Azure Kubernetes Service (AKS)

How Azure Kubernetes Service works: AKS Automatic and Standard, pricing tiers, Azure CNI networking, Workload ID, Gateway API ingress and upgrade channels.

Cloud

Azure Kubernetes Service (AKS) is Microsoft’s managed Kubernetes. Like the other big managed offerings, it runs the control plane for you and leaves you with ordinary Kubernetes APIs, so the manifests, Helm charts and operators you already use work unchanged. What makes AKS distinctive is how closely it ties the cluster into the rest of Azure: Microsoft Entra ID for sign-in, managed identities for pods, Azure networking for pod IPs, and Azure Policy for guardrails.

This article covers how AKS is put together, the choice between AKS Automatic and AKS Standard, networking, identity, ingress, upgrades and what you pay. It follows Google Kubernetes Engine (GKE) and AWS Elastic Container Service (ECS) and EKS, so where a concept has an equivalent on those platforms, it is pointed out. If containers are new to you, read Introduction to Containers and Docker first.

How an AKS cluster is built

An AKS cluster has the same two halves as any Kubernetes cluster. The control plane (API server, etcd, scheduler, controllers) runs in a Microsoft-managed subscription that you never see. The nodes are Azure virtual machines, grouped into node pools, that run your pods along with the kubelet and containerd.

Creating a cluster also creates a second resource group, usually named MC_<resource-group>_<cluster>_<region>. This node resource group holds the VM scale sets, disks, load balancer, public IPs and network interfaces that AKS manages on your behalf. You can look at it, but changing things there by hand is the classic way to break an AKS cluster. AKS can lock it down to read-only to prevent that.

flowchart LR
    DEV["kubectl or CI"] -->|"Entra ID sign-in"| CP["AKS control plane"]
    CP --> SYS["System node pool"]
    CP --> USR["User node pools"]
    ACR["Azure Container Registry"] --> USR
    LB["Azure Load Balancer"] --> USR
    USR --> AZ["Azure services"]
    WI["Workload ID"] -.-> AZ
    subgraph NRG["Node resource group"]
        SYS
        USR
        LB
    end

Node pools come in two modes. A system node pool runs critical add-ons such as CoreDNS and metrics-server, and every cluster needs at least one. User node pools run your applications. Separating them keeps a misbehaving app from starving the components the cluster itself depends on. Linux nodes run Ubuntu by default or Azure Linux, and AKS Standard also supports Windows Server node pools, which is one of the reasons Windows-heavy shops pick AKS.

In regions with availability zones, AKS spreads the control plane across zones automatically. Your node pools are only zonal if you ask for it, by passing --zones 1 2 3 when you create them. The regions and zones themselves are covered in Azure Global Infrastructure: Regions and Availability Zones.

AKS Automatic and AKS Standard

AKS comes in two SKUs, and choosing between them is the first decision.

AKS Automatic is the opinionated, production-ready configuration and the one Microsoft recommends for most new production clusters. Microsoft manages the system node pool and hosts it outside your subscription, provisions user nodes on demand to fit your pods, and turns on a fixed set of best practices you can’t switch off: Microsoft Entra Workload ID, Azure RBAC for Kubernetes authorization, API server VNet integration, deployment safeguards and baseline Pod Security Standards through Azure Policy, automatic node repair, and automatic upgrades. It also comes with a pod readiness SLA: 99.9% of qualifying pod readiness operations complete within five minutes, including any node provisioning needed.

AKS Standard is the classic, configurable AKS. You create and size node pools, choose the network plugin, decide which add-ons to enable and set your own upgrade policy. Almost everything Automatic preconfigures is available on Standard as an option.

AKS AutomaticAKS Standard
System nodesManaged by MicrosoftYou create and manage them
User nodesNode auto-provisioning, always onNode pools you manage; auto-provisioning optional
Pricing tierStandard tier, preconfiguredFree, Standard or Premium
NetworkingAzure CNI Overlay powered by CiliumYour choice of CNI
Sign-in and authorizationAzure RBAC for Kubernetes, preconfiguredLocal accounts by default; Entra options available
UpgradesAutomatic, stable channel, NodeImage OS channelManual by default; channels optional
PolicyDeployment safeguards enforcedOptional
Windows nodesNoYes

In the terms of the earlier articles, Automatic sits close to GKE Autopilot and EKS Auto Mode. Like EKS Auto Mode, it provisions real VMs in your subscription rather than billing per pod.

Node auto-provisioning

Automatic clusters scale nodes with node auto-provisioning (NAP), which is built on Karpenter, the open-source node autoscaler that started on AWS. Instead of scaling fixed node pools up and down, NAP looks at pending pods and creates individual VMs of whatever size fits them, then consolidates and removes nodes when they are no longer needed. You can also enable it on AKS Standard with --node-provisioning-mode Auto.

NAP is configured with two Kubernetes resources: a Karpenter NodePool that sets constraints and disruption rules, and an AKSNodeClass that holds Azure-specific settings such as the OS image. This NodePool lets NAP choose Spot or on-demand VMs from the D-series:

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: general
spec:
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 1m
  template:
    spec:
      requirements:
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["spot", "on-demand"]
        - key: karpenter.azure.com/sku-family
          operator: In
          values: ["D"]
      nodeClassRef:
        group: karpenter.azure.com
        kind: AKSNodeClass
        name: default

When Spot capacity is available Karpenter prefers it, and it falls back to on-demand when it isn’t. Pricing Models: On-Demand, Reserved, Savings Plans, and Spot explains when evictable capacity is a good trade.

On Standard clusters without NAP, the older cluster autoscaler scales each node pool between a minimum and maximum count. It is simpler to reason about, but each pool has one VM size, so mixed workloads often end up on oversized nodes.

A team needs to run Windows Server containers alongside Linux services on AKS. Which option fits?

  • An AKS Automatic cluster with node auto-provisioning
  • An AKS Standard cluster with a Windows node pool
  • An AKS Automatic cluster on the Premium tier

Correct! Windows Server node pools are an AKS Standard feature; Automatic user nodes run Azure Linux or Ubuntu.

Creating a cluster

The Azure CLI creates either SKU. An AKS Automatic cluster takes almost no parameters:

az group create --name rg-demo --location eastus2

az aks create \
  --resource-group rg-demo \
  --name aks-auto \
  --sku automatic

az aks get-credentials --resource-group rg-demo --name aks-auto
kubectl get nodes

Because Automatic uses Azure RBAC for Kubernetes authorization, your Entra account needs a role such as Azure Kubernetes Service RBAC Cluster Admin on the cluster before kubectl commands succeed. az aks get-credentials writes a kubeconfig that signs in through Entra ID using kubelogin.

An AKS Standard cluster with production settings spells out the choices Automatic makes for you:

az aks create \
  --resource-group rg-demo \
  --name aks-std \
  --tier standard \
  --zones 1 2 3 \
  --node-count 3 \
  --node-vm-size Standard_D4s_v5 \
  --network-plugin azure \
  --network-plugin-mode overlay \
  --network-dataplane cilium \
  --enable-oidc-issuer \
  --enable-workload-identity \
  --auto-upgrade-channel stable \
  --node-os-upgrade-channel NodeImage \
  --attach-acr myregistry

The --attach-acr flag grants the cluster’s kubelet identity pull access to an Azure Container Registry, so pods can pull private images without image pull secrets. Note the two different meanings of “Standard” here: AKS Standard is the SKU, and --tier standard is the pricing tier that adds the uptime SLA. An AKS Standard cluster can be on any of the three tiers.

Deploying an app uses plain Kubernetes manifests, exactly as on GKE or EKS:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
        azure.workload.identity/use: "true"
    spec:
      serviceAccountName: web
      containers:
        - name: web
          image: myregistry.azurecr.io/hello-web:1.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: 250m
              memory: 512Mi
            limits:
              memory: 512Mi
          readinessProbe:
            httpGet:
              path: /healthz
              port: 8080

The azure.workload.identity/use label is the one AKS-specific line. It is explained in the identity section below.

Networking

The network plugin decides where pod IP addresses come from, and it is hard to change later, so it is worth getting right on day one. AKS offers several IP address management options:

  • Azure CNI Overlay gives pods addresses from a private CIDR that is separate from the virtual network. Nodes get VNet addresses; pod traffic leaving the cluster is translated to the node’s IP. It conserves VNet address space, scales to large clusters (up to 250 pods per node) and is Microsoft’s recommendation for most clusters.
  • Azure CNI Pod Subnet gives pods real addresses from a dedicated subnet in the VNet. Anything on the network, including on-premises systems over VPN or ExpressRoute, can reach pods directly. You need a large, unfragmented address range.
  • Azure CNI Node Subnet and kubenet are legacy options. Kubenet retires on March 31, 2028, and existing clusters should migrate to Azure CNI Overlay before then.

Independently of the IP model, you can choose Azure CNI Powered by Cilium as the data plane. It uses eBPF instead of iptables, enforces Kubernetes NetworkPolicy, and is what AKS Automatic uses. It plays the same role as GKE Dataplane V2.

OptionPod IP sourceReachable directly from the VNetUses VNet addresses for podsStatus
Azure CNI OverlayPrivate overlay CIDRNo, pods initiate connectionsNoRecommended default
Azure CNI Pod SubnetDedicated VNet subnetYesYesRecommended for flat networks
Azure CNI Node SubnetNode subnetYesYes, pre-allocated per nodeLegacy
KubenetPrivate CIDR with route tablesNoNoRetires March 2028

Outbound traffic leaves through an Azure Standard Load Balancer by default on AKS Standard, or through a NAT gateway, which Automatic uses and which handles large numbers of outbound connections better.

Getting traffic in

A Service of type: LoadBalancer gets a frontend IP on the cluster’s Azure Load Balancer, which is enough for TCP and UDP traffic. For HTTP routing, TLS and host-based rules, you need an ingress or gateway controller, and this area changed in 2026.

AKS used to steer people toward the application routing add-on with managed NGINX. After the upstream ingress-nginx project was retired, Microsoft moved the add-on to the Kubernetes Gateway API, implemented with a lightweight Istio control plane that only manages gateways (no sidecars, no service mesh). Managed NGINX in the add-on stops receiving Azure support after November 2026, so clusters still using it need to migrate now. New AKS Automatic clusters on Kubernetes 1.36 and later get the Gateway API implementation by default. The other supported option is Application Gateway for Containers, Azure’s managed layer 7 load balancer, which supports both Ingress and Gateway API.

flowchart LR
    USER["Users"] --> PIP["Public IP"]
    PIP --> GWP["Gateway proxy pods"]
    GWP --> SVC["web Service"]
    SVC --> P1["Pod in zone 1"]
    SVC --> P2["Pod in zone 2"]
    SVC --> P3["Pod in zone 3"]
    GWR["Gateway and HTTPRoute"] -.->|"istiod configures"| GWP

On an AKS Standard cluster, enable it with:

az aks update --resource-group rg-demo --name aks-std \
  --enable-gateway-api --enable-app-routing-istio

Then a Gateway and an HTTPRoute send traffic to the web Service, which is a plain ClusterIP Service mapping port 80 to the container’s port 8080:

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: web-gateway
spec:
  gatewayClassName: approuting-istio
  listeners:
    - name: http
      protocol: HTTP
      port: 80
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: web
spec:
  parentRefs:
    - name: web-gateway
  rules:
    - backendRefs:
        - name: web
          port: 80

The manifests are the same Gateway API resources used on GKE in the previous article; only the gatewayClassName differs. That portability is the main reason to prefer Gateway API over provider-specific Ingress annotations.

Your company's virtual network has a small, fragmented address space, and nothing outside the cluster needs to reach pods directly. Which AKS networking option fits best?

  • Azure CNI Overlay
  • Azure CNI Pod Subnet
  • Azure CNI Node Subnet

Correct! Overlay assigns pod IPs from a separate private CIDR, so pods consume no VNet addresses.

Identity and access

The same two questions apply as on the other clouds: who can use the cluster, and what can the pods do in Azure.

Access to the cluster goes through Microsoft Entra ID. Users sign in with their Entra accounts, and you authorize them either with Kubernetes RBAC bound to Entra users and groups, or with Azure RBAC for Kubernetes authorization, which lets you grant built-in roles such as Azure Kubernetes Service RBAC Reader or Writer at the cluster or namespace scope, from the same place you manage every other Azure permission. AKS Standard clusters also have local admin accounts by default; disable them with --disable-local-accounts once Entra sign-in works, so nobody holds a shared credential that bypasses your identity provider. The Entra side is covered in Mastering Microsoft Entra Identity and Access Management.

Access from pods uses Microsoft Entra Workload ID. The cluster publishes an OpenID Connect issuer. You create a user-assigned managed identity, link it to a specific Kubernetes service account through a federated identity credential, and the pod exchanges its Kubernetes service account token for an Entra token. No secrets are stored anywhere, and each workload gets only its own permissions.

sequenceDiagram
    participant Pod
    participant Entra as Microsoft Entra ID
    participant KV as Azure Key Vault
    Pod->>Pod: Read projected service account token
    Pod->>Entra: Exchange token for access token
    Entra->>Entra: Check federated credential and issuer
    Entra-->>Pod: Entra access token
    Pod->>KV: Call API with access token

Setting it up for the web service account in the default namespace:

ISSUER=$(az aks show -g rg-demo -n aks-std \
  --query oidcIssuerProfile.issuerUrl -o tsv)

az identity create -g rg-demo -n id-web
CLIENT_ID=$(az identity show -g rg-demo -n id-web --query clientId -o tsv)

az identity federated-credential create \
  --name web-fic \
  --identity-name id-web \
  --resource-group rg-demo \
  --issuer "$ISSUER" \
  --subject system:serviceaccount:default:web \
  --audience api://AzureADTokenExchange

kubectl create serviceaccount web
kubectl annotate serviceaccount web \
  azure.workload.identity/client-id="$CLIENT_ID"

Grant the managed identity an Azure role, for example Key Vault Secrets User on one vault, and pods that use the web service account and carry the azure.workload.identity/use: "true" label can read those secrets. The Azure Identity client libraries pick up the credentials automatically. This is the AKS counterpart of EKS Pod Identity and Workload Identity Federation for GKE. The older pod-managed identity add-on is deprecated; don’t build on it.

Upgrades and support

Kubernetes ships a minor version roughly every four months, and AKS supports each one for about a year of community support. AKS clusters default to the N-1 minor version at creation. AKS separates two kinds of updates, each with its own automatic channel:

Cluster auto-upgrade channels move the Kubernetes version:

  • none disables channel-driven upgrades.
  • patch keeps the cluster on the latest patch of its current minor version.
  • stable targets the latest patch of minor version N-1, where N is the newest supported minor version. AKS Automatic uses this.
  • rapid targets the newest supported minor version.

Node OS upgrade channels patch the node operating system without changing Kubernetes: None, Unmanaged (the OS applies its own updates), SecurityPatch (AKS-tested security updates, reimaging only when needed) and NodeImage (a fresh node image, usually weekly). AKS Automatic uses NodeImage.

Both kinds of upgrade respect planned maintenance windows, so you can confine them to quiet hours. Upgrades replace nodes using a surge: AKS adds extra nodes, cordons and drains old ones, and removes them. The default surge is conservative; raising --max-surge on a node pool speeds upgrades at the cost of extra temporary VMs. As on any platform, give important Deployments a PodDisruptionBudget so draining never removes every replica at once. AKS also stops an upgrade if it detects your cluster using Kubernetes APIs that the target version removes.

Don’t let a cluster drift off the support window. If it stays on an unsupported version for more than 60 days past the end of support, AKS performs a platform-initiated upgrade, and that can happen outside your maintenance window. Choosing the stable channel with a maintenance window avoids that surprise.

If you need to stay on one minor version longer, long-term support (LTS) adds a second year of support, with security fixes backported, for about 24 months in total. LTS requires the Premium tier and must be enabled explicitly:

az aks update -g rg-demo -n aks-std \
  --tier premium \
  --k8s-support-plan AKSLongTermSupport \
  --auto-upgrade-channel patch

You want node operating systems patched automatically, but Kubernetes minor upgrades should happen only when you choose. Which settings match?

  • Cluster channel rapid, node OS channel None
  • Cluster channel stable, node OS channel Unmanaged
  • Cluster channel patch, node OS channel NodeImage

Correct! The patch channel never changes the minor version, and NodeImage keeps the node OS current.

What you pay for

Cluster management in AKS has three pricing tiers:

TierUptime SLA for the API serverMax nodesLong-term supportFee per cluster hour
FreeNone, best effort1,000 (recommended under 10)NoNone
Standard99.95% with availability zones, 99.9% without5,000No$0.10
PremiumSame as Standard5,000Yes$0.60

The Free tier really is free and suits development and test clusters; nothing about features is held back, only the SLA and scale. Production clusters belong on Standard. AKS Automatic clusters are always on the Standard tier, and Automatic has its own line items on the pricing page for the hosted system components and the compute it provisions, so price an Automatic cluster with the Azure pricing calculator rather than by adding up VM prices. Premium is for teams that need LTS. You can change a cluster’s tier at any time with az aks update --tier.

The fee is usually a small part of the bill. On top of it you pay for everything in the node resource group at normal Azure prices: the node VMs, their managed disks, load balancers, public IPs and NAT gateways, plus Log Analytics and Managed Prometheus ingestion if you enable monitoring. On AKS Standard there is no per-pod billing, so idle capacity on a node is capacity you pay for. That is why bin packing matters on AKS, and why NAP’s consolidation and Spot support are worth enabling. Reserved VM instances and savings plans apply to AKS nodes like any other VM. Check the AKS pricing page for current rates in your region, and Azure Free Tier and Billing Overview for budgets and cost alerts.

When to choose AKS

AKS is the obvious Kubernetes choice on Azure, and the strongest one anywhere if your organization already runs on Microsoft Entra ID, needs Windows Server containers, or wants Azure Policy governing clusters along with everything else. Start new production clusters on AKS Automatic. Choose AKS Standard when you need something Automatic doesn’t allow, such as Windows node pools, a custom CNI, or full control over node pools and upgrade timing.

If you don’t need Kubernetes at all, Azure Container Apps runs containers without a cluster, scaling to zero and handling ingress for you. Many teams run simple HTTP services there and keep AKS for workloads that need operators, custom controllers or the wider Kubernetes ecosystem. The same container image runs on both. For how AKS nodes relate to plain VMs, see Understanding Azure Virtual Machines, and for scaling concepts that carry over to node pools, Auto Scaling VMs on AWS, GCP, and Azure.

Further reading

Key takeaways

  • AKS runs the Kubernetes control plane for you; your nodes are Azure VMs in a separate node resource group that you shouldn’t edit by hand.
  • AKS Automatic is the recommended production default: Microsoft-managed system nodes, Karpenter-based node auto-provisioning, enforced security settings and automatic upgrades. AKS Standard gives you full control and supports Windows node pools.
  • Use Azure CNI Overlay for most clusters and Azure CNI Pod Subnet when pods must be directly reachable; kubenet retires in March 2028.
  • Managed NGINX in the application routing add-on loses Azure support after November 2026; move to the add-on’s Gateway API implementation or Application Gateway for Containers.
  • Microsoft Entra Workload ID gives each Kubernetes service account its own managed identity through a federated credential, with no secrets.
  • Separate channels handle Kubernetes version upgrades and node OS patches; pair them with maintenance windows, and use the Premium tier if you need long-term support.
  • The Free tier has no SLA, Standard costs $0.10 per cluster hour with an uptime SLA, and Premium adds LTS; node VMs and networking make up most of the bill.

Part 4 of 4 · Container Services

  1. 01Introduction to Containers and Docker
  2. 02AWS Elastic Container Service (ECS) and EKS
  3. 03Google Kubernetes Engine (GKE)
  4. 04Azure Kubernetes Service (AKS)
Ready to check your understanding?Take the Fluffy Computing quiz
esc

Type to search all articles · ↑↓ to move · ↵ to open