Empaqueter le contenu de votre couche Créer la couche dans Lambda Ajouter la couche à votre fonction Exemple d’application

Utilisation de couches pour les fonctions Lambda Node.js

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 :

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.
Créez la couche dans Lambda.
Ajoutez la couche à vos fonctions.

Empaqueter le contenu de votre couche

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 22, utilisez l’environnement d'exécution Node.js 22 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ù X est votre version de Node.js, par exemple node22)
Pour de plus amples informations, consultez Chemins d’accès de couche pour chaque exécution Lambda.
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 (comme axios ou lodash) ou vos propres modules JavaScript.

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

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 ou bcrypt), assurez-vous qu’ils sont compatibles avec l’environnement Linux Lambda et l’architecture 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.
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.

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

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


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

Créez un fichier package.json pour votre module personnalisé afin de définir comment il doit être importé :
Exemple nodejs/node_modules/validator/package.json
```
{
  "name": "validator",
  "version": "1.0.0",
  "type": "module",
  "main": "index.mjs"
}
```

Créez le fichier de votre module JavaScript :

Exemple nodejs/node_modules/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)
  };
}

Compressez le contenu de la couche :

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

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

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 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

Vous pouvez publier votre couche en utilisant AWS CLI ou la console Lambda.

Ajouter la couche à votre fonction

Exemple d’application

Pour d’autres exemples d’utilisation des couches Lambda, consultez l’exemple d’application layer-nodejs dans le référentiel GitHub du Guide du développeur AWS Lambda. Cette application inclut une couche qui contient la bibliothèque 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.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déploiement d’images de conteneur

Contexte

Utilisation de couches pour les fonctions Lambda Node.js

Rubriques

Empaqueter le contenu de votre couche

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

Note

Note

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

Exemple nodejs/node_modules/validator/package.json

Exemple nodejs/node_modules/validator/index.mjs

Créer la couche dans Lambda

Pour créer une couche (console)

Ajouter la couche à votre fonction

Ajouter une couche à une fonction

Note

Exemple d’application