Fundamentos de la Replicación de MySQL

Introducción

En este laboratorio, aprenderá los fundamentos de la replicación de MySQL. La replicación es un proceso que permite mantener copias de una base de datos MySQL en múltiples servidores. Esto se utiliza comúnmente para el balanceo de carga, copias de seguridad de datos y alta disponibilidad.

Utilizará Docker para crear una configuración de replicación maestro-esclavo realista con dos contenedores MySQL separados. Primero, iniciará y verificará un contenedor maestro, que está preconfigurado con el registro binario (binary logging) habilitado. Creará un usuario de replicación especial en el maestro. Luego, configurará el segundo contenedor para que actúe como esclavo, lo conectará al maestro y verificará que los datos se sincronicen correctamente. Este enfoque práctico le ayudará a comprender los pasos clave involucrados en la gestión de un entorno de replicación de MySQL en el mundo real.

Configurar el Entorno Docker

En este primer paso, configurará los contenedores Docker necesarios para el entorno de replicación maestro-esclavo. Creará una red dedicada y lanzará dos contenedores MySQL.

1. Crear una Red Docker:

   Una red dedicada permite que los contenedores se comuniquen entre sí por nombre. Cree una red llamada mysql-net.

   docker network create mysql-net
   

2. Iniciar el Contenedor Maestro MySQL:

   A continuación, inicie el contenedor maestro. Este comando utiliza mysql:5.7 y lo configura con un ID de servidor (server ID) de 1 y habilita el registro binario (binary logging) para la base de datos replication_db.

   docker run -d \
     --name mysql-master \
     --network mysql-net \
     -e MYSQL_ROOT_PASSWORD=lab_password \
     -e MYSQL_DATABASE=replication_db \
     mysql:5.7 \
     mysqld --server-id=1 --log-bin=mysql-bin --binlog-do-db=replication_db
   

3. Iniciar el Contenedor Esclavo MySQL:

   Ahora, inicie el contenedor esclavo. Este contenedor también está en la misma red y está configurado con un ID de servidor (server ID) de 2. También creamos la base de datos replication_db de antemano, para que el esclavo pueda aplicar correctamente los cambios del maestro.

   docker run -d \
     --name mysql-slave \
     --network mysql-net \
     -e MYSQL_ROOT_PASSWORD=lab_password \
     -e MYSQL_DATABASE=replication_db \
     mysql:5.7 \
     mysqld --server-id=2 --relay-log=mysql-relay-bin --log-slave-updates=1
   

4. Esperar a que los Contenedores se Inicialicen:

   Los contenedores MySQL necesitan tiempo para inicializarse. Espere unos 15 segundos para verificar si los contenedores se están ejecutando.

   docker ps
   

   CONTAINER ID   IMAGE       COMMAND                  CREATED         STATUS         PORTS                 NAMES
   
   cfe8c98d2ad0 mysql:5.7 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 3306/tcp, 33060/tcp mysql-slave
   fc125bf293ea mysql:5.7 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 3306/tcp, 33060/tcp mysql-master
   

Ahora que su entorno está configurado, puede proceder a configurar el servidor maestro.

Verificar la Configuración del Servidor Maestro

Ahora que los contenedores están en ejecución, el siguiente paso es asegurar que el servidor maestro esté configurado correctamente para la replicación. La responsabilidad principal del maestro es registrar todos los cambios de la base de datos en su registro binario (binary log), que el esclavo leerá posteriormente.

Primero, abra una terminal desde su escritorio.

Ahora nos conectaremos al contenedor maestro y verificaremos su configuración.

1. Conectarse al Contenedor Maestro:

   Utilice docker exec para abrir una shell de MySQL dentro del contenedor mysql-master. Se le pedirá que introduzca la contraseña, que es lab_password.

   docker exec -it mysql-master mysql -uroot -plab_password
   

2. Verificar el Registro Binario y el ID del Servidor:

   Una vez que vea el prompt mysql>, ejecute los siguientes comandos para verificar que el registro binario (binary logging) está habilitado y que el ID del servidor (server ID) está configurado correctamente.

   SHOW VARIABLES LIKE 'log_bin';
   

   La salida debería mostrar que log_bin está ON.

   +---------------+----+
   | Variable_name | Value |
   +---------------+----+
   | log_bin       | ON |
   +---------------+----+
   1 row in set (0.01 sec)
   

   A continuación, verifique el ID del servidor.

   SHOW VARIABLES LIKE 'server_id';
   

   La salida debería mostrar que el server_id es 1.

   +---------------+-------+
   | Variable_name | Value |
   +---------------+-------+
   | server_id     | 1     |
   +---------------+-------+
   1 row in set (0.00 sec)
   

   Ahora que ha verificado la configuración, puede salir de la shell de MySQL.

   exit;
   

Ha confirmado con éxito que el servidor maestro está listo para la replicación.

Crear un Usuario de Replicación y una Base de Datos de Prueba

El servidor esclavo necesita conectarse al maestro para leer el registro binario (binary log). Por seguridad, la mejor práctica es crear una cuenta de usuario dedicada para este propósito con privilegios limitados. En este paso, creará un usuario de replicación y poblará la base de datos de prueba para observar la replicación en acción.

1. Conectarse al Servidor Maestro:

   Abra una shell de MySQL dentro del contenedor mysql-master.

   docker exec -it mysql-master mysql -uroot -plab_password
   

2. Crear un Usuario de Replicación:

   En el prompt mysql>, ejecute el siguiente comando para crear un usuario llamado repl_user con la contraseña repl_password. Este usuario será utilizado por el esclavo para conectarse. Usamos '@'%' para permitir que el usuario se conecte desde cualquier host, lo que incluye nuestro contenedor esclavo en la red Docker.

   CREATE USER 'repl_user'@'%' IDENTIFIED BY 'repl_password';
   

3. Otorgar Privilegios de Replicación:

   El nuevo usuario necesita el privilegio REPLICATION SLAVE, que le permite leer los registros binarios (binary logs) del maestro.

   GRANT REPLICATION SLAVE ON *.* TO 'repl_user'@'%';
   

   Después de otorgar los privilegios, recargue las tablas de concesión (grant tables) para aplicar los cambios inmediatamente.

   FLUSH PRIVILEGES;
   

4. Verificar el Estado del Registro Binario del Maestro:

   Antes de configurar el esclavo, necesita conocer las coordenadas exactas en el registro binario del maestro donde el esclavo debe comenzar a replicar. El comando SHOW MASTER STATUS proporciona esta información.

   SHOW MASTER STATUS;
   

   La salida será similar a esta. Anote los valores de File y Position, ya que los necesitará en el siguiente paso.

   +------------------+----------+------------------+--------------------+-------------------+
   | File             | Position | Binlog_Do_DB     | Binlog_Ignore_DB   | Executed_Gtid_Set |
   +------------------+----------+------------------+--------------------+-------------------+
   | mysql-bin.000001 |      337 | replication_db   |                    |                   |
   +------------------+----------+------------------+--------------------+-------------------+
   1 row in set (0.00 sec)
   

5. Crear una Tabla de Prueba y Datos:

   La base de datos replication_db se creó cuando se inició el contenedor. Creemos una tabla e insertemos algunos datos para probar la replicación.

   USE replication_db;
   CREATE TABLE messages (
       id INT PRIMARY KEY AUTO_INCREMENT,
       content VARCHAR(255)
   );
   INSERT INTO messages (content) VALUES ('Hello from the master!');
   

   Puede verificar que los datos se insertaron correctamente.

   SELECT * FROM messages;
   

   Debería ver la fila que acaba de insertar.

   +----+------------------------+
   | id | content                |
   +----+------------------------+
   |  1 | Hello from the master! |
   +----+------------------------+
   1 row in set (0.00 sec)
   

   Ahora, salga de la shell de MySQL.

   exit;
   

Ahora ha preparado el servidor maestro creando un usuario de replicación y algunos datos de prueba.

Configurar e Iniciar el Servidor Esclavo

Ahora que el maestro está listo, configurará el contenedor esclavo. En este paso, utilizará las coordenadas del registro binario (binary log coordinates) que registró del maestro en el Paso 3 para indicarle al esclavo dónde comenzar a replicar.

1. Conectarse al Contenedor Esclavo:

   Primero, abra una shell de MySQL dentro del contenedor mysql-slave.

   docker exec -it mysql-slave mysql -uroot -plab_password
   

2. Configurar el Esclavo para Conectarse al Maestro:

   Ahora, utilizará el comando CHANGE MASTER TO para configurar los ajustes de replicación. Utilice los valores de File y Position que anotó de SHOW MASTER STATUS en el Paso 3. El MASTER_HOST es 'mysql-master', lo cual funciona porque ambos contenedores están en la misma red Docker.

   Nota: Reemplace mysql-bin.000001 y el número de posición con los valores reales que registró en el Paso 3. Si no tiene los valores, puede ejecutar docker exec mysql-master mysql -uroot -plab_password -e "SHOW MASTER STATUS;" en una nueva terminal para obtenerlos.

   CHANGE MASTER TO
       MASTER_HOST='mysql-master',
       MASTER_USER='repl_user',
       MASTER_PASSWORD='repl_password',
       MASTER_LOG_FILE='mysql-bin.000001',
       MASTER_LOG_POS=337;
   

   Este comando configura el esclavo con toda la información necesaria para conectarse al maestro.

3. Iniciar los Hilos del Esclavo:

   Finalmente, inicie el proceso de replicación ejecutando el comando START SLAVE. Esto iniciará dos hilos: el hilo de I/O (I/O thread), que obtiene los registros binarios del maestro, y el hilo de SQL (SQL thread), que ejecuta los eventos de los registros.

   START SLAVE;
   

   Ahora puede salir de la shell de MySQL.

   exit;
   

El esclavo ahora está configurado y debería estar intentando conectarse al maestro y replicar datos.

Verificar la Replicación

Después de iniciar el esclavo, el paso final es verificar que la replicación esté funcionando correctamente. Comprobará el estado del esclavo y confirmará que los datos del maestro se han copiado.

1. Conectarse al Servidor Esclavo:

   Abra una shell de MySQL en el contenedor mysql-slave.

   docker exec -it mysql-slave mysql -uroot -plab_password
   

2. Verificar el Estado del Esclavo:

   El comando más importante para monitorear la replicación es SHOW SLAVE STATUS. El modificador \G formatea la salida verticalmente, lo que la hace mucho más fácil de leer.

   SHOW SLAVE STATUS\G
   

   Busque las siguientes dos líneas en la salida. Ambas deberían tener el valor Yes.

   • Slave_IO_Running: Yes: Esto confirma que el esclavo está conectado exitosamente al maestro y recibiendo datos del registro binario (binary log).
   • Slave_SQL_Running: Yes: Esto confirma que el esclavo está ejecutando exitosamente los eventos del registro binario.

   Otro campo importante es Seconds_Behind_Master. Un valor de 0 indica que el esclavo está completamente sincronizado con el maestro.

   Un estado saludable se verá similar a esto (algunos valores pueden variar):

   *************************** 1. row ***************************
                  Slave_IO_State: Waiting for master to send event
                     Master_Host: mysql-master
                     Master_User: repl_user
                     Master_Port: 3306
                   Connect_Retry: 60
                 Master_Log_File: mysql-bin.000001
             Read_Master_Log_Pos: 529
                  Relay_Log_File: mysql-relay-bin.000002
                   Relay_Log_Pos: 699
           Relay_Master_Log_File: mysql-bin.000001
                Slave_IO_Running: Yes
               Slave_SQL_Running: Yes
   ...
            Seconds_Behind_Master: 0
   ...
   

3. Verificar los Datos Replicados:

   Ahora, verifique si la base de datos replication_db y sus datos se han copiado del maestro.

   SHOW DATABASES;
   

   Debería ver replication_db en la lista.

   +--------------------+
   | Database           |
   +--------------------+
   | information_schema |
   | mysql              |
   | performance_schema |
   | replication_db     |
   | sys                |
   +--------------------+
   

   Cambie a la base de datos y consulte la tabla messages.

   USE replication_db;
   SELECT * FROM messages;
   

   Los datos que insertó en el maestro ahora deberían estar presentes en el esclavo.

   +----+------------------------+
   | id | content                |
   +----+------------------------+
   |  1 | Hello from the master! |
   +----+------------------------+
   1 row in set (0.00 sec)
   

   Esto confirma que la replicación está funcionando correctamente. Ahora puede salir de la shell de MySQL.

   exit;
   

Ha configurado y verificado exitosamente un entorno básico de replicación maestro-esclavo de MySQL utilizando Docker.

Resumen

En este laboratorio, ha aprendido los pasos fundamentales para configurar la replicación maestro-esclavo de MySQL utilizando Docker. Comenzó creando dos contenedores MySQL separados, uno para el maestro y otro para el esclavo, conectados a través de una red Docker. Verificó la configuración del maestro, que incluía un registro binario (binary log) habilitado y un ID de servidor único. Luego creó un usuario de replicación dedicado en el maestro para una conexión segura. Después de preparar el maestro, configuró el contenedor esclavo utilizando el comando CHANGE MASTER TO para establecer la conexión con las coordenadas del registro binario del maestro. Finalmente, verificó el éxito de la replicación comprobando el estado del esclavo con SHOW SLAVE STATUS y confirmando que los datos de prueba se sincronizaron correctamente. Este laboratorio le ha proporcionado las habilidades esenciales para configurar, administrar y verificar una configuración de replicación de MySQL realista.