Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Snapshots und Backup mit Velero

Ziel: Du weißt, warum LINSTOR 1.34 mit klassischem LVM keine Snapshots kann, sicherst die Datenbank stattdessen mit Velero Datei für Datei in einen S3-Speicher am dritten Standort und stellst einen gelöschten Namespace vollständig wieder her. · Dauer: ca. 75 min · Voraussetzung: Tag 12

Briefing

  • DRBD ist kein Backup: Es repliziert jeden Schreibvorgang sofort, auch ein DROP TABLE.
  • CSI-Snapshots brauchen einen Snapshot-Controller und einen Storage-Pool, der Snapshots kann. Thick LVM kann das in LINSTOR erst ab 1.35 – das Update kommt an Tag 15.
  • Bis dahin sichert Velero mit seinem Node-Agent (Kopia) den Inhalt der Volumes auf Dateiebene, ohne Snapshot.
  • Ziel ist SeaweedFS auf k0s-ctrl: außerhalb des Clusters, am „dritten Standort“.
 pg-0 (k0s-w3)  --> node-agent liest /var/lib/k0s/kubelet/pods/...
                      |  Kopia: verschlüsselt, dedupliziert
                      v
 k0s-ctrl: SeaweedFS S3 :8333, Bucket velero

Drill 1: Der Snapshot-Controller

k0s bringt weder die Snapshot-CRDs noch den Controller mit. Beides kommt als Chart aus dem Piraeus-Repository (Tag 7):

# auf k0s-ctrl
mkdir -p ~/k0s-lab/tag13 && cd ~/k0s-lab/tag13
helm install snapshot-controller piraeus-charts/snapshot-controller \
  --version 5.4.0 -n kube-system
kubectl -n kube-system rollout status deploy/snapshot-controller
kubectl get crd | grep snapshot.storage | cut -d' ' -f1

Erwartet (gekürzt):

STATUS: deployed
...
deployment "snapshot-controller" successfully rolled out
volumesnapshotclasses.snapshot.storage.k8s.io
volumesnapshotcontents.snapshot.storage.k8s.io
volumesnapshots.snapshot.storage.k8s.io

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Snapshot scheitert

# auf k0s-ctrl
cat > snapshot.yaml <<'EOF'
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata: {name: linstor-snapshots}
driver: linstor.csi.linbit.com
deletionPolicy: Delete
---
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata: {name: pg-vor-update, namespace: demo}
spec:
  volumeSnapshotClassName: linstor-snapshots
  source: {persistentVolumeClaimName: data-pg-0}
EOF
kubectl apply -f snapshot.yaml
sleep 15
kubectl -n demo get volumesnapshot pg-vor-update -o jsonpath='{.status.error.message}' \
  | fold -w 80

Erwartet:

Failed to check and update snapshot content: failed to take snapshot of the volu
me pvc-395c4ec0-6761-460a-9251-7056ad297f04: "rpc error: code = Internal desc =
failed to create snapshot: failed to create snapshots: Message: 'Storage driver
'LVM' does not support snapshots.'; Details: 'Used for storage pool 'pool_data'
on 'k0s-w2'.\nResource: pvc-395c4ec0-6761-460a-9251-7056ad297f04, Snapshot: snap
shot-0b87e73a-5e46-4074-8764-72cf5f6544b7'; Reports: '[6AFFA9FE-00000-000014]'"

Das stand schon in der Pool-Liste:

# auf k0s-ctrl
linstor --no-utf8 --no-color storage-pool list -s pool_data | cut -d'|' -f2,3,8 \
  | cut -c1-40

Erwartet (gekürzt):

 StoragePool | Node   | CanSnapshots
========================================
 pool_data   | k0s-w1 | False
 pool_data   | k0s-w2 | False
 pool_data   | k0s-w3 | False

Klassisches (thick) LVM bekam Snapshots in LINSTOR erst mit 1.35.0. Bis zum Update an Tag 15 heißt das: kein schneller Rückweg vor einem riskanten Eingriff, keine LINSTOR-Backups nach S3 (die setzen Snapshots voraus) und keine CSI-Snapshots für Velero. Den gescheiterten Versuch räumst du weg, die Klasse bleibt für Tag 15:

# auf k0s-ctrl
kubectl -n demo delete volumesnapshot pg-vor-update
kubectl get volumesnapshotcontent

Erwartet:

volumesnapshot.snapshot.storage.k8s.io "pg-vor-update" deleted from demo namespace
No resources found

Fortschritt speichern? Kostenlos registrieren

Drill 3: SeaweedFS am dritten Standort

Ein Backup gehört an einen anderen Ort als die Daten. Im Labor ist das k0s-ctrl. Dort läuft SeaweedFS als einzelnes Programm außerhalb von Kubernetes:

# auf k0s-ctrl
ARCH=$(dpkg --print-architecture)
W=4.54
B=https://github.com/seaweedfs/seaweedfs/releases/download/$W
curl -sSfLo weed.tgz $B/linux_$ARCH.tar.gz
curl -sSfLo weed.tgz.md5 $B/linux_$ARCH.tar.gz.md5
echo "$(cat weed.tgz.md5)  weed.tgz" | md5sum -c
tar xzf weed.tgz weed
sudo install -m 755 weed /usr/local/bin/weed
weed version 2>/dev/null | grep ^version

Erwartet:

weed.tgz: OK
version 30GB 4.54 5ef99c1d8dbbeb4a035c055e3b464620506aefac linux amd64

Zugangsdaten und Dienst:

# auf k0s-ctrl
sudo install -d -m 700 /etc/seaweedfs /var/lib/seaweedfs
sudo tee /etc/seaweedfs/s3.json >/dev/null <<'EOF'
{"identities": [{"name": "velero",
  "credentials": [{"accessKey": "lab-s3-key", "secretKey": "lab-s3-secret-123"}],
  "actions": ["Admin", "Read", "Write", "List", "Tagging"]}]}
EOF
sudo chmod 600 /etc/seaweedfs/s3.json
sudo tee /etc/systemd/system/seaweedfs.service >/dev/null <<'EOF'
[Unit]
Description=SeaweedFS mit S3 für Velero (dritter Standort)
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/usr/local/bin/weed server -dir=/var/lib/seaweedfs -ip=172.16.0.176 \
  -s3 -s3.port=8333 -s3.config=/etc/seaweedfs/s3.json \
  -master.volumeSizeLimitMB=1024
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now seaweedfs

weed server startet Master, Volume-Server, Filer und mit -s3 die S3-Schnittstelle in einem Prozess. volumeSizeLimitMB=1024 hält die Volume-Dateien klein – die Vorgabe von 30 GB passt nicht auf die Systemplatte. Nach 15 Sekunden den Bucket anlegen:

# auf k0s-ctrl
echo "s3.bucket.create -name velero" | weed shell -master=172.16.0.176:9333 | tail -1
echo "s3.bucket.list" | weed shell -master=172.16.0.176:9333 | tail -1
curl -s -o /dev/null -w '%{http_code}\n' http://172.16.0.176:8333/velero

Erwartet:

created bucket velero
  velero    size:0  logical:0   chunk:0
403

403 ohne Zugangsdaten: Der Bucket ist nicht öffentlich.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Velero installieren

Erst die Kommandozeile, architekturneutral und gegen die Prüfsumme. Das Projekt liegt inzwischen unter github.com/velero-io:

# auf k0s-ctrl
ARCH=$(dpkg --print-architecture)
V=v1.18.4
B=https://github.com/velero-io/velero/releases/download/$V
curl -sSfLO $B/velero-$V-linux-$ARCH.tar.gz
curl -sSfLO $B/CHECKSUM
grep "velero-$V-linux-$ARCH.tar.gz" CHECKSUM | sha256sum -c
tar xzf velero-$V-linux-$ARCH.tar.gz
sudo install -m 755 velero-$V-linux-$ARCH/velero /usr/local/bin/velero
velero version --client-only | grep Version

Erwartet:

velero-v1.18.4-linux-amd64.tar.gz: OK
    Version: v1.18.4

Zugangsdaten im Format einer AWS-Datei und die Helm-Werte:

# auf k0s-ctrl
cat > velero-credentials <<'EOF'
[default]
aws_access_key_id = lab-s3-key
aws_secret_access_key = lab-s3-secret-123
EOF
chmod 600 velero-credentials
cat > velero-werte.yaml <<'EOF'
image:
  tag: v1.18.4
initContainers:
  - name: velero-plugin-for-aws
    image: velero/velero-plugin-for-aws:v1.14.4
    volumeMounts: [{mountPath: /target, name: plugins}]
configuration:
  backupStorageLocation:
    - name: default
      provider: aws
      bucket: velero
      config:
        region: us-east-1
        s3ForcePathStyle: "true"
        s3Url: http://172.16.0.176:8333
  # LINSTOR 1.34 mit thick LVM kann keine Snapshots: Volumes per Dateisicherung
  defaultVolumesToFsBackup: true
snapshotsEnabled: false
deployNodeAgent: true
nodeAgent:
  # k0s: kubelet liegt unter /var/lib/k0s/kubelet
  podVolumePath: /var/lib/k0s/kubelet/pods
  pluginVolumePath: /var/lib/k0s/kubelet/plugins
credentials:
  existingSecret: velero-s3
EOF

Das Chart 12.2.5 bringt Velero 1.18.2 mit, image.tag hebt es auf 1.18.4. defaultVolumesToFsBackup sichert jedes Volume per Kopia, ohne dass du Pods markieren musst. Und wieder der kubelet-Pfad von k0s (Tag 7): Ohne podVolumePath sucht der Node-Agent unter /var/lib/kubelet/pods und findet nichts.

# auf k0s-ctrl
helm repo add vmware-tanzu https://vmware-tanzu.github.io/helm-charts
kubectl create namespace velero
kubectl -n velero create secret generic velero-s3 --from-file=cloud=velero-credentials
helm install velero vmware-tanzu/velero --version 12.2.5 -n velero -f velero-werte.yaml
kubectl -n velero rollout status deploy/velero --timeout=180s
kubectl -n velero get pod -o wide | cut -c1-70
velero -n velero backup-location get | cut -c1-70

Erwartet (gekürzt):

deployment "velero" successfully rolled out
NAME                      READY   STATUS    RESTARTS   AGE   IP            NODE
node-agent-9vd62          1/1     Running   0          53s   10.244.2.14   k0s-w1
node-agent-d8xx7          1/1     Running   0          53s   10.244.1.20   k0s-w2
node-agent-gt27s          1/1     Running   0          53s   10.244.0.18   k0s-w3
velero-7d556887bd-j62r9   1/1     Running   0          53s   10.244.2.15   k0s-w1
NAME      PROVIDER   BUCKET/PREFIX   PHASE       LAST VALIDATED
default   aws        velero          Available   2026-11-20 02:35:43 +0000 UTC

Available heißt: Velero erreicht SeaweedFS und darf in den Bucket schreiben.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Sichern

Erst der Stand, den du nach dem Restore wiedersehen willst:

# auf k0s-ctrl
kubectl -n demo exec pg-0 -- psql -U postgres -tAc "select text from notizen"
velero -n velero backup create demo-1 --include-namespaces demo --wait
velero -n velero backup describe demo-1 --details --colorized=false \
  | grep -A3 'kopia'

Erwartet (gekürzt):

geschrieben auf k0s-w1
...............
Backup completed with status: Completed. You may check for more information using the
...
  Pod Volume Backups - kopia:
    Completed:
      demo/pg-0: data (size: 41233870, incremental size: 41233870)

Die erste Sicherung überträgt alles, 41 MB in 15 Sekunden. Weitere übertragen nur die Änderungen (incremental size).

Achtung: Velero kopiert die Dateien einer laufenden Datenbank nacheinander, nicht in einem Augenblick. Das ist schwächer als der Zustand nach einem Stromausfall (nicht absturzkonsistent): Die Kopie kann Stände aus verschiedenen Sekunden mischen, und PostgreSQL garantiert dafür kein sauberes Nachspielen des WAL (Handbuch: „File System Level Backup“). Im Labor ging es gut. Für echte Daten gehört ein Pre-Hook an den Pod, der vorher einen pg_dump ins Volume schreibt (Annotation pre.hook.backup.velero.io/command), oder ab Tag 15 ein CSI-Snapshot als eingefrorener Stand.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Der Ernstfall

Jemand löscht den Namespace:

Achtung: Das löscht pg samt Volume unwiderruflich. Nur weiter, wenn demo-1 in velero -n velero backup get als Completed steht.

# auf k0s-ctrl
kubectl delete namespace demo
linstor --no-utf8 --no-color resource-definition list | cut -c1-56

Erwartet:

namespace "demo" deleted
+------------------------------------------------------+
| ResourceName | ResourceGroup  | Layers       | State |
|======================================================|
| linstor_db   | linstor-db-grp | DRBD,STORAGE | ok    |
+------------------------------------------------------+

Mit dem Namespace sind PVC, PV und das LINSTOR-Volume weg (reclaimPolicy: Delete). Beide DRBD-Kopien – gelöscht in derselben Sekunde. Jetzt der Restore:

# auf k0s-ctrl
velero -n velero restore create demo-1-restore --from-backup demo-1 --wait
kubectl -n demo rollout status sts/pg --timeout=120s
kubectl -n demo exec pg-0 -c postgres -- psql -U postgres \
  -c "select text from notizen" -c "select max(zeit) from puls"

Erwartet (gekürzt):

Restore completed with status: Completed. You may check for more information using the
...
          text
------------------------
 geschrieben auf k0s-w1
              max
-------------------------------
 2026-11-20 02:36:46.692144+00

Die erste Zeile aus Tag 8 und alle Einträge des Messgeräts bis zum Moment der Sicherung. Der Restore dauerte 27 Sekunden. Velero hat für das PVC ein neues Volume angelegt und vor dem Start von PostgreSQL gefüllt – dafür sorgt der Init-Container restore-wait:

# auf k0s-ctrl
R=$(kubectl -n demo get pvc data-pg-0 -o jsonpath='{.spec.volumeName}')
echo $R
linstor --no-utf8 --no-color resource list -r $R | cut -c44-110

Erwartet (gekürzt):

pvc-11dccaf7-...
| Node     | Layers                  | Usage  | Conns |              State |
...
| k0s-ctrl | DRBD,STORAGE            | Unused | Ok    |           Diskless |
| k0s-w2   | DRBD,WRITECACHE,STORAGE | Unused | Ok    | SyncTarget(68.48%) |
| k0s-w3   | DRBD,WRITECACHE,STORAGE | InUse  | Ok    |           UpToDate |

Neuer Name, wieder zwei Zonen mit Writecache, die zweite Kopie gleicht noch ab. Ab hier heißt das Volume der Datenbank pvc-11dccaf7-....

Fortschritt speichern? Kostenlos registrieren

Drill 7: Das Messgerät hängt

# auf k0s-ctrl
kubectl -n demo logs deploy/pg-client --tail=2
kubectl -n demo exec deploy/pg-client -- ps -o pid,args | cut -c1-80

Erwartet (gekürzt):

    PID COMMAND
      1 bash -c until psql -h pg -U postgres -qc "create table if not exists pul
      7 /usr/lib/postgresql/18/bin/psql -h pg -U postgres -qc create table if no
      8 ps -o pid,args

Kein einziges Log: Der Client startete vor PostgreSQL, und sein erstes psql in der until-Schleife hat kein Timeout – es hängt. Am Backup liegt es nicht, sondern am Client. Neustart:

# auf k0s-ctrl
kubectl -n demo rollout restart deploy/pg-client
kubectl -n demo rollout status deploy/pg-client
sleep 40
kubectl -n demo logs deploy/pg-client --tail=2

Erwartet:

deployment.apps/pg-client restarted
deployment "pg-client" successfully rolled out
02:40:06 ok
02:40:07 ok

Ein Restore ist erst fertig, wenn die Anwendung wieder arbeitet – nicht, wenn Velero Completed meldet. Prüfe nach jedem Restore auch die Clients.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig alle Backups mit Status. Zeitziel: 10 s
  2. Zeig, wie viel Platz der Bucket velero belegt. Zeitziel: 20 s
  3. Lege einen täglichen Zeitplan um 2 Uhr für demo mit 7 Tagen Aufbewahrung an und lösche ihn wieder. Zeitziel: 60 s

Lösung

# auf k0s-ctrl
velero -n velero backup get | cut -c1-60
echo "s3.bucket.list" | weed shell -master=172.16.0.176:9333 | tail -1
velero -n velero schedule create demo-taeglich --schedule="0 2 * * *" \
  --include-namespaces demo --ttl 168h
velero -n velero schedule get | cut -c1-80
velero -n velero schedule delete demo-taeglich --confirm

Erwartet (gekürzt):

NAME     STATUS      ERRORS   WARNINGS   CREATED
demo-1   Completed   0        0          2026-11-20 02:36:38
  velero    size:26273600   logical:26271966    chunk:37
Schedule "demo-taeglich" created successfully.
NAME            STATUS    CREATED                         SCHEDULE    BACKUP TTL
demo-taeglich   Enabled   2026-11-20 02:42:01 +0000 UTC   0 2 * * *   168h0m0s
Schedule deleted: demo-taeglich

26 MB im Bucket für 41 MB Daten: Kopia speichert gleiche Blöcke nur einmal (Deduplizierung), leere Bereiche der Datenbankdateien kosten fast nichts.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf k0s-ctrl
velero -n velero backup-location get | cut -c1-50

Erwartet: default … Available.

# auf k0s-ctrl
kubectl -n demo logs deploy/pg-client --tail=3

Erwartet: nur ok-Zeilen.

# auf k0s-ctrl
linstor --no-utf8 --no-color resource list --faulty

Erwartet: eine leere Tabelle (nach Ende des Resyncs).

# auf k0s-ctrl
kubectl get volumesnapshotclass

Erwartet: linstor-snapshots – die Klasse wartet auf Tag 15.

Challenge

Ein Backup, das nie wiederhergestellt wurde, ist eine Hoffnung. Stelle demo-1 in einen neuen Namespace demo-test wieder her, ohne demo anzufassen, und lies die Notiz aus der wiederhergestellten Datenbank.

Hinweis: velero restore create --help | grep mapping.

Lösung

# auf k0s-ctrl
velero -n velero restore create probe-1 --from-backup demo-1 \
  --namespace-mappings demo:demo-test --wait
kubectl -n demo-test rollout status sts/pg --timeout=120s
sleep 5
kubectl -n demo-test exec pg-0 -c postgres -- psql -U postgres -tAc \
  "select text from notizen"
kubectl -n demo-test logs pg-0 -c postgres | grep -o 'starting: end-of-recovery'
kubectl get pvc -A | cut -c1-80

Erwartet (gekürzt):

Restore completed with status: Completed. ...
geschrieben auf k0s-w1
starting: end-of-recovery
NAMESPACE   NAME        STATUS   VOLUME                                     CAPACITY
demo-test   data-pg-0   Bound    pvc-49f7638a-dc7f-4bb3-9d65-5556d7112c64   2Gi
demo        data-pg-0   Bound    pvc-11dccaf7-f197-4448-b834-1b5db5b0b525   2Gi

Ein zweites, unabhängiges Volume. end-of-recovery zeigt: PostgreSQL hat das WAL nachgespielt wie nach einem Absturz – diesmal mit Erfolg, garantiert ist das bei einer Dateikopie im laufenden Betrieb nicht (Drill 5). Ohne sleep meldet psql manchmal noch No such file or directory, weil der Server gerade startet.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf k0s-ctrl
kubectl delete namespace demo-test

Velero, SeaweedFS, das Backup demo-1 und die VolumeSnapshotClass bleiben.

Interview-Notiz

  • Ist DRBD ein Backup? Nein. Es repliziert auch Fehler und Löschungen sofort. Ein Backup liegt an einem anderen Ort und ist älter als der Fehler.
  • Wie sichert Velero ohne Snapshots? Der Node-Agent liest die gemounteten Volumes auf dem Node und schreibt sie mit Kopia verschlüsselt und dedupliziert nach S3.
  • Wann ist ein Restore fertig? Wenn die Anwendung wieder arbeitet und die Daten geprüft sind – Completed ist nur die halbe Antwort.

Enterprise-Notiz

  • Backup-Ziel mit Objekt-Sperre (S3 Object Lock) oder zumindest getrennten Zugangsdaten – ein Angreifer mit Cluster-Admin darf die Backups nicht löschen können.
  • SeaweedFS als Einzelprozess ist ein Labor-Ziel; in Produktion ein redundanter S3-Speicher an einem anderen Standort, Durchsatz einmal real messen.
  • Datenbanken zusätzlich logisch sichern (pg_dump, WAL-Archivierung mit Point-in-Time- Recovery) – Datei-Backups einer laufenden Datenbank sind nicht einmal sicher absturzkonsistent.
  • Restore-Proben regelmäßig in einen eigenen Namespace, mit Prüfabfrage und Zeitmessung.
  • Nach dem Update auf LINSTOR 1.35 (Tag 15) kann Velero CSI-Snapshots nutzen – mit thick LVM belegen sie aber sofort die volle Volume-Größe.