Introdução
Antes de iniciar a construção do laboratório, é importante compreender os conceitos envolvidos na arquitetura que será implementada.
O MySQL InnoDB ClusterSet é um recurso do MySQL que permite conectar múltiplos InnoDB Clusters distribuídos entre diferentes datacenters ou regiões geográficas. Essa arquitetura foi projetada para fornecer alta disponibilidade (High Availability) e recuperação de desastres (Disaster Recovery – DR), permitindo que um cluster secundário assuma as operações caso o cluster primário fique indisponível.
Em um ClusterSet, apenas um cluster atua como Primário (Primary Cluster), responsável pelas operações de escrita, enquanto um ou mais Clusters Réplica (Replica Clusters) recebem os dados por meio da replicação assíncrona entre clusters. Internamente, cada cluster mantém a sincronização de seus nós utilizando o Group Replication, garantindo alta disponibilidade local.
A arquitetura pode ser representada da seguinte forma:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
InnoDB ClusterSet │ ┌───────────────┴───────────────┐ │ │ Primary Cluster Replica Cluster (Data Center A) (Data Center B) mysql3310 ─┐ mysql3320 ─┐ mysql3311 ─├─ Group Replication mysql3321 ─┤─ Group Replication mysql3312 ─┘ mysql3322 ─┘ Leitura/Escrita Somente Leitura |
Utilizando o MySQL Sandbox
Em um ambiente de produção, a construção dessa arquitetura exigiria, no mínimo, seis servidores Oracle Linux, cada um executando uma instância do MySQL.
Para simplificar a criação do laboratório e reduzir a necessidade de infraestrutura física ou virtual, utilizaremos o MySQL Sandbox.
O MySQL Sandbox é uma ferramenta que permite criar rapidamente instâncias isoladas do MySQL em uma única máquina, possibilitando executar múltiplos servidores de forma independente. Essa abordagem é ideal para laboratórios, testes e treinamentos, pois reproduz um ambiente semelhante ao de produção sem a necessidade de diversos servidores.
Entre as principais vantagens do MySQL Sandbox estão:
-
Criação rápida de múltiplas instâncias do MySQL.
-
Execução de diferentes versões do MySQL na mesma máquina.
-
Testes de atualização (upgrade) de versão.
-
Reprodução e análise de problemas (bugs).
-
Validação de scripts, procedimentos e migrações.
-
Simulação de ambientes com replicação e alta disponibilidade.
-
Realização de treinamentos e experimentos sem impactar ambientes produtivos.
Ao longo deste documento, utilizaremos o MySQL Sandbox para simular os seis servidores necessários para a implementação completa do InnoDB ClusterSet, permitindo demonstrar toda a configuração da solução em um único ambiente de testes.
https://dev.mysql.com/doc/mysql-shell/9.7/en/admin-api-sandboxes.html
Requisitos para este laboratório
Para reproduzir o ambiente apresentado neste documento, serão necessários os seguintes requisitos:
-
Um servidor com Oracle Linux 10;
-
MySQL Server 9.7;
-
MySQL Shell;
-
MySQL Router.
Todos esses componentes devem estar previamente instalados e configurados.
Embora não seja um requisito obrigatório, é recomendável possuir familiaridade com a administração de InnoDB Cluster utilizando o MySQL Shell, pois isso facilitará o entendimento das etapas apresentadas ao longo deste laboratório.
Ambiente utilizado
Neste laboratório será utilizado um único servidor com uma instância do MySQL Server já instalada. A partir dessa instalação serão criadas todas as instâncias necessárias para compor o ambiente do InnoDB ClusterSet por meio do MySQL Sandbox.
Essa abordagem simplifica significativamente a criação do ambiente, pois o Sandbox reutiliza os binários e as dependências já existentes no servidor. Dessa forma, não é necessário:
-
Baixar os pacotes binários do MySQL;
-
Resolver dependências de bibliotecas do sistema operacional;
-
Ajustar permissões e caminhos de instalação;
-
Verificar a compatibilidade entre a versão do MySQL e o sistema operacional.
Com o MySQL já instalado, o Sandbox cria um diretório isolado no home do usuário e, dentro dele, um diretório para cada instância. Em seguida, inicializa os arquivos de dados, configura portas distintas e deixa cada instância pronta para uso em poucos minutos.
Caso o servidor não possua uma instalação prévia do MySQL, será necessário obter os binários corretos, instalar as dependências exigidas pelo sistema operacional e realizar as configurações iniciais antes da criação das sandboxes, tornando o processo mais demorado e complexo.
Por esse motivo, este laboratório utiliza um servidor com o MySQL previamente instalado, permitindo concentrar o foco na configuração do InnoDB ClusterSet, e não na preparação do ambiente.
Iniciando a criação do ambiente.
Nesta etapa iniciaremos a construção do ambiente que compõe o InnoDB ClusterSet.
O primeiro cluster a ser criado será o Cluster PRINCIPAL (Primary Cluster), que será responsável por receber todas as operações de leitura e escrita do ambiente. Esse cluster será composto por três instâncias do MySQL.
|
PRINCIPAL |
|
|
Instance port |
Role |
|
3310 |
Primário |
|
3311 |
Secundário |
|
3312 |
Secundário |
Obs.: Muita atenção com as portas
No servidor acesse o MySQL Shell, com o comando abaixo:
|
1 |
mysqlsh --js |
Crie as instancias MySQL usando o Sandbox, com os comandos abaixo:
|
1 |
dba.deploySandboxInstance(3310, {password: "P@ssw0rd"}) |
Observe que o MySQL criou um diretório “mysql-sanboxes” e dentro deste diretório criou uma pasta chamada 3310, esta pasta vai armazenar todos os arquivos necessário para a instancia funcionar e no final fornece o comando para que faça login na instancia.
Siga com a criação das instancias restante:
|
1 2 |
dba.deploySandboxInstance(3311, {password: "P@ssw0rd"}) dba.deploySandboxInstance(3312, {password: "P@ssw0rd"}) |
Obs.: No comando eu já estou declarando uma senha para o usuário root da instancia MySQL, se omitindo este parâmetro o MySQL solicitará uma senha logo após digitar o comando para cada uma das instancias.
Verificando as instancias no sistema operacional:
|
1 |
ps -ef | grep mysql |
Após criação das instâncias, faça login na instancia de porta 3310:
|
1 |
shell.connect("root@localhost:3310") |
Uma vez estando na instancia crie o usuário para administrar o cluster:
|
1 |
dba.configureInstance("root@localhost:3310", {clusterAdmin: "clusteradmin"}) |
Será solicitado que digite uma senha para este usuário.
Criando o Cluster “PRINCIPAL”
Antes de iniciar quero compartilhar um ponto de atenção, para quem não tem familiaridade com gerenciamento do cluster usando AdminAPI do MySQL Shell, o createCluster() cria o cluster e devolve um “ponteiro” para ele. Guardamos esse ponteiro na variável “pri” para poder executar comandos depois. Quando fechamos o MySQL Shell, a variável desaparece, mas o cluster continua existindo no banco. Então usamos getCluster() para recuperar uma nova referência ao cluster já existente, isso para outros objetos como ClusterSet.
Criar o InnoDB Cluster:
|
1 |
pri = dba.createCluster("PRINCIPAL") |
Adicionar os demais node ao cluster:
|
1 |
pri.addInstance('root@localhost:3311') |
|
1 |
pri.addInstance('root@localhost:3312') |
No momento da adição das instancia, o MySQL fornece dois métodos de recovery, Clone e Incremental, e pergunta qual o método de recovery deseja utilizar. Para esta demonstração escolhe o “Clone”.
Check o status do cluster:
|
1 |
pri.status() |
Criando o InnoDB ClusterSet
Antes de iniciar quero falar de um detalhe importante, o InnoDB ClusterSet não é criado unindo dois clusters existentes. Você cria o ClusterSet a partir de um cluster primário e depois adiciona os demais como Replica Clusters gerenciados pelo ClusterSet. Durante esse processo, o ClusterSet reconfigura o cluster réplica para usar o canal de replicação entre clusters.
Criar o InnoDB ClusterSet.
Ainda no servidor primário “3310”, execute o comando abaixo para criar ClusterSet de nome “DR”:
|
1 |
cs = pri.createClusterSet('DR') |
Observe que após o MySQL criar o “ClusterSet”, o MySQL exibi as instruções necessárias para adicionar as replicas.
Com o “ClusterSet” criado, iniciaremos a configuração do segundo InnoDB Cluster, que será denominado de SECONDARY.
Preparando o ambiente SECONDARY:
Nesta etapa serão criadas e configuradas as três instâncias que compõem o cluster SECONDARY e adicionadas ao ClusterSet como um Replica Cluster.
|
SECONDARY |
|
|
Instance port |
Role |
|
3320 |
Primário |
|
3321 |
Secundário |
|
3322 |
Secundário |
Obs.: Muita atenção com as portas
Se não estiver no MySQL Shell acesse o novamente:
|
1 |
mysqlsh --js |
Obs.: Atenção com as portas, pois ela vai te ajudar a identificar em qual instancia você está logado, evitando que o comando seja executado na instancia errada.
No MySQL Shell crie as instancias com os comandos abaixo:
|
1 2 3 |
dba.deploySandboxInstance(3320,{password: "P@ssw0rd"}) dba.deploySandboxInstance(3321,{password: "P@ssw0rd"}) dba.deploySandboxInstance(3322,{password: "P@ssw0rd"}) |
Veja no sistema operacional:
|
1 2 3 |
ps -ef | grep mysql ls -l /root/mysql-sandbox #Este diretório pode ser diferente de onde você está executando |
Após criação das novas instâncias, faça login na instancia de porta 3310 que a instancia primária do InnoDB Cluster criado início chamado PRINCIPAL, e seguiremos com a adição das instancias ao ClusterSet e a criação do InnoDB Cluster SECONDARY:
|
1 |
shell.connect("root@localhost:3310") |
Vale lembra que se você fez um novo login é necessário carregar as variáveis novamente, primeiro carregue a variável de cluster e em seguida a clusterset:
|
1 |
pri = dba.getCluster() |
|
1 |
cs = pri.getClusterSet() |
Criação do ReplicaCluster
Criar ReplicarCluster:
|
1 |
cs.createReplicaCluster('root@localhost:3320', 'SECONDARY') |
Ao verificar o status do ClusterSet, vai visualizar que um novo cluster foi adicionado, execute o comando abaixo:
|
1 |
cs.status() |
Ou para verificar com uma riqueza maior de detalhes, execute o comando abaixo:
|
1 |
cs.status({extended: 2}); |
Após o criar o Replica Cluster, o MySQL fez a criação do novo InnoDB Cluster chamado SECONDARY.
Agora temos que adicionar as demais instancias, neste caso as de porta 3321 e 3322 ao novo InnoDB Cluster.
Da instancia de porta 3310, ou se preferir pode fazer login a instancia de porta 3320, execute o comando para carregar a variável com os dados do InnoDB cluter SECONDARY:
|
1 |
sec = dba.getCluster("SECONDARY") |
Adicionar os servidores ao cluster:
|
1 2 |
sec.addInstance('root@localhost:3321') sec.addInstance('root@localhost:3322') |
Obs.: A adição das instancias é o mesmo processo que foi executado antes, no início do processo, quando criamos o InnoDB Cluster PRINCIPAL.
Verificar o status do cluster:
|
1 |
sec.status() |
Obs.: Como podem observar todas as instancias estão como read Only.
Verificar o ClusterSet:
|
1 |
cs.describe() |
Obs.: Da forma que criamos, apenas a instancia de porta 3310 (que é a primária do cluster que chamamos de PRINCIPAL) está com o status como read e write.
Para simular um switchover entre os dois clusters, usarei o MySQL Router e uma aplicação Python, conectada a ele fazendo leitura e gravação.
Criar o MySQL Router
Se não estiver logado, faça login na instancia de porta 3310 com o comando abaixo:
|
1 |
shell.connect("root@localhost:3310") |
Após login, criar um usuário para utilizar no serviço do MySQL Router, execute o comando abaixo (Lembre-se que se fizer um novo login é necessário carregar as variáveis):
|
1 2 |
pri = dba.getCluster() pri.setupRouterAccount("routeradmin") |
Será solicitado uma senha para o usuário.
Bootstrap
No servidor, fazer o bootstrap do MySQL Router para que ele passe a conhecer e encaminhar conexões para um MySQL InnoDB Cluster com o comando a seguir:
|
1 2 |
# Atenção este comando deve ser executado no sistema operacional mysqlrouter --bootstrap clusteradmin@localhost:3310 -d /router --name="RT-PRINCIPAL" --account=routeradmin --report-host=localhost --user=root |
No comando será solicitado a senha do usuário clusteradmin (Usuário criado no início, quando foi criado o primeiro cluster) e o do usuário routeradmin (que acabou de criado). Veja a saída após o comando, onde ele informar as portas de leitura e escrita.
Verificar Router na instancia MySQL
Verificar no MySQL uma lista que contém o Router que acabamos de configurar:
|
1 |
cs.listRouters() |
Verificar as configurações de roteamento aplicadas ao ClusterSet:
|
1 |
cs.routerOptions() |
Obs.: Lembre se de carrega as variáveis de ambiente, caso não estejam.
Inicie o MySQL Router no sistema operacional:
|
1 |
/router/start.sh #Certifique que o arquivo start.sh esteja no local. |
Testando o ambiente
É possível realizar este teste no próprio servidor ou acessando o MySQL Router a partir de outra máquina. Neste laboratório, vou acessar a instância do MySQL por meio do MySQL Router a partir de um servidor externo.
O teste consiste em utilizar duas aplicações Python: uma responsável pelas operações de escrita e outra pelas operações de leitura. Em seguida, será realizado o switchover do cluster PRINCIPAL para o SECONDARY, acompanhando o comportamento das aplicações e do MySQL Router durante a troca de função entre os clusters.
Iniciando as aplicações de leitura e escrita
Observe que as operações de escrita são direcionadas para a instância primária (porta 3310) do cluster PRINCIPAL, enquanto as operações de leitura são distribuídas entre as instâncias secundárias do mesmo cluster (portas 3311 e 3312).
Esse comportamento ocorre porque a conexão das aplicações está apontando para o MySQL Router. As aplicações utilizam as portas disponibilizadas pelo Router, sendo a porta 6446 destinada às operações de escrita e a porta 6447 destinada às operações de leitura.
Agora será realizado o switchover para o cluster SECONDARY. Para isso, execute o comando abaixo.
Realize o login na instancia primária do Cluster PRINCIPAL (3310), segue abaixo os comandos:
Acesse o MySQL Shell:
|
1 |
mysqlsh --js |
Connect na instancia:
|
1 |
shell.connect("root@localhost:3310") |
Obtenha a referencia ao cluster:
|
1 |
pri = dba.getCluster() |
Obtenha a referencia ao ClusterSet:
cs = pri.getClusterSet()
Realizar o Switchover para o cluster SECONDARY
|
1 |
cs.setPrimaryCluster("SECONDARY") |
Verificar o status do ClusterSet:
|
1 |
cs.status() |
Observem que agora que o cluster SECONDARY está como primaryCluster e aplicação passou a ler e escrever no cluster no que foi definido como primário.
Conclusão
Neste laboratório foi demonstrada a implementação de um MySQL InnoDB ClusterSet, utilizando o MySQL Sandbox para simular um ambiente composto por um Cluster Primário e um Cluster Réplica. Também foi validado o funcionamento do MySQL Router durante um switchover, evidenciando que as aplicações continuam acessando o banco de dados sem necessidade de alteração na configuração das conexões.
Em um ambiente de produção, uma arquitetura baseada em InnoDB ClusterSet oferece benefícios importantes para a continuidade dos serviços. Além de disponibilizar um site de Disaster Recovery (DR) para recuperação em caso de indisponibilidade do ambiente principal, ela permite realizar switchovers planejados, possibilitando manutenções no Cluster Primário com redução do impacto para as aplicações. Enquanto um cluster assume o papel de Primário, o outro pode receber atualizações, manutenções do sistema operacional, do MySQL ou da infraestrutura de forma planejada, aumentando a disponibilidade e a flexibilidade operacional do ambiente.
Dessa forma, o InnoDB ClusterSet torna-se uma solução robusta para organizações que necessitam de alta disponibilidade, continuidade de negócio e uma estratégia eficiente de recuperação de desastres.
Sugestão de leitura.
https://dev.mysql.com/doc/mysql-shell/9.7/en/
https://dev.mysql.com/doc/mysql-router/9.7/en/
https://dev.mysql.com/doc/mysql-shell/9.7/en/mysql-innodb-cluster.html
https://dev.mysql.com/doc/mysql-shell/9.7/en/innodb-clusterset.html
