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 Node.js
<a name="nodejs-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](#nodejs-layers-package)
+ [Créer la couche dans Lambda](#publishing-layer)
+ [Ajouter la couche à votre fonction](#nodejs-layer-adding)
+ [Exemple d’application](#nodejs-layer-sample-app)

## Empaqueter le contenu de votre couche
<a name="nodejs-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 Node.js que celle que vous prévoyez d’utiliser pour la fonction Lambda. Par exemple, si vous créez votre couche à l'aide de Node.js 24, utilisez le runtime Node.js 24 pour votre fonction.
+ Le fichier .zip de votre couche doit utiliser l’une des structures de répertoires suivantes :
  + `nodejs/node_modules`
  + `nodejs/nodeX/node_modules`(où se *X* trouve votre version de Node.js, par exemple`node22`)

  Pour de plus amples informations, veuillez consulter [Chemins d’accès de couche pour chaque exécution Lambda](packaging-layers.md#packaging-layers-paths).
+ 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 Node.js tierces installées avec `npm` (telles que `axios` ou`lodash`) ou vos propres JavaScript modules.

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

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

1. Créez la structure de répertoires requise et installez-y les packages directement :

   ```
   mkdir -p nodejs
   npm install --prefix nodejs lodash axios
   ```

   Cette commande installe les packages directement dans le répertoire `nodejs/node_modules`, qui correspond à la structure requise par Lambda.
**Note**  
Pour les packages avec des dépendances natives ou des composants binaires (comme [sharp](https://www.npmjs.com/package/sharp) ou [bcrypt](https://www.npmjs.com/package/bcrypt)), assurez-vous qu’ils sont compatibles avec l’environnement Linux Lambda et l’[architecture](foundation-arch.md) de votre fonction. Vous devrez peut-être utiliser l’indicateur `--platform` :  

   ```
   npm install --prefix nodejs --platform=linux --arch=x64 sharp
   ```
Pour les dépendances natives plus complexes, vous devrez peut-être les compiler dans un environnement Linux qui correspond à l’environnement d’exécution Lambda. Vous pouvez utiliser Docker à cette fin.

1. Compressez le contenu de la couche :

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

   ```
   zip -r layer.zip nodejs/
   ```

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

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

------

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

   ```
   nodejs/
   ├── package.json
   ├── package-lock.json
   └── node_modules/
       ├── lodash/
       ├── axios/
       └── (dependencies of the other packages)
   ```
**Note**  
Assurez-vous que votre fichier .zip inclut le répertoire `nodejs` au niveau racine avec `node_modules` à l’intérieur. Cette structure garantit que Lambda peut localiser et importer vos packages.
Les fichiers `package.json` et `package-lock.json` du répertoire `nodejs/` sont utilisés par npm pour la gestion des dépendances, mais ne sont pas requis par Lambda pour le fonctionnement des couches. Chaque package installé contient déjà son propre fichier `package.json` qui définit la manière dont Lambda importe le package.

### JavaScript Modules personnalisés
<a name="custom-nodejs-modules"></a>

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

1. Créez la structure de répertoires requise pour votre couche :

   ```
   mkdir -p nodejs/node_modules/validator
   cd nodejs/node_modules/validator
   ```

1. Créez un fichier `package.json` pour votre module personnalisé afin de définir comment il doit être importé :  
**Example nodejs/node\$1modules/validator/package.json**  

   ```
   {
     "name": "validator",
     "version": "1.0.0",
     "type": "module",
     "main": "index.mjs"
   }
   ```

1. Créez votre fichier JavaScript de module :  
**Example nodejs/node\$1modules/validator/index.mjs**  

   ```
   export function validateOrder(orderData) {
     // Validates an order and returns formatted data
     const requiredFields = ['productId', 'quantity'];
     
     // Check required fields
     const missingFields = requiredFields.filter(field => !(field in orderData));
     if (missingFields.length > 0) {
       throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
     }
     
     // Validate quantity
     const quantity = orderData.quantity;
     if (!Number.isInteger(quantity) || quantity < 1) {
       throw new Error('Quantity must be a positive integer');
     }
     
     // Format and return the validated data
     return {
       productId: String(orderData.productId),
       quantity: quantity,
       shippingPriority: orderData.priority || 'standard'
     };
   }
   
   export function formatResponse(statusCode, body) {
     // Formats the API response
     return {
       statusCode: statusCode,
       body: JSON.stringify(body)
     };
   }
   ```

1. Compressez le contenu de la couche :

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

   ```
   zip -r layer.zip nodejs/
   ```

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

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

------

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

   ```
   nodejs/              
   └── node_modules/
       └── validator/
           ├── package.json
           └── index.mjs
   ```

1. Dans votre fonction, importez et utilisez les modules. Exemple :

   ```
   import { validateOrder, formatResponse } from 'validator';
   
   export const handler = async (event) => {
     try {
       // Parse the order data from the event body
       const orderData = JSON.parse(event.body || '{}');
       
       // Validate and format the order
       const validatedOrder = validateOrder(orderData);
       
       return formatResponse(200, {
         message: 'Order validated successfully',
         order: validatedOrder
       });
     } catch (error) {
       if (error instanceof Error && error.message.includes('Missing required fields')) {
         return formatResponse(400, {
           error: error.message
         });
       }
       
       return formatResponse(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": "{\"productId\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
   }
   ```

   Réponse attendue :

   ```
   {
     "statusCode": 200,
     "body": "{\"message\":\"Order validated successfully\",\"order\":{\"productId\":\"ABC123\",\"quantity\":2,\"shippingPriority\":\"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 nodejs24.x
```

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 **Environnements d’exécution compatibles**, choisissez l’environnement d’exécution Node.js qui correspond à la version de Node.js que vous avez utilisée pour créer votre couche.

1. Choisissez **Créer**.

------

## Ajouter la couche à votre fonction
<a name="nodejs-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="nodejs-layer-sample-app"></a>

Pour d'autres exemples d'utilisation des couches Lambda, consultez l'exemple d'application [layer-nodejs dans le référentiel du Developer](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-nodejs) Guide. AWS Lambda GitHub Cette application inclut une couche qui contient la bibliothèque [lodash](https://www.npmjs.com/package/lodash). Après avoir créé la couche, vous pouvez déployer et invoquer la fonction correspondante pour confirmer que la couche fonctionne comme prévu.