Connect to a standalone instance by using program code

Prerequisites

• The connection strings of the instance are obtained. For more information, see Connect to an instance.

• Download and install the official driver package of your language. For more information, see Start Developing with MongoDB.

Node.js

For more information about the Node.js driver for MongoDB, see MongoDB Node.js Driver.

1. Run the following command on the client to initialize a project:

   mkdir node-mongodb-demo
   cd node-mongodb-demo
   npm init

2. Run the following command to install the driver package and toolkit:

   npm install mongodb node-uuid sprintf-js

3. Obtain the connection information of the standalone instance.

4. Use the following Node.js sample code:

   const sprintf = require("sprintf-js").sprintf;
   const MongoClient = require('mongodb').MongoClient;
   const host1 = "dds-**********.mongodb.rds.aliyuncs.com";
   const port1 = 3717;
   const host2 = "dds-**********.mongodb.rds.aliyuncs.com";
   const port2 = 3717;
   // Set the database account to node-test.
   const username = "node-test";
   const password = "*********";
   const replSetName = "mgset-*********";
   const demoDb = "test";
   const demoColl = "testColl";
    
   const url = sprintf("mongodb://%s:%s@%s:%d,%s:%d/admin?replicaSet=%s",
           username, password, host1, port1, host2, port2, replSetName);
   console.info("url:", url);
   const client = new MongoClient(url);
   // Obtain the MongoClient. 
   async function run() {
       try {
           // Connect to the standalone instance. 
           await client.connect();
           // Obtain the database handle. 
           const database = client.db(demoDb);
           // Obtain the collection handle. 
           const collection = database.collection(demoColl);
           const demoName = "Node For Demo";
           const doc = { "DEMO": demoName, "MESG": "Hello AliCoudDB For MongoDB" };
           console.info("ready insert document: ", doc);
           // Insert data. 
           const result = await collection.insertOne(doc);
           console.log(
               `A document was inserted with the _id: ${result.insertedId}`,
           );
           // Read data. 
           const filter = { "DEMO": demoName };
           const findResult = await collection.find(filter);
           await findResult.forEach(console.dir);
         } finally {
             // Close the connection. 
             await client.close();
         }
   }
   run().catch(console.dir);

PHP

For more information about the PHP driver for MongoDB, see MongoDB PHP Driver.

1. Install the driver package and toolkit.

   $ pecl install mongodb
   $ echo "extension=mongodb.so" >> `php --ini | grep "Loaded Configuration" | sed -e "s|.*:\s*||"`
   $ composer require "mongodb/mongodb=^1.0.0"

2. Obtain the connection information of the standalone instance.

3. Use the following PHP sample code:

   <?php
   require 'vendor/autoload.php'; // include Composer goodies
   # Specify the instance information. 
   $demo_seed1 = '**********.mongodb.test.aliyun-inc.com:3717';
   $demo_seed2 = '**********.mongodb.test.aliyun-inc.com:3717';
   $demo_replname = "mgset-**********";
   # Set the database account to php-test.
   $demo_user = 'php-test';
   $demo_password = '**********';
   $demo_db = 'admin';
   # Construct the MongoDB connection string based on the instance information. 
   # mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
   $demo_uri = 'mongodb://' . $demo_user . ':' . $demo_password . '@' .
       $demo_seed1 . ',' . $demo_seed2 . '/' . $demo_db . '?replicaSet=' . $demo_replname;
   $client = new MongoDB\Client($demo_uri);
   $collection = $client->testDb->testColl;
   $result = $collection->insertOne(['name' => 'ApsaraDB for Mongodb', 'desc' => 'Hello, Mongodb']);
   echo "Inserted with Object ID '{$result->getInsertedId()}'", "\n";
   $result = $collection->find(['name' => 'ApsaraDB for Mongodb']);
   foreach ($result as $entry) {
       echo $entry->_id, ': ', $entry->name, "\n";
   }
   ?>

Java

1. Obtain the connection information of the standalone instance.

2. Use the following Java sample code.

   • Maven configurations

     <dependencies>
         <dependency>
             <groupId>org.mongodb</groupId>
             <artifactId>mongo-java-driver</artifactId>
             <version>3.12.10</version>
         </dependency>
     </dependencies>

   • Java demo code

     import java.util.ArrayList;
     import java.util.List;
     import java.util.UUID;
     import org.bson.BsonDocument;
     import org.bson.BsonString;
     import org.bson.Document;
     import com.mongodb.MongoClient;
     import com.mongodb.MongoClientOptions;
     import com.mongodb.MongoClientURI;
     import com.mongodb.MongoCredential;
     import com.mongodb.ServerAddress;
     import com.mongodb.client.MongoCollection;
     import com.mongodb.client.MongoCursor;
     import com.mongodb.client.MongoDatabase;
      public class Main {
             public static ServerAddress seed1 = new ServerAddress("**********.mongodb.tbc3.newtest.rdstest.aliyun-inc.com",
                             27017);
             public static ServerAddress seed2 = new ServerAddress("**********.mongodb.tbc3.newtest.rdstest.aliyun-inc.com",
                             27017);
             public static String username = "demouser";
             public static String password = "**********";
             public static String ReplSetName = "mgset-**********";
             public static String DEFAULT_DB = "admin";
             public static String DEMO_DB = "test";
             public static String DEMO_COLL = "testColl";
              public static MongoClient createMongoDBClient() {
                     // Construct a seed list. 
                     List<ServerAddress> seedList = new ArrayList<ServerAddress>();
                     seedList.add(seed1);
                     seedList.add(seed2);
                     // Construct authentication information. 
                     List<MongoCredential> credentials = new ArrayList<MongoCredential>();
                     credentials.add(MongoCredential.createScramSha1Credential(username, DEFAULT_DB,
                                     password.toCharArray()));
                     // Construct operation options. Configure options other than requiredReplicaSetName based on your actual requirements. The default parameter settings can meet the requirements of most scenarios. 
                     MongoClientOptions options = MongoClientOptions.builder().requiredReplicaSetName(ReplSetName)
                                     .socketTimeout(2000).connectionsPerHost(1).build();
                     return new MongoClient(seedList, credentials, options);
             }
              public static MongoClient createMongoDBClientWithURI() {
                     // Use a URI to initialize the MongoClient. 
                     // mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
                     MongoClientURI connectionString = new MongoClientURI("mongodb://" + username + ":" + password + "@"
                                     + seed1 + "," + seed2 + "/" + DEFAULT_DB + "?replicaSet=" + ReplSetName);
                     return new MongoClient(connectionString);
             }
              public static void main(String args[]) {
                     MongoClient client = createMongoDBClient();
                     // or
                     // MongoClient client = createMongoDBClientWithURI();
                     try {
                             // Obtain the collection handle. 
                             MongoDatabase database = client.getDatabase(DEMO_DB);
                             MongoCollection<Document> collection = database.getCollection(DEMO_COLL);
                             // Insert data. 
                             Document doc = new Document();
                             String demoname = "JAVA:" + UUID.randomUUID();
                             doc.append("DEMO", demoname);
                             doc.append("MESG", "Hello AliCoudDB For MongoDB");
                             collection.insertOne(doc);
                             System.out.println("insert document: " + doc);
                             // Read data. 
                             BsonDocument filter = new BsonDocument();
                             filter.append("DEMO", new BsonString(demoname));
                             MongoCursor<Document> cursor = collection.find(filter).iterator();
                             while (cursor.hasNext()) {
                                     System.out.println("find document: " + cursor.next());
                             }
                     } finally {
                             // Close the client and release resources. 
                             client.close();
                     }
                     return;
             }
     }

Python

For more information about the Python driver for MongoDB, see API Documentation.

1. Install PyMongo.

   pip3 install pymongo

2. Obtain the connection information of the standalone instance.

3. Use the following Python sample code:

   import sys
   from pymongo import MongoClient
   uri = 'mongodb://%s:%s@dds-bp18365e467ea5c4****.mongodb.rds.aliyuncs.com:3717/admin'
   # Set the database account to python-test and the authentication database to admin.
   username = 'python-test'
   password = 'MongoDB****'
   client = MongoClient(uri % (username, password))
   ret = client.admin.command('ping')['ok']
   if ret:
       print('ping successfully!')
   else:
       print('ping failed!')
       sys.exit(1)
   
   db = client['baz']
   coll = db['quz']
   uuid = coll.insert_one({'hello': 'world'}).inserted_id
   print('Id: %s' % uuid)
   ret = coll.find_one({"_id": uuid})
   print(ret)

C#

For more information about the C# driver for MongoDB, see MongoDB C# Driver.

1. Run the following command to install the driver package:

   Install-Package mongocsharpdriver

2. Obtain the connection information of the standalone instance.

3. Use the following C# sample code:

   using MongoDB.Driver;
   using System;
   using System.Collections.Generic;
   
   namespace Aliyun
   {
       class Program
       {
           static void Main(string[] args)
           {
               // Specify the instance information. 
               const string host1 = "dds-t4n**************.mongodb.singapore.rds.aliyuncs.com";
               const int port1 = 3717;
               const string host2 = "dds-t4n**************.mongodb.singapore.rds.aliyuncs.com";
               const int port2 = 3717;
               const string replicaSetName = "mgset-300******";
               const string admin = "admin";
               // Set the database account to c-test. 
               const string userName = "c-test";
               const string passwd = "********";
   
               try
               {
                   Console.WriteLine("connecting...")
                   MongoClientSettings settings = new MongoClientSettings();
                   List<MongoServerAddress> servers = new List<MongoServerAddress>();
                   servers.Add(new MongoServerAddress(host1, port1));
                   servers.Add(new MongoServerAddress(host2, port2));
                   settings.Servers = servers;
                   // Specify the instance name. 
                   settings.ReplicaSetName = replicaSetName;
                   // Set the timeout period to 3 seconds. 
                   settings.ConnectTimeout = new TimeSpan(0, 0, 0, 3, 0);
                   MongoCredential credentials = MongoCredential.CreateCredential(admin, userName, passwd);
                   settings.Credential = credentials;
                   MongoClient client = new MongoClient(settings);
                   var server = client.GetServer();
                   MongoDatabase database = server.GetDatabase("test");
                   var collection = database.GetCollection<User>("test_collection");
                   User user = new User();
                   user.id = "1";
                   user.name = "mongo_test";
                   user.sex = "female";
                   // Insert data user. 
                   collection.Insert(user);
                   // Obtain a data entry. 
                   User result = collection.FindOne();
                   Console.WriteLine("id:" + result.id + " name:" + result.name + " sex:"+result.sex);
                   Console.WriteLine("connection successful...");
               }
               catch (Exception e)
               {
                   Console.WriteLine("connection failed:"+e.Message);
   
               }
           }
       }
       class User
       {
           public string id { set; get; }
           public string name { set; get; }
           public string sex { set; get; }
   
       }
   }

Go

For more information about the Go Driver for MongoDB, see MongoDB Go Driver.

1. Install the following driver package:

   go get go.mongodb.org/mongo-driver

2. Obtain the connection information of the standalone instance.

3. Use the following Go sample code:

   package main
   
   import (
       "context"
       "fmt"
       "go.mongodb.org/mongo-driver/bson"
       "go.mongodb.org/mongo-driver/mongo"
       "go.mongodb.org/mongo-driver/mongo/options"
       "go.mongodb.org/mongo-driver/mongo/readconcern"
       "log"
   )
   
   func main() {
       // Create a Client to a MongoDB server and use Ping to verify that the
       // server is running.
       // Set the database account to go-test and the authentication database to admin.
       clientOpts := options.Client().ApplyURI("mongodb://go-test:****@dds-bp1*******.mongodb.rds.aliyuncs.com:3717/admin")
       client, err := mongo.Connect(context.TODO(), clientOpts)
       if err != nil {
           fmt.Println("connect failed!")
           log.Fatal(err)
           return
       }
       fmt.Println("connect successful!")
   
       defer func() {
           if err = client.Disconnect(context.TODO()); err != nil {
               fmt.Println("disconnect failed!")
               log.Fatal(err)
           }
           fmt.Println("disconnect successful!")
       }()
   
       // Call Ping to verify that the deployment is up and the Client was
       // configured successfully. As mentioned in the Ping documentation, this
       // reduces application resiliency as the server may be temporarily
       // unavailable when Ping is called.
       if err = client.Ping(context.TODO(), nil); err != nil {
           fmt.Println("ping failed!")
           log.Fatal(err)
           return
       }
       fmt.Println("ping successful!")
   
       // Specify the DefaultReadConcern option so any transactions started through
       // the session will have read concern majority.
       // The DefaultReadPreference and DefaultWriteConcern options aren't
       // specified so they will be inherited from client and be set to primary
       // and majority, respectively.
       opts := options.Session().SetDefaultReadConcern(readconcern.Majority())
       sess, err := client.StartSession(opts)
       if err != nil {
           fmt.Println("start session failed!")
           log.Fatal(err)
           return
       }
       defer func() {
           sess.EndSession(context.TODO())
           fmt.Println("end session!")
       }()
       fmt.Println("start session successful!")
   
       txnOpts := options.Transaction()
       result, err := sess.WithTransaction(
           context.TODO(),
           func(sessCtx mongo.SessionContext) (interface{}, error) {
               collection := client.Database("baz").Collection("qux")
               res, err := collection.InsertOne(context.Background(), bson.M{"hello": "world"})
               if err != nil {
                   fmt.Println("insert result failed!")
                   log.Fatal(err)
                   return nil, err
               }
               id := res.InsertedID
               fmt.Println("Id: ", id)
               fmt.Printf("insert result: %v\n", res)
   
               result := bson.M{}
               filter := bson.D{{"_id", res.InsertedID}}
               if err := collection.FindOne(context.Background(), filter).Decode(&result); err != nil {
                   fmt.Println("find failed!")
                   log.Fatal(err)
                   return nil, err
               }
               return result, err
           },
           txnOpts)
       if err == nil {
           fmt.Printf("result: %v\n", result)
       }
   }