Introducing the Amazon Linux 2023 runtime for AWS Lambda
This post is written by Rakshith Rao, Senior Solutions Architect.
It is based on the Amazon Linux 2023 minimal container image release and has several improvements over Amazon Linux 2 (AL2), such as a smaller deployment footprint, updated versions of libraries like
glibc, and a new package manager.
What are OS-only Lambda runtimes?
Lambda runtimes define the execution environment where your function runs. They provide the OS, language support, and additional settings such as environment variables and certificates.
Lambda provides managed runtimes for Java, Python, Node.js, .NET, and Ruby. However, if you want to develop your Lambda functions in programming languages that are not supported by Lambda’s managed language runtimes, the ‘provided’ runtime family provides an OS-only environment in which you can run code written in any language. This release extends the provided runtime family to support Amazon Linux 2023.
Customers use these OS-only runtimes in three common scenarios. First, they are used with languages that compile to native code, such as Go, Rust, C++, .NET Native AOT and Java GraalVM Native. Since you only upload the compiled binary to Lambda, these languages do not require a dedicated language runtime, they only require an OS environment in which the binary can run.
Second, the OS-only runtimes also enable building third-party language runtimes that you can use off the shelf. For example, you can write Lambda functions in PHP using Bref, or Swift using the Swift AWS Lambda Runtime.
Third, you can use the OS-only runtime to deploy custom runtimes, which you build for a language or language version which Lambda does not provide a managed runtime. For example, Node.js 19 – Lambda only provides managed runtimes for LTS releases, which for Node.js are the even-numbered releases.
New in Amazon Linux 2023 base image for Lambda
AL2023 base image for Lambda is based on the AL2023-minimal container image and includes various package updates and changes compared with
The version of
glibc in the AL2023 base image has been upgraded to 2.34, from 2.26 that was bundled in the AL2 base image. Some libraries that developers wanted to use in provided runtimes required newer versions of glibc. With this launch, you can now use an up-to-date version of
glibc with your Lambda function.
The AL2 base image for Lambda came pre-installed with Python 2.7. This was needed because Python was a required dependency for some of the packages that were bundled in the base image. The AL2023 base image for Lambda has removed this dependency on Python 2.7 and does not come with any pre-installed language runtime. You are free to choose and install any compatible Python version that you need.
Since the AL2023 base image for Lambda is based on the AL2023-minimal distribution, you also benefit from a significantly smaller deployment footprint. The new image is less than 40MB compared to the AL2-based base image, which is over 100MB in size. You can find the full list of packages available in the AL2023 base image for Lambda in the “minimal container” column of the AL2023 package list documentation.
Amazon Linux 2023 uses
dnf as the package manager, replacing
yum, which was the default package manager in Amazon Linux 2. AL2023 base image for Lambda uses
microdnf as the package manager, which is a standalone implementation of
dnf based on
libdnf and does not require extra dependencies such as Python.
provided.al2023 is symlinked as
dnf. Note that
microdnf does not support all options of
dnf. For example, you cannot install a remote
rpm using the rpm’s URL or install a local
rpm file. Instead, you can use the
rpm command directly to install such packages.
This example Dockerfile shows how you can install packages using
dnf while building a container-based Lambda function:
# Use the Amazon Linux 2023 Lambda base image FROM public.ecr.aws/lambda/provided.al2023 # Install the required Python version RUN dnf install -y python3
With the launch of
provided.al2023 you can migrate your AL2 custom runtime-based Lambda functions right away. It also sets the foundation of future Lambda managed runtimes. The future releases of managed language runtimes such as Node.js 20, Python 3.12, Java 21, and .NET 8 are based on Amazon Linux 2023 and will use
provided.al2023 as the base image.
Changing runtimes and using other compute services
provided.al2 base image was built as a custom image that used a selection of packages from AL2. It included packages like curl and yum that were needed to build functions using custom runtime. Also, each managed language runtime used different packages based on the use case.
Since future releases of managed runtimes use
provided.al2023 as the base image, they contain the same set of base packages that come with AL2023-minimal. This simplifies migrating your Lambda function from a custom runtime to a managed language runtime. It also makes it easier to switch to other compute services like AWS Fargate or Amazon Elastic Container Services (ECS) to run your application.
Upgrading from AL1-based runtimes
For more information on Lambda runtime deprecation, see Lambda runtimes.
AL1 end of support is scheduled for December 31, 2023. The AL1-based runtimes
provided will be deprecated from this date. You should migrate your Go based Lambda functions to the provided runtime family, such as
provided.al2023. Using a
provided runtime offers several benefits over the
go1.x runtime. First, you can run your Lambda functions on AWS Graviton2 processors that offer up to 34% better price-performance compared to functions running on x86_64 processors. Second, it offers a smaller deployment package and faster function invoke path. And third, it aligns Go with other languages that also compile to native code and run on the
provided runtime family.
The deprecation of the Amazon Linux 1 (AL1) base image for Lambda is also scheduled for December 31, 2023. With
provided.al2023 now generally available, you should start planning the migration of your
go1.x and AL1 based Lambda functions to
Using the AL2023 base image for Lambda
To build Lambda functions using a custom runtime, follow these steps using the
AWS Management Console
Navigate to the Create function page in the Lambda console. To use the AL2023 custom runtime, select Provide your own bootstrap on Amazon Linux 2023 as the Runtime value:
AWS Serverless Application Model (AWS SAM) template
If you use the AWS SAM template to build and deploy your Lambda function, use the
provided.al2023 as the value of the
Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: hello-world/ Handler: my.bootstrap.file Runtime: provided.al2023
Building Lambda functions that compile natively
Lambda’s custom runtime simplifies the experience to build functions in languages that compile to native code, broadening the range of languages you can use. Lambda provides the Runtime API, an HTTP API that custom runtimes can use to interact with the Lambda service. Implementations of this API, called Runtime Interface Client (RIC), allow your function to receive invocation events from Lambda, send the response back to Lambda, and report errors to the Lambda service. RICs are available as language-specific libraries for several popular programming langauges such as Go, Rust, Python, and Java.
For example, you can build functions using Go as shown in the Building with Go section of the Lambda developer documentation. Note that the name of the executable file of your function should always be
provided.al2023 when using the zip deployment model. To use AL2023 in this example, use
provided.al2023 as the runtime for your Lambda function.
If you are using CLI set the
--runtime option to
aws lambda create-function --function-name myFunction \ --runtime provided.al2023 --handler bootstrap \ --role arn:aws:iam::111122223333:role/service-role/my-lambda-role \ --zip-file fileb://myFunction.zip
If you are using AWS Serverless Application Model, use
provided.al2023 as the value of the
Runtime in your AWS SAM template file:
AWSTemplateFormatVersion: '2010-09-09' Transform: 'AWS::Serverless-2016-10-31' Resources: HelloWorldFunction: Type: AWS::Serverless::Function Metadata: BuildMethod: go1.x Properties: CodeUri: hello-world/ # folder where your main program resides Handler: bootstrap Runtime: provided.al2023 Architectures: [arm64]
If you run your function as a container image as shown in the Deploy container image example, use this Dockerfile. You can use any name for the executable file of your function when using container images. You need to specify the name of the executable as the
ENTRYPOINT in your Dockerfile:
FROM golang:1.20 as build WORKDIR /helloworld # Copy dependencies list COPY go.mod go.sum ./ # Build with optional lambda.norpc tag COPY main.go . RUN go build -tags lambda.norpc -o main main.go # Copy artifacts to a clean image FROM public.ecr.aws/lambda/provided:al2023 COPY --from=build /helloworld/main ./main ENTRYPOINT [ "./main" ]
With this launch, you can now build your Lambda functions using Amazon Linux 2023 as the custom runtime or use it as the base image to run your container-based Lambda functions. You benefit from the updated versions of libraries such as
glibc, new package manager, and smaller deployment size than Amazon Linux 2 based runtimes. Lambda also uses Amazon Linux 2023-minimal as the basis for future Lambda runtime releases.
For more serverless learning resources, visit Serverless Land.