feat: ARM support (#2163)

* feat: ARM architecture support for Function and Layer

* Add docs/tests for Globals Architectures (#85)

Co-authored-by: Renato Valenzuela <[email protected]>

Author: mgrandis

docs/globals.rst

@@ -70,6 +70,7 @@ Currently, the following resources and properties are being supported:
       PermissionsBoundary:
       ReservedConcurrentExecutions:
       EventInvokeConfig:
+      Architectures:
 
     Api:
       # Properties of AWS::Serverless::Api

integration/config/region_service_exclusion.yaml

@@ -8,20 +8,24 @@ regions:
     - IoT
     - GatewayResponses
     - HttpApi
+    - ARM
   ap-east-1:
     - Cognito
     - IoT
     - ServerlessRepo
     - HttpApi
+    - ARM
   ap-northeast-2:
     - HttpApi
+    - ARM
   ap-northeast-3:
     - Cognito
     - IoT
     - ServerlessRepo
     - XRay
     - CodeDeploy
     - HttpApi
+    - ARM
   ap-south-1:
     - HttpApi
   ap-southeast-1:
@@ -30,6 +34,7 @@ regions:
     - Cognito
     - IoT
     - HttpApi
+    - ARM
   cn-north-1:
     - ServerlessRepo
     - Cognito
@@ -39,6 +44,7 @@ regions:
     - IoT
     - GatewayResponses
     - HttpApi
+    - ARM
   cn-northwest-1:
     - ServerlessRepo
     - Cognito
@@ -48,12 +54,14 @@ regions:
     - IoT
     - GatewayResponses
     - HttpApi
+    - ARM
   eu-north-1:
     - ServerlessRepo
     - Cognito
     - IoT
     - HttpApi
     - Layers
+    - ARM
   eu-south-1:
     - ServerlessRepo
     - Cognito
@@ -63,24 +71,29 @@ regions:
     - IoT
     - GatewayResponses
     - HttpApi
+    - ARM
   eu-west-2:
     - HttpApi
   eu-west-3:
     - Cognito
     - IoT
     - XRay
     - HttpApi
+    - ARM
   me-south-1:
     - ServerlessRepo
     - Cognito
     - IoT
     - HttpApi
+    - ARM
   sa-east-1:
     - IoT
     - Cognito
     - HttpApi
+    - ARM
   us-east-2:
     - HttpApi
   us-west-1:
     - Cognito
     - IoT
+    - ARM

integration/resources/expected/single/basic_function_with_arm_architecture.json

@@ -0,0 +1,10 @@
+[
+  {
+    "LogicalResourceId": "MyLambdaFunction",
+    "ResourceType": "AWS::Lambda::Function"
+  },
+  {
+    "LogicalResourceId": "MyLambdaFunctionRole",
+    "ResourceType": "AWS::IAM::Role"
+  }
+]

integration/resources/expected/single/basic_function_with_x86_architecture.json

@@ -0,0 +1,10 @@
+[
+  {
+    "LogicalResourceId": "MyLambdaFunction",
+    "ResourceType": "AWS::Lambda::Function"
+  },
+  {
+    "LogicalResourceId": "MyLambdaFunctionRole",
+    "ResourceType": "AWS::IAM::Role"
+  }
+]

integration/resources/expected/single/basic_layer_with_compatible_architecture.json

@@ -0,0 +1,3 @@
+[
+  { "LogicalResourceId":"MyLayerVersion", "ResourceType":"AWS::Lambda::LayerVersion"}
+]

integration/resources/templates/single/basic_function_with_arm_architecture.yaml

@@ -0,0 +1,10 @@
+Resources:
+    MyLambdaFunction:
+        Type: AWS::Serverless::Function
+        Properties:
+            Handler: index.handler
+            Runtime: nodejs12.x
+            CodeUri: ${codeuri}
+            MemorySize: 128
+            Architectures: ["arm64"]
+            

integration/resources/templates/single/basic_function_with_x86_architecture.yaml

@@ -0,0 +1,11 @@
+Resources:
+    MyLambdaFunction:
+        Type: AWS::Serverless::Function
+        Properties:
+            Handler: index.handler
+            Runtime: nodejs12.x
+            CodeUri: ${codeuri}
+            MemorySize: 128
+            Architectures:
+                - x86_64
+            

integration/resources/templates/single/basic_layer_with_compatible_architecture.yaml

@@ -0,0 +1,28 @@
+Parameters:
+    Runtimes:
+        Type: CommaDelimitedList
+        Default: nodejs12.x,nodejs10.x
+    LayerName:
+        Type: String
+        Default: MyNamedLayerVersion
+    
+
+Resources:
+    MyLayerVersion:
+        Type: AWS::Serverless::LayerVersion
+        Properties:
+            ContentUri: ${contenturi}
+            LayerName:
+                Ref: LayerName
+            CompatibleRuntimes:
+                Ref: Runtimes
+            CompatibleArchitectures: [x86_64, arm64]
+
+Outputs:
+    MyLayerArn:
+        Value:
+            Ref: MyLayerVersion
+    LayerName:
+        Value:
+            Ref: LayerName
+            

integration/single/test_basic_function.py

@@ -44,6 +44,28 @@ def test_function_with_http_api_events(self, file_name):
 
         self.assertEqual(requests.get(endpoint).text, self.FUNCTION_OUTPUT)
 
+    @parameterized.expand(
+        [
+            ("single/basic_function", ["x86_64"]),
+            ("single/basic_function_no_envvar", ["x86_64"]),
+            ("single/basic_function_openapi", ["x86_64"]),
+            ("single/basic_function_with_arm_architecture", ["arm64"]),
+            ("single/basic_function_with_x86_architecture", ["x86_64"]),
+        ]
+    )
+    @skipIf(current_region_does_not_support(["ARM"]), "ARM is not supported in this testing region")
+    def test_basic_function_with_architecture(self, file_name, architecture):
+        """
+        Creates a basic lambda function
+        """
+        self.create_and_verify_stack(file_name)
+
+        lambda_client = self.client_provider.lambda_client
+        function_name = self.get_physical_id_by_type("AWS::Lambda::Function")
+        function_architecture = lambda_client.get_function_configuration(FunctionName=function_name)["Architectures"]
+
+        self.assertEqual(function_architecture, architecture)
+
     def test_function_with_deployment_preference_alarms_intrinsic_if(self):
         self.create_and_verify_stack("single/function_with_deployment_preference_alarms_intrinsic_if")
 

integration/single/test_basic_layer_version.py

@@ -10,7 +10,7 @@ class TestBasicLayerVersion(BaseTest):
     """
 
     @skipIf(current_region_does_not_support(["Layers"]), "Layers is not supported in this testing region")
-    def test_basic_layer_version(self):
+    def test_basic_layer_version(self, filename):
         """
         Creates a basic lambda layer version
         """
@@ -46,3 +46,21 @@ def test_basic_layer_with_parameters(self):
 
         self.assertEqual(layer_version_result["LicenseInfo"], license)
         self.assertEqual(layer_version_result["Description"], description)
+
+    @skipIf(current_region_does_not_support(["Layers"]), "Layers is not supported in this testing region")
+    @skipIf(current_region_does_not_support(["ARM"]), "ARM is not supported in this testing region")
+    def test_basic_layer_with_architecture(self):
+        """
+        Creates a basic lambda layer version specifying compatible architecture
+        """
+        self.create_and_verify_stack("single/basic_layer_with_compatible_architecture")
+
+        outputs = self.get_stack_outputs()
+        layer_arn = outputs["MyLayerArn"]
+        layer_name = outputs["LayerName"]
+
+        layer_version_result = self.client_provider.lambda_client.get_layer_version_by_arn(Arn=layer_arn)
+        self.client_provider.lambda_client.delete_layer_version(
+            LayerName=layer_name, VersionNumber=layer_version_result["Version"]
+        )
+        self.assertEqual(layer_version_result["CompatibleArchitectures"], ["x86_64", "arm64"])