Einschränkungen und Überlegungen Bevor Sie beginnen Sichern von Dateien Wiederherstellen aus einem Amazon S3-Bucket Synchronisieren des Aurora MySQL-DB-Clusters mit der MySQL-Datenbank

Physische Migration von MySQL mithilfe von Percona XtraBackup und Amazon S3

Sie können die Dateien der vollständigen und inkrementellen Sicherung aus Ihrer MySQL-Quelldatenbank (Version 5.7 oder 8.0) in einen Amazon S3-Bucket kopieren. Anschließend können Sie die Wiederherstellung zu einem Amazon Aurora MySQL-DB-Cluster mit derselben Hauptversion wie der dieser Dateien durchführen.

Diese Option kann erheblich schneller sein als das Migrieren der Daten mithilfe von mysqldump, da durch die Verwendung von mysqldump alle Befehle für die erneute Erstellung des Schemas und der Daten aus Ihrer Quelldatenbank im neuen Aurora MySQL-DB-Cluster erneut ausgeführt werden. Da die MySQL-Quelldatendateien kopiert werden, können sie von Aurora MySQL sofort als Daten für einen Aurora MySQL-DB-Cluster verwendet werden.

Dazu können Sie mithilfe der Binärprotokollreplikation während des Migrationsprozesses die Ausfallzeit minimieren. Wenn Sie die Binärprotokollreplikation verwenden, bleibt die externe MySQL-Datenbank für Transaktionen geöffnet, während die Daten in das Aurora MySQL-DB-Cluster migriert werden. Nachdem das Aurora MySQL-DB-Cluster erstellt wurde, können Sie das Aurora MySQL-DB-Cluster mithilfe der Binärprotokollreplikation mit den Transaktionen synchronisieren, die nach der Sicherung ausgeführt wurden. Sobald das Aurora MySQL-DB-Cluster den Stand der MySQL-Datenbank erreicht hat, können Sie die Migration beenden, indem Sie bei neuen Transaktionen vollständig zum Aurora MySQL-DB-Cluster wechseln. Weitere Informationen finden Sie unter Synchronisieren des Amazon Aurora MySQL-DB-Clusters mit der MySQL-Datenbank mittels Replikation.

Inhalt

Einschränkungen und Überlegungen

Die folgenden Einschränkungen und Überlegungen gelten für die Wiederherstellung zu einem Amazon Aurora MySQL DB-Cluster von einem Amazon S3-Bucket:

Sie können Ihre Daten nur zu einem neuen und nicht zu einem bereits vorhandenen DB-Cluster migrieren.
Sie müssen Percona verwenden XtraBackup , um Ihre Daten auf S3 zu sichern. Weitere Informationen finden Sie unter Percona installieren XtraBackup.
Der Amazon S3 S3-Bucket und der Aurora MySQL-DB-Cluster müssen sich in derselben AWS Region befinden.
Sie können nicht von folgenden Quellen aus wiederherstellen:
- DB-Cluster-Snapshot-Export zu Amazon S3. Sie können auch keine Daten von einem DB-Cluster-Snapshot-Export in Ihren Amazon-S3-Bucket migrieren.
- Verschlüsselte Quelldatenbank; Sie können jedoch die migrierten Daten verschlüsseln. Sie können die Daten während des Migrationsprozesses auch unverschlüsselt lassen.
- MySQL 5.5- oder 5.6-Datenbank
Percona Server for MySQL wird nicht als Quelldatenbank unterstützt, da sie compression_dictionary* Tabellen im mysql Schema enthalten kann.
Eine Wiederherstellung auf einen Aurora Serverless-DB-Cluster ist nicht möglich.
Für Haupt- und Nebenversionen wird keine abwärtskompatible Migration unterstützt. Das heißt, Sie können nicht von MySQL Version 8.0 zu Aurora MySQL Version 2 (kompatibel mit MySQL 5.7) und auch nicht von MySQL Version 8.0.32 zu Aurora MySQL Version 3.03 migrieren, das mit der MySQL-Community-Version 8.0.26 kompatibel ist.
Sie können von einigen älteren Versionen von MySQL 8.0, einschließlich 8.0.11, 8.0.13 und 8.0.15, nicht zu Aurora MySQL Version 3.05 und höher migrieren. Wir empfehlen, vor der Migration auf MySQL Version 8.0.28 zu aktualisieren.
Das Importieren von Amazon S3 wird von der DB-Instance-Klasse db.t2.micro nicht unterstützt. Sie können jedoch eine Wiederherstellung zu einer anderen DB-Instance-Klasse ausführen und die DB-Instance-Klasse später ändern. Weitere Informationen zu DB-Instance-Klassen finden Sie unter Amazon Aurora Aurora-DB-Instance-Klassen.
Amazon S3 begrenzt die Größe einer Datei, die in einen 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 einen S3-Bucket hochgeladen werden können, auf 1 Million. Wenn es mehr als 1 Million Sicherungsdateien für Ihre Datenbank gibt (einschließlich aller vollständigen und inkrementellen Sicherungen), speichern Sie diese mittels Gzip (.gz), tar (.tar.gz) oder Percona xbstream (.xbstream) in dem S3-Bucket. Percona XtraBackup 8.0 unterstützt nur Percona xbstream für die Komprimierung.
Um Verwaltungsdienste für jedes DB-Cluster bereitzustellen, wird der rdsadmin-Benutzer erstellt, wenn das DB-Cluster erstellt wird. Da dies ein reservierter Benutzer in RDS ist, gelten die folgenden Einschränkungen:
- Funktionen, Prozeduren, Ansichten, Ereignisse und Trigger mit 'rdsadmin'@'localhost'-Definierer werden nicht importiert. Weitere Informationen finden Sie unter Gespeicherte Objekte mit 'rdsadmin'@'localhost' als Definierer und Master-Benutzerrechte mit Amazon Aurora My SQL.
- Wenn der Aurora MySQL-DB-Cluster erstellt wird, wird ein Master-Benutzer mit den maximal unterstützten Rechten erstellt. Bei der Wiederherstellung aus der Sicherung werden alle nicht unterstützten Rechte, die den importierten Benutzern zugewiesen wurden, beim Import automatisch entfernt.
  
  Informationen zu Benutzern, die davon betroffen sein könnten, finden Sie unter Benutzerkonten mit nicht unterstützten Rechten. Weitere Informationen zu den in Aurora MySQL unterstützten Rechten finden Sie unter Rollenbasiertes Berechtigungsmodell.
Für Aurora MySQL Version 3 werden keine dynamischen Rechte importiert. Von Aurora unterstützte dynamische Rechte können nach der Migration importiert werden. Weitere Informationen finden Sie unter Dynamische Rechte in Aurora MySQL Version 3.
Vom Benutzer erstellte Tabellen im mysql-Schema werden nicht migriert.
Der innodb_data_file_path-Parameter darf nur mit einer Datendatei konfiguriert werden, die den Standarddateinamen ibdata1:12M:autoextend verwendet. Datenbanken mit zwei Datendateien oder nur einer Datendatei eines anderen Namens können mit dieser Methode nicht migriert werden.

Nachfolgend finden Sie Beispiele für unzulässige Dateinamen: innodb_data_file_path=ibdata1:50M, ibdata2:50M:autoextend und 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 Sicherungen mit dieser Methode ist derzeit auf 64 TiB begrenzt. Bei komprimierten Sicherungen wird dieser Grenzwert gesenkt, um den Speicheranforderungen bei der Dekomprimierung Rechnung zu tragen. In solchen Fällen wäre die maximal unterstützte Backup-Größe (64 TiB – compressed backup size).
Aurora MySQL unterstützt den Import von MySQL und anderen externen Komponenten und Plugins nicht.
Aurora MySQL stellt nicht die gesamte Datenbank wieder her. Sie sollten das Datenbankschema und die Werte der folgenden Elemente der MySQL-Quelldatenbank speichern und dem Aurora MySQL-DB-Cluster nach der Wiederherstellung hinzufügen:
- Benutzerkonten
- Funktionen
- Gespeicherte Prozeduren
- Zeitzoneninformation. Die Zeitzoneninformation wird vom lokalen Betriebssystem des Amazon Aurora MySQL-DB-Clusters übernommen. Weitere Informationen finden Sie unter Lokale Zeitzone für Amazon Aurora-DB-Cluster.

Bevor Sie beginnen

Bevor Sie Ihre Daten in einen Amazon S3-Bucket kopieren und daraus einen DB-Cluster wiederherstellen können, müssen Sie folgende Schritte durchführen:

Installieren Sie Percona XtraBackup auf Ihrem lokalen Server.
Autorisieren Sie Aurora MySQL für den Zugriff auf den Amazon S3-Bucket in Ihrem Namen.

Percona installieren XtraBackup

Amazon Aurora kann einen DB-Cluster aus Dateien wiederherstellen, die mit Percona XtraBackup erstellt wurden. Sie können Percona XtraBackup über Software-Downloads — Percona installieren.

Verwenden Sie für die MySQL 5.7-Migration Percona XtraBackup 2.4.

Verwenden Sie für die MySQL 8.0-Migration Percona XtraBackup 8.0. Stellen Sie sicher, dass die XtraBackup Percona-Version mit der Engine-Version Ihrer Quelldatenbank kompatibel ist.

Erforderliche Berechtigungen

Für die Migration von MySQL-Daten in einen Amazon Aurora MySQL-DB-Cluster sind mehrere Berechtigungen erforderlich:

Der Benutzer, der Aurora auffordert, einen neuen Cluster aus einem Amazon S3 S3-Bucket zu erstellen, muss über die Berechtigung verfügen, die Buckets für Ihr AWS Konto aufzulisten. Sie gewähren dem Benutzer diese Berechtigung mithilfe einer AWS Identity and Access Management (IAM-) Richtlinie.
Aurora benötigt die Berechtigung, in Ihrem Namen auf den Amazon S3-Bucket mit den Dateien zum Erstellen des Amazon Aurora MySQL-DB-Clusters zuzugreifen. Sie erteilen Aurora die erforderlichen Berechtigungen, indem Sie eine IAM-Servicerolle verwenden.
Der anfordernde Benutzer muss zudem über die Berechtigung zum Auflisten der IAM-Rollen Ihres AWS -Kontos verfügen.
Wenn der anfordernde Benutzer die IAM-Servicerolle erstellen oder anfordern möchte, dass die IAM-Servicerolle von Aurora erstellt wird (über die Konsole), muss er über die Berechtigung zum Erstellen einer IAM-Rolle für Ihr AWS -Konto verfügen.
Wenn Sie beabsichtigen, die Daten während des Migrationsprozesses zu verschlüsseln, aktualisieren Sie die IAM-Richtlinie des Benutzers, der die Migration durchführen wird, um RDS-Zugriff auf die für die Verschlüsselung der Backups AWS KMS keys verwendeten Daten zu gewähren. Anweisungen finden Sie unter Erstellen einer IAM-Zugriffsrichtlinie für AWS KMS-Ressourcen.

Die folgende IAM-Richtlinie gewährt einem Benutzer beispielsweise die erforderlichen Mindestberechtigungen zur Verwendung der Konsole, um IAM-Rollen aufzulisten, eine IAM-Rolle zu erstellen, die Amazon S3-Buckets für Ihr Konto aufzulisten und die KMS-Schlüssel aufzulisten.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iam:ListRoles",
                "iam:CreateRole",
                "iam:CreatePolicy",
                "iam:AttachRolePolicy",
                "s3:ListBucket",
                "kms:ListKeys"
            ],
            "Resource": "*"
        }
    ]
}

Damit ein IAM-Benutzer eine IAM-Rolle mit einem Amazon S3-Bucket verknüpfen kann, muss der IAM-Benutzer die Berechtigung iam:PassRole für diese IAM-Rolle besitzen. Mit dieser Berechtigung kann ein Administrator einschränken, welche IAM-Rollen ein Benutzer mit Amazon S3-Buckets verknüpfen kann.

So ermöglicht die folgende IAM-Richtlinie einem Benutzer, die Rolle namens S3Access mit einem Amazon S3-Bucket zu verknüpfen.


{
    "Version":"2012-10-17",
    "Statement":[
        {
            "Sid":"AllowS3AccessRole",
            "Effect":"Allow",
            "Action":"iam:PassRole",
            "Resource":"arn:aws:iam::123456789012:role/S3Access"
        }
    ]
}

Weitere Informationen zu IAM-Benutzerberechtigungen finden Sie unter Verwalten des Zugriffs mit Richtlinien.

Erstellen der IAM-Servicerolle

Sie können eine Rolle für sich selbst AWS Management Console erstellen lassen, indem Sie die Option Neue Rolle erstellen wählen (siehe weiter unten in diesem Thema). Wenn Sie diese Option auswählen und einen Namen für die neue Rolle angeben, erstellt Aurora die benötigte IAM-Servicerolle, damit Aurora mit dem von Ihnen angegebenen Namen auf Ihren Amazon S3-Bucket zugreifen kann.

Alternativ können Sie die Rolle auf folgende Weise manuell erstellen.

So erstellen Sie eine IAM-Rolle für Aurora zum Zugriff auf Amazon S3

Führen Sie die Schritte unter au Eine IAM Richtlinie für den Zugriff auf Amazon S3 S3-Ressourcen erstellen.
Führen Sie die Schritte unter au Erstellen einer IAM-Rolle, um Amazon Aurora den Zugriff auf AWS-Services zu erlauben.
Führen Sie die Schritte unter au Zuweisen einer IAM-Rolle zu einem Amazon-Aurora-MySQL-DB-Cluster.

Sichern der wiederherzustellenden Dateien als Amazon Aurora MySQL-DB-Cluster

Sie können mit Percona eine vollständige Sicherung Ihrer MySQL-Datenbankdateien erstellen XtraBackup und die Sicherungsdateien in einen Amazon S3 S3-Bucket hochladen. 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 in einen Amazon S3 S3-Bucket hochladen.

Themen

Erstellen Sie ein vollständiges Backup mit Percona XtraBackup
Verwenden von inkrementellen Backups mit Percona XtraBackup
Überlegungen zu Sicherungen

Erstellen Sie ein vollständiges Backup mit Percona XtraBackup

Um eine vollständige Sicherung Ihrer MySQL-Datenbankdateien zu erstellen, die aus Amazon S3 wiederhergestellt werden kann, um einen Aurora MySQL-DB-Cluster zu erstellen, verwenden Sie das XtraBackup Percona-Hilfsprogramm (xtrabackup), um Ihre Datenbank zu sichern.

Mit dem folgenden Befehl können Sie beispielsweise eine Sicherung 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 die Sicherung in einer Archivdatei komprimieren möchten (die bei Bedarf aufgeteilt werden kann), können Sie mit der Option --stream eines der folgenden Formate festlegen:

Gzip (.gz)
tar (.tar)
Percona xbstream (.xbstream)

Mit dem folgenden Befehl wird eine Sicherung einer MySQL-Datenbank erstellt und in mehreren Gzip-Dateien gespeichert.


xtrabackup --backup --user=<myuser> --password=<password> --stream=tar \
   --target-dir=</on-premises/s3-restore/backup> | gzip - | split -d --bytes=500MB \
   - </on-premises/s3-restore/backup/backup>.tar.gz

Mit dem folgenden Befehl wird ein Backup einer MySQL-Datenbank erstellt und in mehreren tar-Dateien gespeichert.


xtrabackup --backup --user=<myuser> --password=<password> --stream=tar \
   --target-dir=</on-premises/s3-restore/backup> | split -d --bytes=500MB \
   - </on-premises/s3-restore/backup/backup>.tar

Mit dem folgenden Befehl wird ein Backup einer MySQL-Datenbank erstellt und in mehreren xbstream-Dateien gespeichert.


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

Falls 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

Sobald Sie Ihre MySQL-Datenbank mit dem XtraBackup Percona-Hilfsprogramm gesichert haben, können Sie Ihre Backup-Verzeichnisse und -Dateien in einen Amazon S3 S3-Bucket kopieren.

Weitere Informationen zum Erstellen und Hochladen einer Datei in einen Amazon S3-Bucket finden Sie unter Erste Schritte mit Amazon Simple Storage Service im Amazon S3-Handbuch "Erste Schritte".

Verwenden von inkrementellen Backups mit Percona XtraBackup

Amazon Aurora MySQL unterstützt sowohl vollständige als auch inkrementelle Backups, die mit XtraBackup Percona erstellt wurden. 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. Sie können stattdessen viel Zeit sparen, indem Sie die vorhandenen Sicherungsverzeichnisse und -dateien der vollständigen und inkrementelle Sicherungen in einen Amazon S3-Bucket hochladen. Weitere Informationen finden Sie unter Ein inkrementelles Backup erstellen 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. Aurora durchläuft alle Dateien und Verzeichnisse. Aurora verwendet die in jedem inkrementellen Backup enthaltene xtrabackup-checkpoints-Datei, um das Basisverzeichnis zu identifizieren und inkrementelle Backups nach dem Bereich der Protokollsequenznummer (Log Sequence Number, LSN) zu ordnen.

Weitere Informationen zum Erstellen und Hochladen einer Datei in einen Amazon S3-Bucket finden Sie unter Erste Schritte mit Amazon Simple Storage Service im Amazon S3-Handbuch "Erste Schritte".

Überlegungen zu Sicherungen

Aurora unterstützt keine Teil-Backups, die mit Percona XtraBackup erstellt wurden. Sie können beim Sichern der Quelldateien Ihrer Datenbank nicht die folgenden Optionen verwenden, um eine Teilsicherung zu erstellen: --tables, --tables-exclude, --tables-file, --databases, --databases-exclude oder --databases-file.

Weitere Informationen zum Sichern Ihrer Datenbank mit Percona finden Sie unter Percona XtraBackup XtraBackup — Dokumentation und Arbeiten mit Binärprotokollen auf der Percona-Website.

Aurora unterstützt inkrementelle Backups, die mit XtraBackup Percona erstellt wurden. Weitere Informationen finden Sie unter Ein inkrementelles Backup erstellen auf der Percona-Website.

Aurora verarbeitet Sicherungsdateien auf Basis des Dateinamens. Achten Sie daher unbedingt darauf, dass die Namenserweiterungen der Sicherungsdateien dem Dateiformat entsprechen — z. B. .xbstream für Dateien, die im xbstream-Format von Percona gespeichert wurden.

Aurora verarbeitet Sicherungsdateien in alphanumerischer Reihenfolge. Verwenden Sie immer die Option split für den Befehl xtrabackup, um sicherzustellen, dass die Sicherungsdateien in der richtigen Reihenfolge geschrieben und benannt werden.

Amazon S3 begrenzt die Größe einer Datei, die in einen Amazon S3-Bucket hochgeladen werden kann, auf 5 TB. Wenn die Sicherungsdaten Ihrer Datenbank 5 TB überschreiten, müssen Sie die Sicherungsdateien mit dem Befehl split in mehrere Dateien aufteilen, die jeweils kleiner als 5 TB sind.

Aurora begrenzt die Anzahl der Quelldateien, die in einen Amazon S3-Bucket hochgeladen werden können, auf 1 Million Dateien. In manchen Situationen können die Sicherungsdaten Ihrer Datenbank einschließlich aller vollständigen und inkrementellen Sicherungen aus sehr vielen Dateien bestehen. Verwenden Sie in diesen Fällen ein tar-Archiv (.tar.gz), um die Dateien der vollständigen und inkrementellen Sicherungen im Amazon S3-Bucket zu speichern.

Sie können Dateien beim Hochladen in einen Amazon S3-Bucket serverseitig verschlüsseln lassen. Anschließend können Sie aus diesen verschlüsselten Dateien ein Amazon-Aurora-MySQL-DB-Cluster wiederherstellen. Amazon Aurora MySQL kann DB-Cluster mit Dateien wiederherstellen, die mittels der folgenden Arten der serverseitigen Verschlüsselung verschlüsselt wurden:

Serverseitige Verschlüsselung mit von Amazon S3 verwalteten Schlüsseln (SSE-S3): Jedes Objekt wird mit einem eindeutigen Schlüssel mit starker Multifaktor-Verschlüsselung verschlüsselt.
Serverseitige Verschlüsselung mit AWS KMS verwalteten Schlüsseln (SSE-KMS) — Ähnlich wie SSE-S3, aber Sie haben die Möglichkeit, Verschlüsselungsschlüssel selbst zu erstellen und zu verwalten, und es gibt auch andere Unterschiede.

Informationen zur serverseitigen Verschlüsselung beim Hochladen von Dateien in einen Amazon S3-Bucket finden Sie unter Schützen von Daten mithilfe serverseitiger Verschlüsselung im Amazon S3-Entwicklerhandbuch.

Wiederherstellen eines Amazon Aurora-MySQL-DB-Clusters aus einem Amazon S3-Bucket

Sie können Ihre Sicherungsdateien aus Ihrem Amazon-S3-Bucket wiederherstellen, um einen neuen Amazon-Aurora-MySQL-DB-Cluster zu erstellen, indem Sie die Amazon-RDS-Konsole verwenden.

So stellen Sie ein Amazon Aurora MySQL-DB-Cluster aus Dateien in einem Amazon S3-Bucket wieder her

Melden Sie sich bei der Amazon RDS-Konsole an AWS Management Console und öffnen Sie sie unter https://console.aws.amazon.com/rds/.
Wählen Sie in der oberen rechten Ecke der Amazon RDS-Konsole die AWS Region aus, in der Sie Ihren DB-Cluster erstellen möchten. Wählen Sie dieselbe AWS Region wie der Amazon S3 S3-Bucket, der Ihr Datenbank-Backup enthält.
Wählen Sie im Navigationsbereich Databases (Datenbanken) und dann die Option Restore from S3 (Aus S3 wiederherstellen) aus.
Wählen Sie Von S3 wiederherstellen.

Die Seite Datenbank durch Wiederherstellen von S3 erstellen wird angezeigt.
Unter S3-Ziel:
1. Wählen Sie den S3-Bucket aus, in dem sich die Sicherungsdateien befinden.
2. (Optional) Geben Sie für S3 folder path prefix (S3-Ordnerpfadpräfix) ein Dateipfadpräfix für die Dateien ein, die in Ihrem Amazon S3-Bucket gespeichert sind.
  
  Wenn Sie kein Präfix angeben, dann erstellt RDS Ihre DB-Instance unter Verwendung aller Dateien und Ordner im Stammordner des S3-Bucket. Wenn Sie ein Präfix angeben, erstellt 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 Sicherungsdateien auf S3 in einem Unterordner namens 'backups' und haben mehrere Sätze von Sicherungsdateien, die sich jeweils in einem eigenen Verzeichnis befinden (gzip_backup1, gzip_backup2 usw.). Sie müssen nun das Präfix backups/gzip_backup1 angeben, um die Wiederherstellung mit den Dateien im Ordner gzip_backup1 durchzuführen.
Unter Engine-Optionen:
1. Wählen Sie in Engine type (Engine-Typ) die Option Amazon Aurora aus.
2. Wählen Sie für Version die Aurora MySQL-Engine-Version für Ihre wiederhergestellte DB-Instance aus.
Für die IAM-Rolle können Sie eine vorhandene IAM-Rolle auswählen.
(Optional) Sie können auch eine neue IAM-Rolle erstellen lassen, indem Sie Neue Rolle erstellen wählen. Wenn ja:
1. Geben Sie den IAM-Rollennamen ein.
2. Wählen Sie aus, ob Sie den Zugriff auf den KMS-Schlüssel zulassen möchten:
  - Wenn Sie die Sicherungsdateien nicht verschlüsselt haben, wählen Sie No (Nein) aus.
  - Wenn Sie die Sicherungsdateien mit AES-256 (SSE-S3) verschlüsselt haben, als Sie diese zu Amazon S3 hochgeladen haben, wählen Sie Nein aus. In diesem Fall werden die Daten automatisch entschlüsselt.
  - Wenn Sie die Sicherungsdateien beim Hochladen auf Amazon S3 mit serverseitiger Verschlüsselung AWS KMS (SSE-KMS) verschlüsselt haben, wählen Sie Ja. Wählen Sie dann den richtigen KMS-Schlüssel für AWS KMS key.
    
    Das AWS Management Console erstellt eine IAM-Richtlinie, die es Aurora ermöglicht, die Daten zu entschlüsseln.
  Weitere Informationen finden Sie unter Schützen von Daten mithilfe serverseitiger Verschlüsselung im Amazon S3-Entwicklerhandbuch.
Wählen Sie Einstellungen für Ihren DB-Cluster aus, z. B. die DB-Cluster-Speicherkonfiguration, die DB-Instance-Klasse, die DB-Cluster-ID und die Anmeldeinformationen. Weitere Informationen zu den einzelnen Einstellungen finden Sie unter Einstellungen für Aurora-DB-Cluster.
Passen Sie zusätzliche Einstellungen für Ihren Aurora MySQL-DB-Cluster nach Bedarf an.
Wählen Sie Create database (Datenbank erstellen) , um Ihre Aurora-DB-Instance zu starten.

In der Amazon RDS-Konsole wird die neue DB-Instance in der Liste der DB-Instances angezeigt. Die DB-Instance wird mit dem Status creating (Wird erstellt) angezeigt, bis sie erstellt wurde und einsatzbereit ist. Wenn sich der Status in available (Verfügbar) ändert, können Sie die Verbindung mit der primären Instance des DB-Clusters herstellen. Je nach Klasse und Speicherort der DB-Instance kann es einige Minuten dauern, bis sie verfügbar ist.

Um das neu erstellte Cluster anzuzeigen, wählen Sie die Ansicht Database (Datenbank) in der Amazon RDS-Konsole und anschließend das DB-Cluster aus. Weitere Informationen finden Sie unter Anzeigen eines Amazon Aurora-DB-Clusters.

Notieren Sie den Port und den Writer-Endpunkt des DB-Clusters. Verwenden Sie den Writer-Endpunkt und den Port des DB-Clusters in den JDBC- und ODBC-Verbindungszeichenfolgen aller Anwendungen, die Lese- oder Schreibvorgänge ausführen.

Synchronisieren des Amazon Aurora MySQL-DB-Clusters mit der MySQL-Datenbank mittels Replikation

Damit es zu einer möglichst kurzen bzw. überhaupt keiner Unterbrechung während der Migration kommt, können Sie die in der MySQL-Datenbank durchgeführten Transaktionen mittels Replikation in das Aurora MySQL-DB-Cluster übernehmen. Durch die Replikation können die in der MySQL-Datenbank während der Migration durchgeführten Transaktionen in das DB-Cluster übernommen werden. Sobald das DB-Cluster auf dem Stand des MySQL-Masters ist, können Sie die Replikation anhalten und die Migration nach Aurora MySQL beenden.

Themen

Konfigurieren der externen MySQL-Datenbank und des Aurora MySQL-DB-Clusters für die verschlüsselte Replikation
Synchronisieren des Amazon Aurora MySQL-DB-Clusters mit der externen MySQL-Datenbank

Konfigurieren der externen MySQL-Datenbank und des Aurora MySQL-DB-Clusters für die verschlüsselte Replikation

Wenn Sie Daten sicher replizieren möchten, können Sie eine verschlüsselte Replikation verwenden.

Anmerkung

Wenn Sie keine verschlüsselte Replikation benötigen, können Sie diese Schritte überspringen und mit der Anleitung unter fortfahre Synchronisieren des Amazon Aurora MySQL-DB-Clusters mit der externen MySQL-Datenbank.

Folgende Voraussetzungen gelten für die Verwendung einer verschlüsselten Replikation:

Secure Sockets Layer (SSL) muss in der externen MySQL-Primärdatenbank aktiviert sein.
Ein Clientschlüssel und ein Clientzertifikat müssen für das Aurora MySQL-DB-Cluster vorbereitet werden.

Während der verschlüsselten Replikation dient das Aurora MySQL-DB-Cluster als Client für den MySQL-Datenbankserver. Die Zertifikate und Schlüssel für den Aurora MySQL-Client befinden sich in Dateien im PEM-Format.

So konfigurieren Sie die externe MySQL-Datenbank und das Aurora MySQL-DB-Cluster für die verschlüsselte Replikation

Stellen Sie sicher, dass alle Vorbereitungen für die verschlüsselte Replikation getroffen wurden:
- Wenn SSL auf dem externen Server mit der MySQL-Primärdatenbank nicht aktiviert ist und Sie keinen Clientschlüssel und kein Clientzertifikat vorbereitet haben, aktivieren Sie SSL auf dem MySQL-Datenbankserver und generieren Sie den Clientschlüssel und das Clientzertifikat.
- Wenn SSL auf die externen Primäre aktiviert ist, geben Sie einen Clientschlüssel und ein Clientzertifikat für das Aurora MySQL-DB-Cluster an. Wenn Sie diese Werte nicht haben, erstellen Sie ein einen neuen Schlüssel und ein neues Zertifikat für das Aurora MySQL-DB-Cluster. Sie benötigen zur Signierung des Clientzertifikats den Zertifizierungsstellenschlüssel, den Sie zum Konfigurieren von SSL auf der externen MySQL-Primärdatenbank verwendet haben.
Weitere Informationen finden Sie unter Creating SSL Certificates and Keys Using openssl in der MySQL-Dokumentation.

Sie benötigen das Zertifizierungsstellenzertifikat, den Clientschlüssel und das Clientzertifikat.
Stellen Sie als Primärbenutzer über SSL eine Verbindung zum Aurora MySQL-DB-Cluster her.

Informationen zum Herstellen einer Verbindung mit einem Aurora MySQL-DB-Cluster über SSL finden Sie unter TLSVerbindungen zu Aurora My SQL DB-Clustern.

Führen Sie die gespeicherte Prozedur mysql.rds_import_binlog_ssl_material aus, um die SSL-Informationen in das Aurora MySQL-DB-Cluster zu importieren.

Fügen Sie die Informationen aus den PEM-Dateien für das Aurora MySQL-DB-Cluster in die korrekte JSON-Nutzlast für den Parameter ssl_material_value ein.

Im folgenden Beispiel werden SSL-Informationen in ein Aurora MySQL-DB-Cluster importiert. Der Code in den PEM-Dateien ist in der Regel länger als in diesem Beispiel.


call mysql.rds_import_binlog_ssl_material(
'{"ssl_ca":"-----BEGIN CERTIFICATE-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END CERTIFICATE-----\n","ssl_cert":"-----BEGIN CERTIFICATE-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END CERTIFICATE-----\n","ssl_key":"-----BEGIN RSA PRIVATE KEY-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END RSA PRIVATE KEY-----\n"}');

Weitere Informationen finden Sie unter mysql.rds_import_binlog_ssl_material und TLSVerbindungen zu Aurora My SQL DB-Clustern.

Anmerkung

Nach dem Ausführen der Prozedur werden die SSL-Informationen in Dateien gespeichert. Um die Dateien später zu löschen, können Sie die mysql.rds_remove_binlog_ssl_material gespeicherte Prozedur ausführen.

Synchronisieren des Amazon Aurora MySQL-DB-Clusters mit der externen MySQL-Datenbank

Sie können das Amazon Aurora MySQL-DB-Cluster mittels Replikation mit der MySQL-Datenbank synchronisieren.

So synchronisieren Sie das Aurora MySQL-DB-Cluster mittels Replikation mit der MySQL-Datenbank

Stellen Sie sicher, dass die Datei "/etc/my.cnf" für die externe MySQL-Datenbank die relevanten Einträge enthält.

Wenn keine verschlüsselte Replikation erforderlich ist, muss die externe MySQL-Datenbank mit aktivierten Binärprotokollen (binlogs) und deaktiviertem SSL gestartet werden. Dies sind die relevanten Einträge für unverschlüsselte Daten in der Datei "/etc/my.cnf".
```
log-bin=mysql-bin
server-id=2133421
innodb_flush_log_at_trx_commit=1
sync_binlog=1
```
Wenn die verschlüsselte Replikation erforderlich ist, muss die externe MySQL-Datenbank mit aktivierten Binärprotokollen und aktiviertem SSL gestartet werden. Die Einträge in der Datei "/etc/my.cnf" müssen dann die Speicherorte der PEM-Dateien für den MySQL-Datenbankserver enthalten.
```
log-bin=mysql-bin
server-id=2133421
innodb_flush_log_at_trx_commit=1
sync_binlog=1

# Setup SSL.
ssl-ca=/home/sslcerts/ca.pem
ssl-cert=/home/sslcerts/server-cert.pem
ssl-key=/home/sslcerts/server-key.pem
```
Mit dem folgenden Befehl können Sie prüfen, ob SSL aktiviert ist.
```
mysql> show variables like 'have_ssl';
```
Die Ausgabe sollte in etwa wie folgt aussehen.
```
+~-~-~-~-~-~-~-~-~-~-~-~-~-~--+~-~-~-~-~-~--+
| Variable_name | Value |
+~-~-~-~-~-~-~-~-~-~-~-~-~-~--+~-~-~-~-~-~--+
| have_ssl      | YES   |
+~-~-~-~-~-~-~-~-~-~-~-~-~-~--+~-~-~-~-~-~--+
1 row in set (0.00 sec)
```
Bestimmen Sie die Startposition für die Replikation im Binärprotokoll. Sie legen die Startposition für die Replikation in einem späteren Schritt fest.

Mit dem AWS Management Console
1. Melden Sie sich bei der Amazon RDS-Konsole an AWS Management Console und öffnen Sie sie unter https://console.aws.amazon.com/rds/.
2. Wählen Sie im Navigationsbereich die Option Events.
3. Notieren Sie in der Liste Events (Ereignisse) die Position im Ereignis Recovered from Binary log filename (Wiederhergestellt aus Binärprotokoll-Dateiname).
Verwenden Sie den AWS CLI

Sie können den Namen und die Position der Binlog-Datei auch mit dem Befehl AWS CLI describe-events abrufen. Im Folgenden wird ein describe-events Beispielbefehl gezeigt.
```
PROMPT> aws rds describe-events
```
Identifizieren Sie in der Ausgabe das Ereignis, das die Binärprotokoll-Position anzeigt.
Erstellen Sie bei bestehender Verbindung mit der externen MySQL-Datenbank einen Benutzer für die Replikation. 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. Im Folgenden wird ein Beispiel gezeigt.
```
mysql> CREATE USER '<user_name>'@'<domain_name>' IDENTIFIED BY '<password>';
```
Der Benutzer benötigt die Berechtigungen REPLICATION CLIENT und REPLICATION SLAVE. Gewähren Sie dem Benutzer diese Berechtigungen.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO '<user_name>'@'<domain_name>';
```
Wenn die Replikation verschlüsselt durchgeführt werden muss, fordern Sie für den Replikationsbenutzer eine SSL-Verbindung an. Sie können beispielsweise das folgende Statement verwenden, damit für das Benutzerkonto "encrypted_user" eine SSL-Verbindung <user_name>.
```
GRANT USAGE ON *.* TO '<user_name>'@'<domain_name>' REQUIRE SSL;
```
Anmerkung
Wenn REQUIRE SSL nicht angegeben wird, kann die Replikationsverbindung ohne entsprechende Meldung auf eine unverschlüsselte Verbindung zurückgesetzt werden.
Fügen Sie in der Amazon RDS-Console die IP-Adresse des Servers, der die externe MySQL-Datenbank hostet, zur VPC-Sicherheitsgruppe für den Aurora MySQL-DB-Cluster hinzu. Weitere Informationen zum Ändern einer VPC-Sicherheitsgruppe finden Sie unter Sicherheitsgruppen für Ihre VPC im Amazon Virtual Private Cloud-Benutzerhandbuch.

Sie müssen möglicherweise noch das lokale Netzwerk so konfigurieren, dass es Verbindungen von der IP-Adresse des Aurora MySQL-DB-Clusters zulässt, damit Sie mit der externen MySQL-Datenbank kommunizieren können. Verwenden Sie den Befehl host, um die IP-Adresse des Aurora MySQL-DB-Clusters herauszufinden.
```
host <db_cluster_endpoint>
```
Der Hostname ist der DNS-Name aus dem Aurora MySQL-DB-Cluster-Endpunkt.
Aktivieren Sie die Binärprotokollreplikation, indem Sie die gespeicherte Prozedur mysql.rds_reset_external_master (Aurora Meine Version 2) SQL oder mysql.rds_reset_external_source (Aurora Meine Version 3) SQL ausführen. Diese gespeicherte Prozedur hat die folgende Syntax.
```
CALL mysql.rds_set_external_master (
  host_name
  , host_port
  , replication_user_name
  , replication_user_password
  , mysql_binary_log_file_name
  , mysql_binary_log_file_location
  , ssl_encryption
);

CALL mysql.rds_set_external_source (
  host_name
  , host_port
  , replication_user_name
  , replication_user_password
  , mysql_binary_log_file_name
  , mysql_binary_log_file_location
  , ssl_encryption
);
```
Informationen zu den Parametern finden Sie unter mysql.rds_reset_external_master (Aurora Meine Version 2) SQL und mysql.rds_reset_external_source (Aurora Meine Version 3) SQL.

Verwenden Sie für mysql_binary_log_file_name und mysql_binary_log_file_location die Position im Ereignis Recovered from Binary log filename (Wiederhergestellt aus Binärprotokoll-Dateiname), die Sie zuvor notiert haben.

Wenn die Daten im Aurora MySQL-DB-Cluster nicht verschlüsselt sind, muss der Parameter ssl_encryption auf 0 festgelegt werden. Sind die Daten verschlüsselt, muss der Parameter ssl_encryption auf 1 gesetzt werden.

Im folgenden Beispiel wird die Prozedur für ein Aurora MySQL-DB-Cluster mit verschlüsselten Daten ausgeführt.
```
CALL mysql.rds_set_external_master(
  'Externaldb.some.com',
  3306,
  'repl_user'@'mydomain.com',
  'password',
  'mysql-bin.000010',
  120,
  1);

CALL mysql.rds_set_external_source(
  'Externaldb.some.com',
  3306,
  'repl_user'@'mydomain.com',
  'password',
  'mysql-bin.000010',
  120,
  1);
```
Diese gespeicherte Prozedur weist die Parameter zu, die das Aurora MySQL-DB-Cluster zum Herstellen einer Verbindung mit der externen MySQL-Datenbank und zum Lesen seines Binärprotokolls verwendet. Wenn die Daten verschlüsselt sind, werden auch das SSL-Zertifizierungsstellenzertifikat, das Clientzertifikat und der Clientschlüssel auf die lokale Festplatte heruntergeladen.
Starten Sie die Binärprotokollreplikation, indem Sie die gespeicherte Prozedur mysql.rds_start_replication ausführen.
```
CALL mysql.rds_start_replication;
```
Überwachen Sie den Rückstand des Aurora MySQL-DB-Clusters gegenüber der MySQL-Replikationsprimärdatenbank. Stellen Sie dazu eine Verbindung zum Aurora MySQL-DB-Cluster her und führen Sie den folgenden Befehl aus.
```
Aurora MySQL version 2:
SHOW SLAVE STATUS;

Aurora MySQL version 3:
SHOW REPLICA STATUS;
```
In der Befehlsausgabe wird im Feld Seconds Behind Master angezeigt, wie weit das Aurora MySQL-DB-Cluster hinter der MySQL-Primären zurückliegt. Wenn dieser Wert 0 (null) lautet, hat das Aurora MySQL-DB-Cluster den Stand der Primären erreicht und Sie können im nächsten Schritt die Replikation anhalten.
Stellen Sie eine Verbindung zur MySQL-Replikationsprimärdatenbank her und halten Sie die Replikation an. Rufen Sie dazu die gespeicherte Prozedur mysql.rds_stop_replication auf.
```
CALL mysql.rds_stop_replication;
```

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Migrieren von einer externen MySQL-Datenbank zu Aurora MySQL

Verkürzung der physischen Migrationszeit