Ein Artikel zum Verständnis der MySQL Master-Slave-Replikation und der Lese-/Schreibtrennung

Einführung

Das Geschäft in einem Unternehmen verfügt normalerweise über eine große Datenmenge, und eine einzelne Datenbank kann die tatsächlichen Anforderungen in Bezug auf Datenspeicherung, Sicherheit und hohe Parallelität nicht erfüllen. Daher ist es erforderlich, mehrere Master-Slave-Datenserver zu konfigurieren, um eine Master-Slave-Replikation zu erreichen, die Datenzuverlässigkeit zu erhöhen, Lese- und Schreibvorgänge zu trennen und den Datenbankdruck sowie die durch die Speicher-Engine verursachten Tabellen- und Zeilensperrprobleme zu verringern.

1. MySQL Master-Slave-Replikation

In einer tatsächlichen Produktionsumgebung werden das Lesen und Schreiben der Datenbank alle auf demselben Datenbankserver durchgeführt, was den tatsächlichen Anforderungen nicht gerecht wird. Ob in puncto Sicherheit, hohe Verfügbarkeit oder hohe Parallelität: Es kann den tatsächlichen Anforderungen überhaupt nicht gerecht werden. Daher werden Daten durch Master-Slave-Replikation synchronisiert und die gleichzeitige Ladekapazität der Datenbank durch Lese- und Schreibtrennung verbessert. Es ist rsync etwas ähnlich, der Unterschied besteht jedoch darin, dass rsync Festplattendateien sichert, während die MySQL-Master-Slave-Replikation Daten und Anweisungen in der Datenbank sichert.

1. MySQL-Replikationstyp

(1) Anweisungsbasierte Replikation (STATEMENT)

Führen Sie SQL-Anweisungen auf dem Server aus und führen Sie dieselben Anweisungen auf dem Slave-Server aus. MySQL verwendet standardmäßig eine anweisungsbasierte Replikation, die eine hohe Ausführungseffizienz aufweist.

(2) Zeilenbasierte Replikation (ROW)

Kopieren Sie die Änderungen, anstatt den Befehl erneut auf dem Slave-Server auszuführen.

(3) Gemischte Hilfeleistungen (MIXED)

Standardmäßig wird die anweisungsbasierte Replikation verwendet. Sobald festgestellt wird, dass die anweisungsbasierte Replikation nicht genau repliziert werden kann, wird die zeilenbasierte Replikation verwendet.

2. Das Prinzip der MySQL Master-Slave-Replikation

(1) Der Masterknoten zeichnet Datenänderungen in einem Binärprotokoll auf. Wenn sich die Daten auf dem Masterknoten ändern, werden die Änderungen in das Binärprotokoll geschrieben.

(2) Der Slave-Knoten erkennt in einem bestimmten Zeitintervall, ob sich das Binärprotokoll des Masters geändert hat. Wenn dies der Fall ist, startet er einen E/A-Thread, um die Binärereignisse des Masters anzufordern.

(3) Gleichzeitig startet der Master-Knoten einen Dump-Thread für jeden I/O-Thread, um ihm binäre Ereignisse zu senden und sie im lokalen Relay-Protokoll des Slave-Knotens zu speichern. Der Slave-Knoten startet den SQL-Thread, um das binäre Protokoll aus dem Relay-Protokoll zu lesen und es lokal wiederzugeben, d. h. es in SQL-Anweisungen zu zerlegen und diese nacheinander auszuführen, um seine Daten mit denen des Master-Knotens in Einklang zu bringen. Schließlich wechseln der I/O-Thread und der SQL-Thread in einen Ruhezustand und warten darauf, beim nächsten Mal geweckt zu werden.

Hinweis: Relay-Protokolle befinden sich normalerweise im Betriebssystem-Cache, daher ist der Overhead durch Relay-Protokolle sehr gering. Der Replikationsprozess weist eine sehr wichtige Einschränkung auf: Die Replikation erfolgt auf dem Slave serialisiert, was bedeutet, dass parallele Aktualisierungsvorgänge auf dem Master nicht parallel auf dem Slave ausgeführt werden können.

3. Verzögerung der MySQL-Master-Slave-Replikation

①Der Masterserver weist eine hohe Parallelität auf, was zu einer großen Anzahl von Transaktionen führt

②Netzwerkverzögerung

③Master-Slave-Hardwaregeräte verursachen

CPU-Hauptfrequenz, Speicher-E/A, Festplatten-E/A

④Es handelt sich nicht um eine synchrone Replikation, sondern um eine asynchrone Replikation

Optimieren Sie Mysql-Parameter aus der Datenbank. Erhöhen Sie beispielsweise innodb_buffer_pool_size, um die Ausführung von mehr Vorgängen im MySQL-Speicher zu ermöglichen und die Anzahl der Festplattenvorgänge zu verringern.

Verwenden Sie Hochleistungshosts für Slave-Bibliotheken. Inklusive leistungsstarker CPU und größerem Speicher. Vermeiden Sie die Verwendung virtueller Cloud-Hosts und verwenden Sie physische Hosts, was die E/A-Leistung verbessert.

SSD-Festplatten aus der Bibliothek verwenden

Netzwerkoptimierung zur Vermeidung der Synchronisierung über mehrere Rechnerräume hinweg

2. MySQL-Lese-/Schreibtrennung

Das Grundprinzip der Lese- und Schreibtrennung besteht darin, dass die Masterdatenbank transaktionale Hinzufügungs-, Änderungs- und Löschvorgänge (INSERT, UPDATE, DELETE) verarbeitet, während die Slavedatenbank SELECT-Abfragevorgänge verarbeitet. Mithilfe der Datenbankreplikation werden durch Transaktionsvorgänge verursachte Änderungen an Slave-Datenbanken im Cluster synchronisiert.

Die Datenbank muss nicht zwangsläufig in Lesen und Schreiben getrennt werden. Wenn das Programm die Datenbank häufiger nutzt, dabei aber weniger Aktualisierungen und mehr Abfragen anfallen, wird sie für die Nutzung in Betracht gezogen. Durch die Verwendung der Master-Slave-Synchronisierung und der Lese-/Schreibtrennung der Datenbank kann der Datenbankdruck verteilt und die Leistung verbessert werden.

1. Allgemeine MySQL-Lese-/Schreibtrennung

(1) Basierend auf der internen Implementierung des Programmcodes

Im Code werden Routen nach Select und Insert klassifiziert. Diese Methode wird auch in Produktionsumgebungen am häufigsten verwendet. Der Vorteil besteht in der besseren Leistung, da die Implementierung im Programmcode erfolgt und keine zusätzlichen Gerätekosten in Form von Hardware verursacht. Der Nachteil besteht darin, dass die Implementierung von Entwicklern durchgeführt werden muss und das Betriebs- und Wartungspersonal keine Ahnung hat, wo es anfangen soll. Allerdings sind nicht alle Anwendungen für die Implementierung einer Lese-/Schreibtrennung im Programmcode geeignet. Bei einigen großen und komplexen Java-Anwendungen sind beispielsweise erhebliche Codeänderungen erforderlich, um eine Lese-/Schreibtrennung im Programmcode zu implementieren.

(2) Implementierung basierend auf der Zwischenproxyschicht

Der Proxy befindet sich normalerweise zwischen dem Client und dem Server. Nach Erhalt der Clientanforderung leitet der Proxyserver diese nach Beurteilung an die Backend-Datenbank weiter. Im Folgenden sind repräsentative Programme aufgeführt.

①MySQL-Proxy. MySQL-Proxy ist ein MySQL-Open-Source-Projekt, das sein eigenes Lua-Skript zur SQL-Beurteilung verwendet.

②Atlas. Es handelt sich um ein Daten-Middle-Tier-Projekt basierend auf dem MySQL-Protokoll, das vom Infrastrukturteam der Webplattform-Abteilung von Qihoo 360 entwickelt und gepflegt wird. Es basiert auf MySQL-Proxy Version 0.8.2, optimiert diese und fügt einige neue Funktionen hinzu. 360 verwendet Atlas, um MySQL-Geschäfte intern auszuführen, und die Anzahl der Lese- und Schreibanforderungen, die täglich darüber abgewickelt werden, liegt bei Milliarden. Unterstützt Transaktionen und gespeicherte Prozeduren.

③Amöbe. Entwickelt von Chen Siru, der Autor arbeitete früher bei Alibaba. Das Programm wurde in der Programmiersprache Java entwickelt und wird von Alibaba in der Produktionsumgebung verwendet. Transaktionen und gespeicherte Prozeduren werden jedoch nicht unterstützt.

Da die Verwendung von MySQL Proxy das Schreiben einer großen Anzahl von Lua-Skripten erfordert, sind diese Lua-Skripte nicht vorgefertigt und müssen von Ihnen selbst geschrieben werden. Dies ist sehr schwierig für Personen, die mit den integrierten Variablen des MySQL-Proxys und dem MySQL-Protokoll nicht vertraut sind. Amoeba ist eine sehr einfach zu verwendende und äußerst portable Software. Daher wird es in Produktionsumgebungen häufig in der Datenbank-Proxy-Schicht verwendet.

2. MySQL-Prinzip der Lese- und Schreibtrennung

Lese-/Schreibtrennung bedeutet, dass nur auf dem Master-Server geschrieben und nur auf dem Slave-Server gelesen wird. Das Grundprinzip besteht darin, die Transaktionsvorgänge von der Master-Datenbank abwickeln zu lassen, während die Slave-Datenbank ausgewählte Abfragen verarbeitet. Mithilfe der Datenbankreplikation werden Änderungen, die sich aus Transaktionsvorgängen in einer Masterdatenbank ergeben, mit Slavedatenbanken in einem Cluster synchronisiert.

3. Konfigurationsschritte für die MySQL-Master-Slave-Replikation und die Trennung von Lesen und Schreiben

1. Bauen Sie die Umgebung auf

2. Die Bedürfnisse erfüllen

Der Client greift auf den Proxyserver zu. Der Proxyserver schreibt auf den Masterserver. Der Masterserver schreibt Hinzufügungen, Löschungen und Änderungen in sein eigenes Binärprotokoll. Der Slaveserver synchronisiert das Binärprotokoll des Masterservers mit seinem eigenen Relay-Protokoll. Der Slaveserver spielt das Relay-Protokoll in die Datenbank ein. Wenn der Client liest, greift der Proxyserver direkt auf den Slaveserver zu. Dies reduziert die Last und trägt zum Lastenausgleich bei.

3. Vorbereitungsphase (Schließen der Firewall und Kontrolle des Zugriffsmechanismus)

[root@localhost ~]# systemctl stoppe Firewall
[root@localhost ~]# systemctl Firewall deaktivieren
[root@localhost ~]# setenforce 0

4. Erstellen Sie eine MySQL-Master-Slave-Replikation

(1) Konfigurationsschritte zur Zeitsynchronisierung des MySQL-Master-Slave-Servers

①Konfiguration des Masterservers (192.168.32.128)

[root@localhost ~]# yum -y install ntp #NTP installieren
[root@localhost ~]# vim /etc/ntp.conf #ntp konfigurieren
#Fügen Sie in Zeile 25 den folgenden Inhalt hinzu: Server 127.127.32.0 #Legen Sie den lokalen Server als Taktquelle fest und achten Sie darauf, das Netzwerksegment Fudge 127.127.32.0 Stratum 8 zu ändern. #Stellen Sie die Zeitstufe auf 8 ein (begrenzt auf 15).
[root@localhost ~]# systemctl restart ntpd #NTP-Dienst neu starten②Konfiguration von Slave1-Server (192.168.32.133) und Slave2-Server (192.168.32.134)[root@localhost ~]# yum -y install ntp ntpdate #Dienst installieren, ntpdate wird zum Synchronisieren der Zeit verwendet[root@localhost ~]# systemctl start ntpd #Dienst starten[root@localhost ~]# /usr/sbin/ntpdate 192.168.32.128 #Zeitsynchronisierung durchführen, auf die IP des Master-Servers zeigen
[root@localhost ~]# crontab -e
*/30 * * * * /usr/sbin/ntpdate 192.168.32.128 #Schreiben Sie eine geplante Aufgabe, um die Zeit jede halbe Stunde zu synchronisieren

(2) Konfigurieren Sie den Master-Server (192.168.32.128)

[root@localhost ~]# vim /etc/my.cnf
server-id = 1 #Beachten Sie, dass die ID nicht dieselbe sein darf log-bin=master-bin #Hinzufügen, der Master-Server öffnet das Binärprotokoll log-slave-updates=true #Hinzufügen, dem Slave-Server erlauben, das Binärprotokoll zu aktualisieren [root@localhost ~]# systemctl restart mysqld #Starten Sie den Dienst neu, damit die Konfiguration wirksam wird [root@localhost ~]# mysql -uroot -p123456 #Melden Sie sich beim Datenbankprogramm an mysql> grant replication slave on *.* to 'myslave'@'192.168.32.%' identifiert by '123456'; #Autorisieren Sie den Slave-Server mysql> flush permissions;
mysql> show master status; #Die Spalte „File“ zeigt den Protokollnamen und die Spalte „Fosition“ den Offset 

(3) Konfiguration des Slave1-Servers (192.168.32.133) und des Slave2-Servers (192.168.32.134)

①Slave1-Serverkonfiguration (192.168.32.133)

[root@localhost ~]# vim /etc/my.cnf
server-id = 2 #Ändern, beachten Sie, dass die ID sich von der des Masters unterscheidet und die IDs der beiden Slaves ebenfalls unterschiedlich sein müssen relay-log=relay-log-bin #Hinzufügen, Relay-Protokoll aktivieren und Protokolldateidatensätze vom Master-Server mit dem lokalen synchronisieren relay-log-index=slave-relay-bin.index #Hinzufügen, Speicherort und Namen der Relay-Protokolldatei definierenmysql> ändern Sie Master in master_host='192.168.32.128',master_user='myslave',master_password='123456',master_log_file='master-bin.000001',master_log_pos=603; #Synchronisierung konfigurieren, beachten Sie, dass die Werte von master_log_file und master_log_pos mit denen des Masters übereinstimmen müssenmysql> starten Sie Slave; #Synchronisierung starten, wenn ein Fehler auftritt, führen Sie „Slave zurücksetzen“ aus;
mysql> show slave status\G #Überprüfen Sie den Slave-Status (stellen Sie sicher, dass sowohl IO- als auch SQL-Threads „Ja“ sind, was auf eine normale Synchronisierung hinweist)
Slave_IO_Running: Ja #Verantwortlich für die E/A-Kommunikation mit dem Host Slave_SQL_Running: Ja #Verantwortlich für den eigenen Slave-MySQL-Prozess 

②Slave2-Serverkonfiguration (192.168.32.134)

[root@localhost ~]# vim /etc/my.cnf
server-id = 3 #Ändern, beachten Sie, dass die ID sich von der des Masters unterscheidet und die IDs der beiden Slaves ebenfalls unterschiedlich sein müssen relay-log=relay-log-bin #Hinzufügen, Relay-Protokoll aktivieren und Protokolldateidatensätze vom Master-Server mit dem lokalen synchronisieren relay-log-index=slave-relay-bin.index #Hinzufügen, Speicherort und Namen der Relay-Protokolldatei definierenmysql> ändern Sie Master in master_host='192.168.32.128',master_user='myslave',master_password='123456',master_log_file='master-bin.000001',master_log_pos=603; #Synchronisierung konfigurieren, beachten Sie, dass die Werte von master_log_file und master_log_pos mit denen des Masters übereinstimmen müssenmysql> starten Sie Slave; #Synchronisierung starten, wenn ein Fehler auftritt, führen Sie „Slave zurücksetzen“ aus;
mysql> show slave status\G #Überprüfen Sie den Slave-Status (stellen Sie sicher, dass sowohl IO- als auch SQL-Threads „Ja“ sind, was auf eine normale Synchronisierung hinweist)
Slave_IO_Running: Ja #Verantwortlich für die E/A-Kommunikation mit dem Host Slave_SQL_Running: Ja #Verantwortlich für den eigenen Slave-MySQL-Prozess 

Die möglichen Gründe für „Slave_IO_Running: Nein“ sind: Das Netzwerk ist nicht verbunden; es gibt ein Problem mit der my.cnf-Konfiguration; das Kennwort, der Dateiname und der POS-Offset sind falsch; die Firewall ist nicht ausgeschaltet.

(4) Überprüfen Sie den Master-Slave-Replikationseffekt

① Führen Sie die Ausführung auf dem primären Server aus und erstellen Sie eine Datenbank mit dem Namen „mysql01“.

②Von zwei Servern aus verifizieren

5. Schritte zum Erstellen einer MySQL-Lese-/Schreibtrennung

Diese Software ist speziell für die verteilte Datenbank-Frontend-Proxy-Schicht von MySQL gedacht. Sie fungiert hauptsächlich als SQL-Routing, wenn die Anwendungsschicht auf MySQL zugreift, und verfügt über Lastausgleich, hohe Verfügbarkeit, SQL-Filterung, Lese-/Schreibtrennung, Routing zur Zieldatenbank und gleichzeitige Anfragen an mehrere Datenbanken. Durch Amoeba kann sie die Funktionen der hohen Verfügbarkeit, des Lastausgleichs und der Datenaufteilung mehrerer Datenquellen erfüllen.

(1) Konfigurieren Sie den Amoeba-Server und installieren Sie die Java-Umgebung (da Amoeba auf Basis von jdk1.5 entwickelt wurde, wird offiziell die Verwendung von jdk1.5 oder 1.6 empfohlen, höhere Versionen werden nicht empfohlen).

[root@localhost ~]# cd /opt/
[root@localhost opt]# ls
amoeba-mysql-binary-2.2.0.tar.gz jdk-6u14-linux-x64.bin
[root@localhost opt]# cp jdk-6u14-linux-x64.bin /usr/local/
[root@localhost opt]# cd /usr/local/
[root@localhost lokal]# chmod +x jdk-6u14-linux-x64.bin
: : : : : : : : : : : : : : : 

(2) Installieren und konfigurieren Sie Amoeba

[root@localhost ~]# mkdir /usr/local/amoeba
[root@localhost ~]# tar zxvf /opt/amoeba-mysql-binary-2.2.0.tar.gz -C /usr/local/amoeba/
[root@localhost ~]# chmod -R 755 /usr/local/amoeba/
[root@localhost ~]# /usr/local/amoeba/bin/amoeba #Die Anzeige von amoeba start|stop zeigt eine erfolgreiche Installation an

(3) Konfigurieren Sie die Lese-/Schreibtrennung des Amowba-Servers und zwei Slaves, um die Lese- und Schreiblast auszugleichen

① Öffnen Sie zunächst die Berechtigungen für MySQL von Master, Slave1 und Slave2, damit Amoeba darauf zugreifen kann.

Der Master-Server (192.168.32.128), der Slave1-Server (192.168.32.133) und der Slave2-Server (192.168.32.134) sind alle konfiguriert:

mysql> gewähre alles auf *.* an test@'192.168.32.%', identifiziert durch '123.com';

②Bearbeiten Sie die Konfigurationsdatei amoeba.xml im Amoeba-Server

[root@localhost ~]# cd /usr/local/amoeba/conf/
[root@localhost conf]# cp amoeba.xml amoeba.xml.bak #Backup [root@localhost conf]# vim amoeba.xml #Amoeba-Konfigurationsdatei ändern #30 zu ändernde Zeilen <property name="user">amoeba</property>
#Ändern Sie Zeile 32 <property name="password">123123</property>
#115 Zeilenänderung <property name="defaultPool">master</property>
#117 Entfernen Sie den Kommentar <property name="writePool">master</property>
<Eigenschaftsname="readPool">Sklaven</Eigenschaft>

③Bearbeiten Sie die Konfigurationsdatei dbServers.xml

[root@localhost conf]# cp dbServers.xml dbServers.xml.bak #Backup [root@localhost conf]# vim dbServers.xml #Datenbankkonfigurationsdatei ändern #23 Zeile auskommentieren Wirkung: Geben Sie standardmäßig die Testbibliothek ein. Falls in MySQL keine Testbibliothek vorhanden ist, wird ein Fehler gemeldet. <!-- <property name="schema">test</property> -->
#26 Zeilenänderung <property name="user">test</property>
#Entfernen Sie die Kommentarzeichen aus den Zeilen 28-30<!-- mysql password -->
<property name="password">123.com</property>
#Ändern Sie Zeile 45 und setzen Sie den Namen des Masterservers auf Master
<dbServer name="master" parent="abstractServer">
#Ändern Sie Zeile 48 und legen Sie die Adresse des primären Servers fest <property name="ipAddress">192.168.32.128</property>
#Ändern Sie Zeile 52 und setzen Sie den Namen des Slave-Servers auf Slave1
<dbServer name="slave1" parent="abstractServer">
#Ändern Sie Zeile 55 und legen Sie die Adresse des Slave-Servers 1 fest <property name="ipAddress">192.168.132.133</property>
#58 Kopieren und fügen Sie die obigen 6 Zeilen ein, um den Namen und die Adresse des Slave-Servers 2 festzulegen <dbServer name="slave2" parent="abstractServer">
<Eigenschaftsname="IP-Adresse">192.168.32.134</Eigenschaft>
#65 Zeilenänderung <dbServer name="slaves" virtual="true">
#71 Ändern Sie <property name="poolNames">slave1,slave2</property>

④Nachdem Sie bestätigt haben, dass die Konfiguration korrekt ist, können Sie die Amoeba-Software starten. Der Standardport ist TCP 8066

[root@localhost conf]# /usr/local/amoeba/bin/amoeba start &

[root@localhost conf]# netstat -antulp | grep 8066

6. Testen Sie die Lese-/Schreibtrennung

(1) Client-Konfiguration

[root@localhost ~]# yum install -y mariadb-server mariadb #Verwenden Sie YUM, um den virtuellen MySQL-Client schnell zu installieren [root@localhost ~]# systemctl start mariadb.service
[root@localhost ~]# mysql -u amoeba -p123456 -h 192.168.32.135 -P8066 #Greifen Sie über den Amoeba-Server-Proxy auf MySQL zu. Nachdem Sie über den Client eine Verbindung zu MySQL hergestellt haben, werden die geschriebenen Daten nur vom Master-Dienst aufgezeichnet und dann mit dem Slave-Slave-Server synchronisiert

(2) Erstellen Sie eine Tabelle auf dem Master-Server und synchronisieren Sie sie mit den beiden Slave-Servern

mysql> verwende xm;
mysql> Tabelle erstellen Test (ID int(10),Name varchar(10),Adresse varchar(20));

(3) Schalten Sie dann die Slave-Funktion des Slave-Servers aus, synchronisieren Sie die Tabelle vom Master-Server und fügen Sie den Dateninhalt manuell ein

mysql> stop slave; #Synchronisierung schließenmysql> use xm;

①Auf Slave1 konfigurieren

mysql> in Testwerte einfügen('1','zhangsan','this_is_slave1');

②Auf Slave2 konfigurieren

mysql> in Testwerte einfügen('2','lisi','this_is_slave2');

(4) Kehren Sie zum Hauptserver zurück und fügen Sie weitere Inhalte ein

mysql> in Testwerte einfügen('3','wangwu','this_is_master');

(5) Testen Sie den Lesevorgang und gehen Sie zum Client-Host, um die Ergebnisse abzufragen

mysql> verwende xm;
mysql> select * from test; #Der Client liest jeweils Daten von Slave1 und Slave2 und zeigt nur die auf den beiden Slave-Servern hinzugefügten Daten an, nicht die auf dem Master-Server hinzugefügten Daten.

(6) Auf dem Client wird eine Anweisung eingefügt, die jedoch auf dem Client nicht abgefragt werden kann. Schließlich kann der Inhalt dieser Anweisung nur auf dem Master angezeigt werden, was darauf hinweist, dass der Schreibvorgang auf dem Master-Server erfolgt.

mysql>insert into test values('4','kanglong','this_is_client'); #Diese Daten sind nur auf dem primären Server verfügbar

(7) Führen Sie „Start Slave“ auf beiden Slave-Servern aus, um die auf dem Master-Server hinzugefügten Daten zu synchronisieren.

mysql> Slave starten;

Zusammenfassen

1. Das Prinzip der Master-Slave-Replikation: Der Masterserver fügt Daten hinzu, löscht, ändert und aktualisiert sie und schreibt sie nach dem Festschreiben der Transaktion in die Binärdatei. Der E/A-Thread des Slave-Servers fordert die Erkennung der Binärdatei des Master-Servers an. Wenn neue Daten vorhanden sind, verwendet der Master-Server den Dump-Thread, um die Binärdatei an den Speicher des E/A-Threads des Slave-Dienstes zu senden und in das Relay-Protokoll zu schreiben. Der SQL-Thread überwacht die Relay-Protokolldatei, liest die Relay-Protokolldatei, wenn neue Daten vorhanden sind, und spielt die Daten in die Datenbank des Slave-Servers zurück.

2. Der Arbeitsprozess der Master-Slave-Replikation basiert auf Protokollen: Master-Binärprotokoll und Slave-Relay-Protokoll; Anforderungsmethode: E/A-Thread, Dump-Thread, SQL-Thread.

3. Lese-/Schreibtrennung bedeutet, dass nur auf dem Master-Server geschrieben und nur auf dem Slave-Server gelesen wird.

Dies ist das Ende dieses Artikels über MySQL-Master-Slave-Replikation und Lese-/Schreibtrennung. Weitere relevante Inhalte zu MySQL-Master-Slave-Replikation und Lese-/Schreibtrennung finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!