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 MariaDB 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 for MariaDB, consulta [Uso di repliche di lettura MariaDB](USER_MariaDB.Replication.ReadReplicas.md).
Puoi anche configurare la replica in base alle coordinate del log binario per un'istanza database MariaDB. Per le istanze MariadB, puoi anche configurare la replica in base a global IDs transaction GTIDs (), che offre una maggiore sicurezza in caso di crash. Per ulteriori informazioni, consulta [Configurazione della replica basata su GTID con un'istanza di origine esterna](MariaDB.Procedural.Replication.GTID.md).
Quelle elencate di seguito sono altre opzioni di replica disponibili con RDS for MariaDB:
+ Puoi impostare la replica fra un'istanza database RDS for MariaDB e MySQL oppure MariaDB, che è 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.ReplMariaDB.md).
+ Puoi configurare la replica per l'importazione di database da un'istanza MySQL o MariaDB esterna ad Amazon RDS o per l'esportazione di database a tali istanze. Per ulteriori informazioni, consultare [Importazione dei dati in un’istanza database Amazon RDS per MariaDB riducendo il tempo di inattività](mariadb-importing-data-reduced-downtime.md) e [Esportazione di dati da un'istanza database MySQL tramite la replica](MySQL.Procedural.Exporting.NonRDSRepl.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 della registrazione di log binari MariaDB](USER_LogAccess.MariaDB.BinaryFormat.md).
Per informazioni sulla compatibilità di replica tra le versioni di MariaDB, consulta [Replication Compatibility](https://mariadb.com/kb/en/mariadb-vs-mysql-compatibility/#replication-compatibility) nella documentazione MariaDB.
**Topics**
+ [Uso di repliche di lettura MariaDB](USER_MariaDB.Replication.ReadReplicas.md)
+ [Configurazione della replica basata su GTID con un'istanza di origine esterna](MariaDB.Procedural.Replication.GTID.md)
+ [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.ReplMariaDB.md)
# Uso di repliche di lettura MariaDB
Questa sezione contiene informazioni specifiche sull'utilizzo delle repliche di lettura su Amazon RDS for MariaDB. Per informazioni generali sulle repliche di lettura e istruzioni su come usarle, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
+ [Configurazione dei filtri di replica con MariaDB](USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.md)
+ [Configurazione della replica ritardata con MariaDB](USER_MariaDB.Replication.ReadReplicas.DelayReplication.md)
+ [Aggiornamento di repliche di lettura con MariaDB](USER_MariaDB.Replication.ReadReplicas.Updates.md)
+ [Operare con le implementazioni Multi-AZ di repliche di lettura con MariaDB](USER_MariaDB.Replication.ReadReplicas.MultiAZ.md)
+ [Utilizzo di repliche di lettura a cascata con RDS per MariaDB](USER_MariaDB.Replication.ReadReplicas.Cascading.md)
+ [Monitoraggio delle repliche di lettura MariaDB](USER_MariaDB.Replication.ReadReplicas.Monitor.md)
+ [Avvio e arresto della replica con repliche di lettura MariaDB](USER_MariaDB.Replication.ReadReplicas.StartStop.md)
+ [Risoluzione dei problemi relativi a una replica di lettura MariaDB](USER_ReadRepl.Troubleshooting.MariaDB.md)
## Configurazione delle repliche di lettura con MariaDB
Prima di poter usare un'istanza database MariaDB come origine della replica, devi attivare i backup automatici nell'istanza database di origine impostando il periodo di retention dei backup su un valore diverso da 0. Questo requisito si applica anche a una replica di lettura che rappresenta l'istanza database di origine per un'altra replica di lettura.
È possibile creare fino a 15 repliche di lettura da un'istanza database nella stessa regione. Per un efficace funzionamento della replica, ogni replica di lettura deve avere la stessa quantità di risorse di calcolo e di storage dell'istanza database di origine. Se si dimensiona l'istanza database di origine, si devono dimensionare anche le repliche di lettura.
RDS per MariaDB 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 MariaDB](USER_MariaDB.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.
# Configurazione dei filtri di replica con MariaDB
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 database che dispone di repliche di lettura in diverse Regioni AWS, per replicare database o tabelle diversi in diverse Regioni AWS.
**Nota**
Puoi utilizzare i filtri di replica anche per specificare i database e le tabelle che vengono replicati con un'istanza database MariaDB 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 Amazon RDS for MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [Limitazioni di filtro delle repliche per RDS for MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [Esempi di filtri di replica per RDS for MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [Visualizzazione dei filtri di replica per una replica di lettura](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Viewing)
## Impostazione dei parametri di filtro della replica Amazon RDS for MariaDB
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 maggiori informazioni sul funzionamento di questi parametri, consulta [la documentazione di MariaDB](https://mariadb.com/kb/en/replication-filters/#replication-filters-for-replication-slaves).
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 della registrazione di log binari MariaDB](USER_LogAccess.MariaDB.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 for MariaDB
Le seguenti limitazioni si applicano al filtro di replica per RDS for MariaDB:
+ Ogni parametro di filtro della replica ha un limite di 2.000 caratteri.
+ Le virgole non sono supportate nei filtri di replica.
+ Le opzioni MariaDB `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.
+ Il filtro di replica non è supportato per RDS for MariaDB 10.2.
## Esempi di filtri di replica per RDS for MariaDB
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 parametri in un gruppo di parametri utilizzando la Console di gestione AWS, la 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-mariadb)
+ [Including tables in replication](#rep-filter-in-tables-mariadb)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mariadb)
+ [Escaping wildcard characters in names](#rep-filter-escape-wildcards-mariadb)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mariadb)
+ [Excluding tables from replication](#rep-filter-ex-tables-mariadb)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mariadb)
**Example Inclusione dei database nella replica**
Nell'esempio seguente sono inclusi i database `mydb1` e `mydb2` nella replica. Quando si imposta `replicate-do-db` per una replica di lettura, vengono replicati solo i database specificati nel parametro.
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 `orders` e `returns` 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.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
**Example Escape di caratteri jolly nei nomi**
Nell'esempio seguente viene illustrato come utilizzare il carattere escape `\` per un carattere jolly che fa parte di un nome.
Si supponga di avere diversi nomi di tabelle nel database `mydb1` che iniziano con `my_table`e si desidera includere queste tabelle nella replica. I nomi delle tabelle includono un carattere di sottolineatura, che è anche un carattere jolly, quindi l'esempio sfugge al carattere di sottolineatura nei nomi delle tabelle.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "my\_table%", "ApplyMethod":"immediate"}]"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "my\_table%", "ApplyMethod":"immediate"}]"
```
**Example Esclusione di database dalla replica**
Nell'esempio seguente vengono esclusi i database `mydb1` e `mydb2` dalla replica.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-ignore-db", "ParameterValue": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-ignore-db", "ParameterValue": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
**Example Esclusione di tabelle dalla replica**
Nell'esempio seguente vengono escluse le tabelle `table1` e `table2` nel database `mydb1` dalla replica.
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-ignore-table", "ParameterValue": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-ignore-table", "ParameterValue": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
**Example Esclusione di tabelle dalla replica utilizzando caratteri jolly**
Nell'esempio seguente vengono escluse le tabelle con nomi che iniziano con `orders` e `returns` nel database `mydb` 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": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-ignore-table", "ParameterValue": "mydb.orders%,mydb.returns%", "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 MariaDB, 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.
**Nota**
Le versioni precedenti di MariaDB utilizzavano `SHOW SLAVE STATUS` anziché `SHOW REPLICA STATUS`. Se si utilizza una versione di MariaDB precedente alla 10.5, utilizzare `SHOW SLAVE STATUS`.
# Configurazione della replica ritardata con MariaDB
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.
Per arrestare la replica, usa la procedura archiviata [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) .
+ 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**
La replica ritardata è supportata per MariaDB 10.6 e versioni successive.
Utilizza le procedure archiviate per configurare la replica ritardata. Non puoi configurare la replica ritardata tramite la Console di gestione AWS, la AWS CLI o l'API di Amazon RDS.
È possibile utilizzare la replica basata su identificatori di transazione globali (GTID) in una configurazione di replica ritardata.
**Topics**
+ [Configurazione della replica ritardata durante la creazione della replica di lettura](#USER_MariaDB.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [Modifica della replica ritardata per una replica di lettura esistente](#USER_MariaDB.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [Promozione di una replica di lettura](#USER_MariaDB.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 MariaDB, connettersi all'istanza database MariaDB 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 stored procedure, le eventuali repliche di lettura create tramite la AWS CLI o l'API di Amazon RDS vengono configurate con la replica ritardata per il numero specificato di secondi.
## 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 MariaDB, connettersi alla replica di lettura come utente principale.
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.
## 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 MariaDB
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 accelerare i tipi specifici di query che accedono alla replica. Puoi abilitare gli aggiornamenti impostando il parametro `read_only` su **0** nel gruppo di parametri database per la replica di lettura.
# Operare con le implementazioni Multi-AZ di repliche di lettura con MariaDB
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 MariaDB
RDS per MariaDB 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 MariaDB di origine.
Con le repliche di lettura a cascata, l'istanza database RDS per MariaDB 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 MariaDB, 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 MariaDB di origine. Ad esempio, supponi di avere l'istanza database RDS per MariaDB `mariadb-main`. Puoi eseguire le operazioni indicate di seguito:
+ A partire da `mariadb-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 `mariadb-main`. Una serie completa di istanze da un'istanza database RDS per MariaDB 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 MariaDB 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 `mariadb-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 `mariadb-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 delle repliche di lettura MariaDB
Per le repliche di lettura MariaDB, puoi monitorare il ritardo di replica in Amazon CloudWatch visualizzando il parametro `ReplicaLag` in Amazon RDS. Il parametro `ReplicaLag` segnala il valore del campo `Seconds_Behind_Master` del comando `SHOW REPLICA STATUS`.
**Nota**
Le versioni precedenti di MariaDB utilizzavano `SHOW SLAVE STATUS` anziché `SHOW REPLICA STATUS`. Se si utilizza una versione di MariaDB precedente alla 10.5, utilizzare `SHOW SLAVE STATUS`.
Le cause comuni del ritardo di replica per MariaDB sono le seguenti:
+ Interruzione della connessione di rete.
+ Scrittura in tabelle con indici in una replica di lettura. Se il parametro `read_only` non è impostato su 0 nella replica di lettura, la replica può essere interrotta.
+ Uso di un motore di storage non transazionale come MyISAM. La replica è supportata solo per il motore di storage InnoDB su MariaDB.
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 MariaDB
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’istanza database Amazon RDS per MariaDB riducendo il tempo di inattività](mariadb-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 MariaDB
Le tecnologie di replica per MariaDB 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 la [panoramica della replica](http://mariadb.com/kb/en/mariadb/replication-overview/) nella documentazione di MariaDB.
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 MariaDB 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 MariaDB, verifica l'errore nella [documentazione dei messaggi di errore MariaDB](http://mariadb.com/kb/en/mariadb/mariadb-error-codes/).
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 dei parametri database usato per specificare la dimensione massima del codice DML che può essere eseguito nel database. In alcuni casi, il valore del parametro `max_allowed_packet` nel gruppo dei parametri database associato a un'istanza database di origine è minore del valore del parametro `max_allowed_packet` nel gruppo dei parametri database associato alla replica di lettura dell'origine. In questi casi, il processo di replica può generare un errore (indicante che il pacchetto è maggiore dei byte specificati da "max\$1allowed\$1packet") e arrestare la replica. Puoi correggere questo errore impostando l'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. Se crei indici su una replica di lettura, il parametro `read_only` deve essere impostato su **0** affinché gli indici vengano creati. Se scrivi in tabelle nella replica di lettura, l'operazione può interrompere la replica.
+ 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 MariaDB.
+ 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 che un errore possa essere ignorato, completa la procedura descritta in [Ignorare l’errore di replica corrente per RDS per MySQL](Appendix.MySQL.CommonDBATasks.SkipError.md). In caso contrario, puoi eliminare la replica di lettura e creare un'istanza usando lo stesso identificatore istanze DB in modo che l'endpoint sia identico a 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)*.
Per le istanze database MariaDB, in alcuni casi le repliche di lettura non possono essere passate alle istanze secondarie se alcuni eventi di registro binari (binlog) non vengono scaricati durante l'evento di errore. 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.
# Configurazione della replica basata su GTID con un'istanza di origine esterna
È possibile impostare la replica basata sugli identificatori di transazione globali (GTIDs) da un'istanza MariaDB esterna della versione 10.0.24 o successiva in un'istanza RDS per MariaDB DB. Seguire queste linee guida quando si imposta un'istanza di origine esterna e una replica su Amazon RDS:
+ Monitora gli eventi di failover per l'istanza database RDS for MariaDB che rappresenta la tua 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 log binari (binlog) sull'istanza di origine finché non si ha la conferma che siano stati applicati alla replica. Questa manutenzione assicura il ripristino dell'istanza di origine nel caso di errori.
+ Attivare i backup automatici sull'istanza database MariaDB in Amazon RDS. L'attivazione dei backup automatici assicura il ripristino della replica in un determinato "point in time" nel caso fosse necessario risincronizzare l'istanza di origine e la replica. Per informazioni su backup e ripristino, vedere. Point-In-Time [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md)
**Nota**
Le autorizzazioni necessarie per avviare la replica in un'istanza database MariaDB sono limitate e non disponibili per l'utente master Amazon RDS. Per questo motivo, devi usare i comandi Amazon RDS, [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) per configurare la replica tra il database live e il database di RDS for MariaDB.
Per avviare la replica tra un'istanza di origine esterna e un'istanza database MariaDB in Amazon RDS, attieniti alla procedura seguente.
**Per avviare la replica**
1. Rendere di sola lettura l'istanza MariaDB di origine:
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Ottenere il GTID corrente dell'istanza MariaDB esterna. A tale scopo, utilizzare `mysql` o l'editor di query scelto per eseguire `SELECT @@gtid_current_pos;`.
Il formato del GTID è il seguente: `--`. Un tipico GTID è simile a **0-1234510749-1728**. Per ulteriori informazioni GTIDs e sui relativi componenti, consulta [Global transaction ID nella documentazione](http://mariadb.com/kb/en/mariadb/global-transaction-id/) di MariaDB.
1. Copiare il database dall'istanza MariaDB esterna all'istanza database MariaDB tramite `mysqldump`. Per database di dimensioni particolarmente elevate, è possibile utilizzare la procedura in [Importazione dei dati in un’istanza database Amazon RDS per MariaDB riducendo il tempo di inattività](mariadb-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.
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
Usare 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 MariaDB. Il nome host è il nome DNS dell'endpoint dell'istanza database MariaDB, ad esempio `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Puoi trovare il valore dell'endpoint è disponibile nei dettagli dell'istanza, nella console di gestione Amazon RDS.
1. Rendi nuovamente scrivibile l'istanza MariaDB di origine.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
1. Nella Console di gestione di Amazon RDS aggiungi l'indirizzo IP del server che ospita il database MariaDB esterno al gruppo di sicurezza VPC per l'istanza database MariaDB. Per ulteriori informazioni sulla modifica di un gruppo di sicurezza VPC, consulta la sezione relativa ai [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 MariaDB affinché possa comunicare con l'istanza database MariaDB esterna. Per individuare l'indirizzo IP dell'istanza database MariaDB, usa il comando `host`.
```
host db_instance_endpoint
```
Il nome host è il nome DNS dell'endpoint dell'istanza database MariaDB.
1. Utilizzando il client scelto, eseguire la connessione all'istanza database MariaDB esterna e creare un utente MariaDB da utilizzare per la replica. Questo account viene utilizzato unicamente per la replica e deve essere limitato 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 un'istanza MariaDB 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. Configurare l'istanza database MariaDB come replica. Connettersi all'istanza database MariaDB come utente master e identificare il database MariaDB esterno come istanza origine di replica usando il comando [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md). Utilizzare il GTID determinato alla fase 2. Di seguito è riportato un esempio di :
```
CALL mysql.rds_set_external_master_gtid ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'GTID', 1);
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Nell'istanza database MariaDB, emettere 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 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, utilizzando la replica del file di registro 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;
```