Creación de imágenes de contenedor de Lambda

AWS proporciona un conjunto de imágenes base de código abierto que puede utilizar para crear la imagen contenedor. Estas imágenes base incluyen un cliente de interfaz de tiempo de ejecución para administrar la interacción entre Lambda y el código de función.

Para ver aplicaciones de ejemplo, incluidos un ejemplo de Node.js y un ejemplo de Python, vea Soporte de imágenes de contenedor para Lambda en el AWS Blog.

Para reducir el tiempo que tardan las funciones de contenedor de Lambda en activarse, consulte Uso de compilaciones de varias fases en la documentación de Docker. Para crear imágenes de contenedores eficientes, siga las Prácticas recomendadas para escribir Dockerfiles.

nota

Las imágenes de contenedor no son compatibles con las funciones de Lambda en la región de Oriente Medio (EAU).

Temas

• Imágenes base para Lambda
• Pruebas de imágenes de contenedor Lambda en forma local
• Requisitos previos
• Tipos de imagen
• Herramientas para contenedores
• Configuración de imagen de contenedor
• Creación de imágenes a partir de imágenes base de AWS
• Creación de imágenes a partir de imágenes base alternativas
• Cargue la imagen en el repositorio Amazon ECR
• Crear una imagen utilizando el kit de herramientas AWS SAM

Requisitos previos

Para implementar una imagen de contenedor en Lambda, necesita la AWS CLI y la CLI de Docker. Además, tenga en cuenta los siguientes requisitos:

• La imagen contenedor debe implementar la API de tiempo de ejecución de Lambda. Los clientes de interfaz de tiempo de ejecución de AWS código abierto implementan la API. Puede agregar un cliente de interfaz de tiempo de ejecución a su imagen base preferida para que sea compatible con Lambda.

• La imagen de contenedor debe poder ejecutarse en un sistema de archivos de solo lectura. Su código de función puede acceder a un directorio /tmp con escritura permitida con entre 512 MB y 10,240 MB, en incrementos de 1 MB, de almacenamiento.

• El usuario predeterminado de Lambda debe ser capaz de leer todos los archivos necesarios para ejecutar el código de función. Lambda sigue las prácticas recomendadas de seguridad definiendo un usuario predeterminado de Linux con permisos de menos privilegios. Compruebe que el código de su aplicación no depende de los archivos que otros usuarios de Linux tienen restricciones para ejecutar.

• Lambda solo admite imágenes de contenedor basadas en Linux.

• Lambda proporciona imágenes base de varias arquitecturas. Sin embargo, la imagen que crea para su función debe tener como destino a solo una de las arquitecturas. Lambda no admite funciones que utilizan imágenes de contenedor de varias arquitecturas.

Tipos de imagen

Puede utilizar una imagen base AWS alternativa proporcionada, como Alpine o Debian. Lambda admite cualquier imagen que se ajuste a uno de los siguientes formatos de manifiesto de imagen:

• Docker Image Manifest V2 Schema 2 (usado con Docker versión 1.10 y posteriores)

• Especificaciones de la iniciativa de contenedores abiertos (OCI) (versión 1.0.0 y posteriores)

Lambda admite un tamaño máximo de imagen sin comprimir de 10 GB, incluidas todas las capas.

Herramientas para contenedores

Para crear la imagen contenedor, puede utilizar cualquier herramienta de desarrollo que admita uno de los siguientes formatos de manifiesto de imagen contenedor:

• Docker Image Manifest V2 Schema 2 (usado con Docker versión 1.10 y posteriores)

• Especificaciones de OCI (v1.0.0 y superior)

Por ejemplo, puede utilizar la CLI de Docker para compilar, probar e implementar las imágenes de contenedor.

Configuración de imagen de contenedor

Lambda admite la siguiente configuración de imagen contenedor en Dockerfile:

• ENTRYPOINT: especifica la ruta absoluta al punto de entrada de la aplicación.

• CMD: especifica los parámetros que desea pasar con ENTRYPOINT.

• WORKDIR: especifica la ruta absoluta al directorio de trabajo.

• ENV: especifica una variable de entorno para la función de Lambda.

nota

Lambda ignora los valores de cualquier configuración de imagen contenedor no admitida en Dockerfile.

Para obtener más información acerca de cómo Docker utiliza la configuración de la imagen contenedor, consulte ENTRYPOINT en la referencia Dockerfile en el sitio Web Docker Docs. Para obtener más información acerca del uso de ENTRYPOINT y CMD, vea Desmitificar ENTRYPOINT y CMD en Docker en el blog de código AWS abierto.

Puede especificar la configuración de la imagen contenedor en Dockerfile cuando construya la imagen. También puede anular estas configuraciones mediante la consola de Lambda o la API de Lambda. Esto le permite implementar varias funciones que implementan la misma imagen contenedor pero con diferentes configuraciones de tiempo de ejecución.

aviso

Cuando especifique ENTRYPOINT o CMD en el Dockerfile o como anulación, asegúrese de introducir la ruta absoluta. Además, no utilice enlaces simbólicos como punto de entrada al contenedor.

Creación de imágenes a partir de imágenes base de AWS

Para crear una imagen contenedor para una nueva función, puede comenzar con una imagen base AWS para Lambda. Lambda ofrece dos tipos de imágenes base:

• Imagen base de varias arquitecturas

  Especifique una de las etiquetas de imagen principales (como python:3.9 o java:11) para elegir este tipo de imagen.

• Imagen base específica de la arquitectura

  Especifique una etiqueta de imagen con un sufijo de arquitectura. Por ejemplo, especifique 3.9-arm64 para elegir la imagen base arm64 para Python 3.9.

También puede utilizar una imagen base alternativa de otro registro de contenedores. Lambda proporciona clientes de interfaz de tiempo de ejecución de código abierto que se agregan a una imagen base alternativa para hacerla compatible con Lambda.

nota

AWS proporciona periódicamente actualizaciones a las imágenes base AWS para Lambda. Si su Dockerfile incluye el nombre de la imagen en la propiedad FROM, el cliente Docker extrae la última versión de la imagen del repositorio de Amazon ECR. Para utilizar la imagen base actualizada, debe reconstruir la imagen contenedor y actualizar el código de función.

Para crear una imagen a partir de una imagen base AWS para Lambda

1. En su máquina local, cree un directorio de proyecto para su nueva función.

2. Cree un directorio llamado app en el directorio del proyecto y, a continuación, agregue el código del controlador de funciones al directorio de la aplicación.

3. Utilice un editor de texto para crear un nuevo Dockerfile.

   Las imágenes AWS base proporcionan las siguientes variables de entorno:

   • lambda_task_root=/var/tarea

   • Lambda_runtime_dir=/var/Runtime

   Instale cualquier dependencia en el directorio ${LAMBDA_TASK_ROOT} junto con el controlador de funciones para asegurarse de que el tiempo de ejecución de Lambda pueda localizarlas cuando se invoca la función.

   En el siguiente ejemplo se muestra un archivo Docker para Node.js, Python y Ruby:

   Node.js 18

   FROM public.ecr.aws/lambda/nodejs:18
   
   # 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
   
   # 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}"
   
   # Copy function code
   COPY app.py ${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 dependency management file
   COPY Gemfile ${LAMBDA_TASK_ROOT}
   
   # Install dependencies under LAMBDA_TASK_ROOT
   ENV GEM_HOME=${LAMBDA_TASK_ROOT}
   RUN bundle install
   
   # Copy function code
   COPY app.rb ${LAMBDA_TASK_ROOT}
   
   # Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
   CMD [ "app.LambdaFunction::Handler.process" ]

4. Cree su imagen Docker con el comando docker build. Introduzca un nombre para la imagen. En el ejemplo siguiente se asigna un nombre a la imagen hello-world.

   docker build -t hello-world .   

5. Inicie la imagen de Docker con el comando docker run. Para este ejemplo, escriba hello-world como el nombre de la imagen.

   docker run -p 9000:8080 hello-world 

6. (Opcional) Pruebe su aplicación localmente utilizando el emulador de interfaz de tiempo de ejecución. Desde una nueva ventana de terminal, publique un evento en el siguiente punto de enlace mediante un comando curl:

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

   Este comando invoca la función que se ejecuta en la imagen contenedor y devuelve una respuesta.

Creación de imágenes a partir de imágenes base alternativas

Requisitos previos

• Con la AWS CLI

• Docker de escritorio

• Su código de función

Para crear una imagen utilizando una imagen base alternativa

1. Seleccione una imagen base. Lambda admite todas las distribuciones Linux, como Alpine, Debian y Ubuntu.

2. En su máquina local, cree un directorio de proyecto para su nueva función.

3. Cree un directorio llamado app en el directorio del proyecto y, a continuación, agregue el código del controlador de funciones al directorio de la aplicación.

4. Utilice un editor de texto para crear un nuevo Dockerfile con la siguiente configuración:

   • Establezca la propiedad FROM en el URI de la imagen base.

   • Agregue instrucciones para instalar el cliente de interfaz de tiempo de ejecución.

   • Establezca la propiedad ENTRYPOINT para invocar el cliente de interfaz de tiempo de ejecución.

   • Establezca el argumento CMD para especificar el controlador de función de Lambda.

   En el siguiente ejemplo se muestra un archivo Dockerfile para 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. Cree su imagen Docker con el comando docker build. Introduzca un nombre para la imagen. En el ejemplo siguiente se asigna un nombre a la imagen hello-world.

   docker build -t hello-world .    

6. (Opcional) Pruebe la aplicación localmente utilizando el emulador de interfaz de tiempo de ejecución.

Cargue la imagen en el repositorio Amazon ECR

En los siguientes comandos, sustituya 123456789012 por el ID de su cuenta de AWS y, como valor de la región, establezca la región en la que desea crear el repositorio de Amazon ECR.

nota

En Amazon ECR, si reasigna la etiqueta de imagen a otra imagen, Lambda no actualiza la versión de la imagen.

1. Autenticar la CLI de Docker en su registro 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. Crear un repositorio en Amazon ECR, usando el comando create-repository.

   aws ecr create-repository --repository-name hello-world --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

3. Etiquete la imagen para que coincida con el nombre de su repositorio e implemente la imagen en Amazon ECR con el comando docker push

   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        

Ahora que la imagen de contenedor reside en el registro de contenedores de Amazon ECR, puede crear y ejecutar la función de Lambda.

Crear una imagen utilizando el kit de herramientas AWS SAM

Puede utilizar el kit de herramientas AWS Serverless Application Model (AWS SAM) para crear e implementar una función definida como una imagen contenedor. Para un proyecto nuevo, puede utilizar el comando init AWS SAM CLI para configurar el andamio del proyecto en su tiempo de ejecución preferido.

En la plantilla AWS SAM, establece el Runtime tipo Image y proporciona el URI de la imagen base.

Para obtener más información, consulte Creación de aplicaciones en la Guía para desarrolladores de AWS Serverless Application Model.