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