Migrieren von Amazon RDS für MySQL zur Azure-Datenbank für MySQL mithilfe der Daten-In-Replikation

Artikel
12/19/2023

GILT FÜR: Azure Database for MySQL – Single Server Azure Database for MySQL – Flexible Server

Wichtig

Azure Database for MySQL single server is on the retirement path. Es wird dringend empfohlen, ein Upgrade auf azure Database for MySQL flexiblen Server durchzuführen. Weitere Informationen zum Migrieren zu Azure Database for MySQL flexible Server finden Sie unter Was geschieht mit Azure Database for MySQL Single Server?

Hinweis

Dieser Artikel enthält Verweise auf den Begriff Slave, einen Begriff, den Microsoft nicht mehr verwendet. Sobald der Begriff aus der Software entfernt wurde, wird er auch aus diesem Artikel entfernt.

Sie können Methoden wie MySQL Dump and Restore, MySQL Workbench Export and Import oder Azure Database Migration Service verwenden, um Ihre MySQL-Datenbanken zu Azure Database für MySQL flexiblen Server zu migrieren. Sie können Ihre Workloads mit minimaler Ausfallzeit migrieren, wenn Sie eine Kombination aus Open-Source-Tools wie mysqldump oder mydumper und myloader mit Datenreplikation verwenden.

Die Datenreplikation ist ein Verfahren, bei dem basierend auf der position-Methode für binäre Protokolldateien Datenänderungen vom Quellserver auf den Zielserver repliziert werden. In diesem Szenario schreibt die MySQL-Instanz, die als Quelle fungiert (und von der die Datenbankänderungen stammen), Aktualisierungen und Änderungen als Ereignisse in das binäre Protokoll. Die Informationen im binären Protokoll werden je nach aufgezeichneten Datenbankänderungen in unterschiedlichen Protokollierungsformaten gespeichert. Replikate sind so konfiguriert, dass sie das binäre Protokoll aus der Quelle lesen und die Ereignisse im binären Protokoll in der lokalen Datenbank des Replikats ausführen.

Richten Sie Datenreplikation ein, um Daten von einem MySQL-Quellserver mit einem MySQL-Zielserver zu synchronisieren. Sie können einen selektiven Cutover Ihrer Anwendungen vom primären Server (oder aus der Quelldatenbank) auf den Replikatserver (oder in die Zieldatenbank) durchführen.

In diesem Lernprogramm erfahren Sie, wie Sie die Data-In-Replikation zwischen einem Quellserver einrichten, auf dem Amazon Relational Database Service (RDS) für MySQL ausgeführt wird, und einem Zielserver, auf dem Azure Database für MySQL flexible Server ausgeführt wird.

Überlegungen zur Leistung

Bevor Sie mit diesem Tutorial beginnen, sollten Sie die Auswirkungen des Standorts und der Kapazität des Clientcomputers, den Sie für die Durchführung des Vorgangs verwenden, auf die Leistung berücksichtigen.

Clientstandort

Führen Sie Sicherungs- oder Wiederherstellungsvorgänge von einem Clientcomputer aus, der am selben Standort wie der Datenbankserver eingesetzt wird:

Für azure Database for MySQL flexible Serverinstanzen sollte sich der Clientcomputer in derselben virtuellen Netzwerk- und Verfügbarkeitszone wie der Zieldatenbankserver befinden.
Bei Amazon RDS-Quelldatenbankinstanzen sollte sich die Clientinstanz in derselben Amazon Virtual Private Cloud und Verfügbarkeitszone wie der Quelldatenbankserver befinden. Im zuvor genannten Fall können Sie Sicherungsdateien zwischen Clientcomputern mithilfe von Dateiübertragungsprotokollen wie FTP oder SFTP verschieben oder sie in Azure Blob Storage hochladen. Zur Reduzierung der Gesamtmigrationszeit komprimieren Sie Dateien vor der Übertragung.

Clientkapazität

Ganz gleich, wo sich der Clientcomputer befindet, ist eine ausreichende Computing-, E/A- und Netzwerkkapazität erforderlich, um die angeforderten Vorgänge ausführen zu können. Die allgemeinen Empfehlungen lauten wie folgt:

Wenn die Sicherung oder Wiederherstellung eine Echtzeitverarbeitung von Daten beinhaltet, z. B. Komprimierung oder Dekomprimierung, wählen Sie eine Instanzklasse mit mindestens einem CPU-Kern pro Sicherungs- oder Wiederherstellungsthread aus.
Stellen Sie sicher, dass der Clientinstanz eine ausreichende Netzwerkbandbreite zur Verfügung steht. Verwenden Sie Instanztypen, die das Feature für beschleunigten Netzwerkbetrieb unterstützen. Weitere Informationen finden Sie im Abschnitt „Beschleunigter Netzwerkbetrieb“ im Leitfaden für den Azure-VM-Netzwerkbetrieb.
Stellen Sie sicher, dass die Speicherebene des Clientcomputers die erwartete Lese-/Schreibkapazität bietet. Es wird empfohlen, einen virtuellen Azure-Computer mit SSD Premium-Speicher zu verwenden.

Voraussetzungen

Für dieses Tutorial benötigen Sie Folgendes:

Installieren Sie den Mysqlclient auf Ihrem Clientcomputer, um ein Dump zu erstellen, und führen Sie einen Wiederherstellungsvorgang in Ihrer Azure-Zieldatenbank für die flexible Serverinstanz von MySQL aus.
Bei größeren Datenbanken installieren Sie mydumper und myloader zum parallelen Sichern und Wiederherstellen von Datenbanken.

Hinweis

Mydumper kann nur auf Linux-Distributionen ausgeführt werden. Weitere Informationen finden Sie unter Installieren von mydumper.
Erstellen Sie eine Instanz von Azure Database für mySQL flexiblen Server, auf dem Version 5.7 oder 8.0 ausgeführt wird.
Wichtig

Wenn Ihr Ziel azure Database for MySQL flexible Server mit zonenredundanter Hochverfügbarkeit (HA) ist, beachten Sie, dass die Data-In-Replikation für diese Konfiguration nicht unterstützt wird. Als Problemumgehung können Sie bei der Servererstellung zonenredundante Hochverfügbarkeit auf folgende Weise einrichten:
1. Erstellen Sie den Server mit aktivierter zonenredundanter Hochverfügbarkeit.
2. Deaktivieren Sie die Hochverfügbarkeit.
3. Befolgen Sie die Anweisungen im Artikel zum Einrichten der Datenreplikation.
4. Entfernen Sie die Konfiguration der Datenreplikation nach der Übernahme.
5. Aktivieren Sie die Hochverfügbarkeit.

Vergewissern Sie sich, dass verschiedene Parameter und Features wie nachfolgend beschrieben konfiguriert und eingerichtet sind:

Aus Kompatibilitätsgründen sollten Quell- und Zieldatenbankserver dieselbe MySQL-Version verwenden.
Haben Sie in jeder Tabelle einen Primärschlüssel. Ein Fehlen von Primärschlüsseln in Tabellen kann den Replikationsprozess verlangsamen.
Stellen Sie sicher, dass der Zeichensatz der Quell- und der Zieldatenbank identisch ist.
Legen Sie den Parameter wait_timeout auf eine angemessene Zeit fest. Die Zeit hängt von der Datenmenge oder Workload ab, die Sie importieren oder migrieren möchten.
Vergewissern Sie sich, dass alle Ihre Tabellen InnoDB verwenden. Azure Database for MySQL flexible Server unterstützt nur das InnoDB-Speichermodul.
Bei Tabellen mit vielen sekundären Indizes oder bei großen Tabellen sind die Auswirkungen des Leistungsaufwands während der Wiederherstellung besonders sichtbar. Ändern Sie die Sicherungsdateien so, dass CREATE TABLE-Anweisungen keine Sekundärschlüsseldefinitionen enthalten. Erstellen Sie nach dem Importieren der Daten sekundäre Indizes neu, um Leistungseinbußen während des Wiederherstellungsprozesses zu vermeiden.

Zum Vorbereiten der Datenreplikation gehen Sie folgendermaßen vor:

Stellen Sie sicher, dass die Azure-Zieldatenbank für mySQL flexible Serverinstanz über Port 3306 eine Verbindung mit dem Quell-Amazon RDS für MySQL-Server herstellen kann.
Stellen Sie sicher, dass der Amazon RDS for MySQL-Quellserver sowohl eingehenden als auch ausgehenden Datenverkehr auf Port 3306 zulässt.
Stellen Sie sicher, dass Sie Site-to-Site Konnektivität zu Ihrem Quellserver bereitstellen, indem Sie entweder Azure ExpressRoute oder Azure VPN Gateway verwenden. Weitere Informationen zum Erstellen eines virtuellen Netzwerks finden Sie in der Dokumentation zu Azure Virtual Network. Sehen Sie sich auch die Schnellstartartikel mit Schritt-für-Schritt-Anleitungen an.
Konfigurieren Sie die Netzwerksicherheitsgruppen Ihres Quelldatenbankservers, um die Ziel-Azure-Datenbank für die flexible Server-IP-Adresse von MySQL zuzulassen.

Wichtig

Wenn die Amazon RDS-Quelle für MySQL-Instanz GTID_mode auf ON festgelegt hat, muss die Zielinstanz von Azure Database for MySQL flexible Server auch GTID_mode auf ON festgelegt haben.

Konfigurieren Sie die Zielinstanz von Azure Database for MySQL

So konfigurieren Sie die Zielinstanz von Azure Database für mySQL flexiblen Server, der das Ziel für die Data-In-Replikation ist:

Setzen Sie den Parameterwert für max_allowed_packet auf den Höchstwert von 1073741824, also 1 GB. Dieser Wert verhindert Überlaufprobleme im Zusammenhang mit langen Zeilen.
Setzen Sie die Parameter slow_query_log, general_log, audit_log_enabled und query_store_capture_mode während der Migration auf AUS, um jeglichen Overhead im Zusammenhang mit der Abfrageprotokollierung zu vermeiden.
Skalieren Sie die Computegröße der Azure-Zieldatenbank für die flexible Serverinstanz von MySQL auf maximal 64 vCores. Diese Größe bietet mehr Computeressourcen, wenn Sie die Datenbanksicherungskopie vom Quellserver wiederherstellen.

Sie können die Computegröße nach Abschluss der Migration jederzeit wieder an die Anforderungen Ihrer Anwendung anpassen.
Erhöhen Sie die Speichergröße, um mehr IOPS während der Migration zu erhalten, oder erhöhen Sie die maximalen IOPS für die Migration.

Hinweis

Die verfügbaren maximalen IOPS werden durch die Computegröße bestimmt. Weitere Informationen finden Sie im Abschnitt "IOPS" unter " Compute and storage options" in Azure Database for MySQL flexible Server.

Konfigurieren Sie den Amazon RDS for MySQL-Quellserver

Zum Vorbereiten und Konfigurieren des in Amazon RDS gehosteten MySQL-Servers (die Quelle für die Datenreplikation) gehen Sie folgendermaßen vor:

Vergewissern Sie sich, dass die binäre Protokollierung auf dem Amazon RDS for MySQL-Quellserver aktiviert ist. Überprüfen Sie, ob automatisierte Sicherungen aktiviert sind, oder stellen Sie sicher, dass ein Lesereplikat für den Amazon RDS for MySQL-Quellserver vorhanden ist.
Stellen Sie sicher, dass die binären Protokolldateien auf dem Quellserver aufbewahrt werden, bis die Änderungen auf die Zielinstanz von Azure Database für MySQL flexible Server angewendet wurden.

Bei der Datenreplikation verwaltet azure Database for MySQL flexible Server den Replikationsprozess nicht.

Wenn Sie die Aufbewahrung binärer Protokolle auf dem Amazon RDS-Quellserver überprüfen möchten, um die Anzahl der Stunden zu ermitteln, über die binäre Protokolle aufbewahrt werden, rufen Sie die gespeicherte Prozedur mysql.rds_show_configuration auf:

mysql> call mysql.rds_show_configuration;
+------------------------+-------+-----------------------------------------------------------------------------------------------------------+
| name | value | description |
+------------------------+-------+-----------------------------------------------------------------------------------------------------------+
| binlog retention hours | 24 | binlog retention hours specifies the duration in hours before binary logs are automatically deleted. |
| source delay | 0 | source delay specifies replication delay in seconds between current instance and its master. |
| target delay | 0 | target delay specifies replication delay in seconds between current instance and its future read-replica. |
+------------------------+-------            +-----------------------------------------------------------------------------------------------------------+
3 rows in set (0.00 sec)

Zum Konfigurieren der Aufbewahrungsdauer für binäre Protokolle führen Sie die gespeicherte Prozedur rds_set_configuration aus, um sicherzustellen, dass die binären Protokolle auf dem Quellserver für den gewünschten Zeitraum aufbewahrt werden. Zum Beispiel:
```
Mysql> Call mysql.rds_set_configuration(‘binlog retention hours', 96);
```
Wenn Sie eine Sicherungskopie erstellen und dann wiederherstellen, können Sie mithilfe des oben genannten Befehls die Deltaänderungen schnell nachholen.

Hinweis

Vergewissern Sie sich, dass auf dem Quellserver basierend auf der festgelegten Aufbewahrungsdauer ausreichend Speicherplatz für die Speicherung der binären Protokolle vorhanden ist.

Es gibt zwei Möglichkeiten, eine Sicherungskopie der Daten vom Amazon RDS for MySQL-Quellserver zu erfassen. Ein Ansatz besteht darin, eine Sicherungskopie der Daten direkt vom Quellserver zu erfassen. Beim anderen Ansatz wird eine Sicherungskopie von einem Amazon RDS for MySQL-Lesereplikat erfasst.

Wenn Sie eine Sicherungskopie der Daten direkt vom Quellserver erfassen möchten, gehen Sie folgendermaßen vor:
1. Stellen Sie sicher, dass Sie die Schreibvorgänge der Anwendung für einige Minuten anhalten, um eine im Hinblick auf Transaktionen konsistente Sicherungskopie der Daten zu erhalten.
  
  Sie können auch den Parameter read_only vorübergehend auf den Wert 1 setzen, damit bei der Erfassung einer Sicherungskopie der Daten keine Schreibvorgänge verarbeitet werden.
2. Nachdem Sie die Schreibvorgänge auf dem Quellserver angehalten haben, erfassen Sie den Namen und Offset der binären Protokolldatei, indem Sie den Befehl Mysql> Show master status; ausführen.
3. Speichern Sie diese Werte, um die Replikation aus Ihrer Azure-Datenbank für flexible Serverinstanz von MySQL zu starten.
4. Führen Sie zum Erstellen einer Sicherungskopie der Daten mysqldump mit dem folgenden Befehl aus:
```
$ mysqldump -h hostname -u username -p –single-transaction –databases dbnames –order-by-primary> dumpname.sql
```
Wenn das Anhalten von Schreibvorgängen auf dem Quellserver keine Option ist oder die Leistung der Datensicherung auf dem Quellserver nicht akzeptabel ist, erfassen Sie wie folgt eine Sicherungskopie auf einem Replikatserver:
1. Erstellen Sie ein Amazon MySQL-Lesereplikat mit der gleichen Konfiguration wie der Quellserver. Erstellen Sie dann dort die Sicherungskopie.
2. Lassen Sie das Amazon RDS for MySQL-Lesereplikat mit dem Amazon RDS for MySQL-Quellserver gleichziehen.
3. Wenn die Replikationsverzögerung auf dem Lesereplikat 0 erreicht, halten Sie die Replikation durch Aufruf der gespeicherten Prozedur mysql.rds_stop_replication an.
```
Mysql> call mysql.rds_stop_replication;
```
4. Stellen Sie bei angehaltener Replikation eine Verbindung mit dem Replikat her. Führen Sie dann den Befehl SHOW SLAVE STATUS aus, um den aktuellen binären Protokolldateinamen aus dem Feld Relay_Master_Log_File und die Position der Protokolldatei aus dem Feld Exec_Master_Log_Pos abzurufen.
5. Speichern Sie diese Werte, um die Replikation aus Ihrer Azure-Datenbank für flexible Serverinstanz von MySQL zu starten.
6. Zum Erstellen einer Sicherungskopie der Daten aus dem Amazon RDS for MySQL-Lesereplikat führen Sie mysqldump mit dem folgenden Befehl aus:
```
$ mysqldump -h hostname -u username -p –single-transaction –databases dbnames –order-by-primary> dumpname.sql
```
Hinweis

Sie können auch mydumper verwenden, um eine parallelisierte Sicherungskopie Ihrer Daten aus Ihrer Amazon RDS for MySQL-Quelldatenbank zu erfassen. Weitere Informationen finden Sie unter Migrieren großer Datenbanken zu Azure Database for MySQL flexible Server mit mydumper/myloader.

Verknüpfen des Quell- und Replikatservers zum Starten der Datenreplikation

Zum Wiederherstellen der Datenbank mithilfe der nativen Wiederherstellung von mysql führen Sie den folgenden Befehl aus:
```
$ mysql -h <target_server> -u <targetuser> -p < dumpname.sql
```
Hinweis

Wenn Sie stattdessen myloader verwenden, lesen Sie "Migrieren großer Datenbanken zu Azure Database for MySQL flexiblen Server mit mydumper/myloader".
Melden Sie sich beim Amazon RDS for MySQL-Quellserver an, und richten Sie einen Replikationsbenutzer ein. Ersteilen Sie diesem Benutzer dann die erforderlichen Berechtigungen.
- Wenn Sie SSL verwenden, führen Sie die folgenden Befehle aus:
```
Mysql> CREATE USER 'syncuser'@'%' IDENTIFIED BY 'userpassword';
Mysql> GRANT REPLICATION SLAVE, REPLICATION CLIENT on *.* to 'syncuser'@'%' REQUIRE SSL;
Mysql> SHOW GRANTS FOR syncuser@'%';
```
- Wenn Sie SSL nicht verwenden, führen Sie die folgenden Befehle aus:
```
Mysql> CREATE USER 'syncuser'@'%' IDENTIFIED BY 'userpassword';
Mysql> GRANT REPLICATION SLAVE, REPLICATION CLIENT on *.* to 'syncuser'@'%';
Mysql> SHOW GRANTS FOR syncuser@'%';
```
Gespeicherte Prozeduren führen alle Datenreplikationsfunktionen aus. Informationen zu allen Prozeduren finden Sie unter Gespeicherte Prozeduren für die Datenreplikation. Sie können diese gespeicherten Prozeduren in der MySQL-Shell oder der MySQL Workbench ausführen.
Um den Amazon RDS für MySQL-Quellserver und den Azure-Datenbank für MySQL flexiblen Serverzielserver zu verknüpfen, melden Sie sich bei der Azure-Zieldatenbank für mySQL flexible Serverinstanz an. Legen Sie den Amazon RDS for MySQL-Server als Quellserver fest, indem Sie den folgenden Befehl ausführen:
```
CALL mysql.az_replication_change_master('source_server','replication_user_name','replication_user_password',3306,'<master_bin_log_file>',master_bin_log_position,'<master_ssl_ca>');
```
Führen Sie den folgenden Befehl aus, um die Replikation zwischen dem Quell-Amazon RDS für MySQL-Server und der Azure-Zieldatenbank für mySQL flexible Serverinstanz zu starten:
```
Mysql> CALL mysql.az_replication_start;
```
Um den Status der Replikation auf dem Replikatserver zu überprüfen, führen Sie den folgenden Befehl aus:
```
Mysql> show slave status\G
```
Wenn der Status der Parameter Slave_IO_Running und Slave_SQL_RunningYes ist, wurde die Replikation gestartet und befindet sich im Ausführungszustand.
Überprüfen Sie den Wert des Parameters Seconds_Behind_Master, um festzustellen, wie weit der Zielserver verzögert ist.

Ist der Wert 0, hat der Zielserver alle Aktualisierungen vom Quellserver verarbeitet. Beträgt der Wert etwas anderes als 0, verarbeitet der Zielserver noch Updates.

Sicherstellen einer erfolgreichen Übernahme

Zum Sicherstellen einer erfolgreichen Übernahme gehen Sie folgendermaßen vor:

Konfigurieren Sie die entsprechenden Anmelde- und Datenbankberechtigungen in der Azure-Zieldatenbank für die flexible Serverinstanz von MySQL.
Halten Sie die Schreibvorgänge auf dem Amazon RDS for MySQL-Quellserver an.
Stellen Sie sicher, dass die Azure-Zieldatenbank für die flexible Serverinstanz von MySQL mit dem Quellserver abgefangen wurde und dass der Seconds_Behind_Master Wert 0 istshow slave status.
Rufen Sie die gespeicherte Prozedur mysql.az_replication_stop auf, um die Replikation zu beenden, da alle Änderungen in der Azure-Zieldatenbank für die flexible Serverinstanz von MySQL repliziert wurden.
Rufen Sie mysql.az_replication_remove_master auf, um die Konfiguration der Datenreplikation zu entfernen.
Leiten Sie Clients und Clientanwendungen an die Azure-Zieldatenbank für die flexible Serverinstanz mySQL um.

An diesem Punkt ist die Migration abgeschlossen. Ihre Anwendungen sind mit dem Server verbunden, auf dem Azure Database für MySQL flexible Server ausgeführt wird.

Nächste Schritte

Weitere Informationen zum Migrieren von Datenbanken zu Azure Database for MySQL flexible Server finden Sie im Leitfaden zur Datenbankmigration.
Sehen Sie sich das Video zum Einfachen Migrieren von MySQL/PostgreSQL-Apps zum verwalteten Azure-Dienst an. Es enthält eine Demo, die zeigt, wie MySQL-Apps zu Azure Database für MySQL flexiblen Server migriert werden.