MySQL
Replikation
Suche…
Bemerkungen
Die Replikation wird verwendet, um [Backup] -Daten von einem MySQL-Datenbankserver auf einen oder mehrere MySQL-Datenbankserver zu kopieren.
Master - Der MySQL-Datenbankserver, der die zu kopierenden Daten bereitstellt
Slave - Der MySQL-Datenbankserver kopiert Daten, die vom Master bereitgestellt werden
Bei MySQL ist die Replikation standardmäßig asynchron. Dies bedeutet, dass Slaves nicht permanent verbunden sein müssen, um Updates vom Master zu erhalten. Wenn Ihr Slave beispielsweise ausgeschaltet oder nicht mit dem Master verbunden ist und Sie den Slave einschalten oder zu einem späteren Zeitpunkt mit dem Master verbunden sind, wird er automatisch mit dem Master synchronisiert.
Je nach Konfiguration können Sie alle Datenbanken, ausgewählte Datenbanken oder sogar ausgewählte Tabellen in einer Datenbank replizieren.
Replikationsformate
Es gibt zwei Kerntypen von Replikationsformaten
Statement Based Replication (SBR) - repliziert vollständige SQL-Anweisungen. Dabei schreibt der Master SQL-Anweisungen in das Binärlog. Die Replikation des Masters auf den Slave erfolgt durch Ausführen dieser SQL-Anweisungen auf dem Slave.
Row Based Replication (RBR) - Diese Option repliziert nur die geänderten Zeilen. Dabei schreibt der Master Ereignisse in das Binärlog, die angeben, wie einzelne Tabellenzeilen geändert werden. Die Replikation des Masters an den Slave erfolgt durch Kopieren der Ereignisse, die die Änderungen an den Tabellenzeilen darstellen, an den Slave.
Sie können auch eine dritte Variante, Mixed Based Replication (MBR), verwenden . Hierbei wird sowohl die anweisungsbasierte als auch die zeilenbasierte Protokollierung verwendet. Das Protokoll wird erstellt, je nachdem, welches für die Änderung am besten geeignet ist.
In MySQL-Versionen vor 5.7.7 war das Anweisungsformat der Standard. In MySQL 5.7.7 und höher ist das zeilenbasierte Format der Standard.
Master-Slave-Replikations-Setup
Betrachten Sie 2 MySQL-Server für die Replikationskonfiguration, einer ist ein Master und der andere ist ein Slave.
Wir werden den Master so konfigurieren, dass er ein Protokoll jeder durchgeführten Aktion speichert. Wir werden den Slave-Server so konfigurieren, dass er sich das Log im Master ansieht, und wenn sich Änderungen im Log auf dem Master ereignen, sollte er dasselbe tun.
Master-Konfiguration
Zunächst müssen wir einen Benutzer auf dem Master erstellen. Dieser Benutzer wird vom Slave verwendet, um eine Verbindung zum Master herzustellen.
CREATE USER 'user_name'@'%' IDENTIFIED BY 'user_password';
GRANT REPLICATION SLAVE ON *.* TO 'user_name'@'%';
FLUSH PRIVILEGES;
Ändern Sie user_name und user_password entsprechend Ihrem Benutzernamen und Passwort.
Jetzt sollte die Datei my.inf (my.cnf in Linux) bearbeitet werden. Fügen Sie die folgenden Zeilen in den Abschnitt [mysqld] ein.
server-id = 1
log-bin = mysql-bin.log
binlog-do-db = your_database
In der ersten Zeile wird diesem MySQL-Server eine ID zugewiesen.
In der zweiten Zeile wird MySQL angewiesen, ein Protokoll in die angegebene Protokolldatei zu schreiben. In Linux kann dies wie log-bin = /home/mysql/logs/mysql-bin.log . Wenn Sie die Replikation auf einem MySQL-Server starten, auf dem die Replikation bereits verwendet wurde, stellen Sie sicher, dass dieses Verzeichnis keine Replikationsprotokolle enthält.
In der dritten Zeile wird die Datenbank konfiguriert, für die das Protokoll geschrieben werden soll. Sie sollten ersetzen your_database mit Ihren Datenbanknamen.
Stellen Sie sicher, dass das skip-networking nicht aktiviert ist, und starten Sie den MySQL-Server (Master) erneut.
Slave-Konfiguration
my.inf Datei sollte auch im Slave bearbeitet werden. Fügen Sie die folgenden Zeilen in den Abschnitt [mysqld] ein.
server-id = 2
master-host = master_ip_address
master-connect-retry = 60
master-user = user_name
master-password = user_password
replicate-do-db = your_database
relay-log = slave-relay.log
relay-log-index = slave-relay-log.index
In der ersten Zeile wird diesem MySQL-Server eine ID zugewiesen. Diese ID sollte eindeutig sein.
Die zweite Zeile ist die IP-Adresse des Masterservers. Ändern Sie dies entsprechend der IP-Adresse Ihres Mastersystems
In der dritten Zeile wird ein Wiederholungslimit in Sekunden festgelegt.
Die nächsten beiden Zeilen teilen dem Slave den Benutzernamen und das Passwort mit, mit denen er den Master verbindet.
In der nächsten Zeile wird die zu replizierende Datenbank festgelegt.
Die letzten beiden Zeilen, die zum Zuweisen von relay-log und relay-log-index Dateinamen verwendet werden.
Stellen Sie sicher, dass das skip-networking nicht aktiviert ist, und starten Sie den MySQL-Server (Slave) erneut.
Daten zum Slave kopieren
Wenn ständig Daten zum Master hinzugefügt werden, müssen wir den gesamten Datenbankzugriff auf den Master verhindern, damit nichts hinzugefügt werden kann. Dies kann durch Ausführen der folgenden Anweisung in Master erreicht werden.
FLUSH TABLES WITH READ LOCK;
Wenn dem Server keine Daten hinzugefügt werden, können Sie den obigen Schritt überspringen.
Wir werden eine Datensicherung des Masters mit mysqldump
mysqldump your_database -u root -p > D://Backup/backup.sql;
Ändern your_database Ihre your_database und Ihr Sicherungsverzeichnis entsprechend Ihrem Setup. Sie haben jetzt eine Datei namens backup.sql am angegebenen Ort.
Wenn Ihre Datenbank nicht in Ihrem Slave vorhanden ist, erstellen Sie diese, indem Sie Folgendes ausführen
CREATE DATABASE `your_database`;
Jetzt müssen wir ein Backup in den Slave MySQL Server importieren.
mysql -u root -p your_database <D://Backup/backup.sql
--->Change `your_database` and backup directory according to your setup
Starten Sie die Replikation
Um die Replikation zu starten, müssen wir den Namen der Protokolldatei und die Protokollposition im Master suchen. Also führe folgendes in Master aus
SHOW MASTER STATUS;
Dadurch erhalten Sie eine Ausgabe wie unten
+---------------------+----------+-------------------------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+---------------------+----------+-------------------------------+------------------+
| mysql-bin.000001 | 130 | your_database | |
+---------------------+----------+-------------------------------+------------------+
Dann führe folgendes in Slave aus
SLAVE STOP;
CHANGE MASTER TO MASTER_HOST='master_ip_address', MASTER_USER='user_name',
MASTER_PASSWORD='user_password', MASTER_LOG_FILE='mysql-bin.000001', MASTER_LOG_POS=130;
SLAVE START;
Zuerst stoppen wir den Sklaven. Dann sagen wir genau, wo in der Master-Protokolldatei nachgesehen werden soll. MASTER_LOG_FILE Namen MASTER_LOG_FILE und MASTER_LOG_POS die Werte, die wir durch Ausführen des Befehls SHOW MASTER STATUS auf dem Master erhalten haben.
Sie sollten die IP des Masters in MASTER_HOST ändern und den Benutzer und das Kennwort entsprechend ändern.
Der Slave wartet jetzt. Der Status des Slaves kann durch Ausführen des folgenden angezeigt werden
SHOW SLAVE STATUS;
Wenn Sie zuvor FLUSH TABLES WITH READ LOCK im Master ausgeführt haben, geben Sie die Tabellen für die Sperre frei, indem Sie Folgendes ausführen
UNLOCK TABLES;
Jetzt führt der Master für jede durchgeführte Aktion ein Protokoll, und der Slave-Server sieht das Protokoll im Master an. Wenn sich Änderungen am Log auf dem Master ereignen, replizieren Sie den Slave.
Replikationsfehler
Wenn beim Ausführen einer Abfrage auf dem Slave ein Fehler auftritt, stoppt MySQL automatisch die Replikation, um das Problem zu identifizieren und es zu beheben. Dies ist hauptsächlich darauf zurückzuführen, dass ein Ereignis einen doppelten Schlüssel verursachte oder eine Zeile nicht gefunden wurde und es nicht aktualisiert oder gelöscht werden kann. Sie können solche Fehler überspringen, auch wenn dies nicht empfohlen wird
Verwenden Sie die folgende Syntax, um nur eine Abfrage zu überspringen, bei der der Slave hängt
SET GLOBAL sql_slave_skip_counter = N;
Diese Anweisung überspringt die nächsten N Ereignisse vom Master. Diese Anweisung ist nur gültig, wenn die Slave-Threads nicht ausgeführt werden. Andernfalls wird ein Fehler ausgegeben.
STOP SLAVE;
SET GLOBAL sql_slave_skip_counter=1;
START SLAVE;
In manchen Fällen ist das in Ordnung. Wenn die Anweisung jedoch Teil einer Transaktion mit mehreren Anweisungen ist, wird sie komplexer, da das Überspringen der fehlererzeugenden Anweisung die gesamte Transaktion überspringt.
Wenn Sie mehr Abfragen überspringen möchten, die denselben Fehlercode erzeugen, und wenn Sie sicher sind, dass das Überspringen dieser Fehler Ihren Slave nicht inkonsistent macht und Sie sie alle überspringen möchten, fügen Sie eine Zeile zum Überspringen des Fehlercodes in Ihrer my.cnf .
Beispielsweise möchten Sie möglicherweise alle doppelten Fehler überspringen, die Sie möglicherweise erhalten
1062 | Error 'Duplicate entry 'xyz' for key 1' on query
Dann fügen Sie Ihrer my.cnf folgendes my.cnf
slave-skip-errors = 1062
Sie können auch andere Fehlerarten oder alle Fehlercodes überspringen. Stellen Sie jedoch sicher, dass das Überspringen dieser Fehler Ihren Slave nicht inkonsistent macht. Nachfolgend finden Sie die Syntax und Beispiele
slave-skip-errors=[err_code1,err_code2,...|all]
slave-skip-errors=1062,1053
slave-skip-errors=all
slave-skip-errors=ddl_exist_errors