Implémentation de référence de la base de données MariaDB sur GDC sous air gap

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 :

Architecture à trois VM qui exécute une pile de services colocalisés.

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.

  1. Vérifier le routage des écritures (actif/sauvegarde) : HAProxy est configuré pour envoyer tout le trafic du port 3306 strictement 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.

  2. Vérifier le routage en lecture (Round-Robin) : HAProxy est configuré pour répartir uniformément le trafic du port 3307 sur 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, puis db-node-2, puis db-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.

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

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

  4. Étape D : Récupérer et vérifier le failback : démarrez la sauvegarde MariaDB sur le nœud 1 :

    sudo systemctl start mariadb
    

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