Portworx Lets a Storage Pool Move Off a Failing Node
Portworx Kube Datastore makes a storage pool follow a failed node: replica-1 volumes on a redundant SAN, a 10-second live migration and 51 seconds of recovery.
TL;DR
- Portworx Kube Datastore is a storage feature in Portworx Enterprise that lets a Kubernetes storage pool move from one node to another and maintains access to the volumes it contains.
- The feature reached general availability in Portworx Enterprise 3.7.2, announced in a Portworx post on 9 November 2026, with Operator 26.5.0 and Stork 26.5.0 as the matching companion releases.
- The design target is the replica tax created by writing several software copies of every volume on an already redundant SAN appliance: KDS lets a dynamic pool hold replica-1 volumes and move the pool itself when a node fails.
- Portworx measured a live migration of a running CentOS Stream 9 virtual machine at under 10 seconds with zero observed I/O interruption, and recovery after a hard power-off at about 51 seconds, on a six-node OpenShift cluster backed by a Pure Storage FlashArray.
- The GA release raises the per-node ceiling to 12 dynamic pools, adds compute-aware placement through WaitForFirstConsumer, supports local and remote FastPath on dynamic pools, and moves eligible pools off a node before a Portworx upgrade restarts it.
- The requirements are narrow and stated: Red Hat OpenShift with a Pure FlashArray as the shared backend, replica-1 volumes in every dynamic pool, and an opt-in flag in the StorageCluster spec.

Storage pools follow the disks that sit under them
Portworx Enterprise organises storage into pools, and a pool is a logical grouping of disks of the same class and type. A Kubernetes node with attached storage carries one or more of them, depending on how many kinds of disk are attached. Replication happens between pools, and the replication factor is configurable.
That model works because local disks cannot travel. If a node dies, the storage attached to it dies with it, so the answer is a second copy on another node's pool. Portworx describes this as the correct architecture for local disks, and the post spends its first half explaining why the same answer produces a different result on a shared array.
The replica tax lands on an array that is already redundant
A Pure FlashArray is redundant on its own. When a Portworx cluster sits on one, the extra software copies of each volume still get written to the array. On a FlashArray those copies take no additional space, thanks to data reduction, and they do add work: more writes on the array, and more latency while the write waits for acknowledgement.

The tradeoff is the one an infrastructure team argues about every time it puts stateful workloads on shared storage. Storage-layer replication provides mobility and preserves data access after a node loss. On an already redundant array, array-level replication provides durability; repeated software copies add writes and acknowledgement latency. KDS answers that question for virtual machines, which is where the write cost lands hardest.
A dynamic pool holds replica-1 volumes and moves as a unit
Kube Datastore lets a pool move between Kubernetes nodes in three situations: a node failure is detected, an administrator moves the pool non-disruptively, or the system detects an imbalance. When a failure is detected, the pool migrates to another node and the virtual machine restarts there. During maintenance, the same move happens without disruption.

The mechanics rest on two properties. Dynamic pools use ReadWriteMany access modes and block-level intelligence, which lets both the source and the destination node hold access to a volume during a handoff. And because Portworx sits in the I/O path, it can redirect traffic for a virtual machine that is no longer local to its pool. Portworx sums the result as the efficiency of a single-replica volume with the resilience of a multi-replica system, borrowed from the high availability of the SAN underneath.
Live migration moved a running VM in under ten seconds
Portworx tested the behaviour on a six-node OpenShift cluster running the 3.6.0 Directed Availability build, backed by a Pure Storage FlashArray over iSCSI, with workloads on the px-csi-vm StorageClass at repl=1. The first test moved a running CentOS Stream 9 virtual machine from one worker node to another.

The reported numbers are a migration duration under 10 seconds, zero observed I/O interruption, and a virtual machine that stayed running throughout. The post attributes that to the concurrent access the RWX and block configuration allows: the destination pre-attaches and shares the volume path during the transition, which removes the detach and reattach step that usually interrupts a containerised VM move.
A hard power-off came back in about 51 seconds
The second test removed the graceful part. Portworx performed a hard power-off on the worker node hosting a critical virtual machine, which forces the cluster to re-orchestrate the storage pool, work that goes beyond restarting a pod. Total recovery time was about 51 seconds.
The mechanism Portworx describes is a fastpath failover. When the new node tries to claim the volume while the old coordinator is still listed as active in the control plane, KDS registers a dual-attach and forces the volume to the new coordinator. The virtual machine comes back online in under a minute, and the pool converges on its new home.
Both figures describe a virtual machine. KDS supports containers, as the post states directly, and every published measurement comes from a KubeVirt environment; no published vendor measurement covers container workloads.
The GA release adds scale, placement and upgrade behaviour
Version 3.7.2 turns KDS from a Directed Availability feature into a supported one and adds several operational pieces. The per-node ceiling rises to 12 dynamic pools, up from 4 in the DA release, with headroom for four more so a node can absorb pools during maintenance or an outage. Per-cluster scale is stated at 5,000 volumes and 10,000 snapshots.
Placement changes with WaitForFirstConsumer binding. With WaitForFirstConsumer binding, the virtual machine is placed before the volume is provisioned, so data and workload start on the same node and traffic stays north-south to the SAN. Greenfield 3.7.2 installations get a replica-1 plus WaitForFirstConsumer storage class as the default.

On the data path, local and remote FastPath now both work on dynamic pools. Remote FastPath exports replicas over NVMe or TCP to the node running the virtual machine, with automatic promotion and demotion. Affinity groups keep related pools on one node and pull them back together after a failover, which limits how much a rebalance moves running virtual machines around.
Upgrades get their own change. Version 3.7.2 adds non-disruptive Portworx upgrades. The operator moves eligible pools off the node before restarting it, so virtual machines keep running through the upgrade.
What KDS requires before it will run
The platform requirement is the one that decides most deployments: KDS GA is supported on Red Hat OpenShift with a Pure FlashArray as the shared SAN backend. A dynamic pool contains replica-1 volumes only, so the array carries the redundancy and the cluster cannot mix replica counts inside a pool. Activation is opt-in, through spec.kubedatastore.enableDynamicPools: true in the StorageCluster.

Teams already running static pools have a conversion path. The pxvm tool converts legacy static pools to dynamic pools in place, in three steps: pxvm collect, pxvm migrate plan, then pxvm migrate apply --execute. The tool runs read-only until the apply step, and refuses to start unless the cluster is healthy, on 3.7.2 and has dynamic pools enabled.
Migration from VMware ties into the same placement change. Forklift and MTV migrations can use WaitForFirstConsumer storage classes, so virtual machines land hyperconverged on Portworx, and FlashArray XCopy offload lets large virtual machines around 10 TB migrate in hours.
What the measurements still leave open
The 51-second figure and the 10-second migration come from one test cluster with one array, described down to the storage class, and they say nothing about a cluster with slower array links or a heavier virtual machine. The post publishes no failure rate, no measurement on containers, and no comparison against a replicated pool under the same workload, so the replica tax argument rests on the architecture of writing fewer copies and on the write latency it removes.

What a platform team can take from the post is the shape of the decision. A shared SAN with its own redundancy makes software replicas a cost that buys mobility, and KDS moves that cost into the pool: the pool becomes the unit that travels, and the array keeps the copy. Teams that plan their own sovereign infrastructure and cloud exit work meet the same decision from the other side: how long a workload stays unavailable when a node disappears without warning, and whether anyone learns the answer before a customer does.
Sources
Source: Introduction to Portworx KDS: Static to Dynamic Mobility — portworx.com, 2026-11-09, https://portworx.com/blog/portworx-kube-datastore-kds-introduction/, retrieved 2026-11-16.