Skip building arm64 community images in patches (#47)

# Summary

It skips building arm64 docker images when building images in patches
and in evergreen.
arm64 images takes long time to build probably due to emulation (>10min
arm64 vs 10s amd64).

The change should not impact any daily build processes. 

## Proof of Work

Only manual run: 
[with skipped
arm64](https://spruce.mongodb.com/task/mongodb_kubernetes_init_test_run_build_readiness_probe_image_patch_f0050b8942545701e8cb9e42d54d14f0cb58ee6a_680bc0fd99bf4d0007ff73f4_25_04_25_17_06_06/logs?execution=0),
total time: 2min ([link to relevant log
message](https://parsley.mongodb.com/evergreen/mongodb_kubernetes_init_test_run_build_readiness_probe_image_patch_f0050b8942545701e8cb9e42d54d14f0cb58ee6a_680bc0fd99bf4d0007ff73f4_25_04_25_17_06_06/0/task?bookmarks=0%2C542&selectedLineRange=L505&shareLine=505))
[build from
master](https://spruce.mongodb.com/task/mongodb_kubernetes_init_test_run_build_readiness_probe_image_f0050b8942545701e8cb9e42d54d14f0cb58ee6a_25_04_25_12_41_27/logs?execution=1):
total time: 12min


## Checklist
- [ ] Have you linked a jira ticket and/or is the ticket in the title?
- [ ] Have you checked whether your jira ticket required DOCSP changes?
- [ ] Have you checked for release_note changes?

## Reminder (Please remove this when merging)
- Please try to Approve or Reject Changes the PR, keep PRs in review as
short as possible
- Our Short Guide for PRs:
[Link](https://docs.google.com/document/d/1T93KUtdvONq43vfTfUt8l92uo4e4SEEvFbIEKOxGr44/edit?tab=t.0)
- Remember the following Communication Standards - use comment prefixes
for clarity:
  * **blocking**: Must be addressed before approval.
  * **follow-up**: Can be addressed in a later PR or ticket.
  * **q**: Clarifying question.
  * **nit**: Non-blocking suggestions.
  * **note**: Side-note, non-actionable. Example: Praise 
  * --> no prefix is considered a question

Author: lsierant

pipeline.py

@@ -305,19 +305,19 @@ def copy_into_container(client, src, dst):
 # Sonar as an interface to docker. We decided to keep this asymmetry for now, as Sonar will be removed soon.
 
 
-def create_and_push_manifest(image: str, tag: str) -> None:
+def create_and_push_manifest(image: str, tag: str, architectures: list[str]) -> None:
     final_manifest = image + ":" + tag
 
     args = [
         "docker",
         "manifest",
         "create",
         final_manifest,
-        "--amend",
-        final_manifest + "-amd64",
-        "--amend",
-        final_manifest + "-arm64",
     ]
+
+    for arch in architectures:
+        args.extend(["--amend", f"{final_manifest}-{arch}"])
+
     args_str = " ".join(args)
     logger.debug(f"creating new manifest: {args_str}")
     cp = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -752,6 +752,14 @@ def submit(self, fn, *args, **kwargs):
 """
 
 
+def should_skip_arm64():
+    """
+    Determines if arm64 builds should be skipped based on environment.
+    Returns True if running in Evergreen pipeline as a patch.
+    """
+    return is_running_in_evg_pipeline() and is_running_in_patch()
+
+
 def build_image_daily(
     image_name: str,  # corresponds to the image_name in the release.json
     min_version: str = None,
@@ -766,6 +774,10 @@ def get_architectures_set(build_configuration, args):
         if arch_set == {"arm64"}:
             raise ValueError("Building for ARM64 only is not supported yet")
 
+        if should_skip_arm64():
+            logger.info("Skipping ARM64 builds as this is running in EVG pipeline as a patch")
+            return {"amd64"}
+
         # Automatic architecture detection is the default behavior if 'arch' argument isn't specified
         if arch_set == set():
             if check_multi_arch(
@@ -779,13 +791,13 @@ def get_architectures_set(build_configuration, args):
 
         return arch_set
 
-    def create_and_push_manifests(args: dict):
+    def create_and_push_manifests(args: dict, architectures: list[str]):
         """Create and push manifests for all registries."""
         registries = [args["ecr_registry_ubi"], args["quay_registry"]]
         tags = [args["release_version"], args["release_version"] + "-b" + args["build_id"]]
         for registry in registries:
             for tag in tags:
-                create_and_push_manifest(registry + args["ubi_suffix"], tag)
+                create_and_push_manifest(registry + args["ubi_suffix"], tag, architectures=architectures)
 
     def sign_image_concurrently(executor, args, futures, arch=None):
         v = args["release_version"]
@@ -838,7 +850,7 @@ def inner(build_configuration: BuildConfiguration):
                             )
                             if build_configuration.sign:
                                 sign_image_concurrently(executor, copy.deepcopy(args), futures, arch)
-                        create_and_push_manifests(args)
+                        create_and_push_manifests(args, list(arch_set))
                         for arch in arch_set:
                             args["architecture_suffix"] = f"-{arch}"
                             args["platform"] = arch
@@ -985,12 +997,13 @@ def build_image_generic(
     if is_multi_arch:
         # we only push the manifests of the context images here,
         # since daily rebuilds will push the manifests for the proper images later
-        create_and_push_manifest(registry_address, f"{version}-context")
+        architectures = [v["architecture"] for v in multi_arch_args_list]
+        create_and_push_manifest(registry_address, f"{version}-context", architectures=architectures)
         if not config.is_release_step_executed():
             # Normally daily rebuild would create and push the manifests for the non-context images.
             # But since we don't run daily rebuilds on ecr image builds, we can do that step instead here.
             # We only need to push manifests for multi-arch images.
-            create_and_push_manifest(registry_address, version)
+            create_and_push_manifest(registry_address, version, architectures=architectures)
     if config.sign and config.is_release_step_executed():
         sign_and_verify_context_image(registry, version)
     if config.is_release_step_executed() and version and QUAY_REGISTRY_URL in registry:
@@ -1044,7 +1057,14 @@ def build_community_image(build_configuration: BuildConfiguration, image_type: s
 
     version, is_release = get_git_release_tag()
     golang_version = os.getenv("GOLANG_VERSION", "1.24")
-    architectures = build_configuration.architecture or ["amd64", "arm64"]
+
+    # Use only amd64 if we should skip arm64 builds
+    if should_skip_arm64():
+        architectures = ["amd64"]
+        logger.info("Skipping ARM64 builds for community image as this is running in EVG pipeline as a patch")
+    else:
+        architectures = build_configuration.architecture or ["amd64", "arm64"]
+
     multi_arch_args_list = []
 
     for arch in architectures:
@@ -1064,7 +1084,7 @@ def build_community_image(build_configuration: BuildConfiguration, image_type: s
         multi_arch_args_list=multi_arch_args_list,
         inventory_file=inventory_file,
         registry_address=f"{base_repo}/{image_name}",
-        is_multi_arch=True,
+        is_multi_arch=True,  # We for pushing manifest anyway, even if arm64 is skipped in patches
     )
 
 
@@ -1151,16 +1171,19 @@ def build_multi_arch_agent_in_sonar(
     ecr_registry = os.environ.get("REGISTRY", "268558157000.dkr.ecr.us-east-1.amazonaws.com/dev")
     ecr_agent_registry = ecr_registry + f"/mongodb-agent-ubi"
     quay_agent_registry = QUAY_REGISTRY_URL + f"/mongodb-agent-ubi"
-    joined_args = list()
-    for arch in [arch_arm, arch_amd]:
-        joined_args.append(args | arch)
+    joined_args = [arch_amd]
+
+    # Only include arm64 if we shouldn't skip it
+    if not should_skip_arm64():
+        joined_args.append(arch_arm)
+
     build_image_generic(
         config=build_configuration,
         image_name="mongodb-agent",
         inventory_file="inventories/agent_non_matrix.yaml",
         multi_arch_args_list=joined_args,
         registry_address=quay_agent_registry if is_release else ecr_agent_registry,
-        is_multi_arch=True,
+        is_multi_arch=True,  # We for pushing manifest anyway, even if arm64 is skipped in patches
         is_run_in_parallel=True,
     )
 

pipeline_test.py

@@ -225,3 +225,102 @@ def test_all_retries_fail(self, mock_sleep, mock_run):
 
         self.assertEqual(mock_run.call_count, 3)
         self.assertEqual(mock_sleep.call_count, 2)
+
+
+@patch("subprocess.run")
+def test_create_and_push_manifest_success(mock_run):
+    """Test successful creation and pushing of manifest with multiple architectures."""
+    # Setup mock to return success for both calls
+    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=0, stdout=b"", stderr=b"")
+
+    image = "test/image"
+    tag = "1.0.0"
+    architectures = ["amd64", "arm64"]
+
+    from pipeline import create_and_push_manifest
+
+    create_and_push_manifest(image, tag, architectures)
+
+    assert mock_run.call_count == 2
+
+    # Verify first call - create manifest
+    create_call_args = mock_run.call_args_list[0][0][0]
+    assert create_call_args == [
+        "docker",
+        "manifest",
+        "create",
+        "test/image:1.0.0",
+        "--amend",
+        "test/image:1.0.0-amd64",
+        "--amend",
+        "test/image:1.0.0-arm64",
+    ]
+
+    # Verify second call - push manifest
+    push_call_args = mock_run.call_args_list[1][0][0]
+    assert push_call_args == ["docker", "manifest", "push", f"{image}:{tag}"]
+
+
+@patch("subprocess.run")
+def test_create_and_push_manifest_single_arch(mock_run):
+    """Test manifest creation with a single architecture."""
+    # Setup mock to return success for both calls
+    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=0, stdout=b"", stderr=b"")
+
+    image = "test/image"
+    tag = "1.0.0"
+    architectures = ["amd64"]
+
+    from pipeline import create_and_push_manifest
+
+    create_and_push_manifest(image, tag, architectures)
+
+    # Verify first call - create manifest (should only include one architecture)
+    create_call_args = mock_run.call_args_list[0][0][0]
+    assert " ".join(create_call_args) == f"docker manifest create {image}:{tag} --amend {image}:{tag}-amd64"
+
+
+@patch("subprocess.run")
+def test_create_and_push_manifest_create_error(mock_run):
+    """Test error handling when manifest creation fails."""
+    # Setup mock to return error for create call
+    mock_run.return_value = subprocess.CompletedProcess(
+        args=[], returncode=1, stdout=b"", stderr=b"Error creating manifest"
+    )
+
+    image = "test/image"
+    tag = "1.0.0"
+    architectures = ["amd64", "arm64"]
+
+    from pipeline import create_and_push_manifest
+
+    # Verify exception is raised with the stderr content
+    with pytest.raises(Exception) as exc_info:
+        create_and_push_manifest(image, tag, architectures)
+
+    assert "Error creating manifest" in str(exc_info.value)
+    assert mock_run.call_count == 1  # Only the create call, not the push call
+
+
+@patch("subprocess.run")
+def test_create_and_push_manifest_push_error(mock_run):
+    """Test error handling when manifest push fails."""
+    # Setup mock to return success for create but error for push
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(args=[], returncode=0, stdout=b"", stderr=b""),  # create success
+        subprocess.CompletedProcess(args=[], returncode=1, stdout=b"", stderr=b"Error pushing manifest"),  # push error
+    ]
+
+    # Call function with test parameters
+    image = "test/image"
+    tag = "1.0.0"
+    architectures = ["amd64", "arm64"]
+
+    from pipeline import create_and_push_manifest
+
+    # Verify exception is raised with the stderr content
+    with pytest.raises(Exception) as exc_info:
+        create_and_push_manifest(image, tag, architectures)
+
+    assert "Error pushing manifest" in str(exc_info.value)
+    assert mock_run.call_count == 2  # Both create and push calls