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à.
# Compilazione di funzioni Lambda con Python
Puoi eseguire il codice Python in AWS Lambda. Lambda fornisce [Runtime](lambda-runtimes.md) per Python che eseguono il tuo codice per elaborare gli eventi. Il codice viene eseguito in un ambiente che include l'SDK for Python (Boto3), con le credenziali AWS Identity and Access Management di un ruolo (IAM) che gestisci. Per ulteriori informazioni sulle versioni SDK incluse nei runtime Python, consulta [Versioni SDK incluse nel runtime](#python-sdk-included).
Lambda supporta i seguenti runtime di Python.
| Name | Identificatore | Sistema operativo | Data di ritiro | Blocco creazione funzioni | Blocco aggiornamento funzioni |
| --- | --- | --- | --- | --- | --- |
| Python 3.14 | `python3.14` | Amazon Linux 2023 | 30 giugno 2029 | 31 luglio 2029 | 31 agosto 2029 |
| Python 3.13 | `python3.13` | Amazon Linux 2023 | 30 giugno 2029 | 31 luglio 2029 | 31 agosto 2029 |
| Python 3.12 | `python3.12` | Amazon Linux 2023 | 31 ottobre 2028 | 30 novembre 2028 | 10 gennaio 2029 |
| Python 3.11 | `python3.11` | Amazon Linux 2 | 30 giugno 2027 | 31 luglio 2027 | 31 agosto 2027 |
| Python 3.10 | `python3.10` | Amazon Linux 2 | 31 ottobre 2026 | 30 novembre 2026 | 15 gennaio 2027 |
**Per creare una funzione Python**
1. Aprire la [console Lambda](https://console.aws.amazon.com/lambda).
1. Scegli **Crea funzione**.
1. Configura le impostazioni seguenti:
+ **Nome della funzione**: inserisci il nome della funzione.
+ **Runtime**: scegli **Python 3.14**.
1. Scegli **Crea funzione**.
La console crea una funzione Lambda con un singolo file di origine denominato `lambda_function`. È possibile modificare questo file e aggiungere altri file nell'editor di codice predefinito. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione. Quindi, per eseguire il codice, scegli **Crea evento di test** nella sezione **EVENTI DI TEST**.
La funzione Lambda include un gruppo di CloudWatch log Logs. Il runtime della funzione invia i dettagli su ogni chiamata a Logs. CloudWatch Si trasmette qualsiasi [log che la tua funzione emette](python-logging.md) durante la chiamata. Se la funzione restituisce un errore, Lambda formatta l'errore e lo restituisce al chiamante.
**Topics**
+ [Versioni SDK incluse nel runtime](#python-sdk-included)
+ [Funzionalità Python disattivate](#python-disabled-features)
+ [Formato della risposta](#python-response-format)
+ [Chiusura graduale per le estensioni](#python-graceful-shutdown)
+ [Definire l'handler della funzione Lambda in Python](python-handler.md)
+ [Utilizzo di archivi di file .zip per le funzioni Lambda in Python](python-package.md)
+ [Distribuisci funzioni Lambda per Python con immagini di container](python-image.md)
+ [Utilizzo dei livelli per le funzioni Lambda in Python](python-layers.md)
+ [Utilizzo dell'oggetto del contesto Lambda per recuperare le informazioni sulla funzione Python](python-context.md)
+ [Registrare e monitorare le funzioni Lambda con Python](python-logging.md)
+ [Test delle funzioni AWS Lambda in Python](python-testing.md)
+ [Strumentazione del codice Python in AWS Lambda](python-tracing.md)
## Versioni SDK incluse nel runtime
La versione dell' AWS SDK inclusa nel runtime di Python dipende dalla versione di runtime e dalla tua. Regione AWS Per trovare la versione dell'SDK incluso nel runtime che stai utilizzando, crea una funzione Lambda con il codice seguente.
```
import boto3
import botocore
def lambda_handler(event, context):
print(f'boto3 version: {boto3.__version__}')
print(f'botocore version: {botocore.__version__}')
```
## Funzionalità Python disattivate
La tabella seguente elenca le funzionalità di Python che sono disabilitate nei runtime gestiti da Lambda e nelle immagini base dei contenitori per Python. Queste funzionalità devono essere abilitate quando l'eseguibile del runtime Python è compilato e non possono essere abilitate utilizzando un flag in fase di esecuzione. [Per utilizzare queste funzionalità in Lambda, puoi distribuire la tua build di runtime Python con queste funzionalità abilitate, utilizzando un'immagine del [contenitore](python-image.md#python-image-clients) o un runtime personalizzato.](runtimes-custom.md)
| Funzionalità Python | Versioni di Python interessate | Status |
| --- | --- | --- |
| Just-in-Time compilatore (JIT) | Python 3.13 e versioni successive | Il compilatore JIT è sperimentale e non è consigliato per carichi di lavoro di produzione. È quindi disabilitato nei runtime Lambda Python. |
| Threading libero | Python 3.13 e versioni successive | Il threading libero (opzione per disabilitare il blocco globale dell'interprete) è disabilitato nelle build Lambda Python a causa dell'impatto sulle prestazioni sul codice a thread singolo. |
## Formato della risposta
Nei runtime Python 3.12 e successivi, le funzioni restituiscono caratteri Unicode come parte della loro risposta JSON. I runtime Python precedenti restituivano sequenze con escape per i caratteri Unicode nelle risposte. Ad esempio, in Python 3.11, se restituisci una stringa Unicode come "こんにちは", viene eseguito l'escape dei caratteri Unicode e restituito il valore "\$1u3053\$1u3093\$1u306b\$1u3061\$1u306f". Il runtime Python 3.12 restituisce il valore "こんにちは" originale.
L'utilizzo delle risposte Unicode riduce le dimensioni delle risposte Lambda e ciò facilita l'inserimento di risposte più grandi nella dimensione del payload massima di 6 MB per le funzioni sincrone. Nell'esempio precedente, la versione con escape è di 32 byte, rispetto ai 17 della stringa Unicode.
Quando esegui l'aggiornamento a Python 3.12 o a runtime Python successivi, potrebbe essere necessario modificare il codice tenendo conto del nuovo formato di risposta. Se il chiamante prevede un codice Unicode con escape, devi aggiungere manualmente il codice alla funzione restituita per eseguire l'escape dell'Unicode o regolare il chiamante per gestire la restituzione dell'Unicode.
## Chiusura graduale per le estensioni
I runtime Python 3.12 e versioni successive offrono funzionalità di arresto graduale migliorate per funzioni con [estensioni esterne](lambda-extensions.md). Quando chiude un ambiente di esecuzione, Lambda invia un segnale `SIGTERM` al runtime e quindi un evento `SHUTDOWN` a ogni estensione esterna registrata. È possibile catturare il segnale `SIGTERM` nella funzione Lambda e ripulire risorse come le connessioni al database create dalla funzione.
Per ulteriori informazioni sul ciclo di vita dell'ambiente di esecuzione, consulta [Comprendere il ciclo di vita dell’ambiente di esecuzione Lambda](lambda-runtime-environment.md). [Per esempi di come usare Graceful Shutdown con le estensioni, consulta il repository Samples.AWS GitHub ](https://github.com/aws-samples/graceful-shutdown-with-aws-lambda)
# Definire l'handler della funzione Lambda in Python
Il *gestore* di funzioni Lambda è il metodo nel codice della funzione che elabora gli eventi. Quando viene richiamata la funzione, Lambda esegue il metodo del gestore. La funzione viene eseguita fino a quando il gestore non restituisce una risposta, termina o scade.
Questa pagina descrive come lavorare con i gestori di funzioni Lambda in Python, incluse le convenzioni di denominazione, le firme degli handler e le migliori pratiche. Questa pagina include anche un esempio di funzione Go Lambda che raccoglie informazioni su un ordine, produce una ricevuta in un file di testo e inserisce questo file in un bucket Amazon Simple Storage Service (S3).
**Topics**
+ [Esempio di codice della funzione Lambda in Python](#python-handler-example)
+ [Convenzioni di denominazione dei gestori](#python-handler-naming)
+ [L'oggetto evento Lambda:](#python-handler-event)
+ [Accesso e utilizzo dell'oggetto contestuale Lambda](#python-handler-context)
+ [Firme dell'handler valide per gli handler Python](#python-handler-signature)
+ [Restituzione di un valore](#python-handler-return)
+ [Utilizzo della AWS SDK per Python (Boto3) versione v2 nell'handler](#python-handler-sdk)
+ [Accesso alle variabili d'ambiente](#python-handler-env-vars)
+ [Best practice di codice per le funzioni Lambda con Python Lambda](#python-handler-best-practices)
## Esempio di codice della funzione Lambda in Python
Il seguente esempio di codice della funzione Lambda in Python raccoglie le informazioni su un ordine, produce una ricevuta in un file di testo e inserisce questo file in un bucket Amazon S3.
**Example funzione Lambda python**
```
import json
import os
import logging
import boto3
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
# Initialize the logger
logger = logging.getLogger()
logger.setLevel("INFO")
def upload_receipt_to_s3(bucket_name, key, receipt_content):
"""Helper function to upload receipt to S3"""
try:
s3_client.put_object(
Bucket=bucket_name,
Key=key,
Body=receipt_content
)
except Exception as e:
logger.error(f"Failed to upload receipt to S3: {str(e)}")
raise
def lambda_handler(event, context):
"""
Main Lambda handler function
Parameters:
event: Dict containing the Lambda function event data
context: Lambda runtime context
Returns:
Dict containing status message
"""
try:
# Parse the input event
order_id = event['Order_id']
amount = event['Amount']
item = event['Item']
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
if not bucket_name:
raise ValueError("Missing required environment variable RECEIPT_BUCKET")
# Create the receipt content and key destination
receipt_content = (
f"OrderID: {order_id}\n"
f"Amount: ${amount}\n"
f"Item: {item}"
)
key = f"receipts/{order_id}.txt"
# Upload the receipt to S3
upload_receipt_to_s3(bucket_name, key, receipt_content)
logger.info(f"Successfully processed order {order_id} and stored receipt in S3 bucket {bucket_name}")
return {
"statusCode": 200,
"message": "Receipt processed successfully"
}
except Exception as e:
logger.error(f"Error processing order: {str(e)}")
raise
```
Questo file contiene le sezioni seguenti:
+ Blocco `import`: utilizza questo blocco per includere le librerie richieste dalla funzione Lambda.
+ Inizializzazione globale del client e del logger SDK: l'inclusione del codice di inizializzazione all'esterno del gestore sfrutta il riutilizzo dell'[ambiente di esecuzione](lambda-runtime-environment.md) per migliorare le prestazioni della funzione. Per ulteriori informazioni, consulta [Best practice di codice per le funzioni Lambda con Python Lambda](#python-handler-best-practices).
+ `def upload_receipt_to_s3(bucket_name, key, receipt_content):`Questa è una funzione di supporto chiamata dalla funzione principale. `lambda_handler`
+ `def lambda_handler(event, context):`: questo è il **metodo dell'handler principale**, che contiene la logica principale dell'applicazione. Quando Lambda richiama il gestore di funzioni, il runtime [Lambda](concepts-basics.md#gettingstarted-concepts-runtime) passa due argomenti alla funzione, l'oggetto [evento che contiene i dati che la](#python-handler-event) funzione deve elaborare e [l'oggetto context che contiene informazioni sulla chiamata della](#python-handler-context) funzione.
## Convenzioni di denominazione dei gestori
Il nome del gestore di funzioni Lambda specificato al momento della creazione di una funzione Lambda deriva da quanto segue:
+ il nome del file in cui si trova la funzione del gestore Lambda.
+ il nome della funzione del gestore Python.
Nell'esempio precedente, se il file è denominato`lambda_function.py`, il gestore viene specificato come. `lambda_function.lambda_handler` Questo è il nome del gestore predefinito assegnato alle funzioni create utilizzando la console Lambda.
Se si crea una funzione nella console utilizzando un nome di file o un nome del gestore di funzione diverso, è necessario modificare il nome del gestore predefinito.
**Modifica del nome del gestore funzioni (console)**
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 **Codice**.
1. Scorri verso il basso fino al riquadro **Impostazioni di runtime** e scegli **Modifica**.
1. In **Gestore**, inserisci il nuovo nome per il tuo gestore di funzioni.
1. Selezionare **Salva**.
## L'oggetto evento Lambda:
Quando la funzione viene richiamata da Lambda, passa un argomento [dell'oggetto evento](concepts-basics.md#gettingstarted-concepts-event) al gestore di funzioni. Gli oggetti JSON sono il formato di eventi più comune per le funzioni Lambda. Nell'esempio di codice riportato nella sezione precedente, la funzione prevede un input nel seguente formato:
```
{
"Order_id": "12345",
"Amount": 199.99,
"Item": "Wireless Headphones"
}
```
Se la funzione è richiamata da un altroServizio AWS, l'evento di input è anche un oggetto JSON. Il formato esatto dell'oggetto evento dipende dal servizio che richiama la funzione. Per vedere il formato dell'evento per un particolare servizio, consultate la pagina appropriata nel [Richiamare Lambda con eventi di altri servizi AWS](lambda-services.md) capitolo.
Se l'evento di input ha la forma di un oggetto JSON, il runtime Lambda converte l'oggetto in un dizionario Python. Per assegnare valori nell'input JSON alle variabili del codice, usa i metodi del dizionario Python standard come illustrato nel codice di esempio.
Puoi anche passare dati alla tua funzione come array JSON o come qualsiasi altro tipo di dati JSON validi. La tabella seguente definisce come il runtime Python converte questi tipi JSON.
| Tipo di dati JSON | Tipo di dati Python |
| --- | --- |
| oggetto | Dizionariodict |
| array | elencolist |
| number | numero intero (int) o numero in virgola mobile () float |
| string | Stringa (str) |
| Booleano | booleano (bool) |
| null | noeType () NoneType |
## Accesso e utilizzo dell'oggetto contestuale Lambda
L'oggetto contesto: contiene informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione. Lambda passa l'oggetto contestuale alla tua funzione automaticamente. Puoi utilizzare l'oggetto contestuale per generare informazioni sull'invocazione della funzione a scopo di monitoraggio.
L'oggetto context è una classe Python definita nel client dell'interfaccia runtime [Lambda](https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/main/awslambdaric/lambda_context.py). Per restituire il valore di una qualsiasi delle proprietà dell'oggetto contestuale, utilizzate il metodo corrispondente sull'oggetto context. Ad esempio, il frammento di codice seguente assegna il valore della `aws_request_id` proprietà (l'identificatore per la richiesta di chiamata) a una variabile denominata. `request`
```
request = context.aws_request_id
```
Per ulteriori informazioni sull'utilizzo dell'oggetto contestuale Lambda e per visualizzare un elenco completo dei metodi e delle proprietà disponibili, vedere. [Utilizzo dell'oggetto del contesto Lambda per recuperare le informazioni sulla funzione Python](python-context.md)
## Firme dell'handler valide per gli handler Python
Quando si definisce la funzione di gestione in Python, la funzione deve accettare due argomenti. [Il primo di questi argomenti è l'[oggetto evento Lambda e il secondo è l'oggetto](#python-handler-event) contesto Lambda.](#python-handler-context) Per convenzione, questi argomenti di input sono generalmente denominati `event` e`context`, ma puoi assegnare loro tutti i nomi che desideri. Se dichiari la tua funzione di gestione con un solo argomento di input, Lambda genererà un errore quando tenta di eseguire la funzione. Il modo più comune per dichiarare una funzione di gestione in Python è il seguente:
```
def lambda_handler(event, context):
```
È inoltre possibile utilizzare i suggerimenti di tipo Python nella dichiarazione di funzioni, come illustrato nell'esempio seguente:
```
from typing import Dict, Any
def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
```
Per utilizzare una AWS digitazione specifica per eventi generati da altri oggetti Servizi AWS e per l'oggetto di contesto, aggiungi il `aws-lambda-typing` pacchetto al pacchetto di distribuzione della funzione. Puoi installare questa libreria nel tuo ambiente di sviluppo `pip install aws-lambda-typing` eseguendo. Il seguente frammento di codice mostra come utilizzare suggerimenti di tipo AWS specifici. In questo esempio, l'evento previsto è un evento Amazon S3.
```
from aws_lambda_typing.events import S3Event
from aws_lambda_typing.context import Context
from typing import Dict, Any
def lambda_handler(event: S3Event, context: Context) -> Dict[str, Any]:
```
Non puoi usare il tipo di funzione Python per la tua `async` funzione di gestione.
## Restituzione di un valore
È inoltre possibile che il gestore restituisca un valore, che deve essere serializzabile in formato JSON. I tipi di restituzione più comuni includono`dict`,,`list`, e`str`. `int` `float` `bool`
Ciò che accade al valore restituito dipende dal [tipo di chiamata](lambda-invocation.md) e dal [servizio](lambda-services.md) che ha invocato la funzione. Ad esempio:
+ Se si utilizza il tipo di invocazione `RequestResponse`, come [, ](invocation-sync.md) restituisce il risultato della chiamata della funzione Python al client che invoca la funzione Lambda (nella risposta HTTP alla richiesta di invocazione, serializzata in JSON). Ad esempio, la console AWS Lambda utilizza il tipo di invocazione `RequestResponse`; quindi, quando si invoca la funzione mediante la console, in quest'ultima verrà visualizzato il valore restituito.
+ Se il gestore restituisce degli oggetti che non possono essere serializzati da `json.dumps`, il runtime restituisce un errore.
+ Se il gestore restituisce `None`, come fanno implicitamente le funzioni Python senza un'istruzione `return`, il runtime restituisce `null`.
+ Se utilizzi il tipo di invocazione `Event`, ovvero una [invocazione asincrona](invocation-async.md), il valore viene ignorato.
Nel codice di esempio, il gestore restituisce il seguente dizionario Python:
```
{
"statusCode": 200,
"message": "Receipt processed successfully"
}
```
Il runtime Lambda serializza questo dizionario e lo restituisce al client che ha richiamato la funzione come stringa JSON.
**Nota**
In Python 3.9 e nelle versioni successive, Lambda include il requestId dell'invocazione nella risposta di errore.
## Utilizzo della AWS SDK per Python (Boto3) versione v2 nell'handler
Spesso, utilizzerai le funzioni Lambda per interagire o aggiornare altre Servizi AWS risorse. Il modo più semplice per interfacciarsi con queste risorse è usare la AWS SDK per Python (Boto3) v2. Tutti i [runtime Lambda Python supportati](lambda-runtimes.md#runtimes-supported) includono una versione dell'SDK per Python. Tuttavia, consigliamo vivamente di includere l'SDK nel pacchetto di distribuzione della funzione se il codice deve utilizzarlo. L'inclusione dell'SDK nel pacchetto di distribuzione offre il pieno controllo sulle dipendenze e riduce il rischio di problemi di disallineamento delle versioni con altre librerie. Per ulteriori informazioni, consulta le pagine [Dipendenze di runtime in Python](python-package.md#python-package-dependencies) e [Compatibilità con le versioni precedenti](runtimes-update.md#runtime-update-compatibility).
Per usare l'SDK per Python nella tua funzione Lambda, aggiungi la seguente istruzione al blocco di importazione all'inizio del codice della funzione:
```
import boto3
```
Usa il `pip install` comando per aggiungere la `boto3` libreria al pacchetto di distribuzione della funzione. Per istruzioni dettagliate su come aggiungere dipendenze a un pacchetto di implementazione .zip, vedere. [Creazione di un pacchetto di implementazione .zip con dipendenze](python-package.md#python-package-create-dependencies) Per ulteriori informazioni sull'aggiunta di dipendenze alle funzioni Lambda distribuite come immagini di container, consulta o. [Creazione di un'immagine da un'immagine di base](python-image.md#python-image-create) [Creazione di un'immagine da un'immagine di base alternativa](python-image.md#python-alt-create)
Quando `boto3` si utilizza il codice, non è necessario fornire alcuna credenziale per inizializzare un client. Ad esempio, nel codice di esempio, utilizziamo la seguente riga di codice per inizializzare un client Amazon S3:
```
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
```
Con Python, Lambda crea automaticamente variabili di ambiente con credenziali. L'`boto3`SDK controlla le variabili di ambiente della funzione per verificare la presenza di queste credenziali durante l'inizializzazione.
## Accesso alle variabili d'ambiente
Nel codice dell'handler, puoi fare riferimento a qualsiasi [variabile di ambiente](configuration-envvars.md) utilizzando il metodo `os.environ.get`. In questo esempio, facciamo riferimento alla variabile di `RECEIPT_BUCKET` ambiente definita utilizzando la seguente riga di codice:
```
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
```
Non dimenticate di includere un'`import os`istruzione nel blocco di importazione all'inizio del codice.
## Best practice di codice per le funzioni Lambda con Python Lambda
Segui le linee guida riportate nell'elenco seguente per utilizzare le best practice di codifica durante la creazione delle funzioni Lambda:
+ **Separare il gestore Lambda dalla logica principale.** In questo modo è possibile creare una funzione di cui è più semplice eseguire l'unit test. Ad esempio, in Python, l'aspetto è analogo al seguente:
```
def lambda_handler(event, context):
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo, bar)
def my_lambda_function(foo, bar):
// MyLambdaFunction logic here
```
+ **Controllare le dipendenze nel pacchetto di distribuzione della funzione.** L'ambiente di esecuzione AWS Lambda contiene diverse librerie. Per i runtime Node.js e Python, questi includono gli SDK AWS. Per abilitare il set di caratteristiche e aggiornamenti della sicurezza più recenti, Lambda aggiorna periodicamente tali librerie. Tali aggiornamenti possono introdurre lievi modifiche al comportamento della funzione Lambda. Per mantenere il controllo completo delle dipendenze utilizzate dalla funzione, inserire tutte le dipendenze nel pacchetto di implementazione.
+ **Ridurre la complessità delle dipendenze.** Preferire framework più semplici che si caricano velocemente all'avvio del [contesto di esecuzione](lambda-runtime-environment.md).
+ **Ridurre al minimo le dimensioni del pacchetto di implementazione al fine di soddisfare le esigenze di runtime. ** In questo modo viene ridotta la quantità di tempo necessaria per il download del pacchetto e per la relativa decompressione prima dell'invocazione.
**Sfruttare il riutilizzo del contesto di esecuzione per migliorare le prestazioni della funzione.** Inizializzare i client SDK e le connessioni al database all'esterno del gestore di funzioni e memorizzare localmente nella cache gli asset statici nella directory `/tmp`. Le chiamate successive elaborate dalla stessa istanza della funzione possono riutilizzare queste risorse. Ciò consente di risparmiare sui costi riducendo i tempi di esecuzione delle funzioni.
Per evitare potenziali perdite di dati tra le chiamate, non utilizzare il contesto di esecuzione per archiviare dati utente, eventi o altre informazioni con implicazioni di sicurezza. Se la funzione si basa su uno stato mutabile che non può essere archiviato in memoria all'interno del gestore, considerare la possibilità di creare una funzione separata o versioni separate di una funzione per ogni utente.
**Utilizzare una direttiva keep-alive per mantenere le connessioni persistenti.** Lambda elimina le connessioni inattive nel tempo. 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).
**Utilizzare [le variabili di ambiente](configuration-envvars.md) per passare i parametri operativi alla funzione.** Se ad esempio si scrive in un bucket Amazon S3 anziché impostare come hard-coded il nome del bucket in cui si esegue la scrittura, configurare tale nome come una variabile di ambiente.
**Evita di usare invocazioni ricorsive** nella tua funzione Lambda, in cui la funzione si richiama da sola o avvia un processo che potrebbe richiamare nuovamente la funzione. Ciò potrebbe provocare un volume non desiderato di invocazioni della funzione e un aumento dei costi. Se noti un volume indesiderato di invocazioni, imposta immediatamente la simultaneità riservata della funzione su `0` per interrompere tutte le invocazioni della funzione mentre si aggiorna il codice.
**Non utilizzare API non documentate e non pubbliche** nel codice della funzione Lambda. Per i tempi di esecuzione gestiti AWS Lambda, Lambda applica periodicamente aggiornamenti di sicurezza e funzionalità alle API interne di Lambda. Questi aggiornamenti API interni potrebbero essere incompatibili con le versioni precedenti, causando conseguenze indesiderate come errori di chiamata se la funzione ha una dipendenza su queste API non pubbliche. Consulta il [riferimento all'API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) per un elenco di API disponibili pubblicamente.
**Scrivi un codice idempotente.** La scrittura di un codice idempotente per le tue funzioni garantisce che gli eventi duplicati vengano gestiti allo stesso modo. Il tuo codice dovrebbe convalidare correttamente gli eventi e gestire con garbo gli eventi duplicati. Per ulteriori informazioni, consulta [Come posso rendere idempotente la mia funzione Lambda?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Utilizzo di archivi di file .zip per le funzioni Lambda in Python
Il codice della AWS Lambda funzione comprende un file.py contenente il codice del gestore della funzione, insieme a tutti i pacchetti e i moduli aggiuntivi da cui dipende il codice. Per implementare questo codice della funzione in Lambda, utilizza un *pacchetto di implementazione*. Questo pacchetto può essere un archivio di file .zip o un'immagine di container. Per ulteriori informazioni sull'uso delle immagini di container con Python, consulta la sezione [Implementazione di funzioni Lambda in Python con immagini di container](https://docs.aws.amazon.com/lambda/latest/dg/python-image.html).
Per creare un pacchetto di implementazione come archivio di file .zip, puoi utilizzare l'utilità di archiviazione di file .zip incorporata del tuo strumento della linea di comando o qualsiasi altra utilità file .zip, come ad esempio [7zip](https://www.7-zip.org/download.html). Gli esempi mostrati nelle sezioni seguenti presuppongono che tu stia utilizzando uno strumento della linea di comando `zip` in un ambiente Linux o MacOS. Per utilizzare gli stessi comandi in Windows, puoi [installare il sottosistema Windows per Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) per ottenere una versione di Ubuntu e Bash integrata con Windows.
Nota che Lambda utilizza le autorizzazioni dei file POSIX, quindi potresti aver bisogno di [impostare le autorizzazioni per la cartella del pacchetto di implementazione](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) prima di creare l'archivio di file .zip.
**Topics**
+ [Dipendenze di runtime in Python](#python-package-dependencies)
+ [Creazione di un pacchetto di implementazione .zip senza dipendenze](#python-package-create-no-dependencies)
+ [Creazione di un pacchetto di implementazione .zip con dipendenze](#python-package-create-dependencies)
+ [Percorso di ricerca delle dipendenze e librerie incluse nel runtime](#python-package-searchpath)
+ [Utilizzo delle cartelle \$1\$1pycache\$1\$1](#python-package-pycache)
+ [Creazione di un pacchetto di implementazione .zip con librerie native](#python-package-native-libraries)
+ [Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip](#python-package-create-update)
## Dipendenze di runtime in Python
Per le funzioni Lambda che utilizzano il runtime Python, una dipendenza può essere qualsiasi pacchetto o modulo Python. Se implementi la funzione utilizzando un archivio .zip, puoi aggiungere queste dipendenze al file .zip con il tuo codice della funzione o utilizzare un [livello Lambda](chapter-layers.md). Un livello è un file .zip separato che può contenere codice aggiuntivo o altri contenuti. Per ulteriori informazioni sull'uso dei livelli Lambda in Python, consulta [Utilizzo dei livelli per le funzioni Lambda in Python](python-layers.md).
I runtime Lambda Python includono e le relative dipendenze. AWS SDK per Python (Boto3) Lambda fornisce l'SDK nel runtime per scenari di implementazione in cui non è possibile aggiungere le proprie dipendenze. Questi scenari includono la creazione di funzioni nella console utilizzando l'editor di codice integrato o l'utilizzo di funzioni inline in AWS Serverless Application Model () o modelli.AWS SAM CloudFormation
Lambda aggiorna periodicamente le librerie nel runtime Python per includere gli aggiornamenti e le patch di sicurezza più recenti. Se la funzione utilizza la versione dell'SDK Boto3 inclusa nel runtime ma il pacchetto di implementazione include dipendenze SDK, ciò può causare problemi di disallineamento delle versioni. Ad esempio, il pacchetto di implementazione potrebbe includere la dipendenza SDK urllib3. Quando Lambda aggiorna l'SDK nel runtime, i problemi di compatibilità tra la nuova versione del runtime e la versione di urllib3 nel pacchetto di implementazione possono causare il fallimento della funzione.
**Importante**
Per mantenere il pieno controllo sulle dipendenze ed evitare possibili problemi di disallineamento delle versioni, si consiglia di aggiungere tutte le dipendenze della funzione al pacchetto di implementazione, anche se le relative versioni sono incluse nel runtime Lambda. Ciò include l'SDK Boto3.
Per scoprire quale versione dell'SDK per Python (Boto3) è inclusa nel runtime che stai utilizzando, consulta [Versioni SDK incluse nel runtime](lambda-python.md#python-sdk-included).
In base al [modello di responsabilità condivisa di AWS](https://docs.aws.amazon.com/whitepapers/latest/aws-risk-and-compliance/shared-responsibility-model.html), è tua responsabilità gestire eventuali dipendenze nei pacchetti di implementazione delle tue funzioni. Ciò include l'applicazione di aggiornamenti e patch di sicurezza. Per aggiornare le dipendenze nel pacchetto di implementazione della funzione, crea prima un nuovo file .zip e poi caricalo su Lambda. Per ulteriori informazioni, consulta [Creazione di un pacchetto di implementazione .zip con dipendenze](#python-package-create-dependencies) e [Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip](#python-package-create-update).
## Creazione di un pacchetto di implementazione .zip senza dipendenze
Se il codice della funzione non ha dipendenze, il file .zip contiene solo il file .py con il codice del gestore della funzione. Usa la tua utilità zip preferita per creare un file .zip con il file .py nella directory principale. Se il file .py non si trova nella directory principale del file .zip, Lambda non sarà in grado di eseguire il codice.
Per informazioni su come implementare il file .zip per creare una nuova funzione Lambda o aggiornarne una esistente, consulta la sezione [Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip](#python-package-create-update).
## Creazione di un pacchetto di implementazione .zip con dipendenze
Se il tuo codice della funzione dipende da pacchetti o moduli aggiuntivi, puoi aggiungere queste dipendenze al file .zip con il codice della funzione oppure [utilizzare un livello Lambda](python-layers.md). Le istruzioni in questa sezione mostrano come includere le dipendenze nel pacchetto di implementazione .zip. Affinché Lambda esegua il codice, il file .py contenente il codice del gestore e tutte le dipendenze della funzione deve essere installato nella radice del file .zip.
Supponiamo che il codice della funzione sia salvato in un file denominato `lambda_function.py`. I seguenti comandi della CLI di esempio creano un file .zip denominato `my_deployment_package.zip` contenente il codice della funzione e le relative dipendenze. Puoi installare le tue dipendenze direttamente in una cartella nella directory del tuo progetto o utilizzare un ambiente virtuale Python.
**Creazione del pacchetto di implementazione (directory del progetto)**
1. Passa alla directory del progetto contenente il file del codice sorgente `lambda_function.py`. In questo esempio, la directory è denominata `my_function`.
```
cd my_function
```
1. Crea una nuova directory denominata "pacchetto" in cui installare le tue dipendenze.
```
mkdir package
```
Tieni presente che per un pacchetto di implementazione .zip, Lambda prevede che il codice sorgente e le relative dipendenze siano tutti nella directory principale del file .zip. Tuttavia, l'installazione delle dipendenze direttamente nella directory del progetto può introdurre un gran numero di nuovi file e cartelle e rendere difficile la navigazione nell'IDE. Qui crei una directory `package` separata per mantenere le dipendenze separate dal codice sorgente.
1. Installa le dipendenze nella directory `package`. L'esempio seguente installa l'SDK Boto3 da Python Package Index utilizzando pip. Se il codice della funzione utilizza pacchetti Python creati da te, salvali nella directory `package`.
```
pip install --target ./package boto3
```
1. Crea un file .zip con le librerie installate nella directory principale.
```
cd package
zip -r ../my_deployment_package.zip .
```
Verrà generato un file `my_deployment_package.zip` nella directory del progetto.
1. Aggiunta del file lambda\$1function.py alla directory principale del file .zip
```
cd ..
zip my_deployment_package.zip lambda_function.py
```
Il tuo file .zip dovrebbe avere una struttura di directory semplice, con il codice del gestore della funzione e tutte le cartelle delle dipendenze installate nella directory principale come segue.
```
my_deployment_package.zip
|- bin
| |-jp.py
|- boto3
| |-compat.py
| |-data
| |-docs
...
|- lambda_function.py
```
Se il file .py contenente il codice del gestore della funzione non si trova nella directory principale del file .zip, Lambda non sarà in grado di eseguire il codice.
**Creazione del pacchetto di implementazione (ambiente virtuale)**
1. Crea e attiva un ambiente virtuale nella directory del progetto. In questo esempio, la directory del progetto è denominata `my_function`.
```
~$ cd my_function
~/my_function$ python3.14 -m venv my_virtual_env
~/my_function$ source ./my_virtual_env/bin/activate
```
1. Installa le librerie richieste utilizzando pip. Nell'esempio seguente viene installato l'SDK Boto3
```
(my_virtual_env) ~/my_function$ pip install boto3
```
1. Utilizza `pip show` per trovare la posizione, all'interno del tuo ambiente virtuale, in cui pip ha installato le tue dipendenze.
```
(my_virtual_env) ~/my_function$ pip show
```
La cartella in cui pip installa le tue librerie può essere denominata `site-packages` oppure `dist-packages`. Questa cartella può trovarsi nella directory `lib/python3.x` oppure `lib64/python3.x` (dove python3.x rappresenta la versione di Python che stai utilizzando).
1. Disattivazione dell'ambiente virtuale
```
(my_virtual_env) ~/my_function$ deactivate
```
1. Accedi alla directory contenente le dipendenze che hai installato con pip e crea un file .zip nella directory principale del tuo progetto, nella quale sono installate le dipendenze. In questo esempio, pip ha installato le tue dipendenze nella directory `my_virtual_env/lib/python3.14/site-packages`.
```
~/my_function$ cd my_virtual_env/lib/python3.14/site-packages
~/my_function/my_virtual_env/lib/python3.14/site-packages$ zip -r ../../../../my_deployment_package.zip .
```
1. Vai alla directory principale del tuo progetto, in cui si trova il file .py contenente il codice del gestore, e aggiungi quel file alla directory principale del tuo pacchetto .zip. In questo esempio, il file di codice della funzione è denominato `lambda_function.py`.
```
~/my_function/my_virtual_env/lib/python3.14/site-packages$ cd ../../../../
~/my_function$ zip my_deployment_package.zip lambda_function.py
```
## Percorso di ricerca delle dipendenze e librerie incluse nel runtime
Quando utilizzi un'istruzione `import` nel codice, il runtime Python cerca nelle directory del suo percorso di ricerca finché non trova il modulo o il pacchetto. Per impostazione predefinita, la prima posizione cercata dal runtime è la directory in cui il pacchetto di implementazione .zip viene decompresso e montato (`/var/task`). Se includi una versione di una libreria inclusa nel runtime nel tuo pacchetto di implementazione, questa versione avrà la precedenza sulla versione inclusa nel runtime. Le dipendenze nel pacchetto di implementazione hanno la precedenza anche sulle dipendenze nei livelli.
Quando aggiungi una dipendenza a un livello, Lambda la estrae in `/opt/python/lib/python3.x/site-packages`, dove `python3.x` rappresenta la versione del runtime che stai utilizzando, o `/opt/python`. Nel percorso di ricerca, queste directory hanno la precedenza sulle directory contenenti le librerie incluse nel runtime e le librerie installate con pip (`/var/runtime` e `/var/lang/lib/python3.x/site-packages`). Le librerie nei livelli di funzione hanno quindi la precedenza sulle versioni incluse nel runtime.
**Nota**
Nel runtime gestito e nell'immagine di base di Python 3.11, l' AWS SDK e le sue dipendenze sono installati nella directory. `/var/lang/lib/python3.11/site-packages`
Puoi visualizzare il percorso di ricerca completo per la tua funzione Lambda aggiungendo il seguente frammento di codice.
```
import sys
search_path = sys.path
print(search_path)
```
**Nota**
Poiché le dipendenze nei livelli o nel pacchetto di implementazione hanno la precedenza sulle librerie incluse nel runtime, ciò può causare problemi di disallineamento delle versioni se si include una dipendenza SDK come urllib3 nel pacchetto senza includere anche l'SDK. Se implementi la tua versione di una dipendenza Boto3, devi anche implementare Boto3 come dipendenza nel tuo pacchetto di implementazione. Ti consigliamo di impacchettare tutte le dipendenze della tua funzione, anche se le rispettive versioni sono già incluse nel runtime.
Puoi anche aggiungere dipendenze in una cartella separata all'interno del tuo pacchetto .zip. Ad esempio, potresti aggiungere una versione dell'SDK Boto3 a una cartella del tuo pacchetto .zip chiamata `common`. Quando il pacchetto .zip viene decompresso e montato, questa cartella viene inserita nella directory `/var/task`. Per utilizzare nel codice una dipendenza da una cartella del pacchetto di implementazione .zip, utilizza un'istruzione `import from`. Ad esempio, per utilizzare una versione di Boto3 da una cartella denominata `common` nel tuo pacchetto .zip, usa la seguente istruzione.
```
from common import boto3
```
## Utilizzo delle cartelle \$1\$1pycache\$1\$1
È consigliabile non includere cartelle `__pycache__` nel pacchetto di implementazione della funzione. Il bytecode Python compilato su un computer di compilazione con un'architettura o un sistema operativo diverso potrebbe non essere compatibile con l'ambiente di esecuzione Lambda.
## Creazione di un pacchetto di implementazione .zip con librerie native
Se la tua funzione utilizza solo pacchetti e moduli Python puri, puoi usare il comando `pip install` per installare le tue dipendenze su qualsiasi computer di compilazione locale e creare il file .zip. Molte librerie Python popolari, tra cui NumPy e Pandas, non sono Python puro e contengono codice scritto in C o C\$1\$1. Quando aggiungi librerie contenenti codice C/C\$1\$1 al pacchetto di implementazione, devi creare il pacchetto correttamente per assicurarti che sia compatibile con l'ambiente di esecuzione Lambda.
La maggior parte dei pacchetti disponibili nel Python Package Index ([PyPI](https://pypi.org/)) sono disponibili come "wheel" (file .whl). Un file .whl è un tipo di file ZIP che contiene una distribuzione compilata con file binari precompilati per un particolare sistema operativo e un'architettura di set di istruzioni. Per rendere il pacchetto di implementazione compatibile con Lambda, è necessario installare il wheel per i sistemi operativi Linux e l'architettura del set di istruzioni della funzione.
Alcuni pacchetti possono essere disponibili solo come distribuzioni di origine. Per questi pacchetti, è necessario compilare e creare personalmente i componenti C/C\$1\$1.
Per vedere quali distribuzioni sono disponibili per il pacchetto richiesto, procedi come segue:
1. Cerca il nome del pacchetto nella [pagina principale di Python Package Index](https://pypi.org/).
1. Seleziona la versione del pacchetto da utilizzare.
1. Scegli **Scarica file**.
### Utilizzo di distribuzioni integrate (wheel)
Per scaricare un wheel compatibile con Lambda, utilizza l'opzione `--platform` in pip.
Se la tua funzione Lambda utilizza l'architettura del set di istruzioni **x86\$164**, esegui il comando `pip install` seguente per installare un wheel compatibile nella tua directory `package`. Sostituisci `--python 3.x` con la versione del runtime Python che stai utilizzando.
```
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
Se la funzione utilizza l'architettura del set di istruzioni **arm64**, esegui il seguente comando. Sostituisci `--python 3.x` con la versione del runtime Python che stai utilizzando.
```
pip install \
--platform manylinux2014_aarch64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
### Utilizzo delle distribuzioni di origine
Se il tuo pacchetto è disponibile solo come distribuzione di origine, la creazione delle librerie C/C\$1\$1 spetta a te. Per rendere il pacchetto compatibile con l'ambiente di esecuzione Lambda, è necessario crearlo in un ambiente che utilizzi lo stesso sistema operativo Amazon Linux. Puoi farlo creando il tuo pacchetto in un'istanza Amazon Elastic Compute Cloud (Amazon EC2) Linux.
Per informazioni su come avviare e connettersi a un'istanza Amazon EC2 Linux, consulta la Guida [introduttiva ad Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) nella *Amazon EC2 User Guide*.
## Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip
Dopo aver creato il pacchetto di implementazione .zip, puoi utilizzarlo per creare una nuova funzione Lambda o aggiornarne una esistente. Puoi distribuire il tuo pacchetto.zip utilizzando la console Lambda, l'API Lambda AWS Command Line Interface e l'API Lambda. Puoi anche creare e aggiornare le funzioni Lambda usando AWS Serverless Application Model (AWS SAM) e CloudFormation.
La dimensione massima per un pacchetto di implementazione .zip per Lambda è di 250 MB (dopo l'estrazione). Nota che questo limite si applica alla dimensione combinata di tutti i file caricati, inclusi eventuali livelli Lambda.
Il runtime Lambda necessita dell'autorizzazione per leggere i file nel pacchetto di distribuzione. Nella notazione ottale delle autorizzazioni Linux, Lambda richiede 644 permessi per i file non eseguibili (rw-r--r--) e 755 permessi () per le directory e i file eseguibili. rwxr-xr-x
In Linux e macOS, utilizza il comando `chmod` per modificare le autorizzazioni file su file e directory nel pacchetto di implementazione. Ad esempio, per assegnare a un file non eseguibile le autorizzazioni corrette, utilizza il comando seguente.
```
chmod 644
```
Per modificare le autorizzazioni file in Windows, consulta [Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) nella documentazione di Microsoft Windows.
**Nota**
Se non concedi a Lambda le autorizzazioni necessarie per accedere alle directory nel pacchetto di distribuzione, Lambda imposta le autorizzazioni per tali directory su 755 (). rwxr-xr-x
### Creazione e aggiornamento delle funzioni con file .zip utilizzando la console
Per creare una nuova funzione, devi prima creare la funzione nella console, quindi devi caricare il tuo archivio .zip. Per aggiornare una funzione esistente, apri la pagina relativa alla funzione, quindi segui la stessa procedura per aggiungere il file .zip aggiornato.
Se il file .zip ha dimensioni inferiori a 50 MB, è possibile creare o aggiornare una funzione caricando il file direttamente dal computer locale. Per i file .zip di dimensioni superiori a 50 MB, prima è necessario caricare il pacchetto in un bucket Amazon S3. Per istruzioni su come caricare un file in un bucket Amazon S3 utilizzando il Console di gestione AWS, consulta la [Guida introduttiva ad Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). *Per caricare file utilizzando la AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella Guida per l'AWS CLI utente.*
**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.
**Creazione di una nuova funzione (console)**
1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli **Crea funzione**.
1. Scegli **Author from scratch** (Crea da zero).
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. In **Nome funzione**, inserisci il nome della funzione.
1. Per **Runtime**, seleziona il runtime che desideri utilizzare.
1. (Facoltativo) Per **Architettura**, scegli l'architettura del set di istruzioni per la funzione. L'architettura predefinita è x86\$164. Assicurati che il pacchetto di implementazione per la tua funzione sia compatibile con l'architettura del set di istruzioni scelta.
1. (Opzionale) In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**. Puoi creare un nuovo **ruolo di esecuzione** o utilizzare un ruolo esistente.
1. Scegli **Crea funzione**. Lambda crea una funzione di base "Hello world" utilizzando il runtime scelto.
**Caricamento di un archivio .zip dal computer locale (console)**
1. Nella [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda, scegli la funzione per cui vuoi caricare il file .zip.
1. Scegli la scheda **Codice**.
1. Nel riquadro **Origine del codice**, scegli **Carica da**.
1. Scegli **File .zip**.
1. Per caricare il file .zip, procedi come segue:
1. Seleziona **Carica**, quindi seleziona il tuo file .zip nel selettore di file.
1. Seleziona **Apri**.
1. Scegli **Save** (Salva).
**Caricamento di un archivio .zip da un bucket Amazon S3 (console)**
1. Nella [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda, scegli la funzione per cui vuoi caricare un nuovo file .zip.
1. Scegli la scheda **Codice**.
1. Nel riquadro **Origine del codice**, scegli **Carica da**.
1. Scegli **Posizione Amazon S3**.
1. Incolla l'URL del link Amazon S3 del tuo file .zip e scegli **Salva**.
### Aggiornamento delle funzioni dei file .zip tramite l'editor di codice della console
Per alcune funzioni con pacchetti di implementazione .zip, puoi utilizzare l'editor di codice integrato nella console Lambda per aggiornare direttamente il codice della funzione. Per utilizzare questa funzione, la funzione deve soddisfare i seguenti criteri:
+ La funzione deve utilizzare uno dei runtime del linguaggio interpretato (Python, Node.js o Ruby)
+ Il pacchetto di implementazione della funzione deve avere dimensioni inferiori a 50 MB (non compresso).
Il codice della funzione per le funzioni con pacchetti di implementazione di immagini di container non può essere modificato direttamente nella console.
**Aggiornamento del codice della funzione utilizzando l'editor di codice della console**
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 **Codice**.
1. Nel riquadro **Origine del codice**, seleziona il tuo file di codice sorgente e modificalo nell'editor di codice integrato.
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)
### Creazione e aggiornamento di funzioni con file.zip utilizzando AWS CLI
È possibile utilizzare la [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) per creare una nuova funzione o aggiornare una funzione esistente mediante un file .zip. Usa la funzione [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) e [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)i comandi per distribuire il tuo pacchetto .zip. Se il file .zip ha dimensioni inferiori a 50 MB, è possibile caricare il pacchetto .zip da una posizione di file nella macchina di compilazione locale. Per i file di dimensioni maggiori, è necessario caricare il pacchetto .zip da un bucket Amazon S3. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI *
**Nota**
Se carichi il tuo file.zip da un bucket Amazon S3 utilizzando AWS CLI il, il bucket deve trovarsi nella stessa posizione della Regione AWS tua funzione.
Per creare una nuova funzione utilizzando un file.zip con AWS CLI, devi specificare quanto segue:
+ Il nome della funzione (`--function-name`)
+ Il runtime della tua funzione (`--runtime`)
+ Il nome della risorsa Amazon (ARN) del [ruolo di esecuzione](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) della funzione (`--role`)
+ Il nome del metodo del gestore nel codice della funzione (`--handler`)
È inoltre necessario specificare la posizione del file .zip. Se il file .zip si trova in una cartella sulla macchina di compilazione locale, utilizza l'opzione `--zip-file` per specificare il percorso del file, come mostrato nel seguente comando di esempio.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Per specificare la posizione del file .zip in un bucket Amazon S3, utilizza l'opzione `--code` illustrata nel seguente comando di esempio. È necessario utilizzare il parametro `S3ObjectVersion` solo per gli oggetti con controllo delle versioni.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Per aggiornare una funzione esistente mediante la CLI, specifica il nome della funzione utilizzando il parametro `--function-name`. È inoltre necessario specificare la posizione del file .zip che desideri utilizzare per aggiornare il codice della funzione. Se il file .zip si trova in una cartella sulla macchina di compilazione locale, utilizza l'opzione `--zip-file` per specificare il percorso del file, come mostrato nel seguente comando di esempio.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Per specificare la posizione del file .zip in un bucket Amazon S3, utilizza le opzioni `--s3-bucket` e `--s3-key` come illustrato nel seguente comando di esempio. È necessario utilizzare il parametro `--s3-object-version` solo per gli oggetti con controllo delle versioni.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Creazione e aggiornamento delle funzioni con file .zip utilizzando l'API Lambda
Per creare e aggiornare le funzioni mediante un archivio di file .zip, utilizza 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)
### Creazione e aggiornamento di funzioni con file.zip utilizzando AWS SAM
Il AWS Serverless Application Model (AWS SAM) è un toolkit che aiuta a semplificare il processo di creazione ed esecuzione di applicazioni serverless su. AWS Definisci le risorse per la tua applicazione in un modello YAML o JSON e utilizzi l'interfaccia a riga di AWS SAM comando (AWS SAM CLI) per creare, impacchettare e distribuire le tue applicazioni. Quando crei una funzione Lambda da un AWS SAM modello, crea AWS SAM automaticamente un pacchetto di distribuzione.zip o un'immagine del contenitore con il codice della funzione e le eventuali dipendenze specificate. Per ulteriori informazioni sull'utilizzo AWS SAM per creare e distribuire funzioni Lambda, [consulta la Guida introduttiva AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) *alla AWS SAM* Developer Guide.
È inoltre possibile utilizzare AWS SAM per creare una funzione Lambda utilizzando un archivio di file.zip esistente. Per creare una funzione Lambda utilizzando AWS SAM, puoi salvare il tuo file.zip in un bucket Amazon S3 o in una cartella locale sulla tua macchina di compilazione. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI *
Nel AWS SAM modello, la `AWS::Serverless::Function` risorsa specifica la funzione Lambda. In questa risorsa, imposta le seguenti proprietà per creare una funzione utilizzando un archivio di file .zip:
+ `PackageType`: imposta il valore su `Zip`
+ `CodeUri`- impostato sull'URI Amazon S3 del codice della funzione, sul percorso della cartella locale o sull'oggetto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)
+ `Runtime`: imposta il runtime prescelto
Inoltre AWS SAM, se il tuo file.zip è più grande di 50 MB, non è necessario caricarlo prima in un bucket Amazon S3. AWS SAM puoi caricare pacchetti.zip fino alla dimensione massima consentita di 250 MB (decompressi) da una posizione sulla macchina di compilazione locale.
*Per ulteriori informazioni sulla distribuzione delle funzioni utilizzando il file.zip in AWS SAM, consulta la Guida per gli sviluppatori. [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)AWS SAM *
### Creazione e aggiornamento di funzioni con file.zip utilizzando CloudFormation
È possibile utilizzare CloudFormation per creare una funzione Lambda utilizzando un archivio di file.zip. Per creare una funzione Lambda da un file .zip, devi prima caricare il file su un bucket Amazon S3. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI *
Per i runtime di Node.js e Python, puoi anche fornire codice sorgente in linea nel tuo modello. CloudFormation CloudFormation quindi crea un file.zip contenente il codice quando crei la funzione.
**Utilizzo di un file .zip esistente**
Nel CloudFormation modello, la `AWS::Lambda::Function` risorsa specifica la funzione Lambda. In questa risorsa, imposta le seguenti proprietà per creare una funzione utilizzando un archivio di file .zip:
+ `PackageType`: imposta il valore su `Zip`
+ `Code`: inserisci il nome del bucket Amazon S3 e il nome del file .zip nei campi `S3Bucket` e `S3Key`
+ `Runtime`: imposta il runtime prescelto
**Creazione di un file .zip da codice inline**
È possibile dichiarare semplici funzioni scritte in Python o Node.js in linea in un modello. CloudFormation Poiché il codice è incorporato in YAML o JSON, non puoi aggiungere dipendenze esterne al tuo pacchetto di implementazione. Ciò significa che la funzione deve utilizzare la versione dell' AWS SDK inclusa nel runtime. I requisiti del modello, come la necessità di evitare determinati caratteri, rendono anche più difficile l'utilizzo delle funzionalità di controllo della sintassi e di completamento del codice dell'IDE. Ciò significa che il tuo modello potrebbe richiedere test aggiuntivi. A causa di queste limitazioni, la dichiarazione di funzioni in linea è più adatta per codice molto semplice che cambia raramente.
Per creare un file .zip dal codice inline per i runtime Node.js e Python, imposta le seguenti proprietà nella risorsa del modello `AWS::Lambda::Function`:
+ `PackageType`: imposta il valore su `Zip`
+ `Code`: inserisci il codice della funzione nel campo `ZipFile`
+ `Runtime`: imposta il runtime prescelto
Il file.zip che CloudFormation genera non può superare i 4 MB. *Per ulteriori informazioni sulla distribuzione delle funzioni utilizzando il file.zip in CloudFormation, [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)consultate la Guida per l'utente.CloudFormation *
# Distribuisci funzioni Lambda per Python con immagini di container
Esistono tre modi per creare un'immagine di container per una funzione Lambda in Python:
+ [Usare un'immagine AWS base per Python](#python-image-instructions)
[Le immagini di base AWS](images-create.md#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](images-create.md#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 il [client di interfaccia di runtime per Python](#python-image-clients) nell'immagine.
+ [Utilizzo di un'immagine non di base AWS ](#python-image-clients)
È 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 il [client di interfaccia di runtime per Python](#python-image-clients) nell'immagine.
**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/).
Questa pagina spiega come creare, testare e implementare le immagini di container per Lambda.
**Topics**
+ [AWS immagini base per Python](#python-image-base)
+ [Usare un'immagine AWS base per Python](#python-image-instructions)
+ [Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime](#python-image-clients)
## AWS immagini base per Python
AWS fornisce le seguenti immagini di base per Python:
| Tag | Runtime | Sistema operativo | Dockerfile | Raggiunta obsolescenza |
| --- | --- | --- | --- | --- |
| 3.14 | Python 3.14 | Amazon Linux 2023 | [Dockerfile per Python 3.14 e versioni successive GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.14/Dockerfile.python3.14) | 30 giugno 2029 |
| 3.13 | Python 3.13 | Amazon Linux 2023 | [Dockerfile per Python 3.13 e versioni successive GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.13/Dockerfile.python3.13) | 30 giugno 2029 |
| 3,12 | Python 3.12 | Amazon Linux 2023 | [Dockerfile per Python 3.12 e versioni successive GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.12/Dockerfile.python3.12) | 31 ottobre 2028 |
| 3.11 | Python 3.11 | Amazon Linux 2 | [Dockerfile per Python 3.11 e versioni successive GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.11/Dockerfile.python3.11) | 30 giugno 2027 |
| 3,10 | Python 3.10 | Amazon Linux 2 | [Dockerfile per Python 3.10 e versioni successive GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.10/Dockerfile.python3.10) | 31 ottobre 2026 |
[Archivio Amazon ECR: gallery.ecr. aws/lambda/python](https://gallery.ecr.aws/lambda/python)
Le immagini di base Python 3.12 e versioni successive si basano sull'[immagine di container minima di Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Le immagini di base di Python 3.8-3.11 sono basate sull'immagine Amazon Linux 2. AL2023le immagini basate su Amazon Linux 2 offrono diversi vantaggi, tra cui un ingombro di implementazione 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 Docker versione 20.10.10 o successiva.
### Percorso di ricerca delle dipendenze nelle immagini di base
Quando utilizzi un'istruzione `import` nel codice, il runtime Python cerca nelle directory del suo percorso di ricerca finché non trova il modulo o il pacchetto. Per impostazione predefinita, il runtime cerca prima nella directory `{LAMBDA_TASK_ROOT}`. Se includi una versione di una libreria inclusa nel runtime nella tua immagine, questa versione avrà la precedenza sulla versione inclusa nel runtime.
Gli altri passaggi del percorso di ricerca dipendono dalla versione dell'immagine base Lambda per il Python che stai utilizzando:
+ **Python 3.11 e versioni successive**: le librerie incluse nel runtime e le librerie installate con pip sono installate nella directory `/var/lang/lib/python3.11/site-packages`. Questa directory ha la precedenza su `/var/runtime` nel percorso di ricerca. Puoi sovrascrivere l'SDK usando pip per installare una versione più recente. Puoi usare pip per verificare che l'SDK incluso nel runtime e le sue dipendenze siano compatibili con tutti i pacchetti che installi.
+ **Python 3.8-3.10**: le librerie incluse nel runtime sono installate nella directory `/var/runtime`. Le librerie installate da pip sono installate nella directory `/var/lang/lib/python3.x/site-packages`. La directory `/var/runtime` ha la precedenza su `/var/lang/lib/python3.x/site-packages` nel percorso di ricerca.
Puoi visualizzare il percorso di ricerca completo per la tua funzione Lambda aggiungendo il seguente frammento di codice.
```
import sys
search_path = sys.path
print(search_path)
```
## Usare un'immagine AWS base per Python
### Prerequisiti
Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
+ Python
### Creazione di un'immagine da un'immagine di base
**Per creare un'immagine contenitore da un'immagine di AWS base per Python**
1. Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
1. Crea un nuovo file denominato `lambda_function.py`. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
**Example Funzione Python**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Crea un nuovo file denominato `requirements.txt`. Se stai utilizzando il codice della funzione di esempio del passaggio precedente, puoi lasciare il file vuoto perché non ci sono dipendenze. Altrimenti, elenca ogni libreria richiesta. Ad esempio, ecco come dovrebbe apparire la tua versione di `requirements.txt` se la funzione utilizza AWS SDK per Python (Boto3):
**Example requirements.txt**
```
boto3
```
1. Crea un nuovo Dockerfile con la seguente configurazione:
+ Imposta la proprietà `FROM` sull'[URI dell'immagine di base](https://gallery.ecr.aws/lambda/python/).
+ Utilizza il comando COPY per copiare il codice della funzione e le dipendenze di runtime in `{LAMBDA_TASK_ROOT}`, una [variabile d'ambiente definita da Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Imposta l'argomento `CMD` specificando il gestore della funzione Lambda.
Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/python:3.12
# Copy requirements.txt
COPY requirements.txt ${LAMBDA_TASK_ROOT}
# Install the specified packages
RUN pip install -r requirements.txt
# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.handler" ]
```
1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Nota**
Il comando specifica l’opzione `--platform linux/amd64` per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.
### (Facoltativo) Test dell'immagine in locale
1. Avvia l'immagine Docker con il comando **docker run**. In questo esempio, `docker-image` è il nome dell'immagine e `test` è il tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Questo comando esegue l'immagine come container e crea un endpoint locale in `localhost:9000/2015-03-31/functions/function/invocations`.
**Nota**
Se hai creato l'immagine Docker per l'architettura del set di ARM64 istruzioni, assicurati di utilizzare l'`--platform linux/arm64`opzione invece di. `--platform linux/amd64`
1. Da una nuova finestra di terminale, invia un evento all'endpoint locale.
------
#### [ Linux/macOS ]
Su MacOS o Linux, esegui il comando seguente `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
In PowerShell, esegui il seguente `Invoke-WebRequest` comando:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Ottieni l'ID del container.
```
docker ps
```
1. Utilizza il comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) per arrestare il container. In questo comando, sostituisci `3766c4ab331c` con l'ID del container del passaggio precedente.
```
docker kill 3766c4ab331c
```
### Implementazione dell'immagine
**Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda**
1. Esegui il [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)comando per autenticare la CLI Docker nel tuo registro Amazon ECR.
+ Imposta il `--region` valore nel Regione AWS punto in cui desideri creare il repository Amazon ECR.
+ Sostituiscilo `111122223333` con il tuo ID. Account AWS
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Crea un repository in Amazon ECR utilizzando il commando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Nota**
Il repository Amazon ECR deve corrispondere alla funzione Lambda. Regione AWS
In caso di esito positivo, dovresti ottenere una risposta simile a questa:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copia il `repositoryUri` dall'output del passaggio precedente.
1. Esegui il comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
+ `docker-image:test` è il nome e [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) dell'immagine Docker. Si tratta del nome e del tag dell'immagine specificati nel comando `docker build`.
+ Sostituisci l’`` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere `:latest` alla fine dell'URI del repository.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
1. Creazione della funzione Lambda Per `ImageUri`, specifica l'URI del repository creato in precedenza. Assicurati di includere `:latest` alla fine dell'URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Nota**
È 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](images-create.md#configuration-images-xaccount-permissions).
1. Richiama la funzione.
```
aws lambda invoke --function-name hello-world response.json
```
Dovresti ottenere una risposta simile a questa:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Per vedere l'output della funzione, controlla il file `response.json`.
Per aggiornare il codice della funzione, devi creare nuovamente l'immagine, caricare la nuova immagine nell'archivio Amazon ECR e quindi utilizzare il [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.
Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.
Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime
Se utilizzi un'[immagine di base solo per il sistema operativo](images-create.md#runtimes-images-provided) o un'immagine di base alternativa, devi includere il client dell'interfaccia di runtime nell'immagine. Il client dell'interfaccia di runtime estende l'[API Runtime](runtimes-api.md), che gestisce l'interazione tra Lambda e il codice della funzione.
Installa il [client di interfaccia di runtime per Python](https://pypi.org/project/awslambdaric) utilizzando il gestore di pacchetti pip:
```
pip install awslambdaric
```
Puoi anche scaricare il [client dell'interfaccia di runtime Python](https://github.com/aws/aws-lambda-python-runtime-interface-client/) da. GitHub
L'esempio seguente dimostra come creare un'immagine contenitore per Python usando un'immagine non di base AWS . Il Dockerfile di esempio utilizza un'immagine di base Python ufficiale. Il Dockerfile include il client di interfaccia di runtime per Python.
### Prerequisiti
Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
+ Python
### Creazione di un'immagine da un'immagine di base alternativa
**Per creare un'immagine contenitore da un'immagine non di AWS base**
1. Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
1. Crea un nuovo file denominato `lambda_function.py`. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
**Example Funzione Python**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Crea un nuovo file denominato `requirements.txt`. Se stai utilizzando il codice della funzione di esempio del passaggio precedente, puoi lasciare il file vuoto perché non ci sono dipendenze. Altrimenti, elenca ogni libreria richiesta. Ad esempio, ecco come dovrebbe apparire la tua versione di `requirements.txt` se la funzione utilizza AWS SDK per Python (Boto3):
**Example requirements.txt**
```
boto3
```
1. Crea un nuovo Dockerfile. Il seguente Dockerfile utilizza un'immagine di base Python ufficiale anziché un'[immagine di base AWS](images-create.md#runtimes-images-lp). Il Dockerfile include il [client di interfaccia di runtime](https://pypi.org/project/awslambdaric), che rende l'immagine compatibile con Lambda. Il seguente Dockerfile di esempio utilizza una [build multi-fase](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds).
+ Imposta la proprietà `FROM` sull'immagine di base.
+ Imposta l'`ENTRYPOINT` sul modulo su cui desideri che il container Docker venga eseguito all'avvio. In questo caso, il modulo è il client di interfaccia di runtime.
+ Imposta il `CMD` specificando il gestore della funzione Lambda.
Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.
**Example Dockerfile**
```
# Define custom function directory
ARG FUNCTION_DIR="/function"
FROM python:3.12 AS build-image
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}
# Install the function's dependencies
RUN pip install \
--target ${FUNCTION_DIR} \
awslambdaric
# Use a slim version of the base Python image to reduce the final image size
FROM python:3.12-slim
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}
# Copy in the built dependencies
COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "lambda_function.handler" ]
```
1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Nota**
Il comando specifica l’opzione `--platform linux/amd64` per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.
### (Facoltativo) Test dell'immagine in locale
Usa il [simulatore dell'interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) per testare localmente l'immagine. Puoi [creare l'emulatore nella tua immagine](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) o seguire la procedura riportata e installarlo sul tuo computer locale.
**Installazione ed esecuzione dell'emulatore di interfaccia di runtime sul computer locale**
1. Dalla directory del progetto, esegui il comando seguente per scaricare l'emulatore di interfaccia di runtime (architettura x86-64) GitHub e installarlo sul computer locale.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Per installare l'emulatore arm64, sostituisci l'URL del GitHub repository nel comando precedente con il seguente:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Per installare l'emulatore arm64, sostituisci `$downloadLink` con quanto segue:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Avvia l'immagine Docker con il comando **docker run**. Tenere presente quanto segue:
+ `docker-image` è il nome dell'immagine e `test` è il tag.
+ `/usr/local/bin/python -m awslambdaric lambda_function.handler` è l'`ENTRYPOINT` seguito dal `CMD` del Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
Questo comando esegue l'immagine come container e crea un endpoint locale in `localhost:9000/2015-03-31/functions/function/invocations`.
**Nota**
Se hai creato l'immagine Docker per l'architettura del set di ARM64 istruzioni, assicurati di utilizzare l'`--platform linux/arm64`opzione anziché. `--platform linux/amd64`
1. Pubblica un evento nell'endpoint locale.
------
#### [ Linux/macOS ]
Su MacOS o Linux, esegui il comando seguente `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
In PowerShell, esegui il seguente `Invoke-WebRequest` comando:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Ottieni l'ID del container.
```
docker ps
```
1. Utilizza il comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) per arrestare il container. In questo comando, sostituisci `3766c4ab331c` con l'ID del container del passaggio precedente.
```
docker kill 3766c4ab331c
```
### Implementazione dell'immagine
**Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda**
1. Esegui il [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)comando per autenticare la CLI Docker nel tuo registro Amazon ECR.
+ Imposta il `--region` valore nel Regione AWS punto in cui desideri creare il repository Amazon ECR.
+ Sostituiscilo `111122223333` con il tuo ID. Account AWS
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Crea un repository in Amazon ECR utilizzando il commando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Nota**
Il repository Amazon ECR deve corrispondere alla funzione Lambda. Regione AWS
In caso di esito positivo, dovresti ottenere una risposta simile a questa:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copia il `repositoryUri` dall'output del passaggio precedente.
1. Esegui il comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
+ `docker-image:test` è il nome e [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) dell'immagine Docker. Si tratta del nome e del tag dell'immagine specificati nel comando `docker build`.
+ Sostituisci l’`` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere `:latest` alla fine dell'URI del repository.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
1. Creazione della funzione Lambda Per `ImageUri`, specifica l'URI del repository creato in precedenza. Assicurati di includere `:latest` alla fine dell'URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Nota**
È 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](images-create.md#configuration-images-xaccount-permissions).
1. Richiama la funzione.
```
aws lambda invoke --function-name hello-world response.json
```
Dovresti ottenere una risposta simile a questa:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Per vedere l'output della funzione, controlla il file `response.json`.
Per aggiornare il codice della funzione, devi creare nuovamente l'immagine, caricare la nuova immagine nell'archivio Amazon ECR e quindi utilizzare il [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.
Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.
Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
Per un esempio di come creare un'immagine Python da un'immagine di base Alpine, consulta [Supporto delle immagini di container per Lambda](https://aws.amazon.com/blogs/aws/new-for-aws-lambda-container-image-support/) sul Blog AWS .
# Utilizzo dei livelli per le funzioni Lambda in Python
Usa i [livelli Lambda](chapter-layers.md) per impacchettare codice e dipendenze che desideri riutilizzare in più funzioni. I livelli di solito contengono dipendenze dalla libreria, un [runtime personalizzato](runtimes-custom.md) o file di configurazione. La creazione di un livello prevede tre passaggi generali:
1. Crea un pacchetto per il contenuto del livello. Ciò significa creare un archivio di file con estensione .zip che contiene le dipendenze che desideri utilizzare nelle funzioni.
1. Crea il livello in Lambda.
1. Aggiungi il livello alle tue funzioni.
**Topics**
+ [Crea un pacchetto per il contenuto del livello](#python-layers-package)
+ [Crea il layer in Lambda](#publishing-layer)
+ [Aggiungi il layer alla tua funzione](#python-layer-adding)
+ [App di esempio](#python-layer-sample-app)
## Crea un pacchetto per il contenuto del livello
Per creare un layer, raggruppa i pacchetti in un archivio di file.zip che soddisfi i seguenti requisiti:
+ Costruite il layer utilizzando la stessa versione di Python che intendete utilizzare per la funzione Lambda. Ad esempio, se crei il tuo layer usando Python 3.14, usa il runtime Python 3.14 per la tua funzione.
+ Il file.zip deve includere una `python` directory a livello root.
+ I pacchetti del livello devono essere compatibili con Linux. Le funzioni Lambda vengono eseguite su Amazon Linux.
È possibile creare livelli che contengono librerie Python di terze parti installate con `pip` (come `requests` o`pandas`) o moduli e pacchetti Python personalizzati.
### Dipendenze da terze parti
**Per creare un livello utilizzando pacchetti pip**
1. Scegliete uno dei seguenti metodi per installare `pip` i pacchetti nella directory di primo livello richiesta ()`python/`:
------
#### [ pip install ]
Per pacchetti Python puri (come requests o boto3):
```
pip install requests -t python/
```
Alcuni pacchetti Python, come NumPy e Pandas, includono componenti C compilati. Se state creando un layer con questi pacchetti su macOS o Windows, potreste aver bisogno di usare questo comando per installare una ruota compatibile con Linux:
```
pip install numpy --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Per ulteriori informazioni sull'utilizzo dei pacchetti Python che contengono componenti compilati, vedere. [Creazione di un pacchetto di implementazione .zip con librerie native](python-package.md#python-package-native-libraries)
------
#### [ requirements.txt ]
L'utilizzo di un `requirements.txt` file consente di gestire le versioni dei pacchetti e garantire installazioni coerenti.
**Example requirements.txt**
```
requests==2.31.0
boto3==1.37.34
numpy==1.26.4
```
Se il tuo `requirements.txt` file include solo pacchetti Python puri (come requests o boto3):
```
pip install -r requirements.txt -t python/
```
Alcuni pacchetti Python, come NumPy e Pandas, includono componenti C compilati. Se state creando un layer con questi pacchetti su macOS o Windows, potreste aver bisogno di usare questo comando per installare una ruota compatibile con Linux:
```
pip install -r requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Per ulteriori informazioni sull'utilizzo dei pacchetti Python che contengono componenti compilati, vedere. [Creazione di un pacchetto di implementazione .zip con librerie native](python-package.md#python-package-native-libraries)
------
1. Comprimi il contenuto della `python` directory.
------
#### [ Linux/macOS ]
```
zip -r layer.zip python/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\python -DestinationPath .\layer.zip
```
------
La struttura delle cartelle del file.zip dovrebbe essere la seguente:
```
python/ # Required top-level directory
└── requests/
└── boto3/
└── numpy/
└── (dependencies of the other packages)
```
**Nota**
Se usi un ambiente virtuale Python (venv) per installare i pacchetti, la struttura delle cartelle sarà diversa (ad esempio,). `python/lib/python3.x/site-packages` Finché il file.zip include la `python` directory a livello principale, Lambda può localizzare e importare i pacchetti.
### Moduli Python personalizzati
**Per creare un livello utilizzando il proprio codice**
1. Crea la directory di primo livello richiesta per il tuo layer:
```
mkdir python
```
1. Crea i tuoi moduli Python nella `python` directory. Il seguente modulo di esempio convalida gli ordini confermando che contengono le informazioni richieste.
**Example modulo personalizzato: validator.py**
```
import json
def validate_order(order_data):
"""Validates an order and returns formatted data."""
required_fields = ['product_id', 'quantity']
# Check required fields
missing_fields = [field for field in required_fields if field not in order_data]
if missing_fields:
raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
# Validate quantity
quantity = order_data['quantity']
if not isinstance(quantity, int) or quantity < 1:
raise ValueError("Quantity must be a positive integer")
# Format and return the validated data
return {
'product_id': str(order_data['product_id']),
'quantity': quantity,
'shipping_priority': order_data.get('priority', 'standard')
}
def format_response(status_code, body):
"""Formats the API response."""
return {
'statusCode': status_code,
'body': json.dumps(body)
}
```
1. Comprimi il contenuto della `python` directory.
------
#### [ Linux/macOS ]
```
zip -r layer.zip python/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\python -DestinationPath .\layer.zip
```
------
La struttura delle cartelle del file.zip dovrebbe essere la seguente:
```
python/ # Required top-level directory
└── validator.py
```
1. Nella tua funzione, importa e usa i moduli come faresti con qualsiasi pacchetto Python. Esempio:
```
from validator import validate_order, format_response
import json
def lambda_handler(event, context):
try:
# Parse the order data from the event body
order_data = json.loads(event.get('body', '{}'))
# Validate and format the order
validated_order = validate_order(order_data)
return format_response(200, {
'message': 'Order validated successfully',
'order': validated_order
})
except ValueError as e:
return format_response(400, {
'error': str(e)
})
except Exception as e:
return format_response(500, {
'error': 'Internal server error'
})
```
È possibile utilizzare il seguente [evento di test](testing-functions.md#invoke-with-event) per richiamare la funzione:
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Risposta prevista:
```
{
"statusCode": 200,
"body": "{\"message\": \"Order validated successfully\", \"order\": {\"product_id\": \"ABC123\", \"quantity\": 2, \"shipping_priority\": \"express\"}}"
}
```
## Crea il layer in Lambda
È possibile pubblicare il layer utilizzando la console AWS CLI o la console Lambda.
------
#### [ AWS CLI ]
Esegui il [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS CLI comando per creare il livello Lambda:
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes python3.14
```
Il parametro di [runtime compatibile](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) è facoltativo. Quando specificato, Lambda utilizza questo parametro per filtrare i livelli nella console Lambda.
------
#### [ Console ]
**Creazione di un livello (console)**
1. Apri la [pagina Layers](https://console.aws.amazon.com/lambda/home#/layers) (Livelli) nella console Lambda.
1. Scegli **Create layer** (Crea livello).
1. Scegli **Carica un file.zip**, quindi carica l'archivio.zip che hai creato in precedenza.
1. (Facoltativo) Per i **runtime compatibili**, scegliete il runtime Python che corrisponde alla versione di Python che avete usato per creare il layer.
1. Scegli **Create** (Crea).
------
## Aggiungi il layer alla tua funzione
------
#### [ AWS CLI ]
Per collegare il layer alla tua funzione, esegui il [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI comando. Per il `--layers` parametro, utilizzate il livello ARN. L'ARN deve specificare la versione (ad esempio,`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Per ulteriori informazioni, consulta [Livelli e versioni di livelli](chapter-layers.md#lambda-layer-versions).
```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```
L'**cli-binary-format**opzione è obbligatoria se si utilizza la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*.
------
#### [ Console ]
**Aggiunta di un livello a una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli la funzione.
1. Scorri verso il basso fino alla sezione **Livelli**, quindi scegli **Aggiungi un livello**.
1. In **Scegli un livello**, seleziona **Livelli personalizzati**, quindi scegli il tuo livello.
**Nota**
Se non hai aggiunto un [runtime compatibile](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) quando hai creato il layer, il tuo layer non verrà elencato qui. È possibile specificare invece il livello ARN.
1. Scegliere **Aggiungi**.
------
## App di esempio
Per altri esempi di utilizzo dei layer Lambda, consultate l'applicazione di esempio [layer-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-python) nel repository Developer Guide. AWS Lambda GitHub Questa applicazione include due livelli che contengono librerie Python. Dopo aver creato i livelli, è possibile distribuire e richiamare le funzioni corrispondenti per confermare che i livelli funzionino come previsto.
# Utilizzo dell'oggetto del contesto Lambda per recuperare le informazioni sulla funzione Python
Quando Lambda esegue la funzione, passa un oggetto Context al [gestore](python-handler.md). Questo oggetto fornisce i metodi e le proprietà che forniscono le informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione. Per ulteriori informazioni su come l'oggetto contesto viene passato al gestore di funzioni, consulta [Definire l'handler della funzione Lambda in Python](python-handler.md).
**Metodi del contesto**
+ `get_remaining_time_in_millis`: restituisce il numero di millisecondi rimasti prima del timeout dell'esecuzione.
**Proprietà del contesto**
+ `function_name`: il nome della funzione Lambda.
+ `function_version`: la [versione](configuration-versions.md) della funzione.
+ `invoked_function_arn`: l'Amazon Resource Name (ARN) utilizzato per richiamare la funzione. Indica se l'invoker ha specificato un numero di versione o un alias.
+ `memory_limit_in_mb`: la quantità di memoria allocata per la funzione.
+ `aws_request_id`: l'identificatore della richiesta di invocazione.
+ `log_group_name`: il gruppo di log per la funzione.
+ `log_stream_name`: il flusso di log per l'istanza della funzione.
+ `identity`: (app per dispositivi mobili) Informazioni relative all'identità Amazon Cognito che ha autorizzato la richiesta.
+ `cognito_identity_id`: l'identità autenticata di Amazon Cognito.
+ `cognito_identity_pool_id`: il pool di identità Amazon Cognito che ha autorizzato l'invocazione.
+ `client_context`: (app per dispositivi mobili) Contesto client fornito a Lambda dall'applicazione client.
+ `client.installation_id`
+ `client.app_title`
+ `client.app_version_name`
+ `client.app_version_code`
+ `client.app_package_name`
+ `custom`: un `dict` di valori personalizzati impostati dall'applicazione client per dispositivi mobili.
+ `env`: un `dict` di informazioni di ambiente fornite dall'SDK AWS.
Powertools for Lambda (Python) fornisce una definizione di interfaccia per l'oggetto del contesto Lambda. È possibile utilizzare la definizione dell'interfaccia per i suggerimenti sul tipo o per esaminare ulteriormente la struttura dell'oggetto del contesto Lambda. Per la definizione dell'interfaccia, consulta [lambda\$1context.py](https://github.com/aws-powertools/powertools-lambda-python/blob/develop/aws_lambda_powertools/utilities/typing/lambda_context.py) nel repository *powertools-lambda-python* su GitHub.
L'esempio seguente mostra una funzione di gestione che registra le informazioni di contesto.
**Example handler.py**
```
import time
def lambda_handler(event, context):
print("Lambda function ARN:", context.invoked_function_arn)
print("CloudWatch log stream name:", context.log_stream_name)
print("CloudWatch log group name:", context.log_group_name)
print("Lambda Request ID:", context.aws_request_id)
print("Lambda function memory limits in MB:", context.memory_limit_in_mb)
# We have added a 1 second delay so you can see the time remaining in get_remaining_time_in_millis.
time.sleep(1)
print("Lambda time remaining in MS:", context.get_remaining_time_in_millis())
```
Oltre alle opzioni elencate in precedenza, è possibile utilizzare l'SDK AWS X-Ray per [Strumentazione del codice Python in AWS Lambda](python-tracing.md) per identificare i percorsi del codice critici, tenere traccia delle relative prestazioni e acquisire i dati per l'analisi.
# Registrare e monitorare le funzioni Lambda con Python
AWS Lambda monitora automaticamente le funzioni Lambda e invia le voci di registro ad Amazon. CloudWatch La funzione Lambda include un gruppo di log CloudWatch Logs e un flusso di log per ogni istanza della funzione. L'ambiente di runtime di Lambda invia al flusso di log i dettagli su ogni invocazione e altri output dal codice della funzione. Per ulteriori informazioni sui CloudWatch registri, consulta. [Lambda invia automaticamente i log delle funzioni a CloudWatch Logs.](monitoring-cloudwatchlogs.md)
Per l'output dei log dal codice della funzione, puoi utilizzare il modulo di [https://docs.python.org/3/library/logging.html](https://docs.python.org/3/library/logging.html) integrato. Per ottenere voci più dettagliate, puoi utilizzare qualunque libreria di log che scrive in `stdout` o `stderr`.
## Stampa nel log
Per inviare l'output base ai log, puoi utilizzare un metodo `print` nella funzione. L'esempio seguente registra i valori del gruppo e del flusso di log CloudWatch Logs e dell'oggetto evento.
Nota che se la tua funzione genera log usando istruzioni Python`print`, Lambda può inviare output di log a Logs solo in formato testo semplice. CloudWatch Per acquisire i log in formato JSON strutturato, è necessario utilizzare una libreria di registrazione supportata. Per ulteriori informazioni, consulta [Utilizzo dei controlli di registrazione avanzati di Lambda con Python](#python-logging-advanced).
**Example lambda\$1function.py**
```
import os
def lambda_handler(event, context):
print('## ENVIRONMENT VARIABLES')
print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
print('## EVENT')
print(event)
```
**Example Output log**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
/aws/lambda/my-function
2025/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
Il runtime di Python registra `START`, `END` e `REPORT` per ogni chiamata. La riga `REPORT` include i seguenti dati:
**Campi dati della riga REPORT**
+ **RequestId**— L'ID univoco della richiesta per la chiamata.
+ **Durata** – La quantità di tempo che il metodo del gestore della funzione impiega durante l'elaborazione dell'evento.
+ **Durata fatturata** – La quantità di tempo fatturata per la chiamata.
+ **Dimensioni memoria** – La quantità di memoria allocata per la funzione.
+ **Quantità max utilizzata** – La quantità di memoria utilizzata dalla funzione. Quando le invocazioni condividono un ambiente di esecuzione, Lambda riporta la memoria massima utilizzata in tutte le invocazioni. Questo comportamento potrebbe comportare un valore riportato superiore al previsto.
+ **Durata Init** – Per la prima richiesta servita, la quantità di tempo impiegato dal runtime per caricare la funzione ed eseguire il codice al di fuori del metodo del gestore.
+ **XRAY TraceId** [— Per le richieste tracciate, l'ID di traccia.AWS X-Ray](services-xray.md)
+ **SegmentId**— Per le richieste tracciate, l'ID del segmento X-Ray.
+ **Campionato** – Per le richieste tracciate, il risultato del campionamento.
## Utilizzo di una libreria di log
Per registri più dettagliati, utilizza il modulo di [log](https://docs.python.org/3/library/logging.html) nella libreria standard o qualunque libreria di log di terzi che scrive in `stdout` o `stderr`.
Per i runtime Python supportati, puoi scegliere se i log creati utilizzando il modulo `logging` standard vengono acquisiti in testo normale o JSON. Per ulteriori informazioni, consulta [Utilizzo dei controlli di registrazione avanzati di Lambda con Python](#python-logging-advanced).
Attualmente, il formato di log predefinito per tutti i runtime di Python è il testo normale. L'esempio seguente mostra come gli output di registro creati utilizzando il `logging` modulo standard vengono acquisiti in testo semplice in Logs. CloudWatch
```
import os
import logging
logger = logging.getLogger()
logger.setLevel("INFO")
def lambda_handler(event, context):
logger.info('## ENVIRONMENT VARIABLES')
logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
logger.info('## EVENT')
logger.info(event)
```
L'output di `logger` include il livello del log, il timestamp e l'ID della richiesta.
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 /aws/lambda/my-function
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 2025/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d
[INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
**Nota**
Quando il formato di log della funzione è impostato su testo semplice, l'impostazione predefinita a livello di log per i runtime Python è WARN. Ciò significa che Lambda invia solo output di log di livello WARN e inferiore a Logs. CloudWatch Per modificare il livello di log predefinito, utilizza il metodo `logging` `setLevel()` di Python come mostrato in questo codice di esempio. Se imposti il formato di log della funzione su JSON, consigliamo di configurare il livello di log della funzione utilizzando i controlli di registrazione avanzati di Lambda e non impostando il livello di log nel codice. Per ulteriori informazioni, consulta [Utilizzo del filtraggio a livello di log con Python](#python-logging-levels)
## Utilizzo dei controlli di registrazione avanzati di Lambda con Python
Per avere un maggiore controllo sul modo in cui i log delle tue funzioni vengono acquisiti, elaborati e utilizzati, puoi configurare le seguenti opzioni di registrazione per i runtime Python di Lambda supportati:
+ **Formato di log**: scegli tra i formati di testo normale e JSON strutturato per i log della funzione
+ **Livello di log**: per i log in formato JSON, scegli il livello di dettaglio dei log che Lambda invia ad CloudWatch Amazon, come ERROR, DEBUG o INFO
+ Gruppo di **log: scegli il gruppo** di log a cui la CloudWatch funzione invia i log
Per ulteriori informazioni su queste opzioni di registrazione e istruzioni su come configurare la funzione per utilizzarle, consulta la pagina [Configurazione dei controlli di registrazione avanzati per le funzioni Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
Per ulteriori informazioni sull'utilizzo delle opzioni di formato e livello di log con le funzioni Lambda in Python, consulta le istruzioni nelle sezioni seguenti.
### Utilizzo di log JSON strutturati con Python
Se selezioni JSON per il formato di log della tua funzione, Lambda invierà i log in uscita dalla libreria di registrazione standard Python in un formato JSON strutturato. CloudWatch Ogni oggetto di log JSON contiene almeno quattro coppie chiave-valore con le seguenti chiavi:
+ `"timestamp"`: l'ora in cui è stato generato il messaggio di log
+ `"level"`: il livello di log assegnato al messaggio
+ `"message"`: il contenuto del messaggio di log
+ `"requestId"`: l'ID di richiesta univoco dell'invocazione alla funzione
La libreria `logging` di Python può anche aggiungere a tale oggetto JSON ulteriori coppie chiave-valore, come `"logger"`.
Gli esempi nelle sezioni seguenti mostrano come gli output di log generati utilizzando la libreria `logging` Python vengono acquisiti CloudWatch in Logs quando si configura il formato di log della funzione come JSON.
Tieni presente che se usi il metodo `print` per generare output log di base come descritto in [Stampa nel log](#python-logging-output), Lambda acquisirà questi output come testo normale anche se configuri il formato di registrazione della funzione come JSON.
#### Output log JSON standard che utilizzano la libreria di registrazione di Python
Il seguente frammento di codice e l'output di registro mostrano come gli output di log standard generati utilizzando la `logging` libreria Python vengono acquisiti in CloudWatch Logs quando il formato di log della funzione è impostato su JSON.
**Example Codice di registrazione di Python**
```
import logging
logger = logging.getLogger()
def lambda_handler(event, context):
logger.info("Inside the handler function")
```
**Example Record di log JSON**
```
{
"timestamp":"2025-10-27T19:17:45.586Z",
"level":"INFO",
"message":"Inside the handler function",
"logger": "root",
"requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"
}
```
#### Registrazione di parametri aggiuntivi in JSON
Quando il formato dei log della funzione è impostato su JSON, è possibile registrare ulteriori parametri con la libreria standard `logging` di Python utilizzando la parola chiave `extra` per passare un dizionario Python all'output dei log.
**Example Codice di registrazione di Python**
```
import logging
def lambda_handler(event, context):
logging.info(
"extra parameters example",
extra={"a":"b", "b": [3]},
)
```
**Example Record di log JSON**
```
{
"timestamp": "2025-11-02T15:26:28Z",
"level": "INFO",
"message": "extra parameters example",
"logger": "root",
"requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01",
"a": "b",
"b": [
3
]
}
```
#### Registrazione delle eccezioni in JSON
Il seguente frammento di codice mostra come le eccezioni Python vengono acquisite nell'output log della funzione quando si configura JSON come formato di log. Nota che agli output log generati utilizzando `logging.exception` viene assegnato il livello di log ERROR.
**Example Codice di registrazione di Python**
```
import logging
def lambda_handler(event, context):
try:
raise Exception("exception")
except:
logging.exception("msg")
```
**Example Record di log JSON**
```
{
"timestamp": "2025-11-02T16:18:57Z",
"level": "ERROR",
"message": "msg",
"logger": "root",
"stackTrace": [
" File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n raise Exception(\"exception\")\n"
],
"errorType": "Exception",
"errorMessage": "exception",
"requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855",
"location": "/var/task/lambda_function.py:lambda_handler:17"
}
```
#### Log JSON strutturati con altri strumenti di registrazione
Se il codice utilizza già un'altra libreria di registrazione, come Powertools for, per produrre log strutturati JSON AWS Lambda, non è necessario apportare alcuna modifica. AWS Lambda non codifica due volte i log che sono già codificati in JSON. Anche se configuri la tua funzione per utilizzare il formato di registro JSON, i tuoi output di registrazione vengono visualizzati nella struttura JSON che definisci. CloudWatch
L'esempio seguente mostra come gli output di log generati utilizzando il pacchetto Powertools for AWS Lambda vengono acquisiti in Logs. CloudWatch Il formato di questo output log è lo stesso indipendentemente dal fatto che la configurazione di registrazione della funzione sia impostata su JSON o TEXT. Per ulteriori informazioni sull'utilizzo di Powertools per, vedere e AWS Lambda[Utilizzo di Powertools per AWS Lambda (Python) AWS SAM e per la registrazione strutturata](#python-logging-sam) [Utilizzo di Powertools per AWS Lambda (Python) AWS CDK e per la registrazione strutturata](#python-logging-powertools-cdk)
**Example Frammento di codice di registrazione Python (usando Powertools for) AWS Lambda**
```
from aws_lambda_powertools import Logger
logger = Logger()
def lambda_handler(event, context):
logger.info("Inside the handler function")
```
**Example Record di registro JSON (utilizzando Powertools per) AWS Lambda**
```
{
"level": "INFO",
"location": "lambda_handler:7",
"message": "Inside the handler function",
"timestamp": "2025-10-31 22:38:21,010+0000",
"service": "service_undefined",
"xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30"
}
```
### Utilizzo del filtraggio a livello di log con Python
Configurando il filtraggio a livello di registro, puoi scegliere di inviare solo i log di un determinato livello di registrazione o inferiore a Logs. CloudWatch Per informazioni su come configurare il filtraggio a livello di log della funzione, consulta la pagina [Filtraggio a livello di log](monitoring-cloudwatchlogs-log-level.md).
Per AWS Lambda filtrare i log delle applicazioni in base al relativo livello di registro, la funzione deve utilizzare log in formato JSON. Puoi farlo in due modi:
+ Crea output log utilizzando la libreria standard `logging` di Python e configura la funzione affinché utilizzi JSON come formato di log. Successivamente, AWS Lambda filtra gli output log utilizzando la coppia chiave-valore "livello" nell'oggetto JSON descritto in [Utilizzo di log JSON strutturati con Python](#python-logging-JSON). Per informazioni su come configurare il formato di log della funzione, consulta la pagina [Configurazione dei controlli di registrazione avanzati per le funzioni Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
+ Utilizza un'altra libreria o metodo di registrazione per creare nel codice dei log JSON strutturati che includono una coppia chiave-valore "livello" che definisce il livello dell'output log. Ad esempio, puoi utilizzare Powertools per AWS Lambda generare output di log strutturati JSON dal tuo codice.
Inoltre, è possibile utilizzare un'istruzione di stampa per generare un oggetto JSON contenente un identificatore a livello di log. La seguente istruzione print produce un output in formato JSON in cui il livello di registro è impostato su INFO. AWS Lambda invierà l'oggetto JSON a CloudWatch Logs se il livello di registrazione della funzione è impostato su INFO, DEBUG o TRACE.
```
print('{"msg":"My log message", "level":"info"}')
```
Per consentire a Lambda di filtrare i log della funzione, è necessario includere anche una coppia chiave-valore `"timestamp"` nell'output log JSON. L'ora deve essere specificata in un formato di timestamp [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) valido. Se non fornisci un timestamp valido, Lambda assegnerà al log il livello INFO e aggiungerà un timestamp per tuo conto.
## Visualizzazione dei log nella console Lambda
È possibile utilizzare la console Lambda per visualizzare l'output del log dopo aver richiamato una funzione Lambda.
Se il codice può essere testato dall'editor del **codice** incorporato, troverai i log nei **risultati dell’esecuzione**. Quando utilizzi la funzionalità di test della console per richiamare una funzione, troverai l’**output del log** nella sezione **Dettagli**.
## Visualizzazione dei log nella console CloudWatch
Puoi utilizzare la CloudWatch console Amazon per visualizzare i log di tutte le chiamate di funzioni Lambda.
**Per visualizzare i log sulla console CloudWatch**
1. Apri la [pagina Registra gruppi](https://console.aws.amazon.com/cloudwatch/home?#logs:) sulla CloudWatch console.
1. Scegli il gruppo di log per la tua funzione (***your-function-name*/aws/lambda/**).
1. Creare un flusso di log.
Ogni flusso di log corrisponde a un'[istanza della funzione](lambda-runtime-environment.md). Viene visualizzato un flusso di log quando aggiorni la funzione Lambda e quando vengono create istanze aggiuntive per gestire le chiamate simultanee. Per trovare i log per una chiamata specifica, consigliamo di strumentare la funzione con. AWS X-Ray X-Ray registra i dettagli sulla richiesta e il flusso di log nella traccia.
## Visualizzazione dei log con AWS CLI
AWS CLI È uno strumento open source che consente di interagire con i AWS servizi utilizzando i comandi nella shell della riga di comando. Per completare le fasi riportate in questa sezione, è necessario disporre della [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
È possibile utilizzare [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) per recuperare i log per una chiamata utilizzando l'opzione di comando `--log-type`. La risposta include un campo `LogResult` che contiene fino a 4 KB di log con codifica base64 del richiamo.
**Example recuperare un ID di log**
Nell'esempio seguente viene illustrato come recuperare un *ID di log* dal `LogResult` campo per una funzione denominata `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Verrà visualizzato l’output seguente:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example decodificare i log**
Nello stesso prompt dei comandi, utilizzare l'`base64` utilità per decodificare i log. Nell'esempio seguente viene illustrato come recuperare i log codificati in base64 per `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
L'**cli-binary-format**opzione è obbligatoria se utilizzi la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*.
Verrà visualizzato l’output seguente:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
L'utilità `base64` è disponibile su Linux, macOS e [Ubuntu su Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Gli utenti macOS potrebbero dover utilizzare `base64 -D`.
**Example Script get-logs.sh**
Nello stesso prompt dei comandi, utilizzare lo script seguente per scaricare gli ultimi cinque eventi di log. Lo script utilizza `sed` per rimuovere le virgolette dal file di output e rimane in sospensione per 15 secondi in attesa che i log diventino disponibili. L'output include la risposta di Lambda e l'output del comando `get-log-events`.
Copiare il contenuto del seguente esempio di codice e salvare nella directory del progetto Lambda come `get-logs.sh`.
L'**cli-binary-format**opzione è obbligatoria se utilizzi la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example (solo) macOS e Linux**
Nello stesso prompt dei comandi, gli utenti macOS e Linux potrebbero dover eseguire il seguente comando per assicurarsi che lo script sia eseguibile.
```
chmod -R 755 get-logs.sh
```
**Example recuperare gli ultimi cinque eventi di log**
Nello stesso prompt dei comandi, eseguire lo script seguente per ottenere gli ultimi cinque eventi di log.
```
./get-logs.sh
```
Verrà visualizzato l’output seguente:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Eliminazione dei log
I gruppi di log non vengono eliminati automaticamente quando si elimina una funzione. Per evitare di archiviare i log a tempo indeterminato, eliminare il gruppo di log o [configurare un periodo di conservazione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) trascorso il quale i log vengono eliminati automaticamente.
## Utilizzo di altri strumenti di registrazione e librerie
[Powertools for AWS Lambda (Python](https://docs.aws.amazon.com/powertools/python/)) è un toolkit per sviluppatori per implementare le migliori pratiche Serverless e aumentare la velocità degli sviluppatori. L'[utilità di registrazione](https://docs.aws.amazon.com/powertools/python/latest/core/logger/) fornisce un logger ottimizzato per Lambda che include informazioni aggiuntive sul contesto delle funzioni in tutte le funzioni con output strutturato come JSON. Utilizza l'utility per eseguire le seguenti operazioni:
+ Acquisizione di campi essenziali dal contesto Lambda, avvii a freddo e output di registrazione della struttura come JSON
+ Registrazione degli eventi di chiamata Lambda quando richiesto (disabilitata per impostazione predefinita)
+ Stampa di tutti i log solo per una percentuale di chiamate tramite campionamento dei log (disabilitata per impostazione predefinita)
+ Aggiunta di chiavi supplementari al log strutturato in qualsiasi momento
+ Utilizzo di un formattatore di log personalizzato (Bring Your Own Formatter) per generare i log in una struttura compatibile con Logging RFC dell'organizzazione
## Utilizzo di Powertools per AWS Lambda (Python) AWS SAM e per la registrazione strutturata
Segui i passaggi riportati sotto per scaricare, creare e implementare un'applicazione Python Hello World di esempio con moduli [ Powertools per Python](https://docs.aws.amazon.com/powertools/python/latest/) integrati utilizzando AWS SAM. Questa applicazione implementa un backend dell'API di base e utilizza Powertools per l'emissione di log, parametri e tracce. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando invii una richiesta GET all'endpoint API Gateway, la funzione Lambda richiama, invia log e metriche utilizzando Embedded Metric Format e invia tracce a. CloudWatch AWS X-Ray La funzione restituisce un messaggio `hello world`.
**Prerequisiti**
Per completare le fasi riportate in questa sezione, è necessario:
+ Python 3.9
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versione 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) o successiva. Se disponi di una versione precedente della AWS SAM CLI, consulta [Aggiornamento](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade) della CLI. AWS SAM
**Distribuisci un'applicazione di esempio AWS SAM**
1. Inizializza l'applicazione utilizzando il modello Python Hello World.
```
sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --no-tracing
```
1. Costruisci l'app.
```
cd sam-app && sam build
```
1. Distribuire l'app.
```
sam deploy --guided
```
1. Seguire le istruzioni visualizzate sullo schermo. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi `Enter`.
**Nota**
Perché **HelloWorldFunction potrebbe non avere un'autorizzazione definita, va bene?** , assicurati di entrare`y`.
1. Ottieni l'URL dell'applicazione implementata:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Richiama l'endpoint dell'API:
```
curl GET
```
In caso di esito positivo, vedrai questa risposta:
```
{"message":"hello world"}
```
1. Per ottenere i log per la funzione, esegui [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo dei log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) nella *Guida per sviluppatori AWS Serverless Application Model *.
```
sam logs --stack-name sam-app
```
L'output del log ha la struttura seguente:
```
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 {
"level": "INFO",
"location": "hello:23",
"message": "Hello world API - HTTP 200",
"timestamp": "2025-02-03 14:59:51,113+0000",
"service": "PowertoolsHelloWorld",
"cold_start": true,
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_memory_size": "128",
"function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
"correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
"xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"function_name",
"service"
]
],
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
]
}
]
},
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"service": "PowertoolsHelloWorld",
"ColdStart": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"service"
]
],
"Metrics": [
{
"Name": "HelloWorldInvocations",
"Unit": "Count"
}
]
}
]
},
"service": "PowertoolsHelloWorld",
"HelloWorldInvocations": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
sam delete
```
### Gestione della conservazione dei log
I gruppi di log non vengono eliminati automaticamente quando si elimina una funzione. Per evitare di archiviare i log a tempo indeterminato, elimina il gruppo di log o configura un periodo di conservazione dopo il quale i log CloudWatch vengono eliminati automaticamente. Per configurare la conservazione dei log, aggiungi quanto segue al tuo modello: AWS SAM
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
# Omitting other properties
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
RetentionInDays: 7
```
## Utilizzo di Powertools per AWS Lambda (Python) AWS CDK e per la registrazione strutturata
Segui i passaggi seguenti per scaricare, creare e distribuire un'applicazione Hello World Python di esempio con i moduli [Powertools for AWS Lambda (Python) integrati](https://docs.aws.amazon.com/powertools/python/latest/) utilizzando il. AWS CDK Questa applicazione implementa un backend dell'API di base e utilizza Powertools per l'emissione di log, parametri e tracce. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando invii una richiesta GET all'endpoint API Gateway, la funzione Lambda richiama, invia log e metriche utilizzando Embedded Metric Format e invia tracce a. CloudWatch AWS X-Ray La funzione restituisce un messaggio hello world.
**Prerequisiti**
Per completare le fasi riportate in questa sezione, è necessario:
+ Python 3.9
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK versione 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI versione 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) o successiva. Se disponi di una versione precedente della AWS SAM CLI, consulta [Aggiornamento](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade) della CLI. AWS SAM
**Distribuisci un'applicazione di esempio AWS CDK**
1. Crea una directory di progetto per la nuova applicazione.
```
mkdir hello-world
cd hello-world
```
1. Inizializza l'app.
```
cdk init app --language python
```
1. Installa le dipendenze di Python.
```
pip install -r requirements.txt
```
1. Crea una directory **lambda\$1function** nella cartella root.
```
mkdir lambda_function
cd lambda_function
```
1. Crea un file **app.py** e aggiungi il seguente codice al file. Questo è il codice per la funzione Lambda.
```
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit
app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")
@app.get("/hello")
@tracer.capture_method
def hello():
# adding custom metrics
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/metrics/
metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)
# structured log
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/logger/
logger.info("Hello world API - HTTP 200")
return {"message": "hello world"}
# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context)
```
1. Apri la directory **hello\$1world**. Dovrebbe essere visualizzato un file denominato **hello\$1world\$1stack.py**.
```
cd ..
cd hello_world
```
1. Apri **hello\$1world\$1stack.py** e aggiungi il seguente codice al file. Contiene il [Lambda Constructor](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), che crea la funzione Lambda, configura le variabili di ambiente per Powertools e imposta la conservazione dei log su una settimana, e il [costruttore ApiGatewayv 1, che crea l'API REST](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html).
```
from aws_cdk import (
Stack,
aws_apigateway as apigwv1,
aws_lambda as lambda_,
CfnOutput,
Duration
)
from constructs import Construct
class HelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Powertools Lambda Layer
powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
self,
id="lambda-powertools",
# Using AWS Lambda Powertools via Lambda Layer
# This imports the Powertools layer which provides observability features for Lambda functions
# For available versions, see: https://docs.aws.amazon.com/powertools/python/latest/#lambda-layer
)
function = lambda_.Function(self,
'sample-app-lambda',
runtime=lambda_.Runtime.PYTHON_3_9,
layers=[powertools_layer],
code = lambda_.Code.from_asset("./lambda_function/"),
handler="app.lambda_handler",
memory_size=128,
timeout=Duration.seconds(3),
architecture=lambda_.Architecture.X86_64,
environment={
"POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
"POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
"LOG_LEVEL": "INFO"
}
)
apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))
hello_api = apigw.root.add_resource("hello")
hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))
CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")
```
1. Distribuisci l'applicazione.
```
cd ..
cdk deploy
```
1. Ottieni l'URL dell'applicazione implementata:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text
```
1. Richiama l'endpoint dell'API:
```
curl GET
```
In caso di esito positivo, vedrai questa risposta:
```
{"message":"hello world"}
```
1. Per ottenere i log per la funzione, esegui [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo dei log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) nella *Guida per sviluppatori AWS Serverless Application Model *.
```
sam logs --stack-name HelloWorldStack
```
L'output del log ha la struttura seguente:
```
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 {
"level": "INFO",
"location": "hello:23",
"message": "Hello world API - HTTP 200",
"timestamp": "2025-02-03 14:59:51,113+0000",
"service": "PowertoolsHelloWorld",
"cold_start": true,
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_memory_size": "128",
"function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
"correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
"xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"function_name",
"service"
]
],
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
]
}
]
},
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"service": "PowertoolsHelloWorld",
"ColdStart": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"service"
]
],
"Metrics": [
{
"Name": "HelloWorldInvocations",
"Unit": "Count"
}
]
}
]
},
"service": "PowertoolsHelloWorld",
"HelloWorldInvocations": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
cdk destroy
```
# Test delle funzioni AWS Lambda in Python
**Nota**
Consulta il capitolo sul [Test delle funzioni](testing-guide.md) per un'introduzione completa alle tecniche e alle best practice per testare soluzioni serverless.
Sebbene il test delle funzioni serverless si basi su tipologie e tecniche di test consolidate, è importante tenere in considerazione la possibilità di effettuare test sulle applicazioni serverless nella loro interezza. I test basati sul cloud forniranno la misura **più accurata** della qualità sia delle funzioni sia delle applicazioni serverless.
Un'architettura applicativa serverless include servizi gestiti che forniscono funzionalità applicative critiche tramite chiamate API. Pertanto, è fondamentale che il ciclo di sviluppo preveda test automatici in grado di verificare il corretto funzionamento dell'interazione tra le funzioni e i servizi.
Se non crei test basati sul cloud, potresti riscontrare problemi dovuti alle differenze tra l'ambiente locale e quello implementato. Il processo di integrazione continua dovrebbe eseguire test su un insieme di risorse con provisioning nel cloud prima di promuovere il codice nell'ambiente di implementazione successivo, come quello di controllo qualità (QA), staging o produzione.
Continua a leggere questa breve guida per scoprire le strategie di test per le applicazioni serverless oppure visita il [repository Serverless Test Samples](https://github.com/aws-samples/serverless-test-samples) per approfondire esempi pratici, specifici per il linguaggio e il runtime selezionati.
![\[illustration showing the relationship between types of tests\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-type-illustration2.png)
Per i test in ambito serverless, è necessario scrivere *test unitari*, *test di integrazione* e *test end-to-end*.
+ **Test unitari**: vengono eseguiti su un blocco di codice isolato. Ad esempio, possono essere utilizzati per verificare la logica aziendale per calcolare le spese di spedizione in base a un articolo e a una destinazione specifici.
+ **Test di integrazione**: coinvolgono due o più componenti o servizi che interagiscono, in genere in un ambiente cloud. Ad esempio, possono essere utilizzati per verificare che una funzione elabori gli eventi di una coda.
+ **Test end-to-end**: verificano il comportamento di un'intera applicazione. Ad esempio, possono essere utilizzati per verificare che l'infrastruttura sia configurata correttamente e che gli eventi fluiscano tra i servizi come previsto per registrare l'ordine di un cliente.
## Test delle applicazioni serverless
Generalmente, utilizzerai una combinazione di approcci per testare il codice dell'applicazione serverless, inclusi test nel cloud, test con mock e occasionalmente test con emulatori.
### Test nel cloud
I test nel cloud sono utili per tutte le fasi di test, inclusi i test unitari, i test di integrazione e i test end-to-end. Esegui test su codice implementato nel cloud e interagisci con servizi basati su cloud. Questo approccio fornisce la misura **più accurata** della qualità del codice.
Un modo conveniente per eseguire il debug di una funzione Lambda nel cloud è con un evento di test nella console. Un *evento di test* è un input JSON per la funzione. Se la funzione non richiede input, l'evento può essere un documento JSON `({})` vuoto. La console fornisce eventi di esempio per una varietà di integrazioni di servizi. Dopo aver creato un evento nella console, puoi condividerlo con il tuo team per rendere i test più semplici e coerenti.
**Nota**
[Testare una funzione nella console](testing-functions.md) è un modo rapido per iniziare, ma l'automazione dei cicli di test garantisce la qualità delle applicazioni e la velocità di sviluppo.
### Strumenti di test
Esistono strumenti e tecniche per accelerare i cicli di feedback sullo sviluppo. Ad esempio, [AWS SAM Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/accelerate.html) e [AWS CDK watch mode](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch) riducono entrambi il tempo necessario per aggiornare gli ambienti cloud.
[Moto](https://pypi.org/project/moto/) è una libreria Python per simulare servizi e risorse AWS, in modo da poter testare le funzioni con poche o nessuna modifica utilizzando decoratori per intercettare e simulare le risposte.
La funzione di convalida di [Powertools per AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda-python/latest/utilities/validation/) fornisce decoratori che consentono di convalidare gli eventi di input e le risposte di output dalle funzioni Python.
Per ulteriori informazioni, leggi il post del blog [Test unitari di Lambda con Python e servizi AWS fittizi](https://aws.amazon.com/blogs/devops/unit-testing-aws-lambda-with-python-and-mock-aws-services/).
Per ridurre la latenza associata alle iterazioni di implementazione del cloud, consulta le sezioni [AWS Serverless Application Model (AWS SAM) Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-sync.html) e [AWS Cloud Development Kit (AWS CDK) watch mode](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch). Questi strumenti monitorano l'infrastruttura e il codice per rilevare eventuali modifiche. Reagiscono a questi cambiamenti creando e implementando automaticamente aggiornamenti incrementali nell'ambiente cloud.
Alcuni esempi che utilizzano questi strumenti sono disponibili nel repository di codice [Python Test Samples](https://github.com/aws-samples/serverless-test-samples/tree/main/python-test-samples).
# Strumentazione del codice Python in AWS Lambda
Lambda si integra con AWS X-Ray per aiutarti a tracciare, eseguire il debug e ottimizzare le applicazioni Lambda. Puoi utilizzare X-Ray per tracciare una richiesta mentre attraversa le risorse nell'applicazione, che possono includere funzioni Lambda e altri servizi AWS .
Per inviare dati di tracciamento a X-Ray, è possibile utilizzare una delle tre librerie SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel): una distribuzione sicura, pronta per la produzione e supportata dell'SDK (). AWS OpenTelemetry OTel
+ [SDK AWS X-Ray per Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html): un SDK per generare e inviare i dati di traccia su X-Ray.
+ [Powertools for AWS Lambda (Python](https://docs.aws.amazon.com/powertools/python/latest/)): un toolkit per sviluppatori per implementare le migliori pratiche Serverless e aumentare la velocità degli sviluppatori.
Ciascuno di essi SDKs offre modi per inviare i dati di telemetria al servizio X-Ray. Puoi quindi utilizzare X-Ray per visualizzare, filtrare e analizzare le metriche delle prestazioni dell'applicazione per identificare i problemi e le opportunità di ottimizzazione.
**Importante**
X-Ray e Powertools per AWS Lambda SDKs fanno parte di una soluzione di strumentazione strettamente integrata offerta da. AWS I livelli Lambda ADOT fanno parte di uno standard di settore per la strumentazione di tracciamento che in generale raccoglie più dati, ma potrebbero non essere adatti a tutti i casi d'uso. È possibile implementare il end-to-end tracciamento in X-Ray utilizzando entrambe le soluzioni. Per saperne di più sulla scelta tra di esse, consulta [Scelta tra AWS Distro for Open Telemetry](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) e X-Ray. SDKs
**Topics**
+ [Usare Powertools per AWS Lambda (Python) AWS SAM e per tracciare](#python-tracing-sam)
+ [Usare Powertools per AWS Lambda (Python) e AWS CDK per tracciare](#python-logging-cdk)
+ [Utilizzo di ADOT per strumentare le funzioni Python](#python-adot)
+ [Utilizzo dell'SDK X-Ray per strumentare le funzioni Python](#python-xray-sdk)
+ [Attivazione del tracciamento con la console Lambda](#python-tracing-console)
+ [Attivazione del tracciamento con l'API Lambda](#python-tracing-api)
+ [Attivazione del tracciamento con CloudFormation](#python-tracing-cloudformation)
+ [Interpretazione di una traccia X-Ray](#python-tracing-interpretation)
+ [Memorizzazione delle dipendenze di runtime in un livello (SDK X-Ray)](#python-tracing-layers)
## Usare Powertools per AWS Lambda (Python) AWS SAM e per tracciare
Segui i passaggi seguenti per scaricare, creare e distribuire un'applicazione Hello World Python di esempio con i moduli [Powertools for AWS Lambda (Python) integrati](https://docs.powertools.aws.dev/lambda-python) utilizzando il. AWS SAM Questa applicazione implementa un backend dell'API di base e utilizza Powertools per l'emissione di log, parametri e tracce. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando invii una richiesta GET all'endpoint API Gateway, la funzione Lambda richiama, invia log e metriche utilizzando Embedded Metric Format a e invia tracce a. CloudWatch AWS X-Ray La funzione restituisce un messaggio hello world.
**Prerequisiti**
Per completare le fasi riportate in questa sezione, è necessario:
+ Python 3.11
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versione 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) o successiva. Se disponi di una versione precedente della AWS SAM CLI, consulta [Aggiornamento](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade) della CLI. AWS SAM
**Implementa un'applicazione di esempio AWS SAM**
1. Inizializza l'applicazione utilizzando il modello Python Hello World.
```
sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.11 --no-tracing
```
1. Costruisci l'app.
```
cd sam-app && sam build
```
1. Distribuire l'app.
```
sam deploy --guided
```
1. Seguire le istruzioni visualizzate sullo schermo. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi `Enter`.
**Nota**
Perché **HelloWorldFunction potrebbe non avere un'autorizzazione definita, va bene?** , assicurati di entrare`y`.
1. Ottieni l'URL dell'applicazione implementata:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Richiama l'endpoint dell'API:
```
curl -X GET
```
In caso di esito positivo, vedrai questa risposta:
```
{"message":"hello world"}
```
1. Per ottenere le tracce per la funzione, esegui [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
L'output della traccia ha il seguente aspetto:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
sam delete
```
X-Ray non traccia tutte le richieste nell'applicazione. X-Ray applica un algoritmo di campionamento per garantire che il tracciamento avvenga in modo efficiente, continuando allo stesso tempo a fornire un campione rappresentativo di tutte le richieste. La frequenza di campionamento è di una richiesta al secondo e del 5% delle altre richieste. Non è possibile configurare la frequenza di campionamento di X-Ray per le funzioni.
## Usare Powertools per AWS Lambda (Python) e AWS CDK per tracciare
Segui i passaggi seguenti per scaricare, creare e distribuire un'applicazione Hello World Python di esempio con i moduli [Powertools for AWS Lambda (Python) integrati](https://docs.powertools.aws.dev/lambda-python) utilizzando il. AWS CDK Questa applicazione implementa un backend dell'API di base e utilizza Powertools per l'emissione di log, parametri e tracce. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando invii una richiesta GET all'endpoint API Gateway, la funzione Lambda richiama, invia log e metriche utilizzando Embedded Metric Format a e invia tracce a. CloudWatch AWS X-Ray La funzione restituisce un messaggio hello world.
**Prerequisiti**
Per completare le fasi riportate in questa sezione, è necessario:
+ Python 3.11
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK versione 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI versione 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) o successiva. Se disponi di una versione precedente della AWS SAM CLI, consulta [Aggiornamento](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade) della CLI. AWS SAM
**Implementa un'applicazione di esempio AWS CDK**
1. Crea una directory di progetto per la nuova applicazione.
```
mkdir hello-world
cd hello-world
```
1. Inizializza l'app.
```
cdk init app --language python
```
1. Installa le dipendenze di Python.
```
pip install -r requirements.txt
```
1. Crea una directory **lambda\$1function** nella cartella root.
```
mkdir lambda_function
cd lambda_function
```
1. Crea un file **app.py** e aggiungi il seguente codice al file. Questo è il codice per la funzione Lambda.
```
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit
app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")
@app.get("/hello")
@tracer.capture_method
def hello():
# adding custom metrics
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/metrics/
metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)
# structured log
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/logger/
logger.info("Hello world API - HTTP 200")
return {"message": "hello world"}
# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context)
```
1. Apri la directory **hello\$1world**. Dovrebbe essere visualizzato un file denominato **hello\$1world\$1stack.py**.
```
cd ..
cd hello_world
```
1. Apri **hello\$1world\$1stack.py** e aggiungi il seguente codice al file. Contiene il [Lambda Constructor](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), che crea la funzione Lambda, configura le variabili di ambiente per Powertools e imposta la conservazione dei log su una settimana, e il [costruttore ApiGatewayv 1, che crea l'API REST](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html).
```
from aws_cdk import (
Stack,
aws_apigateway as apigwv1,
aws_lambda as lambda_,
CfnOutput,
Duration
)
from constructs import Construct
class HelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Powertools Lambda Layer
powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
self,
id="lambda-powertools",
# At the moment we wrote this example, the aws_lambda_python_alpha CDK constructor is in Alpha, o we use layer to make the example simpler
# See https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_lambda_python_alpha/README.html
# Check all Powertools layers versions here: https://docs.powertools.aws.dev/lambda-python/latest/#lambda-layer
layer_version_arn=f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPythonV2:21"
)
function = lambda_.Function(self,
'sample-app-lambda',
runtime=lambda_.Runtime.PYTHON_3_11,
layers=[powertools_layer],
code = lambda_.Code.from_asset("./lambda_function/"),
handler="app.lambda_handler",
memory_size=128,
timeout=Duration.seconds(3),
architecture=lambda_.Architecture.X86_64,
environment={
"POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
"POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
"LOG_LEVEL": "INFO"
}
)
apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))
hello_api = apigw.root.add_resource("hello")
hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))
CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")
```
1. Distribuisci l'applicazione.
```
cd ..
cdk deploy
```
1. Ottieni l'URL dell'applicazione implementata:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text
```
1. Richiama l'endpoint dell'API:
```
curl -X GET
```
In caso di esito positivo, vedrai questa risposta:
```
{"message":"hello world"}
```
1. Per ottenere le tracce per la funzione, esegui [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
L'output delle tracce ha la struttura seguente:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
cdk destroy
```
## Utilizzo di ADOT per strumentare le funzioni Python
ADOT fornisce layer [Lambda](chapter-layers.md) completamente gestiti che racchiudono tutto il necessario per raccogliere dati di telemetria utilizzando l'SDK. OTel Usando questo livello, è possibile strumentare le funzioni Lambda senza dover modificare alcun codice funzione. Puoi anche configurare il tuo layer per eseguire l'inizializzazione personalizzata di. OTel Per ulteriori informazioni, consulta la sezione relativa alla [configurazione personalizzata per ADOT Collector su Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) nella documentazione di ADOT.
Per i runtime Python, è possibile aggiungere il **livello Lambda gestito da AWS per ADOT Python** per la strumentazione automatica delle funzioni. Questo livello funziona sia per architetture arm64 che x86\$164. Per istruzioni dettagliate su come aggiungere questo layer, consulta [AWS Distro for OpenTelemetry Lambda Support for](https://aws-otel.github.io/docs/getting-started/lambda/lambda-python) Python nella documentazione ADOT.
## Utilizzo dell'SDK X-Ray per strumentare le funzioni Python
Per registrare i dettagli sulle chiamate effettuate dalla funzione Lambda ad altre risorse nell'applicazione, è anche possibile utilizzare il SDK AWS X-Ray per Python. Per ottenere l'SDK, aggiungere il pacchetto `aws-xray-sdk` alle dipendenze dell'applicazione.
**Example [requirements.txt](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/requirements.txt)**
```
jsonpickle==1.3
aws-xray-sdk==2.4.3
```
Nel codice della funzione, puoi strumentare i client AWS SDK applicando una patch alla libreria con il modulo. `boto3` `aws_xray_sdk.core`
**Example [funzione — Tracciamento di un client SDK AWS](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/lambda_function.py)**
```
import boto3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
logger = logging.getLogger()
logger.setLevel(logging.INFO)
patch_all()
client = boto3.client('lambda')
client.get_account_settings()
def lambda_handler(event, context):
logger.info('## ENVIRONMENT VARIABLES\r' + jsonpickle.encode(dict(**os.environ)))
...
```
Dopo aver aggiunto le dipendenze corrette e aver apportato le modifiche necessarie al codice, attivare il tracciamento nella configurazione della funzione tramite la console Lambda o l'API.
## Attivazione del tracciamento con la console Lambda
Per attivare il tracciamento attivo sulla funzione Lambda con la console, attenersi alla seguente procedura:
**Per attivare il tracciamento attivo**
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 **Monitoring and operations tools** (Strumenti di monitoraggio e operazioni).
1. In **Strumenti di monitoraggio aggiuntivi** scegli **Modifica**.
1. In **CloudWatch Application Signals e AWS X-Ray**, scegli **Enable** for **Lambda service trace**.
1. Scegli **Save** (Salva).
## Attivazione del tracciamento con l'API Lambda
Configura il tracciamento sulla tua funzione Lambda con AWS o SDK, utilizza AWS CLI 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)
**Il AWS CLI comando di esempio seguente abilita il tracciamento attivo su una funzione denominata my-function.**
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
La modalità di tracciamento fa parte della configurazione specifica della versione quando si pubblica una versione della funzione. Non è possibile modificare la modalità di tracciamento in una versione pubblicata.
## Attivazione del tracciamento con CloudFormation
Per attivare il tracciamento su una `AWS::Lambda::Function` risorsa in un CloudFormation modello, utilizzate la proprietà. `TracingConfig`
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Configurazione del tracciamento**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Per una `AWS::Serverless::Function` risorsa AWS Serverless Application Model (AWS SAM), utilizzate la `Tracing` proprietà.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Configurazione del tracciamento**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Interpretazione di una traccia X-Ray
La funzione ha bisogno dell'autorizzazione per caricare i dati di traccia su X-Ray. Quando si attiva il tracciamento nella console Lambda, Lambda aggiunge le autorizzazioni necessarie al [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione. Altrimenti, aggiungete la [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)politica al ruolo di esecuzione.
Dopo aver configurato il tracciamento attivo, è possibile osservare richieste specifiche tramite l'applicazione. Il [grafico dei servizi X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) mostra informazioni sull'applicazione e tutti i suoi componenti. Il seguente esempio mostra un'applicazione con due funzioni. La funzione principale elabora gli eventi e talvolta restituisce errori. La seconda funzione in alto elabora gli errori che compaiono nel gruppo di log della prima e utilizza l' AWS SDK per chiamare X-Ray, Amazon Simple Storage Service (Amazon S3) e Amazon Logs. CloudWatch
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
X-Ray non traccia tutte le richieste nell'applicazione. X-Ray applica un algoritmo di campionamento per garantire che il tracciamento avvenga in modo efficiente, continuando allo stesso tempo a fornire un campione rappresentativo di tutte le richieste. La frequenza di campionamento è di una richiesta al secondo e del 5% delle altre richieste. Non è possibile configurare la frequenza di campionamento di X-Ray per le funzioni.
In X-Ray, una *traccia* registra informazioni su una richiesta elaborata da uno o più *servizi*. Lambda registra 2 segmenti per traccia, che creano due nodi sul grafico del servizio. L'immagine seguente evidenzia questi due nodi:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/xray-servicemap-function.png)
Il primo nodo a sinistra rappresenta il servizio Lambda che riceve la richiesta di chiamata. Il secondo nodo rappresenta la specifica funzione Lambda. L'esempio seguente mostra una traccia con questi 2 segmenti. Entrambi sono nominati **my-function**, ma uno ha l'origine `AWS::Lambda` e l'altro ha l'origine `AWS::Lambda::Function`. Se il segmento `AWS::Lambda` mostra un errore, il servizio Lambda ha avuto un problema. Se il `AWS::Lambda::Function` segmento mostra un errore, la funzione ha avuto un problema.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Questo esempio espande il segmento `AWS::Lambda::Function` per visualizzare i relativi tre sottosegmenti.
**Nota**
AWS sta attualmente implementando modifiche al servizio Lambda. A causa di queste modifiche, potresti notare piccole differenze tra la struttura e il contenuto dei messaggi di log di sistema e dei segmenti di traccia emessi da diverse funzioni Lambda nel tuo Account AWS.
La traccia di esempio mostrata qui illustra il segmento di funzione vecchio stile. Le differenze tra i segmenti vecchio e nuovo stile sono descritte nei paragrafi seguenti.
Queste modifiche verranno implementate nelle prossime settimane e tutte le funzioni, Regioni AWS ad eccezione della Cina e delle GovCloud regioni, passeranno all'utilizzo dei messaggi di registro e dei segmenti di traccia di nuovo formato.
Il segmento di funzioni vecchio stile contiene i seguenti sottosegmenti:
+ **Inizializzazione** – Rappresenta il tempo trascorso a caricare la funzione e ad eseguire il [codice di inizializzazione](foundation-progmodel.md). Questo sottosegmento viene visualizzato solo per il primo evento che viene elaborato da ogni istanza della funzione.
+ **Chiamata**: rappresenta il tempo impiegato per eseguire il codice del gestore.
+ **Overhead**: rappresenta il tempo impiegato dal runtime Lambda per prepararsi a gestire l'evento successivo.
Il segmento di funzione di nuovo stile non contiene un sottosegmento `Invocation`. I sottosegmenti dei clienti sono invece collegati direttamente al segmento di funzioni. Per ulteriori informazioni sulla struttura dei segmenti di funzioni vecchio e nuovo stile, consulta [Informazioni sui monitoraggi di X-Ray](services-xray.md#services-xray-traces).
È inoltre possibile strumentare i client HTTP, registrare query SQL e creare segmenti secondari personalizzati con annotazioni e metadati. Per ulteriori informazioni, consulta [SDK AWS X-Ray per Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) nella *Guida per gli sviluppatori di AWS X-Ray *.
**Prezzi**
Puoi utilizzare il tracciamento X-Ray gratuitamente ogni mese fino a un determinato limite come parte del AWS piano gratuito. Oltre la soglia, X-Ray addebita lo storage di traccia e il recupero. Per ulteriori informazioni, consultare [Prezzi di AWS X-Ray](https://aws.amazon.com/xray/pricing/).
## Memorizzazione delle dipendenze di runtime in un livello (SDK X-Ray)
Se utilizzi X-Ray SDK per strumentare i client AWS SDK del codice della funzione, il pacchetto di distribuzione può diventare piuttosto grande. Per evitare di caricare dipendenze di runtime ogni volta che si aggiorna il codice della funzione, includere l'SDK X-Ray in un [livello Lambda](chapter-layers.md).
L'esempio seguente mostra una risorsa `AWS::Serverless::LayerVersion` che memorizza SDK AWS X-Ray per Python.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/template.yml) – Livello delle dipendenze**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-python-lib
Description: Dependencies for the blank-python sample app.
ContentUri: package/.
CompatibleRuntimes:
- python3.11
```
Con questa configurazione, si aggiorna il livello della libreria solo se si modificano le dipendenze di runtime. Poiché il pacchetto di implementazione della funzione contiene solo il codice, questo può contribuire a ridurre i tempi di caricamento.
La creazione di un layer per le dipendenze richiede modifiche alla compilazione per generare l'archivio dei layer prima della distribuzione. Per un esempio funzionante, vedere l'applicazione di esempio [blank-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python) .