Ce guide fournit un tutoriel complet, étape par étape, pour déployer un cluster MariaDB 12 disponibilité élevée sur trois zones de disponibilité dans un environnement Google Distributed Cloud (GDC) isolé. Cette architecture exploite Galera pour le clustering multimaster synchrone, HAProxy pour le routage intelligent des connexions et un service de vérification de l'état d'état Python léger pour gérer l'état des nœuds. En utilisant strictement des machines virtuelles (VM), cette implémentation contourne ouvertement les limites actuelles de GDC sous air gap concernant les clusters Kubernetes étendus entre plusieurs zones, ce qui garantit une résilience multizone complète sans risque de perte de données.
Voici le diagramme de l'architecture :

Avant de commencer
Déployer des VM
Suivez la procédure Créer et démarrer une instance de VM pour créer trois machines virtuelles dans les trois zones disponibles.
Configurez votre environnement local pour vous connecter aux VM en SSH avec une paire de clés : Se connecter à une VM
Vous en aurez besoin pour transférer manuellement les packages via SCP : Transférer des fichiers
Pour la validation, nous avons utilisé l'OS Ubuntu 22.04 et le type de machine n3-standard-2-gdc.
Pour un environnement de production, utilisez un type de machine disposant de plus de ressources.
Obtenez les adresses IP des VM à l'aide de la commande suivante :
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}"
Configurer les variables d'environnement
Tout au long de ce guide, vous utiliserez les variables d'environnement suivantes. Définissez-les dans votre session d'interface système de poste de travail local :
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
Configuration du réseau (règle de réseau de projet)
Si vous devez accéder à la base de données en dehors du projet ou de l'organisation, n'oubliez pas de configurer la règle de réseau de projet en conséquence.
Suivez les sections de la page Présentation des règles de réseau de projet en fonction du cas d'utilisation.
Préparation du logiciel sous air gap
Étant donné que les VM cibles n'ont pas accès à Internet, vous devez d'abord télécharger les artefacts sur une station de travail connectée.
Télécharger des packages via Docker
Exécutez la commande suivante depuis votre poste de travail local à l'aide d'un conteneur 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
"
Transférer et installer
Importez les fichiers .deb téléchargés dans /tmp/packages/ sur les trois VM et installez-les :
# 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
Assurez-vous que dpkg ne renvoie aucune erreur. Si c'est le cas, consultez les journaux pour voir quels packages deb sont manquants et incluez-les dans le téléchargement.
Initialisation de MariaDB et Galera
Configurer Galera sur toutes les VM
Commencez par arrêter le serveur mariadb :
sudo systemctl stop mariadb
Pour éviter les conflits de ports avec HAProxy (qui possédera 3306), remplacez le port par défaut de MariaDB par 3308. Modifiez /etc/mysql/mariadb.conf.d/60-galera.cnf sur toutes les 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
Amorcer le cluster
Sur la VM 1 UNIQUEMENT, initialisez le nouveau cluster :
sudo galera_new_cluster
Joindre des instances répliquées
Une fois que la VM 1 est en cours d'exécution, démarrez le service MariaDB sur la VM 2 et la VM 3 de manière séquentielle :
sudo systemctl start mariadb
Remarque : Attendez que chaque nœud soit entièrement synchronisé avant de démarrer le suivant.
Vérifier que la base de données haute disponibilité est opérationnelle
Sur n'importe quelle VM, exécutez la commande suivante :
sudo mariadb
Ensuite :
MariaDB [(none)]> SHOW STATUS LIKE 'wsrep_cluster_size';
+--------------------+-------+
| Variable_name | Value |
+--------------------+-------+
| wsrep_cluster_size | 3 |
+--------------------+-------+
1 row in set (0.001 sec)
La valeur attendue est 3.
Vérification de l'état de Python
Nous allons utiliser la bibliothèque http.server intégrée de Python et l'encapsuler dans un service systemd afin qu'elle s'exécute automatiquement en arrière-plan sur le port 9200.
Créer un utilisateur de base de données
Dans une VM, exécutez :
CREATE USER 'clustercheck_user'@'localhost' IDENTIFIED BY 'clustercheck_password';
FLUSH PRIVILEGES;
Créer le script Python
Sur les trois VM, créez le script /usr/local/bin/clustercheck.py :
sudo nano /usr/local/bin/clustercheck.py
Collez ce code exact :
#!/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()
Rendez-le exécutable :
sudo chmod +x /usr/local/bin/clustercheck.py
Créer le service systemd
Créez un fichier de service pour gérer le script Python :
sudo nano /etc/systemd/system/clustercheck.service
Collez cette configuration :
[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
Activez et démarrez le service :
sudo systemctl daemon-reload
sudo systemctl enable --now clustercheck.service
Vous pouvez le tester localement en exécutant curl -i http://127.0.0.1:9200.
Configuration de HAProxy
Suivez la même procédure pour obtenir les packages haproxy et les importer dans les VM.
Ensuite, configurez le fichier de configuration HAProxy sur chaque nœud pour gérer le routage du trafic.
Configurer HAProxy
Modifiez /etc/haproxy/haproxy.cfg sur toutes les 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
Important : Remplacez les adresses IP et les noms par les vôtres.
Redémarrez les nœuds un par un pour appliquer les modifications en toute sécurité :
sudo systemctl restart haproxy
sudo systemctl enable haproxy
Vérifier le comportement de routage de HAProxy
Exécutez les commandes suivantes pour vous assurer que HAProxy traite les lectures et les écritures conformément à notre topologie active/de sauvegarde.
Vérifier le routage des écritures (actif/sauvegarde) : HAProxy est configuré pour envoyer tout le trafic du port
3306strictement au nœud 1, sauf si le nœud 1 est mort. Exécutez cette commande trois ou quatre fois de suite à partir du terminal de la VM 2 ou de la VM 3 :mysql -h 127.0.0.1 -P 3306 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"Résultat attendu : chaque fois que vous l'exécutez, il doit renvoyer le nom d'hôte du nœud 1 (par exemple,
db-node-1). Même si vous interrogez le HAProxy local sur la VM 2 ou 3, il transfère correctement la connexion d'écriture sur le réseau vers le nœud 1.Vérifier le routage en lecture (Round-Robin) : HAProxy est configuré pour répartir uniformément le trafic du port
3307sur tous les nœuds entièrement synchronisés. Exécutez cette commande trois ou quatre fois de suite :mysql -h 127.0.0.1 -P 3307 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"Résultat attendu : la sortie doit parcourir de manière uniforme les noms d'hôte de votre cluster (par exemple,
db-node-1, puisdb-node-2, puisdb-node-3).
Configuration de l'équilibreur de charge mondial
Fournissez une adresse IP virtuelle (VIP) unique et stable pour vos applications à l'aide de l'équilibreur de charge L4 global GDC. Suivez la procédure Configurer des équilibreurs de charge globaux internes pour configurer l'équilibreur de charge L4 global interne et configurer vos VM pour qu'elles en soient la cible : Configurer des VM en tant que cible d'équilibreur de charge.
Tests de basculement automatisés
C'est le test le plus important. Vous devez prouver que si un nœud plante, le script Python le détecte et HAProxy redirige instantanément le trafic.
Étape A : Simuler une défaillance sur le nœud 1 : connectez-vous en SSH au nœud 1 et arrêtez complètement la base de données :
sudo systemctl stop mariadbÉtape B : Testez à nouveau le port d'écriture : depuis la VM 2 ou la VM 3, exécutez à nouveau le test d'écriture :
mysql -h 127.0.0.1 -P 3306 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"Résultat attendu : le nœud 2 (
db-node-2) doit être renvoyé instantanément. HAProxy a détecté que le nœud 1 était inactif via le script Python et a promu le premier serveur de sauvegarde.Étape C : Tester à nouveau le port de lecture : exécutez le test de lecture plusieurs fois :
mysql -h 127.0.0.1 -P 3307 -u clustercheck_user -pclustercheck_password -e "SELECT @@hostname;"Résultat attendu : l'alternance ne doit se faire qu'entre le nœud 2 et le nœud 3. Le nœud 1 a été complètement supprimé de la rotation.
Étape D : Récupérer et vérifier le failback : démarrez la sauvegarde MariaDB sur le nœud 1 :
sudo systemctl start mariadbAttendez quelques secondes que la synchronisation s'effectue (état 4), puis exécutez le test d'écriture (port 3306) une dernière fois. HAProxy devrait détecter automatiquement que le nœud 1 est de nouveau opérationnel et rediriger le trafic d'écriture du nœud 2 vers le nœud 1.