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:

• Compute Engine
• Corosync Cluster Engine
• Debian 9
• DRBD
• MySQL 5.6
• Pacemaker
• Ubuntu 16

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.

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 der Google Cloud Platform eine Kostenschätzung für Ihre voraussichtliche Nutzung erstellen.

Hinweise

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Compute Engine API.

   Enable the API

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Compute Engine API.

   Enable the 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

1. Öffnen Sie Cloud Shell:

   Zu Cloud Shell

2. Erstellen Sie das Dienstkonto:

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

3. 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

1. 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
   

2. 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.

1. 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}"
   

2. 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}"
   

3. 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}
   

4. 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

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

   Zur Seite "VM-Instanzen"

2. 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.

3. 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
   

4. Laden Sie die Metadatenvariablen aus der Datei:

   source ~/.varsrc
   

5. 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.

6. Installieren Sie DRBD:

   sudo apt -y install drbd8-utils
   

7. Erstellen Sie die DRBD-Konfigurationsdatei:

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

8. 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"
   

9. Laden Sie das DRBD-Kernelmodul:

   sudo modprobe drbd
   

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

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

11. Erstellen Sie die DRBD-Ressource r0:

    sudo drbdadm create-md r0
    

12. Richten Sie DRBD ein:

    sudo drbdadm up r0
    

13. 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.

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

2. 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
   

3. Laden Sie die Metadatenvariablen aus der Datei:

   source ~/.varsrc
   

4. Formatieren Sie das Datenlaufwerk:

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

5. Installieren Sie die DRBD-Pakete:

   sudo apt -y install drbd8-utils
   

6. Erstellen Sie die DRBD-Konfigurationsdatei:

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

7. 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"
   

8. Laden Sie das DRBD-Kernelmodul:

   sudo modprobe drbd
   

9. Löschen Sie das Laufwerk /dev/sdb:

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

10. Erstellen Sie die DRBD-Ressource r0:

    sudo drbdadm create-md r0
    

11. Richten Sie DRBD ein:

    sudo drbdadm up r0
    

12. 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

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

2. Ü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
   

3. 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.

4. 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

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

2. 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'
   

3. 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
   

4. Aktualisieren Sie die Paketliste:

   sudo apt update
   

5. Installieren Sie den MySQL-Server:

   sudo apt -y install mysql-server
   

   Wenn Sie zur Eingabe eines Passworts aufgefordert werden, geben Sie DRBDha2 ein.

6. Stoppen Sie den MySQL-Server:

   sudo /etc/init.d/mysql stop
   

7. 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'
   

8. Erstellen Sie ein temporäres Verzeichnis für den MySQL-Server (in mysql.conf konfiguriert):

   sudo mkdir /srv/tmp
   sudo chmod 1777 /srv/tmp
   

9. Verschieben Sie alle MySQL-Daten in das DRBD-Verzeichnis /srv/mysql:

   sudo mv /var/lib/mysql /srv/mysql
   

10. Verknüpfen Sie /var/lib/mysql mit /srv/mysql unter dem DRBD-replizierten Speicher-Volume:

    sudo ln -s /srv/mysql /var/lib/mysql
    

11. Ändern Sie den Inhaber von /srv/mysql in einen mysql-Prozess:

    sudo chown -R mysql:mysql /srv/mysql
    

12. 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.

13. Starten Sie MySQL:

    sudo /etc/init.d/mysql start
    

14. 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;"
    

15. Deaktivieren Sie den automatischen MySQL-Start, um den sich die Clusterressourcenverwaltung kümmert:

    sudo update-rc.d -f mysql disable
    

Pacemaker auf database1 installieren

1. Laden Sie die Metadatenvariablen aus der zuvor erstellten .varsrc-Datei:

   source ~/.varsrc
   

2. Stoppen Sie den MySQL-Server:

   sudo /etc/init.d/mysql stop
   

3. Installieren Sie Pacemaker:

   sudo apt -y install pcs
   

4. 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
   

5. 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
   

6. Legen Sie das Nutzerpasswort des Clusters auf haCLUSTER3 für die Authentifizierung fest:

   sudo bash -c "echo  hacluster:haCLUSTER3 | chpasswd"
   

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

8. 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
   

9. 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.

10. Erstellen Sie das Dienstverzeichnis für corosync:

    sudo mkdir -p /etc/corosync/service.d
    

11. Konfigurieren Sie corosync so, dass es Pacemaker erkennt:

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

12. 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'
    

13. Starten Sie die Dienste corosync und pacemaker neu:

    sudo service corosync restart
    sudo service pacemaker restart
    

14. Installieren Sie das Corosync-Paket für Quorumgeräte:

    sudo apt -y install corosync-qdevice
    

15. 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

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

2. 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'
   

3. 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
   

4. Aktualisieren Sie die Paketliste:

   sudo apt update
   

5. Installieren Sie den MySQL-Server:

   sudo apt -y install mysql-server
   

   Wenn Sie zur Eingabe eines Passworts aufgefordert werden, geben Sie DRBDha2 ein.

6. Stoppen Sie den MySQL-Server:

   sudo /etc/init.d/mysql stop
   

7. 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'
   

8. 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
   

   Note: Das Verzeichnis /srv ist zu diesem Zeitpunkt nicht bereitgestellt. Der symbolische Link ist jedoch gültig, wenn ein Failover des Clusters ausgeführt wird.

9. Deaktivieren Sie den automatischen MySQL-Start, um den sich die Clusterressourcenverwaltung kümmert:

   sudo update-rc.d -f mysql disable
   

Pacemaker auf database2 installieren

1. Laden Sie die Metadatenvariablen aus der .varsrc-Datei:

   source ~/.varsrc
   

2. Installieren Sie Pacemaker:

   sudo apt -y install pcs
   

3. 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
   

4. 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
   

5. 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
   

6. 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"
   

7. 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"
   

8. Erstellen Sie das Corosync-Dienstverzeichnis:

   sudo mkdir /etc/corosync/service.d
   

9. Konfigurieren Sie corosync so, dass es Pacemaker erkennt:

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

10. 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'
    

11. Starten Sie die Dienste corosync und pacemaker neu:

    sudo service corosync restart
    sudo service pacemaker restart
    

12. Installieren Sie das Corosync-Paket für Quorumgeräte:

    sudo apt -y install corosync-qdevice
    

13. 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
    

14. Ü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

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

2. Laden Sie die Metadatenvariablen aus der .varsrc-Datei:

   source ~/.varsrc
   

3. Authentifizieren Sie sich bei den Clusterknoten:

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

4. Starten Sie den Cluster.

   sudo pcs cluster start --all
   

5. 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.

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

2. 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
   

3. Deaktivieren Sie STONITH, da Sie das Quorumgerät später bereitstellen:

   sudo pcs -f clust_cfg property set stonith-enabled=false
   

4. Deaktivieren Sie die quorumbezogenen Einstellungen. Sie richten den Quorumgeräteknoten später ein.

   sudo pcs -f clust_cfg property set no-quorum-policy=stop
   

5. Verhindern Sie, dass Pacemaker nach einer Wiederherstellung Ressourcen zurückverschiebt:

   sudo pcs -f clust_cfg resource defaults resource-stickiness=200
   

6. 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
   

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

8. 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"
   

9. 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
   

10. 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
    

11. 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
    

12. 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
    

13. 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
    

14. 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
    

15. Führen Sie ein Commit für die Änderungen am Cluster durch:

    sudo pcs cluster cib-push clust_cfg
    

16. 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

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

2. Installieren Sie pcs und corosync-qnetd:

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

3. 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
   

4. Legen Sie das Nutzerpasswort (haCLUSTER3) des Clusters für die Authentifizierung fest:

   sudo bash -c "echo  hacluster:haCLUSTER3 | chpasswd"
   

5. 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

1. Stellen Sie über SSH eine Verbindung zum database1-Knoten her.

2. Laden Sie die Metadatenvariablen aus der .varsrc-Datei:

   source ~/.varsrc
   

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

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

4. 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.

5. 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"
   

6. Starten Sie den Dienst corosync neu, um die neue Einstellung des Quorumgeräts neu zu laden:

   sudo service corosync restart
   

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

1. Stellen Sie über SSH eine Verbindung zum database2-Knoten her.

2. Laden Sie die Metadatenvariablen aus der .varsrc-Datei:

   source ~/.varsrc
   

3. 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"
   

4. Starten Sie den Dienst corosync neu, um die neue Einstellung des Quorumgeräts neu zu laden:

   sudo service corosync restart
   

5. 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.

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

2. 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
   

3. 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
   

4. 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

1. Öffnen Sie Cloud Shell:

   Zu Cloud Shell

2. 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}
   

3. 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}
   

4. Erstellen Sie eine Systemdiagnose für port 3306:

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

5. 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
   

6. 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}
   

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

8. 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
   

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

   Zur Seite "Load-Balancing"

10. 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

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

2. Aktualisieren Sie die Paketdefinitionen:

   sudo apt-get update
   

3. Installieren Sie den MySQL-Client:

   sudo apt-get install -y mysql-client
   

4. 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
   

5. 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.

---

1. Öffnen Sie Cloud Shell:

   Zu Cloud Shell

2. Stoppen Sie die database1-Instanz:

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

3. 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
   

4. Starten Sie die database1-Instanz:

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

5. 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
   

6. Stoppen Sie die database2-Instanz:

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

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

8. Starten Sie die database2-Instanz:

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

9. 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
   

10. 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
    

11. 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
    

12. 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
    

13. 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
    

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

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

1. Die Verbindungen des Quorumgeräts und des Standby-Knotens zum primären Knoten werden unterbrochen.
2. Das Quorumgerät stimmt für den Standby-Knoten und der Standby-Knoten für sich selbst ab.
3. Der Standby-Knoten erreicht das Quorum.
4. Der Stand-by-Knoten wird zum primären Knoten hochgestuft.
5. 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
6. Der Load-Balancer beginnt, Traffic an den neuen primären Knoten zu senden.

Bereinigen

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:
• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

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