# Migrate x86 workloads to Arm on Google Kubernetes Engine with Axion processors

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/)
- [Explore the benefits of migrating microservices to Arm on GKE](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/background/)
- [Set up your environment](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/project-setup/)
- [Create build-ready Dockerfiles for both architectures](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/multi-arch-images/)
- [Build and deploy multi-architecture images on GKE](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/gke-build-push/)
- [Prepare manifests and deploy on GKE](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/gke-deploy/)
- [Automate builds and rollout with Cloud Build and Skaffold](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/cloud-build/)
- [Next Steps](https://learn.arm.com/learning-paths/servers-and-cloud-computing/gke-multi-arch-axion/_next-steps/)

## About this Learning Path

| Skill level: | Advanced |
|--------------|----------|
| Reading time: | 1 hr 30 min |
| Last updated: | 14 Sep 2026 |

| Author: | Rani Chowdary Mandepudi, Arm |
|---------|-------------------------------|
| Arm IP: | [Neoverse](https://support.arm.com/?tab=compute-ip&Product%20Type=Infrastructure%20Processors) |
| Tags: | [Containers and Virtualization](https://learn.arm.com/tag/containers-and-virtualization), [Google Axion](https://learn.arm.com/tag/google-axion), [Linux](https://learn.arm.com/tag/linux), [Kubernetes](https://learn.arm.com/tag/kubernetes), [GKE](https://learn.arm.com/tag/gke), [Skaffold](https://learn.arm.com/tag/skaffold), [Cloud Build](https://learn.arm.com/tag/cloud-build) |

### Who is this for?

This is an advanced topic for cloud, platform, and site reliability engineers who operate Kubernetes on Google Cloud and need to build multi-architecture images and migrate services from x86 to Arm using Google Axion processors.

### What will you learn?

Upon completion of this Learning Path, you will be able to:

- Prepare Dockerfiles for multi-architecture builds by adding arm64 support.
- Create a dual-architecture Google Kubernetes Engine (GKE) standard cluster with amd64 and arm64 node pools.
- Build and publish multi-architecture images to Artifact Registry using Docker Buildx.
- Deploy a Kubernetes application on amd64, then migrate to arm64 using Kustomize overlays.
- Automate builds and rollouts with Cloud Build and Skaffold.

### Prerequisites

Before starting, you will need the following:

- A [Google Cloud account](https://console.cloud.google.com/) with billing enabled
- A local Linux or macOS computer with access to Google Cloud Shell, or Docker, Kubernetes CLI (`kubectl`), Google Cloud CLI (`gcloud`), and Git installed
- Basic familiarity with Docker, Kubernetes, and `gcloud`

### Summary

You’ll migrate a multi-service application from x86 to Arm on GKE. First, you’ll create amd64 and arm64 node pools, update Dockerfiles, build multi-architecture images, and push them to Artifact Registry. Then, Kustomize overlays direct deployments to each architecture, allowing you to validate the application first on x86 and then on Arm.

### Frequently asked questions

<details>
<summary>How do I know the cluster has both amd64 and arm64 capacity before building images?</summary>
For the native GKE Buildx workflow, list your GKE nodes and check the architecture labels to confirm both amd64 and arm64 node pools are present and ready. You can then run each BuildKit pod on the matching architecture. If you choose Cloud Build, use its own runner with QEMU instead.
</details>

<details>
<summary>Which services need Dockerfile updates for multi-architecture builds?</summary>
Four services require small changes: `emailservice`, `recommendationservice`, `loadgenerator`, and `cartservice`. The edits ensure that the correct compiler headers and runtime libraries are included for each architecture.
</details>

<details>
<summary>Which build workflow avoids QEMU emulation?</summary>
Use the GKE-backed Buildx workflow. It runs separate BuildKit pods on the amd64 and arm64 node pools, so each platform builds natively. The alternative Cloud Build workflow enables QEMU in its runner for cross-architecture builds.
</details>

<details>
<summary>How do I direct a deployment to Arm nodes and later switch from x86?</summary>
Use Kustomize overlays that select nodes by architecture and reference your Artifact Registry images. Apply the overlay for amd64 first, then apply the arm64 overlay to migrate the workload to Axion-based nodes.
</details>

<details>
<summary>What should I check if cluster creation fails due to networking?</summary>
GKE uses VPC-native (IP aliasing) and requires two secondary ranges on the subnet: one for Pods and one for Services. On the default VPC, these ranges are created automatically. For custom networks, verify both ranges exist before creating the cluster.
</details>