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.
# Importieren von Daten in eine DB-Instance von Amazon RDS für MySQL
Für den Import von Daten in eine DB-Instance von RDS für MySQL stehen verschiedene Techniken zur Verfügung. Die beste Methode hängt von einer Reihe von Faktoren ab:
+ Datenquelle
+ Datenmenge
+ Einmaliger oder kontinuierlicher Import
+ Dauer der Ausfallzeit
Wenn Sie auch eine Anwendung mit den Daten migrieren, müssen Sie zudem die Ausfallzeit berücksichtigen.
In der folgenden Tabelle sind Methoden zum Importieren von Daten in eine DB-Instance von RDS für MySQL angegeben:
| Quelle | Datenmenge | Einmalig oder kontinuierlich | Ausfallzeit der Anwendung | Technik | Weitere Informationen |
| --- | --- | --- | --- | --- | --- |
| Lokal oder auf Amazon EC2 vorhandene MySQL-Datenbank | Alle | Einmalig | Etwas | Erstellen Sie ein Backup der Datenbank vor Ort, speichern Sie es auf Amazon S3 und stellen Sie die Sicherungsdatei anschließend auf einer neuen Amazon-RDS-DB-Instance wieder her, auf der MySQL ausgeführt wird. | [Wiederherstellen eines Backups in eine DB-Instance von Amazon RDS für MySQL](MySQL.Procedural.Importing.md) |
| Lokal oder auf Amazon EC2 vorhandene MySQL-Datenbank | Beliebig | Kontinuierlich | Minimal | Konfigurieren Sie die Replikation mit einer vorhandenen MySQL-Datenbank als Replikationsquelle. | [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md) [Importieren von Daten in eine Datenbank von Amazon RDS für MySQL mit reduzierter Ausfallzeit](mysql-importing-data-reduced-downtime.md) |
| Alle vorhandenen Datenbanken | Alle | Einmalig oder kontinuierlich | Minimal | Wird verwendet AWS Database Migration Service , um die Datenbank mit minimaler Ausfallzeit zu migrieren und bei vielen Datenbank-DB-Engines die fortlaufende Replikation fortzusetzen. | [Was ist AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) und [Verwenden einer MySQL-kompatiblen Datenbank als Ziel für AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) im *AWS Database Migration Service -Benutzerhandbuch* |
| Bestehende MySQL-DB-Instance | Alle | Einmalig oder kontinuierlich | Minimal | Erstellen Sie eine Read Replica für die laufende Replikation. Stufen Sie die Read Replica für die einmalige Erstellung einer neuen DB-Instance hoch. | [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md) |
| Vorhandene MySQL-Datenbank | Small | Einmalig | Etwas | Kopieren Sie die Daten mit einem Befehlszeilen-Dienstprogramm direkt in die MySQL-DB-Instance. | [Importieren von Daten aus einer externen MySQL-Datenbank in eine DB-Instance von Amazon RDS für MySQL](mysql-importing-data-external-database.md) |
| Nicht in einer vorhandenen Datenbank gespeicherte Daten | Medium | Einmalig | Etwas | Erstellen Sie Flatfiles und importieren Sie diese mithilfe von MySQL-LOAD DATA LOCAL INFILE-Anweisungen. | [Importieren von Daten aus einer beliebigen Quelle in eine DB-Instance von Amazon RDS für MySQL](mysql-importing-data-any-source.md) |
**Anmerkung**
Die Systemdatenbank `mysql` enthält Authentifizierungs- und Autorisierungsinformationen, die für die Anmeldung bei der DB-Instance und für den Zugriff auf die Daten erforderlich sind. Das Verwerfen, Verändern, Umbenennen oder Verkürzen von Tabellen, Daten oder anderen Inhalten der `mysql`-Datenbank in der DB-Instance kann zu Fehlern führen und den Zugriff auf die DB-Instance und die Daten verhindern. In diesem Fall können Sie die DB-Instance mithilfe des AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)Befehls aus einem Snapshot wiederherstellen. Sie können die DB-Instance mit dem AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)Befehl wiederherstellen.
# Überlegungen zum Importieren von Daten für MySQL
Der folgende Inhalt enthält technische Informationen zum Laden von Daten in MySQL. Dieser Inhalt richtet sich an Benutzer, die mit der MySQL-Serverarchitektur vertraut sind.
## Binärprotokollierung
Durch die Aktivierung der Binärprotokollierung wird die Leistung beim Laden von Daten reduziert und bis zu viermal mehr zusätzlicher Speicherplatz als bei deaktivierter Protokollierung benötigt. Die zum Laden der Daten verwendete Transaktionsgröße wirkt sich direkt auf die Systemleistung und den Speicherplatzbedarf aus. Größere Transaktionen erfordern mehr Ressourcen.
## Transaktionsgröße
Die Transaktionsgröße beeinflusst die folgenden Aspekte bei MySQL-Datenladevorgängen:
+ Ressourcennutzung
+ Auslastung des Festplattenspeichers
+ Fortsetzen des Vorgangs
+ Zeit für die Wiederherstellung
+ Eingabeformat (Flatfiles oder SQL)
In diesem Abschnitt wird beschrieben, wie sich die Transaktionsgröße auf die binäre Protokollierung auswirkt, und verdeutlicht, welche Vorteile das Deaktivieren der binären Protokollierung bei umfangreichen Datenladevorgängen mit sich bringen kann. Die binäre Protokollierung kann durch die Festlegung des automatischen Aufbewahrungszeitraums für Backups in Amazon RDS aktiviert und deaktiviert werden. Nicht-Null-Werte aktivieren die binäre Protokollierung und Null deaktiviert diese. Weitere Informationen finden Sie unter [Aufbewahrungszeitraum für Backups](USER_WorkingWithAutomatedBackups.BackupRetention.md).
In diesem Abschnitt wird auch die Auswirkung von großen Transaktionen auf InnoDB beschrieben und warum es so wichtig ist, die Transaktionsgröße klein zu halten.
### Kleine Transaktionen
Bei kleinen Transaktionen sorgt die binäre Protokollierung für eine Verdopplung der Schreibvorgänge auf der Festplatte, die für das Laden der Daten erforderlich sind. Dieser Effekt kann die Leistung für andere Datenbanksitzungen signifikant herabsetzen und die zum Laden der Daten erforderliche Zeit erhöhen. Wie stark die Leistungseinbuße ist, hängt teilweise von folgenden Faktoren ab:
+ Upload-Rate
+ Andere Datenbankaktivitäten während des Ladevorgangs
+ Kapazität der Amazon-RDS-DB-Instance
Die binären Protokolle benötigen zudem fast genau soviel Speicherplatz wie die Datenladevorgänge, bis sie gesichert und entfernt wurden. Amazon RDS minimiert dies durch häufige Backup-Vorgänge und Löschen von Binärprotokollen.
### Große Transaktionen
Bei großen Transaktionen verdreifacht die binäre Protokollierung die IOPS (Ein-/Ausgabe pro Sekunde) und die Festplattennutzung aus den folgenden Gründen:
+ Der Binärprotokoll-Cache speichert Transaktionsdaten vorübergehend auf der Festplatte.
+ Dieser Cache wächst mit der Transaktionsgröße an, wodurch Speicherplatz belegt wird.
+ Wenn die Transaktion (Commit oder Rollback) abgeschlossen ist, wird der Cache vom System in das Binärprotokoll kopiert.
Bei diesem Vorgang werden drei Kopien von Daten erstellt:
+ Originaldaten
+ Cache auf der Festplatte
+ Letzter binärer Protokolleintrag
Jeder Schreibvorgang verursacht zusätzliche E/A-Vorgänge, was sich weiter auf die Leistung auswirkt.
Aus diesem Grund benötigt die binäre Protokollierung dreimal so viel Speicherplatz wie die deaktivierte Protokollierung. Wenn Sie beispielsweise 10 GiB Daten als eine einzelne Transaktion laden, werden drei Kopien erstellt:
+ 10 GiB für die Tabellendaten
+ 10 GiB für den Binärprotokoll-Cache
+ 10 GiB für die Binärprotokolldatei
Der gesamte benötigte temporäre Speicherplatz beträgt 30 GiB.
Wichtige Überlegungen zum Speicherplatz:
+ Die Cache-Datei wird so lange beibehalten, bis die Sitzung endet oder durch eine neue Transaktion ein weiterer Cache erstellt wird.
+ Das Binärprotokoll wird so lange beibehalten, bis es gesichert wurde, und kann über einen längeren Zeitraum möglicherweise 20 GiB (Cache und Protokoll) enthalten.
Wenn Sie `LOAD DATA LOCAL INFILE` zum Laden der Daten verwenden, wird bei der Datenwiederherstellung eine vierte Kopie für den Fall erstellt, dass die Datenbank aus einem vor dem Ladevorgang durchgeführten Backup wiederhergestellt werden muss. Während der Wiederherstellung extrahiert MySQL die Daten aus dem Binärprotokoll in eine Flat-File. MySQL führt dann `LOAD DATA LOCAL INFILE` aus. Basierend auf dem vorherigen Beispiel benötigt diese Wiederherstellung insgesamt einen temporären Speicherplatz von 40 GiB bzw. jeweils 10 GiB für Tabellen, Caches, Protokolle und lokale Dateien. Wenn nicht mindestens 40 GiB freier Speicherplatz zur Verfügung steht, schlägt die Wiederherstellung fehl.
### Optimieren von großen Datenladevorgängen
Deaktivieren Sie die Binärprotokollierung bei großen Datenladevorgängen, um den Aufwand und Speicherplatzbedarf zu reduzieren. Sie können die Binärprotokollierung deaktivieren, indem Sie den Aufbewahrungszeitraum für Backups auf Null festlegen. Setzen Sie den Wert für den Aufbewahrungszeitraum für Backups auf den entsprechenden Nicht-Null-Wert zurück, nachdem der Ladevorgang abgeschlossen wurde. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md) und [Aufbewahrungszeitraum für Backups](USER_ModifyInstance.Settings.md) in der Einstellungstabelle.
**Anmerkung**
Sie können den Aufbewahrungszeitraum für Backups nicht auf Null festlegen, wenn es sich bei der DB-Instance um eine Quell-DB-Instance für Lesereplikate handelt.
Vor dem Laden von Daten empfehlen wir Ihnen, einen DB-Snapshot zu erstellen. Weitere Informationen finden Sie unter [Verwalten manueller Backups](USER_ManagingManualBackups.md).
## InnoDB
Die folgenden Informationen zu der Undo-Protokollierung und den Wiederherstellungsoptionen helfen Ihnen dabei, InnoDB-Transaktionen klein zu halten, um die Datenbankleistung zu optimieren.
### Grundlagen zur Undo-Protokollierung in InnoDB
Undo ist ein Protokollierungsmechanismus, der die Rücksetzung von Transaktionen ermöglicht und MVCC (Multi-Version Concurrency Control, Parallelitätskontrolle für mehrere Versionen) unterstützt.
Bei MySQL 5.7 und älteren Versionen werden Undo-Protokolle im InnoDB-System-Tablespace (normalerweise ibdata1) gespeichert und so lange beibehalten, bis sie vom Bereinigungs-Thread entfernt werden. Daher können große Datenladetransaktionen dazu führen, dass der System-Tablespace sehr groß wird und Speicherplatz belegt, der erst zurückgewonnen werden kann, wenn die Datenbank neu erstellt wird.
Bei allen MySQL-Versionen muss der Bereinigungs-Thread auf das Löschen der Undo-Protokolle warten, bis die älteste aktive Transaktion entweder festgeschrieben oder zurückgesetzt wurde. Wenn die Datenbank während des Ladevorgangs andere Transaktionen verarbeitet, sammeln sich auch ihre Undo-Protokolle an, die nicht entfernt werden können, selbst wenn die Transaktionen festgeschrieben wurden und keine andere Transaktion die Undo-Protokolle für MVCC benötigt. In dieser Situation werden alle Transaktionen langsamer, auch schreibgeschützte Transaktionen. Diese Verlangsamung ist darauf zurückzuführen, dass alle Transaktionen auf alle Zeilen zugreifen, die von jeder Transaktion und nicht nur von der Ladetransaktion geändert werden. Tatsächlich müssen Transaktionen Undo-Protokolle durchsuchen, deren Löschung durch lang andauernde Ladetransaktionen während einer Bereinigung von Undo-Protokollen verhindert wurde. Dies beeinträchtigt die Leistung aller Vorgänge, die auf geänderte Zeilen zugreifen.
### Optionen zur Wiederherstellung von Transaktionen in InnoDB
Obwohl InnoDB Commit-Vorgänge optimiert, sind große Transaktions-Rollbacks langsam. Führen Sie für eine schnellere Wiederherstellung eine point-in-time Wiederherstellung durch oder stellen Sie einen DB-Snapshot wieder her. Weitere Informationen erhalten Sie unter [Point-in-time Erholung](USER_PIT.md) und [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
## Datenimportformate
MySQL unterstützt zwei Datenimportformate: Flatfiles und SQL. Lesen Sie die Informationen zum jeweiligen Format, um die beste Option für Ihre Anforderungen zu ermitteln.
### Flache Dateien
Laden Sie Flatfiles für kleine Transaktionen mithilfe von `LOAD DATA LOCAL INFILE`. Dieses Datenimportformat bietet die folgenden Vorteile gegenüber der Verwendung von SQL:
+ Weniger Netzwerkverkehr
+ Niedrigere Datenübertragungskosten
+ Geringerer Aufwand für die Verarbeitung von Datenbanken
+ Schnellere Verarbeitung
`LOAD DATA LOCAL INFILE` lädt die gesamte Flatfile als eine Transaktion. Halten Sie die Größe der einzelnen Dateien klein, um die folgenden Vorteile zu erzielen:
+ **Fortgesetzte Leistungsfähigkeit**: Sie können nachverfolgen, welche Dateien geladen wurden. Wenn während des Ladevorgangs ein Problem auftritt, können Sie dort fortfahren, wo Sie aufgehört haben. Einige Daten müssen eventuell erneut an Amazon RDS übertragen werden. Bei kleinen Dateien ist die Menge der erneut zu übertragenden Daten allerdings minimal.
+ **Paralleles Laden der Daten**: Wenn Sie genügend IOPS und die erforderliche Netzwerkbandbreite für das Laden einer einzelnen Datei haben, können parallele Ladevorgänge Zeit sparen.
+ **Steuerung der Laderate**: Wenn sich der Datenladevorgang negativ auf andere Prozesse auswirkt, können Sie die Laderate steuern, indem Sie das Intervall zwischen den Dateien verlängern.
Große Transaktionen verringern die Vorteile, die sich aus der Verwendung von `LOAD DATA LOCAL INFILE` zum Importieren der Daten ergeben. Wenn Sie eine große Datenmenge nicht in kleinere Dateien aufteilen können, sollten Sie SQL verwenden.
### SQL
SQL hat einen Hauptvorteil gegenüber Flatfiles: Damit ist es einfach, Transaktionen klein zu halten. Jedoch kann ein Ladevorgang mit SQL deutlich länger dauern als mit Flatfiles. Außerdem kann es nach einem Fehler schwierig sein, zu ermitteln, wo der Ladevorgang fortgesetzt werden soll, da mysqldump-Dateien nicht neu gestartet werden können. Wenn während des Ladens einer mysqldump-Datei ein Fehler auftritt, müssen Sie die Datei ändern oder ersetzen, damit der Ladevorgang fortgesetzt werden kann. Alternativ können Sie auch nach dem Beheben der Fehlerursache eine Wiederherstellung auf einen Zeitpunkt vor dem Ladevorgang durchführen und die Datei erneut senden. Weitere Informationen finden Sie unter [Point-in-time Erholung](USER_PIT.md).
## Verwenden von Amazon-RDS-DB-Snapshots für Datenbankprüfpunkte
Wenn Sie Daten über lange Zeiträume, z. B Stunden oder Tage, ohne die Binärprotokollierung laden, verwenden Sie DB-Snapshots, um regelmäßige Prüfpunkte für die Datensicherheit bereitzustellen. Jeder DB-Snapshot erstellt eine konsistente Kopie Ihrer Datenbank-Instance, die bei Systemausfällen oder Datenbeschädigungen als Wiederherstellungspunkt dient. Da DB-Snapshots schnell erstellt werden, hat das Festlegen häufiger Prüfpunkte nur minimale Auswirkungen auf die Ladeleistung. Sie können vorherige DB-Snapshots löschen, ohne die Dauerhaftigkeit der Datenbank oder die Wiederherstellungsfunktionen zu beeinträchtigen. Weitere Informationen zu DB-Snapshots finden Sie unter [Verwalten manueller Backups](USER_ManagingManualBackups.md).
## Verkürzen der Ladezeit von Datenbanken
Im Folgenden sind zusätzliche Tipps zum Verringern der Ladezeit aufgeführt:
+ Erstellen Sie alle sekundären Indizes, bevor Sie Daten in MySQL-Datenbanken laden. Im Gegensatz zu anderen Datenbanksystemen erstellt MySQL die gesamte Tabelle neu, wenn sekundäre Indizes hinzugefügt oder geändert werden. Dieser Prozess erstellt eine neue Tabelle mit Indexänderungen, kopiert alle Daten und löscht die Originaltabelle.
+ Laden Sie Daten in der Reihenfolge der Primärschlüssel. Für InnoDB-Tabellen kann hierdurch die Ladezeit um 75 bis 80 % und die Datendateigröße um 50 % reduziert werden.
+ Deaktivieren Sie Fremdschlüsselbeschränkungen, indem Sie `foreign_key_checks` auf `0` festlegen. Dies ist häufig für Flatfiles erforderlich, die mit `LOAD DATA LOCAL INFILE` geladen werden. Durch Deaktivieren von Fremdschlüsselprüfungen werden jegliche Datenladevorgänge beschleunigt. Aktivieren Sie nach Abschluss des Ladevorgangs die Einschränkungen erneut, indem Sie `foreign_key_checks` auf `1` festlegen, und überprüfen Sie die Daten.
+ Laden Sie Daten parallel, es sei denn, Sie nähern sich einer Ressourcenbegrenzung. Verwenden Sie gegebenenfalls partitionierte Tabellen, um gleichzeitige Ladevorgänge über mehrere Tabellensegmente hinweg zu ermöglichen.
+ Um den Aufwand bei der SQL-Ausführung zu reduzieren, kombinieren Sie mehrere `INSERT`-Anweisungen in einzelne `INSERT`-Vorgänge mit mehreren Werten. `mysqldump`implementiert diese Optimierung automatisch.
+ Verringern Sie InnoDB-Protokoll-E/A-Vorgänge, indem Sie `innodb_flush_log_at_trx_commit` auf `0` festlegen. Setzen Sie `innodb_flush_log_at_trx_commit` nach Abschluss des Ladevorgangs wieder auf `1` zurück.
**Warnung**
Wenn `innodb_flush_log_at_trx_commit` auf `0` festgelegt wird, führt dies dazu, dass die Protokolle in InnoDB jede Sekunde anstatt bei jedem Commit bereinigt werden. Diese Einstellung erhöht zwar die Leistung, kann jedoch bei Systemausfällen zu Transaktionsverlusten führen.
+ Wenn Sie Daten in eine DB-Instance laden, in der keine Lesereplikate vorhanden sind, legen Sie `sync_binlog` auf `0` fest. Setzen Sie `sync_binlog parameter` nach Abschluss des Ladevorgangs wieder auf `1` zurück.
+ Laden Sie die Daten in eine Single-AZ-DB-Instance, bevor Sie die DB-Instance in eine Multi-AZ-Bereitstellung konvertieren. Wenn die DB-Instance bereits eine Multi-AZ-Bereitstellung verwendet, empfehlen wir Ihnen nicht, zwecks Laden von Daten zu einer Single-AZ-Bereitstellung zu wechseln. Dies führt nur zu geringfügigen Verbesserungen.
# Wiederherstellen eines Backups in eine DB-Instance von Amazon RDS für MySQL
Amazon RDS unterstützt den Import von MySQL-Datenbanken mithilfe von Backup-Dateien. Sie können ein Backup der Datenbank erstellen, die Backup-Datei in Amazon S3 speichern und anschließend auf einer neuen Amazon-RDS-DB-Instance wiederherstellen, auf der MySQL ausgeführt wird. Amazon RDS unterstützt den Import von Backup-Dateien aus Amazon S3 in allen AWS-Regionen.
Im in diesem Abschnitt beschriebenen Szenario wird ein Backup einer On-Premise-Datenbank wiederhergestellt. Sie können diese Technik für Datenbanken an anderen Speicherorten verwenden, z. B. in Amazon EC2 oder anderen Cloud-Services, solange der Zugriff auf die Datenbank unterstützt wird.
Das folgende Diagramm veranschaulicht das unterstützte Szenario.
![\[MySQL importiert Backup-Dateien von S3.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MySQL-bak-file.png)
Wenn die On-Premise-Datenbank beim Erstellen, Kopieren und Wiederherstellen der Backup-Dateien offline sein kann, wird empfohlen, dass Sie die Datenbank mithilfe von Backup-Dateien in Amazon RDS importieren. Wenn die Datenbank nicht offline sein darf, können Sie eine der folgenden Methoden verwenden:
+ **Binärprotokolle**: Importieren Sie zunächst Backup-Dateien von Amazon S3 in Amazon RDS, wie in diesem Thema erläutert. Verwenden Sie dann die Binärprotokollreplikation (binlog), um die Datenbank zu aktualisieren. Weitere Informationen finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
+ **AWS Database Migration Service**— Wird verwendet AWS Database Migration Service , um Ihre Datenbank zu Amazon RDS zu migrieren. Weitere Informationen finden Sie unter [Was ist AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
## Übersicht über die Einrichtung zum Importieren von Backup-Dateien von Amazon S3 in Amazon RDS
Sie benötigen die folgenden Komponenten, um Backup-Dateien von Amazon S3 in Amazon RDS zu importieren:
+ Einen Amazon S3-Bucket zum Speichern Ihrer Sicherungsdateien
Wenn Sie bereits über einen Amazon-S3-Bucket verfügen, können Sie diesen verwenden. Wenn noch kein Amazon-S3-Bucket vorliegt, können Sie einen neuen erstellen. Weitere Informationen finden Sie unter [Bucket erstellen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html).
+ Ein von XtraBackup Percona erstelltes Backup Ihrer lokalen Datenbank.
Weitere Informationen finden Sie unter [Erstellen Ihrer Datenbanksicherung](#MySQL.Procedural.Importing.Backup).
+ Eine AWS Identity and Access Management (IAM-) Rolle, die Amazon RDS den Zugriff auf den S3-Bucket ermöglicht.
Wenn Sie bereits über eine IAM-Rolle verfügen, können Sie diese verwenden und ihr Vertrauens- und Berechtigungsrichtlinien hinzufügen. Weitere Informationen finden Sie unter [Manuelles Erstellen einer IAM-Rolle](#MySQL.Procedural.Importing.Enabling.IAM).
Wenn Sie noch keine IAM-Rolle besitzen, haben Sie zwei Möglichkeiten:
+ Sie können eine neue IAM-Rolle manuell erstellen. Weitere Informationen finden Sie unter [Manuelles Erstellen einer IAM-Rolle](#MySQL.Procedural.Importing.Enabling.IAM).
+ Sie können auswählen, ob Amazon RDS eine neue IAM-Rolle für Sie erstellen soll. Wenn Sie möchten, dass Amazon RDS eine neue IAM-Rolle für Sie erstellt, folgen Sie dem Verfahren, das den [Importieren von Daten aus Amazon S3 in eine neue MySQL-DB-Instance](#MySQL.Procedural.Importing.PerformingImport) Abschnitt AWS-Managementkonsole in verwendet.
## Erstellen Ihrer Datenbanksicherung
Verwenden Sie die XtraBackup Percona-Software, um Ihr Backup zu erstellen. Wir empfehlen Ihnen, die neueste Version von XtraBackup Percona zu verwenden. Sie können Percona XtraBackup über [Software-Downloads](https://www.percona.com/downloads/) auf der Percona-Website installieren.
**Warnung**
Beim Erstellen einer Datenbanksicherung werden XtraBackup möglicherweise Anmeldeinformationen in der Datei xtrabackup\$1info gespeichert. Vergewissern Sie sich, dass die Einstellung `tool_command` in der xtrabackup\$1info-Datei keine vertraulichen Informationen enthält.
Welche XtraBackup Percona-Version Sie verwenden, hängt von der MySQL-Version ab, die Sie sichern.
+ **MySQL 8.4** — Verwenden Sie Percona XtraBackup Version 8.4.
+ **MySQL 8.0** — Verwenden Sie Percona XtraBackup Version 8.0.
**Anmerkung**
Percona XtraBackup 8.0.12 und höhere Versionen unterstützen die Migration aller Versionen von MySQL 8.0. Wenn Sie zu RDS für MySQL 8.0.32 oder höher migrieren, müssen Sie Percona XtraBackup 8.0.12 oder höher verwenden.
+ **MySQL 5.7** — Verwenden Sie Percona XtraBackup Version 2.4.
Sie können Percona verwenden XtraBackup , um eine vollständige Sicherung Ihrer MySQL-Datenbankdateien zu erstellen. Wenn Sie Percona bereits XtraBackup zum Sichern Ihrer MySQL-Datenbankdateien verwenden, können Sie alternativ Ihre vorhandenen vollständigen und inkrementellen Backup-Verzeichnisse und -Dateien hochladen.
Weitere Informationen zur Sicherung Ihrer Datenbank mit Percona finden Sie unter [Percona XtraBackup XtraBackup — Dokumentation auf der Percona-Website](https://www.percona.com/doc/percona-xtrabackup/LATEST/index.html).
### Erstellen Sie ein vollständiges Backup mit Percona XtraBackup
Verwenden Sie das XtraBackup Percona-Hilfsprogramm (`xtrabackup`), um eine vollständige Sicherung Ihrer MySQL-Datenbankdateien zu erstellen, die Amazon RDS aus Amazon S3 wiederherstellen kann.
Mit dem folgenden Befehl können Sie beispielsweise ein Backup einer MySQL-Datenbank erstellen und die Dateien im Ordner `/on-premises/s3-restore/backup` speichern.
```
xtrabackup --backup --user=myuser --password=password --target-dir=/on-premises/s3-restore/backup
```
Wenn Sie das Backup in einer einzelnen Datei komprimieren möchten (die gegebenenfalls später in mehrere Dateien aufgeteilt werden kann), können Sie das Backup je nach Ihrer MySQL-Version in einem der folgenden Formate speichern:
+ **Gzip (.gz)**: Für MySQL 5.7 und frühere Versionen
+ **tar (.tar)**: Für MySQL 5.7 und frühere Versionen
+ **Percona xbstream (.xbstream)**: Für alle MySQL-Versionen
**Anmerkung**
Percona XtraBackup 8.0 und höher unterstützt nur Percona xbstream für die Komprimierung.
**MySQL 5.7 und frühere Versionen**
Mit dem folgenden Befehl wird ein Backup einer MySQL-Datenbank erstellt und in mehreren Gzip-Dateien gespeichert. Ersetzen Sie die Werte durch Ihre Angaben.
```
xtrabackup --backup --user=my_user --password=password --stream=tar \
--target-dir=/on-premises/s3-restore/backup | gzip - | split -d --bytes=500MB \
- /on-premises/s3-restore/backup/backup.tar.gz
```
**MySQL 5.7 und frühere Versionen**
Mit dem folgenden Befehl wird ein Backup einer MySQL-Datenbank erstellt und in mehreren tar-Dateien gespeichert. Ersetzen Sie die Werte durch Ihre Angaben.
```
xtrabackup --backup --user=my_user --password=password --stream=tar \
--target-dir=/on-premises/s3-restore/backup | split -d --bytes=500MB \
- /on-premises/s3-restore/backup/backup.tar
```
**Alle MySQL-Versionen**
Mit dem folgenden Befehl wird ein Backup einer MySQL-Datenbank erstellt und in mehreren xbstream-Dateien gespeichert. Ersetzen Sie die Werte durch Ihre Angaben.
```
xtrabackup --backup --user=myuser --password=password --stream=xbstream \
--target-dir=/on-premises/s3-restore/backup | split -d --bytes=500MB \
- /on-premises/s3-restore/backup/backup.xbstream
```
**Anmerkung**
Wenn der folgende Fehler angezeigt wird, haben Sie möglicherweise unterschiedliche Dateiformate in Ihrem Befehl verwendet:
```
ERROR:/bin/tar: This does not look like a tar archive
```
### Verwendung inkrementeller Backups mit Percona XtraBackup
Wenn Sie Percona bereits verwenden XtraBackup , um vollständige und inkrementelle Backups Ihrer MySQL-Datenbankdateien durchzuführen, müssen Sie kein vollständiges Backup erstellen und die Sicherungsdateien auf Amazon S3 hochladen. Um Zeit zu sparen, können Sie stattdessen die vorhandenen Backup-Verzeichnisse und -Dateien in den Amazon-S3-Bucket kopieren. Weitere Informationen zum Erstellen inkrementeller Backups mit Percona XtraBackup finden Sie unter [Erstellen eines inkrementellen Backups](https://docs.percona.com/percona-xtrabackup/LATEST/create-incremental-backup.html) auf der Percona-Website.
Wenn Sie die Dateien der vollständigen und inkrementellen Backups in einen Amazon S3-Bucket hochladen, müssen Sie den Inhalt des Basisverzeichnisses rekursiv kopieren. Es müssen sämtliche Verzeichnisse und Dateien der vollständigen und inkrementellen Backups enthalten sein. Diese Kopie muss die Verzeichnisstruktur im Amazon-S3-Bucket beibehalten. Amazon RDS durchläuft alle Dateien und Verzeichnisse. Amazon RDS verwendet die in jedem inkrementellen Backup enthaltene Datei `xtrabackup-checkpoints`, um das Basisverzeichnis zu identifizieren und inkrementelle Backups nach dem Bereich der Protokollsequenznummer (Log Sequence Number, LSN) zu ordnen.
### Überlegungen zum Backup für Percona XtraBackup
Amazon RDS verarbeitet Sicherungsdateien auf Basis des Dateinamens. Benennen Sie die Backup-Dateien mit der entsprechenden Dateierweiterung basierend auf dem Dateiformat. Verwenden Sie beispielsweise `.xbstream` für Dateien, die im xbstream-Format von Percona gespeichert werden.
Amazon RDS verarbeitet Sicherungsdateien in alphanumerischer Reihenfolge. Verwenden Sie die Option `split` für den Befehl `xtrabackup`, um sicherzustellen, dass die Backup-Dateien in der richtigen Reihenfolge geschrieben und benannt werden.
Amazon RDS unterstützt keine Teilsicherungen, die mit Percona XtraBackup erstellt wurden. Sie können beim Backup der Quelldateien Ihrer Datenbank nicht die folgenden Optionen zum Erstellen eines partiellen Backups verwenden:
+ `--tables`
+ `--tables-exclude`
+ `--tables-file`
+ `--databases`
+ `--databases-exclude`
+ `--databases-file`
## Manuelles Erstellen einer IAM-Rolle
Wenn Sie noch keine IAM-Rolle besitzen, können Sie manuell eine neue erstellen. Wenn Sie die Datenbank jedoch mithilfe von wiederherstellen AWS-Managementkonsole, empfehlen wir Ihnen, Amazon RDS diese neue IAM-Rolle für Sie erstellen zu lassen. Damit Amazon RDS diese Rolle für Sie erstellen kann, führen Sie die im Abschnitt [Importieren von Daten aus Amazon S3 in eine neue MySQL-DB-Instance](#MySQL.Procedural.Importing.PerformingImport) beschriebenen Schritte aus.
Wenn Sie eine neue IAM-Rolle zum Importieren der Datenbank aus Amazon S3 manuell erstellen, erstellen Sie eine Rolle, um Berechtigungen von Amazon RDS an den Amazon-S3-Bucket weiterzugeben. Beim Anlegen einer IAM-Rolle geben Sie Vertrauens- und Berechtigungsrichtlinien an. Um Ihre Backup-Dateien aus Amazon S3 zu importieren, verwenden Sie Vertrauens- und Berechtigungsrichtlinien, ähnlich den folgenden Beispielen. Weitere Informationen zum Erstellen der Rolle finden Sie unter Eine Rolle [erstellen, um Berechtigungen an einen Service zu delegieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). AWS
Für die Vertrauens- und Berechtigungsrichtlinien müssen Sie einen Amazon-Ressourcennamen (ARN) angeben. Weitere Informationen zur ARN-Formatierung finden Sie unter [Amazon Resource Names (ARNs) und AWS Service-Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
**Example Vertrauensrichtlinie für den Import aus Amazon S3**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AssumeRoleForBackup",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
**Example Berechtigungsrichtlinie für den Import aus Amazon S3 – IAM-Benutzerberechtigungen**
Ersetzen Sie im folgenden Beispiel durch Ihren *iam\$1user\$1id* eigenen Wert.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowS3AccessRole",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/S3Access"
}
]
}
```
**Example Berechtigungsrichtlinie für den Import aus Amazon S3 – Rollenberechtigungen**
Ersetzen Sie im folgenden Beispiel *amzn-s3-demo-bucket* und *prefix* durch Ihre eigenen Werte.
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action":
[
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/prefix*"
},
{
"Effect": "Allow",
"Action":
[
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/key_id*"
]
}
]
}
```
Wenn Sie ein Dateinamen-Präfix einfügen, fügen Sie das Sternchen (\$1) nach dem Präfix ein. Wenn Sie kein Präfix verwenden möchten, geben Sie nur ein Sternchen ein.
## Importieren von Daten aus Amazon S3 in eine neue MySQL-DB-Instance
Mit der, oder RDS-API können Sie Daten aus Amazon S3 in eine neue MySQL-DB-Instance importieren. AWS-Managementkonsole AWS CLI
### Konsole
**Um Daten aus Amazon S3 in eine neue MySQL DB-Instance zu importieren**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie in der oberen rechten Ecke der Amazon RDS-Konsole den Ort aus, AWS-Region an dem Sie Ihre DB-Instance erstellen möchten. Wählen Sie dasselbe AWS-Region wie für den Amazon S3 S3-Bucket, der Ihr Datenbank-Backup enthält.
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie **Von S3 wiederherstellen**.
Die Seite **Datenbank durch Wiederherstellen von S3 erstellen** wird angezeigt.
![\[Die Seite Datenbank durch Wiederherstellen von S3 erstellen, in der Sie die Details zum Wiederherstellen einer DB-Instance aus S3 angeben.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/mys-s3-ingestion.png)
1. Unter **S3-Quelle**:
1. Wählen Sie den **S3 bucket** (S3-Bucket) aus, in dem sich das Backup befindet.
1. (Optional) Geben Sie für das **S3-Präfix** ein Dateipfadpräfix für die Dateien ein, die im Amazon-S3-Bucket gespeichert sind.
Wenn Sie kein Präfix angeben, dann erstellt Amazon RDS Ihre DB-Instance unter Verwendung aller Dateien und Ordner im Stammordner des S3-Bucket. Wenn Sie ein Präfix angeben, erstellt Amazon RDS Ihre DB-Instance mit den Ordnern und Dateien im S3-Bucket, deren vollständiger Pfadname mit dem angegebenen Präfix beginnt.
Beispiel: Sie speichern Backup-Dateien auf S3 im Unterordner „backups“ und haben mehrere Sätze von Backup-Dateien, die sich jeweils in einem eigenen Verzeichnis befinden (gzip\$1backup1, gzip\$1backup2 usw.). In diesem Fall geben Sie das Präfix „backups/gzip\$1backup1“ an, um die Wiederherstellung mit den Dateien im Ordner „gzip\$1backup1“ durchzuführen.
1. Unter **Engine-Optionen**:
1. Wählen Sie in **Engine-Typ** die Option **MySQL** aus.
1. Wählen Sie für **Quellen-Engine-Version** die MySQL-Hauptversion Ihrer Quelldatenbank.
1. Wählen Sie unter **Engine-Version** die Standard-Nebenversion der MySQL-Hauptversion in der AWS-Region aus.
In der AWS-Managementkonsole ist nur die Standard-Nebenversion verfügbar. Nachdem Sie den Import abgeschlossen haben, können Sie die DB-Instance aktualisieren.
1. Erstellen Sie unter **IAM-Rolle** eine IAM-Rolle mit den erforderlichen Vertrauens- und Berechtigungsrichtlinien bzw. wählen Sie sie aus, die Amazon RDS den Zugriff auf den Amazon-S3-Bucket ermöglicht. Führen Sie eine der folgenden Aktionen aus:
+ (Empfohlen) Wählen Sie **Neue Rolle erstellen** aus und geben Sie den **IAM-Rollennamen** ein. Mit dieser Option erstellt Amazon RDS die Rolle mit der Vertrauens- und Berechtigungsrichtlinie automatisch für Sie.
+ Wählen Sie eine vorhandene IAM-Rolle aus. Vergewissern Sie sich, dass diese Rolle alle Kriterien unter [Manuelles Erstellen einer IAM-Rolle](#MySQL.Procedural.Importing.Enabling.IAM) erfüllt.
1. Geben Sie Ihre DB-Instance-Informationen an. Weitere Informationen zu den einzelnen Einstellungen finden Sie unter [Einstellungen für DB-Instances](USER_CreateDBInstance.Settings.md).
**Anmerkung**
Vergewissern Sie sich, dass Sie genügend Speicherplatz für Ihre neue DB-Instance zuweisen, damit die Wiederherstellung erfolgreich verlaufen kann.
Um eine zukünftige Speichererweiterung automatisch zu ermöglichen, wählen Sie unter **Zusätzliche Speicherkonfiguration** die Option **Automatische Speicherskalierung aktivieren** aus.
1. Wählen Sie zusätzliche Einstellungen wie erforderlich aus.
1. Wählen Sie **Create database (Datenbank erstellen)** aus.
### AWS CLI
Um Daten mit dem aus Amazon S3 in eine neue MySQL-DB-Instance zu importieren AWS CLI, führen Sie den Befehl [restore-db-instance-from-s3](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html) mit den folgenden Optionen aus. Weitere Informationen zu den einzelnen Einstellungen finden Sie unter [Einstellungen für DB-Instances](USER_CreateDBInstance.Settings.md).
**Anmerkung**
Vergewissern Sie sich, dass Sie genügend Speicherplatz für Ihre neue DB-Instance zuweisen, damit die Wiederherstellung erfolgreich verlaufen kann.
Verwenden Sie die Option `--max-allocated-storage`, um die automatische Speicherskalierung zu aktivieren und eine zukünftige Speichererweiterung automatisch zu ermöglichen.
+ `--allocated-storage`
+ `--db-instance-identifier`
+ `--db-instance-class`
+ `--engine`
+ `--master-username`
+ `--manage-master-user-password`
+ `--s3-bucket-name`
+ `--s3-ingestion-role-arn`
+ `--s3-prefix`
+ `--source-engine`
+ `--source-engine-version`
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds restore-db-instance-from-s3 \
2. --allocated-storage 250 \
3. --db-instance-identifier my_identifier \
4. --db-instance-class db.m5.large \
5. --engine mysql \
6. --master-username admin \
7. --manage-master-user-password \
8. --s3-bucket-name amzn-s3-demo-bucket \
9. --s3-ingestion-role-arn arn:aws:iam::account-number:role/rolename \
10. --s3-prefix bucket_prefix \
11. --source-engine my_sql \
12. --source-engine-version 8.0.32 \
13. --max-allocated-storage 1000
```
Für Windows:
```
1. aws rds restore-db-instance-from-s3 ^
2. --allocated-storage 250 ^
3. --db-instance-identifier my_identifier ^
4. --db-instance-class db.m5.large ^
5. --engine mysql ^
6. --master-username admin ^
7. --manage-master-user-password ^
8. --s3-bucket-name amzn-s3-demo-bucket ^
9. --s3-ingestion-role-arn arn:aws:iam::account-number:role/rolename ^
10. --s3-prefix bucket_prefix ^
11. --source-engine mysql ^
12. --source-engine-version 8.0.32 ^
13. --max-allocated-storage 1000
```
### RDS-API
Um Daten mithilfe der Amazon RDS-API aus Amazon S3 in eine neue MySQL-DB-Instance zu importieren, rufen Sie den Vorgang [Restore DBInstance FromS3 auf](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html).
## Einschränkungen und Überlegungen für das Importieren von Backup-Dateien von Amazon S3 in Amazon RDS
Die folgenden Einschränkungen und Überlegungen gelten für das Importieren von Backup-Dateien von Amazon S3 in eine DB-Instance von RDS für MySQL:
+ Sie können die Daten nur zu einer neuen DB-Instance migrieren, nicht zu einer bestehenden DB-Instance.
+ Sie müssen Percona verwenden XtraBackup , um Ihre Daten auf Amazon S3 zu sichern. Weitere Informationen finden Sie unter [Erstellen Ihrer Datenbanksicherung](#MySQL.Procedural.Importing.Backup).
+ Das Amazon-S3-Bucket und die DB-Instance von RDS für MySQL müssen sich in der gleichen AWS-Region befinden.
+ Sie können keine Wiederherstellung aus den folgenden Quellen durchführen:
+ Export eines DB-Instance-Snapshots nach Amazon S3. Sie können auch keine Daten von einem DB-Instance-Snapshot-Export zum Amazon-S3-Bucket migrieren.
+ Verschlüsselte Quelldatenbank. Sie können jedoch die zu migrierenden Daten verschlüsseln. Sie können die Daten während des Migrationsprozesses auch unverschlüsselt lassen.
+ MySQL 5.5- oder 5.6-Datenbank.
+ RDS für MySQL unterstützt Percona Server für MySQL nicht als Quelldatenbank, da sie `compression_dictionary*`-Tabellen im `mysql schema` enthalten kann.
+ RDS für MySQL unterstützt keine abwärtskompatible Migration für Haupt- und Nebenversionen. Sie können zum Beispiel keine Migration von MySQL 8.0 zu RDS für MySQL 5.7 und auch nicht von MySQL 8.0.32 zu RDS für MySQL 8.0.26 durchführen.
+ Amazon RDS unterstützt nicht den Import von Amazon S3 in die DB-Instance-Klasse „db.t2.micro“. Sie können jedoch eine Wiederherstellung in eine andere DB-Instance-Klasse durchführen und die DB-Instance-Klasse dann später ändern. Weitere Informationen zu Instance-Klassen finden Sie unter [Hardwarespezifikationen für DB-Instance-Klassen ](Concepts.DBInstanceClass.Summary.md).
+ Amazon S3 begrenzt die Größe einer Datei, die in einen Amazon S3-Bucket hochgeladen werden kann, auf 5 TB. Wenn eine Sicherungsdatei größer als 5 TB ist, müssen Sie die Sicherungsdatei in kleinere Dateien aufteilen.
+ Amazon RDS begrenzt die Anzahl der Dateien, die in ein Amazon S3-Bucket hochgeladen werden können, auf 1 Million. Wenn es mehr als mehr als 1 Million Sicherungsdateien für Ihre Datenbank gibt (einschließlich aller vollständigen und inkrementellen Backups), speichern Sie diese mittels Gzip (.gz), tar (.tar.gz) oder Percona xbstream (.xbstream) im Amazon S3-Bucket. Percona XtraBackup 8.0 unterstützt nur Percona xbstream für die Komprimierung.
+ Um Verwaltungsservices für die jeweilige DB-Instance bereitzustellen, legt Amazon RDS den Benutzer `rdsadmin` an, wenn die DB-Instance erstellt wird. Da `rdsamin` ein reservierter Benutzer in Amazon RDS ist, gelten die folgenden Einschränkungen:
+ Funktionen, Prozeduren, Ansichten, Ereignisse und Auslöser mit dem Definierer `'rdsadmin'@'localhost'` werden in Amazon RDS nicht importiert. Weitere Informationen erhalten Sie unter [Gespeicherte Objekte mit 'rdsadmin'@'localhost' als Definierer](#MySQL.Procedural.Importing.StoredObjects) und [Berechtigungen von Hauptbenutzerkonten](UsingWithRDS.MasterAccounts.md).
+ Beim Erstellen der DB-Instance legt Amazon RDS einen Masterbenutzer mit den maximal unterstützten Berechtigungen an. Bei der Wiederherstellung anhand des Backups werden in Amazon RDS alle nicht unterstützten Berechtigungen, die den importierten Benutzern zugewiesen sind, automatisch entfernt.
Informationen zu Benutzern, die davon betroffen sein könnten, finden Sie unter [Benutzerkonten mit nicht unterstützten Rechten](#MySQL.Migrating.ExtMySQL.Prechecks.Users). Weitere Informationen zu den in RDS für MySQL unterstützten Berechtigungen finden Sie unter [Rollenbasiertes Berechtigungsmodell für RDS für MySQL](Appendix.MySQL.CommonDBATasks.privilege-model.md).
+ In Amazon RDS werden keine vom Benutzer erstellten Tabellen im Schema `mysql` migriert.
+ Sie dürfen den Parameter `innodb_data_file_path` nur mit einer Datendatei konfigurieren, die den Standarddateinamen `ibdata1:12M:autoextend` verwendet. Mit dieser Methode können Sie Datenbanken mit zwei Datendateien oder mit nur einer Datendatei eines anderen Namens migrieren.
Die folgenden Beispiele sind Dateinamen, die Amazon RDS nicht zulässt:
+ `innodb_data_file_path=ibdata1:50M`
+ `ibdata2:50M:autoextend`
+ `innodb_data_file_path=ibdata01:50M:autoextend`
+ Sie können nicht von einer Quelldatenbank migrieren, deren Tabellen außerhalb des standardmäßigen MySQL-Datenverzeichnisses definiert sind.
+ Die maximal unterstützte Größe für unkomprimierte Backups mit dieser Methode ist derzeit auf 64 TiB begrenzt. Bei komprimierten Backups ist dieser Grenzwert niedriger, um den Speicherplatzanforderungen bei der Dekomprimierung Rechnung zu tragen. In solchen Fällen ist die maximal unterstützte Backup-Größe `64 TiB - compressed backup size`.
Informationen zur maximal unterstützten Datenbankgröße, die von RDS für MySQL unterstützt wird, finden Sie unter [Allzweck-SSD-Speicher](CHAP_Storage.md#Concepts.Storage.GeneralSSD) und [Bereitgestellter IOPS SSD-Speicher](CHAP_Storage.md#USER_PIOPS).
+ Amazon RDS unterstützt den Import von MySQL und anderen externen Komponenten und Plugins nicht.
+ Amazon RDS stellt nicht alles anhand der Datenbank wieder her. Es wird empfohlen, das Datenbankschema und die Werte der folgenden Elemente der Quell-MySQL-Systemdatenbank zu speichern und diese zur wiederhergestellten DB-Instance von RDS für MySQL nach der Erstellung hinzufügen:
+ Benutzerkonten
+ Funktionen
+ Gespeicherte Prozeduren
+ Zeitzoneninformation. Die Zeitzoneninformationen werden vom lokalen Betriebssystem der DB-Instance von RDS für MySQL übernommen. Weitere Informationen finden Sie unter [Lokale Zeitzone für MySQL-DB-Instances](MySQL.Concepts.LocalTimeZone.md).
### Gespeicherte Objekte mit 'rdsadmin'@'localhost' als Definierer
Funktionen, Prozeduren, Ansichten, Ereignisse und Auslöser mit `'rdsadmin'@'localhost'` als Definierer werden in Amazon RDS nicht importiert.
Mit dem folgenden SQL-Skript können die in Ihrer MySQL-Datenbank gespeicherten Objekte mit nicht unterstützten Definierern auflisten.
```
-- This SQL query lists routines with `rdsadmin`@`localhost` as the definer.
SELECT
ROUTINE_SCHEMA,
ROUTINE_NAME
FROM
information_schema.routines
WHERE
definer = 'rdsadmin@localhost';
-- This SQL query lists triggers with `rdsadmin`@`localhost` as the definer.
SELECT
TRIGGER_SCHEMA,
TRIGGER_NAME,
DEFINER
FROM
information_schema.triggers
WHERE
DEFINER = 'rdsadmin@localhost';
-- This SQL query lists events with `rdsadmin`@`localhost` as the definer.
SELECT
EVENT_SCHEMA,
EVENT_NAME
FROM
information_schema.events
WHERE
DEFINER = 'rdsadmin@localhost';
-- This SQL query lists views with `rdsadmin`@`localhost` as the definer.
SELECT
TABLE_SCHEMA,
TABLE_NAME
FROM
information_schema.views
WHERE
DEFINER = 'rdsadmin@localhost';
```
### Benutzerkonten mit nicht unterstützten Rechten
Benutzerkonten mit Berechtigungen, die von RDS für MySQL nicht unterstützt werden, werden ohne die nicht unterstützten Berechtigungen importiert. Die Liste der unterstützten Rechte finden Sie unter [Rollenbasiertes Berechtigungsmodell für RDS für MySQL](Appendix.MySQL.CommonDBATasks.privilege-model.md).
Sie können die folgende SQL-Abfrage in Ihrer Quelldatenbank ausführen, um die Benutzerkonten aufzulisten, die nicht unterstützte Rechte haben.
```
SELECT
user,
host
FROM
mysql.user
WHERE
Shutdown_priv = 'y'
OR File_priv = 'y'
OR Super_priv = 'y'
OR Create_tablespace_priv = 'y';
```
# Importieren von Daten aus einer externen MySQL-Datenbank in eine DB-Instance von Amazon RDS für MySQL
Sie können Daten aus einer vorhandenen MySQL-Datenbank in eine DB-Instance von RDS für MySQL importieren. Zu diesem Zweck kopieren Sie die Datenbank mit [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) und importieren sie direkt in die DB-Instance von RDS für MySQL. Das Befehlszeilen-Dienstprogramm `mysqldump` wird üblicherweise verwendet, um Backups zu erstellen und Daten von einem MySQL-Server zu einem anderen zu übertragen. Es ist in der MySQL-Clientsoftware enthalten.
**Anmerkung**
Wenn Sie große Datenmengen mit einer MySQL-DB-Instance importieren oder exportieren, ist es zuverlässiger und schneller, Daten mithilfe von `xtrabackup`-Backup-Dateien und Amazon S3 in und aus Amazon RDS zu verschieben. Weitere Informationen finden Sie unter [Wiederherstellen eines Backups in eine DB-Instance von Amazon RDS für MySQL](MySQL.Procedural.Importing.md).
Ein typischer `mysqldump`-Befehl für das Verschieben von Daten aus externen Datenbanken in eine Amazon-RDS-DB-Instance ähnelt dem folgenden Beispiel. Ersetzen Sie die Werte durch Ihre Angaben.
```
mysqldump -u local_user \
--databases database_name \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mysql -u RDS_user \
--port=port_number \
--host=host_name \
-pRDS_password
```
**Wichtig**
Lassen Sie ein Leerzeichen zwischen der Option `-p` und dem eingegeben Passwort.
Geben Sie als bewährte Sicherheitsmethode andere Anmeldeinformationen als die in diesem Beispiel angegebenen Prompts an.
Stellen Sie sicher, dass Sie die folgenden Empfehlungen und Überlegungen kennen:
+ Schließen Sie die folgenden Schemas aus der Dump-Datei aus:
+ `sys`
+ `performance_schema`
+ `information_schema`
Das Dienstprogramm `mysqldump` schließt diese Schemas standardmäßig aus.
+ Wenn Sie Benutzer und Rechte migrieren müssen, sollten Sie in Erwägung ziehen, ein Tool zu verwenden, das die Data Control Language (DCL) generiert, um sie neu zu erstellen, z. B. das [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html)Hilfsprogramm.
+ Um den Import durchzuführen, stellen Sie sicher, dass der Benutzer Zugriff auf die DB-Instance hat. Weitere Informationen finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
Die folgenden Parameter werden verwendet:
+ `-u local_user` – für die Angabe eines Benutzernamens. Beim ersten Gebrauch dieses Parameters geben Sie den Namen eines Benutzerkontos in der lokalen MySQL-Datenbank an, die durch den Parameter `--databases` identifiziert wird.
+ `--databases database_name`: für die Angabe des Datenbanknamens in der lokalen MySQL-Instance, die Sie in Amazon RDS importieren möchten.
+ `--single-transaction`: zur Sicherstellung, dass alle aus der lokalen Datenbank geladenen Daten mit einem einzelnen Zeitpunkt übereinstimmen Wenn andere Prozesse die Daten ändern, während diese von `mysqldump` gelesen werden, kann durch die Verwendung dieses Parameters die Datenintegrität erhalten bleiben.
+ `--compress`: für die Reduzierung des Verbrauchs der Netzwerkbandbreite, indem Daten vor dem Sendevorgang aus der lokalen Datenbank an Amazon RDS komprimiert werden.
+ `--order-by-primary`: für die Reduzierung der Ladezeit durch Sortieren der Daten jeder Tabelle nach entsprechendem Primärschlüssel
+ `--routines`: Verwenden Sie diese Option, wenn Routinen wie gespeicherte Prozeduren oder Funktionen in der Datenbank vorhanden sind, die Sie kopieren. Legen Sie den Parameter auf `0` fest, wodurch die Routinen während des Importvorgangs ausgeschlossen werden. Erstellen Sie die Routinen dann später manuell in der Amazon-RDS-Datenbank neu.
+ `--triggers`: Verwenden Sie diese Option, wenn in der Datenbank, die Sie kopieren, Auslöser vorhanden sind. Legen Sie den Parameter auf `0` fest, wodurch die Auslöser während des Importvorgangs ausgeschlossen werden. Erstellen Sie die Auslöser dann später manuell in der Amazon-RDS-Datenbank neu.
+ `--events`: Verwenden Sie diese Option, wenn in der Datenbank, die Sie kopieren, Ereignisse vorhanden sind. Legen Sie den Parameter auf `0` fest, wodurch die Ereignisse während des Importvorgangs ausgeschlossen werden. Erstellen Sie die Ereignisse dann später manuell in der Amazon-RDS-Datenbank neu.
+ `-plocal_password` – für die Angabe eines Passworts. Beim ersten Gebrauch dieses Parameters geben Sie das Passwort für das Benutzerkonto an, das durch den ersten Parameter `-u` gekennzeichnet ist.
+ `-u RDS_user` – für die Angabe eines Benutzernamens. Beim zweiten Gebrauch dieses Parameters geben Sie den Namen eines Benutzerkontos in der Standarddatenbank für die MySQL-DB-Instance an, die durch den Parameter `--host` gekennzeichnet ist.
+ `--port port_number` – für die Angabe des Ports für die MySQL-DB-Instance. Standardmäßig ist dieser Wert auf 3306 festgelegt, außer Sie haben ihn beim Erstellen der DB-Instance geändert.
+ `--host host_name` – für die Angabe des Domain-Name-System(DNS)-Namens aus dem Endpunkt der Amazon-RDS-DB-Instance, zum Beispiel, `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Sie finden den Endpunktwert in den DB-Instance-Details in der Amazon-RDS-Konsole.
+ `-pRDS_password` – für die Angabe eines Passworts. Beim zweiten Gebrauch dieses Parameters geben Sie den Namen eines Passworts einer lokalen MySQL- oder MariaDB-Datenbank an, die durch den zweiten Parameter `-u` bezeichnet wird.
Stellen Sie sicher, dass Sie alle gespeicherten Prozeduren, Auslöser, Funktionen oder Ereignisse manuell in Ihrer Amazon-RDS-Datenbank erstellen. Falls Sie eines dieser Objekte in der Datenbank haben, die Sie kopieren, schließen Sie sie aus, wenn Sie `mysqldump` ausführen. Fügen Sie dazu die folgenden Parameter in den Befehl `mysqldump` ein:
+ `--routines=0`
+ `--triggers=0`
+ `--events=0`
**Beispiel**
Im folgenden Beispiel wird die Beispieldatenbank `world` des lokalen Hosts in eine DB-Instance von RDS für MySQL kopiert. Ersetzen Sie die Werte durch Ihre Angaben.
Für Linux, macOS oder Unix:
```
sudo mysqldump -u local_user \
--databases world \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mysql -u rds_user \
--port=3306 \
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com \
-pRDS_password
```
Für Windows:
Führen Sie den folgenden Befehl in einem Eingabeaufforderungsfenster aus, das per Rechtsklick auf **Eingabeaufforderung** im Windows-Menü und anschließender Auswahl von **Als Administrator ausführen** geöffnet wird. Ersetzen Sie die Werte durch Ihre Angaben.
```
mysqldump -u local_user ^
--databases world ^
--single-transaction ^
--compress ^
--order-by-primary ^
--routines=0 ^
--triggers=0 ^
--events=0 ^
-plocal_password | mysql -u RDS_user ^
--port=3306 ^
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com ^
-pRDS_password
```
**Anmerkung**
Geben Sie als bewährte Sicherheitsmethode andere Anmeldeinformationen als die in diesem Beispiel angegebenen Prompts an.
# Importieren von Daten in eine Datenbank von Amazon RDS für MySQL mit reduzierter Ausfallzeit
In einigen Situationen müssen Sie Daten aus einer externen MySQL-Datenbank importieren, die eine Live-Anwendung für eine DB-Instance von RDS für MySQL oder einen Multi-AZ-DB-Cluster von RDS für MySQL unterstützt. Nutzen Sie das folgende Verfahren, um die Auswirkungen auf die Verfügbarkeit der Anwendung zu minimieren. Dieses Verfahren kann außerdem hilfreich sein, wenn Sie mit einer sehr großen Datenbank arbeiten. Mit diesem Verfahren können Sie die Kosten des Imports durch Reduzierung der Menge an Daten senken, die über das Netzwerk an AWS weitergeleitet werden.
Im Rahmen dieses Verfahrens übertragen Sie eine Kopie Ihrer Datenbankdaten an eine Amazon-EC2-Instance und importieren die Daten in eine neue Amazon-RDS-Datenbank. Anschließend verwenden Sie die Replikation, um die Amazon RDS-Datenbank up-to-date mit Ihrer externen Live-Instance zu verknüpfen, bevor Sie Ihre Anwendung auf die Amazon RDS-Datenbank umleiten. Konfigurieren Sie die Replikation basierend auf den Binärprotokollkoordinaten.
**Anmerkung**
Wenn Sie Daten in eine DB-Instance von RDS für MySQL importieren möchten und Ihr Szenario dies unterstützt, empfehlen wir, Daten mithilfe von Backup-Dateien und Amazon S3 in und aus Amazon RDS zu verschieben. Weitere Informationen finden Sie unter [Wiederherstellen eines Backups in eine DB-Instance von Amazon RDS für MySQL](MySQL.Procedural.Importing.md).
Im folgenden Diagramm ist der Import einer externen MySQL-Datenbank in eine MySQL-Datenbank auf Amazon RDS veranschaulicht.
![\[Workflow, der den Import einer externen MySQL-Datenbank in eine MySQL-Datenbank auf Amazon RDS darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_1.png)
## Aufgabe 1: Erstellen einer Kopie Ihrer bestehenden Datenbank
Der erste Schritt bei der Migration von großen Datenmengen in eine Datenbank von RDS für MySQL mit minimaler Ausfallzeit besteht darin, eine Kopie der Quelldaten zu erstellen.
Das folgende Diagramm veranschaulicht die Erstellung eines Backups der MySQL-Datenbank.
![\[Workflow, der das Erstellen eines Backups der MySQL-Datenbank darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_2.png)
Sie können das Hilfsprogramm `mysqldump` verwenden, um ein Datenbank-Backup im SQL-Format oder im separierten Textformat zu erstellen. Es wird empfohlen, mit jedem Format in einer Nichtproduktionsumgebung einen Testlauf durchzuführen, um festzustellen, welche Methode die Ausführungsdauer von `mysqldump` minimiert.
Wir empfehlen auch, dass Sie die Leistung von `mysqldump` gegenüber den Vorteilen einer Verwendung von separiertem Textformat beim Laden abwägen. Ein Backup, das ein separiertes Textformat verwendet, erstellt eine tabulatorseparierte Textdatei für jede verworfene Tabelle. Um den Zeitaufwand für den Import Ihrer Datenbank zu reduzieren, können Sie diese Dateien mit dem Befehl `LOAD DATA LOCAL INFILE` parallel laden. Weitere Informationen finden Sie unter [Schritt 5: Laden der Daten](mysql-importing-data-any-source.md#mysql-importing-data-any-source-load-data) im Verfahren zum Importieren von Daten aus einer beliebigen Quelle.
Bevor Sie mit dem Backup-Vorgang beginnen, müssen Sie die Optionen für die Replikation in der nach Amazon RDS zu kopierenden MySQL-Datenbank festlegen. Die Optionen für die Replikation schließen die Aktivierung der Binärprotokollierung und das Einstellen einer eindeutigen Server-ID mit ein. Das Einstellen dieser Optionen veranlasst den Server, mit der Protokollierung Ihrer Datenbanktransaktionen zu beginnen, und bereitet ihn darauf vor, später im Vorgang als Quellreplikationsinstance zu agieren.
Stellen Sie sicher, dass Sie die folgenden Empfehlungen und Überlegungen kennen:
+ Verwenden Sie die Option `--single-transaction` mit `mysqldump`, da sie einen einheitlichen Zustand der Datenbank speichert. Um eine gültige Dump-Datei sicherzustellen, führen Sie beim Ausführen von `mysqldump` keine DDL-Anweisungen (Data Definition Language) aus. Sie können ein Wartungsfenster für diese Abläufe planen.
+ Schließen Sie die folgenden Schemas aus der Dump-Datei aus:
+ `sys`
+ `performance_schema`
+ `information_schema`
Das Dienstprogramm `mysqldump` schließt diese Schemas standardmäßig aus.
+ Wenn Sie Benutzer und Rechte migrieren müssen, sollten Sie in Erwägung ziehen, ein Tool zu verwenden, das die Data Control Language (DCL) für deren Neuerstellung generiert, z. B. das Hilfsprogramm. [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html)
### So stellen Sie Optionen für die Replikation ein:
1. Bearbeiten Sie die `my.cnf`-Datei. Diese Datei befindet sich normalerweise in `/etc`.
```
sudo vi /etc/my.cnf
```
Fügen Sie die Optionen `log_bin` und `server_id` zum Abschnitt `[mysqld]` hinzu. Die Option `log_bin` bietet eine Dateinamenkennung für Binärprotokolldateien. Die Option `server_id` stellt eine eindeutige Kennung für den Server für Quelle-Replica-Beziehungen bereit.
Im folgenden Beispiel ist der aktualisierte `[mysqld]`-Abschnitt einer `my.cnf`-Datei angegeben:
```
[mysqld]
log-bin=mysql-bin
server-id=1
```
Weitere Informationen finden Sie unter [Setting the Replication Master Configuration](https://dev.mysql.com/doc/refman/8.4/en/replication-howto-masterbaseconfig.html) in der MySQL-Dokumentation.
1. Legen Sie für die Replikation mit einem Multi-AZ-DB-Cluster die Parameter `ENFORCE_GTID_CONSISTENCY` und `GTID_MODE` auf `ON` fest.
```
mysql> SET @@GLOBAL.ENFORCE_GTID_CONSISTENCY = ON;
```
```
mysql> SET @@GLOBAL.GTID_MODE = ON;
```
Diese Einstellungen sind für die Replikation mit einer DB-Instance nicht erforderlich.
1. Den Service `mysql` neu starten.
```
sudo service mysqld restart
```
### So erstellen Sie eine Sicherungskopie für Ihre bestehende Datenbank:
1. Erstellen Sie ein Backup für Ihre Daten mithilfe des Hilfsprogramms `mysqldump`, indem Sie entweder das SQL- oder separierte Textformat festlegen.
Geben Sie bei MySQL 8.0.25 und älteren Versionen `--master-data=2` an, um eine Backup-Datei zu erstellen, die für das Starten einer Replikation zwischen Servern verwendet werden kann. Geben Sie bei MySQL 8.0.26 und neueren Versionen `--source-data=2` an, um eine Backup-Datei zu erstellen, die für das Starten einer Replikation zwischen Servern verwendet werden kann. Weitere Informationen finden Sie unter [mysqldump – A Database Backup Program](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html) in der MySQL-Dokumentation.
Verwenden Sie die Optionen `--order-by-primary` und `--single-transaction` für `mysqldump`., um die Leistung zu verbessern und die Datenintegrität sicherzustellen.
Verwenden Sie die Option `--all-databases` nicht mit `mysqldump`, um die Einbindung der MySQL-Systemdatenbank im Backup zu vermeiden. Weitere Informationen finden Sie unter [Creating a Data Snapshot Using mysqldump](https://dev.mysql.com/doc/mysql-replication-excerpt/8.0/en/replication-howto-mysqldump.html) in der MySQL-Dokumentation.
Verwenden Sie bei Bedarf `chmod`, um sicherzustellen, dass das Verzeichnis beschreibbar ist, in dem die Backup-Datei erstellt wird.
**Wichtig**
Führen Sie unter Windows die Eingabeaufforderung als Administrator aus.
+ Verwenden Sie den folgenden Befehl, um eine SQL-Ausgabe zu erstellen:
Für Linux, macOS oder Unix:
```
sudo mysqldump \
--databases database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-r backup.sql \
-u local_user \
-ppassword
```
**Anmerkung**
Geben Sie als bewährte Sicherheitsmethode andere Anmeldeinformationen als die in diesem Beispiel angegebenen Prompts an.
Für Windows:
```
mysqldump ^
--databases database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-r backup.sql ^
-u local_user ^
-ppassword
```
**Anmerkung**
Geben Sie als bewährte Sicherheitsmethode andere Anmeldeinformationen als die in diesem Beispiel angegebenen Prompts an.
+ Verwenden Sie den folgenden Befehl, um eine separierte Textausgabe zu erstellen:
Für Linux, macOS oder Unix:
```
sudo mysqldump \
--tab=target_directory \
--fields-terminated-by ',' \
--fields-enclosed-by '"' \
--lines-terminated-by 0x0d0a \
database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-ppassword
```
Für Windows:
```
mysqldump ^
--tab=target_directory ^
--fields-terminated-by "," ^
--fields-enclosed-by """ ^
--lines-terminated-by 0x0d0a ^
database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-ppassword
```
**Anmerkung**
Geben Sie als bewährte Sicherheitsmethode andere Anmeldeinformationen als die in diesem Beispiel angegebenen Prompts an.
Stellen Sie sicher, dass Sie alle gespeicherten Prozeduren, Auslöser, Funktionen oder Ereignisse manuell in Ihrer Amazon-RDS-Datenbank erstellen. Falls Sie eines dieser Objekte in der Datenbank haben, die Sie kopieren, schließen Sie sie aus, wenn Sie `mysqldump` ausführen. Fügen Sie dazu die folgenden Argumente in den Befehl `mysqldump` ein:
`--routines=0`
`--triggers=0`
`--events=0`
Bei MySQL 8.0.22 und früheren Versionen wird der Kommentar `CHANGE MASTER TO` zurückgegeben, wenn Sie `mysqldump` ausführen und das separierte Textformat festlegen. Dieser Kommentar beinhaltet den Namen und die Position der Hauptprotokolldatei. Bei MySQL 8.0.23 und neueren Versionen wird der Kommentar `CHANGE REPLICATION SOURCE TO` zurückgegeben, wenn Sie `mysqldump` mithilfe des separierten Textformats ausführen. Dieser Kommentar beinhaltet den Namen und die Position der Quellprotokolldatei. Wenn es sich bei der externen Instance um MySQL 8.0.23 oder eine neuere Version handelt, notieren Sie die Werte für `MASTER_LOG_FILE` und `MASTER_LOG_POS`. Sie benötigen diese Werte beim Einrichten der Replikation.
Die folgende Ausgabe wird für MySQL 8.0.22 und frühere Versionen zurückgegeben:
```
-- Position to start replication or point-in-time recovery from
--
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin-changelog.000031', MASTER_LOG_POS=107;
```
Die folgende Ausgabe wird für MySQL 8.0.23 und neuere Versionen zurückgegeben:
```
-- Position to start replication or point-in-time recovery from
--
-- CHANGE SOURCE TO SOURCE_LOG_FILE='mysql-bin-changelog.000031', SOURCE_LOG_POS=107;
```
Wenn Sie bei MySQL 8.0.22 und früheren Versionen das SQL-Format verwenden, können Sie den Namen und die Position der Hauptprotokolldatei im Kommentar `CHANGE MASTER TO` in der Backup-Datei abrufen. Wenn Sie bei MySQL 8.0.23 und neueren Versionen das SQL-Format verwenden, können Sie den Namen und die Position der Quellprotokolldatei im Kommentar `CHANGE REPLICATION SOURCE TO` in der Backup-Datei abrufen.
1. Komprimieren Sie die kopierten Daten, um die Menge der Netzwerkressourcen zu reduzieren, die benötigt werden, um Ihre Daten in eine Amazon-RDS-Datenbank zu kopieren. Notieren Sie sich die Größe der Backup-Datei. Diese Informationen benötigen Sie, um die Größe der zu erstellenden Amazon-EC2-Instance zu bestimmen. Wenn Sie fertig sind, komprimieren Sie die Sicherungsdatei mithilfe von GZIP oder Ihrem bevorzugten Komprimierungsprogramm.
+ Verwenden Sie den folgenden Befehl, um eine SQL-Ausgabe zu komprimieren:
```
gzip backup.sql
```
+ Verwenden Sie den folgenden Befehl, um eine separierte Textausgabe zu komprimieren:
```
tar -zcvf backup.tar.gz target_directory
```
## Aufgabe 2: Erstellen einer Amazon EC2-Instance und Kopieren der komprimierten Datenbank
Das Kopieren Ihrer komprimierten Datenbank-Sicherungsdatei in eine Amazon EC2-Instance verbraucht weniger Netzwerkressourcen als eine direkte Kopie von unkomprimierten Daten zwischen Datenbank-Instances. Wenn sich die Daten in Amazon EC2 befinden, können Sie diese von dort direkt in die MySQL-Datenbank kopieren. Damit Sie Kosten für Netzwerkressourcen sparen können, muss sich Ihre Amazon EC2 EC2-Instance in derselben Konfiguration AWS-Region wie Ihre Amazon RDS-DB-Instance befinden. Wenn sich die Amazon EC2-Instance in derselben AWS-Region wie die Amazon-RDS-Datenbank befindet, wird auch die Netzwerklatenz während des Importvorgangs reduziert.
Das folgende Diagramm veranschaulicht den Kopiervorgang des Datenbank-Backups in eine Amazon EC2-Instance.
![\[Workflow, der den Kopiervorgang des Datenbank-Backups in eine Amazon EC2-Instance darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_3.png)
### So erstellen Sie eine Amazon EC2-Instance und kopieren Ihre Daten:
1. Erstellen Sie in AWS-Region dem Bereich, in dem Sie die Amazon RDS-Datenbank erstellen möchten, eine Virtual Private Cloud (VPC), eine VPC-Sicherheitsgruppe und ein VPC-Subnetz. Stellen Sie sicher, dass die eingehenden Regeln für Ihre VPC-Sicherheitsgruppe IP-Adressen zulassen, die für eine Verbindung Ihrer Anwendung mit erforderlich sin AWS. Sie können einen IP-Adressbereich (z. B. `203.0.113.0/24`) oder eine andere VPC-Sicherheitsgruppe festlegen. Sie können die [Amazon VPC-Konsole](https://console.aws.amazon.com/vpc) verwenden VPCs, um Subnetze und Sicherheitsgruppen zu erstellen und zu verwalten. Weitere Informationen finden Sie unter [Erste Schritte mit Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html#getting-started) im *Amazon Virtual Private Cloud-Benutzerhandbuch*.
1. Öffnen Sie die [Amazon EC2 EC2-Konsole](https://console.aws.amazon.com/ec2) und wählen Sie die aus AWS-Region , die sowohl Ihre Amazon EC2 EC2-Instance als auch Ihre Amazon RDS-Datenbank enthalten soll. Starten Sie eine Amazon EC2-Instance unter Verwendung der VPC, dem Subnetz und der Sicherheitsgruppe, die Sie in Schritt 1 erstellt haben. Stellen Sie sicher, dass Sie einen Instance-Typ mit genügend Speicherplatz für Ihre unkomprimierte Datenbank-Sicherungsdatei ausgewählt haben. Weitere Informationen zu Amazon EC2-Instances finden Sie unter [Erste Schritte mit Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) im *Amazon Elastic Compute Cloud-Benutzerhandbuch*.
1. Wenn Sie sich von Ihrer Amazon-EC2-Instance mit Ihrer Amazon-RDS-Datenbank verbinden möchten, bearbeiten Sie Ihre VPC-Sicherheitsgruppe. Fügen Sie eine Regel für eingehenden Datenverkehr hinzu, in der die private IP-Adresse Ihrer EC2-Instance angegeben ist. Die private IP-Adresse finden Sie auf der Registerkarte **Details** im Bereich **Instance** des EC2-Konsolenfensters. Wählen Sie zuerst **Sicherheitsgruppen** im Navigationsbereich der EC2-Konsole und dann Ihre Sicherheitsgruppe aus und fügen Sie anschließend eine Regel für eingehenden Datenverkehr für MySQL oder Aurora hinzu, die die private IP-Adresse Ihrer EC2-Instance angibt, um Ihre VPC-Sicherheitsgruppe zu bearbeiten und eine Regel für eingehenden Datenverkehr hinzuzufügen. Weitere Informationen zum Hinzufügen einer Regel für eingehenden Datenverkehr zu einer VPC-Sicherheitsgruppe finden Sie unter [Sicherheitsgruppenregeln](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html) im *Amazon Virtual Private Cloud-Benutzerhandbuch*.
1. Kopieren Sie Ihre komprimierte Datenbank-Sicherungsdatei aus Ihrem lokalen System in Ihre Amazon EC2-Instance. Verwenden Sie bei Bedarf `chmod`, um sicherzustellen, dass Sie Schreibrechte für das Zielverzeichnis der Amazon EC2-Instance besitzen. Sie können `scp` oder einen Secure-Shell(SSH)-Client verwenden, um die Datei zu kopieren. Nachfolgend finden Sie ein Beispiel für einen `scp`-Befehl:
```
scp -r -i key pair.pem backup.sql.gz ec2-user@EC2 DNS:/target_directory/backup.sql.gz
```
**Wichtig**
Vergewissern Sie sich beim Kopieren von sensiblen Daten, dass Sie ein sicheres Netzwerk-Übertragungsprotokoll verwenden.
1. Verbinden Sie sich mit Ihrer Amazon EC2-Instance und installieren Sie die neusten Updates und MySQL-Client-Tools mithilfe der folgenden Befehle:
```
sudo yum update -y
sudo yum install mysql -y
```
Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit Ihrer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux) für Linux-Instances im *Amazon Elastic Compute Cloud-Benutzerhandbuch*.
**Wichtig**
In diesem Beispiel wird der MySQL-Client auf einem Amazon Machine Image (AMI) für eine Amazon-Linux-Verteilung installiert. Mit diesem Beispiel kann der MySQL-Client nicht auf einer anderen Verteilung wie Ubuntu oder Red Hat Enterprise Linux installiert werden. Informationen zum Installieren von MySQL finden Sie unter [Installation von MySQL](https://dev.mysql.com/doc/refman/8.4/en/installing.html) in der MySQL-Dokumentation.
1. Solange Sie mit Ihrer Amazon EC2-Instance verbunden sind, dekomprimieren Sie Ihre Datenbank-Sicherungsdatei. Die folgenden Befehle sind Beispiele.
+ Verwenden Sie den folgenden Befehl, um eine SQL-Ausgabe zu extrahieren:
```
gzip backup.sql.gz -d
```
+ Verwenden Sie den folgenden Befehl, um eine separierte Textausgabe zu extrahieren:
```
tar xzvf backup.tar.gz
```
## Aufgabe 3: Erstellen einer MySQL-Datenbank und Importieren von Daten aus der Amazon EC2-Instance
Wenn Sie eine DB-Instance von RDS für MySQL oder einen Multi-AZ-DB-Cluster von RDS für MySQL in derselben AWS-Region wie die Amazon EC2-Instance erstellen, können Sie die Backup-Datei der Datenbank schneller aus EC2 importieren als über das Internet.
Das folgende Diagramm veranschaulicht den Importvorgang der Backup-Datei von einer Amazon EC2-Instance in eine MySQL-Datenbank.
![\[Workflow, der den Importvorgang der Backup-Datei von der EC2-Instance in die MySQL-Datenbank darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_4.png)
### So erstellen Sie eine MySQL-Datenbank und importieren Ihre Daten
1. Bestimmen Sie, welche DB-Instance-Klasse und wie viel Speicherplatz erforderlich sind, um den erwarteten Workload für diese Amazon-RDS-Datenbank unterstützen zu können. Bei diesem Vorgang sollten Sie auch entscheiden, wie viel Speicherplatz und Verarbeitungskapazität für Ihre Datenladevorgänge ausreichen. Entscheiden Sie auch, was für den Umgang mit dem Produktions-Workload erforderlich ist. Sie können diese Faktoren anhand der Größe und der Ressourcen der MySQL-Quelldatenbank einschätzen. Weitere Informationen finden Sie unter [](Concepts.DBInstanceClass.md).
1. Erstellen Sie eine DB-Instance oder einen Multi-AZ-DB-Cluster in dem AWS-Region , der Ihre Amazon EC2 EC2-Instance enthält.
Befolgen Sie die Anweisungen unter [Erstellen eines Multi-AZ-DB-Clusters für Amazon RDS](create-multi-az-db-cluster.md), um einen Multi-AZ-DB-Cluster von RDS für MySQL zu erstellen.
Wenn Sie eine DB-Instance von RDS für MySQL erstellen möchten, befolgen Sie die Anweisungen unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md) und verwenden Sie die folgenden Richtlinien:
+ Geben Sie eine DB-Engine-Version an, die mit Ihrer Quell-DB-Instance kompatibel ist.
+ Geben Sie dieselbe Virtual Private Cloud (VPC) und VPC-Sicherheitsgruppe an, die Sie auch für die Amazon-EC2-Instance ausgewählt haben. Durch diesen Ansatz wird sichergestellt, dass Ihre Amazon EC2-Instance und Ihre Amazon-RDS-Instance im Netzwerk gegenseitig füreinander sichtbar sind. Stellen Sie sicher, dass Ihre DB-Instance öffentlich zugänglich ist. Ihre DB-Instance muss öffentlich zugänglich sein, um eine Replikation für Ihre Quelldatenbank einzurichten, wie in einem späteren Abschnitt beschrieben wird.
+ Konfigurieren Sie nicht mehrere Availability Zones, Backup-Aufbewahrungen oder Lesereplikate, nachdem Sie das Datenbank-Backup importiert haben. Wenn dieser Importvorgang abgeschlossen ist, können Sie Multi-AZ und Backup-Aufbewahrung für die Produktions-Instance konfigurieren.
1. Überprüfen Sie die Optionen der Standardkonfiguration für die Amazon-RDS-Datenbank. Wenn in der Standardparametergruppe für die Datenbank die von Ihnen gewünschten Optionen nicht konfiguriert sind, wählen Sie eine andere aus, die die entsprechenden Konfigurationsoptionen enthält, oder erstellen Sie eine neue Parametergruppe. Weitere Informationen zum Erstellen einer Parametergruppe finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
1. Stellen Sie als Hauptbenutzer eine Verbindung mit der neuen Amazon-RDS-Datenbank her. Erstellen Sie die Benutzer, die erforderlich sind, um die Administratoren, Anwendungen und Services zu unterstützen, die auf die DB-Instance zugreifen müssen. Der Hostname für die Amazon-RDS-Datenbank ist ihr **Endpunktwert** für diese DB-Instance ohne die Portnummer, z. B. `mysampledb.123456789012.us-west-2.rds.amazonaws.com`. Sie finden den Endpunktwert in den Datenbankdetails der Amazon-RDS-Konsole.
1. Stellen Sie eine Verbindung zu Ihrer Amazon-EC2-Instance her. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit Ihrer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux) für Linux-Instances im *Amazon Elastic Compute Cloud-Benutzerhandbuch*.
1. Stellen Sie als Remote-Host eine Verbindung mit Ihrer Amazon-RDS-Datenbank von Ihrer Amazon-EC2-Instance aus mithilfe des Befehls `mysql` her. Der folgende Befehl ist ein Beispiel:
```
mysql -h host_name -P 3306 -u db_master_user -p
```
Das *host\$1name* ist der Amazon RDS-Datenbank-Endpunkt.
1. Führen Sie an der Eingabeaufforderung `mysql` den Befehl `source` aus und tragen Sie den Namen der Datenbank-Dumpdatei ein. Mit diesem Befehl werden die Daten in die Amazon-RDS-DB-Instance geladen.
+ Verwenden Sie für das SQL-Format den folgenden Befehl:
```
mysql> source backup.sql;
```
+ Für das separierte Textformat erstellen Sie zuerst die Datenbank, wenn es sich nicht um die Standarddatenbank handelt, die Sie bei der Einrichtung der Amazon-RDS-Datenbank erstellt haben.
```
mysql> create database database_name;
mysql> use database_name;
```
Erstellen Sie anschließend die Tabellen.
```
mysql> source table1.sql
mysql> source table2.sql
etc...
```
Importieren Sie dann die Daten.
```
mysql> LOAD DATA LOCAL INFILE 'table1.txt' INTO TABLE table1 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
mysql> LOAD DATA LOCAL INFILE 'table2.txt' INTO TABLE table2 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
etc...
```
Zur Verbesserung der Leistung können Sie diese Operationen parallel aus mehreren Verbindungen ausführen, damit alle Ihre Tabellen erstellt und die Daten anschließend gleichzeitig geladen werden.
**Anmerkung**
Wenn Sie Optionen für eine Datenformatierung mit `mysqldump` beim ersten Verwerfen der Tabelle verwendet haben, müssen Sie nun dieselben Optionen mit `LOAD DATA LOCAL INFILE` verwenden, um eine richtige Interpretation der Datendateiinhalte sicherzustellen.
1. Führen Sie eine einfache `SELECT`-Abfrage anhand einer oder zwei der Tabellen in der importierten Datenbank durch, um zu prüfen, ob der Importvorgang erfolgreich abgeschlossen wurde.
Wenn Sie die in diesem Verfahren verwendete Amazon EC2 EC2-Instance nicht mehr benötigen, beenden Sie die EC2-Instance, um Ihren AWS Ressourcenverbrauch zu reduzieren. Weitere Informationen zum Beenden einer EC2-Instance finden Sie unter [Beenden einer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#terminating-instances-console) im *Amazon Elastic Compute Cloud-Benutzerhandbuch*.
## Aufgabe 4: Replizieren von Daten aus der externen Datenbank in die neue Amazon-RDS-Datenbank
Die Quelldatenbank wurde in der Zeit, in der die Daten in die MySQL-Datenbank kopiert und übertragen wurden, wahrscheinlich aktualisiert. Sie können also die Replikation verwenden, um die kopierte Datenbank up-to-date mit der Quelldatenbank zu verknüpfen.
![\[Workflow, der die Replikation von Daten aus der externen MySQL-Datenbank in die Datenbank in Amazon RDS darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_5.png)
Die erforderlichen Berechtigungen für das Starten einer Replikation in einer Amazon-RDS-Datenbank sind beschränkt und für den Amazon-RDS-Hauptbenutzer nicht verfügbar. Verwenden Sie daher die entsprechende gespeicherte Amazon-RDS-Prozedur für die Engine-Hauptversion:
+ [mysql\$1rds\$1set\$1external\$1master (Hauptversionen von RDS für MySQL 8.0 und frühere Versionen)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1source (RDS-für-MySQL-Hauptversionen 8.4 und höher)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source)
+ [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) zum Konfigurieren der Replikation und [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) zum Starten der Replikation
### So starten Sie eine Replikation:
In Aufgabe 1 [haben Sie bei der Festlegung der Replikationsoptionen](#mysql-importing-data-reduced-downtime-set-replication-options) die Binärprotokollierung aktiviert und eine eindeutige Server-ID für die Quelldatenbank festgelegt. Jetzt können Sie Ihre Amazon-RDS-Datenbank als Replikat mit Ihrer Live-Datenbank als Quellreplikations-Instance einrichten.
1. Fügen Sie in der Amazon-RDS-Konsole die IP-Adresse des Servers, der die Quelldatenbank hostet, zur VPC-Sicherheitsgruppe dieser Amazon-RDS-Datenbank hinzu. Weitere Informationen zum Konfigurieren einer VPC-Sicherheitsgruppe finden Sie unter [Konfigurieren von Sicherheitsgruppenregeln](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html) im *Amazon Virtual Private Cloud-Benutzerhandbuch*.
Möglicherweise müssen Sie Ihr lokales Netzwerk so konfigurieren, dass es Verbindungen von der IP-Adresse Ihrer Amazon-RDS-Datenbank zulässt, damit es mit Ihrer Quell-Instance kommunizieren kann. Verwenden Sie den Befehl `host`, um die IP-Adresse der Amazon-RDS-Datenbank zu ermitteln.
```
host host_name
```
Das *host\$1name* ist zum Beispiel der DNS-Name vom Amazon RDS-Datenbank-Endpunkt`myinstance.123456789012.us-east-1.rds.amazonaws.com`. Sie finden den Endpunktwert in den DB-Instance-Details in der Amazon-RDS-Konsole.
1. Verbinden Sie sich mithilfe eines Clients Ihrer Wahl mit der Quell-Instance und erstellen Sie einen Benutzer, der für die Replikation verwendet werden soll. Dieses Konto wird ausschließlich für die Replikation verwendet und muss auf Ihre Domäne beschränkt sein, um die Sicherheit zu erhöhen. Der folgende Befehl ist ein Beispiel:
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen andere Anmeldeinformationen als hier angegeben an.
1. Erteilen Sie für die Quell-Instance die Sonderrechte `REPLICATION CLIENT` und `REPLICATION SLAVE` für Ihren Replikationsbenutzer. Erteilen Sie beispielsweise die Sonderrechte `REPLICATION CLIENT` und `REPLICATION SLAVE` in allen Datenbanken für den `repl_user`-Benutzer für Ihre Domäne, mit dem folgenden Befehl:
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Konfigurieren Sie die Amazon-RDS-Datenbank als Replikat. Stellen Sie eine Verbindung mit der Amazon-RDS-Datenbank als Masterbenutzer her und identifizieren Sie die Quelldatenbank mithilfe der entsprechenden gespeicherten Amazon-RDS-Prozedur als Quellreplikations-Instance.
+ [mysql\$1rds\$1set\$1external\$1master (Hauptversionen von RDS für MySQL 8.0 und frühere Versionen)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1source (RDS-für-MySQL-Hauptversionen 8.4 und höher)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source)
Wenn Sie über eine Backup-Datei im SQL-Format verfügen, verwenden Sie den Namen der Hauptprotokolldatei und die Position des Hauptprotokolls, die Sie beide in Schritt 4 ermittelt haben. Wenn Sie das separierte Textformat genutzt haben, verwenden Sie den Namen und die Position, die Sie beide beim Erstellen der Backup-Dateien ermittelt haben. Die folgenden Befehle sind Beispiele.
**MySQL 8.4 und neuere Versionen**
```
CALL mysql.rds_set_external_source ('myserver.mydomain.com', 3306,
'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MySQL 8.0 und frühere Versionen**
```
CALL mysql.rds_set_external_master ('myserver.mydomain.com', 3306,
'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen andere Anmeldeinformationen als hier angegeben an.
1. Um die Replikation in der Amazon-RDS-Datenbank zu starten, führen Sie den folgenden Befehl aus, der die gespeicherte Prozedur [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) verwendet:
```
CALL mysql.rds_start_replication;
```
1. Führen Sie in der Amazon-RDS-Datenbank den Befehl [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) aus, um festzustellen, wann das Replikat auf dem aktuellen Stand der Quellreplikations-Instance ist. Zu den Ergebnissen des `SHOW REPLICA STATUS`-Befehls gehört das Feld `Seconds_Behind_Master`. Wenn das Feld `Seconds_Behind_Master` 0 zurückgibt, ist das Replikat auf dem aktuellen Stand der Quellreplikations-Instance.
**Anmerkung**
Frühere Versionen von MySQL verwenden `SHOW SLAVE STATUS` anstelle von `SHOW REPLICA STATUS`. Wenn Sie vor 8.0.23 eine MySQL-Version verwenden, verwenden Si `SHOW SLAVE STATUS`.
1. Nachdem die Amazon-RDS-Datenbank auf den aktuellen Stand gebracht wurde, aktivieren Sie die automatischen Backups, damit Sie diese Datenbank bei Bedarf wiederherstellen können. Sie können automatische Backups für die Amazon-RDS-Datenbank mithilfe der [Amazon-RDS-Konsole](https://console.aws.amazon.com/rds/) aktivieren oder ändern. Weitere Informationen finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md).
## Aufgabe 5: Weiterleiten der Live-Anwendung an die Amazon-RDS-Instance
Wenn die MySQL-Datenbank auf den aktuellen Stand der Quellreplikations-Instance gebracht wurde, können Sie nun die Live-Anwendung aktualisieren, damit sie die Amazon-RDS-Instance nutzt.
![\[Workflow, der die Beendigung der Replikation und die Weiterleitung der Live-Anwendung an die Datenbank in Amazon RDS darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_6.png)
### So leiten Sie die Live-Anwendung an die MySQL-Datenbank weiter und halten die Replikation an
1. Fügen Sie die IP-Adresse des Host-Servers der Anwendung hinzu, um die VPC-Sicherheitsgruppe für Ihre Amazon-RDS-Datenbank hinzuzufügen. Weitere Informationen zum Ändern einer VPC-Sicherheitsgruppe finden Sie unter [Konfigurieren von Sicherheitsgruppenregeln](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html) im *Amazon Virtual Private Cloud-Benutzerhandbuch*.
1. Vergewissern Sie sich, dass das Feld `Seconds_Behind_Master` im Ergebnis des Befehls [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) 0 ist, was darauf hinweist, dass das Replikat auf dem neuesten Stand mit der Quellreplikations-Instance ist.
```
SHOW REPLICA STATUS;
```
**Anmerkung**
Frühere Versionen von MySQL verwenden `SHOW SLAVE STATUS` anstelle von `SHOW REPLICA STATUS`. Wenn Sie vor 8.0.23 eine MySQL-Version verwenden, verwenden Si `SHOW SLAVE STATUS`.
1. Schließen Sie alle Verbindungen zur Quelle, nachdem ihre Transaktionen abgeschlossen sind.
1. Aktualisieren Sie Ihre Anwendung, um die Amazon-RDS-Datenbank zu nutzen. Dieses Update ändert die Verbindungseinstellungen, um den Hostnamen und den Port der Amazon-RDS-Datenbank, das Benutzerkonto und Passwort für die Verbindung und die zu verwendende Datenbank zu bestimmen.
1. Stellen Sie eine Verbindung mit der DB-Instance her.
Stellen Sie für einen Multi-AZ-DB-Cluster eine Verbindung mit der Writer-DB-Instance her.
1. Halten Sie die Replikation für die Amazon-RDS-Instance an, indem Sie den folgenden Befehl ausführen, der die gespeicherte Prozedur [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) verwendet:
```
CALL mysql.rds_stop_replication;
```
1. Setzen Sie die Replikationskonfiguration zurück, damit diese Instance nicht mehr als Replikat identifiziert wird, indem Sie die entsprechende gespeicherte Amazon-RDS-Prozedur in der Amazon-RDS-Datenbank verwenden:
+ [mysql\$1rds\$1reset\$1external\$1master (Hauptversionen von RDS für MySQL 8.0 und frühere Versionen)](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master)
+ [mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)](mysql-stored-proc-replicating.md#mysql_rds_reset_external_source)
**MySQL 8.4 und neuere Versionen**
```
CALL mysql.rds_reset_external_source;
```
**MySQL 8.0 und frühere Versionen**
```
CALL mysql.rds_reset_external_master;
```
1. Aktivieren Sie zusätzliche Amazon-RDS-Funktionen, wie Multi-AZ-Unterstützung und Lesereplikate. Weitere Informationen erhalten Sie unter [Konfigurieren und Verwalten einer Multi-AZ-Bereitstellung für Amazon RDS](Concepts.MultiAZ.md) und [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
# Importieren von Daten aus einer beliebigen Quelle in eine DB-Instance von Amazon RDS für MySQL
Mit Amazon RDS können Sie vorhandene MySQL-Daten von einer beliebigen Quelle zu einer DB-Instance von RDS für MySQL migrieren. Sie können Daten von lokalen Datenbanken, anderen Cloud-Anbietern oder vorhandenen DB-Instances von RDS für MySQL auf Ihre Ziel-DB-Instance von RDS für MySQL übertragen. Mit dieser Funktion können Sie Datenbanken konsolidieren, Lösungen für eine Notfallwiederherstellung implementieren oder von selbstverwalteten Datenbanken umsteigen. Zu den gängigen Szenarien gehören der Wechsel von selbst gehosteten MySQL-Servern zu vollständig verwalteten Amazon-RDS-DB-Instances, die Konsolidierung mehrerer MySQL-Datenbanken in eine einzige DB-Instance oder die Erstellung von Testumgebungen mit Produktionsdaten. Die folgenden Abschnitte enthalten step-by-step Anweisungen zum Importieren Ihrer MySQL-Daten mithilfe von Methoden wie `mysqldump` Sicherungsdateien oder Replikation.
## Schritt 1: Erstellen von Flatfiles, die die zu ladenden Daten enthalten
Verwenden Sie ein gängiges Format, z. B. kommagetrennte Werte (CSV), um die zu ladenden Daten zu speichern. Jede Tabelle muss über eine eigene Datei verfügen. Sie können keine Daten für mehrere Tabellen in derselben Datei kombinieren. Geben Sie jeder Datei denselben Namen wie der zugehörigen Tabelle. Die Dateierweiterung können Sie benennen, wie Sie möchten. Wenn der Tabellenname beispielsweise `sales` lautet, kann der Dateiname `sales.csv` oder `sales.txt` lauten.
Ordnen Sie die Daten nach Primärschlüssel der ladenden Tabelle, sofern möglich. Dadurch werden die Ladezeiten drastisch verbessert und die Anforderungen an den Festplattenspeicher minimiert.
Die optimale Geschwindigkeit und Effizienz dieser Prozedur ist auf kleine Dateigrößen ausgelegt. Wenn die Größe einer einzelnen unkomprimierten Datei mehr als 1 GiB beträgt, teilen Sie diese in mehrere Dateien auf, die danach separat geladen werden können.
Verwenden Sie auf Unix-ähnlichen Systemen (einschließlich Linux) den `split`-Befehl. Der folgende Befehl teilt beispielsweise die Datei `sales.csv` in mehrere Dateien auf, die kleiner als 1 GiB sind. Die Teilung findet nur an Zeilenumbrüchen statt (-C 1024m). Die Namen der neuen Dateien enthalten numerische Suffixe in aufsteigender Reihenfolge. Mit dem folgenden Befehl werden beispielsweise Dateien mit Namen wie `sales.part_00` und `sales.part_01` erzeugt.
```
split -C 1024m -d sales.csv sales.part_
```
Ähnliche Hilfsprogramme sind auch für andere Betriebssysteme verfügbar.
Sie können die Flatfiles überall speichern. Wenn Sie die Daten in [Schritt 5](#mysql-importing-data-any-source-load-data) laden, müssen Sie die `mysql`-Shell jedoch von demselben Speicherort aufrufen, an dem sich die Dateien befinden, oder beim Ausführen von `LOAD DATA LOCAL INFILE` den absoluten Pfad für die Dateien verwenden.
## Schritt 2: Verhindern des Zugriffs von Anwendungen auf die Ziel-DB-Instance
Unterbinden Sie vor dem Starten eines großen Ladevorgangs den Zugriff jeglicher Anwendungsaktivitäten auf die Ziel-DB-Instance, in die die Daten geladen werden sollen. Wir empfehlen dies insbesondere, wenn andere Sitzungen die zu ladenden Tabellen oder die in diesen Tabellen referenzierten Tabellen verändern. Dadurch wird die Gefahr von Verstößen gegen Einschränkungen während des Ladens reduziert und zugleich die Ausführungsgeschwindigkeit des Ladevorgangs erhöht. Zudem wird es möglich, die DB-Instance im Zustand unmittelbar vor dem Ladevorgang wiederherzustellen, ohne die Änderungen durch Prozesse zu verlieren, die nicht am Ladevorgang beteiligt sind.
Unter Umständen ist dies jedoch nicht möglich oder nicht praktikabel. Wenn Sie vor dem Ladevorgang den Zugriff von Anwendungen auf die DB-Instance nicht stoppen können, führen Sie die erforderlichen Schritte aus, um die Verfügbarkeit und Integrität der Daten sicherzustellen. Die jeweiligen erforderlichen Schritte können sich stark unterscheiden, je nachdem welche besonderen Verwendungsfälle der Standortanforderungen vorliegen.
## Schritt 3: Erstellen Sie einen DB-Snapshot
Wenn Sie Daten in eine neue DB-Instance laden wollen, die keine Daten enthält, können Sie diesen Schritt überspringen. Andernfalls empfehlen wir, dass Sie vor und nach dem Datenladevorgang DB-Snapshots für die Ziel-DB-Instance von Amazon RDS erstellen. Amazon-RDS-DB-Snapshots sind vollständige Backups der DB-Instance, die Sie für eine Wiederherstellung der DB-Instance auf einen bekannten Zustand verwenden können. Wenn Sie einen DB-Snapshot initiieren, werden die I/O Operationen an Ihrer DB-Instance vorübergehend unterbrochen, während Ihre Datenbank gesichert wird.
Wenn Sie einen DB-Snapshot unmittelbar vor dem Laden erstellen, können Sie die Datenbank bei Bedarf in ihrem Zustand vor dem Laden wiederherstellen. Ein DB-Snapshot, der sofort nach einem Ladevorgang erstellt wird, bewahrt Sie davor, die Daten bei einem Fehler erneut laden zu müssen. Sie können DB-Snapshots auch nach dem Laden verwenden, um Daten in die neuen Datenbank-Instances zu importieren.
Im folgenden Beispiel wird der AWS CLI [create-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-snapshot.html)Befehl ausgeführt, um einen DB-Snapshot der `AcmeRDS` Instance zu erstellen und dem DB-Snapshot die Kennung `"preload"` zuzuweisen.
Für Linux, macOS oder Unix:
```
aws rds create-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
Für Windows:
```
aws rds create-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
Sie können auch die Wiederherstellung aus der DB-Snapshot-Funktionalität verwenden, um Test-DB-Instances für Testversuche zu erstellen, oder, um die Änderungen während eines Ladevorgangs rückgängig zu machen.
Bedenken Sie, dass die Wiederherstellung einer Datenbank aus einem DB-Snapshot eine neue DB-Instance erstellt, die wie alle DB-Instances über eine eindeutige Kennung und einen Endpunkt verfügt. Um die DB-Instance wiederherzustellen, ohne den Endpunkt zu ändern, löschen Sie zuerst die DB-Instance, damit Sie den Endpunkt wiederverwenden können.
Um beispielsweise eine DB-Instance für einen Testlauf oder andere Testzwecke zu erstellen, weisen Sie der DB-Instance eine eigene Kennung zu. Im Beispiel ist `AcmeRDS-2`" die Kennung. Das Beispiel stellt über den Endpunkt, der `AcmeRDS-2` zugeordnet ist, eine Verbindung mit der DB-Instance her. Weitere Informationen finden Sie unter [restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html).
Für Linux, macOS oder Unix:
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS-2 \
--db-snapshot-identifier preload
```
Für Windows:
```
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS-2 ^
--db-snapshot-identifier preload
```
Um einen bestehenden Endpunkt erneut zu verwenden, löschen Sie zuerst die DB-Instance und weisen Sie dann der wiederhergestellten Datenbank dieselbe Kennung zu. Weitere Informationen finden Sie unter [delete-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance.html).
Im folgenden Beispiel wird auch ein letzter DB-Snapshot der DB-Instance erstellt, bevor sie gelöscht wird. Dies ist zwar optional, wird aber empfohlen.
Für Linux, macOS oder Unix:
```
aws rds delete-db-instance \
--db-instance-identifier AcmeRDS \
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
Für Windows:
```
aws rds delete-db-instance ^
--db-instance-identifier AcmeRDS ^
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
## Schritt 4 (optional): Deaktivieren von automatischen Backups für Amazon RDS
**Warnung**
Deaktivieren Sie automatische Backups nicht, wenn Sie eine Wiederherstellung durchführen müssen. point-in-time
Das Deaktivieren von automatischen Backups ist eine Leistungsoptimierung und ist für Datenladevorgänge nicht erforderlich. Durch das Deaktivieren von automatischen Backups werden alle vorhandenen Backups gelöscht. Daher ist eine point-in-time Wiederherstellung nicht möglich, nachdem Sie automatische Backups deaktiviert haben. Beachten Sie, dass manuelle DB-Snapshots nicht von der Deaktivierung automatischer Backups betroffen sind. Alle bestehenden manuellen DB-Snapshots bleiben für eine Wiederherstellung verfügbar.
Das Deaktivieren von automatischen Backups reduziert die Ladezeit um 25 % und verringert zugleich den während des Ladevorgangs erforderlichen Speicherplatz. Wenn Sie Daten in eine neue DB-Instance laden wollen, die keine Daten enthält, ist das Deaktivieren von Backups eine einfache Möglichkeit, die Übertragungsgeschwindigkeit zu erhöhen und zusätzlichen Speicherverbrauch zu vermeiden. In einigen Fällen können Sie jedoch in eine DB-Instance laden, die bereits Daten enthält. Wenn ja, sollten Sie die Vorteile der Deaktivierung von Backups gegen die Auswirkungen eines Verlusts der Leistungsfähigkeit abwägen point-in-time-recovery.
In DB-Instances ist die Funktion für automatische Backups standardmäßig aktiviert (mit einem Aufbewahrungszeitraum von 1 Tag). Setzen Sie den Wert des Aufbewahrungszeitraums für Backups auf 0, um automatische Backups zu deaktivieren. Nach dem Ladevorgang können Sie Backups erneut aktivieren, indem Sie den Aufbewahrungszeitraum für Backups auf einen Nicht-Null-Wert setzen. Um Backups zu aktivieren oder zu deaktivieren, fährt Amazon RDS die DB-Instance herunter und startet sie dann neu, um die Protokollierung in MySQL zu aktivieren oder zu deaktivieren.
Führen Sie den AWS CLI `modify-db-instance` Befehl aus, um die Backup-Aufbewahrung auf Null zu setzen und die Änderung sofort zu übernehmen. Das Setzen des Aufbewahrungszeitraums für Backups auf Null erfordert den Neustart einer DB-Instance. Warten Sie daher bitte, bis der Neustart abgeschlossen wurde, bevor Sie fortfahren. Weitere Informationen finden Sie unter [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html).
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--apply-immediately \
--backup-retention-period 0
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--apply-immediately ^
--backup-retention-period 0
```
Sie können den Status Ihrer DB-Instance mit dem AWS CLI [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)Befehl überprüfen. Das folgende Beispiel zeigt den DB-Instance-Status der DB-Instance `AcmeRDS`.
```
aws rds describe-db-instances --db-instance-identifier AcmeRDS --query "*[].{DBInstanceStatus:DBInstanceStatus}"
```
Wenn der Status der DB-Instance `available` ist, können Sie mit dem nächsten Schritt fortfahren.
## Schritt 5: Laden der Daten
Verwenden Sie die MySQL-Anweisung `LOAD DATA LOCAL INFILE`, um Zeilen aus den Flatfiles in die Datenbanktabellen einzulesen.
**Anmerkung**
Sie müssen die `mysql`-Shell von demselben Speicherort aufrufen, an dem sich die Flatfiles befinden, oder beim Ausführen von `LOAD DATA LOCAL INFILE` den absoluten Pfad für die Dateien verwenden.
Das folgende Beispiel zeigt, wie Daten aus der Datei `sales.txt` in die Tabelle `Sales` in der Datenbank geladen werden:
```
mysql> LOAD DATA LOCAL INFILE 'sales.txt' INTO TABLE Sales FIELDS TERMINATED BY ' ' ENCLOSED BY '' ESCAPED BY '\\';
Query OK, 1 row affected (0.01 sec)
Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
```
Weitere Informationen zur Anweisung `LOAD DATA` finden Sie unter [LOAD DATA-Anweisung](https://dev.mysql.com/doc/refman/8.4/en/load-data.html) in der MySQL-Dokumentation.
## Schritt 6: Reaktivieren von automatischen Backups für Amazon RDS
Wenn Sie die automatischen Backups für Amazon RDS in [Schritt 4](#mysql-importing-data-any-source-turn-off-automated-backups) deaktiviert haben, aktivieren Sie sie nach Abschluss des Ladevorgangs erneut, indem Sie den Aufbewahrungszeitraum für Backups auf seinen ursprünglichen Wert vor dem Ladevorgang setzen. Wie bereits in Schritt 4 erwähnt, startet Amazon RDS die DB-Instance neu. Es kommt also zu einem kurzen Ausfall.
Im folgenden Beispiel wird der AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)Befehl ausgeführt, um automatische Backups für die `AcmeRDS` DB-Instance zu aktivieren und die Aufbewahrungsfrist auf einen Tag festzulegen:
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--backup-retention-period 1 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--backup-retention-period 1 ^
--apply-immediately
```