tencent cloud

TencentDB for MongoDB

DocumentationTencentDB for MongoDBDevelopment SpecificationsConnection and Security SpecificationsConfiguring SDK Connections

Configuring SDK Connections

Download
Focus Mode
Font Size
Last updated: 2026-06-15 18:51:12
Proper SDK connection configuration is fundamental to ensuring stable operation of the MongoDB service. The parameters in the connection string directly determine the authentication method, failover behavior, connection pool efficiency, and read/write reliability. Missing or incorrect configuration of any of these items can lead to connection failure, performance degradation, or data consistency issues in a production environment. This document provides connection configuration examples for four mainstream SDKs: Python, Java, Node.js, and Go. All examples come pre-configured with production-recommended settings, including connection pooling, timeouts, retries, write concern (w=majority), and read preference (secondaryPreferred). They can be used directly in production or have their parameter values adjusted based on actual business needs. Replace the username, password, and address in the connection string with your actual instance information (which can be obtained from the Tencent Cloud console > MongoDB > Instance Details page).

Python(pymongo)

Within the Python ecosystem, `pymongo` is the officially maintained MongoDB driver library. It provides a synchronous connection mode, making it suitable for scenarios such as Web backends (such as Flask and Django) and data processing scripts. The following example shows the complete configuration for four connection methods, including production-recommended parameters such as connection pooling, timeouts, retries, and read/write policies. The connection pool in `pymongo` is automatically managed internally by the driver. The number of connections is controlled via `maxPoolSize` and `minPoolSize`, eliminating the need for manual creation or release of connections.
from pymongo import MongoClient
from pymongo.read_preferences import ReadPreference

# Sharded Cluster: SRV Connection (Automatically Discovers Mongos, No Connection String Modification Required for Scaling)
client = MongoClient(
    "mongodb+srv://mongouser:password@xxx.tencentcdb.com/admin",
    authSource="admin",
    
    # Connection Pool Configuration
    maxPoolSize=150,
    minPoolSize=10,
    maxIdleTimeMS=120000,
    waitQueueTimeoutMS=5000,
    
    # Timeout Configuration
    connectTimeoutMS=10000,
    serverSelectionTimeoutMS=5000,
    
    # Reliability Configuration
    retryWrites=True,
    retryReads=True,
    w="majority",
    
    # Read Preference
    readPreference=ReadPreference.SECONDARY_PREFERRED
)

# Replica Set: Use the Console Default Connection String (Contains All Node Addresses)
client = MongoClient(
    "mongodb://mongouser:password@10.0.0.100:27017,10.0.0.101:27017,10.0.0.102:27017/admin",
    authSource="admin",
    replicaSet="cmgo-xxxxxxxx",
    maxPoolSize=150,
    retryWrites=True,
    w="majority",
    readPreference=ReadPreference.SECONDARY_PREFERRED
)

# Sharded Cluster: LB Address Connection (Default Method, Applicable to the Vast Majority of Scenarios)
client = MongoClient(
    "mongodb://mongouser:password@10.0.0.100:27017/admin",
    authSource="admin",
    maxPoolSize=150,
    retryWrites=True,
    w="majority",
    readPreference=ReadPreference.SECONDARY_PREFERRED
)

# Sharded Cluster: Connect to All Mongos (Requires Enabling Mongos Access Addresses First)
client = MongoClient(
    "mongodb://mongouser:password@10.0.0.100:27017,10.0.0.100:27018,10.0.0.100:27019/admin",
    authSource="admin",
    maxPoolSize=150,
    retryWrites=True,
    w="majority",
    readPreference=ReadPreference.SECONDARY_PREFERRED
)

# Connection Health Check
def check_connection():
    try:
        client.admin.command('ping')
        print("MongoDB connection is normal")
        return True
    except Exception as e:
        print(f"MongoDB connection failure: {e}")
        return False

Java(MongoDB Driver)

In the Java ecosystem, mongodb-driver-sync is the official synchronous driver provided by MongoDB and is widely used in enterprise-level projects such as Spring Boot and microservices. The Java driver configures connection parameters using the MongoClientSettings builder pattern, centrally managing configurations such as connection pooling, timeouts, write concern, and read preference. The following example encapsulates four connection methods as independent functions, sharing the same set of MongoClientSettings configurations to facilitate switching between different architectures. The connection pool is maintained internally by the driver. Applications only need to call the corresponding function to obtain a MongoClient instance, eliminating the need for manual connection lifecycle management.
import com.mongodb.ConnectionString;
import com.mongodb.MongoClientSettings;
import com.mongodb.ReadPreference;
import com.mongodb.WriteConcern;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import java.util.concurrent.TimeUnit;

public class MongoDBConfig {
    
    // Sharded Cluster: SRV Connection
    public static MongoClient createClientWithSRV() {
        String uri = "mongodb+srv://mongouser:password@xxx.tencentcdb.com/admin"
                   + "?authSource=admin";
        return createClientFromUri(uri);
    }
    
    // Replica Set: Console Default Connection String (Contains All Node Addresses)
    public static MongoClient createClientWithReplicaSet() {
        String uri = "mongodb://mongouser:password"
                   + "@10.0.0.100:27017,10.0.0.101:27017,10.0.0.102:27017/admin"
                   + "?authSource=admin&replicaSet=cmgo-xxxxxxxx";
        return createClientFromUri(uri);
    }
    
    // Sharded Cluster: LB Address Connection (Applicable to the Vast Majority of Scenarios)
    public static MongoClient createClientWithLB() {
        String uri = "mongodb://mongouser:password@10.0.0.100:27017/admin"
                   + "?authSource=admin";
        return createClientFromUri(uri);
    }
    
    // Sharded Cluster: Connect to All Mongos
    public static MongoClient createClientWithAllMongos() {
        String uri = "mongodb://mongouser:password"
                   + "@10.0.0.100:27017,10.0.0.100:27018,10.0.0.100:27019/admin"
                   + "?authSource=admin";
        return createClientFromUri(uri);
    }

    private static MongoClient createClientFromUri(String uri) {
        MongoClientSettings settings = MongoClientSettings.builder()
            .applyConnectionString(new ConnectionString(uri))
            
            // Connection Pool Configuration
            .applyToConnectionPoolSettings(builder -> builder
                .maxSize(150)
                .minSize(10)
                .maxConnectionIdleTime(120, TimeUnit.SECONDS)
                .maxWaitTime(5, TimeUnit.SECONDS))
            
            // Timeout Configuration
            .applyToSocketSettings(builder -> builder
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS))
            
            .applyToClusterSettings(builder -> builder
                .serverSelectionTimeout(5, TimeUnit.SECONDS))
            
            // Reliability Configuration
            .retryWrites(true)
            .retryReads(true)
            .writeConcern(WriteConcern.MAJORITY)
            .readPreference(ReadPreference.secondaryPreferred())
            
            .build();
        
        return MongoClients.create(settings);
    }
}

Node.js(MongoDB Driver)

In the Node.js ecosystem, mongodb is the official driver package. It is based on an asynchronous I/O model and is suitable for scenarios such as high-concurrency Web services (such as Express, Koa, and NestJS) and Serverless functions. The following example extracts common parameters such as connection pooling, timeouts, retries, and read/write policies into a commonOptions object. The four connection methods share the same set of configurations, and switching connection methods only requires modifying the URI. The connection pool of the Node.js driver is also automatically managed by the driver. After each call to client.connect(), connections from the pool can be reused, eliminating the need to manually create or close individual connections.
const { MongoClient, ReadPreference } = require('mongodb');

// General Connection Configuration
const commonOptions = {
    maxPoolSize: 150,
    minPoolSize: 10,
    maxIdleTimeMS: 120000,
    waitQueueTimeoutMS: 5000,
    connectTimeoutMS: 10000,
    serverSelectionTimeoutMS: 5000,
    retryWrites: true,
    retryReads: true,
    w: 'majority',
    readPreference: ReadPreference.SECONDARY_PREFERRED
};

// Sharded Cluster: SRV Connection
async function connectWithSRV() {
    const uri = "mongodb+srv://mongouser:password@xxx.tencentcdb.com/admin?authSource=admin";
    const client = new MongoClient(uri, commonOptions);
    await client.connect();
    await client.db('admin').command({ ping: 1 });
    console.log('SRV connection successful');
    return client;
}

// Replica Set: Console Default Connection String
async function connectReplicaSet() {
    const uri = "mongodb://mongouser:password@10.0.0.100:27017,10.0.0.101:27017,10.0.0.102:27017/admin?authSource=admin&replicaSet=cmgo-xxxxxxxx";
    const client = new MongoClient(uri, commonOptions);
    await client.connect();
    console.log('Replica set connection successful');
    return client;
}

// Sharded Cluster: LB Address Connection (Applicable to the Vast Majority of Scenarios)
async function connectWithLB() {
    const uri = "mongodb://mongouser:password@10.0.0.100:27017/admin?authSource=admin";
    const client = new MongoClient(uri, commonOptions);
    await client.connect();
    console.log('LB connection successful');
    return client;
}

// Sharded Cluster: Connect to All Mongos
async function connectWithAllMongos() {
    const uri = "mongodb://mongouser:password@10.0.0.100:27017,10.0.0.100:27018,10.0.0.100:27019/admin?authSource=admin";
    const client = new MongoClient(uri, commonOptions);
    await client.connect();
    console.log('All Mongos connection successful');
    return client;
}

Go(mongo-driver)

In the Go ecosystem, mongo-driver is the official driver library maintained by MongoDB, suitable for high-performance backend services and microservices architectures. The Go driver configures connection parameters through the options.Client() chained call, supporting a complete set of configuration items such as connection pooling, timeouts, retries, and read/write policies. The following example encapsulates common configurations in the createClient function. The four connection methods can reuse the same configuration logic by simply passing in different URIs. The Go driver requires passing a context.Context during connection to control timeouts. It is recommended to create a mongo.Client instance once at application startup and reuse it throughout the entire lifecycle to avoid repeatedly establishing connections.
package main

import (
    "context"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/mongo/readpref"
    "go.mongodb.org/mongo-driver/mongo/writeconcern"
)

// Sharded Cluster: SRV Connection
func createClientWithSRV() (*mongo.Client, error) {
    uri := "mongodb+srv://mongouser:password@xxx.tencentcdb.com/admin?authSource=admin"
    return createClient(uri)
}

// Replica Set: Console Default Connection String (Contains All Node Addresses)
func createClientWithReplicaSet() (*mongo.Client, error) {
    uri := "mongodb://mongouser:password@10.0.0.100:27017,10.0.0.101:27017,10.0.0.102:27017/admin" +
           "?authSource=admin&replicaSet=cmgo-xxxxxxxx"
    return createClient(uri)
}

// Sharded Cluster: LB Address Connection (Applicable to the Vast Majority of Scenarios)
func createClientWithLB() (*mongo.Client, error) {
    uri := "mongodb://mongouser:password@10.0.0.100:27017/admin?authSource=admin"
    return createClient(uri)
}

// Sharded Cluster: Connect to All Mongos
func createClientWithAllMongos() (*mongo.Client, error) {
    uri := "mongodb://mongouser:password@10.0.0.100:27017,10.0.0.100:27018,10.0.0.100:27019/admin" +
           "?authSource=admin"
    return createClient(uri)
}

func createClient(uri string) (*mongo.Client, error) {
    clientOpts := options.Client().ApplyURI(uri).
        // Connection Pool Configuration
        SetMaxPoolSize(150).
        SetMinPoolSize(10).
        SetMaxConnIdleTime(120 * time.Second).
        
        // Timeout Configuration
        SetConnectTimeout(10 * time.Second).
        SetServerSelectionTimeout(5 * time.Second).
        
        // Reliability Configuration
        SetRetryWrites(true).
        SetRetryReads(true).
        SetWriteConcern(writeconcern.Majority()).
        SetReadPreference(readpref.SecondaryPreferred())

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    client, err := mongo.Connect(ctx, clientOpts)
    if err != nil {
        return nil, err
    }

    // Connection Health Check
    if err := client.Ping(ctx, readpref.Primary()); err != nil {
        return nil, err
    }
    log.Println("MongoDB connection is normal")

    return client, nil
}
Previous Topic: Connection Configuration SpecificationsNext Topic: Data Modeling and Schema Design Specifications

Help and Support

Was this page helpful?

Help us improve! Rate your documentation experience in 5 mins.

Feedback