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à.
# Backup, ripristino ed esportazione dei dati
Questa sezione illustra come eseguire il backup, il ripristino e l’esportazione dei dati da un’istanza database Amazon RDS o un cluster di database Multi-AZ.
Per informazioni sul backup dell’istanza database Amazon RDS o di un cluster di database Multi-AZ, fai riferimento agli argomenti indicati di seguito.
+ [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md)
+ [Gestione dei backup automatizzati](USER_ManagingAutomatedBackups.md)
+ [Gestione dei backup manuali](USER_ManagingManualBackups.md)
Per informazioni sul ripristino dell’istanza database Amazon RDS o di un cluster di database Multi-AZ, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
Per informazioni sulla copia, la condivisione o l’esportazione di snapshot di database, consulta i seguenti argomenti.
+ [Copia di uno snapshot del database per Amazon RDS](USER_CopySnapshot.md)
+ [Condivisione di uno snapshot DB per Amazon RDS](USER_ShareSnapshot.md)
+ [Supporto per l’esportazione di dati dello snapshot del database in Amazon S3 per Amazon RDS](USER_ExportSnapshot.md)
Per informazioni sulla visualizzazione di backup automatici gestiti da AWS Backup, consulta [Utilizzo di AWS Backup per gestire backup automatizzati per Amazon RDS](AutomatedBackups.AWSBackup.md).
# Introduzione ai backup
Amazon RDS crea e salva i backup automatici dell'istanza database o del cluster database Multi-AZ durante la finestra di backup dell'istanza database. RDS crea uno snapshot dei volumi di storage dell'istanza database, eseguendo il backup dell'intera istanza database anziché dei singoli database. RDS salva i backup automatici dell'istanza database in base al periodo di retention dei backup specificato. Se necessario, è possibile ripristinare l'istanza database a uno specifico momento durante il periodo di conservazione dei backup.
I backup automatici seguono queste regole:
+ La tua istanza database deve essere nello stato `available` per effettuare i backup automatici. I backup automatici non si verificano mentre l'istanza database è in uno stato diverso da `available`, ad esempio, `storage_full`.
+ I backup automatici non si verificano quando una copia dello snapshot di database viene eseguita nella stessa Regione AWS per lo stesso database.
Puoi inoltre eseguire il backup dell'istanza database manualmente mediante la creazione di una snapshot DB. Per ulteriori informazioni sulla creazione di uno snapshot di database, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
Le funzionalità di snapshot e backup supportano configurazioni multi-volume. Tutte le operazioni di backup includono sia il volume principale che eventuali volumi di storage aggiuntivi. Le istantanee catturano l'intera configurazione di archiviazione del database. Point-in-timeil ripristino (PITR) funziona su tutti i volumi di archiviazione.
Il primo snapshot di un'istanza database contiene i dati dell'intero database. Gli snapshot successivi dello stesso database sono incrementali, ovvero vengono salvati solo i dati che sono cambiati dal salvataggio dell'ultimo snapshot.
Puoi copiare le snapshot DB automatiche e manuali e condividere le snapshot DB manuali. Per ulteriori informazioni sulla copia di una snapshot DB, consulta [Copia di uno snapshot del database per Amazon RDS](USER_CopySnapshot.md). Per ulteriori informazioni sulla condivisione di una snapshot DB, consulta [Condivisione di uno snapshot DB per Amazon RDS](USER_ShareSnapshot.md).
## Storage di backup
Lo storage di backup Amazon RDS per ciascuna regione Regione AWS è composto da backup automatici e snapshot DB manuali per quella regione. Lo spazio totale di storage di backup è uguale alla somma dello storage di tutti i backup nella regione. Il trasferimento di una snapshot DB in un'altra regione aumenta lo storage di backup nella regione di destinazione. I backup sono archiviati in Amazon S3.
Per ulteriori informazioni sui costi di storage dei backup, consulta [Prezzi di Amazon RDS](https://aws.amazon.com/rds/pricing/).
Se si sceglie di mantenere i backup automatici quando si elimina un'istanza database, i backup automatici vengono salvati per tutto il periodo di conservazione. Se non scegli **Retain automated backups (Mantieni backup automatici)** quando elimini un'istanza database, tutti i backup automatici vengono eliminati con l'istanza database. Dopo che sono stati eliminati, i backup automatici non possono essere ripristinati. Se scegli di fare in modo che Amazon RDS crei una snapshot DB finale prima di eliminare l'istanza database, puoi utilizzarla per ripristinare l'istanza database. In alternativa, puoi utilizzare uno snapshot manuale creato in precedenza. Gli snapshot manuali non vengono eliminati. Puoi avere un massimo di 100 snapshot manuali per regione.
# Gestione dei backup automatizzati
Questa sezione illustra come gestire i backup automatizzati per le istanze database e i cluster di database Multi-AZ.
**Topics**
+ [Backup window (Finestra di backup)](#USER_WorkingWithAutomatedBackups.BackupWindow)
+ [Periodo di conservazione dei backup](USER_WorkingWithAutomatedBackups.BackupRetention.md)
+ [Abilitazione dei backup automatici](USER_WorkingWithAutomatedBackups.Enabling.md)
+ [Mantenimento dei backup automatici](USER_WorkingWithAutomatedBackups.Retaining.md)
+ [Eliminazione dei backup automatici mantenuti](USER_WorkingWithAutomatedBackups-Deleting.md)
+ [Backup automatici con motori di storage MySQL non supportati](Overview.BackupDeviceRestrictions.md)
+ [Backup automatici con motori di storage MariaDB non supportati](Overview.BackupDeviceRestrictionsMariaDB.md)
+ [Replica dei backup automatici su un altro Regione AWS](USER_ReplicateBackups.md)
## Backup window (Finestra di backup)
I backup automatici vengono effettuati quotidianamente durante la finestra di backup scelta. Se il backup richiede più tempo rispetto alla finestra di backup prevista, l'esecuzione continua dopo il termine della finestra finché non viene completata. La finestra di backup non può sovrapporsi con la finestra di manutenzione settimanale per l'istanza database o il cluster di database multi-AZ.
Durante la finestra di backup automatico, lo storage I/O potrebbe essere sospeso brevemente durante l'inizializzazione del processo di backup (in genere entro pochi secondi). Potresti rilevare un aumento della latenza per alcuni minuti durante i backup per le implementazioni Multi-AZ. Per MariaDB, MySQL, Oracle e I/O PostgreSQL, l'attività non viene sospesa sul sistema primario durante il backup per le implementazioni Multi-AZ perché il backup viene eseguito dallo standby. Per SQL Server, I/O l'attività viene sospesa brevemente durante il backup sia per le implementazioni Single-AZ che Multi-AZ perché il backup viene eseguito dalla principale. Per Db2, I/O l'attività viene inoltre sospesa brevemente durante il backup, anche se il backup viene eseguito dalla modalità di standby.
I backup automatici possono occasionalmente essere saltati se l'istanza database o il cluster di database ha un carico di lavoro pesante nel momento in cui deve essere avviato un backup. Se un backup viene saltato, è comunque possibile eseguire un backup point-in-time-recovery (PITR) e il backup viene comunque tentato nella finestra di backup successiva. Per ulteriori informazioni su PITR, consulta [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
Se non specifichi una finestra di backup al momento della creazione dell'istanza database o del cluster di database multi-AZ, Amazon RDS assegna una finestra di backup predefinita di 30 minuti. Questa finestra viene selezionata a caso da un intervallo di tempo di 8 ore per ciascuna. Regione AWS La tabella seguente elenca i blocchi temporali per ciascuno Regione AWS a cui sono assegnate le finestre di backup predefinite.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/USER_ManagingAutomatedBackups.html)
# Periodo di conservazione dei backup
È possibile impostare il periodo di conservazione del backup quando si crea o si ripristina un'istanza DB o un cluster DB Multi-AZ. Se crei un'istanza DB utilizzando l'API Amazon RDS o il AWS CLI e se non imposti il periodo di conservazione del backup, il periodo di conservazione del backup predefinito è di un giorno. Se crei un’istanza database utilizzando la console, il periodo di conservazione del backup predefinito è di sette giorni.
Puoi modificare il periodo di conservazione dei backup dopo la creazione di un'istanza database o un cluster di database. È possibile impostare il periodo di conservazione dei backup per un'istanza database su un valore compreso tra 0 e 35 giorni. Impostando il periodo di retention dei backup su 0, i backup automatici vengono disabilitati. Per un cluster di database Multi-AZ, è possibile impostare il periodo di conservazione del backup su un valore compreso tra 1 e 35 giorni. I limiti degli snapshot manuali (100 per ogni regione) non si applicano ai backup automatici.
Durante le operazioni di ripristino, hai la possibilità di specificare un periodo di conservazione dei backup per l'istanza DB o il cluster DB Multi-AZ. Quando non si imposta esplicitamente questo valore, il database ripristinato eredita il periodo di conservazione del backup dallo snapshot o dall'istanza di origine. Tieni presente che questo comportamento di ereditarietà è unico per le operazioni di ripristino: quando si crea un nuovo database, il sistema applica invece periodi di conservazione predefiniti.
**Importante**
Se modifichi il periodo di conservazione del backup di un’istanza database da zero a un valore diverso da zero o viceversa, si verifica un’interruzione del servizio.
RDS non include il tempo trascorso nello stato `stopped` quando viene calcolato il periodo di conservazione del backup. I backup automatici non vengono creati mentre un'istanza database o un cluster di database viene arrestato. I backup possono essere conservati più a lungo del periodo di conservazione del backup se un'istanza database è stata arrestata.
# Abilitazione dei backup automatici
Se i backup automatici non sono abilitati per l'istanza database, puoi abilitarli in qualsiasi momento. Per abilitare i backup automatici, impostare il periodo di conservazione dei backup su un valore diverso da zero positivo. Quando i backup automatici vengono attivati, l'istanza database viene portata offline e un backup viene creato immediatamente.
**Nota**
Se gestisci i backup in AWS Backup, non puoi abilitare i backup automatici. Per ulteriori informazioni, consulta [Utilizzo di AWS Backup per gestire backup automatizzati per Amazon RDS](AutomatedBackups.AWSBackup.md).
## Console
**Per abilitare immediatamente i backup automatici**
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, scegli **Database**, quindi scegli l'istanza database o il cluster di database multi-AZ che vuoi modificare.
1. Scegli **Modifica**.
1. In **Periodo di conservazione dei backup**, scegli un valore positivo diverso da zero, ad esempio tre giorni.
1. Scegli **Continue (Continua)**.
1. Scegliere **Apply immediately** (Applica immediatamente).
1. Scegli **Modifica istanza database** o **Modifica cluster** per salvare le modifiche e abilitare i backup automatici.
## AWS CLI
Per abilitare i backup automatici, usa il comando AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)or [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html).
Includere i seguenti parametri:
+ `--db-instance-identifier` (o `--db-cluster-identifier` per un cluster di database multi-AZ)
+ `--backup-retention-period`
+ `--apply-immediately` o `--no-apply-immediately`
In questo esempio vengono abilitati i backup automatici impostando il periodo di conservazione dei backup su tre giorni. Le modifiche vengono applicate immediatamente.
**Example**
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier my_db_instance \
--backup-retention-period 3 \
--apply-immediately
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier my_db_instance ^
--backup-retention-period 3 ^
--apply-immediately
```
## API RDS
Per abilitare i backup automatici, utilizza l'DBClusteroperazione [[Modifica DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) o modifica](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) dell'API RDS con i seguenti parametri richiesti:
+ `DBInstanceIdentifier` o `DBClusterIdentifier`
+ `BackupRetentionPeriod`
## Visualizzazione dei backup automatici
Per visualizzare i backup automatici conservati, scegli **Backup automatici** nel pannello di navigazione, quindi scegli Mantenuti. Per visualizzare singoli snapshot associati a un backup automatico mantenuto, scegli **Snapshot** nel pannello di navigazione. In alternativa, puoi descrivere singoli snapshot associati a un backup automatico mantenuto. Da qui, puoi ripristinare un’istanza database direttamente da uno di tali snapshot.
I nomi degli snapshot automatici seguono il modello `rds:-yyyy-mm-dd-hh-mm`, con `yyyy-mm-dd-hh-mm` che rappresenta la data e l’ora di creazione dello snapshot.
Per descrivere i backup automatici per le istanze DB esistenti utilizzando il AWS CLI, utilizza uno dei seguenti comandi:
```
aws rds describe-db-instance-automated-backups --db-instance-identifier DBInstanceIdentifier
```
or
```
aws rds describe-db-instance-automated-backups --dbi-resource-id DbiResourceId
```
Per descrivere i backup automatici mantenuti tramite l'API RDS, chiama l'operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstanceAutomatedBackups.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstanceAutomatedBackups.html) con uno dei seguenti parametri:
+ `DBInstanceIdentifier`
+ `DbiResourceId`
# Mantenimento dei backup automatici
**Nota**
È possibile mantenere solo i backup automatici delle istanza database, non dei cluster di database multi-AZ.
Puoi scegliere di mantenere i backup automatici quando elimini un'istanza DB. I backup automatici possono essere mantenuti per il numero di giorni configurato per il periodo di conservazione dei backup sull'istanza database al momento della sua eliminazione.
I backup automatici mantenuti contengono snapshot di sistema e log delle transazioni di un'istanza database. Includono anche proprietà dell'istanza database come archiviazione allocata e classe di istanza database, che sono richieste per eseguire il ripristino in un'istanza attiva.
I backup automatici conservati e le istantanee manuali comportano costi di fatturazione fino alla loro eliminazione. Per ulteriori informazioni, consulta [Costi di retention](#USER_WorkingWithAutomatedBackups.RetentionCosts).
Puoi mantenere i backup automatici per istanze RDS che eseguono i motori Db2, MariaDB, MySQL, PostgreSQL, Oracle e Microsoft SQL Server.
Puoi ripristinare o rimuovere i backup automatici mantenuti tramite la Console di gestione AWS, l'API RDS e AWS CLI.
**Topics**
+ [Periodo di conservazione](#USER_WorkingWithAutomatedBackups.RetentionPeriods)
+ [Visualizzazione dei backup conservati](#USER_WorkingWithAutomatedBackups.viewing-retained)
+ [Ripristino](#USER_WorkingWithAutomatedBackups.Restoration)
+ [Costi di retention](#USER_WorkingWithAutomatedBackups.RetentionCosts)
+ [Limitazioni](#USER_WorkingWithAutomatedBackups.Limits)
## Periodo di conservazione
Gli snapshot di sistema e i log delle transazioni di un backup automatico mantenuto scadono allo stesso modo dell'istanza database di origine. Poiché non esistono nuovi snapshot o log creati per questa istanza, i backup automatici mantenuti scadono alla fine completamente. Di fatto, continuano a esistere fino al termine del loro ultimo snapshot di sistema, in base alle impostazioni del periodo di retention per l'istanza di origine al momento dell'eliminazione. I backup automatici mantenuti vengono rimossi dal sistema dopo che il loro ultimo snapshot di sistema è scaduto.
Puoi rimuovere un backup automatico mantenuto nello stesso modo con cui elimini un'istanza database. Puoi rimuovere backup automatici mantenuti utilizzando la console o l'operazione API RDS `DeleteDBInstanceAutomatedBackup`.
Gli snapshot finali sono indipendenti dai backup automatici mantenuti. Ti suggeriamo di acquisire uno snapshot finale anche se mantieni i backup automatici in quanto prima o poi scadono. Lo snapshot finale non scade.
## Visualizzazione dei backup conservati
Per visualizzare i backup automatici conservati, scegli **Backup automatici** nel pannello di navigazione, quindi scegli **Mantenuti**. Per visualizzare singoli snapshot associati a un backup automatico mantenuto, scegli **Snapshot** nel pannello di navigazione. In alternativa, puoi descrivere singoli snapshot associati a un backup automatico mantenuto. Da qui, puoi ripristinare un’istanza database direttamente da uno di tali snapshot.
Per descrivere i backup automatizzati conservati utilizzando il AWS CLI, utilizza uno dei seguenti comandi:
```
aws rds describe-db-instance-automated-backups --dbi-resource-id DbiResourceId
```
Per descrivere i backup automatici mantenuti tramite l'API RDS, chiama l'operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstanceAutomatedBackups.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstanceAutomatedBackups.html) con il parametro `DbiResourceId`.
## Ripristino
Per informazioni sul ripristino di istanze database dai backup automatici, consulta [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
## Costi di retention
Il costo di un backup automatico mantenuto è il costo di storage totale degli snapshot di sistema ad esso associati. Non sono previsti costi aggiuntivi per i log delle transazioni o i metadati dell'istanza. Tutte le altre regole di prezzo per i backup si applicano alle istanze ripristinabili.
Ad esempio, supponiamo che lo storage allocato totale di istanze in esecuzione sia 100 GB. Supponiamo anche di avere 50 GB di snapshot manuali più 75 GB di snapshot di sistema associate a un backup automatico mantenuto. In questo caso, vengono addebitati solo i 25 GB aggiuntivi di storage di backup, come riportato di seguito: (50 GB \$1 75 GB) – 100 GB = 25 GB.
## Limitazioni
Le seguenti limitazioni si applicano ai backup automatici mantenuti:
+ Il numero massimo di backup automatici mantenuti in una regione AWS è pari a 40. Non è incluso nella quota di istanze database. Possono esserci contemporaneamente 40 istanze database in esecuzione e 40 backup automatici mantenuti aggiuntivi.
+ I backup automatici mantenuti non contengono informazioni relative ai parametri o ai gruppi di opzioni.
+ È possibile ripristinare un'istanza eliminata a un punto temporale che si trova all'interno del periodo di conservazione al momento dell'eliminazione.
+ Non è possibile modificare un backup automatico conservato. Questo perché è costituito da backup di sistema, log delle transazioni e proprietà dell'istanza database esistenti al momento in cui è stata eliminata l'istanza di origine.
# Eliminazione dei backup automatici mantenuti
Puoi eliminare i backup automatici mantenuti quando non servono più.
## Console
**Per eliminare i backup automatici mantenuti**
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, selezionare **Automated backups (Backup automatici)**.
1. Nella scheda **Conservato** scegli il backup automatico conservato che desideri eliminare.
1. In **Actions (Azioni)**, scegliere **Delete (Elimina)**.
1. Nella pagina di conferma, immetti **delete me** e seleziona **Elimina**.
## AWS CLI
È possibile eliminare un backup automatico conservato usando il comando AWS CLI [delete-db-instance-automated-backup](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance-automated-backup.html) con la seguente opzione:
+ `--dbi-resource-id` – L'identificatore della risorsa per il cluster database.
È possibile trovare identificatore della risorsa per l’istanza DB source di un backup automatico mantenuto eseguendo il comando AWS CLI [describe-db-instance-automated-backups](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instance-automated-backups.html).
**Example**
Il seguente esempio elimina il backup automatico mantenuto con l’identificatore della risorsa di istanza DB source `db-123ABCEXAMPLE`.
Per Linux, macOS o Unix:
```
1. aws rds delete-db-instance-automated-backup \
2. --dbi-resource-id db-123ABCEXAMPLE
```
Per Windows:
```
1. aws rds delete-db-instance-automated-backup ^
2. --dbi-resource-id db-123ABCEXAMPLE
```
## API RDS
Puoi eliminare un backup automatico conservato usando l’operazione API Amazon RDS [delete-db-instance-automated-backup](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteDBInstanceAutomatedBackup.html) con il seguente parametro:
+ `DbiResourceId` – L'identificatore della risorsa per il cluster database.
È possibile trovare l'identificatore della risorsa per l'istanza database source di un backup automatico mantenuto usando l'operazione API Amazon RDS [DescribeDBInstanceAutomatedBackups](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstanceAutomatedBackups.html).
## Disabilitazione dei backup automatici
In alcuni casi, potrebbe essere necessario disabilitare temporaneamente i backup automatici; ad esempio, durante il caricamento di grandi quantità di dati.
**Importante**
Sconsigliamo vivamente la disabilitazione dei backup automatici perché comporta la disabilitazione del ripristino point-in-time. La disabilitazione dei backup automatici per un'istanza database o un cluster di database multi-AZ elimina tutti i backup automatici esistenti per il database. Se disattivi e poi riattivi i backup automatici, potrai poi ripristinarli solo dal momento in cui sono stati riattivati.
### Console
**Per disabilitare immediatamente i backup automatici**
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 pannello di navigazione, scegli **Database**, quindi scegli l'istanza database o il cluster di database multi-AZ che vuoi modificare.
1. Scegliere **Modify (Modifica)**.
1. Per **Periodo di retention dei backup**, seleziona **0 giorni**.
1. Scegli **Continue (Continua)**.
1. Scegliere **Apply immediately** (Applica immediatamente).
1. Scegli **Modifica istanza database** o **Modifica cluster** per salvare le modifiche e disabilitare i backup automatici.
### AWS CLI
Per disabilitare immediatamente i backup automatici, utilizza il comando [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) o [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) e imposta il periodo di conservazione dei backup su 0 con `--apply-immediately`.
**Example**
L'esempio seguente disabilita immediatamente i backup automatici su un cluster di database multi-AZ.
Per Linux, macOS o Unix:
```
aws rds modify-db-cluster \
--db-cluster-identifier mydbcluster \
--backup-retention-period 0 \
--apply-immediately
```
Per Windows:
```
aws rds modify-db-cluster ^
--db-cluster-identifier mydbcluster ^
--backup-retention-period 0 ^
--apply-immediately
```
Per sapere quando viene applicata la modifica, chiama `describe-db-instances` per l'istanza database o `describe-db-clusters` per un cluster di database multi-AZ finché il valore del periodo di conservazione dei backup è 0 e lo stato di `mydbcluster` è disponibile.
```
aws rds describe-db-clusters --db-cluster-identifier mydcluster
```
### API RDS
Per disabilitare immediatamente i backup automatici, chiama l'operazione [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) o [ModifyDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) con i seguenti parametri:
+ `DBInstanceIdentifier = mydbinstance` (o `DBClusterIdentifier = mydbcluster`)
+ `BackupRetentionPeriod = 0`
**Example**
```
https://rds.amazonaws.com/
?Action=ModifyDBInstance
&DBInstanceIdentifier=mydbinstance
&BackupRetentionPeriod=0
&SignatureVersion=2
&SignatureMethod=HmacSHA256
&Timestamp=2009-10-14T17%3A48%3A21.746Z
&AWSAccessKeyId=<&AWS; Access Key ID>
&Signature=
```
# Backup automatici con motori di storage MySQL non supportati
Per il motore di database MySQL, i backup automatici sono supportati solo per il motore di storage InnoDB. L'utilizzo di queste caratteristiche con altri motori di archiviazione MySQL, incluso MyISAM, può causare un comportamento inaffidabile durante il ripristino dai backup. Nello specifico, poiché i motori di storage come MyISAM non supportano il ripristino da arresto anomalo affidabile, è possibile che le tabelle vengano danneggiate in caso di arresto anomalo. Per questo, ti consigliamo di utilizzare il motore di storage InnoDB.
+ Per convertire le tabelle MyISAM esistenti in tabelle InnoDB, è possibile utilizzare il comando `ALTER TABLE`, ad esempio: `ALTER TABLE table_name ENGINE=innodb, ALGORITHM=COPY;`
+ Se si sceglie di utilizzare MyISAM, è possibile tentare di eseguire manualmente il ripristino delle tabelle danneggiate dopo un arresto anomalo utilizzando il comando `REPAIR`. Per ulteriori informazioni, consulta [REPAIR TABLE Statement](https://dev.mysql.com/doc/refman/8.0/en/repair-table.html) nella documentazione MySQL. Come specificato nella documentazione MySQL, è tuttavia molto probabile che non sia possibile recuperare tutti i dati.
+ Per acquisire uno snapshot delle tabelle MyISAM prima del ripristino, procedere nel seguente modo:
1. Arrestare ogni attività sulle tabelle MyISAM (ovvero, chiudere tutte le sessioni).
È possibile chiudere tutte le sessioni chiamando il comando [mysql.rds\$1kill](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.MySQL.CommonDBATasks.html) per ogni processo restituito dal comando `SHOW FULL PROCESSLIST`.
1. Bloccare e svuotare ciascuna tabella MyISAM. Ad esempio, i seguenti comandi bloccano e svuotano le due tabelle denominate `myisam_table1` e `myisam_table2`:
```
mysql> FLUSH TABLES myisam_table, myisam_table2 WITH READ LOCK;
```
1. Crea uno snapshot dell'istanza database o del cluster di database multi-AZ. Quando la snapshot è completata, rilasciare i blocchi e riprendere l'attività sulle tabelle MyISAM. È possibile utilizzare il comando seguente per rilasciare i blocchi sulle tabelle:
```
mysql> UNLOCK TABLES;
```
Queste fasi forzano MyISAM a svuotare i dati archiviati in memoria sul disco, garantendo un avvio pulito quando si esegue il ripristino da uno snapshot DB. Per ulteriori informazioni sulla creazione di una snapshot DB, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
# Backup automatici con motori di storage MariaDB non supportati
Per il motore di database MariaDB, i backup automatici sono supportati solo per il motore di archiviazione InnoDB. L'utilizzo di queste caratteristiche con altri motori di archiviazione MariaDB, incluso Aria, può causare un comportamento inaffidabile durante il ripristino dai backup. Sebbene Aria sia un'alternativa resistente agli arresti anomali a MyISAM, è possibile che le tabelle vengano comunque danneggiate in caso di arresto anomalo. Per questo, ti consigliamo di utilizzare il motore di storage InnoDB.
+ Per convertire le tabelle Aria esistenti in tabelle InnoDB, è possibile utilizzare il comando `ALTER TABLE`. Ad esempio: `ALTER TABLE table_name ENGINE=innodb, ALGORITHM=COPY;`
+ Se si sceglie di utilizzare Aria, è possibile tentare di eseguire manualmente il ripristino delle tabelle danneggiate dopo un arresto anomalo utilizzando il comando `REPAIR TABLE`. Per ulteriori informazioni sugli spazi, consulta [http://mariadb.com/kb/en/mariadb/repair-table/](http://mariadb.com/kb/en/mariadb/repair-table/).
+ Per acquisire uno snapshot delle tabelle Aria prima del ripristino, procedere nel seguente modo:
1. Arrestare ogni attività sulle tabelle Aria (ovvero, chiudere tutte le sessioni).
1. Bloccare e svuotare ciascuna tabella Aria.
1. Crea uno snapshot dell'istanza database o del cluster di database multi-AZ. Quando la snapshot è completata, rilasciare i blocchi e riprendere l'attività sulle tabelle Aria. Queste fasi forzano Aria a svuotare i dati archiviati in memoria sul disco, garantendo un avvio pulito quando si esegue il ripristino da una snapshot DB.
# Replica dei backup automatici su un altro Regione AWS
Per una maggiore capacità di disaster recovery, puoi configurare l'istanza del database Amazon RDS per replicare istantanee e log delle transazioni verso una destinazione Regione AWS a tua scelta. Se per un'istanza database è configurata la replica di backup, RDS avvia una copia tra regioni di tutte le snapshot e i log delle transazioni non appena questi sono pronti nell'istanza database.
Al trasferimento dei dati vengono applicati addebiti per la copia della snapshot DB. Dopo aver copiato la snapshot DB, vengono applicati addebiti standard allo storage nella regione di destinazione. Per maggiori dettagli, consulta [Prezzi di RDS](https://aws.amazon.com/rds/oracle/pricing/).
Per un esempio di utilizzo della replica di backup, consulta il talk tecnico AWS online [Managed Disaster Recovery with Amazon RDS for Oracle Cross-Region](https://pages.awscloud.com/Managed-Disaster-Recovery-with-Amazon-RDS-for-Oracle-Cross-Region-Automated-Backups_2021_0908-DAT_OD.html) Automated Backups.
**Nota**
La replica di backup automatizzata non è supportata per i cluster di database Multi-AZ. Tuttavia, è supportata per le implementazioni di istanze database Multi-AZ. Per ulteriori informazioni sulle limitazioni per i backup automatizzati, consulta [Quote e vincoli per Amazon RDS](CHAP_Limits.md).
Per informazioni sulla configurazione e la gestione dei backup automatizzati per Amazon RDS, consulta gli argomenti riportati di seguito.
**Argomenti**
+ [Abilitazione dei backup automatici tra Regioni per Amazon RDS](AutomatedBackups.Replicating.Enable.md)
+ [Ricerca di informazioni sui backup replicati per Amazon RDS](AutomatedBackups.Replicating.Describe.md)
+ [Ripristino a un’ora specificata da un backup replicato per Amazon RDS](AutomatedBackups.PiTR.md)
+ [Arresto della replica di backup automatici per Amazon RDS](AutomatedBackups.StopReplicating.md)
+ [Eliminazione dei backup replicati per Amazon RDS](AutomatedBackups.Delete.md)
+ [Risoluzione dei problemi relativi ai backup automatici interregionali interrotti](AutomatedXREGBackups.Troubleshooting.md)
## Supporto per l’implementazione Multi-AZ
La replica di backup automatizzata tra regioni è supportata per le implementazioni di istanze DB Multi-AZ per i seguenti motori:
+ RDS per Db2
+ RDS per MariaDB
+ RDS per MySQL
+ RDS per Oracle
+ RDS per PostgreSQL
+ RDS per SQL Server
La replica di backup automatizzata tra Regioni non è supportata per i cluster di database Multi-AZ.
## Disponibilità di regioni e versioni
Il supporto varia a seconda delle versioni specifiche di ciascun motore di database e a seconda delle Regioni AWS. Per ulteriori informazioni sulla disponibilità di versioni e regioni con backup automatici tra regioni, consulta [Regioni e motori di database supportati per i backup automatizzati tra Regioni in Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionAutomatedBackups.md).
## Regione AWS Supporto di origine e destinazione
La replica di Backup è supportata tra i seguenti Regioni AWS.
****
| Regione di origine | Regioni di destinazione disponibili |
| --- | --- |
| Africa (Città del Capo) | Europa (Francoforte), Europa (Irlanda), Europa (Londra) |
| Asia Pacifico (Hong Kong) | Asia Pacifico (Singapore), Asia Pacifico (Tokyo) |
| Asia Pacifico (Hyderabad) | Asia Pacifico (Mumbai) |
| Asia Pacifico (Giacarta) | Asia Pacifico (Malesia), Asia Pacifico (Singapore) |
| Asia Pacifico (Melbourne) | Asia Pacifico (Sydney) |
| Asia Pacifico (Malesia) | Asia Pacifico (Singapore) |
| Asia Pacifico (Mumbai) | Asia Pacifico (Hyderabad), Asia Pacifico (Singapore) Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (Oregon) |
| Asia Pacific (Osaka) | Asia Pacific (Tokyo) |
| Asia Pacific (Seoul) | Asia Pacifico (Singapore), Asia Pacifico (Tokyo) Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (Oregon) |
| Asia Pacifico (Singapore) | Asia Pacifico (Hong Kong), Asia Pacifico (Malaysia), Asia Pacifico (Mumbai), Asia Pacifico (Seoul), Asia Pacifico (Sydney), Asia Pacifico (Tokyo) Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (Oregon) |
| Asia Pacifico (Sydney) | Asia Pacifico (Melbourne), Asia Pacifico (Singapore) Stati Uniti orientali (Virginia settentrionale), Stati Uniti occidentali (California settentrionale), Stati Uniti occidentali (Oregon) |
| Asia Pacifico (Tokyo) | Asia Pacifico (Hong Kong), Asia Pacifico (Osaka), Asia Pacifico (Seoul), Asia Pacifico (Singapore) Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (Oregon) |
| Canada (Centrale) | Canada occidentale (Calgary) Europa (Irlanda) Stati Uniti orientali (Virginia settentrionale), Stati Uniti occidentali (California settentrionale), Stati Uniti occidentali (Oregon) |
| Canada occidentale (Calgary) | Canada (Centrale) |
| Cina (Pechino) | Cina (Ningxia) |
| Cina (Ningxia) | Cina (Pechino) |
| Europa (Francoforte) | Africa (Città del Capo) Europa (Irlanda), Europa (Londra), Europa (Parigi), Europa (Stoccolma), Europa (Zurigo) Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (Oregon) |
| Europa (Irlanda) | Africa (Città del Capo) Canada (Centrale) Europa (Francoforte), Europa (Londra), Europa (Parigi), Europa (Stoccolma), Europa (Zurigo) Stati Uniti orientali (Virginia settentrionale), Stati Uniti occidentali (California settentrionale), Stati Uniti occidentali (Oregon) |
| Europa (Londra) | Africa (Città del Capo) UE (Francoforte), UE (Irlanda), UE (Parigi), UE (Stoccolma) Stati Uniti orientali (Virginia settentrionale) |
| Europa (Milano) | Europa (Francoforte) |
| Europa (Parigi) | UE (Francoforte), UE (Irlanda), UE (Londra), UE (Stoccolma) Stati Uniti orientali (Virginia settentrionale) |
| Europa (Spagna) | Europa (Irlanda), Europa (Parigi) |
| Europa (Stoccolma) | UE (Francoforte), UE (Irlanda), UE (Londra), UE (Parigi) Stati Uniti orientali (Virginia settentrionale) |
| Europa (Zurigo) | UE (Francoforte), UE (Irlanda) |
| Israele (Tel Aviv) | Europa (Irlanda) |
| Medio Oriente (Emirati Arabi Uniti) | Europa (Francoforte) |
| Sud America (San Paolo) | Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio) |
| AWS GovCloud (Stati Uniti orientali) | AWS GovCloud (Stati Uniti occidentali) |
| AWS GovCloud (Stati Uniti occidentali) | AWS GovCloud (Stati Uniti orientali) |
| Stati Uniti orientali (Virginia settentrionale) | Asia Pacifico (Mumbai), Asia Pacifico (Seoul), Asia Pacifico (Singapore), Asia Pacifico (Sydney), Asia Pacifico (Tokyo) Canada (Central) UE (Francoforte), UE (Irlanda), UE (Londra), UE (Parigi), UE (Stoccolma) South America (São Paulo) Stati Uniti orientali (Ohio), Stati Uniti occidentali (California settentrionale), Stati Uniti occidentali (Oregon) |
| US East (Ohio) | Asia Pacifico (Mumbai), Asia Pacifico (Seoul), Asia Pacifico (Singapore), Asia Pacifico (Tokyo) Canada (Central) UE (Francoforte), UE (Irlanda) South America (São Paulo) Stati Uniti orientali (Virginia settentrionale), Stati Uniti occidentali (California settentrionale), Stati Uniti occidentali (Oregon) |
| US West (N. California) | Asia Pacific (Sydney) Canada (Central) Europe (Ireland) Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (Oregon) |
| US West (Oregon) | Asia Pacifico (Mumbai), Asia Pacifico (Seoul), Asia Pacifico (Singapore), Asia Pacifico (Sydney), Asia Pacifico (Tokyo) Canada (Central) UE (Francoforte), UE (Irlanda) Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (California settentrionale) |
Puoi anche usare il `describe-source-regions` AWS CLI comando per scoprire quali Regioni AWS possono replicarsi tra loro. Per ulteriori informazioni, consulta [Ricerca di informazioni sui backup replicati per Amazon RDS](AutomatedBackups.Replicating.Describe.md).
## Limitazioni
Di seguito sono riportate le limitazioni per i backup automatizzati tra Regioni per Amazon RDS.
+ La replica di backup automatizzata non è supportata per i cluster di database Multi-AZ.
+ Per impostazione predefinita, è possibile avere fino a 20 backup automatici interregionali per persona. Account AWS
# Abilitazione dei backup automatici tra Regioni per Amazon RDS
Puoi abilitare la replica di backup su istanze database nuove o esistenti utilizzando la console Amazon RDS. Puoi inoltre utilizzare il comando `start-db-instance-automated-backups-replication` AWS CLI comando o la funzionalità dell’API RDS `StartDBInstanceAutomatedBackupsReplication`. È possibile replicare fino a 20 backup su ciascuna Regione AWS di destinazione di ogni Account AWS.
**Nota**
Per poter replicare i backup automatici, assicurati di attivarli. Per ulteriori informazioni, consulta [Abilitazione dei backup automatici](USER_WorkingWithAutomatedBackups.Enabling.md).
## Console
Puoi abilitare la replica di backup per un'istanza database nuova o esistente:
+ Per una nuova istanza database, abilitarla all'avvio dell'istanza. Per ulteriori informazioni, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
+ Per un'istanza database esistente, completa la procedura descritta di seguito.
**Per abilitare la replica di backup per un'istanza database esistente**
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, selezionare **Automated backups (Backup automatici)**.
1. Nella scheda **Regione corrente** seleziona l'istanza database per cui desideri abilitare la replica di backup.
1. Per **Azioni**, seleziona **Gestisci replica tra regioni**.
1. In **Replica di backup** seleziona **Abilita replica in un'altra Regione AWS**.
1. Seleziona la **regione di destinazione**.
1. Seleziona il **periodo di conservazione del backup replicato**.
1. Se è stata abilitata la crittografia nell’istanza database di origine, scegli la **AWS KMS key** per crittografare i backup o immettere una chiave ARN.
1. Scegli **Save** (Salva).
Nella regione di origine, i backup replicati sono riportati nella scheda **Regione corrente** della pagina **Backup automatici** . Nella regione di destinazione, i backup replicati sono riportati nella scheda **Backup replicati** della pagina **Backup automatici** .
## AWS CLI
Abilita la replica di backup utilizzando il comando [https://docs.aws.amazon.com/cli/latest/reference/rds/start-db-instance-automated-backups-replication.html](https://docs.aws.amazon.com/cli/latest/reference/rds/start-db-instance-automated-backups-replication.html) della AWS CLI.
L'esempio seguente di CLI replica i backup automatici da un'istanza database in Stati Uniti occidentali (Oregon) a della regione Stati Uniti orientali (Virginia settentrionale),. Consente inoltre di crittografare i backup replicati utilizzando una AWS KMS key dal cliente nella Regione di destinazione.
**Per abilitare la replica di backup**
+ Eseguire uno dei seguenti comandi.
Per Linux, macOS o Unix:
```
aws rds start-db-instance-automated-backups-replication \
--region us-east-1 \
--source-db-instance-arn "arn:aws:rds:us-west-2:123456789012:db:mydatabase" \
--kms-key-id "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE" \
--backup-retention-period 7
```
Per Windows:
```
aws rds start-db-instance-automated-backups-replication ^
--region us-east-1 ^
--source-db-instance-arn "arn:aws:rds:us-west-2:123456789012:db:mydatabase" ^
--kms-key-id "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE" ^
--backup-retention-period 7
```
L'opzione `--source-region` è obbligatoria quando si crittografano i backup tra la regione AWS GovCloud (Stati Uniti orientali) e la regione AWS GovCloud (Stati Uniti occidentali). Per `--source-region`, specifica la Regione AWS dell'istanza database di origine.
Se non si specifica `--source-region`, assicurati di specificare un valore per `--pre-signed-url`. Un *URL prefirmato* è un URL che contiene una richiesta firmata Signature Versione 4 per il comando `start-db-instance-automated-backups-replication` chiamato nella Regione AWS di origine. Per ulteriori informazioni sull'opzione `pre-signed-url`, consulta [start-db-instance-automated-backups-replication](https://docs.aws.amazon.com/cli/latest/reference/rds/start-db-instance-automated-backups-replication.html) nella *Riferimento ai comandi AWS CLI*.
## API RDS
Abilita la replica di backup utilizzando la funzionalità dell’API RDS [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StartDBInstanceAutomatedBackupsReplication.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StartDBInstanceAutomatedBackupsReplication.html) con i seguenti parametri:
+ `Region` (se non stai chiamando l’operazione API dalla Regione di destinazione)
+ `SourceDBInstanceArn`
+ `BackupRetentionPeriod`
+ `KmsKeyId` (facoltativo)
+ `PreSignedUrl` (obbligatorio se si utilizza `KmsKeyId`)
**Nota**
Se i backup vanno crittografati, è necessario includere anche un URL prefirmato. Per ulteriori informazioni sugli URL prefirmati, consulta [Richieste di autenticazione: utilizzo di parametri di query (AWS Signature Version 4)](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) nella * Documentazione di riferimento delle API di Amazon Simple Storage Service* e [Processo di firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in *Riferimenti generali AWS*.
# Ricerca di informazioni sui backup replicati per Amazon RDS
Per visualizzare le informazioni sui backup replicati puoi utilizzare i seguenti comandi della CLI:
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-source-regions.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-source-regions.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instance-automated-backups.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instance-automated-backups.html)
Nel seguente comando `describe-source-regions` di esempio vengono elencate le Regioni AWS di origine dalle quali è possibile replicare i backup automatici nella regione Stati Uniti occidentali (Oregon) di destinazione.
**Per visualizzare le informazioni sulle regioni di origine**
+ Eseguire il comando riportato qui di seguito.
```
aws rds describe-source-regions --region us-west-2
```
L'output mostra che i backup possono essere replicati da US East (N. Virginia), ma non da Stati Uniti orientali (Ohio) o Stati Uniti occidentali (California settentrionale) in Stati Uniti occidentali (Oregon).
```
{
"SourceRegions": [
...
{
"RegionName": "us-east-1",
"Endpoint": "https://rds.us-east-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "us-east-2",
"Endpoint": "https://rds.us-east-2.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
"RegionName": "us-west-1",
"Endpoint": "https://rds.us-west-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
}
]
}
```
Nell'esempio `describe-db-instances` seguente vengono illustrati i backup automatici per un'istanza database.
**Per visualizzare i backup replicati per un'istanza DB**
+ Eseguire uno dei seguenti comandi.
Per Linux, macOS o Unix:
```
aws rds describe-db-instances \
--db-instance-identifier mydatabase
```
Per Windows:
```
aws rds describe-db-instances ^
--db-instance-identifier mydatabase
```
L'output include i backup replicati.
```
{
"DBInstances": [
{
"StorageEncrypted": false,
"Endpoint": {
"HostedZoneId": "Z1PVIF0B656C1W",
"Port": 1521,
...
"BackupRetentionPeriod": 7,
"DBInstanceAutomatedBackupsReplications": [{"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE"}]
}
]
}
```
Nell'esempio `describe-db-instance-automated-backups` seguente vengono illustrati i backup automatici per un'istanza database.
**Per visualizzare i backup automatici per un'istanza database**
+ Eseguire uno dei seguenti comandi.
Per Linux, macOS o Unix:
```
aws rds describe-db-instance-automated-backups \
--db-instance-identifier mydatabase
```
Per Windows:
```
aws rds describe-db-instance-automated-backups ^
--db-instance-identifier mydatabase
```
L'output mostra l'istanza database di origine e i backup automatici in Stati Uniti occidentali (Oregon), con i backup replicati in US East (N. Virginia).
```
{
"DBInstanceAutomatedBackups": [
{
"DBInstanceArn": "arn:aws:rds:us-west-2:868710585169:db:mydatabase",
"DbiResourceId": "db-L2IJCEXJP7XQ7HOJ4SIEXAMPLE",
"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-west-2:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE",
"BackupRetentionPeriod": 7,
"DBInstanceAutomatedBackupsReplications": [{"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE"}]
"Region": "us-west-2",
"DBInstanceIdentifier": "mydatabase",
"RestoreWindow": {
"EarliestTime": "2020-10-26T01:09:07Z",
"LatestTime": "2020-10-31T19:09:53Z",
}
...
}
]
}
```
Nell'esempio `describe-db-instance-automated-backups` seguente viene utilizzata l'opzione `--db-instance-automated-backups-arn` per visualizzare i backup replicati nella regione di destinazione.
**Per visualizzare i backup replicati**
+ Eseguire uno dei seguenti comandi.
Per Linux, macOS o Unix:
```
aws rds describe-db-instance-automated-backups \
--db-instance-automated-backups-arn "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE"
```
Per Windows:
```
aws rds describe-db-instance-automated-backups ^
--db-instance-automated-backups-arn "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE"
```
L'output mostra l'istanza database di origine in Stati Uniti occidentali (Oregon), con backup replicati in US East (N. Virginia).
```
{
"DBInstanceAutomatedBackups": [
{
"DBInstanceArn": "arn:aws:rds:us-west-2:868710585169:db:mydatabase",
"DbiResourceId": "db-L2IJCEXJP7XQ7HOJ4SIEXAMPLE",
"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE",
"Region": "us-west-2",
"DBInstanceIdentifier": "mydatabase",
"RestoreWindow": {
"EarliestTime": "2020-10-26T01:09:07Z",
"LatestTime": "2020-10-31T19:01:23Z"
},
"AllocatedStorage": 50,
"BackupRetentionPeriod": 7,
"Status": "replicating",
"Port": 1521,
...
}
]
}
```
# Ripristino a un’ora specificata da un backup replicato per Amazon RDS
Puoi ripristinare un'istanza database a un determinato momento temporale da un backup replicato utilizzando la console Amazon RDS . Puoi inoltre utilizzare il comando `restore-db-instance-to-point-in-time` AWS CLI comando o la funzionalità dell’API RDS `RestoreDBInstanceToPointInTime`.
Per informazioni generali sul ripristino point-in-time (PITR), consulta [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
**Nota**
Tieni presente le seguenti restrizioni del motore database quando i backup automatici vengono replicati nelle Regioni AWS:
Su RDS per SQL Server, i gruppi di opzioni non vengono copiati.
In RDS per Oracle, le seguenti opzioni non vengono copiate: `NATIVE_NETWORK_ENCRYPTION`, `OEM`, `OEM_AGENT` e `SSL`.
Se è stato associato un gruppo di opzioni personalizzate all'istanza database , è possibile ricreare tale gruppo di opzioni nella regione di destinazione. Quindi ripristina l'istanza database nella regione di destinazione e associarla al gruppo di opzioni personalizzate. Per ulteriori informazioni, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md).
## Console
**Per ripristinare un'istanza database a un'ora specificata da un backup replicato**
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. Sceglie la regione di destinazione (in cui vengono replicati i backup) dal selettore di regioni.
1. Nel riquadro di navigazione, selezionare **Automated backups (Backup automatici)**.
1. Nella scheda **Backup replicati** scegli l'istanza database che desideri ripristinare.
1. In **Actions (Operazioni)**, scegliere **Restore to point in time (Ripristina a un punto temporale)**.
1. Scegliere **Latest restorable time (Ultimo orario di ripristino)** per eseguire il ripristino in base al momento più recente oppure scegliere **Custom (Personalizzato)** per scegliere una data e un'ora.
Se si sceglie **Custom (Personalizza)**, immettere la data e l'ora in cui si desidera ripristinare l'istanza.
**Nota**
Gli orari vengono visualizzati nel fuso orario locale, indicato da un offset dell'ora UTC (Coordinated Universal Time). Ad esempio, UTC-5 è l'orario standard degli Stati Uniti orientali/ora legale degli Stati Uniti orientali.
1. Per **DB Instance Identifier (Identificatore istanze database)**, inserire il nome dell'istanza database di destinazione ripristinata.
1. (Facoltativo) Scegliere altre opzioni in base alle esigenze, ad esempio l'attivazione dell’autoscaling.
1. Scegliere **Restore to point in time (Ripristina per punto nel tempo)**.
## AWS CLI
Utilizza 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) AWS CLI per creare una nuova istanza database.
**Per ripristinare un'istanza database a un'ora specificata da un backup replicato**
+ Eseguire uno dei seguenti comandi.
Per Linux, macOS o Unix:
```
1. aws rds restore-db-instance-to-point-in-time \
2. --source-db-instance-automated-backups-arn "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE" \
3. --target-db-instance-identifier mytargetdbinstance \
4. --restore-time 2020-10-14T23:45:00.000Z
```
Per Windows:
```
1. aws rds restore-db-instance-to-point-in-time ^
2. --source-db-instance-automated-backups-arn "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE" ^
3. --target-db-instance-identifier mytargetdbinstance ^
4. --restore-time 2020-10-14T23:45:00.000Z
```
## API RDS
Per ripristinare un'istanza database a un momento temporale specifico, utilizza la funzionalità dell’API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) Amazon RDS con i seguenti parametri:
+ `SourceDBInstanceAutomatedBackupsArn`
+ `TargetDBInstanceIdentifier`
+ `RestoreTime`
# Arresto della replica di backup automatici per Amazon RDS
Puoi interrompere la replica di backup per le istanze database utilizzando la console Amazon RDS. Puoi inoltre utilizzare il comando `stop-db-instance-automated-backups-replication` AWS CLI comando o la funzionalità dell’API RDS `StopDBInstanceAutomatedBackupsReplication`.
I backup replicati vengono conservati, in base al periodo di conservazione del backup, impostato al momento della creazione.
## Console
Arresta la replica di backup dalla pagina **Backup automatici** nella regione di origine.
**Per arrestare la replica di backup in una Regione 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. Seleziona la regione di origine dal **selettore di regioni**.
1. Nel riquadro di navigazione, selezionare **Automated backups (Backup automatici)**.
1. Nella scheda **Area corrente** seleziona l'istanza database per la quale desideri interrompere la replica di backup.
1. Per **Azioni**, seleziona **Gestisci replica tra regioni**.
1. In **Replica di backup** deseleziona la casella di controllo **Abilita replica in un'altra Regione AWS**.
1. Scegli **Save** (Salva).
I backup replicati sono riportati nella scheda **Mantenuti** della pagina **Backup automatici** nella regione di destinazione.
## AWS CLI
Arresta la replica di backup utilizzando il comando [https://docs.aws.amazon.com/cli/latest/reference/rds/stop-db-instance-automated-backups-replication.html](https://docs.aws.amazon.com/cli/latest/reference/rds/stop-db-instance-automated-backups-replication.html) AWS CLI.
Nell'esempio seguente di CLI viene interrotta la replica dei backup automatici di un'istanza database nella regione Stati Uniti occidentali (Oregon).
**Per interrompere la replica di backup**
+ Eseguire uno dei seguenti comandi.
Per Linux, macOS o Unix:
```
aws rds stop-db-instance-automated-backups-replication \
--region us-east-1 \
--source-db-instance-arn "arn:aws:rds:us-west-2:123456789012:db:mydatabase"
```
Per Windows:
```
aws rds stop-db-instance-automated-backups-replication ^
--region us-east-1 ^
--source-db-instance-arn "arn:aws:rds:us-west-2:123456789012:db:mydatabase"
```
## API RDS
Arresta la replica di backup utilizzando la funzionalità dell’API RDS [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StopDBInstanceAutomatedBackupsReplication.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StopDBInstanceAutomatedBackupsReplication.html) con i seguenti parametri:
+ `Region`
+ `SourceDBInstanceArn`
# Eliminazione dei backup replicati per Amazon RDS
Puoi eliminare i backup replicati per le istanze database utilizzando la console Amazon RDS. Puoi inoltre utilizzare il comando `delete-db-instance-automated-backups` AWS CLI comando o la funzionalità dell’API RDS `DeleteDBInstanceAutomatedBackup`.
## Console
Elimina i backup replicati nella regione di destinazione dalla pagina **Backup automatici**.
**Per eliminare i backup replicati**
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. Seleziona la regione di destinazione dal **selettore di regioni**.
1. Nel riquadro di navigazione, selezionare **Automated backups (Backup automatici)**.
1. Nella scheda **Backup replicati** scegli l'istanza database per cui desideri eliminare i backup replicati.
1. In **Actions (Azioni)**, selezionare **Delete (Elimina)**.
1. Nella pagina di conferma, immetti **delete me** e seleziona **Elimina**.
## AWS CLI
Elimina i backup replicati utilizzando il comando [https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance-automated-backup.html](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance-automated-backup.html) AWS CLI.
Puoi utilizzare il comando della CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) per trovare gli ARN (Amazon Resource Names) dei backup replicati. Per ulteriori informazioni, consulta [Ricerca di informazioni sui backup replicati per Amazon RDS](AutomatedBackups.Replicating.Describe.md).
**Per eliminare i backup replicati**
+ Eseguire uno dei seguenti comandi.
Per Linux, macOS o Unix:
```
aws rds delete-db-instance-automated-backup \
--db-instance-automated-backups-arn "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE"
```
Per Windows:
```
aws rds delete-db-instance-automated-backup ^
--db-instance-automated-backups-arn "arn:aws:rds:us-east-1:123456789012:auto-backup:ab-L2IJCEXJP7XQ7HOJ4SIEXAMPLE"
```
## API RDS
Elimina i backup replicati utilizzando la funzionalità dell’API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteDBInstanceAutomatedBackup.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteDBInstanceAutomatedBackup.html) RDS con il parametro `DBInstanceAutomatedBackupsArn`.
# Risoluzione dei problemi relativi ai backup automatici interregionali interrotti
Amazon RDS interrompe automaticamente la replica di backup automatizzata tra regioni in circostanze specifiche per proteggere i dati e mantenere la conformità AWS ai requisiti operativi.
## Sospensione dell'account
Se il tuo AWS account è sospeso, Amazon RDS interrompe automaticamente la replica di backup automatizzata tra regioni per tutte le istanze DB di quell'account. I backup replicati già esistenti nella destinazione Regione AWS vengono conservati fino al periodo di conservazione specificato.
Una volta risolta la sospensione dell'account, è necessario riattivare manualmente la replica automatica dei backup tra aree geografiche per riprendere la replica dei backup nella destinazione. Regione AWS
## Opt-in per le modifiche alla regione
La replica di backup automatizzata su più regioni si interrompe automaticamente quando si disattiva l'origine Regione AWS (dove si trova l'istanza DB principale) o la destinazione Regione AWS (dove vengono replicati i backup). [Per ulteriori informazioni sulle regioni opt-in, consulta Gestione delle regioni. AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html)
I backup replicati già esistenti nella destinazione Regione AWS vengono conservati fino al periodo di conservazione specificato. Per riprendere la replica, attivate nuovamente la replica di backup automatica richiesta Regione AWS e riattivate manualmente la replica di backup automatizzata su più regioni.
## AWS KMS questioni chiave
Per le istanze DB crittografate, Amazon RDS richiede l'accesso alle AWS KMS chiavi sia nell'origine che nella destinazione Regione AWS per replicare i backup. Se disabiliti o elimini la AWS KMS chiave in una delle due Regione AWS, la replica di backup automatizzata tra regioni si interrompe automaticamente. I backup replicati già esistenti nella destinazione Regione AWS vengono conservati fino al periodo di conservazione specificato.
Per riprendere la replica automatica dei backup tra regioni:
1. Riattiva la AWS KMS chiave disabilitata o crea una nuova AWS KMS chiave se l'originale è stata eliminata
1. Se utilizzi una nuova AWS KMS chiave, elimina il backup replicato esistente nella destinazione Regione AWS crittografata con la chiave precedente.
1. Riattiva la replica di backup automatizzata su più regioni per l'istanza
[Per ulteriori informazioni sulla gestione delle AWS KMS chiavi, consulta la documentazione.AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)
**Nota**
Non è possibile eseguire il ripristino da backup precedentemente replicati nella destinazione a Regione AWS meno che la AWS KMS chiave precedente non venga riattivata. I backup rimangono crittografati e inaccessibili senza una chiave valida. AWS KMS
## Monitoraggio dello stato di replica dei backup
Puoi monitorare lo stato dei tuoi backup automatici tra regioni utilizzando la console Amazon RDS o l'API RDS. AWS CLI Per ulteriori informazioni, consulta [Ricerca di informazioni sui backup replicati per Amazon RDS](AutomatedBackups.Replicating.Describe.md).
# Gestione dei backup manuali
Questa sezione illustra come gestire i backup manuali per le istanze database e i cluster di database.
Per informazioni su come creare uno snapshot DB per un’istanza database Single-AZ, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
Per informazioni su come creare uno snapshot DB per un cluster di database Multi-AZ, consulta [Creazione di uno snapshot di cluster di database Multi-AZ per Amazon RDS](USER_CreateMultiAZDBClusterSnapshot.md).
Per informazioni su come eliminare uno snapshot DB, consulta [Eliminazione di uno snapshot del database per Amazon RDS](USER_DeleteSnapshot.md).
# Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS
Amazon RDS crea una snapshot dei volumi di storage dell'istanza database, eseguendo il backup dell'intera istanza database anziché dei singoli database. La creazione di questa istantanea DB su un'istanza DB Single-AZ comporta una breve I/O sospensione che può durare da pochi secondi a pochi minuti, a seconda delle dimensioni e della classe dell'istanza DB. Per MariaDB, MySQL, Oracle e I/O PostgreSQL, l'attività non viene sospesa sul sistema primario durante il backup per le implementazioni Multi-AZ, poiché il backup viene eseguito dallo standby. Per SQL Server, l'attività di I/O viene sospesa brevemente durante il backup delle implementazioni Multi-AZ.
Quando crei uno snapshot DB è necessario identificare qual è l'istanza database di cui stai effettuando il backup e dare un nome allo snapshot DB in modo da poterlo usare successivamente per il ripristino. La quantità di tempo necessaria per creare uno snapshot varia a seconda della dimensione dei database. Poiché lo snapshot include l'intero volume di storage, anche la dimensione dei file, come i file temporanei, influisce sulla quantità di tempo necessaria per creare lo snapshot.
**Nota**
La tua istanza database deve essere nello stato `available` per poter acquisire uno snapshot di database.
Per le istanze di PostgreSQL DB, i dati nelle tabelle non registrate potrebbero non essere ripristinati dagli snapshot. Per ulteriori informazioni, consulta [Best practice per l'utilizzo di PostgreSQL](CHAP_BestPractices.md#CHAP_BestPractices.PostgreSQL).
A differenza dei backup automatizzati, gli snapshot manuali non sono soggetti al periodo di retention dei backup. Gli snapshot non scadono.
Per i backup a lungo termine dei dati di MariaDB, MySQL e PostgreSQL, si consiglia di esportare i dati snapshot in Amazon S3. Se la versione principale del motore DB non è più supportata, non è possibile ripristinare tale versione da uno snapshot. Per ulteriori informazioni, consulta [Supporto per l’esportazione di dati dello snapshot del database in Amazon S3 per Amazon RDS](USER_ExportSnapshot.md).
È possibile creare uno snapshot DB utilizzando l'API RDS o l'API RDS. Console di gestione AWS AWS CLI
## Console
**Come creare uno snapshot 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. Nel riquadro di navigazione, selezionare **Snapshots (Snapshot)**.
Viene visualizzato l’elenco **Snapshot manuali**.
1. Seleziona **Acquisisci snapshot**.
Viene visualizzata la finestra **Acquisizione di snapshot DB**.
![\[Acquisizione di uno snapshot del database\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/take_db_snapshot.png)
1. Scegli l’**istanza database** per cui desideri acquisire uno snapshot.
1. Immetti il **Nome snapshot**.
1. Seleziona **Acquisisci snapshot**.
Viene visualizzato l’elenco **Snapshot manuali**, con lo stato del nuovo snapshot del database che indica `Creating`. Dopo che lo stato è diventato `Available`, potrai vedere il tempo di creazione.
## AWS CLI
Quando crei uno snapshot DB utilizzando ilAWS CLI, devi identificare l'istanza DB di cui vuoi eseguire il backup e quindi assegnare un nome allo snapshot DB in modo da poterlo ripristinare in un secondo momento. È possibile eseguire questa operazione utilizzando il AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-snapshot.html)comando con i seguenti parametri:
+ `--db-instance-identifier`
+ `--db-snapshot-identifier`
In questo esempio, si crea uno snapshot DB chiamato *mydbsnapshot* per un'istanza DB chiamata*mydbinstance*.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds create-db-snapshot \
2. --db-instance-identifier mydbinstance \
3. --db-snapshot-identifier mydbsnapshot
```
Per Windows:
```
1. aws rds create-db-snapshot ^
2. --db-instance-identifier mydbinstance ^
3. --db-snapshot-identifier mydbsnapshot
```
## API RDS
Quando crei uno snapshot DB usando l'API Amazon RDS è necessario identificare qual è l'istanza database di cui stai effettuando il backup e dare un nome allo snapshot DB in modo da poterlo usare successivamente per il ripristino. Puoi eseguire questa operazione utilizzando il comando API Amazon RDS [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBSnapshot.html) con i seguenti parametri:
+ `DBInstanceIdentifier`
+ `DBSnapshotIdentifier`
# Creazione di uno snapshot di cluster di database Multi-AZ per Amazon RDS
Quando crei uno snapshot di cluster database Multi-AZ assicurati di identificare qual è il cluster database Multi-AZ di cui stai effettuando il backup e dare un nome alla snapshot di cluster database in modo da poterlo usare successivamente per il ripristino. Puoi anche condividere uno snapshot di cluster di database multi-AZ. Per istruzioni, consultare [Condivisione di uno snapshot DB per Amazon RDS](USER_ShareSnapshot.md).
Puoi creare uno snapshot del cluster di database Multi-AZ con la Console di gestione AWS, l'AWS CLI o l'API RDS.
Per i backup a lungo termine, si consiglia di esportare i dati delle snapshot in Amazon S3. Se la versione principale del motore DB non è più supportata, non è possibile ripristinare tale versione da un'istantanea. Per ulteriori informazioni, consulta [Supporto per l’esportazione di dati dello snapshot del database in Amazon S3 per Amazon RDS](USER_ExportSnapshot.md).
## Console
**Per creare una snapshot del cluster di database**
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 **Databases (Database)**.
1. Nell'elenco scegliere il cluster di database Multi-AZ per il quale si desidera fare uno snapshot.
1. Per **Actions (Operazioni)**, selezionare **Take snapshot (Acquisisci snapshot)**.
Viene visualizzata la finestra **Acquisizione di snapshot DB**.
1. Per **Nome snapshot**, inserisci il nome dello snapshot.
1. Seleziona **Acquisisci snapshot**.
Viene visualizzata la pagina **Snapshot**, con lo stato del nuovo snapshot del cluster di database Multi-AZ come `Creating`. Dopo che lo stato è diventato `Available`, potrai vedere il tempo di creazione.
## AWS CLI
È possibile creare uno snapshot cluster di database Multi-AZ utilizzando il comando AWS CLI [create-db-cluster-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster-snapshot.html) con le seguenti opzioni:
+ `--db-cluster-identifier`
+ `--db-cluster-snapshot-identifier`
In questo esempio crei uno snapshot del cluster di database Multi-AZ denominato *`mymultiazdbclustersnapshot`* per un cluster di database denominato *`mymultiazdbcluster`*.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds create-db-cluster-snapshot \
2. --db-cluster-identifier mymultiazdbcluster \
3. --db-cluster-snapshot-identifier mymultiazdbclustersnapshot
```
Per Windows:
```
1. aws rds create-db-cluster-snapshot ^
2. --db-cluster-identifier mymultiazdbcluster ^
3. --db-cluster snapshot-identifier mymultiazdbclustersnapshot
```
## API RDS
È possibile creare uno snapshot cluster di database Multi-AZ utilizzando l’operazione API Amazon RDS [CreateDBClusterSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBClusterSnapshot.html) con i seguenti parametri:
+ `DBClusterIdentifier`
+ `DBClusterSnapshotIdentifier`
## Eliminazione di uno snapshot di cluster di database multi-AZ
Puoi eliminare gli snapshot dei cluster di database multi-AZ gestiti da Amazon RDS quando non ti servono più. Per istruzioni, consultare [Eliminazione di uno snapshot del database per Amazon RDS](USER_DeleteSnapshot.md).
# Eliminazione di uno snapshot del database per Amazon RDS
Puoi eliminare snapshot del cluster di database gestiti da Amazon RDS quando non ti servono più.
**Nota**
Per eliminare i backup gestiti daAWS Backup, usa la AWS Backup console. Per ulteriori informazioni su AWS Backup, consulta la [https://docs.aws.amazon.com/aws-backup/latest/devguide](https://docs.aws.amazon.com/aws-backup/latest/devguide).
## Eliminazione di una snapshot DB
È possibile eliminare un'istantanea del DB manuale, condivisa o pubblica utilizzando l'API Console di gestione AWS RDS o AWS CLI l'API RDS.
Per eliminare uno snapshot condiviso o pubblico, è necessario accedere all'AWSaccount proprietario dello snapshot.
Se hai snapshot DB automatizzate che desideri eliminare senza eliminare l'istanza database, modifica il periodo di retention dei backup per l'istanza database a 0. Le snapshot automatizzate vengono eliminate all'applicazione della modifica. Se non desideri aspettare fino al periodo di manutenzione successivo, puoi applicare la modifica immediatamente. Dopo aver completato la modifica, puoi riabilitare i backup automatici impostando il periodo di retention dei backup a un numero maggiore di 0. Per ulteriori informazioni sulla modifica di un'istanza di database, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
I backup automatici conservati e le istantanee manuali comportano costi di fatturazione fino alla loro eliminazione. Per ulteriori informazioni, consulta [Costi di retention](USER_WorkingWithAutomatedBackups.Retaining.md#USER_WorkingWithAutomatedBackups.RetentionCosts).
Se hai eliminato un'istanza database, puoi eliminare le sue snapshot DB automatizzate rimuovendo i backup automatici per l'istanza database. Per informazioni sui backup automatici, consulta [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md).
### Console
**Come eliminare uno snapshot 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. Nel riquadro di navigazione, selezionare **Snapshots (Snapshot)**.
Viene visualizzato l’elenco **Snapshot manuali**.
1. Scegliere la snapshot DB da eliminare.
1. Per **Actions (Operazioni)**, scegliere **Delete Snapshot (Elimina snapshot)**.
![\[Elimina lo snapshot\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/delete-snapshot.png)
1. Nella pagina di conferma, scegliere **Delete (Elimina)**.
![\[Conferma l'eliminazione dello snapshot\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/delete-snapshot-confirm.png)
### AWS CLI
Puoi eliminare uno snapshot del DB utilizzando il AWS CLI comando. [delete-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-snapshot.html)
Le seguenti opzioni vengono utilizzate per eliminare una snapshot DB.
+ `--db-snapshot-identifier` – L'identificatore per la snapshot DB.
**Example**
Il seguente codice elimina la snapshot DB `mydbsnapshot`.
Per Linux, macOS o Unix:
```
1. aws rds delete-db-snapshot \
2. --db-snapshot-identifier mydbsnapshot
```
Per Windows:
```
1. aws rds delete-db-snapshot ^
2. --db-snapshot-identifier mydbsnapshot
```
### API RDS
[Puoi eliminare uno snapshot DB utilizzando l'operazione Delete dell'API Amazon RDS. DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteDBSnapshot.html)
I seguenti parametri vengono utilizzati per eliminare una snapshot DB.
+ `DBSnapshotIdentifier` – L'identificatore per la snapshot DB.
# Ripristino in un’istanza database
Questa sezione illustra come effettuare il ripristino in un’istanza database. Questa pagina illustra come ripristinare in un’istanza database Amazon RDS da uno snapshot DB.
Amazon RDS crea uno snapshot dei volumi di storage dell'istanza database, eseguendo il backup dell'intera istanza database anziché dei singoli database. È possibile creare una nuova istanza database eseguendo il ripristino da uno snapshot di database. Si specifica il nome dello snapshot di database da cui ripristinare, quindi si fornisce un nome per la nuova istanza database che viene creata dal ripristino. Non è possibile eseguire il ripristino da uno snapshot DB su un'istanza DB esistente; si crea una nuova istanza DB quando si ripristina lo snapshot.
È possibile utilizzare l'istanza database ripristinata non appena lo stato diventa `available`. L’istanza del cluster database continuerà a caricare i dati in background. Questo processo è noto come *caricamento lento*. Se accedi a dati che non sono ancora stati caricati, l’istanza del cluster database scarica immediatamente i dati richiesti da Amazon S3 e continua a caricare il resto dei dati in background. Per ulteriori informazioni, consulta [Snapshot Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html).
Per ridurre gli effetti del caricamento lento sulle tabelle a cui è necessario accedere rapidamente, è possibile eseguire operazioni che comportano scansioni di tabelle complete, ad esempio `SELECT *`. Ciò consente ad Amazon RDS di scaricare tutti i dati della tabella di backup da S3.
Puoi effettuare il ripristino di un'istanza database e utilizzare un tipo di storage diverso dalla snapshot DB di origine. In questo caso, il processo di ripristino è più lento a causa del lavoro aggiuntivo necessario per migrare i dati verso il nuovo tipo di archiviazione. Se effettui il ripristino su o dallo storage magnetico, il processo di migrazione è particolarmente lento. Questo perché lo storage magnetico non dispone della funzionalità IOPS dello storage Provisioned IOPS o General Purpose (SSD).
È possibile utilizzare CloudFormation per ripristinare un'istanza DB da uno snapshot di un'istanza DB. Per ulteriori informazioni, consulta [AWS: :RDS:: DBInstance nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-rds-dbinstance.html) per l'*AWS CloudFormation utente*.
**Nota**
Non è possibile ripristinare un'istanza database da una snapshot DB condivisa e crittografata. Invece puoi copiare la snapshot DB e ripristinare l'istanza database dalla copia. Per ulteriori informazioni, consulta [Copia di uno snapshot del database per Amazon RDS](USER_CopySnapshot.md).
Per informazioni sul ripristino di un’istanza database con una versione del supporto esteso RDS, consulta [Ripristino di un’istanza database o di un cluster di database Multi-AZ con il supporto esteso per Amazon RDS](extended-support-restoring-db-instance.md).
## Ripristino da uno snapshot
È possibile ripristinare un'istanza DB da uno snapshot DB utilizzando l'API Console di gestione AWS AWS CLI, the o RDS.
**Nota**
Non puoi ridurre lo spazio di archiviazione quando ripristini un'istanza database. Quando si aumenta lo storage allocato, questo valore deve essere almeno del 10%. Se si prova ad aumentarlo di un valore inferiore al 10%, verrà visualizzato un errore. Non puoi aumentare lo spazio di archiviazione allocato quando ripristini le istanze database RDS per SQL Server.
### Console
**Come ripristinare un’istanza database da uno snapshot 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. Nel pannello di navigazione, selezionare **Snapshots (Snapshot)**.
1. Scegliere la snapshot DB dalla quale effettuare il ripristino.
1. Per **Actions (Operazioni)**, selezionare **Restore Snapshot (Ripristina snapshot)**.
1. Nella pagina **Ripristina snapshot**, in **Identificatore istanza database**, immettere il nome dell'istanza database ripristinata.
1. Specifica altre impostazioni, ad esempio la dimensione dello spazio di archiviazione allocato.
Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
1. Selezionare **Ripristina istanza database**.
### AWS CLI
[Per ripristinare un'istanza DB da uno snapshot DB, usa il AWS CLI comando restore-db-instance-from -db-snapshot.](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
In questo esempio il ripristino avviene da uno snapshot DB creato precedentemente e denominato `mydbsnapshot`. Viene ripristinata una nuova istanza database denominata `mynewdbinstance`. Questo esempio imposta anche la dimensione dello spazio di archiviazione allocato.
È possibile specificare altre impostazioni. Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
**Example**
Per Linux, macOS o Unix:
```
1. aws rds restore-db-instance-from-db-snapshot \
2. --db-instance-identifier mynewdbinstance \
3. --db-snapshot-identifier mydbsnapshot \
4. --allocated-storage 100
```
Per Windows:
```
1. aws rds restore-db-instance-from-db-snapshot ^
2. --db-instance-identifier mynewdbinstance ^
3. --db-snapshot-identifier mydbsnapshot ^
4. --allocated-storage 100
```
Questo comando restituisce un output simile al seguente:
```
1. DBINSTANCE mynewdbinstance db.t3.small MySQL 50 sa creating 3 n 8.0.28 general-public-license
```
**Example**
L'esempio seguente mostra il ripristino di un'istantanea aggiungendo un volume di archiviazione aggiuntivo all'istanza appena creata. L'istantanea includeva un volume aggiuntivo. `rdsdbdata2` L'operazione di ripristino si aggiunge`rdsdbdata3`, per un totale di tre volumi nell'istanza appena creata. Non è possibile eliminare un volume quando si ripristina l'istantanea.
```
1. aws rds restore-db-instance-from-db-snapshot \
2. --db-instance-identifier my-restored-instance \
3. --db-snapshot-identifier my-asv-snapshot \
4. --additional-storage-volumes '[{ \
5. "VolumeName": "rdsdbdata3", \
6. "StorageType":"gp3", \
7. "AllocatedStorage": 5000, \
8. "IOPS": 12000 \
9. }]'
```
### API RDS
Per ripristinare un'istanza DB da uno snapshot DB, chiama la funzione dell'API Amazon RDS [Restore DBInstance From DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html) con i seguenti parametri:
+ `DBInstanceIdentifier`
+ `DBSnapshotIdentifier`
## Considerazioni
Per le considerazioni sul ripristino in un’istanza database da uno snapshot DB, consulta i seguenti argomenti.
**Topics**
+ [Considerazioni sui gruppi di parametri](#USER_RestoreFromSnapshot.Parameters)
+ [Considerazioni relative al gruppo di sicurezza](#USER_RestoreFromSnapshot.Security)
+ [Considerazioni su gruppi di opzioni](#USER_RestoreFromSnapshot.Options)
+ [Considerazioni sull’assegnazione di tag alle risorse](#restore-from-snapshot.tagging)
+ [Considerazioni su Db2](#USER_RestoreFromSnapshot.Db2)
+ [Considerazioni su Microsoft SQL Server](#USER_RestoreFromSnapshot.MSSQL)
+ [Considerazioni su MySQL](#USER_RestoreFromSnapshot.MySQL)
+ [Considerazioni su Oracle Database](#USER_RestoreFromSnapshot.Oracle)
### Considerazioni sui gruppi di parametri
È consigliabile mantenere il gruppo parametri del database per tutti gli snapshot DB creati, in modo che sia possibile associare l'istanza database ripristinata al gruppo di parametri corretto.
Il gruppo parametri del database di default è associato all'istanza ripristinata, a meno che non se ne scelga una diversa. Nel gruppo di parametri di default non sono disponibili impostazioni di parametro personalizzate.
È possibile specificare il gruppo di parametri al momento del ripristino dell'istanza database.
Per ulteriori informazioni sui gruppi di parametri database, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
### Considerazioni relative al gruppo di sicurezza
Quando ripristini un'istanza database, il cloud privato virtuale (VPC) di default, il gruppo di sottoreti del database e il gruppo di sicurezza VPC sono associati all'istanza ripristinata, a meno che non si scelgano altri gruppi.
+ Se utilizzi la console Amazon RDS, puoi specificare un gruppo di sicurezza VPC personalizzato da associare all'istanza o creare un nuovo gruppo di sicurezza VPC.
+ Se utilizzi il AWS CLI, puoi specificare un gruppo di sicurezza VPC personalizzato da associare all'istanza includendo l'`--vpc-security-group-ids`opzione nel comando. `restore-db-instance-from-db-snapshot`
+ Se utilizzi l'API di Amazon RDS, puoi includere il parametro `VpcSecurityGroupIds.VpcSecurityGroupId.N` nell'operazione `RestoreDBInstanceFromDBSnapshot`.
Non appena il ripristino è completo e la nuova istanza database è disponibile, puoi anche cambiare le impostazioni del VPC modificando l'istanza database. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
### Considerazioni su gruppi di opzioni
Quando si ripristina un'istanza database, il gruppo di opzioni di database predefinito viene associato all'istanza database ripristinata nella maggior parte dei casi.
L'eccezione è quando l'istanza database di origine è associata a un gruppo di opzioni contenente un'opzione persistente o permanente. Ad esempio, se l'istanza database di origine utilizza Oracle TDE (Transparent Data Encryption), l'istanza database ripristinata deve utilizzare un gruppo di opzioni contenente l'opzione TDE.
Se ripristini un'istanza database in un VPC diverso, devi eseguire una delle seguenti operazioni per assegnare un gruppo di opzioni di database:
+ Assegnare all'istanza il gruppo di opzioni di default per quel gruppo di VPC.
+ Assegnare un altro gruppo di opzioni collegato a tale VPC.
+ Creare un nuovo gruppo di opzioni e assegnarlo all'istanza database. Con le opzioni persistenti o permanenti, come Oracle TDE, devi creare un nuovo gruppo di opzioni che includa l'opzione persistente o permanente.
Per ulteriori informazioni sui gruppi di opzioni di database, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md).
### Considerazioni sull’assegnazione di tag alle risorse
Quando ripristini un'istanza database da uno snapshot DB, RDS controlla se hai specificato nuovi tag. In caso affermativo, i nuovi tag vengono aggiunti all'istanza database ripristinata. Se non ci sono nuovi tag, RDS aggiunge i tag dall'istanza database di origine al momento della creazione dello snapshot nell'istanza database ripristinata.
Per ulteriori informazioni, consulta [Copia di tag in snapshot database](USER_Tagging.md#USER_Tagging.CopyTags).
### Considerazioni su Db2
Con il modello BYOL, le istanze database Amazon RDS per Db2 devono essere associate a un gruppo di parametri personalizzato che contenga IBM Site ID e IBM Customer ID. In caso contrario, i tentativi di ripristino di un’istanza database da uno snapshot non riescono. Le tue istanze database Amazon RDS for Db2 devono inoltre essere associate a una licenza autogestita AWS License Manager . Per ulteriori informazioni, consulta [Uso di licenze proprie (BYOL) per Db2](db2-licensing.md#db2-licensing-options-byol).
Con il Marketplace AWS modello Db2 license through, è necessario un Marketplace AWS abbonamento attivo per la particolare IBM Db2 edizione che desideri utilizzare. Se non ne disponi, [abbonati a Db2 in Marketplace AWS](db2-licensing.md#db2-marketplace-subscribing-registering) per quell’edizione di IBM Db2. Per ulteriori informazioni, consulta [Licenza Db2 tramite Marketplace AWS](db2-licensing.md#db2-licensing-options-marketplace).
### Considerazioni su Microsoft SQL Server
Quando ripristini uno snapshot database di RDS per Microsoft SQL Server su una nuova istanza, puoi sempre ripristinare la stessa edizione dello snapshot. In alcuni casi puoi anche cambiare l'edizione dell'istanza database. Le limitazioni di seguito sono riportate sono applicabili quando cambi le edizioni:
+ Alla snapshot DB deve essere assegnato uno storage sufficiente per la nuova edizione.
+ Sono supportate solo le seguenti modifiche per l'edizione:
+ Da Standard Edition a Enterprise Edition
+ Da Web Edition a Standard Edition o Enterprise Edition
+ Da Express Edition a Web Edition, Standard Edition o Enterprise Edition
Se desideri passare da un'edizione a una nuova edizione non supportata ripristinando una snapshot, puoi tentare di utilizzare la funzione di backup e ripristino nativi. SQL Server verifica la compatibilità del database con la nuova edizione sulla base delle funzionalità SQL Server abilitate nel database. Per ulteriori informazioni, consulta [Importazione ed esportazione di database SQL Server mediante backup e ripristino nativi](SQLServer.Procedural.Importing.md).
### Considerazioni su MySQL
Per eseguire il ripristino da uno snapshot DB RDS per MySQL con una versione del motore non supportata, potrebbe essere necessario aggiornare lo snapshot DB più di una volta. Per ulteriori informazioni sulle opzioni di aggiornamento, consulta [Opzioni di aggiornamento per snapshot di database con versioni del motore non supportate per RDS per MySQL](mysql-upgrade-snapshot.upgrade-options.md).
Per ulteriori informazioni sull’aggiornamento della versione del motore di uno snapshot DB RDS per MySQL, consulta [Aggiornamento di una versione del motore di snapshot di database MySQL](mysql-upgrade-snapshot.md).
### Considerazioni su Oracle Database
Quando ripristini un database Oracle da uno snapshot di database, considera quanto segue:
+ Prima di ripristinare uno snapshot di database, è possibile aggiornarlo a una versione successiva. Per ulteriori informazioni, consulta [Aggiornamento di uno shapshot DB Oracle](USER_UpgradeDBSnapshot.Oracle.md).
+ Se ripristini uno snapshot di un'istanza CDB che utilizza la configurazione a tenant singolo, è possibile modificare il nome PDB. Non è possibile modificare i nomi PDB quando l'istanza CDB utilizza la configurazione multi-tenant. Per ulteriori informazioni, consulta [Backup e ripristino di un CDB](Oracle.Concepts.single-tenant.snapshots.md).
+ Non è possibile modificare il nome CDB, che è sempre `RDSCDB`. Questo nome CDB è lo stesso per tutte le istanze CDB.
+ Non è possibile interagire direttamente con i database del tenant in uno snapshot di database. Se ripristini uno snapshot di un'istanza CDB che utilizza la configurazione multi-tenant, ripristini tutti i relativi database del tenant. È possibile utilizzare [describe-db-snapshot-tenant-databases](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-snapshot-tenant-databases.html) per ispezionare i database tenant all'interno di uno snapshot DB prima di ripristinarlo.
+ Se usi Oracle GoldenGate, mantieni sempre il gruppo di parametri con il parametro. `compatible` Quando ripristini un'istanza database da una snapshot DB, specifica un gruppo di parametri con un valore `compatible` uguale o superiore.
+ Quando si ripristina uno snapshot DB è possibile scegliere di rinominare il database. Se la dimensione totale del log di redo online è superiore a 20 GB, RDS potrebbe reimpostare la dimensione del log di redo online sulle impostazioni predefinite di 512 MB (4 x 128 MB). La dimensione ridotta consente di completare l’operazione di ripristino in un tempo ragionevole. È possibile ricreare i log di redo online in un secondo momento e modificarne la dimensione.
+ È possibile gestire la password dell’utente master in Gestione dei segreti AWS. Per ulteriori informazioni, consulta [Panoramica della gestione delle password degli utenti principali con Gestione dei segreti AWS](rds-secrets-manager.md#rds-secrets-manager-overview).
# Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS
È possibile ripristinare un’istanza database a un punto temporale specifico, creando una nuova istanza database senza modificare l’istanza database di origine.
Quando ripristini un'istanza database a un determinato momento, puoi scegliere il gruppo di sicurezza VPC (Virtual Private Cloud) predefinito. In alternativa, puoi applicare un gruppo di sicurezza VPC personalizzato alla tua istanza database.
Le istanze database ripristinate vengono associate automaticamente ai gruppi di parametri e opzioni predefiniti del database. Tuttavia, puoi applicare un gruppo di parametri e un gruppo di opzioni personalizzati specificandoli durante un ripristino.
Se i tag vengono forniti nella richiesta, i tag forniti vengono applicati all'istanza DB ripristinata. Se i tag non sono forniti nella richiesta e se l'istanza DB di origine è attiva nella regione e presenta tag, RDS aggiunge i tag più recenti dall'istanza DB di origine all'istanza DB ripristinata.
RDS carica i log delle transazioni per le istanze database in Amazon S3 ogni cinque minuti. Per visualizzare l'ora di ripristino più recente per un'istanza DB, usa il AWS CLI [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)comando e guarda il valore restituito nel `LatestRestorableTime` campo per l'istanza DB. Per visualizzare l'ora di ripristino più recente per ogni istanza del DB nella console Amazon RDS, scegliere **Backup automatici**.
Puoi eseguire il ripristino point-in-time durante il periodo di retention dei backup. Per visualizzare il tempo di ripristino più breve per ogni istanza del DB, scegliere **Backup automatici** nella console Amazon RDS.
![\[Backup automatizzati\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/automated-backups.png)
**Nota**
Si consiglia di ripristinare una dimensione identica o simile dell'istanza database — e IOPS se si utilizza lo storage IOPS con provisioning — come istanza database di origine. È possibile che venga visualizzato un errore se, ad esempio, si sceglie una dimensione di istanza DB con un valore IOPS incompatibile.
Per informazioni sul ripristino di un’istanza database con una versione del supporto esteso RDS, consulta [Ripristino di un’istanza database o di un cluster di database Multi-AZ con il supporto esteso per Amazon RDS](extended-support-restoring-db-instance.md).
Per alcuni motori di database Amazon RDS si applicano considerazioni speciali ai fini del ripristino point-in-time:
+ Se si utilizza l’autenticazione tramite password con un’istanza database Amazon RDS per Db2, le azioni di gestione dell’utente, incluso `rdsadmin.add_user`, non verranno acquisite nei log. Queste azioni richiedono un backup completo dello snapshot.
Con il modello BYOL, le istanze database RDS per Db2 devono essere associate a un gruppo di parametri personalizzato che contenga IBM Site ID e IBM Customer ID. In caso contrario, i tentativi di ripristinare un’istanza database a un punto temporale specifico non riusciranno. Le tue istanze database Amazon RDS for Db2 devono inoltre essere associate a una licenza autogestita AWS License Manager . Per ulteriori informazioni, consulta [Uso di licenze proprie (BYOL) per Db2](db2-licensing.md#db2-licensing-options-byol).
Con il Marketplace AWS modello Db2 license through, è necessario un Marketplace AWS abbonamento attivo per la particolare IBM Db2 edizione che desideri utilizzare. Se non ne disponi, [abbonati a Db2 in Marketplace AWS](db2-licensing.md#db2-marketplace-subscribing-registering) per quell’edizione di IBM Db2. Per ulteriori informazioni, consulta [Licenza Db2 tramite Marketplace AWS](db2-licensing.md#db2-licensing-options-marketplace).
+ Quando ripristini un'istanza DB RDS for Oracle in un determinato momento, puoi specificare un motore DB, un modello di licenza e DBName (SID) diversi per l'istanza DB ripristinata. È anche possibile specificare che RDS debba archiviare le password dell’utente master in Gestione dei segreti AWS. Per ulteriori informazioni, consulta [Panoramica della gestione delle password degli utenti principali con Gestione dei segreti AWS](rds-secrets-manager.md#rds-secrets-manager-overview).
+ Quando si esegue il ripristino point-in-time di un'istanza database Microsoft SQL Server, ogni database nell'istanza viene ripristinato a un point-in-time entro 1 secondo da ciascuno degli altri database nell'istanza. Le transazioni che si estendono su più database nell'istanza potrebbero essere ripristinate in modo incoerente.
+ Per un'istanza database di SQL Server, le modalità `OFFLINE`, `EMERGENCY` e `SINGLE_USER` non sono supportate. Impostando una di queste modalità per un database, l'ora di ripristino più recente non si sposterà più in avanti per l'intera istanza.
+ Alcune azioni, come la modifica del modello di ripristino di un database SQL Server, possono interrompere la sequenza di log utilizzati per il ripristino. point-in-time In alcuni casi, Amazon RDS può rilevare questo problema e all'ultima ora di ripristino sarà impedito di andare avanti. In altri casi, ad esempio quando un database SQL Server utilizza il modello di ripristino `BULK_LOGGED`, l'interruzione nella sequenza di log non viene rilevata. Potrebbe non essere possibile eseguire il ripristino point-in-time di un'istanza database SQL Server in caso di interruzione della sequenza dei log. Per questi motivi, Amazon RDS non supporta la modifica del modello di ripristino dei database SQL Server.
Puoi anche utilizzarlo AWS Backup per gestire i backup delle istanze database di Amazon RDS. Se l'istanza DB è associata a un piano di backup in AWS Backup, tale piano di backup viene utilizzato per il ripristino. point-in-time I backup creati con AWS Backup hanno nomi che terminano con. `awsbackup:AWS-Backup-job-number` Per informazioni in merito AWS Backup, consulta la [https://docs.aws.amazon.com/aws-backup/latest/devguide](https://docs.aws.amazon.com/aws-backup/latest/devguide).
**Nota**
Le informazioni contenute in questo argomento si applicano ad Amazon RDS. Per informazioni sul ripristino del cluster database di Amazon Aurora, consulta [Ripristino di un cluster di database a un determinato momento](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-pitr.html).
È possibile ripristinare un'istanza DB in un determinato momento utilizzando l' Console di gestione AWS API RDS o l'API RDS. AWS CLI
**Nota**
Non puoi ridurre lo spazio di archiviazione quando ripristini un'istanza database. Quando si aumenta lo storage allocato, questo valore deve essere almeno del 10%. Se si prova ad aumentarlo di un valore inferiore al 10%, verrà visualizzato un errore. Non puoi aumentare lo spazio di archiviazione allocato quando ripristini le istanze database RDS per SQL Server.
## Console
**Per ripristinare un'istanza database a un punto temporale specifico**
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 riquadro di navigazione, selezionare **Automated backups (Backup automatici)**.
I backup automatici vengono visualizzati nella scheda **Current Region** (Regione corrente).
1. Scegli l'istanza database da ripristinare.
1. In **Actions (Operazioni)**, scegli **Restore to point in time (Ripristina a un istante temporale)**.
Viene visualizzata la finestra **Restore to point in time (Ripristina a un istante temporale)**.
1. Scegliere **Latest restorable time (Ultimo orario di ripristino)** per eseguire il ripristino in base al momento più recente oppure scegliere **Custom (Personalizzato)** per scegliere una data e un'ora.
Se scegli **Personalizzato**, specifica la data e l'ora in cui desideri ripristinare l'istanza.
**Nota**
Gli orari vengono visualizzati nel fuso orario locale, indicato come un offset dell'ora UTC (Coordinated Universal Time). Ad esempio, UTC-5 è l'ora legale standard Time/Central orientale.
1. Per **DB Instance Identifier (Identificatore istanze database)**, inserire il nome dell'istanza database di destinazione ripristinata. Il nome deve essere univoco.
1. Scegli altre opzioni in base alle esigenze, ad esempio la classe di istanza database, l'archiviazione e se desideri utilizzare la funzione di scalabilità automatica dell'archiviazione.
Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
1. Scegli **Restore to point in time (Ripristina per punto nel tempo)**.
## AWS CLI
Per ripristinare un'istanza DB a un'ora specificata, usa il AWS CLI comando [restore-db-instance-to- point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) per creare una nuova istanza DB. Questo esempio inoltre imposta la dimensione dello spazio di archiviazione allocato e abilita la scalabilità automatica dell'archiviazione.
Il tagging di risorse è supportato per questa operazione. Quando usi l'opzione `--tags`, i tag dell'istanza database di origine vengono ignorati e vengono utilizzati quelli forniti. In caso contrario, vengono utilizzati i tag più recenti dell'istanza di origine.
È possibile specificare altre impostazioni. Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
**Example**
Per Linux, macOS o Unix:
```
1. aws rds restore-db-instance-to-point-in-time \
2. --source-db-instance-identifier mysourcedbinstance \
3. --target-db-instance-identifier mytargetdbinstance \
4. --restore-time 2017-10-14T23:45:00.000Z \
5. --allocated-storage 100 \
6. --max-allocated-storage 1000
```
Per Windows:
```
1. aws rds restore-db-instance-to-point-in-time ^
2. --source-db-instance-identifier mysourcedbinstance ^
3. --target-db-instance-identifier mytargetdbinstance ^
4. --restore-time 2017-10-14T23:45:00.000Z ^
5. --allocated-storage 100 ^
6. --max-allocated-storage 1000
```
**Example**
L'esempio seguente mostra l'aggiunta di un volume quando si ripristina l'istanza in un determinato momento.
Per Linux, macOS o Unix:
```
1. aws rds restore-db-instance-to-point-in-time \
2. --source-db-instance-identifier my-asv-instance \
3. --target-db-instance-identifier my-pitr-instance \
4. --use-latest-restorable-time \
5. --additional-storage-volumes '[{ \
6. "VolumeName": "rdsdbdata2", \
7. "StorageType":"gp3", \
8. "AllocatedStorage": 5000, \
9. "IOPS": 12000 \
10. }]'
```
Per Windows:
```
1. aws rds restore-db-instance-to-point-in-time ^
2. --source-db-instance-identifier my-asv-instance ^
3. --target-db-instance-identifier my-pitr-instance ^
4. --use-latest-restorable-time ^
5. --additional-storage-volumes '[{ ^
6. "VolumeName": "rdsdbdata2", ^
7. "StorageType":"gp3", ^
8. "AllocatedStorage": 5000, ^
9. "IOPS": 12000 ^
10. }]'
```
## API RDS
Per ripristinare un'istanza database a un punto temporale specifico, utilizzare l'operazione API Amazon RDS [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) con i parametri seguenti:
+ `SourceDBInstanceIdentifier`
+ `TargetDBInstanceIdentifier`
+ `RestoreTime`
# Ripristino di un cluster di database Multi-AZ a un determinato momento
È possibile ripristinare un cluster di database Multi-AZ a un determinato momento, creando un nuovo cluster di database Multi-AZ.
RDS carica i log delle transazioni per i cluster database Multi-AZ in Amazon S3 continuamente. Puoi eseguire il ripristino point-in-time durante il tempo di conservazione del backup. Per visualizzare l'ora di ripristino più vecchia per un cluster di database Multi-AZ, utilizzare il comando AWS CLI [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html). Guarda il valore restituito nel campo `EarliestRestorableTime` per il cluster di database. Per visualizzare l'ultima ora di ripristino per un cluster di database Multi-AZ, guarda il valore restituito nel campo `LatestRestorableTime` per il cluster di database.
Quando si utilizza il ripristino point-in-time per un cluster di database Multi-AZ, è possibile scegliere il gruppo di sicurezza VPC predefinito per il cluster di database Multi-AZ o applicare un gruppo di sicurezza VPC personalizzato al cluster di database Multi-AZ.
I cluster database Multi-AZ ripristinati vengono associati automaticamente al gruppo di parametri del cluster di datababse predefinito. Tuttavia, è possibile applicare un gruppo di parametri personalizzato del cluster di database specificandolo durante un ripristino.
Se il cluster di database di origine ha tag di risorsa, RDS aggiunge i tag più recenti al cluster di database ripristinato.
**Nota**
Si consiglia di ripristinare una dimensione identica o simile del cluster di database Multi-AZ come cluster di database di origine. Si consiglia inoltre di eseguire il ripristino con un valore IOPS uguale o simile se si utilizza l’archiviazione IOPS con provisioning. È possibile che venga visualizzato un errore se, ad esempio, si sceglie una dimensione di cluster database con un valore IOPS incompatibile.
Se il cluster di database Multi-AZ di origine utilizza l’archiviazione SSD per scopi generici (gp3) e dispone di meno di 400 GiB di archiviazione allocata, non è possibile modificare la capacità di IOPS allocata per il cluster di database ripristinato.
Per informazioni sul ripristino di un cluster di database Multi-AZ con una versione del supporto esteso RDS, consultare [Ripristino di un’istanza database o di un cluster di database Multi-AZ con il supporto esteso per Amazon RDS](extended-support-restoring-db-instance.md).
Puoi ripristinare un cluster di database Multi-AZ a un punto temporale specifico usando la Console di gestione AWS, AWS CLI o l'API di RDS.
## Console
**Per ripristinare un cluster di database Multi-AZ a un determinato momento**
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 **Databases (Database)**.
1. Seleziona il cluster di database Multi-AZ che desideri ripristinare.
1. In **Actions (Operazioni)**, scegli **Restore to point in time (Ripristina a un istante temporale)**.
Viene visualizzata la finestra **Restore to point in time (Ripristina a un istante temporale)**.
1. Scegliere **Latest restorable time (Ultimo orario di ripristino)** per eseguire il ripristino in base al momento più recente oppure scegliere **Custom (Personalizzato)** per scegliere una data e un'ora.
Se scegli **Custom (Personalizzato)**, specifica la data e l'ora in cui desideri ripristinare il cluster di database Multi-AZ.
**Nota**
Gli orari vengono visualizzati nel fuso orario locale, indicato come un offset dell'ora UTC (Coordinated Universal Time). Ad esempio, UTC-5 è l'orario standard degli Stati Uniti orientali/ora legale degli Stati Uniti centrali.
1. Per **Identificativo cluster di database**, specificare il nome del cluster di database Multi-AZ ripristinato.
1. In **Availability and durability (Disponibilità e durabilità)**, scegliere **Multi-AZ DB cluster (Cluster di database Multi-AZ)**.
![\[Scelta cluster di database Multi-AZ\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/multi-az-db-cluster-create.png)
1. In **DB instance class (classe dell'istanza del database)**, selezionare una classe dell’istanza database.
Attualmente, i cluster di database Multi-AZ supportano solo le classi di istanza database db.m6gd e db.r6gd. Per altre informazioni sulle classi di istanza database, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
1. Per le restanti sezioni, specifica le impostazioni del cluster di database. Per informazioni su ciascuna impostazione, consulta [Impostazioni per la creazione di cluster di database Multi-AZ](create-multi-az-db-cluster.md#create-multi-az-db-cluster-settings).
1. Scegli **Restore to point in time (Ripristina per punto nel tempo)**.
## AWS CLI
Per ripristinare un cluster di database Multi-AZ a un punto temporale specifico, utilizzare il comando AWS CLI[restore-db-cluster-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-to-point-in-time.html) per creare un nuovo cluster di database Multi-AZ.
Attualmente, i cluster di database Multi-AZ supportano solo le classi di istanza database db.m6gd e db.r6gd. Per altre informazioni sulle classi di istanza database, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
**Example**
Per Linux, macOS o Unix:
```
1. aws rds restore-db-cluster-to-point-in-time \
2. --source-db-cluster-identifier mysourcemultiazdbcluster \
3. --db-cluster-identifier mytargetmultiazdbcluster \
4. --restore-to-time 2021-08-14T23:45:00.000Z \
5. --db-cluster-instance-class db.r6gd.xlarge
```
Per Windows:
```
1. aws rds restore-db-cluster-to-point-in-time ^
2. --source-db-cluster-identifier mysourcemultiazdbcluster ^
3. --db-cluster-identifier mytargetmultiazdbcluster ^
4. --restore-to-time 2021-08-14T23:45:00.000Z ^
5. --db-cluster-instance-class db.r6gd.xlarge
```
## API RDS
Per ripristinare un cluster database a un punto temporale specifico, utilizzare l'operazione API Amazon RDS [RestoreDBClusterToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html) con i parametri seguenti:
+ `SourceDBClusterIdentifier`
+ `DBClusterIdentifier`
+ `RestoreToTime`
# Ripristino da uno snapshot a un cluster di database Multi-AZ
È possibile ripristinare un'istantanea in un cluster DB Multi-AZ utilizzando l'API Console di gestione AWS AWS CLI, the o RDS. È possibile ripristinare ciascuno di questi tipi di snapshot in un cluster di database Multi-AZ:
+ Uno snapshot di implementazione single-AZ
+ Uno snapshot dell’implementazione del cluster di database Multi-AZ con una singola istanza database
+ Uno snapshot di un cluster di database Multi-AZ
Per informazioni sulle implementazioni multi-AZ, consulta [Configurazione e gestione di un’implementazione Multi-AZ per Amazon RDS](Concepts.MultiAZ.md).
**Suggerimento**
È possibile eseguire la migrazione di un’implementazione Single-AZ o di un’implementazione di cluster di database Multi-AZ a un’implementazione di cluster di database Multi-AZ ripristinando uno snapshot.
Per informazioni sul ripristino del cluster di database Multi-AZ con una versione del supporto esteso RDS, consulta [Ripristino di un’istanza database o di un cluster di database Multi-AZ con il supporto esteso per Amazon RDS](extended-support-restoring-db-instance.md).
## Console
**Per ripristinare uno snapshot a un cluster di database Multi-AZ**
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 il ripristino.
1. Per **Actions (Operazioni)**, selezionare **Restore Snapshot (Ripristina snapshot)**.
1. Nella pagina **Restore snapshots (Ripristina snapshot)**, in **Availability and durability (Disponibilità e durabilità)**, scegliere **Multi-AZ DB cluster** (Cluster di database Multi-AZ).
![\[Scelta cluster di database Multi-AZ\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/multi-az-db-cluster-create.png)
1. Per **Identificativo cluster database**, specifica il nome del cluster database Multi-AZ ripristinato.
1. Per le restanti sezioni, specifica le impostazioni del cluster di database. Per informazioni su ciascuna impostazione, consulta [Impostazioni per la creazione di cluster di database Multi-AZ](create-multi-az-db-cluster.md#create-multi-az-db-cluster-settings).
1. Selezionare **Ripristina istanza database**.
## AWS CLI
[Per ripristinare un'istantanea in un cluster DB Multi-AZ, usa il AWS CLI comando -snapshot. restore-db-cluster-from](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-from-snapshot.html)
Nel seguente esempio il ripristino avviene da uno snapshot creato precedentemente e denominato `mysnapshot`. Viene ripristinato un nuovo cluster di database Multi-AZ denominato `mynewmultiazdbcluster`. È inoltre possibile specificare la classe di istanza database utilizzata dalle istanze database nel cluster di database Multi-AZ. Specificare `mysql` o `postgres` per il motore di database.
Per l’opzione `--snapshot-identifier`, è possibile utilizzare il nome o l'Amazon Resource Name (ARN) per specificare uno snapshot del cluster di database. Tuttavia, è possibile utilizzare solo l'ARN per specificare uno snapshot di database.
Per l'opzione `--db-cluster-instance-class`, specifica la classe di istanza database per il nuovo cluster database multi-AZ. I cluster database multi-AZ supportano solo classi di istanza database specifiche, come le classi di istanza database db.m6gd e db.r6gd. Per maggiori informazioni sulle classi di istanza database, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
Puoi anche specificare altre opzioni.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds restore-db-cluster-from-snapshot \
2. --db-cluster-identifier mynewmultiazdbcluster \
3. --snapshot-identifier mysnapshot \
4. --engine mysql|postgres \
5. --db-cluster-instance-class db.r6gd.xlarge
```
Per Windows:
```
1. aws rds restore-db-cluster-from-snapshot ^
2. --db-cluster-identifier mynewmultiazdbcluster ^
3. --snapshot-identifier mysnapshot ^
4. --engine mysql|postgres ^
5. --db-cluster-instance-class db.r6gd.xlarge
```
Dopo il ripristino del cluster database, puoi aggiungere il cluster database multi-AZ al gruppo di sicurezza associato all'istanza database o al cluster database usato per creare lo snapshot, se opportuno. In questo modo viene fornita la stessa funzionalità del cluster database o dell'istanza database precedente.
## API RDS
[Per ripristinare un'istantanea in un cluster DB Multi-AZ, chiamate l'operazione Restore dell'API RDS con i seguenti parametri: DBCluster FromSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html)
+ `DBClusterIdentifier`
+ `SnapshotIdentifier`
+ `Engine`
Puoi inoltre specificare altri parametri facoltativi.
Dopo il ripristino del cluster database, puoi aggiungere il cluster database multi-AZ al gruppo di sicurezza associato all'istanza database o al cluster database usato per creare lo snapshot, se opportuno. In questo modo viene fornita la stessa funzionalità del cluster database o dell'istanza database precedente.
# Ripristino di uno snapshot di cluster database multi-AZ a un'istanza database
Uno *snapshot di cluster database multi-AZ* è uno snapshot dei volumi di archiviazione del cluster database con il backup dell'intero cluster database anziché dei singoli database. Puoi ripristinare uno snapshot di cluster database multi-AZ in un'implementazione single-AZ o a un'implementazione di istanza database multi-AZ. Per informazioni sulle implementazioni multi-AZ, consulta [Configurazione e gestione di un’implementazione Multi-AZ per Amazon RDS](Concepts.MultiAZ.md).
**Nota**
È inoltre possibile ripristinare uno snapshot di cluster database multi-AZ in un nuovo cluster database multi-AZ. Per istruzioni, consulta [Ripristino da uno snapshot a un cluster di database Multi-AZ](USER_RestoreFromMultiAZDBClusterSnapshot.Restoring.md).
Per informazioni sul ripristino di un cluster di database Multi-AZ con una versione del supporto esteso RDS, consultare [Ripristino di un’istanza database o di un cluster di database Multi-AZ con il supporto esteso per Amazon RDS](extended-support-restoring-db-instance.md).
Utilizza l'API Console di gestione AWS AWS CLI, the o RDS per ripristinare uno snapshot del cluster DB Multi-AZ in una distribuzione Single-AZ o in un'istanza DB Multi-AZ.
## Console
**Per ripristinare uno snapshot di cluster database multi-AZ in un'implementazione single-AZ o in un'implementazione di istanza database multi-AZ**
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 lo snapshot di cluster database multi-AZ di cui vuoi eseguire il ripristino.
1. Per **Actions (Operazioni)**, selezionare **Restore Snapshot (Ripristina snapshot)**.
1. Nella pagina **Restore snapshot** (Ripristina snapshot), in **Availability and durability** (Disponibilità e durabilità), scegli una delle seguenti opzioni:
+ **Single DB instance** (Istanza database singola): ripristina lo snapshot in una sola istanza database senza istanza database in standby.
+ **Multi-AZ DB instance** (Istanza database multi-AZ): ripristina lo snapshot in un'implementazione di istanza database multi-AZ con un'istanza database primaria e un'istanza database standby.
1. Per **DB Instance Identifier** (Identificatore di istanza database), immetti il nome dell'istanza database ripristinata.
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. Selezionare **Ripristina istanza database**.
## AWS CLI
[Per ripristinare uno snapshot del cluster DB Multi-AZ in una distribuzione di istanza DB, usa il AWS CLI comando -db-snapshot. restore-db-instance-from](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
Nell'esempio seguente si esegue il ripristino di uno snapshot di cluster database multi-AZ creato in precedenza denominato `myclustersnapshot`. Viene ripristinato in una nuova implementazione di istanza database multi-AZ con un'istanza database primaria denominata `mynewdbinstance`. Per l'opzione `--db-cluster-snapshot-identifier`, specifica il nome dello snapshot di cluster database multi-AZ.
Per l'opzione `--db-instance-class`, specifica la classe di istanza database per la nuova implementazione di istanza database. Per maggiori informazioni sulle classi di istanza database, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
Puoi anche specificare altre opzioni.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds restore-db-instance-from-db-snapshot \
2. --db-instance-identifier mynewdbinstance \
3. --db-cluster-snapshot-identifier myclustersnapshot \
4. --engine mysql \
5. --multi-az \
6. --db-instance-class db.r6g.xlarge
```
Per Windows:
```
1. aws rds restore-db-instance-from-db-snapshot ^
2. --db-instance-identifier mynewdbinstance ^
3. --db-cluster-snapshot-identifier myclustersnapshot ^
4. --engine mysql ^
5. --multi-az ^
6. --db-instance-class db.r6g.xlarge
```
Dopo il ripristino dell'istanza database, puoi aggiungerla al gruppo di sicurezza associato al cluster database multi-AZ utilizzato per creare lo snapshot, se opportuno. In questo modo viene fornita la stessa funzionalità del cluster database multi-AZ precedente.
## API RDS
[Per ripristinare uno snapshot del cluster DB Multi-AZ in una distribuzione di istanza DB, chiama l'operazione Restore From dell'API RDS con i seguenti parametri: DBInstance DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ `DBInstanceIdentifier`
+ `DBClusterSnapshotIdentifier`
+ `Engine`
Puoi inoltre specificare altri parametri facoltativi.
Dopo il ripristino dell'istanza database, puoi aggiungerla al gruppo di sicurezza associato al cluster database multi-AZ utilizzato per creare lo snapshot, se opportuno. In questo modo viene fornita la stessa funzionalità del cluster database multi-AZ precedente.
# Tutorial: ripristino di un'istanza database Amazon RDS da uno snapshot DB
Spesso quando lavori con Amazon RDS hai un'istanza database che utilizzi occasionalmente e non a tempo pieno. Ad esempio, supponi di avere un sondaggio trimestrale sui clienti che utilizza un'istanza Amazon EC2 per ospitare un sito Web di sondaggi sui clienti. Hai anche un'istanza database che viene utilizzata per archiviare i risultati del sondaggio. Un modo per risparmiare denaro in uno scenario del genere è acquisire uno snapshot DB dell'istanza database dopo il completamento del sondaggio. Quindi elimini l'istanza database e la ripristini quando devi ripetere il sondaggio.
Quando ripristini l'istanza database, fornisci il nome dello snapshot DB da cui eseguire il ripristino. Quindi specifichi un nome per la nuova istanza database creata dall'operazione di ripristino.
Per ulteriori informazioni sul ripristino di un'istanza database da uno snapshot, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
Per informazioni sulla gestione delle chiavi AWS KMS di Amazon RDS, consulta [AWS KMS key gestione](Overview.Encryption.Keys.md).
## Ripristino di un'istanza database da uno snapshot DB
Procedi come segue per eseguire il ripristino da uno snapshot nella Console di gestione AWS.
**Per ripristinare un'istanza database da uno snapshot DB**
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, selezionare **Snapshots (Snapshot)**.
1. Scegliere la snapshot DB dalla quale effettuare il ripristino.
1. Per **Actions (Operazioni)**, selezionare **Restore Snapshot (Ripristina snapshot)**.
![\[Opzione Restore snapshot (Ripristina snapshot) nel menu Actions (Operazioni) nella console RDS\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tut-restore-instance1.png)
Viene visualizzata la pagina **Restore snapshot (Ripristina snapshot)**.
![\[Pagina Restore snapshot (Ripristina snapshot)\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tut-restore-instance2.png)
1. Sotto **DB instance settings** (Impostazioni dell'istanza database), utilizza le impostazioni di default per **DB engine** (Motore del database) e **License model** (Modello di licenza) (per Oracle o Microsoft SQL Server).
1. Sotto **Settings** (Impostazioni), per **DB instance identifier** (Identificatore istanze DB) inserisci il nome univoco da usare per l'istanza database ripristinata, ad esempio **mynewdbinstance**.
Se si sta eseguendo il ripristino da un'istanza database eliminata dopo aver creato lo snapshot DB, è possibile usare il nome dell'istanza database.
1. In **Durabilità e disponibilità**, scegli se creare un'istanza in standby in un'altra zona di disponibilità.
Per questo tutorial, non creare un'istanza in standby.
1. Sotto **Connectivity** (Connettività), utilizza le impostazioni di default per quanto segue:
+ **Virtual Private Cloud (VPC)** (Cloud privato virtuale (VPC)
+ **DB subnet group** (Gruppo di sottoreti DB)
+ **Accesso pubblico**
+ **VPC security group (firewall)** (Gruppo di sicurezza VPC (firewall)
1. Scegli la **DB instance class** (Classe di istanza database).
Per questo tutorial, scegli **Burstable classes (includes t classes)** (Classi espandibili (include le classi t) e quindi scegli **db.t3.small**.
1. Per **Encryption** (Crittografia), utilizza le impostazioni di default.
Se l'istanza database di origine per lo snapshot è stata crittografata, anche l'istanza database ripristinata viene crittografata. Non è possibile renderla non crittografato.
1. Espandi **Additional configuration** (Configurazione aggiuntiva) nella parte inferiore della pagina.
![\[Configurazione aggiuntiva\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tut-restore-instance3.png)
1. Esegui l'operazione seguente sotto **Database options** (Opzioni database):
1. Seleziona il **DB parameter group** (Gruppo parametri del database).
Per questo tutorial, utilizza il gruppo di parametri di default.
1. Scegli **Option group** (Gruppo di opzioni).
Per questo tutorial, utilizza il gruppo di opzioni di default.
**Importante**
In alcuni casi, puoi eseguire il ripristino da uno snapshot DB di un'istanza database che utilizza un'opzione persistente o permanente. In tal caso, assicurati di scegliere un gruppo di opzioni che utilizzi la stessa opzione.
1. Per **Deletion protection** (Protezione da eliminazione), scegli la casella di controllo **Enable deletion protection** (Abilita protezione da eliminazione).
1. Selezionare **Ripristina istanza database**.
La pagina **Databases** (Database) visualizza l'istanza database ripristinata, con uno stato `Creating`.
![\[Istanza database ripristinata nella pagina Database\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tut-restore-instance4.png)
# Copia di uno snapshot del database per Amazon RDS
Con Amazon RDS è possibile copiare backup automatici o snapshot di database manuali. Dopo aver copiato uno snapshot, la copia è uno snapshot manuale. È possibile creare più copie di un backup automatico o di uno snapshot manuale, ma ogni copia deve avere un identificatore univoco.
È possibile copiare un'istantanea all'interno della stessa Regione AWS, copiare un'istantanea e copiare istantanee condivise. Regioni AWSÈ possibile copiare le istantanee su un altro account in Regione AWS un unico passaggio.
## Copia di una snapshot DB.
Per ognuna di esse Account AWS, è possibile copiare fino a 20 istantanee DB alla volta da una Regione AWS all'altra. Se si copia un'istantanea del DB su un'altra Regione AWS, si crea un'istantanea del DB manuale che viene conservata in quella copia. Regione AWS La copia di uno snapshot DB dall'origine comporta costi di Regione AWS trasferimento dati Amazon RDS.
Per ulteriori informazioni sui prezzi del trasferimento dati, consulta [Prezzi di Amazon RDS](https://aws.amazon.com/rds/pricing/).
Dopo che la copia dello snapshot DB è stata creata nel nuovo database Regione AWS, la copia dello snapshot DB si comporta come tutte le altre snapshot DB. Regione AWS
È possibile copiare uno snapshot DB utilizzando Console di gestione AWS, the o l' AWS CLI API RDS.
### Console
La procedura seguente copia uno snapshot DB crittografato o non crittografato, nella stessa regione Regione AWS o in più regioni, utilizzando. Console di gestione AWS
**Come copiare uno snapshot 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. Nel riquadro di navigazione, selezionare **Snapshots (Snapshot)**.
1. Seleziona la snapshot DB che desideri copiare.
1. In **Operazioni**, seleziona **Copia snapshot**.
Viene visualizzata la pagina **Copia snapshot**.
![\[Copia di uno snapshot DB\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/DBSnapshotCopy1.png)
1. Per **Target Option Group (optional)** (Gruppo di opzioni di destinazione (facoltativo)), seleziona un nuovo gruppo di opzioni.
Specificate questa opzione se state copiando uno snapshot da uno Regione AWS all'altro e l'istanza DB utilizza un gruppo di opzioni non predefinito.
Se l'istanza database di origine utilizza Transparent Data Encryption per il server Oracle o Microsoft SQL, devi specificare questa opzione quando esegui la copia tra regioni. Per ulteriori informazioni, consulta [Considerazioni sui gruppi di opzioni](#USER_CopySnapshot.Options).
1. (Facoltativo) Per copiare lo snapshot DB in un'altra Regione AWS, per **Regione di destinazione**, scegli la nuova. Regione AWS
**Nota**
La destinazione Regione AWS deve avere la stessa versione del motore di database disponibile come origine Regione AWS.
1. Per **New DB Snapshot Identifier** (Nuovo identificatore snapshot database), digita il nome della copia dello snapshot di database.
È possibile creare più copie di un backup automatico o di uno snapshot manuale, ma ogni copia deve avere un identificatore univoco.
1. (Facoltativo) Seleziona **Copy Tags (Copia tag)** per copiare i tag e i valori dalla snapshot alla copia della snapshot.
1. (Facoltativo) Per **Crittografia**, effettuare le seguenti operazioni:
1. Scegli **Abilita crittografia** se lo snapshot DB non è crittografato, ma desideri crittografare la copia.
**Nota**
Se lo snapshot DB è crittografato, è necessario crittografare la copia, quindi la casella di controllo è già selezionata.
1. Per **AWS KMS key**, specifica l'identificatore di chiave KMS da utilizzare per crittografare la copia di snapshot DB.
1. Selezionare **Copy Snapshot (Copia snapshot)**.
### AWS CLI
È possibile copiare un'istantanea del DB utilizzando il AWS CLI comando [copy-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/copy-db-snapshot.html). Se stai copiando l'istantanea in una nuova Regione AWS, esegui il comando nella nuova. Regione AWS
Le seguenti opzioni vengono utilizzate per copiare una snapshot DB. Non tutte le opzioni sono necessarie per tutti gli scenari. Utilizza le descrizioni e gli esempi che seguono per determinare quali opzioni utilizzare.
+ `--source-db-snapshot-identifier` – Identificatore per lo snapshot DB origine.
+ Se lo snapshot di origine è Regione AWS uguale alla copia, specificate un identificatore DB snapshot valido. Ad esempio, `rds:mysql-instance1-snapshot-20130805`.
+ Se lo snapshot di origine è nella Regione AWS stessa copia ed è stato condiviso con il tuo Account AWS, specifica un ARN di snapshot DB valido. Ad esempio, `arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805`.
+ Se lo snapshot di origine si trova in un formato Regione AWS diverso da quello della copia, specificare un ARN di snapshot DB valido. Ad esempio, `arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805`.
+ Se stai copiando da uno snapshot DB manuale condiviso, questo parametro deve essere l'Amazon Resource Name (ARN) della snapshot DB condivisa.
+ Se si copia un'istantanea crittografata, questo parametro deve essere nel formato ARN per l'origine Regione AWS e deve corrispondere al `SourceDBSnapshotIdentifier` parametro. `PreSignedUrl`
+ `--target-db-snapshot-identifier` – Identificatore per la nuova copia dello snapshot DB crittografato.
+ `--copy-option-group` – Copia il gruppo di opzioni da uno snapshot che è stato condiviso con il tuo Account AWS.
+ `--copy-tags` – Includi l'opzione di copia dei tag e i valori dello snapshot nella copia dello snapshot.
+ `--option-group-name` – Gruppo di opzioni da associare alla copia dello snapshot.
Specificate questa opzione se state copiando uno snapshot da uno Regione AWS all'altro e l'istanza DB utilizza un gruppo di opzioni non predefinito.
Se l'istanza database di origine utilizza Transparent Data Encryption per il server Oracle o Microsoft SQL, devi specificare questa opzione quando esegui la copia tra regioni. Per ulteriori informazioni, consulta [Considerazioni sui gruppi di opzioni](#USER_CopySnapshot.Options).
+ `--kms-key-id`: l'identificatore di chiave KMS per uno snapshot DB crittografato. L'identificatore della chiave KMS è il nome della risorsa Amazon Resource Name (ARN), l'identificatore della chiave o l'alias della chiave per la chiave KMS.
+ Se copi uno snapshot DB crittografato dal tuo Account AWS, puoi specificare un valore per questo parametro per crittografare la copia con una nuova chiave KMS. Se non specifichi un valore per questo parametro, la copia della snapshot DB viene crittografata con la stessa chiave KMS della snapshot DB origine.
+ Se copi un'istantanea DB crittografata condivisa da un'altra Account AWS, devi specificare un valore per questo parametro.
+ Se specifichi questo parametro quando copi una snapshot crittografata, la copia viene crittografata.
+ Se copi un'istantanea crittografata in un'altra Regione AWS, devi specificare una chiave KMS per la destinazione. Regione AWS Le chiavi KMS sono specifiche del sistema in Regione AWS cui vengono create e non è possibile utilizzare le chiavi di crittografia l'una all'altra Regione AWS . Regione AWS
**Example Da non crittografata, alla stessa regione**
Il codice seguente crea una copia di un'istantanea, con il nuovo nome`mydbsnapshotcopy`, nello stesso dello snapshot Regione AWS di origine. Quando viene creata la copia, il gruppo di opzioni database e i tag dello snapshot originale vengono copiati nella copia dello snapshot.
Per Linux, macOS o Unix:
```
aws rds copy-db-snapshot \
--source-db-snapshot-identifier arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805 \
--target-db-snapshot-identifier mydbsnapshotcopy \
--copy-option-group \
--copy-tags
```
Per Windows:
```
aws rds copy-db-snapshot ^
--source-db-snapshot-identifier arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805 ^
--target-db-snapshot-identifier mydbsnapshotcopy ^
--copy-option-group ^
--copy-tags
```
**Example Da non crittografata, tra regioni**
Il codice seguente crea una copia di un'istantanea, con il nuovo nome`mydbsnapshotcopy`, Regione AWS nella quale viene eseguito il comando.
Per Linux, macOS o Unix:
```
aws rds copy-db-snapshot \
--source-db-snapshot-identifier arn:aws:rds:us-east-1:123456789012:snapshot:mysql-instance1-snapshot-20130805 \
--target-db-snapshot-identifier mydbsnapshotcopy
```
Per Windows:
```
aws rds copy-db-snapshot ^
--source-db-snapshot-identifier arn:aws:rds:us-east-1:123456789012:snapshot:mysql-instance1-snapshot-20130805 ^
--target-db-snapshot-identifier mydbsnapshotcopy
```
**Example Da crittografata, tra regioni**
Nell'esempio di codice riportato di seguito viene copiata uno snapshot DB crittografato dalla regione Stati Uniti occidentali (Oregon) alla regione US East (N. Virginia). Emetti il comando nella regione di destinazione (us-est-1).
Per Linux, macOS o Unix:
```
aws rds copy-db-snapshot \
--source-db-snapshot-identifier arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20161115 \
--target-db-snapshot-identifier mydbsnapshotcopy \
--kms-key-id my-us-east-1-key \
--option-group-name custom-option-group-name
```
Per Windows:
```
aws rds copy-db-snapshot ^
--source-db-snapshot-identifier arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20161115 ^
--target-db-snapshot-identifier mydbsnapshotcopy ^
--kms-key-id my-us-east-1-key ^
--option-group-name custom-option-group-name
```
Il `--source-region` parametro è obbligatorio quando si copia un'istantanea crittografata tra le regioni AWS GovCloud (Stati Uniti orientali) e AWS GovCloud (Stati Uniti occidentali). Per `--source-region`, specificare la Regione AWS dell'istanza database di origine.
Se non si specifica `--source-region`, è necessario specificare un valore per `--pre-signed-url`. Un *URL prefirmato* è un URL che contiene una richiesta firmata Signature Versione 4 per il comando `copy-db-snapshot` chiamato nella Regione AWS di origine. *Per ulteriori informazioni sull'`pre-signed-url`opzione, consulta [copy-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/copy-db-snapshot.html)la sezione Command Reference.AWS CLI *
### API RDS
[Puoi copiare uno snapshot DB utilizzando l'operazione Copy dell'API Amazon RDS. DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CopyDBSnapshot.html) Se stai copiando lo snapshot su uno nuovo Regione AWS, esegui l'azione nel nuovo. Regione AWS
I seguenti parametri vengono utilizzati per copiare una snapshot DB. Non tutti parametri sono necessari per tutti gli scenari. Utilizza le descrizioni e gli esempi che seguono per determinare quali parametri utilizzare.
+ `SourceDBSnapshotIdentifier` – Identificatore per lo snapshot DB origine.
+ Se lo snapshot di origine è Regione AWS uguale alla copia, specificate un identificatore DB snapshot valido. Ad esempio, `rds:mysql-instance1-snapshot-20130805`.
+ Se lo snapshot di origine è nella Regione AWS stessa copia ed è stato condiviso con il tuo Account AWS, specifica un ARN di snapshot DB valido. Ad esempio, `arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805`.
+ Se lo snapshot di origine si trova in un formato Regione AWS diverso da quello della copia, specificare un ARN di snapshot DB valido. Ad esempio, `arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805`.
+ Se stai copiando da uno snapshot DB manuale condiviso, questo parametro deve essere l'Amazon Resource Name (ARN) della snapshot DB condivisa.
+ Se si copia un'istantanea crittografata, questo parametro deve essere nel formato ARN per l'origine Regione AWS e deve corrispondere al `SourceDBSnapshotIdentifier` parametro. `PreSignedUrl`
+ `TargetDBSnapshotIdentifier` – Identificatore per la nuova copia dello snapshot DB crittografato.
+ `CopyOptionGroup` – Imposta questo parametro su `true` per copiare il gruppo di opzioni dallo snapshot condiviso alla copia dello snapshot. Il valore predefinito è `false`.
+ `CopyTags` – Imposta questo parametro su `true` per copiare i tag e i valori dallo snapshot alla copia dello snapshot. Il valore di default è `false`.
+ `OptionGroupName` – Gruppo di opzioni da associare alla copia dello snapshot.
Specificate questo parametro se state copiando uno snapshot da uno Regione AWS all'altro e l'istanza DB utilizza un gruppo di opzioni non predefinito.
Se l'istanza database di origine utilizza Transparent Data Encryption per il server Oracle o Microsoft SQL, devi specificare questo parametro quando esegui la copia tra regioni. Per ulteriori informazioni, consulta [Considerazioni sui gruppi di opzioni](#USER_CopySnapshot.Options).
+ `KmsKeyId`: l'identificatore di chiave KMS per uno snapshot DB crittografato. L'identificatore della chiave KMS è il nome della risorsa Amazon Resource Name (ARN), l'identificatore della chiave o l'alias della chiave per la chiave KMS.
+ Se copi uno snapshot DB crittografato dal tuo Account AWS, puoi specificare un valore per questo parametro per crittografare la copia con una nuova chiave KMS. Se non specifichi un valore per questo parametro, la copia della snapshot DB viene crittografata con la stessa chiave KMS della snapshot DB origine.
+ Se copi un'istantanea DB crittografata condivisa da un'altra Account AWS, devi specificare un valore per questo parametro.
+ Se specifichi questo parametro quando copi una snapshot crittografata, la copia viene crittografata.
+ Se copi un'istantanea crittografata in un'altra Regione AWS, devi specificare una chiave KMS per la destinazione. Regione AWS Le chiavi KMS sono specifiche del sistema in Regione AWS cui vengono create e non è possibile utilizzare le chiavi di crittografia l'una nell'altra Regione AWS . Regione AWS
+ `PreSignedUrl`— L'URL che contiene una richiesta firmata Signature Version 4 per l'operazione `CopyDBSnapshot` API nell'origine Regione AWS che contiene lo snapshot del DB di origine da copiare.
Specificare questo parametro quando si copia uno snapshot DB crittografato Regione AWS da un altro utilizzando l'API Amazon RDS. Puoi specificare l'opzione della regione di origine anziché questo parametro quando copi uno snapshot di database crittografato da un'altra Regione AWS utilizzando la AWS CLI.
L'URL prefirmato deve essere una richiesta valida per l'operazione API `CopyDBSnapshot` che può essere eseguita nella Regione AWS di origine che contiene lo snapshot di database crittografato da copiare. La richiesta URL prefirmata deve contenere i seguenti valori di parametro:
+ `DestinationRegion`— In Regione AWS cui verrà copiata la snapshot DB crittografata. Regione AWS È la stessa in cui viene chiamata l'`CopyDBSnapshot`operazione che contiene questo URL predefinito.
Si assuma, ad esempio, di copiare uno snapshot DB crittografato dalla regione us-west-2 nella regione us-est-1. È quindi necessario richiamare l’operazione `CopyDBSnapshot` nella regione us-east-1 e fornire un URL prefirmato che contenga una chiamata all’operazione `CopyDBSnapshot` nella regione us-west-2. In questo esempio, `DestinationRegion` nell'URL prefirmato deve essere impostato sulla regione Stati Uniti orientali 1.
+ `KmsKeyId`: l'identificatore della chiave KMS per la chiave da utilizzare per crittografare la copia dello snapshot di database nella Regione AWS di destinazione. Si tratta dello stesso identificatore sia per l'`CopyDBSnapshot`operazione chiamata nella destinazione Regione AWS sia per l'operazione contenuta nell'URL predefinito.
+ `SourceDBSnapshotIdentifier` – L'identificatore di snapshot DB per lo snapshot crittografato da copiare. L'identificatore deve essere nel formato Amazon Resource Name (ARN) per la Regione AWS di origine. Ad esempio, se copi uno snapshot del database crittografato dalla Regione us-west-2, `SourceDBSnapshotIdentifier` ha il seguente formato: `arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20161115`.
Per ulteriori informazioni sulle richieste firmate Signature Version 4, consulta quanto segue:
+ [Autenticazione delle richieste: utilizzo dei parametri di query (versione 4 AWS della firma)](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) nell'Amazon Simple Storage Service API Reference
+ [Processo di firma della versione 4 di Signature](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in Riferimenti generali di AWS
**Example Da non crittografata, alla stessa regione**
Il codice seguente crea una copia di un'istantanea, con il nuovo nome`mydbsnapshotcopy`, con lo stesso Regione AWS nome dell'istantanea di origine. Quando viene creata la copia, tutti i tag della snapshot originale vengono copiati nella copia della snapshot.
```
https://rds.us-west-1.amazonaws.com/
?Action=CopyDBSnapshot
&CopyTags=true
&SignatureMethod=HmacSHA256
&SignatureVersion=4
&SourceDBSnapshotIdentifier=mysql-instance1-snapshot-20130805
&TargetDBSnapshotIdentifier=mydbsnapshotcopy
&Version=2013-09-09
&X-Amz-Algorithm=AWS4-HMAC-SHA256
&X-Amz-Credential=AKIADQKE4SARGYLE/20140429/us-west-1/rds/aws4_request
&X-Amz-Date=20140429T175351Z
&X-Amz-SignedHeaders=content-type;host;user-agent;x-amz-content-sha256;x-amz-date
&X-Amz-Signature=9164337efa99caf850e874a1cb7ef62f3cea29d0b448b9e0e7c53b288ddffed2
```
**Example Da non crittografata, tra regioni**
Il seguente codice crea una copia di uno snapshot, con il nuovo nome `mydbsnapshotcopy`, nella regione Stati Uniti occidentali (California settentrionale).
```
https://rds.us-west-1.amazonaws.com/
?Action=CopyDBSnapshot
&SignatureMethod=HmacSHA256
&SignatureVersion=4
&SourceDBSnapshotIdentifier=arn%3Aaws%3Ards%3Aus-east-1%3A123456789012%3Asnapshot%3Amysql-instance1-snapshot-20130805
&TargetDBSnapshotIdentifier=mydbsnapshotcopy
&Version=2013-09-09
&X-Amz-Algorithm=AWS4-HMAC-SHA256
&X-Amz-Credential=AKIADQKE4SARGYLE/20140429/us-west-1/rds/aws4_request
&X-Amz-Date=20140429T175351Z
&X-Amz-SignedHeaders=content-type;host;user-agent;x-amz-content-sha256;x-amz-date
&X-Amz-Signature=9164337efa99caf850e874a1cb7ef62f3cea29d0b448b9e0e7c53b288ddffed2
```
**Example Da crittografata, tra regioni**
Il seguente codice crea una copia di uno snapshot, con il nuovo nome `mydbsnapshotcopy`, nella regione US East (N. Virginia).
```
https://rds.us-east-1.amazonaws.com/
?Action=CopyDBSnapshot
&KmsKeyId=my-us-east-1-key
&OptionGroupName=custom-option-group-name
&PreSignedUrl=https%253A%252F%252Frds.us-west-2.amazonaws.com%252F
%253FAction%253DCopyDBSnapshot
%2526DestinationRegion%253Dus-east-1
%2526KmsKeyId%253Dmy-us-east-1-key
%2526SourceDBSnapshotIdentifier%253Darn%25253Aaws%25253Ards%25253Aus-west-2%25253A123456789012%25253Asnapshot%25253Amysql-instance1-snapshot-20161115
%2526SignatureMethod%253DHmacSHA256
%2526SignatureVersion%253D4
%2526Version%253D2014-10-31
%2526X-Amz-Algorithm%253DAWS4-HMAC-SHA256
%2526X-Amz-Credential%253DAKIADQKE4SARGYLE%252F20161117%252Fus-west-2%252Frds%252Faws4_request
%2526X-Amz-Date%253D20161117T215409Z
%2526X-Amz-Expires%253D3600
%2526X-Amz-SignedHeaders%253Dcontent-type%253Bhost%253Buser-agent%253Bx-amz-content-sha256%253Bx-amz-date
%2526X-Amz-Signature%253D255a0f17b4e717d3b67fad163c3ec26573b882c03a65523522cf890a67fca613
&SignatureMethod=HmacSHA256
&SignatureVersion=4
&SourceDBSnapshotIdentifier=arn%3Aaws%3Ards%3Aus-west-2%3A123456789012%3Asnapshot%3Amysql-instance1-snapshot-20161115
&TargetDBSnapshotIdentifier=mydbsnapshotcopy
&Version=2014-10-31
&X-Amz-Algorithm=AWS4-HMAC-SHA256
&X-Amz-Credential=AKIADQKE4SARGYLE/20161117/us-east-1/rds/aws4_request
&X-Amz-Date=20161117T221704Z
&X-Amz-SignedHeaders=content-type;host;user-agent;x-amz-content-sha256;x-amz-date
&X-Amz-Signature=da4f2da66739d2e722c85fcfd225dc27bba7e2b8dbea8d8612434378e52adccf
```
## Limitazioni
Di seguito sono riportate alcune limitazioni che si applicano quando si copiano le snapshot:
+ Non puoi copiare uno snapshot nelle o dalle regioni Cina (Pechino) o Cina (Ningxia).
+ È possibile copiare un'istantanea tra AWS GovCloud (Stati Uniti orientali) e AWS GovCloud (Stati Uniti occidentali). Tuttavia, non è possibile copiare un'istantanea tra queste regioni GovCloud (Stati Uniti) e regioni che non lo GovCloud sono.
+ Se elimini una snapshot origine prima che la snapshot target diventi disponibile, la copia della snapshot potrebbe non riuscire. Verifica che la snapshot target abbia lo stato di `AVAILABLE` prima di eliminare una snapshot origine.
+ Puoi avere un massimo di 20 richieste di copia di snapshot in corso in una singola regione di destinazione per account.
+ Quando vengono richieste più copie di snapshot per la stessa istanza database di origine, vengono accodate internamente. Le copie richieste in seguito non verranno avviate fino al completamento delle copie di snapshot precedenti. Per ulteriori informazioni, consulta [Perché la creazione di snapshot EBS o AMI EC2](https://aws.amazon.com/premiumsupport/knowledge-center/ebs-snapshot-ec2-ami-creation-slow/) è lenta? nel Knowledge Center. AWS
+ A seconda del soggetto Regioni AWS coinvolto e della quantità di dati da copiare, il completamento di una copia istantanea tra diverse regioni può richiedere ore. In alcuni casi, potrebbe esserci un numero elevato di richieste di copia di snapshot tra regioni da una determinata regione di origine. In questi casi, Amazon RDS potrebbe mettere in coda le richieste di copia tra regioni provenienti dalla regione di origine fino al completamento di alcune copie in corso. Nessuna informazione di progresso viene visualizzata sulle richieste di copia mentre sono in coda. Le informazioni sul progresso vengono visualizzate quando inizia la copia.
+ Se una copia è ancora in sospeso quando si avvia un'altra copia, la seconda copia sarà avviata solo al termine della prima copia.
+ Non è possibile copiare uno snapshot di un cluster di database Multi-AZ.
+ È possibile copiare solo istantanee di istanze DB che utilizzano volumi io2 Regioni AWS laddove sono disponibili volumi io2 Block Express. Per ulteriori informazioni, consulta [Storage delle istanze di database Amazon RDS](CHAP_Storage.md).
## Considerazioni
Per considerazioni sulla copia di uno snapshot del database, consulta i seguenti argomenti.
**Topics**
+ [Conservare gli snapshot](#USER_CopySnapshot.Retention)
+ [Considerazioni sulla copia di snapshot condivisi](#USER_CopySnapshot.Shared)
+ [Considerazioni sulla copia crittografata delle istantanee](#USER_CopySnapshot.Encryption)
+ [Considerazioni sulla copia di snapshot incrementali](#USER_CopySnapshot.Incremental)
+ [Considerazioni sulla copia di snapshot tra Regioni](#USER_CopySnapshot.AcrossRegions)
+ [Considerazioni sui gruppi di opzioni](#USER_CopySnapshot.Options)
+ [Considerazioni sui gruppi di parametri](#USER_CopySnapshot.Parameters)
### Conservare gli snapshot
Amazon RDS elimina i backup automatici in diverse situazioni:
+ Al termine del periodo di conservazione.
+ Quando si disabilitano i backup automatici per una istanza database.
+ Quando si elimina una istanza database.
Se si desidera mantenere uno snapshot automatico per un periodo più lungo, è possbile copiarlo e creare uno snapshot manuale che sarà conservato finché non lo si elimina personalmente. I costi di archiviazione di Amazon RDS potrebbero applicarsi agli snapshot manuali se superano lo spazio di archiviazione predefinito.
Per ulteriori informazioni sui costi di storage dei backup, consulta [Prezzi di Amazon RDS](https://aws.amazon.com/rds/pricing/).
### Considerazioni sulla copia di snapshot condivisi
Puoi copiare istantanee condivise con te da altri. Account AWS In alcuni casi, è possibile copiare un'istantanea crittografata che è stata condivisa da un'altra persona. Account AWS In questi casi, è necessario avere accesso allo AWS KMS key strumento utilizzato per crittografare l'istantanea.
**Nota**
I costi di archiviazione di Amazon RDS si applicano agli snapshot condivisi che vengono copiati. Amazon RDS potrebbe allegare l’ARN dell’istanza database di origine allo snapshot copiato.
È possibile copiare uno snapshot DB condiviso Regioni AWS se lo snapshot non è crittografato.
**Nota**
La copia di istantanee incrementali condivise nello stesso Regione AWS è supportata quando non sono crittografate o crittografate utilizzando la stessa chiave KMS dello snapshot completo iniziale. Se si utilizza una chiave del servizio di gestione delle chiavi diversa per crittografare le istantanee successive durante la copia, tali snapshot condivisi sono istantanee complete. Per ulteriori informazioni, consulta [Considerazioni sulla copia di snapshot incrementali](#USER_CopySnapshot.Incremental).
#### Copia tra regioni e più account in un unico passaggio
Per copiare un'istantanea tra regioni e più account in un'unica operazione, devi prima condividere l'istantanea con l'account di destinazione. AWS Se l'istantanea è crittografata, devi anche condividere la AWS KMS chiave con l'account di destinazione. AWS Se l'istantanea è crittografata con la AWS KMS chiave predefinita, è necessario prima copiarla per crittografarla nuovamente con una chiave gestita dal cliente prima di condividerla con l'account di destinazione. Una volta condivisa, puoi iniziarne una copia su quell'account (interno o interregionale) dall'account di destinazione.
### Considerazioni sulla copia crittografata delle istantanee
Puoi copiare una snapshot che è stata crittografata utilizzando una chiave KMS. Se la copia di una snapshot crittografata, la copia della snapshot deve anche essere crittografata. Se si copia un'istantanea crittografata all'interno della stessa Regione AWS, è possibile crittografare la copia con la stessa chiave KMS dell'istantanea originale. Oppure puoi specificare una chiave KMS diversa.
Se copi uno snapshot crittografato tra regioni, devi specificare una chiave KMS valida nella Regione AWS di destinazione. Può essere una chiave KMS specifica per la regione o una chiave multi-regione. Per ulteriori informazioni sulle chiavi multi-regione, consulta [Utilizzo delle chiavi multi-regione in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html).
La snapshot di origine resta crittografata nel processo di copia. Per ulteriori informazioni, consulta [Limiti relativi a cluster di database crittografate Amazon RDS](Overview.Encryption.md#Overview.Encryption.Limitations).
Puoi anche crittografare una copia di una snapshot crittografata. In questo modo, puoi aggiungere rapidamente la crittografia a un'istanza database non crittografata. Ciò significa che puoi creare uno snapshot dell’istanza database quando sei pronto per la crittografia. È quindi possibile creare una copia di tale snapshot e specificare una chiave KMS per crittografare lo snapshot. Puoi quindi ripristinare un'istanza database crittografata dalla snapshot crittografata.
**Importante**
Quando utilizzi dichiarazioni di rifiuto esplicite per tutte le risorse (\$1) nelle politiche AWS KMS chiave con servizi gestiti come Amazon RDS, devi specificare una condizione per consentire l'account proprietario della risorsa. L’operazione di copia potrebbe non riuscire senza questa condizione, anche se la regola di rifiuto include eccezioni per l’utente IAM.
Per ulteriori informazioni sulla gestione delle AWS KMS chiavi per Amazon RDS, consulta[AWS KMS key gestione](Overview.Encryption.Keys.md).
#### Autorizzazioni necessarie per copiare istantanee crittografate
Per copiare uno snapshot DB crittografato, l'utente deve disporre delle seguenti autorizzazioni per utilizzare la crittografia Amazon RDS.
+ `kms:DescribeKey`
+ `kms:CreateGrant`
+ `kms:Decrypt`
+ `kms:Encrypt`
+ `kms:GenerateDataKey`
+ `kms:GenerateDataKeyWithoutPlaintext`
+ `kms:ReEncrypt`
Se utilizzi le condizioni delle policy IAM per limitare le operazioni di AWS KMS concessione, assicurati che la policy includa tutte le operazioni richieste da Amazon RDS. Se ricevi un `KMSKeyNotAccessibleFault` errore durante la copia di uno snapshot crittografato tra le regioni, verifica che la tua politica IAM includa tutte le operazioni di AWS KMS concessione richieste sopra menzionate.
### Considerazioni sulla copia di snapshot incrementali
Una snapshot *incrementale* contiene solo i dati modificati dopo la snapshot più recente della stessa istanza database. La copia di snapshot incrementali è più rapida e comporta costi di archiviazione inferiori rispetto alla copia di snapshot complete.
Una copia di snapshot incrementale è determinata dalla copia di snapshot completata più recente e dallo snapshot di origine. Se la copia snapshot più recente è stata eliminata, la copia successiva è una copia completa, non una copia incrementale. La copia di snapshot sarà dello stesso tipo dello snapshot di origine. Se lo snapshot di origine è incrementale, la copia sarà uno snapshot incrementale. L'incrementalità è determinata anche dal numero di modifiche apportate nell'istanza DB di origine dopo la snapshot più recente.
Quando si copia uno snapshot Account AWS, la copia è una copia incrementale solo se sono soddisfatte tutte le seguenti condizioni:
+ La copia di snapshot più recente è della stessa istanza database di origine ed esiste nell’account di destinazione.
+ Tutte le copie dello snapshot nell'account di destinazione o non sono crittografate o sono state crittografate utilizzando la stessa chiave KMS. Se sono crittografati, devono avere lo stesso lignaggio, vale a dire una profondità di ereditarietà corrispondente e chiavi di crittografia coerenti ai livelli corrispondenti.
+ Se l'istanza database di origine è un'istanza Multi-AZ, non ha eseguito il failover su un'altra istanza AZ da quando è stato acquisito l'ultimo snapshot.
Negli esempi seguenti viene illustrata la differenza tra snapshot completi e incrementali. Si applicano sia alle istantanee condivise che a quelle non condivise.
| Snapshot | Chiave di crittografia | Completo o incrementale |
| --- | --- | --- |
| S1 | K1 | Full |
| S2 | K1 | Incrementale di S1 |
| S3 | K1 | Incrementale di S2 |
| S4 | K1 | Incrementale di S3 |
| Copia di S1 (S1C) | K2 | Full |
| Copia di S2 (S2C) | K3 | Full |
| Copia di S3 (S3C) | K3 | Incrementale di S2C |
| Copia di S4 (S4C) | K3 | Incrementale di S3C |
| Copia 2 di S4 (S4C2) | K4 | Full |
**Nota**
In questi esempi, gli snapshot S2, S3 e S4 sono incrementali solo se lo snapshot precedente esiste ancora.
Lo stesso vale per le copie. Le copie degli snapshot S3C e S4C sono incrementali solo se la copia precedente esiste ancora.
Per informazioni sulla copia di istantanee incrementali, consulta. Regioni AWS[Copie complete e incrementali](#USER_CopySnapshot.AcrossRegions.Full)
### Considerazioni sulla copia di snapshot tra Regioni
È possibile copiare snapshot di database tra Regioni AWS. Per la copia di istantanee in più regioni si applicano i costi di trasferimento dei dati. La copia di istantanee tra regioni è soggetta a determinati vincoli e considerazioni.
#### Richiesta di una copia di snapshot DB tra regioni
Per comunicare con la regione di origine per richiedere una copia di snapshot DB tra regioni, il richiedente (ruolo IAM o utente IAM) deve avere accesso allo snapshot DB di origine e alla regione di origine.
Alcune condizioni nella policy IAM del richiedente possono causare l'esito negativo della richiesta. Negli esempi seguenti si assume che si stia copiando lo snapshot DB da Stati Uniti orientali (Ohio) a US East (N. Virginia) . Questi esempi mostrano le condizioni nella policy IAM del richiedente che causano l'esito negativo della richiesta:
+ La policy del richiedente ha una condizione per `aws:RequestedRegion`.
```
...
"Effect": "Allow",
"Action": "rds:CopyDBSnapshot",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestedRegion": "us-east-1"
}
}
```
La richiesta ha esito negativo perché la policy non consente l'accesso alla regione di origine. Perché una richiesta sia completata correttamente, specifica sia le regioni di origine che quelle di destinazione.
```
...
"Effect": "Allow",
"Action": "rds:CopyDBSnapshot",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestedRegion": [
"us-east-1",
"us-east-2"
]
}
}
```
+ La policy del richiedente non consente l'accesso allo snapshot DB di origine.
```
...
"Effect": "Allow",
"Action": "rds:CopyDBSnapshot",
"Resource": "arn:aws:rds:us-east-1:123456789012:snapshot:target-snapshot"
...
```
Perché una richiesta sia completata correttamente, specifica sia gli snapshot di origine che quelli di destinazione.
```
...
"Effect": "Allow",
"Action": "rds:CopyDBSnapshot",
"Resource": [
"arn:aws:rds:us-east-1:123456789012:snapshot:target-snapshot",
"arn:aws:rds:us-east-2:123456789012:snapshot:source-snapshot"
]
...
```
+ La policy del richiedente rifiuta `aws:ViaAWSService`.
```
...
"Effect": "Allow",
"Action": "rds:CopyDBSnapshot",
"Resource": "*",
"Condition": {
"Bool": {"aws:ViaAWSService": "false"}
}
```
La comunicazione con la regione di origine viene effettuata da RDS per conto del richiedente. Se la richiesta va a buon fine, non rifiutare le chiamate effettuate dai servizi. AWS
+ La policy del richiedente ha una condizione per `aws:SourceVpc` o `aws:SourceVpce`.
Queste richieste potrebbero non riuscire perché quando RDS effettua la chiamata alla regione remota, non proviene dall'endpoint VPC o dal VPC specificato.
Se è necessario utilizzare una delle condizioni precedenti che causerebbero un errore di una richiesta, è possibile includere una seconda istruzione con `aws:CalledVia` nella policy in modo che la richiesta abbia esito positivo. Ad esempio, è possibile utilizzare `aws:CalledVia` con `aws:SourceVpce` come riportato di seguito:
```
...
"Effect": "Allow",
"Action": "rds:CopyDBSnapshot",
"Resource": "*",
"Condition": {
"Condition" : {
"ForAnyValue:StringEquals" : {
"aws:SourceVpce": "vpce-1a2b3c4d"
}
}
},
{
"Effect": "Allow",
"Action": [
"rds:CopyDBSnapshot"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": [
"rds.amazonaws.com"
]
}
}
}
```
Per ulteriori informazioni, consulta [Policy e autorizzazioni in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) nella *Guida per l'utente di IAM*.
#### Autorizzazione della copia di snapshot
Dopo una richiesta di copia di snapshot DB tra regioni restituisce `success`, RDS avvia la copia in background. Viene creata un'autorizzazione per RDS per accedere allo snapshot di origine. Questa autorizzazione collega lo snapshot DB di origine allo snapshot DB di destinazione e consente a RDS di copiare solo lo snapshot di destinazione specificato.
L'autorizzazione è verificata da RDS utilizzando l’autorizzazione `rds:CrossRegionCommunication` nel ruolo IAM collegato al servizio. Se la copia è autorizzata, RDS comunica con la regione di origine e completa la copia.
RDS non ha accesso agli snapshot DB che non erano state autorizzati in precedenza da una richiesta `CopyDBSnapshot`. L'autorizzazione viene revocata al completamento della copia.
RDS utilizza il ruolo collegato al servizio per verificare l'autorizzazione nella regione di origine. Se si elimina il ruolo collegato al servizio durante il processo di copia, la copia avrà esito negativo.
Per ulteriori informazioni, consulta [Utilizzo di ruoli collegati ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html) nella *Guida per l'utente di IAM*.
#### Utilizzo delle credenziali AWS Security Token Service
I token di sessione dell'endpoint global AWS Security Token Service (AWS STS) sono validi solo se abilitati per impostazione predefinita (regioni commerciali). Regioni AWS Se utilizzi le credenziali dell'operazione `assumeRole` API in AWS STS, utilizza l'endpoint regionale se la regione di origine è una regione che richiede l'attivazione. In caso contrario, la richiesta ha esito negativo. Ciò accade perché le credenziali devono essere valide in entrambe le regioni, il che vale per le regioni che hanno aderito solo quando viene utilizzato l'endpoint regionale. AWS STS
Per utilizzare l'endpoint globale, assicurarsi che sia abilitato per entrambe le regioni nelle operazioni. Imposta l'endpoint globale su `Valid in all Regioni AWS` nelle impostazioni dell'account. AWS STS
La stessa regola si applica alle credenziali nel parametro URL prefirmato.
Per ulteriori informazioni, consulta [Managing AWS STS nella](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html) *Guida per l'utente di IAM*. Regione AWS
#### Latenza e richieste di copia multiple
A seconda del soggetto Regioni AWS coinvolto e della quantità di dati da copiare, il completamento di una copia istantanea tra diverse regioni può richiedere ore.
In alcuni casi, potrebbe esserci un numero elevato di richieste di copia di snapshot tra regioni da una determinata Regione AWS di origine. In questi casi, Amazon RDS potrebbe mettere in coda nuove richieste di copia interregionali provenienti da tale fonte fino al completamento di alcune copie Regione AWS in corso. Nessuna informazione di progresso viene visualizzata sulle richieste di copia mentre sono in coda. Le informazioni sul progresso vengono visualizzate quando inizia la copia.
#### Copie complete e incrementali
Quando si copia uno snapshot in uno snapshot diverso Regione AWS da quello di origine, la prima copia è una copia istantanea completa, anche se si copia uno snapshot incrementale. Una copia snapshot completa contiene tutti i dati e i metadati necessari per archiviare l'istanza database. Dopo la copia del primo snapshot, puoi copiare snapshot incrementali della stessa istanza database nella stessa Regione di destinazione all’interno dello stesso Account AWS. Per ulteriori informazioni sugli snapshot incrementali, vedere [Considerazioni sulla copia di snapshot incrementali](#USER_CopySnapshot.Incremental).
La copia incrementale delle istantanee Regioni AWS è supportata sia per le istantanee non crittografate che per quelle crittografate.
Quando si copia un'istantanea Regioni AWS, la copia è una copia incrementale se sono soddisfatte le seguenti condizioni:
+ Lo snapshot è stato precedentemente copiato nella regione di destinazione.
+ La copia snapshot più recente esiste ancora nella regione di destinazione.
+ Tutte le copie dello snapshot nella Regione di destinazione sono non crittografate o sono state crittografate utilizzando la stessa chiave KMS.
### Considerazioni sui gruppi di opzioni
I gruppi di opzioni del database sono specifici del Regione AWS tipo in cui vengono creati e non è possibile utilizzare un gruppo di opzioni proveniente da uno Regione AWS all'altro. Regione AWS
Per i database Oracle, puoi utilizzare l'API AWS CLI o RDS per copiare il gruppo di opzioni DB personalizzato da uno snapshot che è stato condiviso con il tuo. Account AWSÈ possibile copiare i gruppi di opzioni solo all'interno della stessa Regione AWS. Il gruppo di opzioni non viene copiato se è già stato copiato nell'account di destinazione e non è stata apportata alcuna modifica dopo la copia. Se il gruppo di opzioni di origine è stato copiato in precedenza, ma è stato modificato dopo la copia, RDS copia la nuova versione nell'account di destinazione. I gruppi di opzioni predefiniti non vengono copiati.
Quando copi uno snapshot tra regioni, puoi specificare un nuovo gruppo di opzione per lo snapshot. Consigliamo di preparare un nuovo gruppo di opzioni prima di copiare la snapshot. Nella destinazione Regione AWS, crea un gruppo di opzioni con le stesse impostazioni dell'istanza DB originale. Se ne esiste già uno nella nuova Regione AWS, puoi usare quello.
In alcuni casi, è possibile copiare uno snapshot e non specificare un nuovo gruppo di opzioni per lo snapshot. In questi casi, quando si ripristina lo snapshot l'istanza database ottiene il gruppo di opzioni predefinito. Per assegnare alla nuova istanza al nuovo cluster di database le stesse opzioni dell'originale, completa la seguente procedura:
1. Nella destinazione Regione AWS, create un gruppo di opzioni con le stesse impostazioni dell'istanza DB originale. Se ne esiste già uno nella nuova Regione AWS, puoi usare quello.
1. Dopo aver ripristinato l'istantanea nella destinazione Regione AWS, modifica la nuova istanza DB e aggiungi il gruppo di opzioni nuovo o esistente del passaggio precedente.
### Considerazioni sui gruppi di parametri
Quando copi uno snapshot tra regioni, la copia non include il gruppo di parametri usato dall'istanza database originale. Quando ripristini uno snapshot per creare una nuova istanza DB, a quell'istanza DB viene assegnato il gruppo di parametri predefinito in cui Regione AWS è stata creata. Per assegnare alla nuova istanza database gli stessi parametri dell'originale, completa la seguente procedura:
1. Nella destinazione Regione AWS, create un gruppo di parametri DB con le stesse impostazioni dell'istanza DB originale. Se ne esiste già uno nella nuova Regione AWS, puoi usare quello.
1. Dopo aver ripristinato l'istantanea nella destinazione Regione AWS, modifica la nuova istanza DB e aggiungi il gruppo di parametri nuovo o esistente del passaggio precedente.
# Condivisione di uno snapshot DB per Amazon RDS
Con Amazon RDS puoi condividere uno snapshot di database manuale nei modi seguenti:
+ La condivisione di uno snapshot DB manuale, crittografato o non crittografato, consente agli utenti autorizzati Account AWS di copiare lo snapshot.
+ La condivisione di un'istantanea database manuale non crittografata consente Account AWS agli utenti autorizzati di ripristinare direttamente un'istanza DB dalla snapshot anziché prenderne una copia e ripristinarla da quella. Tuttavia, non puoi ripristinare un'istanza database da una snapshot DB condivisa e crittografata. Invece puoi copiare la snapshot DB e ripristinare l'istanza database dalla copia.
**Nota**
Per condividere uno snapshot di database automatico, occorre creare uno snapshot di database manuale copiando lo snapshot automatico e poi condividere la copia. Questo processo si applica anche alle risorse AWS generate dal backup.
Per ulteriori informazioni sulla creazione di una copia di una snapshot, consulta [Copia di uno snapshot del database per Amazon RDS](USER_CopySnapshot.md). Per ulteriori informazioni sul ripristino di un'istanza database da uno snapshot di database, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
È possibile condividere un'istantanea manuale con un massimo di 20 altre persone. Account AWS
Le seguenti limitazioni si applicano quando condividi istantanee manuali con altri: Account AWS
+ Quando ripristini un'istanza DB da uno snapshot condiviso utilizzando AWS Command Line Interface (AWS CLI) o l'API Amazon RDS, devi specificare l'Amazon Resource Name (ARN) dello snapshot condiviso come identificatore dello snapshot.
+ Non è possibile condividere uno snapshot di database che utilizza un gruppo di opzioni con opzioni permanenti o persistenti, ad eccezione delle istanze Oracle DB, che hanno l'opzione `Timezone` o `OLS` (o entrambe).
Non è possibile rimuovere *un'opzione permanente* da un gruppo di opzioni. Non è possibile rimuovere i gruppi di opzioni con opzioni persistenti da un'istanza database una volta che il gruppo di opzioni è stato assegnato all'istanza database.
La tabella seguente elenca le opzioni permanenti e persistenti e i loro motori di database correlati.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/USER_ShareSnapshot.html)
Per le istanze database di Oracle, puoi copiare gli snapshot DB condivisi che hanno l'opzione `Timezone` o `OLS` (o entrambe). Per eseguire l’operazione, specifica un gruppo di opzioni target che include queste opzioni quando copi lo snapshot DB. L'opzione OLS è permanente e persistente solo per le istanze Oracle DB in esecuzione su Oracle 12.2 o versioni successive. Per ulteriori informazioni su queste opzioni, consulta [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md) e [Oracle Label Security](Oracle.Options.OLS.md).
+ Non è possibile condividere uno snapshot di un cluster di database Multi-AZ.
+ Non puoi condividere uno snapshot quando contiene un volume di storage aggiuntivo.
Consulta i seguenti argomenti per informazioni sulla condivisione di snapshot pubblici, sulla condivisione di snapshot crittografati e sull’arresto della condivisione di snapshot.
**Argomenti**
+ [Condivisione di snapshot pubblici per Amazon RDS](USER_ShareSnapshot.Public.md)
+ [Condivisione di snapshot crittografati per Amazon RDS](share-encrypted-snapshot.md)
+ [Arresto della condivisione di snapshot per Amazon RDS](share-snapshot-stop.md)
## Condivisione di uno snapshot
È possibile condividere uno snapshot del DB utilizzando l'API RDS Console di gestione AWS AWS CLI, the o l'API RDS.
### Console
Utilizzando la console Amazon RDS, puoi condividere uno snapshot DB manuale con un massimo di 20 persone. Account AWS Puoi anche utilizzare la console per interrompere la condivisione di una snapshot manuale con uno o più account.
**Come condividere uno snapshot manuale tramite la console Amazon RDS**
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 riquadro di navigazione, selezionare **Snapshots (Snapshot)**.
1. Selezionare lo snapshot manuale da condividere.
1. Per **Actions** (Operazioni), seleziona **Share snapshot** (Condividi snapshot).
1. Scegliere una delle opzioni seguenti per **DB snapshot visibility (Visibilità snapshot DB)**.
+ Se l'origine non è crittografata, scegli **Pubblica** per consentire a tutti gli AWS account di ripristinare un'istanza DB dallo snapshot DB manuale, oppure scegli **Privato** per consentire solo a Account AWS ciò che hai specificato di ripristinare un'istanza DB dallo snapshot DB manuale.
**avvertimento**
Se imposti la **visibilità dello snapshot DB** su **Pubblico**, tutti Account AWS possono ripristinare un'istanza DB dallo snapshot DB manuale e avere accesso ai tuoi dati. Non condividere le snapshot DB manuali che contengono informazioni private come **Public (Pubblica)**.
Per ulteriori informazioni, consulta [Condivisione di snapshot pubblici per Amazon RDS](USER_ShareSnapshot.Public.md).
+ Se l'origine è crittografata, l'opzione **DB snapshot visibility (Visibilità snapshot DB)** è impostata su **Private (Privato)**, perché gli snapshot crittografati non possono essere condivisi come pubblici.
**Nota**
Le istantanee che sono state crittografate con l'impostazione predefinita non AWS KMS key possono essere condivise. Per informazioni su come ovviare al problema, consulta [Condivisione di snapshot crittografati per Amazon RDS](share-encrypted-snapshot.md).
1. **Per **AWS Account ID**, inserisci l' Account AWS identificatore di un account a cui desideri consentire il ripristino di un'istanza DB dallo snapshot manuale, quindi scegli Aggiungi.** Ripeti l'operazione per includere Account AWS identificatori aggiuntivi, fino a 20. Account AWS
Se commetti un errore durante l'aggiunta di un Account AWS identificatore all'elenco degli account consentiti, puoi eliminarlo dall'elenco scegliendo **Elimina** a destra dell'identificatore errato Account AWS .
![\[Autorizzazione Account AWS al ripristino di un'istantanea manuale del DB\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/ShareSnapshot_add.png)
1. Dopo aver aggiunto gli identificatori per tutti quelli a Account AWS cui desideri consentire il ripristino dell'istantanea manuale, scegli **Salva per salvare** le modifiche.
### AWS CLI
Per condividere una snapshot DB, utilizza il comando `aws rds modify-db-snapshot-attribute`. Utilizzate il `--values-to-add` parametro per aggiungere un elenco dei IDs file autorizzati Account AWS a ripristinare l'istantanea manuale.
**Example di condividere uno snapshot con un singolo account**
L'esempio seguente abilita l' Account AWS identificatore `123456789012` per ripristinare l'istantanea del DB denominata. `db7-snapshot`
Per Linux, macOS o Unix:
```
aws rds modify-db-snapshot-attribute \
--db-snapshot-identifier db7-snapshot \
--attribute-name restore \
--values-to-add 123456789012
```
Per Windows:
```
aws rds modify-db-snapshot-attribute ^
--db-snapshot-identifier db7-snapshot ^
--attribute-name restore ^
--values-to-add 123456789012
```
**Example di condividere uno snapshot con più account**
L'esempio seguente abilita due Account AWS identificatori `111122223333` e`444455556666`, per ripristinare lo snapshot DB denominato. `manual-snapshot1`
Per Linux, macOS o Unix:
```
aws rds modify-db-snapshot-attribute \
--db-snapshot-identifier manual-snapshot1 \
--attribute-name restore \
--values-to-add {"111122223333","444455556666"}
```
Per Windows:
```
aws rds modify-db-snapshot-attribute ^
--db-snapshot-identifier manual-snapshot1 ^
--attribute-name restore ^
--values-to-add "[\"111122223333\",\"444455556666\"]"
```
Quando usi il prompt comandi di Windows, non devi inserire le doppie virgolette (") nel codice JSON precedendole con il backslash (\$1).
Per elencare gli utenti Account AWS abilitati al ripristino di un'istantanea, utilizzare il comando. [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-snapshot-attributes.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-snapshot-attributes.html) AWS CLI
### API RDS
Puoi anche condividere uno snapshot DB manuale con altri utenti Account AWS utilizzando l'API Amazon RDS. Per eseguire questa operazione, chiama l'operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBSnapshotAttribute.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBSnapshotAttribute.html). `AttributeName`Specificate `restore` e utilizzate il `ValuesToAdd` parametro per aggiungere un elenco degli IDs snapshot autorizzati a ripristinare lo snapshot manuale. Account AWS
Per rendere pubblica e ripristinabile da tutti un'istantanea manuale Account AWS, usa il valore. `all` Tuttavia, non aggiungere il valore `all` agli snapshot manuali contenenti informazioni private che non devono essere disponibili a tutti gli Account AWS. Inoltre, non è necessario specificare `all` per le snapshot crittografate, perché l'operazione di rendere pubbliche queste snapshot non è supportata.
Per elencare tutte le opzioni Account AWS consentite per il ripristino di un'istantanea, utilizza l'[https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBSnapshotAttributes.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBSnapshotAttributes.html)operazione API.
# Condivisione di snapshot pubblici per Amazon RDS
È possibile condividere uno snapshot manuale non crittografato come pubblico, rendendolo disponibile in tutti gli Account AWS. Asicurati, quando condividi uno snapshot come pubblico, che non siano incluse nessuna delle tue informazioni personali.
Quando uno snapshot è condiviso pubblicamente, fornisce a tutti gli Account AWS l’autorizzazione sia a copiare lo snapshot sia a creare istanze database da esso.
Non ti viene addebitata l'archiviazione di backup degli snapshot pubblici di proprietà di altri account. Ti verranno addebitate solo gli snapshot di tua proprietà.
Se si copia uno snapshot pubblico, si è proprietari della copia. Viene addebitato l'archiviazione di backup dello snapshot istantaneo. Se si crea un'istanza database da uno snapshot pubblico, ti viene addebitata tale istanza. Per informazioni sui prezzi di Amazon RDS, consulta la [pagina del prodotto Amazon RDS](https://aws.amazon.com/rds/pricing).
È possibile eliminare solo gli snapshot pubblici di tua proprietà. Per eliminare uno snapshot condiviso o pubblico, è necessario accedere all’Account AWS proprietario dello snapshot.
## Visualizzazione di snapshot pubblici di proprietà di altri Account AWS
È possibile visualizzare snapshot pubblici di proprietà di altri account in una particolare regione AWS sulla scheda **Pubblic (Pubblico)** della pagina **Snapshots (Snapshot)** nella console Amazon RDS. Gli snapshot (quelli di proprietà del tuo account) non vengono visualizzati in questa scheda.
**Per visualizzare gli snapshot pubblici**
1. Apri la console di Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegli **Snapshots (Snapshot)**.
1. Scegliere la scheda **Public (Pubblico)**.
Vengono visualizzati gli snapshot pubblici. È possibile vedere quale account possiede uno snapshot pubblico nella colonna **Owner (Proprietario)**.
**Nota**
Potrebbe essere necessario modificare le preferenze della pagina, selezionando l'icona a forma di ingranaggio in alto a destra dell’elenco **Public snapshots (Snapshot pubblici)**, per visualizzare questa colonna.
## Visualizzazione degli snapshot pubblici
È possibile utilizzare il seguente comando AWS CLI (solo Unix) per visualizzare gli snapshot pubblici di proprietà dell’Account AWS in una determinata Regione AWS.
```
aws rds describe-db-snapshots --snapshot-type public --include-public | grep account_number
```
Se si dispone di snapshot pubblici, l'output restituito è simile all'esempio seguente.
```
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mysnapshot1",
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mysnapshot2",
```
**Nota**
Potresti vedere voci duplicate per `DBSnapshotIdentifier` o `SourceDBSnapshotIdentifier`.
## Condivisione di snapshot pubblici da versioni obsolete del motore di database
Il ripristino o la copia di snapshot pubblici da versioni obsolete del motore di database non è supportato.
I motori di database RDS per Oracle e RDS per PostgreSQL supportano l’aggiornamento diretto delle versioni del motore di snapshot DB. È possibile aggiornare gli snapshot e condividerli nuovamente pubblicamente. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Aggiornamento di uno shapshot DB Oracle](USER_UpgradeDBSnapshot.Oracle.md)
+ [Aggiornamento di una versione del motore di snapshot database PostgreSQL](USER_UpgradeDBSnapshot.PostgreSQL.md)
Per altri motori di database, i seguenti passaggi consentono di rendere lo snapshot pubblico esistente non supportato disponibile per il ripristino o la copia:
1. Contrassegnare lo snapshot come privato.
1. Ripristinare lo snapshot:
1. Aggiornare l’istanza database ripristinata a una versione supportata del motore.
1. Creare un nuovo snapshot.
1. Condividere nuovamente lo snapshot pubblicamente.
# Condivisione di snapshot crittografati per Amazon RDS
Puoi condividere gli snapshot di database crittografati con stato inattivo usando l'algoritmo di crittografia AES-256, come descritto in [Crittografia delle risorse Amazon RDS](Overview.Encryption.md).
Per la condivisione di snapshot crittografati vigono le seguenti restrizioni:
+ Non puoi condividere le snapshot crittografate come pubbliche.
+ Non puoi condividere le snapshot Oracle o Microsoft SQL Server che sono crittografate utilizzando Transparent Data Encryption (TDE).
+ Non è possibile condividere uno snapshot crittografato con la chiave KMS predefinita dell’Account AWS che lo ha condiviso.
Per ulteriori informazioni sulla gestione delle chiavi AWS KMS di Amazon RDS, consulta [AWS KMS key gestione](Overview.Encryption.Keys.md).
Per risolvere il problema relativo alla chiave KMS predefinita, esegui le seguenti attività:
1. [Creare una chiave gestita dal cliente e concedere l’accesso a tale chiave](#share-encrypted-snapshot.cmk).
1. [Copiare e condividere lo snapshot dall’account di origine](#share-encrypted-snapshot.share).
1. [Copiare lo snapshot condiviso nell’account di destinazione](#share-encrypted-snapshot.target).
## Creare una chiave gestita dal cliente e concedere l’accesso a tale chiave
Per prima cosa, si crea una chiave KMS personalizzata nella stessa Regione AWS dello snapshot di database. Durante la creazione della chiave gestita dal cliente, si concede l’accesso a tale chiave per un altro Account AWS.
**Nota**
È anche possibile utilizzare una chiave KMS di un altro account AWS quando la policy della chiave consente l’accesso agli account di origine e di destinazione.
**Per creare una chiave gestita dal cliente e concedere l’accesso a tale chiave**
1. Accedi alla Console di gestione AWS dall’Account AWS di origine.
1. Aprire la console AWS KMS all'indirizzo [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms).
1. Per modificare la Regione AWS, utilizza il Selettore di regione nell'angolo in alto a destra della pagina.
1. Nel riquadro di navigazione, scegli **Chiavi gestite dal cliente**.
1. Scegliere **Create key (Crea chiave)**.
1. Nella pagina **Configura chiave**:
1. Per **Tipo di chiave**, seleziona **Simmetrica**.
1. In **Utilizzo della chiave**, scegli **Crittografa e decrittografa**.
1. Espandere **Advanced options (Opzioni avanzate)**.
1. In **Origine del materiale della chiave**, seleziona **KMS**.
1. In **Regionalità**, seleziona **Chiave a Regione singola**.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Aggiungi etichette**:
1. Per **Alias**, inserisci un nome visualizzato per la tua chiave KMS, ad esempio **share-snapshot**.
1. (Facoltativo) Inserisci una descrizione per la chiave KMS.
1. (Facoltativo) Aggiungi tag alla chiave KMS.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Definisci le autorizzazioni per gestire la chiave** scegli **Avanti**.
1. Nella pagina **Definisci le autorizzazioni per utilizzare la chiave**:
1. Per **Altri Account AWS**, scegli **Aggiungi un altro Account AWS**.
1. Inserisci l’ID dell’Account AWS a cui desideri concedere l’accesso.
Puoi concedere l’accesso a più Account AWS.
1. Scegli **Next (Successivo)**.
1. Controlla la chiave KMS, quindi scegli **Fine**.
## Copiare e condividere lo snapshot dall’account di origine
Successivamente si copia lo snapshot del database di origine in un nuovo snapshot utilizzando la chiave gestita dal cliente. Quindi si condivide lo snapshot con l’Account AWS di destinazione.
**Per copiare e condividere lo snapshot**
1. Accedi alla Console di gestione AWS dall’Account AWS di origine.
1. Apri la console Amazon RDS all’indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)
1. Nel riquadro di navigazione, selezionare **Snapshots (Snapshot)**.
1. Seleziona lo snapshot di database che desideri copiare.
1. In **Operazioni**, seleziona **Copia snapshot**.
1. Nella pagina **Copia snapshot**:
1. Per **Regione di destinazione**, scegli la Regione AWS in cui hai creato la chiave gestita dal cliente nella procedura precedente.
1. Digita il nome della copia dello snapshot di database in **Nuovo identificatore snapshot DB**.
1. Per **AWS KMS key**, scegli la chiave gestita dal cliente che hai creato.
![\[Scegli la chiave gestita dal cliente.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/copy-encrypted-snapshot.png)
1. Selezionare **Copy Snapshot (Copia snapshot)**.
1. Quando la copia dello snapshot è disponibile, selezionala.
1. Per **Actions** (Operazioni), seleziona **Share snapshot** (Condividi snapshot).
1. Nella pagina **Autorizzazioni snapshot**:
1. Inserisci l’**ID Account AWS** con cui vuoi condividere la copia dello snapshot, quindi scegli **Aggiungi**.
1. Scegli **Save** (Salva).
Lo snapshot è condiviso.
## Copiare lo snapshot condiviso nell’account di destinazione
A questo punto, è possibile copiare lo snapshot condiviso nell’Account AWS di destinazione.
**Per copiare lo snapshot condiviso**
1. Accedi alla Console di gestione AWS dall’Account AWS di destinazione.
1. Apri la console Amazon RDS all’indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)
1. Nel riquadro di navigazione, selezionare **Snapshots (Snapshot)**.
1. Scegli la scheda **Condivisi con me**.
1. Seleziona lo snapshot condiviso.
1. In **Operazioni**, seleziona **Copia snapshot**.
1. Scegli le impostazioni per copiare lo snapshot come nella procedura precedente, ma utilizza una AWS KMS key appartenente all’account di destinazione.
Selezionare **Copy Snapshot (Copia snapshot)**.
# Arresto della condivisione di snapshot per Amazon RDS
Per interrompere la condivisione di uno snapshot DB, rimuovi l'autorizzazione dalla destinazione Account AWS.
## Console
**Per interrompere la condivisione di uno snapshot DB manuale con un Account AWS**
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 riquadro di navigazione, selezionare **Snapshots (Snapshot)**.
1. Selezionare lo snapshot manuale di cui interrompere la condivisione.
1. Scegli **Actions** (Operazioni) e quindi **Share Snapshot** (Condividi snapshot).
1. Per rimuovere l'autorizzazione per un AWS account Account AWS, scegli **Elimina** come identificatore dell'account dall'elenco degli account autorizzati.
1. Scegli **Salva** per salvare le modifiche.
## CLI
Per rimuovere un Account AWS identificatore dall'elenco, utilizza il `--values-to-remove` parametro.
**Example di interruzione della condivisione degli snapshot**
L'esempio seguente impedisce all' Account AWS ID 444455556666 di ripristinare l'istantanea.
Per Linux, macOS o Unix:
```
aws rds modify-db-snapshot-attribute \
--db-snapshot-identifier manual-snapshot1 \
--attribute-name restore \
--values-to-remove 444455556666
```
Per Windows:
```
aws rds modify-db-snapshot-attribute ^
--db-snapshot-identifier manual-snapshot1 ^
--attribute-name restore ^
--values-to-remove 444455556666
```
## API RDS
Per rimuovere l'autorizzazione di condivisione per un Account AWS, utilizzate l'[https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterSnapshotAttribute.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterSnapshotAttribute.html)operazione con `AttributeName` set to `restore` e il parametro. `ValuesToRemove` Per contrassegnare uno snapshot manuale come privata, rimuovi il valore `all` dall'elenco dei valori per l'attributo `restore`.
# Supporto per l’esportazione di dati dello snapshot del database in Amazon S3 per Amazon RDS
È possibile esportare i dati dello snapshot DB in un bucket Simple Storage Service (Amazon S3). Il processo di esportazione viene eseguito in background e non ha ripercussioni sulle prestazioni del database attivo.
Quando si esporta uno snapshot di database, Amazon RDS estrae i dati dallo snapshot e li archivia in un bucket Amazon S3. I dati vengono archiviati in un formato Apache Parquet compresso e coerente.
È possibile esportare tutti i tipi di istantanee DB, incluse istantanee manuali, istantanee di sistema automatizzate e istantanee create dal servizio. AWS Backup Per impostazione predefinita, vengono esportati tutti i dati nello snapshot. Tuttavia, è possibile scegliere di esportare set specifici di database, schemi o tabelle.
Dopo l'esportazione dei dati, è possibile analizzare i dati esportati direttamente mediante strumenti quali Amazon Athena o Amazon Redshift Spectrum. Per ulteriori informazioni sull'utilizzo di Athena per leggere i dati di Parquet, consulta [Parquet SerDe](https://docs.aws.amazon.com/athena/latest/ug/parquet-serde.html) nella Guida per l'utente di *Amazon Athena*. Per ulteriori informazioni sull'utilizzo Redshift Spectrum per leggere i dati Parquet, consulta [COPY da formati di dati a colonna](https://docs.aws.amazon.com/redshift/latest/dg/copy-usage_notes-copy-from-columnar.html) nella *Guida per gli sviluppatori di database di Amazon Redshift*.
**avvertimento**
Non è possibile ripristinare i dati degli snapshot esportati da S3 in una nuova istanza database o importare i dati degli snapshot da S3 in un’istanza database esistente. Tuttavia, è possibile elaborare i dati utilizzando Amazon Athena o Redshift Spectrum per l’analisi. Inoltre, puoi utilizzarli AWS Glue per trasformare i dati e poi importarli in Amazon RDS utilizzando strumenti come AWS DMS script personalizzati.
Per ulteriori informazioni sull’esportazione degli snapshot del database in Amazon S3, consulta gli argomenti riportati di seguito.
**Argomenti**
+ [Monitoraggio delle esportazioni di snapshot per Amazon RDS](USER_ExportSnapshot.Monitoring.md)
+ [Annullamento di un’attività di esportazione di snapshot per Amazon RDS](USER_ExportSnapshot.Canceling.md)
+ [Messaggi di errore per le attività di esportazione di Amazon S3 per Amazon RDS](USER_ExportSnapshot.failure-msg.md)
+ [Risoluzione degli errori di autorizzazione RDS per PostgreSQL](USER_ExportSnapshot.postgres-permissions.md)
+ [Convenzioni di denominazione dei file per le esportazioni in Amazon S3 per Amazon RDS](USER_ExportSnapshot.FileNames.md)
+ [Conversione dei dati durante l’esportazione in un bucket Amazon S3 per Amazon RDS](USER_ExportSnapshot.data-types.md)
## Panoramica sull'esportazione dei dati degli snapshot
Per esportare i dati dello snapshot DB in un bucket Simple Storage Service (Amazon S3) puoi utilizzare il processo riportato di seguito. Per ulteriori dettagli, consulta le seguenti sezioni:
1. Identificare lo snapshot da esportare.
Utilizzare uno snapshot automatico o manuale esistente oppure creare uno snapshot manuale di un’istanza database o un cluster di database Multi-AZ.
1. Configurare l'accesso al bucket Simple Storage Service (Amazon S3).
Un *bucket* è un container per oggetti o file Simple Storage Service (Amazon S3). Per fornire le informazioni per accedere a un bucket, attenersi alla seguente procedura:
1. Identificare il bucket S3 in cui deve essere esportato lo snapshot. Il bucket S3 deve trovarsi nella stessa AWS regione dello snapshot. Per ulteriori informazioni, consulta [Identificazione del bucket Simple Storage Service (Amazon S3) in cui esportare](#USER_ExportSnapshot.SetupBucket).
1. Crea un ruolo AWS Identity and Access Management (IAM) che conceda all'attività di esportazione degli snapshot l'accesso al bucket S3. Per ulteriori informazioni, consulta [Fornire l'accesso a un bucket Simple Storage Service (Amazon S3) utilizzando un ruolo IAM](#USER_ExportSnapshot.SetupIAMRole).
1. Crea una crittografia simmetrica per la crittografia lato server. AWS KMS key La chiave KMS viene utilizzata dall'attività di esportazione delle istantanee per configurare la crittografia AWS KMS lato server durante la scrittura dei dati di esportazione su S3.
La policy della chiave KMS deve includere entrambe le autorizzazioni `kms:CreateGrant` e `kms:DescribeKey`. Per ulteriori informazioni sull'uso delle chiavi KMS in Amazon RDS, consulta [AWS KMS key gestione](Overview.Encryption.Keys.md).
Se hai una dichiarazione di rifiuto nella tua politica sulle chiavi KMS, assicurati di escludere esplicitamente il responsabile del servizio. AWS `export.rds.amazonaws.com`
Puoi utilizzare una chiave KMS all'interno del tuo AWS account oppure puoi utilizzare una chiave KMS per più account. Per ulteriori informazioni, consulta [Utilizzo di un account incrociato AWS KMS key per crittografare le esportazioni Amazon S3](#USER_ExportSnapshot.CMK).
1. Esportare lo snapshot in Simple Storage Service (Amazon S3) utilizzando la console o il comando CLI `start-export-task`. Per ulteriori informazioni, consulta [Esportazione di uno snapshot DB in un bucket Amazon S3](#USER_ExportSnapshot.Exporting).
1. Per accedere ai dati esportati nel bucket Simple Storage Service (Amazon S3), consulta [Caricamento, download e gestione di oggetti](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-download-objects.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
## Configurazione dell'accesso a un bucket Simple Storage Service (Amazon S3)
Per esportare i dati dello snapshot DB in un file Simple Storage Service (Amazon S3), è innanzitutto necessario concedere allo snapshot l'autorizzazione per accedere al bucket Simple Storage Service (Amazon S3). È quindi possibile creare un ruolo IAM per consentire al servizio Amazon RDS di scrivere nel bucket Amazon S3.
**Topics**
+ [Identificazione del bucket Simple Storage Service (Amazon S3) in cui esportare](#USER_ExportSnapshot.SetupBucket)
+ [Fornire l'accesso a un bucket Simple Storage Service (Amazon S3) utilizzando un ruolo IAM](#USER_ExportSnapshot.SetupIAMRole)
+ [Utilizzo di un bucket Simple Storage Service (Amazon S3) multiaccount](#USER_ExportSnapshot.Setup.XAcctBucket)
+ [Utilizzo di un account incrociato AWS KMS key per crittografare le esportazioni Amazon S3](#USER_ExportSnapshot.CMK)
### Identificazione del bucket Simple Storage Service (Amazon S3) in cui esportare
Identificare il bucket Simple Storage Service (Amazon S3) in cui esportare lo snapshot DB. Utilizzare un bucket S3 esistente o crearne uno nuovo.
**Nota**
Il bucket S3 in cui esportare deve trovarsi nella stessa AWS regione dell'istantanea.
Per ulteriori informazioni sull'utilizzo dei bucket Simple Storage Service (Amazon S3), vedere quanto segue in *Guida per l'utente di Amazon Simple Storage Service*:
+ [ Come visualizzare le proprietà di un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/view-bucket-properties.html)
+ [ In che modo si abilita la crittografia di default per un bucket Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/default-bucket-encryption.html)
+ [ Come creare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html)
### Fornire l'accesso a un bucket Simple Storage Service (Amazon S3) utilizzando un ruolo IAM
Prima di esportare i dati dello snapshot DB in Simple Storage Service (Amazon S3), fornire l'autorizzazione di accesso in scrittura alle attività di esportazione dello snapshot al bucket Simple Storage Service (Amazon S3).
Per concedere l'autorizzazione, crea una policy IAM che fornisca accesso al bucket, crea un ruolo IAM e collega la policy al ruolo. Successivamente assegnare il ruolo IAM all'attività di esportazione dello snapshot.
Per informazioni su altri strumenti di gestione degli accessi Amazon S3, consulta [Controllo degli accessi in Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-management.html) nella *Guida per l’utente di Amazon S3*.
**Importante**
Se prevedi di utilizzare il Console di gestione AWS per esportare la tua istantanea, puoi scegliere di creare automaticamente la policy IAM e il ruolo quando esporti la snapshot. Per istruzioni, consulta [Esportazione di uno snapshot DB in un bucket Amazon S3](#USER_ExportSnapshot.Exporting).
**Per fornire alle attività dello snapshot DB l'accesso a Amazon S3**
1. Creare una policy IAM Questa policy fornisce le autorizzazioni al bucket e all'oggetto che consentono all'attività di esportazione snapshot l'accesso a Amazon S3.
Includi nella policy le seguenti operazioni necessarie per consentire il trasferimento dei file da Amazon RDS a un bucket S3:
+ `s3:PutObject*`
+ `s3:GetObject*`
+ `s3:ListBucket`
+ `s3:DeleteObject*`
+ `s3:GetBucketLocation`
Includi nella policy le seguenti risorse per identificare il bucket S3 e gli oggetti nel bucket. Il seguente elenco di risorse mostra il formato Amazon Resource Name (ARN) per l'accesso a Amazon S3.
+ `arn:aws:s3:::amzn-s3-demo-bucket`
+ `arn:aws:s3:::amzn-s3-demo-bucket/*`
Per ulteriori informazioni sulla creazione di una policy IAM per Amazon RDS, consultare [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Consulta anche il [Tutorial: Creare e collegare la prima policy gestita dal cliente](https://docs.aws.amazon.com//IAM/latest/UserGuide/tutorial_managed-policies.html) nella *Guida per l'utente di IAM*.
Il AWS CLI comando seguente crea una policy IAM denominata `ExportPolicy` con queste opzioni. Concede l'accesso a un bucket denominato *amzn-s3-demo-bucket*.
**Nota**
Dopo aver creato la policy, prendere nota del relativo ARN. Per la fase successiva, in cui si associa la policy a un ruolo IAM, è necessario l'ARN.
```
aws iam create-policy --policy-name ExportPolicy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ExportPolicy",
"Effect": "Allow",
"Action": [
"s3:PutObject*",
"s3:ListBucket",
"s3:GetObject*",
"s3:DeleteObject*",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
1. Crea un ruolo IAM in modo che Amazon RDS possa assumere questo ruolo IAM per tuo conto per accedere ai bucket Amazon S3. Per ulteriori informazioni, consulta la pagina relativa alla [creazione di un ruolo per delegare le autorizzazioni a un utente IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) nella *Guida per l'utente IAM*.
L'esempio seguente mostra l'utilizzo del AWS CLI comando per creare un ruolo denominato`rds-s3-export-role`.
```
aws iam create-role --role-name rds-s3-export-role --assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "export.rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
1. Collegare la policy IAM al ruolo IAM creato.
Il AWS CLI comando seguente collega la politica creata in precedenza al ruolo denominato`rds-s3-export-role`. Sostituire `your-policy-arn` con l'ARN della policy annotato nella fase precedente.
```
aws iam attach-role-policy --policy-arn your-policy-arn --role-name rds-s3-export-role
```
### Utilizzo di un bucket Simple Storage Service (Amazon S3) multiaccount
Puoi utilizzare i bucket Amazon S3 su più account. AWS Per utilizzare un bucket tra account, aggiungi un criterio bucket per consentire l'accesso al ruolo IAM utilizzato per le esportazioni S3. Per informazioni, consulta [ Esempio 2: il proprietario del bucket concede autorizzazioni per il bucket multiaccount](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html).
Allega una policy di bucket al bucket, come mostrato nell'esempio riportato di seguito.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/Admin"
},
"Action": [
"s3:PutObject*",
"s3:ListBucket",
"s3:GetObject*",
"s3:DeleteObject*",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket",
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
}
]
}
```
------
### Utilizzo di un account incrociato AWS KMS key per crittografare le esportazioni Amazon S3
Puoi utilizzare un account multiplo AWS KMS key per crittografare le esportazioni Amazon S3. Innanzitutto, aggiungi una policy chiave all'account locale, quindi aggiungi le policy IAM nell'account esterno. Per ulteriori informazioni, consulta [Autorizzazione per gli utenti in altri account a utilizzare una chiave KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying-external-accounts.html).
**Per utilizzare una chiave KMS multiaccount**
1. Aggiungi una policy di chiave all'account locale.
Il seguente esempio fornisce `ExampleRole` e `ExampleUser` nell'account esterno 444455556666 autorizzazioni nell'account locale 123456789012.
```
{
"Sid": "Allow an external account to use this KMS key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::444455556666:role/ExampleRole",
"arn:aws:iam::444455556666:user/ExampleUser"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:CreateGrant",
"kms:DescribeKey",
"kms:RetireGrant"
],
"Resource": "*"
}
```
1. Aggiungere le policy IAM nell'account esterno
La policy IAM dell'esempio seguente consente al principale di utilizzare la chiave KMS nell'account 123456789012 per le operazioni di crittografia. Per concedere questa autorizzazione a `ExampleRole` e `ExampleUser` nell'account 444455556666, [collega la policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html#attach-managed-policy-console) ad essi nell'account.
```
{
"Sid": "Allow use of KMS key in account 123456789012",
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:CreateGrant",
"kms:DescribeKey",
"kms:RetireGrant"
],
"Resource": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
```
## Esportazione di uno snapshot DB in un bucket Amazon S3
Puoi avere in corso fino a cinque attività simultanee di esportazione di snapshot DB per volta. Account AWS
**Nota**
L'esportazione di snapshot RDS può richiedere qualche minuto a seconda del tipo e delle dimensioni del database. L'attività di esportazione ripristina e ridimensiona innanzitutto l'intero database prima di estrarre i dati su Simple Storage Service (Amazon S3). Lo stato di avanzamento dell'attività durante questa fase viene visualizzato come **Avvio**. Quando l'attività passa all'esportazione dei dati in S3, lo stato di avanzamento diventa **In progress (In corso)**.
Il tempo necessario per completare l'esportazione dipende dai dati memorizzati nel database. Ad esempio, le tabelle con chiave primaria numerica o colonne indice ben distribuite esporteranno più velocemente. Le tabelle che non contengono una colonna adatta al partizionamento e le tabelle con un solo indice su una colonna basata su stringhe richiedono più tempo. Questo tempo di esportazione più lungo si verifica perché l'esportazione utilizza un processo a thread singolo più lento.
Puoi esportare uno snapshot DB su Amazon S3 utilizzando Console di gestione AWS l'API, AWS CLI the o RDS. Per esportare uno snapshot DB in un bucket Amazon S3 con più account, usa o AWS CLI l'API RDS.
Se si utilizza una funzione Lambda per esportare uno snapshot, aggiungere l'operazione `kms:DescribeKey` alla policy della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html).
### Console
L'opzione **Export to Amazon S3 (Esporta in Simple Storage Service (Amazon S3))** viene visualizzata solo per gli snapshot che possono essere esportati in Simple Storage Service (Amazon S3). Uno snapshot potrebbe non essere disponibile per l'esportazione a causa dei seguenti motivi:
+ Il motore del database non è supportato per l'esportazione S3.
+ La versione del motore di database non è supportata per l’esportazione S3.
+ L'esportazione da S3 non è supportata nella AWS regione in cui è stata creata la snapshot.
**Per esportare 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. Dalle schede, scegliere il tipo di snapshot che si desidera esportare.
1. Nell'elenco degli snapshot, scegliere lo snapshot che si desidera esportare.
1. Per **Actions (Operazioni)**, scegli **Export to Amazon S3 (Esporta in Simple Storage Service (Amazon S3)**.
Viene visualizzata la finestra **Export to Amazon S3 (Esporta in Simple Storage Service (Amazon S3))**.
1. Per **Export identifier (Identificatore di esportazione)**, immettere un nome per identificare l'attività di esportazione. Questo valore viene utilizzato anche per il nome del file creato nel bucket S3.
1. Scegli i dati da esportare:
+ Scegliere **All (Tutti)** per esportare tutti i dati nello snapshot.
+ Scegliere **Partial (Parziali)** per esportare parti specifiche dello snapshot. Per identificare le parti dello snapshot da esportare, immettere uno o più database, schemi o tabelle per **Identifiers (Identificatori)**, separati da spazi.
Utilizza il seguente formato:
```
database[.schema][.table] database2[.schema2][.table2] ... databasen[.scheman][.tablen]
```
Ad esempio:
```
mydatabase mydatabase2.myschema1 mydatabase2.myschema2.mytable1 mydatabase2.myschema2.mytable2
```
1. Per **S3 bucket (Bucket S3)**, scegliere il bucket in cui esportare.
Per assegnare i dati esportati a un percorso di cartella nel bucket S3, immettere il percorso opzionale per **S3 prefix (Prefisso S3)**.
1. Per il **ruolo IAM**, scegliere un ruolo che conceda l'accesso in scrittura al bucket S3 scelto o creare un nuovo ruolo.
+ Se è stato creato un ruolo seguendo le fasi in [Fornire l'accesso a un bucket Simple Storage Service (Amazon S3) utilizzando un ruolo IAM](#USER_ExportSnapshot.SetupIAMRole), scegliere tale ruolo.
+ Se non è stato creato un ruolo che fornisce l'accesso in scrittura al bucket S3 scelto, scegli **Create a new role** (Crea un nuovo ruolo) per creare automaticamente il ruolo. Immettere quindi un nome per il ruolo nel **nome del ruolo IAM**.
1. Per **AWS KMS key**, immettere l'ARN per la chiave da utilizzare per crittografare i dati esportati.
1. Scegliere **Export to Amazon S3 (Esporta in Simple Storage Service (Amazon S3))**.
### AWS CLI
Per esportare uno snapshot DB in Amazon S3 utilizzando, usa AWS CLI il comando con [start-export-task](https://docs.aws.amazon.com/cli/latest/reference/rds/start-export-task.html)le seguenti opzioni richieste:
+ `--export-task-identifier`
+ `--source-arn`
+ `--s3-bucket-name`
+ `--iam-role-arn`
+ `--kms-key-id`
Negli esempi seguenti, viene denominata l'attività di esportazione delle istantanee*my-snapshot-export*, che esporta un'istantanea in un bucket S3 denominato. *amzn-s3-demo-bucket*
**Example**
Per Linux, macOS o Unix:
```
1. aws rds start-export-task \
2. --export-task-identifier my-snapshot-export \
3. --source-arn arn:aws:rds:AWS_Region:123456789012:snapshot:snapshot-name \
4. --s3-bucket-name amzn-s3-demo-bucket \
5. --iam-role-arn iam-role \
6. --kms-key-id my-key
```
Per Windows:
```
1. aws rds start-export-task ^
2. --export-task-identifier my-snapshot-export ^
3. --source-arn arn:aws:rds:AWS_Region:123456789012:snapshot:snapshot-name ^
4. --s3-bucket-name amzn-s3-demo-bucket ^
5. --iam-role-arn iam-role ^
6. --kms-key-id my-key
```
Di seguito è riportato un output di esempio.
```
{
"Status": "STARTING",
"IamRoleArn": "iam-role",
"ExportTime": "2019-08-12T01:23:53.109Z",
"S3Bucket": "my-export-bucket",
"PercentProgress": 0,
"KmsKeyId": "my-key",
"ExportTaskIdentifier": "my-snapshot-export",
"TotalExtractedDataInGB": 0,
"TaskStartTime": "2019-11-13T19:46:00.173Z",
"SourceArn": "arn:aws:rds:AWS_Region:123456789012:snapshot:snapshot-name"
}
```
Per fornire un percorso di cartella nel bucket S3 per l'esportazione delle istantanee, includi l'opzione nel comando. `--s3-prefix` [start-export-task](https://docs.aws.amazon.com/cli/latest/reference/rds/start-export-task.html)
### API RDS
Per esportare uno snapshot DB su Amazon S3 utilizzando l'API Amazon RDS, utilizza l'operazione con i [StartExportTask](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StartExportTask.html)seguenti parametri obbligatori:
+ `ExportTaskIdentifier`
+ `SourceArn`
+ `S3BucketName`
+ `IamRoleArn`
+ `KmsKeyId`
## Disponibilità di regioni e versioni
Il supporto varia a seconda delle versioni specifiche di ciascun motore di database e a seconda delle Regioni AWS. Per ulteriori informazioni sulla disponibilità di versioni e regioni in caso di esportazione di snapshot in S3, consulta [Regioni e motori di database Aurora supportati per l’esportazione di snapshot in S3 in Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ExportSnapshotToS3.md).
## Limitazioni
L'esportazione dei dati snapshot DB in Simple Storage Service (Amazon S3) presenta le seguenti limitazioni:
+ Non è possibile eseguire contemporaneamente più attività di esportazione per lo stesso snapshot database. Ciò è valido sia per le esportazioni totali sia per le esportazioni parziali.
+ L’esportazione di snapshot da database che utilizzano l’archiviazione magnetica non è supportata.
+ Le esportazioni in S3 non supportano i prefissi S3 contenenti i due punti (:).
+ I seguenti caratteri nel percorso del file S3 vengono convertiti in caratteri di sottolineatura (\$1) durante l'esportazione:
```
\ ` " (space)
```
+ Se un database, uno schema o una tabella contiene caratteri diversi da quelli riportati di seguito, l'esportazione parziale non è supportata. Tuttavia, è possibile esportare l'intero snapshot DB.
+ Lettere latine (A–Z)
+ Numeri (0–9)
+ Simbolo del dollaro (\$1)
+ Carattere di sottolineatura (\$1)
+ Gli spazi ( ) e alcuni caratteri non sono supportati nei nomi delle colonne delle tabelle del database. Le tabelle con i seguenti caratteri nei nomi delle colonne vengono ignorate durante l'esportazione:
```
, ; { } ( ) \n \t = (space)
```
+ Le tabelle con barre (/) nei rispettivi nomi vengono ignorate durante l'esportazione.
+ Le tabelle temporanee e non registrate di RDS per PostgreSQL vengono ignorate durante l'esportazione.
+ Se i dati contengono un oggetto di grandi dimensioni, ad esempio un BLOB o un CLOB, vicino o superiore a 500 MB, l'esportazione non riesce.
+ Se una tabella contiene una riga di grandi dimensioni, vicine o superiori a 2 GB, la tabella viene ignorata durante l'esportazione.
+ Per le esportazioni parziali, l’elenco `ExportOnly` ha una dimensione massima di 200 KB.
+ Si consiglia vivamente di utilizzare un nome univoco per ogni attività di esportazione. Se non utilizzi un nome di attività univoco, potresti ricevere il seguente messaggio di errore:
ExportTaskAlreadyExistsFault: Si è verificato un errore (ExportTaskAlreadyExists) durante la chiamata dell' StartExportTaskoperazione: l'attività di esportazione con l'ID *xxxxx* esiste già.
+ È possibile eliminare uno snapshot durante l'esportazione dei suoi dati in S3, ma vengono comunque addebitati i costi di storage per tale snapshot fino al completamento dell'attività di esportazione.
+ Non è possibile ripristinare i dati degli snapshot esportati da S3 in una nuova istanza database o importare i dati degli snapshot da S3 in un’istanza database esistente.
+ È possibile avere in corso fino a cinque attività simultanee di esportazione di snapshot DB per. Account AWS
+ Per esportare uno snapshot DB in un bucket Amazon S3 con più account, devi utilizzare o AWS CLI l'API RDS.
+ Dopo che Amazon RDS ha completato un’attività di esportazione, potrebbe essere necessario attendere qualche istante prima di iniziare un’altra attività di esportazione dallo stesso snapshot del database.
+ Non è possibile esportare viste o viste materializzate.
+ RDS Export to S3 non supporta il controllo degli accessi basato su tag per. GuardDuty Malware Protection for S3
# Monitoraggio delle esportazioni di snapshot per Amazon RDS
È possibile monitorare le esportazioni di snapshot DB utilizzando la Console di gestione AWS, l'AWS CLI o l'API RDS.
## Console
**Per monitorare le esportazioni di snapshot DB**
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 pannello di navigazione, selezionare **Snapshots (Snapshot)**.
1. Per monitorare l'elenco delle esportazioni di snapshot, scegliere la scheda **Esportazioni in Simple Storage Service (Amazon S3)**.
1. Per visualizzare informazioni su un'esportazione di snapshot specifica, scegliere l'attività di esportazione.
## AWS CLI
Per monitorare le esportazioni di snapshot DB utilizzando l'AWS CLI, utilizzare il comando [describe-export-tasks](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-export-tasks.html).
Nell'esempio seguente viene illustrato come visualizzare le informazioni correnti su tutte le esportazioni di snapshot.
**Example**
```
1. aws rds describe-export-tasks
2.
3. {
4. "ExportTasks": [
5. {
6. "Status": "CANCELED",
7. "TaskEndTime": "2019-11-01T17:36:46.961Z",
8. "S3Prefix": "something",
9. "ExportTime": "2019-10-24T20:23:48.364Z",
10. "S3Bucket": "amzn-s3-demo-bucket",
11. "PercentProgress": 0,
12. "KmsKeyId": "arn:aws:kms:AWS_Region:123456789012:key/K7MDENG/bPxRfiCYEXAMPLEKEY",
13. "ExportTaskIdentifier": "anewtest",
14. "IamRoleArn": "arn:aws:iam::123456789012:role/export-to-s3",
15. "TotalExtractedDataInGB": 0,
16. "TaskStartTime": "2019-10-25T19:10:58.885Z",
17. "SourceArn": "arn:aws:rds:AWS_Region:123456789012:snapshot:parameter-groups-test"
18. },
19. {
20. "Status": "COMPLETE",
21. "TaskEndTime": "2019-10-31T21:37:28.312Z",
22. "WarningMessage": "{\"skippedTables\":[],\"skippedObjectives\":[],\"general\":[{\"reason\":\"FAILED_TO_EXTRACT_TABLES_LIST_FOR_DATABASE\"}]}",
23. "S3Prefix": "",
24. "ExportTime": "2019-10-31T06:44:53.452Z",
25. "S3Bucket": "amzn-s3-demo-bucket1",
26. "PercentProgress": 100,
27. "KmsKeyId": "arn:aws:kms:AWS_Region:123456789012:key/2Zp9Utk/h3yCo8nvbEXAMPLEKEY",
28. "ExportTaskIdentifier": "thursday-events-test",
29. "IamRoleArn": "arn:aws:iam::123456789012:role/export-to-s3",
30. "TotalExtractedDataInGB": 263,
31. "TaskStartTime": "2019-10-31T20:58:06.998Z",
32. "SourceArn": "arn:aws:rds:AWS_Region:123456789012:snapshot:rds:example-1-2019-10-31-06-44"
33. },
34. {
35. "Status": "FAILED",
36. "TaskEndTime": "2019-10-31T02:12:36.409Z",
37. "FailureCause": "The S3 bucket edgcuc-export isn't located in the current AWS Region. Please, review your S3 bucket name and retry the export.",
38. "S3Prefix": "",
39. "ExportTime": "2019-10-30T06:45:04.526Z",
40. "S3Bucket": "amzn-s3-demo-bucket2",
41. "PercentProgress": 0,
42. "KmsKeyId": "arn:aws:kms:AWS_Region:123456789012:key/2Zp9Utk/h3yCo8nvbEXAMPLEKEY",
43. "ExportTaskIdentifier": "wednesday-afternoon-test",
44. "IamRoleArn": "arn:aws:iam::123456789012:role/export-to-s3",
45. "TotalExtractedDataInGB": 0,
46. "TaskStartTime": "2019-10-30T22:43:40.034Z",
47. "SourceArn": "arn:aws:rds:AWS_Region:123456789012:snapshot:rds:example-1-2019-10-30-06-45"
48. }
49. ]
50. }
```
Per visualizzare informazioni su un'esportazione di snapshot specifica, includere l'opzione `--export-task-identifier` nel comando `describe-export-tasks`. Per filtrare l'output, includere l'opzione `--Filters`. Per ulteriori opzioni, consultare il comando [describe-export-tasks](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-export-tasks.html).
## API RDS
Per visualizzare informazioni sulle esportazioni di snapshot DB utilizzando l'API Amazon RDS, utilizzare l'operazione [DescribeExportTasks](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeExportTasks.html).
Per tenere traccia del completamento del flusso di lavoro di esportazione o per attivare un altro flusso di lavoro, è possibile sottoscrivere gli argomenti del Servizio di notifica semplice Amazon. Per ulteriori informazioni su Amazon SNS, consulta [Utilizzo della notifica degli eventi di Amazon RDS](USER_Events.md).
# Annullamento di un’attività di esportazione di snapshot per Amazon RDS
È possibile annullare un'attività di esportazione di snapshot DB utilizzando la Console di gestione AWS, l'AWS CLI o l'API RDS.
**Nota**
L'annullamento di un'attività di esportazione di snapshot non rimuove i dati esportati in Simple Storage Service (Amazon S3). Per informazioni su come eliminare i dati utilizzando la console, consultare [Come eliminare oggetti da un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/delete-objects.html) Per eliminare i dati utilizzando l'interfaccia della riga di comando (CLI), utilizzare il comando [delete-object](https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-object.html).
## Console
**Per annullare un'attività di esportazione di uno snapshot**
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 pannello di navigazione, selezionare **Snapshots (Snapshot)**.
1. Scegli la scheda **Exports in Simple Storage Service (Amazon S3) (Esportazioni in Simple Storage Service (Amazon S3))**.
1. Scegliere l'attività di esportazione di snapshot che si desidera annullare.
1. Seleziona **Cancel (Annulla)**.
1. Scegli **Cancel export task (Annulla attività di esportazione)** nella pagina di conferma.
## AWS CLI
Per annullare un'attività di esportazione di snapshot utilizzando l'AWS CLI, utilizzare il comando [cancel-export-task](https://docs.aws.amazon.com/cli/latest/reference/rds/cancel-export-task.html). Il comando richiede l'opzione `--export-task-identifier`.
**Example**
```
1. aws rds cancel-export-task --export-task-identifier my_export
2. {
3. "Status": "CANCELING",
4. "S3Prefix": "",
5. "ExportTime": "2019-08-12T01:23:53.109Z",
6. "S3Bucket": "amzn-s3-demo-bucket",
7. "PercentProgress": 0,
8. "KmsKeyId": "arn:aws:kms:AWS_Region:123456789012:key/K7MDENG/bPxRfiCYEXAMPLEKEY",
9. "ExportTaskIdentifier": "my_export",
10. "IamRoleArn": "arn:aws:iam::123456789012:role/export-to-s3",
11. "TotalExtractedDataInGB": 0,
12. "TaskStartTime": "2019-11-13T19:46:00.173Z",
13. "SourceArn": "arn:aws:rds:AWS_Region:123456789012:snapshot:export-example-1"
14. }
```
## API RDS
Per annullare un'attività di esportazione di snapshot utilizzando l'API Amazon RDS, utilizzare l'operazione [CancelExportTask](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CancelExportTask.html) con il parametro `ExportTaskIdentifier`.
# Messaggi di errore per le attività di esportazione di Amazon S3 per Amazon RDS
Nella tabella seguente vengono descritti i messaggi restituiti quando le attività di esportazione di Amazon S3 non riescono.
| Messaggio di errore | Descrizione |
| --- | --- |
| Si è verificato un errore interno sconosciuto. | L'elaborazione della richiesta non è riuscita a causa di un errore, un'eccezione o un guasto interno sconosciuto. |
| Si è verificato un errore interno sconosciuto durante la scrittura dei metadati dell'attività di esportazione nel bucket S3 [nome bucket]. | L'elaborazione della richiesta non è riuscita a causa di un errore, un'eccezione o un guasto interno sconosciuto. |
| L'esportazione RDS non è riuscita a scrivere i metadati dell'attività di esportazione perché non può assumere il ruolo IAM [ruolo ARN]. | L'attività di esportazione assume il ruolo IAM per verificare se è consentito scrivere metadati nel bucket S3. Se l'attività non può assumere il ruolo IAM, non riesce. |
| L'esportazione RDS non è riuscita a scrivere i metadati dell'attività di esportazione nel bucket S3 [nome bucket] utilizzando il ruolo IAM [ruolo ARN] con la chiave KMS [ID chiave]. Codice di errore: [codice di errore] | Mancano una o più autorizzazioni, quindi l'attività di esportazione non può accedere al bucket S3. Questo messaggio di errore viene generato quando si riceve uno dei seguenti codici di errore: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/USER_ExportSnapshot.failure-msg.html) Questi codici di errore indicano che le impostazioni non sono configurate correttamente per il ruolo IAM, il bucket S3 o la chiave KMS. |
| Il ruolo IAM [ruolo ARN] non è autorizzato a chiamare [azione S3] sul bucket S3 [nome bucket]. Controlla le tue autorizzazioni e riprova l'esportazione. | La policy IAM è configurata in modo errato. L'autorizzazione per l'azione S3 specifica sul bucket S3 è mancante e questa condizione causa l'esito negativo dell'attività di esportazione. |
| Controllo chiave KMS non riuscito. Controlla le credenziali sulla tua chiave KMS e riprova. | Controllo delle credenziali della chiave KMS non riuscito. |
| Controllo delle credenziali S3 non riuscito. Controlla le autorizzazioni per il bucket S3 e la policy IAM. | Il controllo delle credenziali S3 non è riuscito. |
| Il bucket S3 [nome bucket] non è valido. O non si trova nella corrente Regione AWS o non esiste. Esamina il nome del bucket S3 e riprova l'esportazione. | Bucket S3 non è valido. |
| Il bucket S3 [nome bucket] non si trova nella corrente Regione AWS. Esamina il nome del bucket S3 e riprova l'esportazione. | Bucket S3 non è nella Regione AWS. |
# Risoluzione degli errori di autorizzazione RDS per PostgreSQL
Quando si esportano i database PostgreSQL in Simple Storage Service (Amazon S3), è possibile che venga visualizzato un errore `PERMISSIONS_DO_NOT_EXIST` che indica che alcune tabelle sono state ignorate. Questo errore si verifica in genere quando l’utente con privilegi avanzati specificato durante la creazione del database, non dispone delle autorizzazioni per accedere alle tabelle.
Per risolvere questo errore, eseguire il comando seguente:
```
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA schema_name TO superuser_name
```
Per ulteriori informazioni sui privilegi utente con privilegi avanzati, vedere [Privilegi dell'account utente master](UsingWithRDS.MasterAccounts.md).
# Convenzioni di denominazione dei file per le esportazioni in Amazon S3 per Amazon RDS
I dati esportati per tabelle specifiche vengono memorizzati nel formato `base_prefix/files`, dove il prefisso di base è il seguente:
```
export_identifier/database_name/schema_name.table_name/
```
Ad esempio:
```
export-1234567890123-459/rdststdb/rdststdb.DataInsert_7ADB5D19965123A2/
```
Esistono due convenzioni di denominazione per i file.
+ Convenzione attuale:
```
batch_index/part-partition_index-random_uuid.format-based_extension
```
L’indice batch è un numero sequenziale che rappresenta un batch di dati letti dalla tabella. Se la tabella non può essere partizionata in piccoli blocchi da esportare in parallelo, saranno presenti più indici batch. La stessa cosa accade se la tabella è partizionata in più tabelle. Saranno presenti più indici batch, uno per ciascuna delle partizioni di tabella della tabella principale.
Se la tabella può essere partizionata in piccoli blocchi da leggere in parallelo, sarà presente solo la cartella di indice batch `1`.
All’interno della cartella dell’indice batch sono presenti più file Parquet che contengono i dati della tabella. Il prefisso del nome file Parquet è `part-partition_index`. Se la tabella è partizionata, saranno presenti più file che iniziano con l’indice di partizione `00000`.
La sequenza dell’indice di partizione può presentare delle lacune. Ciò accade perché ogni partizione è ottenuta da una query a intervalli nella tabella. Se l’intervallo di quella partizione non contiene dati, quel numero di sequenza viene ignorato.
Ad esempio, supponiamo che la colonna `id` sia la chiave primaria della tabella e che i suoi valori minimo e massimo siano `100` e `1000`. Quando proviamo a esportare questa tabella con nove partizioni, la leggiamo con query parallele come le seguenti:
```
SELECT * FROM table WHERE id <= 100 AND id < 200
SELECT * FROM table WHERE id <= 200 AND id < 300
```
Questo dovrebbe generare nove file, da `part-00000-random_uuid.gz.parquet` a `part-00008-random_uuid.gz.parquet`. Tuttavia, se non ci sono righe con ID compresi tra `200` e `350`, una delle partizioni completate è vuota e non viene creato alcun file per essa. Nell’esempio precedente, `part-00001-random_uuid.gz.parquet` non viene creato.
+ Convenzione precedente:
```
part-partition_index-random_uuid.format-based_extension
```
È uguale alla convenzione attuale, ma senza il prefisso `batch_index`, ad esempio:
```
part-00000-c5a881bb-58ff-4ee6-1111-b41ecff340a3-c000.gz.parquet
part-00001-d7a881cc-88cc-5ab7-2222-c41ecab340a4-c000.gz.parquet
part-00002-f5a991ab-59aa-7fa6-3333-d41eccd340a7-c000.gz.parquet
```
La convenzione di denominazione file è soggetta a modifiche. Pertanto, quando usi le tabelle di destinazione ti consigliamo di leggere tutto quanto riportato all'interno del prefisso di base della tabella.
# Conversione dei dati durante l’esportazione in un bucket Amazon S3 per Amazon RDS
Quando si esporta uno snapshot di database in un bucket Amazon S3, Amazon RDS converte, esporta e memorizza i dati nel formato Parquet. Per ulteriori informazioni su Parquet, consultare il sito Web [Apache Parquet](https://parquet.apache.org/docs/).
Parquet archivia tutti i dati in uno dei seguenti tipi primitivi:
+ BOOLEAN
+ INT32
+ INT64
+ INT96
+ FLOAT
+ DOUBLE
+ BYTE\$1ARRAY: un array di byte a lunghezza variabile, noto anche come binario
+ FIXED\$1LEN\$1BYTE\$1ARRAY: un array di byte a lunghezza fissa utilizzato quando i valori hanno una dimensione costante
I tipi di dati Parquet sono pochi per ridurre la complessità di lettura e scrittura del formato. Parquet fornisce tipi logici per estendere i tipi primitivi. Un *tipo logico* viene implementato come annotazione con i dati in un campo di metadati `LogicalType`. L'annotazione di tipo logico spiega come interpretare il tipo primitivo.
Quando il tipo logico `STRING` annota un tipo `BYTE_ARRAY`, indica che l'array di byte deve essere interpretato come una stringa di caratteri con codifica UTF-8. Al termine di un'attività di esportazione, Amazon RDS notifica all'utente se si è verificata una conversione di stringa. I dati sottostanti esportati sono sempre uguali ai dati provenienti dall'origine. Tuttavia, a causa della differenza di codifica in UTF-8, alcuni caratteri potrebbero apparire diversi dall'origine quando vengono letti in strumenti come Athena.
Per ulteriori informazioni, consultare la sezione relativa alle [definizioni dei tipi logici di Parquet](https://github.com/apache/parquet-format/blob/master/LogicalTypes.md) nella documentazione di Parquet.
**Topics**
+ [Mappatura dei tipi di dati MySQL e MariaDB su Parquet](#USER_ExportSnapshot.data-types.MySQL)
+ [Mappatura dei tipi di dati PostgreSQL su Parquet](#USER_ExportSnapshot.data-types.PostgreSQL)
## Mappatura dei tipi di dati MySQL e MariaDB su Parquet
La tabella seguente mostra la mappature dai tipi di dati MySQL e MariaDB nei tipi di dati Parquet quando i dati vengono convertiti ed esportati in Simple Storage Service (Amazon S3).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/USER_ExportSnapshot.data-types.html)
## Mappatura dei tipi di dati PostgreSQL su Parquet
Nella tabella seguente viene illustrata la mappatura dai tipi di dati PostgreSQL ai tipi di dati Parquet quando i dati vengono convertiti ed esportati in Simple Storage Service (Amazon S3).
| Tipo di dati PostgreSQL | Tipo Parquet primitivo | Annotazione del tipo logico | Note relative alla mappatura |
| --- | --- | --- | --- |
| Tipi di dati numerici |
| BIGINT | INT64 | | |
| BIGSERIAL | INT64 | | |
| DECIMAL | BYTE\$1ARRAY | STRING | Un tipo DECIMAL viene convertito in una stringa di tipo BYTE\$1ARRAY e codificato come. UTF8Questa conversione serve a evitare complicazioni dovute alla precisione dei dati e ai valori di dati che non sono un numero (NaN). |
| DOUBLE PRECISION | DOUBLE | | |
| INTEGER | INT32 | | |
| MONEY | BYTE\$1ARRAY | STRING | |
| REAL | FLOAT | | |
| SERIAL | INT32 | | |
| SMALLINT | INT32 | INT(16, true) | |
| SMALLSERIAL | INT32 | INT(16, true) | |
| Tipi di dati stringa e correlati |
| ARRAY | BYTE\$1ARRAY | STRING | Un array viene convertito in una stringa e codificato come BINARY (). UTF8 Questa conversione serve a evitare complicazioni dovute alla precisione dei dati, ai valori di dati che non sono un numero (NaN) e ai valori di dati temporali. |
| BIT | BYTE\$1ARRAY | STRING | |
| BIT VARYING | BYTE\$1ARRAY | STRING | |
| BYTEA | BINARY | | |
| CHAR | BYTE\$1ARRAY | STRING | |
| CHAR(N) | BYTE\$1ARRAY | STRING | |
| ENUM | BYTE\$1ARRAY | STRING | |
| NAME | BYTE\$1ARRAY | STRING | |
| TEXT | BYTE\$1ARRAY | STRING | |
| TEXT SEARCH | BYTE\$1ARRAY | STRING | |
| VARCHAR(N) | BYTE\$1ARRAY | STRING | |
| XML | BYTE\$1ARRAY | STRING | |
| Tipi di dati data e ora |
| DATE | BYTE\$1ARRAY | STRING | |
| INTERVAL | BYTE\$1ARRAY | STRING | |
| TIME | BYTE\$1ARRAY | STRING | |
| TIME WITH TIME ZONE | BYTE\$1ARRAY | STRING | |
| TIMESTAMP | BYTE\$1ARRAY | STRING | |
| TIMESTAMP WITH TIME ZONE | BYTE\$1ARRAY | STRING | |
| Tipi di dati geometrici |
| BOX | BYTE\$1ARRAY | STRING | |
| CIRCLE | BYTE\$1ARRAY | STRING | |
| LINE | BYTE\$1ARRAY | STRING | |
| LINESEGMENT | BYTE\$1ARRAY | STRING | |
| PATH | BYTE\$1ARRAY | STRING | |
| POINT | BYTE\$1ARRAY | STRING | |
| POLYGON | BYTE\$1ARRAY | STRING | |
| Tipi di dati JSON |
| JSON | BYTE\$1ARRAY | STRING | |
| JSONB | BYTE\$1ARRAY | STRING | |
| Altri tipi di dati |
| BOOLEAN | BOOLEAN | | |
| CIDR | BYTE\$1ARRAY | STRING | Tipo di dati di rete |
| COMPOSITE | BYTE\$1ARRAY | STRING | |
| DOMAIN | BYTE\$1ARRAY | STRING | |
| INET | BYTE\$1ARRAY | STRING | Tipo di dati di rete |
| MACADDR | BYTE\$1ARRAY | STRING | |
| OBJECT IDENTIFIER | N/A | | |
| PG\$1LSN | BYTE\$1ARRAY | STRING | |
| RANGE | BYTE\$1ARRAY | STRING | |
| UUID | BYTE\$1ARRAY | STRING | |
# Utilizzo di AWS Backup per gestire backup automatizzati per Amazon RDS
AWS Backup è un servizio di backup totalmente gestito che semplifica la centralizzazione e l'automazione del backup dei dati in tutti i servizi AWS nel cloud e in locale. I backup dei database Amazon RDS possono essere facilmente gestiti in AWS Backup.
**Nota**
I backup gestiti da AWS Backup sono considerati snapshot DB manuali, ma non vengono conteggiati per la quota snapshot DB per RDS. I backup che sono stati creati con AWS Backup hanno i nomi che terminano con `awsbackup:backup-job-number`.
Per ulteriori informazioni su AWS Backup[, consulta la *Guida per sviluppatori di AWS Backup*](https://docs.aws.amazon.com/aws-backup/latest/devguide).
**Per visualizzare i backup gestiti da AWS Backup**
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, selezionare **Snapshots (Snapshot)**.
1. Seleziona la scheda **Servizio di backup**.
I tuoi backup AWS Backup sono riportati in **Snapshot del servizio di backup**.