Configuración de Replicación Maestro-Esclavo en MySQL: Guía de Configuración Completa

Introducción

La replicación maestro-esclavo de MySQL es un patrón de arquitectura de base de datos fundamental que permite que los datos de un servidor de base de datos MySQL (el maestro) se copien automáticamente a uno o más servidores de base de datos MySQL (los esclavos). Esta poderosa característica proporciona numerosos beneficios, incluyendo un rendimiento de lectura mejorado mediante la distribución de carga, redundancia de datos mejorada para recuperación ante desastres, y la capacidad de realizar copias de seguridad sin impactar el servidor de base de datos principal.

La replicación funciona registrando todos los cambios de datos en el servidor maestro en registros binarios, que luego se transmiten a los servidores esclavos y se reproducen para mantener los datos sincronizados. Este proceso asíncrono permite al maestro continuar operando independientemente mientras los esclavos se ponen al día con los cambios, convirtiéndolo en una solución ideal para aplicaciones con muchas lecturas donde la mayoría de las operaciones de base de datos son consultas SELECT.

Comprender e implementar correctamente la replicación de MySQL es crucial para construir infraestructuras de bases de datos escalables y de alta disponibilidad. Esta guía completa le guiará a través de cada paso de la configuración de replicación maestro-esclavo, desde la preparación inicial del servidor hasta el monitoreo y la solución de problemas, asegurando que pueda desplegar y gestionar con confianza entornos MySQL replicados.

Requisitos Previos

Antes de comenzar la configuración de replicación, asegúrese de tener lo siguiente:

Requisitos del Servidor

  • Dos o más servidores Linux (Ubuntu 20.04+, CentOS 7+ o Debian 10+)
  • Un servidor designado como maestro
  • Uno o más servidores designados como esclavos
  • Conectividad de red entre todos los servidores
  • Ancho de banda suficiente para el tráfico de replicación

Instalación de MySQL

  • MySQL 5.7+ o MySQL 8.0+ instalado en todos los servidores
  • MariaDB 10.3+ también es compatible
  • Acceso root o administrativo a MySQL en todos los servidores
  • Servicio MySQL ejecutándose y accesible

Requisitos del Sistema

  • Al menos 2GB de RAM por servidor (4GB+ recomendado)
  • Espacio en disco adecuado para almacenamiento de base de datos y registros binarios
  • Direcciones IP estáticas o nombres DNS confiables para todos los servidores
  • Relojes del sistema sincronizados (NTP recomendado)

Configuración del Firewall

  • Puerto 3306 abierto entre servidores maestro y esclavo
  • Acceso SSH (puerto 22) para gestión del servidor

Requisitos de Conocimiento

  • Habilidades básicas de administración de MySQL
  • Comprensión de sintaxis SQL
  • Competencia en línea de comandos de Linux
  • Conceptos básicos de redes

Comprender la Replicación de MySQL

Arquitectura de Replicación

La replicación de MySQL utiliza un enfoque basado en registro binario (binlog):

  1. El maestro registra todos los cambios de datos en registros binarios
  2. Los esclavos se conectan al maestro y solicitan eventos del registro binario
  3. El maestro envía eventos del registro binario a los esclavos conectados
  4. Los esclavos reciben eventos y los almacenan en registros de retransmisión
  5. Un hilo SQL en cada esclavo lee y ejecuta eventos del registro de retransmisión

Formatos de Replicación

MySQL soporta tres formatos de registro binario:

Replicación Basada en Sentencias (SBR): Registra sentencias SQL. Más compacto pero puede causar inconsistencias con funciones no determinísticas.

Replicación Basada en Filas (RBR): Registra cambios de filas individuales. Más confiable y consistente pero genera registros más grandes.

Replicación Mixta: Cambia automáticamente entre formatos basados en sentencias y basados en filas dependiendo de la operación.

Topología de Replicación

Las topologías de replicación comunes incluyen:

  • Maestro Único, Múltiples Esclavos: Un maestro maneja escrituras, múltiples esclavos manejan lecturas
  • Replicación en Cadena: El maestro replica a esclavos intermedios, que replican a esclavos adicionales
  • Maestro-Maestro: Dos servidores actuando como maestro y esclavo (configuración avanzada)

Configuración Paso a Paso

Paso 1: Configurar el Servidor Maestro

Primero, conéctese a su servidor maestro y modifique el archivo de configuración de MySQL.

Para Ubuntu/Debian:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Para CentOS/RHEL:

sudo nano /etc/my.cnf

Agregue o modifique la siguiente configuración bajo la sección [mysqld]:

[mysqld]
# Identificación del servidor
server-id = 1

# Habilitar registro binario
log_bin = /var/log/mysql/mysql-bin.log

# Formato de registro binario (ROW es recomendado)
binlog_format = ROW

# Bases de datos a replicar (opcional - omitir para replicar todas)
# binlog_do_db = database1
# binlog_do_db = database2

# Bases de datos a ignorar (opcional)
# binlog_ignore_db = mysql
# binlog_ignore_db = information_schema

# Período de retención del registro binario (días)
expire_logs_days = 10

# Tamaño máximo del registro binario antes de rotación
max_binlog_size = 100M

# Habilitar GTID para failover más fácil (MySQL 5.6+)
gtid_mode = ON
enforce_gtid_consistency = ON

# Asegurar que los registros binarios se sincronicen con el disco
sync_binlog = 1

# Configuraciones de InnoDB para durabilidad
innodb_flush_log_at_trx_commit = 1

Guarde el archivo y reinicie MySQL:

sudo systemctl restart mysql

Verifique que MySQL esté ejecutándose:

sudo systemctl status mysql

Paso 2: Crear Usuario de Replicación en el Maestro

Conéctese a MySQL en el servidor maestro:

mysql -u root -p

Cree un usuario de replicación dedicado con privilegios apropiados:

-- Crear usuario de replicación
CREATE USER 'replication_user'@'%' IDENTIFIED WITH mysql_native_password BY 'StrongPassword123!';

-- Otorgar privilegios de replicación
GRANT REPLICATION SLAVE ON *.* TO 'replication_user'@'%';

-- Aplicar cambios de privilegios
FLUSH PRIVILEGES;

Para mayor seguridad, restrinja el usuario de replicación a direcciones IP de esclavos específicos:

-- Crear usuario de replicación para esclavo específico
CREATE USER 'replication_user'@'192.168.1.20' IDENTIFIED WITH mysql_native_password BY 'StrongPassword123!';
GRANT REPLICATION SLAVE ON *.* TO 'replication_user'@'192.168.1.20';
FLUSH PRIVILEGES;

Paso 3: Registrar Posición del Registro Binario del Maestro

Mientras aún esté conectado al servidor MySQL maestro, bloquee las tablas y obtenga la posición del registro binario:

-- Bloquear tablas para prevenir escrituras
FLUSH TABLES WITH READ LOCK;

-- Obtener archivo de registro binario actual y posición
SHOW MASTER STATUS;

Verá una salida similar a:

+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000001 |      154 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+

Importante: Anote el nombre del File y el número de Position. Necesitará estos valores al configurar el esclavo. Mantenga la sesión MySQL abierta con las tablas bloqueadas mientras crea la copia de seguridad.

Paso 4: Crear Copia de Seguridad de la Base de Datos Maestra

Abra una nueva sesión de terminal al servidor maestro y cree una copia de seguridad:

# Crear directorio de respaldo
sudo mkdir -p /var/backups/mysql

# Crear volcado completo de base de datos
sudo mysqldump -u root -p \
    --all-databases \
    --master-data=2 \
    --single-transaction \
    --flush-logs \
    --triggers \
    --routines \
    --events \
    > /var/backups/mysql/master_backup.sql

Para bases de datos grandes, agregue compresión:

sudo mysqldump -u root -p \
    --all-databases \
    --master-data=2 \
    --single-transaction \
    --flush-logs \
    --triggers \
    --routines \
    --events | gzip > /var/backups/mysql/master_backup.sql.gz

Después de que se complete la copia de seguridad, vuelva a su sesión MySQL y desbloquee las tablas:

UNLOCK TABLES;

Paso 5: Transferir Copia de Seguridad al Servidor Esclavo

Transfiera el archivo de copia de seguridad a su servidor esclavo:

# Usando scp
scp /var/backups/mysql/master_backup.sql root@slave_server_ip:/tmp/

# O con compresión
scp /var/backups/mysql/master_backup.sql.gz root@slave_server_ip:/tmp/

Alternativamente, use rsync para archivos grandes:

rsync -avz --progress /var/backups/mysql/master_backup.sql root@slave_server_ip:/tmp/

Paso 6: Configurar el Servidor Esclavo

Conéctese a su servidor esclavo y edite el archivo de configuración de MySQL:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Agregue la siguiente configuración bajo [mysqld]:

[mysqld]
# Identificación del servidor (debe ser única)
server-id = 2

# Habilitar registro de retransmisión
relay-log = /var/log/mysql/mysql-relay-bin

# Registro binario en esclavo (opcional, para replicación en cascada)
log_bin = /var/log/mysql/mysql-bin.log
binlog_format = ROW

# Hacer esclavo de solo lectura para prevenir escrituras accidentales
read_only = 1

# Configuraciones del registro de retransmisión
relay_log_recovery = 1
relay_log_purge = 1

# Habilitar GTID (debe coincidir con el maestro)
gtid_mode = ON
enforce_gtid_consistency = ON

# Omitir errores (usar con precaución)
# slave_skip_errors = 1062,1032

# Filtros de replicación (opcional)
# replicate_do_db = database1
# replicate_ignore_db = mysql

Guarde la configuración y reinicie MySQL:

sudo systemctl restart mysql

Paso 7: Restaurar Copia de Seguridad del Maestro en el Esclavo

Conéctese al servidor esclavo e importe la copia de seguridad del maestro:

# Si la copia de seguridad está comprimida
gunzip /tmp/master_backup.sql.gz

# Importar la copia de seguridad
mysql -u root -p < /tmp/master_backup.sql

Este proceso puede tomar varios minutos u horas dependiendo del tamaño de la base de datos.

Paso 8: Configurar Replicación en el Esclavo

Conéctese a MySQL en el servidor esclavo:

mysql -u root -p

Configure el esclavo para conectarse al maestro:

-- Detener esclavo si está ejecutándose
STOP SLAVE;

-- Configurar conexión del maestro
CHANGE MASTER TO
    MASTER_HOST='master_server_ip',
    MASTER_USER='replication_user',
    MASTER_PASSWORD='StrongPassword123!',
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=154;

-- Iniciar replicación del esclavo
START SLAVE;

-- Verificar estado del esclavo
SHOW SLAVE STATUS\G

Si usa replicación basada en GTID (recomendado para MySQL 5.6+):

STOP SLAVE;

CHANGE MASTER TO
    MASTER_HOST='master_server_ip',
    MASTER_USER='replication_user',
    MASTER_PASSWORD='StrongPassword123!',
    MASTER_AUTO_POSITION=1;

START SLAVE;

SHOW SLAVE STATUS\G

Paso 9: Verificar Estado de Replicación

Verifique la salida del estado del esclavo para indicadores clave:

SHOW SLAVE STATUS\G

Busque estos valores críticos:

Slave_IO_Running: Yes
Slave_SQL_Running: Yes
Seconds_Behind_Master: 0
Last_IO_Error:
Last_SQL_Error:

Tanto Slave_IO_Running como Slave_SQL_Running deben ser "Yes" para una replicación exitosa.

Paso 10: Probar Replicación

En el servidor maestro, cree una base de datos y tabla de prueba:

-- Conectarse al maestro
CREATE DATABASE replication_test;
USE replication_test;

CREATE TABLE test_table (
    id INT PRIMARY KEY AUTO_INCREMENT,
    test_data VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO test_table (test_data) VALUES ('Test replication data');

En el servidor esclavo, verifique que los datos han sido replicados:

-- Conectarse al esclavo
USE replication_test;
SELECT * FROM test_table;

Debería ver los datos que fueron insertados en el maestro.

Configuración Avanzada

Configuración de Múltiples Esclavos

Para agregar esclavos adicionales, repita los pasos 6-10 para cada nuevo servidor esclavo, asegurando que cada uno tenga un server-id único.

Para el segundo esclavo, use:

server-id = 3

Para el tercer esclavo:

server-id = 4

Implementación de Replicación Semi-Síncrona

La replicación semi-síncrona proporciona mejor seguridad de datos asegurando que al menos un esclavo reciba el registro binario antes de que el maestro confirme:

En el maestro:

-- Instalar plugin
INSTALL PLUGIN rpl_semi_sync_master SONAME 'semisync_master.so';

-- Habilitar semi-sync
SET GLOBAL rpl_semi_sync_master_enabled = 1;

-- Establecer tiempo de espera (milisegundos)
SET GLOBAL rpl_semi_sync_master_timeout = 1000;

-- Verificar estado
SHOW VARIABLES LIKE 'rpl_semi_sync%';

En cada esclavo:

-- Instalar plugin
INSTALL PLUGIN rpl_semi_sync_slave SONAME 'semisync_slave.so';

-- Habilitar semi-sync
SET GLOBAL rpl_semi_sync_slave_enabled = 1;

-- Reiniciar hilos del esclavo
STOP SLAVE IO_THREAD;
START SLAVE IO_THREAD;

-- Verificar estado
SHOW VARIABLES LIKE 'rpl_semi_sync%';

Replicación Retardada

Configure replicación retardada para proteger contra eliminación accidental de datos:

-- En servidor esclavo
STOP SLAVE;

-- Establecer retraso de 1 hora
CHANGE MASTER TO MASTER_DELAY = 3600;

START SLAVE;

-- Verificar retraso
SHOW SLAVE STATUS\G

Replicación Paralela

Habilite replicación paralela para mejor rendimiento en sistemas multi-núcleo (MySQL 5.7+):

En esclavo:

STOP SLAVE SQL_THREAD;

SET GLOBAL slave_parallel_type = 'LOGICAL_CLOCK';
SET GLOBAL slave_parallel_workers = 4;

START SLAVE SQL_THREAD;

Monitoreo y Mantenimiento

Monitorear Retraso de Replicación

Cree un script de monitoreo:

sudo nano /usr/local/bin/check-replication-lag.sh

#!/bin/bash

SLAVE_STATUS=$(mysql -e "SHOW SLAVE STATUS\G")
LAG=$(echo "$SLAVE_STATUS" | grep "Seconds_Behind_Master" | awk '{print $2}')

if [ "$LAG" = "NULL" ]; then
    echo "ERROR: Replication is not running!"
    exit 2
elif [ "$LAG" -gt 300 ]; then
    echo "WARNING: Replication lag is ${LAG} seconds"
    exit 1
else
    echo "OK: Replication lag is ${LAG} seconds"
    exit 0
fi

Hacerlo ejecutable:

sudo chmod +x /usr/local/bin/check-replication-lag.sh

Monitorear Tamaño del Registro Binario

En el maestro, monitoree el uso de disco del registro binario:

sudo du -sh /var/log/mysql/

Configure purga automática del registro binario:

-- Mantener registros por 7 días
SET GLOBAL expire_logs_days = 7;

-- O especificar en días y horas (MySQL 8.0+)
SET GLOBAL binlog_expire_logs_seconds = 604800;

Crear Panel de Monitoreo

Monitoree métricas clave de replicación:

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

-- Ver posición del registro de retransmisión
SHOW RELAYLOG EVENTS;

-- Verificar posición del registro binario en el maestro
SHOW MASTER STATUS;

-- Ver errores de replicación
SELECT * FROM performance_schema.replication_applier_status_by_worker;

Verificación y Pruebas

Verificar Configuración del Esclavo

-- Verificar que el esclavo es de solo lectura
SHOW VARIABLES LIKE 'read_only';

-- Verificar estado de GTID
SHOW VARIABLES LIKE 'gtid%';

-- Verificar configuración del registro de retransmisión
SHOW VARIABLES LIKE 'relay%';

Probar Preparación para Failover

Simular falla del maestro:

# En el maestro
sudo systemctl stop mysql

En el esclavo, promover a maestro:

-- Detener replicación
STOP SLAVE;

-- Reiniciar estado del esclavo
RESET SLAVE ALL;

-- Deshabilitar modo de solo lectura
SET GLOBAL read_only = 0;

-- Verificar promoción
SHOW MASTER STATUS;

Verificar Consistencia de Datos

Use pt-table-checksum del Percona Toolkit:

# Instalar Percona Toolkit
sudo apt-get install percona-toolkit

# Ejecutar checksum
pt-table-checksum --host=master_server --databases=your_database

Solución de Problemas

Replicación No Se Inicia

Problema: Slave_IO_Running o Slave_SQL_Running muestra "No"

Solución: Verifique los registros de error y el estado del esclavo:

SHOW SLAVE STATUS\G

Mire los campos Last_IO_Error y Last_SQL_Error. Causas comunes incluyen:

# Verificar conectividad de red
ping master_server_ip
telnet master_server_ip 3306

# Verificar credenciales
mysql -h master_server_ip -u replication_user -p

# Verificar firewall
sudo ufw status
sudo firewall-cmd --list-all

Errores de Clave Duplicada

Problema: Error 1062: Duplicate entry

Solución: Omitir el error duplicado:

-- Detener esclavo
STOP SLAVE;

-- Omitir un error
SET GLOBAL sql_slave_skip_counter = 1;

-- Reiniciar esclavo
START SLAVE;

-- Verificar estado
SHOW SLAVE STATUS\G

Para replicación basada en GTID:

STOP SLAVE;
SET GTID_NEXT='problematic_gtid';
BEGIN;
COMMIT;
SET GTID_NEXT='AUTOMATIC';
START SLAVE;

Problemas de Retraso de Replicación

Problema: Valor alto de Seconds_Behind_Master

Solución: Investigar y optimizar:

-- Verificar consultas lentas en el esclavo
SET GLOBAL slow_query_log = 1;
SET GLOBAL long_query_time = 1;

-- Habilitar replicación paralela
STOP SLAVE SQL_THREAD;
SET GLOBAL slave_parallel_workers = 4;
START SLAVE SQL_THREAD;

-- Verificar bloqueos de tabla
SHOW PROCESSLIST;

Archivo de Registro Binario No Encontrado

Problema: Error: "Could not find first log file"

Solución: Reiniciar esclavo y reconfigurar:

STOP SLAVE;
RESET SLAVE;

-- Reconfigurar con posición actual del maestro
CHANGE MASTER TO
    MASTER_LOG_FILE='current_bin_file',
    MASTER_LOG_POS=current_position;

START SLAVE;

Tiempos de Espera de Conexión

Problema: Lost connection to MySQL server during query

Solución: Ajustar configuraciones de tiempo de espera:

-- En esclavo
SET GLOBAL slave_net_timeout = 60;

-- En my.cnf
[mysqld]
slave_net_timeout = 60

Mejores Prácticas

1. Usar Replicación Basada en GTID

Los Identificadores Globales de Transacción (GTIDs) simplifican la gestión de replicación y facilitan el failover. Siempre habilite GTID para nuevas configuraciones.

2. Implementar Monitoreo y Alertas

Configure monitoreo automatizado para:

  • Retraso de replicación (Seconds_Behind_Master)
  • Estado de hilos del esclavo (hilos IO y SQL)
  • Uso de disco del registro binario
  • Conectividad de red
  • Registros de error

3. Pruebas Regulares de Copias de Seguridad

Pruebe copias de seguridad del esclavo regularmente para asegurar que sean consistentes y restaurables. Realice restauraciones de prueba en un servidor separado mensualmente.

4. Documentar Su Topología de Replicación

Mantenga documentación clara de:

  • Roles de servidores y direcciones IP
  • Configuración de replicación
  • Procedimientos de failover
  • Información de contacto para administradores de base de datos

5. Asegurar Tráfico de Replicación

Use SSL/TLS para tráfico de replicación en producción:

CHANGE MASTER TO
    MASTER_HOST='master_server_ip',
    MASTER_USER='replication_user',
    MASTER_PASSWORD='password',
    MASTER_SSL=1,
    MASTER_SSL_CA='/path/to/ca.pem',
    MASTER_SSL_CERT='/path/to/client-cert.pem',
    MASTER_SSL_KEY='/path/to/client-key.pem';

6. Planificar para Capacidad

Monitoree espacio en disco para registros binarios y de retransmisión. Configure rotación y purga automática de registros para prevenir problemas de espacio en disco.

7. Usar Modo de Solo Lectura en Esclavos

Siempre configure esclavos como de solo lectura para prevenir escrituras accidentales:

SET GLOBAL read_only = 1;
SET GLOBAL super_read_only = 1;  -- MySQL 5.7.8+

8. Implementar Connection Pooling

Use connection pooling en su capa de aplicación para distribuir eficientemente consultas de lectura a través de múltiples esclavos.

9. Monitorear Impacto en Rendimiento

La replicación puede impactar el rendimiento del maestro. Monitoree:

  • Tasa de generación de registro binario
  • Uso de ancho de banda de red
  • I/O de disco para registros binarios

10. Tener un Plan de Failover

Documente y pruebe regularmente sus procedimientos de failover:

  • Promover un esclavo a maestro
  • Redirigir tráfico de aplicación
  • Reconfigurar esclavos restantes
  • Volver a poner en línea el antiguo maestro

Conclusión

La replicación maestro-esclavo de MySQL es una característica poderosa que habilita arquitecturas de bases de datos escalables y de alta disponibilidad. Siguiendo esta guía completa, ha aprendido cómo configurar, mantener y solucionar problemas de replicación de MySQL desde la configuración básica hasta configuraciones avanzadas.

Los logros clave incluyen configurar registro binario en el maestro, crear usuarios de replicación dedicados con privilegios apropiados, configurar uno o más servidores esclavos, implementar sistemas de monitoreo y alertas, y comprender cómo solucionar problemas comunes de replicación. También ha aprendido mejores prácticas para mantener un entorno de replicación saludable y asegurar consistencia de datos a través de su infraestructura de base de datos.

La replicación no es un reemplazo para copias de seguridad, sino más bien una tecnología complementaria que mejora la disponibilidad y escalabilidad de lectura. Continúe manteniendo copias de seguridad regulares de servidores maestro y esclavo, monitoree el retraso y estado de replicación regularmente, pruebe procedimientos de failover periódicamente y manténgase actualizado con parches de seguridad y actualizaciones de MySQL.

A medida que su infraestructura crece, considere topologías más avanzadas como replicación multi-fuente, replicación de grupo para failover automático, o soluciones híbridas combinando replicación con tecnologías de clustering. La base que ha construido con esta guía le servirá bien a medida que escale y evolucione su arquitectura de base de datos para satisfacer demandas crecientes.