MySQL InnoDB Cluster besteht aus 3 Komponenten:
- MySQL-Gruppenreplikation (eine Gruppe von Datenbankservern, die sich gegenseitig mit Fehlertoleranz replizieren).
- MySQL Router (Abfragerouter zu den fehlerfreien Datenbankknoten)
- MySQL Shell (Hilfsprogramm, Client, Konfigurationstool)
Im ersten Teil dieser exemplarischen Vorgehensweise werden wir einen MySQL InnoDB-Cluster bereitstellen. Es gibt eine Reihe von praktischen Tutorials, die online verfügbar sind, aber diese exemplarische Vorgehensweise behandelt alle notwendigen Schritte/Befehle, um den Cluster an einem Ort zu installieren und auszuführen. Im zweiten Teil dieses Blogbeitrags werden wir Überwachungs-, Verwaltungs- und Skalierungsvorgänge sowie einige Fallstricke im Umgang mit MySQL InnoDB Cluster behandeln.
Das folgende Diagramm veranschaulicht unsere Post-Deployment-Architektur:
Wir werden insgesamt 4 Knoten bereitstellen; Eine MySQL-Gruppenreplikation mit drei Knoten und ein MySQL-Router-Knoten, die sich gemeinsam innerhalb des Anwendungsservers befinden. Alle Server laufen auf Ubuntu 18.04 Bionic.
Installieren von MySQL
Die folgenden Schritte sollten auf allen Datenbankknoten db1, db2 und db3 durchgeführt werden.
Zuerst müssen wir ein Host-Mapping durchführen. Dies ist entscheidend, wenn Sie den Hostnamen als Host-ID im InnoDB-Cluster verwenden möchten, und dies ist die empfohlene Vorgehensweise. Ordnen Sie alle Hosts wie folgt in /etc/hosts zu:
$ vi /etc/hosts
192.168.10.40 router apps
192.168.10.41 db1 db1.local
192.168.10.42 db2 db2.local
192.168.10.43 db3 db3.local
127.0.0.1 localhost localhost.localdomainBeenden und deaktivieren Sie AppArmor:
$ service apparmor stop
$ service apparmor teardown
$ systemctl disable apparmorLaden Sie das neueste APT-Konfigurations-Repository von der MySQL-Ubuntu-Repository-Website unter https://repo.mysql.com/apt/ubuntu/pool/mysql-apt-config/m/mysql-apt-config/ herunter. . Zum Zeitpunkt des Verfassens dieses Artikels ist die neueste Version vom 15. Oktober 2019 und lautet mysql-apt-config_0.8.14-1_all.deb:
$ wget https://repo.mysql.com/apt/ubuntu/pool/mysql-apt-config/m/mysql-apt-config/mysql-apt-config_0.8.14-1_all.debInstallieren Sie das Paket und konfigurieren Sie es für "mysql-8.0":
$ dpkg -i mysql-apt-config_0.8.14-1_all.debInstallieren Sie den GPG-Schlüssel:
$ apt-key adv --recv-keys --keyserver ha.pool.sks-keyservers.net 5072E1F5Repolist aktualisieren:
$ apt-get updateInstallieren Sie Python, gefolgt von MySQL-Server und MySQL-Shell:
$ apt-get -y install mysql-server mysql-shellIhnen werden die folgenden Konfigurationsassistenten angezeigt:
- Root-Passwort festlegen – Geben Sie ein sicheres Passwort für den MySQL-Root-Benutzer an.
- Legen Sie die Authentifizierungsmethode fest – Wählen Sie „Legacy-Authentifizierungsmethode verwenden (MySQL 5.x-Kompatibilität beibehalten)“
MySQL sollte zu diesem Zeitpunkt installiert sein. Bestätigen Sie mit:
$ systemctl status mysqlStellen Sie sicher, dass Sie den Status "aktiv (läuft)" erhalten.
Vorbereiten des Servers für InnoDB-Cluster
Die folgenden Schritte sollten auf allen Datenbankknoten db1, db2 und db3 durchgeführt werden.
Konfigurieren Sie den MySQL-Server so, dass er die Gruppenreplikation unterstützt. Der einfachste und empfohlene Weg, dies zu tun, ist die Verwendung der neuen MySQL-Shell:
$ mysqlshAuthentifizieren Sie sich als lokaler Root-Benutzer und folgen Sie dem Konfigurationsassistenten wie im folgenden Beispiel gezeigt:
MySQL JS > dba.configureLocalInstance("[email protected]:3306");Nach der Authentifizierung sollten Sie eine Reihe von Fragen wie die folgenden erhalten:
Antworten auf diese Fragen mit den folgenden Antworten:
- Auswahl 2 – Erstellen Sie ein neues Administratorkonto für den InnoDB-Cluster mit minimal erforderlichen Berechtigungen
- Kontoname:[email protected]%
- Passwort:mys3cret&&
- Passwort bestätigen:mys3cret&&
- Möchten Sie die erforderlichen Konfigurationsänderungen durchführen?:ja
- Möchten Sie die Instanz nach der Konfiguration neu starten?:ja
Vergessen Sie nicht, das Obige auf allen Datenbankknoten zu wiederholen. An diesem Punkt sollte der MySQL-Daemon alle IP-Adressen abhören und die Gruppenreplikation ist aktiviert. Wir können jetzt mit der Erstellung des Clusters fortfahren.
Cluster erstellen
Jetzt können wir einen Cluster erstellen. Verbinden Sie sich auf db1 als Cluster-Administrator von MySQL Shell:
MySQL|JS> shell.connect('[email protected]:3306');
Creating a session to '[email protected]:3306'
Please provide the password for '[email protected]:3306': ***********
Save password for '[email protected]:3306'? [Y]es/[N]o/Ne[v]er (default No): Y
Fetching schema names for autocompletion... Press ^C to stop.
Your MySQL connection id is 9
Server version: 8.0.18 MySQL Community Server - GPL
No default schema selected; type \use <schema> to set one.
<ClassicSession:[email protected]:3306>Sie sollten als [email protected] verbunden sein (Sie können dies erkennen, indem Sie sich die Eingabeaufforderungszeichenfolge vor „>“ ansehen). Wir können jetzt einen neuen Cluster erstellen:
MySQL|db1:3306 ssl|JS> cluster = dba.createCluster('my_innodb_cluster');Clusterstatus prüfen:
MySQL|db1:3306 ssl|JS> cluster.status()
{
"clusterName": "my_innodb_cluster",
"defaultReplicaSet": {
"name": "default",
"primary": "db1:3306",
"ssl": "REQUIRED",
"status": "OK_NO_TOLERANCE",
"statusText": "Cluster is NOT tolerant to any failures.",
"topology": {
"db1:3306": {
"address": "db1:3306",
"mode": "R/W",
"readReplicas": {},
"replicationLag": null,
"role": "HA",
"status": "ONLINE",
"version": "8.0.18"
}
},
"topologyMode": "Single-Primary"
},
"groupInformationSourceMember": "db1:3306"
}Zu diesem Zeitpunkt ist nur db1 Teil des Clusters. Der standardmäßige Topologiemodus ist Single-Primary, ähnlich einem Replikatsatzkonzept, bei dem jeweils nur ein Knoten ein Writer ist. Die verbleibenden Knoten im Cluster sind Leser.
Achten Sie auf den Cluster-Status, der OK_NO_TOLERANCE lautet, und weitere Erläuterungen unter dem StatusText-Schlüssel. In einem Replikatsatzkonzept bietet ein Knoten keine Fehlertoleranz. Es sind mindestens 3 Knoten erforderlich, um das Failover des primären Knotens zu automatisieren. Wir werden uns später darum kümmern.
Fügen Sie nun den zweiten Knoten, db2, hinzu und akzeptieren Sie die Standardwiederherstellungsmethode „Klonen“:
MySQL|db1:3306 ssl|JS> cluster.addInstance('[email protected]:3306');Der folgende Screenshot zeigt den Initialisierungsfortschritt von db2, nachdem wir den obigen Befehl ausgeführt haben. Der Synchronisierungsvorgang wird automatisch von MySQL durchgeführt:
Überprüfen Sie den Cluster- und db2-Status:
MySQL|db1:3306 ssl|JS> cluster.status()
{
"clusterName": "my_innodb_cluster",
"defaultReplicaSet": {
"name": "default",
"primary": "db1:3306",
"ssl": "REQUIRED",
"status": "OK_NO_TOLERANCE",
"statusText": "Cluster is NOT tolerant to any failures.",
"topology": {
"db1:3306": {
"address": "db1:3306",
"mode": "R/W",
"readReplicas": {},
"replicationLag": null,
"role": "HA",
"status": "ONLINE",
"version": "8.0.18"
},
"db2:3306": {
"address": "db2:3306",
"mode": "R/O",
"readReplicas": {},
"replicationLag": null,
"role": "HA",
"status": "ONLINE",
"version": "8.0.18"
}
},
"topologyMode": "Single-Primary"
},
"groupInformationSourceMember": "db1:3306"
}An diesem Punkt haben wir zwei Knoten im Cluster, db1 und db2. Der Status zeigt immer noch OK_NO_TOLERANCE mit weiteren Erläuterungen unter statusText value. Wie oben erwähnt, erfordert die MySQL-Gruppenreplikation mindestens 3 Knoten in einem Cluster für die Fehlertoleranz. Deshalb müssen wir den dritten Knoten wie unten gezeigt hinzufügen.
Fügen Sie den letzten Knoten, db3, hinzu und akzeptieren Sie die Standardwiederherstellungsmethode „Clone“, ähnlich wie bei db2:
MySQL|db1:3306 ssl|JS> cluster.addInstance('[email protected]:3306');Der folgende Screenshot zeigt den Initialisierungsfortschritt von db3, nachdem wir den obigen Befehl ausgeführt haben. Der Synchronisierungsvorgang wird automatisch von MySQL durchgeführt:
Prüfen Sie den Cluster- und db3-Status:
MySQL|db1:3306 ssl|JS> cluster.status()
{
"clusterName": "my_innodb_cluster",
"defaultReplicaSet": {
"name": "default",
"primary": "db1:3306",
"ssl": "REQUIRED",
"status": "OK",
"statusText": "Cluster is ONLINE and can tolerate up to ONE failure.",
"topology": {
"db1:3306": {
"address": "db1:3306",
"mode": "R/W",
"readReplicas": {},
"replicationLag": null,
"role": "HA",
"status": "ONLINE",
"version": "8.0.18"
},
"db2:3306": {
"address": "db2:3306",
"mode": "R/O",
"readReplicas": {},
"replicationLag": null,
"role": "HA",
"status": "ONLINE",
"version": "8.0.18"
},
"db3:3306": {
"address": "db3:3306",
"mode": "R/O",
"readReplicas": {},
"replicationLag": null,
"role": "HA",
"status": "ONLINE",
"version": "8.0.18"
}
},
"topologyMode": "Single-Primary"
},
"groupInformationSourceMember": "db1:3306"
}Jetzt sieht der Cluster gut aus, wobei der Status OK ist und der Cluster bis zu einem Ausfallknoten gleichzeitig tolerieren kann. Der primäre Knoten ist db1, wo „primary“ angezeigt wird:„db1:3306“ und „mode“:„R/W“, während andere Knoten im Status „R/O“ sind. Wenn Sie die read_only- und super_read_only-Werte auf RO-Knoten überprüfen, werden beide als wahr angezeigt.
Unsere MySQL Group Replication-Bereitstellung ist jetzt abgeschlossen und synchronisiert.
Bereitstellen des Routers
Stellen Sie auf dem App-Server, auf dem wir unsere Anwendung ausführen werden, sicher, dass die Hostzuordnung korrekt ist:
$ vim /etc/hosts
192.168.10.40 router apps
192.168.10.41 db1 db1.local
192.168.10.42 db2 db2.local
192.168.10.43 db3 db3.local
127.0.0.1 localhost localhost.localdomainBeenden und deaktivieren Sie AppArmor:
$ service apparmor stop
$ service apparmor teardown
$ systemctl disable apparmorInstallieren Sie dann das MySQL-Repository-Paket, ähnlich wie bei der Datenbankinstallation:
$ wget https://repo.mysql.com/apt/ubuntu/pool/mysql-apt-config/m/mysql-apt-config/mysql-apt-config_0.8.14-1_all.deb
$ dpkg -i mysql-apt-config_0.8.14-1_all.debGPG-Schlüssel hinzufügen:
$ apt-key adv --recv-keys --keyserver ha.pool.sks-keyservers.net 5072E1F5Aktualisieren Sie die Repo-Liste:
$ apt-get updateMySQL-Router und -Client installieren:
$ apt-get -y install mysql-router mysql-clientMySQL Router ist jetzt unter /usr/bin/mysqlrouter installiert. Der MySQL-Router stellt ein Bootstrap-Flag bereit, um den Router-Betrieb automatisch mit einem MySQL-InnoDB-Cluster zu konfigurieren. Was wir tun müssen, ist, den String-URI zu einem der Datenbankknoten als InnoDB-Cluster-Admin-Benutzer (clusteradmin) anzugeben.
Um die Konfiguration zu vereinfachen, führen wir den mysqlrouter-Prozess als Root-Benutzer aus:
$ mysqlrouter --bootstrap [email protected]:3306 --directory myrouter --user=rootFolgendes sollten wir erhalten, nachdem wir das Passwort für den Clusteradmin-Benutzer angegeben haben:
Der Bootstrap-Befehl hilft uns, die Router-Konfigurationsdatei unter /root/myrouter/mysqlrouter.conf zu generieren. Jetzt können wir den mysqlrouter-Daemon mit folgendem Befehl aus dem aktuellen Verzeichnis starten:
$ myrouter/start.shÜberprüfen Sie, ob die erwarteten Ports korrekt lauschen:
$ netstat -tulpn | grep mysql
tcp 0 0 0.0.0.0:6446 0.0.0.0:* LISTEN 14726/mysqlrouter
tcp 0 0 0.0.0.0:6447 0.0.0.0:* LISTEN 14726/mysqlrouter
tcp 0 0 0.0.0.0:64470 0.0.0.0:* LISTEN 14726/mysqlrouter
tcp 0 0 0.0.0.0:64460 0.0.0.0:* LISTEN 14726/mysqlrouterJetzt kann unsere Anwendung Port 6446 zum Lesen/Schreiben und 6447 für schreibgeschützte MySQL-Verbindungen verwenden.
Verbinden mit dem Cluster
Lassen Sie uns einen Datenbankbenutzer auf dem Masterknoten erstellen. Verbinden Sie sich auf db1 über die MySQL-Shell mit dem MySQL-Server:
$ mysqlsh [email protected]:3306Vom Javascript-Modus in den SQL-Modus wechseln:
MySQL|localhost:3306 ssl|JS> \sql
Switching to SQL mode... Commands end with ;Erstellen Sie eine Datenbank:
MySQL|localhost:3306 ssl|SQL> CREATE DATABASE sbtest;Erstellen Sie einen Datenbankbenutzer:
MySQL|localhost:3306 ssl|SQL> CREATE USER [email protected]'%' IDENTIFIED BY 'password';Gewähren Sie dem Benutzer Zugriff auf die Datenbank:
MySQL|localhost:3306 ssl|SQL> GRANT ALL PRIVILEGES ON sbtest.* TO [email protected]'%';Jetzt ist unsere Datenbank und unser Benutzer bereit. Lassen Sie uns sysbench installieren, um einige Testdaten zu generieren. Führen Sie auf dem App-Server Folgendes aus:
$ apt -y install sysbench mysql-clientJetzt können wir auf dem App-Server testen, um über den MySQL-Router eine Verbindung zum MySQL-Server herzustellen. Verbinden Sie sich für eine Schreibverbindung mit Port 6446 des Router-Hosts:
$ mysql -usbtest -p -h192.168.10.40 -P6446 -e 'select user(), @@hostname, @@read_only, @@super_read_only'
+---------------+------------+-------------+-------------------+
| user() | @@hostname | @@read_only | @@super_read_only |
+---------------+------------+-------------+-------------------+
| [email protected] | db1 | 0 | 0 |
+---------------+------------+-------------+-------------------+Stellen Sie für eine schreibgeschützte Verbindung eine Verbindung zu Port 6447 des Router-Hosts her:
$ mysql -usbtest -p -h192.168.10.40 -P6447 -e 'select user(), @@hostname, @@read_only, @@super_read_only'
+---------------+------------+-------------+-------------------+
| user() | @@hostname | @@read_only | @@super_read_only |
+---------------+------------+-------------+-------------------+
| [email protected] | db3 | 1 | 1 |
+---------------+------------+-------------+-------------------+Sieht gut aus. Wir können jetzt einige Testdaten mit sysbench generieren. Generieren Sie auf dem App-Server 20 Tabellen mit 100.000 Zeilen pro Tabelle, indem Sie eine Verbindung zu Port 6446 des App-Servers herstellen:
$ sysbench \
/usr/share/sysbench/oltp_common.lua \
--db-driver=mysql \
--mysql-user=sbtest \
--mysql-db=sbtest \
--mysql-password=password \
--mysql-port=6446 \
--mysql-host=192.168.10.40 \
--tables=20 \
--table-size=100000 \
prepare
Um einen einfachen Lese-Schreib-Test auf Port 6446 für 300 Sekunden durchzuführen, führen Sie Folgendes aus:
$ sysbench \
/usr/share/sysbench/oltp_read_write.lua \
--report-interval=2 \
--threads=8 \
--time=300 \
--db-driver=mysql \
--mysql-host=192.168.10.40 \
--mysql-port=6446 \
--mysql-user=sbtest \
--mysql-db=sbtest \
--mysql-password=password \
--tables=20 \
--table-size=100000 \
runFür schreibgeschützte Workloads können wir die MySQL-Verbindung an Port 6447 senden:
$ sysbench \
/usr/share/sysbench/oltp_read_only.lua \
--report-interval=2 \
--threads=1 \
--time=300 \
--db-driver=mysql \
--mysql-host=192.168.10.40 \
--mysql-port=6447 \
--mysql-user=sbtest \
--mysql-db=sbtest \
--mysql-password=password \
--tables=20 \
--table-size=100000 \
runSchlussfolgerung
Das ist es. Unser MySQL InnoDB-Cluster-Setup ist jetzt vollständig und alle seine Komponenten laufen und wurden getestet. Im zweiten Teil werden wir uns mit Management-, Überwachungs- und Skalierungsvorgängen des Clusters sowie Lösungen für eine Reihe häufiger Probleme im Umgang mit MySQL InnoDB Cluster befassen. Bleiben Sie dran!
