PersistentVolumeClaims with StorageOS

Difficulty: Beginner

Estimated Time: 15 minutes

This sandbox environment is a fully configured 3 node Kubernetes cluster with StorageOS already installed.

In this tutorial, you will create and use Persistent Volume Claims using StorageOS and multiple StorageClasses.

Your environment is currently being packaged as a Docker container and the download will begin shortly. To run the image locally, once Docker has been installed, use the commands

cat scrapbook_storageos_pvc-basic_container.tar | docker load

docker run -it /storageos_pvc-basic:

Restart Scenario

Next Scenario

Step 1 of 7

Introduction and Setup Environment

First verify the StorageOS Installation.

kubectl -n kube-system get pods -lapp=storageos

We can use a pod to access the CLI using kubectl exec:

kubectl -n kube-system run \ --image storageos/cli:v2.1.0 \ --restart=Never \ --env STORAGEOS_ENDPOINTS=[[HOST2_IP]]:5705 \ --env STORAGEOS_USERNAME=storageos \ --env STORAGEOS_PASSWORD=storageos \ --command cli \ -- /bin/sh -c "while true; do sleep 999999; done"

Wait for the CLI pod to enter the Running state and press Ctrl+C to continue once the pod is running.

kubectl -n kube-system get pods -l run=cli -w

Verify that you have a healthy installation with three nodes:

kubectl exec -ti cli -n kube-system -- storageos get node

Create Dev PVC

Lets check how to dynamically provision storage using StorageOS.

During cluster bootstrap StorageOS creates a StorageClass called fast. A StorageClass is a Kubernetes construct that describes different "classes" of Storage and their providers.

Additional StorageClasses can be created to define different behaviours or apply feature labels by default.

Lets create a StorageClass and provision a PVC (Persistent Volume Claim).

Create a StorageClass for development.

kubectl create -f-<<END
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: dev
provisioner: csi.storageos.com
allowVolumeExpansion: true
parameters:
  csi.storage.k8s.io/fstype: ext4
  pool: default
  csi.storage.k8s.io/node-publish-secret-namespace: kube-system
  csi.storage.k8s.io/provisioner-secret-namespace: kube-system
  csi.storage.k8s.io/controller-publish-secret-namespace: kube-system
  csi.storage.k8s.io/controller-expand-secret-namespace: kube-system
  csi.storage.k8s.io/node-publish-secret-name: csi-node-publish-secret
  csi.storage.k8s.io/provisioner-secret-name: csi-provisioner-secret
  csi.storage.k8s.io/controller-publish-secret-name: csi-controller-publish-secret
  csi.storage.k8s.io/controller-expand-secret-name: csi-controller-expand-secret
END

Create a Namespace for development

kubectl create namespace dev

Create a PVC in the dev namespace.

kubectl create -f- <<END
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-1
  namespace: dev
spec:
  storageClassName: dev
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
END

Check the PVC

kubectl -n dev get pvc

StorageOS dynamically provisions the PV (Persistent Volume).

kubectl get pv

Create Prod PVC

We can create a second StorageClass for production.

Creating a StorageClass for production

kubectl create -f- <<END
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: prod
provisioner: csi.storageos.com
allowVolumeExpansion: true
parameters:
  csi.storage.k8s.io/fstype: ext4
  pool: default
  storageos.com/replicas: "1" # Enforces 1 replica for any Volume created by this StorageClass
  csi.storage.k8s.io/node-publish-secret-namespace: kube-system
  csi.storage.k8s.io/provisioner-secret-namespace: kube-system
  csi.storage.k8s.io/controller-publish-secret-namespace: kube-system
  csi.storage.k8s.io/controller-expand-secret-namespace: kube-system
  csi.storage.k8s.io/node-publish-secret-name: csi-node-publish-secret
  csi.storage.k8s.io/provisioner-secret-name: csi-provisioner-secret
  csi.storage.k8s.io/controller-publish-secret-name: csi-controller-publish-secret
  csi.storage.k8s.io/controller-expand-secret-name: csi-controller-expand-secret
END

Note the additional parameter storageos.com/replicas: 1. This parameter will apply a storageos.com/replicas: 1 label to any volume created with the prod StorageClass causing StorageOS to provision a volume with 1 replica. This means that 2 synchronous copies of the volume data are kept on two nodes in the cluster. The primary volume, where I/O operations are performed by the application and the replica that keeps in sync from the primary. Having a replicated volume means that should the node holding the primary volume fail, the replica volume will be promoted and I/O can continue uninterrupted. For more information about StorageOS replication please see: https://docs.storageos.com/docs/concepts/replication/

Create a Namespace for production

kubectl create namespace prod

Create a PVC in the prod namespace.

kubectl create -f- <<END
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-1
  namespace: prod
spec:
  storageClassName: prod
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
END

Check the PVC

kubectl -n prod get pvc

Labels in PVC spec

It can be useful to define feature labels for each PVC instead of using the StorageClass. You can define StorageOS labels such as replication in the PVC definition.

For instance, the following would create a Volume with 1 replicas.

kubectl create -f- <<END
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-replicated
  labels:
    storageos.com/replicas: "1"
spec:
  storageClassName: dev
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
END

Create Pod and write to Volume

Once PVCs are provisioned, Pods can use them to store data persisted by StorageOS.

Create Pod using PVC

kubectl create -f- <<END
apiVersion: v1
kind: Pod
metadata:
  name: d1
  namespace: prod
  labels:
    app: debian
spec:
  containers:
    - name: debian
      image: debian:9-slim
      command: ["/bin/sleep"]
      args: [ "3600" ]
      volumeMounts:
        - mountPath: /mnt
          name: v1
  volumes:
    - name: v1
      persistentVolumeClaim:
        claimName: pvc-1
END

Wait for the Pod to be ready

kubectl -n prod get pod -w

Exec into the Pod

kubectl -n prod exec -it d1 -- /bin/bash
Check the FileSystem in the Pod

df -h /mnt
Create file in the StorageOS Volume

echo 'Hello world' > /mnt/hello
Exit the Pod

exit

Restart Pod

Delete the Pod

kubectl -n prod delete pod d1

Wait until the Pod is deleted.

Recreate Pod to mount the Volume

kubectl create -f- <<END
apiVersion: v1
kind: Pod
metadata:
  name: d1
  namespace: prod
  labels:
    app: debian
spec:
  containers:
    - name: debian
      image: debian:9-slim
      command: ["/bin/sleep"]
      args: [ "3600" ]
      volumeMounts:
        - mountPath: /mnt
          name: v1
  volumes:
    - name: v1
      persistentVolumeClaim:
        claimName: pvc-1
END

Wait for the Pod to be ready

kubectl -n prod get pod -w

Check content

kubectl -n prod exec d1 -- cat /mnt/hello

The data is persisted across container restarts and can be claimed by applications.

Terminal

cd <directory>	Change directory
ls	List directory
echo 'contents' > <file>	Write contents to a file
cat <file>	Output contents of file

i	In Command Mode	Change into Insert Mode, you can now insert and edit text in the file
esc	In Insert Mode	Change into Command Mode, you can now execute commands
:wq	In Command Mode	Save and Exit

Welcome!

PersistentVolumeClaims with StorageOS

Congratulations!

You've completed the scenario!

Scenario Rating

Steps