Grundlagen der MySQL-Replikation

MySQLMySQLBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden wir die Grundlagen der MySQL-Replikation untersuchen. Das Hauptziel besteht darin, eine einfache Master-Slave-Replikationsumgebung einzurichten, die die Datensynchronisierung zwischen zwei MySQL-Servern ermöglicht.

Das Lab beginnt mit der Konfiguration eines Master-Servers mit aktivierter binärer Protokollierung (binary logging), die für die Aufzeichnung aller Datenänderungen unerlässlich ist. Wir werden die MySQL-Konfigurationsdatei (/etc/mysql/mysql.conf.d/mysqld.cnf) bearbeiten, um log_bin = mysql-bin und server_id = 1 festzulegen. Anschließend werden wir einen Slave-Server einrichten, um Daten vom Master zu replizieren, den Replikationsstatus mit SHOW SLAVE STATUS überprüfen und schließlich einen Replikationsfehler simulieren und beheben, um Troubleshooting-Techniken zu verstehen.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL mysql(("MySQL")) -.-> mysql/BasicKeywordsandStatementsGroup(["Basic Keywords and Statements"]) mysql(("MySQL")) -.-> mysql/TransactionManagementandSecurityGroup(["Transaction Management and Security"]) mysql(("MySQL")) -.-> mysql/SystemManagementToolsGroup(["System Management Tools"]) mysql/BasicKeywordsandStatementsGroup -.-> mysql/create_database("Database Creation") mysql/BasicKeywordsandStatementsGroup -.-> mysql/create_table("Table Creation") mysql/BasicKeywordsandStatementsGroup -.-> mysql/select("Data Retrieval") mysql/BasicKeywordsandStatementsGroup -.-> mysql/insert("Data Insertion") mysql/TransactionManagementandSecurityGroup -.-> mysql/grant_permission("Permission Granting") mysql/SystemManagementToolsGroup -.-> mysql/show_status("Status Overview") mysql/SystemManagementToolsGroup -.-> mysql/show_variables("Configuration Overview") subgraph Lab Skills mysql/create_database -.-> lab-550913{{"Grundlagen der MySQL-Replikation"}} mysql/create_table -.-> lab-550913{{"Grundlagen der MySQL-Replikation"}} mysql/select -.-> lab-550913{{"Grundlagen der MySQL-Replikation"}} mysql/insert -.-> lab-550913{{"Grundlagen der MySQL-Replikation"}} mysql/grant_permission -.-> lab-550913{{"Grundlagen der MySQL-Replikation"}} mysql/show_status -.-> lab-550913{{"Grundlagen der MySQL-Replikation"}} mysql/show_variables -.-> lab-550913{{"Grundlagen der MySQL-Replikation"}} end

Konfiguration eines Master-Servers mit binärer Protokollierung

In diesem Schritt werden wir einen MySQL-Server so konfigurieren, dass er als Master in einer Replikationsumgebung fungiert. Ein entscheidender Teil dieser Konfiguration ist die Aktivierung der binären Protokollierung (binary logging). Binäre Protokolle (Binary logs) erfassen alle Datenänderungen, die an der Datenbank vorgenommen werden. Diese Protokolle werden dann vom Slave-Server verwendet, um die Änderungen zu replizieren.

Zunächst verstehen wir, warum die binäre Protokollierung wichtig ist. Ohne binäre Protokollierung hätte der Slave-Server keine Möglichkeit zu erfahren, welche Änderungen er vom Master replizieren soll. Binäre Protokolle fungieren als Transaktionsprotokolle und sorgen dafür, dass der Slave-Server mit dem Master synchron bleibt.

Jetzt konfigurieren wir den Master-Server.

  1. Bearbeiten der MySQL-Konfigurationsdatei:

    Die MySQL-Konfigurationsdatei befindet sich normalerweise unter /etc/mysql/mysql.conf.d/mysqld.cnf. Wir verwenden nano, um diese Datei zu bearbeiten.

    sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf
  2. Aktivieren der binären Protokollierung:

    Fügen Sie die folgenden Zeilen in den mysqld-Abschnitt der Konfigurationsdatei ein. Wenn der mysqld-Abschnitt nicht existiert, suchen Sie die Zeile [mysqld] und fügen Sie die folgenden Konfigurationen darunter ein.

    log_bin = mysql-bin
    server_id = 1
    • log_bin = mysql-bin: Dies aktiviert die binäre Protokollierung und legt den Basisnamen für die Protokolldateien auf mysql-bin fest. MySQL fügt automatisch eine Sequenznummer an diesen Basisnamen an (z. B. mysql-bin.000001, mysql-bin.000002 usw.).
    • server_id = 1: Dies legt eine eindeutige ID für den Master-Server fest. Jeder Server in einer Replikationsumgebung muss eine eindeutige server_id haben.

    Der mysqld-Abschnitt Ihrer Konfigurationsdatei sollte jetzt in etwa so aussehen:

    [mysqld]
    #
    ## * Grundeinstellungen
    #
    user            = mysql
    pid-file        = /var/run/mysqld/mysqld.pid
    socket          = /var/run/mysqld/mysqld.sock
    port            = 3306
    basedir         = /usr
    datadir         = /var/lib/mysql
    tmpdir          = /tmp
    lc-messages-dir = /usr/share/mysql
    log_bin = mysql-bin
    server_id = 1
    ## ... andere Konfigurationen ...

    Drücken Sie Ctrl+X, dann Y und anschließend Enter, um die Änderungen zu speichern und nano zu verlassen.

  3. Neustart des MySQL-Servers:

    Um die Änderungen anzuwenden, starten Sie den MySQL-Server neu. Da wir in einem Docker-Container sind, können wir systemctl nicht verwenden. Stattdessen verwenden wir das mysql.server-Skript.

    sudo /etc/init.d/mysql restart

    Sie sollten eine Ausgabe ähnlich der folgenden sehen:

    [ ok ] Restarting mysql (via systemctl): mysql.service.
  4. Überprüfen, ob die binäre Protokollierung aktiviert ist:

    Melden Sie sich als Root-Benutzer am MySQL-Server an. Möglicherweise müssen Sie sudo verwenden, um auf MySQL zuzugreifen, wenn Sie noch kein Passwort für den Root-Benutzer festgelegt haben.

    sudo mysql -u root

    Führen Sie die folgende SQL-Abfrage aus, um den Status der binären Protokollierung zu überprüfen:

    SHOW VARIABLES LIKE 'log_bin';

    Die Ausgabe sollte wie folgt aussehen:

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

    Dies bestätigt, dass die binäre Protokollierung aktiviert ist.

    Sie können auch die Server-ID überprüfen:

    SHOW VARIABLES LIKE 'server_id';

    Die Ausgabe sollte wie folgt aussehen:

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

    Verlassen Sie den MySQL-Monitor:

    exit

Sie haben den Master-Server jetzt erfolgreich mit binärer Protokollierung konfiguriert. Im nächsten Schritt werden wir den Slave-Server einrichten, um Daten von diesem Master zu replizieren.

Einrichten eines Slave-Servers zur Datenreplikation

In diesem Schritt werden wir einen MySQL-Server so konfigurieren, dass er als Slave fungiert und Daten vom im vorherigen Schritt konfigurierten Master-Server repliziert. Dies umfasst die Konfiguration der Einstellungen des Slave-Servers und die Herstellung einer Verbindung zum Master.

  1. Konfigurieren des Slave-Servers:

    Zunächst müssen wir den Slave-Server mit einer eindeutigen server_id konfigurieren und die Relay-Protokollierung (relay logging) aktivieren. Relay-Protokolle (Relay logs) werden vom Slave-Server verwendet, um die vom Master empfangenen binären Protokollereignisse zu speichern, bevor sie auf seine eigene Datenbank angewendet werden.

    Bearbeiten Sie die MySQL-Konfigurationsdatei auf dem Slave-Server (normalerweise unter /etc/mysql/mysql.conf.d/mysqld.cnf):

    sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

    Fügen Sie oder ändern Sie die folgenden Zeilen im [mysqld]-Abschnitt hinzu:

    server_id = 2
    relay_log = mysql-relay-bin
    • server_id = 2: Dies legt eine eindeutige ID für den Slave-Server fest. Sie muss sich von der server_id des Master-Servers unterscheiden.
    • relay_log = mysql-relay-bin: Dies aktiviert die Relay-Protokollierung und legt den Basisnamen für die Relay-Protokolldateien fest.

    Der mysqld-Abschnitt Ihrer Konfigurationsdatei sollte jetzt in etwa so aussehen:

    [mysqld]
    #
    ## * Grundeinstellungen
    #
    user            = mysql
    pid-file        = /var/run/mysqld/mysqld.pid
    socket          = /var/run/mysqld/mysqld.sock
    port            = 3306
    basedir         = /usr
    datadir         = /var/lib/mysql
    tmpdir          = /tmp
    lc-messages-dir = /usr/share/mysql
    server_id = 2
    relay_log = mysql-relay-bin
    ## ... andere Konfigurationen ...

    Drücken Sie Ctrl+X, dann Y und anschließend Enter, um die Änderungen zu speichern und nano zu verlassen.

  2. Neustart des MySQL-Servers auf dem Slave:

    Starten Sie den MySQL-Server neu, um die Änderungen anzuwenden:

    sudo /etc/init.d/mysql restart

    Sie sollten eine Ausgabe ähnlich der folgenden sehen:

    [ ok ] Restarting mysql (via systemctl): mysql.service.
  3. Erstellen eines Replikationsbenutzers auf dem Master-Server:

    Melden Sie sich auf dem Master-Server als Root-Benutzer am MySQL-Server an:

    sudo mysql -u root

    Erstellen Sie einen dedizierten Benutzer für die Replikation. Ersetzen Sie 'slave_user' durch den gewünschten Benutzernamen und 'password' durch ein starkes Passwort. Ersetzen Sie auch '%' durch die IP-Adresse Ihres Slave-Servers, um die Sicherheit zu erhöhen. Wenn Sie sich nicht sicher sind, welche IP-Adresse der Slave-Server hat, können Sie '%' verwenden, um Verbindungen von jedem Host zuzulassen (nicht empfohlen für Produktionsumgebungen).

    CREATE USER 'slave_user'@'%' IDENTIFIED BY 'password';
    GRANT REPLICATION SLAVE ON *.* TO 'slave_user'@'%';
    FLUSH PRIVILEGES;
    • CREATE USER 'slave_user'@'%' IDENTIFIED BY 'password': Erstellt einen neuen MySQL-Benutzer namens slave_user, der sich von jedem Host ('%') verbinden kann.
    • GRANT REPLICATION SLAVE ON *.* TO 'slave_user'@'%': Gewährt dem slave_user das REPLICATION SLAVE-Privileg für alle Datenbanken und Tabellen. Dieses Privileg ist erforderlich, damit der Slave-Server binäre Protokollaktualisierungen vom Master anfordern kann.
    • FLUSH PRIVILEGES: Lädt die Berechtigungstabellen neu, um die neuen Privilegien anzuwenden.

    Verlassen Sie den MySQL-Monitor auf dem Master-Server:

    exit
  4. Konfigurieren des Slaves zur Verbindung mit dem Master:

    Melden Sie sich auf dem Slave-Server als Root-Benutzer am MySQL-Server an:

    sudo mysql -u root

    Teilen Sie dem Slave-Server mit, wie er sich mit dem Master-Server verbinden soll. Ersetzen Sie 'master_host' durch die IP-Adresse oder den Hostnamen Ihres Master-Servers, 'slave_user' durch den von Ihnen erstellten Replikationsbenutzernamen und 'password' durch das Replikationspasswort.

    CHANGE MASTER TO
        MASTER_HOST='master_host',
        MASTER_USER='slave_user',
        MASTER_PASSWORD='password',
        MASTER_LOG_FILE='mysql-bin.000001',
        MASTER_LOG_POS=4;
    • MASTER_HOST: Der Hostname oder die IP-Adresse des Master-Servers.
    • MASTER_USER: Der Benutzername, den der Slave zum Verbinden mit dem Master verwenden wird.
    • MASTER_PASSWORD: Das Passwort für den Replikationsbenutzer.
    • MASTER_LOG_FILE: Der Name der binären Protokolldatei des Masters, von der die Replikation beginnen soll. Sie können dies herausfinden, indem Sie SHOW MASTER STATUS; auf dem Master-Server ausführen. Bei einer frischen Einrichtung ist es normalerweise mysql-bin.000001.
    • MASTER_LOG_POS: Die Position in der binären Protokolldatei, von der die Replikation beginnen soll. Sie können dies herausfinden, indem Sie SHOW MASTER STATUS; auf dem Master-Server ausführen. Bei einer frischen Einrichtung ist es normalerweise 4.

    Wichtig: Sie müssen die richtigen Werte für MASTER_LOG_FILE und MASTER_LOG_POS vom Master-Server ermitteln. Führen Sie auf dem Master-Server die folgende Abfrage aus:

    SHOW MASTER STATUS;

    Die Ausgabe zeigt die File (entspricht MASTER_LOG_FILE) und die Position (entspricht MASTER_LOG_POS). Verwenden Sie diese Werte in der CHANGE MASTER TO-Anweisung auf dem Slave-Server.

    Nach der Ausführung der CHANGE MASTER TO-Anweisung starten Sie den Slave:

    START SLAVE;

    Verlassen Sie den MySQL-Monitor auf dem Slave-Server:

    exit

Sie haben den Slave-Server jetzt so konfiguriert, dass er Daten vom Master-Server repliziert. Im nächsten Schritt werden wir überprüfen, ob die Replikation korrekt funktioniert.

Überprüfung der Replikation mit SHOW SLAVE STATUS

In diesem Schritt werden wir überprüfen, ob der Slave-Server erfolgreich Daten vom Master-Server repliziert. Wir verwenden den Befehl SHOW SLAVE STATUS, um den Status der Replikations-Threads zu überprüfen und eventuelle Probleme zu identifizieren.

  1. Überprüfen des Slave-Status:

    Melden Sie sich auf dem Slave-Server als Root-Benutzer am MySQL-Server an:

    sudo mysql -u root

    Führen Sie den folgenden Befehl aus, um den Slave-Status anzuzeigen:

    SHOW SLAVE STATUS\G

    Das \G am Ende des Befehls formatiert die Ausgabe vertikal, was das Lesen erleichtert.

  2. Interpretation der Ausgabe:

    Die Ausgabe von SHOW SLAVE STATUS liefert detaillierte Informationen über den Replikationsprozess. Hier sind einige Schlüsselfelder, auf die Sie achten sollten:

    • Slave_IO_State: Dies gibt den aktuellen Zustand des I/O-Threads an, der für das Lesen der binären Protokollereignisse vom Master verantwortlich ist. Idealerweise sollte es Waiting for master to send event anzeigen.
    • Slave_IO_Running: Dies gibt an, ob der I/O-Thread läuft. Es sollte Yes sein.
    • Slave_SQL_Running: Dies gibt an, ob der SQL-Thread läuft. Der SQL-Thread wendet die vom Master empfangenen Ereignisse auf die Slave-Datenbank an. Es sollte Yes sein.
    • Last_IO_Error: Wenn es Fehler im Zusammenhang mit dem I/O-Thread gibt, werden sie hier angezeigt.
    • Last_SQL_Error: Wenn es Fehler im Zusammenhang mit dem SQL-Thread gibt, werden sie hier angezeigt.
    • Master_Log_File: Der Name der binären Protokolldatei auf dem Master-Server, aus der der Slave derzeit liest.
    • Read_Master_Log_Pos: Die Position in der binären Protokolldatei, bis zu der der Slave gelesen hat.
    • Relay_Log_File: Der Name der Relay-Protokolldatei auf dem Slave-Server, aus der der SQL-Thread derzeit liest.
    • Relay_Log_Pos: Die Position in der Relay-Protokolldatei, bis zu der der SQL-Thread gelesen hat.
    • Seconds_Behind_Master: Dies gibt an, wie viele Sekunden der Slave hinter dem Master zurückliegt. Ein Wert von 0 bedeutet, dass der Slave aktuell ist. Ein größerer Wert zeigt an, dass der Slave hinterherhinkt.

    Bei einer erfolgreichen Replikationskonfiguration sollten Slave_IO_Running und Slave_SQL_Running auf Yes gesetzt sein, und Seconds_Behind_Master sollte nahe bei 0 liegen.

    Beispiel für eine erfolgreiche SHOW SLAVE STATUS-Ausgabe (gekürzt):

    *************************** 1. row ***************************
                   Slave_IO_State: Waiting for master to send event
                      Master_Host: master_host
                      Master_User: slave_user
                      Master_Port: 3306
                    Connect_Retry: 60
                  Master_Log_File: mysql-bin.000001
              Read_Master_Log_Pos: 154
                   Relay_Log_File: mysql-relay-bin.000002
                    Relay_Log_Pos: 311
            Relay_Master_Log_File: mysql-bin.000001
                 Slave_IO_Running: Yes
                Slave_SQL_Running: Yes
                  Replicate_Do_DB:
              Replicate_Ignore_DB:
               Replicate_Do_Table:
           Replicate_Ignore_Table:
          Replicate_Wild_Do_Table:
      Replicate_Wild_Ignore_Table:
                       Last_Errno: 0
                       Last_Error:
                     Skip_Counter: 0
              Exec_Master_Log_Pos: 154
                  Relay_Log_Space: 472
                  Until_Condition: None
                   Until_Log_File:
                    Until_Log_Pos: 0
               Master_SSL_Allowed: No
                Master_SSL_CA_File:
                Master_SSL_CA_Path:
                   Master_SSL_Cert:
                 Master_SSL_Cipher:
                    Master_SSL_Key:
             Seconds_Behind_Master: 0
    ...
  3. Erstellen einer Testdatenbank und -tabelle auf dem Master:

    Um die Replikation weiter zu überprüfen, erstellen Sie auf dem Master-Server eine Testdatenbank und -tabelle:

    sudo mysql -u root
    CREATE DATABASE test_replication;
    USE test_replication;
    CREATE TABLE test_table (
        id INT AUTO_INCREMENT PRIMARY KEY,
        data VARCHAR(255)
    );
    INSERT INTO test_table (data) VALUES ('This is a test record from master');
    exit
  4. Überprüfen der Daten auf dem Slave:

    Melden Sie sich auf dem Slave-Server als Root-Benutzer am MySQL-Server an:

    sudo mysql -u root

    Überprüfen Sie, ob die test_replication-Datenbank und die test_table-Tabelle repliziert wurden:

    USE test_replication;
    SELECT * FROM test_table;
    exit

    Sie sollten die auf dem Master-Server eingefügten Daten sehen:

    +----+-----------------------------------------+
    | id | data                                    |
    +----+-----------------------------------------+
    |  1 | This is a test record from master       |
    +----+-----------------------------------------+
    1 row in set (0.00 sec)

Wenn Sie die Testdatenbank, -tabelle und -daten auf dem Slave-Server sehen, funktioniert die Replikation korrekt.

Simulieren und Beheben eines Replikationsfehlers

In diesem Schritt werden wir einen häufigen Replikationsfehler simulieren und zeigen, wie er behoben werden kann. Dies hilft Ihnen zu verstehen, wie Sie Replikationsprobleme in einer realen Umgebung beheben können.

  1. Simulieren eines Fehlers:

    Ein häufiger Replikationsfehler tritt auf, wenn der Slave-Server eine Dateninkonsistenz feststellt. Wir simulieren dies, indem wir manuell eine Zeile in die Tabelle test_replication.test_table auf dem Slave-Server einfügen. Dies führt zu einem Konflikt, wenn der Master versucht, die gleiche Zeile zu replizieren.

    Melden Sie sich auf dem Slave-Server als Root-Benutzer am MySQL-Server an:

    sudo mysql -u root

    Fügen Sie eine Zeile in die Tabelle test_replication.test_table ein:

    USE test_replication;
    INSERT INTO test_table (data) VALUES ('This is an intentionally conflicting record on the slave');
    exit
  2. Auslösen der Replikation:

    Fügen Sie nun eine weitere Zeile in die Tabelle test_replication.test_table auf dem Master-Server ein:

    sudo mysql -u root
    USE test_replication;
    INSERT INTO test_table (data) VALUES ('This is a new record from master');
    exit

    Diese Einfügung auf dem Master löst die Replikation auf den Slave aus. Da wir jedoch manuell eine konfliktive Zeile auf dem Slave eingefügt haben, wird der Replikationsprozess wahrscheinlich einen Fehler encounter.

  3. Überprüfen des Slave-Status:

    Melden Sie sich auf dem Slave-Server als Root-Benutzer am MySQL-Server an:

    sudo mysql -u root

    Überprüfen Sie den Slave-Status:

    SHOW SLAVE STATUS\G

    Untersuchen Sie die Ausgabe. Sie sollten sehen, dass Slave_SQL_Running wahrscheinlich auf No gesetzt ist und das Feld Last_SQL_Error eine Fehlermeldung enthält, die auf einen doppelten Schlüssel oder einen ähnlichen Konflikt hinweist.

    Beispiel für eine Fehlermeldung:

    ...
                   Slave_IO_State: Waiting for master to send event
                      Master_Host: master_host
                      Master_User: slave_user
                      Master_Port: 3306
                    Connect_Retry: 60
                  Master_Log_File: mysql-bin.000002
              Read_Master_Log_Pos: 154
                   Relay_Log_File: mysql-relay-bin.000003
                    Relay_Log_Pos: 311
            Relay_Master_Log_File: mysql-bin.000002
                 Slave_IO_Running: Yes
                Slave_SQL_Running: No
                  Replicate_Do_DB:
              Replicate_Ignore_DB:
               Replicate_Do_Table:
           Replicate_Ignore_Table:
          Replicate_Wild_Do_Table:
      Replicate_Wild_Ignore_Table:
                       Last_Errno: 1062
                       Last_Error: Duplicate entry '1' for key 'PRIMARY'
                     Skip_Counter: 0
              Exec_Master_Log_Pos: 154
                  Relay_Log_Space: 472
                  Until_Condition: None
                   Until_Log_File:
                    Until_Log_Pos: 0
               Master_SSL_Allowed: No
                Master_SSL_CA_File:
                Master_SSL_CA_Path:
                   Master_SSL_Cert:
                 Master_SSL_Cipher:
                    Master_SSL_Key:
             Seconds_Behind_Master: NULL
    ...
  4. Beheben des Replikationsfehlers:

    Um diesen Fehler zu beheben, überspringen wir das problematische Ereignis auf dem Slave-Server. Dadurch wird dem Slave mitgeteilt, das Ereignis, das den Fehler verursacht hat, zu ignorieren und die Replikation mit dem nächsten Ereignis fortzusetzen.

    Stoppen Sie zunächst den Slave-SQL-Thread:

    STOP SLAVE SQL_THREAD;

    Überspringen Sie dann das fehlerhafte Ereignis:

    SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1;

    Dieser Befehl teilt dem Slave mit, das nächste Ereignis im Relay-Log zu überspringen.

    Starten Sie schließlich den Slave-SQL-Thread:

    START SLAVE SQL_THREAD;
  5. Überprüfen, ob die Replikation wieder läuft:

    Überprüfen Sie erneut den Slave-Status:

    SHOW SLAVE STATUS\G

    Sie sollten jetzt sehen, dass Slave_SQL_Running auf Yes gesetzt ist und Last_SQL_Error leer ist. Die Replikation sollte wieder normal laufen.

  6. Überprüfen der Datenkonsistenz:

    Überprüfen Sie auf dem Slave-Server den Inhalt der Tabelle test_replication.test_table:

    USE test_replication;
    SELECT * FROM test_table;
    exit

    Sie sollten sowohl den absichtlich konfliktiven Datensatz als auch den neuen Datensatz vom Master sehen. Der konfliktive Datensatz war bereits vorhanden, und der neue Datensatz wurde nach dem Überspringen des Fehlers erfolgreich repliziert.

    +----+-----------------------------------------------------+
    | id | data                                                |
    +----+-----------------------------------------------------+
    |  1 | This is a test record from master                   |
    |  2 | This is an intentionally conflicting record on the slave |
    |  3 | This is a new record from master                    |
    +----+-----------------------------------------------------+
    3 rows in set (0.00 sec)

Sie haben nun erfolgreich einen Replikationsfehler simuliert und ihn durch Überspringen des problematischen Ereignisses behoben. Dies ist eine gängige Technik zur Behebung von Replikationsproblemen, die durch Dateninkonsistenzen verursacht werden. Denken Sie daran, dass das Überspringen von Ereignissen mit Vorsicht erfolgen sollte, da es zu Datenabweichungen führen kann, wenn es nicht richtig behandelt wird. Es ist wichtig, die Ursache des Fehlers zu verstehen, bevor Sie Ereignisse überspringen.

Zusammenfassung

In diesem Lab (Praktikum) konzentriert sich der erste Schritt darauf, einen MySQL-Server als Master in einer Replikationsumgebung einzurichten, indem die binäre Protokollierung (binary logging) aktiviert wird. Dazu muss die MySQL-Konfigurationsdatei, die normalerweise unter /etc/mysql/mysql.conf.d/mysqld.cnf zu finden ist, bearbeitet werden. Innerhalb des mysqld-Abschnitts müssen die Zeilen log_bin = mysql-bin und server_id = 1 hinzugefügt werden.

Die Aktivierung der binären Protokollierung ist von entscheidender Bedeutung, da dadurch der Master-Server alle Datenänderungen protokollieren kann. Diese Protokolle werden dann vom Slave-Server verwendet, um die Änderungen zu replizieren und so die Datensynchronisierung sicherzustellen. Die Direktive log_bin gibt den Basisnamen für die binären Protokolldateien an, während die server_id dem Master-Server innerhalb der Replikationsumgebung eine eindeutige Kennung zuweist.