Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Connexion par programmation à Amazon DocumentDB
Cette section contient des exemples de code qui montrent comment se connecter à Amazon DocumentDB (compatible avec MongoDB) en utilisant plusieurs langages différents. Les exemples sont séparés en deux sections selon que vous choisissez de vous connecter à un cluster ayant le protocole TLS (Transport Layer Security) activé ou désactivé. Par défaut, le protocole TLS est activé sur les clusters Amazon DocumentDB. Cependant, vous pouvez désactiver TLS si vous le souhaitez. Pour de plus amples informations, veuillez consulter [chiffrement des données en transit](security.encryption.ssl.md).
Si vous tentez de vous connecter à votre Amazon DocumentDB depuis l'extérieur du VPC dans lequel réside votre cluster, veuillez consulter [Connexion à un cluster Amazon DocumentDB depuis l'extérieur d'un Amazon VPC](connect-from-outside-a-vpc.md).
Avant de vous connecter à votre cluster, vous devez savoir si TLS est activé sur celui-ci. La section suivante vous montre comment déterminer la valeur du paramètre `tls` de votre cluster à l'aide de la AWS Management Console ou de l' AWS CLI. Ensuite, vous pouvez continuer en recherchant et en appliquant l'exemple de code approprié.
**Topics**
+ [Déterminer la valeur de votre `tls` paramètre](#connect_programmatically-determine_tls_value)
+ [Connexion avec TLS activé](#connect_programmatically-tls_enabled)
+ [Connexion avec TLS désactivé](#connect_programmatically-tls_disabled)
## Déterminer la valeur de votre `tls` paramètre
Déterminer si le protocole TLS est activé sur votre cluster est un processus en deux étapes que vous pouvez effectuer à l'aide du AWS Management Console ou. AWS CLI
1. **Déterminez quel groupe de paramètres régit votre cluster.**
------
#### [ Using the AWS Management Console ]
1. [Connectez-vous à la AWS Management Console console Amazon DocumentDB et ouvrez-la à https://console.aws.amazon.com l'adresse /docdb.](https://console.aws.amazon.com/docdb)
1. Dans le volet de navigation de gauche, choisissez **Clusters**.
1. Dans la liste des clusters, sélectionnez le nom de votre cluster.
1. La page qui s'affiche répertorie les détails du cluster sélectionné. Sélectionnez l’onglet **Configuration**. Dans la section **Configurations et état**, recherchez le nom du groupe de paramètres sous **Groupe de paramètres du cluster**.
------
#### [ Using the AWS CLI ]
Le AWS CLI code suivant détermine le paramètre qui régit votre cluster. Assurez-vous de remplacer *`sample-cluster`* par le nom de votre cluster.
```
aws docdb describe-db-clusters \
--db-cluster-identifier sample-cluster \
--query 'DBClusters[*].[DBClusterIdentifier,DBClusterParameterGroup]'
```
Le résultat de cette opération ressemble à ce qui suit :
```
[
[
"sample-cluster",
"sample-parameter-group"
]
]
```
------
1. **Déterminez la valeur du paramètre `tls` dans le groupe de paramètres de votre cluster.**
------
#### [ Using the AWS Management Console ]
1. Dans le panneau de navigation, choisissez **Groupes de paramètres**.
1. Dans la fenêtre **Groupes de paramètres de cluster**, sélectionnez le nom de votre groupe de paramètres de cluster à l'étape 1d.
1. La page résultante affiche les paramètres de votre groupe de paramètres de cluster. Ici, vous pouvez voir la valeur du paramètre `tls`. Pour plus d'informations sur la modification de ce paramètre, veuillez consulter [Modification des groupes de paramètres du cluster Amazon DocumentDB](cluster_parameter_groups-modify.md).
------
#### [ Using the AWS CLI ]
Vous pouvez utiliser la `describe-db-cluster-parameters` AWS CLI commande pour afficher les détails des paramètres de votre groupe de paramètres de cluster.
+ **`--describe-db-cluster-parameters`**— Pour répertorier tous les paramètres d'un groupe de paramètres et leurs valeurs.
+ **`--db-cluster-parameter-group name`** — Obligatoire. Nom de votre groupe de paramètres de cluster.
Dans les exemples suivants, remplacez chacun *user input placeholder* par les informations de votre cluster.
```
aws docdb describe-db-cluster-parameters \
--db-cluster-parameter-group-name sample-parameter-group
```
Le résultat de cette opération ressemble à ce qui suit :
```
{
"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"
}
]
}
```
**Note**
Amazon DocumentDB prend en charge les points de terminaison FIPS 140-3 à partir des clusters Amazon DocumentDB 5.0 (moteur version 3.0.3727) dans les régions suivantes : ca-central-1, us-west-2, us-east-1, us-east-2, -1, -1. us-gov-east us-gov-west
------
Après avoir déterminé la valeur de votre paramètre `tls`, poursuivez la connexion de votre cluster en utilisant l'un des exemples de code des sections suivantes.
+ [Connexion avec TLS activé](#connect_programmatically-tls_enabled)
+ [Connexion avec TLS désactivé](#connect_programmatically-tls_disabled)
## Connexion avec TLS activé
Pour afficher un exemple de code permettant de se connecter par programmation à un cluster Amazon DocumentDB compatible TLS, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser.
Pour chiffrer les données en transit, téléchargez la clé publique pour Amazon DocumentDB `global-bundle.pem` nommée à l'aide de l'opération suivante.
```
wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem
```
Si votre application fonctionne sous Microsoft Windows et nécessite un PKCS7 fichier, vous pouvez télécharger le bundle de PKCS7 certificats. Ce bundle contient à la fois les certificats intermédiaires et racines sur [https://truststore.pki.rds.amazonaws.com/global/global-bundle.p7b](https://truststore.pki.rds.amazonaws.com/global/global-bundle.p7b).
------
#### [ Python ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Python lorsque le protocole TLS est activé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Node.js lorsque le protocole TLS est activé.
**Important**
Il existe une limitation connue concernant les pilotes Node.js antérieurs à la version 6.13.1, qui ne sont actuellement pas pris en charge par l'authentification d'identité IAM pour Amazon DocumentDB. Les pilotes et outils Node.js qui utilisent le pilote Node.js (par exemple, Mongosh) doivent être mis à niveau pour utiliser le pilote Node.js version 6.13.1 ou supérieure.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de PHP lorsque le protocole TLS est activé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
"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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Go lorsque le protocole TLS est activé.
**Note**
À partir de la version 1.2.1, le pilote MongoDB Go n'utilisera que le premier certificat de serveur CA trouvé dans `sslcertificateauthorityfile`. L'exemple de code ci-dessous corrige cette limitation en ajoutant manuellement tous les certificats de serveur présents dans `sslcertificateauthorityfile` à une configuration TLS personnalisée utilisée lors de la création du client.
Dans les exemples suivants, remplacez chacun *user input placeholder* par les informations de votre cluster.
```
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 ]
Lorsque vous vous connectez à un cluster Amazon DocumentDB compatible TLS depuis une application Java, votre programme doit utiliser AWS le fichier d'autorité de certification (CA) fourni pour valider la connexion. Pour utiliser le certificat Amazon RDS CA, procédez comme suit :
1. Téléchargez le fichier Amazon RDS CA depuis [https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem).
1. Créez un référentiel d'approbations avec le certificat d'autorité de certification (CA) contenu dans le fichier en exécutant les commandes suivantes. Assurez-vous de le *truststore-password* remplacer par autre chose. Si vous accédez à un référentiel d'approbations qui contient à la fois l'ancien certificat d'autorité de certification (`rds-ca-2015-root.pem`) et le nouveau certificat d'autorité de certification (`rds-ca-2019-root.pem`), vous pouvez importer le bundle de certificats dans le référentiel d'approbations.
Voici un exemple de scripting shell qui importe le lot de certificats vers un magasin d'approbations sur un système d'exploitation Linux. Dans les exemples suivants, remplacez chacune *user input placeholder * par vos propres informations. Plus particulièrement, chaque fois que le répertoire d'exemple *mydir* « » se trouve dans le script, remplacez-le par un répertoire que vous avez créé pour cette tâche.
```
mydir=/tmp/certs
truststore=${mydir}/rds-truststore.jks
storepassword=truststore-password
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
```
Voici un exemple de scripting shell qui importe le lot de certificats vers un magasin d'approbations sur macOS.
```
mydir=/tmp/certs
truststore=${mydir}/rds-truststore.jks
storepassword=truststore-password
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
```
1. Utilisez-le `keystore` dans votre programme en définissant les propriétés système suivantes dans votre application avant d'établir une connexion au cluster Amazon DocumentDB.
```
javax.net.ssl.trustStore: truststore
javax.net.ssl.trustStorePassword: truststore-password;
```
1. Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Java lorsque le protocole TLS est activé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 = "truststore-password";
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 numbersCollection = testDB.getCollection("sample-collection");
Document doc = new Document("name", "pi").append("value", 3.14159);
numbersCollection.insertOne(doc);
MongoCursor cursor = numbersCollection.find().iterator();
try {
while (cursor.hasNext()) {
System.out.println(cursor.next().toJson());
}
} finally {
cursor.close();
}
}
}
```
------
#### [ C\$1 / .NET ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de C\$1/.NET lorsque le protocole TLS est activé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 = "";
// 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("samplecollection");
var docToInsert = new BsonDocument { { "pi", 3.14159 } };
collection.InsertOne(docToInsert);
}
}
}
```
------
#### [ MongoDB Shell ]
Le code suivant montre comment se connecter à Amazon DocumentDB et l'interroger à l'aide de la version la plus récente, mongosh, ou de la version précédente du shell mongo, lorsque le protocole TLS est activé.
**Connectez-vous à Amazon DocumentDB avec Mongosh**
**Important**
Il existe une limitation connue concernant les pilotes Node.js antérieurs à la version 6.13.1, qui ne sont actuellement pas pris en charge par l'authentification d'identité IAM pour Amazon DocumentDB. Les pilotes et outils Node.js qui utilisent le pilote Node.js (par exemple, Mongosh) doivent être mis à niveau pour utiliser le pilote Node.js version 6.13.1 ou supérieure.
Dans les exemples suivants, remplacez chacun *user input placeholder* par les informations de votre cluster.
```
mongosh --tls --host cluster-end-point:27017 --tlsCAFile global-bundle.pem --username sample-user --password password --retryWrites false
```
**Connectez-vous à Amazon DocumentDB avec la version précédente du shell mongo**
Si vous utilisez IAM, vous devez utiliser une version précédente de mongo shell. Entrez l'une des options de commande suivantes :
```
mongo --ssl --host cluster-end-point:27017 --sslCAFile global-bundle.pem --username sample-user --password password
```
Si vous utilisez une version égale ou supérieure à 4.2, utilisez le code suivant pour vous connecter. Les écritures réessayables ne sont pas prises en charge dans Amazon DocumentDB. Si vous utilisez un ancien shell mongo (et non mongosh), n'incluez la `retryWrites=false` commande dans aucune chaîne de code. Par défaut, les écritures réessayables sont désactivées. L'inclusion `retryWrites=false` peut entraîner un échec des commandes de lecture normales.
```
mongo --tls --host cluster-end-point:27017 --tlsCAFile global-bundle.pem --username sample-user --password password
```
**Testez la connexion**
1. Insérez un document unique.
```
db.myTestCollection.insertOne({'hello':'Amazon DocumentDB'})
```
1. Recherchez le document qui a été inséré précédemment.
```
db.myTestCollection.find({'hello':'Amazon DocumentDB'})
```
------
#### [ R ]
Le code suivant montre comment se connecter à Amazon DocumentDB avec R à l'aide de mongolite ([https://jeroen.github.io/mongolite/](https://jeroen.github.io/mongolite/)) lorsque le protocole TLS est activé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
#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 =""))
#Insert a single document
str <- c('{"hello" : "Amazon DocumentDB"}')
client$insert(str)
#Find the document that was previously written
client$find()
```
------
#### [ Ruby ]
Le code suivant montre comment se connecter à Amazon DocumentDB avec Ruby lorsque le protocole TLS est activé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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
```
------
## Connexion avec TLS désactivé
Pour afficher un exemple de code permettant de se connecter par programmation à un cluster Amazon DocumentDB désactivé par TLS, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser.
------
#### [ Python ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Python lorsque le protocole TLS est désactivé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
## 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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Node.js lorsque le protocole TLS est désactivé.
**Important**
Il existe une limitation connue concernant les pilotes Node.js antérieurs à la version 6.13.1, qui ne sont actuellement pas pris en charge par l'authentification d'identité IAM pour Amazon DocumentDB. Les pilotes et outils Node.js qui utilisent le pilote Node.js (par exemple, Mongosh) doivent être mis à niveau pour utiliser le pilote Node.js version 6.13.1 ou supérieure.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de PHP lorsque le protocole TLS est désactivé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Go lorsque le protocole TLS est désactivé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de Java lorsque le protocole TLS est désactivé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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 numbersCollection = testDB.getCollection("sample-collection");
Document doc = new Document("name", "pi").append("value", 3.14159);
numbersCollection.insertOne(doc);
MongoCursor cursor = numbersCollection.find().iterator();
try {
while (cursor.hasNext()) {
System.out.println(cursor.next().toJson());
}
} finally {
cursor.close();
}
}
}
```
------
#### [ C\$1 / .NET ]
Le code suivant montre comment se connecter à Amazon DocumentDB à l'aide de C\$1/.NET lorsque le protocole TLS est désactivé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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("samplecollection");
var docToInsert = new BsonDocument { { "pi", 3.14159 } };
collection.InsertOne(docToInsert);
}
}
}
```
------
#### [ MongoDB Shell ]
Le code suivant montre comment se connecter à Amazon DocumentDB et l'interroger à l'aide de la version la plus récente, mongosh, ou de la version précédente du shell mongo, lorsque le protocole TLS est désactivé.
**Connectez-vous à Amazon DocumentDB avec Mongosh**
**Important**
Il existe une limitation connue concernant les pilotes Node.js antérieurs à la version 6.13.1, qui ne sont actuellement pas pris en charge par l'authentification d'identité IAM pour Amazon DocumentDB. Les pilotes et outils Node.js qui utilisent le pilote Node.js (par exemple, Mongosh) doivent être mis à niveau pour utiliser le pilote Node.js version 6.13.1 ou supérieure.
Dans les exemples suivants, remplacez chacun *user input placeholder* par les informations de votre cluster.
```
mongosh --host cluster-end-point:27017 --username sample-user --password password --retryWrites false
```
**Connectez-vous à Amazon DocumentDB avec la version précédente du shell mongo**
Si vous utilisez IAM, vous devez utiliser une version précédente de mongo shell. Entrez l'une des options de commande suivantes :
```
mongo --host cluster-end-point:27017 --username sample-user --password password
```
Si vous utilisez une version égale ou supérieure à 4.2, utilisez le code suivant pour vous connecter. Les écritures réessayables ne sont pas prises en charge dans Amazon DocumentDB. Si vous utilisez un ancien shell mongo (et non mongosh), n'incluez la `retryWrites=false` commande dans aucune chaîne de code. Par défaut, les écritures réessayables sont désactivées. L'inclusion `retryWrites=false` peut entraîner un échec des commandes de lecture normales.
```
mongo --host cluster-end-point:27017 --username sample-user --password password
```
**Testez la connexion**
1. Insérez un document unique.
```
db.myTestCollection.insertOne({'hello':'Amazon DocumentDB'})
```
1. Recherchez le document qui a été inséré précédemment.
```
db.myTestCollection.find({'hello':'Amazon DocumentDB'})
```
------
#### [ R ]
Le code suivant montre comment se connecter à Amazon DocumentDB avec R à l'aide de mongolite ([https://jeroen.github.io/mongolite/](https://jeroen.github.io/mongolite/)) lorsque le protocole TLS est désactivé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
#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 ]
Le code suivant montre comment se connecter à Amazon DocumentDB avec Ruby lorsque le protocole TLS est désactivé.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
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
```
------