Lambda and Docker

Introduction

We saw in previous classes why Docker is important for ML. In this class, we will see how to create Docker images and deploy Lambda functions from them.

Create Source Code

Consider the following lambda function code:

import sys

def hello_from_docker(event, context):
    return {
        "created_by": "your name",
        "message": "Hello World!",
        "version": sys.version
    }

Our goal is to deploy this function with Docker + Lambda.

Create Image

FROM public.ecr.aws/lambda/python:3.10

# Copy requirements.txt
COPY requirements.txt ${LAMBDA_TASK_ROOT}

# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}

# Install the specified packages
RUN pip install -r requirements.txt

# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.hello_from_docker" ]

Let's name the image lambda-ex-image and give it the test tag:

$ docker build --platform linux/amd64 -t lambda-ex-image:test .

Test locally

Before deploying, let's test the function locally.

Start the Docker image with the docker run command:

$ docker run -p 9500:8080 lambda-ex-image:test

Let's make a request with:

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

If that doesn't work, try with double quotes:

$ curl "http://localhost:9500/2015-03-31/functions/function/invocations" -d "{}"

import requests
import json

url = "http://localhost:9500/2015-03-31/functions/function/invocations"
data = {}

response = requests.post(url, json=data, timeout=2)

response_json = response.json()

print(f"Status code: {response.status_code}")
print("Response:")
print(json.dumps(response_json, indent=4))

Container Registry

The Amazon Elastic Container Registry (ECR) is a fully managed service that allows you to store, manage, and deploy container images. With ECR, you can securely store and manage your Docker container images.

Let's upload our image to ECR. But first, we need to create a container repository:

import boto3
import os
from dotenv import load_dotenv

load_dotenv()

# Provide a name like test1-mlops-<INSPER_USERNAME>
repository_name = "test1-mlops-xxxxx"

# Create a Boto3 client for ECR
ecr_client = boto3.client(
    "ecr",
    aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
    aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
    region_name=os.getenv("AWS_REGION"),
)

response = ecr_client.create_repository(
    repositoryName=repository_name,
    imageScanningConfiguration={"scanOnPush": True},
    imageTagMutability="MUTABLE",
)

print(response)

print(f"\nrepositoryArn: {response['repository']['repositoryArn']}")
print(f"repositoryUri: {response['repository']['repositoryUri']}")

$ repository_name="test1-mlops-xxxxxx"

$ aws ecr create-repository \
    --repository-name "$repository_name" \
    --image-scanning-configuration scanOnPush=true \
    --image-tag-mutability MUTABLE \
    --query 'repository.{repositoryArn:repositoryArn, repositoryUri:repositoryUri}' \
    --output text

Upload Image to ECR

Before uploading our Docker image to ECR, we need to configure the AWS Command Line Interface (AWS CLI). If you didn't, check this out in our previous class.

Let's authenticate and login to ECR using the Docker CLI:

$ aws ecr get-login-password --region us-east-2 --profile mlops | docker login --username AWS --password-stdin AWS_ACCOUNT_ID.dkr.ecr.us-east-2.amazonaws.com

Then, we will run the docker tag command to tag our local Docker image into your Amazon ECR repository as the latest version by doing:

$ docker tag lambda-ex-image:test REPOSITORY_URI:latest

And push image to ECR with:

$ docker push REPOSITORY_URI:latest

Create Function

Now we can create the lambda function from the image already stored in the ECR.

To do this, run:

import boto3
import os
from dotenv import load_dotenv

load_dotenv()

# Provide function name: "ex_docker_<INSPER_USERNAME>"
function_name = ""

# Provide Image URI from before
image_uri = ""

lambda_role_arn = os.getenv("AWS_LAMBDA_ROLE_ARN")

# Create a Boto3 client for AWS Lambda
lambda_client = boto3.client(
    "lambda",
    aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
    aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
    region_name=os.getenv("AWS_REGION"),
)

response = lambda_client.create_function(
    FunctionName=function_name,
    PackageType="Image",
    Code={"ImageUri": image_uri},
    Role=lambda_role_arn,
    Timeout=30,  # Optional: function timeout in seconds
    MemorySize=128,  # Optional: function memory size in megabytes
)

print("Lambda function created successfully:")
print(f"Function Name: {response['FunctionName']}")
print(f"Function ARN: {response['FunctionArn']}")

Proceed to the APS!

References

• https://docs.aws.amazon.com/lambda/latest/dg/python-image.html#python-image-instructions
• https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html