Skip to main content
Version: 26.1

Control Volume Placement Using FlashArray Pods

Use FlashArray pods to control where PX-CSI provisions volumes when multiple FlashArrays are connected to your Kubernetes cluster. This feature lets you direct volumes to specific arrays based on performance tiers, geographic location, or other organizational requirements.

note

This feature requires Purity//FA version 6.6.11 or later.

Use FlashArray pod-based volume placement when:

  • You have multiple FlashArrays connected to your cluster.
  • You need to provision volumes on specific arrays (such as performance or capacity tiers).
  • You want to organize volumes by workload type, department, or geographic location.
  • You are implementing secure multi-tenancy with FlashArray realms and pods.

How it works​

When you specify pure_fa_pod_name in a StorageClass:

  1. PX-CSI receives a volume provisioning request.
  2. PX-CSI searches for the specified pod name across all connected FlashArrays.
  3. After PX-CSI finds the pod, it provisions the volume inside that pod on the FlashArray where the pod exists.
  4. PX-CSI names the volume using the convention: <pod-name>::px_<cluster-uuid-prefix>-pvc-<pvc-uuid>
important

If the same pod name exists on multiple FlashArrays, PX-CSI will schedule volumes on any of those arrays. To target a specific FlashArray, make sure the pod name is unique to that array.

Example use case​

The following example shows how to separate high-performance and capacity-optimized workloads across different FlashArrays.

Scenario: You need to provision storage for two different workload types:

  • Database workload: Requires high IOPS and low latency for transactional operations
  • Backup workload: Requires large capacity for storing backups, where performance is less critical

Environment: Four FlashArrays: two high-performance arrays and two capacity-optimized arrays.

Configuration:

  • Create a pod named performance-pod on both high-performance arrays.
  • Create a pod named capacity-pod on both capacity-optimized arrays.
  • Create a performance-array-sc StorageClass with pure_fa_pod_name: "performance-pod" for database volumes.
  • Create a capacity-array-sc StorageClass with pure_fa_pod_name: "capacity-pod" for backup volumes.

Result:

  • Database volumes (using performance-array-sc) are provisioned on high-performance arrays with IOPS and bandwidth limits.
  • Backup volumes (using capacity-array-sc) are provisioned on capacity-optimized arrays without performance constraints.

Create FlashArray pods​

Before configuring StorageClasses, create the required pods on your FlashArrays.

Create a pod on each FlashArray where you want to provision volumes:

purepod create <pod-name>

Example:

# Create performance pod on high-performance arrays
purepod create performance-pod

# Create capacity pod on capacity-optimized arrays
purepod create capacity-pod

Configure StorageClass with pod placement​

Create StorageClass YAML manifests that specify the FlashArray pod name using the pure_fa_pod_name parameter.

In this example, you create two StorageClasses:

  • Performance StorageClass: For database workloads requiring high IOPS (50,000) and bandwidth (10G)
  • Capacity StorageClass: For backup workloads where capacity is more important than performance

  1. Create StorageClass YAML manifests for different performance tiers:

    performance-sc.yaml
    kind: StorageClass
    apiVersion: storage.k8s.io/v1
    metadata:
      name: performance-array-sc
    provisioner: pxd.portworx.com
    parameters:
      backend: "pure_block"
      pure_fa_pod_name: "performance-pod"
      max_iops: "50000"
      max_bandwidth: "10G"
    volumeBindingMode: Immediate
    capacity-sc.yaml
    kind: StorageClass
    apiVersion: storage.k8s.io/v1
    metadata:
      name: capacity-array-sc
    provisioner: pxd.portworx.com
    parameters:
      backend: "pure_block"
      pure_fa_pod_name: "capacity-pod"
    volumeBindingMode: Immediate
    tip

    For a complete list of StorageClass parameters, see the StorageClass reference.

  2. Apply the StorageClasses:

    kubectl apply -f performance-sc.yaml -f capacity-sc.yaml
    storageclass.storage.k8s.io/performance-array-sc created
    storageclass.storage.k8s.io/capacity-array-sc created

Create PVCs using pod-based StorageClasses​

Create PVCs that reference the appropriate StorageClass with pod placement. The configuration is the same for both standard and multi-tenancy deployments.

In this example, you create two PVCs:

  • Database PVC: 100Gi volume on high-performance arrays for database workloads
  • Backup PVC: 1Ti volume on capacity-optimized arrays for backup storage

  1. Create PVC YAML manifests:

    database-pvc.yaml
    kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: database-claim
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 100Gi
      storageClassName: performance-array-sc  # Uses performance-pod
    backup-pvc.yaml
    kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: backup-claim
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 1Ti
      storageClassName: capacity-array-sc  # Uses capacity-pod
    tip

    For a complete list of PersistentVolumeClaim fields and annotations, see the PersistentVolumeClaim reference.

  2. Apply the PVCs:

    kubectl apply -f database-pvc.yaml -f backup-pvc.yaml
    persistentvolumeclaim/database-claim created
    persistentvolumeclaim/backup-claim created

Verify volume placement​

After creating a PVC, verify that the volume was provisioned in the correct FlashArray pod.

  1. Get the PersistentVolume name:

    kubectl get pvc database-claim
    NAME              STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS            AGE
    database-claim    Bound    pvc-a1b2c3d4-xxxx-xxxx-xxxx-105a73740493   100Gi      RWO            performance-array-sc    2m

  2. Find the PureVolume associated with your PVC:

    kubectl get pvol -n portworx | grep pvc-a1b2c3d4
    xxxxxxxx-xxxx-xxxx-xxxx-d7e4a5255d7d   px_20e4c7e1-pvc-a1b2c3d4-xxxx-xxxx-xxxx-105a73740493   FlashArray    2m

  3. Get the detailed information for the specific PureVolume:

    kubectl get pvol xxxxxxxx-xxxx-xxxx-xxxx-d7e4a5255d7d -n portworx -o yaml
    apiVersion: storage.purestorage.com/v1alpha1
    kind: PureVolume
    metadata:
      name: xxxxxxxx-xxxx-xxxx-xxxx-d7e4a5255d7d
      namespace: portworx
    spec:
      storageBackends:
      - id: 1b07343b-xxxx-xxxx-xxxx-8b5e8cdeb16c
        ...
      volumeName: performance-pod::px_20e4c7e1-pvc-a1b2c3d4-xxxx-xxxx-xxxx-105a73740493

    Note the following information:

    • volumeName: The full volume name on FlashArray, including the pod prefix (performance-pod::px_20e4c7e1-...)
    • storageBackends.id: The FlashArray backend ID (e.g., 1b07343b-xxxx-xxxx-xxxx-8b5e8cdeb16c). Use this ID to identify the FlashArray in the Pure Storage GUI.

  4. On the FlashArray, verify that the volume exists in the specified pod:

    purevol list --pod performance-pod

    The volume name should appear with the pod prefix: performance-pod::px_20e4c7e1-pvc-a1b2c3d4-xxxx-xxxx-xxxx-105a73740493