Conecte-se à comunidade de pesquisa do MongoDB

• mongosh

• MongoDB Compass

• Um terminal

• Um editor de texto

• dotnet

• AC# projeto

  Para inicializar um projeto, execute o comando dotnet new console no diretório do seu projeto. Para saber mais, consulte Início rápido do C#.

• Um terminal

• Um editor de texto

• Go

• Um projeto Go

  Para inicializar um projeto, use o comando go mod. Para saber mais, consulte Início rápido do Go.

• MongoDB Go driver

  Para baixar e instalar o driver Go e as dependências do driver, execute os seguintes comandos:

  go get go.mongodb.org/mongo-driver/v2/mongo
  go get github.com/joho/godotenv

• Java Development Kit (JDK) versão 8 ou posterior

• As dependências do driver instaladas usando Maven ou Gradle

  Recomendamos o uso de um ambiente de desenvolvimento integrado (IDE), como o IntelliJ IDEA ou Eclipse IDE para configurar as dependências.

  Para configurar Maven ou Gradle para criar e executar seu projeto, consulte Adicionar MongoDB como dependência.

• Um terminal

• Um editor de texto

• npm

• Node.js

Para instalar o node.js driver, execute o seguinte comando em um prompt de terminal:

npm install mongodb --save

• Um terminal

• Um editor de texto

• Python

  Para baixar a versão mais recente do Python para seu sistema operacional, consulte a página de downloads do Python.

• O instalador do pacote pip

  Começando com o Python 2.7.9 e o Python 3.4, os pacotes baixados de https://python.org incluem pip.

  Para instalar o pip manualmente, consulte a página de instalação do pip. Este pacote inclui Python.

mongosh -u <USER-NAME> -p <USER-PASSWORD> --authenticationDatabase "<AUTHENTICATION-DB>" --host <HOST-NAME> --port <PORT-NUMBER>

rs0 [direct: primary] test>

Para saber mais, consulte Conectar-se a uma implementação.

Para saber mais, consulte Conectar ao MongoDB.

O aplicação de amostra a seguir se conecta ao conjunto de réplicas com sua string de conexão e envia um ping para confirmar o sucesso da conexão. Para testar o aplicação de amostra, execute as seguintes etapas:

1. Crie um novo diretório chamado connect e inicialize seu projeto usando o comando dotnet new.

   mkdir connect
   cd connect
   dotnet new console

2. Execute o seguinte comando para adicionar o driver .NET/C# ao seu projeto como uma dependência:

   dotnet add package MongoDB.Driver

3. Defina suas configurações de conexão no arquivo Program.cs.

   Substitua o conteúdo do arquivo Program.cs pelo seguinte código. O código de exemplo faz o seguinte:

   • Conecta-se à sua implantação local.

   • Insere uma coleção denominada movies com um documento no banco de dados do test.

   • Recupera todos os índices de pesquisa da collection.

   1
   using MongoDB.Bson;
   2
   using MongoDB.Driver;
   3
   4
   public class Connect
   5
   {
   6
      // Replace the following with your connection string
   7
      private const string MongoConnectionString = "<CONNECTION-STRING>";
   8
   9
      public static void Main(string[] args)
   10
      {
   11
         // Connect to your replica set
   12
         var client = new MongoClient(MongoConnectionString);
   13
   14
         // Send a ping to confirm a successful connection
   15
         try {
   16
            var result = client.GetDatabase("admin").RunCommand<BsonDocument>(new BsonDocument("ping", 1));
   17
            Console.WriteLine("Successfully connected to Replica Set");
   18
         }
   19
         catch (Exception e) { Console.WriteLine(e);}
   20
   21
         // Insert a document to a collection
   22
         var database = client.GetDatabase("test");
   23
         var collection = database.GetCollection<BsonDocument>("movies");
   24
         var movieDocument = new BsonDocument{{"title", "Back to the Future"}};
   25
         try {
   26
            collection.InsertOne(movieDocument);
   27
            Console.WriteLine("Document inserted successfully.");
   28
         }
   29
         catch (Exception e) {
   30
            Console.WriteLine($"Insertion error: {e.Message}");
   31
         }
   32
   33
         // List search indexes
   34
         try {
   35
            var result = collection.SearchIndexes.List().ToList();
   36
            if (indexes.Count == 0) {
   37
               Console.WriteLine("No indexes found on the collection.");
   38
            }
   39
            else {
   40
               Console.WriteLine("Indexes on the collection:");
   41
               foreach (var index in indexes)
   42
                  {
   43
                     Console.WriteLine(index.ToJson());
   44
                  }
   45
            }
   46
         }
   47
         catch (Exception e) {
   48
            Console.WriteLine($"Error listing indexes: {e.Message}");
   49
         }
   50
      }
   51
   }

4. Substitua o espaço reservado (linha 7) por sua string de conexão e salve o arquivo.

5. Execute seu aplicação.

   dotnet run Program.cs

   OCULTAR SAÍDA

   Successfully connected to MongoDB.
   Document inserted successfully.
   No indexes found on the collection.

   Observação

   Os resultados não contêm índices porque o código de amostra não criou nenhum índice para a collection movies.

Para saber mais, consulte Opções de conexão.

O aplicação de amostra a seguir se conecta ao conjunto de réplicas com sua string de conexão e envia um ping para confirmar o sucesso da conexão. Teste o aplicação de amostra com as seguintes etapas:

1. Crie um novo diretório chamado connect e inicialize seu projeto usando o comando go mod.

   mkdir connect
   cd connect
   go mod init connect

2. Defina suas configurações de conexão em um arquivo .go.

   Em seu projeto, crie um novo arquivo chamado connect.go e cole o código a seguir.

   1
   package main
   2
   3
   import (
   4
      "context"
   5
      "encoding/json"
   6
      "fmt"
   7
      "log"
   8
   9
      "go.mongodb.org/mongo-driver/bson"
   10
      "go.mongodb.org/mongo-driver/mongo"
   11
      "go.mongodb.org/mongo-driver/mongo/options"
   12
      "go.mongodb.org/mongo-driver/mongo/readpref"
   13
   )
   14
   15
   type Movie struct {
   16
      Title string `bson:"title"`
   17
   }
   18
   19
   func main() {
   20
      // Replace with your connection string
   21
      uri := "<CONNECTION-STRING>"
   22
   23
      // Connect to MongoDB
   24
      client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
   25
      if err != nil {
   26
         log.Fatalf("Failed to connect to MongoDB: %v", err)
   27
      }
   28
      defer func() {
   29
         if err = client.Disconnect(context.TODO()); err != nil {
   30
            log.Fatalf("Failed to disconnect MongoDB client: %v", err)
   31
         }
   32
      }()
   33
   34
      // Ping to confirm connection
   35
      if err := client.Ping(context.TODO(), readpref.Primary()); err != nil {
   36
         log.Fatalf("Failed to ping MongoDB: %v", err)
   37
      }
   38
      fmt.Println("Successfully connected to MongoDB")
   39
   40
      // Insert a document to a collection
   41
      coll := client.Database("test").Collection("movies")
   42
      newMovie := Movie{Title: "Back to the Future"}
   43
      result, err := coll.InsertOne(context.TODO(), newMovie)
   44
      if err != nil {
   45
         log.Fatalf("Failed to insert document: %v", err)
   46
      }
   47
      fmt.Printf("Inserted document ID: %v\n", result.InsertedID)
   48
   49
      // List search indexes
   50
      listOpts := options.ListSearchIndexesOptions{}
   51
      ctx := context.TODO()
   52
      cursor, err := coll.SearchIndexes().List(ctx, nil, &listOpts)
   53
      if err != nil {
   54
         log.Fatalf("Failed to list search indexes: %v", err)
   55
      }
   56
   57
      var results []bson.D
   58
      if err = cursor.All(ctx, &results); err != nil {
   59
         log.Fatalf("Failed to iterate over cursor: %v", err)
   60
      }
   61
   62
      res, err := json.Marshal(results)
   63
      if err != nil {
   64
         log.Fatalf("Failed to marshal results to JSON: %v", err)
   65
      }
   66
      fmt.Println("Search indexes found:", string(res))
   67
   }

3. Substitua o espaço reservado (linha 15) por sua string de conexão e salve o arquivo.

4. Execute seu aplicação.

   go run connect.go

   OCULTAR SAÍDA

   Successfully connected to MongoDB
   Inserted document ID: ObjectID("67e42df345bc0b636fe340f0")
   Search indexes found: null

   Observação

   Os resultados não contêm índices porque o código de amostra não criou nenhum índice para a collection movies.

Para saber mais, consulte Conexões.

O seguinte aplicação de amostra conecta ao seu conjunto de réplicas com sua string de conexão. Para testar o aplicação de amostra, execute as seguintes etapas:

1. Defina suas configurações de conexão em um arquivo de classe Java .

   Copie o seguinte código para um arquivo denominado Connect.java.

   1
   import com.mongodb.ConnectionString;
   2
   import com.mongodb.MongoClientSettings;
   3
   import com.mongodb.MongoException;
   4
   import com.mongodb.ServerApi;
   5
   import com.mongodb.ServerApiVersion;
   6
   import com.mongodb.client.MongoClient;
   7
   import com.mongodb.client.MongoClients;
   8
   import com.mongodb.client.MongoCollection;
   9
   import com.mongodb.client.MongoCursor;
   10
   import com.mongodb.client.MongoDatabase;
   11
   import org.bson.BsonDocument;
   12
   import org.bson.BsonInt64;
   13
   import org.bson.Document;
   14
   import org.bson.conversions.Bson;
   15
   16
   public class Connect {
   17
      public static void main(String[] args) {
   18
         // Replace the placeholder with your Replica Set connection string
   19
         String uri = "<CONNECTION-STRING>";
   20
   21
         // Construct a ServerApi instance using the ServerApi.builder() method
   22
         ServerApi serverApi = ServerApi.builder()
   23
                  .version(ServerApiVersion.V1)
   24
                  .build();
   25
   26
         MongoClientSettings settings = MongoClientSettings.builder()
   27
                  .applyConnectionString(new ConnectionString(uri))
   28
                  .serverApi(serverApi)
   29
                  .build();
   30
   31
         // Create a new client and connect to the server
   32
         try (MongoClient mongoClient = MongoClients.create(settings)) {
   33
               MongoDatabase adminDatabase = mongoClient.getDatabase("admin");
   34
               try {
   35
                  // Send a ping to confirm a successful connection
   36
                  Bson command = new BsonDocument("ping", new BsonInt64(1));
   37
                  adminDatabase.runCommand(command);
   38
                  System.out.println("Successfully connected to Replica Set");
   39
               } catch (MongoException e) {
   40
                  System.err.println("Ping failed: " + e);
   41
               }
   42
   43
               // Insert a document into a collection
   44
               MongoDatabase database = mongoClient.getDatabase("test");
   45
               MongoCollection<Document> collection = database.getCollection("movies");
   46
               Document movieDocument = new Document("title", "Back to the Future");
   47
               try {
   48
                  collection.insertOne(movieDocument);
   49
                  System.out.println("Document inserted successfully.");
   50
               } catch (MongoException e) {
   51
                  System.err.println("Insertion failed: " + e);
   52
               }
   53
   54
               // List search indexes
   55
               try (MongoCursor<Document> resultsCursor = collection.listSearchIndexes().iterator()) {
   56
                  System.out.println("Search indexes found:");
   57
                  while (resultsCursor.hasNext()) {
   58
                     System.out.println(resultsCursor.next().toJson());
   59
                  }
   60
               } catch (MongoException e) {
   61
                  System.err.println("Error listing indexes: " + e);
   62
               }
   63
         } catch (MongoException e) {
   64
               System.err.println("Failed to create MongoClient: " + e);
   65
         }
   66
      }
   67
   }

2. Substitua o espaço reservado (linha 14) por sua string de conexão e salve o arquivo.

3. Compile e execute o arquivo Connect.java usando um IDE ou os seguintes comandos:

   javac Connect.java
   java Connect

   OCULTAR SAÍDA

   Successfully connected to Replica Set
   Document inserted successfully.
   Search indexes found:

   Observação

   Os resultados não contêm índices porque o código de amostra não criou nenhum índice para a collection movies.

Para saber mais, consulte Conectar ao MongoDB.

O seguinte aplicação de amostra conecta ao seu conjunto de réplicas com sua string de conexão e retorna uma mensagem de confirmação. Para testar o aplicação de amostra, execute as seguintes etapas:

1. Defina suas configurações de conexão em um arquivo .js.

   Copie o seguinte código para um arquivo denominado connect.js.

   1
   const { MongoClient } = require("mongodb");
   2
   3
   const url = "<CONNECTION-STRING>";
   4
   5
   // Connect to your  Replica Set
   6
   const client = new MongoClient(url);
   7
   8
   async function run() {
   9
      try {
   10
      await client.connect();
   11
      console.log("Successfully connected to Replica Set");
   12
   13
      // Insert a document in a collection
   14
      const database = client.db("test");
   15
      const coll = database.collection("movies");
   16
      const doc = { title: "Back to the Future" };
   17
      const insertResult = await coll.insertOne(doc);
   18
      console.log(`Document inserted with _id: ${insertResult.insertedId}`);
   19
   20
      // List search indexes for the collection
   21
      const searchIndexesResult = await coll.listSearchIndexes().toArray();
   22
      console.log("Search indexes:", searchIndexesResult);
   23
      } catch (err) {
   24
      console.log("Error occurred:", err.stack);
   25
      } finally {
   26
      await client.close();
   27
      }
   28
   }
   29
   30
   run().catch(console.dir);

2. Substitua o espaço reservado (linha 4) por sua string de conexão e salve o arquivo.

3. Execute o aplicação de amostra usando o seguinte comando:

   node connect.js

   OCULTAR SAÍDA

   Successfully connected to Replica Set
   Document inserted with _id: 67e432123504d5a7ed2156eb
   Search indexes: []

   Observação

   Os resultados não contêm índices porque o código de amostra não criou nenhum índice para a collection movies.

Para saber mais, consulte Conexão.

1. Importar MongoClient do PyMongo.

   Para se conectar a uma instância do MongoDB em execução, o PyMongo requer MongoClient. No shell do Python em execução no seu terminal, execute o seguinte comando para importar MongoClient:

   from pymongo import MongoClient

2. Defina suas configurações de conexão em um arquivo .py.

   Copie o seguinte código para um arquivo denominado connect.py.

   1
   from pymongo import MongoClient, errors
   2
   3
   # Replace '<connection-string>' with your actual MongoDB connection string
   4
   connection_string = '<CONNECTION-STRING>'
   5
   6
   # Connect to MongoDB
   7
   try:
   8
      client = MongoClient(connection_string)
   9
      print("Successfully connected to MongoDB.")
   10
   except errors.ConnectionError as e:
   11
      print("Failed to connect to MongoDB:", e)
   12
      exit()
   13
   14
   # Access the database and collection
   15
   database = client["test"]
   16
   collection = database["movies"]
   17
   18
   # Insert a document into the collection
   19
   try:
   20
      result = collection.insert_one({"title": "Back to the Future"})
   21
      print(f"Document inserted with _id: {result.inserted_id}")
   22
   except Exception as e:
   23
      print("Failed to insert document:", e)
   24
   25
   # List search indexes for the collection (ensure method exists)
   26
   try:
   27
      cursor = collection.list_search_indexes()
   28
      indexes = list(cursor)  # Convert cursor to list for ease
   29
      if indexes:
   30
         print("Search indexes found:")
   31
         for index in indexes:
   32
               print(index)
   33
      else:
   34
         print("No search indexes found.")
   35
   except Exception as e:
   36
      print("Failed to list search indexes:", e)
   37
   38
   # Close the client connection (Optionally used here for resource management)
   39
   client.close()

3. Substitua o espaço reservado (linha 4) por sua string de conexão e salve o arquivo.

4. Execute o aplicação de amostra usando o seguinte comando.

   python connect.py

   OCULTAR SAÍDA

   Successfully connected to MongoDB.
   Document inserted with _id: 67e43400bd92a83c1a81cbb4
   No search indexes found.

   Observação

   Os resultados não contêm índices porque o código de amostra não criou nenhum índice para a collection movies.

Para saber mais, consulte Conectar ao MongoDB.