Detaillierte Erläuterung der MySQL Master-Slave-Replikation und der Lese-/Schreibtrennung

Vorwort

In tatsächlichen Unternehmensanwendungen verfügen reife Unternehmen normalerweise über große Datenmengen, und ein einzelner MySQL-Server kann die tatsächlichen Anforderungen in Bezug auf Sicherheit, hohe Verfügbarkeit und hohe Parallelität nicht erfüllen. Wir können die Master-Slave-Replikation auf mehreren MySQL-Servern (Master-Slave) bereitstellen, um Daten zu synchronisieren, und dann die gleichzeitige Ladekapazität der Datenbank durch Lese- und Schreibtrennung verbessern. 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. Übersicht

Master-Slave-Replikation: Die Master-Datenbank (Master) sendet Aktualisierungsereignisse an die Slave-Datenbank (Slave), die die Aktualisierungsdatensätze liest und ausführt, um den Inhalt der Slave-Datenbank mit der Master-Datenbank konsistent zu halten.

1. Von MySQL unterstützte Replikationstypen

• Anweisungsbasierte Replikation (STATEMENT). Die auf der Masterdatenbank ausgeführte SQL-Anweisung führt dieselbe Anweisung auf der Slavedatenbank aus. MySQL verwendet standardmäßig die anweisungsbasierte Replikation, die effizienter ist.
• Zeilenbasierte Replikation (ROW). Kopieren Sie den geänderten Inhalt, anstatt den Befehl in der Slave-Bibliothek auszuführen.
• Replikation gemischter Typen (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.

(II) Arbeitsweise der MySQL Master-Slave-Replikation

1. Der Master-Server speichert Datensätze im Binärprotokoll

• Die Datenaktualisierungen, die in der MySQL-Masterdatenbank hinzugefügt, gelöscht und geändert werden, werden in ihre eigene Im Binärprotokoll

2. Der Slave-Server kopiert das Protokoll des Master-Servers

• Anschließend startet MySQL eine Der I/O-Thread stellt eine Verbindung zur Hauptdatenbank her und liest die Hauptdatenbank Das Binärprotokoll wird im Relay-Protokoll des Slave-Servers gesichert. Wenn es den Master eingeholt hat, wird es in den Ruhezustand versetzt und wartet darauf, dass der Master neue Ereignisse generiert. Der E/A-Thread schreibt diese Ereignisse dann in das Relay-Protokoll.

3. Der Slave-Server spielt die kopierten Protokolle erneut ab

• Öffnen Sie dann die Bibliothek SQL-Thread, SQL-Thread liest vom I/O-Thread geschriebene Daten Relay-Protokoll, und aktualisieren Sie die Slave-Datenbankdaten entsprechend dem Inhalt des Relay-Protokolls, um sie mit den Daten in der Master-Datenbank in Einklang zu bringen

Wichtig: 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.

2. Lese- und Schreibtrennung

(1) Das Konzept der Lese- und Schreibtrennung

Lese-/Schreibtrennung: Lese-/Schreibtrennung bedeutet, dass auf dem Master-Server nur geschrieben und auf dem Slave-Server nur gelesen wird. Das Grundprinzip besteht darin, dass die Master-Datenbank die transaktionalen Hinzufügungs-, Änderungs- und Löschvorgänge (INSERT, UPDATE, DELETE) handhabt, während die Slave-Datenbank die SELECT-Abfragevorgänge handhabt. Mithilfe der Datenbankreplikation werden durch Transaktionsvorgänge verursachte Änderungen an Slave-Datenbanken im Cluster synchronisiert.

(2) Die Rolle der Lese- und Schreibtrennung

• Weil der „Schreib“-Vorgang der Datenbank (das Schreiben von 10.000 Daten kann 3 Minuten dauern) zeitaufwändig ist. Aber das „Lesen“ der Datenbank (das Lesen von 10.000 Datensätzen) dauert möglicherweise nur 5 Sekunden.
• Daher löst die Trennung von Lesen und Schreiben das Problem, dass das Schreiben in die Datenbank die Effizienz von Abfragen beeinträchtigt. Hinweis: 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.

(3) 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, dass die Master-Datenbank die Transaktionsabfragen verarbeitet, während die Slave-Datenbank ausgewählte Abfragen verarbeitet.
• Mithilfe der Datenbankreplikation werden durch Transaktionsabfragen verursachte Änderungen an der Masterdatenbank mit den Slavedatenbanken im Cluster synchronisiert.

(4) Allgemeine MySQL-Lese-/Schreibtrennung

1) Basierend auf der internen Implementierung des Programmcodes

1. Routen nach Auswahl und Einfügen im Code klassifizieren. Diese Methode wird auch in Produktionsumgebungen am häufigsten verwendet.

2. Vorteile und Nachteile:

• Der Vorteil liegt in einer besseren Performance, da die Implementierung im Programmcode erfolgt und kein zusätzlicher Hardwareaufwand nötig ist;
• Der Nachteil besteht darin, dass für die Implementierung Entwickler erforderlich sind und das Betriebs- und Wartungspersonal keine Ahnung hat, wo es anfangen soll.

3. Nicht alle Anwendungen eignen sich für die Implementierung einer Lese-/Schreibtrennung im Programmcode. Bei einigen großen und komplexen Java-Anwendungen beispielsweise erfordert die Implementierung einer Lese-/Schreibtrennung im Programmcode erhebliche Codeänderungen.

2) Implementierung basierend auf der Zwischenproxyschicht

1. Der Proxy befindet sich normalerweise zwischen dem Client und dem Server. Nach dem Empfang der Clientanforderung leitet der Proxyserver diese nach der Beurteilung an die Backend-Datenbank weiter. Die folgenden Programme sind repräsentativ:

• MySQL-Proxy: MySQL-Proxy ist ein MySQL-Open-Source-Projekt, das sein eigenes Lua-Skript zur SQL-Beurteilung verwendet.
• Atlas: Dies ist 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.
• Amoeba: Entwickelt von Chen Siru, der früher bei Alibaba gearbeitet hat. 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.
  

2. Da für die Verwendung von MySQL Proxy eine große Anzahl von Lua-Skripten geschrieben werden muss, 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 von MySQL Proxy und dem MySQL-Protokoll nicht vertraut sind.

3.Amoeba ist eine sehr benutzerfreundliche und äußerst portable Software und wird daher in Produktionsumgebungen häufig als Proxy-Schicht der Datenbank verwendet.

3. Experimentelle Bereitstellung der MySQL Master-Slave-Replikation

Erforderliches zugehöriges Softwarepaket
amöbe-mysql-binär-2.2.0.tar.gz
jdk-6u14-linux-x64.bin
MySQL komprimiertes Paket

(1) Experimentelle Schritte und Vorbereitung zur Master-Slave-Replikation

Experimentelle Schritte Schritt 1: Client-Client greift auf Proxy-Server-Amöbe zu
Schritt 2: Der Proxyserver liest und schreibt die Daten Schreiboperation: Schreiben auf den Masterserver Schritt 3: Der Masterserver schreibt die Hinzufügungen, Löschungen und Änderungen in sein eigenes Binärprotokoll Schritt 4: Der Slave-Server synchronisiert das Binärprotokoll des Masterservers mit seinem eigenen Relay-Protokoll Schritt 5: Der Slave-Server spielt das Relay-Protokoll in die Datenbank zurück Leseoperation: Direkter Zugriff auf den Slave-Server Endergebnis: Reduziert die Last und übernimmt eine Lastausgleichsfunktion IP-Adresse des Host-Betriebssystems Erforderliche Tools/Software/Installationspakete

1. Firewall und Sicherheitsmechanismen ausschalten

Alle vier Server müssen heruntergefahren werden

systemctl stoppe Firewall
systemctl deaktiviert Firewall
0

2. Installieren Sie den Zeitsynchronisationsdienst ntp

(1) Primärserver

yum -y installiere NTP

vim /etc/ntp.conf
##---------Am Ende hinzufügen---------
Server 127.127.71.0 #Stellen Sie die lokale Taktquelle ein und achten Sie darauf, das Netzwerksegment Fudge 127.127.71.0 Stratum 8 zu ändern. #Stellen Sie die Zeitstufe auf 8 ein (begrenzt auf 15).

Dienst ntpd starten

(2) Zwei Slave-Server

yum -y installiere NTP ntpdate

Dienst ntpd starten

/usr/sbin/ntpdate 192.168.71.12 #Zeitsynchronisierung, zeigt auf die IP des Masterservers

crontab -e #Stellen Sie die geplante Aufgabe so ein, dass die Zeit alle halbe Stunde synchronisiert wird */30 * * * * /usr/sbin/ntpdate 192.168.71.12

3. MySQL-Konfiguration des Hauptservers

vim /etc/meine.cnf
Server-ID = 1
log-bin=master-bin #Hinzufügen, Master-Server öffnet Binärprotokoll log-slave-updates=true #Hinzufügen, Slave-Server erlauben, Binärprotokoll zu aktualisieren systemctl restart mysqld

mysql -u root -p
Gewähren Sie Replikations-Slave auf *.* an „myslave“@„192.168.71.%“, gekennzeichnet durch „123“. #Erhöhen Sie die Berechtigungen für den Slave-Server. #Erteilen Sie Autorisierung. #Replikationsreplikation #Erlauben Sie dem Netzwerksegment 192.168.71, das Kennwort 123 zum Replizieren aller Tabellen und Bibliotheken zu verwenden. Berechtigungen zum Leeren.

Masterstatus anzeigen;
#Die Spalte „Datei“ zeigt den Protokollnamen und die Spalte „Position“ den Offset 

4. MySQL-Konfiguration vom Server

Slave1-Server: 192.168.163.13
Slave2-Server: 192.168.163.14

1) Ändern Sie die Konfigurationsdatei

vim /etc/meine.cnf
#Ändern, beachten Sie, dass die ID sich von der des Masters unterscheidet und die IDs der beiden Slaves ebenfalls unterschiedlich sein müssen Server-ID = 2

#Relay-Log hinzufügen, öffnen, Logdateien vom Master-Server mit dem lokalen Relay-Log synchronisieren=Relay-Log-Bin

#Hinzufügen, Speicherort und Namen der Relay-Protokolldatei definieren relay-log-index=slave-relay-bin.index

systemctl startet mysqld neu

Sklave1

Sklave2

2) Bedienen der Datenbank vom Server aus

mysql -u root -p123
Ändern Sie den Master in master_host = '192.168.71.12', master_user = 'myslave', master_password = '123', master_log_file = 'master-bin.000002', master_log_pos = 306; #Masterstatus anzeigen; Die ausgegebene Binärdatei entspricht dem Positionspunkt. #Synchronisierung konfigurieren. Beachten Sie, dass die Werte von master_log_file und master_log_pos mit der Master-Abfrage übereinstimmen müssen.	 
Slave starten; #Synchronisierung starten, bei einem Fehler „Slave zurücksetzen“ ausführen;
show slave status\G; #Überprüfen Sie den Slave-Status // Stellen Sie sicher, dass sowohl der IO- als auch der SQL-Thread „Ja“ sind, was darauf hinweist, dass die Synchronisierung normal ist.
Slave_IO_Running:Yes #Verantwortlich für die E/A-Kommunikation mit dem Host Slave_SQL_Running:Yes #Verantwortlich für den eigenen Slave-MySQL-Prozess 

5. Überprüfen Sie die Ergebnisse

Erstellen Sie eine Bibliothek auf dem Master-Server und zeigen Sie sie auf dem Slave-Server an

4. MySQL-Lese-/Schreibtrennungsexperiment

Amoeba-Server (192.168.153.30)
Installieren Sie die Java-Umgebung. Da Amoeba auf Basis von jdk1.5 entwickelt wurde, wird offiziell empfohlen, jdk1.5 oder 1.6 zu verwenden. Höhere Versionen werden nicht empfohlen.

1) Erstellen Sie eine JDK-Java-Umgebung

cd /opt/
#Laden Sie jdk-6u14-linux-x64.bin und amoeba-mysql-binary-2.2.0.tar.gz in das Verzeichnis /opt hoch. cp jdk-6u14-linux-x64.bin /usr/local/
cd /usr/lokal/
chmod +x jdk-6u14-linux-x64.bin
./jdk-6u14-linux-x64.bin
//Drücken Sie „Ja“, drücken Sie die Eingabetaste

mv jdk1.6.0_14/ /usr/1ocal/jdk1.6

vim /etc/profil
exportiere JAVA_HOME=/usr/local/jdk1.6
export CLASSPATH=SCLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
export PATH=$JAVA_HOME/lib:$JAVA_HOME/jre/bin/:$PATH:$HOME/bin
export AMOEBA_HOME=/usr/local/amoeba
export PATH=$PATH:$AMOEBA_HOME/bin

Quelle /etc/Profil
Java-Version

2) Installieren Sie die Amoeba-Software

mkdir /usr/local/amoeba
tar zxvf /opt/amoeba-mysql-binary-2.2.0.tar.gz -C /usr/local/amoeba/
chmod -R 755 /usr/local/amoeba/
/usr/local/amoeba/bin/amoeba
//Wenn amoeba start|stop angezeigt wird, bedeutet dies, dass die Installation erfolgreich war 

3) Autorisierung auf dem MySQL des Master- und Slave-Servers

Master-Server: 192.168.71.12
Slave1-Server: 192.168.71.13
Slave2-Server: 192.168.71.14

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

gewähre alles auf *.* an „test“@„192.168.163.%“, identifiziert durch „abc123“; 

4) Konfigurieren Sie den Amöbendienst auf der Amöbe

cd /usr/local/amoeba/conf/

cp amoeba.xml amoeba.xml.bak #Sichern Sie die Konfigurationsdatei vim amoeba.xml #Ändern Sie die Amoeba-Konfigurationsdatei <property name="user">amoeba</property> #Ändern Sie Zeile 30 <property name="password">abc123</property> #Ändern Sie das Kennwort für den Client, um eine Verbindung zum Amoeba-Server herzustellen, in Zeile 32 <property.name="defaultPool">master</property> #Ändern Sie den Standardpool in Zeile 115 <property name="writePool">master</property> #Entfernen Sie die Kommentare in Zeile 117 und legen Sie den Master als Schreibpool fest <property name="readPool">slaves</property> #Slaves als Lesepool 

cp dbServers.xml dbServers.xml.bak
vim dbServers.xml #Ändern Sie die Datenbankkonfigurationsdatei<!-- <property name="schema"> test</property> --> #Zeile 23, kommentieren Sie den Zweck aus: Rufen Sie standardmäßig die Testbibliothek auf. Falls in MySQL keine Testbibliothek vorhanden ist, wird ein Fehler gemeldet<property name="user">test</property> #Zeile 26, ändern Sie den Benutzer und das Kennwort für die Berechtigungsausweitung auf den Master- und Slave-Servern<property.name-"password">123</property> #Zeilen 28-30, entfernen Sie die Kommentare<dbServer name= "master" parent="abstractServer"> #Zeile 45, ändern Sie, setzen Sie den Namen des Masterservers auf Master

<property name= "ipAddress">192.168.71.12</property> #48 Zeile, ändern, Adresse des Master-Servers festlegen <dbServer name="slave1" parent="abstractServer"> #52 Zeile, ändern, Name des Slave-Servers festlegen slave1

<property.name="ipAddress">192.168.71.13</property> Zeile Nr. 55, ändern, Adresse des Slave-Servers 1 festlegen <dbServer name="slave2 " parent="abstractserver"> Zeile Nr. 59, die obigen 6 Zeilen kopieren und einfügen, Name und Adresse des Slave-Servers 2 festlegen slave2 <property, name="ipAddress">192.168.71.14</property>

<dbServer name="slaves" virtual="true"> #65 Zeile, ändern Sie <property name="poolNames">slave1,slave2</property> #71 Zeile, ändern Sie /usr/local/amoeba/bin/amoeba start& #Starten Sie die Amoeba-Software, drücken Sie Strg+C, um zurückzukehren netstat -anpt | grep java #Überprüfen Sie, ob Port 8066 geöffnet ist, der Standardport ist TCP 8066

5) Testen Sie die Lese-/Schreibtrennung

Testen auf dem Client-Server

yum install -y mysql mysql-server #Installieren Sie MySQL schnell, oder Sie können mysql -u amoeba -pabc123 -h 192.168.71.20 -P8066 kompilieren und installieren. 

Diese Tabelle ist sowohl auf dem Master- als auch auf dem Slave-Server sichtbar.

Greifen Sie über den Amoeba-Server-Proxy auf MySQL zu. Nach der Verbindung mit MySQL über den Client werden die geschriebenen Daten nur vom Master-Dienst aufgezeichnet und dann mit dem Slave-Server synchronisiert.

Slave stoppen; #Synchronisiertes Schreiben von Daten schließen, Schule verwenden;
//Auf Slave1:
in Test1 Werte einfügen('1','Slave1');

//Auf Slave2:
in Test1 Werte einfügen('2','Slave2');

Einfügen von Daten auf dem primären Server

in test1 Werte einfügen('3','Master');

Einfügen von Daten in die Tabelle im Client

//Auf dem Client-Server:
Schule benutzen;
select * from test1; //Der Client liest die Daten jeweils von slave1 und s1ave2 und zeigt nur die auf den beiden Slave-Servern hinzugefügten Daten an. Auf dem Master-Server hinzugefügte Daten werden nicht angezeigt. insert into test1 values('4','climet'); //Diese Daten sind nur auf dem Master-Server verfügbar. 

Daten auf dem primären Server anzeigen

Starten Sie zwei Slave-Server gleichzeitig und zeigen Sie die Tabellendatensätze an

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!