Resizing a PersistentVolume Claimed by a StatefulSet with the Plural Operator

Delete the StatefulSet object without deleting the underlying pods.

log.Info("deleting statefulset while orphaning pods", "statefulset", statefulset.Name)
    if err := r.Delete(ctx, &statefulset, client.PropagationPolicy(metav1.DeletePropagationOrphan)); err != nil {
        log.Error(err, "failed to delete", "statefulset", statefulset.Name)
        return ctrl.Result{}, err
    }

Set allowVolumeExpansion: true on the StorageClass associated with your PVC.

// find the storageClass associated with your PVC
var storageClass storagev1.StorageClass
    if claim.Spec.StorageClassName == nil {
        classes := &storagev1.StorageClassList{}
        if err := r.List(ctx, classes); err != nil {
            log.Error(err, "could not list storage classes")
            return ctrl.Result{}, err
        }

        found := false
        for _, class := range classes.Items {
            fmt.Printf("%+v", class)
            if _, ok := class.Annotations["storageclass.kubernetes.io/is-default-class"]; ok {
                storageClass = class
                found = true
                break
            }
        }

        if !found {
            err := fmt.Errorf("Could not find default storage class")
            log.Error(err, "could not find default storage class")
            return ctrl.Result{}, err
        }
    } else {
        if err := r.Get(ctx, types.NamespacedName{Name: *claim.Spec.StorageClassName}, &storageClass); err != nil {
            log.Error(err, "failed to get storageClass", "storageclass", *claim.Spec.StorageClassName)
            return ctrl.Result{}, err
        }
    }


// set AllowVolumeExpansion on the PVC
if storageClass.AllowVolumeExpansion == nil || !*storageClass.AllowVolumeExpansion {
        storageClass.AllowVolumeExpansion = resources.BoolPtr(true)
        if err := r.Update(ctx, &storageClass); err != nil {
            log.Error(err, "Failed to enable volume expansion for storage class", "storageclass", storageClass.Name)
            return ctrl.Result{}, err
        }
    }

Modify the PVC object with the desired storage

for i := 0; i < replicas; i++ {
    claimName := fmt.Sprintf("%s-%s-%d", claim.Name, statefulset.Name, i)
    var pvc corev1.PersistentVolumeClaim
    nsn := types.NamespacedName{
        Namespace: resize.Namespace,
        Name:      claimName,
    }

    if err := r.Get(ctx, nsn, &pvc); err != nil {
        log.Error(err, "failed to get pvc", "pvc", pvc.Name)
        return ctrl.Result{}, err
    }

    pvc.Spec.Resources.Requests["storage"] = quant

    if err := r.Update(ctx, &pvc); err != nil {
        log.Error(err, "failed to resize statefulset pvc", "pvc", pvc.Name)
        return ctrl.Result{}, err
    }
   }

Recreate the StatefulSet with the new storage request

// create a new set of VolumeClaims
claims := statefulset.Spec.VolumeClaimTemplates
    newClaims := make([]corev1.PersistentVolumeClaim, len(claims))
    var claim corev1.PersistentVolumeClaim
    for i, cl := range claims {
        if cl.Name == resize.Spec.PersistentVolume {
            if quant.Cmp(cl.Spec.Resources.Requests["storage"]) == 0 {
                log.Info("No change needed for storage")
                return r.cleanup(ctx, &resize)
            }

            cl.Spec.Resources.Requests["storage"] = quant
            claim = cl
        }

        newClaims[i] = cl
    }

// create a new StatefulSet and set the volumeClaimTemplates with the new claims
newStatefulSet := &appsv1.StatefulSet{}
    newStatefulSet.Spec = statefulset.Spec
    newStatefulSet.Spec.VolumeClaimTemplates = newClaims
    newStatefulSet.Name = statefulset.Name
    newStatefulSet.Namespace = statefulset.Namespace
    newStatefulSet.Labels = statefulset.Labels
    newStatefulSet.Annotations = statefulset.Annotations
    if newStatefulSet.Spec.Template.Annotations == nil {
        newStatefulSet.Spec.Template.Annotations = map[string]string{}
    }

    newStatefulSet.Spec.Template.Annotations["platform.plural.sh/rotate"] = time.Now().String()
    if err := r.Create(ctx, newStatefulSet); err != nil {
        log.Error(err, "failed to recreate statefulset", "statefulset", newStatefulSet.Name)
        return ctrl.Result{}, err
    }