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
<a name="python-layers"></a>

Utilisez les [couches Lambda](chapter-layers.md) 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](runtimes-custom.md), 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.

1. Créez la couche dans Lambda.

1. Ajoutez la couche à vos fonctions.

**Topics**
+ [

## Empaqueter le contenu de votre couche
](#python-layers-package)
+ [

## Créer la couche dans Lambda
](#publishing-layer)
+ [

## Ajouter la couche à votre fonction
](#python-layer-adding)
+ [

## Exemple d’application
](#python-layer-sample-app)

## Empaqueter le contenu de votre couche
<a name="python-layers-package"></a>

Pour créer une couche, regroupez vos packages dans une archive (fichier .zip) répondant aux exigences suivantes :
+ Créez la couche à l’aide de 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.14, utilisez le runtime Python 3.14 pour votre fonction.
+ Votre fichier .zip doit inclure un répertoire `python` 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` (comme `requests` ou `pandas`) ou vos propres modules et packages Python.

### Dépendances tierces
<a name="python-layers-third-party-dependencies"></a>

**Créer une couche à l’aide de packages pip**

1. Choisissez l’une des méthodes suivantes pour installer les packages `pip` dans le répertoire de niveau supérieur requis (`python/`) :

------
#### [ pip install ]

   Pour les packages Python purs (comme requests 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 un fichier wheel compatible avec Linux :

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

   Pour plus d’informations sur l’utilisation des packages Python contenant des composants compilés, consultez [Création de packages de déploiement .zip avec des bibliothèques natives](python-package.md#python-package-native-libraries).

------
#### [ requirements.txt ]

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

**Example requirements.txt**  

   ```
   requests==2.31.0
   boto3==1.37.34
   numpy==1.26.4
   ```

   Si votre fichier `requirements.txt` contient uniquement des packages Python purs (comme requests 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 un fichier wheel compatible avec Linux :

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

   Pour plus d’informations sur l’utilisation des packages Python contenant des composants compilés, consultez [Création de packages de déploiement .zip avec des bibliothèques natives](python-package.md#python-package-native-libraries).

------

1. Compressez le contenu du répertoire `python` dans un fichier .zip.

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip python/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\python -DestinationPath .\layer.zip
   ```

------

   La structure de répertoire de votre fichier .zip devrait se présenter comme suit :

   ```
   python/              # Required top-level directory
   └── requests/
   └── boto3/
   └── numpy/
   └── (dependencies of the other packages)
   ```
**Note**  
Si vous utilisez un environnement virtuel Python (venv) pour installer les 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 répertoire `python` au niveau racine, Lambda peut localiser et importer vos packages.

### Modules Python personnalisés
<a name="custom-python-modules"></a>

**Créer une couche à l’aide de votre propre code**

1. Créez le répertoire de niveau supérieur requis pour votre couche :

   ```
   mkdir python
   ```

1. Créez vos modules Python dans le répertoire `python`. L’exemple de module suivant valide les commandes en confirmant qu’elles contiennent les informations requises.  
**Example 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)
       }
   ```

1. Compressez le contenu du répertoire `python` dans un fichier .zip.

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip python/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\python -DestinationPath .\layer.zip
   ```

------

   La structure de répertoire de votre fichier .zip devrait se présenter comme suit :

   ```
   python/     # Required top-level directory
   └── validator.py
   ```

1. 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](testing-functions.md#invoke-with-event) suivant afin d’invoquer 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éer la couche dans Lambda
<a name="publishing-layer"></a>

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](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) 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.14
```

Le paramètre [compatible runtimes](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) 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](https://console.aws.amazon.com/lambda/home#/layers) de la console Lambda.

1. Sélectionnez **Créer un calque**.

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

1. (Facultatif) Pour **Exécutions compatibles**, choisissez l’environnement d’exécution Python qui correspond à la version de Python que vous avez utilisée pour créer votre couche.

1. Choisissez **Créer**.

------

## Ajouter la couche à votre fonction
<a name="python-layer-adding"></a>

------
#### [ AWS CLI ]

Pour associer la couche à votre fonction, exécutez la [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI commande. Utilisez l’ARN de la couche pour le paramètre `--layers`. 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](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**option est obligatoire si vous utilisez AWS CLI la version 2. Pour faire de ce paramètre le paramètre par défaut, exécutez `aws configure set cli-binary-format raw-in-base64-out`. Pour plus d’informations, consultez les [options de ligne de commande globales AWS CLI prises en charge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) dans le *Guide de l’utilisateur AWS Command Line Interface version 2*.

------
#### [ Console ]

**Ajouter une couche à une fonction**

1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.

1. Choisissez la fonction.

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

1. 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](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) lors de la création de la couche, celle-ci ne sera pas répertoriée ici. Vous pouvez spécifier l’ARN de la couche à la place.

1. Choisissez **Ajouter**.

------

## Exemple d’application
<a name="python-layer-sample-app"></a>

Pour d'autres exemples d'utilisation des couches Lambda, consultez l'exemple d'application [layer-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/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.