Serverless .NET: Building Minimal APIs with .NET 8 on AWS Lambda

Since its introduction, .NET's Minimal API framework has been celebrated for its simplicity and low-ceremony approach to building APIs. With the release of .NET 8, this paradigm has become even more powerful and a perfect fit for serverless architectures on AWS Lambda. By shedding the weight of the traditional Startup.cs and Controller classes, Minimal APIs offer a faster, more efficient way to build serverless backends.

This post will guide you through building and deploying a .NET 8 Minimal API to AWS Lambda.

Why Minimal APIs for Lambda?

1. Reduced Cold Starts: Less code and fewer abstractions mean a faster initialization phase. The streamlined pipeline of Minimal APIs translates directly to lower cold start times.
2. Simplified Codebase: Your entire API can often be defined in a single Program.cs file, making it easier to read, understand, and maintain.
3. Performance: The focus on a lean, middleware-centric pipeline results in better raw performance and lower resource consumption.

Setting Up the Project

To get started, you'll need the AWS Lambda templates for .NET. If you don't have them, install them via the CLI:

dotnet new install Amazon.Lambda.Templates

Now, create a new project using the "Serverless ASP.NET Core Minimal API" template:

dotnet new lambda.MinimalApi -n MyServerlessApi
cd MyServerlessApi

This template scaffolds a project that is pre-configured for Lambda deployment.

The Core of the Minimal API: Program.cs

The heart of your application is Program.cs. Here’s what a basic setup looks like:

// Program.cs
var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Add AWS Lambda support. This is the key integration point.
builder.Services.AddAWSLambdaHosting(LambdaEventSource.HttpApi);

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

// Define your endpoints
app.MapGet("/weatherforecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55)
        ))
        .ToArray();
    return forecast;
});

app.Run();

record WeatherForecast(DateOnly Date, int TemperatureC);

The magic happens with builder.Services.AddAWSLambdaHosting(LambdaEventSource.HttpApi). This extension method from the Amazon.Lambda.AspNetCoreServer package bridges the gap between the ASP.NET Core request pipeline and the Lambda invocation model.

Deploying to AWS Lambda

The template also includes a serverless.template file, which is an AWS SAM (Serverless Application Model) template. You can deploy your API using the AWS Toolkit for Visual Studio or the .NET Core Global Tool for Lambda.

Using the CLI:

1. Install the Lambda tool:

   dotnet tool install -g Amazon.Lambda.Tools
   

2. Deploy the function:

   dotnet lambda deploy-serverless
   

The tool will prompt you for a stack name and an S3 bucket to store the deployment package. Once complete, it will output the URL for your new serverless API.

Optimizing for Production: Ahead-of-Time (AOT) Compilation

For even better performance, .NET 8 enhances support for Native AOT. Compiling your Minimal API to native code can dramatically reduce cold start times and memory usage, as it eliminates the need for JIT (Just-In-Time) compilation at runtime.

To enable this, you'll need to modify your .csproj file:

<PropertyGroup>
    <PublishAot>true</PublishAot>
</PropertyGroup>

Note: Native AOT has some limitations and requires your code and dependencies to be AOT-compatible. However, for many common API workloads, it provides a significant performance advantage on Lambda.

Conclusion

.NET 8 Minimal APIs and AWS Lambda are a perfect match. They allow C# developers to build fast, scalable, and cost-effective serverless applications without the boilerplate of traditional ASP.NET Core projects. The streamlined nature of Minimal APIs directly addresses the performance sensitivities of a serverless environment, making it an excellent choice for your next cloud-native backend.