The .NET 6 Managed Runtime for AWS Lambda: An Overview of Lambda Annotations

Recently, AWS introduced the .NET 6 managed runtime for Lambda, which brings an exciting update for developers utilizing AWS for serverless applications. This runtime is accompanied by a new framework designed to simplify the process of writing .NET 6 Lambda functions: Lambda Annotations. This framework not only enhances the development experience but also seamlessly integrates with your project’s CloudFormation templates, minimizing the complexity involved in function management.

Simplifying Lambda Functions with Annotations

Traditionally, AWS Lambda required developers to write functions that included a fair amount of boilerplate code. Consider the Lambda function for adding two numbers:

csharp
public APIGatewayHttpApiV2ProxyResponse LambdaMathAdd(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext context)
{
if (!request.PathParameters.TryGetValue(“x”, out var xs) || !request.PathParameters.TryGetValue(“y”, out var ys))
{
return new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.BadRequest
};
}
var x = int.Parse(xs);
var y = int.Parse(ys);
return new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = (x + y).ToString(),
Headers = new Dictionary<string, string> { { “Content-Type”, “text/plain” } }
};
}

This code includes logic for error handling and HTTP responses, making it quite verbose. With the new Annotations framework, developers can express the same functionality using a much cleaner syntax:

csharp
[LambdaFunction]
[HttpApi(LambdaHttpMethod.Get, “/add/{x}/{y}”)]
public int Add(int x, int y)
{
return x + y;
}

As you can see, the use of attributes here allows you to focus on the core business logic, significantly reducing complexity.

How Does Annotations Work?

The Lambda programming model relies on writing functions that accept a maximum of two parameters: an event object and an instance of ILambdaContext. While the first example adheres to this model, the second example deviates by taking parameters that correspond to the API’s resource path directly.

The Annotations framework leverages C# source generators to bridge this gap. When the .NET C# compiler is engaged, it scans for Lambda attributes, generating the necessary code to transform the more straightforward syntax into something that complies with the traditional Lambda programming model.

Compile-Time Optimization

A key advantage of this approach is that it occurs at compile time. By using source generators, runtime performance improves since the generated code is ready to go without incurring the overhead of reflection.

However, it’s worth noting that source generators only work with C#. Consequently, the Annotations framework isn’t available for Lambda functions written in F#.

Getting Started with Lambda Annotations

To dive into the new Lambda Annotations framework, the AWS Toolkit for Visual Studio 2022 is your best bet. By creating a project with the AWS Serverless Application template, developers can quickly start crafting Lambda functions, with the added benefit of CloudFormation resource integration.

Upon setting up your project, a reference to the Amazon.Lambda.Annotations NuGet package will be automatically included, equipping you with the attributes necessary for annotating your Lambda functions and generating the corresponding code.

Example: Building a REST API Calculator

Within the project structure, the main Lambda functions will be housed in a Function.cs file, and the serverless.template file serves as the CloudFormation template for defining these functions. For instance, a simple REST API calculator could include the following operations:

csharp
[LambdaFunction()]
[HttpApi(LambdaHttpMethod.Get, “/add/{x}/{y}”)]
public int Add(int x, int y, ILambdaContext context)
{
context.Logger.LogInformation($”{x} plus {y} is {x + y}”);
return x + y;
}

Deploying these functions as a single CloudFormation stack ensures that all components are kept in sync.

Enhancing Functionality: Adding More Features

Let’s say you want to extend your calculator with a modulus function. You need only add the following code:

csharp
[LambdaFunction(Timeout = 3, MemorySize = 128)]
[HttpApi(LambdaHttpMethod.Get, “/mod/{x}/{y}”)]
public int Mod(int x, int y, ILambdaContext context)
{
context.Logger.LogInformation($”{x} mod {y} is {x % y}”);
return x % y;
}

Every time you compile the project, the CloudFormation template is automatically updated to include any new functions you define, making version management straightforward.

Dependency Injection Made Easy

Dependency injection (DI) is a cornerstone of modern application design, and the Annotations framework supports DI using the LambdaStartup attribute. This feature allows developers to configure services easily, promoting cleaner and more organized code.

In the Startup class, you can register services as follows:

csharp
[Amazon.Lambda.Annotations.LambdaStartup]
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<ICalculatorService, CalculatorService>();
}
}

Once registered, these services can be injected into your Lambda functions either via constructor injection or through the [FromServices] attribute, as demonstrated earlier.

Practical Example of Service Injection

Using constructor injection looks like this:

csharp
public class Functions
{
private readonly ICalculatorService _calculatorService;

public Functions(ICalculatorService calculatorService)
{
    _calculatorService = calculatorService;
}

[LambdaFunction()]
[HttpApi(LambdaHttpMethod.Get, "/add/{x}/{y}")]
public int Add(int x, int y, ILambdaContext context)
{
    context.Logger.LogInformation($"{x} plus {y} is {x + y}");
    return _calculatorService.Add(x, y);
}

}

This approach works best when employing singleton services, ensuring efficient utilization of resources across different invocations.

Conclusion

The .NET Lambda Annotations framework significantly simplifies the experience of building AWS Lambda functions using C#. With minimal boilerplate code, enhanced syntax using annotations, and efficient usage of dependency injection, this framework simplifies the development process and enhances productivity. Developers are encouraged to experiment with this new framework and share their experiences to help refine its functionality in future iterations.

For further exploration, you can refer to the GitHub repository to stay updated on the latest developments and feature requests. Happy coding!