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à.
# 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 | |