How to Run a Python Docker Image on AWS Lambda

Summary

This tutorial video guides viewers on deploying a Docker image on AWS Lambda, showcasing the synergy of containerization and serverless computing. It demonstrates creating a Python 'Hello World' application with Docker, highlighting the benefits of using Docker for complex dependencies. The video covers the setup of AWS CDK, Dockerfile creation, local testing, and AWS infrastructure deployment, culminating in a functional Lambda function accessible via an API endpoint. It also addresses potential cold-start performance trade-offs and provides a foundation for developing applications with diverse dependencies.

Takeaways

• 📦 Docker is a containerization platform that packages code and its dependencies into a container for consistent execution across different environments.
• 🚀 AWS Lambda is a serverless compute service that runs code in response to events and charges based on the time the code executes.
• 💡 Combining Docker with AWS Lambda allows for building applications in any language and running them with all necessary dependencies on the cloud at a low cost.
• 🛠️ To get started, you need to have Docker, AWS CLI, and AWS CDK installed, ideally with some experience using them.
• 📝 The script demonstrates creating a Python 'Hello World' application as a Docker image to be deployed on AWS Lambda.
• 🔧 AWS CDK is utilized to define and provision cloud infrastructure through code, which is more efficient than manual console operations.
• 🔑 The script includes creating a Dockerfile that specifies the base image, copies the application and its dependencies, and sets up the execution environment.
• 📝 The Dockerfile uses an AWS Lambda Python 3.11 base image and installs additional dependencies like numpy, which is useful for applications requiring specific packages.
• 🖥️ Before deploying to AWS, the script suggests testing the Docker image locally to ensure it functions as expected.
• 🔄 The script outlines deploying the Docker image to AWS Lambda using AWS CDK, which automates the creation of the necessary cloud resources.
• 🔗 A function URL is created for easy access to the Lambda function, allowing the Docker image to be triggered via an HTTP request.
• ⚠️ The video notes potential issues with architecture mismatches, especially when using different processor architectures like ARM64 or x86.
• 🌡️ Docker Lambda functions may have slower cold-starts compared to native Lambda functions but offer reliability for applications with complex dependencies.

Q & A

What is Docker and why is it useful?

Docker is a way to package your code and its dependencies into a container, ensuring consistent behavior across different environments and machines. This helps avoid unexpected issues that can arise from running the code in different setups.

What is AWS Lambda and how does it work with Docker?

AWS Lambda is a serverless compute service that allows you to run code in response to events without managing servers. By running Docker images on AWS Lambda, you can execute containerized applications on demand, billed by millisecond of usage.

Why combine Docker and AWS Lambda?

Combining Docker and AWS Lambda allows you to build applications in any language and run them in a serverless environment. This combination offers flexibility, low cost, and avoids platform-specific issues by packaging dependencies within the Docker image.

What are the prerequisites for following the tutorial in the video?

To follow along effectively, you need to have Docker, AWS CLI, and AWS CDK installed, along with some experience using these tools.

What is AWS CDK and why is it used in the tutorial?

AWS CDK (Cloud Development Kit) is a tool for defining cloud infrastructure using code. It is used in the tutorial to create the necessary AWS infrastructure for deploying and running the Docker image as a Lambda function.

How do you initialize a CDK project for this tutorial?

You initialize a CDK project by creating a folder for the project, navigating to it, and running the 'cdk init' command. The tutorial uses TypeScript as the language for the CDK application.

What is the purpose of the Dockerfile in this tutorial?

The Dockerfile contains instructions for building the Docker image. It specifies the base image, installs dependencies, and sets up the Python application to be run by AWS Lambda.

How do you build and run the Docker image locally?

To build the Docker image, navigate to the folder containing the Dockerfile and run a Docker build command. To run the image locally, use a Docker run command and test it by sending an HTTP request to the specified port.

What steps are involved in deploying the Docker image to AWS Lambda?

Deploying the Docker image involves setting up AWS CLI, bootstrapping the CDK application, and running 'cdk deploy' to create the necessary AWS resources and upload the Docker image.

What should you check if your deployed Lambda function encounters runtime errors?

If you encounter runtime errors like 'runtime invalid entry point,' ensure that the Lambda architecture matches the architecture of the machine used to build the Docker image. For example, use ARM64 for Apple M1 silicon or x86 for Intel processors.

What are the trade-offs of using Docker functions on AWS Lambda compared to native runtimes?

Docker functions can have slower cold-start times but offer greater reliability for applications with complex dependencies or platform-specific binaries. They simplify development by avoiding platform-specific issues that can arise when deploying to the AWS Lambda environment.

Outlines

00:00

🐳 Introduction to Docker on AWS Lambda

This paragraph introduces the concept of running a Docker image on AWS Lambda. Docker is explained as a containerization tool that ensures code runs consistently across different environments. AWS Lambda is described as a serverless compute service that executes code in response to events, billed per millisecond of usage. The tutorial aims to demonstrate combining Docker with Lambda by creating a Python 'Hello World' application. Prerequisites include having Docker, AWS CLI, and AWS CDK installed, along with some experience with these tools. The process begins with setting up a CDK project using TypeScript and creating a Docker image folder for the Python application and its dependencies.

05:02

🛠️ Building and Testing the Docker Image Locally

The second paragraph details the steps to create a Dockerfile, which is a set of instructions for building the Docker image. It explains how to copy the 'requirements.txt' file and install the numpy package as a dependency within the Docker image. The Dockerfile is then used to build and run the image locally, testing it by sending an HTTP request to the running container. The paragraph also covers creating the necessary AWS infrastructure using the AWS CDK, defining a Lambda function with a Docker image and setting up an API endpoint for easy access. It emphasizes the importance of testing the Docker image locally before deploying it to AWS and provides guidance on configuring the AWS CLI for deployment.

10:07

🚀 Deploying Docker Image to AWS and Testing

The final paragraph outlines the deployment process of the Docker image to AWS using the AWS CDK. It describes the steps to bootstrap the CDK environment, deploy the application, and verify the deployment by accessing the function URL. The paragraph addresses potential issues that may arise, such as architecture mismatches between the local machine and AWS Lambda, and provides a solution for it. It also discusses the trade-offs between using Docker with Lambda versus native Lambda functions, particularly in terms of cold-start performance. The video concludes with an invitation to check the comments for project code and a thank you note to the viewers.

Keywords

💡Docker

Docker is a platform that uses containerization technology to package applications and their dependencies into a portable, consistent, and isolated environment. In the video, Docker is used to create a container for a Python application, ensuring that it runs smoothly across different machines or environments. The script mentions Docker as a way to avoid unexpected problems when deploying applications.

💡AWS Lambda

AWS Lambda is a serverless compute service provided by Amazon Web Services (AWS) that allows users to run code without provisioning or managing servers. The video explains how to run a Docker image on AWS Lambda, emphasizing its on-demand nature and the cost-effectiveness of its pay-per-millisecond billing model.

💡Container

A container in the context of the video refers to a lightweight, standalone, and executable package of software that includes everything needed to run an application as a single unit. The script discusses using Docker to create a container for the Python 'Hello World' application, highlighting the benefits of containerization for application deployment.

💡Serverless

Serverless computing is a cloud computing execution model where the cloud provider fully manages the server, and dynamically manages the allocation of machine resources. The video describes AWS Lambda as a serverless service, meaning that users do not have to manage servers, and they are billed based on usage rather than server capacity.

💡Cloud Development Kit (CDK)

AWS Cloud Development Kit (CDK) is an open-source software development framework to define cloud infrastructure using code and provision it through AWS CloudFormation. The script describes using the CDK to create a project for the application, allowing for infrastructure as code, which streamlines the process of setting up the necessary cloud resources for the Docker image to run on AWS Lambda.

💡Dockerfile

A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. In the video, a Dockerfile is created to provide instructions for building the Docker image of the Python application, which includes specifying the base image, copying files, and setting the default command for the image.

💡Python

Python is a high-level, interpreted programming language known for its readability and efficiency. The video script uses Python to create a 'Hello World' application that serves as an example of how to run a Docker image on AWS Lambda. The script also mentions the use of Python for creating the Lambda function handler.

💡Dependencies

Dependencies in software development refer to other software packages or libraries that a program requires to function properly. The video discusses the use of a 'requirements.txt' file to list all the packages or dependencies needed for the project, such as the 'numpy' package, which is used to demonstrate the handling of external dependencies within a Docker container.

💡API Endpoint

An API endpoint is a specific location in a networked system that is used to send and receive data to and from other programs. The video explains how to create an API endpoint using AWS Lambda, which allows the Docker image to be triggered on-demand when the endpoint is called.

💡Lambda Function Handler

In AWS Lambda, a function handler is the method in your code that processes events. The video script describes creating a Python file named 'main.py' that serves as the Lambda function handler, executing the 'hello world' message and generating a random matrix using the 'numpy' package when the Lambda function is invoked.

💡Cold-start

Cold-start refers to the initial startup latency that occurs when a cloud function is invoked for the first time or after not being used for a period. The video mentions that Docker Lambda functions may have a slower cold-start compared to native Python Lambda functions due to the need to initialize the Docker runtime environment.

Highlights

Docker images can be run on AWS Lambda, offering a serverless cloud computing solution.

AWS Lambda is billed by millisecond of usage, making it an extremely cost-effective option.

Docker and Lambda combined allow for building applications in any language with any dependencies.

The tutorial demonstrates creating a Python 'Hello World' application as a Docker image for AWS Lambda.

Prerequisites for the project include Docker, AWS CLI, and AWS CDK installation and familiarity.

AWS CDK is used to define cloud infrastructure as code, simplifying the setup process.

A Docker image folder with a Python app and a Dockerfile is necessary for the project.

The Python file 'main.py' serves as the Lambda function handler executing the 'hello world' function.

Docker is particularly useful for Python applications with many dependencies or platform-specific binaries.

The 'numpy' package is demonstrated as an example of an external dependency in the Python application.

A Dockerfile is created with instructions to build the Docker image from an AWS Lambda Python base image.

The Dockerfile includes steps to copy the 'requirements.txt' and 'main.py' to the Lambda task root.

Local testing of the Docker image is recommended before uploading it to AWS.

AWS infrastructure for the Lambda function and API endpoint is created using AWS CDK.

The Lambda function is configured with a Docker image, memory size, timeout, and architecture.

A function URL is added for easy access to the Lambda function via an API endpoint.

AWS CLI must be configured with the correct permissions to deploy the Docker image to AWS.

CDK deployment involves bootstrapping and deploying the application to create AWS resources.

The function URL output allows testing of the deployed Lambda function directly from the browser.

Potential issues with architecture mismatch between the local machine and Lambda need to be checked.

Docker Lambda functions may have slower cold-starts but offer reliability with runtime dependencies.

The tutorial concludes with the successful deployment of a Docker Python function on AWS Lambda.

Transcripts

Hey everyone. In this video, I'm going to show

you how to run a Docker image on AWS Lambda.

Docker is a way to put all of your code into

a container. That way you won't encounter

unexpected problems when you run it on a different

machine or a different environment.

AWS Lambda is a cloud compute service. We can

use this to run our Docker image on demand,

just like a function. And we can make it

run whenever a user calls our API endpoint.

It's completely serverless, so we get billed by millisecond

of usage. But it is extremely cheap.

Docker and Lambda are amazing together because

it means that you can build any type of application

you want in any language you want, and then

run it on the cloud for a really low cost.

Today, we're going to learn how to use this by creating

a Python "Hello World" application that we're

going to run as a Docker image on AWS Lambda.

To follow along effectively with this project,

you'll need to have Docker, AWS CLI and

AWS CDK installed. And it will be good if you

have some experience with them as well.

I'm going to start by creating a CDK project for this

app. AWS CDK—or "Cloud Development Kit"—is a tool

we can use to create our cloud infrastructure.

That way, we can define our cloud infrastructure using

code instead of having to click things in the console

or having to do everything in the command line.

Let's make a folder for our CDK project.

When you're in the folder, you can run the "cdk

init" command to create the CDK application.

I'm going to use the language TypeScript for the CDK application.

This should finish after about a minute and

we can open this directory up in our code editor.

Next, we have to create our Docker image folder.

That means we'll have our Python app in a

folder and a Dockerfile to turn that app into

an image with all of its runtime dependencies.

Back in our project, I'm going to create a folder

called "image". Inside that image folder, I'm

going to create another folder called "src".

In the "image/src" folder, I'm going to create my Python

application file, which I'm going to call "main.py".

This Python file is going to be my Lambda function

handler. This is going to be the code that

executes when my Lambda function is called.

And for this, it's just going to be a really basic

"hello world" function. It simply returns

a status code of 200 (which means it was successful)

and a "hello world" message in the body.

But if you only wanted to run a simple Python script by

itself, then AWS actually has a native Python runtime.

So if "hello world" was all you wanted to do, you could

just use that. You don't need to use Docker.

Where Docker starts to become really useful

is if you actually need a lot of packages or

dependencies with your Python application.

That's because many popular Python packages actually use a lot

of platform specific binaries or code behind the scenes.

And it can be really difficult to get these binaries

installed or working correctly for the

Amazon Linux runtime that AWS Lambda uses.

That's why a lot of people who develop Python Lambda functions

find that they have an error in their AWS Lambda

when the same Python code works fine on their machine.

With Docker though, this is really easy to fix.

Everything inside the image will be run as is.

So to demonstrate that, let's also install the

"numpy" package and use that in our code.

Go to our image folder and in here we're going to create a

new file and we're going to call it "requirements.txt".

And in here we can use this to list all of the packages

or dependencies we need for our project.

So here I'm going to add numpy.

And now I've gone back to my Python function code

and I've included numpy as a dependency.

And I've also used it to generate a random matrix

so that I can use it as part of my application.

And I'll print it out here as well.

So now I have a Python hello world application that also uses an external package.

And I'm ready to build it into a Docker image.

To turn this app into a Docker image, we'll need a Dockerfile.

Which is basically just a set of instructions on how to build the image.

So go to your image folder and let's create a new file here.

We have to call it "Dockerfile".

And the name here does matter. It has to be

named "Dockerfile" with the capital "D".

The first line of our Dockerfile is going to tell us where to base this image on.

So we're not building the image from scratch.

We're actually going to use this base image,

which is an AWS Lambda Python 3.11 image.

And then add our stuff into this image to build our own image.

And if you want to use a different base image,

then the AWS documentation has a list of

all the different base images they publish.

So you can click in the link below (in the video description)

to go to this page and look at all the

different Python versions you can choose from.

Or if you don't want to use Python, then AWS

also provides a bunch of base images in other

languages too, such as TypeScript and Java.

The next line we need to add to the Dockerfile is

to copy this requirements text, which is here.

So when we run this Dockerfile, the root directory that it

works with is basically wherever this Dockerfile is based.

So because the Dockerfile is in the same folder as requirements

text, we can just call it requirements text

without having to have an absolute path to the file.

And we want to copy this into the Lambda "task root".

So this is going to be an environment variable that

is available to the Dockerfile when it's building.

And this is basically where Lambda will consider as the root path for its function.

Next, we're going to want to run "pip install" on the

requirements text file, which is how we get our

numpy dependency installed into the Docker image.

My next command is going to copy all the files in this source folder.

So that's going to be my main.py application file.

And it's also going to put it in the Lambda task root.

And the last line is going to set the default command

of the Dockerfile to this handler function.

This is going to be "main", which is the name of this file,

and then "handler", which is the name of the function.

So this is what the Lambda function runs when it is used.

Now your Dockerfile is ready and you can build an image from it.

But before we upload it to AWS, you might want to test it locally.

So first go back to your terminal and then navigate

to the folder where your Dockerfile is.

So that's the "image" folder in this project.

And then build your Dockerfile.

And you can do that using a command like this.

And once you've built your Dockerfile, you have to run it.

So you can do that using a command like this.

And here I'm going to run it on port 9000.

And once the image is running, you can go to another terminal

and then send an HTTP request to it like this.

And this will actually run the function inside your Dockerfile.

So if I run that, you can see that I get my status code 200

and my "hello world" message and even my numpy matrix.

Now let's go ahead and create the AWS infrastructure

that will have the Lambda function and the

API endpoint that we can use to run this image.

Go to the "lib" folder in your project and you'll find this AWS stack file here.

And it should look something like this.

So we're going to delete all this commented code because we don't need that.

And at the top we're going to import AWS Lambda.

And in here, let's create our Docker image function.

I'm going to call this Docker function and it's

going to be a Lambda "DockerImageFunction".

And here are the parameters.

For the code, we're going to use Docker image code from asset.

And this is going to be a directory where we have the Dockerfile.

When we compile this, CDK will go into this folder and

it will use this Dockerfile to create an image.

And it's going to upload that image and associate it

with this Lambda function so that we can use it.

For the memory size, I'm going to put 1024MB and then

I'm going to give it a timeout of 10 seconds.

By default, I think Lambda has quite a low timeout.

Maybe it's like 2 seconds and that might not be enough

time for a Docker image to start up and run.

And for the architecture, I'm going to put architecture "arm64".

Now, most of you probably don't need this.

So this is probably going to be fine to have it like this.

But because I'm running this on a Mac M1, I need the

architecture of the Lambda function to match the

architecture that I'm building this image with.

So when I run it on this machine, it's going to be built with "arm64".

If I don't do this, it's going to fail.

But you can choose arm64 or the Intel one if you are using a Windows

or if you know that you are using an Intel processor.

Or just leave it out completely if you're unsure.

Now, to make the Lambda function easily accessible with

an API endpoint, I'm also going to add a function URL.

So to do that, you can use this add function URL

method on your Lambda function to create a URL

endpoint that you can just use right away.

But I'm going to set the arguments here so that auth type is

"NONE" so that we don't need to be authenticated to use it.

Anyone with a URL will be able to call it.

And I'm also going to set the CORS header to allow all

HTTP methods and allow all headers and origins.

And finally, to actually see the value of this function URL,

we're also going to create an output variable for it.

So I'm going to do like that so that when we build our CDK application,

we actually get this function URL in a string.

So this should be all the infrastructure code we need.

And because we also have the Python application

file ready and the Docker image file

ready, we should be ready to deploy this.

Now you're ready to deploy your Docker image to AWS.

But before you do that, please make sure that

you have your AWS CLI ready and configured

because you will need the permissions

from that to interact with your AWS account.

As a sanity check, you can type `aws sts get-caller-identity`.

And if your AWS CLI is configured properly, you should get a response like this.

Now let's go back to our project root directory and set up CDK.

So in your project root folder, type "cdk bootstrap".

And here you can even choose the region you

want to bootstrap in or leave it blank if you

just want to use your default AWS region.

Bootstrapping will create a bunch of resources

in your AWS account that CDK will need.

But you only need to run it once per account per region.

And because I've already run it for this account in this region, nothing happens.

And that's fine as well.

With bootstrapping completed, we can now run

"cdk deploy" to deploy our application.

And the first time you run this, you might have to press yes

to confirm that you do want to create these resources.

And you can see here it's actually building and

publishing our image to this private repo.

After a couple of minutes, it should finish deploying.

And you can find the URL for the function right here

in this function value output that we've created.

And we can try out the function by just clicking on this URL.

And here you can see that our function returns "hello world from Lambda".

And it's even returned our numpy matrix for us.

If you go to your AWS console, you'll see this function created here.

And if you click into it, you'll see that there's a function URL.

And it's also using this Docker image that we created.

Now if you get up to this point and you can't

run the function or it has an error like

runtime invalid entry point, then double check

what architecture you're using because

you could be using the wrong Lambda architecture

for the machine that you're built with.

So in this one, I used an ARM64 architecture

because I'm using an M1 Apple silicon Mac.

But if you're using an Intel or a Windows computer,

you might need to use the x86 architecture instead.

Otherwise, I hope this worked for you and that you

have a working Lambda Docker Python function.

And you can use this as a basis to start developing your

app and use whatever packages and dependencies you want.

Now Docker Lambda functions are a little bit slower than

native Python Lambda functions on the cold-start.

The cold-start is when you first use the function after

you haven't used it for 15 minutes because Lambda

will have to kind of create the whole runtime again.

But it is more reliable if you do need to have

runtime dependencies because you don't have to

worry about having platform specific bugs or

errors appear when you move from your development

environment to the Lambda cloud environment.

This is especially true if you use packages that

are heavy on things like math, cryptography

or basically anything that tends to use platform

specific binaries to do the heavy lifting.

So there is a bit of a trade off, but if you want

an easier development experience and you

don't mind the slower cold-start, then I do think

that Docker functions are the way to go.

Anyways, I hope you enjoyed this video. You

can check in the comments for the code for

this project. And thank you for watching.