Noções Básicas de Replicação MySQL

Introdução

Neste laboratório, você aprenderá os fundamentos da replicação MySQL. A replicação é um processo que permite manter cópias de um banco de dados MySQL em múltiplos servidores. Isso é comumente usado para balanceamento de carga (load balancing), backup de dados e alta disponibilidade (high availability).

Você usará o Docker para criar uma configuração realista de replicação master-slave com dois contêineres MySQL separados. Primeiro, você iniciará e verificará um contêiner master, que é pré-configurado com o binary logging habilitado. Você criará um usuário de replicação especial no master. Em seguida, você configurará o segundo contêiner para atuar como slave, conectá-lo ao master e verificar se os dados estão sincronizados corretamente. Essa abordagem prática ajudará você a entender os passos chave envolvidos no gerenciamento de um ambiente de replicação MySQL do mundo real.

Configurar o Ambiente Docker

Nesta primeira etapa, você configurará os contêineres Docker necessários para o ambiente de replicação master-slave. Você criará uma rede dedicada e iniciará dois contêineres MySQL.

Criar uma Rede Docker:

Uma rede dedicada permite que os contêineres se comuniquem entre si por nome. Crie uma rede chamada mysql-net.
```
docker network create mysql-net
```

Iniciar o Contêiner Master MySQL:

Em seguida, inicie o contêiner master. Este comando usa mysql:5.7 e o configura com um server-id de 1 e habilita o binary logging para o banco de dados 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

Iniciar o Contêiner Slave MySQL:

Agora, inicie o contêiner slave. Este contêiner também está na mesma rede e é configurado com um server-id de 2. Também criamos o banco de dados replication_db com antecedência, para que o slave possa aplicar corretamente as alterações do master.
```
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
```

Aguardar a Inicialização dos Contêineres:

Os contêineres MySQL precisam de algum tempo para inicializar. Aguarde cerca de 15 segundos para verificar se os contêineres estão em execução.

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

Agora que seu ambiente está configurado, você pode prosseguir para configurar o servidor master.

Verificar a Configuração do Servidor Master

Agora que os contêineres estão em execução, o próximo passo é garantir que o servidor master esteja configurado corretamente para replicação. A principal responsabilidade do master é registrar todas as alterações do banco de dados em seu binary log, que o slave lerá posteriormente.

Primeiro, abra um terminal em sua área de trabalho.

Agora, vamos nos conectar ao contêiner master e verificar sua configuração.

Conectar ao Contêiner Master:

Use docker exec para abrir um shell MySQL dentro do contêiner mysql-master. Você será solicitado a inserir a senha, que é lab_password.
```
docker exec -it mysql-master mysql -uroot -plab_password
```
Verificar Binary Logging e Server ID:

Assim que você vir o prompt mysql>, execute os seguintes comandos para verificar se o binary logging está habilitado e se o server_id está configurado corretamente.
```
SHOW VARIABLES LIKE 'log_bin';
```
A saída deve mostrar que log_bin está ON.
```
+---------------+----+
| Variable_name | Value |
+---------------+----+
| log_bin       | ON |
+---------------+----+
1 row in set (0.01 sec)
```
Em seguida, verifique o server_id.
```
SHOW VARIABLES LIKE 'server_id';
```
A saída deve mostrar que o server_id é 1.
```
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| server_id     | 1     |
+---------------+-------+
1 row in set (0.00 sec)
```
Agora que você verificou a configuração, pode sair do shell MySQL.
```
exit;
```

Você confirmou com sucesso que o servidor master está pronto para replicação.

Criar um Usuário de Replicação e um Banco de Dados de Teste

O servidor slave precisa se conectar ao master para ler o binary log. Por segurança, é uma boa prática criar uma conta de usuário dedicada para esse fim, com privilégios limitados. Nesta etapa, você criará um usuário de replicação e populará o banco de dados de teste para observar a replicação em ação.

Conectar ao Servidor Master:

Abra um shell MySQL dentro do contêiner mysql-master.
```
docker exec -it mysql-master mysql -uroot -plab_password
```
Criar um Usuário de Replicação:

No prompt mysql>, execute o seguinte comando para criar um usuário chamado repl_user com a senha repl_password. Este usuário será usado pelo slave para se conectar. Usamos '@'%' para permitir que o usuário se conecte de qualquer host, o que inclui nosso contêiner slave na rede Docker.
```
CREATE USER 'repl_user'@'%' IDENTIFIED BY 'repl_password';
```
Conceder Privilégios de Replicação:

O novo usuário precisa do privilégio REPLICATION SLAVE, que permite que ele leia os binary logs do master.
```
GRANT REPLICATION SLAVE ON *.* TO 'repl_user'@'%';
```
Após conceder os privilégios, recarregue as tabelas de concessão para aplicar as alterações imediatamente.
```
FLUSH PRIVILEGES;
```

Verificar o Status do Binary Log do Master:

Antes de configurar o slave, você precisa saber as coordenadas exatas no binary log do master onde o slave deve começar a replicar. O comando SHOW MASTER STATUS fornece essa informação.

SHOW MASTER STATUS;

A saída será semelhante a esta. Anote os valores de File e Position, pois você precisará deles na próxima etapa.

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

Criar uma Tabela de Teste e Dados:

O banco de dados replication_db foi criado quando o contêiner iniciou. Vamos criar uma tabela e inserir alguns dados para testar a replicação.

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

Você pode verificar se os dados foram inseridos corretamente.

SELECT * FROM messages;

Você deverá ver a linha que acabou de inserir.

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

Agora, saia do shell MySQL.

exit;

Você preparou o servidor master criando um usuário de replicação e alguns dados de teste.

Configurar e Iniciar o Servidor Slave

Agora que o master está pronto, você configurará o contêiner slave. Nesta etapa, você usará as coordenadas do binary log que registrou do master na Etapa 3 para informar ao slave onde começar a replicar.

Conectar ao Contêiner Slave:

Primeiro, abra um shell MySQL dentro do contêiner mysql-slave.
```
docker exec -it mysql-slave mysql -uroot -plab_password
```
Configurar o Slave para Conectar ao Master:

Agora, você usará o comando CHANGE MASTER TO para configurar as definições de replicação. Use os valores de File e Position que você anotou em SHOW MASTER STATUS na Etapa 3. O MASTER_HOST é 'mysql-master', o que funciona porque ambos os contêineres estão na mesma rede Docker.

Nota: Substitua mysql-bin.000001 e o número da posição pelos valores reais que você registrou na Etapa 3. Se você não tiver os valores, pode executar docker exec mysql-master mysql -uroot -plab_password -e "SHOW MASTER STATUS;" em um novo terminal para obtê-los.
```
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 o slave com todas as informações necessárias para se conectar ao master.
Iniciar as Threads do Slave:

Finalmente, inicie o processo de replicação executando o comando START SLAVE. Isso iniciará duas threads: a thread de I/O, que busca os binary logs do master, e a thread SQL, que executa os eventos dos logs.
```
START SLAVE;
```
Você pode sair do shell MySQL agora.
```
exit;
```

O slave agora está configurado e deve estar tentando se conectar ao master e replicar os dados.

Verificar Replicação

Após iniciar o slave, a etapa final é verificar se a replicação está funcionando corretamente. Você verificará o status do slave e confirmará se os dados do master foram copiados.

Conectar ao Servidor Slave:

Abra um shell MySQL no contêiner mysql-slave.
```
docker exec -it mysql-slave mysql -uroot -plab_password
```
Verificar o Status do Slave:

O comando mais importante para monitorar a replicação é SHOW SLAVE STATUS. O modificador \G formata a saída verticalmente, o que a torna muito mais fácil de ler.
```
SHOW SLAVE STATUS\G
```
Procure pelas duas linhas a seguir na saída. Ambas devem ter o valor Yes.
- Slave_IO_Running: Yes: Isso confirma que o slave está conectado com sucesso ao master e recebendo dados do binary log.
- Slave_SQL_Running: Yes: Isso confirma que o slave está executando com sucesso os eventos do binary log.
Outro campo importante é Seconds_Behind_Master. Um valor de 0 indica que o slave está totalmente sincronizado com o master.

Um status saudável será semelhante a este (alguns valores podem diferir):
```
*************************** 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
...
```

Verificar os Dados Replicados:

Agora, verifique se o banco de dados replication_db e seus dados foram copiados do master.

SHOW DATABASES;

Você deverá ver replication_db na lista.

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

Mude para o banco de dados e consulte a tabela messages.

USE replication_db;
SELECT * FROM messages;

Os dados que você inseriu no master agora devem estar presentes no slave.

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

Isso confirma que a replicação está funcionando corretamente. Você pode sair do shell MySQL agora.

exit;

Você configurou e verificou com sucesso um ambiente básico de replicação master-slave MySQL usando Docker.

Resumo

Neste laboratório, você aprendeu os passos fundamentais para configurar a replicação master-slave do MySQL usando Docker. Você começou criando dois contêineres MySQL separados, um para o master e outro para o slave, conectados através de uma rede Docker. Você verificou a configuração do master, que incluiu um binary log habilitado e um ID de servidor exclusivo. Em seguida, você criou um usuário de replicação dedicado no master para uma conexão segura. Após preparar o master, você configurou o contêiner slave usando o comando CHANGE MASTER TO para estabelecer a conexão com as coordenadas do binary log do master. Finalmente, você verificou o sucesso da replicação verificando o status do slave com SHOW SLAVE STATUS e confirmando que os dados de teste foram sincronizados corretamente. Este laboratório forneceu as habilidades essenciais para configurar, gerenciar e verificar uma configuração de replicação MySQL realista.