通过编程方式连接到 Amazon DocumentDB

本部分包含说明了如何使用多种不同语言连接到 Amazon DocumentDB（与 MongoDB 兼容） 的代码示例。根据连接的集群是否启用传输层安全性 (TLS)，这些示例分为两个部分。默认情况下，Amazon DocumentDB 集群启用了 TLS。但是，您可以根据需要关闭 TLS。有关更多信息，请参阅加密传输中的数据。

如果您尝试从集群所在的 VPC 外部连接到 Amazon DocumentDB，请参阅从 Amazon VPC 外部连接到 Amazon DocumentDB集群。

在连接到集群之前，您必须知道集群是否启用了 TLS。下一部分介绍如何使用 AWS 管理控制台或 AWS CLI 确定集群的 tls 参数的值。之后，您可以查找和应用适当的代码示例。

确定 tls 参数的值

确定集群是否启用了 TLS 是一个两步过程，您可以使用 AWS 管理控制台或 AWS CLI 执行该过程。

  1. 确定管理集群的参数组。

    1. 通过以下网址登录 AWS 管理控制台并打开 Amazon DocumentDB 控制台：https://console.aws.amazon.com/docdb。

    2. 在左侧导航窗格中，选择集群。

    3. 在集群列表中，选择您的集群的名称。

    4. 生成的页面将显示所选集群的详细信息。向下滚动到 Cluster details (集群详细信息)。在此部分的底部，在 Cluster parameter group (集群参数组) 的下方找到参数组的名称。

    使用以下 AWS CLI 代码可以确定管理您的集群的参数。请确保将 sample-cluster 替换为您的集群的名称。

    1. aws docdb describe-db-clusters \
    2.     --db-cluster-identifier sample-cluster \
    3.     --query 'DBClusters[*].[DBClusterIdentifier,DBClusterParameterGroup]'      
    4.

    此操作的输出将类似于以下内容：

    1. [
    2.        [
    3.            "sample-cluster",
    4.            "sample-parameter-group"
    5.        ]
    6. ]
    7.

  2. 确定集群参数组中 tls 参数的值。

    1. 在导航窗格中，选择参数组。

    2. 在 Cluster parameter groups (集群参数组) 窗口中，选择您的集群参数组。

    3. 打开的页面上会显示您的集群参数组中包含的参数。您可以在其中查看 tls 参数的值。有关修改此参数的信息，请参阅修改 Amazon DocumentDB 集群参数组。

    您可以使用 describe-db-cluster-parameters AWS CLI 命令来查看集群参数组中的参数的详细信息。

    • --describe-db-cluster-parameters — 列出参数组中的所有参数及其值。

      • --db-cluster-parameter-group name — 必需。您的集群参数组的名称。
  1. <pre><code>aws docdb describe-db-cluster-parameters \
  2.     --db-cluster-parameter-group-name sample-parameter-group</code></pre>
  4. 此操作的输出将类似于以下内容：
  6. <pre><div></div><code>{
  7.         "Parameters": [
  8.             {
  9.                 "ParameterName": "profiler_threshold_ms",
  10.                 "ParameterValue": "100",
  11.                 "Description": "Operations longer than profiler_threshold_ms will be logged",
  12.                 "Source": "system",
  13.                 "ApplyType": "dynamic",
  14.                 "DataType": "integer",
  15.                 "AllowedValues": "50-2147483646",
  16.                 "IsModifiable": true,
  17.                 "ApplyMethod": "pending-reboot"
  18.             },
  19.             {
  20.                 "<b>ParameterName": "tls"</b>,
  21.                 "ParameterValue": "disabled",
  22.                 "Description": "Config to enable/disable TLS",
  23.                 "Source": "user",
  24.                 "ApplyType": "static",
  25.                 "DataType": "string",
  26.                 "AllowedValues": "disabled,enabled",
  27.                 "IsModifiable": true,
  28.                 "ApplyMethod": "pending-reboot"
  29.             }
  30.         ]
  31. }</code></pre>

确定 tls 参数的值后，即可使用以下部分中的代码示例之一继续连接到您的集群。

启用了 TLS 的情况下的连接

要查看以编程方式连接到启用了 TLS 的 Amazon DocumentDB 集群的代码示例，请选择您要使用的语言所对应的选项卡。

要加密传输中的数据，请使用以下操作下载名为 Amazon DocumentDB 的 rds-combined-ca-bundle.pem 的公有密钥。

  1. wget https://s3.amazonaws.com/rds-downloads/rds-combined-ca-bundle.pem

Python

以下代码说明了如何在启用了 TLS 的情况下使用 Python 连接到 Amazon DocumentDB。

  1. import pymongo
  2. import sys
  4. ##Create a MongoDB client, open a connection to Amazon DocumentDB as a replica set and specify the read preference as secondary preferred
  5. client = pymongo.MongoClient('mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/?ssl=true&ssl_ca_certs=rds-combined-ca-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred') 
  7. ##Specify the database to be used
  8. db = client.sample_database
  10. ##Specify the collection to be used
  11. col = db.sample_collection
  13. ##Insert a single document
  14. col.insert_one({'hello':'Amazon DocumentDB'})
  16. ##Find the document that was previously written
  17. x = col.find_one({'hello':'Amazon DocumentDB'})
  19. ##Print the result to the screen
  20. print(x)
  22. ##Close the connection
  23. client.close()
  24.

Node.js

以下代码说明了如何在启用了 TLS 的情况下使用 Node.js 连接到 Amazon DocumentDB。

  1. var MongoClient = require('mongodb').MongoClient,
  2.   f = require('util').format,
  3.   fs = require('fs');
  5. //Specify the Amazon DocumentDB cert
  6. var ca = [fs.readFileSync("rds-combined-ca-bundle.pem")];
  8. //Create a MongoDB client, open a connection to Amazon DocumentDB as a replica set, 
  9. //  and specify the read preference as secondary preferred
  10. var client = MongoClient.connect(
  11. 'mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database?ssl=true&replicaSet=rs0&readPreference=secondaryPreferred', 
  12. { 
  13.   sslValidate: true,
  14.   sslCA:ca,
  15.   useNewUrlParser: true
  16. },
  17. function(err, client) {
  18.     if(err)
  19.         throw err;
  21.     //Specify the database to be used
  22.     db = client.db('sample-database');
  24.     //Specify the collection to be used
  25.     col = db.collection('sample-collection');
  27.     //Insert a single document
  28.     col.insertOne({'hello':'Amazon DocumentDB'}, function(err, result){
  29.       //Find the document that was previously written
  30.       col.findOne({'hello':'Amazon DocumentDB'}, function(err, result){
  31.         //Print the result to the screen
  32.         console.log(result);
  34.         //Close the connection
  35.         client.close()
  36.       });
  37.    });
  38. });
  39.

PHP

以下代码说明了如何在启用了 TLS 的情况下使用 PHP 连接到 Amazon DocumentDB。

  1. <?php
  2. //Include Composer's autoloader
  3. require 'vendor/autoload.php';
  5. $SSL_DIR = "/home/ubuntu";
  6. $SSL_FILE = "rds-combined-ca-bundle.pem";
  8. //Specify the Amazon DocumentDB cert
  9. $ctx = stream_context_create(array(
  10.     "ssl" => array(
  11.         "cafile" => $SSL_DIR . "/" . $SSL_FILE,
  12.     ))
  13. );
  15. //Create a MongoDB client and open connection to Amazon DocumentDB
  16. $client = new MongoDB\Client("mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017", array("ssl" => true), array("context" => $ctx));
  18. //Specify the database and collection to be used
  19. $col = $client->sample-database->sample-collection;
  21. //Insert a single document
  22. $result = $col->insertOne( [ 'hello' => 'Amazon DocumentDB'] );
  24. //Find the document that was previously written
  25. $result = $col->findOne(array('hello' => 'Amazon DocumentDB'));
  27. //Print the result to the screen
  28. print_r($result);
  29. ?>
  30.

Go

以下代码说明了如何在启用了 TLS 的情况下使用 Go 连接到 Amazon DocumentDB。

注意

从版本 1.2.1 开始，MongoDB Go 驱动程序将仅使用在 sslcertificateauthorityfile 中找到的第一个 CA 服务器证书。 以下示例代码通过手动将在 sslcertificateauthorityfile 中找到的所有服务器证书附加到在客户端创建期间使用的自定义 TLS 配置，解决了这一限制。

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  7.     "time"
  9.     "go.mongodb.org/mongo-driver/bson"
  10.     "go.mongodb.org/mongo-driver/mongo"
  11.     "go.mongodb.org/mongo-driver/mongo/options"
  13.     "io/ioutil"
  14.     "crypto/tls"
  15.     "crypto/x509"
  16.     "errors"
  17. )
  19. const (
  20.     // Path to the AWS CA file
  21.     caFilePath = "rds-combined-ca-bundle.pem"
  23.     // Timeout operations after N seconds
  24.     connectTimeout  = 5
  25.     queryTimeout    = 30
  26.     username        = "<sample-user>"
  27.     password        = "<password>"
  28.     clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017"
  30.     // Which instances to read from
  31.     readPreference = "secondaryPreferred"
  33.     connectionStringTemplate = "mongodb://%s:%s@%s/sample-database?ssl=true&replicaSet=rs0&readpreference=%s"
  34. )
  36. func main() {
  38.     connectionURI := fmt.Sprintf(connectionStringTemplate, username, password, clusterEndpoint, readPreference)
  40.     tlsConfig, err := getCustomTLSConfig(caFilePath)
  41.     if err != nil {
  42.         log.Fatalf("Failed getting TLS configuration: %v", err)
  43.     }
  45.     client, err := mongo.NewClient(options.Client().ApplyURI(connectionURI).SetTLSConfig(tlsConfig))
  46.     if err != nil {
  47.         log.Fatalf("Failed to create client: %v", err)
  48.     }
  50.     ctx, cancel := context.WithTimeout(context.Background(), connectTimeout*time.Second)
  51.     defer cancel()
  53.     err = client.Connect(ctx)
  54.     if err != nil {
  55.         log.Fatalf("Failed to connect to cluster: %v", err)
  56.     }
  58.     // Force a connection to verify our connection string
  59.     err = client.Ping(ctx, nil)
  60.     if err != nil {
  61.         log.Fatalf("Failed to ping cluster: %v", err)
  62.     }
  64.     fmt.Println("Connected to DocumentDB!")
  66.     collection := client.Database("sample-database").Collection("sample-collection")
  68.     ctx, cancel = context.WithTimeout(context.Background(), queryTimeout*time.Second)
  69.     defer cancel()
  71.     res, err := collection.InsertOne(ctx, bson.M{"name": "pi", "value": 3.14159})
  72.     if err != nil {
  73.         log.Fatalf("Failed to insert document: %v", err)
  74.     }
  76.     id := res.InsertedID
  77.     log.Printf("Inserted document ID: %s", id)
  79.     ctx, cancel = context.WithTimeout(context.Background(), queryTimeout*time.Second)
  80.     defer cancel()
  82.     cur, err := collection.Find(ctx, bson.D{})
  84.     if err != nil {
  85.         log.Fatalf("Failed to run find query: %v", err)
  86.     }
  87.     defer cur.Close(ctx)
  89.     for cur.Next(ctx) {
  90.         var result bson.M
  91.         err := cur.Decode(&result)
  92.         log.Printf("Returned: %v", result)
  94.         if err != nil {
  95.             log.Fatal(err)
  96.         }
  97.     }
  99.     if err := cur.Err(); err != nil {
  100.         log.Fatal(err)
  101.     }
  103. }
  105. func getCustomTLSConfig(caFile string) (*tls.Config, error) {
  106.     tlsConfig := new(tls.Config)
  107.     certs, err := ioutil.ReadFile(caFile)
  109.     if err != nil {
  110.         return tlsConfig, err
  111.     }
  113.     tlsConfig.RootCAs = x509.NewCertPool()
  114.     ok := tlsConfig.RootCAs.AppendCertsFromPEM(certs)
  116.     if !ok {
  117.         return tlsConfig, errors.New("Failed parsing pem file")
  118.     }
  120.     return tlsConfig, nil
  121. }
  123.

Java

从 Java 应用程序连接到启用了 TLS 的 Amazon DocumentDB 集群时，您的程序必须使用 AWS 提供的证书颁发机构 （CA） 文件来验证连接。要使用 Amazon RDS CA 证书，请执行以下操作：

  1. 从 Amazon RDS https://s3.amazonaws.com/rds-downloads/rds-combined-ca-bundle.pem 下载 CA 文件。

  2. 通过执行以下命令，使用该文件中包含的 CA 证书来创建信任存储。请务必更改 <truststorePassword> 转换为其他内容。如果您要访问同时包含旧 CA 证书 (rds-ca-2015-root.pem) 和新 CA 证书 (rds-ca-2019-root.pem) 的信任存储，可以将证书捆绑包导入该信任存储。

    下面是一个示例 Shell 脚本，它将证书捆绑包导入 Linux 操作系统上的信任存储。

    1. mydir=/tmp/certs
    2. truststore=${mydir}/rds-truststore.jks
    3. storepassword=<truststorePassword>
    5. curl -sS "https://s3.amazonaws.com/rds-downloads/rds-combined-ca-bundle.pem" > ${mydir}/rds-combined-ca-bundle.pem
    6. awk 'split_after == 1 {n++;split_after=0} /-----END CERTIFICATE-----/ {split_after=1}{print > "rds-ca-" n ".pem"}' < ${mydir}/rds-combined-ca-bundle.pem
    8. for CERT in rds-ca-*; do
    9.   alias=$(openssl x509 -noout -text -in $CERT | perl -ne 'next unless /Subject:/; s/.*(CN=|CN = )//; print')
    10.   echo "Importing $alias"
    11.   keytool -import -file ${CERT} -alias "${alias}" -storepass ${storepassword} -keystore ${truststore} -noprompt
    12.   rm $CERT
    13. done
    15. rm ${mydir}/rds-combined-ca-bundle.pem
    17. echo "Trust store content is: "
    19. keytool -list -v -keystore "$truststore" -storepass ${storepassword} | grep Alias | cut -d " " -f3- | while read alias 
    20. do
    21.    expiry=`keytool -list -v -keystore "$truststore" -storepass ${storepassword} -alias "${alias}" | grep Valid | perl -ne 'if(/until: (.*?)\n/) { print "$1\n"; }'`
    22.    echo " Certificate ${alias} expires in '$expiry'" 
    23. done
    24.

    下面是一个示例 Shell 脚本，它将证书捆绑包导入 macOS 上的信任存储。

    1. mydir=/tmp/certs
    2. truststore=${mydir}/rds-truststore.jks
    3. storepassword=<truststorePassword>
    5. curl -sS "https://s3.amazonaws.com/rds-downloads/rds-combined-ca-bundle.pem" > ${mydir}/rds-combined-ca-bundle.pem
    6. split -p "-----BEGIN CERTIFICATE-----" ${mydir}/rds-combined-ca-bundle.pem rds-ca-
    8. for CERT in rds-ca-*; do
    9.   alias=$(openssl x509 -noout -text -in $CERT | perl -ne 'next unless /Subject:/; s/.*(CN=|CN = )//; print')
    10.   echo "Importing $alias"
    11.   keytool -import -file ${CERT} -alias "${alias}" -storepass ${storepassword} -keystore ${truststore} -noprompt
    12.   rm $CERT
    13. done
    15. rm ${mydir}/rds-combined-ca-bundle.pem
    17. echo "Trust store content is: "
    19. keytool -list -v -keystore "$truststore" -storepass ${storepassword} | grep Alias | cut -d " " -f3- | while read alias 
    20. do
    21.    expiry=`keytool -list -v -keystore "$truststore" -storepass ${storepassword} -alias "${alias}" | grep Valid | perl -ne 'if(/until: (.*?)\n/) { print "$1\n"; }'`
    22.    echo " Certificate ${alias} expires in '$expiry'" 
    23. done
    24.

  3. 请先在您的应用程序中设置以下系统属性，以便在该程序中使用 keystore，然后再连接到 Amazon DocumentDB 集群。

    1. javax.net.ssl.trustStore: <truststore>
    2. javax.net.ssl.trustStorePassword: <truststorePassword>
    3.

  4. 以下代码说明了如何在启用了 TLS 的情况下使用 Java 连接到 Amazon DocumentDB。

    1. package com.example.documentdb;
    3. import com.mongodb.MongoClient;
    4. import com.mongodb.MongoClientURI;
    5. import com.mongodb.ServerAddress;
    6. import com.mongodb.MongoException;
    7. import com.mongodb.client.MongoCursor;
    8. import com.mongodb.client.MongoDatabase;
    9. import com.mongodb.client.MongoCollection;
    10. import org.bson.Document;
    12. public final class Main {
    13.     private Main() {
    14.     }
    15.     public static void main(String[] args) {
    17.         String template = "mongodb://%s:%s@%s/sample-database?ssl=true&replicaSet=rs0&readpreference=%s";
    18.         String username = "<sample-user>";
    19.         String password = "<password>";
    20.         String clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
    21.         String readPreference = "secondaryPreferred";
    22.         String connectionString = String.format(template, username, password, clusterEndpoint, readPreference);
    24.         String truststore = "<truststore>";
    25.         String truststorePassword = "<truststorePassword>";
    27.         System.setProperty("javax.net.ssl.trustStore", truststore);
    28.         System.setProperty("javax.net.ssl.trustStorePassword", truststorePassword);
    30.         MongoClientURI clientURI = new MongoClientURI(connectionString);
    31.         MongoClient mongoClient = new MongoClient(clientURI);
    33.         MongoDatabase testDB = mongoClient.getDatabase("sample-database");
    34.         MongoCollection<Document> numbersCollection = testDB.getCollection("sample-collection");
    36.         Document doc = new Document("name", "pi").append("value", 3.14159);
    37.         numbersCollection.insertOne(doc);
    39.         MongoCursor<Document> cursor = numbersCollection.find().iterator();
    40.         try {
    41.             while (cursor.hasNext()) {
    42.                 System.out.println(cursor.next().toJson());
    43.             }
    44.         } finally {
    45.             cursor.close();
    46.         }
    48.     }
    49. }
    50.

C# / .NET

以下代码说明了如何在启用了 TLS 的情况下使用 C# / .NET 连接到 Amazon DocumentDB。

  1. using System;
  2. using System.Text;
  3. using System.Linq;
  4. using System.Collections.Generic;
  5. using System.Security.Cryptography;
  6. using System.Security.Cryptography.X509Certificates;
  7. using System.Net.Security;
  8. using MongoDB.Driver;
  9. using MongoDB.Bson;
  11. namespace DocDB
  12. {
  13.     class Program
  14.     {
  15.         static void Main(string[] args)
  16.         {
  17.             string template = "mongodb://{0}:{1}@{2}/sample-database?ssl=true&replicaSet=rs0&readpreference={3}";
  18.             string username = "<sample-user>";
  19.             string password = "<password>";
  20.             string readPreference = "secondaryPreferred";
  21.             string clusterEndpoint="sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
  22.             string connectionString = String.Format(template, username, password, clusterEndpoint, readPreference);
  24.             string pathToCAFile = "<path_to_rds-combined-ca-bundle.p7b_file>";
  26.             // ADD CA certificate to local trust store
  27.             // DO this once - Maybe when your service starts
  28.             X509Store localTrustStore = new X509Store(StoreName.Root);
  29.             X509Certificate2Collection certificateCollection = new X509Certificate2Collection();
  30.             certificateCollection.Import(pathToCAFile);
  31.             try 
  32.             {
  33.                 localTrustStore.Open(OpenFlags.ReadWrite);
  34.                 localTrustStore.AddRange(certificateCollection);
  35.             } 
  36.             catch (Exception ex) 
  37.             {
  38.                 Console.WriteLine("Root certificate import failed: " + ex.Message);
  39.                 throw;
  40.             } 
  41.             finally 
  42.             {
  43.                 localTrustStore.Close();
  44.             }
  46.             var settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));
  47.             var client = new MongoClient(settings);
  49.             var database = client.GetDatabase("sample-database");
  50.             var collection = database.GetCollection<BsonDocument>("sample-collection");
  51.             var docToInsert = new BsonDocument { { "pi", 3.14159 } };
  52.             collection.InsertOne(docToInsert);
  53.         }
  54.     }
  55. }
  56.

mongo shell

以下代码说明了如何在启用了 TLS 的情况下使用 mongo shell 连接和查询 Amazon DocumentDB。

  1. 使用 mongo shell 连接到 Amazon DocumentDB。

    1. mongo --ssl --host sample-cluster.node.us-east-1.docdb.amazonaws.com:27017 --sslCAFile rds-combined-ca-bundle.pem --username <sample-user> --password <password>

  2. 插入单个文档。

    1. db.myTestCollection.insertOne({'hello':'Amazon DocumentDB'})

  3. 查找以前插入的文档。

    1. db.myTestCollection.find({'hello':'Amazon DocumentDB'})

R

以下代码说明了如何在启用了 TLS 的情况下通过 R 使用 mongolite （Amazon DocumentDB） 连接到 https://jeroen.github.io/mongolite/。

  1. #Include the mongolite library.
  2. library(mongolite)
  4. mongourl <- paste("mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/test2?ssl=true&",
  5.           "readPreference=secondaryPreferred&replicaSet=rs0", sep="")
  7. #Create a MongoDB client, open a connection to Amazon DocumentDB as a replica
  8. #   set and specify the read preference as secondary preferred
  9. client <- mongo(url = mongo(url = mongourl, options = ssl_options(weak_cert_validation = F, ca = <path to 'rds-combined-ca-bundle.pem'>)) 
  11. #Insert a single document
  12. str <- c('{"hello" : "Amazon DocumentDB"}')
  13. client$insert(str)
  15. #Find the document that was previously written
  16. client$find()
  17.

Ruby

以下代码说明了如何在启用了 TLS 的情况下使用 Ruby 连接到 Amazon DocumentDB。

  1. require 'mongo'
  2. require 'neatjson'
  3. require 'json'
  4. client_host = 'mongodb://sample-cluster.node.us-east-1.docdb.amazonaws.com:27017'
  5. client_options = {
  6.    database: 'test',
  7.    replica_set: 'rs0',
  8.    read: {:secondary_preferred => 1},
  9.    user: '<sample-user>',
  10.    password: '<password>',
  11.    ssl: true,
  12.    ssl_verify: true,
  13.    ssl_ca_cert: <path to 'rds-combined-ca-bundle.pem'>
  14. }
  16. begin
  17.    ##Create a MongoDB client, open a connection to Amazon DocumentDB as a
  18.    ##   replica set and specify the read preference as secondary preferred
  19.    client = Mongo::Client.new(client_host, client_options)
  21.    ##Insert a single document
  22.    x = client[:test].insert_one({"hello":"Amazon DocumentDB"})
  24.    ##Find the document that was previously written
  25.    result = client[:test].find()
  27.    #Print the document
  28.    result.each do |document|
  29.       puts JSON.neat_generate(document)
  30.    end
  31. end
  33. #Close the connection
  34. client.close
  35.

禁用了 TLS 的情况下的连接

要查看以编程方式连接到禁用了 TLS 的 Amazon DocumentDB 集群的代码示例，请选择您要使用的语言所对应的选项卡。

Python

以下代码说明了如何在禁用 TLS 的情况下使用 Python 连接到 Amazon DocumentDB。

  1. ## Create a MongoDB client, open a connection to Amazon DocumentDB as a replica set and specify the read preference as secondary preferred                  
  2. client = pymongo.MongoClient('mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/?replicaSet=rs0&readPreference=secondaryPreferred') 
  4. ##Specify the database to be used
  5. db = client.sample_database
  7. ##Specify the collection to be used
  8. col = db.sample_collection
  10. ##Insert a single document
  11. col.insert_one({'hello':'Amazon DocumentDB'})
  13. ##Find the document that was previously written
  14. x = col.find_one({'hello':'Amazon DocumentDB'})
  16. ##Print the result to the screen
  17. print(x)
  19. ##Close the connection
  20. client.close()
  21.

Node.js

以下代码说明了如何在禁用了 TLS 的情况下使用 Node.js 连接到 Amazon DocumentDB。

  1. var MongoClient = require('mongodb').MongoClient;
  3. //Create a MongoDB client, open a connection to Amazon DocumentDB as a replica set,
  4. //  and specify the read preference as secondary preferred
  5. var client = MongoClient.connect(
  6. 'mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database?replicaSet=rs0&readPreference=secondaryPreferred', 
  7. {
  8.   useNewUrlParser: true
  9. },
  11. function(err, client) {
  12.     if(err)
  13.         throw err;
  14.     //Specify the database to be used
  15.     db = client.db('sample-database');
  17.     //Specify the collection to be used
  18.     col = db.collection('sample-collection');
  20.     //Insert a single document
  21.     col.insertOne({'hello':'Amazon DocumentDB'}, function(err, result){
  22.       //Find the document that was previously written
  23.       col.findOne({'hello':'Amazon DocumentDB'}, function(err, result){
  24.         //Print the result to the screen
  25.         console.log(result);
  27.         //Close the connection
  28.         client.close()
  29.       });
  30.    });
  31. });
  32.

PHP

以下代码说明了如何在禁用了 TLS 的情况下使用 PHP 连接到 Amazon DocumentDB。

  1. <?php
  2. //Include Composer's autoloader
  3. require 'vendor/autoload.php';
  5. //Create a MongoDB client and open connection to Amazon DocumentDB
  6. $client = new MongoDB\Client("mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017");
  8. //Specify the database and collection to be used
  9. $col = $client->sample-database->sample-collection;
  11. //Insert a single document
  12. $result = $col->insertOne( [ 'hello' => 'Amazon DocumentDB'] );
  14. //Find the document that was previously written
  15. $result = $col->findOne(array('hello' => 'Amazon DocumentDB'));
  17. //Print the result to the screen
  18. print_r($result);
  19. ?>
  20.

Go

以下代码说明了如何在禁用了 TLS 的情况下使用 Go 连接到 Amazon DocumentDB。

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  7.     "time"
  9.     "go.mongodb.org/mongo-driver/bson"
  10.     "go.mongodb.org/mongo-driver/mongo"
  11.     "go.mongodb.org/mongo-driver/mongo/options"
  12. )
  14. const (
  15.     // Timeout operations after N seconds
  16.     connectTimeout  = 5
  17.     queryTimeout    = 30
  18.     username        = "<sample-user>"
  19.     password        = "<password>"
  20.     clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017"
  22.     // Which instances to read from
  23.     readPreference           = "secondaryPreferred"
  24.     connectionStringTemplate = "mongodb://%s:%s@%s/sample-database?replicaSet=rs0&readpreference=%s"
  25. )
  27. func main() {
  29.     connectionURI := fmt.Sprintf(connectionStringTemplate, username, password, clusterEndpoint, readPreference)
  31.     client, err := mongo.NewClient(options.Client().ApplyURI(connectionURI))
  32.     if err != nil {
  33.         log.Fatalf("Failed to create client: %v", err)
  34.     }
  36.     ctx, cancel := context.WithTimeout(context.Background(), connectTimeout*time.Second)
  37.     defer cancel()
  39.     err = client.Connect(ctx)
  40.     if err != nil {
  41.         log.Fatalf("Failed to connect to cluster: %v", err)
  42.     }
  44.     // Force a connection to verify our connection string
  45.     err = client.Ping(ctx, nil)
  46.     if err != nil {
  47.         log.Fatalf("Failed to ping cluster: %v", err)
  48.     }
  50.     fmt.Println("Connected to DocumentDB!")
  52.     collection := client.Database("sample-database").Collection("sample-collection")
  54.     ctx, cancel = context.WithTimeout(context.Background(), queryTimeout*time.Second)
  55.     defer cancel()
  57.     res, err := collection.InsertOne(ctx, bson.M{"name": "pi", "value": 3.14159})
  58.     if err != nil {
  59.         log.Fatalf("Failed to insert document: %v", err)
  60.     }
  62.     id := res.InsertedID
  63.     log.Printf("Inserted document ID: %s", id)
  65.     ctx, cancel = context.WithTimeout(context.Background(), queryTimeout*time.Second)
  66.     defer cancel()
  68.     cur, err := collection.Find(ctx, bson.D{})
  70.     if err != nil {
  71.         log.Fatalf("Failed to run find query: %v", err)
  72.     }
  73.     defer cur.Close(ctx)
  75.     for cur.Next(ctx) {
  76.         var result bson.M
  77.         err := cur.Decode(&result)
  78.         log.Printf("Returned: %v", result)
  80.         if err != nil {
  81.             log.Fatal(err)
  82.         }
  83.     }
  85.     if err := cur.Err(); err != nil {
  86.         log.Fatal(err)
  87.     }
  89. }
  90.

Java

以下代码说明了如何在禁用了 TLS 的情况下使用 Java 连接到 Amazon DocumentDB。

  1. package com.example.documentdb;
  3. import com.mongodb.MongoClient;
  4. import com.mongodb.MongoClientURI;
  5. import com.mongodb.ServerAddress;
  6. import com.mongodb.MongoException;
  7. import com.mongodb.client.MongoCursor;
  8. import com.mongodb.client.MongoDatabase;
  9. import com.mongodb.client.MongoCollection;
  10. import org.bson.Document;
  12. public final class Main {
  13.     private Main() {
  14.     }
  15.     public static void main(String[] args) {
  17.         String template = "mongodb://%s:%s@%s/sample-database?replicaSet=rs0&readpreference=%s";
  18.         String username = "<sample-user>";
  19.         String password = "<password>";
  20.         String clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
  21.         String readPreference = "secondaryPreferred";
  22.         String connectionString = String.format(template, username, password, clusterEndpoint, readPreference);
  24.         MongoClientURI clientURI = new MongoClientURI(connectionString);
  25.         MongoClient mongoClient = new MongoClient(clientURI);
  27.         MongoDatabase testDB = mongoClient.getDatabase("sample-database");
  28.         MongoCollection<Document> numbersCollection = testDB.getCollection("sample-collection");
  30.         Document doc = new Document("name", "pi").append("value", 3.14159);
  31.         numbersCollection.insertOne(doc);
  33.         MongoCursor<Document> cursor = numbersCollection.find().iterator();
  34.         try {
  35.             while (cursor.hasNext()) {
  36.                 System.out.println(cursor.next().toJson());
  37.             }
  38.         } finally {
  39.             cursor.close();
  40.         }
  42.     }
  43. }
  44.

C# / .NET

以下代码说明了如何在禁用了 TLS 的情况下使用 C# / .NET 连接到 Amazon DocumentDB。

  1. using System;
  2. using System.Text;
  3. using System.Linq;
  4. using System.Collections.Generic;
  5. using System.Security.Cryptography;
  6. using System.Security.Cryptography.X509Certificates;
  7. using System.Net.Security;
  8. using MongoDB.Driver;
  9. using MongoDB.Bson;
  11. namespace CSharpSample
  12. {
  13.    class Program
  14.     {
  15.        static void Main(string[] args)
  16.         {
  17.            string template = "mongodb://{0}:{1}@{2}/sample-database?&replicaSet=rs0&readpreference={3}";
  18.            string username = "<sample-user>";
  19.            string password = "<password>";
  20.            string clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
  21.            string readPreference = "secondaryPreferred";
  22.            string connectionString = String.Format(template, username, password, clusterEndpoint, readPreference);
  24.            var settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));
  25.            var client = new MongoClient(settings);
  27.            var database = client.GetDatabase("sample-database");
  28.            var collection = database.GetCollection<BsonDocument>("sample-collection");
  29.            var docToInsert = new BsonDocument { { "pi", 3.14159 } };
  30.             collection.InsertOne(docToInsert);
  31.         }
  32.     }
  33. }
  34.

mongo shell

以下代码演示如何在禁用 TLS 时使用 mongo shell 连接和查询 Amazon DocumentDB。

  1. 使用 mongo shell 连接到 Amazon DocumentDB。

    1. mongo --host mycluster.node.us-east-1.docdb.amazonaws.com:27017 --username <sample-user> --password <password>

  2. 插入单个文档。

    1. db.myTestCollection.insertOne({'hello':'Amazon DocumentDB'})

  3. 查找以前插入的文档。

    1. db.myTestCollection.find({'hello':'Amazon DocumentDB'})

R

以下代码说明了如何在禁用了 TLS 的情况下通过 R 使用 mongolite （Amazon DocumentDB） 连接到 https://jeroen.github.io/mongolite/。

  1. #Include the mongolite library.
  2. library(mongolite)
  4. #Create a MongoDB client, open a connection to Amazon DocumentDB as a replica
  5. #   set and specify the read preference as secondary preferred
  6. client <- mongo(url = "mongodb://sample-user;:password@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database?readPreference=secondaryPreferred&replicaSet=rs0")
  8. ##Insert a single document
  9. str <- c('{"hello" : "Amazon DocumentDB"}')
  10. client$insert(str)
  12. ##Find the document that was previously written
  13. client$find()
  14.

Ruby

以下代码说明了如何在禁用了 TLS 的情况下使用 Ruby 连接到 Amazon DocumentDB。

  1. require 'mongo'
  2. require 'neatjson'
  3. require 'json'
  4. client_host = 'mongodb://sample-cluster.node.us-east-1.docdb.amazonaws.com:27017'
  5. client_options = {
  6.    database: 'test',
  7.    replica_set: 'rs0',
  8.    read: {:secondary_preferred => 1},
  9.    user: '<sample-user>',
  10.    password: '<password>',
  11.    ssl: true,
  12.    ssl_verify: true,
  13.    ssl_ca_cert: <path to 'rds-combined-ca-bundle.pem'>
  14. }
  16. begin
  17.    ##Create a MongoDB client, open a connection to Amazon DocumentDB as a
  18.    ##   replica set and specify the read preference as secondary preferred
  19.    client = Mongo::Client.new(client_host, client_options)
  21.    ##Insert a single document
  22.    x = client[:test].insert_one({"hello":"Amazon DocumentDB"})
  24.    ##Find the document that was previously written
  25.    result = client[:test].find()
  27.    #Print the document
  28.    result.each do |document|
  29.       puts JSON.neat_generate(document)
  30.    end
  31. end
  33. #Close the connection
  34. client.close
  35.