Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 10: Storage

Ziel: Du bindest Speicher statisch und dynamisch an, wählst Access Mode und Reclaim Policy bewusst und vergrößerst Volumes im Betrieb. · Dauer: ca. 60 min · Voraussetzung: Tag 8 (Helm)

Briefing

CKA: Storage (10 %) – StorageClasses und dynamische Bereitstellung, Volume-Typen, Access Modes, Reclaim Policies, PV und PVC.

  Pod --> PVC (Wunsch: 1Gi, RWX, Klasse nfs)
            |  bindet an
            v
          PV  <-- von Hand angelegt (statisch)
              <-- vom CSI-Treiber erzeugt (dynamisch, über StorageClass)
Access Mode Kürzel Bedeutung
ReadWriteOnce RWO ein Node schreibt
ReadOnlyMany ROX viele Nodes lesen
ReadWriteMany RWX viele Nodes schreiben
ReadWriteOncePod RWOP genau ein Pod schreibt

Drill 1: Ein lokales PV von Hand

Auf worker1 ein Verzeichnis mit Inhalt anlegen:

sudo mkdir -p /mnt/data/pv1
echo "Hallo von worker1" | sudo tee /mnt/data/pv1/index.html

Auf cp1:

k create ns tag10
k config set-context --current --namespace=tag10
cat <<'EOF' | k apply -f -
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv1
spec:
  capacity:
    storage: 1Gi
  accessModes:
  - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: manual
  local:
    path: /mnt/data/pv1
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values: ["worker1"]
EOF
k get pv pv1

Erwartet (gekürzt):

NAME   CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS
pv1    1Gi        RWO            Retain           Available           manual

Ein local-Volume braucht nodeAffinity – die Daten liegen nur auf diesem einen Node. PVs sind clusterweit, PVCs gehören in einen Namespace.

Fortschritt speichern? Kostenlos registrieren

Drill 2: PVC binden und benutzen

cat <<'EOF' | k apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data
spec:
  storageClassName: manual
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi
EOF
k get pvc data

Erwartet (gekürzt):

NAME   STATUS   VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS
data   Bound    pv1      1Gi        RWO            manual

500Mi angefragt, 1Gi bekommen: Ein PVC bindet an ein passendes PV, das mindestens so groß ist – und belegt es ganz.

cat <<'EOF' | k apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: web
spec:
  containers:
  - name: nginx
    image: nginx:1.29
    volumeMounts:
    - name: data
      mountPath: /usr/share/nginx/html
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: data
EOF
k wait --for=condition=Ready pod/web
k get pod web -o wide
k exec web -- curl -s localhost

Erwartet: web läuft auf worker1, und die Ausgabe ist Hallo von worker1. Der Scheduler hat die nodeAffinity des PV beachtet.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Reclaim Policy Retain

k delete pod web --now
k delete pvc data
k get pv pv1

Erwartet (gekürzt):

NAME   CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS     CLAIM        STORAGECLASS
pv1    1Gi        RWO            Retain           Released   tag10/data   manual

Released: Die Daten bleiben, aber das PV ist nicht wieder frei – es merkt sich den alten Claim. Nach Prüfung der Daten gibst du es wieder frei:

k patch pv pv1 -p '{"spec":{"claimRef":null}}'
k get pv pv1

Erwartet: STATUS ist wieder Available.

Fortschritt speichern? Kostenlos registrieren

Drill 4: NFS und der CSI-Treiber

Für dynamische Volumes braucht es einen Provisioner. Im Labor dient cp1 als NFS-Server. Auf cp1:

sudo apt-get install -y nfs-kernel-server
sudo mkdir -p /srv/nfs/k8s
sudo chown nobody:nogroup /srv/nfs/k8s
echo "/srv/nfs/k8s 172.16.0.0/24(rw,sync,no_subtree_check,no_root_squash)" \
  | sudo tee -a /etc/exports
sudo exportfs -ra

Auf worker1 und worker2 den NFS-Client:

sudo apt-get install -y nfs-common
showmount -e 172.16.0.126

Erwartet:

Export list for 172.16.0.126:
/srv/nfs/k8s 172.16.0.0/24

Zurück auf cp1, den CSI-Treiber per Helm:

helm repo add csi-driver-nfs \
  https://raw.githubusercontent.com/kubernetes-csi/csi-driver-nfs/master/charts
helm install csi-driver-nfs csi-driver-nfs/csi-driver-nfs -n kube-system \
  --version 4.13.6
k rollout status deployment csi-nfs-controller -n kube-system
k get csidriver nfs.csi.k8s.io

Erwartet (gekürzt):

deployment "csi-nfs-controller" successfully rolled out
NAME             ATTACHREQUIRED   PODINFOONMOUNT   ...   MODES        AGE
nfs.csi.k8s.io   false            false            ...   Persistent   45s

Fortschritt speichern? Kostenlos registrieren

Drill 5: StorageClass und dynamisches RWX-Volume

cat <<'EOF' | k apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs
provisioner: nfs.csi.k8s.io
parameters:
  server: 172.16.0.126
  share: /srv/nfs/k8s
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
mountOptions:
- nfsvers=4.1
EOF
cat <<'EOF' | k apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: shared
spec:
  storageClassName: nfs
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Gi
EOF
k get pvc shared
ls /srv/nfs/k8s

Erwartet (gekürzt):

NAME     STATUS   VOLUME                                     CAPACITY   ACCESS MODES
shared   Bound    pvc-0fe656be-e4f9-4433-a298-92f418648f57   1Gi        RWX
pvc-0fe656be-e4f9-4433-a298-92f418648f57

Kein PV von Hand: Der Treiber hat ein Unterverzeichnis auf dem NFS-Server angelegt und das PV dazu erzeugt.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Zwei Nodes, ein Volume

cat <<'EOF' | k apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: writer
spec:
  replicas: 2
  selector:
    matchLabels:
      app: writer
  template:
    metadata:
      labels:
        app: writer
    spec:
      containers:
      - name: w
        image: busybox:1.37
        command: ["sh", "-c", "while true; do hostname >> /data/log.txt; sleep 5; done"]
        volumeMounts:
        - name: shared
          mountPath: /data
      volumes:
      - name: shared
        persistentVolumeClaim:
          claimName: shared
EOF
k rollout status deployment writer
k get pods -l app=writer -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName

Erwartet:

NAME                      NODE
writer-6c79b9c54d-2m7z4   worker1
writer-6c79b9c54d-mcdg8   worker2

Nach etwa zehn Sekunden:

P=$(k get pod -l app=writer -o jsonpath='{.items[0].metadata.name}')
k exec $P -- sort -u /data/log.txt

Erwartet:

writer-6c79b9c54d-2m7z4
writer-6c79b9c54d-mcdg8

Beide Pods auf zwei Nodes schreiben in dieselbe Datei – das kann nur RWX.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Vergrößern und Löschen

k patch pvc shared -p '{"spec":{"resources":{"requests":{"storage":"2Gi"}}}}'
k get pvc shared

Erwartet: CAPACITY zeigt nach einigen Sekunden 2Gi. Das geht nur, weil die StorageClass allowVolumeExpansion: true hat. Verkleinern ist nie erlaubt.

Jetzt die Reclaim Policy Delete:

k delete deployment writer
k delete pvc shared
k get pv
ls /srv/nfs/k8s | wc -l

Erwartet: Außer pv1 kein PV mehr, und 0 – PV und Daten sind weg. Für Daten, die wichtig sind, Retain wählen.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Mache nfs zur Standard-StorageClass. Zeitziel: 30 s
  2. Lege einen PVC auto mit 100Mi RWO ohne storageClassName an. Zeitziel: 45 s
  3. Zeige alle PVs mit Reclaim Policy und Status. Zeitziel: 20 s

Lösung

A=storageclass.kubernetes.io/is-default-class
k patch storageclass nfs -p "{\"metadata\":{\"annotations\":{\"$A\":\"true\"}}}"
cat <<'EOF' | k apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: auto
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 100Mi
EOF
k get pvc auto
C=NAME:.metadata.name,RECLAIM:.spec.persistentVolumeReclaimPolicy,STATUS:.status.phase
k get pv -o custom-columns=$C

Erwartet (Ausschnitt):

storageclass.storage.k8s.io/nfs patched
NAME   STATUS   VOLUME          CAPACITY   ACCESS MODES   STORAGECLASS
auto   Bound    pvc-...         100Mi      RWO            nfs

Ohne Klasse im PVC greift die Standardklasse.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get sc

Erwartet: nfs (default) mit ALLOWVOLUMEEXPANSION true.

k get pv pv1 -o jsonpath='{.status.phase}{"\n"}'

Erwartet: Available

k get pvc auto -o jsonpath='{.status.phase}{"\n"}'

Erwartet: Bound

Challenge

Ein Kollege legt einen PVC wrong mit der Klasse manual, 500Mi und ReadWriteMany an. Er bleibt Pending. Finde den Grund und erkläre die Meldung.

Hinweis: Vergleiche den Wunsch des PVC mit dem, was pv1 anbietet.

Lösung

cat <<'EOF' | k apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wrong
spec:
  storageClassName: manual
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 500Mi
EOF
k get pvc wrong
k describe pvc wrong | tail -1

Erwartet (gekürzt):

NAME    STATUS    VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS
wrong   Pending                                      manual
  Warning  ProvisioningFailed  1s (x2 over 4s)  persistentvolume-controller
storageclass.storage.k8s.io "manual" not found

pv1 bietet nur RWO, also passt kein vorhandenes PV. Dann versucht Kubernetes, dynamisch eines zu erzeugen – über eine StorageClass manual, die es gar nicht gibt. Die Meldung klingt nach falscher Klasse, die Ursache ist der Access Mode.

Aufräumen (nfs bleibt Standardklasse für die nächsten Tage):

k config set-context --current --namespace=default
k delete ns tag10
k delete pv pv1

Auf worker1:

sudo rm -rf /mnt/data/pv1

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • PVC Pending? Klasse, Access Mode und Größe mit den PVs vergleichen – alle drei müssen passen.
  • volumeBindingMode: WaitForFirstConsumer lässt PVCs bewusst Pending, bis ein Pod sie nutzt. Das ist kein Fehler.
  • Ein PV im Zustand Released wird erst nach Entfernen von claimRef wieder Available.

Enterprise-Notiz

  • NFS ohne Hochverfügbarkeit ist ein Single Point of Failure. Produktion nutzt Ceph (Rook), Longhorn, Portworx oder den Speicher des Cloud-Anbieters.
  • Für Datenbanken RWO-Blockspeicher mit Snapshots (VolumeSnapshot) statt NFS.
  • Reclaim Policy Retain für alles, was nicht reproduzierbar ist; Backups mit Velero.