Lab 6 - Kubernetes Storage

Complete

Log into the Ghostfolio application (use any of the node IPs and the port configured in ghostfolio Nodeport service).

Use the "Get Started" button and save the security Token that is provided. This token will be used for loging in to Ghostfolio.

Also, make a new account. The account information is stored in the Postgres DB.

Now, delete the posgresql Pod. As we have configured postgre as a StatefulSet, Kubernetes will notice that the number of Pods is smaller than required (1) and will recreate the Pod automatically.

Complete

Create a new Storage Class template with "local-storage" name and the following content:

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
reclaimPolicy: Retain
volumeBindingMode: WaitForFirstConsumer 

Some explanations to used values:

• provisioner: kubernetes.io/no-provisioner means that we do not use an automated (or dynamic) provisioner. And we will have to create the Persitent Volumes manually.
• volumeBindingMode: WaitForFirstConsumer means that PV is not initiated until a Pod claiming it is provisioned.
• reclaimPolicy: Retain means that PV content should be kept between. This setting has no real effect for us as we are not using a provisioner.

Apply the template to Kubernetes.

Complete

Create a "/mnt/data" folder in both Kubernetes nodes. We will store persistent volumes there.

Let's now create a new Persitant Volume postgres-0-pv. Add the following content to a new pv-postgre.yaml file:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgresql-0-pv
  labels: 
    app: postgresql
    ver: postgresql-0-pv-v1
spec:
  capacity:
    storage: 1Gi
  volumeMode: Filesystem
  accessModes:
  - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: local-storage
  local:
    path: /mnt/data/postgresql-0-pv
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - NODE-HOSTNAME

NODE-HOSTNAME must be replaced with actual full hostname (e.g., pelle-worker.cloud.ut.ee) Apply the pv-postgre.yaml template using kubectl.

Also, create a folder for a new volume at /mnt/data/postgresql-0-pv in your first/main machine.

Set its folder permissions to 755.

Complete

Let's now create a new Persitant Volume Claim (PVC) postgres-0-pv-claim and reconfigure our posgresql database stateful set to use it.

Add the following content to a new pv-claim-postgre.yaml file:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-0-pv-claim
spec:
  storageClassName: local-storage
  selector:
    matchLabels:  #Select a volume with this labels
      app: postgresql
      ver: postgresql-0-pv-v1
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Gi

Apply the pv-claim-postgre.yaml template using kubectl.

Modify the posgresql stateful set we created in lab 4 (statefulset-postgre.yaml)

Replace the line:

  volumes:
    - name: postgresql-data
      emptyDir: {}

with:

  volumes:
    - name: postgresql-data
      persistentVolumeClaim:
        claimName: postgres-0-pv-claim

And apply the modified posgresql stateful set template.

Complete

First, make sure you have created a user inside the Ghostfolio Application. Secondly, delete the postgresql-0 Pod and check that the database stays intact afterwards.

Complete

You'll be completing this section from Longhorn documentation

There's few packages you'll need to install, using the package manager:

• nfs-utils
• iscsi-initiator-utils
• jq

Make sure to also load the iscsi_tcp kernel module, and make it persistent across reboots. You can achieve this by loading the module with modprobe command and adding the kernel module name to a file in /etc/modules-load.d/<file>.conf

Finally, start and enable the iscsid systemd service.

Complete

Do this part only if the verification of the previous step did not bring up any issues. Perform these tasks on the main server only.

There are several ways to install Longhorn, but we'll use the simplest and quickest one, which uses kubectl.

kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.5.1/deploy/longhorn.yaml

This command downloads the manifest from the URL and applies it to the cluster.

Complete

Create a namespace called storage, and run the following manifest:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: longhorn-pvc
  namespace: storage
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: longhorn
  resources:
    requests:
      storage: 1Gi
---
apiVersion: v1
kind: Pod
metadata:
  name: writer-pod
  namespace: storage
spec:
  containers:
  - name: busybox
    image: busybox
    command: ["/bin/sh", "-c", "echo 'Hello, Persistent Storage!' >> /data/hello.txt; sleep 3600"]
    volumeMounts:
    - name: longhorn-volume
      mountPath: /data
  volumes:
  - name: longhorn-volume
    persistentVolumeClaim:
      claimName: longhorn-pvc

Complete

Create a new Longhorn type PersistentVolumeClaim for the Postgresql StatefulSet.

NB! Name the persistent volume claim postgresql-lh-pvc

Reconfigure Postgresql to claim the Longhorn Persistent Volume instead of local volume type.

Because Postgresql does not run as a root user inside the container, we need to make sure that the directory permissions are correct in the mounted volume. At the start of the lab, we did this manually for the local volume. Now we will automate it using a Kubernetes init container. Add a new init container to the Postgre StatefulSet which changes the owner of the mounted volume before the Postgresql container is started.

Add the following inside the spec: block of Postgresql StatefulSet template:

      initContainers:
      - name: permission-init
        image: alpine:latest
        command:
        - sh
        - -c
        - (chown 1001:1001 /bitnami/postgresql)
        volumeMounts:
          - name: postgresql-data
            mountPath: /bitnami/postgresql