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

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, ou des fichiers de configuration. La création d’une couche implique trois étapes générales :

Cette rubrique contient des étapes et des conseils sur la manière d’empaqueter et de créer correctement une couche Lambda Node.js avec des dépendances de bibliothèque externes.

Prérequis

Pour suivre les étapes de cette section, vous devez disposer des éléments suivants :

Tout au long de cette rubrique, nous faisons référence à l’exemple d’application layer-nodejs dans le référentiel GitHub aws-lambda-developer-guide. Cette application contient des scripts qui téléchargent une dépendance et l’empaquetent dans une couche. L’application contient également des fonctions correspondantes qui utilisent la dépendance de la couche. Après avoir créé une couche, vous pouvez déployer et invoquer la fonction correspondante pour vérifier que tout fonctionne. Cet exemple d’application utilise l’environnement d’exécution Node.js 20. Si vous ajoutez des dépendances supplémentaires à votre couche, elles doivent être compatibles avec Node.js 20.

L’exemple d’application layer-nodejs va empaqueter la bibliothèque lodash dans une couche Lambda. Le répertoire layer contient les scripts permettant de générer la couche. Le répertoire function contient un exemple de fonction permettant de vérifier le fonctionnement de la couche. Ce document explique comment créer, empaqueter, déployer et tester cette couche.

Compatibilité de la couche Node.js avec l’environnement d’exécution Lambda

Lorsque vous empaquetez du code dans une couche Node.js, vous spécifiez les environnements d’exécution Lambda avec lesquelles le code est compatible. Pour évaluer la compatibilité du code avec un environnement d’exécution, déterminez les versions de Node.js, les systèmes d’exploitation et les architectures de jeu d’instructions pour lesquelles le code est conçu.

Les environnements d’exécution Lambda Node.js spécifient leur version Node.js et leur système d’exploitation. Dans ce document, vous allez utiliser l’environnement d’exécution Node.js 20, basée sur AL2023. Pour plus d’informations sur les versions d’environnements d’exécution, consultez Environnements d'exécution pris en charge. Lorsque vous créez cette fonction Lambda, vous pouvez spécifier l’architecture de l’ensemble des instructions. Dans ce document, vous utiliserez l’architecture arm64. Pour plus d’informations sur les architectures dans Lambda, consultez Sélection et configuration d’une architecture de jeu d’instructions pour votre fonction Lambda.

Lorsque vous utilisez le code fourni dans un package, chaque responsable du package définit indépendamment sa compatibilité. La plupart des développements Node.js sont conçus pour fonctionner indépendamment du système d’exploitation et de l’architecture du jeu d’instructions. De plus, il n’est pas courant de rompre les incompatibilités avec les nouvelles versions de Node.js. Attendez-vous à passer plus de temps à évaluer la compatibilité entre les packages qu’à évaluer la compatibilité des packages avec la version de Node.js, le système d’exploitation ou l’architecture du jeu d’instructions.

Parfois, les packages Node.js incluent du code compilé, ce qui vous oblige à prendre en compte la compatibilité du système d’exploitation et de l’architecture du jeu d’instructions. Si vous devez évaluer la compatibilité du code de vos packages, il est nécessaire d’inspecter les packages et leur documentation. Dans NPM, les packages peuvent spécifier leur compatibilité via les champs engines, os et cpu de leur fichier manifeste package.json. Pour plus d’informations sur les fichiers package.json, consultez package.json dans la documentation NPM.

Chemins d’accès de couche des environnements d’exécution Node.js

Lorsque vous ajoutez une couche à une fonction, Lambda charge le contenu de la couche dans l’environnement d’exécution. Si votre couche regroupe les dépendances dans des chemins de dossier spécifiques, l’environnement d’exécution Node.js reconnaîtra les modules et vous pourrez les référencer à partir de votre code de fonction.

Pour vous assurer que vos modules sont sélectionnés, empaquez-les dans le fichier .zip de votre couche dans l’un des chemins de dossier suivants. Ces fichiers sont stockés dans /opt et les chemins d’accès aux dossiers sont chargés dans la variable d’environnement PATH.

Par exemple, le fichier de couche .zip obtenu que vous créez dans ce tutoriel possède la structure de répertoire suivante :

layer_content.zip
└ nodejs
    └ node20
        └ node_modules
            └ lodash
            └ <other potential dependencies>
            └ ...

Vous allez placer la bibliothèque lodash dans le répertoire nodejs/node20/node_modules. Cela garantit que Lambda peut localiser la bibliothèque lors des appels de fonctions.

Empaquetage du contenu de la couche

Dans cet exemple, vous allez empaqueter la bibliothèque lodash dans un fichier .zip de couche. Pour installer et empaqueter le contenu de la couche, complétez les étapes suivantes.

Création de la couche

Prenez le fichier layer_content.zip que vous avez généré dans la section précédente et chargez-le en tant que couche Lambda. Vous pouvez charger une couche à l’aide de l’AWS Management Console ou de l’API Lambda via l’AWS Command Line Interface (AWS CLI). Lorsque vous chargez le fichier .zip de votre couche, dans la commande PublishLayerVersion de l’AWS CLI suivante, spécifiez nodejs20.x en tant qu’environnement d’exécution compatible et arm64 en tant qu’architecture compatible.

aws lambda publish-layer-version --layer-name nodejs-lodash-layer \
    --zip-file fileb://layer_content.zip \
    --compatible-runtimes nodejs20.x \
    --compatible-architectures "arm64"

Dans la réponse, notez le LayerVersionArn, qui ressemble à arn:aws:lambda:us-east-1:123456789012:layer:nodejs-lodash-layer:1. Vous aurez besoin de cet Amazon Resource Name (ARN) à l’étape suivante de ce tutoriel, lorsque vous ajouterez la couche à votre fonction.

Ajout de la couche à votre fonction

Déployez un exemple de fonction Lambda qui utilise la bibliothèque lodash dans son code de fonction, puis attachez la couche que vous avez créée. Pour déployer la fonction, vous avez besoin d’un rôle d’exécution. Pour en savoir plus, consultez Définition des autorisations de fonction Lambda avec un rôle d’exécution. Si vous ne disposez pas d’un rôle d’exécution existant, suivez les étapes de la section réductible. Sinon, passez à la section suivante pour déployer la fonction.

L’exemple de code de fonction utilise la méthode lodash _.findLastIndex pour lire un tableau d’objets. Il compare les objets par rapport à un critère pour trouver l’index d’une correspondance. Il renvoie ensuite l’index et la valeur de l’objet dans la réponse Lambda.

import _ from "lodash"

export const handler = async (event) => {

  var users = [
  { 'user': 'Carlos',  'active': true },
  { 'user': 'Gil-dong',    'active': false },
  { 'user': 'Pat', 'active': false }
  ];

  let out = _.findLastIndex(users, function(o) { return o.user == 'Pat'; });
  const response = {
    statusCode: 200,
    body: JSON.stringify(out + ", " + users[out].user),
  };
  return response;
};