Running Kubernetes on ARM Devices in Production
Production-grade Kubernetes on ARM means solving arch labels, multi-arch image pipelines, mixed-arch scheduling, and SD-card wear — not just installing k3s on a Raspberry Pi.
Published on • November 15, 2026
AI Assistant

ARM has quietly become the default architecture for edge Kubernetes, and increasingly a serious option in the data center. K3s ships first-class binaries for ARMv7 and ARM64 and describes itself as optimized for ARM — from a Raspberry Pi up to an AWS a1.4xlarge with 32 GiB of RAM — while Graviton and Ampere instances now price 20–40% below comparable x86 offerings. But “it installs” is not “it runs in production.” The real work is in image pipelines, scheduling policy, and hardware hygiene that most tutorials skip. This post covers the operational realities of running ARM nodes in production clusters: what arm/v7 actually costs you today, how multi-arch manifests work, how to label and taint mixed fleets, and where ARM saves money versus where it quietly hurts.
arm64 versus arm/v7: two very different tiers
Kubernetes distinguishes three ARM-related values in its node labels: arm64 (AArch64), arm (32-bit ARMv7), and amd64. They are not interchangeable tiers of the same platform — they are closer to two different generations.
arm64 is the production target. Every serious ARM server today — AWS Graviton2/3/4, Ampere Altra and AmpereOne, Apple Silicon runners, Raspberry Pi 4/5 running a 64-bit OS — is arm64. All major base images, language runtimes, and CNCF project images publish arm64 as a first-class architecture.
arm/v7 is legacy-adjacent, and the ecosystem is draining. Upstream Kubernetes still lists arm-linux as a released platform, but 32-bit ARM is effectively second-class: the Kubernetes release packaging dropped 32-bit arm builds in 2023 (kubernetes/release#2960), the kubelet had 32-bit panics in the 1.23 line (kubernetes#106977) that complicated upgrades, and minikube formally removed 32-bit support in early 2026. K3s still ships an ARMv7 binary — useful for repurposing Raspberry Pi 2/3 boards and industrial gateways — but new production deployments should treat arm/v7 as a compatibility constraint, not a target. The practical consequences of32-bit are real: a ~3 GB usable address space per process, runtimes that have stopped shipping armhf builds, and container images whose maintainers publish only linux/amd64 and linux/arm64.
Rule of thumb: if the board runs a 64-bit OS, put it on arm64 and delete the 32-bit userland before you install anything. If it can’t, budget for an image-pipeline tax before committing to production.
Multi-arch images and the manifest index
A mixed-arch cluster only works if every image you deploy is published as an OCI image index (the multi-arch manifest list). Kubernetes’ kubelet requests the platform matching the node’s kubernetes.io/arch label, and containerd resolves that from the index. The node-side behavior is not where the interesting work happens — the interesting work is in CI.
Build with Buildx across platforms in one pass:
docker buildx build \
--platform linux/amd64,linux/arm64 \
-t registry.example.com/shop-api:1.4.2 \
--push .
Verify what you actually published rather than trusting the tag:
docker buildx imagetools inspect registry.example.com/shop-api:1.4.2
The output should list both linux/amd64 and linux/arm64 entries with their digests. A practical pipeline policy: make the --platform list an explicit CI variable, fail the build if the pushed index has fewer platforms than the policy requires, and pin deployments to the image digest so that the amd64 and arm64 nodes in the same cluster are provably running the same source revision.
Two structural notes for fleets:
- Third-party charts and operators are your real dependency. Your own images you control; the Helm charts for cert-manager, Prometheus, ingress controllers, and service meshes you do not. Audit them with
helm template ... | grep image:plus a manifest inspection pass before they land in a mixed cluster. - DaemonSets are the highest-risk workload class. A DaemonSet must schedule on every node, so a single-platform image breaks the whole fleet rollout at once. Treat DaemonSet images as the strictest tier of your multi-arch policy.
Labels, taints, and mixed-arch scheduling
Kubernetes does not taint nodes by architecture. Every node simply carries a label:
kubectl get nodes -L kubernetes.io/arch
NAME STATUS ROLES VERSION ARCH
pi-node-01 Ready <none> v1.33.x arm64
pi-node-02 Ready <none> v1.33.x arm
graviton-01 Ready <none> v1.33.x amd64
ampere-01 Ready <none> v1.33.x arm64
Scheduling by architecture is then an ordinary nodeSelector or affinity rule:
apiVersion: batch/v1
kind: Job
metadata:
name: arm-benchmark
spec:
template:
spec:
nodeSelector:
kubernetes.io/arch: arm64
containers:
- name: bench
image: registry.example.com/bench:2.1
But the more common production need is the inverse: keep general workloads off weak ARM nodes while letting explicitly compatible workloads land there. Use a taint for that, and opt workloads in with a toleration:
kubectl taint nodes pi-node-02 arch=armv7:NoSchedule
kubectl taint nodes pi-node-01 edge=lowmem:NoSchedule
This is the standard pattern for heterogeneous edge fleets: ARM SBCs get a taint so that only workloads with a matching toleration and a kubernetes.io/arch selector run on them, while bulk services default to the arm64/x86 servers. Two details that matter in practice:
- The
beta.kubernetes.io/archlabel is long gone from modern clusters — usekubernetes.io/archonly. - If you use cluster autoscaling or cluster-api machine pools, encode the architecture in the node pool definition, not in ad-hoc label patches, so replacement nodes inherit the same scheduling contract.
Hardware notes: Raspberry Pi, Ampere, and Graviton
Raspberry Pi (arm64). A Pi 4/5 with 8 GB is a legitimate single-node K3s production box for a shop-floor gateway — but its bottleneck is storage and I/O, not CPU. Budget roughly 5–15 W per node, and note that the Pi’s shared USB storage bus means an NVMe HAT and a USB NIC together can saturate each other. For multi-node Pi clusters, power and network are cheap; your operational time is not — a six-Pi cluster needs exactly as much patching as six servers.
Ampere (arm64). Ampere Altra and AmpereOne give you 80–128 uniform cores at modest TDP — excellent for scale-out control planes, CI runners, and horizontally replicated stateless services. The trade-off is per-core clock and memory bandwidth versus a top-bin Xeon/EPYC for single-threaded or NUMA-sensitive workloads.
AWS Graviton (arm64). The easiest money in ARM: Graviton-based instances (m6g/m7g/c6g/c7g families) typically price ~20% lower than comparable x86 instances with competitive per-core performance. Caveats to check before you migrate: benchmark your workload (JVM, compression-heavy, and single-threaded workloads vary most), and review software licensing — per-core commercial licenses are where ARM’s economics can invert.
Storage and SD-card wear
This is where ARM edge clusters fail in production, and it is almost never a Kubernetes problem — it is a flash-wear problem. Kubernetes on a Pi writes constantly: containerd’s content store, kubelet pod logs, and SQLite/WAL from K3s’ default datastore all generate steady small writes. On an SD card rated for a few hundred terabytes of writes, that is a measured lifetime, not an abstraction.
Production practices that work:
- Get the datastore and images off the SD card. Point K3s’ data dir and containerd state at an NVMe/SSD (
--data-diron install), or mount a USB-attached SSD as/var/lib/rancher/k3s. - Make journals volatile.
Storage=persistentfor journald on an SD-card node turns log rotation into a wear generator; setStorage=volatileor capSystemMaxUse=50M. - Prefer replicated block storage over node-local disks for anything with state. Longhorn or OpenEBS with replication means a worn-out disk is a node replacement, not a data-loss event — but remember replication multiplies writes across the fleet, so size the flash for aggregate write volume, not per-node volume.
- Monitor SMART and treat SD cards as consumable.
smartctl -a /dev/mmcblk0, alert onMedia_Wearout_Indicatorand reallocated sectors, and keep the OS image reproducible so a failing board is a 20-minute swap rather than a rebuild.
Where ARM saves money — and where it hurts
ARM wins on power-constrained and space-constrained edge sites (fanless SBCs, solar-powered cabinets), on horizontal scale-out fleets where per-node price dominates, and on cloud compute where Graviton discounts apply directly to every node in the cluster — control plane included. A K3s server on a $10/month ARM VM running a full control plane plus workloads is a legitimate cost architecture.
ARM hurts when you have single-threaded latency-sensitive services, specialized hardware dependencies (FPGA/GPU passthrough with x86-only drivers), commercial licenses priced per core or per socket with unfavourable ARM terms, or a team that cannot reliably build and verify multi-arch images. It also hurts when you choose arm/v7 to save a few dollars on old boards and inherit a shrinking ecosystem for the next three years.
The decision heuristic that holds up: adopt ARM where the workload is horizontally replicated and image-controlled by you, stay on x86 where it is single-threaded, license-bound, or hardware-bound, and treat arm/v7 as a legacy tier you migrate off rather than a platform you grow.
References
- K3s project — Lightweight Kubernetes: https://k3s.io/
- K3s documentation (architecture, import images, registries): https://docs.k3s.io/
- Kubernetes platforms guide (supported architectures): https://www.kubernetes.dev/docs/guide/platforms/
- Drop 32-bit arm from Kubernetes package builds (kubernetes/release#2960): https://github.com/kubernetes/release/pull/2960
- Kubelet crashes on 32-bit arm (kubernetes#106977): https://github.com/kubernetes/kubernetes/issues/106977
- minikube removal of 32-bit architecture support: https://github.com/kubernetes/minikube/pull/22401