MySQL Replikationsgrundlagen

Einführung

In diesem Lab lernen Sie die Grundlagen der MySQL-Replikation. Replikation ist ein Prozess, der es Ihnen ermöglicht, Kopien einer MySQL-Datenbank auf mehreren Servern zu pflegen. Dies wird üblicherweise für Load Balancing, Datensicherung und Hochverfügbarkeit eingesetzt.

Sie werden Docker verwenden, um ein realistisches Master-Slave-Replikationssetup mit zwei separaten MySQL-Containern zu erstellen. Zuerst starten und verifizieren Sie einen Master-Container, der vorkonfiguriert ist und bei dem das Binärprotokoll (binary logging) aktiviert ist. Sie erstellen einen speziellen Replikationsbenutzer auf dem Master. Anschließend konfigurieren Sie den zweiten Container als Slave, verbinden ihn mit dem Master und verifizieren, dass die Daten korrekt synchronisiert werden. Dieser praktische Ansatz hilft Ihnen, die wichtigsten Schritte im Management einer realen MySQL-Replikationsumgebung zu verstehen.

Docker-Umgebung einrichten

In diesem ersten Schritt richten Sie die notwendigen Docker-Container für die Master-Slave-Replikationsumgebung ein. Sie erstellen ein dediziertes Netzwerk und starten zwei MySQL-Container.

1. Docker-Netzwerk erstellen:

   Ein dediziertes Netzwerk ermöglicht es Containern, sich gegenseitig anhand ihres Namens zu kommunizieren. Erstellen Sie ein Netzwerk namens mysql-net.

   docker network create mysql-net
   

2. Master-MySQL-Container starten:

   Starten Sie als Nächstes den Master-Container. Dieser Befehl verwendet mysql:5.7 und konfiguriert ihn mit einer Server-ID von 1 und aktiviert das Binärprotokoll (binary logging) für die Datenbank replication_db.

   docker run -d \
     --name mysql-master \
     --network mysql-net \
     -e MYSQL_ROOT_PASSWORD=lab_password \
     -e MYSQL_DATABASE=replication_db \
     mysql:5.7 \
     mysqld --server-id=1 --log-bin=mysql-bin --binlog-do-db=replication_db
   

3. Slave-MySQL-Container starten:

   Starten Sie nun den Slave-Container. Dieser Container befindet sich ebenfalls im selben Netzwerk und ist mit der Server-ID 2 konfiguriert. Wir erstellen auch im Voraus die Datenbank replication_db, damit der Slave Änderungen vom Master korrekt anwenden kann.

   docker run -d \
     --name mysql-slave \
     --network mysql-net \
     -e MYSQL_ROOT_PASSWORD=lab_password \
     -e MYSQL_DATABASE=replication_db \
     mysql:5.7 \
     mysqld --server-id=2 --relay-log=mysql-relay-bin --log-slave-updates=1
   

4. Auf die Initialisierung der Container warten:

   Die MySQL-Container benötigen einige Zeit zur Initialisierung. Warten Sie etwa 15 Sekunden, um zu überprüfen, ob die Container laufen.

   docker ps
   

   CONTAINER ID   IMAGE       COMMAND                  CREATED         STATUS         PORTS                 NAMES
   
   cfe8c98d2ad0 mysql:5.7 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 3306/tcp, 33060/tcp mysql-slave
   fc125bf293ea mysql:5.7 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 3306/tcp, 33060/tcp mysql-master
   

Nachdem Ihre Umgebung eingerichtet ist, können Sie mit der Konfiguration des Master-Servers fortfahren.

Master-Server-Konfiguration überprüfen

Nachdem die Container laufen, besteht der nächste Schritt darin, sicherzustellen, dass der Master-Server korrekt für die Replikation konfiguriert ist. Die Hauptaufgabe des Masters besteht darin, alle Datenbankänderungen in sein Binärprotokoll (binary log) zu schreiben, das der Slave später lesen wird.

Öffnen Sie zunächst ein Terminal auf Ihrem Desktop.

Wir werden uns nun mit dem Master-Container verbinden und seine Konfiguration überprüfen.

1. Verbindung zum Master-Container herstellen:

   Verwenden Sie docker exec, um eine MySQL-Shell innerhalb des mysql-master-Containers zu öffnen. Sie werden aufgefordert, das Passwort einzugeben, das lab_password lautet.

   docker exec -it mysql-master mysql -uroot -plab_password
   

2. Binärprotokollierung und Server-ID überprüfen:

   Sobald Sie die Eingabeaufforderung mysql> sehen, führen Sie die folgenden Befehle aus, um zu überprüfen, ob die Binärprotokollierung aktiviert ist und die Server-ID korrekt gesetzt ist.

   SHOW VARIABLES LIKE 'log_bin';
   

   Die Ausgabe sollte zeigen, dass log_bin auf ON steht.

   +---------------+----+
   | Variable_name | Value |
   +---------------+----+
   | log_bin       | ON |
   +---------------+----+
   1 row in set (0.01 sec)
   

   Überprüfen Sie als Nächstes die Server-ID.

   SHOW VARIABLES LIKE 'server_id';
   

   Die Ausgabe sollte zeigen, dass die server_id 1 ist.

   +---------------+-------+
   | Variable_name | Value |
   +---------------+-------+
   | server_id     | 1     |
   +---------------+-------+
   1 row in set (0.00 sec)
   

Nachdem Sie die Konfiguration überprüft haben, können Sie die MySQL-Shell verlassen.

```sql
exit;
```

Sie haben erfolgreich bestätigt, dass der Master-Server für die Replikation bereit ist.

Replikationsbenutzer und Testdatenbank erstellen

Der Slave-Server muss sich mit dem Master verbinden, um das Binärprotokoll zu lesen. Aus Sicherheitsgründen ist es bewährte Praxis, für diesen Zweck ein dediziertes Benutzerkonto mit eingeschränkten Berechtigungen zu erstellen. In diesem Schritt erstellen Sie einen Replikationsbenutzer und füllen die Testdatenbank, um die Replikation in Aktion zu beobachten.

1. Verbindung zum Master-Server herstellen:

   Öffnen Sie eine MySQL-Shell innerhalb des mysql-master-Containers.

   docker exec -it mysql-master mysql -uroot -plab_password
   

2. Replikationsbenutzer erstellen:

   Geben Sie an der Eingabeaufforderung mysql> den folgenden Befehl aus, um einen Benutzer namens repl_user mit dem Passwort repl_password zu erstellen. Dieser Benutzer wird vom Slave für die Verbindung verwendet. Wir verwenden '@'%', um dem Benutzer die Verbindung von jedem Host zu erlauben, einschließlich unseres Slave-Containers im Docker-Netzwerk.

   CREATE USER 'repl_user'@'%' IDENTIFIED BY 'repl_password';
   

3. Replikationsberechtigungen erteilen:

   Der neue Benutzer benötigt die Berechtigung REPLICATION SLAVE, die es ihm erlaubt, die Binärprotokolle vom Master zu lesen.

   GRANT REPLICATION SLAVE ON *.* TO 'repl_user'@'%';
   

   Nachdem Sie die Berechtigungen erteilt haben, laden Sie die Grant-Tabellen neu, um die Änderungen sofort anzuwenden.

   FLUSH PRIVILEGES;
   

4. Status des Master-Binärprotokolls überprüfen:

   Bevor Sie den Slave konfigurieren, müssen Sie die genauen Koordinaten im Binärprotokoll des Masters kennen, an denen der Slave mit der Replikation beginnen soll. Der Befehl SHOW MASTER STATUS liefert diese Informationen.

   SHOW MASTER STATUS;
   

   Die Ausgabe wird ähnlich wie diese aussehen. Notieren Sie sich die Werte für File und Position, da Sie diese im nächsten Schritt benötigen werden.

   +------------------+----------+------------------+--------------------+-------------------+
   | File             | Position | Binlog_Do_DB     | Binlog_Ignore_DB   | Executed_Gtid_Set |
   +------------------+----------+------------------+--------------------+-------------------+
   | mysql-bin.000001 |      337 | replication_db   |                    |                   |
   +------------------+----------+------------------+--------------------+-------------------+
   1 row in set (0.00 sec)
   

5. Testtabelle und Daten erstellen:

   Die Datenbank replication_db wurde beim Start des Containers erstellt. Erstellen wir eine Tabelle und fügen einige Daten ein, um die Replikation zu testen.

   USE replication_db;
   CREATE TABLE messages (
       id INT PRIMARY KEY AUTO_INCREMENT,
       content VARCHAR(255)
   );
   INSERT INTO messages (content) VALUES ('Hello from the master!');
   

   Sie können überprüfen, ob die Daten korrekt eingefügt wurden.

   SELECT * FROM messages;
   

   Sie sollten die gerade eingefügte Zeile sehen.

   +----+------------------------+
   | id | content                |
   +----+------------------------+
   |  1 | Hello from the master! |
   +----+------------------------+
   1 row in set (0.00 sec)
   

   Beenden Sie nun die MySQL-Shell.

   exit;
   

Sie haben nun den Master-Server vorbereitet, indem Sie einen Replikationsbenutzer und einige Testdaten erstellt haben.

Slave-Server konfigurieren und starten

Nachdem der Master bereit ist, konfigurieren Sie den Slave-Container. In diesem Schritt verwenden Sie die Binärprotokollkoordinaten, die Sie in Schritt 3 vom Master aufgezeichnet haben, um dem Slave mitzuteilen, wo er mit der Replikation beginnen soll.

1. Verbindung zum Slave-Container herstellen:

   Öffnen Sie zunächst eine MySQL-Shell innerhalb des mysql-slave-Containers.

   docker exec -it mysql-slave mysql -uroot -plab_password
   

2. Slave für die Verbindung zum Master konfigurieren:

   Nun verwenden Sie den Befehl CHANGE MASTER TO, um die Replikationseinstellungen zu konfigurieren. Verwenden Sie die Werte für File und Position, die Sie in Schritt 3 aus SHOW MASTER STATUS notiert haben. Der MASTER_HOST ist 'mysql-master', was funktioniert, da beide Container sich im selben Docker-Netzwerk befinden.

   Hinweis: Ersetzen Sie mysql-bin.000001 und die Positionsnummer durch die tatsächlichen Werte, die Sie in Schritt 3 aufgezeichnet haben. Wenn Sie die Werte nicht haben, können Sie in einem neuen Terminal docker exec mysql-master mysql -uroot -plab_password -e "SHOW MASTER STATUS;" ausführen, um sie zu erhalten.

   CHANGE MASTER TO
       MASTER_HOST='mysql-master',
       MASTER_USER='repl_user',
       MASTER_PASSWORD='repl_password',
       MASTER_LOG_FILE='mysql-bin.000001',
       MASTER_LOG_POS=337;
   

   Dieser Befehl konfiguriert den Slave mit allen notwendigen Informationen, um sich mit dem Master zu verbinden.

3. Slave-Threads starten:

   Starten Sie schließlich den Replikationsprozess, indem Sie den Befehl START SLAVE ausführen. Dies startet zwei Threads: den I/O-Thread, der Binärprotokolle vom Master abruft, und den SQL-Thread, der die Ereignisse aus den Protokollen ausführt.

   START SLAVE;
   

   Sie können die MySQL-Shell nun verlassen.

   exit;
   

Der Slave ist nun konfiguriert und sollte versuchen, sich mit dem Master zu verbinden und Daten zu replizieren.

Replikation überprüfen

Nachdem der Slave gestartet wurde, ist der letzte Schritt die Überprüfung, ob die Replikation korrekt funktioniert. Sie überprüfen den Status des Slaves und stellen sicher, dass die Daten vom Master kopiert wurden.

1. Verbindung zum Slave-Server herstellen:

   Öffnen Sie eine MySQL-Shell auf dem mysql-slave-Container.

   docker exec -it mysql-slave mysql -uroot -plab_password
   

2. Slave-Status überprüfen:

   Der wichtigste Befehl zur Überwachung der Replikation ist SHOW SLAVE STATUS. Der Modifikator \G formatiert die Ausgabe vertikal, was die Lesbarkeit erheblich verbessert.

   SHOW SLAVE STATUS\G
   

   Suchen Sie in der Ausgabe nach den folgenden beiden Zeilen. Beide sollten den Wert Yes haben.

   • Slave_IO_Running: Yes: Dies bestätigt, dass der Slave erfolgreich mit dem Master verbunden ist und Binärprotokolldaten empfängt.
   • Slave_SQL_Running: Yes: Dies bestätigt, dass der Slave die Ereignisse aus dem Binärprotokoll erfolgreich ausführt.

   Ein weiteres wichtiges Feld ist Seconds_Behind_Master. Ein Wert von 0 zeigt an, dass der Slave vollständig mit dem Master synchronisiert ist.

   Ein gesunder Status sieht ähnlich wie folgt aus (einige Werte können abweichen):

   *************************** 1. row ***************************
                  Slave_IO_State: Waiting for master to send event
                     Master_Host: mysql-master
                     Master_User: repl_user
                     Master_Port: 3306
                   Connect_Retry: 60
                 Master_Log_File: mysql-bin.000001
             Read_Master_Log_Pos: 529
                  Relay_Log_File: mysql-relay-bin.000002
                   Relay_Log_Pos: 699
           Relay_Master_Log_File: mysql-bin.000001
                Slave_IO_Running: Yes
               Slave_SQL_Running: Yes
   ...
            Seconds_Behind_Master: 0
   ...
   

3. Replikationsdaten überprüfen:

   Überprüfen Sie nun, ob die Datenbank replication_db und ihre Daten vom Master kopiert wurden.

   SHOW DATABASES;
   

   Sie sollten replication_db in der Liste sehen.

   +--------------------+
   | Database           |
   +--------------------+
   | information_schema |
   | mysql              |
   | performance_schema |
   | replication_db     |
   | sys                |
   +--------------------+
   

   Wechseln Sie zur Datenbank und fragen Sie die Tabelle messages ab.

   USE replication_db;
   SELECT * FROM messages;
   

   Die Daten, die Sie auf dem Master eingefügt haben, sollten nun auf dem Slave vorhanden sein.

   +----+------------------------+
   | id | content                |
   +----+------------------------+
   |  1 | Hello from the master! |
   +----+------------------------+
   1 row in set (0.00 sec)
   

   Dies bestätigt, dass die Replikation korrekt funktioniert. Sie können die MySQL-Shell nun verlassen.

   exit;
   

Sie haben erfolgreich eine grundlegende MySQL Master-Slave-Replikationsumgebung mit Docker eingerichtet und überprüft.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Schritte zur Einrichtung der MySQL Master-Slave-Replikation mit Docker gelernt. Sie haben damit begonnen, zwei separate MySQL-Container zu erstellen, einen für den Master und einen für den Slave, die über ein Docker-Netzwerk verbunden sind. Sie haben die Konfiguration des Masters überprüft, die ein aktiviertes Binärprotokoll und eine eindeutige Server-ID beinhaltete. Anschließend haben Sie auf dem Master einen dedizierten Replikationsbenutzer für eine sichere Verbindung erstellt. Nach der Vorbereitung des Masters haben Sie den Slave-Container mit dem Befehl CHANGE MASTER TO konfiguriert, um die Verbindung mit den Binärprotokollkoordinaten des Masters herzustellen. Schließlich haben Sie den Erfolg der Replikation überprüft, indem Sie den Status des Slaves mit SHOW SLAVE STATUS kontrolliert und bestätigt haben, dass die Testdaten korrekt synchronisiert wurden. Dieses Lab hat Ihnen die wesentlichen Fähigkeiten vermittelt, um eine realistische MySQL-Replikation einzurichten, zu verwalten und zu überprüfen.