How can I build an image using dotnet/sdk6 that can also execute lambdas

[zeusongit]

So, I have been struggling to find a way to do both from a single image.
I have an executable that will need dotnet/sdk:6 image to run, but then while creating a lambda I have to pull in public.ecr.aws/lambda/dotnet:6 which does not have dotnet sdk required to run the executable.

For each trigger on my lambda I want to run that executable and process some data received via the same event.

So basically I need a lambda environment that call run the executable as well as handle lambda calls.

How can I do this? Should I install the runtime manually on dotnet/sdk image? How do I make the final stage compatible with lambda executions, i.e it could handle entry points like: "HelloWorld::HelloWorld.Function::FunctionHandler"

PS: Newbie alert!

[behdad088]

Hi @zeusongit, I am not sure if I got your question, but maybe this will help you.
To create a Lambda function that can execute your custom executable and also handle incoming events, you'll need to package your code and any dependencies into a single deployment package that can be uploaded to AWS Lambda. Here are the general steps you can follow:
Create a Dockerfile that starts with the dotnet/sdk:6 base image and installs any additional dependencies needed to run your executable. For example:

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /app

# Copy your application code to the container
COPY MyApp.csproj .
COPY Program.cs .
COPY OtherFiles/ ./OtherFiles/

# Restore dependencies
RUN dotnet restore

# Build your application
RUN dotnet publish -c Release -o out

# Start with the dotnet/runtime:6.0 base image to run the application
FROM mcr.microsoft.com/dotnet/runtime:6.0
WORKDIR /app
COPY --from=build /app/out .

# Install any additional dependencies needed to run the executable
RUN apt-get update && apt-get install -y my-dependency

# Set the command to run your application
CMD ["./MyApp", "arg1", "arg2"]

Build the Docker image and tag it with a version number. For example:

$ docker build -t my-lambda:1.0 .

Test the Docker image locally to make sure your executable runs correctly. For example:

$ docker run my-lambda:1.0

Create a Lambda function using the public.ecr.aws/lambda/dotnet:6 base image. In the Lambda function code, you can use the os/exec package to run your custom executable. For example:

package main

import (
    "fmt"
    "os/exec"

    "github.com/aws/aws-lambda-go/lambda"
)

func handleRequest(event MyEvent) (string, error) {
    cmd := exec.Command("./MyApp", "arg1", "arg2")
    output, err := cmd.Output()
    if err != nil {
        return "", fmt.Errorf("error running MyApp: %w", err)
    }
    return string(output), nil
}

func main() {
    lambda.Start(handleRequest)
}

Package your Lambda function code and the my-lambda:1.0 Docker image into a deployment package using a tool like AWS SAM or the AWS CLI. For example, with AWS SAM:

$ sam build --use-container
$ sam package --output-template-file packaged.yaml --s3-bucket my-bucket

Deploy the Lambda function using the packaged deployment package. For example, with AWS SAM:

$ sam deploy --template-file packaged.yaml --stack-name my-stack --capabilities CAPABILITY_IAM

Configure your Lambda function to use the correct handler function by setting the Handler property in your CloudFormation template or in the Lambda function configuration in the AWS Management Console. For example, if your handler function is named main, set the Handler property to main.

With these steps, you should have a Lambda function that can execute your custom executable and also handle incoming events. Note that you may need to adjust this approach depending on the specific requirements of your application.

@zeusongit I hope it helps you!