Estrategias de Replicación entre Centros de Datos

La replicación entre centros de datos asegura que tus datos estén disponibles en múltiples ubicaciones geográficas, proporcionando tanto recuperación ante desastres como disponibilidad mejorada. Esta guía integral cubre replicación de bases de datos, sincronización de almacenamiento y estrategias de conmutación por error para infraestructura distribuida.

Tabla de Contenidos

  1. Descripción General de Arquitectura de Replicación
  2. Replicación de MySQL
  3. Replicación de PostgreSQL
  4. Sincronización de Almacenamiento
  5. Consideraciones de Red
  6. Monitoreo de Replicación
  7. Estrategias de Conmutación por Error
  8. Resolución de Problemas
  9. Conclusión

Descripción General de Arquitectura de Replicación

La arquitectura de replicación entre centros de datos típicamente incluye:

  • Centro de datos primario: Aloja la base de datos principal y servidores de aplicación
  • Centro de datos secundario: Recibe datos replicados con retardo mínimo
  • Red: Enlace de replicación dedicado con ancho de banda suficiente
  • Monitoreo: Estado de sincronización en tiempo real y alertas
# Validación de topología de red de replicación
validate_replication_network() {
    local primary_ip="10.0.1.10"
    local secondary_ip="10.0.2.10"
    local replication_port=3306
    
    echo "Validando red de replicación"
    
    # Probar conectividad
    if nc -zv "$primary_ip" "$replication_port" 2>/dev/null; then
        echo "✓ Centro de datos primario alcanzable"
    else
        echo "✗ No se puede alcanzar centro de datos primario"
        return 1
    fi
    
    # Medir latencia
    latency=$(ping -c 5 "$secondary_ip" 2>/dev/null | tail -1 | awk -F'/' '{print $5}')
    echo "✓ Latencia de red: ${latency}ms"
    
    # Recomendado: < 50ms para replicación sincrónica
    if (( $(echo "$latency < 50" | bc -l) )); then
        echo "✓ Latencia aceptable para replicación sincrónica"
    else
        echo "⚠ Latencia alta - considerar replicación asincrónica"
    fi
}

validate_replication_network

Replicación de MySQL

La replicación de MySQL utiliza logs binarios (binlog) para replicar cambios de datos del servidor primario a servidores réplica.

Configuración del Servidor Primario

# Configurar servidor primario de MySQL
cat > /etc/mysql/mysql.conf.d/replication.cnf << 'EOF'
[mysqld]
# Habilitar binary logging
log_bin = /var/log/mysql/mysql-bin.log
binlog_format = ROW
binlog_row_image = FULL

# ID del servidor (debe ser único en topología de replicación)
server_id = 1

# Crear usuario de replicación
create_replication_user = 1

# Retención de binary log (7 días)
expire_logs_days = 7

# Opcional: Replicación semi-sincrónica (consistencia más fuerte)
plugin_load_add = semisync_master.so
rpl_semi_sync_master_enabled = 1
rpl_semi_sync_master_timeout = 10000

# Configuración de replicación
binlog_cache_size = 32768
max_binlog_size = 1073741824
EOF

# Reiniciar MySQL
systemctl restart mysql

# Verificar que la replicación está habilitada
mysql -u root -e "SHOW VARIABLES LIKE 'log_bin%';"
mysql -u root -e "SHOW VARIABLES LIKE 'server_id';"

Crear Usuario de Replicación

# Crear usuario de replicación dedicado con permisos apropiados
mysql -u root << 'EOF'
CREATE USER 'repl_user'@'10.0.2.%' IDENTIFIED BY 'secure_replication_password';
GRANT REPLICATION SLAVE ON *.* TO 'repl_user'@'10.0.2.%';
FLUSH PRIVILEGES;

-- Mostrar permisos para verificar
SHOW GRANTS FOR 'repl_user'@'10.0.2.%';
EOF

Crear Copia de Seguridad Base

# Crear copia de seguridad consistente para inicialización de réplica
mysql -u root << 'EOF'
-- Crear usuario de directorio de copia de seguridad si es necesario
CREATE USER 'backup'@'localhost' IDENTIFIED BY 'backup_password';
GRANT SELECT, RELOAD, LOCK TABLES, REPLICATION CLIENT ON *.* TO 'backup'@'localhost';
EOF

# Hacer copia de seguridad con mysqlbackup (o mysqldump)
mysqldump \
    -u backup \
    -p \
    --all-databases \
    --single-transaction \
    --master-data=2 \
    --quick \
    > /tmp/mysql-replication-base.sql

# Obtener posición del binary log desde copia de seguridad
grep -i "CHANGE MASTER" /tmp/mysql-replication-base.sql

# Comprimir y transferir a centro de datos secundario
gzip -c /tmp/mysql-replication-base.sql | \
    ssh -C [email protected] 'zcat > /tmp/mysql-replication-base.sql'

Configuración del Servidor Secundario

# Configurar servidor secundario (réplica) de MySQL
cat > /etc/mysql/mysql.conf.d/replication.cnf << 'EOF'
[mysqld]
# Habilitar binary logging en réplica (para replicación encadenada)
log_bin = /var/log/mysql/mysql-bin.log
binlog_format = ROW

# ID único del servidor
server_id = 2

# Modo de solo lectura (opcional pero recomendado para réplicas)
read_only = 1
super_read_only = 1

# Replicación paralela (aumentar throughput)
slave_parallel_workers = 8
slave_parallel_type = LOGICAL_CLOCK
slave_preserve_commit_order = 1

# Replicación semi-sincrónica
plugin_load_add = semisync_slave.so
rpl_semi_sync_slave_enabled = 1

# Relay log
relay_log = /var/log/mysql/mysql-relay-bin
relay_log_index = /var/log/mysql/mysql-relay-bin.index
EOF

systemctl restart mysql

Inicializar Réplica

# En servidor secundario: importar copia de seguridad base
mysql -u root < /tmp/mysql-replication-base.sql

# Configurar conexión de replicación
mysql -u root << 'EOF'
CHANGE MASTER TO
    MASTER_HOST='10.0.1.10',
    MASTER_USER='repl_user',
    MASTER_PASSWORD='secure_replication_password',
    MASTER_PORT=3306,
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=12345;

-- Iniciar replicación
START SLAVE;

-- Verificar estado de replicación
SHOW SLAVE STATUS\G
EOF

# Monitorear estado de réplica
watch_replica_status() {
    while true; do
        mysql -u root -e "SHOW SLAVE STATUS\G" | grep -E "Slave_IO_State|Seconds_Behind_Master|Last_Error"
        sleep 5
    done
}

Monitoreo de Replicación de MySQL

# Verificar retardo de replicación
check_replication_lag() {
    mysql -u root << 'EOF'
SHOW SLAVE STATUS\G | grep -E "Seconds_Behind_Master|Master_Server_Id|Slave_IO_Running|Slave_SQL_Running"
EOF
}

# Alerta sobre retardo de replicación
monitor_mysql_lag() {
    local lag_threshold=10  # segundos
    
    lag=$(mysql -u root -sNe "SHOW SLAVE STATUS\G" | grep "Seconds_Behind_Master:" | awk '{print $NF}')
    
    if [ -z "$lag" ] || [ "$lag" = "NULL" ]; then
        echo "ERROR: La replicación no está en ejecución"
        return 1
    fi
    
    if [ "$lag" -gt "$lag_threshold" ]; then
        echo "ADVERTENCIA: El retardo de replicación es ${lag}s (umbral: ${lag_threshold}s)"
    fi
}

# Crear alerta de monitoreo
cat > /usr/local/bin/mysql-replication-monitor.sh << 'EOF'
#!/bin/bash

ALERT_EMAIL="[email protected]"
LAG_THRESHOLD=60
ERROR_CHECK_SQL="SHOW SLAVE STATUS\G | grep Last_Error"

check_replica_health() {
    local status=$(mysql -u root -sNe "SHOW SLAVE STATUS\G")
    
    # Verificar si la replicación está en ejecución
    if ! echo "$status" | grep -q "Slave_IO_Running: Yes"; then
        echo "CRÍTICO: El hilo IO de replicación está detenido" | mail -s "Alerta de Replicación MySQL" "$ALERT_EMAIL"
    fi
    
    if ! echo "$status" | grep -q "Slave_SQL_Running: Yes"; then
        echo "CRÍTICO: El hilo SQL de replicación está detenido" | mail -s "Alerta de Replicación MySQL" "$ALERT_EMAIL"
    fi
    
    # Verificar retardo
    local lag=$(echo "$status" | grep "Seconds_Behind_Master:" | awk '{print $NF}')
    if [ "$lag" -gt "$LAG_THRESHOLD" ]; then
        echo "ADVERTENCIA: El retardo de replicación es ${lag}s" | mail -s "Alerta de Replicación MySQL" "$ALERT_EMAIL"
    fi
}

check_replica_health
EOF

chmod +x /usr/local/bin/mysql-replication-monitor.sh

Replicación de PostgreSQL

PostgreSQL utiliza archivado WAL (Write-Ahead Logging) y replicación de streaming para redundancia entre centros de datos.

Configuración del Servidor Primario

# Configurar PostgreSQL primario para replicación
cat > /etc/postgresql/14/main/postgresql.conf << 'EOF'
# Configuración de replicación
wal_level = replica
max_wal_senders = 5
max_replication_slots = 5
hot_standby = on
hot_standby_feedback = on

# Archivado de WAL
archive_mode = on
archive_command = 'test ! -f /var/lib/postgresql/wal_archive/%f && cp %p /var/lib/postgresql/wal_archive/%f'
archive_timeout = 300

# Configuración de conexión
listen_addresses = '*'
EOF

# Crear directorio de archivo WAL
mkdir -p /var/lib/postgresql/wal_archive
chown postgres:postgres /var/lib/postgresql/wal_archive
chmod 700 /var/lib/postgresql/wal_archive

# Configurar acceso de replicación
cat >> /etc/postgresql/14/main/pg_hba.conf << 'EOF'
# Permitir conexiones de replicación desde centro de datos secundario
host    replication     repl_user       10.0.2.0/24        md5
EOF

systemctl restart postgresql

Crear Usuario de Replicación

# Crear usuario de replicación
sudo -u postgres psql << 'EOF'
CREATE USER repl_user WITH REPLICATION ENCRYPTED PASSWORD 'secure_password';

-- Verificar que el rol fue creado
\du repl_user
EOF

Crear Copia de Seguridad Base

# Usar pg_basebackup para inicialización de réplica
pg_basebackup \
    -h 10.0.1.10 \
    -U repl_user \
    -D /var/lib/postgresql/14/replication-backup \
    -Xstream \
    -v

Configuración del Servidor Secundario

# Restaurar copia de seguridad base en secundario
sudo -u postgres pg_basebackup \
    -h 10.0.1.10 \
    -U repl_user \
    -D /var/lib/postgresql/14/main \
    -Xstream \
    -R \
    -v

# Crear recovery.conf (o postgresql.auto.conf)
cat > /var/lib/postgresql/14/main/recovery.conf << 'EOF'
# Replicación de streaming
primary_conninfo = 'host=10.0.1.10 port=5432 user=repl_user password=secure_password'
primary_slot_name = 'standby1'

# Configuración de recuperación
recovery_target_timeline = 'latest'
EOF

# Ajustar permisos
chown postgres:postgres /var/lib/postgresql/14/main/recovery.conf
chmod 600 /var/lib/postgresql/14/main/recovery.conf

# Iniciar PostgreSQL
systemctl start postgresql

Monitoreo de Replicación de PostgreSQL

# Verificar estado de replicación
check_postgresql_replication() {
    sudo -u postgres psql << 'EOF'
-- Verificar conexiones en standby
SELECT 
    pid,
    usename,
    application_name,
    client_addr,
    state,
    sync_state,
    flush_lsn,
    replay_lsn
FROM pg_stat_replication;

-- Verificar slots de replicación
SELECT 
    slot_name,
    slot_type,
    active,
    restart_lsn,
    confirmed_flush_lsn
FROM pg_replication_slots;

-- Verificar nivel de WAL
SHOW wal_level;
EOF
}

# Monitorear retardo de replicación
monitor_postgresql_lag() {
    sudo -u postgres psql -t << 'EOF'
SELECT 
    EXTRACT(EPOCH FROM (NOW() - pg_last_xact_replay_timestamp()))::INT as replication_lag_seconds;
EOF
}

# Script de monitoreo continuo
cat > /usr/local/bin/pg-replication-monitor.sh << 'EOF'
#!/bin/bash

ALERT_EMAIL="[email protected]"
LAG_THRESHOLD=60

monitor_lag() {
    local lag=$(sudo -u postgres psql -t -c \
        "SELECT EXTRACT(EPOCH FROM (NOW() - pg_last_xact_replay_timestamp()))::INT;")
    
    if [ -z "$lag" ] || [ "$lag" = "NULL" ]; then
        echo "CRÍTICO: No se puede determinar el retardo de replicación" | \
            mail -s "Alerta de Replicación PostgreSQL" "$ALERT_EMAIL"
        return 1
    fi
    
    if [ "$lag" -gt "$LAG_THRESHOLD" ]; then
        echo "ADVERTENCIA: El retardo de replicación PostgreSQL es ${lag}s" | \
            mail -s "Alerta de Replicación PostgreSQL" "$ALERT_EMAIL"
    fi
}

monitor_lag
EOF

chmod +x /usr/local/bin/pg-replication-monitor.sh

Sincronización de Almacenamiento

Para almacenamiento no relacionado con bases de datos, usar rsync y DRBD para sincronización eficiente entre centros de datos.

Replicación Basada en Rsync

# Configuración de rsync para sincronización continua
cat > /usr/local/bin/sync-storage.sh << 'EOF'
#!/bin/bash

SOURCE_DIR="/data/storage"
REMOTE_HOST="secondary-dc.com"
REMOTE_USER="backup"
REMOTE_DIR="/data/storage"
LOG_FILE="/var/log/storage-sync.log"
LOCK_FILE="/var/run/storage-sync.lock"

# Prevenir syncs concurrentes
if [ -f "$LOCK_FILE" ]; then
    echo "Sync ya está en ejecución" >> "$LOG_FILE"
    exit 1
fi
touch "$LOCK_FILE"
trap "rm -f $LOCK_FILE" EXIT

echo "[$(date)] Iniciando sincronización de almacenamiento" >> "$LOG_FILE"

# Realizar rsync con compresión y límite de ancho de banda
rsync -avz \
    --bwlimit=50000 \
    --delete \
    --exclude='.tmp/*' \
    --exclude='*.log' \
    "$SOURCE_DIR/" \
    "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR" \
    >> "$LOG_FILE" 2>&1

if [ $? -eq 0 ]; then
    echo "[$(date)] Sincronización completada exitosamente" >> "$LOG_FILE"
else
    echo "[$(date)] Sincronización fallida con estado $?" >> "$LOG_FILE"
fi
EOF

chmod +x /usr/local/bin/sync-storage.sh

# Programar replicación continua
(crontab -l 2>/dev/null; echo "*/15 * * * * /usr/local/bin/sync-storage.sh") | crontab -

Configuración DRBD (Replicación a Nivel de Bloque)

# Configuración de DRBD para replicación sincrónica
cat > /etc/drbd.d/storage.res << 'EOF'
resource storage {
    protocol C;  # Replicación sincrónica (espera confirmación)
    
    on primary-server {
        device /dev/drbd0;
        disk /dev/sda1;
        address 10.0.1.20:7788;
        meta-disk internal;
    }
    
    on secondary-server {
        device /dev/drbd0;
        disk /dev/sda1;
        address 10.0.2.20:7788;
        meta-disk internal;
    }
    
    net {
        # Ajuste de rendimiento
        max-buffers 8192;
        max-epoch-size 20000;
        sndbuf-size 512K;
        rcvbuf-size 512K;
        
        # Fencing
        fencing resource-only;
        
        # Integridad de datos
        verify-alg sha256;
    }
}
EOF

# Inicializar DRBD
drbdadm create-md storage
systemctl start drbd

# Promover primario
drbdadm primary storage --force

# Crear sistema de archivos en dispositivo DRBD
mkfs.ext4 /dev/drbd0

# Montar el sistema de archivos replicado
mkdir -p /data/replicated
mount /dev/drbd0 /data/replicated

# Verificar estado de replicación
cat /proc/drbd

Consideraciones de Red

Planificación de Ancho de Banda

# Calcular ancho de banda requerido para replicación
cat > /usr/local/bin/bandwidth-calculator.sh << 'EOF'
#!/bin/bash

# Parámetros de entrada
database_size_gb=$1        # Tamaño total de base de datos en GB
daily_change_percent=$2    # Porcentaje de datos que cambian diariamente (0-100)
replication_window_hours=$3  # Ventana de replicación disponible en horas

if [ -z "$database_size_gb" ] || [ -z "$daily_change_percent" ] || [ -z "$replication_window_hours" ]; then
    echo "Uso: $0 <size_gb> <change_percent> <window_hours>"
    echo "Ejemplo: $0 500 5 4"
    exit 1
fi

# Calcular throughput requerido
daily_change_bytes=$((database_size_gb * $daily_change_percent * 10737418))  # GB a bytes
throughput_bytes=$((daily_change_bytes / ($replication_window_hours * 3600)))
throughput_mbps=$((throughput_bytes * 8 / 1000000))

echo "Calculadora de Ancho de Banda de Replicación"
echo "=================================="
echo "Tamaño de Base de Datos: ${database_size_gb}GB"
echo "Cambio Diario: ${daily_change_percent}%"
echo "Ventana de Replicación: ${replication_window_hours} horas"
echo ""
echo "Throughput Requerido: ${throughput_mbps} Mbps"
echo "Velocidad de Enlace Recomendada: $((throughput_mbps * 2)) Mbps (con redundancia)"
EOF

chmod +x /usr/local/bin/bandwidth-calculator.sh
bash /usr/local/bin/bandwidth-calculator.sh 500 5 4

Optimización de Red

# Optimizar red para replicación
configure_network_optimization() {
    # Aumentar tamaños de buffer para window scaling de TCP
    sysctl -w net.core.rmem_max=134217728
    sysctl -w net.core.wmem_max=134217728
    sysctl -w net.ipv4.tcp_rmem="4096 87380 67108864"
    sysctl -w net.ipv4.tcp_wmem="4096 65536 67108864"
    
    # Habilitar window scaling de TCP
    sysctl -w net.ipv4.tcp_window_scaling=1
    
    # Optimizar para replicación (deshabilitar algoritmo de Nagle)
    sysctl -w net.ipv4.tcp_nodelay=1
    
    # Aumentar backlog
    sysctl -w net.core.netdev_max_backlog=5000
    
    # Persistir cambios
    cat >> /etc/sysctl.conf << 'EOF'
net.core.rmem_max=134217728
net.core.wmem_max=134217728
net.ipv4.tcp_rmem=4096 87380 67108864
net.ipv4.tcp_wmem=4096 65536 67108864
net.ipv4.tcp_window_scaling=1
net.ipv4.tcp_nodelay=1
net.core.netdev_max_backlog=5000
EOF
}

configure_network_optimization

Monitoreo de Replicación

# Monitoreo integral de replicación
cat > /usr/local/bin/replication-health.sh << 'EOF'
#!/bin/bash

ALERT_EMAIL="[email protected]"
METRICS_FILE="/var/metrics/replication-health.txt"

check_replication_health() {
    echo "=== Informe de Salud de Replicación ===" > "$METRICS_FILE"
    echo "Marca de tiempo: $(date)" >> "$METRICS_FILE"
    echo "" >> "$METRICS_FILE"
    
    # Verificar replicación de MySQL
    echo "Estado de Replicación de MySQL:" >> "$METRICS_FILE"
    mysql -u root -sNe "SHOW SLAVE STATUS\G" >> "$METRICS_FILE" 2>&1
    echo "" >> "$METRICS_FILE"
    
    # Verificar replicación de PostgreSQL
    echo "Estado de Replicación de PostgreSQL:" >> "$METRICS_FILE"
    sudo -u postgres psql -c "SELECT * FROM pg_stat_replication;" >> "$METRICS_FILE" 2>&1
    echo "" >> "$METRICS_FILE"
    
    # Verificar estado de DRBD
    if command -v drbdadm &> /dev/null; then
        echo "Estado de DRBD:" >> "$METRICS_FILE"
        cat /proc/drbd >> "$METRICS_FILE"
        echo "" >> "$METRICS_FILE"
    fi
    
    # Verificar conectividad de red
    echo "Conectividad de Red:" >> "$METRICS_FILE"
    ping -c 3 secondary-dc.com >> "$METRICS_FILE" 2>&1
    echo "" >> "$METRICS_FILE"
}

check_replication_health
cat "$METRICS_FILE"
EOF

chmod +x /usr/local/bin/replication-health.sh

Estrategias de Conmutación por Error

Conmutación por Error Automática con Keepalived

# Configurar conmutación por error automática con Keepalived
cat > /etc/keepalived/keepalived.conf << 'EOF'
global_defs {
    router_id DATABASE_HA
    script_user root
    enable_script_security
}

vrrp_script check_database {
    script "/usr/local/bin/check-db-health.sh"
    interval 5
    weight -20
    fall 3
    rise 2
}

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    
    authentication {
        auth_type PASS
        auth_pass database_failover
    }
    
    virtual_ipaddress {
        10.0.1.50/24
    }
    
    track_script {
        check_database
    }
    
    notify_master "/usr/local/bin/notify-master.sh"
    notify_backup "/usr/local/bin/notify-backup.sh"
    notify_fault "/usr/local/bin/notify-fault.sh"
}
EOF

# Script de verificación de salud
cat > /usr/local/bin/check-db-health.sh << 'EOF'
#!/bin/bash

# Verificar si la base de datos responde
mysql -u health_check -p'password' -e "SELECT 1" > /dev/null 2>&1
if [ $? -eq 0 ]; then
    exit 0  # Verificación de salud aprobada
else
    exit 1  # Verificación de salud fallida
fi
EOF

chmod +x /usr/local/bin/check-db-health.sh
systemctl restart keepalived

Procedimiento Manual de Conmutación por Error

# Procedimiento manual de conmutación por error
failover_to_secondary() {
    echo "Iniciando conmutación por error al centro de datos secundario"
    
    # 1. Detener replicación en secundario
    echo "Paso 1: Deteniendo replicación en secundario"
    mysql -h secondary-dc.com -u root << 'EOF'
STOP SLAVE;
SHOW SLAVE STATUS\G;
EOF
    
    # 2. Promover secundario a primario
    echo "Paso 2: Promoviendo secundario a primario"
    mysql -h secondary-dc.com -u root << 'EOF'
RESET SLAVE ALL;
SHOW MASTER STATUS\G;
EOF
    
    # 3. Actualizar cadenas de conexión de aplicación
    echo "Paso 3: Actualizando configuración de aplicación"
    # Actualizar /etc/myapp/database.conf
    # Reiniciar servicios de aplicación
    
    # 4. Apuntar DNS al nuevo primario
    echo "Paso 4: Actualizando registros DNS"
    # Actualizar DNS para apuntar database.example.com a secondary-dc.com
    
    # 5. Verificar conectividad
    echo "Paso 5: Verificando conectividad"
    mysql -h secondary-dc.com -u app_user -p << 'EOF'
SELECT @@hostname, @@server_id, NOW();
EOF
    
    echo "Conmutación por error completada"
}

Resolución de Problemas

# Problemas comunes de replicación y soluciones

# Problema 1: Retardo de replicación
diagnose_replication_lag() {
    echo "Diagnosticando retardo de replicación..."
    
    # Verificar posición de log binario en primario
    echo "Estado de Log Binario Primario:"
    mysql -h primary-dc.com -u root -e "SHOW MASTER STATUS\G"
    
    # Verificar posición de log relay en secundario
    echo "Estado de Log Relay Secundario:"
    mysql -h secondary-dc.com -u root -e "SHOW SLAVE STATUS\G"
    
    # Verificar queries de larga ejecución
    echo "Queries de larga ejecución en primario:"
    mysql -h primary-dc.com -u root -e "SHOW PROCESSLIST WHERE Time > 300\G"
}

# Problema 2: Error de replicación
fix_replication_error() {
    local secondary_host=$1
    
    echo "Intentando recuperarse de error de replicación..."
    
    # Obtener detalles del error
    mysql -h "$secondary_host" -u root << 'EOF'
SHOW SLAVE STATUS\G | grep -i error;
EOF
    
    # Saltar el error (¡usar con cuidado!)
    # mysql -h "$secondary_host" -u root -e "SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1; START SLAVE;"
    
    echo "Consultar detalles de error antes de saltar"
}

# Problema 3: Log binario no encontrado
recover_missing_binlog() {
    local primary_host=$1
    
    # Obtener logs binarios disponibles
    mysql -h "$primary_host" -u root -e "SHOW BINARY LOGS;"
    
    # Si el log requerido falta, puede ser necesario resincronizar desde cero
    echo "Si falta el log binario requerido, realizar resincronización completa:"
    echo "1. Tomar nueva copia de seguridad en primario"
    echo "2. Restaurar en secundario"
    echo "3. Reinicializar replicación"
}

Conclusión

La replicación efectiva entre centros de datos requiere:

  1. Replicación de Base de Datos: Usar replicación nativa (MySQL binlog, PostgreSQL WAL)
  2. Sincronización de Almacenamiento: Complementar con rsync o DRBD para datos no relacionados con bases de datos
  3. Optimización de Red: Asegurar ancho de banda suficiente y baja latencia
  4. Monitoreo: Verificaciones continuas de salud y monitoreo de retardo
  5. Pruebas: Simulacros regulares de conmutación por error para validar procedimientos
  6. Documentación: Mantener runbooks actualizados para tu configuración específica

Comenzar con replicación asincrónica para simplicidad, luego actualizar a replicación sincrónica para sistemas críticos donde la pérdida de datos es inaceptable. Recuerda que la replicación no es una copia de seguridad: mantén copias de seguridad separadas junto con la replicación.