How to dockerize .NET WebAPI lambda on both local and cloud

[Fitmavincent]

I've generated the .NET WebAPI lambda from the dotnet lambda template serverless.image.AspNetCoreWebAPI. I want to wrap this webapi lambda and build it as image on both local and cloud.

For local, I can docker run and test and play around in my local machine.
For cloud, I can upload the image to ECR and then lambda can pull the image from ECR and deploy.

However, I've encountered the error from both docker build
Program does not contain a static 'Main' method suitable for an entry point [/src/API.Lambda/API.Lambda.csproj]
Even I explicitly set the entrypoint:

Dockerfile.local

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

FROM mcr.microsoft.com/dotnet/sdk:7.0-bullseye-slim as build
WORKDIR /src
COPY ["Lambda/src/API.Lambda/API.Lambda.csproj", "API.Lambda/"]
RUN dotnet restore "API.Lambda/API.Lambda.csproj"

COPY . .
WORKDIR "/src/API.Lambda"
ENTRYPOINT [ "dotnet", "API.Lambda/LocalEntryPoint.cs" ]
RUN dotnet build "API.Lambda.csproj" --configuration Release --output /app/build

FROM build AS publish
RUN dotnet publish "API.Lambda.csproj" \
            --configuration Release \
            --runtime linux-x64 \
            --self-contained false \
            --output /app/publish \
            -p:PublishReadyToRun=true

FROM base AS final
WORKDIR /var/task
COPY --from=publish /app/publish .
COPY "Lambda/src/API.Lambda/Signer" .

ENTRYPOINT [ "dotnet", "API.Lambda.dll" ]

Dockerfile

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

FROM mcr.microsoft.com/dotnet/sdk:7.0-bullseye-slim as build
WORKDIR /src
COPY ["Lambda/src/API.Lambda/API.Lambda.csproj", "API.Lambda/"]
RUN dotnet restore "API.Lambda/API.Lambda.csproj"

COPY . .
WORKDIR "/src/API.Lambda"
ENTRYPOINT [ "dotnet", "API.Lambda/LambdaEntryPoint.cs" ]
RUN dotnet build "API.Lambda.csproj" --configuration Release --output /app/build

FROM build AS publish
RUN dotnet publish "API.Lambda.csproj" \
            --configuration Release \
            --runtime linux-x64 \
            --self-contained false \
            --output /app/publish \
            -p:PublishReadyToRun=true

FROM base AS final
WORKDIR /var/task
COPY --from=publish /app/publish .
COPY "Lambda/src/API.Lambda/Signer" .

ENTRYPOINT [ "dotnet", "API.Lambda.dll" ]

Do we have any official guide on this?

[ashishdhingra]

@Fitmavincent Good afternoon. I see multiple issues here:

• Unsure why the ENTRYPOINT is set as API.Lambda/LambdaEntryPoint.cs in your Dockerfile. Could you please check Application hangs sending to SQS using docker container hosted in AWS AppRunner aws-sdk-net#2588 (comment) for guidance for the correct Dockerfile (although it targets .NET 6)?
• 2nd issue is how to use the pushed Docker image to ECR. Could you please check if your scenario is similar to the one reported at "lambda deploy-serverless" command tries to build image when ImageUri is set without any Metadata aws-extensions-for-dotnet-cli#264. In that issue, user also builds the Docker image locally and uploads the image to ECR, thereafter, uses dotnet lambda deploy-serverless in conjunction with ImageUri attribute to point to the image already uploaded in ECR (take a note of when the ImageUri is taken into consideration in the note mentioned in the issue).

Thanks,
Ashish

[Fitmavincent]

Hi @ashishdhingra, to clarify a bit on the issue that I have, the ENTRYPOINT set to API.Lambda/LambdaEntryPoint.cs or API.Lambda/LocalEntryPoint.cs is my attempt to point the dotnet build command in my Dockerfile to the correct entry point. As I mentioned in the discussion, the dotnet build simply fails because the LambdaEntryPoint.cs file does not have a main function.

What I wanna know is, do we have an official way of achieving these:

1. The .NET WebAPI project/solutions can be built as a docker image in the local environment
2. The .NET WebAPI project can be built as a docker image deployed to lambda by reading it from ECR.
3. Do we need an explicit setup to point the .NET WebAPI to LocalEntryPoint or LambdaEntrypoint?

[ashishdhingra]

@Fitmavincent If you refer the example given at https://docs.docker.com/engine/reference/builder/#entrypoint, the command line arguments to docker run <image> will be appended after all elements in an exec form ENTRYPOINT. So essentially in your case, you are executing dotnet API.Lambda/LambdaEntryPoint.cs (not the dotnet build API.Lambda/LambdaEntryPoint.cs), hence it is expecting an assembly that contains the Main method. The file API.Lambda/LambdaEntryPoint.cs (as an example) is not a compiled .NET assembly.

When you add a new Dockerfile to a WebAPI project, it adds the following content:

#See https://aka.ms/containerfastmode to understand how Visual Studio uses this Dockerfile to build your images for faster debugging.

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443
    
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["TestWebApiProject.csproj", "."]
RUN dotnet restore "./TestWebApiProject.csproj"
COPY . .
WORKDIR "/src/."
RUN dotnet build "TestWebApiProject.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "TestWebApiProject.csproj" -c Release -o /app/publish /p:UseAppHost=false

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "TestWebApiProject.dll"]

So you need to build the .NET project using the RUN dotnet build Docker instruction.

Thanks,
Ashish

@bot propose-answer

[Fitmavincent]

Hi @ashishdhingra ,

Thanks for you reply. But I still got confused with the entry point here. Because when I build it locally, I also want to build it as an image and run in docker.

Build it through pipeline and pushing the cloud solution with LambdaEntryPoint to ECR then deploy the Lambda from ECR.

Therefore, what I want to achieve here is the dockerfile that can help me running it locally by pointing it to LocalEntryPoint, and when it comes to deploying Lambda, it can deploy and run via LambdaEntryPoint.

I understand that the LambdaEntryPoint isn't a compiled .NET assembly. That's why I want to know that is can this .NET webapi lambda build as an image then deploy to Lambda from an image.

[ashishdhingra]

@Fitmavincent Are you using the .NET 7 serverless container image template or upgrading the serverless WebAPI project to .NET 7? Could you please share what Visual Studio template you used to develop your solution and may be share the minimal code solution (with sensitive information removed), may be attached as a ZIP for investigation?

EDIT: Attached is the sample Serverless WebAPI container image project which has both LocalEntryPoint and LambdaEntryPoint. When the code is executed locally, it should execute LocalEntryPoint and when it is executed in Lamba environment, it should execute LambdaEntryPoint.
ServerlessWebApiNet7.zip

Below is the Dockerfile:

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

FROM mcr.microsoft.com/dotnet/sdk:7.0-bullseye-slim as build
WORKDIR /src
COPY ["ServerlessWebApiNet7.csproj", "ServerlessWebApiNet7/"]
RUN dotnet restore "ServerlessWebApiNet7/ServerlessWebApiNet7.csproj"

WORKDIR "/src/ServerlessWebApiNet7"
COPY . .
RUN dotnet build "ServerlessWebApiNet7.csproj" --configuration Release --output /app/build

FROM build AS publish
RUN dotnet publish "ServerlessWebApiNet7.csproj" \
            --configuration Release \ 
            --runtime linux-x64 \
            --self-contained false \ 
            --output /app/publish \
            -p:PublishReadyToRun=true  

FROM base AS final
WORKDIR /var/task
COPY --from=publish /app/publish .  

The code could be deployed using AWS .NET CLI Extensions tooling command dotnet lambda deploy-serverless (with the current directory as the folder containing the Dockerfile.

Hope this helps.

Thanks,
Ashish

[banderberg]

Doesn't this defeat one of the purposes of using containers - namely that when running locally for development the code is executing in an environment that is identical to that which it will be executing in when deployed to AWS Lambda? If I understand correctly, when run locally it will run under the microsoft .net 8.0 image and in AWS lambda will run under the aws .net 8.0 image.

[github-actions[bot]]

Hello! Reopening this discussion to make it searchable.