Implementazione di riferimento del database MariaDB su GDC con air gap

Questa guida fornisce un tutorial completo e dettagliato per il deployment di un cluster MariaDB 12 ad alta affidabilità in tre zone di disponibilità in un ambiente Google Distributed Cloud (GDC) con air gap. Questa architettura sfrutta Galera per il clustering multi-master sincrono, HAProxy per il routing intelligente delle connessioni e un servizio di controllo di integrità Python leggero per gestire lo stato dei nodi. Utilizzando rigorosamente le macchine virtuali (VM), questa implementazione aggira apertamente le attuali limitazioni di GDC con air gap relative ai cluster estesi Kubernetes tra zone, garantendo una resilienza multizona completa senza rischiare la perdita di dati.

Questo è il diagramma dell'architettura:

Architettura con tre VM che esegue uno stack di servizi in colocation.

Prima di iniziare

Esegui il deployment delle VM

Segui Crea e avvia un'istanza VM per creare 3 macchine virtuali nelle 3 zone disponibili.

Configura l'ambiente locale per connetterti alle VM tramite SSH con una coppia di chiavi: Connettiti a una VM

Questo passaggio è necessario per eseguire manualmente l'SCP dei pacchetti: Trasferisci i file

Per la verifica abbiamo utilizzato il sistema operativo Ubuntu 22.04 e il tipo di macchina n3-standard-2-gdc. Per un ambiente di produzione, utilizza un tipo di macchina con più risorse.

Ottieni gli IP delle VM utilizzando:

VM_NAME=$1

if [[ -z "$VM_NAME" ]]; then
  echo "Error: VM_NAME must be provided."
  echo "Usage: $0 <VM_NAME>"
  exit 1
fi

# 1. Get External IP from 'instances list'
EXT_IP=$(gdcloud compute instances list | awk -v vm="${VM_NAME}" '$1 == vm {print $5}')

if [[ -z "$EXT_IP" ]]; then
  echo "Error: Could not find VM '${VM_NAME}' in the instance list."
  exit 1
fi

INTERNAL_IP=$(gdcloud compute instances describe "${VM_NAME}" | awk '/^status:/ {in_status=1} in_status && /- [0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/ {print $2; exit}' | cut -d'/' -f1)

if [[ -z "$INTERNAL_IP" ]]; then
  INTERNAL_IP="<Not assigned or not found>"
fi

echo "${VM_NAME}"
echo "External IP: ${EXT_IP}"
echo "Internal IP: ${INTERNAL_IP}"

Configura le variabili di ambiente

In questa guida utilizzerai le seguenti variabili di ambiente. Impostale nella sessione della shell della workstation locale:

export PROJECT_ID="your-project-id"
export VM1_NAME="db-node-1"
export VM2_NAME="db-node-2"
export VM3_NAME="db-node-3"
export VM1_IP="10.0.1.245" # Zone 1
export VM2_IP="10.0.1.241" # Zone 2
export VM3_IP="10.0.1.242" # Zone 3

Configurazione di rete (policy di rete del progetto)

Se devi accedere al database dall'esterno del progetto o dell'organizzazione, ricordati di configurare la PNP (policy di rete del progetto) di conseguenza.

Segui le sezioni della panoramica di PNP a seconda del caso d'uso.

Preparazione del software con air gap

Poiché le VM di destinazione non hanno accesso a internet, devi prima scaricare gli artefatti su una workstation connessa.

Scarica i pacchetti tramite Docker

Esegui questo comando dalla tua workstation locale utilizzando un container Docker Ubuntu:

mkdir -p ./packages
docker run --rm -v "$(pwd)/packages:/packages" ubuntu:22.04 bash -c "
  apt-get update
  apt-get install curl
  curl -LsS https://r.mariadb.com/downloads/mariadb_repo_setup | bash
  apt-get update
  cd packages
  PACKAGES='mariadb-server mariadb-client mariadb-common mysql-common'
  apt-get download \$(apt-cache depends --recurse --no-recommends --no-suggests --no-conflicts --no-breaks --no-replaces --no-enhances --no-pre-depends \${PACKAGES} | grep '^\w')
  apt-get download libpam-modules-bin
"

Trasferisci e installa

Carica i file .deb scaricati in /tmp/packages/ su tutte e tre le VM e installali:

# From local workstation
scp ./packages/*.deb ${VM1_IP}:/tmp/packages/
scp ./packages/*.deb ${VM2_IP}:/tmp/packages/
scp ./packages/*.deb ${VM3_IP}:/tmp/packages/

# On each VM, run:
sudo apt update
sudo dpkg -i /tmp/packages/*.deb

Assicurati che dpkg non restituisca errori. In questo caso, controlla i log per vedere quali pacchetti deb potrebbero mancare e includili nel download.

Inizializzazione di MariaDB e Galera

Configura Galera su tutte le VM

Innanzitutto, arresta il server mariadb:

sudo systemctl stop mariadb

Per evitare conflitti di porta con HAProxy (che sarà proprietario di 3306), modifica la porta predefinita di MariaDB in 3308. Modifica /etc/mysql/mariadb.conf.d/60-galera.cnf su tutte le VM:

[mysqld]
bind-address = 0.0.0.0
port = 3308
binlog_format = ROW
default-storage-engine = innodb
innodb_autoinc_lock_mode = 2

# Galera Provider Configuration
wsrep_on = ON
wsrep_provider = /usr/lib/galera/libgalera_smm.so
wsrep_cluster_name = "mariadb-ha-cluster"
wsrep_cluster_address = "gcomm://${VM1_IP},${VM2_IP},${VM3_IP}" # explicitly set the IPs, do not leave bash syntax / environment variable
wsrep_sst_method = rsync

# Node-specific (Update per VM)
wsrep_node_address = "${VM1_IP}" # explicitly set the IPs, do not leave bash syntax / environment variable. Change for VM 2 and VM 3
wsrep_node_name = "db-node-1"     # Change for VM 2 and VM 3

Esegui il bootstrap del cluster

SOLO su VM 1, inizializza il nuovo cluster:

sudo galera_new_cluster

Unisciti alle repliche

Una volta avviata correttamente VM 1, avvia il servizio MariaDB su VM 2 e VM 3 in sequenza:

sudo systemctl start mariadb

Nota: attendi che ogni nodo sia completamente sincronizzato prima di avviare il successivo.

Verifica che il database ad alta affidabilità sia attivo e in esecuzione

Su qualsiasi VM, esegui:

sudo mariadb

E poi:

MariaDB [(none)]> SHOW STATUS LIKE 'wsrep_cluster_size';
+--------------------+-------+
| Variable_name      | Value |
+--------------------+-------+
| wsrep_cluster_size | 3     |
+--------------------+-------+
1 row in set (0.001 sec)

Il valore previsto è 3.

Il controllo di integrità di Python

Utilizzeremo la libreria http.server integrata di Python e la inseriremo in un servizio systemd in modo che venga eseguita automaticamente in background sulla porta 9200.

Crea utente DB

In una VM, esegui:

CREATE USER 'clustercheck_user'@'localhost' IDENTIFIED BY 'clustercheck_password';
FLUSH PRIVILEGES;

Crea lo script Python

Su tutte e tre le VM, crea lo script /usr/local/bin/clustercheck.py:

sudo nano /usr/local/bin/clustercheck.py

Incolla esattamente questo codice:

#!/usr/bin/env python3
import mysql.connector
from http.server import BaseHTTPRequestHandler, HTTPServer

class HealthHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        try:
            # Connect to backend MariaDB port 3308
            db = mysql.connector.connect(user='clustercheck_user', password='clustercheck_password', host='127.0.0.1', port=3308)
            cursor = db.cursor()
            cursor.execute("SHOW GLOBAL STATUS LIKE 'wsrep_local_state_comment'")
            state = cursor.fetchone()

            # Galera 'Synced' state means the node is fully healthy
            if state == 'Synced':
                self.send_response(200)
                self.end_headers()
                self.wfile.write(b"Node is Healthy and Synced.\n")
            else:
                self.send_response(503)
                self.end_headers()
                self.wfile.write(b"Node is unavailable.\n")
        except Exception as e:
            self.send_response(503)
            self.end_headers()

HTTPServer(('0.0.0.0', 9200), HealthHandler).serve_forever()

Rendilo eseguibile:

sudo chmod +x /usr/local/bin/clustercheck.py

Crea il servizio systemd

Crea un file di servizio per gestire lo script Python:

sudo nano /etc/systemd/system/clustercheck.service

Incolla questa configurazione:

[Unit]
Description=MariaDB Galera Health Check
After=network.target mariadb.service

[Service]
Type=simple
User=root
ExecStart=/usr/local/bin/clustercheck.py
Restart=always

[Install]
WantedBy=multi-user.target

Attiva e avvia il servizio:

sudo systemctl daemon-reload
sudo systemctl enable --now clustercheck.service

Puoi testarlo localmente eseguendo curl -i http://127.0.0.1:9200.

Configurazione di HAProxy

Esegui la stessa procedura per ottenere i pacchetti haproxy e caricarli nelle VM. Quindi, configura il file di configurazione HAProxy su ogni nodo per gestire il routing del traffico.

Configura HAProxy

Modifica /etc/haproxy/haproxy.cfg su tutte le VM:

global
    log /dev/log local0
    user haproxy
    group haproxy
    daemon

defaults
    log global
    mode tcp
    option tcplog
    timeout connect 5000ms
    timeout client  50000ms
    timeout server  50000ms

# Write Port (Active/Backup)
listen galera_write
    bind *:3306
    mode tcp
    option httpchk GET /
    http-check expect status 200
    server db-node-1 10.0.1.245:3308 check port 9200
    server db-node-2 10.0.1.241:3308 check port 9200 backup
    server db-node-3 10.0.1.242:3308 check port 9200 backup

# Read Port (Round-Robin)
listen galera_read
    bind *:3307
    mode tcp
    balance roundrobin
    option httpchk GET /
    http-check expect status 200
    server db-node-1 10.0.1.245:3308 check port 9200
    server db-node-2 10.0.1.241:3308 check port 9200
    server db-node-3 10.0.1.242:3308 check port 9200

Importante: modifica gli IP e i nomi in modo che corrispondano ai tuoi.

Riavvia i nodi uno alla volta per applicare le modifiche in sicurezza:

sudo systemctl restart haproxy
sudo systemctl enable haproxy

Verifica il comportamento di routing di HAProxy

Esegui questi comandi per assicurarti che HAProxy elabori le letture e le scritture in base alla nostra topologia attiva/di backup.

  1. Verifica il routing di scrittura (attivo/backup): HAProxy è configurato per inviare tutto il traffico della porta 3306 rigorosamente al nodo 1, a meno che il nodo 1 non sia inattivo. Esegui questo comando 3 o 4 volte di seguito dal terminale della VM 2 o della VM 3:

    mysql -h 127.0.0.1 -P 3306 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"
    

    Risultato previsto: ogni volta che lo esegui, dovrebbe restituire il nome host del nodo 1 (ad es. db-node-1). Anche se stai eseguendo una query su HAProxy locale sulla VM 2 o 3, la connessione di scrittura viene inoltrata correttamente attraverso la rete al nodo 1.

  2. Verifica il routing di lettura (round robin): HAProxy è configurato per distribuire il traffico della porta 3307 in modo uniforme su tutti i nodi completamente sincronizzati. Esegui questo comando 3 o 4 volte di seguito:

    mysql -h 127.0.0.1 -P 3307 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"
    

    Risultato previsto: l'output deve scorrere in modo uniforme i nomi host del tuo cluster (ad es. db-node-1, poi db-node-2, poi db-node-3).

Configurazione del bilanciatore del carico globale

Fornisci un unico IP virtuale (VIP) stabile per le tue applicazioni utilizzando il bilanciatore del carico L4 globale di GDC. Segui Configura i bilanciatori del carico globali interni per configurare il bilanciatore del carico L4 globale interno e le VM in modo che siano il target: Configura le VM come target del bilanciatore del carico.

Test di failover automatico

Questo è il test più importante. Devi dimostrare che, se un nodo si arresta in modo anomalo, lo script Python lo rileva e HAProxy cambia percorso del traffico istantaneamente.

  1. Passaggio A: simula un errore sul nodo 1. Accedi tramite SSH al nodo 1 e arresta completamente il database:

    sudo systemctl stop mariadb
    
  2. Passaggio B: testa di nuovo la porta di scrittura. Dalla VM 2 o dalla VM 3, esegui di nuovo il test di scrittura:

    mysql -h 127.0.0.1 -P 3306 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"
    

    Risultato previsto: dovrebbe restituire immediatamente il nodo 2 (db-node-2). HAProxy ha rilevato che il nodo 1 era inattivo tramite lo script Python e ha promosso il primo server di backup.

  3. Passaggio C: testa di nuovo la porta di lettura. Esegui il test di lettura più volte:

    mysql -h 127.0.0.1 -P 3307 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"
    

    Risultato previsto: dovrebbe alternarsi solo tra il nodo 2 e il nodo 3. Il nodo 1 è stato completamente rimosso dalla rotazione.

  4. Passaggio D: recupera e verifica il failback: avvia il backup di MariaDB sul nodo 1:

    sudo systemctl start mariadb
    

    Attendi qualche secondo per la sincronizzazione (stato 4), quindi esegui il test di scrittura (porta 3306) un'ultima volta. HAProxy dovrebbe rilevare automaticamente che il nodo 1 è di nuovo integro e sottrarre il traffico di scrittura al nodo 2.