Running Container Images as Lambda Functions on AWS

Table of Contents


Serverless computing has revolutionized the way applications are developed and deployed in the cloud. AWS Lambda, one of the key services provided by Amazon Web Services (AWS), allows developers to run code without the need to provision or manage servers. While Lambda has traditionally supported running code in various programming languages, AWS has recently introduced the ability to run container images as Lambda functions. This exciting feature opens up new possibilities for developers seeking to leverage the benefits of both Serverless computing and containerization. In this blog post, we will explore how to run container images as Lambda functions on AWS.

Benefits of Running Container Images as Lambda Functions

  1. Increased Flexibility: Containers provide a standardized and portable way to package applications and their dependencies. Running container images as Lambda functions enables developers to bring their own runtime environment, giving them greater flexibility in choosing libraries, tools, and configurations. This flexibility allows for easier migration of existing containerized applications to Lambda and the ability to customize the runtime environment to meet specific application requirements.
  2. Simplified Packaging: With container images, you can package your entire application stack, including the runtime, dependencies, and code, into a single artifact. This makes it easier to manage and deploy complex applications, reducing the chances of version conflicts and ensuring consistency across different environments. You can include all the necessary files, libraries, and resources within the container image, making it a self-contained unit that is easy to distribute and share.
  3. Use Case Examples: Running container images as Lambda functions opens up a wide range of use cases where the benefits of both Serverless computing and containerization can be leveraged. For example, you can use container-based Lambdas for running machine learning models, data processing pipelines, or applications with complex dependencies. Containerization provides the flexibility to bundle all the necessary components, ensuring smooth execution and simplified deployment.

Getting Started with Container Image Support in AWS Lambda

To start running container images as Lambda functions, follow these steps:

1. Build and package your container image

Create a Dockerfile in your project directory with the necessary instructions to build your application’s runtime environment and copy the code into the image. Here’s an example Dockerfile:



CMD ["app.lambda_handler"]

In this example, we use the official AWS Lambda base image for Python 3.8, copy the file into the image, and specify the command to execute when the Lambda function is invoked.

2. Push the container image to Amazon Elastic Container Registry (ECR)

To push your container image to Amazon Elastic Container Registry (ECR), you need to create an ECR repository and configure the necessary permissions. Follow these steps:

  • Create an ECR repository using the AWS Management Console or the AWS CLI.
  • Ensure you have the required IAM role and permissions to push the image to ECR. The IAM role should have the necessary permissions to interact with ECR, such as ecr:GetAuthorizationToken, ecr:BatchGetImage, and ecr:BatchCheckLayerAvailability.

Build and tag your Docker image using the following commands:

docker build -t <your-repository-name>:<your-image-tag> .docker tag <your-repository-name>:<your-image-tag> <your-account-id>.dkr.ecr.<your-region><your-repository-name>:<your-image-tag>

Log in to ECR using the AWS CLI:

aws ecr get-login-password --region <your-region> | docker login --username AWS --password-stdin <your-account-id>.dkr.ecr.<your-region>

Push the image to ECR:

docker push <your-account-id>.dkr.ecr.<your-region><your-repository-name>:<your-image-tag>

Make sure to replace <your-region>, <your-account-id>, <your-repository-name>, and <your-image-tag> with the appropriate values.

3. Create a Lambda function using the container image

Now, let’s create a Lambda function using the container image you pushed to ECR. You’ll need an IAM role with the required permissions to create and execute Lambda functions. The IAM role should have the following permissions:

  • lambda:CreateFunction
  • lambda:UpdateFunctionCode
  • lambda:UpdateFunctionConfiguration
  • lambda:PublishVersion
  • lambda:GetFunction
  • lambda:GetFunctionConfiguration
  • lambda:InvokeFunction

Additionally, you’ll need to add the following permissions to the IAM role to fetch the images from ECR:

  • ecr:GetAuthorizationToken
  • ecr:BatchGetImage

Follow these steps:

  • Create an IAM role with the necessary permissions to execute Lambda functions. You can use the AWSLambdaBasicExecutionRole policy as a starting point and attach additional policies as needed.
  • In the AWS Lambda console, click on “Create function” to begin setting up your Lambda function. Provide a name, such as “hello-world-lambda-container-function,” and choose the “Container image” option for the runtime.
  • In the configuration section of the Lambda function, specify the image URI as <your-account-id>.dkr.ecr.<your-region><your-repository-name>:<your-image-tag>. Set the memory allocation, timeout, and other function settings according to your requirements.

4. Test the Lambda function from the Lambda console

To test your Lambda function, you can use the “Test” feature provided in the AWS Lambda console. Follow these steps:

  • In the AWS Lambda console, select your Lambda function.
  • Click on the “Test” button.
  • Provide a sample event, such as {"message": "Hello, World!"}.
  • Click on the “Create” button to create a test event.
  • Click on the “Test” button again to invoke the Lambda function with the test event.
  • Verify the function’s output and any logs generated.

5. Deploy the Lambda function

Once you have successfully tested your Lambda function, you can deploy it to make it ready for invocation. Click on the “Deploy” button in the AWS Lambda console. This will publish the latest version of your Lambda function and make it available for execution.


By following the steps outlined above, you can successfully run container images as Lambda functions on AWS. This provides you with the flexibility of containerization combined with the Serverless benefits of AWS Lambda. Remember to tailor the Dockerfile, IAM roles, and the Lambda function configuration according to your specific application requirements. Happy Serverless container development!

About the Author

Deepali Sonune is a DevOps engineer with 10+ years of industry experience. She has been developing high-performance DevOps solutions with stringent security and governance requirements in AWS for 7+ years. She also works with developers and IT to oversee code releases, combining an understanding of both engineering and programming.

Leave a Reply

Your email address will not be published. Required fields are marked *