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.
# Migration zu Amazon DocumentDB
Amazon DocumentDB ist ein vollständig verwalteter Datenbankservice, der mit der MongoDB-API kompatibel ist. Sie können Ihre Daten von MongoDB-Datenbanken, die lokal oder auf Amazon Elastic Compute Cloud (Amazon EC2) laufen, nach Amazon DocumentDB migrieren, indem Sie den in diesem Abschnitt beschriebenen Prozess verwenden.
**Topics**
+ [Schnellstart-Anleitung](migration-quick-start.md)
+ [Runbook zur Migration](docdb-migration-runbook.md)
+ [Migration von Couchbase Server](migration-from-couchbase.md)
# Migrieren Sie mit dem AWS Database Migration Service (DMS) zu Amazon DocumentDB: Schnellstartanleitung
**Topics**
+ [Bereiten Sie die DMS-Quelle vor](#migrate-qs-dma-source)
+ [DMS einrichten](#migrate-qs-dms-setup)
+ [DocumentDB-Komprimierung aktivieren](#migrate-qs-comp)
+ [Erstellen Sie eine Replikationsaufgabe](#migrate-qs-create)
+ [Überwachen des Fortschritts](#migrate-qs-monitor)
+ [Zusätzliche Informationen](#migrate-qs-info)
## Bereiten Sie die DMS-Quelle vor
Weitere Informationen finden Sie unter [Change-Streams aktivieren](change_streams.md#change_streams-enabling) So aktivieren Sie DocumentDB-Change-Streams oder aktivieren den MongoDB-Oplog zur Unterstützung von DMS Change Data Capture (CDC).
+ Die DMS-Quelle muss alle laufenden Änderungen beibehalten, bis der DMS-Vollladevorgang für alle enthaltenen Sammlungen abgeschlossen ist.
+ DocumentDB-Change-Streams sind zeitbasiert. Stellen Sie sicher, dass Ihre `change_stream_log_retention_duration` Einstellung groß genug ist, um die Zeit bis zum vollständigen Laden abzudecken.
+ Der MongoDB-Oplog hat eine feste Größe. Stellen Sie sicher, dass es so dimensioniert ist, dass es alle Operationen unter Volllast aufnehmen kann.
## DMS einrichten
Erstellen Sie DMS-Instanz-, Quell- und Zielendpunkte und testen Sie jeden Endpunkt.
## DocumentDB-Komprimierung aktivieren
Aktivieren Sie die Komprimierung, indem Sie eine benutzerdefinierte Parametergruppe an Ihren DocumentDB-Cluster anhängen und den Parameter default\$1collection\$1compression auf aktiviert aktualisieren. Weitere Informationen finden Sie unter [Verwaltung der Dokumentenkomprimierung auf Sammlungsebene](doc-compression.md).
## Erstellen Sie eine Replikationsaufgabe
1. **Wählen Sie in der DMS-Konsole im Navigationsbereich **Migrieren oder replizieren** und dann Aufgaben aus.**
1. Wählen Sie **Create task** aus.
1. Gehen Sie auf der Seite **Aufgabe erstellen** im Abschnitt **Aufgabenkonfiguration** wie folgt vor:
+ Geben Sie eine eindeutige und aussagekräftige **Task-ID** ein (z. B. "mongodb-docdb-replication„).
+ Wählen Sie den Quellendpunkt, den Sie zuvor erstellt haben, im Dropdownmenü **Quelldatenbank-Endpunkt** aus.
+ Wählen Sie den Zielendpunkt, den Sie zuvor erstellt haben, im Dropdownmenü **Zieldatenbank-Endpunkt** aus.
+ Wählen Sie als **Aufgabentyp** die Option **Migrieren und replizieren** aus.
1. Gehen Sie im Abschnitt **Einstellungen** wie folgt vor:
+ **Aktivieren Sie für **Task-Protokolle** das Kästchen CloudWatch Protokolle aktivieren.**
+ Wählen Sie für den **Bearbeitungsmodus** (oben im Abschnitt) die Option **JSON-Editor** und legen Sie die folgenden Attribute fest:
+ Stellen Sie `ParallelApplyThreads` den Wert auf 5 (unter`TargetMetadata`) ein. Dies ermöglicht \$11000 insert/update/delete Operationen pro Sekunde in CDC.
+ Auf 16 (unter`FullLoadSettings`) eingestellt`MaxFullLoadSubTasks`. Erwägen Sie, diesen Wert je nach Größe Ihrer Instanz zu erhöhen.
+ Für große Sammlungen (über 100 GB) aktivieren Sie die automatische Partition (unter Table Mapping und unter dem `parallel-load` Attribut):
+ „Typ“: „auto Partitionen“
+ „„: 16 number-of-partitions
## Überwachen des Fortschritts
Verwenden Sie die AWS DMS Konsole oder erstellen Sie ein benutzerdefiniertes Dashboard ([Dashboarder-Tool](https://github.com/awslabs/amazon-documentdb-tools/tree/master/monitoring/docdb-dashboarder)), um die Migration zu verfolgen. Konzentrieren Sie sich auf die folgenden Kennzahlen:
+ **FullLoadThroughputBandwidthTarget**— Misst die Netzwerkbandbreite (in KB/Sekunde), die von DMS bei der Übertragung von Daten an die Zieldatenbank während der Volllastphase der Migration verwendet wird.
+ **CDCLatencyZiel** — Misst die Zeitverzögerung (in Sekunden) zwischen dem Zeitpunkt, an dem eine Änderung in der Quelldatenbank erfolgt, und dem Zeitpunkt, an dem diese Änderung auf die Zieldatenbank angewendet wird.
+ **CDCThroughputRowsTarget**— Misst die Anzahl der Zeilen pro Sekunde, die DMS während der laufenden Replikationsphase der Migration auf die Zieldatenbank anwendet.
## Zusätzliche Informationen
Weitere Informationen zu Amazon DocumentDB und AWS DMS finden Sie unter: Weitere Informationen finden Sie unter.
+ [Runbook zur Amazon DocumentDB-Migration](docdb-migration-runbook.md)
+ [Migration von MongoDB zu Amazon DocumentDB](https://docs.aws.amazon.com/dms/latest/sbs/chap-mongodb2documentdb.html)
# Runbook zur Amazon DocumentDB-Migration
Dieses Runbook bietet einen umfassenden Leitfaden für die Migration einer MongoDB-Datenbank zu Amazon DocumentDB mithilfe von AWS Database Migration Service (DMS). Es wurde entwickelt, um Datenbankadministratoren, Cloud-Techniker und Entwickler während der gesamten Migration zu unterstützen — von der ersten Entdeckung bis zur end-to-end Validierung nach der Migration.
Angesichts der Unterschiede in der Implementierung und den unterstützten Funktionen zwischen MongoDB und Amazon DocumentDB betont dieses Runbook einen strukturierten und systematischen Ansatz. Es beschreibt wichtige Bewertungen vor der Migration, hebt Kompatibilitätsaspekte hervor und beschreibt detailliert die wichtigsten Aufgaben, die erforderlich sind, um eine erfolgreiche Migration mit minimalen Unterbrechungen sicherzustellen.
Das Runbook ist in die folgenden Themen gegliedert:
+ **[Kompatibilität](#mig-runbook-compatibility)**— Machen Sie sich mit den unterstützten MongoDB-Funktionen und Datentypen in Amazon DocumentDB vertraut und identifizieren Sie potenzielle Inkompatibilitäten.
+ **[Workload-Erkennung](#mig-runbook-workload)**— Analysieren Sie bestehende MongoDB-Workloads, einschließlich read/write Muster, Datenvolumen und Leistungsbasislinien.
+ **[Index-Migration](#mig-runbook-index)**— Analysieren Sie Strategien zum Extrahieren und Transformieren von MongoDB-Indizes für eine optimale Leistung in Amazon DocumentDB.
+ **[Benutzermigration](#mig-runbook-user)**— Erläutern Sie den Ansatz für die Migration von Datenbankbenutzern, Rollen und Zugriffskontrollen zu Amazon DocumentDB.
+ **[Datenmigrationen](#mig-runbook-data)**— Erläutern Sie verschiedene Methoden zur Datenmigration AWS DMS, einschließlich Volllast und Erfassung von Änderungsdaten (CDC).
+ **[Überwachen](#mig-runbook-monitoring)**— Erläutern Sie die verschiedenen Überwachungsansätze bei der Migration mithilfe von DMS oder systemeigenen Tools.
+ **[Validierung](#mig-runbook-validation)**— Bereitstellung von Verfahren für Datenintegritätsprüfungen, Funktionsvalidierung und Leistungsvergleiche nach der Migration.
Wenn Teams die Anleitungen in diesem Runbook befolgen, können sie einen reibungslosen, sicheren und effizienten Übergang zu Amazon DocumentDB sicherstellen und gleichzeitig die Anwendungsfunktionalität beibehalten und Risiken minimieren.
## Kompatibilität
**Topics**
+ [Kompatibilität der Kernfunktionen](#w2aac23b9c13c13)
+ [Tool zur Bewertung der Kompatibilität mit Amazon DocumentDB](#w2aac23b9c13c15)
Bei der Migration von MongoDB zu Amazon DocumentDB sind eine gründliche Erstbeurteilung und Funktionskompatibilitätsprüfung für eine erfolgreiche Migration unerlässlich. Dieser Prozess beginnt mit einer umfassenden Bestandsaufnahme Ihrer MongoDB-Funktionen, einschließlich Aggregationspipeline-Operatoren, Abfragemustern, Indizes und Datenmodellen.
Da Amazon DocumentDB mit den MongoDB-APIs 3.6, 4.0, 5.0 und 8.0 kompatibel ist, müssen Anwendungen, die neuere MongoDB-spezifische Funktionen verwenden, möglicherweise umgestaltet werden. Zu den kritischen Bereichen, die bewertet werden müssen, gehören Sharding-Mechanismen (Amazon DocumentDB verwendet einen anderen Ansatz), Transaktionsimplementierungen, Change-Stream-Funktionen und Indextypen (insbesondere Sparse-Indizes und partielle Indizes).
Auch die Leistungsmerkmale unterscheiden sich, da Amazon DocumentDB für Unternehmens-Workloads mit vorhersehbarer Leistung optimiert ist. Beim Testen sollten repräsentative Workloads auf beiden Systemen ausgeführt werden, um Abfragemuster zu identifizieren, die möglicherweise optimiert werden müssen.
Während der Bewertungsphase ist es wichtig, die Ausführungspläne zu überwachen, um potenzielle Leistungslücken zu erkennen. Dies hilft bei der Erstellung eines klaren Migrationsplans, in dem notwendige Anwendungsänderungen identifiziert und realistische Zeitpläne für einen reibungslosen Übergang festgelegt werden.
### Kompatibilität der Kernfunktionen
#### Umfassende Funktionsunterstützung
+ **CRUD-Operationen** — Genießen Sie volle Unterstützung für alle grundlegenden Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge, einschließlich Bulk- und Abfrageoperatoren, wodurch eine nahtlose Anwendungskompatibilität gewährleistet wird.
+ **Umfangreiche Indizierungsfunktionen** — Nutzen Sie die umfassende Unterstützung für Einzelfeld-, Verbund-, TTL-, Teil-, Sparse- und 2dsphären-Indizes, um Ihre Abfrageleistung und Textindizes (Version 5) für textbasierte Suchvorgänge zu optimieren.
+ **Replikation auf Unternehmensebene** — Profitieren Sie von einem robusten automatischen Failover-Mechanismus mit Read Replicas für hervorragende Hochverfügbarkeit ohne Betriebsaufwand.
+ **Fortschrittliche Backup-Lösungen** — Mit dem automatisierten Backup-System mit Point-in-Time Recovery (PITR) und manuellen Snapshots auf Abruf zum Schutz Ihrer Daten können Sie sich darauf verlassen.
#### Verbesserte AWS— integrierte Funktionen
+ **Optimierte Aggregation** — Nutzen Sie die am häufigsten verwendeten Aggregationsstufen (`$match`,, `$group` `$sort``$project`, usw.) mit optimierter Leistung für Unternehmens-Workloads.
+ **Transaktionsunterstützung** — Implementieren Sie Transaktionen mit mehreren Dokumenten und mehreren Sammlungen, die sich perfekt für die meisten Anforderungen von Geschäftsanwendungen eignen.
+ **Datenverfolgung in Echtzeit** — Aktivieren Sie Change-Streams mit einem einfachen Befehl und verlängern Sie die Aufbewahrungsdauer von Change-Streams durch eine einfache Parametergruppeneinstellung für die Überwachung von Datenänderungen in Echtzeit.
+ **Ortsbezogene Dienste** — Implementieren Sie Geodatenanwendungen mit Unterstützung für `$geoNear` Operator- und 2dSphere-Indizes.
+ **Textsuchfunktionen** — Nutzen Sie die integrierte Textsuchfunktion für die Suche nach Inhalten.
#### Vorteile moderner Architektur
+ **Cloud-natives Design** — Genießen Sie eine AWS optimierte Architektur, die ältere Funktionen durch effizientere Aggregations-Pipeline-Operationen ersetzt. MapReduce
+ **Verbesserte Sicherheit** — Profitieren Sie von AWS Identity and Access Management (IAM), SCRAM-SHA-1, SCRAM-SHA-256, X.509-Zertifikatsauthentifizierung und passwortbasierter Authentifizierung.
+ **Vorhersehbare Leistung — Erleben Sie eine konsistente Leistung, die speziell für Unternehmens-Workloads optimiert wurde**.
Einen umfassenden Überblick über die Funktionen von Amazon DocumentDB finden Sie unter [Unterstützte MongoDB APIs, Operationen und Datentypen in Amazon DocumentDB](mongo-apis.md) und [Funktionale Unterschiede: Amazon DocumentDB und MongoDB](functional-differences.md) zur Maximierung des Potenzials Ihrer Datenbank.
Amazon DocumentDB unterstützt nicht alle von MongoDB angebotenen Indizes. Wir bieten ein kostenloses [Index-Tool](https://github.com/awslabs/amazon-documentdb-tools/blob/master/index-tool/README.md) zur Überprüfung der Kompatibilität. Wir empfehlen, das Indextool auszuführen, um die Inkompatibilität zu beurteilen und die Problemumgehungen entsprechend zu planen.
### Tool zur Bewertung der Kompatibilität mit Amazon DocumentDB
Das [MongoDB to Amazon DocumentDB Compatibility Tool ist ein Open-Source-Hilfsprogramm, das dabei hilft GitHub , die Kompatibilität](https://github.com/awslabs/amazon-documentdb-tools/blob/master/compat-tool/README.md) von MongoDB-Workloads mit Amazon DocumentDB zu bewerten, indem MongoDB-Protokolle oder Anwendungsquellcode analysiert werden.
**Schlüssel-Features**
+ Identifiziert MongoDB-API-Nutzungsmuster in Ihrem Workload
+ Weist vor der Migration auf mögliche Kompatibilitätsprobleme hin
+ Generiert detaillierte Kompatibilitätsberichte mit Empfehlungen
+ Als eigenständiges Hilfsprogramm verfügbar, das lokal ausgeführt werden kann
#### Bewertungsmethoden
**Protokollgestützte Bewertung**
+ Vorteile:
+ Erfasst das tatsächliche Laufzeitverhalten und Abfragemuster
+ Identifiziert reale Nutzungshäufigkeiten und Leistungsmerkmale
+ Erkennt dynamische Abfragen, die im Quellcode möglicherweise nicht sichtbar sind
+ Kein Zugriff auf den Quellcode der Anwendung erforderlich
+ Nachteile:
+ Erfordert Zugriff auf MongoDB-Protokolle mit aktivierter Profilerstellung
+ Erfasst nur Vorgänge, die während des Protokollierungszeitraums stattgefunden haben
+ Möglicherweise fehlen selten genutzte Funktionen oder saisonale Workloads
**Analyse des Quellcodes**
+ Vorteile:
+ Umfassende Abdeckung aller potenziellen MongoDB-Operationen in der Codebasis
+ Kann Probleme in selten ausgeführten Codepfaden identifizieren
+ Erkennt clientseitige Logik, die von Amazon DocumentDB DocumentDB-Unterschieden betroffen sein könnte
+ Sie müssen die Anwendung nicht ausführen, um die Bewertung durchzuführen
+ Nachteile:
+ Kann Code kennzeichnen, der zwar existiert, aber nie in der Produktion ausgeführt wird
+ Erfordert Zugriff auf den vollständigen Quellcode der Anwendung
+ Eingeschränkte Fähigkeit, dynamisch erstellte Abfragen zu analysieren
Um optimale Ergebnisse zu erzielen, empfehlen wir, wenn möglich beide Bewertungsmethoden zu verwenden, um sich vor der Migration ein vollständiges Bild der Kompatibilitätsprobleme zu machen.
## Workload-Erkennung
Die Migration von MongoDB zu Amazon DocumentDB erfordert ein gründliches Verständnis der bestehenden Datenbank-Arbeitslast. Bei der Workload-Erkennung werden Ihre Datenbanknutzungsmuster, Datenstrukturen, Abfrageleistung und Betriebsabhängigkeiten analysiert, um einen reibungslosen Übergang mit minimalen Unterbrechungen sicherzustellen. In diesem Abschnitt werden die wichtigsten Schritte beschrieben, die bei der Workload-Erkennung erforderlich sind, um eine effektive Migration von MongoDB zu Amazon DocumentDB zu ermöglichen.
**Topics**
+ [Bewertung der bestehenden MongoDB-Bereitstellung](#w2aac23b9c15b7)
+ [Identifizieren von Unterschieden im Datenmodell](#w2aac23b9c15b9)
+ [Abfrage- und Leistungsanalyse](#w2aac23b9c15c11)
+ [Überprüfung der Sicherheit und Zugriffskontrolle](#w2aac23b9c15c13)
+ [Überlegungen zum Betrieb und zur Überwachung](#w2aac23b9c15c15)
### Bewertung der bestehenden MongoDB-Bereitstellung
Vor der Migration ist es wichtig, die aktuelle MongoDB-Umgebung zu evaluieren, einschließlich:
+ **Cluster-Architektur** — Identifizieren Sie die Anzahl der Knoten, Replikatgruppen und Sharding-Konfigurationen. Bei der Migration von MongoDB zu Amazon DocumentDB ist es wichtig, Ihre MongoDB-Sharding-Konfiguration zu verstehen, da Amazon DocumentDB kein benutzergesteuertes Sharding unterstützt. Für Anwendungen, die für eine Shard-MongoDB-Umgebung entwickelt wurden, müssen architektonische Änderungen vorgenommen werden, da Amazon DocumentDB mit seiner speicherbasierten Architektur einen anderen Skalierungsansatz verwendet. Bei der Umstellung auf Amazon DocumentDB müssen Sie Ihre Datenverteilungsstrategie anpassen und möglicherweise gemeinsam genutzte Sammlungen konsolidieren.
+ **Speicher und Datenvolumen** — Messen Sie die Gesamtdatengröße und Indexgröße Ihres Clusters. Ergänzen Sie dies mit dem [Oplog-Überprüfungstool](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/mongodb-oplog-review), um Schreibmuster und die Geschwindigkeit des Datenwachstums zu verstehen. Weitere Informationen zur Dimensionierung Ihres Clusters finden Sie unter[Dimensionierung der Instanzen](best_practices.md#best_practices-instance_sizing).
+ **Workload-Muster** — Analysieren Sie den Lese- und Schreibdurchsatz, die Häufigkeit der Abfrageausführung und die Indexierungseffizienz.
+ **Betriebliche Abhängigkeiten** — Dokumentieren Sie alle Anwendungen, Dienste und Integrationen, die auf MongoDB basieren.
### Identifizieren von Unterschieden im Datenmodell
Obwohl Amazon DocumentDB MongoDB-kompatibel ist, gibt es Unterschiede bei den unterstützten Funktionen, wie z. B.:
+ **Transaktionen** — Amazon DocumentDB unterstützt ACID-Transaktionen, jedoch mit einigen[Einschränkungen](transactions.md#transactions-limitations).
+ **Schemadesign** — Stellen Sie sicher, dass Dokumentstrukturen, eingebettete Dokumente und Verweise den [Best Practices von Amazon DocumentDB](https://d1.awsstatic.com/product-marketing/Data%20modeling%20with%20Amazon%20DocumentDB.pdf) entsprechen.
### Abfrage- und Leistungsanalyse
Das Verständnis des Abfrageverhaltens hilft bei der Optimierung der Leistung bei der Migration und nach der Migration. Zu den wichtigsten zu analysierenden Bereichen gehören:
+ **Langsame Abfragen** — Identifizieren Sie Abfragen mit hoher Ausführungszeit mithilfe der Profiling-Tools von MongoDB.
+ **Abfragemuster** — Kategorisieren Sie gängige Abfragetypen, einschließlich CRUD-Operationen und -Aggregationen.
+ **Indexnutzung** — Beurteilen Sie, ob Indizes in Amazon DocumentDB effektiv genutzt werden oder optimiert werden müssen. Verwenden Sie die `$indexStats` Aggregationspipeline-Phase in Kombination mit der `explain()` Methode für Ihre kritischen Abfragen, um die Indexnutzung zu bewerten und die Leistung in Amazon DocumentDB zu optimieren. Beginnen Sie mit der Ausführung`db.collection.aggregate([{$indexStats{}}])`, um zu ermitteln, welche Indizes verwendet werden. Sie können detailliertere Analysen durchführen, indem Sie Ihre häufigsten Abfragen mit `explainPlan` ausführen.
+ **Parallelität und Verteilung der Arbeitslast** — Bewerten Sie Lese- und Schreibverhältnisse, Verbindungspooling und Leistungsengpässe.
### Überprüfung der Sicherheit und Zugriffskontrolle
**Authentifizierung und Autorisierung**
+ **MongoDB RBAC zu Amazon DocumentDB IAM und RBAC** — Ordnen Sie die rollenbasierten Zugriffskontrollbenutzer und Rollen von MongoDB AWS Identity and Access Management (IAM) -Richtlinien und Amazon DocumentDB SCRAM-Authentifizierungsbenutzern zu.
+ **Strategie zur Benutzermigration** — Planen Sie die Migration von Datenbankbenutzern, benutzerdefinierten Rollen und Rechten zu den von Amazon DocumentDB unterstützten Authentifizierungsmechanismen.
+ **Rechteunterschiede** — Identifizieren Sie MongoDB-Rechte ohne direkte Amazon DocumentDB DocumentDB-Entsprechungen (z. B. Clusterverwaltungsrollen).
+ **Anwendungsauthentifizierung** — Aktualisieren Sie die Verbindungszeichenfolgen und die Verwaltung der Anmeldeinformationen für die Passwortrichtlinien von Amazon DocumentDB. Sie können den Secrets Manager verwenden, um Ihre Anmeldeinformationen zu speichern und Passwörter zu wechseln.
+ **Verwaltung von Dienstkonten** — Richten Sie Prozesse für die Verwaltung der Anmeldeinformationen für Dienstkonten in ein AWS Secrets Manager.
+ **Implementierung der geringsten Rechte** — Überprüfen und verfeinern Sie die Zugriffskontrollen, um die Prinzipien der geringsten Rechte in der neuen Umgebung zu implementieren.
**Verschlüsselung**
Stellen Sie sicher, dass die Verschlüsselung im Ruhezustand und bei der Übertragung den Compliance-Anforderungen entspricht.
**Netzwerkkonfiguration**
Planen Sie die Einrichtung von [Virtual Private Cloud (VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc.html) und die Regeln für Sicherheitsgruppen.
### Überlegungen zum Betrieb und zur Überwachung
Um die Zuverlässigkeit des Systems zu gewährleisten, sollte die Workload-Erkennung auch Folgendes beinhalten:
+ **Backup- und Wiederherstellungsstrategie** — Evaluieren Sie bestehende Backup-Methoden und die Backup-Funktionen von Amazon DocumentDB.
+ **AWS Backup Integration** — Nutzen Sie das zentralisierte Backup-Management AWS Backup für alle AWS Dienste, einschließlich Amazon DocumentDB.
+ **CloudWatch Metriken** — Ordnen MongoDB MongoDB-Überwachungsmetriken Amazon CloudWatch DocumentDB-Metriken für CPU, Arbeitsspeicher, Verbindungen und Speicher zu.
+ **Performance Insights** — Implementieren Sie Amazon DocumentDB Performance Insights, um die Datenbanklast zu visualisieren und Leistungsprobleme mit detaillierten Abfrageanalysen zu analysieren.
+ **Profiler** — Konfigurieren Sie den Amazon DocumentDB DocumentDB-Profiler für die Erfassung langsam laufender Vorgänge (ähnlich dem Profiler von MongoDB, jedoch mit Amazon DocumentDB-spezifischen Einstellungen).
+ Die Aktivierung erfolgt über Parametergruppen mit entsprechenden Schwellenwerten.
+ Analysieren Sie Profiler-Daten, um Optimierungsmöglichkeiten zu identifizieren
+ **CloudWatch Ereignisse** — Richten Sie eine ereignisgesteuerte Überwachung für Amazon DocumentDB-Clusterereignisse ein.
+ Konfigurieren Sie Benachrichtigungen für Backup-Ereignisse, Wartungsfenster und Failover.
+ Integrieren Sie Amazon SNS für Benachrichtigungen und automatische AWS Lambda Antworten.
+ **Audit-Protokollierung** — Planen Sie die Konfiguration der Audit-Protokollierung ein, um Benutzeraktivitäten und sicherheitsrelevante Ereignisse nachzuverfolgen.
+ **Verbesserte Überwachung — Ermöglicht eine** erweiterte Überwachung detaillierter Messdaten auf Betriebssystemebene in Intervallen von 1 Sekunde.
## Index-Migration
Bei der Migration von MongoDB zu Amazon DocumentDB werden nicht nur Daten, sondern auch Indizes übertragen, um die Abfrageleistung aufrechtzuerhalten und den Datenbankbetrieb zu optimieren. In diesem Abschnitt wird der detaillierte step-by-step Prozess für die Migration von Indizes von MongoDB zu Amazon DocumentDB beschrieben, wobei Kompatibilität und Effizienz gewährleistet werden.
### Verwenden des Amazon DocumentDB DocumentDB-Indextools
**Klonen Sie das [Index-Tool](https://github.com/awslabs/amazon-documentdb-tools/blob/master/index-tool/README.md)**
```
git clone https://github.com/aws-samples/amazon-documentdb-tools.git
cd amazon-documentdb-tools/index-tool
```
```
pip install -r requirements.txt
```
**Indizes aus MongoDB exportieren (wenn Sie von MongoDB migrieren)**
```
python3 migrationtools/documentdb_index_tool.py --dump-indexes --dir mongodb_index_export --uri
'mongodb://localhost:27017'
```
**Indizes aus Amazon DocumentDB exportieren (wenn Sie von Amazon DocumentDB migrieren)**
```
python3 migrationtools/documentdb_index_tool.py --dump-indexes --dir docdb_index_export --uri
'mongodb://user:password@mydocdb.cluster-cdtjj00yfi95.eu-west-
2.docdb.amazonaws.com:27017/?tls=true&tlsCAFile=rds-combined-ca-
bundle.pem&replicaSet=rs0&retryWrites=false'
```
**Indizes importieren**
```
python3 migrationtools/documentdb_index_tool.py --restore-indexes --skip-incompatible --dir
mongodb_index_export --uri 'mongodb://user:password@mydocdb.cluster-cdtjj00yfi95.eu-west-
2.docdb.amazonaws.com:27017/?tls=true&tlsCAFile=rds-combined-ca-
bundle.pem&replicaSet=rs0&retryWrites=false'
```
**Überprüfen Sie die Indizes**
```
python3 migrationtools/documentdb_index_tool.py --show-issues --dir mongodb_index_export
```
## Benutzermigration
Die Migration von Benutzern von MongoDB zu Amazon DocumentDB ist für die Aufrechterhaltung der Zugriffskontrolle, Authentifizierung und Datenbanksicherheit unerlässlich. In diesem Abschnitt werden detaillierte Schritte zur erfolgreichen Migration von MongoDB-Benutzern unter Beibehaltung ihrer Rollen und Berechtigungen mithilfe des Amazon DocumentDB DocumentDB-Export-Benutzertools beschrieben.
### Verwenden des Amazon DocumentDB DocumentDB-Tools zum Exportieren von Benutzern
Der [https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/export-users](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/export-users)exportiert Benutzer und Rollen aus MongoDB oder Amazon DocumentDB in JavaScript Dateien, die dann verwendet werden können, um sie in einem anderen Cluster neu zu erstellen.
**Voraussetzungen**
```
# Clone the repository
git clone https://github.com/awslabs/amazon-documentdb-tools.git
cd amazon-documentdb-tools/migration/export-users
```
```
# Install required dependencies
pip install pymongo
```
**Schritt 1: Benutzer und Rollen exportieren**
```
# Export users and roles to JavaScript files
python3 docdbExportUsers.py \
--users-file mongodb-users.js \
--roles-file mongodb-roles.js \
--uri "mongodb://admin:password@source-host:27017/"
```
**Schritt 2: Bearbeiten Sie die Benutzerdatei**
```
// Example of how to update the users.js file
// Find each user creation statement and add the password
db.getSiblingDB("admin").createUser({
user: "appuser",
// Add password here
pwd: "newpassword",
roles: [
{ role: "readWrite", db: "mydb" }
]
})
```
**Schritt 3: Benutzerdefinierte Rollen in Amazon DocumentDB wiederherstellen**
```
# Import roles first
mongo --ssl \
--host target-host:27017 \
--sslCAFile rds-combined-ca-bundle.pem \
--username admin \
--password password \
mongodb-roles.js
```
**Schritt 4: Benutzer in Amazon DocumentDB wiederherstellen**
```
# Import users after roles are created
mongo --ssl \
--host target-host:27017 \
--sslCAFile rds-combined-ca-bundle.pem \
--username admin \
--password password \
mongodb-users.js
```
**Wichtige Hinweise**
+ Passwörter werden aus Sicherheitsgründen nicht exportiert und müssen manuell zur Datei users.js hinzugefügt werden.
+ Rollen müssen vor den Benutzern importiert werden, um eine korrekte Rollenzuweisung sicherzustellen.
+ Das Tool generiert JavaScript Dateien, die direkt mit der Mongo-Shell ausgeführt werden können.
+ Benutzerdefinierte Rollen und ihre Rechte bleiben während der Migration erhalten.
+ Dieser Ansatz ermöglicht die Überprüfung und Änderung der Benutzerberechtigungen vor dem Import.
Diese Methode bietet einen sicheren und flexiblen Ansatz für die Migration von Benutzern und Rollen von MongoDB zu Amazon DocumentDB und ermöglicht gleichzeitig das Zurücksetzen von Kennwörtern während des Migrationsprozesses.
## Datenmigrationen
**Topics**
+ [Online-Migration](#w2aac23b9c21b5)
+ [Offline-Migration](#w2aac23b9c21b7)
+ [Voraussetzungen](#w2aac23b9c21c11)
+ [Einen Amazon DocumentDB-Cluster vorbereiten](#w2aac23b9c21c13)
+ [Führen Sie den Datendump durch (Mongodump)](#w2aac23b9c21c15)
+ [Übertragen Sie Dumpdateien in die Wiederherstellungsumgebung](#w2aac23b9c21c17)
+ [Daten in Amazon DocumentDB wiederherstellen (mongorestore)](#w2aac23b9c21c19)
### Online-Migration
Dieser Abschnitt enthält detaillierte Schritte zur Durchführung einer Online-Migration von MongoDB zu Amazon DocumentDB, um minimale Ausfallzeiten und kontinuierliche Replikation AWS DMS zu ermöglichen. Zunächst richten Sie einen Amazon DocumentDB-Cluster als Ziel ein und stellen sicher, dass Ihre MongoDB-Instance ordnungsgemäß als Quelle konfiguriert ist. In der Regel ist für die Erfassung von Change Data Capture ein Replikat-Set-Modus erforderlich. Als Nächstes erstellen Sie eine DMS-Replikationsinstanz und definieren Quell- und Zielendpunkte mit den erforderlichen Verbindungsdetails. Nach der Validierung der Endpunkte konfigurieren und starten Sie eine Migrationsaufgabe, die das vollständige Laden von Daten, eine laufende Replikation oder beides umfassen kann.
#### Ziel konfigurieren (Amazon DocumentDB)
**Anmerkung**
Wenn Sie bereits einen Amazon DocumentDB-Cluster für die Migration bereitgestellt haben, können Sie diesen Schritt überspringen.
**Erstellen Sie eine benutzerdefinierte Parametergruppe**
Informationen zu den AWS-Managementkonsole AWS CLI Oder-Verfahren finden Sie unter[Amazon DocumentDB-Cluster-Parametergruppen erstellen](cluster_parameter_groups-create.md).
**Erstellen Sie einen Amazon DocumentDB-Cluster**
**Anmerkung**
In diesem Handbuch werden zwar weitere Verfahren zum Erstellen eines Amazon DocumentDB-Clusters beschrieben, die Schritte in diesem Abschnitt beziehen sich jedoch speziell auf die Aufgabe, große Datenmengen auf einen neuen Cluster zu migrieren.
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. Wählen Sie in der Amazon DocumentDB-Managementkonsole unter **Clusters** die Option **Create** aus.
1. Wählen Sie auf der Seite **Amazon DocumentDB-Cluster erstellen** im Abschnitt **Clustertyp** die Option **Instance-based cluster** (dies ist die Standardoption).
1. Gehen Sie im Abschnitt Cluster-Konfiguration wie folgt vor:
+ Geben Sie als **Cluster-ID** einen eindeutigen Namen ein, z. **mydocdbcluster** B. Beachten Sie, dass die Konsole alle Clusternamen unabhängig von der Art der Eingabe in Kleinbuchstaben ändert.
+ Wählen Sie für **Engine-Version 5.0.0** aus.
1. Lassen Sie im Abschnitt **Cluster-Speicherkonfiguration** die **Standardeinstellung von Amazon DocumentDB** unverändert (dies ist die Standardoption).
1. Gehen Sie im Abschnitt **Instanzkonfiguration wie folgt** vor:
+ Wählen Sie für **DB-Instance-Klasse** die Option **Speicheroptimierte Klassen (einschließlich R-Klassen)** aus (dies ist die Standardeinstellung).
+ Wählen Sie für **Instance-Klasse** eine Instance-Klasse aus, die auf der Arbeitslast basiert. Beispiel:
+ db.r6g.large: für kleinere Workloads
+ db.r6g.4xlarge: für größere Workloads
Als bewährte Methode empfehlen wir, eine möglichst große Instance zu wählen, um einen optimalen Durchsatz bei Volllast zu erzielen, und sie nach Abschluss der Migration herunterzuskalieren.
+ Wählen Sie für **Anzahl der Instanzen** die Option 1 Instanz aus. Die Auswahl einer Instanz trägt zur Kostenminimierung bei. Wir empfehlen, dass Sie nach Abschluss der Volllastmigration auf drei Instanzen skalieren, um eine hohe Verfügbarkeit zu gewährleisten.
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.
1. Wählen Sie im Abschnitt **Netzwerkeinstellungen** eine VPC- und Subnetzgruppe aus und konfigurieren Sie dann die VPC-Sicherheitsgruppe. Stellen Sie sicher, dass Ihre Amazon DocumentDB-Sicherheitsgruppe eingehende Verbindungen von der Sicherheitsgruppe der DMS-Instance zulässt, indem Sie die Regeln für eingehenden Datenverkehr aktualisieren.
1. Aktivieren Sie im ncryption-at-rest Abschnitt **E** die Verschlüsselung (empfohlen) und wählen Sie einen KMS-Schlüssel aus oder geben Sie ihn ein.
1. Stellen Sie im Abschnitt **Backup** die Aufbewahrungsfrist für Backups ein (1—35 Tage).
1. Überprüfen Sie Ihre Konfiguration und wählen Sie **Create cluster** aus.
Die Bereitstellungszeit beträgt in der Regel zwischen 10 und 15 Minuten.
#### Quelle konfigurieren
MongoDB und Amazon DocumentDB können je nach Szenario beide als Migrationsquellen dienen:
+ **MongoDB als Quelle** — Häufig bei der Migration von einer lokalen oder selbstverwalteten MongoDB zu einer Amazon DocumentDB oder anderen Datenbankdiensten. AWS Erfordert die Ausführung im Replikatgruppenmodus mit einem ausreichend dimensionierten Oplog (stellen Sie sicher, dass es so dimensioniert ist, dass es alle Operationen bei Volllast aufnehmen kann), um die Erfassung von Änderungsdaten während der Migration zu unterstützen.
+ **Amazon DocumentDB als Quelle** — Wird in der Regel für regionsübergreifende Replikation, Versions-Upgrades oder die Migration zu anderen Datenbankdiensten wie MongoDB Atlas verwendet. Erfordert[Change-Streams aktivieren](change_streams.md#change_streams-enabling), dass der `change_stream_log_retention_duration` Parameter in der Cluster-Parametergruppe festgelegt wird, um laufende Änderungen während der Migration zu erfassen. Stellen Sie sicher, dass Ihre `change_stream_log_retention_duration` Einstellung groß genug ist, um die Zeit abzudecken, die für den Vollladevorgang benötigt wird.
Bevor Sie mit der Migration beginnen, konfigurieren Sie Ihre Quelle so, dass der AWS DMS Zugriff möglich ist.
Erstellen Sie einen MongoDB-Benutzer mit den richtigen Berechtigungen:
```
db.createUser({
user: "dmsUser",
pwd: "yourSecurePassword",
roles: [{ role: "readAnyDatabase", db: "admin" }]
})
```
Konfigurieren Sie Netzwerk und Authentifizierung.
Gehen Sie bei der Konfiguration der Netzwerkkonnektivität für die Migration von MongoDB zu DMS wie folgt vor:
**Von EC2 gehostete MongoDB-Quelle**
+ Ändern Sie die EC2-Sicherheitsgruppe, um eingehenden Datenverkehr von der Sicherheitsgruppe der DMS-Replikationsinstanz zuzulassen.
+ Fügen Sie eine Regel für den TCP-Port 27017 (oder Ihren benutzerdefinierten MongoDB-Port) hinzu.
+ Verwenden Sie die Sicherheitsgruppen-ID der DMS-Replikationsinstanz als Quelle für eine präzise Zugriffskontrolle.
+ Stellen Sie sicher, dass das Subnetz der EC2-Instanz über eine Route zum Subnetz der DMS-Replikationsinstanz verfügt.
**On-Premises-MongoDB-Quelle**
+ Konfigurieren Sie Ihre Firewall so, dass eingehende Verbindungen von den öffentlichen IP-Adressen der DMS-Replikationsinstanz zugelassen werden.
+ Wenn Sie Direct Connect oder ein VPN verwenden, stellen Sie sicher, dass das Routing zwischen Ihrem Netzwerk und der VPC, die die DMS-Instanz enthält, ordnungsgemäß ist.
+ Testen Sie die Konnektivität mit Telnet- oder NC-Befehlen vom DMS-Subnetz zu Ihrem MongoDB-Server.
**MongoDB Atlas-Quelle**
+ Fügen Sie IP-Adressen einer DMS-Replikationsinstanz zur IP-Zulassungsliste von MongoDB Atlas hinzu.
+ Konfigurieren Sie VPC-Peering zwischen AWS VPC und MongoDB Atlas VPC, wenn Atlas auf läuft. AWS
+ AWS PrivateLink Richten Sie private Konnektivität (Enterprise-Stufe) ein, wenn die Ausführung auf einem anderen Cloud-Anbieter erfolgt.
+ Erstellen Sie einen dedizierten Benutzer mit entsprechenden read/write Berechtigungen.
+ Verwenden Sie eine MongoDB Atlas-Verbindungszeichenfolge, bei der der SSL-Modus auf „verify-full“ gesetzt ist.
+ Stellen Sie sicher, dass die Protokollgröße für die Dauer der Migration ausreichend ist.
**Amazon DocumentDB DocumentDB-Quelle**
Konfigurieren Sie Ihre Amazon DocumentDB DocumentDB-Quellsicherheitsgruppe so, dass eingehender Datenverkehr von der Sicherheitsgruppe der DMS-Replikationsinstanz zugelassen wird.
#### Erstellen Sie eine DMS-Replikationsinstanz
Wir empfehlen die Verwendung von [DMS Buddy](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/dms_buddy) für die Bereitstellung Ihrer DMS-Infrastruktur, da dadurch eine optimale Migrationsinfrastruktur mit optimalen DMS-Einstellungen und Instanzgrößen geschaffen wird.
Wenn Sie es vorziehen, manuell zu konfigurieren, gehen Sie wie folgt vor:
1. Öffnen Sie die AWS DMS-Konsole und wählen Sie **Create Replication instance**.
1. Geben Sie Details zur Replikationsinstanz ein:
+ **Instanzname**: Wählen Sie einen eindeutigen Namen.
+ **Instanzklasse**: Wählen Sie basierend auf der Arbeitslast aus. Beispiel: dms.r5.large (kleine Workloads), dms.r5.4xlarge (große Workloads).
+ Motorversion**:** 3.5.4
+ **Zugewiesener Speicher**: Die Standardeinstellung ist 100 GB (bei Bedarf erhöhen). Dies hängt von der Größe des Dokuments updates/second und der Dauer des vollen Ladevorgangs ab.
+ **Multi-AZ-Bereitstellung**: Aktivieren Sie diese Option für hohe Verfügbarkeit, falls erforderlich.
+ Wählen Sie dieselbe VPC wie Amazon DocumentDB.
+ Stellen Sie sicher, dass **Sicherheitsgruppen** eingehenden Datenverkehr von der Quelle und Amazon DocumentDB zulassen.
1. Klicken Sie auf **Replikationsinstanz erstellen** und warten Sie, bis der Status verfügbar ist.
#### DMS-Endpunkte erstellen
##### Erstellen Sie einen Quellendpunkt
**Für eine MongoDB-Quelle**
1. **Wählen Sie in der DMS-Konsole im Navigationsbereich **Migrieren oder Replizieren** und dann Endpoints aus.**
1. Wählen Sie **Endpunkt erstellen** aus.
1. **Wählen Sie auf der Seite **Endpunkt erstellen** die Option Quellendpunkt aus.**
1. Gehen Sie im Abschnitt **Endpunktkonfiguration** wie folgt vor:
+ Geben Sie eine eindeutige und aussagekräftige **Endpunkt-ID** ein (z. B. „mongodb-source“).
+ Wählen Sie **MongoDB** als **Quell-Engine**.
+ Wählen Sie für **Zugriff auf Endpunktdatenbank** die Option **Zugriffsinformationen manuell bereitstellen** aus.
+ Geben Sie als **Servername** Ihren *MongoDB server DNS name/IP address* ein.
+ Geben Sie für **Port** **27017** ein (Standard-MongoDB-Port).
+ Wählen Sie für den **Authentifizierungsmodus** den entsprechenden Modus für Ihre Anwendung (Passwort/SSL) aus (Standard ist Secrets Manager).
+ Wenn der **Authentifizierungsmodus** **Passwort** ist, geben Sie Folgendes an:
+ **Benutzername** und **Passwort**: Geben Sie MongoDB-Anmeldeinformationen ein.
+ **Datenbankname**: Ihr Quelldatenbankname.
+ **Authentifizierungsmechanismus**: SCRAM-SHA-1 (Standard) oder geeigneter Mechanismus
1. **Behalten Sie für **den Metadatenmodus** die Standardeinstellung Dokument bei.**
1. Zusätzliche Verbindungsattribute:
+ authSource=admin (wenn die Authentifizierungsdatenbank anders ist)
+ your-replica-set-namereplicaSet=< > (für CDC erforderlich)
**Für eine Amazon DocumentDB DocumentDB-Quelle**
1. **Wählen Sie in der DMS-Konsole im Navigationsbereich **Migrieren oder Replizieren** und dann Endpoints aus.**
1. Wählen Sie **Endpunkt erstellen** aus.
1. **Wählen Sie auf der Seite **Endpunkt erstellen** die Option Quellendpunkt aus.**
1. Gehen Sie im Abschnitt **Endpunktkonfiguration** wie folgt vor:
+ Geben Sie eine eindeutige und aussagekräftige **Endpunkt-ID** ein (z. B. „docdb-source“).
+ Wählen Sie **Amazon DocumentDB** als **Quell-Engine**.
+ Wählen Sie für **Zugriff auf Endpunktdatenbank** die Option **Zugriffsinformationen manuell bereitstellen** aus.
+ Geben Sie als **Servername** Ihren *source Amazon DocumentDB cluster endpoint* ein.
+ Geben Sie für **Port** **27017** ein (Standardport von Amazon DocumentDB).
+ Wählen Sie für **den SSL-Modus** **verify-full** (empfohlen für Amazon DocumentDB).
+ Wählen Sie für **CA Certificate** das Amazon RDS-Root-CA-Zertifikat aus.
+ Wählen Sie für den **Authentifizierungsmodus** den entsprechenden Modus für Ihre Anwendung (Passwort/SSL) (Standard ist Secrets Manager).
+ Wenn der **Authentifizierungsmodus** **Passwort** ist, geben Sie Folgendes an:
+ **Benutzername** und **Passwort**: Geben Sie Ihre Amazon DocumentDB DocumentDB-Anmeldeinformationen ein.
+ **Datenbankname**: Ihr Quelldatenbankname.
+ **Authentifizierungsmechanismus**: SCRAM-SHA-1 (Standard) oder geeigneter Mechanismus
1. **Behalten Sie für **den Metadatenmodus** die Standardeinstellung Dokument bei.**
##### Einen Zielendpunkt erstellen (Amazon DocumentDB)
1. **Wählen Sie in der DMS-Konsole im Navigationsbereich **Migrieren oder Replizieren** und anschließend Endpoints aus.**
1. Wählen Sie **Endpunkt erstellen** aus.
1. **Wählen Sie auf der Seite **Endpunkt erstellen** die Option Zielendpunkt aus.**
1. Gehen Sie im Abschnitt **Endpunktkonfiguration** wie folgt vor:
+ Geben Sie eine eindeutige und aussagekräftige **Endpunkt-ID** ein (z. B. „docdb-target“).
+ Wählen Sie **Amazon DocumentDB** als **Ziel-Engine**.
+ Wählen Sie für **Access to Endpoint Database** die Methode aus, mit der Sie den Zugriff auf die Datenbank authentifizieren möchten:
+ **Wenn Sie **AWS Secrets Manager** wählen, wählen Sie im Feld Secret das Geheimnis aus, in dem Sie Ihre Amazon DocumentDB DocumentDB-Anmeldeinformationen speichern.**
+ Wenn Sie **Zugangsinformationen manuell bereitstellen** wählen:
+ Geben Sie als **Servername** Ihren ein*target Amazon DocumentDB cluster endpoint*.
+ Geben Sie für **Port** **27017** ein (Standardport von Amazon DocumentDB).
+ Wählen Sie für **den SSL-Modus** **verify-full** (empfohlen für Amazon DocumentDB).
+ Laden Sie für **CA Certificate das CA-Zertifikatspaket** für die SSL-Verifizierung herunter und geben Sie es an.
+ Wählen Sie für den **Authentifizierungsmodus** den entsprechenden Modus für Ihre Anwendung (Passwort/SSL) (Standard ist Secrets Manager).
+ Wenn der **Authentifizierungsmodus** **Passwort** ist, geben Sie Folgendes an:
+ **Benutzername** und **Passwort**: Geben Sie Ihre Amazon DocumentDB DocumentDB-Anmeldeinformationen ein.
+ **Datenbankname**: Ihr Quelldatenbankname.
+ **Authentifizierungsmechanismus**: SCRAM-SHA-1 (Standard) oder geeigneter Mechanismus
1. **Behalten Sie für **den Metadatenmodus** die Standardeinstellung Dokument bei.**
#### Replikationsaufgabe erstellen
1. **Wählen Sie in der DMS-Konsole im Navigationsbereich **Migrieren oder replizieren** und dann Aufgaben aus.**
1. Wählen Sie **Create task** aus.
1. Gehen Sie auf der Seite **Aufgabe erstellen** im Abschnitt **Aufgabenkonfiguration** wie folgt vor:
+ Geben Sie eine eindeutige und aussagekräftige **Task-ID** ein (z. B. "mongodb-docdb-replication„).
+ Wählen Sie den Quellendpunkt, den Sie zuvor erstellt haben, im Dropdownmenü **Quelldatenbank-Endpunkt** aus.
+ Wählen Sie den Zielendpunkt, den Sie zuvor erstellt haben, im Dropdownmenü **Zieldatenbank-Endpunkt** aus.
+ Wählen Sie als **Aufgabentyp** die Option **Migrieren und replizieren** aus.
1. Gehen Sie im Abschnitt **Einstellungen** wie folgt vor:
+ Behalten Sie für den **Target-Tabellenvorbereitungsmodus** die Standardeinstellung bei.
+ **Behalten Sie für Aufgabe nach Abschluss des vollständigen Ladevorgangs** die Standardeinstellung bei.
+ Lassen Sie für **LOB-Spalteneinstellungen** die Einstellung **Eingeschränkter LOB-Modus** unverändert.
+ **Behalten** Sie für die **Datenvalidierung** die Standardeinstellung Ausschalten bei.
+ **Aktivieren Sie für **Aufgabenprotokolle** das Kontrollkästchen CloudWatch Protokolle aktivieren.**
+ Lassen Sie für **Batch-optimiertes Anwenden** die Standardeinstellung deaktiviert (aus).
1. Wählen Sie ganz oben im Bereich **Aufgabeneinstellungen** im **Bearbeitungsmodus** die Option **JSON-Editor** aus und legen Sie die folgenden Attribute fest:
```
{
"TargetMetadata": {
"ParallelApplyThreads": 5
},
"FullLoadSettings": {
"MaxFullLoadSubTasks": 16
}
}
```
1. Fügen Sie im Abschnitt **Tabellenzuordnungen** eine neue Auswahlregel hinzu:
+ Fügen Sie als **Schemaname** die zu migrierende Quelldatenbank hinzu. Verwenden Sie%, um mehrere Datenbanken anzugeben.
+ Fügen Sie als Name der **Schematabelle** die Quellsammlung hinzu, die migriert werden soll. Verwenden Sie%, um mehrere Sammlungen anzugeben.
+ Behalten Sie für **Aktion** die Standardeinstellung **Include** bei
1. Fügen Sie für große Sammlungen (über 100 GB) die **Regel für Tabelleneinstellungen** hinzu:
+ Fügen Sie als **Schemaname** die zu migrierende Quelldatenbank hinzu. Verwenden Sie%, um mehrere Datenbanken anzugeben.
+ Fügen Sie als Name der **Schematabelle** die Quellsammlung hinzu, die migriert werden soll. Verwenden Sie%, um mehrere Sammlungen anzugeben.
+ Geben Sie für **Anzahl der Partitionen** den Wert 16 ein (sollte kleiner sein als`MaxFullLoadSubTask`).
1. **Vergewissern Sie sich, dass die Option im Abschnitt „Bewertung vor der Migration**“ ausgeschaltet ist.
### Offline-Migration
In diesem Abschnitt wird der Prozess zur Durchführung einer Offline-Migration von einer selbstverwalteten MongoDB-Instance zu Amazon DocumentDB mithilfe nativer MongoDB-Tools beschrieben: und. `mongodump` `mongorestore`
### Voraussetzungen
**Anforderungen an Source MongoDB**
+ Zugriff auf die MongoDB-Quellinstanz mit entsprechenden Berechtigungen.
+ Installieren Sie`mongodump`. falls erforderlich (es wird während einer MongoDB-Installation installiert).
+ Stellen Sie sicher, dass genügend Speicherplatz für die Dump-Dateien vorhanden ist.
**Amazon DocumentDB DocumentDB-Anforderungen von Target**
+ Stellen Sie sicher, dass Sie einen Amazon DocumentDB-Cluster bereitgestellt haben.
+ Stellen Sie sicher, dass sich in derselben VPC wie Amazon DocumentDB eine EC2-Instance befindet, um die Migration zu erleichtern.
+ Netzwerkkonnektivität muss zwischen Ihrer Quellumgebung und Amazon DocumentDB verfügbar sein.
+ **mongorestore** muss auf der EC2-Migrationsinstanz installiert sein.
+ Für den Zugriff auf Amazon DocumentDB müssen entsprechende IAM-Berechtigungen konfiguriert werden.
**Allgemeine Anforderungen**
+ AWS CLI muss konfiguriert sein (wenn AWS Dienste für die Zwischenspeicherung verwendet werden)
+ Für die Datenübertragung muss ausreichend Bandbreite verfügbar sein.
+ Das Ausfallzeitfenster sollte genehmigt werden (wenn Sie eine Live-Migration durchführen, sollten Sie andere Methoden in Betracht ziehen)
### Einen Amazon DocumentDB-Cluster vorbereiten
Erstellen Sie einen Amazon DocumentDB-Cluster in AWS:
+ Passen Sie eine Instance-Größe an, die auf Ihrer Arbeitslast basiert.
+ Konfigurieren Sie eine VPC, Subnetze und Sicherheitsgruppen.
+ Aktivieren Sie die erforderlichen Parameter über Parametergruppen.
### Führen Sie den Datendump durch (Mongodump)
Wählen Sie eine der folgenden Optionen, um eine Dump-Datei zu erstellen:
+ **Option 1: Einfach**
```
mongodump --
uri="mongodb://:@:/" --
out=/path/to/dump
```
+ **Option 2: Bessere Steuerung und Leistung**
```
mongodump \
--uri="mongodb://:@:" \
--out=/path/to/dump \
--gzip \# Compress output
--numParallelCollections=4 \# Parallel collections dump
--ssl \# If using SSL
--authenticationDatabase=admin \ # If auth is required
--readPreference=secondaryPreferred # If replica set
```
+ **Option 3: Große Datenbanken**
```
mongodump \
--host= \
--port= \
--username= \
--password= \
--db= \# Only dump specific DB
--collection= \ # Only dump specific collection
--query='{ "date": { "$gt": "2020-01-01" } }' \ # Filter documents
--archive=/path/to/archive.gz \# Single archive output
--gzip \
--ssl
```
### Übertragen Sie Dumpdateien in die Wiederherstellungsumgebung
Wählen Sie eine geeignete Methode, die auf Ihrer Dump-Größe basiert:
+ **Klein** — Direkt auf Ihre Migrationsmaschine kopieren (EC2-Instanz, die Sie zuvor erstellt haben):
```
scp -r /path/to/dump user@migration-machine:/path/to/restore
```
+ **Medium** — Amazon S3 als Zwischenspeicher verwenden:
```
aws s3 cp --recursive /path/to/dump s3://your-bucket/mongodb-dump/
```
+ **Groß** — Bei sehr großen Datenbanken sollten Sie eine physische Übertragung in Betracht ziehen AWS DataSync .
### Daten in Amazon DocumentDB wiederherstellen (mongorestore)
Bevor Sie mit dem Wiederherstellungsprozess beginnen, erstellen Sie die Indizes in Amazon DocumentDB. Sie können das [Amazon DocumentDB Index-Tool](https://github.com/awslabs/amazon-documentdb-tools/tree/master/index-tool) verwenden, um Indizes zu exportieren und zu importieren.
Wählen Sie eine der folgenden Optionen, um Daten wiederherzustellen:
+ **Option 1: Grundlegende Wiederherstellung**
```
mongorestore --uri="mongodb://:@:27017"
/path/to/dump
```
+ **Option 2: Bessere Steuerung und Leistung**
```
mongorestore \
--uri="mongodb://:@:27017" \
--ssl \
--sslCAFile=/path/to/rds-combined-ca-bundle.pem \ # DocumentDB CA cert
--gzip \# If dumped with gzip
--numParallelCollections=4 \# Parallel restoration
--numInsertionWorkersPerCollection=4 \# Parallel documents insertion
--noIndexRestore \# skip indexes as they are pre-created
/path/to/dump
```
+ **Option 3: Große Datenbanken oder spezifische Kontrollen**
```
mongorestore \
--host= \
--port=27017 \
--username= \
--password= \
--ssl \
--sslCAFile=/path/to/rds-combined-ca-bundle.pem \
--archive=/path/to/archive.gz \# If using archive format
--gzip \
--nsInclude="db1.*" \# Only restore specific namespaces
--nsExclude="db1.sensitive_data" \ # Exclude specific collections if needed
--noIndexRestore \# skip indexes as they are pre-created
--writeConcern="{w: 'majority'}" # Ensure write durability
```
## Überwachen
Dieser Abschnitt bietet einen detaillierten Überwachungsprozess, mit dem Sie den Fortschritt, die Leistung und den Zustand einer laufenden Migration aus folgenden Quellen verfolgen können:
**MongoDB** nach **Amazon DocumentDB**
oder
**Amazon DocumentDB** zu **Amazon** DocumentDB
Die Schritte zur Überwachung gelten unabhängig von der Migrationsmethode (AWS DMS Mongodump/Mongorestore oder andere Tools).
### AWS DMS Überwachung der Migration (falls zutreffend)
Überwachen Sie die folgenden wichtigen CloudWatch Kennzahlen:
**Metriken für die Volllastphase**
+ **FullLoadThroughputBandwidthTarget**— Netzwerkbandbreite (KB/Sekunde) bei Volllast
+ **FullLoadThroughputRowsTarget**— Anzahl der Ladevorgänge pro rows/documents Sekunde
+ **FullLoadThroughputTablesTarget**— Anzahl der tables/collections Abgeschlossenen pro Minute
+ **FullLoadProgressPercent**— Prozentsatz der abgeschlossenen Volllast
+ **TablesLoaded**— Anzahl der tables/collections erfolgreich geladenen
+ **TablesLoading**— Anzahl der tables/collections aktuell geladenen
+ **TablesQueued**— Anzahl der Personen, die tables/collections darauf warten, geladen zu werden
+ **TablesErrored**— Nummer tables/collections , die nicht geladen werden konnte
**Metriken der CDC-Phase**
+ **CDCLatencyZiel** — Zeitverzögerung (Sekunden) zwischen Quellenänderung und Zielanwendung
+ **CDCLatencyQuelle** — Zeitverzögerung (Sekunden) zwischen der Änderung an der Quelle und dem Lesen durch das DMS
+ **CDCThroughputRowsTarget**— Zeilen pro Sekunde, die während der laufenden Replikation angewendet werden
+ **CDCThroughputBandwidthTarget**— Netzwerkbandbreite (KB/Sekunde) während CDC
+ **CDCIncomingÄnderungen** — Anzahl der von der Quelle empfangenen Änderungsereignisse
+ **CDCChangesMemoryTarget**— Verwendeter Speicher (MB) zum Speichern von Änderungen auf der Zielseite
**Metriken für Ressourcen**
+ **CPUUtilization**— CPU-Auslastung der Replikationsinstanz
+ **FreeableMemory**— Verfügbarer Speicher auf der Replikationsinstanz
+ **FreeStorageSpace**— Verfügbarer Speicher auf der Replikationsinstanz
+ **NetworkTransmitThroughput**— Netzwerkdurchsatz für die Replikationsinstanz
+ **NetworkReceiveThroughput**— Netzwerkdurchsatz für die Replikationsinstanz
**Metriken für Fehler**
+ **ErrorsCount**— Gesamtzahl der Fehler während der Migration
+ **TableErrorsCount**— Anzahl der tabellenspezifischen Fehler
+ **RecordsErrorsCount**— Anzahl der datensatzspezifischen Fehler
Erstellen Sie CloudWatch Alarme für kritische Messwerte, z. B. `CDCLatencyTarget` um Benachrichtigungen `CPUUtilization` zu erhalten, wenn sich die Migrationsleistung verschlechtert.
#### DMS-Protokolle (Protokolle) CloudWatch
1. Gehen Sie zur Amazon CloudWatch Logs-Konsole.
1. Suchen Sie nach Ihrer Protokollgruppe und wählen Sie sie aus. Es wird ähnlich aussehen wie „dms-tasks —“.
1. Suchen Sie nach Protokollstreams, die möglicherweise Fehlerinformationen enthalten:
+ Streams mit „Fehler“ im Namen
+ Streams mit Aufgaben IDs - oder Endpunktnamen
+ Die neuesten Log-Streams zum Zeitpunkt Ihrer Migration
1. Suchen Sie in diesen Streams nach Schlüsselwörtern wie:
+ „Fehler“
+ „Ausnahme“
+ „gescheitert“
+ „Warnung“
#### Status der DMS-Aufgabe (verwendet AWS CLI)
```
aws dms describe-replication-tasks --filters Name=replication-task id,Values= --query
"ReplicationTasks[0].Status"
```
Erwarteter Statusfluss:
erstellen → bereit → läuft → stoppt → gestoppt (oder fehlgeschlagen)
#### Monitor mit `docdb-dashboarder`
Das `docdb-dashboarder` Tool bietet eine umfassende Überwachung für Amazon DocumentDB-Cluster, indem es automatisch CloudWatch Dashboards mit wichtigen Leistungskennzahlen generiert. Diese Dashboards zeigen wichtige Metriken auf Clusterebene (Replikatverzögerung, Betriebszähler), Metriken auf Instanzebene (CPU, Arbeitsspeicher, Verbindungen) und Speichermetriken (Volumennutzung, Backup-Speicher). Für Migrationsszenarien bietet das Tool spezielle Dashboards, die den Migrationsfortschritt anhand von Kennzahlen wie CDC-Replikationsverzögerung und Betriebsraten verfolgen. Die Dashboards können mehrere Cluster gleichzeitig überwachen und bieten Unterstützung für NVMe Instanzen, die von einem System unterstützt werden. Durch die Visualisierung dieser Kennzahlen können Teams proaktiv Leistungsengpässe erkennen, die Ressourcenzuweisung optimieren und den reibungslosen Betrieb ihrer Amazon DocumentDB DocumentDB-Bereitstellungen sicherstellen. Das Tool macht die manuelle Erstellung von Dashboards überflüssig und bietet gleichzeitig eine konsistente Überwachung in allen Umgebungen. Anweisungen zur Einrichtung und erweiterte Konfigurationsoptionen finden Sie im [Amazon DocumentDB Dashboarder](https://github.com/awslabs/amazon-documentdb-tools/tree/master/monitoring/docdb-dashboarder) Tool-Repository. GitHub
## Validierung
**Topics**
+ [Checkliste für die Validierung](#w2aac23b9c25c15)
+ [Schema- und Indexvalidierung](#w2aac23b9c25c17)
+ [Datenerhebung und Validierung auf Feldebene](#w2aac23b9c25c19)
+ [Validierung mit einem DataDiffer Tool](#w2aac23b9c25c21)
Dieser Abschnitt enthält einen detaillierten Validierungsprozess zur Sicherstellung der Datenkonsistenz, Integrität und Anwendungskompatibilität nach der Migration von:
**MongoDB** nach **Amazon DocumentDB**
oder
**Amazon DocumentDB** zu **Amazon** DocumentDB
Die Validierungsschritte gelten unabhängig von der Migrationsmethode (AWS DMS mongodump/mongorestore oder andere Tools).
### Checkliste für die Validierung
Stellen Sie sicher, dass die Anzahl der Dokumente in jeder Sammlung zwischen Quelle und Ziel übereinstimmt:
**MongoDB-Quelle**
```
mongo --host --port --username -- password --eval
"db..count()"
```
**Amazon DocumentDB DocumentDB-Ziel**
```
mongo --host --port --username -- password --eval
"db..count()"
```
### Schema- und Indexvalidierung
Stellen Sie Folgendes sicher:
+ Alle Sammlungen sind im Ziel vorhanden.
+ Indizes werden korrekt repliziert.
+ Schemadefinitionen (sofern erzwungen) sind identisch.
**Überprüfen Sie die Sammlungen (Quelle im Vergleich zu Ziel)**
```
mongo --host --eval "show collections"
mongo --host --ssl --eval "show collections"
```
**Überprüfen Sie die Indizes (Quelle im Vergleich zu Ziel)**
```
mongo --host --eval" db..getIndexes()"
mongo --host --ssl –eval" db..getIndexes()"
```
Vergleichen Sie die Liste der Sammlungen, um sicherzustellen, dass keine Sammlungen fehlen oder zusätzliche Sammlungen vorhanden sind.
Überprüfen Sie Indizes, indem Sie Indexnamen, Schlüsseldefinitionen, eindeutige Einschränkungen und TTL-Indizes (falls vorhanden) überprüfen.
**Überprüfen Sie die Schemavalidierungsregeln (wenn Sie die Schemavalidierung in MongoDB verwenden)**
```
mongo --host --eval" db.getCollectionInfos({name: ''})
[0].options.validator"
mongo --host --ssl –eval" db.getCollectionInfos({name: ''})[0].options.validator"
```
### Datenerhebung und Validierung auf Feldebene
Sie können Dokumente nach dem Zufallsprinzip auswählen und Felder zwischen Quelle und Ziel vergleichen.
**Manuelle Probenahme**
Ruft fünf zufällige Dokumente ab (Quelle):
```
mongo --host --eval "db..aggregate([{ \$sample: { size: 5 } }])"
```
Ruft dasselbe Dokument ab IDs (Ziel):
```
mongo --host --ssl –eval "db..find({ _id: { \$in: [] } })"
```
**Automatische Probenahme**
```
import pymongo
# Connect to source and target
source_client = pymongo.MongoClient("")
target_client = pymongo.MongoClient("", ssl=True)
source_db = source_client[""]
target_db = target_client[""]
# Compare 100 random documents
for doc in source_db..aggregate([{ "$sample":
{ "size": 100 } }]):
target_doc = target_db..find_one({ "_id":
doc["_id"] })
if target_doc != doc:
print(f"❌ Mismatch in _id: {doc['_id']}")
else:
print(f"✅ Match: {doc['_id']}")
```
### Validierung mit einem DataDiffer Tool
Das [DataDiffer Tool](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/data-differ) bietet eine zuverlässige Möglichkeit, Daten zwischen Quell- und Zieldatenbanken zu vergleichen.
#### Voraussetzungen
Vor der Installation des DataDiffer Tools müssen die folgenden Voraussetzungen erfüllt sein:
+ Python 3.7\$1
+ PyMongo Bibliothek
+ Netzwerkkonnektivität sowohl zu Quell- als auch zu Amazon DocumentDB DocumentDB-Zielclustern
#### Einrichtung und Installation
**Klonen Sie das Repository und navigieren Sie zum Verzeichnis DataDiffer **
```
git clone https://github.com/awslabs/amazon-documentdb-tools.git
cd amazon-documentdb-tools/migration/data-differ
```
**Installieren Sie die erforderlichen Abhängigkeiten**
```
pip install -r requirements.txt
```
#### Datenvalidierung wird ausgeführt
**Erstellen Sie eine Konfigurationsdatei (z. B. config.json) mit Verbindungsdetails**
```
{
"source": {
"uri": "mongodb://username:password@source-mongodb-
host:27017/?replicaSet=rs0",
"db": "your_database",
"collection": "your_collection"
},
"target": {
"uri": "mongodb://username:password@target-docdb-
cluster.region.docdb.amazonaws.com:27017/?tls=true&tlsCAFile=global-
bundle.pem&replicaSet=rs0",
"db": "your_database",
"collection": "your_collection"
},
"options": {
"batch_size": 1000,
"threads": 4,
"sample_size": 0,
"verbose": true
}
}
```
**Führen Sie das Tool aus DataDiffer **
```
python differ.py --config config.json
```
**Verwenden Sie bei großen Sammlungen Stichproben, um eine Teilmenge von Daten zu validieren**
```
python differ.py --config config.json --sample-size 10000
```
**Um mehrere Sammlungen zu validieren, erstellen Sie separate Konfigurationsdateien oder verwenden Sie den Batch-Modus**
```
python differ.py --batch-config batch_config.json
```
#### Ergebnisse interpretieren
Das Tool gibt Folgendes aus:
+ Gesamtzahl der Dokumente in Quell- und Zieldokument
+ Anzahl der übereinstimmenden Dokumente
+ Anzahl der fehlenden Dokumente
+ Anzahl der Dokumente mit Unterschieden
+ Detaillierter Bericht über Unterschiede (falls vorhanden)
#### Best Practices
Im Folgenden finden Sie bewährte Methoden für die Verwendung des DataDiffer Tools:
+ **Schrittweise ausführen** — Überprüfen Sie zunächst die Anzahl der Dokumente, nehmen Sie dann Stichproben für wichtige Dokumente vor und führen Sie abschließend, falls erforderlich, einen vollständigen Vergleich durch.
+ **Suchen Sie nach Schemaunterschieden** — Amazon DocumentDB hat im Vergleich zu MongoDB einige Einschränkungen. Das Tool hebt inkompatible Datentypen oder Strukturen hervor.
+ **In Ruhephasen validieren** — Führen Sie die Validierung aus, wenn die Schreibvorgänge minimal sind, um die Konsistenz zu gewährleisten.
+ **Überwachen Sie die Ressourcennutzung** — Der Vergleichsprozess kann ressourcenintensiv sein. Passen Sie die Chargengröße und die Fadenzahl entsprechend an.
+ **Indizes validieren** — Stellen Sie nach der Datenvalidierung sicher, dass alle erforderlichen Indizes auf dem Amazon DocumentDB DocumentDB-Zielcluster erstellt wurden.
+ **Validierungsergebnisse dokumentieren** — Führen Sie als Teil Ihrer Migrationsdokumentation eine Aufzeichnung der Validierungsergebnisse für jede Sammlung.
# Migration von Couchbase Server
**Topics**
+ [Einführung](#introduction)
+ [Vergleich mit Amazon DocumentDB](#comparison-to-amazon-documentdb)
+ [Erkennung](#discovery)
+ [Planung](#planning)
+ [Migration](#migration)
+ [Validierung](#validation)
## Einführung
In diesem Handbuch werden die wichtigsten Punkte vorgestellt, die bei der Migration von Couchbase Server zu Amazon DocumentDB zu beachten sind. Es werden Überlegungen zu den Ermittlungs-, Planungs-, Ausführungs- und Validierungsphasen Ihrer Migration erläutert. Außerdem wird erklärt, wie Sie Offline- und Online-Migrationen durchführen.
## Vergleich mit Amazon DocumentDB
| | **Couchbase-Server** | **Amazon DocumentDB** |
| --- | --- | --- |
| Organisation der Daten | In den Versionen 7.0 und höher sind Daten in Buckets, Bereichen und Sammlungen organisiert. In früheren Versionen wurden Daten in Buckets organisiert. | Daten sind in Datenbanken und Sammlungen organisiert. |
| Kompatibilität | APIs Für jeden Dienst (z. B. Daten, Index, Suche usw.) gibt es separate. Sekundäre Suchvorgänge verwenden SQL\$1\$1 (früher bekannt als N1QL), eine Abfragesprache, die auf dem ANSI-Standard-SQL basiert und daher vielen Entwicklern vertraut ist. | Amazon DocumentDB ist [mit der MongoDB-API kompatibel](compatibility.html). |
| Architektur | Jeder Cluster-Instance ist Speicher zugeordnet. Sie können die Rechenleistung nicht unabhängig vom Speicher skalieren. | Amazon DocumentDB wurde für die Cloud entwickelt und vermeidet die Einschränkungen herkömmlicher Datenbankarchitekturen. Die [Rechen- und Speicherebene sind in Amazon DocumentDB getrennt](db-clusters-understanding.html), und die Rechenschicht kann [unabhängig vom Speicher skaliert](how-it-works.html) werden. |
| Fügen Sie bei Bedarf Lesekapazität hinzu | Cluster können durch Hinzufügen von Instanzen skaliert werden. Da der Speicher an die Instanz angehängt wird, auf der der Dienst ausgeführt wird, hängt die Zeit, die für die Skalierung benötigt wird, von der Datenmenge ab, die auf die neue Instanz verschoben oder neu verteilt werden muss. | Sie können die Leseskalierung für Ihren Amazon DocumentDB-Cluster erreichen, [indem Sie bis zu 15 Amazon DocumentDB DocumentDB-Replikate](db-cluster-manage-performance.html#db-cluster-manage-scaling-reads) im Cluster erstellen. Es hat keine Auswirkungen auf die Speicherebene. |
| Schnelle Wiederherstellung nach einem Knotenausfall | Cluster verfügen über automatische Failover-Funktionen, aber die Zeit, bis der Cluster wieder voll funktionsfähig ist, hängt von der Datenmenge ab, die auf die neue Instanz verschoben werden muss. | Amazon DocumentDB kann in [der Regel innerhalb von 30 Sekunden ein Failover auf den Primärserver](failover.html) durchführen und den Cluster innerhalb von 8 bis 10 Minuten wieder auf volle Stärke zurücksetzen, unabhängig von der Datenmenge im Cluster. |
| Skalieren Sie den Speicher, wenn die Datenmenge wächst | Für selbstverwaltete Cluster als Speicher und IOs nicht automatische Skalierung. | [Automatische Speicherung und IOs Skalierung](db-cluster-manage-performance.html#db-cluster-manage-scaling-storage) von Amazon DocumentDB. |
| Daten Backup, ohne die Leistung zu beeinträchtigen | Backups werden vom Backup-Dienst durchgeführt und sind standardmäßig nicht aktiviert. Da Speicher und Datenverarbeitung nicht getrennt sind, kann dies Auswirkungen auf die Leistung haben. | Amazon DocumentDB-Backups sind standardmäßig aktiviert und können nicht deaktiviert werden. Backups werden von der Speicherebene verwaltet, sodass sie keine Auswirkungen auf die Rechenebene haben. Amazon DocumentDB unterstützt die [Wiederherstellung aus einem Cluster-Snapshot](backup_restore-restore_from_snapshot.html) und [die Wiederherstellung zu einem bestimmten Zeitpunkt.](backup_restore-point_in_time_recovery.html) |
| Haltbarkeit der Daten | In einem Cluster können maximal 3 Replikatkopien von Daten vorhanden sein, also insgesamt 4 Kopien. Für jede Instanz, in der der Datendienst ausgeführt wird, sind 1, 2 oder 3 Replikatkopien der Daten aktiv. | Amazon DocumentDB verwaltet unabhängig von der Anzahl der Recheninstanzen 6 Kopien von Daten mit einem Schreibquorum von 4 und persist true. Kunden erhalten eine Bestätigung, nachdem die Speicherebene 4 Kopien der Daten gespeichert hat. |
| Konsistenz | Sofortige Konsistenz der K/V Abläufe wird unterstützt. Das Couchbase SDK leitet K/V Anfragen an die spezifische Instanz weiter, die die aktive Kopie der Daten enthält. Sobald ein Update bestätigt wurde, kann der Client dieses Update garantiert lesen. Die Replikation von Updates auf andere Dienste (Index, Suche, Analytik, Eventing) ist letztlich konsistent. | Amazon DocumentDB DocumentDB-Replikate sind letztendlich konsistent. Wenn sofortige Konsistenzlesevorgänge erforderlich sind, kann der Client von der primären Instance aus lesen. |
| Replikation | Cross-Data Center Replication (XDCR) ermöglicht eine gefilterte, aktiv-passive/aktiv-aktive Replikation von Daten in vielen Topologien. | [Globale Amazon DocumentDB-Cluster](global-clusters.html) bieten Aktiv-Passiv-Replikation in 1:many (bis zu 10) Topologien. |
## Erkennung
Die Migration zu Amazon DocumentDB erfordert ein gründliches Verständnis der bestehenden Datenbank-Arbeitslast. Bei der Workload-Erkennung werden Ihre Couchbase-Cluster-Konfiguration und die Betriebsmerkmale — Datensatz, Indizes und Arbeitslast — analysiert, um einen reibungslosen Übergang mit minimalen Unterbrechungen zu gewährleisten.
### Cluster-Konfiguration
Couchbase verwendet eine serviceorientierte Architektur, bei der jede Funktion einem Dienst entspricht. Führen Sie den folgenden Befehl für Ihren Couchbase-Cluster aus, um festzustellen, welche Dienste verwendet werden (siehe Informationen zu Knoten [abrufen](https://docs.couchbase.com/server/current/rest-api/rest-node-get-info.html)):
```
curl -v -u : \
http://:/pools/nodes | \
jq '[.nodes[].services[]] | unique'
```
Beispielausgabe:
```
[
"backup",
"cbas",
"eventing",
"fts",
"index",
"kv",
"n1ql"
]
```
Die Couchbase-Dienste umfassen Folgendes:
#### Datendienst (kv)
Der Datendienst ermöglicht read/write den Zugriff auf Daten im Speicher und auf der Festplatte.
Amazon DocumentDB unterstützt K/V Operationen mit JSON-Daten über die [MongoDB-API](java-crud-operations.html).
#### Abfragedienst (n1ql)
Der Abfragedienst unterstützt das Abfragen von JSON-Daten über SQL\$1\$1.
Amazon DocumentDB unterstützt die Abfrage von JSON-Daten über die MongoDB-API.
#### Indexdienst (Index)
Der Indexdienst erstellt und verwaltet Indizes für Daten und ermöglicht so eine schnellere Abfrage.
Amazon DocumentDB unterstützt einen Standard-Primärindex und die Erstellung von Sekundärindizes für JSON-Daten über die MongoDB-API.
#### Suchdienst (fts)
Der Suchdienst unterstützt die Erstellung von Indizes für die Volltextsuche.
Mit der nativen Volltextsuchfunktion von Amazon DocumentDB können Sie [mithilfe von speziellen Textindizes über die MongoDB-API eine Textsuche in großen Textdatensätzen durchführen](text-search.html). Für erweiterte Suchanwendungsfälle bietet die [Amazon DocumentDB Zero-ETL-Integration mit Amazon OpenSearch Service](https://aws.amazon.com/blogs/big-data/amazon-documentdb-zero-etl-integration-with-amazon-opensearch-service-is-now-available/) erweiterte Suchfunktionen wie Fuzzy-Suche, sammlungsübergreifende Suche und mehrsprachige Suche in Amazon DocumentDB DocumentDB-Daten.
#### Analysedienst (CBAS)
Der Analysedienst unterstützt die Analyse von JSON-Daten nahezu in Echtzeit.
Amazon DocumentDB unterstützt Ad-hoc-Abfragen von JSON-Daten über die MongoDB-API. Sie können mit [Apache Spark, der auf Amazon EMR läuft, auch komplexe Abfragen für Ihre JSON-Daten in Amazon DocumentDB ausführen](https://aws.amazon.com/blogs/database/run-complex-queries-on-massive-amounts-of-data-stored-on-your-amazon-documentdb-clusters-using-apache-spark-running-on-amazon-emr/).
#### Veranstaltungsservice (Eventing)
Der Eventing-Dienst führt als Reaktion auf Datenänderungen eine benutzerdefinierte Geschäftslogik aus.
Amazon DocumentDB automatisiert ereignisgesteuerte Workloads, indem es [jedes Mal AWS Lambda Funktionen aufruft, wenn sich Daten mit Ihrem Amazon DocumentDB-Cluster ändern](https://docs.aws.amazon.com/lambda/latest/dg/with-documentdb-tutorial.html).
#### Backup-Dienst (Backup)
Der Backup-Service plant vollständige und inkrementelle Datensicherungen und Zusammenführungen früherer Datensicherungen.
Amazon DocumentDB sichert Ihre Daten kontinuierlich auf Amazon S3 mit einer Aufbewahrungsdauer von 1—35 Tagen, sodass Sie innerhalb des Aufbewahrungszeitraums für Backups an jedem beliebigen Punkt schnell wiederherstellen können. Amazon DocumentDB erstellt im Rahmen dieses kontinuierlichen Backup-Prozesses auch automatische Schnappschüsse Ihrer Daten. Sie können auch die [Sicherung und Wiederherstellung von Amazon DocumentDB mit AWS Backup verwalten](https://aws.amazon.com/blogs/storage/manage-backup-and-restore-of-amazon-documentdb-with-aws-backup/). .
### Betriebliche Eigenschaften
Verwenden Sie das [Discovery Tool for Couchbase](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/discovery-tool-for-couchbase), um die folgenden Informationen zu Ihrem Datensatz, Ihren Indizes und Ihrer Arbeitslast abzurufen. Diese Informationen helfen Ihnen bei der Größe Ihres Amazon DocumentDB-Clusters.
#### Dataset
Das Tool ruft die folgenden Bucket-, Bereichs- und Sammlungsinformationen ab:
1. Bucket-Name
1. Bucket-Typ
1. Name des Bereichs
1. Name der Sammlung
1. Gesamtgröße (Byte)
1. Gesamtzahl der Artikel
1. Artikelgröße (Byte)
#### Indizes
Das Tool ruft die folgenden Indexstatistiken und alle Indexdefinitionen für alle Buckets ab. Beachten Sie, dass Primärindizes ausgeschlossen sind, da Amazon DocumentDB automatisch einen Primärindex für jede Sammlung erstellt.
1. Bucket-Name
1. Name des Bereichs
1. Name der Sammlung
1. Indexname
1. Indexgröße (Byte)
#### Workload
Das Tool ruft Metriken ab K/V und fragt N1QL ab. K/V Metrikwerte werden auf Bucket-Ebene und SQL\$1\$1-Metriken auf Cluster-Ebene gesammelt.
Die Befehlszeilenoptionen des Tools lauten wie folgt:
```
python3 discovery.py \
--username \
--password \
--data_node \
--admin_port \
--kv_zoom \
--tools_path \
--index_metrics \
--indexer_port \
--n1ql_start \
--n1ql_step
```
Hier sehen Sie ein Beispiel für einen Befehl.
```
python3 discovery.py \
--username username \
--password ******** \
--data_node "http://10.0.0.1" \
--admin_port 8091 \
--kv_zoom week \
--tools_path "/opt/couchbase/bin" \
--index_metrics true \
--indexer_port 9102 \
--n1ql_start -60000 \
--n1ql_step 1000
```
Die K/V-Metrikwerte werden auf Stichproben basieren, die in der letzten Woche alle 10 Minuten abgerufen wurden (siehe [HTTP-Methode und URI](https://docs.couchbase.com/server/current/rest-api/rest-bucket-stats.html#http-method-and-uri)). Die SQL\$1\$1-Metrikwerte basieren auf Stichproben der letzten 60 Sekunden alle 1 Sekunde (siehe [Allgemeine Bezeichnungen](https://docs.couchbase.com/server/current/rest-api/rest-statistics-single.html#general-labels)). Die Ausgabe des Befehls wird in den folgenden Dateien gespeichert:
**collection-stats.csv** — Informationen zu Bereich, Umfang und Sammlung
```
bucket,bucket_type,scope_name,collection_name,total_size,total_items,document_size
beer-sample,membase,_default,_default,2796956,7303,383
gamesim-sample,membase,_default,_default,114275,586,196
pillowfight,membase,_default,_default,1901907769,1000006,1902
travel-sample,membase,inventory,airport,547914,1968,279
travel-sample,membase,inventory,airline,117261,187,628
travel-sample,membase,inventory,route,13402503,24024,558
travel-sample,membase,inventory,landmark,3072746,4495,684
travel-sample,membase,inventory,hotel,4086989,917,4457
...
```
**index-stats.csv** — Indexnamen und -größen
```
bucket,scope,collection,index-name,index-size
beer-sample,_default,_default,beer_primary,468144
gamesim-sample,_default,_default,gamesim_primary,87081
travel-sample,inventory,airline,def_inventory_airline_primary,198290
travel-sample,inventory,airport,def_inventory_airport_airportname,513805
travel-sample,inventory,airport,def_inventory_airport_city,487289
travel-sample,inventory,airport,def_inventory_airport_faa,526343
travel-sample,inventory,airport,def_inventory_airport_primary,287475
travel-sample,inventory,hotel,def_inventory_hotel_city,497125
...
```
**kv-stats.csv** — Metriken für alle Buckets abrufen, festlegen und löschen
```
bucket,gets,sets,deletes
beer-sample,0,0,0
gamesim-sample,0,0,0
pillowfight,369,521,194
travel-sample,0,0,0
```
**n1ql-stats.csv** — SQL\$1\$1 wählt Metriken für den Cluster aus, löscht sie und fügt sie ein
```
selects,deletes,inserts
0,132,87
```
**indexes- .txt** — Indexdefinitionen aller Indizes im Bucket. Beachten Sie, dass Primärindizes ausgeschlossen sind, da Amazon DocumentDB automatisch einen Primärindex für jede Sammlung erstellt.
```
CREATE INDEX `def_airportname` ON `travel-sample`(`airportname`)
CREATE INDEX `def_city` ON `travel-sample`(`city`)
CREATE INDEX `def_faa` ON `travel-sample`(`faa`)
CREATE INDEX `def_icao` ON `travel-sample`(`icao`)
CREATE INDEX `def_inventory_airport_city` ON `travel-sample`.`inventory`.`airport`(`city`)
CREATE INDEX `def_inventory_airport_faa` ON `travel-sample`.`inventory`.`airport`(`faa`)
CREATE INDEX `def_inventory_hotel_city` ON `travel-sample`.`inventory`.`hotel`(`city`)
CREATE INDEX `def_inventory_landmark_city` ON `travel-sample`.`inventory`.`landmark`(`city`)
CREATE INDEX `def_sourceairport` ON `travel-sample`(`sourceairport`)
...
```
## Planung
In der Planungsphase legen Sie die Anforderungen an den Amazon DocumentDB-Cluster und die Zuordnung der Couchbase-Buckets, -Bereiche und -Sammlungen zu Amazon DocumentDB DocumentDB-Datenbanken und -Sammlungen fest.
### Anforderungen für Amazon DocumentDB-Cluster
Verwenden Sie die in der Ermittlungsphase gesammelten Daten, um die Größe Ihres Amazon DocumentDB-Clusters zu bestimmen. Weitere Informationen zur [Dimensionierung Ihres Amazon DocumentDB-Clusters finden Sie unter Instance-Größe](best_practices.html#best_practices-instance_sizing).
### Zuordnung von Buckets, Bereichen und Sammlungen zu Datenbanken und Sammlungen
Ermitteln Sie die Datenbanken und Sammlungen, die in Ihren Amazon DocumentDB-Clustern vorhanden sein werden. Ziehen Sie die folgenden Optionen in Betracht, je nachdem, wie die Daten in Ihrem Couchbase-Cluster organisiert sind. Dies sind nicht die einzigen Optionen, aber sie bieten Ausgangspunkte, die Sie in Betracht ziehen sollten.
#### Couchbase Server 6.x oder früher
##### Couchbase-Buckets zu Amazon DocumentDB-Sammlungen
Migrieren Sie jeden Bucket in eine andere Amazon DocumentDB-Sammlung. In diesem Szenario wird der `id` Couchbase-Dokumentwert als Amazon DocumentDB `_id` DocumentDB-Wert verwendet.
![\[Couchbase Server 6.x oder frühere Buckets für Amazon DocumentDB-Sammlungen\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/buckets-to-collections.png)
#### Couchbase Server 7.0 oder höher
##### Couchbase-Sammlungen zu Amazon DocumentDB-Sammlungen
Migrieren Sie jede Sammlung zu einer anderen Amazon DocumentDB-Sammlung. In diesem Szenario wird der `id` Couchbase-Dokumentwert als Amazon DocumentDB `_id` DocumentDB-Wert verwendet.
![\[Couchbase Server 7.0 oder neuere Sammlungen zu Amazon DocumentDB-Sammlungen\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/collections-to-collections.png)
## Migration
### Indexmigration
Bei der Migration zu Amazon DocumentDB werden nicht nur Daten, sondern auch Indizes übertragen, um die Abfrageleistung aufrechtzuerhalten und den Datenbankbetrieb zu optimieren. In diesem Abschnitt wird der detaillierte step-by-step Prozess für die Migration von Indizes zu Amazon DocumentDB beschrieben, wobei Kompatibilität und Effizienz gewährleistet werden.
Verwenden Sie [Amazon Q](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/chat-with-q.html), um `CREATE INDEX` SQL\$1\$1-Anweisungen in Amazon DocumentDB DocumentDB-Befehle `createIndex()` zu konvertieren.
1. Laden Sie die **Index-.txt-Datei** (en) hoch, die mit dem Discovery Tool for Couchbase erstellt wurden.
1. Geben Sie die folgende Aufforderung ein:
`Convert the Couchbase CREATE INDEX statements to Amazon DocumentDB createIndex commands`
Amazon Q generiert entsprechende Amazon DocumentDB `createIndex()` DocumentDB-Befehle. Beachten Sie, dass Sie die Sammlungsnamen möglicherweise aktualisieren müssen, je nachdem, wie Sie [die Couchbase-Buckets, Bereiche und Sammlungen Amazon DocumentDB-Sammlungen](#mapping-buckets-scopes-and-collections-to-databases-and-collections) zugeordnet haben.
Beispiel:
**indexes-beer-sample.txt**
```
CREATE INDEX `beerType` ON `beer-sample`(`type`)
CREATE INDEX `code` ON `beer-sample`(`code`) WHERE (`type` = "brewery")
```
Beispiel für eine Amazon Q-Ausgabe (Auszug):
```
db.beerSample.createIndex(
{ "type": 1 },
{
"name": "beerType",
"background": true
}
)
db.beerSample.createIndex(
{ "code": 1 },
{
"name": "code",
"background": true,
"partialFilterExpression": { "type": "brewery" }
}
)
```
Weitere Informationen zu Indizes, die Amazon Q nicht konvertieren kann, finden Sie unter [Amazon DocumentDB DocumentDB-Indizes verwalten](managing-indexes.html) und [Indizes und Indexeigenschaften](mongo-apis.html#mongo-apis-index).
### Code umgestalten, um die MongoDB zu verwenden APIs
Clients verwenden die Couchbase, um eine Verbindung zum SDKs Couchbase-Server herzustellen. Amazon DocumentDB-Clients verwenden MongoDB-Treiber, um eine Verbindung zu Amazon DocumentDB herzustellen. Alle von Couchbase unterstützten Sprachen SDKs werden auch von MongoDB-Treibern unterstützt. Weitere Informationen zum [Treiber für Ihre Sprache finden Sie unter MongoDB-Treiber](https://www.mongodb.com/docs/drivers/).
Da sie APIs sich zwischen Couchbase Server und Amazon DocumentDB unterscheiden, müssen Sie Ihren Code umgestalten, um die entsprechende MongoDB zu verwenden. APIs Sie können [Amazon Q](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/chat-with-q.html) verwenden, um die K/V API-Aufrufe und SQL\$1\$1-Abfragen in die entsprechende APIs MongoDB zu konvertieren:
1. Laden Sie die Quellcodedatei (en) hoch.
1. Geben Sie die folgende Aufforderung ein:
`Convert the Couchbase API code to Amazon DocumentDB API code`
Mithilfe des Python-Codebeispiels [Hello Couchbase](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html#hello-couchbase) generiert Amazon Q Folgendes (Auszug):
```
from datetime import timedelta
from pymongo import MongoClient
# Connection parameters
database_name = "travel-sample"
# Connect to Amazon DocumentDB cluster
client = MongoClient('')
# Get reference to database and collection
db = client['travel-sample']
airline_collection = db['airline']
# upsert document function
def upsert_document(doc):
print("\nUpsert Result: ")
try:
# key will equal: "airline_8091"
key = doc["type"] + "_" + str(doc["id"])
doc['_id'] = key # Amazon DocumentDB uses _id as primary key
result = airline_collection.update_one(
{'_id': key},
{'$set': doc},
upsert=True
)
print(f"Modified count: {result.modified_count}")
except Exception as e:
print(e)
# get document function
def get_airline_by_key(key):
print("\nGet Result: ")
try:
result = airline_collection.find_one({'_id': key})
print(result)
except Exception as e:
print(e)
# query for document by callsign
def lookup_by_callsign(cs):
print("\nLookup Result: ")
try:
result = airline_collection.find(
{'callsign': cs},
{'name': 1, '_id': 0}
)
for doc in result:
print(doc['name'])
except Exception as e:
print(e)
# Test document
airline = {
"type": "airline",
"id": 8091,
"callsign": "CBS",
"iata": None,
"icao": None,
"name": "Couchbase Airways",
}
upsert_document(airline)
get_airline_by_key("airline_8091")
lookup_by_callsign("CBS")
```
Beispiele für das Herstellen einer [Verbindung zu Amazon DocumentDB in Python, Node.js, PHP, Go, Java, C\$1/.NET, R und Ruby finden Sie unter Programmgesteuert](connect_programmatically.html) mit Amazon DocumentDB verbinden.
### Wählen Sie den Migrationsansatz
Bei der Migration von Daten zu Amazon DocumentDB gibt es zwei Optionen:
1. [Offline-Migration](#offline-migration)
1. [Online-Migration](#online-migration)
#### Offline-Migration
Ziehen Sie eine Offline-Migration in Betracht, wenn:
+ **Ausfallzeiten sind akzeptabel:** Bei der Offline-Migration werden Schreibvorgänge in die Quelldatenbank gestoppt, die Daten exportiert und anschließend in Amazon DocumentDB importiert. Dieser Vorgang führt zu Ausfallzeiten für Ihre Anwendung. Wenn Ihre Anwendung oder Ihr Workload diesen Zeitraum der Nichtverfügbarkeit verträgt, ist eine Offline-Migration eine praktikable Option.
+ **Migration kleinerer Datensätze oder Durchführung von Machbarkeitsnachweisen:** Bei kleineren Datensätzen ist der Zeitaufwand für den Export- und Importvorgang relativ kurz, sodass die Offline-Migration eine schnelle und einfache Methode darstellt. Es eignet sich auch gut für Entwicklungs-, Test- und proof-of-concept Umgebungen, in denen Ausfallzeiten weniger kritisch sind.
+ **Einfachheit hat Priorität:** Die Offline-Methode mit cbexport und mongoimport ist im Allgemeinen der einfachste Ansatz zur Datenmigration. Sie vermeidet die Komplexität der Erfassung von Änderungsdaten (CDC), die mit Online-Migrationsmethoden verbunden ist.
+ Es **müssen keine laufenden Änderungen repliziert werden:** Wenn die Quelldatenbank während der Migration nicht aktiv Änderungen empfängt oder wenn diese Änderungen nicht unbedingt erfasst und während des Migrationsprozesses auf das Ziel angewendet werden müssen, ist ein Offline-Ansatz angemessen.
**Topics**
+ [Couchbase Server 6.x oder früher](#couchbase-6x-or-earlier-offline)
+ [Couchbase Server 7.0 oder höher](#couchbase-70-or-later-offline)
##### Couchbase Server 6.x oder früher
##### Couchbase-Bucket zur Amazon DocumentDB-Sammlung
Exportieren Sie Daten mit [cbexport json](https://docs-archive.couchbase.com/server/6.6/tools/cbexport-json.html), um einen JSON-Dump aller Daten im Bucket zu erstellen. Für die `--format` Option können Sie oder verwenden. `lines` `list`
```
cbexport json \
--cluster \
--bucket \
--format \
--username \
--password \
--output export.json \
--include-key _id
```
Importieren Sie die Daten mithilfe von [mongoimport](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) in eine Amazon DocumentDB-Sammlung mit der entsprechenden Option zum Importieren der Zeilen oder Listen:
Zeilen:
```
mongoimport \
--db \
--collection \
--uri "" \
--file export.json
```
Liste:
```
mongoimport \
--db \
--collection \
--uri "" \
--jsonArray \
--file export.json
```
##### Couchbase Server 7.0 oder höher
Verwenden Sie die Tools cbexport und mongoimport, um eine Offline-Migration durchzuführen:
##### Couchbase-Bucket mit Standardbereich und Standardsammlung
Exportieren Sie Daten mit [cbexport json](https://docs.couchbase.com/server/current/tools/cbexport-json.html), um einen JSON-Dump aller Sammlungen im Bucket zu erstellen. Für die `--format` Option können Sie oder verwenden. `lines` `list`
```
cbexport json \
--cluster \
--bucket \
--format \
--username \
--password \
--output export.json \
--include-key _id
```
Importieren Sie die Daten mithilfe von [mongoimport](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) in eine Amazon DocumentDB-Sammlung mit der entsprechenden Option zum Importieren der Zeilen oder Listen:
Zeilen:
```
mongoimport \
--db \
--collection \
--uri "" \
--file export.json
```
Liste:
```
mongoimport \
--db \
--collection \
--uri "" \
--jsonArray \
--file export.json
```
##### Couchbase-Sammlungen zu Amazon DocumentDB-Sammlungen
Exportieren Sie Daten mit [cbexport json](https://docs.couchbase.com/server/current/tools/cbexport-json.html), um für jede Sammlung einen JSON-Dump zu erstellen. Verwenden Sie die `--include-data` Option, um jede Sammlung zu exportieren. Für die `--format` Option können Sie `lines` oder verwenden`list`. Verwenden Sie die `--collection-field` Optionen `--scope-field` und, um den Namen des Bereichs und der Sammlung in den angegebenen Feldern in jedem JSON-Dokument zu speichern.
```
cbexport json \
--cluster \
--bucket \
--include-data . \
--format \
--username \
--password \
--output export.json \
--include-key _id \
--scope-field "_scope" \
--collection-field "_collection"
```
Da cbexport die `_collection` Felder `_scope` und zu jedem exportierten Dokument hinzugefügt hat, können Sie sie mit Suchen und Ersetzen oder einer beliebigen Methode aus jedem Dokument in der Exportdatei entfernen. `sed`
Importieren Sie die Daten für jede Sammlung mithilfe von [mongoimport](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) in eine Amazon DocumentDB-Sammlung mit der entsprechenden Option zum Importieren der Zeilen oder Listen:
Zeilen:
```
mongoimport \
--db \
--collection \
--uri "" \
--file export.json
```
Liste:
```
mongoimport \
--db \
--collection \
--uri "" \
--jsonArray \
--file export.json
```
#### Online-Migration
Ziehen Sie eine Online-Migration in Betracht, wenn Sie Ausfallzeiten minimieren möchten und laufende Änderungen nahezu in Echtzeit auf Amazon DocumentDB repliziert werden müssen.
Unter [So führen Sie eine Live-Migration von Couchbase zu Amazon DocumentDB durch, um](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) zu erfahren, wie Sie eine Live-Migration zu Amazon DocumentDB durchführen. Die Dokumentation führt Sie durch die Bereitstellung der Lösung und die Durchführung einer Live-Migration eines Buckets zu einem Amazon DocumentDB-Cluster.
**Topics**
+ [Couchbase Server 6.x oder früher](#couchbase-6x-or-earlier-online)
+ [Couchbase Server 7.0 oder höher](#couchbase-70-or-later-online)
##### Couchbase Server 6.x oder früher
##### Couchbase-Bucket zur Amazon DocumentDB-Sammlung
Das [Migrationsprogramm für Couchbase](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) ist vorkonfiguriert, um eine Online-Migration eines Couchbase-Buckets zu einer Amazon DocumentDB-Sammlung durchzuführen. In der Konfiguration des [Sink-Connectors](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) ist der `document.id.strategy` Parameter so konfiguriert, dass er den Nachrichtenschlüsselwert als `_id` Feldwert verwendet (siehe Eigenschaften der [Sink-Connector-ID-Strategie](https://www.mongodb.com/docs/kafka-connector/current/sink-connector/configuration-properties/id-strategy/#std-label-sink-configuration-id-strategy)):
```
ConnectorConfiguration:
document.id.strategy: 'com.mongodb.kafka.connect.sink.processor.id.strategy.ProvidedInKeyStrategy'
```
##### Couchbase Server 7.0 oder höher
##### Couchbase-Bucket mit Standardbereich und Standardsammlung
Das [Migrationsprogramm für Couchbase](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) ist vorkonfiguriert, um eine Online-Migration eines Couchbase-Buckets zu einer Amazon DocumentDB-Sammlung durchzuführen. In der Konfiguration des [Sink-Connectors](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) ist der `document.id.strategy` Parameter so konfiguriert, dass er den Nachrichtenschlüsselwert als `_id` Feldwert verwendet (siehe Eigenschaften der [Sink-Connector-ID-Strategie](https://www.mongodb.com/docs/kafka-connector/current/sink-connector/configuration-properties/id-strategy/#std-label-sink-configuration-id-strategy)):
```
ConnectorConfiguration:
document.id.strategy: 'com.mongodb.kafka.connect.sink.processor.id.strategy.ProvidedInKeyStrategy'
```
##### Couchbase-Sammlungen zu Amazon DocumentDB-Sammlungen
[Konfigurieren Sie den [Quell-Connector](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) so, dass jede Couchbase-Sammlung in jedem Bereich zu einem separaten Thema gestreamt wird (siehe Quellkonfigurationsoptionen).](https://docs.couchbase.com/kafka-connector/current/source-configuration-options.html#couchbase.collections) Beispiel:
```
ConnectorConfiguration:
# add couchbase.collections configuration
couchbase.collections: '., ., ...'
```
Konfigurieren Sie den [Sink Connector](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) so, dass er von jedem Thema in eine separate Amazon DocumentDB-Sammlung streamt (siehe [Eigenschaften der Sink Connector-Konfiguration](https://github.com/mongodb-labs/mongo-kafka/blob/master/docs/sink.md#sink-connector-configuration-properties)). Beispiel:
```
ConnectorConfiguration:
# remove collection configuration
#collection: 'test'
# modify topics configuration
topics: '.., .., ...'
# add topic.override.%s.%s configurations for each topic
topic.override....collection: ''
topic.override....collection: ''
```
## Validierung
Dieser Abschnitt enthält einen detaillierten Validierungsprozess zur Überprüfung der Datenkonsistenz und Integrität nach der Migration zu Amazon DocumentDB. Die Validierungsschritte gelten unabhängig von der Migrationsmethode.
**Topics**
+ [Stellen Sie sicher, dass alle Sammlungen im Ziel vorhanden sind](#validation-checklist-step-1)
+ [Überprüfen Sie die Anzahl der Dokumente zwischen Quell- und Zielclustern](#validation-checklist-step-2)
+ [Dokumente zwischen Quell- und Zielclustern vergleichen](#validation-checklist-step-3)
### Stellen Sie sicher, dass alle Sammlungen im Ziel vorhanden sind
#### Couchbase-Quelle
Option 1: Abfrage-Workbench
```
SELECT RAW `path`
FROM system:keyspaces
WHERE `bucket` = ''
```
Option 2: [CBQ-Tool](https://docs.couchbase.com/server/current/cli/cbq-tool.html)
```
cbq \
-e \
-u \
-p \
-q "SELECT RAW `path`
FROM system:keyspaces
WHERE `bucket` = ''"
```
#### Amazon DocumentDB DocumentDB-Ziel
mongosh (siehe [Connect zu Ihrem Amazon DocumentDB-Cluster](connect-ec2-manual.html#manual-connect-ec2.connect-use) herstellen):
```
db.getSiblingDB('')
db.getCollectionNames()
```
### Überprüfen Sie die Anzahl der Dokumente zwischen Quell- und Zielclustern
#### Couchbase-Quelle
##### Couchbase Server 6.x oder früher
Option 1: Query Workbench
```
SELECT COUNT(*)
FROM ``
```
[Option 2: cbq](https://docs.couchbase.com/server/current/cli/cbq-tool.html)
```
cbq \
-e \
-u \
-p \
-q "SELECT COUNT(*)
FROM ``"
```
##### Couchbase Server 7.0 oder höher
Option 1: Query Workbench
```
SELECT COUNT(*)
FROM ``.``.``
```
[Option 2: cbq](https://docs.couchbase.com/server/current/cli/cbq-tool.html)
```
cbq \
-e \
-u \
-p \
-q "SELECT COUNT(*)
FROM ``.``.``"
```
#### Amazon DocumentDB DocumentDB-Ziel
mongosh (siehe [Connect zu Ihrem Amazon DocumentDB-Cluster](connect-ec2-manual.html#manual-connect-ec2.connect-use) herstellen):
```
db = db.getSiblingDB('')
db.getCollection('').countDocuments()
```
### Dokumente zwischen Quell- und Zielclustern vergleichen
#### Couchbase-Quelle
##### Couchbase Server 6.x oder früher
Option 1: Query Workbench
```
SELECT META().id as _id, *
FROM ``
LIMIT 5
```
[Option 2: cbq](https://docs.couchbase.com/server/current/cli/cbq-tool.html)
```
cbq \
-e
-u \
-p \
-q "SELECT META().id as _id, *
FROM `` \
LIMIT 5"
```
##### Couchbase Server 7.0 oder höher
Option 1: Query Workbench
```
SELECT COUNT(*)
FROM ``.``.``
```
[Option 2: cbq](https://docs.couchbase.com/server/current/cli/cbq-tool.html)
```
cbq \
-e \
-u \
-p \
-q "SELECT COUNT(*)
FROM ``.``.``"
```
#### Amazon DocumentDB DocumentDB-Ziel
mongosh (siehe [Connect zu Ihrem Amazon DocumentDB-Cluster](connect-ec2-manual.html#manual-connect-ec2.connect-use) herstellen):
```
db = db.getSiblingDB('')
db.getCollection('').find({
_id: {
$in: [
<_id 1>, <_id 2>, <_id 3>, <_id 4>, <_id 5>
]
}
})
```