Creating Lambda container images

On your local machine, create a project directory for your new function.

Create a directory named app in the project directory, and then add your function handler code to the app directory.

Use a text editor to create a new Dockerfile.

The Amazon base images provide the following environment variables:

Install any dependencies under the ${LAMBDA_TASK_ROOT} directory alongside the function handler to ensure that the Lambda runtime can locate them when the function is invoked.

The following shows an example Dockerfile for Node.js, Python, and Ruby:

Build your Docker image with the docker build command. Enter a name for the image. The following example names the image hello-world.

docker build -t hello-world .   

Start the Docker image with the docker run command. For this example, enter hello-world as the image name.

docker run -p 9000:8080 hello-world 

(Optional) Test your application locally using the runtime interface emulator. From a new terminal window, post an event to the following endpoint using a curl command:

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

This command invokes the function running in the container image and returns a response.

Choose a base image. Lambda supports all Linux distributions, such as Alpine, Debian, and Ubuntu.

On your local machine, create a project directory for your new function.

Create a directory named app in the project directory, and then add your function handler code to the app directory.

Use a text editor to create a new Dockerfile with the following configuration:

The following example shows a Dockerfile for 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" ]
        

Build your Docker image with the docker build command. Enter a name for the image. The following example names the image hello-world.

docker build -t hello-world .    

(Optional) Test your application locally using the Runtime interface emulator.

Run the get-login-password command to authenticate the Docker CLI to your Amazon ECR registry.

aws ecr get-login-password --region cn-north-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn

Create a repository in Amazon ECR using the create-repository command.

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

If successful, you see a response like this:

{
    "repository": {
        "repositoryArn": "arn:aws:ecr:cn-north-1:111122223333:repository/hello-world",
        "registryId": "111122223333",
        "repositoryName": "hello-world",
        "repositoryUri": "111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

Copy the repositoryUri from the output in the previous step.

Run the docker tag command to tag your local image into your Amazon ECR repository as the latest version. In this command:

docker tag docker-image:test 111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world:latest

Run the docker push command to deploy your local image to the Amazon ECR repository. Make sure to include :latest at the end of the repository URI.

docker push 111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world:latest

Create an execution role for the function, if you don't already have one. You need the Amazon Resource Name (ARN) of the role in the next step.

Create the Lambda function. For ImageUri, specify the repository URI from earlier. Make sure to include :latest at the end of the URI.

aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world:latest \
  --role arn:aws:iam::111122223333:role/lambda-ex

Invoke the function.

aws lambda invoke --function-name hello-world response.json

You should see a response like this:

{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

To see the output of the function, check the response.json file.