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à.
# Uso della replica MySQL in Amazon RDS
Generalmente, per configurare la replica tra le istanze database di Amazon RDS si utilizzano repliche di lettura. Per informazioni generali sulle repliche di lettura, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md). Per informazioni specifiche sull'uso di repliche di lettura in Amazon RDS per MySQL, consulta [Uso delle repliche di lettura MySQL](USER_MySQL.Replication.ReadReplicas.md).
È possibile utilizzare gli identificatori di transazione globali (GTIDs) per la replica con RDS for MySQL. Per ulteriori informazioni, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
Puoi anche configurare la replica tra un'istanza database RDS for MySQL e un'istanza MariaDB o MySQL esterna ad Amazon RDS. Per ulteriori informazioni sulla configurazione della replica con un'origine esterna, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
Per qualsiasi opzione di replica, puoi utilizzare la replica basata su riga, basata su istruzioni o quella mista. La replica basata su riga replica solamente le righe modificate che risultano da un'istruzione SQL. La replica basata su istruzioni replica l'intera istruzione SQL. La replica mista utilizza la replica basata su istruzione quando possibile, ma passa alla replica basata su riga quando vengono eseguite le istruzioni SQL che non sono sicure per la replica basata su istruzione. Nella maggior parte dei casi, si consiglia l'utilizzo della replica mista. Il formato di log binario dell'istanza database determina se la replica è basata su riga, su istruzione o è mista. Per informazioni sull'impostazione del formato di log binario, consulta [Configurazione di MySQL RDS per la registrazione binaria MySQL per database Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md).
**Nota**
Puoi configurare la replica per l'importazione di database da un'istanza MariaDB o MySQL esterna ad Amazon RDS o per l'esportazione di database a tali istanze. Per ulteriori informazioni, consultare [Importazione dei dati in un database Amazon RDS per MySQL con tempo di inattività ridotto](mysql-importing-data-reduced-downtime.md) e [Esportazione di dati da un'istanza database MySQL tramite la replica](MySQL.Procedural.Exporting.NonRDSRepl.md).
Dopo aver ripristinato l'istanza DB da un'istantanea o eseguito un point-in-time ripristino, è possibile visualizzare l'ultima posizione del binlog recuperata dal database di origine nella console RDS. In **Log ed eventi**, immettere **Binlog**. La posizione del log binario viene visualizzata in **Note di sistema**.
**Topics**
+ [
# Uso delle repliche di lettura MySQL
](USER_MySQL.Replication.ReadReplicas.md)
+ [
# Utilizzo della replica basata su GTID
](mysql-replication-gtid.md)
+ [
# Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.
](MySQL.Procedural.Importing.External.Repl.md)
+ [
# Configurazione multi-source-replication per Amazon RDS for MySQL
](mysql-multi-source-replication.md)
# Uso delle repliche di lettura MySQL
Questa sezione contiene informazioni specifiche sull'utilizzo delle repliche di lettura su RDS per MySQL. Per informazioni generali sulle repliche di lettura e istruzioni su come usarle, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Per ulteriori informazioni sulle repliche di lettura MySQL, consulta gli argomenti riportati di seguito.
+ [Configurazione dei filtri di replica con MySQL](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md)
+ [Configurazione della replica ritardata con MySQL](USER_MySQL.Replication.ReadReplicas.DelayReplication.md)
+ [Aggiornamento di repliche di lettura con MySQL](USER_MySQL.Replication.ReadReplicas.Updates.md)
+ [Utilizzo di implementazioni Multi-AZ di repliche di lettura con MySQL](USER_MySQL.Replication.ReadReplicas.MultiAZ.md)
+ [Utilizzo di repliche di lettura a cascata con RDS per MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md)
+ [Monitoraggio del ritardo di replica per le repliche di lettura MySQL](USER_MySQL.Replication.ReadReplicas.Monitor.md)
+ [Avvio e arresto della replica con repliche di lettura MySQL](USER_MySQL.Replication.ReadReplicas.StartStop.md)
+ [Risoluzione dei problemi relativi a una replica di lettura MySQL](USER_ReadRepl.Troubleshooting.md)
## Configurazione delle repliche di lettura con MySQL
Prima di poter utilizzare un'istanza database MySQL come un'origine delle replica, assicurati di abilitare i backup automatici sull'istanza database di origine. A questo scopo, imposta il periodo di retention dei backup su un valore diverso da zero. Questo requisito si applica anche a una replica di lettura che rappresenta l'istanza database di origine per un'altra replica di lettura. I backup automatici vengono solo supportati per le repliche di lettura che eseguono qualsiasi versione di MySQL. Puoi configurare la replica in base alle coordinate del log binario per un'istanza database MySQL.
È possibile configurare la replica utilizzando gli ID globali di transazione (GTID) nelle seguenti versioni:
+ RDS per MySQL versione 5.7.44 e versioni successive alla 5.7
+ RDS per MySQL versione 8.0.28 e versioni successive alla 8.0
+ RDS per MySQL versione 8.4.3 e versioni successive alla 8.4
Per ulteriori informazioni, consulta [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
È possibile creare fino a 15 repliche di lettura da un'istanza database nella stessa regione. Per un efficace funzionamento della replica, ciascuna replica di lettura dovrebbe avere la stessa quantità di risorse di calcolo e storage dell'istanza database di origine. Se si dimensiona l'istanza database di origine, si devono dimensionare anche le repliche di lettura.
RDS per MySQL supporta le repliche di lettura a cascata. Per informazioni su come configurare le repliche di lettura a cascata, consulta [Utilizzo di repliche di lettura a cascata con RDS per MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md).
Puoi eseguire più operazioni di creazione ed eliminazione di repliche di lettura simultanee che fanno riferimento alla stessa istanza database di origine. Quando esegui queste operazioni, rimani entro il limite delle 15 repliche di lettura per ogni istanza di origine.
Una replica in lettura di un'istanza DB MySQL non può utilizzare una versione del motore DB inferiore rispetto alla sua istanza DB di origine.
### Preparazione delle istanze database MySQL che utilizzano MyISAM
Se l'istanza database MySQL utilizza un motore non transazionale come MyISAM, devi eseguire la seguente procedura per configurare correttamente la replica di lettura. Questa procedura è necessaria per verificare che la replica di lettura contenga una copia coerente dei dati. Non è invece necessaria alcuna procedura se tutte le tabelle usano un motore transazionale come InnoDB.
1. Arresta tutte le operazioni DML (Data Manipulation Language) e DDL (Data Definition Language) sulle tabelle non transazionali nell'istanza database di origine e attendi il loro completamento. Le istruzioni SELECT possono restare in esecuzione.
1. Scarica e blocca le tabelle nell'istanza database di origine.
1. Crea una replica di lettura usando uno dei metodi nelle seguenti sezioni.
1. Verifica lo stato di avanzamento della creazione della replica di lettura utilizzando, ad esempio, l'operazione API `DescribeDBInstances`. Dopo che la replica di lettura è disponibile, sblocca le tabelle dell'istanza database di origine e ripristina le normali operazioni del database.
# Configurazione dei filtri di replica con MySQL
Puoi utilizzare i filtri di replica per specificare quali database e tabelle vengono replicati con una replica di lettura. I filtri di replica possono includere database e tabelle nella replica o escluderli dalla replica.
Di seguito sono riportati alcuni casi d'uso per i filtri di replica:
+ Per ridurre le dimensioni di una replica di lettura. Con il filtro di replica è possibile escludere i database e le tabelle che non sono necessari nella replica di lettura.
+ Per escludere database e tabelle dalle repliche di lettura per motivi di sicurezza.
+ Per replicare database e tabelle diversi per casi d'uso specifici in repliche di lettura diverse. Ad esempio, è possibile utilizzare repliche di lettura specifiche per l'analisi o la condivisione.
+ Per un'istanza DB che ha repliche di lettura in diversi Regioni AWS, per replicare database o tabelle diversi in diversi. Regioni AWS
**Nota**
Puoi utilizzare i filtri di replica anche per specificare i database e le tabelle che vengono replicati con un'istanza database MySQL primaria configurata come replica in una topologia di replica in ingresso. Per ulteriori informazioni su questa configurazione, consulta [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.Repl.md).
**Topics**
+ [
## Impostazione dei parametri di filtro della replica RDS for MySQL
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [
## Limitazioni di filtro delle repliche per RDS per MySQL
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [
## Esempi di filtri di replica per RDS per MySQL
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [
## Visualizzazione dei filtri di replica per una replica di lettura
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Viewing)
## Impostazione dei parametri di filtro della replica RDS for MySQL
Per configurare i filtri di replica, impostare i seguenti parametri di filtro replica sulla replica di lettura:
+ `replicate-do-db` – Replicare le modifiche ai database specificati. Quando si imposta questo parametro per una replica di lettura, vengono replicati solo i database specificati nel parametro.
+ `replicate-ignore-db` – Non replicare le modifiche ai database specificati. Quando il parametro `replicate-do-db` è impostato per una replica di lettura, questo parametro non viene valutato.
+ `replicate-do-table` – Replicare le modifiche alle tabelle specificate. Quando si imposta questo parametro per una replica di lettura, vengono replicate solo le tabelle specificate nel parametro. Inoltre, quando viene impostato il parametro `replicate-do-db` o `replicate-ignore-db`, assicurarsi di includere il database che include le tabelle specificate nella replica con la replica di lettura.
+ `replicate-ignore-table` – Non replicare le modifiche alle tabelle specificate. Quando il parametro `replicate-do-table` è impostato per una replica di lettura, questo parametro non viene valutato.
+ `replicate-wild-do-table` – Replicare le tabelle in base ai modelli di nome del database e della tabella specificati. I caratteri jolly `%` e `_` sono supportati. Quando è impostato il parametro `replicate-do-db` o `replicate-ignore-db`, assicurarsi di includere il database che include le tabelle specificate nella replica con la replica di lettura.
+ `replicate-wild-ignore-table` – Non replicare le tabelle in base ai modelli di nomi di database e tabella specificati. I caratteri jolly `%` e `_` sono supportati. Quando è impostato il parametro `replicate-do-table` o `replicate-wild-do-table` per una replica di lettura, questo parametro non viene valutato.
I parametri vengono valutati nell'ordine in cui sono elencati. Per ulteriori informazioni sul funzionamento di questi parametri, consulta la documentazione di MySQL:
+ Per informazioni generali, consulta [Opzioni e variabili del server di replica](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html).
+ Per informazioni sulla modalità di valutazione dei parametri di filtro della replica del database, consulta [Valutazione delle opzioni di replica a livello di database e registrazione binaria](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-db-options.html).
+ Per informazioni sulla modalità di valutazione dei parametri di filtro replica delle tabelle, consulta [Valutazione delle opzioni di replica a livello di tabella](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-table-options.html).
Per impostazione predefinita, ognuno di questi parametri ha un valore vuoto. In ogni replica di lettura, è possibile utilizzare questi parametri per impostare, modificare ed eliminare i filtri di replica. Quando viene impostato uno di questi parametri, è necessario separare ogni filtro dagli altri con una virgola.
È possibile utilizzare i caratteri jolly `%` e `_` nei parametri `replicate-wild-do-table` e `replicate-wild-ignore-table`. Il carattere jolly `%` corrisponde a un numero qualsiasi di caratteri e il carattere jolly `_` corrisponde a un solo carattere.
Il formato di registrazione binaria dell'istanza database di origine è importante per la replica perché determina il record delle modifiche ai dati. L'impostazione del parametro `binlog_format` determina se la replica è basata su righe o basata su dichiarazione. Per ulteriori informazioni, consulta [Configurazione di MySQL RDS per la registrazione binaria MySQL per database Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md).
**Nota**
Tutte le istruzioni DDL (Data Definition Language) vengono replicate come istruzioni, indipendentemente dall'impostazione `binlog_format` dell'istanza database di origine.
## Limitazioni di filtro delle repliche per RDS per MySQL
Le seguenti limitazioni si applicano al filtro di replica per RDS per MySQL:
+ Ogni parametro di filtro della replica ha un limite di 2.000 caratteri.
+ Le virgole non sono supportate nei filtri di replica per i valori dei parametri. In un elenco di parametri, le virgole possono essere utilizzate solo come separatori di valori. Ad esempio, `ParameterValue='`a,b`'` non è supportato, ma `ParameterValue='a,b'` è supportato.
+ Le opzioni MySQL `--binlog-do-db` e `--binlog-ignore-db` per il filtro dei log binari non sono supportate.
+ Il filtro delle repliche non supporta le transazioni XA.
Per ulteriori informazioni, consulta [Restrizioni sulle transazioni XA](https://dev.mysql.com/doc/refman/8.0/en/xa-restrictions.html) nella documentazione di MySQL.
## Esempi di filtri di replica per RDS per MySQL
Per configurare il filtro di replica per una replica di lettura, modificare i parametri di filtro replica nel gruppo di parametri associato alla replica di lettura.
**Nota**
Non è consentito modificare un gruppo di parametri predefinito. Se la replica di lettura usa un gruppo di parametri predefinito, creare un nuovo gruppo di parametri e associarlo alla replica di lettura. Per ulteriori informazioni sui gruppi di parametri database, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
È possibile impostare i parametri in un gruppo di parametri utilizzando Console di gestione AWS AWS CLI, o l'API RDS. Per informazioni sull'estensione dei parametri consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). Quando si impostano parametri in un gruppo di parametri, tutte le istanze DB associate al gruppo di parametri utilizzano le impostazioni dei parametri. Se si impostano i parametri di filtro della replica in un gruppo di parametri, assicurarsi che il gruppo di parametri sia associato solo alle repliche di lettura. Lasciare vuoti i parametri di filtro di replica per le istanze database di origine.
Negli esempi seguenti vengono impostati i parametri utilizzando AWS CLI. In questi esempi si imposta `ApplyMethod` su `immediate` in modo che le modifiche ai parametri avvengano immediatamente dopo il completamento del comando della CLI. Se si desidera applicare una modifica in sospeso dopo il riavvio della replica di lettura, impostare `ApplyMethod` su `pending-reboot`.
Gli esempi seguenti impostano i filtri di replica:
+ [Including databases in replication](#rep-filter-in-dbs-mysql)
+ [Including tables in replication](#rep-filter-in-tables-mysql)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mysql)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mysql)
+ [Excluding tables from replication](#rep-filter-ex-tables-mysql)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mysql)
**Example Inclusione dei database nella replica**
Nell'esempio seguente sono inclusi i database `mydb1` e `mydb2` nella replica.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
**Example Inclusione delle tabelle nella replica**
Nell'esempio seguente sono incluse le tabelle `table1` e `table2` nel database `mydb1` nella replica.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
**Example Inclusione di tabelle nella replica utilizzando caratteri jolly**
Nell'esempio seguente sono incluse tabelle con nomi che iniziano con `order` e `return` nel database `mydb` nella replica.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
**Example Esclusione di database dalla replica**
Nell'esempio seguente vengono esclusi i database `mydb5` e `mydb6` dalla replica.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
**Example Esclusione di tabelle dalla replica**
Nell'esempio seguente vengono escluse dalla replica le tabelle `table1` nel database `mydb5` e `table2` nel database `mydb6`.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
**Example Esclusione di tabelle dalla replica utilizzando caratteri jolly**
Nell'esempio seguente vengono escluse le tabelle con nomi che iniziano con `order` e `return` nel database `mydb7` dalla replica.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
## Visualizzazione dei filtri di replica per una replica di lettura
È possibile visualizzare i filtri di replica per una replica di lettura nei seguenti modi:
+ Controllare le impostazioni dei parametri di filtro replica nel gruppo di parametri associato alla replica di lettura.
Per istruzioni, consulta [Visualizzazione dei valori dei parametri per un gruppo di parametri del database in Amazon RDS](USER_WorkingWithParamGroups.Viewing.md).
+ In un client MySQL, connettersi alla replica di lettura ed eseguire l'istruzione `SHOW REPLICA STATUS`.
Nell'output, i campi seguenti mostrano i filtri di replica per la replica di lettura:
+ `Replicate_Do_DB`
+ `Replicate_Ignore_DB`
+ `Replicate_Do_Table`
+ `Replicate_Ignore_Table`
+ `Replicate_Wild_Do_Table`
+ `Replicate_Wild_Ignore_Table`
Per ulteriori informazioni su questi campi, consulta [Verifica dello stato della replica](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) nella documentazione di MariaDB.
# Configurazione della replica ritardata con MySQL
Puoi usare la replica ritardata come strategia per il disaster recovery. Con la replica ritardata puoi specificare il tempo minimo, in secondi, di ritardo della replica rispetto all'origine nella replica di lettura. In caso di emergenza, come ad esempio l'eliminazione accidentale di una tabella, completa la seguente procedura per risolvere velocemente il problema:
+ Arresta la replica sulla replica di lettura prima che la modifica che ha provocato il problema venga inviata.
Usa la procedura archiviata [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) per arrestare la replica.
+ Avvia la replica e specifica che la replica si arresta automaticamente in corrispondenza di una posizione del file di log.
Puoi specificare una posizione prima dell'emergenza utilizzando la procedura archiviata [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
+ Utilizza le istruzioni contenute in [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md) per promuovere la replica di lettura a nuova istanza database di origine.
**Nota**
Su RDS for MySQL 8.4, la replica ritardata è supportata per MySQL 8.4.3 e versioni successive. Su RDS per MySQL 8,0, la replica ritardata è supportata per MySQL 8.0.28 e versioni successive. In RDS for MySQL 5.7, la replica ritardata è supportata per MySQL 5.7.44 e versioni successive.
Utilizza le procedure archiviate per configurare la replica ritardata. Non puoi configurare la replica ritardata con Console di gestione AWS, the o l' AWS CLI API Amazon RDS.
Puoi utilizzare la replica basata sugli identificatori di transazione globali (GTIDs) in una configurazione di replica ritardata per le seguenti versioni:
RDS per MySQL versione 5.7.44 e versioni successive alla 5.7
RDS per MySQL versione 8.0.28 e versioni successive alla 8.0
RDS per MySQL versione 8.4.3 e versioni successive alla 8.4
Se si utilizza la replica basata su GTID, scegliere la stored procedure [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) invece della [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). Per ulteriori informazioni sulla replica basata su GTID, consultare [Utilizzo della replica basata su GTID](mysql-replication-gtid.md).
**Topics**
+ [
## Configurazione della replica ritardata durante la creazione della replica di lettura
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [
## Modifica della replica ritardata per una replica di lettura esistente
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [
## Definire una posizione per arrestare la replica su una replica di lettura
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.StartUntil)
+ [
## Promozione di una replica di lettura
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.Promote)
## Configurazione della replica ritardata durante la creazione della replica di lettura
Per configurare la replica ritardata per eventuali repliche di lettura future create da un'istanza database, esegui la stored procedure [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) con il parametro `target delay`.
**Per configurare le replica ritardata durante la creazione della replica di lettura**
1. Utilizzando un client MySQL, connettersi all'istanza database MySQL che sarà l'origine delle repliche di lettura come l'utente master.
1. Eseguire la procedura archiviata [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) con il parametro `target delay`.
Ad esempio, eseguire la seguente procedura archiviata per specificare che la replica è ritardata per almeno un'ora (3.600 secondi) per le repliche di lettura create dall'istanza database corrente.
```
call mysql.rds_set_configuration('target delay', 3600);
```
**Nota**
Dopo aver eseguito questa procedura memorizzata, qualsiasi replica di lettura creata utilizzando l'API AWS CLI o Amazon RDS viene configurata con una replica ritardata del numero di secondi specificato.
## Modifica della replica ritardata per una replica di lettura esistente
Per modificare la replica ritardata per una replica di lettura esistente, esegui la stored procedure [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
**Per modificare la replica ritardata per una replica di lettura esistente**
1. Utilizzando un client MySQL, connettersi alla replica di lettura come utente master.
1. Usa la procedura archiviata [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) per arrestare la replica.
1. Eseguire la procedura archiviata [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
Ad esempio, eseguire la seguente stored procedure per specificare che la replica sulla replica di lettura è ritardata per almeno un'ora (3600 secondi).
```
call mysql.rds_set_source_delay(3600);
```
1. Usare la procedura archiviata [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) per avviare la replica.
## Definire una posizione per arrestare la replica su una replica di lettura
Dopo aver arrestato la replica sulla replica di lettura, puoi avviare la replica e poi arrestarla in corrispondenza della posizione del file di log binario specificato utilizzando la procedura archiviata [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
**Per avviare la replica su una replica di lettura e arrestare la replica in corrispondenza di una posizione specifica**
1. Utilizzando un client MySQL, connettersi all'istanza database MySQL di origine come utente master.
1. Eseguire la procedura archiviata [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
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`. In caso di disaster recovery, presumere che la posizione `120` si riferisca al momento immediatamente precedente l'errore.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
La replica si arresta automaticamente quando viene raggiunto il punto di arresto. Viene generato il seguente evento RDS: `Replication has been stopped since the replica reached the stop point specified by the rds_start_replication_until stored procedure`.
## Promozione di una replica di lettura
Dopo l'arresto della replica, in uno scenario di disaster recovery, puoi promuovere la replica di lettura come nuova istanza database di origine. Per informazioni sulla promozione di una replica di lettura, consulta [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
# Aggiornamento di repliche di lettura con MySQL
Le repliche di lettura sono progettate per supportare query di lettura, ma occasionalmente potrebbe essere necessario eseguire aggiornamenti. Ad esempio, potresti dover aggiungere un indice per ottimizzare i tipi specifici di query che accedono alla replica.
Sebbene sia possibile abilitare gli aggiornamenti impostando il parametro `read_only` su `0` nel gruppo di parametri database per la replica di lettura, si consiglia di non farlo perché questa operazione può causare problemi se la replica di lettura diventa non compatibile con l'istanza database di origine. Per le operazioni di manutenzione, si consiglia di utilizzare le blue/green distribuzioni. Per ulteriori informazioni, consulta [Utilizzo di Deployments Blue/Green per gli aggiornamenti del database](blue-green-deployments.md).
Se disabiliti la modalità di sola lettura su una replica di lettura, modifica il valore del parametro `read_only` impostandolo su `1` il prima possibile.
# Utilizzo di implementazioni Multi-AZ di repliche di lettura con MySQL
Puoi creare una replica di lettura da implementazioni Single-AZ o Multi-AZ di istanze database. Puoi usare implementazioni Multi-AZ per migliorare la durabilità e la disponibilità di dati critici, ma non puoi usare l'istanza secondaria Multi-AZ per inviare query di sola lettura. Puoi invece creare repliche di lettura da istanze database Multi-AZ con traffico elevato per l'offload di query di sola lettura. Se viene eseguito il failover dell'istanza di origine di un'implementazione Multi-AZ all'istanza secondaria, tutte le repliche di lettura passeranno automaticamente a usare l'istanza secondaria (ora primaria) come origine della replica. Per ulteriori informazioni, consulta [Configurazione e gestione di un’implementazione Multi-AZ per Amazon RDS](Concepts.MultiAZ.md).
È possibile creare una replica di lettura come istanza database Multi-AZ. Amazon RDS crea una replica di standby in un'altra zona di disponibilità per il supporto del failover per la replica. La creazione della replica di lettura come un'istanza database Multi-AZ non dipende dal fatto che il database di origine sia un'istanza database Multi-AZ.
# Utilizzo di repliche di lettura a cascata con RDS per MySQL
RDS per MySQL supporta le repliche di lettura a cascata. Con le *repliche di lettura a cascata*, puoi dimensionare le letture senza aggiungere sovraccarico all'istanza database RDS per MySQL di origine.
Con le repliche di lettura a cascata, l'istanza database RDS per MySQL invia i dati alla prima replica di lettura della catena. La replica di lettura invia quindi i dati alla seconda replica della catena e così via. Il risultato finale è che tutte le repliche di lettura nella catena includono le modifiche dall'istanza database RDS per MySQL, ma senza sovraccaricare esclusivamente l'istanza database di origine.
È possibile creare una serie di fino a tre repliche di lettura in una catena da un'istanza database RDS per MySQL di origine. Ad esempio, supponi di avere l'istanza database RDS per MySQL `mysql-main`. Puoi eseguire le operazioni indicate di seguito:
+ A partire da `mysql-main`, crea la prima replica di lettura nella catena, `read-replica-1`.
+ Da `read-replica-1`, crea quindi la successiva replica di lettura nella catena, `read-replica-2`.
+ Da `read-replica-2`, crea infine la terza replica di lettura nella catena, `read-replica-3`.
Non è possibile creare un'altra replica di lettura oltre la terza replica di lettura a cascata nella serie per `mysql-main`. Una serie completa di istanze da un'istanza database RDS per MySQL di origine fino alla fine di una serie di repliche di lettura a cascata può essere composta al massimo da quattro istanze database.
Affinché le repliche di lettura a cascata funzionino, ogni istanza database RDS per MySQL di origine deve avere i backup automatici attivati. Per abilitare i backup automatici in una replica di lettura, crea prima di tutto la replica di lettura, quindi modificala in modo da abilitare i backup automatici. Per ulteriori informazioni, consulta [Creazione di una replica di lettura](USER_ReadRepl.Create.md).
Come per qualsiasi replica di lettura, puoi promuovere una replica di lettura appartenente a una cascata. La promozione di una replica di lettura all'interno di una catena di repliche di lettura rimuove la replica dalla catena. Ad esempio, supponi di voler spostare parte del carico di lavoro fuori dall'istanza database `mysql-main` in una nuova istanza usata solo dal reparto contabile. Facendo riferimento alla catena di tre repliche di lettura dell'esempio, decidi di promuovere `read-replica-2`. La catena verrà modificata come segue:
+ La promozione `read-replica-2` rimuove l'istanza dalla catena di replica.
+ Ora è un'istanza database completa di lettura/scrittura.
+ Continua a replicare su `read-replica-3`, proprio come prima della promozione.
+ L'istanza `mysql-main` continua a venire replicata su `read-replica-1`.
Per ulteriori informazioni sulla promozione delle repliche di lettura, consulta [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
# Monitoraggio del ritardo di replica per le repliche di lettura MySQL
Per le repliche di lettura MySQL, puoi monitorare il ritardo di replica in Amazon CloudWatch visualizzando il parametro Amazon RDS `ReplicaLag`. Il parametro `ReplicaLag` segnala il valore del campo `Seconds_Behind_Master` del comando `SHOW REPLICA STATUS`.
Le cause comuni del ritardo di replica per MySQL sono le seguenti:
+ Interruzione della connessione di rete.
+ Scrittura su tabelle con indici diversi su una replica di lettura. Se il parametro `read_only` è impostato su `0` sulla replica di lettura, la replica può interrompersi se la replica di lettura diventa incompatibile con l'istanza database di origine. Dopo aver eseguito operazioni di manutenzione sulla replica di lettura, consigliamo di ripristinare il parametro `read_only` a `1`.
+ Uso di un motore di storage non transazionale come MyISAM. La replica è supportata solo per il motore di storage InnoDB su MySQL.
Quando il parametro `ReplicaLag` è 0, la replica ha raggiunto l'istanza del database di origine. Se il parametro `ReplicaLag` restituisce -1, la replica non è attualmente attiva. `ReplicaLag` = -1 equivale a `Seconds_Behind_Master` = `NULL`.
# Avvio e arresto della replica con repliche di lettura MySQL
Puoi arrestare e riavviare il processo di replica in un'istanza database Amazon RDS chiamando le stored procedure di sistema [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication). Puoi procedere in questo modo quando esegui la replica tra due istanze Amazon RDS per operazioni a esecuzione prolungata, come la creazione di indici di grandi dimensioni. Devi arrestare e avviare la replica anche durante l'importazione o l'esportazione di database. Per ulteriori informazioni, consultare [Importazione dei dati in un database Amazon RDS per MySQL con tempo di inattività ridotto](mysql-importing-data-reduced-downtime.md) e [Esportazione di dati da un'istanza database MySQL tramite la replica](MySQL.Procedural.Exporting.NonRDSRepl.md).
Se la replica viene arrestata per più di 30 giorni consecutivi, manualmente o a causa di un errore di replica, Amazon RDS termina la replica tra l'istanza database di origine e tutte le repliche di lettura. Questo avviene per evitare requisiti di storage maggiori sull'istanza database di origine e tempi di failover prolungati. L'istanza database della replica di lettura continua a essere disponibile. Tuttavia, la replica non può essere ripresa, perché i log binari richiesti dalla replica di lettura vengono eliminati dall'istanza database di origine una volta terminata la replica. Puoi creare una nuova replica di lettura per l'istanza database di origine per ristabilire la replica.
# Risoluzione dei problemi relativi a una replica di lettura MySQL
Per le istanze database MySQL, in alcuni casi le repliche di lettura presentano errori o incoerenze (o entrambi) dei dati tra la replica di lettura e la sua istanza database di origine. Questo problema si verifica quando alcuni eventi log binario (binlog) o log redo InnoDB non vengono scaricati durante un errore della replica di lettura o dell'istanza database di origine. In questi casi, elimina e ricrea manualmente le repliche di lettura. Puoi ridurre le possibilità che si verifichi una situazione di questo tipo impostando i seguenti valori dei parametri: `sync_binlog=1` e `innodb_flush_log_at_trx_commit=1`. Tali impostazioni potrebbero ridurre le prestazioni, per cui ti consigliamo di testare il loro impatto prima di implementare le modifiche nell'ambiente di produzione.
**avvertimento**
Nel gruppo di parametri associato all'istanza database di origine, consigliamo di mantenere i valori di questi parametri: `sync_binlog=1` e `innodb_flush_log_at_trx_commit=1`. Questi parametri sono dinamici. Se non vuoi utilizzare queste impostazioni, ti consigliamo di impostare temporaneamente tali valori prima di eseguire qualsiasi operazione sull'istanza database di origine che potrebbe causarne il riavvio. Queste operazioni includono, a titolo esemplificativo ma non esaustivo, il riavvio, il riavvio con failover, l'aggiornamento della versione del database e la modifica della classe di istanza database o della relativa archiviazione. Lo stesso suggerimento si applica alla creazione di nuove repliche di lettura per l'istanza database di origine.
Il mancato rispetto di questa guida aumenta il rischio che le repliche di lettura presentino errori o incoerenze dei dati (o entrambe) tra la replica di lettura e la sua istanza database di origine.
Le tecnologie di replica per MySQL sono asincrone. Per questo motivo, devi occasionalmente aspettarti incrementi del parametro `BinLogDiskUsage` per l'istanza database di origine e del parametro `ReplicaLag` per la replica di lettura. Ad esempio, può verificarsi un elevato volume di scrittura in parallelo nell'istanza database di origine. Al contrario, le operazioni di scrittura nella replica di lettura vengono serializzate usando un singolo thread di I/O, causando un ritardo tra l'istanza di origine e la replica di lettura. Per ulteriori informazioni sulle repliche di sola lettura, consulta le [informazioni dettagliate sull'implementazione di repliche](https://dev.mysql.com/doc/refman/8.0/en/replication-implementation-details.html) nella documentazione di MySQL.
Puoi ridurre il ritardo tra gli aggiornamenti di un'istanza database di origine e i successivi aggiornamenti della replica di lettura in diversi modi, ad esempio:
+ Dimensionando una replica di lettura in modo che dimensioni di storage e classe dell'istanza database siano equivalenti all'istanza database di origine.
+ Assicurandoti che le impostazioni dei parametri nei gruppi di parametri database usati dall'istanza database di origine e dalla replica di lettura siano compatibili. Per ulteriori informazioni e un esempio, consulta la discussione sul parametro `max_allowed_packet` più avanti in questa sezione.
Amazon RDS monitora lo stato delle repliche di lettura e aggiorna il campo `Replication State` dell'istanza della replica di lettura con il valore `Error` se la replica viene arrestata per qualsiasi motivo. Un possibile esempio è quando query DML in esecuzione nella replica di lettura sono in conflitto con gli aggiornamenti eseguiti nell'istanza database di origine.
Puoi esaminare i dettagli dell'errore associato generato dal motore MySQL visualizzando il campo `Replication Error`. Vengono generati anche eventi che indicano lo stato della replica di lettura, inclusi [RDS-EVENT-0045](USER_Events.Messages.md#RDS-EVENT-0045), [RDS-EVENT-0046](USER_Events.Messages.md#RDS-EVENT-0046) e [RDS-EVENT-0047](USER_Events.Messages.md#RDS-EVENT-0047). Per ulteriori informazioni sugli eventi e sulla sottoscrizione a essi, consulta [Utilizzo della notifica degli eventi di Amazon RDS](USER_Events.md). Se viene restituito un messaggio di errore MySQL, verifica il numero di errore nella [documentazione dei messaggi di errore MySQL](https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html).
Un problema comune che può provocare errori di replica si verifica quando il valore del parametro `max_allowed_packet` per una replica di lettura è minore del parametro `max_allowed_packet` per l'istanza database di origine. Il parametro `max_allowed_packet` è un parametro personalizzato che puoi impostare in un gruppo di parametri database. Utilizza `max_allowed_packet` per specificare la dimensione massima del codice DML che può essere eseguito nel database. In alcuni casi, il valore `max_allowed_packet` nel gruppo dei parametri database associato alla replica di lettura è minore del valore `max_allowed_packet` nel gruppo dei parametri database associato all'istanza database di origine. In questi casi, il processo di replica può generare l'errore `Packet bigger than 'max_allowed_packet' bytes` e interrompere la replica. Per correggere l'errore, impostare l'istanza database di origine e la replica di lettura in modo che utilizzino i gruppi di parametri database con gli stessi valori del parametro `max_allowed_packet`.
Altre situazioni comuni che possono causare errori di replica includono le seguenti:
+ Scrittura in tabelle su una replica di lettura. In alcuni casi, potrebbe essere necessario creare indici su una replica di lettura che sono diversi dagli indici nell'istanza database di origine. In tal caso, imposta il parametro `read_only` su `0` per creare gli indici. Se scrivi in tabelle sulla replica di lettura, questa operazione potrebbe comportare l'interruzione della replica se la replica di lettura diventa incompatibile con l'istanza database di origine. Dopo aver eseguito attività di manutenzione sulla replica di lettura, ti consigliamo di ripristinare il parametro `read_only` su `1`.
+ Utilizzo di un motore di storage non transazionale come MyISAM. Le repliche di lettura richiedono un motore di storage transazionale. La replica è supportata solo per il motore di storage InnoDB su MySQL.
+ Utilizzo di query non deterministiche non sicure come `SYSDATE()`. Per ulteriori informazioni, consulta la pagina relativa alla [determinazione delle istruzioni sicure e non sicure nel log binario](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html).
Se decidi di poter ignorare un errore con certezza, puoi completare la procedura descritta nella sezione [Ignorare l’errore di replica corrente per RDS per MySQL](Appendix.MySQL.CommonDBATasks.SkipError.md). In caso contrario, puoi prima eliminare la replica di lettura. Quindi crea un'istanza utilizzando lo stesso identificatore istanze DB in modo che l'endpoint resti lo stesso di quello della replica di lettura precedente. Quando un problema relativo alla replica viene risolto, il campo `Replication State` (Stato di replica) cambia in *replicating (replica in corso)*.
# Utilizzo della replica basata su GTID
Di seguito sono riportate le indicazioni per utilizzare gli identificatori di transazione globali (GTID) con la replica basata sui log binari (binlog) tra istanze database Amazon RDS per MySQL.
Se si utilizza la replica basata su binlog e non si ha familiarità con la replica basata su GTID con MySQL, consulta [Replication with global transaction identifiers](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids.html) nella documentazione MySQL.
La replica basata su GTID è supportata per le seguenti versioni:
+ Tutte le versioni di RDS per MySQL 8.4
+ Tutte le versioni di RDS per MySQL 8.0
+ Tutte le versioni di RDS per MySQL 5.7
Tutte le istanze database MySQL in una configurazione di replica devono rispettare questo requisito relativo alla versione.
**Topics**
+ [
## Identificatori globali di transazione (GTID)
](#mysql-replication-gtid.overview)
+ [
## Parametri per la replica basata su GTID
](#mysql-replication-gtid.parameters)
+ [
# Abilitazione della replica basata su GTID per nuove repliche di lettura per RDS per MySQL
](mysql-replication-gtid.configuring-new-read-replicas.md)
+ [
# Abilitazione della replica basata su GTID per le repliche di lettura esistenti per RDS per MySQL
](mysql-replication-gtid.configuring-existing-read-replicas.md)
+ [
# Disabilitazione della replica basata su GTID per un'istanza database MySQL con repliche di lettura
](mysql-replication-gtid.disabling.md)
## Identificatori globali di transazione (GTID)
*Gli identificatori globali di transazione (GTID)* sono identificatori univoci generati per le transazioni MySQL sottoposte a commit. Puoi utilizzare i GTID per semplificare la replica basata sui log binari e facilitare la risoluzione dei problemi.
MySQL utilizza due diversi tipi di transazioni per la replica basata sui log binari:
+ *Transazioni GTID* – Transazioni identificate da un GTID.
+ *Transazioni anonime* – Transazioni a cui non è assegnato un GTID.
In una configurazione di replica, i GTID sono univoci in tutte le istanze database. I GTID semplificano la configurazione della replica perché, quando vengono utilizzati, non è necessario fare riferimento alle posizioni nel file di log. I GTID semplificano anche la registrazione delle transazioni replicate e verificano che l’istanza di origine e le repliche siano coerenti.
Puoi utilizzare la replica basata su GTID per replicare i dati con le repliche di lettura di RDS for MySQL. Puoi configurare la replica basata su GTID quando crei le nuove repliche di lettura oppure puoi convertire le repliche di lettura esistenti in modo che usino la replica basata su GTID.
Puoi utilizzare la replica basata su GTID anche in una configurazione di replica ritardata con RDS for MySQL. Per ulteriori informazioni, consulta [Configurazione della replica ritardata con MySQL](USER_MySQL.Replication.ReadReplicas.DelayReplication.md).
## Parametri per la replica basata su GTID
Utilizzare i parametri seguenti per configurare la replica basata su GTID.
| Parametro | Valori validi | Descrizione |
| --- | --- | --- |
| `gtid_mode` | `OFF`, `OFF_PERMISSIVE`, `ON_PERMISSIVE`, `ON` | `OFF` indica che le nuove transazioni sono anonime, ovvero non hanno GTID, e che una transazione deve essere anonima per poter essere replicata. `OFF_PERMISSIVE` indica che le nuove transazioni sono anonime, ma tutte le transazioni possono essere replicate. `ON_PERMISSIVE` indica che le nuove transazioni hanno GTID assegnati, ma tutte le transazioni possono essere replicate. `ON` indica che le nuove transazioni hanno GTID assegnati e che una transazione deve avere un GTID per poter essere replicata. |
| `enforce_gtid_consistency` | `OFF`, `ON`, `WARN` | `OFF` consente alle transazioni di violare la coerenza GTID. `ON` impedisce alle transazioni di violare la coerenza GTID. `WARN` consente alle transazioni di violare la consistenza GTID, ma genera un avviso quando si verifica una violazione. |
**Nota**
Nella Console di gestione AWS, il parametro `gtid_mode` viene visualizzato come `gtid-mode`.
Per la replica basata su GTID, utilizza queste impostazioni per il gruppo di parametri dell'istanza database o per la replica di lettura:
+ `ON` e `ON_PERMISSIVE` si applicano solo alla replica in uscita da un'istanza database RDS. Entrambi questi valori fanno sì che l'istanza database RDS utilizzi i GTID per le transazioni replicate. `ON` richiede che anche il database di destinazione utilizzi la replica basata su GTID. Per `ON_PERMISSIVE` la replica basata su GTID è opzionale sul database di destinazione.
+ `OFF_PERMISSIVE`, se impostato, significa che le istanze database RDS possono accettare la replica in ingresso da un database di origine. Possono farlo indipendentemente dal fatto che il database di origine utilizzi la replica basata su GTID.
+ `OFF`, se impostato, significa che le istanze database RDS accettano solo la replica in ingresso da database di origine che non utilizzano la replica basata su GTID.
Per ulteriori informazioni sui gruppi di parametri, consultare [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
# Abilitazione della replica basata su GTID per nuove repliche di lettura per RDS per MySQL
Quando la replica basata su GTID è abilitata per un'istanza database di RDS for MySQL, la replica basata su GTID viene configurata automaticamente per le repliche di lettura di un'istanza database.
**Per abilitare la replica basata su GTID per le nuove repliche di lettura**
1. Verificare che il gruppo di parametri associato all'istanza database abbia le impostazioni dei parametri seguenti:
+ `gtid_mode` – `ON` o `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
Per ulteriori informazioni sull'impostazione dei parametri di configurazione mediante i gruppi di parametri, consultare [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
1. Se è stato modificato un gruppo di parametri dell'istanza database, riavviare l'istanza. Per ulteriori informazioni su come effettuare questa operazione, consultare [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
1. Creare una o più repliche di lettura dell'istanza database. Per ulteriori informazioni su come effettuare questa operazione, consultare [Creazione di una replica di lettura](USER_ReadRepl.Create.md).
Amazon RDS prova a stabilire una replica basata su GTID tra l'istanza database di MySQL e le repliche di lettura utilizzando `MASTER_AUTO_POSITION`. Se il tentativo non riesce, Amazon RDS utilizza le posizioni del file di log per la replica con le repliche di lettura. Per ulteriori informazioni su `MASTER_AUTO_POSITION`, consultare l'argomento relativo al [ posizionamento automatico dei GTID](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-auto-positioning.html) nella documentazione di MySQL.
# Abilitazione della replica basata su GTID per le repliche di lettura esistenti per RDS per MySQL
Per un'istanza database di RDS for MySQL esistente con repliche di lettura che non utilizzano la replica basata su GTID, è possibile configurare la replica basata su GTID tra l'istanza database e le repliche di lettura.
**Per abilitare la replica basata su GTID per le repliche di lettura esistenti**
1. Se l'istanza database o qualsiasi replica di lettura sta utilizzando RDS versione 8.0 for MySQL versione 8.0.26 o precedente, aggiornare l'istanza database o la replica di lettura a MySQL 8.0.26 o versione successiva alla 8.0. Tutte le versioni di RDS per MySQL 8.4 e le versioni 5.7 supportano la replica basata su GTID.
Per ulteriori informazioni, consulta [Aggiornamenti del motore di database RDS per MySQL](USER_UpgradeDBInstance.MySQL.md).
1. (Facoltativo) Reimpostare i parametri GTID e verificare il comportamento dell'istanza database e delle repliche di lettura:
1. Verificare che il gruppo di parametri associato all'istanza database e ogni replica di lettura abbiano il parametro `enforce_gtid_consistency` impostato su `WARN`.
Per ulteriori informazioni sull'impostazione dei parametri di configurazione mediante i gruppi di parametri, consultare [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
1. Se è stato modificato un gruppo di parametri dell'istanza database, riavviare l'istanza. Se il gruppo di parametri è stato modificato per una replica di lettura, riavviare la replica.
Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
1. Eseguire l'istanza database e le repliche di lettura con il normale carico di lavoro e monitorare i file di log.
Se vengono visualizzati avvisi relativi a transazioni incompatibili con GTID, modificare l'applicazione in modo che usi solo caratteristiche compatibili con GTID. Verificare che l'istanza database non stia generando avvisi relativi a transazioni incompatibili con GTID prima di procedere alla prossima fase.
1. Reimpostare i parametri GTID per la replica basata su GTID che consente le transazioni anonime finché le repliche di lettura non ne completano l'elaborazione.
1. Verificare che il gruppo di parametri associato all'istanza database e ogni replica di lettura abbiano le impostazioni dei parametri seguenti:
+ `gtid_mode` – `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
1. Se è stato modificato un gruppo di parametri dell'istanza database, riavviare l'istanza. Se il gruppo di parametri è stato modificato per una replica di lettura, riavviare la replica.
1. Attendere il completamento della replica di tutte le transazioni anonime. Per verificare che vengano replicate, procedere come descritto di seguito:
1. Eseguire questa istruzione sull'istanza DB primaria.
**MySQL 8.4**
```
SHOW BINARY LOG STATUS;
```
**MySQL 5.7 e 8.0**
```
SHOW MASTER STATUS;
```
Annotare i valori nelle colonne `File` e `Position`.
1. In ogni replica di lettura, utilizzare le informazioni su file e posizione presenti nell’istanza di origine menzionata nella fase precedente per eseguire la query seguente.
```
SELECT MASTER_POS_WAIT('file', position);
```
Ad esempio, se il nome del file è `mysql-bin-changelog.000031` e la posizione è `107`, eseguire l'istruzione seguente.
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
Se la replica di lettura si trova dopo la posizione specificata, la query la restituisce immediatamente. In caso contrario, la funzione entra in attesa. Passare alla fase successiva quando la query restituisce risposte per tutte le repliche di lettura.
1. Reimpostare i parametri GTID solo per la replica basata su GTID.
1. Verificare che il gruppo di parametri associato all'istanza database e ogni replica di lettura abbiano le impostazioni dei parametri seguenti:
+ `gtid_mode` – `ON`
+ `enforce_gtid_consistency` – `ON`
1. Riavviare l'istanza database e ogni replica di lettura.
1. In ogni replica di lettura completare la procedura seguente.
**MySQL 8.4 e versioni principali successive**
```
CALL mysql.rds_set_source_auto_position(1);
```
**MySQL 8.0 e versioni secondarie precedenti**
```
CALL mysql.rds_set_master_auto_position(1);
```
# Disabilitazione della replica basata su GTID per un'istanza database MySQL con repliche di lettura
Puoi disabilitare la replica basata su GTID per un un'istanza database MySQL con repliche di lettura.
**Per disabilitare la replica basata su GTID per un'istanza database MySQL con repliche di lettura**
1. In ogni replica di lettura, esegui questa procedura:
**MySQL 8.4 e versioni principali successive**
```
CALL mysql.rds_set_source_auto_position(0);
```
**MySQL 8.0 e versioni secondarie precedenti**
```
CALL mysql.rds_set_master_auto_position(0);
```
1. Reimpostare `gtid_mode` su `ON_PERMISSIVE`.
1. Verifica che il gruppo di parametri associato all'istanza database MySQL e ogni replica di lettura abbiano `gtid_mode` impostato su `ON_PERMISSIVE`.
Per ulteriori informazioni sull'impostazione dei parametri di configurazione mediante i gruppi di parametri, consultare [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
1. Riavvia l'istanza database MySQL e ogni replica di lettura. Per ulteriori informazioni sul riavvio, consultare [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
1. Reimpostare `gtid_mode` su `OFF_PERMISSIVE`.
1. Verifica che il gruppo di parametri associato all'istanza database MySQL e ogni replica di lettura abbiano `gtid_mode` impostato su `OFF_PERMISSIVE`.
1. Riavvia l'istanza database MySQL e ogni replica di lettura.
1. Attendere che tutte le transazioni GTID vengano applicate a tutte le repliche di lettura. Per verificare che le transazioni siano applicate, esegui queste operazioni:
1. Su un’istanza database MySQL, esegui questo comando:
**MySQL 8.4**
```
SHOW BINARY LOG STATUS
```
**MySQL 5.7 e 8.0**
```
SHOW MASTER STATUS
```
L’output visualizzato dovrebbe essere simile al seguente.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
Annotare il file e la posizione nell'output.
1. In ogni replica di lettura, utilizza le informazioni su file e posizione presenti nell’istanza di origine menzionata nella fase precedente per eseguire la query seguente.
**MySQL 8.4 e MySQL 8.0.26 e versioni successive a MySQL 8.0**
```
SELECT SOURCE_POS_WAIT('file', position);
```
**MySQL 5.7**
```
SELECT MASTER_POS_WAIT('file', position);
```
Ad esempio, se il nome del file è `mysql-bin-changelog.000031` e la posizione è `107`, eseguire l’istruzione seguente.
**MySQL 8.4 e MySQL 8.0.26 e versioni successive a MySQL 8.0**
```
SELECT SOURCE_POS_WAIT('mysql-bin-changelog.000031', 107);
```
**MySQL 5.7**
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
1. Reimposta i parametri GTID per disabilitare la replica basata su GTID.
1. Verifica che il gruppo di parametri associato all'istanza database MySQL e ogni replica di lettura abbiano le impostazioni dei parametri seguenti:
+ `gtid_mode` – `OFF`
+ `enforce_gtid_consistency` – `OFF`
1. Riavvia l'istanza database MySQL e ogni replica di lettura.
# Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.
Puoi impostare la replica fra un'istanza database RDS for MySQL o MariaDB e un’istanza MySQL o MariaDB che è esterna ad Amazon RDS usando la replica del file di log binario.
**Topics**
+ [
## Prima di iniziare
](#MySQL.Procedural.Importing.External.Repl.BeforeYouBegin)
+ [
## Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.
](#MySQL.Procedural.Importing.External.Repl.Procedure)
## Prima di iniziare
È possibile configurare la replica utilizzando la posizione del file di log binario delle transazioni replicate.
Le autorizzazioni necessarie per avviare la replica in un'istanza database Amazon RDS sono limitate e non disponibili per l'utente master Amazon RDS. Per questo motivo, assicurati di utilizzare i comandi [mysql.rds\$1set\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) o [mysql.rds\$1set\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) in Amazon RDS per configurare la replica tra il database live e il database Amazon RDS.
Per impostare il formato di logging binario per un database MySQL o MariaDB, aggiornare il parametro `binlog_format`. Se l’istanza database utilizza il gruppo di parametri di istanza database predefinito, crea un nuovo gruppo di questo tipo per modificare il parametro `binlog_format`. In MariaDB e in MySQL 8.0 e versioni precedenti, il valore predefinito di `binlog_format` è `MIXED`. Tuttavia, puoi anche impostare `binlog_format` su `ROW` o `STATEMENT` se hai bisogno di un formato di registro binario (binlog) specifico. Riavvia l'istanza database affinché venga applicata la modifica. In MySQL 8.4 e versioni successive, il valore predefinito di `binlog_format` è `ROW`.
Per ulteriori informazioni sull'impostazione del parametro `binlog_format`, consulta [Configurazione di MySQL RDS per la registrazione binaria MySQL per database Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md) Per ulteriori informazioni sulle implicazioni dei vari tipi di replica MySQL, consulta la pagina relativa a [vantaggi e svantaggi della replica basata su istruzioni e basata su riga](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html) nella documentazione di MySQL.
## Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.
Seguire queste linee guida quando si imposta un'istanza di origine esterna e una replica su Amazon RDS:
+ Monitorare gli eventi di failover per l'istanza database di Amazon RDS che rappresenta la replica. In caso di failover, l'istanza database che rappresenta la replica potrebbe essere ricreata in un nuovo host con un indirizzo di rete diverso. Per informazioni su come monitorare gli eventi di failover, consulta [Utilizzo della notifica degli eventi di Amazon RDS](USER_Events.md).
+ Conservare i binlog sull'istanza di origine finché non si ha la conferma che siano stati applicati alla replica. Conservando questi file, si è certi di poter ripristinare l'istanza di origine in caso di errori.
+ Attivare i backup automatici sull'istanza database di Amazon RDS. L'attivazione dei backup automatici assicura il ripristino della replica a un punto temporale specifico nel caso fosse necessario risincronizzare l'istanza di origine e la replica. Per informazioni su backup e point-in-time ripristino, vedere[Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
**Per configurare la replica della posizione del file di log binario con un'istanza di origine esterna**
1. Rendere l'istanza MySQL o MariaDB di origine di sola lettura.
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Eseguire il comando `SHOW MASTER STATUS` nell'istanza database di MySQL o MariaDB di origine per determinare la posizione del binlog.
Viene restituito un output simile all'esempio seguente.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
1. Copiare il database dall'istanza esterna all'istanza database Amazon RDS usando `mysqldump`. Per database di dimensioni particolarmente elevate, è possibile utilizzare la procedura in [Importazione dei dati in un database Amazon RDS per MySQL con tempo di inattività ridotto](mysql-importing-data-reduced-downtime.md).
Per Linux, macOS o Unix:
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
Per Windows:
```
mysqldump --databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary ^
-u local_user ^
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**Nota**
Assicurarsi che non siano presenti spazi tra l'opzione `-p` e la password immessa.
Utilizzare le opzioni `--host`, `--user (-u)`, `--port` e `-p` nel comando `mysql` per specificare il nome host, il nome utente, la porta e la password per la connessione all'istanza database Amazon RDS. Il nome host è il nome DNS (Domain Name Service) dell'endpoint dell'istanza database di Amazon RDS, ad esempio `myinstance.123456789012.us-east-1.rds.amazonaws.com`. È possibile trovare il valore dell'endpoint nei dettagli dell'istanza nella Console di gestione AWS.
1. Rendere nuovamente scrivibile l'istanza MySQL o MariaDB di origine.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
Per ulteriori informazioni sulla creazione di backup da utilizzare con la replica, vedere [la documentazione di MySQL](https://dev.mysql.com/doc/refman/8.0/en/replication-solutions-backups-read-only.html).
1. Nel Console di gestione AWS, aggiungi l'indirizzo IP del server che ospita il database esterno al gruppo di sicurezza del cloud privato virtuale (VPC) per l'istanza database Amazon RDS. Per ulteriori informazioni sulla modifica di un gruppo di sicurezza VPC, consulta [Gruppi di sicurezza per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) nella *Guida per l'utente di Amazon Virtual Private Cloud*.
L'indirizzo IP può cambiare quando vengono soddisfatte le seguenti condizioni:
+ Si sta utilizzando un indirizzo IP pubblico per la comunicazione tra l'istanza di origine esterna e l'istanza database.
+ L'istanza di origine esterna è stata arrestata e riavviata.
Se queste condizioni vengono soddisfatte, verificare l'indirizzo IP prima di aggiungerlo.
Potrebbe anche essere necessario configurare la rete locale per consentire le connessioni dall'indirizzo IP dell'istanza database di Amazon RDS, affinché possa comunicare con l'istanza MySQL o MariaDB esterna. Per individuare l'indirizzo IP dell'istanza database di Amazon RDS, utilizzare il comando `host`.
```
host db_instance_endpoint
```
Il nome host è il nome DNS dall'endpoint dell'istanza database di Amazon RDS.
1. Utilizzando il client scelto, eseguire la connessione all'istanza esterna e creare un utente da utilizzare per la replica. Utilizza questo account unicamente per la replica e limitalo al dominio personale per aumentare la sicurezza. 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. Per l'istanza esterna, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all'utente della replica. Per concedere ad esempio i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` su tutti i database per l'utente "`repl_user`" del proprio dominio, eseguire questo comando.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Definire l'istanza database di Amazon RDS come replica. A tale scopo, connettersi innanzitutto all'istanza database di Amazon RDS come l'utente master. Quindi, identificare il database MySQL o MariaDB esterno come istanza di origine utilizzando il comando [mysql.rds\$1set\$1external\$1source (RDS per MySQL versioni principali 8.4 e successive)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) o [mysql.rds\$1set\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master). Utilizzare il nome e la posizione del file di log master recuperati nella fase 2. Di seguito sono riportati esempi di comandi.
**MySQL 8.4**
```
CALL mysql.rds_set_external_source ('mysourceserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MariaDB e MySQL 8.0 e 5.7**
```
CALL mysql.rds_set_external_master ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**Nota**
In RDS per MySQL è possibile scegliere di utilizzare la replica ritardata eseguendo in alternativa la stored procedure [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) o [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). Su RDS for MySQL, una ragione per utilizzare la replica ritardata è attuare il ripristino di emergenza con la procedura archiviata [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). Attualmente RDS for MariaDB supporta la replica ritardata ma non supporta la procedura `mysql.rds_start_replication_until`.
1. Nell'istanza database di Amazon RDS eseguire il comando [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) per avviare la replica.
```
CALL mysql.rds_start_replication;
```
# Configurazione multi-source-replication per Amazon RDS for MySQL
La replica da più origini consente di configurare un’istanza database Amazon RDS per MySQL come replica che riceve eventi del log binario da più di un’istanza database RDS per MySQL di origine. La replica da più origini è supportata per le istanze database RDS per MySQL con le versioni del motore seguenti:
+ Tutte le versioni di MySQL 8.4
+ 8.0.35 e versioni secondarie successive
+ 5.7.44 e versioni secondarie successive
Per informazioni sulla replica da più origini MySQL, consulta [MySQL Multi-Source Replication](https://dev.mysql.com/doc/refman/8.0/en/replication-multi-source.html) nella documentazione MySQL. La documentazione MySQL contiene informazioni dettagliate su questa funzionalità, mentre il presente argomento descrive come configurare e gestire i canali di replica da più origini nelle istanze database RDS per MySQL.
## Casi d’uso per la replica da più origini
L’uso della replica da più origini in RDS per MySQL è opportuna per le applicazioni o i requisiti seguenti:
+ Unione o combinazione di più shard di istanze database separate in un unico shard.
+ Generazione di report da dati consolidati da più origini.
+ Creazione di backup consolidati a lungo termine dei dati distribuiti tra più istanze database RDS per MySQL.
## Prerequisiti per la replica da più origini
Prima di configurare la replica da più origini, assicurarsi che siano rispettati i prerequisiti seguenti.
+ Per ogni istanza database RDS per MySQL di origine devono essere abilitati i backup automatici. L’abilitazione dei backup automatici consente di eseguire la registrazione di log binari. Per informazioni su come abilitare i backup automatici, consulta [Abilitazione dei backup automatici](USER_WorkingWithAutomatedBackups.Enabling.md).
+ Per evitare errori di replica, si consiglia di bloccare le operazioni di scrittura nelle istanze database di origine. A tale scopo, impostare il parametro `read-only` su `ON` in un gruppo di parametri personalizzato collegato all’istanza database RDS per MySQL di origine. Puoi usare Console di gestione AWS o the AWS CLI per creare un nuovo gruppo di parametri personalizzato o per modificarne uno esistente. Per ulteriori informazioni, consultare [Creazione di un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Creating.md) e [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
+ Per ogni istanza database di origine, aggiungere l’indirizzo IP dell’istanza database al gruppo di sicurezza Amazon Virtual Private Cloud (VPC) per l’istanza database da più origini. Per identificare l’indirizzo IP di un’istanza database di origine, eseguire il comando `dig RDS Endpoint` da un’istanza Amazon EC2 nello stesso gruppo VPC dell’istanza database da più origini.
+ Per ogni istanza database di origine, utilizzare un client per connettersi all’istanza database e creare un utente del database con i privilegi richiesti per la replica, come nell’esempio seguente.
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user';
```
**Nota**
A partire da MySQL 8.4, il privilegio `REPLICATION SLAVE` è obsoleto ed è stato sostituito da `REPLICATION REPLICA`. Per MySQL 8.4 e versioni successive, utilizzare la sintassi seguente:
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION REPLICA ON *.* TO 'repl_user';
```
## Configurazione di canali di replica da più origini in istanze database RDS per MySQL
La configurazione dei canali di replica da più origini è analoga a quella della replica da un’unica origine. Per la replica da più origini, attiva innanzitutto la registrazione di log binari nell’istanza di origine. Successivamente, importa i dati dalle origini nella replica da più origini, quindi avvia la replica da ciascuna origine utilizzando le coordinate del log binario oppure il posizionamento automatico GTID.
Per configurare un’istanza database RDS per MySQL come replica da più origini di due o più istanze database RDS per MySQL, esegui queste operazioni.
**Topics**
+ [
### Fase 1: importare i dati dalle istanze database di origine alla replica da più origini
](#mysql-multi-source-replication-import)
+ [
### Fase 2: avviare la replica dalle istanze database di origine nella replica da più origini
](#mysql-multi-source-replication-setting-up-start-replication-other)
### Fase 1: importare i dati dalle istanze database di origine alla replica da più origini
Esegui le operazioni seguenti per ogni istanza database di origine.
Prima di importare i dati da un’origine nella replica da più origini, esegui il comando `SHOW MASTER STATUS` per determinare il file di log binario e la posizione correnti. Annota questi dettagli per utilizzarli nella fase successiva. In questo output di esempio, il file è `mysql-bin-changelog.000031` e la posizione è `107`.
**Nota**
A partire da MySQL 8.4, il comando `SHOW MASTER STATUS` è obsoleto ed è stato sostituito da `SHOW BINARY LOG STATUS`. Per MySQL 8.4 e versioni successive, utilizza `SHOW BINARY LOG STATUS`.
```
File Position
-----------------------------------
mysql-bin-changelog.000031 107
-----------------------------------
```
Copia il database dall’istanza database di origine nella replica da più origini utilizzando `mysqldump`, come nell’esempio seguente.
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u RDS_user_name \
-p RDS_password \
--host=RDS Endpoint | mysql \
--host=RDS Endpoint \
--port=3306 \
-u RDS_user_name \
-p RDS_password
```
Dopo aver copiato il database, è possibile impostare il parametro di sola lettura su `OFF` nell’istanza database di origine.
### Fase 2: avviare la replica dalle istanze database di origine nella replica da più origini
Per ogni istanza database di origine, utilizza le credenziali dell’utente amministratore per connetterti all’istanza ed esegui le due stored procedure seguenti che configurano la replica su un canale e la avviano. In questo esempio si utilizzano il nome e la posizione del file binlog restituito dall’esempio nella fase precedente.
```
CALL mysql.rds_set_external_source_for_channel('mysourcehost.example.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1, 'channel_1');
CALL mysql.rds_start_replication_for_channel('channel_1');
```
Per ulteriori informazioni sull’utilizzo di queste e di altre stored procedure per l’impostazione e la gestione dei canali di replica, consulta [Gestione della replica da più origini](mysql-stored-proc-multi-source-replication.md).
## Utilizzo dei filtri con la replica da più origini
I filtri di replica consentono di specificare quali database e tabelle vengono replicati con una replica da più origini. I filtri di replica possono includere database e tabelle nella replica o escluderli dalla replica. Per ulteriori informazioni sui filtri di replica, consulta [Configurazione dei filtri di replica con MySQL](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md).
Con la replica da più origini è possibile configurare i filtri di replica a livello globale oppure a livello di canale. L’applicazione dei filtri a livello di canale è possibile solo nelle istanze database supportate che eseguono la versione 8.0 o la versione 8.4. Gli esempi seguenti mostrano come configurare i filtri a livello globale oppure a livello di canale.
Per l’applicazione dei filtri nella replica da più origini, tenere presente i requisiti seguenti:
+ I nomi dei canali devono essere racchiusi tra backtick (``).
+ Se si modificano i filtri di replica nel gruppo di parametri, l’elemento `sql_thread` della replica da più origini per tutti i canali con aggiornamenti viene riavviato per applicare dinamicamente le modifiche. Se un aggiornamento coinvolge un filtro globale, tutti i canali di replica in stato di esecuzione vengono riavviati.
+ Tutti i filtri globali vengono applicati prima di qualsiasi filtro specifico del canale.
+ Se un filtro viene applicato globalmente e a livello di canale, si utilizza solo il filtro a livello di canale. Ad esempio, se i filtri sono `replicate_ignore_db="db1,`channel_22`:db2"`, il filtro `replicate_ignore_db` impostato su `db1` viene applicato a tutti a canali ad eccezione di `channel_22` e solo `channel_22` ignora le modifiche da `db2`.
Esempio 1. Impostazione di un filtro globale
Nell’esempio seguente, il database `temp_data` è escluso dalla replica in ogni canale.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='temp_data',ApplyMethod=immediate"
```
Esempio 2. Impostazione di un filtro a livello di canale
Nell’esempio seguente, le modifiche dal database `sample22` sono incluse sono nel canale `channel_22`. In modo analogo, le modifiche dal database `sample99` sono incluse solo nel canale `channel_99`.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='\`channel_22\`:sample22,\`channel_99\`:sample99',ApplyMethod=immediate"
```
## Monitoraggio di canali di replica da più origini
Per monitorare i singoli canali in una replica da più origini, utilizzare uno dei metodi seguenti:
+ Per monitorare lo stato di tutti i canali o di un canale specifico, connettersi alla replica da più origini ed eseguire il comando `SHOW REPLICA STATUS` o `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'`. Per ulteriori informazioni, consulta [Verifica dello stato della replica](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) nella documentazione MySQL.
+ Per ricevere una notifica quando un canale di replica viene avviato, interrotto o rimosso, utilizzare la notifica di eventi RDS. Per ulteriori informazioni, consulta [Utilizzo della notifica degli eventi di Amazon RDS](USER_Events.md).
+ Per monitorare il ritardo per un canale specifico, controllare la relativa metrica `ReplicationChannelLag`. I punti dati per questa metrica hanno un periodo di 60 secondi (1 minuto) e sono disponibili per 15 giorni. Per individuare il ritardo del canale di replica per un canale, utilizzare l’identificatore di istanza e il nome del canale di replica. Per ricevere una notifica quando questo ritardo supera una determinata soglia, puoi impostare un CloudWatch allarme. Per ulteriori informazioni, consulta [Monitoraggio dei parametri di Amazon RDS Aurora con Amazon CloudWatch](monitoring-cloudwatch.md).
## Considerazioni e best practice per la replica da più origini
Prima di utilizzare la replica da più origini in RDS per MySQL, rivedere le considerazioni e le best practice seguenti:
+ Verificare che un’istanza database configurata come replica da più origini disponga di risorse sufficienti, ad esempio throughput, memoria, CPU e IOPS, per gestire il carico di lavoro proveniente da più istanze di origine.
+ Monitorare regolarmente l’uso delle risorse sulla replica da più origini e modificare la configurazione dell’archiviazione o dell’istanza per gestire il carico di lavoro senza sovraccaricare le risorse.
+ Impostare la variabile di sistema `replica_parallel_workers` su un valore maggiore di `0` per configurare la replica multi-thread in una replica da più origini. In questo caso, il numero di thread assegnati a ciascun canale è il valore della variabile più un thread di coordinamento per gestire i thread dell’applicatore.
+ Configurare i filtri di replica in modo appropriato per evitare conflitti. Per replicare un intero database su un altro database in una replica, è possibile utilizzare l’opzione `--replicate-rewrite-db`. Ad esempio, si possono replicare tutte le tabelle del database A nel database B in un’istanza di replica. Questo approccio può essere utile quando tutte le istanze di origine utilizzano la stessa convenzione di denominazione dello schema. Per informazioni sull’opzione `--replicate-rewrite-db`, consulta [Replica Server Options and Variables](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html) nella documentazione MySQL.
+ Per evitare errori di replica, non scrivere sulla replica. Si consiglia di abilitare il parametro `read_only` sulle repliche da più origini per bloccare le operazioni di scrittura. In tal modo è possibile eliminare i problemi di replica causati da operazioni di scrittura in conflitto.
+ Per aumentare le prestazioni delle operazioni di lettura, ad esempio ordinamenti e join a carico elevato, eseguite sulla replica da più origini, considerare l’utilizzo di Letture ottimizzate per Amazon RDS. Questa funzionalità può essere utile per le query che dipendono da tabelle temporanee o da file di ordinamento di grandi dimensioni. Per ulteriori informazioni, consulta [Prestazioni delle query migliorate per RDS per MySQL con Amazon RDS Optimized Reads](rds-optimized-reads.md).
+ Per ridurre il ritardo nella replica e migliorare le prestazioni di una replica da più origini, si consiglia di abilitare scritture ottimizzate. Per ulteriori informazioni, consulta [Prestazioni di scrittura migliorate con Scritture ottimizzate per Amazon RDS per MySQL](rds-optimized-writes.md).
+ Eseguire operazioni di gestione, ad esempio la modifica della configurazione, su un canale alla volta ed evitare di apportare modifiche a più canali da più connessioni per non provocare conflitti nelle operazioni di replica. Se si eseguono simultaneamente le procedure `rds_skip_repl_error_for_channel` e `rds_start_replication_for_channel` da più connessioni, ad esempio, gli eventi possono essere ignorati in un canale diverso da quello previsto.
+ È possibile abilitare i backup su un’istanza di replica da più origini ed esportare i dati da tale istanza in un bucket Amazon S3 per archiviarli a lungo termine. Tuttavia, è importante configurare anche i backup con una conservazione appropriata nelle singole istanze di origine. Per informazioni sull’esportazione dei dati di snapshot in Amazon S3, consulta [Supporto per l’esportazione di dati dello snapshot del database in Amazon S3 per Amazon RDS](USER_ExportSnapshot.md).
+ È possibile creare repliche di lettura da una replica da più origini per distribuirvi il carico di lavoro di lettura. È possibile individuare queste repliche di lettura in diversi modi in Regioni AWS base ai requisiti dell'applicazione. Per ulteriori informazioni sulle repliche di lettura, consulta [Uso delle repliche di lettura MySQL](USER_MySQL.Replication.ReadReplicas.md).
## Limitazioni per la replica da più origini in RDS per MySQL
Alla replica da più origini in RDS per MySQL si applicano le limitazioni seguenti:
+ Per una replica da più origini, RDS per MySQL supporta attualmente la configurazione di un massimo di 15 canali.
+ Un’istanza di replica di lettura non può essere configurata come replica da più origini.
+ Per configurare la replica da più origini in RDS per MySQL con versione del motore 5.7, è necessario abilitare lo schema delle prestazioni sull’istanza di replica. L’abilitazione dello schema delle prestazioni è facoltativa in RDS per MySQL con versione del motore 8.0 o 8.4.
+ In RDS per MySQL con versione del motore 5.7, i filtri di replica si applicano a tutti i canali di replica. In RDS per MySQL con versione del motore 8.0 o 8.4, è possibile configurare filtri che si applicano a tutti i canali di replica oppure a singoli canali.
+ Il ripristino di un'istantanea RDS o l'esecuzione di un Point-in-time-Restore (PITR) non ripristinano le configurazioni dei canali di replica da più fonti.
+ Quando si crea una replica di lettura di una replica da più origini, vengono replicati solo i dati dell’istanza da più origini e non viene ripristinata alcuna configurazione dei canali.
+ MySQL non supporta la configurazione di un numero diverso di worker paralleli per canale. A ogni canale viene assegnato lo stesso numero di worker paralleli in base al valore `replica_parallel_workers`.
Se la destinazione di replica da più origini è un cluster di database Multi-AZ, si applicano le limitazioni aggiuntive seguenti:
+ È necessario configurare un canale per un’istanza RDS per MySQL di origine prima che sia possibile scrivere su tale istanza.
+ Per ogni istanza RDS per MySQL di origine, la replica basata su GTID deve essere abilitata.
+ Un evento di failover sul cluster di database rimuove la configurazione di replica da più origini. Il ripristino di tale configurazione richiede la ripetizione delle operazioni di configurazione.