Should you run Kubernetes on arm64 or x86?

Arm64 (also called AArch64) is the 64-bit Arm instruction set used by AWS Graviton, Google Axion, Azure Cobalt and Ampere processors. x86-64 (also called x64 or amd64) is the 64-bit instruction set of Intel and AMD processors. On AWS, Google Cloud and Azure, a general-purpose arm64 VM lists 4% to 31% below a comparable x86 VM as of November 2026, so arm64 nodes are worth running for every workload whose container images have an arm64 build. Keep x86 nodes for images and binaries that exist only for amd64.

Price per vCPU, November 2026

On-demand Linux prices for general-purpose VMs with 4 vCPUs and 16 GiB of memory, except Hetzner, whose sizes are 4 vCPUs and 8 GB:

Provider and regionArm64Intel x86AMD x86
AWS, us-east-1m8g.xlarge (Graviton4): $0.1795/h; m9g.xlarge (Graviton5): $0.1957/hm8i.xlarge: $0.2117/hm8a.xlarge: $0.2434/h
Google Cloud, us-central1c4a-standard-4 (Axion): $0.1796/h; n4a-standard-4 (Axion): $0.1540/hc4-standard-4: $0.1977/h; n4-standard-4: $0.1814/hc4d-standard-4: $0.1871/h; n4d-standard-4: $0.1694/h
Azure, East USD4ps_v6 (Cobalt 100): $0.140/hD4s_v6: $0.202/hD4as_v6: $0.182/h
Hetzner Cloud, Germany and FinlandCAX21 (Ampere): €10.99/monthCX33 (Intel or AMD): €8.99/month

Sources: the AWS EC2 on-demand pricing data published on 14 November 2026, Google Cloud general-purpose VM pricing, the Azure retail prices API and Hetzner’s Cost-Optimized page, all checked on 16 November 2026. Hetzner prices exclude VAT.

Read the table with three points in mind:

  • The discount depends on the comparison. Graviton4 is 15% below Intel M8i and 26% below AMD M8a. Axion C4A is 9% below Intel C4 but only 4% below AMD C4D. Cobalt 100 is 31% below Intel. AWS’s own Graviton page claims instances that “cost up to 20% less than comparable x86-based” EC2 instances.
  • A vCPU is not the same unit everywhere. On Graviton, Axion and Cobalt, each vCPU is a full physical core. On Intel instances such as C4, N4 and M8i, a vCPU is one of two hardware threads on a core. AMD varies: on AWS M8a each vCPU is a physical core. Shared vs dedicated vCPUs explains why that changes throughput under load.
  • Hetzner is the exception. Its Arm CAX servers cost more than its x86 CX servers of the same size. Both lines have also been listed as unavailable since Hetzner’s capacity incident of 26 June 2026, as explained in why you can’t create a Hetzner server.

Price is only half of price-performance. Benchmark your own service on both architectures, measuring requests per second or job time per dollar. Code that depends on x86 SIMD extensions such as AVX-512 may run slower on Arm if its Arm code path is less optimized.

Multi-arch images

A container image can hold builds for several platforms behind one tag. The registry stores an image index that lists one manifest per platform, such as linux/amd64 and linux/arm64, and the container runtime on each node pulls the matching one. The same Deployment then runs on both architectures without changes.

Docker documents three ways to build multi-platform images: emulation with QEMU, native builder nodes for each architecture, and cross-compilation. Emulation needs no extra hardware but is slow for compiled languages. Native arm64 CI runners or cross-compilation, for example GOARCH=arm64 in Go, are faster. A typical build command:

shell
docker buildx build --platform linux/amd64,linux/arm64 -t registry.example.com/app:1.4.0 --push .

To check which platforms an existing image supports, run docker buildx imagetools inspect <image>.

Scheduling with kubernetes.io/arch

The kubelet labels every node with kubernetes.io/arch, set to the Go runtime’s architecture name: amd64 or arm64 (well-known labels). Use it to pin Pods whose images exist for only one architecture:

yaml
spec:
  nodeSelector:
    kubernetes.io/arch: amd64

In a mixed cluster, a safe default is to taint arm64 nodes so that only workloads that opt in land on them. GKE does this automatically: it taints all Arm nodes with kubernetes.io/arch=arm64:NoSchedule and adds the matching toleration to Pods that select arm64 through a node selector or node affinity. Multi-arch workloads that may run on either architecture need the toleration added by hand.

What breaks on arm64

  • Images without an arm64 build. If an image index has no arm64 entry, the pull fails. If the image is a single amd64 build, the container starts and exits with exec format error, which shows up as CrashLoopBackOff.
  • Hard-coded downloads in Dockerfiles. A curl of a linux-amd64 release archive builds fine and then fails at runtime on Arm. Use the TARGETARCH build argument to pick the right file.
  • Native dependencies. Python wheels, Node.js native add-ons and Java JNI libraries without aarch64 builds either compile from source during the build or fail.
  • Third-party DaemonSets. Security, monitoring and storage agents run on every node, so one agent without an arm64 image blocks an Arm node pool. Check every DaemonSet before adding arm64 nodes.
  • Vendor binaries. Closed-source tools and older software sometimes exist only for x86.

Workloads in Go, Java, Node.js, Python and Rust usually move with a rebuild. Most widely used open-source images, including official Docker Hub images for common databases and runtimes, already publish arm64 builds.

A low-risk migration path

  1. Inventory the images and DaemonSets in the cluster and check their platforms.
  2. Build multi-arch images in CI.
  3. Add a tainted arm64 node pool.
  4. Move one stateless service with a toleration and compare latency, error rates and cost.
  5. Expand service by service, and pin the rest to amd64.

Architecture is one of several cost levers covered in how to reduce Kubernetes costs. For hands-on results, see our tests of Google Axion instances and AWS Graviton4 X8g instances.

Arm64 nodes on Cloudfleet

Node auto-provisioning in Cloudfleet picks the cheapest node that fits a Pod, which is often an arm64 instance. Set kubernetes.io/arch: amd64 on Pods with single-platform images as described in handling single-platform container images, or restrict a whole Fleet to one architecture with Fleet constraints.

On this page