Création d’images de conteneur Lambda - AWS Lambda

Création d’images de conteneur Lambda

AWS fournit un ensemble d’images de base open source que vous pouvez utiliser pour créer votre image de conteneur. Ces images de base comprennent un client d’interface de runtime afin de gérer l’interaction entre Lambda et votre code de fonction.

Pour consulter des exemples d’applications, y compris un exemple Node.js et un exemple Python, consultez Prise en charge des images de conteneur pour Lambda sur le blog AWS.

Prérequis

Pour déployer une image de conteneur sur Lambda, vous avez besoin des interfaces de ligne de commande AWS CLI et Docker. En outre, notez les exigences suivantes :

  • L’image de conteneur doit implémenter l’API Runtime Lambda. Les clients d’interface de runtime open source AWS implémentent l’API. Vous pouvez ajouter un client d’interface de runtime à votre image de base préférée pour la rendre compatible avec Lambda.

  • L’image de conteneur doit pouvoir s’exécuter sur un système de fichiers en lecture seule. Votre code de fonction peut accéder à un répertoire /tmp inscriptible entre 512 Mo et 10 240 Mo de stockage, par incréments de 1 Mo.

  • L’utilisateur Lambda par défaut doit pouvoir lire tous les fichiers requis pour exécuter votre code de fonction. Lambda suit les bonnes pratiques de sécurité en définissant un utilisateur Linux par défaut avec des autorisations assortie d’un privilège minimum. Vérifiez que votre code d’application ne repose pas sur des fichiers dont l’exécution n’est pas autorisée à d’autres utilisateurs Linux.

  • Lambda prend uniquement en charge les images de conteneur basées sur Linux.

  • Lambda fournit des images de base multi-architecture. Toutefois, l’image que vous créez pour la fonction ne doit avoir que l’une des architectures pour cible. Lambda ne prend pas en charge les fonctions qui utilisent les images de conteneur multi-architecture.

Types d’images

Vous pouvez utiliser une image de base fournie par AWS ou une autre image de base, comme Alpine ou Debian. Lambda prend en charge toute image conforme à l’un des formats de manifeste d’image suivants :

  • Manifeste d’images Docker V2, schéma 2 (utilisé avec la version 1.10 de Docker et les versions les plus récentes)

  • Spécifications OCI (Open Container initiative, soit initiative de conteneur ouvert) (v1.0.0 et versions ultérieures)

Lambda prend en charge les images jusqu’à 10 Go.

Outils de conteneur

Pour créer votre image de conteneur, vous pouvez utiliser n’importe quel outil de développement prenant en charge l’un des formats de manifeste d’images de conteneur suivants :

  • Manifeste d’images Docker V2, schéma 2 (utilisé avec la version 1.10 de Docker et les versions les plus récentes)

  • Spécifications OCI (v1.0.0 et versions ultérieures)

Par exemple, vous pouvez utiliser la CLI Docker afin de créer, tester et déployer vos images de conteneur.

Paramètres d’images de conteneur

Lambda prend en charge les paramètres d’images de conteneur suivants dans le fichier Docker :

  • ENTRYPOINT – Spécifie le chemin absolu vers le point d’entrée de l’application.

  • CMD – Spécifie les paramètres que vous souhaitez transmettre avec ENTRYPOINT.

  • WORKDIR – Spécifie le chemin absolu vers le répertoire de travail.

  • ENV – Spécifie une variable d’environnement pour la fonction Lambda.

Note

Lambda ignore les valeurs des paramètres d’image de conteneur non pris en charge dans le fichier Docker.

Pour plus d’informations sur la manière dont Docker utilise les paramètres d’images de conteneur, consultez ENTRYPOINT dans la référence du fichier Docker, sur le site web Docker Docs. Pour plus d’informations sur l’utilisation des paramètres ENTRYPOINT et CMD, consultez Lumière sur les paramètres ENTRYPOINT et CMD dans Docker, sur le blog AWS Open Source.

Vous pouvez spécifier les paramètres d’images de conteneur dans le fichier Docker lorsque vous créez votre image. Vous pouvez également remplacer ces configurations à l’aide de la console Lambda ou de l’API Lambda. Cela vous permet de déployer plusieurs fonctions qui déploient la même image de conteneur, mais avec des configurations de runtime différentes.

Avertissement

Lorsque vous spécifiez ENTRYPOINT ou CMD dans le Dockerfile ou en tant que remplacement, veillez à saisir le chemin absolu. En outre, n’utilisez pas de liens symboliques en tant que point d’entrée du conteneur.

Création d'images à partir d'images de base AWS

Pour créer une image de conteneur pour une nouvelle fonction Lambda, vous pouvez commencer par une image de base AWS pour Lambda. Lambda fournit deux types d’image de base :

  • Image de base multi-architecture

    Spécifiez l’une des principales balises d’image (telles que python:3.9 ou java:11) pour choisir ce type d’image.

  • Image de base spécifique à l’architecture

    Spécifiez une balise d’image avec un suffixe d’architecture. Par exemple, spécifiez 3.9-arm64 pour choisir l’image de base arm64 pour Python 3.9.

Vous pouvez également utiliser une autre image de base à partir d'un autre registre de conteneur. Lambda fournit des clients d’interface de runtime open source que vous ajoutez à une autre image de base pour la rendre compatible avec Lambda.

Note

AWS fournit régulièrement des mises à jour des images de base AWS pour Lambda. Si votre Dockerfile inclut le nom de l'image dans la propriété FROM, votre client Docker extrait la dernière version de l'image du référentiel Amazon ECR. Afin d'utiliser l'image de base mise à jour, vous devez reconstruire votre image de conteneur et mettre à jour le code de la fonction.

Pour créer une image à partir d'une image de base AWS pour Lambda

  1. Sur votre machine locale, créez un répertoire de projets pour votre nouvelle fonction.

  2. Créez un répertoire nommé app dans le répertoire de projets, puis ajoutez votre code de gestionnaire de fonctions au répertoire d’applications.

  3. Utilisez un éditeur de texte créer un nouveau Dockerfile.

    Les images de base AWS fournissent les variables d'environnement suivantes :

    • LAMBDA_TASK_ROOT=/var/task

    • LAMBDA_RUNTIME_DIR=/var/runtime

    Installez toutes les dépendances sous le répertoire ${LAMBDA_TASK_ROOT} à côté du gestionnaire de fonction pour vous assurer que le runtime Lambda peut les localiser lorsque la fonction est appelée.

    L’exemple suivant représente un exemple de fichier Docker pour Node.js, Python et Ruby :

    Node.js 14
    FROM public.ecr.aws/lambda/nodejs:14 # Assumes your function is named "app.js", and there is a package.json file in the app directory COPY app.js package.json ${LAMBDA_TASK_ROOT} # Install NPM dependencies for function RUN npm install # Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile) CMD [ "app.handler" ]
    Python 3.8
    FROM public.ecr.aws/lambda/python:3.8 # Copy function code COPY app.py ${LAMBDA_TASK_ROOT} # Install the function's dependencies using file requirements.txt # from your project folder. COPY requirements.txt . RUN pip3 install -r requirements.txt --target "${LAMBDA_TASK_ROOT}" # Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile) CMD [ "app.handler" ]
    Ruby 2.7
    FROM public.ecr.aws/lambda/ruby:2.7 # Copy function code COPY app.rb ${LAMBDA_TASK_ROOT} # Copy dependency management file COPY Gemfile ${LAMBDA_TASK_ROOT} # Install dependencies under LAMBDA_TASK_ROOT ENV GEM_HOME=${LAMBDA_TASK_ROOT} RUN bundle install # Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile) CMD [ "app.LambdaFunction::Handler.process" ]
  4. Créez votre image Docker à l’aide de la commande docker build. Saisissez un nom pour l’image. L’exemple suivant nomme l’image hello-world.

    docker build -t hello-world .
  5. Démarrez votre image Docker à l'aide de la commande docker run. Pour cet exemple, saisissez hello-world comme nom de l’image.

    docker run -p 9000:8080 hello-world
  6. (Facultatif) Testez votre application localement à l’aide de l’émulateur d’interface d’exécution. À partir d’une nouvelle fenêtre de terminal, publiez un événement sur le point de terminaison suivant au moyen d’une curl commande :

    curl -XPOST "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'

    Cette commande appelle la fonction exécutée dans l’image de conteneur et renvoie une réponse.

Création d'images à partir d'autres images de base

Prérequis

  • L’interface AWS CLI

  • Docker Desktop

  • Le code de votre fonction

Pour créer une image au moyen d’une autre image de base

  1. Choisissez une image de base. Lambda prend en charge toutes les distributions Linux, telles qu’Alpine, Debian et Ubuntu.

  2. Sur votre machine locale, créez un répertoire de projets pour votre nouvelle fonction.

  3. Créez un répertoire nommé app dans le répertoire de projets, puis ajoutez votre code de gestionnaire de fonctions au répertoire d’applications.

  4. Utilisez un éditeur de texte pour créer un nouveau Dockerfile avec la configuration suivante :

    • Définissez la propriété FROM sur l’URI de l’image de base.

    • Ajoutez des instructions pour installer le client d’interface de runtime.

    • Définissez la propriété ENTRYPOINT pour appeler le client d'interface de runtime.

    • Définissez l'argument CMD pour spécifier le gestionnaire de la fonction Lambda.

    L’exemple suivant représente un fichier Docker pour Python :

    # Define function directory ARG FUNCTION_DIR="/function" FROM python:buster as build-image # Install aws-lambda-cpp build dependencies RUN apt-get update && \ apt-get install -y \ g++ \ make \ cmake \ unzip \ libcurl4-openssl-dev # Include global arg in this stage of the build ARG FUNCTION_DIR # Create function directory RUN mkdir -p ${FUNCTION_DIR} # Copy function code COPY app/* ${FUNCTION_DIR} # Install the runtime interface client RUN pip install \ --target ${FUNCTION_DIR} \ awslambdaric # Multi-stage build: grab a fresh copy of the base image FROM python:buster # Include global arg in this stage of the build ARG FUNCTION_DIR # Set working directory to function root directory WORKDIR ${FUNCTION_DIR} # Copy in the build image dependencies COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR} ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ] CMD [ "app.handler" ]
  5. Créez votre image Docker à l’aide de la commande docker build. Saisissez un nom pour l’image. L’exemple suivant nomme l’image hello-world.

    docker build -t hello-world .
  6. (Facultatif) Testez votre application localement à l’aide de l’émulateur d’interface d’exécution.

Chargez l'image dans le référentiel Amazon ECR.

Dans les commandes suivantes, remplacez 123456789012 par votre ID de compte AWS et définissez la valeur de la région sur la région où vous souhaitez créer le référentiel Amazon ECR.

Note

Dans Amazon ECR, si vous réaffectez la balise d’image à une autre image, Lambda ne met pas à jour la version de l’image.

  1. Authentifiez la CLI Docker dans votre registre Amazon ECR.

    aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com
  2. Créez un référentiel dans Amazon ECR à l’aide de la commande create-repository.

    aws ecr create-repository --repository-name hello-world --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
  3. À l’aide de la commande docker push, étiquetez votre image pour qu’elle corresponde au nom de votre référentiel, puis déployez l’image sur Amazon ECR.

    docker tag hello-world:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest

A présent que votre image conteneur réside dans le registre de conteneur Amazon ECR, vous pouvez créer et exécuter la fonction Lambda.

Création d’une image à l’aide de la boîte à outils AWS SAM

Vous pouvez utiliser la boîte à outils AWS Serverless Application Model (AWS SAM) pour créer et déployer une fonction définie en tant qu'image de conteneur. Pour un nouveau projet, vous pouvez utiliser la commande init CLI AWS SAM pour configurer l’échafaudage du projet dans l’environnement d’exécution préféré.

Dans votre modèle AWS SAM, vous définissez le type Runtime sur Image et fournissez l’URI de l’image de base.

Pour plus d’informations, consultez Génération d’applications dans le AWS Serverless Application ModelGuide du développeur.