feat: ARM support

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"])

samtranslator/model/architecture.py

@@ -0,0 +1,5 @@
+""" 
+Enum for determining type of architectures for Lambda Function.
+"""
+ARM64 = "arm64"
+X86_64 = "x86_64"

samtranslator/model/lambda_.py

@@ -26,6 +26,7 @@ class LambdaFunction(Resource):
         "FileSystemConfigs": PropertyType(False, list_of(is_type(dict))),
         "CodeSigningConfigArn": PropertyType(False, is_str()),
         "ImageConfig": PropertyType(False, is_type(dict)),
+        "Architectures": PropertyType(False, list_of(one_of(is_str(), is_type(dict)))),
     }
 
     runtime_attrs = {"name": lambda self: ref(self.logical_id), "arn": lambda self: fnGetAtt(self.logical_id, "Arn")}
@@ -113,6 +114,7 @@ class LambdaLayerVersion(Resource):
         "Content": PropertyType(True, is_type(dict)),
         "Description": PropertyType(False, is_str()),
         "LayerName": PropertyType(False, is_str()),
+        "CompatibleArchitectures": PropertyType(False, list_of(one_of(is_str(), is_type(dict)))),
         "CompatibleRuntimes": PropertyType(False, list_of(one_of(is_str(), is_type(dict)))),
         "LicenseInfo": PropertyType(False, is_str()),
     }

samtranslator/model/sam_resources.py

@@ -22,6 +22,7 @@
     ApiGatewayApiKey,
 )
 from samtranslator.model.apigatewayv2 import ApiGatewayV2Stage, ApiGatewayV2DomainName
+from samtranslator.model.architecture import ARM64, X86_64
 from samtranslator.model.cloudformation import NestedStack
 from samtranslator.model.dynamodb import DynamoDBTable
 from samtranslator.model.exceptions import InvalidEventException, InvalidResourceException
@@ -91,6 +92,7 @@ class SamFunction(SamResourceMacro):
         "FileSystemConfigs": PropertyType(False, list_of(is_type(dict))),
         "ImageConfig": PropertyType(False, is_type(dict)),
         "CodeSigningConfigArn": PropertyType(False, is_str()),
+        "Architectures": PropertyType(False, list_of(one_of(is_str(), is_type(dict)))),
     }
     event_resolver = ResourceTypeResolver(
         samtranslator.model.eventsources,
@@ -419,6 +421,7 @@ def _construct_lambda_function(self):
         lambda_function.FileSystemConfigs = self.FileSystemConfigs
         lambda_function.ImageConfig = self.ImageConfig
         lambda_function.PackageType = self.PackageType
+        lambda_function.Architectures = self.Architectures
 
         if self.Tracing:
             lambda_function.TracingConfig = {"Mode": self.Tracing}
@@ -429,6 +432,7 @@ def _construct_lambda_function(self):
         lambda_function.CodeSigningConfigArn = self.CodeSigningConfigArn
 
         self._validate_package_type(lambda_function)
+        self._validate_architectures(lambda_function)
         return lambda_function
 
     def _add_event_invoke_managed_policy(self, dest_config, logical_id, condition, dest_arn):
@@ -543,6 +547,36 @@ def _validate_package_type_image():
         # Call appropriate validation function based on the package type.
         return _validate_per_package_type[packagetype]()
 
+    def _validate_architectures(self, lambda_function):
+        """
+        Validates Function based on the existence of architecture type
+
+        parameters
+        ----------
+        lambda_function: LambdaFunction
+            Object of function properties supported on AWS Lambda
+
+        Raises
+        ------
+        InvalidResourceException
+            Raised when the Architectures property is invalid
+        """
+
+        architectures = [X86_64] if lambda_function.Architectures is None else lambda_function.Architectures
+
+        if is_intrinsic(architectures):
+            return
+
+        if (
+            not isinstance(architectures, list)
+            or len(architectures) != 1
+            or (not is_intrinsic(architectures[0]) and (architectures[0] not in [X86_64, ARM64]))
+        ):
+            raise InvalidResourceException(
+                lambda_function.logical_id,
+                "Architectures needs to be a list with one string, either `{}` or `{}`.".format(X86_64, ARM64),
+            )
+
     def _validate_dlq(self):
         """Validates whether the DeadLetterQueue LogicalId is validation
         :raise: InvalidResourceException
@@ -1138,6 +1172,7 @@ class SamLayerVersion(SamResourceMacro):
         "LayerName": PropertyType(False, one_of(is_str(), is_type(dict))),
         "Description": PropertyType(False, is_str()),
         "ContentUri": PropertyType(True, one_of(is_str(), is_type(dict))),
+        "CompatibleArchitectures": PropertyType(False, list_of(one_of(is_str(), is_type(dict)))),
         "CompatibleRuntimes": PropertyType(False, list_of(one_of(is_str(), is_type(dict)))),
         "LicenseInfo": PropertyType(False, is_str()),
         "RetentionPolicy": PropertyType(False, is_str()),
@@ -1220,6 +1255,9 @@ def _construct_lambda_layer(self, intrinsics_resolver):
         lambda_layer.LayerName = self.LayerName
         lambda_layer.Description = self.Description
         lambda_layer.Content = construct_s3_location_object(self.ContentUri, self.logical_id, "ContentUri")
+
+        lambda_layer.CompatibleArchitectures = self.CompatibleArchitectures
+        self._validate_architectures(lambda_layer)
         lambda_layer.CompatibleRuntimes = self.CompatibleRuntimes
         lambda_layer.LicenseInfo = self.LicenseInfo
 
@@ -1253,6 +1291,31 @@ def _get_retention_policy_value(self):
                 "'RetentionPolicy' must be one of the following options: {}.".format([self.RETAIN, self.DELETE]),
             )
 
+    def _validate_architectures(self, lambda_layer):
+        """Validate the values inside the CompatibleArchitectures field of a layer
+
+        Parameters
+        ----------
+        lambda_layer: SamLayerVersion
+            The AWS Lambda layer version to validate
+
+        Raises
+        ------
+        InvalidResourceException
+            If any of the architectures is not valid
+        """
+        architectures = lambda_layer.CompatibleArchitectures or [X86_64]
+        # Intrinsics are not validated
+        if is_intrinsic(architectures):
+            return
+        for arq in architectures:
+            # We validate the values only if we they're not intrinsics
+            if not is_intrinsic(arq) and not arq in [ARM64, X86_64]:
+                raise InvalidResourceException(
+                    lambda_layer.logical_id,
+                    "CompatibleArchitectures needs to be a list of '{}' or '{}'".format(X86_64, ARM64),
+                )
+
 
 class SamStateMachine(SamResourceMacro):
     """SAM state machine macro."""

samtranslator/plugins/globals/globals.py

@@ -42,6 +42,7 @@ class Globals(object):
             "EventInvokeConfig",
             "FileSystemConfigs",
             "CodeSigningConfigArn",
+            "Architectures",
         ],
         # Everything except
         #   DefinitionBody: because its hard to reason about merge of Swagger dictionaries