Heartbeat und DRBD werden beide für eine Clusterlösung für beliebige Anwendungen 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 "lebt", und wenn der primäre nicht, Failover-Ressourcen zum Backup. Es verwaltet auch die IP-Hochverfügbarkeit und andere Dienste auf Ihren Servern.
In diesem Tutorial erfahren wir, wie Sie mit Heartbeat und DRBD auf einem Ubuntu 16.04-Server eine hohe Verfügbarkeit von MariaDB erreichen.
Anforderungen
- Zwei Knoten mit installiertem Ubuntu 16.04-Server.
- Zwei Netzwerkkarten auf jedem Knoten installiert.
- Zusätzliche unpartitionierte Festplatte auf jedem Knoten installiert.
- Nicht-Root-Benutzer mit sudo-Berechtigungen auf jedem Knoten eingerichtet.
Erste Schritte
Bevor Sie beginnen, müssen Sie die IP-Adresse auf jedem Knoten einrichten. Verwenden Sie auf jedem Knoten die folgende IP-Adresse:
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 ist die Hochverfügbarkeits-IP.
Als nächstes müssen Sie auch den Hostnamen und die Hostnamenauflösung auf jedem Knoten einrichten. So können alle Knoten miteinander kommunizieren. Öffnen Sie auf dem ersten Knoten die Datei /etc/hosts und die Datei /etc/hostname:
sudo nano /etc/hosts
Fügen Sie am Ende der Datei die folgenden Zeilen 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ügen Sie am Ende der Datei die folgenden Zeilen 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 als Nächstes 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
Starten Sie als Nächstes den DRBD- und Heartbeat-Dienst und ermöglichen Sie ihnen, 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 auf jedem Knoten einrichten. Erstellen Sie eine einzelne Partition auf dem zweiten unpartitionierten Laufwerk /dev/sdb auf jedem 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 auf jedem Knoten erstellen.
sudo nano /etc/drbd.d/r0.res
Fügen Sie 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 andere Konfigurationsdatei auf jedem Knoten:
sudo nano /etc/ha.d/ha.cf
Fügen Sie 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 als Nächstes die Ressourcendatei /etc/ha.d/haresources auf jedem Knoten:
sudo nano /etc/ha.d/haresources
Fügen Sie 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 ist die Gleitkomma-IP-Adresse, /var/lib/mysql ist ein Einhängepunkt und /dev/drbd0 ist ein DRBD-Gerät.
Als Nächstes müssen Sie identische Autorisierungsschlüssel auf beiden Knoten definieren und speichern. Sie können dies über die Datei /etc/ha.d/authkeys auf jedem Knoten tun:
sudo nano /etc/ha.d/authkeys
Fügen Sie die folgenden Zeilen hinzu:
auth1 1 sha1 your-secure-password
Hier ist your-secure-password Ihr sicheres Passwort. Verwenden Sie auf beiden Knoten dasselbe 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
Nachdem der DRBD-Datenträger auf Node1 erstellt wurde, erstellen Sie den DRBD-Datenträger 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
Starten Sie als Nächstes Heartbeat auf beiden Knoten, um den Failover-Teil Ihres Setups zu aktivieren.
sudo systemctl start heartbeat
Überprüfen Sie als Nächstes 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)
Überprüfen Sie als Nächstes mit dem folgenden Befehl, ob die Floating-IP nur 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 verwenden wir Node1 als primär und Datenbanken auf Node2 sollten durch Synchronisierung mit Node1 erstellt und gefüllt werden. Sie müssen also den MariaDB-Dienst stoppen und Inhalte in /var/lib/mysql auf Node2 entfernen. Sie können dies mit dem folgenden Befehl tun:
sudo systemctl stop mysql
sudo rm -rf /var/lib/mysql/*
Als Nächstes müssen Sie die MySQL-Wartungskonfigurationsdatei von Node1 auf Node2 kopieren. Sie können dies tun, indem Sie den folgenden Befehl ausführen:
sudo scp /etc/mysql/debian.cnf [email protected]:/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 mit dem folgenden Befehl einen Root-Benutzer:
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;
Legen Sie als Nächstes die Bindungsadresse für MySQL auf beiden Knoten mit dem folgenden Befehl fest:
sudo sed -i 's/127.0.0.1/0.0.0.0/g' /etc/mysql/mariadb.conf.d/*.cnf
Heartbeat für MariaDB-Dienst initiieren
Als Nächstes müssen Sie den MariaDB-Dienst in Ihren Heartbeat-Instanzen auf beiden Knoten 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 Heartbeat konfiguriert ist, müssen Sie ihn auf beiden Knoten neu starten.
Starten Sie zuerst heartbea auf Node1 neu:
sudo systemctl restart heartbeat
Warten Sie als Nächstes 50 Sekunden und starten Sie dann den Heartbeat-Dienst auf Node2 neu:
sudo systemctl restart heartbeat
Heartbeat und DRBD testen
Jetzt, da alles richtig konfiguriert ist, ist es 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 auf irgendeine Weise ausfällt.
Überprüfen Sie zuerst, ob Knoten1 der primäre drbd-Knoten ist, mit dem folgenden Befehl auf Knoten1:
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 überprüfen wir mit dem folgenden Befehl, ob die DRBD-Festplatte gemountet ist:
sudo mount | grep drbd
/dev/drbd0 on /var/lib/mysql type ext4 (rw,noatime,data=ordered)
Als nächstes überprüfen Sie den MariaDB-Dienst mit dem folgenden Befehl:
sudo systemctl status mysql
Greifen Sie als Nächstes über Floating IP vom Remote-Computer aus auf den MariaDB-Server zu und erstellen Sie eine Testdatenbank:
mysql -h 192.168.0.103 -u root -p
MariaDB [(none)]> create database test;
MariaDB [(none)]> quit
Starten Sie als Nächstes Heartbeat auf Node1 neu:
sudo systemctl restart heartbeat
Jetzt interpretiert Heartbeat diesen Neustart als Fehler von MariaDB auf Node1 und sollte ein Failover auslösen, um Node2 zum primären Server zu machen.
Mit dem folgenden Befehl auf Node1 können Sie überprüfen, ob DRBD Node1 jetzt als sekundären Server behandelt:
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
Überprüfen Sie als Nächstes, ob MariaDB auf Node2 ausgeführt wird:
sudo systemctl status mysql
Stellen Sie jetzt eine Verbindung zum MariaDB-Server her, indem Sie Floating IP auf Node2 vom Remote-Benutzer verwenden.
mysql -h 192.168.0.103 -u root -p
Sehen Sie sich als Nächstes 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)