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à.
# Attività di log DBA comuni per istanze database MySQL
Questo articolo descrive le implementazioni specifiche di Amazon RDS di alcune attività DBA comuni per le istanze database in esecuzione sul motore di database MySQL. 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.
Per informazioni sull'uso di file di log MySQL in Amazon RDS, consult [File di registro del database ](USER_LogAccess.Concepts.MySQL.md).
## Informazioni sugli utenti predefiniti
Amazon RDS crea automaticamente diversi utenti predefiniti con istanze database RDS per MySQL. Gli utenti predefiniti e i relativi privilegi non possono essere modificati. Non è possibile eliminare, rinominare o modificare i privilegi per questi utenti predefiniti. Qualsiasi tentativo comporta la generazione di un errore.
+ **rdsadmin**: un utente creato per gestire molte delle attività di gestione che l’amministratore con privilegi `superuser` esegue su un database MySQL autonomo. Questo utente viene utilizzato internamente da RDS per MySQL per molte attività di gestione.
+ **rdsrepladmin**: un utente utilizzato internamente da Amazon RDS per supportare le attività di replica su cluster e istanze database RDS per MySQL.
Per informazioni su altre attività DBA comuni, consulta gli argomenti indicati di seguito.
**Topics**
+ [
## Informazioni sugli utenti predefiniti
](#Appendix.MySQL.CommonDBATasks.users)
+ [
# Privilegio basato sui ruoli per RDS per MySQL
](Appendix.MySQL.CommonDBATasks.privilege-model.md)
+ [
# Privilegi dinamici per RDS per MySQL
](Appendix.MySQL.CommonDBATasks.dynamic-privileges.md)
+ [
# Termine di una sessione o una query per RDS per MySQL
](Appendix.MySQL.CommonDBATasks.End.md)
+ [
# Ignorare l’errore di replica corrente per RDS per MySQL
](Appendix.MySQL.CommonDBATasks.SkipError.md)
+ [
# Lavorare con i tablespace InnoDB per migliorare i tempi di ripristino dopo un arresto anomalo per RDS per MySQL
](Appendix.MySQL.CommonDBATasks.Tables.md)
+ [
# Gestione della cronologia dello stato globale per RDS per MySQL
](Appendix.MySQL.CommonDBATasks.GoSH.md)
+ [
# Configurazione delle dimensioni del pool di buffer e della capacità dei log di redo in MySQL 8.4
](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md)
# Privilegio basato sui ruoli per RDS per MySQL
A partire da RDS per MySQL versione 8.0.36, non è più possibile modificare le tabelle direttamente nel database `mysql`. In particolare, non puoi creare utenti del database eseguendo operazioni DML (Data Manipulation Language) sulle tabelle `grant`. Si utilizzano invece istruzioni di gestione degli account MySQL come `CREATE USER`, `GRANT` e `REVOKE` per concedere privilegi basati sui ruoli agli utenti. Inoltre, nel database `mysql`, non è possibile creare altri tipi di oggetti come le stored procedure. È comunque possibile interrogare le tabelle di `mysql`. Se utilizzi la replica del log binario, le modifiche apportate direttamente alle tabelle `mysql` sull’istanza database di origine non vengono replicate nel cluster di destinazione.
In alcuni casi, l'applicazione potrebbe utilizzare scorciatoie per creare utenti o altri oggetti inserendoli nelle tabelle di `mysql`. In tal caso, modifica il codice dell'applicazione per utilizzare le istruzioni corrispondenti come `CREATE USER`.
Per esportare i metadati per gli utenti del database durante la migrazione da un database MySQL esterno, utilizza uno dei metodi riportati di seguito:
+ Utilizza l’utilità di dump delle istanze di MySQL Shell con un filtro per escludere utenti, ruoli e concessioni. L’esempio seguente mostra la sintassi dei comandi da utilizzare. Assicurati che `outputUrl` sia vuoto.
```
mysqlsh user@host -- util.dumpInstance(outputUrl,{excludeSchemas:['mysql'],users: true})
```
Per ulteriori informazioni, consulta [Instance Dump Utility, Schema Dump Utility, and Table Dump Utility](https://dev.mysql.com/doc/mysql-shell/8.0/en/mysql-shell-utilities-dump-instance-schema.html) nel manuale di riferimento di MySQL.
+ Usa l’utilità client `mysqlpump`. Questo esempio include tutte le tabelle ad eccezione di quelle nel database di sistema `mysql`. Include anche istruzioni `CREATE USER` e `GRANT` per riprodurre tutti gli utenti MySQL nel database migrato.
```
mysqlpump --exclude-databases=mysql --users
```
L’utilità client `mysqlpump` non è più disponibile con MySQL 8.4. Utilizza invece `mysqldump`.
Per semplificare la gestione delle autorizzazioni per molti utenti o applicazioni, è possibile utilizzare l'istruzione `CREATE ROLE` per creare un ruolo con una serie di autorizzazioni. Puoi quindi utilizzare le istruzioni `GRANT` e `SET ROLE` e la funzione `current_role` per assegnare ruoli a utenti o applicazioni, cambiare il ruolo corrente e verificare quali ruoli sono in vigore. Per ulteriori informazioni sul sistema di autorizzazione basato sui ruoli in MySQL 8.0, consultare [Utilizzo di ruoli](https://dev.mysql.com/doc/refman/8.0/en/roles.html) nel Manuale di riferimento di MySQL.
**Importante**
Si consiglia di non utilizzare l'utente master direttamente nelle applicazioni. Rispetta piuttosto la best practice di utilizzare un utente del database creato con i privilegi minimi richiesti per l'applicazione.
A partire dalla versione 8.0.36, RDS per MySQL include un ruolo speciale che ha tutti i seguenti privilegi. Il ruolo è denominato `rds_superuser_role`. L’utente amministrativo principale per ciascuna istanza database ha già concesso questo ruolo. Il ruolo `rds_superuser_role` include i seguenti privilegi per tutti gli oggetti del database:
+ `ALTER`
+ `APPLICATION_PASSWORD_ADMIN`
+ `ALTER ROUTINE`
+ `CREATE`
+ `CREATE ROLE`
+ `CREATE ROUTINE`
+ `CREATE TEMPORARY TABLES`
+ `CREATE USER`
+ `CREATE VIEW`
+ `DELETE`
+ `DROP`
+ `DROP ROLE`
+ `EVENT`
+ `EXECUTE`
+ `INDEX`
+ `INSERT`
+ `LOCK TABLES`
+ `PROCESS`
+ `REFERENCES`
+ `RELOAD`
+ `REPLICATION CLIENT`
+ `REPLICATION SLAVE`
+ `ROLE_ADMIN`
+ `SET_USER_ID`
+ `SELECT`
+ `SHOW DATABASES`
+ `SHOW VIEW`
+ `TRIGGER`
+ `UPDATE`
+ `XA_RECOVER_ADMIN`
La definizione del ruolo include anche la `WITH GRANT OPTION` in modo che un utente amministrativo possa concedere tale ruolo ad altri utenti. In particolare, l’amministratore deve concedere tutti i privilegi necessari per eseguire la replica del log binario con il cluster MySQL come destinazione.
**Suggerimento**
Per visualizzare i dettagli completi delle autorizzazioni, usare la seguente istruzione.
```
SHOW GRANTS FOR rds_superuser_role@'%';
```
Quando concedi l’accesso utilizzando i ruoli in RDS per MySQL versione 8.0.36 e successive, attivi anche il ruolo utilizzando l’istruzione `SET ROLE role_name` o `SET ROLE ALL`. L'esempio seguente mostra come. Sostituire il nome del ruolo appropriato per `CUSTOM_ROLE`.
```
# Grant role to user
mysql> GRANT CUSTOM_ROLE TO 'user'@'domain-or-ip-address'
# Check the current roles for your user. In this case, the CUSTOM_ROLE role has not been activated.
# Only the rds_superuser_role is currently in effect.
mysql> SELECT CURRENT_ROLE();
+--------------------------+
| CURRENT_ROLE() |
+--------------------------+
| `rds_superuser_role`@`%` |
+--------------------------+
1 row in set (0.00 sec)
# Activate all roles associated with this user using SET ROLE.
# You can activate specific roles or all roles.
# In this case, the user only has 2 roles, so we specify ALL.
mysql> SET ROLE ALL;
Query OK, 0 rows affected (0.00 sec)
# Verify role is now active
mysql> SELECT CURRENT_ROLE();
+--------------------------------------------------+
| CURRENT_ROLE() |
+--------------------------------------------------+
| `CUSTOM_ROLE`@`%`,`rds_superuser_role`@`%` |
+--------------------------------------------------+
```
# Privilegi dinamici per RDS per MySQL
I privilegi dinamici sono privilegi MySQL che è possibile concedere esplicitamente utilizzando l’istruzione `GRANT`. A seconda della versione di RDS per MySQL, RDS consente di concedere solo privilegi dinamici specifici. RDS non consente alcuni di questi privilegi perché possono interferire con determinate operazioni del database, come la replica e il backup.
La tabella seguente mostra quali di questi privilegi è possibile concedere a diverse versioni di MySQL. Se esegui l’aggiornamento da una versione di MySQL precedente alla 8.0.36 o successiva, potrebbe essere necessario aggiornare il codice dell’applicazione se non è più consentito concedere un particolare privilegio.
| Privilegio | MySQL 8.0.35 e versioni precedenti | MySQL 8.0.36 e versioni secondarie successive | MySQL 8.4.3 e versioni successive |
| --- | --- | --- | --- |
| [ALLOW\$1NONEXISTENT\$1DEFINER](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_allow-nonexistent-definer) | Non disponibile | Non disponibile | Non consentito |
| [APPLICATION\$1PASSWORD\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_application-password-admin) | Consentito | Consentito | Consentito |
| [AUDIT\$1ABORT\$1EXEMPT](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_audit-abort-exempt) | Consentito | Non consentito | Non consentito |
| [AUDIT\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_audit-admin) | Non consentito | Non consentito | Non consentito |
| [AUTHENTICATION\$1POLICY\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_authentication-policy-admin) | Consentito | Non consentito | Non consentito |
| [BACKUP\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_backup-admin) | Consentito | Non consentito | Non consentito |
| [BINLOG\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_binlog-admin) | Consentito | Non consentito | Non consentito |
| [BINLOG\$1ENCRYPTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_binlog-encryption-admin) | Non consentito | Non consentito | Non consentito |
| [CLONE\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_clone-admin) | Non consentito | Non consentito | Non consentito |
| [CONNECTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_connection-admin) | Consentito | Non consentito | Non consentito |
| [ENCRYPTION\$1KEY\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_encryption-key-admin) | Non consentito | Non consentito | Non consentito |
| [FIREWALL\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_firewall-admin) | Non consentito | Non consentito | Non consentito |
| [FIREWALL\$1EXEMPT](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_firewall-exempt) | Consentito | Non consentito | Non consentito |
| [FIREWALL\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_firewall-user) | Non consentito | Non consentito | Non consentito |
| [FLUSH\$1OPTIMIZER\$1COSTS](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-optimizer-costs) | Consentito | Consentito | Consentito |
| [FLUSH\$1PRIVILEGI](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_flush-privileges) | Non disponibile | Non disponibile | Consentito |
| [FLUSH\$1STATUS](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-status) | Consentito | Consentito | Consentito |
| [FLUSH\$1TABLES](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-tables) | Consentito | Consentito | Consentito |
| [FLUSH\$1USER\$1RESOURCES](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-user-resources) | Consentito | Consentito | Consentito |
| [ADMIN DI REPLICA DI GRUPPO](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_group-replication-admin) | Non consentito | Non consentito | Non consentito |
| [GROUP\$1REPLICATION\$1STREAM](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_group-replication-stream) | Non consentito | Non consentito | Non consentito |
| [INNODB\$1REDO\$1LOG\$1ARCHIVE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_innodb-redo-log-archive) | Non consentito | Non consentito | Non consentito |
| [INNODB\$1REDO\$1LOG\$1ENABLE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_innodb-redo-log-enable) | Non consentito | Non consentito | Non consentito |
| [MASKING\$1DICTIONARIES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_masking-dictionaries-admin) | Non consentito | Non consentito | Non consentito |
| [NDB\$1STORED\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_ndb-stored-user) | Non consentito | Non consentito | Non consentito |
| [OPTIMIZE\$1LOCAL\$1TABLE](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_optimize-local-table) | Non disponibile | Non disponibile | Non consentito |
| [PASSWORDLESS\$1USER\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_passwordless-user-admin) | Non consentito | Non consentito | Non consentito |
| [PERSIST\$1RO\$1VARIABLES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_persist-ro-variables-admin) | Non consentito | Non consentito | Non consentito |
| [REPLICATION\$1APPLIER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_replication-applier) | Consentito | Non consentito | Non consentito |
| [REPLICATION\$1SLAVE\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_replication-slave-admin) | Non consentito | Non consentito | Non consentito |
| [RESOURCE\$1GROUP\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_resource-group-admin) | Consentito | Non consentito | Non consentito |
| [RESOURCE\$1GROUP\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_resource-group-user) | Consentito | Non consentito | Non consentito |
| [ROLE\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_role-admin) | Consentito | Consentito | Consentito |
| [SENSITIVE\$1VARIABLES\$1OBSERVER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_sensitive-variables-observer) | Consentito | Consentito | Consentito |
| [SERVICE\$1CONNECTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_service-connection-admin) | Consentito | Non consentito | Non consentito |
| [SESSION\$1VARIABLES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_session-variables-admin) | Consentito | Consentito | Consentito |
| [SET\$1ANY\$1DEFINER](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_set-any-definer) | Non disponibile | Non disponibile | Consentito |
| [IMPOSTA USER\$1ID](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_set-user-id) | Consentito | Consentito | Non disponibile |
| [SHOW\$1ROUTINE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_show-routine) | Consentito | Consentito | Consentito |
| [SKIP\$1QUERY\$1REWRITE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_skip-query-rewrite) | Non consentito | Non consentito | Non consentito |
| [SYSTEM\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_system-user) | Non consentito | Non consentito | Non consentito |
| [SYSTEM\$1VARIABLES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_system-variables-admin) | Non consentito | Non consentito | Non consentito |
| [TABLE\$1ENCRYPTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_table-encryption-admin) | Non consentito | Non consentito | Non consentito |
| [TELEMETRY\$1LOG\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_telemetry-log-admin) | Consentito | Non consentito | Non consentito |
| [TP\$1CONNECTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_tp-connection-admin) | Non consentito | Non consentito | Non consentito |
| [TRANSACTION\$1GTID\$1TAG](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_transaction-gtid-tag) | Non disponibile | Non disponibile | Non consentito |
| [VERSION\$1TOKEN\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_version-token-admin) | Non consentito | Non consentito | Non consentito |
| [XA\$1RECOVER\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_xa-recover-admin) | Consentito | Consentito | Consentito |
# Termine di una sessione o una query per RDS per MySQL
Puoi terminare query o sessioni utente sulle istanze database utilizzando i comandi `rds_kill` e `rds_kill_query`. Connettiti alla tua istanza database MySQL, quindi immetti il comando appropriato come mostrato di seguito. Per ulteriori informazioni, consulta [Connessione all’istanza database MySQL](USER_ConnectToInstance.md).
```
CALL mysql.rds_kill(thread-ID)
CALL mysql.rds_kill_query(thread-ID)
```
Ad esempio, per terminare la sessione in esecuzione sul thread 99, dovresti digitare:
```
CALL mysql.rds_kill(99);
```
Per terminare la query in esecuzione sul thread 99, dovresti digitare:
```
CALL mysql.rds_kill_query(99);
```
# Ignorare l’errore di replica corrente per RDS per MySQL
È possibile ignorare un errore sulle repliche di lettura se l'errore provoca il blocco della replica di lettura e non compromette l'integrità dei dati.
**Nota**
Dovrai prima verificare che sia sicuro ignorare l'errore. In una utility MySQL, connettiti alla replica di lettura ed esegui il seguente comando MySQL.
```
SHOW REPLICA STATUS\G
```
Per informazioni sui valori restituiti, vedere [la documentazione di MySQL](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html).
Le versioni precedenti di MySQL utilizzavano `SHOW SLAVE STATUS` anziché `SHOW REPLICA STATUS`. Se si utilizza una versione MySQL prima della 8.0.23, utilizzare `SHOW SLAVE STATUS`.
È possibile saltare un errore nella replica di lettura nei seguenti modi.
**Topics**
+ [
## Chiamata della procedura mysql.rds\$1skip\$1repl\$1error
](#Appendix.MySQL.CommonDBATasks.SkipError.procedure)
+ [
## Impostazione del parametro slave\$1skip\$1errors
](#Appendix.MySQL.CommonDBATasks.SkipError.parameter)
## Chiamata della procedura mysql.rds\$1skip\$1repl\$1error
Amazon RDS fornisce una stored procedure che puoi chiamare per saltare un errore nelle repliche di lettura. In primo luogo, collegati alla replica di lettura, quindi emetti i comandi appropriati come mostrato qui di seguito. Per ulteriori informazioni, consulta [Connessione all’istanza database MySQL](USER_ConnectToInstance.md).
Per ignorare l'errore, puoi emettere il seguente comando.
```
CALL mysql.rds_skip_repl_error;
```
Questo comando non ha alcun effetto se lo esegui sull'istanza database di origine o in una replica di lettura che non ha riscontrato un errore di replica.
Per ulteriori informazioni, ad esempio per conoscere le versioni di MySQL che supportano `mysql.rds_skip_repl_error`, consulta [mysql.rds\$1skip\$1repl\$1error](mysql-stored-proc-replicating.md#mysql_rds_skip_repl_error).
**Importante**
Se tenti di chiamare `mysql.rds_skip_repl_error` e incontri questo errore: `ERROR 1305 (42000): PROCEDURE mysql.rds_skip_repl_error does not exist`, aggiorna l’istanza database MySQL alla versione secondaria più recente o a una delle versioni secondarie minime indicate in [mysql.rds\$1skip\$1repl\$1error](mysql-stored-proc-replicating.md#mysql_rds_skip_repl_error).
## Impostazione del parametro slave\$1skip\$1errors
Per saltare uno o più errori, puoi impostare il parametro statico `slave_skip_errors` sulla replica di lettura. Puoi impostare questo parametro per saltare uno o più codici di errore di replica specifici. Attualmente, puoi impostare questo parametro solo per le istanze DB per RDS for MySQL 5.7. Dopo aver modificato l'impostazione per questo parametro, accertati di riavviare l'istanza database per rendere effettiva la nuova impostazione. Per ulteriori informazioni su questo parametro, consulta la [documentazione di MySQL](https://dev.mysql.com/doc/refman/5.7/en/replication-options-replica.html#sysvar_slave_skip_errors).
Consigliamo di impostare questo parametro in un gruppo di parametri database a parte. Puoi associare questo gruppo di parametri database solo alle repliche di lettura che devono saltare gli errori. Seguendo questa best practice riduci il potenziale impatto su altre istanze database e sulle repliche di lettura.
**Importante**
L'impostazione di un valore non predefinito per questo parametro può causare incoerenza nella replica. Impostare questo parametro su un valore non predefinito solo se sono state esaurite le altre opzioni per risolvere il problema e si è sicuri del potenziale impatto sui dati della replica di lettura.
# Lavorare con i tablespace InnoDB per migliorare i tempi di ripristino dopo un arresto anomalo per RDS per MySQL
Ogni tabella in MySQL è formata da una definizione della tabella, dati e indici. Il motore di storage InnoDB MySQL salva gli indici e i dati della tabella in un *tablespace*. InnoDB crea un tablespace globale condiviso che contiene un dizionario di dati e altri metadati rilevanti e che può inoltre contenere indici e dati della tabella. InnoDB può anche creare degli spazi tabella per ciascuna tabella e partizione. Questi spazi tabella separati vengono salvati in file con estensione .ibd e l'intestazione di ciascuno spazio tabella contiene un numero identificativo univoco.
Amazon RDS fornisce un parametro in un gruppo di parametri MySQL denominato `innodb_file_per_table`. Questo parametro controlla se InnoDB aggiunge nuovi dati e indici di tabella allo spazio di tabella condiviso (impostando il valore del parametro su 0) o a singoli spazi di tabella (impostando il valore del parametro su 1). Amazon RDS imposta il valore predefinito per il parametro `innodb_file_per_table` su 1, che consente di eliminare singole tabelle InnoDB e recuperare l'archiviazione utilizzata da tali tabelle per l'istanza database. Nella maggior parte dei casi d'uso l'impostazione del parametro `innodb_file_per_table` su 1 rappresenta l'opzione consigliata.
Dovresti impostare il parametro `innodb_file_per_table` su 0 quando hai un numero elevato di tabelle, ad esempio oltre 1.000 tabelle quando utilizzi lo storage standard (magnetico) o lo storage General Purpose SSD oppure oltre 10.000 tabelle quando utilizzi lo storage Provisioned IOPS Quando imposti questo parametro su 0, non vengono creati singoli spazi tabella, pertanto il ripristino dopo un arresto anomalo del database viene completato in minor tempo.
MySQL elabora ciascun file dei metadati, che include spazi tabella durante il ciclo di recupero dopo un arresto anomalo. Il tempo richiesto da MySQL per elaborare le informazioni dei metadati negli spazi tabella condivisi è trascurabile rispetto al tempo necessario per elaborare migliaia di file di spazi tabella quando sono presenti più spazi tabella. Poiché il numero di spazi tabella viene salvato nell'intestazione di ciascun file, il tempo complessivo per leggere tutti i file degli spazi tabella può essere di diverse ore. Ad esempio, per elaborare un milione di spazi tabella InnoDB nello storage standard per un ciclo di ripristino dopo un arresto anomalo potrebbero essere necessarie da cinque a otto ore. In alcuni casi, InnoDB può reputare la necessità di una pulizia aggiuntiva dopo un ciclo di ripristino dopo un arresto anomalo che attiverà un altro ciclo di ripristino dopo un arresto anomalo, rendendo più lungo il tempo di ripristino. Ricorda che un ciclo di ripristino dopo un arresto anomalo, oltre all'elaborazione delle informazioni degli spazi tabella, implica transazioni di rollback, riparazioni delle pagine non funzionanti e altre operazioni.
Poiché il parametro `innodb_file_per_table` risiede in un gruppo di parametri, puoi cambiare il valore del parametro modificando il gruppo di parametri utilizzato dalla tua istanza database senza riavviarla. Dopo aver cambiato l'impostazione, ad esempio da 1 (per creare tabelle individuali) a 0 (per utilizzare gli spazi tabella condivisi), allo spazio tabella condiviso saranno aggiunte altre tabelle InnoDB, mentre quelle esistenti continueranno ad avere degli spazi tabella individuali. Per spostare una tabella InnoDB in uno spazio tabella condiviso, devi utilizzare il comando `ALTER TABLE`.
## Migrazione di più spazi tabella in uno spazio tabella condiviso
Puoi spostare i metadati di una tabella InnoDB dal loro spazio tabella allo spazio tabella condiviso che ricompilerà i metadati della tabella secondo l'impostazione del parametro `innodb_file_per_table`. Connettiti innanzitutto alla tua istanza database MySQL, quindi utilizza i comandi appropriati come mostrato di seguito. Per ulteriori informazioni, consulta [Connessione all’istanza database MySQL](USER_ConnectToInstance.md).
```
ALTER TABLE table_name ENGINE = InnoDB, ALGORITHM=COPY;
```
Ad esempio, la seguente query restituisce un’istruzione `ALTER TABLE` per ogni tabella InnoDB non presente nel tablespace condiviso.
**Per le istanze database MySQL 5.7:**
```
SELECT CONCAT('ALTER TABLE `',
REPLACE(LEFT(NAME , INSTR((NAME), '/') - 1), '`', '``'), '`.`',
REPLACE(SUBSTR(NAME FROM INSTR(NAME, '/') + 1), '`', '``'), '` ENGINE=InnoDB, ALGORITHM=COPY;') AS Query
FROM INFORMATION_SCHEMA.INNODB_SYS_TABLES
WHERE SPACE <> 0 AND LEFT(NAME, INSTR((NAME), '/') - 1) NOT IN ('mysql','');
```
**Per le istanze database MySQL 8.4 e 8.0:**
```
SELECT CONCAT('ALTER TABLE `',
REPLACE(LEFT(NAME , INSTR((NAME), '/') - 1), '`', '``'), '`.`',
REPLACE(SUBSTR(NAME FROM INSTR(NAME, '/') + 1), '`', '``'), '` ENGINE=InnoDB, ALGORITHM=COPY;') AS Query
FROM INFORMATION_SCHEMA.INNODB_TABLES
WHERE SPACE <> 0 AND LEFT(NAME, INSTR((NAME), '/') - 1) NOT IN ('mysql','');
```
La ricompilazione di una tabella MySQL per spostare i metadati della tabella nel tablespace condiviso richiede uno spazio di archiviazione ulteriore disponibile nell’istanza database. Durante la ricompilazione, la tabella è bloccata e inaccessibile alle query. Per le tabelle di piccole dimensioni o le tabelle a cui non si accede di frequente, questo potrebbe non essere un problema. Per tabelle di grandi dimensioni o tabelle a cui si accede di frequente in un ambiente con molti processi simultanei, puoi ricompilare le tabelle su una replica di lettura.
Puoi creare una replica di lettura e migrare i metadati della tabella nello spazio tabella condiviso sulla replica di lettura. Mentre l'istruzione ALTER TABLE blocca l'accesso sulla replica di lettura, l'istanza database di origine non viene interessata. L'istanza database di origine continuerà a generare i suoi log binari, mentre la replica di lettura sarà in ritardo durante il processo di ricompilazione della tabella. Poiché la ricompilazione richiede spazio di storage aggiuntivo e il file di log di riproduzione può essere di grandi dimensioni, dovresti creare una replica di lettura con uno storage allocato più grande rispetto all'istanza database di origine.
Per creare una replica di lettura e ricompilare le tabelle InnoDB per utilizzare lo spazio tabella condiviso, procedere come indicato di seguito:
1. Assicurarsi che la retention dei backup sia abilitata sull'istanza database di origine in modo che sia abilitato il log binario.
1. Usa Console di gestione AWS o AWS CLI per creare una replica di lettura per l'istanza DB di origine. Poiché la creazione di una replica di lettura richiede molti degli stessi processi di un ripristino dopo un arresto anomalo, il processo di creazione potrebbe richiedere diverso tempo se sono presenti numerosi spazi tabella InnoDB. Allocare più spazio di storage sulla replica di lettura rispetto a quello attualmente utilizzato sull'istanza database.
1. Una volta creata la replica di lettura, creare un gruppo di parametri con le impostazioni dei parametri `read_only = 0` e `innodb_file_per_table = 0`. Quindi, associare il gruppo di parametri alla replica di lettura.
1. Immettere la seguente istruzione SQL per tutte le tabelle di cui si desidera eseguire la migrazione nella replica:
```
ALTER TABLE name ENGINE = InnoDB
```
1. Quando tutte le istruzioni `ALTER TABLE` sono state completate sulla replica di lettura, verificare che quest'ultima sia connessa all'istanza database di origine e che le due istanze siano sincronizzate.
1. Utilizzare la console o la CLI per promuovere la replica di lettura a istanza. Assicurarsi che il gruppo di parametri utilizzato per la nuova istanza DB standalone abbia il parametro `innodb_file_per_table` impostato su 0. Modificare il nome della nuova istanza DB standalone e puntare tutte le applicazioni alla nuova istanza DB standalone.
# Gestione della cronologia dello stato globale per RDS per MySQL
**Suggerimento**
Per analizzare le prestazioni del database, puoi anche utilizzare la funzionalità Approfondimenti sulle prestazioni su Amazon RDS. Per ulteriori informazioni, consulta [Monitoraggio del carico DB con Performance Insights su Amazon RDS](USER_PerfInsights.md).
MySQL mantiene molte variabili di stato che forniscono informazioni sul suo funzionamento. Il loro valore può aiutarti a rilevare problemi di blocco o di memoria su un'istanza database. I valori di queste variabili di stato sono cumulativi dal momento dell'ultimo avvio dell'istanza database. Puoi reimpostare la maggiore parte delle variabili di stato su 0 utilizzando il comando `FLUSH STATUS`.
Per consentire il monitoraggio di questi valori nel tempo, Amazon RDS fornisce un insieme di procedure che effettuano una snapshot dei valori di queste variabili di stato nel tempo e li scrivono su una tabella insieme alle modifiche eseguite dall'ultima snapshot. Questa infrastruttura, denominata GoSH (Global Status History, cronologia di stato globale), viene installata in tutte le istanze database MySQL a partire dalle versioni 5.5.23. La funzione GoSH è disabilitata per impostazione predefinita.
Per abilitare la funzione GoSH dovrai prima abilitare il pianificatore di eventi da un gruppo di parametri database impostando il parametro `event_scheduler` su `ON`. Anche per le istanze database MySQL su cui è in esecuzione MySQL 5.7, imposta il parametro `show_compatibility_56` su `1`. Per informazioni sulla creazione e la modifica di un gruppo di parametri database, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md). Per informazioni sugli effetti collaterali dell'abilitazione di questo parametro, consulta [show\$1compatibility\$156](https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_show_compatibility_56) nel *Manuale di riferimento di MySQL 5.7*.
Puoi utilizzare le procedure riportate nella seguente tabella per abilitare e configurare la funzione GoSH. Connettiti innanzitutto alla tua istanza database MySQL, quindi utilizza i comandi appropriati come mostrato di seguito. Per ulteriori informazioni, consulta [Connessione all’istanza database MySQL](USER_ConnectToInstance.md). Per ogni procedura, esegui il comando seguente e sostituisci **procedure-name**:
```
CALL procedure-name;
```
Nella tabella seguente sono elencate tutte le procedure che è possibile utilizzare **procedure-name**nel comando precedente.
| Procedura | Descrizione |
| --- | --- |
| `mysql.rds_enable_gsh_collector` | Abilita la funzione GoSH per acquisire le snapshot per impostazione predefinita a intervalli specificati da `rds_set_gsh_collector`. |
| `mysql.rds_set_gsh_collector` | Specifica l'intervallo, in minuti, tra gli snapshot. Il valore predefinito è 5. |
| `mysql.rds_disable_gsh_collector` | Disabilita gli snapshot. |
| `mysql.rds_collect_global_status_history` | Acquisisce una snapshot a richiesta. |
| `mysql.rds_enable_gsh_rotation` | Abilita la rotazione dei contenuti della tabella `mysql.rds_global_status_history` su `mysql.rds_global_status_history_old` a intervalli specificati da `rds_set_gsh_rotation`. |
| `mysql.rds_set_gsh_rotation` | Specifica l'intervallo, in giorni, tra le conversioni delle tabelle. Il valore predefinito è 7. |
| `mysql.rds_disable_gsh_rotation` | Disabilita la rotazione delle tabelle. |
| `mysql.rds_rotate_global_status_history` | Ruota i contenuti della tabella `mysql.rds_global_status_history` su `mysql.rds_global_status_history_old` a richiesta. |
Quando la funzione GoSH è in esecuzione, puoi inviare query alle tabelle su cui viene completata la scrittura. Ad esempio, per inviare una query per il numero di riscontri del buffer pool InnoDB, dovresti inviare la seguente query:
```
select a.collection_end, a.collection_start, (( a.variable_Delta-b.variable_delta)/a.variable_delta)*100 as "HitRatio"
from mysql.rds_global_status_history as a join mysql.rds_global_status_history as b on a.collection_end = b.collection_end
where a. variable_name = 'Innodb_buffer_pool_read_requests' and b.variable_name = 'Innodb_buffer_pool_reads'
```
# Configurazione delle dimensioni del pool di buffer e della capacità dei log di redo in MySQL 8.4
In MySQL 8.4, Amazon RDS abilita il parametro `innodb_dedicated_server` per impostazione predefinita. Con il parametro `innodb_dedicated_server`, il motore del database calcola i parametri `innodb_buffer_pool_size` e `innodb_redo_log_capacity`. Per informazioni su come vengono calcolati questi parametri, consulta [Configuring InnoDB Buffer Pool Size](https://dev.mysql.com/doc/refman/8.4/en/innodb-buffer-pool-resize.html) e [Redo Log](https://dev.mysql.com/doc/refman/8.4/en/innodb-redo-log.html) nella documentazione MySQL.
Se è abilitato `innodb_dedicated_server`, il parametro `innodb_buffer_pool_size` viene calcolato in base alla memoria per la classe di istanza database. La tabella seguente mostra la memoria del server rilevata e le dimensioni del pool di buffer corrispondente.
| Memoria del server rilevata | Dimensioni del pool di buffer |
| --- | --- |
| < 1 GB | Valore predefinito di 128 MB |
| Da 1 GB a 4 GB | *Detected server memory*\$1 0,5 |
| > 4 GB | *Detected server memory*\$1 0,75 |
Il `innodb_redo_log_capacity` parametro viene ridimensionato automaticamente in base alla classe di istanza fino a (numero di CPUs v/ 2) GB fino a un massimo di 16 GB. Le classi delle istanze più grandi hanno una maggiore capacità di log di redo, che può migliorare le prestazioni e la resilienza per carichi di lavoro ad alta intensità di scrittura.
Prima di effettuare l’aggiornamento da MySQL 8.0 a MySQL 8.4, assicurati di aumentare lo spazio di archiviazione per far fronte a un potenziale aumento delle dimensioni dei log di redo che potrebbe verificarsi dopo il completamento dell’aggiornamento. Per ulteriori informazioni, consulta [Aumento della capacità di storage dell'istanza database](USER_PIOPS.ModifyingExisting.md).
Se non desideri che il parametro `innodb_dedicated_server` calcoli i valori per i parametri `innodb_buffer_pool_size` e `innodb_redo_log_capacity`, puoi sovrascrivere questi valori impostando valori specifici per essi in un gruppo di parametri personalizzato. In alternativa, puoi disabilitare il parametro `innodb_dedicated_server` e impostare i valori per i parametri `innodb_buffer_pool_size` e `innodb_redo_log_capacity` in un gruppo di parametri personalizzato. Per ulteriori informazioni, consulta [Gruppi di parametri predefiniti e personalizzati](parameter-groups-overview.md#parameter-groups-overview.custom).
Se disabiliti il parametro `innodb_dedicated_server` impostandolo su `0` e non imposti valori per i parametri `innodb_buffer_pool_size` e `innodb_redo_log_capacity`, Amazon RDS imposta gli ultimi due parametri rispettivamente su 128 MB e 100 MB. Con queste impostazioni predefinite si può riscontrare una riduzione delle prestazioni sulle classi di istanze più grandi.