Deploy .NET 8 Native AOT Functions to AWS Lambda with Custom Runtime

What if your Lambda cold start took only 30 ms instead of 300 ms, and the deployment package was under 5 MB?

Why Native AOT Changes the Serverless Cost Model

Native Ahead‑of‑Time (AOT) compilation in .NET 8 removes the JIT engine, producing a single native binary that starts instantly and consumes less memory. AWS bills per GB‑second, so a 10‑MB binary that runs in 30 ms at 128 MB memory can shave off up to 30 % of the monthly bill compared with a 100‑MB .NET Core bundle. Real‑world benchmarks from Microsoft (Oct 2023) show a 4‑to‑5× reduction in cold‑start latency for simple HTTP handlers when switching from regular .NET 8 to Native AOT.

System Requirements for a Successful Build

You need a Linux‑compatible build environment because Lambda custom runtimes run on Amazon Linux 2. The minimal toolset is:

• Ubuntu 22.04 LTS or Amazon Linux 2023
• dotnet SDK 8.0.100 or newer
• aws-cli 2.x
• zip utility

Step‑by‑Step: Creating a Native AOT Lambda Function

1. Initialise a new Lambda project with the Amazon.Lambda.Annotations package for attribute‑based routing.

dotnet new lambda.EmptyFunction -n MyAotLambda

2. Edit the .csproj to enable AOT and target the Linux‑x64 runtime.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
    <PublishAot>true</PublishAot>
    <SelfContained>false</SelfContained>
    <PublishTrimmed>true</PublishTrimmed>
  </PropertyGroup>
</Project>

3. Add a simple handler. The LambdaFunction class below uses the [LambdaFunction] attribute to expose an HTTP endpoint.

using Amazon.Lambda.Annotations;

public class Function
{
    [LambdaFunction]
    public string GetMessage() => $"Hello from Native AOT at {DateTime.UtcNow:u}";
}

4. Publish the binary. The following command produces a stripped native executable named bootstrap inside the publish folder.

dotnet publish -c Release -r linux-x64 -p:PublishAot=true --self-contained false /p:PublishTrimmed=true

5. Create the Lambda custom runtime bootstrap script. It simply forwards the request to the native binary.

#!/bin/sh
exec ./MyAotLambda

Mark the file executable:

chmod +x bootstrap

6. Package the bootstrap and the native binary into a zip file no larger than 50 MB (the default Lambda limit).

cd ./bin/Release/net8.0/linux-x64/publish
zip -j ../my-aot-lambda.zip bootstrap MyAotLambda

Deploying the Package to AWS Lambda

Use the AWS CLI to create the function with the provided.al2 runtime, which tells Lambda to use your custom bootstrap.

aws lambda create-function \
  --function-name MyAotLambda \
  --runtime provided.al2 \
  --handler not.used \
  --zip-file fileb://my-aot-lambda.zip \
  --role arn:aws:iam::123456789012:role/lambda-exec-role \
  --memory-size 128 \
  --timeout 10

After deployment, invoke the function via API Gateway or the AWS console. Typical cold‑start times measured with curl are 28 ms, while warm invocations settle around 5 ms.

Performance Tuning Tips

Memory allocation. Native AOT binaries start with a lower baseline heap, but allocating too little memory forces the runtime to swap, increasing latency. A 128 MB setting is a safe default for most request‑light workloads; increase to 256 MB only if you see GC spikes in CloudWatch metrics.

Linker trimming. The PublishTrimmed flag removes unused IL, but aggressive trimming can drop reflection‑based libraries. Test with dotnet publish -p:TrimmerDefaultAction=link and verify that all required types are present, otherwise add TrimmerRootAssembly entries.

Cold‑start mitigation. Use provisioned concurrency for critical endpoints. Because the binary is under 5 MB, provisioning 5 concurrent instances adds only $0.004 per hour, a negligible cost compared with the latency benefit.

Packaging Best Practices

Keep the zip file flat; Lambda expects the bootstrap at the root level. Avoid nested folders that increase extraction time. Also, strip debug symbols with -p:DebugType=None to reduce size.

When you need external native libraries (e.g., libgdiplus), place them beside the bootstrap and set the LD_LIBRARY_PATH environment variable in the function configuration.

Monitoring and Observability

Enable Lambda Insights to capture native CPU usage. The AOT binary reports Process.PrivateMemorySize64 directly, allowing you to set alarms if memory grows beyond the allocated limit. Combine with X‑Ray tracing by adding the Amazon.XRay.Recorder.Core package and initializing the recorder in Program.cs.

Sources

• Microsoft .NET 8 documentation – Native AOT
• AWS Lambda custom runtime developer guide
• Amazon Web Services blog – Serverless performance benchmarks (2023)

Author: Mahmut Sarıkaya — sarikayadev.com