Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Référence des procédures stockées RDS pour MySQL
Ces rubriques décrivent les procédures stockées système disponibles pour les instances Amazon RDS exécutant le moteur de base de données MySQL. L'utilisateur principal doit exécuter ces procédures.
**Topics**
+ [
# Collecte et maintenance de l’historique global des statuts
](mysql-stored-proc-gsh.md)
+ [
# Configuration, démarrage et arrêt de la réplication des journaux binaires (binlog)
](mysql-stored-proc-replicating.md)
+ [
# Mettre fin à une session ou à une requête
](mysql-stored-proc-ending.md)
+ [
# Gestion des clusters actifs-actifs
](mysql-stored-proc-active-active-clusters.md)
+ [
# Gestion de la réplication multisource
](mysql-stored-proc-multi-source-replication.md)
+ [
# Répliquer des transactions à l'aide de GTIDs
](mysql-stored-proc-gtid.md)
+ [
# Rotation des journaux de requêtes
](mysql-stored-proc-logging.md)
+ [
# Configuration et affichage de la configuration du journal binaire
](mysql-stored-proc-configuring.md)
+ [
# Réchauffement du cache InnoDB
](mysql-stored-proc-warming.md)
# Collecte et maintenance de l’historique global des statuts
Amazon RDS fournit un ensemble de procédures qui prennent des instantanés des valeurs des variables d’état au fil du temps et les écrivent dans une table, ainsi que toutes les modifications intervenues depuis le dernier instantané. Cette infrastructure porte le nom d'historique global des statuts. Pour plus d'informations, consultez [Gestion de l’historique global des statuts de RDS for MySQL](Appendix.MySQL.CommonDBATasks.GoSH.md).
Les procédures stockées suivantes gèrent la manière dont l'historique global des statuts est collecté et conservé.
**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
Prend un instantané sur demande pour l'historique global des statuts.
### Syntaxe
```
CALL mysql.rds_collect_global_status_history;
```
## mysql.rds\$1disable\$1gsh\$1collector
Désactive les instantanés pris par l'historique global des statuts.
### Syntaxe
```
CALL mysql.rds_disable_gsh_collector;
```
## mysql.rds\$1disable\$1gsh\$1rotation
Désactive la rotation de la table `mysql.global_status_history`.
### Syntaxe
```
CALL mysql.rds_disable_gsh_rotation;
```
## mysql.rds\$1enable\$1gsh\$1collector
Active l'historique global des statuts pour prendre des instantanés par défaut aux intervalles spécifiés par `rds_set_gsh_collector`.
### Syntaxe
```
CALL mysql.rds_enable_gsh_collector;
```
## mysql.rds\$1enable\$1gsh\$1rotation
Active la rotation du contenu de la table `mysql.global_status_history` en `mysql.global_status_history_old` aux intervalles spécifiés par `rds_set_gsh_rotation`.
### Syntaxe
```
CALL mysql.rds_enable_gsh_rotation;
```
## mysql.rds\$1rotate\$1global\$1status\$1history
Effectue une rotation du contenu de la table `mysql.global_status_history` en `mysql.global_status_history_old` à la demande.
### Syntaxe
```
CALL mysql.rds_rotate_global_status_history;
```
## mysql.rds\$1set\$1gsh\$1collector
Spécifie l'intervalle, en minutes, entre les instantanés pris par l'historique global des statuts.
### Syntaxe
```
CALL mysql.rds_set_gsh_collector(intervalPeriod);
```
### Paramètres
*intervalPeriod*
Intervalle, en minutes, entre les instantanés. La valeur par défaut est `5`.
## mysql.rds\$1set\$1gsh\$1rotation
Spécifie l’intervalle, en jours, entre deux rotations de la table `mysql.global_status_history`.
### Syntaxe
```
CALL mysql.rds_set_gsh_rotation(intervalPeriod);
```
### Paramètres
*intervalPeriod*
Intervalle, en jours, entre deux rotations de table. La valeur par défaut est `7`.
# Configuration, démarrage et arrêt de la réplication des journaux binaires (binlog)
Les procédures stockées suivantes contrôlent la façon dont les transactions sont répliquées à partir d’une base de données externe dans RDS for MySQL, ou à partir de RDS for MySQL vers une base de données externe.
Lorsque vous utilisez ces procédures stockées pour gérer la réplication avec un utilisateur de réplication configuré avec `caching_sha2_password`, vous devez configurer le protocole TLS en spécifiant `SOURCE_SSL=1`. `caching_sha2_password` est le plugin d’authentification par défaut pour RDS for MySQL 8.4. Pour plus d’informations, consultez [Chiffrement avec SSL/TLS](mysql-ssl-connections.md).
Pour en savoir plus sur la configuration, l’utilisation et la gestion de réplicas en lecture, consultez [Utilisation de réplicas en lecture MySQL](USER_MySQL.Replication.ReadReplicas.md).
**Topics**
+ [
##
](#mysql_rds_next_master_log)
+ [
## mysql.rds\$1next\$1source\$1log (RDS for MySQL, versions majeures 8.4 et ultérieures)
](#mysql_rds_next_source_log)
+ [
## mysql.rds\$1reset\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)
](#mysql_rds_reset_external_master)
+ [
## mysql.rds\$1reset\$1external\$1source (RDS for MySQL, versions majeures 8.4 et ultérieures)
](#mysql_rds_reset_external_source)
+ [
## mysql.rds\$1set\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)
](#mysql_rds_set_external_master)
+ [
## mysql.rds\$1set\$1external\$1source (RDS for MySQL, versions majeures 8.4 et ultérieures)
](#mysql_rds_set_external_source)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS for MySQL, versions majeures 8.0 et antérieures)
](#mysql_rds_set_external_master_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS for MySQL, versions majeures 8.4 et ultérieures)
](#mysql_rds_set_external_source_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)
](#mysql_rds_set_external_master_with_delay)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS for MySQL, versions majeures 8.4 et ultérieures)
](#mysql_rds_set_external_source_with_delay)
+ [
## mysql.rds\$1set\$1external\$1source\$1gtid\$1purged
](#mysql_rds_set_external_source_gtid_purged)
+ [
##
](#mysql_rds_set_master_auto_position)
+ [
## mysql.rds\$1set\$1source\$1auto\$1position (RDS for MySQL, versions majeures 8.4 et ultérieures)
](#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_start_replication_until)
+ [
## mysql.rds\$1stop\$1replication
](#mysql_rds_stop_replication)
##
Modifie la position du journal de l’instance de base de données source au début du journal binaire suivant sur l’instance de base de données source. Utilisez cette procédure uniquement si vous recevez l' I/O erreur de réplication 1236 sur une réplique en lecture.
### Syntaxe
```
CALL mysql.rds_next_master_log(
curr_master_log
);
```
### Parameters
*curr\$1master\$1log*
Index du fichier journal maître actif. Par exemple, si le fichier en cours se nomme `mysql-bin-changelog.012345`, l’index est 12345. Pour déterminer le nom du fichier journal maître actif, exécutez la commande `SHOW REPLICA STATUS` et affichez le champ `Master_Log_File`.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_next_master_log`.
**Avertissement**
Appelez `mysql.rds_next_master_log` uniquement si la réplication échoue après le basculement d'une instance de base de données multi-AZ qui est la source de réplication et si le `Last_IO_Errno` champ de `SHOW REPLICA STATUS` signale l' I/O erreur 1236.
L’appel de `mysql.rds_next_master_log` peut se traduire par une perte de données dans le réplica en lecture si les transactions de l’instance source n’ont pas été écrites dans le journal binaire sur disque avant que l’événement de basculement se produise. Vous pouvez réduire la probabilité que cela se produise en définissant les paramètres d’instance source `sync_binlog` et `innodb_support_xa` sur `1`, même si cela peut compromettre les performances. Pour plus d'informations, consultez [Résolution d'un problème de réplica en lecture MySQL](USER_ReadRepl.Troubleshooting.md).
### Exemples
Supposons que la réplication échoue sur un réplica en lecture RDS pour MySQL. L’exécution de `SHOW REPLICA STATUS\G` sur le réplica en lecture renvoie le résultat suivant :
```
*************************** 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
```
Le champ `Last_IO_Errno` montre que l’instance reçoit une erreur 1236 d’I/O. Le champ `Master_Log_File` montre que le nom du fichier est `mysql-bin-changelog.012345`, ce qui signifie que l’index du fichier journal est `12345`. Pour résoudre l’erreur, vous pouvez appeler `mysql.rds_next_master_log` avec le paramètre suivant :
```
CALL mysql.rds_next_master_log(12345);
```
## mysql.rds\$1next\$1source\$1log (RDS for MySQL, versions majeures 8.4 et ultérieures)
Modifie la position du journal de l’instance de base de données source au début du journal binaire suivant sur l’instance de base de données source. Utilisez cette procédure uniquement si vous recevez l' I/O erreur de réplication 1236 sur une réplique en lecture.
### Syntaxe
```
CALL mysql.rds_next_source_log(
curr_source_log
);
```
### Parameters
*curr\$1source\$1log*
Index du fichier journal source actuel. Par exemple, si le fichier en cours se nomme `mysql-bin-changelog.012345`, l’index est 12345. Pour déterminer le nom du fichier journal actuel, exécutez la commande `SHOW REPLICA STATUS` et affichez le champ `Source_Log_File`.
### Notes d’utilisation
L’utilisateur administratif doit exécuter la procédure `mysql.rds_next_source_log`.
**Avertissement**
Appelez `mysql.rds_next_source_log` uniquement si la réplication échoue après le basculement d'une instance de base de données multi-AZ qui est la source de réplication et si le `Last_IO_Errno` champ de `SHOW REPLICA STATUS` signale l' I/O erreur 1236.
L’appel de `mysql.rds_next_source_log` peut se traduire par une perte de données dans le réplica en lecture si les transactions de l’instance source n’ont pas été écrites dans le journal binaire sur disque avant que l’événement de basculement se produise. Vous pouvez réduire la probabilité que cela se produise en définissant les paramètres d’instance source `sync_binlog` et `innodb_support_xa` sur `1`, même si cela peut compromettre les performances. Pour plus d’informations, consultez [Résolution d'un problème de réplica en lecture MySQL](USER_ReadRepl.Troubleshooting.md).
### Exemples
Supposons que la réplication échoue sur un réplica en lecture RDS pour MySQL. L’exécution de `SHOW REPLICA STATUS\G` sur le réplica en lecture renvoie le résultat suivant :
```
*************************** 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
```
Le champ `Last_IO_Errno` montre que l’instance reçoit une erreur 1236 d’I/O. Le champ `Source_Log_File` montre que le nom du fichier est `mysql-bin-changelog.012345`, ce qui signifie que l’index du fichier journal est `12345`. Pour résoudre l’erreur, vous pouvez appeler `mysql.rds_next_source_log` avec le paramètre suivant :
```
CALL mysql.rds_next_source_log(12345);
```
## mysql.rds\$1reset\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)
Reconfigure une instance de base de données RDS for MySQL comme n’étant plus un réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
CALL mysql.rds_reset_external_master;
```
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_reset_external_master`. Cette procédure doit être exécutée sur l’instance de base de données MySQL à supprimer comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS. Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
Pour plus d’informations sur l’utilisation de la réplication pour importer des données à partir d’une instance de MySQL s’exécutant à l’extérieur de Amazon RDS, consultez [Configuration d’une réplication de position de fichier journal binaire avec une instance source externe](MySQL.Procedural.Importing.External.Repl.md).
## mysql.rds\$1reset\$1external\$1source (RDS for MySQL, versions majeures 8.4 et ultérieures)
Reconfigure une instance de base de données RDS for MySQL comme n’étant plus un réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
CALL mysql.rds_reset_external_source;
```
### Notes d’utilisation
L’utilisateur administratif doit exécuter la procédure `mysql.rds_reset_external_source`. Cette procédure doit être exécutée sur l’instance de base de données MySQL à supprimer comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS.
Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md). Pour plus d’informations sur l’utilisation de la réplication pour importer des données à partir d’une instance de MySQL s’exécutant à l’extérieur de Amazon RDS, consultez [Configuration d’une réplication de position de fichier journal binaire avec une instance source externe](MySQL.Procedural.Importing.External.Repl.md).
## mysql.rds\$1set\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)
Configure une instance de base de données RDS for MySQL comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
**Note**
Vous pouvez utiliser la procédure stockée [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)](#mysql_rds_set_external_master_with_delay) pour configurer une instance de base de données source externe et une réplication différée.
### Syntaxe
```
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
);
```
### Parameters
*host\$1name*
Nom d’hôte ou adresse IP de l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS pour devenir l’instance de base de données source.
*host\$1port*
Port utilisé par l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et à configurer comme instance de base de données source. Si votre configuration réseau inclut une réplication de port Secure Shell (SSH) qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance externe.
*replication\$1user\$1password*
Mot de passe de l’ID utilisateur spécifié dans `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nom du journal binaire sur l’instance de base de données source qui contient les informations de réplication.
*mysql\$1binary\$1log\$1file\$1location*
Emplacement dans le journal binaire `mysql_binary_log_file_name` à partir duquel la réplication commence à lire les informations de réplication.
Vous pouvez déterminer le nom et l’emplacement du fichier journal binaire en exécutant `SHOW MASTER STATUS` sur l’instance de base de données source.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d’utiliser le chiffrement SSL, et la valeur 0 de ne pas l’utiliser. La valeur par défaut est 0.
L’option `MASTER_SSL_VERIFY_SERVER_CERT` n’est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_external_master`. Cette procédure doit être exécutée sur l’instance de base de données MySQL qui doit être configurée comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
Avant d’exécuter `mysql.rds_set_external_master`, vous devez configurer l’instance de MySQL s’exécutant en dehors de Amazon RDS comme instance de base de données source. Pour vous connecter à l’instance MySQL en cours d’exécution en dehors de Amazon RDS, vous devez spécifier des valeurs `replication_user_name` et `replication_user_password` qui indiquent un utilisateur de réplication possédant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance externe de MySQL.
**Pour configurer une instance externe de MySQL en tant qu’instance de base de données source**
1. A l’aide du client MySQL de votre choix, connectez-vous à l’instance externe de MySQL et créez un compte d’utilisateur à utiliser pour la réplication. Voici un exemple.
**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';
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
1. Sur l’instance externe de MySQL, accordez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur « repl\$1user » de votre domaine.
**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';
```
Pour utiliser la réplication chiffrée, configurez l’instance de base de données source de façon à utiliser les connexions SSL.
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS. Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
Après avoir appelé `mysql.rds_set_external_master` pour configurer une instance de base de données Amazon RDS comme réplica en lecture, vous pouvez appeler [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sur le réplica en lecture pour démarrer le processus de réplication. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)](#mysql_rds_reset_external_master) pour supprimer la configuration du réplica en lecture.
Quand la procédure `mysql.rds_set_external_master` est appelée, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set master` dans les tables `mysql.rds_history` et `mysql.rds_replication_status`.
### Exemples
Lors d’une exécution sur une instance de base de données MySQL, l’exemple suivant configure l’instance de base de données comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’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 for MySQL, versions majeures 8.4 et ultérieures)
Configure une instance de base de données RDS for MySQL comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
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
);
```
### Parameters
*host\$1name*
Nom d’hôte ou adresse IP de l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS pour devenir l’instance de base de données source.
*host\$1port*
Port utilisé par l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et à configurer comme instance de base de données source. Si votre configuration réseau inclut une réplication de port Secure Shell (SSH) qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance externe.
*replication\$1user\$1password*
Mot de passe de l’ID utilisateur spécifié dans `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nom du journal binaire sur l’instance de base de données source qui contient les informations de réplication.
*mysql\$1binary\$1log\$1file\$1location*
Emplacement dans le journal binaire `mysql_binary_log_file_name` à partir duquel la réplication commence à lire les informations de réplication.
Vous pouvez déterminer le nom et l’emplacement du fichier journal binaire en exécutant `SHOW MASTER STATUS` sur l’instance de base de données source.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d’utiliser le chiffrement SSL, et la valeur 0 de ne pas l’utiliser. La valeur par défaut est 0.
L’option `SOURCE_SSL_VERIFY_SERVER_CERT` n’est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
### Notes d’utilisation
L’utilisateur administratif doit exécuter la procédure `mysql.rds_set_external_source`. Cette procédure doit être exécutée sur l’instance de base de données RDS for MySQL qui doit être configurée comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
Avant d’exécuter `mysql.rds_set_external_source`, vous devez configurer l’instance de MySQL s’exécutant en dehors de Amazon RDS comme instance de base de données source. Pour vous connecter à l’instance MySQL en cours d’exécution en dehors de Amazon RDS, vous devez spécifier des valeurs `replication_user_name` et `replication_user_password` qui indiquent un utilisateur de réplication possédant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance externe de MySQL.
**Pour configurer une instance externe de MySQL en tant qu’instance de base de données source**
1. A l’aide du client MySQL de votre choix, connectez-vous à l’instance externe de MySQL et créez un compte d’utilisateur à utiliser pour la réplication. Voici un exemple.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
1. Sur l’instance externe de MySQL, accordez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur « repl\$1user » de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
Pour utiliser la réplication chiffrée, configurez l’instance de base de données source de façon à utiliser les connexions SSL. De plus, importez le certificat de l’autorité de certification, le certificat du client et la clé du client dans l’instance de base de données ou le cluster de bases de données à l’aide de la procédure [mysql.rds\$1import\$1binlog\$1ssl\$1material](url-rds-user;mysql_rds_import_binlog_ssl_material.html).
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS. Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
Après avoir appelé `mysql.rds_set_external_source` pour configurer une instance de base de données RDS for MySQL comme réplica en lecture, vous pouvez appeler [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sur le réplica en lecture pour démarrer le processus de réplication. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1source (RDS for MySQL, versions majeures 8.4 et ultérieures)](#mysql_rds_reset_external_source) pour supprimer la configuration du réplica en lecture.
Quand la procédure `mysql.rds_set_external_source` est appelée, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set master` dans les tables `mysql.rds_history` et `mysql.rds_replication_status`.
### Exemples
Lors d’une exécution sur une instance de base de données RDS for MySQL, l’exemple suivant configure l’instance de base de données comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’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 for MySQL, versions majeures 8.0 et antérieures)
Configure une instance de base de données RDS for MySQL comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur de Amazon RDS. Cette procédure configure également la réplication différée et la réplication en fonction des identificateurs de transaction globaux ()GTIDs.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
CALL mysql.rds_set_external_master_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parameters
*host\$1name*
Nom d’hôte ou adresse IP de l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS pour devenir l’instance de base de données source.
*host\$1port*
Port utilisé par l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et à configurer comme instance de base de données source. Si votre configuration réseau inclut une réplication de port Secure Shell (SSH) qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance externe.
*replication\$1user\$1password*
Mot de passe de l’ID utilisateur spécifié dans `replication_user_name`.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d’utiliser le chiffrement SSL, et la valeur 0 de ne pas l’utiliser. La valeur par défaut est 0.
L’option `MASTER_SSL_VERIFY_SERVER_CERT` n’est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_external_master_with_auto_position`. Cette procédure doit être exécutée sur l’instance de base de données MySQL qui doit être configurée comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
Cette procédure est prise en charge pour toutes les versions de RDS for MySQL 5.7, et RDS for MySQL 8.0.26 et les versions 8.0 ultérieures.
Avant d’exécuter `mysql.rds_set_external_master_with_auto_position`, vous devez configurer l’instance de MySQL s’exécutant en dehors de Amazon RDS comme instance de base de données source. Pour vous connecter à l’instance MySQL s’exécutant en dehors d’Amazon RDS, vous devez spécifier des valeurs pour `replication_user_name` et `replication_user_password`. Ces valeurs doivent indiquer un utilisateur de réplication disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance externe de MySQL.
**Pour configurer une instance externe de MySQL en tant qu’instance de base de données source**
1. A l’aide du client MySQL de votre choix, connectez-vous à l’instance externe de MySQL et créez un compte d’utilisateur à utiliser pour la réplication. Voici un exemple de.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Sur l’instance externe de MySQL, accordez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur `'repl_user'` de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Pour plus d’informations, consultez [Configuration d’une réplication de position de fichier journal binaire avec une instance source externe](MySQL.Procedural.Importing.External.Repl.md).
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS. Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
Avant d’appeler `mysql.rds_set_external_master_with_auto_position`, assurez-vous d’appeler [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) pour définir la variable système `gtid_purged` avec une plage GTID spécifiée à partir d’une source externe.
Après avoir appelé `mysql.rds_set_external_master_with_auto_position` pour configurer une instance de base de données Amazon RDS comme réplica en lecture, vous pouvez appeler [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sur le réplica en lecture pour démarrer le processus de réplication. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)](#mysql_rds_reset_external_master) pour supprimer la configuration du réplica en lecture.
Lorsque vous appelez `mysql.rds_set_external_master_with_auto_position`, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set master` dans les tables `mysql.rds_history` et `mysql.rds_replication_status`.
Pour la reprise après sinistre, vous pouvez utiliser cette procédure avec la procédure stockée [](#mysql_rds_start_replication_until) ou [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre, vous pouvez exécuter la procédure `mysql.rds_set_external_master_with_auto_position`. Une fois que la procédure `mysql.rds_start_replication_until_gtid` a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Pour utiliser la procédure `mysql.rds_rds_start_replication_until_gtid`, la réplication basée sur des identifiants de transaction globaux (GTID) doit être activée. Pour ignorer une transaction basée sur des identifiants de transaction globaux spécifique qui est réputée pour entraîner des défaillances, vous pouvez utiliser la procédure stockée [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Pour plus d’informations sur la gestion d’une réplication basée sur des identifiants de transaction globaux, consultez [Utilisation de la réplication basée sur des identifiants de transaction globaux (GTID)](mysql-replication-gtid.md).
### Exemples
Lors d’une exécution sur une instance de base de données MySQL, l’exemple suivant configure l’instance de base de données comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS. Il définit le délai de réplication minimal à une heure (soit 3 600 secondes) sur l’instance de base de données MySQL. Une modification provenant de l’instance de base de données source MySQL exécutée à l’extérieur d’Amazon RDS n’est pas appliquée dans le réplica en lecture de l’instance de base de données MySQL pendant au moins une heure.
```
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 for MySQL, versions majeures 8.4 et ultérieures)
Configure une instance de base de données RDS for MySQL comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur de Amazon RDS. Cette procédure configure également la réplication différée et la réplication en fonction des identificateurs de transaction globaux ()GTIDs.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
CALL mysql.rds_set_external_source_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parameters
*host\$1name*
Nom d’hôte ou adresse IP de l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS pour devenir l’instance de base de données source.
*host\$1port*
Port utilisé par l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et à configurer comme instance de base de données source. Si votre configuration réseau inclut une réplication de port Secure Shell (SSH) qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance externe.
*replication\$1user\$1password*
Mot de passe de l’ID utilisateur spécifié dans `replication_user_name`.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d’utiliser le chiffrement SSL, et la valeur 0 de ne pas l’utiliser. La valeur par défaut est 0.
L’option `SOURCE_SSL_VERIFY_SERVER_CERT` n’est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
### Notes d’utilisation
L’utilisateur administratif doit exécuter la procédure `mysql.rds_set_external_source_with_auto_position`. Cette procédure doit être exécutée sur l’instance de base de données MySQL qui doit être configurée comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
Avant d’exécuter `mysql.rds_set_external_source_with_auto_position`, vous devez configurer l’instance de MySQL s’exécutant en dehors de Amazon RDS comme instance de base de données source. Pour vous connecter à l’instance MySQL s’exécutant en dehors d’Amazon RDS, vous devez spécifier des valeurs pour `replication_user_name` et `replication_user_password`. Ces valeurs doivent indiquer un utilisateur de réplication disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance externe de MySQL.
**Pour configurer une instance externe de MySQL en tant qu’instance de base de données source**
1. A l’aide du client MySQL de votre choix, connectez-vous à l’instance externe de MySQL et créez un compte d’utilisateur à utiliser pour la réplication. Voici un exemple de.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Sur l’instance externe de MySQL, accordez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur `'repl_user'` de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Pour plus d’informations, consultez [Configuration d’une réplication de position de fichier journal binaire avec une instance source externe](MySQL.Procedural.Importing.External.Repl.md).
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS. Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
Avant d’appeler `mysql.rds_set_external_source_with_auto_position`, assurez-vous d’appeler [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) pour définir la variable système `gtid_purged` avec une plage GTID spécifiée à partir d’une source externe.
Après avoir appelé `mysql.rds_set_external_source_with_auto_position` pour configurer une instance de base de données Amazon RDS comme réplica en lecture, vous pouvez appeler [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sur le réplica en lecture pour démarrer le processus de réplication. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1source (RDS for MySQL, versions majeures 8.4 et ultérieures)](#mysql_rds_reset_external_source) pour supprimer la configuration du réplica en lecture.
Lorsque vous appelez `mysql.rds_set_external_source_with_auto_position`, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set master` dans les tables `mysql.rds_history` et `mysql.rds_replication_status`.
Pour la reprise après sinistre, vous pouvez utiliser cette procédure avec la procédure stockée [](#mysql_rds_start_replication_until) ou [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre, vous pouvez exécuter la procédure `mysql.rds_set_external_source_with_auto_position`. Une fois que la procédure `mysql.rds_start_replication_until_gtid` a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Pour utiliser la procédure `mysql.rds_rds_start_replication_until_gtid`, la réplication basée sur des identifiants de transaction globaux (GTID) doit être activée. Pour ignorer une transaction basée sur des identifiants de transaction globaux spécifique qui est réputée pour entraîner des défaillances, vous pouvez utiliser la procédure stockée [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Pour plus d’informations sur la gestion d’une réplication basée sur des identifiants de transaction globaux, consultez [Utilisation de la réplication basée sur des identifiants de transaction globaux (GTID)](mysql-replication-gtid.md).
### Exemples
Lors d’une exécution sur une instance de base de données MySQL, l’exemple suivant configure l’instance de base de données comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS. Il définit le délai de réplication minimal à une heure (soit 3 600 secondes) sur l’instance de base de données MySQL. Une modification provenant de l’instance de base de données source MySQL exécutée à l’extérieur d’Amazon RDS n’est pas appliquée dans le réplica en lecture de l’instance de base de données MySQL pendant au moins une heure.
```
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 for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)
Configure une instance de base de données RDS for MySQL comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur de Amazon RDS et configure une réplication retardée.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
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
);
```
### Parameters
*host\$1name*
Nom d’hôte ou adresse IP de l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et qui deviendra l’instance de base de données source.
*host\$1port*
Port utilisé par l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et à configurer comme instance de base de données source. Si votre configuration réseau inclut une réplication de port SSH qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance externe.
*replication\$1user\$1password*
Mot de passe de l’ID utilisateur spécifié dans `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Le nom du journal binaire sur l’instance de base de données source contient les informations de réplication.
*mysql\$1binary\$1log\$1file\$1location*
Emplacement dans le journal binaire `mysql_binary_log_file_name` à partir duquel la réplication commence à lire les informations de réplication.
Vous pouvez déterminer le nom et l’emplacement du fichier journal binaire en exécutant `SHOW MASTER STATUS` sur l’instance de base de données source.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d’utiliser le chiffrement SSL, et la valeur 0 de ne pas l’utiliser. La valeur par défaut est 0.
L’option `MASTER_SSL_VERIFY_SERVER_CERT` n’est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_external_master_with_delay`. Cette procédure doit être exécutée sur l’instance de base de données MySQL qui doit être configurée comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
Avant d’exécuter `mysql.rds_set_external_master_with_delay`, vous devez configurer l’instance de MySQL s’exécutant en dehors de Amazon RDS comme instance de base de données source. Pour vous connecter à l’instance MySQL s’exécutant en dehors d’Amazon RDS, vous devez spécifier des valeurs pour `replication_user_name` et `replication_user_password`. Ces valeurs doivent indiquer un utilisateur de réplication disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance externe de MySQL.
**Pour configurer une instance externe de MySQL en tant qu’instance de base de données source**
1. A l’aide du client MySQL de votre choix, connectez-vous à l’instance externe de MySQL et créez un compte d’utilisateur à utiliser pour la réplication. Voici un exemple de.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Sur l’instance externe de MySQL, accordez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur `'repl_user'` de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Pour plus d’informations, consultez [Configuration d’une réplication de position de fichier journal binaire avec une instance source externe](MySQL.Procedural.Importing.External.Repl.md).
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS. Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
Après avoir appelé `mysql.rds_set_external_master_with_delay` pour configurer une instance de base de données Amazon RDS comme réplica en lecture, vous pouvez appeler [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sur le réplica en lecture pour démarrer le processus de réplication. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)](#mysql_rds_reset_external_master) pour supprimer la configuration du réplica en lecture.
Lorsque vous appelez `mysql.rds_set_external_master_with_delay`, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set master` dans les tables `mysql.rds_history` et `mysql.rds_replication_status`.
Pour la reprise après sinistre, vous pouvez utiliser cette procédure avec la procédure stockée [](#mysql_rds_start_replication_until) ou [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre, vous pouvez exécuter la procédure `mysql.rds_set_external_master_with_delay`. Une fois que la procédure `mysql.rds_start_replication_until` a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Pour utiliser la procédure `mysql.rds_rds_start_replication_until_gtid`, la réplication basée sur des identifiants de transaction globaux (GTID) doit être activée. Pour ignorer une transaction basée sur des identifiants de transaction globaux spécifique qui est réputée pour entraîner des défaillances, vous pouvez utiliser la procédure stockée [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Pour plus d’informations sur la gestion d’une réplication basée sur des identifiants de transaction globaux, consultez [Utilisation de la réplication basée sur des identifiants de transaction globaux (GTID)](mysql-replication-gtid.md).
La procédure `mysql.rds_set_external_master_with_delay` est disponible dans les versions de RDS for MySQL suivantes :
+ MySQL 8.0.26 et versions 8.0 ultérieures
+ Toutes les versions 5.7
### Exemples
Lors d’une exécution sur une instance de base de données MySQL, l’exemple suivant configure l’instance de base de données comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS. Il définit le délai de réplication minimal à une heure (soit 3 600 secondes) sur l’instance de base de données MySQL. Une modification provenant de l’instance de base de données source MySQL exécutée à l’extérieur d’Amazon RDS n’est pas appliquée dans le réplica en lecture de l’instance de base de données MySQL pendant au moins une heure.
```
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 for MySQL, versions majeures 8.4 et ultérieures)
Configure une instance de base de données RDS for MySQL comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur de Amazon RDS et configure une réplication retardée.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
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
);
```
### Parameters
*host\$1name*
Nom d’hôte ou adresse IP de l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et qui deviendra l’instance de base de données source.
*host\$1port*
Port utilisé par l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS et à configurer comme instance de base de données source. Si votre configuration réseau inclut une réplication de port SSH qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance MySQL s’exécutant à l’extérieur d’Amazon RDS. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance externe.
*replication\$1user\$1password*
Mot de passe de l’ID utilisateur spécifié dans `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Le nom du journal binaire sur l’instance de base de données source contient les informations de réplication.
*mysql\$1binary\$1log\$1file\$1location*
Emplacement dans le journal binaire `mysql_binary_log_file_name` à partir duquel la réplication commence à lire les informations de réplication.
Vous pouvez déterminer le nom et l’emplacement du fichier journal binaire en exécutant `SHOW MASTER STATUS` sur l’instance de base de données source.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d’utiliser le chiffrement SSL, et la valeur 0 de ne pas l’utiliser. La valeur par défaut est 0.
L’option `SOURCE_SSL_VERIFY_SERVER_CERT` n’est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
### Notes d’utilisation
L’utilisateur administratif doit exécuter la procédure `mysql.rds_set_external_source_with_delay`. Cette procédure doit être exécutée sur l’instance de base de données MySQL qui doit être configurée comme réplica en lecture d’une instance MySQL s’exécutant en dehors d’Amazon RDS.
Avant d’exécuter `mysql.rds_set_external_source_with_delay`, vous devez configurer l’instance de MySQL s’exécutant en dehors de Amazon RDS comme instance de base de données source. Pour vous connecter à l’instance MySQL s’exécutant en dehors d’Amazon RDS, vous devez spécifier des valeurs pour `replication_user_name` et `replication_user_password`. Ces valeurs doivent indiquer un utilisateur de réplication disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance externe de MySQL.
**Pour configurer une instance externe de MySQL en tant qu’instance de base de données source**
1. A l’aide du client MySQL de votre choix, connectez-vous à l’instance externe de MySQL et créez un compte d’utilisateur à utiliser pour la réplication. Voici un exemple de.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Sur l’instance externe de MySQL, accordez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur `'repl_user'` de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Pour plus d’informations, consultez [Configuration d’une réplication de position de fichier journal binaire avec une instance source externe](MySQL.Procedural.Importing.External.Repl.md).
**Note**
Nous vous conseillons d’utiliser des réplicas en lecture pour gérer la réplication entre deux instances de base de données Amazon RDS dès que possible. Dans ce cas, nous vous conseillons d’utiliser seulement cette procédure et d’autres procédures stockées liées à la réplication. Ces pratiques permettent d’obtenir des topologies de réplication plus complexes entre des instances de base de données Amazon RDS. Nous proposons ces procédures stockées avant tout pour permettre la réplication avec les instances MySQL s’exécutant en dehors d’Amazon RDS. Pour plus d’informations sur la gestion de la réplication entre les instances de base de données Amazon RDS, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
Après avoir appelé `mysql.rds_set_external_source_with_delay` pour configurer une instance de base de données Amazon RDS comme réplica en lecture, vous pouvez appeler [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sur le réplica en lecture pour démarrer le processus de réplication. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1source (RDS for MySQL, versions majeures 8.4 et ultérieures)](#mysql_rds_reset_external_source) pour supprimer la configuration du réplica en lecture.
Lorsque vous appelez `mysql.rds_set_external_source_with_delay`, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set master` dans les tables `mysql.rds_history` et `mysql.rds_replication_status`.
Pour la reprise après sinistre, vous pouvez utiliser cette procédure avec la procédure stockée [](#mysql_rds_start_replication_until) ou [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre, vous pouvez exécuter la procédure `mysql.rds_set_external_source_with_delay`. Une fois que la procédure `mysql.rds_start_replication_until` a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Pour utiliser la procédure `mysql.rds_rds_start_replication_until_gtid`, la réplication basée sur des identifiants de transaction globaux (GTID) doit être activée. Pour ignorer une transaction basée sur des identifiants de transaction globaux spécifique qui est réputée pour entraîner des défaillances, vous pouvez utiliser la procédure stockée [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Pour plus d’informations sur la gestion d’une réplication basée sur des identifiants de transaction globaux, consultez [Utilisation de la réplication basée sur des identifiants de transaction globaux (GTID)](mysql-replication-gtid.md).
### Exemples
Lors d’une exécution sur une instance de base de données MySQL, l’exemple suivant configure l’instance de base de données comme réplica en lecture d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS. Il définit le délai de réplication minimal à une heure (soit 3 600 secondes) sur l’instance de base de données MySQL. Une modification provenant de l’instance de base de données source MySQL exécutée à l’extérieur d’Amazon RDS n’est pas appliquée dans le réplica en lecture de l’instance de base de données MySQL pendant au moins une heure.
```
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
Définit la variable système [gtid\$1purged](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_gtid_purged) avec une plage GTID spécifiée à partir d’une source externe. La valeur `gtid_purged` est requise pour configurer la réplication GTID afin de reprendre la réplication à l’aide du positionnement automatique.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l’activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
CALL mysql.rds_set_external_source_gtid_purged(
server_uuid
, start_pos
, end_pos
);
```
### Parameters
*server\$1uuid*
L’identifiant universel unique (UUID) du serveur externe à partir duquel la plage GTID est importée.
*start\$1pos*
La position de départ de la plage GTID à définir.
*end\$1pos*
La position de fin de la plage GTID à définir.
### Notes d’utilisation
La procédure `mysql.rds_set_external_source_gtid_purged` est uniquement disponible avec MySQL 8.0.37 et les versions 8.0 ultérieures.
Appelez `mysql.rds_set_external_source_gtid_purged` avant d’appeler [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS for MySQL, versions majeures 8.0 et antérieures)](#mysql_rds_set_external_master_with_auto_position), [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS for MySQL, versions majeures 8.4 et ultérieures)](#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).
Avant d’appeler `mysql.rds_set_external_source_gtid_purged`, assurez-vous d’arrêter tous les canaux de réplication actifs pour la base de données. Pour vérifier l’état d’un canal, utilisez l’instruction MySQL `SHOW REPLICA STATUS`. Pour arrêter la réplication sur un canal, appelez [mysql.rds\$1stop\$1replication\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_stop_replication_for_channel).
La plage GTID que vous spécifiez doit être un sur-ensemble de la valeur existante `GTID_PURGED`. Cette procédure stockée vérifie les valeurs suivantes avant de définir la valeur `GTID_PURGED` :
+ Le `server_uuid` est valide.
+ La valeur `start_pos` est supérieure à `0` et inférieure à la valeur `end_pos`.
+ La valeur `end_pos` est supérieure ou égale à la valeur `start_pos`.
Si le GTID défini sur votre serveur externe contient plusieurs plages de valeurs, il est recommandé d’appeler la procédure plusieurs fois, avec différentes valeurs de GTID.
Lorsque vous appelez `mysql.rds_set_external_source_gtid_purged`, Amazon RDS enregistre l’heure, l’utilisateur et une action `set gtid_purged` dans la table `mysql.rds_history`.
Si vous ne définissez pas la valeur `gtid_purged` appropriée pour la sauvegarde que vous utilisez pour la réplication, certaines transactions peuvent être manquantes ou dupliquées au cours du processus de réplication. Effectuez les étapes suivantes pour définir la valeur `gtid_purged` appropriée.
**Pour définir la valeur gtid\$1purged sur le réplica**
1. Identifiez le moment précis ou le fichier de sauvegarde à utiliser comme point de départ de la réplication. Il peut s’agir d’une sauvegarde logique (un fichier mysqldump) ou physique (un instantané Amazon RDS).
1. Déterminez la valeur `gtid_executed`. Cette valeur représente l'ensemble de tous ceux GTIDs qui ont été validés sur le serveur. Pour obtenir cette valeur, effectuez l’une des actions suivantes sur l’instance source :
+ Exécutez l’instruction SQL `SELECT @@GLOBAL.GTID_EXECUTED;` au moment de la sauvegarde.
+ Si des options associées sont incluses dans l’utilitaire de sauvegarde correspondant, extrayez la valeur du fichier de sauvegarde. Pour plus d'informations, consultez l'[set-gtid-purged](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html#option_mysqldump_set-gtid-purged)option dans la documentation MySQL.
1. Déterminez la valeur `gtid_purged` à utiliser pour l’appel à `mysql.rds_set_external_source_gtid_purged`. La `gtid_purged` valeur doit inclure tous ceux GTIDs qui ont été exécutés sur l'instance source et qui ne sont plus nécessaires pour la réplication. Cette valeur `gtid_purged` doit donc être un sous-ensemble de la valeur `gtid_executed` récupérée à l’étape précédente.
Pour déterminer la `gtid_purged` valeur, identifiez ceux GTIDs qui ne sont pas inclus dans la sauvegarde et qui ne sont plus nécessaires pour la réplication. Vous pouvez le faire en analysant les journaux binaires ou en utilisant un outil tel que mysqlbinlog pour trouver ceux GTIDs qui ont été purgés des journaux binaires.
Sinon, si vous disposez d’une sauvegarde cohérente qui inclut tous les journaux binaires jusqu’au point de sauvegarde, vous pouvez attribuer à la valeur `gtid_purged` la même valeur que la valeur `gtid_executed` à ce moment-là.
1. Après avoir déterminé la valeur `gtid_purged` appropriée cohérente avec votre sauvegarde, appelez la procédure `mysql.rds_set_external_source_gtid_purged` stockée sur votre instance de base de données RDS for MySQL pour définir la valeur.
### Exemples
Lorsqu’il est exécuté sur une instance de base de données MySQL, l’exemple suivant définit la plage GTID d’un serveur MySQL externe avec l’UUID `12345678-abcd-1234-efgh-123456789abc`, une position de départ de `1` et une position de fin de `100`. La valeur GTID résultante est définie sur `+12345678-abcd-1234-efgh-123456789abc:1-100`.
```
CALL mysql.rds_set_external_source_gtid_purged('12345678-abcd-1234-efgh-123456789abc', 1, 100);
```
##
Définit le mode de réplication en fonction des positions du fichier journal binaire ou des identificateurs de transaction globaux (GTIDs).
### Syntaxe
```
CALL mysql.rds_set_master_auto_position (
auto_position_mode
);
```
### Parameters
*auto\$1position\$1mode*
Valeur qui indique si la réplication à utiliser est la réplication basée sur la position de fichier ou la réplication basée sur les identifiants de transaction globaux :
+ `0` : utiliser la méthode de réplication basée sur la position du fichier journal binaire. La valeur par défaut est `0`.
+ `1` : utiliser la méthode de réplication basée sur les identifiants de transaction globaux.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_master_auto_position`.
Cette procédure est prise en charge pour toutes les versions de RDS for MySQL 5.7, et RDS for MySQL 8.0.26 et les versions 8.0 ultérieures.
## mysql.rds\$1set\$1source\$1auto\$1position (RDS for MySQL, versions majeures 8.4 et ultérieures)
Définit le mode de réplication en fonction des positions du fichier journal binaire ou des identificateurs de transaction globaux (GTIDs).
### Syntaxe
```
CALL mysql.rds_set_source_auto_position (auto_position_mode);
```
### Parameters
*auto\$1position\$1mode*
Valeur qui indique si la réplication à utiliser est la réplication basée sur la position de fichier ou la réplication basée sur les identifiants de transaction globaux :
+ `0` : utiliser la méthode de réplication basée sur la position du fichier journal binaire. La valeur par défaut est `0`.
+ `1` : utiliser la méthode de réplication basée sur les identifiants de transaction globaux.
### Notes d’utilisation
L’utilisateur administratif doit exécuter la procédure `mysql.rds_set_source_auto_position`.
## mysql.rds\$1set\$1source\$1delay
Définit le nombre minimum de secondes pour retarder la réplication de l’instance de base de données source vers le réplica en lecture actuel. Utilisez cette procédure lorsque vous êtes connecté à un réplica en lecture afin de retarder la réplication à partir de l’instance de base de données source.
### Syntaxe
```
CALL mysql.rds_set_source_delay(
delay
);
```
### Parameters
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_source_delay`.
Pour la reprise après sinistre, vous pouvez utiliser cette procédure avec la procédure stockée [](#mysql_rds_start_replication_until) ou [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre, vous pouvez exécuter la procédure `mysql.rds_set_source_delay`. Une fois que la procédure `mysql.rds_start_replication_until` ou `mysql.rds_start_replication_until_gtid` a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Pour utiliser la procédure `mysql.rds_rds_start_replication_until_gtid`, la réplication basée sur des identifiants de transaction globaux (GTID) doit être activée. Pour ignorer une transaction basée sur des identifiants de transaction globaux spécifique qui est réputée pour entraîner des défaillances, vous pouvez utiliser la procédure stockée [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Pour plus d’informations sur la réplication basée sur des identifiants de transaction globaux, consultez [Utilisation de la réplication basée sur des identifiants de transaction globaux (GTID)](mysql-replication-gtid.md).
La procédure `mysql.rds_set_source_delay` est disponible dans les versions de RDS for MySQL suivantes :
+ Toutes les versions RDS for MySQL 8.4
+ MySQL 8.0.26 et versions 8.0 ultérieures
+ Toutes les versions 5.7
### Exemples
Pour retarder la réplication à partir de l’instance de base de données source vers le réplica en lecture actuel pendant au moins un heure (3 600 secondes), vous pouvez appeler `mysql.rds_set_source_delay` avec le paramètre suivant :
```
CALL mysql.rds_set_source_delay(3600);
```
## mysql.rds\$1skip\$1repl\$1error
Ignore et supprime une erreur de réplication sur un réplica en lecture d’une base de données MySQL.
### Syntaxe
```
CALL mysql.rds_skip_repl_error;
```
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_skip_repl_error` sur un réplica en lecture. Pour plus d’informations sur cette procédure, consultez [Appel de la procédure mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
Pour déterminer s’il y a des erreurs, exécutez la commande MySQL `SHOW REPLICA STATUS\G`. Si une erreur de réplication n’est pas critique, vous pouvez exécuter `mysql.rds_skip_repl_error` pour ignorer l’erreur. S’il y a plusieurs erreurs, `mysql.rds_skip_repl_error` supprime la première erreur, puis avertit qu’il y a d’autres erreurs. Vous pouvez alors utiliser `SHOW REPLICA STATUS\G` pour déterminer l’action appropriée pour l’erreur suivante. Pour obtenir des informations sur les valeurs renvoyées, consultez [Instruction SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) dans la documentation sur MySQL.
Pour plus d’informations sur le traitement des erreurs de réplication avec Amazon RDS, consultez [Résolution d'un problème de réplica en lecture MySQL](USER_ReadRepl.Troubleshooting.md).
#### Erreur d’arrêt de réplication
Lorsque vous appelez la procédure `mysql.rds_skip_repl_error`, un message d’erreur peut s’afficher pour indiquer que le réplica a rencontré une erreur ou est désactivé.
Ce message d’erreur s’affiche si vous exécutez la procédure sur l’instance principale plutôt que sur le réplica en lecture. Vous devez exécuter cette procédure sur le réplica en lecture pour que la procédure fonctionne.
Ce message d’erreur peut également s’afficher si vous exécutez la procédure sur le réplica en lecture, mais que la réplication ne peut pas être redémarrée correctement.
Si vous avez besoin d’ignorer un grand nombre d’erreurs, le retard de réplication peut augmenter et dépasser la période de rétention par défaut pour les fichiers journaux binaires (binlog). Dans ce cas, vous pouvez rencontrer une erreur irrécupérable due à des fichiers journaux binaires purgés avant d’avoir été réutilisés sur le réplica en lecture. Cette purge entraîne l'arrêt de la réplication et vous ne pouvez plus appeler la commande `mysql.rds_skip_repl_error` pour ignorer les erreurs de réplication.
Vous pouvez atténuer ce problème en augmentant le nombre d’heures pendant lequel les fichiers journaux binaires sont conservés sur votre instance de base de données source. Une fois que vous avez augmenté le temps de rétention de journaux binaires, vous pouvez redémarrer la réplication et appeler la commande `mysql.rds_skip_repl_error` en fonction des besoins.
Pour définir la période de rétention des journaux binaires, utilisez la procédure [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) et spécifiez un paramètre de configuration `'binlog retention hours'`, ainsi que le nombre d’heures pendant lequel conserver les fichiers journaux binaires sur le cluster de bases de données. L’exemple suivant définit la période de rétention des fichiers journaux binaires à 48 heures.
```
CALL mysql.rds_set_configuration('binlog retention hours', 48);
```
## mysql.rds\$1start\$1replication
Lance la réplication à partir d’une instance de base de données RDS for MySQL.
**Note**
Vous pouvez utiliser la procédure stockée [](#mysql_rds_start_replication_until) ou [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) pour lancer la réplication à partir d’une instance de base de données RDS for MySQL et arrêter la réplication à la position spécifiée dans le fichier journal binaire.
### Syntaxe
```
CALL mysql.rds_start_replication;
```
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_start_replication`.
Pour importer des données à partir d’une instance de MySQL externe à Amazon RDS, appelez `mysql.rds_start_replication` sur le réplica en lecture pour démarrer le processus de réplication après avoir appelé [mysql.rds\$1set\$1external\$1master (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)](#mysql_rds_set_external_master)ou [mysql.rds\$1set\$1external\$1source (RDS for MySQL, versions majeures 8.4 et ultérieures)](#mysql_rds_set_external_source) pour créer la configuration de réplication. Pour plus d’informations, consultez [Restauration d’une sauvegarde dans une instance de base de données Amazon RDS for MySQL](MySQL.Procedural.Importing.md).
Pour exporter des données vers une instance de MySQL extérieure à Amazon RDS, appelez `mysql.rds_start_replication` et `mysql.rds_stop_replication` sur le réplica en lecture pour contrôler certaines actions de réplication, telles que la purge des journaux binaires. Pour plus d’informations, consultez [Exportation de données à partir d'une instance DB MySQL grâce à la réplication](MySQL.Procedural.Exporting.NonRDSRepl.md).
Vous pouvez aussi appeler `mysql.rds_start_replication` sur le réplica en lecture pour redémarrer un processus de réplication que vous avez précédemment arrêté en appelant `mysql.rds_stop_replication`. Pour de plus amples informations, veuillez consulter [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
##
Lance la réplication à partir d’une instance de base de données RDS for MySQL et arrête la réplication à la position spécifiée dans le fichier journal binaire.
### Syntaxe
```
CALL mysql.rds_start_replication_until (
replication_log_file
, replication_stop_point
);
```
### Parameters
*replication\$1log\$1file*
Nom du journal binaire sur l’instance de base de données source qui contient les informations de réplication.
*replication\$1stop\$1point *
Position dans le journal binaire `replication_log_file` à laquelle la réplication s’arrêtera.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_start_replication_until`.
La procédure `mysql.rds_start_replication_until` est disponible dans les versions de RDS for MySQL suivantes :
+ Toutes les versions RDS for MySQL 8.4
+ MySQL 8.0.26 et versions 8.0 ultérieures
+ Toutes les versions 5.7
Vous pouvez utiliser cette procédure avec la réplication retardée pour la reprise après sinistre. Si vous avez configuré la réplication retardée, vous pouvez utiliser cette procédure pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre. Une fois que cette procédure a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Vous pouvez configurer la réplication retardée en utilisant les procédures stockées suivantes :
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS for MySQL, versions majeures 8.4 et ultérieures)](#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](#mysql_rds_set_source_delay)
Le nom de fichier spécifié pour le paramètre `replication_log_file` doit correspondre au nom du fichier binlog de l’instance de base de données source.
Lorsque le paramètre `replication_stop_point` spécifie une position d’arrêt survenant dans le passé, la réplication est arrêtée immédiatement.
### Exemples
L’exemple suivant lance la réplication et réplique les modifications jusqu’à ce qu’il atteigne la position `120` dans le fichier journal binaire `mysql-bin-changelog.000777`.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
## mysql.rds\$1stop\$1replication
Arrête la réplication à partir d’une instance de base de données MySQL.
### Syntaxe
```
CALL mysql.rds_stop_replication;
```
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_stop_replication`.
Si vous configurez la réplication pour importer des données à partir d’une instance de MySQL s’exécutant à l’extérieur d’Amazon RDS, vous appelez `mysql.rds_stop_replication` sur le réplica en lecture pour arrêter le processus de réplication après que l’importation soit terminée. Pour plus d’informations, consultez [Restauration d’une sauvegarde dans une instance de base de données Amazon RDS for MySQL](MySQL.Procedural.Importing.md).
Si vous configurez la réplication pour exporter les données vers une instance de MySQL extérieure à Amazon RDS, vous appelez `mysql.rds_start_replication` et `mysql.rds_stop_replication` sur le réplica en lecture pour contrôler certaines actions de réplication, telles que la purge des journaux binaires. Pour plus d’informations, consultez [Exportation de données à partir d'une instance DB MySQL grâce à la réplication](MySQL.Procedural.Exporting.NonRDSRepl.md).
Vous pouvez aussi utiliser `mysql.rds_stop_replication` pour arrêter la réplication entre deux instances de base de données Amazon RDS. Vous arrêtez généralement la réplication pour exécuter une longue opération sur le réplica en lecture, comme la création d’un index volumineux sur le réplica en lecture. Vous pouvez redémarrer tout processus de réplication que vous avez arrêté en appelant [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sur le réplica en lecture. Pour plus d’informations, consultez [Utilisation des réplicas en lecture d'instance de base de données](USER_ReadRepl.md).
# Mettre fin à une session ou à une requête
Les procédures stockées suivantes mettent fin à une session ou à une requête.
**Topics**
+ [
## mysql.rds\$1kill
](#mysql_rds_kill)
+ [
## mysql.rds\$1kill\$1query
](#mysql_rds_kill_query)
## mysql.rds\$1kill
Termine une connexion au serveur MySQL.
### Syntaxe
```
CALL mysql.rds_kill(processID);
```
### Paramètres
*processID*
Identité du thread de connexion à terminer.
### Notes d'utilisation
Chaque connexion au serveur MySQL s'exécute dans un thread distinct. Pour terminer une connexion, utilisez la procédure `mysql.rds_kill` et transmettez-lui l'ID de thread de cette connexion. Pour obtenir l'ID de thread, utilisez la commande MySQL [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html).
Pour plus d'informations sur les limites, consultez [Limitations des procédures stockées MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Exemples
L'exemple suivant termine une connexion avec l'ID de thread 4243 :
```
CALL mysql.rds_kill(4243);
```
## mysql.rds\$1kill\$1query
Termine une requête s'exécutant sur le serveur MySQL.
### Syntaxe
```
CALL mysql.rds_kill_query(processID);
```
### Paramètres
*processID*
Identité du processus ou du thread qui exécute la requête à terminer.
### Notes d’utilisation
Pour arrêter une requête en cours d'exécution sur le serveur MySQL, utilisez la procédure `mysql_rds_kill_query` et transmettez l'ID de connexion du thread qui exécute la requête. La procédure met alors fin à la connexion.
Pour obtenir l'ID, interrogez la table MySQL [INFORMATION\$1SCHEMA PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/information-schema-processlist-table.html) ou utilisez la commande MySQL [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html). La valeur figurant dans la colonne ID de `SHOW PROCESSLIST` ou `SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST` est le *processID*.
Pour plus d'informations sur les limites, consultez [Limitations des procédures stockées MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Exemples
L'exemple suivant arrête une requête dont l'ID de thread de requête est 230040 :
```
CALL mysql.rds_kill_query(230040);
```
# Gestion des clusters actifs-actifs
Les procédures stockées suivantes permettent de configurer et de gérer les clusters actifs-actifs RDS for MySQL. Pour plus d’informations, consultez [Configuration de clusters actifs-actifs pour RDS for MySQL](mysql-active-active-clusters.md).
Ces procédures stockées ne sont disponibles qu’avec les instances de base de données RDS for MySQL exécutant les versions suivantes :
+ Toutes les versions 8.4 de MySQL
+ MySQL 8.0.35 et versions mineures ultérieures
**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
Crée des GTID d’espace réservé sur l’instance de base de données actuelle.
### Syntaxe
```
CALL mysql.rds_group_replication_advance_gtid(
begin_id
, end_id
, server_uuid
);
```
### Paramètres
*begin\$1id*
L’ID de transaction de départ à créer.
*end\$1id*
L’ID de transaction de fin à créer.
*begin\$1id*
Le `group_replication_group_name` de transaction à créer. Le `group_replication_group_name` est spécifié sous forme d’UUID dans le groupe de paramètres de base de données associé à l’instance de base de données.
### Notes d’utilisation
Dans un cluster actif-actif, pour qu’une instance de base de données rejoigne un groupe, toutes les transactions GTID exécutées sur la nouvelle instance de base de données doivent exister sur les autres membres du cluster. Dans des cas inhabituels, une nouvelle instance de base de données peut contenir davantage de transactions lorsque les transactions sont exécutées avant de joindre l’instance au groupe. Dans ce cas, vous ne pouvez supprimer aucune transaction existante, mais vous pouvez utiliser cette procédure pour créer les GTID d’espace réservé correspondants sur les autres instances de base de données du groupe. Avant cela, vérifiez que les transactions *n’affectent pas les données répliquées*.
Lorsque vous appelez cette procédure, les transactions GTID de `server_uuid:begin_id-end_id` sont créées avec un contenu vide. Pour éviter les problèmes de réplication, n’utilisez pas cette procédure dans d’autres conditions.
**Important**
Évitez d’appeler cette procédure lorsque le cluster actif-actif fonctionne normalement. N’appelez cette procédure que si vous comprenez les conséquences possibles des transactions que vous créez. L’appel de cette procédure peut entraîner des données incohérentes.
### exemple
L’exemple suivant crée des GTID d’espace réservé sur l’instance de base de données actuelle :
```
CALL mysql.rds_group_replication_advance_gtid(5, 6, '11111111-2222-3333-4444-555555555555');
```
## mysql.rds\$1group\$1replication\$1create\$1user
Crée l’utilisateur de réplication `rdsgrprepladmin` pour la réplication de groupe sur l’instance de base de données.
### Syntaxe
```
CALL mysql.rds_group_replication_create_user(
replication_user_password
);
```
### Paramètres
*replication\$1user\$1password*
Mot de passe de l’utilisateur de réplication `rdsgrprepladmin`.
### Notes d’utilisation
+ Le mot de passe de l’utilisateur de réplication `rdsgrprepladmin` doit être le même sur toutes les instances de base de données d’un cluster actif-actif.
+ Le nom d’utilisateur `rdsgrprepladmin` est réservé aux connexions de réplication de groupe. Aucun autre utilisateur, y compris l’utilisateur principal, ne peut avoir ce nom d’utilisateur.
### exemple
L’exemple suivant crée l’utilisateur de réplication `rdsgrprepladmin` pour la réplication de groupe sur l’instance de base de données :
```
CALL mysql.rds_group_replication_create_user('password');
```
## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
Définit le canal `group_replication_recovery` d’un cluster actif-actif. La procédure utilise l’utilisateur réservé `rdsgrprepladmin` pour configurer le canal.
### Syntaxe
```
CALL mysql.rds_group_replication_set_recovery_channel(
replication_user_password);
```
### Paramètres
*replication\$1user\$1password*
Mot de passe de l’utilisateur de réplication `rdsgrprepladmin`.
### Notes d’utilisation
Le mot de passe de l’utilisateur de réplication `rdsgrprepladmin` doit être le même sur toutes les instances de base de données d’un cluster actif-actif. Un appel au `mysql.rds_group_replication_create_user` permet de spécifier le mot de passe.
### exemple
L’exemple suivant définit le canal `group_replication_recovery` d’un cluster actif-actif.
```
CALL mysql.rds_group_replication_set_recovery_channel('password');
```
## mysql.rds\$1group\$1replication\$1start
Démarre la réplication de groupe sur l’instance de base de données actuelle.
### Syntaxe
```
CALL mysql.rds_group_replication_start(
bootstrap
);
```
### Paramètres
*bootstrap*
Valeur qui indique s’il faut initialiser un nouveau groupe ou rejoindre un groupe existant. `1` initialise un nouveau groupe avec l’instance de base de données actuelle. `0` associe l’instance de base de données actuelle à un groupe existant en se connectant aux points de terminaison définis dans le paramètre `group_replication_group_seeds` du groupe de paramètres de base de données associé à l’instance de base de données.
### exemple
L’exemple suivant initialise un nouveau groupe avec l’instance de base de données actuelle :
```
CALL mysql.rds_group_replication_start(1);
```
## mysql.rds\$1group\$1replication\$1stop
Arrête la réplication de groupe sur l’instance de base de données actuelle.
### Syntaxe
```
CALL mysql.rds_group_replication_stop();
```
### Notes d’utilisation
Lorsque vous arrêtez la réplication sur une instance de base de données, cela n’affecte aucune autre instance de base de données du cluster actif-actif.
# Gestion de la réplication multisource
Les procédures stockées suivantes permettent de configurer et de gérer les canaux de réplication sur un réplica multisource RDS for MySQL. Pour plus d’informations, consultez [Configuration multi-source-replication pour Amazon RDS for MySQL](mysql-multi-source-replication.md).
Ces procédures stockées ne sont disponibles qu’avec les instances de base de données RDS for MySQL exécutant les versions de moteur suivantes :
+ Toutes les versions 8.4
+ 8.0.35 et versions mineures ultérieures
+ 5.7.44 et versions mineures ultérieures
Lorsque vous utilisez des procédures stockées pour gérer la réplication avec un utilisateur de réplication configuré avec `caching_sha2_passwword`, vous devez configurer le protocole TLS en spécifiant `SOURCE_SSL=1`. `caching_sha2_password` est le plugin d’authentification par défaut pour RDS for MySQL 8.4.
**Note**
Bien que cette documentation désigne les instances de base de données source sous le nom d’instances de base de données RDS for MySQL, ces procédures fonctionnent également pour les instances MySQL exécutées en dehors d’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
Modifie la position du journal de l’instance de base de données source au début du journal binaire suivant sur l’instance de base de données source du canal. N’utilisez cette procédure que si vous recevez une erreur 1236 d’E/S de réplication sur un réplica multisource.
### Syntaxe
```
CALL mysql.rds_next_source_log_for_channel(
curr_master_log,
channel_name
);
```
### Paramètres
*curr\$1master\$1log*
Index du fichier journal source actuel. Par exemple, si le fichier en cours se nomme `mysql-bin-changelog.012345`, l’index est 12345. Pour déterminer le nom du fichier journal actuel, exécutez la commande `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'` et affichez le champ `Source_Log_File`.
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_next_source_log_for_channel`. En cas d’erreur IO\$1Thread, par exemple, vous pouvez utiliser cette procédure pour ignorer tous les événements du fichier journal binaire actuel et reprendre la réplication à partir du fichier journal binaire suivant pour le canal spécifié dans `channel_name`.
### exemple
Supposons que la réplication échoue sur un canal d’un réplica multisource. L’exécution de `SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G` sur le réplica multisource renvoie le résultat suivant :
```
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
```
Le champ `Last_IO_Errno` montre que l’instance reçoit une erreur 1236 d’I/O. Le champ `Source_Log_File` montre que le nom du fichier est `mysql-bin-changelog.012345`, ce qui signifie que l’index du fichier journal est `12345`. Pour résoudre l’erreur, vous pouvez appeler `mysql.rds_next_source_log_for_channel` avec les paramètres suivants :
```
CALL mysql.rds_next_source_log_for_channel(12345,'channel_1');
```
## mysql.rds\$1reset\$1external\$1source\$1for\$1channel
Arrête le processus de réplication sur le canal spécifié et supprime le canal et les configurations associées du réplica multisource.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l'activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
CALL mysql.rds_reset_external_source_for_channel (channel_name);
```
### Paramètres
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_reset_external_source_for_channel`. Cette procédure supprime tous les journaux de relais appartenant au canal à supprimer.
## mysql.rds\$1set\$1external\$1source\$1for\$1channel
Configure un canal de réplication sur une instance de base de données RDS for MySQL afin de répliquer les données d’une autre instance de base de données RDS for MySQL.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l'activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
**Note**
Vous pouvez plutôt utiliser la procédure stockée [mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel](#mysql_rds_set_external_source_with_delay_for_channel) pour configurer ce canal avec une réplication différée.
### Syntaxe
```
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
);
```
### Paramètres
*host\$1name*
Nom d’hôte ou adresse IP de l’instance de base de données source RDS for MySQL.
*host\$1port*
Port utilisé par l’instance de base de données source RDS for MySQL. Si votre configuration réseau inclut une réplication de port Secure Shell (SSH) qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance de base de données source RDS for MySQL. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance de base de données source.
*replication\$1user\$1password*
Mot de passe de l'ID utilisateur spécifié dans `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nom du journal binaire sur l’instance de base de données source qui contient les informations de réplication.
*mysql\$1binary\$1log\$1file\$1location*
Emplacement dans le journal binaire `mysql_binary_log_file_name` à partir duquel la réplication commence à lire les informations de réplication.
Vous pouvez déterminer le nom et l’emplacement du fichier journal binaire en exécutant `SHOW BINARY LOG STATUS` sur l’instance de base de données source.
Les versions précédentes de MySQL utilisaient `SHOW MASTER STATUS` à la place de `SHOW BINARY LOG STATUS`. Si vous utilisez une version MySQL antérieure à la version 8.4, utilisez alors `SHOW MASTER STATUS`.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d'utiliser le chiffrement SSL, et la valeur 0 de ne pas l'utiliser. La valeur par défaut est 0.
L'option `SOURCE_SSL_VERIFY_SERVER_CERT` n'est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
*channel\$1name*
Nom du canal de réplication. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_external_source_for_channel`. Cette procédure doit être exécutée sur l’instance de base de données RDS for MySQL cible sur laquelle vous créez le canal de réplication.
Avant d’exécuter `mysql.rds_set_external_source_for_channel`, configurez un utilisateur de réplication sur l’instance de base de données source avec les privilèges requis pour le réplica multisource. Pour connecter le réplica multisource à l’instance de base de données source, vous devez spécifier les valeurs `replication_user_name` et `replication_user_password` d’un utilisateur de réplication disposant d’autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance de base de données source.
**Pour configurer un utilisateur de réplication sur l’instance de base de données source**
1. À l’aide du client MySQL de votre choix, connectez-vous à l’instance de base de données source et créez un compte utilisateur à utiliser pour la réplication. Voici un exemple de.
**Important**
En tant que bonne pratique de sécurité, spécifiez un mot de passe autre que la valeur d’espace réservé indiquée dans les exemples suivants.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Sur l’instance de base de données source, attribuez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur « repl\$1user » de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Pour utiliser la réplication chiffrée, configurez l’instance de base de données source de façon à utiliser les connexions SSL.
Après avoir appelé `mysql.rds_set_external_source_for_channel` pour configurer ce canal de réplication, vous pouvez appeler [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) sur le réplica pour démarrer le processus de réplication sur le canal. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) pour arrêter la réplication sur le canal et supprimer la configuration du canal du réplica.
Lorsque vous appelez `mysql.rds_set_external_source_for_channel`, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set channel source` dans la table `mysql.rds_history` sans informations spécifiques au canal, et dans la table `mysql.rds_replication_status` avec le nom du canal. Ces informations sont enregistrées uniquement à des fins d’utilisation interne et de surveillance. Pour enregistrer l’appel de procédure complet à des fins d’audit, pensez à activer les journaux d’audit ou généraux, en fonction des exigences spécifiques de votre application.
### Exemples
Lorsqu’il est exécuté sur une instance de base de données RDS for MySQL, l’exemple suivant configure un canal de réplication nommé `channel_1` sur cette instance de base de données, pour répliquer les données à partir de la source spécifiée par l’hôte `sourcedb.example.com` et le port `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
Configure un canal de réplication sur une instance de base de données RDS for MySQL avec un délai de réplication facultatif. La réplication est basée sur des identifiants de transaction globaux (GTID).
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l'activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
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
);
```
### Paramètres
*host\$1name*
Nom d’hôte ou adresse IP de l’instance de base de données source RDS for MySQL.
*host\$1port*
Port utilisé par l’instance de base de données source RDS for MySQL. Si votre configuration réseau inclut une réplication de port Secure Shell (SSH) qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance de base de données source RDS for MySQL. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance de base de données source.
*replication\$1user\$1password*
Mot de passe de l'ID utilisateur spécifié dans `replication_user_name`.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d'utiliser le chiffrement SSL, et la valeur 0 de ne pas l'utiliser. La valeur par défaut est 0.
L'option `SOURCE_SSL_VERIFY_SERVER_CERT` n'est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
*channel\$1name*
Nom du canal de réplication. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_external_source_with_auto_position_for_channel`. Cette procédure doit être exécutée sur l’instance de base de données RDS for MySQL cible sur laquelle vous créez le canal de réplication.
Avant d’exécuter `rds_set_external_source_with_auto_position_for_channel`, configurez un utilisateur de réplication sur l’instance de base de données source avec les privilèges requis pour le réplica multisource. Pour connecter le réplica multisource à l’instance de base de données source, vous devez spécifier les valeurs `replication_user_name` et `replication_user_password` d’un utilisateur de réplication disposant d’autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance de base de données source.
**Pour configurer un utilisateur de réplication sur l’instance de base de données source**
1. À l’aide du client MySQL de votre choix, connectez-vous à l’instance de base de données source et créez un compte utilisateur à utiliser pour la réplication. Voici un exemple de.
**Important**
En tant que bonne pratique de sécurité, spécifiez un mot de passe autre que la valeur d’espace réservé indiquée dans les exemples suivants.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Sur l’instance de base de données source, attribuez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur « repl\$1user » de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Pour utiliser la réplication chiffrée, configurez l’instance de base de données source de façon à utiliser les connexions SSL.
Avant d’appeler `mysql.rds_set_external_source_with_auto_position_for_channel`, assurez-vous d’appeler [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_gtid_purged) pour définir la variable système `gtid_purged` avec une plage GTID spécifiée à partir d’une source externe.
Après avoir appelé `mysql.rds_set_external_source_with_auto_position_for_channel` pour configurer une instance de base de données Amazon RDS comme réplica en lecture sur un canal spécifique, vous pouvez appeler [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) sur le réplica en lecture pour démarrer le processus de réplication sur ce canal.
Après avoir appelé `mysql.rds_set_external_source_with_auto_position_for_channel` pour configurer ce canal de réplication, vous pouvez appeler [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) sur le réplica pour démarrer le processus de réplication sur le canal. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) pour arrêter la réplication sur le canal et supprimer la configuration du canal du réplica.
### Exemples
Lorsqu’il est exécuté sur une instance de base de données RDS for MySQL, l’exemple suivant configure un canal de réplication nommé `channel_1` sur cette instance de base de données, pour répliquer les données à partir de la source spécifiée par l’hôte `sourcedb.example.com` et le port `3306`. Il définit le délai de réplication minimum sur une heure (3 600 secondes). Cela signifie qu’une modification provenant de l’instance de base de données source RDS for MySQL n’est pas appliquée sur le réplica multisource pendant au moins une heure.
```
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
Configure un canal de réplication sur une instance de base de données RDS for MySQL avec un délai de réplication spécifié.
**Important**
Pour exécuter cette procédure, `autocommit` doit être activé. Pour l'activer, définissez le paramètre `autocommit` sur `1`. Pour plus d’informations sur la modification des paramètres d’instance, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntaxe
```
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
);
```
### Paramètres
*host\$1name*
Nom d’hôte ou adresse IP de l’instance de base de données source RDS for MySQL.
*host\$1port*
Port utilisé par l’instance de base de données source RDS for MySQL. Si votre configuration réseau inclut une réplication de port Secure Shell (SSH) qui convertit le numéro de port, spécifiez le numéro de port qui est exposé par SSH.
*replication\$1user\$1name*
ID d’un utilisateur disposant des autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance de base de données source RDS for MySQL. Nous vous recommandons de fournir un compte qui soit utilisé uniquement pour la réplication avec l’instance de base de données source.
*replication\$1user\$1password*
Mot de passe de l'ID utilisateur spécifié dans `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nom du journal binaire sur l’instance de base de données source contient les informations de réplication.
*mysql\$1binary\$1log\$1file\$1location*
Emplacement dans le journal binaire `mysql_binary_log_file_name` à partir duquel la réplication commence à lire les informations de réplication.
Vous pouvez déterminer le nom et l’emplacement du fichier journal binaire en exécutant `SHOW BINARY LOG STATUS` sur l’instance de base de données source.
Les versions précédentes de MySQL utilisaient `SHOW MASTER STATUS` à la place de `SHOW BINARY LOG STATUS`. Si vous utilisez une version MySQL antérieure à la version 8.4, utilisez alors `SHOW MASTER STATUS`.
*ssl\$1encryption*
Valeur indiquant si le chiffrement Secure Socket Layer (SSL) est utilisé sur la connexion de réplication. La valeur 1 spécifie d'utiliser le chiffrement SSL, et la valeur 0 de ne pas l'utiliser. La valeur par défaut est 0.
L'option `SOURCE_SSL_VERIFY_SERVER_CERT` n'est pas prise en charge. Cette option est définie sur 0, ce qui signifie que la connexion est chiffrée, mais que les certificats ne sont pas vérifiés.
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
*channel\$1name*
Nom du canal de réplication. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_external_source_with_delay_for_channel`. Cette procédure doit être exécutée sur l’instance de base de données RDS for MySQL cible sur laquelle vous créez le canal de réplication.
Avant d’exécuter `mysql.rds_set_external_source_with_delay_for_channel`, configurez un utilisateur de réplication sur l’instance de base de données source avec les privilèges requis pour le réplica multisource. Pour connecter le réplica multisource à l’instance de base de données source, vous devez spécifier les valeurs `replication_user_name` et `replication_user_password` d’un utilisateur de réplication disposant d’autorisations `REPLICATION CLIENT` et `REPLICATION SLAVE` sur l’instance de base de données source.
**Pour configurer un utilisateur de réplication sur l’instance de base de données source**
1. À l’aide du client MySQL de votre choix, connectez-vous à l’instance de base de données source et créez un compte utilisateur à utiliser pour la réplication. Voici un exemple de.
**Important**
En tant que bonne pratique de sécurité, spécifiez un mot de passe autre que la valeur d’espace réservé indiquée dans les exemples suivants.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Sur l’instance de base de données source, attribuez les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` à votre utilisateur de réplication. L’exemple suivant accorde les privilèges `REPLICATION CLIENT` et `REPLICATION SLAVE` sur toutes les bases de données pour l’utilisateur « repl\$1user » de votre domaine.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Pour utiliser la réplication chiffrée, configurez l’instance de base de données source de façon à utiliser les connexions SSL.
Après avoir appelé `mysql.rds_set_external_source_with_delay_for_channel` pour configurer ce canal de réplication, vous pouvez appeler [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) sur le réplica pour démarrer le processus de réplication sur le canal. Vous pouvez appeler [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) pour arrêter la réplication sur le canal et supprimer la configuration du canal du réplica.
Lorsque vous appelez `mysql.rds_set_external_source_with_delay_for_channel`, Amazon RDS enregistre l’heure, l’utilisateur et une action de `set channel source` dans la table `mysql.rds_history` sans informations spécifiques au canal, et dans la table `mysql.rds_replication_status` avec le nom du canal. Ces informations sont enregistrées uniquement à des fins d’utilisation interne et de surveillance. Pour enregistrer l’appel de procédure complet à des fins d’audit, pensez à activer les journaux d’audit ou généraux, en fonction des exigences spécifiques de votre application.
### Exemples
Lorsqu’il est exécuté sur une instance de base de données RDS for MySQL, l’exemple suivant configure un canal de réplication nommé `channel_1` sur cette instance de base de données, pour répliquer les données à partir de la source spécifiée par l’hôte `sourcedb.example.com` et le port `3306`. Il définit le délai de réplication minimum sur une heure (3 600 secondes). Cela signifie qu’une modification provenant de l’instance de base de données source RDS for MySQL n’est pas appliquée sur le réplica multisource pendant au moins une heure.
```
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
Définit le mode de réplication pour le canal spécifié de manière à ce qu’il soit basé sur des positions de fichier journal binaire ou sur des identifiants de transaction globaux (GTID).
### Syntaxe
```
CALL mysql.rds_set_source_auto_position_for_channel (
auto_position_mode
, channel_name
);
```
### Paramètres
*auto\$1position\$1mode*
Valeur qui indique si la réplication à utiliser est la réplication basée sur la position de fichier ou la réplication basée sur les identifiants de transaction globaux :
+ `0` – Utiliser la méthode de réplication basée sur la position du fichier journal binaire. La valeur par défaut est `0`.
+ `1` – Utiliser la méthode de réplication basée sur les identifiants de transaction globaux.
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_source_auto_position_for_channel`. Cette procédure redémarre la réplication sur le canal spécifié pour appliquer le mode de positionnement automatique spécifié.
### Exemples
L’exemple suivant définit le mode de positionnement automatique pour channel\$11 afin d’utiliser la méthode de réplication basée sur le GTID.
```
call mysql.rds_set_source_auto_position_for_channel(1,'channel_1');
```
## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
Définit le nombre minimum de secondes pour retarder la réplication de l’instance de base de données source vers le réplica multisource pour le canal spécifié.
### Syntaxe
```
CALL mysql.rds_set_source_delay_for_channel(delay, channel_name);
```
### Paramètres
*delay*
Nombre minimum de secondes pour retarder la réplication à partir de l’instance de base de données source.
La limite de ce paramètre est une journée (soit 86 400 secondes).
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_set_source_delay_for_channel`. Pour utiliser cette procédure, appelez d’abord `mysql.rds_stop_replication_for_channel` pour arrêter la réplication. Appelez ensuite cette procédure pour définir la valeur du délai de réplication. Lorsque le délai est défini, appelez `mysql.rds_start_replication_for_channel` pour redémarrer la réplication.
### Exemples
L’exemple suivant définit le délai de réplication à partir de l’instance de base de données source sur le `channel_1` du réplica multisource pendant au moins un heure (3 600 secondes).
```
CALL mysql.rds_set_source_delay_for_channel(3600,'channel_1');
```
## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
Ignore un événement du journal binaire et supprime une erreur de réplication sur un réplica multisource de base de données MySQL pour le canal spécifié.
### Syntaxe
```
CALL mysql.rds_skip_repl_error_for_channel(channel_name);
```
### Paramètres
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_skip_repl_error_for_channel` sur un réplica en lecture. Vous pouvez utiliser cette procédure de la même manière que `mysql.rds_skip_repl_error` pour ignorer une erreur sur un réplica en lecture. Pour plus d’informations, consultez [Appel de la procédure mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
**Note**
Pour ignorer les erreurs lors de la réplication basée sur le GTID, nous vous recommandons plutôt d’utiliser la procédure [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid).
Pour déterminer s’il y a des erreurs, exécutez la commande MySQL `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G`. Si une erreur de réplication n’est pas critique, vous pouvez exécuter `mysql.rds_skip_repl_error_for_channel` pour ignorer l’erreur. S’il y a plusieurs erreurs, `mysql.rds_skip_repl_error_for_channel` supprime la première sur le canal de réplication spécifié, puis avertit qu’il y a d’autres erreurs. Vous pouvez alors utiliser `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` pour déterminer l’action appropriée pour l’erreur suivante. Pour obtenir des informations sur les valeurs renvoyées, consultez [Instruction SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) dans la documentation sur MySQL.
## mysql.rds\$1start\$1replication\$1for\$1channel
Lance la réplication à partir d’une instance de bases de données RDS for MySQL vers un réplica multisource sur le canal spécifié.
**Note**
Vous pouvez utiliser la procédure stockée [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) pour lancer la réplication à partir d'une instance de bases de données RDS for MySQL et arrêter la réplication à la position spécifiée dans le fichier journal binaire.
### Syntaxe
```
CALL mysql.rds_start_replication_for_channel(channel_name);
```
### Paramètres
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_start_replication_for_channel`. Après avoir importé les données à partir de l’instance de base de données source RDS for MySQL, exécutez cette commande sur le réplica multisource pour démarrer la réplication sur le canal spécifié.
### Exemples
L’exemple suivant démarre la réplication sur le `channel_1` du réplica multisource.
```
CALL mysql.rds_start_replication_for_channel('channel_1');
```
## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
Lance la réplication à partir d’une instance de bases de données RDS for MySQL sur le canal spécifié et arrête la réplication à la position spécifiée dans le fichier journal binaire.
### Syntaxe
```
CALL mysql.rds_start_replication_until_for_channel (
replication_log_file
, replication_stop_point
, channel_name
);
```
### Paramètres
*replication\$1log\$1file*
Nom du journal binaire sur l’instance de base de données source contient les informations de réplication.
*replication\$1stop\$1point *
Position dans le journal binaire `replication_log_file` à laquelle la réplication s’arrêtera.
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_start_replication_until_for_channel`. Avec cette procédure, la réplication démarre, puis s’arrête lorsque la position spécifiée du fichier binlog est atteinte. Cette procédure arrête à la fois `SQL_THREAD` et `IO_THREAD`.
Le nom de fichier spécifié pour le paramètre `replication_log_file` doit correspondre au nom du fichier binlog de l’instance de base de données source.
Lorsque le paramètre `replication_stop_point` spécifie une position d’arrêt survenant dans le passé, la réplication est arrêtée immédiatement.
### Exemples
L’exemple suivant lance la réplication sur `channel_1` et réplique les modifications jusqu’à ce qu’il atteigne la position `120` dans le fichier journal binaire `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
Lance la réplication sur le canal spécifié à partir d’une instance de bases de données RDS for MySQL et arrête la réplication à la position de l’identifiant de transaction global spécifié (GTID).
### Syntaxe
```
CALL mysql.rds_start_replication_until_gtid_for_channel(gtid,channel_name);
```
### Paramètres
*gtid*
Identifiant de transaction global (GTID) après lequel la réplication s’arrête.
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_start_replication_until_gtid_for_channel`. La procédure démarre la réplication sur le canal spécifié et applique toutes les modifications jusqu’à la valeur GTID spécifiée. Ensuite, elle arrête la réplication sur le canal.
Lorsque le paramètre `gtid` spécifie une transaction ayant déjà été exécutée par le réplica, la réplication est immédiatement arrêtée.
Avant d’exécuter cette procédure, vous devez désactiver la réplication multithread en définissant la valeur de `replica_parallel_workers` ou `slave_parallel_workers` sur `0`.
### Exemples
L’exemple suivant lance la réplication sur `channel_1` et réplique les modifications jusqu’à ce que le GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23` soit atteint.
```
call mysql.rds_start_replication_until_gtid_for_channel('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','channel_1');
```
## mysql.rds\$1stop\$1replication\$1for\$1channel
Arrête la réplication à partir d’une instance de base de données MySQL sur le canal spécifié.
### Syntaxe
```
CALL mysql.rds_stop_replication_for_channel(channel_name);
```
### Paramètres
*channel\$1name*
Nom du canal de réplication sur le réplica multisource. Chaque canal de réplication reçoit les événements du journal binaire d’une instance de base de données RDS for MySQL à source unique exécutée sur un hôte et un port spécifiques.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_stop_replication_for_channel`.
### Exemples
L’exemple suivant arrête la réplication sur le `channel_1` du réplica multisource.
```
CALL mysql.rds_stop_replication_for_channel('channel_1');
```
# Répliquer des transactions à l'aide de GTIDs
Les procédures stockées suivantes contrôlent la façon dont les transactions sont répliquées à l'aide des identificateurs de transaction globaux (GTIDs) avec RDS pour MySQL. Pour plus d'informations sur la réplication basée sur GTIDs RDS pour MySQL, consultez[Utilisation de la réplication basée sur des identifiants de transaction globaux (GTID)](mysql-replication-gtid.md).
Lorsque vous utilisez des procédures stockées pour gérer la réplication avec un utilisateur de réplication configuré avec `caching_sha2_password`, vous devez configurer le protocole TLS en spécifiant `SOURCE_SSL=1`. `caching_sha2_password` est le plugin d’authentification par défaut pour RDS for MySQL 8.4.
**Topics**
+ [
##
](#mysql_rds_skip_transaction_with_gtid)
+ [
##
](#mysql_rds_start_replication_until_gtid)
##
Ignore la réplication d’une transaction avec l’identifiant de transaction global (GTID) spécifié sur une instance de base de données MySQL.
Vous pouvez utiliser cette procédure pour la reprise après sinistre lorsqu’il est avéré qu’une transaction GTID entraîne des problèmes. Utilisez cette procédure stockée pour ignorer la transaction problématique. Les transactions problématiques sont par exemple celles qui désactivent la réplication, suppriment des données importantes ou entraînent l’indisponibilité de l’instance de base de données.
### Syntaxe
```
CALL mysql.rds_skip_transaction_with_gtid (
gtid_to_skip
);
```
### Parameters
*gtid\$1to\$1skip*
GTID de la transaction de réplication à ignorer.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_skip_transaction_with_gtid`.
Cette procédure est prise en charge pour toutes les versions de RDS for MySQL 5.7, toutes les version de RDS for MySQL 8.0 et toutes les versions de RDS for MySQL 8.4.
### Exemples
L’exemple suivant ignore la réplication de la transaction avec le GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
CALL mysql.rds_skip_transaction_with_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
##
Lance la réplication à partir d’une instance de base de données RDS for MySQL et arrête la réplication immédiatement après l’identifiant de transaction global (GTID) spécifié.
### Syntaxe
```
CALL mysql.rds_start_replication_until_gtid(gtid);
```
### Parameters
*gtid*
Identifiant de transaction global (GTID) après lequel la réplication s’arrête.
### Notes d’utilisation
L’utilisateur principal doit exécuter la procédure `mysql.rds_start_replication_until_gtid`.
Cette procédure est prise en charge pour toutes les versions de RDS for MySQL 5.7, toutes les version de RDS for MySQL 8.0 et toutes les versions de RDS for MySQL 8.4.
Vous pouvez utiliser cette procédure avec la réplication retardée pour la reprise après sinistre. Si vous avez configuré la réplication retardée, vous pouvez utiliser cette procédure pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre. Une fois que cette procédure a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Vous pouvez configurer la réplication retardée en utilisant les procédures stockées suivantes :
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS for MariaDB et RDS for MySQL, versions majeures 8.0 et antérieures)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS for MySQL, versions majeures 8.4 et ultérieures)](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)
Lorsque le paramètre `gtid` spécifie une transaction ayant déjà été exécutée par le réplica, la réplication est immédiatement arrêtée.
### Exemples
L’exemple suivant lance la réplication et réplique les modifications jusqu’à ce que le GTID soit atteint `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
call mysql.rds_start_replication_until_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
# Rotation des journaux de requêtes
Les procédures stockées suivantes effectuent la rotation des journaux MySQL vers des tables de sauvegarde. Pour plus d’informations, consultez [Fichiers journaux de base de données 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
Convertit la table `mysql.general_log` en table de sauvegarde.
### Syntaxe
```
CALL mysql.rds_rotate_general_log;
```
### Notes d'utilisation
Vous pouvez convertir la table `mysql.general_log` en table de sauvegarde en appelant la procédure `mysql.rds_rotate_general_log`. Lors de la rotation des tables de journaux, la table de journal actuelle est copiée vers une table de journal de sauvegarde et les entrées de la table de journal actuelle sont supprimées. Si la table du journal de sauvegarde existe déjà, elle est supprimée avant que la table du journal active ne soit copiée dans la sauvegarde. Si besoin, vous pouvez interroger la table de journal de sauvegarde. La table de journal de sauvegarde de la table `mysql.general_log` est nommée `mysql.general_log_backup`.
Vous ne pouvez exécuter cette procédure que lorsque le paramètre `log_output` est défini sur `TABLE`.
## mysql.rds\$1rotate\$1slow\$1log
Convertit la table `mysql.slow_log` en table de sauvegarde.
### Syntaxe
```
CALL mysql.rds_rotate_slow_log;
```
### Notes d'utilisation
Vous pouvez convertir la table `mysql.slow_log` en table de sauvegarde en appelant la procédure `mysql.rds_rotate_slow_log`. Lors de la rotation des tables de journaux, la table de journal actuelle est copiée vers une table de journal de sauvegarde et les entrées de la table de journal actuelle sont supprimées. Si la table du journal de sauvegarde existe déjà, elle est supprimée avant que la table du journal active ne soit copiée dans la sauvegarde.
Si besoin, vous pouvez interroger la table de journal de sauvegarde. La table de journal de sauvegarde de la table `mysql.slow_log` est nommée `mysql.slow_log_backup`.
# Configuration et affichage de la configuration du journal binaire
Les procédures stockées suivantes définissent et affichent les paramètres de configuration, tels que la conservation des fichiers journaux binaires.
**Topics**
+ [
## mysql.rds\$1set\$1configuration
](#mysql_rds_set_configuration)
+ [
## mysql.rds\$1show\$1configuration
](#mysql_rds_show_configuration)
## mysql.rds\$1set\$1configuration
Spécifie le nombre d’heures pendant lequel les journaux binaires doivent être conservés ou le nombre de secondes pendant lequel retarder la réplication.
### Syntaxe
```
CALL mysql.rds_set_configuration(name,value);
```
### Parameters
*name*
Nom du paramètre de configuration à définir.
*value*
Valeur du paramètre de configuration.
### Notes d’utilisation
La procédure `mysql.rds_set_configuration` prend en charge des paramètres de configuration suivants :
+ [nombre d’heures de conservation du journal binaire](#mysql_rds_set_configuration-usage-notes.binlog-retention-hours)
+ [retard à la source](#mysql_rds_set_configuration-usage-notes.source-delay)
+ [target delay](#mysql_rds_set_configuration-usage-notes.target-delay)
Les paramètres de configuration sont stockés de manière permanente et survivent à tout redémarrage ou basculement d’une instance de base de données.
#### nombre d’heures de conservation du journal binaire
Le paramètre `binlog retention hours` est utilisé pour spécifier le nombre d’heures de rétention des fichiers journaux binaires. Amazon RDS purge normalement un journal binaire dès que possible, mais il se peut que le journal binaire soit encore requis pour la réplication avec une base de données MySQL extérieure à RDS.
La valeur par défaut de `binlog retention hours` est `NULL`. Pour RDS pour MySQL, `NULL` signifie que les journaux binaires ne sont pas conservés (0 heure).
Pour spécifier le nombre d’heures pendant lesquelles conserver les journaux binaires sur une instance, utilisez la procédure stockée `mysql.rds_set_configuration` et spécifiez une période suffisamment longue pour que la réplication se produise, comme illustré dans l’exemple suivant.
`call mysql.rds_set_configuration('binlog retention hours', 24);`
**Note**
Vous ne pouvez pas utiliser la valeur `0` pour `binlog retention hours`.
Pour les instances de base de données MySQL, la valeur `binlog retention hours` maximale est 168 (7 jours).
Après avoir défini la période de rétention, surveillez l’utilisation du stockage de l’instance de base de données afin de garantir que les journaux binaires conservés n’utilisent pas un espace de stockage trop grand.
Pour les déploiements de cluster de bases de données multi-AZ, vous pouvez uniquement configurer la conservation des journaux binaires à partir de l’instance de base de données de l’enregistreur, et le paramètre est propagé à toutes les instances de base de données de lecteur de manière asynchrone. Si les journaux binaires du cluster de bases de données dépassent la moitié de l’espace de stockage local total, Amazon RDS déplace automatiquement les journaux périmés vers le volume EBS. Cependant, les journaux les plus récents restent stockés localement ; ils risquent donc d’être perdus en cas de défaillance nécessitant le remplacement de l’hôte ou lors d’une mise à l’échelle à la hausse ou à la baisse de la base de données.
#### retard à la source
Utilisez le paramètre `source delay` dans un réplica en lecture pour spécifier le nombre de secondes dont il faut retarder la réplication à partir du réplica en lecture vers son instance de base de données source. Amazon RDS réplique normalement les modifications dès que possible, mais vous pouvez souhaiter que certains environnement retardent la réplication. Par exemple, lorsque la réplication est retardée, vous pouvez restaurer par progression un réplica en lecture retardé au moment précédant un sinistre. Si une table est supprimée par mégarde, vous pouvez utiliser la réplication retardée pour la récupérer rapidement. La valeur par défaut de `target delay` est `0` (ne pas retarder la réplication).
Lorsque vous utilisez ce paramètre, il exécute [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) et applique la valeur d’entrée CHANGE primary TO MASTER\$1DELAY =. En cas de succès, la procédure enregistre le paramètre `source delay` dans la table `mysql.rds_configuration`.
Pour spécifier le nombre de secondes pendant lesquelles Amazon RDS retardera la réplication vers une instance de base de données source, utilisez la procédure `mysql.rds_set_configuration` stockée et spécifiez le nombre de secondes dont il faut retarder la réplication. Dans l’exemple suivant, la réplication est retardée d’au moins une heure (3 600 secondes).
`call mysql.rds_set_configuration('source delay', 3600);`
La procédure exécute ensuite `mysql.rds_set_source_delay(3600)`.
La limite du paramètre `source delay` est une journée (soit 86 400 secondes).
#### target delay
Utilisez le paramètre `target delay` pour spécifier le nombre de secondes dont il faut retarder la réplication entre une instance de base de données et tout réplica en lecture futur géré par RDS créé à partir de cette instance. Ce paramètre est ignoré pour les répliques de non-RDS-managed lecture. Amazon RDS réplique normalement les modifications dès que possible, mais vous pouvez souhaiter que certains environnement retardent la réplication. Par exemple, lorsque la réplication est retardée, vous pouvez restaurer par progression un réplica en lecture retardé au moment précédant un sinistre. Si une table est supprimée par mégarde, vous pouvez utiliser la réplication retardée pour la récupérer rapidement. La valeur par défaut de `target delay` est `0` (ne pas retarder la réplication).
Pour la reprise après sinistre, vous pouvez utiliser ce paramètre de configuration avec la procédure stockée [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) ou [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Pour restaurer par progression les modifications dans un réplica en lecture retardé au moment précédant un sinistre, vous pouvez exécuter la procédure `mysql.rds_set_configuration` avec ce paramètre défini. Une fois que la procédure `mysql.rds_start_replication_until` ou `mysql.rds_start_replication_until_gtid` a arrêté la réplication, vous pouvez promouvoir le réplica en lecture pour qu’il devienne la nouvelle instance de base de données principale, en utilisant les instructions figurant dans [Promotion d'un réplica en lecture en instance de bases de données autonome](USER_ReadRepl.Promote.md).
Pour utiliser la procédure `mysql.rds_rds_start_replication_until_gtid`, la réplication basée sur des identifiants de transaction globaux (GTID) doit être activée. Pour ignorer une transaction basée sur des identifiants de transaction globaux spécifique qui est réputée pour entraîner des défaillances, vous pouvez utiliser la procédure stockée [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Pour plus d’informations sur la gestion d’une réplication basée sur des identifiants de transaction globaux, consultez [Utilisation de la réplication basée sur des identifiants de transaction globaux (GTID)](mysql-replication-gtid.md).
Pour spécifier le nombre de secondes pendant lesquelles Amazon RDS retardera la réplication vers un réplica en lecture, utilisez la procédure stockée `mysql.rds_set_configuration` et spécifiez le nombre de secondes dont il faut retarder la réplication. L’exemple suivant spécifie que la réplication est retardée d’au moins une heure (3 600 secondes).
`call mysql.rds_set_configuration('target delay', 3600);`
La limite du paramètre `target delay` est une journée (soit 86 400 secondes).
## mysql.rds\$1show\$1configuration
Nombre d’heures pendant lequel les journaux binaires sont conservés.
### Syntaxe
```
CALL mysql.rds_show_configuration;
```
### Notes d’utilisation
Pour vérifier le nombre d’heures pendant lequel Amazon RDS conserve les journaux binaires, utilisez la procédure stockée `mysql.rds_show_configuration`.
### Exemples
L’exemple suivant affiche la période de rétention :
```
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.
```
# Réchauffement du cache InnoDB
Les procédures stockées suivantes enregistrent, chargent ou annulent le chargement du pool de mémoires tampons InnoDB sur les instances de base de données RDS pour MySQL. Pour de plus amples informations, consultez [Préparation du cache InnoDB pour MySQL sur 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
Vide l'état actuel du pool de tampons sur le disque.
### Syntaxe
```
CALL mysql.rds_innodb_buffer_pool_dump_now();
```
### Notes d'utilisation
L'utilisateur principal doit exécuter la procédure `mysql.rds_innodb_buffer_pool_dump_now`.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
Annule un chargement en cours de l'état du groupe de tampons enregistré.
### Syntaxe
```
CALL mysql.rds_innodb_buffer_pool_load_abort();
```
### Notes d'utilisation
L'utilisateur principal doit exécuter la procédure `mysql.rds_innodb_buffer_pool_load_abort`.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
Charge l'état enregistré du pool de tampons à partir du disque.
### Syntaxe
```
CALL mysql.rds_innodb_buffer_pool_load_now();
```
### Notes d'utilisation
L'utilisateur principal doit exécuter la procédure `mysql.rds_innodb_buffer_pool_load_now`.