Block storage aan je Kubernetes-cluster koppelen

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. Let wel dat op ons Kubernetes-platform wij enkel file storage ondersteunen, dat op zijn beurt in blocks wordt opgeslagen).

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, ReadWriteOncePod), 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.