connect to a MongoDB standalone instance by using program code-阿里云帮助中心

ApsaraDB for MongoDB is fully compatible with the MongoDB protocol. This topic describes how to connect to a standalone instance using code in different languages.

Prerequisites

You can obtain the connection address of the ApsaraDB for MongoDB replica set instance. For more information, see Connect to a replica set instance.
Download and install the official driver for your programming language. For more information, see MongoDB Drivers.

Node.js connection example

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

Run the following command on the client to initialize the project.
```
mkdir node-mongodb-demo
cd node-mongodb-demo
npm init
```
Run the following command to install the driver and tool packages.
```
npm install mongodb node-uuid sprintf-js
```
Obtain the connection information of the ApsaraDB for MongoDB standalone instance.

Sample Node.js 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;
// The database account is node-test.
const username = "node-test";
const password = "*********";
const replSetName = "mgset-*********";
const demoDb = "test";
const demoColl = "testColl";
// Use the replica set endpoint to ensure high availability.
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);
// Get the MongoClient.
async function run() {
    try {
        // Connect to the instance.
        await client.connect();
        // Get the database handle.
        const database = client.db(demoDb);
        // Get 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 connection example

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

Install the driver and tool packages.

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

Obtain the connection information of the ApsaraDB for MongoDB standalone instance.

Sample PHP code.

<?php
require 'vendor/autoload.php'; // include Composer goodies
# Instance information.
$demo_seed1 = '**********.mongodb.test.aliyun-inc.com:3717';
$demo_seed2 = '**********.mongodb.test.aliyun-inc.com:3717';
$demo_replname = "mgset-**********";
# The database account is 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 connection example

Related links:

The official Quick Start document.
Download the JAR package.

Obtain the connection information of the ApsaraDB for MongoDB standalone instance.

Sample Java code.

Maven configuration.

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

Java code.

Note

The following code provides an example on how to manually configure a connection to an ApsaraDB for MongoDB instance. If you use this configuration in a Spring Boot project, we recommend that you add @SpringBootApplication(exclude = {MongoAutoConfiguration.class, MongoDataAutoConfiguration,class}) to disable automatic configuration. This prevents a connection failure due to configuration conflicts.

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() {
                // Build the seed list.
                List<ServerAddress> seedList = new ArrayList<ServerAddress>();
                seedList.add(seed1);
                seedList.add(seed2);
                // Build the authentication information.
                List<MongoCredential> credentials = new ArrayList<MongoCredential>();
                credentials.add(MongoCredential.createScramSha1Credential(username, DEFAULT_DB,
                                password.toCharArray()));
                // Build the operation options. Configure options other than the requiredReplicaSetName property as needed. The default parameters are suitable for most scenarios.
                MongoClientOptions options = MongoClientOptions.builder().requiredReplicaSetName(ReplSetName)
                                .socketTimeout(2000).connectionsPerHost(1).build();
                return new MongoClient(seedList, credentials, options);
        }
         public static MongoClient createMongoDBClientWithURI() {
                // You can also initialize the connection using a URI.
                // 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 {
                        // Get 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 connection example

For more information, see pymongo.

Install pymongo.
```
pip3 install pymongo
```
Obtain the connection information of the ApsaraDB for MongoDB standalone instance.

Sample Python code.

import sys
from pymongo import MongoClient
uri = 'mongodb://%s:%s@dds-bp18365e467ea5c4****.mongodb.rds.aliyuncs.com:3717/admin'
# The database account is python-test and the authentication database is 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# connection example

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

Run the following command on the client to install the driver package.
```
Install-Package mongocsharpdriver
```
Obtain the connection information of the ApsaraDB for MongoDB standalone instance.

Sample C# code.

using MongoDB.Driver;
using System;
using System.Collections.Generic;

namespace Aliyun
{
    class Program
    {
        static void Main(string[] args)
        {
            // Mongo 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";
            // The database account is 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;
                // Set the replica set 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 the user data.
                collection.Insert(user);
                // Get 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 connection example

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

Install the following driver package.
```
go get go.mongodb.org/mongo-driver
```
Obtain the connection information of the ApsaraDB for MongoDB standalone instance.

Sample Go 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.
    // The database account is go-test and the authentication database is 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)
    }
}

FAQ

How do I troubleshoot connection errors?

If a connection error occurs, check the following items:

Network connectivity. Use the mongo shell to connect to the instance and test the network connectivity. For more information, see Connect to a standalone instance using the mongo shell.
Code issues. After you confirm the network connectivity, check your code and environment configuration for issues.