Determinazione del valore tls TLSConnessione con abilitato Connessione con disabilitato TLS

Connessione programmatica ad Amazon DocumentDB

Questa sezione contiene esempi di codice che dimostrano come connettersi ad Amazon DocumentDB (con compatibilità con MongoDB) utilizzando diversi linguaggi. Gli esempi sono suddivisi in due sezioni a seconda che ci si stia connettendo a un cluster con Transport Layer Security (TLS) abilitato o disabilitato. Per impostazione predefinita, TLS è abilitato nei cluster Amazon DocumentDB. Tuttavia, puoi disattivarlo TLS se lo desideri. Per ulteriori informazioni, consulta Crittografia dei dati in transito.

Se stai tentando di connetterti ad Amazon DocumentDB dall'esterno VPC del cluster in cui risiede il cluster, consulta. Connessione a un cluster Amazon DocumentDB dall'esterno di Amazon VPC

Prima di connetterti al cluster, devi sapere se TLS è abilitato sul cluster. La sezione successiva illustra come determinare il valore del parametro tls del cluster tramite la AWS Management Console o l' AWS CLI. Seguendo tale procedura potrai trovare e applicare il codice di esempio appropriato.

Argomenti

Determinazione del valore del tls parametro
TLSConnessione con abilitato
Connessione con disabilitato TLS

Determinazione del valore del `tls` parametro

Determinare se il cluster è TLS abilitato è un processo in due fasi che è possibile eseguire utilizzando AWS Management Console o AWS CLI.

Determinare il gruppo di parametri che regola il cluster.
Using the AWS Management Console
Accedi a e apri AWS Management Console la console Amazon DocumentDB all'indirizzo https://console.aws.amazon.com/docdb.

Nel pannello di navigazione a sinistra, seleziona Cluster.

Nell'elenco dei cluster selezionare il nome del cluster.

La pagina risultante mostra i dettagli del cluster selezionato. Scorri verso il basso fino a Cluster details (Dettagli del cluster). Nella parte inferiore della sezione, individua il nome del gruppo di parametri sotto Cluster parameter group (Gruppo di parametri del cluster).
Using the AWS CLI
Il AWS CLI codice seguente determina quale parametro governa il cluster. Assicurarsi di sostituire sample-cluster con il nome del cluster.
```
aws docdb describe-db-clusters \
    --db-cluster-identifier sample-cluster \
    --query 'DBClusters[*].[DBClusterIdentifier,DBClusterParameterGroup]'
```
L'aspetto dell'output di questa operazione è simile al seguente.
```
[
       [
           "sample-cluster",
           "sample-parameter-group"
       ]
]
```
Determinare il valore del parametro tls nel gruppo di parametri del cluster.
Using the AWS Management Console
Nel riquadro di navigazione scegliere Parameter groups (Gruppi di parametri).

Nella finestra Cluster parameter groups (Gruppi di parametri cluster), selezionare il gruppo di parametri del cluster.

La pagina risultante mostra i parametri del gruppo di parametri del cluster. Puoi vedere il valore del parametro tls qui. Per informazioni sulla modifica di questo parametro, consulta Modifica dei gruppi di parametri del cluster Amazon DocumentDB.
Using the AWS CLI
È possibile utilizzare il describe-db-cluster-parameters AWS CLI comando per visualizzare i dettagli dei parametri nel gruppo di parametri del cluster.
--describe-db-cluster-parameters— Per elencare tutti i parametri all'interno di un gruppo di parametri e i relativi valori.

--db-cluster-parameter-group name: obbligatorio. Il nome del gruppo di parametri del cluster.
```
aws docdb describe-db-cluster-parameters \
    --db-cluster-parameter-group-name sample-parameter-group
```
L'aspetto dell'output di questa operazione è simile al seguente.
```
{
        "Parameters": [
            {
                "ParameterName": "profiler_threshold_ms",
                "ParameterValue": "100",
                "Description": "Operations longer than profiler_threshold_ms will be logged",
                "Source": "system",
                "ApplyType": "dynamic",
                "DataType": "integer",
                "AllowedValues": "50-2147483646",
                "IsModifiable": true,
                "ApplyMethod": "pending-reboot"
            },
            {
                "ParameterName": "tls",
                "ParameterValue": "disabled",
                "Description": "Config to enable/disable TLS",
                "Source": "user",
                "ApplyType": "static",
                "DataType": "string",
                "AllowedValues": "disabled,enabled,fips-140-3",
                "IsModifiable": true,
                "ApplyMethod": "pending-reboot"
            }
        ]
}
```
Nota
Amazon DocumentDB supporta FIPS 140-3 endpoint a partire dai cluster Amazon DocumentDB 5.0 (versione del motore 3.0.3727) nelle seguenti regioni: ca-central-1, us-west-2, us-east-1, us-east-2, -1. us-gov-east us-gov-west

Dopo aver determinato il valore del parametro tls, continuare con la connessione al cluster utilizzando uno degli esempi di codice nelle seguenti sezioni.

TLSConnessione con abilitato
Connessione con disabilitato TLS

TLSConnessione con abilitato

Per visualizzare un esempio di codice per la connessione programmatica a un cluster Amazon TLS DocumentDB abilitato, scegli la scheda appropriata per la lingua che desideri utilizzare.

Per crittografare i dati in transito, scarica la chiave pubblica per Amazon DocumentDB global-bundle.pem denominata utilizzando la seguente operazione.


wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem

Se la tua applicazione è su Microsoft Windows e richiede un PKCS7 file, puoi scaricare il pacchetto di PKCS7 certificati. Questo pacchetto contiene sia i certificati intermedi che quelli root su global-bundle.p7b. https://truststore.pki.rds.amazonaws.com/global/

Python

Il codice seguente mostra come connettersi ad Amazon DocumentDB usando TLS Python quando è abilitato.


import pymongo
import sys

##Create a MongoDB client, open a connection to Amazon DocumentDB as a replica set and specify the read preference as secondary preferred
client = pymongo.MongoClient('mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false') 

##Specify the database to be used
db = client.sample_database

##Specify the collection to be used
col = db.sample_collection

##Insert a single document
col.insert_one({'hello':'Amazon DocumentDB'})

##Find the document that was previously written
x = col.find_one({'hello':'Amazon DocumentDB'})

##Print the result to the screen
print(x)

##Close the connection
client.close()

Node.js

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando Node.js TLS quando è abilitato.


var MongoClient = require('mongodb').MongoClient

//Create a MongoDB client, open a connection to DocDB; as a replica set,
//  and specify the read preference as secondary preferred

var client = MongoClient.connect(
'mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database?tls=true&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false',
{
  tlsCAFile: `global-bundle.pem` //Specify the DocDB; cert
},
function(err, client) {
    if(err)
        throw err;

    //Specify the database to be used
    db = client.db('sample-database');

    //Specify the collection to be used
    col = db.collection('sample-collection');

    //Insert a single document
    col.insertOne({'hello':'Amazon DocumentDB'}, function(err, result){
      //Find the document that was previously written
      col.findOne({'hello':'Amazon DocumentDB'}, function(err, result){
        //Print the result to the screen
        console.log(result);

        //Close the connection
        client.close()
      });
   });
});

PHP

Il codice seguente mostra come connettersi ad Amazon DocumentDB PHP utilizzando TLS when è abilitato.


<?php
//Include Composer's autoloader
require 'vendor/autoload.php';

$TLS_DIR = "/home/ubuntu/global-bundle.pem";

//Create a MongoDB client and open connection to Amazon DocumentDB
$client = new MongoDB\Client("mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/?retryWrites=false", ["tls" => "true", "tlsCAFile" => $TLS_DIR ]);

//Specify the database and collection to be used
$col = $client->sampledatabase->samplecollection;

//Insert a single document
$result = $col->insertOne( [ 'hello' => 'Amazon DocumentDB'] );

//Find the document that was previously written
$result = $col->findOne(array('hello' => 'Amazon DocumentDB'));

//Print the result to the screen
print_r($result);
?>

Go

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando Go TLS quando è abilitato.

Nota

A partire dalla versione 1.2.1, il driver MongoDB Go utilizzerà solo il primo certificato del server CA trovato in sslcertificateauthorityfile. Il codice di esempio riportato di seguito risolve questa limitazione aggiungendo manualmente tutti i certificati server presenti in sslcertificateauthorityfile una TLS configurazione personalizzata utilizzata durante la creazione del client.


package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"

	"io/ioutil"
	"crypto/tls"
	"crypto/x509"
	"errors"
)

const (
	// Path to the AWS CA file
	caFilePath = "global-bundle.pem"

	// Timeout operations after N seconds
	connectTimeout  = 5
	queryTimeout    = 30
	username        = "<sample-user>"
	password        = "<password>"
	clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017"

	// Which instances to read from
	readPreference = "secondaryPreferred"

	connectionStringTemplate = "mongodb://%s:%s@%s/sample-database?tls=true&replicaSet=rs0&readpreference=%s"
)

func main() {

	connectionURI := fmt.Sprintf(connectionStringTemplate, username, password, clusterEndpoint, readPreference)

	tlsConfig, err := getCustomTLSConfig(caFilePath)
	if err != nil {
		log.Fatalf("Failed getting TLS configuration: %v", err)
	}

	client, err := mongo.NewClient(options.Client().ApplyURI(connectionURI).SetTLSConfig(tlsConfig))
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}

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

	err = client.Connect(ctx)
	if err != nil {
		log.Fatalf("Failed to connect to cluster: %v", err)
	}

	// Force a connection to verify our connection string
	err = client.Ping(ctx, nil)
	if err != nil {
		log.Fatalf("Failed to ping cluster: %v", err)
	}

	fmt.Println("Connected to DocumentDB!")

	collection := client.Database("sample-database").Collection("sample-collection")

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

	res, err := collection.InsertOne(ctx, bson.M{"name": "pi", "value": 3.14159})
	if err != nil {
		log.Fatalf("Failed to insert document: %v", err)
	}

	id := res.InsertedID
	log.Printf("Inserted document ID: %s", id)

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

	cur, err := collection.Find(ctx, bson.D{})

	if err != nil {
		log.Fatalf("Failed to run find query: %v", err)
	}
	defer cur.Close(ctx)

	for cur.Next(ctx) {
		var result bson.M
		err := cur.Decode(&result)
		log.Printf("Returned: %v", result)

		if err != nil {
			log.Fatal(err)
		}
	}

	if err := cur.Err(); err != nil {
		log.Fatal(err)
	}

}

func getCustomTLSConfig(caFile string) (*tls.Config, error) {
	tlsConfig := new(tls.Config)
	certs, err := ioutil.ReadFile(caFile)

	if err != nil {
		return tlsConfig, err
	}

	tlsConfig.RootCAs = x509.NewCertPool()
	ok := tlsConfig.RootCAs.AppendCertsFromPEM(certs)

	if !ok {
		return tlsConfig, errors.New("Failed parsing pem file")
	}

	return tlsConfig, nil

Java

Quando ci si connette a un cluster Amazon DocumentDB TLS abilitato da un'applicazione Java, il programma deve utilizzare AWS il file di autorità di certificazione (CA) fornito per convalidare la connessione. Per utilizzare il certificato Amazon RDS CA, procedi come segue:

Scarica il file Amazon RDS CA da https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem.

Creare uno store attendibile con il certificato CA contenuto nel file eseguendo i comandi indicati di seguito. Assicurati di modificare il <truststorePassword> a qualcos'altro. Se si accede a uno store attendibile che contiene sia il vecchio certificato CA (rds-ca-2015-root.pem) sia il nuovo certificato CA (rds-ca-2019-root.pem), è possibile importare il pacchetto di certificati nell'archivio attendibilità.

Il seguente script è uno script di esempio shell che importa il bundle di certificati in un archivio di trust su un sistema operativo Linux. Nel seguente esempio, sostituisci ogni user input placeholder con le tue informazioni. In particolare, ovunque si trovi la directory degli esempi»mydir"si trova nello script, sostituiscilo con una directory creata per questa attività.


mydir=/tmp/certs
truststore=${mydir}/rds-truststore.jks
storepassword=<truststorePassword>

curl -sS "https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem" > ${mydir}/global-bundle.pem
awk 'split_after == 1 {n++;split_after=0} /-----END CERTIFICATE-----/ {split_after=1}{print > "rds-ca-" n ".pem"}' < ${mydir}/global-bundle.pem

for CERT in rds-ca-*; do
  alias=$(openssl x509 -noout -text -in $CERT | perl -ne 'next unless /Subject:/; s/.*(CN=|CN = )//; print')
  echo "Importing $alias"
  keytool -import -file ${CERT} -alias "${alias}" -storepass ${storepassword} -keystore ${truststore} -noprompt
  rm $CERT
done

rm ${mydir}/global-bundle.pem

echo "Trust store content is: "

keytool -list -v -keystore "$truststore" -storepass ${storepassword} | grep Alias | cut -d " " -f3- | while read alias 
do
   expiry=`keytool -list -v -keystore "$truststore" -storepass ${storepassword} -alias "${alias}" | grep Valid | perl -ne 'if(/until: (.*?)\n/) { print "$1\n"; }'`
   echo " Certificate ${alias} expires in '$expiry'" 
done

Il seguente script è uno script di shell di esempio che importa il bundle di certificati in un archivio di trust su un sistema operativo Linux.


mydir=/tmp/certs
truststore=${mydir}/rds-truststore.jks
storepassword=<truststorePassword>

curl -sS "https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem" > ${mydir}/global-bundle.pem
split -p "-----BEGIN CERTIFICATE-----" ${mydir}/global-bundle.pem rds-ca-

for CERT in rds-ca-*; do
  alias=$(openssl x509 -noout -text -in $CERT | perl -ne 'next unless /Subject:/; s/.*(CN=|CN = )//; print')
  echo "Importing $alias"
  keytool -import -file ${CERT} -alias "${alias}" -storepass ${storepassword} -keystore ${truststore} -noprompt
  rm $CERT
done

rm ${mydir}/global-bundle.pem

echo "Trust store content is: "

keytool -list -v -keystore "$truststore" -storepass ${storepassword} | grep Alias | cut -d " " -f3- | while read alias 
do
   expiry=`keytool -list -v -keystore "$truststore" -storepass ${storepassword} -alias "${alias}" | grep Valid | perl -ne 'if(/until: (.*?)\n/) { print "$1\n"; }'`
   echo " Certificate ${alias} expires in '$expiry'" 
done

Utilizzalo keystore nel tuo programma impostando le seguenti proprietà di sistema nell'applicazione prima di effettuare una connessione al cluster Amazon DocumentDB.
```
javax.net.ssl.trustStore: <truststore>
javax.net.ssl.trustStorePassword: <truststorePassword>
```

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando Java TLS quando è abilitato.


package com.example.documentdb;

import com.mongodb.client.*;
import org.bson.Document;

public final class Test {
    private Test() {
    }
    public static void main(String[] args) {

        String template = "mongodb://%s:%s@%s/sample-database?ssl=true&replicaSet=rs0&readpreference=%s";
        String username = "<sample-user>";
        String password = "<password>";
        String clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
        String readPreference = "secondaryPreferred";
        String connectionString = String.format(template, username, password, clusterEndpoint, readPreference);

        String truststore = "<truststore>";
        String truststorePassword = "<truststorePassword>";

        System.setProperty("javax.net.ssl.trustStore", truststore);
        System.setProperty("javax.net.ssl.trustStorePassword", truststorePassword);

        MongoClient mongoClient = MongoClients.create(connectionString);

        MongoDatabase testDB = mongoClient.getDatabase("sample-database");
        MongoCollection<Document> numbersCollection = testDB.getCollection("sample-collection");

        Document doc = new Document("name", "pi").append("value", 3.14159);
        numbersCollection.insertOne(doc);

        MongoCursor<Document> cursor = numbersCollection.find().iterator();
        try {
            while (cursor.hasNext()) {
                System.out.println(cursor.next().toJson());
            }
        } finally {
            cursor.close();
        }

    }
}

C# / .NET

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando C#/. NETquando è abilitatoTLS.


using System;
using System.Text;
using System.Linq;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Net.Security;
using MongoDB.Driver;
using MongoDB.Bson;

namespace DocDB
{
    class Program
    {
        static void Main(string[] args)
        {
            string template = "mongodb://{0}:{1}@{2}/sampledatabase?tls=true&replicaSet=rs0&readpreference={3}";
            string username = "<sample-user>";
            string password = "<password>";
            string readPreference = "secondaryPreferred";
            string clusterEndpoint="sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
            string connectionString = String.Format(template, username, password, clusterEndpoint, readPreference);
            
            string pathToCAFile = "<PATH/global-bundle.p7b_file>";

            // ADD CA certificate to local trust store
            // DO this once - Maybe when your service starts
            X509Store localTrustStore = new X509Store(StoreName.Root);
            X509Certificate2Collection certificateCollection = new X509Certificate2Collection();
            certificateCollection.Import(pathToCAFile);
            try 
            {
                localTrustStore.Open(OpenFlags.ReadWrite);
                localTrustStore.AddRange(certificateCollection);
            } 
            catch (Exception ex) 
            {
                Console.WriteLine("Root certificate import failed: " + ex.Message);
                throw;
            } 
            finally 
            {
                localTrustStore.Close();
            }

            var settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));
            var client = new MongoClient(settings);

            var database = client.GetDatabase("sampledatabase");
            var collection = database.GetCollection<BsonDocument>("samplecollection");
            var docToInsert = new BsonDocument { { "pi", 3.14159 } };
            collection.InsertOne(docToInsert);
        }
    }
}

mongo shell

Il codice seguente mostra come connettersi e interrogare Amazon DocumentDB utilizzando la shell TLS mongo quando è abilitata.

Connect ad Amazon DocumentDB con la shell mongo. Se utilizzi una versione mongo shell precedente alla 4.2, usa il seguente codice per connetterti.
```
mongo --ssl --host sample-cluster.node.us-east-1.docdb.amazonaws.com:27017 --sslCAFile global-bundle.pem --username <sample-user> --password <password>
```
Se stai usando una versione uguale o superiore alla 4.2, usa il seguente codice per connetterti. Le scritture riutilizzabili non sono supportate in AWS DocumentDB. Se state usando la vecchia mongo shell (non mongosh), non includete il comando in nessuna stringa di codice. retryWrites=false Per impostazione predefinita, le scritture riutilizzabili sono disabilitate. L'inclusione retryWrites=false potrebbe causare un errore nei normali comandi di lettura.
```
mongo --tls --host sample-cluster.node.us-east-1.docdb.amazonaws.com:27017 --tlsCAFile global-bundle.pem --username <sample-user> --password <password>
```

Inserire un singolo documento.


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

Trovare il documento precedentemente inserito.


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

R

Il codice seguente mostra come connettersi ad Amazon DocumentDB con R utilizzando mongolite https://jeroen.github.io/mongolite/ () quando è abilitato. TLS


#Include the mongolite library.
library(mongolite)

mongourl <- paste("mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/test2?ssl=true&",
          "readPreference=secondaryPreferred&replicaSet=rs0", sep="")
          
#Create a MongoDB client, open a connection to Amazon DocumentDB as a replica
#   set and specify the read preference as secondary preferred
client <-  mongo(url = mongourl, options = ssl_options(weak_cert_validation = F, ca ="<PATH/global-bundle.pem>"))

#Insert a single document
str <- c('{"hello" : "Amazon DocumentDB"}')
client$insert(str)

#Find the document that was previously written
client$find()

Ruby

Il codice seguente mostra come connettersi ad Amazon DocumentDB con Ruby TLS quando è abilitato.


require 'mongo'
require 'neatjson'
require 'json'
client_host = 'mongodb://sample-cluster.node.us-east-1.docdb.amazonaws.com:27017'
client_options = {
   database: 'test',
   replica_set: 'rs0',
   read: {:secondary_preferred => 1},
   user: '<sample-user>',
   password: '<password>',
   ssl: true,
   ssl_verify: true,
   ssl_ca_cert: <'PATH/global-bundle.pem'>,
   retry_writes: false
}


begin
   ##Create a MongoDB client, open a connection to Amazon DocumentDB as a
   ##   replica set and specify the read preference as secondary preferred
   client = Mongo::Client.new(client_host, client_options)
   
   ##Insert a single document
   x = client[:test].insert_one({"hello":"Amazon DocumentDB"})
   
   ##Find the document that was previously written
   result = client[:test].find()
   
   #Print the document
   result.each do |document|
      puts JSON.neat_generate(document)
   end
end

#Close the connection
client.close

Connessione con disabilitato TLS

Per visualizzare un esempio di codice per la connessione programmatica a un cluster Amazon TLS DocumentDB disattivato, scegli la scheda relativa alla lingua che desideri utilizzare.

Python

Il codice seguente mostra come connettersi ad Amazon DocumentDB usando TLS Python quando è disabilitato.


## Create a MongoDB client, open a connection to Amazon DocumentDB as a replica set and specify the read preference as secondary preferred 
                    
import pymongo
import sys

client = pymongo.MongoClient('mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/?replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')

##Specify the database to be used
db = client.sample_database

##Specify the collection to be used
col = db.sample_collection

##Insert a single document
col.insert_one({'hello':'Amazon DocumentDB'})

##Find the document that was previously written
x = col.find_one({'hello':'Amazon DocumentDB'})

##Print the result to the screen
print(x)

##Close the connection
client.close()

Node.js

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando Node.js TLS quando è disabilitato.


var MongoClient = require('mongodb').MongoClient;
                  
//Create a MongoDB client, open a connection to Amazon DocumentDB as a replica set,
//  and specify the read preference as secondary preferred
var client = MongoClient.connect(
'mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database?replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false', 
{ 
  useNewUrlParser: true
},

function(err, client) {
    if(err)
        throw err;
    //Specify the database to be used
    db = client.db('sample-database');
    
    //Specify the collection to be used
    col = db.collection('sample-collection');

    //Insert a single document
    col.insertOne({'hello':'Amazon DocumentDB'}, function(err, result){
      //Find the document that was previously written
      col.findOne({'hello':'Amazon DocumentDB'}, function(err, result){
        //Print the result to the screen
        console.log(result);
        
        //Close the connection
        client.close()
      });
   });
});

PHP

Il codice seguente mostra come connettersi ad Amazon DocumentDB PHP utilizzando TLS when è disabilitato.


<?php
//Include Composer's autoloader
require 'vendor/autoload.php';

//Create a MongoDB client and open connection to Amazon DocumentDB
$client = new MongoDB\Client("mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/?retryWrites=false");

//Specify the database and collection to be used
$col = $client->sampledatabase->samplecollection;

//Insert a single document
$result = $col->insertOne( [ 'hello' => 'Amazon DocumentDB'] );

//Find the document that was previously written
$result = $col->findOne(array('hello' => 'Amazon DocumentDB'));

//Print the result to the screen
print_r($result);
?>

Go

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando Go TLS quando è disabilitato.


package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

const (
	// Timeout operations after N seconds
	connectTimeout  = 5
	queryTimeout    = 30
	username        = "<sample-user>"
	password        = "<password>"
	clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017"
	
	// Which instances to read from
	readPreference           = "secondaryPreferred"
	connectionStringTemplate = "mongodb://%s:%s@%s/sample-database?replicaSet=rs0&readpreference=%s"
)

func main() {

	connectionURI := fmt.Sprintf(connectionStringTemplate, username, password, clusterEndpoint, readPreference)

	client, err := mongo.NewClient(options.Client().ApplyURI(connectionURI))
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}

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

	err = client.Connect(ctx)
	if err != nil {
		log.Fatalf("Failed to connect to cluster: %v", err)
	}

	// Force a connection to verify our connection string
	err = client.Ping(ctx, nil)
	if err != nil {
		log.Fatalf("Failed to ping cluster: %v", err)
	}

	fmt.Println("Connected to DocumentDB!")

	collection := client.Database("sample-database").Collection("sample-collection")

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

	res, err := collection.InsertOne(ctx, bson.M{"name": "pi", "value": 3.14159})
	if err != nil {
		log.Fatalf("Failed to insert document: %v", err)
	}

	id := res.InsertedID
	log.Printf("Inserted document ID: %s", id)

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

	cur, err := collection.Find(ctx, bson.D{})

	if err != nil {
		log.Fatalf("Failed to run find query: %v", err)
	}
	defer cur.Close(ctx)

	for cur.Next(ctx) {
		var result bson.M
		err := cur.Decode(&result)
		log.Printf("Returned: %v", result)

		if err != nil {
			log.Fatal(err)
		}
	}

	if err := cur.Err(); err != nil {
		log.Fatal(err)
	}

}

Java

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando Java TLS quando è disabilitato.


package com.example.documentdb;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.ServerAddress;
import com.mongodb.MongoException;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;
import org.bson.Document;


public final class Main {
    private Main() {
    }
    public static void main(String[] args) {

        String template = "mongodb://%s:%s@%s/sample-database?replicaSet=rs0&readpreference=%s";
        String username = "<sample-user>";
        String password = "<password>";
        String clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
        String readPreference = "secondaryPreferred";
        String connectionString = String.format(template, username, password, clusterEndpoint, readPreference);

        MongoClientURI clientURI = new MongoClientURI(connectionString);
        MongoClient mongoClient = new MongoClient(clientURI);

        MongoDatabase testDB = mongoClient.getDatabase("sample-database");
        MongoCollection<Document> numbersCollection = testDB.getCollection("sample-collection");

        Document doc = new Document("name", "pi").append("value", 3.14159);
        numbersCollection.insertOne(doc);

        MongoCursor<Document> cursor = numbersCollection.find().iterator();
        try {
            while (cursor.hasNext()) {
                System.out.println(cursor.next().toJson());
            }
        } finally {
            cursor.close();
        }

    }
}

C# / .NET

Il codice seguente mostra come connettersi ad Amazon DocumentDB utilizzando C#/. NETquando è disabilitatoTLS.


using System;
using System.Text;
using System.Linq;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Net.Security;
using MongoDB.Driver;
using MongoDB.Bson;

namespace CSharpSample
{
   class Program
    {
       static void Main(string[] args)
        {
           string template = "mongodb://{0}:{1}@{2}/sampledatabase?replicaSet=rs0&readpreference={3}";
           string username = "<sample-user>";
           string password = "<password>";
           string clusterEndpoint = "sample-cluster.node.us-east-1.docdb.amazonaws.com:27017";
           string readPreference = "secondaryPreferred";
           string connectionString = String.Format(template, username, password, clusterEndpoint, readPreference);

           var settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));
           var client = new MongoClient(settings);

           var database = client.GetDatabase("sampledatabase");
           var collection = database.GetCollection<BsonDocument>("samplecollection");
           var docToInsert = new BsonDocument { { "pi", 3.14159 } };
            collection.InsertOne(docToInsert);
        }
    }
}

mongo shell

Il codice seguente mostra come connettersi e interrogare Amazon DocumentDB utilizzando la shell TLS mongo quando è disabilitata.

Connect ad Amazon DocumentDB con la shell mongo.


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

Inserire un singolo documento.


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

Trovare il documento precedentemente inserito.


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

R

Il codice seguente mostra come connettersi ad Amazon DocumentDB con R utilizzando mongolite https://jeroen.github.io/mongolite/ () quando è disabilitato. TLS


#Include the mongolite library.
library(mongolite)
               
#Create a MongoDB client, open a connection to Amazon DocumentDB as a replica
#   set and specify the read preference as secondary preferred
client <- mongo(url = "mongodb://<sample-user>:<password>@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database?readPreference=secondaryPreferred&replicaSet=rs0")

##Insert a single document
str <- c('{"hello" : "Amazon DocumentDB"}')
client$insert(str)

##Find the document that was previously written
client$find()

Ruby

Il codice seguente mostra come connettersi ad Amazon DocumentDB con Ruby TLS quando è disabilitato.


require 'mongo'
require 'neatjson'
require 'json'
client_host = 'mongodb://sample-cluster.node.us-east-1.docdb.amazonaws.com:27017'
client_options = {
   database: 'test',
   replica_set: 'rs0',
   read: {:secondary_preferred => 1},
   user: '<sample-user>',
   password: '<password>',
   retry_writes: false
}
               
begin
   ##Create a MongoDB client, open a connection to Amazon DocumentDB as a
   ##   replica set and specify the read preference as secondary preferred
   client = Mongo::Client.new(client_host, client_options)
   
   ##Insert a single document
   x = client[:test].insert_one({"hello":"Amazon DocumentDB"})
   
   ##Find the document that was previously written
   result = client[:test].find()
   
   #Print the document
   result.each do |document|
      puts JSON.neat_generate(document)
   end
end

#Close the connection
client.close

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Sviluppo con Amazon DocumentDB

Utilizzo dei flussi di modifica

Connessione programmatica ad Amazon DocumentDB

Argomenti

Determinazione del valore del tls parametro

Nota

TLSConnessione con abilitato

Nota

Connessione con disabilitato TLS

Determinazione del valore del `tls` parametro