(Refresh) Add arm64 architecture support (#1379)

* Add Support for Graviton 2 / ARM Architecture

* Changed parameter in README to architecture

* Removed redundant blank line

* Bugfix + black compliance

* Fix: architecture argument not used properly

* Fixed black compliance

* Fixed architecture label for wheels, added check for invalid architecture

* Testing architecture

* Added tests for ARM64 architecture

* Only allow ARM64 arch if Python version >= 3.8

* Removed redundant references to architecture

* Removed redundant references to architecture

* Added test for default architecture setting

* added .pre-commit hook for black-check and isort-check

* Fixed test failure  in Python 3.7

* 🔧 re-work regex for abi3

* 🔧 fix Zappa.create_lambda_function to pass a list to 'Architectures' in `create_function()` call.

* 🐛 fix typo in json

---------

Co-authored-by: DS992 <>
Co-authored-by: Gabor Schulz <[email protected]>
Co-authored-by: shane <[email protected]>

Author: 3 people

README.md

@@ -897,6 +897,7 @@ to change Zappa's behavior. Use these at your own risk!
         "assume_policy": "my_assume_policy.json", // optional, IAM assume policy JSON file
         "attach_policy": "my_attach_policy.json", // optional, IAM attach policy JSON file
         "apigateway_policy": "my_apigateway_policy.json", // optional, API Gateway resource policy JSON file
+        "architecture": "x86_64", // optional, Set Lambda Architecture, defaults to x86_64. For Graviton 2 use: arm64
         "async_source": "sns", // Source of async tasks. Defaults to "lambda"
         "async_resources": true, // Create the SNS topic and DynamoDB table to use. Defaults to true.
         "async_response_table": "your_dynamodb_table_name",  // the DynamoDB table name to use for captured async responses; defaults to None (can't capture)

test_settings.json

@@ -142,5 +142,19 @@
        "delete_local_zip": true,
        "binary_support": true,
        "additional_text_mimetypes": ["application/custommimetype"]
-    }
+    },
+    "arch_arm64": {
+        "s3_bucket": "lmbda",
+        "app_function": "tests.test_app.hello_world",
+        "delete_local_zip": true,
+        "debug": true,
+        "architecture": "arm64"
+     },
+     "archfail": {
+        "s3_bucket": "lmbda",
+        "app_function": "tests.test_app.hello_world",
+        "delete_local_zip": true,
+        "debug": true,
+        "architecture": "invalid_architecture"
+     }
 }

tests/tests.py

@@ -239,14 +239,13 @@ def test_get_manylinux_python313(self):
 
     def test_verify_downloaded_manylinux_wheel(self):
         z = Zappa(runtime="python3.10")
-        cached_wheels_dir = os.path.join(tempfile.gettempdir(), "cached_wheels")
-        expected_wheel_path = os.path.join(
-            cached_wheels_dir,
-            "pycryptodome-3.16.0-cp35-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl",
+        cached_wheels_dir = Path(tempfile.gettempdir()) / "cached_wheels"
+        expected_wheel_path = (
+            cached_wheels_dir / "pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl"
         )
 
         # check with a known manylinux wheel package
-        actual_wheel_path = z.get_cached_manylinux_wheel("pycryptodome", "3.16.0")
+        actual_wheel_path = z.get_cached_manylinux_wheel("pycryptodome", "3.23.0")
         self.assertEqual(actual_wheel_path, expected_wheel_path)
         os.remove(actual_wheel_path)
 
@@ -1409,6 +1408,21 @@ def test_load_extended_settings(self):
         zappa_cli.load_settings("test_settings.json")
         self.assertEqual("lmbda", zappa_cli.stage_config["s3_bucket"])
         self.assertEqual(True, zappa_cli.stage_config["touch"])
+        self.assertIn("x86_64", zappa_cli.architecture)
+
+        if sys.version_info.major == 3 and sys.version_info.minor < 8:
+            with self.assertRaises(ValueError):
+                zappa_cli = ZappaCLI()
+                zappa_cli.api_stage = "arch_arm64"
+                zappa_cli.load_settings("test_settings.json")
+                self.assertIn("arm64", zappa_cli.stage_config["architecture"])
+                self.assertIn("arm64", zappa_cli.architecture)
+        else:
+            zappa_cli = ZappaCLI()
+            zappa_cli.api_stage = "arch_arm64"
+            zappa_cli.load_settings("test_settings.json")
+            self.assertIn("arm64", zappa_cli.stage_config["architecture"])
+            self.assertIn("arm64", zappa_cli.architecture)
 
         zappa_cli = ZappaCLI()
         zappa_cli.api_stage = "extendofail"
@@ -1427,6 +1441,11 @@ def test_load_extended_settings(self):
         self.assertTrue(zappa_cli.stage_config["touch"])  # First Extension
         self.assertTrue(zappa_cli.stage_config["delete_local_zip"])  # The base
 
+        zappa_cli = ZappaCLI()
+        zappa_cli.api_stage = "archfail"
+        with self.assertRaises(ValueError):
+            zappa_cli.load_settings("test_settings.json")
+
     def test_load_settings__lambda_concurrency_enabled(self):
         zappa_cli = ZappaCLI()
         zappa_cli.api_stage = "lambda_concurrency_enabled"

zappa/cli.py

@@ -124,6 +124,7 @@ class ZappaCLI:
     additional_text_mimetypes = None
     tags = []  # type: ignore[var-annotated]
     layers = None
+    architecture = None
 
     stage_name_env_pattern = re.compile("^[a-zA-Z0-9_]+$")
 
@@ -2261,7 +2262,7 @@ def load_settings(self, settings_file=None, session=None):
         self.dead_letter_config = {"TargetArn": dead_letter_arn} if dead_letter_arn else {}
         self.cognito = self.stage_config.get("cognito", None)
         self.num_retained_versions = self.stage_config.get("num_retained_versions", None)
-
+        self.architecture = self.stage_config.get("architecture", "x86_64")
         # Check for valid values of num_retained_versions
         if self.num_retained_versions is not None and type(self.num_retained_versions) is not int:
             raise ClickException(
@@ -2331,6 +2332,7 @@ def load_settings(self, settings_file=None, session=None):
             tags=self.tags,
             endpoint_urls=self.stage_config.get("aws_endpoint_urls", {}),
             xray_tracing=self.xray_tracing,
+            architecture=self.architecture,
         )
 
         for setting in CUSTOM_SETTINGS:

zappa/core.py

@@ -239,10 +239,44 @@
 # the Lambda.
 # See: https://github.com/Miserlou/Zappa/pull/1730
 ALB_LAMBDA_ALIAS = "current-alb-version"
-
-##
-# Classes
-##
+X86_ARCHITECTURE = "x86_64"
+ARM_ARCHITECTURE = "arm64"
+VALID_ARCHITECTURES = (X86_ARCHITECTURE, ARM_ARCHITECTURE)
+
+
+def build_manylinux_wheel_file_match_pattern(runtime: str, architecture: str) -> re.Pattern:
+    # Support PEP600 (https://peps.python.org/pep-0600/)
+    # The wheel filename is {distribution}-{version}(-{build tag})?-{python tag}-{abi tag}-{platform tag}.whl
+    runtime_major_version, runtime_minor_version = runtime[6:].split(".")
+    python_tag = f"cp{runtime_major_version}{runtime_minor_version}"  # python3.13 -> cp313
+    manylinux_legacy_tags = ("manylinux2014", "manylinux2010", "manylinux1")
+    if architecture == X86_ARCHITECTURE:
+        valid_platform_tags = [X86_ARCHITECTURE]
+    elif architecture == ARM_ARCHITECTURE:
+        valid_platform_tags = [ARM_ARCHITECTURE, "aarch64"]
+    else:
+        raise ValueError(f"Invalid 'architecture', must be one of {VALID_ARCHITECTURES}, got: {architecture}")
+
+    manylinux_wheel_file_match = (
+        rf'^.*{python_tag}-(manylinux_\d+_\d+_({"|".join(valid_platform_tags)})[.])?'
+        rf'({"|".join(manylinux_legacy_tags)})_({"|".join(valid_platform_tags)})[.]whl$'
+    )
+
+    # The 'abi3' tag is a compiled distribution format designed for compatibility across multiple Python 3 versions.
+    # An abi3 wheel is built against the stable ABI (Application Binary Interface) of a minimum supported Python version.
+    # -- make sure cp3XX version is <= to the runtime version (runtime_minor_version)
+    minimum_minor_version = 5
+    abi_valid_python_minor_versions = [str(i) for i in range(minimum_minor_version, int(runtime_minor_version) + 1)]
+    manylinux_suffixes = [r"_\d+_\d+", r"manylinux_\d+_\d+"]
+    manylinux_suffixes.extend(manylinux_legacy_tags)
+    manylinux_wheel_abi3_file_match = (
+        # rf'^.*cp3.-abi3-manylinux({"|".join(manylinux_suffixes)})_({"|".join(valid_platform_tags)}).whl$'
+        rf'^.*cp3({"|".join(abi_valid_python_minor_versions)})-abi3-'
+        rf'manylinux(({"|".join(manylinux_suffixes)})_({"".join(valid_platform_tags)})(\.|))+.whl$'
+    )
+    combined_match_pattern = rf"({manylinux_wheel_file_match})|({manylinux_wheel_abi3_file_match})"
+    manylinux_wheel_file_match_pattern = re.compile(combined_match_pattern)
+    return manylinux_wheel_file_match_pattern
 
 
 class Zappa:
@@ -263,7 +297,7 @@ class Zappa:
     apigateway_policy = None
     cloudwatch_log_levels = ["OFF", "ERROR", "INFO"]
     xray_tracing = False
-
+    architecture = None
     ##
     # Credentials
     ##
@@ -283,6 +317,7 @@ def __init__(
         tags=(),
         endpoint_urls={},
         xray_tracing=False,
+        architecture=None,
     ):
         """
         Instantiate this new Zappa instance, loading any custom credentials if necessary.
@@ -304,14 +339,14 @@ def __init__(
 
         self.runtime = runtime
 
-        # TODO: Support PEP600 properly (https://peps.python.org/pep-0600/)
-        self.manylinux_suffix_start = f"cp{self.runtime[6:].replace('.', '')}"
-        self.manylinux_suffixes = ("_2_24", "2014", "2010", "1")
-        # TODO: Support aarch64 architecture
-        self.manylinux_wheel_file_match = re.compile(
-            rf'^.*{self.manylinux_suffix_start}-(manylinux_\d+_\d+_x86_64[.])?manylinux({"|".join(self.manylinux_suffixes)})_x86_64[.]whl$'  # noqa: E501
-        )
-        self.manylinux_wheel_abi3_file_match = re.compile(r"^.*cp3.-abi3-manylinux.*_x86_64[.]whl$")
+        if not architecture:
+            architecture = X86_ARCHITECTURE
+        if architecture not in VALID_ARCHITECTURES:
+            raise ValueError(f"Invalid architecture '{architecture}'. Must be one of: {VALID_ARCHITECTURES}")
+
+        self.architecture = architecture
+
+        self.manylinux_wheel_file_match = build_manylinux_wheel_file_match_pattern(runtime, architecture)
 
         self.endpoint_urls = endpoint_urls
         self.xray_tracing = xray_tracing
@@ -754,7 +789,7 @@ def splitpath(path):
                 # use the compiled bytecode anyway..
                 if filename[-3:] == ".py" and root[-10:] != "migrations":
                     abs_filename = os.path.join(root, filename)
-                    abs_pyc_filename = abs_filename + "c"
+                    abs_pyc_filename = f"{abs_filename}c"  # XXX.pyc
                     if os.path.isfile(abs_pyc_filename):
                         # but only if the pyc is older than the py,
                         # otherwise we'll deploy outdated code!
@@ -870,34 +905,33 @@ def get_cached_manylinux_wheel(self, package_name, package_version, disable_prog
         """
         Gets the locally stored version of a manylinux wheel. If one does not exist, the function downloads it.
         """
-        cached_wheels_dir = os.path.join(tempfile.gettempdir(), "cached_wheels")
+        cached_wheels_dir = Path(tempfile.gettempdir()) / "cached_wheels"
 
-        if not os.path.isdir(cached_wheels_dir):
-            os.makedirs(cached_wheels_dir)
+        if not cached_wheels_dir.is_dir() or not cached_wheels_dir.exists():
+            cached_wheels_dir.mkdir(parents=True, exist_ok=True)
         else:
             # Check if we already have a cached copy
+            # - get package name from prefix of the wheel file
             wheel_name = re.sub(r"[^\w\d.]+", "_", package_name, flags=re.UNICODE)
-            wheel_file = f"{wheel_name}-{package_version}-*_x86_64.whl"
-            wheel_path = os.path.join(cached_wheels_dir, wheel_file)
-
-            for pathname in glob.iglob(wheel_path):
-                if re.match(self.manylinux_wheel_file_match, pathname):
-                    logger.info(f" - {package_name}=={package_version}: Using locally cached manylinux wheel")
-                    return pathname
-                elif re.match(self.manylinux_wheel_abi3_file_match, pathname):
-                    for manylinux_suffix in self.manylinux_suffixes:
-                        if f"manylinux{manylinux_suffix}_x86_64" in pathname:
-                            logger.info(f" - {package_name}=={package_version}: Using locally cached manylinux wheel")
-                            return pathname
+            valid_architectures = (X86_ARCHITECTURE,)
+            if self.architecture == ARM_ARCHITECTURE:
+                valid_architectures = (ARM_ARCHITECTURE, "aarch64")
+            for arch in valid_architectures:
+                wheel_file_pattern = f"{wheel_name}-{package_version}-*_{arch}.whl"
+                for pathname in cached_wheels_dir.glob(wheel_file_pattern):
+                    if self.manylinux_wheel_file_match.match(str(pathname)):
+                        logger.info(f" - {package_name}=={package_version}: Using locally cached manylinux wheel")
+                        return pathname
 
         # The file is not cached, download it.
         wheel_url, filename = self.get_manylinux_wheel_url(package_name, package_version)
         if not wheel_url:
+            logger.warning(f" - {package_name}=={package_version}: No manylinux wheel found for this package")
             return None
 
-        wheel_path = os.path.join(cached_wheels_dir, filename)
+        wheel_path = cached_wheels_dir / filename
         logger.info(f" - {package_name}=={package_version}: Downloading")
-        with open(wheel_path, "wb") as f:
+        with wheel_path.open("wb") as f:
             self.download_url_with_progress(wheel_url, f, disable_progress)
 
         if not zipfile.is_zipfile(wheel_path):
@@ -917,23 +951,23 @@ def get_manylinux_wheel_url(self, package_name, package_version, ignore_cache: b
         every time.
         """
         cached_pypi_info_dir = Path(tempfile.gettempdir()) / "cached_pypi_info"
-        if not cached_pypi_info_dir.is_dir():
-            os.makedirs(cached_pypi_info_dir)
+        if not cached_pypi_info_dir.exists():
+            cached_pypi_info_dir.mkdir(parents=True, exist_ok=True)
 
         # Even though the metadata is for the package, we save it in a
         # filename that includes the package's version. This helps in
         # invalidating the cached file if the user moves to a different
         # version of the package.
         # Related: https://github.com/Miserlou/Zappa/issues/899
         data = None
-        json_file_name = "{0!s}-{1!s}.json".format(package_name, package_version)
+        json_file_name = f"{package_name!s}-{package_version!s}.json"
         json_file_path = cached_pypi_info_dir / json_file_name
         if json_file_path.exists():
             with json_file_path.open("rb") as metafile:
                 data = json.load(metafile)
 
         if not data or ignore_cache:
-            url = "https://pypi.python.org/pypi/{}/json".format(package_name)
+            url = f"https://pypi.python.org/pypi/{package_name}/json"
             try:
                 res = requests.get(url, timeout=float(os.environ.get("PIP_TIMEOUT", 1.5)))
                 data = res.json()
@@ -949,14 +983,10 @@ def get_manylinux_wheel_url(self, package_name, package_version, ignore_cache: b
             return None, None
 
         for f in data["releases"][package_version]:
-            if re.match(self.manylinux_wheel_file_match, f["filename"]):
+            if self.manylinux_wheel_file_match.match(f["filename"]):
                 # Since we have already lowered package names in get_installed_packages
                 # manylinux caching is not working for packages with capital case in names like MarkupSafe
                 return f["url"], f["filename"].lower()
-            elif re.match(self.manylinux_wheel_abi3_file_match, f["filename"]):
-                for manylinux_suffix in self.manylinux_suffixes:
-                    if f"manylinux{manylinux_suffix}_x86_64" in f["filename"]:
-                        return f["url"], f["filename"].lower()
         return None, None
 
     ##
@@ -1126,6 +1156,8 @@ def create_lambda_function(
             TracingConfig={"Mode": "Active" if self.xray_tracing else "PassThrough"},
             SnapStart={"ApplyOn": snap_start if snap_start else "None"},
             Layers=layers,
+            # zappa currently only supports a single architecture, and uses a str value internally
+            Architectures=[self.architecture],
         )
         if not docker_image_uri:
             kwargs["Runtime"] = runtime