Deploy transpiled TypeScript code in Lambda with container images

To create an image from an Amazon base image for Lambda

1. On your local machine, create a project directory for your new function.

2. Create a new Node.js project with npm or a package manager of your choice.

   npm init

3. Add the @types/aws-lambda and esbuild packages as development dependencies. The @types/aws-lambda package contains the type definitions for Lambda.

   npm install -D @types/aws-lambda esbuild

4. Add a build script to the package.json file.

     "scripts": {
     "build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js"
   }

5. Create a new file called index.ts. Add the following sample code to the new file. This is the code for the Lambda function. The function returns a hello world message.

   Note

   The import statement imports the type definitions from @types/aws-lambda. It does not import the aws-lambda NPM package, which is an unrelated third-party tool. For more information, see aws-lambda in the DefinitelyTyped GitHub repository.

   import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';
   
   export const handler = async (event: APIGatewayEvent, context: Context): Promise<APIGatewayProxyResult> => {
       console.log(`Event: ${JSON.stringify(event, null, 2)}`);
       console.log(`Context: ${JSON.stringify(context, null, 2)}`);
       return {
           statusCode: 200,
           body: JSON.stringify({
               message: 'hello world',
           }),
       };
   };

6. Create a new Dockerfile with the following configuration:

   • Set the FROM property to the URI of the base image.

   • Set the CMD argument to specify the Lambda function handler.

   Example Dockerfile

   The following Dockerfile uses a multi-stage build. The first step transpiles the TypeScript code into JavaScript. The second step produces a container image that contains only JavaScript files and production dependencies.

   FROM public.ecr.aws/lambda/nodejs:18 as builder
   WORKDIR /usr/app
   COPY package.json index.ts  ./
   RUN npm install
   RUN npm run build
       
   FROM public.ecr.aws/lambda/nodejs:18
   WORKDIR ${LAMBDA_TASK_ROOT}
   COPY --from=builder /usr/app/dist/* ./
   CMD ["index.handler"]

7. Build the Docker image with the docker build command. The following example names the image docker-image and gives it the test tag.

   docker build --platform linux/amd64 -t docker-image:test .

   Note

   The command specifies the --platform linux/amd64 option to ensure that your container is compatible with the Lambda execution environment regardless of the architecture of your build machine. If you intend to create a Lambda function using the ARM64 instruction set architecture, be sure to change the command to use the --platform linux/arm64 option instead.

1. Start the Docker image with the docker run command. In this example, docker-image is the image name and test is the tag.

   docker run --platform linux/amd64 -p 9000:8080 docker-image:test

   This command runs the image as a container and creates a local endpoint at localhost:9000/2015-03-31/functions/function/invocations.

   Note

   If you built the Docker image for the ARM64 instruction set architecture, be sure to use the --platform linux/arm64 option instead of --platform linux/amd64.

2. From a new terminal window, post an event to the local endpoint.

   Linux/macOS

   In Linux and macOS, run the following curl command:

   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'

   This command invokes the function with an empty event and returns a response. If you're using your own function code rather than the sample function code, you might want to invoke the function with a JSON payload. Example:

   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'

   PowerShell

   In PowerShell, run the following Invoke-WebRequest command:

   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"

   This command invokes the function with an empty event and returns a response. If you're using your own function code rather than the sample function code, you might want to invoke the function with a JSON payload. Example:

   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"

3. Get the container ID.

   docker ps

4. Use the docker kill command to stop the container. In this command, replace 3766c4ab331c with the container ID from the previous step.

   docker kill 3766c4ab331c

To upload the image to Amazon ECR and create the Lambda function

1. Run the get-login-password command to authenticate the Docker CLI to your Amazon ECR registry.

   • Set the --region value to the Amazon Web Services Region where you want to create the Amazon ECR repository.

   • Replace 111122223333 with your Amazon Web Services account ID.

   aws ecr get-login-password --region cn-north-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn

2. Create a repository in Amazon ECR using the create-repository command.

   aws ecr create-repository --repository-name hello-world --region cn-north-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

   Note

   The Amazon ECR repository must be in the same Amazon Web Services Region as the Lambda function.

   If successful, you see a response like this:

   {
       "repository": {
           "repositoryArn": "arn:aws:ecr:cn-north-1:111122223333:repository/hello-world",
           "registryId": "111122223333",
           "repositoryName": "hello-world",
           "repositoryUri": "111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world",
           "createdAt": "2023-03-09T10:39:01+00:00",
           "imageTagMutability": "MUTABLE",
           "imageScanningConfiguration": {
               "scanOnPush": true
           },
           "encryptionConfiguration": {
               "encryptionType": "AES256"
           }
       }
   }

3. Copy the repositoryUri from the output in the previous step.

4. Run the docker tag command to tag your local image into your Amazon ECR repository as the latest version. In this command:

   • Replace docker-image:test with the name and tag of your Docker image.

   • Replace <ECRrepositoryUri> with the repositoryUri that you copied. Make sure to include :latest at the end of the URI.

   docker tag docker-image:test <ECRrepositoryUri>:latest

   Example:

   docker tag docker-image:test 111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world:latest

5. Run the docker push command to deploy your local image to the Amazon ECR repository. Make sure to include :latest at the end of the repository URI.

   docker push 111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world:latest

6. Create an execution role for the function, if you don't already have one. You need the Amazon Resource Name (ARN) of the role in the next step.

7. Create the Lambda function. For ImageUri, specify the repository URI from earlier. Make sure to include :latest at the end of the URI.

   aws lambda create-function \
     --function-name hello-world \
     --package-type Image \
     --code ImageUri=111122223333.dkr.ecr.cn-north-1.amazonaws.com.cn/hello-world:latest \
     --role arn:aws:iam::111122223333:role/lambda-ex

   Note

   You can create a function using an image in a different Amazon account, as long as the image is in the same Region as the Lambda function. For more information, see Amazon ECR cross-account permissions.

8. Invoke the function.

   aws lambda invoke --function-name hello-world response.json

   You should see a response like this:

   {
     "ExecutedVersion": "$LATEST", 
     "StatusCode": 200
   }

9. To see the output of the function, check the response.json file.