:Connect to a sharded cluster instance by using program code

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 information required to connect to an ApsaraDB for MongoDB 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;
   const username = "root";
   const password = "*********";
   // const replSetName = "mgset-*********";
   const demoDb = "test";
   const demoColl = "testColl";
   // We recommend that you use the endpoints of a sharded cluster instance to ensure high availability. 
   const url = sprintf("mongodb://%s:%s@%s:%d,%s:%d/admin",
           username, password, host1, port1, host2, port2);
   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 information required to connect to an ApsaraDB for MongoDB 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-**********";
   $demo_user = 'root';
   $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;
   $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

Python

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

1. Install PyMongo.

   pip3 install pymongo

2. Obtain the information required to connect to an ApsaraDB for MongoDB 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'
   username = 'root'
   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 information required to connect to an ApsaraDB for MongoDB 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";
               const string userName = "root";
               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;
                   // Enter a name for the instance. 
                   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. Run the following command to install the driver package:

   go get go.mongodb.org/mongo-driver

2. Obtain the information required to connect to an ApsaraDB for MongoDB 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"
       "go.mongodb.org/mongo-driver/mongo/readpref"
       "go.mongodb.org/mongo-driver/mongo/writeconcern"
       "log"
   )
   
   func main() {
       // Create a Client to a MongoDB server and use Ping to verify that the
       // server is running.
   
       clientOpts := options.Client().ApplyURI("mongodb://root:****@s-bp1*******.mongodb.rds.aliyuncs.com:3717,s-bp2*******.mongodb.rds.aliyuncs.com:3717/admin")
       clientOpts.SetReadPreference(readpref.PrimaryPreferred())
       clientOpts.SetWriteConcern(writeconcern.New(writeconcern.WMajority(), writeconcern.J(true), writeconcern.WTimeout(1000)))
       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 inheritied 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.InsertMany(context.Background(), []interface{}{bson.M{"shardkey": 0}, bson.M{"shardkey": 1}, bson.M{"shardkey": 2}})
               if err != nil {
                   fmt.Println("insert result failed!")
                   log.Fatal(err)
                   return nil, err
               }
               id := res.InsertedIDs
               fmt.Println("Ids: ", id)
               fmt.Printf("insert result: %v\n", res)
   
               result := bson.M{}
               filter := bson.D{{"shardkey", 0}}
               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)
       }
   }

FAQ