
Introduction
Stateful workloads break the "containers are disposable" assumption. Databases, queues, analytics engines, and AI model servers on AKS all need storage that outlives a container's filesystem, and often needs NVMe-class speed too.
CNCF's 2024 survey found that 74% of organizations use containers for stateful applications. That figure measures organizational adoption, not the share of workloads that are stateful, but the direction is clear.
Azure Container Storage (ACS) is a Kubernetes-native storage orchestration service for AKS. It is not an Azure Blob Storage container or a Docker container. This guide covers architecture, backends, deployment, cost, workload fit, and operations.
Key Takeaways
- ACS provisions and manages persistent storage for AKS through standard Kubernetes resources.
- Local NVMe is fast, but its data is tied to the node's lifecycle.
- Match the backend to your latency, IOPS, durability, recovery, and cost needs.
- Confirm versions, VM support, pricing, and prerequisites in Microsoft Learn before you deploy.
What Is Azure Container Storage for AKS?
Azure Container Storage (ACS) is a Kubernetes-native layer for provisioning and managing persistent volumes on Linux-based clusters, using Azure storage offerings underneath. You work with StorageClasses, PersistentVolumeClaims (PVCs), and PersistentVolumes. ACS handles the rest.
It is an orchestrator, not a backend. Capacity comes from local NVMe disks on the node VM or from Azure Elastic SAN.
Terms People Confuse
Picture a photo app. The app runs in a Kubernetes container (an isolated runtime, same idea as a Docker container).
Uploaded images live in a blob inside a Blob container inside a storage account. The app's database files sit on an ACS volume.
- Storage account: the top-level Azure namespace for storage data
- Blob container: organizes blobs, much like a directory
- Blob: an individual object
- ACS volume: block storage mounted into a pod
Blob Storage is object storage. An ACS volume is block storage with a filesystem.
Why Teams Use It
Microsoft positions the two backends for different workload profiles:
- Local NVMe: PostgreSQL, Ray, Kubeflow, and other latency-sensitive AI/ML workloads
- Elastic SAN: databases, streaming and messaging, CI/CD, and tier 1 and tier 2 workloads
Search systems and model serving fit the same profile.
Current Version Context
Version details matter here, and older tutorials are often stale.
| Release | What changed |
|---|---|
| 2.0.0 (Sept 2025) | Removed the StoragePool CR and bundled Prometheus Operator; supports one- and two-node clusters |
| 2.1.0 | GA announced April 8, 2026; adds Elastic SAN |
| 2.2.0 (June 2026) | SAN private endpoints, cross-subscription SAN, restricted tolerations |
Azure Disk is not a supported backend in v2. Distributed accelerator for cloud storage (DACS) is in preview. It caches Blob reads on local NVMe and is not a PV or StorageClass.
How Azure Container Storage Works: Backends, Kubernetes Resources, and Data Durability
Architecture and Request Flow
You install ACS as the AKS extension acstor (type microsoft.azurecontainerstoragev2). From v2.1, components deploy modularly and on demand. The extension runs node-level CSI drivers and managers alongside your workloads.
The request flow:
- A StorageClass defines the provisioner and policy.
- A PVC requests a volume.
- The local class uses
WaitForFirstConsumer, so binding waits until a pod needs it. - The scheduler places the pod, and the volume is provisioned on that node.
- The pod mounts the volume. Expansion and deletion follow the class settings.

Backend Choices
| Local NVMe | Elastic SAN | |
|---|---|---|
| Scope | v2 | v2.1+ |
| Performance | High IOPS and throughput; sub-millisecond latency possible, depends on VM | Shared pool; predictable throughput |
| Access | On the node VM | Remote block volumes over iSCSI |
| Durability | No ACS replication | LRS or ZRS |
| Snapshots | Unsupported | Supported |
For transactional production databases, durable remote storage is the safer default. Local NVMe suits scratch space, caches, and AI model loading, where data can be rebuilt.
Node, VM, and Scheduling Considerations
Local volumes need NVMe-capable VM SKUs, such as Standard_L8s_v3 or Standard_L16s_v3. Microsoft's guide recommends two NVMe disks and a managed OS disk. All available NVMe disks on a VM are striped automatically, and you can't turn that off.
- A volume must fit within a single node's disk capacity. Adding nodes doesn't enlarge it.
- Control placement with the StorageClass annotation
storageoperator.acstor.io/nodeAffinity. Labels are case-sensitive. - Without affinity, the local driver deploys to all nodes.
- v2.2 limits formerly permissive tolerations to control-plane and
CriticalAddonsOnlypools.
Kubernetes support follows the AKS N-2 policy. Check Microsoft Learn for current VM series and regional availability, since the nine listed US regions and Elastic SAN's own subset can change.
Durability, Replication, and Recovery
A PVC surviving a pod restart is not the same as surviving node loss. Local NVMe data is lost on VM stop or deallocation, node deletion, or a pod moving to another node.
To make a local PVC persistent, you must set localdisk.csi.acstor.io/accept-ephemeral-storage: "true". That annotation acknowledges the risk and does not remove it.
ACS doesn't replace application replication, backups, or restore testing. Elastic SAN adds LRS or ZRS redundancy and snapshots. The current ACS feature matrix doesn't specify backup, so plan it separately.

How to Deploy and Configure Azure Container Storage on AKS
Prerequisites and Design Decisions
Validate these first:
- Azure CLI 2.83.0+ and
kubectl - Contributor-or-higher access to the cluster's resource group
- A supported region and available quota
- Linux node pools with NVMe-capable VMs (for local storage)
- For Elastic SAN: the Azure Container Storage Operator role on the AKS identity
A dedicated node pool isolates storage-heavy workloads and limits the blast radius of node failures, but adds VM cost. Reusing an existing pool is cheaper and mixes failure domains.
Install with Azure CLI or IaC
az extension add --upgrade --name k8s-extension
az extension add --upgrade --name elastic-san
az provider register --namespace Microsoft.ElasticSan
# Local NVMe
az aks update -n myAKSCluster -g myResourceGroup \
--enable-azure-container-storage ephemeralDisk
# Elastic SAN
az aks update -n <cluster-name> -g <resource-group> \
--enable-azure-container-storage elasticSan
The CLI installs the latest major version by default. --container-storage-version pins the major version only, not minor or patch.
For Terraform, use azurerm_kubernetes_cluster_extension with name acstor and type microsoft.azurecontainerstoragev2. It follows automatic updates, with no manual version selection.
Generic Bicep or ARM extension resources (Microsoft.KubernetesConfiguration/extensions) exist, but the schema carries no ACS-specific pinning guarantee. Review extension versions after each apply to catch drift.
Verify the Installation
kubectl get deploy -n kube-system | grep acstor
kubectl get sc
kubectl get storageclass local-csi
Before production, test:
- Permissions and pod scheduling
- Provisioning, mounting, expansion, and deletion
- Behavior during node maintenance
Create and Consume a Volume
This Elastic SAN example defines a StorageClass and a PersistentVolumeClaim:
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: azuresan-csi
provisioner: san.csi.azure.com
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: managedpvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 1Gi
storageClassName: azuresan-csi
Reference managedpvc under volumes in your Deployment or StatefulSet, then mount it with volumeMounts. Settings to watch:
- Access mode: ReadWriteOnce. RWX is unsupported; use Azure Files or the Blob CSI driver instead.
- Reclaim policy:
Deleteremoves data with the claim. - Expansion: SAN volumes expand, but expanding the backing SAN through ACS is unsupported.
- SAN capacity: The default initial size is 1 TiB.
Test with a Real Workload
Benchmark your actual application where you can. Otherwise use fio, as in Microsoft's tutorial:
kubectl exec -it fiopod -- fio --name=benchtest --size=800m --filename=/volume/test --direct=1 --rw=randrw --ioengine=libaio --bs=4k --iodepth=16 --numjobs=8 --time_based --runtime=60
Track latency, IOPS, throughput, queue depth, and tail behavior, not one headline number. When comparing local NVMe, SAN, and alternatives, hold VM size, dataset, access pattern, and cost assumptions constant.
Performance, Cost, and Workload Fit
Microsoft's September 2025 benchmarks on Standard_L16s_v3 showed:
- About 7x IOPS and 4x lower latency in fio
- 60% higher PostgreSQL TPS
- 5x faster Llama-3.1-8B-Instruct loading, against an ephemeral OS disk

These are vendor tests against the prior ACS version. Block size, job mix, and replication weren't specified, so validate on your own workload.
The Full Cost Model
- ACS service charge: None from 2.0.0. Older versions carried an orchestration charge above a free tier.
- Local NVMe: Included in the VM price, with no separate storage charge.
- Elastic SAN: One Base unit is 1 TiB, 5,000 IOPS, 200 MBps. Capacity-only units add space without performance.
- Also count: node costs, backup, monitoring, and CPU and memory used by storage components.

Pull current rates from Azure's pricing pages. Microsoft says v2 uses fewer resources than the prior lowest-impact tier, but gives no fixed overhead figure.
Workload Guidance
- Caches, scratch data, model loading: local NVMe
- Production databases and critical systems: Elastic SAN plus application replication and independent backups
Beyond ACS
Teams running block storage across Azure and other clouds also need visibility into utilization. Lucidity supports AWS, Azure, and Google Cloud with real-time volume visibility and autonomous block-storage expansion and shrinking. It works as a complementary optimization layer, and this guide doesn't claim native ACS integration.
Operations, Security, and Troubleshooting Best Practices
Observability
ACS exports metrics through acstor-metrics-exporter, scraped every 30 seconds by default. Azure Monitor's guide explains managed Prometheus setup. Existing Prometheus collects ACS metrics automatically, but there's no default ACS Grafana dashboard.
Key metrics to watch:
disk_io_nowanddisk_errors_total- Read/write operation and byte counters
- Kubernetes events, node capacity, and mount failures
Security
- Elastic SAN encrypts at rest with platform-managed keys by default; ACS 2.1+ supports Key Vault customer-managed keys
- CMK needs managed identity access (
get,wrapKey,unwrapKey) plus soft delete and purge protection - Private endpoints fix their type at volume-group creation, and ACLs must authorize every node-pool subnet
- Apply least-privilege roles, protect backups, and block public access on any Blob accounts used alongside ACS
Troubleshooting Sequence
- Pending PVC: The local class waits for a consumer. Setting
spec.nodeNamebypasses the scheduler and can leave the PVC Pending indefinitely. - Unschedulable pod: Check node labels, affinity annotations, taints, and tolerations.
- Capacity errors: Confirm the volume fits one node's available disk.
- Mount or attach failures: Inspect events, StorageClass parameters, SAN ACLs, and quotas.

Microsoft's runbook is for v1.x only, so don't treat it as a v2 reference.
Frequently Asked Questions
What is the difference between a blob and a container in Azure storage?
A blob is an individual object. A Blob Storage container is a logical grouping of blobs. Both differ from ACS volumes, which are block storage for Kubernetes workloads.
Is Azure container the same as Docker?
No. A Blob Storage container is an object-storage namespace, while a Docker or Kubernetes container is an isolated application runtime. ACS is a separate storage orchestration service.
What is Azure Container Storage used for in AKS?
It provides persistent and high-performance storage for stateful AKS workloads, including databases, queues, analytics applications, and AI systems.
Is Azure Container Storage persistent?
It depends on the backend. Local NVMe data is lost on node deletion or VM deallocation, while Elastic SAN volumes are durable. Backups and application replication are still your job.
How does Azure Container Storage differ from Azure Disk and Azure Files?
Azure Disk and Azure Files are storage services. ACS orchestrates Kubernetes volumes on supported backends, currently local NVMe and Elastic SAN. Azure Disk is unsupported in v2, and RWX workloads belong on Azure Files.
Does Azure Container Storage cost extra?
Not from version 2.0.0; orchestration is free. You still pay for AKS VMs, Elastic SAN units, backup, and monitoring, so check current Azure pricing.