Automating Persistent Volume Claims with GCP Storage Classes.

Question

Pulumi · Accepted Answer

To automate the creation of Persistent Volume Claims (PVCs) with GCP Storage Classes in a Kubernetes cluster, we'll use the Pulumi Kubernetes Provider to define the required resources. In GCP, Cloud Filestore is the managed file storage service, which you can use for this purpose.

We will create:

A StorageClass resource to define a storage tier that maps to a GCP Cloud Filestore instance.
A PersistentVolume (PV) to represent the storage volume that the claim can bind to.
A PersistentVolumeClaim (PVC) to request the persistent storage for a pod.

Each PersistentVolume in Kubernetes can be provisioned by specifying a StorageClass. When a PersistentVolumeClaim is created, it can request a specific class of storage. The cluster then dynamically provisions a PersistentVolume that meets the criteria of the claim with the defined StorageClass.

Below is the example Pulumi program written in TypeScript that demonstrates how to set up these resources. Note that you need to have the Pulumi CLI installed and configured with your GCP credentials.

import * as k8s from '@pulumi/kubernetes';

// Define a new Kubernetes Storage Class using GCP Cloud Filestore.
const filestoreStorageClass = new k8s.storage.v1.StorageClass('filestore-sc', {
  metadata: {
    name: 'filestore-sc'
  },
  provisioner: 'filestore.csi.storage.gke.io', // This provisioner is for Google Cloud Filestore.
  parameters: {
    // Add any additional parameters specific to the filestore.csi.storage.gke.io provisioner.
  },
}, { provider: provider }); // Ensure that the 'provider' is the Pulumi Kubernetes Provider configured for the intended cluster.

// Define a new PersistentVolume that uses the StorageClass above.
const filestorePersistentVolume = new k8s.core.v1.PersistentVolume('filestore-pv', {
  metadata: {
    name: 'filestore-pv'
  },
  spec: {
    capacity: {
      storage: '1Ti' // Define size - can be adjusted to your needs.
    },
    accessModes: ['ReadWriteOnce'], // This PV is only mountable by a single node.
    persistentVolumeReclaimPolicy: 'Retain', // Keeps the volume after the PVC is deleted.
    storageClassName: filestoreStorageClass.metadata.name, // Use the GCP Filestore Storage Class created above.
    // Provide the volumeHandle received from GCP after creating the Filestore instance.
    csi: {
      driver: 'filestore.csi.storage.gke.io',
      volumeHandle: '<your-volumeHandle-from-gcp>', // Replace with your actual volume handle from GCP Filestore.
    },
  }
}, { provider: provider });

// Define a PersistentVolumeClaim that requests the StorageClass above.
const filestorePersistentVolumeClaim = new k8s.core.v1.PersistentVolumeClaim('filestore-pvc', {
  metadata: {
    name: 'filestore-pvc'
  },
  spec: {
    accessModes: ['ReadWriteOnce'],
    resources: {
      requests: {
        storage: '1Ti' // Ensure this matches the size of the PersistentVolume above.
      },
    },
    storageClassName: filestoreStorageClass.metadata.name,
  }
}, { provider: provider });

// Export the name of the PersistentVolumeClaim
export const persistentVolumeClaimName = filestorePersistentVolumeClaim.metadata.name;

In the program above:

We define a StorageClass named filestore-sc that uses the GCP Filestore CSI driver.
Next, we create a PersistentVolume that represents a block of storage in GCP associated with the StorageClass we just created. The volumeHandle is a unique identifier for your GCP Filestore instance which you receive when you create a Filestore in GCP.
We then define a PersistentVolumeClaim which uses the StorageClass and requests 1Ti of storage, the same amount as specified in the PersistentVolume. The access mode ReadWriteOnce means the volume can be mounted as read-write by a single node.

You would replace the placeholder <your-volumeHandle-from-gcp> with the actual volume handle provided by GCP for your Filestore instance.

Note: The actual provisioning of GCP Filestore instances and retrieving their volumeHandle requires setting them up through GCP Console or the CLI, which is not covered by the Pulumi Kubernetes resources. So the volumeHandle should be obtained before running your Pulumi program.

Remember to adjust the storage size requests, access modes, and other parameters to suit your specific use case.