Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Entwickeln mit Amazon DocumentDB
In diesen Abschnitten wird die Entwicklung mit Amazon DocumentDB behandelt.
**Topics**
+ [Mit DocumentDB Connect](connect-docdb.md)
+ [Programm mit DocumentDB](program-docdb.md)
# Connect zu Amazon DocumentDB her
Amazon DocumentDB bietet mehrere Verbindungsoptionen, darunter programmatische Verbindungen mithilfe von MongoDB-Treibern, Verbindungen von außerhalb einer VPC über SSH-Tunneling oder AWS VPN sowie beliebte Tools wie Studio 3T und. DataGrip Der Service unterstützt Verbindungen mit Replikatgruppen für hohe Verfügbarkeit. Für Analysen und Berichte können Sie mithilfe von JDBC- oder ODBC-Treibern eine Verbindung herstellen. EC2 Instanzen in derselben VPC können sich direkt mit DocumentDB-Clustern verbinden. Alle Verbindungen erfordern TLS und die richtigen AWS Anmeldeinformationen/Authentifizierung.
**Topics**
+ [Programmgesteuert eine Verbindung herstellen](connect_programmatically.md)
+ [Verbindung von außerhalb einer Amazon VPC herstellen](connect-from-outside-a-vpc.md)
+ [Als Replikatsatz eine Verbindung herstellen](connect-to-replica-set.md)
+ [Connect mit Studio 3T her](studio3t.md)
+ [Connect mit DataGrip](data-grip-connect.md)
+ [Stellen Sie mithilfe von Amazon EC2 eine Verbindung her](connect-ec2.md)
+ [Stellen Sie mithilfe des JDBC-Treibers eine Verbindung her](connect-jdbc.md)
+ [Stellen Sie mithilfe des ODBC-Treibers eine Verbindung her](connect-odbc.md)
# Programmgesteuertes Herstellen einer Verbindung zu Amazon DocumentDB
Dieser Abschnitt enthält Codebeispiele, die zeigen, wie Sie mithilfe verschiedener Sprachen eine Verbindung zu Amazon DocumentDB (mit MongoDB-Kompatibilität) herstellen können. Die Beispiele sind in zwei Abschnitte unterteilt: Verbindung mit einem Cluster mit und ohne aktiviertem TLS (Transport Layer Security). Standardmäßig ist TLS auf Amazon DocumentDB-Clustern aktiviert. Sie können TLS jedoch bei Bedarf deaktivieren. Weitere Informationen finden Sie unter [Verschlüsseln von Daten während der Übertragung](security.encryption.ssl.md).
Wenn Sie versuchen, von außerhalb der VPC, in der sich Ihr Cluster befindet, eine Verbindung zu Ihrer Amazon DocumentDB herzustellen, lesen Sie bitte [Von außerhalb einer Amazon VPC eine Verbindung zu einem Amazon DocumentDB-Cluster herstellen](connect-from-outside-a-vpc.md).
Bevor Sie sich mit Ihrem Cluster verbinden, müssen Sie wissen, ob TLS auf dem Cluster aktiviert ist. Der nächste Abschnitt zeigt Ihnen, wie Sie den Wert des Parameters `tls` Ihres Clusters mit der AWS-Managementkonsole oder der AWS CLI bestimmen können. Danach können Sie fortfahren, indem Sie das entsprechende Codebeispiel anwenden.
**Topics**
+ [
## Ermitteln Sie den Wert Ihres Parameters `tls`
](#connect_programmatically-determine_tls_value)
+ [
## Verbindung bei aktiviertem TLS herstellen
](#connect_programmatically-tls_enabled)
+ [
## Verbindung bei deaktiviertem TLS herstellen
](#connect_programmatically-tls_disabled)
## Ermitteln Sie den Wert Ihres Parameters `tls`
Die Feststellung, ob TLS in Ihrem Cluster aktiviert ist, ist ein zweistufiger Prozess, den Sie entweder mit AWS-Managementkonsole oder AWS CLI durchführen können.
1. **Bestimmen Sie, welche Parametergruppe Ihren Cluster steuert.**
------
#### [ Using the AWS-Managementkonsole ]
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon DocumentDB DocumentDB-Konsole unter [https://console.aws.amazon.com/docdb](https://console.aws.amazon.com/docdb).
1. Wählen Sie im linken Navigationsbereich **Cluster** aus.
1. Wählen Sie in der Liste der Cluster den Namen des Clusters aus.
1. Auf der anschließend angezeigten Seite werden die Details des von Ihnen ausgewählten Clusters angezeigt. Wählen Sie die Registerkarte **Configuration** aus. Suchen Sie im Abschnitt **Konfigurationen und Status** den Namen der Parametergruppe unter **Cluster-Parametergruppe**.
------
#### [ Using the AWS CLI ]
Der folgende AWS CLI Code bestimmt, welcher Parameter Ihren Cluster steuert. Ersetzen Sie *`sample-cluster`* durch den Namen Ihres Clusters.
```
aws docdb describe-db-clusters \
--db-cluster-identifier sample-cluster \
--query 'DBClusters[*].[DBClusterIdentifier,DBClusterParameterGroup]'
```
Die Ausgabe dieser Operation sieht in etwa wie folgt aus:
```
[
[
"sample-cluster",
"sample-parameter-group"
]
]
```
------
1. **Bestimmen Sie den Wert des Parameters `tls` in der Parametergruppe Ihres Clusters**.
------
#### [ Using the AWS-Managementkonsole ]
1. Wählen Sie im Navigationsbereich **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie im Fenster **Cluster-Parametergruppen** den Namen Ihrer Cluster-Parametergruppe aus Schritt 1d aus.
1. Auf der Ergebnisseite werden die Parameter der Cluster-Parametergruppe angezeigt. Hier können Sie den Wert des `tls`-Parameters sehen. Informationen zum Ändern dieses Parameters finden Sie unter [Amazon DocumentDB-Cluster-Parametergruppen ändern](cluster_parameter_groups-modify.md).
------
#### [ Using the AWS CLI ]
Sie können den `describe-db-cluster-parameters` AWS CLI Befehl verwenden, um die Details der Parameter in Ihrer Cluster-Parametergruppe anzuzeigen.
+ **`--describe-db-cluster-parameters`**— Um alle Parameter innerhalb einer Parametergruppe und ihre Werte aufzulisten.
+ **`--db-cluster-parameter-group name`** – Erforderlich. Der Name Ihrer Cluster-Parametergruppe.
Ersetzen Sie in den folgenden Beispielen jeden *user input placeholder* durch die Informationen Ihres Clusters.
```
aws docdb describe-db-cluster-parameters \
--db-cluster-parameter-group-name sample-parameter-group
```
Die Ausgabe dieser Operation sieht in etwa wie folgt aus:
```
{
"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"
}
]
}
```
**Anmerkung**
Amazon DocumentDB unterstützt FIPS 140-3-Endpunkte, beginnend mit Amazon DocumentDB 5.0-Clustern (Engine-Version 3.0.3727) in diesen Regionen: ca-central-1, us-west-2, us-east-1, us-east-2, -1, -1. us-gov-east us-gov-west
------
Nachdem Sie den Wert des `tls`-Parameters bestimmt haben, fahren Sie mit dem Herstellen einer Verbindung zu Ihrem Cluster fort, indem Sie eines der Codebeispiele in den folgenden Abschnitten verwenden.
+ [Verbindung bei aktiviertem TLS herstellen](#connect_programmatically-tls_enabled)
+ [Verbindung bei deaktiviertem TLS herstellen](#connect_programmatically-tls_disabled)
## Verbindung bei aktiviertem TLS herstellen
Um ein Codebeispiel für die programmgesteuerte Verbindung zu einem TLS-fähigen Amazon DocumentDB-Cluster anzuzeigen, wählen Sie die entsprechende Registerkarte für die Sprache, die Sie verwenden möchten.
Um Daten während der Übertragung zu verschlüsseln, laden Sie den öffentlichen Schlüssel für Amazon DocumentDB `global-bundle.pem` mit dem folgenden Vorgang herunter.
```
wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem
```
Wenn Ihre Anwendung unter Microsoft Windows läuft und eine PKCS7 Datei benötigt, können Sie das PKCS7 Zertifikatspaket herunterladen. Dieses Paket enthält sowohl die Zwischen- als auch die Stammzertifikate unter [https://truststore.pki.rds.amazonaws.com/global/global-bundle.p7b](https://truststore.pki.rds.amazonaws.com/global/global-bundle.p7b).
------
#### [ Python ]
Der folgende Code zeigt, wie Sie mit Python eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit Node.js eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
**Wichtig**
Es gibt eine bekannte Einschränkung bei Treibern von Node.js, die älter als Version 6.13.1 sind und die derzeit nicht von der IAM-Identitätsauthentifizierung für Amazon DocumentDB unterstützt werden. Die Treiber und Tools der Datei Node.js, die den Treiber Node.js verwenden (z. B. mongosh), müssen aktualisiert werden, sodass sie den Treiber Node.js der Version 6.13.1 oder höher verwenden.
Ersetzen Sie im folgenden Beispiel jeden durch die Informationen *user input placeholder* Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit PHP eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
"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 ]
Der folgende Code zeigt, wie Sie mit Go eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
**Anmerkung**
Ab Version 1.2.1 verwendet der MongoDB Go Driver nur das erste CA-Serverzertifikat, das in `sslcertificateauthorityfile` gefunden wurde. Der folgende Beispielcode behebt diese Einschränkung, indem alle in `sslcertificateauthorityfile` gefundenen Serverzertifikate manuell an eine benutzerdefinierte TLS-Konfiguration angehängt werden, die während der Client-Erstellung verwendet wird.
Ersetzen Sie in den folgenden Beispielen jedes Beispiel *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Wenn Sie von einer Java-Anwendung aus eine Verbindung zu einem TLS-fähigen Amazon DocumentDB-Cluster herstellen, muss Ihr Programm die von AWS Ihnen bereitgestellte Zertifizierungsstelle (CA) verwenden, um die Verbindung zu validieren. Gehen Sie wie folgt vor, um das Amazon RDS-CA-Zertifikat zu verwenden:
1. Laden Sie die Amazon RDS-CA-Datei von herunter [https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem).
1. Erstellen Sie einen Vertrauensspeicher mit dem in der Datei enthaltenen CA-Zertifikat, indem Sie die folgenden Befehle ausführen. Stellen Sie sicher, dass Sie das *truststore-password* in etwas anderes ändern. Wenn Sie auf einen Vertrauensspeicher zugreifen, der sowohl das alte CA-Zertifikat (`rds-ca-2015-root.pem`) als auch das neue CA-Zertifikat (`rds-ca-2019-root.pem`) enthält, können Sie das Zertifikat-Bundle in den Vertrauensspeicher importieren.
Nachfolgend finden Sie ein Beispiel-Shell-Skript, das das Zertifikatpaket in einen Trust Store auf einem Linux-Betriebssystem importiert. Ersetzen Sie in den folgenden Beispielen jedes *user input placeholder * durch Ihre eigenen Informationen. Insbesondere gilt: Wo immer sich das Beispielverzeichnis *mydir* "" im Skript befindet, ersetzen Sie es durch ein Verzeichnis, das Sie für diese Aufgabe erstellt haben.
```
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
```
Es folgt ein Beispiel für ein Shell-Skript, das das Zertifikatspaket in einen Vertrauensspeicher unter macOS importiert.
```
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. Verwenden Sie das `keystore` in Ihrem Programm, indem Sie die folgenden Systemeigenschaften in Ihrer Anwendung festlegen, bevor Sie eine Verbindung zum Amazon DocumentDB-Cluster herstellen.
```
javax.net.ssl.trustStore: truststore
javax.net.ssl.trustStorePassword: truststore-password;
```
1. Der folgende Code zeigt, wie Sie mit Java eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit C\$1 /.NET eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
Im folgenden Beispiel ersetzen Sie jeden *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit der neuesten Version, Mongosh, oder der vorherigen Mongo-Shell-Version eine Verbindung zu Amazon DocumentDB herstellen und diese abfragen, wenn TLS aktiviert ist.
**Stellen Sie mit Mongosh eine Connect zu Amazon DocumentDB her**
**Wichtig**
Es gibt eine bekannte Einschränkung bei Treibern von Node.js, die älter als Version 6.13.1 sind und die derzeit nicht von der IAM-Identitätsauthentifizierung für Amazon DocumentDB unterstützt werden. Die Treiber und Tools der Datei Node.js, die den Treiber Node.js verwenden (z. B. mongosh), müssen aktualisiert werden, sodass sie den Treiber Node.js der Version 6.13.1 oder höher verwenden.
Ersetzen Sie in den folgenden Beispielen jedes *user input placeholder* Beispiel durch die Informationen Ihres Clusters.
```
mongosh --tls --host cluster-end-point:27017 --tlsCAFile global-bundle.pem --username sample-user --password password --retryWrites false
```
**Stellen Sie mit der vorherigen Mongo-Shell-Version eine Connect zu Amazon DocumentDB her**
Wenn Sie IAM verwenden, müssen Sie eine frühere Version von Mongo Shell verwenden. Geben Sie eine der folgenden Befehlsoptionen ein:
```
mongo --ssl --host cluster-end-point:27017 --sslCAFile global-bundle.pem --username sample-user --password password
```
Wenn Sie eine Version gleich oder höher als 4.2 verwenden, verwenden Sie den folgenden Code, um eine Verbindung herzustellen. Wiederholbare Schreibvorgänge werden in Amazon DocumentDB nicht unterstützt. Wenn Sie eine ältere Mongo-Shell (nicht Mongosh) verwenden, nehmen Sie den `retryWrites=false` Befehl nicht in eine Codezeichenfolge auf. Standardmäßig sind wiederholbare Schreibvorgänge deaktiviert. `retryWrites=false`Das Einschließen kann zu einem Fehler bei normalen Lesebefehlen führen.
```
mongo --tls --host cluster-end-point:27017 --tlsCAFile global-bundle.pem --username sample-user --password password
```
**Testen Sie die Verbindung**
1. Fügen Sie ein einzelnes Dokument ein.
```
db.myTestCollection.insertOne({'hello':'Amazon DocumentDB'})
```
1. Suchen Sie das Dokument, das zuvor eingefügt wurde.
```
db.myTestCollection.find({'hello':'Amazon DocumentDB'})
```
------
#### [ R ]
Der folgende Code zeigt, wie Sie mit R mithilfe von mongolite ([https://jeroen.github.io/mongolite/](https://jeroen.github.io/mongolite/)) eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
Ersetzen Sie im folgenden Beispiel jede durch die Informationen *user input placeholder* Ihres Clusters.
```
#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 ]
Der folgende Code zeigt, wie Sie mit Ruby eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS aktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
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
```
------
## Verbindung bei deaktiviertem TLS herstellen
Um ein Codebeispiel für die programmgesteuerte Verbindung zu einem TLS-deaktivierten Amazon DocumentDB-Cluster anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten.
------
#### [ Python ]
Der folgende Code zeigt, wie Sie mithilfe von Python eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
## 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 ]
Der folgende Code zeigt, wie Sie mithilfe von Node.js eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
**Wichtig**
Es gibt eine bekannte Einschränkung bei Treibern von Node.js, die älter als Version 6.13.1 sind und die derzeit nicht von der IAM-Identitätsauthentifizierung für Amazon DocumentDB unterstützt werden. Die Treiber und Tools der Datei Node.js, die den Treiber Node.js verwenden (z. B. mongosh), müssen aktualisiert werden, sodass sie den Treiber Node.js der Version 6.13.1 oder höher verwenden.
Ersetzen Sie im folgenden Beispiel jeden durch die Informationen *user input placeholder* Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit PHP eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit Go eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
Ersetzen Sie im folgenden Beispiel beide *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit Java eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit C\$1 /.NET eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
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 ]
Der folgende Code zeigt, wie Sie mit der neuesten Version, Mongosh, oder der vorherigen Mongo-Shell-Version eine Verbindung zu Amazon DocumentDB herstellen und diese abfragen, wenn TLS deaktiviert ist.
**Stellen Sie mit Mongosh eine Connect zu Amazon DocumentDB her**
**Wichtig**
Es gibt eine bekannte Einschränkung bei Treibern von Node.js, die älter als Version 6.13.1 sind und die derzeit nicht von der IAM-Identitätsauthentifizierung für Amazon DocumentDB unterstützt werden. Die Treiber und Tools der Datei Node.js, die den Treiber Node.js verwenden (z. B. mongosh), müssen aktualisiert werden, sodass sie den Treiber Node.js der Version 6.13.1 oder höher verwenden.
Ersetzen Sie in den folgenden Beispielen jedes *user input placeholder* Beispiel durch die Informationen Ihres Clusters.
```
mongosh --host cluster-end-point:27017 --username sample-user --password password --retryWrites false
```
**Stellen Sie mit der vorherigen Mongo-Shell-Version eine Connect zu Amazon DocumentDB her**
Wenn Sie IAM verwenden, müssen Sie eine frühere Version von Mongo Shell verwenden. Geben Sie eine der folgenden Befehlsoptionen ein:
```
mongo --host cluster-end-point:27017 --username sample-user --password password
```
Wenn Sie eine Version gleich oder höher als 4.2 verwenden, verwenden Sie den folgenden Code, um eine Verbindung herzustellen. Wiederholbare Schreibvorgänge werden in Amazon DocumentDB nicht unterstützt. Wenn Sie eine ältere Mongo-Shell (nicht Mongosh) verwenden, nehmen Sie den `retryWrites=false` Befehl nicht in eine Codezeichenfolge auf. Standardmäßig sind wiederholbare Schreibvorgänge deaktiviert. `retryWrites=false`Das Einschließen kann zu einem Fehler bei normalen Lesebefehlen führen.
```
mongo --host cluster-end-point:27017 --username sample-user --password password
```
**Testen Sie die Verbindung**
1. Fügen Sie ein einzelnes Dokument ein.
```
db.myTestCollection.insertOne({'hello':'Amazon DocumentDB'})
```
1. Suchen Sie das Dokument, das zuvor eingefügt wurde.
```
db.myTestCollection.find({'hello':'Amazon DocumentDB'})
```
------
#### [ R ]
Der folgende Code zeigt, wie Sie mit R mithilfe von mongolite ([https://jeroen.github.io/mongolite/](https://jeroen.github.io/mongolite/)) eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
Ersetzen Sie im folgenden Beispiel jede durch die Informationen *user input placeholder* Ihres Clusters.
```
#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 ]
Der folgende Code zeigt, wie Sie mit Ruby eine Verbindung zu Amazon DocumentDB herstellen, wenn TLS deaktiviert ist.
Ersetzen Sie im folgenden Beispiel jede *user input placeholder* durch die Informationen Ihres Clusters.
```
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
```
------
# Von außerhalb einer Amazon VPC eine Verbindung zu einem Amazon DocumentDB-Cluster herstellen
Amazon DocumentDB-Cluster (mit MongoDB-Kompatibilität) werden in einer Amazon Virtual Private Cloud (Amazon VPC) bereitgestellt. Sie können direkt von EC2 Amazon-Instances oder anderen AWS Services abgerufen werden, die in derselben Amazon VPC bereitgestellt werden. Darüber hinaus kann Amazon DocumentDB über VPC-Peering von EC2 Instances oder anderen AWS Services VPCs in verschiedenen Regionen AWS-Region oder in anderen Regionen aufgerufen werden.
Nehmen wir jedoch an, dass Ihr Anwendungsfall erfordert, dass Sie (oder Ihre Anwendung) von außerhalb der VPC des Clusters auf Ihre Amazon DocumentDB DocumentDB-Ressourcen zugreifen. In diesem Fall können Sie SSH-Tunneling (auch bekannt als *Portweiterleitung*) verwenden, um auf Ihre Amazon DocumentDB DocumentDB-Ressourcen zuzugreifen.
Die eingehende Diskussion zum Thema SSH-Tunneling geht über den Rahmen dieses Themas hinaus. Weitere Informationen zum SSH-Tunneling finden Sie in den folgenden Ressourcen:
+ [SSH-Tunnel](https://www.ssh.com/ssh/tunneling/)
+ [Beispiel zum SSH-Port-Forwarding](https://www.ssh.com/ssh/tunneling/example), insbesondere der Abschnitt [Lokales Forwarding](https://www.ssh.com/ssh/tunneling/example#sec-Local-Forwarding).
Um einen SSH-Tunnel zu erstellen, benötigen Sie eine EC2 Amazon-Instance, die in derselben Amazon VPC wie Ihr Amazon DocumentDB-Cluster läuft. Sie können entweder eine bestehende EC2 Instanz in derselben VPC wie Ihr Cluster verwenden oder eine erstellen. Weitere Informationen finden Sie im entsprechenden Thema für Ihr Betriebssystem:
+ [Erste Schritte mit Amazon EC2 Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html)
+ [Erste Schritte mit Amazon EC2 Windows-Instances](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html)
Normalerweise können Sie mit dem folgenden Befehl eine Verbindung zu einer EC2 Instance herstellen.
```
ssh -i "ec2Access.pem" ubuntu@ec2-34-229-221-164.compute-1.amazonaws.com
```
Falls ja, können Sie einen SSH-Tunnel zum Amazon DocumentDB-Cluster einrichten, `sample-cluster.node.us-east-1.docdb.amazonaws.com` indem Sie den folgenden Befehl auf Ihrem lokalen Computer ausführen. Das `-L`-Flag dient zur Weiterleitung eines lokalen Ports. Wenn Sie einen SSH-Tunnel verwenden, empfehlen wir, dass Sie über den Clusterendpunkt eine Verbindung mit Ihrem Cluster herstellen und nicht versuchen, eine Verbindung im Replikatsatzmodus herzustellen (d. h. `replicaSet=rs0` in der Verbindungszeichenfolge anzugeben), da dies zu einem Fehler führt.
```
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
```
Nachdem der SSH-Tunnel erstellt wurde, werden alle Befehle, an die Sie ausgeben, an den Amazon DocumentDB-Cluster weitergeleitet, der in der Amazon `sample-cluster` VPC ausgeführt wird. `localhost:27017` Wenn Transport Layer Security (TLS) auf Ihrem Amazon DocumentDB-Cluster aktiviert ist, müssen Sie den öffentlichen Schlüssel für Amazon DocumentDB von herunterladen. [https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem) Mit dem folgenden Vorgang wird diese Datei heruntergeladen:
```
wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem
```
**Anmerkung**
TLS ist standardmäßig für neue Amazon DocumentDB-Cluster aktiviert. Eine Deaktivierung ist jedoch möglich. Weitere Informationen finden Sie unter [TLS-Einstellungen für Amazon DocumentDB-Cluster verwalten](security.encryption.ssl.md#security.encryption.ssl.managing).
Verwenden Sie den folgenden Befehl, um von außerhalb der Amazon VPC eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herzustellen.
```
mongo --sslAllowInvalidHostnames --ssl --sslCAFile global-bundle.pem --username --password
```
# Als Replikatsatz eine Verbindung zu Amazon DocumentDB herstellen
Wenn Sie mit Amazon DocumentDB (mit MongoDB-Kompatibilität) entwickeln, empfehlen wir, dass Sie eine Verbindung zu Ihrem Cluster als Replikatsatz herstellen und Lesevorgänge mithilfe der integrierten Leseeinstellungen Ihres Treibers an Replikatinstanzen verteilen. In diesem Abschnitt wird genauer beschrieben, was das bedeutet, und es wird beschrieben, wie Sie am Beispiel des SDK für Python eine Verbindung zu Ihrem Amazon DocumentDB-Cluster als Replikatsatz herstellen können.
Amazon DocumentDB hat drei Endpunkte, über die Sie eine Verbindung zu Ihrem Cluster herstellen können:
+ Cluster-Endpunkt
+ Leser-Endpunkt
+ Instance-Endpunkte
In den meisten Fällen, wenn Sie eine Verbindung zu Amazon DocumentDB herstellen, empfehlen wir, den Cluster-Endpunkt zu verwenden. Dies ist ein CNAME, der auf die primäre Instance in Ihrem Cluster verweist wie im folgenden Diagramm gezeigt.
Wenn Sie einen SSH-Tunnel verwenden, empfehlen wir, dass Sie über den Clusterendpunkt eine Verbindung mit Ihrem Cluster herstellen und nicht versuchen, eine Verbindung im Replikatsatzmodus herzustellen (d. h. `replicaSet=rs0` in der Verbindungszeichenfolge anzugeben), da dies zu einem Fehler führt.
**Anmerkung**
Weitere Informationen zu Amazon DocumentDB DocumentDB-Endpunkten finden Sie unter. [Amazon DocumentDB DocumentDB-Endpunkte](how-it-works.md#how-it-works.endpoints)
![\[Diagramm mit Amazon DocumentDB DocumentDB-Endpunkten, einschließlich der Cluster-, Reader- und Instance-Endpunkte.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/docdb-endpoint-types.png)
Mithilfe des Cluster-Endpunkts können Sie im Replikatsatzmodus eine Verbindung zu Ihrem Cluster herstellen. Anschließend können Sie die integrierten Treiberfunktionen für Leseeinstellungen verwenden. Im folgenden Beispiel signalisiert die Angabe von `/?replicaSet=rs0` dem SDK, das Sie eine Verbindung als Replikatsatz herstellen möchten. Wenn Sie `/?replicaSet=rs0'` auslassen, leitet der Client alle Anfragen an den Cluster-Endpunkt weiter, d. h. Ihre primäre Instance.
```
## 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')
```
Der Vorteil der Verbindung als Replikatsatz besteht darin, dass Ihr SDK die Cluster-Topographie automatisch erkennt, auch wenn Instances dem Cluster hinzugefügt oder aus dem Cluster entfernt werden. Anschließend können Sie den Cluster effizienter nutzen, indem Sie Leseanforderungen an Ihre Replikat-Instances weiterleiten.
Wenn Sie eine Verbindung als Replikatsatz herstellen, können Sie die `readPreference` für die Verbindung angeben. Wenn Sie die Leseeinstellung `secondaryPreferred` angeben, leitet der Client Leseabfragen an Ihre Replikate und Schreibabfragen an Ihre primäre Instance weiter (wie im folgenden Diagramm gezeigt). Damit werden Ihre Cluster-Ressourcen besser genutzt. Weitere Informationen finden Sie unter [Lesen Sie die Einstellungsoptionen](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')
```
![\[Diagramm, das Amazon DocumentDB readPreference: SecondaryPreferred zeigt.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/docdb-readPreference-secondaryPreferred.png)
Lesevorgänge von Amazon DocumentDB DocumentDB-Replikaten sind letztendlich konsistent. Sie geben die Daten in der gleichen Reihenfolge zurück, in der sie auf dem primären Knoten geschrieben wurden. Die Replikationsverzögerung beträgt häufig weniger als 50 ms. Sie können die Replikatverzögerung für Ihren Cluster mithilfe der CloudWatch Amazon-Metriken `DBInstanceReplicaLag` und `DBClusterReplicaLagMaximum` überwachen. Weitere Informationen finden Sie unter [Überwachen von Amazon DocumentDB mit CloudWatch](cloud_watch.md).
Im Gegensatz zur herkömmlichen monolithischen Datenbankarchitektur trennt Amazon DocumentDB Speicher und Datenverarbeitung. Aufgrund dieser modernen Architektur sollten Sie Lesevorgänge auf Replikat-Instances skalieren. Lesevorgänge auf Replikat-Instances blockieren keine Schreibvorgänge, die von der primären Instance repliziert werden. Sie können einem Cluster bis zu 15 Read-Reaplica-Instances hinzufügen und auf Millionen von Lesevorgängen pro Sekunde skalieren.
Der Hauptvorteil der Verbindung als Replikatsatz und der Verteilung von Lesevorgängen an Replikate besteht darin, dass dies die Gesamtzahl der Ressourcen im Cluster erhöht, die für Ihre Anwendung verfügbar sind. Wir empfehlen die Verbindung als Replikatsatz als bewährte Methode. Darüber hinaus empfehlen wir diesen Ansatz besonders für die folgenden Szenarien:
+ Sie nutzen nahezu 100 Prozent der CPU-Leistung auf Ihrer primären Instance.
+ Das Puffer-Cache-Treffer-Verhältnis ist beinahe Null.
+ Sie erreichen die Verbindungs- oder Cursor-Limits für eine einzelne Instance.
Die Aufwärtsskalierung einer Cluster-Instance-Größe ist eine Option und kann in einigen Fällen die beste Möglichkeit für die Skalierung des Clusters darstellen. Sie sollten jedoch auch überlegen, wie Sie die Replikate, die in Ihrem Cluster bereits vorhanden sind, besser nutzen können. So können Sie die Skalierung erhöhen, ohne dass für Sie höhere Kosten für die Verwendung eines größeren Instance-Typs anfallen. Wir empfehlen außerdem, diese Grenzwerte (d. h., und`BufferCacheHitRatio`) mithilfe von CloudWatch Alarmen zu überwachen und Warnmeldungen zu erstellen `CPUUtilization``DatabaseConnections`, damit Sie wissen, wenn eine Ressource stark beansprucht wird.
Weitere Informationen finden Sie unter den folgenden Themen:
+ [Bewährte Methoden für Amazon DocumentDB](best_practices.md)
+ [Amazon DocumentDB Kontingente und Beschränkungen](limits.md)
## Verwenden von Clusterverbindungen
Betrachten Sie ein Szenario, in dem alle Verbindungen in Ihrem Cluster genutzt werden. Beispielsweise hat eine `r5.2xlarge`-Instance ein Limit von 4.500 Verbindungen (und 450 offenen Cursors). Wenn Sie einen Amazon DocumentDB-Cluster mit drei Instanzen erstellen und nur über den Cluster-Endpunkt eine Verbindung zur primären Instance herstellen, liegen Ihre Cluster-Grenzwerte für offene Verbindungen und Cursor bei 4.500 bzw. 450. Sie können diese Limits erreichen, wenn Sie Anwendungen mit zahlreichen Workern verwenden, die in Containern gestartet werden. Die Container öffnen mehrere Verbindungen gleichzeitig und sättigen den Cluster.
Stattdessen könnten Sie sich als Replikatsatz mit dem Amazon DocumentDB-Cluster verbinden und Ihre Lesevorgänge an die Replikatinstanzen verteilen. Anschließend könnten Sie die Anzahl der verfügbaren Verbindungen und Cursors im Cluster effektiv auf 13.500 bzw. 1.350 verdreifachen. Das Hinzufügen weiterer Instances zum Cluster erhöht lediglich die Anzahl der Verbindungen und Cursors für Lese-Workloads. Wenn Sie die Anzahl der Verbindungen für Schreibvorgänge in Ihrem Cluster erhöhen müssen, sollten Sie die Instance-Größe erhöhen.
**Anmerkung**
Die Anzahl der Verbindungen für `large`, `xlarge`, und `2xlarge` Instances erhöht sich mit der Instance-Größe bis zu 4.500. Die maximale Anzahl von Verbindungen pro Instance für `4xlarge` Instances oder größer beträgt 4.500. Weitere Hinweise zu Beschränkungen nach Instance-Typ finden Sie unter [Instance-Limits](limits.md#limits.instance).
In der Regel empfehlen wir das Herstellen von Verbindungen mit Ihrem Cluster unter Verwendung der Leseeinstellung `secondary` nicht. Der Grund hierfür ist, dass die Lesevorgänge fehlschlagen, wenn es keine Replikat-Instances im Cluster gibt. Nehmen wir zum Beispiel an, Sie haben einen Amazon DocumentDB-Cluster mit zwei Instanzen, einem primären und einem Replikat. Wenn die Replikat-Instance ein Problem aufweist, schlagen Leseanforderungen aus einem als `secondary` festgelegten Verbindungspool fehl. Der Vorteil von `secondaryPreferred` besteht darin, dass der Client für Lesevorgänge auf den primären Knoten zurückgreift, wenn er keine geeignete Replikat-Instance für die Verbindung finden kann.
## Mehrere Verbindungspools
In einigen Szenarien müssen Lesevorgänge in einer Anwendung read-after-write konsistent sein, sodass sie nur von der primären Instance in Amazon DocumentDB bedient werden können. In diesen Szenarien könnten Sie zwei Client-Verbindungspools erstellen: einen für Schreibvorgänge und einen für Lesevorgänge, die read-after-write Konsistenz erfordern. Ihr Code würde in diesem Fall ungefähr wie folgt aussehen.
```
## 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')
```
Eine weitere Möglichkeit besteht darin, einen einzelnen Verbindungspool zu erstellen und die Leseeinstellung für eine bestimmte Sammlung zu überschreiben.
```
##Specify the collection and set the read preference level for that collection
col = db.review.with_options(read_preference=ReadPreference.SECONDARY_PREFERRED)
```
## Übersicht
Um die Ressourcen im Cluster besser zu nutzen, sollten Sie Verbindungen mit dem Cluster über den Replikatsatzmodus herstellen. Sie können die Zahl der Lesevorgänge für Ihre Anwendung skalieren, indem Sie Ihre Lesevorgänge an die Replikat-Instances verteilen, wenn dies für Ihre Anwendung geeignet ist.
# Von Studio 3T aus eine Verbindung zu einem Amazon DocumentDB-Cluster herstellen
[Studio 3T](https://studio3t.com/) ist eine beliebte GUI und IDE für Entwickler und Dateningenieure, die mit MongoDB arbeiten. Es bietet mehrere leistungsstarke Funktionen Baum-, Tabellen- und JSON-Ansichten Ihrer Daten, einfach import/export in CSV, JSON, SQL und BSON/MongoDump, flexible Abfrageoptionen, eine visuelle drag-and-drop Benutzeroberfläche, eine integrierte Mongo-Shell mit Autovervollständigung, einen Aggregationspipeline-Editor und SQL-Abfrageunterstützung.
## Voraussetzungen
+ Wenn Sie noch keinen Amazon DocumentDB-Cluster haben, der Amazon EC2 als bastion/jump Host verwendet, folgen Sie den Anweisungen zur [Connect mit Amazon](https://docs.aws.amazon.com/documentdb/latest/developerguide/connect-ec2.html) EC2.
+ Wenn Sie Studio 3T nicht haben, laden Sie es [herunter](https://studio3t.com/download) und installieren Sie es.
## Mit Studio 3T Connect
1. Wählen Sie in der oberen linken Ecke der Werkzeugleiste **Connect**.
![\[Studio 3T-Oberfläche mit Willkommensbildschirm und hervorgehobener Connect-Option in der oberen linken Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-connect.png)
1. Wählen Sie in der oberen linken Ecke der Werkzeugleiste **Neue Verbindung**.
![\[Verbindungs-Manager-Oberfläche mit hervorgehobener Option „Neue Verbindung“ in der oberen linken Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-newconn.png)
1. Geben Sie auf der Registerkarte **Server** im Feld **Server** die Informationen zum Cluster-Endpunkt ein.
![\[Registerkarte „Server“ in der Schnittstelle „Neue Verbindung“, wobei das Eingabefeld Server hervorgehoben ist.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-endpoint.png)
**Anmerkung**
Sie können Ihren Cluster-Endpunkt nicht finden? Folgen Sie einfach den Schritten [hier](https://docs.aws.amazon.com/documentdb/latest/developerguide/db-instance-endpoint-find.html).
1. Wählen Sie die Registerkarte **Authentifizierung** und wählen Sie **Legacy** im Drop-down-Menü für **Authentifizierungsmodus** aus.
![\[Registerkarte „Authentifizierung“ in der Benutzeroberfläche „Neue Verbindung“ mit ausgewähltem Legacy-Authentifizierungsmodus und Angabe von Benutzername, Passwort und Authentifizierungs-DB-Informationen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-auth.png)
1. Geben Sie Ihren Benutzernamen und Ihre Anmeldeinformationen in die Felder **Benutzername** und **Passwort ein**.
1. Wählen Sie die Registerkarte **SSL** und aktivieren Sie das Kästchen **SSL-Protokoll für die Verbindung verwenden**.
![\[Auf der Registerkarte „Neue Verbindung“ ist auf der Registerkarte „Neue Verbindung“ die Option „SSL-Protokoll für Verbindung verwenden“ ausgewählt.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-ssl.png)
1. Wählen Sie **Eigene Root-CA-Datei verwenden**. Fügen Sie dann das Amazon DocumentDB DocumentDB-Zertifikat hinzu (Sie können diesen Schritt überspringen, wenn SSL in Ihrem DocumentDB-Cluster deaktiviert ist). Markieren Sie das Kästchen, um **ungültige** Hostnamen zuzulassen.
![\[Registerkarte SSL in der Schnittstelle „Neue Verbindung“ mit eingegebener Root-CA-Datei und ausgewählter Option „Ungültige Hostnamen zulassen“.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-ssl.png)
**Anmerkung**
Sie haben das Zertifikat nicht? Sie können es mit dem folgenden Befehl herunterladen:
`wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem `
1. Wenn Sie von einem Client-Computer außerhalb der Amazon VPC aus eine Verbindung herstellen, müssen Sie einen SSH-Tunnel erstellen. Sie werden dies auf der Registerkarte **SSH** tun.
1. **Aktivieren Sie das Kontrollkästchen **SSH-Tunnel verwenden** und geben Sie die SSH-Adresse in das Feld SSH-Adresse ein.** Dies ist Ihre Instanz Public DNS (). IPV4 Sie können diese URL von Ihrer [Amazon EC2-Managementkonsole](https://console.aws.amazon.com/ec2) abrufen.
1. Geben Sie Ihren Nutzernamen ein. Dies ist der Benutzername Ihrer Amazon EC2 EC2-Instance
1. **Wählen Sie für den **SSH-Authentifizierungsmodus die** Option Private Key aus.** Wählen Sie im Feld **Privater Schlüssel** das Dateifinder-Symbol aus, um den privaten Schlüssel Ihrer Amazon EC2 EC2-Instance zu suchen und auszuwählen. Dies ist die PEM-Datei (key pair), die Sie beim Erstellen Ihrer Instance in der Amazon EC2 EC2-Konsole gespeichert haben.
1. Wenn Sie sich auf einem Linux/macOS Client-Computer befinden, müssen Sie möglicherweise die Berechtigungen Ihres privaten Schlüssels mit dem folgenden Befehl ändern:
`chmod 400 /fullPathToYourPemFile/.pem`
![\[SSH-Tab in der Schnittstelle „Neue Verbindung“ mit eingegebenen SSH-Tunnelanmeldedaten.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-ssh.png)
**Anmerkung**
Diese Amazon EC2 EC2-Instance sollte sich in derselben Amazon VPC und Sicherheitsgruppe wie Ihr DocumentDB-Cluster befinden. Sie können die SSH-Adresse, den Benutzernamen und den privaten Schlüssel von Ihrer [Amazon EC2-Managementkonsole](https://console.aws.amazon.com/ec2) abrufen.
1. Testen Sie nun Ihre Konfiguration, indem Sie auf die Schaltfläche **Verbindung testen klicken**.
![\[Neue Verbindungsschnittstelle mit hervorgehobener Schaltfläche „Verbindung testen“ in der unteren linken Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-testbutton.png)
1. In einem Diagnosefenster sollte ein grüner Balken angezeigt werden, der anzeigt, dass der Test erfolgreich war. Wählen Sie nun **OK**, um das Diagnosefenster zu schließen.
![\[Diagnosefenster, das nach einem erfolgreichen Verbindungstest erscheint.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-testconn.png)
1. Wählen Sie **Speichern**, um Ihre Verbindung für die future Verwendung zu speichern.
![\[Neue Verbindungsschnittstelle mit hervorgehobener Schaltfläche „Speichern“.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-save.png)
1. Wählen Sie nun Ihren Cluster aus und wählen Sie **Connect**.
![\[Verbindungs-Manager-Oberfläche mit hervorgehobener Schaltfläche „Connect“.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/studio3t/studio3t-finalconnect.png)
Herzlichen Glückwunsch\$1 Sie sind jetzt erfolgreich über Studio 3T mit Ihrem Amazon DocumentDB-Cluster verbunden.
# Connect zu Amazon DocumentDB her mit DataGrip
[DataGrip](https://www.jetbrains.com/help/datagrip/documentdb.html)ist eine leistungsstarke integrierte Entwicklungsumgebung (IDE), die verschiedene Datenbanksysteme unterstützt, darunter Amazon DocumentDB. Dieser Abschnitt führt Sie durch die Schritte, mit denen Sie eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herstellen DataGrip, sodass Sie Ihre Daten einfach über eine grafische Oberfläche verwalten und abfragen können.
## Voraussetzungen
+ DataGrip IDE ist auf Ihrem Computer installiert. Sie können es von herunterladen [JetBrains](https://www.jetbrains.com/datagrip/download/#section=windows).
+ Eine EC2 Amazon-Instance, die in derselben VPC wie Ihr Amazon DocumentDB-Cluster läuft. Sie verwenden diese Instanz, um einen sicheren Tunnel von Ihrem lokalen Computer zum Amazon-Dokument einzurichtenDBcluster. Folgen Sie den Anweisungen dazu[Stellen Sie mithilfe von Amazon EC2 eine Verbindung her](connect-ec2.md).
+ Alternative zu einer EC2 Amazon-Instance, einer VPN-Verbindung oder wenn Sie bereits über ein sicheres VPN auf Ihre AWS Infrastruktur zugreifen. Wenn Sie diese Option bevorzugen, folgen Sie den Anweisungen für den [sicheren Zugriff auf Amazon DocumentDB mit AWS Client VPN](https://aws.amazon.com/blogs/database/securely-access-amazon-documentdb-with-mongodb-compatibility-locally-using-aws-client-vpn/).
## Connect mit DataGrip
1. Starten Sie DataGrip auf Ihrem Computer und erstellen Sie ein **neues Projekt**.
![\[DataGrip Willkommensbildschirm, auf dem die Option Neues Projekt markiert ist.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/welcome.png)
1. Fügen Sie mithilfe einer der folgenden Methoden eine neue Datenquelle hinzu:
1. Navigieren Sie im Hauptmenü zu **Datei — Neu — Datenquelle** und wählen Sie **DocumentDB**
1. Klicken Sie im **Datenbank-Explorer** in der Werkzeugleiste auf das neue Symbol (**\$1**). Navigieren Sie zu **Data Source** und wählen Sie **DocumentDB** aus.
![\[Die Drop-down-Liste für + zeigt das Untermenü Datenquelle. DocumentDB wird aus diesem Untermenü ausgewählt.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/explorer.png)
1. Überprüfen Sie auf der Seite **Datenquellen** auf der Registerkarte **Allgemein**, ob sich unten im Bereich mit den Verbindungseinstellungen der Link **Fehlende Treiberdateien herunterladen** befindet. Klicken Sie auf diesen Link, um Treiber herunterzuladen, die für die Interaktion mit einer Datenbank erforderlich sind. Einen direkten Download-Link finden Sie unter [JetBrains JDBC-Treiber](https://www.jetbrains.com/datagrip/jdbc-drivers/).
![\[Schnittstelle zwischen Datenquellen und Treibern, wobei der Link „Fehlende Treiberdateien herunterladen“ hervorgehoben ist.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/missing-driver.png)
1. Geben Sie auf der Registerkarte **Allgemein** die Verbindungsdetails an:
1. Geben Sie im Feld **Host** den Amazon DocumentDB-Cluster-Endpunkt an.
1. **Der Port** ist bereits auf 27017 eingestellt. Ändern Sie es, wenn Ihr Cluster auf einem anderen Port bereitgestellt wurde.
1. Wählen Sie für **Authentifizierung** die Option **Benutzer und Passwort** aus.
1. Geben Sie Ihren Benutzernamen und Ihr Passwort ein.
1. Das **Datenbankfeld** ist optional. Sie können die Datenbank angeben, zu der Sie eine Verbindung herstellen möchten.
1. Das **URL-Feld** wird automatisch vervollständigt, wenn Sie die obigen Details hinzufügen.
![\[Host-, Port-, Authentifizierungs-, Datenbank- und URL-Felder auf der Registerkarte „Allgemein“ der Benutzeroberfläche „Datenquellen und Treiber“.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/connection.png)
1. **Aktivieren **Sie auf der Registerkarte **SSH/SSL** die Option SSH-Tunnel verwenden und klicken Sie dann auf das Symbol, um den SSH-Konfigurationsdialog** zu öffnen.** Geben Sie die folgenden Informationen ein:
1. Geben Sie im Feld **Host** den Hostnamen Ihrer EC2 Amazon-Instance ein.
1. Geben Sie den Benutzernamen und das Passwort für Ihre EC2 Amazon-Instance ein.
1. Wählen Sie als **Authentifizierungstyp** die Option **Schlüsselpaar** aus.
1. Geben Sie Ihre **private Schlüsseldatei** ein.
**Anmerkung**
Wenn Sie die VPN-Option verwenden, müssen Sie den SSH-Tunnel nicht konfigurieren.
![\[Auf der Registerkarte SSH/SSL in der Benutzeroberfläche für Datenquellen und Treiber ist die Option SSH-Tunnel verwenden ausgewählt und das SSH-Konfigurationssymbol hervorgehoben. Das Symbol öffnet die angezeigte SSH-Konfigurationsoberfläche.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ssh-tunnel.png)
1. **Aktivieren Sie auf der Registerkarte **SSH/SSL** die Option SSL verwenden.** Geben Sie im Feld **CA-Datei** den Speicherort der `global-bundle.pem` Datei auf Ihrem Computer ein. Behalten Sie für **Modus** die Option **Erforderlich bei**.
**Anmerkung**
Sie können das Zertifikat von diesem Speicherort oder mit dem folgenden Befehl herunterladen: wget [https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem](https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem)
**Anmerkung**
Wenn Sie eine Verbindung zu Amazon DocumentDB Elastic Cluster herstellen, müssen Sie die CA-Datei nicht angeben. Lassen Sie die Option **SSL verwenden** aktiviert und lassen Sie alle anderen Optionen auf ihren Standardwerten stehen.
![\[Registerkarte SSH/SSL in der Benutzeroberfläche für Datenquellen und Treiber mit aktivierten SSL-Einstellungen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/use-ssl.png)
1. **Wählen Sie auf der Registerkarte **Schemas** die Option **Alle Datenbanken** aus, oder geben Sie den Filter „\$1: \$1“ in das Feld Schemamuster ein.** Klicken Sie auf den Link **Verbindung testen**, um die Verbindung zu testen.
![\[Auf der Registerkarte Schemas in der Benutzeroberfläche Datenquellen und Treiber ist die Option Alle Datenbanken ausgewählt. Über dem Link Verbindung testen wird die Meldung Erfolgreich angezeigt.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/schemas.png)
1. Sobald die Verbindung erfolgreich getestet wurde, klicken Sie auf **OK**, um die Datenquellenkonfiguration zu speichern.
## DataGrip features
DataGrip bietet verschiedene Funktionen, die Ihnen helfen, effizient mit Amazon DocumentDB zu arbeiten:
+ **SQL Editor** — Schreiben Sie SQL-ähnliche Abfragen in Ihren DocumentDB-Sammlungen und führen Sie sie mit dem SQL-Editor in aus. DataGrip
+ **Visual Query Builder** — Verwenden Sie den Visual Query Builder, um Abfragen grafisch zu erstellen, ohne SQL-Code schreiben zu müssen.
+ **Schemaverwaltung** — Einfache Verwaltung Ihres Datenbankschemas, einschließlich des Erstellens, Änderns und Löschens von Sammlungen.
+ **Datenvisualisierung** — Zeigen Sie Ihre Daten an und analysieren Sie sie mithilfe verschiedener Visualisierungstools, die unter verfügbar sind. DataGrip
+ **Daten exportieren und importieren** — Übertragen Sie Daten zwischen Amazon DocumentDB und anderen Datenbanken mithilfe DataGrip der Export- und Importfunktionen.
Weiterführende Funktionen und Tipps zur Arbeit mit Amazon DocumentDB und anderen Datenbanksystemen finden Sie in der offiziellen [DataGrip Dokumentation](https://www.jetbrains.com/datagrip/features/).
# Stellen Sie mithilfe von Amazon EC2 eine Verbindung her
In diesem Abschnitt wird beschrieben, wie Sie die Konnektivität zwischen einem Amazon DocumentDB-Cluster und Amazon EC2 einrichten und von der Amazon EC2-Instance aus auf den Amazon DocumentDB-Cluster zugreifen.
Es gibt zwei Optionen für die Konfiguration der EC2-Verbindung:
+ [Automatisches Verbinden Ihrer EC2-Instance mit einer Amazon DocumentDB DocumentDB-Datenbank](connect-ec2-auto.md) — Verwenden Sie die automatische Verbindungsfunktion in der EC2-Konsole, um die Verbindung zwischen Ihrer EC2-Instance und einer neuen oder vorhandenen Amazon DocumentDB DocumentDB-Datenbank automatisch zu konfigurieren. Diese Verbindung ermöglicht den Verkehr zwischen der EC2-Instance und der Amazon DocumentDB DocumentDB-Datenbank. Diese Option wird normalerweise zum Testen und Erstellen neuer Sicherheitsgruppen verwendet.
+ [Manuelles Verbinden Ihrer EC2-Instance mit Ihrer Amazon DocumentDB DocumentDB-Datenbank](connect-ec2-manual.md) — Konfigurieren Sie die Verbindung zwischen Ihrer EC2-Instance und Ihrer Amazon DocumentDB DocumentDB-Datenbank, indem Sie die Sicherheitsgruppen manuell konfigurieren und zuweisen, um die Konfiguration zu reproduzieren, die durch die automatische Verbindungsfunktion erstellt wird. Diese Option wird normalerweise verwendet, um erweiterte Einstellungen zu ändern und bestehende Sicherheitsgruppen zu verwenden.
## Voraussetzungen
Unabhängig von der Option und bevor Sie Ihren ersten Amazon DocumentDB-Cluster erstellen, müssen Sie Folgendes tun:
**Erstellen Sie ein Amazon Web Services (AWS) -Konto**
Bevor Sie Amazon DocumentDB verwenden können, benötigen Sie ein Amazon Web Services (AWS) -Konto. Das AWS Konto ist kostenlos. Sie zahlen nur für die Services und Ressourcen, die Sie wirklich nutzen.
Wenn Sie noch keinen haben AWS-Konto, führen Sie die folgenden Schritte aus, um einen zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
**Richten Sie optional die erforderlichen AWS Identity and Access Management (IAM-) Berechtigungen ein.**
Für den Zugriff auf die Verwaltung von Amazon DocumentDB DocumentDB-Ressourcen wie Clustern, Instances und Cluster-Parametergruppen sind Anmeldeinformationen erforderlich, mit denen Sie Ihre Anfragen authentifizieren AWS können. Weitere Informationen finden Sie unter [Identity and Access Management für Amazon DocumentDB](security-iam.md).
1. Geben Sie in der Suchleiste von IAM ein und wählen Sie im angezeigten Drop-down-Menü **IAM** aus. AWS-Managementkonsole
1. Sobald Sie sich in der IAM-Konsole befinden, wählen Sie im **Navigationsbereich Benutzer** aus.
1. Wählen Sie Ihren Nutzernamen aus.
1. Klicken Sie auf den Button **Berechtigungen hinzufügen**.
1. Wählen Sie die Option **Attach existing policies directly (Vorhandene Richtlinien direkt anfügen)** aus.
1. Geben Sie `AmazonDocDBFullAccess` in die Suchleiste ein und wählen Sie sie aus, sobald sie in den Suchergebnissen erscheint.
1. Klicken Sie unten auf die blaue Schaltfläche mit der Aufschrift **Weiter: Überprüfen**.
1. Klicken Sie unten auf die blaue Schaltfläche mit der Aufschrift **Berechtigungen hinzufügen**.
**Erstellen Sie eine Amazon Virtual Private Cloud (Amazon VPC)**
Je nachdem, in welchem Bereich AWS-Region Sie sich befinden, haben Sie möglicherweise bereits eine Standard-VPC erstellt oder auch nicht. Wenn Sie keine Standard-VPC haben, führen Sie Schritt 1 der Anleitung [Erste Schritte mit Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-getting-started.html) im *Amazon VPC-Benutzerhandbuch* durch. Dies dauert weniger als fünf Minuten.
# Amazon EC2 automatisch Connect
**Topics**
+ [
## Automatisches Verbinden einer EC2-Instance mit einer neuen Amazon DocumentDB DocumentDB-Datenbank
](#auto-connect-ec2.process)
+ [
## Automatisches Verbinden einer EC2-Instance mit einer vorhandenen Amazon DocumentDB DocumentDB-Datenbank
](#auto-connect-ec2-existing-cluster)
+ [
## Übersicht über die automatische Verbindung mit einer EC2-Instance
](#auto-connect-ec2.overview)
+ [
## Anzeigen verbundener Rechenressourcen
](#auto-connect-ec2.compute)
Bevor Sie eine Verbindung zwischen einer EC2-Instance und einer neuen Amazon DocumentDB DocumentDB-Datenbank einrichten, stellen Sie sicher, dass Sie die unter beschriebenen Anforderungen erfüllen. [Übersicht über die automatische Verbindung mit einer EC2-Instance](#auto-connect-ec2.overview) Wenn Sie nach der Konfiguration der Konnektivität Änderungen an Sicherheitsgruppen vornehmen, können sich die Änderungen auf die Verbindung zwischen der EC2-Instance und der Amazon DocumentDB DocumentDB-Datenbank auswirken.
**Anmerkung**
Sie können nur automatisch eine Verbindung zwischen einer EC2-Instance und einer Amazon DocumentDB DocumentDB-Datenbank einrichten, indem Sie die verwenden. AWS-Managementkonsole Sie können keine automatische Verbindung mit der AWS CLI oder der Amazon DocumentDB DocumentDB-API einrichten.
## Automatisches Verbinden einer EC2-Instance mit einer neuen Amazon DocumentDB DocumentDB-Datenbank
Beim folgenden Prozess wird davon ausgegangen, dass Sie die Schritte im Thema abgeschlossen haben. [Voraussetzungen](connect-ec2.md#connect-ec2-prerequisites)
**Topics**
+ [
### Schritt 1: Erstellen Sie eine Amazon EC2 EC2-Instance
](#auto-connect-ec2.launch-ec2-instance)
+ [
### Schritt 2: Erstellen Sie einen Amazon DocumentDB-Cluster
](#auto-connect-ec2.launch-cluster)
+ [
### Schritt 3: Connect zu Ihrer Amazon EC2 EC2-Instance her
](#manual-connect-ec2.connect)
+ [
### Schritt 4: Installieren Sie die MongoDB-Shell
](#auto-connect-ec2.install-mongo-shell)
+ [
### Schritt 5: Amazon DocumentDB TLS verwalten
](#auto-connect-ec2.tls)
+ [
### Schritt 6: Connect zu Ihrem Amazon DocumentDB-Cluster her
](#auto-connect-ec2.connect-use)
+ [
### Schritt 7: Daten einfügen und abfragen
](#auto-cloud9-insert-query)
+ [
### Schritt 8: Erkunden
](#auto-connect-ec2.explore)
### Schritt 1: Erstellen Sie eine Amazon EC2 EC2-Instance
In diesem Schritt erstellen Sie eine Amazon EC2 EC2-Instance in derselben Region und Amazon VPC, die Sie später für die Bereitstellung Ihres Amazon DocumentDB-Clusters verwenden werden.
1. Wählen Sie auf der Amazon EC2 EC2-Konsole **Launch instance** aus.
![\[Der Abschnitt Launch Instance auf der Amazon EC2 EC2-Konsole.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/launch-instance.png)
1. Geben Sie einen Namen oder eine Kennung in das Feld **Name** im Abschnitt **Name und Tags** ein.
1. Suchen Sie in der Dropdownliste **Amazon Machine Image (AMI)** nach **Amazon Linux 2 AMI** und wählen Sie es aus.
![\[Die Anwendungs- und Betriebssystem-Images bieten eine Schnittstelle mit der Amazon Linux 2 AMI-Option, die im Abschnitt Schnellstart ausgewählt wurde.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/linux2-ami.png)
1. Suchen Sie in der Dropdownliste **Instance-Typ** nach **t3.micro** und wählen Sie es aus.
1. Geben Sie im Abschnitt **key pair (Anmeldung)** die Kennung eines vorhandenen Schlüsselpaars ein, oder wählen Sie **Neues Schlüsselpaar erstellen**.
![\[Die Schlüsselpaar-Schnittstelle mit dem Feld für den Namen des key pair und der Option Neues key pair erstellen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/key-pair.png)
Sie müssen ein Amazon EC2 EC2-Schlüsselpaar angeben.
+ Wenn Sie ein Amazon EC2 EC2-Schlüsselpaar haben:
1. Wählen Sie ein key pair aus, wählen Sie Ihr key pair aus der Liste.
1. Sie müssen die private Schlüsseldatei (.pem- oder .ppk-Datei) bereits verfügbar haben, um sich bei Ihrer Amazon EC2 EC2-Instance anmelden zu können.
+ Wenn Sie kein Amazon EC2 EC2-Schlüsselpaar haben:
1. Wählen Sie **Neues key pair** **erstellen. Daraufhin wird das Dialogfeld key pair** erstellen angezeigt.
1. Geben Sie einen Namen in das Feld **Name des Schlüsselpaars** ein.
1. Wählen Sie den **Schlüsselpaartyp** und das **Dateiformat für den privaten Schlüssel**.
1. Wählen Sie **Create Key Pair (Schlüsselpaar erstellen)** aus.
![\[Die Schnittstelle key pair erstellen mit Feldern für den Namen, den Typ und das Dateiformat des key pair. Die Schaltfläche key pair erstellen befindet sich in der unteren rechten Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/create-key-pair.png)
**Anmerkung**
Aus Sicherheitsgründen empfehlen wir dringend, ein Schlüsselpaar sowohl für die SSH- als auch für die Internetverbindung zu Ihrer EC2-Instance zu verwenden.
1. **Optional:** **Wählen Sie im **Abschnitt Netzwerkeinstellungen** unter **Firewall (Sicherheitsgruppen) die Option Sicherheitsgruppe erstellen** aus.**
![\[Die Oberfläche mit den Netzwerkeinstellungen zeigt Optionen zum Erstellen einer Sicherheitsgruppe.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/firewall.png)
Wählen Sie **Sicherheitsgruppe erstellen** (überprüfen Sie alle Regeln für die Zulassung von Datenverkehr, die für Ihre EC2-Konnektivität gelten).
**Anmerkung**
Wenn Sie eine bestehende Sicherheitsgruppe verwenden möchten, folgen Sie den Anweisungen unter[Manuelles Connect von Amazon EC2](connect-ec2-manual.md).
1. Überprüfen Sie im Abschnitt **Zusammenfassung** Ihre EC2-Konfiguration und wählen Sie **Launch instance**, falls korrekt.
### Schritt 2: Erstellen Sie einen Amazon DocumentDB-Cluster
Während die Amazon EC2 EC2-Instance bereitgestellt wird, erstellen Sie Ihren Amazon DocumentDB-Cluster.
1. Navigieren Sie zur Amazon DocumentDB DocumentDB-Konsole und wählen Sie im Navigationsbereich **Clusters** aus.
1. Wählen Sie **Erstellen** aus.
1. Belassen Sie die Standardeinstellung für den **Clustertyp** **auf Instance Based Cluster**.
1. Geben Sie in **Clusterkonfiguration** für **Cluster-ID** einen eindeutigen Namen ein. Beachten Sie, dass die Konsole alle Clusternamen unabhängig davon, wie sie eingegeben wurden, in Kleinbuchstaben ändert.
**Behalten Sie für die **Engine-Version** den Standardwert 5.0.0 bei.**
1. Behalten Sie für die **Cluster-Speicherkonfiguration** die Standardeinstellung von **Amazon DocumentDB Standard** bei.
1. In der **Instanzkonfiguration**:
+ Wählen Sie für **DB-Instance-Klasse** die Option **Speicheroptimierte Klassen (einschließlich R-Klassen)** aus (dies ist die Standardeinstellung).
Bei der anderen Instance-Option handelt es sich um **Klassen mit NVMe -backed.** Weitere Informationen hierzu finden Sie unter [NVMe-gestützte Instances](db-instance-nvme.md).
+ Wählen Sie für **Instance-Klasse** den Instance-Typ aus, der Ihren Anforderungen entspricht. Eine detailliertere Erläuterung der Instanzklassen finden Sie unter[Spezifikationen der Instanzklasse](db-instance-classes.md#db-instance-class-specs).
+ Wählen Sie für **die Anzahl der Instances** eine Zahl aus, die Ihren Anforderungen am besten entspricht. Denken Sie daran, je niedriger die Anzahl, desto niedriger die Kosten und desto geringer das read/write Volumen, das vom Cluster verwaltet werden kann.
![\[Konfigurationsoberfläche mit Standardwerten für Cluster-ID, Engine-Version und Instanzklasse, wobei die Anzahl der Instanzen auf eins festgelegt ist.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/create-cluster/instance-config.png)
1. Wählen Sie für **Konnektivität** die Option Mit **einer EC2-Rechenressource Connect** aus. Dies ist die EC2-Instance, die Sie in Schritt 1 erstellt haben.
![\[Konnektivitätsschnittstelle, bei der die Option Mit einer EC2-Rechenressource Connect ausgewählt ist.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2-connect.png)
**Anmerkung**
Wenn Sie eine Verbindung zu einer EC2-Rechenressource herstellen, wird automatisch eine Sicherheitsgruppe für Ihre EC2-Rechenressourcenverbindung zu Ihrem Amazon DocumentDB-Cluster erstellt. Wenn Sie mit der Erstellung Ihres Clusters fertig sind und die neu erstellte Sicherheitsgruppe sehen möchten, navigieren Sie zur Cluster-Liste und wählen Sie die Kennung Ihres Clusters aus. Gehen Sie auf der Registerkarte **Konnektivität und Sicherheit** zu **Sicherheitsgruppen** und suchen Sie unter **Sicherheitsgruppenname (ID) nach Ihrer Gruppe**. Sie wird den Namen Ihres Clusters enthalten und etwa wie folgt aussehen:`docdb-ec2-docdb-2023-12-11-21-33-41:i-0e4bb09985d2bbc4c (sg-0238e0b0bf0f73877)`.
1. Geben Sie im Abschnitt **Authentifizierung** einen Benutzernamen für den Hauptbenutzer ein und wählen Sie dann **Selbstverwaltet** aus. Geben Sie ein Passwort ein und bestätigen Sie es.
Wenn Sie stattdessen **Verwaltet in** wählen AWS Secrets Manager, finden Sie [Passwortverwaltung mit Amazon DocumentDB und AWS Secrets Manager](docdb-secrets-manager.md) weitere Informationen unter.
1. Wählen Sie **Cluster erstellen**.
### Schritt 3: Connect zu Ihrer Amazon EC2 EC2-Instance her
Um die Mongo-Shell zu installieren, müssen Sie zuerst eine Verbindung zu Ihrer Amazon EC2 EC2-Instance herstellen. Durch die Installation der Mongo-Shell können Sie eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herstellen und ihn abfragen. Führen Sie folgende Schritte aus:
1. Navigieren Sie auf der Amazon EC2 EC2-Konsole zu Ihren Instances und überprüfen Sie, ob die gerade erstellte Instance läuft. Wenn ja, wählen Sie die Instance aus, indem Sie auf die Instance-ID klicken.
![\[Instance-Tabelle mit zwei Instances in der Amazon EC2 EC2-Konsole.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/ec2-instance-table.png)
1. Wählen Sie **Connect** aus.
![\[Instanzzusammenfassung für eine Amazon EC2 EC2-Instance. Die Schaltfläche Connect befindet sich in der oberen rechten Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/ec2-instance-summary.png)
1. Es gibt vier Optionen mit Registerkarten für Ihre Verbindungsmethode: Amazon EC2 Instance Connect, Session Manager, SSH-Client oder serielle EC2-Konsole. Sie müssen eine auswählen und deren Anweisungen befolgen. Wenn Sie fertig sind, wählen Sie **Connect**.
![\[Schnittstelle mit Konfigurationsoptionen für die EC2 Instance Connect-Verbindungsmethode.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/connect-options.png)
**Anmerkung**
Wenn sich Ihre IP-Adresse geändert hat, nachdem Sie diesen Walkthrough gestartet haben, oder wenn Sie zu einem späteren Zeitpunkt zu Ihrer Umgebung zurückkehren, müssen Sie Ihre `demoEC2` Sicherheitsgruppenregel für eingehenden Datenverkehr aktualisieren, um eingehenden Datenverkehr von Ihrer neuen API-Adresse aus zu ermöglichen.
### Schritt 4: Installieren Sie die MongoDB-Shell
Sie können jetzt die MongoDB-Shell installieren. Dabei handelt es sich um ein Befehlszeilenprogramm, mit dem Sie eine Verbindung herstellen und Ihren Amazon DocumentDB-Cluster abfragen können. Derzeit gibt es zwei Versionen der MongoDB-Shell: die neueste Version, Mongosh, und die vorherige Version, Mongo-Shell.
**Wichtig**
Es gibt eine bekannte Einschränkung bei Treibern von Node.js, die älter als Version 6.13.1 sind und die derzeit nicht von der IAM-Identitätsauthentifizierung für Amazon DocumentDB unterstützt werden. Die Treiber und Tools der Datei Node.js, die den Treiber Node.js verwenden (z. B. mongosh), müssen aktualisiert werden, sodass sie den Treiber Node.js der Version 6.13.1 oder höher verwenden.
Folgen Sie den nachstehenden Anweisungen, um die MongoDB-Shell für Ihr Betriebssystem zu installieren.
------
#### [ On Amazon Linux ]
**So installieren Sie die MongoDB-Shell auf Amazon Linux**
Wenn Sie *keine* IAM-Authentifizierung verwenden und die neueste MongoDB-Shell (mongosh) verwenden möchten, um eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herzustellen, gehen Sie wie folgt vor:
1. Erstellen Sie die Repository-Datei. Führen Sie in der Befehlszeile Ihrer EC2-Instance, die Sie erstellt haben, den folgenden Befehl aus:
```
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. Wenn der Vorgang abgeschlossen ist, installieren Sie mongosh mit einer der beiden folgenden Befehlsoptionen an der Befehlszeile:
**Option 1** — Wenn Sie während der Amazon EC2-Konfiguration das standardmäßige Amazon Linux 2023 ausgewählt haben, geben Sie diesen Befehl ein:
```
sudo yum install -y mongodb-mongosh-shared-openssl3
```
**Option 2** — Wenn Sie bei der Amazon EC2-Konfiguration Amazon Linux 2 ausgewählt haben, geben Sie diesen Befehl ein:
```
sudo yum install -y mongodb-mongosh
```
Wenn Sie die IAM-Authentifizierung verwenden, müssen Sie die vorherige Version der MongoDB-Shell (5.0) verwenden, um eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herzustellen. Gehen Sie wie folgt vor:
1. Erstellen Sie die Repository-Datei. Führen Sie in der Befehlszeile Ihrer EC2-Instance, die Sie erstellt haben, den folgenden Befehl aus:
```
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. Wenn der Vorgang abgeschlossen ist, installieren Sie die Mongodb 5.0-Shell mit der folgenden Befehlsoption an der Befehlszeile:
```
sudo yum install -y mongodb-org-shell
```
------
#### [ On Ubuntu ]
**Um mongosh auf Ubuntu zu installieren**
1. Importieren Sie den öffentlichen Schlüssel, der von dem Paketverwaltungssystem verwendet wird.
```
curl -fsSL https://pgp.mongodb.com/server-5.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-server-5.0.gpg
```
1. Erstellen Sie die Listendatei `mongodb-org-5.0.list` für MongoDB mit dem korrekten Befehl für Ihre Ubuntu-Version.
```
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. Importieren und aktualisieren Sie die lokale Paketdatenbank mit dem folgenden Befehl:
```
sudo apt-get update
```
1. Installieren Sie Mongosh.
```
sudo apt-get install -y mongodb-mongosh
```
Weitere Informationen zum Installieren von früheren Versionen von MongoDB auf Ihrem Ubuntu-System finden Sie unter [Installieren von MongoDB Community Edition auf Ubuntu](https://docs.mongodb.com/v3.6/tutorial/install-mongodb-on-ubuntu/).
------
#### [ On other operating systems ]
Informationen zum Installieren der mongo-Shell auf anderen Betriebssystemen finden Sie unter [Installieren von MongoDB Community Edition](https://www.mongodb.com/docs/manual/administration/install-community/) in der MongoDB-Dokumentation.
------
### Schritt 5: Amazon DocumentDB TLS verwalten
Laden Sie das CA-Zertifikat für Amazon DocumentDB mit dem folgenden Code herunter: `wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem`
**Anmerkung**
Transport Layer Security (TLS) ist standardmäßig für alle neuen Amazon DocumentDB-Cluster aktiviert. Weitere Informationen finden Sie unter [TLS-Einstellungen für Amazon DocumentDB-Cluster verwalten](https://docs.aws.amazon.com/documentdb/latest/developerguide/security.encryption.ssl.html).
### Schritt 6: Connect zu Ihrem Amazon DocumentDB-Cluster her
1. Suchen Sie auf der Amazon DocumentDB DocumentDB-Konsole unter **Clusters** Ihren Cluster. Wählen Sie den Cluster aus, den Sie erstellt haben, indem Sie auf die **Cluster-ID für diesen** Cluster klicken.
1. **Suchen Sie auf der Registerkarte **Konnektivität und Sicherheit** im Feld **Connect nach Connect to this cluster with the mongo shell**:**
![\[Cluster-Verbindungseinstellungen mit hervorgehobener MongoDB-Verbindungszeichenfolge für die Verbindung zu einem Amazon DocumentDB-Cluster mithilfe der Mongo-Shell.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/connect-mongosh.png)
Kopieren Sie die angegebene Verbindungszeichenfolge und fügen Sie sie in Ihr Terminal ein.
Nehmen Sie die folgenden Änderungen daran vor:
1. Stellen Sie sicher, dass Sie den richtigen Benutzernamen in der Zeichenfolge haben.
1. Auslassen, `` sodass Sie beim Herstellen der Verbindung von der Mongo-Shell zur Eingabe des Passworts aufgefordert werden.
1. Optional: Wenn Sie die IAM-Authentifizierung oder die vorherige Version der MongoDB-Shell verwenden, ändern Sie Ihre Verbindungszeichenfolge wie folgt:
`mongo --ssl --host mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1.docdb.amazonaws.com:27017 --sslCAFile global-bundle.pem --username SampleUser1 --password`
`mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1`Ersetzen Sie durch dieselben Informationen aus Ihrem Cluster.
1. Drücken Sie die Eingabetaste in Ihrem Terminal. Sie werden nun zur Eingabe Ihres Passworts aufgefordert. Geben Sie Ihr Passwort ein.
1. Wenn Sie Ihr Passwort eingeben und die `rs0 [direct: primary] >` Aufforderung sehen, sind Sie erfolgreich mit Ihrem Amazon DocumentDB-Cluster verbunden.
Haben Sie Probleme mit der Verbindung? Weitere Informationen finden Sie unter [Fehlerbehebung bei Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/troubleshooting.html).
### Schritt 7: Daten einfügen und abfragen
Nachdem Sie nun mit Ihrem Cluster verbunden sind, können Sie einige Abfragen ausführen, um sich mit der Verwendung einer Dokumentendatenbank vertraut zu machen.
1. Um ein einzelnes Dokument einzufügen, geben Sie Folgendes ein:
```
db.collection.insertOne({"hello":"DocumentDB"})
```
Sie erhalten die folgende Ausgabe:
```
{
acknowledged: true,
insertedId: ObjectId('673657216bdf6258466b128c')
}
```
1. Sie können das Dokument lesen, das Sie mit dem `findOne()` Befehl geschrieben haben (weil er nur ein einziges Dokument zurückgibt). Geben Sie Folgendes ein:
```
db.collection.findOne()
```
Sie erhalten die folgende Ausgabe:
```
{ "_id" : ObjectId("5e401fe56056fda7321fbd67"), "hello" : "DocumentDB" }
```
1. Um ein paar weitere Abfragen durchzuführen, sollten Sie einen Anwendungsfall für Spieleprofile in Betracht ziehen. Fügen Sie zunächst einige Einträge in eine Sammlung mit dem Titel ein`profiles`. Geben Sie Folgendes ein:
```
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 }
])
```
Sie erhalten die folgende Ausgabe:
```
{ acknowledged: true, insertedIds: { '0': 1, '1': 2, '2': 3, '3': 4 } }
```
1. Verwenden Sie den `find()` Befehl, um alle Dokumente in der Profilsammlung zurückzugeben. Geben Sie Folgendes ein:
```
db.profiles.find()
```
Sie erhalten eine Ausgabe, die den Daten entspricht, die Sie in Schritt 3 eingegeben haben.
1. Verwenden Sie mithilfe eines Filters eine Abfrage für ein einzelnes Dokument. Geben Sie Folgendes ein:
```
db.profiles.find({name: "Katie"})
```
Sie erhalten die folgende Ausgabe:
```
{ "_id" : 4, "name" : "Katie", "status": "active", "level": 3, "score":27}
```
1. Versuchen wir nun, ein Profil zu finden und es mit dem `findAndModify` Befehl zu ändern. Wir geben dem Benutzer Matt zusätzliche 10 Punkte mit dem folgenden Code:
```
db.profiles.findAndModify({
query: { name: "Matt", status: "active"},
update: { $inc: { score: 10 } }
})
```
Sie erhalten die folgende Ausgabe (beachten Sie, dass sein Punktestand noch nicht gestiegen ist):
```
{
[{_id : 1, name : 'Matt', status: 'active', level: 12, score: 202}]
```
1. Sie können mit der folgenden Abfrage überprüfen, ob sich sein Punktestand geändert hat:
`db.profiles.find({name: "Matt"})`
Sie erhalten die folgende Ausgabe:
```
{ "_id" : 1, "name" : "Matt", "status" : "active", "level" : 12, "score" : 212 }
```
### Schritt 8: Erkunden
Herzlichen Glückwunsch\$1 Sie haben die Schnellstartanleitung für Amazon DocumentDB erfolgreich abgeschlossen.
Was kommt als Nächstes? Erfahren Sie, wie Sie diese leistungsstarke Datenbank mit einigen ihrer beliebten Funktionen voll ausschöpfen können:
+ [Amazon DocumentDB verwalten](https://docs.aws.amazon.com/documentdb/latest/developerguide/managing-documentdb.html)
+ [Skalierung](https://docs.aws.amazon.com/documentdb/latest/developerguide/operational_tasks.html)
+ [Sichern und Wiederherstellen](https://docs.aws.amazon.com/documentdb/latest/developerguide/backup_restore.html)
**Anmerkung**
Um Kosten zu sparen, können Sie entweder Ihren Amazon DocumentDB-Cluster stoppen, um die Kosten zu senken, oder den Cluster löschen. Standardmäßig stoppt Ihre AWS Cloud9 Umgebung nach 30 Minuten Inaktivität die zugrunde liegende Amazon EC2 EC2-Instance.
## Automatisches Verbinden einer EC2-Instance mit einer vorhandenen Amazon DocumentDB DocumentDB-Datenbank
Das folgende Verfahren setzt voraus, dass Sie über einen vorhandenen Amazon DocumentDB-Cluster und eine bestehende Amazon EC2 EC2-Instance verfügen.
**Greifen Sie auf Ihren Amazon DocumentDB-Cluster zu und richten Sie die Amazon EC2 EC2-Verbindung ein**
1. Greifen Sie auf Ihren Amazon DocumentDB-Cluster zu.
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon DocumentDB DocumentDB-Konsole unter [https://console.aws.amazon.com/docdb](https://console.aws.amazon.com/docdb).
1. Klicken Sie im Navigationsbereich auf **Cluster**.
**Tipp**
Wenn der Navigationsbereich auf der linken Seite des Bildschirms nicht angezeigt wird, wählen Sie links oben auf der Seite das Menüsymbol (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/docdb-menu-icon.png)) aus.
1. Geben Sie den gewünschten Cluster an, indem Sie auf die Schaltfläche links neben dem Namen des Clusters klicken.
1. Richten Sie die Amazon EC2 EC2-Verbindung ein.
1. Wählen Sie **Aktionen** und dann **EC2-Verbindung einrichten**.
![\[In der Dropdownliste Aktionen ist die Option EC2-Verbindung einrichten ausgewählt.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/setup-ec2-connect.png)
Das Dialogfeld **EC2-Verbindung einrichten** wird angezeigt.
1. Wählen Sie im Feld **EC2-Instance** die EC2-Instance aus, die Sie mit Ihrem Cluster verbinden möchten.
![\[Die Dropdownliste EC2-Verbindungsschnittstelle einrichten mit hervorgehobener EC2-Instance.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/setup-ec2-connect-dialog.png)
1. Klicken Sie auf **Weiter**.
Das Dialogfeld „**Überprüfen und bestätigen**“ wird angezeigt.
1. Vergewissern Sie sich, dass die Änderungen korrekt sind. Wählen Sie dann **Verbindung einrichten**.
![\[Die Oberfläche „Überprüfen und Bestätigen“ zeigt eine Zusammenfassung der Änderungen an. Die Schaltfläche Verbindung einrichten befindet sich in der unteren rechten Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/setup-ec2-review-confirm.png)
Bei Erfolg wird die folgende Überprüfung angezeigt:
![\[Bestätigungsnachricht für einen erfolgreichen Verbindungsaufbau zwischen der Amazon DocumentDB DocumentDB-Datenbank und der EC2-Instance.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/setup-ec2-connect-success.png)
## Übersicht über die automatische Verbindung mit einer EC2-Instance
Wenn Sie eine Verbindung zwischen einer EC2-Instance und einer Amazon DocumentDB-Datenbank einrichten, konfiguriert Amazon DocumentDB automatisch die VPC-Sicherheitsgruppe für Ihre EC2-Instance und für Ihre Amazon DocumentDB DocumentDB-Datenbank.
Die folgenden Anforderungen gelten für die Verbindung einer EC2-Instance mit einer Amazon DocumentDB DocumentDB-Datenbank:
+ Die EC2-Instance muss in derselben VPC wie die Amazon DocumentDB DocumentDB-Datenbank existieren.
Wenn keine EC2-Instances in derselben VPC vorhanden sind, dann bietet die Konsole einen Link zum Erstellen einer solchen Instance.
+ Der Benutzer, der die Verbindung einrichtet, muss über Berechtigungen zum Ausführen der folgenden Amazon-EC2-Vorgänge verfügen:
+ `ec2:AuthorizeSecurityGroupEgress`
+ `ec2:AuthorizeSecurityGroupIngress`
+ `ec2:CreateSecurityGroup`
+ `ec2:DescribeInstances`
+ `ec2:DescribeNetworkInterfaces`
+ `ec2:DescribeSecurityGroups`
+ `ec2:ModifyNetworkInterfaceAttribute`
+ `ec2:RevokeSecurityGroupEgress`
Auf Ihrem Konto fallen ggf. Kosten über Availability Zones hinweg an, wenn sich die DB-Instance und die EC2-Instance in unterschiedlichen Availability Zones befinden.
Wenn Sie eine Verbindung zu einer EC2-Instance einrichten, handelt Amazon DocumentDB gemäß der aktuellen Konfiguration der Sicherheitsgruppen, die der Amazon DocumentDB DocumentDB-Datenbank und EC2-Instance zugeordnet sind, wie in der folgenden Tabelle beschrieben:
| Aktuelle Amazon DocumentDB-Sicherheitsgruppenkonfiguration | Aktuelle EC2-Sicherheitsgruppenkonfiguration | Amazon DocumentDB DocumentDB-Aktion |
| --- | --- | --- |
| Der Amazon DocumentDB DocumentDB-Datenbank sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster DocumentDB-ec2-n entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. | Der EC2-Instance sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster entspricht DocumentDB-ec2-n (wobei n eine Zahl ist). Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe hat nur eine ausgehende Regel mit der VPC-Sicherheitsgruppe der Amazon DocumentDB DocumentDB-Datenbank als Quelle. | Amazon DocumentDB ergreift keine Maßnahmen. Eine Verbindung zwischen der EC2-Instance und der Amazon DocumentDB DocumentDB-Datenbank wurde bereits automatisch konfiguriert. Da bereits eine Verbindung zwischen der EC2-Instance und der Amazon DocumentDB DocumentDB-Datenbank besteht, werden die Sicherheitsgruppen nicht geändert. |
| Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/connect-ec2-auto.html) | Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/connect-ec2-auto.html) | Amazon DocumentDB DocumentDB-Aktion: Neue Sicherheitsgruppen erstellen |
| Der Amazon DocumentDB DocumentDB-Datenbank sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster DocumentDB-ec2-n entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. | Der EC2-Instance sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster ec2-DocumentDB-n entspricht. Amazon DocumentDB kann jedoch keine dieser Sicherheitsgruppen für die Verbindung mit der Amazon DocumentDB DocumentDB-Datenbank verwenden. Amazon DocumentDB kann keine Sicherheitsgruppe verwenden, die keine einzige ausgehende Regel mit der VPC-Sicherheitsgruppe der Amazon DocumentDB DocumentDB-Datenbank als Quelle hat. Amazon DocumentDB kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. | Amazon DocumentDB DocumentDB-Aktion: Neue Sicherheitsgruppen erstellen |
| Der Amazon DocumentDB DocumentDB-Datenbank sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster DocumentDB-ec2-n entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. | Eine gültige EC2-Sicherheitsgruppe für die Verbindung ist vorhanden, jedoch nicht mit der EC2-Instance verknüpft. Die Sicherheitsgruppe trägt einen Namen, der dem Muster DocumentDB-ec2-n entspricht. Sie wurde nicht geändert. Es gibt nur eine ausgehende Regel mit der VPC-Sicherheitsgruppe der Amazon DocumentDB DocumentDB-Datenbank als Quelle. | Amazon DocumentDB DocumentDB-Aktion: EC2-Sicherheitsgruppe zuordnen |
| Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/connect-ec2-auto.html) | Der EC2-Instance sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster DocumentDB-ec2-n entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe hat nur eine ausgehende Regel mit der VPC-Sicherheitsgruppe der Amazon DocumentDB DocumentDB-Datenbank als Quelle. | Amazon DocumentDB DocumentDB-Aktion: Neue Sicherheitsgruppen erstellen |
**Amazon DocumentDB DocumentDB-Aktion: Neue Sicherheitsgruppen erstellen**
Amazon DocumentDB ergreift die folgenden Aktionen:
+ Erstellt eine neue Sicherheitsgruppe, die dem Muster `DocumentDB-ec2-n` entspricht. Diese Sicherheitsgruppe enthält eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. Diese Sicherheitsgruppe ist mit der Amazon DocumentDB DocumentDB-Datenbank verknüpft und ermöglicht der EC2-Instance den Zugriff auf die Amazon DocumentDB DocumentDB-Datenbank.
+ Erstellt eine neue Sicherheitsgruppe, die dem Muster `ec2-DocumentDB-n` entspricht. Diese Sicherheitsgruppe hat eine ausgehende Regel mit der VPC-Sicherheitsgruppe der Amazon DocumentDB DocumentDB-Datenbank als Quelle. Diese Sicherheitsgruppe ist der EC2-Instance zugeordnet und ermöglicht der EC2-Instance, Traffic an die Amazon DocumentDB DocumentDB-Datenbank zu senden.
**Amazon DocumentDB DocumentDB-Aktion: EC2-Sicherheitsgruppe zuordnen**
Amazon DocumentDB ordnet die gültige, bestehende EC2-Sicherheitsgruppe der EC2-Instance zu. Diese Sicherheitsgruppe ermöglicht es der EC2-Instance, Datenverkehr an die Amazon DocumentDB DocumentDB-Datenbank zu senden.
## Anzeigen verbundener Rechenressourcen
Sie können den verwenden AWS-Managementkonsole , um die Rechenressourcen anzuzeigen, die mit einer Amazon DocumentDB DocumentDB-Datenbank verbunden sind. Zu den angezeigten Ressourcen gehören Rechenressourcenverbindungen, die automatisch eingerichtet wurden. Sie können die Konnektivität mit Rechenressourcen auf folgende Weise automatisch einrichten:
+ Sie können die Rechenressource auswählen, wenn Sie die Datenbank erstellen. Weitere Informationen finden Sie unter [Einen Amazon DocumentDB-Cluster erstellen](db-cluster-create.md) und Einen Multi-AZ-DB-Cluster erstellen.
+ Sie können die Konnektivität zwischen einer vorhandenen Datenbank und einer Rechenressource einrichten. Weitere Informationen finden Sie unter [Amazon EC2 automatisch Connect](#connect-ec2-auto).
Die aufgelisteten Rechenressourcen enthalten keine Ressourcen, die manuell mit der Datenbank verbunden wurden. Sie können beispielsweise einer Rechenressource den manuellen Zugriff auf eine Datenbank erlauben, indem Sie der VPC-Sicherheitsgruppe, die der Datenbank zugeordnet ist, eine Regel hinzufügen.
Für die Auflistung einer Rechenressource müssen die folgenden Bedingungen erfüllt sei:
+ Der Name der Sicherheitsgruppe, die der Rechenressource zugeordnet ist, entspricht dem Muster `ec2-DocumentDB-n` (wobei n eine Zahl ist).
+ Die mit der Rechenressource verknüpfte Sicherheitsgruppe hat eine ausgehende Regel, bei der der Portbereich auf den Port festgelegt ist, den die Amazon DocumentDB DocumentDB-Datenbank verwendet.
+ Die mit der Rechenressource verknüpfte Sicherheitsgruppe hat eine ausgehende Regel, bei der die Quelle auf eine Sicherheitsgruppe gesetzt ist, die der Amazon DocumentDB DocumentDB-Datenbank zugeordnet ist.
+ Der Name der Sicherheitsgruppe, die mit der Amazon DocumentDB DocumentDB-Datenbank verknüpft ist, entspricht dem Muster `DocumentDB-ec2-n` (wobei n eine Zahl ist).
+ Die mit der Amazon DocumentDB DocumentDB-Datenbank verknüpfte Sicherheitsgruppe hat eine Eingangsregel, bei der der Portbereich auf den Port festgelegt ist, den die Amazon DocumentDB DocumentDB-Datenbank verwendet.
+ Die mit der Amazon DocumentDB DocumentDB-Datenbank verknüpfte Sicherheitsgruppe hat eine Eingangsregel, bei der die Quelle auf eine Sicherheitsgruppe gesetzt ist, die der Rechenressource zugeordnet ist.
**Um Rechenressourcen anzuzeigen, die mit einer Amazon DocumentDB DocumentDB-Datenbank verbunden sind**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon DocumentDB DocumentDB-Konsole unter [https://console.aws.amazon.com/docdb](https://console.aws.amazon.com/docdb).
1. Wählen Sie im Navigationsbereich **Datenbanken** und dann den Namen der Amazon DocumentDB DocumentDB-Datenbank aus.
1. Sehen Sie sich auf der Registerkarte **Konnektivität und Sicherheit** die Rechenressourcen im Abschnitt **Verbundene Rechenressourcen** an.
# Manuelles Connect von Amazon EC2
**Topics**
+ [
## Schritt 1: Erstellen Sie eine Amazon EC2 EC2-Instance
](#manual-connect-ec2.launch-ec2-instance)
+ [
## Schritt 2: Erstellen einer Sicherheitsgruppe
](#manual-connect-ec2.security-group)
+ [
## Schritt 3: Erstellen Sie einen Amazon DocumentDB-Cluster
](#manual-connect-ec2.launch-cluster)
+ [
## Schritt 4: Connect zu Ihrer Amazon EC2 EC2-Instance her
](#manual-connect-ec2.connect)
+ [
## Schritt 5: Installieren Sie die MongoDB-Shell
](#manual-connect-ec2.install-mongo-shell)
+ [
## Schritt 6: Amazon DocumentDB TLS verwalten
](#manual-connect-ec2.tls)
+ [
## Schritt 7: Connect zu Ihrem Amazon DocumentDB-Cluster her
](#manual-connect-ec2.connect-use)
+ [
## Schritt 8: Daten einfügen und abfragen
](#manual-cloud9-insert-query)
+ [
## Schritt 9: Erkunden
](#manual-connect-ec2.explore)
Bei den folgenden Schritten wird davon ausgegangen, dass Sie die Schritte im [Voraussetzungen](connect-ec2.md#connect-ec2-prerequisites) Thema abgeschlossen haben.
## Schritt 1: Erstellen Sie eine Amazon EC2 EC2-Instance
In diesem Schritt erstellen Sie eine Amazon EC2 EC2-Instance in derselben Region und Amazon VPC, die Sie später für die Bereitstellung Ihres Amazon DocumentDB-Clusters verwenden werden.
1. Wählen Sie auf der Amazon EC2 EC2-Konsole **Launch instance** aus.
![\[Der Abschnitt Launch Instance auf der Amazon EC2 EC2-Konsole.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/launch-instance.png)
1. Geben Sie einen Namen oder eine Kennung in das Feld **Name** im Abschnitt **Name und Tags** ein.
1. Suchen Sie in der Dropdownliste **Amazon Machine Image (AMI)** nach **Amazon Linux 2 AMI** und wählen Sie es aus.
![\[Die Anwendungs- und Betriebssystem-Images bieten eine Schnittstelle mit der Amazon Linux 2 AMI-Option, die im Abschnitt Schnellstart ausgewählt wurde.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/linux2-ami.png)
1. Suchen Sie in der Dropdownliste **Instance-Typ** nach **t3.micro** und wählen Sie es aus.
1. Geben Sie im Abschnitt **key pair (Anmeldung)** die Kennung eines vorhandenen Schlüsselpaars ein, oder wählen Sie **Neues Schlüsselpaar erstellen**.
![\[Die Schlüsselpaar-Schnittstelle mit dem Feld für den Namen des key pair und der Option Neues key pair erstellen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/key-pair.png)
Sie müssen ein Amazon EC2 EC2-Schlüsselpaar angeben.
+ Wenn Sie ein Amazon EC2 EC2-Schlüsselpaar haben:
1. Wählen Sie ein key pair aus, wählen Sie Ihr key pair aus der Liste.
1. Sie müssen die private Schlüsseldatei (.pem- oder .ppk-Datei) bereits verfügbar haben, um sich bei Ihrer Amazon EC2 EC2-Instance anmelden zu können.
+ Wenn Sie kein Amazon EC2 EC2-Schlüsselpaar haben:
1. Wählen Sie **Neues key pair** **erstellen. Daraufhin wird das Dialogfeld key pair** erstellen angezeigt.
1. Geben Sie einen Namen in das Feld **Name des Schlüsselpaars** ein.
1. Wählen Sie den **Schlüsselpaartyp** und das **Dateiformat für den privaten Schlüssel**.
1. Wählen Sie **Create Key Pair (Schlüsselpaar erstellen)** aus.
![\[Die Schnittstelle key pair erstellen mit Feldern für den Namen, den Typ und das Dateiformat des key pair. Die Schaltfläche key pair erstellen befindet sich in der unteren rechten Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/create-key-pair.png)
**Anmerkung**
Aus Sicherheitsgründen empfehlen wir dringend, ein Schlüsselpaar sowohl für die SSH- als auch für die Internetverbindung zu Ihrer EC2-Instance zu verwenden.
1. Wählen Sie im **Abschnitt Netzwerkeinstellungen** unter **Firewall (Sicherheitsgruppen)** entweder Sicherheitsgruppe **erstellen oder Bestehende Sicherheitsgruppe** **auswählen aus**.
![\[Die Oberfläche mit den Netzwerkeinstellungen zeigt Optionen zum Erstellen einer Sicherheitsgruppe.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/firewall.png)
Wenn Sie eine bestehende Sicherheitsgruppe auswählen möchten, wählen Sie eine aus der Dropdownliste **Allgemeine Sicherheitsgruppen** aus.
Wenn Sie eine neue Sicherheitsgruppe erstellen möchten, gehen Sie wie folgt vor:
1. Überprüfen Sie alle Regeln für die Zulassung von Datenverkehr, die für Ihre EC2-Konnektivität gelten.
1. Wählen Sie im Feld IP die Option **Meine IP** oder **Benutzerdefiniert** aus, um aus einer Liste von CIDR-Blöcken, Präfixlisten oder Sicherheitsgruppen auszuwählen. Wir empfehlen **Anywhere** nicht als Wahl, es sei denn, Ihre EC2-Instance befindet sich in einem isolierten Netzwerk, da sie beliebigen IP-Adressen den Zugriff auf Ihre EC2-Instance ermöglicht.
![\[Das Drop-down-Menü „Meine IP“.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/ip-field.png)
1. Überprüfen Sie im Abschnitt **Zusammenfassung** Ihre EC2-Konfiguration und wählen Sie, falls korrekt, die Option **Launch instance** aus.
## Schritt 2: Erstellen einer Sicherheitsgruppe
Sie werden jetzt eine neue Sicherheitsgruppe in Ihrer Standard-Amazon-VPC erstellen. Die Sicherheitsgruppe `demoDocDB` ermöglicht es Ihnen, von Ihrer Amazon EC2-Instance aus eine Verbindung zu Ihrem Amazon DocumentDB-Cluster auf Port 27017 (dem Standardport für Amazon DocumentDB) herzustellen.
1. Wählen Sie in der [Amazon EC2 Management Console](https://console.aws.amazon.com/ec2) unter **Netzwerk und Sicherheit** die Option **Sicherheitsgruppen** aus.
![\[Navigationsbereich der Amazon DocumentDB DocumentDB-Konsole mit der in der Dropdownliste Netzwerk und Sicherheit ausgewählten Option „Sicherheitsgruppen“.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/nav-security-groups.png)
1. Wählen Sie **Sicherheitsgruppe erstellen** aus.
![\[Die Schaltfläche Sicherheitsgruppe erstellen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/create-sg-btn-2.png)
1. Gehen Sie im Abschnitt **Grundlegende Details** wie folgt vor:
1. Geben Sie für **Security group name** (Name der Sicherheitsgruppe) `demoDocDB` ein.
1. Geben Sie im Feld **Description (Beschreibung)** eine Beschreibung ein.
1. Akzeptieren Sie für **VPC** die Verwendung Ihrer Standard-VPC.
1. Wählen Sie im Abschnitt **Eingehende Regeln** die Option **Regel hinzufügen** aus.
1. Wählen Sie für **Typ** die Option **Benutzerdefinierte TCP-Regel** (Standard) aus.
1. Geben Sie für **Portbereich** den Wert ein`27017`.
1. Wählen Sie für **Source (Quelle)** die Option **Custom (Benutzerdefiniert)** aus. Suchen Sie im Feld daneben nach der Sicherheitsgruppe, die Sie gerade in Schritt 1 erstellt haben. Möglicherweise müssen Sie Ihren Browser aktualisieren, damit die Amazon EC2 EC2-Konsole den Quellnamen automatisch ausfüllt.
![\[Abschnitt mit Regeln für eingehende Nachrichten mit Feldern für Typ, Protokoll, Portbereich, Quelle und Beschreibung. Die Schaltfläche Regel hinzufügen befindet sich in der unteren linken Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/inbound-rules.png)
1. Akzeptieren Sie alle anderen Standardeinstellungen und wählen Sie Sicherheitsgruppe **erstellen** aus.
![\[Die Schaltfläche Sicherheitsgruppe erstellen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/create-sg-btn-2.png)
## Schritt 3: Erstellen Sie einen Amazon DocumentDB-Cluster
Während die Amazon EC2 EC2-Instance bereitgestellt wird, erstellen Sie Ihren Amazon DocumentDB-Cluster.
1. Navigieren Sie zur Amazon DocumentDB DocumentDB-Konsole und wählen Sie im Navigationsbereich **Clusters** aus.
1. Wählen Sie **Erstellen** aus.
1. Belassen Sie die Standardeinstellung für den **Clustertyp** **auf Instance Based Cluster**.
1. Geben Sie in **Clusterkonfiguration** für **Cluster-ID** einen eindeutigen Namen ein. Beachten Sie, dass die Konsole alle Clusternamen unabhängig davon, wie sie eingegeben wurden, in Kleinbuchstaben ändert.
**Behalten Sie für die **Engine-Version** den Standardwert 5.0.0 bei.**
1. Behalten Sie für die **Cluster-Speicherkonfiguration** die Standardeinstellung von **Amazon DocumentDB Standard** bei.
1. In der **Instanzkonfiguration**:
+ Wählen Sie für **DB-Instance-Klasse** die Option **Speicheroptimierte Klassen (einschließlich R-Klassen)** aus (dies ist die Standardeinstellung).
Bei der anderen Instance-Option handelt es sich um **Klassen mit NVMe -backed.** Weitere Informationen hierzu finden Sie unter [NVMe-gestützte Instances](db-instance-nvme.md).
+ Wählen Sie für **Instance-Klasse** den Instance-Typ aus, der Ihren Anforderungen entspricht. Eine detailliertere Erläuterung der Instanzklassen finden Sie unter[Spezifikationen der Instanzklasse](db-instance-classes.md#db-instance-class-specs).
+ Wählen Sie für **die Anzahl der Instances** eine Zahl aus, die Ihren Anforderungen am besten entspricht. Denken Sie daran, je niedriger die Anzahl, desto niedriger die Kosten und desto geringer das read/write Volumen, das vom Cluster verwaltet werden kann.
![\[Konfigurationsoberfläche mit Standardwerten für Cluster-ID, Engine-Version und Instanzklasse, wobei die Anzahl der Instanzen auf eins festgelegt ist.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/create-cluster/instance-config.png)
1. Behalten Sie für **Konnektivität** die Standardeinstellung „**Keine Verbindung zu einer EC2-Rechenressource** herstellen“ bei.
**Anmerkung**
Wenn Sie eine Verbindung zu einer EC2-Rechenressource herstellen, werden automatisch Sicherheitsgruppen für Ihre Verbindung zu Ihrem Cluster erstellt. Da Sie diese Sicherheitsgruppen im vorherigen Schritt manuell erstellt haben, sollten Sie „**Keine Verbindung zu einer EC2-Rechenressource** herstellen“ auswählen, um keinen zweiten Satz von Sicherheitsgruppen zu erstellen.
1. Geben Sie im Abschnitt **Authentifizierung** einen Benutzernamen für den Hauptbenutzer ein und wählen Sie dann **Selbstverwaltet** aus. Geben Sie ein Passwort ein und bestätigen Sie es.
Wenn Sie stattdessen **Verwaltet in** wählen AWS Secrets Manager, finden Sie [Passwortverwaltung mit Amazon DocumentDB und AWS Secrets Manager](docdb-secrets-manager.md) weitere Informationen unter.
1. Wählen Sie **Cluster erstellen**.
## Schritt 4: Connect zu Ihrer Amazon EC2 EC2-Instance her
Wenn Sie eine Verbindung zu Ihrer Amazon EC2 EC2-Instance herstellen, können Sie die MongoDB-Shell installieren. Durch die Installation der Mongo-Shell können Sie eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herstellen und ihn abfragen. Führen Sie folgende Schritte aus:
1. Navigieren Sie auf der Amazon EC2 EC2-Konsole zu Ihren Instances und überprüfen Sie, ob die gerade erstellte Instance läuft. Wenn ja, wählen Sie die Instance aus, indem Sie auf die Instance-ID klicken.
![\[Instance-Tabelle mit zwei Instances auf der Amazon EC2 EC2-Konsole.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/ec2-instance-table.png)
1. Wählen Sie **Connect** aus.
![\[Instanzzusammenfassung für eine Amazon EC2 EC2-Instance. Die Schaltfläche Connect befindet sich in der oberen rechten Ecke.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/ec2-instance-summary.png)
1. Es gibt vier Optionen mit Registerkarten für Ihre Verbindungsmethode: Amazon EC2 Instance Connect, Session Manager, SSH-Client oder serielle EC2-Konsole. Sie müssen eine auswählen und deren Anweisungen befolgen. Wenn Sie fertig sind, wählen Sie **Connect**.
![\[Schnittstelle mit Konfigurationsoptionen für die EC2 Instance Connect-Verbindungsmethode.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/ec2/connect-options.png)
**Anmerkung**
Wenn sich Ihre IP-Adresse geändert hat, nachdem Sie diesen Walkthrough gestartet haben, oder wenn Sie zu einem späteren Zeitpunkt zu Ihrer Umgebung zurückkehren, müssen Sie Ihre `demoEC2` Sicherheitsgruppenregel für eingehenden Datenverkehr aktualisieren, um eingehenden Datenverkehr von Ihrer neuen API-Adresse aus zu ermöglichen.
## Schritt 5: Installieren Sie die MongoDB-Shell
Sie können jetzt die MongoDB-Shell installieren. Dabei handelt es sich um ein Befehlszeilenprogramm, mit dem Sie eine Verbindung herstellen und Ihren Amazon DocumentDB-Cluster abfragen können. Derzeit gibt es zwei Versionen der MongoDB-Shell: die neueste Version, Mongosh, und die vorherige Version, Mongo-Shell.
**Wichtig**
Es gibt eine bekannte Einschränkung bei Treibern von Node.js, die älter als Version 6.13.1 sind und die derzeit nicht von der IAM-Identitätsauthentifizierung für Amazon DocumentDB unterstützt werden. Die Treiber und Tools der Datei Node.js, die den Treiber Node.js verwenden (z. B. mongosh), müssen aktualisiert werden, sodass sie den Treiber Node.js der Version 6.13.1 oder höher verwenden.
Folgen Sie den nachstehenden Anweisungen, um die MongoDB-Shell für Ihr Betriebssystem zu installieren.
------
#### [ On Amazon Linux ]
**So installieren Sie die MongoDB-Shell auf Amazon Linux**
Wenn Sie IAM *nicht* verwenden und die neueste MongoDB-Shell (mongosh) verwenden möchten, um eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herzustellen, gehen Sie wie folgt vor:
1. Erstellen Sie die Repository-Datei. Führen Sie in der Befehlszeile Ihrer EC2-Instance, die Sie erstellt haben, den folgenden Befehl aus:
```
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. Wenn der Vorgang abgeschlossen ist, installieren Sie mongosh mit einer der beiden folgenden Befehlsoptionen an der Befehlszeile:
**Option 1** — Wenn Sie während der Amazon EC2-Konfiguration das standardmäßige Amazon Linux 2023 ausgewählt haben, geben Sie diesen Befehl ein:
```
sudo yum install -y mongodb-mongosh-shared-openssl3
```
**Option 2** — Wenn Sie bei der Amazon EC2-Konfiguration Amazon Linux 2 ausgewählt haben, geben Sie diesen Befehl ein:
```
sudo yum install -y mongodb-mongosh
```
Wenn Sie IAM verwenden, müssen Sie die vorherige Version der MongoDB-Shell (5.0) verwenden, um eine Verbindung zu Ihrem Amazon DocumentDB-Cluster herzustellen. Gehen Sie wie folgt vor:
1. Erstellen Sie die Repository-Datei. Führen Sie in der Befehlszeile Ihrer EC2-Instance, die Sie erstellt haben, den folgenden Befehl aus:
```
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. Wenn der Vorgang abgeschlossen ist, installieren Sie die Mongodb 5.0-Shell mit der folgenden Befehlsoption an der Befehlszeile:
```
sudo yum install -y mongodb-org-shell
```
------
#### [ On Ubuntu ]
**Um mongosh auf Ubuntu zu installieren**
1. Importieren Sie den öffentlichen Schlüssel, der von dem Paketverwaltungssystem verwendet wird.
```
curl -fsSL https://pgp.mongodb.com/server-5.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-server-5.0.gpg
```
1. Erstellen Sie die Listendatei `mongodb-org-5.0.list` für MongoDB mit dem korrekten Befehl für Ihre Ubuntu-Version.
```
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. Importieren und aktualisieren Sie die lokale Paketdatenbank mit dem folgenden Befehl:
```
sudo apt-get update
```
1. Installieren Sie Mongosh.
```
sudo apt-get install -y mongodb-mongosh
```
Weitere Informationen zum Installieren von früheren Versionen von MongoDB auf Ihrem Ubuntu-System finden Sie unter [Installieren von MongoDB Community Edition auf Ubuntu](https://docs.mongodb.com/v3.6/tutorial/install-mongodb-on-ubuntu/).
------
#### [ On other operating systems ]
Informationen zum Installieren der mongo-Shell auf anderen Betriebssystemen finden Sie unter [Installieren von MongoDB Community Edition](https://www.mongodb.com/docs/manual/administration/install-community/) in der MongoDB-Dokumentation.
------
## Schritt 6: Amazon DocumentDB TLS verwalten
Laden Sie das CA-Zertifikat für Amazon DocumentDB mit dem folgenden Code herunter: `wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem`
**Anmerkung**
Transport Layer Security (TLS) ist standardmäßig für alle neuen Amazon DocumentDB-Cluster aktiviert. Weitere Informationen finden Sie unter [TLS-Einstellungen für Amazon DocumentDB-Cluster verwalten](https://docs.aws.amazon.com/documentdb/latest/developerguide/security.encryption.ssl.html).
## Schritt 7: Connect zu Ihrem Amazon DocumentDB-Cluster her
1. Suchen Sie auf der Amazon DocumentDB DocumentDB-Konsole unter **Clusters** Ihren Cluster. Wählen Sie den Cluster aus, den Sie erstellt haben, indem Sie auf die **Cluster-ID für diesen** Cluster klicken.
![\[Amazon DocumentDB-Clusterliste mit einem regionalen Cluster mit Details zur primären Instanz.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/cluster-connect-choose.png)
1. **Suchen Sie auf der Registerkarte **Konnektivität und Sicherheit** im Feld **Connect nach Connect to this cluster with the mongo shell**:**
![\[Cluster-Verbindungseinstellungen mit hervorgehobener MongoDB-Verbindungszeichenfolge für die Verbindung zu einem Amazon DocumentDB-Cluster mithilfe der Mongo-Shell.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/connect-mongosh.png)
Kopieren Sie die angegebene Verbindungszeichenfolge und fügen Sie sie in Ihr Terminal ein.
Nehmen Sie die folgenden Änderungen daran vor:
1. Stellen Sie sicher, dass Sie den richtigen Benutzernamen in der Zeichenfolge haben.
1. Auslassen, `` sodass Sie beim Herstellen der Verbindung von der Mongo-Shell zur Eingabe des Passworts aufgefordert werden.
1. Optional: Wenn Sie die IAM-Authentifizierung oder die vorherige Version der MongoDB-Shell verwenden, ändern Sie Ihre Verbindungszeichenfolge wie folgt:
`mongo --ssl --host mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1.docdb.amazonaws.com:27017 --sslCAFile global-bundle.pem --username SampleUser1 --password`
`mydocdbcluster.cluster-cozt4xr9xv9b.us-east-1`Ersetzen Sie durch dieselben Informationen aus Ihrem Cluster.
1. Drücken Sie die Eingabetaste in Ihrem Terminal. Sie werden nun zur Eingabe Ihres Passworts aufgefordert. Geben Sie Ihr Passwort ein.
1. Wenn Sie Ihr Passwort eingeben und die `rs0 [direct: primary] >` Aufforderung sehen, sind Sie erfolgreich mit Ihrem Amazon DocumentDB-Cluster verbunden.
Haben Sie Probleme mit der Verbindung? Weitere Informationen finden Sie unter [Fehlerbehebung bei Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/troubleshooting.html).
## Schritt 8: Daten einfügen und abfragen
Nachdem Sie nun mit Ihrem Cluster verbunden sind, können Sie einige Abfragen ausführen, um sich mit der Verwendung einer Dokumentendatenbank vertraut zu machen.
1. Um ein einzelnes Dokument einzufügen, geben Sie Folgendes ein:
```
db.collection.insertOne({"hello":"DocumentDB"})
```
Sie erhalten die folgende Ausgabe:
```
{
acknowledged: true,
insertedId: ObjectId('673657216bdf6258466b128c')
}
```
1. Sie können das Dokument lesen, das Sie mit dem `findOne()` Befehl geschrieben haben (weil er nur ein einziges Dokument zurückgibt). Geben Sie Folgendes ein:
```
db.collection.findOne()
```
Sie erhalten die folgende Ausgabe:
```
{ "_id" : ObjectId("5e401fe56056fda7321fbd67"), "hello" : "DocumentDB" }
```
1. Um ein paar weitere Abfragen durchzuführen, sollten Sie einen Anwendungsfall für Spieleprofile in Betracht ziehen. Fügen Sie zunächst einige Einträge in eine Sammlung mit dem Titel ein`profiles`. Geben Sie Folgendes ein:
```
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 }
])
```
Sie erhalten die folgende Ausgabe:
```
{ acknowledged: true, insertedIds: { '0': 1, '1': 2, '2': 3, '3': 4 } }
```
1. Verwenden Sie den `find()` Befehl, um alle Dokumente in der Profilsammlung zurückzugeben. Geben Sie Folgendes ein:
```
db.profiles.find()
```
Sie erhalten eine Ausgabe, die den Daten entspricht, die Sie in Schritt 3 eingegeben haben.
1. Verwenden Sie mithilfe eines Filters eine Abfrage für ein einzelnes Dokument. Geben Sie Folgendes ein:
```
db.profiles.find({name: "Katie"})
```
Sie erhalten die folgende Ausgabe:
```
{ "_id" : 4, "name" : "Katie", "status": "active", "level": 3, "score":27}
```
1. Versuchen wir nun, ein Profil zu finden und es mit dem `findAndModify` Befehl zu ändern. Wir geben dem Benutzer Matt zusätzliche 10 Punkte mit dem folgenden Code:
```
db.profiles.findAndModify({
query: { name: "Matt", status: "active"},
update: { $inc: { score: 10 } }
})
```
Sie erhalten die folgende Ausgabe (beachten Sie, dass sein Punktestand noch nicht gestiegen ist):
```
{
[{_id : 1, name : 'Matt', status: 'active', level: 12, score: 202}]
```
1. Sie können mit der folgenden Abfrage überprüfen, ob sich sein Punktestand geändert hat:
`db.profiles.find({name: "Matt"})`
Sie erhalten die folgende Ausgabe:
```
{ "_id" : 1, "name" : "Matt", "status" : "active", "level" : 12, "score" : 212 }
```
## Schritt 9: Erkunden
Herzlichen Glückwunsch\$1 Sie haben die Schnellstartanleitung für Amazon DocumentDB erfolgreich abgeschlossen.
Was kommt als Nächstes? Erfahren Sie, wie Sie diese leistungsstarke Datenbank mit einigen ihrer beliebten Funktionen voll ausschöpfen können:
+ [Amazon DocumentDB verwalten](https://docs.aws.amazon.com/documentdb/latest/developerguide/managing-documentdb.html)
+ [Skalierung](https://docs.aws.amazon.com/documentdb/latest/developerguide/operational_tasks.html)
+ [Sichern und Wiederherstellen](https://docs.aws.amazon.com/documentdb/latest/developerguide/backup_restore.html)
**Anmerkung**
Um Kosten zu sparen, können Sie entweder Ihren Amazon DocumentDB-Cluster stoppen, um die Kosten zu senken, oder den Cluster löschen. Standardmäßig stoppt Ihre AWS Cloud9 Umgebung nach 30 Minuten Inaktivität die zugrunde liegende Amazon EC2 EC2-Instance.
# Stellen Sie mithilfe des Amazon DocumentDB DocumentDB-JDBC-Treibers eine Verbindung her
Der JDBC-Treiber für Amazon DocumentDB bietet Entwicklern eine relationale SQL-Schnittstelle und ermöglicht die Konnektivität von BI-Tools wie Tableau und. DbVisualizer
Weitere Informationen finden Sie in der [Amazon DocumentDB DocumentDB-JDBC-Treiber-Dokumentation](https://github.com/aws/amazon-documentdb-jdbc-driver/blob/develop/src/markdown/index.md) unter. GitHub
**Topics**
+ [
## Erste Schritte
](#connect-jdbc-gettingstarted)
+ [
# Stellen Sie von Tableau Desktop aus eine Connect zu Amazon DocumentDB her
](connect-jdbc-tableau.md)
+ [
# Connect zu Amazon DocumentDB her von DbVisualizer
](connect-jdbc-DbVisualizer.md)
+ [
# Automatische JDBC-Schemagenerierung
](connect-jdbc-autoschemagen.md)
+ [
# SQL-Unterstützung und Einschränkungen
](connect-jdbc-sqlandlimits.md)
+ [
# Fehlerbehebung
](connect-jdbc-troubleshooting.md)
## Erste Schritte
**Schritt 1. Amazon DocumentDB-Cluster erstellen**
Wenn Sie keinen Amazon DocumentDB-Cluster erstellt haben, erstellen Sie einen anhand der Anweisungen im Abschnitt [Erste Schritte](https://docs.aws.amazon.com/documentdb/latest/developerguide/get-started-guide.html) im Amazon DocumentDB DocumentDB-Entwicklerhandbuch.
Amazon DocumentDB ist ein reiner Virtual Private Cloud (VPC) -Service. Wenn Sie eine Verbindung von einem lokalen Computer außerhalb der VPC des Clusters herstellen, müssen Sie eine SSH-Verbindung zu einer Amazon EC2 EC2-Instance herstellen. Starten Sie in diesem Fall Ihren Cluster anhand der Anweisungen unter [Connect with EC2](https://docs.aws.amazon.com/documentdb/latest/developerguide/connect-ec2.html). Weitere Informationen [zum SSH-Tunneling und wann Sie es möglicherweise benötigen, finden Sie unter Verwenden eines SSH-Tunnels zum Herstellen einer Connect zu 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).
**Schritt 2. JRE- oder JDK-Installation**
Abhängig von Ihrer BI-Anwendung müssen Sie möglicherweise sicherstellen, dass eine 64-Bit-JRE- oder JDK-Installationsversion 8 oder höher auf Ihrem Computer installiert ist. [Sie können das Java SE Runtime Environment 8 hier herunterladen.](https://www.oracle.com/ca-en/java/technologies/javase-jre8-downloads.html)
**Schritt 3. Laden Sie den DocumentDB JDBC-Treiber herunter**
[Laden Sie den DocumentDB-JDBC-Treiber von hier herunter.](https://github.com/aws/amazon-documentdb-jdbc-driver/releases) Der Treiber ist als einzelne JAR-Datei verpackt (z. B. documentdb-jdbc-1.0.0-all.jar).
**Schritt 4. Verwenden eines SSH-Tunnels zum Connect zu Amazon DocumentDB**
Amazon DocumentDB-Cluster (mit MongoDB-Kompatibilität) werden in einer Amazon Virtual Private Cloud (Amazon VPC) bereitgestellt. Auf sie kann direkt von Amazon EC2 EC2-Instances oder anderen AWS Services zugegriffen werden, die in derselben Amazon VPC bereitgestellt werden. Darüber hinaus können EC2a Instances oder andere AWS Services VPCs in verschiedenen Regionen derselben AWS Region oder anderen Regionen über VPC-Peering auf Amazon DocumentDB zugreifen.
Sie können SSH-Tunneling (auch bekannt als Portweiterleitung) verwenden, um von außerhalb der VPC des Clusters auf Ihre Amazon DocumentDB DocumentDB-Ressourcen zuzugreifen. Dies wird bei den meisten Benutzern der Fall sein, die ihre Anwendung nicht auf einer VM in derselben VPC wie der DocumentDB-Cluster ausführen.
Um einen SSH-Tunnel zu erstellen, benötigen Sie eine Amazon EC2 EC2-Instance, die in derselben Amazon VPC wie Ihr Amazon DocumentDB-Cluster läuft. Sie können entweder eine vorhandene EC2-Instance in derselben VPC wie Ihr Cluster verwenden oder eine erstellen. Sie können einen SSH-Tunnel zum Amazon DocumentDB-Cluster einrichten, `sample-cluster.node.us-east-1.docdb.amazonaws.com` indem Sie den folgenden Befehl auf Ihrem lokalen Computer ausführen.
```
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
```
Das Flag -L wird für die Weiterleitung eines lokalen Ports verwendet. Dies ist eine Voraussetzung für die Verbindung zu einem BI-Tool, das auf einem Client außerhalb Ihrer VPC ausgeführt wird. Sobald Sie den obigen Schritt ausgeführt haben, können Sie mit den nächsten Schritten für das BI-Tool Ihrer Wahl fortfahren.
Weitere Informationen zum SSH-Tunneling finden Sie in der Dokumentation zum Herstellen einer [Verbindung mit Amazon DocumentDB über einen SSH-Tunnel.](https://github.com/aws/amazon-documentdb-jdbc-driver/blob/develop/src/markdown/setup/setup.md#using-an-ssh-tunnel-to-connect-to-amazon-documentdb )
# Stellen Sie von Tableau Desktop aus eine Connect zu Amazon DocumentDB her
**Topics**
+ [
## Hinzufügen des Amazon DocumentDB DocumentDB-JDBC-Treibers
](#connect-jdbc-tableau-adddriver)
+ [
## Mit Tableau eine Verbindung zu Amazon DocumentDB herstellen — SSH-Tunnel
](#connect-jdbc-tableau-ssh)
## Hinzufügen des Amazon DocumentDB DocumentDB-JDBC-Treibers
Um von Tableau Desktop aus eine Verbindung zu Amazon DocumentDB herzustellen, müssen Sie den Amazon DocumentDB DocumentDB-JDBC-Treiber und den DocumentDB-Tableau-Connector herunterladen und installieren.
1. Laden Sie die JAR-Datei des Amazon DocumentDB DocumentDB-JDBC-Treibers aus dem [Amazon DocumentDB DocumentDB-JDBC-Treiber-Repository](https://github.com/aws/amazon-documentdb-jdbc-driver/releases) herunter und kopieren Sie sie je nach Betriebssystem in eines der folgenden Verzeichnisse:
+ *Windows -* `C:\Program Files\Tableau\Drivers`
+ *macOS* - `~/Library/Tableau/Drivers`
1. Laden Sie den DocumentDB Tableau-Connector (eine TACO-Datei) von der [Tableau Exchange-Website](https://exchange.tableau.com/products/821) herunter und kopieren Sie ihn in Ihr *My Repository/Connectors Tableau-Verzeichnis*.
+ *Windows -* `C:\Users\[user]\Documents\My Tableau Repository\Connectors`
+ *macOS* - `/Users/[user]/Documents/My Tableau Repository/Connectors`
Weitere Informationen finden Sie in der [Tableau-Dokumentation](https://tableau.github.io/connector-plugin-sdk/docs/run-taco).
**Anmerkung**
Wenn Sie neuere CA-Zertifikate verwenden, stellen Sie sicher, dass Sie Ihren JDBC-Treiber auf Version 1.4.5 aktualisieren (in diesem AWS [GitHub Repository](https://github.com/aws/amazon-documentdb-jdbc-driver/releases/tag/v1.4.5) verfügbar).
## Mit Tableau eine Verbindung zu Amazon DocumentDB herstellen — SSH-Tunnel
Um von einem Client-Computer außerhalb der VPC Ihres DocumentDB-Clusters aus eine Verbindung zu Tableau herzustellen, müssen Sie einen SSH-Tunnel einrichten, bevor Sie die folgenden Schritte ausführen:
1. Starten Sie die Tableau Desktop-Anwendung.
1. Navigieren Sie zu **Connect** > **Zu einem Server** > **Mehr**.
1. Wählen Sie unter **Installierte Konnektoren** die Option **Amazon DocumentDB by Amazon Web Services** aus.
![\[Die Connect-Oberfläche auf Tableau Desktop zeigt das Untermenü Mehr... im Abschnitt Zu einem Server. Die Option Amazon DocumentDB ist im Untermenü Installed Connectors hervorgehoben.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/tableau-choose-docdb.png)
**Herstellen einer Verbindung zu Amazon DocumentDB mithilfe von Tableau — Externer SSH-Tunnel**
1. **Geben Sie die erforderlichen Verbindungsparameter **Hostname**, **Port**, **Datenbank**, **Benutzername** und Passwort ein.** Die Verbindungsparameter im folgenden Beispiel entsprechen der JDBC-Verbindungszeichenfolge:
`jdbc:documentdb://localhost:27019/test? tls=true&tlsAllowInvalidHostnames=true&scanMethod=random&scanLimit=1000&loginTimeoutSec=0&readPreference=primary&retryReads=true&schemaName=_default`wobei die Parameter Benutzername und Passwort separat in einer Eigenschaftensammlung übergeben werden. Weitere Informationen zu Verbindungszeichenfolgenparametern finden Sie in der Github-Dokumentation des [Amazon DocumentDB DocumentDB-JDBC-Treibers](https://github.com/aws/amazon-documentdb-jdbc-driver/blob/develop/src/markdown/setup/connection-string.md).
![\[Registerkarte „Allgemein“ in der Amazon DocumentDB DocumentDB-Konnektorschnittstelle mit Feldern für Hostname, Port, Datenbank, Benutzername und Passwort.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/tableau-connect.png)
1. (Optional) Weitere erweiterte Optionen finden Sie auf der Registerkarte **Erweitert**.
![\[Registerkarte „Erweitert“ in der Amazon DocumentDB DocumentDB-Konnektorschnittstelle mit zusätzlichen Verbindungsoptionen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/tableau-advanced.png)
1. Klicken Sie auf **Sign in**.
**Mit Tableau eine Verbindung zu Amazon DocumentDB herstellen — Interner SSH-Tunnel**
**Anmerkung**
Wenn Sie es vorziehen, den SSH-Tunnel nicht über ein Terminal einzurichten, können Sie die Tableau-GUI verwenden, um Ihre EC2-Instanzdetails anzugeben, die der JDBC-Treiber standardmäßig zur Erstellung eines SSH-Tunnels verwenden wird.
1. Wählen Sie auf der Registerkarte **Erweitert** die Option **SSH-Tunnel aktivieren** aus, um weitere Eigenschaften zu überprüfen.
![\[Registerkarte „Erweitert“ in der Amazon DocumentDB DocumentDB-Connector-Schnittstelle, wobei „SSH-Tunnel aktivieren“ ausgewählt ist und zusätzliche SSH-Eingabefelder angezeigt werden.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/tableau-advanced-Enablessh.png)
1. **Geben Sie den **SSH-Benutzer, den SSH-Hostnamen** **und die private SSH-Schlüsseldatei ein**.**
1. (Optional) Sie können die Option **SSH Strict Host Key Check deaktivieren, wodurch die Überprüfung des Hostschlüssels** anhand einer Datei mit bekannten Hosts umgangen wird.
**Anmerkung**
Die Deaktivierung dieser Option ist weniger sicher, da sie zu einem Angriff führen kann. [man-in-the-middle](https://en.wikipedia.org/wiki/Man-in-the-middle_attack)
![\[Registerkarte „Erweitert“ in der Amazon DocumentDB DocumentDB-Konnektorschnittstelle mit deaktivierter Option „SSH Strict Host Key Check“.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/tableau-advanced-sshhostkeycheck.png)
1. **Geben Sie die erforderlichen Parameter ein: **Hostname**, **Port**, **Datenbank**, **Benutzername und Passwort**.**
**Anmerkung**
Stellen Sie sicher, dass Sie den DocumentDB-Clusterendpunkt und nicht localhost verwenden, wenn Sie die interne SSH-Tunneloption verwenden.
![\[Registerkarte „Allgemein“ in der Amazon DocumentDB DocumentDB-Konnektorschnittstelle mit Feldern für Hostname, Port, Datenbank, Benutzername und Passwort.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/tableau-hostname.png)
1. Klicken Sie auf **Sign In**.
# Connect zu Amazon DocumentDB her von DbVisualizer
**Topics**
+ [
## Hinzufügen des Amazon DocumentDB DocumentDB-JDBC-Treibers
](#connect-jdbc-DbVisualizer-adddriver)
+ [
## Verbindung zu Amazon DocumentDB herstellen mit DbVisualizer
](#connect-jdbc-DbVisualizer-connect)
## Hinzufügen des Amazon DocumentDB DocumentDB-JDBC-Treibers
Um eine Verbindung zu Amazon DocumentDB herzustellen, müssen DbVisualizer Sie zuerst den Amazon DocumentDB DocumentDB-JDBC-Treiber importieren.
1. Starten Sie die DbVisualizer Anwendung und navigieren Sie zum Menüpfad: **Tools** > Driver Manager...
1. Wählen Sie **\$1** (oder wählen Sie im Menü **Treiber > Treiber erstellen**).
1. Legen Sie **Name** auf `DocumentDB` fest.
1. Stellen Sie das **URL-Format ein** auf `jdbc:documentdb://[:port]/[?option=value[&option=value[...]]]`
1. **Wählen Sie die **Ordnerschaltfläche** und dann die JAR-Datei des Amazon DocumentDB DocumentDB-JDBC-Treibers aus und klicken Sie auf die Schaltfläche Öffnen.**
1. Stellen Sie sicher, dass das Feld **Treiberklasse** auf eingestellt ist. `software.amazon.documentdb.jdbc.DocumentDbDriver` Ihre Driver Manager-Einstellungen für **DocumentDB** sollten wie im folgenden Beispiel aussehen.
![\[Die Treibereinstellungen-Schnittstelle enthält den DbVisualizer eingegebenen Amazon DocumentDB DocumentDB-Namen, das URL-Format und die Treiberklassenkonfigurationen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/DbVisualizer-adddriver.jpg)
1. Schließen Sie das Dialogfeld. Der Amazon DocumentDB DocumentDB-JDBC-Treiber wird eingerichtet und ist einsatzbereit.
## Verbindung zu Amazon DocumentDB herstellen mit DbVisualizer
Stellen Sie mithilfe von Amazon DocumentDB eine Connect DbVisualizer
1. Wenn Sie von außerhalb der VPC des Amazon DocumentDB-Clusters eine Verbindung herstellen, stellen Sie sicher, dass Sie einen SSH-Tunnel eingerichtet haben.
1. Wählen Sie im Menü der obersten **Ebene Datenbank > Datenbankverbindung erstellen**.
1. Geben Sie einen aussagekräftigen Namen für das Feld „**Name**“ ein.
1. Stellen Sie **Driver (JDBC)** auf den DocumentDB-Treiber ein, den Sie im vorherigen Abschnitt erstellt haben.
1. Stellen Sie die **Datenbank-URL** auf Ihre JDBC-Verbindungszeichenfolge ein.
Beispiel: `jdbc:documentdb://localhost:27017/database?tlsAllowInvalidHostnames=true`
1. Setzen Sie **Database Userid** auf Ihre Amazon DocumentDB DocumentDB-Benutzer-ID.
1. Stellen Sie **das Datenbankpasswort** auf das entsprechende Passwort für die Benutzer-ID ein.
Ihr Datenbankverbindungsdialog sollte wie der folgende Dialog aussehen:
![\[Datenbankverbindungsschnittstelle mit DocumentDB-Einstellungen.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/jdbc/DbVisualizer-connect.jpg)
1. Wählen Sie **Connect** aus.
# Automatische JDBC-Schemagenerierung
Amazon DocumentDB ist eine Dokumentendatenbank und hat daher nicht das Konzept von Tabellen und Schemas. BI-Tools wie Tableau erwarten jedoch, dass die Datenbank, mit der sie eine Verbindung herstellen, ein Schema darstellt. Insbesondere wenn die JDBC-Treiberverbindung das Schema für die Sammlung in der Datenbank abrufen muss, fragt sie nach allen Sammlungen in der Datenbank ab. Der Treiber ermittelt, ob bereits eine zwischengespeicherte Version des Schemas für diese Sammlung vorhanden ist. Wenn keine zwischengespeicherte Version vorhanden ist, wird anhand der Sammlung nach Dokumenten gesucht und ein Schema erstellt, das auf dem folgenden Verhalten basiert.
**Topics**
+ [
## Einschränkungen bei der Schemagenerierung
](#connect-jdbc-autoschemagen-limits)
+ [
## Optionen für die Scanmethode
](#connect-jdbc-autoschemagen-scanningoptions)
+ [
## Amazon-DocumentDB-Datentypen
](#connect-jdbc-autoschemagen-datatypes)
+ [
## Zuordnung skalarer Dokumentfelder
](#connect-jdbc-autoschemagen-scalarfields)
+ [
## Behandlung von Objekt- und Array-Datentypen
](#connect-jdbc-autoschemagen-objectandarray)
## Einschränkungen bei der Schemagenerierung
Der DocumentDB-JDBC-Treiber begrenzt die Länge von Bezeichnern auf 128 Zeichen. Der Schema-Generator kann die Länge der generierten Bezeichner (Tabellennamen und Spaltennamen) kürzen, um sicherzustellen, dass sie dieser Grenze entsprechen.
## Optionen für die Scanmethode
Das Sampling-Verhalten kann mithilfe von Verbindungszeichenfolgen- oder Datenquellenoptionen geändert werden.
+ *ScanMethod=*