Deployment di un cluster MySQL 5.6 a disponibilità elevata con DRBD su Compute Engine

Last reviewed 2019-05-10 UTC

---

Questo tutorial illustra il processo di deployment di un database MySQL 5.6 per Google Cloud mediante Distributed Replicated Block Device (DRBD) e Compute Engine. DRBD è un sistema di archiviazione distribuito e replicato per la piattaforma Linux.

Questo tutorial è utile per amministratori di sistema, sviluppatori, ingegneri, database o DevOps Engineer. Potresti voler gestire la tua istanza MySQL invece di utilizzare il servizio gestito per diversi motivi, tra cui:

• Utilizzi istanze di MySQL in più regioni.
• Devi impostare parametri che non sono disponibili nella versione gestita di e MySQL.
• Vuoi ottimizzare il rendimento in modi non impostabili nella versione gestita.

DRBD fornisce la replica a livello di dispositivo di blocco. Ciò significa che non devi configurare la replica in MySQL stesso e puoi usufruire immediatamente dei vantaggi di DRBD, ad esempio il supporto del bilanciamento del carico di lettura e delle connessioni sicure.

Il tutorial utilizza quanto segue:

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

Non sono richieste conoscenze avanzate per utilizzare queste risorse, anche se questa questo documento fa riferimento a funzionalità avanzate come MySQL clustering, DRBD, configurazione e gestione delle risorse Linux.

Architettura

Pacemaker è un gestore delle risorse del cluster. Corosync è un pacchetto per la comunicazione e la partecipazione al cluster utilizzato da Pacemaker. In questo tutorial utilizzi DRBD per replicare il disco MySQL dall'istanza principale all'istanza di standby. Per consentire ai client di connettersi al cluster MySQL, esegui anche il deployment un bilanciatore del carico interno.

Esegui il deployment di un cluster gestito da Pacemaker di tre istanze di calcolo. Installa MySQL su due delle istanze, che fungono da istanze principali e di standby. La terza istanza funge da dispositivo di quorum.

In un cluster, ogni nodo vota per il nodo che dovrebbe essere il nodo attivo, è quello che esegue MySQL. In un cluster a due nodi, è necessario un solo voto per determinare il nodo attivo. In tal caso, il comportamento del cluster potrebbe generare cervello diviso problemi o tempi di inattività. I problemi di split-brain si verificano quando entrambi i nodi prendono il controllo perché in uno scenario con due nodi è necessario un solo voto. Si verifica un tempo di riposo quando il nodo che si arresta è quello configurato per essere sempre il principale in caso di perdita di connettività. Se i due nodi perdono connettività tra loro, c'è il rischio che più di un nodo del cluster presuma che si tratti del nodo attivo.

L'aggiunta di un dispositivo di quorum impedisce questa situazione. Un dispositivo per il quorum funge da mediatore e il suo unico compito è esprimere un voto. In questo modo, nella situazione in cui le istanze database1 e database2 non possono comunicare, questo quorum device comunica con una delle due istanze, mentre la maggior parte può raggiunto.

Il seguente diagramma mostra l'architettura del sistema descritto qui.

Obiettivi

• Crea le istanze del cluster.
• Installa MySQL e DRBD su due delle istanze.
• Configura la replica DRBD.
• Installa Pacemaker sulle istanze.
• Configura il clustering Pacemaker sulle istanze.
• Crea un'istanza e configurala come dispositivo di quorum.
• Testa il failover.

Costi

Utilizza la Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

Prima di iniziare

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 questo tutorial, inserisci i comandi utilizzando Cloud Shell, se non diversamente indicato.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Preparazione

In questa sezione, configuri un account di servizio, crei variabili di ambiente e prenoti indirizzi IP.

Configura un account di servizio per le istanze del cluster

1. Apri Cloud Shell:

   Apri Cloud Shell

2. Crea l'account di servizio:

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

3. Collega all'account di servizio i ruoli necessari per questo tutorial:

   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
   

Creare variabili di ambiente Cloud Shell

1. Crea un file con le variabili di ambiente richieste per questo tutorial:

   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. Carica le variabili di ambiente nella sessione corrente e imposta Cloud Shell in modo da caricarle automaticamente ai successivi accessi:

   source ~/.mysqldrbdrc
   grep -q -F "source ~/.mysqldrbdrc" ~/.bashrc || echo "source ~/.mysqldrbdrc" >> ~/.bashrc
   

Prenotare indirizzi IP

• In Cloud Shell, prenota un indirizzo IP interno per ciascuno dei tre nodi del cluster:

  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
  

Creazione delle istanze Compute Engine

Nei passaggi successivi, le istanze del cluster utilizzano Debian 9 e le istanze client Ubuntu 16.

1. In Cloud Shell, crea un'istanza MySQL denominata database1 in zona 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. Crea un'istanza MySQL denominata database2 nella zona 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. Crea un nodo di quorum per l'utilizzo da parte di Pacemaker nella zona 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. Crea un'istanza client MySQL:

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

Installazione e configurazione di DRBD

In questa sezione installerai e configurerai i pacchetti DRBD su database1 e database2 istanze, quindi avvia la replica DRBD da database1 a database2.

Configura DRBD su database1

1. Nella console Google Cloud, vai alla pagina Istanze VM:

   PAGINA ISTANZE VM

2. Nella riga dell'istanza database1, fai clic su SSH per connetterti all'istanza.

   Nota: durante questo tutorial, ti connetterai a varie istanze. Ripeti i due passaggi precedenti per connetterti a ciascuna istanza nel console Google Cloud mediante SSH.

3. Crea un file per recuperare e archiviare i metadati dell'istanza nell'ambiente variabili:

   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. Carica le variabili dei metadati dal file:

   source ~/.varsrc
   

5. Formatta il disco dati:

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

   Per una descrizione dettagliata delle opzioni mkfs.ext4, consulta la pagina di manual mkfs.ext4.

6. Installa DRBD:

   sudo apt -y install drbd8-utils
   

7. Crea il file di configurazione DRBD:

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

8. Crea un file di risorse DRBD:

   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. Carica il modulo kernel DRBD:

   sudo modprobe drbd
   

10. Cancella i contenuti del disco /dev/sdb:

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

11. Crea la risorsa DRBD r0:

    sudo drbdadm create-md r0
    

12. Avvia DRBD:

    sudo drbdadm up r0
    

13. Disabilita DRBD all'avvio del sistema, in modo che la risorsa del cluster il software di gestione di rete consente di visualizzare tutti i servizi necessari nell'ordine indicato:

    sudo update-rc.d drbd disable
    

Configura DRBD su database2

Ora puoi installare e configurare i pacchetti DRBD sull'istanza database2.

1. Connettiti all'istanza database2 tramite SSH.

2. Crea un file .varsrc per recuperare e archiviare i metadati delle istanze nelle variabili di ambiente:

   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. Carica le variabili dei metadati dal file:

   source ~/.varsrc
   

4. Formatta il disco dati:

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

5. Installa i pacchetti DRBD:

   sudo apt -y install drbd8-utils
   

6. Crea il file di configurazione DRBD:

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

7. Crea un file di risorse DRBD:

   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. Carica il modulo kernel DRBD:

   sudo modprobe drbd
   

9. Cancella il disco /dev/sdb:

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

10. Crea la risorsa DRBD r0:

    sudo drbdadm create-md r0
    

11. Avvia DRBD:

    sudo drbdadm up r0
    

12. Disattiva DRBD all'avvio del sistema, consentendo al software di gestione delle risorse del cluster di avviare tutti i servizi necessari in ordine:

    sudo update-rc.d drbd disable
    

Avvia replica DRBD da database1 a database2

1. Connettiti all'istanza database1 tramite SSH.

2. Sovrascrivi tutte le r0 risorse sul nodo primario:

   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. Verifica lo stato di DRBD:

   sudo cat /proc/drbd | grep ============
   

   L'output è simile al seguente:

   [===================>] sync'ed:100.0% (208/307188)M
   

   Nota: potrebbero essere necessari alcuni minuti prima che la sincronizzazione raggiunga il 100,0%.

4. Monta /dev/drbd su /srv:

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

Installazione di MySQL e Pacemaker

In questa sezione installerai MySQL e Pacemaker su ciascuna istanza.

Installa MySQL su database1

1. Connettiti all'istanza database1 tramite SSH.

2. Aggiorna il repository APT con le definizioni del pacchetto MySQL 5.6:

   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. Aggiungi le chiavi GPG al file APT repository.srv:

   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. Aggiorna l'elenco di pacchetti:

   sudo apt update
   

5. Installa il server MySQL:

   sudo apt -y install mysql-server
   

   Quando ti viene chiesto di inserire una password, inserisci DRBDha2.

6. Arresta il server MySQL:

   sudo /etc/init.d/mysql stop
   

7. Crea il file di configurazione MySQL:

   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. Crea una directory temporanea per il server MySQL (configurata in mysql.conf):

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

9. Sposta tutti i dati di MySQL nella directory DRBD /srv/mysql:

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

10. Collega /var/lib/mysql a /srv/mysql nel volume dello spazio di archiviazione replicato DRBD:

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

11. Cambia il proprietario di /srv/mysql in un processo mysql:

    sudo chown -R mysql:mysql /srv/mysql
    

12. Rimuovi i dati iniziali di InnoDB per assicurarti che il disco sia il più pulito possibile:

    sudo bash -c "cd /srv/mysql && rm ibdata1 && rm ib_logfile*"
    

    InnoDB è un motore di archiviazione per il sistema di gestione del database MySQL.

13. Avvia MySQL:

    sudo /etc/init.d/mysql start
    

14. Concedi l'accesso all'utente root per le connessioni remote in modo da testare il in un secondo momento:

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

15. Disattiva l'avvio automatico di MySQL, che viene gestito dalla gestione delle risorse del cluster:

    sudo update-rc.d -f mysql disable
    

Installa Pacemaker su database1

1. Carica le variabili dei metadati dal file .varsrc creato in precedenza:

   source ~/.varsrc
   

2. Arresta il server MySQL:

   sudo /etc/init.d/mysql stop
   

3. Installa il pacemaker:

   sudo apt -y install pcs
   

4. Attiva pcsd, corosync e pacemaker all'avvio del sistema su istanza principale:

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

5. Configura corosync in modo che inizi prima di pacemaker:

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

6. Imposta la password dell'utente del cluster su haCLUSTER3 per l'autenticazione:

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

7. Esegui lo script corosync-keygen per generare una chiave di autorizzazione del cluster a 128 bit e scrivila in/etc/corosync/authkey:

   sudo corosync-keygen -l
   

8. Copia authkey nell'istanza database2. Quando viene richiesto un passphrase, premi 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. Crea un file di configurazione del cluster Corosync:

   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"
   

   La sezione totem configura il protocollo Totem per una comunicazione affidabile. Corosync utilizza questa comunicazione per controllare il cluster e specifica in che modo i membri del cluster devono comunicare una con l'altra.

   Le impostazioni importanti della configurazione sono le seguenti:

   • transport: specifica la modalità unicast (udpu).
   • Bindnetaddr: specifica l'indirizzo di rete a cui si associa Corosync.
   • nodelist: definisce i nodi nel cluster e come possono essere raggiunto: in questo caso, i nodi database1 e database2.
   • quorum/two_node: per impostazione predefinita, in un cluster di due nodi nessun nodo acquisirà un quorum. Puoi eseguire l'override di questa opzione specificando il valore "1" per two_node nella sezione quorum.

   Questa configurazione ti consente di configurare il cluster e prepararlo per un utilizzo successivo quando aggiunti un terzo nodo che fungerà da dispositivo di quorum.

10. Crea la directory dei servizi per corosync:

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

11. Configura corosync in modo che sia consapevole di Pacemaker:

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

12. Attiva il servizio corosync per impostazione predefinita:

    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. Riavvia i servizi corosync e pacemaker:

    sudo service corosync restart
    sudo service pacemaker restart
    

14. Installa il pacchetto del dispositivo quorum Corosync:

    sudo apt -y install corosync-qdevice
    

15. Installa uno script shell per gestire gli eventi di errore DRBD:

    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
    

Installa MySQL su database2

1. Connettiti all'istanza database2 tramite SSH.

2. Aggiorna il repository APT con il pacchetto MySQL 5.6:

   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. Aggiungi le chiavi GPG al repository APT:

   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. Aggiorna l'elenco dei pacchetti:

   sudo apt update
   

5. Installa il server MySQL:

   sudo apt -y install mysql-server
   

   Quando ti viene chiesto di inserire una password, inserisci DRBDha2.

6. Arresta il server MySQL:

   sudo /etc/init.d/mysql stop
   

7. Crea il file di configurazione MySQL:

   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. Rimuovi i dati in /var/lib/mysql e aggiungi un link simbolico al punto di montaggio di destinazione per il volume DRBD replicato. Il volume DRBD (/dev/drbd0) verrà montato in /srv solo quando si verifica un failover.

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

   Nota: a questo punto, la directory /srv non è montata, ma viene utilizzata sarà valido in caso di failover del cluster.

9. Disattiva l'avvio automatico di MySQL, che viene gestito dalla gestione delle risorse del cluster:

   sudo update-rc.d -f mysql disable
   

Installa Pacemaker su database2

1. Carica le variabili dei metadati dal file .varsrc:

   source ~/.varsrc
   

2. Installa il pacemaker:

   sudo apt -y install pcs
   

3. Sposta il file authkey di Corosync che hai copiato in precedenza in /etc/corosync/:

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

4. Attiva pcsd, corosync e pacemaker all'avvio del sistema su istanza in standby:

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

5. Configura corosync in modo che inizi prima di pacemaker:

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

6. Imposta la password dell'utente del cluster per l'autenticazione. La password è la stessa (haCLUSTER3) che hai utilizzato per l'istanza database1.

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

7. Crea il file di configurazione 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. Crea la directory dei servizi Corosync:

   sudo mkdir /etc/corosync/service.d
   

9. Configura corosync in modo che sia consapevole di Pacemaker:

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

10. Attiva il servizio corosync per impostazione predefinita:

    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. Riavvia i servizi corosync e pacemaker:

    sudo service corosync restart
    sudo service pacemaker restart
    

12. Installa il pacchetto del dispositivo quorum Corosync:

    sudo apt -y install corosync-qdevice
    

13. Installa uno script shell per gestire gli eventi di errore DRBD:

    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. Controlla lo stato del cluster Corosync:

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

    L'output è simile al seguente:

    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)
    

Avvio del cluster

1. Connettiti all'istanza database2 tramite SSH.

2. Carica le variabili dei metadati dal file .varsrc:

   source ~/.varsrc
   

3. Esegui l'autenticazione sui nodi del cluster:

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

4. Avvia il cluster:

   sudo pcs cluster start --all
   

5. Verifica lo stato del cluster:

   sudo pcs status
   

   L'output è il seguente:

   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
   

Configurazione di Pacemaker per gestire le risorse del cluster

Quindi, configurerai Pacemaker con DRBD, disco, MySQL e quorum Google Cloud.

1. Connettiti all'istanza database1 tramite SSH.

2. Utilizza l'utilità Pacemaker pcs per mettere in coda diverse modifiche in un file e successivamente inviarle in modo atomico alla Cluster Information Base (CIB):

   sudo pcs cluster cib clust_cfg
   

3. Disattiva STONITH perché eseguirai il deployment del dispositivo di quorum in un secondo momento:

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

4. Disattiva le impostazioni relative al quorum. Configurerai il nodo del dispositivo di quorum in un secondo momento.

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

5. Per impedire a Pacemaker di spostare nuovamente le risorse dopo un recupero:

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

6. Crea la risorsa DRBD nel 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. Assicurati che alla risorsa DRBD sia assegnato un solo ruolo principale:

   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. Crea la risorsa del file system per montare il disco DRBD:

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

9. Configura il cluster per collocare la risorsa DRBD con il disco sulla stessa VM:

   sudo pcs -f clust_cfg constraint colocation add mystore_FS with primary_mysql INFINITY with-rsc-role=Master
   

10. Configura il cluster in modo che attivi la risorsa del disco solo dopo la promozione del primario DRBD:

    sudo pcs -f clust_cfg constraint order promote primary_mysql then start mystore_FS
    

11. Crea un servizio MySQL:

    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. Configura il cluster in modo da collocare la risorsa MySQL con il disco sulla stessa VM:

    sudo pcs -f clust_cfg constraint colocation add mysql_service with mystore_FS INFINITY
    

13. Assicurati che il file system DRBD preceda il servizio MySQL nella ordine di avvio:

    sudo pcs -f clust_cfg constraint order mystore_FS then mysql_service
    

14. Crea l'agente avvisi e aggiungi la patch al file di log come destinatario:

    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. Esegui il commit delle modifiche al cluster:

    sudo pcs cluster cib-push clust_cfg
    

16. Verifica che tutte le risorse siano online:

    sudo pcs status
    

    L'output è il seguente:

    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
    

Configurazione di un dispositivo di quorum

1. Connettiti all'istanza qdevice tramite SSH.

2. Installa pcs e corosync-qnetd:

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

3. Avvia il daemon del sistema di configurazione Pacemaker/Corosync (pcsd) e abilitarlo all'avvio del sistema:

   sudo service pcsd start
   sudo update-rc.d pcsd enable
   

4. Imposta la password utente del cluster (haCLUSTER3) per l'autenticazione:

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

5. Controlla lo stato del dispositivo di quorum:

   sudo pcs qdevice status net --full
   

   L'output è il seguente:

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

Configura le impostazioni del dispositivo per il quorum su database1

1. Connettiti al nodo database1 tramite SSH.

2. Carica le variabili dei metadati dal file .varsrc:

   source ~/.varsrc
   

3. Esegui l'autenticazione del nodo del dispositivo di quorum per il cluster:

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

4. Aggiungi il quorum device al cluster. Utilizza l'algoritmo ffsplit, che garantisce che il nodo attivo venga deciso in base al 50% o più dei voti:

   sudo pcs quorum device add model net host=${QUORUM_INSTANCE_NAME} algorithm=ffsplit
   

   Nota: potresti visualizzare messaggi di errore che indicano che non è stato possibile attivare corosync-qdevice su database1 e database2. Ignora gli errori relativi a per ora.

5. Aggiungi l'impostazione del quorum a corosync.conf:

   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. Riavvia il servizio corosync per ricaricare la nuova impostazione del quorum device:

   sudo service corosync restart
   

7. Avvia il daemon del quorum di dispositivo corosync e visualizzalo all'avvio del sistema:

   sudo service corosync-qdevice start
   sudo update-rc.d corosync-qdevice defaults
   

Configura le impostazioni del dispositivo per il quorum su database2

1. Connettiti al nodo database2 tramite SSH.

2. Carica le variabili dei metadati dal file .varsrc:

   source ~/.varsrc
   

3. Aggiungi un'impostazione di quorum a corosync.conf:

   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. Riavvia il servizio corosync per ricaricare la nuova impostazione del dispositivo di quorum:

   sudo service corosync restart
   

5. Avvia il daemon del dispositivo di quorum Corosync e configuralo in modo che venga avviato all'avvio del sistema:

   sudo service corosync-qdevice start
   sudo update-rc.d corosync-qdevice defaults
   

Verifica dello stato del cluster in corso...

Il passaggio successivo consiste nel verificare che le risorse del cluster siano online.

1. Connettiti all'istanza database1 tramite SSH.

2. Verifica lo stato del cluster:

   sudo pcs status
   

   L'output è simile al seguente:

   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. Mostra lo stato del quorum:

   sudo pcs quorum status
   

   L'output è il seguente:

   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. Mostra lo stato del dispositivo di quorum:

   sudo pcs quorum device status
   

   L'output è simile al seguente:

   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
   

Configurazione di un bilanciatore del carico interno come IP del cluster

1. Apri Cloud Shell:

   APRI Cloud Shell

2. Crea un gruppo di istanze non gestito e aggiungi l'istanza database1:

   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. Crea un gruppo di istanze non gestite e aggiungi al suo interno l'istanza database2:

   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. Crea un controllo di integrità per port 3306:

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

5. Crea un servizio di backend interno a livello di regione:

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

6. Aggiungi i due gruppi di istanze come backend al servizio di backend:

   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. Crea una regola di inoltro per il bilanciatore del carico:

   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. Crea una regola firewall per consentire un controllo di integrità del bilanciatore del carico interno:

   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. Per verificare lo stato del bilanciatore del carico, vai a Bilanciamento del carico nella console Google Cloud.

   APRI LA PAGINA BILANCAMENTO DEL CARICO

10. Fai clic su mysql-ilb:

    

    Nota: potrebbero essere necessari un paio di minuti prima che l'istanza diventi sana.

    Il cluster consente a una sola istanza di eseguire MySQL in un dato momento solo un'istanza è in stato integro dal bilanciatore del carico interno punto di vista.

    

Connessione al cluster dal client MySQL

1. Connettiti all'istanza mysql-client tramite SSH.

2. Aggiorna le definizioni del pacchetto:

   sudo apt-get update
   

3. Installa il client MySQL:

   sudo apt-get install -y mysql-client
   

4. Crea un file di script che crei e compili una tabella con dati di esempio:

   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. Crea la tabella:

   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
   

Test del cluster

Per testare la funzionalità HA del cluster di cui è stato eseguito il deployment, puoi eseguire i seguenti test:

• Arresta l'istanza database1 per verificare se il database master può eseguire il failover sull'istanza database2.
• Avvia l'istanza database1 per verificare se database1 può riuscire di partecipare di nuovo al cluster.
• Arresta l'istanza database2 per verificare se il database master può eseguire il failover all'istanza database1.
• Avvia l'istanza database2 per verificare se database2 può riuscire Rientra nel cluster e indica se l'istanza database1 mantiene ancora il master ruolo.
• Crea una partizione di rete tra database1 e database2 per simulare un problema di divisione del cervello.

---

1. Apri Cloud Shell:

   APRI Cloud Shell

2. Arresta l'istanza database1:

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

3. Controlla lo stato del cluster:

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

   L'output è simile al seguente. Verifica che la configurazione cambi che hai effettuato è avvenuto:

   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. Avvia l'istanza database1:

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

5. Controlla lo stato del cluster:

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

   L'output è simile al seguente:

   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. Arresta l'istanza database2:

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

7. Controlla lo stato del cluster:

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

   L'output è simile al seguente:

   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. Avvia l'istanza database2:

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

9. Controlla lo stato del cluster:

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

   L'output è il seguente:

   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. Crea una partizione di rete tra database1 e 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. Dopo un paio di minuti, controlla lo stato del cluster. Nota come database1 mantiene il proprio ruolo principale, perché il criterio di quorum è il primo ID nodo più basso in caso di partizione della rete. Nel frattempo, database2 Il servizio MySQL è stato interrotto. Questo meccanismo di quorum evita il problema di split-brain quando si verifica la partizione della rete.

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

    L'output è il seguente:

    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. Elimina la regola firewall di rete per rimuovere la partizione di rete. Premi Y quando richiesto.

    gcloud compute firewall-rules delete block-comms
    

13. Verifica che lo stato del cluster sia tornato alla normalità:

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

    L'output è simile al seguente:

    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
    

    Nota: potresti visualizzare errori di timeout nell'output seguente. È solo un registro informativo di Pacemaker che non influisce su qualsiasi funzionalità di database. Puoi ripulire questo log degli errori eseguendo il seguente comando: sudo pcs resource cleanup.

    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. Connettiti all'istanza mysql-client tramite SSH.

15. Nella shell, esegui una query sulla tabella che hai creato in precedenza:

    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"
    

    L'output dovrebbe elencare 10 record del seguente modulo, verificando la coerenza dei dati nel cluster:

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

Sequenza di failover

Se il nodo principale del cluster si arresta in modo anomalo, la sequenza di failover è la seguente:

1. Sia il dispositivo di quorum che il nodo in standby perdono la connettività con e al nodo primario.
2. Il quorum del dispositivo vota per il nodo in standby, mentre il nodo in standby vota per conto proprio.
3. Il quorum viene acquisito dal nodo in standby.
4. Il nodo in standby viene promosso a principale.
5. Il nuovo nodo principale esegue le seguenti operazioni:
   1. Promuove DRBD a principale
   2. Monta il disco dati MySQL da DRBD
   3. Avvia MySQL
   4. Diventa stabile per il bilanciatore del carico
6. Il bilanciatore del carico inizia a inviare traffico al nuovo nodo principale.

Esegui la pulizia

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:
• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.
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.

Passaggi successivi

• Scopri di più su DRBD.
• Scopri di più su Pacemaker.
• Scopri di più su Corosync Cluster Engine.
• Per impostazioni più avanzate del server MySQL 5.6, consulta il manuale di amministrazione del server MySQL.
• Se vuoi configurare l'accesso remoto a MySQL, consulta Come configurare l'accesso remoto a MySQL su Compute Engine.
• Per ulteriori informazioni su MySQL, consulta la documentazione ufficiale di MySQL.
• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Centro architetture cloud.