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