
The central distinction is simple. Kubernetes generally supports expanding a bound PersistentVolumeClaim (PVC). Shrinking is not supported, so you create a smaller replacement volume and migrate the data.
This guide covers expansion prerequisites, online versus offline filesystem resizing, safe shrink workarounds, StatefulSet handling, and production validation.
Key Takeaways
- Expansion depends on the StorageClass, CSI driver, storage provider, and filesystem.
- Lowering a PVC request is not a shrink procedure.
- A shrink means a new PVC, controlled data migration, cutover, and validation.
- StatefulSet template edits do not resize existing claims.
What PVC Resize Means in Kubernetes
PVC resize changes the capacity of a bound PersistentVolumeClaim. The operation touches every layer in the storage stack, so you need to know which one is lagging:
- The PVC requests storage and binds to a PersistentVolume (PV)
- The StorageClass defines how volumes are provisioned
- The CSI driver talks to the cloud block volume
- The filesystem sits on top of that volume
Requested versus reported capacity
spec.resources.requests.storage is what you ask for. status.capacity.storage is what Kubernetes reports. During expansion they differ, and they must eventually agree. Expansion resizes the existing volume rather than creating a new PV, per the Kubernetes persistent volumes documentation.
Two stages, online or offline
Expansion happens in two stages:
- The external-resizer calls the CSI controller (
ControllerExpandVolume) and the backend grows the block device. - Where required, the node calls
NodeExpandVolumeso the filesystem grows and the application can use the space.
Kubernetes supports expanding XFS, Ext3, and Ext4. In-use (online) expansion has been stable since v1.24.
Whether you need a restart still depends on the CSI driver's online/offline capability, the filesystem, the backend, and the driver version. Treat zero downtime as conditional.
Native workflows are built for growth only. Check current Kubernetes and CSI driver documentation rather than relying on older in-tree plugin behavior. In-tree drivers are deprecated, and CSI migration has been GA since v1.25.

How to Expand a PVC Safely
Verify expansion support first
Inspect the claim, its class, and the provisioner:
kubectl get pvc data-pvc -o jsonpath='{.spec.storageClassName}'
kubectl get storageclass <class> -o yaml
Confirm allowVolumeExpansion: true and check that your CSI driver documents controller-side expansion. Online expansion may need extra node-side capability, so verify the exact combination of Kubernetes version, driver, provider, filesystem, and access mode. Note that GKE states ReadOnlyMany claims cannot be expanded.
Update the PVC request
Raise only spec.resources.requests.storage, and make it larger than the current value. Microsoft's AKS documentation uses this patch:
kubectl patch pvc pvc-azuredisk --type merge \
--patch '{"spec":{"resources":{"requests":{"storage":"15Gi"}}}}'
kubectl edit or a declarative manifest works equally well. Treat the PVC manifest as the source of truth. Don't edit the PV capacity or the cloud disk directly unless your provider says to. Editing PV capacity can suppress the real backend expansion.
Monitor the workflow
Run kubectl describe pvc <name> and watch conditions and events. Check CSI controller logs and, if the filesystem step stalls, node-side or kubelet logs.
| Signal | Meaning |
|---|---|
Resizing=True |
Controller expansion is in progress on the backend |
FileSystemResizePending |
Backend is done; the node filesystem still needs to finish |
FileSystemResizeRequired event |
Node-side filesystem expansion is required |
VolumeResizeFailed event |
The controller hit an error |
FileSystemResizePending carries the message "Waiting for user to (re-)start a pod to finish file system resize." That is not a universal restart requirement when online expansion is supported.
Provider limits apply too:
- AWS EBS allows four modifications per rolling 24 hours as of January 15, 2026, each starting after the previous completes (the old six-hour wait is outdated)
- Azure online expansion works up to 4 TiB; larger Standard HDD, Standard SSD, and Premium SSD disks require detaching and scaling to zero
Complete filesystem expansion
If a restart is needed, use a rolling restart for replicated Deployments:
kubectl rollout restart deployment/<name>
This replaces pods gradually and keeps capacity available. Deleting a single-replica pod causes downtime. For databases and other stateful apps, schedule an application-aware maintenance window.
Validate inside the workload
Compare the PVC's reported capacity with what the pod sees:
kubectl get pvc data-pvc -o jsonpath='{.status.capacity.storage}'
kubectl exec <pod> -- df -h /data
Then check application health, I/O latency, and workload metrics before calling it done. Record the driver-specific steps and any resize events in your runbook.

PVC Shrink Workarounds
Why there is no simple shrink
Kubernetes does not support shrinking a PVC below its current size. Lowering the request doesn't reduce the filesystem or block device, and data may sit beyond the proposed smaller boundary.
Don't shrink the cloud disk, PV, or filesystem directly. resize2fs can shrink an unmounted ext4 filesystem, and XFS has limited last-allocation-group shrink support, but neither adds PVC shrink support.
A mismatched change risks data loss, corruption, or a Kubernetes-versus-backend mismatch.
One caveat: Kubernetes v1.34 made recovery from expansion failure GA. You can lower a failed request, but only to a value above reported capacity. That corrects a retry; it is not a shrink.
Choose a migration strategy
| Strategy | Best when | Watch for |
|---|---|---|
| New PVC + file copy | Short downtime is acceptable | Metadata fidelity, write quiescing |
| Snapshot or backup restore | Driver supports snapshots | Restore size floor |
| Application-native replication or export/import | Database or clustered app | Needs app support |
Weigh downtime tolerance, access mode, snapshot support, replication, and data volume. AWS's own guidance for a smaller EBS volume is a replacement volume plus application-level migration, such as rsync.
Migrate data to a smaller PVC
- Create the replacement PVC and confirm its StorageClass and filesystem.
- Stop or quiesce writes.
- Copy data, preserving ownership, permissions, links, ACLs, xattrs, and sparse files.
- Run a final sync.
- Validate before cutover.
A common copy command, run from a helper pod mounting both claims:
rsync -aHAXS --numeric-ids /old/ /new/
-a alone omits hard links, ACLs, and xattrs, so -H, -A, and -X matter. -S handles sparse files.
Exact flags depend on filesystem, security context, and access mode. Xattr copying also depends on privileges. Validate with file counts, checksums, or application-level checks, then confirm mount options with a test read/write.

Cut over and keep a rollback
Before you switch, lock in the basics:
- Plan a maintenance window and confirm a backup exists.
- Define rollback criteria up front.
- Check DNS and Service continuity.
Point the Deployment, StatefulSet, Helm values, or operator-managed resource at the new claim. Operators may reconcile manual edits away, so change the declarative source.
Set the old PV's reclaim policy to Retain and keep the original PVC until validation finishes.
Snapshots, clones, and replication
A CSI clone must request at least the source capacity, in the same namespace and VolumeMode. A snapshot restore cannot go below VolumeSnapshot.status.restoreSize. So neither gets you to a smaller volume. They mainly speed up creating a copy you'll then migrate from.
Neither guarantees application consistency. Databases and write-heavy systems may need quiescing, a native backup, replication, or a transactionally consistent export.
After cutover validates and rollback is no longer needed, clean up old claims, snapshots, and cloud volumes.

StatefulSets and Production Edge Cases
Changing a StatefulSet's volumeClaimTemplates doesn't resize existing PVCs. GKE documents that direct template edits are rejected, and new replicas still receive the original size.
Resize each ordinal's PVC individually (data-web-0, data-web-1, and so on). KEP 4650 proposes template updates, but it's still an open proposal, so don't plan around it.
Coordinate the work with your application:
- Default
OrderedReadypod management waits on each predecessor;Paralleldoesn't. - The Eviction API respects PodDisruptionBudgets, but direct pod deletion bypasses them.
- Move one replica at a time and confirm replication health and leader election between steps.
Be careful with delete-and-recreate recipes. kubectl delete --cascade=orphan leaves pods running without a controller. Later PVC deletion can still remove backing storage, depending on reclaim policy.
Since v1.32, persistentVolumeClaimRetentionPolicy (default Retain) governs claim deletion. Take a backup before any controller change.
Automation, Monitoring, and Storage Optimization
Watch volumes before they fill. Useful signals:
kubelet_volume_stats_used_bytes,capacity_bytes, andavailable_bytes- Requested versus reported PVC capacity
- Resize conditions, events, and CSI errors
- Pod restarts and application health
The kubernetes-mixin's KubePersistentVolumeFillingUp alert warns below 15% free with a four-day forecast, and fires critical below 3%.
Expansion controllers cut repetitive edits. TopoLVM's pvc-autoresizer grows PVCs from Prometheus metrics, with a StorageClass opt-in, a per-PVC upper limit, and 10% default thresholds. Whatever you use, add guardrails:
- Maximum capacity caps
- Approval policies
- Rate limits
- Alerting on resize activity
- Testing against each CSI driver you run
Native workflows still leave shrinking and continuous right-sizing to you. Lucidity provides an application-agnostic, autonomous cloud block storage layer that expands, shrinks, and optimizes storage across AWS, Azure, and Google Cloud with zero downtime.
Its internal data shows enterprises averaging 30% disk utilization, the gap continuous optimization targets. For teams that need that beyond PVC workflows, validate compatibility with your environment and governance requirements before deploying.
Frequently Asked Questions
Can a PVC be resized in Kubernetes?
Yes, for expansion. Kubernetes can expand a bound PVC when the StorageClass and CSI driver support it. Behavior still depends on the storage provider and filesystem.
Can you shrink a PVC in Kubernetes?
Not natively. Create a smaller replacement PVC, migrate or restore the data, validate it, and cut over the workload.
How do I expand a PVC without downtime?
You need online expansion support across the CSI driver, storage provider, and filesystem. Without it, a controlled pod restart may be necessary.
Why is my PVC stuck in FileSystemResizePending?
The block device grew but the filesystem hasn't, the driver needs a remount or restart, or node-side expansion failed. Check PVC events and CSI or kubelet logs.
How do I resize a PVC used by a StatefulSet?
Resize each existing PVC individually. Plan rollout, replication, disruption, and consistency for every ordinal.
What is the safest workaround for shrinking a PVC?
Take a backup or snapshot, create a smaller PVC, and migrate with consistency in mind. Cut over, validate, and delete the original claim only later.