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:

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.
Verifica il routing di scrittura (attivo/backup): HAProxy è configurato per inviare tutto il traffico della porta
3306rigorosamente 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.Verifica il routing di lettura (round robin): HAProxy è configurato per distribuire il traffico della porta
3307in 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, poidb-node-2, poidb-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.
Passaggio A: simula un errore sul nodo 1. Accedi tramite SSH al nodo 1 e arresta completamente il database:
sudo systemctl stop mariadbPassaggio 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.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.
Passaggio D: recupera e verifica il failback: avvia il backup di MariaDB sul nodo 1:
sudo systemctl start mariadbAttendi 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.