All Products
Search
Document Center

:Connect to a sharded cluster instance by using program code

Last Updated:Jan 15, 2025

ApsaraDB for MongoDB is fully compatible with the MongoDB protocol. This topic describes the sample code used to connect to a sharded cluster instance in different languages.

Prerequisites

Note

To connect to sharded cluster instances, you do not need to specify the replicaSet-related parameters in the following 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

For more information about the Java driver for MongoDB, see the official documentation or download the package of the driver from the following links:

  1. Obtain the information required to connect to an ApsaraDB for MongoDB 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

      package mongodb;
      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 shardingConnectTest {
          public static ServerAddress seed1 = new ServerAddress("11.238.XX.XX",
                  3717);
          public static ServerAddress seed2 = new ServerAddress("11.238.XX.XX",
                  3717);
          public static String username = "autotest";
          public static String password = "autotest";
      //    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 are sufficient in most scenarios.
              MongoClientOptions options = MongoClientOptions.builder().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);
              return new MongoClient(connectionString);
          }
          public static void main(String args[]) {
              MongoClient client = createMongoDBClientWithURI();
              try {
                  // Obtain the collection handle.
                  MongoDatabase database = client.getDatabase(DEMO_DB);
                  MongoCollection<Document> collection = database.getCollection(DEMO_COLL);
                  // Insert data to the table.
                  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 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

How do I troubleshoot an error when I connect to an instance by using the program code?

You can troubleshoot an error from the following aspects when you connect to an instance by using the program code:

  • Network connectivity. You can use the mongo shell to connect to the instance for the network connectivity testing. For more information, see Connect to a sharded cluster instance by using the mongo shell.

  • Code issues. After you ensure a smooth connection, you can check whether issues occur in your code and runtime environment configuration.