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à.
# Integrazione di Amazon Aurora PostgreSQL con altri servizi AWS
Amazon Aurora si integra con altri AWS servizi in modo da poter estendere il cluster Aurora PostgreSQL DB per utilizzare funzionalità aggiuntive nel cloud. AWS Il cluster Aurora PostgreSQL DB può utilizzare i servizi per eseguire le seguenti operazioni: AWS
+ Raccolta, visualizzazione e valutazione delle prestazioni in modo rapido per le istanze database Aurora PostgreSQL con Performance Insights di Amazon RDS. Performance Insights si espande sulle caratteristiche di monitoraggio esistenti Amazon RDS per illustrare le prestazioni del database e aiutare ad analizzare eventuali problemi che lo riguardano. Con il pannello di controllo di Performance Insights, è possibile visualizzare il carico del database e filtrare il carico in base alle attese, alle istruzioni SQL, agli host o agli utenti. Per ulteriori informazioni su Performance Insights, consulta [Monitoraggio del carico DB con Performance Insights su Amazon Aurora](USER_PerfInsights.md).
+ Configura il tuo cluster Aurora PostgreSQL DB per pubblicare i dati di log su Amazon Logs. CloudWatch CloudWatch I log forniscono uno storage estremamente durevole per i tuoi record di log. Con CloudWatch Logs, è possibile eseguire analisi in tempo reale dei dati di registro e utilizzarli CloudWatch per creare allarmi e visualizzare metriche. Per ulteriori informazioni, consulta [Pubblicazione di log Aurora PostgreSQL in Amazon CloudWatch Logs](AuroraPostgreSQL.CloudWatch.md).
+ Importa dati da un bucket Amazon S3 in un cluster DB Aurora PostgreSQL oppure esporta dati da un cluster DB Aurora PostgreSQL in un bucket Amazon S3. Per ulteriori informazioni, consultare [Importazione di dati da Amazon S3 in un cluster database Aurora PostgreSQL](USER_PostgreSQL.S3Import.md) e [Esportazione di dati da del cluster di database Aurora PostgreSQLRDS per PostgreSQL a Amazon S3](postgresql-s3-export.md).
+ Aggiungere previsioni basate sul machine learning alle applicazioni di database utilizzando il linguaggio SQL. L'apprendimento automatico Aurora utilizza un'integrazione altamente ottimizzata tra il database Aurora e i servizi di AWS machine learning (ML) AI e SageMaker Amazon Comprehend. Per ulteriori informazioni, consulta [Utilizzo del machine learning di Amazon Aurora con Aurora PostgreSQL](postgresql-ml.md).
+ Richiama AWS Lambda funzioni da un cluster Aurora PostgreSQL DB. Per fare ciò, utilizzare l'estensione PostgreSQL `aws_lambda` fornita con Aurora PostgreSQL. Per ulteriori informazioni, consulta [](PostgreSQL-Lambda.md).
+ Integra le query di Amazon Redshift e Aurora PostgreSQL. Per ulteriori informazioni, consulta [Nozioni di base sull'utilizzo di query federate su PostgreSQL](https://docs.aws.amazon.com/redshift/latest/dg/getting-started-federated.html) nella *Guida per gli sviluppatori Amazon Redshift Database*.
# Importazione di dati da Amazon S3 in un cluster database Aurora PostgreSQL
Puoi importare i dati che sono stati archiviati utilizzando Servizio di archiviazione semplice Amazon in una tabella su un'istanza cluster database Aurora PostgreSQL. A questo scopo, installa innanzitutto l'estensione Aurora 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 , il database deve eseguire PostgreSQL versione 10.7 o successive. Aurora PostgreSQL.
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*.
**Nota**
L'importazione di dati da Amazon S3 non è supportata per Aurora Serverless v1. È supportata per Aurora Serverless v2.
**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)
+ [](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 il cluster database Aurora 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 di un cluster database Aurora PostgreSQL in un bucket Amazon S3. Per ulteriori informazioni, consulta [Esportazione di dati da del cluster di database Aurora PostgreSQLRDS 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 di scrittura del cluster database Aurora 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 Aurora PostgreSQL**
Raccogli innanzitutto i dettagli che devi fornire alla funzione. Questi includono il nome della tabella sull'istanza del cluster Aurora PostgreSQL DB, l'istanza DB RDS per PostgreSQL e il nome del bucket, il 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/AuroraUserGuide/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 sul cluster database Aurora 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 [](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 cluster database Aurora PostgreSQL a 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 al cluster di database Aurora 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 al cluster .
**Nota**
Non è possibile associare un ruolo IAM a un cluster di database Aurora Serverless v1, quindi i seguenti passaggi non sono attinenti.
**Per consentire a un cluster di database Aurora 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 al cluster di database Aurora 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 Aurora PostgreSQL:
+ `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 Aurora 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, Aurora PostgreSQL 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:cluster:clustername"
}
}
}
]
}'
```
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:cluster:clustername"
}
}
}
]
}'
```
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 al cluster.
A tale scopo, utilizzare Console di gestione AWS o AWS CLI, come descritto di seguito.
### Console
**Per aggiungere un ruolo IAM al cluster di 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 del cluster di 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 istanza del **.
1. In **Feature (Caratteristica)**, scegliere **s3Import**.
1. Scegliere **Add role (Aggiungi ruolo)**.
### AWS CLI
**Per aggiungere un ruolo IAM a un cluster di database PostgreSQL tramite CLI**
+ Utilizzare il seguente comando per aggiungere il ruolo al cluster di database PostgreSQL denominato `my-db-cluster`. 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-cluster \
--db-cluster-identifier my-db-cluster \
--feature-name s3Import \
--role-arn your-role-arn \
--region your-region
```
Per Windows:
```
aws rds add-role-to-db-cluster ^
--db-cluster-identifier my-db-cluster ^
--feature-name s3Import ^
--role-arn your-role-arn ^
--region your-region
```
### API RDS
Per aggiungere un ruolo IAM per un' del cluster DB PostgreSQL utilizzando l'API Amazon RDS, chiama l'operazione. [AddRoleToDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AddRoleToDBCluster.html)
## 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 Aurora](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*.
#
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 nel cluster di 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 nel cluster di database Aurora 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 Aurora PostgreSQL. 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 il cluster di 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 e zone di disponibilità](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 e zone di disponibilità](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 e zone di disponibilità](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.
# Esportazione di dati da del cluster di database Aurora PostgreSQLRDS per PostgreSQL a Amazon S3
È possibile eseguire query sui dati da del cluster di database Aurora PostgreSQLRDS per PostgreSQL ed esportarli direttamente in file memorizzati in un bucket Amazon S3. A questo scopo, installa innanzitutto l'estensione Aurora PostgreSQL `aws_s3`. Questa estensione fornisce le funzioni utilizzate per esportare i risultati delle quey in Amazon S3. Di seguito, sono disponibili informazioni su come installare l'estensione ed esportare i dati in Amazon S3.
Puoi esportare da un'istanza database con provisioning o Aurora Serverless v2. Questi passaggi non sono supportati per Aurora Serverless v1.
**Nota**
L'esportazione tra account in Amazon S3 non è supportata.
Tutte le versioni attualmente disponibili di Aurora PostgreSQL supportano l'esportazione dei dati in Servizio di archiviazione semplice Amazon. Per informazioni dettagliate sulla versione, consulta gli [aggiornamenti di Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) nelle *Note di rilascio di Aurora PostgreSQL*.
Se non disponi di un bucket configurato per l'esportazione, consulta i seguenti argomenti nella *Guida per l'utente di Servizio di archiviazione semplice Amazon*.
+ [Configurazione di Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/setting-up-s3.html)
+ [Creare un secchio](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)
Per impostazione predefinita, i dati esportati da Aurora PostgreSQL ad Amazon S3 utilizzano la crittografia lato server con. Chiave gestita da AWS In alternativa, è possibile utilizzare la chiave gestita dal cliente che è già stata creata. Se utilizzi la crittografia a bucket, il bucket Amazon S3 deve essere crittografato AWS Key Management Service con la chiave AWS KMS() (SSE-KMS). Attualmente, i bucket crittografati con chiavi gestite da Amazon S3 (SSE-S3) non sono supportati.
**Nota**
Puoi salvare i dati degli snapshot del database e del cluster DB su Amazon S3 utilizzando AWS CLI, o Console di gestione AWS l'API Amazon RDS. Per ulteriori informazioni, consulta [Esportazione dei dati dello snapshot del cluster di database in Amazon S3](aurora-export-snapshot.md).
**Topics**
+ [Installazione dell'estensione aws\$1s3](#USER_PostgreSQL.S3Export.InstallExtension)
+ [Panoramica dell'esportazione di dati in Amazon S3](#postgresql-s3-export-overview)
+ [Specifica del percorso del file Amazon S3 in cui eseguire l'esportazione](#postgresql-s3-export-file)
+ [Configurazione dell'accesso a un bucket Amazon S3](postgresql-s3-export-access-bucket.md)
+ [Esportazione dei dati della query utilizzando la funzione aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md)
+ [Informazioni di riferimento sulle funzioni](postgresql-s3-export-functions.md)
+ [Risoluzione dei problemi di accesso a Amazon S3](postgresql-s3-export-troubleshoot.md)
## Installazione dell'estensione aws\$1s3
Prima di poter utilizzare Servizio di archiviazione semplice Amazon con il cluster database Aurora PostgreSQL, è necessario installare l'estensione `aws_s3`. Questa estensione fornisce funzioni per l'esportazione di dati dall'istanza di scrittura di un cluster database Aurora PostgreSQL in un bucket Amazon S3. Fornisce inoltre funzioni per l'importazione dei dati da Amazon S3. Per ulteriori informazioni, consulta [Importazione di dati da Amazon S3 in un cluster database Aurora PostgreSQL](USER_PostgreSQL.S3Import.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 di scrittura del cluster database Aurora 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.
### Verifica che la tua versione supporti le esportazioni verso Amazon S3
Per verificare che la versione di Aurora PostgreSQL supporti l'esportazione in Amazon S3, puoi utilizzare il comando `describe-db-engine-versions`. L'esempio seguente verifica se la versione 10.14 può eseguire l'esportazione in Amazon S3.
```
aws rds describe-db-engine-versions --region us-east-1 \
--engine aurora-postgresql --engine-version 10.14 | grep s3Export
```
Se l'output include la stringa `"s3Export"`, allora il motore supporta le esportazioni Amazon S3. In caso contrario, il motore non le supporta.
## Panoramica dell'esportazione di dati in Amazon S3
Per esportare i dati archiviati in un database Aurora PostgreSQL verso un bucket Amazon S3, attenersi alla procedura descritta di seguito.
**Per esportare i dati Aurora PostgreSQL in S3.**
1. Identifica un percorso del file Amazon S3 da utilizzare per l'esportazione dei dati. Per informazioni dettagliate su questo processo, consulta [Specifica del percorso del file Amazon S3 in cui eseguire l'esportazione](#postgresql-s3-export-file).
1. Fornisci l'autorizzazione ad accedere al bucket Amazon S3.
Per esportare i dati in un file Amazon S3, concedi al cluster di database Aurora PostgreSQL l'autorizzazione per accedere al bucket Amazon S3 che verrà utilizzato dall'esportazione per lo storage. Questa operazione include le seguenti fasi:
1. Crea una policy IAM che fornisce l'accesso a un bucket Amazon S3 in cui desideri eseguire l'esportazione.
1. Creare un ruolo IAM.
1. Collega la policy creata al ruolo creato.
1. Aggiungi questo ruolo IAM al cluster di database .
Per informazioni dettagliate su questo processo, consulta [Configurazione dell'accesso a un bucket Amazon S3](postgresql-s3-export-access-bucket.md).
1. Identifica una query del database per ottenere i dati. Esporta i dati della query chiamando la funzione `aws_s3.query_export_to_s3`.
Dopo aver completato le attività di preparazione precedenti, utilizza la funzione [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) per esportare i risultati della query in Amazon S3. Per informazioni dettagliate su questo processo, consulta [Esportazione dei dati della query utilizzando la funzione aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
## Specifica del percorso del file Amazon S3 in cui eseguire l'esportazione
Specifica le seguenti informazioni per identificare la posizione in Amazon S3 in cui desideri esportare i dati:
+ Nome del bucket – Un *bucket* è un container di oggetti o file Amazon S3.
Per ulteriori informazioni sull’archiviazione dei dati con Amazon S3, consulta [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) e [Utilizzo degli oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-downloading-objects.html) nella *Guida per l’utente di Amazon Simple Storage Service*.
+ Percorso del file – Il percorso del file identifica la posizione di archiviazione dell'esportazione nel bucket Amazon S3. Il percorso del file comprende:
+ Un prefisso del percorso facoltativo che identifica un percorso di cartella virtuale.
+ Un prefisso del file che identifica uno o più file da archiviare. Esportazioni di dimensioni maggiori vengono archiviate in più file, ciascuno con una dimensione massima di circa 6 GB. I nomi di file aggiuntivi hanno lo stesso prefisso di file ma con l'aggiunta di `_partXX`. `XX` rappresenta 2, poi 3 e così via.
Ad esempio, un percorso del file con una cartella `exports` e un prefisso del file `query-1-export` è `/exports/query-1-export`.
+ AWS Regione (opzionale): la AWS regione in cui si trova il bucket Amazon S3.
**Nota**
Per un elenco dei nomi delle AWS regioni e dei valori associati, vedere[ Regioni e zone di disponibilità](Concepts.RegionsAndAvailabilityZones.md).
Per conservare le informazioni sul file Amazon S3 relative alla posizione di archiviazione dell'esportazione, puoi utilizzare la funzione [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) per creare una struttura composita `aws_commons._s3_uri_1` come descritto di seguito.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
In seguito fornisci questo valore `s3_uri_1` come un parametro nella chiamata alla funzione [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Per alcuni esempi, consulta [Esportazione dei dati della query utilizzando la funzione aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
# Configurazione dell'accesso a un bucket Amazon S3
Per esportare i dati in Amazon S3, concedi all' del cluster di database PostgreSQL l'autorizzazione per accedere al bucket Amazon S3 di destinazione dei file.
A tale scopo, procedi come indicato di seguito.
**Per concedere a un cluster di database PostgreSQL l'accesso ad Amazon S3 tramite un ruolo IAM**
1. Creare una policy IAM
Questa policy fornisce le autorizzazioni bucket e di oggetto che consentono all’ del cluster di database PostgreSQL di accedere a Amazon S3.
Come parte della creazione di questa policy, attenersi alla seguente procedura:
1. Includere nella policy le seguenti operazioni obbligatorie per consentire il trasferimento dei file dall’ del cluster del database PostgreSQL a un bucket Amazon S3:
+ `s3:PutObject`
+ `s3:AbortMultipartUpload`
1. Includere l'Amazon Resource Name (ARN) che identifica il bucket Amazon S3 e gli oggetti nel bucket. Il formato ARN per l'accesso a Amazon S3 è: `arn:aws:s3:::amzn-s3-demo-bucket/*`
Per ulteriori informazioni sulla creazione di una policy IAM per Aurora 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 `rds-s3-export-policy` con queste opzioni. Concede l'accesso a un bucket denominato *amzn-s3-demo-bucket*.
**avvertimento**
Si consiglia di impostare il database all'interno di un VPC privato con policy di endpoint configurate per accedere a bucket specifici. Per ulteriori informazioni, consulta [Utilizzo delle policy dell'endpoint per Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html#vpc-endpoints-policies-s3) nella Guida per l'utente di Amazon VPC.
Si consiglia di non creare una policy con accesso a tutte le risorse. Questo accesso può rappresentare una minaccia per la sicurezza dei dati. Se si crea una policy che consente a `S3:PutObject` di accedere a tutte le risorse utilizzando `"Resource":"*"`, un utente con privilegi di esportazione può esportare i dati in tutti i bucket dell'account. Inoltre, l'utente può esportare i dati in *qualsiasi bucket pubblicamente scrivibile all'interno della regione AWS *.
Dopo aver creato la policy, annotarne l'Amazon Resource Name (ARN). Per la fase successiva, in cui si associa la policy a un ruolo IAM, è necessario l'ARN.
```
aws iam create-policy --policy-name rds-s3-export-policy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3export",
"Action": [
"s3:PutObject*",
"s3:ListBucket",
"s3:GetObject*",
"s3:DeleteObject*",
"s3:GetBucketLocation",
"s3:AbortMultipartUpload"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
1. Creare un ruolo IAM.
In questo modo, Aurora PostgreSQL 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-export-role`.
**Example**
Per Linux, macOS o Unix:
```
aws iam create-role \
--role-name rds-s3-export-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:cluster:dbname"
}
}
}
]
}'
```
Per Windows:
```
aws iam create-role ^
--role-name rds-s3-export-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:cluster:dbname"
}
}
}
]
}'
```
1. Collegare la policy IAM al ruolo IAM creato.
Il AWS CLI comando seguente associa la policy creata in precedenza al ruolo denominato `rds-s3-export-role.` Replace `your-policy-arn` con l'ARN della policy annotato in un passaggio precedente.
```
aws iam attach-role-policy --policy-arn your-policy-arn --role-name rds-s3-export-role
```
1. Aggiungere il ruolo IAM al cluster. A tale scopo, utilizzare Console di gestione AWS o AWS CLI, come descritto di seguito.
## Console
**Per aggiungere un ruolo IAM al cluster di 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 del cluster di database PostgreSQL per visualizzarne i dettagli.
1. Nella scheda **Connectivity & security (Connettività e sicurezza)**, nella sezione **Manage IAM roles (Gestisci ruoli IAM)**, selezionare il ruolo da aggiungere sotto **Add IAM roles to this instance (Aggiungi ruoli IAM a questa istanza)**.
1. In **Feature (Caratteristica)**, scegliere **s3Export**.
1. Scegliere **Add role (Aggiungi ruolo)**.
## AWS CLI
**Per aggiungere un ruolo IAM a un cluster di database PostgreSQL tramite CLI**
+ Utilizzare il seguente comando per aggiungere il ruolo al cluster di database PostgreSQL denominato `my-db-cluster`. Sostituire *`your-role-arn`* con l'ARN del ruolo annotato in precedenza. Utilizzare `s3Export` come valore dell’opzione `--feature-name`.
**Example**
Per Linux, macOS o Unix:
```
aws rds add-role-to-db-cluster \
--db-cluster-identifier my-db-cluster \
--feature-name s3Export \
--role-arn your-role-arn \
--region your-region
```
Per Windows:
```
aws rds add-role-to-db-cluster ^
--db-cluster-identifier my-db-cluster ^
--feature-name s3Export ^
--role-arn your-role-arn ^
--region your-region
```
# Esportazione dei dati della query utilizzando la funzione aws\$1s3.query\$1export\$1to\$1s3
Esporta i dati PostgreSQL in Amazon S3 chiamando la funzione [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
**Topics**
+ [Prerequisiti](#postgresql-s3-export-examples-prerequisites)
+ [Chiamare aws\$1s3.query\$1export\$1to\$1s3](#postgresql-s3-export-examples-basic)
+ [Esportazione in un file CSV che utilizza un delimitatore personalizzato](#postgresql-s3-export-examples-custom-delimiter)
+ [Esportazione in un file binario con codifica](#postgresql-s3-export-examples-encoded)
## Prerequisiti
Prima di utilizzare la funzione `aws_s3.query_export_to_s3`, assicurati di completare i seguenti prerequisiti:
+ Installa le estensioni PostgreSQL richieste come descritto in [Panoramica dell'esportazione di dati in Amazon S3](postgresql-s3-export.md#postgresql-s3-export-overview).
+ Determina dove esportare i dati in Amazon S3 come descritto in [Specifica del percorso del file Amazon S3 in cui eseguire l'esportazione](postgresql-s3-export.md#postgresql-s3-export-file).
+ Assicurati che il cluster di database abbia accesso di esportazione a Amazon S3 come descritto in [Configurazione dell'accesso a un bucket Amazon S3](postgresql-s3-export-access-bucket.md).
Gli esempi seguenti utilizzano una tabella del database denominata `sample_table`. Questi esempi esportano i dati in un bucket denominato *amzn-s3-demo-bucket*. La tabella e i dati di esempio vengono creati con le seguenti istruzioni SQL in psql.
```
psql=> CREATE TABLE sample_table (bid bigint PRIMARY KEY, name varchar(80));
psql=> INSERT INTO sample_table (bid,name) VALUES (1, 'Monday'), (2,'Tuesday'), (3, 'Wednesday');
```
## Chiamare aws\$1s3.query\$1export\$1to\$1s3
Di seguito vengono illustrati le modalità di base per chiamare la funzione [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
In questi esempi viene utilizzata la variabile `s3_uri_1` per identificare una struttura contenente le informazioni che identificano il file Amazon S3. Utilizzare la funzione [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) per creare la struttura.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Anche se i parametri variano per le due chiamate di funzione `aws_s3.query_export_to_s3` seguenti, i risultati sono gli stessi per questi esempi. Tutte le righe della tabella `sample_table` vengono esportate in un bucket denominato *amzn-s3-demo-bucket*.
```
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1');
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1', options :='format text');
```
I parametri sono descritti come segue:
+ `'SELECT * FROM sample_table'` – Il primo parametro è una stringa di testo obbligatoria contenente una query SQL. Il motore PostgreSQL esegue questa query. I risultati della query vengono copiati nel bucket S3 identificato in altri parametri.
+ `:'s3_uri_1'` – Questo parametro è una struttura che identifica il file Amazon S3. In questo esempio viene utilizzata una variabile per identificare la struttura creata in precedenza. È invece possibile creare la struttura includendo la chiamata di funzione `aws_commons.create_s3_uri` in linea all'interno della chiamata di funzione `aws_s3.query_export_to_s3` come segue.
```
SELECT * from aws_s3.query_export_to_s3('select * from sample_table',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'sample-filepath', 'us-west-2')
);
```
+ `options :='format text'` – Il parametro `options` è una stringa di testo opzionale contenente argomenti `COPY` 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).
Se il file specificato non esiste nel bucket Amazon S3, viene creato. Se il file esiste già, viene sovrascritto. La sintassi per accedere ai dati esportati Amazon S3 è la seguente.
```
s3-region://bucket-name[/path-prefix]/file-prefix
```
Esportazioni di dimensioni maggiori vengono archiviate in più file, ciascuno con una dimensione massima di circa 6 GB. I nomi di file aggiuntivi hanno lo stesso prefisso di file ma con l'aggiunta di `_partXX`. `XX` rappresenta 2, poi 3 e così via. Ad esempio, supponi di specificare il percorso in cui archivi i file di dati come segue.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
```
Se l'esportazione deve creare tre file di dati, il bucket Amazon S3 contiene i seguenti file di dati.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part2
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part3
```
Per il riferimento completo per questa funzione e altri modi per chiamarla, consulta [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Per ulteriori informazioni sull'accesso ai file in Amazon S3, consulta [Visualizzazione di un oggetto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
## Esportazione in un file CSV che utilizza un delimitatore personalizzato
Nell'esempio seguente viene illustrato come chiamare la funzione [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) per esportare i dati in un file che utilizza un delimitatore personalizzato. Nell'esempio vengono utilizzati gli argomenti del comando [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html) per specificare il formato CSV (valori delimitati da virgole) e un delimitatore : (due punti).
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format csv, delimiter $$:$$');
```
## Esportazione in un file binario con codifica
Nell'esempio seguente viene illustrato come chiamare la funzione [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) per esportare i dati in un file binario con codifica Windows-1253.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format binary, encoding WIN1253');
```
# Informazioni di riferimento sulle funzioni
**Topics**
+ [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3)
+ [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri)
## aws\$1s3.query\$1export\$1to\$1s3
Esporta un risultato della query PostgreSQL in un bucket Amazon S3. L'estensione `aws_s3` fornisce la funzione `aws_s3.query_export_to_s3`.
I due parametri richiesti sono `query` e `s3_info`. Questi definiscono la query da esportare e identificano il bucket Amazon S3 in cui eseguire l’esportazione. Un parametro opzionale chiamato `options` fornisce la definizione di vari parametri di esportazione. Per esempi di utilizzo della funzione `aws_s3.query_export_to_s3`, consulta [Esportazione dei dati della query utilizzando la funzione aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
**Sintassi**
```
aws_s3.query_export_to_s3(
query text,
s3_info aws_commons._s3_uri_1,
options text,
kms_key text
)
```Parametri di input
*query*
Una stringa di testo obbligatoria contenente una query SQL eseguita dal motore PostgreSQL. I risultati di questa query vengono copiati in un bucket S3 identificato nel parametro `s3_info`.
*s3\$1info*
Un tipo composito `aws_commons._s3_uri_1` contenente le seguenti informazioni sull'oggetto S3:
+ `bucket` – Il nome del bucket Amazon S3 per contenere il file.
+ `file_path` – Il nome e il percorso del file Amazon S3.
+ `region`— La AWS regione in cui si trova il bucket. Per un elenco dei nomi delle AWS regioni e dei valori associati, vedere[ Regioni e zone di disponibilità](Concepts.RegionsAndAvailabilityZones.md).
Attualmente, questo valore deve essere la stessa AWS regione dell' che esporta. L'impostazione predefinita è la AWS regione dell'istanza DB del cluster che esporta.
Per creare una struttura composita `aws_commons._s3_uri_1`, consulta la funzione [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri).
*options*
Una stringa di testo opzionale contenente gli argomenti del comando `COPY` di PostgreSQL. Questi argomenti specificano come i dati devono essere copiati quando vengono esportati. Per maggiori dettagli, consulta la [documentazione di COPY PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*testo kms\$1key*
Una stringa di testo opzionale contenente la chiave KMS gestita dal cliente del bucket S3 in cui esportare i dati.
### Parametri di input alternativi
Per facilitare il testing, puoi utilizzare un set esteso di parametri al posto del parametro `s3_info`. Di seguito vengono riportate le variazioni di sintassi aggiuntive per la funzione `aws_s3.query_export_to_s3`.
Invece di utilizzare il parametro `s3_info` per identificare un file Amazon S3, utilizzare la combinazione dei parametri `bucket`, `file_path` e `region`.
```
aws_s3.query_export_to_s3(
query text,
bucket text,
file_path text,
region text,
options text,
kms_key text
)
```
*query*
Una stringa di testo obbligatoria contenente una query SQL eseguita dal motore PostgreSQL. I risultati di questa query vengono copiati in un bucket S3 identificato nel parametro `s3_info`.
*bucket*
Una stringa di testo obbligatoria contenente il nome del bucket Amazon S3 che contiene il file
*file\$1path*
Una stringa di testo obbligatoria contenente il nome file di Amazon S3, incluso il percorso.
*Regione*
Una stringa di testo opzionale contenente la AWS regione in cui si trova il bucket. Per un elenco dei nomi delle AWS regioni e dei valori associati, vedere[ Regioni e zone di disponibilità](Concepts.RegionsAndAvailabilityZones.md).
Attualmente, questo valore deve essere la stessa AWS regione dell' che esporta. L'impostazione predefinita è la AWS regione dell'istanza DB del cluster che esporta.
*options*
Una stringa di testo opzionale contenente gli argomenti del comando `COPY` di PostgreSQL. Questi argomenti specificano come i dati devono essere copiati quando vengono esportati. Per maggiori dettagli, consulta la [documentazione di COPY PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*testo kms\$1key*
Una stringa di testo opzionale contenente la chiave KMS gestita dal cliente del bucket S3 in cui esportare i dati.
### Parametri di output
```
aws_s3.query_export_to_s3(
OUT rows_uploaded bigint,
OUT files_uploaded bigint,
OUT bytes_uploaded bigint
)
```
*rows\$1uploaded*
Il numero di righe della tabella che sono state caricate correttamente in Amazon S3 per la query specificata.
*files\$1uploaded*
Il numero di file caricati in Amazon S3. I file vengono creati in dimensioni di circa 6 GB. A ogni file aggiuntivo creato è stato aggiunto `_partXX` al nome. `XX` rappresenta 2, poi 3 e così via, se necessario.
*bytes\$1uploaded*
Il numero totale di byte caricati in Amazon S3.
### Esempi
```
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2','format text');
```
## aws\$1commons.create\$1s3\$1uri
Crea una struttura `aws_commons._s3_uri_1` per conservare le informazioni relative al file Amazon S3. I risultati della funzione `aws_commons.create_s3_uri` vengono utilizzati nel parametro `s3_info` della funzione [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3). Per un esempio di utilizzo della funzione `aws_commons.create_s3_uri`, consulta [Specifica del percorso del file Amazon S3 in cui eseguire l'esportazione](postgresql-s3-export.md#postgresql-s3-export-file).
**Sintassi**
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```Parametri di input
*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 contenente la AWS regione in cui si trova il file. Per un elenco dei nomi delle AWS regioni e dei valori associati, vedere[ Regioni e zone di disponibilità](Concepts.RegionsAndAvailabilityZones.md).
# Risoluzione dei problemi di accesso a Amazon S3
Se si verificano problemi di connessione durante il tentativo di esportare i dati in Amazon S3, conferma innanzi tutto che le regole di accesso in uscita per il gruppo di sicurezza VPC associato all'istanza DB consentano la connettività di rete. In particolare, il gruppo di sicurezza deve disporre di una regola che consenta all'istanza database di inviare traffico TCP alla porta 443 e a qualsiasi indirizzo IPv4 (0.0.0.0/0). Per ulteriori informazioni, consulta [Fornitura dell'accesso al cluster di database nel VPC creando un gruppo di sicurezza](CHAP_SettingUp_Aurora.md#CHAP_SettingUp_Aurora.SecurityGroup).
Consulta anche quanto segue per i suggerimenti:
+ [Risoluzione dei problemi di identità e accesso in Amazon Aurora](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 di IAM*.
#
AWS Lambda è un servizio di elaborazione basato sugli eventi che consente di eseguire codice senza effettuare il provisioning o la gestione di server. Ad esempio, è possibile utilizzare le funzioni Lambda per elaborare le notifiche di eventi da un database o per caricare dati da file ogni volta che un nuovo file viene caricato su Amazon S3. Per ulteriori informazioni su Lambda, vedi [Cos'è? AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) nella *Guida per gli AWS Lambda sviluppatori*.
**Nota**
Le AWS Lambda funzioni di richiamo sono supportate in Aurora PostgreSQL 11.9 e versioni successive (incluso). Aurora Serverless v2
Di seguito sono riportati i riepiloghi dei passaggi necessari.
Per ulteriori informazioni sulle funzioni Lambda, consulta [Nozioni di base su Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) e [Fondamenti di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-foundation.html) nella *Guida per gli sviluppatori di AWS Lambda *.
**Topics**
+ [Fase 1: configurare l'istanza DB del cluster Aurora PostgreSQL DB per PostgreSQL per le connessioni in uscita a AWS Lambda](#PostgreSQL-Lambda-network)
+ [AWS Lambda](#PostgreSQL-Lambda-access)
+ [](#PostgreSQL-Lambda-install-extension)
+ [Fase 4: utilizzo delle funzioni di supporto Lambda con il cluster database Aurora PostgreSQL (facoltativo)](#PostgreSQL-Lambda-specify-function)
+ [Fase 5: richiamo di una funzione Lambda dal cluster database Aurora PostgreSQL](#PostgreSQL-Lambda-invoke)
+ [Fase 6: concessione delle autorizzazioni ad altri utenti per richiamare le funzioni Lambda](#PostgreSQL-Lambda-grant-users-permissions)
+ [Esempi: Richiamo delle funzioni Lambda dal cluster di database Aurora PostgreSQL](PostgreSQL-Lambda-examples.md)
+ [Messaggi di errore della funzione Lambda](PostgreSQL-Lambda-errors.md)
+ [Riferimento alla funzione AWS Lambda e ai parametri](PostgreSQL-Lambda-functions.md)
## Fase 1: configurare l'istanza DB del cluster Aurora PostgreSQL DB per PostgreSQL per le connessioni in uscita a AWS Lambda
Le funzioni Lambda vengono sempre eseguite all'interno di un Amazon VPC di proprietà del servizio. AWS Lambda Lambda applica le regole di accesso alla rete e di sicurezza a questo VPC e mantiene e monitora il VPC automaticamente. Il cluster database Aurora PostgreSQL deve inviare traffico di rete al VPC del servizio Lambda. La modalità di configurazione dipende dal fatto che l'istanza database principale del cluster database Aurora sia pubblica o privata.
+ **Cluster database pubblico Aurora PostgreSQL RDS per PostgreSQL: l'istanza DB ** è pubblica se si trova in una sottorete pubblica sul VPC e se la proprietà "" dell' è. PubliclyAccessible `true` Per trovare il valore di questa proprietà, puoi usare il comando. [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) AWS CLI In alternativa, puoi utilizzare la Console di gestione AWS per aprire la scheda **Connectivity & security** (Connettività e sicurezza) e controllare che l’opzione **Publicly accessible** (Accessibile pubblicamente) sia impostata su **Yes** (Sì). Per verificare se l'istanza si trova nella sottorete pubblica del VPC, puoi utilizzare la Console di gestione AWS o la AWS CLI.
Per configurare l'accesso a Lambda, usi Console di gestione AWS o AWS CLI per creare una regola in uscita sul gruppo di sicurezza del tuo VPC. La regola in uscita specifica che TCP può utilizzare la porta 443 per inviare pacchetti a qualsiasi indirizzo (0.0.0.0/0). IPv4
+ Istanza **privata del cluster Aurora PostgreSQL DB RDS per PostgreSQL** si trova in una sottorete privata. PubliclyAccessible `false` Per consentire all'istanza di funzionare con Lambda, è possibile utilizzare un gateway Network Address Translation (NAT). Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html). In alternativa, puoi configurare il VPC con un endpoint VPC per Lamda. Per ulteriori informazioni, consultare [Endpoint VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) nella *Guida per l'utente di Amazon VPC*. L'endpoint risponde alle chiamate effettuate dal cluster database Aurora PostgreSQL alle funzioni Lambda.
Il tuo VPC può ora interagire con il AWS Lambda VPC a livello di rete. Configura quindi le autorizzazioni utilizzando IAM.
## AWS Lambda
Il richiamo di funzioni Lambda dal cluster database Aurora PostgreSQL richiede determinati privilegi. Per configurare i privilegi necessari, si consiglia di creare una policy IAM che consenta di richiamare le funzioni Lambda, assegnare tale policy a un ruolo e quindi applicare il ruolo al cluster database. Questo approccio fornisce al cluster database privilegi per richiamare la funzione Lambda specificata per tuo conto. La procedura seguente mostra come eseguire questa operazione in AWS CLI.
**Configurare le autorizzazioni IAM per l'utilizzo del cluster con Lambda**
1. Usa il AWS CLI comando [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) per creare una policy IAM che consenta all'istanza database Aurora PostgreSQL DB del cluster RDS per di richiamare la funzione Lambda specificata. (L'ID dichiarazione (Sid) è una descrizione facoltativa per la dichiarazione di policy e non ha alcun effetto sull'utilizzo). Questa policy fornisce al cluster database Aurora le autorizzazioni minime necessarie per richiamare la funzione Lambda specificata.
```
aws iam create-policy --policy-name rds-lambda-policy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToExampleFunction",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:aws-region:444455556666:function:my-function"
}
]
}'
```
In alternativa, puoi utilizzare la policy `AWSLambdaRole` predefinita che ti consente di richiamare una qualsiasi delle tue funzioni Lambda. Per ulteriori informazioni, consulta [Policy IAM basate sull'identità per Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-identity-based.html#access-policy-examples-aws-managed)
1. Utilizza il comando [create-role per creare un ruolo IAM che la policy può assumere in fase di esecuzione](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) AWS CLI .
```
aws iam create-role --role-name rds-lambda-role --assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
1. Applica la policy al ruolo utilizzando il [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html) AWS CLI comando.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \
--role-name rds-lambda-role --region aws-region
```
1. [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-role-to-db-cluster.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-role-to-db-cluster.html) AWS CLI Quest'ultimo passaggio consente agli utenti del cluster database di richiamare le funzioni Lambda.
```
aws rds add-role-to-db-cluster \
--db-cluster-identifier my-cluster-name \
--feature-name Lambda \
--role-arn arn:aws:iam::444455556666:role/rds-lambda-role \
--region aws-region
```
Con le configurazioni di VPC e IAM completate, puoi ora installare l'estensione `aws_lambda`. (Puoi installare l'estensione in qualsiasi momento, ma fino a quando non configuri il supporto VPC e i privilegi IAM corretti, l'estensione `aws_lambda`non aggiunge nulla alle funzionalità del cluster database Aurora PostgreSQL).
##
Questa estensione fornisce al cluster database Aurora PostgreSQL la possibilità di chiamare le funzioni Lambda da PostgreSQL.
****
Utilizza la riga di comando PostgreSQL `psql` o lo strumento pgAdmin per connetterti al cluster database Aurora PostgreSQL.
1. Connettiti al cluster database Aurora PostgreSQL come utente con privilegi `rds_superuser`. L'utente `postgres` predefinito viene visualizzato nell'esempio.
```
psql -h cluster-instance.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432
```
1. Installa l’estensione `aws_lambda`. Anche l'estensione `aws_commons` è obbligatoria. Fornisce funzioni di supporto ad `aws_lambda` e molte altre estensioni Aurora per PostgreSQL. Se non si trova già nel tuo cluster database Aurora PostgreSQL , viene installata con `aws_lambda` come mostrato di seguito.
```
CREATE EXTENSION IF NOT EXISTS aws_lambda CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
L'estensione `aws_lambda` è installata nell'istanza database principale del cluster database Aurora PostgreSQL. Ora puoi creare strutture utili per richiamare le tue funzioni Lambda.
## Fase 4: utilizzo delle funzioni di supporto Lambda con il cluster database Aurora PostgreSQL (facoltativo)
Puoi utilizzare le funzioni di supporto nell'estensione `aws_commons` per preparare entità che è possibile richiamare più facilmente da PostgreSQL. Per farlo, devi disporre delle seguenti informazioni sulle funzioni Lambda:
+ **Nome funzione**: il nome, l'Amazon Resource Name (ARN), la versione o l'alias della funzione Lambda. La policy IAM creata in [Fase 2: configurazione di IAM per il cluster e Lambda](#PostgreSQL-Lambda-access) richiede l'ARN, quindi ti consigliamo di utilizzare l'ARN della tua funzione.
+ **AWS Regione**
Per mantenere le informazioni sul nome della funzione Lambda, puoi utilizzare la funzione [aws\$1commons.create\$1lambda\$1function\$1arn](PostgreSQL-Lambda-functions.md#aws_commons.create_lambda_function_arn). Questa funzione di supporto crea una struttura composita `aws_commons._lambda_function_arn_1` con i dettagli necessari alla funzione di richiamo. Di seguito, puoi trovare tre approcci alternativi per l'impostazione di questa struttura composita.
```
SELECT aws_commons.create_lambda_function_arn(
'my-function',
'aws-region'
) AS aws_lambda_arn_1 \gset
```
```
SELECT aws_commons.create_lambda_function_arn(
'111122223333:function:my-function',
'aws-region'
) AS lambda_partial_arn_1 \gset
```
```
SELECT aws_commons.create_lambda_function_arn(
'arn:aws:lambda:aws-region:111122223333:function:my-function'
) AS lambda_arn_1 \gset
```
Ognuno di questi valori può essere utilizzato nelle chiamate alla funzione [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke). Per alcuni esempi, consulta [Fase 5: richiamo di una funzione Lambda dal cluster database Aurora PostgreSQL](#PostgreSQL-Lambda-invoke).
## Fase 5: richiamo di una funzione Lambda dal cluster database Aurora PostgreSQL
La funzione `aws_lambda.invoke` si comporta in modo sincrono o asincrono, a seconda del `invocation_type`. Le due alternative per questo parametro sono `RequestResponse` (il valore predefinito) e `Event`, come di seguito riportato.
+ **`RequestResponse`**: questo tipo di richiamo è *sincrono*. Questo è il comportamento predefinito quando viene effettuata la chiamata senza specificare un tipo di chiamata. Il payload di risposta include i risultati della funzione `aws_lambda.invoke`. Utilizza questo tipo di chiamata quando il flusso di lavoro richiede la ricezione dei risultati della funzione Lambda prima di procedere.
+ **`Event`**: questo tipo di richiamo è *asincrono*. La risposta non include un payload contenente i risultati. Utilizza questo tipo di richiamo quando il flusso di lavoro non ha bisogno di un risultato della funzione Lambda per continuare l'elaborazione.
Come semplice test della configurazione, puoi connetterti all'istanza database utilizzando `psql` e richiamare una funzione di esempio dalla riga di comando. Supponiamo di avere una delle funzioni di base impostate sul tuo servizio Lambda, come la semplice funzione Python mostrata nello screenshot di seguito.
![\[Esempio di funzione Lambda mostrata nel modulo AWS CLI AWS Lambda\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/lambda_simple_function.png)
**Per richiamare una funzione di esempio**
1. Connettiti all’istanza database principale utilizzando `psql` o pgAdmin.
```
psql -h cluster.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432
```
1. Richiama la funzione utilizzando il relativo ARN.
```
SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('arn:aws:lambda:aws-region:444455556666:function:simple', 'us-west-1'), '{"body": "Hello from Postgres!"}'::json );
```
La risposta è la seguente.
```
status_code | payload | executed_version | log_result
-------------+-------------------------------------------------------+------------------+------------
200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST |
(1 row)
```
Se il tuo tentativo di richiamo non ha esito positivo, vedi [Messaggi di errore della funzione Lambda](PostgreSQL-Lambda-errors.md).
## Fase 6: concessione delle autorizzazioni ad altri utenti per richiamare le funzioni Lambda
A questo punto della procedura, solo tu in qualità di `rds_superuser` puoi richiamare le funzioni Lambda. Per consentire ad altri utenti di richiamare le funzioni che crei, è necessario concedere loro l'autorizzazione.
**Per concedere ad altri utenti l'autorizzazione per richiamare le funzioni Lambda**
1. Connettiti all’istanza database principale utilizzando `psql` o pgAdmin.
```
psql -h cluster.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432
```
1. Esegui i seguenti comandi SQL:
```
postgres=> GRANT USAGE ON SCHEMA aws_lambda TO db_username;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA aws_lambda TO db_username;
```
# Esempi: Richiamo delle funzioni Lambda dal cluster di database Aurora PostgreSQL
Di seguito, è possibile trovare diversi esempi di chiamate alla funzione [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke). Nella maggior parte degli esempi viene utilizzata la struttura composita `aws_lambda_arn_1` creata in [Fase 4: utilizzo delle funzioni di supporto Lambda con il cluster database Aurora PostgreSQL (facoltativo)](PostgreSQL-Lambda.md#PostgreSQL-Lambda-specify-function) per semplificare il passaggio dei dettagli della funzione. Per un esempio di chiamata asincrona, consulta [Esempio: richiamo (di eventi) asincroni di funzioni Lambda](#PostgreSQL-Lambda-Event). Tutti gli altri esempi elencati utilizzano il richiamo sincrono.
Per ulteriori informazioni sui tipi di chiamata Lambda, consulta [Richiamo di funzioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html) nella *Guida per gli sviluppatori di AWS Lambda *. Per ulteriori informazioni su `aws_lambda_arn_1`, consultare [aws\$1commons.create\$1lambda\$1function\$1arn](PostgreSQL-Lambda-functions.md#aws_commons.create_lambda_function_arn).
**Topics**
+ [Esempio: invocazione sincrona (RequestResponse) di funzioni Lambda](#PostgreSQL-Lambda-RequestResponse)
+ [Esempio: richiamo (di eventi) asincroni di funzioni Lambda](#PostgreSQL-Lambda-Event)
+ [Esempio: acquisizione del registro di esecuzione Lambda in una risposta di funzione](#PostgreSQL-Lambda-log-response)
+ [Esempio: inclusione del contesto client in una funzione Lambda](#PostgreSQL-Lambda-client-context)
+ [Esempio: richiamo di una versione specifica di una funzione Lambda](#PostgreSQL-Lambda-function-version)
## Esempio: invocazione sincrona (RequestResponse) di funzioni Lambda
Di seguito sono riportati due esempi di una chiamata di funzione Lambda sincrona. I risultati di queste chiamate di funzione `aws_lambda.invoke` sono gli stessi.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json);
```
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse');
```
I parametri sono descritti come segue:
+ `:'aws_lambda_arn_1'`: questo parametro identifica la struttura composita creata in [Fase 4: utilizzo delle funzioni di supporto Lambda con il cluster database Aurora PostgreSQL (facoltativo)](PostgreSQL-Lambda.md#PostgreSQL-Lambda-specify-function) con la funzione di supporto di `aws_commons.create_lambda_function_arn`. Puoi anche creare questa struttura in linea all'interno della chiamata `aws_lambda.invoke` come segue:
```
SELECT * FROM aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'aws-region'),
'{"body": "Hello from Postgres!"}'::json
);
```
+ `'{"body": "Hello from PostgreSQL!"}'::json`: il payload JSON da passare alla funzione Lambda.
+ `'RequestResponse'`: il tipo di richiamo Lambda.
## Esempio: richiamo (di eventi) asincroni di funzioni Lambda
Di seguito è riportato un esempio di una chiamata di funzione Lambda asincrona. Il tipo di richiamo `Event` pianifica il richiamo della funzione Lambda con il payload di input specificato e restituisce immediatamente un risultato. Utilizza il tipo di chiamata `Event` in determinati flussi di lavoro che non dipendono dai risultati della funzione Lambda.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'Event');
```
## Esempio: acquisizione del registro di esecuzione Lambda in una risposta di funzione
È possibile includere gli ultimi 4 KB del registro di esecuzione nella risposta della funzione utilizzando il parametro `log_type` nella chiamata di funzione `aws_lambda.invoke`. Per impostazione predefinita, questo parametro è impostato su `None`, ma puoi specificare `Tail` per acquisire i risultati del registro di esecuzione Lambda nella risposta, come illustrato di seguito.
```
SELECT *, select convert_from(decode(log_result, 'base64'), 'utf-8') as log FROM aws_lambda.invoke(:'aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'Tail');
```
Impostare il parametro [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke) della funzione `log_type` su `Tail` per includere il log di esecuzione nella risposta. Il valore predefinito per il parametro `log_type` è `None`.
Il `log_result` che viene restituito è una stringa `base64` codificata. È possibile decodificare i contenuti utilizzando una combinazione delle funzioni PostgreSQL `decode` e `convert_from`.
Per ulteriori informazioni su `log_type`, consultare [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke).
## Esempio: inclusione del contesto client in una funzione Lambda
La funzione `aws_lambda.invoke` ha un parametro `context` che puoi utilizzare per passare le informazioni separate dal payload, come illustrato di seguito.
```
SELECT *, convert_from(decode(log_result, 'base64'), 'utf-8') as log FROM aws_lambda.invoke(:'aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'Tail');
```
Per includere il contesto client, utilizzare un oggetto JSON per il parametro [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke) della funzione `context`.
Per ulteriori informazioni sul parametro `context`, consulta la documentazione di riferimento di [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke).
## Esempio: richiamo di una versione specifica di una funzione Lambda
Puoi specificare una determinata versione di una funzione Lambda includendo il parametro `qualifier` con la chiamata `aws_lambda.invoke`. Di seguito puoi trovare un esempio in cui viene utilizzato `'custom_version'` come alias per la versione.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'None', NULL, 'custom_version');
```
Puoi inoltre fornire un qualificatore di funzione Lambda con i dettagli relativi al nome della funzione, come mostrato di seguito.
```
SELECT * FROM aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function:custom_version', 'us-west-2'),
'{"body": "Hello from Postgres!"}'::json);
```
Per ulteriori informazioni su `qualifier` e altri parametri, consulta documentazione di riferimento di [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke).
# Messaggi di errore della funzione Lambda
Nell'elenco seguente sono disponibili informazioni sui messaggi di errore, con le possibili cause e soluzioni.
+ **Problemi di configurazione del VPC**
I problemi di configurazione del VPC possono generare i seguenti messaggi di errore al momento della connessione:
```
ERROR: invoke API failed
DETAIL: AWS Lambda client returned 'Unable to connect to endpoint'.
CONTEXT: SQL function "invoke" statement 1
```
Una causa comune di questo errore è il gruppo di sicurezza VPC configurato in modo errato. Assicurati di avere una regola in uscita per TCP aperta sulla porta 443 del gruppo di sicurezza VPC in modo che il VPC possa connettersi al VPC Lambda.
+ **Mancanza delle autorizzazioni necessarie per richiamare le funzioni Lambda**
Se viene visualizzato uno dei seguenti messaggi di errore, l'utente (ruolo) che richiama la funzione non dispone delle autorizzazioni appropriate.
```
ERROR: permission denied for schema aws_lambda
```
```
ERROR: permission denied for function invoke
```
A un utente (ruolo) devono essere concesse autorizzazioni specifiche per richiamare le funzioni Lambda. Per ulteriori informazioni, consulta [Fase 6: concessione delle autorizzazioni ad altri utenti per richiamare le funzioni Lambda](PostgreSQL-Lambda.md#PostgreSQL-Lambda-grant-users-permissions).
+ **Gestione impropria degli errori nelle funzioni Lambda**
Se una funzione Lambda genera un'eccezione durante l'elaborazione della richiesta, `aws_lambda.invoke` non riesce e indica un errore PostgreSQL come quello seguente.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json);
ERROR: lambda invocation failed
DETAIL: "arn:aws:lambda:us-west-2:555555555555:function:my-function" returned error "Unhandled", details: "".
```
Assicurati di gestire gli errori nelle funzioni Lambda o nell'applicazione PostgreSQL.
# Riferimento alla funzione AWS Lambda e ai parametri
Di seguito è riportato il riferimento per le funzioni e i parametri da utilizzare per invocare Lambda con Aurora PostgreSQL .
**Topics**
+ [aws\$1lambda.invoke](#aws_lambda.invoke)
+ [aws\$1commons.create\$1lambda\$1function\$1arn](#aws_commons.create_lambda_function_arn)
+ [parametri aws\$1lambda](#aws_lambda.parameters)
## aws\$1lambda.invoke
Esegue una funzione Lambda per un cluster DB Aurora PostgreSQL .
Per ulteriori dettagli sul richiamo delle funzioni Lambda, consulta anche [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) nella *Guida per gli sviluppatori di AWS Lambda*.
**Sintassi**
------
#### [ JSON ]
```
aws_lambda.invoke(
IN function_name TEXT,
IN payload JSON,
IN region TEXT DEFAULT NULL,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSON DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSON,
OUT executed_version TEXT,
OUT log_result TEXT)
```
```
aws_lambda.invoke(
IN function_name aws_commons._lambda_function_arn_1,
IN payload JSON,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSON DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSON,
OUT executed_version TEXT,
OUT log_result TEXT)
```
------
#### [ JSONB ]
```
aws_lambda.invoke(
IN function_name TEXT,
IN payload JSONB,
IN region TEXT DEFAULT NULL,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSONB DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSONB,
OUT executed_version TEXT,
OUT log_result TEXT)
```
```
aws_lambda.invoke(
IN function_name aws_commons._lambda_function_arn_1,
IN payload JSONB,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSONB DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSONB,
OUT executed_version TEXT,
OUT log_result TEXT
)
```
------Parametri di input
**function\$1name**
Nome identificativo della funzione Lambda. Il valore può essere il nome della funzione, un ARN o un ARN parziale. Per un elenco dei formati possibili, consulta [Formati dei nomi delle funzioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_RequestParameters) nella *Guida per gli sviluppatori di AWS Lambda*.
*payload*
L'input per la funzione Lambda. Il formato può essere JSON o JSONB. Per ulteriori informazioni, consulta [Tipi di JSON](https://www.postgresql.org/docs/current/datatype-json.html) nella documentazione di PostgreSQL.
*region*
(Facoltativo) La regione Lambda per la funzione. Per impostazione predefinita, Aurora risolve la regione AWS dall'ARN completo nella `function_name` oppure utilizza la regione dell'istanza database Aurora PostgreSQL . Se il valore di questa Regione è in conflitto con quello fornito nell'ARN `function_name`, viene generato un errore.
*invocation\$1type*
Il tipo di chiamata della funzione Lambda. Il valore prevede la distinzione tra lettere maiuscole e minuscole. I valori possibili sono:
+ `RequestResponse` – Il valore predefinito. Questo tipo di chiamata per una funzione Lambda è sincrono e restituisce un payload di risposta nel risultato. Utilizzare il tipo di chiamata `RequestResponse` quando il flusso di lavoro dipende dalla ricezione immediata del risultato della funzione Lambda.
+ `Event` – Questo tipo di chiamata per una funzione Lambda è asincrono e restituisce immediatamente una risposta senza un payload restituito. Utilizzare il tipo di chiamata `Event` quando non sono necessari i risultati della funzione Lambda prima che il flusso di lavoro proceda.
+ `DryRun` – Questo tipo di chiamata verifica l'accesso senza eseguire la funzione Lambda.
*log\$1type*
Il tipo di log Lambda da restituire nel parametro di output `log_result`. Il valore prevede la distinzione tra lettere maiuscole e minuscole. I valori possibili sono:
+ Tail – Il parametro di output `log_result` restituito includerà gli ultimi 4 KB del registro di esecuzione.
+ None – Non viene restituita nessuna informazione di log Lambda.
*context*
Contesto client in formato JSON o JSONB. I campi da utilizzare includono `custom` e `env`.
*qualifier*
Un qualificatore che identifica la versione di una funzione Lambda da richiamare. Se questo valore è in conflitto con quello fornito nell' `function_name` ARN, viene generato un errore.Parametri di output
*status\$1code*
Un codice di risposta allo stato HTTP. Per ulteriori informazioni, consulta [Elementi di risposta del richiamo di Lambda](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_ResponseElements) nella *Guida per gli sviluppatori di AWS Lambda*.
*payload*
Le informazioni restituite dalla funzione Lambda eseguita. Il formato è in JSON o JSONB.
*executed\$1version*
La versione della funzione Lambda eseguita.
*log\$1result*
Le informazioni del registro di esecuzione restituite se il valore `log_type` è `Tail` quando è stata richiamata la funzione Lambda. Il risultato contiene gli ultimi 4 KB del registro di esecuzione codificato in Base64.
## aws\$1commons.create\$1lambda\$1function\$1arn
Crea una struttura `aws_commons._lambda_function_arn_1` per contenere le informazioni sul nome della funzione Lambda. È possibile utilizzare i risultati della `aws_commons.create_lambda_function_arn` funzione nel parametro `function_name` della funzione [aws\$1lambda.invoke](#aws_lambda.invoke) aws\$1lambda.invoke.
**Sintassi**
```
aws_commons.create_lambda_function_arn(
function_name TEXT,
region TEXT DEFAULT NULL
)
RETURNS aws_commons._lambda_function_arn_1
```Parametri di input
*function\$1name*
Stringa di testo obbligatoria contenente il nome della funzione Lambda. Il valore può essere un nome di funzione, un ARN parziale o un ARN completo.
*region*
Una stringa di testo facoltativa contenente la regione AWS in cui si trova la funzione Lambda. Per un elenco di nomi di regione e dei valori associati, consulta [ Regioni e zone di disponibilità](Concepts.RegionsAndAvailabilityZones.md).
## parametri aws\$1lambda
In questa tabella sono illustrati i parametri associati alla funzione `aws_lambda`.
| Parametro | Descrizione |
| --- | --- |
| `aws_lambda.connect_timeout_ms` | Si tratta di un parametro dinamico che imposta il tempo di attesa massimo durante la connessione a AWS Lambda. Il valore predefinito è `1000`. I valori consentiti per questo parametro sono compresi tra 1 e 900000. |
| `aws_lambda.request_timeout_ms` | Si tratta di un parametro dinamico che imposta il tempo di attesa massimo durante l’attesa della risposta da AWS Lambda. Il valore predefinito è `3000`. I valori consentiti per questo parametro sono compresi tra 1 e 900000. |
| `aws_lambda.endpoint_override` | Specifica l’endpoint che può essere utilizzato per connettersi a AWS Lambda. Una stringa vuota seleziona l’endpoint AWS Lambda predefinito per la Regione. Per rendere effettiva la modifica del parametro statico, è necessario riavviare il database. |
# Pubblicazione di log Aurora PostgreSQL in Amazon CloudWatch Logs
È possibile configurare il cluster database Aurora PostgreSQL per l’esportazione dei dati di registro in File di log Amazon CloudWatch in modo regolare. In questo caso, gli eventi del registro PostgreSQL del cluster database Aurora PostgreSQL vengono *pubblicati* automaticamente in Amazon CloudWatch, come File di log Amazon CloudWatch. In CloudWatch, sono disponibili i dati di registro esportati in un *Gruppo di log* per il cluster database Aurora PostgreSQL. Il gruppo di log contiene uno o più *flussi di log* che contengono gli eventi del registro PostgreSQL di ogni istanza nel cluster.
La pubblicazione dei registri in File di log CloudWatch consente di mantenere i record di registro PostgreSQL del cluster in uno storage altamente durevole. Con i dati di registro disponibili in File di log CloudWatch, puoi valutare e migliorare le operazioni del cluster. Puoi anche usare CloudWatch per creare allarmi e visualizzare metriche. Per ulteriori informazioni, consulta [Monitoraggio degli eventi di registro in Amazon CloudWatch](AuroraPostgreSQL.CloudWatch.Monitor.md).
**Nota**
La pubblicazione dei registri PostgreSQL in File di log CloudWatch consuma spazio di archiviazione e comporta costi di archiviazione. Assicurati di eliminare gli eventuali File di log CloudWatch non più necessari.
La disattivazione dell'opzione Export log (Esporta log) per un cluster database Aurora PostgreSQL esistente non influenza gli eventuali dati già contenuti in File di log CloudWatch. I registri esistenti rimangono disponibili in File di log CloudWatch in base alle impostazioni di conservazione dei registri. Per ulteriori informazioni su File di log CloudWatch, consulta [Che cos'è File di log Amazon CloudWatch?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)
Aurora PostgreSQL supporta la pubblicazione di registri in File di log CloudWatch per le seguenti versioni.
+ 16.1 e tutte le versioni successive
+ 15.2 o versioni successive alla 15
+ 14.3 o versioni successive alla 14
+ 13.3 o versioni successive alla 13
+ 12.8 e versioni successive alla 12
+ 11.9 o versioni successive alla 11
Per informazioni sull’attivazione dell’opzione di pubblicazione dei log su CloudWatch Logs, sul monitoraggio degli eventi di log in CloudWatch Logs e sull’analisi dei log utilizzando CloudWatch Logs Insights, consulta i seguenti argomenti.
**Topics**
+ [Attivazione dell'opzione per pubblicare i registri in Amazon CloudWatch](AuroraPostgreSQL.CloudWatch.Publishing.md)
+ [Monitoraggio degli eventi di registro in Amazon CloudWatch](AuroraPostgreSQL.CloudWatch.Monitor.md)
+ [Analisi dei registri Aurora PostgreSQL utilizzando approfondimenti sui file di log Amazon CloudWatch](AuroraPostgreSQL.CloudWatch.Analyzing.md)
# Attivazione dell'opzione per pubblicare i registri in Amazon CloudWatch
Per pubblicare il registro PostgreSQL del cluster database Aurora PostgreSQL in File di log CloudWatch, seleziona l’opzione **Log Export** (Esportazione log) per il cluster. Puoi scegliere l'impostazione Log export (Esportazione log) durante la creazione del cluster database Aurora PostgreSQL. In alternativa, puoi modificare il cluster in un secondo momento. Quando si modifica un cluster esistente, i relativi registri PostgreSQL di ciascuna istanza vengono pubblicati nel cluster CloudWatch da quel momento in poi. Per Aurora PostgreSQL, il registro PostgreSQL (`postgresql.log`) è l'unico registro pubblicato in Amazon CloudWatch.
Puoi utilizzare la Console di gestione AWS, la AWS CLI o l'API RDS per attivare la funzionalità Log export (Esportazione log) per il cluster database Aurora PostgreSQL.
## Console
Scegliere l’opzione Log exports (Esportazioni log) per avviare la pubblicazione dei registri PostgreSQL dal cluster database Aurora PostgreSQL in File di log Amazon CloudWatch.
**Per attivare la funzionalità Log export (Esportazione log) dalla console**
1. Apri la console Amazon RDS all’indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Databases (Database)**.
1. Scegli il cluster database Aurora PostgreSQL di cui desideri pubblicare i dati di registro in File di log CloudWatch.
1. Scegliere **Modify (Modifica)**.
1. Nella sezione **Log exports** (Esportazioni log) scegli **Postgresql log** (Log PostgreSQL).
1. Scegliere **Continue (Continua)** e quindi selezionare **Modify cluster (Modifica cluster)** nella pagina di riepilogo.
## AWS CLI
Puoi attivare l'opzione Log export (Esportazione log) per iniziare a pubblicare i registri di Aurora PostgreSQL in File di log Amazon CloudWatch con la AWS CLI. A questo scopo, esegui il comando AWS CLI [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) con le opzioni seguenti:
+ `--db-cluster-identifier`: l’identificatore del cluster di database.
+ `--cloudwatch-logs-export-configuration`—L'impostazione di configurazione per i tipi di log da abilitare per l'esportazione in CloudWatch Logs per il cluster DB.
Puoi pubblicare i log Aurora PostgreSQL anche emettendo uno dei seguenti comandi della AWS CLI:
+ [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html)
+ [restore-db-cluster-from-s3](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-from-s3.html)
+ [restore-db-cluster-from-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-from-snapshot.html)
+ [restore-db-cluster-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-to-point-in-time.html)
Esegui uno di questi comandi dell'AWS CLI con le opzioni seguenti:
+ `--db-cluster-identifier`: l’identificatore del cluster di database.
+ `--engine`— – Il motore di database.
+ `--enable-cloudwatch-logs-exports`— – L'impostazione di configurazione per i tipi di log da abilitare per l'esportazione in CloudWatch Logs per il cluster DB.
Altre opzioni potrebbero essere richieste a seconda del comando dell'AWS CLI che esegui.
**Example**
Il seguente comando crea un cluster DB Aurora PostgreSQL per pubblicare i file di log in CloudWatch Logs.
Per Linux, macOS o Unix:
```
1. aws rds create-db-cluster \
2. --db-cluster-identifier my-db-cluster \
3. --engine aurora-postgresql \
4. --enable-cloudwatch-logs-exports postgresql
```
Per Windows:
```
1. aws rds create-db-cluster ^
2. --db-cluster-identifier my-db-cluster ^
3. --engine aurora-postgresql ^
4. --enable-cloudwatch-logs-exports postgresql
```
**Example**
Il seguente comando modifica un cluster DB Aurora PostgreSQL esistente per pubblicare i file di log in CloudWatch Logs. Il valore `--cloudwatch-logs-export-configuration` è un oggetto JSON. La chiave per questo oggetto è `EnableLogTypes` e il relativo valore è `postgresql` e `instance`.
Per Linux, macOS o Unix:
```
1. aws rds modify-db-cluster \
2. --db-cluster-identifier my-db-cluster \
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["postgresql","instance"]}'
```
Per Windows:
```
1. aws rds modify-db-cluster ^
2. --db-cluster-identifier my-db-cluster ^
3. --cloudwatch-logs-export-configuration '{\"EnableLogTypes\":[\"postgresql\",\"instance\"]}'
```
Quando usi il prompt comandi di Windows, non devi inserire le doppie virgolette (") nel codice JSON precedendole con il backslash (\$1).
**Example**
Nell'esempio seguente viene modificato un cluster Aurora PostgreSQL DB esistente per disabilitare i file di registro di pubblicazione CloudWatch Logs. Il valore `--cloudwatch-logs-export-configuration` è un oggetto JSON. La chiave per questo oggetto è `DisableLogTypes` e il relativo valore è `postgresql` e `instance`.
Per Linux, macOS o Unix:
```
aws rds modify-db-cluster \
--db-cluster-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"DisableLogTypes":["postgresql","instance"]}'
```
Per Windows:
```
aws rds modify-db-cluster ^
--db-cluster-identifier mydbinstance ^
--cloudwatch-logs-export-configuration "{\"DisableLogTypes\":[\"postgresql\",\"instance\"]}"
```
Quando usi il prompt comandi di Windows, non devi inserire le doppie virgolette (") nel codice JSON precedendole con il backslash (\$1).
## API RDS
Puoi attivare l'opzione Log export (Esportazione log) per iniziare a pubblicare i registri di Aurora PostgreSQL con l’API RDS. A questo scopo, esegui l'operazione [ModifyDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) con le seguenti opzioni:
+ `DBClusterIdentifier` - L'identificatore del cluster di database.
+ `CloudwatchLogsExportConfiguration` – L'impostazione di configurazione per i tipi di log da abilitare per l'esportazione in CloudWatch Logs per il cluster di database.
Puoi anche pubblicare i log Aurora MySQL con l'API RDS eseguendo una delle seguenti operazioni dell'API RDS:
+ [CreateDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html)
+ [RestoreDBClusterFromS3](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromS3.html)
+ [RestoreDBClusterFromSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html)
+ [RestoreDBClusterToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html)
Esegui l'operazione dell'API RDS con i seguenti parametri:
+ `DBClusterIdentifier`: l’identificatore del cluster di database.
+ `Engine`— – Il motore di database.
+ `EnableCloudwatchLogsExports`— – L'impostazione di configurazione per i tipi di log da abilitare per l'esportazione in CloudWatch Logs per il cluster DB.
Altri parametri potrebbero essere richiesti a seconda del comando dell'AWS CLI che esegui.
# Monitoraggio degli eventi di registro in Amazon CloudWatch
Con gli eventi di log di Aurora PostgreSQL pubblicati e disponibili come Amazon CloudWatch Logs, puoi visualizzare e monitorare gli eventi utilizzando Amazon. CloudWatch Per ulteriori informazioni sul monitoraggio, consulta [Visualizza i dati di registro](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) inviati ai registri. CloudWatch
Se si attiva Log exports (Esportazioni log), un nuovo gruppo di log viene creato automaticamente utilizzando il prefisso `/aws/rds/cluster/` con il nome di Aurora PostgreSQL e il tipo di registro, come nel modello seguente.
```
/aws/rds/cluster/your-cluster-name/postgresql
```
Ad esempio, supponiamo che un cluster `docs-lab-apg-small` DB Aurora PostgreSQL denominato esporti il proprio log in Amazon Logs. CloudWatch Il nome del gruppo di log in Amazon CloudWatch è mostrato di seguito.
```
/aws/rds/cluster/docs-lab-apg-small/postgresql
```
Se esiste un gruppo di log con il nome specificato, Aurora utilizza quel gruppo di log per esportare i dati di log per il cluster DB Aurora. Ogni istanza database nel cluster database Aurora PostgreSQL carica il proprio registro PostgreSQL nel gruppo di log come flusso di log distinto. Puoi esaminare il gruppo di log e i relativi flussi di log utilizzando i vari strumenti grafici e analitici disponibili in Amazon. CloudWatch
Ad esempio, è possibile cercare informazioni all'interno degli eventi di registro del cluster Aurora PostgreSQL DB e filtrare gli eventi utilizzando la console Logs, o l'API CloudWatch Logs. AWS CLI CloudWatch Per ulteriori informazioni, consulta [Ricerca e filtraggio dei dati di log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/MonitoringLogData.html) nella *Amazon CloudWatch Logs User Guide.*
Per impostazione predefinita, i nuovi gruppi di log vengono creati utilizzando **Never expire** (Non scade mai) per il periodo di conservazione. Puoi utilizzare la console CloudWatch Logs, l'API Logs o l' AWS CLI API CloudWatch Logs per modificare il periodo di conservazione dei log. Per ulteriori informazioni, consulta [Change log data retention in CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) nella *Amazon CloudWatch Logs User* Guide.
**Suggerimento**
Puoi utilizzare la configurazione automatizzata AWS CloudFormation, ad esempio per creare gruppi di log con periodi di conservazione dei log predefiniti, filtri metrici e autorizzazioni di accesso.
# Analisi dei registri Aurora PostgreSQL utilizzando approfondimenti sui file di log Amazon CloudWatch
Con i registri PostgreSQL del cluster database Aurora PostgreSQL pubblicati come File di log Amazon CloudWatch, è possibile usare approfondimenti sui File di log Amazon CloudWatch per cercare e analizzare in modo interattivo i dati di registro in File di log Amazon CloudWatch. Approfondimenti sui file di log Amazon CloudWatch include un linguaggio di query, query di esempio e altri strumenti per l'analisi dei dati di registro in modo da poter identificare potenziali problemi e verificare le correzioni. Per ulteriori informazioni, consulta [Analisi dei dati di registro con approfondimenti sui file di log Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) nella *Guida per l'utente di File di log Amazon CloudWatch*.
**Per analizzare i registri Aurora PostgreSQL con Approfondimenti sui file di log Amazon CloudWatch**
1. Apri la console CloudWatch all’indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione, aprire **Logs (Log)**, e scegliere **Log Insights (Informazioni dettagliate Log**.
1. In **Select log group(s)** (Seleziona uno o più i gruppi di log), seleziona il gruppo di log per il cluster database Aurora PostgreSQL.
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-select-log-group.png)
1. Nell'editor di query, elimina la query attualmente visualizzata, quindi immetti quanto segue e scegli **Run (Esegui)**.
```
##Autovacuum execution time in seconds per 5 minute
fields @message
| parse @message "elapsed: * s" as @duration_sec
| filter @message like / automatic vacuum /
| display @duration_sec
| sort @timestamp
| stats avg(@duration_sec) as avg_duration_sec,
max(@duration_sec) as max_duration_sec
by bin(5 min)
```
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-query.png)
1. Seleziona la scheda **Visualization (Visualizzazione)**.
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-visualization.png)
1. Scegli **Add to dashboard (Aggiungi a pannello di controllo)**.
1. In **Seleziona un pannello di controllo**, seleziona un pannello di controllo o inserisci un nome per creare un nuovo pannello di controllo.
1. In **Tipo di widget**, scegli un tipo di widget per la tua visualizzazione.
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-dashboard.png)
1. (Facoltativo) Aggiungi altri widget in base ai risultati della query di log.
1. Seleziona **Add widget** (Aggiungi widget).
1. Scegli un tipo di widget, ad esempio **Line (Linea)**.
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-widget.png)
1. Nella finestra **Aggiungi a questo pannello di controllo**, scegli **Log**.
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-add-logs-to-dashboard.png)
1. Nello stato **Seleziona gruppi di log**, seleziona il gruppo di log per il cluster di database di.
1. Nell'editor di query, elimina la query attualmente visualizzata, quindi immetti quanto segue e scegli **Run (Esegui)**.
```
##Autovacuum tuples statistics per 5 min
fields @timestamp, @message
| parse @message "tuples: " as @tuples_temp
| parse @tuples_temp "* removed," as @tuples_removed
| parse @tuples_temp "remain, * are dead but not yet removable, " as @tuples_not_removable
| filter @message like / automatic vacuum /
| sort @timestamp
| stats avg(@tuples_removed) as avg_tuples_removed,
avg(@tuples_not_removable) as avg_tuples_not_removable
by bin(5 min)
```
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-query2.png)
1. Seleziona **Crea widget**.
Il pannello di controllo dovrebbe apparire simile alla seguente immagine.
![\[\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-dashboard-two-graphs.png)