C# and AWS Lambdas, Part 8 – .NET 6, inside a Container, inside a Lambda

Full source code available here.

After playing with .NET 5 libraries and Web API applications inside Lambda containers I wanted to see if I could get a .NET 6 library running too.

I cloned https://github.com/aws/aws-lambda-dotnet, and started digging into this Dockerfile.
With a few minor alterations this should be all I needed to change.

The Dockerfile pulls down a .NET runtime from https://dotnetcli.azureedge.net/dotnet.

Grabs an image to build the internal .NET support into the Lambda –

FROM mcr.microsoft.com/dotnet/sdk:5.0-buster-slim AS builder

Updating those two elements should be all that is needed.

.NET 6 Lambda Image
I updated the runtime to the latest .NET 6 preview, available from https://versionsof.net/core/6.0/6.0.0-preview.2/. In the attached example, I use the .NET 6 Runtime, but you might want to use the .NET 6 ASP.NET Runtime.

I also updated the builder to .NET 6 (but I found this wasn’t strictly necessary).

FROM mcr.microsoft.com/dotnet/nightly/sdk:6.0.100-preview.2-bullseye-slim-amd64 AS builder

To build the image run this inside the Dotnet6LambdaImage directory –

docker build -t dotnet6_runtime_aws_lambda .

That’s that, you now have a base image to run .NET 6 inside a Lambda container. Now to the library.

The Library
You can create a simple .NET Lambda application using a command like –

dotnet new lambda.EmptyFunction --name Dotnet6LambdaLibrary

You’ll need to update the .csproj file to make the target framework net6.0.

The attached example has stripped away the tests and the directory structure.

Add a Dockerfile that looks like this to the directory where the .csproj file is –

FROM dotnet6_runtime_aws_lambda as base

# https://hub.docker.com/_/microsoft-dotnet-sdk/
FROM mcr.microsoft.com/dotnet/nightly/sdk:6.0.100-preview.2-alpine3.13-amd64 as build

WORKDIR /source

# there is no point doing the restore as it's own step because the donet publish doesn't work with the --no-restore flag.
# COPY *.csproj .
# RUN dotnet restore

COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /var/task
COPY --from=build /app/publish .
CMD ["Dotnet6LambdaLibrary::Dotnet6LambdaLibrary.Function::FunctionHandler"]

The first line sets the image built above as the base.
The last line tells the Lambda what to call when running the function.
The rest in the middle are fairly standard Docker commands.

From inside the Dotnet6LambdaLibrary directory, build the library –

docker build -t dotnet6dockerlambdalibrary .

Deploy to AWS as shown in part 6 of this series.

Test as shown in part 1 of this series.

If you want to build and deploy .NET 6 Web API applications to Lambda containers, change the runtime that is pulled down in Dotnet6LambdaImage/Dockerfile to a more suitable one found here https://versionsof.net/core/6.0/6.0.0-preview.2/, then check out part 7 of this series to see how to hook up a HTTP Gateway to the Lamnbda.

I think that wraps up this series on C# and .NET in AWS Lambdas, I thought I was going to post four blogs on the topic, but ended up with eight. Hope they are helpful.

Full source code available here.

C# and AWS Lambdas, Part 7 – .NET 5 Web API inside a Container inside a Lambda, with API Gateway in front

Full source code available here.

In my previous post I showed how to build a .NET 5 library inside a docker image and deploy it to an AWS Lambda. This post is a small extension on that.

I’m going to build a .NET 5 Web API application, turn it into a docker image, deploy it to an AWS Lambda, and connect an API Gateway to the Lambda to call the controller inside the application, inside the container, inside the Lambda!

The Web API application
This is the same as what I did in part 2 of this series.

Use the AWS template –

dotnet new serverless.AspNetCoreWebAPI --name Dotnet5DockerWebAPILambda

In LambdaEntryPoint.cs change the class so that it inherits from to Amazon.Lambda.AspNetCoreServer.APIGatewayHttpApiV2ProxyFunction.

You can change what the controllers return if you like, in the attached code example I have –

public class ValuesController : ControllerBase
    // GET api/values
    public ActionResult Get()
        return Ok($"Hello World - {DateTime.Now}");
    // snip...

The Dockerfile

FROM public.ecr.aws/lambda/dotnet:5.0 as base

FROM mcr.microsoft.com/dotnet/sdk:5.0-alpine-amd64 AS build
WORKDIR /source

COPY *.csproj .
RUN dotnet restore

COPY . .
RUN dotnet publish --no-restore -c Release -o /app/publish

FROM base AS final
WORKDIR /var/task
COPY --from=build /app/publish .
CMD ["Dotnet5DockerWebAPILambda::Dotnet5DockerWebAPILambda.LambdaEntryPoint::FunctionHandlerAsync"]

This Dockerfile uses the AWS .NET 5 base image from their Elastic Container Repository.

Note the CMD that specifies the entry point to the application.

The Lambda
Follow the procedure described in part 6 of this series.

Build the image.

docker build -t dotnet5dockerwebapilambda .

Create a repository to store the image.
Push the image to the repository.

Create the Lambda (same as in part 6).
Select the container image you uploaded.

You won’t be able to test this Lambda function as easily as in the previous post, I have not had luck with the AWS provided test Json files from the .NET project template.

Connecting the API Gateway
I gave an example of how to connect an API Gateway to a Lambda in the second post in this series, the procedure is the same .

Click Create API.

Top of the list should be HTTP API, click Build.

Hit Add integration, choose Lambda, and pick the Lambda function created earlier.
Select Version 2.0.
Give the API a name.
Hit next.

Change resource path to $default – this is a wildcard that will match any controller in the Web API application.

In Configure Stages don’t change anything for this simple example.
Hit next.

In Review and Create confirm that it looks correct and hit Create in the bottom right.

You should now have an API Gateway setup that looks something like –

Click on the Invoke URL and you should get a response like –

“Welcome to running ASP.NET Core on AWS Lambda”

Change the url to include the route of the controller and by adding /api/values, the output from that action method should look like –

“Hello World – 3/23/2021 10:22:42 PM”

The Base Image
You might have noticed that I used the same base image in this and the previous post, but the previous post was a .Net 5 library. This means that the base image can run both libraries and Web API, not ideal if all you want to run is the library because you are getting the full .Net 5 ASP.NET Runtime. See update 2 of part 6 of this series for some brief instructions on building a base image with the .NET 5 Runtime.

Full source code available here.

C# and AWS Lambdas, Part 6 – .NET 5 inside a Container inside a Lambda

Full source code available here.

A few months ago AWS released a feature allowing Lambdas to run container images, for larger applications this is easier to work with than a zip file or set of layers, it also lets you move your already containerized apps to Lambda with a small effort.

I was interested to see if I could get a .NET 5 “Hello World” application running in this manner. There is a blog on the AWS site explaining how to do this with Visual Studio and the AWS Toolkit, but primarily use VS Code so I could not leverage those tools, and it would be fun to figure out.

UPDATE 1 – when I published this blog post I was unaware of a pre-made .NET 5 Docker image for AWS Lambda so I built my own following instructions found on an AWS GitHub repo. Those instructions are below.
But it is much easier to use the AWS provided image available here – https://gallery.ecr.aws/lambda/dotnet and use public.ecr.aws/lambda/dotnet:5.0.

UPDATE 2 – the AWS Lambda image above seems to have the full .NET 5 ASP.NET Runtime as opposed to the .NET 5 Runtime, if all you are running in the container is a library, then having the full .NET 5 ASP.NET Runtime will be larger than you need. As of now, I don’t see an image on the AWS ECR page for the .NET 5 Runtime. But you can build it your self following the below instructions, with one change, on line 49 of this file https://github.com/aws/aws-lambda-dotnet/blob/087590ce99274e16e26d37e1dfd73b0b71d1230a/LambdaRuntimeDockerfiles/dotnet5/Dockerfile, change the linked tar.gz to the appropriate file in here https://versionsof.net/core/5.0/.

Building your own base image (optional)
You can’t use just any docker image for a .NET 5 application, it has to have special Lambda and AWS components included, here is how to build your own, if you want to, from the AWS code on GitHub.

But it is much easier to use the one image AWS provides – https://gallery.ecr.aws/lambda/dotnet
Now that you have a base image, let’s move to the application.

Building the hello world container
Create a new .NET Lambda using –

dotnet new lambda.EmptyFunction --name HelloWorldLambdaContainer

This crates a simple library that converts an input string to uppercase.
If you wanted to, you could build this, zip it and deploy it to a Lambda as I showed in part 1 of this series.

But I want to put this in a container.

You need Docker for the rest of this, there are plenty of tutorials out there including one from my friend Steve Gordon.

In the source code directory add a file named Dockerfile with the below content. Note that it’s using the image I put on Docker Hub.

FROM public.ecr.aws/lambda/dotnet:5.0 AS base

FROM mcr.microsoft.com/dotnet/sdk:5.0-buster-slim as build

WORKDIR /source

COPY *.csproj .
RUN dotnet restore

COPY . .
RUN dotnet publish --no-restore -c Release -o /app/publish

FROM base AS final
WORKDIR /var/task
COPY --from=build /app/publish .
CMD ["HelloWorldLambdaContainer::HelloWorldLambdaContainer.Function::FunctionHandler"]

Everything is in place, build the image.

docker build -t helloworldlambdacontainer .

Over in AWS we need a repository to store the image.

Go to the Elastic Container Registry.

Create a repository.

Navigate into the repository and you will see a button labeled “View push commands”. Follow those instructions to upload the container image to repository.

That’s everything done here, over to the Lambda.

The Lambda
This is similar to what I showed in part one, but this time the function will be based on a container image.

Create a new Lambda function, select Container image from the options.

Give the function a name.

Hit Browse images, and select the container image from the repository created above.

It will take a few moments for AWS to create the function. Once it is up, open the test tool in the top right of the screen and click “Configure test events”.

Set the event name, and replace the body with this – “hello world”.

Hit the “Test” button in the top right.

You should see something like – “Execution result: succeeded(logs)”. Expand the Details and you will see “HELLO WORLD” and bunch of other information about the execution of the Lambda.

That is a .NET 5 library running inside container, running inside a Lambda, not bad!

But what if you could get Kestrel up and running and map API Gateway requests to it, that would be fun…and that’s in the next post of this series.

Full source code available here.