Mysql
 sql >> Datenbank >  >> RDS >> Mysql

So konfigurieren Sie die Source-Replica-Replikation in MySQL

Das MySQL ist ein relationales Datenbankverwaltungssystem, das eines der beliebtesten Open-Source-Projekte ist. Obwohl MySQL für seine Stabilität bekannt ist, ist es sogar noch zuverlässiger, wenn die Replikation der Quellreplik konfiguriert ist. Bei der Replikation wird normalerweise ein MySQL-Server als Quelle bezeichnet . Eine Quelle sendet alle Datenbankänderungen und Datenaktualisierungen an ein oder mehrere Replikate Datenbankserver. Das Datenreplikationsverfahren von MySQL ist flexibel, und die Replica-Server müssen nicht permanent mit der Quelle verbunden sein. Diese Anleitung erläutert, wie Sie die Quellreplikat-Datenreplikation in MySQL konfigurieren.

Funktionsweise der MySQL-Datenreplikation

Der Replikationsprozess speichert Daten zuerst in der Quelldatenbank und kopiert sie dann auf beliebige Replikate. Nachdem er die Anweisung verarbeitet hat, verfolgt der Quelldatenbankserver die Änderung in einem Binärprotokoll. Das Protokoll dient als fortlaufende Aufzeichnung aller Änderungen an der Datenbankstruktur und den Inhalten. SELECT Anweisungen werden nicht aufgezeichnet, da sie den Inhalt der Datenbank nicht ändern.

Aktualisierungen erfolgen asynchron, sodass die Replikate nicht ständig verbunden sein müssen. Dies steht im Gegensatz zu den synchronen Architekturen hochzuverlässiger Systeme. Wenn Echtzeitsynchronisierung erforderlich ist, empfiehlt MySQL die Verwendung des NDB-Clusters .

Jedes Replikat ruft Daten aus der Quelle ab, indem es den Inhalt des Binärlogs der Quelle anfordert. Das Replikat wendet dann die Anweisungen der Reihe nach an und gibt die Ereignisse effektiv wieder, die auf der Quelle aufgetreten sind. Jede Replik ist unabhängig und verfolgt ihre aktuelle Position mit dem binären Quellprotokoll. Darüber hinaus kann sich jedes Replikat gemäß seinem eigenen Zeitplan mit der Quelle synchronisieren. Daten können von allen Servern gelesen werden, einschließlich der Replikate.

MySQL ermöglicht ein hohes Maß an Granularität. Es ist möglich, über bestimmte Datenbanken oder sogar bestimmte Tabellen innerhalb einer Datenbank zu replizieren. Das standardmäßige Replikationsformat ist Anweisungsbasierte Replikation (SBR), in dem die gesamte SQL-Anweisung repliziert wird. Allerdings zeilenbasierte Replikation (RBR) ist ebenfalls verfügbar. Dieses Format repliziert die geänderten Zeilen. Es ist auch möglich, kompliziertere Many-to-Many-Konfigurationen zu konfigurieren. Weitere Informationen zu den verschiedenen Replikationsoptionen finden Sie in der MySQL-Dokumentation.

Hinweis MySQL bezeichnete die Source-Replica-Replikation früher als „Master-Slave-Replikation“. Die MySQL-Organisation hat kürzlich die Terminologie geändert und ihre Argumentation in einem Terminologie-Update erläutert. Der ältere Begriff „Master“ wurde in „Quelle“ geändert, während ein „Slave“ jetzt als „Replica“ bezeichnet wird. Die alten Begriffe erscheinen möglicherweise noch in bestimmten Befehlen und Ausgabeanzeigen, während MySQL seine Codebasis aktualisiert. In diesem Leitfaden werden in den Anweisungen die bevorzugten Begriffe von MySQL verwendet.

Vorteile der MySQL-Datenreplikation

Die Aktivierung der Quellreplikatreplikation bietet viele bedeutende Vorteile gegenüber einem nicht redundanten System. Die folgende Liste gibt einen Überblick über einige Vorteile:

  • Es ist jederzeit einfach, eine Live-Sicherungskopie zu erstellen. Da der Replikationsprozess asynchron ist, kann die Replikation nach einem beliebigen Zeitplan erfolgen. Die Replikate müssen nicht mit der Quelle synchron gehalten werden, um zuverlässig zu funktionieren.

  • Das Hinzufügen eines Replikats kann die Verfügbarkeit und Zuverlässigkeit des gesamten Systems erhöhen. Die primäre Steuerung kann auf das Replikat umschalten, wenn Wartungsarbeiten erforderlich sind oder die Quelldatenbank nicht verfügbar ist.

  • Jedes Replikat stellt eine weitere lesbare Instanz der Datenbank bereit. Dadurch können Data-Mining- oder Analyseprogramme die Replik abfragen, ohne die ursprüngliche Quelldatenbank zusätzlich zu belasten.

  • Diese Architektur erhöht die Skalierbarkeit und Leistung. Datenbank liest und SELECT Anweisungen können zwischen den Servern ausgeglichen werden, wodurch die Latenz reduziert wird.

  • Dritte können über ein Replikat schreibgeschützten Zugriff auf eine Datenbank erhalten und benötigen keinen Zugriff mehr auf die Quelle. Eine Replikatdatenbank kann bei Bedarf nach Bedarf erstellt und gelöscht werden, wenn sie nicht mehr benötigt wird. Diese Technik erhöht die Sicherheit und stellt sicher, dass die Originaldaten nicht manipuliert werden können.

Bevor Sie beginnen

  1. Wenn Sie dies noch nicht getan haben, erstellen Sie ein Linode-Konto und eine Compute-Instanz. Sehen Sie sich unsere Leitfäden Erste Schritte mit Linode und Erstellen einer Compute-Instanz an.

  2. Folgen Sie unserem Leitfaden zum Einrichten und Sichern einer Compute-Instanz, um Ihr System zu aktualisieren. Möglicherweise möchten Sie auch die Zeitzone festlegen, Ihren Hostnamen konfigurieren, ein eingeschränktes Benutzerkonto erstellen und den SSH-Zugriff sichern.

  3. Sie müssen mindestens zwei separate Linodes haben, um die MySQL-Quellreplikatreplikation zu konfigurieren. Ein Linode hostet die Quelldatenbank, während ein weiterer Knoten für den Replikationsserver erforderlich ist.

Hinweis Die Schritte in diesem Handbuch sind für einen Nicht-Root-Benutzer geschrieben. Befehlen, die erhöhte Berechtigungen erfordern, wird das Präfix sudo vorangestellt . Wenn Sie mit sudo nicht vertraut sind finden Sie im Handbuch für Linux-Benutzer und -Gruppen.

Quellreplikat-Replikation in MySQL konfigurieren

Um die Quellreplikatreplikation zu konfigurieren, muss MySQL auf zwei separaten Servern installiert werden, die miteinander kommunizieren können. Diese Anleitung ist auf die Ubuntu-Distribution ausgerichtet, gilt aber allgemein für alle Linux-Distributionen. Der Prozess besteht aus den folgenden Schritten:

  1. Installieren Sie MySQL.
  2. Konfigurieren Sie die MySQL-Quelldatenbank.
  3. Konfigurieren Sie einen neuen MySQL-Benutzer für das Replikat.
  4. Bereiten Sie die MySQL-Daten für die Replikation vor.
  5. Konfigurieren Sie die MySQL-Replikatdatenbank.
  6. Importieren Sie die replizierten MySQL-Daten und aktivieren Sie die Replikation.

Installieren Sie MySQL

Wenn MySQL nicht bereits auf beiden Linodes verfügbar ist, installieren Sie es mit den folgenden Schritten:

  1. Werte die Linodes auf.

     sudo apt-get update && sudo apt-get upgrade

  2. Installieren Sie die MySQL-Server- und -Client-Anwendungen sowohl auf dem Quell- als auch auf dem Replikatserver.

     sudo apt-get install mysql-server mysql-client -y

  3. Konfigurieren Sie die Sicherheitsoptionen, einschließlich des Root-Passworts, mit mysql_secure_installation Befehl.

     sudo mysql_secure_installation

  4. Wenn Sie eine Firewall wie ufw verwenden , stellen Sie sicher, dass MySQL-Datenverkehr durchgelassen wird. Fügen Sie die folgende Regel hinzu, um Port 3306 zu öffnen auf der Firewall.

     ufw allow mysql

Konfigurieren Sie die MySQL-Quelldatenbank

Um die MySQL-Replikation zu aktivieren, bearbeiten Sie einige Variablen in der Hauptkonfigurationsdatei von MySQL. Nehmen Sie die folgenden Änderungen an der Konfiguration der Quelldatenbank vor.

  1. Suchen Sie die MySQL-Hauptkonfigurationsdatei auf dem Quelldatenbankserver. Diese Datei befindet sich normalerweise unter /etc/mysql/mysql.conf.d/mysqld.cnf . In früheren Installationen könnte es sich jedoch unter /etc/my.cnf befinden oder /etc/mysql/my.cnf . Es könnte auch von einer der Dateien über ein includedir referenziert werden Richtlinie.

  2. Öffnen Sie die MySQL-Konfigurationsdatei und ändern Sie die bind-address an die IP-Adresse des Quellservers.

    Datei:/ etc/mysql/mysql.conf.d/mysqld.cnf
    1
2

    bind-address  = <source_ip_address>

  3. Kommentieren Sie die Zeilen für server-id aus oder fügen Sie sie hinzu und log-bin . Legen Sie die server-id fest zu 1 , und log-bin nach /var/log/mysql/mysql-bin.log .

    Hinweis Stellen Sie das skip_networking sicher Variable ist nirgendwo deklariert. Kommentieren Sie es aus, wenn es in dieser Datei erscheint. Um eine einzelne Datenbank zu replizieren, fügen Sie die Zeile binlog_do_db = <database_name> hinzu in die Datei.
    Datei:/ etc/mysql/mysql.conf.d/mysqld.cnf
    1
2
3

    server-id  = 1
log_bin  = /var/log/mysql/mysql-bin.log

  4. Starten Sie den MySQL-Dienst neu.

     sudo systemctl restart mysql

  5. Überprüfen Sie den Status von MySQL und stellen Sie sicher, dass es active ist .

     sudo systemctl status mysql

    mysql.service - MySQL Community Server
Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset: enabled)
Active: active (running) since Sun 2021-05-30 13:06:47 UTC; 1 day 1h ago

Konfigurieren Sie einen neuen MySQL-Benutzer für das Replikat

Sie müssen einen neuen Benutzer auf dem Quellserver erstellen, um das Replikat darzustellen. Neue Benutzer werden innerhalb der MySQL-Shell erstellt.

  1. Rufen Sie die MySQL-Shell auf.

     sudo mysql -u root -p

  2. Fügen Sie mithilfe von MySQL CREATE USER einen Benutzer für das Replikatkonto hinzu Syntax. Der Benutzername muss aus dem Namen des Replikatkontos bestehen, einem @ Symbol und die IP-Adresse des Replikatservers. Wählen Sie anstelle von REPLICA_PASSWORD ein sichereres Passwort für das Konto .

     CREATE USER 'replica_account_name'@'replica_ip_address‘ IDENTIFIED WITH sha256_password BY 'REPLICA_PASSWORD';
    Hinweis Damit das Replikat von jeder Adresse aus eine Verbindung herstellen kann, geben Sie den Benutzer als 'replica_account_name'@'%' an . Der % Das Symbol steht für eine beliebige Adresse oder Domäne. Dies bietet zusätzliche Flexibilität auf Kosten der Sicherheit.

  3. Gewähren Sie dem Remote-Replik-Benutzer Replikationsrechte.

     GRANT REPLICATION SLAVE ON *.* TO 'replica_account_name'@'replica_ip_address';

Vorbereiten der MySQL-Daten für die Replikation

An diesem Punkt ist es notwendig, die Quelldatenbank zu leeren und zu sperren, um die Daten für die Replikation bereitzustellen.

  1. Bleiben Sie in der MySQL-Shell und leeren Sie die Berechtigungen, um die Grant-Tabellen neu zu laden, ohne die Datenbank neu zu starten.

     FLUSH PRIVILEGES;

  2. Sperren Sie die Datenbank, um die Datenbank an einem stabilen Punkt einzufrieren, von dem aus die Daten exportiert werden können. Lassen Sie den MySQL-Client laufen, bis Sie die Datenbank exportieren. Die Eingabe eines Schreibbefehls oder das Verlassen der MySQL-Shell hebt die Sperre auf.

     FLUSH TABLES WITH READ LOCK;
    Achtung Dieser Befehl blockiert alle Commits an die Quelldatenbank. Exportieren Sie die Daten, bevor Sie der Quelle erlauben, weitere Commits zu verarbeiten. Andernfalls könnte die Replikatdatenbank beschädigt werden oder mit der Quelldatenbank inkonsistent werden. Führen Sie die beiden verbleibenden Schritte in diesem Abschnitt so schnell wie möglich aus.

  3. Überprüfen Sie den Status der Datenbank mit dem folgenden Befehl. Dieser Befehl zeigt die aktuelle Protokolldatei zusammen mit der Position des letzten Datensatzes in dieser Datei an. Notieren Sie sich diese Informationen, da sie später erforderlich sind, um die Replikation auf dem Replikat zu initiieren.

     SHOW MASTER STATUS;

    +------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000002 |     1301 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)

  4. Exportieren Sie die Datenbank mithilfe der Linux-Shell von einer anderen Konsole aus mit mysqldump Werkzeug. Wählen Sie einen einprägsamen Namen für die Zieldatei. Fügen Sie die –master-data hinzu Option zum Hinzufügen von Informationen über die Protokolldatei und die Position des aktuellen Datensatzes zum Protokoll.

     sudo mysqldump -u root -p -–all-databases -–master-data > databasecopy.sql
    Hinweis Um eine einzelne Datenbank zu exportieren, schließen Sie --opt <database_name> ein Option anstelle von -–all-databases .

  5. Zurück in der ursprünglichen MySQL-Shell entsperren Sie die Quelldatenbank.

     UNLOCK TABLES;

  6. Beenden Sie die MySQL-Shell.

     QUIT;

  7. Kopieren Sie die exportierte Datenbankdatei mit ftp auf den replizierten Datenbankserver , scp , oder eine andere Methode zum Übertragen der Datei.

     scp databasecopy.sql [email protected]<replica_ip_address>

Konfigurieren Sie die MySQL-Replikatdatenbank

Die folgende Konfiguration sollte auf die Replikatdatenbankkonfiguration angewendet werden. Informationen zum Installieren von MySQL auf dem Replikatserver finden Sie im Abschnitt MySQL installieren.

  1. Öffnen Sie die MySQL-Hauptdatei, die sich normalerweise unter /etc/mysql/mysql.conf.d/mysqld.cnf befindet , und ändern Sie die bind-address um mit der IP-Adresse des Replica-Servers übereinzustimmen.

    Datei:/ etc/mysql/mysql.conf.d/mysqld.cnf
    1
2

    bind-address  = xx.xx.xx.xx

  2. Kommentieren Sie die Zeilen für server-id aus oder fügen Sie sie hinzu und log-bin . Die server-id muss auf 2 gesetzt werden auf dem Replikat, während der log-bin Variable muss auf /var/log/mysql/mysql-bin.log gesetzt werden . Fügen Sie eine Variable für relay-log hinzu und setzen Sie es auf /var/log/mysql/mysql-relay-bin.log .

    Hinweis Stellen Sie das skip_networking sicher Die Variable ist nirgendwo in dieser Datei gesetzt. Um eine einzelne Datenbank zu replizieren, fügen Sie der Datei binlog_do_db = database_name die folgende Direktive hinzu . Um mehr als ein Replikat zu konfigurieren, nummerieren Sie die server-id Werte sequentiell ansteigend. Beispielsweise hätte ein zweites Replikat eine server-id von 3 .
    Datei:/ etc/mysql/mysql.conf.d/mysqld.cnf
    1
2
3
4

    server-id        = 2
log_bin    = /var/log/mysql/mysql-bin.log
relay-log        = /var/log/mysql/mysql-relay-bin.log

  3. Starten Sie den MySQL-Dienst neu, um die Änderungen zu übernehmen.

     sudo systemctl restart mysql

  4. Überprüfen Sie den Status von MySQL und stellen Sie sicher, dass es active ist .

     sudo systemctl status mysql

    mysql.service - MySQL Community Server
     Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset:>
     Active: active (running) since Mon 2021-05-31 16:29:48 UTC; 6s ago

  5. (Optional ) MySQL empfiehlt aus Sicherheitsgründen die Verwendung von SSL zur Verbindung mit der Quelle. Weitere Informationen zum Konfigurieren von SSL finden Sie in der MySQL-SSL-Dokumentation. DasRSA-Einrichtungstool kann verwendet werden, um diesen Prozess zu beschleunigen.

Importieren Sie die replizierten MySQL-Daten und aktivieren Sie die Replikation

Der nächste Schritt besteht darin, die Kopie der Datenbankdaten zu importieren, die Replikationsquelle festzulegen und den Replikat-Datenbankserver neu zu starten. Das Replikat sollte dann synchronisiert und einsatzbereit sein.

  1. Geben Sie den folgenden Befehl in der Linux-Shell ein, um die Quelldatenbank zu importieren. Geben Sie den Datenbanknamen an, der zuvor zum Exportieren der Daten verwendet wurde.

     sudo mysql -u root -p < databasecopy.sql

  2. Melden Sie sich bei der MySQL-Shell an.

     sudo mysql -u root -p

  3. Beenden Sie das Replikat.

     STOP REPLICA;

  4. Geben Sie CHANGE REPLICATION SOURCE ein Befehl, zusammen mit den folgenden Details. Ersetzen Sie source_ip_address durch die IP-Adresse des Quelldatenbankservers . Für SOURCE_USER und SOURCE_PASSWORD , geben Sie den Benutzernamen und das Kennwort des Replikats im Abschnitt Konfigurieren eines neuen MySQL-Benutzers für das Replikat ein. Für die SOURCE_LOG_FILE und SOURCE_LOG_POS geben Sie die Informationen ein, die Sie unter SHOW MASTER STATUS; aufgezeichnet haben Befehl.

     CHANGE REPLICATION SOURCE TO SOURCE_HOST='source_ip_address',SOURCE_USER='replica_account_name', SOURCE_PASSWORD='REPLICA_PASSWORD', SOURCE_LOG_FILE='log_file_name', SOURCE_LOG_POS=log_position;
    Hinweis Um SSL für die Verbindung zu verwenden, was MySQL empfiehlt, fügen Sie das Attribut SOURCE_SSL=1 hinzu zum Befehl. Weitere Informationen zur Verwendung von SSL in einem Quell-Replikat-Replikationskontext finden Sie in der MySQL-Dokumentation.

  5. Starten Sie das Replikat neu.

     START REPLICA;

  6. Überprüfen Sie den Status des Replikats. Das Replikat sollte auf Ereignisse warten und es sollte keinen Last_IO_Error geben oder Last_Error Veranstaltungen. Der Slave_SQL_Running_State Der Eintrag sollte angeben, dass das Replikat das Relay-Protokoll gelesen hat.

     SHOW REPLICA STATUS\G

    Slave_IO_State: Waiting for master to send event
                  Master_Host: 178.79.153.39
                  Master_User: replica
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000006
          Read_Master_Log_Pos: 156
               Relay_Log_File: mysql-relay-bin.000006
                Relay_Log_Pos: 371
        Relay_Master_Log_File: mysql-bin.000006
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
..
                   Last_Errno: 0
                   Last_Error:
..
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error:
               Last_SQL_Errno: 0
               Last_SQL_Error:
  Replicate_Ignore_Server_Ids:
             Master_Server_Id: 1
                  Master_UUID: 5bed9d10-c140-11eb-bc63-f23c92a2a6ac
             Master_Info_File: mysql.slave_master_info
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Slave has read all relay log; waiting for more updates

Testen Sie die MySQL Source-Replica-Replikation

Wenn die Quelldatenbank bereits aufgefüllt wurde, bevor das Replikat instanziiert wurde, sind zusätzliche Tests erforderlich. Stellen Sie in diesem Fall sicher, dass die Datenbanken und Tabellen, die auf der Quelle vorhanden sind, auf dem Replikat vorhanden sind, nachdem die Daten importiert wurden. Im SHOW REPLICA STATUS Anzeige, der Slave_SQL_Running_State Der Eintrag sollte Slave has read all relay log lauten .

Um zu überprüfen, ob die Replikation ordnungsgemäß erfolgt, erstellen Sie eine neue Datenbank oder Tabelle auf der Quelle. Nach einigen Sekunden sollte der neue Eintrag auf dem Replikat vorhanden sein. Überprüfen Sie das Vorhandensein der Datenbank mit SHOW DATABASES; Befehl. Um das Vorhandensein einer Tabelle zu bestätigen, wechseln Sie mit USE databasename; zur Datenbank , und geben Sie SHOW TABLES; ein . Es ist auch eine gute Idee, den SHOW REPLICA STATUS auszuführen Befehl und überprüfen Sie die Ausgabe auf Fehler. Der Last_Error und Last_IO_Error Felder sollten leer sein und das Replikat sollte verbunden bleiben.

Weitere Informationen zur MySQL-Quellreplikatreplikation

Die beste Quelle für Informationen zur Replikation von Quellreplikaten ist die offizielle MySQL-Dokumentation. Der Abschnitt zur Replikation enthält ausführlichere Informationen zur Architektur und zum Installationsprozess. Die MySQL-Foren könnten ebenfalls hilfreich sein.

Weitere Informationen

Weitere Informationen zu diesem Thema finden Sie in den folgenden Ressourcen. Obwohl diese in der Hoffnung bereitgestellt werden, dass sie nützlich sind, beachten Sie bitte, dass wir nicht für die Genauigkeit oder Aktualität extern gehosteter Materialien garantieren können.

  • MySQL-Dokumentation