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.
# Gestion des dépendances Lambda à l’aide de couches
Une couche Lambda est une archive de fichier .zip qui contient du code ou des données supplémentaires. 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.
Vous pouvez envisager d'utiliser des couches pour plusieurs raisons :
+ **Pour réduire la taille de vos packages de déploiement.** Au lieu d'inclure toutes vos dépendances de fonctions avec votre code de fonction dans votre package de déploiement, placez-les dans une couche. Cela permet de maintenir la taille et l'organisation des packages de déploiement.
+ **Pour séparer la logique des fonctions de base des dépendances.** Avec les couches, vous pouvez mettre à jour les dépendances de vos fonctions indépendamment du code de votre fonction, et vice versa. Cela favorise la séparation des préoccupations et vous aide à vous concentrer sur la logique de votre fonction.
+ **Pour partager les dépendances entre plusieurs fonctions.** Après avoir créé une couche, vous pouvez l'appliquer à un certain nombre de fonctions de votre compte. Sans couches, vous devez inclure les mêmes dépendances dans chaque package de déploiement individuel.
+ **Pour utiliser l'éditeur de code de la console Lambda.** L'éditeur de code est un outil utile pour tester rapidement les mises à jour mineures du code des fonctions. Toutefois, vous ne pouvez pas utiliser l'éditeur si la taille de votre package de déploiement est trop importante. L'utilisation de couches réduit la taille de votre package et peut débloquer l'utilisation de l'éditeur de code.
+ **Pour verrouiller une version de SDK intégrée.**Les kits SDK intégrés peuvent être modifiés sans préavis au fur et à mesure qu’AWS publie de nouveaux services et fonctionnalités. Vous pouvez verrouiller une version du kit SDK en [créant une couche Lambda](#chapter-layers) avec la version spécifique requise. La fonction utilise alors toujours la version de la couche, même si la version intégrée au service change.
Si vous utilisez des fonctions Lambda dans Go ou Rust, nous vous déconseillons d’utiliser des couches. Le code des fonctions Go et Rust est fourni sous la forme d’un exécutable, qui contient le code compilé de la fonction ainsi que toutes ses dépendances. Placer vos dépendances dans une couche oblige votre fonction à charger manuellement des assemblages supplémentaires pendant la phase d’initialisation, ce qui peut augmenter les temps de démarrage à froid. Pour des performances optimales pour les fonctions Go et Rust, incluez vos dépendances dans votre package de déploiement.
Le diagramme suivant illustre les différences architecturales de haut niveau entre deux fonctions qui partagent des dépendances. L'un utilise des couches Lambda, l'autre non.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/lambda-layers-diagram.png)
Lorsque vous ajoutez une couche à une fonction, Lambda extrait le contenu de la couche dans le répertoire `/opt` de l'[environnement d'exécution](lambda-runtime-environment.md) de votre fonction. Toutes les exécutions Lambda prises en charge en mode natif incluent des chemins vers des répertoires spécifiques dans le répertoire `/opt`. Cela permet à votre fonction d'accéder au contenu de votre couche. Pour plus d'informations sur ces chemins spécifiques et sur la manière d'empaqueter correctement vos couches, consultez [Empaquetage du contenu de votre couche](packaging-layers.md).
Vous pouvez inclure jusqu’à cinq couches par fonction. En outre, vous ne pouvez utiliser des couches qu'avec des fonctions Lambda [déployées en tant qu'archive de fichiers .zip](configuration-function-zip.md). Pour des fonctions [définies en tant qu'image de conteneur](images-create.md), créez un package avec votre exécution préférée et toutes les dépendances de code lorsque vous créez l'image de conteneur. Pour plus d'informations, consultez [Utilisation de couches et d'extensions Lambda dans des images conteneurs](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/) sur le blog AWS Compute.
**Topics**
+ [
## Utilisation des couches
](#lambda-layers-overview)
+ [
## Couches et versions de couches
](#lambda-layer-versions)
+ [
# Empaquetage du contenu de votre couche
](packaging-layers.md)
+ [
# Création et suppression de couches dans Lambda
](creating-deleting-layers.md)
+ [
# Ajout de couches aux fonctions
](adding-layers.md)
+ [
# Utilisation de AWS CloudFormation avec des couches
](layers-cfn.md)
+ [
# Utilisation de AWS SAM avec des couches
](layers-sam.md)
## Utilisation des couches
Pour créer une couche, empaquetez vos dépendances dans un fichier .zip, de la même manière que vous [créer un package de déploiement normal](configuration-function-zip.md). Plus précisément, le processus général de création et d'utilisation de couches comporte les trois étapes suivantes :
+ **Empaquetez d'abord le contenu de votre couche.** Cela implique de créer une archive de fichiers .zip. Pour de plus amples informations, consultez [Empaquetage du contenu de votre couche](packaging-layers.md).
+ **Créez ensuite la couche dans Lambda.** Pour de plus amples informations, consultez [Création et suppression de couches dans Lambda](creating-deleting-layers.md).
+ **Ajoutez la couche à vos fonctions).** Pour de plus amples informations, consultez [Ajout de couches aux fonctions](adding-layers.md).
## Couches et versions de couches
Une version de couche est un instantané immuable d'une version spécifique d'une couche. Lorsque vous créez une nouvelle couche, Lambda crée une nouvelle version de couche avec un numéro de version de 1. Chaque fois que vous publiez une mise à jour de la couche, Lambda incrémente le numéro de version et crée une nouvelle version de couche.
Chaque version de couche est identifiée par un Amazon Resource Name (ARN) unique. Lorsque vous ajoutez une couche à la fonction, vous devez spécifier la version de couche exacte que vous voulez utiliser (par exemple `arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`).
# Empaquetage du contenu de votre couche
Une couche Lambda est une archive de fichier .zip qui contient du code ou des données supplémentaires. 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.
Cette section explique comment empaqueter correctement le contenu de votre couche. Pour plus d’informations conceptuelles sur les couches et les raisons pour lesquelles vous pourriez envisager de les utiliser, consultez [Gestion des dépendances Lambda à l’aide de couches](chapter-layers.md).
La première étape de la création d’une couche consiste à regrouper l’ensemble du contenu de la couche dans une archive de fichiers .zip. Parce que les fonctions Lambda s’exécutent sur [Amazon Linux](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html), le contenu de votre couche doit pouvoir être compilé et construit dans un environnement Linux.
Pour vous assurer que le contenu de votre couche fonctionne correctement dans un environnement Linux, nous vous recommandons de créer le contenu de votre couche à l’aide d’un outil comme [Docker](https://docs.docker.com/get-docker).
**Topics**
+ [
## Chemins d’accès de couche pour chaque exécution Lambda
](#packaging-layers-paths)
## Chemins d’accès de couche pour chaque exécution Lambda
Lorsque vous ajoutez une couche à une fonction, Lambda charge le contenu de la couche dans le répertoire `/opt` de cet environnement d’exécution. Pour chaque exécution Lambda, la variable `PATH` inclut déjà des chemins de dossiers spécifiques dans le répertoire `/opt`. Pour garantir que Lambda capture le contenu de votre couche, le fichier .zip de votre couche doit avoir ses dépendances un des chemins de dossier suivants :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/packaging-layers.html)
Les exemples suivants montrent comment structurer les dossiers dans votre couche d’archive .zip.
------
#### [ Node.js ]
**Example structure de fichiers du kit SDK AWS X-Ray pour Node.js**
```
xray-sdk.zip
└ nodejs/node_modules/aws-xray-sdk
```
------
#### [ Python ]
**Example**
```
python/ # Required top-level directory
└── requests/
└── boto3/
└── numpy/
└── (dependencies of the other packages)
```
------
#### [ Ruby ]
**Example structure de fichiers pour la gem JSON**
```
json.zip
└ ruby/gems/3.4.0/
| build_info
| cache
| doc
| extensions
| gems
| └ json-2.1.0
└ specifications
└ json-2.1.0.gemspec
```
------
#### [ Java ]
**Example structure de fichiers pour le fichier JAR Jackson**
```
layer_content.zip
└ java
└ lib
└ jackson-core-2.17.0.jar
└
└ ...
```
------
#### [ All ]
**Example structure de fichiers pour la bibliothèque jq**
```
jq.zip
└ bin/jq
```
------
Pour obtenir des instructions spécifiques au langage et relatives à l’empaquetage, à la création et à l’ajout d’une couche, reportez-vous aux pages suivantes :
+ **Node.js** – [Utilisation de couches pour les fonctions Lambda Node.js](nodejs-layers.md)
+ **Python** – [Utilisation de couches pour les fonctions Lambda Python](python-layers.md)
+ **Ruby** – [Utilisation de couches pour les fonctions Lambda Ruby](ruby-layers.md)
+ **Java** : [Utilisation de couches pour les fonctions Lambda Java](java-layers.md)
Nous **déconseillons** d’utiliser des couches pour gérer les dépendances des fonctions Lambda écrites en Go et Rust. Cela est dû au fait que les fonctions Lambda écrites dans ces langages sont compilées en un seul exécutable, que vous fournissez à Lambda lorsque vous déployez votre fonction. Cet exécutable contient votre code de fonction compilé, ainsi que toutes ses dépendances. L’utilisation de couches complique non seulement ce processus, mais entraîne également une augmentation des temps de démarrage à froid, car vos fonctions doivent charger manuellement des assemblages supplémentaires en mémoire pendant la phase d’initialisation.
Pour utiliser des dépendances externes avec vos fonctions Lambda Go et Rust, incluez-les directement dans votre package de déploiement.
# Création et suppression de couches dans Lambda
Une couche Lambda est une archive de fichier .zip qui contient du code ou des données supplémentaires. 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.
Cette section explique comment créer et supprimer des couches dans Lambda. Pour plus d’informations conceptuelles sur les couches et les raisons pour lesquelles vous pourriez envisager de les utiliser, consultez [Gestion des dépendances Lambda à l’aide de couches](chapter-layers.md).
Une fois que vous avez [empaqueté le contenu de votre couche](packaging-layers.md), l’étape suivante consiste à créer la couche dans Lambda. Cette section explique comment créer et supprimer des couches à l’aide de la console Lambda ou de l’API Lambda uniquement. Pour créer une couche à l’aide d’ AWS CloudFormation, consultez [Utilisation de AWS CloudFormation avec des couches](layers-cfn.md). Pour créer une couche à l’aide d’ AWS Serverless Application Model (AWS SAM), consultez [Utilisation de AWS SAM avec des couches](layers-sam.md).
**Topics**
+ [
## Création d’une couche
](#layers-create)
+ [
## Suppression d’une version de couche
](#layers-delete)
## Création d’une couche
Pour créer une couche, vous pouvez soit charger l’archive du fichier .zip depuis votre ordinateur local, soit depuis Amazon Simple Storage Service (Amazon S3). Lors de la configuration de l’environnement d’exécution pour la fonction, Lambda extrait le contenu de la couche dans le répertoire `/opt`.
Les couches peuvent avoir une ou plusieurs [versions de couche](chapter-layers.md#lambda-layer-versions). Lorsque vous créez une couche, Lambda définit la version de la couche sur version 1. Vous pouvez modifier les autorisations sur une version de couche existante à tout moment. Toutefois, pour mettre à jour le code ou apporter d’autres modifications de configuration, vous devez créer une nouvelle version de la couche.
**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. Sous **Configuration de la couche**, dans **Nom**, nommez votre couche.
1. (Facultatif) Dans le champ **Description**, saisissez une description pour le calque.
1. Pour télécharger le code de votre couche, effectuez l’une des opérations suivantes :
+ Pour charger un fichier .zip à partir de votre ordinateur, choisissez **Charger un fichier .zip**. Puis, sélectionnez **Charger** pour sélectionner votre fichier .zip local.
+ Pour charger un fichier à partir d’Amazon S3, choisissez **Charger un fichier à partir d’Amazon S3**. Ensuite, pour l’**URL du lien Amazon S3**, saisissez un lien vers le fichier.
1. (Facultatif) Pour **Architectures compatibles**, choisissez une valeur ou les deux valeurs. Pour de plus amples informations, veuillez consulter [Sélection et configuration d’une architecture de jeu d’instructions pour votre fonction Lambda](foundation-arch.md).
1. (Facultatif) Pour **Exécutions compatibles**, choisissez les exécutions avec lesquelles votre couche est compatible.
1. (Facultatif) Pour **Licence**, saisissez toutes les informations de licence nécessaires.
1. Choisissez **Créer**.
Vous pouvez également exécuter la commande [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS Command Line Interface (CLI). Exemple :
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes python3.14
```
Chaque fois que vous exécutez `publish-layer-version`, Lambda crée une nouvelle [version de la couche](chapter-layers.md#lambda-layer-versions).
## Suppression d’une version de couche
Pour supprimer une version de couche, utilisez l'opération [DeleteLayerVersion](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteLayerVersion.html)API. Par exemple, exécutez la [delete-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-layer-version.html) AWS CLI commande avec le nom de couche et la version de couche spécifiés.
```
aws lambda delete-layer-version --layer-name my-layer --version-number 1
```
Lorsque vous supprimez une version de couche, vous ne pouvez plus configurer de fonction Lambda pour l’utiliser. En revanche, toute fonction qui utilise déjà la version continue d’y avoir accès. De plus, Lambda ne réutilise jamais les numéros de version pour le nom d’une couche.
Lors du calcul des [quotas](gettingstarted-limits.md), la suppression d’une version de couche signifie qu’elle n’est plus prise en compte dans le quota par défaut de 75 Go pour le stockage des fonctions et des couches. Toutefois, pour les fonctions qui utilisent une version de couche supprimée, le contenu de la couche est toujours pris en compte dans le quota de taille du package de déploiement de la fonction (c’est-à-dire 250 Mo pour les archives de fichiers .zip).
# Ajout de couches aux fonctions
Une couche Lambda est une archive de fichier .zip qui contient du code ou des données supplémentaires. 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.
Cette section explique comment ajouter une couche à une fonction Lambda. Pour plus d’informations conceptuelles sur les couches et les raisons pour lesquelles vous pourriez envisager de les utiliser, consultez [Gestion des dépendances Lambda à l’aide de couches](chapter-layers.md).
Avant de pouvoir configurer une fonction Lambda pour utiliser une couche, vous devez :
+ [Empaqueter le contenu de votre couche](packaging-layers.md)
+ [Créer une couche dans Lambda](creating-deleting-layers.md)
+ Assurez-vous que vous êtes autorisé à appeler l'[GetLayerVersion](https://docs.aws.amazon.com/lambda/latest/api/API_GetLayerVersion.html)API sur la version de la couche. Pour les fonctions de votre Compte AWS, vous devez disposer de cette autorisation dans votre [politique d'utilisation](access-control-identity-based.md). Pour utiliser une couche dans un autre compte, le propriétaire de ce compte doit accorder l’autorisation à votre compte dans une [stratégie basée sur les ressources](access-control-resource-based.md). Pour obtenir des exemples, consultez [Octroi de l’accès de la couche Lambda à d’autres comptes](permissions-layer-cross-account.md).
Vous pouvez ajouter jusqu’à cinq couches à une fonction Lambda. La taille totale décompressée de la fonction avec toutes les couches ne peut pas dépasser le quota de taille de package de déploiement décompressé de 250 Mo. Pour de plus amples informations, veuillez consulter [Quotas Lambda](gettingstarted-limits.md).
Vos fonctions peuvent continuer à utiliser n’importe quelle version de couche que vous avez déjà ajoutée, même après la suppression de cette version de couche ou après la révocation de votre autorisation d’accès à la couche. Toutefois, vous ne pouvez pas créer une nouvelle fonction qui utilise une version de couche supprimée.
**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**, choisissez une source de couche :
1. **AWS couches** : choisissez dans la liste des [extensions AWS gérées](extensions-api-partners.md#aws-managed-extensions).
1. **Couches personnalisées** : choisissez une couche créée dans votre Compte AWS.
1. **Spécifiez un ARN** : pour utiliser une couche [provenant d'une autre](permissions-layer-cross-account.md) couche Compte AWS, telle qu'une [extension tierce](extensions-api-partners.md), entrez le Amazon Resource Name (ARN).
1. Choisissez **Ajouter**.
L’ordre dans lequel vous ajoutez les couches correspond à l’ordre dans lequel Lambda fusionne ultérieurement le contenu de la couche dans l’environnement d’exécution. Vous pouvez modifier l’ordre de fusion des couches à l’aide de la console.
**Pour mettre à jour l’ordre de fusion des couches pour votre fonction (console)**
1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.
1. Choisissez la fonction à configurer.
1. Sous **Layers** (Couches), choisissez **Edit** (Modifier).
1. Choisissez l’une des couches.
1. Choisissez **Merge earlier (Fusionner plus tôt)** ou **Merge later (Fusionner plus tard)** pour ajuster l’ordre des couches.
1. Choisissez **Enregistrer**.
Les couches sont versionnées. Le contenu de chaque version de couche est immuable. Le propriétaire d’une couche peut publier une nouvelle version de la couche pour fournir du contenu mis à jour. Vous pouvez utiliser la console pour mettre à jour la version de couche associée à vos fonctions.
**Pour mettre à jour les versions des couches de votre fonction (console)**
1. Ouvrez la [page Couches](https://console.aws.amazon.com/lambda/home#/layers) de la console Lambda.
1. Choisissez la couche pour laquelle vous voulez mettre à jour la version.
1. Choisissez l’onglet **Fonctions utilisant cette version**.
1. Choisissez les fonctions que vous voulez modifier, puis cliquez sur **Modifier**.
1. Pour **Version de la couche**, choisissez la version de la couche à modifier.
1. Choisissez **Update functions** (Mettre à jour les fonctions).
Vous ne pouvez pas mettre à jour les versions des couches fonctionnelles d'un AWS compte à l'autre.
## Recherche d’informations sur la couche
Pour trouver dans votre compte des couches compatibles avec le temps d'exécution de votre fonction, utilisez l'[ListLayers](https://docs.aws.amazon.com/lambda/latest/api/API_ListLayers.html)API. Par exemple, vous pouvez utiliser la commande [list-layers](https://docs.aws.amazon.com/cli/latest/reference/lambda/list-layers.html) ( AWS Command Line Interface CLI) suivante :
```
aws lambda list-layers --compatible-runtime python3.14
```
Vous devez voir des résultats similaires à ce qui suit :
```
{
"Layers": [
{
"LayerName": "my-layer",
"LayerArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer",
"LatestMatchingVersion": {
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:2",
"Version": 2,
"Description": "My layer",
"CreatedDate": "2025-04-15T00:37:46.592+0000",
"CompatibleRuntimes": [
"python3.14"
]
}
}
]
}
```
Pour répertorier toutes les couches de votre compte, ignorez l’option `--compatible-runtime`. Les détails de la réponse indiquent la dernière version de chaque couche.
Vous pouvez également obtenir la dernière version d'une couche à l'aide de l'[ListLayerVersions](https://docs.aws.amazon.com/lambda/latest/api/API_ListLayerVersions.html)API. Par exemple, vous pouvez utiliser la commande CLI `list-layer-versions` suivante :
```
aws lambda list-layer-versions --layer-name my-layer
```
Vous devez voir des résultats similaires à ce qui suit :
```
{
"LayerVersions": [
{
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:2",
"Version": 2,
"Description": "My layer",
"CreatedDate": "2023-11-15T00:37:46.592+0000",
"CompatibleRuntimes": [
"java11"
]
},
{
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:1",
"Version": 1,
"Description": "My layer",
"CreatedDate": "2023-11-15T00:27:46.592+0000",
"CompatibleRuntimes": [
"java11"
]
}
]
}
```
# Utilisation de AWS CloudFormation avec des couches
Vous pouvez utiliser CloudFormation pour créer une couche et l’associer à votre fonction Lambda. L’exemple de modèle suivant crée une couche nommée `my-lambda-layer` et l’attache à la fonction Lambda à l’aide de la propriété **Couches**.
Dans cet exemple, le modèle indique l’Amazon Resource Name (ARN) d’un [rôle d’exécution](lambda-intro-execution-role.md) IAM existant. Vous pouvez également créer un nouveau rôle d’exécution dans le modèle à l’aide de la ressource CloudFormation [AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html).
Votre fonction n’a pas besoin d’autorisations spéciales pour utiliser les couches.
```
---
Description: CloudFormation Template for Lambda Function with Lambda Layer
Resources:
MyLambdaLayer:
Type: AWS::Lambda::LayerVersion
Properties:
LayerName: my-lambda-layer
Description: My Lambda Layer
Content:
S3Bucket: amzn-s3-demo-bucket
S3Key: my-layer.zip
CompatibleRuntimes:
- python3.9
- python3.10
- python3.11
MyLambdaFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: my-lambda-function
Runtime: python3.9
Handler: index.handler
Timeout: 10
Role: arn:aws:iam::111122223333:role/my_lambda_role
Layers:
- !Ref MyLambdaLayer
```
# Utilisation de AWS SAM avec des couches
Vous pouvez utiliser l’AWS Serverless Application Model (AWS SAM) pour automatiser la création de couches dans votre application. Le type de ressource `AWS::Serverless::LayerVersion` crée une version de couche que vous pouvez référencer à partir de la configuration de votre fonction Lambda.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Description: AWS SAM Template for Lambda Function with Lambda Layer
Resources:
MyLambdaLayer:
Type: AWS::Serverless::LayerVersion
Properties:
LayerName: my-lambda-layer
Description: My Lambda Layer
ContentUri: s3://amzn-s3-demo-bucket/my-layer.zip
CompatibleRuntimes:
- python3.9
- python3.10
- python3.11
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: MyLambdaFunction
Runtime: python3.9
Handler: app.handler
CodeUri: s3://amzn-s3-demo-bucket/my-function
Layers:
- !Ref MyLambdaLayer
```