Implementação de referência do banco de dados MariaDB no GDC com isolamento físico

Este guia é um tutorial completo e detalhado para implantar um cluster do MariaDB 12 altamente disponível em três zonas de disponibilidade em um ambiente do Google Distributed Cloud (GDC) com isolamento físico. Essa arquitetura usa o Galera para clustering síncrono de vários mestres, o HAProxy para roteamento inteligente de conexões e um serviço de verificação de integridade do Python leve para gerenciar o estado do nó. Ao usar estritamente máquinas virtuais (VMs), essa implementação ignora abertamente as limitações atuais do GDC com isolamento físico em relação aos clusters estendidos do Kubernetes entre zonas, garantindo resiliência total em várias zonas sem risco de perda de dados.

Este é o diagrama de arquitetura:

Arquitetura de três VMs que executa uma pilha de serviços colocalizada.

Antes de começar

Implantar VMs

Siga as instruções em Criar e iniciar uma instância de VM para criar três máquinas virtuais nas três zonas disponíveis.

Configure o ambiente local para acessar as VMs por SSH com um par de chaves: Conectar-se a uma VM

Isso será necessário para fazer o SCP manual dos pacotes: Transferir arquivos

Para a verificação, usamos o SO Ubuntu 22.04 e o tipo de máquina n3-standard-2-gdc. Para um ambiente de produção, use um tipo de máquina com mais recursos.

Consiga os IPs das VMs usando:

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

Configure as variáveis de ambiente

Neste guia, você vai usar as seguintes variáveis de ambiente. Defina-as na sessão de shell da estação de trabalho 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

Configuração de rede (política de rede do projeto)

Se você precisar acessar o banco de dados fora do projeto ou da organização, configure a PNP (política de rede do projeto) de acordo.

Siga as seções de Visão geral do PNP dependendo do caso de uso.

Preparação de software com isolamento físico

Como as VMs de destino não têm acesso à Internet, primeiro é necessário baixar os artefatos em uma estação de trabalho conectada.

Fazer o download de pacotes pelo Docker

Execute o seguinte na estação de trabalho local usando um contêiner do Docker do 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
"

Transferir e instalar

Faça upload dos arquivos .deb baixados para /tmp/packages/ em todas as três VMs e instale-os:

# 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

Verifique se o dpkg não retorna erros. Se isso acontecer, verifique os registros para ver quais pacotes deb estão faltando e inclua-os no download.

Inicialização do MariaDB e do Galera

Configurar o Galera em todas as VMs

Primeiro, interrompa o servidor mariadb:

sudo systemctl stop mariadb

Para evitar conflitos de porta com o HAProxy (que será o proprietário de 3306), mude a porta padrão do MariaDB para 3308. Edite /etc/mysql/mariadb.conf.d/60-galera.cnf em todas as VMs:

[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

Inicializar o cluster

SOMENTE na VM 1, inicialize o novo cluster:

sudo galera_new_cluster

Mesclar réplicas

Depois que a VM 1 estiver em execução, inicie o serviço MariaDB na VM 2 e na VM 3 sequencialmente:

sudo systemctl start mariadb

Observação: aguarde a sincronização completa de cada nó antes de iniciar o próximo.

Verificar se o banco de dados de alta disponibilidade está em execução

Em qualquer VM, execute:

sudo mariadb

Depois:

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

O valor esperado é 3.

A verificação de integridade do Python

Vamos usar a biblioteca http.server integrada do Python e envolvê-la em um serviço systemd para que ela seja executada automaticamente em segundo plano na porta 9200.

Criar usuário do banco de dados

Em uma VM, execute:

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

Criar o script em Python

Em todas as três VMs, crie o script /usr/local/bin/clustercheck.py:

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

Cole este código:

#!/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()

Torne-o executável:

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

Criar o serviço systemd

Crie um arquivo de serviço para gerenciar o script Python:

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

Cole esta configuração:

[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

Ative e inicie o serviço:

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

Para testar localmente, execute curl -i http://127.0.0.1:9200.

Configuração do HAProxy

Siga o mesmo procedimento para receber os pacotes haproxy e fazer upload deles nas VMs. Em seguida, configure o arquivo de configuração do HAProxy em cada nó para processar o roteamento de tráfego.

Configurar o HAProxy

Edite /etc/haproxy/haproxy.cfg em todas as VMs:

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: mude os IPs e os nomes para que correspondam aos seus.

Reinicie os nós um por um para aplicar as mudanças com segurança:

sudo systemctl restart haproxy
sudo systemctl enable haproxy

Verificar o comportamento de roteamento do HAProxy

Execute os comandos a seguir para garantir que o HAProxy esteja processando leituras e gravações de acordo com nossa topologia ativa/de backup.

  1. Verificar o roteamento de gravação (ativo/backup): o HAProxy está configurado para enviar todo o tráfego da porta 3306 estritamente para o Nó 1, a menos que ele esteja inativo. Execute este comando três ou quatro vezes seguidas no terminal da VM 2 ou da VM 3:

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

    Resultado esperado: sempre que você executar o comando, ele vai retornar o nome do host do Nó 1 (por exemplo, db-node-1). Mesmo que você esteja consultando o HAProxy local na VM 2 ou 3, ele vai encaminhar corretamente a conexão de gravação pela rede para o Nó 1.

  2. Verificar o roteamento de leitura (Round-Robin): o HAProxy está configurado para distribuir o tráfego da porta 3307 de maneira uniforme entre todos os nós totalmente sincronizados. Execute este comando três ou quatro vezes seguidas:

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

    Resultado esperado: a saída precisa percorrer de maneira uniforme os nomes de host do cluster (por exemplo, db-node-1, depois db-node-2 e, em seguida, db-node-3).

Configuração do balanceador de carga global

Forneça um IP virtual (VIP) único e estável para seus aplicativos usando o balanceador de carga global L4 do GDC. Siga as instruções em Configurar balanceadores de carga globais internos para configurar o balanceador de carga L4 global interno e as VMs como destino dele: Configurar VMs como destino do balanceador de carga.

Teste de failover automatizado

Este é o teste mais importante. Você precisa provar que, se um nó falhar, o script Python vai detectar isso e o HAProxy vai redirecionar o tráfego instantaneamente.

  1. Etapa A: simular uma falha no Nó 1: use SSH para acessar o Nó 1 e interrompa completamente o banco de dados:

    sudo systemctl stop mariadb
    
  2. Etapa B: testar a porta de gravação novamente: na VM 2 ou VM 3, execute o teste de gravação novamente:

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

    Resultado esperado: ele deve retornar instantaneamente o nó 2 (db-node-2). O HAProxy percebeu que o nó 1 estava inativo pelo script Python e promoveu o primeiro servidor de backup.

  3. Etapa C: testar a porta de leitura novamente: execute o teste de leitura várias vezes:

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

    Resultado esperado: o ciclo deve ser apenas entre o Nó 2 e o Nó 3. O nó 1 foi completamente removido da rotação.

  4. Etapa D: recuperar e verificar o failback: inicie o backup do MariaDB no Nó 1:

    sudo systemctl start mariadb
    

    Aguarde alguns segundos para que ele seja sincronizado (estado 4) e execute o teste de gravação (porta 3306) uma última vez. O HAProxy deve detectar automaticamente que o Nó 1 está íntegro novamente e roubar o tráfego de gravação de volta do Nó 2.