Support for arm64 architecture (aws#52)

Author: valerena

Makefile

@@ -2,31 +2,43 @@
 RELEASE_BUILD_LINKER_FLAGS=-s -w
 
 BINARY_NAME=aws-lambda-rie
-DESTINATION=bin/${BINARY_NAME}
+ARCH=x86_64
+GO_ARCH_old := amd64
+GO_ARCH_x86_64 := amd64
+GO_ARCH_arm64 := arm64
+DESTINATION_old:= bin/${BINARY_NAME}
+DESTINATION_x86_64 := bin/${BINARY_NAME}-x86_64
+DESTINATION_arm64 := bin/${BINARY_NAME}-arm64
+
+compile-with-docker-all:
+	make ARCH=x86_64 compile-with-docker
+	make ARCH=arm64 compile-with-docker
+	make ARCH=old compile-with-docker
+
+compile-lambda-linux-all:
+	make ARCH=x86_64 compile-lambda-linux
+	make ARCH=arm64 compile-lambda-linux
+	make ARCH=old compile-lambda-linux
 
 compile-with-docker:
-	docker run --env GOPROXY=direct -v $(shell pwd):/LambdaRuntimeLocal -w /LambdaRuntimeLocal golang:1.14 make compile-lambda-linux
+	docker run --env GOPROXY=direct -v $(shell pwd):/LambdaRuntimeLocal -w /LambdaRuntimeLocal golang:1.14 make ARCH=${ARCH} compile-lambda-linux
 
 compile-lambda-linux:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "${RELEASE_BUILD_LINKER_FLAGS}" -o ${DESTINATION} ./cmd/aws-lambda-rie
+	CGO_ENABLED=0 GOOS=linux GOARCH=${GO_ARCH_${ARCH}} go build -ldflags "${RELEASE_BUILD_LINKER_FLAGS}" -o ${DESTINATION_${ARCH}} ./cmd/aws-lambda-rie
 
 tests:
 	go test ./...
 
-integ-tests-and-compile: tests compile-lambda-linux
-	python3 -m venv .venv
-	.venv/bin/pip install --upgrade pip
-	.venv/bin/pip install requests
-	.venv/bin/python3 test/integration/local_lambda/end-to-end-test.py
-
-integ-tests-with-docker: tests compile-with-docker
-	python3 -m venv .venv
-	.venv/bin/pip install --upgrade pip
-	.venv/bin/pip install requests
-	.venv/bin/python3 test/integration/local_lambda/end-to-end-test.py
+integ-tests-and-compile: tests 
+	make compile-lambda-linux-all
+	make integ-tests
 
+integ-tests-with-docker: tests 
+	make compile-with-docker-all
+	make integ-tests
+	
 integ-tests:
 	python3 -m venv .venv
 	.venv/bin/pip install --upgrade pip
-	.venv/bin/pip install requests
-	.venv/bin/python3 test/integration/local_lambda/end-to-end-test.py
+	.venv/bin/pip install requests parameterized
+	.venv/bin/python3 test/integration/local_lambda/test_end_to_end.py

README.md

@@ -18,9 +18,10 @@ Instructions for installing AWS Lambda Runtime Interface Emulator for your platf
 
 | Platform | Command to install |
 |---------|---------
-| macOS | `mkdir -p ~/.aws-lambda-rie && curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && chmod +x ~/.aws-lambda-rie/aws-lambda-rie` |
-| Linux | `mkdir -p ~/.aws-lambda-rie && curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && chmod +x ~/.aws-lambda-rie/aws-lambda-rie` |
-| Windows | `Invoke-WebRequest -OutFile 'C:\Program Files\aws lambda\aws-lambda-rie' https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie` |
+| macOS/Linux x86\_64 | `mkdir -p ~/.aws-lambda-rie && curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && chmod +x ~/.aws-lambda-rie/aws-lambda-rie` |
+| macOS/Linux arm64 | `mkdir -p ~/.aws-lambda-rie && curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64 && chmod +x ~/.aws-lambda-rie/aws-lambda-rie` |
+| Windows x86\_64 | `Invoke-WebRequest -OutFile 'C:\Program Files\aws lambda\aws-lambda-rie' https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie` |
+| Windows arm64 | `Invoke-WebRequest -OutFile 'C:\Program Files\aws lambda\aws-lambda-rie' https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64` |
 
 
 ## Getting started
@@ -53,10 +54,14 @@ The AWS base images for Lambda include the runtime interface emulator. You can a
 ### Build RIE into your base image
 
 You can build RIE into a base image. Download the RIE from GitHub to your local machine and update your Dockerfile to install RIE.
- 
+
 #### To build the emulator into your image
 
-1. Create a script and save it in your project directory. The following example shows a typical script for a Node.js function. The presence of the AWS_LAMBDA_RUNTIME_API environment variable indicates the presence of the runtime API. If the runtime API is present, the script runs the runtime interface client (https://docs.aws.amazon.com/lambda/latest/dg/runtimes-images.html#runtimes-api-client). Otherwise, the script runs the runtime interface emulator. 
+1. Create a script and save it in your project directory. Set execution permissions for the script file.
+
+The script checks for the presence of the `AWS_LAMBDA_RUNTIME_API` environment variable, which indicates the presence of the runtime API. If the runtime API is present, the script runs [the runtime interface client](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-images.html#runtimes-api-client). Otherwise, the script runs the runtime interface emulator.
+
+The following example shows a typical script for a Node.js function.
     ```
     #!/bin/sh
     if [ -z "${AWS_LAMBDA_RUNTIME_API}" ]; then
@@ -65,45 +70,56 @@ You can build RIE into a base image. Download the RIE from GitHub to your local
       exec /usr/bin/npx aws-lambda-ric
     fi
     ```
-   
-2. Download the runtime interface emulator (https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie) from GitHub into your project directory. 
 
-3. Install the emulator package and change ENTRYPOINT to run the new script by adding the following lines to your Dockerfile:
+2. Download the [runtime interface emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest) for your target architecture (`aws-lambda-rie` for x86\_64 or `aws-lambda-rie-arm64` for arm64) from GitHub into your project directory. 
+
+3. Install the emulator package and change `ENTRYPOINT` to run the new script by adding the following lines to your Dockerfile:
+
+To use the default x86\_64 architecture
+    ```
+    ADD aws-lambda-rie /usr/local/bin/aws-lambda-rie
+    ENTRYPOINT [ "/entry_script.sh" ]
+    ```
+
+To use the arm64 architecture:
     ```
-    ADD aws-lambda-rie /usr/local/bin/aws-lambda-rie 
+    ADD aws-lambda-rie-arm64 /usr/local/bin/aws-lambda-rie
     ENTRYPOINT [ "/entry_script.sh" ]
     ```
 
-4. Build your image locally using the docker build command. 
+4. Build your image locally using the docker build command.
     ```
     docker build -t myfunction:latest .
     ```
 
-5. Run your image locally using the docker run command.     
+5. Run your image locally using the docker run command.
     ```
     docker run -p 9000:8080 myfunction:latest
     ```
 
 ### Test an image without adding RIE to the image
 
-You install the runtime interface emulator to your local machine. When you run the image function, you set the entry point to be the emulator. 
+You install the runtime interface emulator to your local machine. When you run the container image, you set the entry point to be the emulator.
 *To test an image without adding RIE to the image *
 
-1. From your project directory, run the following command to download the RIE from GitHub and install it on your local machine. 
+1. From your project directory, run the following command to download the RIE (x86-64 architecture) from GitHub and install it on your local machine.
 
     ```
-   mkdir -p ~/.aws-lambda-rie && curl -Lo ~/.aws-lambda-rie/aws-lambda-rie \
-   https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie \
-   && chmod +x ~/.aws-lambda-rie/aws-lambda-rie
-   ```      
+    mkdir -p ~/.aws-lambda-rie && curl -Lo ~/.aws-lambda-rie/aws-lambda-rie \
+    https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie \
+    && chmod +x ~/.aws-lambda-rie/aws-lambda-rie
+    ```      
 
-2. Run your Lambda image function using the docker run command. 
+To download the RIE for arm64 architecture, use the previous command with a different GitHub download url.
+    ```
+    https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64 \
+    ```
 
+2. Run your Lambda image function using the docker run command. 
+    ```
+    docker run -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 myfunction:latest 
+        --entrypoint /aws-lambda/aws-lambda-rie  <image entrypoint> <(optional) image command>`
     ```
-    docker run -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
-    --entrypoint /aws-lambda/aws-lambda-rie \
-    myfunction:latest  <image entrypoint> <(optional) image command>
-    ````
 
     This runs the image as a container and starts up an endpoint locally at `localhost:9000/2015-03-31/functions/function/invocations`. 
 
@@ -142,7 +158,7 @@ configurations that will not be emulated by this component.
 * You can also use it to test extensions and agents built into the container image against the Lambda Extensions API.
 * This component does _not_ emulate Lambda’s orchestration, or security and authentication configurations. 
 * The component does _not_ support X-ray and other Lambda integrations locally. 
-* The component supports only Linux x86-64 architectures.
+* The component supports only Linux, for x86-64 and arm64 architectures.
 
 ## Security
 

test/integration/local_lambda/end-to-end-test.py

@@ -0,0 +1,209 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from subprocess import Popen, PIPE
+from unittest import TestCase, main
+from pathlib import Path
+import time
+
+import requests
+from parameterized import parameterized
+
+SLEEP_TIME = 2
+DEFAULT_1P_ENTRYPOINT = "/lambda-entrypoint.sh"
+ARCHS = ["x86_64", "arm64", ""]
+
+
+class TestEndToEnd(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        testdata_path = Path(__file__).resolve().parents[1].joinpath("testdata")
+        dockerfile_path = testdata_path.joinpath("Dockerfile-allinone")
+        cls.image_name = "aws-lambda-local:testing"
+        cls.path_to_binary = Path().resolve().joinpath("bin")
+
+        # build image
+        for arch in ARCHS:
+            image_name = cls.image_name if arch == "" else f"{cls.image_name}-{arch}"
+            architecture = arch if arch == "arm64" else "amd64"
+            build_cmd = [
+                "docker",
+                "build",
+                "--platform",
+                f"linux/{architecture}",
+                "-t",
+                image_name,
+                "-f",
+                str(dockerfile_path),
+                str(testdata_path),
+            ]
+            Popen(build_cmd).communicate()
+
+    @classmethod
+    def tearDownClass(cls):
+        images_to_delete = [
+            "envvarcheck",
+            "twoinvokes",
+            "arnexists",
+            "customname",
+            "timeout",
+            "exception",
+            "pre-runtime-api",
+            "assert-overwritten",
+        ]
+
+        for image in images_to_delete:
+            for arch in ARCHS:
+                arch_tag = "" if arch == "" else f"-{arch}"
+                cmd = f"docker rm -f {image}{arch_tag}"
+                Popen(cmd.split(" ")).communicate()
+            
+        for arch in ARCHS:
+            arch_tag = "" if arch == "" else f"-{arch}"
+            Popen(f"docker rmi {cls.image_name}{arch_tag}".split(" ")).communicate()
+
+    def tagged_name(self, name, architecture):
+        tag = self.get_tag(architecture)
+        return (name + tag, "aws-lambda-rie" + tag, self.image_name + tag)
+        
+    def get_tag(self, architecture):
+        return "" if architecture == "" else str(f"-{architecture}")
+
+    @parameterized.expand([("x86_64", "8000"), ("arm64", "9001"), ("", "9003")])
+    def test_env_var_with_equal_sign(self, arch, port):
+        image, rie, image_name = self.tagged_name("envvarcheck", arch)
+
+        cmd = f"docker run --name {image} -d -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.check_env_var_handler"
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b'"4=4"', r.content)
+
+    @parameterized.expand([("x86_64", "8001"), ("arm64", "9002"), ("", "9005")])
+    def test_two_invokes(self, arch, port):
+        image, rie, image_name = self.tagged_name("twoinvokes", arch)
+
+        cmd = f"docker run --name {image} -d -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.success_handler"
+
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b'"My lambda ran succesfully"', r.content)
+
+        # Make sure we can invoke the function twice
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b'"My lambda ran succesfully"', r.content)
+
+    @parameterized.expand([("x86_64", "8002"), ("arm64", "9004"), ("", "9007")])
+    def test_lambda_function_arn_exists(self, arch, port):
+        image, rie, image_name = self.tagged_name("arnexists", arch)
+        
+        cmd = f"docker run --name {image} -d -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.assert_lambda_arn_in_context"
+
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b'"My lambda ran succesfully"', r.content)
+
+    @parameterized.expand([("x86_64", "8003"), ("arm64", "9006"), ("", "9009")])
+    def test_lambda_function_arn_exists_with_defining_custom_name(self, arch, port):
+        image, rie, image_name = self.tagged_name("customname", arch)
+        
+        cmd = f"docker run --name {image} --env AWS_LAMBDA_FUNCTION_NAME=MyCoolName -d -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.assert_lambda_arn_in_context"
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b'"My lambda ran succesfully"', r.content)
+
+    @parameterized.expand([("x86_64", "8004"), ("arm64", "9008"), ("", "9011")])
+    def test_timeout_invoke(self, arch, port):
+        image, rie, image_name = self.tagged_name("timeout", arch)
+        
+        cmd = f"docker run --name {image} -d --env AWS_LAMBDA_FUNCTION_TIMEOUT=1 -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.sleep_handler"
+
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b"Task timed out after 1.00 seconds", r.content)
+
+    @parameterized.expand([("x86_64", "8005"), ("arm64", "9010"), ("", "9013")])
+    def test_exception_returned(self, arch, port):
+        image, rie, image_name = self.tagged_name("exception", arch)
+        
+        cmd = f"docker run --name {image} -d -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.exception_handler"
+
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(
+            b'{"errorMessage": "Raising an exception", "errorType": "Exception", "stackTrace": ["  File \\"/var/task/main.py\\", line 13, in exception_handler\\n    raise Exception(\\"Raising an exception\\")\\n"]}',
+            r.content,
+        )
+
+    @parameterized.expand([("x86_64", "8006"), ("arm64", "9012"), ("", "9015")])
+    def test_invoke_with_pre_runtime_api_runtime(self, arch, port):
+        image, rie, image_name = self.tagged_name("pre-runtime-api", arch)
+        
+        cmd = f"docker run --name {image} -d -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.success_handler"
+
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b'"My lambda ran succesfully"', r.content)
+
+    @parameterized.expand([("x86_64", "8007"), ("arm64", "9014"), ("", "9016")])
+    def test_function_name_is_overriden(self, arch, port):
+        image, rie, image_name = self.tagged_name("assert-overwritten", arch)
+        
+        cmd = f"docker run --name {image} -d --env AWS_LAMBDA_FUNCTION_NAME=MyCoolName -v {self.path_to_binary}:/local-lambda-runtime-server -p {port}:8080 --entrypoint /local-lambda-runtime-server/{rie} {image_name} {DEFAULT_1P_ENTRYPOINT} main.assert_env_var_is_overwritten"
+
+        Popen(cmd.split(" ")).communicate()
+
+        # sleep 1s to give enough time for the endpoint to be up to curl
+        time.sleep(SLEEP_TIME)
+
+        r = requests.post(
+            f"http://localhost:{port}/2015-03-31/functions/function/invocations", json={}
+        )
+        self.assertEqual(b'"My lambda ran succesfully"', r.content)
+
+
+if __name__ == "__main__":
+    main()

test/integration/local_lambda/test_end_to_end.py

@@ -4,4 +4,4 @@ WORKDIR /var/task
 COPY ./ ./
 
 # This is to verify env vars are parsed correctly before executing the function
-ENV MyEnv="4=4"
+ENV MyEnv="4=4"