# Configurar, iniciar e interromper a replicação de logs binários (binlogs)
Os procedimentos armazenados a seguir controlam como as transações são replicadas de um banco de dados externo para o RDS para MySQL, ou do RDS para MySQL para um banco de dados externo.
Ao usar esses procedimentos armazenados para gerenciar a replicação com um usuário de replicação configurado com `caching_sha2_password`, você deve configurar o TLS especificando `SOURCE_SSL=1`. `caching_sha2_password` é o plugin de autenticação padrão do RDS para MySQL 8.4. Para obter mais informações, consulte [Criptografia com SSL/TLS](mysql-ssl-connections.md).
Para obter informações sobre como configurar, usar e gerenciar réplicas de leitura, consulte [Trabalhar com réplicas de leitura do MySQL](USER_MySQL.Replication.ReadReplicas.md).
**Topics**
+ [mysql.rds\$1next\$1master\$1log (RDS para MariaDB e versões principais 8.0 e anteriores do RDS para MySQL)](#mysql_rds_next_master_log)
+ [mysql.rds\$1next\$1source\$1log (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_next_source_log)
+ [mysql.rds\$1reset\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_reset_external_master)
+ [mysql.rds\$1reset\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_reset_external_source)
+ [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_set_external_source)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_set_external_master_with_auto_position)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_set_external_source_with_auto_position)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS para MySQL versões principais 8.4 e superiores)](#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged)
+ [mysql.rds\$1set\$1master\$1auto\$1position (versões principais 8.0 e anteriores do RDS para MySQL)](#mysql_rds_set_master_auto_position)
+ [mysql.rds\$1set\$1source\$1auto\$1position (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_set_source_auto_position)
+ [mysql.rds\$1set\$1source\$1delay](#mysql_rds_set_source_delay)
+ [mysql.rds\$1skip\$1repl\$1error](#mysql_rds_skip_repl_error)
+ [mysql.rds\$1start\$1replication](#mysql_rds_start_replication)
+ [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until)
+ [mysql.rds\$1stop\$1replication](#mysql_rds_stop_replication)
## mysql.rds\$1next\$1master\$1log (RDS para MariaDB e versões principais 8.0 e anteriores do RDS para MySQL)
Altera a posição do log da instância de banco de dados de origem para o início do próximo log binário na instância de banco de dados de origem. Use este procedimento somente se estiver recebendo o erro 1236 de E/S de replicação em uma réplica de leitura.
### Sintaxe
```
CALL mysql.rds_next_master_log(
curr_master_log
);
```
### Parâmetros
*curr\$1master\$1log*
O índice do arquivo de log mestre atual. Por exemplo, se o arquivo atual dor denominado `mysql-bin-changelog.012345`, o índice será 12345. Para determinar o nome do arquivo de log do mestre, execute o comando `SHOW REPLICA STATUS` e veja o campo `Master_Log_File`.
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_next_master_log`.
**Atenção**
Chame `mysql.rds_next_master_log` somente se a replicação falhar após um failover de uma instância de banco de dados multi-AZ que for a origem da replicação, e o campo `Last_IO_Errno` do `SHOW REPLICA STATUS` reportar o erro 1236 de E/S.
Chamar `mysql.rds_next_master_log` pode resultar em perda de dados na réplica de leitura caso as transações na instância de origem não tenham sido gravadas no log binário no disco antes do evento de failover. Você pode reduzir a chance de que isso aconteça configurando os parâmetros `sync_binlog` e `innodb_support_xa` da instância de origem como `1`, embora isso possa reduzir o desempenho. Para obter mais informações, consulte [Solucionar problemas de uma réplica de leitura do MySQL](USER_ReadRepl.Troubleshooting.md).
### Exemplos
Suponha que a replicação falhe em uma réplica de leitura do RDS para MySQL. A execução de `SHOW REPLICA STATUS\G` na réplica de leitura retorna o seguinte resultado:
```
*************************** 1. row ***************************
Replica_IO_State:
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: MasterUser
Source_Port: 3306
Connect_Retry: 10
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: relaylog.012340
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 30223232
Relay_Log_Space: 5248928866
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Master: NULL
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from master when reading data from binary log: 'Client requested master to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 67285976
```
O campo `Last_IO_Errno` mostra que a instância está recebendo o erro 1236 de E/S. O campo `Master_Log_File` mostra que o nome do arquivo é `mysql-bin-changelog.012345`, o que significa que o índice de arquivos de log é `12345`. Para resolver o erro, chame `mysql.rds_next_master_log` com o seguinte parâmetro:
```
CALL mysql.rds_next_master_log(12345);
```
## mysql.rds\$1next\$1source\$1log (RDS para MySQL versões principais 8.4 e posteriores)
Altera a posição do log da instância de banco de dados de origem para o início do próximo log binário na instância de banco de dados de origem. Use este procedimento somente se estiver recebendo o erro 1236 de E/S de replicação em uma réplica de leitura.
### Sintaxe
```
CALL mysql.rds_next_source_log(
curr_source_log
);
```
### Parâmetros
*curr\$1source\$1log*
O índice do arquivo de log de origem atual. Por exemplo, se o arquivo atual dor denominado `mysql-bin-changelog.012345`, o índice será 12345. Para determinar o nome do arquivo de log de origem atual, execute o comando `SHOW REPLICA STATUS` e veja o campo `Source_Log_File`.
### Observações de uso
O usuário administrativo precisa executar o procedimento `mysql.rds_next_source_log`.
**Atenção**
Chame `mysql.rds_next_source_log` somente se a replicação falhar após um failover de uma instância de banco de dados multi-AZ que for a origem da replicação, e o campo `Last_IO_Errno` do `SHOW REPLICA STATUS` reportar o erro 1236 de E/S.
Chamar `mysql.rds_next_source_log` pode resultar em perda de dados na réplica de leitura caso as transações na instância de origem não tenham sido gravadas no log binário no disco antes do evento de failover. Você pode reduzir a chance de que isso aconteça configurando os parâmetros `sync_binlog` e `innodb_support_xa` da instância de origem como `1`, embora isso possa reduzir o desempenho. Para obter mais informações, consulte [Solucionar problemas de uma réplica de leitura do MySQL](USER_ReadRepl.Troubleshooting.md).
### Exemplos
Suponha que a replicação falhe em uma réplica de leitura do RDS para MySQL. A execução de `SHOW REPLICA STATUS\G` na réplica de leitura retorna o seguinte resultado:
```
*************************** 1. row ***************************
Replica_IO_State:
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: MasterUser
Source_Port: 3306
Connect_Retry: 10
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: relaylog.012340
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 30223232
Relay_Log_Space: 5248928866
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Source: NULL
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from source when reading data from binary log: 'Client requested source to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 67285976
```
O campo `Last_IO_Errno` mostra que a instância está recebendo o erro 1236 de E/S. O campo `Source_Log_File` mostra que o nome do arquivo é `mysql-bin-changelog.012345`, o que significa que o índice de arquivos de log é `12345`. Para resolver o erro, chame `mysql.rds_next_source_log` com o seguinte parâmetro:
```
CALL mysql.rds_next_source_log(12345);
```
## mysql.rds\$1reset\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)
Reconfigura uma instância de banco de dados do RDS para MySQL para que não seja mais uma réplica de leitura de uma instância do MySQL executada fora do Amazon RDS.
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_reset_external_master;
```
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_reset_external_master`. Esse procedimento deve ser executado na instância de banco de dados MySQL a ser removida como a réplica de leitura de uma instância do MySQL sendo executada externamente ao Amazon RDS.
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Para obter mais informações sobre como usar a replicação para importar dados de uma instância do MySQL sendo executada externamente ao Amazon RDS, 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).
## mysql.rds\$1reset\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)
Reconfigura uma instância de banco de dados do RDS para MySQL para que não seja mais uma réplica de leitura de uma instância do MySQL executada fora do Amazon RDS.
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_reset_external_source;
```
### Observações de uso
O usuário administrativo precisa executar o procedimento `mysql.rds_reset_external_source`. Esse procedimento deve ser executado na instância de banco de dados MySQL a ser removida como a réplica de leitura de uma instância do MySQL sendo executada externamente ao Amazon RDS.
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS.
Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md). Para obter mais informações sobre como usar a replicação para importar dados de uma instância do MySQL sendo executada externamente ao Amazon RDS, 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).
## mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)
Configura uma instância de banco de dados do RDS para MySQL para que seja uma réplica de leitura de uma instância do MySQL executada fora do Amazon RDS.
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
**nota**
É possível usar o procedimento armazenado [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_set_external_master_with_delay) para configurar uma instância de banco de dados de origem externa e uma replicação atrasada.
### Sintaxe
```
CALL mysql.rds_set_external_master (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
);
```
### Parâmetros
*host\$1name*
O nome de host ou o endereço IP da instância do MySQL executada externamente ao Amazon RDS que se tornará a instância de banco de dados de origem.
*host\$1port*
A porta usada para executar a instância do MySQL executada externamente ao Amazon RDS a ser configurada como a instância de banco de dados de origem. Se sua configuração de rede inclui replicação de porta Secure Shell (SSH) que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
O ID de um usuário com as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância do MySQL executada externamente ao Amazon RDS. Recomendamos que você forneça uma conta que seja usada unicamente para a replicação com a instância externa.
*replication\$1user\$1password*
A senha do ID de usuário especificada em `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
O nome do log binário na instância de banco de dados de origem que contém as informações de replicação.
*mysql\$1binary\$1log\$1file\$1location*
O local no log binário `mysql_binary_log_file_name` no qual a replicação começa a ler as informações de replicação.
É possível determinar o nome e a localização do arquivo de binlog executando `SHOW MASTER STATUS` na instância do banco de dados de origem.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `MASTER_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_set_external_master`. Esse procedimento deve ser executado na instância de banco de dados MySQL que será configurada como a réplica de leitura de uma instância do MySQL externa ao Amazon RDS.
Antes de executar `mysql.rds_set_external_master`, é necessário configurar a instância do MySQL executada externamente ao Amazon RDS para ser uma instância de banco de dados de origem. Para conectar-se à instância do MySQL sendo executada externamente ao Amazon RDS, você deve especificar valores de `replication_user_name` e `replication_user_password` que indicam um usuário de replicação com permissões de `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância externa do MySQL.
**Como configurar uma instância externa do MySQL como uma instância de banco de dados de origem**
1. Usando o cliente do MySQL de sua escolha, conecte-se à instância externa do MySQL e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir.
**MySQL 5.7**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**MySQL 8.0**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED WITH mysql_native_password BY 'password';
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
1. Na instância externa do MySQL, conceda privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. O exemplo a seguir concede privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` ao usuário 'repl\$1user' em todos os bancos de dados de seu domínio.
**MySQL 5.7**
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**MySQL 8.0**
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
Para usar a replicação criptografada, configure a instância de banco de dados de origem para usar conexões SSL.
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Depois de chamar `mysql.rds_set_external_master` para configurar uma instância de banco de dados do Amazon RDS, é possível chamar [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) na réplica de leitura para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_reset_external_master) para remover a configuração da réplica de leitura.
Quando `mysql.rds_set_external_master` é chamado, o Amazon RDS grava a hora, o usuário e uma ação do `set master` nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
### Exemplos
Ao executar em uma instância de banco de dados MySQL, o exemplo a seguir configura a instância do banco de dados para ser uma réplica de leitura de uma instância do MySQL que é executada externamente ao Amazon RDS.
```
call mysql.rds_set_external_master(
'Externaldb.some.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
1);
```
## mysql.rds\$1set\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)
Configura uma instância de banco de dados do RDS para MySQL para que seja uma réplica de leitura de uma instância do MySQL executada fora do Amazon RDS.
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_set_external_source (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
);
```
### Parâmetros
*host\$1name*
O nome de host ou o endereço IP da instância do MySQL executada externamente ao Amazon RDS que se tornará a instância de banco de dados de origem.
*host\$1port*
A porta usada para executar a instância do MySQL executada externamente ao Amazon RDS a ser configurada como a instância de banco de dados de origem. Se sua configuração de rede inclui replicação de porta Secure Shell (SSH) que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
O ID de um usuário com as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância do MySQL executada externamente ao Amazon RDS. Recomendamos que você forneça uma conta que seja usada unicamente para a replicação com a instância externa.
*replication\$1user\$1password*
A senha do ID de usuário especificada em `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
O nome do log binário na instância de banco de dados de origem que contém as informações de replicação.
*mysql\$1binary\$1log\$1file\$1location*
O local no log binário `mysql_binary_log_file_name` no qual a replicação começa a ler as informações de replicação.
É possível determinar o nome e a localização do arquivo de binlog executando `SHOW MASTER STATUS` na instância do banco de dados de origem.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `SOURCE_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
### Observações de uso
O usuário administrativo precisa executar o procedimento `mysql.rds_set_external_source`. Esse procedimento deve ser executado na instância de banco de dados do RDS para MySQL que será configurada como a réplica de leitura de uma instância do MySQL externa ao Amazon RDS.
Antes de executar `mysql.rds_set_external_source`, é necessário configurar a instância do MySQL executada externamente ao Amazon RDS para ser uma instância de banco de dados de origem. Para conectar-se à instância do MySQL sendo executada externamente ao Amazon RDS, você deve especificar valores de `replication_user_name` e `replication_user_password` que indicam um usuário de replicação com permissões de `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância externa do MySQL.
**Como configurar uma instância externa do MySQL como uma instância de banco de dados de origem**
1. Usando o cliente do MySQL de sua escolha, conecte-se à instância externa do MySQL e crie uma conta de usuário a ser usada para a replicação. 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. Na instância externa do MySQL, conceda privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. O exemplo a seguir concede privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` ao usuário 'repl\$1user' em todos os bancos de dados de seu domínio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
Para usar a replicação criptografada, configure a instância de banco de dados de origem para usar conexões SSL. Além disso, importe o certificado de autoridade de certificação, o certificado e a chave de clientes na instância de banco de dados ou no cluster de banco de dados usando o procedimento [mysql.rds\$1import\$1binlog\$1ssl\$1material](url-rds-user;mysql_rds_import_binlog_ssl_material.html).
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Depois de chamar `mysql.rds_set_external_source` para configurar uma instância de banco de dados do RDS para MySQL, é possível chamar [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) na réplica de leitura para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_reset_external_source) para remover a configuração da réplica de leitura.
Quando `mysql.rds_set_external_source` é chamado, o Amazon RDS grava a hora, o usuário e uma ação do `set master` nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
### Exemplos
Quando executado em uma instância de banco de dados do RDS para MySQL, o exemplo a seguir configura a instância de banco de dados para ser uma réplica de leitura de uma instância do MySQL que é executada externamente ao Amazon RDS.
```
call mysql.rds_set_external_source(
'Externaldb.some.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
1);
```
## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS para MySQL versões principais 8.0 e anteriores)
Configura uma instância de banco de dados do RDS para MySQL para ser uma réplica de leitura de uma instância do MySQL executada externamente em relação ao Amazon RDS. Esse procedimento também configura a replicação atrasada e a replicação baseada em identificadores de transações globais (GTIDs).
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_set_external_master_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parâmetros
*host\$1name*
O nome de host ou o endereço IP da instância do MySQL executada externamente ao Amazon RDS que se tornará a instância de banco de dados de origem.
*host\$1port*
A porta usada para executar a instância do MySQL executada externamente ao Amazon RDS a ser configurada como a instância de banco de dados de origem. Se sua configuração de rede inclui replicação de porta Secure Shell (SSH) que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
O ID de um usuário com as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância do MySQL executada externamente ao Amazon RDS. Recomendamos que você forneça uma conta que seja usada unicamente para a replicação com a instância externa.
*replication\$1user\$1password*
A senha do ID de usuário especificada em `replication_user_name`.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `MASTER_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
*delay*
O número mínimo de segundos para atrasar a replicação da instância de banco de dados de origem.
O limite para esse parâmetro é de um dia (86.400 segundos).
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_set_external_master_with_auto_position`. Esse procedimento deve ser executado na instância de banco de dados MySQL que será configurada como a réplica de leitura de uma instância do MySQL externa ao Amazon RDS.
Esse procedimento é compatível com todas as versões 5.7 do RDS para MySQL e com o RDS para MySQL 8.0.26 e versões 8.0 posteriores.
Antes de executar `mysql.rds_set_external_master_with_auto_position`, é necessário configurar a instância do MySQL executada externamente ao Amazon RDS para ser uma instância de banco de dados de origem. Para conectar-se à instância do MySQL que é externa ao Amazon RDS, você deve especificar os valores de `replication_user_name` e `replication_user_password`. Esses valores devem indicar um usuário de replicação que tenha as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância externa do MySQL.
**Como configurar uma instância externa do MySQL como uma instância de banco de dados de origem**
1. Usando o cliente do MySQL de sua escolha, conecte-se à instância externa do MySQL e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Na instância externa do MySQL, conceda privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. O exemplo a seguir concede privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` ao usuário `'repl_user'` em todos os bancos de dados de seu domínio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Para obter mais informações, 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).
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Antes de chamar `mysql.rds_set_external_master_with_auto_position`, chame [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) para definir a variável de sistema `gtid_purged` com um intervalo GTID especificado de uma fonte externa.
Depois de chamar `mysql.rds_set_external_master_with_auto_position` para configurar uma instância de banco de dados do Amazon RDS, é possível chamar [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) na réplica de leitura para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_reset_external_master) para remover a configuração da réplica de leitura.
Ao chamar `mysql.rds_set_external_master_with_auto_position`, o Amazon RDS registra a hora, o usuário e uma ação do `set master` nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
Para a recuperação de desastres, você pode usar esse procedimento com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) ou o [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Para efetuar roll forward de alterações para uma réplica de leitura atrasada no momento imediatamente antes de um desastre, é possível executar o procedimento `mysql.rds_set_external_master_with_auto_position`. Depois que o procedimento `mysql.rds_start_replication_until_gtid` interromper a replicação, é possível promover a réplica de leitura para ser a nova instância de banco de dados primária 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).
Para usar o procedimento `mysql.rds_rds_start_replication_until_gtid`, a replicação baseada em GTID deve estar habilitada. Para ignorar uma transação específica baseada em GTID que seja conhecida por causar desastres, use o procedimento armazenado [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Para obter mais informações sobre como trabalhar com a replicação baseada em GTID, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
### Exemplos
Ao executar em uma instância de banco de dados MySQL, o exemplo a seguir configura a instância do banco de dados para ser uma réplica de leitura de uma instância do MySQL que é executada externamente ao Amazon RDS. Ele define o atraso mínimo de replicação como uma hora (3.600 segundos) na instância de banco de dados MySQL. Uma alteração da instância do banco de dados de origem MySQL executada externamente ao Amazon RDS não é aplicada à réplica de leitura da instância de banco de dados MySQL por pelo menos uma hora.
```
call mysql.rds_set_external_master_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS para MySQL versões principais 8.4 e posteriores)
Configura uma instância de banco de dados do RDS para MySQL para ser uma réplica de leitura de uma instância do MySQL executada externamente em relação ao Amazon RDS. Esse procedimento também configura a replicação atrasada e a replicação baseada em identificadores de transações globais (GTIDs).
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_set_external_source_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parâmetros
*host\$1name*
O nome de host ou o endereço IP da instância do MySQL executada externamente ao Amazon RDS que se tornará a instância de banco de dados de origem.
*host\$1port*
A porta usada para executar a instância do MySQL executada externamente ao Amazon RDS a ser configurada como a instância de banco de dados de origem. Se sua configuração de rede inclui replicação de porta Secure Shell (SSH) que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
O ID de um usuário com as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância do MySQL executada externamente ao Amazon RDS. Recomendamos que você forneça uma conta que seja usada unicamente para a replicação com a instância externa.
*replication\$1user\$1password*
A senha do ID de usuário especificada em `replication_user_name`.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `SOURCE_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
*delay*
O número mínimo de segundos para atrasar a replicação da instância de banco de dados de origem.
O limite para esse parâmetro é de um dia (86.400 segundos).
### Observações de uso
O usuário administrativo precisa executar o procedimento `mysql.rds_set_external_source_with_auto_position`. Esse procedimento deve ser executado na instância de banco de dados MySQL que será configurada como a réplica de leitura de uma instância do MySQL externa ao Amazon RDS.
Antes de executar `mysql.rds_set_external_source_with_auto_position`, é necessário configurar a instância do MySQL executada externamente ao Amazon RDS para ser uma instância de banco de dados de origem. Para conectar-se à instância do MySQL que é externa ao Amazon RDS, você deve especificar os valores de `replication_user_name` e `replication_user_password`. Esses valores devem indicar um usuário de replicação que tenha as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância externa do MySQL.
**Como configurar uma instância externa do MySQL como uma instância de banco de dados de origem**
1. Usando o cliente do MySQL de sua escolha, conecte-se à instância externa do MySQL e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Na instância externa do MySQL, conceda privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. O exemplo a seguir concede privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` ao usuário `'repl_user'` em todos os bancos de dados de seu domínio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Para obter mais informações, 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).
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Antes de chamar `mysql.rds_set_external_source_with_auto_position`, chame [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) para definir a variável de sistema `gtid_purged` com um intervalo GTID especificado de uma fonte externa.
Depois de chamar `mysql.rds_set_external_source_with_auto_position` para configurar uma instância de banco de dados do Amazon RDS, é possível chamar [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) na réplica de leitura para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_reset_external_source) para remover a configuração da réplica de leitura.
Ao chamar `mysql.rds_set_external_source_with_auto_position`, o Amazon RDS registra a hora, o usuário e uma ação do `set master` nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
Para a recuperação de desastres, você pode usar esse procedimento com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) ou o [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Para efetuar roll forward de alterações para uma réplica de leitura atrasada no momento imediatamente antes de um desastre, é possível executar o procedimento `mysql.rds_set_external_source_with_auto_position`. Depois que o procedimento `mysql.rds_start_replication_until_gtid` interromper a replicação, é possível promover a réplica de leitura para ser a nova instância de banco de dados primária 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).
Para usar o procedimento `mysql.rds_rds_start_replication_until_gtid`, a replicação baseada em GTID deve estar habilitada. Para ignorar uma transação específica baseada em GTID que seja conhecida por causar desastres, use o procedimento armazenado [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Para obter mais informações sobre como trabalhar com a replicação baseada em GTID, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
### Exemplos
Ao executar em uma instância de banco de dados MySQL, o exemplo a seguir configura a instância do banco de dados para ser uma réplica de leitura de uma instância do MySQL que é executada externamente ao Amazon RDS. Ele define o atraso mínimo de replicação como uma hora (3.600 segundos) na instância de banco de dados MySQL. Uma alteração da instância do banco de dados de origem MySQL executada externamente ao Amazon RDS não é aplicada à réplica de leitura da instância de banco de dados MySQL por pelo menos uma hora.
```
call mysql.rds_set_external_source_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
1,
3600);
```
## mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)
Configura uma instância de banco de dados do RDS para MySQL para ser uma réplica de leitura de uma instância do MySQL executada externamente em relação ao Amazon RDS e configura a replicação atrasada.
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_set_external_master_with_delay(
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
);
```
### Parâmetros
*host\$1name*
O nome de host ou o endereço IP da instância do MySQL executada externamente ao Amazon RDS que se tornará a instância de banco de dados de origem.
*host\$1port*
A porta usada para executar a instância do MySQL executada externamente ao Amazon RDS a ser configurada como a instância de banco de dados de origem. Se sua configuração de rede inclui replicação de porta SSH que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
O ID de um usuário com as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância do MySQL executada externamente ao Amazon RDS. Recomendamos que você forneça uma conta que seja usada unicamente para a replicação com a instância externa.
*replication\$1user\$1password*
A senha do ID de usuário especificada em `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
O nome do log binário na instância de banco de dados de origem contém as informações de replicação.
*mysql\$1binary\$1log\$1file\$1location*
O local no log binário `mysql_binary_log_file_name` no qual a replicação começará a ler as informações de replicação.
É possível determinar o nome e a localização do arquivo de binlog executando `SHOW MASTER STATUS` na instância do banco de dados de origem.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `MASTER_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
*delay*
O número mínimo de segundos para atrasar a replicação da instância de banco de dados de origem.
O limite para esse parâmetro é de um dia (86.400 segundos).
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_set_external_master_with_delay`. Esse procedimento deve ser executado na instância de banco de dados MySQL que será configurada como a réplica de leitura de uma instância do MySQL externa ao Amazon RDS.
Antes de executar `mysql.rds_set_external_master_with_delay`, é necessário configurar a instância do MySQL executada externamente ao Amazon RDS para ser uma instância de banco de dados de origem. Para conectar-se à instância do MySQL que é externa ao Amazon RDS, você deve especificar os valores de `replication_user_name` e `replication_user_password`. Esses valores devem indicar um usuário de replicação que tenha as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância externa do MySQL.
**Como configurar uma instância externa do MySQL como uma instância de banco de dados de origem**
1. Usando o cliente do MySQL de sua escolha, conecte-se à instância externa do MySQL e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Na instância externa do MySQL, conceda privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. O exemplo a seguir concede privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` ao usuário `'repl_user'` em todos os bancos de dados de seu domínio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Para obter mais informações, 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).
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Depois de chamar `mysql.rds_set_external_master_with_delay` para configurar uma instância de banco de dados do Amazon RDS, é possível chamar [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) na réplica de leitura para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_reset_external_master) para remover a configuração da réplica de leitura.
Ao chamar `mysql.rds_set_external_master_with_delay`, o Amazon RDS registra a hora, o usuário e uma ação do `set master` nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
Para a recuperação de desastres, você pode usar esse procedimento com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) ou o [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Para efetuar roll forward de alterações para uma réplica de leitura atrasada no momento imediatamente antes de um desastre, é possível executar o procedimento `mysql.rds_set_external_master_with_delay`. Depois que o procedimento `mysql.rds_start_replication_until` interromper a replicação, é possível promover a réplica de leitura para ser a nova instância de banco de dados primária 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).
Para usar o procedimento `mysql.rds_rds_start_replication_until_gtid`, a replicação baseada em GTID deve estar habilitada. Para ignorar uma transação específica baseada em GTID que seja conhecida por causar desastres, use o procedimento armazenado [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Para obter mais informações sobre como trabalhar com a replicação baseada em GTID, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
O procedimento `mysql.rds_set_external_master_with_delay` está disponível nestas versões do RDS para MySQL:
+ MySQL 8.0.26 e versões 8.0 posteriores
+ Todas as versões 5.7
### Exemplos
Ao executar em uma instância de banco de dados MySQL, o exemplo a seguir configura a instância do banco de dados para ser uma réplica de leitura de uma instância do MySQL que é executada externamente ao Amazon RDS. Ele define o atraso mínimo de replicação como uma hora (3.600 segundos) na instância de banco de dados MySQL. Uma alteração da instância do banco de dados de origem MySQL executada externamente ao Amazon RDS não é aplicada à réplica de leitura da instância de banco de dados MySQL por pelo menos uma hora.
```
call mysql.rds_set_external_master_with_delay(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
'mysql-bin-changelog.000777',
120,
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS para MySQL versões principais 8.4 e superiores)
Configura uma instância de banco de dados do RDS para MySQL para ser uma réplica de leitura de uma instância do MySQL executada externamente em relação ao Amazon RDS e configura a replicação atrasada.
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_set_external_source_with_delay (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
);
```
### Parâmetros
*host\$1name*
O nome de host ou o endereço IP da instância do MySQL executada externamente ao Amazon RDS que se tornará a instância de banco de dados de origem.
*host\$1port*
A porta usada para executar a instância do MySQL executada externamente ao Amazon RDS a ser configurada como a instância de banco de dados de origem. Se sua configuração de rede inclui replicação de porta SSH que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
O ID de um usuário com as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância do MySQL executada externamente ao Amazon RDS. Recomendamos que você forneça uma conta que seja usada unicamente para a replicação com a instância externa.
*replication\$1user\$1password*
A senha do ID de usuário especificada em `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
O nome do log binário na instância de banco de dados de origem contém as informações de replicação.
*mysql\$1binary\$1log\$1file\$1location*
O local no log binário `mysql_binary_log_file_name` no qual a replicação começará a ler as informações de replicação.
É possível determinar o nome e a localização do arquivo de binlog executando `SHOW MASTER STATUS` na instância do banco de dados de origem.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `SOURCE_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
*delay*
O número mínimo de segundos para atrasar a replicação da instância de banco de dados de origem.
O limite para esse parâmetro é de um dia (86.400 segundos).
### Observações de uso
O usuário administrativo precisa executar o procedimento `mysql.rds_set_external_source_with_delay`. Esse procedimento deve ser executado na instância de banco de dados MySQL que será configurada como a réplica de leitura de uma instância do MySQL externa ao Amazon RDS.
Antes de executar `mysql.rds_set_external_source_with_delay`, é necessário configurar a instância do MySQL executada externamente ao Amazon RDS para ser uma instância de banco de dados de origem. Para conectar-se à instância do MySQL que é externa ao Amazon RDS, você deve especificar os valores de `replication_user_name` e `replication_user_password`. Esses valores devem indicar um usuário de replicação que tenha as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância externa do MySQL.
**Como configurar uma instância externa do MySQL como uma instância de banco de dados de origem**
1. Usando o cliente do MySQL de sua escolha, conecte-se à instância externa do MySQL e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Na instância externa do MySQL, conceda privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. O exemplo a seguir concede privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` ao usuário `'repl_user'` em todos os bancos de dados de seu domínio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Para obter mais informações, 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).
**nota**
Recomendamos que você use réplicas de leitura para gerenciar a replicação entre duas instâncias de banco de dados do Amazon RDS, sempre que possível. Quando você o fizer, recomendamos o uso somente desse e de outros procedimentos armazenados relacionados a replicação. Essas práticas permitem o uso de topologias de replicação mais complexas entre as instâncias de banco de dados do Amazon RDS. Oferecemos esses procedimentos armazenados principalmente para permitir a replicação com instâncias do MySQL externas ao Amazon RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Depois de chamar `mysql.rds_set_external_source_with_delay` para configurar uma instância de banco de dados do Amazon RDS, é possível chamar [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) na réplica de leitura para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_reset_external_source) para remover a configuração da réplica de leitura.
Ao chamar `mysql.rds_set_external_source_with_delay`, o Amazon RDS registra a hora, o usuário e uma ação do `set master` nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
Para a recuperação de desastres, você pode usar esse procedimento com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) ou o [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Para efetuar roll forward de alterações para uma réplica de leitura atrasada no momento imediatamente antes de um desastre, é possível executar o procedimento `mysql.rds_set_external_source_with_delay`. Depois que o procedimento `mysql.rds_start_replication_until` interromper a replicação, é possível promover a réplica de leitura para ser a nova instância de banco de dados primária 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).
Para usar o procedimento `mysql.rds_rds_start_replication_until_gtid`, a replicação baseada em GTID deve estar habilitada. Para ignorar uma transação específica baseada em GTID que seja conhecida por causar desastres, use o procedimento armazenado [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Para obter mais informações sobre como trabalhar com a replicação baseada em GTID, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
### Exemplos
Ao executar em uma instância de banco de dados MySQL, o exemplo a seguir configura a instância do banco de dados para ser uma réplica de leitura de uma instância do MySQL que é executada externamente ao Amazon RDS. Ele define o atraso mínimo de replicação como uma hora (3.600 segundos) na instância de banco de dados MySQL. Uma alteração da instância do banco de dados de origem MySQL executada externamente ao Amazon RDS não é aplicada à réplica de leitura da instância de banco de dados MySQL por pelo menos uma hora.
```
call mysql.rds_set_external_source_with_delay(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
'mysql-bin-changelog.000777',
120,
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1gtid\$1purged
Define a variável de sistema [gtid\$1purged](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_gtid_purged) com um intervalo GTID especificado de uma fonte externa. O valor `gtid_purged` é necessário para configurar a replicação baseada em GTID para retomar a replicação usando posicionamento automático.
**Importante**
Para executar esse procedimento, `autocommit` deve estar habilitado. Para habilitá-lo, defina o parâmetro `autocommit` como `1`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintaxe
```
CALL mysql.rds_set_external_source_gtid_purged(
server_uuid
, start_pos
, end_pos
);
```
### Parâmetros
*server\$1uuid*
O identificador universalmente exclusivo (UID) do servidor externo do qual o intervalo GTID está sendo importado.
*start\$1pos*
A posição inicial do intervalo GTID a ser definida.
*end\$1pos*
A posição final do intervalo GTID a ser definida.
### Observações de uso
O procedimento `mysql.rds_set_external_source_gtid_purged` só está disponível com o MySQL 8.0.37 e versões 8.0 posteriores.
Chame `mysql.rds_set_external_source_gtid_purged` antes de chamar [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_set_external_master_with_auto_position), [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_set_external_source_with_auto_position) ou [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_set_external_source_with_auto_position_for_channel).
Antes de chamar `mysql.rds_set_external_source_gtid_purged`, interrompa todos os canais de replicação ativos do banco de dados. Para conferir o status de um canal, use a declaração `SHOW REPLICA STATUS` MySQL. Para interromper a replicação em um canal, chame [mysql.rds\$1stop\$1replication\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_stop_replication_for_channel).
O intervalo GTID especificado deverá ser um superconjunto do valor `GTID_PURGED` existente. Esse procedimento armazenado confere os seguintes valores antes de definir o valor `GTID_PURGED`:
+ O `server_uuid` é válido.
+ O valor de `start_pos` é maior que `0` e menor que o valor de `end_pos`.
+ O valor de `end_pos` é maior ou igual ao valor de `start_pos`.
Se o conjunto de GTID no servidor externo contiver vários intervalos de valores, pense em chamar o procedimento várias vezes com valores de conjunto de GTID diferentes.
Ao chamar `mysql.rds_set_external_source_gtid_purged`, o Amazon RDS registra a hora, o usuário e uma ação do `set gtid_purged` na tabela `mysql.rds_history`.
Se você não definir o valor `gtid_purged` adequadamente para o backup utilizado para replicação, isso poderá gerar transações perdidas ou duplicadas durante o processo de replicação. Execute as etapas a seguir para corrigir o valor `gtid_purged`.
**Como definir o valor gtid\$1purged na réplica**
1. Determine o ponto no tempo ou o arquivo de backup específico a ser usado como ponto de partida para a replicação. Pode ser um backup lógico (um arquivo mysqldump) ou físico (um snapshot do Amazon RDS).
1. Determine o valor `gtid_executed`. Esse valor representa o conjunto de todos os GTIDs que foram confirmados no servidor. Para recuperar esse valor, na instância de origem, faça o seguinte:
+ Execute a declaração `SELECT @@GLOBAL.GTID_EXECUTED;` SQL no momento em que o backup foi feito.
+ Se alguma opção relacionada estiver incluída no respectivo utilitário de backup, extraia o valor do arquivo de backup. Para ter mais informações, consulte a opção [set-gtid-purged](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html#option_mysqldump_set-gtid-purged) na documentação do MySQL.
1. Determine o valor `gtid_purged` a ser usado para a chamada para `mysql.rds_set_external_source_gtid_purged`. O valor `gtid_purged` deve incluir todos os GTIDs que foram executados na instância de origem e que não são mais necessários para a replicação. Portanto, o valor `gtid_purged` deve ser um subconjunto do valor `gtid_executed` recuperado na etapa anterior.
Para determinar o valor `gtid_purged`, identifique os GTIDs que não estão incluídos no backup e não são mais necessários para a replicação. É possível fazer isso analisando os logs binários ou usando uma ferramenta, como mysqlbinlog, para encontrar os GTIDs que foram removidos dos logs binários.
Se você tiver um backup consistente que inclua todos os logs binários até o ponto de backup, também será possível definir o valor `gtid_purged` como igual ao valor `gtid_executed` no ponto de backup.
1. Depois de determinar o valor `gtid_purged` apropriado que seja consistente com o backup, chame o procedimento armazenado `mysql.rds_set_external_source_gtid_purged` na sua instância de banco de dados do RDS para MySQL para definir o valor.
### Exemplos
Quando executado em uma instância de banco de dados do MySQL, o exemplo a seguir define o intervalo GTID de um servidor MySQL externo com o UUID `12345678-abcd-1234-efgh-123456789abc`, uma posição inicial de `1` e uma posição final de `100`. O valor do GTID resultante é definido como `+12345678-abcd-1234-efgh-123456789abc:1-100`.
```
CALL mysql.rds_set_external_source_gtid_purged('12345678-abcd-1234-efgh-123456789abc', 1, 100);
```
## mysql.rds\$1set\$1master\$1auto\$1position (versões principais 8.0 e anteriores do RDS para MySQL)
Define o modo de replicação de base nas posições do arquivo de log binário ou nos identificadores de transações globais (GTIDs).
### Sintaxe
```
CALL mysql.rds_set_master_auto_position (
auto_position_mode
);
```
### Parâmetros
*auto\$1position\$1mode*
Um valor que indica se será usada a replicação de posição do arquivo de log ou a replicação com base no GTID:
+ `0`: usar o método de replicação com base na posição do arquivo de log binário. O padrão é `0`.
+ `1`: usar o método de replicação com base no GTID.
### Observações de uso
O usuário principal deve executar o procedimento `mysql.rds_set_master_auto_position`.
Esse procedimento é compatível com todas as versões 5.7 do RDS para MySQL e com o RDS para MySQL 8.0.26 e versões 8.0 posteriores.
## mysql.rds\$1set\$1source\$1auto\$1position (RDS para MySQL versões principais 8.4 e posteriores)
Define o modo de replicação de base nas posições do arquivo de log binário ou nos identificadores de transações globais (GTIDs).
### Sintaxe
```
CALL mysql.rds_set_source_auto_position (auto_position_mode);
```
### Parâmetros
*auto\$1position\$1mode*
Um valor que indica se será usada a replicação de posição do arquivo de log ou a replicação com base no GTID:
+ `0`: usar o método de replicação com base na posição do arquivo de log binário. O padrão é `0`.
+ `1`: usar o método de replicação com base no GTID.
### Observações de uso
O usuário administrativo precisa executar o procedimento `mysql.rds_set_source_auto_position`.
## mysql.rds\$1set\$1source\$1delay
Define o número mínimo de segundos para atrasar a replicação da instância de banco de dados de origem para a réplica de leitura atual. Use esse procedimento quando estiver conectado a uma réplica de leitura para atrasar a replicação da instância de banco de dados de origem.
### Sintaxe
```
CALL mysql.rds_set_source_delay(
delay
);
```
### Parâmetros
*delay*
O número mínimo de segundos para atrasar a replicação da instância de banco de dados de origem.
O limite para esse parâmetro é de um dia (86.400 segundos).
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_set_source_delay`.
Para a recuperação de desastres, você pode usar esse procedimento com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) ou o [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Para efetuar roll forward de alterações para uma réplica de leitura atrasada no momento imediatamente antes de um desastre, é possível executar o procedimento `mysql.rds_set_source_delay`. Depois que o procedimento `mysql.rds_start_replication_until` ou `mysql.rds_start_replication_until_gtid` interromper a replicação, é possível promover a réplica de leitura para ser a nova instância de banco de dados primária 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).
Para usar o procedimento `mysql.rds_rds_start_replication_until_gtid`, a replicação baseada em GTID deve estar habilitada. Para ignorar uma transação específica baseada em GTID que seja conhecida por causar desastres, use o procedimento armazenado [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Para obter mais informações sobre a replicação baseada em GTID, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md).
O procedimento `mysql.rds_set_source_delay` está disponível nestas versões do RDS para MySQL:
+ Todas as versões do RDS para MySQL 8.4
+ MySQL 8.0.26 e versões 8.0 posteriores
+ Todas as versões 5.7
### Exemplos
Para atrasar a replicação da instância de banco de dados de origem para a réplica de leitura atual por pelo menos uma hora (3.600 segundos), é possível chamar `mysql.rds_set_source_delay` com o seguinte parâmetro:
```
CALL mysql.rds_set_source_delay(3600);
```
## mysql.rds\$1skip\$1repl\$1error
Ignora e exclui um erro de replicação em uma réplica de leitura de banco de dados MySQL.
### Sintaxe
```
CALL mysql.rds_skip_repl_error;
```
### Observações de uso
O usuário principal deve executar o procedimento `mysql.rds_skip_repl_error` em uma réplica de leitura. Para obter mais informações sobre esse procedimento, consulte [Chamando o procedimento mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
Para determinar se há erros, execute o comando `SHOW REPLICA STATUS\G` do MySQL. Se um erro de replicação não for crítico, execute `mysql.rds_skip_repl_error` para ignorá-lo. Se houver vários, `mysql.rds_skip_repl_error` exclui o primeiro erro, depois avisa que há outros ainda. Assim, você pode usar `SHOW REPLICA STATUS\G` para determinar o plano de ação correto para o próximo erro. Para obter informações sobre os valores retornados, consulte [Instrução SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) na documentação do MySQL.
Para obter mais informações sobre como lidar com erros de replicação no Amazon RDS, consulte [Solucionar problemas de uma réplica de leitura do MySQL](USER_ReadRepl.Troubleshooting.md).
#### Erro de replicação interrompida
Ao chamar o procedimento `mysql.rds_skip_repl_error`, você pode receber uma mensagem de erro informando que a réplica está inativa ou desativada.
Essa mensagem de erro aparece quando você executa o procedimento na instância primária em vez da réplica de leitura. Você deve executar esse procedimento na réplica de leitura para que o procedimento funcione.
Essa mensagem de erro também poderá aparecer se você executar o procedimento na réplica de leitura, mas a replicação não poderá ser reiniciada com êxito.
Se você precisar ignorar um grande número de erros, o atraso de replicação poderá aumentar além do período de retenção padrão para arquivos de log binário (binlog). Nesse caso, você poderá encontrar um erro fatal, com os arquivos binlog sendo limpos antes de sua reprodução na réplica de leitura. Essa remoção faz com que a replicação pare, e você não consegue chamar o comando `mysql.rds_skip_repl_error` para ignorar erros de replicação.
É possível mitigar esse problema aumentando o número de horas em que os arquivos binlog são retidos na instância de banco de dados de origem. Após aumentar o período de retenção de log binário, você pode reiniciar a replicação e chamar o comando `mysql.rds_skip_repl_error` conforme necessário.
Para definir o período de retenção do binlog, use o procedimento [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) e especifique um parâmetro de configuração `'binlog retention hours'`, juntamente com o número de horas de retenção dos arquivos binlog no cluster do banco de dados. O exemplo a seguir define o período de retenção para arquivos de log binário em 48 horas.
```
CALL mysql.rds_set_configuration('binlog retention hours', 48);
```
## mysql.rds\$1start\$1replication
Inicia a replicação de uma instância de banco de dados do RDS para MySQL.
**nota**
Você pode usar o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) ou [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) para iniciar a replicação de uma instância de banco de dados do RDS para MySQL e interromper a replicação no local do arquivo de log binário especificado.
### Sintaxe
```
CALL mysql.rds_start_replication;
```
### Observações de uso
O usuário principal deve executar o procedimento `mysql.rds_start_replication`.
Para importar dados de uma instância do MySQL fora do Amazon RDS, chame `mysql.rds_start_replication` na réplica de leitura para iniciar o processo de replicação depois de ter chamado [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_set_external_master) ou [mysql.rds\$1set\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](#mysql_rds_set_external_source) para criar a configuração de replicação. Para obter mais informações, consulte [Restaurar um backup em uma instância de banco de dados do Amazon RDS para MySQL](MySQL.Procedural.Importing.md).
Para exportar dados para uma instância do MySQL fora do Amazon RDS, chame `mysql.rds_start_replication` e `mysql.rds_stop_replication` na réplica de leitura para controlar algumas ações de replicação, como a remoção de logs binários. Para obter mais informações, consulte [Exportar dados de uma instância de banco de dados MySQL usando replicação](MySQL.Procedural.Exporting.NonRDSRepl.md).
Também é possível chamar `mysql.rds_start_replication` na réplica de leitura para reiniciar qualquer processo de replicação que tenha sido interrompido anteriormente chamando `mysql.rds_stop_replication`. Para obter mais informações, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
## mysql.rds\$1start\$1replication\$1until
Inicia a replicação de uma instância de banco de dados do RDS para MySQL e interrompe a replicação no local do arquivo de log binário especificado.
### Sintaxe
```
CALL mysql.rds_start_replication_until (
replication_log_file
, replication_stop_point
);
```
### Parâmetros
*replication\$1log\$1file*
O nome do log binário na instância de banco de dados de origem que contém as informações de replicação.
*replication\$1stop\$1point *
O local no log binário `replication_log_file` no qual a replicação será interrompida.
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_start_replication_until`.
O procedimento `mysql.rds_start_replication_until` está disponível nestas versões do RDS for MySQL:
+ Todas as versões do RDS para MySQL 8.4
+ MySQL 8.0.26 e versões 8.0 posteriores
+ Todas as versões 5.7
Você pode usar esse procedimento com a replicação atrasada para recuperação de desastres. Se você tiver a replicação atrasada configurada, use esse procedimento para efetuar roll forward de alterações em uma réplica de leitura atrasada para o momento imediatamente antes de um desastre. Depois que esse procedimento interromper a replicação, é possível promover a réplica de leitura para ser a nova instância de banco de dados primária 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).
Você pode configurar a replicação atrasada usando os seguintes procedimentos armazenados:
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS para MySQL versões principais 8.4 e superiores)](#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](#mysql_rds_set_source_delay)
O nome do arquivo especificado para o parâmetro `replication_log_file` deve corresponder ao nome do arquivo do log binário da instância de banco de dados de origem.
Quando o parâmetro `replication_stop_point` especifica um local de parada no passado, a replicação é interrompida imediatamente.
### Exemplos
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`.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
## mysql.rds\$1stop\$1replication
Interrompe a replicação de uma instância de banco de dados MySQL.
### Sintaxe
```
CALL mysql.rds_stop_replication;
```
### Observações de uso
O usuário mestre deve executar o procedimento `mysql.rds_stop_replication`.
Se você estiver configurando a replicação para importar dados de uma instância do MySQL em execução externamente ao Amazon RDS, chame `mysql.rds_stop_replication` na réplica de leitura para encerrar o processo de replicação após a importação ter sido concluída. Para obter mais informações, consulte [Restaurar um backup em uma instância de banco de dados do Amazon RDS para MySQL](MySQL.Procedural.Importing.md).
Se estiver configurando a replicação para exportar dados para uma instância do MySQL externa ao Amazon RDS, chame `mysql.rds_start_replication` e `mysql.rds_stop_replication` na réplica de leitura para controlar algumas ações de replicação, como a remoção de logs binários. Para obter mais informações, consulte [Exportar dados de uma instância de banco de dados MySQL usando replicação](MySQL.Procedural.Exporting.NonRDSRepl.md).
Você também pode usar `mysql.rds_stop_replication` para parar uma replicação entre duas instâncias de banco de dados do Amazon RDS. Normalmente, você interrompe a replicação para executar uma operação de execução longa na réplica de leitura, como ao criar um índice grande na réplica de leitura. Também é possível reiniciar qualquer processo de replicação que tenha sido interrompido chamando [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) na réplica de leitura. Para obter mais informações, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).