Migrieren von Amazon RDS für MySQL zu Azure Database for MySQL unter Verwendung von Datenreplikation

Artikel
08/15/2024

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

Wichtig

Azure Database for MySQL Single Server wird eingestellt. Es wird dringend empfohlen, ein Upgrade auf Azure Database for MySQL Flexible Server auszufü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 die Sicherung und Wiederherstellung mit MySQL, MySQL Workbench-Export und -lmport oder Azure Database Migration Service verwenden, um Ihre MySQL-Datenbanken zum flexiblen Azure Database for MySQL-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 Tutorial erfahren Sie, wie Sie die Datenreplikation zwischen einem Quellserver mit Amazon Relational Database Service (RDS) für MySQL und einem Zielserver mit Azure Database for MySQL – Flexibler Server einrichten.

Ü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:

Bei Instanzen von flexiblen Azure Database for MySQL-Servern sollte sich der Clientcomputer im gleichen virtuellen Netzwerk und in der gleichen 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 mysqlclient auf Ihrem Clientcomputer, um eine Sicherungskopie zu erstellen und einen Wiederherstellungsvorgang auf Ihrer Zielinstanz des flexiblen Azure Database for MySQL-Servers durchzuführen.
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 des flexiblen Azure Database for MySQL-Servers mit der Version 5.7 oder 8.0.
Wichtig

Wenn Ihr Ziel ein flexibler Azure Database for MySQL-Server mit zonenredundanter Hochverfügbarkeit ist, beachten Sie, dass die Datenreplikation 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. Der flexible Azure Database for MySQL-Server unterstützt nur die InnoDB-Speicher-Engine.
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:

Überprüfen Sie, ob die Zielinstanz des flexiblen Azure Database for MySQL-Servers über Port 3306 mit dem Quellserver für Amazon RDS für MySQL verbunden werden 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 so, dass die IP-Adresse des flexiblen Azure Database for MySQL-Zielservers zulässig ist.

Wichtig

Wenn für die Quellinstanz von Amazon RDS für MySQL der GTID-Modus (GTID_mode) auf EIN festgelegt ist, muss auch für die Zielinstanz des flexiblen Azure Database for MySQL-Servers der GTID-Modus auf EIN festgelegt sein.

Konfigurieren Sie die Zielinstanz von Azure Database for MySQL

Zum Konfigurieren der Zielinstanz des flexiblen Azure Database for MySQL-Servers (das Ziel für die Datenreplikation) gehen Sie folgendermaßen vor:

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 Zielinstanz des flexiblen Azure Database for MySQL-Servers auf das Maximum von 64 virtuellen Kernen hoch. 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- und Speicheroptionen 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 so lange beibehalten werden, bis die Änderungen auf die Zielinstanz des flexiblen Azure Database for MySQL-Servers angewendet werden.

Bei der Datenreplikation verwaltet der flexible Azure Database for MySQL-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 von Ihrer Instanz des flexiblen Azure Database for MySQL-Servers 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 von Ihrer Instanz des flexiblen Azure Database for MySQL-Servers 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 – Flexibler 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, finden Sie Informationen dazu unter Migrieren großer Datenbanken zu „Azure Database for MySQL – Flexibler 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 Quellserver für Amazon RDS für MySQL und den flexiblen Azure Database for MySQL-Zielserver zu verknüpfen, melden Sie sich bei der Zielinstanz des flexiblen Azure Database for MySQL-Servers 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>');
```
Um die Replikation zwischen dem Quellserver für Amazon RDS für MySQL und der Zielinstanz des flexiblen Azure Database for MySQL-Servers zu starten, führen Sie den folgenden Befehl aus:
```
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 Anmeldungen und Berechtigungen auf Datenbankebene für die Zielinstanz des flexiblen Azure Database for MySQL-Servers.
Halten Sie die Schreibvorgänge auf dem Amazon RDS for MySQL-Quellserver an.
Stellen Sie sicher, dass die Zielinstanz des flexiblen Azure Database for MySQL-Servers mit dem Quellserver gleichgezogen hat und dass der Wert Seconds_Behind_Master von show slave status gleich 0 ist.
Rufen Sie die gespeicherte Prozedur mysql.az_replication_stop auf, um die Replikation zu beenden, da alle Änderungen in der Zielinstanz des flexiblen Azure Database for MySQL-Servers repliziert wurden.
Rufen Sie mysql.az_replication_remove_master auf, um die Konfiguration der Datenreplikation zu entfernen.
Leiten Sie Clients und Clientanwendungen an die Zielinstanz des flexiblen Azure Database for MySQL-Servers um.

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

Nächste Schritte

Weitere Informationen zum Migrieren von Datenbanken flexibler Azure Database for MySQL-Server finden Sie im Leitfaden zur Datenbankmigration.
Sehen Sie sich das Video zum Einfachen Migrieren von MySQL/PostgreSQL-Apps zum verwalteten Azure-Dienst an. In diesem Video wird Ihnen anhand einer Demo gezeigt, wie MySQL-Apps zu einem flexiblen Azure Database for MySQL-Server migriert werden.

Teilen über