# Referência de procedimentos armazenados do RDS para MySQL Esses tópicos descrevem procedimentos armazenados no sistema que estão disponíveis para instâncias do Amazon RDS que executam o mecanismo de banco de dados MySQL. O usuário primário deve executar esses procedimentos. **Topics** + [ # Coletar e manter o histórico de status global ](mysql-stored-proc-gsh.md) + [ # Configurar, iniciar e interromper a replicação de logs binários (binlogs) ](mysql-stored-proc-replicating.md) + [ # Encerrar uma sessão ou consulta ](mysql-stored-proc-ending.md) + [ # Gerenciar clusters ativos-ativos ](mysql-stored-proc-active-active-clusters.md) + [ # Gerenciar a replicação de várias fontes ](mysql-stored-proc-multi-source-replication.md) + [ # Replicar transações com GTIDs ](mysql-stored-proc-gtid.md) + [ # Alternar os logs de consulta ](mysql-stored-proc-logging.md) + [ # Definir e mostrar a configuração de logs binários ](mysql-stored-proc-configuring.md) + [ # Aquecer o armazenamento em cache do InnoDB ](mysql-stored-proc-warming.md) # Coletar e manter o histórico de status global O Amazon RDS fornece um conjunto de procedimentos que gera snapshots dos valores dessas variáveis de status ao longo do tempo e as grava em uma tabela, juntamente com quaisquer alterações feitas desde o último snapshot. Essa infraestrutura é chamada de histórico de status global. Para obter mais informações, consulte [Gerenciar o histórico de status global do RDS para MySQL](Appendix.MySQL.CommonDBATasks.GoSH.md). Os procedimentos armazenados a seguir gerenciam a forma como o histórico de status global é coletado e mantido. **Topics** + [ ## mysql.rds\$1collect\$1global\$1status\$1history ](#mysql_rds_collect_global_status_history) + [ ## mysql.rds\$1disable\$1gsh\$1collector ](#mysql_rds_disable_gsh_collector) + [ ## mysql.rds\$1disable\$1gsh\$1rotation ](#mysql_rds_disable_gsh_rotation) + [ ## mysql.rds\$1enable\$1gsh\$1collector ](#mysql_rds_enable_gsh_collector) + [ ## mysql.rds\$1enable\$1gsh\$1rotation ](#mysql_rds_enable_gsh_rotation) + [ ## mysql.rds\$1rotate\$1global\$1status\$1history ](#mysql_rds_rotate_global_status_history) + [ ## mysql.rds\$1set\$1gsh\$1collector ](#mysql_rds_set_gsh_collector) + [ ## mysql.rds\$1set\$1gsh\$1rotation ](#mysql_rds_set_gsh_rotation) ## mysql.rds\$1collect\$1global\$1status\$1history Gera um snapshot sob demanda para o histórico de status global. ### Sintaxe ``` CALL mysql.rds_collect_global_status_history; ``` ## mysql.rds\$1disable\$1gsh\$1collector Desativa os snapshots gerados pelo histórico de status global. ### Sintaxe ``` CALL mysql.rds_disable_gsh_collector; ``` ## mysql.rds\$1disable\$1gsh\$1rotation Desativa a rotação da tabela `mysql.global_status_history`. ### Sintaxe ``` CALL mysql.rds_disable_gsh_rotation; ``` ## mysql.rds\$1enable\$1gsh\$1collector Ativa o histórico de status global para gerar snapshots padrão em intervalos especificados por `rds_set_gsh_collector`. ### Sintaxe ``` CALL mysql.rds_enable_gsh_collector; ``` ## mysql.rds\$1enable\$1gsh\$1rotation Ativa a rotação do conteúdo da tabela `mysql.global_status_history` com o da `mysql.global_status_history_old` em intervalos especificados por `rds_set_gsh_rotation`. ### Sintaxe ``` CALL mysql.rds_enable_gsh_rotation; ``` ## mysql.rds\$1rotate\$1global\$1status\$1history Reveza o conteúdo da tabela `mysql.global_status_history` para o da `mysql.global_status_history_old` sob demanda. ### Sintaxe ``` CALL mysql.rds_rotate_global_status_history; ``` ## mysql.rds\$1set\$1gsh\$1collector Especifica o intervalo em minutos entre os snapshots gerados pelo histórico de status global. ### Sintaxe ``` CALL mysql.rds_set_gsh_collector(intervalPeriod); ``` ### Parâmetros *intervalPeriod* O intervalo em minutos entre snapshots. O valor padrão é `5`. ## mysql.rds\$1set\$1gsh\$1rotation Especifica o intervalo em dias entre os revezamentos da tabela `mysql.global_status_history`. ### Sintaxe ``` CALL mysql.rds_set_gsh_rotation(intervalPeriod); ``` ### Parâmetros *intervalPeriod* O intervalo em dias entre os revezamentos da tabela. O valor padrão é `7`. # 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). # Encerrar uma sessão ou consulta Os procedimentos armazenados a seguir encerram uma sessão ou consulta. **Topics** + [ ## mysql.rds\$1kill ](#mysql_rds_kill) + [ ## mysql.rds\$1kill\$1query ](#mysql_rds_kill_query) ## mysql.rds\$1kill Encerra uma conexão ao servidor MySQL. ### Sintaxe ``` CALL mysql.rds_kill(processID); ``` ### Parâmetros *processID* A identidade do thread de conexão a ser encerrada. ### Observações de uso Cada conexão ao servidor do MySQL é executada em um thread separado. Para encerrar uma conexão, use o procedimento `mysql.rds_kill` e passe o ID de thread dessa conexão. Para obter o ID de thread, use o comando [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html) do MySQL. Para receber informações sobre limitações, consulte [Limitações de procedimentos armazenados do MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures). ### Exemplos O exemplo a seguir encerra uma conexão com um ID de thread de 4243: ``` CALL mysql.rds_kill(4243); ``` ## mysql.rds\$1kill\$1query Encerra uma consulta em execução no servidor MySQL. ### Sintaxe ``` CALL mysql.rds_kill_query(processID); ``` ### Parâmetros *processID* A identidade do processo ou thread que está executando a consulta a ser encerrada. ### Observações de uso Para encerrar uma consulta em execução no servidor MySQL, use o procedimento `mysql_rds_kill_query` e passe o ID do thread que está executando a consulta. O procedimento então encerra a conexão. Para obter o ID, consulte a [tabela INFORMATION\$1SCHEMA PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/information-schema-processlist-table.html) do MySQL ou use o comando [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html) do MySQL. O valor na coluna ID de `SHOW PROCESSLIST` ou `SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST` é *processID*. Para receber informações sobre limitações, consulte [Limitações de procedimentos armazenados do MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures). ### Exemplos O seguinte exemplo encerra uma consulta com um ID de thread de consulta 230040: ``` CALL mysql.rds_kill_query(230040); ``` # Gerenciar clusters ativos-ativos Os procedimentos armazenados a seguir configuram e gerenciam clusters ativos-ativos do RDS para MySQL. Para ter mais informações, consulte [Configurar clusters ativos-ativos para RDS para MySQL](mysql-active-active-clusters.md). Esses procedimentos armazenados só estão disponíveis com as instâncias de banco de dados do RDS para MySQL que executam as seguintes versões: + Todas as versões do MySQL 8.4 + MySQL 8.0.35 e versões secundárias posteriores **Topics** + [ ## mysql.rds\$1group\$1replication\$1advance\$1gtid ](#mysql_rds_group_replication_advance_gtid) + [ ## mysql.rds\$1group\$1replication\$1create\$1user ](#mysql_rds_group_replication_create_user) + [ ## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel ](#mysql_rds_group_replication_set_recovery_channel) + [ ## mysql.rds\$1group\$1replication\$1start ](#mysql_rds_group_replication_start) + [ ## mysql.rds\$1group\$1replication\$1stop ](#mysql_rds_group_replication_stop) ## mysql.rds\$1group\$1replication\$1advance\$1gtid Cria GTIDs de espaço reservado na instância de banco de dados atual. ### Sintaxe ``` CALL mysql.rds_group_replication_advance_gtid( begin_id , end_id , server_uuid ); ``` ### Parâmetros *begin\$1id* O ID da transação inicial a ser criado. *end\$1id* O ID da transação final a ser criado. *begin\$1id* O `group_replication_group_name` da transação final a ser criado. O `group_replication_group_name` é especificada como um UUID no grupo de parâmetros de banco de dados associado à instância de banco de dados. ### Observações de uso Em um cluster ativo-ativo, para que uma instância de banco de dados ingresse em um grupo, todas as transações GTID executadas na nova instância de banco de dados devem existir nos outros membros do cluster. Em casos incomuns, uma nova instância de banco de dados pode ter mais transações a serem agrupadas quando as transações são executadas antes de ingressar na instância. Nesse caso, não é possível remover nenhuma transação existente, mas é possível usar esse procedimento para criar os GTIDs de espaço reservado correspondentes nas outras instâncias de banco de dados do grupo. Antes de fazer isso, verifique se as transações *não afetam os dados replicados*. Ao chamar esse procedimento, as transações GTID do `server_uuid:begin_id-end_id` são criadas com conteúdo vazio. Para evitar problemas de replicação, não use esse procedimento em nenhuma outra condição. **Importante** Evite chamar esse procedimento quando o cluster ativo-ativo estiver funcionando normalmente. Não chame esse procedimento a menos que você entenda as possíveis consequências das transações que está criando. Chamar esse procedimento pode gerar dados inconsistentes. ### Exemplo O seguinte exemplo cria GTIDs de espaço reservado na instância de banco de dados atual: ``` CALL mysql.rds_group_replication_advance_gtid(5, 6, '11111111-2222-3333-4444-555555555555'); ``` ## mysql.rds\$1group\$1replication\$1create\$1user Cria o usuário de replicação `rdsgrprepladmin` para replicação do grupo na instância de banco de dados. ### Sintaxe ``` CALL mysql.rds_group_replication_create_user( replication_user_password ); ``` ### Parâmetros *replication\$1user\$1password* A senha do usuário de replicação `rdsgrprepladmin`. ### Observações de uso + A senha do usuário de replicação `rdsgrprepladmin` deve ser a mesma em todas as instâncias de banco de dados em um cluster ativo-ativo. + O nome do usuário `rdsgrprepladmin` é reservado para conexões da replicação do grupo. Nenhum outro usuário, incluindo o usuário principal, pode ter esse nome de usuário. ### Exemplo O seguinte exemplo cria o usuário de replicação `rdsgrprepladmin` para replicação do grupo na instância de banco de dados: ``` CALL mysql.rds_group_replication_create_user('password'); ``` ## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel Define o canal `group_replication_recovery` para um cluster ativo-ativo. O procedimento utiliza o usuário reservado `rdsgrprepladmin` para configurar o canal. ### Sintaxe ``` CALL mysql.rds_group_replication_set_recovery_channel( replication_user_password); ``` ### Parâmetros *replication\$1user\$1password* A senha do usuário de replicação `rdsgrprepladmin`. ### Observações de uso A senha do usuário de replicação `rdsgrprepladmin` deve ser a mesma em todas as instâncias de banco de dados em um cluster ativo-ativo. Uma chamada para o `mysql.rds_group_replication_create_user` especifica a senha. ### Exemplo O seguinte exemplo define o canal `group_replication_recovery` para um cluster ativo-ativo: ``` CALL mysql.rds_group_replication_set_recovery_channel('password'); ``` ## mysql.rds\$1group\$1replication\$1start Inicia a replicação do grupo na instância de banco de dados atual. ### Sintaxe ``` CALL mysql.rds_group_replication_start( bootstrap ); ``` ### Parâmetros *bootstrap* Um valor que especifica se deve inicializar um novo grupo ou ingressar em um grupo existente. `1` inicializa um novo grupo com a instância de banco de dados atual. `0` insere a instância de banco de dados atual em um grupo existente conectando-se aos endpoints definidos no parâmetro `group_replication_group_seeds` no grupo de parâmetros do banco de dados associado à instância de banco de dados. ### Exemplo O seguinte exemplo inicializa um novo grupo com a instância de banco de dados atual: ``` CALL mysql.rds_group_replication_start(1); ``` ## mysql.rds\$1group\$1replication\$1stop Interrompe a replicação do grupo na instância de banco de dados atual. ### Sintaxe ``` CALL mysql.rds_group_replication_stop(); ``` ### Observações de uso A interrupção da replicação em uma instância de banco de dados não afeta nenhuma outra instância de banco de dados no cluster ativo-ativo. # Gerenciar a replicação de várias fontes Os procedimentos armazenados a seguir configuram e gerenciam canais de replicação em uma réplica de várias fontes do RDS para MySQL. Para ter mais informações, consulte [Configurar a replicação de várias fontes do Amazon RDS para MySQL](mysql-multi-source-replication.md). Esses procedimentos armazenados só estão disponíveis com as instâncias de banco de dados do RDS para MySQL que executam as seguintes versões de mecanismo: + Todas as versões 8.4 + 8.0.35 e versões secundárias posteriores + 5.7.44 e versões secundárias posteriores Ao usar procedimentos armazenados para gerenciar a replicação com um usuário de replicação configurado com `caching_sha2_passwword`, 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. **nota** Embora essa documentação se refira às instâncias de banco de dados de origem como instâncias de banco de dados do RDS para MySQL, esses procedimentos também funcionam para instâncias do MySQL executadas fora do Amazon RDS. **Topics** + [ ## mysql.rds\$1next\$1source\$1log\$1for\$1channel ](#mysql_rds_next_source_log_for_channel) + [ ## mysql.rds\$1reset\$1external\$1source\$1for\$1channel ](#mysql_rds_reset_external_source_for_channel) + [ ## mysql.rds\$1set\$1external\$1source\$1for\$1channel ](#mysql_rds_set_external_source_for_channel) + [ ## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel ](#mysql_rds_set_external_source_with_auto_position_for_channel) + [ ## mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel ](#mysql_rds_set_external_source_with_delay_for_channel) + [ ## mysql.rds\$1set\$1source\$1auto\$1position\$1for\$1channel ](#mysql_rds_set_source_auto_position_for_channel) + [ ## mysql.rds\$1set\$1source\$1delay\$1for\$1channel ](#mysql_rds_set_source_delay_for_channel) + [ ## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel ](#mysql_rds_skip_repl_error_for_channel) + [ ## mysql.rds\$1start\$1replication\$1for\$1channel ](#mysql_rds_start_replication_for_channel) + [ ## mysql.rds\$1start\$1replication\$1until\$1for\$1channel ](#mysql_rds_start_replication_until_for_channel) + [ ## mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel ](#mysql_rds_start_replication_until_gtid_for_channel) + [ ## mysql.rds\$1stop\$1replication\$1for\$1channel ](#mysql_rds_stop_replication_for_channel) ## mysql.rds\$1next\$1source\$1log\$1for\$1channel 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 esse procedimento somente se estiver recebendo o erro 1236 de E/S de replicação em uma réplica de várias fontes. ### Sintaxe ``` CALL mysql.rds_next_source_log_for_channel( curr_master_log, channel_name ); ``` ### Parâmetros *curr\$1master\$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 FOR CHANNEL 'channel_name'` e veja o campo `Source_Log_File`. *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_next_source_log_for_channel`. Se houver um erro IO\$1thread, por exemplo, será possível usar esse procedimento para ignorar todos os eventos no arquivo de log binário atual e retomar a replicação do próximo arquivo de log binário para o canal especificado em `channel_name`. ### Exemplo Suponha que a replicação falhe em um canal em uma réplica de várias fontes. A execução de `SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G` na réplica de leitura exibe o seguinte resultado: ``` mysql> SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G *************************** 1. row *************************** Replica_IO_State: Waiting for source to send event Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com Source_User: ReplicationUser Source_Port: 3306 Connect_Retry: 60 Source_Log_File: mysql-bin-changelog.012345 Read_Source_Log_Pos: 1219393 Relay_Log_File: replica-relay-bin.000003 Relay_Log_Pos: 30223388 Relay_Source_Log_File: mysql-bin-changelog.012345 Replica_IO_Running: No Replica_SQL_Running: Yes Replicate_Do_DB:. . . 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: . . Channel_name: channel_1 . . -- Some fields are omitted in this example output ``` 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_for_channel` com os seguintes parâmetros: ``` CALL mysql.rds_next_source_log_for_channel(12345,'channel_1'); ``` ## mysql.rds\$1reset\$1external\$1source\$1for\$1channel Interrompe o processo de replicação no canal especificado e remove o canal e as configurações associadas da réplica de várias fontes. **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_for_channel (channel_name); ``` ### Parâmetros *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_reset_external_source_for_channel`. Esse procedimento exclui todos os registros de retransmissão pertencentes ao canal que está sendo removido. ## mysql.rds\$1set\$1external\$1source\$1for\$1channel Configura um canal de replicação em uma instância de banco de dados do RDS para MySQL para replicar os dados de outra instância de banco de dados do RDS para MySQL. **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** Em vez disso, é possível usar o procedimento armazenado [mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel](#mysql_rds_set_external_source_with_delay_for_channel) para configurar esse canal com replicação atrasada. ### Sintaxe ``` CALL mysql.rds_set_external_source_for_channel ( host_name , host_port , replication_user_name , replication_user_password , mysql_binary_log_file_name , mysql_binary_log_file_location , ssl_encryption , channel_name ); ``` ### Parâmetros *host\$1name* O nome de host ou o endereço IP da instância de banco de dados do RDS para MySQL. *host\$1port* A porta usada pela instância de banco de dados do RDS para MySQL. 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 de banco de dados de origem do RDS para MySQL. Recomendamos fornecer uma conta que seja usada unicamente para a replicação com a instância de banco de dados de origem. *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 BINARY LOG STATUS` na instância do banco de dados de origem. As versões anteriores do MySQL usavam `SHOW MASTER STATUS` em vez de `SHOW BINARY LOG STATUS`. Se você estiver usando uma versão do MySQL anterior à 8.4, use `SHOW MASTER STATUS`. *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. *channel\$1name* O nome da instância de replicação. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_set_external_source_for_channel`. Esse procedimento deve ser executado na instância de banco de dados do RDS para MySQL de destino na qual você está criando o canal de replicação. Antes de executar `mysql.rds_set_external_source_for_channel`, configure um usuário de replicação na instância de banco de dados de origem com os privilégios necessários para a réplica de várias fontes. Para conectar a réplica de várias fontes à instância de banco de dados de origem, é necessário especificar os valores `replication_user_name` e `replication_user_password` de um usuário de replicação que tenha as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância de banco de dados de origem. **Como configurar um usuário de replicação na instância de banco de dados de origem** 1. Usando o cliente MySQL de sua preferência, conecte-se à instância de banco de dados de origem e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir. **Importante** Como prática recomendada de segurança, especifique uma senha diferente do valor do espaço reservado mostrado nos exemplos a seguir. ``` CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password'; ``` 1. Na instância de banco de dados de origem, conceda os privilégios `REPLICATION CLIENT` e `REPLICATION SLAVE` para o 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'@'example.com'; ``` Para usar a replicação criptografada, configure a instância de banco de dados de origem para usar conexões SSL. Depois de chamar `mysql.rds_set_external_source_for_channel` para configurar esse canal de replicação, será possível chamar [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) na réplica para iniciar o processo de replicação no canal. É possível chamar [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) para interromper a replicação no canal e remover a configuração do canal da réplica. Ao chamar `mysql.rds_set_external_source_for_channel`, o Amazon RDS grava a hora, o usuário e uma ação de `set channel source` na tabela `mysql.rds_history` sem detalhes específicos do canal e na tabela `mysql.rds_replication_status` com o nome do canal. Essas informações são registradas apenas para fins internos de uso e monitoramento. Para registrar a chamada de procedimento completa para fins de auditoria, pense em habilitar logs gerais ou de auditoria, com base nos requisitos específicos da aplicação. ### Exemplos Quando executado em uma instância de banco de dados do RDS para MySQL, o exemplo a seguir configura um canal de replicação denominado `channel_1` nessa instância de banco de dados para replicar dados da fonte especificada pelo host `sourcedb.example.com` e pela porta `3306`. ``` call mysql.rds_set_external_source_for_channel( 'sourcedb.example.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.0777', 120, 0, 'channel_1'); ``` ## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel Configura um canal de replicação em uma instância de banco de dados do RDS para MySQL com um atraso de replicação opcional. A replicação se baseia em identificadores de transação global (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_for_channel ( host_name , host_port , replication_user_name , replication_user_password , ssl_encryption , delay , channel_name ); ``` ### Parâmetros *host\$1name* O nome de host ou o endereço IP da instância de banco de dados do RDS para MySQL. *host\$1port* A porta usada pela instância de banco de dados do RDS para MySQL. 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 de banco de dados de origem do RDS para MySQL. Recomendamos fornecer uma conta que seja usada unicamente para a replicação com a instância de banco de dados de origem. *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). *channel\$1name* O nome da instância de replicação. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_set_external_source_with_auto_position_for_channel`. Esse procedimento deve ser executado na instância de banco de dados do RDS para MySQL de destino na qual você está criando o canal de replicação. Antes de executar `rds_set_external_source_with_auto_position_for_channel`, configure um usuário de replicação na instância de banco de dados de origem com os privilégios necessários para a réplica de várias fontes. Para conectar a réplica de várias fontes à instância de banco de dados de origem, é necessário especificar os valores `replication_user_name` e `replication_user_password` de um usuário de replicação que tenha as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância de banco de dados de origem. **Como configurar um usuário de replicação na instância de banco de dados de origem** 1. Usando o cliente MySQL de sua preferência, conecte-se à instância de banco de dados de origem e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir. **Importante** Como prática recomendada de segurança, especifique uma senha diferente do valor do espaço reservado mostrado nos exemplos a seguir. ``` CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password'; ``` 1. Na instância de banco de dados de origem, conceda os privilégios `REPLICATION CLIENT` e `REPLICATION SLAVE` para o 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'@'example.com'; ``` Para usar a replicação criptografada, configure a instância de banco de dados de origem para usar conexões SSL. Antes de chamar `mysql.rds_set_external_source_with_auto_position_for_channel`, chame [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](mysql-stored-proc-replicating.md#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_for_channel` para configurar uma instância de banco de dados do Amazon RDS como réplica de leitura em um canal específico, é possível chamar [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) na réplica de leitura para iniciar o processo de replicação nesse canal. Depois de chamar `mysql.rds_set_external_source_with_auto_position_for_channel` para configurar esse canal de replicação, será possível chamar [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) na réplica para iniciar o processo de replicação no canal. É possível chamar [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) para interromper a replicação no canal e remover a configuração do canal da réplica. ### Exemplos Quando executado em uma instância de banco de dados do RDS para MySQL, o exemplo a seguir configura um canal de replicação denominado `channel_1` nessa instância de banco de dados para replicar dados da fonte especificada pelo host `sourcedb.example.com` e pela porta `3306`. Ele define o atraso de replicação mínimo como uma hora (3.600 segundos). Isso significa que uma alteração da instância de banco de dados do RDS para MySQL não é aplicada à réplica de várias fontes por pelo menos uma hora. ``` call mysql.rds_set_external_source_with_auto_position_for_channel( 'sourcedb.example.com', 3306, 'repl_user', 'password', 1, 3600, 'channel_1'); ``` ## mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel Configura um canal de replicação em uma instância de banco de dados do RDS para MySQL com um atraso de replicação especificado. **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_for_channel ( host_name , host_port , replication_user_name , replication_user_password , mysql_binary_log_file_name , mysql_binary_log_file_location , ssl_encryption , delay , channel_name ); ``` ### Parâmetros *host\$1name* O nome de host ou o endereço IP da instância de banco de dados do RDS para MySQL. *host\$1port* A porta usada pela instância de banco de dados do RDS para MySQL. 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 de banco de dados de origem do RDS para MySQL. Recomendamos fornecer uma conta que seja usada unicamente para a replicação com a instância de banco de dados de origem. *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 BINARY LOG STATUS` na instância do banco de dados de origem. As versões anteriores do MySQL usavam `SHOW MASTER STATUS` em vez de `SHOW BINARY LOG STATUS`. Se você estiver usando uma versão do MySQL anterior à 8.4, use `SHOW MASTER STATUS`. *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). *channel\$1name* O nome da instância de replicação. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_set_external_source_with_delay_for_channel`. Esse procedimento deve ser executado na instância de banco de dados do RDS para MySQL de destino na qual você está criando o canal de replicação. Antes de executar `mysql.rds_set_external_source_with_delay_for_channel`, configure um usuário de replicação na instância de banco de dados de origem com os privilégios necessários para a réplica de várias fontes. Para conectar a réplica de várias fontes à instância de banco de dados de origem, é necessário especificar os valores `replication_user_name` e `replication_user_password` de um usuário de replicação que tenha as permissões `REPLICATION CLIENT` e `REPLICATION SLAVE` na instância de banco de dados de origem. **Como configurar um usuário de replicação na instância de banco de dados de origem** 1. Usando o cliente MySQL de sua preferência, conecte-se à instância de banco de dados de origem e crie uma conta de usuário a ser usada para a replicação. Veja um exemplo a seguir. **Importante** Como prática recomendada de segurança, especifique uma senha diferente do valor do espaço reservado mostrado nos exemplos a seguir. ``` CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password'; ``` 1. Na instância de banco de dados de origem, conceda os privilégios `REPLICATION CLIENT` e `REPLICATION SLAVE` para o 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'@'example.com'; ``` Para usar a replicação criptografada, configure a instância de banco de dados de origem para usar conexões SSL. Depois de chamar `mysql.rds_set_external_source_with_delay_for_channel` para configurar esse canal de replicação, será possível chamar [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) na réplica para iniciar o processo de replicação no canal. É possível chamar [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) para interromper a replicação no canal e remover a configuração do canal da réplica. Ao chamar `mysql.rds_set_external_source_with_delay_for_channel`, o Amazon RDS grava a hora, o usuário e uma ação de `set channel source` na tabela `mysql.rds_history` sem detalhes específicos do canal e na tabela `mysql.rds_replication_status` com o nome do canal. Essas informações são registradas apenas para fins internos de uso e monitoramento. Para registrar a chamada de procedimento completa para fins de auditoria, pense em habilitar logs gerais ou de auditoria, com base nos requisitos específicos da aplicação. ### Exemplos Quando executado em uma instância de banco de dados do RDS para MySQL, o exemplo a seguir configura um canal de replicação denominado `channel_1` nessa instância de banco de dados para replicar dados da fonte especificada pelo host `sourcedb.example.com` e pela porta `3306`. Ele define o atraso de replicação mínimo como uma hora (3.600 segundos). Isso significa que uma alteração da instância de banco de dados do RDS para MySQL não é aplicada à réplica de várias fontes por pelo menos uma hora. ``` call mysql.rds_set_external_source_with_delay_for_channel( 'sourcedb.example.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000777', 120, 1, 3600, 'channel_1'); ``` ## mysql.rds\$1set\$1source\$1auto\$1position\$1for\$1channel Define o modo de replicação para o canal especificado como baseado 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_for_channel ( auto_position_mode , channel_name ); ``` ### 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. *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_set_source_auto_position_for_channel`. Esse procedimento reinicia a replicação no canal especificado para aplicar o modo de posição automática especificado. ### Exemplos O exemplo a seguir define o modo de posição automática para channel\$11 usar o método de replicação baseado em GTID. ``` call mysql.rds_set_source_auto_position_for_channel(1,'channel_1'); ``` ## mysql.rds\$1set\$1source\$1delay\$1for\$1channel 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 várias fontes para o canal especificado. ### Sintaxe ``` CALL mysql.rds_set_source_delay_for_channel(delay, channel_name); ``` ### 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). *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_set_source_delay_for_channel`. Para usar o procedimento, primeiro chame `mysql.rds_stop_replication_for_channel` para interromper a replicação. Depois, chame esse procedimento para definir o valor do atraso de replicação. Quando o atraso estiver definido, chame `mysql.rds_start_replication_for_channel` para reiniciar a replicação. ### Exemplos O exemplo a seguir define o atraso da replicação da instância de banco de dados de origem no `channel_1` da réplica de várias fontes por pelo menos uma hora (3.600 segundos). ``` CALL mysql.rds_set_source_delay_for_channel(3600,'channel_1'); ``` ## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel Ignora um evento de logs binários e exclui um erro de replicação em uma réplica de várias fontes de banco de dados do MySQL para o canal especificado. ### Sintaxe ``` CALL mysql.rds_skip_repl_error_for_channel(channel_name); ``` ### Parâmetros *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_skip_repl_error_for_channel` em uma réplica de leitura. É possível usar esse procedimento praticamente da mesma forma que o `mysql.rds_skip_repl_error` é usado para ignorar um erro em uma réplica de leitura. Para ter mais informações, consulte [Chamando o procedimento mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure). **nota** Para ignorar erros na replicação baseada em GTID, recomendamos usar o procedimento [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Para determinar se há erros, execute o comando `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` do MySQL. Se um erro de replicação não for crítico, execute `mysql.rds_skip_repl_error_for_channel` para ignorá-lo. Se houver vários erros, `mysql.rds_skip_repl_error_for_channel` excluirá o primeiro erro no canal de replicação especificado e, depois, avisará que há outros. Assim, você pode usar `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\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. ## mysql.rds\$1start\$1replication\$1for\$1channel Inicia a replicação de uma instância de banco de dados do RDS para MySQL para uma réplica de várias fontes no canal especificado. **nota** Você pode usar o procedimento armazenado [mysql.rds\$1start\$1replication\$1until\$1for\$1channel](#mysql_rds_start_replication_until_for_channel) ou [mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel](#mysql_rds_start_replication_until_gtid_for_channel) para iniciar a replicação de uma instância de banco de dados do RDS para MySQL interromper a replicação no local do arquivo de log binário especificado. ### Sintaxe ``` CALL mysql.rds_start_replication_for_channel(channel_name); ``` ### Parâmetros *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_start_replication_for_channel`. Depois de importar os dados da instância de banco de dados do RDS para MySQL de origem, execute esse comando na réplica de várias fontes para iniciar a replicação no canal especificado. ### Exemplos O exemplo a seguir inicia a replicação em `channel_1` de várias fontes. ``` CALL mysql.rds_start_replication_for_channel('channel_1'); ``` ## mysql.rds\$1start\$1replication\$1until\$1for\$1channel Inicia a replicação de uma instância de banco de dados do RDS para MySQL no canal especificado e interrompe a replicação no local do arquivo de log binário especificado. ### Sintaxe ``` CALL mysql.rds_start_replication_until_for_channel ( replication_log_file , replication_stop_point , channel_name ); ``` ### Parâmetros *replication\$1log\$1file* O nome do log binário na instância de banco de dados de origem 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. *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_start_replication_until_for_channel`. Com esse procedimento, a replicação começa e depois é interrompida quando a posição especificada do arquivo de log binário é atingida. Esse procedimento interrompe tanto o `SQL_THREAD` quanto o `IO_THREAD`. 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 em `channel_1` e replica as alterações até atingir o local `120` no arquivo de log binário `mysql-bin-changelog.000777`. ``` call mysql.rds_start_replication_until_for_channel( 'mysql-bin-changelog.000777', 120, 'channel_1' ); ``` ## mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel Inicia a replicação no canal especificado de uma instância de banco de dados do RDS para MySQL e interrompe a replicação no identificador de transação global (GTID) especificado. ### Sintaxe ``` CALL mysql.rds_start_replication_until_gtid_for_channel(gtid,channel_name); ``` ### Parâmetros *gtid* O GTID após o qual a replicação será interrompida. *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_start_replication_until_gtid_for_channel`. O procedimento inicia a replicação no canal especificado e aplica todas as alterações até o valor de GTID especificado. Depois, ele interrompe a replicação no canal. Quando o parâmetro `gtid` especifica uma transação que já tenha sido executada pela réplica, a replicação é interrompida imediatamente. Antes de executar esse procedimento, você deve desabilitar a replicação multiencadeada definindo o valor de `replica_parallel_workers` ou `slave_parallel_workers` como `0`. ### Exemplos O exemplo a seguir inicia a replicação em `channel_1` e replica as alterações até atingir o GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`. ``` call mysql.rds_start_replication_until_gtid_for_channel('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','channel_1'); ``` ## mysql.rds\$1stop\$1replication\$1for\$1channel Interrompe a replicação de uma instância de banco de dados do MySQL no canal especificado. ### Sintaxe ``` CALL mysql.rds_stop_replication_for_channel(channel_name); ``` ### Parâmetros *channel\$1name* O nome do canal de replicação na réplica de várias fontes. Cada canal de replicação recebe os eventos de logs binários de uma única instância de banco de dados do RDS para MySQL de origem executada em uma porta e um host específicos. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_stop_replication_for_channel`. ### Exemplos O exemplo a seguir interrompe a replicação em `channel_1` da réplica de várias fontes. ``` CALL mysql.rds_stop_replication_for_channel('channel_1'); ``` # Replicar transações com GTIDs Os procedimentos armazenados a seguir controlam como as transações são replicadas usando identificadores de transações globais (GTIDs) com o RDS para MySQL. Para ter mais informações sobre replicação com base em GTIDs com o RDS para MySQL, consulte [Usar a replicação baseada em GTID](mysql-replication-gtid.md). Ao usar 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. **Topics** + [ ## mysql.rds\$1skip\$1transaction\$1with\$1gtid ](#mysql_rds_skip_transaction_with_gtid) + [ ## mysql.rds\$1start\$1replication\$1until\$1gtid ](#mysql_rds_start_replication_until_gtid) ## mysql.rds\$1skip\$1transaction\$1with\$1gtid Ignora a replicação de uma transação com o identificador de transação global (GTID) especificado em uma instância de banco de dados MySQL. Você pode usar esse procedimento para a recuperação de desastres, quando uma transação baseada em GTID específica for conhecida por causar desastres. Use esse procedimento armazenado para ignorar a transação problemática. Exemplos de transações problemáticas incluem transações que desabilitam a replicação, excluem dados importantes ou fazem com que a instância de banco de dados se torne indisponível. ### Sintaxe ``` CALL mysql.rds_skip_transaction_with_gtid ( gtid_to_skip ); ``` ### Parâmetros *gtid\$1to\$1skip* O GTID da transação de replicação a ser ignorada. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_skip_transaction_with_gtid`. Esse procedimento é compatível com todas as versões 5.7 do RDS para MySQL, todas as versões 8.0 do RDS para MySQL e todas as versões do RDS para MySQL 8.4. ### Exemplos O exemplo a seguir ignora a replicação da transação com o GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`. ``` CALL mysql.rds_skip_transaction_with_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23'); ``` ## mysql.rds\$1start\$1replication\$1until\$1gtid Inicia a replicação de uma instância de banco de dados do RDS para MySQL e interrompe a replicação logo depois do identificador de transação global (GTID) especificado. ### Sintaxe ``` CALL mysql.rds_start_replication_until_gtid(gtid); ``` ### Parâmetros *gtid* O GTID após o qual a replicação será interrompida. ### Observações de uso O usuário principal deve executar o procedimento `mysql.rds_start_replication_until_gtid`. Esse procedimento é compatível com todas as versões 5.7 do RDS para MySQL, todas as versões 8.0 do RDS para MySQL e todas as versões do RDS para MySQL 8.4. 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-stored-proc-replicating.md#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-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay) + [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) Quando o parâmetro `gtid` especifica uma transação que já tenha sido executada pela réplica, a replicação é interrompida imediatamente. ### Exemplos O exemplo a seguir inicia a replicação e replica as alterações até atingir o GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`. ``` call mysql.rds_start_replication_until_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23'); ``` # Alternar os logs de consulta Os procedimentos armazenados a seguir fazem a rotação dos logs do MySQL para tabelas de backup. Para ter mais informações, consulte [Arquivos de log do banco de dados MySQL](USER_LogAccess.Concepts.MySQL.md). **Topics** + [ ## mysql.rds\$1rotate\$1general\$1log ](#mysql_rds_rotate_general_log) + [ ## mysql.rds\$1rotate\$1slow\$1log ](#mysql_rds_rotate_slow_log) ## mysql.rds\$1rotate\$1general\$1log Reveza a tabela `mysql.general_log` com uma tabela de backup. ### Sintaxe ``` CALL mysql.rds_rotate_general_log; ``` ### Observações de uso Você pode revezar a tabela `mysql.general_log` com uma tabela de backup, chamando o procedimento `mysql.rds_rotate_general_log`. Quando as tabelas de log são revezadas, a tabela de log atual é copiada para uma tabela de log de backup e as entradas na tabela de log atual são removidas. Se uma tabela de log de backup já existir, então ela será excluída antes que a tabela de log atual seja copiada ao backup. Você pode consultar a tabela de log de backup, se necessário. A tabela de log de backup para a tabela `mysql.general_log` é denominada `mysql.general_log_backup`. É possível executar esse procedimento somente quando o parâmetro `log_output` está definido como `TABLE`. ## mysql.rds\$1rotate\$1slow\$1log Reveza a tabela `mysql.slow_log` com uma tabela de backup. ### Sintaxe ``` CALL mysql.rds_rotate_slow_log; ``` ### Observações de uso Você pode revezar a tabela `mysql.slow_log` com uma tabela de backup, chamando o procedimento `mysql.rds_rotate_slow_log`. Quando as tabelas de log são revezadas, a tabela de log atual é copiada para uma tabela de log de backup e as entradas na tabela de log atual são removidas. Se uma tabela de log de backup já existir, então ela será excluída antes que a tabela de log atual seja copiada ao backup. Você pode consultar a tabela de log de backup, se necessário. A tabela de log de backup para a tabela `mysql.slow_log` é denominada `mysql.slow_log_backup`. # Definir e mostrar a configuração de logs binários Os procedimentos armazenados a seguir definem e mostram parâmetros de configuração, como para retenção de arquivos de log binários. **Topics** + [ ## mysql.rds\$1set\$1configuration ](#mysql_rds_set_configuration) + [ ## mysql.rds\$1show\$1configuration ](#mysql_rds_show_configuration) ## mysql.rds\$1set\$1configuration Especifica o número de horas para retenção de logs binários ou o número de segundos para atrasar a replicação. ### Sintaxe ``` CALL mysql.rds_set_configuration(name,value); ``` ### Parâmetros *name* (Opcional) O nome do parâmetro de configuração a definir. *value* O valor do parâmetro de configuração. ### Observações de uso O procedimento `mysql.rds_set_configuration` oferece suporte aos seguintes parâmetros de configuração: + [horas de retenção do log binário](#mysql_rds_set_configuration-usage-notes.binlog-retention-hours) + [atraso na origem](#mysql_rds_set_configuration-usage-notes.source-delay) + [atraso de destino](#mysql_rds_set_configuration-usage-notes.target-delay) Os parâmetros de configuração são armazenados permanentemente e sobrevivem a qualquer reinicialização ou failover da instância de banco de dados. #### horas de retenção do log binário O parâmetro `binlog retention hours` é usado para especificar o número de horas para reter arquivos de log binários. O Amazon RDS normalmente elimina um log binário o mais rápido possível, mas o log binário ainda pode ser necessário para a replicação com um banco de dados MySQL externo ao RDS. O valor padrão de `binlog retention hours` é `NULL`. Para o RDS para MySQL, `NULL` significa que os logs binários não são retidos (0 horas). Para especificar o número de horas para reter os logs binários em uma instância de banco de dados, use o procedimento armazenado `mysql.rds_set_configuration` e especifique um período com tempo suficiente para que a replicação ocorra, conforme exibido no exemplo a seguir. `call mysql.rds_set_configuration('binlog retention hours', 24);` **nota** Não é possível usar o valor `0` para `binlog retention hours`. Para instâncias de banco de dados MySQL, o valor máximo de `binlog retention hours` é de 168 (7 dias). Após configurar o período de retenção, monitore o uso de armazenamento da instância de banco de dados para garantir que os logs binários retidos não consumam muito armazenamento. Para implantações de cluster de banco de dados multi-AZ, você só pode configurar a retenção de log binário da instância de banco de dados de gravador, e a configuração é propagada para todas as instâncias de banco de dados de leitor de forma assíncrona. Se os logs binários no cluster de banco de dados excederem a metade do espaço total de armazenamento local, o Amazon RDS moverá automaticamente os logs obsoletos para o volume do EBS. No entanto, os logs mais recentes permanecem no armazenamento local e, portanto, poderão ser perdidos se houver uma falha que exija a substituição do host ou se você aumentar ou reduzir a escala do banco de dados verticalmente. #### atraso na origem Use o parâmetro `source delay` em uma réplica de leitura para especificar o número de segundos para atrasar a replicação da réplica de leitura para a instância de banco de dados de origem. O Amazon RDS replica as alterações o mais rápido possível, mas talvez você queira que alguns ambientes atrasem a replicação. Por exemplo, quando a replicação é atrasada, você pode efetuar roll forward de uma réplica de leitura atrasada para o momento imediatamente antes de um desastre. Se uma tabela for descartada acidentalmente, use a replicação atrasada para recuperá-la rapidamente. O valor padrão de `target delay` é `0` (não atrasar a replicação). Quando você usa esse parâmetro, ele executa [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) e aplica CHANGE primary TO MASTER\$1DELAY = valor de entrada. Se for bem-sucedido, o procedimento salvará o parâmetro `source delay` na tabela `mysql.rds_configuration`. Para especificar o número de segundos em que o Amazon RDS atrasará a replicação de uma instância de banco de dados de origem, use o procedimento armazenado `mysql.rds_set_configuration` e especifique o número de segundos de atraso da replicação. No exemplo a seguir, a replicação é atrasada por pelo menos uma hora (3.600 segundos). `call mysql.rds_set_configuration('source delay', 3600);` Depois, o procedimento executa `mysql.rds_set_source_delay(3600)`. O limite do parâmetro `source delay` é de um dia (86.400 segundos). #### atraso de destino Use o parâmetro `target delay` para especificar o número de segundos para atrasar a replicação entre uma instância de banco de dados e quaisquer réplicas de leitura gerenciadas pelo RDS criadas futuramente com base nessa instância. Esse parâmetro é ignorado para réplicas de leitura não gerenciadas pelo RDS. O Amazon RDS replica as alterações o mais rápido possível, mas talvez você queira que alguns ambientes atrasem a replicação. Por exemplo, quando a replicação é atrasada, você pode efetuar roll forward de uma réplica de leitura atrasada para o momento imediatamente antes de um desastre. Se uma tabela for descartada acidentalmente, use a replicação atrasada para recuperá-la rapidamente. O valor padrão de `target delay` é `0` (não atrasar a replicação). Para a recuperação de desastres, você pode usar esse parâmetro de configuração com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#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_configuration` com esse conjunto de parâmetros. 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 ter 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). Para especificar o número de segundos em que o Amazon RDS atrasará a replicação de uma réplica de leitura, use o procedimento armazenado `mysql.rds_set_configuration` e especifique o número de segundos de atraso da replicação. O exemplo a seguir especifica que a replicação é atrasada por pelo menos uma hora (3.600 segundos). `call mysql.rds_set_configuration('target delay', 3600);` O limite do parâmetro `target delay` é de um dia (86.400 segundos). ## mysql.rds\$1show\$1configuration A quantidade de horas em que os logs binários são mantidos. ### Sintaxe ``` CALL mysql.rds_show_configuration; ``` ### Observações de uso Para verificar o número de horas durante as quais o Amazon RDS vai reter os logs binários, use o procedimento armazenado `mysql.rds_show_configuration`. ### Exemplos O exemplo a seguir mostra exibe o período de retenção: ``` call mysql.rds_show_configuration; name value description binlog retention hours 24 binlog retention hours specifies the duration in hours before binary logs are automatically deleted. ``` # Aquecer o armazenamento em cache do InnoDB Os procedimentos armazenados a seguir salvam, carregam ou cancelam o carregamento do pool de buffers do InnoDB no RDS para instâncias de banco de dados MySQL. Para obter mais informações, consulte [Aquecimento de cache do InnoDB para o MySQL no Amazon RDS](MySQL.Concepts.FeatureSupport.md#MySQL.Concepts.InnoDBCacheWarming). **Topics** + [ ## mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now ](#mysql_rds_innodb_buffer_pool_dump_now) + [ ## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort ](#mysql_rds_innodb_buffer_pool_load_abort) + [ ## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now ](#mysql_rds_innodb_buffer_pool_load_now) ## mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now Descarrega o estado atual do grupo de buffer no disco. ### Sintaxe ``` CALL mysql.rds_innodb_buffer_pool_dump_now(); ``` ### Observações de uso O usuário mestre deve executar o procedimento `mysql.rds_innodb_buffer_pool_dump_now`. ## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort Cancela um carregamento do estado salvo do grupo de buffer em andamento. ### Sintaxe ``` CALL mysql.rds_innodb_buffer_pool_load_abort(); ``` ### Observações de uso O usuário mestre deve executar o procedimento `mysql.rds_innodb_buffer_pool_load_abort`. ## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now Carrega o estado salvo do grupo de buffer a partir do disco. ### Sintaxe ``` CALL mysql.rds_innodb_buffer_pool_load_now(); ``` ### Observações de uso O usuário mestre deve executar o procedimento `mysql.rds_innodb_buffer_pool_load_now`.