From 0d860be0b6263169dfebf705a21a50ed97342386 Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Fri, 11 Jul 2025 17:54:35 +0000 Subject: [PATCH 1/3] Updates --- .../arm-cost-savings/_index.md | 75 ++++++++-------- .../arm-cost-savings/migrationsteps.md | 87 +++++++++---------- 2 files changed, 78 insertions(+), 84 deletions(-) diff --git a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_index.md b/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_index.md index c73b42c745..50b45c400a 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_index.md @@ -1,62 +1,57 @@ --- title: Build multi-architecture applications with Red Hat OpenShift Pipelines on AWS -draft: true -cascade: - draft: true - minutes_to_complete: 30 -who_is_this_for: This topic is for OpenShift administrators interested in migrating their applications to Arm. - +who_is_this_for: This topic is for OpenShift administrators who want to migrate their applications to Arm. learning_objectives: - - Migrate existing OpenShift applications to Arm. + - Migrate existing OpenShift applications to Arm-based nodes prerequisites: - - An AWS account with an OpenShift 4.18 cluster with x86 nodes installed and configured. - - Red Hat OpenShift Pipelines (Tekton) operator installed in your cluster. - - Familiarity with Red Hat OpenShift (oc CLI), container concepts, and basic Tekton principles (Task, Pipeline, PipelineRun). - - Access to your Red Hat OpenShift cluster with cluster-admin or equivalent privileges for node configuration and pipeline setup. + - An AWS account with an OpenShift 4.18 cluster running x86 compute nodes + - Red Hat OpenShift Pipelines (Tekton) Operator installed in your cluster + - Familiarity with the `oc` CLI, container fundamentals, and basic Tekton concepts (Task, Pipeline, PipelineRun) + - Cluster access with `cluster-admin` or equivalent permissions to configure nodes and pipelines author: Jeff Young -### Tags +# Tags skilllevels: Advanced subjects: CI-CD armips: - - Neoverse + - Neoverse tools_software_languages: - - Tekton - - OpenShift + - Tekton + - OpenShift operatingsystems: - - Linux + - Linux further_reading: - - resource: - title: Red Hat OpenShift Documentation - link: https://docs.openshift.com/container-platform/latest/welcome/index.html - type: documentation - - resource: - title: OpenShift Pipelines (Tekton) Documentation - link: https://docs.openshift.com/container-platform/latest/cicd/pipelines/understanding-openshift-pipelines.html - type: documentation - - resource: - title: OpenShift Multi-Architecture Compute Machines - link: https://docs.redhat.com/en/documentation/openshift_container_platform/4.18/html/postinstallation_configuration/configuring-multi-architecture-compute-machines-on-an-openshift-cluster - type: documentation - - resource: - title: OpenShift ImageStreams Documentation - link: https://docs.openshift.com/container-platform/latest/openshift_images/image-streams-managing.html - type: documentation - - resource: - title: Migrating to Multi-Architecture Compute Machines - link: https://docs.redhat.com/en/documentation/openshift_container_platform/4.18/html-single/updating_clusters/#migrating-to-multi-payload - type: documentation + - resource: + title: Red Hat OpenShift documentation + link: https://docs.openshift.com/container-platform/latest/welcome/index.html + type: documentation + - resource: + title: OpenShift Pipelines (Tekton) documentation + link: https://docs.openshift.com/container-platform/latest/cicd/pipelines/understanding-openshift-pipelines.html + type: documentation + - resource: + title: OpenShift multi-architecture compute machines + link: https://docs.redhat.com/en/documentation/openshift_container_platform/4.18/html/postinstallation_configuration/configuring-multi-architecture-compute-machines-on-an-openshift-cluster + type: documentation + - resource: + title: OpenShift ImageStreams documentation + link: https://docs.openshift.com/container-platform/latest/openshift_images/image-streams-managing.html + type: documentation + - resource: + title: Migrating to multi-architecture compute machines + link: https://docs.redhat.com/en/documentation/openshift_container_platform/4.18/html-single/updating_clusters/#migrating-to-multi-payload + type: documentation ### FIXED, DO NOT MODIFY # ================================================================================ -weight: 1 # _index.md always has weight of 1 to order correctly -layout: "learningpathall" # All files under learning paths have this same wrapper -learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. ---- \ No newline at end of file +weight: 1 +layout: "learningpathall" +learning_path_main_page: "yes" +--- diff --git a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md b/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md index 3ebb0a6ecf..e03ca78b23 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md +++ b/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md @@ -1,64 +1,70 @@ --- -title: Migrate an x86 workload to Arm on AWS +title: Migrate an x86 workload to Arm on AWS weight: 2 ### FIXED, DO NOT MODIFY layout: learningpathall --- -Migrating workloads from x86 to Arm on AWS can help reduce costs and improve performance. The steps below explain how to assess your workload compatibility, enable multi-architecture support in Red Hat OpenShift, configure arm64 nodes, rebuild and verify container images, and safely transition your deployments. +Migrating container workloads from x86 to Arm on AWS can help reduce cloud costs, improve energy efficiency, and enhance performance. This Learning Path shows you how to assess workload compatibility, enable multi-architecture support in Red Hat OpenShift, configure Arm64 nodes, rebuild and verify container images, and transition your deployments safely. -This example assumes you have the [OpenShift Pipelines Tutorial](https://github.com/openshift/pipelines-tutorial) built and running on x86. +This example uses the [OpenShift Pipelines Tutorial](https://github.com/openshift/pipelines-tutorial) as the baseline and assumes it is running on x86 infrastructure. -### 1. Assess Workload Compatibility +## Assess workload compatibility -Before migrating, determine whether your applications can run on 64-bit Arm architecture. Most modern applications built with portable runtimes such as Java, Go, Python, or Node.js can run seamlessly on 64-bit Arm with little or no modifications. Check your container images and dependencies for 64-bit Arm compatibility. +Before migrating, confirm that your applications can run on the Arm 64-bit (`arm64`) architecture. Most modern applications built with portable runtimes such as Java, Go, Python, or Node.js run on Arm with little or no changes. Check your container images and dependencies for compatibility. -To check if your container images support multiple architectures (such as arm64 and amd64), you can use tools like [KubeArchInspect](https://learn.arm.com/learning-paths/servers-and-cloud-computing/kubearchinspect/) to analyze images in your Kubernetes cluster. +Use the following tools to inspect container images for multi-architecture support: -Additionally, you can use the Python script provided in [Learn how to use Docker](https://learn.arm.com/learning-paths/cross-platform/docker/check-images/) to inspect images for multi-architecture support. +- [KubeArchInspect](https://learn.arm.com/learning-paths/servers-and-cloud-computing/kubearchinspect/): Scans container images in your Kubernetes cluster. +- [Docker inspect script](https://learn.arm.com/learning-paths/cross-platform/docker/check-images/): Checks local image manifests for platform variants. -The OpenShift Pipelines Tutorial supports arm64 and doesn't have any architecture restrictions. +> [!NOTE] +> The OpenShift Pipelines Tutorial supports `arm64` and has no architecture restrictions. -### 2. Enable Multi-Arch Support in Red Hat OpenShift +## Enable multi-architecture support in Red Hat OpenShift -Red Hat OpenShift supports multi-architecture workloads, allowing you to run both x86 and Arm based nodes in the same cluster. +OpenShift supports multi-architecture workloads, allowing you to run x86 and Arm nodes in the same cluster. -Red Hat OpenShift's [documentation](https://docs.redhat.com/en/documentation/openshift_container_platform/4.18/html/postinstallation_configuration/configuring-multi-architecture-compute-machines-on-an-openshift-cluster#multi-architecture-verifying-cluster-compatibility_creating-multi-arch-compute-nodes-aws) provides full details for the process. - -To check if your cluster is multi-architecture compatible, use the OpenShift CLI and run: +To check if your cluster is multi-architecture compatible, run: ```bash oc adm release info -o jsonpath="{ .metadata.metadata }" ``` -If the output includes `"release.openshift.io/architecture": "multi"`, your cluster supports multi-architecture compute nodes. +If the output includes: + +```json +"release.openshift.io/architecture": "multi" +``` + +...then your cluster supports multi-architecture nodes. If your cluster is not multi-architecture compatible, you must migrate it to use the multi-architecture release payload. This involves updating your OpenShift cluster to a version that supports multi-architecture and switching to the multi-architecture payload. For step-by-step instructions, see the OpenShift documentation on [migrating to a cluster with multi-architecture compute machines](https://docs.redhat.com/en/documentation/openshift_container_platform/4.18/html-single/updating_clusters/#migrating-to-multi-payload). Once migration is complete, you can add compute nodes with different architectures. -### 3. Add 64-bit Arm MachineSets +## Add 64-bit Arm MachineSets To take advantage of Arm-based compute, you need to add new MachineSets to your OpenShift cluster that use Arm (Graviton) EC2 instances. This step enables your cluster to schedule workloads on Arm nodes, allowing you to run and test your applications on the target architecture while maintaining your existing x86 nodes for a smooth migration. -#### Decide on a scheduling strategy +## Decide on a scheduling strategy When introducing Arm nodes into your OpenShift cluster, you need to control which workloads are scheduled onto these new nodes. There are two main approaches: - **Manual scheduling with Taints and Tolerations:** By applying a taint to your Arm nodes, you ensure that only workloads with a matching toleration are scheduled there. This gives you precise control over which applications run on Arm, making it easier to test and migrate workloads incrementally. - **Automated scheduling with the Multiarch Tuning Operator:** This operator helps automate the placement of workloads on the appropriate architecture by managing node affinity and tolerations for you. This is useful for larger environments or when you want to simplify multi-architecture workload management. -For scenarios with a single workload in the build pipeline, the manual taint and toleration method can be used. The following taint can be added to new Arm machine sets: +For manual scheduling, add the following taint: -``` - taints: - - effect: NoSchedule - key: newarch - value: arm64 +```yaml +taints: + - effect: NoSchedule + key: newarch + value: arm64 ``` This prevents existing x86 workloads from being scheduled to the Arm nodes, ensuring only workloads that explicitly tolerate this taint will run on Arm. -#### Reimport needed ImageStreams with import-mode set to PreserveOriginal +## Reimport needed ImageStreams with import-mode set to PreserveOriginal When running workloads on Arm nodes, you may need to ensure that the required container images are available for the arm64 architecture. OpenShift uses ImageStreams to manage container images, and by default, these may only include x86 (amd64) images. @@ -71,19 +77,19 @@ oc import-image php -n openshift --all --confirm --import-mode='PreserveOriginal oc import-image python -n openshift --all --confirm --import-mode='PreserveOriginal' ``` -This step is important to avoid image pull errors when deploying workloads to Arm nodes. +> [!TIP] +> This avoids image pull errors when deploying on Arm nodes. -### 4. Rebuild and Verify Container Images +## 4. Rebuild and verify container images To build 64-bit Arm compatible images, the OpenShift Pipelines Tutorial has been modified to patch deployments with the Tekton Task's podTemplate information. This will allow you to pass a podTemplate for building and deploying your newly built application on the target architecture. It also makes it easy to revert back to 64-bit x86 by re-running the pipeline without the template. -{{% notice Note %}} -Red Hat OpenShift only supports native architecture container builds. Cross-architecture container builds are not supported. -{{% /notice %}} - +> [!NOTE] +> Red Hat OpenShift only supports native builds. Cross-architecture builds are not supported. +## Define a podTemplate Create a podTemplate defining a toleration and a node affinity to make the builds deploy on Arm machines. -Save the code below in a file named `arm64.yaml` +Save the following as `arm64.yaml`: ```yaml tolerations: @@ -172,15 +178,15 @@ Finally the `04_pipeline.yaml` needs to be updated to pass the taskrun-name to t ```yaml - name: update-deployment - taskRef: + taskRef: name: update-deployment - params: + params: - name: deployment - value: $(params.deployment-name) + value: $(params.deployment-name) - name: IMAGE - value: $(params.IMAGE) - - name: taskrun-name //add these - value: $(context.taskRun.name) //lines + value: $(params.IMAGE) + - name: taskrun-name + value: $(context.taskRun.name) ``` Now the UI and API can be redeployed using the `arm64.yaml` podTemplate. This will force all parts of the build pipeline and deployment to the tainted Arm nodes. @@ -188,14 +194,7 @@ Now the UI and API can be redeployed using the `arm64.yaml` podTemplate. This wi Run the `tkn` command: ```bash -tkn pipeline start build-and-deploy \\\\ ---prefix-name build-deploy-api-pipelinerun-arm64 \\\\ --w name=shared-workspace,volumeClaimTemplateFile=https://raw.githubusercontent.com/openshift/pipelines-tutorial/master/01\_pipeline/03\_persistent\_volume\_claim.yaml \\\\ --p deployment-name=pipelines-vote-api \\\\ --p git-url=https://github.com/openshift/pipelines-vote-api.git \\\\ --p IMAGE=image-registry.openshift-image-registry.svc:5000/pipelines-tutorial/pipelines-vote-api-arm64 ---use-param-defaults \\\\ ---pod-template arm64.yaml +tkn pipeline start build-and-deploy --prefix-name build-deploy-api-pipelinerun-arm64 -w name=shared-workspace,volumeClaimTemplateFile=https://raw.githubusercontent.com/openshift/pipelines-tutorial/master/01_pipeline/03_persistent_volume_claim.yaml -p deployment-name=pipelines-vote-api -p git-url=https://github.com/openshift/pipelines-vote-api.git -p IMAGE=image-registry.openshift-image-registry.svc:5000/pipelines-tutorial/pipelines-vote-api-arm64 --use-param-defaults --pod-template arm64.yaml ``` Once the pods are up and running, you can safely remove the x86 worker nodes from the cluster, and remove the taints from the Arm worker nodes (if you choose to do so). From c7eb95ac8a8ae72ce35b258edea24f749803c70d Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Fri, 11 Jul 2025 18:05:25 +0000 Subject: [PATCH 2/3] Final --- .../arm-cost-savings/migrationsteps.md | 28 +++++++++++-------- 1 file changed, 17 insertions(+), 11 deletions(-) diff --git a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md b/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md index e03ca78b23..48655ee0e1 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md +++ b/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md @@ -16,11 +16,13 @@ Before migrating, confirm that your applications can run on the Arm 64-bit (`arm Use the following tools to inspect container images for multi-architecture support: -- [KubeArchInspect](https://learn.arm.com/learning-paths/servers-and-cloud-computing/kubearchinspect/): Scans container images in your Kubernetes cluster. -- [Docker inspect script](https://learn.arm.com/learning-paths/cross-platform/docker/check-images/): Checks local image manifests for platform variants. +- [KubeArchInspect](https://learn.arm.com/learning-paths/servers-and-cloud-computing/kubearchinspect/): scans container images in your Kubernetes cluster. +- [Docker inspect script](https://learn.arm.com/learning-paths/cross-platform/docker/check-images/): checks local image manifests for platform variants. + +{{% notice Note %}} +The OpenShift Pipelines Tutorial supports `arm64` and has no architecture restrictions. +{{% /notice %}} -> [!NOTE] -> The OpenShift Pipelines Tutorial supports `arm64` and has no architecture restrictions. ## Enable multi-architecture support in Red Hat OpenShift @@ -50,8 +52,8 @@ To take advantage of Arm-based compute, you need to add new MachineSets to your When introducing Arm nodes into your OpenShift cluster, you need to control which workloads are scheduled onto these new nodes. There are two main approaches: -- **Manual scheduling with Taints and Tolerations:** By applying a taint to your Arm nodes, you ensure that only workloads with a matching toleration are scheduled there. This gives you precise control over which applications run on Arm, making it easier to test and migrate workloads incrementally. -- **Automated scheduling with the Multiarch Tuning Operator:** This operator helps automate the placement of workloads on the appropriate architecture by managing node affinity and tolerations for you. This is useful for larger environments or when you want to simplify multi-architecture workload management. +- **Manual scheduling with Taints and Tolerations:** by applying a taint to your Arm nodes, you ensure that only workloads with a matching toleration are scheduled there. This gives you precise control over which applications run on Arm, making it easier to test and migrate workloads incrementally. +- **Automated scheduling with the Multiarch Tuning Operator:** this operator helps automate the placement of workloads on the appropriate architecture by managing node affinity and tolerations for you. This is useful for larger environments or when you want to simplify multi-architecture workload management. For manual scheduling, add the following taint: @@ -77,15 +79,19 @@ oc import-image php -n openshift --all --confirm --import-mode='PreserveOriginal oc import-image python -n openshift --all --confirm --import-mode='PreserveOriginal' ``` -> [!TIP] -> This avoids image pull errors when deploying on Arm nodes. +{{% notice Note %}} +This avoids image pull errors when deploying on Arm nodes. +{{% /notice %}} + -## 4. Rebuild and verify container images +## Rebuild and verify container images To build 64-bit Arm compatible images, the OpenShift Pipelines Tutorial has been modified to patch deployments with the Tekton Task's podTemplate information. This will allow you to pass a podTemplate for building and deploying your newly built application on the target architecture. It also makes it easy to revert back to 64-bit x86 by re-running the pipeline without the template. -> [!NOTE] -> Red Hat OpenShift only supports native builds. Cross-architecture builds are not supported. +{{% notice Note %}} +Red Hat OpenShift only supports native builds. Cross-architecture builds are not supported. +{{% /notice %}} + ## Define a podTemplate Create a podTemplate defining a toleration and a node affinity to make the builds deploy on Arm machines. From d1d11a1a74a27310cce6f878b0f536cfaeb44853 Mon Sep 17 00:00:00 2001 From: Jason Andrews Date: Fri, 11 Jul 2025 20:12:06 +0100 Subject: [PATCH 3/3] spelling updates --- .wordlist.txt | 6 +++++- .../multiplying-matrices-with-sme2/7-sme2-matmul-intr.md | 2 +- .../{arm-cost-savings => openshift}/_index.md | 2 +- .../{arm-cost-savings => openshift}/_next-steps.md | 0 .../{arm-cost-savings => openshift}/migrationsteps.md | 0 5 files changed, 7 insertions(+), 3 deletions(-) rename content/learning-paths/servers-and-cloud-computing/{arm-cost-savings => openshift}/_index.md (95%) rename content/learning-paths/servers-and-cloud-computing/{arm-cost-savings => openshift}/_next-steps.md (100%) rename content/learning-paths/servers-and-cloud-computing/{arm-cost-savings => openshift}/migrationsteps.md (100%) diff --git a/.wordlist.txt b/.wordlist.txt index 00a6d1f24e..5d4d10d124 100644 --- a/.wordlist.txt +++ b/.wordlist.txt @@ -4448,4 +4448,8 @@ wlan wlp wlx xquartz -zenohd \ No newline at end of file +zenohd +Kompanio +Zenoh's +instrumentable +subprocesses \ No newline at end of file diff --git a/content/learning-paths/cross-platform/multiplying-matrices-with-sme2/7-sme2-matmul-intr.md b/content/learning-paths/cross-platform/multiplying-matrices-with-sme2/7-sme2-matmul-intr.md index 0127c6a39d..f5aa9a7248 100644 --- a/content/learning-paths/cross-platform/multiplying-matrices-with-sme2/7-sme2-matmul-intr.md +++ b/content/learning-paths/cross-platform/multiplying-matrices-with-sme2/7-sme2-matmul-intr.md @@ -201,7 +201,7 @@ is exactly what was shown in Figure 2 earlier in the Learning Path. Note again t Once again, intrinsics makes it easy to fully leverage SME2, provided you have a solid understanding of its available instructions. The compiler is automatically -handling many low-level aspects (saving / restoring of the diferent contexts), +handling many low-level aspects (saving / restoring of the different contexts), as well as not using registers that are reserved on specific platforms (like `x18`). Predicates handle corner cases elegantly, ensuring robust execution. Most importantly, the code adapts to different SVL values across various diff --git a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_index.md b/content/learning-paths/servers-and-cloud-computing/openshift/_index.md similarity index 95% rename from content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_index.md rename to content/learning-paths/servers-and-cloud-computing/openshift/_index.md index 50b45c400a..876477f9c8 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/openshift/_index.md @@ -12,7 +12,7 @@ prerequisites: - An AWS account with an OpenShift 4.18 cluster running x86 compute nodes - Red Hat OpenShift Pipelines (Tekton) Operator installed in your cluster - Familiarity with the `oc` CLI, container fundamentals, and basic Tekton concepts (Task, Pipeline, PipelineRun) - - Cluster access with `cluster-admin` or equivalent permissions to configure nodes and pipelines + - Cluster access with cluster-admin or equivalent permissions to configure nodes and pipelines author: Jeff Young diff --git a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/openshift/_next-steps.md similarity index 100% rename from content/learning-paths/servers-and-cloud-computing/arm-cost-savings/_next-steps.md rename to content/learning-paths/servers-and-cloud-computing/openshift/_next-steps.md diff --git a/content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md b/content/learning-paths/servers-and-cloud-computing/openshift/migrationsteps.md similarity index 100% rename from content/learning-paths/servers-and-cloud-computing/arm-cost-savings/migrationsteps.md rename to content/learning-paths/servers-and-cloud-computing/openshift/migrationsteps.md