How to connect to a Managed MongoDB® Database Instance

Current Mongosh Log ID:	67ab0096d43bcc1d9ed4336d
Connecting to:		mongodb+srv://<credentials>@{db-instance-id}.mgdb.{region}.scw.cloud/?appName=mongosh+2.3.8
Using MongoDB:		7.0.12
Using Mongosh:		2.3.8
For mongosh info see: https://docs.mongodb.com/mongodb-shell/
rs-{db-instance-id} [primary] test>

from pymongo import MongoClient
# Replace with your MongoDB® connection details
username = "your_username"
password = "your_password" # it is best to use environment variables to manage sensitive data
instance_id = "your_instance_id"
region = "your_region" #the region of your database instance. "fr-par" if Paris
tls_certificate = "path/to/your_tls_certificate.pem" # path to your TLS certificate file
database_name = "databaseName"
# Construct the connection string
connection_string = f"mongodb+srv://{username}:{password}@{instance_id}.mgdb.{region}.scw.cloud/?tls=true&tlsCAFile={tls_certificate}"
# Establish a connection
client = MongoClient(connection_string)
# Access a specific database
db = client[database_name]
# Example: Access a specific collection
collection = db['your_collection_name']
# Now you can interact with the collection, e.g., find documents
documents = collection.find({})
for doc in documents:
  print(doc)

const { MongoClient } = require('mongodb');
const path = require('path');
// Replace with your MongoDB® connection details
const username = encodeURIComponent('your_username');
const password = encodeURIComponent('your_password');
const region = "your_region" // "fr-par" for Paris.
const instanceId = 'your_instance_id';  // your instance id
const databaseName = 'databaseName'
// Path to your TLS certificate file
const tlsCertificatePath = path.resolve(__dirname, 'path/to/your_tls_certificate.pem');
// Construct the public connection string
const connectionString = `mongodb+srv://${username}:${password}@${instanceId}.mgdb.${region}.scw.cloud;`
// Construct the private connection string
const connectionString = `mongodb+srv://${username}:${password}@${instanceId}.${privateNetworkId}.internal;`
// Create a new MongoClient
const client = new MongoClient(connectionString, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    tls: true, // Enable TLS/SSL
    tlsCAFile: tlsCertificatePath, // Path to the CA certificate file
});
async function run() {
    try {
        // Connect to the MongoDB® server
        await client.connect();
        console.log('Connected to MongoDB!');
        // Access the database and collection
        const db = client.db(databaseName);
        const collection = db.collection('your_collection_name');
        // Example: Find documents in the collection
        const documents = await collection.find({}).toArray();
        console.log('Documents:', documents);
    } catch (err) {
        console.error(err);
    } finally {
        // Close the connection
        await client.close();
        console.log('Connection to MongoDB® closed.');
    }
}
run().catch(console.dir);

package main
import (
    "context"
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io/ioutil"
    "log"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)
func main() {
    // Replace with your MongoDB connection details
    username := "your_username"
    password := "your_password"
    instanceID := "your_instance_id"  // your instance_id
    privateNetworkID := "your_private_network_id" // Id of your Private Network
    region := "your_region" // the region of your database instance. "fr-par" for Paris.
    tlsCertificate := "path/to/your_tls_certificate.pem" // path to your TLS certificate
    databaseName = "databaseName"
    // Read CA certificate
    caCert, err := ioutil.ReadFile(tlsCertificate)
    if err != nil {
        log.Fatalf("Erreur lors de la lecture du fichier CA: %v", err)
    }
    // Create certificate pool
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)
    tlsConfig := &tls.Config{
        RootCAs: caCertPool,
    }
    // Construct the public connection string
    connectionString := fmt.Sprintf("mongodb+srv://%s:%s@%s.mgdb.%s.scw.cloud", username, password, instanceID, region)
    // Construct the private connection string
    connectionString := fmt.Sprintf("mongodb+srv://%s:%s@%s.%s.internal", username, password, instanceID, privateNetworkID)
    // Create a new client and connect to the server
    clientOptions := options.Client().
        ApplyURI(connectionString).
        SetTLSConfig(tlsConfig)
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }
    // Check the connection
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")
    // Access a specific collection
    collection := client.Database(databaseName).Collection("your_collection_name")
    // Example: Find documents in the collection
    cursor, err := collection.Find(context.TODO(), map[string]interface{}{})
    if err != nil {
        log.Fatal(err)
    }
    defer cursor.Close(context.TODO())
    for cursor.Next(context.TODO()) {
        var result map[string]interface{}
        err := cursor.Decode(&result)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println(result)
    }
    if err := cursor.Err(); err != nil {
        log.Fatal(err)
    }
    // Close the connection once no longer needed
    err = client.Disconnect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connection to MongoDB closed.")
}

const mongoose = require('mongoose');
const path = require('path');
// Replace with your MongoDB connection details
const username = encodeURIComponent('your_username');
const password = encodeURIComponent('your_password');
const region = "your_region"; // "fr-par" for Paris.
const instanceId = 'your_instance_id';  // your instance id
const privateNetworkId = 'your_private_network_id'; // your private network id
const databaseName = 'databaseName'
// Path to your TLS certificate file
const tlsCertificatePath = path.resolve(__dirname, 'path/to/your_tls_certificate.pem');
// Construct the public connection string
const connectionString = `mongodb+srv://${username}:${password}@${instanceId}.mgdb.${region}.scw.cloud`;
// Construct the private connection string
const connectionString = `mongodb+srv://${username}:${password}@${instanceId}.${privateNetworkId}.internal`;
// Connect to MongoDB using Mongoose
mongoose.connect(connectionString, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    tls: true, // Enable TLS/SSL
    tlsCAFile: tlsCertificatePath, // Path to the CA certificate file
})
.then(() => {
    console.log('Connected to MongoDB with Mongoose!');
})
.catch(err => {
    console.error('Connection error', err);
});
// Example schema and model
const exampleSchema = new mongoose.Schema({
    name: String,
    age: Number,
});
const ExampleModel = mongoose.model('Example', exampleSchema);
// Example: Creating a new document
const exampleDoc = new ExampleModel({ name: 'John Doe', age: 30 });
exampleDoc.save()
.then(doc => {
    console.log('Document saved:', doc);
})
.catch(err => {
    console.error('Error saving document', err);
});