Wie man MariaDB High Availability mit Heartbeat und DRBD auf Ubuntu 16.04 LTS einrichtet.
Heartbeat und DRBD werden beide für eine Clusterlösung für jede Anwendung mit zwei Servern verwendet. Beide Server arbeiten im aktiven und passiven Modus, ein Server arbeitet gleichzeitig und ein anderer Server als Backup-Server. DRBD (Distributed Replicated Block Device) ist ein Dienst auf Kernel-Ebene, der Daten zwischen zwei Servern in Echtzeit synchronisiert. Heartbeat ist ein Open-Source-Programm, das es einem primären und einem Backup-Linux-Server ermöglicht, festzustellen, ob der andere „lebendig“ ist und wenn der primäre nicht, Failover-Ressourcen für das Backup. Es wird auch die IP-Hochverfügbarkeit und andere Dienste in Ihren Servern verwalten.
In diesem Tutorial erfahren wir, wie wir eine hohe Verfügbarkeit von MariaDB mit Heartbeat und DRBD auf dem Ubuntu 16.04 Server erreichen können.
Anforderungen
- Zwei Knoten mit installiertem Ubuntu 16.04 Server.
- Zwei Netzwerkkarten, die auf jedem Knoten installiert sind.
- Zusätzliche nicht partitionierte Festplatte, die auf jedem Knoten installiert ist.
- Nicht-Root-Benutzer mit sudo-Rechten, die auf jedem Knoten eingerichtet sind.
Erste Schritte
Vor dem Start müssen Sie die IP-Adresse für jeden Knoten einrichten. Verwenden Sie die folgende IP-Adresse auf jedem Knoten:
Knoten1 :
172.16.0.1 auf eth0 und 192.168.0.101 auf eth1.
Knoten2 :
172.16.0.2 auf eth0 und 192.168.0.102 auf eth1.
IP 192.168.0.103 wird die hochverfügbare IP sein.
Als nächstes müssen Sie auch den Hostnamen und die Hostnamenauflösung für jeden Knoten einrichten. So kann jeder Knoten miteinander kommunizieren. Öffnen Sie auf dem ersten Knoten die Datei /etc/hosts und die Datei /etc/hostname:
sudo nano /etc/hosts
Füge die folgenden Zeilen am Ende der Datei hinzu:
172.16.0.1 Node1 172.16.0.2 Node2
sudo nano /etc/hostname
Ändern Sie die Datei wie unten gezeigt:
Node1
Speichern und schließen Sie die Datei, wenn Sie fertig sind.
Öffnen Sie auf dem zweiten Knoten die Datei /etc/hosts und die Datei /etc/hostname:
sudo nano /etc/hosts
Füge die folgenden Zeilen am Ende der Datei hinzu:
172.16.0.1 Node1 172.16.0.2 Node2
sudo nano /etc/hostname
Ändern Sie die Datei wie unten gezeigt:
Node2
Speichern und schließen Sie die Datei, wenn Sie fertig sind.
Aktualisieren Sie anschließend jeden Knoten mit der neuesten Version mit dem folgenden Befehl:
sudo apt-get update -y sudo apt-get upgrade -y
Sobald Ihr System aktualisiert ist, starten Sie das System neu, um diese Änderungen zu übernehmen.
DRBD und Heartbeat installieren
Als nächstes müssen Sie DRBD und Heartbeat auf beiden Knoten installieren. Standardmäßig sind beide im Standard-Repository von Ubuntu 16.04 verfügbar. Sie können sie installieren, indem Sie einfach den folgenden Befehl auf beiden Knoten ausführen:
sudo apt-get install drbd8-utils heartbeat -y
Als nächstes starten Sie den DRBD- und Heartbeat-Dienst und ermöglichen Sie ihm, beim Booten zu starten:
sudo systemctl start drbd sudo systemctl start heartbeat systemctl enable drbd systemctl enable heartbeat
DRBD und Heartbeat konfigurieren
Als nächstes müssen Sie das DRBD-Gerät für jeden Knoten einrichten. Erstellen Sie eine einzelne Partition auf dem zweiten nicht partitionierten Laufwerk /dev/sdb für jeden Knoten.
Sie können dies tun, indem Sie einfach den folgenden Befehl auf jedem Knoten ausführen:
sudo echo -e 'n\np\n1\n\n\nw' | fdisk /dev/sdb
Als nächstes müssen Sie DRBD auf beiden Knoten konfigurieren. Sie können dies tun, indem Sie die Datei /etc/drbd.d/r0.res für jeden Knoten erstellen.
sudo nano /etc/drbd.d/r0.res
Füge die folgenden Zeilen hinzu:
global {
usage-count no;
}
resource r0 {
protocol C;
startup {
degr-wfc-timeout 60;
}
disk {
}
syncer {
rate 100M;
}
net {
cram-hmac-alg sha1;
shared-secret "aBcDeF";
}
on Node1 {
device /dev/drbd0;
disk /dev/sdb1;
address 172.16.0.1:7789;
meta-disk internal;
}
on Node2 {
device /dev/drbd0;
disk /dev/sdb1;
address 172.16.0.2:7789;
meta-disk internal;
}
}
Speichern und schließen Sie die Datei, wenn Sie fertig sind, und öffnen Sie dann eine weitere Konfigurationsdatei für jeden Knoten:
sudo nano /etc/ha.d/ha.cf
Füge die folgenden Zeilen hinzu:
# Check Interval keepalive 1 # Time before server declared dead deadtime 10 # Secondary wait delay at boot initdead 60 # Auto-failback auto_failback off # Heartbeat Interface bcast eth1 # Nodes to monitor node Node1 node Node2
Speichern und schließen Sie die Datei.
Öffnen Sie anschließend die Ressourcendatei /etc/ha.d/haresources für jeden Knoten:
sudo nano /etc/ha.d/haresources
Füge die folgenden Zeilen hinzu:
Node1 192.168.0.103/24 drbddisk::r0 Filesystem::/dev/drbd0::/var/lib/mysql::ext4::noatime
Hier ist Node1 der Hostname Ihres aktiven Hauptknotens, 192.168.0.103 die Gleitkomma-IP-Adresse, /var/lib/mysql ist ein Mountpunkt und /dev/drbd0 ist ein DRBD-Gerät.
Als nächstes müssen Sie auf beiden Knoten identische Berechtigungsschlüssel definieren und speichern. Du kannst dies mit der Datei /etc/ha.d/authkeys auf jedem Knoten tun:
sudo nano /etc/ha.d/authkeys
Füge die folgenden Zeilen hinzu:
auth1 1 sha1 your-secure-password
Hier ist Ihr sicheres Passwort Ihr sicheres Passwort. Verwenden Sie auf beiden Knoten das gleiche Passwort.
Als nächstes erstellen und starten Sie DRBD, indem Sie den folgenden Befehl auf Node1 ausführen:
sudo drbdadm create-md r0 sudo systemctl restart drbd sudo drbdadm outdate r0 sudo drbdadm -- --overwrite-data-of-peer primary all sudo drbdadm primary r0 sudo mkfs.ext4 /dev/drbd0 sudo chmod 600 /etc/ha.d/authkeys sudo mkdir /var/lib/mysql
Sobald die DRBD-Platte auf Node1 erstellt wurde, erstellen Sie die DRBD-Platte auf Node2 mit dem folgenden Befehl:
sudo drbdadm create-md r0 sudo systemctl restart drbd sudo chmod 600 /etc/ha.d/authkeys sudo mkdir /var/lib/mysql
Jetzt können Sie überprüfen, ob die DRBD-Festplatte angeschlossen ist und ordnungsgemäß synchronisiert wird, indem Sie den folgenden Befehl ausführen:
sudo cat /proc/drbd
Wenn alles in Ordnung ist, sollten Sie die folgende Ausgabe sehen:
version: 8.4.5 (api:1/proto:86-101) srcversion: F446E16BFEBS8B115AJB14H 0: cs:SyncSource ro:Primary/Secondary ds:UpToDate/Inconsistent C r----- ns:210413 nr:0 dw:126413 dr:815311 al:35 bm:0 lo:0 pe:11 ua:0 ap:0 ep:1 wo:f oos:16233752 [>....................] sync'ed: 3.3% (14752/14350)M finish: 0:12:23 speed: 12,156 (16,932) K/sec
Als nächstes starten Sie den Heartbeat auf beiden Nodes, um den Failover-Bereich Ihres Setups zu aktivieren.
sudo systemctl start heartbeat
Als nächstes überprüfen Sie die gemountete DRBD-Partition mit dem folgenden Befehl auf Node1:
sudo mount | grep drbd
Sie sollten die folgende Ausgabe sehen:
/dev/drbd0 on /var/lib/mysql type ext4 (rw,noatime,data=ordered)
Als nächstes überprüfen Sie, ob die Floating IP nur mit dem folgenden Befehl an Node1 gebunden ist:
sudo ip addr show | grep 192.168.0.103
Sie sollten die folgende Ausgabe sehen:
inet 192.168.0.103/24 brd 192.168.0.255 scope global secondary eth1:0
MariaDB installieren und konfigurieren
Sobald alles auf beiden Knoten richtig konfiguriert ist, ist es an der Zeit, den MariaDB-Server auf beiden Knoten zu installieren.
Führen Sie den folgenden Befehl auf beiden Knoten aus, um den MariaDB-Server zu installieren:
sudo apt-get install mariadb-server -y
Als nächstes müssen Sie den MariaDB-Dienst auf beiden Knoten deaktivieren:
sudo systemctl disable mysql
Hier werden wir Node1 als primären Knoten verwenden und Datenbanken auf Node2 sollten erstellt und durch Synchronisation mit Node1 gefüllt werden. Sie müssen also den MariaDB-Dienst stoppen und Inhalte in /var/lib/mysql auf Node2 entfernen. Dies kannst du mit dem folgenden Befehl tun:
sudo systemctl stop mysql sudo rm -rf /var/lib/mysql/*
Als nächstes müssen Sie die MySQL Maintenance-Konfigurationsdatei von Node1 nach Node2 kopieren. Sie können dies tun, indem Sie den folgenden Befehl ausführen:
sudo scp /etc/mysql/debian.cnf root@172.16.0.2:/etc/mysql/debian.cnf
Als nächstes müssen Sie einen Root-Benutzer für die Fernverwaltung und den Zugriff auf die Datenbanken auf der hochverfügbaren MySQL-Instanz erstellen.
Sie können dies tun, indem Sie den folgenden Befehl auf Node1 ausführen:
mysql -u root -p
Geben Sie Ihr root-Passwort ein und erstellen Sie dann einen root-Benutzer mit dem folgenden Befehl:
MariaDB [(none)]> CREATE USER 'root'@'192.168.0.%' IDENTIFIED BY 'password'; MariaDB [(none)]> GRANT ALL PRIVILEGES ON *.* TO 'root'@'192.168.0..%' WITH GRANT OPTION; MariaDB [(none)]> FLUSH PRIVILEGES; MariaDB [(none)]> QUIT;
Als nächstes setzen Sie die Bindungsadresse für MySQL auf beiden Knoten mit dem folgenden Befehl:
sudo sed -i 's/127.0.0.1/0.0.0.0/g' /etc/mysql/mariadb.conf.d/*.cnf
Heartbeat für MariaDB Service initiieren
Als nächstes müssen Sie den MariaDB-Dienst in Ihren Heartbeat-Instanzen auf beiden Nodes hinzufügen. Sie können dies tun, indem Sie die Datei /etc/ha.d/haresources bearbeiten:
sudo nano /etc/ha.d/haresources
Ändern Sie die folgenden Zeilen:
Node1 192.168.0.103/24 drbddisk::r0 Filesystem::/dev/drbd0::/var/lib/mysql::ext4::noatime mysql
Speichern und schließen Sie die Datei, wenn Sie fertig sind.
Sobald der Herzschlag konfiguriert ist, müssen Sie ihn auf beiden Knoten neu starten.
Zuerst starten Sie den Heartbea auf Node1 neu:
sudo systemctl restart heartbeat
Warten Sie anschließend 50 Sekunden und starten Sie dann den Heartbeat-Dienst auf Node2 neu:
sudo systemctl restart heartbeat
Test Heartbeat und DRBD testen
Jetzt ist alles richtig konfiguriert, es ist an der Zeit, eine Reihe von Tests durchzuführen, um sicherzustellen, dass Heartbeat tatsächlich eine Übertragung vom aktiven Server zum passiven Server auslöst, wenn der aktive Server in irgendeiner Weise ausfällt.
Überprüfen Sie zunächst, ob Node1 der primäre drbd Knoten ist, mit dem folgenden Befehl auf Node1:
sudo cat /proc/drbd
Sie sollten die folgende Ausgabe sehen:
version: 8.4.5 (api:1/proto:86-101) srcversion: F446E16BFEBS8B115AJB14H O cs:Connected ro:Primary/Secondary ds:UpToDate/UpToDate C r----- ns:22764644 nr:256 dw:529232 dr:22248299 al:111 bm:0 lo:0 pe:0 ua:0 ap:0 ep:1 wo:f oos:0
Als nächstes werden wir überprüfen, ob die DRBD-Festplatte mit dem folgenden Befehl eingebunden ist:
sudo mount | grep drbd
/dev/drbd0 on /var/lib/mysql type ext4 (rw,noatime,data=ordered)
Überprüfen Sie anschließend den MariaDB-Dienst mit dem folgenden Befehl:
sudo systemctl status mysql
Als nächstes greifen Sie von der entfernten Maschine aus über Floating IP auf den MariaDB-Server zu und erstellen eine Testdatenbank:
mysql -h 192.168.0.103 -u root -p
MariaDB [(none)]> create database test; MariaDB [(none)]> quit
Als nächstes starten Sie den Herzschlag auf Node1 neu:
sudo systemctl restart heartbeat
Nun interpretiert Heartbeat diesen Neustart als Fehler von MariaDB auf Node1 und sollte ein Failover auslösen, um Node2 zum primären Server zu machen.
Sie können überprüfen, ob DRBD nun Node1 als sekundären Server behandelt, mit dem folgenden Befehl auf Node1:
sudo cat /proc/drbd
Sie sollten die folgende Ausgabe sehen:
version: 8.4.5 (api:1/proto:86-101) srcversion: F446E16BFEBS8B115AJB14H 0: cs:Connected ro:Secondary/Primary ds:UpToDate/UpToDate C r----- ns:22764856 nr:388 dw:529576 dr:22248303 al:112 bm:0 lo:0 pe:0 ua:0 ap:0 ep:1 wo:f oos:0
Überprüfen Sie nun, ob Node2 der primäre drbd Knoten ist, indem Sie den folgenden Befehl auf Node2 ausführen:
sudo cat /proc/drbd
Sie sollten die folgende Ausgabe sehen:
version: 8.4.5 (api:1/proto:86-101) srcversion: F446E16BFEBS8B115AJB14H 0: cs:Connected ro:Primary/Secondary ds:UpToDate/UpToDate C r----- ns:412 nr:20880892 dw:20881304 dr:11463 al:7 bm:0 lo:0 pe:0 ua:0 ap:0 ep:1 wo:f oos:0
Als nächstes überprüfen Sie, ob MariaDB auf Node2 läuft:
sudo systemctl status mysql
Verbinden Sie sich nun mit dem MariaDB-Server unter Verwendung von Floating IP auf Node2 vom Remote-Benutzer.
mysql -h 192.168.0.103 -u root -p
Als nächstes sehen Sie sich die Testdatenbank an, die wir zuvor erstellt haben, während Node1 der primäre Server war.
MariaDB [(none)]> show databases;
Sie sollten die folgende Ausgabe sehen:
+--------------------+ | Database | +--------------------+ | test | | information_schema | | lost+found | | mysql | | performance_schema | +--------------------+ 5 rows in set (0.04 sec)