Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Conexión mediante programación a Amazon DocumentDB
<a name="connect_programmatically"></a>

En esta sección, se incluyen ejemplos de código que demuestran cómo conectarse a Amazon DocumentDB (con compatibilidad con MongoDB) utilizando diferentes lenguajes. Los ejemplos se dividen en dos secciones en función de si se conecta a un clúster que tiene habilitado o deshabilitado Transport Layer Security (TLS). De manera predeterminada, TLS está habilitado para los nuevos clústeres de Amazon DocumentDB. Sin embargo, puede desactivar TLS si lo desea. Para obtener más información, consulte [Cifrado de datos en tránsito](security.encryption.ssl.md). 

Si intenta conectarse a su Amazon DocumentDB desde fuera de la VPC en la que reside el clúster, consulte [Conexión a un clúster de Amazon DocumentDB desde fuera de una Amazon VPC](connect-from-outside-a-vpc.md). 

Antes de conectarse a su clúster, debe saber si TLS está habilitado en él. En la siguiente sección, se muestra cómo determinar el valor del parámetro `tls` del clúster mediante la Consola de administración de AWS o la AWS CLI. A continuación, puede buscar y aplicar el ejemplo de código adecuado.

**Topics**
+ [Determinación del valor del parámetro `tls`](#connect_programmatically-determine_tls_value)
+ [Conexión con TLS habilitado](#connect_programmatically-tls_enabled)
+ [Conexión con TLS deshabilitado](#connect_programmatically-tls_disabled)

## Determinación del valor del parámetro `tls`
<a name="connect_programmatically-determine_tls_value"></a>

Para determinar si el clúster tiene habilitado TLS, hay que seguir un proceso de dos pasos que puede realizar mediante la Consola de administración de AWS o la AWS CLI.

1. **Determine qué grupo de parámetros rige el clúster.**

------
#### [ Using the Consola de administración de AWS ]

   1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon DocumentDB en [https://console.aws.amazon.com/docdb](https://console.aws.amazon.com/docdb).

   1. En el panel de navegación izquierdo, elija **Clusters (Clústeres)**.

   1. En la lista de clústeres, seleccione el nombre del clúster.

   1. La página resultante muestra los detalles del clúster seleccionado. Seleccione la pestaña **Configuración**. En la sección **Configuraciones y estado**, busque el nombre del grupo de parámetros debajo del **Grupo de parámetros del clúster**.

------
#### [ Using the AWS CLI ]

   El siguiente código de la AWS CLI determina qué parámetro rige el clúster. Asegúrese de reemplazar *`sample-cluster`* por el nombre del clúster.

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

   La salida de esta operación será similar a lo que se indica a continuación:

   ```
   [
          [
              "sample-cluster",
              "sample-parameter-group"
          ]
   ]
   ```

------

1. **Determine el valor del parámetro `tls` en el grupo de parámetros del clúster.**

------
#### [ Using the Consola de administración de AWS ]

   1. En el panel de navegación, seleccione **Grupos de parámetros**.

   1. En la ventana **Grupos de parámetros del clúster**, seleccione el nombre del grupo de parámetros del clúster del Paso 1d.

   1. En la página resultante se muestran los parámetros del grupo de parámetros del clúster. Puede ver el valor del parámetro `tls` aquí. Para obtener información sobre la modificación de este parámetro, consulte [Modificación de grupos de parámetros de clúster de Amazon DocumentDB](cluster_parameter_groups-modify.md).

------
#### [ Using the AWS CLI ]

   Puede utilizar el comando de la `describe-db-cluster-parameters` AWS CLI para ver los detalles de los parámetros del grupo de parámetros del clúster.
   + **`--describe-db-cluster-parameters`** — para obtener una lista de los parámetros de un grupo de parámetros, junto con sus valores.
     + **`--db-cluster-parameter-group name`** — obligatorio. El nombre del grupo de parámetros del clúster.

   En los siguientes ejemplos, reemplace cada *marcador de posición del usuario* con la información de su clúster.

   ```
   aws docdb describe-db-cluster-parameters \
       --db-cluster-parameter-group-name sample-parameter-group
   ```

   La salida de esta operación será similar a lo que se indica a continuación: 

   ```
   {
           "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 admite los puntos de conexión FIPS 140-3 a partir de los clústeres con Amazon DocumentDB 5.0 (versión del motor 3.0.3727) en las siguientes regiones: ca-central-1, us-west-2, us-east-1, us-east-2, us-gov-east-1, us-gov-west-1.

------

Después de determinar el valor del parámetro `tls`, continúe conectándose al clúster utilizando uno de los ejemplos de código que se muestran en las siguientes secciones.
+ [Conexión con TLS habilitado](#connect_programmatically-tls_enabled) 
+ [Conexión con TLS deshabilitado](#connect_programmatically-tls_disabled) 

## Conexión con TLS habilitado
<a name="connect_programmatically-tls_enabled"></a>

Para ver un ejemplo de código para conectarse mediante programación a un clúster de Amazon DocumentDB con TLS habilitado, elija la pestaña adecuada al lenguaje que desea utilizar.

Para cifrar datos en tránsito, descargue la clave pública para Amazon DocumentDB denominada `global-bundle.pem` mediante la siguiente operación.

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

Si l aplicación está en Microsoft Windows y requiere un archivo PKCS7, puede descargar el paquete de certificados PKCS7. Este paquete contiene los certificados intermedio y raíz en [ https://truststore.pki.rds.amazonaws.com/global/global-bundle.p7b](https://truststore.pki.rds.amazonaws.com/global/global-bundle.p7b).

------
#### [ Python ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Python cuando TLS está habilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Node.js cuando TLS está habilitado.

**importante**  
Existe una limitación conocida con los controladores de Node.js anteriores a la versión 6.13.1, ya que Amazon DocumentDB no los admite actualmente para la autenticación de identidad de IAM. Los controladores y las herramientas de Node.js que utilizan el controlador Node.js (por ejemplo, mongosh) deben actualizarse para utilizar el controlador Node.js, versión 6.13.1 o posterior.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando PHP cuando TLS está habilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
<?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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Go cuando TLS está habilitado.

**nota**  
A partir de la versión 1.2.1, el controlador de MongoDB Go solo utilizará el primer certificado de servidor de CA que se encuentre en `sslcertificateauthorityfile`. El siguiente código de ejemplo corrige esta limitación anexando manualmente todos los certificados de servidor que se encuentran en `sslcertificateauthorityfile` a una configuración TLS personalizada utilizada durante la creación del cliente. 

En los siguientes ejemplos, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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 ]

Si se conecta a un clúster de Amazon DocumentDB con TLS habilitado desde una aplicación Java, el programa debe utilizar el archivo de la entidad de certificación (CA) proporcionado por AWS para validar la conexión. Para utilizar el certificado de CA de Amazon RDS, haga lo siguiente:

1. Descargue el archivo de CA de Amazon RDS desde [https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem) .

1. Cree un almacén de confianza con el certificado de CA contenido en el archivo utilizando los siguientes comandos. Asegúrese de cambiar *truststore-password* por otra cosa. Si tiene acceso a un almacén de confianza que contiene el certificado de CA antiguo (`rds-ca-2015-root.pem`) y el nuevo certificado de CA (`rds-ca-2019-root.pem`), puede importar el grupo de certificados en el almacén de confianza. 

   A continuación se muestra un ejemplo de script de shell que importa el paquete de certificados a un almacén de confianza en un sistema operativo Linux. En los ejemplos siguientes, reemplace cada *marcador de posición del usuario* con su propia información. En particular, siempre que se encuentre el directorio de ejemplo “*mydir*” en el script, sustitúyalo por un directorio que haya creado para esta tarea.

   ```
   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
   ```

   A continuación se muestra un ejemplo de script de shell que importa el paquete de certificados a un almacén de confianza en 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. Utilice el `keystore` de su programa estableciendo las siguientes propiedades del sistema en la aplicación antes de establecer una conexión con el clúster de Amazon DocumentDB.

   ```
   javax.net.ssl.trustStore: truststore
   javax.net.ssl.trustStorePassword: truststore-password;
   ```

1. El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Java cuando TLS está habilitado.

   En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

   ```
   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<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\$1 / .NET ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando C\$1 / .NET cuando TLS está habilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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);
        }
    }
}
```

------
#### [ MongoDB Shell ]

El siguiente código demuestra cómo conectarse a Amazon DocumentDB y realizar consultas mediante la versión más reciente, mongosh, o la versión anterior del shell de mongo cuando TLS está habilitado.

**Conexión con Amazon DocumentDB con mongosh**

**importante**  
Existe una limitación conocida con los controladores de Node.js anteriores a la versión 6.13.1, ya que Amazon DocumentDB no los admite actualmente para la autenticación de identidad de IAM. Los controladores y las herramientas de Node.js que utilizan el controlador Node.js (por ejemplo, mongosh) deben actualizarse para utilizar el controlador Node.js, versión 6.13.1 o posterior.

En los siguientes ejemplos, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
mongosh --tls --host cluster-end-point:27017 --tlsCAFile  global-bundle.pem --username sample-user --password password --retryWrites false
```

**Conexión con Amazon DocumentDB con la versión anterior del shell de mongo**

Si usa IAM, debe usar una versión anterior del shell de mongo. Introduzca una de las siguientes opciones de comando:

```
mongo --ssl --host cluster-end-point:27017 --sslCAFile global-bundle.pem --username sample-user --password password
```

Si utiliza una versión igual o superior a la 4.2, utilice el siguiente código para conectarse. Amazon DocumentDB no admite el reintento de las escrituras. Si utiliza el shell de mongo heredado (no mongosh), no incluya el comando `retryWrites=false` en ninguna cadena de código. El reintento de las escrituras está desactivado de forma predeterminada. Incluir `retryWrites=false` podría provocar un error en comandos de lectura normales.

```
mongo --tls --host cluster-end-point:27017 --tlsCAFile global-bundle.pem --username sample-user --password password
```

**Pruebe la conexión**

1. Insertar un documento.

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

1. Busque el documento que ha insertado anteriormente.

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

------
#### [ R ]

En el siguiente código, se muestra cómo conectarse a Amazon DocumentDB con R usando mongolite ([https://jeroen.github.io/mongolite/](https://jeroen.github.io/mongolite/)) cuando TLS está habilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
#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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB con Ruby cuando TLS está habilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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
```

------

## Conexión con TLS deshabilitado
<a name="connect_programmatically-tls_disabled"></a>

Para ver un ejemplo de código para conectarse mediante programación a un clúster de Amazon DocumentDB con TLS deshabilitado, elija la pestaña del lenguaje que desea utilizar.

------
#### [ Python ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Python cuando TLS está deshabilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
## 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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Node.js cuando TLS está deshabilitado.

**importante**  
Existe una limitación conocida con los controladores de Node.js anteriores a la versión 6.13.1, ya que Amazon DocumentDB no los admite actualmente para la autenticación de identidad de IAM. Los controladores y las herramientas de Node.js que utilizan el controlador Node.js (por ejemplo, mongosh) deben actualizarse para utilizar el controlador Node.js, versión 6.13.1 o posterior.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando PHP cuando TLS está deshabilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
<?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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Go cuando TLS está deshabilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando Java cuando TLS está deshabilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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\$1 / .NET ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB utilizando C\$1 / .NET cuando TLS está deshabilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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);
        }
    }
}
```

------
#### [ MongoDB Shell ]

El siguiente código demuestra cómo conectarse a Amazon DocumentDB y realizar consultas mediante la versión más reciente, mongosh, o la versión anterior del shell de mongo cuando TLS está deshabilitado.

**Conexión con Amazon DocumentDB con mongosh**

**importante**  
Existe una limitación conocida con los controladores de Node.js anteriores a la versión 6.13.1, ya que Amazon DocumentDB no los admite actualmente para la autenticación de identidad de IAM. Los controladores y las herramientas de Node.js que utilizan el controlador Node.js (por ejemplo, mongosh) deben actualizarse para utilizar el controlador Node.js, versión 6.13.1 o posterior.

En los siguientes ejemplos, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
mongosh --host cluster-end-point:27017 --username sample-user --password password --retryWrites false
```

**Conexión con Amazon DocumentDB con la versión anterior del shell de mongo**

Si usa IAM, debe usar una versión anterior del shell de mongo. Introduzca una de las siguientes opciones de comando:

```
mongo --host cluster-end-point:27017 --username sample-user --password password
```

Si utiliza una versión igual o superior a la 4.2, utilice el siguiente código para conectarse. Amazon DocumentDB no admite el reintento de las escrituras. Si utiliza el shell de mongo heredado (no mongosh), no incluya el comando `retryWrites=false` en ninguna cadena de código. El reintento de las escrituras está desactivado de forma predeterminada. Incluir `retryWrites=false` podría provocar un error en comandos de lectura normales.

```
mongo --host cluster-end-point:27017 --username sample-user --password password
```

**Pruebe la conexión**

1. Insertar un documento.

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

1. Busque el documento que ha insertado anteriormente.

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

------
#### [ R ]

En el siguiente código, se muestra cómo conectarse a Amazon DocumentDB con R usando mongolite ([https://jeroen.github.io/mongolite/](https://jeroen.github.io/mongolite/)) cuando TLS está deshabilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
#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 ]

El código siguiente demuestra cómo conectarse a Amazon DocumentDB con Ruby cuando TLS está deshabilitado.

En el siguiente ejemplo, reemplace cada *marcador de posición del usuario* con la información de su clúster.

```
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
```

------