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.
# Création de couches Lambda dans AWS SAM
Vous pouvez l'utiliser AWS SAM pour créer des couches Lambda personnalisées. Les couches Lambda vous permettent d'extraire le code d'une fonction Lambda qui peut ensuite être réutilisé dans plusieurs fonctions Lambda. La création de couches Lambda uniquement (au lieu de créer l'intégralité de votre application) peut vous être bénéfique de plusieurs manières. Cela peut vous aider à réduire la taille de vos packages de déploiement, à séparer la logique des fonctions de base des dépendances et à partager les dépendances entre plusieurs fonctions. Pour davantage d'informations sur les couches, consultez [Couches Lambda AWS](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) dans le *Guide du développeur AWS Lambda *.
## Comment créer une couche Lambda dans AWS SAM
**Note**
Avant de créer une couche Lambda, vous devez d'abord écrire une couche Lambda dans votre modèle. AWS SAM Pour obtenir des informations et des exemples à ce sujet, consultez[Améliorez l'efficacité en utilisant les couches Lambda avec AWS SAM](serverless-sam-cli-layers.md).
Pour créer une couche personnalisée, déclarez-la dans votre fichier modèle AWS Serverless Application Model (AWS SAM) et incluez une section d'attribut de `Metadata` ressource avec une `BuildMethod` entrée. Les valeurs valides pour `BuildMethod` sont des identifiants pour une [exécution AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), ou `makefile`. Incluez une entrée `BuildArchitecture` pour préciser les architectures de jeux d'instructions prises en charge par votre couche. Les valeurs valides pour `BuildArchitecture` sont [Architectures du jeu d'instructions Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).
Si vous spécifiez `makefile`, vous fournissez un makefile personnalisé, où vous déclarez une cible de génération du formulaire `build-layer-logical-id` qui contient les commandes de création de votre couche. Votre makefile est responsable de la compilation de la couche si nécessaire, et de la copie des artefacts de construction dans l'emplacement approprié requis pour les étapes suivantes de votre flux. L'emplacement du makefile est spécifié par la propriété `ContentUri` de la ressource de couche, et doit être nommé `Makefile`.
**Note**
Lorsque vous créez une couche personnalisée, AWS Lambda cela dépend des variables d'environnement pour trouver votre code de couche. Les exécutions Lambda incluent des chemins dans le répertoire `/opt` dans lequel votre code de couche est copié. La structure de dossier d'artefact de construction de votre projet doit correspondre à la structure de dossier attendue de l'exécution pour que votre code de couche personnalisé puisse être trouvé.
Par exemple, pour Python, vous pouvez placer votre code dans le sous-répertoire `python/`. Pour NodeJS, vous pouvez placer votre code dans le sous-répertoire `nodejs/node_modules/`.
Pour de plus amples informations, consultez [Inclusion de dépendances de bibliothèques dans une couche](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) dans le *Guide du développeur AWS Lambda *.
Voici un exemple de section d'attribut de ressource `Metadata`.
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**Note**
Si vous n'incluez pas la section `Metadata` des attributs de ressource, AWS SAM cela ne crée pas la couche. Au lieu de cela, il copie les artefacts de construction à partir de l'emplacement spécifié dans la propriété `CodeUri` de la ressource de couche. Pour plus d'informations, consultez la propriété [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi) du type de ressource `AWS::Serverless::LayerVersion`.
Lorsque vous incluez la section `Metadata` des attributs de ressource, vous pouvez utiliser la `sam build` commande pour créer la couche, à la fois en tant qu'objet indépendant ou en tant que dépendance d'une AWS Lambda fonction.
+ ****En tant qu'objet indépendant.**** Vous pouvez souhaiter créer uniquement l'objet de la couche, par exemple si vous testez localement une modification de code de la couche et que vous n'avez pas besoin de créer l'ensemble de votre application. Pour créer la couche indépendamment, spécifiez la ressource de couche à l'aide de la commande `sam build layer-logical-id`.
+ **En tant que dépendance d'une fonction Lambda.** Lorsque vous incluez l'ID logique d'une couche dans la propriété `Layers` d'une fonction Lambda dans le même fichier modèle AWS SAM , la couche sera une dépendance de cette fonction Lambda. Lorsque cette couche inclut également une section d'attribut de ressource `Metadata` avec une entrée `BuildMethod`, vous créez la couche soit en créant la totalité de l'application à l'aide de l'option `sam build` ou en spécifiant la ressource de fonction avec la commande `sam build function-logical-id`.
## Exemples
### Exemple de modèle 1 : création d'une couche dans l'environnement d'exécution Python 3.12
L'exemple de AWS SAM modèle suivant crée une couche sur l'environnement d'exécution Python 3.12.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### Exemple de modèle 2 : création d'une couche à l'aide d'un makefile personnalisé
L'exemple de AWS SAM modèle suivant utilise un modèle personnalisé `makefile` pour créer la couche.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
Le `makefile` suivant contient la cible de génération et les commandes qui seront exécutées. Notez que la propriété `ContentUri` est définie sur `my_layer`. Le makefile doit donc se trouver dans la racine du répertoire `my_layer`, et le nom de fichier doit être `Makefile`. Notez également que les artefacts de construction sont copiés dans le `python/` sous-répertoire afin que AWS Lambda celui-ci puisse trouver le code de couche.
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**Note**
Lorsque le `makefile` est appelé, la cible appropriée est déclenchée et les artefacts doivent être copiés dans la variable environnementale exposée`$ARTIFACTS_DIR`. Pour plus d'informations, reportez-vous [aws-lambda-builders à GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md).
### Exemple de commandes de création sam
Procédez comme suit : les commandes `sam build` créent des couches qui incluent la section d'attribut de ressource `Metadata`.
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```