Hochverfügbaren MySQL 5.6-Cluster mit DRBD in Compute Engine bereitstellen

Last reviewed 2019-05-10 UTC

In dieser Anleitung erfahren Sie, wie Sie mithilfe von Distributed Replicated Block Device (DRBD) und Compute Engine eine MySQL 5.6-Datenbank in Google Cloud bereitstellen. DRBD ist ein verteiltes repliziertes Speichersystem für die Linux-Plattform.

Diese Anleitung ist nützlich, wenn Sie Systemadministrator, Entwickler, Datenbankadministrator oder DevOps-Entwickler sind. Es gibt verschiedene Gründe, eine eigene MySQL-Instanz zu verwalten, statt den verwalteten Dienst zu nutzen. Beispiele:

Sie verwenden regionenübergreifende Instanzen von MySQL.
Sie möchten Parameter festlegen, die in der verwalteten Version von MySQL nicht verfügbar sind.
Sie möchten die Leistung auf eine Weise optimieren, für die es in der verwalteten Version keine Einstellungen gibt.

DRBD bietet Replikation auf Blockgeräteebene. Sie brauchen die Replikation also nicht direkt in MySQL zu konfigurieren und können sofort von DRBD-Vorteilen wie sicheren Verbindungen und Load-Balancing für Lesevorgänge profitieren.

In der Anleitung wird Folgendes verwendet:

Die Nutzung dieser Ressourcen setzt keine weitergehenden Kenntnisse voraus. Allerdings wird in diesem Dokument auf komplexere Funktionen wie MySQL-Clustering, DRBD-Konfiguration und Linux-Ressourcenverwaltung Bezug genommen.

Architektur

Pacemaker ist ein Clusterressourcenmanager. Corosync ist ein Paket für die Clusterkommunikation und -beteiligung, das von Pacemaker verwendet wird. In dieser Anleitung verwenden Sie DRBD, um das MySQL-Laufwerk von der primären Instanz auf die Standby-Instanz zu replizieren. Damit sich Clients mit dem MySQL-Cluster verbinden können, stellen Sie außerdem einen internen Load-Balancer bereit.

Sie stellen einen von Pacemaker verwalteten Cluster mit drei Compute-Instanzen bereit. Dann installieren Sie MySQL auf zwei der Instanzen, die als primäre und Standby-Instanz dienen. Die dritte Instanz fungiert als Quorumgerät.

In einem Cluster stimmt jeder Knoten für den Knoten ab, der der aktive Knoten sein soll. Das ist der Knoten, auf dem MySQL ausgeführt wird. In einem Cluster mit zwei Knoten ist nur eine Stimme erforderlich, um den aktiven Knoten zu ermitteln. In einem solchen Fall kann das Clusterverhalten zu sogenannten Split-Brain-Problemen oder Ausfallzeiten führen. Split-Brain-Probleme treten auf, wenn beide Knoten die Kontrolle übernehmen, da in einem Szenario mit zwei Knoten nur eine Stimme erforderlich ist. Zu Ausfallzeiten kommt es, wenn der heruntergefahrene Knoten so konfiguriert ist, dass er bei einer Verbindungsunterbrechung immer der primäre Knoten ist. Wenn die Verbindung zwischen den beiden Knoten abbricht, besteht die Gefahr, dass mehrere Clusterknoten davon ausgehen, der aktive Knoten zu sein.

Das Hinzufügen eines Quorumgeräts verhindert diese Situation. Ein Quorumgerät dient als Arbiter, dessen einzige Aufgabe darin besteht, seine Stimme abzugeben. So kann sich dieser Quorumgeräteknoten in einer Situation, in der die Instanzen database1 und database2 nicht kommunizieren können, mit einer der beiden Instanzen in Verbindung setzen und trotzdem eine Mehrheit bilden.

Das folgende Diagramm zeigt die Architektur des hier beschriebenen Systems.

Architektur einer MySQL 5.6-Datenbank, die mit DRBD und Compute Engine in Google Cloud bereitgestellt wird

Ziele

Clusterinstanzen erstellen
MySQL und DRBD auf zwei der Instanzen installieren
DRBD-Replikation konfigurieren
Pacemaker auf den Instanzen installieren
Pacemaker-Clustering auf den Instanzen konfigurieren
Instanz erstellen und als Quorumgerät konfigurieren
Failover testen

Kosten

Sie können mithilfe des Preisrechners eine Kostenschätzung für Ihre voraussichtliche Nutzung erstellen.

Vorbereitung

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Compute Engine API aktivieren.

Aktivieren Sie die API

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Compute Engine API aktivieren.

Aktivieren Sie die API

In dieser Anleitung geben Sie Befehle mit Cloud Shell ein, sofern nicht anders angegeben.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Einrichtung

In diesem Abschnitt richten Sie ein Dienstkonto ein, erstellen Umgebungsvariablen und reservieren IP-Adressen.

Dienstkonto für die Clusterinstanzen einrichten

Öffnen Sie Cloud Shell:

Zu Cloud Shell

Erstellen Sie das Dienstkonto:

gcloud iam service-accounts create mysql-instance \
    --display-name "mysql-instance"

Hängen Sie die für diese Anleitung erforderlichen Rollen an das Dienstkonto an:

gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
    --member=serviceAccount:mysql-instance@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
    --role=roles/compute.instanceAdmin.v1

gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
    --member=serviceAccount:mysql-instance@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
    --role=roles/compute.viewer

gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
    --member=serviceAccount:mysql-instance@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
    --role=roles/iam.serviceAccountUser

Cloud Shell-Umgebungsvariablen erstellen

Erstellen Sie eine Datei mit den erforderlichen Umgebungsvariablen für diese Anleitung:

cat <<EOF > ~/.mysqldrbdrc
# Cluster instance names
DATABASE1_INSTANCE_NAME=database1
DATABASE2_INSTANCE_NAME=database2
QUORUM_INSTANCE_NAME=qdevice
CLIENT_INSTANCE_NAME=mysql-client
# Cluster IP addresses
DATABASE1_INSTANCE_IP="10.140.0.2"
DATABASE2_INSTANCE_IP="10.140.0.3"
QUORUM_INSTANCE_IP="10.140.0.4"
ILB_IP="10.140.0.6"
# Cluster zones and region
DATABASE1_INSTANCE_ZONE="asia-east1-a"
DATABASE2_INSTANCE_ZONE="asia-east1-b"
QUORUM_INSTANCE_ZONE="asia-east1-c"
CLIENT_INSTANCE_ZONE="asia-east1-c"
CLUSTER_REGION="asia-east1"
EOF

Laden Sie die Umgebungsvariablen in die aktuelle Sitzung und legen Sie fest, dass Cloud Shell die Variablen bei zukünftigen Anmeldungen automatisch lädt:
```
source ~/.mysqldrbdrc
grep -q -F "source ~/.mysqldrbdrc" ~/.bashrc || echo "source ~/.mysqldrbdrc" >> ~/.bashrc
```

IP-Adressen reservieren

Reservieren Sie in Cloud Shell eine interne IP-Adresse für jeden der drei Clusterknoten:

gcloud compute addresses create ${DATABASE1_INSTANCE_NAME} ${DATABASE2_INSTANCE_NAME} ${QUORUM_INSTANCE_NAME} \
    --region=${CLUSTER_REGION} \
    --addresses "${DATABASE1_INSTANCE_IP},${DATABASE2_INSTANCE_IP},${QUORUM_INSTANCE_IP}" \
    --subnet=default

Compute Engine-Instanzen erstellen

In den folgenden Schritten verwenden die Clusterinstanzen Debian 9 und die Clientinstanzen Ubuntu 16.

Erstellen Sie in Cloud Shell eine MySQL-Instanz mit dem Namen database1 in der Zone asia-east1-a:

gcloud compute instances create ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --machine-type=n1-standard-2  \
    --network-tier=PREMIUM \
    --maintenance-policy=MIGRATE \
    --image-family=debian-9 \
    --image-project=debian-cloud \
    --boot-disk-size=50GB \
    --boot-disk-type=pd-standard \
    --boot-disk-device-name=${DATABASE1_INSTANCE_NAME} \
    --create-disk=mode=rw,size=300,type=pd-standard,name=disk-1 \
    --private-network-ip=${DATABASE1_INSTANCE_NAME} \
    --tags=mysql --service-account=mysql-instance@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
    --scopes="https://www.googleapis.com/auth/compute,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/service.management.readonly" \
    --metadata="DATABASE1_INSTANCE_IP=${DATABASE1_INSTANCE_IP},DATABASE2_INSTANCE_IP=${DATABASE2_INSTANCE_IP},DATABASE1_INSTANCE_NAME=${DATABASE1_INSTANCE_NAME},DATABASE2_INSTANCE_NAME=${DATABASE2_INSTANCE_NAME},QUORUM_INSTANCE_NAME=${QUORUM_INSTANCE_NAME},DATABASE1_INSTANCE_ZONE=${DATABASE1_INSTANCE_ZONE},DATABASE2_INSTANCE_ZONE=${DATABASE2_INSTANCE_ZONE}"

Erstellen Sie eine MySQL-Instanz mit dem Namen database2 in der Zone asia-east1-b:

gcloud compute instances create ${DATABASE2_INSTANCE_NAME} \
    --zone=${DATABASE2_INSTANCE_ZONE} \
    --machine-type=n1-standard-2  \
    --network-tier=PREMIUM \
    --maintenance-policy=MIGRATE \
    --image-family=debian-9 \
    --image-project=debian-cloud \
    --boot-disk-size=50GB \
    --boot-disk-type=pd-standard \
    --boot-disk-device-name=${DATABASE2_INSTANCE_NAME} \
    --create-disk=mode=rw,size=300,type=pd-standard,name=disk-2 \
    --private-network-ip=${DATABASE2_INSTANCE_NAME} \
    --tags=mysql \
    --service-account=mysql-instance@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
    --scopes="https://www.googleapis.com/auth/compute,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/service.management.readonly" \
    --metadata="DATABASE1_INSTANCE_IP=${DATABASE1_INSTANCE_IP},DATABASE2_INSTANCE_IP=${DATABASE2_INSTANCE_IP},DATABASE1_INSTANCE_NAME=${DATABASE1_INSTANCE_NAME},DATABASE2_INSTANCE_NAME=${DATABASE2_INSTANCE_NAME},QUORUM_INSTANCE_NAME=${QUORUM_INSTANCE_NAME},DATABASE1_INSTANCE_ZONE=${DATABASE1_INSTANCE_ZONE},DATABASE2_INSTANCE_ZONE=${DATABASE2_INSTANCE_ZONE}"

Erstellen Sie einen Quorumknoten zur Verwendung durch Pacemaker in der Zone asia-east1-c:

gcloud compute instances create ${QUORUM_INSTANCE_NAME} \
    --zone=${QUORUM_INSTANCE_ZONE} \
    --machine-type=n1-standard-1 \
    --network-tier=PREMIUM \
    --maintenance-policy=MIGRATE \
    --image-family=debian-9  \
    --image-project=debian-cloud \
    --boot-disk-size=10GB \
    --boot-disk-type=pd-standard \
    --boot-disk-device-name=${QUORUM_INSTANCE_NAME} \
    --private-network-ip=${QUORUM_INSTANCE_NAME}

Erstellen Sie eine MySQL-Clientinstanz:

gcloud compute instances create ${CLIENT_INSTANCE_NAME} \
    --image-family=ubuntu-1604-lts \
    --image-project=ubuntu-os-cloud \
    --tags=mysql-client \
    --zone=${CLIENT_INSTANCE_ZONE} \
    --boot-disk-size=10GB \
    --metadata="ILB_IP=${ILB_IP}"

DRBD installieren und konfigurieren

In diesem Bereich installieren und konfigurieren Sie die DRBD-Pakete auf den Instanzen database1 und database2 und initiieren dann die DRBD-Replikation von database1 auf database2.

DRBD auf database1 konfigurieren

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf:

Zur Seite "VM-Instanzen"
Klicken Sie in der Zeile mit der database1-Instanz auf SSH, um eine Verbindung zur Instanz herzustellen.

Hinweis: In dieser Anleitung stellen Sie eine Verbindung zu verschiedenen Instanzen her. Wiederholen Sie die beiden vorherigen Schritte, um über SSH eine Verbindung zu jeder Instanz in der Cloud Console herzustellen.

Erstellen Sie eine Datei, um Instanzmetadaten in Umgebungsvariablen abzurufen und zu speichern:

sudo bash -c cat <<EOF  > ~/.varsrc
DATABASE1_INSTANCE_IP=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE1_INSTANCE_IP" -H "Metadata-Flavor: Google")
DATABASE2_INSTANCE_IP=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE2_INSTANCE_IP" -H "Metadata-Flavor: Google")
DATABASE1_INSTANCE_NAME=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE1_INSTANCE_NAME" -H "Metadata-Flavor: Google")
DATABASE2_INSTANCE_NAME=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE2_INSTANCE_NAME" -H "Metadata-Flavor: Google")
DATABASE2_INSTANCE_ZONE=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE2_INSTANCE_ZONE" -H "Metadata-Flavor: Google")
DATABASE1_INSTANCE_ZONE=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE1_INSTANCE_ZONE" -H "Metadata-Flavor: Google")
QUORUM_INSTANCE_NAME=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/QUORUM_INSTANCE_NAME" -H "Metadata-Flavor: Google")

EOF

Laden Sie die Metadatenvariablen aus der Datei:
```
source ~/.varsrc
```
Formatieren Sie das Datenlaufwerk:
```
sudo bash -c  "mkfs.ext4 -m 0 -F -E \
lazy_itable_init=0,lazy_journal_init=0,discard /dev/sdb"
```
Eine detaillierte Beschreibung der mkfs.ext4-Optionen finden Sie auf der Manpage zu mkfs.ext4.
Installieren Sie DRBD:
```
sudo apt -y install drbd8-utils
```

Erstellen Sie die DRBD-Konfigurationsdatei:

sudo bash -c 'cat <<EOF  > /etc/drbd.d/global_common.conf
global {
    usage-count no;
}
common {
    protocol C;
}
EOF'

Erstellen Sie eine DRBD-Ressourcendatei:

sudo bash -c "cat <<EOF  > /etc/drbd.d/r0.res
resource r0 {
    meta-disk internal;
    device /dev/drbd0;
    net {
        allow-two-primaries no;
        after-sb-0pri discard-zero-changes;
        after-sb-1pri discard-secondary;
        after-sb-2pri disconnect;
        rr-conflict disconnect;
    }
    on database1 {
        disk /dev/sdb;
        address 10.140.0.2:7789;
    }
    on database2 {
        disk /dev/sdb;
        address 10.140.0.3:7789;
    }
}
EOF"

Laden Sie das DRBD-Kernelmodul:
```
sudo modprobe drbd
```

Löschen Sie den Inhalt des Laufwerks /dev/sdb:

sudo dd if=/dev/zero of=/dev/sdb bs=1k count=1024

Erstellen Sie die DRBD-Ressource r0:
```
sudo drbdadm create-md r0
```
Richten Sie DRBD ein:
```
sudo drbdadm up r0
```
Deaktivieren Sie DRBD, wenn das System gestartet wird, damit die Software für die Clusterressourcenverwaltung alle erforderlichen Dienste nacheinander einrichten kann:
```
sudo update-rc.d drbd disable
```

DRBD auf database2 konfigurieren

Jetzt installieren und konfigurieren Sie die DRBD-Pakete auf der Instanz database2.

Stellen Sie über SSH eine Verbindung zur database2-Instanz her.

Erstellen Sie eine .varsrc-Datei, um Instanzmetadaten in Umgebungsvariablen abzurufen und zu speichern:

sudo bash -c cat <<EOF  > ~/.varsrc
DATABASE1_INSTANCE_IP=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE1_INSTANCE_IP" -H "Metadata-Flavor: Google")
DATABASE2_INSTANCE_IP=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE2_INSTANCE_IP" -H "Metadata-Flavor: Google")
DATABASE1_INSTANCE_NAME=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE1_INSTANCE_NAME" -H "Metadata-Flavor: Google")
DATABASE2_INSTANCE_NAME=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE2_INSTANCE_NAME" -H "Metadata-Flavor: Google")
DATABASE2_INSTANCE_ZONE=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE2_INSTANCE_ZONE" -H "Metadata-Flavor: Google")
DATABASE1_INSTANCE_ZONE=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/DATABASE1_INSTANCE_ZONE" -H "Metadata-Flavor: Google")
QUORUM_INSTANCE_NAME=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/QUORUM_INSTANCE_NAME" -H "Metadata-Flavor: Google")
EOF

Laden Sie die Metadatenvariablen aus der Datei:
```
source ~/.varsrc
```

Formatieren Sie das Datenlaufwerk:

sudo bash -c  "mkfs.ext4 -m 0 -F -E  lazy_itable_init=0,lazy_journal_init=0,discard /dev/sdb"

Installieren Sie die DRBD-Pakete:
```
sudo apt -y install drbd8-utils
```

Erstellen Sie die DRBD-Konfigurationsdatei:

sudo bash -c 'cat <<EOF  > /etc/drbd.d/global_common.conf
global {
    usage-count no;
}
common {
    protocol C;
}
EOF'

Erstellen Sie eine DRBD-Ressourcendatei:

sudo bash -c "cat <<EOF  > /etc/drbd.d/r0.res
resource r0 {
    meta-disk internal;
    device /dev/drbd0;
    net {
        allow-two-primaries no;
        after-sb-0pri discard-zero-changes;
        after-sb-1pri discard-secondary;
        after-sb-2pri disconnect;
        rr-conflict disconnect;
    }
    on ${DATABASE1_INSTANCE_NAME} {
        disk /dev/sdb;
        address ${DATABASE1_INSTANCE_IP}:7789;
    }
    on ${DATABASE2_INSTANCE_NAME} {
        disk /dev/sdb;
        address ${DATABASE2_INSTANCE_IP}:7789;
    }
}
EOF"

Laden Sie das DRBD-Kernelmodul:
```
sudo modprobe drbd
```

Löschen Sie das Laufwerk /dev/sdb:

sudo dd if=/dev/zero of=/dev/sdb bs=1k count=1024

Erstellen Sie die DRBD-Ressource r0:
```
sudo drbdadm create-md r0
```
Richten Sie DRBD ein:
```
sudo drbdadm up r0
```
Deaktivieren Sie DRBD, wenn das System gestartet wird, damit die Software für die Clusterressourcenverwaltung alle erforderlichen Dienste nacheinander einrichten kann:
```
sudo update-rc.d drbd disable
```

DRBD-Replikation von database1 auf database2 initiieren

Stellen Sie über SSH eine Verbindung zur database1-Instanz her.

Überschreiben Sie alle r0-Ressourcen auf dem primären Knoten:

sudo drbdadm -- --overwrite-data-of-peer primary r0
sudo mkfs.ext4 -m 0 -F -E lazy_itable_init=0,lazy_journal_init=0,discard /dev/drbd0

Prüfen Sie den Status von DRBD:
```
sudo cat /proc/drbd | grep ============
```
Sie erhalten folgende Ausgabe:
```
[===================>] sync'ed:100.0% (208/307188)M
```
Hinweis: Es kann einige Minuten dauern, bis die Synchronisierung 100 % erreicht.

Stellen Sie /dev/drbd auf /srv bereit:

sudo mount -o discard,defaults /dev/drbd0 /srv

MySQL und Pacemaker installieren

In diesem Abschnitt installieren Sie MySQL und Pacemaker auf jeder Instanz.

MySQL auf database1 installieren

Stellen Sie über SSH eine Verbindung zur database1-Instanz her.

Aktualisieren Sie das APT-Repository mit den MySQL 5.6-Paketdefinitionen:

sudo bash -c 'cat <<EOF  > /etc/apt/sources.list.d/mysql.list
deb http://repo.mysql.com/apt/debian/ stretch mysql-5.6\ndeb-src http://repo.mysql.com/apt/debian/ stretch mysql-5.6
EOF'

Fügen Sie die GPG-Schlüssel in die APT-Datei repository.srv ein:

wget -O /tmp/RPM-GPG-KEY-mysql https://repo.mysql.com/RPM-GPG-KEY-mysql
sudo apt-key add /tmp/RPM-GPG-KEY-mysql

Aktualisieren Sie die Paketliste:
```
sudo apt update
```
Installieren Sie den MySQL-Server:
```
sudo apt -y install mysql-server
```
Wenn Sie zur Eingabe eines Passworts aufgefordert werden, geben Sie DRBDha2 ein.
Stoppen Sie den MySQL-Server:
```
sudo /etc/init.d/mysql stop
```

Erstellen Sie die MySQL-Konfigurationsdatei:

sudo bash -c 'cat <<EOF  > /etc/mysql/mysql.conf.d/my.cnf
[mysqld]
bind-address = 0.0.0.0  # You may want to listen at localhost at the beginning
datadir = /var/lib/mysql
tmpdir = /srv/tmp
user = mysql
EOF'

Erstellen Sie ein temporäres Verzeichnis für den MySQL-Server (in mysql.conf konfiguriert):
```
sudo mkdir /srv/tmp
sudo chmod 1777 /srv/tmp
```
Verschieben Sie alle MySQL-Daten in das DRBD-Verzeichnis /srv/mysql:
```
sudo mv /var/lib/mysql /srv/mysql
```
Verknüpfen Sie /var/lib/mysql mit /srv/mysql unter dem DRBD-replizierten Speicher-Volume:
```
sudo ln -s /srv/mysql /var/lib/mysql
```
Ändern Sie den Inhaber von /srv/mysql in einen mysql-Prozess:
```
sudo chown -R mysql:mysql /srv/mysql
```
Entfernen Sie die ersten InnoDB-Daten, um dafür zu sorgen, dass das Laufwerk so sauber wie möglich ist:
```
sudo bash -c "cd /srv/mysql && rm ibdata1 && rm ib_logfile*"
```
InnoDB ist ein Speichermodul für das MySQL-Datenbankverwaltungssystem.
Starten Sie MySQL:
```
sudo /etc/init.d/mysql start
```

Gewähren Sie dem Root-Nutzer Zugriff auf Remoteverbindungen, um die Bereitstellung später zu testen:

mysql -uroot -pDRBDha2 -e "GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'DRBDha2' WITH GRANT OPTION;"

Deaktivieren Sie den automatischen MySQL-Start, um den sich die Clusterressourcenverwaltung kümmert:
```
sudo update-rc.d -f mysql disable
```

Pacemaker auf database1 installieren

Laden Sie die Metadatenvariablen aus der zuvor erstellten .varsrc-Datei:
```
source ~/.varsrc
```
Stoppen Sie den MySQL-Server:
```
sudo /etc/init.d/mysql stop
```
Installieren Sie Pacemaker:
```
sudo apt -y install pcs
```

Aktivieren Sie pcsd, corosync und pacemaker beim Systemstart auf der primären Instanz:

sudo update-rc.d -f pcsd enable
sudo update-rc.d -f corosync enable
sudo update-rc.d -f pacemaker enable

Konfigurieren Sie corosync so, dass es vor pacemaker startet:

sudo update-rc.d corosync defaults 20 20
sudo update-rc.d pacemaker defaults 30 10

Legen Sie das Nutzerpasswort des Clusters auf haCLUSTER3 für die Authentifizierung fest:
```
sudo bash -c "echo  hacluster:haCLUSTER3 | chpasswd"
```
Führen Sie das Skript corosync-keygen aus, um einen 128-Bit-Clusterautorisierungsschlüssel zu generieren und schreiben Sie ihn in /etc/corosync/authkey:
```
sudo corosync-keygen -l
```

Kopieren Sie authkey in die Instanz database2. Wenn Sie zur Eingabe einer Passphrase aufgefordert werden, drücken Sie Enter:

sudo chmod 444 /etc/corosync/authkey
gcloud beta compute scp /etc/corosync/authkey ${DATABASE2_INSTANCE_NAME}:~/authkey --zone=${DATABASE2_INSTANCE_ZONE} --internal-ip
sudo chmod 400 /etc/corosync/authkey

Erstellen Sie eine Corosync-Clusterkonfigurationsdatei:
```
sudo bash -c "cat <<EOF  > /etc/corosync/corosync.conf

totem {
    version: 2
    cluster_name: mysql_cluster
    transport: udpu
    interface {
        ringnumber: 0
        Bindnetaddr: ${DATABASE1_INSTANCE_IP}
        broadcast: yes
        mcastport: 5405
    }
}
quorum {
    provider: corosync_votequorum
two_node: 1
}

nodelist {
    node {
        ring0_addr: ${DATABASE1_INSTANCE_NAME}
    name:  ${DATABASE1_INSTANCE_NAME}

    nodeid: 1
    }
    node {
        ring0_addr:  ${DATABASE2_INSTANCE_NAME}
        name:  ${DATABASE2_INSTANCE_NAME}
        nodeid: 2
    }
}
logging {
    to_logfile: yes
    logfile: /var/log/corosync/corosync.log
    timestamp: on
}

EOF"
```
Der Bereich totem konfiguriert das Totem-Protokoll für zuverlässige Kommunikation. Corosync bedient sich dieser Kommunikationsart zur Steuerung der Clustermitgliedschaft und gibt an, wie die Clustermitglieder miteinander kommunizieren sollen.

Die wichtigen Einstellungen der Einrichtung sind:
- transport: Gibt den Unicast-Modus an (udpu).
- Bindnetaddr: Gibt die Netzwerkadresse an, an die Corosync bindet.
- nodelist: Definiert die Knoten im Cluster und wie sie erreicht werden können. In diesem Fall sind das die Knoten database1 und database2.
- quorum/two_node: Standardmäßig erreicht kein Knoten in einem Zwei-Knoten-Cluster ein Quorum. Sie können dies überschreiben, wenn Sie im Bereich quorum den Wert "1" für two_node angeben.
Mit dieser Einrichtung können Sie den Cluster konfigurieren und für das spätere Hinzufügen eines dritten Knotens – dem Quorumgerät – vorbereiten.
Erstellen Sie das Dienstverzeichnis für corosync:
```
sudo mkdir -p /etc/corosync/service.d
```

Konfigurieren Sie corosync so, dass es Pacemaker erkennt:

sudo bash -c 'cat <<EOF  > /etc/corosync/service.d/pcmk
service {
    name: pacemaker
    ver: 1
}
EOF'

Aktivieren Sie den Dienst corosync als Standard:

sudo bash -c 'cat <<EOF  > /etc/default/corosync
# Path to corosync.conf
COROSYNC_MAIN_CONFIG_FILE=/etc/corosync/corosync.conf
# Path to authfile
COROSYNC_TOTEM_AUTHKEY_FILE=/etc/corosync/authkey
# Enable service by default
START=yes
EOF'

Starten Sie die Dienste corosync und pacemaker neu:

sudo service corosync restart
sudo service pacemaker restart

Installieren Sie das Corosync-Paket für Quorumgeräte:
```
sudo apt -y install corosync-qdevice
```

Installieren Sie ein Shell-Skript, um DRBD-Fehlerereignisse zu behandeln:

sudo bash -c 'cat << 'EOF'  > /var/lib/pacemaker/drbd_cleanup.sh
#!/bin/sh
if [ -z \$CRM_alert_version ]; then
    echo "\$0 must be run by Pacemaker version 1.1.15 or later"
    exit 0
fi

tstamp="\$CRM_alert_timestamp: "

case \$CRM_alert_kind in
    resource)
        if [ \${CRM_alert_interval} = "0" ]; then
            CRM_alert_interval=""
        else
            CRM_alert_interval=" (\${CRM_alert_interval})"
        fi

        if [ \${CRM_alert_target_rc} = "0" ]; then
            CRM_alert_target_rc=""
        else
            CRM_alert_target_rc=" (target: \${CRM_alert_target_rc})"
        fi

        case \${CRM_alert_desc} in
            Cancelled) ;;
            *)
                echo "\${tstamp}Resource operation "\${CRM_alert_task}\${CRM_alert_interval}" for "\${CRM_alert_rsc}" on "\${CRM_alert_node}": \${CRM_alert_desc}\${CRM_alert_target_rc}" >> "\${CRM_alert_recipient}"
                if [ "\${CRM_alert_task}" = "stop" ] && [ "\${CRM_alert_desc}" = "Timed Out" ]; then
                    echo "Executing recovering..." >> "\${CRM_alert_recipient}"
                    pcs resource cleanup \${CRM_alert_rsc}
                fi
                ;;
        esac
        ;;
    *)
        echo "\${tstamp}Unhandled \$CRM_alert_kind alert" >> "\${CRM_alert_recipient}"
        env | grep CRM_alert >> "\${CRM_alert_recipient}"
        ;;
esac
EOF'
sudo chmod 0755 /var/lib/pacemaker/drbd_cleanup.sh
sudo touch /var/log/pacemaker_drbd_file.log
sudo chown hacluster:haclient /var/log/pacemaker_drbd_file.log

MySQL auf database2 installieren

Stellen Sie über SSH eine Verbindung zur database2-Instanz her.

Aktualisieren Sie das APT-Repository mit dem MySQL 5.6-Paket:

sudo bash -c 'cat <<EOF  > /etc/apt/sources.list.d/mysql.list
deb http://repo.mysql.com/apt/debian/ stretch mysql-5.6\ndeb-src http://repo.mysql.com/apt/debian/ stretch mysql-5.6
EOF'

Nehmen Sie die GPG-Schlüssel in das APT-Repository auf:

wget -O /tmp/RPM-GPG-KEY-mysql https://repo.mysql.com/RPM-GPG-KEY-mysql
sudo apt-key add /tmp/RPM-GPG-KEY-mysql

Aktualisieren Sie die Paketliste:
```
sudo apt update
```
Installieren Sie den MySQL-Server:
```
sudo apt -y install mysql-server
```
Wenn Sie zur Eingabe eines Passworts aufgefordert werden, geben Sie DRBDha2 ein.
Stoppen Sie den MySQL-Server:
```
sudo /etc/init.d/mysql stop
```

Erstellen Sie die MySQL-Konfigurationsdatei:

sudo bash -c 'cat <<EOF  > /etc/mysql/mysql.conf.d/my.cnf
[mysqld]
bind-address = 0.0.0.0  # You may want to listen at localhost at the beginning
datadir = /var/lib/mysql
tmpdir = /srv/tmp
user = mysql
EOF'

Entfernen Sie Daten unter /var/lib/mysql und fügen Sie dem als Ziel gesetzten Bereitstellungspunkt für das replizierte DRBD-Volume einen symbolischen Link hinzu. Das DRBD-Volume (/dev/drbd0) wird nur dann unter /srv bereitgestellt, wenn ein Failover auftritt.
```
sudo rm -rf /var/lib/mysql
sudo ln -s /srv/mysql /var/lib/mysql
```
Hinweis: Das Verzeichnis /srv ist zu diesem Zeitpunkt nicht bereitgestellt. Der symbolische Link ist jedoch gültig, wenn ein Failover des Clusters ausgeführt wird.
Deaktivieren Sie den automatischen MySQL-Start, um den sich die Clusterressourcenverwaltung kümmert:
```
sudo update-rc.d -f mysql disable
```

Pacemaker auf database2 installieren

Laden Sie die Metadatenvariablen aus der .varsrc-Datei:
```
source ~/.varsrc
```
Installieren Sie Pacemaker:
```
sudo apt -y install pcs
```

Verschieben Sie die zuvor kopierte Corosync-Datei authkey in /etc/corosync/:

sudo mv ~/authkey /etc/corosync/
sudo chown root: /etc/corosync/authkey
sudo chmod 400 /etc/corosync/authkey

Aktivieren Sie pcsd, corosync und pacemaker beim Systemstart auf der Stand-by-Instanz:

sudo update-rc.d -f pcsd enable
sudo update-rc.d -f corosync enable
sudo update-rc.d -f pacemaker enable

Konfigurieren Sie corosync so, dass es vor pacemaker startet:

sudo update-rc.d corosync defaults 20 20
sudo update-rc.d pacemaker defaults 30 10

Legen Sie das Nutzerpasswort des Clusters für die Authentifizierung fest. Es ist dasselbe Passwort (haCLUSTER3), das Sie für die database1-Instanz verwendet haben.
```
sudo bash -c "echo  hacluster:haCLUSTER3 | chpasswd"
```

Erstellen Sie die Konfigurationsdatei corosync:

sudo bash -c "cat <<EOF  > /etc/corosync/corosync.conf

totem {
    version: 2
    cluster_name: mysql_cluster
    transport: udpu
    interface {
        ringnumber: 0
        Bindnetaddr: ${DATABASE2_INSTANCE_IP}
        broadcast: yes
        mcastport: 5405
    }
}
quorum {
    provider: corosync_votequorum
    two_node: 1
}
nodelist {
    node {
        ring0_addr: ${DATABASE1_INSTANCE_NAME}
        name: ${DATABASE1_INSTANCE_NAME}
        nodeid: 1
    }
    node {
        ring0_addr: ${DATABASE2_INSTANCE_NAME}
        name: ${DATABASE2_INSTANCE_NAME}
        nodeid: 2
    }
}
logging {
    to_logfile: yes
    logfile: /var/log/corosync/corosync.log
timestamp: on
}
EOF"

Erstellen Sie das Corosync-Dienstverzeichnis:
```
sudo mkdir /etc/corosync/service.d
```

Konfigurieren Sie corosync so, dass es Pacemaker erkennt:

sudo bash -c 'cat <<EOF  > /etc/corosync/service.d/pcmk
service {
name: pacemaker
ver: 1
}
EOF'

Aktivieren Sie den Dienst corosync als Standard:

sudo bash -c 'cat <<EOF  > /etc/default/corosync
# Path to corosync.conf
COROSYNC_MAIN_CONFIG_FILE=/etc/corosync/corosync.conf
# Path to authfile
COROSYNC_TOTEM_AUTHKEY_FILE=/etc/corosync/authkey
# Enable service by default
START=yes
EOF'

Starten Sie die Dienste corosync und pacemaker neu:

sudo service corosync restart
sudo service pacemaker restart

Installieren Sie das Corosync-Paket für Quorumgeräte:
```
sudo apt -y install corosync-qdevice
```

Installieren Sie ein Shell-Skript, um DRBD-Fehlerereignisse zu behandeln:

sudo bash -c 'cat << 'EOF'  > /var/lib/pacemaker/drbd_cleanup.sh
#!/bin/sh
if [ -z \$CRM_alert_version ]; then
    echo "\$0 must be run by Pacemaker version 1.1.15 or later"
    exit 0
fi

tstamp="\$CRM_alert_timestamp: "

case \$CRM_alert_kind in
    resource)
        if [ \${CRM_alert_interval} = "0" ]; then
            CRM_alert_interval=""
        else
            CRM_alert_interval=" (\${CRM_alert_interval})"
        fi

        if [ \${CRM_alert_target_rc} = "0" ]; then
            CRM_alert_target_rc=""
        else
            CRM_alert_target_rc=" (target: \${CRM_alert_target_rc})"
        fi

        case \${CRM_alert_desc} in
            Cancelled) ;;
            *)
                echo "\${tstamp}Resource operation "\${CRM_alert_task}\${CRM_alert_interval}" for "\${CRM_alert_rsc}" on "\${CRM_alert_node}": \${CRM_alert_desc}\${CRM_alert_target_rc}" >> "\${CRM_alert_recipient}"
                if [ "\${CRM_alert_task}" = "stop" ] && [ "\${CRM_alert_desc}" = "Timed Out" ]; then
                    echo "Executing recovering..." >> "\${CRM_alert_recipient}"
                    pcs resource cleanup \${CRM_alert_rsc}
                fi
                ;;
        esac
        ;;
    *)
        echo "\${tstamp}Unhandled \$CRM_alert_kind alert" >> "\${CRM_alert_recipient}"
        env | grep CRM_alert >> "\${CRM_alert_recipient}"
        ;;
esac
EOF'
sudo chmod 0755 /var/lib/pacemaker/drbd_cleanup.sh
sudo touch /var/log/pacemaker_drbd_file.log
sudo chown hacluster:haclient /var/log/pacemaker_drbd_file.log

Überprüfen Sie den Corosync-Clusterstatus:

sudo corosync-cmapctl | grep "members...ip"

Sie erhalten folgende Ausgabe:

runtime.totem.pg.mrp.srp.members.1.ip (str) = r(0) ip(10.140.0.2)
runtime.totem.pg.mrp.srp.members.2.ip (str) = r(0) ip(10.140.0.3)

Cluster starten

Stellen Sie über SSH eine Verbindung zur database2-Instanz her.
Laden Sie die Metadatenvariablen aus der .varsrc-Datei:
```
source ~/.varsrc
```

Authentifizieren Sie sich bei den Clusterknoten:

sudo pcs cluster auth --name mysql_cluster ${DATABASE1_INSTANCE_NAME} ${DATABASE2_INSTANCE_NAME} -u hacluster -p haCLUSTER3

Starten Sie den Cluster.
```
sudo pcs cluster start --all
```

Prüfen Sie den Clusterstatus:

sudo pcs status

Sie erhalten folgende Ausgabe:

Cluster name: mysql_cluster
WARNING: no stonith devices and stonith-enabled is not false
Stack: corosync
Current DC: database2 (version 1.1.16-94ff4df) - partition with quorum
Last updated: Sat Nov  3 07:24:53 2018
Last change: Sat Nov  3 07:17:17 2018 by hacluster via crmd on database2

2 nodes configured
0 resources configured

Online: [ database1 database2 ]

No resources

Daemon Status:
  corosync: active/enabled
  pacemaker: active/enabled
  pcsd: active/enabled

Pacemaker zum Verwalten von Clusterressourcen konfigurieren

Als Nächstes konfigurieren Sie Pacemaker mit den DRBD-, Laufwerks-, MySQL- und Quorumressourcen.

Stellen Sie über SSH eine Verbindung zur database1-Instanz her.
Verwenden Sie das Pacemaker-Dienstprogramm pcs, um mehrere Änderungen in einer Datei in eine Warteschlange zu stellen und diese Änderungen später atomar in die Cluster Information Base (CIB) per Push zu übertragen:
```
sudo pcs cluster cib clust_cfg
```
Deaktivieren Sie STONITH, da Sie das Quorumgerät später bereitstellen:
```
sudo pcs -f clust_cfg property set stonith-enabled=false
```
Deaktivieren Sie die quorumbezogenen Einstellungen. Sie richten den Quorumgeräteknoten später ein.
```
sudo pcs -f clust_cfg property set no-quorum-policy=stop
```
Verhindern Sie, dass Pacemaker nach einer Wiederherstellung Ressourcen zurückverschiebt:
```
sudo pcs -f clust_cfg resource defaults resource-stickiness=200
```

Erstellen Sie die DRBD-Ressource im Cluster:

sudo pcs -f clust_cfg resource create mysql_drbd ocf:linbit:drbd \
    drbd_resource=r0 \
    op monitor role=Master interval=110 timeout=30 \
    op monitor role=Slave interval=120 timeout=30 \
    op start timeout=120 \
    op stop timeout=60

Sorgen Sie dafür, dass der DRBD-Ressource nur eine einzige primäre Rolle zugewiesen wird:

sudo pcs -f clust_cfg resource master primary_mysql mysql_drbd \
    master-max=1 master-node-max=1 \
    clone-max=2 clone-node-max=1 \
    notify=true

Erstellen Sie die Dateisystemressource, um das DRBD-Laufwerk bereitzustellen:

sudo pcs -f clust_cfg resource create mystore_FS Filesystem \
    device="/dev/drbd0" \
    directory="/srv" \
    fstype="ext4"

Konfigurieren Sie den Cluster so, dass die DRBD-Ressource mit der Laufwerksressource auf derselben VM platziert wird:
```
sudo pcs -f clust_cfg constraint colocation add mystore_FS with primary_mysql INFINITY with-rsc-role=Master
```
Konfigurieren Sie den Cluster so, dass die Laufwerksressource erst nach dem Hochstufen der primären DRBD-Ressource eingerichtet wird:
```
sudo pcs -f clust_cfg constraint order promote primary_mysql then start mystore_FS
```

Erstellen Sie einen MySQL-Dienst:

sudo pcs -f clust_cfg resource create mysql_service ocf:heartbeat:mysql \
    binary="/usr/bin/mysqld_safe" \
    config="/etc/mysql/my.cnf" \
    datadir="/var/lib/mysql" \
    pid="/var/run/mysqld/mysql.pid" \
    socket="/var/run/mysqld/mysql.sock" \
    additional_parameters="--bind-address=0.0.0.0" \
    op start timeout=60s \
    op stop timeout=60s \
    op monitor interval=20s timeout=30s

Konfigurieren Sie den Cluster so, dass die MySQL-Ressource mit der Laufwerksressource auf derselben VM platziert wird:
```
sudo pcs -f clust_cfg constraint colocation add mysql_service with mystore_FS INFINITY
```
Sorgen Sie dafür, dass das DRBD-Dateisystem in der Startreihenfolge vor dem MySQL-Dienst steht:
```
sudo pcs -f clust_cfg constraint order mystore_FS then mysql_service
```

Erstellen Sie den Benachrichtigungs-Agent und fügen Sie den Patch in die Logdatei als dessen Empfänger ein:

sudo pcs -f clust_cfg alert create id=drbd_cleanup_file description="Monitor DRBD events and perform post cleanup" path=/var/lib/pacemaker/drbd_cleanup.sh
sudo pcs -f clust_cfg alert recipient add drbd_cleanup_file id=logfile value=/var/log/pacemaker_drbd_file.log

Führen Sie ein Commit für die Änderungen am Cluster durch:
```
sudo pcs cluster cib-push clust_cfg
```

Sehen Sie nach, ob alle Ressourcen online sind:

sudo pcs status

Sie erhalten folgende Ausgabe:

Online: [ database1 database2 ]

Full list of resources:
 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database1 ]
     Slaves: [ database2 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database1
 mysql_service  (ocf::heartbeat:mysql): Started database1

Quorumgerät konfigurieren

Stellen Sie über SSH eine Verbindung zur qdevice-Instanz her.

Installieren Sie pcs und corosync-qnetd:

sudo apt update && sudo apt -y install pcs corosync-qnetd

Starten Sie den Pacemaker/Corosync-Dienst für den Konfigurationssystem-Daemon (pcsd) und aktivieren Sie ihn beim Systemstart:
```
sudo service pcsd start
sudo update-rc.d pcsd enable
```
Legen Sie das Nutzerpasswort (haCLUSTER3) des Clusters für die Authentifizierung fest:
```
sudo bash -c "echo  hacluster:haCLUSTER3 | chpasswd"
```

Prüfen Sie den Status des Quorumgeräts:

sudo pcs qdevice status net --full

Sie erhalten folgende Ausgabe:

QNetd address:                  *:5403
TLS:                            Supported (client certificate required)
Connected clients:              0
Connected clusters:             0
Maximum send/receive size:      32768/32768 bytes

Einstellungen des Quorumgeräts auf database1 konfigurieren

Stellen Sie über SSH eine Verbindung zum database1-Knoten her.
Laden Sie die Metadatenvariablen aus der .varsrc-Datei:
```
source ~/.varsrc
```

Authentifizieren Sie den Quorumgeräteknoten für den Cluster:

sudo pcs cluster auth --name mysql_cluster ${QUORUM_INSTANCE_NAME} -u hacluster -p haCLUSTER3

Fügen Sie dem Cluster das Quorumgerät hinzu. Verwenden Sie den ffsplit-Algorithmus, der garantiert, dass der aktive Knoten auf Basis von 50 % der Stimmen oder mehr bestimmt wird:
```
sudo pcs quorum device add model net host=${QUORUM_INSTANCE_NAME} algorithm=ffsplit
```
Hinweis: Möglicherweise werden Fehlermeldungen angezeigt, die darauf hinweisen, dass corosync-qdevice nicht auf database1 und database2 aktiviert werden konnte. Ignorieren Sie diese Fehler vorerst.

Fügen Sie die Quorumeinstellung in corosync.conf ein:

sudo bash -c "cat <<EOF  > /etc/corosync/corosync.conf

totem {
    version: 2
    cluster_name: mysql_cluster
    transport: udpu
    interface {
        ringnumber: 0
        Bindnetaddr: ${DATABASE1_INSTANCE_IP}
        broadcast: yes
        mcastport: 5405
    }
}

quorum {
    provider: corosync_votequorum
    device {
        votes: 1
        model: net
        net {
            tls: on
            host: ${QUORUM_INSTANCE_NAME}
            algorithm: ffsplit
        }
    }
}

nodelist {
    node {
        ring0_addr: ${DATABASE1_INSTANCE_NAME}
        name: ${DATABASE1_INSTANCE_NAME}
        nodeid: 1
    }
    node {
        ring0_addr: ${DATABASE2_INSTANCE_NAME}
        name: ${DATABASE2_INSTANCE_NAME}
        nodeid: 2
    }
}

logging {
    to_logfile: yes
    logfile: /var/log/corosync/corosync.log
    timestamp: on
}

EOF"

Starten Sie den Dienst corosync neu, um die neue Einstellung des Quorumgeräts neu zu laden:
```
sudo service corosync restart
```
Starten Sie den corosync-Quorumgeräte-Daemon und richten Sie ihn beim Systemstart ein:
```
sudo service corosync-qdevice start
sudo update-rc.d corosync-qdevice defaults
```

Einstellungen des Quorumgeräts auf database2 konfigurieren

Stellen Sie über SSH eine Verbindung zum database2-Knoten her.
Laden Sie die Metadatenvariablen aus der .varsrc-Datei:
```
source ~/.varsrc
```

Fügen Sie eine Quorumeinstellung in corosync.conf ein:

sudo bash -c "cat <<EOF  > /etc/corosync/corosync.conf

totem {
    version: 2
    cluster_name: mysql_cluster
    transport: udpu
    interface {
        ringnumber: 0
        Bindnetaddr: ${DATABASE2_INSTANCE_IP}
        broadcast: yes
        mcastport: 5405
    }
}

quorum {
    provider: corosync_votequorum
    device {
        votes: 1
        model: net
        net {
            tls: on
            host: ${QUORUM_INSTANCE_NAME}
            algorithm: ffsplit
        }
    }
}

nodelist {
    node {
        ring0_addr: ${DATABASE1_INSTANCE_NAME}
        name: ${DATABASE1_INSTANCE_NAME}
        nodeid: 1
    }
    node {
        ring0_addr: ${DATABASE2_INSTANCE_NAME}
        name: ${DATABASE2_INSTANCE_NAME}
        nodeid: 2
    }
}

logging {
    to_logfile: yes
    logfile: /var/log/corosync/corosync.log
    timestamp: on
}

EOF"

Starten Sie den Dienst corosync neu, um die neue Einstellung des Quorumgeräts neu zu laden:
```
sudo service corosync restart
```
Starten Sie den Corosync-Quorumgeräte-Daemon und konfigurieren Sie ihn so, dass er beim Systemstart aktiviert wird:
```
sudo service corosync-qdevice start
sudo update-rc.d corosync-qdevice defaults
```

Clusterstatus prüfen

Im nächsten Schritt prüfen Sie, ob die Clusterressourcen online sind.

Stellen Sie über SSH eine Verbindung zur database1-Instanz her.

Prüfen Sie den Clusterstatus:

sudo pcs status

Sie erhalten folgende Ausgabe:

Cluster name: mysql_cluster
Stack: corosync
Current DC: database1 (version 1.1.16-94ff4df) - partition with quorum
Last updated: Sun Nov  4 01:49:18 2018
Last change: Sat Nov  3 15:48:21 2018 by root via cibadmin on database1

2 nodes configured
4 resources configured

Online: [ database1 database2 ]

Full list of resources:

 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database1 ]
     Slaves: [ database2 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database1
 mysql_service  (ocf::heartbeat:mysql): Started database1

Daemon Status:
  corosync: active/enabled
  pacemaker: active/enabled
  pcsd: active/enabled

Rufen Sie den Quorumstatus auf:

sudo pcs quorum status

Sie erhalten folgende Ausgabe:

Quorum information
------------------
Date:             Sun Nov  4 01:48:25 2018
Quorum provider:  corosync_votequorum
Nodes:            2
Node ID:          1
Ring ID:          1/24
Quorate:          Yes

Votequorum information
----------------------
Expected votes:   3
Highest expected: 3
Total votes:      3
Quorum:           2
Flags:            Quorate Qdevice

Membership information
----------------------
    Nodeid      Votes    Qdevice Name
         1          1    A,V,NMW database1 (local)
         2          1    A,V,NMW database2
         0          1            Qdevice

Rufen Sie den Quorumgerätestatus auf:

sudo pcs quorum device status

Sie erhalten folgende Ausgabe:

Qdevice information
-------------------
Model:                  Net
Node ID:                1
Configured node list:
    0   Node ID = 1
    1   Node ID = 2
Membership node list:   1, 2

Qdevice-net information
----------------------
Cluster name:           mysql_cluster
QNetd host:             qdevice:5403
Algorithm:              Fifty-Fifty split
Tie-breaker:            Node with lowest node ID
State:                  Connected

Internen Load-Balancer als Cluster-IP-Adresse konfigurieren

Öffnen Sie Cloud Shell:

Zu Cloud Shell

Erstellen Sie eine nicht verwaltete Instanzgruppe und fügen Sie ihr die Instanz database1 hinzu:

gcloud compute instance-groups unmanaged create ${DATABASE1_INSTANCE_NAME}-instance-group \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --description="${DATABASE1_INSTANCE_NAME} unmanaged instance group"

gcloud compute instance-groups unmanaged add-instances ${DATABASE1_INSTANCE_NAME}-instance-group \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --instances=${DATABASE1_INSTANCE_NAME}

Erstellen Sie eine nicht verwaltete Instanzgruppe und fügen Sie ihr die Instanz database2 hinzu:

gcloud compute instance-groups unmanaged create ${DATABASE2_INSTANCE_NAME}-instance-group \
    --zone=${DATABASE2_INSTANCE_ZONE} \
    --description="${DATABASE2_INSTANCE_NAME} unmanaged instance group"

gcloud compute instance-groups unmanaged add-instances ${DATABASE2_INSTANCE_NAME}-instance-group \
    --zone=${DATABASE2_INSTANCE_ZONE} \
    --instances=${DATABASE2_INSTANCE_NAME}

Erstellen Sie eine Systemdiagnose für port 3306:

gcloud compute health-checks create tcp mysql-backend-healthcheck \
    --port 3306

Erstellen Sie einen regionalen internen Back-End-Dienst:

gcloud compute backend-services create mysql-ilb \
    --load-balancing-scheme internal \
    --region ${CLUSTER_REGION} \
    --health-checks mysql-backend-healthcheck \
    --protocol tcp

Fügen Sie dem Backend-Dienst die beiden Instanzgruppen als Backends hinzu:

gcloud compute backend-services add-backend mysql-ilb \
    --instance-group ${DATABASE1_INSTANCE_NAME}-instance-group \
    --instance-group-zone ${DATABASE1_INSTANCE_ZONE} \
    --region ${CLUSTER_REGION}

gcloud compute backend-services add-backend mysql-ilb \
    --instance-group ${DATABASE2_INSTANCE_NAME}-instance-group \
    --instance-group-zone ${DATABASE2_INSTANCE_ZONE} \
    --region ${CLUSTER_REGION}

Erstellen Sie eine Weiterleitungsregel für den Load-Balancer:

gcloud compute forwarding-rules create mysql-ilb-forwarding-rule \
    --load-balancing-scheme internal \
    --ports 3306 \
    --network default \
    --subnet default \
    --region ${CLUSTER_REGION} \
    --address ${ILB_IP} \
    --backend-service mysql-ilb

Erstellen Sie eine Firewallregel, um eine Systemdiagnose für den internen Load-Balancer zu ermöglichen:

gcloud compute firewall-rules create allow-ilb-healthcheck \
    --direction=INGRESS --network=default \
    --action=ALLOW --rules=tcp:3306 \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=mysql

Den Status Ihres Load-Balancers finden Sie in der Google Cloud Console auf der Seite Load-Balancing.

Zur Seite "Load-Balancing"
Klicken Sie auf mysql-ilb:

Hinweis: Es kann einige Minuten dauern, bis die Instanz fehlerfrei ist.

Da der Cluster jeweils nur einer Instanz die Ausführung von MySQL erlaubt, ist aus Sicht des internen Load-Balancers nur eine einzige Instanz fehlerfrei.

Verbindung zum Cluster vom MySQL-Client aus herstellen

Stellen Sie über SSH eine Verbindung zur mysql-client-Instanz her.
Aktualisieren Sie die Paketdefinitionen:
```
sudo apt-get update
```
Installieren Sie den MySQL-Client:
```
sudo apt-get install -y mysql-client
```

Erstellen Sie eine Skriptdatei, die eine Tabelle erstellt und mit Beispieldaten füllt:

cat <<EOF > db_creation.sql
CREATE DATABASE source_db;
use source_db;
CREATE TABLE source_table
(
    id BIGINT NOT NULL AUTO_INCREMENT,
    timestamp timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    event_data float DEFAULT NULL,
    PRIMARY KEY (id)
);
DELIMITER $$
CREATE PROCEDURE simulate_data()
BEGIN
DECLARE i INT DEFAULT 0;
WHILE i < 100 DO
    INSERT INTO source_table (event_data) VALUES (ROUND(RAND()*15000,2));
    SET i = i + 1;
END WHILE;
END$$
DELIMITER ;
CALL simulate_data()
EOF

Erstellen Sie die Tabelle:

ILB_IP=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/ILB_IP" -H "Metadata-Flavor: Google")
mysql -u root -pDRBDha2 "-h${ILB_IP}" < db_creation.sql

Cluster testen

So können Sie die Hochverfügbarkeitsleistung des bereitgestellten Clusters testen:

Fahren Sie die Instanz database1 herunter, um zu testen, ob ein Failover der Masterdatenbank auf die Instanz database2 möglich ist.
Starten Sie die Instanz database1, um festzustellen, ob database1 wieder erfolgreich in den Cluster aufgenommen werden kann.
Fahren Sie die Instanz database2 herunter, um zu testen, ob ein Failover der Masterdatenbank auf die Instanz database1 möglich ist.
Starten Sie die Instanz database2, um festzustellen, ob database2 wieder erfolgreich in den Cluster aufgenommen werden kann und ob die Instanz database1 weiterhin die Masterrolle behält.
Erstellen Sie eine Netzwerkpartition zwischen database1 und database2, um ein Split-Brain-Problem zu simulieren.

Öffnen Sie Cloud Shell:

Zu Cloud Shell

Stoppen Sie die database1-Instanz:

gcloud compute instances stop ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE}

Prüfen Sie den Clusterstatus:

gcloud compute ssh ${DATABASE2_INSTANCE_NAME} \
    --zone=${DATABASE2_INSTANCE_ZONE} \
    --command="sudo pcs status"

Die Ausgabe sieht wie unten gezeigt aus. Prüfen Sie, ob die vorgenommenen Konfigurationsänderungen realisiert wurden:

2 nodes configured
4 resources configured

Online: [ database2 ]
OFFLINE: [ database1 ]

Full list of resources:

 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database2 ]
     Stopped: [ database1 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database2
 mysql_service  (ocf::heartbeat:mysql): Started database2

Daemon Status:
  corosync: active/enabled
  pacemaker: active/enabled
  pcsd: active/enabled

Starten Sie die database1-Instanz:

gcloud compute instances start ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE}

Prüfen Sie den Clusterstatus:

gcloud compute ssh ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --command="sudo pcs status"

Sie erhalten folgende Ausgabe:

2 nodes configured
4 resources configured

Online: [ database1 database2 ]

Full list of resources:

 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database2 ]
     Slaves: [ database1 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database2
 mysql_service  (ocf::heartbeat:mysql): Started database2

Daemon Status:
  corosync: active/enabled
  pacemaker: active/enabled
  pcsd: active/enabled

Stoppen Sie die database2-Instanz:

gcloud compute instances stop ${DATABASE2_INSTANCE_NAME} \
    --zone=${DATABASE2_INSTANCE_ZONE}

Prüfen Sie den Clusterstatus:

gcloud compute ssh ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --command="sudo pcs status"

Sie erhalten folgende Ausgabe:

2 nodes configured
4 resources configured

Online: [ database1 ]
OFFLINE: [ database2 ]

Full list of resources:

 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database1 ]
     Stopped: [ database2 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database1
 mysql_service  (ocf::heartbeat:mysql): Started database1

Daemon Status:
  corosync: active/enabled
  pacemaker: active/enabled
  pcsd: active/enabled

Starten Sie die database2-Instanz:

gcloud compute instances start ${DATABASE2_INSTANCE_NAME} \
    --zone=${DATABASE2_INSTANCE_ZONE}

Prüfen Sie den Clusterstatus:

gcloud compute ssh ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --command="sudo pcs status"

Sie erhalten folgende Ausgabe:

2 nodes configured
4 resources configured

Online: [ database1 database2 ]

Full list of resources:

 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database1 ]
     Slaves: [ database2 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database1
 mysql_service  (ocf::heartbeat:mysql): Started database1

Daemon Status:
  corosync: active/enabled
  pacemaker: active/enabled
  pcsd: active/enabled

Erstellen Sie eine Netzwerkpartition zwischen database1 und database2:

gcloud compute firewall-rules create block-comms \
    --description="no MySQL communications" \
    --action=DENY \
    --rules=all \
    --source-tags=mysql \
    --target-tags=mysql \
    --priority=800

Prüfen Sie nach einigen Minuten den Status des Clusters. Achten Sie darauf, dass database1 die primäre Rolle behält, da die Quorumrichtlinie der niedrigste ID-Knoten ist, der in der Netzwerkpartitionssituation zuerst kommt. In der Zwischenzeit wird der MySQL-Dienst database2 gestoppt. Dieser Quorummechanismus verhindert das Split-Brain-Problem, wenn die Netzwerkpartitionierung erfolgt.

gcloud compute ssh ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --command="sudo pcs status"

Sie erhalten folgende Ausgabe:

2 nodes configured
4 resources configured

Online: [ database1 ]
OFFLINE: [ database2 ]

Full list of resources:
 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database1 ]
     Stopped: [ database2 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database1
 mysql_service  (ocf::heartbeat:mysql): Started database1

Löschen Sie die Netzwerk-Firewallregel, um die Netzwerkpartition zu entfernen. Drücken Sie Y, wenn Sie dazu aufgefordert werden.
```
gcloud compute firewall-rules delete block-comms
```

Prüfen Sie, ob der Clusterstatus wieder normal ist:

gcloud compute ssh ${DATABASE1_INSTANCE_NAME} \
    --zone=${DATABASE1_INSTANCE_ZONE} \
    --command="sudo pcs status"

Sie erhalten folgende Ausgabe:

2 nodes configured
4 resources configured

Online: [ database1 database2 ]

Full list of resources:

 Master/Slave Set: primary_mysql [mysql_drbd]
     Masters: [ database1 ]
     Slaves: [ database2 ]
 mystore_FS     (ocf::heartbeat:Filesystem):    Started database1
 mysql_service  (ocf::heartbeat:mysql): Started database1

Hinweis: In der folgenden Ausgabe werden möglicherweise Zeitüberschreitungsfehler angezeigt. Dies ist lediglich ein Informationslog von Pacemaker, das keinerlei Auswirkungen auf die Datenbankfunktionalität hat. Sie können dieses Fehlerlog mit dem Befehl sudo pcs resource cleanup löschen.

Failed Actions:
* mysql_drbd_monitor_0 on database2 'unknown error' (1): call=66, status=Timed Out, exitreason='none',
    last-rc-change='Wed Mar 13 05:13:43 2019', queued=0ms, exec=30002ms

Stellen Sie über SSH eine Verbindung zur mysql-client-Instanz her.

Fragen Sie in Ihrer Shell die zuvor erstellte Tabelle ab:

ILB_IP=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/ILB_IP" -H "Metadata-Flavor: Google")

mysql -uroot "-h${ILB_IP}" -pDRBDha2 -e "select * from source_db.source_table LIMIT 10"

Die Ausgabe sollte zehn Datensätze im folgenden Format zur Überprüfung der Datenkonsistenz im Cluster auflisten:

+----+---------------------+------------+
| id | timestamp           | event_data |
+----+---------------------+------------+
|  1 | 2018-11-27 21:00:09 |    1279.06 |
|  2 | 2018-11-27 21:00:09 |    4292.64 |
|  3 | 2018-11-27 21:00:09 |    2626.01 |
|  4 | 2018-11-27 21:00:09 |     252.13 |
|  5 | 2018-11-27 21:00:09 |    8382.64 |
|  6 | 2018-11-27 21:00:09 |    11156.8 |
|  7 | 2018-11-27 21:00:09 |      636.1 |
|  8 | 2018-11-27 21:00:09 |    14710.1 |
|  9 | 2018-11-27 21:00:09 |    11642.1 |
| 10 | 2018-11-27 21:00:09 |    14080.3 |
+----+---------------------+------------+

Failover-Sequenz

Wenn der primäre Knoten im Cluster ausfällt, sieht die Failover-Sequenz so aus:

Die Verbindungen des Quorumgeräts und des Standby-Knotens zum primären Knoten werden unterbrochen.
Das Quorumgerät stimmt für den Standby-Knoten und der Standby-Knoten für sich selbst ab.
Der Standby-Knoten erreicht das Quorum.
Der Stand-by-Knoten wird zum primären Knoten hochgestuft.
Der neue primäre Knoten führt Folgendes aus:
1. Stuft DRBD zur primären Ressource hoch
2. Stellt das MySQL-Datenlaufwerk aus DRBD bereit
3. Startet MySQL
4. Erreicht für den Load-Balancer einen fehlerfreien Status
Der Load-Balancer beginnt, Traffic an den neuen primären Knoten zu senden.

Bereinigen

Projekt löschen

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Nächste Schritte

Mehr über DRBD erfahren
Mehr über Pacemaker erfahren
Mehr über Corosync Cluster Engine erfahren
Zusätzliche erweiterte Einstellungen für den MySQL-Server 5.6 im Administratorhandbuch für den MySQL-Server einsehen
Remotezugriff auf MySQL mithilfe der Anleitung unter Clientzugriff über private IP-Adressen auf MySQL in Compute Engine einrichten implementieren
Weitere Informationen zu MySQL finden Sie in der offiziellen MySQL-Dokumentation.
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center