👁 Image
Siemens.AspNet.Lambda.Sdk 7.5.8

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.