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à.
# Configurazione delle funzioni AWS Lambda
Scopri come configurare le funzionalità e le opzioni principali per la funzione Lambda tramite l'API o la console Lambda.
**[archivi di file.zip](configuration-function-zip.md) **
Crea un pacchetto di distribuzione delle funzioni Lambda quando desideri includere dipendenze, livelli di runtime personalizzati o qualsiasi file oltre al codice della funzione. Il pacchetto di distribuzione è un archivio di file.zip contenente il codice della funzione e le dipendenze.
**[Immagini di container](images-create.md) **
Usa le immagini dei contenitori per impacchettare il codice della funzione e le dipendenze quando hai bisogno di un maggiore controllo sul processo di compilazione o se la tua funzione richiede configurazioni di runtime personalizzate. Puoi creare, testare e distribuire funzioni Lambda come immagini di container utilizzando strumenti come Docker CLI.
**[Memoria](configuration-memory.md)**
Scopri come e quando aumentare la memoria della funzione.
**[Archiviazione temporanea](configuration-ephemeral-storage.md) **
Scopri come e quando aumentare la capacità di archiviazione temporanea della tua funzione.
**[Timeout](configuration-timeout.md) **
Scopri come e quando aumentare il valore di timeout della funzione.
**[Configurazione durevole](durable-configuration.md) **
Consenti alle funzioni Lambda di funzionare per periodi prolungati, fino a un anno, mantenendo lo stato tra le chiamate. Configura i timeout di esecuzione, la conservazione dello stato e il comportamento di controllo delle versioni per flussi di lavoro a lunga durata e con stato. Le funzioni durevoli consentono di creare processi complessi e in più fasi in grado di sospendere, riprendere e gestire automaticamente le interruzioni.
** [Variabili d'ambiente](configuration-envvars.md)**
È possibile rendere il codice della funzione portabile e nascondere i segreti del codice archiviandoli nella configurazione della funzione utilizzando le variabili di ambiente.
**[Rete in uscita](configuration-vpc.md) **
Puoi usare la tua funzione Lambda con AWS risorse in un Amazon VPC. La connessione della funzione a un VPC consente di accedere alle risorse in una sottorete privata, ad esempio database relazionali e cache.
** [Rete in entrata](configuration-vpc-endpoints.md)**
È possibile utilizzare un endpoint VPC dell'interfaccia per richiamare le funzioni Lambda senza attraversare l'Internet pubblico.
**[File system](configuration-filesystem.md)**
È possibile utilizzare la funzione Lambda per montare un Amazon EFS in una directory locale. Un file system consente al codice della funzione di accedere e modificare le risorse condivise in modo sicuro e con una simultaneità elevata.
**[Alias](configuration-aliases.md)**
Quindi è possibile configurare i client per invocare una versione della funzione Lambda specifica utilizzando un alias anziché aggiornando il client.
**[Versioni](configuration-versions.md)**
Pubblicando una versione della funzione, sarà possibile archiviare il codice e la configurazione come risorse separate che non possono essere modificate.
**[Tag](configuration-tags.md)**
Utilizza i tag per abilitare il controllo degli accessi basato sugli attributi (ABAC), per organizzare le funzioni Lambda e per filtrare e generare report sulle tue funzioni utilizzando i nostri servizi Billing and AWS Cost Explorer Cost AWS Management.
**[Streaming delle risposte](configuration-response-streaming.md)**
Puoi configurare la tua funzione Lambda URLs per trasmettere i payload di risposta ai client. Lo streaming delle risposte può favorire le applicazioni sensibili alla latenza migliorando le prestazioni del time to first byte (TTFB). Questo perché consente di inviare risposte parziali al client non appena diventano disponibili. Inoltre, lo streaming delle risposte permette di creare funzioni che restituiscono payload più grandi.
**[Endpoint di metadati](configuration-metadata-endpoint.md)**
Usa l'endpoint di metadati Lambda per scoprire in quale zona di disponibilità è in esecuzione la tua funzione, consentendoti di ottimizzare la latenza indirizzando verso risorse Same-AZ e di implementare modelli di resilienza compatibili con AZ.
# Distribuzione di funzioni Lambda come archivi di file .zip
Quando si crea una funzione Lambda, viene utilizzato un pacchetto di implementazione per impacchettare il codice della funzione. Lambda supporta due tipi di pacchetti di implementazione: immagini di container e archivi di file .zip. Il flusso di lavoro per creare una funzione dipende dal tipo di pacchetto di implementazione. Per creare una funzione definita come immagine di container, consulta [Creare una funzione Lambda utilizzando un'immagine di container](images-create.md).
Puoi utilizzare la console Lambda e l'API Lambda per creare una funzione definita con un archivio di file .zip. È inoltre possibile caricare un file .zip aggiornato per modificare il codice funzione.
**Nota**
Non è possibile modificare il [tipo di pacchetto di implementazione](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o immagine di container) per una funzione esistente. Ad esempio, non è possibile convertire una funzione di immagine di container esistente per utilizzare un archivio di file .zip. È necessario creare una nuova funzione.
**Topics**
+ [
## Creazione della funzione
](#configuration-function-create)
+ [
## Utilizzo dell'editor di codice della console
](#configuration-functions-console-update)
+ [
## Aggiornamento del codice della funzione
](#configuration-function-update)
+ [
## Modifica del runtime
](#configuration-function-runtime)
+ [
## Modifica dell'architettura
](#configuration-function-arch)
+ [
## Utilizzo dell'API Lambda
](#configuration-function-api)
+ [
## Download del codice della funzione
](#configuration-function-download)
+ [
## CloudFormation
](#configuration-function-cloudformation)
+ [
# Crittografia dei pacchetti di implementazione .zip per Lambda
](encrypt-zip-package.md)
## Creazione della funzione
Quando si crea una funzione definita con un archivio di file .zip, si scelgono un modello di codice, la versione della lingua e il ruolo di esecuzione per la funzione. Si aggiunge il codice della funzione dopo che Lambda ha creato la funzione.
**Creazione della funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli **Crea funzione**.
1. Scegliere **Author from scratch (Crea da zero)** o **Use a blueprint (Usa un piano)** per creare la funzione
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. In **Function name (Nome funzione)**, immettere il nome della funzione. I nomi delle funzioni hanno un limite di lunghezza di 64 caratteri.
1. Per **Runtime**, scegliere la versione della lingua da utilizzare per la funzione.
1. (Opzionale) Per **Architecture (Architettura)**, scegli l'architettura del set di istruzioni da utilizzare per la funzione. L'architettura predefinita è x86\$164. Quando crei il pacchetto di implementazione per la tua funzione, assicurati che sia compatibile con questa [architettura del set di istruzioni](foundation-arch.md).
1. (Opzionale) In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**. Puoi creare un nuovo **ruolo di esecuzione** o utilizzare un ruolo esistente.
1. (Facoltativo) Espandi **Advanced settings (Impostazioni avanzate)**. È possibile scegliere una **Code signing configuration (Configurazione della firma del codice)** per la funzione Puoi anche configurare un (Amazon VPC) per accedere alla funzione.
1. Scegli **Crea funzione**.
Lambda crea la nuova funzione. È ora possibile utilizzare la console per aggiungere il codice della funzione e configurare altri parametri di funzione e funzionalità. Per le istruzioni di distribuzione del codice, consulta la pagina del gestore del runtime utilizzato dalla funzione.
------
#### [ Node.js ]
[Distribuisci funzioni Lambda in Node.js con archivi di file .zip](nodejs-package.md)
------
#### [ Python ]
[Utilizzo di archivi di file .zip per le funzioni Lambda in Python](python-package.md)
------
#### [ Ruby ]
[Distribuire le funzioni Ruby Lambda con gli archivi di file .zip](ruby-package.md)
------
#### [ Java ]
[Distribuisci funzioni Lambda per Java con archivi di file .zip o JAR](java-package.md)
------
#### [ Go ]
[Distribuisci funzioni Lambda per Go con gli archivi di file .zip](golang-package.md)
------
#### [ C\$1 ]
[Crea e implementa le funzioni Lambda C\$1 con gli archivi di file .zip](csharp-package.md)
------
#### [ PowerShell ]
[Distribuzione delle funzioni Lambda di PowerShell con gli archivi di file .zip](powershell-package.md)
------
## Utilizzo dell'editor di codice della console
La console crea una funzione Lambda con un unico file di origine. Per i linguaggi di scripting, è possibile modificare questo file e aggiungere altri file con l'editor di codice incorporato. Per salvare le modifiche, scegliere **Save (Salva)**. Quindi, per eseguire il codice, scegliere **Test (Testa)**.
Quando si salva il codice funzione, la console Lambda crea un pacchetto di implementazione dell'archivio di file .zip. Quando sviluppi il codice funzione al di fuori della console (utilizzando un IDE) devi [creare un pacchetto di implementazione](nodejs-package.md) per caricare il codice nella funzione Lambda.
## Aggiornamento del codice della funzione
Per i linguaggi di scripting (Node.js, Python e Ruby), puoi modificare il codice della funzione nell'editor di codice incorporato. Se il codice supera i 3 MB, o se è necessario aggiungere librerie, o per linguaggi che l'editor non supporta (come Java, Go e C\$1), è necessario caricare il codice funzione come archivio .zip. Se l'archivio di file .zip è inferiore a 50 MB, è possibile caricare l'archivio di file .zip direttamente dal computer locale. Se le dimensioni dell'archivio .zip sono maggiori di 50 MB, carica il file sulla funzione da un bucket Amazon S3.
**Per caricare il codice funzione come archivio .zip**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere la funzione da aggiornare e scegliere la scheda **Codice**
1. In **Code source (Origine codice)**, scegli **Upload from (Carica da)**.
1. Scegli **.zip file**, quindi scegli **Upload (Carica)**.
1. Nella finestra di selezione dei file, selezionare la nuova versione dell'immagine e scegliere **Open (Apri)**, quindi scegliere **Save (Salva)**.
1. (Alternativa al passaggio 4) Scegli **Percorso Amazon S3**.
1. Nella casella di testo, inserisci l'URL del link S3 dell'archivio di file .zip, quindi scegli **Save (Salva)**.
## Modifica del runtime
Se si aggiorna la configurazione della funzione in modo da utilizzare una nuova versione di runtime, potrebbe essere necessario aggiornare il codice della funzione per renderlo compatibile con la nuova versione. Se si aggiorna la configurazione della funzione per utilizzare un runtime diverso, **è necessario** fornire un nuovo codice funzione compatibile con il runtime e l'architettura. Per istruzioni su come creare un pacchetto di implementazione per il codice della funzione, consulta la pagina del gestore per il runtime utilizzato dalla funzione.
Le immagini di base Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 e versioni successive si basano sull'immagine minima del container di Amazon Linux 2023. Le immagini di base precedenti utilizzavano Amazon Linux 2. AL2023 offre diversi vantaggi rispetto ad Amazon Linux 2, tra cui un ingombro di distribuzione ridotto e versioni aggiornate di librerie come`glibc`. Per ulteriori informazioni, consulta il post [Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) del blog AWS Compute.
**Modifica del runtime**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere la funzione da aggiornare e scegliere la scheda **Codice**
1. Scorrere fino alla sezione **Runtime settings** (Impostazioni runtime) sotto l'editor di codice.
1. Scegli **Modifica**.
1. Per **Runtime**, seleziona l'identificatore di runtime.
1. In **Gestore**, specifica il nome del file e il gestore per la funzione.
1. Per **Architecture (Architettura)**, scegli l'architettura del set di istruzioni da utilizzare per la funzione.
1. Scegli **Save** (Salva).
## Modifica dell'architettura
Prima di poter modificare l'architettura del set di istruzioni, è necessario assicurarsi che il codice della funzione sia compatibile con l'architettura di destinazione.
Se usi Node.js, Python o Ruby e modifichi il codice della funzione nell'editor incorporato, il codice esistente può essere eseguito senza modifiche.
Tuttavia, se si fornisce il codice della funzione utilizzando un pacchetto di implementazione con un archivio di file. zip, è necessario preparare un nuovo archivio di file .zip compilato e sviluppato correttamente per il runtime e l'architettura del set di istruzioni di destinazione. Per le istruzioni, consulta la pagina del gestore del runtime della funzione.
**Per modificare l'architettura del set di istruzioni**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere la funzione da aggiornare e scegliere la scheda **Codice**
1. In **Impostazioni runtime**, scegliere **Modifica**.
1. Per **Architecture (Architettura)**, scegli l'architettura del set di istruzioni da utilizzare per la funzione.
1. Scegli **Save** (Salva).
## Utilizzo dell'API Lambda
Per creare e configurare una funzione che utilizza un archivio di file .zip, utilizzare le seguenti operazioni API:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
## Download del codice della funzione
Puoi scaricare la versione corrente non pubblicata (`$LATEST`) del tuo codice funzione .zip tramite la console Lambda. Per fare ciò, assicurati innanzitutto di disporre delle seguenti autorizzazioni IAM:
+ `iam:GetPolicy`
+ `iam:GetPolicyVersion`
+ `iam:GetRole`
+ `iam:GetRolePolicy`
+ `iam:ListAttachedRolePolicies`
+ `iam:ListRolePolicies`
+ `iam:ListRoles`
**Per scaricare il file .zip del codice della funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli la funzione per la quale desideri scaricare il file .zip codice della funzione.
1. Nella **panoramica delle funzioni**, scegli il pulsante **Scarica**, quindi **Scarica il file .zip del codice della funzione.**
1. In alternativa, scegli **Scarica AWS SAM file** per generare e scaricare un modello SAM basato sulla configurazione della tua funzione. Puoi anche scegliere **Scarica entrambi** per scaricare sia il file .zip che il modello SAM.
## CloudFormation
È possibile utilizzare CloudFormation per creare una funzione Lambda che utilizza un archivio di file.zip. Nel CloudFormation modello, la `AWS::Lambda::Function` risorsa specifica la funzione Lambda. Per le descrizioni delle proprietà della `AWS::Lambda::Function` risorsa, [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)consultate la Guida per l'*AWS CloudFormation utente*.
Nella risorsa `AWS::Lambda::Function`, impostare le seguenti proprietà per creare una funzione definita come archivio di file .zip:
+ AWS::Lambda::Function
+ PackageType — Impostato su`Zip`.
+ Codice: inserisci il nome del bucket Amazon S3 e il nome del file .zip nei campi `S3Bucket` e `S3Key`. Per Node.js o Python, puoi fornire il codice sorgente inline della funzione Lambda.
+ Runtime: imposta il valore di runtime.
+ Architettura: imposta il valore dell'architettura su cui `arm64` utilizzare il processore AWS Graviton2. Per impostazione predefinita, il valore dell'architettura è `x86_64`.
# Crittografia dei pacchetti di implementazione .zip per Lambda
Lambda fornisce sempre la crittografia lato server dei dati a riposo per i pacchetti di implementazione .zip e i dettagli di configurazione delle funzioni con una AWS KMS key. Per impostazione predefinita, Lambda utilizza un [Chiave di proprietà di AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk). Se questo comportamento predefinito si adatta al tuo flusso di lavoro, non devi configurare nient'altro. AWS non ti addebita alcun costo per l'utilizzo di questa chiave.
Se preferisci, puoi invece fornire una chiave gestita AWS KMS dal cliente. È possibile eseguire questa operazione per avere il controllo sulla rotazione della chiave KMS o per soddisfare i requisiti dell'organizzazione per la gestione delle chiavi KMS. Quando si utilizza una chiave gestita dal cliente, solo gli utenti del tuo account con accesso alla chiave KMS possono visualizzare o gestire il codice o la configurazione della funzione.
Le chiavi gestite dal cliente sono soggette a costi standard AWS KMS . Per ulteriori informazioni, consultare [Prezzi di AWS Key Management Service](https://aws.amazon.com/kms/pricing/).
## Creazione di una chiave gestita dal cliente
È possibile creare una chiave simmetrica gestita dal cliente utilizzando, o il Console di gestione AWS. AWS KMS APIs
**Per creare una chiave simmetrica gestita dal cliente**
Segui le fasi descritte in [Creazione delle chiavi KMS per la crittografia simmetrica](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) nella *Guida per gli sviluppatori di AWS Key Management Service *.
### Permissions
**Policy della chiave**
Le [policy della chiave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) controllano l'accesso alla chiave gestita dal cliente. Ogni chiave gestita dal cliente deve avere esattamente una policy della chiave, che contiene istruzioni che determinano chi può usare la chiave e come la possono usare. Per ulteriori informazioni, consulta [Come modificare una policy delle chiavi](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to) nella *Guida per gli sviluppatori di AWS Key Management Service *.
Quando si utilizza una chiave gestita dal cliente per crittografare un pacchetto di implementazione .zip, Lambda non aggiunge alcuna [concessione](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) alla chiave. Invece, la tua policy AWS KMS chiave deve consentire a Lambda di chiamare le seguenti operazioni AWS KMS API per tuo conto:
+ [km: GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)
+ [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
Il seguente esempio di policy chiave consente a tutte le funzioni Lambda nell'account 111122223333 di richiamare le AWS KMS operazioni richieste per la chiave gestita dal cliente specificata:
**Example AWS KMS politica chiave**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id",
"Condition": {
"StringLike": {
"kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:*"
}
}
}
]
}
```
Per informazioni sulla [Risoluzione dei problemi delle chiavi di accesso](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html#example-no-iam) consulta la *Guida per gli sviluppatori di AWS Key Management Service *.
**Autorizzazioni del principale**
Quando si utilizza una chiave gestita dal cliente per crittografare un pacchetto di implementazione .zip, solo i [principali](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html) che hanno accesso a quella chiave possono accedere al pacchetto di implementazione .zip. Ad esempio, i responsabili che non hanno accesso alla chiave gestita dal cliente non possono scaricare il pacchetto.zip utilizzando l'URL S3 predefinito incluso nella risposta. [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html) `AccessDeniedException` viene restituito nella sessione `Code` della risposta.
**Example AWS KMS AccessDeniedException**
```
{
"Code": {
"RepositoryType": "S3",
"Error": {
"ErrorCode": "AccessDeniedException",
"Message": "KMS access is denied. Check your KMS permissions. KMS Exception: AccessDeniedException KMS Message: User: arn:aws:sts::111122223333:assumed-role/LambdaTestRole/session is not authorized to perform: kms:Decrypt on resource: arn:aws:kms:us-east-1:111122223333:key/key-id with an explicit deny in a resource-based policy"
},
"SourceKMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/key-id"
},
...
```
Per ulteriori informazioni sulle autorizzazioni per le AWS KMS chiavi, consulta [Autenticazione](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html) e controllo degli accessi per. AWS KMS
## Utilizzo di una chiave gestita dal cliente per il pacchetto di implementazione .zip
Utilizza i seguenti parametri API per configurare le chiavi gestite dal cliente per i pacchetti di implementazione .zip:
+ [Source KMSKey Arn](https://docs.aws.amazon.com/lambda/latest/api/API_FunctionCode.html#lambda-Type-FunctionCode-SourceKMSKeyArn): crittografa il pacchetto di distribuzione.zip di origine (il file che carichi).
+ [KMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-KMSKeyArn)[: crittografa le [variabili di ambiente e le istantanee](configuration-envvars-encryption.md) Lambda. SnapStart](snapstart.md)
Quando `SourceKMSKeyArn` e `KMSKeyArn` sono specificati entrambi, Lambda utilizza la chiave `KMSKeyArn` per crittografare la versione decompressa del pacchetto utilizzata da Lambda per richiamare la funzione. Quando `SourceKMSKeyArn` è specificato ma `KMSKeyArn` non lo è, Lambda utilizza una [Chiave gestita da AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) per crittografare la versione decompressa del pacchetto.
------
#### [ Lambda console ]
**Per aggiungere la crittografia della chiave gestita dal cliente durante la creazione di una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli **Crea funzione**.
1. Scegliere **Author from scratch** (Crea da zero) o **Container image** (Immagine di container).
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. In **Function name (Nome funzione)**, immettere il nome della funzione.
1. Per **Runtime**, scegliere la versione della lingua da utilizzare per la funzione.
1. Espandi **Impostazioni avanzate**, quindi seleziona **Abilita la crittografia con una AWS KMS ** chiave gestita dal cliente.
1. Scegli una chiave gestita dal cliente.
1. Scegli **Crea funzione**.
Per rimuovere la crittografia con la chiave gestita dal cliente o per utilizzare una chiave diversa, è necessario caricare nuovamente il pacchetto di implementazione .zip.
**Per aggiungere la crittografia con la chiave gestita dal cliente a una funzione esistente**
1. Aprire la pagina [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funzioni) della console Lambda.
1. Scegliere il nome della funzione.
1. Nel riquadro **Origine del codice**, scegli **Carica da**.
1. Scegli il **file .zip** o la **posizione di Amazon S3**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/upload-zip.png)
1. Carica il file o inserisci la posizione Amazon S3.
1. Scegli **Abilita la crittografia con una chiave gestita dal AWS KMS cliente**.
1. Scegli una chiave gestita dal cliente.
1. Scegli **Save** (Salva).
------
#### [ AWS CLI ]
**Per aggiungere la crittografia della chiave gestita dal cliente durante la creazione di una funzione**
Nel seguente esempio [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html):
+ `--code`: specifica il percorso locale del pacchetto di distribuzione.zip (`ZipFile`) e la chiave gestita dal cliente per crittografarlo (). `SourceKMSKeyArn`
+ `--kms-key-arn`: specifica la chiave gestita dal cliente per crittografare le variabili d'ambiente e la versione compressa del pacchetto di implementazione.
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x \
--handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code ZipFile=fileb://myFunction.zip,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
Nel seguente esempio [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html):
+ `--code`: specifica la posizione del file.zip in un bucket Amazon S3 `S3Bucket` (`S3Key`,`S3ObjectVersion`,) e la chiave gestita dal cliente per crittografarlo (). `SourceKMSKeyArn`
+ `--kms-key-arn`: specifica la chiave gestita dal cliente per crittografare le variabili d'ambiente e la versione compressa del pacchetto di implementazione.
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x --handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
**Per aggiungere la crittografia con la chiave gestita dal cliente a una funzione esistente**
Nell'esempio seguente: [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)
+ `--zip-file`: specifica il percorso locale del pacchetto di implementazione .zip.
+ `--source-kms-key-arn`: specifica la chiave gestita dal cliente per crittografare la versione compressa del pacchetto di implementazione. Lambda utilizza una chiave AWS proprietaria per crittografare il pacchetto decompresso per le chiamate di funzioni. Se desideri utilizzare una chiave gestita dal cliente per crittografare la versione decompressa del pacchetto, esegui il comando con l'opzione. [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)`--kms-key-arn`
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip \
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
Nel seguente esempio: [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)
+ `--s3-bucket`: specifica la posizione del file .zip in un bucket Amazon S3.
+ `--s3-key`: specifica la chiave Amazon S3 del pacchetto di implementazione.
+ `--s3-object-version`: per gli oggetti con versione, la versione dell'oggetto del pacchetto di implementazione da utilizzare.
+ `--source-kms-key-arn`: specifica la chiave gestita dal cliente per crittografare la versione compressa del pacchetto di implementazione. Lambda utilizza una chiave AWS proprietaria per crittografare il pacchetto decompresso per le chiamate di funzioni. Se desideri utilizzare una chiave gestita dal cliente per crittografare la versione decompressa del pacchetto, esegui il comando con l'opzione. [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)`--kms-key-arn`
```
aws lambda update-function-code \
--function-name myFunction \
--s3-bucket amzn-s3-demo-bucket \
--s3-key myFileName.zip \
--s3-object-version myObject Version
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
**Per rimuovere la crittografia con la chiave gestita dal cliente da una funzione esistente**
Nell'[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)esempio seguente, `--zip-file` specifica il percorso locale del pacchetto di distribuzione.zip. Quando esegui questo comando senza l'`--source-kms-key-arn`opzione, Lambda utilizza una chiave AWS proprietaria per crittografare la versione compressa del pacchetto di distribuzione.
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip
```
------
# Creare una funzione Lambda utilizzando un'immagine di container
Il codice della AWS Lambda funzione è costituito da script o programmi compilati e dalle relative dipendenze. Utilizza un *pacchetto di implementazione* per distribuire il codice della funzione a Lambda. Lambda supporta due tipi di pacchetti di implementazione: immagini di container e archivi di file .zip.
Esistono tre modi per creare un'immagine di container per una funzione Lambda:
+ [Usare un'immagine AWS di base per Lambda](#runtimes-images-lp)
[Le immagini di base AWS](#runtimes-images-lp) sono precaricate con un runtime in linguaggio, un client di interfaccia di runtime per gestire l'interazione tra Lambda e il codice della funzione e un emulatore di interfaccia di runtime per i test locali.
+ [Utilizzo di un'immagine di AWS base solo per il sistema operativo](#runtimes-images-provided)
[AWS Le immagini di base solo](https://gallery.ecr.aws/lambda/provided) per il sistema operativo contengono una distribuzione Amazon Linux e l'emulatore [di interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Queste immagini vengono comunemente utilizzate per creare immagini di container per linguaggi compilati, come [Go](go-image.md#go-image-provided) e [Rust](lambda-rust.md), e per un linguaggio o una versione di linguaggio per cui Lambda non fornisce un'immagine di base, come Node.js 19. Puoi anche utilizzare immagini di base solo per il sistema operativo per implementare un [runtime personalizzato](runtimes-custom.md). Per rendere l'immagine compatibile con Lambda, devi includere nell'immagine un [client di interfaccia di runtime](#images-ric) per il tuo linguaggio.
+ [Utilizzo di un'immagine non AWS di base](#images-types)
È possibile utilizzare un'immagine di base alternativa da un altro registro del container, come ad esempio Alpine Linux o Debian. Puoi anche utilizzare un'immagine personalizzata creata dalla tua organizzazione. Per rendere l'immagine compatibile con Lambda, devi includere nell'immagine un [client di interfaccia di runtime](#images-ric) per il tuo linguaggio.
**Suggerimento**
Per ridurre il tempo necessario all'attivazione delle funzioni del container Lambda, consulta [Utilizzo di compilazioni a più fasi](https://docs.docker.com/build/building/multi-stage/) nella documentazione Docker. Per creare immagini di container efficienti, segui le [best practice per scrivere file Docker](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Per creare una funzione Lambda da un'immagine di un container, crea l'immagine localmente e caricala in un repository Amazon Elastic Container Registry (Amazon ECR). Se si utilizza un'immagine container fornita da un venditore [Marketplace AWS](https://docs.aws.amazon.com/marketplace/latest/userguide/container-based-products.html), devi prima clonare l'immagine nel tuo repository Amazon ECR privato. Quindi, specifica l’URI del repository al momento della creazione della funzione. Il repository Amazon ECR deve corrispondere alla funzione Lambda. Regione AWS È possibile creare una funzione utilizzando un'immagine in un AWS account diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni multiaccount Amazon ECR](#configuration-images-xaccount-permissions).
**Nota**
Lambda non supporta gli endpoint FIPS di Amazon ECR per le immagini dei container. Se l'URI del repository include `ecr-fips`, stai utilizzando un endpoint FIPS. Esempio: `111122223333.dkr.ecr-fips.us-east-1.amazonaws.com`.
Questa pagina spiega i tipi di immagini di base e i requisiti per la creazione di immagini di container compatibili con Lambda.
**Nota**
Non è possibile modificare il [tipo di pacchetto di implementazione](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o immagine di container) per una funzione esistente. Ad esempio, non è possibile convertire una funzione di immagine di container esistente per utilizzare un archivio di file .zip. È necessario creare una nuova funzione.
**Topics**
+ [
## Requisiti
](#images-reqs)
+ [
## Usare un'immagine AWS di base per Lambda
](#runtimes-images-lp)
+ [
## Utilizzo di un'immagine di AWS base solo per il sistema operativo
](#runtimes-images-provided)
+ [
## Utilizzo di un'immagine non AWS di base
](#images-types)
+ [
## Client di interfaccia runtime
](#images-ric)
+ [
## Autorizzazioni Amazon ECR
](#gettingstarted-images-permissions)
+ [
## Ciclo di vita delle funzioni
](#images-lifecycle)
## Requisiti
Installa la [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e la [CLI Docker](https://docs.docker.com/get-docker). Sono inoltre necessari i seguenti requisiti:
+ L'immagine di container deve implementare l'[Utilizzo dell'API di runtime Lambda per runtime personalizzati](runtimes-api.md). I [client dell'interfaccia runtime AWS](#images-ric) open-source implementano l'API. È possibile aggiungere un client di interfaccia di runtime all'immagine di base preferita per renderla compatibile con Lambda.
+ L'immagine di container deve essere in grado di funzionare su un filesystem di sola lettura. Il codice della funzione può accedere a una directory `/tmp` scrivibile con spazio di storage compreso tra 512 MB e 10.240 MB con incrementi di 1 MB.
+ L'utente Lambda predefinito deve essere in grado di leggere tutti i file necessari per eseguire il codice della funzione. Lambda segue le best practice di sicurezza tramite la definizione di un utente Linux predefinito con autorizzazioni meno privilegiate. Ciò significa che non è necessario specificare un [USER](https://docs.docker.com/reference/dockerfile/#user) nel Dockerfile. Verifica che il codice dell'applicazione non si basi su file che altri utenti Linux non possono eseguire.
+ Lambda supporta solo le immagini di container basate su Linux.
+ Lambda fornisce immagini di base multi-architettura. Tuttavia, l'immagine creata per la tua funzione deve essere destinata a una sola delle architetture. Lambda non supporta funzioni che utilizzano immagini container multi-architettura.
## Usare un'immagine AWS di base per Lambda
È possibile utilizzare una delle [immagini di base AWS](https://gallery.ecr.aws/lambda/) per Lambda per creare l'immagine di container per il codice della funzione. Le immagini di base sono precaricate con un runtime di lingua e altri componenti necessari per eseguire un'immagine container su Lambda. Aggiungere il codice funzione e le dipendenze all'immagine di base e quindi impacchettarlo come immagine container.
AWS fornisce periodicamente aggiornamenti alle immagini di AWS base per Lambda. Se il Dockerfile include il nome dell'immagine nella proprietà FROM, il client Docker estrae l'ultima versione dell'immagine dal [repository Amazon ECR](https://gallery.ecr.aws/lambda/). Per utilizzare l'immagine di base aggiornata, è necessario ricostruire l'immagine di container e [aggiornare il codice della funzione](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html).
Le immagini di base Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 e versioni successive si basano sull'[immagine minima del container di Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Le immagini di base precedenti utilizzavano Amazon Linux 2. AL2023 offre diversi vantaggi rispetto ad Amazon Linux 2, tra cui un ingombro di distribuzione ridotto e versioni aggiornate di librerie come`glibc`.
AL2023le immagini basate utilizzano `microdnf` (symlinked as`dnf`) come gestore di pacchetti anziché`yum`, che è il gestore di pacchetti predefinito in Amazon Linux 2. `microdnf`è un'implementazione autonoma di. `dnf` Per un elenco dei pacchetti inclusi nelle immagini AL2023 basate, consulta le colonne **Minimal Container** in [Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Per ulteriori informazioni sulle differenze tra Amazon Linux 2 AL2023 e Amazon Linux 2, consulta [la sezione Introduzione al runtime di Amazon Linux 2023 AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) sul AWS Compute Blog.
**Nota**
Per eseguire immagini AL2023 basate localmente, incluso with AWS Serverless Application Model (AWS SAM), devi usare la versione Docker 20.10.10 o successiva.
Per creare un'immagine del contenitore utilizzando un'immagine di AWS base, scegli le istruzioni per la tua lingua preferita:
+ [Node.js](nodejs-image.md#nodejs-image-instructions)
+ [TypeScript](typescript-image.md#base-image-typescript)(utilizza un'immagine di base Node.js)
+ [Python](python-image.md#python-image-instructions)
+ [Java](java-image.md#java-image-instructions)
+ [Go](go-image.md#go-image-provided)
+ [.NET](csharp-image.md#csharp-image-instructions)
+ [Ruby](ruby-image.md#ruby-image-instructions)
## Utilizzo di un'immagine di AWS base solo per il sistema operativo
[AWS Le immagini di base solo](https://gallery.ecr.aws/lambda/provided) per il sistema operativo contengono una distribuzione Amazon Linux e l'emulatore [di interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Queste immagini vengono comunemente utilizzate per creare immagini di container per linguaggi compilati, come [Go](go-image.md#go-image-provided) e [Rust](lambda-rust.md), e per un linguaggio o una versione di linguaggio per cui Lambda non fornisce un'immagine di base, come Node.js 19. Puoi anche utilizzare immagini di base solo per il sistema operativo per implementare un [runtime personalizzato](runtimes-custom.md). Per rendere l'immagine compatibile con Lambda, devi includere nell'immagine un [client di interfaccia di runtime](#images-ric) per il tuo linguaggio.
| Tag | Runtime | Sistema operativo | Dockerfile | Raggiunta obsolescenza |
| --- | --- | --- | --- | --- |
| al2023 | Runtime solo per il sistema operativo | Amazon Linux 2023 | [Dockerfile per Runtime solo per sistema operativo su GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 30 giugno 2029 |
| al2 | Runtime solo per il sistema operativo | Amazon Linux 2 | [Dockerfile per Runtime solo per sistema operativo su GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | 31 luglio 2026 |
Galleria pubblica di Amazon Elastic Container Registry: [gallery.ecr. aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## Utilizzo di un'immagine non AWS di base
Lambda supporta qualsiasi immagine conforme a uno dei seguenti formati manifest per le immagini:
+ Docker Image Manifest V2 Schema 2 (utilizzato con Docker versione 1.10 e successive)
+ Open Container Initiative (OCI) Specifications (v1.0.0 e successive)
Lambda supporta una dimensione massima dell'immagine non compressa pari a 10 GB, inclusi tutti i livelli.
**Nota**
Per rendere l'immagine compatibile con Lambda, devi includere nell'immagine un [client di interfaccia di runtime](#images-ric) per il tuo linguaggio.
Per prestazioni ottimali, mantenere la dimensione del manifesto dell'immagine al di sotto di 25.400 byte. Per ridurre le dimensioni del manifesto dell'immagine, ridurre al minimo il numero di livelli nell'immagine e riduci le annotazioni.
## Client di interfaccia runtime
Se utilizzi un'[immagine di base solo per il sistema operativo](#runtimes-images-provided) o un'immagine di base alternativa, devi includere un client dell'interfaccia di runtime nell'immagine. Il client dell'interfaccia di runtime deve estendere[Utilizzo dell'API di runtime Lambda per runtime personalizzati](runtimes-api.md), che gestisce l'interazione tra Lambda e il codice della funzione. AWS fornisce client di interfaccia di runtime open source per le seguenti lingue:
+ [Node.js](nodejs-image.md#nodejs-image-clients)
+ [Python](python-image.md#python-image-clients)
+ [Java](java-image.md#java-image-clients)
+ [.NET](csharp-image.md#csharp-image-clients)
+ [Go](go-image.md#go-image-clients)
+ [Ruby](ruby-image.md#ruby-image-clients)
+ [Ruggine](lambda-rust.md) —
Se utilizzi un linguaggio che non dispone di un AWS client di interfaccia di runtime fornito, devi crearne uno tuo.
## Autorizzazioni Amazon ECR
Prima di creare la funzione Lambda da un'immagine di container, è necessario creare un'immagine del container in locale e caricarla in un repository Amazon ECR. Quando crei la funzione, specifica l'URI del repository Amazon ECR.
Assicurati che le autorizzazioni per l'utente o il ruolo che crea la funzione includano`GetRepositoryPolicy`, `SetRepositoryPolicy``BatchGetImage`, e. `GetDownloadUrlForLayer`
Ad esempio, utilizza la console IAM per creare un ruolo con la seguente policy:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"ecr:SetRepositoryPolicy",
"ecr:GetRepositoryPolicy",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world"
}
]
}
```
------
### Policy del repository Amazon ECR
Per una funzione nello stesso account dell'immagine di container in Amazon ECR, puoi aggiungere le autorizzazioni `ecr:BatchGetImage` e `ecr:GetDownloadUrlForLayer` alla policy del tuo repository Amazon ECR. L'esempio seguente mostra il valore minimo della policy.
```
{
"Sid": "LambdaECRImageRetrievalPolicy",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
]
}
```
Per ulteriori informazioni sulle autorizzazioni per il repository Amazon ECR, consulta la pagina [Policy dei repository privati](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html) nella *Guida per l'utente di Amazon Elastic Container Registry*.
Se il repository Amazon ECR non include queste autorizzazioni, Lambda tenta di aggiungerle automaticamente. Lambda può aggiungere autorizzazioni solo se l'entità principale che chiama Lambda dispone delle autorizzazioni `ecr:getRepositoryPolicy` e `ecr:setRepositoryPolicy`.
Per visualizzare o modificare le autorizzazioni del repository Amazon ECR, segui le istruzioni riportate nella pagina [Impostazione di un'istruzione di policy per i repository privati](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) della *Guida per l'utente di Amazon Elastic Container Registry*.
#### Autorizzazioni multiaccount Amazon ECR
Un account diverso nella stessa Regione può creare una funzione che utilizza un'immagine container di proprietà del tuo account. Nell'esempio seguente, la [policy delle autorizzazioni del repository Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) richiede le seguenti istruzioni per concedere l'accesso all'account numero 123456789012.
+ **CrossAccountPermission**— Consente all'account 123456789012 di creare e aggiornare funzioni Lambda che utilizzano immagini da questo repository ECR.
+ **Lambda**: ECRImage CrossAccountRetrievalPolicy Lambda alla fine imposterà lo stato di una funzione su inattivo se non viene richiamata per un periodo prolungato. Questa istruzione è necessaria affinché Lambda possa recuperare l'immagine del container per l'ottimizzazione e la memorizzazione nella cache per conto della funzione di proprietà di 123456789012.
**Example - Aggiunta di autorizzazioni multi-account al repository**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CrossAccountPermission",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
},
{
"Sid": "LambdaECRImageCrossAccountRetrievalPolicy",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Condition": {
"ArnLike": {
"aws:sourceARN": "arn:aws:lambda:us-east-1:123456789012:function:*"
}
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
}
]
}
```
Per consentire l'accesso a più account, aggiungi l'account IDs all'elenco Principal nella `CrossAccountPermission` policy e all'elenco di valutazione delle condizioni in. `LambdaECRImageCrossAccountRetrievalPolicy`
Se lavori con più account in un' AWS organizzazione, ti consigliamo di enumerare ogni ID account nella politica di autorizzazione ECR. Questo approccio è in linea con le migliori pratiche di AWS sicurezza che prevedono l'impostazione di autorizzazioni ristrette nelle policy IAM.
Oltre alle autorizzazioni Lambda, l'utente o il ruolo che crea la funzione deve disporre anche delle autorizzazioni `BatchGetImage` e `GetDownloadUrlForLayer`.
## Ciclo di vita delle funzioni
Dopo aver caricato un'immagine container nuova o aggiornata, Lambda ottimizza l'immagine prima che la funzione possa elaborare le chiamate. Il processo di ottimizzazione può richiedere alcuni secondi. La funzione rimane nello stato `Pending` fino al completamento del processo, quando lo stato passa a `Active`. Non è possibile richiamare la funzione fino a quando non raggiunge lo stato `Active`.
Se una funzione non viene richiamata per più settimane, Lambda recupera la sua versione ottimizzata e la funzione passa allo stato `Inactive`. Per riattivare la funzione, è necessario invocarla. Lambda rifiuta la prima invocazione e la funzione entra nello stato `Pending` finché Lambda non riottimizza l'immagine. La funzione ritorna quindi allo stato `Active`.
Lambda recupera periodicamente l'immagine di container associata dal repository Amazon ECR. Se l'immagine di container corrispondente non esiste più in Amazon ECR o le autorizzazioni sono state revocate, la funzione entra nello stato `Failed` e Lambda restituisce un errore per qualsiasi chiamata della funzione.
È possibile utilizzare l'API Lambda per ottenere informazioni sullo stato di una funzione. Per ulteriori informazioni, consulta [Stati funzione Lambda](functions-states.md).
# Configurare la memoria di una funzione Lambda
Lambda alloca la potenza della CPU in proporzione alla quantità di memoria configurata. *Memory (Memoria)* indica la quantità di memoria disponibile per la funzione Lambda in fase di runtime. È possibile aumentare o diminuire la memoria e la potenza della CPU assegnate alla funzione utilizzando l'impostazione **Memoria**. È possibile configurare memoria compresa tra 128 MB e 10.240 MB in incrementi di 1 MB. A 1.769 MB, una funzione ha l'equivalente di una vCPU (un vCPU-secondo di crediti al secondo).
In questa pagina viene descritto come e quando aggiornare l'impostazione della memoria per una funzione Lambda.
**Topics**
+ [
## Determinazione dell'impostazione di memoria appropriata per una funzione Lambda
](#configuration-memory-use-cases)
+ [
## Configurazione della memoria delle funzioni (console)
](#configuration-memory-console)
+ [
## Configurazione della memoria delle funzioni (AWS CLI)
](#configuration-memory-cli)
+ [
## Configurazione della memoria delle funzioni (AWS SAM)
](#configuration-memory-sam)
+ [
## Accettazione dei suggerimenti relativi alla memoria delle funzioni (console)
](#configuration-memory-optimization-accept)
## Determinazione dell'impostazione di memoria appropriata per una funzione Lambda
La memoria è la leva principale per controllare le prestazioni di una funzione. L'impostazione predefinita, 128 MB, è l'impostazione più bassa possibile. Ti consigliamo di utilizzare 128 MB solo per funzioni Lambda semplici, come quelle che trasformano e instradano gli eventi verso altri servizi AWS . Una allocazione maggiore della memoria può migliorare le prestazioni per le funzioni che utilizzano librerie importate, livelli [Lambda](chapter-layers.md), Amazon Simple Storage Service (Amazon S3) o Amazon Elastic File System (Amazon EFS). L'aggiunta di più memoria aumenta proporzionalmente la quantità di CPU, aumentando la potenza di calcolo complessiva disponibile. Se una funzione è collegata alla CPU, alla rete o alla memoria, l'aumento dell'impostazione della memoria può migliorarne notevolmente le prestazioni.
Per trovare la giusta configurazione di memoria, monitora le tue funzioni con Amazon CloudWatch e imposta allarmi se il consumo di memoria si avvicina ai massimi configurati. Questo può aiutare a identificare le funzioni legate alla memoria. Per le funzioni legate alla CPU e all'IO, anche il monitoraggio della durata può fornire informazioni. In questi casi, l'aumento della memoria può aiutare a risolvere i problemi di elaborazione o di rete.
Puoi anche prendere in considerazione l'utilizzo dello strumento open source [Power Tuning AWS Lambda](https://github.com/alexcasalboni/aws-lambda-power-tuning). Questo strumento consente AWS Step Functions di eseguire più versioni simultanee di una funzione Lambda con diverse allocazioni di memoria e misurare le prestazioni. La funzione di input viene eseguita nell' AWS account ed esegue chiamate HTTP in tempo reale e interazioni SDK, per misurare le probabili prestazioni in uno scenario di produzione live. Puoi anche implementare un CI/CD processo per utilizzare questo strumento per misurare automaticamente le prestazioni delle nuove funzioni che distribuisci.
## Configurazione della memoria delle funzioni (console)
È possibile configurare la memoria della funzione nella console Lambda.
**Per aggiornare la memoria di una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Seleziona la scheda **Configurazione**, quindi scegli **Configurazione generale**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/configuration-tab.png)
1. In **Configurazione generale**, scegli **Modifica**.
1. Per **Memoria**, impostare un valore compreso tra 128 MB e 10.240 MB.
1. Scegli **Save** (Salva).
## Configurazione della memoria delle funzioni (AWS CLI)
È possibile utilizzare il [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)comando per configurare la memoria della funzione.
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--memory-size 1024
```
## Configurazione della memoria delle funzioni (AWS SAM)
Per configurare la memoria per la tua funzione, puoi usare [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ). Aggiorna la [MemorySize](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-memorysize)proprietà nel tuo `template.yaml` file e poi esegui [sam deploy.](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 1024
# Other function properties...
```
## Accettazione dei suggerimenti relativi alla memoria delle funzioni (console)
Se disponi delle autorizzazioni di amministratore in AWS Identity and Access Management (IAM), puoi scegliere di ricevere consigli sulle impostazioni della memoria della funzione Lambda da. AWS Compute Optimizer Per istruzioni su come attivare i suggerimenti sulla memoria per il proprio account o la propria organizzazione, consultare [Accettazione delle opzioni nell'account](https://docs.aws.amazon.com/compute-optimizer/latest/ug/getting-started.html#account-opt-in) nella *Guida per l'utente di AWS Compute Optimizer *.
**Nota**
Compute Optimizer supporta solo le funzioni che utilizzano l'architettura x86\$164.
Dopo avere accettato le opzioni e se la [funzione Lambda soddisfa i requisiti del Sistema di ottimizzazione del calcolo](https://docs.aws.amazon.com/compute-optimizer/latest/ug/requirements.html#requirements-lambda-functions), puoi visualizzare e accettare i suggerimenti sulla memoria della funzione del Sistema di ottimizzazione del calcolo nella console Lambda in **Configurazione generale**.
# Configurare lo spazio di archiviazione temporaneo per le funzioni Lambda
Lambda fornisce uno spazio di archiviazione temporaneo per le funzioni nella directory `/tmp`. Questo spazio di archiviazione è temporaneo e unico per ogni ambiente di esecuzione. È possibile controllare la quantità di spazio di archiviazione temporaneo allocato alla funzione utilizzando l'impostazione **Archiviazione temporanea**. È possibile configurare uno spazio di archiviazione temporaneo compreso tra 512 MB e 10.240 MB in incrementi di 1 MB. Tutti i dati archiviati in `/tmp` vengono crittografati a riposo con una chiave gestita da AWS.
In questa pagina sono descritti i casi d'uso comuni e come aggiornare lo spazio di archiviazione temporanea per una funzione Lambda.
**Topics**
+ [
## Casi d'uso comuni per una maggiore archiviazione temporanea
](#configuration-ephemeral-storage-use-cases)
+ [
## Configurazione dell'archiviazione temporanea (console)
](#configuration-ephemeral-storage-console)
+ [
## Configurazione dello spazio di archiviazione temporanea (AWS CLI)
](#configuration-ephemeral-storage-cli)
+ [
## Configurazione dello spazio di archiviazione temporanea (AWS SAM)
](#configuration-ephemeral-storage-sam)
## Casi d'uso comuni per una maggiore archiviazione temporanea
Ecco alcuni casi d'uso comuni che traggono vantaggio dall'aumento dello spazio di archiviazione temporanea:
+ **Extract-transform-load Lavori (ETL):** aumenta lo storage temporaneo quando il codice esegue calcoli intermedi o scarica altre risorse per completare l'elaborazione. Più spazio temporaneo consente l'esecuzione di lavori ETL più complessi nelle funzioni Lambda.
+ **Inferenza con il machine learning (ML):** molte attività di inferenza si basano su file di dati di riferimento di grandi dimensioni, tra cui librerie e modelli. Con più spazio di archiviazione temporanea, puoi scaricare modelli più grandi da Amazon Simple Storage Service (Amazon S3) in `/tmp` e utilizzarli nell'elaborazione.
+ **Elaborazione dei dati:** per i carichi di lavoro che scaricano oggetti da Amazon S3 in risposta a eventi S3, più spazio `/tmp` consente di gestire oggetti più grandi senza utilizzare l'elaborazione in memoria. Anche i carichi di lavoro che creano PDFs o elaborano contenuti multimediali traggono vantaggio da uno storage più effimero.
+ **Elaborazione grafica:** l'elaborazione delle immagini è un caso d'uso comune per le applicazioni basate su Lambda. Per i carichi di lavoro che elaborano file TIFF di grandi dimensioni o immagini satellitari, uno spazio di archiviazione temporanea più grande semplifica l'uso delle librerie e l'esecuzione del calcolo in Lambda.
## Configurazione dell'archiviazione temporanea (console)
Puoi configurare lo spazio di archiviazione temporanea nella console Lambda.
**Per modificare lo spazio di archiviazione temporanea effimera per una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Seleziona la scheda **Configurazione**, quindi scegli **Configurazione generale**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/configuration-tab.png)
1. In **Configurazione generale**, scegli **Modifica**.
1. Per **Archiviazione temporanea**, imposta un valore compreso tra 512 MB e 10.240 MB in incrementi di 1 MB.
1. Scegli **Save** (Salva).
## Configurazione dello spazio di archiviazione temporanea (AWS CLI)
È possibile utilizzare il [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)comando per configurare l'archiviazione temporanea.
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--ephemeral-storage '{"Size": 1024}'
```
## Configurazione dello spazio di archiviazione temporanea (AWS SAM)
Per configurare lo spazio di archiviazione temporanea per la tua funzione, puoi usare [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ). Aggiorna la [EphemeralStorage](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-ephemeralstorage)proprietà nel tuo `template.yaml` file e poi esegui [sam deploy.](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs22.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
# Other function properties...
```
# Selezione e configurazione di un'architettura di set di istruzioni per la funzione Lambda
L'*architettura del set di istruzioni* di una funzione Lambda determina il tipo di processore del computer utilizzato da Lambda per eseguire la funzione. Lambda offre una scelta di architetture del set di istruzioni:
+ arm64 — Architettura ARM a 64 bit, per il processore Graviton2 AWS .
+ x86\$164: architettura x86 a 64 bit, per processori basati su x86.
**Nota**
L'architettura arm64 è disponibile nella maggior parte dei casi. Regioni AWS Per ulteriori informazioni, consultare [AWS Lambda Prezzi](https://aws.amazon.com//lambda/pricing/#aws-element-9ccd9262-b656-4d9c-8a72-34ee6b662135). Nella tabella dei prezzi della memoria, scegli la scheda **Arm Price**, quindi apri l'elenco a discesa **Region** per vedere quali Regioni AWS supportano arm64 con Lambda.
Per un esempio di come creare una funzione con l'architettura arm64, vedi [AWS Lambda Functions Powered](https://aws.amazon.com/blogs/aws/aws-lambda-functions-powered-by-aws-graviton2-processor-run-your-functions-on-arm-and-get-up-to-34-better-price-performance/) by Graviton2 Processor. AWS
**Topics**
+ [
## Vantaggi dell'utilizzo dell'architettura arm64
](#foundation-arch-adv)
+ [
## Requisiti per la migrazione all'architettura arm64
](#foundation-arch-consider)
+ [
## Compatibilità del codice della funzione con l'architettura arm64
](#foundation-arch-considerations)
+ [
## Come eseguire la migrazione all'architettura arm64
](#foundation-arch-steps)
+ [
## Configurazione dell'architettura del set di istruzioni
](#foundation-arch-config)
## Vantaggi dell'utilizzo dell'architettura arm64
Le funzioni Lambda che utilizzano l'architettura arm64 (processore AWS Graviton2) possono ottenere prezzi e prestazioni significativamente migliori rispetto alla funzione equivalente in esecuzione sull'architettura x86\$164. Prendi in considerazione l'utilizzo di arm64 per applicazioni ad uso intensivo di calcolo come computing ad alte prestazioni, codifica video e carichi di lavoro di simulazione.
La CPU Graviton2 utilizza il core Neoverse N1 e supporta Armv8.2 (incluse le estensioni CRC e crittografiche) oltre a diverse altre estensioni architettoniche.
Graviton2 riduce il tempo di lettura della memoria fornendo una cache L2 maggiore per vCPU, che migliora le prestazioni di latenza dei back-end Web e per dispositivi mobili, dei microservizi e dei sistemi di elaborazione dati. Inoltre, Graviton2 offre prestazioni di crittografia migliorate e supporta set di istruzioni che migliorano la latenza dell'inferenza di machine learning basata sulla CPU.
[Per ulteriori informazioni su Graviton2, vedere Graviton Processor. AWSAWS](https://aws.amazon.com/ec2/graviton)
## Requisiti per la migrazione all'architettura arm64
Quando selezioni una funzione Lambda per migrare all'architettura arm64, per garantire una migrazione fluida assicurati che la tua funzione soddisfi i seguenti requisiti:
+ Il pacchetto di implementazione contiene solo componenti open source e codice sorgente sotto il tuo controllo, in modo da poter apportare tutti gli aggiornamenti necessari per la migrazione.
+ Se il codice delle funzione include dipendenze di terze parti, ogni libreria o pacchetto fornisce una versione arm64.
## Compatibilità del codice della funzione con l'architettura arm64
Il codice della funzione Lambda deve essere compatibile con l'architettura del set di istruzioni della funzione. Prima di migrare una funzione all'architettura arm64, tieni presente le seguenti osservazioni sul codice della funzione corrente:
+ Se hai aggiunto il codice della funzione utilizzando l'editor di codice incorporato, probabilmente è possibile eseguire il codice su entrambe le architetture senza modifiche.
+ Se il codice della funzione è stato caricato, è necessario caricare un nuovo codice compatibile con l'architettura specifica.
+ Se la funzione utilizza livelli, è necessario [controllare ogni livello](adding-layers.md#finding-layer-information) per garantire che sia compatibile con la nuova architettura. Se un livello non è compatibile, modifica la funzione per sostituire la versione del livello corrente con una versione del livello compatibile.
+ Se la tua funzione utilizza estensioni Lambda, è necessario controllare ciascuna estensione per assicurarsi che sia compatibile con la nuova architettura.
+ Se la funzione usa un tipo di pacchetto di distribuzione dell'immagine del container, è necessario creare una nuova immagine del container compatibile con l'architettura della funzione.
## Come eseguire la migrazione all'architettura arm64
Per migrare una funzione Lambda all'architettura arm64, ti consigliamo di seguire questi passaggi:
1. Crea l'elenco di dipendenze per l'applicazione o il carico di lavoro. Le dipendenze comuni includono:
+ Tutte le librerie e i pacchetti utilizzati dalla funzione.
+ Gli strumenti utilizzati per creare, distribuire e testare la funzione, come compilatori, suite di test, pipeline di integrazione continua e distribuzione continua (CI/CD), strumenti di provisioning e script.
+ Le estensioni Lambda e gli strumenti di terza parte utilizzati per monitorare la funzione in produzione.
1. Per ciascuna delle dipendenze, controlla la versione e verifica se sono disponibili versioni arm64.
1. Crea un ambiente per eseguire la migrazione dell'applicazione.
1. Esegui il bootstrap dell'applicazione.
1. Test e debugging dell'applicazione.
1. Testa le prestazioni della funzione arm64. Confronta le prestazioni con la versione x86\$164.
1. Aggiorna la pipeline dell'infrastruttura per supportare le funzioni arm64 Lambda.
1. Simula l'implementazione per la produzione.
Ad esempio, è possibile usare la [configurazione del routing dell'alias](configuring-alias-routing.md) per dividere il traffico tra le versioni x86 e arm64 della funzione e confrontare le prestazioni e la latenza.
[Per ulteriori informazioni su come creare un ambiente di codice per l'architettura arm64, incluse informazioni specifiche del linguaggio per Java, Go, .NET e Python, consulta il repository Getting started with Graviton. AWS](https://github.com/aws/aws-graviton-getting-started) GitHub
## Configurazione dell'architettura del set di istruzioni
Puoi configurare l'architettura del set di istruzioni per funzioni Lambda nuove ed esistenti utilizzando la console Lambda, AWS SDKs, AWS Command Line Interface ()AWS CLI o. CloudFormation Completa questa procedura per modificare l'architettura del set di istruzioni per una funzione Lambda esistente dalla console.
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli il nome della funzione per la quale desideri configurare l'architettura del set di istruzioni.
1. Nella scheda **Codice** principale, per la sezione **Impostazioni di runtime**, scegli **Modifica**.
1. In **Architettura**, scegli l'architettura del set di istruzioni da utilizzare per la funzione.
1. Scegli **Save** (Salva).
# Configurare il timeout della funzione Lambda
Lambda esegue il codice per un determinato periodo di tempo prima del timeout. Il *timeout* è il tempo massimo in secondi in cui una funzione Lambda può essere eseguita. Il valore predefinito per questa impostazione è 3 secondi, ma è possibile regolarlo con incrementi di 1 secondo fino a un valore massimo di 900 secondi (15 minuti).
In questa pagina viene descritto come e quando aggiornare l'impostazione di timeout per una funzione Lambda.
**Topics**
+ [
## Determinazione del valore di timeout appropriato per una funzione Lambda
](#configuration-timeout-use-cases)
+ [
## Configurazione del timeout (console)
](#configuration-timeout-console)
+ [
## Configurazione del timeout (AWS CLI)
](#configuration-timeout-cli)
+ [
## Configurazione del timeout (AWS SAM)
](#configuration-timeout-sam)
## Determinazione del valore di timeout appropriato per una funzione Lambda
Se un valore di timeout viene impostato vicino alla durata media di una funzione, c'è un rischio elevato che la funzione scada inaspettatamente. La durata di una funzione può variare in base alla quantità di trasferimento ed elaborazione dei dati e alla latenza dei servizi con cui interagisce la funzione. Alcune cause comuni di timeout includono:
+ I download da Amazon Simple Storage Service (Amazon S3) sono di dimensioni maggiori o richiedono più tempo della media.
+ Una funzione invia una richiesta a un altro servizio, che impiega più tempo a rispondere.
+ I parametri forniti a una funzione richiedono una maggiore complessità computazionale della funzione, il che fa sì che l'invocazione richieda più tempo.
Nel testare l'applicazione, assicurati che i test riflettano accuratamente la dimensione e la quantità di dati e valori realistici dei parametri. I test utilizzano spesso campioni di piccole dimensioni per comodità, ma è consigliabile utilizzare set di dati al limite massimo di quanto ragionevolmente previsto per il carico di lavoro.
## Configurazione del timeout (console)
Puoi configurare il timeout della funzione nella console Lambda.
**Per modificare il timeout di una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Seleziona la scheda **Configurazione**, quindi scegli **Configurazione generale**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/configuration-tab.png)
1. In **Configurazione generale**, scegli **Modifica**.
1. Per **Timeout**, imposta un valore compreso tra 1 e 900 secondi (15 minuti).
1. Scegli **Save** (Salva).
## Configurazione del timeout (AWS CLI)
È possibile utilizzare il [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)comando per configurare il valore di timeout, in secondi. Il comando di esempio seguente aumenta il timeout della funzione a 120 secondi (2 minuti).
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--timeout 120
```
## Configurazione del timeout (AWS SAM)
Per configurare il valore di timeout per la tua funzione, puoi usare [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ). Aggiorna la proprietà [Timeout](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-timeout) nel file `template.yaml` e poi esegui [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html).
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
# Other function properties...
```
# Configura le funzioni durevoli Lambda
Per consentire l'esecuzione duratura della funzione Lambda, è necessario configurare impostazioni specifiche che controllino per quanto tempo può essere eseguita la funzione, per quanto tempo vengono conservati i dati sullo stato e quali autorizzazioni sono richieste.
## Abilita un'esecuzione duratura
Per abilitare l'esecuzione durevole della tua funzione Lambda, configurala `DurableConfig` nella configurazione della tua funzione. Questa impostazione controlla il timeout di esecuzione, il mantenimento dello stato e il comportamento di controllo delle versioni.
------
#### [ AWS CLI ]
```
aws lambda update-function-configuration \
--function-name my-durable-function \
--durable-config '{
"ExecutionTimeout": 3600,
"RetentionPeriodInDays": 30,
"AllowInvokeLatest": true
}'
```
------
#### [ CloudFormation ]
```
Resources:
MyDurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: my-durable-function
Runtime: nodejs18.x
Handler: index.handler
Code:
ZipFile: |
// Your durable function code
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 30
AllowInvokeLatest: true
```
------
**Parametri di configurazione:**
+ `ExecutionTimeout`- Tempo massimo di esecuzione in secondi (fino a 31.536.000 per un anno)
+ `RetentionPeriodInDays`- Per quanto tempo conservare lo stato e la cronologia di esecuzione (1-365 giorni)
+ `AllowInvokeLatest`- Se consentire l'invocazione della versione \$1LATEST per un'esecuzione duratura
## Autorizzazioni IAM per funzioni durevoli
Le funzioni durevoli richiedono autorizzazioni IAM aggiuntive oltre ai ruoli di esecuzione Lambda standard. Il ruolo di esecuzione della funzione deve includere le autorizzazioni per la gestione dello stato e l'esecuzione duratura. APIs
**Autorizzazioni minime richieste:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ManageDurableState",
"lambda:GetDurableExecution",
"lambda:ListDurableExecutions"
],
"Resource": "arn:aws:lambda:*:*:function:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
**CloudFormation esempio di ruolo di esecuzione:**
```
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: DurableFunctionPolicy
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action:
- lambda:ManageDurableState
- lambda:GetDurableExecution
- lambda:ListDurableExecutions
Resource: '*'
```
## Best practice per la configurazione
Segui queste best practice per configurare funzioni durevoli per l'uso in produzione:
+ **Imposta i timeout di esecuzione appropriati**: configura `ExecutionTimeout` in base alla durata massima prevista del flusso di lavoro. Non impostate timeout inutilmente lunghi poiché influiscono sull'allocazione dei costi e delle risorse.
+ **Bilancia la conservazione con i costi di archiviazione**: imposta in `RetentionPeriodInDays` base ai requisiti di debug e audit. Periodi di conservazione più lunghi aumentano i costi di storage.
+ **Usa il controllo delle versioni in produzione**: imposta l'`AllowInvokeLatest`opzione `false` negli ambienti di produzione e utilizza versioni di funzioni o alias specifici per esecuzioni durature.
+ **Monitora le dimensioni dello stato**: gli oggetti a stato di grandi dimensioni aumentano i costi di storage e possono influire sulle prestazioni. Riduci al minimo lo stato e utilizza lo storage esterno per dati di grandi dimensioni.
+ **Configura la registrazione appropriata**: abilita la registrazione dettagliata per la risoluzione dei problemi dei flussi di lavoro a lunga durata, ma fai attenzione al volume e ai costi dei log.
**Esempio di configurazione di produzione:**
```
{
"ExecutionTimeout": 86400,
"RetentionPeriodInDays": 7,
"AllowInvokeLatest": false
}
```
# Utilizzo delle variabili di ambiente Lambda
È possibile utilizzare le variabili di ambiente per regolare il comportamento della funzione senza aggiornare il codice. Una variabile di ambiente è una coppia di stringhe archiviata nella configurazione specifica della versione di una funzione. Il runtime Lambda rende le variabili di ambiente disponibili per il codice e imposta variabili di ambiente aggiuntive che contengono informazioni sulla richiesta di funzione e invocazione.
**Nota**
Per aumentare la sicurezza, consigliamo di utilizzare Gestione dei segreti AWS al posto delle variabili di ambiente per archiviare le credenziali del database e altre informazioni sensibili come chiavi API o token di autorizzazione. Per ulteriori informazioni, consulta [Uso dei segreti in Secrets Manager nelle funzioni Lambda](with-secrets-manager.md).
Le variabili di ambiente non vengono valutate prima dell'invocazione della funzione. Qualsiasi valore definito è considerato una stringa letterale e non espanso. Eseguire la valutazione della variabile nel codice funzione.
## Creazione delle variabili di ambiente Lambda
Puoi configurare le variabili di ambiente in Lambda utilizzando la console Lambda, (), AWS Command Line Interface (AWS CLI) o utilizzando un AWS SAM SDK. AWS Serverless Application Model AWS
------
#### [ Console ]
Puoi definire le variabili di ambiente sulla versione non pubblicata della funzione. Quando pubblichi una versione, le variabili di ambiente sono bloccate per quella versione insieme ad altre [impostazioni di configurazioni specifiche della versione](configuration-versions.md).
È possibile creare una variabile di ambiente per la funzione definendo una chiave e un valore. La funzione utilizza il nome della chiave per recuperare il valore della variabile di ambiente.
**Per impostare le variabili di ambiente nella console Lambda**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Scegli **Configurazione**, quindi scegli **Variabili di ambiente**.
1. In **Environment variables (Variabili di ambiente)**, scegliere **Edit (Modifica)**.
1. Scegli **Add environment variable (Aggiungi variabile d'ambiente)**.
1. Inserisci una coppia chiave valore.
**Requisiti**
+ Le chiavi iniziano con una lettera e sono di almeno due caratteri.
+ Le chiavi contengono solo lettere, numeri e il carattere di sottolineatura (`_`).
+ Le chiavi non sono [riservate da Lambda](#configuration-envvars-runtime).
+ La dimensione totale di tutte le variabili di ambiente non supera i 4 KB.
1. Scegli **Save** (Salva).
**Generazione di un elenco di variabili di ambiente nell'editor di codice della console**
Puoi generare un elenco di variabili di ambiente nell'editor di codice Lambda. È un modo rapido per fare riferimento alle variabili di ambiente durante la scrittura del codice.
1. Scegli la scheda **Codice**.
1. Scorri verso il basso fino alla sezione **VARIABILI DI AMBIENTE** dell'editor di codice. Le variabili di ambiente esistenti sono elencate qui:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/env-var.png)
1. Per creare nuove variabili di ambiente, scegli il segno più (![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/add-plus.png)):
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/create-env-var.png)
Le variabili di ambiente rimangono crittografate quando sono elencate nell'editor di codice della console. Se hai abilitato gli helper di crittografia per la crittografia in transito, tali impostazioni rimangono invariate. Per ulteriori informazioni, consulta [Protezione delle variabili di ambiente Lambda](configuration-envvars-encryption.md).
L'elenco delle variabili di ambiente è di sola lettura ed è disponibile solo nella console Lambda. Questo file non è incluso quando scarichi l'archivio di file .zip della funzione e non è possibile aggiungere variabili di ambiente caricando questo file.
------
#### [ AWS CLI ]
L'esempio seguente imposta due variabili di ambiente in una funzione denominata `my-function`.
```
aws lambda update-function-configuration \
--function-name my-function \
--environment "Variables={BUCKET=amzn-s3-demo-bucket,KEY=file.txt}"
```
Quando applichi le variabili di ambiente con il comando `update-function-configuration`, viene sostituito l'intero contenuto della struttura `Variables`. Per mantenere le variabili di ambiente esistenti quando ne aggiungi una nuova, includi tutti i valori esistenti nella richiesta.
Per ottenere la configurazione corrente, utilizza il comando `get-function-configuration`.
```
aws lambda get-function-configuration \
--function-name my-function
```
Verrà visualizzato l’output seguente:
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:111122223333:function:my-function",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::111122223333:role/lambda-role",
"Environment": {
"Variables": {
"BUCKET": "amzn-s3-demo-bucket",
"KEY": "file.txt"
}
},
"RevisionId": "0894d3c1-2a3d-4d48-bf7f-abade99f3c15",
...
}
```
È possibile passare l'ID di revisione dall'output di `get-function-configuration` come parametro a `update-function-configuration`. Ciò garantisce che i valori non cambino da quando leggi la configurazione a quando la aggiorni.
Per configurare la chiave di crittografia di una funzione, imposta l'opzione `KMSKeyARN`.
```
aws lambda update-function-configuration \
--function-name my-function \
--kms-key-arn arn:aws:kms:us-east-2:111122223333:key/055efbb4-xmpl-4336-ba9c-538c7d31f599
```
------
#### [ AWS SAM ]
Per configurare le variabili di ambiente per la tua funzione, puoi utilizzare [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ). Aggiorna le proprietà [Environment](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment) e [Variables](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-environment.html#cfn-lambda-function-environment-variables) nel tuo file `template.yaml`, quindi esegui [sam deploy.](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs24.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
Environment:
Variables:
BUCKET: amzn-s3-demo-bucket
KEY: file.txt
# Other function properties...
```
------
#### [ AWS SDKs ]
Per gestire le variabili di ambiente utilizzando un AWS SDK, utilizzate le seguenti operazioni API.
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
Per ulteriori informazioni, consulta la [documentazione dell'SDK AWS](https://aws.amazon.com/developer/tools/) relativa al linguaggio di programmazione preferito.
------
## Scenario di esempio per le variabili di ambiente
È possibile utilizzare le variabili di ambiente per personalizzare il comportamento delle funzioni nell'ambiente di test e nell'ambiente di produzione. Ad esempio, puoi creare due funzioni con stesso codice ma configurazione diversa. Una funzione si connette a un database di test e l'altra a un database di produzione. In questo caso, puoi utilizzare le variabili di ambiente per passare alla funzione il nome host e altri dettagli di connessione per il database.
Nell'esempio seguente viene illustrato come definire l'host del database e il nome del database come variabili di ambiente.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/console-env.png)
Se si desidera che l'ambiente di test generi più informazioni di debug rispetto all'ambiente di produzione, è possibile impostare una variabile di ambiente per configurare l'ambiente di test in modo da utilizzare una registrazione più dettagliata o una traccia più dettagliata.
Ad esempio, nell'ambiente di test, è possibile impostare una variabile di ambiente con la chiave `LOG_LEVEL` e un valore che indica un livello di log di debug o trace. Nel codice della funzione Lambda, puoi quindi utilizzare questa variabile di ambiente per impostare il livello di log.
I seguenti esempi di codice in Python e Node.js illustrano come è possibile raggiungere questo obiettivo. Questi esempi presuppongono che la variabile di ambiente abbia un valore `DEBUG` in Python o `debug` in Node.js.
------
#### [ Python ]
**Example Codice Python per impostare il livello di log**
```
import os
import logging
# Initialize the logger
logger = logging.getLogger()
# Get the log level from the environment variable and default to INFO if not set
log_level = os.environ.get('LOG_LEVEL', 'INFO')
# Set the log level
logger.setLevel(log_level)
def lambda_handler(event, context):
# Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment')
logger.info('This is a log with standard information - shown in production and test environments')
```
------
#### [ Node.js (ES module format) ]
**Example Codice Node.js per impostare il livello di log**
Questo esempio utilizza la libreria di registrazione `winston`. Usa npm per aggiungere questa libreria al pacchetto di implementazione della funzione. Per ulteriori informazioni, consulta [Creazione di un pacchetto di implementazione .zip con dipendenze](nodejs-package.md#nodejs-package-create-dependencies).
```
import winston from 'winston';
// Initialize the logger using the log level from environment variables, defaulting to INFO if not set
const logger = winston.createLogger({
level: process.env.LOG_LEVEL || 'info',
format: winston.format.json(),
transports: [new winston.transports.Console()]
});
export const handler = async (event) => {
// Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment');
logger.info('This is a log with standard information - shown in production and test environment');
};
```
------
## Recupero delle variabili di ambiente Lambda
Per recuperare le variabili di ambiente nel codice della funzione, utilizza il metodo standard per il linguaggio di programmazione.
------
#### [ Node.js ]
```
let region = process.env.AWS_REGION
```
------
#### [ Python ]
```
import os
region = os.environ['AWS_REGION']
```
**Nota**
In alcuni casi, potrebbe essere necessario utilizzare il seguente formato:
```
region = os.environ.get('AWS_REGION')
```
------
#### [ Ruby ]
```
region = ENV["AWS_REGION"]
```
------
#### [ Java ]
```
String region = System.getenv("AWS_REGION");
```
------
#### [ Go ]
```
var region = os.Getenv("AWS_REGION")
```
------
#### [ C\$1 ]
```
string region = Environment.GetEnvironmentVariable("AWS_REGION");
```
------
#### [ PowerShell ]
```
$region = $env:AWS_REGION
```
------
Lambda memorizza le variabili di ambiente in modo sicuro crittografandole quando inattive. Puoi [configurare Lambda per utilizzare una chiave di crittografia diversa](configuration-envvars-encryption.md), crittografare i valori delle variabili di ambiente sul lato client o impostare le variabili di ambiente in un CloudFormation modello con. Gestione dei segreti AWS
## Variabili di ambiente di runtime definite
I [tempi di esecuzione](lambda-runtimes.md) Lambda impostano diverse variabili di ambiente durante l'inizializzazione. La maggior parte delle variabili di ambiente fornisce informazioni sulla funzione o sul runtime. Le chiavi per queste variabili di ambiente sono *riservate* e non possono essere impostate nella configurazione della funzione.
**Variabili d'ambiente riservate**
+ `_HANDLER`: la posizione del gestore configurata nella funzione.
+ `_X_AMZN_TRACE_ID`: l'[intestazione di traccia X-Ray](services-xray.md). Questa variabile di ambiente cambia a ogni invocazione.
+ Questa variabile di ambiente non è definita per i runtime solo per il sistema operativo (la famiglia di runtime `provided`). Puoi impostare `_X_AMZN_TRACE_ID` per runtime personalizzati utilizzando l'intestazione di risposta `Lambda-Runtime-Trace-Id` dal [Chiamata successiva](runtimes-api.md#runtimes-api-next).
+ Per le versioni di runtime Java 17 e successive, questa variabile di ambiente non viene utilizzata. Lambda archivia invece le informazioni di tracciamento nella proprietà di sistema `com.amazonaws.xray.traceHeader`.
+ `AWS_DEFAULT_REGION`— L'impostazione predefinita Regione AWS in cui viene eseguita la funzione Lambda.
+ `AWS_REGION`— Il Regione AWS luogo in cui viene eseguita la funzione Lambda. Se immesso, questo valore sovrascrive `AWS_DEFAULT_REGION`.
+ Per ulteriori informazioni sull'utilizzo delle variabili di Regione AWS ambiente con AWS SDKs, vedete [AWS Region nella AWS](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html#feature-region-sdk-compat) *SDKs and Tools Reference Guide*.
+ `AWS_EXECUTION_ENV`: l'[identificatore di runtime](lambda-runtimes.md), preceduto da `AWS_Lambda_`, ad esempio `AWS_Lambda_java8`. Questa variabile di ambiente non è definita per i runtime solo per il sistema operativo (la famiglia di runtime `provided`).
+ `AWS_LAMBDA_FUNCTION_NAME`: il nome della funzione.
+ `AWS_LAMBDA_FUNCTION_MEMORY_SIZE`: la quantità di memoria disponibile per la funzione in MB.
+ `AWS_LAMBDA_FUNCTION_VERSION`: la versione della funzione in esecuzione.
+ `AWS_LAMBDA_INITIALIZATION_TYPE`— Il tipo di inizializzazione della funzione, che è`on-demand`, `provisioned-concurrency``snap-start`, o`lambda-managed-instances`. Per informazioni, vedere [Configurazione della concorrenza fornita, o](provisioned-concurrency.md). [Migliorare le prestazioni di avvio con Lambda SnapStart](snapstart.md) [Istanze Lambda gestite](lambda-managed-instances.md)
+ `AWS_LAMBDA_LOG_GROUP_NAME`, `AWS_LAMBDA_LOG_STREAM_NAME` — Il nome del gruppo e dello stream Amazon CloudWatch Logs per la funzione. Le [variabili di `AWS_LAMBDA_LOG_STREAM_NAME` ambiente `AWS_LAMBDA_LOG_GROUP_NAME`](#configuration-envvars-runtime) e non sono disponibili nelle funzioni Lambda SnapStart .
+ `AWS_ACCESS_KEY`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`: le chiavi di accesso ottenute dal [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione.
+ `AWS_LAMBDA_RUNTIME_API`: ([Runtime personalizzato](runtimes-custom.md)) L'host e la porta dell'[API di runtime](runtimes-api.md).
+ `LAMBDA_TASK_ROOT`: il percorso del codice della funzione Lambda.
+ `LAMBDA_RUNTIME_DIR`: il percorso delle librerie di runtime.
+ `AWS_LAMBDA_MAX_CONCURRENCY`— (Solo istanze gestite Lambda) Il numero massimo di chiamate simultanee che Lambda invierà a un ambiente di esecuzione.
+ `AWS_LAMBDA_METADATA_API`— L'indirizzo del server [endpoint dei metadati](configuration-metadata-endpoint.md) nel formato (ad esempio,). `{ipv4_address}:{port}` `169.254.100.1:9001`
+ `AWS_LAMBDA_METADATA_TOKEN`[— Un token di autenticazione unico per l'ambiente di esecuzione corrente utilizzato per autenticare le richieste all'endpoint di metadati.](configuration-metadata-endpoint.md) Lambda genera questo token automaticamente al momento dell'inizializzazione.
Le seguenti variabili di ambiente aggiuntive non sono riservate e possono essere estese nella configurazione della funzione.
**Variabili d'ambiente non riservate**
+ `LANG` – Le impostazioni locali del runtime (`en_US.UTF-8`).
+ `PATH`: il percorso di esecuzione (`/usr/local/bin:/usr/bin/:/bin:/opt/bin`).
+ `LD_LIBRARY_PATH`: il percorso della libreria di sistema (`/var/lang/lib:/lib64:/usr/lib64:$LAMBDA_RUNTIME_DIR:$LAMBDA_RUNTIME_DIR/lib:$LAMBDA_TASK_ROOT:$LAMBDA_TASK_ROOT/lib:/opt/lib`).
+ `NODE_PATH` – ([Node.js](lambda-nodejs.md)) Il percorso della libreria Node.js (`/opt/nodejs/node12/node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules`).
+ `NODE_OPTIONS`: ([Node.js](lambda-nodejs.md)) per i runtime Node.js, puoi utilizzare `NODE_OPTIONS` per riattivare le funzionalità sperimentali che Lambda disabilita per impostazione predefinita.
+ `PYTHONPATH`: ([Python](lambda-python.md)) il percorso della libreria Python (`$LAMBDA_RUNTIME_DIR`).
+ `GEM_PATH` – ([Ruby](lambda-ruby.md)) Il percorso della libreria Ruby (`$LAMBDA_TASK_ROOT/vendor/bundle/ruby/3.3.0:/opt/ruby/gems/3.3.0`).
+ `AWS_XRAY_CONTEXT_MISSING` – Per il tracciamento X-Ray, Lambda imposta questo valore su `LOG_ERROR` per evitare di generare errori di runtime dall'SDK X-Ray.
+ `AWS_XRAY_DAEMON_ADDRESS` – Per il tracciamento X-Ray, l'indirizzo IP e la porta del daemon X-Ray.
+ `AWS_LAMBDA_DOTNET_PREJIT`: ([.NET](lambda-csharp.md)) imposta questa variabile per abilitare o disabilitare le ottimizzazioni di runtime specifiche di .NET. I valori includono `always`, `never` e `provisioned-concurrency`. Per ulteriori informazioni, consulta [Configurazione della simultaneità fornita per una funzione](provisioned-concurrency.md).
+ `TZ`: il fuso orario dell'ambiente (`:UTC`). L'ambiente di esecuzione utilizza NTP per sincronizzare l'orologio di sistema.
I valori di esempio mostrati riflettono i runtime più recenti. La presenza di variabili specifiche o dei loro valori può variare nei runtime precedenti.
# Protezione delle variabili di ambiente Lambda
Per proteggere le variabili di ambiente, è possibile utilizzare la crittografia lato server per proteggere i dati inattivi e la crittografia lato client per proteggere i dati in transito.
**Nota**
Per aumentare la sicurezza del database, si consiglia di utilizzare Gestione dei segreti AWS al posto delle variabili di ambiente per archiviare le credenziali del database. Per ulteriori informazioni, consulta [Uso dei segreti in Secrets Manager nelle funzioni Lambda](with-secrets-manager.md).
**Sicurezza dei dati inattivi**
Lambda fornisce sempre la crittografia lato server dei dati inattivi con un AWS KMS key. Per impostazione predefinita, Lambda utilizza un Chiave gestita da AWS. Se questo comportamento predefinito si adatta al flusso di lavoro, non è necessario impostare altro. Lambda li crea Chiave gestita da AWS nel tuo account e gestisce le autorizzazioni per te. AWS non ti addebita alcun costo per l'utilizzo di questa chiave.
Se preferisci, puoi invece fornire una chiave gestita AWS KMS dal cliente. È possibile eseguire questa operazione per avere il controllo sulla rotazione della chiave KMS o per soddisfare i requisiti dell'organizzazione per la gestione delle chiavi KMS. Quando si utilizza la chiave gestita dal cliente, solo gli utenti del tuo account con accesso alla chiave possono visualizzare o gestire le variabili di ambiente sulla funzione.
Le chiavi gestite dal cliente sono soggette a costi standard AWS KMS . Per ulteriori informazioni, consultare [Prezzi di AWS Key Management Service](https://aws.amazon.com/kms/pricing/).
**Sicurezza in transito**
Per una maggiore sicurezza, è possibile abilitare gli helper per la crittografia in transito, assicurando così che le variabili di ambiente siano crittografate lato client per la protezione in transito.
**Per configurare la crittografia per le variabili di ambiente**
1. Usa AWS Key Management Service (AWS KMS) per creare qualsiasi chiave gestita dal cliente che Lambda possa utilizzare per la crittografia lato server e lato client. Per ulteriori informazioni, consulta [Creazione di chiavi](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) nella *AWS Key Management Service Guida per gli sviluppatori di *.
1. Utilizzando la console Lambda, accedere alla pagina **Edit environment variables (Modifica delle variabili di ambiente)**.
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Scegliere **Configurazione**, quindi scegliere **Variabili di ambiente** nella barra di navigazione sinistra.
1. Nella sezione **Variabili di ambiente**, scegliere **Modifica**.
1. Espandere **Encryption configuration (Configurazione della crittografia)**.
1. (Facoltativo) Abilita gli helper di crittografia della console per utilizzare la crittografia lato client per proteggere i dati in transito.
1. In **Crittografia in transito**, scegliere **Enable helpers for encryption in transit (Abilita helper per la crittografia in transito)**.
1. Per ogni variabile di ambiente per cui si desidera abilitare gli helper di crittografia della console, scegliere **Encrypt** (Crittografia) accanto alla variabile di ambiente.
1. In AWS KMS key Per crittografare in transito, scegli una chiave gestita dal cliente che hai creato all'inizio di questa procedura.
1. Scegliere **Execution role policy (Policy del ruolo di esecuzione)** e copiare la policy. Questa policy concede l'autorizzazione al ruolo di esecuzione della funzione per decrittare le variabili di ambiente.
Salvare la policy da utilizzare nell'ultima fase di questa procedura.
1. Aggiungi il codice alla funzione che decritta le variabili di ambiente. Per visualizzare un esempio, scegli **Decritta frammento di segreto**.
1. (Facoltativo) Specifica la chiave gestita dal cliente per la crittografia dei dati inattivi.
1. Scegliere **Use a customer master key (Utilizza una chiave master del cliente)**.
1. Scegliere una chiave gestita dal cliente creata all'inizio di questa procedura.
1. Scegli **Save** (Salva).
1. Impostare le autorizzazioni.
Se stai utilizzando una chiave gestita dal cliente con crittografia lato server, concedi le autorizzazioni a qualsiasi utente o ruolo che desideri possa visualizzare o gestire le variabili di ambiente sulla funzione. Per ulteriori informazioni, consulta [Gestione delle autorizzazioni per la chiave KMS di crittografia lato server](#managing-permissions-to-your-server-side-encryption-key).
Se si abilita la crittografia lato client per la sicurezza in transito, la funzione richiede l'autorizzazione per chiamare l'operazione API `kms:Decrypt`. Aggiungere la policy salvata in precedenza in questa procedura al [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione.
## Gestione delle autorizzazioni per la chiave KMS di crittografia lato server
Non sono necessarie AWS KMS autorizzazioni affinché l'utente o il ruolo di esecuzione della funzione utilizzino la chiave di crittografia predefinita. Per utilizzare una chiave gestita dal cliente, occorre l'autorizzazione all'utilizzo della chiave. Lambda utilizza queste autorizzazioni per creare una concessione sulla chiave. Questo consente a Lambda di usarla per la crittografia.
+ `kms:ListAliases` – Per visualizzare i tasti nella console Lambda.
+ `kms:CreateGrant`, `kms:Encrypt` – Per configurare una chiave gestita dal cliente su una funzione.
+ `kms:Decrypt` – Per visualizzare e gestire le variabili di ambiente crittografate con la chiave gestita dal cliente.
Puoi ottenere queste autorizzazioni dalla tua politica di autorizzazioni basata sulle risorse Account AWS o sulla politica delle autorizzazioni basata sulle risorse di una chiave. `ListAliases`è fornito dalle [policy gestite per Lambda](access-control-identity-based.md). Le policy della chiave concedono le autorizzazioni rimanenti agli utenti del gruppo **Key users (Utenti chiave)**.
Gli utenti senza autorizzazioni `Decrypt` possono comunque gestire le funzioni, ma non possono visualizzare le variabili di ambiente o gestirle nella console Lambda. Per impedire a un utente di visualizzare le variabili di ambiente, aggiungere un'istruzione alle autorizzazioni dell'utente che nega l'accesso alla chiave predefinita, a una chiave gestita dal cliente o a tutte le chiavi.
**Example Policy IAM: negano l'accesso in base all'ARN della chiave**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Deny",
"Action": [
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-2:111122223333:key/3be10e2d-xmpl-4be4-bc9d-0405a71945cc"
}
]
}
```
Per informazioni dettagliate sulla gestione delle autorizzazioni delle chiavi, consulta la pagina [Utilizzo delle policy delle chiavi in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) nella *Guida per gli sviluppatori di AWS Key Management Service *.
# Consentire alle funzioni Lambda l'accesso alle risorse in un Amazon VPC
Con Amazon Virtual Private Cloud (Amazon VPC), puoi creare reti private Account AWS al tuo interno per ospitare risorse come istanze Amazon Elastic Compute Cloud (Amazon EC2), istanze Amazon Relational Database Service (Amazon RDS) e istanze Amazon. ElastiCache Puoi consentire alla tua funzione Lambda di accedere alle risorse ospitate in un Amazon VPC collegando la funzione al VPC tramite le sottoreti private che contengono le risorse. Segui le istruzioni nelle seguenti sezioni per collegare una funzione Lambda a un Amazon VPC utilizzando la console Lambda, il () o. AWS Command Line Interface AWS CLI AWS SAM
**Nota**
Ogni funzione Lambda viene eseguita all'interno di un VPC di proprietà e gestito dal servizio Lambda. Questi VPCs vengono gestiti automaticamente da Lambda e non sono visibili ai clienti. La configurazione della funzione per accedere ad altre AWS risorse in un Amazon VPC non ha alcun effetto sul VPC gestito da Lambda all'interno del quale viene eseguita la funzione.
**Topics**
+ [
## Autorizzazioni IAM richieste
](#configuration-vpc-permissions)
+ [
## Collegamento di funzioni Lambda a un Amazon VPC nel tuo Account AWS
](#configuration-vpc-attaching)
+ [
## Accesso a Internet se collegato a un VPC
](#configuration-vpc-internet-access)
+ [
## IPv6 supporto
](#configuration-vpc-ipv6)
+ [
## Le migliori pratiche per l'utilizzo di Lambda con Amazon VPCs
](#configuration-vpc-best-practice)
+ [
## Comprensione delle interfacce di rete elastiche Hyperplane () ENIs
](#configuration-vpc-enis)
+ [
## Utilizzo dei tasti di condizione IAM per le impostazioni VPC
](#vpc-conditions)
+ [
## Tutorial VPC
](#vpc-tutorials)
## Autorizzazioni IAM richieste
Per collegare una funzione Lambda a un Amazon VPC nel tuo, Account AWS Lambda necessita delle autorizzazioni per creare e gestire le interfacce di rete che utilizza per consentire alla funzione di accedere alle risorse del VPC.
Le interfacce di rete create da Lambda sono note come Hyperplane Elastic Network Interfaces o Hyperplane. ENIs Per ulteriori informazioni su queste interfacce di rete, consulta [Comprensione delle interfacce di rete elastiche Hyperplane () ENIs](#configuration-vpc-enis).
Puoi concedere alla tua funzione le autorizzazioni necessarie allegando la policy AWS [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)gestita al ruolo di esecuzione della funzione. Quando crei una nuova funzione nella console Lambda e la colleghi a un VPC, Lambda aggiunge automaticamente questa policy di autorizzazioni per tuo conto.
Se preferisci creare la tua policy di autorizzazioni IAM, assicurati di aggiungere tutte le seguenti autorizzazioni e di consentirle su tutt le risorse (`"Resource": "*"`):
+ ec2: CreateNetworkInterface
+ ec2: DescribeNetworkInterfaces
+ ec2: DescribeSubnets
+ ec2: DeleteNetworkInterface
+ ec2: AssignPrivateIpAddresses
+ ec2: UnassignPrivateIpAddresses
Tieni presente che il ruolo della tua funzione necessita di queste autorizzazioni solo per creare le interfacce di rete, non per richiamare la tua funzione. Puoi comunque richiamare correttamente la funzione quando è collegata a un Amazon VPC, anche se si rimuovono queste autorizzazioni dal ruolo di esecuzione della funzione.
Per collegare la tua funzione a un VPC, Lambda deve anche verificare le risorse di rete utilizzando il tuo ruolo utente IAM. Assicurati che il tuo ruolo utente disponga delle seguenti autorizzazioni IAM:
+ **ec2: DescribeSecurityGroups**
+ **ec2: DescribeSubnets**
+ **ec2: DescribeVpcs**
+ **ec2: GetSecurityGroupsForVpc**
**Nota**
Le autorizzazioni Amazon EC2 concesse al ruolo di esecuzione della funzione vengono utilizzate dal servizio Lambda per collegare la funzione a un VPC. Tuttavia, stai anche concedendo implicitamente queste autorizzazioni al codice della tua funzione. Ciò significa che il codice della funzione è in grado di effettuare queste chiamate API Amazon EC2. Per ulteriori informazioni su come seguire la best practice di sicurezza, consulta [Best practice di sicurezza](#configuration-vpc-best-practice-security).
## Collegamento di funzioni Lambda a un Amazon VPC nel tuo Account AWS
Collega la tua funzione a un Amazon VPC del tuo dispositivo Account AWS utilizzando la console Lambda, oppure. AWS CLI AWS SAM Se utilizzi AWS CLI o o AWS SAM colleghi una funzione esistente a un VPC utilizzando la console Lambda, assicurati che il ruolo di esecuzione della funzione disponga delle autorizzazioni necessarie elencate nella sezione precedente.
Le funzioni Lambda non possono connettersi direttamente a un VPC con la [tenancy dell'istanza dedicata](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html). Per connetterti alle risorse in un VPC dedicato, [esegui il peering a un secondo VPC con la tenancy predefinita](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-dedicated-vpc/).
------
#### [ Lambda console ]
**Per collegare una funzione a un Amazon VPC al momento della creazione**
1. Apri la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli **Crea funzione**.
1. In **Informazioni di base**, immettere un nome per la funzione in **Nome funzione**.
1. Configura le impostazioni del VPC per la funzione effettuando le seguenti operazioni:
1. Espandere **Advanced settings (Impostazioni avanzate)**.
1. Seleziona **Abilita VPC**, quindi scegli il VPC a cui desideri collegare la funzione.
1. (Facoltativo) Per consentire il traffico in [uscita, seleziona Consenti IPv6 il traffico](#configuration-vpc-ipv6) per sottoreti **dual-stack IPv6 **.
1. Scegli le sottoreti e i gruppi di sicurezza per cui creare l'interfaccia di rete. Se hai selezionato **Consenti il IPv6 traffico per le sottoreti dual-stack, tutte le sottoreti selezionate devono avere un blocco** CIDR e un blocco CIDR. IPv4 IPv6
**Nota**
Connetti la tua funzione a sottoreti private per accedere alle risorse private. Se la tua funzione ha bisogno dell'accesso a Internet, consulta [Abilitare l'accesso a Internet per funzioni Lambda connesse a un VPC](configuration-vpc-internet.md). La connessione di una funzione a una sottorete pubblica non fornisce l'accesso a Internet o a un indirizzo IP pubblico.
1. Scegli **Crea funzione**.
**Per collegare una funzione esistente a un Amazon VPC**
1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli la tua funzione.
1. Scegli la scheda **Configurazione**, quindi scegli **VPC**.
1. Scegli **Modifica**.
1. In **VPC**, seleziona l'Amazon VPC a cui desideri collegare la funzione.
1. **(Facoltativo) Per consentire il traffico in [uscita, seleziona Consenti il traffico per sottoreti dual-stack IPv6 ](#configuration-vpc-ipv6). IPv6 **
1. Scegli le sottoreti e i gruppi di sicurezza per cui creare l'interfaccia di rete. Se hai selezionato **Consenti il IPv6 traffico per le sottoreti dual-stack, tutte le sottoreti selezionate devono avere un blocco** CIDR e un blocco CIDR. IPv4 IPv6
**Nota**
Connetti la tua funzione a sottoreti private per accedere alle risorse private. Se la tua funzione ha bisogno dell'accesso a Internet, consulta [Abilitare l'accesso a Internet per funzioni Lambda connesse a un VPC](configuration-vpc-internet.md). La connessione di una funzione a una sottorete pubblica non fornisce l'accesso a Internet o a un indirizzo IP pubblico.
1. Scegli **Save** (Salva).
------
#### [ AWS CLI ]
**Per collegare una funzione a un Amazon VPC al momento della creazione**
+ Per creare una funzione Lambda e collegarla a un VPC, esegui il comando della CLI `create-function` seguente.
```
aws lambda create-function --function-name my-function \
--runtime nodejs24.x --handler index.js --zip-file fileb://function.zip \
--role arn:aws:iam::123456789012:role/lambda-role \
--vpc-config Ipv6AllowedForDualStack=true,SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
Specifica le tue sottoreti e i tuoi gruppi di sicurezza e imposta `Ipv6AllowedForDualStack` su `true` o `false` in base al tuo caso d'uso.
**Per collegare una funzione esistente a un Amazon VPC**
+ Per collegare una funzione esistente a un VPC, esegui il comando della CLI `update-function-configuration` seguente.
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config Ipv6AllowedForDualStack=true, SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
**Per scollegare la tua funzione da un VPC**
+ Per scollegare la funzione da un VPC, esegui il comando della CLI `update-function-configuration` seguente con un elenco vuoto di sottoreti VPC e gruppi di sicurezza.
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config SubnetIds=[],SecurityGroupIds=[]
```
------
#### [ AWS SAM ]
**Per collegare la tua funzione a un VPC**
+ Per collegare una funzione Lambda a un Amazon VPC, aggiungi la proprietà `VpcConfig` alla definizione della funzione come mostrato nel seguente modello di esempio. Per ulteriori informazioni su questa proprietà, vedere [AWS: :Lambda: :Function VpcConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) nella *Guida per l'CloudFormation utente* (la AWS SAM `VpcConfig` proprietà viene passata direttamente alla `VpcConfig` proprietà di una CloudFormation `AWS::Lambda::Function` risorsa).
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./lambda_function/
Handler: lambda_function.handler
Runtime: python3.12
VpcConfig:
SecurityGroupIds:
- !Ref MySecurityGroup
SubnetIds:
- !Ref MySubnet1
- !Ref MySubnet2
Policies:
- AWSLambdaVPCAccessExecutionRole
MySecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for Lambda function
VpcId: !Ref MyVPC
MySubnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.1.0/24
MySubnet2:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.2.0/24
MyVPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
```
*Per ulteriori informazioni sulla configurazione del tuo VPC AWS SAM in, [AWS consulta: :EC2: :VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html) nella Guida per l'utente.CloudFormation *
------
## Accesso a Internet se collegato a un VPC
Per impostazione predefinita, le funzioni Lambda hanno accesso a Internet pubblico. Quando si collega la funzione a un VPC, può accedere solo alle risorse disponibili all'interno di tale VPC. Per concedere alla funzione l'accesso a Internet, è inoltre necessario configurare il VPC per l'accesso a Internet. Per ulteriori informazioni, consulta [Abilitare l'accesso a Internet per funzioni Lambda connesse a un VPC](configuration-vpc-internet.md).
## IPv6 supporto
La tua funzione può connettersi alle risorse nelle sottoreti VPC dual-stack tramite. IPv6 Per impostazione predefinita, questa opzione è disabilitata. [Per consentire il IPv6 traffico in uscita, usa la console o l'opzione con la funzione o il `--vpc-config Ipv6AllowedForDualStack=true` comando create-. [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html)](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html)
**Nota**
Per consentire il IPv6 traffico in uscita in un VPC, tutte le sottoreti connesse alla funzione devono essere sottoreti dual-stack. Lambda non supporta IPv6 connessioni in uscita per IPv6 sole sottoreti in un VPC o connessioni in IPv6 uscita per funzioni che non sono connesse a un VPC.
Puoi aggiornare il codice della funzione per connetterti in modo esplicito alle risorse della sottorete. IPv6 Il seguente esempio di Python apre un socket e si connette a un IPv6 server.
**Example — Connect al IPv6 server**
```
def connect_to_server(event, context):
server_address = event['host']
server_port = event['port']
message = event['message']
run_connect_to_server(server_address, server_port, message)
def run_connect_to_server(server_address, server_port, message):
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
try:
# Send data
sock.connect((server_address, int(server_port), 0, 0))
sock.sendall(message.encode())
BUFF_SIZE = 4096
data = b''
while True:
segment = sock.recv(BUFF_SIZE)
data += segment
# Either 0 or end of data
if len(segment) < BUFF_SIZE:
break
return data
finally:
sock.close()
```
## Le migliori pratiche per l'utilizzo di Lambda con Amazon VPCs
Per garantire che la configurazione del VPC Lambda soddisfi le linee guida delle best practice, segui i consigli nelle sezioni seguenti.
### Best practice di sicurezza
Per collegare la tua funzione Lambda a un VPC, devi assegnare al ruolo di esecuzione della funzione una serie di autorizzazioni Amazon EC2. Queste autorizzazioni sono necessarie per creare le interfacce di rete utilizzate dalla funzione per accedere alle risorse nel VPC. Tuttavia, stai anche concedendo implicitamente queste autorizzazioni al codice della tua funzione. Ciò significa che il codice della funzione ha l'autorizzazione per effettuare queste chiamate API Amazon EC2.
Per seguire il principio dell'accesso con privilegio minimo, aggiungi una policy di negazione come quella riportata nell'esempio seguente al ruolo di esecuzione della funzione. Questa policy impedisce al codice della funzione di effettuare chiamate ad Amazon EC2 APIs, pur consentendo al servizio Lambda di gestire le risorse VPC per tuo conto. La policy utilizza la chiave di condizione `lambda:SourceFunctionArn`, che si applica solo alle chiamate API effettuate dal codice della funzione durante l'esecuzione. Per ulteriori informazioni, consulta [Utilizzo dell'ARN della funzione di origine per controllare il comportamento di accesso alla funzione](permissions-source-function-arn.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSubnets",
"ec2:DetachNetworkInterface",
"ec2:AssignPrivateIpAddresses",
"ec2:UnassignPrivateIpAddresses"
],
"Resource": [ "*" ],
"Condition": {
"ArnEquals": {
"lambda:SourceFunctionArn": [
"arn:aws:lambda:us-west-2:123456789012:function:my_function"
]
}
}
}
]
}
```
------
AWS fornisce *[gruppi di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)* e *[liste di controllo degli accessi alla rete (ACLs)](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)* per aumentare la sicurezza nel tuo VPC. I gruppi di sicurezza controllano il traffico in entrata e in uscita per le risorse e la rete ACLs controllano il traffico in entrata e in uscita per le sottoreti. I gruppi di sicurezza forniscono un controllo di accesso sufficiente per la maggior parte delle sottoreti. Puoi usare la rete ACLs se desideri un ulteriore livello di sicurezza per il tuo VPC. Per linee guida generali sulle best practice di sicurezza per l'utilizzo di Amazon VPCs, consulta [le best practice di sicurezza per il tuo VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-best-practices.html) nella *Amazon Virtual Private Cloud User* Guide.
### Best practice sulle prestazioni
Quando colleghi la tua funzione a un VPC, Lambda verifica se esiste una risorsa di rete disponibile (Hyperplane ENI) a cui può connettersi. Gli Hyperplane ENIs sono associati a una particolare combinazione di gruppi di sicurezza e sottoreti VPC. Se hai già collegato una funzione a un VPC, specificare le stesse sottoreti e gli stessi gruppi di sicurezza quando colleghi un'altra funzione implica che Lambda può condividere le risorse di rete ed evitare la necessità di creare una nuova Hyperplane ENI. Per ulteriori informazioni su Hyperplane ENIs e il relativo ciclo di vita, vedere. [Comprensione delle interfacce di rete elastiche Hyperplane () ENIs](#configuration-vpc-enis)
## Comprensione delle interfacce di rete elastiche Hyperplane () ENIs
Una Hyperplane ENI è una risorsa gestita che funge da interfaccia di rete tra la tua funzione Lambda e le risorse a cui desideri che la tua funzione si connetta. Il servizio Lambda li crea e li gestisce ENIs automaticamente quando colleghi la funzione a un VPC.
Gli Hyperplane non ENIs sono visibili direttamente all'utente e non è necessario configurarli o gestirli. Tuttavia, conoscerne il funzionamento può aiutarti a comprendere il comportamento della tua funzione quando la colleghi a un VPC.
La prima volta che si collega una funzione a un VPC utilizzando una particolare combinazione di sottorete e gruppo di sicurezza, Lambda crea una Hyperplane ENI. Anche altre funzioni del tuo account che utilizzano la stessa combinazione di sottorete e gruppo di sicurezza possono utilizzare questa ENI. Ove possibile, Lambda riutilizza le risorse esistenti ENIs per ottimizzare l'utilizzo delle risorse e ridurre al minimo la creazione di nuove. ENIs Ogni Hyperplane ENI supporta fino a 65.000 connessioni/porte. Se il numero di connessioni supera questo limite, Lambda ridimensiona automaticamente il numero in base al traffico ENIs di rete e ai requisiti di concorrenza.
Per le nuove funzioni, mentre Lambda crea una Hyperplane ENI, la funzione rimane nello stato In sospeso e non è possibile richiamarla. La funzione passa allo stato Attivo solo quando l'Hyperplane ENI è pronta, il che può richiedere diversi minuti. Per le funzioni esistenti, non è possibile eseguire ulteriori operazioni per tale funzione, ad esempio la creazione di versioni o l'aggiornamento del codice della funzione, ma è possibile continuare a richiamare le sue versioni precedenti.
Come parte della gestione del ciclo di vita ENI, Lambda può eliminare e ricreare ENIs per bilanciare il carico del traffico di rete ENIs o per risolvere problemi riscontrati nei controlli sanitari ENI. Inoltre, se una funzione Lambda rimane inattiva per 14 giorni, Lambda recupera qualsiasi ENIs iperpiano inutilizzato e imposta lo stato della funzione su. `Inactive` L'invocazione successiva avrà esito negativo e la funzione entrerà di nuovo nello stato in sospeso fino a quando Lambda non completa la creazione o l'allocazione di una Hyperplane ENI. Ti consigliamo di non basare il tuo design sulla persistenza di. ENIs
Quando aggiorni una funzione per rimuoverne la configurazione VPC, Lambda richiede fino a 20 minuti per eliminare l'ENI Hyperplane allegato. Lambda elimina l'ENI solo se nessun'altra funzione (o versione della funzione pubblicata) utilizza l'Hyperplane ENI.
Per eliminare l'Hyperplane ENI, Lambda si basa sulle autorizzazioni del [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione. Se elimini il ruolo di esecuzione prima che Lambda abbia eliminato l'Hyperplane ENI, Lambda non sarà più in grado di eliminare l'Hyperplane ENI. Puoi eseguire manualmente l'eliminazione.
## Utilizzo dei tasti di condizione IAM per le impostazioni VPC
È possibile utilizzare chiavi di condizione Lambda specifiche per le impostazioni VPC per fornire controlli di autorizzazione aggiuntivi per le funzioni Lambda. Ad esempio, è possibile richiedere che tutte le funzioni dell'organizzazione siano connesse a un VPC. È inoltre possibile specificare le sottoreti e i gruppi di sicurezza che gli utenti della funzione possono e non possono utilizzare.
Lambda supporta inoltre le seguenti chiavi di condizione nelle policy IAM:
+ **lambda: VpcIds** — Consenti o nega uno o più. VPCs
+ **lambda: SubnetIds** — Consenti o nega una o più sottoreti.
+ **lambda: SecurityGroupIds** — Consenti o nega uno o più gruppi di sicurezza.
L'API Lambda opera [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)e [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)supporta queste chiavi di condizione. Per ulteriori informazioni sull'uso delle chiavi di condizione nelle policy IAM, consulta [elementi della policy IAM JSON: condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) nella *Guida per l'utente di IAM*.
**Suggerimento**
Se la funzione include già una configurazione VPC da una richiesta API precedente, è possibile inviare una richiesta `UpdateFunctionConfiguration` senza la configurazione VPC.
### Policy di esempio con chiavi di condizione per le impostazioni VPC
Negli esempi seguenti viene illustrato come utilizzare le chiavi di condizione per le impostazioni VPC. Dopo aver creato un'istruzione delle policy con le restrizioni desiderate, aggiungere l'istruzione delle policy per l'utente o il ruolo di destinazione.
#### Assicurarsi che gli utenti distribuiscano solo funzioni connesse a VPC
Per garantire che tutti gli utenti distribuiscano solo funzioni connesse a VPC, è possibile negare le operazioni di creazione e aggiornamento delle funzioni che non includono un ID VPC valido.
Si noti che l'ID VPC non è un parametro di input per la richiesta `CreateFunction` o `UpdateFunctionConfiguration`. Lambda recupera il valore dell'ID VPC in base ai parametri della sottorete e del gruppo di sicurezza.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceVPCFunction",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"Null": {
"lambda:VpcIds": "true"
}
}
}
]
}
```
------
#### Nega agli utenti l'accesso a sottoreti o gruppi di sicurezza specifici VPCs
Per negare agli utenti l'accesso a informazioni specifiche VPCs, usa `StringEquals` per verificare il valore della condizione. `lambda:VpcIds` Nell'esempio seguente viene negato agli utenti l'accesso a `vpc-1` e `vpc-2`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceOutOfVPC",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
Per negare agli utenti l'accesso a subnet specifiche, utilizzare `StringEquals` per verificare il valore della condizione `lambda:SubnetIds`. Nell'esempio seguente viene negato agli utenti l'accesso a `subnet-1` e `subnet-2`.
```
{
"Sid": "EnforceOutOfSubnet",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
Per negare agli utenti l'accesso a specifici gruppi di sicurezza, utilizzare `StringEquals` per verificare il valore della condizione `lambda:SecurityGroupIds`. Nell'esempio seguente viene negato agli utenti l'accesso a `sg-1` e `sg-2`.
```
{
"Sid": "EnforceOutOfSecurityGroups",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
#### Consenti agli utenti di creare e aggiornare funzioni con impostazioni VPC specifiche
Per consentire agli utenti di accedere a condizioni specifiche VPCs, utilizza `StringEquals` per verificare il valore della `lambda:VpcIds` condizione. L'esempio seguente consente agli utenti di accedere a `vpc-1` e `vpc-2`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceStayInSpecificVpc",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
Per consentire agli utenti di accedere a sottoreti specifiche, utilizzare `StringEquals` per verificare il valore della condizione `lambda:SubnetIds`. L'esempio seguente consente agli utenti di accedere a `subnet-1` e `subnet-2`.
```
{
"Sid": "EnforceStayInSpecificSubnets",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
Per consentire agli utenti di accedere a gruppi di sicurezza specifici, utilizzare `StringEquals` per verificare il valore della condizione `lambda:SecurityGroupIds`. L'esempio seguente consente agli utenti di accedere a `sg-1` e `sg-2`.
```
{
"Sid": "EnforceStayInSpecificSecurityGroup",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
## Tutorial VPC
Nelle esercitazioni seguenti è possibile connettere una funzione Lambda alle risorse del VPC.
+ [Tutorial: Utilizzo di una funzione Lambda per l'accesso ad Amazon RDS in un VPC Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html)
+ [Tutorial: Configurazione di una funzione Lambda per accedere ad Amazon in un ElastiCache Amazon VPC](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/LambdaRedis.html)
# Consentire alle funzioni Lambda di accedere a una risorsa in un Amazon VPC in un altro account
Puoi consentire alla tua AWS Lambda funzione di accedere a una risorsa in un Amazon VPC in Amazon Virtual Private Cloud gestito da un altro account, senza esporre nessuno dei due VPC a Internet. Questo modello di accesso consente di condividere i dati con altre organizzazioni utilizzando. AWS Utilizzando questo modello di accesso, è possibile condividere i dati VPCs con un livello di sicurezza e prestazioni maggiore rispetto a Internet. Configura la tua funzione Lambda per utilizzare una connessione peering Amazon VPC per accedere a queste risorse.
**avvertimento**
Quando consenti l'accesso tra account o VPCs, verifica che il tuo piano soddisfi i requisiti di sicurezza delle rispettive organizzazioni che gestiscono questi account. Seguire le istruzioni contenute in questo documento influirà sul livello di sicurezza delle risorse.
In questo tutorial, colleghi due account con una connessione peering utilizzando IPv4. Si configura una funzione Lambda che non è già connessa a un Amazon VPC. La risoluzione DNS viene configurata per connettere la funzione a risorse che non forniscono dati statici. IPs Per adattare queste istruzioni ad altri scenari di peering, consulta la [Guida al peering VPC](https://docs.aws.amazon.com//vpc/latest/peering/what-is-vpc-peering.html).
## Prerequisiti
Per consentire a una funzione Lambda di accedere a una risorsa in un altro account, devi avere:
+ Una funzione Lambda configurata per l'autenticazione e la successiva lettura dalla risorsa.
+ Una risorsa in un altro account, ad esempio un cluster Amazon RDS, disponibile tramite Amazon VPC.
+ Le credenziali per l'account della funzione Lambda e l'account della risorsa. Se non sei autorizzato a utilizzare l'account della tua risorsa, contatta un utente autorizzato per preparare quell'account.
+ L'autorizzazione per creare e aggiornare un VPC (e le risorse del Amazon VPC di supporto) da associare alla funzione Lambda.
+ L'autorizzazione per aggiornare il ruolo di esecuzione e la configurazione VPC per la funzione Lambda.
+ L'autorizzazione per creare una connessione peering VPC nell'account della funzione Lambda.
+ L'autorizzazione per accettare una connessione peering VPC nell'account della risorsa.
+ L'autorizzazione per aggiornare la configurazione del VPC della risorsa (e le risorse Amazon VPC di supporto).
+ Autorizzazione per richiamare la funzione Lambda.
## Creare un Amazon VPC nell'account della tua funzione
Crea un Amazon VPC, le sottoreti, le tabelle di routing e un gruppo di sicurezza nell'account della tua funzione Lambda.
**Come creare un VPC, sottoreti e altre risorse VPC tramite la console**
1. Apri la console Amazon VPC all'indirizzo [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel pannello di controllo, scegli **Crea VPC**.
1. Per il **blocco IPv4 CIDR**, fornisci un blocco CIDR privato. Il blocco CIDR non deve sovrapporsi ai blocchi utilizzati nel VPC della risorsa. Non scegliere un blocco utilizzato dal VPC delle risorse da IPs assegnare alle risorse o un blocco già definito nelle tabelle di routing nel VPC delle risorse. Per ulteriori informazioni sulla definizione dei blocchi CIDR appropriati, consulta [Blocchi CIDR VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html).
1. Scegliere **Customize (Personalizza) AZs**.
1. Seleziona lo stesso della tua risorsa. AZs
1. Per **Numero di sottoreti pubbliche**, scegli **0**.
1. Per **VPC endpoints** (Endpoint VPC), scegli **None** (Nessuno).
1. Seleziona **Crea VPC**.
## Concedere le autorizzazioni VPC al ruolo di esecuzione della funzione
[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)Collegati al ruolo di esecuzione della tua funzione per consentirle di connettersi a VPCs.
**Per concedere le autorizzazioni VPC al ruolo di esecuzione della funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli il nome della funzione .
1. Scegliere **Configuration (Configurazione)**.
1. Seleziona **Autorizzazioni**.
1. In **Nome del ruolo**, scegli il ruolo di esecuzione.
1. Nella sezione **Policy di autorizzazioni**, seleziona **Aggiungi autorizzazioni**.
1. Dall'elenco a discesa scegli **Collega policy**.
1. Nella casella di ricerca immetti `AWSLambdaVPCAccessExecutionRole`.
1. Seleziona la casella di controllo sulla sinistra del nome della policy.
1. Scegli **Add Permissions (Aggiungi autorizzazioni)**.
**Per collegare la tua funzione al tuo Amazon VPC**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli il nome della funzione .
1. Scegli la scheda **Configurazione**, quindi scegli **VPC**.
1. Scegli **Modifica**.
1. In **VPC**, seleziona il tuo VPC.
1. In **Sottoreti**, scegli le tue sottoreti.
1. Per **Gruppi di sicurezza**, scegli il gruppo di sicurezza predefinito del VPC.
1. Scegli **Save** (Salva).
## Creare una richiesta di connessione peering VPC
Crea una richiesta di connessione peering VPC dal VPC della tua funzione (il VPC richiedente) al VPC della tua risorsa (il VPC accettante).
**Per richiedere una connessione peering VPC al VPC della funzione**
1. Apri la [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel riquadro di navigazione, seleziona **Connessioni peering**.
1. Scegli **Create peering connection** (Crea connessione peering).
1. Per **ID VPC (richiedente)**, seleziona il VPC della tua funzione.
1. In **ID account** immetti l'ID dell'account della risorsa.
1. Per **ID VPC (accettante)**, inserisci il VPC della tua risorsa.
## Preparare l'account della tua risorsa
Per creare la connessione peering e preparare il VPC della risorsa all'utilizzo della connessione, accedi all'account della risorsa con un ruolo che detiene le autorizzazioni elencate nei prerequisiti. I passaggi per accedere possono essere diversi in base al modo in cui l'account è protetto. Per ulteriori informazioni su come accedere a un AWS account, consulta la [Guida per AWS l'utente di accesso](https://docs.aws.amazon.com//signin/latest/userguide/what-is-sign-in.html). Nell'account della risorsa, completa le seguenti procedure.
**Per accettare una richiesta di connessione peering VPC.**
1. Apri la [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel riquadro di navigazione, seleziona **Connessioni peering**.
1. Seleziona la connessione peering VPC in attesa (lo stato è pending-acceptance).
1. Scegli **Azioni**
1. Dal menù a discesa, scegli **Accetta richiesta**.
1. Quando viene chiesta la conferma, seleziona **Accetta richiesta**.
1. Scegli **Modifica subito le tabelle di routing** per aggiungere una route alla tabella di routing principale del VPC in modo da poter inviare e ricevere traffico attraverso la connessione peering.
Ispeziona le tabelle di routing per il VPC della risorsa. Il percorso generato da Amazon VPC potrebbe non stabilire la connettività a seconda di come è configurato il VPC della risorsa. Verifica la presenza di conflitti tra la nuova route e la configurazione esistente per il VPC. Per ulteriori informazioni sulla risoluzione dei problemi, consulta [Risoluzione dei problemi di una connessione peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/troubleshoot-vpc-peering-connections.html) nella *Guida al peering VPC di Amazon Virtual Private Cloud* Guide.
**Per aggiornare il gruppo di sicurezza per la risorsa**
1. Apri la [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel pannello di navigazione, seleziona **Gruppi di sicurezza**.
1. Seleziona il gruppo di sicurezza per la tua risorsa.
1. Scegli **Azioni**.
1. Dall'elenco a discesa, scegli **Modifica regole in entrata**.
1. Scegli **Aggiungi regola**.
1. Per **Origine**, inserisci l'ID account della funzione e l'ID del gruppo di sicurezza, separati da una barra (ad esempio 111122223333/sg-1a2b3c4d).
1. Scegli **Edit outbound rules** (Modifica regole in uscita).
1. Verifica se il traffico in uscita è limitato. Le impostazioni VPC predefinite autorizzano tutto il traffico in uscita. Se il traffico in uscita è limitato, continua con il passaggio successivo.
1. Scegli **Aggiungi regola**.
1. Per **Destinazione**, inserisci l'ID account della funzione e l'ID del gruppo di sicurezza, separati da una barra (ad esempio 111122223333/sg-1a2b3c4d).
1. Scegliere **Salva regole**.
**Per abilitare la risoluzione DNS per la connessione peering**
1. Apri la [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel riquadro di navigazione, seleziona **Connessioni peering**.
1. Seleziona la connessione peering.
1. Scegli **Azioni**.
1. Seleziona **Modifica impostazioni DNS**.
1. In **Risoluzione DNS accettante**, seleziona **Consenti al VPC richiedente di risolvere il DNS degli host VPC accettanti su IP privato**.
1. Scegli **Save changes** (Salva modifiche).
## Aggiornare la configurazione VPC nell'account della tua funzione
Accedi all'account della funzione, quindi aggiorna la configurazione VPC.
**Per aggiungere una route per la connessione peering VPC**
1. Apri la [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel riquadro di navigazione, seleziona **Tabelle di routing**.
1. Seleziona la casella di controllo accanto al nome della tabella di routing per la sottorete associata alla tua funzione.
1. Scegli **Azioni**.
1. Selezionare **Modifica route**.
1. Seleziona **Aggiungi route**.
1. Per **Destinazione**, inserisci il blocco CIDR per il VPC della risorsa.
1. Per **Destinazione** seleziona la connessione peering VPC.
1. Scegli **Save changes** (Salva modifiche).
Per ulteriori informazioni sulle considerazioni che potresti incontrare durante l'aggiornamento delle tabelle di routing, consulta [Aggiornamento delle tabelle di routing per una connessione peering VPC](https://docs.aws.amazon.com//vpc/latest/peering/vpc-peering-routing.html).
**Per aggiornare il gruppo di sicurezza per la tua funzione Lambda**
1. Apri la [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel pannello di navigazione, seleziona **Gruppi di sicurezza**.
1. Scegli **Azioni**.
1. Sceglere **Edit inbound rules (Modifica regole in entrata)**.
1. Scegli **Aggiungi regola**.
1. Per **Origine**, inserisci l'ID account della risorsa e l'ID del gruppo di sicurezza, separati da una barra (ad esempio 111122223333/sg-1a2b3c4d).
1. Scegliere **Salva regole**.
**Per abilitare la risoluzione DNS per la connessione peering**
1. Apri la [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel riquadro di navigazione, seleziona **Connessioni peering**.
1. Seleziona la connessione peering.
1. Scegli **Azioni**.
1. Seleziona **Modifica impostazioni DNS**.
1. In **Risoluzione DNS richiedente**, seleziona **Consenti al VPC accettante di risolvere il DNS degli host VPC richiedenti su IP privato**.
1. Scegli **Save changes** (Salva modifiche).
## Test della funzione
**Per creare un evento di test e controllare l'output della funzione**
1. Nel riquadro **Origine del codice**, scegli **Test**.
1. Seleziona **Crea nuovo evento**.
1. Nel pannello **JSON evento**, sostituisci i valori predefiniti con un input appropriato per la tua funzione Lambda.
1. Scegli **Richiama **.
1. Nella scheda **Risultati di esecuzione**, conferma che la sezione **Risposta** contenga l'output previsto.
Inoltre, puoi controllare i log della tua funzione per verificare che siano quelli previsti.
**Per visualizzare i record di invocazione della funzione in Logs CloudWatch**
1. Selezionare la scheda **Monitor (Monitora)**.
1. **Scegli Visualizza registri. CloudWatch **
1. Nella scheda **Flussi di log**, scegli il flusso di log per l'invocazione della funzione.
1. Conferma che i log siano quelli che ti aspetti.
# Abilitare l'accesso a Internet per funzioni Lambda connesse a un VPC
Per impostazione predefinita, le funzioni Lambda vengono eseguite in un VPC gestito da Lambda con accesso a Internet. Per accedere alle risorse in un VPC nel tuo account, puoi aggiungere una configurazione VPC a una funzione. Ciò limita la funzione alle risorse all'interno di quel VPC, a meno che il VPC non abbia accesso a Internet. Questa pagina spiega come fornire l'accesso a Internet alle funzioni Lambda connesse al VPC.
## Non ho ancora un VPC
### Creazione del VPC
Il **flusso di lavoro Crea VPC** crea tutte le risorse VPC necessarie per una funzione Lambda per accedere alla rete Internet pubblica da una sottorete privata, incluse sottoreti, gateway NAT, gateway Internet e voci della tabella di routing.
**Per creare il VPC**
1. Apri la console Amazon VPC all'indirizzo [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel pannello di controllo, scegli **Crea VPC**.
1. Per **Risorse da creare**, scegli **VPC e altro**.
1. **Configurazione del VPC**
1. Per **Name tag auto-generation** (Generazione automatica di tag nome), immetti un nome per il VPC.
1. Per il **blocco IPv4 CIDR**, puoi mantenere il suggerimento predefinito o, in alternativa, puoi inserire il blocco CIDR richiesto dall'applicazione o dalla rete.
1. Se la tua applicazione comunica utilizzando IPv6 gli indirizzi, scegli il blocco **IPv6CIDR, il blocco CIDR** fornito da **Amazon IPv6 **.
1. **Configurazione delle sottoreti**
1. In **Numero di zone di disponibilità**, scegli **2**. Ne consigliamo almeno due per un'elevata disponibilità. AZs
1. Per **Number of public subnets** (Numero di sottoreti pubbliche), scegli **2**.
1. Per **Number of private subnets** (Numero di sottoreti private), scegli **2**.
1. Puoi mantenere il blocco CIDR predefinito per la sottorete pubblica o, in alternativa, espandere **Personalizza blocchi CIDR della sottorete** e inserire un blocco CIDR. Per ulteriori informazioni, consulta [Blocchi CIDR della sottorete](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html).
1. Per **Gateway NAT**, scegli **1 per AZ** per migliorare la resilienza.
1. Per il **gateway Internet solo Egress**, scegli **Sì** se hai scelto di includere un blocco IPv6 CIDR.
1. Per **Endpoint VPC**, mantieni il valore predefinito, **Gateway S3**. Questa opzione non prevede alcun costo. Per ulteriori informazioni, consulta [Tipi di endpoint VPC per Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html#types-of-vpc-endpoints-for-s3).
1. Per **Opzioni DNS**, mantieni le impostazioni predefinite.
1. Seleziona **Crea VPC**.
### Configura la funzione Lambda
**Per configurare un VPC quando si crea una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli **Crea funzione**.
1. In **Informazioni di base**, immettere un nome per la funzione in **Nome funzione**.
1. Espandere **Advanced settings (Impostazioni avanzate)**.
1. Seleziona **Abilita VPC**, quindi scegli un VPC.
1. (Facoltativo) Per consentire il traffico in [uscita, seleziona Consenti IPv6 il traffico](configuration-vpc.md#configuration-vpc-ipv6) per sottoreti ** IPv6 dual-stack**.
1. Per **Sottoreti**, seleziona tutte le sottoreti private. Le sottoreti private possono accedere a Internet attraverso un gateway NAT. La connessione di una funzione a una sottorete pubblica non fornisce l'accesso a Internet.
**Nota**
Se hai selezionato **Consenti il IPv6 traffico per le sottoreti dual-stack, tutte le sottoreti selezionate devono avere un blocco** CIDR e un blocco CIDR. IPv4 IPv6
1. Per **Gruppi di sicurezza**, seleziona un gruppo di sicurezza che consenta il traffico in uscita.
1. Scegli **Crea funzione**.
Lambda crea automaticamente un ruolo di esecuzione con la policy [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS gestita. Le autorizzazioni in questa policy sono necessarie solo per creare interfacce di rete elastiche per la configurazione VPC, non per richiamare la funzione. Per applicare le autorizzazioni con privilegi minimi, puoi rimuovere la **AWSLambdaVPCAccessExecutionRole**policy dal tuo ruolo di esecuzione dopo aver creato la funzione e la configurazione del VPC. Per ulteriori informazioni, consulta [Autorizzazioni IAM richieste](configuration-vpc.md#configuration-vpc-permissions).
**Per configurare un VPC per una funzione esistente**
Per aggiungere una configurazione VPC a una funzione esistente, il ruolo di esecuzione della funzione deve disporre dell'[autorizzazione per creare e gestire interfacce di rete elastiche](configuration-vpc.md#configuration-vpc-permissions). La policy [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS gestita include le autorizzazioni richieste. Per applicare le autorizzazioni con privilegi minimi, puoi rimuovere la **AWSLambdaVPCAccessExecutionRole**policy dal tuo ruolo di esecuzione dopo aver creato la configurazione VPC.
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Scegli la scheda **Configurazione**, quindi scegli **VPC**.
1. In **VPC**, scegli **Modifica**.
1. Seleziona il VPC
1. **(Facoltativo) Per consentire il traffico in [uscita, seleziona Consenti il IPv6 traffico](configuration-vpc.md#configuration-vpc-ipv6) per sottoreti dual-stack. IPv6 **
1. Per **Sottoreti**, seleziona tutte le sottoreti private. Le sottoreti private possono accedere a Internet attraverso un gateway NAT. La connessione di una funzione a una sottorete pubblica non fornisce l'accesso a Internet.
**Nota**
Se hai selezionato **Consenti il IPv6 traffico per le sottoreti dual-stack, tutte le sottoreti selezionate devono avere un blocco** CIDR e un blocco CIDR. IPv4 IPv6
1. Per **Gruppi di sicurezza**, seleziona un gruppo di sicurezza che consenta il traffico in uscita.
1. Scegli **Save** (Salva).
### Test della funzione
Usa il seguente codice di esempio per verificare che la tua funzione connessa al VPC possa raggiungere la rete Internet pubblica. In caso di successo, il codice restituisce un codice di stato `200`. Se non ha esito positivo, la funzione scade.
------
#### [ Node.js ]
1. Nel riquadro **Codice sorgente** della console Lambda, incolla il codice seguente nel file **index.mjs**. La funzione effettua una richiesta HTTP GET a un endpoint pubblico e restituisce il codice di risposta HTTP per verificare se la funzione ha accesso alla rete Internet pubblica.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/code-source-nodejs.png)
**Example Richiesta HTTP con async/await**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Seleziona la scheda **Test**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-tab.png)
1. Scegli **Test (Esegui test)**.
1. La funzione restituisce un codice di stato `200`. Ciò significa che la funzione dispone di un accesso a Internet in uscita.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-successful-200.png)
Se la funzione non riesce a raggiungere la rete Internet pubblica, ti verrà mostrato un messaggio di errore come questo:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. Nel riquadro **Codice sorgente** della console Lambda, incolla il seguente codice seguente nel file **lambda\$1function.py**. La funzione effettua una richiesta HTTP GET a un endpoint pubblico e restituisce il codice di risposta HTTP per verificare se la funzione ha accesso alla rete Internet pubblica.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Seleziona la scheda **Test**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-tab.png)
1. Scegli **Test (Esegui test)**.
1. La funzione restituisce un codice di stato `200`. Ciò significa che la funzione dispone di un accesso a Internet in uscita.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-successful-200.png)
Se la funzione non riesce a raggiungere la rete Internet pubblica, ti verrà mostrato un messaggio di errore come questo:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
## Ho già un VPC
Se disponi già di un VPC ma devi configurare l'accesso pubblico a Internet per una funzione Lambda, completa questa procedura. Questa procedura presuppone che il VPC abbia almeno due sottoreti. Se non disponi di due sottoreti, consulta [Creare una sottorete](https://docs.aws.amazon.com/vpc/latest/userguide/create-subnets.html) nella *Guida per l'utente di Amazon VPC*.
### Verificare la configurazione della tabella di routing
1. Apri la console Amazon VPC all'indirizzo [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Scegli l'**ID VPC**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/vpc-id.png)
1. Scorri verso il basso fino alla sezione **Mappa delle risorse**. Prendi nota delle mappature delle tabelle di routing. Apri ogni tabella di routing mappata a una sottorete.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/route-table-associations.png)
1. Scorri verso il basso fino alla scheda **Route**. Esamina i routing per determinare se il tuo VPC ha entrambe le seguenti tabelle di routing. Ciascuno di questi requisiti deve essere soddisfatto da una tabella di routing separata.
+ Il traffico diretto a Internet (`0.0.0.0/0`for IPv4, `::/0` for IPv6) viene indirizzato a un gateway Internet (). `igw-xxxxxxxxxx` Ciò significa che la sottorete associata alla tabella di routing è una sottorete pubblica.
**Nota**
Se la tua sottorete non ha un blocco IPv6 CIDR, vedrai solo route (). IPv4 `0.0.0.0/0`
**Example tabella di routing della sottorete pubblica**
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/routes-public.png)
+ Il traffico collegato a Internet for IPv4 (`0.0.0.0/0`) viene indirizzato a un gateway NAT (`nat-xxxxxxxxxx`) associato a una sottorete pubblica. Ciò significa che la sottorete è una sottorete privata che può accedere a Internet tramite il gateway NAT.
**Nota**
Se la sottorete ha un blocco IPv6 CIDR, la tabella di routing deve inoltre indirizzare il traffico legato a Internet () verso un gateway Internet di sola uscita () IPv6 . `::/0` `eigw-xxxxxxxxxx` Se la sottorete non ha un blocco IPv6 CIDR, vedrete solo route (). IPv4 `0.0.0.0/0`
**Example tabella di routing della sottorete privata**
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/routes-private.png)
1. Ripeti il passaggio precedente fino a quando non avrai esaminato ogni tabella di routing associata a una sottorete nel tuo VPC e avrai confermato di avere una tabella di routing con un gateway Internet e una tabella di routing con un gateway NAT.
Se non disponi di due tabelle di routing, una con una route verso un gateway Internet e una con una route verso un gateway NAT, segui questi passaggi per creare le risorse mancanti e le voci della tabella di routing.
### Creazione di una tabella di routing
Completa la seguente procedura per creare una tabella di routing e associarla a una sottorete.
**Per creare una tabella di routing personalizzata utilizzando la console Amazon VPC**
1. Apri la console Amazon VPC all'indirizzo [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel riquadro di navigazione, seleziona **Tabelle di routing**.
1. Selezionare **Create route table (Crea tabella di instradamento)**.
1. (Facoltativo) In **Name (Nome)**, inserisci un nome per la tabella di instradamento.
1. In **VPC**, seleziona il VPC.
1. (Facoltativo) Per aggiungere un tag, scegli **Add new tag** (Aggiungi nuovo tag) e inserisci la chiave e il valore del tag.
1. Selezionare **Create route table (Crea tabella di instradamento)**.
1. Nella scheda **Associazioni sottorete** scegli **Modifica associazioni sottorete**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/route-table-subnet.png)
1. Seleziona la casella di controllo per la sottorete da associare alla tabella di instradamento.
1. Scegli **Salva associazioni**.
### Creazione di un Internet Gateway
Segui questi passaggi per creare un gateway Internet, collegarlo al tuo VPC e aggiungerlo alla tabella di routing della sottorete pubblica.
**Come creare un gateway Internet**
1. Apri la console Amazon VPC all'indirizzo [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Nel riquadro di navigazione, seleziona **Gateway Internet**.
1. Scegliere **Crea gateway Internet**.
1. (Facoltativo) Inserisci un nome per il gateway Internet.
1. (Facoltativo) Per aggiungere un tag, scegli **Add new tag** (Aggiungi nuovo tag) e immetti la chiave e il valore del tag.
1. Scegliere **Crea gateway Internet**.
1. Scegli **Collega a un VPC** dal banner nella parte superiore dello schermo, seleziona un VPC disponibile e scegli **Collega un gateway Internet**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/igw-attach-vpc.png)
1. Scegli l'**ID VPC**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/igw-subnet-1.png)
1. Scegli di nuovo l'**ID VPC** per aprire la pagina dei dettagli del VPC.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/igw-your-vpcs.png)
1. Scorri verso il basso fino alla sezione **Mappa delle risorse**, quindi scegli una sottorete. I dettagli della sottorete vengono visualizzati in una nuova scheda.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/vpc-subnets.png)
1. Scegli il link sotto **Tabella di routing**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/subnet-route-table.png)
1. Seleziona **ID tabella di routing** per aprire la pagina dei dettagli della tabella di routing.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/route-table-id.png)
1. In **Route**, seleziona **Modifica route**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/edit-routes.png)
1. Scegli **Aggiungi route**, quindi inserisci `0.0.0.0/0` nella casella **Destinazione**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/create-route-1.png)
1. Per **Destinazione**, seleziona **Internet gateway**, quindi scegli il gateway Internet creato in precedenza. Se la sottorete ha un blocco IPv6 CIDR, è necessario aggiungere anche un percorso `::/0` per lo stesso gateway Internet.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/create-route-2.png)
1. Scegli **Save changes** (Salva modifiche).
### Creazione di un gateway NAT
Segui questi passaggi per creare un gateway NAT, associarlo a una sottorete pubblica e aggiungerlo alla tabella di routing della sottorete privata.
**Per creare un gateway NAT e associarlo a una sottorete pubblica**
1. Nel riquadro di navigazione, scegli **Gateway NAT**.
1. Scegli **Crea gateway NAT**.
1. (Facoltativo) Inserisci un nome per il gateway NAT.
1. In **Sottorete** seleziona una sottorete pubblica del VPC. Una sottorete pubblica è una sottorete che ha una route diretta a un gateway Internet nella sua tabella di routing.
**Nota**
I gateway NAT sono associati a una sottorete pubblica, ma la voce della tabella di routing si trova nella sottorete privata.
1. Per **ID allocazione IP elastico**, seleziona un indirizzo IP elastico o scegli **Alloca IP elastico**.
1. Scegli **Crea gateway NAT**.
**Per aggiungere una route al gateway NAT nella tabella di routing della sottorete privata**
1. Nel riquadro di navigazione, seleziona **Sottoreti**.
1. Seleziona una sottorete privata nel VPC. Una sottorete privata è una sottorete che non dispone di una route a un gateway Internet nella sua tabella di routing.
1. Scegli il link sotto **Tabella di routing**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/subnet-route-table.png)
1. Seleziona **ID tabella di routing** per aprire la pagina dei dettagli della tabella di routing.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/route-table-id.png)
1. Scorri verso il basso e seleziona la scheda **Route**, quindi scegli **Modifica route**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/route-table-edit-routes.png)
1. Scegli **Aggiungi route**, quindi inserisci `0.0.0.0/0` nella casella **Destinazione**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/create-route-1.png)
1. Per **Destinazione**, seleziona **Gateway NAT**, quindi scegli il gateway NAT creato in precedenza.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/create-route-nat.png)
1. Scegli **Save changes** (Salva modifiche).
### Crea un gateway Internet solo in uscita (solo) IPv6
Segui questi passaggi per creare un gateway Internet solo in uscita e aggiungerlo alla tabella di routing della tua sottorete privata.
**Per creare un gateway internet egress-only**
1. Nel riquadro di navigazione, seleziona **Gateway Internet solo in uscita**.
1. Seleziona **Crea gateway Internet solo in uscita**.
1. (Facoltativo) Immetti un nome.
1. Selezionare il VPC nel quale creare l'Internet Gateway egress-only.
1. Seleziona **Crea gateway Internet solo in uscita**.
1. Scegli il link sotto **ID VPC collegato**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/eigw-details.png)
1. Scegliere il link sotto **ID VPC** per aprire la pagina dei dettagli del VPC.
1. Scorri verso il basso fino alla sezione **Mappa delle risorse**, quindi scegli una sottorete privata. Una sottorete privata è una sottorete che non dispone di una route a un gateway Internet nella sua tabella di routing. I dettagli della sottorete vengono visualizzati in una nuova scheda.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/vpc-subnet-private.png)
1. Scegli il link sotto **Tabella di routing**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/private-subnet-route-table.png)
1. Seleziona **ID tabella di routing** per aprire la pagina dei dettagli della tabella di routing.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/route-table-id.png)
1. In **Route**, seleziona **Modifica route**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/edit-routes.png)
1. Scegli **Aggiungi route**, quindi inserisci `::/0` nella casella **Destinazione**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/create-route-1.png)
1. Per **Destinazione**, seleziona **Gateway Internet solo in uscita**, quindi scegli il gateway creato in precedenza.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/eigw-route.png)
1. Scegli **Save changes** (Salva modifiche).
### Configura la funzione Lambda
**Per configurare un VPC quando si crea una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli **Crea funzione**.
1. In **Informazioni di base**, immettere un nome per la funzione in **Nome funzione**.
1. Espandere **Advanced settings (Impostazioni avanzate)**.
1. Seleziona **Abilita VPC**, quindi scegli un VPC.
1. (Facoltativo) Per consentire il traffico in [uscita, seleziona Consenti IPv6 il traffico](configuration-vpc.md#configuration-vpc-ipv6) per sottoreti ** IPv6 dual-stack**.
1. Per **Sottoreti**, seleziona tutte le sottoreti private. Le sottoreti private possono accedere a Internet attraverso un gateway NAT. La connessione di una funzione a una sottorete pubblica non fornisce l'accesso a Internet.
**Nota**
Se hai selezionato **Consenti il IPv6 traffico per le sottoreti dual-stack, tutte le sottoreti selezionate devono avere un blocco** CIDR e un blocco CIDR. IPv4 IPv6
1. Per **Gruppi di sicurezza**, seleziona un gruppo di sicurezza che consenta il traffico in uscita.
1. Scegli **Crea funzione**.
Lambda crea automaticamente un ruolo di esecuzione con la policy [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS gestita. Le autorizzazioni in questa policy sono necessarie solo per creare interfacce di rete elastiche per la configurazione VPC, non per richiamare la funzione. Per applicare le autorizzazioni con privilegi minimi, puoi rimuovere la **AWSLambdaVPCAccessExecutionRole**policy dal tuo ruolo di esecuzione dopo aver creato la funzione e la configurazione del VPC. Per ulteriori informazioni, consulta [Autorizzazioni IAM richieste](configuration-vpc.md#configuration-vpc-permissions).
**Per configurare un VPC per una funzione esistente**
Per aggiungere una configurazione VPC a una funzione esistente, il ruolo di esecuzione della funzione deve disporre dell'[autorizzazione per creare e gestire interfacce di rete elastiche](configuration-vpc.md#configuration-vpc-permissions). La policy [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) AWS gestita include le autorizzazioni richieste. Per applicare le autorizzazioni con privilegi minimi, puoi rimuovere la **AWSLambdaVPCAccessExecutionRole**policy dal tuo ruolo di esecuzione dopo aver creato la configurazione VPC.
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Scegli la scheda **Configurazione**, quindi scegli **VPC**.
1. In **VPC**, scegli **Modifica**.
1. Seleziona il VPC
1. **(Facoltativo) Per consentire il traffico in [uscita, seleziona Consenti il IPv6 traffico](configuration-vpc.md#configuration-vpc-ipv6) per sottoreti dual-stack. IPv6 **
1. Per **Sottoreti**, seleziona tutte le sottoreti private. Le sottoreti private possono accedere a Internet attraverso un gateway NAT. La connessione di una funzione a una sottorete pubblica non fornisce l'accesso a Internet.
**Nota**
Se hai selezionato **Consenti il IPv6 traffico per le sottoreti dual-stack, tutte le sottoreti selezionate devono avere un blocco** CIDR e un blocco CIDR. IPv4 IPv6
1. Per **Gruppi di sicurezza**, seleziona un gruppo di sicurezza che consenta il traffico in uscita.
1. Scegli **Save** (Salva).
### Test della funzione
Usa il seguente codice di esempio per verificare che la tua funzione connessa al VPC possa raggiungere la rete Internet pubblica. In caso di successo, il codice restituisce un codice di stato `200`. Se non ha esito positivo, la funzione scade.
------
#### [ Node.js ]
1. Nel riquadro **Codice sorgente** della console Lambda, incolla il codice seguente nel file **index.mjs**. La funzione effettua una richiesta HTTP GET a un endpoint pubblico e restituisce il codice di risposta HTTP per verificare se la funzione ha accesso alla rete Internet pubblica.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/code-source-nodejs.png)
**Example Richiesta HTTP con async/await**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Seleziona la scheda **Test**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-tab.png)
1. Scegli **Test (Esegui test)**.
1. La funzione restituisce un codice di stato `200`. Ciò significa che la funzione dispone di un accesso a Internet in uscita.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-successful-200.png)
Se la funzione non riesce a raggiungere la rete Internet pubblica, ti verrà mostrato un messaggio di errore come questo:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. Nel riquadro **Codice sorgente** della console Lambda, incolla il seguente codice seguente nel file **lambda\$1function.py**. La funzione effettua una richiesta HTTP GET a un endpoint pubblico e restituisce il codice di risposta HTTP per verificare se la funzione ha accesso alla rete Internet pubblica.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Seleziona la scheda **Test**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-tab.png)
1. Scegli **Test (Esegui test)**.
1. La funzione restituisce un codice di stato `200`. Ciò significa che la funzione dispone di un accesso a Internet in uscita.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-successful-200.png)
Se la funzione non riesce a raggiungere la rete Internet pubblica, ti verrà mostrato un messaggio di errore come questo:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
# Connessione di endpoint VPC con interfaccia in entrata per Lambda
Se usi Amazon Virtual Private Cloud (Amazon VPC) per l'hosting delle risorse AWS, puoi stabilire una connessione tra il cloud privato virtuale (VPC) e Lambda. È possibile utilizzare questa connessione per richiamare la propria funzione Lambda senza attraversare l'Internet pubblico.
È possibile stabilire una connessione privata tra il VPC e Lambda creando un [endpoint VPC di interfaccia](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html). Gli endpoint di interfaccia sono alimentati da [AWS PrivateLink](https://aws.amazon.com/privatelink), che consente di accedere privatamente alle API Lambda APIs senza un gateway Internet, un dispositivo NAT, una connessione VPN o una connessione AWS Direct Connect. Le istanze presenti nel VPC non richiedono indirizzi IP pubblici per comunicare con le API Lambda. Il traffico tra il tuo VPC e Lambda non esce dalla rete AWS.
Ogni endpoint di interfaccia è rappresentato da una o più [interfacce di rete elastiche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) nelle sottoreti. Un'interfaccia di rete fornisce un indirizzo IP privato che funge da punto di ingresso per il traffico verso Lambda.
**Topics**
+ [
## Considerazioni per gli endpoint di interfaccia Lambda
](#vpc-endpoint-considerations)
+ [
## Creazione di un endpoint di interfaccia per Lambda
](#vpc-endpoint-create)
+ [
## Creazione di una policy degli endpoint di interfaccia per Lambda
](#vpc-endpoint-policy)
## Considerazioni per gli endpoint di interfaccia Lambda
Prima di impostare un endpoint di interfaccia per Lambda, esaminare l'argomento [Proprietà e limitazioni degli endpoint dell'interfaccia](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#vpce-interface-limitations) nella *Guida per l'utente di Amazon VPC*.
Puoi chiamare qualsiasi operazione API Lambda dal tuo VPC. Ad esempio, è possibile richiamare la funzione Lambda invocando l'API `Invoke` dall'interno del VPC. Per l'elenco completo delle API Lambda, vedere [Azioni](https://docs.aws.amazon.com/lambda/latest/dg/API_Operations.html) nella Guida di riferimento alle API Lambda.
`use1-az3` è una regione a capacità limitata per le funzioni Lambda VPC. L'utilizzo di sottoreti con le funzioni Lambda in questa zona di disponibilità non è consigliato perché, in caso di interruzione del servizio, potrebbe provocare una riduzione della ridondanza zonale.
### Keep-alive per connessioni persistenti
Lambda elimina le connessioni inattive nel tempo, quindi occorre utilizzare una direttiva keep-alive per mantenere le connessioni persistenti. Se si tenta di riutilizzare una connessione inattiva quando si richiama una funzione, si verificherà un errore di connessione. Per mantenere la connessione persistente, utilizzare la direttiva keep-alive associata al runtime. Per un esempio, vedere [Riutilizzo delle connessioni con Keep-Alive in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html) nella *Guida per gli sviluppatori di AWS SDK per JavaScript*.
### Considerazioni sulla fatturazione
Non vi è alcun costo aggiuntivo per accedere a una funzione Lambda tramite un endpoint di interfaccia. Per ulteriori informazioni sui prezzi di Lambda, consulta [Prezzi di AWS Lambda](https://aws.amazon.com/lambda/pricing/).
Prezzi standard per AWS PrivateLink si applica agli endpoint di interfaccia per Lambda. L'account AWS viene fatturato ogni ora che viene eseguito il provisioning di un endpoint di interfaccia in ogni zona di disponibilità e per i dati elaborati tramite l'endpoint dell'interfaccia. Per ulteriori informazioni sui prezzi degli endpoint di interfaccia, consulta [Prezzi di AWS PrivateLink](https://aws.amazon.com/privatelink/pricing/).
### Considerazioni sul peering VPC
È possibile connettere altri VPC al VPC con endpoint di interfaccia utilizzando [Peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). Il peering VPC è una connessione di rete tra due VPC. Puoi creare una connessione peering VPC tra i tuoi VPC oppure con un VPC in un altro account AWS. I VPC possono essere anche in due diverse regioni AWS.
Il traffico tra VPC peered rimane sulla rete AWS e non attraversa la rete Internet pubblica. Una volta eseguito il peering dei vPC, risorse come istanze Amazon Elastic Compute Cloud (Amazon EC2), istanze Amazon Relational Database Service (Amazon RDS) o funzioni Lambda abilitate per VPC in entrambi i VPC possono accedere all'API Lambda tramite gli endpoint di interfaccia creati in uno dei VPC.
## Creazione di un endpoint di interfaccia per Lambda
Puoi creare un endpoint di interfaccia per Lambda utilizzando la console Amazon VPC o AWS Command Line Interface (AWS CLI). Per ulteriori informazioni, consultare [Creazione di un endpoint di interfaccia](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint) nella *Guida per l'utente di Amazon VPC*.
**Per creare un endpoint di interfaccia per Lambda (console)**
1. Aprire la [pagina Endpoint](https://console.aws.amazon.com/vpc/home?#Endpoints) della console Amazon VPC.
1. Scegliere **Create Endpoint** (Crea endpoint).
1. In **Categoria del servizio**, assicurati che sia selezionato **Servizi AWS**.
1. Per **Nome servizio**, scegli **com.amazonaws.*region*.lambda**. Verificare che il **tipo** sia **Interfaccia**.
1. Creazione di un VPC e delle sottoreti
1. Per abilitare il DNS privato per l'endpoint di interfaccia, in **Enable DNS Name (Abilita nome DNS)**, selezionare la casella di controllo. Ti consigliamo di abilitare nomi host DNS privati per gli endpoint VPC per Servizi AWS. Ciò garantisce che le richieste che utilizzano gli endpoint del servizio pubblico, come le richieste effettuate tramite un SDK AWS, vengano risolte sull'endpoint VPC.
1. Per **gruppo di sicurezza**, scegliere uno o più gruppi di sicurezza.
1. Seleziona **Crea endpoint**.
Per utilizzare l'opzione DNS privato, è necessario impostare `enableDnsHostnames` e `enableDnsSupportattributes` del VPC. Per ulteriori informazioni, consulta [Visualizzazione e aggiornamento del supporto DNS per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating) nella *Guida per l'utente di Amazon VPC*. Se si abilita il DNS privato per l'endpoint di interfaccia, è possibile effettuare richieste API verso Lambda utilizzando il nome DNS predefinito per la regione, ad esempio ., `lambda.us-east-1.amazonaws.com`. Per ulteriori endpoint di servizio, vedere [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) in *Riferimenti generali di AWS*.
Per ulteriori informazioni, consultare [Accesso a un servizio tramite un endpoint di interfaccia](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint) in *Guida per l'utente di Amazon VPC*.
Per informazioni sulla creazione e sulla configurazione di un endpoint utilizzando CloudFormation, consulta la risorsa [AWS::EC2::VPCEndpoint](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html) nella *Guida per l'utente di AWS CloudFormation*.
**Per creare un endpoint di interfaccia per Lambda (AWS CLI)**
Utilizza il comando [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html) e specifica l'ID VPC, il tipo di endpoint VPC (interfaccia), il nome del servizio, le sottoreti per utilizzare l'endpoint e i gruppi di sicurezza da associare alle interfacce di rete dell'endpoint. Ad esempio:
```
aws ec2 create-vpc-endpoint
--vpc-id vpc-ec43eb89
--vpc-endpoint-type Interface
--service-name com.amazonaws.us-east-1.lambda
--subnet-id subnet-abababab
--security-group-id sg-1a2b3c4d
```
## Creazione di una policy degli endpoint di interfaccia per Lambda
Per controllare chi può utilizzare l'endpoint di interfaccia e a quali funzioni Lambda l'utente può accedere, è possibile allegare una policy endpoint all'endpoint. La policy specifica le informazioni riportate di seguito:
+ Il principale che può eseguire operazioni.
+ Le azioni che l'entità può eseguire.
+ Le risorse su cui l'utente/gruppo/ruolo può eseguire azioni.
Per ulteriori informazioni, consulta [Controllo degli accessi ai servizi con endpoint VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) nella *Guida per l'utente di Amazon VPC.*
**Esempio: policy endpoint di interfaccia per le azioni Lambda**
Di seguito è riportato un esempio di una policy endpoint per Lambda. Quando è collegata a un endpoint, questa policy consente all'utente `MyUser` di richiamare la funzione `my-function`.
**Nota**
Nella risorsa è necessario includere l'ARN della funzione qualificata e non qualificata.
```
{
"Statement":[
{
"Principal":
{
"AWS": "arn:aws:iam::111122223333:user/MyUser"
},
"Effect":"Allow",
"Action":[
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-east-2:123456789012:function:my-function",
"arn:aws:lambda:us-east-2:123456789012:function:my-function:*"
]
}
]
}
```
# Configurazione dell'accesso al file system per le funzioni Lambda
È possibile configurare una funzione per montare un file system Amazon Elastic File System (Amazon EFS) in una directory locale. Con Amazon EFS, il codice della funzione può accedere e modificare le risorse condivise in modo sicuro e ad alta concorrenza.
## Regioni supportate
Amazon EFS per Lambda è disponibile in tutte le [regioni commerciali](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#region) a eccezione di Asia Pacifico (Nuova Zelanda), Asia Pacifico (Taipei), Asia Pacifico (Malesia), Messico (centrale), Asia Pacifico (Thailandia) e Canada occidentale (Calgary).
**Topics**
+ [
## Regioni supportate
](#configuration-filesystem-supported-regions)
+ [
## Autorizzazioni del ruolo di esecuzione e dell'utente
](#configuration-filesystem-permissions)
+ [
## Configurazione di un file system e di un punto di accesso
](#configuration-filesystem-setup)
+ [
## Connessione a un file system (console)
](#configuration-filesystem-config)
## Autorizzazioni del ruolo di esecuzione e dell'utente
Se il file system non dispone di una policy AWS Identity and Access Management (IAM) configurata dall'utente, EFS utilizza una policy predefinita che consente l'accesso completo a qualsiasi client in grado di connettersi al file system tramite una destinazione di montaggio del file system. Se il file system dispone di una Policy IAM configurata dall'utente, il ruolo di esecuzione della funzione deve disporre delle autorizzazioni `elasticfilesystem` corrette.
**Autorizzazioni del ruolo di esecuzione**
+ **elasticfilesystem:ClientMount**
+ **elasticfilesystem:ClientWrite (non richiesto per connessioni di sola lettura)**
Queste autorizzazioni sono incluse nella policy gestita di **AmazonElasticFileSystemClientReadWriteAccess**. Inoltre, il ruolo di esecuzione deve avere le [autorizzazioni necessarie per connettersi al VPC del file system](configuration-vpc.md#configuration-vpc-permissions).
Quando si configura un file system, Lambda utilizza le autorizzazioni dell'utente per verificare le destinazioni di montaggio. Per configurare una funzione affinché possa connettersi a un file system, l'utente deve disporre delle seguenti autorizzazioni:
**Autorizzazioni degli utenti**
+ **elasticfilesystem:DescribeMountTargets**
## Configurazione di un file system e di un punto di accesso
Creare un file system in Amazon EFS con una destinazione di montaggio in ogni zona di disponibilità a cui la funzione si connette. Per prestazioni e resilienza, utilizzare almeno due zone di disponibilità. Ad esempio, in una configurazione semplice è possibile avere un VPC con due sottoreti private in zone di disponibilità separate. La funzione si connette a entrambe le sottoreti e in ciascuna di esse è disponibile una destinazione di montaggio. Assicurarsi che il traffico NFS (porta 2049) sia consentito dai gruppi di sicurezza utilizzati dalla funzione e dalle destinazioni di montaggio.
**Nota**
Quando si crea un file system, si sceglie una modalità di prestazioni che non può essere modificata in un secondo momento. La modalità **Uso generale** ha una latenza inferiore e la modalità **I/O max** supporta throughput e IOPS massimi più elevati. Per assistenza nella scelta, consulta [Prestazioni di Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/performance.html) nella *Amazon Elastic File System User Guide*.
Un punto di accesso collega ogni istanza della funzione alla destinazione di montaggio corretta per la zona di disponibilità a cui si connette. Per ottenere prestazioni ottimali, creare un punto di accesso con un percorso non root e limitare il numero di file creati in ogni directory. Nell'esempio seguente viene creata una directory denominata `my-function` nel file system e viene impostato l'ID proprietario su 1001 con autorizzazioni di directory standard (755).
**Example Configurazione del punto di accesso**
+ **Nome** – `files`
+ **ID utente** – `1001`
+ **ID gruppo** – `1001`
+ **Percorso** – `/my-function`
+ **Autorizzazioni** – `755`
+ **ID utente proprietario** – `1001`
+ **ID utente gruppo** – `1001`
Quando una funzione utilizza il punto di accesso, riceve l'ID utente 1001 e ha accesso completo alla directory.
Per ulteriori informazioni, consulta i seguenti argomenti nella *Amazon Elastic File System User Guide*.
+ [Creazione di risorse per Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/creating-using.html)
+ [Utilizzo di utenti, gruppi e autorizzazioni](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html)
## Connessione a un file system (console)
Una funzione si connette a un file system tramite la rete locale in un VPC. Le sottoreti a cui si connette la funzione possono essere le stesse sottoreti che contengono punti di montaggio per il file system o sottoreti nella stessa zona di disponibilità che possono instradare il traffico NFS (porta 2049) al file system.
**Nota**
Se la funzione non è già connessa a un VPC, consulta [Consentire alle funzioni Lambda l'accesso alle risorse in un Amazon VPC](configuration-vpc.md).
**Configurazione dell'accesso al file system**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Scegliere **Configuration (Configurazione)** e quindi scegliere **File systems (File system)**.
1. In **File system**, scegliere **Aggiungi file system**.
1. Configurare le proprietà seguenti:
+ **File system EFS**: il punto di accesso per un file system nello stesso VPC.
+ **Percorso di montaggio locale**: la posizione in cui il file system è montato sulla funzione Lambda, a partire da `/mnt/`.
**Prezzi**
Amazon EFS prevede addebiti per lo storage e il throughput, con tariffe che variano in base alla classe di storage. Per informazioni dettagliate, consulta [Prezzi di Amazon EFS](https://aws.amazon.com/efs/pricing).
Lambda prevede addebiti per il trasferimento dei dati tra VPC. Questo vale solo se il VPC della funzione è collegato in peering a un altro VPC con un file system. Le tariffe sono le stesse del trasferimento di dati Amazon EC2 tra VPC nella stessa regione. Per informazioni dettagliate, consulta [Prezzi di Lambda](https://aws.amazon.com/lambda/pricing).
# Creare un alias per una funzione Lambda
È possibile creare alias per la funzione Lambda. Un alias Lambda è un puntatore a una versione della funzione che è possibile aggiornare. Gli utenti possono accedere alla versione della funzione utilizzando l'alias nome della risorsa Amazon (ARN). Quando si distribuisce una nuova versione, è possibile aggiornare l'alias per utilizzare la nuova versione o dividere il traffico tra due versioni.
------
#### [ Console ]
**Per creare un alias tramite la console**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Scegliere **Aliases (Alias)** e quindi **Create alias (Crea alias)**.
1. Nella pagina **Create alias (Crea alias)**, eseguire le operazioni seguenti:
1. Immettere un **Name (Nome)** per la query.
1. (Facoltativo) Immettere una **Description (Descrizione)** per l'alias.
1. Per **Version (Versione)**, scegliere una versione della funzione a cui si desidera puntare l'alias.
1. (Facoltativo) Per configurare il routing sull'alias, espandere **Weighted alias (Alias ponderato)**. Per ulteriori informazioni, consulta [Implementare le implementazioni canary Lambda utilizzando un alias ponderato](configuring-alias-routing.md).
1. Seleziona **Save (Salva**.
------
#### [ AWS CLI ]
Per creare un alias tramite la AWS Command Line Interface (AWS CLI), utilizza il comando [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html).
```
aws lambda create-alias \
--function-name my-function \
--name alias-name \
--function-version version-number \
--description " "
```
Per modificare un alias in modo che punti a una nuova versione della funzione, utilizza il comando [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html).
```
aws lambda update-alias \
--function-name my-function \
--name alias-name \
--function-version version-number
```
Per eliminare un alias, utilizza il comando [delete-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-alias.html).
```
aws lambda delete-alias \
--function-name my-function \
--name alias-name
```
I comandi AWS CLI nei passaggi precedenti corrispondono alle seguenti operazioni API Lambda:
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
+ [DeleteAlias](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteAlias.html)
------
# Utilizzo degli alias Lambda nelle origini eventi e nelle policy di autorizzazioni
Ogni alias ha un ARN univoco. Un alias può puntare solo a una versione della funzione, non a un altro alias. È possibile aggiornare un alias in modo che punti a una nuova versione della funzione.
Le origini eventi, ad esempio Amazon Simple Storage Service (Amazon S3), richiamano la funzione Lambda. Queste origini eventi mantengono un mapping che identifica la funzione da richiamare quando si verificano gli eventi. Se si specifica un alias di funzione Lambda nella configurazione del mapping, non è necessario aggiornare il mapping quando cambia la versione della funzione. Per ulteriori informazioni, consulta [In che modo Lambda elabora i record provenienti da origini eventi basate su flussi e code](invocation-eventsourcemapping.md).
In una policy di risorsa, è possibile concedere le autorizzazioni per le origini eventi per utilizzare la funzione Lambda. Se si specifica un ARN di alias nella policy, non è necessario aggiornare la policy quando cambia la versione della funzione.
## Policy delle risorse
È possibile utilizzare una [policy basata sulle risorse](access-control-resource-based.md) per concedere a un servizio, a una risorsa o a un account l'accesso alla funzione. L'ambito di tale autorizzazione dipende dal fatto che venga applicata a un alias, a una versione o all'intera funzione. Ad esempio, se si utilizza un nome alias (ad esempio `helloworld:PROD`), l'autorizzazione consente di richiamare la funzione `helloworld` utilizzando l'ARN dell'alias (`helloworld:PROD`).
Se si tenta di richiamare la funzione senza un alias o una versione specifica, viene visualizzato un errore di autorizzazione. Questo errore di autorizzazione si verifica anche se si tenta di richiamare direttamente la versione della funzione associata all'alias.
Ad esempio, il comando AWS CLI seguente concede le autorizzazioni Amazon S3 per richiamare l'alias PROD della funzione `helloworld` se Amazon S3 agisce per conto di `amzn-s3-demo-bucket`.
```
aws lambda add-permission \
--function-name helloworld \
--qualifier PROD \
--statement-id 1 \
--principal s3.amazonaws.com \
--action lambda:InvokeFunction \
--source-arn arn:aws:s3:::amzn-s3-demo-bucket \
--source-account 123456789012
```
Per ulteriori informazioni sull'utilizzo dei nomi delle risorse nelle policy, consulta [Ottimizzazione delle sezioni Risorse e Condizioni delle policy](lambda-api-permissions-ref.md).
# Implementare le implementazioni canary Lambda utilizzando un alias ponderato
È possibile utilizzare un alias ponderato per suddividere il traffico tra due diverse [versioni](configuration-versions.md) della stessa funzione. Con questo approccio, puoi testare nuove versioni delle tue funzioni con una piccola percentuale di traffico e ripristinarle rapidamente se necessario. Questa operazione è nota come [implementazione canary](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/canary-deployments.html). Le implementazioni Canary differiscono dalle blue/green distribuzioni in quanto espongono la nuova versione solo a una parte delle richieste anziché spostare tutto il traffico contemporaneamente.
È possibile puntare un alias a un massimo di due versioni della funzione Lambda. Le versioni devono soddisfare i seguenti criteri:
+ Entrambe le versioni devono disporre dello stesso [ruolo di esecuzione](lambda-intro-execution-role.md).
+ Entrambe le versioni devono avere la stessa configurazione della [coda dead-letter](invocation-async-retain-records.md#invocation-dlq) o nessuna configurazione della coda dead-letter.
+ Entrambe le versioni devono essere pubblicate. L'alias non può puntare a `$LATEST`.
**Nota**
Lambda utilizza un modello probabilistico semplice per distribuire il traffico tra le due versioni delle funzioni. A livelli di traffico bassi, è possibile che si verifichi una variazione elevata tra la percentuale di traffico configurata e quella effettiva in ciascuna versione. Se la tua funzione utilizza la concorrenza con provisioning, puoi evitare [invocazioni spillover](monitoring-metrics-types.md#invocation-metrics) configurando un numero maggiore di istanze di concorrenza sottoposte a provisioning durante il periodo in cui il routing degli alias è attivo.
## Creare un alias ponderato
------
#### [ Console ]
**Per configurare il routing utilizzando la console**
**Nota**
Verificare che la funzione abbia almeno due versioni pubblicate. Per creare versioni aggiuntive, seguire le istruzioni in [Creazione di versioni delle funzioni](configuration-versions.md#configuration-versions-config).
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegliere una funzione.
1. Scegliere **Aliases (Alias)** e quindi **Create alias (Crea alias)**.
1. Nella pagina **Create alias (Crea alias)**, eseguire le operazioni seguenti:
1. Immettere un **Name (Nome)** per la query.
1. (Facoltativo) Immettere una **Description (Descrizione)** per l'alias.
1. Per **Version (Versione)**, scegliere la prima versione della funzione a cui si desidera puntare l'alias.
1. Espandere **Weighted alias (Alias ponderato)**.
1. In **Additional version (Versione aggiuntiva)**, scegliere la seconda versione della funzione a cui si desidera puntare l'alias.
1. Per **Weight (%) (Ponderazione %)**, digitare un valore di ponderazione per la funzione. *Weight* (Ponderazione) è la percentuale di traffico assegnata alla versione quando l'alias viene invocato. La prima versione riceve la ponderazione residua. Ad esempio se si specifica il 10 percento per **Additional version (Versione aggiuntiva)**, alla prima versione viene automaticamente assegnato il 90 percento.
1. Scegli **Save** (Salva).
------
#### [ AWS CLI ]
Utilizzate i comandi [create-alias e [AWS CLI update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html)](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html) per configurare i pesi del traffico tra due versioni di funzioni. Quando crei o aggiorni l'alias, specifica il peso del traffico nel parametro `routing-config`.
Nell'esempio seguente viene creato un alias della funzione Lambda denominato **routing-alias** che punta alla versione 1 della funzione. La versione 2 della funzione riceve il 3% del traffico. Il restante 97 percento del traffico viene instradato alla versione 1.
```
aws lambda create-alias \
--name routing-alias \
--function-name my-function \
--function-version 1 \
--routing-config AdditionalVersionWeights={"2"=0.03}
```
Utilizza il comando `update-alias` per aumentare la percentuale di traffico in ingresso alla versione 2. Nell'esempio seguente, aumenti il traffico al 5%.
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--routing-config AdditionalVersionWeights={"2"=0.05}
```
Per instradare tutto il traffico alla versione 2, utilizza il comando `update-alias` per modificare la proprietà `function-version` in modo che l'alias punti alla versione 2. Il comando reimposta anche la configurazione di routing.
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--function-version 2 \
--routing-config AdditionalVersionWeights={}
```
I AWS CLI comandi nei passaggi precedenti corrispondono alle seguenti operazioni dell'API Lambda:
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
------
## Determinazione della versione richiamata
Quando configuri i pesi del traffico tra due versioni di funzioni, esistono due modi per determinare la versione della funzione Lambda invocata:
+ **CloudWatch Registri**: Lambda emette automaticamente `START` una voce di registro che contiene l'ID di versione richiamato per ogni chiamata di funzione. Esempio:
`START RequestId: 1dh194d3759ed-4v8b-a7b4-1e541f60235f Version: 2`
Per le invocazioni di alias Lambda utilizza la dimensione `ExecutedVersion` per filtrare i dati del parametro dalla versione richiamata. Per ulteriori informazioni, consulta [Visualizzazione di parametri per le funzioni Lambda](monitoring-metrics-view.md).
+ **Payload della risposta (invocazioni sincrone)** - Le risposte a invocazioni sincrone della funzione includono un'intestazione `x-amz-executed-version` per indicare quale versione della funzione è stata invocata.
## Creare una implementazione continua con alias ponderati
Usa AWS CodeDeploy and AWS Serverless Application Model (AWS SAM) per creare una distribuzione continua che rilevi automaticamente le modifiche al codice della funzione, distribuisca una nuova versione della funzione e aumenti gradualmente la quantità di traffico che fluisce verso la nuova versione. La quantità di traffico e la velocità dell'aumento sono parametri che è possibile configurare.
In una distribuzione continua, AWS SAM esegue le seguenti attività:
+ Configura la funzione Lambda e crea un alias. La configurazione del routing con alias ponderati è la funzionalità che implementa l'implementazione in sequenza.
+ Crea un' CodeDeploy applicazione e un gruppo di distribuzione. Il gruppo di distribuzione gestisce l'implementazione in sequenza e il rollback (se necessario).
+ Rileva quando viene creata una nuova versione della funzione Lambda.
+ Trigger CodeDeploy per avviare la distribuzione della nuova versione.
### Modello di esempio AWS SAM
Nell'esempio seguente viene illustrato un [modello AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html) per una semplice distribuzione in sequenza.
```
AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A sample SAM template for deploying Lambda functions
Resources:
# Details about the myDateTimeFunction Lambda function
myDateTimeFunction:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Handler: myDateTimeFunction.handler
Runtime: nodejs24.x
# Creates an alias named "live" for the function, and automatically publishes when you update the function.
AutoPublishAlias: live
DeploymentPreference:
# Specifies the deployment configuration
Type: Linear10PercentEvery2Minutes
```
Questo modello definisce una funzione Lambda denominata `myDateTimeFunction` con le seguenti proprietà.
**AutoPublishAlias **
La proprietà `AutoPublishAlias` crea un alias denominato `live`. Inoltre, il framework AWS SAM rileva automaticamente quando viene salvato il nuovo codice per la funzione. Il framework pubblica quindi una nuova versione di funzione e aggiorna l'alias `live` in modo che punti alla nuova versione.
**DeploymentPreference**
La `DeploymentPreference` proprietà determina la velocità con cui l' CodeDeploy applicazione sposta il traffico dalla versione originale della funzione Lambda alla nuova versione. Il valore `Linear10PercentEvery2Minutes` sposta un ulteriore dieci percento del traffico alla nuova versione ogni due minuti.
Per l'elenco delle configurazioni di distribuzione predefinite, consulta [Configurazioni di distribuzione](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html).
Per ulteriori informazioni su come creare distribuzioni continue con CodeDeploy and AWS SAM, consulta quanto segue:
+ [Tutorial: Implementa una funzione CodeDeploy Lambda aggiornata con e AWS Serverless Application Model](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-lambda-sam.html)
+ [Distribuzione graduale di applicazioni serverless con AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/automating-updates-to-serverless-apps.html)
# Gestire le versioni delle funzioni Lambda
Puoi utilizzare le versioni per gestire la distribuzione delle funzioni . Ad esempio, è possibile pubblicare una nuova versione di una funzione per il test beta senza influire sugli utenti della versione di produzione stabile. Lambda crea una nuova versione della funzione ogni volta che pubblichi la funzione. La nuova versione è una copia della versione non pubblicata della funzione. La versione non pubblicata è denominata `$LATEST`.
È importante sottolineare che ogni volta che implementi il codice della funzione, sovrascrivi il codice corrente in `$LATEST`. Per salvare l'iterazione corrente di `$LATEST`, crea una nuova versione della funzione. Se `$LATEST` è identica a una versione pubblicata in precedenza, non potrai creare una nuova versione finché non implementerai le modifiche su `$LATEST`. Queste modifiche possono includere l'aggiornamento del codice o la modifica delle impostazioni di configurazione della funzione.
Dopo aver pubblicato la versione di una funzione, il codice, il runtime, l'architettura, la memoria, i livelli e la maggior parte delle altre impostazioni di configurazione saranno immutabili. Ciò significa che non potrai modificare queste impostazioni senza pubblicare una nuova versione da `$LATEST`. È possibile configurare i seguenti elementi per una versione pubblicata della funzione:
+ [Trigger](lambda-services.md#lambda-invocation-trigger)
+ [Destinazioni](invocation-async-retain-records.md#create-destination)
+ [Concorrenza fornita](provisioned-concurrency.md)
+ [Invocazione asincrona](invocation-async.md)
+ [Connessioni a database e proxy](services-rds.md#rds-configuration)
**Nota**
Quando si utilizzano i [controlli di gestione del runtime](runtimes-update.md#runtime-management-controls) con la modalità **Auto**, la versione di runtime utilizzata dalla versione della funzione viene aggiornata automaticamente. Quando si utilizza la modalità **Function update** (Aggiornamento delle funzioni) o **Manual** (Manuale), la versione di runtime non viene aggiornata. Per ulteriori informazioni, consulta [Informazioni su come Lambda gestisce gli aggiornamenti delle versioni di runtime](runtimes-update.md).
**Topics**
+ [
## Creazione di versioni delle funzioni
](#configuration-versions-config)
+ [
## Utilizzo delle versioni
](#versioning-versions-using)
+ [
## Concessione di autorizzazioni
](#versioning-permissions)
## Creazione di versioni delle funzioni
Puoi modificare il codice della funzione e le impostazioni solo sulla versione non pubblicata di una funzione. Quando pubblichi una versione, il codice e la maggior parte delle impostazioni sono bloccati da Lambda per garantire un'esperienza coerente agli utenti di quella versione.
È possibile creare una versione della funzione utilizzando la console Lambda.
**Per creare una nuova versione della funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli una funzione e quindi seleziona la scheda **Versioni**.
1. Nella pagina di configurazione delle versioni, scegliere **Publish new version (Pubblica nuova versione)**.
1. (Facoltativo) Immettere una descrizione della versione.
1. Seleziona **Pubblica**.
In alternativa, puoi pubblicare una versione di una funzione utilizzando l'operazione [PublishVersion](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html)API.
Il AWS CLI comando seguente pubblica una nuova versione di una funzione. La risposta restituisce le informazioni di configurazione sulla nuova versione, tra cui il numero della versione e l'ARN della funzione con il suffisso della versione.
```
aws lambda publish-version --function-name my-function
```
Verrà visualizzato l’output seguente:
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Version": "1",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "function.handler",
"Runtime": "nodejs24.x",
...
}
```
**Nota**
Lambda assegna numeri di sequenza crescenti in modo monotono per il controllo delle versioni. Lambda non riutilizza mai i numeri di versione, anche dopo aver eliminato e ricreato una funzione.
## Utilizzo delle versioni
Puoi fare riferimento alla tua funzione Lambda usando un ARN qualificato o un ARN non qualificato.
+ **ARN qualificato** – L'ARN della funzione con il suffisso della versione. L'esempio seguente fa riferimento alla versione 42 della funzione `helloworld`.
```
arn:aws:lambda:aws-region:acct-id:function:helloworld:42
```
+ **ARN non qualificato** – L'ARN della funzione senza il suffisso della versione.
```
arn:aws:lambda:aws-region:acct-id:function:helloworld
```
È possibile utilizzare un ARN qualificato o non qualificato in tutte le operazioni API pertinenti. Tuttavia, non è possibile utilizzare un ARN non qualificato per creare un alias.
Se decidi di non pubblicare le versioni di funzione, puoi richiamare la funzione utilizzando l'ARN qualificato o non qualificato nel [mapping dell'origine eventi](invocation-eventsourcemapping.md). Quando richiami una funzione utilizzando un ARN non completo, Lambda richiama implicitamente `$LATEST`.
L'ARN qualificato per ogni versione di funzione Lambda è univoco. Dopo aver pubblicato una versione, non è possibile modificare l'ARN o il codice di funzione.
Lambda pubblica una nuova versione della funzione solo se il codice non è mai stato pubblicato o se il codice è cambiato rispetto all'ultima versione pubblicata. Se non ci sono modifiche, la versione della funzione rimane la versione pubblicata più di recente.
Quando pubblichi una versione, Lambda crea uno snapshot immutabile del codice e della configurazione della funzione. Non tutte le modifiche alla configurazione attivano la pubblicazione di una nuova versione. Le seguenti modifiche alla configurazione qualificano una funzione per la pubblicazione della versione:
+ Codice della funzione
+ Variabili di ambiente
+ Runtime
+ Gestore
+ Livelli
+ Dimensioni della memoria
+ Timeout
+ Configurazione VPC
+ Configurazione coda DLQ
+ Ruolo IAM
+ Description
+ Architettura (x86\$164 o arm64)
+ Dimensioni di archiviazione temporanea
+ Tipo di pacchetto
+ Configurazione della registrazione
+ Configurazione del file system
+ SnapStart
+ Configurazione del tracciamento
Impostazioni operative come la [simultaneità riservata](configuration-concurrency.md) non attivano la pubblicazione di una nuova versione quando vengono modificate.
## Concessione di autorizzazioni
È possibile utilizzare una [policy basata sulle risorse](access-control-resource-based.md) o una [policy basata sull'identità](access-control-identity-based.md) per concedere l'accesso alla funzione. L'ambito dell'autorizzazione dipende dal fatto che la policy venga applicata a una funzione o a una versione di una funzione. Per ulteriori informazioni sui nomi delle risorse delle funzioni nelle policy, consulta [Ottimizzazione delle sezioni Risorse e Condizioni delle policy](lambda-api-permissions-ref.md).
È possibile semplificare la gestione delle fonti di eventi e delle politiche AWS Identity and Access Management (IAM) utilizzando gli alias delle funzioni. Per ulteriori informazioni, consulta [Creare un alias per una funzione Lambda](configuration-aliases.md).
# Uso dei tag sulle funzioni Lambda
È possibile taggare le funzioni per organizzare e gestire le risorse. I tag sono coppie chiave-valore a forma libera associate alle risorse supportate su Servizi AWS. Per ulteriori informazioni sui casi d'uso dei tag, consulta [Strategie di tagging comuni nella Guida AWS](https://docs.aws.amazon.com//tag-editor/latest/userguide/best-practices-and-strats.html#tag-strategies) *alle risorse di etichettatura e all'editor di tag*.
I tag si applicano a livello di funzione, non a versioni o alias. I tag non fanno parte della configurazione specifica della versione che AWS Lambda crea un'istantanea di quando si pubblica una versione. Per visualizzare e aggiornare i tag, puoi utilizzare l'API Lambda. Puoi anche visualizzare e aggiornare i tag mentre gestisci una funzione specifica nella console Lambda.
**Topics**
+ [
## Autorizzazioni necessarie per lavorare con i tag
](#fxn-tags-required-permissions)
+ [
## Utilizzo di tag con la console Lambda
](#using-tags-with-the-console)
+ [
## Usare i tag con AWS CLI
](#configuration-tags-cli)
## Autorizzazioni necessarie per lavorare con i tag
Per consentire a un'identità AWS Identity and Access Management (IAM) (utente, gruppo o ruolo) di leggere o impostare tag su una risorsa, concedile le autorizzazioni corrispondenti:
+ **lambda: ListTags** —Quando una risorsa ha dei tag, concedi questa autorizzazione a chiunque abbia bisogno di richiamarla. `ListTags` Per le funzioni con tag, questa autorizzazione è necessaria anche per `GetFunction`.
+ **lambda: TagResource** —Concedi questa autorizzazione a chiunque abbia bisogno di chiamare `TagResource` o eseguire un tag durante la creazione.
Facoltativamente, prendi in considerazione la possibilità di concedere anche l'UntagResourceautorizzazione **lambda:** per consentire `UntagResource` le chiamate alla risorsa.
Per ulteriori informazioni, consulta [Policy IAM basate sull'identità per Lambda](access-control-identity-based.md).
## Utilizzo di tag con la console Lambda
Puoi utilizzare la console Lambda per creare funzioni che hanno tag, aggiungere tag a funzioni esistenti e filtrare le funzioni in base ai tag aggiunti.
**Per aggiungere tag durante la creazione di una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli **Crea funzione**.
1. Scegliere **Author from scratch** (Crea da zero) o **Container image** (Immagine di container).
1. In **Informazioni di base**, configura la tua funzione. Per ulteriori informazioni sulla configurazione delle funzioni, consulta [Configurazione delle funzioni AWS Lambda](lambda-functions.md).
1. Espandi **Advanced settings** (Impostazioni avanzate), quindi seleziona **Enable tags** (Abilita tag).
1. Scegli **Add new tag (Aggiungi nuovo tag)** e completa i campi **Key** (Chiave) e facoltativamente **Value** (Valore). Ripetere questa fase per aggiungere altri tag.
1. Scegli **Crea funzione**.
**Per aggiungere tag a una funzione esistente**
1. Aprire la pagina [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funzioni) della console Lambda.
1. Scegliere il nome della funzione.
1. Scegli **Configuration** (Configurazione), quindi **Tags** (Tag).
1. In **Tag**, scegli **Gestisci tag**.
1. Scegli **Add new tag (Aggiungi nuovo tag)** e completa i campi **Key** (Chiave) e facoltativamente **Value** (Valore). Ripetere questa fase per aggiungere altri tag.
1. Scegli **Save** (Salva).
**Per filtrare le funzioni con i tag**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli la barra di ricerca per visualizzare un elenco di proprietà della funzione e chiavi di tag.
1. Scegliete una chiave di tag per visualizzare un elenco di valori in uso nella regione corrente. AWS
1. Seleziona **Usa: "nome-tag"** per vedere tutte funzioni taggate con questa chiave, oppure scegli un **operatore** per filtrare ulteriormente in base al valore.
1. Seleziona il valore del tag da filtrare in base a una combinazione di chiave e valore del tag.
La barra di ricerca supporta anche la ricerca di chiavi tag. Immetti `tag` per visualizzare solo un elenco di chiavi di tag oppure immetti il nome di una chiave per trovarla nell'elenco.
## Usare i tag con AWS CLI
Puoi aggiungere e rimuovere tag sulle risorse Lambda esistenti, incluse le funzioni, con l'API Lambda. Puoi aggiungere i tag anche quando crei una funzione, il che ti consente di mantenere etichettata una risorsa per tutto il suo ciclo di vita.
### Aggiornamento dei tag con il tag Lambda APIs
Puoi aggiungere e rimuovere tag per le risorse Lambda supportate tramite le operazioni [TagResource](https://docs.aws.amazon.com/lambda/latest/api/API_TagResource.html)e [UntagResource](https://docs.aws.amazon.com/lambda/latest/api/API_UntagResource.html)API.
Puoi chiamare queste operazioni tramite la AWS CLI. Per aggiungere i tag a una risorsa esistente, utilizza il comando `tag-resource`. Questo esempio aggiunge due tag, uno con la chiave *Department* e uno con la chiave*CostCenter*.
```
aws lambda tag-resource \
--resource arn:aws:lambda:us-east-2:123456789012:resource-type:my-resource \
--tags Department=Marketing,CostCenter=1234ABCD
```
Pr rimuovere i tag, utilizza il comando `untag-resource`. Questo esempio rimuove il tag con la chiave*Department*.
```
aws lambda untag-resource --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier \
--tag-keys Department
```
### Aggiunta di tag durante la creazione di una funzione
Per creare una nuova funzione Lambda con tag, usa l'operazione [CreateFunction](https://docs.aws.amazon.com//lambda/latest/api/API_CreateFunction.html)API. Specifica il parametro `Tags`. È possibile richiamare questa operazione con il comando della CLI `create-function` e l'opzione --tags. Prima di utilizzare il parametro tags con `CreateFunction`, assicurati che il tuo ruolo disponga dell'autorizzazione per taggare le risorse oltre alle normali autorizzazioni necessarie per questa operazione. Per ulteriori informazioni sulle autorizzazioni per il tagging, consulta [Autorizzazioni necessarie per lavorare con i tag](#fxn-tags-required-permissions). Questo esempio aggiunge due tag, uno con la chiave *Department* e uno con la chiave*CostCenter*.
```
aws lambda create-function --function-name my-function
--handler index.js --runtime nodejs24.x \
--role arn:aws:iam::123456789012:role/lambda-role \
--tags Department=Marketing,CostCenter=1234ABCD
```
### Visualizzazione dei tag su una funzione
Per visualizzare i tag applicati a una risorsa Lambda specifica, utilizza l'operazione API `ListTags`. Per ulteriori informazioni, consulta [ListTags](https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html).
Puoi richiamare questa operazione con il `list-tags` AWS CLI comando fornendo un ARN (Amazon Resource Name).
```
aws lambda list-tags --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier
```
Puoi visualizzare i tag applicati a una risorsa specifica con l'operazione [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html)API. Funzionalità comparabili non sono disponibili per altri tipi di risorse.
È possibile richiamare questa operazione utilizzando il comando `get-function` della CLI:
```
aws lambda get-function --function-name my-function
```
### Filtro delle risorse per tag
È possibile utilizzare l'operazione AWS Resource Groups Tagging API [GetResources](https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_GetResources.html)API per filtrare le risorse in base ai tag. L'operazione `GetResources` riceve fino a 10 filtri, ognuno dei quali contenente una chiave di tag e un massimo di 10 valori di tag. Fornisci `GetResources` con un `ResourceType` per filtrare in base a tipi di risorse specifiche.
È possibile richiamare questa operazione utilizzando il `get-resources` AWS CLI comando. Per esempi di utilizzo di `get-resources`, consulta [get-resources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/resourcegroupstaggingapi/get-resources.html#examples) nella *Riferimento ai comandi CLI di AWS *.
# Streaming di risposte per le funzioni Lambda
Le funzioni Lambda possono trasmettere nativamente i payload di risposta ai client tramite la [funzione Lambda URLs](urls-configuration.md) o utilizzando l'[InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html)API (tramite l' AWS SDK o le chiamate API dirette). La tua funzione Lambda può anche trasmettere i payload di risposta tramite l'[integrazione proxy di Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html), che utilizza l'[InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html)API per richiamare la tua funzione. Lo streaming delle risposte può favorire le applicazioni sensibili alla latenza migliorando le prestazioni del time to first byte (TTFB). Questo perché consente di inviare risposte parziali al client non appena diventano disponibili. Inoltre, le funzioni di streaming di risposta possono restituire payload fino a 200 MB, rispetto al massimo di 6 MB per le risposte bufferizzate. Lo streaming di una risposta significa anche che la funzione non deve contenere l'intera risposta in memoria. Per risposte molto grandi, ciò può ridurre la quantità di memoria necessaria per configurare la funzione.
**Nota**
Lo streaming di risposta Lambda non è ancora disponibile in tutti. Regioni AWS Per informazioni sulla disponibilità delle funzionalità per [regione, consulta AWS le funzionalità di](https://builder.aws.com/build/capabilities) Builder Center.
La velocità con cui Lambda trasmette le tue risposte dipende dalla dimensione della risposta. La velocità di streaming per i primi 6 MB di risposta della funzione è illimitata. Per le risposte superiori a 6 MB, il resto della risposta è soggetto a un limite di larghezza di banda. Per ulteriori informazioni sulla larghezza di banda dello streaming, consulta la sezione [Limiti di larghezza di banda per lo streaming delle risposte](#config-rs-bandwidth-cap).
Le risposte in streaming comportano costi e le risposte in streaming non vengono interrotte o interrotte quando la connessione del client che effettua la chiamata viene interrotta. Ai clienti verrà fatturata l'intera durata della funzione, quindi i clienti devono prestare attenzione quando configurano lunghi timeout di funzionamento.
Lambda supporta lo streaming delle risposte sui runtime gestiti di Node.js. Per altri linguaggi, incluso Python, puoi [utilizzare un runtime personalizzato con un'integrazione API Runtime personalizzata](runtimes-custom.md#runtimes-custom-response-streaming) per lo streaming delle risposte o utilizzare il [Lambda](https://github.com/awslabs/aws-lambda-web-adapter) Web Adapter.
**Nota**
Quando testi la funzione tramite la console Lambda, vedrai sempre le risposte come memorizzate nel buffer.
**Topics**
+ [
## Limiti di larghezza di banda per lo streaming delle risposte
](#config-rs-bandwidth-cap)
+ [
## Compatibilità VPC con streaming di risposta
](#config-rs-vpc-compatibility)
+ [
# Scrittura di funzioni Lambda abilitate allo streaming delle risposte
](config-rs-write-functions.md)
+ [
# Richiamo di una funzione abilitata allo streaming di risposte utilizzando la funzione Lambda URLs
](config-rs-invoke-furls.md)
+ [
# Tutorial: creazione di una funzione Lambda di streaming delle risposte con un URL della funzione
](response-streaming-tutorial.md)
## Limiti di larghezza di banda per lo streaming delle risposte
I primi 6 MB del payload di risposta della funzione hanno una larghezza di banda illimitata. Dopo questa raffica iniziale, Lambda trasmette la tua risposta a una velocità massima di 2. MBps Se le risposte delle tue funzioni non superano mai i 6 MB, questo limite di larghezza di banda non verrà mai applicato.
**Nota**
I limiti di larghezza di banda si applicano solo al payload di risposta della funzione e non all'accesso alla rete da parte della funzione.
La velocità della larghezza di banda illimitata varia in base a una serie di fattori, inclusa la velocità di elaborazione della funzione. Normalmente puoi aspettarti una frequenza superiore a 2 MBps per i primi 6 MB di risposta della funzione. Se la tua funzione trasmette in streaming una risposta a una destinazione esterna AWS, la velocità di streaming dipende anche dalla velocità della connessione Internet esterna.
## Compatibilità VPC con streaming di risposta
Quando utilizzi le funzioni Lambda in un ambiente VPC, per lo streaming di risposta è importante tenere in considerazione quanto segue:
+ La funzione Lambda URLs non supporta lo streaming di risposte all'interno di un ambiente VPC.
+ Puoi utilizzare lo streaming di risposte all'interno di un VPC richiamando la funzione Lambda tramite l'SDK utilizzando l' AWS API. `InvokeWithResponseStream` Ciò richiede la configurazione degli endpoint VPC appropriati per Lambda.
+ Per gli ambienti VPC, dovrai creare un endpoint VPC di interfaccia per Lambda per abilitare la comunicazione tra le tue risorse nel VPC e il servizio Lambda.
Un'architettura tipica per lo streaming di risposta in un VPC potrebbe includere:
```
Client in VPC -> Interface VPC endpoint for Lambda -> Lambda function -> Response streaming back through the same path
```
# Scrittura di funzioni Lambda abilitate allo streaming delle risposte
La scrittura del gestore per le funzioni di streaming delle risposte è diversa dai modelli di gestore tipici. Quando scrivi funzioni di streaming, assicurati di completare le seguenti operazioni:
+ Completa la funzione con il decoratore `awslambda.streamifyResponse()`. L'oggetto globale `awslambda` è fornito dall'ambiente di runtime Node.js di Lambda.
+ Termina il flusso in modo corretto per assicurarti che tutta l'elaborazione dei dati sia completa.
## Configurazione di un gestore delle funzioni per lo streaming delle risposte
Per indicare al runtime che Lambda deve trasmettere in streaming le risposte della funzione, è necessario racchiudere la funzione con il decoratore `streamifyResponse()`. Questo indica al runtime di utilizzare il percorso logico corretto per lo streaming delle risposte e consente alla funzione di trasmettere le risposte.
Il decoratore `streamifyResponse()` accetta una funzione che accetta i seguenti parametri:
+ `event`: fornisce informazioni sull'evento di chiamata dell'URL della funzione, ad esempio il metodo HTTP, i parametri della query e il corpo della richiesta.
+ `responseStream`: fornisce un flusso scrivibile.
+ `context`: fornisce i metodi e le proprietà con informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione.
L'oggetto `responseStream` è un [`writableStream` Node.js](https://nodesource.com/blog/understanding-streams-in-nodejs/). Come con qualsiasi flusso di questo tipo, dovresti usare il metodo `pipeline()`.
**Nota**
L'oggetto globale `awslambda` viene fornito automaticamente dal runtime Node.js di Lambda e non è richiesta alcuna importazione.
**Example gestore abilitato allo streaming delle risposte**
```
import { pipeline } from 'node:stream/promises';
import { Readable } from 'node:stream';
export const echo = awslambda.streamifyResponse(async (event, responseStream, _context) => {
// As an example, convert event to a readable stream.
const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
await pipeline(requestStream, responseStream);
});
```
Sebbene `responseStream` offra il metodo `write()` per scrivere sul flusso, ti consigliamo di utilizzare [https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback](https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback)laddove possibile. L'utilizzo di `pipeline()` garantisce che il flusso scrivibile non venga sopraffatto da un flusso leggibile più veloce.
## Terminazione dello streaming
Assicurati di terminare correttamente il flusso prima che torni al gestore. Il metodo `pipeline()` gestisce questo aspetto automaticamente.
Per altri casi d'uso, chiama il metodo `responseStream.end()` per terminare correttamente un flusso. Questo metodo segnala che nel flusso non devono essere scritti altri dati. Questo metodo non è necessario se si scrive nel flusso con `pipeline()` o `pipe()`.
A partire da Node.js 24, Lambda non attende più che le promesse non risolte vengano completate dopo il ritorno del gestore o il termine del flusso di risposta. Se la tua funzione dipende da operazioni asincrone aggiuntive, come timer o recuperi, dovresti inserirle nel tuo gestore. `await`
**Example Esempio di terminazione di un flusso con pipeline()**
```
import { pipeline } from 'node:stream/promises';
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
await pipeline(requestStream, responseStream);
});
```
**Example Esempio di terminazione di un flusso senza pipeline()**
```
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
responseStream.write("Hello ");
responseStream.write("world ");
responseStream.write("from ");
responseStream.write("Lambda!");
responseStream.end();
});
```
# Richiamo di una funzione abilitata allo streaming di risposte utilizzando la funzione Lambda URLs
**Nota**
La tua funzione Lambda può ora trasmettere in streaming i payload di risposta tramite l'integrazione proxy di [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html).
Puoi richiamare le funzioni abilitate allo streaming delle risposte modificando la modalità di richiamo dell'URL della funzione. La modalità di richiamo determina quale operazione API Lambda utilizza per richiamare la funzione. Le modalità di richiamo disponibili sono:
+ `BUFFERED`: questa è l'opzione predefinita. Lambda richiama la funzione utilizzando l'operazione API `Invoke`. I risultati delle chiamate sono disponibili quando il payload è completo. La dimensione massima del payload è pari a 6 MB.
+ `RESPONSE_STREAM`: consente alla funzione di trasmettere in streaming i risultati del payload non appena diventano disponibili. Lambda richiama la funzione utilizzando l'operazione API `InvokeWithResponseStream`. La dimensione massima del payload di risposta è di 200 MB.
Puoi comunque richiamare la funzione senza lo streaming delle risposte chiamando direttamente l'operazione API `Invoke`. Tuttavia, Lambda trasmette in streaming tutti i payload di risposta per le chiamate che arrivano tramite l'URL della funzione fino a quando non si modifica la modalità di richiamo in `BUFFERED`.
------
#### [ Console ]
**Creazione di un URL della funzione (console)**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli il nome della funzione per la quale desideri impostare la modalità di richiamo.
1. Scegli la scheda **Configurazione**, quindi scegli **URL della funzione**.
1. Scegli **Modifica**, quindi scegli **Impostazioni aggiuntive**.
1. In **Modalità di richiamo**, scegli la modalità di richiamo desiderata.
1. Scegli **Save** (Salva).
------
#### [ AWS CLI ]
**Per impostare la modalità di richiamo di un URL della funzione (AWS CLI)**
```
aws lambda update-function-url-config \
--function-name my-function \
--invoke-mode RESPONSE_STREAM
```
------
#### [ CloudFormation ]
**Per impostare la modalità di richiamo di un URL della funzione (CloudFormation)**
```
MyFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: AWS_IAM
InvokeMode: RESPONSE_STREAM
```
------
Per ulteriori informazioni sulla configurazione della funzione URLs, vedere Funzione [ URLsLambda](urls-configuration.md).
# Tutorial: creazione di una funzione Lambda di streaming delle risposte con un URL della funzione
In questo tutorial viene creata una funzione Lambda definita come archivio file .zip con un endpoint funzione URL che restituisce un flusso di risposte. Per ulteriori informazioni sulla configurazione della funzione URLs, vedere[Funzione URLs](urls-configuration.md).
## Prerequisiti
Questo tutorial presuppone una certa conoscenza delle operazioni di base di Lambda e della console relativa. Se non lo si è già fatto, seguire le istruzioni riportate in [Creare una funzione Lambda con la console](getting-started.md#getting-started-create-function) per creare la prima funzione Lambda.
Per completare i passaggi seguenti, è necessaria la [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). I comandi e l'output previsto sono elencati in blocchi separati:
```
aws --version
```
Verrà visualizzato l'output seguente:
```
aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2
```
Per i comandi lunghi viene utilizzato un carattere di escape (`\`) per dividere un comando su più righe.
In Linux e macOS utilizzare la propria shell e il proprio programma di gestione dei pacchetti preferiti.
**Nota**
Su Windows, alcuni comandi della CLI Bash utilizzati comunemente con Lambda (ad esempio, `zip`) non sono supportati dai terminali integrati del sistema operativo. Per ottenere una versione integrata su Windows di Ubuntu e Bash, [installa il sottosistema Windows per Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10). I comandi della CLI di esempio in questa guida utilizzano la formattazione Linux. Se si utilizza la CLI di Windows, i comandi che includono documenti JSON in linea dovranno essere riformattati.
## Creazione di un ruolo di esecuzione
Creare il [ruolo di esecuzione](lambda-intro-execution-role.md) che offre l'autorizzazione alla funzione Lambda per accedere alle risorse AWS .
**Creazione di un ruolo di esecuzione**
1. Aprire la pagina [Roles (Ruoli)](https://console.aws.amazon.com/iam/home#/roles) della console IAM AWS Identity and Access Management .
1. Scegli **Crea ruolo**.
1. Creare un ruolo con le seguenti proprietà:
+ **Tipo di entità affidabile**: **servizio di AWS **
+ **Caso d'uso**: **Lambda**
+ **Autorizzazioni**: **AWSLambdaBasicExecutionRole**
+ **Nome ruolo** – **response-streaming-role**
La **AWSLambdaBasicExecutionRole**policy dispone delle autorizzazioni necessarie alla funzione per scrivere log su Amazon CloudWatch Logs. Una volta creato il ruolo, prendi nota del relativo nome della risorsa Amazon (ARN). Questo valore servirà nella fase successiva.
## Creazione di una funzione di streaming delle risposte (AWS CLI)
Crea una funzione Lambda di streaming delle risposte con un endpoint URL della funzione utilizzando l' AWS Command Line Interface (AWS CLI).
**Creazione di una funzione in grado di trasmettere le risposte**
1. Copiare il codice di esempio seguente in un file denominato `index.js`. Questa funzione trasmette tre risposte, separate da 1 secondo.
```
exports.handler = awslambda.streamifyResponse(
async (event, responseStream, _context) => {
// Metadata is a JSON serializable JS object. Its shape is not defined here.
const metadata = {
statusCode: 200,
headers: {
"Content-Type": "application/json",
"CustomHeader": "outerspace"
}
};
// Assign to the responseStream parameter to prevent accidental reuse of the non-wrapped stream.
responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
responseStream.write("Streaming with Helper \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 0 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 1 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 2 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.end();
await responseStream.finished();
}
);
```
1. Crea un pacchetto di implementazione.
```
zip function.zip index.js
```
1. Creare una funzione Lambda con il comando `create-function`. Sostituisci il valore di `--role` con l'ARN del ruolo del passaggio precedente. Questo comando imposta il timeout della funzione su 10 secondi, il che consente alla funzione di trasmettere tre risposte.
```
aws lambda create-function \
--function-name my-streaming-function \
--runtime nodejs24.x \
--zip-file fileb://function.zip \
--handler index.handler \
--timeout 10 \
--role arn:aws:iam::123456789012:role/response-streaming-role
```
**Creazione di un URL della funzione**
1. Aggiungi alla tua funzione una politica basata sulle risorse che concede e autorizzazioni. `lambda:InvokeFunctionUrl` `lambda:InvokeFunction` Ogni istruzione deve essere aggiunta in un comando separato. Sostituisci il valore di `--principal` con il tuo Account AWS ID.
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunctionUrl \
--statement-id UrlPolicyInvokeURL \
--principal 123456789012 \
--function-url-auth-type AWS_IAM
```
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunction \
--statement-id UrlPolicyInvokeFunction \
--principal 123456789012
```
1. Crea un endpoint URL per la funzione con il comando `create-function-url-config`.
```
aws lambda create-function-url-config \
--function-name my-streaming-function \
--auth-type AWS_IAM \
--invoke-mode RESPONSE_STREAM
```
**Nota**
Se ricevi un errore in merito`--invoke-mode`, potrebbe essere necessario eseguire l'aggiornamento a una [versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
## Verifica l'endpoint URL della funzione
Testa l'integrazione richiamando la tua funzione. Puoi aprire l'URL della funzione in un browser oppure puoi usare curl.
```
curl --request GET "https://abcdefghijklm7nop7qrs740abcd.lambda-url.us-east-1.on.aws/" --user "AKIAIOSFODNN7EXAMPLE" --aws-sigv4 "aws:amz:us-east-1:lambda" --no-buffer
```
La nostra funzione URL utilizza il tipo di autenticazione `IAM_AUTH`. Ciò implica che devi firmare le richieste sia con la [chiave di accesso AWS che con la chiave segreta](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html). Nel comando precedente, sostituiscilo `AKIAIOSFODNN7EXAMPLE` con l'ID della chiave di AWS accesso. Inserisci la tua chiave AWS segreta quando richiesto. Se non disponi della chiave AWS segreta, puoi invece [utilizzare AWS credenziali temporanee](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html).
Dovresti ottenere una risposta simile a questa:
```
Streaming with Helper
Hello 0
Hello 1
Hello 2
```
## Pulizia delle risorse
Ora è possibile eliminare le risorse create per questo tutorial, a meno che non si voglia conservarle. Eliminando AWS le risorse che non utilizzi più, eviti addebiti inutili a tuo carico. Account AWS
**Come eliminare il ruolo di esecuzione**
1. Aprire la pagina [Ruoli](https://console.aws.amazon.com/iam/home#/roles) della console IAM.
1. Selezionare il ruolo di esecuzione creato.
1. Scegliere **Elimina**.
1. Inserisci il nome del ruolo nel campo di immissione testo e seleziona **Delete** (Elimina).
**Per eliminare la funzione Lambda**
1. Aprire la pagina [Functions (Funzioni)](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Selezionare la funzione creata.
1. Scegliere **Operazioni**, **Elimina**.
1. Digita **confirm** nel campo di immissione testo e scegli **Delete** (Elimina).
# Utilizzo dell'endpoint di metadati Lambda
L'endpoint di metadati Lambda consente alle tue funzioni di scoprire in quale zona di disponibilità (AZ) sono in esecuzione, consentendoti di ottimizzare la latenza indirizzando verso risorse Same-AZ come gli endpoint Amazon ElastiCache e Amazon RDS e di implementare modelli di resilienza compatibili con AZ.
L'endpoint restituisce i metadati in un semplice formato JSON tramite un'API HTTP localhost all'interno dell'ambiente di esecuzione ed è accessibile sia ai runtime che alle estensioni.
**Topics**
+ [
## Nozioni di base
](#metadata-endpoint-getting-started)
+ [
## Comprendere la zona di disponibilità IDs
](#metadata-endpoint-az-ids)
+ [
## Guida di riferimento alle API
](#metadata-endpoint-api-reference)
## Nozioni di base
[Powertools for AWS Lambda](https://docs.aws.amazon.com/powertools/) fornisce un'utilità per accedere all'endpoint dei metadati Lambda in Python, Java e.NET. TypeScript L'utilità memorizza nella cache la risposta dopo la prima chiamata e gestisce automaticamente l'invalidazione della cache. SnapStart
Utilizza l'utilità per i metadati Powertools for AWS Lambda o chiama direttamente l'endpoint dei metadati
------
#### [ Python ]
Installa il pacchetto Powertools:
```
pip install "aws-lambda-powertools"
```
Usa l'utilità per i metadati nel tuo gestore:
**Example Recupero dell'ID AZ con Powertools (Python)**
```
from aws_lambda_powertools.utilities.lambda_metadata import get_lambda_metadata
def handler(event, context):
metadata = get_lambda_metadata()
az_id = metadata.availability_zone_id # e.g., "use1-az1"
return {"az_id": az_id}
```
------
#### [ TypeScript ]
Installa il pacchetto Powertools:
```
npm install @aws-lambda-powertools/commons
```
Usa l'utilità per i metadati nel tuo gestore:
**Example Recupero dell'ID AZ con Powertools () TypeScript**
```
import { getMetadata } from '@aws-lambda-powertools/commons/utils/metadata';
const metadata = await getMetadata();
export const handler = async () => {
const { AvailabilityZoneID: azId } = metadata;
return azId;
};
```
------
#### [ Java ]
Aggiungi la dipendenza Powertools al tuo: `pom.xml`
```
software.amazon.lambda
powertools-lambda-metadata
2.10.0
```
Usa il client di metadati nel tuo gestore:
**Example Recupero dell'ID AZ con Powertools (Java)**
```
import software.amazon.lambda.powertools.metadata.LambdaMetadata;
import software.amazon.lambda.powertools.metadata.LambdaMetadataClient;
public class App implements RequestHandler {
@Override
public String handleRequest(Object input, Context context) {
LambdaMetadata metadata = LambdaMetadataClient.get();
String azId = metadata.getAvailabilityZoneId(); // e.g., "use1-az1"
return "{\"azId\": \"" + azId + "\"}";
}
}
```
------
#### [ .NET ]
Installa il pacchetto Powertools:
```
dotnet add package AWS.Lambda.Powertools.Metadata
```
Usa la classe di metadati nel tuo gestore:
**Example Recupero dell'ID AZ con Powertools (.NET)**
```
using AWS.Lambda.Powertools.Metadata;
public class Function
{
public string Handler(object input, ILambdaContext context)
{
var azId = LambdaMetadata.AvailabilityZoneId;
return $"Running in AZ: {azId}";
}
}
```
------
#### [ All Runtimes ]
Tutti i runtime Lambda supportano l'endpoint dei metadati, inclusi i runtime personalizzati e le immagini dei contenitori. Usa l'esempio seguente per accedere all'API dei metadati direttamente dalla tua funzione utilizzando le variabili di ambiente che Lambda imposta automaticamente nell'ambiente di esecuzione.
**Example Accesso diretto all'endpoint dei metadati**
```
# Variables are automatically set by Lambda
METADATA_ENDPOINT="http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment"
# Make the request
RESPONSE=$(curl -s -H "Authorization: Bearer ${AWS_LAMBDA_METADATA_TOKEN}" "$METADATA_ENDPOINT")
# Parse the AZ ID
AZ_ID=$(echo "$RESPONSE" | jq -r '.AvailabilityZoneID')
echo "Function is running in AZ ID: $AZ_ID"
```
------
## Comprendere la zona di disponibilità IDs
AZ IDs (ad esempio,`use1-az1`) si riferisce sempre alla stessa posizione fisica in tutti gli AWS account, mentre i nomi AZ (ad esempio`us-east-1a`) possono essere mappati a infrastrutture fisiche diverse in ciascun AWS account in determinate regioni. Per ulteriori informazioni, consulta [AZ IDs per la coerenza tra account](https://docs.aws.amazon.com/global-infrastructure/latest/regions/az-ids.html).
**Conversione dell'ID AZ in un nome AZ:**
Per convertire un ID AZ in un nome AZ, utilizza l'API Amazon EC2 [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html). Per utilizzare questa API, aggiungi l'`ec2:DescribeAvailabilityZones`autorizzazione al ruolo di esecuzione della funzione.
## Guida di riferimento alle API
### Variabili di ambiente
Lambda imposta automaticamente le seguenti variabili di ambiente in ogni ambiente di esecuzione:
+ `AWS_LAMBDA_METADATA_API`— L'indirizzo del server di metadati nel formato `{ipv4_address}:{port}` (ad esempio,`169.254.100.1:9001`).
+ `AWS_LAMBDA_METADATA_TOKEN`— Un token di autenticazione unico per l'ambiente di esecuzione corrente. Lambda genera questo token automaticamente al momento dell'inizializzazione. Includilo in tutte le richieste API di metadati.
### Endpoint
`GET http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment`
### Richiesta
**Intestazioni obbligatorie:**
+ `Authorization`— Il valore del token della variabile di `AWS_LAMBDA_METADATA_TOKEN` ambiente con lo schema Bearer:. `Bearer ` Questa autenticazione basata su token fornisce una difesa approfondita contro le vulnerabilità SSRF (Server-Side Request Forgery). Ogni ambiente di esecuzione riceve un token unico generato casualmente al momento dell'inizializzazione.
### Risposta
**Stato:** `200 OK`
**Tipo di contenuto:** `application/json`
**Controllo della cache:** `private, max-age=43200, immutable`
La risposta è immutabile all'interno di un ambiente di esecuzione. I client devono memorizzare nella cache la risposta e rispettare il `Cache-Control` TTL. Per quanto riguarda SnapStart le funzioni, il TTL viene ridotto durante l'inizializzazione in modo che i client aggiornino i metadati dopo il ripristino quando l'ambiente di esecuzione può trovarsi in una AZ diversa. Se si utilizza Powertools, la memorizzazione nella cache e l'invalidazione vengono gestite automaticamente. SnapStart
**Testo:**
```
{
"AvailabilityZoneID": "use1-az1"
}
```
Il `AvailabilityZoneID` campo contiene l'identificatore univoco per la zona di disponibilità in cui è in esecuzione l'ambiente di esecuzione.
**Nota**
Nei futuri aggiornamenti potrebbero essere aggiunti campi aggiuntivi alla risposta. I client devono ignorare i campi sconosciuti e non fallire se vengono visualizzati nuovi campi.
### Risposte agli errori
+ **401 Non autorizzato**: l'`Authorization`intestazione è mancante o contiene un token non valido. Verifica che stai superando il test. `Bearer ${AWS_LAMBDA_METADATA_TOKEN}`
+ **Metodo 405 non consentito**: il metodo di richiesta non `GET` lo è.
+ **500 Errore interno del server: errore** di elaborazione lato server.