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à.
# Importazione di dati in PostgreSQL su Amazon RDS
Si supponga di avere una distribuzione PostgreSQL esistente da spostare in Amazon RDS. La complessità dell'attività dipende dalle dimensioni del database e dal tipo di oggetti di database da trasferire. Pensa, ad esempio, a un database con diversi gigabyte di set di dati, trigger e stored procedure. Trasferire un database di questo tipo è più complicato che trasferire un semplice database con pochi megabyte di dati di test e senza trigger o stored procedure.
Ti consigliamo di utilizzare gli strumenti di migrazione dei database PostgreSQL nativi nei seguenti casi:
+ Hai una migrazione omogenea, dove effettui la migrazione da un database con lo stesso motore del database del database di destinazione.
+ Desideri migrare un intero database.
+ Gli strumenti nativi ti consentono di migrare il tuo sistema con tempi di inattività ridotti.
Nella maggior parte degli altri casi, eseguire una migrazione del AWS database utilizzando Database Migration Service (AWS DMS) è l'approccio migliore. AWS DMS può migrare i database senza tempi di inattività e, per molti motori di database, continuare la replica continua fino a quando non si è pronti a passare al database di destinazione. È possibile migrare allo stesso motore di database o a un motore di database diverso utilizzando DMS. AWS Se si esegue la migrazione a un motore di database diverso da quello del database di origine, è possibile utilizzare il AWS Schema Conversion Tool ().AWS SCT Si utilizza AWS SCT per migrare oggetti dello schema che non sono stati migrati da. AWS DMS[Per ulteriori informazioni su AWS DMS, consulta What is? AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Modifica il gruppo di parametri database per includere le seguenti impostazioni *solo per la tua importazione*. Per individuare le impostazioni più efficienti per le dimensioni della tua istanza database devi testare le impostazioni dei parametri. Dovrai inoltre ripristinare i valori di produzione per questi parametri al termine dell'impostazione.
Modifica i parametri dell'istanza database come segue:
+ Disabilita i backup delle istanze database (imposta backup\$1retention su 0).
+ Disabilita Multi-AZ.
Modifica il gruppo di parametri del database in modo da includere le seguenti impostazioni. Utilizza queste impostazioni soltanto quando importi i dati. Per individuare le impostazioni più efficienti per le dimensioni della tua istanza database devi testare le impostazioni dei parametri. Dovrai inoltre ripristinare i valori di produzione per questi parametri al termine dell'impostazione.
| Parametro | Valori consigliati durante l'importazione | Descrizione |
| --- | --- | --- |
| `maintenance_work_mem` | 524288, 1048576, 2097152 o 4194304 (in KB). Queste impostazioni sono paragonabili a 512 MB, 1 GB, 2 GB e 4 GB. | Il valore di questa impostazione dipende dalle dimensioni dell'host. Questo parametro viene utilizzato durante le istruzioni CREATE INDEX e ogni comando parallelo può utilizzare questa quantità di memoria. Calcola il valore ottimale, per evitare di impostare un valore troppo alto ed esaurire la memoria. |
| `max_wal_size` | 256 (per la versione 9.6), 4096 (per le versioni 10 e successive) | Dimensione massima per far crescere il WAL durante i checkpoint automatici. Aumentando questo parametro puoi aumentare il tempo necessario per il ripristino di caso di arresto anomalo. Questo parametro sostituisce `checkpoint_segments` per PostgreSQL 9.6 e versioni successive. Per PostgreSQL versione 9.6, questo valore è espresso in unità da 16 MB. Per le versioni successive, il valore è espresso in unità da 1 MB. Ad esempio, nella versione 9.6, 128 significa 128 blocchi ognuno con una dimensione di 16 MB. Nella versione 12.4, 2048 significa 2048 blocchi che hanno una dimensione di 1 MB. |
| `checkpoint_timeout` | 1800 | Il valore per questa impostazione consente una rotazione WAL meno frequente. |
| `synchronous_commit` | Disattivata | Disabilita questa impostazione per velocizzare la scrittura. La disattivazione del parametro può aumentare il rischio di perdita di dati in caso di arresto anomalo del server (non disattivare FSYNC) |
| `wal_buffers` | 8192 | Questo valore è impostato in unità di 8 KB. Anche questo aiuta a velocizzare la generazione dei WAL. |
| `autovacuum` | 0 | Disabilita il parametro di eliminazione automatica PostgreSQL durante il caricamento dei dati in modo che non utilizzi risorse. |
Utilizza i comandi `pg_dump -Fc` (compresso) o `pg_restore -j` (parallelo) con queste impostazioni.
**Nota**
Il comando PostgreSQL `pg_dumpall` richiede autorizzazioni super\$1user che non vengono concesse quando crei un'istanza database, quindi non puoi utilizzarlo per importare i dati.
**Topics**
+ [Importazione di un database PostgreSQL da un'istanza Amazon EC2](PostgreSQL.Procedural.Importing.EC2.md)
+ [Utilizzo del comando \$1copy per importare i dati in una tabella su un'istanza database PostgreSQL](PostgreSQL.Procedural.Importing.Copy.md)
+ [Importazione di dati da Amazon S3 in un'istanza database RDS per PostgreSQL](USER_PostgreSQL.S3Import.md)
+ [Trasporto dei database PostgreSQL tra istanze database](PostgreSQL.TransportableDB.md)
# Importazione di un database PostgreSQL da un'istanza Amazon EC2
Se i dati si trovano in un server PostgreSQL su un’istanza Amazon EC2 e desideri trasferirli in un’istanza database per PostgreSQL, puoi utilizzare la seguente procedura per eseguirne la migrazione.
1. Creare un file utilizzando pg\$1dump che contiene i dati da caricare
1. Creare l'istanza database di destinazione
1. Utilizzare *psql* per creare il database sull'istanza database e caricare i dati
1. Creare uno snapshot DB dell'istanza database
Nelle seguenti sezioni vengono forniti ulteriori dettagli su ciascuna delle fasi elencate in precedenza.
## Fase 1: creare un file utilizzando pg\$1dump che contiene i dati da caricare
L'utilità `pg_dump` utilizza il comando COPY per creare uno schema e il dump dei dati di un database PostgreSQL. Lo script del dump generato da `pg_dump` carica i dati in un database con lo stesso nome e ricrea le tabelle, gli indici e le chiavi esterne. Puoi utilizzare il comando `pg_restore` e il parametro `-d` per ripristinare i dati in un database con un nome diverso.
Prima di creare il dump dei dati, devi eseguire le query delle tabelle da sottoporre a dump per ottenere un conteggio delle righe e confermare il numero sull'istanza database di destinazione.
Il seguente commando crea un file dump denominato mydb2dump.sql per un database denominato mydb2.
```
prompt>pg_dump dbname=mydb2 -f mydb2dump.sql
```
## Passo 2: creare l'istanza database di destinazione.
Crea l'istanza database PostgreSQL di destinazione usando la console Amazon RDS, AWS CLI o l'API. Crea l'istanza con l'impostazione di retention dei backup impostata su 0 e disabilita l'opzione Multi-AZ. Ciò consente di velocizzare l'importazione dei dati. Devi creare un database sull'istanza prima di poter effettuare il dump dei dati. Il database può avere lo stesso nome del database che conteneva i dati del dump. In alternativa, puoi creare un database con un nome diverso. In questo caso, puoi utilizzare il comando `pg_restore` e il parametro `-d` per ripristinare i dati nel database con il nuovo nome.
Ad esempio, puoi utilizzare i seguenti comandi per il dump, il ripristino e la ridenominazione di un database.
```
pg_dump -Fc -v -h [endpoint of instance] -U [master username] [database] > [database].dump
createdb [new database name]
pg_restore -v -h [endpoint of instance] -U [master username] -d [new database name] [database].dump
```
## Passo 3: utilizzare psql per creare il database sull'istanza database e caricare i dati
Puoi utilizzare la stessa connessione utilizzata per eseguire il comando pg\$1dump per connetterti all'istanza database di destinazione e ricreare il database. Servendoti di *psql*, puoi utilizzare il nome utente master e la password master per creare il database sull'istanza database.
Il seguente esempio utilizza *psql* e un file dump denominato mydb2dump.sql per creare un database denominato mydb2 su un'istanza database PostgreSQL denominata mypginstance:
Per Linux, macOS o Unix:
```
psql \
-f mydb2dump.sql \
--host mypginstance.555555555555.aws-region.rds.amazonaws.com \
--port 8199 \
--username myawsuser \
--password password \
--dbname mydb2
```
Per Windows:
```
psql ^
-f mydb2dump.sql ^
--host mypginstance.555555555555.aws-region.rds.amazonaws.com ^
--port 8199 ^
--username myawsuser ^
--password password ^
--dbname mydb2
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
## Passo 4: creare uno snapshot DB dell'istanza database.
Dopo aver verificato che i dati siano stati caricati nella tua istanza database, ti consigliamo di creare uno snapshot DB dell'istanza database PostgreSQL di destinazione. Le snapshot DB sono backup completi della tua istanza database che puoi utilizzare per ripristinare la tua istanza database in uno stato noto. Una snapshot DB ottenuta immediatamente dopo il caricamento consente di non dover caricare nuovamente i dati in caso di problemi. Può essere utilizzata per inizializzare nuove istanze database. Per ulteriori informazioni sulla creazione di uno snapshot DB, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
# Utilizzo del comando \$1copy per importare i dati in una tabella su un'istanza database PostgreSQL
Il comando `\copy` di PostgreSQL è un meta-comando disponibile dallo strumento client interattivo `psql`. Puoi utilizzare `\copy` per importare i dati in una tabella sull'istanza database RDS for PostgreSQL. Per utilizzare il comando `\copy`, è necessario innanzitutto creare la struttura della tabella sull'istanza database di destinazione in modo che `\copy` abbia una destinazione per i dati copiati.
Puoi utilizzare `\copy` per caricare i dati da un file di valori separati da virgole (CSV), ad esempio uno che è stato esportato e salvato nella workstation client.
Per importare i dati CSV nell'istanza database RDS for PostgreSQL di destinazione, connettiti prima all'istanza database di destinazione utilizzando `psql`.
```
psql --host=db-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=target-db
```
Quindi esegui il comando `\copy` con i seguenti parametri per identificare la destinazione per i dati e il relativo formato.
+ `target_table` - Il nome della tabella che dovrebbe ricevere i dati copiati dal file CSV.
+ `column_list` - Specifiche delle colonne per la tabella.
+ `'filename'` - Il percorso completo del file CSV sulla workstation locale.
```
\copy target_table from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV;
```
Se il file CSV contiene informazioni sull'intestazione di colonna, puoi utilizzare questa versione del comando e dei parametri.
```
\copy target_table (column-1, column-2, column-3, ...)
from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV HEADER;
```
Se il comando `\copy` ha esito negativo, PostgreSQL emette messaggi di errore.
Crea una nuova istanza database utilizzando il comando `psql` dell’ambiente di anteprima del database con il meta-comando `\copy` come mostrato negli esempi seguenti. Questo esempio utilizza *source-table* come nome della tabella di origine, *source-table.csv* come file .csv e *target-db* come database di destinazione:
Per Linux, macOS o Unix:
```
$psql target-db \
-U \
-p \
-h \
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Per Windows:
```
$psql target-db ^
-U ^
-p ^
-h ^
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Per informazioni dettagliate sul comando `\copy`, consulta la pagina [psql](http://www.postgresql.org/docs/current/static/app-psql.html) nella documentazione di PostgreSQL, nella sezione *Meta-comandi*.
# Importazione di dati da Amazon S3 in un'istanza database RDS per PostgreSQL
Puoi importare i dati che sono stati archiviati utilizzando Servizio di archiviazione semplice Amazon in una tabella su un'istanza database RDS per PostgreSQL. A questo scopo, installa innanzitutto l'estensione RDS per PostgreSQL `aws_s3`. Questa estensione fornisce le funzioni utilizzate per importare i dati da un bucket Amazon S3. Un *bucket* è un container Amazon S3 per oggetti e file. I dati possono trovarsi in un file con valori separati da virgole (CSV), un file di testo o un file compresso (gzip). Di seguito, sono fornite informazioni su come installare l'estensione e come importare dati da Amazon S3 in una tabella.
Per eseguire l'importazione da Amazon S3 a RDS for PostgreSQL, il database deve eseguire PostgreSQL versione 10.7 o successive.
Se Amazon S3 non contiene dati, occorre innanzitutto creare un bucket e archiviare i dati. Per ulteriori informazioni, consulta i seguenti argomenti nella *Guida per l'utente di Servizio di archiviazione semplice Amazon*.
+ [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#creating-bucket)
+ [Aggiunta di un oggetto a un bucket.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket)
È supportata l'importazione multiaccount da Amazon S3. Per ulteriori informazioni, consulta [Concessione di autorizzazioni multiaccount](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
Puoi utilizzare la chiave gestita dal cliente per la crittografia durante l'importazione dei dati da S3. Per ulteriori informazioni, consulta [Chiavi KMS archiviate in AWS KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
**Topics**
+ [Installazione dell'estensione aws\$1s3](USER_PostgreSQL.S3Import.InstallExtension.md)
+ [Panoramica dell'importazione di dati dai dati di Amazon S3](USER_PostgreSQL.S3Import.Overview.md)
+ [Configurazione dell'accesso a un bucket Simple Storage Service (Amazon S3)](USER_PostgreSQL.S3Import.AccessPermission.md)
+ [Importazione di dati da Amazon S3 alla tua istanza database](USER_PostgreSQL.S3Import.FileFormats.md)
+ [Informazioni di riferimento sulle funzioni](USER_PostgreSQL.S3Import.Reference.md)
# Installazione dell'estensione aws\$1s3
Prima di poter utilizzare Amazon S3 con l'istanza database RDS per PostgreSQL, è necessario installare l'estensione `aws_s3`. Questa estensione fornisce funzioni per l'importazione dei dati da Amazon S3. Inoltre, fornisce funzioni per l'esportazione di dati da un'istanza database RDS per PostgreSQL in un bucket Amazon S3. Per ulteriori informazioni, consulta [Esportazione di dati da un'istanza di database del RDS per PostgreSQL a Amazon S3](postgresql-s3-export.md). L'estensione `aws_s3` dipende da alcune delle funzioni helper nell'estensione `aws_commons`, che vengono installate automaticamente quando necessario.
**Per installare l'estensione `aws_s3`**
1. Usa psql (o pgAdmin) per connetterti all'istanza database RDS per PostgreSQL come un utente che dispone di privilegi `rds_superuser`. Se hai mantenuto il nome predefinito durante il processo di configurazione, esegui la connessione come `postgres`.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Per installare l'estensione, esegui il comando seguente.
```
postgres=> CREATE EXTENSION aws_s3 CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
1. Per verificare che l'estensione sia installata, puoi usare il metacomando psql `\dx`.
```
postgres=> \dx
List of installed extensions
Name | Version | Schema | Description
-------------+---------+------------+---------------------------------------------
aws_commons | 1.2 | public | Common data types across AWS services
aws_s3 | 1.1 | public | AWS S3 extension for importing data from S3
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
(3 rows)
```
Le funzioni per importare dati da Amazon S3 ed esportare dati in Amazon S3 sono ora disponibili per l'uso.
# Panoramica dell'importazione di dati dai dati di Amazon S3
**Per importare i dati S3 in Amazon RDS**
Raccogli innanzitutto i dettagli che devi fornire alla funzione. Questi includono il nome della tabella sull'istanza del cluster percorso del file, il tipo di file e dove sono archiviati i dati di Amazon S3. Regione AWS Per ulteriori informazioni, consulta [Visualizzazione di un oggetto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) nella *Guida per l'utente di Servizio di archiviazione semplice Amazon*.
**Nota**
L'importazione in più parti da Amazon S3 non è attualmente supportata.
1. Otteni il nome della tabella in cui la funzione `aws_s3.table_import_from_s3` deve importare dati. Il seguente comando, ad esempio, crea una tabella `t1` che può essere utilizzata in fasi successive.
```
postgres=> CREATE TABLE t1
(col1 varchar(80),
col2 varchar(80),
col3 varchar(80));
```
1. Ottieni i dettagli relativi al bucket Amazon S3 e i dati da importare. **A tale scopo, apri la console Amazon S3 all'indirizzo e scegli [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)Bucket.** Individua il bucket contenente i dati nell'elenco. Scegli il bucket, apri la pagina Object overview (Panoramica degli oggetti) e quindi scegli Properties (Proprietà).
Prendi nota del nome, del percorso, del e del tipo di file del Regione AWS bucket. Il nome della risorsa Amazon (ARN) è richiesto in un secondo momento per configurare l'accesso ad Amazon S3 tramite un ruolo IAM. Per ulteriori informazioni, consulta [Configurazione dell'accesso a un bucket Simple Storage Service (Amazon S3)](USER_PostgreSQL.S3Import.AccessPermission.md). Un esempio è illustrato nell'immagine seguente.
![\[Immagine di un oggetto file in un bucket Amazon S3.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/aws_s3_import-export_s3_bucket-info.png)
1. Puoi verificare il percorso dei dati nel bucket Amazon S3 utilizzando il comando. AWS CLI `aws s3 cp` Se le informazioni sono corrette, questo comando scarica una copia del file Amazon S3.
```
aws s3 cp s3://amzn-s3-demo-bucket/sample_file_path ./
```
1. Configura le autorizzazioni sull'istanza database RDS per PostgreSQL per consentire l'accesso al file sul bucket Amazon S3. A tale scopo, utilizzi un ruolo AWS Identity and Access Management (IAM) o credenziali di sicurezza. Per ulteriori informazioni, consulta [Configurazione dell'accesso a un bucket Simple Storage Service (Amazon S3)](USER_PostgreSQL.S3Import.AccessPermission.md).
1. Fornisci alla funzione `create_s3_uri` il percorso e gli altri dettagli dell'oggetto Amazon S3 raccolti (vedi passaggio 2) per costruire un oggetto URI Amazon S3. Per ulteriori informazioni su questa funzione, consulta [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri). Di seguito è riportato un esempio di costruzione dell'oggetto durante una sessione psql.
```
postgres=> SELECT aws_commons.create_s3_uri(
'docs-lab-store-for-rpg',
'versions_and_jdks_listing.csv',
'us-west-1'
) AS s3_uri \gset
```
Nella fase seguente, si passa questo oggetto (`aws_commons._s3_uri_1`) alla funzione `aws_s3.table_import_from_s3` per importare i dati nella tabella.
1. Invoca la funzione `aws_s3.table_import_from_s3` per importare dati da Amazon S3 nella tabella. Per informazioni di riferimento, consulta [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). Per alcuni esempi, consulta [Importazione di dati da Amazon S3 alla tua istanza database ](USER_PostgreSQL.S3Import.FileFormats.md).
# Configurazione dell'accesso a un bucket Simple Storage Service (Amazon S3)
Per importare i dati da un file Amazon S3, concedere al a RDS per un'istanza database PostgreSQL l'autorizzazione ad accedere al bucket Amazon S3 che contiene il file. Puoi concedere l'accesso a un bucket Amazon S3 in uno dei due modi descritti negli argomenti seguenti.
**Topics**
+ [Utilizzo di un ruolo IAM per accedere a un bucket Amazon S3.](#USER_PostgreSQL.S3Import.ARNRole)
+ [Utilizzo delle credenziali di sicurezza per accedere a un bucket Amazon S3](#USER_PostgreSQL.S3Import.Credentials)
+ [Risoluzione dei problemi di accesso a Amazon S3](#USER_PostgreSQL.S3Import.troubleshooting)
## Utilizzo di un ruolo IAM per accedere a un bucket Amazon S3.
Prima di caricare i dati da un file Amazon S3, è necessario concedere a RDS per un'istanza database PostgreSQL l'autorizzazione per accedere al bucket Amazon S3 che contiene il file. In questo modo non dovrai gestire ulteriori informazioni sulle credenziali né fornirle nella chiamata della funzione [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
Per svolgere questa operazione, creare una policy IAM che fornisca accesso al bucket Amazon S3. Creare un ruolo IAM e collegarvi la policy. Quindi, assegnare il ruolo IAM all'istanza database.
**Per consentire a un RDS per un'istanza database PostgreSQL l'accesso a Amazon S3 tramite un ruolo IAM.**
1. Creare una policy IAM
Questa policy fornisce le autorizzazioni bucket e di oggetto che consentono a RDS per un'istanza database PostgreSQL di accedere a Amazon S3.
Includere nella policy le seguenti operazioni necessarie per consentire il trasferimento dei file da un bucket Amazon S3 a Amazon RDS:
+ `s3:GetObject`
+ `s3:ListBucket`
Includere nella policy le seguenti risorse per identificare il bucket Amazon S3 e gli oggetti nel bucket. Questo mostra il formato Amazon Resource Name (ARN) per accedere a Amazon S3.
+ arn:aws:s3::: *amzn-s3-demo-bucket*
+ arn:aws:s3::: /\$1 *amzn-s3-demo-bucket*
Per ulteriori informazioni sulla creazione di una policy IAM per RDS per PostgreSQL, consulta [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 con queste opzioni. `rds-s3-import-policy` Concede l'accesso a un bucket denominato *amzn-s3-demo-bucket*.
**Nota**
Prendi nota del nome della risorsa Amazon (ARN) della policy restituita mediante questo comando. L'ARN sarà richiesto in una fase successiva quando si associa la policy a un ruolo IAM.
**Example**
Per Linux, macOS o Unix:
```
aws iam create-policy \
--policy-name rds-s3-import-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3import",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
Per Windows:
```
aws iam create-policy ^
--policy-name rds-s3-import-policy ^
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3import",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
1. Crea un ruolo IAM.
In questo modo, Amazon RDS può 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*.
Si consiglia di utilizzare le chiavi di contesto delle condizioni globali `[aws:SourceArn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)` e `[aws:SourceAccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)` nelle policy basate sulle risorse per limitare le autorizzazioni del servizio a una risorsa specifica. Questo è il modo più efficace per proteggersi dal [problema di deputy confused](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Se si utilizzano entrambe le chiavi di contesto delle condizioni globali e il valore `aws:SourceArn` contiene l'ID account, il valore `aws:SourceAccount` e l’account nel valore `aws:SourceArn` devono utilizzare lo stesso ID account quando viene utilizzato nella stessa dichiarazione di policy.
+ Utilizzare `aws:SourceArn` se si desidera un accesso cross-service per una singola risorsa.
+ Utilizzare `aws:SourceAccount` se si desidera consentire l'associazione di qualsiasi risorsa in tale account all'uso cross-service.
Nella policy, assicurarsi di utilizzare la chiave di contesto della condizione globale `aws:SourceArn` con l'ARN completo della risorsa. L'esempio seguente mostra come eseguire questa operazione utilizzando il AWS CLI comando per creare un ruolo denominato`rds-s3-import-role`.
**Example**
Per Linux, macOS o Unix:
```
aws iam create-role \
--role-name rds-s3-import-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
Per Windows:
```
aws iam create-role ^
--role-name rds-s3-import-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
1. Collegare la policy IAM al ruolo IAM creato.
Il AWS CLI comando seguente collega la policy creata nel passaggio precedente al ruolo denominato `rds-s3-import-role` Replace `your-policy-arn` con l'ARN della policy annotato in un passaggio precedente.
**Example**
Per Linux, macOS o Unix:
```
aws iam attach-role-policy \
--policy-arn your-policy-arn \
--role-name rds-s3-import-role
```
Per Windows:
```
aws iam attach-role-policy ^
--policy-arn your-policy-arn ^
--role-name rds-s3-import-role
```
1. Aggiungere il ruolo IAM all'istanza database.
A tale scopo, utilizzare Console di gestione AWS o AWS CLI, come descritto di seguito.
### Console
**Per aggiungere un ruolo IAM all'istanza database PostgreSQL tramite la console**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Scegliere il nome dell'istanza database PostgreSQL per visualizzarne i dettagli.
1. Nella scheda **Connettività e sicurezza**, nella sezione **Gestisci ruoli IAM**, scegli il ruolo da aggiungere in **Aggiungi ruoli IAM a questa del cluster**.
1. In **Feature (Caratteristica)**, scegliere **s3Import**.
1. Scegliere **Add role (Aggiungi ruolo)**.
### AWS CLI
**Per aggiungere un ruolo IAM a un'istanza database PostgreSQL tramite CLI**
+ Utilizzare il seguente comando per aggiungere il ruolo all'istanza database PostgreSQL denominata `my-db-instance`. Sostituire *`your-role-arn`* con l'ARN del ruolo annotato in precedenza. Utilizzare `s3Import` come valore dell’opzione `--feature-name`.
**Example**
Per Linux, macOS o Unix:
```
aws rds add-role-to-db-instance \
--db-instance-identifier my-db-instance \
--feature-name s3Import \
--role-arn your-role-arn \
--region your-region
```
Per Windows:
```
aws rds add-role-to-db-instance ^
--db-instance-identifier my-db-instance ^
--feature-name s3Import ^
--role-arn your-role-arn ^
--region your-region
```
### API RDS
Per aggiungere un ruolo IAM per un'istanza del DB PostgreSQL utilizzando l'API Amazon RDS, chiama l'operazione.
## Utilizzo delle credenziali di sicurezza per accedere a un bucket Amazon S3
Se preferisci, puoi utilizzare le credenziali di sicurezza per fornire accesso a un bucket Amazon S3 invece di fornire accesso con un ruolo IAM. A tale scopo, specifica il parametro `credentials` nella chiamata di funzione [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
Il `credentials` parametro è una struttura di tipo `aws_commons._aws_credentials_1` che contiene le credenziali. AWS Utilizzare la funzione [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) per impostare la chiave di accesso e la chiave segreta in una struttura `aws_commons._aws_credentials_1`, come illustrato di seguito.
```
postgres=> SELECT aws_commons.create_aws_credentials(
'sample_access_key', 'sample_secret_key', '')
AS creds \gset
```
Dopo aver creato la struttura `aws_commons._aws_credentials_1 `, utilizzare la funzione [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) con il parametro `credentials` per importare i dati, come illustrato di seguito.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't', '', '(format csv)',
:'s3_uri',
:'creds'
);
```
Oppure si può includere la chiamata inline di funzione [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) all'interno della chiamata di funzione `aws_s3.table_import_from_s3`.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't', '', '(format csv)',
:'s3_uri',
aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
);
```
## Risoluzione dei problemi di accesso a Amazon S3
Se riscontri problemi di connessione quanto tenti di importare i dati da Amazon S3, segui questi suggerimenti:
+ [Risoluzione dei problemi di identità e accesso in Amazon RDS](security_iam_troubleshoot.md)
+ [Risoluzione dei problemi di Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/troubleshooting.html) nella *Guida per l'utente di Amazon Simple Storage Service*
+ [Risoluzione dei problemi di Amazon S3 e IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_iam-s3.html) nella *Guida per l'utente IAM*.
# Importazione di dati da Amazon S3 alla tua istanza database
Importa i dati dal bucket Amazon S3 utilizzando la funzione `table_import_from_s3` dell'estensione aws\$1s3. Per informazioni di riferimento, consulta [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
**Nota**
Gli esempi seguenti utilizzano il metodo del ruolo IAM per consentire l'accesso al bucket Amazon S3. Pertanto, le chiamate della funzione `aws_s3.table_import_from_s3` non includono parametri di credenziali.
Di seguito viene illustrato un tipico esempio.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't1',
'',
'(format csv)',
:'s3_uri'
);
```
I parametri sono i seguenti:
+ `t1` – Il nome della tabella nell'istanza database PostgreSQL in cui copiare i dati.
+ `''` – Un elenco opzionale di colonne nella tabella di database. Questo parametro può essere utilizzato per indicare quali colonne di dati S3 vanno in quali colonne della tabella. Se non viene specificata alcuna colonna, tutte le colonne vengono copiate nella tabella. Per un esempio di utilizzo di un elenco di colonne, consulta [Importazione di un file Amazon S3 che utilizza un delimitatore personalizzato](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
+ `(format csv)` – Argomenti COPY di PostgreSQL. La procedura di copia utilizza gli argomenti e il formato del comando [COPY di PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html) per importare i dati. Le scelte di formato includono valori separati da virgole (CSV), come mostrato in questo esempio, testo e file binario. Il valore predefinito è testo.
+ `s3_uri` – Una struttura contenente le informazioni che identificano il file Amazon S3. Per un esempio di utilizzo della funzione [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) per creare una struttura `s3_uri`, consulta [Panoramica dell'importazione di dati dai dati di Amazon S3](USER_PostgreSQL.S3Import.Overview.md).
Per ulteriori informazioni su questa funzione, consulta [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
La funzione restituisce `aws_s3.table_import_from_s3`. Per specificare altri tipi di file da importare da un bucket Amazon S3, consulta uno dei seguenti esempi.
**Nota**
L'importazione di un file da 0 byte genererà un errore.
**Topics**
+ [Importazione di un file Amazon S3 che utilizza un delimitatore personalizzato](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter)
+ [Importazione di un file compresso (gzip) Amazon S3](#USER_PostgreSQL.S3Import.FileFormats.gzip)
+ [Importazione di un file Amazon S3 codificato](#USER_PostgreSQL.S3Import.FileFormats.Encoded)
## Importazione di un file Amazon S3 che utilizza un delimitatore personalizzato
Il seguente esempio mostra come importare un file che utilizza un delimitatore personalizzato. Mostra anche come controllare dove inserire i dati nella tabella di database utilizzando il parametro `column_list` della funzione [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
In questo esempio si presuppone che le seguenti informazioni siano organizzate in colonne delimitate da pipe nel file Amazon S3.
```
1|foo1|bar1|elephant1
2|foo2|bar2|elephant2
3|foo3|bar3|elephant3
4|foo4|bar4|elephant4
...
```
**Per importare un file che utilizza un delimitatore personalizzato**
1. Creare una tabella nel database per i dati importati.
```
postgres=> CREATE TABLE test (a text, b text, c text, d text, e text);
```
1. Utilizzare il seguente formato della funzione [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) per importare i dati dal file Amazon S3.
Si può includere la chiamata inline di funzione [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) all'interno della chiamata di funzione `aws_s3.table_import_from_s3` per specificare il file.
```
postgres=> SELECT aws_s3.table_import_from_s3(
'test',
'a,b,d,e',
'DELIMITER ''|''',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'pipeDelimitedSampleFile', 'us-east-2')
);
```
I dati sono ora nella tabella nelle seguenti colonne.
```
postgres=> SELECT * FROM test;
a | b | c | d | e
---+------+---+---+------+-----------
1 | foo1 | | bar1 | elephant1
2 | foo2 | | bar2 | elephant2
3 | foo3 | | bar3 | elephant3
4 | foo4 | | bar4 | elephant4
```
## Importazione di un file compresso (gzip) Amazon S3
Il seguente esempio mostra come importare da Amazon S3 un file compresso con gzip. Il file importato deve avere i seguenti metadati Amazon S3:
+ Chiave: `Content-Encoding`
+ Valore: `gzip`
Se carichi il file utilizzando il, i metadati vengono in genere applicati dal sistema Console di gestione AWS. Per informazioni sul caricamento di file su Amazon S3 utilizzando Console di gestione AWS l', la o l'API, AWS CLI[consulta Uploading](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) objects nella *Amazon Simple Storage Service User Guide*.
Per ulteriori informazioni sui metadati di Amazon S3 e i dettagli sui metadati forniti dal sistema, consulta la sezione [Modifica dei metadati degli oggetti nella console Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-object-metadata.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
Importare il file gzip in RDS per un'istanza database PostgreSQL, come illustrato di seguito.
```
postgres=> CREATE TABLE test_gzip(id int, a text, b text, c text, d text);
postgres=> SELECT aws_s3.table_import_from_s3(
'test_gzip', '', '(format csv)',
'amzn-s3-demo-bucket', 'test-data.gz', 'us-east-2'
);
```
## Importazione di un file Amazon S3 codificato
Il seguente esempio mostra come importare da Amazon S3 un file codificato con Windows-1252
```
postgres=> SELECT aws_s3.table_import_from_s3(
'test_table', '', 'encoding ''WIN1252''',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'SampleFile', 'us-east-2')
);
```
# Informazioni di riferimento sulle funzioni
**Topics**
+ [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3)
+ [aws\$1commons.create\$1s3\$1uri](#USER_PostgreSQL.S3Import.create_s3_uri)
+ [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials)
## aws\$1s3.table\$1import\$1from\$1s3
Importa dati Amazon S3 in una tabella Amazon RDS. L'estensione `aws_s3` fornisce la funzione `aws_s3.table_import_from_s3`. Il valore restituito è testo.
### Sintassi
I parametri richiesti sono `table_name`, `column_list` e `options`. Identificano la tabella di database e specificano il modo in cui i dati vengono copiati nella tabella
Puoi inoltre utilizzare i seguenti parametri:
+ Il parametro `s3_info` specifica il file Amazon S3 da importare. Se si utilizza questo parametro, l'accesso a Amazon S3 è fornito da un ruolo IAM per l'istanza database PostgreSQL.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
s3_info aws_commons._s3_uri_1
)
```
+ Il parametro `credentials` specifica le credenziali per accedere a Amazon S3. Se si utilizza questo parametro, non si utilizza il ruolo IAM.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
s3_info aws_commons._s3_uri_1,
credentials aws_commons._aws_credentials_1
)
```
### Parameters
*table\$1name*
Una stringa di testo obbligatoria contenente il nome della tabella di database PostgreSQL in cui importare i dati.
*column\$1list*
Una stringa di testo obbligatoria contenente un elenco opzionale delle colonne della tabella di database PostgreSQL nelle quali copiare i dati. Se la stringa è vuota, vengono utilizzate tutte le colonne della tabella. Per un esempio, consulta [Importazione di un file Amazon S3 che utilizza un delimitatore personalizzato](USER_PostgreSQL.S3Import.FileFormats.md#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
*options*
Una stringa di testo obbligatorio contenente gli argomenti del comando `COPY` di PostgreSQL. Tali argomenti specificano in che modo i dati vengono copiati nella tabella PostgreSQL. Per maggiori dettagli, consulta la [documentazione di COPY PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*s3\$1info*
Un tipo composito `aws_commons._s3_uri_1` contenente le seguenti informazioni sull'oggetto S3:
+ `bucket` – Il nome del bucket Amazon S3 contenente il file.
+ `file_path` – Il nome file di Amazon S3, incluso il percorso.
+ `region`— La AWS regione in cui si trova il file. Per un elenco dei nomi delle AWS regioni e dei valori associati, vedere[Regioni, zone di disponibilità e Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
*credenziali*
Un tipo composito `aws_commons._aws_credentials_1` contenente le seguenti credenziali da utilizzare per l'operazione di importazione:
+ Chiave di accesso
+ Chiave segreta
+ Token di sessione
Per informazioni sulla creazione di una struttura composita `aws_commons._aws_credentials_1`, consulta [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials).
### Sintassi alternativa
Per un aiuto nei test, si può utilizzare un set più ampio di parametri al posto dei parametri `s3_info` e `credentials`. Di seguito vengono riportate le variazioni di sintassi aggiuntive per la funzione `aws_s3.table_import_from_s3`.
+ Invece di utilizzare il parametro `s3_info` per identificare un file Amazon S3, utilizzare la combinazione dei parametri `bucket`, `file_path` e `region`. Con questo formato della funzione, l'accesso a Amazon S3 viene fornito da un ruolo IAM nell'istanza database PostgreSQL.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
bucket text,
file_path text,
region text
)
```
+ Invece di utilizzare il parametro `credentials` per specificare l'accesso a Amazon S3, utilizzare la combinazione dei parametri `access_key`, `session_key` e `session_token`.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
bucket text,
file_path text,
region text,
access_key text,
secret_key text,
session_token text
)
```
### Parametri alternativi
*bucket*
Una stringa di testo contenente il nome del bucket Amazon S3 che contiene il file
*file\$1path*
Una stringa di testo contenente il nome file di Amazon S3, incluso il percorso.
*Regione*
Una stringa di testo che identifica la Regione AWS posizione del file. Per un elenco dei Regione AWS nomi e dei valori associati, vedere[Regioni, zone di disponibilità e Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
*chiave\$1accesso*
Una stringa di testo contenente la chiave di accesso da utilizzare per l'operazione di importazione. Il valore predefinito è NULL.
*secret\$1key*
Una stringa di testo contenente la chiave segreta da utilizzare per l'operazione di importazione. Il valore predefinito è NULL.
*session\$1token*
(Opzionale) Una stringa di testo contenente la chiave di sessione da utilizzare per l'operazione di importazione. Il valore predefinito è NULL.
## aws\$1commons.create\$1s3\$1uri
Crea una struttura `aws_commons._s3_uri_1` per conservare le informazioni relative al file Amazon S3. Si utilizzano i risultati della funzione `aws_commons.create_s3_uri` nel parametro `s3_info` della funzione [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3).
### Sintassi
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```
### Parameters
*bucket*
Una stringa di testo obbligatoria contenente il nome del bucket Amazon S3 del file.
*file\$1path*
Una stringa di testo obbligatoria contenente il nome file di Amazon S3, incluso il percorso.
*Regione*
Una stringa di testo obbligatoria Regione AWS contenente il file. Per un elenco dei Regione AWS nomi e dei valori associati, vedere[Regioni, zone di disponibilità e Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
## aws\$1commons.create\$1aws\$1credentials
Imposta una chiave di accesso e una chiave segreta in una struttura `aws_commons._aws_credentials_1`. Si utilizzano i risultati della funzione `aws_commons.create_aws_credentials` nel parametro `credentials` della funzione [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3).
### Sintassi
```
aws_commons.create_aws_credentials(
access_key text,
secret_key text,
session_token text
)
```
### Parameters
*chiave\$1accesso*
Una stringa di testo obbligatoria contenente la chiave di accesso da utilizzare per l'importazione di un file Amazon S3. Il valore predefinito è NULL.
*secret\$1key*
Una stringa di testo obbligatoria contenente la chiave segreta da utilizzare per l'importazione di un file Amazon S3. Il valore predefinito è NULL.
*session\$1token*
Una stringa di testo opzionale contenente il token di sessione da utilizzare per l'importazione di un file Amazon S3. Il valore predefinito è NULL. Se si fornisce un `session_token` opzionale, è possibile utilizzare credenziali temporanee.
# Trasporto dei database PostgreSQL tra istanze database
Utilizzando Transportable Database di PostgreSQL per Amazon RDS, puoi spostare un database PostgreSQL tra due istanze database. Si tratta di un modo molto rapido per migrare database di grandi dimensioni tra diverse istanze database. Per utilizzare questo approccio, le istanze database devono essere entrambe eseguite con la stessa versione principale di PostgreSQL.
Questa funzionalità richiede l'installazione dell’estensione `pg_transport` sull'istanza database di origine e destinazione. L’estensione `pg_transport` fornisce un meccanismo di trasporto fisico che consente di spostare i file del database con elaborazione minima. Questo meccanismo consente di spostare i dati più rapidamente rispetto ai tradizionali processi dump e load, con tempi di inattività molto ridotti.
**Nota**
Transportable Database di PostgreSQL è disponibile in RDS for PostgreSQL versioni 11.5 e in RDS for PostgreSQL versioni 10.10 e successive.
Per trasportare un'istanza database PostgreSQL da un'istanza database RDS for PostgreSQL a un'altra, è necessario innanzitutto impostare le istanze di origine e di destinazione come descritto in [ Configurazione di un’istanza database per il trasporto](PostgreSQL.TransportableDB.Setup.md). È quindi possibile trasportare il database utilizzando la funzione descritta in [ Trasporto di un database PostgreSQL](PostgreSQL.TransportableDB.Transporting.md).
**Topics**
+ [Cosa succede durante il trasporto del database](#PostgreSQL.TransportableDB.DuringTransport)
+ [Limitazioni all'utilizzo di Transportable Database di PostgreSQL](#PostgreSQL.TransportableDB.Limits)
+ [Configurazione del trasporto di un database PostgreSQL](PostgreSQL.TransportableDB.Setup.md)
+ [Trasporto di un database PostgreSQL alla destinazione dall'origine](PostgreSQL.TransportableDB.Transporting.md)
+ [Riferimento per la funzione Transportable Database](PostgreSQL.TransportableDB.transport.import_from_server.md)
+ [Riferimento per i parametri di Transportable Database](PostgreSQL.TransportableDB.Parameters.md)
## Cosa succede durante il trasporto del database
La funzione Transportable Database di PostgreSQL utilizza un modello pull per importare il database dall'istanza database di origine alla destinazione. La funzione `transport.import_from_server` crea il database in transito nell'istanza database di destinazione. Il database in transito non è accessibile nell'istanza database di destinazione per tutta la durata del trasporto.
All'avvio del trasporto, tutte le sessioni correnti nel database di origine vengono terminate. Nessun database, oltre al database di origine nell'istanza database di origine, viene interessato dal trasporto.
Il database di origine passa in una modalità speciale di sola lettura. In questa modalità, puoi connetterti al database di origine ed eseguire query di sola lettura. Invece, le query abilitate per la scrittura e alcuni altri tipi di comandi sono bloccati. Solo lo specifico database di origine trasportato è sottoposto a queste limitazioni.
Durante il trasporto, non puoi ripristinare l'istanza database di destinazione a un point-in-time perché il trasporto non è transazionale e non utilizza il log write-ahead (WAL) di PostgreSQL per registrare le modifiche. Se l'istanza DB di destinazione ha i backup automatici abilitati, viene eseguito automaticamente un backup dopo il completamento del trasporto. Point-in-timei ripristini sono disponibili per alcuni periodi successivi al *termine del backup*.
Se il trasporto non riesce, l'estensione `pg_transport` tenta di annullare tutte le modifiche alle istanze database di origine e di destinazione, inclusa la rimozione del database parzialmente trasportato nella destinazione. A seconda del tipo di errore, il database di origine potrebbe continuare a rifiutare le query abilitate per la scrittura. Se accade, utilizza il comando seguente per consentirle.
```
ALTER DATABASE db-name SET default_transaction_read_only = false;
```
## Limitazioni all'utilizzo di Transportable Database di PostgreSQL
Transportable Database ha le limitazioni seguenti:
+ **Repliche di lettura** – I database trasportabili non possono essere utilizzati su repliche di lettura o istanze padre di repliche di lettura.
+ **Tipi di colonne non supportati** – Impossibile utilizzare i tipi di dati `reg` nelle tabelle di database che si intendono trasportare con questo metodo. Questi tipi dipendono dall'oggetto del catalogo di sistema IDs (OIDs), che spesso cambia durante il trasporto.
+ **Spazi tabelle** – Tutti gli oggetti del database di origine devono trovarsi nello spazio tabelle `pg_default` predefinito.
+ **Compatibilità** – Le istanze database di origine e di destinazione devono eseguire la stessa versione principale di PostgreSQL.
+ **Estensioni** – L'istanza database di origine può avere solo `pg_transport` installato.
+ **Ruoli e ACLs**: i privilegi di accesso e le informazioni sulla proprietà del database di origine non vengono trasferiti al database di destinazione. Tutti gli oggetti del database vengono creati e assegnati all'utente di destinazione locale del trasporto.
+ **Trasporti simultanei** – Una singola istanza database può supportare fino a 32 trasporti simultanei, comprese le importazioni e le esportazioni, se i processi di lavoro sono stati configurati correttamente.
+ **Solo istanze database RDS for PostgreSQL** – Sono supportati solo database trasportabili sulle istanze database RDS for PostgreSQL. Non è possibile utilizzarlo con database o database locali in esecuzione su Amazon EC2.
# Configurazione del trasporto di un database PostgreSQL
Prima di iniziare, verifica che le istanze database RDS for PostgreSQL soddisfino i seguenti requisiti seguenti:
+ Le istanze database RDS for PostgreSQL di origine e di destinazione devono eseguire la stessa versione di PostgreSQL.
+ Il database di destinazione non può avere un database con lo stesso nome del database di origine che si desidera trasportare.
+ L'account utilizzato per eseguire il trasporto necessita di privilegi `rds_superuser` sia sul database di origine che sul database di destinazione.
+ Il gruppo di sicurezza per l'istanza database di origine deve consentire l'accesso in entrata dall'istanza database di destinazione. Questo potrebbe già accadere se le istanze database di origine e di destinazione si trovano nel VPC. Per ulteriori informazioni sui gruppi di sicurezza, consulta [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md).
Il trasporto dei database da un'istanza database di origine a un'istanza database di destinazione richiede diverse modifiche al gruppo parametri del database associato a ciascuna istanza. Ciò significa che è necessario creare un gruppo parametri del database personalizzato per l'istanza database di origine e creare un gruppo parametri del database personalizzato per l'istanza database di destinazione.
**Nota**
Se le istanze database sono già configurate utilizzando gruppi di parametri del database personalizzati, è possibile iniziare con il passaggio 2 della procedura seguente.
**Per configurare il gruppo parametri del database personalizzato per il trasporto dei database**
Per i seguenti passaggi, utilizza un account con privilegi `rds_superuser`.
1. Se le istanze database di origine e di destinazione utilizzano un gruppo di parametri database predefinito, è necessario creare un gruppo di parametri database personalizzato utilizzando la versione appropriata per le istanze. Questa operazione consente di modificare i valori per diversi parametri. Per ulteriori informazioni, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
1. Nel gruppo parametri del database personalizzato, modifica i valori per i seguenti parametri:
+ `shared_preload_libraries` – Aggiungi `pg_transport` all'elenco delle librerie.
+ `pg_transport.num_workers` – Il valore predefinito è 3. Aumenta o riduci questo valore secondo necessità del tuo database. Per un database da 200 GB, consigliamo un valore non più alto di 8. Tieni presente che se aumenti il valore predefinito per questo parametro, dovresti anche aumentare il valore di `max_worker_processes`.
+ `pg_transport.work_mem` – Il valore predefinito è 128 MB o 256 MB, a seconda della versione di PostgreSQL. In genere, l'impostazione predefinita può essere lasciata invariata.
+ `max_worker_processes` - Il valore di questo parametro deve essere impostato utilizzando il seguente calcolo:
```
(3 * pg_transport.num_workers) + 9
```
Questo valore è necessario sulla destinazione per gestire vari processi di lavoro in background coinvolti nel trasporto. Per ulteriori informazioni su `max_worker_processes,`, consulta [Consumo di risorse](https://www.postgresql.org/docs/current/runtime-config-resource.html) nella documentazione di PostgreSQL.
Per ulteriori informazioni sui parametri `pg_transport`, consulta [Riferimento per i parametri di Transportable Database](PostgreSQL.TransportableDB.Parameters.md).
1. Riavvia l'istanza database RDS for PostgreSQL e l'istanza di destinazione in modo che le impostazioni per i parametri abbiano effetto.
1. Connettiti all'istanza database RDS for PostgreSQL di origine.
```
psql --host=source-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Rimuovi le estensioni estranee dallo schema pubblico dell'istanza database. Solo l’estensione `pg_transport` è consentita durante l'effettiva operazione di trasporto.
1. Installa l’estensione `pg_transport` come segue:
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
1. Connettiti all'istanza database RDS for PostgreSQL di destinazione. Rimuovi eventuali estensioni estranee, quindi installa l’estensione `pg_transport`.
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
# Trasporto di un database PostgreSQL alla destinazione dall'origine
Dopo aver completato il processo descritto in [Configurazione del trasporto di un database PostgreSQL](PostgreSQL.TransportableDB.Setup.md), puoi avviare il trasporto. A questo scopo, esegui la funzione `transport.import_from_server` nell'istanza database di destinazione. Nella sintassi seguente puoi trovare i parametri della funzione.
```
SELECT transport.import_from_server(
'source-db-instance-endpoint',
source-db-instance-port,
'source-db-instance-user',
'source-user-password',
'source-database-name',
'destination-user-password',
false);
```
Il valore `false` mostrato nell'esempio indica alla funzione che non si tratta di un test. Per testare la configurazione di trasporto, è possibile specificare `true` per l’opzione `dry_run` quando chiami la funzione, come illustrato di seguito:
```
postgres=> SELECT transport.import_from_server(
'docs-lab-source-db.666666666666aws-region.rds.amazonaws.com', 5432,
'postgres', '********', 'labdb', '******', true);
INFO: Starting dry-run of import of database "labdb".
INFO: Created connections to remote database (took 0.03 seconds).
INFO: Checked remote cluster compatibility (took 0.05 seconds).
INFO: Dry-run complete (took 0.08 seconds total).
import_from_server
--------------------
(1 row)
```
Le linee INFO sono di output perché il parametro `pg_transport.timing` è impostato sul valore predefinito, `true`. Imposta la proprietà `dry_run` su `false` quando esegui il comando e il database di origine viene importato nella destinazione, come illustrato di seguito:
```
INFO: Starting import of database "labdb".
INFO: Created connections to remote database (took 0.02 seconds).
INFO: Marked remote database as read only (took 0.13 seconds).
INFO: Checked remote cluster compatibility (took 0.03 seconds).
INFO: Signaled creation of PITR blackout window (took 2.01 seconds).
INFO: Applied remote database schema pre-data (took 0.50 seconds).
INFO: Created connections to local cluster (took 0.01 seconds).
INFO: Locked down destination database (took 0.00 seconds).
INFO: Completed transfer of database files (took 0.24 seconds).
INFO: Completed clean up (took 1.02 seconds).
INFO: Physical transport complete (took 3.97 seconds total).
import_from_server
--------------------
(1 row)
```
Questa funzione richiede l'inserimento di password per l'utente del database. Quindi, ti consigliamo di modificare le password dei ruoli utente utilizzati dopo aver completato il trasporto. In alternativa, puoi utilizzare le variabili di associazione SQL per creare ruoli utente temporanei. Utilizza questi ruoli temporanei per il trasporto, quindi eliminali al termine.
Se il trasporto non ha esito positivo, potrebbe essere visualizzato un messaggio di errore simile al seguente:
```
pg_transport.num_workers=8 25% of files transported failed to download file data
```
Il messaggio di errore "Impossibile scaricare dati file" indica che il numero di processi di lavoro non è impostato correttamente per le dimensioni del database. Potrebbe essere necessario aumentare o diminuire il valore impostato per `pg_transport.num_workers`. Ogni errore segnala la percentuale di completamento, in modo da poter vedere l'impatto delle modifiche. Ad esempio, la modifica dell'impostazione da 8 a 4 in un caso ha comportato quanto segue:
```
pg_transport.num_workers=4 75% of files transported failed to download file data
```
Ricorda che il parametro `max_worker_processes` viene preso in considerazione anche durante il processo di trasporto. In altre parole, potrebbe essere necessario modificare sia `pg_transport.num_workers` che `max_worker_processes` per trasportare correttamente il database. L'esempio mostrato ha finalmente funzionato quando `pg_transport.num_workers` è stato impostato su 2:
```
pg_transport.num_workers=2 100% of files transported
```
Per ulteriori informazioni sulla funzione `transport.import_from_server` e sui relativi parametri, consulta [Riferimento per la funzione Transportable Database](PostgreSQL.TransportableDB.transport.import_from_server.md).
# Riferimento per la funzione Transportable Database
La funzione `transport.import_from_server` trasporta un database PostgreSQL importandolo da un'istanza database di origine a un'istanza database di destinazione. Per farlo, utilizza un meccanismo di trasporto con connessione al database fisico.
Prima di iniziare il trasporto, questa funzione verifica che le istanze database di origine e di destinazione siano della stessa versione e siano compatibili per la migrazione. Conferma inoltre che l'istanza database di destinazione abbia spazio sufficiente per l'origine.
**Sintassi**
```
transport.import_from_server(
host text,
port int,
username text,
password text,
database text,
local_password text,
dry_run bool
)
```
**Valore restituito**
Nessuna.
**Parametri**
Le descrizioni dei parametri della funzione `transport.import_from_server` sono disponibili nella tabella seguente.
****
| Parametro | Descrizione |
| --- | --- |
| host | L'endpoint dell'istanza database di origine. |
| port | Un numero intero che rappresenta la porta dell'istanza database di origine. Le istanze database di PostgreSQL spesso utilizzano la porta 5432. |
| username | L'utente dell'istanza database di origine. Questo utente deve essere membro del ruolo `rds_superuser`. |
| password | La password utente dell'istanza database di origine. |
| database | Il nome del database nell'istanza database di origine da trasportare. |
| local\$1password | La password locale dell'utente corrente per l'istanza database di destinazione. Questo utente deve essere membro del ruolo `rds_superuser`. |
| dry\$1run | Un valore booleano facoltativo che specifica se eseguire un test. L'impostazione predefinita è `false`, che indica che il trasporto procede.Per confermare la compatibilità tra le istanze database di origine e di destinazione senza eseguire effettivamente il trasporto, imposta dry\$1run su true. |
**Esempio**
Per un esempio, consulta [Trasporto di un database PostgreSQL alla destinazione dall'origine](PostgreSQL.TransportableDB.Transporting.md).
# Riferimento per i parametri di Transportable Database
Diversi parametri controllano il comportamento dell'estensione `pg_transport`. Di seguito, sono disponibili le descrizioni di questi parametri.
**`pg_transport.num_workers`**
Il numero di dipendenti da utilizzare per il processo di trasporto. L'impostazione predefinita è 3. I valori validi sono 1–32. Anche i trasporti di database più grandi in genere richiedono un numero di dipendenti inferiore a 8. Il valore di questa impostazione sull'istanza database di destinazione viene utilizzato sia dall’origine che dalla destinazione durante il trasporto.
**`pg_transport.timing` **
Specifica se riportare le informazioni temporali durante il trasporto. Il valore predefinito è `true`, il che significa che le informazioni temporali vengono riportate. Consigliamo di lasciare questo parametro impostato su `true` in modo da poter monitorare i progressi. Per output di esempio, vedi [Trasporto di un database PostgreSQL alla destinazione dall'origine](PostgreSQL.TransportableDB.Transporting.md).
**`pg_transport.work_mem`**
La quantità massima di memoria da allocare per ogni processo di lavoro. Il valore predefinito è 131072 kilobyte (KB) o 262144 KB (256 MB), a seconda della versione di PostgreSQL. Il valore minimo è 64 megabyte (65536 KB). I valori validi sono espressi in kilobyte (KBs) come unità binarie in base 2, dove 1 KB = 1024 byte.
Il trasporto potrebbe utilizzare meno memoria rispetto a quella specificata in questo parametro. Anche i trasporti di database di dimensioni maggiori in genere richiedono meno di 256 MB (262144 KB) di memoria per dipendente.