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 MariaDB mit reduzierter Ausfallzeit
In einigen Situationen müssen Sie möglicherweise Daten aus einer externen MariaDB-Datenbank importieren, die eine Live-Anwendung für eine DB-Instance von RDS für MariaDB 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 Importkosten senken, indem Sie die Datenmenge reduzieren, die über das Netzwerk an übertragen wird AWS.
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. Wenn die externe Instance MariaDB 10.0.24 oder höher ist und die Zielinstanz RDS for MariaDB ist, konfigurieren Sie die MariaDB-Replikation basierend auf globalen Transaktions-Identifikatoren (). GTIDs Andernfalls konfigurieren Sie die Replikation basierend auf den Binärprotokollkoordinaten. Wir empfehlen die GTID-basierte Replikation, wenn Ihre externe Datenbank diese unterstützt, da diese Methode zuverlässiger ist. Weitere Informationen finden Sie unter [Global Transaction ID](http://mariadb.com/kb/en/mariadb/global-transaction-id/) in der MariaDB-Dokumentation.
Im folgenden Diagramm ist der Import einer externen MariaDB-Datenbank in eine MariaDB-Datenbank auf Amazon RDS veranschaulicht.
![\[Workflow, der den Import einer externen MariaDB-Datenbank in eine MariaDB-Datenbank auf Amazon RDS darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_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 MariaDB mit minimaler Ausfallzeit besteht darin, eine Kopie der Quelldaten zu erstellen.
Das folgende Diagramm veranschaulicht die Erstellung eines Backups der MariaDB-Datenbank.
![\[Workflow, der das Erstellen eines Backups der MariaDB-Datenbank darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_2.png)
Sie können das Dienstprogramm `mysqldump` oder `mariadb-dump` verwenden, um ein Datenbank-Backup im SQL-Format oder im separierten Textformat zu erstellen. [In MariaDB 10.5 heißt der Client mariadb-dump](https://mariadb.com/kb/en/mariadb-dump/). Ab MariaDB 11.0.1 müssen Sie `mariadb-dump` anstelle von `mysqldump` verwenden. Es wird empfohlen, mit jedem Format in einer Nichtproduktionsumgebung einen Testlauf durchzuführen, um festzustellen, welche Methode die Ausführungsdauer von `mysqldump` oder `mariadb-dump` minimiert.
Wir empfehlen auch, dass Sie die Leistung von `mysqldump` oder `mariadb-dump` 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](mariadb-importing-data-any-source.md#mariadb-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 MariaDB-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` oder `mariadb-dump`, da sie einen einheitlichen Zustand der Datenbank speichert. Um für eine gültige Dump-Datei zu sorgen, führen Sie beim Ausführen von `mysqldump` oder `mariadb-dump` 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`
Die Dienstprogramme `mysqldump` und `mariadb-dump` schließen 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 Utility. [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 `[mariadb]`-Abschnitt einer `my.cnf`-Datei angegeben:
```
[mariadb]
log-bin
server-id=1
log-basename=master1
binlog-format=mixed
```
Weitere Informationen finden Sie unter [Setting the Replication Source Configuration](https://mariadb.com/docs/server/ha-and-performance/standard-replication/setting-up-replication) in der MariaDB-Dokumentation.
1. Aktivieren Sie `gtid_strict_mode` für die Replikation mit einem Multi-AZ-DB-Cluster. Weitere Informationen finden Sie unter [gtid\$1strict\$1mode](https://mariadb.com/docs/server/ha-and-performance/standard-replication/gtid#gtid_strict_mode) in der MariaDB-Dokumentation.
Eine Aktivierung von `gtid_strict_mode` ist für die Replikation mit einer DB-Instance nicht erforderlich.
1. Den Service `mariadb` neu starten.
```
sudo service mariadb restart
```
### So erstellen Sie eine Sicherungskopie für Ihre bestehende Datenbank:
1. Erstellen Sie ein Backup für Ihre Daten mithilfe des Dienstprogramms `mysqldump` oder `mariadb-dump`, indem Sie es im SQL-Format oder im separierten Textformat festlegen.
Verwenden Sie die Optionen `--order-by-primary` und `--single-transaction` für `mysqldump` und `mariadb-dump`, um die Leistung zu verbessern und die Datenintegrität zu sichern.
Verwenden Sie die Option `--all-databases` nicht mit `mysqldump` oder `mariadb-dump`, 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. Ersetzen Sie für MariaDB 10.11 und ältere Versionen `mariadb-dump` durch `mysqldump`.
Für Linux, macOS oder Unix:
```
sudo mariadb-dump \
--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:
```
mariadb-dump ^
--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. Ersetzen Sie für MariaDB 11.01 und höhere Versionen `mysqldump` durch `mariadb-dump`.
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. Wenn sich eines dieser Objekte in der Datenbank befindet, die Sie kopieren, schließen Sie sie beim Ausführen von `mysqldump` oder `mariadb-dump` aus. Fügen Sie dazu die folgenden Argumente in den Befehl `mysqldump` oder `mariadb-dump` ein:
`--routines=0`
`--triggers=0`
`--events=0`
Wenn Sie `mysqldump` ausführen und das separierte Textformat verwenden, wird ein `CHANGE MASTER TO`-Kommentar zurückgegeben. Dieser Kommentar beinhaltet den Namen und die Position der Hauptprotokolldatei. Wenn es sich bei der externen Instance um MariaDB 10.0.23 oder eine ältere 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 MariaDB-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;
```
1. Wenn die verwendete externe Instance MariaDB 10.0.24 oder höher ist, nutzen Sie die GTID-basierte Replikation. Führen Sie `SHOW MASTER STATUS` in der externen MariaDB-Instance aus, um den Namen und die Position der Binärprotokolldatei zu erhalten. Konvertieren Sie dann die Werte in GTID, indem Sie `BINLOG_GTID_POS` in der externen MariaDB-Instance ausführen.
```
SELECT BINLOG_GTID_POS('binary_log_file_name', binary_log_file_position);
```
Notieren Sie die zurückgegebene GTID. Sie benötigen sie für die Konfiguration der Replikation.
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. Sobald sich die Daten in Amazon EC2 befinden, können Sie diese von dort direkt in die MariaDB-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 EC2-Instance in derselben Datenbank AWS-Region wie Ihre Amazon RDS-Datenbank befindet, wird auch die Netzwerklatenz während des Imports 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/MigrateMariaDBToRDS_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. Stellen Sie eine Verbindung mit der Amazon EC2-Instance her und installieren Sie die neusten Updates und MariaDB-Client-Tools mithilfe der folgenden Befehle:
```
sudo yum update -y
sudo yum install mariadb1011-client-utils -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* und [MariaDB Connectors](https://mariadb.com/docs/connectors) in der MariaDB-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 MariaDB-Datenbank und Importieren von Daten aus der Amazon EC2-Instance
Indem Sie eine RDS for MariaDB-DB-Instance in derselben Weise AWS-Region wie Ihre Amazon EC2-Instance erstellen, können Sie die Datenbank-Backup-Datei schneller als über das Internet aus Amazon EC2 importieren.
Das folgende Diagramm veranschaulicht den Importvorgang der Backup-Datei von einer Amazon EC2-Instance in eine MariaDB-Datenbank.
![\[Workflow, der den Importvorgang der Backup-Datei von der EC2-Instance in die MariaDB-Datenbank darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_4.png)
### Erstellen einer MariaDB-Datenbank und Importieren der 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 Quell-MariaDB-Datenbank einschätzen. Weitere Informationen finden Sie unter [](Concepts.DBInstanceClass.md).
1. Erstellen Sie eine DB-Instance in der AWS-Region , die Ihre Amazon EC2 EC2-Instance enthält. Folgen Sie den 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:
```
MariaDB [(none)]> 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.
```
MariaDB [(none)]> create database database_name;
MariaDB [(none)]> use database_name;
```
Erstellen Sie anschließend die Tabellen.
```
MariaDB [(none)]> source table1.sql
MariaDB [(none)]> source table2.sql
etc...
```
Importieren Sie dann die Daten.
```
MariaDB [(none)]> LOAD DATA LOCAL INFILE 'table1.txt' INTO TABLE table1 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
MariaDB [(none)]> 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` oder `mariadb-dump` 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 MariaDB-Datenbank kopiert und übertragen wurden, wahrscheinlich aktualisiert. Sie können die Replikation verwenden, um die kopierte Datenbank up-to-date mit der Quelldatenbank zu verbinden.
![\[Workflow, der die Replikation von Daten aus der externen MariaDB-Datenbank in die Datenbank in Amazon RDS darstellt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_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:
+ [mysql.rds\$1set\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_set_external_master)
+ [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](#mariadb-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. Wenn Sie das SQL-Format zum Erstellen der Backup-Datei verwendet haben und auf der externen Instance nicht MariaDB 10.0.24 oder höher ausgeführt wird, schauen Sie sich den Inhalt dieser Datei an, indem Sie den folgenden Befehl ausführen:
```
cat backup.sql
```
Die Datei beinhaltet einen `CHANGE MASTER TO`-Kommentar, der den Namen und die Position der Hauptprotokolldatei beinhaltet. Dieser Kommentar ist in der Sicherungsdatei enthalten, wenn Sie die Option `--master-data` mit `mysqldump` verwenden. Beachten Sie die Werte für `MASTER_LOG_FILE` und `MASTER_LOG_POS`.
```
--
-- Position to start replication or point-in-time recovery from
--
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin-changelog.000031', MASTER_LOG_POS=107;
```
Wenn Sie ein separiertes Textformat zum Erstellen der Backup-Datei verwendet haben und auf der externen Instance nicht MariaDB 10.0.24 oder höher ausgeführt wird, sollten Sie bereits über Binärprotokollkoordinaten aus Schritt 1 in Aufgabe 1 verfügen, [in dem Sie eine Backup-Kopie Ihrer vorhandenen Datenbank erstellt haben](#mariadb-importing-data-reduced-downtime-create-backup).
Wenn auf der externen Instance MariaDB 10.0.24 oder höher ausgeführt wird, sollten Sie bereits über die GTID verfügen, von der aus Sie die Replikation in Schritt 2 in Aufgabe 1 begonnen haben, [in dem Sie eine Backup-Kopie Ihrer vorhandenen Datenbank erstellt haben](#mariadb-importing-data-reduced-downtime-create-backup).
1. Konfigurieren Sie die Amazon-RDS-Datenbank als Replikat. Wenn auf der externen Instance nicht MariaDB 10.0.24 oder höher ausgeführt wird, stellen Sie als Masterbenutzer eine Verbindung mit der Amazon-RDS-Datenbank her und identifizieren Sie die Quelldatenbank mithilfe der gespeicherten Prozedur [mysql.rds\$1set\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) als Quellreplikations-Instance.
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. Der folgende Befehl ist ein Beispiel:
```
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.
Wenn auf der externen Instance MariaDB 10.0.24 oder höher ausgeführt wird, stellen Sie eine Verbindung mit der Amazon-RDS-Datenbank als Masterbenutzer her und identifizieren Sie die Quelldatenbank mithilfe der gespeicherten Prozedur [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) als Quellreplikations-Instance. Verwenden Sie die GTID, die Sie in Schritt 2 in Aufgabe 1 ermittelt haben, [in dem Sie eine Backup-Kopie Ihrer vorhandenen Datenbank erstellt haben](#mariadb-importing-data-reduced-downtime-create-backup). Der folgende Befehl ist ein Beispiel:
```
CALL mysql.rds_set_external_master_gtid ('source_server_ip_address', 3306, 'ReplicationUser', 'password', 'GTID', 1);
```
Die `source_server_ip_address` ist die IP-Adresse der Quellreplikationsinstance. Eine private DNS-Adresse für EC2 wird derzeit nicht unterstützt.
**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. Um in der Amazon RDS-Datenbank zu ermitteln, wann sich das Replikat up-to-date bei der Quellreplikationsinstanz befindet, führen Sie den Befehl [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) aus. Zu den Ergebnissen des `SHOW REPLICA STATUS`-Befehls gehört das Feld `Seconds_Behind_Master`. Wenn das `Seconds_Behind_Master` Feld 0 zurückgibt, befindet sich das Replikat up-to-date bei der Quellreplikationsinstanz.
Bei einer DB-Instance von MariaDB 10.5, 10.6, 10.11, 11.4 oder 11.8 verwenden Sie die gespeicherte Prozedur [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md), anstatt den MySQL-Befehl auszuführen.
1. Nachdem die Amazon RDS-Datenbank eingerichtet wurde up-to-date, aktivieren Sie automatische 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
Nachdem die MariaDB-Datenbank up-to-date mit der Quellreplikationsinstanz verbunden ist, können Sie jetzt Ihre Live-Anwendung aktualisieren, um die Amazon RDS-Instance zu verwenden.
![\[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/MigrateMariaDBToRDS_6.png)
### So leiten Sie die Live-Anwendung an die MariaDB-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. Stellen Sie sicher, dass das `Seconds_Behind_Master` Feld in den Ergebnissen des Befehls [SHOW REPLICA STATUS den](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) Wert 0 hat, was bedeutet, dass sich das Replikat up-to-date bei der Quellreplikationsinstanz befindet.
```
SHOW REPLICA STATUS;
```
Bei einer DB-Instance von MariaDB 10.5, 10.6, 10.11, 11.4 oder 11.8 verwenden Sie die Prozedur [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md), anstatt den MySQL-Befehl auszuführen.
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.
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 den folgenden Befehl ausführen, der die gespeicherte Prozedur [mysql.rds\$1reset\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master) in der Amazon-RDS-Datenbank verwendet:
```
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).