Définition du gestionnaire de fonction Lambda en Python

Le gestionnaire de fonction Lambda est la méthode dans votre code de fonction qui traite les événements. Lorsque votre fonction est invoquée, Lambda exécute la méthode du gestionnaire. Votre fonction s’exécute jusqu’à ce que le gestionnaire renvoie une réponse, se ferme ou expire.

Cette page explique comment utiliser les gestionnaires de fonctions Lambda en Python, notamment les conventions de dénomination, les signatures de gestionnaires valides et les meilleures pratiques en matière de code. Cette page inclut également un exemple de fonction Lambda Python qui prend des informations sur une commande, produit un reçu sous forme de fichier texte et place ce fichier dans un bucket Amazon Simple Storage Service (Amazon S3).

Exemple de code de fonction Lambda en Python

L'exemple de code de fonction Lambda Python suivant prend en compte les informations relatives à une commande, produit un reçu de fichier texte et place ce fichier dans un compartiment Amazon S3 :

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

Ce fichier comprend les sections suivantes :

Convention de nommage du gestionnaire

Le nom du gestionnaire de fonctions défini au moment de la création d'une fonction Lambda est dérivé de :

Dans l'exemple ci-dessus, si le fichier est nommélambda_function.py, le gestionnaire sera spécifié commelambda_function.lambda_handler. Il s'agit du nom de gestionnaire par défaut attribué aux fonctions que vous créez à l'aide de la console Lambda.

Si vous créez une fonction dans la console en utilisant un nom de fichier ou un nom de gestionnaire de fonction différent, vous devez modifier le nom du gestionnaire par défaut.

Utilisation de l'objet d'événement Lambda

Lorsque Lambda appelle votre fonction, il transmet un argument d'objet d'événement au gestionnaire de fonctions. Les objets JSON constituent le format d'événement le plus courant pour les fonctions Lambda. Dans l'exemple de code de la section précédente, la fonction attend une entrée au format suivant :

{
    "Order_id": "12345",
    "Amount": 199.99,
    "Item": "Wireless Headphones"
}

Si votre fonction est invoquée par un autre Service AWS, l'événement d'entrée est également un objet JSON. Le format exact de l'objet d'événement dépend du service qui appelle votre fonction. Pour connaître le format de l'événement pour un service en particulier, reportez-vous à la page appropriée du Invoquer Lambda avec des événements provenant d'autres services AWS chapitre.

Si l'événement d'entrée prend la forme d'un objet JSON, le moteur d'exécution Lambda convertit l'objet en dictionnaire Python. Pour attribuer des valeurs dans le JSON d'entrée aux variables de votre code, utilisez les méthodes standard du dictionnaire Python, comme illustré dans l'exemple de code.

Vous pouvez également transmettre des données à votre fonction sous forme de tableau JSON ou de n'importe quel autre type de données JSON valide. Le tableau suivant définit la manière dont le moteur d'exécution Python convertit ces types JSON.

Accès et utilisation de l’objet de contexte Lambda

L'objet de contexte Lambda contient des informations sur l'environnement d'appel et d'exécution des fonctions. Lambda transmet automatiquement l'objet de contexte à votre fonction lorsqu'il est invoqué. Vous pouvez utiliser l'objet de contexte pour générer des informations sur l'invocation de votre fonction à des fins de surveillance.

L'objet de contexte est une classe Python définie dans le client d'interface d'exécution Lambda. Pour renvoyer la valeur de l'une des propriétés de l'objet de contexte, utilisez la méthode correspondante sur l'objet de contexte. Par exemple, l'extrait de code suivant attribue la valeur de la aws_request_id propriété (l'identifiant de la demande d'appel) à une variable nommée. request

request = context.aws_request_id

Pour en savoir plus sur l'utilisation de l'objet de contexte Lambda et pour consulter la liste complète des méthodes et propriétés disponibles, consultez. Utilisation de l’objet de contexte Lambda pour récupérer les informations de la fonction Python

Signatures de gestionnaire valides pour les gestionnaires Python

Lorsque vous définissez votre fonction de gestionnaire en Python, la fonction doit prendre deux arguments. Le premier de ces arguments est l'objet d'événement Lambda et le second est l'objet de contexte Lambda. Par convention, ces arguments d'entrée sont généralement nommés event etcontext, mais vous pouvez leur donner le nom que vous souhaitez. Si vous déclarez votre fonction de gestionnaire avec un seul argument d'entrée, Lambda générera une erreur lorsqu'il tentera d'exécuter votre fonction. La méthode la plus courante pour déclarer une fonction de gestionnaire en Python est la suivante :

def lambda_handler(event, context):

Vous pouvez également utiliser des indications de type Python dans la déclaration de votre fonction, comme illustré dans l'exemple suivant :

from typing import Dict, Any
      
def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:

Pour utiliser une AWS saisie spécifique pour les événements générés par d'autres Services AWS et pour l'objet de contexte, ajoutez le aws-lambda-typing package au package de déploiement de votre fonction. Vous pouvez installer cette bibliothèque dans votre environnement de développement en exécutantpip install aws-lambda-typing. L'extrait de code suivant montre comment utiliser les indices de type AWS spécifiques. Dans cet exemple, l'événement attendu est un événement 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]:

Vous ne pouvez pas utiliser le type de async fonction Python pour votre fonction de gestionnaire.

Renvoi d’une valeur

Un gestionnaire peut éventuellement renvoyer une valeur, qui doit être sérialisable au format JSON. Les types de retour les plus courants incluent dict list strint,,float, etbool.

Ce qu’il advient de la valeur renvoyée dépend du type d’invocation et du service qui a invoqué la fonction. Par exemple :

Dans l'exemple de code, le gestionnaire renvoie le dictionnaire Python suivant :

{
  "statusCode": 200,
  "message": "Receipt processed successfully"
}

Le moteur d'exécution Lambda sérialise ce dictionnaire et le renvoie au client qui a invoqué la fonction sous forme de chaîne JSON.

En utilisant le AWS SDK pour Python (Boto3) dans votre gestionnaire

Vous utiliserez souvent les fonctions Lambda pour interagir avec d'autres ressources Services AWS . Le moyen le plus simple d'interagir avec ces ressources est d'utiliser le AWS SDK pour Python (Boto3). Tous les environnements d'exécution Lambda Python pris en charge incluent une version du SDK pour Python. Toutefois, nous vous recommandons vivement d'inclure le SDK dans le package de déploiement de votre fonction si votre code doit l'utiliser. L'inclusion du SDK dans votre package de déploiement vous permet de contrôler totalement vos dépendances et de réduire le risque de problèmes de désalignement des versions avec les autres bibliothèques. Pour en savoir plus, consultez Dépendances d’exécution dans Python et Rétrocompatibilité.

Pour utiliser le SDK pour Python dans votre fonction Lambda, ajoutez l'instruction suivante au bloc d'importation au début du code de votre fonction :

import boto3

Utilisez la pip install commande pour ajouter la boto3 bibliothèque au package de déploiement de votre fonction. Pour obtenir des instructions détaillées sur la façon d'ajouter des dépendances à un package de déploiement .zip, consultezCréation d’un package de déploiement .zip avec dépendances. Pour en savoir plus sur l'ajout de dépendances aux fonctions Lambda déployées sous forme d'images de conteneur, consultez Création d’une image à partir d’une image de base ou. Création d’une image à partir d’une image de base alternative

Lorsque vous l'utilisez boto3 dans votre code, vous n'avez pas besoin de fournir d'informations d'identification pour initialiser un client. Par exemple, dans l'exemple de code, nous utilisons la ligne de code suivante pour initialiser un client Amazon S3 :

# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')

Avec Python, Lambda crée automatiquement des variables d'environnement avec des informations d'identification. Le boto3 SDK vérifie la présence de ces informations d'identification dans les variables d'environnement de votre fonction lors de l'initialisation.

Accès aux variables d’environnement

Dans le code de votre gestionnaire, vous pouvez référencer des variables d'environnement à l'aide de la os.environ.get méthode. Dans l'exemple de code, nous référençons la variable d'RECEIPT_BUCKETenvironnement définie à l'aide de la ligne de code suivante :

# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')

N'oubliez pas d'inclure une import os instruction dans le bloc d'importation au début de votre code.

Pratiques exemplaires en matière de code pour les fonctions Lambda Python

Respectez les directives de la liste suivante pour utiliser les pratiques exemplaires de codage lors de la création de vos fonctions Lambda :