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à.
# Amazon RDS per MariaDB
Amazon RDS supporta varie versioni di MariaDB per le istanze database. Per informazioni complete sulle versioni supportate, consulta [Versioni di MariaDB in Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
Per creare un'istanza database MariaDB, utilizza gli strumenti o le interfacce di gestione di Amazon RDS. Puoi quindi utilizzare gli strumenti Amazon RDS per eseguire azioni di gestione per l'istanza database. Queste includono le azioni seguenti:
+ Riconfigurazione o ridimensionamento dell'istanza database
+ Autorizzazione delle connessioni all'istanza database
+ Creazione e ripristino da backup o snapshot
+ Creazione di istanze secondarie Multi-AZ
+ Creazione di repliche di lettura
+ Monitoraggio delle prestazioni dell'istanza database
Per archiviare e accedere ai dati nell'istanza database, utilizza le utilità e le applicazioni MariaDB standard.
MariaDB è disponibile in tutte le Regioni AWS. Per ulteriori informazioni su Regioni AWS, consulta [Regioni, zone di disponibilità e Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
Puoi utilizzare i database Amazon RDS for MariaDB allo scopo di creare applicazioni conformi ai requisiti HIPAA. Puoi archiviare informazioni sanitarie, inclusi dati sanitari protetti (PHI), in base a un Contratto di società in affari (BAA) con AWS. Per ulteriori informazioni, consulta [Compliance HIPAA](https://aws.amazon.com/compliance/hipaa-compliance/). AWS I servizi coperti dal programma di compliance sono stati integralmente valutati da un auditor di terzi e generano una certificazione, un'attestazione di conformità o un'autorizzazione operativa (ATO). Per ulteriori informazioni, consulta [Servizi AWS coperti dal programma di compliance](https://aws.amazon.com/compliance/services-in-scope/).
Prima di creare un'istanza database, completa i passaggi in [Configurazione dell’ambiente Amazon RDS](CHAP_SettingUp.md). Quando crei un'istanza database, l'utente principale di RDS ottiene privilegi DBA, con alcune limitazioni. Utilizzare questo account per attività amministrative, ad esempio la creazione di account di database aggiuntivi.
Puoi creare:
+ Istanze DB
+ Snapshot DB
+ Ripristini point-in-time
+ Backup automatizzati
+ Backup manuali
Puoi utilizzare istanze database che eseguono MariaDB all'interno di un cloud privato virtuale (VPC) basato su Amazon VPC. Inoltre, puoi abilitare varie opzioni per aggiungere altre funzionalità all'istanza database MariaDB. Amazon RDS supporta le implementazioni Multi-AZ per MariaDB come soluzione failover a elevata disponibilità.
**Importante**
Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. Limita anche l'accesso ad alcune procedure di sistema e tabelle che richiedono privilegi avanzati. Puoi accedere al database utilizzando i client SQL standard come il client mysql. Tuttavia, non è possibile accedere direttamente all'host utilizzando Telnet o Secure Shell (SSH).
**Topics**
+ [Supporto funzionalità MariaDB su Amazon RDS](MariaDB.Concepts.FeatureSupport.md)
+ [Versioni di MariaDB in Amazon RDS](MariaDB.Concepts.VersionMgmt.md)
+ [Connessione all’istanza database MariaDB](USER_ConnectToMariaDBInstance.md)
+ [Protezione delle connessioni di istanze database MariaDB](securing-mariadb-connections.md)
+ [Prestazioni delle query migliorate per RDS per MariaDB con Amazon RDS Optimized Reads](rds-optimized-reads-mariadb.md)
+ [Prestazioni di scrittura migliorate con Scritture ottimizzate per Amazon RDS per MariaDB](rds-optimized-writes-mariadb.md)
+ [Aggiornamenti del motore di database MariaDB](USER_UpgradeDBInstance.MariaDB.md)
+ [Aggiornamento di una versione del motore di snapshot di database MariaDB](mariadb-upgrade-snapshot.md)
+ [Importazione di dati in un’istanza database Amazon RDS per MariaDB.](MariaDB.Procedural.Importing.md)
+ [Uso della replica MariaDB in Amazon RDS](USER_MariaDB.Replication.md)
+ [Opzioni per il motore di database MariaDB](Appendix.MariaDB.Options.md)
+ [Parametri per MariaDB](Appendix.MariaDB.Parameters.md)
+ [Migrazione dei dati da uno snapshot DB MySQL a un'istanza database MariaDB](USER_Migrate_MariaDB.md)
+ [MariaDB sul riferimento SQL di Amazon RDS](Appendix.MariaDB.SQLRef.md)
+ [Fuso orario locale per le istanze database MariaDB](MariaDB.Concepts.LocalTimeZone.md)
+ [Problemi e limitazioni note per RDS per MariaDB](CHAP_MariaDB.Limitations.md)
# Supporto funzionalità MariaDB su Amazon RDS
RDS per MariaDB supporta la maggior parte delle caratteristiche e delle funzionalità di MariaDB. Alcune funzionalità potrebbero avere un supporto o privilegi limitati.
Puoi filtrare le nuove funzionalità di Amazon RDS alla pagina [Quali sono le novità del database?](https://aws.amazon.com/about-aws/whats-new/database/). Per **Prodotti**, scegli **Amazon RDS**. Quindi esegui la ricerca utilizzando parole chiave come **MariaDB 2023**.
**Nota**
I seguenti elenchi non sono esaustivi.
Per ulteriori informazioni sul supporto delle funzionalità di MariaDB in Amazon RDS, consulta gli argomenti seguenti.
**Argomenti**
+ [Motori di storage supportati per MariaDB in Amazon RDS](MariaDB.Concepts.Storage.md)
+ [Precaricamento della cache per MariaDB in Amazon RDS](MariaDB.Concepts.XtraDBCacheWarming.md)
+ [Funzionalità MariaDB non supportate da Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md)
## Supporto alle funzionalità MariaDB nelle versioni principali di Amazon RDS per MariaDB
Nelle seguenti sezioni sono disponibili informazioni sul supporto alle funzionalità MariaDB nelle versioni principali di Amazon RDS per MariaDB:
**Topics**
+ [Supporto per MariaDB 11.8 in Amazon RDS](#MariaDB.Concepts.FeatureSupport.11-8)
+ [Supporto per MariaDB 11.4 in Amazon RDS](#MariaDB.Concepts.FeatureSupport.11-4)
+ [Supporto per MariaDB 10.11 in Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-11)
+ [Supporto per MariaDB 10.6 in Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-6)
+ [Supporto per MariaDB 10.5 in Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-5)
+ [Supporto per MariaDB 10.4 in Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-4)
Per informazioni sulle versioni secondarie supportate di Amazon RDS for MariaDB, consulta [Versioni di MariaDB in Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
### Supporto per MariaDB 11.8 in Amazon RDS
Amazon RDS supporta le seguenti nuove funzionalità per le istanze database che eseguono MariaDB 11.8 o versioni successive.
**Nota**
In MariadB 11.8, il valore predefinito `require_secure_transport` per `1` ora è che richiede connessioni sicure. SSL/TLS Il valore può essere impostato su `0` se sono necessarie connessioni non sicure.
+ **Nuovo valore predefinito per il parametro**: il valore predefinito del parametro `require_secure_transport` è stato modificato da `0` a `1`, in modo da applicare connessioni di trasporto sicure per impostazione predefinita. Per ulteriori informazioni, consulta [Richiesta SSL/TLS di tutte le connessioni a un'istanza DB MariaDB su Amazon RDS](mariadb-ssl-connections.require-ssl.md).
+ **Supporto vettoriale**: è possibile utilizzare la funzionalità di vettore MariaDB per archiviare e cercare vettori generati dall’intelligenza artificiale direttamente in MariaDB. Questa funzionalità introduce le seguenti variabili di sistema:
+ La variabile [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_distance](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_distance) specifica la metrica della distanza predefinita per l’indicizzazione vettoriale MHNSW.
+ La variabile [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_m](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_m) definisce il valore predefinito per il parametro `M` nell’indicizzazione vettoriale MHNSW.
+ La variabile [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_ef_search](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_ef_search) definisce il numero minimo di risultati candidati per le ricerche con indici vettoriali.
+ La variabile [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_max_cache_size](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_max_cache_size) imposta il limite superiore per una cache di indici vettoriali MHNSW.
+ **Limiti alle dimensioni dei file temporanei**: ora è possibile limitare la dimensione delle tabelle e dei file temporanei del disco creati utilizzando due variabili di sistema disponibili nel gruppo di parametri RDS per MariaDB 11.8:
+ La variabile [https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_session_space_usage-system-variable](https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_session_space_usage-system-variable) limita lo spazio temporaneo consentito per utente.
+ La variabile [https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_total_space_usage-system-variable](https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_total_space_usage-system-variable) limita lo spazio temporaneo consentito per utente.
+ **Gestione del tablespace temporaneo**: il tablespace temporaneo archivia le tabelle temporanee e cresce man mano che vengono aggiunti dati. Quando le tabelle temporanee vengono eliminate, lo spazio non viene recuperato automaticamente. Per ridurre il tablespace temporaneo e recuperare spazio su disco, è possibile utilizzare la procedura [mysql.rds\$1execute\$1operation](mysql_rds_execute_operation.md).
Per un elenco di tutte le funzionalità di MariaDB 11.8 e la relativa documentazione, [consulta Modifiche e miglioramenti in MariaDB 11.8 [e Note di rilascio -](https://mariadb.com/kb/en/release-notes-mariadb-11-8-series/) Serie MariaDB](https://mariadb.com/kb/en/changes-improvements-in-mariadb-11-8/) 11.8 sul sito Web MariaDB.
Per un elenco delle funzionalità non supportate, consulta [Funzionalità MariaDB non supportate da Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Supporto per MariaDB 11.4 in Amazon RDS
Amazon RDS supporta le seguenti nuove funzionalità per le istanze database che eseguono MariaDB 11.4 o versioni successive:
+ **Libreria crittografica**: RDS per MariaDB ha sostituito OpenSSL con (), che è certificato FIPS 140-3. AWS Libcrypto AWS-LC
+ **Plugin Simple Password Check**: il [plugin Simple Password Check](https://mariadb.com/kb/en/simple-password-check-plugin/) di MariaDB consente di verificare se una password contiene almeno un numero specifico di caratteri di un determinato tipo. Per ulteriori informazioni, consulta [Utilizzo del plugin di convalida delle password per RDS per MariaDB](MariaDB.Concepts.PasswordValidationPlugins.md).
+ **Plugin Cracklib Password Check**: il [plugin Cracklib Password Check](https://mariadb.com/kb/en/cracklib-password-check-plugin/) di MariaDB consente di verificare la sicurezza delle nuove password. Per ulteriori informazioni, consulta [Utilizzo del plugin di convalida delle password per RDS per MariaDB](MariaDB.Concepts.PasswordValidationPlugins.md).
+ **Miglioramenti di InnoDB**: i miglioramenti includono i seguenti elementi:
+ Il buffer di modifica è stato rimosso. Per ulteriori informazioni, consulta [InnoDB Change Buffering](https://mariadb.com/kb/en/innodb-change-buffering/).
+ La deframmentazione di InnoDB è stata rimossa. Per ulteriori informazioni, consulta [InnoDB Defragmentation](https://mariadb.com/kb/en/defragmenting-innodb-tablespaces/#innodb-defragmentation).
+ **Nuovo privilegio**: ora il privilegio `SHOW CREATE ROUTINE` è assegnato anche all’utente amministratore. Il privilegio consente di visualizzare la dichiarazione di definizione `SHOW CREATE` di una routine di proprietà di un altro utente. Per ulteriori informazioni, consulta [Database Privileges](https://mariadb.com/kb/en/grant/#database-privileges).
+ **Miglioramento della replica**: le istanze database MariaDB versione 11.4 supportano l’indicizzazione binlog. È possibile creare un indice GTID per ogni file binlog. Tali indici migliorano le prestazioni della replica riducendo il tempo necessario per individuare un GTID. Per ulteriori informazioni, consulta [Binlog Indexing](https://mariadb.com/kb/en/gtid/#binlog-indexing).
+ Parametri **obsoleti o rimossi: i seguenti parametri** sono stati obsoleti o rimossi per le istanze DB di MariaDB versione 11.4:
+ `engine_condition_pushdown` viene rimosso da [optimizer\$1switch](https://mariadb.com/kb/en/optimizer-switch/)
+ [innodb\$1change\$1buffer\$1max\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_change_buffer_max_size)
+ [innodb\$1defragment](https://mariadb.com/kb/en/innodb-system-variables/#innodb_defragment)
+ `TLSv1.0` e `TLSv1.1` vengono rimossi da [tls\$1version](https://mariadb.com/kb/en/ssltls-system-variables/#tls_version)
+ **Nuovi valori predefiniti per un parametro**: il valore predefinito del parametro [innodb\$1undo\$1tablespaces](https://mariadb.com/kb/en/innodb-system-variables/#innodb_undo_tablespaces) è stato modificato da `0` a `3`.
+ **Nuovi valori validi per i parametri** — I seguenti parametri hanno nuovi valori validi per le istanze DB di MariaDB versione 11.4:
+ I valori validi per il parametro [binlog\$1row\$1image](https://mariadb.com/kb/en/replication-and-binary-log-system-variables/#binlog_row_image) ora includono `FULL_NODUP`.
+ I valori validi del parametro [OLD\$1MODE](https://mariadb.com/kb/en/old-mode/) ora includono `NO_NULL_COLLATION_IDS`.
+ **Nuovi parametri: i** seguenti parametri sono nuovi per le istanze DB di MariaDB versione 11.4:
+ Il parametro [transaction\$1isolation](https://mariadb.com/kb/en/server-system-variables/#transaction_isolation) sostituisce il parametro [tx\$1isolation](https://mariadb.com/kb/en/server-system-variables/#tx_isolation).
+ Il parametro [transaction\$1read\$1only](https://mariadb.com/kb/en/server-system-variables/#transaction_read_only) sostituisce il parametro [tx\$1read\$1only](https://mariadb.com/kb/en/server-system-variables/#tx_read_only).
+ Il parametro [block\$1encryption\$1mode](https://mariadb.com/kb/en/server-system-variables/#block_encryption_mode) definisce la modalità di crittografia in blocco predefinita per le funzioni [AES\$1ENCRYPT()](https://mariadb.com/kb/en/aes_encrypt/) and [AES\$1DECRYPT()](https://mariadb.com/kb/en/aes_decrypt/).
+ [ character\$1set\$1collations](https://mariadb.com/kb/en/server-system-variables/#character_set_collations) definisce le sostituzioni per le regole di confronto predefinite dei set di caratteri.
+ [binlog\$1gtid\$1index](https://mariadb.com/kb/en/system-versioned-tables/#binlog_gtid_index), [binlog\$1gtid\$1index\$1page\$1size](https://mariadb.com/kb/en/system-versioned-tables/#binlog_gtid_index_page_size) e [binlog\$1gtid\$1index\$1span\$1min](https://mariadb.com/kb/en/system-versioned-tables/#binlog_gtid_index_span_min) definiscono le proprietà dell’indice GTID binlog. Per ulteriori informazioni, consulta [Binlog Indexing](https://mariadb.com/kb/en/gtid/#binlog-indexing).
Per un elenco di tutte le funzionalità di MariaDB 11.4 e la relativa documentazione, [consulta Modifiche e miglioramenti in MariaDB 11.4 [e Note di rilascio -](https://mariadb.com/kb/en/release-notes-mariadb-11-4-series/) Serie MariaDB](https://mariadb.com/kb/en/changes-improvements-in-mariadb-11-4/) 11.4 sul sito Web MariaDB.
Per un elenco delle funzionalità non supportate, consulta [Funzionalità MariaDB non supportate da Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Supporto per MariaDB 10.11 in Amazon RDS
Amazon RDS supporta le seguenti nuove funzionalità per le istanze database che eseguono MariaDB versione 10.11 o versioni successive:
+ **Plugin Password Reuse Check**: puoi utilizzare il plug-in MariaDB Password Reuse Check per impedire agli utenti di riutilizzare le password e impostare il periodo di conservazione delle password. Per ulteriori informazioni, consulta[Plugin Password Reuse Check](https://mariadb.com/kb/en/password-reuse-check-plugin/) (Utilità di controllo del riutilizzo delle password).
+ **Autorizzazione GRANT TO PUBLIC**: puoi concedere i privilegi a tutti gli utenti che hanno accesso al tuo server. Per ulteriori informazioni, consulta [GRANT TO PUBLIC](https://mariadb.com/kb/en/grant/#to-public).
+ **Separazione dei privilegi SUPER e READ ONLY ADMIN**: puoi rimuovere i privilegi READ ONLY ADMIN da tutti gli utenti, anche dagli utenti che in precedenza avevano i privilegi SUPER.
+ **Sicurezza**: ora puoi impostare l'opzione `--ssl` come impostazione predefinita per il tuo client MariaDB. MariaDB non disabilita più SSL automaticamente se la configurazione non è corretta.
+ **Comandi e funzioni SQL**: ora puoi usare il comando `SHOW ANALYZE FORMAT=JSON` e le funzioni `ROW_NUMBER`,`SFORMAT` e `RANDOM_BYTES`. `SFORMAT` consente la formattazione delle stringhe ed è abilitata per impostazione predefinita. Puoi eseguire la conversione da partizione a tabella e da tabella a partizione con un solo comando. Ci sono anche diversi miglioramenti relativi alle funzioni `JSON_*()`. Le funzioni `DES_ENCRYPT` e `DES_DECRYPT` sono obsolete per la versione 10.10 e successive. Per ulteriori informazioni, consulta [SFORMAT](https://mariadb.com/kb/en/sformat/).
+ **Miglioramenti di InnoDB**: i miglioramenti includono i seguenti elementi:
+ Miglioramenti delle prestazioni nel redo log per ridurre l'amplificazione della scrittura e migliorare la concorrenza.
+ La possibilità di modificare la tablespace di undo senza reinizializzare la directory dei dati. Questo miglioramento riduce il sovraccarico del piano di controllo (control plane). Richiede il riavvio ma non la reinizializzazione dopo aver modificato la tablespace di undo.
+ Supporto interno per `CHECK TABLE … EXTENDED` e per gli indici decrescenti.
+ Miglioramenti dell'inserimento in blocco.
+ **Modifiche a binlog**: queste modifiche includono i seguenti elementi:
+ Generazione di log di `ALTER` in due fasi per ridurre la latenza di replica. Il parametro `binlog_alter_two_phase` è disabilitato per impostazione predefinita, ma può essere abilitato tramite i gruppi di parametri.
+ Generazione di log di `explicit_defaults_for_timestamp`.
+ Non vengono più generati i log `INCIDENT_EVENT` se la transazione può essere ripristinata in modo sicuro.
+ **Miglioramenti della** **replica**: le istanze database MariaDB versione 10.11 utilizzano la replica GTID per impostazione predefinita se il master la supporta. Inoltre,`Seconds_Behind_Master` è più preciso.
+ **Client**: puoi utilizzare nuove opzioni della riga di comando per `mysqlbinglog` e `mariadb-dump`. Puoi usare `mariadb-dump` per scaricare e ripristinare i dati storici.
+ **Controllo delle versioni del sistema**: è possibile modificare la cronologia. MariaDB crea automaticamente nuove partizioni.
+ **DDL atomico**: `CREATE OR REPLACE` ora è atomico. L'istruzione ha esito positivo o è completamente invertita.
+ **Scrittura dei redo log**: i redo log vengono scritti in modo asincrono.
+ **Funzioni archiviate**: le funzioni archiviate ora supportano gli stessi parametri `IN`, `OUT` e `INOUT` delle stored procedure.
+ **Parametri obsoleti o rimossi**: i seguenti parametri sono obsoleti o sono stati rimossi per le istanze database MariaDB versione 10.11:
+ [innodb\$1change\$1buffering](https://mariadb.com/kb/en/innodb-system-variables/#innodb_change_buffering)
+ [innodb\$1disallow\$1writes](https://mariadb.com/kb/en/innodb-system-variables/#innodb_disallow_writes)
+ [innodb\$1log\$1write\$1ahead\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_write_ahead_size)
+ [ innodb\$1prefix\$1index\$1cluster\$1optimization](https://mariadb.com/kb/en/innodb-system-variables/#innodb_prefix_index_cluster_optimization)
+ [ keep\$1files\$1on\$1create](https://mariadb.com/kb/en/server-system-variables/#keep_files_on_create)
+ [old](https://mariadb.com/kb/en/server-system-variables/#old)
+ **Parametri dinamici**: i seguenti parametri ora sono dinamici per le istanze database diMariaDB versione 10.11:
+ [innodb\$1log\$1file\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_file_size)
+ [innodb\$1write\$1io\$1threads](https://mariadb.com/kb/en/innodb-system-variables/#innodb_write_io_threads)
+ [innodb\$1read\$1io\$1threads](https://mariadb.com/kb/en/innodb-system-variables/#innodb_read_io_threads)
+ **Nuovi valori predefiniti per i parametri**: i seguenti parametri hanno nuovi valori predefiniti per le istanze database MariaDB versione 10.11:
+ Il valore predefinito del parametro [explicit\$1defaults\$1for\$1timestamp](https://mariadb.com/kb/en/server-system-variables/#explicit_defaults_for_timestamp)modificato da `OFF` in `ON`.
+ Il valore predefinito del parametro [optimizer\$1prune\$1level](https://mariadb.com/kb/en/server-system-variables/#optimizer_prune_level) modificato da `1` in `2`.
+ **Nuovi valori validi per i parametri**: i seguenti parametri hanno nuovi valori validi per le istanze database MariaDB versione 10.11:
+ I valori validi per il parametro [old](https://mariadb.com/kb/en/server-system-variables/#old) sono stati uniti a quelli del parametro [old\$1mode](https://mariadb.com/kb/en/server-system-variables/#old_mode).
+ I valori validi del parametro [histogram\$1type](https://mariadb.com/kb/en/server-system-variables/#histogram_type) ora includono `JSON_HB`.
+ L'intervallo di valori valido per il parametro [innodb\$1log\$1buffer\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_buffer_size) è ora da `262144` a `4294967295`(da 256 KB a 4096 MB).
+ L'intervallo di valori valido per il parametro [innodb\$1log\$1file\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_file_size) è ora da `4194304` a `512GB` (da 4 MB a 512 GB).
+ I valori validi per il parametro [optimizer\$1prune\$1level](https://mariadb.com/kb/en/server-system-variables/#optimizer_prune_level) ora include`2`.
+ **Nuovi parametri**: i seguenti parametri sono nuovi per le istanze database MariaDB versione 10.11:
+ Il parametro [binlog\$1alter\$1two\$1phase](https://mariadb.com/kb/en/replication-and-binary-log-system-variables//#binlog_alter_two_phase)il parametro può migliorare le prestazioni della replica.
+ Il parametro [log\$1slow\$1min\$1examed\$1row\$1limit](https://mariadb.com/kb/en/server-system-variables/#log_slow_min_examined_row_limit) può migliorare le prestazioni.
+ Il parametro [log\$1slow\$1query](https://mariadb.com/kb/en/server-system-variables/#log_slow_query) e il parametro [log\$1slow\$1query\$1file](https://mariadb.com/kb/en/server-system-variables/#log_slow_query_file) sono alias rispettivamente per `slow_query_log` e `slow_query_log_file`, .
+ [ optimizer\$1extra\$1pruning\$1depth](https://mariadb.com/kb/en/server-system-variables/#optimizer_extra_pruning_depth)
+ [system\$1versioning\$1insert\$1history](https://mariadb.com/kb/en/system-versioned-tables/#system_versioning_insert_history)
Per un elenco di tutte le funzionalità di MariaDB 10.11 e la relativa documentazione, [consulta Modifiche e miglioramenti in MariaDB 10.11 [e Note di rilascio -](https://mariadb.com/kb/en/release-notes-mariadb-1011-series/) MariaDB](https://mariadb.com/kb/en/changes-improvements-in-mariadb-1011/) 10.11 series sul sito Web MariaDB.
Per un elenco delle funzionalità non supportate, consulta [Funzionalità MariaDB non supportate da Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Supporto per MariaDB 10.6 in Amazon RDS
Amazon RDS supporta le seguenti nuove funzionalità per le istanze database che eseguono MariaDB versione 10.6 o versioni successive:
+ **MyRocks motore di archiviazione**: puoi utilizzare il motore di MyRocks archiviazione con RDS for MariaDB per ottimizzare il consumo di archiviazione delle tue applicazioni Web ad alte prestazioni e ad alta intensità di scrittura. Per ulteriori informazioni, consultare [Motori di storage supportati per MariaDB in Amazon RDS](MariaDB.Concepts.Storage.md) e [MyRocks](https://mariadb.com/kb/en/myrocks/).
+ **AWS Identity and Access Management Autenticazione (IAM) DB**: puoi utilizzare l'autenticazione IAM DB per una maggiore sicurezza e una gestione centrale delle connessioni alle tue istanze DB MariaDB. Per ulteriori informazioni, consulta [Autenticazione del database IAM per MariaDB, MySQL e PostgreSQL](UsingWithRDS.IAMDBAuth.md).
+ **Opzioni di aggiornamento**: ora è possibile eseguire l'aggiornamento a RDS per MariaDB versione 10.6 da qualsiasi versione precedente (10.3, 10.4, 10.5). Inoltre, puoi ripristinare uno snapshot di un'istanza database di MySQL 5.6 o 5.7 esistente in un'istanza MariaDB 10.6. Per ulteriori informazioni, consulta [Aggiornamenti del motore di database MariaDB](USER_UpgradeDBInstance.MariaDB.md).
+ **Replica ritardata**: ora è possibile impostare un periodo di tempo configurabile per cui una replica di lettura ritarda rispetto al database di origine. In una configurazione di replica MariaDB standard, esiste un ritardo di replica minimo tra l'origine e la replica. Con la replica ritardata, puoi impostare un ritardo intenzionale come strategia per il ripristino di emergenza. Per ulteriori informazioni, consulta [Configurazione della replica ritardata con MariaDB](USER_MariaDB.Replication.ReadReplicas.DelayReplication.md).
+ ** PL/SQL Compatibilità con Oracle**: utilizzando RDS per MariaDB versione 10.6, puoi migrare più facilmente le tue applicazioni Oracle legacy su Amazon RDS. Per ulteriori informazioni, consulta [SQL\$1MODE=ORACLE](https://mariadb.com/kb/en/sql_modeoracle/).
+ **DDL atomico**: le istruzioni Dynamic Data Language (DDL) possono essere relativamente protette con RDS for MariaDB versione 10.6. `CREATE TABLE`, `ALTER TABLE`, `RENAME TABLE`, `DROP TABLE`, `DROP DATABASE` e le relative istruzioni DDL sono ora atomiche. L’istruzione ha esito positivo o è completamente invertita. Per ulteriori informazioni, consulta [DDL atomico](https://mariadb.com/kb/en/atomic-ddl/).
+ **Altri miglioramenti**: questi miglioramenti includono una funzione `JSON_TABLE` per trasformare i dati JSON in formato relazionale all'interno di SQL e un caricamento più rapido dei dati della tabella vuota con Innodb. Includono anche nuovi `sys_schema` per l’analisi e la risoluzione dei problemi, miglioramenti di Optimizer per ignorare gli indici inutilizzati e miglioramenti delle prestazioni. Per ulteriori informazioni, consulta [JSON\$1TABLE](https://mariadb.com/kb/en/json_table/).
+ **Nuovi valori predefiniti per i parametri**: i seguenti parametri hanno nuovi valori predefiniti per le istanze database di MariaDB versione 10.6:
+ Il valore predefinito per i seguenti parametri è cambiato da `utf8` a `utf8mb3`:
+ [character\$1set\$1client](https://mariadb.com/kb/en/server-system-variables/#character_set_client)
+ [character\$1set\$1connection](https://mariadb.com/kb/en/server-system-variables/#character_set_connection)
+ [character\$1set\$1results](https://mariadb.com/kb/en/server-system-variables/#character_set_results)
+ [character\$1set\$1system](https://mariadb.com/kb/en/server-system-variables/#character_set_system)
Sebbene i valori predefiniti siano cambiati per questi parametri, non vi è alcuna modifica funzionale. Per ulteriori informazioni, consulta [Set di caratteri e regole di confronto supportati](https://mariadb.com/kb/en/supported-character-sets-and-collations/) nella documentazione di MariaDB.
+ Il valore predefinito del parametro [ collation\$1connection](https://mariadb.com/kb/en/server-system-variables/#collation_connection) è stato modificato da `utf8_general_ci` a `utf8mb3_general_ci`. Sebbene il valore predefinito sia cambiato per questo parametri, non vi è alcuna modifica funzionale.
+ Il valore predefinito del parametro [ old\$1mode](https://mariadb.com/kb/en/server-system-variables/#old_mode) è stato modificato da non impostato a `UTF8_IS_UTF8MB3`. Sebbene il valore predefinito sia cambiato per questo parametri, non vi è alcuna modifica funzionale.
Per un elenco di tutte le funzionalità di MariaDB 10.6 e la relativa documentazione, consulta [Modifiche e miglioramenti in MariaDB 10.6](https://mariadb.com/kb/en/changes-improvements-in-mariadb-106/) e [Note di rilascio - MariaDB 10.6 Series](https://mariadb.com/kb/en/release-notes-mariadb-106-series/) sul sito Web di MariaDB.
Per un elenco delle funzionalità non supportate, consulta [Funzionalità MariaDB non supportate da Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Supporto per MariaDB 10.5 in Amazon RDS
Amazon RDS supporta le seguenti nuove funzionalità per le istanze database che eseguono MariaDB versione 10.5 o successive:
+ **Miglioramenti InnoDB** – MariaDB versione 10.5 include miglioramenti InnoDB. Per ulteriori informazioni, consulta [InnoDB: Miglioramenti delle prestazioni ecc.](https://mariadb.com/kb/en/changes-improvements-in-mariadb-105/#innodb-performance-improvements-etc) nella documentazione di MariaDB.
+ **Aggiornamenti dello schema delle prestazioni** – MariaDB versione 10.5 include aggiornamenti dello schema delle prestazioni. Per ulteriori informazioni, consulta [Aggiornamenti dello schema delle prestazioni che corrispondono alla strumentazione e alle tabelle MySQL 5.7](https://mariadb.com/kb/en/changes-improvements-in-mariadb-105/#performance-schema-updates-to-match-mysql-57-instrumentation-and-tables) nella documentazione di MariaDB.
+ **Un file nel log redo InnoDB** – Nelle versioni di MariaDB prima della versione 10.5, il valore del parametro `innodb_log_files_in_group` era impostato su `2`. In MariaDB versione 10.5, il valore di questo parametro è impostato su `1`.
Se si esegue l'aggiornamento da una versione precedente a MariaDB versione 10.5 e non si modificano i parametri, il valore del parametro `innodb_log_file_size` rimane invariato. Tuttavia, si applica a un file di log anziché a due. Il risultato è che l'istanza di MariaDB versione 10.5 aggiornata utilizza metà delle dimensioni del log redo che stava utilizzando prima dell'aggiornamento. Questa modifica può avere un notevole impatto sulle prestazioni. Per risolvere questo problema, è possibile raddoppiare il valore del parametro `innodb_log_file_size`. Per ulteriori informazioni sulla modifica dei parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
+ **Comando SHOW SLAVE STATUS non supportato** – Nelle versioni di MariaDB precedenti alla versione 10.5, il comando `SHOW SLAVE STATUS` richiedeva il privilegio `REPLICATION SLAVE`. In MariaDB versione 10.5, il comando `SHOW REPLICA STATUS` equivalente richiede il privilegio `REPLICATION REPLICA ADMIN`. Questo nuovo privilegio non viene concesso all'utente master RDS.
Anziché utilizzare il comando `SHOW REPLICA STATUS`, eseguire la nuova procedura memorizzata `mysql.rds_replica_status` per restituire informazioni simili. Per ulteriori informazioni, consulta [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md).
+ **Comando SHOW RELAYLOG EVENTS non supportato** – Nelle versioni di MariaDB precedenti alla versione 10.5, il comando `SHOW RELAYLOG EVENTS` richiedeva il privilegio `REPLICATION SLAVE`. In MariaDB versione 10.5, questo comando richiede il privilegio `REPLICATION REPLICA ADMIN`. Questo nuovo privilegio non viene concesso all'utente master RDS.
+ **Nuovi valori predefiniti per i parametri** – I seguenti parametri hanno nuovi valori predefiniti per le istanze database di MariaDB versione 10.5:
+ Il valore predefinito del parametro [max\$1connections](https://mariadb.com/kb/en/server-system-variables/#max_connections) è stato modificato in `LEAST({DBInstanceClassMemory/25165760},12000)`. Per informazioni sulla funzione del parametro `LEAST`, consulta [Funzioni dei parametri database](USER_ParamValuesRef.md#USER_ParamFunctions).
+ Il valore predefinito del parametro [innodb\$1adaptive\$1hash\$1index](https://mariadb.com/kb/en/innodb-system-variables/#innodb_adaptive_hash_index) è stato modificato in `OFF` (`0`).
+ Il valore predefinito del parametro [innodb\$1checksum\$1algorithm](https://mariadb.com/kb/en/innodb-system-variables/#innodb_checksum_algorithm) è stato modificato in `full_crc32`.
+ Il valore predefinito del parametro [innodb\$1log\$1file\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_file_size) è stato modificato in 2 GB.
Per un elenco di tutte le funzionalità di MariaDB 10.5 e la relativa documentazione, consulta [Modifiche e miglioramenti in MariaDB 10.5](https://mariadb.com/kb/en/changes-improvements-in-mariadb-105/) e [Note di rilascio - MariaDB 10.5 Series](https://mariadb.com/kb/en/release-notes-mariadb-105-series/) sul sito Web di MariaDB.
Per un elenco delle funzionalità non supportate, consulta [Funzionalità MariaDB non supportate da Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Supporto per MariaDB 10.4 in Amazon RDS
Amazon RDS supporta le seguenti nuove funzionalità per le istanze database che eseguono MariaDB versione 10.4 o successive:
+ **Miglioramenti in termini di sicurezza dell'account utente** – [Scadenza password](https://mariadb.com/kb/en/user-password-expiry/) e miglioramenti del [blocco account](https://mariadb.com/kb/en/account-locking/)
+ **Miglioramenti di Optimizer** – [Funzionalità Optimizer Trace](https://mariadb.com/kb/en/optimizer-trace-overview/)
+ **Miglioramenti di InnoDB** – [Supporto Instant DROP COLUMN](https://mariadb.com/kb/en/alter-table/#drop-column) ed estensione `VARCHAR` istant per `ROW_FORMAT=DYNAMIC` e `ROW_FORMAT=COMPACT`
+ **Nuovi parametri** – Inclusi [tcp\$1nodedelay](https://mariadb.com/kb/en/server-system-variables/#tcp_nodelay), [tls\$1version](https://mariadb.com/kb/en/ssltls-system-variables/#tls_version) e [gtid\$1cleanup\$1batch\$1size](https://mariadb.com/kb/en/gtid/#gtid_cleanup_batch_size)
Per un elenco di tutte le funzionalità di MariaDB 10.4 e la relativa documentazione, consulta [Changes & Improvements in MariaDB 10.4](https://mariadb.com/kb/en/library/changes-improvements-in-mariadb-104/) e [Release Notes - MariaDB 10.4 Series](https://mariadb.com/kb/en/library/release-notes-mariadb-104-series/) sul sito Web di MariaDB.
Per un elenco delle funzionalità non supportate, consulta [Funzionalità MariaDB non supportate da Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
# Motori di storage supportati per MariaDB in Amazon RDS
RDS per MariaDB supporta i seguenti motori di storage.
**Topics**
+ [Motore di storage InnoDB](#MariaDB.Concepts.Storage.InnoDB)
+ [Il MyRocks motore di archiviazione](#MariaDB.Concepts.Storage.MyRocks)
Altri motori di storage non sono attualmente supportati da Amazon RDS for MariaDB.
## Motore di storage InnoDB
Sebbene MariaDB supporti più motori di storage con funzionalità diverse, non tutti sono ottimizzati per il recupero e per la durata dei dati. InnoDB è il motore di storage consigliato per istanze di database MariaDB su Amazon RDS. Le funzionalità di Amazon RDS come point-in-time restore e snapshot restore richiedono un motore di storage recuperabile e sono supportate solo per il motore di storage consigliato per la versione MariadB.
Per ulteriori informazioni, consulta [InnoDB](https://mariadb.com/kb/en/innodb/).
## Il MyRocks motore di archiviazione
Il motore MyRocks di archiviazione è disponibile in RDS per MariadB versione 10.6 e successive. Prima di utilizzare il motore di MyRocks archiviazione in un database di produzione, ti consigliamo di eseguire benchmark e test approfonditi per verificare eventuali vantaggi potenziali rispetto a InnoDB per il tuo caso d'uso.
Il gruppo di parametri predefinito per MariadB versione 10.6 include i parametri. MyRocks Per ulteriori informazioni, consultare [Parametri per MariaDB](Appendix.MariaDB.Parameters.md) e [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
Per creare una tabella che utilizza il motore MyRocks di archiviazione, specificalo `ENGINE=RocksDB` nell'istruzione. `CREATE TABLE` L'esempio seguente crea una tabella che utilizza il motore MyRocks di archiviazione.
```
CREATE TABLE test (a INT NOT NULL, b CHAR(10)) ENGINE=RocksDB;
```
Ti consigliamo vivamente di non eseguire transazioni che riguardano sia InnoDB MyRocks che tabelle. MariaDB non garantisce ACID (Atomicity, Consistency, Isolation, Durability) per le transazioni tra i motori di storage. Sebbene sia possibile avere sia InnoDB che MyRocks tabelle in un'istanza DB, non consigliamo questo approccio tranne durante la migrazione da un motore di archiviazione all'altro. Quando in un'istanza DB sono presenti sia InnoDB che MyRocks tabelle, ogni motore di archiviazione ha il proprio pool di buffer, il che potrebbe causare un peggioramento delle prestazioni.
MyRocks non supporta l'`SERIALIZABLE`isolamento o i gap lock. Pertanto, in genere non è possibile utilizzare la replica MyRocks basata su istruzioni. [Per ulteriori informazioni, vedere MyRocks and Replication.](https://mariadb.com/kb/en/myrocks-and-replication/)
Attualmente, è possibile modificare solo i seguenti MyRocks parametri:
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_block_cache_size](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_block_cache_size)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load_size](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load_size)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect_depth](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect_depth)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_max_latest_deadlocks](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_max_latest_deadlocks)
Il motore MyRocks di archiviazione e il motore di archiviazione InnoDB possono competere per la memoria in base alle impostazioni per i parametri `rocksdb_block_cache_size` and`innodb_buffer_pool_size`. In alcuni casi, potresti voler utilizzare il motore di MyRocks archiviazione solo su una particolare istanza DB. In tal caso, ti consigliamo di impostare il parametro `innodb_buffer_pool_size minimal` su un valore minimo e `rocksdb_block_cache_size` il più in alto possibile.
È possibile MyRocks accedere ai file di registro utilizzando le [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html)operazioni [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html)and.
Per maggiori informazioni MyRocks, consulta il [MyRocks](https://mariadb.com/kb/en/myrocks/)sito web di MariadB.
# Precaricamento della cache per MariaDB in Amazon RDS
Il precaricamento della cache InnoDB può offrire vantaggi in termini di prestazioni per l'istanza database MariaDB salvando lo stato corrente del pool di buffer quando l'istanza database viene arrestata e quindi ricaricando il pool di buffer con le informazioni salvate quando l'istanza database si avvia. Questo approccio elimina la necessità di preparare il pool di buffer a partire da un utilizzo normale del database e consente invece di precaricare il pool di buffer con le pagine per le query comuni note. Per ulteriori informazioni sul precaricamento della cache, consulta [Dump e ripristino del pool di buffer](http://mariadb.com/kb/en/mariadb/xtradbinnodb-buffer-pool/#dumping-and-restoring-the-buffer-pool) nella documentazione di MariaDB.
Il precaricamento della cache è abilitato per impostazione predefinita nelle istanze database MariaDB 10.3 e versioni successive. Per abilitarlo, imposta i parametri `innodb_buffer_pool_dump_at_shutdown` e `innodb_buffer_pool_load_at_startup` su 1 nel gruppo di parametri per l'istanza database. La modifica dei valori di questi parametri in un gruppo di parametri ha effetto su tutte le istanze database MariaDB che utilizzano tale gruppo di parametri. Per abilitare il precaricamento della cache per istanze database MariaDB specifiche, potrebbe essere necessario creare un nuovo gruppo di parametri per tali istanze database. Per informazioni sui gruppi di parametri, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
Il precaricamento della cache fornisce principalmente un vantaggio in termini di prestazioni per le istanze database che utilizzano lo storage standard. Se utilizzi lo storage PIOPS probabilmente non riscontrerai un vantaggio significativo in termini di prestazioni.
**Importante**
Se l'istanza database MariaDB non si arresta normalmente, ad esempio durante un failover, lo stato del pool di buffer non è salvato su disco. In questo caso, al riavvio dell'istanza database, MariaDB carica il file del pool di buffer disponibile. Ciò non comporta alcun problema, ma il pool di buffer ripristinato potrebbe non riflettere lo stato più recente del pool di buffer prima del riavvio. Per assicurarti di disporre di uno stato recente del pool di buffer per precaricare la cache all'avvio, consigliamo di eseguire periodicamente un dump del pool di buffer "on demand". Puoi eseguire il dump del pool di buffer o caricarlo on demand.
Puoi creare un evento per eseguire il dump del pool di buffer automaticamente e a intervalli regolari. L'istruzione seguente crea ad esempio un evento denominato `periodic_buffer_pool_dump` che esegue il dump del pool di buffer ogni ora.
```
1. CREATE EVENT periodic_buffer_pool_dump
2. ON SCHEDULE EVERY 1 HOUR
3. DO CALL mysql.rds_innodb_buffer_pool_dump_now();
```
Per ulteriori informazioni, consulta [Events](http://mariadb.com/kb/en/mariadb/stored-programs-and-views-events/) nella documentazione di MariaDB.
## Dump e caricamento del pool di buffer on demand
Puoi salvare e caricare la cache on demand mediante le seguenti stored procedure:
+ Per eseguire il dump dello stato corrente del pool di buffer su disco, chiama la stored procedure [mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_dump_now).
+ Per caricare lo stato salvato del pool di buffer dal disco, chiama la stored procedure [mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_load_now).
+ Per annullare un'operazione di caricamento in corso, chiama la stored procedure [mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_load_abort).
# Funzionalità MariaDB non supportate da Amazon RDS
Le seguenti funzionalità di MariaDB non sono supportate in Amazon RDS:
+ Motore di storage S3
+ Plug-in di autenticazione – GSSAPI
+ Plug-in di autenticazione – Unix Socket
+ AWS Plugin di crittografia di gestione delle chiavi
+ Replica ritardata per le versioni di MariaDB inferiori alla 10.6
+ Crittografia MariaDB nativa dei dati inattivi per InnoDB e Aria
Puoi abilitare la crittografia dei dati inattivi per un'istanza database MariaDB seguendo le istruzioni in [Crittografia delle risorse Amazon RDS](Overview.Encryption.md).
+ HandlerSocket
+ Tipo di tabella JSON per le versioni MariaDB inferiori alla 10.6
+ MariadB ColumnStore
+ MariaDB Galera Cluster
+ Replica multi-source
+ MyRocks motore di archiviazione per versioni di MariaDB precedenti alla 10.6
+ Plugin per la convalida della password, `simple_password_check` e `cracklib_password_check` per le versioni di MariaDB precedenti alla 11.4
+ Filtri di storage Spider
+ Filtri di storage Sphinx
+ Motore di storage TokuDB
+ Attributi degli oggetti specifici del motore di archiviazione, come descritto in [Nuovi attributi definiti dal motore nella documentazione di MariadB Table/Field/Index](http://mariadb.com/kb/en/mariadb/engine-defined-new-tablefieldindex-attributes/)
+ Crittografia di tabelle e spazi tabelle
+ Plugin per la gestione delle chiavi Hashicorp
+ Esecuzione di due aggiornamenti in parallelo
Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a determinate procedure e tabelle di sistema che richiedono privilegi avanzati. Amazon RDS supporta l'accesso ai database su un'istanza database mediante qualsiasi applicazione client SQL standard. Amazon RDS non consente l'accesso host diretto a un'istanza database tramite Telnet, Secure Shell (SSH) o Windows Remote Desktop Connection.
# Versioni di MariaDB in Amazon RDS
Per MariaDB, i numeri di versione sono organizzati come versione X.Y.Z. Nella terminologia di Amazon RDS; X.Y indica la versione principale e Z è il numero di versione secondaria. Per le implementazioni di Amazon RDS, una modifica di versione è considerata principale se cambia il numero di versione principale, ad esempio nel caso di un passaggio dalla versione 10.5 alla 10.6. Una modifica di versione è considerata secondaria se cambia solo il numero di versione secondaria, ad esempio nel caso di un passaggio dalla versione 10.6.14 alla versione 10.6.16.
**Topics**
+ [Versioni secondarie di MariaDB supportate in Amazon RDS](#MariaDB.Concepts.VersionMgmt.Supported)
+ [Versioni principali di MariaDB supportate in Amazon RDS](#MariaDB.Concepts.VersionMgmt.ReleaseCalendar)
+ [Utilizzo dell'ambiente di anteprima del database](#mariadb-working-with-the-database-preview-environment)
+ [MariaDB versione 11.7 nell’ambiente di anteprima del database](#mariadb-preview-environment-version-11-7)
+ [Versioni obsolete per Amazon RDS for MariaDB](#MariaDB.Concepts.DeprecatedVersions)
## Versioni secondarie di MariaDB supportate in Amazon RDS
Attualmente Amazon RDS supporta le seguenti versioni secondarie di MariaDB.
**Nota**
Le date con solo un mese e un anno sono approssimative e vengono aggiornate con una data esatta quando nota.
Nella tabella seguente sono indicate le versioni secondarie di MariaDB 11.8 supportate attualmente da Amazon RDS.
| Versione del motore di MariaDB | Data di rilascio nella community | Data di rilascio per RDS | Data di fine del supporto standard RDS |
| --- | --- | --- | --- |
| 11,86 | 04 febbraio 2026 | 10 febbraio 2026 | febbraio 2027 |
| 11.8.5 | 14 novembre 2025 | 20 novembre 2025 | Novembre 2026 |
| 11.8.3 | 6 agosto 2025 | 25 agosto 2025 | Settembre 2026 |
Nella tabella seguente sono indicate le versioni secondarie di MariaDB 11.4 supportate attualmente da Amazon RDS.
| Versione del motore di MariaDB | Data di rilascio nella community | Data di rilascio per RDS | Data di fine del supporto standard RDS |
| --- | --- | --- | --- |
| 11.4.10 | 04 febbraio 2026 | 10 febbraio 2026 | febbraio 2027 |
| 11.4.9 | 6 novembre 2025 | 18 novembre 2025 | Novembre 2026 |
| 11.4.8 | 6 agosto 2025 | 13 agosto 2025 | Settembre 2026 |
| 11.4.7 | 22 maggio 2025 | 4 giugno 2025 | Settembre 2026 |
| 11.4.5 | 4 febbraio 2025 | 24 febbraio 2025 | maggio 2026 |
| 11.4.4 | 1 novembre 2024 | 20 dicembre 2024 | maggio 2026 |
| 11.4.3 | 8 agosto 2024 | 15 ottobre 2024 | maggio 2026 |
Nella tabella seguente sono indicate le versioni secondarie di MariaDB 10.11 supportate attualmente da Amazon RDS.
| Versione del motore di MariaDB | Data di rilascio nella community | Data di rilascio per RDS | Data di fine del supporto standard RDS |
| --- | --- | --- | --- |
| 10.11,16 | 04 febbraio 2026 | 10 febbraio 2026 | febbraio 2027 |
| 10.11.15 | 6 novembre 2025 | 18 novembre 2025 | Novembre 2026 |
| 10.11.14 | 6 agosto 2025 | 13 agosto 2025 | Settembre 2026 |
| 10.11.13 | 22 maggio 2025 | 4 giugno 2025 | Settembre 2026 |
| 10.11.11 | 4 febbraio 2025 | 24 febbraio 2025 | maggio 2026 |
| 10.11.10 | 1 novembre 2024 | 20 dicembre 2024 | maggio 2026 |
| 10.11.9 | 8 agosto 2024 | 4 settembre 2024 | maggio 2026 |
Nella tabella seguente sono indicate le versioni secondarie di MariaDB 10.6 supportate attualmente da Amazon RDS.
| Versione del motore di MariaDB | Data di rilascio nella community | Data di rilascio per RDS | Data di fine del supporto standard RDS |
| --- | --- | --- | --- |
| 10,6,25 | 04 febbraio 2026 | 10 febbraio 2026 | Luglio 2026 |
| 10.6.24 | 6 novembre 2025 | 18 novembre 2025 | Luglio 2026 |
| 10.6.23 | 6 agosto 2025 | 13 agosto 2025 | Luglio 2026 |
| 10.6.22 | 6 maggio 2025 | 20 maggio 2025 | Luglio 2026 |
| 10,6,21 | 4 febbraio 2025 | 24 febbraio 2025 | maggio 2026 |
| 10,6,20 | 1 novembre 2024 | 20 dicembre 2024 | maggio 2026 |
| 10.6.19 | 8 agosto 2024 | 4 settembre 2024 | maggio 2026 |
Nella tabella seguente sono indicate le versioni secondarie di MariaDB 10.5 supportate attualmente da Amazon RDS.
| Versione del motore di MariaDB | Data di rilascio nella community | Data di rilascio per RDS | Data di fine del supporto standard RDS |
| --- | --- | --- | --- |
| 10,5,29 | 6 maggio 2025 | 20 maggio 2025 | giugno 2026 |
| 10.5.28 | 4 febbraio 2025 | 24 febbraio 2025 | giugno 2026 |
| 10,5,27 | 1 novembre 2024 | 20 dicembre 2024 | maggio 2026 |
Quando crei una nuova istanza database, puoi specificare qualsiasi versione di MariaDB attualmente supportata. Puoi specificare la versione principale (come MariaDB 10.5) e qualsiasi versione secondaria supportata per la versione principale specificata. Se non viene specificata alcuna versione, Amazon RDS utilizza per impostazione predefinita una versione supportata, in genere la più recente. Se viene specificata una versione principale ma non una secondaria, per impostazione predefinita Amazon RDS utilizza una release recente della versione principale specificata. Per visualizzare un elenco delle versioni supportate, nonché le impostazioni predefinite per le istanze DB appena create, usa il comando. [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) AWS CLI
Ad esempio, per elencare le versioni del motore supportate per RDS per MariaDB, esegui il comando CLI seguente:
```
aws rds describe-db-engine-versions --engine mariadb --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
La versione predefinita di MariaDB potrebbe variare in base alla Regione AWS. Per creare un'istanza DB con una versione secondaria specifica, specifica la versione secondaria durante la creazione dell'istanza DB. È possibile determinare la versione secondaria predefinita per an Regione AWS eseguendo il comando seguente: AWS CLI
```
aws rds describe-db-engine-versions --default-only --engine mariadb --engine-version major_engine_version --region region --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
Sostituire *major\$1engine\$1version* con la versione principale del motore e sostituire *region* con Regione AWS. Ad esempio, il AWS CLI comando seguente restituisce la versione predefinita del motore secondario MariaDB per la versione principale 10.5 e gli Stati Uniti occidentali (Oregon) (us-west-2): Regione AWS
```
aws rds describe-db-engine-versions --default-only --engine mariadb --engine-version 10.5 --region us-west-2 --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
### Versioni secondarie di MariaDB in Amazon RDS
**Topics**
+ [MariaDB versione 11.8.6](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.8.6)
+ [MariaDB versione 11.8.5](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.8.5)
+ [MariaDB versione 11.8.3](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.8.3)
+ [MariaDB versione 11.4.10](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.10)
+ [MariaDB versione 11.4.9](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.9)
+ [MariaDB versione 11.4.8](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.8)
+ [MariaDB versione 11.4.7](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.7)
+ [MariaDB versione 11.4.5](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.5)
+ [MariaDB versione 11.4.4](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.4)
+ [MariaDB versione 10.11.16](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.16)
+ [MariaDB versione 10.11.15](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.15)
+ [MariaDB versione 10.11.14](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.14)
+ [MariaDB versione 10.11.13](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.13)
+ [MariaDB versione 10.11.11](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.11)
+ [MariaDB versione 10.11.10](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.10)
+ [MariaDB versione 10.6.25](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.25)
+ [MariaDB versione 10.6.24](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.24)
+ [MariaDB versione 10.6.23](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.23)
+ [MariaDB versione 10.6.22](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.22)
+ [MariaDB versione 10.6.21](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.21)
+ [MariaDB versione 10.6.20](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.20)
+ [MariaDB versione 10.5.29](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.5.29)
+ [MariaDB versione 10.5.28](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.5.28)
+ [MariaDB versione 10.5.27](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.5.27)
#### MariaDB versione 11.8.6
La versione 11.8.6 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025c`.
+ È stato risolto un problema che poteva impedire la registrazione di alcune istruzioni SQL nel registro di controllo.
#### MariaDB versione 11.8.5
La versione 11.8.5 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
#### MariaDB versione 11.8.3
MariaDB versione 11.8.3 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ **Nuovo valore predefinito per il parametro**: il valore predefinito del parametro `require_secure_transport` è stato modificato da `0` a `1`, in modo da applicare connessioni di trasporto sicure per impostazione predefinita. Per ulteriori informazioni, consulta [Richiesta SSL/TLS di tutte le connessioni a un'istanza DB MariaDB su Amazon RDS](mariadb-ssl-connections.require-ssl.md).
#### MariaDB versione 11.4.10
La versione 11.4.10 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025c`.
+ È stato risolto un problema che poteva impedire la registrazione di alcune istruzioni SQL nel registro di controllo.
#### MariaDB versione 11.4.9
La versione 11.4.9 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
#### MariaDB versione 11.4.8
MariaDB versione 11.4.8 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
#### MariaDB versione 11.4.7
MariaDB versione 11.4.7 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025b`.
#### MariaDB versione 11.4.5
MariaDB versione 11.4.5 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025a`.
#### MariaDB versione 11.4.4
MariaDB versione 11.4.4 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state annullate due modifiche alla community MariadB che hanno point-in-time causato il fallimento del ripristino (PITR). Per ulteriori informazioni, consulta [MariaDB Server Jira issue MDEV-35528](https://jira.mariadb.org/browse/MDEV-35528).
#### MariaDB versione 10.11.16
La versione 10.11.16 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025c`.
+ È stato risolto un problema che poteva impedire la registrazione di alcune istruzioni SQL nel registro di controllo.
#### MariaDB versione 10.11.15
La versione 10.11.15 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
#### MariaDB versione 10.11.14
MariaDB versione 10.11.14 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
#### MariaDB versione 10.11.13
MariaDB versione 10.11.13 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025b`.
#### MariaDB versione 10.11.11
MariaDB versione 10.11.11 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025a`.
#### MariaDB versione 10.11.10
MariaDB versione 10.11.10 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state annullate due modifiche alla community MariadB che hanno point-in-time causato il fallimento del ripristino (PITR). Per ulteriori informazioni, consulta [MariaDB Server Jira issue MDEV-35528](https://jira.mariadb.org/browse/MDEV-35528).
#### MariaDB versione 10.6.25
La versione 10.6.25 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025c`.
+ È stato risolto un problema che poteva impedire la registrazione di alcune istruzioni SQL nel registro di controllo.
#### MariaDB versione 10.6.24
La versione 10.6.24 di MariaDB è ora disponibile su Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
#### MariaDB versione 10.6.23
MariaDB versione 10.6.23 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
#### MariaDB versione 10.6.22
MariaDB versione 10.6.22 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025b`.
#### MariaDB versione 10.6.21
MariaDB versione 10.6.21 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025a`.
#### MariaDB versione 10.6.20
MariaDB versione 10.6.20 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state annullate due modifiche alla community MariadB che hanno point-in-time causato il fallimento del ripristino (PITR). Per ulteriori informazioni, consulta [MariaDB Server Jira issue MDEV-35528](https://jira.mariadb.org/browse/MDEV-35528).
#### MariaDB versione 10.5.29
MariaDB versione 10.5.29 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025b`.
#### MariaDB versione 10.5.28
MariaDB versione 10.5.28 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state aggiornate le informazioni sul fuso orario per basarle su `tzdata2025a`.
#### MariaDB versione 10.5.27
MariaDB versione 10.5.27 è ora disponibile in Amazon RDS. Tale versione contiene correzioni e miglioramenti aggiunti dalla Community MariaDB e da Amazon RDS.
**Nuove funzionalità e miglioramenti**
+ Sono state annullate due modifiche alla community MariadB che hanno point-in-time causato il fallimento del ripristino (PITR). Per ulteriori informazioni, consulta [MariaDB Server Jira issue MDEV-35528](https://jira.mariadb.org/browse/MDEV-35528).
## Versioni principali di MariaDB supportate in Amazon RDS
Le versioni principali di RDS per MariaDB restano disponibili almeno fino alla fine del ciclo di vita della community per la versione della community corrispondente. È possibile utilizzare le date seguenti per pianificare i cicli di test e aggiornamento. Se Amazon estende il supporto per una versione di RDS per MariaDB più a lungo di quanto inizialmente previsto, questa tabella verrà aggiornata in base alla nuova data.
**Nota**
Le date con solo un mese e un anno sono approssimative e vengono aggiornate con una data esatta quando nota.
[È inoltre possibile visualizzare le informazioni sulle date di supporto per le principali versioni del motore eseguendo il AWS CLI comando [describe-db-major-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-major-engine-versions.html) o utilizzando l'operazione Descrivi RDS API. DBMajor EngineVersions](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBMajorEngineVersions.html)
| Versione principale di MariaDB | Data di rilascio nella community | Data di rilascio per RDS | Data di fine vita nella community | Data di fine del supporto standard RDS |
| --- | --- | --- | --- | --- |
| MariaDB 11.8 | 6 agosto 2025 | 25 agosto 2025 | giugno 2030 | giugno 2030 |
| MariadB 11.4 | 8 agosto 2024 | 15 ottobre 2024 | maggio 2029 | maggio 2029 |
| MariaDB 10.11 | 16 febbraio 2023 | 21 agosto 2023 | 16 febbraio 2028 | Febbraio 2028 |
| MariaDB 10.6 | 6 luglio 2021 | 3 febbraio 2022 | 6 luglio 2026 | agosto 2026 |
| MariaDB 10.5 | 24 giugno 2020 | 21 gennaio 2021 | 24 giugno 2025 | agosto 2026 |
## Utilizzo dell'ambiente di anteprima del database
Le istanze database MariaDB per MySQL nell’ambiente di anteprima del database sono funzionalmente simili alle altre istanze database RDS per MariaDB. Non è tuttavia possibile utilizzare l'ambiente di anteprima del database per carichi di lavoro di produzione.
Gli ambienti di anteprima presentano le seguenti limitazioni:
+ Amazon RDS elimina tutte le istanze database 60 giorni dopo la creazione, insieme a eventuali backup e snapshot.
+ Puoi utilizzare solo lo storage General Purpose (SSD) e Provisioned IOPS (SSD).
+ Non puoi ricevere assistenza Supporto con le istanze DB. [Puoi invece pubblicare le tue domande nella community di domande e risposte AWS gestita, re:POST.AWS](https://repost.aws/tags/TAsibBK6ZeQYihN9as4S_psg/amazon-relational-database-service)
+ Non puoi copiare uno snapshot di un'istanza database in un ambiente di produzione.
Le seguenti opzioni sono supportate dall'anteprima.
+ È possibile creare istanze database utilizzando le classi di istanza database db.m6i, db.m6g, db.m5, db.t3, db.r6g e db.r5. Per ulteriori informazioni sulle classi delle istanze RDS, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
+ È possibile utilizzare implementazioni Single-AZ e Multi-AZ.
+ È possibile utilizzare le funzioni di dump e caricamento standard di MariaDB per esportare o importare database da o nell’ambiente di anteprima database.
### Funzionalità non supportate nell'ambiente di anteprima del database
Le seguenti funzionalità non sono disponibili nell'ambiente di anteprima del database:
+ Copia di snapshot tra regioni diverse
+ Repliche di lettura tra regioni diverse
+ Server proxy per RDS
### Creazione di una nuova istanza database nell'ambiente di anteprima del database
È possibile creare un'istanza DB nell'ambiente Database Preview utilizzando Console di gestione AWS, AWS CLI o l'API RDS.
#### Console
**Per creare un'istanza database nell'ambiente di anteprima del database**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Scegliere **Dashboard (Pannello di controllo)** nel pannello di navigazione.
1. Nella pagina **Pannello di controllo** individua la sezione **Ambiente di anteprima del database**, come mostrato nell'immagine seguente.
![\[Sezione Ambiente di anteprima del database con link nella console Amazon RDS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/preview-environment-dashboard.png)
L'[ambiente di anteprima del database](https://us-east-2.console.aws.amazon.com/rds-preview/home?region=us-east-2#) è accessibile direttamente. Prima di poter procedere, è necessario capire e accettare le limitazioni.
![\[Finestra di dialogo Contratto di servizio ambiente di anteprima del database per accettare le limitazioni.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/preview-environment-console.png)
1. Per creare l’istanza database RDS per MariaDB, segui la stessa procedura utilizzata per creare qualsiasi istanza database Amazon RDS. Per ulteriori informazioni, consulta la procedura [Console](USER_CreateDBInstance.md#USER_CreateDBInstance.CON) in [Creazione di un'istanza database](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating).
#### AWS CLI
Per creare un'istanza DB nell'ambiente Database Preview utilizzando il AWS CLI, utilizza il seguente endpoint.
```
rds-preview.us-east-2.amazonaws.com
```
Per creare l’istanza database RDS per MariaDB, segui la stessa procedura utilizzata per creare qualsiasi istanza database Amazon RDS. Per ulteriori informazioni, consulta la procedura [AWS CLI](USER_CreateDBInstance.md#USER_CreateDBInstance.CLI) in [Creazione di un'istanza database](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating).
#### API RDS
Per creare un'istanza database nell'ambiente di anteprima del database utilizzando l'API RDS, usa il seguente endpoint.
```
rds-preview.us-east-2.amazonaws.com
```
Per creare l’istanza database RDS per MariaDB, segui la stessa procedura utilizzata per creare qualsiasi istanza database Amazon RDS. Per ulteriori informazioni, consulta la procedura [API RDS](USER_CreateDBInstance.md#USER_CreateDBInstance.API) in [Creazione di un'istanza database](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating).
## MariaDB versione 11.7 nell’ambiente di anteprima del database
MariaDB versione 11.7 è ora disponibile nell’ambiente di anteprima del database Amazon RDS. MariaDB versione 11.7 include vari miglioramenti, descritti in [Changes and improvements in MariaDB 11.7](https://mariadb.com/kb/en/changes-improvements-in-mariadb-11-7/). Questa versione include inoltre il supporto del tipo di dati, dell’indicizzazione e della ricerca vettoriale. Per ulteriori informazioni, consulta [Vector Overview](https://mariadb.com/kb/en/vector-overview/) nella documentazione di MariaDB.
È possibile utilizzare l'ambiente Database Preview per testare i carichi di lavoro rispetto a questa versione prima che sia disponibile in tutti i carichi di lavoro Regioni AWS di produzione. Per informazioni sull’ambiente di anteprima del database, consulta [Utilizzo dell'ambiente di anteprima del database](#mariadb-working-with-the-database-preview-environment). Per accedere all'ambiente di anteprima dalla console, selezionare [rds-preview/](https://console.aws.amazon.com/rds-preview/).
## Versioni obsolete per Amazon RDS for MariaDB
Le versioni 10.0, 10.1, e 10.2 di Amazon RDS per MariaDB sono obsolete.
[Per informazioni sulla politica di deprecazione di Amazon RDS per MariaDB, consulta Amazon RDS. FAQs](https://aws.amazon.com/rds/faqs/)
# Connessione all’istanza database MariaDB
Dopo che Amazon RDS ha effettuato il provisioning dell'istanza database, puoi utilizzare qualsiasi utilità o applicazione client MariaDB standard per connetterti all'istanza. Nella stringa di connessione, specifica l'indirizzo Domain Name System (DNS) dell'endpoint dell'istanza database come il parametro host. Puoi inoltre specificare il numero di porta dell'endpoint dell'istanza database come parametro porta.
Puoi stabilire la connessione ad un'istanza database Amazon RDS for MariaDB usando strumenti come il client della riga di comando MySQL. Per ulteriori informazioni sull'utilizzo del client della riga di comando MySQL, consulta [Client della riga di comando mysql](http://mariadb.com/kb/en/mariadb/mysql-command-line-client/) nella documentazione di MariaDB. Un'applicazione basata su GUI che puoi utilizzare per la connessione è Heidi. Per ulteriori informazioni, consulta la pagina relativa al [ download di HeidiSQL](http://www.heidisql.com/download.php). Per informazioni sull'installazione di MySQL (compreso il client della riga di comando MySQL), consulta [Installazione e aggiornamento di MySQL](https://dev.mysql.com/doc/refman/8.0/en/installing.html).
La maggior parte delle distribuzioni Linux include il client MariaDB invece del client Oracle MySQL. Per installare il client della linea di comando MySQL su Amazon Linux 2023, esegui il comando seguente:
```
sudo dnf install mariadb105
```
Per installare il client della linea di comando MySQL su Amazon Linux 2, esegui il comando seguente:
```
sudo yum install mariadb
```
Per installare il client a riga di comando MySQL sulla maggior parte delle distribuzioni Linux basate su DEB, esegui il comando seguente:
```
apt-get install mariadb-client
```
Per controllare la versione del client a riga di comando MySQL, esegui il comando seguente.
```
mysql --version
```
Per leggere la documentazione MySQL per la versione corrente del client, esegui il comando seguente:
```
man mysql
```
Per connettersi a un'istanza database dall'esterno di un cloud privato virtuale (VPC) basato su Amazon VPC, l'istanza database deve essere accessibile pubblicamente. Inoltre, l'accesso deve essere concesso utilizzando le regole in ingresso del gruppo di sicurezza dell'istanza database e devono essere soddisfatti altri requisiti. Per ulteriori informazioni, consulta [Impossibile connettersi all'istanza database di Amazon RDS](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
Puoi utilizzare la crittografia SSL nelle connessioni a un'istanza database MariaDB. Per informazioni, consulta [Supporto di SSL/TLS per le istanze database MariaDB in Amazon RDS](MariaDB.Concepts.SSLSupport.md).
Per trovare e connettersi a un’istanza database RDS per MariaDB, consulta i seguenti argomenti.
**Topics**
+ [Ricerca delle informazioni di connessione per un'istanza database MariaDB](USER_ConnectToMariaDBInstance.EndpointAndPort.md)
+ [Connessione dal client di riga di comando MySQL (non crittografato) per RDS per MariaDB](USER_ConnectToMariaDBInstance.CLI.md)
+ [Connessione a RDS per MariaDB con il driver AWS JDBC e il driver Python; AWS](MariaDB.Connecting.Drivers.md)
+ [Risoluzione dei problemi relativi alle connessioni all'istanza database MariaDB](USER_ConnectToMariaDBInstance.Troubleshooting.md)
# Ricerca delle informazioni di connessione per un'istanza database MariaDB
Le informazioni di connessione per un'istanza database includono l'endpoint, la porta e un utente di database valido, ad esempio l'utente master. Si supponga, ad esempio, che un valore endpoint sia `mydb.123456789012.us-east-1.rds.amazonaws.com`. In questo caso, il valore della porta è `3306` e l'utente del database è `admin`. Date queste informazioni, è possibile specificare i seguenti valori in una stringa di connessione:
+ Per host, nome host o nome DNS, specifica `mydb.123456789012.us-east-1.rds.amazonaws.com`.
+ Per la porta, specific `3306`.
+ Per l'utente, specifica `admin`.
Per connettersi a un'istanza database, utilizzare qualsiasi client per un motore di database MariaDB. Ad esempio, è possibile utilizzare il client a riga di comando MySQL o MySQL Workbench.
Per trovare le informazioni di connessione per un'istanza database, è possibile utilizzare la Console di gestione AWS, il comando [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) della AWS Command Line Interface (AWS CLI) o l'API di Amazon RDS [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html) e visualizzarne i dettagli.
## Console
**Per trovare le informazioni di connessione per un'istanza database nella Console di gestione AWS**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di spostamento scegliere **Database** per visualizzare un elenco delle istanze database.
1. Scegliere il nome dell'istanza database MariaDB per visualizzarne i dettagli.
1. Nella scheda **Connectivity & security (Connettività e sicurezza)**, copiare l'endpoint. Annotare anche il numero di porta. L'endpoint e il numero di porta sono necessari per la connessione all'istanza database.
![\[L’endpoint e la porta di un’istanza database nella console Amazon RDS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/endpoint-port.png)
1. Se è necessario trovare il nome utente master, scegliere la scheda **Configurazione** e visualizzare il valore del **nome utente principale** .
## AWS CLI
Per trovare le informazioni di connessione per un’istanza database MariaDB utilizzando AWS CLI, eseguire il comando [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html). Nella chiamata, eseguire una query per l'ID istanza database, l'endpoint, la porta e il nome utente master.
Per Linux, macOS o Unix:
```
aws rds describe-db-instances \
--filters "Name=engine,Values=mariadb" \
--query "*[].[DBInstanceIdentifier,Endpoint.Address,Endpoint.Port,MasterUsername]"
```
Per Windows:
```
aws rds describe-db-instances ^
--filters "Name=engine,Values=mariadb" ^
--query "*[].[DBInstanceIdentifier,Endpoint.Address,Endpoint.Port,MasterUsername]"
```
L'output visualizzato dovrebbe essere simile al seguente.
```
[
[
"mydb1",
"mydb1.123456789012.us-east-1.rds.amazonaws.com",
3306,
"admin"
],
[
"mydb2",
"mydb2.123456789012.us-east-1.rds.amazonaws.com",
3306,
"admin"
]
]
```
## API RDS
Per trovare le informazioni di connessione per un'istanza database utilizzando l'API Amazon RDS, richiamare l'operazione [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html). Nell'output, individuare i valori per l'indirizzo dell'endpoint, la porta dell'endpoint e il nome utente master.
# Connessione dal client di riga di comando MySQL (non crittografato) per RDS per MariaDB
**Importante**
Utilizzare una connessione MySQL non crittografata solo quando il client e il server sono nello stesso VPC e la rete è attendibile. Per ulteriori informazioni sull'uso di connessioni crittografate, consulta [Connessione alla tua istanza DB MariadB su Amazon RDS SSL/TLS dal client a riga di comando MySQL (crittografato)](USER_ConnectToMariaDBInstanceSSL.CLI.md).
Per connetterti a un'istanza database utilizzando il client della riga di comando MySQL, immetti il seguente comando al prompt dei comandi su un computer client. In questo modo esegui la connessione a un database su un'istanza database MariaDB. Sostituisci il nome DNS (endpoint) per l'istanza database con *``* e il nome utente master utilizzato con *``*. Devi fornire la password master utilizzata quando viene richiesta una password.
```
mysql -h -P 3306 -u -p
```
Dopo avere inserito la password per l'utente, l'output dovrebbe essere analogo a quanto mostrato di seguito.
```
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MariaDB connection id is 31
Server version: 10.6.10-MariaDB-log Source distribution
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]>
```
# Connessione a RDS per MariaDB con il driver AWS JDBC e il driver Python; AWS
Connect a RDS for MariaDB DB con il driver AWS JDBC e il driver Python. AWS Per ulteriori informazioni, consulta i seguenti argomenti.
**Topics**
+ [Connessione a RDS per MariaDB con il driver JDBC per Amazon Web Services (AWS)](#MariaDB.Connecting.JDBCDriver)
+ [Connessione a RDS per MariaDB con il driver Python per Amazon Web Services (AWS)](#MariaDB.Connecting.PythonDriver)
## Connessione a RDS per MariaDB con il driver JDBC per Amazon Web Services (AWS)
Il driver JDBC per Amazon Web Services (AWS) è progettato come wrapper JDBC avanzato. Tale wrapper è complementare a un driver JDBC esistente e ne estende le funzionalità. Il driver è compatibile direttamente con il driver MySQL della community Connector/J e il driver MariaDB della community. Connector/J
Per installare il driver AWS JDBC, aggiungi il file.jar del driver AWS JDBC (che si trova nell'applicazione) e mantieni i riferimenti al rispettivo driver della community. `CLASSPATH` Aggiorna il rispettivo prefisso dell’URL di connessione nel modo seguente:
+ `jdbc:mysql://` Da a `jdbc:aws-wrapper:mysql://`
+ `jdbc:mariadb://` Da a `jdbc:aws-wrapper:mariadb://`
Per ulteriori informazioni sul driver AWS JDBC e istruzioni complete per il suo utilizzo, consulta l'archivio dei driver [JDBC di Amazon Web Services (AWS)](https://github.com/awslabs/aws-advanced-jdbc-wrapper). GitHub
## Connessione a RDS per MariaDB con il driver Python per Amazon Web Services (AWS)
Amazon Web Services (AWS) Python Driver è progettato come wrapper Python avanzato. Tale wrapper è complementare al driver open source Psycopg e ne estende le funzionalità. Il driver Python per AWS supporta Python 3.8 e versioni successive. È possibile installare il pacchetto `aws-advanced-python-wrapper` utilizzando il comando `pip`, insieme ai pacchetti open source `psycopg`.
Per ulteriori informazioni sul driver AWS Python e istruzioni complete per il suo utilizzo, consulta il repository [Amazon Web Services ()AWS Python](https://github.com/awslabs/aws-advanced-python-wrapper) Driver. GitHub
# Risoluzione dei problemi relativi alle connessioni all'istanza database MariaDB
Di seguito sono indicate due cause comuni degli errori di connessione a una nuova istanza database:
+ L'istanza database è stata creata utilizzando un gruppo di sicurezza che non autorizza le connessioni dal dispositivo o dall'istanza Amazon EC2 in cui è in esecuzione l'applicazione o l'utilità MariaDB. L'istanza database deve disporre di un gruppo di sicurezza VPC che autorizzi le connessioni. Per ulteriori informazioni, consulta [Amazon VPC e Amazon RDS](USER_VPC.md).
Puoi aggiungere o modificare una regola in entrata nel gruppo di sicurezza: per **Source (Origine)**, scegli **My IP (Il mio IP)**. Questo consente l'accesso all'istanza database dall'indirizzo IP rilevato nel browser.
+ L'istanza database è stata creata utilizzando la porta predefinita 3306 e nell'azienda vi sono regole del firewall che bloccano le connessioni a tale porta dai dispositivi nella rete aziendale. Per correggere l'errore, ricrea l'istanza con una porta diversa.
Per ulteriori informazioni sui problemi di connessione, consulta [Impossibile connettersi all'istanza database di Amazon RDS](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
# Protezione delle connessioni di istanze database MariaDB
Puoi gestire la sicurezza delle istanze database MariaDB.
**Topics**
+ [Sicurezza di MariaDB in Amazon RDS](MariaDB.Concepts.UsersAndPrivileges.md)
+ [Utilizzo del plugin di convalida delle password per RDS per MariaDB](MariaDB.Concepts.PasswordValidationPlugins.md)
+ [Crittografia delle connessioni client con SSL/TLS istanze DB MariadB su Amazon RDS](mariadb-ssl-connections.md)
+ [Aggiornamento delle applicazioni per connettersi alle istanze di MariadB utilizzando nuovi certificati SSL/TLS](ssl-certificate-rotation-mariadb.md)
# Sicurezza di MariaDB in Amazon RDS
La sicurezza delle istanze database MariaDB è gestita su tre livelli:
+ AWS Identity and Access Management controlla chi è in grado di eseguire le operazioni di gestione Amazon RDS nelle istanze database. Quando esegui la connessione ad AWS usando le credenziali IAM, il tuo account IAM deve disporre di policy IAM per la concessione delle autorizzazioni richieste per eseguire le operazioni di gestione di Amazon RDS. Per ulteriori informazioni, consulta [Gestione accessi e identità per Amazon RDS](UsingWithRDS.IAM.md).
+ Quando crei un'istanza database, utilizzi un gruppo di sicurezza VPC per controllare i dispositivi e le istanze Amazon EC2 che possono aprire le connessioni all'endpoint e alla porta dell'istanza database. Queste connessioni possono essere stabilite tramite Secure Socket Layer (SSL) e Transport Layer Security (TLS). Le regole del firewall aziendale possono inoltre determinare se i dispositivi in esecuzione nell'azienda possono aprire connessioni all'istanza database.
+ Dopo la creazione di una connessione a un'istanza database MariaDB, l'autenticazione del login e le autorizzazioni sono applicate come in un'istanza autonoma di MariaDB. I comandi come `CREATE USER`, `RENAME USER`, `GRANT`, `REVOKE` e `SET PASSWORD` funzionano esattamente come nei database autonomi, come avviene per la modifica diretta delle tabelle dello schema del database.
Quando crei un'istanza database Amazon RDS, l'utente master ha i seguenti privilegi predefiniti:
+ `alter`
+ `alter routine`
+ `create`
+ `create routine`
+ `create temporary tables`
+ `create user`
+ `create view`
+ `delete`
+ `drop`
+ `event`
+ `execute`
+ `grant option`
+ `index`
+ `insert`
+ `lock tables`
+ `process`
+ `references`
+ `reload`
Questo privilegio è limitato sulle istanze database di MariaDB. Non concede l’accesso alle operazioni `FLUSH TABLES WITH READ LOCK` o `FLUSH LOGS`.
+ `replication client`
+ `replication slave`
+ `select`
+ `show create routine`
Questo privilegio è disponibile solo nelle istanze database MariaDB che eseguono la versione 11.4 e successive.
+ `show databases`
+ `show view`
+ `trigger`
+ `update`
Per ulteriori informazioni su questi privilegi, consulta [User Account Management](http://mariadb.com/kb/en/mariadb/grant/) nella documentazione di MariaDB.
**Nota**
Sebbene sia possibile eliminare l'utente master in un'istanza database, consigliamo di non farlo. Per ricreare l'utente master, utilizza l'API `ModifyDBInstance` o lo `modify-db-instance` AWS CLIe specifica una nuova password utente master con il parametro appropriato. Se l'utente master non è presente nell'istanza, viene creato con la password specificata.
Per fornire servizi di gestione per ogni istanza database, viene creato l'utente `rdsadmin` al momento della creazione dell'istanza database. I tentativi di rimuovere, rinominare, cambiare la password o modificare i privilegi dell'account `rdsadmin` produrranno errori.
Per consentire la gestione dell'istanza database, i comandi standard `kill` e `kill_query` sono stati limitati. I comandi Amazon RDS `mysql.rds_kill`, `mysql.rds_kill_query` e `mysql.rds_kill_query_id`, vengono forniti per l'uso in MariaDB e anche in MySQL, per permettere di terminare le query o le sessioni utente nelle istanze database.
# Utilizzo del plugin di convalida delle password per RDS per MariaDB
A partire da RDS per MariaDB versione 11.4, per migliorare la sicurezza delle connessioni al database è possibile utilizzare i seguenti plugin di convalida delle password:
+ [simple\$1password\$1check](https://mariadb.com/kb/en/simple-password-check-plugin/): verifica se una password contiene almeno un numero specifico di caratteri di un determinato tipo.
+ [cracklib\$1password\$1check — controlla](https://mariadb.com/kb/en/cracklib_password_check/) se una password appare in un file di dizionario della libreria. [CrackLib](https://github.com/cracklib/cracklib)
Per abilitare i plugin, imposta il valore del parametro `simple_password_check` o `cracklib_password_check` su `FORCE_PLUS_PERMANENT` nel gruppo di parametri database associati all’istanza database. Quando questo valore è impostato, il plugin non può essere disinstallato utilizzando l’`UNINSTALL PLUGIN`istruzione in fase di runtime.
Per disabilitare i plugin, imposta il valore del parametro `simple_password_check` o `cracklib_password_check` su `OFF` nel gruppo di parametri database associati all’istanza database. Quando questo valore è impostato, le regole di convalida del plugin non si applicano più alle nuove password.
Per informazioni sull’impostazione dei valori dei parametri in gruppi di parametri, consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
# Crittografia delle connessioni client con SSL/TLS istanze DB MariadB su Amazon RDS
Secure Sockets Layer (SSL) è un protocollo standard del settore utilizzato per proteggere connessioni di rete tra client e server. Dopo SSL versione 3.0, il nome è stato modificato in Transport Layer Security (TLS). Amazon RDS supporta la SSL/TLS crittografia per le istanze DB di MariadB. L'utilizzo del SSL/TLS, you can encrypt a connection between your application client and your MariaDB DB instance. SSL/TLS supporto è disponibile in tutti. Regioni AWS
Con Amazon RDS, puoi proteggere i dati in transito crittografando le connessioni client alle istanze DB di MariaDB con la crittografia per le istanze di SSL/TLS, requiring SSL/TLS for all connections to a MariaDB DB instance, and connecting from the MySQL command-line client with SSL/TLS (encrypted). The following sections provide guidance on configuring and utilizing SSL/TLS MariaDB su Amazon RDS.
**Topics**
+ [Supporto di SSL/TLS per le istanze database MariaDB in Amazon RDS](MariaDB.Concepts.SSLSupport.md)
+ [Richiesta di account utente specifici SSL/TLS per un'istanza database MariaDB su Amazon RDS](MariaDB-ssl-connections.require-ssl-users.md)
+ [Richiesta SSL/TLS di tutte le connessioni a un'istanza DB MariaDB su Amazon RDS](mariadb-ssl-connections.require-ssl.md)
+ [Connessione alla tua istanza DB MariadB su Amazon RDS SSL/TLS dal client a riga di comando MySQL (crittografato)](USER_ConnectToMariaDBInstanceSSL.CLI.md)
# Supporto di SSL/TLS per le istanze database MariaDB in Amazon RDS
Amazon RDS crea un SSL/TLS certificato e lo installa sull'istanza DB quando Amazon RDS effettua il provisioning dell'istanza. Questi certificati sono firmati da un'autorità di certificazione. Il SSL/TLS certificato include l'endpoint dell'istanza DB come nome comune (CN) del SSL/TLS certificato per proteggerlo dagli attacchi di spoofing.
Un SSL/TLS certificato creato da Amazon RDS è l'entità root affidabile e dovrebbe funzionare nella maggior parte dei casi, ma potrebbe fallire se l'applicazione non accetta catene di certificati. Se l’applicazione non accetta le catene di certificati, potrebbe essere necessario utilizzare un certificato intermedio per la connessione alla Regione AWS. Ad esempio, devi utilizzare un certificato intermedio per connetterti alle AWS GovCloud (US) regioni con SSL/TLS.
Per ulteriori informazioni sul download dei certificati, consultare [](UsingWithRDS.SSL.md). Per ulteriori informazioni sull'utilizzo SSL/TLS con MySQL, vedere. [Aggiornamento delle applicazioni per connettersi alle istanze di MariadB utilizzando nuovi certificati SSL/TLS](ssl-certificate-rotation-mariadb.md)
Amazon RDS per MariaDB supporta Transport Layer Security (TLS) versioni 1.3, 1.2, 1.1 e and 1.0. Il supporto TLS dipende dalla versione secondaria di MariaDB. La tabella seguente mostra il supporto TLS per le versioni secondarie di MariaDB.
| Versione TLS | MariaDB 11.8 | MariadB 11.4 | MariaDB 10.11 | MariaDB 10.6 | MariaDB 10.5 | MariaDB 10.4 |
| --- | --- | --- | --- | --- | --- | --- |
| TLS 1.3 | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie |
| TLS 1.2 | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie | Tutte le versioni secondarie |
| TLS 1.1 | Non supportata | Non supportata | Non supportata | 10.6.16 e precedenti | 10.5.23 e versioni precedenti | 10.4.32 e versioni precedenti |
| TLS 1.0 | Non supportata | Non supportata | Non supportata | 10.6.16 e precedenti | 10.5.23 e versioni precedenti | 10.4.32 e versioni precedenti |
# Richiesta di account utente specifici SSL/TLS per un'istanza database MariaDB su Amazon RDS
Puoi richiedere SSL/TLS la crittografia per connessioni di account utente specifici alle tue istanze DB MariaDB su Amazon RDS. La protezione delle informazioni sensibili da accessi o intercettazioni non autorizzati è fondamentale per applicare le policy di sicurezza in tutti gli ambiti in cui sia necessario mantenere la riservatezza dei dati.
Per richiedere SSL/TLS connessioni per account utente specifici, utilizza una delle seguenti istruzioni, a seconda della versione di MySQL, per SSL/TLS richiedere connessioni sull'account utente. `encrypted_user`
A tale scopo, utilizza la dichiarazione seguente.
```
ALTER USER 'encrypted_user'@'%' REQUIRE SSL;
```
Per ulteriori informazioni sulle SSL/TLS connessioni con MariaDB, [consulta Securing Connections for Client and Server](https://mariadb.com/kb/en/securing-connections-for-client-and-server/) nella documentazione di MariaDB.
# Richiesta SSL/TLS di tutte le connessioni a un'istanza DB MariaDB su Amazon RDS
Utilizza il parametro `require_secure_transport` per richiedere che tutte le connessioni utente all'istanza database MariaDB utilizzino SSL/TLS. Per le versioni 11.4 e precedenti, il valore del parametro `require_secure_transport` è `OFF` per impostazione predefinita. Per la 11.8 e le versioni successive, il valore predefinito è impostato su`ON`, che impone SSL/TLS le connessioni all'istanza DB. È possibile impostare il parametro `require_secure_transport` su `OFF` se sono necessarie connessioni non sicure.
**Nota**
Il parametro `require_secure_transport` è supportato solo per MariaDB versione 10.5 e successive.
Puoi impostare il valore del parametro `require_secure_transport` aggiornando il gruppo di parametri database per l'istanza database. Non è necessario riavviare l'istanza database affinché la modifica abbia effetto.
Quando il parametro `require_secure_transport` è impostato su `ON` per un'istanza database, un client di database può connettersi a essa se è in grado di stabilire una connessione crittografata. In caso contrario, viene restituito al client un messaggio di errore simile al seguente:
```
ERROR 1045 (28000): Access denied for user 'USER'@'localhost' (using password: YES | NO)
```
Per informazioni sull'estensione dei parametri consulta [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
Per ulteriori informazioni sul parametro `require_secure_transport`, consulta la [documentazione di MariaDB](https://mariadb.com/docs/ent/ref/mdb/system-variables/require_secure_transport/).
# Connessione alla tua istanza DB MariadB su Amazon RDS SSL/TLS dal client a riga di comando MySQL (crittografato)
I parametri del programma client `mysql` sono leggermente diversi se si utilizza la versione MySQL 5.7, la versione MySQL 8.0 o la versione MariaDB.
Per scoprire quale versione è disponibile, esegui il comando `mysql` con l’opzione `--version`. Nell'esempio seguente, nell'output viene mostrato che il programma client proviene da MariaDB.
```
$ mysql --version
mysql Ver 15.1 Distrib 10.5.15-MariaDB, for osx10.15 (x86_64) using readline 5.1
```
La maggior parte delle distribuzioni Linux, come Amazon Linux, CentOS, SUSE e Debian, hanno sostituito MySQL con MariaDB e la versione `mysql` presente proviene da MariaDB.
Per eseguire la connessione all'istanza database utilizzando SSL/TLS, segui questi passaggi:
**Per connettersi a un'istanza DB SSL/TLS utilizzando il client a riga di comando MySQL**
1. Scarica un certificato root che funzioni per tutti. Regioni AWS
Per ulteriori informazioni sul download dei certificati, consultare [](UsingWithRDS.SSL.md).
1. Per stabilire la connessione a un'istanza database con la crittografia SSL/TLS, utilizza il client a riga di comando MySQL Per il parametro `-h`, sostituisci il nome DNS (endpoint) per l'istanza database. Per il `--ssl-ca` parametro, sostituisci il nome del file del SSL/TLS certificato. Per il parametro `-P`, sostituisci la porta per l'istanza database. Per il parametro `-u`, sostituisci il nome utente di un utente di database valido, ad esempio l'utente master. Immetti la password dell'utente master quando richiesto.
L'esempio seguente mostra come avviare il client utilizzando il parametro `--ssl-ca` con il client MariaDB.
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl -P 3306 -u myadmin -p
```
Per richiedere che la SSL/TLS connessione verifichi l'endpoint dell'istanza DB rispetto all'endpoint nel SSL/TLS certificato, inserisci il comando seguente:
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl-verify-server-cert -P 3306 -u myadmin -p
```
L'esempio seguente mostra come avviare il client utilizzando il parametro `--ssl-ca` per il client MySQL 5.7 o versioni successive.
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl-mode=REQUIRED -P 3306 -u myadmin -p
```
1. Immetti la password dell'utente master quando richiesto.
Verrà visualizzato un output simile al seguente.
```
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MariaDB connection id is 31
Server version: 10.6.10-MariaDB-log Source distribution
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]>
```
# Aggiornamento delle applicazioni per connettersi alle istanze di MariadB utilizzando nuovi certificati SSL/TLS
A partire dal 13 gennaio 2023, Amazon RDS ha pubblicato nuovi certificati dell'autorità di certificazione (CA) per la connessione alle istanze database RDS utilizzando Secure Socket Layer o Transport Layer Security (SSL/TLS). Di seguito sono disponibili le informazioni sull'aggiornamento delle applicazioni per utilizzare i nuovi certificati.
Questo argomento aiuta a determinare se le applicazioni richiedono la verifica dei certificati per la connessione delle istanze database.
**Nota**
Alcune applicazioni sono configurate per connettersi a MariaDB sono se possono correttamente verificare il certificato sul server. Per queste applicazioni, è necessario aggiornare gli archivi di trust delle applicazioni client per includere i nuovi certificati CA.
Puoi specificare le seguenti modalità SSL: `disabled`, `preferred` e `required`. Quando si utilizza la modalità `preferred` SSL e il certificato CA non esiste o non è aggiornato, la connessione non utilizza SSL e continua a connettersi correttamente.
Consigliamo di evitare la modalità `preferred`. In modalità `preferred`, se la connessione rileva un certificato non valido, interrompe l'utilizzo della crittografia e procede in modo non crittografato.
Dopo aver aggiornato i certificati CA negli archivi di trust delle applicazioni client, puoi ruotare i certificati nelle istanze database. Consigliamo vivamente di testare queste procedure in un ambiente di sviluppo o di gestione temporanea prima di implementarle negli ambienti di produzione.
Per ulteriori informazioni sulla rotazione dei certificati, consulta [Rotazione del certificato SSL/TLS](UsingWithRDS.SSL-certificate-rotation.md). Per ulteriori informazioni sul download, consulta [](UsingWithRDS.SSL.md). Per informazioni sull'utilizzo SSL/TLS con le istanze DB MariadB, consulta. [Supporto di SSL/TLS per le istanze database MariaDB in Amazon RDS](MariaDB.Concepts.SSLSupport.md)
**Topics**
+ [Determinare se un client richiede la verifica del certificato per la connessione](#ssl-certificate-rotation-mariadb.determining)
+ [Aggiornare l'archivio di trust delle applicazioni](#ssl-certificate-rotation-mariadb.updating-trust-store)
+ [Codice Java di esempio per stabilire connessioni SSL](#ssl-certificate-rotation-mariadb.java-example)
## Determinare se un client richiede la verifica del certificato per la connessione
Puoi verificare se i client JDBC e MySQL richiedono la verifica del certificato per la connessione.
### JDBC
L'esempio seguente con Connector/J MySQL 8.0 mostra un modo per verificare le proprietà di connessione JDBC di un'applicazione per determinare se le connessioni riuscite richiedono un certificato valido. Per ulteriori informazioni su tutte le opzioni di connessione JDBC per MySQL, consulta l'argomento relativo alle [proprietà di configurazione](https://dev.mysql.com/doc/connector-j/en/connector-j-reference-configuration-properties.html) nella documentazione di MySQL.
Quando si utilizza Connector/J MySQL 8.0, una connessione SSL richiede la verifica rispetto al certificato CA del server se le proprietà della connessione `sslMode` sono impostate su `VERIFY_IDENTITY` o, come nell'`VERIFY_CA`esempio seguente.
```
Properties properties = new Properties();
properties.setProperty("sslMode", "VERIFY_IDENTITY");
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
```
**Nota**
Se utilizzi MySQL Java Connector v5.1.38 o successivo oppure MySQL Java Connector v8.0.9 o successivo per connetterti ai tuoi database, anche se non hai configurato esplicitamente le tue applicazioni da SSL/TLS utilizzare per la connessione ai database, questi driver client vengono utilizzati per impostazione predefinita, eseguono una verifica parziale del certificato e non riescono a connettersi se il certificato del server del database è scaduto. SSL/TLS. In addition, when using SSL/TLS
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
### MySQL
I seguenti esempi con il client MySQL mostrano due modi per verificare la connessione MySQL di uno script per determinare se le connessioni riuscite richiedono un certificato valido. Per ulteriori informazioni su tutte le opzioni di connessione con il client MySQL, consulta l'argomento relativo alla [configurazione lato client delle connessioni crittografate](https://dev.mysql.com/doc/refman/en/using-encrypted-connections.html#using-encrypted-connections-client-side-configuration) nella documentazione di MySQL.
Quando utilizzi il client MySQL 5.7 o MySQL 8.0, la connessione SSL richiede la verifica del certificato CA del server se per l'opzione `--ssl-mode` viene specificato `VERIFY_CA` o `VERIFY_IDENTITY`, come nell'esempio seguente.
```
mysql -h mysql-database.rds.amazonaws.com -uadmin -ppassword --ssl-ca=/tmp/ssl-cert.pem --ssl-mode=VERIFY_CA
```
Quando utilizzi il client MySQL 5.6, la connessione SSL richiede la verifica del certificato CA del server se viene specificata l'opzione `--ssl-verify-server-cert`, come nell'esempio seguente.
```
mysql -h mysql-database.rds.amazonaws.com -uadmin -ppassword --ssl-ca=/tmp/ssl-cert.pem --ssl-verify-server-cert
```
## Aggiornare l'archivio di trust delle applicazioni
Per informazioni sull'aggiornamento del trust store per le applicazioni MySQL, consulta [Using TLS/SSL with MariaDB Connector/J nella documentazione di MariaDB](https://mariadb.com/kb/en/library/using-tls-ssl-with-mariadb-java-connector/).
Per ulteriori informazioni sul download del certificato root, consulta [](UsingWithRDS.SSL.md).
Per gli script di esempio che importano i certificati, consulta [Script di esempio per l'importazione di certificati nel tuo archivio di trust](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-sample-script).
**Nota**
Quando aggiorni l'archivio di trust puoi conservare i certificati meno recenti oltre ad aggiungere i nuovi certificati.
Se stai utilizzando il driver JDBC Connector/J MariadB in un'applicazione, imposta le seguenti proprietà nell'applicazione.
```
System.setProperty("javax.net.ssl.trustStore", certs);
System.setProperty("javax.net.ssl.trustStorePassword", "password");
```
Quando avvii l'applicazione, imposta le seguenti proprietà.
```
java -Djavax.net.ssl.trustStore=/path_to_truststore/MyTruststore.jks -Djavax.net.ssl.trustStorePassword=my_truststore_password com.companyName.MyApplication
```
**Nota**
Specifica password diverse dalle istruzioni mostrate qui come best practice di sicurezza.
## Codice Java di esempio per stabilire connessioni SSL
L'esempio di codice seguente mostra come impostare la connessione SSL utilizzando JDBC.
```
private static final String DB_USER = "admin";
private static final String DB_USER = "user name";
private static final String DB_PASSWORD = "password";
// This key store has only the prod root ca.
private static final String KEY_STORE_FILE_PATH = "file-path-to-keystore";
private static final String KEY_STORE_PASS = "keystore-password";
public static void main(String[] args) throws Exception {
Class.forName("org.mariadb.jdbc.Driver");
System.setProperty("javax.net.ssl.trustStore", KEY_STORE_FILE_PATH);
System.setProperty("javax.net.ssl.trustStorePassword", KEY_STORE_PASS);
Properties properties = new Properties();
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
Connection connection = DriverManager.getConnection("jdbc:mysql://ssl-mariadb-public.cni62e2e7kwh.us-east-1.rds.amazonaws.com:3306?useSSL=true",properties);
Statement stmt=connection.createStatement();
ResultSet rs=stmt.executeQuery("SELECT 1 from dual");
return;
}
```
**Importante**
Dopo aver stabilito che le connessioni al database utilizzano SSL/TLS e aggiornato l'archivio di fiducia dell'applicazione, è possibile aggiornare il database per utilizzare i certificati 2048-g1. rds-ca-rsa Per istruzioni, consulta la fase 3 in [Aggiornamento del certificato CA modificando l’istanza database o il cluster di database](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-updating).
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
# Prestazioni delle query migliorate per RDS per MariaDB con Amazon RDS Optimized Reads
Puoi ottenere un'elaborazione delle query per RDS per MariaDB più rapida con Amazon RDS Optimized Reads. Un'istanza database RDS per MariaDB che utilizza RDS Optimized Reads può ottenere un'elaborazione delle query fino a due volte più veloce rispetto a un'istanza database che non lo utilizza.
**Topics**
+ [Panoramica di RDS Optimized Reads](#rds-optimized-reads-mariadb-overview)
+ [Casi d'uso per RDS Optimized Reads](#rds-optimized-reads-mariadb-use-cases)
+ [Best practice per RDS Optimized Reads](#rds-optimized-reads-mariadb-best-practices)
+ [Utilizzo di RDS Optimized Reads](#rds-optimized-reads-mariadb-using)
+ [Monitoraggio delle istanze database che utilizzano RDS Optimized Reads](#rds-optimized-reads-mariadb-monitoring)
+ [Limitazioni per RDS Optimized Reads](#rds-optimized-reads-mariadb-limitations)
## Panoramica di RDS Optimized Reads
Quando si utilizza un'istanza database RDS per MariaDB con RDS Optimized Reads attivato, l'istanza database ottiene prestazioni di query più rapide tramite l'uso di un archivio dell'istanza. Un *archivio istanze* fornisce uno storage temporaneo di livello per l’istanza database. Lo storage si trova su unità a stato solido Non-Volatile Memory Express (NVMeSSDs) () fisicamente collegate al server host. Questo storage è ottimizzato per una bassa latenza, alte I/O prestazioni casuali e un'elevata velocità di lettura sequenziale.
RDS Optimized Reads è attivato per impostazione predefinita quando un'istanza database utilizza una classe di istanza database con un archivio dell'istanza, ad esempio db.m5d o db.m6gd. Con RDS Optimized Reads, alcuni oggetti temporanei vengono archiviati nell'archivio dell'istanza. Questi oggetti temporanei includono file temporanei interni, tabelle temporanee interne su disco, file di mappe in memoria e file di cache di log binario (binlog). Per ulteriori informazioni sull'instance store, consulta [Amazon EC2 instance store](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html) nella *Amazon Elastic Compute Cloud User Guide for Linux Instances*.
I carichi di lavoro che generano gli oggetti temporanei in MariaDB per l'elaborazione delle query possono sfruttare l'archivio dell'istanza per elaborare più rapidamente le query. Questo tipo di carico di lavoro include query che coinvolgono ordinamenti, aggregazioni di hash, join ad alto carico, Common Table Expressions () e query su colonne non indicizzate. CTEs Questi volumi dell'archivio dell'istanza forniscono operazioni IOPS e prestazioni più elevate, indipendentemente dalle configurazioni utilizzate per l'archivio persistente di Amazon EBS. Poiché RDS Optimized Reads trasferisce le operazioni sugli oggetti temporanei all'instance store, le input/output operazioni al secondo (IOPS) o il throughput dello storage persistente (Amazon EBS) possono ora essere utilizzati per operazioni su oggetti persistenti. Queste includono le normali operazioni di lettura e scrittura dei file di dati e le operazioni del motore in background, come lo svuotamento e l'unione di inserimenti di buffer.
**Nota**
Gli snapshot RDS manuali e automatici contengono solo i file del motore per gli oggetti persistenti. Gli oggetti temporanei creati nell'archivio dell'istanza non sono inclusi negli snapshot RDS.
## Casi d'uso per RDS Optimized Reads
Se hai carichi di lavoro che si basano pesantemente sugli oggetti temporanei, come tabelle o file interni, per l'esecuzione delle query, puoi trarre vantaggio dall'attivazione di RDS Optimized Reads. I seguenti casi d'uso sono candidati per RDS Optimized Reads:
+ Applicazioni che eseguono query analitiche con espressioni di tabella comuni complesse (CTEs), tabelle derivate e operazioni di raggruppamento
+ Repliche di lettura che generano un intenso traffico di lettura con query non ottimizzate
+ Applicazioni che eseguono query di report on demand o dinamiche che includono operazioni complesse, ad esempio query con le clausole `GROUP BY` e `ORDER BY`
+ Carichi di lavoro che utilizzano tabelle temporanee interne per l'elaborazione delle query
È possibile monitorare la variabile di stato del motore `created_tmp_disk_tables` per determinare il numero di tabelle temporanee basate su disco create nell'istanza database.
+ Applicazioni che creano tabelle temporanee di grandi dimensioni, direttamente o tramite procedure, per archiviare risultati intermedi
+ Query di database che eseguono il raggruppamento o l'ordinamento di colonne non indicizzate
## Best practice per RDS Optimized Reads
Usa le seguenti best practice per RDS Optimized Reads:
+ Aggiungi la logica dei tentativi per le query di sola lettura, nel caso in cui non riescano perché l'archivio dell'istanza è completo durante l'esecuzione.
+ Monitora lo spazio di archiviazione disponibile sull'instance store con la CloudWatch metrica. `FreeLocalStorage` Se l'archivio dell'istanza sta raggiungendo il limite a causa del carico di lavoro dell'istanza database, modifica l'istanza database in modo da utilizzare una classe di istanza database più grande.
+ Se l'istanza database ha la memoria sufficiente ma raggiunge comunque il limite di archiviazione dell'archivio dell'istanza, aumenta il valore `binlog_cache_size` per mantenere in memoria le voci binlog specifiche della sessione. Questa configurazione impedisce di scrivere le voci binlog in file di cache binlog temporanei memorizzati su disco.
Il parametro `binlog_cache_size` è specifico della sessione. É possibile modificare il valore per ogni nuova sessione. L'impostazione di questo parametro può aumentare l'utilizzo della memoria dell'istanza database durante i picchi di carico di lavoro. Pertanto, è consigliabile aumentare il valore del parametro in base al modello di carico di lavoro dell'applicazione e alla memoria disponibile nell'istanza database.
+ Usa il valore predefinito `MIXED` per `binlog_format`. A seconda della dimensione delle transazioni, l'impostazione `binlog_format` su `ROW` può comportare la creazione di file di cache binlog di grandi dimensioni nell'archivio dell'istanza.
+ Evita di apportare modifiche in blocco in una singola transazione. Questi tipi di transazioni possono generare file di cache binlog di grandi dimensioni nell'archivio dell'istanza e possono causare problemi quando l'archivio dell'istanza è pieno. Prendi in considerazione la suddivisione delle scritture in transazioni più piccole per ridurre al minimo l'uso dello spazio di archiviazione per i file di cache binlog.
## Utilizzo di RDS Optimized Reads
L'istanza database utilizza automaticamente la funzionalità Letture ottimizzate per Amazon RDS quando in un'implementazione di istanza database single-AZ o multi-AZ, effettui il provisioning di un'istanza database RDS per MariaDB con una delle seguenti classi di istanza database.
Per attivare RDS Optimized Reads, procedi in uno dei seguenti modi:
+ Crea un'istanza database RDS per MariaDB utilizzando una di queste classi di istanza database. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Modifica un'istanza database RDS per MariaDB esistente per utilizzare una di queste classi di istanza database. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
RDS Optimized Reads è disponibile Regioni AWS ovunque siano supportate una o più classi di istanze DB con archiviazione NVMe SSD locale. Per informazioni sulle classi di istanza database, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
La disponibilità delle classi di istanze DB è diversa per. Regioni AWS Per determinare se una classe di istanza DB è supportata in una determinata istanza Regione AWS, consulta[Determinazione del supporto della classe di istanze DB in Regioni AWS](Concepts.DBInstanceClass.RegionSupport.md).
Se non desideri utilizzare RDS Optimized Reads, modifica l'istanza database in modo che non utilizzi una classe di istanza database che supporti la funzionalità.
## Monitoraggio delle istanze database che utilizzano RDS Optimized Reads
È possibile monitorare le istanze DB che utilizzano RDS Optimized Reads con le seguenti metriche: CloudWatch
+ `FreeLocalStorage`
+ `ReadIOPSLocalStorage`
+ `ReadLatencyLocalStorage`
+ `ReadThroughputLocalStorage`
+ `WriteIOPSLocalStorage`
+ `WriteLatencyLocalStorage`
+ `WriteThroughputLocalStorage`
Queste metriche forniscono dati sullo spazio di archiviazione dell'archivio dell'istanza, sulle operazioni IOPS e sulla velocità di trasmissione effettiva disponibili. Per ulteriori informazioni su questi parametri, consulta [Parametri a CloudWatch livello di istanza Amazon per Amazon RDS](rds-metrics.md#rds-cw-metrics-instance).
## Limitazioni per RDS Optimized Reads
Le seguenti limitazioni si applicano a RDS Optimized Reads:
+ RDS Optimized Reads è supportato nelle seguenti versioni di RDS per MariaDB:
+ Tutte le versioni secondarie della versione 11.4 e le versioni principali successive disponibili
+ 10.11.4 e versioni successive alla 10.11
+ 10.6.7 e versioni successive alla 10.6
+ 10.5.16 e versioni successive alla 10.5
+ 10.4.25 e versioni successive alla 10.4
Per ulteriori informazioni sulle versioni di RDS per MariaDB, consulta [Versioni di MariaDB in Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
+ Non è possibile modificare la posizione degli oggetti temporanei nell'archivio persistente (Amazon EBS) nelle classi di istanza database che supportano RDS Optimized Reads.
+ Quando i log binari sono abilitati su un'istanza database, la dimensione massima della transazione è limitata alla dimensione dell'archivio dell'istanza. In MariaDB, qualsiasi sessione che richiede più spazio di archiviazione rispetto al valore `binlog_cache_size` scrive le modifiche della transazione nei file di cache binlog temporanei, che vengono creati nell'archivio dell'istanza.
+ Le transazioni possono non riuscire quando l'archivio dell'istanza è pieno.
# Prestazioni di scrittura migliorate con Scritture ottimizzate per Amazon RDS per MariaDB
Puoi migliorare le prestazioni delle transazioni di scrittura con Scritture ottimizzate per RDS per MariaDB. Quando il database RDS per MariaDB utilizza Scritture ottimizzate per Amazon RDS, può raggiungere una velocità di trasmissione effettiva delle transazioni di scrittura fino a due volte superiore.
**Topics**
+ [Panoramica di RDS Optimized Writes](#rds-optimized-writes-overview)
+ [Utilizzo di RDS Optimized Writes](#rds-optimized-writes-using-mariadb)
+ [Abilitazione delle scritture ottimizzate per RDS in un database esistente](#rds-optimized-writes-modify-enable-mariadb)
+ [Limitazioni per RDS Optimized Writes](#rds-optimized-writes-limitations-mariadb)
## Panoramica di RDS Optimized Writes
Quando attivi Scritture ottimizzate per RDS, i database RDS per MariaDB scrivono solo una volta, quando trasferiscono i dati nell'archiviazione durevole senza la necessità del buffer di doppia scrittura. I database continuano a fornire le protezioni delle proprietà ACID per le transazioni di database affidabili, insieme alle prestazioni migliorate.
I database relazionali, come MariaDB, forniscono le *proprietà ACID* di atomicità, consistenza, isolamento e durabilità per le transazioni di database affidabili. Per fornire queste proprietà, MariaDB utilizza un'area di archiviazione di dati chiamata *buffer di doppia scrittura* che impedisce gli errori di scrittura parziale della pagina. Questi errori si verificano nel caso di un guasto hardware mentre il database sta aggiornando una pagina, ad esempio in caso di interruzione dell'alimentazione. Un database MariaDB può rilevare le scritture parziali della pagina e recuperarle con una copia della pagina nel buffer di doppia scrittura. Sebbene questa tecnica fornisca protezione, comporta anche operazioni di scrittura aggiuntive. Per ulteriori informazioni sul buffer di doppia scrittura MariaDB, consulta l'argomento relativo al [buffer di doppia scrittura](https://mariadb.com/kb/en/innodb-doublewrite-buffer/) nella documentazione di MySQL.
Quando attivi Scritture ottimizzate per Amazon RDS, i database RDS per MariaDB scrivono una sola volta, quando trasferiscono i dati nell'archiviazione durevole senza usare il buffer di doppia scrittura. Scritture ottimizzate per Amazon RDS è utile se esegui carichi di lavoro intensivi in scrittura sui database RDS per MariaDB. Esempi di database con carichi di lavoro intensivi in scrittura includono quelli che supportano pagamenti digitali, trading finanziario e applicazioni di gioco.
Questi database vengono eseguiti su classi di istanze DB che utilizzano il sistema AWS Nitro. Grazie alla configurazione hardware di questi sistemi, il database può scrivere pagine da 16 KiB direttamente su file di dati in modo affidabile e durevole in un solo passaggio. Il sistema AWS Nitro rende possibili le scritture ottimizzate per RDS.
Puoi impostare il nuovo parametro di database `rds.optimized_writes` per controllare la funzionalità Scritture ottimizzate per Amazon RDS per i database RDS per MariaDB. Accedi a questo parametro nei gruppi di parametri database RDS per MariaDB aventi le seguenti versioni:
+ Tutte le versioni secondarie della versione 11.8 e le versioni principali successive disponibili
+ 11.4.3 e versioni successive alla 11.4
+ 10.11.4 e versioni successive alla 10.11
+ 10.6.10 e versioni successive alla 10.6
Imposta il parametro su uno dei seguenti valori:
+ `AUTO` - Attiva RDS Optimized Writes se la funzionalità è supportata dal database. In caso contrario, disattiva RDS Optimized Writes. Questa è l'impostazione di default.
+ `OFF` - Disattiva RDS Optimized Writes anche la funzionalità è supportata dal database.
Se esegui la migrazione di un database RDS per MariaDB configurato per utilizzare Scritture ottimizzate per Amazon RDS in una classe di istanza database che non supporta la funzionalità, RDS disattiva automaticamente Scritture ottimizzate per Amazon RDS per il database.
Quando la funzionalità Scritture ottimizzate per Amazon RDS è disattivata, il database utilizza il buffer di doppia scrittura MariaDB.
Per determinare se un database RDS per MySQL utilizza Scritture ottimizzate per Amazon RDS, osserva il valore corrente del parametro `innodb_doublewrite` per il database. Se il database utilizza RDS Optimized Writes, questo parametro è impostato su `FALSE` (`0`).
## Utilizzo di RDS Optimized Writes
Puoi attivare RDS Optimized Writes quando crei un database RDS per MariaDB con la console RDS, o l'API RDS. AWS CLI La funzionalità RDS Optimized Writes viene attivata automaticamente quando si verificano entrambe le seguenti condizioni durante la creazione del database:
+ Si specificano una versione del motore di database e una classe di istanza database che supportano RDS Optimized Writes.
+ La funzionalità Scritture ottimizzate per Amazon RDS è supportata nelle seguenti versioni di RDS per MariaDB:
+ Tutte le versioni secondarie della versione 11.8 e le versioni principali successive disponibili
+ 11.4.3 e versioni successive alla 11.4
+ 10.11.4 e versioni successive alla 10.11
+ 10.6.10 e versioni successive alla 10.6
Per ulteriori informazioni sulle versioni di RDS per MariaDB, consulta [Versioni di MariaDB in Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
+ La funzionalità Scritture ottimizzate per Amazon RDS è supportata per i database RDS per MariaDB che utilizzano le seguenti classi di istanza database:
+ db.m7i
+ db.m7g
+ db.m6g
+ db.m6gd
+ db.m6i
+ db.m5
+ db.m5d
+ db.r7i
+ db.r7g
+ db.r6g
+ db.r6gd
+ db.r6i
+ db.r5
+ db.r5b
+ db.r5d
+ db.x2idn
+ db.x2iedn
Per informazioni sulle classi di istanza database, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
La disponibilità delle classi di istanze DB è diversa per. Regioni AWS Per determinare se una classe di istanza DB è supportata in una determinata istanza Regione AWS, consulta[Determinazione del supporto della classe di istanze DB in Regioni AWS](Concepts.DBInstanceClass.RegionSupport.md).
+ Nel gruppo di parametri associato al database, il parametro `rds.optimized_writes` è impostato su `AUTO`. Nei gruppi di parametri predefiniti, questo parametro è sempre impostato su `AUTO`.
Se vuoi utilizzare una versione del motore di database e una classe di istanza database che supportino Scritture ottimizzate per Amazon RDS, senza usare questa funzionalità, specifica un gruppo di parametri personalizzato durante la creazione del database. In questo gruppo di parametri, imposta il parametro `rds.optimized_writes` su `OFF`. Se si desidera che il database utilizzi RDS Optimized Writes in un secondo momento, è possibile impostare il parametro su `AUTO` per attivarlo. Per informazioni sull'utilizzo dei gruppi di parametri personalizzati e sull'impostazione dei parametri, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
Per informazioni sulla creazione di un'istanza database, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
### Console
Quando usi la console RDS per creare un database RDS per MariaDB, puoi filtrare le versioni del motore di database e le classi di istanza database che supportano Scritture ottimizzate per Amazon RDS. Dopo aver attivato i filtri, puoi scegliere tra le versioni del motore di database e le classi di istanza database disponibili.
Per scegliere una versione del motore di database che supporti Scritture ottimizzate per Amazon RDS, filtra le versioni del motore di database RDS per MariaDB che supportano la funzionalità in **Versione motore**, quindi scegli una versione.
![\[La sezione Opzioni motore con il filtro Scritture ottimizzate per Amazon RDS attivato per Versione motore.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/rds-optimized-writes-version-filter-mariadb.png)
Nella sezione **Instance configuration** (Configurazione dell'istanza), filtra le classi di istanza database che supportano RDS Optimized Writes, quindi scegli una classe di istanza database.
![\[La sezione Configurazione dell’istanza con il filtro Scritture ottimizzate per Amazon RDS attivato per Classe dell’istanza DB.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/rds-optimized-writes-class-filter.png)
Dopo aver effettuato queste selezioni, puoi scegliere altre impostazioni che soddisfano i tuoi requisiti e completare la creazione del database RDS per MariaDB con la console.
### AWS CLI
Per creare un'istanza DB utilizzando AWS CLI, esegui il [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)comando. Assicurati che i valori `--engine-version` e `--db-instance-class` supportino RDS Optimized Writes. Inoltre, assicurati che il gruppo di parametri associato all'istanza database abbia il parametro `rds.optimized_writes` impostato su `AUTO`. Questo esempio associa il gruppo di parametri predefinito all'istanza database.
**Example Creazione di un'istanza database che utilizza RDS Optimized Writes**
Per Linux, macOS o Unix:
```
1. aws rds create-db-instance \
2. --db-instance-identifier mydbinstance \
3. --engine mariadb \
4. --engine-version 10.6.10 \
5. --db-instance-class db.r5b.large \
6. --manage-master-user-password \
7. --master-username admin \
8. --allocated-storage 200
```
Per Windows:
```
1. aws rds create-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --engine mariadb ^
4. --engine-version 10.6.10 ^
5. --db-instance-class db.r5b.large ^
6. --manage-master-user-password ^
7. --master-username admin ^
8. --allocated-storage 200
```
### API RDS
È possibile creare un'istanza DB utilizzando l'DBInstanceoperazione [Create](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Quando utilizzi questa operazione, assicurati che i valori `EngineVersion` e `DBInstanceClass` supportino RDS Optimized Writes. Inoltre, assicurati che il gruppo di parametri associato all'istanza database abbia il parametro `rds.optimized_writes` impostato su `AUTO`.
## Abilitazione delle scritture ottimizzate per RDS in un database esistente
Per modificare un database RDS per MariaDB esistente per attivare Scritture ottimizzate per RDS, il database deve essere stato creato con una versione del motore di database e una classe di istanza database supportate. Inoltre, il database deve essere stato creato *dopo* il rilascio di Scritture ottimizzate per RDS del 7 marzo 2023, poiché la configurazione del file system sottostante richiesta è incompatibile con quella dei database creati prima del rilascio. Se queste condizioni sono soddisfatte, è possibile attivare Scritture ottimizzate per RDS impostando il parametro `rds.optimized_writes` su `AUTO`.
Se il database *non* è stato creato con una versione del motore, una classe di istanza o una configurazione del file system supportata, è possibile utilizzare RDS Blue/Green Deployments per migrare a una configurazione supportata. Durante la creazione della blue/green distribuzione, procedi come segue:
+ Seleziona **Abilita le scritture ottimizzate sul database verde**, quindi specifica una versione del motore e una classe di istanza database che supportano e scritture ottimizzate RDS. Per l'elenco delle versioni di motore e delle classi di istanza supportate, consulta [Utilizzo di RDS Optimized Writes](#rds-optimized-writes-using-mariadb).
+ In **Archiviazione** scegli **Aggiorna la configurazione del file system di archiviazione**. Questa opzione aggiorna il database a una configurazione del file system sottostante compatibile.
Quando crei la blue/green distribuzione, se il `rds.optimized_writes` parametro è impostato su`AUTO`, RDS Optimized Writes verrà abilitato automaticamente nell'ambiente verde. È quindi possibile passare alla blue/green distribuzione, il che promuove l'ambiente verde come nuovo ambiente di produzione.
Per ulteriori informazioni, consulta [Creazione di una blue/green distribuzione in Amazon RDS ](blue-green-deployments-creating.md).
## Limitazioni per RDS Optimized Writes
Quando si ripristina un database RDS per MariaDB da uno snapshot, è possibile attivare Scritture ottimizzate per Amazon RDS per il database solo se si verificano tutte le seguenti condizioni:
+ Lo snapshot è stato creato da un database che supporta RDS Optimized Writes.
+ Lo snapshot è stato creato da un database creato *dopo* il rilascio della funzionalità Scritture ottimizzate per Amazon RDS.
+ Lo snapshot è stato ripristinato in un database che supporta RDS Optimized Writes.
+ Il database ripristinato è associato a un gruppo di parametri con il parametro `rds.optimized_writes` impostato su `AUTO`.
# Aggiornamenti del motore di database MariaDB
Quando Amazon RDS supporta una nuova versione di un motore di database, puoi effettuare l’aggiornamento delle istanze database alla nuova versione. Sono disponibili due tipi di aggiornamenti per le istanze database MariaDB: per la versione principale e per la versione secondaria.
Gli *aggiornamenti a versioni principali* possono contenere modifiche al database non compatibili con le versioni precedenti delle applicazioni esistenti. Ne risulta che è necessario eseguire manualmente gli aggiornamenti a versioni principali per le proprie istanze database. Puoi avviare manualmente un aggiornamento a una versione principale modificando l’istanza database. Tuttavia, prima di eseguire un aggiornamento della versione principale, si consiglia di seguire le istruzioni presenti in [Aggiornamenti a versioni principali per RDS per MariaDB](USER_UpgradeDBInstance.MariaDB.Major.md).
Al contrario, gli *aggiornamento a versioni secondarie* includono solo modifiche compatibili con le versioni precedenti delle applicazioni esistenti. Puoi avviare un aggiornamento a una versione secondaria manualmente modificando la tua istanza database. In alternativa, è possibile abilitare l'opzione **Auto minor version upgrade (Aggiornamenti automatico della versione secondaria)** durante la creazione o la modifica di un'istanza database. Ciò significa che l'istanza database viene automaticamente aggiornata dopo che Amazon RDS testa e approva la nuova versione. Per informazioni sull’esecuzione di un aggiornamento, consulta [Aggiornamento della versione del motore di di un'istanza database](USER_UpgradeDBInstance.Upgrading.md).
Se la tua istanza database MariaDB sta utilizzando repliche di lettura, dovrai aggiornare tutte le repliche di lettura prima di aggiornare l'istanza di origine. Se la tua istanza database è in un'implementazione Multi-AZ, le repliche principali e le repliche standby vengono entrambe aggiornate. L'istanza database potrebbe non essere disponibile fino al completamento dell'aggiornamento.
Per ulteriori informazioni sulle versioni di MariaDB supportate e sulla gestione delle versioni, consulta [Versioni di MariaDB in Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
Per gli aggiornamenti del motore di database si verificano tempi di inattività. La durata dell’interruzione varia in base alla dimensione dell’istanza database.
Amazon RDS supporta anche la politica di implementazione degli aggiornamenti per gestire gli aggiornamenti automatici delle versioni secondarie su più risorse di database e. Account AWS Per ulteriori informazioni, consulta [Utilizzo della politica di implementazione degli AWS Organizations aggiornamenti per gli aggiornamenti automatici delle versioni secondarie](RDS.Maintenance.AMVU.UpgradeRollout.md).
**Suggerimento**
È possibile ridurre al minimo i tempi di inattività necessari per l'aggiornamento delle istanze DB utilizzando una distribuzione. blue/green Per ulteriori informazioni, consulta [Utilizzo di Amazon RDS Blue/Green Aurora Deployments per gli aggiornamenti del database](blue-green-deployments.md).
**Topics**
+ [Considerazioni relative agli aggiornamenti di MariaDB](#USER_UpgradeDBInstance.MariaDB.Considerations)
+ [Individuazione di destinazioni di aggiornamento valide](#USER_UpgradeDBInstance.MariaDB.FindingTargets)
+ [Numeri di versione MariaDB](USER_UpgradeDBInstance.MariaDB.VersionID.md)
+ [Numeri di versione RDS in RDS per MariaDB](USER_UpgradeDBInstance.MariaDB.rds.version.md)
+ [Aggiornamenti a versioni principali per RDS per MariaDB](USER_UpgradeDBInstance.MariaDB.Major.md)
+ [Aggiornamento di un'istanza database MariaDB](#USER_UpgradeDBInstance.MariaDB.Upgrading)
+ [Aggiornamenti automatici a versioni secondarie per RDS per MariaDB](USER_UpgradeDBInstance.MariaDB.Minor.md)
+ [Utilizzo di una replica di lettura per ridurre i tempi di inattività durante l’aggiornamento di un database RDS per MariaDB](USER_UpgradeDBInstance.MariaDB.ReducedDowntime.md)
+ [Monitoraggio degli aggiornamenti del motore RDS per MariaDB DB con eventi](USER_UpgradeDBInstance.MariaDB.Monitoring.md)
## Considerazioni relative agli aggiornamenti di MariaDB
Durante il processo di aggiornamento, Amazon RDS acquisisce due o più istantanee DB. Amazon RDS richiede fino a due istantanee dell'istanza database *prima di apportare modifiche* all'aggiornamento. Se l'aggiornamento non funziona per i database, puoi ripristinare una di queste istantanee per creare un'istanza database che esegue la versione precedente. Amazon RDS acquisisce un'altra istantanea dell'istanza database al termine dell'aggiornamento. Amazon RDS acquisisce queste istantanee indipendentemente dal fatto che AWS Backup gestisca o meno i backup per l'istanza DB.
**Nota**
Amazon RDS acquisisce gli snapshot DB solo se hai impostato il periodo di retention dei backup per l’istanza database su un valore maggiore di 0. Per cambiare il periodo di retention dei backup, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
Al termine dell'aggiornamento, non puoi ripristinare la versione precedente del motore di database. Se desideri tornare alla versione precedente, ripristina il primo snapshot DB acquisito per creare una nuova istanza database.
Puoi controllare quando eseguire l'aggiornamento dell'istanza database a una nuova versione supportata da Amazon RDS. Questo livello di controllo ti consente di mantenere la compatibilità con versioni di database specifiche e testare le nuove versioni con l'applicazione prima di distribuirle in produzione. Puoi aggiornare le versioni quando più appropriato in base alla tua pianificazione.
Se la tua istanza database utilizza una replica di lettura, devi aggiornare tutte le repliche di lettura prima di aggiornare l'istanza di origine.
Se l'istanza database è in un'implementazione Multi-AZ, vengono aggiornate sia l'istanza database principale che quella di standby. Le istanze database principali e standby vengono aggiornate contemporaneamente e si verificherà un'interruzione fino al completamento dell'aggiornamento. Il tempo di interruzione necessario varia in base a motore di database, versione del motore e dimensione dell'istanza database.
## Individuazione di destinazioni di aggiornamento valide
Quando si utilizza Console di gestione AWS per aggiornare un'istanza DB, mostra gli obiettivi di aggiornamento validi per l'istanza DB. È inoltre possibile eseguire il AWS CLI comando seguente per identificare gli obiettivi di aggiornamento validi per un'istanza DB:
Per Linux, macOS o Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version version_number \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Per Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version version_number ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Ad esempio, per identificare gli obiettivi di aggiornamento validi per un'istanza DB MariaDB versione 10.5.17, esegui il seguente comando: AWS CLI
Per Linux, macOS o Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version 10.5.17 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Per Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version 10.5.17 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
# Numeri di versione MariaDB
La sequenza di numerazione delle versioni per il motore di database RDS per MariaDB è indicata come *principale.secondaria.patch.AAAAMMGG* o *major.minor.patch*, per esempio 10.11.5.R2.20231201 o 10.4.30. Il formato utilizzato dipende dalla versione del motore MariaDB.
**principale**
Il numero di versione principale è costituito dal numero intero e dalla prima parte frazionaria del numero di versione, ad esempio 10.11. Un aggiornamento a una versione principale incrementa la parte principale del numero di versione. Ad esempio, un aggiornamento da *10.5* .20 a 10.6.12 è un aggiornamento della versione principale, dove *10.5 e *10.6** sono i numeri di versione principali.
**minore**
Il numero di versione secondaria è la terza parte del numero di versione, ad esempio il numero 5 in 10.11.5.
**patch**
La patch è la quarta parte del numero di versione, ad esempio R2 in 10.11.5.R2. Una versione della patch di RDS include importanti correzioni di bug aggiunte a una versione secondaria dopo il rilascio.
**AAAAMMGG**
La data è la quinta parte del numero di versione, ad esempio 20231201 in 10.11.5.R2.20231201. Una versione con data di RDS è una patch di sicurezza che include importanti correzioni di sicurezza aggiunte a una versione secondaria dopo il rilascio, senza includere correzioni che potrebbero modificare il comportamento del motore.
La tabella seguente spiega lo schema di denominazione per RDS per MariaDB versione 10.11.
| Versione secondaria 10.11 | Schema di denominazione |
| --- | --- |
| ≥ 5 | Le nuove istanze database utilizzano *principale.secondaria.patch.AAMMGG*, ad esempio 10.11.5.R2.20231201. Le istanze database esistenti potrebbero utilizzare *principale.secondaria.patch*, ad esempio 10.11.5.R2, fino al successivo aggiornamento a una versione principale o secondaria. |
| < 5 | Le istanze database esistenti utilizzano *principale.secondaria.patch*, ad esempio 10.11.4.R2. |
La tabella seguente spiega lo schema di denominazione per RDS per MariaDB versione 10.6.
| Versione secondaria 10.6 | Schema di denominazione |
| --- | --- |
| ≥ 14 | Le nuove istanze database utilizzano *principale.secondaria.patch.AAMMGG*, ad esempio 10.6.14.R2.20231201. Le istanze database esistenti potrebbero utilizzare *principale.secondaria.patch*, ad esempio 10.6.14.R2, fino al successivo aggiornamento a una versione principale o secondaria. |
| < 14 | Le istanze database esistenti utilizzano *principale.secondaria.patch*, ad esempio 10.6.13.R2. |
La tabella seguente spiega lo schema di denominazione per RDS per MariaDB versione 10.5.
| Versione secondaria 10.5 | Schema di denominazione |
| --- | --- |
| ≥ 21 | Le nuove istanze database utilizzano *principale.secondaria.patch.AAMMGG*, ad esempio 10.5.21.R2.20231201. Le istanze database esistenti potrebbero utilizzare *principale.secondaria.patch*, ad esempio 10.5.21.R2, fino al successivo aggiornamento a una versione principale o secondaria. |
| < 21 | Le istanze database esistenti utilizzano *principale.secondaria.patch*, ad esempio 10.5.20.R2. |
La tabella seguente spiega lo schema di denominazione per RDS per MariaDB versione 10.4.
| Versione secondaria 10.4 | Schema di denominazione |
| --- | --- |
| ≥ 30 | Le nuove istanze database utilizzano *principale.secondaria.patch.AAMMGG*, ad esempio 10.4.30.R2.20231201. Le istanze database esistenti potrebbero utilizzare *principale.secondaria.patch*, ad esempio 10.4.30.R2, fino al successivo aggiornamento a una versione principale o secondaria. |
| < 30 | Le istanze database esistenti utilizzano *principale.secondaria.patch*, ad esempio 10.4.29.R2. |
# Numeri di versione RDS in RDS per MariaDB
I numeri di versione RDS utilizzano `major.minor.patch` o lo schema di denominazione `major.minor.patch.YYYYMMDD`. Una versione della patch di RDS include importanti correzioni di bug aggiunte a una versione secondaria dopo il rilascio. Una versione con data di RDS (*AAMMGG*) è una patch di sicurezza. Una patch di sicurezza non include correzioni che potrebbero modificare il comportamento del motore.
Per identificare il numero di versione Amazon RDS del tuo database, è prima necessario creare l’estensione `rds_tools` utilizzando il seguente comando:
```
CREATE EXTENSION rds_tools;
```
Puoi trovare il numero di versione RDS del tuo database RDS per MariaDB con la seguente query SQL:
```
mysql> select mysql.rds_version();
```
Ad esempio, l’esecuzione di una query su un database RDS per MariaDB 10.6.14 restituisce il seguente output:
```
+---------------------+
| mysql.rds_version() |
+---------------------+
| 10.6.14.R2.20231201 |
+---------------------+
1 row in set (0.01 sec)
```
# Aggiornamenti a versioni principali per RDS per MariaDB
Gli aggiornamenti di versione principali possono contenere modifiche al database non compatibili con le versioni precedenti delle applicazioni esistenti. Ne risulta che Amazon RDS non applica aggiornamenti automatici alla versione principale. È necessario modificare manualmente l'istanza database. Ti raccomandiamo di eseguire un test approfondito di qualsiasi aggiornamento prima di applicarlo alle istanze di produzione.
**Nota**
In MariadB 11.8, il valore predefinito `require_secure_transport` per `1` ora è che richiede connessioni sicure. SSL/TLS Il valore può essere impostato su `0` se sono necessarie connessioni non sicure.
Amazon RDS supporta i seguenti aggiornamenti in loco per le versioni principali del motore di database MariaDB:
+ Qualsiasi versione MariaDB fino a MariaDB 11.8
+ Qualsiasi versione MariaDB fino a MariaDB 11.4
+ Qualsiasi versione MariaDB fino a MariaDB 10.11
+ Qualsiasi versione MariaDB a MariaDB 10.6
+ Da MariaDB 10.4 a MariaDB 10.5
Se usi un gruppo di parametri personalizzato ed esegui l'aggiornamento di una versione principale, devi specificare un gruppo di parametri predefinito per la nuova versione del motore di database oppure creare un gruppo di parametri personalizzato per la nuova versione del motore di database. L'associazione del nuovo gruppo di parametri all'istanza database richiede il riavvio del database avviato dal cliente al termine dell'aggiornamento. Lo stato del gruppo di parametri dell'istanza riporterà `pending-reboot` se è necessario riavviare l'istanza per applicare le modifiche del gruppo di parametri. È possibile visualizzare lo stato del gruppo di parametri dell’istanza nella Console di gestione AWS oppure eseguendo una chiamata “describe” (descrivi) come `describe-db-instances`.
## Aggiornamento di un'istanza database MariaDB
Per informazioni sull'aggiornamento manuale o automatico di un'istanza database MariaDB, consulta [Aggiornamento della versione del motore di di un'istanza database](USER_UpgradeDBInstance.Upgrading.md).
# Aggiornamenti automatici a versioni secondarie per RDS per MariaDB
Se specifichi le seguenti impostazioni durante la creazione o la modifica di un’istanza database, puoi decidere aggiornare automaticamente l’istanza database.
+ L'impostazione di **aggiornamento automatico della versione secondaria** deve essere attivata.
+ L’impostazione del **periodo di conservazione del backup** deve essere maggiore di 0.
Nella Console di gestione AWS, queste impostazioni si trovano in **Additional configuration** (Configurazione aggiuntiva). L’immagine che segue mostra l’impostazione **Aggiornamento automatico versione secondaria**.
![\[Impostazione di aggiornamento automatico della versione secondaria\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/amvu.png)
Per ulteriori informazioni su queste impostazioni, consultare [Impostazioni per istanze database](USER_ModifyInstance.Settings.md).
Per alcune versioni principali di RDS per MariaDB in alcune Regioni AWS, una versione secondaria viene designata da RDS come la versione di aggiornamento automatico. Una volta che una versione secondaria è stata testata e approvata da Amazon RDS, l’aggiornamento alla versione secondaria avviene automaticamente nel corso della finestra di manutenzione. RDS non imposta mai automaticamente le nuove release secondarie come versione di aggiornamento automatico. Prima che RDS indichi una versione di aggiornamento automatico più recente, vengono considerati diversi livelli di valutazione, quali:
+ Problemi di sicurezza noti
+ Bug nella versione della community di MariaDB
+ Stabilità generale del parco istanze da quando la versione secondaria è stata rilasciata
**Nota**
Il supporto per l’utilizzo delle versioni TLS 1.0 e 1.1 è stato rimosso a partire da specifiche versioni secondarie di MariaDB. Per informazioni sulle versioni secondarie supportate di MariaDB, consulta [Supporto di SSL/TLS per le istanze database MariaDB in Amazon RDS](MariaDB.Concepts.SSLSupport.md).
Puoi eseguire il comando AWS CLI seguente per determinare la versione di destinazione dell’aggiornamento automatico secondario corrente per una versione secondaria di MariaDB specificata in una determinata Regione AWS.
Per Linux, macOS o Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version minor_version \
--region region \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" \
--output text
```
Per Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version minor_version ^
--region region ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" ^
--output text
```
Ad esempio, il comando AWS CLI seguente determina la destinazione dell'aggiornamento secondario automatico per la versione secondaria MariaDB 10.5.16 nella Regione AWS Stati Uniti orientali (Ohio) (us-east-2).
Per Linux, macOS o Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version 10.5.16 \
--region us-east-2 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" \
--output table
```
Per Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version 10.5.16 ^
--region us-east-2 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" ^
--output table
```
L’output è simile a quello riportato di seguito.
```
----------------------------------
| DescribeDBEngineVersions |
+--------------+-----------------+
| AutoUpgrade | EngineVersion |
+--------------+-----------------+
| True | 10.5.17 |
| False | 10.5.18 |
| False | 10.5.19 |
| False | 10.6.5 |
| False | 10.6.7 |
| False | 10.6.8 |
| False | 10.6.10 |
| False | 10.6.11 |
| False | 10.6.12 |
+--------------+-----------------+
```
In questo esempio, il valore `AutoUpgrade` è `True` per MariaDB versione 10.5.17. Quindi, la destinazione dell'aggiornamento secondario automatico è MariaDB versione 10.5.17, che è evidenziata nell'output.
Un'istanza database MariaDB viene aggiornata automaticamente durante la finestra di manutenzione se vengono soddisfatti i seguenti criteri:
+ L'impostazione di **aggiornamento automatico della versione secondaria** deve essere attivata.
+ L’impostazione del **periodo di conservazione del backup** deve essere maggiore di 0.
+ L'istanza database esegue una versione motore database minore rispetto a una versione minore automatica dell'aggiornamento corrente.
Per ulteriori informazioni, consulta [Aggiornamento automatico della versione secondaria del motore](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades).
# Utilizzo di una replica di lettura per ridurre i tempi di inattività durante l’aggiornamento di un database RDS per MariaDB
Nella maggior parte dei casi, un'implementazione blu/verde è l'opzione migliore per ridurre i tempi di inattività durante l'aggiornamento di un'istanza database MariaDB. Per ulteriori informazioni, consulta [Utilizzo di Amazon RDS Blue/Green Aurora Deployments per gli aggiornamenti del database](blue-green-deployments.md).
Se non è possibile utilizzare un'implementazione blu/verde e l'istanza database MariaDB è attualmente in uso con un'applicazione di produzione, puoi seguire la seguente procedura per aggiornare la versione del database per l'istanza database. Questa procedura permette di ridurre i tempi di indisponibilità dell’applicazione.
Utilizzando una replica di lettura, è possibile eseguire la maggior parte dei passaggi di manutenzione in anticipo e ridurre al minimo le modifiche necessarie durante l'interruzione effettiva. Con questa tecnica, è possibile testare e preparare la nuova istanza database senza apportare alcuna modifica all’istanza database esistente.
La seguente procedura mostra un esempio di aggiornamento da MariaDB versione 10.5 a MariaDB versione 10.6. Puoi utilizzare la stessa procedura generale per gli aggiornamenti ad altre versioni principali.
**Per aggiornare un database MariaDB con un'istanza database in uso**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all’indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Crea una replica di lettura dell'istanza database MariaDB 10.5. Questo processo crea una copia aggiornabile del database. Potrebbero esistere già presenti altre repliche di lettura dell'istanza database.
1. Nella console, seleziona **Database** e quindi l'istanza database da aggiornare.
1. Per **Actions (Operazioni)**, scegliere **Create read replica (Crea replica di lettura)**.
1. Fornisci un valore per **DB instance identifier** (Identificatore di istanza database) per la replica di lettura e assicurati che **DB instance class** (Classe di istanza database) e altre impostazioni corrispondano all'istanza database MariaDB 10.5.
1. Scegliere **Create read replica (Crea replica di lettura)**.
1. (Facoltativo) Una volta creata la replica di lettura e il campo **Stato** riporta **Disponibile**, converti la replica di lettura in una implementazione Multi-AZ e abilita i backup.
Per impostazione predefinita, una replica di lettura viene creata come implementazione single-AZ con backup disabilitati. Poiché la replica di lettura diventerà in definitiva l'istanza database di produzione, è opportuno configurare un'implementazione multi-AZ e abilitare i backup in questo momento.
1. Nella console, seleziona **Database**, quindi seleziona la replica di lettura appena creata.
1. Scegliere **Modify (Modifica)**.
1. Per **Implementazione Multi-AZ**, seleziona **Crea istanza di standby**.
1. In **Backup Retention Period** (Periodo di conservazione dei backup), seleziona un valore positivo diverso da zero, ad esempio 3 giorni, quindi scegli **Continue** (Continua).
1. In **Scheduling of Modifications (Pianificazione delle modifiche)**, scegliere **Apply immediately (Applica immediatamente)**.
1. Scegliere **Modify DB Instance (Modifica istanza database)**.
1. Quando il campo **Status** (Stato) della replica di lettura riporta **Available** (Disponibile), aggiorna la replica di lettura a MariaDB 10.6.
1. Nella console, seleziona **Database**, quindi seleziona la replica di lettura appena creata.
1. Scegliere **Modify (Modifica)**.
1. In **DB engine version** (Versione motore database) scegli la versione MariaDB 10.6 da aggiornare e quindi seleziona **Continue** (Continua).
1. In **Scheduling of Modifications (Pianificazione delle modifiche)**, scegliere **Apply immediately (Applica immediatamente)**.
1. Scegliere **Modify DB Instance (Modifica istanza database)** per avviare l’aggiornamento.
1. Al termine dell'aggiornamento, quando il campo **Status** (Stato) riporta **Available** (Disponibile), verifica che la replica di lettura aggiornata sia sincronizzata con l'istanza database MariaDB 10.5 di origine. Per verificare, connettiti alla replica di lettura ed esegui il comando `SHOW REPLICA STATUS`. Se il campo `Seconds_Behind_Master` vale `0`, la replica è sincronizzata.
**Nota**
Le versioni precedenti di MariaDB utilizzavano `SHOW SLAVE STATUS` anziché `SHOW REPLICA STATUS`. Se si utilizza una versione di MariaDB precedente alla 10.6, usa `SHOW SLAVE STATUS`.
1. (Facoltativo) Crea una replica di lettura della replica di lettura.
Se desideri che l'istanza database disponga di una replica di lettura dopo che è stata promossa a un'istanza database autonoma, puoi crearla in questo momento.
1. Nella console, seleziona **Database**, quindi scegli la replica di lettura appena aggiornata.
1. Per **Actions (Operazioni)**, scegliere **Create read replica (Crea replica di lettura)**.
1. Fornisci un valore per **DB instance identifier** (Identificatore di istanza database) per la replica di lettura e assicurati che **DB instance class** (Classe di istanza database) e altre impostazioni corrispondano all'istanza database MariaDB 10.5.
1. Scegliere **Create read replica (Crea replica di lettura)**.
1. (Facoltativo) Configura un gruppo di parametri database personalizzato per la replica di lettura.
Se desideri che l'istanza database utilizzi un gruppo di parametri personalizzato dopo che è stato promossa a un'istanza database autonoma, puoi creare il gruppo e associarlo alla replica di lettura.
1. Crea un gruppo di parametri database personalizzato per MariaDB 10.6. Per istruzioni, consultare [Creazione di un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Creating.md).
1. Modifica i parametri che desideri modificare nel gruppo di parametri database appena creato. Per istruzioni, consultare [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
1. Nella console seleziona **Database**, quindi scegli la replica di lettura.
1. Scegliere **Modify (Modifica)**.
1. Per **DB parameter group** (Gruppo di parametri database), seleziona il gruppo di parametri database MariaDB 10.6 appena creato, quindi scegli **Continue** (Continua).
1. In **Scheduling of Modifications (Pianificazione delle modifiche)**, scegliere **Apply immediately (Applica immediatamente)**.
1. Scegliere **Modify DB Instance (Modifica istanza database)** per avviare l’aggiornamento.
1. Promuovi la replica di lettura MariaDB 10.6 a un'istanza database autonoma.
**Importante**
Quando promuovi la replica di lettura MariaDB 10.6 a un'istanza database autonoma, la replica non sarà più dell'istanza database MariaDB 10.5. Ti consigliamo di promuovere la replica di lettura MariaDB 10.6 durante una finestra di manutenzione quando l'istanza database MariaDB 10.5 di origine è in modalità di sola lettura e tutte le operazioni di scrittura sono sospese. Al termine dell'operazione, è possibile indirizzare le operazioni di scrittura all'istanza database MariaDB 10.6 aggiornata per evitare la perdita di qualsiasi informazione.
Inoltre, prima di promuovere la replica di lettura MariaDB 10.6, ti consigliamo di eseguire tutte le operazioni DDL (Data Definition Language) necessarie sulla replica di lettura MariaDB 10.6. Un esempio di tale operazione è la creazione degli indici. Questo approccio consente di evitare qualsiasi effetto negativo sulle prestazioni della replica di lettura MariaDB 10.6 dopo la promozione. Per promuovere una replica di lettura, utilizzare la procedura seguente.
1. Nella console, seleziona **Database**, quindi scegli la replica di lettura appena aggiornata.
1. In **Actions** (Operazioni), seleziona **Promote** (Promuovi).
1. Scegliere **Yes (Sì)** per abilitare backup automatizzati per l'istanza della replica di lettura. Per ulteriori informazioni, consulta [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md).
1. Scegli **Continue (Continua)**.
1. Selezionare **Promote read replica (Promuovi replica di lettura)**.
1. Ora si dispone di una versione aggiornata del database MariaDB. A questo punto, puoi indirizzare le applicazioni alla nuova istanza database MariaDB 10.6.
# Monitoraggio degli aggiornamenti del motore RDS per MariaDB DB con eventi
Quando aggiorni la versione del motore di un database RDS per MariaDB, Amazon RDS emette un evento specifico durante ogni fase del processo. Per monitorare lo stato di avanzamento di un aggiornamento, puoi visualizzare o sottoscrivere questi eventi.
Per ulteriori informazioni sugli eventi RDS, consulta[Monitoraggio di eventi Amazon RDS](working-with-events.md).
Per informazioni dettagliate su uno specifico evento Amazon RDS che si verifica durante l'aggiornamento del motore, consulta[Categorie di eventi e messaggi di eventi di Amazon RDS ](USER_Events.Messages.md).
# Aggiornamento di una versione del motore di snapshot di database MariaDB
Amazon RDS consente di creare uno snapshot di database del volume di archiviazione dell’istanza database MariaDB. Quando si crea uno snapshot di database, lo snapshot si basa sulla versione del motore utilizzata dall’istanza database. È possibile aggiornare la versione del motore per gli snapshot di database in uso.
Per RDS per MariaDB, è possibile eseguire l’aggiornamento a tutte le versioni del motore disponibili. È possibile aggiornare snapshot di database crittografati o non crittografati.
Per visualizzare le versioni del motore disponibili per lo snapshot di database RDS per MariaDB, utilizza l’esempio della AWS CLI seguente.
```
aws rds describe-db-engine-versions --engine mariadb --include-all --engine-version example-engine-version --query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Se per lo snapshot non viene visualizzato alcun risultato, la versione del motore potrebbe essere obsoleta. Se la versione del motore è obsoleta, si consiglia di eseguire l’aggiornamento alla versione principale più recente oppure a una delle altre destinazioni di aggiornamento disponibili per tale versione. Per ulteriori informazioni, consulta [Opzioni di aggiornamento per snapshot di database con versioni del motore non supportate per RDS per MariaDB](mariadb-upgrade-snapshot.upgrade-options.md).
Dopo aver ripristinato uno snapshot DB aggiornato a una nuova versione del motore, verificare che l'aggiornamento abbia avuto esito positivo. Per maggiori informazioni sull’aggiornamento di una versione principale, consultare [Aggiornamenti del motore di database MariaDB](USER_UpgradeDBInstance.MariaDB.md). Per informazioni su come ripristinare uno snapshot DB, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
**Nota**
Non è possibile aggiornare gli snapshot di database automatizzati creati durante il processo di backup automatico.
È possibile aggiornare uno snapshot DB utilizzando Console di gestione AWS AWS CLI, o l'API RDS.
------
#### [ Console ]
Per aggiornare una versione del motore di snapshot DB utilizzando il Console di gestione AWS, utilizzare la procedura seguente.
**Per aggiornare uno snapshot DB**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, selezionare **Snapshots (Snapshot)**.
1. Scegli la snapshot da usare per l’aggiornamento.
1. Per **Actions (Operazioni)**, scegliere **Upgrade snapshot (Aggiorna snapshot)**. Viene visualizzata la pagina **Upgrade snapshot (Aggiorna snapshot)**.
1. Scegli **New engine version (Nuova versione del motore)** per eseguire l’aggiornamento.
1. Scegliere **Save changes (Salva modifiche)** per aggiornare lo snapshot.
Durante il processo di aggiornamento, tutte le operazioni dello snapshot sono disabilitate per lo snapshot database. Inoltre, lo stato dello snapshot di database cambia da **disponibile** a **in aggiornamento**, quindi diventa **attivo** al completamento. Se lo snapshot di database non può essere aggiornato a causa di problemi di corruzione, lo stato diventa **non disponibile**. Non è possibile recuperare lo snapshot quando è in questo stato.
**Nota**
Se l’aggiornamento dello snapshot fallisce, lo snapshot viene riportato allo stato originario con la versione iniziale.
------
#### [ AWS CLI ]
Per aggiornare uno snapshot DB a una nuova versione del motore di database, esegui il AWS CLI [modify-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-snapshot.html)comando.
**Opzioni**
+ `--db-snapshot-identifier` – Identificatore dello snapshot DB da aggiornare. L'identificatore deve essere un Amazon Resource Name (ARN) univoco. Per ulteriori informazioni, consulta [Nomi della risorsa Amazon (ARN) in Amazon RDS](USER_Tagging.ARN.md).
+ `--engine-version` – Versione del motore a cui aggiornare lo snapshot DB.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds modify-db-snapshot \
2.
3. --db-snapshot-identifier my_db_snapshot \
4. --engine-version new_version
```
Per Windows:
```
1. aws rds modify-db-snapshot ^
2. --db-snapshot-identifier my_db_snapshot ^
3. --engine-version new_version
```
------
#### [ Amazon RDS API ]
[Per aggiornare uno snapshot DB a una nuova versione del motore di database, chiamate l'operazione RDS API Modify. DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBSnapshot.html)
**Parameters**
+ `DBSnapshotIdentifier` – Identificatore dello snapshot DB da aggiornare. L'identificatore deve essere un Amazon Resource Name (ARN) univoco. Per ulteriori informazioni, consulta [Nomi della risorsa Amazon (ARN) in Amazon RDS](USER_Tagging.ARN.md).
+ `EngineVersion` – Versione del motore a cui aggiornare lo snapshot DB.
------
# Opzioni di aggiornamento per snapshot di database con versioni del motore non supportate per RDS per MariaDB
Nella tabella seguente sono indicate le versioni del motore a cui è possibile eseguire l’aggiornamento da una versione del motore non supportata per gli snapshot di database di RDS per MariaDB.
**Nota**
Per eseguire l’aggiornamento alla versione del motore scelta, potrebbe essere necessario aggiornare lo snapshot di database più di una volta.
| Versione del motore di snapshot di database | Versioni del motore disponibili per l’aggiornamento |
| --- | --- |
| 10.0.17, 10.0.24, 10.0.28, 10.0.31, 10.0.32, 10.0.34, 10.0.35 | 10.0.38, 10.1.48, 10.6.19, 10.6.20, 10.11.9, 10.11.10, 11.4.3, 11.4.4, 11.8.3 |
| 10.1.14, 10.1.16, 10.1.19, 10.1.23, 10.1.26, 10.1.31, 10.1.34 | 10.1.48, 10.2.44, 10.6.19, 10.6.20, 10.11.9, 10.11.10, 11.4.3, 11.4.4, 11.8.3 |
| 10.2.11, 10.2.12, 10.2.15, 10.2.21, 10.2.32, 10.2.37, 10.2.39, 10.2.40, 10.2.41, 10.2.43 | 10.2.44, 10.3.39, 10.6.19, 10.6.20, 10.6.21, 10.11.9, 10.11.10, 10.11.11, 11.4.3, 11.4.4, 11.8.3 |
| 10.3.8, 10.3.13, 10.3.20, 10.3.23, 10.3.28, 10.3.31, 10.3.32 | 10.3.39, 10.4.34, 10.6.19, 10.6.20 10.6.21, 10.11.9, 10.11.10, 10.11.11, 11.4.3, 11.4.4, 11.8.3 |
| 10,48 | 10.4.34, 10.5.16, 10.5.17, 10.5.18, 10.5.20, 10.5.21, 10.5.22, 10.5.23, 10.5.24, 10.5.25, 10.5.26, 10.5.27, 10.5.28, 10.6.8, 10.6.10, 10.6.11, 10.6.13, 10.6.14, 10.6.15, 10.6.16, 10.6.18, 10.6.19, 10.6.20, 10.6.21, 10.11.4, 10.6.17, 10.11.5, 10.11.6, 10.11.7, 10.11.8, 10.11.9, 10.11.10, 10.11.11 |
# Importazione di dati in un’istanza database Amazon RDS per MariaDB.
Puoi utilizzare diverse tecniche per importare i dati in un'istanza database RDS for MariaDB. L’approccio migliore dipende da una serie di fattori:
+ Origine dei dati
+ Quantità di dati
+ Importazione continua o eseguita una sola volta
+ Durata del tempo di inattività
Se si esegue la migrazione di un’applicazione insieme a tutti i relativi dati, la quantità del tempo di inattività è un fattore importante da considerare.
Nella seguente tabella sono riportate le varie tecniche per importare i dati in un’istanza database RDS per MariaDB:
**Nota**
Amazon RDS non supporta `mariadb-backup` né l’importazione da Amazon S3 per MariaDB.
| Origine | Quantità di dati | Una volta o continua | Tempo di inattività delle applicazioni | Tecnica | Ulteriori informazioni |
| --- | --- | --- | --- | --- | --- |
| Database MariaDB esistente on-premises oppure in Amazon EC2 | Qualsiasi | Continua | Minima | Configurare la replica utilizzando un database MariaDB esistente come origine della replica. Puoi configurare la replica in un'istanza MariaDB utilizzando gli identificatori di transazione globali di MariaDB GTIDs () quando l'istanza esterna è MariaDB versione 10.0.24 o successiva o utilizzando coordinate di log binarie per istanze MariaDB su versioni precedenti alla 10.0.24. GTIDs MariadB è implementato in modo diverso rispetto a GTIDs MySQL, che non è supportato da Amazon RDS. | [Configurazione della replica della posizione del file di log binario con un'istanza di origine esterna.](MySQL.Procedural.Importing.External.ReplMariaDB.md) [Importazione dei dati in un’istanza database Amazon RDS per MariaDB riducendo il tempo di inattività](mariadb-importing-data-reduced-downtime.md) |
| Qualsiasi database esistente | Qualsiasi | Una volta o continua | Minima | Utilizzali AWS Database Migration Service per migrare il database con tempi di inattività minimi e, per molti motori di database DB, continuare la replica continua. | [Cos'è AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) e [Utilizzo di un database compatibile con MySQL come destinazione per AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) nella *Guida per l’utente di AWS Database Migration Service * |
| Istanza database MariaDB esistente | Qualsiasi | Una volta o continua | Minima | Creare una replica di lettura per la replica continua. Promuovere la replica di lettura per la creazione una tantum di una nuova istanza database. | [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md) |
| Database MariaDB esistente | Small | Una volta | Medio | Copiare i dati direttamente nell’istanza database MariaDB tramite un’utilità a riga di comando. | [Importazione di dati da un database MariaDB esterno in un’istanza database Amazon RDS per MariaDB](mariadb-importing-data-external-database.md) |
| Dati non salvati in un database esistente | Medium | Una volta | Medio | Creare file flat e importarli con le istruzioni `LOAD DATA LOCAL INFILE` di MariaDB. | [Importazione di dati da qualsiasi origine in un’istanza database Amazon RDS per MariaDB](mariadb-importing-data-any-source.md) |
**Nota**
Il database di sistema `mysql` contiene le informazioni di autenticazione e autorizzazione necessarie per accedere all'istanza database e ai dati. L’eliminazione, la modifica, la ridenominazione o il troncamento di tabelle, dati o altro contenuto del database `mysql` nell’istanza database può causare errori e rendere inaccessibili dati e istanza database. In tal caso, è possibile ripristinare l'istanza DB da un'istantanea utilizzando il comando. AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) Puoi ripristinare l’istanza database tramite il comando [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html).
# Considerazioni sull’importazione di dati per MariaDB
Il contenuto seguente include informazioni tecniche relative al caricamento dei dati in MariaDB. Il contenuto è rivolto a utenti con una buona conoscenza dell’architettura server MariaDB.
## Registrazione di log binari
L’abilitazione della registrazione di log binari riduce le prestazioni di caricamento dei dati e richiede uno spazio su disco quattro volte superiore rispetto alla registrazione di log disabilitata. Le dimensioni delle transazioni utilizzate per caricare i dati influiscono direttamente sulle prestazioni del sistema e sulle esigenze di spazio su disco – transazioni di grandi dimensioni richiedono un numero maggiore di risorse.
## Dimensioni delle transazioni
Le dimensioni delle transazioni influenzano i seguenti aspetti dei caricamenti di dati MariaDB:
+ Consumo di risorse
+ Utilizzo dello spazio su disco
+ Processo di ripresa
+ Tempo di ripristino
+ Formato di input (file flat o SQL)
Questa sezione descrive in che modo le dimensioni della transazione incidono sul log binario e spiega perché sia conveniente disattivare il log binario durante il caricamento di grandi quantità di dati. Per abilitare e disabilitare la registrazione di log binari, impostare il periodo di conservazione dei backup automatici di Amazon RDS. Un valore pari a zero disattiva il log binario, mentre qualsiasi altro valore lo attiva. Per ulteriori informazioni, consulta [Periodo di conservazione dei backup](USER_WorkingWithAutomatedBackups.BackupRetention.md).
Questa sezione descrive anche l’impatto delle transazioni di grandi dimensioni in InnoDB nonché i motivi per cui è importante contenere le dimensioni delle transazioni.
### Transazioni di piccole dimensioni
Nel caso delle transazioni di piccole dimensioni, i log binari raddoppiano il numero di scritture su disco richieste per il caricamento dei dati. Tale effetto può incidere molto negativamente sulle prestazioni di altre sessioni di database e allungare i tempi richiesti per il caricamento dei dati. La riduzione delle prestazioni dipende in parte dai seguenti fattori:
+ Velocità di caricamento
+ Altre attività del database in esecuzione durante il caricamento
+ Capacità dell’istanza database Amazon RDS
I log binari consumano una quantità di spazio su disco approssimativamente pari alla quantità di dati caricati, fino a quando non ne viene effettuato il backup e i dati non vengono rimossi. Amazon RDS attenua il problema grazie a backup frequenti e alla rimozione dei log binari.
### Transazioni di grandi dimensioni
Per transazioni di grandi dimensioni, la registrazione di log binari triplica il numero di IOPS e l’utilizzo del disco per i seguenti motivi:
+ La cache del log binario archivia temporaneamente i dati delle transazioni su disco.
+ Le dimensioni della cache aumentano in base a quelle della transazione, consumando spazio su disco.
+ Al termine della transazione (commit o rollback), il sistema copia la cache nel log binario.
Il processo crea tre copie dei dati:
+ Dati originali
+ Cache su disco
+ Ultima voce del log binario
Ogni operazione di scrittura comporta un I/O aggiuntivo, con un ulteriore impatto sulle prestazioni.
Per questo motivo, la registrazione di log binari richiede uno spazio su disco tre volte maggiore rispetto al caso in cui sia disabilitata. Ad esempio, il caricamento di 10 GiB di dati come singola transazione crea tre copie:
+ 10 GiB per i dati della tabella
+ 10 GiB per la cache del log binario
+ 10 GiB per il file di log binario
Lo spazio su disco totale richiesto temporaneamente è di 30 GiB.
Considerazioni importanti sullo spazio su disco:
+ Il file di cache persiste fino al termine della sessione o fino alla creazione di un’altra cache da parte di una nuova transazione.
+ Il log binario rimane attivo fino a quando non ne viene eseguito il backup e può contenere 20 GiB di dati (cache e log) per un periodo prolungato.
Se si utilizza `LOAD DATA LOCAL INFILE` per caricare i dati, durante il ripristino viene creata una quarta copia dei dati qualora il database debba essere ripristinato da un backup eseguito prima del caricamento. Durante il ripristino, MariaDB estrae i dati dal log binario e li inserisce in un file flat. MariaDB esegue quindi `LOAD DATA LOCAL INFILE`. In base all’esempio precedente, questo ripristino richiede uno spazio su disco temporaneo totale di 40 GiB o di 10 GiB ciascuno per tabella, cache, log e file locale. Se non sono disponibili almeno 40 GiB di spazio su disco, il ripristino non può essere eseguito.
### Ottimizzazione di carichi di dati di grandi dimensioni
Per carichi di dati di grandi dimensioni, disabilitare la registrazione di log binari per ridurre il sovraccarico e i requisiti di spazio su disco. È possibile disabilitare la registrazione di log binari impostando il periodo di conservazione dei backup su 0. Al termine del caricamento, ripristinare il periodo di conservazione dei backup sul valore diverso da zero appropriato. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md) e [Periodo di conservazione dei backup](USER_ModifyInstance.Settings.md) nella tabella delle impostazioni.
**Nota**
Non è possibile impostare il periodo di conservazione dei backup su zero se l’istanza database è un’origine per le repliche di lettura.
Prima di caricare i dati, è consigliabile creare uno snapshot di database. Per ulteriori informazioni, consulta [Gestione dei backup manuali](USER_ManagingManualBackups.md).
## InnoDB
Le seguenti informazioni sulla registrazione di log di undo e sulle opzioni di ripristino prevedono di mantenere ridotte le dimensioni delle transazioni InnoDB per ottimizzare le prestazioni del database.
### Informazioni sulla registrazione di log di undo InnoDB
L’annullamento (undo) è un meccanismo della registrazione di log che consente il rollback delle transazioni e supporta il controllo della concorrenza multiversione (MVCC).
In MariaDB 10.11 e versioni precedenti, i log di undo vengono archiviati nel tablespace del sistema InnoDB (in genere ibdata1) e mantenuti fino a quando il thread di eliminazione non li rimuove. Di conseguenza, le transazioni di caricamento di dati di grandi dimensioni possono causare un aumento significativo delle dimensioni del tablespace del sistema, con un consumo di spazio su disco che non si può recuperare senza ricreare il database da zero.
Per tutte le versioni di MariaDB, il thread di eliminazione deve attendere la rimozione dei log di undo fino al commit o al rollback della transazione attiva meno recente. Se il database elabora altre transazioni durante il caricamento, anche i relativi log di undo si accumulano e non possono essere rimossi, anche nel caso di commit delle transazioni e in quello in cui nessun’altra transazione richieda log di undo per MVCC. In questa situazione, tutte le transazioni, incluse quelle di sola lettura, rallentano. Il rallentamento si verifica perché tutte le transazioni accedono a tutte le righe modificate da qualsiasi transazione, non solo da quella di caricamento. In effetti, le transazioni devono eseguire la scansione dei log di undo che le transazioni di caricamento di lunga durata hanno impedito di eliminare durante una pulizia dei log di undo stessi. Ciò influisce sulle prestazioni di tutte le operazioni di accesso alle righe modificate.
### Opzioni di ripristino delle transazioni InnoDB
Sebbene InnoDB ottimizzi le operazioni di commit, i rollback delle transazioni di grandi dimensioni sono lenti. Per un ripristino più rapido, esegui un point-in-time ripristino o ripristina un'istantanea del DB. Per ulteriori informazioni, consultare [Point-in-time recupero](USER_PIT.md) e [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
## Formati di importazione dei dati
MariaDB supporta due formati di importazione di dati, ovvero file flat e SQL. Consultare le informazioni su ciascun formato per determinare l’opzione migliore per le proprie esigenze.
### File flat
Per transazioni di piccole dimensioni, caricare file flat con `LOAD DATA LOCAL INFILE`. Rispetto all’utilizzo di SQL, questo formato di importazione dati può comportare i seguenti vantaggi:
+ Minor traffico di rete
+ Riduzione dei costi di trasmissione dei dati
+ Riduzione del sovraccarico di elaborazione del database
+ Elaborazione più rapida
`LOAD DATA LOCAL INFILE` carica l’intero file flat come un’unica transazione. Mantenere ridotte le dimensioni dei singoli file per ottenere i seguenti vantaggi:
+ **Capacità di ripristino**: si può tenere facilmente traccia dei file caricati. In caso di problemi durante il caricamento, si può riprendere l’operazione dal punto in cui era stata interrotta. Potrebbe essere necessario trasmettere nuovamente alcuni file ad Amazon RDS, ma nel caso di file di piccole dimensioni la quantità di dati ritrasmessa è minima.
+ **Caricamento di dati in parallelo**: se si dispone di IOPS e di larghezza di banda della rete sufficienti per caricare un file singolo, il caricamento in parallelo potrebbe consentire di risparmiare tempo.
+ **Controllo della velocità di caricamento**: se il caricamento dei dati ha un impatto negativo su altri processi, è possibile controllarne la velocità aumentando l’intervallo tra i file.
Le transazioni di grandi dimensioni riducono i vantaggi dell’utilizzo di `LOAD DATA LOCAL INFILE` per importare i dati. Se non si riesce a suddividere una grande quantità di dati in file di dimensioni minori, prendere in considerazione l’utilizzo di SQL.
### SQL
Rispetto ai file flat, SQL presenta un grande vantaggio perché consente di mantenere ridotte le dimensioni delle transazioni, sebbene i tempi di caricamento siano significativamente più lunghi. Dopo un errore, inoltre, può essere difficile determinare il punto da cui riprendere perché non è possibile riavviare i file mariadb-dump. In caso di errore durante il caricamento di un file mariadb-dump, quest’ultimo dovrà essere modificato o sostituito prima che sia possibile riprendere il caricamento. In alternativa, dopo aver corretto la causa dell’errore, è possibile tornare al punto temporale precedente al caricamento e inviare nuovamente il file. Per ulteriori informazioni, consulta [Point-in-time recupero](USER_PIT.md).
## Utilizzo degli snapshot di database di Amazon RDS per i checkpoint di database
Se si caricano dati per lunghi periodi, ad esempio ore o giorni, senza registrazione di log binari, utilizzare gli snapshot di database per fornire checkpoint periodici per la sicurezza dei dati. Ogni snapshot di database crea una copia coerente dell’istanza database che funge da punto di ripristino in caso di errori di sistema o di eventi di danneggiamento dei dati. Poiché gli snapshot di database sono veloci, i checkpoint frequenti hanno un impatto minimo sulle prestazioni del caricamento. È possibile eliminare gli snapshot di database precedenti senza influire sulla durabilità o sulle funzionalità di ripristino del database. Per ulteriori informazioni sugli snapshot di database, consulta [Gestione dei backup manuali](USER_ManagingManualBackups.md).
## Riduzione dei tempi di caricamento del database
Di seguito sono indicati alcuni suggerimenti per ridurre i tempi di caricamento:
+ Creare tutti gli indici secondari prima di caricare i dati nei database MariaDB. A differenza di altri sistemi di database, quando si aggiungono o si modificano gli indici secondari MariaDB ricostruisce l’intera tabella. Questo processo consente di creare una nuova tabella con modifiche agli indici, di copiare tutti i dati e di eliminare la tabella originale.
+ Caricare i dati in base all’ordine della chiave primaria. Per le tabelle InnoDB, questa operazione può ridurre i tempi di caricamento del 75%-80% e le dimensioni dei file di dati del 50%.
+ Disabilitare i vincoli di chiave esterna impostando `foreign_key_checks` su `0`. Questa operazione è spesso necessaria per i file flat caricati con `LOAD DATA LOCAL INFILE`. Per qualsiasi carico, la disabilitazione dei controlli di chiave esterna accelera il caricamento dei dati. Dopo aver completato il caricamento, riabilitare i vincoli impostando `foreign_key_checks` su `1` e verificare i dati.
+ Caricare i dati in parallelo a meno che non si stia raggiungendo il limite di risorse. Per consentire il caricamento simultaneo su più segmenti di tabella, se necessario utilizzare tabelle partizionate.
+ Per ridurre il sovraccarico di esecuzione SQL, combinare più istruzioni `INSERT` in singole operazioni `INSERT` con più valori. `mariadb-dump` implementa questa ottimizzazione in modo automatico.
+ Ridurre le operazioni di I/O dei log InnoDB impostando `innodb_flush_log_at_trx_commit` su `0`. Al termine del caricamento, ripristinare il valore di `innodb_flush_log_at_trx_commit` su `1`.
**avvertimento**
Se si imposta `innodb_flush_log_at_trx_commit` su `0`, InnoDB cancella i log ogni secondo anziché a ogni commit. Questa impostazione aumenta le prestazioni, ma può comportare il rischio di perdita delle transazioni durante i guasti del sistema.
+ Se si caricano i dati in un’istanza database che non include repliche di lettura, impostare `sync_binlog` su `0`. Al termine del caricamento, ripristinare il valore di `sync_binlog parameter` su `1`.
+ Caricare i dati in un’istanza database Single-AZ prima di convertire l’istanza database in un’implementazione Multi-AZ. Se l’istanza database utilizza già un’implementazione Multi-AZ, non è consigliabile passare a un’implementazione Single-AZ per il caricamento dei dati. In tal modo si otterrebbero solo miglioramenti marginali.
# Importazione di dati da un database MariaDB esterno in un’istanza database Amazon RDS per MariaDB
È possibile importare i dati da un database MariaDB esistente in un’istanza database RDS per MariaDB. A tale scopo, copia il database con [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) o [mariadb-dump](https://mariadb.com/kb/en/mariadb-dump/) e reindirizzalo direttamente all’istanza database RDS per MariaDB. L’utilità a riga di comando `mysqldump` o `mariadb-dump` viene spesso usata per creare backup e trasferire dati da un server MariaDB a un altro. ed è inclusa nel software client MariaDB.
A partire da MariaDB 11.0.1, è necessario utilizzare `mariadb-dump` anziché `mysqldump`.
Un tipico comando `mysqldump` per spostare dati da un database esterno a un’istanza database Amazon RDS è simile al seguente. Sostituisci i valori con le tue informazioni. Per MariaDB 11.0.1 e versioni successive, sostituisci `mysqldump` con `mariadb-dump`.
```
mysqldump -u local_user \
--databases database_name \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mariadb -u RDS_user \
--port=port_number \
--host=host_name \
-pRDS_password
```
**Importante**
Assicurati di non lasciare spazi tra l'opzione `-p` e la password immessa.
Come best practice per la sicurezza, specifica credenziali diverse dai prompt mostrati nell’esempio.
Assicurati di essere a conoscenza dei seguenti suggerimenti e considerazioni:
+ Escludi gli schemi seguenti dal file di dump:
+ `sys`
+ `performance_schema`
+ `information_schema`
Per impostazione predefinita, l’utilità `mysqldump` e `mariadb-dump` esclude questi schemi.
+ Se devi migrare utenti e privilegi, prendi in considerazione l'utilizzo di uno strumento che genera il linguaggio di controllo dei dati (DCL) per ricrearli, come l'utilità. [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html)
+ L’utente che esegue l'importazione deve avere accesso all'istanza database. Per ulteriori informazioni, consulta [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md).
I parametri utilizzati sono i seguenti:
+ `-u local_user`: specifica un nome utente. La prima volta si utilizza questo parametro, specificare il nome di un account utente nel database MariaDB locale, identificato dal parametro `--databases`.
+ `--databases database_name`: specifica il nome del database nell’istanza database MariaDB locale da importare in Amazon RDS.
+ `--single-transaction` – Verifica che tutti i dati caricati dal database locale siano coerenti a un singolo punto temporale. Nel caso in cui vi siano altri processi che modificano i dati mentre `mysqldump` o `mariadb-dump` li legge, l’utilizzo di questo parametro consente di preservare l’integrità dei dati.
+ `--compress` – Riduce il consumo della larghezza di banda di rete comprimendo i dati dal database locale prima di inviarli ad Amazon RDS.
+ `--order-by-primary`: riduce il tempo di caricamento ordinando i dati di ogni tabella in base alla chiave primaria.
+ `--routines`: parametro utilizzato se nel database da copiare sono presenti routine, ad esempio stored procedure o funzioni. Imposta il parametro su `0` per escludere le routine durante il processo di importazione. Successivamente, ricrea manualmente le routine nel database Amazon RDS.
+ `--triggers`: parametro utilizzato se nel database da copiare sono presenti trigger. Imposta il parametro su `0` per escludere i trigger durante il processo di importazione. Successivamente, ricrea manualmente i trigger nel database Amazon RDS.
+ `--events`: parametro utilizzato se nel database da copiare sono presenti eventi. Imposta il parametro su `0` per escludere gli eventi durante il processo di importazione. Successivamente, ricrea manualmente gli eventi nel database Amazon RDS.
+ `-plocal_password` – Specifica una password. La prima volta che si utilizza questo parametro, specificare la password per l’account utente identificato dal primo parametro `-u`.
+ `-u RDS_user`: specifica un nome utente. La seconda volta che si utilizza questo parametro, specificare il nome di un account utente nel database predefinito per l’istanza database MariaDB identificata dal parametro `--host`.
+ `--port port_number`: specifica la porta per l’istanza database MariaDB. Il valore predefinito è 3306, che può essere modificato al momento della creazione dell’istanza database.
+ `--host host_name` – Specifica il nome del sistema dei nomi di dominio (DNS) dall'endpoint dell'istanza database Amazon RDS, ad esempio `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Il valore dell’endpoint è disponibile nei dettagli dell’istanza database nella console Amazon RDS.
+ `-pRDS_password` – Specifica una password. La seconda volta che usi questo parametro, devi specificare la password per l'account utente identificato dal secondo parametro `-u`.
Eventuali procedure, trigger, funzioni o eventi devono essere creati manualmente nel database Amazon RDS. Se nel database da copiare sono presenti questi tipi di oggetti, è necessario escluderli quando si esegue `mysqldump` o `mariadb-dump`. A tale scopo, includi i seguenti parametri con il comando `mysqldump` o `mariadb-dump`:
+ `--routines=0`
+ `--triggers=0`
+ `--events=0`
**Esempio**
Di seguito il database di esempio `world` viene copiato nell’host locale in un’istanza database RDS per MariaDB. Sostituisci i valori con le tue informazioni.
Per Linux, macOS o Unix:
```
sudo mariadb-dump -u local_user \
--databases world \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mariadb -u rds_user \
--port=3306 \
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com \
-pRDS_password
```
Per Windows:
Apri un prompt dei comandi facendo clic con il pulsante destro del mouse su **Prompt dei comandi** del menu dei programmi di Windows e selezionando **Esegui come amministratore** ed esegui il comando seguente. Sostituisci i valori con le tue informazioni.
```
mariadb-dump -u local_user ^
--databases world ^
--single-transaction ^
--compress ^
--order-by-primary ^
--routines=0 ^
--triggers=0 ^
--events=0 ^
-plocal_password | mariadb -u RDS_user ^
--port=3306 ^
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com ^
-pRDS_password
```
**Nota**
Come best practice per la sicurezza, specifica credenziali diverse dai prompt mostrati nell’esempio.
# Importazione dei dati in un’istanza database Amazon RDS per MariaDB riducendo il tempo di inattività
In alcuni casi, potrebbe essere necessario importare dati da un database MariaDB esterno che supporti un’applicazione attiva in un’istanza database RDS per MariaDB. Usa la seguente procedura per ridurre l'impatto sulla disponibilità delle applicazioni. Questa procedura può risultare utile anche quando utilizzi un database di dimensioni particolarmente elevate. Utilizzando questa procedura, è possibile ridurre i costi di importazione riducendo la quantità di dati trasmessi attraverso la rete a AWS.
Con questa procedura trasferisci una copia dei dati del database in un'istanza Amazon EC2 e li importi in un nuovo database Amazon RDS. Utilizza quindi la replica per portare il database Amazon RDS up-to-date con la tua istanza esterna attiva, prima di reindirizzare l'applicazione al database Amazon RDS. Se l'istanza esterna è MariaDB 10.0.24 o versione successiva e l'istanza di destinazione è RDS for MariaDB, configura la replica di MariaDB in base agli identificatori di transazione globali (). GTIDs In alternativa, è possibile configurare la replica in base alle coordinate del log binario. Si consiglia la replica basata su GTID se supportata dal database esterno perché è un metodo più affidabile. Per ulteriori informazioni, consulta [ID globali di transazione](http://mariadb.com/kb/en/mariadb/global-transaction-id/) nella documentazione di MariaDB.
Il diagramma seguente mostra l’importazione di un database MariaDB esterno in un database MariaDB in Amazon RDS.
![\[Flusso di lavoro che mostra l’importazione di un database MariaDB esterno in un database MariaDB in Amazon RDS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_1.png)
## Attività 1: creazione di una copia del database esistente
Il primo passaggio da eseguire nella migrazione di grandi quantità di dati in un database RDS per MariaDB riducendo al minimo il tempo di inattività consiste nella creazione di una copia dei dati di origine.
Il diagramma seguente mostra la creazione di un backup del database MariaDB.
![\[Flusso di lavoro che mostra la creazione di un backup del database MariaDB.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_2.png)
Per creare un backup di database in formato SQL o con testo delimitato, è possibile utilizzare l’utilità `mysqldump` o `mariadb-dump`. In MariaDB 10.5, il client è denominato [mariadb-dump](https://mariadb.com/kb/en/mariadb-dump/). A partire da MariaDB 11.0.1, è necessario utilizzare `mariadb-dump` anziché `mysqldump`. Si consiglia di eseguire un test con ciascun formato, fuori dall’ambiente di produzione, per capire quale metodo consenta di ridurre maggiormente il tempo di esecuzione di `mysqldump` o `mariadb-dump`.
Si consiglia anche di valutare le prestazioni di `mysqldump` o `mariadb-dump` e i vantaggi offerti dal caricamento nel formato con testo delimitato. Un backup eseguito con testo delimitato crea un file di testo separato da tabulazioni per ciascuna tabella eliminata. Per ridurre il tempo di importazione del database, puoi caricare questi file in parallelo con il comando `LOAD DATA LOCAL INFILE`. Per ulteriori informazioni, consulta [Fase 5: Caricamento dei dati](mariadb-importing-data-any-source.md#mariadb-importing-data-any-source-load-data) nella procedura Importazione di dati da qualsiasi origine.
Prima di iniziare l’operazione di backup, imposta le opzioni di replica nel database MariaDB da copiare in Amazon RDS. Le opzioni di replica includono l’attivazione del log binario e l’impostazione di un ID server univoco. L'impostazione di tali opzioni porta il server ad avviare la registrazione delle transazioni del database e lo prepara per diventare l'istanza di replica di origine in una fase successiva del processo.
Assicurati di essere a conoscenza dei seguenti suggerimenti e considerazioni:
+ utilizza l’opzione `--single-transaction` con `mysqldump` o `mariadb-dump` perché esegue il dump di uno stato coerente del database. Per garantire un file di dump valido, non eseguire istruzioni DDL (Data Definition Language) durante l’esecuzione di `mysqldump` o `mariadb-dump`. È possibile pianificare una finestra di manutenzione per queste operazioni.
+ Escludi gli schemi seguenti dal file di dump:
+ `sys`
+ `performance_schema`
+ `information_schema`
Per impostazione predefinita, le utilità `mysqldump` e `mariadb-dump` escludono questi schemi.
+ Se devi migrare utenti e privilegi, prendi in considerazione l'utilizzo di uno strumento che genera il linguaggio di controllo dei dati (DCL) per ricrearli, come l'utilità. [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html)
### Per impostare le opzioni di autenticazione
1. Modificare il file `my.cnf`. Il file si trova in genere in `/etc`.
```
sudo vi /etc/my.cnf
```
Aggiungere le opzioni `log_bin` e `server_id` alla sezione `[mysqld]`. L'opzione `log_bin` fornisce un identificatore di nome file per i file di log binari. L'opzione `server_id` fornisce un identificatore univoco per il server in relazioni master-replica.
L’esempio seguente mostra la sezione `[mariadb]` aggiornata di un file `my.cnf`:
```
[mariadb]
log-bin
server-id=1
log-basename=master1
binlog-format=mixed
```
Per ulteriori informazioni, consulta [Setting the Replication Source Configuration](https://mariadb.com/docs/server/ha-and-performance/standard-replication/setting-up-replication) nella documentazione MariaDB.
1. Per la replica con un cluster di database Multi-AZ, abilita `gtid_strict_mode`. Per ulteriori informazioni, consulta [gtid\$1strict\$1mode](https://mariadb.com/docs/server/ha-and-performance/standard-replication/gtid#gtid_strict_mode) nella documentazione MariaDB.
L’abilitazione di `gtid_strict_mode` non è richiesta per la replica con un’istanza database.
1. Riavvia il servizio `mariadb`.
```
sudo service mariadb restart
```
### Per creare una copia di backup del database esistente
1. Crea un backup dei dati con l’utilità `mysqldump` o `mariadb-dump`, specificando il formato SQL o con testo delimitato.
Per migliorare le prestazioni e garantire l’integrità dei dati, utilizza le opzioni `--order-by-primary` e `--single-transaction` per `mysqldump` e `mariadb-dump`.
Per non includere il database di sistema MySQL nel backup, non utilizzare l’opzione `--all-databases` con `mysqldump` o `mariadb-dump`. Per ulteriori informazioni, consulta [Creating a Data Snapshot Using mysqldump](https://dev.mysql.com/doc/mysql-replication-excerpt/8.0/en/replication-howto-mysqldump.html) nella documentazione MySQL.
Se necessario, utilizza `chmod` per avere la certezza che sia possibile scrivere nella directory in cui viene creato il file di backup.
**Importante**
In Windows, eseguire la finestra di comando come amministratore.
+ Per produrre un output SQL, utilizzare il comando seguente. Per MariaDB 10.11 e versioni precedenti, sostituisci `mariadb-dump` con `mysqldump`.
Per Linux, macOS o Unix:
```
sudo mariadb-dump \
--databases database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-r backup.sql \
-u local_user \
-ppassword
```
**Nota**
Come best practice per la sicurezza, specifica credenziali diverse dai prompt mostrati nell’esempio.
Per Windows:
```
mariadb-dump ^
--databases database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-r backup.sql ^
-u local_user ^
-ppassword
```
**Nota**
Come best practice per la sicurezza, specifica credenziali diverse dai prompt mostrati nell’esempio.
+ Per produrre un output in testo delimitato, utilizzare il comando seguente. Per MariaDB 11.01 e versioni successive, sostituisci `mysqldump` con `mariadb-dump`.
Per Linux, macOS o Unix:
```
sudo mysqldump \
--tab=target_directory \
--fields-terminated-by ',' \
--fields-enclosed-by '"' \
--lines-terminated-by 0x0d0a \
database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-ppassword
```
Per Windows:
```
mysqldump ^
--tab=target_directory ^
--fields-terminated-by "," ^
--fields-enclosed-by """ ^
--lines-terminated-by 0x0d0a ^
database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-ppassword
```
**Nota**
Come best practice per la sicurezza, specifica credenziali diverse dai prompt mostrati nell’esempio.
Eventuali procedure, trigger, funzioni o eventi devono essere creati manualmente nel database Amazon RDS. Se nel database da copiare sono presenti questi tipi di oggetti, è necessario escluderli quando si esegue `mysqldump` o `mariadb-dump`. A tale scopo, includi gli argomenti seguenti con il comando `mysqldump` o `mariadb-dump`:
`--routines=0`
`--triggers=0`
`--events=0`
Quando si esegue `mysqldump` e si specifica il formato con testo delimitato, viene restituito un comando `CHANGE MASTER TO`. Tale commento contiene il nome e la posizione del file log principale. Se l’istanza esterna è diversa da MariaDB versione 10.0.23 o precedente, annota i valori per `MASTER_LOG_FILE` e `MASTER_LOG_POS`. Questi valori sono necessari durante l'impostazione della replica.
Per le versioni di MariaDB, viene restituito l’output seguente.
```
-- Position to start replication or point-in-time recovery from
--
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin-changelog.000031', MASTER_LOG_POS=107;
```
1. Se l’istanza esterna è MariaDB versione 10.0.24 o successiva, utilizza la replica basata su GTID. Esegui `SHOW MASTER STATUS` nell’istanza MariaDB esterna per ottenere il nome e la posizione del file di log binario e convertirli in un GTID utilizzando `BINLOG_GTID_POS` nell’istanza MariaDB esterna.
```
SELECT BINLOG_GTID_POS('binary_log_file_name', binary_log_file_position);
```
Annota il GTID restituito perché sarà necessario per configurare la replica.
1. Comprimi i dati copiati per ridurre la quantità di risorse di rete necessarie per copiare i dati nell'istanza database Amazon RDS. Annota la dimensione del file di backup. Questa informazione è necessaria per determinare le dimensioni dell'istanza Amazon EC2 da creare. Al termine, comprimere il file di backup con GZIP o un'altra utility simile.
+ Per comprimere un output SQL, utilizza il comando seguente:
```
gzip backup.sql
```
+ Per comprimere un output in testo delimitato, utilizza il comando seguente:
```
tar -zcvf backup.tar.gz target_directory
```
## Attività 2: creazione di un’istanza Amazon EC2 e copia del database compresso
La copia del file di backup del database compresso in un'istanza Amazon EC2 richiede una quantità di risorse di rete inferiore rispetto alla copia diretta di dati non compressi da un'istanza database a un'altra. Quando i dati sono presenti in Amazon EC2, puoi copiarli direttamente nell’istanza database MariaDB. Per risparmiare sul costo delle risorse di rete, l'istanza Amazon EC2 deve essere la Regione AWS stessa dell'istanza Amazon RDS DB. La presenza dell'istanza Amazon EC2 nello Regione AWS stesso database Amazon RDS riduce anche la latenza di rete durante l'importazione.
Il seguente diagramma mostra la copia del backup del database in un’istanza Amazon EC2.
![\[Flusso di lavoro che mostra la copia del backup del database in un’istanza Amazon EC2.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_3.png)
### Per creare un'istanza Amazon EC2 e copiare i dati
1. Nel luogo in Regione AWS cui prevedi di creare il database Amazon RDS, crea un cloud privato virtuale (VPC), un gruppo di sicurezza VPC e una sottorete VPC. Verificare che le regole in entrata del gruppo di sicurezza VPC consentano agli indirizzi IP necessari per l'applicazione di connettersi ad AWS. È possibile specificare un intervallo di indirizzi IP, ad esempio `203.0.113.0/24`, oppure un altro gruppo di sicurezza VPC. Puoi utilizzare la [console Amazon VPC](https://console.aws.amazon.com/vpc) per creare e gestire VPCs sottoreti e gruppi di sicurezza. Per ulteriori informazioni, consulta [Nozioni di base su Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html#getting-started) nella *Guida per l’utente di Amazon Virtual Private Cloud*.
1. Apri la [console Amazon EC2](https://console.aws.amazon.com/ec2) e scegli di contenere sia Regione AWS l'istanza Amazon EC2 che il database Amazon RDS. Avviare un'istanza di Amazon EC2 utilizzando il VPC, la sottorete e il gruppo di sicurezza creati nella fase 1. Assicurarsi di selezionare un tipo di istanza con spazio di storage sufficiente per il file di backup del database decompresso. Per informazioni sulle istanze Amazon EC2, consulta [Nozioni di base su Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
1. Per connetterti al database Amazon RDS dall'istanza Amazon EC2, modifica il gruppo di sicurezza VPC. Aggiungere una regola in entrata specificando l'indirizzo IP privato e l'istanza EC2. L'indirizzo IP privato è indicato nella scheda **Details (Dettagli)** del riquadro **Instance (Istanza)** della finestra della console EC2. Per modificare il gruppo di sicurezza VPC e aggiungere una regola in entrata, selezionare **Security Groups (Gruppi di sicurezza)** nel riquadro di navigazione della console di EC2, selezionare il gruppo di sicurezza e aggiungere una regola in entrata per MySQL/Aurora specificando l'indirizzo IP privato dell'istanza EC2. Per ulteriori informazioni sull’aggiunta di una regola in entrata a un gruppo di sicurezza VPC, consulta [Regole del gruppo di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html) nella *Guida per l’utente di Amazon Virtual Private Cloud*.
1. Copiare il file compresso con il backup del database dal sistema locale all'istanza Amazon EC2. Se necessario, utilizza `chmod` per ottenere l’autorizzazione di scrittura per la directory di destinazione dell’istanza Amazon EC2. Il file può essere copiato con `scp` oppure con un client Secure Shell (SSH). Di seguito è riportato un comando `scp` di esempio:
```
scp -r -i key pair.pem backup.sql.gz ec2-user@EC2 DNS:/target_directory/backup.sql.gz
```
**Importante**
Quando si copiano dati sensibili, utilizzare un protocollo di trasferimento di rete sicuro.
1. Connettiti all’istanza Amazon EC2 e installa gli ultimi aggiornamenti e gli strumenti del client MariaDB con i comandi seguenti:
```
sudo yum update -y
sudo yum install mariadb1011-client-utils -y
```
Per ulteriori informazioni, consulta [Connessione all’istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux) per le istanze Linux nella *Guida per l’utente di Amazon Elastic Compute Cloud* e [MariaDB Connectors](https://mariadb.com/docs/connectors) nella documentazione di MariaDB.
1. Durante la connessione all'istanza Amazon EC2 decomprimere il file di backup del database. I comandi seguenti sono esempi.
+ Per decomprimere l'output SQL, utilizzare il comando seguente:
```
gzip backup.sql.gz -d
```
+ Per decomprimere un output in testo delimitato, utilizzare il comando seguente:
```
tar xzvf backup.tar.gz
```
## Attività 3: creazione di un database MariaDB e importazione dei dati dall’istanza Amazon EC2
Creando un'istanza DB RDS per MariaDB nella stessa istanza Amazon EC2, puoi importare Regione AWS il file di backup del database da Amazon EC2 più velocemente che su Internet.
Il seguente diagramma mostra l’importazione del backup da un’istanza Amazon EC2 in un database MariaDB.
![\[Flusso di lavoro che mostra l’importazione del backup dall’istanza EC2 nel database MariaDB.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_4.png)
### Per creare un database MariaDB e importare i dati
1. Determina la classe di istanza database e la quantità di spazio di archiviazione necessaria per supportare il carico di lavoro previsto per il database Amazon RDS. Come parte di questo processo, è necessario valutare la quantità di spazio richiesta e la capacità di elaborazione per le procedure di caricamento dati. Valuta anche gli elementi necessari per gestire il carico di lavoro di produzione. È possibile produrre una stima sulla base delle dimensioni e delle risorse del database MariaDB di origine. Per ulteriori informazioni, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
1. Crea un'istanza DB Regione AWS che contiene la tua istanza Amazon EC2. Segui le istruzioni in [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md) e utilizza le linee guida seguenti:
+ Specifica una versione del motore di database compatibile con l’istanza database di origine.
+ Specifica lo stesso cloud privato virtuale (VPC) e lo stesso gruppo di sicurezza VPC dell'istanza Amazon EC2. Questo approccio garantisce che l’istanza Amazon EC2 e l’istanza Amazon RDS siano visibili una all’altra in rete. Assicurati che l'istanza database sia accessibile pubblicamente. Per impostare la replica con il database di origine, come descritto in una sezione seguente, l’istanza database deve essere accessibile pubblicamente.
+ Non configurare più zone di disponibilità, retention dei backup o repliche di lettura fino a quando non è stato importato il backup del database. Al termine dell'importazione, puoi configurare le varie zone di disponibilità e la conservazione dei backup per l'istanza di produzione.
1. Esamina le opzioni di configurazione predefinite per il database Amazon RDS. Se il gruppo di parametri predefinito per il database non include le opzioni di configurazione desiderate, cercane uno che le contenga oppure crea un gruppo di parametri nuovo. Per ulteriori informazioni sulla creazione di un gruppo di parametri, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
1. Connettiti al nuovo database Amazon RDS come utente master. Crea gli utenti necessari per supportare gli amministratori, le applicazioni e i servizi che devono accedere all’istanza database. Il nome host per il database Amazon RDS corrisponde al valore di **Endpoint** per l’istanza database senza il numero di porta, ad esempio `mysampledb.123456789012.us-west-2.rds.amazonaws.com`. Il valore dell’endpoint è disponibile nei dettagli del database nella console Amazon RDS.
1. Esegui la connessione all'istanza Amazon EC2. Per ulteriori informazioni, consulta [Connessione all’istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux) per le istanze Linux nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
1. Connettiti al database Amazon RDS come host remoto dall'istanza Amazon EC2 usando il comando `mysql`. Il comando seguente è un esempio:
```
mysql -h host_name -P 3306 -u db_master_user -p
```
*host\$1name*È l'endpoint del database Amazon RDS.
1. Al prompt `mysql`, esegui il comando `source` e passa il nome del file di dump del database. Il comando carica i dati nell’istanza database Amazon RDS.
+ Per il formato SQL, utilizza il comando seguente:
```
MariaDB [(none)]> source backup.sql;
```
+ Per il formato con testo delimitato, crea innanzitutto il database se non utilizzi il database predefinito creato al momento dell’impostazione del database Amazon RDS,
```
MariaDB [(none)]> create database database_name;
MariaDB [(none)]> use database_name;
```
quindi crea le tabelle
```
MariaDB [(none)]> source table1.sql
MariaDB [(none)]> source table2.sql
etc...
```
e infine importa i dati.
```
MariaDB [(none)]> LOAD DATA LOCAL INFILE 'table1.txt' INTO TABLE table1 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
MariaDB [(none)]> LOAD DATA LOCAL INFILE 'table2.txt' INTO TABLE table2 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
etc...
```
Per migliorare le prestazioni, puoi eseguire queste operazioni in parallelo da più connessioni, in modo che tutte le tabelle vengano create e caricate contemporaneamente.
**Nota**
Se nel dump iniziale della tabella sono state utilizzate opzioni di formattazione dati con `mysqldump` o `mariadb-dump`, è necessario utilizzare le stesse opzioni con `LOAD DATA LOCAL INFILE` per assicurare una corretta interpretazione del contenuto del file dati.
1. Esegui una semplice query `SELECT` in una o due tabelle del database importato, per verificare che l’operazione sia stata eseguita correttamente.
Se non hai più bisogno dell'istanza Amazon EC2 utilizzata in questa procedura, interrompi l'istanza EC2 per ridurre l'utilizzo delle risorse. AWS Per terminare un’istanza EC2, consulta [Terminare un’istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#terminating-instances-console) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
## Attività 4: replica dei dati dal database esterno al nuovo database Amazon RDS
È probabile che il database di origine sia stato aggiornato durante la copia e il trasferimento dei dati nel database MariaDB. Puoi utilizzare la replica per portare il database copiato con il database up-to-date di origine.
![\[Flusso di lavoro che mostra la replica dei dati dal database MariaDB esterno al database in Amazon RDS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_5.png)
Le autorizzazioni necessarie per avviare la replica in un database Amazon RDS sono limitate e non disponibili per l’utente master di Amazon RDS. Per questo motivo, utilizza la stored procedure Amazon RDS appropriata:
+ [mysql.rds\$1set\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) per configurare la replica e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) per avviarla
### Per avviare la replica
Nell’Attività 1, [quando si impostano le opzioni di replica](#mariadb-importing-data-reduced-downtime-set-replication-options) si attiva la registrazione di log binari e si imposta un ID server univoco per il database di origine. Ora è possibile impostare il database Amazon RDS come replica, utilizzando il database attivo come istanza di replica di origine.
1. Nella console Amazon RDS aggiungi l’indirizzo IP del server che ospita il database di origine al gruppo di sicurezza VPC per il database Amazon RDS. Per ulteriori informazioni sui gruppi di sicurezza VPC, consulta [Configurazione delle regole per i gruppi di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html) nella *Guida per l’utente di Amazon Virtual Private Cloud*.
Potrebbe essere necessario configurare anche la rete locale per consentire le connessioni dall’indirizzo IP del database Amazon RDS, in modo da comunicare con l’istanza di origine. Per individuare l’indirizzo IP del database Amazon RDS, utilizza il comando `host`:
```
host host_name
```
*host\$1name*È il nome DNS dell'endpoint del database Amazon RDS, ad esempio. `myinstance.123456789012.us-east-1.rds.amazonaws.com` Il valore dell’endpoint è disponibile nei dettagli dell’istanza database nella console Amazon RDS.
1. Utilizzando il client scelto, eseguire la connessione all'istanza di origine e creare un utente da utilizzare per la replica. Questo account viene utilizzato unicamente per la replica e deve essere limitato al dominio personale per aumentare la sicurezza. Il comando seguente è un esempio:
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**Nota**
Specifica credenziali diverse dai prompt mostrati qui come best practice per la sicurezza.
1. Per l'istanza di origine, concedere i privilegi `REPLICATION CLIENT` e `REPLICATION SLAVE` all'utente di 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. Se per creare il file di backup è stato utilizzato il formato SQL e l’istanza esterna non è MariaDB 10.0.24 o versione successiva, esegui questo comando seguente per controllare il contenuto del file:
```
cat backup.sql
```
Il file include un commento `CHANGE MASTER TO` che contiene il nome e la posizione del file di log principale. Il commento si trova nel file di backup, se è stata utilizzata l'opzione `--master-data` con `mysqldump`. Prendere nota dei valori per `MASTER_LOG_FILE` e `MASTER_LOG_POS`.
```
--
-- Position to start replication or point-in-time recovery from
--
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin-changelog.000031', MASTER_LOG_POS=107;
```
Se per creare il file di backup è stato utilizzato il formato con testo delimitato e l’istanza esterna non è MariaDB 10.0.24 o versione successiva, si dovrebbe già disporre delle coordinate del log binario dalla fase 1 dell’Attività 1 [quando è stata creata una copia di backup del database esistente](#mariadb-importing-data-reduced-downtime-create-backup).
Se l’istanza esterna è MariaDB 10.0.24 o versione successiva, si dovrebbe già disporre del GTID da cui avviare la replica dalla fase 2 dell’Attività 1 [quando è stata creata una copia di backup del database esistente](#mariadb-importing-data-reduced-downtime-create-backup).
1. Definisci il database Amazon RDS come replica. Se l’istanza esterna non è MariaDB 10.0.24 o versione successiva, connettiti al database Amazon RDS come utente master e identifica il database di origine come istanza di replica di origine utilizzando la stored procedure [mysql.rds\$1set\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_set_external_master).
Se si dispone di un file di backup in formato SQL, utilizza il nome e la posizione del file di log principale, recuperati nella fase 4. Se invece è stato utilizzato il formato con testo delimitato, usa il nome e la posizione determinati al momento di creare i file di backup. Il comando seguente è un esempio:
```
CALL mysql.rds_set_external_master ('myserver.mydomain.com', 3306,
'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**Nota**
Specifica credenziali diverse dai prompt mostrati qui come best practice per la sicurezza.
Se l’istanza esterna è MariaDB 10.0.24 o versione successiva, connettiti al database Amazon RDS come utente master e identifica il database di origine come istanza di replica di origine utilizzando la stored procedure [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md). Utilizza il GTID determinato nella fase 2 dell’Attività 1 [quando è stata creata una copia di backup del database esistente](#mariadb-importing-data-reduced-downtime-create-backup). Il comando seguente è un esempio:
```
CALL mysql.rds_set_external_master_gtid ('source_server_ip_address', 3306, 'ReplicationUser', 'password', 'GTID', 1);
```
`source_server_ip_address` è l' indirizzo IP dell'istanza di replica di origine. Al momento, gli indirizzi DNS privati di EC2 non sono supportati.
**Nota**
Specifica credenziali diverse dai prompt mostrati qui come best practice per la sicurezza.
1. Nel database Amazon RDS, per avviare la replica esegui questo comando che utilizza la stored procedure [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication):
```
CALL mysql.rds_start_replication;
```
1. Nel database Amazon RDS, per determinare quando la replica è up-to-date con l'istanza di replica di origine, esegui il comando [SHOW REPLICA](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) STATUS. I risultati del comando `SHOW REPLICA STATUS` includono il campo `Seconds_Behind_Master`. Quando il `Seconds_Behind_Master` campo restituisce 0, la replica si trova up-to-date con l'istanza di replica di origine.
Per un’istanza database MariaDB 10.5, 10.6, 10.11, 11.4 o 11.8, esegui la stored procedure [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md) anziché il comando MySQL.
1. Una volta installato il database Amazon RDS up-to-date, attiva i backup automatici in modo da poter ripristinare il database, se necessario. È possibile attivare o modificare i backup automatici per il database Amazon RDS tramite la [console Amazon RDS](https://console.aws.amazon.com/rds/). Per ulteriori informazioni, consulta [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md).
## Attività 5: reindirizzamento di un’applicazione attiva all’istanza Amazon RDS
Dopo che il database MariaDB up-to-date è con l'istanza di replica di origine, ora puoi aggiornare la tua applicazione live per utilizzare l'istanza Amazon RDS.
![\[Flusso di lavoro che mostra l’arresto della replica e l’indirizzamento dell’applicazione attiva al database in Amazon RDS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_6.png)
### Per reindirizzare l’applicazione attiva al database MariaDB e arrestare la replica
1. Per aggiungere il gruppo di sicurezza VPC per il database Amazon RDS, aggiungi l’indirizzo IP del server che ospita l’applicazione. Per ulteriori informazioni sui gruppi di sicurezza VPC, consulta [Configurazione delle regole per i gruppi di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html) nella *Guida per l’utente di Amazon Virtual Private Cloud*.
1. Verifica che il `Seconds_Behind_Master` campo nei risultati del comando [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) sia 0, il che indica che la replica è up-to-date con l'istanza di replica di origine.
```
SHOW REPLICA STATUS;
```
Per un’istanza database MariaDB 10.5, 10.6, 10.11, 11.4 o 11.8, esegui la procedura [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md) anziché il comando MySQL.
1. Chiudere tutte le connessioni all'origine quando le loro transazioni sono complete.
1. Aggiorna l'applicazione per usare il database Amazon RDS. In genere, l'aggiornamento prevede la modifica delle impostazioni di connessione per identificare il nome host e la porta del database Amazon RDS, l'account utente e la password per eseguire la connessione e il database da utilizzare.
1. Effettua la connessione all'istanza database.
1. Arresta la replica per l’istanza Amazon RDS eseguendo questo comando che utilizza la stored procedure [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication):
```
CALL mysql.rds_stop_replication;
```
1. Esegui la stored procedure [mysql.rds\$1reset\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master) nel database Amazon RDS per reimpostare la configurazione della replica in modo che l’istanza non venga più identificata come replica.
```
CALL mysql.rds_reset_external_master;
```
1. Attivare le caratteristiche aggiuntive di Amazon RDS, quali il supporto Multi-AZ e le repliche di lettura. Per ulteriori informazioni, consultare [Configurazione e gestione di un’implementazione Multi-AZ per Amazon RDS](Concepts.MultiAZ.md) e [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
# Importazione di dati da qualsiasi origine in un’istanza database Amazon RDS per MariaDB
Amazon RDS consente di migrare dati di MariaDB esistenti da qualsiasi origine a un’istanza database RDS per MariaDB. È possibile trasferire dati da database on-premises, altri provider cloud o istanze database RDS per MariaDB esistenti all’istanza database RDS per MariaDB di destinazione. La funzionalità permette di consolidare i database, implementare soluzioni di disaster recovery o eseguire il passaggio da database autogestiti. Gli scenari più comuni includono il passaggio da server MariaDB in hosting autonomo a istanze database Amazon RDS completamente gestite, il consolidamento di più database MariaDB in una singola istanza database o la creazione di ambienti di test con dati di produzione. Le seguenti sezioni forniscono step-by-step istruzioni per importare i dati MariadB utilizzando metodi `mariadb-dump` come file di backup o replica.
## Fase 1: Creazione di file flat contenenti i dati da caricare
Per salvare i dati da caricare, utilizza un formato comune, come ad esempio valori separati da virgola (CSV). Ciascuna tabella deve possedere il proprio file. Non è possibile combinare i dati di più tabelle nello stesso file. Devi fornire a ciascun file lo stesso nome della tabella corrispondente. Il file può avere qualsiasi estensione. Ad esempio, se il nome della tabella è `sales`, il nome del file potrebbe essere `sales.csv` o `sales.txt`.
Se possibile, ordina i dati in base alla chiave primaria della tabella da caricare. In questo modo i tempi di caricamento risultano significativamente più rapidi e si riduce il consumo di spazio su disco.
La velocità e l'efficienza di questa procedura dipende dalla capacità di mantenere contenute le dimensioni dei file. Se le dimensioni di un qualsiasi file (non compresso) superano 1 GiB, suddividilo in più file da caricare separatamente.
Nei sistemi di tipo Unix (incluso Linux), puoi utilizzare il comando `split`. Ad esempio, il comando seguente divide il file `sales.csv` in vari file con dimensioni inferiori a 1 GiB. Le divisioni vengono effettuate solo sulle interruzioni di riga (-C 1024m). I nomi dei nuovi file includono suffissi numerici crescenti. Il comando seguente genera file con nomi come `sales.part_00` e `sales.part_01`.
```
split -C 1024m -d sales.csv sales.part_
```
Utility simili sono disponibili anche per altri sistemi operativi.
È possibile archiviare i file flat ovunque. Tuttavia, quando si caricano i dati nella [Fase 5](#mariadb-importing-data-any-source-load-data), è necessario invocare la shell `mysql` dalla stessa posizione in cui si trovano i file o utilizzare il percorso assoluto dei file quando si esegue `LOAD DATA LOCAL INFILE`.
## Fase 2: arrestare le applicazioni che accedono all’istanza database di destinazione
Prima di avviare il caricamento di grandi quantità di dati, arresta le attività di tutte le applicazioni che accedono all’istanza database in cui intendi eseguire il caricamento. Questa operazione è particolarmente consigliata se le altre sessioni modificano le tabelle caricate o quelle di riferimento. In questo modo, puoi ridurre i rischi di violazione dei vincoli e ottimizzare le prestazioni durante il caricamento. Inoltre, diventa possibile ripristinare l'istanza database al punto immediatamente precedente il caricamento, senza perdere le modifiche apportate dai processi che non sono coinvolti nell'operazione di caricamento.
Ovviamente, ci sono casi in cui l'esecuzione di questa operazione risulta impossibile o poco pratica. Se puoi evitare che alcune applicazioni accedano all'istanza database prima del caricamento, prendi tutte le misure necessarie per assicurare la disponibilità e l'integrità dei dati. Tali misure dipendono in larga parte dal tipo specifico di utilizzo e dai requisiti del sito.
## Fase 3: Creazione di una snapshot DB
Se desideri caricare i dati in una nuova istanza database priva di dati, puoi ignorare questa parte. In caso contrario, si consiglia di creare snapshot di database dell’istanza database di destinazione Amazon RDS immediatamente prima e dopo il caricamento dei dati. Gli snapshot di database di Amazon RDS sono backup completi dell’istanza database che consentono di ripristinarla in uno stato noto. Quando si avvia uno snapshot DB, I/O le operazioni sull'istanza DB vengono momentaneamente sospese durante il backup del database.
Creando una snapshot DB immediatamente prima di caricare i dati ti consente di ripristinare il database allo stato precedente il caricamento, se fosse necessario. Una snapshot DB ottenuta immediatamente dopo il caricamento consente di non dover caricare nuovamente i dati in caso di problemi. È inoltre possibile utilizzare gli snapshot di database dopo il caricamento per importare dati in nuove istanze database.
L'esempio seguente esegue il AWS CLI [create-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-snapshot.html)comando per creare uno snapshot DB dell'`AcmeRDS`istanza e assegnare allo snapshot DB l'identificatore. `"preload"`
Per Linux, macOS o Unix:
```
aws rds create-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
Per Windows:
```
aws rds create-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
Puoi utilizzare anche la funzione di ripristino da snapshot DB per creare istanze database di prova in cui eseguire test o annullare modifiche apportate durante il caricamento.
Ricorda che il ripristino di un database da una snapshot DB crea una nuova istanza database che, come tutte le istanze database, possiede un identificatore e un endpoint univoci. Per ripristinare l'istanza database senza modificare l'endpoint, devi innanzitutto eliminare l'istanza database, in modo da poter riutilizzare l'endpoint.
Ad esempio, per creare un'istanza database in cui eseguire test di vario tipo, devi assegnare all'istanza database il proprio identificatore. Nell’esempio, l'identificatore è `AcmeRDS-2`". L'esempio si connette all'istanza database utilizzando l'endpoint associato a `AcmeRDS-2`. [Per ulteriori informazioni, vedere -db-snapshot. restore-db-instance-from](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
Per Linux, macOS o Unix:
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS-2 \
--db-snapshot-identifier preload
```
Per Windows:
```
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS-2 ^
--db-snapshot-identifier preload
```
Per riutilizzare l'endpoint esistente, innanzitutto elimina l'istanza database e fornisci al database ripristinato lo stesso identificatore. Per ulteriori informazioni, consulta [delete-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance.html).
L’esempio seguente crea uno snapshot di database finale dell’istanza database prima di eliminarla. Questo passaggio è facoltativo, ma è consigliato.
Per Linux, macOS o Unix:
```
aws rds delete-db-instance \
--db-instance-identifier AcmeRDS \
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
Per Windows:
```
aws rds delete-db-instance ^
--db-instance-identifier AcmeRDS ^
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
## Fase 4 (facoltativa): disattivare i backup automatici di Amazon RDS
**avvertimento**
Non disattivare i backup automatici se è necessario eseguire il ripristino. point-in-time
La disattivazione dei backup automatici è utile per ottimizzare le prestazioni, ma non è indispensabile per il caricamento dei dati. La disattivazione dei backup automatici comporta l’eliminazione di tutti i backup esistenti. Di conseguenza, dopo aver disattivato i backup automatici, il point-in-time ripristino non è possibile. Gli snapshot DB manuali non sono influenzati dalla disattivazione dei backup automatici. Tutti gli snapshot DB esistenti rimangono disponibili per il ripristino.
La disattivazione dei backup automatici velocizza il tempo di caricamento di circa il 25% e riduce la quantità di spazio richiesto. Se devi caricare dati in una nuova istanza database che non contiene altri dati, la disattivazione dei backup rappresenta un'ottima soluzione per velocizzare il caricamento ed evitare di occupare troppo spazio con i backup. Tuttavia, in alcuni casi, potresti pianificare di caricare i dati in un'istanza database che contiene già altri dati. In tal caso, valuta i vantaggi della disattivazione dei backup rispetto all'impatto della perdita della capacità di esecuzione. point-in-time-recovery
Per impostazione predefinita, i backup sono attivati per le istanze database (con un periodo di conservazione di un giorno). Per disabilitare i backup automatici, imposta il periodo di conservazione del backup su zero. Dopo il caricamento potrai riattivare i backup automatici impostando il periodo di conservazione su un valore diverso da zero. Per attivare o disattivare i backup, Amazon RDS chiude l’istanza database e la riavvia in modo da attivare o disattivare la registrazione di log MariaDB.
Esegui il AWS CLI `modify-db-instance` comando per impostare la conservazione dei backup su zero e applica immediatamente la modifica. Per impostare il periodo di retention su zero è necessario riavviare l'istanza database, quindi prima di continuare dovrai attendere il completamento del riavvio. Per ulteriori informazioni, consulta [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html).
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--apply-immediately \
--backup-retention-period 0
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--apply-immediately ^
--backup-retention-period 0
```
Puoi controllare lo stato della tua istanza DB con il AWS CLI [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)comando. Nell’esempio seguente viene visualizzato lo stato dell’istanza database `AcmeRDS`.
```
aws rds describe-db-instances --db-instance-identifier AcmeRDS --query "*[].{DBInstanceStatus:DBInstanceStatus}"
```
Quando lo stato dell’istanza database è `available`, si può passare alla fase successiva.
## Fase 5: Caricamento dei dati
Per leggere le righe dai file flat nelle tabelle del database, usa l’istruzione `LOAD DATA LOCAL INFILE` di MariaDB.
**Nota**
È necessario invocare la shell `mariadb` dalla stessa posizione in cui si trovano i file flat o utilizzare il percorso assoluto dei file quando si esegue `LOAD DATA LOCAL INFILE`.
L’esempio seguente mostra come caricare i dati da un file denominato `sales.txt` in una tabella denominata `Sales` nel database:
```
MariaDB [(none)]> LOAD DATA LOCAL INFILE 'sales.txt' INTO TABLE Sales FIELDS TERMINATED BY ' ' ENCLOSED BY '' ESCAPED BY '\\';
Query OK, 1 row affected (0.01 sec)
Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
```
Per ulteriori informazioni sull’istruzione `LOAD DATA`, consulta [LOAD DATA INFILE](https://mariadb.com/docs/server/reference/sql-statements/data-manipulation/inserting-loading-data/load-data-into-tables-or-index/load-data-infile) nella documentazione MariaDB.
## Fase 6: riattivare i backup automatici di Amazon RDS
Se nella [Fase 4](#mariadb-importing-data-any-source-turn-off-automated-backups) sono stati disattivati, al termine del caricamento riattiva i backup automatici di Amazon RDS impostando il periodo di conservazione del backup sul valore originale. Come indicato nella Fase 4, Amazon RDS riavvia l’istanza database, interrompendo brevemente le attività.
L'esempio seguente esegue il AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)comando per attivare i backup automatici per l'istanza `AcmeRDS` DB e impostare il periodo di conservazione su un giorno:
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--backup-retention-period 1 \
--apply-immediately
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--backup-retention-period 1 ^
--apply-immediately
```
# 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;
```
# Opzioni per il motore di database MariaDB
Vengono fornite descrizioni delle opzioni o delle funzionalità aggiuntive disponibili per le istanze Amazon RDS che eseguono il motore di database MariaDB. Per attivare queste opzioni, devi aggiungerle a un gruppo di opzioni personalizzate e quindi associare il gruppo di opzioni all'istanza database. Per ulteriori informazioni sull'utilizzo di gruppi di opzioni, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md).
Amazon RDS supporta le seguenti opzioni per MariaDB:
| ID opzione | Versioni del motore |
| --- | --- |
| `MARIADB_AUDIT_PLUGIN` | MariaDB 10.3 e versioni successive |
## Supporto del plug-in per audit MariaDB
Amazon RDS supporta l'uso del plug-in per audit MariaDB sulle istanze database MariaDB. Il plug-in per audit MariaDB registra le attività del database, ad esempio gli utenti che accedono al database, le query eseguite sul database e altro ancora. Il record con le attività del database è archiviato in un file di log.
### Impostazioni dell'opzione relativa al plug-in per audit
Amazon RDS supporta le seguenti impostazioni per l'opzione relativa al plug-in per audit MariaDB.
**Nota**
Se non configuri un'impostazione di opzione nella console, RDS utilizza l'impostazione predefinita.
| Impostazione opzioni | Valori validi | Valore predefinito | Descrizione |
| --- | --- | --- | --- |
| `SERVER_AUDIT_FILE_PATH` | `/rdsdbdata/log/audit/` | `/rdsdbdata/log/audit/` | La posizione del file di log. Il file di log contiene il record dell'attività specificata in `SERVER_AUDIT_EVENTS`. Per ulteriori informazioni, consulta [Visualizzazione ed elenco dei file di log del database](USER_LogAccess.Procedural.Viewing.md) e [File di log del database MariaDB](USER_LogAccess.Concepts.MariaDB.md). |
| `SERVER_AUDIT_FILE_ROTATE_SIZE` | 1–1000000000 | 1000000 | La dimensione in byte che, una volta raggiunta, provoca la rotazione del file. Per ulteriori informazioni, consulta [Rotazione e conservazione dei log per MariaDB](USER_LogAccess.MariaDB.LogFileSize.md). |
| `SERVER_AUDIT_FILE_ROTATIONS` | 0–100 | 9 | Il numero di rotazioni dei log da salvare se `server_audit_output_type=file`. Se impostata su 0, la rotazione del file di log non viene mai eseguita. Per ulteriori informazioni, consultare [Rotazione e conservazione dei log per MariaDB](USER_LogAccess.MariaDB.LogFileSize.md) e [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md). |
| `SERVER_AUDIT_EVENTS` | `CONNECT`, `QUERY`, `TABLE`, `QUERY_DDL`, `QUERY_DML`, `QUERY_DML_NO_SELECT`, `QUERY_DCL` | `CONNECT`, `QUERY` | I tipi di attività da registrate nel log. Viene registrata anche l'installazione del plug-in per audit MariaDB. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.MariaDB.Options.html) |
| `SERVER_AUDIT_INCL_USERS` | Più valori separati da virgola | Nessuna | Sono incluse solo le attività degli utenti specificati. Per impostazione predefinita, l'attività viene registrata per tutti gli utenti. `SERVER_AUDIT_INCL_USERS` e `SERVER_AUDIT_EXCL_USERS` si escludono a vicenda. Se si aggiungono valori a `SERVER_AUDIT_INCL_USERS`, è necessario assicurarsi che non venga aggiunto alcun valore a `SERVER_AUDIT_EXCL_USERS`. |
| `SERVER_AUDIT_EXCL_USERS` | Più valori separati da virgola | Nessuna | Sono escluse le attività degli utenti specificati. Per impostazione predefinita, l'attività viene registrata per tutti gli utenti. `SERVER_AUDIT_INCL_USERS` e `SERVER_AUDIT_EXCL_USERS` si escludono a vicenda. Se si aggiungono valori a `SERVER_AUDIT_EXCL_USERS`, è necessario assicurarsi che non venga aggiunto alcun valore a `SERVER_AUDIT_INCL_USERS`. L'utente `rdsadmin` esegue query sul database ogni secondo per verificare l'integrità del database. In base alle altre impostazioni, questa attività può causare un rapido ed eccessivo aumento delle dimensioni del file di log. Se non desideri registrare questa attività, aggiungi l'utente `rdsadmin` all'elenco `SERVER_AUDIT_EXCL_USERS`. `CONNECT`L'attività viene sempre registrata per tutti gli utenti, anche se l'utente è specificato per l'impostazione di questa opzione. |
| `SERVER_AUDIT_LOGGING` | `ON` | `ON` | La registrazione è attiva. L'unico valore valido è `ON`. Amazon RDS non supporta la disattivazione del logging. Se desideri disattivare la registrazione, rimuovi il plug-in per audit MariaDB. Per ulteriori informazioni, consulta [Rimozione del plug-in per audit MariaDB](#Appendix.MariaDB.Options.AuditPlugin.Remove). |
| `SERVER_AUDIT_QUERY_LOG_LIMIT` | 0–2147483647 | 1.024 | Il limite di lunghezza della stringa di query in un record. |
### Aggiunta del plug-in per audit MariaDB
Di seguito è riportato il processo generale per aggiungere il plug-in per audit MariaDB a un'istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Dopo aver aggiunto il plug-in per audit MariaDB, non dovrai riavviare la tua istanza database. Non appena il gruppo di opzioni è attivo, inizia immediatamente l'audit.
**Per aggiungere il plug-in per audit MariaDB**
1. Determinare il gruppo di opzioni che si desidera usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. Altrimenti, creare un gruppo di opzioni database personalizzato. Scegli **mariadb** per **Engine** (Motore), quindi **10.3** o versione successiva per **Major engine version** (Versione del motore principale). Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **MARIADB\$1AUDIT\$1PLUGIN** al gruppo di opzioni e configurare le impostazioni dell'opzione. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption). Per ulteriori informazioni su ciascuna impostazione, consulta [Impostazioni dell'opzione relativa al plug-in per audit](#Appendix.MariaDB.Options.AuditPlugin.Options).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente.
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza database e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
### Visualizzazione e download del log del plug-in per audit MariaDB
Dopo avere abilitato il plug-in per audit MariaDB, potrai accedere ai risultati nei file di log nello stesso modo in cui accedi a qualsiasi altro file di log basato su testo. I file di log per audit si trovano in `/rdsdbdata/log/audit/`. Per ulteriori informazioni sulla visualizzazione del file di log nella console, consulta [Visualizzazione ed elenco dei file di log del database](USER_LogAccess.Procedural.Viewing.md). Per informazioni sul download del file di log, consulta [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
### Modifica delle impostazioni del plug-in per audit MariaDB
Dopo aver abilitato il plug-in per audit MariaDB, puoi modificare le relative impostazioni. Per ulteriori informazioni su come modificare le impostazioni dell'opzione, consulta [Modifica di un'impostazione di un'opzione](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption). Per ulteriori informazioni su ciascuna impostazione, consulta [Impostazioni dell'opzione relativa al plug-in per audit](#Appendix.MariaDB.Options.AuditPlugin.Options).
### Rimozione del plug-in per audit MariaDB
Amazon RDS non supporta la disattivazione della registrazione nel plug-in per audit MariaDB. Puoi tuttavia rimuovere il plug-in da un'istanza database. Dopo aver rimosso il plug-in per audit MariaDB, l'istanza database viene riavviata automaticamente per arrestare l'audit.
Per rimuovere il plug-in per audit MariaDB da un'istanza database, procedi in uno dei seguenti modi:
+ Rimuovere l'opzione relativa al plug-in per audit MariaDB dal gruppo di opzioni a cui appartiene. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)
+ Modificare l'istanza database e specificare un diverso gruppo di opzioni che non comprenda il plug-in. Questa modifica coinvolge una singola istanza database. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Parametri per MariaDB
Per impostazione predefinita, un'istanza database MariaDB utilizza un gruppo di parametri database specifico a un database MariaDB. Questo gruppo di parametri contiene alcuni ma non tutti i parametri inclusi nel gruppo di parametri database Amazon RDS per il motore di database MySQL. Contiene inoltre vari parametri nuovi specifici di MariaDB. Per informazioni sull'utilizzo dei gruppi di parametri e sull'impostazione dei parametri, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
## Visualizzazione dei parametri MariaDB
I parametri di RDS for MariaDB sono impostati sui valori predefiniti del motore di storage selezionati. Per ulteriori informazioni sui parametri di MariaDB, consulta la [documentazione di MariaDB](http://mariadb.com/kb/en/mariadb/documentation/). Per ulteriori informazioni sui motori di storage MariaDB, consulta [Motori di storage supportati per MariaDB in Amazon RDS](MariaDB.Concepts.Storage.md).
È possibile visualizzare i parametri disponibili per una versione RDS for MariaDB specifica utilizzando la console RDS o la AWS CLI. Per informazioni sulla visualizzazione dei parametri in un gruppo di parametri MariaDB nella console RDS, consulta [Visualizzazione dei valori dei parametri per un gruppo di parametri del database in Amazon RDS](USER_WorkingWithParamGroups.Viewing.md).
Utilizzando AWS CLI, è possibile visualizzare i parametri per una versione RDS per MariaDB eseguendo il comando. [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-engine-default-parameters.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-engine-default-parameters.html) Indica uno dei valori seguenti per l’opzione `--db-parameter-group-family`:
+ `mariadb11.8`
+ `mariadb11.4`
+ `mariadb10.11`
+ `mariadb10.6`
+ `mariadb10.5`
+ `mariadb10.4`
+ `mariadb10.3`
Ad esempio, per visualizzare i parametri supportati per RDS for MariaDB versione 10.6 esegui il comando seguente.
```
aws rds describe-engine-default-parameters --db-parameter-group-family mariadb10.6
```
L'output avrà un aspetto simile al seguente.
```
{
"EngineDefaults": {
"Parameters": [
{
"ParameterName": "alter_algorithm",
"Description": "Specify the alter table algorithm.",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "string",
"AllowedValues": "DEFAULT,COPY,INPLACE,NOCOPY,INSTANT",
"IsModifiable": true
},
{
"ParameterName": "analyze_sample_percentage",
"Description": "Percentage of rows from the table ANALYZE TABLE will sample to collect table statistics.",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "float",
"AllowedValues": "0-100",
"IsModifiable": true
},
{
"ParameterName": "aria_block_size",
"Description": "Block size to be used for Aria index pages.",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "integer",
"AllowedValues": "1024-32768",
"IsModifiable": false
},
{
"ParameterName": "aria_checkpoint_interval",
"Description": "Interval in seconds between automatic checkpoints.",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "integer",
"AllowedValues": "0-4294967295",
"IsModifiable": true
},
...
```
Per visualizzare i parametri supportati per RDS for MariaDB versione 10.6 esegui il comando seguente.
Per Linux, macOS o Unix:
```
aws rds describe-engine-default-parameters --db-parameter-group-family mariadb10.6 \
--query 'EngineDefaults.Parameters[?IsModifiable==`true`]'
```
Per Windows:
```
aws rds describe-engine-default-parameters --db-parameter-group-family mariadb10.6 ^
--query "EngineDefaults.Parameters[?IsModifiable==`true`]"
```
## Parametri MySQL non disponibili
I seguenti parametri MySQL non sono disponibili nei gruppi di parametri database specifici di MariaDB:
+ bind\$1address
+ binlog\$1error\$1action
+ binlog\$1gtid\$1simple\$1recovery
+ binlog\$1max\$1flush\$1queue\$1time
+ binlog\$1order\$1commits
+ binlog\$1row\$1image
+ binlog\$1rows\$1query\$1log\$1events
+ binlogging\$1impossible\$1mode
+ block\$1encryption\$1mode
+ core\$1file
+ default\$1tmp\$1storage\$1engine
+ div\$1precision\$1increment
+ end\$1markers\$1in\$1json
+ enforce\$1gtid\$1consistency
+ eq\$1range\$1index\$1dive\$1limit
+ explicit\$1defaults\$1for\$1timestamp
+ gtid\$1executed
+ gtid-mode
+ gtid\$1next
+ gtid\$1owned
+ gtid\$1purged
+ log\$1bin\$1basename
+ log\$1bin\$1index
+ log\$1bin\$1use\$1v1\$1row\$1events
+ log\$1slow\$1admin\$1statements
+ log\$1slow\$1slave\$1statements
+ log\$1throttle\$1queries\$1not\$1using\$1indexes
+ master-info-repository
+ optimizer\$1trace
+ optimizer\$1trace\$1features
+ optimizer\$1trace\$1limit
+ optimizer\$1trace\$1max\$1mem\$1size
+ optimizer\$1trace\$1offset
+ relay\$1log\$1info\$1repository
+ rpl\$1stop\$1slave\$1timeout
+ slave\$1parallel\$1workers
+ slave\$1pending\$1jobs\$1size\$1max
+ slave\$1rows\$1search\$1algorithms
+ storage\$1engine
+ table\$1open\$1cache\$1instances
+ timed\$1mutexes
+ transaction\$1allow\$1batching
+ validate-password
+ validate\$1password\$1dictionary\$1file
+ validate\$1password\$1length
+ validate\$1password\$1mixed\$1case\$1count
+ validate\$1password\$1number\$1count
+ validate\$1password\$1policy
+ validate\$1password\$1special\$1char\$1count
Per ulteriori informazioni sui parametri di MySQL, consulta la [documentazione di MySQL](https://dev.mysql.com/doc/refman/8.0/en/).
# Migrazione dei dati da uno snapshot DB MySQL a un'istanza database MariaDB
Puoi eseguire la migrazione di uno snapshot DB RDS for MySQL a una nuova istanza database che esegue MariaDB utilizzando Console di gestione AWS, AWS CLI, o l'API Amazon RDS. Devi utilizzare lo snapshot di database creato da un'istanza database Amazon RDS che esegue MySQL 5.6. o 5.7. Per informazioni su come creare uno snapshot database RDS for MySQL, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
La migrazione dello snapshot non influisce sull'istanza database originale da cui è stato acquisito lo snapshot. È possibile testare e convalidare la nuova istanza database prima di indirizzarvi il traffico in sostituzione dell'istanza database originale.
Dopo aver effettuato la migrazione da MySQL a MariaDB, l'istanza database MariaDB sarà associata al gruppo di parametri database e al gruppo di opzioni predefiniti. Dopo aver ripristinato lo snapshot DB, è possibile associare un gruppo di parametri database personalizzato alla nuova istanza database. Tuttavia, un gruppo di parametri MariaDB ha un set diverso di variabili di sistema configurabili. Per informazioni sulle differenze tra le variabili di sistema MySQL e MariaDB, consultare [ System Variable Differences Between MariaDB and MySQL](https://mariadb.com/kb/en/system-variable-differences-between-mariadb-and-mysql/). Per informazioni sui gruppi di parametri database, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md). Per informazioni sui gruppi di opzioni, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md).
## Esecuzione della migrazione
È possibile eseguire la migrazione di uno snapshot DB RDS for MySQL in una nuova istanza database di MariaDB utilizzando la Console di gestione AWS, AWS CLI, o l'API RDS.
### Console
**Per effettuare la migrazione di una snapshot DB MySQL a un'istanza database MariaDB**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione, scegliere **Snapshots (Snapshot)**, quindi selezionare la snapshot DB MySQL di cui si desidera effettuare la migrazione.
1. Per **Actions (Operazioni)** scegliere **Migrate Snapshot (Migrazione dello snapshot)**. Viene visualizzata la pagina **Migrate Database (Migrazione database)**.
1. Per **Migrate to DB Engine (Migra al motore del database)**, scegliere **mariadb**.
Amazon RDS seleziona automaticamente la **versione motore di database**. Non è possibile modificare la versione del motore di database.
![\[La pagina Migra il database per migrare da MySQL a MariaDB nella console Amazon RDS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/MigrateMariaDB.png)
1. Per le restanti sezioni, specifica le impostazioni dell'istanza database. Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
1. Scegliere **Migrate (Migrazione)**.
### AWS CLI
Per eseguire la migrazione dei dati da uno snapshot del database MySQL a un’istanza database MariaDB, utilizzare il comando AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) con le seguenti opzioni:
+ --db-instance-identifier – Nome dell'istanza database da creare dalla snapshot DB.
+ --db-snapshot-identifier – L'identificatore della snapshot DB da cui eseguire il ripristino.
+ --engine – Il motore di database da utilizzare per la nuova istanza.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds restore-db-instance-from-db-snapshot \
2. --db-instance-identifier newmariadbinstance \
3. --db-snapshot-identifier mysqlsnapshot \
4. --engine mariadb
```
Per Windows:
```
1. aws rds restore-db-instance-from-db-snapshot ^
2. --db-instance-identifier newmariadbinstance ^
3. --db-snapshot-identifier mysqlsnapshot ^
4. --engine mariadb
```
### API
Per eseguire la migrazione dei dati da uno snapshot database MySQL a un'istanza database MariaDB, chiamare l'operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html) dell'API Amazon RDS.
## Incompatibilità tra MariaDB e MySQL
Le incompatibilità tra MySQL e MariaDB includono quanto segue:
+ Non puoi eseguire la migrazione di una snapshot DB creata con MySQL 8.0 a MariaDB.
+ Se il database MySQL di origine utilizza un hash della password SHA256, è necessario reimpostare le password utente con hash SHA256 prima di effettuare la connessione al database MariaDB. Il seguente codice mostra come reimpostare una password con hash SHA256.
```
SET old_passwords = 0;
UPDATE mysql.user SET plugin = 'mysql_native_password',
Password = PASSWORD('new_password')
WHERE (User, Host) = ('master_user_name', %);
FLUSH PRIVILEGES;
```
+ Se l'account utente master RDS utilizza l'hash della password SHA-256, è necessario reimpostare la password utilizzando la Console di gestione AWS, il comando [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) AWS CLI o l'operazione API RDS [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html). Per ulteriori informazioni sulla modifica di un'istanza database, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
+ MariaDB non supporta il plugin Memcached. Tuttavia, i dati utilizzati dal plugin Memcached sono archiviati come tabelle InnoDB. Dopo aver effettuato la migrazione di una snapshot DB MySQL, è possibile accedere ai dati utilizzati dal plugin Memcached mediante SQL. Per ulteriori informazioni sul database innodb\$1memcache, consulta la pagina relativa a [plugin interni InnoDB memcached](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-internals.html).
# MariaDB sul riferimento SQL di Amazon RDS
Di seguito, sono disponibili descrizioni di stored procedure di sistema disponibili alle istanze Amazon RDS che eseguono il motore di database MariaDB.
Puoi utilizzare tutte le stored procedure del sistema disponibili per le istanze database MySQL e MariaDB. Le procedure archiviate sono documentate in [Riferimento delle stored procedure RDS per MySQL](Appendix.MySQL.SQLRef.md). Le istanze database MariaDB supportano tutte le procedure archiviate, ad eccezione di `mysql.rds_start_replication_until` e `mysql.rds_start_replication_until_gtid`.
Inoltre, le seguenti procedure archiviate nel sistema sono supportate solo per le istanze database Amazon RDS che eseguono MariaDB:
+ [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md)
+ [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md)
+ [mysql.rds\$1kill\$1query\$1id](mysql_rds_kill_query_id.md)
+ [mysql.rds\$1execute\$1operation](mysql_rds_execute_operation.md)
# mysql.rds\$1replica\$1status
Mostra lo stato di replica di una replica di lettura MariaDB.
Richiamare questa procedura sulla replica di lettura per visualizzare le informazioni sullo stato dei parametri essenziali dei thread di replica.
## Sintassi
```
CALL mysql.rds_replica_status;
```
## Note per l'utilizzo
Questa procedura è supportata solo per le istanze database MariaDB che eseguono MariaDB versione 10.5 e successive.
Questa procedura è l'equivalente del comando `SHOW REPLICA STATUS`. Questo comando non è supportato per le istanze database MariaDB versione 10.5 e successive.
Nelle versioni precedenti di MariaDB, il comando `SHOW SLAVE STATUS` equivalente richiedeva il privilegio `REPLICATION SLAVE`. In MariaDB 10.5 e versioni successive, richiede il privilegio `REPLICATION REPLICA ADMIN`. Per proteggere la gestione RDS delle istanze database MariaDB 10.5 e versioni successive, questo nuovo privilegio non viene concesso all'utente master RDS.
## Esempi
L'esempio seguente mostra lo stato di una replica di lettura MariaDB:
```
call mysql.rds_replica_status;
```
La risposta è simile a quella riportata di seguito.
```
*************************** 1. row ***************************
Replica_IO_State: Waiting for master to send event
Source_Host: XX.XX.XX.XXX
Source_User: rdsrepladmin
Source_Port: 3306
Connect_Retry: 60
Source_Log_File: mysql-bin-changelog.003988
Read_Source_Log_Pos: 405
Relay_Log_File: relaylog.011024
Relay_Log_Pos: 657
Relay_Source_Log_File: mysql-bin-changelog.003988
Replica_IO_Running: Yes
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table: mysql.rds_sysinfo,mysql.rds_history,mysql.rds_replication_status
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 405
Relay_Log_Space: 1016
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Master: 0
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 807509301
Source_SSL_Crl:
Source_SSL_Crlpath:
Using_Gtid: Slave_Pos
Gtid_IO_Pos: 0-807509301-3980
Replicate_Do_Domain_Ids:
Replicate_Ignore_Domain_Ids:
Parallel_Mode: optimistic
SQL_Delay: 0
SQL_Remaining_Delay: NULL
Replica_SQL_Running_State: Reading event from the relay log
Replica_DDL_Groups: 15
Replica_Non_Transactional_Groups: 0
Replica_Transactional_Groups: 3658
1 row in set (0.000 sec)
Query OK, 0 rows affected (0.000 sec)
```
# mysql.rds\$1set\$1external\$1master\$1gtid
Configura la replica basata su GTID da un'istanza MariaDB in esecuzione all'esterno di Amazon RDS a un'istanza database MariaDB. Questa procedura archiviata è supportata solo se l'istanza esterna di MariaDB è la versione 10.0.24 o successiva. Quando configuri una replica dove una o entrambe le istanze non supportano gli ID globale di transazione (GTID) di MariaDB, utilizza [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).
L'utilizzo di GTID per la replica offre funzioni di sicurezza contro l'arresto anomalo non offerte dalla replica dei log binari. Pertanto è consigliata per la replica di istanze che li supportano.
## Sintassi
```
CALL mysql.rds_set_external_master_gtid(
host_name
, host_port
, replication_user_name
, replication_user_password
, gtid
, ssl_encryption
);
```
## Parametri
*host\$1name*
Stringa. Il nome host o l'indirizzo IP dell'istanza MariaDB in esecuzione all'esterno di Amazon RDS che diventerà l’istanza di origine.
*host\$1port*
Numero intero. La porta utilizzata dall'istanza MariaDB in esecuzione all'esterno di Amazon RDS da configurare come istanza di origine. Se la configurazione della rete include la replica della porta SSH che converte il numero di porta, specifica il numero di porta esposto da SSH.
*replication\$1user\$1name*
Stringa. L'ID di un utente con autorizzazioni `REPLICATION SLAVE` nell'istanza database MariaDB da configurare come replica di lettura.
*replication\$1user\$1password*
Stringa. La password dell'ID utente specificata in `replication_user_name`.
*gtid*
Stringa. L'ID globale di transazione sull’istanza di origine dalla quale la replica dovrebbe iniziare.
Puoi utilizzare `@@gtid_current_pos` per ottenere il GTID corrente se l’istanza di origine è stata bloccata durante la configurazione della replica, così il log binario non cambia tra i punti quando ottieni il GTID e quando la replica inizia.
In alternativa, se utilizzi `mysqldump` versione 10.0.13 o successiva per compilare l'istanza di replica prima di avviare la replica, puoi ottenere la posizione GTID nell'output utilizzando l'opzione `--master-data` o `--dump-slave`. Se non utilizzi `mysqldump` versione 10.0.13 o successiva, puoi eseguire `SHOW MASTER STATUS` o utilizzare quelle stesse opzioni `mysqldump` per ottenere il nome e la posizione del file di log binario, quindi convertirle in un GTID eseguendo `BINLOG_GTID_POS` sull'istanza MariaDB esterna:
```
SELECT BINLOG_GTID_POS('', );
```
Per ulteriori informazioni sull'implementazione di GTID di MariaDB, consulta [ID globale di transazione (GTID)](http://mariadb.com/kb/en/mariadb/global-transaction-id/) nella documentazione di MariaDB.
*ssl\$1encryption*
Un valore che specifica se la crittografia Secure Socket Layer (SSL) è utilizzata sulla connessione di replica. 1 indica che la crittografia SSL deve essere utilizzata; 0 specifica che la crittografia non deve essere utilizzata. Il valore predefinito è 0.
L'opzione `MASTER_SSL_VERIFY_SERVER_CERT` non è supportata. Questa opzione è impostata su 0, il che significa che la connessione è crittografata, ma i certificati non sono verificati.
## Note per l'utilizzo
La procedura `mysql.rds_set_external_master_gtid` deve essere eseguita dall'utente master. Deve essere eseguita sull'istanza database MariaDB che stai configurando come replica di un'istanza MariaDB in esecuzione all'esterno di Amazon RDS. Prima di eseguire `mysql.rds_set_external_master_gtid`, devi aver configurato l'istanza di MariaDB in esecuzione all'esterno di Amazon RDS come istanza di origine. Per ulteriori informazioni, consulta [Importazione di dati in un’istanza database Amazon RDS per MariaDB.](MariaDB.Procedural.Importing.md).
**avvertimento**
Non usare `mysql.rds_set_external_master_gtid` per gestire la replica tra due istanze database Amazon RDS. Utilizzala soltanto nel caso della replica con un'istanza di MariaDB in esecuzione all'esterno di RDS. Per ulteriori informazioni sulla gestione della replica tra istanze database Amazon RDS, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md).
Dopo aver chiamato `mysql.rds_set_external_master_gtid` per configurare un'istanza database di Amazon RDS come una replica di lettura, puoi chiamare [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) nella replica per avviare il processo di replica. Puoi chiamare [mysql.rds\$1reset\$1external\$1master (RDS per MariaDB e RDS per MySQL versioni principali 8.0 e precedenti)](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master) per rimuovere la configurazione della replica di lettura.
Quando `mysql.rds_set_external_master_gtid` viene chiamato, Amazon RDS registra l'ora, l'utente e un'operazione di "impostazione master" nelle tabelle `mysql.rds_history` e `mysql.rds_replication_status`.
## Esempi
Nel caso di esecuzione di un'istanza database MariaDB, l'esempio seguente la configura come replica di un'istanza di MariaDB in esecuzione all'esterno di Amazon RDS.
```
call mysql.rds_set_external_master_gtid ('Sourcedb.some.com',3306,'ReplicationUser','SomePassW0rd','0-123-456',0);
```
# mysql.rds\$1kill\$1query\$1id
Termina una query in esecuzione sul server MariaDB per chiudere query di lunga durata o problematiche. È possibile identificare l’ID della query e arrestare in modo efficace una query specifica per risolvere problemi di prestazioni e mantenere un funzionamento ottimale del database.
## Sintassi
```
CALL mysql.rds_kill_query_id(queryID);
```
## Parametri
*queryID*
Numero intero. L'identità della query da terminare.
## Note per l'utilizzo
Per arrestare una query in esecuzione nel server MariaDB, utilizza la procedura `mysql.rds_kill_query_id` e invia l'ID di quella query. Per ottenere l'ID query, esegui la query nella [Information Schema PROCESSLIST Table](http://mariadb.com/kb/en/mariadb/information-schema-processlist-table/) di MariaDB come mostrato di seguito:
```
SELECT USER, HOST, COMMAND, TIME, STATE, INFO, QUERY_ID FROM
INFORMATION_SCHEMA.PROCESSLIST WHERE USER = '';
```
La connessione al server MariaDB viene mantenuta.
## Esempi
L'esempio seguente termina una query con un ID query di 230040:
```
call mysql.rds_kill_query_id(230040);
```
# mysql.rds\$1execute\$1operation
Esegue operazioni InnoDB per gestire gli stati del pool di buffer e il tablespace temporaneo. Questa procedura consente di controllare dinamicamente le operazioni di InnoDB, ad esempio il dump e il caricamento degli stati del pool di buffer o il troncamento del tablespace temporaneo.
## Sintassi
```
CALL mysql.rds_execute_operation(operation);
```
## Parametri
*operazione*
Stringa. Le operazioni InnoDB da eseguire. I valori validi sono:
+ *innodb\$1buffer\$1pool\$1dump\$1now* - Operazione che esegue il dump dello stato corrente del pool di buffer.
+ *innodb\$1buffer\$1pool\$1load\$1now* - Operazione che carica lo stato del pool di buffer salvato.
+ *innodb\$1buffer\$1pool\$1load\$1abort* - Operazione che interrompe il caricamento di un pool di buffer.
+ *innodb\$1truncate\$1temporary\$1tablespace\$1now* - Operazione che trova il tablespace temporaneo.
## Note per l’utilizzo
Questa procedura è supportata solo per le istanze database MariaDB che eseguono MariaDB versione 11.8 e successive.
Durante l’esecuzione, la registrazione di log binari è temporaneamente disabilitata per impedire la replica di questi comandi amministrativi.
La procedura mantiene un audit trail registrando tutte le operazioni nella tabella [https://mariadb.com/docs/server/security/securing-mariadb/securing-mariadb-encryption/data-in-transit-encryption/securing-connections-for-client-and-server#requiring-tls](https://mariadb.com/docs/server/security/securing-mariadb/securing-mariadb-encryption/data-in-transit-encryption/securing-connections-for-client-and-server#requiring-tls).
## Esempi
L’esempio seguente mostra la riduzione temporanea del tablespace `mysql.rds_execute_operation`:
Per controllare la dimensione attuale del tablespace, esequi questa query:
```
SELECT FILE_SIZE FROM information_schema.innodb_sys_tablespaces WHERE name LIKE 'innodb_temporary';
+------------+
| FILE_SIZE |
+------------+
| 6723469312 | -- 6.3 GB
+------------+
```
Quando si eliminano tabelle temporanee, non si riduce l’utilizzo dello spazio di archiviazione nel tablespace. Per diminuire le dimensioni dello spazio di tabelle globale, esegui il comando `mysql.rds_execute_operation` per ridurre il tablespace temporaneo.
```
CALL mysql.rds_execute_operation('innodb_truncate_temporary_tablespace_now');
Query OK, 2 rows affected (0.004 sec)
```
Dopo aver eseguito la procedura, verifica che lo spazio sia stato recuperato.
```
SELECT FILE_SIZE FROM information_schema.innodb_sys_tablespaces WHERE name LIKE 'innodb_temporary';
+-----------+
| FILE_SIZE |
+-----------+
| 12582912 | -- 12 MB
+-----------+
```
**Nota**
L’operazione di riduzione potrebbe richiedere tempo, in base alle dimensioni del tablespace temporaneo e del carico di lavoro corrente.
**Importante**
Il tablespace temporaneo si riduce solo quando tutte le tabelle temporanee che hanno contribuito alla sue dimensioni non sono più in uso. Si consiglia di eseguire questa procedura quando nell’istanza non sono presenti tablespace temporanei attivi.
# Fuso orario locale per le istanze database MariaDB
Per impostazione predefinita, il fuso orario per un'istanza database di MariaDB è in formato Universal Time Coordinated (UTC). Puoi impostare il fuso orario per l'istanza database sul fuso orario locale dell'applicazione.
Per impostare il fuso orario locale per un'istanza database, imposta il parametro `time_zone` nel gruppo di parametri per l'istanza database su uno dei valori supportati elencati più avanti in questa sezione. Quando imposti il parametro `time_zone` per un gruppo di parametri, tutte le istanze database e le repliche di lettura che utilizzano tale gruppo di parametri cambiano per utilizzare il nuovo fuso orario locale. Per informazioni sull'impostazione dei parametri in un gruppo di parametri, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
Dopo aver impostato il fuso orario locale, tutte le nuove connessioni al database riflettono la modifica. Se ci sono connessioni aperte al database quando modifichi il fuso orario locale, questo non viene aggiornato fino a quando non chiudi la connessione e ne apri una nuova.
Puoi impostare un fuso orario locale diverso per un'istanza database e una o più delle relative repliche di lettura. A tale scopo, utilizza un gruppo di parametri diverso per l'istanza database e la replica o le repliche e imposta il parametro `time_zone` in ogni gruppo di parametri su un fuso orario locale diverso.
Se esegui la replica tra Regioni AWS, l'istanza database di origine e la replica di lettura utilizzano gruppi di parametri diversi (i gruppi di parametri sono univoci per una Regione AWS). Per utilizzare lo stesso fuso orario locale per ogni istanza, imposta il parametro `time_zone` nei gruppi di parametri dell'istanza e della replica di lettura.
Quando ripristini un'istanza database da uno snapshot DB, il fuso orario locale è impostato su UTC. Puoi aggiornare il fuso orario impostandolo sul fuso orario locale dopo il completamento del ripristino. Se ripristini un'istanza database a un punto nel tempo, il fuso orario locale per l'istanza database ripristinata corrisponde all'impostazione del fuso orario per il gruppo di parametri dell'istanza database ripristinata.
Internet Assigned Numbers Authority (IANA) pubblica nuovi fusi orari all'indirizzo [https://www.iana.org/time-zones](https://www.iana.org/time-zones) più volte all'anno. Ogni volta che RDS rilascia una nuova versione di manutenzione secondaria di MariaDB, la versione viene fornita con i dati sul fuso orario più recenti al momento del rilascio. Quando utilizzi le versioni più recenti di RDS per MariaDB, hai a disposizione i dati recenti relativi ai fusi orari di RDS. Per assicurarti che l'istanza DB disponga dei dati più aggiornati relativi ai fusi orari, ti consigliamo di eseguire l'aggiornamento a una versione superiore del motore DB. In alternativa, puoi modificare manualmente le tabelle dei fusi orari nelle istanze DB MariaDB. A tale scopo, puoi utilizzare i comandi SQL o eseguire lo strumento [mysql\$1tzinfo\$1to\$1sql](https://mariadb.com/kb/en/mysql_tzinfo_to_sql/) in un client SQL. Dopo l'aggiornamento manuale dei dati dei fusi orari, avvia l'istanza database per applicare le modifiche. RDS non modifica né ripristina i dati dei fusi orari delle istanze DB in esecuzione. I nuovi dati dei fusi orari vengono installati solo quando si esegue un aggiornamento della versione del motore di database.
Puoi impostare il fuso orario locale su uno dei valori seguenti.
| Zona | Time zone (Fuso orario) |
| --- | --- |
| Africa | Africa/Cairo, Africa/Casablanca, Africa/Harare, Africa/Monrovia, Africa/Nairobi, Africa/Tripoli, Africa/Windhoek |
| America | America/Araguaina, America/Asuncion, America/Bogota, America/Buenos\$1Aires, America/Caracas, America/Chihuahua, America/Cuiaba, America/Denver, America/Fortaleza, America/Guatemala, America/Halifax, America/Manaus, America/Matamoros, America/Monterrey, America/Montevideo, America/Phoenix, America/Santiago, America/Tijuana |
| Asia | Asia/Amman, Asia/Ashgabat, Asia/Baghdad, Asia/Baku, Asia/Bangkok, Asia/Beirut, Asia/Calcutta, Asia/Damasco, Asia/Dhaka, Asia/Irkutsk, Asia/Gerusalemme, Asia/Kabul, Asia/Karachi, Asia/Kathmandu, Asia/Krasnoyarsk, Asia/Magadan, Asia/Muscat, Asia/Novosibirsk, Asia/Riyadh, Asia/Seoul, Asia/Shanghai, Asia/Singapore, Asia/Taipei, Asia/Tehran, Asia/Tokyo, Asia/Ulaanbaatar, Asia/Vladivostok, Asia/Yakutsk, Asia/Yerevan |
| Atlantico | Atlantico/Azzorre |
| Australia | Australia/Adelaide, Australia/Brisbane, Australia/Darwin, Australia/Hobart, Australia/Perth, Australia/Sydney |
| Brasile | Brasile/DeNoronha, Brasile/Est |
| Canada | Canada/Newfoundland, Canada/Saskatchewan |
| Europa | Europa/Amsterdam, Europa/Atene, Europa/Dublino, Europa/Helsinki, Europa/Istanbul, Europa/Kaliningrad Europa/Mosca, Europa/Parigi, Europa/Praga, Europe/Sarajevo |
| Pacifico | Pacifico/Auckland, Pacifico/Fiji, Pacifico/Guam, Pacifico/Honolulu, Pacifico/Samoa |
| USA | Stati Uniti/Alaska, Stati Uniti/Centrali, Stati Uniti/Est-Indiana, Stati Uniti/Orientali, Stati Uniti/Pacifico |
| UTC | UTC |
# Problemi e limitazioni note per RDS per MariaDB
I seguenti elementi sono problemi e limitazioni noti quando si utilizza RDS per MariaDB.
**Nota**
L'elenco non è completo.
**Topics**
+ [Limiti delle dimensioni dei file MariaDB in Amazon RDS](#RDS_Limits.FileSize.MariaDB)
+ [Parola riservata InnoDB](#MariaDB.Concepts.InnodbDatabaseName)
+ [Porte personalizzate](#MariaDB.Concepts.CustomPorts)
+ [Approfondimenti sulle prestazioni](#MariaDB.Concepts.PerformanceInsights)
## Limiti delle dimensioni dei file MariaDB in Amazon RDS
Per le istanze database MariaDB, le dimensioni massime di una tabella è 16 TB quando si usano spazi tabelle file-per-table InnoDB. Questo valore limita anche il tablespace di sistema a una dimensione massima di 16 TB. Gli spazi tabelle file-per-table InnoDB (con ciascuna tabella nel relativo spazio tabelle) sono configurati per impostazione predefinita per le istanze database MariaDB. Questo limite non è correlato al limite massimo di archiviazione per le istanze database MariaDB. Per ulteriori informazioni sui limiti di archiviazione, consulta [Storage delle istanze di database Amazon RDS](CHAP_Storage.md).
Ci sono vantaggi e svantaggi nell'utilizzare i tablespaces file-per-table InnoDB, a seconda dell'applicazione. Per stabilire l'approccio migliore per l'applicazione, consulta [File-Per-Table Tablespaces](https://dev.mysql.com/doc/refman/5.7/en/innodb-file-per-table-tablespaces.html) nella documentazione MySQL.
Non è consigliabile consentire alle tabelle di crescere fino alla dimensione massima del file. In generale, una pratica migliore consiste nel partizionare i dati in tabelle più piccole, che possano migliorare le prestazioni e i tempi di ripristino.
Un'opzione che è possibile utilizzare per suddividere una tabella di grandi dimensioni in tabelle più piccole è rappresentata dal partizionamento. Il *partizionamento* distribuisce parti della tabella di grandi dimensioni in file separati in base alle regole specificate. Ad esempio, se si archiviano le transazioni per data, è possibile creare regole di partizionamento che distribuiscono le transazioni meno recenti in file separati mediante il partizionamento. Quindi, periodicamente, è possibile archiviare i dati storici della transazione che non devono essere prontamente disponibili per l'applicazione. Per ulteriori informazioni, consulta [Partitioning](https://dev.mysql.com/doc/refman/5.7/en/partitioning.html) nella documentazione MySQL.
**Determinazione della dimensione di tutti gli spazi tabella InnoDB**
+ Utilizza il seguente comando SQL per stabilire se qualche tabella supera le dimensioni consentite e può essere scelta per il partizionamento.
**Nota**
Per MariaDB 10.6 e versioni successive, questa query restituisce anche la dimensione dello spazio tabella del sistema InnoDB.
Per le versioni di MariaDB precedenti alla 10.6, non è possibile determinare la dimensione dello spazio tabella del sistema InnoDB mediante query sulle tabelle di sistema. Consigliamo di eseguire l'aggiornamento a una versione più recente.
```
1. SELECT SPACE,NAME,ROUND((ALLOCATED_SIZE/1024/1024/1024), 2)
2. as "Tablespace Size (GB)"
3. FROM information_schema.INNODB_SYS_TABLESPACES ORDER BY 3 DESC;
```
**Determinazione della dimensione delle tabelle utente non InnoDB**
+ Utilizza il seguente comando SQL per stabilire se qualche tabella utente non InnoDB ha dimensioni eccessive.
```
SELECT TABLE_SCHEMA, TABLE_NAME, round(((DATA_LENGTH + INDEX_LENGTH+DATA_FREE)
/ 1024 / 1024/ 1024), 2) As "Approximate size (GB)" FROM information_schema.TABLES
WHERE TABLE_SCHEMA NOT IN ('mysql', 'information_schema', 'performance_schema')
and ENGINE<>'InnoDB';
```
**Per abilitare gli spazi tabelle file-per-table InnoDB**
+ Imposta il parametro `innodb_file_per_table` su `1` nel gruppo di parametri per l'istanza database.
**Per disabilitare gli spazi tabelle file-per-table InnoDB**
+ Imposta il parametro `innodb_file_per_table` su `0` nel gruppo di parametri per l'istanza database.
Per informazioni sull'aggiornamento di un gruppo di parametri database, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
Una volta abilitati o disabilitati gli spazi tabelle file-per-table InnoDB, puoi eseguire il comando `ALTER TABLE`. È possibile utilizzare questo comando per spostare una tabella dallo spazio tabelle globale al proprio spazio tabelle. Oppure è possibile spostare una tabella dal proprio spazio tabelle allo spazio tabelle globale. Di seguito è riportato un esempio.
```
1. ALTER TABLE table_name ENGINE=InnoDB, ALGORITHM=COPY;
```
## Parola riservata InnoDB
`InnoDB` è una parola riservata per RDS for MariaDB. Non è possibile utilizzare questo nome per un database MariaDB.
## Porte personalizzate
Amazon RDS blocca le connessioni alla porta personalizzata 33060 per il motore MariaDB. Scegli una porta diversa per il motore MariaDB.
## Approfondimenti sulle prestazioni
I contatori InnoDB non sono visibili in Approfondimenti sulle prestazioni di Amazon RDS per MariaDB versione 10.11 perché la community MariaDB non li supporta più.