De individuele nodes van Kubernetes-clusters komen met een kleine hoeveelheid opslagruimte. Wanneer je voor jouw use case aanvullende schijfruimte nodig hebt, voeg je die toe door een 'Persistent Volume' en/of 'Persistent Volume Claim' te gebruiken. Hierin kun je aangeven wat voor type storage je wil gebruiken, bijvoorbeeld block storage, file storage of object storage.

Wanneer dit nieuwe termen voor je zijn raden we aan eerst ons artikel over Persistent Volumes en Persistent Volume Claims te lezen. In deze handleiding laten we zien hoe je een 'block storage' gebruikt op je Kubernetes-cluster door middel van een Persistent Volume Claim.

Een block storage gebruiken op je cluster

Wanneer je begint met Kubernetes kom je veel voorbeelden tegen zowel online in .yaml-objecten als in Helm-charts waarin er gebruik wordt gemaakt van block storages via de 'kind' PersistentVolume en/of PersistentVolumeClaim.

Als je je eigen applicatie containerizeert dan kom je al snel een punt tegen waarop je zelf extra schijfruimte aan je deployment wil toekennen. In de volgende stappen laten we aan de hand van een simpel voorbeeld zien hoe je via een PersistentVolumeClaim extra schijfruimte aan je applicaties toekent.

Stap 1

Maak eerst een namespace aan waarin je je (test-)setup opneemt:

kubectl create ns transip-demo
    

Je bent uiteraard vrij om de namespace naam transip-demo aan te passen naar een andere naam. Let wel dat je dat in de volgende stappen dan ook doet.

Stap 2

Maak het object aan waarin je de setup definieert:

nano transip-demo.yaml
    

Geef het bestand de inhoud uit het codeblock hieronder. In dit voorbeeld maken we gebruik van een Nginx-deployment met een loadbalancer service, MySQL-server en twee block storages om extra schijfruimte te bieden.

Het is altijd handiger om per applicatie een PVC toe te voegen omdat in een praktijktoepassing elke applicatie mogelijk verschillende opslagvereisten heeft in termen van grootte, toegangsmodus (ReadWriteOnce, ReadOnlyMany, ReadWriteMany), etc. Het scheiden van PVC's per applicatie zorgt ook voor een betere isolatie en beveiliging.

apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: nginx-pvc
      namespace: transip-demo
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-deployment
      namespace: transip-demo
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.25.1
            ports:
            - containerPort: 80
            volumeMounts:
            - name: nginx-storage
              mountPath: /usr/share/nginx/html
          volumes:
          - name: nginx-storage
            persistentVolumeClaim:
              claimName: nginx-pvc
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: nginx-service
      namespace: transip-demo
    spec:
      type: LoadBalancer
      ports:
      - port: 80
      selector:
        app: nginx
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: mysql-pvc
      namespace: transip-demo
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: mysql-deployment
      namespace: transip-demo
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: mysql
      template:
        metadata:
          labels:
            app: mysql
        spec:
          containers:
          - name: mysql
            image: mysql:8.0
            env:
            - name: MYSQL_ROOT_PASSWORD
              value: my-secret-pw
            ports:
            - containerPort: 3306
            volumeMounts:
            - name: mysql-storage
              mountPath: /var/lib/mysql
          volumes:
          - name: mysql-storage
            persistentVolumeClaim:
              claimName: mysql-pvc

Sla de wijzigingen op en sluit het bestand (ctrl + x > y > enter).

De onderdelen van deze configuratie:

In een notendop bestaat deze configuratie uit de volgende onderdelen:

1. Een PersistentVolumeClaim voor Nginx van 1Gi. Dit geeft Nginx extra schijfruimte die je bijvoorbeeld kunt inzetten om statische bestanden van een website te hosten.
2. Een Deployment voor Nginx, die een enkele replica van de Nginx pod draait en de eerder gemaakte PersistentVolumeClaim gebruikt voor opslag.
3. Een Service voor Nginx, die de Nginx pod blootstelt aan het internet via een LoadBalancer.
4. Een PersistentVolumeClaim van 10 Gi voor MySQL.
5. Een Deployment voor MySQL, die een enkele replica van de MySQL pod draait en de 'mysql-pvc' PersistentVolumeClaim gebruikt voor opslag.

Code specifiek voor het gebruik van Persistent Volume Claims:

Een groot deel van de code in dit object zal er vertrouwd uit zien als je vaker in Kubernetes met .yaml-objecten hebt gewerkt. Zo niet, raden we aan om onze handleiding over het maken van .yaml-objecten te bekijken. Er zijn in het PVC-blok echter twee elementen die in het bovengenoemde artikel niet behandeld worden, namelijk:

• spec.accessModes: De modus waarop het volume gemount wordt, zie deze pagina voor de beschikbare opties.
• spec.storageClassName: Het type storage class dat je gebruikt. Beschikbare opties zijn transip-fast-storage op basis van NVMe en transip-big-storage op basis van HDD.

Let op: Dit is een eenvoudig voorbeeld en in een productieomgeving zou je geheime waarden zoals het MySQL-wachtwoord niet direct in het YAML-bestand opnemen, maar ze opslaan in een Kubernetes Secret. Daarnaast zou je ook gebruik maken van SSL. Dit valt echter buiten de scope van deze handleiding.

Stap 3

Pas je configuratie toe op je cluster met het commando:

kubectl apply -f transip-demo.yaml

Je krijgt nu een bevestiging te zien die er ongeveer als volgt uitziet:

transip:~$ kubectl apply -f bsdemo.yaml
    persistentvolumeclaim/nginx-pvc created
    deployment.apps/nginx-deployment created
    service/nginx-service created
    persistentvolumeclaim/mysql-pvc created
    deployment.apps/mysql-deployment created

Daarmee zijn we aan het eind van deze handleiding over het gebruik van block storage via een Persistent Volume Claim gekomen.