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.
# Desarrollo de Amazon DocumentDB
En estas secciones se explica la implementación mediante Amazon DocumentDB.
**Topics**
+ [Conexión a DocumentDB](connect-docdb.md)
+ [Programación con DocumentDB](program-docdb.md)
# Conexión a Amazon DocumentDB
Amazon DocumentDB ofrece varias opciones de conexión, incluidas las conexiones programáticas mediante controladores MongoDB, la conexión desde fuera de una VPC mediante túneles SSH o una VPN de AWS, y herramientas populares como Studio 3T y DataGrip. El servicio admite conexiones de conjuntos de réplicas para una alta disponibilidad. Para el análisis y la elaboración de informes, puede conectarse mediante controladores JDBC u ODBC. Las instancias de EC2 de la misma VPC pueden conectarse directamente a los clústeres de DocumentDB. Todas las conexiones requieren TLS y credenciales/autenticación de AWS adecuadas.
**Topics**
+ [Conexión mediante programación](connect_programmatically.md)
+ [Conexión desde fuera de una Amazon VPC](connect-from-outside-a-vpc.md)
+ [Conexión como conjunto de réplicas](connect-to-replica-set.md)
+ [Conexión mediante Studio 3T](studio3t.md)
+ [Conexión mediante DataGrip](data-grip-connect.md)
+ [Conectarse mediante Amazon EC2](connect-ec2.md)
+ [Conexión mediante el controlador JDBC](connect-jdbc.md)
+ [Conexión mediante el controlador ODBC](connect-odbc.md)
# Conexión mediante programación a Amazon DocumentDB
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`
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
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.
```
"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 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 ]
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 = "";
// 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 ]
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 =""))
#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
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.
```
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 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 ]
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("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
```
------
# Conexión a un clúster de Amazon DocumentDB desde fuera de una Amazon VPC
Los clústeres de Amazon DocumentDB (con compatibilidad con MongoDB) se implementan en una instancia de Amazon Virtual Private Cloud (Amazon VPC). Se puede obtener acceso a ellos directamente mediante instancias de Amazon EC2 u otros servicios de AWS que se implementen en la misma Amazon VPC. Además, es posible obtener acceso a Amazon DocumentDB mediante instancias EC2 u otros servicios de AWS en diferentes VPC de la misma región de Región de AWS u otras regiones a través de la interconexión de VPC.
Sin embargo, supongamos que su caso de uso requiere que usted o su aplicación tengan acceso a los recursos de Amazon DocumentDB desde fuera de la VPC del clúster. En ese caso, puede utilizar la tunelización SSH (denominada también *reenvío de puertos*) para obtener acceso a sus recursos de Amazon DocumentDB.
La descripción detallada de la tunelización SSH queda fuera del alcance de este tema. Si desea obtener más información sobre la tunelización SSH, consulte los siguientes temas:
+ [Túnel SSH](https://www.ssh.com/ssh/tunneling/)
+ [SSH Port Forwarding Example](https://www.ssh.com/ssh/tunneling/example), en concreto la sección [ Local Forwarding](https://www.ssh.com/ssh/tunneling/example#sec-Local-Forwarding)
Para crear un túnel SSH, necesita una instancia de Amazon EC2 que se ejecute en la misma VPC de Amazon que el clúster de Amazon DocumentDB. Puede usar una instancia EC2 existente en la misma VPC que el clúster o crear una. Para obtener más información, consulte el tema correspondiente a su sistema operativo:
+ [Introducción a las instancias Linux de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html)
+ [Introducción a las instancias de Windows de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html)
Es posible que normalmente se conecte a una instancia EC2 con el siguiente comando:
```
ssh -i "ec2Access.pem" ubuntu@ec2-34-229-221-164.compute-1.amazonaws.com
```
Si es así, puede configurar un túnel de SSH en el clúster de Amazon DocumentDB `sample-cluster.node.us-east-1.docdb.amazonaws.com` ejecutando el siguiente comando en el equipo local. La marca `-L` se utiliza para el reenvío de un puerto local. Cuando utilice un túnel SSH, es recomendable que se conecte al clúster utilizando el punto de conexión de dicho clúster y que no intente conectarse utilizando el modo de conjunto de réplicas (es decir, especificando `replicaSet=rs0` en la cadena de conexión), ya que dará lugar a un error.
```
ssh -i "ec2Access.pem" -L 27017:sample-cluster.node.us-east-1.docdb.amazonaws.com:27017 ubuntu@ec2-34-229-221-164.compute-1.amazonaws.com -N
```
Una vez creado el túnel SSH, cualquier comando que envíe a `localhost:27017` se reenvía al clúster de Amazon DocumentDB `sample-cluster` que se ejecuta en la VPC de Amazon. Si la seguridad de la capa de transporte (TLS) está habilitada en el clúster de Amazon DocumentDB, tiene que descargar la clave pública de Amazon DocumentDB desde [https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem) . La siguiente operación descarga este archivo:
```
wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem
```
**nota**
TLS está habilitado de forma predeterminada para los nuevos clústeres de Amazon DocumentDB. No obstante, sí puede deshabilitarlo. Para obtener más información, consulte [Administración de la configuración de TLS del clúster de Amazon DocumentDB](security.encryption.ssl.md#security.encryption.ssl.managing).
Para conectarse a su clúster de Amazon DocumentDB desde fuera de Amazon VPC, utilice el comando siguiente.
```
mongo --sslAllowInvalidHostnames --ssl --sslCAFile global-bundle.pem --username --password
```
# Conexión a Amazon DocumentDB como conjunto de réplicas
Cuando desarrolle en Amazon DocumentDB (con compatibilidad con MongoDB), recomendamos que se conecte al clúster como conjunto de réplicas y distribuya las lecturas a las instancias de réplica mediante las funciones integradas de preferencias de lectura del controlador. En esta sección se profundiza en lo que esto significa y se describe cómo conectarse al clúster de Amazon DocumentDB como conjunto de réplicas con el SDK para Python como ejemplo.
Amazon DocumentDB tiene tres puntos de conexión que puede utilizar para conectarse al clúster:
+ Punto de conexión de clúster
+ Punto de conexión del lector
+ Puntos de conexión de instancia
En la mayoría de los casos, cuando se conecte a Amazon DocumentDB, recomendamos que utilice el punto de conexión de clúster. Se trata de un CNAME que apunta a la instancia principal del clúster, tal y como se muestra en el siguiente diagrama.
Cuando utilice un túnel SSH, es recomendable que se conecte al clúster utilizando el punto de conexión de dicho clúster y que no intente conectarse utilizando el modo de conjunto de réplicas (es decir, especificando `replicaSet=rs0` en la cadena de conexión), ya que dará lugar a un error.
**nota**
Para obtener más información acerca de los puntos de conexión de sitio web de Amazon DocumentDB, consulte [Puntos de conexión de Amazon DocumentDB](how-it-works.md#how-it-works.endpoints).
![\[Diagrama que muestra los puntos de conexión Amazon DocumentDB, incluidos los puntos de conexión de clúster, lector e instancia.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/docdb-endpoint-types.png)
Con el punto de conexión de clúster, puede conectarse al clúster en modo de conjunto de réplicas. A continuación, puede utilizar las funciones integradas del controlador de preferencias de lectura. En el siguiente ejemplo, al especificar `/?replicaSet=rs0`, el SDK entiende que desea conectarse como conjunto de réplicas. Si omite `/?replicaSet=rs0'`, el cliente dirige todas las solicitudes al punto de conexión de clúster, es decir, la instancia principal.
```
## 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://:@mycluster.node.us-east-1.docdb.amazonaws.com:27017/?replicaSet=rs0')
```
La ventaja de conectarse como conjunto de réplicas es que permite al SDK detectar automáticamente la topografía del clúster, lo que incluye cuándo se añaden o se eliminan instancias del clúster. Posteriormente, puede utilizar el clúster de forma más eficiente dirigiendo las solicitudes de lectura a las instancias de réplica.
Cuando se conecta como conjunto de réplicas, puede especificar la `readPreference` para la conexión. Si especifica una preferencia de lectura de `secondaryPreferred`, el cliente dirige las consultas de lectura a las réplicas y las consultas de escritura, a la instancia principal (como en el siguiente diagrama). Así, se aprovechan mejor los recursos del clúster. Para obtener más información, consulte [Opciones de preferencia de lectura](how-it-works.md#durability-consistency-isolation).
```
## 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://:@mycluster.node.us-east-1.docdb.amazonaws.com:27017/?replicaSet=rs0&readPreference=secondaryPreferred')
```
![\[Diagrama que muestra readPreference de Amazon DocumentDB: secondaryPreferred.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/docdb-readPreference-secondaryPreferred.png)
Las lecturas de las réplicas de Amazon DocumentDB presentan consistencia final. Devuelven los datos en el mismo orden en que se escribieron en la instancia principal y, a menudo, hay un retardo de replicación inferior a 50 ms. Puede monitorizar el retardo de réplica del clúster con las métricas de Amazon CloudWatch `DBInstanceReplicaLag` y `DBClusterReplicaLagMaximum`. Para obtener más información, consulte [Supervisión de Amazon DocumentDB con CloudWatch](cloud_watch.md).
A diferencia de la arquitectura monolítica tradicional de las bases de datos, Amazon DocumentDB separa el almacenamiento y la computación. Dada esta arquitectura moderna, le animamos a escalar la lectura en las instancias de réplica. Las lecturas en las instancias de réplica no bloquean la replicación de las escrituras desde la instancia principal. Puede añadir hasta 15 instancias de réplica de lectura en un clúster y escalar a millones de lecturas por segundo.
La ventaja principal de conectarse como conjunto de réplicas y distribuir las lecturas a las réplicas es que aumenta los recursos generales del clúster disponibles para utilizar la aplicación. Recomendamos que se conecte como conjunto de réplicas como práctica recomendada. Además, lo recomendamos con más frecuencia en las siguientes situaciones:
+ Si utiliza casi el 100 % de la CPU en la instancia principal.
+ Si la proporción de aciertos de la caché del búfer es casi cero.
+ Si alcanza los límites de conexión o cursor de una instancia.
Escalar el tamaño de una instancia de clúster es una opción y, en algunos casos, puede ser la mejor manera de escalar el clúster. Sin embargo, también deberá plantearse cómo aprovechar mejor las réplicas que ya tiene en el clúster. Esto le permite aumentar la escala sin el mayor coste de utilizar un tipo de instancia mayor. También recomendamos que monitorice y alerte de estos límites (es decir, `CPUUtilization`, `DatabaseConnections` y `BufferCacheHitRatio`) mediante las alarmas de CloudWatch para saber cuándo se está utilizando mucho un recurso.
Para obtener más información, consulte los temas siguientes:
+ [Prácticas recomendadas para Amazon DocumentDB](best_practices.md)
+ [Cuotas y límites de Amazon DocumentDB](limits.md)
## Uso de las conexiones del clúster
Plantéese la posibilidad de utilizar todas las conexiones del clúster. Por ejemplo, una instancia `r5.2xlarge` tiene un límite de 4500 conexiones (y 450 cursores abiertos). Si crea un clúster de Amazon DocumentDB de tres instancias y se conecta únicamente a la instancia principal mediante el punto de conexión de clúster, los límites de conexiones y cursores abiertos del clúster son de 4500 y 450 respectivamente. Podría alcanzar estos límites al crear aplicaciones que utilizan muchos procesos de trabajo que se ponen en marcha en contenedores. Los contenedores abren una serie de conexiones a la vez y saturan el clúster.
En su lugar, podría conectarse al clúster de Amazon DocumentDB como conjunto de réplicas y distribuir las lecturas a las instancias de réplica. A continuación, podría triplicar de forma eficaz el número de conexiones y cursores disponibles en el clúster a 13 500 y 1350 respectivamente. Añadir más instancias al clúster solo aumenta el número de conexiones y cursores para las cargas de trabajo de lectura. Si necesita aumentar el número de conexiones para las escrituras en el clúster, recomendamos que aumente el tamaño de la instancia.
**nota**
El número de conexiones para las instancias `large`, `xlarge` y `2xlarge` aumenta con el tamaño de instancia hasta 4500. El número máximo de conexiones por instancia para instancias `4xlarge` o superiores es 4500. Para obtener más información sobre los límites por tipos de instancia, consulte [Límites de instancias](limits.md#limits.instance).
Normalmente, no recomendamos que se conecte al clúster con la preferencia de lectura de `secondary`. Esto se debe a que, si no hay instancias de réplica en el clúster, las lecturas generarán un error. Por ejemplo, suponga que tiene un clúster de Amazon DocumentDB de dos instancias con una instancia principal y una réplica. Si la réplica tiene un problema, se generará un error en las solicitudes de lectura de un grupo de conexiones establecido como `secondary`. La ventaja de `secondaryPreferred` es que, si el cliente no encuentra una instancia de réplica adecuada a la que conectarse, recurre a la instancia principal para las lecturas.
## Varios grupos de conexiones
En algunos casos, las lecturas de una aplicación deben contar con consistencia de lectura tras escritura, que solo se puede distribuir desde la instancia principal en Amazon DocumentDB. En estos casos, podría crear dos grupos de conexiones del cliente: uno para escrituras y otro para lecturas que necesiten consistencia de lectura tras escritura. Para ello, el código tendría un aspecto similar al siguiente.
```
## Create a MongoDB client,
## open a connection to Amazon DocumentDB as a replica set and specify the readPreference as primary
clientPrimary = pymongo.MongoClient('mongodb://:@mycluster.node.us-east-1.docdb.amazonaws.com:27017/?replicaSet=rs0&readPreference=primary')
## Create a MongoDB client,
## open a connection to Amazon DocumentDB as a replica set and specify the readPreference as secondaryPreferred
secondaryPreferred = pymongo.MongoClient('mongodb://:@mycluster.node.us-east-1.docdb.amazonaws.com:27017/?replicaSet=rs0&readPreference=secondaryPreferred')
```
Otra opción consiste en crear un único grupo de conexiones y sobrescribir la preferencia de lectura en una colección determinada.
```
##Specify the collection and set the read preference level for that collection
col = db.review.with_options(read_preference=ReadPreference.SECONDARY_PREFERRED)
```
## Resumen
Para aprovechar mejor los recursos del clúster, recomendamos que se conecte al clúster mediante el modo de conjunto de réplicas. Si es adecuado para la aplicación, puede escalar la lectura de la aplicación distribuyendo las lecturas a las instancias de réplica.
# Conexión a un clúster de Amazon DocumentDB desde Studio 3T
[Studio 3T](https://studio3t.com/) es una GUI e IDE popular para desarrolladores e ingenieros de datos que trabajan con MongoDB. Ofrece varias funciones potentes: vistas de sus datos en árbol, tabla y JSON, sencillas import/export en CSV, JSON, SQL y BSON/MongoDump, una opción de consulta flexible, una drag-and-drop interfaz de usuario visual, un shell mongo integrado con autocompletado, un editor de canalizaciones de agregación y soporte para consultas SQL.
## Requisitos previos
+ Si aún no tiene un clúster de Amazon DocumentDB que utilice Amazon EC2 como bastion/jump host, siga las instrucciones sobre cómo [Conectarse con Amazon](https://docs.aws.amazon.com/documentdb/latest/developerguide/connect-ec2.html) EC2.
+ Si no tiene Studio 3T, [descárguelo e instálelo](https://studio3t.com/download).
## Conexión con Studio 3T
1. Seleccione **Conectar** en la esquina superior izquierda de la barra de herramientas.
![\[Interfaz Studio 3T, en la que se muestra la pantalla de bienvenida y la opción Conectar resaltadas en la esquina superior izquierda.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-connect.png)
1. Seleccione **Nueva conexión** en la esquina superior izquierda de la barra de herramientas.
![\[Interfaz del Administrador de conexión con la opción Nueva conexión resaltada en la esquina superior izquierda.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-newconn.png)
1. En la pestaña **Servidor**, en el campo **Servidor**, introduzca la información del punto de conexión del clúster.
![\[Pestaña Servidor de la interfaz Conexión nueva con el campo de entrada Servidor resaltado.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-endpoint.png)
**nota**
¿No encuentra el punto de conexión de su clúster? Solo tiene que seguir los pasos que se indican [aquí](https://docs.aws.amazon.com/documentdb/latest/developerguide/db-instance-endpoint-find.html).
1. Elija la pestaña **Autenticación** y seleccione **Heredado** en el menú desplegable **Modo de autenticación**.
![\[Pestaña Autenticación de la interfaz Conexión nueva con el modo de autenticación anterior seleccionado y la información de nombre de usuario, contraseña y base de datos de autenticación proporcionada.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-auth.png)
1. Introduzca su nombre de usuario y sus credenciales en los campos **Nombre de usuario** y **Contraseña**.
1. Seleccione la pestaña **SSL** y marque la casilla **Usar el protocolo SSL para conectarse**.
![\[Pestaña SSL de la interfaz Conexión nueva con la opción Usar protocolo SSL para conectarse seleccionada.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-ssl.png)
1. Seleccione **Usar un archivo CA raíz propio**. A continuación, añada el certificado de Amazon DocumentDB (puede omitir este paso si SSL está deshabilitado en su clúster de DocumentDB). Marque la casilla para permitir **nombres de host no válidos**.
![\[Pestaña SSL de la interfaz Conexión nueva con el archivo CA raíz ingresado y permitir nombres de host no válidos seleccionado.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-ssl.png)
**nota**
¿No tiene el certificado? Puede descargarlo con el siguiente comando:
`wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem `
1. Si se conecta desde una máquina cliente externa a Amazon VPC, debe crear un túnel SSH. Hará esto en la pestaña **SSH**.
1. Marque la casilla **Usar túnel SSH** e introduzca la dirección SSH en el campo **Dirección SSH**. Esta es su instancia Public DNS (). IPV4 Puede obtener esta URL desde su [Consola de administración de Amazon EC2](https://console.aws.amazon.com/ec2).
1. Introduzca su nombre de usuario. Este es el nombre de usuario de su instancia de Amazon EC2.
1. Como **Modo de autenticación SSH**, seleccione **Clave privada**. En el campo **Clave privada**, elija el icono del buscador de archivos para localizar y elegir la clave privada de su instancia de Amazon EC2. Este es el archivo .pem (par de claves) que guardó al crear la instancia en la consola de Amazon EC2.
1. Si estás en una máquina Linux/macOS cliente, es posible que tengas que cambiar los permisos de tu clave privada mediante el siguiente comando:
`chmod 400 /fullPathToYourPemFile/.pem`
![\[Pestaña SSH de la interfaz Conexión nueva con las credenciales del túnel SSH introducidas.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-ssh.png)
**nota**
Esta instancia de Amazon EC2 debe estar en la misma VPC de Amazon y grupo de seguridad que el clúster de DocumentDB. Puede obtener la dirección SSH, el nombre de usuario y la clave privada en su [Consola de administración de Amazon EC2](https://console.aws.amazon.com/ec2).
1. Ahora pruebe la configuración pulsando el botón **Probar conexión**.
![\[Interfaz Conexión nueva con el botón Probar conexión resaltado en la esquina inferior izquierda.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-testbutton.png)
1. Una ventana de diagnóstico debería cargar una barra verde para indicar que la prueba se ha realizado correctamente. Ahora pulse **Aceptar** para cerrar la ventana de diagnóstico.
![\[Ventana de diagnóstico que aparece después de una prueba de conexión correcta.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-testconn.png)
1. Elija **Guardar** para guardar la conexión y usarla en el futuro.
![\[Interfaz Conexión nueva con el botón Guardar resaltado.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-save.png)
1. Ahora seleccione su clúster y elija **Conectar**.
![\[Interfaz Conexión nueva con el botón Conectar resaltado.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/studio3t/studio3t-finalconnect.png)
¡Enhorabuena\$1 Se ha conectado correctamente a su clúster de Amazon DocumentDB a través de Studio 3T.
# Conexión a Amazon DocumentDB mediante DataGrip
[DataGrip](https://www.jetbrains.com/help/datagrip/documentdb.html) es un potente entorno de desarrollo integrado (IDE) que admite varios sistemas de bases de datos, incluido Amazon DocumentDB. En esta sección se explican los pasos para conectarse a su clúster de Amazon DocumentDB mediante DataGrip, lo que le permite administrar y consultar sus datos fácilmente mediante una interfaz gráfica.
## Requisitos previos
+ El IDE de DataGrip está instalado en su máquina. Puede descargarlo desde [JetBrains](https://www.jetbrains.com/datagrip/download/#section=windows).
+ Una instancia de Amazon EC2 que se ejecute en la misma VPC que el clúster de Amazon DocumentDB. Utilizará esta instancia para establecer un túnel seguro desde su máquina local hasta el clúster de Amazon DocumentDBCluster. Siga estas instrucciones sobre cómo [Conectarse mediante Amazon EC2](connect-ec2.md):
+ Como alternativa a una instancia Amazon EC2, a una conexión VPN o si ya está accediendo a su infraestructura de AWS mediante una VPN segura. Si prefiere esta opción, siga las instrucciones para [acceder de forma segura a Amazon DocumentDB mediante AWS Client VPN](https://aws.amazon.com/blogs/database/securely-access-amazon-documentdb-with-mongodb-compatibility-locally-using-aws-client-vpn/).
## Conexión mediante DataGrip
1. Inicie DataGrip en su ordenador y cree un **Nuevo proyecto**.
![\[Pantalla de bienvenida de DataGrip con la opción Nuevo proyecto resaltada.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/welcome.png)
1. Agregue un nuevo origen de datos de una de las siguientes formas:
1. En el menú principal, vaya a **Archivo — Nuevo — Origen de datos** y seleccione **DocumentDB**
1. En el **explorador de bases de datos**, haga clic en el nuevo icono (**\$1**) de la barra de herramientas. Vaya al **origen de datos** y seleccione **DocumentDB**.
![\[La lista desplegable de + muestra el submenú Origen de datos. DocumentDB se selecciona en ese submenú.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/explorer.png)
1. En la página **Orígenes de datos** de la pestaña **General**, compruebe si hay un enlace para **descargar los archivos del controlador que faltan** en la parte inferior del área de configuración de la conexión. Haga clic en este enlace para descargar los controladores necesarios para interactuar con una base de datos. Para obtener un enlace de descarga directa, consulte los [controladores JDBC de JetBrains](https://www.jetbrains.com/datagrip/jdbc-drivers/).
![\[La interfaz de Orígenes de datos y controladores con el enlace Descargar los archivos de controladores que faltan resaltado.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/missing-driver.png)
1. En la pestaña **General**, especifique los detalles de la conexión:
1. En el campo **Host**, especifique el punto de conexión del clúster de Amazon DocumentDB.
1. **El puerto** ya está establecido en 27017. Cámbielo si el clúster se implementó en un puerto diferente.
1. En **Autenticación**, elija **Nombre de usuario y contraseña**.
1. Introduzca la información de nombre de usuario y contraseña.
1. El campo **Base de datos** es opcional. Puede especificar la base de datos a la que desea conectarse.
1. El campo **URL** se completa automáticamente a medida que añade los detalles anteriores.
![\[Los campos de host, puerto, autenticación, base de datos y URL se encuentran en la pestaña General de la interfaz de Orígenes de datos y controladores.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/connection.png)
1. En la pestaña **SSH/SSL**, habilite **Usar túnel SSH** y, a continuación, haga clic en el icono para abrir el cuadro de diálogo **Configuración de SSH**. Introduzca la información siguiente:
1. En el campo **Host**, introduzca el nombre de host de su instancia de Amazon EC2.
1. Introduzca el nombre de usuario y la contraseña de la instancia de Amazon EC2.
1. En **Tipo de autenticación**, elija **Par de claves**.
1. Introduzca su **Archivo de clave privada**.
**nota**
Si utiliza la opción VPN, no es necesario configurar el túnel SSH.
![\[La pestaña SSH/SSL de la interfaz de Orígenes de datos y controladores con la opción Usar túnel SSH seleccionada y el icono de configuración de SSH resaltado. El icono abre la interfaz de Configuraciones de SSH que se muestra.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ssh-tunnel.png)
1. En la pestaña **SSH/SSL**, habilite **Usar SSL**. En el campo **Archivo CA**, introduzca la ubicación del archivo `global-bundle.pem` en su ordenador. En **Modo**, deje la opción **Requerir**.
**nota**
Puede descargar el certificado desde esta ubicación o con este comando: wget [https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem)
**nota**
Si se está conectando al clúster elástico de Amazon DocumentDB, no tiene que especificar el archivo CA. Deje marcada la opción **Usar SSL** y todas las demás opciones con sus valores predeterminados.
![\[La pestaña SSH/SSL de la interfaz de Orígenes de datos y controladores tiene habilitada la configuración de SSL.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/use-ssl.png)
1. En la pestaña **Esquemas**, elija **Todas las bases de datos** o introduzca el filtro “\$1:\$1” en el campo del **patrón del esquema**. Haga clic en el enlace **Probar la conexión** para probar la conexión.
![\[La pestaña Esquemas de la interfaz de Orígenes de datos y controladores con la opción Todas las bases de datos seleccionada. Aparece un mensaje de Realizado correctamente sobre el enlace de Probar conexión.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/schemas.png)
1. Una vez que la conexión se haya probado correctamente, haga clic en **Aceptar** para guardar la configuración del origen de datos.
## Características de DataGrip
DataGrip ofrece varias características para ayudarle a trabajar con Amazon DocumentDB de forma eficiente:
+ **Editor de SQL**: escriba y ejecute consultas tipo SQL en sus colecciones de DocumentDB mediante el editor SQL de DataGrip.
+ **Generador visual de consultas**: utilice el generador visual de consultas para crear consultas de forma gráfica sin escribir el código SQL.
+ **Administración de esquemas**: administre fácilmente el esquema de su base de datos, incluida la creación, modificación y eliminación de colecciones.
+ **Visualización de datos**: vea y analice sus datos con varias herramientas de visualización disponibles en DataGrip.
+ **Exportación e importación de datos**: transfiera datos entre Amazon DocumentDB y otras bases de datos mediante las características de exportación e importación de DataGrip.
Consulte la [documentación oficial de DataGrip](https://www.jetbrains.com/datagrip/features/) para obtener características y consejos más avanzados sobre cómo trabajar con Amazon DocumentDB y otros sistemas de bases de datos.
# Conectarse mediante Amazon EC2
En esta sección se describe cómo configurar la conectividad entre un clúster de Amazon DocumentDB y Amazon EC2 y cómo acceder al clúster de Amazon DocumentDB desde la instancia de Amazon EC2.
Hay dos opciones para configurar la conexión de EC2:
+ [Conexión automática de la instancia de EC2 a una base de datos de Amazon DocumentDB](connect-ec2-auto.md): utilice la característica de conexión automática de la consola de EC2 para configurar automáticamente la conexión entre la instancia de EC2 y una base de datos de Amazon DocumentDB nueva o existente. Esta conexión permite que el tráfico se desplace entre la instancia de EC2 y la base de datos de Amazon DocumentDB. Esta opción se utiliza normalmente para probar y crear nuevos grupos de seguridad.
+ [Conexión manual de la instancia de EC2 a la base de datos de Amazon DocumentDB](connect-ec2-manual.md): configure la conexión entre la instancia de EC2 y la base de datos de Amazon DocumentDB mediante la configuración y la asignación manuales de los grupos de seguridad para que reproduzcan la configuración que se crea mediante la característica de conexión automática. Esta opción se suele utilizar para cambiar configuraciones más avanzadas y usar los grupos de seguridad existentes.
## Requisitos previos
Independientemente de la opción y antes de crear el primer clúster de Amazon DocumentDB, debe hacer lo siguiente:
**Creación de una cuenta de Amazon Web Services (AWS)**
Para empezar a utilizar Amazon DocumentDB, debe tener una cuenta de Amazon Web Services (AWS). La AWS cuenta es gratuita. Solo se paga por los servicios y los recursos que se utilicen.
Si no tiene una Cuenta de AWS, complete los siguientes pasos para crearla.
**Para suscribirse a una Cuenta de AWS**
1. Abrir [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).
1. Siga las instrucciones que se le indiquen.
Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.
Cuando te registras en un Cuenta de AWS, *Usuario raíz de la cuenta de AWS*se crea un. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [Tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
**Si lo desea, configure los permisos AWS Identity and Access Management (IAM) necesarios.**
El acceso para gestionar los recursos de Amazon DocumentDB, como clústeres, instancias y grupos de parámetros de clústeres, requiere credenciales que AWS pueda utilizar para autenticar sus solicitudes. Para obtener más información, consulte [Identity and Access Management para Amazon DocumentDB](security-iam.md).
1. En la barra de búsqueda Consola de administración de AWS, escriba IAM y seleccione **IAM** en el menú desplegable que aparece.
1. Cuando esté en la consola de IAM, seleccione **Usuarios** en el panel de navegación.
1. Seleccione su nombre de usuario.
1. Haga clic en el botón **Añadir permisos**.
1. Seleccione **Asociar directamente las políticas existentes**.
1. Escriba `AmazonDocDBFullAccess` en la barra de búsqueda y selecciónelo en cuanto aparezca en los resultados de búsqueda.
1. Haga clic en el botón azul de la parte inferior que dice **Siguiente: Revisión**.
1. Haga clic en el botón azul de la parte inferior que dice **Añadir permisos**.
**Creación de una Amazon Virtual Private Cloud (Amazon VPC)**
En función del lugar en el que se Región de AWS encuentre, es posible que ya tenga creada una VPC predeterminada o no. Si no cuenta con una VPC determinada, complete el paso 1 de la [Introducción a Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-getting-started.html) en la *Guía del usuario de Amazon VPC*. Esto tardará menos de cinco minutos.
# Conexión automática de Amazon EC2
**Topics**
+ [Conexión automática de una instancia de EC2 a una nueva base de datos de Amazon DocumentDB](#auto-connect-ec2.process)
+ [Conexión automática de una instancia de EC2 a una base de datos de Amazon DocumentDB existente](#auto-connect-ec2-existing-cluster)
+ [Descripción general de la conectividad automática con una instancia de EC2](#auto-connect-ec2.overview)
+ [Visualización de los recursos de computación conectados](#auto-connect-ec2.compute)
Antes de configurar una conexión entre una instancia de EC2 y una nueva base de datos de Amazon DocumentDB, asegúrese de cumplir con los requisitos descritos en [Descripción general de la conectividad automática con una instancia de EC2](#auto-connect-ec2.overview). Si hace cambios en los grupos de seguridad después de configurar la conectividad, los cambios pueden afectar a la conexión entre la instancia de EC2 y la base de datos de Amazon DocumentDB.
**nota**
Solo puede configurar automáticamente una conexión entre una instancia de EC2 y una base de datos de Amazon DocumentDB automáticamente mediante la Consola de administración de AWS. No puede configurar una conexión automáticamente con la API AWS CLI o Amazon DocumentDB.
## Conexión automática de una instancia de EC2 a una nueva base de datos de Amazon DocumentDB
En el siguiente proceso se presupone que ha completado los pasos que se detallan en el tema [Requisitos previos](connect-ec2.md#connect-ec2-prerequisites).
**Topics**
+ [Paso 1: creación de una instancia de Amazon EC2](#auto-connect-ec2.launch-ec2-instance)
+ [Paso 2: creación de un clúster de Amazon DocumentDB](#auto-connect-ec2.launch-cluster)
+ [Paso 3: conexión a la instancia de Amazon EC2](#manual-connect-ec2.connect)
+ [Paso 4: instalación del intérprete de comandos de MongoDB](#auto-connect-ec2.install-mongo-shell)
+ [Paso 5: administración de TLS de Amazon DocumentDB](#auto-connect-ec2.tls)
+ [Paso 6: conexión al clúster de Amazon DocumentDB](#auto-connect-ec2.connect-use)
+ [Paso 7: inserción y consulta de datos](#auto-cloud9-insert-query)
+ [Paso 8: exploración](#auto-connect-ec2.explore)
### Paso 1: creación de una instancia de Amazon EC2
En este paso, creará una instancia de Amazon EC2 en la misma región y Amazon VPC que utilizará más adelante para aprovisionar el clúster de Amazon DocumentDB.
1. En el panel de la consola de Amazon EC2, seleccione **Lanzar instancia**.
![\[La sección Lanzar instancia en la consola de Amazon EC2.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/launch-instance.png)
1. Ingrese un nombre o identificador en el campo **Nombre** ubicado en la sección **Nombres y etiquetas**.
1. En la lista desplegable **Imagen de máquina de Amazon (AMI)**, busque la **AMI de Amazon Linux 2** y selecciónela.
![\[La interfaz Imágenes de aplicaciones y sistema operativo con la opción AMI de Amazon Linux 2 seleccionada en la sección Inicio rápido.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/linux2-ami.png)
1. Busque y seleccione **t3.micro** en la lista desplegable de **Tipo de instancia**.
1. En la sección **Par de claves (inicio de sesión)**, ingrese el identificador de un par de claves existente o elija **Crear un par de claves nuevo**.
![\[La interfaz Par de claves, en la que se muestra el campo del nombre del par de claves y la opción Crear un nuevo par de claves.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/key-pair.png)
También debe proporcionar un par de claves de Amazon EC2.
+ Si tiene un par de claves de Amazon EC2:
1. Seleccione un par de claves, elija su par de claves de la lista.
1. Debe tener el archivo de clave privada (archivo .pem o .ppk) a su disposición para poder iniciar sesión en la instancia de Amazon EC2.
+ Si no tiene un par de claves de Amazon EC2:
1. Seleccione **Crear un par de claves nuevo** y aparecerá el cuadro de diálogo **Crear par de claves**.
1. Escriba un nombre en el campo **Nombre del par de claves**.
1. Seleccione el **Tipo de par de claves** y el **Formato de archivo de clave privada**.
1. Elija **Crear par de claves**.
![\[La interfaz Crear par de claves con campos para el nombre, el tipo y el formato de archivo del par de claves. El botón Crear par de claves se encuentra en la esquina inferior derecha.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/create-key-pair.png)
**nota**
Por motivos de seguridad, le recomendamos encarecidamente que utilice un par de claves para la conectividad a Internet y SSH con la instancia de EC2.
1. **Opcional:** en la sección **Configuración de red**, en **Firewall (grupos de seguridad)**, seleccione **Crear grupo de seguridad**.
![\[La interfaz Configuración de red, en la que se muestran opciones para crear un grupo de seguridad.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/firewall.png)
Elija **Crear grupo de seguridad** (compruebe todas las reglas de tráfico que se aplican a su conectividad con EC2).
**nota**
Si desea utilizar un grupo de seguridad existente, siga las instrucciones de [Conexión manual de Amazon EC2](connect-ec2-manual.md).
1. En la sección **Resumen**, revise la configuración de EC2 y, si es correcta, elija **Lanzar instancia**.
### Paso 2: creación de un clúster de Amazon DocumentDB
Mientras se aprovisiona la instancia de Amazon EC2, cree su clúster de Amazon DocumentDB.
1. Navegue hasta la consola de Amazon DocumentDB y elija **Clústeres** en el panel de navegación.
1. Seleccione **Crear**.
1. Deje la configuración de **Tipo de clúster** como predeterminada en **Clúster basado en instancias**.
1. En **Configuración del clúster**, ingrese un nombre único en **Identificador de clúster**. Tenga en cuenta que la consola cambiará todos los nombres de los clústeres a minúsculas independientemente de cómo se ingresen.
Deje **Versión del motor** con su valor predeterminado de **5.0.0**.
1. En **Configuración del almacenamiento en clúster**, deje la configuración predeterminada de **Amazon DocumentDB estándar**.
1. En **Configuración de instancias**:
+ En **Clase de instancia de base de datos**, elija **Clases optimizadas para memoria (incluidas las clases r)**, que es la opción predeterminada.
La otra opción de instancia son las clases **NVMerespaldadas por comandos**. Para obtener más información, consulte [Instancias respaldadas por NVMe](db-instance-nvme.md).
+ En **Clase de instancia**, elija el tipo de instancia que se adapte a sus necesidades. Para obtener una explicación más detallada de las clases de instancia, consulte [Especificaciones de clases de instancias](db-instance-classes.md#db-instance-class-specs).
+ En **Número de instancias**, elija el número que mejor refleje sus necesidades. Recuerde que cuanto menor sea el número, menor será el costo y menor será el read/write volumen que puede administrar el clúster.
![\[La interfaz de configuración con valores predeterminados para el identificador del clúster, la versión del motor y la clase de instancia, con el número de instancias establecido en uno.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/create-cluster/instance-config.png)
1. En **Conectividad**, elija **Conectarse a un recurso de computación de EC2**. Esta es la instancia de EC2 que creó en el paso 1.
![\[La interfaz de conectividad con la opción Conectar a un recurso de computación de EC2 seleccionada.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2-connect.png)
**nota**
La conexión a un recurso de computación de EC2 crea automáticamente un grupo de seguridad para la conexión del recurso de computación de EC2 al clúster de Amazon DocumentDB. Cuando haya terminado de crear el clúster y desee ver el grupo de seguridad recién creado, navegue hasta la lista de clústeres y elija el identificador del clúster. En la pestaña **Conectividad y seguridad**, vaya a **Grupos de seguridad** y busque su grupo en **Nombre del grupo de seguridad (ID)**. Contendrá el nombre del clúster y tendrá un aspecto similar al siguiente: `docdb-ec2-docdb-2023-12-11-21-33-41:i-0e4bb09985d2bbc4c (sg-0238e0b0bf0f73877)`.
1. En la sección **Autenticación**, ingrese un nombre de usuario para el usuario principal y, a continuación, elija **Autoadministrado**. Ingrese una contraseña y, a continuación, confírmela.
Si, en su lugar, eligió **Administrado en AWS Secrets Manager**, consulte [Administración de contraseñas con Amazon DocumentDB y AWS Secrets Manager](docdb-secrets-manager.md) para obtener más información.
1. Elija **Create cluster**.
### Paso 3: conexión a la instancia de Amazon EC2
Para instalar el intérprete de comandos de mongo, primero se debe conectar a la instancia de Amazon EC2. La instalación del intérprete de comandos de mongo permite conectarse a su clúster de Amazon DocumentDB y realizar consultas en él. Realice los siguientes pasos:
1. En la consola Amazon EC2, navegue hasta sus instancias y compruebe si la instancia que acaba de crear se está ejecutando. Si es así, haga clic en el ID de la instancia para seleccionar la instancia.
![\[Tabla de instancias con una lista de dos instancias de la consola de Amazon EC2.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/ec2-instance-table.png)
1. Elija **Conectar**.
![\[Resumen de instancias de una instancia de Amazon EC2. El botón Conectar se encuentra en la esquina superior derecha.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/ec2-instance-summary.png)
1. Hay cuatro opciones con pestañas para el método de conexión: Amazon EC2 Instance Connect, Session Manager, cliente SSH o consola serie de EC2. Debe elegir uno y seguir sus instrucciones. Cuando haya terminado, elija **Conectar**.
![\[Interfaz en la que se muestran las opciones de configuración del método de conexión EC2 Instance Connect.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/connect-options.png)
**nota**
Si su dirección IP ha cambiado después de iniciar este tutorial o si va a volver a su entorno más adelante, debe actualizar la regla de entrada del grupo de seguridad `demoEC2` para habilitar el tráfico entrante desde su nueva dirección de API.
### Paso 4: instalación del intérprete de comandos de MongoDB
Ahora puede instalar el intérprete de comandos de MongoDB, que es una utilidad de línea de comandos que se utiliza para conectarse al clúster de Amazon DocumentDB y consultarlo. Actualmente hay dos versiones del intérprete de comandos de MongoDB: la versión más reciente, mongosh, y la versión anterior, el intérprete de comandos de mongo.
**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 Node.js y las herramientas que utilizan el controlador Node.js (como mongosh) deben actualizarse al controlador Node.js versión 6.13.1 o posterior.
Siga las siguientes instrucciones para instalar el intérprete de comandos de MongoDB en su sistema operativo.
------
#### [ On Amazon Linux ]
**Cómo instalar el intérprete de comandos de MongoDB en Amazon Linux**
Si *no* utiliza la autenticación de IAM y desea utilizar el último intérprete de comandos de MongoDB (mongosh) para conectarse a su clúster de Amazon DocumentDB, siga estos pasos:
1. Cree el archivo de repositorio. En la línea de comando de la instancia de EC2 que creó, escriba el siguiente comando:
```
echo -e "[mongodb-org-5.0] \nname=MongoDB Repository\nbaseurl=https://repo.mongodb.org/yum/amazon/2023/mongodb-org/5.0/x86_64/\ngpgcheck=1 \nenabled=1 \ngpgkey=https://pgp.mongodb.com/server-5.0.asc" | sudo tee /etc/yum.repos.d/mongodb-org-5.0.repo
```
1. Cuando esté completo, instale mongosh con una de las siguientes opciones de comando en el símbolo del sistema:
**Opción 1**: si eligió Amazon Linux 2023 (predeterminado) durante la configuración de Amazon EC2, introduzca este comando:
```
sudo yum install -y mongodb-mongosh-shared-openssl3
```
**Opción 2**: si eligió Amazon Linux 2 durante la configuración de Amazon EC2, introduzca este comando:
```
sudo yum install -y mongodb-mongosh
```
Si utiliza la autenticación de IAM, debe utilizar la versión anterior del intérprete de comandos de MongoDB (5.0) para conectarse al clúster de Amazon DocumentDB. Siga estos pasos:
1. Cree el archivo de repositorio. En la línea de comando de la instancia de EC2 que creó, escriba el siguiente comando:
```
echo -e "[mongodb-org-5.0] \nname=MongoDB Repository\nbaseurl=https://repo.mongodb.org/yum/amazon/2023/mongodb-org/5.0/x86_64/\ngpgcheck=1 \nenabled=1 \ngpgkey=https://pgp.mongodb.com/server-5.0.asc" | sudo tee /etc/yum.repos.d/mongodb-org-5.0.repo
```
1. Cuando esté completo, instale el intérprete de comandos de MongoDB 5.0 con la siguiente opción de comando en el símbolo del sistema:
```
sudo yum install -y mongodb-org-shell
```
------
#### [ On Ubuntu ]
**Cómo instalar mongosh en Ubuntu**
1. Importe la clave pública que utilizará el sistema de administración de paquetes.
```
curl -fsSL https://pgp.mongodb.com/server-5.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-server-5.0.gpg
```
1. Cree el archivo de lista `mongodb-org-5.0.list` para MongoDB mediante el comando correspondiente a su versión de Ubuntu.
```
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-5.0.gpg ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/5.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-5.0.list
```
1. Importe y actualice la base de datos del paquete local utilizando el siguiente comando:
```
sudo apt-get update
```
1. Instale mongosh.
```
sudo apt-get install -y mongodb-mongosh
```
Para obtener información sobre cómo instalar las versiones anteriores de MongoDB en un sistema Ubuntu, consulte [Install MongoDB Community Edition on Ubuntu](https://docs.mongodb.com/v3.6/tutorial/install-mongodb-on-ubuntu/).
------
#### [ On other operating systems ]
Para instalar el intérprete de comandos de mongo en otros sistemas operativos, consulte el tema sobre [cómo instalar MongoDB Community Edition](https://www.mongodb.com/docs/manual/administration/install-community/) en la documentación de MongoDB.
------
### Paso 5: administración de TLS de Amazon DocumentDB
Descargue el certificado CA para Amazon DocumentDB con el siguiente código: `wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem`
**nota**
La seguridad de la capa de transporte (TLS) está habilitada de forma predeterminada para todos los clústeres nuevos de Amazon DocumentDB. Para obtener más información, consulte [Managing Amazon DocumentDB cluster TLS settings](https://docs.aws.amazon.com/documentdb/latest/developerguide/security.encryption.ssl.html).
### Paso 6: conexión al clúster de Amazon DocumentDB
1. En la consola de Amazon DocumentDB, en **Clústeres**, localice su clúster. Haga clic en **Identificador del clúster** para elegir el clúster que creó.
1. En la pestaña **Conectividad y seguridad**, busque **Conectar a este clúster con el intérprete de comandos de mongo** en el cuadro **Conectar**:
![\[Configuración de conexión del clúster con la cadena de conexión de MongoDB resaltada para conectarse a un clúster de Amazon DocumentDB mediante el intérprete de comandos de mongo.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/connect-mongosh.png)
Copie la cadena de conexión proporcionada y péguela en el terminal.
Haga los siguientes cambios en ella:
1. Asegúrese de que tenga el nombre de usuario correcto en la cadena.
1. Omita `` para que el intérprete de comandos de mongo le pida la contraseña cuando se conecte.
1. Opcional: si utiliza la autenticación de IAM o utiliza la versión anterior del intérprete de comandos de MongoDB, modifique la cadena de conexión de la siguiente manera:
`mongo --ssl --host mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1.docdb.amazonaws.com:27017 --sslCAFile global-bundle.pem --username SampleUser1 --password`
Sustituya `mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1` por la misma información de su clúster.
1. Pulse Intro en el terminal. Ahora se le solicitará la contraseña. Introduzca su contraseña.
1. Cuando introduzca la contraseña y pueda ver el mensaje `rs0 [direct: primary] >`, significa que se ha conectado correctamente a su clúster de Amazon DocumentDB.
¿Tiene problemas para conectarse? Consulte [Solución de problemas de Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/troubleshooting.html).
### Paso 7: inserción y consulta de datos
Ahora que está conectado a su clúster, puede realizar algunas consultas para familiarizarse con el uso de una base de datos de documentos.
1. Para insertar un solo documento, escriba lo siguiente:
```
db.collection.insertOne({"hello":"DocumentDB"})
```
Obtiene el siguiente resultado:
```
{
acknowledged: true,
insertedId: ObjectId('673657216bdf6258466b128c')
}
```
1. Puede leer el documento que escribió con el comando `findOne()` (ya que solo devuelve un documento). La siguiente entrada:
```
db.collection.findOne()
```
Obtiene el siguiente resultado:
```
{ "_id" : ObjectId("5e401fe56056fda7321fbd67"), "hello" : "DocumentDB" }
```
1. Para realizar algunas consultas más, plantéese un caso de uso de perfiles de juegos. Primero, inserte algunas entradas en una colección titulada `profiles`. La siguiente entrada:
```
db.profiles.insertMany([{ _id: 1, name: 'Matt', status: 'active', level: 12, score: 202 },
{ _id: 2, name: 'Frank', status: 'inactive', level: 2, score: 9 },
{ _id: 3, name: 'Karen', status: 'active', level: 7, score: 87 },
{ _id: 4, name: 'Katie', status: 'active', level: 3, score: 27 }
])
```
Obtiene el siguiente resultado:
```
{ acknowledged: true, insertedIds: { '0': 1, '1': 2, '2': 3, '3': 4 } }
```
1. Utilice el comando `find()` para devolver todos los documentos de la colección de perfiles. La siguiente entrada:
```
db.profiles.find()
```
Obtendrá un resultado que coincidirá con los datos que escribió en el paso 3.
1. Utilice una consulta para un único documento mediante un filtro. La siguiente entrada:
```
db.profiles.find({name: "Katie"})
```
Obtiene el siguiente resultado:
```
{ "_id" : 4, "name" : "Katie", "status": "active", "level": 3, "score":27}
```
1. Ahora intentemos buscar un perfil y modificarlo con el comando `findAndModify`. Le daremos al usuario Matt 10 puntos adicionales con el siguiente código:
```
db.profiles.findAndModify({
query: { name: "Matt", status: "active"},
update: { $inc: { score: 10 } }
})
```
Se obtiene el siguiente resultado (tenga en cuenta que la puntuación aún no ha aumentado):
```
{
[{_id : 1, name : 'Matt', status: 'active', level: 12, score: 202}]
```
1. Puede comprobar que su puntuación ha cambiado con la siguiente consulta:
`db.profiles.find({name: "Matt"})`
Obtiene el siguiente resultado:
```
{ "_id" : 1, "name" : "Matt", "status" : "active", "level" : 12, "score" : 212 }
```
### Paso 8: exploración
¡Enhorabuena\$1 Ha completado correctamente la Guía de inicio rápido para Amazon DocumentDB.
Pasos siguientes Descubra cómo aprovechar al máximo esta potente base de datos con algunas de sus características más populares:
+ [Administración de Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/managing-documentdb.html)
+ [Escalado](https://docs.aws.amazon.com/documentdb/latest/developerguide/operational_tasks.html)
+ [Copia de seguridad y restauración](https://docs.aws.amazon.com/documentdb/latest/developerguide/backup_restore.html)
**nota**
Para ahorrar costos, puede detener el clúster de Amazon DocumentDB para reducir los costos o eliminar el clúster. De forma predeterminada, tras 30 minutos de inactividad, el AWS Cloud9 entorno detendrá la instancia Amazon EC2 subyacente.
## Conexión automática de una instancia de EC2 a una base de datos de Amazon DocumentDB existente
En el siguiente procedimiento se presupone que ya tiene un clúster de Amazon DocumentDB y una instancia de Amazon EC2.
**Acceso al clúster de Amazon DocumentDB y configuración de la conexión de Amazon EC2**
1. Acceda al clúster de Amazon DocumentDB.
1. [Inicie sesión en y abra la Consola de administración de AWS consola de Amazon DocumentDB en https://console.aws.amazon.com /docdb.](https://console.aws.amazon.com/docdb)
1. En el panel de navegación, seleccione **Clusters (Clústeres)**.
**sugerencia**
Si no ve el panel de navegación del lado izquierdo de la pantalla, seleccione el icono de menú (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/docdb-menu-icon.png)) en la esquina superior izquierda de la página.
1. Para especificar el clúster que desea, seleccione el botón situado a la izquierda del nombre del clúster.
1. Configure la conexión de Amazon EC2.
1. Elija **Acciones** y, a continuación, elija **Configurar conexión de EC2**.
![\[La lista desplegable Acciones con la opción Configurar conexión a EC2 seleccionada.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/setup-ec2-connect.png)
Aparece el cuadro de diálogo **Configurar conexión de EC2**.
1. En el campo **Instancia de EC2**, elija la instancia de EC2 que desea conectar al clúster.
![\[La interfaz Configurar conexión a EC2 con la lista desplegable Instancia de EC2 resaltada.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/setup-ec2-connect-dialog.png)
1. Elija **Continuar**.
Aparece el cuadro de diálogo **Revisar y confirmar**.
1. Asegúrese de que los cambios sean correctos. A continuación, elija **Configurar la conexión**.
![\[La interfaz Revisión y confirmación, en la que se muestra un resumen de los cambios. El botón Configurar conexión se encuentra en la esquina inferior derecha.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/setup-ec2-review-confirm.png)
Si la operación se lleva a cabo correctamente, aparecerá la siguiente verificación:
![\[Mensaje de confirmación de una configuración de conexión correcta entre la base de datos de Amazon DocumentDB y la instancia de EC2.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/setup-ec2-connect-success.png)
## Descripción general de la conectividad automática con una instancia de EC2
Cuando se configura una conexión entre una instancia de EC2 y una base de datos de Amazon DocumentDB, Amazon DocumentDB configura automáticamente el grupo de seguridad de la VPC para la instancia de EC2 y la base de datos de Amazon DocumentDB.
Estos son los requisitos para conectar una instancia de EC2 a una base de datos de Amazon DocumentDB:
+ La instancia de EC2 debe existir en la misma VPC que la base de datos de Amazon DocumentDB.
Si no existen instancias de EC2 en la misma VPC, la consola proporciona un enlace para crear una.
+ El usuario que establece la conectividad debe tener permisos para realizar las siguientes operaciones de Amazon EC2:
+ `ec2:AuthorizeSecurityGroupEgress`
+ `ec2:AuthorizeSecurityGroupIngress`
+ `ec2:CreateSecurityGroup`
+ `ec2:DescribeInstances`
+ `ec2:DescribeNetworkInterfaces`
+ `ec2:DescribeSecurityGroups`
+ `ec2:ModifyNetworkInterfaceAttribute`
+ `ec2:RevokeSecurityGroupEgress`
Si la instancia de la base de datos y la instancia de EC2 se encuentran en diferentes zonas de disponibilidad, su cuenta podría incurrir en costos cruzados de la zona de disponibilidad.
Cuando se establece una conexión con una instancia de EC2, Amazon DocumentDB lleva a cabo una acción basada en la configuración actual de los grupos de seguridad asociados a la base de datos de Amazon DocumentDB y la instancia de EC2, como se describe en la siguiente tabla:
| Configuración actual del grupo de seguridad de Amazon DocumentDB | Configuración del grupo de seguridad de EC2 actual | Acción de Amazon DocumentDB |
| --- | --- | --- |
| Hay uno o más grupos de seguridad asociados a la base de datos de Amazon DocumentDB con un nombre que coincide con el patrón DocumentDB-ec2-n. No se ha modificado ningún grupo de seguridad que coincida con el patrón. Este grupo de seguridad tiene solo una regla de entrada con el grupo de seguridad de VPC de la instancia de EC2 como origen. | Hay uno o más grupos de seguridad asociados a la instancia de EC2 con un nombre que coincide con el patrón DocumentDB-ec2-n (donde n es un número). No se ha modificado ningún grupo de seguridad que coincida con el patrón. Este grupo de seguridad solo tiene una regla de salida con el grupo de seguridad de VPC de la base de datos de Amazon DocumentDB como origen. | Amazon DocumentDB no lleva a cabo ninguna acción. Ya se configuró automáticamente una conexión entre la instancia de EC2 y la base de datos de Amazon DocumentDB. Como ya existe una conexión entre la instancia de EC2 y la base de datos de Amazon DocumentDB, los grupos de seguridad no se modifican. |
| Se aplica alguna de las siguientes condiciones: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/connect-ec2-auto.html) | Se aplica alguna de las siguientes condiciones: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/connect-ec2-auto.html) | Acción de Amazon DocumentDB: creación de nuevos grupos de seguridad |
| Hay uno o más grupos de seguridad asociados a la base de datos de Amazon DocumentDB con un nombre que coincide con el patrón DocumentDB-ec2-n. No se ha modificado ningún grupo de seguridad que coincida con el patrón. Este grupo de seguridad tiene solo una regla de entrada con el grupo de seguridad de VPC de la instancia de EC2 como origen. | Hay uno o más grupos de seguridad asociados a la instancia de EC2 con un nombre que coincide con el patrón ec2-DocumentDB-n. Sin embargo, Amazon DocumentDB no puede usar ninguno de estos grupos de seguridad para la conexión con la base de datos de Amazon DocumentDB. Amazon DocumentDB no puede usar un grupo de seguridad que no tenga una regla de salida con el grupo de seguridad de la VPC de la base de datos de Amazon DocumentDB como origen. Amazon DocumentDB tampoco puede usar un grupo de seguridad que se haya modificado. | Acción de Amazon DocumentDB: creación de nuevos grupos de seguridad |
| Hay uno o más grupos de seguridad asociados a la base de datos de Amazon DocumentDB con un nombre que coincide con el patrón DocumentDB-ec2-n. No se ha modificado ningún grupo de seguridad que coincida con el patrón. Este grupo de seguridad tiene solo una regla de entrada con el grupo de seguridad de VPC de la instancia de EC2 como origen. | Existe un grupo de seguridad de EC2 válido para la conexión, pero no está asociado a la instancia de EC2. Este grupo de seguridad tiene un nombre que coincide con el patrón DocumentDB-ec2-n. No se ha modificado. Solo tiene una regla de salida con el grupo de seguridad de VPC de la base de datos de Amazon DocumentDB como origen. | Acción de Amazon DocumentDB: asociación de un grupo de seguridad de EC2 |
| Se aplica alguna de las siguientes condiciones: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/connect-ec2-auto.html) | Hay uno o más grupos de seguridad asociados a la instancia de EC2 con un nombre que coincide con el patrón DocumentDB-ec2-n. No se ha modificado ningún grupo de seguridad que coincida con el patrón. Este grupo de seguridad solo tiene una regla de salida con el grupo de seguridad de VPC de la base de datos de Amazon DocumentDB como origen. | Acción de Amazon DocumentDB: creación de nuevos grupos de seguridad |
**Acción de Amazon DocumentDB: creación de nuevos grupos de seguridad**
Amazon DocumentDB lleva a cabo las siguientes acciones:
+ Crea un nuevo grupo de seguridad que coincide con el patrón `DocumentDB-ec2-n`. Este grupo de seguridad tiene una regla de entrada con el grupo de seguridad de VPC de la instancia de EC2 como origen. Este grupo de seguridad está asociado a la base de datos de Amazon DocumentDB y permite que la instancia de EC2 acceda a la base de datos de Amazon DocumentDB.
+ Crea un nuevo grupo de seguridad que coincide con el patrón `ec2-DocumentDB-n`. Este grupo de seguridad tiene una regla de salida con el grupo de seguridad de VPC de la base de datos de Amazon DocumentDB como origen. Este grupo de seguridad está asociado a la instancia de EC2 y permite que la instancia de EC2 envíe tráfico a la base de datos de Amazon DocumentDB.
**Acción de Amazon DocumentDB: asociación de un grupo de seguridad de EC2**
Amazon DocumentDB asocia el grupo de seguridad de EC2 válido y existente con la instancia de EC2. Este grupo de seguridad permite que la instancia de EC2 envíe tráfico a la base de datos de Amazon DocumentDB.
## Visualización de los recursos de computación conectados
Puede utilizarla Consola de administración de AWS para ver los recursos informáticos que están conectados a una base de datos de Amazon DocumentDB. Los recursos que se muestran incluyen conexiones de recursos informáticos que se configuraron automáticamente. Puede definir la conectividad con los recursos informáticos de manera automática de las siguientes maneras:
+ Puede seleccionar el recurso informático al crear la base de datos. Para obtener más información, consulte [Creación de un clúster de Amazon DocumentDB](db-cluster-create.md) y Creación de un clúster de base de datos Multi-AZ.
+ Puede configurar la conectividad entre una base de datos existente y un recurso informático. Para obtener más información, consulte [Conexión automática de Amazon EC2](#connect-ec2-auto).
Los recursos informáticos de la lista no incluyen los que se conectaron a la base de datos manualmente. Por ejemplo, puede permitir que un recurso informático acceda a una base de datos manualmente añadiendo una regla al grupo de seguridad de la VPC asociado a la base de datos.
Para que un recurso informático coincida, se deben cumplir las siguientes condiciones:
+ El nombre del grupo de seguridad asociado al recurso de computación coincide con el patrón `ec2-DocumentDB-n` (donde n es un número).
+ El grupo de seguridad asociado al recurso de computación tiene una regla de salida con el rango de puertos establecido en el puerto utilizado por la base de datos de Amazon DocumentDB.
+ El grupo de seguridad asociado al recurso de computación tiene una regla de salida en la que el origen está establecido en un grupo de seguridad asociado a la base de datos de Amazon DocumentDB.
+ El nombre del grupo de seguridad asociado a la base de datos de Amazon DocumentDB coincide con el patrón `DocumentDB-ec2-n` (donde n es un número).
+ El grupo de seguridad asociado a la base de datos de Amazon DocumentDB tiene una regla de entrada con el rango de puertos establecido en el puerto utilizado por la base de datos de Amazon DocumentDB.
+ El grupo de seguridad asociado a la base de datos de Amazon DocumentDB tiene una regla de entrada con el origen establecido en un grupo de seguridad asociado al recurso de computación.
**Visualización de los recursos de computación que están conectados a una base de datos de Amazon DocumentDB**
1. [Inicie sesión en y abra la Consola de administración de AWS consola de Amazon DocumentDB en https://console.aws.amazon.com /docdb.](https://console.aws.amazon.com/docdb)
1. En el panel de navegación, elija **Bases de datos** y, luego, el nombre de la instancia de base de datos de Amazon DocumentDB.
1. En la pestaña **Conectividad y seguridad**, consulte los recursos de computación en la sección **Recursos de computación conectados**.
# Conexión manual de Amazon EC2
**Topics**
+ [Paso 1: creación de una instancia de Amazon EC2](#manual-connect-ec2.launch-ec2-instance)
+ [Paso 2: crear un grupo de seguridad](#manual-connect-ec2.security-group)
+ [Paso 3: crear un clúster de Amazon DocumentDB](#manual-connect-ec2.launch-cluster)
+ [Paso 4: conectarse a su instancia de Amazon EC2](#manual-connect-ec2.connect)
+ [Paso 5: instalación del intérprete de comandos de MongoDB](#manual-connect-ec2.install-mongo-shell)
+ [Paso 6: administrar TLS de Amazon DocumentDB](#manual-connect-ec2.tls)
+ [Paso 7: conectarse a su clúster de Amazon DocumentDB](#manual-connect-ec2.connect-use)
+ [Paso 8: insertar y consultar datos](#manual-cloud9-insert-query)
+ [Paso 9: explorar](#manual-connect-ec2.explore)
En los siguientes pasos se presupone que ha completado los pasos que se detallan en el tema [Requisitos previos](connect-ec2.md#connect-ec2-prerequisites).
## Paso 1: creación de una instancia de Amazon EC2
En este paso, creará una instancia de Amazon EC2 en la misma región y Amazon VPC que utilizará más adelante para aprovisionar el clúster de Amazon DocumentDB.
1. En el panel de la consola de Amazon EC2, seleccione **Lanzar instancia**.
![\[La sección Lanzar instancia en la consola de Amazon EC2.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/launch-instance.png)
1. Ingrese un nombre o identificador en el campo **Nombre** ubicado en la sección **Nombres y etiquetas**.
1. En la lista desplegable **Imagen de máquina de Amazon (AMI)**, busque la **AMI de Amazon Linux 2** y selecciónela.
![\[La interfaz Imágenes de aplicaciones y sistema operativo con la opción AMI de Amazon Linux 2 seleccionada en la sección Inicio rápido.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/linux2-ami.png)
1. Busque y seleccione **t3.micro** en la lista desplegable de **Tipo de instancia**.
1. En la sección **Par de claves (inicio de sesión)**, ingrese el identificador de un par de claves existente o elija **Crear un par de claves nuevo**.
![\[La interfaz Par de claves, en la que se muestra el campo del nombre del par de claves y la opción Crear un nuevo par de claves.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/key-pair.png)
También debe proporcionar un par de claves de Amazon EC2.
+ Si tiene un par de claves de Amazon EC2:
1. Seleccione un par de claves, elija su par de claves de la lista.
1. Debe tener el archivo de clave privada (archivo .pem o .ppk) a su disposición para poder iniciar sesión en la instancia de Amazon EC2.
+ Si no tiene un par de claves de Amazon EC2:
1. Seleccione **Crear un par de claves nuevo** y aparecerá el cuadro de diálogo **Crear par de claves**.
1. Escriba un nombre en el campo **Nombre del par de claves**.
1. Seleccione el **Tipo de par de claves** y el **Formato de archivo de clave privada**.
1. Elija **Crear par de claves**.
![\[La interfaz Crear par de claves con campos para el nombre, el tipo y el formato de archivo del par de claves. El botón Crear par de claves se encuentra en la esquina inferior derecha.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/create-key-pair.png)
**nota**
Por motivos de seguridad, le recomendamos encarecidamente que utilice un par de claves para la conectividad a Internet y SSH con la instancia de EC2.
1. En la sección **Configuración de red**, en **Firewall (grupos de seguridad)**, elija **Crear grupo de seguridad** o **Seleccionar grupo de seguridad existente**.
![\[La interfaz Configuración de red, en la que se muestran opciones para crear un grupo de seguridad.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/firewall.png)
Si opta por seleccionar un grupo de seguridad existente, seleccione uno en la lista desplegable de **Grupos de seguridad comunes**.
Si ha optado por crear un grupo de seguridad nuevo, haga lo siguiente:
1. Compruebe todas las reglas de tráfico que se aplican a la conectividad de EC2.
1. En el campo IP, elija **Mi IP** o seleccione **Personalizado** para elegir entre una lista de bloques de CIDR, listas de prefijos o grupos de seguridad. No recomendamos **Cualquier lugar** como opción, a menos que la instancia de EC2 se encuentre en una red aislada, ya que permite el acceso a la instancia de EC2 desde cualquier dirección IP.
![\[El menú desplegable Mi IP.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/ip-field.png)
1. En la sección **Resumen**, revise la configuración de EC2 y, si es correcta, elija **Lanzar instancia**.
## Paso 2: crear un grupo de seguridad
Ahora creará un nuevo grupo de seguridad en su Amazon VPC predeterminada. El grupo de seguridad `demoDocDB` le permite conectarse a su clúster de Amazon DocumentDB en el puerto 27017 (el puerto predeterminado de Amazon DocumentDB) desde su instancia de Amazon EC2.
1. En la [Consola de administración de Amazon EC2](https://console.aws.amazon.com/ec2), en **Red y seguridad**, elija **Grupos de seguridad**.
![\[Panel de navegación de la consola Amazon DocumentDB con la opción Grupos de seguridad seleccionada en el menú desplegable Red y seguridad.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/nav-security-groups.png)
1. Elija **Creación de grupo de seguridad**.
![\[El botón Crear grupo de seguridad.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/create-sg-btn-2.png)
1. En la sección **Detalles básicos**:
1. En **Nombre del grupo de seguridad**, introduzca `demoDocDB`.
1. En **Descripción**, escriba una descripción.
1. En **VPC**, acepte el uso de la VPC predeterminada.
1. En la sección **Inbound rules (Reglas de entrada)**, elija **Add rule (agregar regla)**.
1. En **Tipo**, elija **Regla TCP personalizada** (predeterminada).
1. En **Rango de puertos**, introduzca `27017`.
1. En **Source** (Origen), seleccione **Custom** (Personalizado). En el campo contiguo, busque el grupo de seguridad que acaba de crear en el paso 1. Es posible que tenga que actualizar el navegador para que la consola Amazon EC2 complete automáticamente el nombre de la fuente .
![\[La sección de reglas de entrada, en la que se muestran los campos del tipo, el protocolo, el rango de puertos, el origen y la descripción. El botón Añadir regla se encuentra en la esquina inferior izquierda.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/inbound-rules.png)
1. Acepte todos los demás valores predeterminados y elija **Crear grupo de seguridad**.
![\[El botón Crear grupo de seguridad.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/create-sg-btn-2.png)
## Paso 3: crear un clúster de Amazon DocumentDB
Mientras se aprovisiona la instancia de Amazon EC2, creará su clúster de Amazon DocumentDB.
1. Navegue hasta la consola de Amazon DocumentDB y elija **Clústeres** en el panel de navegación.
1. Seleccione **Crear**.
1. Deje la configuración de **Tipo de clúster** como predeterminada en **Clúster basado en instancias**.
1. En **Configuración del clúster**, ingrese un nombre único en **Identificador de clúster**. Tenga en cuenta que la consola cambiará todos los nombres de los clústeres a minúsculas independientemente de cómo se ingresen.
Deje **Versión del motor** con su valor predeterminado de **5.0.0**.
1. En **Configuración del almacenamiento en clúster**, deje la configuración predeterminada de **Amazon DocumentDB estándar**.
1. En **Configuración de instancias**:
+ En **Clase de instancia de base de datos**, elija **Clases optimizadas para memoria (incluidas las clases r)**, que es la opción predeterminada.
**La otra opción de instancia son NVMe las clases respaldadas por comandos.** Para obtener más información, consulte [Instancias respaldadas por NVMe](db-instance-nvme.md).
+ En **Clase de instancia**, elija el tipo de instancia que se adapte a sus necesidades. Para obtener una explicación más detallada de las clases de instancia, consulte [Especificaciones de clases de instancias](db-instance-classes.md#db-instance-class-specs).
+ En **Número de instancias**, elija el número que mejor refleje sus necesidades. Recuerde que cuanto menor sea el número, menor será el costo y menor será el read/write volumen que puede administrar el clúster.
![\[La interfaz de configuración con valores predeterminados para el identificador del clúster, la versión del motor y la clase de instancia, con el número de instancias establecido en uno.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/create-cluster/instance-config.png)
1. En **Conectividad**, deje la configuración predeterminada de **No conectarse a un recurso de computación de EC2**.
**nota**
La conexión a un recurso de computación de EC2 crea automáticamente grupos de seguridad para la conexión al clúster. Como en el paso anterior creó estos grupos de seguridad manualmente, debe seleccionar **No conectarse a un recurso de computación de EC2** para no crear un segundo conjunto de grupos de seguridad.
1. En la sección **Autenticación**, ingrese un nombre de usuario para el usuario principal y, a continuación, elija **Autoadministrado**. Ingrese una contraseña y, a continuación, confírmela.
Si, en su lugar, eligió **Administrado en AWS Secrets Manager**, consulte [Administración de contraseñas con Amazon DocumentDB y AWS Secrets Manager](docdb-secrets-manager.md) para obtener más información.
1. Elija **Create cluster**.
## Paso 4: conectarse a su instancia de Amazon EC2
La conexión de la instancia de Amazon EC2 le permitirá instalar el intérprete de comandos de MongoDB. La instalación del intérprete de comandos de mongo permite conectarse a su clúster de Amazon DocumentDB y realizar consultas en él. Realice los siguientes pasos:
1. En la consola Amazon EC2, navegue hasta sus instancias y compruebe si la instancia que acaba de crear se está ejecutando. Si es así, haga clic en el ID de la instancia para seleccionar la instancia.
![\[Tabla de instancias con una lista de dos instancias de la consola de Amazon EC2\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/ec2-instance-table.png)
1. Elija **Conectar**.
![\[Resumen de instancias de una instancia de Amazon EC2. El botón Conectar se encuentra en la esquina superior derecha.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/ec2-instance-summary.png)
1. Hay cuatro opciones con pestañas para el método de conexión: Amazon EC2 Instance Connect, Session Manager, cliente SSH o consola serie de EC2. Debe elegir uno y seguir sus instrucciones. Cuando haya terminado, elija **Conectar**.
![\[Interfaz en la que se muestran las opciones de configuración del método de conexión EC2 Instance Connect.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/ec2/connect-options.png)
**nota**
Si su dirección IP ha cambiado después de iniciar este tutorial o si va a volver a su entorno más adelante, debe actualizar la regla de entrada del grupo de seguridad `demoEC2` para habilitar el tráfico entrante desde su nueva dirección de API.
## Paso 5: instalación del intérprete de comandos de MongoDB
Ahora puede instalar el intérprete de comandos de MongoDB, que es una utilidad de línea de comandos que se utiliza para conectarse al clúster de Amazon DocumentDB y consultarlo. Actualmente hay dos versiones del intérprete de comandos de MongoDB: la versión más reciente, mongosh, y la versión anterior, el intérprete de comandos de mongo.
**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 Node.js y las herramientas que utilizan el controlador Node.js (como mongosh) deben actualizarse al controlador Node.js versión 6.13.1 o posterior.
Siga las siguientes instrucciones para instalar el intérprete de comandos de MongoDB en su sistema operativo.
------
#### [ On Amazon Linux ]
**Cómo instalar el intérprete de comandos de MongoDB en Amazon Linux**
Si *no* utiliza IAM y desea utilizar el último intérprete de comandos de MongoDB (mongosh) para conectarse a su clúster de Amazon DocumentDB, siga estos pasos:
1. Cree el archivo de repositorio. En la línea de comando de la instancia de EC2 que creó, escriba el siguiente comando:
```
echo -e "[mongodb-org-5.0] \nname=MongoDB Repository\nbaseurl=https://repo.mongodb.org/yum/amazon/2023/mongodb-org/5.0/x86_64/\ngpgcheck=1 \nenabled=1 \ngpgkey=https://pgp.mongodb.com/server-5.0.asc" | sudo tee /etc/yum.repos.d/mongodb-org-5.0.repo
```
1. Cuando esté completo, instale mongosh con una de las siguientes opciones de comando en el símbolo del sistema:
**Opción 1**: si eligió Amazon Linux 2023 (predeterminado) durante la configuración de Amazon EC2, introduzca este comando:
```
sudo yum install -y mongodb-mongosh-shared-openssl3
```
**Opción 2**: si eligió Amazon Linux 2 durante la configuración de Amazon EC2, introduzca este comando:
```
sudo yum install -y mongodb-mongosh
```
Si utiliza IAM, debe utilizar la versión anterior del intérprete de comandos de MongoDB (5.0) para conectarse al clúster de Amazon DocumentDB. Siga estos pasos:
1. Cree el archivo de repositorio. En la línea de comando de la instancia de EC2 que creó, escriba el siguiente comando:
```
echo -e "[mongodb-org-5.0] \nname=MongoDB Repository\nbaseurl=https://repo.mongodb.org/yum/amazon/2023/mongodb-org/5.0/x86_64/\ngpgcheck=1 \nenabled=1 \ngpgkey=https://pgp.mongodb.com/server-5.0.asc" | sudo tee /etc/yum.repos.d/mongodb-org-5.0.repo
```
1. Cuando esté completo, instale el intérprete de comandos de MongoDB 5.0 con la siguiente opción de comando en el símbolo del sistema:
```
sudo yum install -y mongodb-org-shell
```
------
#### [ On Ubuntu ]
**Cómo instalar mongosh en Ubuntu**
1. Importe la clave pública que utilizará el sistema de administración de paquetes.
```
curl -fsSL https://pgp.mongodb.com/server-5.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-server-5.0.gpg
```
1. Cree el archivo de lista `mongodb-org-5.0.list` para MongoDB mediante el comando correspondiente a su versión de Ubuntu.
```
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-5.0.gpg ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/5.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-5.0.list
```
1. Importe y actualice la base de datos del paquete local utilizando el siguiente comando:
```
sudo apt-get update
```
1. Instale mongosh.
```
sudo apt-get install -y mongodb-mongosh
```
Para obtener información sobre cómo instalar las versiones anteriores de MongoDB en un sistema Ubuntu, consulte [Install MongoDB Community Edition on Ubuntu](https://docs.mongodb.com/v3.6/tutorial/install-mongodb-on-ubuntu/).
------
#### [ On other operating systems ]
Para instalar el intérprete de comandos de mongo en otros sistemas operativos, consulte el tema sobre [cómo instalar MongoDB Community Edition](https://www.mongodb.com/docs/manual/administration/install-community/) en la documentación de MongoDB.
------
## Paso 6: administrar TLS de Amazon DocumentDB
Descargue el certificado CA para Amazon DocumentDB con el siguiente código: `wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem`
**nota**
La seguridad de la capa de transporte (TLS) está habilitada de forma predeterminada para todos los clústeres nuevos de Amazon DocumentDB. Para obtener más información, consulte [Managing Amazon DocumentDB cluster TLS settings](https://docs.aws.amazon.com/documentdb/latest/developerguide/security.encryption.ssl.html).
## Paso 7: conectarse a su clúster de Amazon DocumentDB
1. En la consola de Amazon DocumentDB, en **Clústeres**, localice su clúster. Haga clic en **Identificador del clúster** para elegir el clúster que creó.
![\[Lista de clústeres de Amazon DocumentDB en la que se muestra un clúster regional con detalles de la instancia principal.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/cluster-connect-choose.png)
1. En la pestaña **Conectividad y seguridad**, busque **Conectar a este clúster con el intérprete de comandos de mongo** en el cuadro **Conectar**:
![\[Configuración de conexión del clúster con la cadena de conexión de MongoDB resaltada para conectarse a un clúster de Amazon DocumentDB mediante el intérprete de comandos de mongo.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/connect-mongosh.png)
Copie la cadena de conexión proporcionada y péguela en el terminal.
Haga los siguientes cambios en ella:
1. Asegúrese de que tenga el nombre de usuario correcto en la cadena.
1. Omita `` para que el intérprete de comandos de mongo le pida la contraseña cuando se conecte.
1. Opcional: si utiliza la autenticación de IAM o utiliza la versión anterior del intérprete de comandos de MongoDB, modifique la cadena de conexión de la siguiente manera:
`mongo --ssl --host mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1.docdb.amazonaws.com:27017 --sslCAFile global-bundle.pem --username SampleUser1 --password`
Sustituya `mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1` por la misma información de su clúster.
1. Pulse Intro en el terminal. Ahora se le solicitará la contraseña. Introduzca su contraseña.
1. Cuando introduzca la contraseña y pueda ver el mensaje `rs0 [direct: primary] >`, significa que se ha conectado correctamente a su clúster de Amazon DocumentDB.
¿Tiene problemas para conectarse? Consulte [Solución de problemas de Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/troubleshooting.html).
## Paso 8: insertar y consultar datos
Ahora que está conectado a su clúster, puede realizar algunas consultas para familiarizarse con el uso de una base de datos de documentos.
1. Para insertar un solo documento, escriba lo siguiente:
```
db.collection.insertOne({"hello":"DocumentDB"})
```
Obtiene el siguiente resultado:
```
{
acknowledged: true,
insertedId: ObjectId('673657216bdf6258466b128c')
}
```
1. Puede leer el documento que escribió con el comando `findOne()` (ya que solo devuelve un documento). La siguiente entrada:
```
db.collection.findOne()
```
Obtiene el siguiente resultado:
```
{ "_id" : ObjectId("5e401fe56056fda7321fbd67"), "hello" : "DocumentDB" }
```
1. Para realizar algunas consultas más, plantéese un caso de uso de perfiles de juegos. Primero, inserte algunas entradas en una colección titulada `profiles`. La siguiente entrada:
```
db.profiles.insertMany([{ _id: 1, name: 'Matt', status: 'active', level: 12, score: 202 },
{ _id: 2, name: 'Frank', status: 'inactive', level: 2, score: 9 },
{ _id: 3, name: 'Karen', status: 'active', level: 7, score: 87 },
{ _id: 4, name: 'Katie', status: 'active', level: 3, score: 27 }
])
```
Obtiene el siguiente resultado:
```
{ acknowledged: true, insertedIds: { '0': 1, '1': 2, '2': 3, '3': 4 } }
```
1. Utilice el comando `find()` para devolver todos los documentos de la colección de perfiles. La siguiente entrada:
```
db.profiles.find()
```
Obtendrá un resultado que coincidirá con los datos que escribió en el paso 3.
1. Utilice una consulta para un único documento mediante un filtro. La siguiente entrada:
```
db.profiles.find({name: "Katie"})
```
Obtiene el siguiente resultado:
```
{ "_id" : 4, "name" : "Katie", "status": "active", "level": 3, "score":27}
```
1. Ahora intentemos buscar un perfil y modificarlo con el comando `findAndModify`. Le daremos al usuario Matt 10 puntos adicionales con el siguiente código:
```
db.profiles.findAndModify({
query: { name: "Matt", status: "active"},
update: { $inc: { score: 10 } }
})
```
Se obtiene el siguiente resultado (tenga en cuenta que la puntuación aún no ha aumentado):
```
{
[{_id : 1, name : 'Matt', status: 'active', level: 12, score: 202}]
```
1. Puede comprobar que su puntuación ha cambiado con la siguiente consulta:
`db.profiles.find({name: "Matt"})`
Obtiene el siguiente resultado:
```
{ "_id" : 1, "name" : "Matt", "status" : "active", "level" : 12, "score" : 212 }
```
## Paso 9: explorar
¡Enhorabuena\$1 Ha completado correctamente la Guía de inicio rápido para Amazon DocumentDB.
Pasos siguientes Descubra cómo aprovechar al máximo esta potente base de datos con algunas de sus características más populares:
+ [Administración de Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/managing-documentdb.html)
+ [Escalado](https://docs.aws.amazon.com/documentdb/latest/developerguide/operational_tasks.html)
+ [Copia de seguridad y restauración](https://docs.aws.amazon.com/documentdb/latest/developerguide/backup_restore.html)
**nota**
Para ahorrar costos, puede detener el clúster de Amazon DocumentDB para reducir los costos o eliminar el clúster. De forma predeterminada, tras 30 minutos de inactividad, el AWS Cloud9 entorno detendrá la instancia Amazon EC2 subyacente.
# Conexión mediante el controlador JDBC de Amazon DocumentDB
El controlador JDBC para Amazon DocumentDB proporciona una interfaz relacional de SQL para los desarrolladores y permite la conectividad desde herramientas de BI como Tableau y. DbVisualizer
Para obtener información más detallada, consulte la documentación del controlador [JDBC de Amazon DocumentDB](https://github.com/aws/amazon-documentdb-jdbc-driver/blob/develop/src/markdown/index.md) en. GitHub
**Topics**
+ [Introducción](#connect-jdbc-gettingstarted)
+ [Conexión a Amazon DocumentDB desde Tableau Desktop](connect-jdbc-tableau.md)
+ [Conéctese a Amazon DocumentDB desde DbVisualizer](connect-jdbc-DbVisualizer.md)
+ [Generación automática de esquemas JDBC](connect-jdbc-autoschemagen.md)
+ [Compatibilidad y limitaciones de SQL](connect-jdbc-sqlandlimits.md)
+ [Resolución de problemas](connect-jdbc-troubleshooting.md)
## Introducción
**Paso 1. Creación de un clúster de Amazon DocumentDB**
Si no ha creado un clúster de Amazon DocumentDB, cree uno siguiendo las instrucciones de la sección [Introducción](https://docs.aws.amazon.com/documentdb/latest/developerguide/get-started-guide.html) de la Guía para desarrolladores de Amazon DocumentDB.
Amazon DocumentDB es un servicio exclusivo de nube privada virtual (VPC). Si se conecta desde una máquina local, fuera de la VPC del clúster, necesitará crear una conexión SSH a una instancia de Amazon EC2. En este caso, inicie el clúster siguiendo las instrucciones de [Conexión con EC2](https://docs.aws.amazon.com/documentdb/latest/developerguide/connect-ec2.html). Consulte [Cómo usar un túnel SSH para conectarse a Amazon DocumentDB](https://github.com/aws/amazon-documentdb-jdbc-driver/blob/develop/src/markdown/setup/setup.md#using-an-ssh-tunnel-to-connect-to-amazon-documentdb) para obtener más información sobre los túneles SSH y cuándo podría necesitarlos.
**Paso 2. Instalación de JRE o JDK**
En función de la aplicación de BI que utilice, es posible que tenga instalada en su ordenador una instalación JRE o JDK de 64 bits, versión 8 o posterior. Puede descargar el Java SE Runtime Environment 8 [aquí.](https://www.oracle.com/ca-en/java/technologies/javase-jre8-downloads.html)
**Paso 3. Descarga del controlador JDBC de DocumentDB**
Descargue el controlador JDBC de DocumentDB desde [aquí](https://github.com/aws/amazon-documentdb-jdbc-driver/releases). El controlador está empaquetado como un único archivo JAR (por ejemplo, documentdb-jdbc-1.0.0-all.jar).
**Paso 4. Cómo usar un túnel SSH para conectarse a Amazon DocumentDB**
Los clústeres de Amazon DocumentDB (compatible con MongoDB) se implementan en una instancia de Amazon Virtual Private Cloud (Amazon VPC). Se puede acceder a ellos directamente mediante instancias de Amazon EC2 u otros AWS servicios que se desplieguen en la misma Amazon VPC. Además, EC2a instancias u otros AWS servicios de la misma AWS región o de otras regiones pueden acceder a Amazon DocumentDB mediante la interconexión de VPC. VPCs
Puede utilizar la tunelización SSH (también conocida como reenvío de puertos) para acceder a los recursos de Amazon DocumentDB desde fuera de la VPC del clúster. Este será el caso de la mayoría de los usuarios que no ejecuten su aplicación en una máquina virtual de la misma VPC que el clúster de DocumentDB.
Para crear un túnel SSH, necesita una instancia de Amazon EC2 que se ejecute en la misma VPC de Amazon que el clúster de Amazon DocumentDB. Puede usar una instancia EC2 existente en la misma VPC que el clúster o crear una. Si es así, puede configurar un túnel de SSH en el clúster de Amazon DocumentDB `sample-cluster.node.us-east-1.docdb.amazonaws.com` ejecutando el siguiente comando en el equipo local.
```
ssh -i "ec2Access.pem" -L 27017:sample-cluster.node.us-east-1.docdb.amazonaws.com:27017 ubuntu@ec2-34-229-221-164.compute-1.amazonaws.com -N
```
La marca -L se utiliza para el reenvío de un puerto local. Este es un requisito previo para conectarse a cualquier herramienta de BI que se ejecute en un cliente externo a su VPC. Una vez realizado el paso anterior, puede pasar a los siguientes con la herramienta de BI que prefiera.
Para obtener más información sobre los túneles SSH, consulte la documentación sobre [Uso de un túnel SSH para conectarse a Amazon DocumentDB](https://github.com/aws/amazon-documentdb-jdbc-driver/blob/develop/src/markdown/setup/setup.md#using-an-ssh-tunnel-to-connect-to-amazon-documentdb ).
# Conexión a Amazon DocumentDB desde Tableau Desktop
**Topics**
+ [Adición del controlador JDBC de Amazon DocumentDB](#connect-jdbc-tableau-adddriver)
+ [Conexión a Amazon DocumentDB mediante Tableau - Túnel SSH](#connect-jdbc-tableau-ssh)
## Adición del controlador JDBC de Amazon DocumentDB
Para conectar con Amazon DocumentDB desde Tableau Desktop, debe descargar e instalar el controlador JDBC de Amazon DocumentDB y el conector de DocumentDB para Tableau.
1. Descargue el archivo JAR del controlador JDBC de Amazon DocumentDB del [repositorio de controladores JDBC de Amazon DocumentDB](https://github.com/aws/amazon-documentdb-jdbc-driver/releases) y cópielo en uno de los siguientes directorios según su sistema operativo:
+ *Windows* - `C:\Program Files\Tableau\Drivers`
+ *MacOS* - `~/Library/Tableau/Drivers`
1. Descargue el conector de DocumentDB para Tableau (un archivo TACO) del [sitio web de Tableau Exchange](https://exchange.tableau.com/products/821) y cópielo en su directorio *Mi* Tableau. Repository/Connectors
+ *Windows* - `C:\Users\[user]\Documents\My Tableau Repository\Connectors`
+ *MacOS* - `/Users/[user]/Documents/My Tableau Repository/Connectors`
Para obtener información adicional, consulte la [documentación de Tableau](https://tableau.github.io/connector-plugin-sdk/docs/run-taco).
**nota**
[Si utiliza certificados de CA más recientes, asegúrese de actualizar el controlador JDBC a la versión 1.4.5 (disponible en este repositorio). AWS GitHub ](https://github.com/aws/amazon-documentdb-jdbc-driver/releases/tag/v1.4.5)
## Conexión a Amazon DocumentDB mediante Tableau - Túnel SSH
Para conectarse a Tableau desde un equipo cliente fuera de la VPC de su clúster de DocumentDB, debe configurar un túnel SSH antes de seguir los pasos que se indican a continuación:
1. Inicie la aplicación Tableau Desktop.
1. Vaya a **Conectar** > **A un servidor** > **Más**.
1. Elija **Amazon DocumentDB de Amazon Web Services en** **Conectores instalados**.
![\[La interfaz Conexión en Tableau Desktop muestra el submenú Más… en la sección A un servidor. La opción Amazon DocumentDB aparece resaltada en el submenú Conectores instalados.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/tableau-choose-docdb.png)
**Conexión a Amazon DocumentDB mediante Tableau: túnel SSH externo**
1. Introduzca los parámetros de conexión necesarios: **Nombre de host**, **Puerto**, **Base de datos**, **Nombre de usuario** y **Contraseña**. Los parámetros de conexión del ejemplo siguiente son equivalentes a la cadena de conexión JDBC:
`jdbc:documentdb://localhost:27019/test? tls=true&tlsAllowInvalidHostnames=true&scanMethod=random&scanLimit=1000&loginTimeoutSec=0&readPreference=primary&retryReads=true&schemaName=_default` con los parámetros de nombre de usuario y contraseña transferidos por separado en una colección de propiedades. Para obtener más información sobre los parámetros de la cadena de conexión, consulte la [documentación de GitHub del controlador JDBC de Amazon DocumentDB](https://github.com/aws/amazon-documentdb-jdbc-driver/blob/develop/src/markdown/setup/connection-string.md).
![\[Pestaña General de la interfaz del conector de Amazon DocumentDB, en la que se muestran los campos de nombre de host, puerto, base de datos, nombre de usuario y contraseña.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/tableau-connect.png)
1. (Opcional) Puede encontrar opciones más avanzadas en la pestaña **Avanzado**.
![\[Pestaña Avanzado de la interfaz del conector de Amazon DocumentDB, en la que se muestran opciones de conexión adicionales.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/tableau-advanced.png)
1. Seleccione **Iniciar sesión**.
**Conexión a Amazon DocumentDB mediante Tableau: túnel SSH interno**
**nota**
Si prefiere no configurar el túnel SSH mediante un terminal, puede usar la GUI de Tableau para especificar los detalles de su instancia EC2, que el controlador JDBC utilizará de forma inherente para crear un túnel SSH.
1. En la pestaña **Avanzado**, elija la opción **Habilitar el túnel SSH** para revisar otras propiedades.
![\[Pestaña Avanzado de la interfaz del conector de Amazon DocumentDB con la opción Activar túnel SSH seleccionada y los campos de entrada SSH adicionales mostrados.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/tableau-advanced-Enablessh.png)
1. Introduzca el **Usuario SSH**, el **Nombre de host SSH** y el **Archivo de clave privada SSH**.
1. (Opcional) Puede deshabilitar la opción de **verificación estricta de la clave de host de SSH**, que evita la verificación de la clave de host con un archivo de hosts conocido.
**nota**
La desactivación de esta opción es menos segura, ya que puede provocar un ataque. [man-in-the-middle](https://en.wikipedia.org/wiki/Man-in-the-middle_attack)
![\[Pestaña Avanzado de la interfaz del conector de Amazon DocumentDB con la opción Verificación estricta de la clave de host de SSH desactivada.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/tableau-advanced-sshhostkeycheck.png)
1. Introduzca los parámetros necesarios: **Nombre de host**, **Puerto**, **Base de datos**, **Nombre de usuario** y **Contraseña**.
**nota**
Asegúrese de utilizar el punto de conexión del clúster de DocumentDB y no localhost cuando utilice la opción de túnel SSH interno.
![\[Pestaña General de la interfaz del conector de Amazon DocumentDB, en la que se muestran los campos de nombre de host, puerto, base de datos, nombre de usuario y contraseña.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/tableau-hostname.png)
1. Elija **Iniciar sesión**.
# Conéctese a Amazon DocumentDB desde DbVisualizer
**Topics**
+ [Adición del controlador JDBC de Amazon DocumentDB](#connect-jdbc-DbVisualizer-adddriver)
+ [Conexión a Amazon DocumentDB mediante DbVisualizer](#connect-jdbc-DbVisualizer-connect)
## Adición del controlador JDBC de Amazon DocumentDB
Para conectarse a Amazon DocumentDB desde, primero DbVisualizer debe importar el controlador JDBC de Amazon DocumentDB.
1. Inicie la DbVisualizer aplicación y navegue hasta la ruta del menú: **Herramientas** > Administrador de controladores...
1. Elija **\$1** (o en el menú, seleccione **Controlador > Crear controlador**).
1. Establezca **Name (Nombre)** en `DocumentDB`.
1. Defina el **formato de URL** en `jdbc:documentdb://[:port]/[?option=value[&option=value[...]]]`
1. Elija el botón de **carpeta** y luego seleccione el archivo JAR del controlador JDBC de Amazon DocumentDB y luego pulse el botón **Abrir**.
1. Compruebe que el campo **Clase de controlador** esté establecido en `software.amazon.documentdb.jdbc.DocumentDbDriver`. La configuración del Administrador de controladores para **DocumentDB** debe tener el siguiente aspecto.
![\[La interfaz de configuración del controlador incluye DbVisualizer el nombre de Amazon DocumentDB, el formato de URL y las configuraciones de clase de controlador ingresadas.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/DbVisualizer-adddriver.jpg)
1. Cierre el cuadro de diálogo. El controlador JDBC de Amazon DocumentDB estará configurado y listo para usarse.
## Conexión a Amazon DocumentDB mediante DbVisualizer
Conéctese a Amazon DocumentDB mediante DbVisualizer
1. Si se conecta desde fuera de la VPC del clúster de Amazon DocumentDB, asegúrese de haber configurado un túnel SSH.
1. Seleccione **Base de datos > Crear conexión a base de datos** en el menú de nivel superior.
1. En el campo **Nombre**, ingrese un nombre descriptivo.
1. Establezca **Controlador (JDBC)** en el controlador de DocumentDB que creó en la sección anterior.
1. Establezca la **URL de la base de datos** en la cadena de conexión JDBC.
Por ejemplo: `jdbc:documentdb://localhost:27017/database?tlsAllowInvalidHostnames=true`
1. Establezca el **ID de usuario de la base de datos** en su ID de usuario de Amazon DocumentDB.
1. Establezca la **contraseña de la base de datos** como la contraseña correspondiente al ID de usuario.
El cuadro de diálogo de conexión a la base de datos debe tener el siguiente aspecto:
![\[Interfaz Conexión a base de datos con configuración de DocumentDB.\]](http://docs.aws.amazon.com/es_es/documentdb/latest/developerguide/images/jdbc/DbVisualizer-connect.jpg)
1. Elija **Connect (Conectar)**.
# Generación automática de esquemas JDBC
Amazon DocumentDB es una base de datos de documentos y, por lo tanto, no tiene el concepto de tablas y esquema. Sin embargo, las herramientas de inteligencia empresarial, como Tableau, esperan que la base de datos a la que se conecta presente un esquema. En concreto, cuando la conexión del controlador JDBC necesite obtener el esquema de la colección en la base de datos, consultará todas las colecciones de la base de datos. El controlador determinará si ya existe una versión en caché del esquema para esa colección. Si no existe una versión en caché, tomará muestras de la colección de documentos y creará un esquema basado en el siguiente comportamiento.
**Topics**
+ [Limitaciones de generación de esquemas](#connect-jdbc-autoschemagen-limits)
+ [Opciones del método de análisis](#connect-jdbc-autoschemagen-scanningoptions)
+ [Tipos de datos de Amazon DocumentDB](#connect-jdbc-autoschemagen-datatypes)
+ [Asignación de campos de documentos escalares](#connect-jdbc-autoschemagen-scalarfields)
+ [Manejo de tipos de datos de objetos y matrices](#connect-jdbc-autoschemagen-objectandarray)
## Limitaciones de generación de esquemas
El controlador JDBC de DocumentDB impone un límite de 128 caracteres a la longitud de los identificadores. El generador de esquemas puede truncar la longitud de los identificadores generados (nombres de tablas y nombres de columnas) para garantizar que se ajusten a ese límite.
## Opciones del método de análisis
El comportamiento del muestreo se puede modificar mediante la cadena de conexión o las opciones de origen de datos.
+ *scanMethod=*