Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Riferimento delle stored procedure RDS per MySQL
In questi argomenti vengono descritte le stored procedure di sistema disponibili per le istanze Amazon RDS che eseguono il motore di database MySQL. La procedura deve essere eseguita dall'utente master.
**Topics**
+ [
# Raccolta e gestione della cronologia dello stato globale
](mysql-stored-proc-gsh.md)
+ [
# Configurazione, avvio e arresto della replica dei log binari (binlog)
](mysql-stored-proc-replicating.md)
+ [
# Terminare una sessione o una query
](mysql-stored-proc-ending.md)
+ [
# Gestione di cluster attivi-attivi
](mysql-stored-proc-active-active-clusters.md)
+ [
# Gestione della replica da più origini
](mysql-stored-proc-multi-source-replication.md)
+ [
# Replica delle transazioni utilizzando GTIDs
](mysql-stored-proc-gtid.md)
+ [
# Rotazione dei log di query
](mysql-stored-proc-logging.md)
+ [
# Impostazione e visualizzazione della configurazione dei log binari
](mysql-stored-proc-configuring.md)
+ [
# Precaricamento della cache di InnoDB
](mysql-stored-proc-warming.md)
# Raccolta e gestione della cronologia dello stato globale
Amazon RDS fornisce una serie di procedure che acquisiscono uno snapshot dei valori di queste variabili di stato nel tempo e li scrivono in una tabella insieme alle modifiche eseguite dopo l'ultimo snapshot. Questa infrastruttura si chiama cronologia di stato globale. Per ulteriori informazioni, consulta [Gestione della cronologia dello stato globale per RDS per MySQL](Appendix.MySQL.CommonDBATasks.GoSH.md).
Le seguenti stored procedure gestiscono il modo in cui la cronologia di stato globale viene raccolta e gestita.
**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
Acquisisce uno snapshot on demand per la cronologia di stato globale.
### Sintassi
```
CALL mysql.rds_collect_global_status_history;
```
## mysql.rds\$1disable\$1gsh\$1collector
Disabilita gli snapshot creati mediante la cronologia di stato globale.
### Sintassi
```
CALL mysql.rds_disable_gsh_collector;
```
## mysql.rds\$1disable\$1gsh\$1rotation
Disattiva la rotazione della tabella `mysql.global_status_history`.
### Sintassi
```
CALL mysql.rds_disable_gsh_rotation;
```
## mysql.rds\$1enable\$1gsh\$1collector
Abilita la cronologia di stato globale per acquisire snapshot predefiniti agli intervalli specificati da `rds_set_gsh_collector`.
### Sintassi
```
CALL mysql.rds_enable_gsh_collector;
```
## mysql.rds\$1enable\$1gsh\$1rotation
Attiva la rotazione dei contenuti della tabella `mysql.global_status_history` su `mysql.global_status_history_old` agli intervalli specificati da `rds_set_gsh_rotation`.
### Sintassi
```
CALL mysql.rds_enable_gsh_rotation;
```
## mysql.rds\$1rotate\$1global\$1status\$1history
Ruota i contenuti della tabella `mysql.global_status_history` su `mysql.global_status_history_old` a richiesta.
### Sintassi
```
CALL mysql.rds_rotate_global_status_history;
```
## mysql.rds\$1set\$1gsh\$1collector
Specifica l'intervallo, espresso in minuti, tra gli snapshot acquisiti mediante la cronologia di stato globale.
### Sintassi
```
CALL mysql.rds_set_gsh_collector(intervalPeriod);
```
### Parametri
*intervalPeriod*
L'intervallo, in minuti, tra gli snapshot. Il valore predefinito è `5`.
## mysql.rds\$1set\$1gsh\$1rotation
Specifica l'intervallo, in giorni, tra le conversioni della tabella `mysql.global_status_history`.
### Sintassi
```
CALL mysql.rds_set_gsh_rotation(intervalPeriod);
```
### Parametri
*intervalPeriod*
L'intervallo, in giorni, tra le conversioni delle tabelle. Il valore predefinito è `7`.
# Configurazione, avvio e arresto della replica dei log binari (binlog)
Queste stored procedure controllano il modo in cui le transazioni vengono replicate da un database esterno in RDS per MySQL o viceversa.
Quando si utilizzano queste stored procedure per gestire la replica con un utente di replica configurato con `caching_sha2_password`, è necessario configurare TLS specificando `SOURCE_SSL=1`. `caching_sha2_password` è il plugin di autenticazione predefinito per RDS per MySQL 8.4. Per ulteriori informazioni, consulta [Crittografia con SSL/TLS](mysql-ssl-connections.md).
Per informazioni sulla configurazione, l’utilizzo e la gestione delle repliche di lettura, consulta [Uso delle repliche di lettura MySQL](USER_MySQL.Replication.ReadReplicas.md).
**Topics**
+ [
##
](#mysql_rds_next_master_log)
+ [
## mysql.rds\$1next\$1source\$1log (RDS per MySQL versioni principali 8.4 e successive)
](#mysql_rds_next_source_log)
+ [
## mysql.rds\$1reset\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)
](#mysql_rds_reset_external_master)
+ [
## mysql.rds\$1reset\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)
](#mysql_rds_reset_external_source)
+ [
## mysql.rds\$1set\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)
](#mysql_rds_set_external_master)
+ [
## mysql.rds\$1set\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)
](#mysql_rds_set_external_source)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS per MySQL versioni principali 8.0 e precedenti)
](#mysql_rds_set_external_master_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS per MySQL versioni principali 8.4 e successive)
](#mysql_rds_set_external_source_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)
](#mysql_rds_set_external_master_with_delay)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS per MySQL versioni principali 8.4 e successive)
](#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 per MySQL versioni principali 8.4 e successive)
](#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)
##
Cambia la posizione del log dell'istanza database di origine all'inizio del successivo log binario nell'istanza database di origine. Utilizzate questa procedura solo se ricevete l'errore di replica 1236 I/O su una replica di lettura.
### Sintassi
```
CALL mysql.rds_next_master_log(
curr_master_log
);
```
### Parameters
*curr\$1master\$1log*
L'indice del file di log master corrente. Ad esempio, se il file corrente è denominato `mysql-bin-changelog.012345`, l’indice è 12345. Per determinare il nome del file di log master corrente, esegui il comando `SHOW REPLICA STATUS` e visualizza il campo `Master_Log_File`.
### Note per l’utilizzo
La procedura `mysql.rds_next_master_log` deve essere eseguita dall’utente master.
**avvertimento**
Effettua la chiamata `mysql.rds_next_master_log` solo se la replica fallisce dopo un failover di un'istanza DB Multi-AZ che è l'origine della replica e il campo riporta l'errore 1236. `Last_IO_Errno` `SHOW REPLICA STATUS` I/O
La chiamata di `mysql.rds_next_master_log` può comportare una perdita di dati nella replica di lettura se le transazioni nell’istanza di origine non sono state scritte nel log binario sul disco prima dell’evento di failover. Si può diminuire la possibilità che si verifichi una situazione di questo tipo impostando i parametri dell’istanza di origine `sync_binlog` e `innodb_support_xa` su `1`, anche se ciò può compromettere le prestazioni. Per ulteriori informazioni, consulta [Risoluzione dei problemi relativi a una replica di lettura MySQL](USER_ReadRepl.Troubleshooting.md).
### Esempi
Supponi che una replica di lettura RDS per MySQL non riesca. L’esecuzione di `SHOW REPLICA STATUS\G` nella replica di lettura restituisce il risultato seguente:
```
*************************** 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
```
Il campo `Last_IO_Errno` mostra che l'istanza riceve l'errore I/O 1236. Il campo `Master_Log_File` mostra che il nome di file è `mysql-bin-changelog.012345`, il che significa che l'indice del file di log è `12345`. Per risolvere il problema, puoi chiamare `mysql.rds_next_master_log` con il seguente parametro:
```
CALL mysql.rds_next_master_log(12345);
```
## mysql.rds\$1next\$1source\$1log (RDS per MySQL versioni principali 8.4 e successive)
Cambia la posizione del log dell'istanza database di origine all'inizio del successivo log binario nell'istanza database di origine. Utilizzare questa procedura solo se si riceve l' I/O errore di replica 1236 su una replica di lettura.
### Sintassi
```
CALL mysql.rds_next_source_log(
curr_source_log
);
```
### Parameters
*curr\$1source\$1log*
L'indice del file di log di origine corrente. Ad esempio, se il file corrente è denominato `mysql-bin-changelog.012345`, l’indice è 12345. Per determinare il nome del file di log di origine corrente, esegui il comando `SHOW REPLICA STATUS` e visualizza il campo `Source_Log_File`.
### Note per l’utilizzo
L’utente amministrativo deve eseguire la procedura `mysql.rds_next_source_log`.
**avvertimento**
Effettua la chiamata `mysql.rds_next_source_log` solo se la replica fallisce dopo un failover di un'istanza DB Multi-AZ che è l'origine della replica e il campo riporta l'errore 1236. `Last_IO_Errno` `SHOW REPLICA STATUS` I/O
La chiamata di `mysql.rds_next_source_log` può comportare una perdita di dati nella replica di lettura se le transazioni nell’istanza di origine non sono state scritte nel log binario sul disco prima dell’evento di failover. Si può diminuire la possibilità che si verifichi una situazione di questo tipo impostando i parametri dell’istanza di origine `sync_binlog` e `innodb_support_xa` su `1`, anche se ciò può compromettere le prestazioni. Per ulteriori informazioni, consulta [Risoluzione dei problemi relativi a una replica di lettura MySQL](USER_ReadRepl.Troubleshooting.md).
### Esempi
Supponi che una replica di lettura RDS per MySQL non riesca. L’esecuzione di `SHOW REPLICA STATUS\G` nella replica di lettura restituisce il risultato seguente:
```
*************************** 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
```
Il campo `Last_IO_Errno` mostra che l'istanza riceve l'errore I/O 1236. Il campo `Source_Log_File` mostra che il nome di file è `mysql-bin-changelog.012345`, il che significa che l'indice del file di log è `12345`. Per risolvere il problema, puoi chiamare `mysql.rds_next_source_log` con il seguente parametro:
```
CALL mysql.rds_next_source_log(12345);
```
## mysql.rds\$1reset\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)
Riconfigura un'istanza database RDS per MySQL affinché non sia più una replica di lettura di un'istanza di MySQL in esecuzione all'esterno di Amazon RDS.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
CALL mysql.rds_reset_external_master;
```
### Note per l’utilizzo
La procedura `mysql.rds_reset_external_master` deve essere eseguita dall'utente master. Questa procedura deve essere eseguita sull’istanza database MySQL da rimuovere come replica di lettura di un’istanza MySQL eseguita esternamente a Amazon RDS.
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Per ulteriori informazioni sull’uso della replica per importare dati da un’istanza di MySQL in esecuzione all’esterno di Amazon RDS, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
## mysql.rds\$1reset\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)
Riconfigura un'istanza database RDS per MySQL affinché non sia più una replica di lettura di un'istanza di MySQL in esecuzione all'esterno di Amazon RDS.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
CALL mysql.rds_reset_external_source;
```
### Note per l’utilizzo
L’utente amministrativo deve eseguire la procedura `mysql.rds_reset_external_source`. Questa procedura deve essere eseguita sull’istanza database MySQL da rimuovere come replica di lettura di un’istanza MySQL eseguita esternamente a Amazon RDS.
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS.
Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md). Per ulteriori informazioni sull'uso della replica per importare dati da un'istanza di MySQL in esecuzione all'esterno di Amazon RDS, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
## mysql.rds\$1set\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)
Configura un'istanza database RDS per MySQL come replica di lettura di un'istanza di MySQL in esecuzione all'esterno di Amazon RDS.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
**Nota**
Puoi usare la procedura archiviata [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](#mysql_rds_set_external_master_with_delay) per configurare un’istanza database di origine esterna e una replica ritardata.
### Sintassi
```
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*
Il nome host o l'indirizzo IP dell'istanza di MySQL eseguita esternamente a Amazon RDS per diventare l’istanza database di origine.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Amazon RDS e da configurare come istanza database di origine. Se la configurazione della rete include la replica della porta Secure Shell (SSH) che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
L'ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell'istanza di MySQL eseguita esternamente a Amazon RDS. Ti consigliamo di fornire un account utilizzato unicamente per la replica con l'istanza esterna.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Il nome del log binario sull’istanza database di origine che contiene le informazioni relative alla replica.
*mysql\$1binary\$1log\$1file\$1location*
La posizione nel log binario `mysql_binary_log_file_name` a partire dalla quale la replica inizia a leggere le informazioni a essa relative.
È possibile determinare il nome e la posizione del file binlog in esecuzione `SHOW MASTER STATUS` sull'istanza del database di origine.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L’opzione `MASTER_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
### Note per l’utilizzo
La procedura `mysql.rds_set_external_master` deve essere eseguita dall'utente master. Questa procedura deve essere eseguita sull’istanza database MySQL da configurare come replica di lettura di un’istanza MySQL eseguita esternamente a Amazon RDS.
Prima di eseguire `mysql.rds_set_external_master`, devi configurare l’istanza di MySQL in esecuzione all’esterno di Amazon RDS come istanza database di origine. Per connetterti all'istanza MySQL in esecuzione all'esterno di Amazon RDS, devi specificare i valori di `replication_user_name` e `replication_user_password` che indicano un utente della replica dotato delle autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` per l'istanza esterna di MySQL.
**Per configurare un'istanza esterna di MySQL come istanza database di origine**
1. Mediante il client MySQL scelto, eseguire la connessione all'istanza esterna di MySQL e creare un account utente da utilizzare per la replica. Di seguito è riportato un esempio di :
**MySQL 5.7**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**MySQL 8.0**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED WITH mysql_native_password BY 'password';
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Nell’istanza esterna di MySQL, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all’utente della replica. L’esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l’utente “repl\$1user” del dominio:
**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';
```
Per utilizzare la replica crittografata, configura l'istanza database di origine per utilizzare le connessioni SSL.
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Dopo aver chiamato `mysql.rds_set_external_master` per configurare un’istanza database di Amazon RDS come replica di lettura, puoi chiamare [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) nella replica di lettura per avviare il processo di replica. Puoi chiamare [mysql.rds\$1reset\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](#mysql_rds_reset_external_master) per rimuovere la configurazione della replica di lettura.
Quando `mysql.rds_set_external_master` viene chiamato, Amazon RDS registra l'ora, l'utente e un'operazione di `set master` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
### Esempi
Nel caso di esecuzione su un’istanza database MySQL, l’esempio seguente configura l’istanza database come replica di lettura di un’istanza di MySQL eseguita esternamente a 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 per MySQL versioni principali 8.4 e successive)
Configura un'istanza database RDS per MySQL come replica di lettura di un'istanza di MySQL in esecuzione all'esterno di Amazon RDS.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
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*
Il nome host o l'indirizzo IP dell'istanza di MySQL eseguita esternamente a Amazon RDS per diventare l’istanza database di origine.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Amazon RDS e da configurare come istanza database di origine. Se la configurazione della rete include la replica della porta Secure Shell (SSH) che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
L'ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell'istanza di MySQL eseguita esternamente a Amazon RDS. Ti consigliamo di fornire un account utilizzato unicamente per la replica con l'istanza esterna.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Il nome del log binario sull’istanza database di origine che contiene le informazioni relative alla replica.
*mysql\$1binary\$1log\$1file\$1location*
La posizione nel log binario `mysql_binary_log_file_name` a partire dalla quale la replica inizia a leggere le informazioni a essa relative.
È possibile determinare il nome e la posizione del file binlog in esecuzione `SHOW MASTER STATUS` sull'istanza del database di origine.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L’opzione `SOURCE_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
### Note per l’utilizzo
L’utente amministrativo deve eseguire la procedura `mysql.rds_set_external_source`. Questa procedura deve essere eseguita nell’istanza database RDS per MySQL da configurare come replica di lettura di un’istanza MySQL eseguita esternamente ad Amazon RDS.
Prima di eseguire `mysql.rds_set_external_source`, devi configurare l’istanza di MySQL in esecuzione all’esterno di Amazon RDS come istanza database di origine. Per connetterti all'istanza MySQL in esecuzione all'esterno di Amazon RDS, devi specificare i valori di `replication_user_name` e `replication_user_password` che indicano un utente della replica dotato delle autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` per l'istanza esterna di MySQL.
**Per configurare un'istanza esterna di MySQL come istanza database di origine**
1. Mediante il client MySQL scelto, eseguire la connessione all'istanza esterna di MySQL e creare un account utente da utilizzare per la replica. Di seguito è riportato un esempio di :
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Nell’istanza esterna di MySQL, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all’utente della replica. L’esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l’utente “repl\$1user” del dominio:
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
Per utilizzare la replica crittografata, configura l'istanza database di origine per utilizzare le connessioni SSL. Importa inoltre il certificato dell'autorità di certificazione, il certificato client e la chiave client nell'istanza database o nel cluster database utilizzando la procedura [mysql.rds\$1import\$1binlog\$1ssl\$1material](url-rds-user;mysql_rds_import_binlog_ssl_material.html).
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Dopo aver chiamato `mysql.rds_set_external_source` per configurare un’istanza database RDS per MySQL come replica di lettura, è possibile chiamare [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) sulla replica di lettura per avviare il processo di replica. Puoi chiamare [mysql.rds\$1reset\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)](#mysql_rds_reset_external_source) per rimuovere la configurazione della replica di lettura.
Quando `mysql.rds_set_external_source` viene chiamato, Amazon RDS registra l'ora, l'utente e un'operazione di `set master` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
### Esempi
Se in esecuzione in un’istanza database RDS per MySQL, l’esempio seguente configura l’istanza database come replica di lettura di un’istanza di MySQL eseguita esternamente ad 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 per MySQL versioni principali 8.0 e precedenti)
Configura un’istanza database RDS per MySQL come replica di lettura di un’istanza di MySQL eseguita esternamente a Amazon RDS. Questa procedura configura anche la replica ritardata e la replica in base agli identificatori di transazione globali (). GTIDs
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
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*
Il nome host o l'indirizzo IP dell'istanza di MySQL eseguita esternamente a Amazon RDS per diventare l’istanza database di origine.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Amazon RDS e da configurare come istanza database di origine. Se la configurazione della rete include la replica della porta Secure Shell (SSH) che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
L'ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell'istanza di MySQL eseguita esternamente a Amazon RDS. Ti consigliamo di fornire un account utilizzato unicamente per la replica con l'istanza esterna.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L’opzione `MASTER_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
*delay*
Numero minimo di secondi per ritardare la replica dall'istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
### Note per l’utilizzo
La procedura `mysql.rds_set_external_master_with_auto_position` deve essere eseguita dall'utente master. Questa procedura deve essere eseguita sull’istanza database MySQL da configurare come replica di lettura di un’istanza MySQL eseguita esternamente a Amazon RDS.
Questa procedura è supportata per tutte le versioni di RDS per MySQL 5.7 e per RDS per MySQL 8.0.26 e versioni successive alla 8.0.
Prima di eseguire `mysql.rds_set_external_master_with_auto_position`, devi configurare l'istanza di MySQL in esecuzione all'esterno di Amazon RDS come istanza database di origine. Per connetterti all'istanza MySQL in esecuzione all'esterno di Amazon RDS, devi specificare i valori per `replication_user_name` e `replication_user_password`. Questi valori devono indicare un utente di replica che dispone delle autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` sull'istanza esterna di MySQL.
**Per configurare un'istanza esterna di MySQL come istanza database di origine**
1. Mediante il client MySQL scelto, eseguire la connessione all'istanza esterna di MySQL e creare un account utente da utilizzare per la replica. Di seguito è riportato un esempio.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Nell'istanza esterna di MySQL, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all'utente della replica. L'esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente `'repl_user'` per il dominio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Per ulteriori informazioni, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Prima di chiamare `mysql.rds_set_external_master_with_auto_position`, assicurati di chiamare [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) per impostare la variabile di sistema `gtid_purged` con un intervallo di GTID specificato da un’origine esterna.
Dopo aver chiamato `mysql.rds_set_external_master_with_auto_position` per configurare un’istanza database di Amazon RDS come replica di lettura, puoi chiamare [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) nella replica di lettura per avviare il processo di replica. Puoi chiamare [mysql.rds\$1reset\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](#mysql_rds_reset_external_master) per rimuovere la configurazione della replica di lettura.
Quando viene chiamato `mysql.rds_set_external_master_with_auto_position`, Amazon RDS registra l'ora, l'utente e un'operazione `set master` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
Per il disaster recovery puoi usare questa procedura con la stored procedure [](#mysql_rds_start_replication_until) o [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore, puoi eseguire la procedura `mysql.rds_set_external_master_with_auto_position`. Dopo che la procedura `mysql.rds_start_replication_until_gtid` arresta la replica, puoi promuovere la replica di lettura come nuova istanza database primaria seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Per usare la procedura `mysql.rds_rds_start_replication_until_gtid`, è necessario che sia abilitata la replica basata su GTID. Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la stored procedure [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Per ulteriori informazioni sull'utilizzo della replica basata su GTID, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
### Esempi
Nel caso di esecuzione su un’istanza database MySQL, l’esempio seguente configura l’istanza database come replica di lettura di un’istanza di MySQL eseguita esternamente a Amazon RDS. Imposta il ritardo di replica minimo su un’ora (3600 secondi) nell’istanza database MySQL. Una modifica dall’istanza database di origine MySQL in esecuzione all’esterno di Amazon RDS non viene applicata nella replica di lettura dell’istanza database MySQL per almeno un’ora.
```
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 per MySQL versioni principali 8.4 e successive)
Configura un’istanza database RDS per MySQL come replica di lettura di un’istanza di MySQL eseguita esternamente a Amazon RDS. Questa procedura configura anche la replica ritardata e la replica in base agli identificatori di transazione globali (). GTIDs
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
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*
Il nome host o l'indirizzo IP dell'istanza di MySQL eseguita esternamente a Amazon RDS per diventare l’istanza database di origine.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Amazon RDS e da configurare come istanza database di origine. Se la configurazione della rete include la replica della porta Secure Shell (SSH) che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
L'ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell'istanza di MySQL eseguita esternamente a Amazon RDS. Ti consigliamo di fornire un account utilizzato unicamente per la replica con l'istanza esterna.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L’opzione `SOURCE_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
*delay*
Numero minimo di secondi per ritardare la replica dall'istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
### Note per l’utilizzo
L’utente amministrativo deve eseguire la procedura `mysql.rds_set_external_source_with_auto_position`. Questa procedura deve essere eseguita sull’istanza database MySQL da configurare come replica di lettura di un’istanza MySQL eseguita esternamente a Amazon RDS.
Prima di eseguire `mysql.rds_set_external_source_with_auto_position`, devi configurare l'istanza di MySQL in esecuzione all'esterno di Amazon RDS come istanza database di origine. Per connetterti all'istanza MySQL in esecuzione all'esterno di Amazon RDS, devi specificare i valori per `replication_user_name` e `replication_user_password`. Questi valori devono indicare un utente di replica che dispone delle autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` sull'istanza esterna di MySQL.
**Per configurare un'istanza esterna di MySQL come istanza database di origine**
1. Mediante il client MySQL scelto, eseguire la connessione all'istanza esterna di MySQL e creare un account utente da utilizzare per la replica. Di seguito è riportato un esempio.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Nell'istanza esterna di MySQL, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all'utente della replica. L'esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente `'repl_user'` per il dominio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Per ulteriori informazioni, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Prima di chiamare `mysql.rds_set_external_source_with_auto_position`, assicurati di chiamare [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) per impostare la variabile di sistema `gtid_purged` con un intervallo di GTID specificato da un’origine esterna.
Dopo aver chiamato `mysql.rds_set_external_source_with_auto_position` per configurare un’istanza database di Amazon RDS come replica di lettura, puoi chiamare [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) nella replica di lettura per avviare il processo di replica. Puoi chiamare [mysql.rds\$1reset\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)](#mysql_rds_reset_external_source) per rimuovere la configurazione della replica di lettura.
Quando viene chiamato `mysql.rds_set_external_source_with_auto_position`, Amazon RDS registra l'ora, l'utente e un'operazione `set master` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
Per il disaster recovery puoi usare questa procedura con la stored procedure [](#mysql_rds_start_replication_until) o [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore, puoi eseguire la procedura `mysql.rds_set_external_source_with_auto_position`. Dopo che la procedura `mysql.rds_start_replication_until_gtid` arresta la replica, puoi promuovere la replica di lettura come nuova istanza database primaria seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Per usare la procedura `mysql.rds_rds_start_replication_until_gtid`, è necessario che sia abilitata la replica basata su GTID. Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la stored procedure [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Per ulteriori informazioni sull'utilizzo della replica basata su GTID, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
### Esempi
Nel caso di esecuzione su un’istanza database MySQL, l’esempio seguente configura l’istanza database come replica di lettura di un’istanza di MySQL eseguita esternamente a Amazon RDS. Imposta il ritardo di replica minimo su un’ora (3600 secondi) nell’istanza database MySQL. Una modifica dall’istanza database di origine MySQL in esecuzione all’esterno di Amazon RDS non viene applicata nella replica di lettura dell’istanza database MySQL per almeno un’ora.
```
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 per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)
Configura un'istanza database RDS for MySQL come replica di lettura di un'istanza di MySQL in esecuzione all'esterno di Amazon RDS e configura la replica ritardata.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
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*
Nome host o indirizzo IP dell'istanza MySQL in esecuzione all'esterno di Amazon RDS che diventerà l'istanza database di origine.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Amazon RDS e da configurare come istanza database di origine. Se la configurazione della rete include la replica della porta SSH che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
L'ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell'istanza di MySQL eseguita esternamente a Amazon RDS. Ti consigliamo di fornire un account utilizzato unicamente per la replica con l'istanza esterna.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Il nome del log binario sull’istanza database di origine contiene le informazioni relative alla replica.
*mysql\$1binary\$1log\$1file\$1location*
Posizione nel log binario `mysql_binary_log_file_name` a partire dalla quale la replica inizierà a leggere le informazioni di replica.
È possibile determinare il nome e la posizione del file binlog in esecuzione `SHOW MASTER STATUS` sull'istanza del database di origine.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L’opzione `MASTER_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
*delay*
Numero minimo di secondi per ritardare la replica dall'istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
### Note per l’utilizzo
La procedura `mysql.rds_set_external_master_with_delay` deve essere eseguita dall'utente master. Questa procedura deve essere eseguita sull’istanza database MySQL da configurare come replica di lettura di un’istanza MySQL eseguita esternamente a Amazon RDS.
Prima di eseguire `mysql.rds_set_external_master_with_delay`, devi configurare l'istanza di MySQL in esecuzione all'esterno di Amazon RDS come istanza database di origine. Per connetterti all'istanza MySQL in esecuzione all'esterno di Amazon RDS, devi specificare i valori per `replication_user_name` e `replication_user_password`. Questi valori devono indicare un utente di replica che dispone delle autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` sull'istanza esterna di MySQL.
**Per configurare un'istanza esterna di MySQL come istanza database di origine**
1. Mediante il client MySQL scelto, eseguire la connessione all'istanza esterna di MySQL e creare un account utente da utilizzare per la replica. Di seguito è riportato un esempio.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Nell'istanza esterna di MySQL, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all'utente della replica. L'esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente `'repl_user'` per il dominio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Per ulteriori informazioni, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Dopo aver chiamato `mysql.rds_set_external_master_with_delay` per configurare un'istanza database di Amazon RDS come replica di lettura, puoi chiamare [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) nella replica di lettura per avviare il processo di replica. Puoi chiamare [mysql.rds\$1reset\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](#mysql_rds_reset_external_master) per rimuovere la configurazione della replica di lettura.
Quando viene chiamato `mysql.rds_set_external_master_with_delay`, Amazon RDS registra l'ora, l'utente e un'operazione `set master` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
Per il disaster recovery puoi usare questa procedura con la stored procedure [](#mysql_rds_start_replication_until) o [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore, puoi eseguire la procedura `mysql.rds_set_external_master_with_delay`. Dopo che la procedura `mysql.rds_start_replication_until` arresta la replica, puoi promuovere la replica di lettura come nuova istanza database primaria seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Per usare la procedura `mysql.rds_rds_start_replication_until_gtid`, è necessario che sia abilitata la replica basata su GTID. Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la stored procedure [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Per ulteriori informazioni sull'utilizzo della replica basata su GTID, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
La procedura `mysql.rds_set_external_master_with_delay` è disponibile nelle seguenti versioni di RDS per MySQL:
+ MySQL 8.0.26 e versioni successive alla 8.0
+ Tutte le versioni 5.7
### Esempi
Nel caso di esecuzione su un’istanza database MySQL, l’esempio seguente configura l’istanza database come replica di lettura di un’istanza di MySQL eseguita esternamente a Amazon RDS. Imposta il ritardo di replica minimo su un’ora (3600 secondi) nell’istanza database MySQL. Una modifica dall’istanza database di origine MySQL in esecuzione all’esterno di Amazon RDS non viene applicata nella replica di lettura dell’istanza database MySQL per almeno un’ora.
```
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 per MySQL versioni principali 8.4 e successive)
Configura un'istanza database RDS for MySQL come replica di lettura di un'istanza di MySQL in esecuzione all'esterno di Amazon RDS e configura la replica ritardata.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
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*
Nome host o indirizzo IP dell'istanza MySQL in esecuzione all'esterno di Amazon RDS che diventerà l'istanza database di origine.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Amazon RDS e da configurare come istanza database di origine. Se la configurazione della rete include la replica della porta SSH che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
L'ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell'istanza di MySQL eseguita esternamente a Amazon RDS. Ti consigliamo di fornire un account utilizzato unicamente per la replica con l'istanza esterna.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Il nome del log binario sull’istanza database di origine contiene le informazioni relative alla replica.
*mysql\$1binary\$1log\$1file\$1location*
Posizione nel log binario `mysql_binary_log_file_name` a partire dalla quale la replica inizierà a leggere le informazioni di replica.
È possibile determinare il nome e la posizione del file binlog in esecuzione `SHOW MASTER STATUS` sull'istanza del database di origine.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L’opzione `SOURCE_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
*delay*
Numero minimo di secondi per ritardare la replica dall'istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
### Note per l’utilizzo
L’utente amministrativo deve eseguire la procedura `mysql.rds_set_external_source_with_delay`. Questa procedura deve essere eseguita sull’istanza database MySQL da configurare come replica di lettura di un’istanza MySQL eseguita esternamente a Amazon RDS.
Prima di eseguire `mysql.rds_set_external_source_with_delay`, devi configurare l'istanza di MySQL in esecuzione all'esterno di Amazon RDS come istanza database di origine. Per connetterti all'istanza MySQL in esecuzione all'esterno di Amazon RDS, devi specificare i valori per `replication_user_name` e `replication_user_password`. Questi valori devono indicare un utente di replica che dispone delle autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` sull'istanza esterna di MySQL.
**Per configurare un'istanza esterna di MySQL come istanza database di origine**
1. Mediante il client MySQL scelto, eseguire la connessione all'istanza esterna di MySQL e creare un account utente da utilizzare per la replica. Di seguito è riportato un esempio.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Nell'istanza esterna di MySQL, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all'utente della replica. L'esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente `'repl_user'` per il dominio.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Per ulteriori informazioni, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
**Nota**
Ti consigliamo di usare le repliche di lettura per gestire la replica tra due istanze database di Amazon RDS. In questo caso, si consiglia di usare solo questa e altre stored procedure correlate alla replica. Questo consente di usare topologie di replica più complesse tra le istanze database Amazon RDS. Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Dopo aver chiamato `mysql.rds_set_external_source_with_delay` per configurare un'istanza database di Amazon RDS come replica di lettura, puoi chiamare [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) nella replica di lettura per avviare il processo di replica. Puoi chiamare [mysql.rds\$1reset\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)](#mysql_rds_reset_external_source) per rimuovere la configurazione della replica di lettura.
Quando viene chiamato `mysql.rds_set_external_source_with_delay`, Amazon RDS registra l'ora, l'utente e un'operazione `set master` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
Per il disaster recovery puoi usare questa procedura con la stored procedure [](#mysql_rds_start_replication_until) o [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore, puoi eseguire la procedura `mysql.rds_set_external_source_with_delay`. Dopo che la procedura `mysql.rds_start_replication_until` arresta la replica, puoi promuovere la replica di lettura come nuova istanza database primaria seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Per usare la procedura `mysql.rds_rds_start_replication_until_gtid`, è necessario che sia abilitata la replica basata su GTID. Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la stored procedure [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Per ulteriori informazioni sull'utilizzo della replica basata su GTID, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
### Esempi
Nel caso di esecuzione su un’istanza database MySQL, l’esempio seguente configura l’istanza database come replica di lettura di un’istanza di MySQL eseguita esternamente a Amazon RDS. Imposta il ritardo di replica minimo su un’ora (3600 secondi) nell’istanza database MySQL. Una modifica dall’istanza database di origine MySQL in esecuzione all’esterno di Amazon RDS non viene applicata nella replica di lettura dell’istanza database MySQL per almeno un’ora.
```
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
Imposta la variabile di sistema [gtid\$1purged](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_gtid_purged) con un intervallo GTID specificato da un’origine esterna. Il valore `gtid_purged` è necessario per configurare la replica basata su GTID per riprendere la replica utilizzando il posizionamento automatico.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
CALL mysql.rds_set_external_source_gtid_purged(
server_uuid
, start_pos
, end_pos
);
```
### Parameters
*server\$1uuid*
Identificatore univoco universale (UUID) del server esterno da cui viene importato l’intervallo GTID.
*start\$1pos*
Posizione iniziale dell’intervallo GTID da impostare.
*end\$1pos*
Posizione finale dell’intervallo GTID da impostare.
### Note per l’utilizzo
La procedura `mysql.rds_set_external_source_gtid_purged` è disponibile solo con MySQL 8.0.37 e versioni successive alla 8.0.
Chiama `mysql.rds_set_external_source_gtid_purged` prima di chiamare [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS per MySQL versioni principali 8.0 e precedenti)](#mysql_rds_set_external_master_with_auto_position), [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS per MySQL versioni principali 8.4 e successive)](#mysql_rds_set_external_source_with_auto_position) o [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).
Prima di chiamare `mysql.rds_set_external_source_gtid_purged`, assicurati di arrestare tutti i canali di replica attivi per il database. Per controllare lo stato di un canale, usa l’istruzione `SHOW REPLICA STATUS` MySQL. Per arrestare la replica su un canale, chiama [mysql.rds\$1stop\$1replication\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_stop_replication_for_channel).
L’intervallo GTID specificato deve essere un superset del valore `GTID_PURGED` esistente. Prima di impostare il valore `GTID_PURGED`, la stored procedure esegue i controlli seguenti:
+ `server_uuid` deve essere valido.
+ Il valore di `start_pos` deve essere maggiore di `0` e minore del valore di `end_pos`.
+ Il valore di `end_pos` deve essere maggiore di o uguale al valore di `start_pos`.
Se il GTID impostato sul server esterno contiene più intervalli di valori, prendi in considerazione la possibilità di chiamare la procedura più volte con valori di GTID diversi.
Quando si chiama `mysql.rds_set_external_source_gtid_purged`, Amazon RDS registra l’ora, l’utente e un’operazione `set gtid_purged` nella tabella `mysql.rds_history`.
L’impostazione non appropriata del valore `gtid_purged` per il backup utilizzato per la replica può comportare transazioni mancanti o duplicate durante il processo di replica. Per impostare il valore `gtid_purged` corretto, esegui queste operazioni.
**Per impostare il valore gtid\$1purged nella replica**
1. Determina il punto temporale o il file di backup specifico da utilizzare come punto di partenza per la replica. Potrebbe trattarsi di un backup logico (file mysqldump) o di un backup fisico (snapshot Amazon RDS).
1. Determina il valore `gtid_executed`. Questo valore rappresenta l'insieme di tutto ciò GTIDs che è stato eseguito sul server. Per recuperare questo valore, sull’istanza di origine, procedi in uno dei modi seguenti:
+ Esegui l’istruzione SQL `SELECT @@GLOBAL.GTID_EXECUTED;` nel momento in cui è stato eseguito il backup.
+ Se nella rispettiva utilità di backup sono incluse opzioni correlate, estrai il valore dal file di backup. Per ulteriori informazioni, consulta l'[set-gtid-purged](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html#option_mysqldump_set-gtid-purged)opzione nella documentazione di MySQL.
1. Determina il valore `gtid_purged` da utilizzare per la chiamata a `mysql.rds_set_external_source_gtid_purged`. Il `gtid_purged` valore dovrebbe includere tutto ciò GTIDs che è stato eseguito sull'istanza di origine e non è più necessario per la replica. Di conseguenza, il valore `gtid_purged` deve essere un sottoinsieme del valore `gtid_executed` ottenuto nel passaggio precedente.
Per determinare il `gtid_purged` valore, identifica quelli GTIDs che non sono inclusi nel backup e non sono più necessari per la replica. È possibile farlo analizzando i log binari o utilizzando uno strumento come mysqlbinlog per trovare quelli che sono stati eliminati dai log binari. GTIDs
In alternativa, se si dispone di un backup coerente che include tutti i log binari fino al punto di backup, è possibile impostare il valore `gtid_purged` in modo che sia uguale al valore `gtid_executed` nel punto di backup.
1. Dopo aver determinato il valore `gtid_purged` appropriato coerente con il backup, chiama la stored procedure `mysql.rds_set_external_source_gtid_purged` nell’istanza database RDS per MySQL per impostare il valore.
### Esempi
Se eseguito in un’istanza database MySQL, l’esempio seguente imposta l’intervallo GTID da un server MySQL esterno con l’UUID `12345678-abcd-1234-efgh-123456789abc`, una posizione iniziale di `1` e una posizione finale di `100`. Il valore GTID risultante è impostato su `+12345678-abcd-1234-efgh-123456789abc:1-100`.
```
CALL mysql.rds_set_external_source_gtid_purged('12345678-abcd-1234-efgh-123456789abc', 1, 100);
```
##
Imposta la modalità di replica in modo che sia basata sulle posizioni dei file di registro binari o sugli identificatori globali delle transazioni (). GTIDs
### Sintassi
```
CALL mysql.rds_set_master_auto_position (
auto_position_mode
);
```
### Parameters
*auto\$1position\$1mode*
Valore che indica se usare la replica basata sulla posizione del file di log o la replica basata su GTID:
+ `0` – Usa il metodo di replica basato sulla posizione del file di log binario. Il valore di default è `0`.
+ `1` – Usa il metodo di replica basato su GTID.
### Note per l’utilizzo
La procedura `mysql.rds_set_master_auto_position` deve essere eseguita dall’utente master.
Questa procedura è supportata per tutte le versioni di RDS per MySQL 5.7 e per RDS per MySQL 8.0.26 e versioni successive alla 8.0.
## mysql.rds\$1set\$1source\$1auto\$1position (RDS per MySQL versioni principali 8.4 e successive)
Imposta la modalità di replica in modo che sia basata sulle posizioni dei file di registro binari o sugli identificatori globali delle transazioni (). GTIDs
### Sintassi
```
CALL mysql.rds_set_source_auto_position (auto_position_mode);
```
### Parameters
*auto\$1position\$1mode*
Valore che indica se usare la replica basata sulla posizione del file di log o la replica basata su GTID:
+ `0` – Usa il metodo di replica basato sulla posizione del file di log binario. Il valore di default è `0`.
+ `1` – Usa il metodo di replica basato su GTID.
### Note per l'utilizzo
L'utente amministrativo deve eseguire la procedura `mysql.rds_set_source_auto_position`.
## mysql.rds\$1set\$1source\$1delay
Imposta il numero minimo di secondi per ritardare la replica dall'istanza database di origine alla replica di lettura corrente. Usa questa procedura in presenza di una connessione a una replica di lettura per ritardare la replica rispetto all’istanza database di origine.
### Sintassi
```
CALL mysql.rds_set_source_delay(
delay
);
```
### Parameters
*delay*
Numero minimo di secondi per ritardare la replica dall'istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
### Note per l’utilizzo
La procedura `mysql.rds_set_source_delay` deve essere eseguita dall'utente master.
Per il disaster recovery puoi usare questa procedura con la stored procedure [](#mysql_rds_start_replication_until) o [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore, puoi eseguire la procedura `mysql.rds_set_source_delay`. Dopo che la procedura `mysql.rds_start_replication_until` o `mysql.rds_start_replication_until_gtid` arresta la replica, puoi promuovere la replica di lettura come nuova istanza database master seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Per usare la procedura `mysql.rds_rds_start_replication_until_gtid`, è necessario che sia abilitata la replica basata su GTID. Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la stored procedure [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Per ulteriori informazioni sulla replica basata su GTID, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
La procedura `mysql.rds_set_source_delay` è disponibile nelle seguenti versioni di RDS for MySQL:
+ Tutte le versioni di RDS per MySQL 8.4
+ MySQL 8.0.26 e versioni successive alla 8.0
+ Tutte le versioni 5.7
### Esempi
Per ritardare la replica rispetto all’istanza database di origine nella replica di lettura corrente per almeno un'ora (3600 secondi), puoi chiamare `mysql.rds_set_source_delay` con il parametro seguente:
```
CALL mysql.rds_set_source_delay(3600);
```
## mysql.rds\$1skip\$1repl\$1error
Ignora ed elimina un errore di replica su una replica di lettura database MySQL.
### Sintassi
```
CALL mysql.rds_skip_repl_error;
```
### Note per l’utilizzo
La procedura `mysql.rds_skip_repl_error` deve essere eseguita dall'utente master su una replica di lettura. Per ulteriori informazioni su questa procedura, consulta [Chiamata della procedura mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
Per determinare se ci sono errori, esegui il comando MySQL `SHOW REPLICA STATUS\G`. Se un errore di replica non è critico, puoi eseguire `mysql.rds_skip_repl_error` per ignorare l'errore. Se vi sono più errori, `mysql.rds_skip_repl_error` elimina il primo, quindi informa della presenza di altri errori. Puoi quindi utilizzare `SHOW REPLICA STATUS\G` per determinare l'operazione corretta per l'errore successivo. Per informazioni sui valori restituiti, consulta [Istruzione SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) nella documentazione di MySQL.
Per ulteriori informazioni sulla risoluzione degli errori di replica con Amazon RDS, consulta [Risoluzione dei problemi relativi a una replica di lettura MySQL](USER_ReadRepl.Troubleshooting.md).
#### Errore di replica interrotta
Quando si chiama la procedura `mysql.rds_skip_repl_error`, è possibile che venga visualizzato un messaggio di errore che indica che la replica è inattiva o disattivata.
Questo messaggio di errore viene visualizzato se si esegue la procedura sull'istanza primaria anziché sulla replica di lettura. È necessario eseguire questa procedura sulla replica di lettura affinché funzioni.
Questo messaggio di errore può essere visualizzato anche quando si esegue la procedura sulla replica di lettura, ma la replica non viene riavviata correttamente.
Se devi ignorare un numero elevato di errori, il ritardo della replica potrebbe superare il periodo di retention predefinito per i file di log binari (binlog). In questo caso può verificarsi un errore irreversibile causato dall’eliminazione dei file binlog prima della loro riproduzione nella replica di lettura. Questa eliminazione causa l'arresto della replica e non è più possibile chiamare il comando `mysql.rds_skip_repl_error` per ignorare errori di replica.
Puoi limitare questo problema aumentando il numero di ore di retention dei file binlog nell’istanza database di origine. Una volta aumentato il tempo di retention dei file binlog, puoi riavviare la replica e chiamare il comando `mysql.rds_skip_repl_error` secondo necessità.
Per impostare il periodo di retention dei file binlog, usa la procedura [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) e specifica un parametro di configurazione di `'binlog retention hours'` insieme al numero di ore di retention dei file binlog nel cluster di database. Nell'esempio seguente il periodo di retention dei file binlog è impostato su 48 ore.
```
CALL mysql.rds_set_configuration('binlog retention hours', 48);
```
## mysql.rds\$1start\$1replication
Avvia la replica da un'istanza database RDS per MySQL.
**Nota**
Puoi usare la stored procedure [](#mysql_rds_start_replication_until) o [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) per avviare la replica da un'istanza database RDS per MySQL e arrestare la replica in corrispondenza della posizione del file di log binario specificato.
### Sintassi
```
CALL mysql.rds_start_replication;
```
### Note per l’utilizzo
La procedura `mysql.rds_start_replication` deve essere eseguita dall’utente master.
Per importare dati da un’istanza MySQL in esecuzione all’esterno di Amazon RDS, chiama `mysql.rds_start_replication` nella replica di lettura per avviare il processo di replica dopo aver chiamato [mysql.rds\$1set\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](#mysql_rds_set_external_master) o [mysql.rds\$1set\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)](#mysql_rds_set_external_source) per creare la configurazione della replica. Per ulteriori informazioni, consulta [Ripristino di un backup in un’istanza database Amazon RDS per MySQL](MySQL.Procedural.Importing.md).
Per esportare dati in un'istanza di MySQL in esecuzione all'esterno di Amazon RDS, devi chiamare `mysql.rds_start_replication` e `mysql.rds_stop_replication` nella replica di lettura per controllare alcune operazioni di replica, come l'eliminazione di log binari. Per ulteriori informazioni, consulta [Esportazione di dati da un'istanza database MySQL tramite la replica](MySQL.Procedural.Exporting.NonRDSRepl.md).
Puoi anche chiamare `mysql.rds_start_replication` nella replica di lettura per riavviare un processo di replica arrestato in precedenza chiamando `mysql.rds_stop_replication`. Per ulteriori informazioni, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
##
Avvia la replica da un'istanza database RDS per MySQL e la arresta in corrispondenza della posizione del file di log binario specificato.
### Sintassi
```
CALL mysql.rds_start_replication_until (
replication_log_file
, replication_stop_point
);
```
### Parameters
*replication\$1log\$1file*
Il nome del log binario sull’istanza database di origine che contiene le informazioni relative alla replica.
*replication\$1stop\$1point *
Posizione nel log binario `replication_log_file` in corrispondenza di cui la replica verrà arrestata.
### Note per l’utilizzo
La procedura `mysql.rds_start_replication_until` deve essere eseguita dall'utente master.
La procedura `mysql.rds_start_replication_until` è disponibile nelle seguenti versioni di RDS for MySQL:
+ Tutte le versioni di RDS per MySQL 8.4
+ MySQL 8.0.26 e versioni successive alla 8.0
+ Tutte le versioni 5.7
Puoi usare questa procedura archiviata con la replica ritardata per il disaster recovery. Se hai configurato la replica ritardata, puoi usare questa procedura archiviata per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore. Dopo che questa procedura archiviata arresta la replica, puoi promuovere la replica di lettura come nuova istanza database primaria seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Puoi configurare la replica ritardata usando le procedure archiviate seguenti:
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS per MySQL versioni principali 8.4 e successive)](#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](#mysql_rds_set_source_delay)
Il nome file specificato per il parametro `replication_log_file` deve corrispondere al nome file binlog dell'istanza database di origine.
Quando il parametro `replication_stop_point` specifica una posizione di arresto nel passato, la replica viene arrestata immediatamente.
### Esempi
L'esempio seguente avvia la replica e replica le modifiche fino a raggiungere la posizione `120` nel file di log binario `mysql-bin-changelog.000777`.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
## mysql.rds\$1stop\$1replication
Arresta la replica da un'istanza database MySQL.
### Sintassi
```
CALL mysql.rds_stop_replication;
```
### Note per l’utilizzo
La procedura `mysql.rds_stop_replication` deve essere eseguita dall'utente master.
Se configuri la replica per importare dati da un'istanza di MySQL in esecuzione all'esterno di Amazon RDS, puoi chiamare `mysql.rds_stop_replication` nella replica di lettura per arrestare il processo di replica al termine dell'importazione. Per ulteriori informazioni, consulta [Ripristino di un backup in un’istanza database Amazon RDS per MySQL](MySQL.Procedural.Importing.md).
Se configuri la replica per esportare dati in un'istanza di MySQL esterna ad Amazon RDS, devi chiamare `mysql.rds_start_replication` e `mysql.rds_stop_replication` nella replica di lettura per controllare alcune operazioni di replica, come l'eliminazione di log binari. Per ulteriori informazioni, consulta [Esportazione di dati da un'istanza database MySQL tramite la replica](MySQL.Procedural.Exporting.NonRDSRepl.md).
Puoi usare `mysql.rds_stop_replication` anche per arrestare la replica tra due istanze database Amazon RDS. In genere si arresta una replica per eseguire un'operazione di lunga durata nella replica di lettura, come la creazione di un indice di grandi dimensioni nella replica di lettura. Puoi riavviare qualsiasi processo di replica arrestato chiamando [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) nella replica di lettura. Per ulteriori informazioni, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
# Terminare una sessione o una query
Le seguenti stored procedure terminano una sessione o una query.
**Topics**
+ [
## mysql.rds\$1kill
](#mysql_rds_kill)
+ [
## mysql.rds\$1kill\$1query
](#mysql_rds_kill_query)
## mysql.rds\$1kill
Termina una connessione al server MySQL.
### Sintassi
```
CALL mysql.rds_kill(processID);
```
### Parametri
*processID*
L'identità del thread di connessione da terminare.
### Note per l'utilizzo
Ogni connessione al server MySQL viene eseguita in un thread distinto. Per terminare una connessione, utilizza la procedura `mysql.rds_kill` e passa l'ID di thread di quella connessione. Per ottenere l'ID di thread, utilizza il comando MySQL [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html).
Per informazioni sulle limitazioni, consulta [Limitazioni delle stored procedure di MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Esempi
L'esempio seguente termina una connessione con l'ID di thread 4243:
```
CALL mysql.rds_kill(4243);
```
## mysql.rds\$1kill\$1query
Termina una query in esecuzione sul server MySQL.
### Sintassi
```
CALL mysql.rds_kill_query(processID);
```
### Parametri
*processID*
L'identità del processo o del thread che esegue la query da terminare.
### Note per l'utilizzo
Per arrestare una query in esecuzione nel server MySQL, utilizza la procedura `mysql_rds_kill_query` e invia l'ID di connessione del thread che sta eseguendo la query. La procedura termina quindi la connessione.
Per ottenere l'ID, esegui una query sulla [tabella INFORMATION\$1SCHEMA PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/information-schema-processlist-table.html) MySQL o utilizza il comando MySQL [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html). Il valore nella colonna ID da `SHOW PROCESSLIST` o `SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST` è *processID*.
Per informazioni sulle limitazioni, consulta [Limitazioni delle stored procedure di MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Esempi
L'esempio seguente arresta una query con l'ID di thread di query 230040:
```
CALL mysql.rds_kill_query(230040);
```
# Gestione di cluster attivi-attivi
Le stored procedure seguenti configurano e gestiscono i cluster attivi-attivi RDS per MySQL. Per ulteriori informazioni, consulta [Configurazione di cluster attivi-attivi in RDS per MySQL](mysql-active-active-clusters.md).
Tali stored procedure sono disponibili solo con le istanze database RDS per MySQL che eseguono le versioni seguenti:
+ Tutte le versioni di MySQL 8.4
+ MySQL 8.0.35 e versioni secondarie successive
**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
Crea GTID segnaposto sull’istanza database corrente.
### Sintassi
```
CALL mysql.rds_group_replication_advance_gtid(
begin_id
, end_id
, server_uuid
);
```
### Parametri
*begin\$1id*
ID della transazione iniziale da creare.
*end\$1id*
ID della transazione finale da creare.
*begin\$1id*
`group_replication_group_name` della transazione da creare. `group_replication_group_name` è specificato come UUID nel gruppo di parametri di database associato all’istanza database.
### Note per l'utilizzo
In un cluster attivo-attivo, affinché un’istanza database possa unirsi a un gruppo, tutte le transazioni GTID eseguite nella nuova istanza database devono esistere negli altri membri del cluster. In casi insoliti, per una nuova istanza database potrebbero esistere più transazioni quando queste ultime sono eseguite prima di aggiungere l’istanza al gruppo. In questo caso, non è possibile rimuovere alcuna transazione esistente, ma si può utilizzare questa procedura per creare i GTID segnaposto corrispondenti nelle altre istanze database del gruppo. Prima di eseguire questa operazione, verificare che le transazioni *non influiscano sui dati replicati*.
Quando si chiama questa procedura, le transazioni GTID di `server_uuid:begin_id-end_id` vengono create con contenuto vuoto. Per evitare problemi di replica, non utilizzare questa procedura in altre condizioni.
**Importante**
Evitare di chiamare la procedura quando il cluster attivo-attivo funziona normalmente. Non chiamare questa procedura se non si comprendono le possibili conseguenze delle transazioni in fase di creazione. Quando si chiama questa procedura, è possibile che vengano generati dati non coerenti.
### Esempio
L’esempio seguente crea GTID segnaposto sull’istanza database corrente:
```
CALL mysql.rds_group_replication_advance_gtid(5, 6, '11111111-2222-3333-4444-555555555555');
```
## mysql.rds\$1group\$1replication\$1create\$1user
Crea l’utente di replica `rdsgrprepladmin` per la replica di gruppo nell’istanza database.
### Sintassi
```
CALL mysql.rds_group_replication_create_user(
replication_user_password
);
```
### Parametri
*replication\$1user\$1password*
Password dell’utente di replica `rdsgrprepladmin`.
### Note per l'utilizzo
+ La password dell’utente di replica `rdsgrprepladmin` deve essere la stessa su tutte le istanze database di un cluster attivo-attivo.
+ Il nome utente `rdsgrprepladmin` è riservato per le connessioni di replica di gruppo e non può essere assegnato ad alcun altro utente, incluso l’utente master.
### Esempio
L’esempio seguente crea l’utente di replica `rdsgrprepladmin` per la replica di gruppo sull’istanza database:
```
CALL mysql.rds_group_replication_create_user('password');
```
## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
Imposta il canale `group_replication_recovery` per un cluster attivo-attivo. La procedura utilizza l’utente `rdsgrprepladmin` riservato per configurare il canale.
### Sintassi
```
CALL mysql.rds_group_replication_set_recovery_channel(
replication_user_password);
```
### Parametri
*replication\$1user\$1password*
Password dell’utente di replica `rdsgrprepladmin`.
### Note per l'utilizzo
La password dell’utente di replica `rdsgrprepladmin` deve essere la stessa su tutte le istanze database di un cluster attivo-attivo. Una chiamata a `mysql.rds_group_replication_create_user` specifica la password.
### Esempio
L’esempio seguente imposta il canale `group_replication_recovery` per un cluster attivo-attivo:
```
CALL mysql.rds_group_replication_set_recovery_channel('password');
```
## mysql.rds\$1group\$1replication\$1start
Avvia la replica di gruppo sull’istanza database corrente.
### Sintassi
```
CALL mysql.rds_group_replication_start(
bootstrap
);
```
### Parametri
*bootstrap*
Valore che specifica se inizializzare un nuovo gruppo o unirsi a un gruppo esistente. `1` inizializza un nuovo gruppo con l’istanza database corrente. `0` unisce l’istanza database corrente a un gruppo esistente connettendosi agli endpoint definiti nel parametro `group_replication_group_seeds` del gruppo di parametri di database associato all’istanza database.
### Esempio
L’esempio seguente inizializza un nuovo gruppo con l’istanza database corrente:
```
CALL mysql.rds_group_replication_start(1);
```
## mysql.rds\$1group\$1replication\$1stop
Arresta la replica di gruppo sull’istanza database corrente.
### Sintassi
```
CALL mysql.rds_group_replication_stop();
```
### Note per l'utilizzo
L’arresto di una replica su un’istanza database non influisce su alcun’altra istanza database nel cluster attivo-attivo.
# Gestione della replica da più origini
Le stored procedure seguenti configurano e gestiscono i canali di replica su una replica da più origini RDS per MySQL. Per ulteriori informazioni, consulta [Configurazione multi-source-replication per Amazon RDS for MySQL](mysql-multi-source-replication.md).
Tali stored procedure sono disponibili solo con le istanze database RDS per MySQL che eseguono le versioni del motore seguenti:
+ Tutte le versioni 8.4
+ 8.0.35 e versioni secondarie successive
+ 5.7.44 e versioni secondarie successive
Quando si utilizzano queste stored procedure per gestire la replica con un utente di replica configurato con `caching_sha2_passwword`, è necessario configurare TLS specificando `SOURCE_SSL=1`. `caching_sha2_password` è il plugin di autenticazione predefinito per RDS per MySQL 8.4.
**Nota**
Sebbene questa documentazione faccia riferimento alle istanze database di origine, ad esempio le istanze database RDS per MySQL, queste procedure funzionano anche per le istanze MySQL eseguite esternamente ad 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
Cambia la posizione del log dell’istanza database di origine all’inizio del successivo log binario nell’istanza database di origine per il canale. Utilizza questa procedura solo se ricevi un errore I/O di replica 1236 su una replica da più origini.
### Sintassi
```
CALL mysql.rds_next_source_log_for_channel(
curr_master_log,
channel_name
);
```
### Parametri
*curr\$1master\$1log*
L'indice del file di log di origine corrente. Ad esempio, se il file corrente è denominato `mysql-bin-changelog.012345`, l'indice è 12345. Per determinare il nome del file di log di origine corrente, esegui il comando `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'` e visualizza il campo `Source_Log_File`.
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_next_source_log_for_channel` deve essere eseguita dall'utente master. Se si verifica un errore IO\$1Thread, ad esempio, è possibile utilizzare questa procedura per ignorare tutti gli eventi nel file di log binario corrente e riprendere la replica dal file di log binario successivo per il canale specificato in `channel_name`.
### Esempio
Supponiamo che si verifichi un errore di replica su un canale per una replica da più origini. L’esecuzione di `SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G` nella replica da più origini restituisce il risultato seguente:
```
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
```
Il campo `Last_IO_Errno` mostra che l'istanza riceve l'errore I/O 1236. Il campo `Source_Log_File` mostra che il nome di file è `mysql-bin-changelog.012345`, il che significa che l'indice del file di log è `12345`. Per risolvere il problema, puoi chiamare `mysql.rds_next_source_log_for_channel` con i parametri seguenti:
```
CALL mysql.rds_next_source_log_for_channel(12345,'channel_1');
```
## mysql.rds\$1reset\$1external\$1source\$1for\$1channel
Arresta il processo di replica sul canale specificato e rimuove il canale e le configurazioni associate dalla replica da più origini.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
CALL mysql.rds_reset_external_source_for_channel (channel_name);
```
### Parametri
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_reset_external_source_for_channel` deve essere eseguita dall'utente master. Questa procedura elimina tutti i log di inoltro che appartengono al canale da rimuovere.
## mysql.rds\$1set\$1external\$1source\$1for\$1channel
Configura un canale di replica su un’istanza database RDS per MySQL per replicare i dati da un’altra istanza database RDS per MySQL.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
**Nota**
È possibile utilizzare invece la stored procedure [mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel](#mysql_rds_set_external_source_with_delay_for_channel) per configurare questo canale con la replica ritardata.
### Sintassi
```
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
);
```
### Parametri
*host\$1name*
Nome host o indirizzo IP dell’istanza database RDS per MySQL di origine.
*host\$1port*
Porta utilizzata dall’istanza database RDS per MySQL di origine. Se la configurazione della rete include la replica della porta Secure Shell (SSH) che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell’istanza database RDS per MySQL di origine. Si consiglia di fornire un account utilizzato unicamente per la replica con l’istanza database di origine.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nome del log binario sull’istanza database di origine che contiene le informazioni relative alla replica.
*mysql\$1binary\$1log\$1file\$1location*
La posizione nel log binario `mysql_binary_log_file_name` a partire dalla quale la replica inizia a leggere le informazioni a essa relative.
È possibile determinare il nome e la posizione del file binlog eseguendo `SHOW BINARY LOG STATUS` nell’istanza database di origine.
Versioni precedenti di MySQL utilizzate `SHOW MASTER STATUS` al posto di `SHOW BINARY LOG STATUS`. Se si utilizza una versione MySQL precedente alla 8.4, utilizzare `SHOW MASTER STATUS`.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L'opzione `SOURCE_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
*channel\$1name*
Nome del canale di replica. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_set_external_source_for_channel` deve essere eseguita dall'utente master. Questa procedura deve essere eseguita sull’istanza database RDS per MySQL di destinazione su cui si crea il canale di replica.
Prima di eseguire `mysql.rds_set_external_source_for_channel`, configura un utente di replica sull’istanza database di origine con i privilegi richiesti per la replica da più origini. Per connettere la replica da più origini all’istanza database di origine, è necessario specificare i valori `replication_user_name` e `replication_user_password` di un utente di replica con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell’istanza database di origine.
**Per configurare un utente di replica nell’istanza database di origine**
1. Utilizzando il client MySQL scelto, esegui la connessione all’istanza database di origine e crea un utente da utilizzare per la replica. Di seguito è riportato un esempio.
**Importante**
Come best practice per la sicurezza, specificare una password diversa dal valore segnaposto mostrato negli esempi seguenti.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Nell’istanza database di origine, concedi i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all’utente di replica. L'esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente "repl\$1user" del dominio:
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Per utilizzare la replica crittografata, configura l’istanza database di origine per utilizzare le connessioni SSL.
Dopo aver chiamato `mysql.rds_set_external_source_for_channel` per configurare il canale di replica, è possibile chiamare [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) sulla replica per avviare il processo di replica sul canale. È anche possibile chiamare [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) per arrestare la replica sul canale e rimuovere la configurazione del canale dalla replica.
Quando si chiama `mysql.rds_set_external_source_for_channel`, Amazon RDS registra l’ora, l’utente e un’operazione di `set channel source` nella tabella `mysql.rds_history` senza dettagli specifici del canale e nella tabella `mysql.rds_replication_status` con il nome del canale. Queste informazioni vengono registrate solo per uso interno e a scopo di monitoraggio. Per registrare l’intera chiamata di procedura ai fini di audit, prendi in considerazione la possibilità di abilitare i log di audit o i log generali, in base ai requisiti specifici dell’applicazione.
### Esempi
Se eseguito in un’istanza database RDS per MySQL, l’esempio seguente configura un canale di replica denominato `channel_1` sull’istanza database per replicare i dati dall’origine specificata dall’host `sourcedb.example.com` e dalla porta `3306`.
```
call mysql.rds_set_external_source_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
0,
'channel_1');
```
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel
Configura un canale di replica su un’istanza database RDS per MySQL con un ritardo di replica facoltativo. La replica si basa sugli ID di transazione globali (GTID).
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
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
);
```
### Parametri
*host\$1name*
Nome host o indirizzo IP dell’istanza database RDS per MySQL di origine.
*host\$1port*
Porta utilizzata dall’istanza database RDS per MySQL di origine. Se la configurazione della rete include la replica della porta Secure Shell (SSH) che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell’istanza database RDS per MySQL di origine. Si consiglia di fornire un account utilizzato unicamente per la replica con l’istanza database di origine.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L'opzione `SOURCE_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
*delay*
Numero minimo di secondi per ritardare la replica dall’istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
*channel\$1name*
Nome del canale di replica. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_set_external_source_with_auto_position_for_channel` deve essere eseguita dall'utente master. Questa procedura deve essere eseguita sull’istanza database RDS per MySQL di destinazione su cui si crea il canale di replica.
Prima di eseguire `rds_set_external_source_with_auto_position_for_channel`, configura un utente di replica sull’istanza database di origine con i privilegi richiesti per la replica da più origini. Per connettere la replica da più origini all’istanza database di origine, è necessario specificare i valori `replication_user_name` e `replication_user_password` di un utente di replica con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell’istanza database di origine.
**Per configurare un utente di replica nell’istanza database di origine**
1. Utilizzando il client MySQL scelto, esegui la connessione all’istanza database di origine e crea un utente da utilizzare per la replica. Di seguito è riportato un esempio.
**Importante**
Come best practice per la sicurezza, specificare una password diversa dal valore segnaposto mostrato negli esempi seguenti.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Nell’istanza database di origine, concedi i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all’utente di replica. L'esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente "repl\$1user" del dominio:
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Per utilizzare la replica crittografata, configura l’istanza database di origine per utilizzare le connessioni SSL.
Prima di chiamare `mysql.rds_set_external_source_with_auto_position_for_channel`, assicurati di chiamare [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_gtid_purged) per impostare la variabile di sistema `gtid_purged` con un intervallo di GTID specificato da un’origine esterna.
Dopo aver chiamato `mysql.rds_set_external_source_with_auto_position_for_channel` per configurare un’istanza database di Amazon RDS come replica di lettura su un canale specifico, è possibile chiamare [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) nella replica di lettura per avviare il processo di replica su tale canale.
Dopo aver chiamato `mysql.rds_set_external_source_with_auto_position_for_channel` per configurare il canale di replica, è possibile chiamare [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) sulla replica per avviare il processo di replica sul canale. È anche possibile chiamare [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) per arrestare la replica sul canale e rimuovere la configurazione del canale dalla replica.
### Esempi
Se eseguito in un’istanza database RDS per MySQL, l’esempio seguente configura un canale di replica `channel_1` denominato su questa istanza database per replicare i dati dall’origine specificata dall’host `sourcedb.example.com` e dalla porta `3306`. Il ritardo minimo di replica viene impostato a un’ora (3.600 secondi). Ciò significa che una modifica dall’istanza database RDS per MySQL di origine non viene applicata nella replica da più origini per almeno un’ora.
```
call mysql.rds_set_external_source_with_auto_position_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
1,
3600,
'channel_1');
```
## mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel
Configura un canale di replica su un’istanza database RDS per MySQL con un ritardo di replica facoltativo.
**Importante**
Per eseguire questa procedura, è necessario abilitare `autocommit`. Per abilitarlo, impostare il parametro `autocommit` su `1`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Sintassi
```
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
);
```
### Parametri
*host\$1name*
Nome host o indirizzo IP dell’istanza database RDS per MySQL di origine.
*host\$1port*
Porta utilizzata dall’istanza database RDS per MySQL di origine. Se la configurazione della rete include la replica della porta Secure Shell (SSH) che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
ID di un utente con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell’istanza database RDS per MySQL di origine. Si consiglia di fornire un account utilizzato unicamente per la replica con l’istanza database di origine.
*replication\$1user\$1password*
La password dell'ID utente specificata in `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Il nome del log binario sull’istanza database di origine contiene le informazioni relative alla replica.
*mysql\$1binary\$1log\$1file\$1location*
Posizione nel log binario `mysql_binary_log_file_name` a partire dalla quale la replica inizierà a leggere le informazioni di replica.
È possibile determinare il nome e la posizione del file binlog in esecuzione `SHOW BINARY LOG STATUS` sull'istanza del database di origine.
Versioni precedenti di MySQL utilizzate `SHOW MASTER STATUS` al posto di `SHOW BINARY LOG STATUS`. Se si utilizza una versione MySQL precedente alla 8.4, utilizzare `SHOW MASTER STATUS`.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L'opzione `SOURCE_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
*delay*
Numero minimo di secondi per ritardare la replica dall’istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
*channel\$1name*
Nome del canale di replica. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_set_external_source_with_delay_for_channel` deve essere eseguita dall'utente master. Questa procedura deve essere eseguita sull’istanza database RDS per MySQL di destinazione su cui si crea il canale di replica.
Prima di eseguire `mysql.rds_set_external_source_with_delay_for_channel`, configura un utente di replica sull’istanza database di origine con i privilegi richiesti per la replica da più origini. Per connettere la replica da più origini all’istanza database di origine, è necessario specificare i valori `replication_user_name` e `replication_user_password` di un utente di replica con autorizzazioni `REPLICATION CLIENT` e `REPLICATION SLAVE` nell’istanza database di origine.
**Per configurare un utente di replica nell’istanza database di origine**
1. Utilizzando il client MySQL scelto, esegui la connessione all’istanza database di origine e crea un utente da utilizzare per la replica. Di seguito è riportato un esempio.
**Importante**
Come best practice per la sicurezza, specificare una password diversa dal valore segnaposto mostrato negli esempi seguenti.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Nell’istanza database di origine, concedi i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all’utente di replica. L'esempio seguente concede i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente "repl\$1user" del dominio:
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Per utilizzare la replica crittografata, configura l’istanza database di origine per utilizzare le connessioni SSL.
Dopo aver chiamato `mysql.rds_set_external_source_with_delay_for_channel` per configurare il canale di replica, è possibile chiamare [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) sulla replica per avviare il processo di replica sul canale. È anche possibile chiamare [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) per arrestare la replica sul canale e rimuovere la configurazione del canale dalla replica.
Quando si chiama `mysql.rds_set_external_source_with_delay_for_channel`, Amazon RDS registra l’ora, l’utente e un’operazione di `set channel source` nella tabella `mysql.rds_history` senza dettagli specifici del canale e nella tabella `mysql.rds_replication_status` con il nome del canale. Queste informazioni vengono registrate solo per uso interno e a scopo di monitoraggio. Per registrare l’intera chiamata di procedura ai fini di audit, prendi in considerazione la possibilità di abilitare i log di audit o i log generali, in base ai requisiti specifici dell’applicazione.
### Esempi
Se eseguito in un’istanza database RDS per MySQL, l’esempio seguente configura un canale di replica `channel_1` denominato su questa istanza database per replicare i dati dall’origine specificata dall’host `sourcedb.example.com` e dalla porta `3306`. Il ritardo minimo di replica viene impostato a un’ora (3.600 secondi). Ciò significa che una modifica dall’istanza database RDS per MySQL di origine non viene applicata nella replica da più origini per almeno un’ora.
```
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
Imposta la modalità di replica in modo che sia basata sulle posizioni dei file di log binario o sugli ID di transazione globali (GTID).
### Sintassi
```
CALL mysql.rds_set_source_auto_position_for_channel (
auto_position_mode
, channel_name
);
```
### Parametri
*auto\$1position\$1mode*
Valore che indica se usare la replica basata sulla posizione del file di log o la replica basata su GTID:
+ `0` – Usa il metodo di replica basato sulla posizione del file di log binario. Il valore di default è `0`.
+ `1` – Usa il metodo di replica basato su GTID.
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_set_source_auto_position_for_channel` deve essere eseguita dall'utente master. Questa procedura riavvia la replica sul canale specificato per applicare la modalità di posizionamento automatico specificata.
### Esempi
L’esempio seguente imposta la modalità di posizionamento automatico per channel\$11 per utilizzare il metodo di replica basato su GTID.
```
call mysql.rds_set_source_auto_position_for_channel(1,'channel_1');
```
## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
Imposta il numero minimo di secondi per ritardare la replica dall’istanza database di origine alla replica da più origini per il canale specificato.
### Sintassi
```
CALL mysql.rds_set_source_delay_for_channel(delay, channel_name);
```
### Parametri
*delay*
Numero minimo di secondi per ritardare la replica dall’istanza database di origine.
Il limite per questo parametro è un giorno (86400 secondi).
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_set_source_delay_for_channel` deve essere eseguita dall'utente master. Per utilizzare questa procedura, chiama prima `mysql.rds_stop_replication_for_channel` per arrestare la replica, quindi chiama la procedura per impostare il valore del ritardo di replica. Quando il ritardo è impostato, chiama `mysql.rds_start_replication_for_channel` per riavviare la replica.
### Esempi
L’esempio seguente imposta il ritardo per la replica dall’istanza database di origine su `channel_1` della replica da più origini per almeno un’ora (3.600 secondi).
```
CALL mysql.rds_set_source_delay_for_channel(3600,'channel_1');
```
## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
Ignora un evento del log binario ed elimina un errore di replica su una replica database MySQL da più origini per il canale specificato.
### Sintassi
```
CALL mysql.rds_skip_repl_error_for_channel(channel_name);
```
### Parametri
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_skip_repl_error_for_channel` deve essere eseguita dall'utente master su una replica di lettura. È possibile utilizzare questa procedura in modo analogo a come si utilizza `mysql.rds_skip_repl_error` per evitare un errore in una replica di lettura. Per ulteriori informazioni, consulta [Chiamata della procedura mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
**Nota**
Per evitare errori nella replica basata su GTID, si consiglia di utilizzare invece la procedura [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid).
Per determinare se ci sono errori, esegui il comando MySQL `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G`. Se un errore di replica non è critico, puoi eseguire `mysql.rds_skip_repl_error_for_channel` per ignorare l'errore. Se sono presenti più errori, `mysql.rds_skip_repl_error_for_channel` elimina il primo sul canale di replica specificato, quindi informa della presenza di altri errori. Puoi quindi utilizzare `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` per determinare l'operazione corretta per l'errore successivo. Per informazioni sui valori restituiti, consulta [Istruzione SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) nella documentazione di MySQL.
## mysql.rds\$1start\$1replication\$1for\$1channel
Avvia la replica da un’istanza database RDS per MySQL a una replica da più origini sul canale specificato.
**Nota**
Puoi usare la stored procedure [mysql.rds\$1start\$1replication\$1until\$1for\$1channel](#mysql_rds_start_replication_until_for_channel) o [mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel](#mysql_rds_start_replication_until_gtid_for_channel) per avviare la replica da un'istanza database RDS for MySQL e arrestare la replica in corrispondenza della posizione del file di log binario specificato.
### Sintassi
```
CALL mysql.rds_start_replication_for_channel(channel_name);
```
### Parametri
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_start_replication_for_channel` deve essere eseguita dall'utente master. Dopo aver importato i dati dall’istanza database RDS per MySQL di origine, esegui questo comando sulla replica da più origini per avviare la replica sul canale specificato.
### Esempi
L’esempio seguente avvia la replica su `channel_1` della replica da più origini.
```
CALL mysql.rds_start_replication_for_channel('channel_1');
```
## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
Avvia la replica da un’istanza database RDS per MySQL sul canale specificato e la arresta in corrispondenza della posizione del file di log binario specificato.
### Sintassi
```
CALL mysql.rds_start_replication_until_for_channel (
replication_log_file
, replication_stop_point
, channel_name
);
```
### Parametri
*replication\$1log\$1file*
Il nome del log binario sull’istanza database di origine contiene le informazioni relative alla replica.
*replication\$1stop\$1point *
Posizione nel log binario `replication_log_file` in corrispondenza di cui la replica verrà arrestata.
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_start_replication_until_for_channel` deve essere eseguita dall'utente master. Con questa procedura, la replica viene avviata e successivamente arrestata quando viene raggiunta la posizione del file binlog specificata. La procedura arresta sia `SQL_THREAD` sia `IO_THREAD`.
Il nome di file specificato per il parametro `replication_log_file` deve corrispondere al nome del file binlog dell’istanza database di origine.
Quando il parametro `replication_stop_point` specifica una posizione di arresto nel passato, la replica viene arrestata immediatamente.
### Esempi
L’esempio seguente avvia la replica su `channel_1` e replica le modifiche fino a quando non raggiunge la posizione `120` nel file di log binario `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
Avvia la replica da un’istanza database RDS per MySQL e la arresta in corrispondenza dell’ID di transazione globale (GTID) specificato.
### Sintassi
```
CALL mysql.rds_start_replication_until_gtid_for_channel(gtid,channel_name);
```
### Parametri
*gtid*
GTID dopo il quale arrestare la replica.
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_start_replication_until_gtid_for_channel` deve essere eseguita dall'utente master. La procedura avvia la replica sul canale specificato, applica tutte le modifiche fino al valore GTID specificato, quindi arresta la replica sul canale.
Quando il parametro `gtid` specifica una transazione che è già stata eseguita dalla replica, la procedura viene arrestata immediatamente.
Prima di eseguire la procedure, è necessario disabilitare la replica multi-thread impostando il valore di `replica_parallel_workers` o `slave_parallel_workers` su `0`.
### Esempi
L’esempio seguente avvia la replica su `channel_1` e replica le modifiche fino a quando non raggiunge il GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
call mysql.rds_start_replication_until_gtid_for_channel('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','channel_1');
```
## mysql.rds\$1stop\$1replication\$1for\$1channel
Arresta la replica da un’istanza database MySQL sul canale specificato.
### Sintassi
```
CALL mysql.rds_stop_replication_for_channel(channel_name);
```
### Parametri
*channel\$1name*
Nome del canale di replica sulla replica da più origini. Ogni canale di replica riceve gli eventi del log binario da un’unica istanza database RDS per MySQL di origine in esecuzione su un host e una porta specifici.
### Note per l'utilizzo
La procedura `mysql.rds_stop_replication_for_channel` deve essere eseguita dall'utente master.
### Esempi
L’esempio seguente arresta la replica su `channel_1` della replica da più origini.
```
CALL mysql.rds_stop_replication_for_channel('channel_1');
```
# Replica delle transazioni utilizzando GTIDs
Le seguenti stored procedure controllano il modo in cui le transazioni vengono replicate utilizzando gli identificatori di transazione globali (GTIDs) con RDS for MySQL. Per ulteriori informazioni sulla replica basata su GTIDs RDS for MySQL, vedere. [Utilizzo della replica basata su GTID](mysql-replication-gtid.md)
Quando si utilizzano queste stored procedure per gestire la replica con un utente di replica configurato con `caching_sha2_password`, è necessario configurare TLS specificando `SOURCE_SSL=1`. `caching_sha2_password` è il plugin di autenticazione predefinito per RDS per MySQL 8.4.
**Topics**
+ [
##
](#mysql_rds_skip_transaction_with_gtid)
+ [
##
](#mysql_rds_start_replication_until_gtid)
##
Ignora la replica di una transazione con l'ID globale di transazione (GTID) specificato in un'istanza database MySQL.
Puoi usare questa procedura per il ripristino di emergenza quando è noto che una specifica transazione GTID causa un problema. Usa questa stored procedure per saltare la transazione problematica. Esempi di transazioni problematiche includono le transazioni che disabilitano la replica, eliminano dati importanti o con le quali l'istanza database diventa non disponibile.
### Sintassi
```
CALL mysql.rds_skip_transaction_with_gtid (
gtid_to_skip
);
```
### Parameters
*gtid\$1to\$1skip*
GTID della transazione di replica da ignorare.
### Note per l'utilizzo
La procedura `mysql.rds_skip_transaction_with_gtid` deve essere eseguita dall’utente master.
Questa procedura è supportata per tutte le versioni di RDS per MySQL 5.7, per tutte le versioni di RDS per MySQL 8.0 e per tutte le versioni di RDS per MySQL 8.4.
### Esempi
Nell'esempio seguente viene ignorata la replica della transazione con il GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
CALL mysql.rds_skip_transaction_with_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
##
Avvia la replica da un'istanza database RDS per MySQL e la arresta immediatamente dopo l'ID globale di transazione (GTID) specificato.
### Sintassi
```
CALL mysql.rds_start_replication_until_gtid(gtid);
```
### Parameters
*gtid*
Il GTID dopo il quale deve essere arrestata la replica.
### Note per l'utilizzo
La procedura `mysql.rds_start_replication_until_gtid` deve essere eseguita dall’utente master.
Questa procedura è supportata per tutte le versioni di RDS per MySQL 5.7, per tutte le versioni di RDS per MySQL 8.0 e per tutte le versioni di RDS per MySQL 8.4.
Puoi usare questa procedura archiviata con la replica ritardata per il disaster recovery. Se hai configurato la replica ritardata, puoi usare questa procedura archiviata per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore. Dopo che questa procedura archiviata arresta la replica, puoi promuovere la replica di lettura come nuova istanza database primaria seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Puoi configurare la replica ritardata usando le procedure archiviate seguenti:
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS per MySQL versioni principali 8.4 e successive)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay)
Quando il parametro `gtid` specifica una transazione che è già stata eseguita dalla replica, la procedura viene arrestata immediatamente.
### Esempi
L'esempio seguente avvia la replica e replica le modifiche finché non raggiunge il GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
call mysql.rds_start_replication_until_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
# Rotazione dei log di query
Le seguenti stored procedure ruotano i log MySQL nelle tabelle di backup. Per ulteriori informazioni, consulta [File di registro del database ](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
Converte la tabella `mysql.general_log` in una tabella di backup.
### Sintassi
```
CALL mysql.rds_rotate_general_log;
```
### Note per l'utilizzo
Puoi convertire la tabella `mysql.general_log` in una tabella di backup chiamando la procedura `mysql.rds_rotate_general_log`. Quando le tabelle di log sono convertite, la tabella di log corrente è copiata in una tabella di logo di backup e le voci nella tabella di log corrente sono eliminate. Se una tabella di log di backup esiste, viene eliminata prima che la tabella di log corrente sia copiata nel backup. Puoi eseguire una query sulla tabella di log di backup, se necessario. La tabella di log di backup per la tabella `mysql.general_log` è denominata `mysql.general_log_backup`.
È possibile eseguire questa procedura solo quando il parametro `log_output` è impostato su `TABLE`.
## mysql.rds\$1rotate\$1slow\$1log
Converte la tabella `mysql.slow_log` in una tabella di backup.
### Sintassi
```
CALL mysql.rds_rotate_slow_log;
```
### Note per l'utilizzo
Puoi convertire la tabella `mysql.slow_log` in una tabella di backup chiamando la procedura `mysql.rds_rotate_slow_log`. Quando le tabelle di log sono convertite, la tabella di log corrente è copiata in una tabella di logo di backup e le voci nella tabella di log corrente sono eliminate. Se una tabella di log di backup esiste, viene eliminata prima che la tabella di log corrente sia copiata nel backup.
Puoi eseguire una query sulla tabella di log di backup, se necessario. La tabella di log di backup per la tabella `mysql.slow_log` è denominata `mysql.slow_log_backup`.
# Impostazione e visualizzazione della configurazione dei log binari
Le seguenti stored procedure impostano e mostrano i parametri di configurazione, ad esempio per la conservazione dei file di log binari.
**Topics**
+ [
## mysql.rds\$1set\$1configuration
](#mysql_rds_set_configuration)
+ [
## mysql.rds\$1show\$1configuration
](#mysql_rds_show_configuration)
## mysql.rds\$1set\$1configuration
Specifica il numero di ore di conservazione dei log binari o il numero di secondi di ritardo della replica.
### Sintassi
```
CALL mysql.rds_set_configuration(name,value);
```
### Parameters
*name*
Il nome del parametro di configurazione da impostare.
*value*
Il valore del parametro di configurazione.
### Note per l'utilizzo
la procedura archiviata `mysql.rds_set_configuration` supporta i parametri di configurazione seguenti:
+ [binlog retention hours](#mysql_rds_set_configuration-usage-notes.binlog-retention-hours)
+ [Ritardo dell'origine](#mysql_rds_set_configuration-usage-notes.source-delay)
+ [target delay](#mysql_rds_set_configuration-usage-notes.target-delay)
I parametri di configurazione vengono archiviati in modo permanente e restano effettivi dopo qualsiasi riavvio o failover dell'istanza database.
#### binlog retention hours
Il parametro `binlog retention hours` viene utilizzato per specificare il numero di ore di conservazione dei file di log binari. Amazon RDS elimina in genere un log binario non appena possibile, tuttavia il log potrebbe continuare a essere necessario per la replica con un database MySQL esterno a RDS.
Il valore predefinito di `binlog retention hours` è `NULL`. Per RDS per MySQL, `NULL` significa che i log binari non vengono mantenuti (0 ore).
Per specificare il numero di ore per mantenere i log binari in un'istanza, usa la stored procedure `mysql.rds_set_configuration` e specifica un periodo con tempo sufficiente per l'esecuzione della replica, come mostrato nell'esempio seguente.
`call mysql.rds_set_configuration('binlog retention hours', 24);`
**Nota**
Non puoi utilizzare il valore `0` per `binlog retention hours`.
Per le istanze database MySQL, il valore `binlog retention hours` massimo è 168 (7 giorni).
Dopo l'impostazione del periodo di retention, monitora l'utilizzo dello storage per l'istanza database per verificare che i log binari conservati non occupino troppo spazio di storage.
Per le implementazioni di cluster di database Multi-AZ, è possibile configurare la conservazione dei log binari solo dall’istanza database di scrittura e l’impostazione viene propagata a tutte le istanze database di lettura in modo asincrono. Se i log binari nel cluster di database superano la metà dello spazio di archiviazione locale totale, Amazon RDS sposta automaticamente i log obsoleti nel volume EBS. I log più recenti, tuttavia, rimangono nell’archiviazione locale, quindi sono soggetti a perdita se si verifica un errore che richieda la sostituzione dell’host o se si aumenta o si riduce verticalmente il database.
#### Ritardo dell'origine
Usa il parametro `source delay` in una replica di lettura per specificare il numero di secondi per cui ritardare la replica di lettura rispetto all'istanza database di origine. Amazon RDS in genere replica le modifiche non appena possibile, ma in alcuni ambienti è possibile che la replica venga ritardata. Ritardando la replica, ad esempio, è possibile effettuare il roll forward di una replica di lettura ritardata al momento immediatamente precedente a un errore. Se una tabella viene eliminata accidentalmente, puoi usare la replica ritardata per recuperarla rapidamente. Il valore predefinito di `target delay` è `0` (la replica non viene ritardata).
Quando utilizzato, questo parametro esegue [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) e applica CHANGE primary TO MASTER\$1DELAY = valore di input. In caso di esito positivo, la procedura salva il parametro `source delay` nella tabella `mysql.rds_configuration`.
Per specificare il numero di secondi per cui Amazon RDS deve ritardare la replica in un'istanza database di origine, usa la stored procedure `mysql.rds_set_configuration` e specifica il numero di secondi per il ritardo della replica. Nell'esempio seguente la replica viene ritardata di almeno un'ora (3600 secondi).
`call mysql.rds_set_configuration('source delay', 3600);`
La procedura quindi esegue `mysql.rds_set_source_delay(3600)`.
Il limite per il parametro `source delay` è un giorno (86400 secondi).
#### target delay
Usa il parametro `target delay` per specificare il numero di secondi per cui ritardare la replica tra un'istanza database e le repliche di lettura future gestite da RDS create dall'istanza. Questo parametro viene ignorato per le repliche di non-RDS-managed lettura. Amazon RDS in genere replica le modifiche non appena possibile, ma in alcuni ambienti è possibile che la replica venga ritardata. Ritardando la replica, ad esempio, è possibile effettuare il roll forward di una replica di lettura ritardata al momento immediatamente precedente a un errore. Se una tabella viene eliminata accidentalmente, puoi usare la replica ritardata per recuperarla rapidamente. Il valore predefinito di `target delay` è `0` (la replica non viene ritardata).
Per il disaster recovery puoi usare questo parametro di configurazione con la stored procedure [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) o [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Per effettuare il roll forward delle modifiche a una replica di lettura ritardata al momento immediatamente precedente a un errore, puoi eseguire la procedura `mysql.rds_set_configuration` con questo parametro impostato. Dopo che la procedura `mysql.rds_start_replication_until` o `mysql.rds_start_replication_until_gtid` arresta la replica, puoi promuovere la replica di lettura come nuova istanza database master seguendo le istruzioni in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
Per usare la procedura `mysql.rds_rds_start_replication_until_gtid`, è necessario che sia abilitata la replica basata su GTID. Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la stored procedure [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Per ulteriori informazioni sull'utilizzo della replica basata su GTID, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
Per specificare il numero di secondi per cui Amazon RDS deve ritardare la replica in una replica di lettura, usa la stored procedure `mysql.rds_set_configuration` e specifica il numero di secondi per il ritardo della replica. L'esempio seguente specifica che la replica viene ritardata di almeno un'ora (3600 secondi).
`call mysql.rds_set_configuration('target delay', 3600);`
Il limite per il parametro `target delay` è un giorno (86400 secondi).
## mysql.rds\$1show\$1configuration
Il numero di ore di retention dei log binari.
### Sintassi
```
CALL mysql.rds_show_configuration;
```
### Note per l'utilizzo
Per verificare il numero di ore per cui Amazon RDS deve conservare i log binari, usa la stored procedure `mysql.rds_show_configuration`.
### Esempi
L'esempio seguente visualizza il periodo di retention:
```
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.
```
# Precaricamento della cache di InnoDB
Le seguenti stored procedure salvano, caricano o annullano il caricamento del pool di buffer di InnoDB nelle istanze database RDS per MySQL. Per ulteriori informazioni, consulta [Precaricamento della cache InnoDB per MySQL su 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
Esegue il dump dello stato corrente del pool di buffer sul disco.
### Sintassi
```
CALL mysql.rds_innodb_buffer_pool_dump_now();
```
### Note per l'utilizzo
La procedura `mysql.rds_innodb_buffer_pool_dump_now` deve essere eseguita dall'utente master.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
Annulla un caricamento in corso dello stato del pool di buffer salvato.
### Sintassi
```
CALL mysql.rds_innodb_buffer_pool_load_abort();
```
### Note per l'utilizzo
La procedura `mysql.rds_innodb_buffer_pool_load_abort` deve essere eseguita dall'utente master.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
Carica lo stato salvato del pool di buffer dal disco.
### Sintassi
```
CALL mysql.rds_innodb_buffer_pool_load_now();
```
### Note per l'utilizzo
La procedura `mysql.rds_innodb_buffer_pool_load_now` deve essere eseguita dall'utente master.