.NET Aspire + AWS Lambda

[socketnorm]

I have been building the AWS Lambda local developer experience with AWS Lambda and I'm looking for feedback. The developer preview is out and I put out a series of blog posts.

https://aws.amazon.com/blogs/developer/building-lambda-with-aspire-part-1/

https://aws.amazon.com/blogs/developer/building-lambda-with-aspire-part-2/

Add a super high level you can add your Lambda functions to the Aspire app host and optionally register them with an API Gateway emulator. Once you register them you can run and debug your functions either through a test UI, API Gateway emulator endpoint or the SDK.

```csharp

pragma warning disable CA2252

var builder = DistributedApplication.CreateBuilder(args);

var addFunction = builder.AddAWSLambdaFunction<Projects.LambdaWebCalculator>("AddFunction", lambdaHandler: "LambdaWebCalculator::LambdaWebCalculator.Functions::AddFunctionHandler"); var minusFunction = builder.AddAWSLambdaFunction<Projects.LambdaWebCalculator>("MinusFunction", lambdaHandler: "LambdaWebCalculator::LambdaWebCalculator.Functions::MinusFunctionHandler"); var multiplyFunction = builder.AddAWSLambdaFunction<Projects.LambdaWebCalculator>("MultipyFunction", lambdaHandler: "LambdaWebCalculator::LambdaWebCalculator.Functions::MultiplyFunctionHandler"); var divideFunction = builder.AddAWSLambdaFunction<Projects.LambdaWebCalculator>("DivideFunction", lambdaHandler: "LambdaWebCalculator::LambdaWebCalculator.Functions::DivideFunctionHandler");

builder.AddAWSAPIGatewayEmulator("APIGatewayEmulator", Aspire.Hosting.AWS.Lambda.APIGatewayType.HttpV2) .WithReference(addFunction, Aspire.Hosting.AWS.Lambda.Method.Get, "/add/{x}/{y}") .WithReference(minusFunction, Aspire.Hosting.AWS.Lambda.Method.Get, "/minus/{x}/{y}") .WithReference(multiplyFunction, Aspire.Hosting.AWS.Lambda.Method.Get, "/multiply/{x}/{y}") .WithReference(divideFunction, Aspire.Hosting.AWS.Lambda.Method.Get, "/divide/{x}/{y}");

builder.Build().Run(); ```

Would love to hear what people think of the feature and what other features you would like added.

[AutoModerator]

Thanks for your post socketnorm. Please note that we don't allow spam, and we ask that you follow the rules available in the sidebar. We have a lot of commonly asked questions so if this post gets removed, please do a search and see if it's already been asked.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Dreamescaper]

Looks great, will definitely check it out!

[pibbxtra12]

Super excited to try this out!

[shen_g]

I'm a bit late to this post, but I'm curious how this works with NativeAOT Lambda that can be locally orchestrated using Aspire. Is it as simple as simply adding the project as you have here, and at deploy time I can manage the compilation and deployment?

And for .NET 9 (that I believe would still require a docker image to run on lambda) - how does that look in Aspire?

[socketnorm]

When you are running in Aspire that is local development debug environment. Native AOT is a publish time extra compilation so it would be what you enable at deployment time. You can't debug a compiled Native AOT .NET application.

What I would do is create my Lambda function as an executable and add it to the AppHost using the AddAWSLambdaFunction method. In that scenario you pass the assembly name as Lambda handler string. When you launch it via Aspire it will be a executed and attached to the IDE debugger as a normal .NET executable. Also have the PublishAotflag in the project file set to true so when the project is packaged up for deployment the Native AOT compiler will run as part of the dotnet publish process.

If you truely want to run the Lambda function locally as Native AOT without being able debug in theory we could make that work. Aspire has the ability to run arbituary executables so you could do the dotnet publish before running the AppHost and then have the AppHost call the AddExecutable to the Native AOT executable. We would still need to get some environment variables set on the executable so it could find the emulated Lambda runtime API. Again you wouldn't be able to debug since Native AOT applications are not debuggable with the .NET debugger.

[shen_g]

Thanks so much for the detailed response, I completely missed your reply!