Siemens.AspNet.Lambda.Sdk 0.1.0-alpha.169

Siemens.AspNet.Lambda.Sdk

The Siemens.AspNet.Lambda.Sdk NuGet package simplifies and accelerates AWS Lambda function development using ASP.NET-inspired middleware pipelines, structured exception handling, and pre-configured startup patterns.

📖 Overview

This SDK helps developers focus on implementing business logic by abstracting boilerplate and common concerns specific to AWS Lambda environments.

✅ Key Features

• 🚀 Quick Lambda function implementation with structured base classes.
• ⚙️ ASP.NET-like middleware pipeline support.
• 📌 Customizable startup configurations with dependency injection.
• 🔍 Structured error logging with built-in handlers.
• 🔄 JSON serialization management.
• 🛠️ Predefined logging and error handling strategies.
• 🕒 Built-in cancellation support to gracefully handle Lambda execution limits.

📦 Installation

Using the .NET CLI

dotnet add package Siemens.AspNet.Lambda.Sdk

🧠 Key Concepts

⚡ Quickstart Examples

Dockerfile and Lambda entry point

Use the fully qualified method name (InvokeAsync) as the Lambda entry point.

Sample Dockerfile entry point:

CMD ["Siemens.TestProject.InitCognitoUser::Siemens.TestProject.InitCognitoUser.Function::InvokeAsync"]

Implementing a simple Lambda function without response

public class MyFunction : FunctionBase<SQSEvent>
{
    public override Task HandleAsync(SQSEvent request, ILambdaContext context, CancellationToken cancellationToken)
    {
        // Your Lambda logic here
    }
}

Implementing a simple Lambda function with request and response

public class Function : FunctionBase<CognitoPostConfirmationEvent, CognitoPostConfirmationEvent>
{
    public override Task<CognitoPostConfirmationEvent> HandleAsync(CognitoPostConfirmationEvent request,
                                                                   ILambdaContext context,
                                                                   CancellationToken cancellationToken)
    {
        // Your Lambda logic here
    }
}

Implementing a Lambda function with custom handler and dependency injection

Function:

public class Function : FunctionHandlerBase<Startup, CognitoPostConfirmationEvent, CognitoPostConfirmationEvent>
{
}

Startup:

public sealed class Startup : LambdaStartup
{
    protected override void ConfigureServices(IServiceCollection services, IConfiguration configuration)
    {
        base.ConfigureServices(services, configuration);
        services.AddFunctionHandler();
    }
}

FunctionHandler registration:

internal static class AddFunctionHandlerExtension
{
    internal static void AddFunctionHandler(this IServiceCollection services)
    {
        services.AddSingletonIfNotExists<IFunctionHandler<CognitoPostConfirmationEvent, CognitoPostConfirmationEvent>, FunctionHandler>();
    }
}

internal sealed class FunctionHandler(IMyService service, IJsonSerializer jsonSerializer)
    : IFunctionHandler<CognitoPostConfirmationEvent, CognitoPostConfirmationEvent>
{
    public Task<CognitoPostConfirmationEvent> HandleAsync(CognitoPostConfirmationEvent request,
                                                          ILambdaContext context,
                                                          CancellationToken cancellationToken)
    {
        // Your custom logic here
    }
}

📌 Cancellation and Execution Management

The SDK includes built-in cancellation token support to help gracefully handle AWS Lambda execution timeouts.

Configure the cancellation buffer time:

internal sealed class LambdaSettings
{
    /// <summary>
    /// Offset to trigger the cancellation token slightly before Lambda's remaining execution time ends, ensuring proper resource cleanup.
    /// </summary>
    public TimeSpan CancellationBufferTime { get; init; } = TimeSpan.FromSeconds(10);
}

Base Function with Cancellation Token

If you want to implement your own function handler, here is a sample how to set up such a use case

public abstract class FunctionBase<TRequest, TResponse> : FunctionWithStartupBase<LambdaStartup, TRequest, TResponse>
{
}

public abstract class FunctionWithStartupBase<TStartup, TRequest, TResponse> where TStartup : LambdaStartup, new()
{
    protected ILogger Logger { get; private set; }
    private readonly ILambdaPipelineExecutor<TRequest, TResponse> _pipeline;
    private readonly LambdaSettings _lambdaSettings;

    protected FunctionWithStartupBase()
    {
        var startup = new TStartup();
        var serviceProvider = startup.Setup();
        _pipeline = serviceProvider.GetRequiredService<ILambdaPipelineExecutor<TRequest, TResponse>>();
        _lambdaSettings = serviceProvider.GetRequiredService<LambdaSettings>();
        Logger = startup.Logger;
    }

    public async Task<TResponse> InvokeAsync(TRequest request,
                                             ILambdaContext context)
    {
        var cancelAfter = context.RemainingTime.Subtract(_lambdaSettings.CancellationBufferTime);
        cancelAfter = cancelAfter < TimeSpan.Zero ? TimeSpan.Zero : cancelAfter;

        using var cts = new CancellationTokenSource();
        cts.CancelAfter(cancelAfter);

        // Do not remove "await" here, it is necessary for the pipeline to work correctly in combination with the cancellation token.
        var result = await _pipeline.ExecuteAsync(request, context, HandleAsync, cts.Token).ConfigureAwait(false);

        return result;
    }

    public abstract Task<TResponse> HandleAsync(TRequest request,
                                                ILambdaContext context,
                                                CancellationToken cancellationToken);
}

📌 Error Handling and Logging

Built-in structured handlers:

Each handler provides detailed, structured logging of exceptions, aiding rapid diagnostics and maintenance.

📚 Documentation

Detailed documentation and further examples can be found within the codebase and will soon be available online.

📢 Contributing

Contributions and feedback are welcome! Please create issues or pull requests to suggest improvements.