Utilisation de couches pour les fonctions Lambda Python - AWS Lambda

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation de couches pour les fonctions Lambda Python

Utilisez les couches Lambda pour empaqueter le code et les dépendances que vous souhaitez réutiliser dans plusieurs fonctions. Les couches contiennent généralement des dépendances de bibliothèque, une exécution personnalisée, ou des fichiers de configuration. La création d’une couche implique trois étapes générales :

  1. Empaquetez le contenu de votre couche. Cela signifie créer une archive de fichiers .zip contenant les dépendances que vous souhaitez utiliser dans vos fonctions.

  2. Créez la couche dans Lambda.

  3. Ajoutez la couche à vos fonctions.

Cette rubrique explique comment créer une couche Python et l'associer à une fonction Lambda.

Empaqueter le contenu de votre couche

Pour créer une couche, regroupez vos packages dans une archive de fichier .zip répondant aux exigences suivantes :

  • Construisez la couche en utilisant la même version de Python que celle que vous prévoyez d'utiliser pour la fonction Lambda. Par exemple, si vous créez votre couche à l'aide de Python 3.13, utilisez le runtime Python 3.13 pour votre fonction.

  • Votre fichier .zip doit inclure un python répertoire au niveau racine.

  • Les packages de votre couche doivent être compatibles avec Linux. Les fonctions Lambda s'exécutent sur Amazon Linux.

Vous pouvez créer des couches contenant des bibliothèques Python tierces installées avec pip (telles que requests oupandas) ou vos propres modules et packages Python.

Pour créer une couche à l'aide de packages pip
  1. Choisissez l'une des méthodes suivantes pour installer les pip packages dans le répertoire de premier niveau requis (python/) :

    pip install

    Pour les packages Python purs (comme les requêtes ou boto3) :

    pip install requests -t python/

    Certains packages Python, tels que NumPy Pandas, incluent des composants C compilés. Si vous créez une couche avec ces packages sous macOS ou Windows, vous devrez peut-être utiliser cette commande pour installer une roue compatible avec Linux :

    pip install numpy --platform manylinux2014_x86_64 --only-binary=:all: -t python/

    Pour plus d'informations sur l'utilisation de packages Python contenant des composants compilés, consultezCréation de packages de déploiement .zip avec des bibliothèques natives.

    requirements.txt

    L'utilisation d'un requirements.txt fichier vous permet de gérer les versions des packages et de garantir des installations cohérentes.

    Exemple requirements.txt
    requests==2.31.0 boto3==1.37.34 numpy==1.26.4

    Si votre requirements.txt fichier contient uniquement des packages Python purs (comme des requêtes ou boto3) :

    pip install -r requirements.txt -t python/

    Certains packages Python, tels que NumPy Pandas, incluent des composants C compilés. Si vous créez une couche avec ces packages sous macOS ou Windows, vous devrez peut-être utiliser cette commande pour installer une roue compatible avec Linux :

    pip install -r requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/

    Pour plus d'informations sur l'utilisation de packages Python contenant des composants compilés, consultezCréation de packages de déploiement .zip avec des bibliothèques natives.

  2. Compressez le contenu du python répertoire.

    zip -r layer.zip python/

    La structure de répertoire de votre fichier .zip doit ressembler à ceci :

    python/              # Required top-level directory
    └── requests/
    └── boto3/
    └── numpy/
    └── (dependencies of the other packages)
    Note

    Si vous utilisez un environnement virtuel Python (venv) pour installer des packages, la structure de votre répertoire sera différente (par exemple,python/lib/python3.x/site-packages). Tant que votre fichier .zip inclut le python répertoire au niveau racine, Lambda peut localiser et importer vos packages.

Pour créer une couche à l'aide de votre propre code
  1. Créez le répertoire de premier niveau requis pour votre couche :

    mkdir python
  2. Créez vos modules Python dans le python répertoire. L'exemple de module suivant valide les commandes en confirmant qu'elles contiennent les informations requises.

    Exemple module personnalisé : 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) }
  3. Compressez le contenu du python répertoire.

    zip -r layer.zip python/

    La structure de répertoire de votre fichier .zip doit ressembler à ceci :

    python/     # Required top-level directory
    └── validator.py
  4. Dans votre fonction, importez et utilisez les modules comme vous le feriez avec n'importe quel package Python. Exemple :

    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' })

    Vous pouvez utiliser l'événement de test suivant pour appeler la fonction :

    { "body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}" }

    Réponse attendue :

    { "statusCode": 200, "body": "{\"message\": \"Order validated successfully\", \"order\": {\"product_id\": \"ABC123\", \"quantity\": 2, \"shipping_priority\": \"express\"}}" }

Création de la couche dans Lambda

Vous pouvez publier votre couche à l'aide de la console Lambda AWS CLI ou de la console Lambda.

AWS CLI

Exécutez la publish-layer-version AWS CLI commande pour créer la couche Lambda :

aws lambda publish-layer-version \ --layer-name my-layer \ --zip-file fileb://layer.zip \ --compatible-runtimes python3.13

Le paramètre d'exécution compatible est facultatif. Lorsqu'il est spécifié, Lambda utilise ce paramètre pour filtrer les couches dans la console Lambda.

Console
Pour créer une couche (console)
  1. Ouvrez la page Couches de la console Lambda.

  2. Sélectionnez Créer un calque.

  3. Choisissez Charger un fichier .zip, puis chargez l'archive .zip que vous avez créée précédemment.

  4. (Facultatif) Pour les environnements d'exécution compatibles, choisissez le moteur d'exécution Python qui correspond à la version de Python que vous avez utilisée pour créer votre couche.

  5. Choisissez Créer.

Ajoutez la couche à votre fonction

AWS CLI

Pour associer la couche à votre fonction, exécutez la update-function-configuration AWS CLI commande. Pour le --layers paramètre, utilisez l'ARN de la couche. L'ARN doit spécifier la version (par exemple,arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1). Pour de plus amples informations, veuillez consulter Couches et versions de couches.

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"
Console
Pour ajouter une couche à une fonction
  1. Ouvrez la page Functions (Fonctions) de la console Lambda.

  2. Choisissez la fonction.

  3. Faites défiler jusqu’à la section Couches, puis choisissez Ajouter une couche.

  4. Sous Choisir une couche, sélectionnez Couches personnalisées, puis choisissez votre couche.

    Note

    Si vous n'avez pas ajouté d'environnement d'exécution compatible lors de la création de la couche, celle-ci ne sera pas répertoriée ici. Vous pouvez plutôt spécifier l'ARN de la couche.

  5. Choisissez Ajouter.

Exemple d'application

Pour d'autres exemples d'utilisation des couches Lambda, consultez l'exemple d'application layer-python dans le référentiel du AWS Lambda Developer Guide. GitHub Cette application inclut deux couches contenant des bibliothèques Python. Après avoir créé les couches, vous pouvez déployer et invoquer les fonctions correspondantes pour vérifier que les couches fonctionnent comme prévu.