Run ARM64 Node Pools in AKS (2026)

AKS now supports ARM64 nodes, allowing you to run workloads on Graviton processors.

Here’s a quick demo:

# Create a resource group
az group create --name aks-arm64-demo --location eastus

# Create an AKS cluster with ARM64 node pool
az aks create \
    --resource-group aks-arm64-demo \
    --name aks-arm64-cluster \
    --node-count 1 \
    --node-vm-size Standard_D2ps_v5 \
    --os-type Linux \
    --kubernetes-version 1.27.7 \
    --node-taints "sku=arm64:NoSchedule" \
    --node-osdisk-size 100 \
    --vnet-subnet-id "/subscriptions/YOUR_SUBSCRIPTION_ID/resourceGroups/MC_aks-arm64-demo_aks-arm64-cluster_eastus/providers/Microsoft.Network/virtualNetworks/aks-vnet-aks-arm64-cluster/subnets/aks-subnet-aks-arm64-cluster" \
    --attach-acr YOUR_ACR_NAME

# Get credentials
az aks get-credentials --resource-group aks-arm64-demo --name aks-arm64-cluster

# Verify node pool
kubectl get nodes -o wide

This cluster will have a default node pool with x86 VMs. We’ll add an ARM64 pool next.

# Add an ARM64 node pool
az aks nodepool add \
    --resource-group aks-arm64-demo \
    --cluster-name aks-arm64-cluster \
    --name arm64pool \
    --node-count 1 \
    --node-vm-size Standard_D2p_v5 \
    --os-type Linux \
    --node-taints "sku=arm64:NoSchedule"

The Standard_D2p_v5 is a Graviton equivalent. The --node-taints ensures only ARM64-specific workloads land here.

Now, let’s deploy a simple ARM64 application. We’ll use a multi-arch image for demonstration.

# nginx-arm64.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-arm64-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-arm64
  template:
    metadata:
      labels:
        app: nginx-arm64
    spec:
      containers:
      - name: nginx
        image: nginx:latest # This image is multi-arch
        ports:
        - containerPort: 80
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: sku
                operator: In
                values:
                - arm64

Apply it:

kubectl apply -f nginx-arm64.yaml

Check the pods:

kubectl get pods -o wide

You should see your Nginx pods scheduled on the ARM64 nodes.

The primary advantage of ARM64 on AKS is cost and performance for compatible workloads. Graviton processors often provide a better price-performance ratio than comparable x86 instances. This is particularly beneficial for compute-intensive applications, microservices, and general-purpose workloads that have been compiled for the ARM64 architecture.

The key challenge when migrating to ARM64 is ensuring your application dependencies and base images are compatible. Most official Linux distribution images (like Ubuntu and Alpine) and popular application images (like Nginx, Redis, and PostgreSQL) are now multi-arch, meaning they contain both x86_64 and arm64 variants. Docker and Kubernetes will automatically pull the correct architecture based on the node.

You can verify the architecture of your running containers by exec-ing into a pod and running uname -m. For example:

kubectl exec -it <your-pod-name> -- uname -m

This should output aarch64, confirming it’s running on ARM64.

When specifying VM sizes for ARM64 node pools, you’ll use the Standard_D*p_v5 series, like Standard_D2p_v5, Standard_D4p_v5, etc. These are Azure’s virtual machine sizes that utilize AWS Graviton processors. Always check the Azure documentation for the latest available ARM64 VM SKUs in your region.

A common pitfall is forgetting to update your CI/CD pipelines to build multi-arch images. If your build process only targets amd64, your ARM64 node pool won’t be able to run your applications. Tools like docker buildx are essential for creating images that support multiple architectures. You’ll need to configure your build agent or runner to be ARM64-compatible or use a remote builder capable of producing multi-arch images.

Another consideration is the underlying operating system. While AKS abstracts much of this, ensure your chosen OS image for the ARM64 node pool is well-supported and tested for the aarch64 architecture. AKS typically uses Ubuntu or Mariner for its Linux nodes, both of which have excellent ARM64 support.

The next step in optimizing ARM64 deployments is to explore custom node images for faster provisioning and pre-installed dependencies.