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à.
# Informazioni di riferimento sulle stored procedure Aurora MySQL
Puoi gestire il cluster di database Aurora MySQL tramite la chiamata delle stored procedure integrate.
**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)
+ [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)
# 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 di stato globale](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.MySQL.CommonDBATasks.html#Appendix.MySQL.CommonDBATasks.GoSH).
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)
Puoi chiamare le seguenti procedure archiviate mentre sei connesso all'istanza primaria in un cluster Aurora MySQL. Queste procedure controllano il modo in cui le transazioni vengono replicate da un database esterno a Aurora MySQL o da Aurora MySQL a un database esterno.
**Topics**
+ [mysql.rds\$1disable\$1session\$1binlog (Aurora MySQL versione 2)](#mysql_rds_disable_session_binlog)
+ [mysql.rds\$1enable\$1session\$1binlog (Aurora MySQL versione 2)](#mysql_rds_enable_session_binlog)
+ [mysql.rds\$1import\$1binlog\$1ssl\$1material](#mysql_rds_import_binlog_ssl_material)
+ [mysql.rds\$1next\$1master\$1log](#mysql_rds_next_master_log)
+ [mysql.rds\$1next\$1source\$1log (Aurora MySQL versione 3)](#mysql_rds_next_source_log)
+ [mysql.rds\$1remove\$1binlog\$1ssl\$1material](#mysql_rds_remove_binlog_ssl_material)
+ [mysql.rds\$1reset\$1external\$1master (Aurora MySQL versione 2)](#mysql_rds_reset_external_master)
+ [mysql.rds\$1reset\$1external\$1source (Aurora MySQL versione 3)](#mysql_rds_reset_external_source)
+ [mysql.rds\$1set\$1binlog\$1source\$1ssl (Aurora MySQL versione 3)](#mysql_rds_set_binlog_source_ssl)
+ [mysql.rds\$1set\$1external\$1master (Aurora MySQL versione 2)](#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1source (Aurora MySQL versione 3)](#mysql_rds_set_external_source)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (Aurora MySQL versione 2)](#mysql_rds_set_external_master_with_auto_position)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (Aurora MySQL versione 3)](#mysql_rds_set_external_source_with_auto_position)
+ [mysql.rds\$1set\$1master\$1auto\$1position (RDS )](#mysql_rds_set_master_auto_position)
+ [mysql.rds\$1set\$1read\$1only (Aurora MySQL versione 3)](#mysql_rds_set_read_only)
+ [mysql.rds\$1set\$1session\$1binlog\$1format (Aurora MySQL versione 2)](#mysql_rds_set_session_binlog_format)
+ [mysql.rds\$1set\$1source\$1auto\$1position (Aurora MySQL versione 3)](#mysql_rds_set_source_auto_position)
+ [mysql.rds\$1skip\$1repl\$1error](#mysql_rds_skip_repl_error)
+ [mysql.rds\$1start\$1replication](#mysql_rds_start_replication)
+ [mysql.rds\$1start\$1replication\$1until (Aurora MySQL versione 3)](#mysql_rds_start_replication_until)
+ [mysql.rds\$1stop\$1replication](#mysql_rds_stop_replication)
## mysql.rds\$1disable\$1session\$1binlog (Aurora MySQL versione 2)
Disattiva la registrazione binaria per la sessione corrente impostando la variabile `sql_log_bin` su `OFF`.
### Sintassi
```
CALL mysql.rds_disable_session_binlog;
```
### Parameters
Nessuno
### Note per l’utilizzo
Per un cluster di database Aurora MySQL, puoi chiamare questa procedura archiviata mentre sei connesso all’istanza primaria.
Per Aurora, questa procedura è supportata per Aurora MySQL versione 2.12 e versioni successive compatibili con MySQL 5.7.
**Nota**
In Aurora MySQL versione 3, è possibile utilizzare il seguente comando per disabilitare la registrazione di log binari per la sessione corrente se si dispone del privilegio `SESSION_VARIABLES_ADMIN`:
```
SET SESSION sql_log_bin = OFF;
```
## mysql.rds\$1enable\$1session\$1binlog (Aurora MySQL versione 2)
Attiva la registrazione binaria per la sessione corrente impostando la variabile `sql_log_bin` su `ON`.
### Sintassi
```
CALL mysql.rds_enable_session_binlog;
```
### Parameters
Nessuno
### Note per l’utilizzo
Per un cluster di database Aurora MySQL, puoi chiamare questa procedura archiviata mentre sei connesso all’istanza primaria.
Per Aurora, questa procedura è supportata per Aurora MySQL versione 2.12 e versioni successive compatibili con MySQL 5.7.
**Nota**
In Aurora MySQL versione 3, è possibile utilizzare il seguente comando per abilitare la registrazione di log binari per la sessione corrente se si dispone del privilegio `SESSION_VARIABLES_ADMIN`:
```
SET SESSION sql_log_bin = ON;
```
## mysql.rds\$1import\$1binlog\$1ssl\$1material
Importa il certificato dell'autorità di certificazione, il certificato client e la chiave client in un cluster di database Aurora MySQL. Le informazioni sono necessarie per la comunicazione SSL e la replica crittografata.
**Nota**
Attualmente, questa procedura è supportata per Aurora MySQL versione 2 (2.09.2, 2.10.0, 2.10.1 e 2.11.0) e versione 3 (3.01.1 e successive).
### Sintassi
```
CALL mysql.rds_import_binlog_ssl_material (
ssl_material
);
```
### Parameters
*ssl\$1material*
Il payload JSON che contiene il contenuto dei seguenti file in formato .pem per un client MySQL:
+ «ssl\$1it»:»» *Certificate authority certificate*
+ «certificato SSL»:»» *Client certificate*
+ «chiave\$1ssl»:»» *Client key*
### Note per l’utilizzo
Prepara la replica crittografata prima di eseguire questa procedura:
+ Se SSL non è abilitato sull’istanza database di origine MySQL esterna e non disponi di una chiave client e di un certificato client preparato, abilita SSL sul server di database MySQL e genera la chiave client e il certificato client necessari.
+ Se SSL è abilitato sull’istanza database di origine esterna, fornisci un certificato e una chiave client per il cluster database Aurora MySQL. Se non disponi di questi elementi, genera una nuova chiave e un nuovo certificato per il cluster di database Aurora MySQL. Per firmare il certificato client, devi avere la chiave autorità certificato che hai utilizzato per configurare SSL nell’istanza database di origine esterna MySQL.
Per ulteriori informazioni, consulta [Creating SSL Certificates and Keys Using openssl](https://dev.mysql.com/doc/refman/8.0/en/creating-ssl-files-using-openssl.html) nella documentazione MySQL.
**Importante**
Dopo aver preparato la replica crittografata, utilizza una connessione SSL per eseguire questa procedura. La chiave client non deve essere trasferita mediante una connessione non sicura.
Questa procedura importa le informazioni SSL da un database MySQL esterno in un cluster di database Aurora MySQL. Le informazioni SSL sono in file in formato .pem che contengono le informazioni SSL per il cluster di database Aurora MySQL. Durante la replica crittografata, il cluster di database Aurora MySQL agisce come un client per il server di database MySQL. I certificati e le chiavi per il client Aurora MySQL sono in file in formato .pem.
Puoi copiare le informazioni da questi file nel parametro `ssl_material` nel payload JSON corretto. Per supportare la replica crittografata, importa queste informazioni SSL nel cluster di database Aurora MySQL.
Il payload JSON deve avere il formato seguente.
```
'{"ssl_ca":"-----BEGIN CERTIFICATE-----
ssl_ca_pem_body_code
-----END CERTIFICATE-----\n","ssl_cert":"-----BEGIN CERTIFICATE-----
ssl_cert_pem_body_code
-----END CERTIFICATE-----\n","ssl_key":"-----BEGIN RSA PRIVATE KEY-----
ssl_key_pem_body_code
-----END RSA PRIVATE KEY-----\n"}'
```
### Esempi
L'esempio seguente importa le informazioni SSL in Aurora MySQL. Nei file in formato .pem, il codice del corpo è in genere più lungo del codice del corpo riportato nell'esempio.
```
call mysql.rds_import_binlog_ssl_material(
'{"ssl_ca":"-----BEGIN CERTIFICATE-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END CERTIFICATE-----\n","ssl_cert":"-----BEGIN CERTIFICATE-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END CERTIFICATE-----\n","ssl_key":"-----BEGIN RSA PRIVATE KEY-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END RSA PRIVATE KEY-----\n"}');
```
## mysql.rds\$1next\$1master\$1log
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.
### Esempi
Supponi che una replica di lettura Aurora 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 (Aurora MySQL versione 3)
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.
### Esempi
Supponi che una replica di lettura Aurora 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\$1remove\$1binlog\$1ssl\$1material
Elimina il certificato dell'autorità di certificazione, il certificato client e la chiave client per la comunicazione SSL e la replica crittografata. Queste informazioni sono importate utilizzando [mysql.rds\$1import\$1binlog\$1ssl\$1material](#mysql_rds_import_binlog_ssl_material).
### Sintassi
```
CALL mysql.rds_remove_binlog_ssl_material;
```
## mysql.rds\$1reset\$1external\$1master (Aurora MySQL versione 2)
Riconfigura un'istanza database Aurora 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 Aurora](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**
Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Ti consigliamo di usare le repliche Aurora per gestire la replica in un cluster database Aurora MySQL. Per informazioni sulla gestione della replica nei cluster database Aurora MySQL, consulta [Utilizzo delle repliche di Aurora](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas).
Per ulteriori informazioni sull'uso della replica per importare dati da un'istanza di MySQL in esecuzione all'esterno di Aurora MySQL, consulta [Replica tra Aurora e MySQL o tra Aurora e un altro cluster di database Aurora (replica dei log binari)](AuroraMySQL.Replication.MySQL.md).
## mysql.rds\$1reset\$1external\$1source (Aurora MySQL versione 3)
Riconfigura un'istanza database Aurora 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 Aurora](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**
Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Ti consigliamo di usare le repliche Aurora per gestire la replica in un cluster database Aurora MySQL. Per informazioni sulla gestione della replica nei cluster database Aurora MySQL, consulta [Utilizzo delle repliche di Aurora](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas).
## mysql.rds\$1set\$1binlog\$1source\$1ssl (Aurora MySQL versione 3)
Abilita la crittografia `SOURCE_SSL` per la replica binlog. Per ulteriori informazioni, consulta [CHANGE REPLICATION SOURCE TO statement](https://dev.mysql.com/doc/refman/8.0/en/change-replication-source-to.html) nella documentazione MySQL.
### Sintassi
```
CALL mysql.rds_set_binlog_source_ssl(mode);
```
### Parameters
*mode*
Valore che indica se la crittografia `SOURCE_SSL` è abilitata:
+ `0`: la crittografia `SOURCE_SSL` è disabilitata. Il valore predefinito è `0`.
+ `1`: la crittografia `SOURCE_SSL` è abilitata. È possibile configurare la crittografia utilizzando SSL o TLS.
### Note per l’utilizzo
Questa procedura è supportata per Aurora MySQL versione 3.06 e successive.
## mysql.rds\$1set\$1external\$1master (Aurora MySQL versione 2)
Configura un'istanza database Aurora MySQL come replica di lettura di un'istanza di MySQL in esecuzione all'esterno di Amazon RDS.
La procedura `mysql.rds_set_external_master` è obsoleta e verrà rimossa in una versione futura. Usare invece `mysql.rds\$1set\$1external\$1source`.
**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 Aurora](USER_WorkingWithParamGroups.Modifying.md).
### 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. Importa inoltre il certificato dell'autorità di certificazione, il certificato client e la chiave client nell'istanza database o nel cluster di database utilizzando la procedura [mysql.rds\$1import\$1binlog\$1ssl\$1material](#mysql_rds_import_binlog_ssl_material).
**Nota**
Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Ti consigliamo di usare le repliche Aurora per gestire la replica in un cluster database Aurora MySQL. Per informazioni sulla gestione della replica nei cluster database Aurora MySQL, consulta [Utilizzo delle repliche di Aurora](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas).
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 (Aurora MySQL versione 2)](#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 (Aurora MySQL versione 3)
Configura un'istanza database Aurora 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 Aurora](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.
Per abilitare questa opzione, è necessario aver importato un certificato SSL personalizzato tramite [mysql.rds\$1import\$1binlog\$1ssl\$1material](#mysql_rds_import_binlog_ssl_material). Se non è stato importato un certificato SSL personalizzato, impostare questo parametro su 0 e utilizzare [mysql.rds\$1set\$1binlog\$1source\$1ssl (Aurora MySQL versione 3)](#mysql_rds_set_binlog_source_ssl) per abilitare SSL per la replica dei log binari.
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 Aurora 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**
Queste stored procedure sono fornite principalmente per abilitare la replica con le istanze MySQL eseguite esternamente a Amazon RDS. Ti consigliamo di usare le repliche Aurora per gestire la replica in un cluster database Aurora MySQL. Per informazioni sulla gestione della replica nei cluster database Aurora MySQL, consulta [Utilizzo delle repliche di Aurora](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas).
Dopo aver chiamato `mysql.rds_set_external_source` per configurare un’istanza database Aurora 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 (Aurora MySQL versione 3)](#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 Aurora 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 (Aurora MySQL versione 2)
Configura un’istanza primaria Aurora MySQL affinché accetti la replica in entrata da un’istanza di MySQL esterna. Questa procedura configura anche la replica in base agli identificatori globali delle transazioni (). GTIDs
Questa procedura non configura la replica ritardata in quanto non è supportata da Aurora MySQL.
### Sintassi
```
CALL mysql.rds_set_external_master_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
);
```
### Parameters
*host\$1name*
Il nome host o l'indirizzo IP dell'istanza di MySQL eseguita esternamente a Aurora per diventare il fonte di replica.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Aurora e da configurare come fonte di replica. 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 Aurora. 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*
Questa opzione non è al momento implementata. Il valore predefinito è 0.
### Note per l'utilizzo
Per un cluster di database Aurora MySQL, puoi chiamare questa procedura archiviata mentre sei connesso all'istanza primaria.
La procedura `mysql.rds_set_external_master_with_auto_position` deve essere eseguita dall'utente master. L'utente master esegue questa procedura sull'istanza primaria di un cluster di database Aurora MySQL che opera da destinazione di replica. Questa può essere la destinazione di replica di un’istanza database MySQL esterna o di un cluster di database Aurora MySQL.
Questa procedura è supportata per Aurora MySQL versione 2. Per Aurora MySQL versione 3, utilizzare invece la procedura [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (Aurora MySQL versione 3)](#mysql_rds_set_external_source_with_auto_position).
Prima di eseguire `mysql.rds_set_external_master_with_auto_position`, configura l’istanza database MySQL esterna come fonte di replica. Per connetterti all’istanza di MySQL esterna, specifica 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 di MySQL esterna.
**Per configurare un'istanza di MySQL esterna come fonte di replica**
1. Mediante il client MySQL scelto, eseguire la connessione all’istanza di MySQL esterna 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. Per un'istanza di MySQL esterna, 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'
```
Quando chiami `mysql.rds_set_external_master_with_auto_position`, Amazon RDS registra determinate informazioni. Queste informazioni sono l'orario, l'utente e l'operazione di `"set master"` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la procedura archiviata [mysql.rds\$1skip\$1transaction\$1with\$1gtid (Aurora MySQL versione 2 e 3)](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 primaria Aurora, l’esempio seguente configura il cluster Aurora come replica di lettura di un’istanza di MySQL eseguita esternamente a Aurora.
```
call mysql.rds_set_external_master_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user'@'mydomain.com',
'SomePassW0rd');
```
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (Aurora MySQL versione 3)
Configura un’istanza primaria Aurora MySQL affinché accetti la replica in entrata da un’istanza di MySQL esterna. Questa procedura configura anche la replica in base agli identificatori globali delle transazioni (). GTIDs
### Sintassi
```
CALL mysql.rds_set_external_source_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
);
```
### Parameters
*host\$1name*
Il nome host o l'indirizzo IP dell'istanza di MySQL eseguita esternamente a Aurora per diventare il fonte di replica.
*host\$1port*
La porta utilizzata dall'istanza di MySQL eseguita esternamente a Aurora e da configurare come fonte di replica. 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 Aurora. 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*
Questa opzione non è al momento implementata. Il valore predefinito è 0.
Utilizzare [mysql.rds\$1set\$1binlog\$1source\$1ssl (Aurora MySQL versione 3)](#mysql_rds_set_binlog_source_ssl) per abilitare SSL per la replica di log binari.
### Note per l’utilizzo
Per un cluster di database Aurora MySQL, puoi chiamare questa procedura archiviata mentre sei connesso all’istanza primaria.
L'utente amministrativo deve eseguire la procedura `mysql.rds_set_external_source_with_auto_position`. L'utente master esegue questa procedura sull'istanza primaria di un cluster di database Aurora MySQL che opera da destinazione di replica. Questa può essere la destinazione di replica di un’istanza database MySQL esterna o di un cluster di database Aurora MySQL.
Questa procedura è supportata per Aurora MySQL versione 3. Questa procedura non configura la replica ritardata in quanto non è supportata da Aurora MySQL.
Prima di eseguire `mysql.rds_set_external_source_with_auto_position`, configura l’istanza database MySQL esterna come fonte di replica. Per connetterti all’istanza di MySQL esterna, specifica 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 di MySQL esterna.
**Per configurare un'istanza di MySQL esterna come fonte di replica**
1. Mediante il client MySQL scelto, eseguire la connessione all’istanza di MySQL esterna 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. Per un'istanza di MySQL esterna, 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'
```
Quando chiami `mysql.rds_set_external_source_with_auto_position`, Amazon RDS registra determinate informazioni. Queste informazioni sono l'orario, l'utente e l'operazione di `"set master"` nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
Per passare a una specifica transazione basata su GTID che notoriamente causa un problema, puoi usare la procedura archiviata [mysql.rds\$1skip\$1transaction\$1with\$1gtid (Aurora MySQL versione 2 e 3)](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 primaria Aurora, l’esempio seguente configura il cluster Aurora come replica di lettura di un’istanza di MySQL eseguita esternamente a Aurora.
```
call mysql.rds_set_external_source_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user'@'mydomain.com',
'SomePassW0rd');
```
## mysql.rds\$1set\$1master\$1auto\$1position (RDS )
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 Aurora MySQL versione 2.
## mysql.rds\$1set\$1read\$1only (Aurora MySQL versione 3)
Attiva o disattiva la modalità `read_only` a livello globale per l’istanza database.
### Sintassi
```
CALL mysql.rds_set_read_only(mode);
```
### Parameters
*mode*
Valore che indica se la modalità `read_only` è attiva o disattiva a livello globale per l’istanza database:
+ `0` – `OFF`. Il valore predefinito è `0`.
+ `1` – `ON`
### Note per l’utilizzo
La stored procedure `mysql.rds_set_read_only` modifica solo il parametro `read_only`. Il parametro `innodb_read_only` non può essere modificato sulle istanze database di lettura.
La modifica del parametro `read_only` non viene mantenuta al riavvio. Per apportare modifiche permanenti a `read_only`, è necessario utilizzare il parametro `read_only` del cluster di database.
Questa procedura è supportata per Aurora MySQL versione 3.06 e successive.
## mysql.rds\$1set\$1session\$1binlog\$1format (Aurora MySQL versione 2)
Imposta il formato di log binario per la sessione corrente.
### Sintassi
```
CALL mysql.rds_set_session_binlog_format(format);
```
### Parameters
*format*
Un valore che indica il formato di log binario per la sessione corrente:
+ `STATEMENT`: l'origine della replica scrive eventi nel log binario in base alle istruzioni SQL.
+ `ROW`: l'origine della replica scrive eventi nel log binario che indicano le modifiche alle singole righe della tabella.
+ `MIXED`: la registrazione si basa in genere su istruzioni SQL, ma passa alle righe in determinate condizioni. Per ulteriori informazioni, consulta [Mixed Binary Logging Format](https://dev.mysql.com/doc/refman/8.0/en/binary-log-mixed.html) nella documentazione di MySQL.
### Note per l’utilizzo
Per un cluster di database Aurora MySQL, puoi chiamare questa procedura archiviata mentre sei connesso all’istanza primaria.
Per utilizzare questa procedura archiviata, la registrazione binaria deve essere configurata per la sessione corrente.
Per Aurora, questa procedura è supportata per Aurora MySQL versione 2.12 e versioni successive compatibili con MySQL 5.7.
## mysql.rds\$1set\$1source\$1auto\$1position (Aurora MySQL versione 3)
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
Per un cluster di database Aurora MySQL, puoi chiamare questa procedura archiviata mentre sei connesso all’istanza primaria.
L'utente amministrativo deve eseguire la procedura `mysql.rds_set_source_auto_position`.
## 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 [Ignorare l'errore di replica corrente](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.MySQL.CommonDBATasks.html#Appendix.MySQL.CommonDBATasks.SkipError).
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 Aurora MySQL, consulta [](CHAP_Troubleshooting.md#CHAP_Troubleshooting.MySQL.RR).
#### 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 cluster di database Aurora MySQL.
**Nota**
Puoi usare la stored procedure [mysql.rds\$1start\$1replication\$1until (Aurora MySQL versione 3)](#mysql_rds_start_replication_until) o [mysql.rds\$1start\$1replication\$1until\$1gtid (Aurora MySQL versione 3)](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) per avviare la replica da un'istanza database Aurora 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 (Aurora MySQL versione 2)](#mysql_rds_set_external_master) o [mysql.rds\$1set\$1external\$1source (Aurora MySQL versione 3)](#mysql_rds_set_external_source) per creare la configurazione della replica. Per ulteriori informazioni, consulta [Replica tra Aurora e MySQL o tra Aurora e un altro cluster di database Aurora (replica dei log binari)](AuroraMySQL.Replication.MySQL.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 [Replica tra Aurora e MySQL o tra Aurora e un altro cluster di database Aurora (replica dei log binari)](AuroraMySQL.Replication.MySQL.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 [Errore di replica interrotta](CHAP_Troubleshooting.md#CHAP_Troubleshooting.MySQL.ReplicationStopped).
## mysql.rds\$1start\$1replication\$1until (Aurora MySQL versione 3)
Avvia la replica da cluster di database Aurora 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.
Questa procedura è supportata per Aurora MySQL versione 3.04 e successive.
La stored procedure `mysql.rds_start_replication_until` non è supportata per la replica gestita, che include quanto segue:
+ [Repliche di cluster di database Amazon Aurora MySQL tra Regioni AWS](AuroraMySQL.Replication.CrossRegion.md)
+ [Migrazione di dati da un'istanza database RDS per MySQL a un cluster database Amazon Aurora MySQL utilizzando una replica di lettura Aurora](AuroraMySQL.Migrating.RDSMySQL.Replica.md)
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 [Replica tra Aurora e MySQL o tra Aurora e un altro cluster di database Aurora (replica dei log binari)](AuroraMySQL.Replication.MySQL.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 [Replica tra Aurora e MySQL o tra Aurora e un altro cluster di database Aurora (replica dei log binari)](AuroraMySQL.Replication.MySQL.md).
La stored procedure `mysql.rds_stop_replication` non è supportata per la replica gestita, che include quanto segue:
+ [Repliche di cluster di database Amazon Aurora MySQL tra Regioni AWS](AuroraMySQL.Replication.CrossRegion.md)
+ [Migrazione di dati da un'istanza database RDS per MySQL a un cluster database Amazon Aurora MySQL utilizzando una replica di lettura Aurora](AuroraMySQL.Migrating.RDSMySQL.Replica.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).
### 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*.
### Esempi
L'esempio seguente arresta una query con l'ID di thread di query 230040:
```
CALL mysql.rds_kill_query(230040);
```
# 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 Aurora MySQL. Per informazioni su come utilizzare la replica basata su GTIDs Aurora MySQL, consulta. [Utilizzo della replica basata su GTID](mysql-replication-gtid.md)
**Topics**
+ [mysql.rds\$1assign\$1gtids\$1to\$1anonymous\$1transactions (Aurora MySQL versione 3)](#mysql_assign_gtids_to_anonymous_transactions)
+ [mysql.rds\$1gtid\$1purged (Aurora MySQL versione 3)](#mysql_rds_gtid_purged)
+ [mysql.rds\$1skip\$1transaction\$1with\$1gtid (Aurora MySQL versione 2 e 3)](#mysql_rds_skip_transaction_with_gtid)
+ [mysql.rds\$1start\$1replication\$1until\$1gtid (Aurora MySQL versione 3)](#mysql_rds_start_replication_until_gtid)
## mysql.rds\$1assign\$1gtids\$1to\$1anonymous\$1transactions (Aurora MySQL versione 3)
Configura l'opzione `ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS` dell'istruzione `CHANGE REPLICATION SOURCE TO`. Il canale di replica assegna così un GTID alle transazioni replicate che non ne hanno uno. In questo modo, è possibile eseguire la replica del log binario da un'origine che non utilizza la replica basata su GTID in una replica che lo usa. *Per ulteriori informazioni, vedere [CHANGE REPLICATION SOURCE TO Statement and Replication From a](https://dev.mysql.com/doc/refman/8.0/en/change-replication-source-to.html) [Source Without GTIDs to a Replica With GTIDs](https://dev.mysql.com/doc/refman/8.0/en/replication-gtids-assign-anon.html) nel MySQL Reference Manual.*
### Sintassi
```
CALL mysql.rds_assign_gtids_to_anonymous_transactions(gtid_option);
```
### Parameters
*gtid\$1option*
Valore di stringa. I valori consentiti sono `OFF`, `LOCAL` o un UUID specificato.
### Note per l’utilizzo
Questa procedura ha lo stesso effetto del rilascio dell'istruzione `CHANGE REPLICATION SOURCE TO ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS = gtid_option` nella community MySQL.
GTID deve essere impostato su o su un `ON` UUID specifico. *gtid\$1option* `LOCAL`
Il valore predefinito è `OFF`, il che significa che la funzione non viene utilizzata.
`LOCAL` assegna un GTID incluso l'UUID della replica (l'impostazione `server_uuid`).
Il passaggio di un parametro che è un UUID assegna un GTID che include l'UUID specificato, ad esempio l'impostazione `server_uuid` per il server di fonte di replica.
### Esempi
Per disattivare questa funzione:
```
mysql> call mysql.rds_assign_gtids_to_anonymous_transactions('OFF');
+-------------------------------------------------------------+
| Message |
+-------------------------------------------------------------+
| ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS has been set to: OFF |
+-------------------------------------------------------------+
1 row in set (0.07 sec)
```
Per utilizzare l'UUID della replica:
```
mysql> call mysql.rds_assign_gtids_to_anonymous_transactions('LOCAL');
+---------------------------------------------------------------+
| Message |
+---------------------------------------------------------------+
| ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS has been set to: LOCAL |
+---------------------------------------------------------------+
1 row in set (0.07 sec)
```
Per utilizzare un UUID specificato:
```
mysql> call mysql.rds_assign_gtids_to_anonymous_transactions('317a4760-f3dd-3b74-8e45-0615ed29de0e');
+----------------------------------------------------------------------------------------------+
| Message |
+----------------------------------------------------------------------------------------------+
| ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS has been set to: 317a4760-f3dd-3b74-8e45-0615ed29de0e |
+----------------------------------------------------------------------------------------------+
1 row in set (0.07 sec)
```
## mysql.rds\$1gtid\$1purged (Aurora MySQL versione 3)
Imposta il valore globale della variabile di sistema `gtid_purged` su un set di ID globali di transazione (GTID) specificato. La variabile di `gtid_purged` sistema è un set GTID composto da tutte le transazioni che sono state eseguite sul server, ma che non esistono in alcun file di registro binario sul server. GTIDs
Per consentire la compatibilità con MySQL 8.0, esistono due modi per impostare il valore di `gtid_purged`:
+ Sostituire il valore di `gtid_purged` con il set di GTID specificato.
+ Aggiungere il set di GTID specificato al set di GTID già contenuto in `gtid_purged`.
### Sintassi
Per sostituire il valore di `gtid_purged` con il set di GTID specificato:
```
CALL mysql.rds_gtid_purged (gtid_set);
```
Per aggiungere il valore di `gtid_purged` con al set di GTID specificato:
```
CALL mysql.rds_gtid_purged (+gtid_set);
```
### Parameters
*gtid\$1set*
Il valore di *gtid\$1set* deve essere un superset del valore corrente di `gtid_purged` e non può intersecarsi con. `gtid_subtract(gtid_executed,gtid_purged)` Cioè, il nuovo set GTID deve includere quelli già presenti GTIDs `gtid_purged` e non può includere quelli `gtid_executed` che non sono ancora GTIDs stati eliminati. Inoltre, il *gtid\$1set* parametro non può includere GTIDs quelli presenti nel `gtid_owned` set globale, vale a dire GTIDs per le transazioni attualmente in corso di elaborazione sul server.
### Note per l’utilizzo
La procedura `mysql.rds_gtid_purged` deve essere eseguita dall’utente master.
Questa procedura è supportata per Aurora MySQL versione 3.04 e successive.
### Esempi
L'esempio seguente assegna il GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23` alla variabile globale `gtid_purged`.
```
CALL mysql.rds_gtid_purged('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
## mysql.rds\$1skip\$1transaction\$1with\$1gtid (Aurora MySQL versione 2 e 3)
Ignora la replica di una transazione con l'ID globale di transazione (GTID) specificato in un'istanza primaria Aurora.
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 Aurora MySQL versione 2 e 3.
### 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');
```
## mysql.rds\$1start\$1replication\$1until\$1gtid (Aurora MySQL versione 3)
Avvia la replica da un cluster di database Aurora 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 Aurora MySQL versione 3.04 e successive.
La stored procedure `mysql.rds_start_replication_until_gtid` non è supportata per la replica gestita, che include quanto segue:
+ [Repliche di cluster di database Amazon Aurora MySQL tra Regioni AWS](AuroraMySQL.Replication.CrossRegion.md)
+ [Migrazione di dati da un'istanza database RDS per MySQL a un cluster database Amazon Aurora MySQL utilizzando una replica di lettura Aurora](AuroraMySQL.Migrating.RDSMySQL.Replica.md)
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 Aurora MySQL](USER_LogAccess.Concepts.MySQL.md).
**Topics**
+ [mysql.rds\$1rotate\$1general\$1log](#mysql_rds_rotate_general_log)
+ [mysql.rds\$1rotate\$1slow\$1log](#mysql_rds_rotate_slow_log)
## mysql.rds\$1rotate\$1general\$1log
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)
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 Aurora 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 ad Aurora.
Il valore predefinito di `binlog retention hours` è `NULL`. Per Aurora MySQL, `NULL` significa che i log binari vengono eliminati lentamente. I log binari Aurora MySQL potrebbero rimanere nel sistema per un certo periodo, di solito non più di un giorno.
Per specificare il numero di ore per mantenere i log binari in un cluster di database, 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`.
Il valore `binlog retention hours` massimo per i cluster database Aurora MySQL versione 2.11.0 e successive e versione 3 è 2160 (90 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.
## 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.
```