# Trabalhar com a replicação do MySQL no Amazon RDS
Normalmente, você usa réplicas de leitura para configurar a replicação entre as instâncias de banco de dados do Amazon RDS. Para obter informações gerais sobre réplicas de leitura, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md). Para obter informações específicas sobre como trabalhar com réplicas de leitura no Amazon RDS para MySQL, consulte [Trabalhar com réplicas de leitura do MySQL](USER_MySQL.Replication.ReadReplicas.md).
Você pode utilizar Global Transaction Identifiers (GTIDs – Identificadores de transação global) para replicação com o RDS para MySQL. Para obter mais informações, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
A replicação também pode ser configurada entre uma instância de banco de dados do RDS para MySQL e uma instância MySQL ou MariaDB externa ao Amazon RDS. Para obter informações sobre como configurar a replicação com uma origem externa, consulte [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](MySQL.Procedural.Importing.External.Repl.md).
Para todas essas opções de replicação, use replicação baseada em linha, em instrução ou mista. A replicação baseada em linha só replica as linhas alteradas resultantes de uma instrução SQL. A replicação baseada em instrução copia toda a instrução SQL. A replicação mista usa uma replicação baseada em instrução quando possível, mas alterna para replicação baseada em linha quando as instruções SQL não seguras para replicação baseada em instrução são executadas. Na maioria dos casos, a replicação mista é recomendada. O formato de log binário da instância de banco de dados determina se a replicação se baseia na linha, na instrução ou mista. Para obter informações sobre como definir o formato de log binário, consulte [Configurar o registro em log binário do RDS para MySQL para bancos de dados single-AZ](USER_LogAccess.MySQL.BinaryFormat.md).
**nota**
Você pode configurar a replicação para importar bancos de dados de uma instância MySQL ou MariaDB externa ao Amazon RDS, ou exportar bancos de dados para essas instâncias. Para obter mais informações, consulte [Importar dados para um banco de dados do Amazon RDS para MySQL com tempo de inatividade reduzido](mysql-importing-data-reduced-downtime.md) e [Exportar dados de uma instância de banco de dados MySQL usando replicação](MySQL.Procedural.Exporting.NonRDSRepl.md).
Depois de restaurar a instância de banco de dados com base em um snapshot ou realizar uma recuperação para um ponto no tempo, é possível visualizar a última posição do log binário recuperada do banco de dados de origem no console do RDS. Em **Logs e eventos**, insira **log binário**. A posição do log binário aparece em **Notas do sistema**.
**Topics**
+ [Trabalhar com réplicas de leitura do MySQL](USER_MySQL.Replication.ReadReplicas.md)
+ [Usar a replicação baseada em GTID](mysql-replication-gtid.md)
+ [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](MySQL.Procedural.Importing.External.Repl.md)
+ [Configurar a replicação de várias fontes do Amazon RDS para MySQL](mysql-multi-source-replication.md)
# Trabalhar com réplicas de leitura do MySQL
A seguir, você pode encontrar informações específicas sobre como trabalhar com réplicas de leitura no RDS para MySQL. Para obter informações gerais sobre as réplicas de leitura e as instruções de como usá-las, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Para ter mais informações sobre réplicas de leitura do MySQL, consulte os tópicos a seguir.
+ [Configurar filtros de replicação com MySQL](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md)
+ [Configurar replicação atrasada com o MySQL](USER_MySQL.Replication.ReadReplicas.DelayReplication.md)
+ [Atualizar réplicas de leitura com o MySQL](USER_MySQL.Replication.ReadReplicas.Updates.md)
+ [Trabalhar com implantações de réplicas de leitura multi-AZ com o MySQL](USER_MySQL.Replication.ReadReplicas.MultiAZ.md)
+ [Usar réplicas de leitura em cascata com o RDS para MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md)
+ [Monitorar o atraso de replicação para réplicas de leitura do MySQL](USER_MySQL.Replication.ReadReplicas.Monitor.md)
+ [Início e interrupção de replicação com réplicas de leitura do MySQL](USER_MySQL.Replication.ReadReplicas.StartStop.md)
+ [Solucionar problemas de uma réplica de leitura do MySQL](USER_ReadRepl.Troubleshooting.md)
## Configurar réplicas de leitura com o MySQL
Antes que uma instância de banco de dados do MySQL possa servir como uma fonte de replicação, certifique-se de habilitar os backups automáticos na instância de banco de dados de origem. Para fazer isso, defina o período de retenção de backup como um valor diferente de 0. Esse requisito também se aplica a uma réplica de leitura que seja a instância de banco de dados de origem de outra réplica de leitura. Os backups automáticos são compatíveis somente com réplicas de leitura que executam qualquer versão do MySQL. Você pode configurar a replicação com base nas coordenadas do log binário para uma instância de banco de dados MySQL.
Você pode configurar a replicação usando identificadores de transação global (GTIDs) nas seguintes versões:
+ RDS para MySQL versão 5.7.44 e versões 5.7 posteriores
+ RDS para MySQL versão 8.0.28 e versões 8.0 posteriores
+ RDS para MySQL versão 8.4.3 e versões 8.4 posteriores
Para obter mais informações, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
Você pode criar até quinze réplicas de leitura de uma instância de banco de dados na mesma região. Para que a replicação funcione efetivamente, cada réplica de leitura deve ter a mesma quantidade de recursos de computação e de armazenamento que a instância de banco de dados de origem. Se você dimensionar a instância de banco de dados de origem, dimensione as réplicas de leitura também.
O RDS para MySQL é compatível com réplicas de leitura em cascata. Para saber mais sobre como configurar réplicas de leitura em cascata, consulte [Usar réplicas de leitura em cascata com o RDS para MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md).
É possível executar várias ações simultâneas de criação ou exclusão de réplicas de leitura que fazem referência à mesma instância de banco de dados de origem. Ao realizar essas ações, permaneça dentro do limite de quinze réplicas de leitura para cada instância de origem.
Uma réplica de leitura de uma instância de banco de dados MySQL não pode usar uma versão de mecanismo de banco de dados inferior à sua instância de banco de dados de origem.
### Preparar instâncias de banco de dados MySQL que usam MyISAM
Se sua instância de banco de dados MySQL usar um mecanismo não transacional, como o MyISAM, será necessário realizar as etapas a seguir para configurar sua réplica de leitura com sucesso. Essas etapas são necessárias para garantir que a réplica de leitura tenha uma cópia consistente de seus dados. Essas etapas não são necessárias caso todas as suas tabelas utilizem um mecanismo transacional como InnoDB.
1. Interrompa todas as operações de linguagem de manipulação de dados (DML) e de linguagem de definição de dados (DDL) em tabelas não transacionais na instância de banco de dados de origem e aguarde pela conclusão delas. Comandos SELECIONAR podem continuar sendo executados.
1. Descarregue e bloqueie as tabelas na instância do banco de dados de origem.
1. Crie a réplica de leitura usando um dos métodos nas seções a seguir.
1. Verifique o andamento da criação da réplica de leitura usando, por exemplo, a operação da API `DescribeDBInstances`. Após a réplica de leitura estar disponível, desbloqueie as tabelas da instância de banco de dados de origem e retome as operações de banco de dados normais.
# Configurar filtros de replicação com MySQL
Você pode usar filtros de replicação para especificar quais bancos de dados e tabelas são replicados com uma réplica de leitura. Os filtros de replicação podem incluir bancos de dados e tabelas na replicação ou excluí-los da replicação.
Veja a seguir alguns casos de uso para filtros de replicação:
+ Para reduzir o tamanho de uma réplica de leitura. Com a filtragem de replicação, você pode excluir os bancos de dados e tabelas que não são necessários na réplica de leitura.
+ Para excluir bancos de dados e tabelas de réplicas de leitura por motivos de segurança.
+ Para replicar diferentes bancos de dados e tabelas para casos de uso específicos em diferentes réplicas de leitura. Por exemplo, você pode usar réplicas de leitura específicas para análise ou fragmentação.
+ Para uma instância de banco de dados que tenha réplicas de leitura em diferentes Regiões da AWS, para replicar diferentes bancos de dados ou tabelas em diferentes Regiões da AWS.
**nota**
É possível usar filtros de replicação para especificar quais bancos de dados e tabelas serão replicados com uma instância de banco de dados primária do MySQL configurada como uma réplica em uma topologia de replicação de entrada. Para obter mais informações sobre essa configuração, consulte [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](MySQL.Procedural.Importing.External.Repl.md).
**Topics**
+ [Configurar parâmetros de filtragem de replicação para o RDS para MySQL](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [Limitações de filtragem de replicação do RDS para MySQL](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [Exemplos de filtragem de replicação do RDS para MySQL](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [Visualizar os filtros de replicação para uma réplica de leitura](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Viewing)
## Configurar parâmetros de filtragem de replicação para o RDS para MySQL
Para configurar filtros de replicação, defina os seguintes parâmetros de filtragem de replicação na réplica de leitura:
+ `replicate-do-db` – Replicar alterações nos bancos de dados especificados. Quando você define esse parâmetro para uma réplica de leitura, somente os bancos de dados especificados no parâmetro são replicados.
+ `replicate-ignore-db` – Não replique as alterações nos bancos de dados especificados. Quando o parâmetro `replicate-do-db` é definido para uma réplica de leitura, esse parâmetro não é avaliado.
+ `replicate-do-table` – Replicar alterações nas tabelas especificadas. Quando você define esse parâmetro para uma réplica de leitura, somente as tabelas especificadas no parâmetro são replicadas. Além disso, quando o parâmetro `replicate-do-db` ou `replicate-ignore-db` estiver definido, certifique-se de incluir o banco de dados que inclui as tabelas especificadas na replicação com a réplica de leitura.
+ `replicate-ignore-table` – Não replique as alterações nas tabelas especificadas. Quando o parâmetro `replicate-do-table` é definido para uma réplica de leitura, esse parâmetro não é avaliado.
+ `replicate-wild-do-table` – Replicar tabelas com base nos padrões de nome de banco de dados e tabela especificados. Os caracteres curinga `%` e `_` são compatíveis. Quando o parâmetro `replicate-do-db` ou `replicate-ignore-db` estiver definido, certifique-se de incluir o banco de dados que inclui as tabelas especificadas na replicação com a réplica de leitura.
+ `replicate-wild-ignore-table` – Não replique tabelas com base nos padrões de nome de banco de dados e tabela especificados. Os caracteres curinga `%` e `_` são compatíveis. Quando o parâmetro `replicate-do-table` ou `replicate-wild-do-table` é definido para uma réplica de leitura, esse parâmetro não é avaliado.
Os parâmetros são avaliados na ordem em que estão listados. Para obter mais informações sobre como esses parâmetros funcionam, consulte a documentação do MySQL:
+ Para obter informações gerais, consulte [ Opções e variáveis do servidor de réplica](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html).
+ Para obter informações sobre como os parâmetros de filtragem de replicação de banco de dados são avaliados, consulte [ Avaliação de opções de replicação em nível de banco de dados e log binário](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-db-options.html).
+ Para obter informações sobre como os parâmetros de filtragem de replicação de tabela são avaliados, consulte [ Avaliação de opções de replicação em nível de tabela](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-table-options.html).
Por padrão, cada um desses parâmetros tem um valor vazio. Em cada réplica de leitura, você pode usar esses parâmetros para definir, alterar e excluir filtros de replicação. Quando você define um desses parâmetros, separe cada filtro dos outros com uma vírgula.
Você pode usar `%` os caracteres curinga `_` e nos parâmetros `replicate-wild-do-table` e `replicate-wild-ignore-table`. O curinga `%` corresponde a qualquer número de caracteres e o caractere curinga `_` corresponde apenas a um caractere.
O formato de log binário da instância de banco de dados de origem é importante para replicação porque determina o registro de alterações de dados. A configuração do parâmetro `binlog_format` determina se a replicação é baseada em linha ou baseada em declaração. Para obter mais informações, consulte [Configurar o registro em log binário do RDS para MySQL para bancos de dados single-AZ](USER_LogAccess.MySQL.BinaryFormat.md).
**nota**
Todas as instruções DDL (Data Definition Language, linguagem de definição de dados) são replicadas como instruções, independentemente da `binlog_format` configuração na instância de banco de dados de origem.
## Limitações de filtragem de replicação do RDS para MySQL
As seguintes limitações aplicam-se à filtragem de replicação para o RDS para MySQL:
+ Cada parâmetro de filtragem de replicação tem um limite de 2.000 caracteres.
+ As vírgulas não são aceitas em filtros de replicação para valores de parâmetros. Em uma lista de parâmetros, as vírgulas só podem ser usadas como separadores de valores. Por exemplo, `ParameterValue='`a,b`'` não é aceito, mas `ParameterValue='a,b'` é.
+ O MySQL `--binlog-do-db` e `--binlog-ignore-db` as opções para filtragem de log binário não são compatíveis.
+ A filtragem de replicação não suporta transações XA.
Para obter mais informações, consulte [Restrictions on XA Transactions](https://dev.mysql.com/doc/refman/8.0/en/xa-restrictions.html) na documentação do MySQL.
## Exemplos de filtragem de replicação do RDS para MySQL
Para configurar a filtragem de replicação para uma réplica de leitura, modifique os parâmetros de filtragem de replicação no grupo de parâmetros associado à réplica de leitura.
**nota**
Não é possível modificar um grupo de parâmetros padrão. Se a réplica de leitura estiver usando um grupo de parâmetros padrão, crie um novo grupo de parâmetros e o associe à instância de banco de dados. Para obter mais informações sobre grupos de parâmetros de banco de dados, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Você pode definir parâmetros em um grupo de parâmetros usando a Console de gerenciamento da AWS, a AWS CLI ou a API do RDS. Para obter informações sobre como configurar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). Quando você define parâmetros em um grupo de parâmetros, todas as instâncias de banco de dados associadas ao grupo de parâmetros usam as configurações de parâmetro. Se você definir os parâmetros de filtragem de replicação em um grupo de parâmetros, verifique se o grupo de parâmetros está associado apenas a réplicas de leitura. Deixe os parâmetros de filtragem de replicação vazios para instâncias de banco de dados de origem.
Os exemplos a seguir definem os parâmetros usando o AWS CLI. Estes exemplos definem `ApplyMethod` para `immediate` de modo que as mudanças do parâmetro ocorram imediatamente depois que o comando CLI termina. Se você quiser que uma alteração pendente seja aplicada depois que a réplica de leitura for reinicializada, defina como `ApplyMethod` `pending-reboot`.
Os exemplos a seguir definem filtros de replicação:
+ [Including databases in replication](#rep-filter-in-dbs-mysql)
+ [Including tables in replication](#rep-filter-in-tables-mysql)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mysql)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mysql)
+ [Excluding tables from replication](#rep-filter-ex-tables-mysql)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mysql)
**Example Incluir bancos de dados em replicação**
O exemplo a seguir inclui os bancos de dados `mydb1` e `mydb2` na replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
**Example Incluir tabelas na replicação**
O exemplo a seguir inclui as tabelas `table1` e `table2` no banco de dados `mydb1` na replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
**Example Incluir tabelas na replicação usando caracteres curinga**
O exemplo a seguir inclui tabelas com nomes que começam com `order` e `return` no banco de dados `mydb` na replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
**Example Excluir bancos de dados da replicação**
O exemplo a seguir exclui os bancos de dados `mydb5` e `mydb6` da replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
**Example Excluir tabelas da replicação**
O exemplo a seguir exclui a tabela `table1` no banco de dados `mydb5` e a tabela `table2` no banco de dados `mydb6` da replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
**Example Excluir tabelas da replicação usando caracteres curinga**
O exemplo a seguir exclui tabelas com nomes que começam com `order` e `return` no banco de dados `mydb7` da replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
## Visualizar os filtros de replicação para uma réplica de leitura
Você pode visualizar os filtros de replicação de uma réplica de leitura das seguintes maneiras:
+ Verifique as configurações dos parâmetros de filtragem de replicação no grupo de parâmetros associado à réplica de leitura.
Para obter instruções, consulte [Visualizar valores de parâmetros para um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Viewing.md).
+ Em um cliente MySQL, conecte-se à réplica de leitura e execute a instrução `SHOW REPLICA STATUS`.
Na saída, os campos a seguir mostram os filtros de replicação para a réplica de leitura:
+ `Replicate_Do_DB`
+ `Replicate_Ignore_DB`
+ `Replicate_Do_Table`
+ `Replicate_Ignore_Table`
+ `Replicate_Wild_Do_Table`
+ `Replicate_Wild_Ignore_Table`
Para obter mais informações sobre esses campos, consulte [Verificar o status da replicação](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) na documentação do MySQL.
# Configurar replicação atrasada com o MySQL
Você pode usar a replicação atrasada como uma estratégia para a recuperação de desastres. Com a replicação atrasada, você especifica o tempo mínimo, em segundos, para atrasar a replicação da origem para a réplica de leitura. Em caso de um desastre, como uma tabela excluída acidentalmente, você executa as seguintes etapas para recuperar-se rapidamente do desastre:
+ Interrompa a replicação da réplica de leitura antes que a alteração que causou o desastre seja enviada para ela.
Use o procedimento armazenado [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) para interromper a replicação.
+ Inicie a replicação e especifique que a replicação deve ser interrompida automaticamente em um local do arquivo de log.
Especifique um local imediatamente antes do desastre usando o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
+ Promova a réplica de leitura para ser a nova instância de banco de dados de origem usando as instruções em [Promoção de uma réplica de leitura a uma instância de banco de dados autônoma](USER_ReadRepl.Promote.md).
**nota**
No RDS para MySQL 8.4, a replicação atrasada tem suporte para o MySQL 8.4.3 e versões posteriores. No RDS para MySQL 8.0, a replicação atrasada tem suporte para o MySQL 8.0.28 e versões posteriores. No RDS para MySQL 5.7, a replicação atrasada é compatível com o MySQL 5.7.44 e posterior.
Use procedimentos armazenados para configurar a replicação atrasada. Você não pode configurar a replicação atrasada com o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS.
Você pode usar a replicação com base em identificadores de transação global (GTIDs) em uma configuração de replicação atrasada para as seguintes versões:
RDS para MySQL versão 5.7.44 e versões 5.7 posteriores
RDS para MySQL versão 8.0.28 e versões 8.0 posteriores
RDS para MySQL versão 8.4.3 e versões 8.4 posteriores
Caso você use a replicação baseada em GTID, use o procedimento armazenado [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) em vez do procedimento armazenado [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). Para obter mais informações sobre a replicação baseada em GTID, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
**Topics**
+ [Configurar replicação atrasada durante a criação da réplica de leitura](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [Modificar replicação atrasada de uma réplica de leitura existente](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [Configurar um local para interromper a replicação para uma réplica de leitura](#USER_MySQL.Replication.ReadReplicas.DelayReplication.StartUntil)
+ [Promover uma réplica de leitura](#USER_MySQL.Replication.ReadReplicas.DelayReplication.Promote)
## Configurar replicação atrasada durante a criação da réplica de leitura
Para configurar a replicação atrasada para qualquer réplica de leitura futura criada a partir de uma instância de banco de dados, execute o procedimento armazenado [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) com o parâmetro `target delay`.
**Para configurar a replicação atrasada durante a criação da réplica de leitura**
1. Usando um cliente MySQL, conecte-se à instância de banco de dados MySQL que será a origem para réplicas de leitura como o usuário mestre.
1. Execute o procedimento armazenado [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) com o parâmetro `target delay`.
Por exemplo, execute o procedimento armazenado a seguir para especificar que a replicação é atrasada em pelo menos uma hora (3,600 segundos) para qualquer réplica de leitura criada a partir da instância de banco de dados atual.
```
call mysql.rds_set_configuration('target delay', 3600);
```
**nota**
Após executar esse procedimento armazenado, qualquer réplica de leitura que você criar usando a AWS CLI ou a API do Amazon RDS será configurada com a replicação atrasada pelo número de segundos especificado.
## Modificar replicação atrasada de uma réplica de leitura existente
Para modificar a replicação atrasada para uma réplica de leitura existente, execute o procedimento armazenado [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
**Para modificar a replicação atrasada para uma réplica de leitura existente**
1. Usando um cliente do MySQL, conecte-se à réplica de leitura como o usuário mestre.
1. Use o procedimento armazenado [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) para interromper a replicação.
1. Execute o procedimento armazenado [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
Por exemplo, execute o procedimento armazenado a seguir para especificar que a replicação para a réplica de leitura é atrasada em pelo menos uma hora (3.600 segundos) para qualquer réplica de leitura criada a partir da instância de banco de dados atual.
```
call mysql.rds_set_source_delay(3600);
```
1. Use o procedimento armazenado [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) para iniciar a replicação.
## Configurar um local para interromper a replicação para uma réplica de leitura
Após interromper a replicação para a réplica de leitura, você pode começar a replicação e interrompê-la em um local especificado do arquivo de log binário usando o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
**Para iniciar a replicação para uma Réplica de leitura e interrompê-la em um local específico**
1. Usando um cliente do MySQL, conecte-se à instância de banco de dados MySQL de origem como o usuário mestre.
1. Execute o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
O exemplo a seguir inicia a replicação e replica as alterações até que ela atinja o local `120` no arquivo de log binário `mysql-bin-changelog.000777`. Em um cenário de recuperação de desastres, suponha que o local `120` é imediatamente antes do desastre.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
A replicação é interrompida automaticamente quando o ponto de interrupção é atingido. O seguinte evento do RDS é gerado: `Replication has been stopped since the replica reached the stop point specified by the rds_start_replication_until stored procedure`.
## Promover uma réplica de leitura
Após a replicação ser interrompida, em um cenário de recuperação de desastres, você pode promover uma réplica de leitura para ser a nova instância de banco de dados de origem. Para obter informações sobre como promover uma réplica de leitura, consulte [Promoção de uma réplica de leitura a uma instância de banco de dados autônoma](USER_ReadRepl.Promote.md).
# Atualizar réplicas de leitura com o MySQL
As réplicas de leitura foram projetadas para oferecer suporte a consultas de leitura, mas você pode precisar fazer atualizações ocasionais. Por exemplo, talvez seja necessário adicionar um índice para otimizar tipos específicos de consultas que acessam a réplica.
Embora você possa habilitar as atualizações definindo o parâmetro `read_only` como `0` no grupo de parâmetros de banco de dados para a réplica de leitura, é recomendável não fazer isso, pois essa ação pode causar problemas se a réplica de leitura tornar-se incompatível com a instância de banco de dados de origem. Para operações de manutenção, recomendamos que você use implantações azul/verde. Para obter mais informações, consulte [Usar implantações azul/verde para atualizações de banco de dados](blue-green-deployments.md).
Se você desabilitar a opção somente leitura em uma réplica de leitura, altere o valor do parâmetro `read_only` de volta para `1` o mais rápido possível.
# Trabalhar com implantações de réplicas de leitura multi-AZ com o MySQL
É possível criar uma réplica de leitura a partir de implantações de instâncias de banco de dados single-AZ ou multi-AZ. Você pode usar implantações multi-AZ para melhorar a durabilidade e a disponibilidade de dados essenciais. No entanto, não é possível usar o multi-AZ secundário para atender a consultas somente leitura. Em vez disso, crie réplicas de leitura de instâncias de banco de dados multi-AZ de alto tráfego para descarregar consultas somente leitura. Se a instância de origem de uma implantação multi-AZ falhar na secundária, todas as réplicas de leitura associadas serão automaticamente alteradas para usar a secundária (não a primária) como a origem de replicação. Para obter mais informações, consulte [Configurar e gerenciar uma implantação multi-AZ para o Amazon RDS](Concepts.MultiAZ.md).
É possível criar uma réplica de leitura como uma instância de banco de dados multi-AZ. O Amazon RDS cria um em modo de espera de sua réplica em outra zona de disponibilidade para suporte a failover da réplica. Você pode criar a réplica de leitura como uma instância de banco de dados multi-AZ independentemente de o banco de dados de origem ser ou não uma instância de banco de dados multi-AZ.
# Usar réplicas de leitura em cascata com o RDS para MySQL
O RDS para MySQL é compatível com réplicas de leitura em cascata. Com *réplicas de leitura em cascata*, é possível escalar leituras sem adicionar sobrecarga à instância de banco de dados do RDS para MySQL de origem.
Com réplicas de leitura em cascata, sua instância de banco de dados do RDS para MySQL envia dados para a primeira réplica de leitura da cadeia. Essa réplica de leitura envia dados para a segunda réplica na cadeia e assim por diante. O resultado final é que todas as réplicas de leitura na cadeia têm as alterações da instância de banco de dados do RDS para MySQL DB, mas sem a sobrecarga apenas na instância de banco de dados de origem.
É possível criar uma série de até três réplicas de leitura em uma cadeia de uma instância de banco de dados de origem do RDS para MySQL. Por exemplo, suponha que você tenha uma instância de banco de dados do RDS para MySQL, `mysql-main`. Você pode fazer o seguinte:
+ Começando com `mysql-main`, crie a primeira réplica de leitura na cadeia, `read-replica-1`.
+ Na `read-replica-1`, crie a próxima réplica de leitura na cadeia, `read-replica-2`.
+ Finalmente, na `read-replica-2`, crie a terceira réplica de leitura na cadeia, `read-replica-3`.
Não é possível criar outra réplica de leitura além dessa terceira réplica de leitura em cascata na série de `mysql-main`. Uma série completa de instâncias de uma instância de banco de dados de origem do RDS para MySQL até o final de uma série de réplicas de leitura em cascata pode consistir em, no máximo, quatro instâncias de banco de dados.
Para que as réplicas de leitura em cascata funcionem, cada instância de banco de dados do RDS para MySQL de origem deve ter os backups automatizados ativados. Para ativar backups automáticos em uma réplica de leitura, primeiro crie a réplica de leitura e a modifique para ativar backups automáticos. Para ter mais informações, consulte [Como criar uma réplica de leitura](USER_ReadRepl.Create.md).
Como em qualquer réplica de leitura, é possível promover uma réplica de leitura que faz parte de uma cascata. A promoção de uma réplica de leitura de uma cadeia de réplicas de leitura remove essa réplica da cadeia. Por exemplo, suponha que você queira mover parte da workload da instância de banco de dados `mysql-main` para uma nova instância para uso somente pelo departamento de contabilidade. Pressupondo a cadeia com três réplicas de leitura do exemplo, você decide promover `read-replica-2`. A cadeia é afetada da seguinte forma:
+ A promoção de `read-replica-2` a remove da cadeia de replicação.
+ Ela agora é uma instância de banco de dados de leitura/gravação completa.
+ Ela continua replicando para `read-replica-3`, da mesma forma como estava fazendo antes da promoção.
+ A `mysql-main` continua a replicar para a `read-replica-1`.
Para obter mais informações sobre como promover réplicas de leitura, consulte [Promoção de uma réplica de leitura a uma instância de banco de dados autônoma](USER_ReadRepl.Promote.md).
# Monitorar o atraso de replicação para réplicas de leitura do MySQL
Para as réplicas de leitura do MySQL, você pode monitorar o atraso da replicação no Amazon CloudWatch visualizando a métrica `ReplicaLag` do Amazon RDS. A métrica `ReplicaLag` relata o valor do campo `Seconds_Behind_Master` do comando `SHOW REPLICA STATUS`.
As causas comuns para o atraso da replicação do MySQL são as seguintes:
+ Uma queda de rede.
+ Gravação em tabelas com índices diferentes em uma réplica de leitura. Se o parâmetro `read_only` estiver definido como `0` na réplica de leitura, a replicação poderá ser interrompida se a réplica de leitura torna-se incompatível com a instância de banco de dados de origem. Depois de realizar tarefas de manutenção na réplica de leitura, recomendamos que você defina o parâmetro `read_only` de volta para `1`.
+ Uso de um mecanismo de armazenamento não transacional, como o MyISAM. A replicação só é compatível com o mecanismo de armazenamento InnoDB no MySQL.
Quando a métrica `ReplicaLag` chega a 0, isso mostra que a réplica alcançou a instância do banco de dados de origem. Se a métrica `ReplicaLag` retornar -1, então a replicação não está ativa no momento. `ReplicaLag` = -1 é equivalente a `Seconds_Behind_Master` = `NULL`.
# Início e interrupção de replicação com réplicas de leitura do MySQL
Você pode interromper e reiniciar o processo de replicação em uma instância de banco de dados do Amazon RDS ao chamar os procedimentos armazenados do sistema [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication). Você pode fazer isso ao replicar entre duas instâncias do Amazon RDS para operações de longa duração, como a criação de índices grandes. Você também precisa interromper e iniciar a replicação ao importar ou exportar bancos de dados. Para obter mais informações, consulte [Importar dados para um banco de dados do Amazon RDS para MySQL com tempo de inatividade reduzido](mysql-importing-data-reduced-downtime.md) e [Exportar dados de uma instância de banco de dados MySQL usando replicação](MySQL.Procedural.Exporting.NonRDSRepl.md).
Se a replicação for interrompida por mais de 30 dias consecutivos, seja manualmente ou devido a um erro de replicação, o Amazon RDS a encerrará entre a instância de banco de dados de origem e todas as réplicas de leitura. Isso acontece para evitar um aumento nos requisitos de armazenamento da instância de banco de dados de origem e nos tempos de failover prolongado. A instância de banco de dados da réplica de leitura ainda está disponível. No entanto, a replicação não pode ser retomada porque os logs binários exigidos pela réplica de leitura são excluídos da instância de banco de dados de origem após a conclusão da replicação. Você pode criar uma nova réplica de leitura para a instância de banco de dados de origem a fim de restabelecer a replicação.
# Solucionar problemas de uma réplica de leitura do MySQL
Para instâncias de bancos de dados MySQL, em alguns casos as réplicas de leitura apresentam erros de replicação ou inconsistências de dados entre a réplica de leitura e sua fonte da instância de banco de dados. Esse problema ocorre quando alguns eventos de log binário (binlog) ou logs redo do InnoDB não são liberados durante uma falha da réplica de leitura ou da instância de banco de dados de origem. Nesses casos, exclua e recrie manualmente as réplicas de leitura. Você pode reduzir a chance disso acontecer definindo os seguintes valores de parâmetro: `sync_binlog=1` e `innodb_flush_log_at_trx_commit=1`. Essas configurações podem reduzir a performance, portanto, teste o impacto delas antes de implantar as alterações em um ambiente de produção.
**Atenção**
No grupo de parâmetros associado à fonte da instância de banco de dados, recomendamos manter esses valores de parâmetros: `sync_binlog=1` e `innodb_flush_log_at_trx_commit=1`. Esses parâmetros são dinâmicos. Se você não quiser usar essas configurações, recomendamos definir temporariamente esses valores antes de executar qualquer operação na fonte da instância de banco de dados que possa fazer com que ela seja reiniciada. Essas operações incluem, entre outras, a reinicialização, a reinicialização com failover, a atualização da versão do banco de dados e a alteração da classe de instância de banco de dados ou seu armazenamento. A mesma recomendação se aplica à criação de novas réplicas de leitura para a fonte da instância de banco de dados.
Não seguir essa orientação aumenta o risco de réplicas de leitura apresentarem erros de replicação ou inconsistências de dados (ou ambas) entre a réplica de leitura e sua fonte da instância de banco de dados.
As tecnologias de replicação do MySQL são assíncronas. Como são assíncronas, são esperados ocasionais aumentos de `BinLogDiskUsage` na instância de banco de dados de origem e `ReplicaLag` na réplica de leitura. Por exemplo, um volume elevado de operações de gravação para a instância de banco de dados de origem pode ocorrer em paralelo. Por outro lado, as operações de gravação na réplica de leitura são serializadas usando um único thread de E/S, o que pode ocasionar um atraso entre a instância de origem e a réplica de leitura. Para obter mais informações sobre réplicas somente leitura na documentação do MySQL, consulte [Detalhes de implantação da replicação](https://dev.mysql.com/doc/refman/8.0/en/replication-implementation-details.html).
Você pode fazer várias coisas para reduzir o atraso entre as atualizações de uma instância de banco de dados de origem e as atualizações subsequentes da réplica de leitura, como o seguinte:
+ Dimensionar uma réplica de leitura para ter um tamanho de armazenamento e uma categoria de instância de banco de dados comparáveis à da instância de banco de dados de origem.
+ Assegurar-se de que as configurações de parâmetros nos grupos de parâmetros de banco de dados utilizados pela instância de banco de dados de origem e pela réplica de leitura são compatíveis. Para mais informações e um exemplo, consulte a discussão sobre o parâmetro `max_allowed_packet` posteriormente nesta seção.
O Amazon RDS monitora o status de replicação de suas réplicas de leitura e atualiza o campo `Replication State` da instância da réplica de leitura para `Error` caso a replicação seja interrompida por qualquer motivo. Um exemplo pode ser se as consultas DML forem executadas no seu conflito de réplica de leitura com as atualizações feitas na instância de banco de dados de origem.
Você pode analisar os detalhes do erro associado gerado pelo mecanismo do MySQL visualizando o campo `Replication Error`. Os eventos que indicam o status da réplica de leitura também são gerados, incluindo [RDS-EVENT-0045](USER_Events.Messages.md#RDS-EVENT-0045), [RDS-EVENT-0046](USER_Events.Messages.md#RDS-EVENT-0046) e [RDS-EVENT-0047](USER_Events.Messages.md#RDS-EVENT-0047). Para mais informações sobre eventos e como se inscrever neles, consulte [Trabalhar com a notificação de eventos do Amazon RDS](USER_Events.md). Se for retornada uma mensagem de erro do MySQL, analise o número de erro na [ documentação de mensagens de erro do MySQL](https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html).
Um problema comum que pode causar erros de replicação é quando o valor do parâmetro `max_allowed_packet` para uma réplica de leitura é menor que o do parâmetro `max_allowed_packet` para a instância de banco de dados de origem. O parâmetro `max_allowed_packet` é um parâmetro personalizado que você pode definir em um grupo de parâmetros de banco de dados. Use o `max_allowed_packet` para especificar o tamanho máximo do código DML que pode ser executado no banco de dados. Em alguns casos, o valor do `max_allowed_packet` no grupo de parâmetros de banco de dados associado a uma réplica de leitura é menor do que o valor de `max_allowed_packet` no grupo de parâmetros de banco de dados associado à instância de banco de dados de origem. Nesses casos, o processo de replicação pode lançar o erro `Packet bigger than 'max_allowed_packet' bytes` e interromper a replicação. Para corrigir o erro, faça com que a instância de banco de dados de origem e a réplica de leitura usem grupos de parâmetros de banco de dados com os mesmos valores de parâmetro `max_allowed_packet`
Outras situações comuns que podem causar erros de replicação incluem o seguinte:
+ A gravação em tabelas em uma réplica de leitura. Em alguns casos, é possível criar índices em uma réplica de leitura diferentes dos índices na instância de banco de dados da origem. Se você fizer isso, defina o parâmetro `read_only` como `0` para criar índices. Se você gravar em tabelas na réplica de leitura, isso poderá interromper a replicação se a réplica de leitura tornar-se incompatível com a instância de banco de dados de origem. Depois de realizar tarefas de manutenção na réplica de leitura, recomendamos que você defina o parâmetro `read_only` de volta para `1`.
+ Uso de um mecanismo de armazenamento não transacional, como o MyISAM. As réplicas de leitura exigem um mecanismo de armazenamento transacional. A replicação só é compatível com o mecanismo de armazenamento InnoDB no MySQL.
+ Usando consultas não deterministas inseguras, como `SYSDATE()`. Para obter mais informações, consulte [Determinação de instruções seguras e inseguras no registro de logs binários](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html).
Se você acreditar que pode ignorar um erro com segurança, siga as etapas descritas na seção [Ignorar o erro de replicação atual para o RDS para MySQL](Appendix.MySQL.CommonDBATasks.SkipError.md). Caso contrário, você pode excluir a réplica de leitura primeiro. Crie uma instância usando o mesmo identificador de instância de banco de dados para que o endpoint permaneça o mesmo que o da sua antiga réplica de leitura. Se um erro de replicação for corrigido, o `Replication State` mudará para *replicating*.
# Usar a replicação baseada em GTID
O conteúdo a seguir explica como usar identificadores de transações globais (GTIDs) com a replicação de logs binários (binlog) entre instâncias de banco de dados do Amazon RDS para MySQL.
Se você usa a replicação de logs binários e não conhece a replicação baseada em GTID com o MySQL, consulte [Replication with global transaction identifiers](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids.html) na documentação do MySQL.
A replicação baseada em GTID é compatível com as seguintes versões:
+ Todas as versões do RDS para MySQL 8.4
+ Todas as versões do RDS para MySQL 8.0
+ Todas as versões do RDS para MySQL 5.7
Todas as instâncias de banco de dados do MySQL em uma configuração de replicação devem atender a esse requisito de versão.
**Topics**
+ [Visão geral dos identificadores de transações globais (GTIDs)](#mysql-replication-gtid.overview)
+ [Parâmetros para replicação baseada em GTID](#mysql-replication-gtid.parameters)
+ [Ativar a replicação baseada em GTID para novas réplicas de leitura para RDS para MySQL](mysql-replication-gtid.configuring-new-read-replicas.md)
+ [Ativar a replicação baseada em GTID para réplicas de leitura existentes para RDS para MySQL](mysql-replication-gtid.configuring-existing-read-replicas.md)
+ [Desabilitação da replicação baseada em GTID para uma instância de banco de dados do RDS for MySQL com réplicas de leitura](mysql-replication-gtid.disabling.md)
## Visão geral dos identificadores de transações globais (GTIDs)
*GTIDs* são identificadores exclusivos gerados para transações MySQL confirmadas. Você pode usar GTIDs para tornar a replicação de log binário mais simples e fácil de solucionar.
O MySQL usa dois tipos diferentes de transações para a replicação de log binário:
+ *Transações GTID* – Transações identificadas por um GTID.
+ *Transações anônimas* – transações que não têm um GTID atribuído.
Em uma configuração de replicação, GTIDs são exclusivos entre todas as instâncias de banco de dados. Os GTIDs simplificam a configuração da replicação porque ao usá-los você não precisa consultar posições de arquivo de log. Os GTIDs também facilitam o rastreamento de transações replicadas e a determinação da consistência da instância de origem e de réplicas.
É possível usar replicação baseada em GTID para replicar dados com réplicas de leitura do RDS for MySQL. É possível configurar a replicação baseada em GTID ao criar réplicas de leitura ou você pode converter réplicas de leitura existentes para usar a replicação baseada em GTID.
Você também pode utilizar a replicação baseada em GTID em uma configuração de replicação atrasada com o RDS for MySQL. Para ter mais informações, consulte [Configurar replicação atrasada com o MySQL](USER_MySQL.Replication.ReadReplicas.DelayReplication.md).
## Parâmetros para replicação baseada em GTID
Use os parâmetros a seguir para configurar a replicação baseada em GTID.
| Parâmetro | Valores válidos | Descrição |
| --- | --- | --- |
| `gtid_mode` | `OFF`, `OFF_PERMISSIVE`, `ON_PERMISSIVE`, `ON` | `OFF` especifica que novas transações são anônimas (ou seja, não têm GTIDs) e que uma transação deve ser anônima para ser replicada. `OFF_PERMISSIVE` especifica que novas transações são anônimas, mas todas podem ser replicadas. `ON_PERMISSIVE` especifica que novas transações são GTID, mas todas podem ser replicadas. `ON` especifica que novas transações são GTID e que uma transação deve ser GTID para ser replicada. |
| `enforce_gtid_consistency` | `OFF`, `ON`, `WARN` | `OFF` permite que as transações violem a consistência GTID. `ON` evita que as transações violem a consistência GTID. `WARN` permite que as transações violem a consistência GTID, mas gera um aviso quando ocorre uma violação. |
**nota**
No Console de gerenciamento da AWS, o parâmetro `gtid_mode` aparece como `gtid-mode`.
Para a replicação baseada em GTID, use estas configurações para o grupo de parâmetros da instância de banco de dados ou réplica de leitura:
+ `ON` e `ON_PERMISSIVE` somente são aplicáveis à replicação de saída de uma instância de banco de dados do RDS. Esses dois valores fazem com que a sua instância de banco de dados do RDS usem GTIDs para transações que são replicadas. O `ON` requer que o banco de dados de destino também use a replicação baseada em GTID. O `ON_PERMISSIVE` torna a replicação baseada em GTID opcional no banco de dados de destino.
+ `OFF_PERMISSIVE`, se definido, significa que as instâncias de banco de dados do RDS podem aceitar a replicação de entrada de um banco de dados de origem. Eles podem fazer isso independentemente de o banco de dados de origem usar a replicação baseada em GTID.
+ `OFF`, se definido, significa que sua instância de banco de dados do RDS apenas aceita a replicação de entrada de bancos de dados de origem que não usam a replicação baseada em GTID.
Para obter mais informações sobre parameter groups, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
# Ativar a replicação baseada em GTID para novas réplicas de leitura para RDS para MySQL
Quando a replicação baseada em GTID é habilitada para uma instância de banco de dados do RDS for MySQL, a replicação é configurada automaticamente para réplicas de leitura da instância de banco de dados.
**Como habilitar a replicação baseada em GTID para novas réplicas de leitura**
1. Verifique se o grupo de parâmetros associado a uma instância de banco de dados tem as seguintes configurações de parâmetro:
+ `gtid_mode` – `ON` ou `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
Para obter mais informações sobre a definição de parâmetros de configuração usando grupos de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. Se você tiver alterado o grupo de parâmetros da instância de banco de dados, reinicie a instância de banco de dados. Para obter mais informações sobre como fazer isso, consulte [Reinicializar uma instância de banco de dados](USER_RebootInstance.md).
1. Crie uma ou mais réplicas de leitura da instância de banco de dados. Para obter mais informações sobre como fazer isso, consulte [Como criar uma réplica de leitura](USER_ReadRepl.Create.md).
O Amazon RDS tenta estabelecer a replicação baseada em GTID entre a instância de banco de dados do MySQL e as réplicas de leitura usando o `MASTER_AUTO_POSITION`. Caso a tentativa falhe, o Amazon RDS usa posições de arquivo de log na replicação com as réplicas de leitura. Para obter mais informações sobre o `MASTER_AUTO_POSITION`, consulte [ GTID Auto-Positioning](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-auto-positioning.html) na documentação do MySQL.
# Ativar a replicação baseada em GTID para réplicas de leitura existentes para RDS para MySQL
Para uma instância de banco de dados do RDS for MySQL existente com réplicas de leitura que não usam a replicação baseada em GTID, é possível configurar a replicação baseada em GTID entre a instância de banco de dados e as réplicas de leitura.
**Como habilitar a replicação baseada em GTID para réplicas de leitura existentes**
1. Se a instância de banco de dados ou qualquer réplica de leitura estiver utilizando uma versão 8.0 do RDS for MySQL inferior a 8.0.26, faça upgrade da instância de banco de dados ou da réplica de leitura para 8.0.26 ou uma versão posterior do MySQL 8.0. Todas as versões do RDS para MySQL versões 8.4 e 5.7 são compatíveis com replicação baseada em GTID.
Para obter mais informações, consulte [Atualizações do mecanismo de banco de dados do RDS para MySQL](USER_UpgradeDBInstance.MySQL.md).
1. (Opcional) Redefina os parâmetros GTID e teste o comportamento da instância de banco de dados e as réplicas de leitura:
1. Verifique se o grupo de parâmetros associado a uma instância de banco de dados e cada réplica de leitura tem o parâmetro `enforce_gtid_consistency` definido como `WARN`.
Para obter mais informações sobre a definição de parâmetros de configuração usando grupos de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. Se você tiver alterado o grupo de parâmetros da instância de banco de dados, reinicie a instância de banco de dados. Se você tiver alterado o grupo de parâmetros para uma réplica de leitura, reinicie a réplica de leitura.
Para obter mais informações, consulte [Reinicializar uma instância de banco de dados](USER_RebootInstance.md).
1. Execute a instância de banco de dados e as réplicas de leitura com a workload normal e monitore os arquivos de log.
Caso você veja avisos sobre transações incompatíveis com GTID, ajuste o aplicativo de maneira que ele só use recursos compatíveis com GTID. Verifique se a instância de banco de dados não estiver gerando avisos sobre transações incompatíveis com GTID antes de avançar à próxima etapa.
1. Redefina os parâmetros GTID para replicação baseada em GTID que permite transações anônimas até que as réplicas de leitura tenham processado todas elas.
1. Verifique se o grupo de parâmetros associado a uma instância de banco de dados e cada réplica de leitura tem as seguintes configurações de parâmetro:
+ `gtid_mode` – `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
1. Se você tiver alterado o grupo de parâmetros da instância de banco de dados, reinicie a instância de banco de dados. Se você tiver alterado o grupo de parâmetros para uma réplica de leitura, reinicie a réplica de leitura.
1. Aguarde a replicação de todas as transações anônimas. Para verificar se elas estão replicadas, faça o seguinte:
1. Execute a instrução a seguir na instância de banco de dados de origem.
**MySQL 8.4**
```
SHOW BINARY LOG STATUS;
```
**MySQL 5.7 e 8.0**
```
SHOW MASTER STATUS;
```
Observe os valores nas colunas `File` e `Position`.
1. Em cada réplica de leitura, use as informações de arquivo e posição de sua instância de origem na etapa anterior para executar a consulta a seguir.
```
SELECT MASTER_POS_WAIT('file', position);
```
Por exemplo, caso o nome do arquivo seja `mysql-bin-changelog.000031` e a posição seja `107`, execute a declaração a seguir.
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
Se a réplica de leitura ultrapassar a posição especificada, a consulta retornará imediatamente. Do contrário, a função aguarda. Prossiga para a próxima etapa quando a consulta retornar para todas as réplicas de leitura.
1. Redefina os parâmetros GTID apenas para replicação baseada em GTID.
1. Verifique se o grupo de parâmetros associado a uma instância de banco de dados e cada réplica de leitura tem as seguintes configurações de parâmetro:
+ `gtid_mode` – `ON`
+ `enforce_gtid_consistency` – `ON`
1. Reinicialize a instância de banco de dados e cada réplica de leitura.
1. Em cada réplica de leitura, execute o procedimento a seguir.
**MySQL 8.4 e versões principais posteriores**
```
CALL mysql.rds_set_source_auto_position(1);
```
**MySQL 8.0 e versões principais anteriores**
```
CALL mysql.rds_set_master_auto_position(1);
```
# Desabilitação da replicação baseada em GTID para uma instância de banco de dados do RDS for MySQL com réplicas de leitura
Você pode desabilitar a replicação baseada em GTID para uma instância de banco de dados MySQL com réplicas de leitura.
**Para desabilitar a replicação baseada em GTID para uma instância de banco de dados do RDS for MySQL com réplicas de leitura**
1. Em cada réplica de leitura, execute o seguinte procedimento:
**MySQL 8.4 e versões principais posteriores**
```
CALL mysql.rds_set_source_auto_position(0);
```
**MySQL 8.0 e versões principais anteriores**
```
CALL mysql.rds_set_master_auto_position(0);
```
1. Redefina o `gtid_mode` como `ON_PERMISSIVE`.
1. Verifique se o grupo de parâmetros associado a uma instância de banco de dados do MySQL e cada réplica de leitura tem possuem `gtid_mode` definido como `ON_PERMISSIVE`.
Para obter mais informações sobre a definição de parâmetros de configuração usando grupos de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. Reinicialize a instância de banco de dados do MySQL e cada réplica de leitura. Para obter mais informações sobre como reiniciar, consulte [Reinicializar uma instância de banco de dados](USER_RebootInstance.md).
1. Redefina o `gtid_mode` como `OFF_PERMISSIVE`.
1. Verifique se o grupo de parâmetros associado a uma instância de banco de dados do MySQL e cada réplica de leitura tem possuem `gtid_mode` definido como `OFF_PERMISSIVE`.
1. Reinicialize a instância de banco de dados do MySQL e cada réplica de leitura.
1. Aguarde todas as transações GTID serem aplicadas a todas as réplicas de leitura. Para conferir se elas foram aplicadas, siga estas etapas:
1. Na instância de banco de dados do MySQL, execute o comando a seguir:
**MySQL 8.4**
```
SHOW BINARY LOG STATUS
```
**MySQL 5.7 e 8.0**
```
SHOW MASTER STATUS
```
Sua saída deve ser semelhante ao resultado a seguir.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
Observe o arquivo e posicione na saída.
1. Em cada réplica de leitura, use as informações de arquivo e posição de sua instância de origem na etapa anterior para executar a seguinte consulta:
**MySQL 8.4 e MySQL 8.0.26 e versões posteriores do MySQL**
```
SELECT SOURCE_POS_WAIT('file', position);
```
**MySQL 5.7**
```
SELECT MASTER_POS_WAIT('file', position);
```
Por exemplo, caso o nome do arquivo seja `mysql-bin-changelog.000031` e a posição seja `107`, execute a seguinte declaração:
**MySQL 8.4 e MySQL 8.0.26 e versões posteriores do MySQL 8.0**
```
SELECT SOURCE_POS_WAIT('mysql-bin-changelog.000031', 107);
```
**MySQL 5.7**
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
1. Redefina os parâmetros de GTID para desabilitar a replicação baseada em GTID.
1. Verifique se o grupo de parâmetros associado à instância de banco de dados MySQL e cada réplica de leitura possuem as seguintes configurações de parâmetro:
+ `gtid_mode` – `OFF`
+ `enforce_gtid_consistency` – `OFF`
1. Reinicialize a instância de banco de dados do MySQL e cada réplica de leitura.
# Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa
É possível configurar a replicação entre uma instância de banco de dados do RDS para MySQL ou do MariaDB e uma instância do MySQL ou do MariaDB externa ao Amazon RDS usando a replicação de arquivos de log binários.
**Topics**
+ [Antes de começar](#MySQL.Procedural.Importing.External.Repl.BeforeYouBegin)
+ [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](#MySQL.Procedural.Importing.External.Repl.Procedure)
## Antes de começar
Você pode configurar a replicação usando a posição do arquivo de log binário de transações replicadas.
As permissões necessárias para iniciar a replicação em uma instância de banco de dados do Amazon RDS são restritas e não estão disponíveis ao seu usuário mestre do Amazon RDS. Por isso, use os comandos [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) ou [mysql.rds\$1set\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) do Amazon RDS para configurar a replicação entre seu banco de dados on-line e seu banco de dados do Amazon RDS.
Para definir o formato de registro em log binário para um banco de dados MySQL e MariaDB, atualize o parâmetro `binlog_format`. Se a instância de banco de dados usar o grupo de parâmetros da instância de banco de dados padrão, crie um novo grupo de parâmetros de banco de dados para modificar o parâmetro `binlog_format`. No MariaDB e no MySQL 8.0 e versões anteriores, `binlog_format` tem como padrão `MIXED`. No entanto, você também pode definir o `binlog_format` como `ROW` ou `STATEMENT` se precisar de um formato específico de log binário (binlog). Reinicie a instância de banco de dados para que a alteração entre em vigor. No MySQL 8.4 e versões superiores, `binlog_format` tem como padrão `ROW`.
Para obter informações sobre como definir o parâmetro `binlog_format`, consulte [Configurar o registro em log binário do RDS para MySQL para bancos de dados single-AZ](USER_LogAccess.MySQL.BinaryFormat.md). Para obter informações sobre as implicações de tipos de replicação do MySQL diferentes, consulte [Vantagens e desvantagens da replicação baseada em instrução e baseada em linha](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html) na documentação do MySQL.
## Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa
Siga estas diretrizes ao configurar uma instância de origem externa e uma réplica no Amazon RDS:
+ Monitore eventos de failover para a instância do banco de dados do Amazon RDS, que é sua réplica. Se ocorrer um failover, a instância de banco de dados que for a sua réplica poderá ser recriada em um novo host com um endereço de rede diferente. Para obter informações sobre como monitorar eventos de failover, consulte [Trabalhar com a notificação de eventos do Amazon RDS](USER_Events.md).
+ Retenha os logs binários na instância de origem até confirmar que eles foram aplicados à réplica. Esta manutenção garante que seja possível restaurar sua instância de origem em caso de falha.
+ Ative backups automatizados na sua instância de banco de dados do Amazon RDS. Ativar backups automáticos garante que seja possível restaurar sua réplica para um determinado ponto no tempo, caso seja necessário ressincronizar sua instância de origem e sua réplica. Para obter informações sobre backups e restauração Point-In-Time, consulte [Backup, restauração e exportação de dados](CHAP_CommonTasks.BackupRestore.md).
**Como configurar a replicação do arquivo de log binário com uma instância de origem externa**
1. Torne a instância de origem MySQL ou MariaDB somente leitura.
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Execute o comando `SHOW MASTER STATUS` na instância do MySQL ou MariaDB de origem para determinar a localização do log binário.
Você recebe um resultado semelhante ao seguinte exemplo.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
1. Copie o banco de dados da instância externa para a instância de banco de dados do Amazon RDS usando `mysqldump`. Para bancos de dados muito grandes, convém usar o procedimento em [Importar dados para um banco de dados do Amazon RDS para MySQL com tempo de inatividade reduzido](mysql-importing-data-reduced-downtime.md).
Para Linux, macOS ou Unix:
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
Para Windows:
```
mysqldump --databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary ^
-u local_user ^
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**nota**
Confirme que não há um espaço entre a opção `-p` e a senha inserida.
Para especificar o nome do host, o nome do usuário, a porta e a senha para se conectar à instância de banco de dados Amazon RDS, use as opções `--host`, `--user (-u)`, `--port` e `-p` no comando `mysql`. O nome do host é o nome do Serviço de Nome de Domínio (DNS) do endpoint da instância de banco de dados do Amazon RDS, por exemplo, `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Você pode encontrar o valor do endpoint nos detalhes da instância no Console de gerenciamento da AWS.
1. Torne a instância MySQL ou MariaDB de origem novamente gravável.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
Para obter mais informações sobre como fazer backups para usar com a replicação, consulte a [documentação do MySQL](https://dev.mysql.com/doc/refman/8.0/en/replication-solutions-backups-read-only.html).
1. No Console de gerenciamento da AWS, adicione o endereço IP do servidor que hospeda o banco de dados externo ao grupo de segurança da nuvem privada virtual (VPC) para a instância de banco de dados Amazon RDS. Para obter mais informações sobre como modificar um grupo de segurança da VPC, consulte [Grupos de segurança para a VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) no *Guia do usuário da Amazon Virtual Private Cloud*.
O endereço IP poderá ser alterado se as seguintes condições forem atendidas:
+ Se você estiver usando um endereço IP público para a comunicação entre a instância de origem externa e a instância de banco de dados.
+ A instância de origem externa foi interrompida e reiniciada.
Se essas condições forem atendidas, verifique o endereço IP antes de adicioná-lo.
Você também pode precisar configurar a rede local para permitir conexões com o endereço IP da instância de banco de dados do Amazon RDS. Isso é realizado para que a rede local consiga se comunicar com a instância do MySQL ou do MariaDB externa. Para localizar o endereço IP da instância de banco de dados do Amazon RDS, use o comando `host`.
```
host db_instance_endpoint
```
O nome do host é o nome de DNS do endpoint da instância de banco de dados do Amazon RDS.
1. Usando o cliente de sua preferência, conecte-se à instância externa e crie um usuário a ser usado para a replicação. Use essa conta unicamente para replicação e restrinja-a ao seu domínio para melhorar a segurança. Veja um exemplo a seguir.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
1. Para a instância externa, conceda os privilégios `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. Por exemplo, para conceder os privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` em todos os bancos de dados para o usuário '`repl_user`' de seu domínio, emita o seguinte comando.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Transforma a instância de banco de dados do Amazon RDS na réplica. Para fazer isso, primeiro se conecte à instância de banco de dados do Amazon RDS como usuário mestre. Depois disso, identifique o banco de dados MySQL ou MariaDB externo como a instância de origem usando o comando [mysql.rds\$1set\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) ou [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master). Use o nome do arquivo de log mestre e a posição do log mestre que você determinou na etapa 2. Os comandos a seguir são exemplos.
**MySQL 8.4**
```
CALL mysql.rds_set_external_source ('mysourceserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MariaDB e MySQL 8.0 e 5.7**
```
CALL mysql.rds_set_external_master ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**nota**
No RDS para MySQL, é possível optar por usar a replicação atrasada executando o procedimento armazenado [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS para MySQL versões principais 8.4 e superiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay) ou [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay). No RDS para MySQL, um motivo para usar a replicação atrasada é ativar a recuperação de desastres com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). Atualmente, o RDS para MariaDB é compatível com a replicação atrasada, mas não com o procedimento `mysql.rds_start_replication_until`.
1. Na instância de banco de dados do Amazon RDS, emita o comando [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) para iniciar a replicação.
```
CALL mysql.rds_start_replication;
```
# Configurar a replicação de várias fontes do Amazon RDS para MySQL
Com a replicação de várias fontes, é possível configurar uma instância de banco de dados do Amazon RDS para MySQL como uma réplica que recebe eventos de logs binários de mais de uma instância de banco de dados de origem do RDS para MySQL. A replicação de várias fontes é compatível com instâncias de banco de dados do RDS para MySQL que executam as seguintes versões de mecanismo:
+ Todas as versões do MySQL 8.4
+ 8.0.35 e versões secundárias posteriores
+ 5.7.44 e versões secundárias posteriores
Para ter informações sobre a replicação de várias fontes do MySQL, consulte [MySQL Multi-Source Replication](https://dev.mysql.com/doc/refman/8.0/en/replication-multi-source.html) na documentação do MySQL. A documentação do MySQL contém informações detalhadas sobre esse recurso, enquanto este tópico descreve como configurar e gerenciar canais de replicação de várias fontes nas instâncias de banco de dados do RDS para MySQL.
## Casos de uso da replicação de várias fontes
Os casos a seguir são bons candidatos para usar a replicação de várias fontes no RDS para MySQL:
+ Aplicações que precisam mesclar ou combinar vários fragmentos em instâncias de banco de dados separadas em um único fragmento.
+ Aplicações que precisam gerar relatórios a partir de dados consolidados de várias fontes.
+ Requisitos para criar backups consolidados de longo prazo de dados distribuídos entre várias instâncias de banco de dados do RDS para MySQL.
## Pré-requisitos para replicação de várias fontes
Antes de configurar a replicação de várias fontes, cumpra os pré-requisitos a seguir.
+ Garanta que cada instância de banco de dados do RDS para MySQL de origem tenha backups automáticos habilitados. A ativação de backups automáticos habilita o registro em log binário. Para saber como habilitar os backups automáticos, consulte [Ativar backups automáticos](USER_WorkingWithAutomatedBackups.Enabling.md).
+ Para evitar erros de replicação, recomendamos bloquear as operações de gravação nas instâncias de banco de dados de origem. É possível fazer isso definindo o parâmetro `read-only` como `ON` em um grupo de parâmetros personalizado associado à instância de banco de dados de origem do RDS para MySQL. É possível usar o Console de gerenciamento da AWS ou a AWS CLI para criar um grupo de parâmetros personalizado ou modificar um existente. Para obter mais informações, consulte [Criar um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Creating.md) e [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
+ Para cada instância de banco de dados de origem, adicione o endereço IP da instância ao grupo de segurança da Amazon Virtual Private Cloud (VPC) para a instância de banco de dados de várias fontes de dados. Para identificar o endereço IP de uma instância de banco de dados de origem, é possível executar o comando `dig RDS Endpoint`. Execute o comando a partir de uma instância do Amazon EC2 na mesma VPC da instância de banco de dados de várias fontes de destino.
+ Para cada instância de banco de dados de origem, use um cliente para se conectar à instância de banco de dados e criar um usuário de banco de dados com os privilégios necessários para replicação, como no exemplo a seguir.
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user';
```
**nota**
A partir do MySQL 8.4, o privilégio `REPLICATION SLAVE` foi descontinuado e substituído por `REPLICATION REPLICA`. Para MySQL 8.4 e versões posteriores, use a seguinte sintaxe:
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION REPLICA ON *.* TO 'repl_user';
```
## Configurar canais de replicação de várias fontes nas instâncias de banco de dados do RDS para MySQL
A configuração de canais de replicação de várias fontes é semelhante à configuração da replicação de uma única fonte. Para replicação de várias fontes, primeiro habilite o registro em log binário na instância de origem. Depois, importe os dados das fontes para a réplica de várias fontes. Então, inicie a replicação de cada fonte usando as coordenadas binárias do log binário ou usando o posicionamento automático do GTID.
Para configurar uma instância de banco de dados do RDS para MySQL como uma réplica de várias fontes de duas ou mais instâncias de banco de dados do RDS para MySQL, execute as etapas a seguir.
**Topics**
+ [Etapa 1: Importar dados das instâncias de banco de dados de origem para a réplica de várias fontes](#mysql-multi-source-replication-import)
+ [Etapa 2: Iniciar a replicação das instâncias de banco de dados de origem para a réplica de várias fontes](#mysql-multi-source-replication-setting-up-start-replication-other)
### Etapa 1: Importar dados das instâncias de banco de dados de origem para a réplica de várias fontes
Execute as etapas a seguir em cada instância de banco de dados de origem.
Antes de importar os dados de uma fonte para a réplica de várias fontes, determine o arquivo de log binário atual e a posição executando o comando `SHOW MASTER STATUS`. Anote esses detalhes para uso na próxima etapa. Neste exemplo de saída, o arquivo é `mysql-bin-changelog.000031` e a posição é `107`.
**nota**
A partir do MySQL 8.4, o comando `SHOW MASTER STATUS` foi descontinuado e substituído por `SHOW BINARY LOG STATUS`. Para MySQL 8.4 e versões posteriores, use `SHOW BINARY LOG STATUS`.
```
File Position
-----------------------------------
mysql-bin-changelog.000031 107
-----------------------------------
```
Agora, copie o banco de dados da instância de banco de dados de origem para a réplica de várias fontes usando `mysqldump`, como no exemplo a seguir.
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u RDS_user_name \
-p RDS_password \
--host=RDS Endpoint | mysql \
--host=RDS Endpoint \
--port=3306 \
-u RDS_user_name \
-p RDS_password
```
Depois de copiar o banco de dados, é possível definir o parâmetro somente leitura como `OFF` na instância de banco de dados de origem.
### Etapa 2: Iniciar a replicação das instâncias de banco de dados de origem para a réplica de várias fontes
Para cada instância de banco de dados de origem, use as credenciais de usuário administrativas para se conectar à instância e executar os dois procedimentos armazenados a seguir. Esses procedimentos armazenados configuram a replicação em um canal e iniciam a replicação. Este exemplo usa o nome do arquivo de log binário e a posição da saída do exemplo na etapa anterior.
```
CALL mysql.rds_set_external_source_for_channel('mysourcehost.example.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1, 'channel_1');
CALL mysql.rds_start_replication_for_channel('channel_1');
```
Para ter mais informações sobre como usar esses procedimentos armazenados e outros para configurar e gerenciar os canais de replicação, consulte [Gerenciar a replicação de várias fontes](mysql-stored-proc-multi-source-replication.md).
## Usar filtros com replicação de várias fontes
É possível usar filtros de replicação para especificar quais bancos de dados e tabelas são replicados em uma réplica de várias fontes. Os filtros de replicação podem incluir bancos de dados e tabelas na replicação ou excluí-los da replicação. Para ter mais informações sobre filtros de replicação , consulte [Configurar filtros de replicação com MySQL](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md).
Com a replicação de várias fontes, é possível configurar filtros de replicação globalmente ou em nível de canal. A filtragem em nível de canal está disponível somente com instâncias de banco de dados compatíveis que executam a versão 8.0 ou 8.4. Os exemplos a seguir mostram como gerenciar filtros globalmente ou em nível de canal.
Observe os seguintes requisitos e comportamento com a filtragem na replicação de várias fontes:
+ Aspas invertidas (``) ao redor dos nomes dos canais são obrigatórias.
+ Se você alterar os filtros de replicação no grupo de parâmetros, `sql_thread` das réplicas de várias fontes de todos os canais com atualizações será reiniciado para aplicar as alterações dinamicamente. Se uma atualização envolver um filtro global, todos os canais de replicação no estado de execução serão reiniciados.
+ Todos os filtros globais são aplicados antes de qualquer filtro específico do canal.
+ Se um filtro for aplicado globalmente e em nível de canal, somente o filtro em nível de canal será aplicado. Por exemplo, se os filtros forem `replicate_ignore_db="db1,`channel_22`:db2"`, `replicate_ignore_db` definido como `db1` será aplicado a todos os canais, exceto a `channel_22` e somente `channel_22` ignorará as alterações de `db2`.
Exemplo 1: Definir um filtro global
No exemplo a seguir, o banco de dados `temp_data` é excluído da replicação em todos os canais.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='temp_data',ApplyMethod=immediate"
```
Exemplo 2: Definir um filtro em nível de canal
No exemplo a seguir, as alterações do banco de dados `sample22` são incluídas somente no canal `channel_22`. Da mesma forma, as alterações do banco de dados `sample99` são incluídas apenas no canal `channel_99`.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='\`channel_22\`:sample22,\`channel_99\`:sample99',ApplyMethod=immediate"
```
## Monitorar canais de replicação de várias fontes
É possível monitorar canais individuais em uma réplica de várias fontes usando os seguintes métodos:
+ Para monitorar o status de todos os canais ou de um canal específico, conecte-se à réplica de várias fontes e execute o comando `SHOW REPLICA STATUS` ou `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'`. Para ter mais informações, consulte [Checking Replication Status](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) na documentação do MySQL.
+ Para receber uma notificação quando um canal de replicação for iniciado, interrompido ou removido, use a notificação de eventos do RDS. Para obter mais informações, consulte [Trabalhar com a notificação de eventos do Amazon RDS](USER_Events.md).
+ Para monitorar o atraso de um canal específico, confira a métrica `ReplicationChannelLag`. Os pontos de dados dessa métrica têm um período de 60 segundos (1 minuto) e ficam disponíveis por 15 dias. Para localizar o atraso de replicação de um canal, use o identificador da instância e o nome do canal de replicação. Para receber uma notificação quando esse atraso exceder um determinado limite, configure um alarme do CloudWatch. Para obter mais informações, consulte [Monitorar métricas do Amazon RDS com o Amazon CloudWatch](monitoring-cloudwatch.md).
## Considerações e práticas recomendadas para replicação de várias fontes
Antes de usar a replicação de várias fontes no RDS para MySQL, analise as seguintes considerações e práticas recomendadas:
+ Garanta que uma instância de banco de dados configurada como uma réplica de várias fontes tenha recursos suficientes, como throughput, memória, CPU e IOPS, para lidar com a workload de instâncias de várias fontes.
+ Monitore regularmente a utilização de recursos na réplica de várias fontes e ajuste a configuração do armazenamento ou da instância para lidar com a workload sem sobrecarregar os recursos.
+ É possível configurar a replicação multithread em uma réplica de várias fontes definindo a variável do sistema `replica_parallel_workers` com um valor maior que `0`. Nesse caso, o número de threads alocados para cada canal é o valor dessa variável, mais um thread coordenador para gerenciar os threads aplicadores.
+ Configure os filtros de replicação corretamente para evitar conflitos. Para replicar um banco de dados inteiro em outro banco de dados em uma réplica, é possível usar a opção `--replicate-rewrite-db`. Por exemplo, é possível replicar todas as tabelas no banco de dados A no banco de dados B em uma instância de réplica. Essa abordagem pode ser útil quando todas as instâncias de origem estão usando a mesma convenção de nomenclatura de esquema. Para ter informações sobre a opção `--replicate-rewrite-db`, consulte [Replica Server Options and Variables](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html) na documentação do MySQL.
+ Para evitar erros de replicação, evite gravar na réplica. Recomendamos habilitar o parâmetro `read_only` em réplicas de várias fontes para bloquear as operações de gravação. Isso ajuda a eliminar problemas de replicação causados por operações de gravação conflitantes.
+ Para melhor a performance das operações de leitura, como classificações e junções de alta carga que são executadas na réplica de várias fontes, pense em usar leituras otimizadas pelo RDS. Esse recurso pode ajudar com consultas que dependem de grandes tabelas temporárias ou arquivos de classificação. Para obter mais informações, consulte [Melhorar a performance das consultas para o RDS para MySQL com leituras otimizadas do Amazon RDS](rds-optimized-reads.md).
+ Para minimizar o atraso na replicação e melhorar a performance de uma réplica de várias fontes, pense em habilitar gravações otimizadas. Para obter mais informações, consulte [Melhorar a performance das gravações com gravações otimizadas pelo RDS para MySQL](rds-optimized-writes.md).
+ Execute operações de gerenciamento (como alterar a configuração) em um canal por vez e evite realizar alterações em vários canais a partir de várias conexões. Essas práticas podem causar conflitos nas operações de replicação. Por exemplo, a execução simultânea de procedimentos `rds_skip_repl_error_for_channel` e `rds_start_replication_for_channel` de várias conexões pode causar a omissão de eventos em um canal diferente do pretendido.
+ É possível habilitar backups em uma instância de replicação de várias fontes e exportar dados dessa instância para um bucket do Amazon S3 para armazená-los para fins de longo prazo. No entanto, é importante também configurar backups com retenção adequada nas instâncias de origem individuais. Para ter informações sobre como exportar dados de snapshot para o Amazon S3, consulte [Exportação de dados de snapshot de banco de dados para o Amazon S3 para Amazon RDS](USER_ExportSnapshot.md).
+ Para distribuir a workload de leitura em uma réplica de várias fontes, é possível criar réplicas de leitura de uma réplica de várias fontes. É possível localizar essas réplicas de leitura em Regiões da AWS diferentes com base nos requisitos da aplicação. Para ter mais informações sobre réplicas de leitura, consulte [Trabalhar com réplicas de leitura do MySQL](USER_MySQL.Replication.ReadReplicas.md).
## Limitações da replicação de várias fontes do RDS para MySQL
As seguintes limitações se aplicam à replicação de várias fontes no RDS para MySQL:
+ No momento, o RDS para MySQL comporta a configuração de no máximo 15 canais para uma réplica de várias fontes.
+ Uma instância de réplica de leitura não pode ser configurada como uma réplica de várias fontes.
+ Para configurar a replicação de várias fontes no RDS para MySQL executando a versão 5.7 do mecanismo, o Performance Schema deve estar habilitado na instância de réplica. A ativação do Performance Schema é opcional no RDS para MySQL executando a versão 8.0 ou 8.4 do mecanismo.
+ Para o RDS para MySQL que executa a versão 5.7 do mecanismo, os filtros de replicação se aplicam a todos os canais de replicação. Para o RDS para MySQL que executa a versão 8.0 ou 8.4 do mecanismo, é possível configurar filtros que se aplicam a todos os canais de replicação ou a canais individuais.
+ Restaurar um snapshot do RDS ou realizar uma recuperação para um ponto no tempo (PITR) não restaura configurações de canais de réplica de várias fontes.
+ Ao criar uma réplica de leitura por meio de uma réplica de várias fontes, ela replica apenas os dados da instância de várias fontes. Ela não restaura a configuração de nenhum canal.
+ O MySQL não comporta a configuração de um número diferente de operadores paralelos para cada canal. Cada canal recebe o mesmo número de operadores paralelos com base no valor `replica_parallel_workers`.
As seguintes limitações adicionais se aplicarão se o destino de replicação de várias fontes for um cluster de banco de dados multi-AZ:
+ É necessário configurar um canal para uma instância de origem do RDS para MySQL antes de qualquer gravação nessa instância.
+ Cada instância do RDS para MySQL de origem deve ter a replicação baseada em GTID habilitada.
+ Um evento de failover no cluster de banco de dados remove a configuração de replicação de várias fontes. A restauração dessa configuração requer a repetição das etapas de configuração.