Implementierungsprinzip und Konfiguration der MySql Master-Slave-Replikation

Die Trennung von Lese- und Schreibzugriffen in Datenbanken ist eine wesentliche und wichtige Funktion für große Systeme oder Internetanwendungen mit hohem Datenverkehr. Bei MySQL ist die standardmäßige Lese-/Schreibtrennung der Master-Slave-Modus, wobei ein Schreibknoten Master ist, gefolgt von mehreren Leseknoten. Die Anzahl der Leseknoten hängt von der Systemauslastung ab und wird normalerweise mit 1-3 Leseknoten konfiguriert. Allgemeine Middleware zur Lese-/Schreibtrennung, wie beispielsweise die Lese-/Schreibtrennung und der automatische Umschaltmechanismus von Mycat, erfordert die Zusammenarbeit mit dem Master-Slave-Replikationsmechanismus von MySQL.

Hinweise zur Master-Slave-Konfiguration

1. Die Versionen der Master-DB-Server- und Slave-DB-Server-Datenbanken sind konsistent

2. Die Datenbankdatennamen des Master-DB-Servers und des Slave-DB-Servers sind konsistent

3. Der Master-DB-Server startet die binäre Protokollierung. Die Server-IDs des Master-DB-Servers und des Slave-DB-Servers müssen eindeutig sein. MySQL-Masterserver-Konfiguration

Schritt 1: Ändern Sie die Datei my.conf:

Fügen Sie unter dem Abschnitt [mysqld] Folgendes hinzu:

binlog-ignore-db=mysql

# Binärprotokoll aktivieren log-bin=mysql-bin
//Es gibt drei Formate für Binärprotokolle: Anweisung/Zeile/gemischt
binlog_format=Zeile
#Die eindeutige ID des Hauptservers, normalerweise das letzte Segment der IP-Adresse server-id=82

Schritt 2: Starten Sie den MySQL-Dienst neu

Dienst MySQL Neustart

Schritt 3: Konto erstellen und Slave autorisieren

mysql>GRANT FILE ON *.* TO 'slave'@'%' IDENTIFIZIERT DURCH 'slavepw';
mysql>GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* an 'Slave'@'%', identifiziert durch 'slavepw';

Im Allgemeinen wird das Root-Konto nicht verwendet. „%“ bedeutet, dass sich alle Clients verbinden können, solange Konto und Passwort korrekt sind. Zur Erhöhung der Sicherheit kann hier die spezifische Client-IP-Adresse verwendet werden, z. B. 192.168.145.226.

Berechtigungen aktualisieren

mysql> FLUSH-PRIVILEGIEN;

Schritt 4: Status des Masters abfragen

mysql> Masterstatus anzeigen;
+------------------+----------+--------------+------------------+-------------------+
| Datei | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000001 | 881 | | mysql | |
+------------------+----------+--------------+------------------+-------------------+
1 Zeile im Satz (0,00 Sek.)

MySQL-Slave-Server-Konfiguration

Schritt 1: Ändern Sie die Datei my.conf

[mysqld]# Eindeutige ID vom Server, normalerweise das letzte Segment der IP-Adresse server-id=83

Schritt 2: Konfigurieren Sie den Slave-Server

mysql>ändere Master in master_host='192.168.11.82',master_port=3306,master_user='slave',master_password='slavepw',master_log_file='mysql-bin.000001',master_log_pos=881;

Achten Sie darauf, die Anweisung in der Mitte nicht zu trennen. „master_port“ ist die Portnummer des MySQL-Servers (ohne Anführungszeichen), „master_user“ ist das Datenbankkonto, das die Synchronisierungsoperation ausführt, und „881“ hat keine einfachen Anführungszeichen (hier ist 881 der in „show master status“ angezeigte Positionswert und hier ist „mysql-bin.000001“ der der Datei entsprechende Wert).

Schritt 3: Starten Sie die Replikationsfunktion vom Server aus

mysql>Slave starten;

Schritt 4: Überprüfen Sie den Status der Replikationsfunktion des Slave-Servers:

mysql> Slave-Status anzeigen;

Slave_IO_Running: Ja //Dieser Status muss JA sein

Slave_SQL_Running: Ja //Dieser Status muss JA sein

Hinweis: Die Prozesse Slave_IO und Slave_SQL müssen normal ausgeführt werden, d. h. sich im Zustand „JA“ befinden, andernfalls befinden sie sich in einem Fehlerzustand (wenn einer von ihnen beispielsweise „NEIN“ lautet, handelt es sich um einen Fehler).

Verifizieren

Erstellen Sie eine Tabelle und fügen Sie Daten auf dem Masterknoten ein. Achten Sie darauf, dass der Slaveknoten ebenfalls eine Tabelle erstellt und Daten einfügt.

Was ist das Prinzip der MySQL Master-Slave-Replikation?

Die Masterdatenbank schreibt die Änderungen in das Binlog-Protokoll. Nachdem die Slavedatenbank eine Verbindung mit der Masterdatenbank hergestellt hat, verfügt die Slavedatenbank über einen IO-Thread, der das Binlog-Protokoll der Masterdatenbank auf seinen lokalen Computer kopiert und in ein Relay-Protokoll schreibt. Anschließend liest ein SQL-Thread in der Slave-Datenbank das Binärprotokoll aus dem Relay-Protokoll und führt den Inhalt des Binärprotokolls aus, d. h. er führt SQL lokal erneut aus, um sicherzustellen, dass die Daten mit denen der Master-Datenbank übereinstimmen.

Hier gibt es einen sehr wichtigen Punkt: Der Prozess der Synchronisierung der Daten der Slave-Datenbank mit der Master-Datenbank wird serialisiert, d. h. die parallelen Vorgänge in der Master-Datenbank werden seriell in der Slave-Datenbank ausgeführt. Dies ist also ein sehr wichtiger Punkt. Aufgrund der Eigenschaften der Slave-Datenbank, die Protokolle aus der Master-Datenbank kopiert und SQL seriell ausführt, sind die Daten in der Slave-Datenbank in einem Szenario mit hoher Parallelität definitiv langsamer als die in der Master-Datenbank, und es kommt zu einer Verzögerung. Daher kommt es häufig vor, dass die gerade in die Hauptdatenbank geschriebenen Daten nicht lesbar sind und das Lesen Dutzende oder sogar Hunderte von Millisekunden dauern kann.

Und hier gibt es noch ein weiteres Problem. Wenn die Master-Datenbank plötzlich ausfällt und die Daten nicht mit der Slave-Datenbank synchronisiert wurden, sind einige Daten möglicherweise nicht in der Slave-Datenbank verfügbar und einige Daten gehen möglicherweise verloren.

MySQL verfügt in diesem Bereich also eigentlich über zwei Mechanismen. Einer ist die halbsynchrone Replikation, mit der das Problem des Datenverlusts in der Masterdatenbank gelöst wird, und der andere ist die parallele Replikation, mit der das Problem der Synchronisationsverzögerung zwischen Master und Slave gelöst wird.

Diese sogenannte halbsynchrone Replikation, auch semi-sync Replikation genannt, bedeutet, dass die Master-Datenbank, nachdem sie das Binlog-Protokoll geschrieben hat, gezwungen wird, die Daten sofort mit der Slave-Datenbank zu synchronisieren. Nachdem die Slave-Datenbank das Protokoll in ihr lokales Relay-Protokoll geschrieben hat, gibt sie eine Bestätigung an die Master-Datenbank zurück. Die Master-Datenbank betrachtet den Schreibvorgang erst dann als abgeschlossen, wenn sie mindestens eine Bestätigung von der Slave-Datenbank erhalten hat.

Die sogenannte parallele Replikation bedeutet, dass mehrere Threads aus der Datenbank gestartet werden, Protokolle aus verschiedenen Datenbanken im Relay-Protokoll parallel gelesen werden und dann Protokolle aus verschiedenen Datenbanken parallel wiedergegeben werden. Dies ist Parallelität auf Datenbankebene.

Problem mit der Verzögerung der MySQL-Master-Slave-Synchronisierung

In der Vergangenheit hatten wir es mit Online-Fehlern zu tun, die durch Verzögerungen bei der Master-Slave-Synchronisierung verursacht wurden. Dabei handelte es sich um kleinere Produktionsunfälle.

Ist das die Szene? Ein Klassenkamerad hat die Code-Logik folgendermaßen geschrieben. Fügen Sie zuerst Daten ein, checken Sie diese dann aus und aktualisieren Sie anschließend die Daten. Während der Spitzenzeit der Produktionsumgebung erreichte die Schreibparallelität 2000/s. Zu diesem Zeitpunkt betrug die Master-Slave-Replikationsverzögerung etwa zehn Millisekunden. Wir werden feststellen, dass jeden Tag einige Daten verfügbar sind und wir erwarten, den Status einiger wichtiger Daten zu aktualisieren, diese werden jedoch während der Spitzenzeiten nicht aktualisiert. Benutzer geben dem Kundendienst Feedback, und der Kundendienst gibt uns Feedback.

Wir verwenden den MySQL-Befehl:

Status anzeigen

Wenn Sie sich Seconds_Behind_Master ansehen, können Sie erkennen, dass die Slave-Datenbank beim Kopieren der Daten aus der Master-Datenbank mehrere Millisekunden hinterherhinkt.

Wenn die Master-Slave-Verzögerung schwerwiegend ist, gibt es im Allgemeinen die folgenden Lösungen:

Durch Datenbank-Sharding, also das Aufteilen einer Hauptdatenbank in mehrere Hauptdatenbanken, wird die Schreibparallelität jeder Hauptdatenbank um ein Vielfaches reduziert und die Master-Slave-Verzögerung kann ignoriert werden. Aktivieren Sie die von MySQL unterstützte parallele Replikation und replizieren Sie mehrere Datenbanken parallel. Wenn die Schreibparallelität einer bestimmten Datenbank sehr hoch ist und die Schreibparallelität einer einzelnen Datenbank 2000/s erreicht, ist eine parallele Replikation immer noch sinnlos. Schreiben Sie den Code neu. Studenten, die Code schreiben, sollten vorsichtig sein. Beim Einfügen von Daten können Sie diese möglicherweise nicht sofort finden. Wenn es existiert und zuerst eingefügt werden muss, muss es sofort abgefragt werden und dann müssen einige Operationen sofort umgekehrt ausgeführt werden. Stellen Sie für diese Abfrage eine direkte Verbindung zur Hauptdatenbank her. Diese Methode wird nicht empfohlen. Wenn Sie dies tun, geht die Bedeutung der Trennung von Lesen und Schreiben verloren. Aktivieren der parallelen Replikation

Zum Aktivieren der Multithread-Replikation gibt es zwei Standardschlüsselparameter:

mysql> Variablen wie „slave_parallel_%“ anzeigen;
+------------------------+----------+
| Variablenname | Wert |
+------------------------+----------+
| Slave-Paralleltyp | DATENBANK |
| parallele_Sklavenarbeiter | 0 |
+------------------------+----------+
2 Zeilen im Satz (0,00 Sek.)

Der Standardwert des Slave-Parallel-Typs ist Datenbank

Slave-Parallel-Worker Der Standardwert ist 0

Offen:

mysql> Slave-SQL_Thread stoppen;

Abfrage OK, 0 Zeilen betroffen (0,05 Sek.)

mysql> setze globalen Slave-Paralleltyp = 'LOGICAL_CLOCK';

Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)

mysql> setze globale Slave_Parallel_Worker = 4;

Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)

mysql> starte Slave-SQL_Thread;

Abfrage OK, 0 Zeilen betroffen (0,07 Sek.)

Quellen:

https://www.jianshu.com/p/3932551e0221

https://github.com/doocs/advanced-java/blob/master/docs/high-concurrency/mysql-read-write-separation.md

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.