Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Hooks und Chart-Tests

Ziel: Die Datenbank-Migration als Hook-Job ausführen, die Fallen von Reihenfolge, Gewicht und Aufräumen live erleben und den Release mit helm test prüfen. · Dauer: ca. 60 min · Voraussetzung: Tag 10

Briefing

  • Ein Hook ist ein normales Objekt mit der Annotation helm.sh/hook. Helm legt es zu einem bestimmten Zeitpunkt an und wartet, bis es fertig ist.
  • Zeitpunkte: pre-/post-install, -upgrade, -rollback, -delete und test. hook-weight ordnet Hooks desselben Zeitpunkts – als Zahl aufsteigend, in der Annotation aber in Anführungszeichen.
  • Hooks gehören nicht zum Release: Sie stehen nicht im Manifest, und helm uninstall lässt sie liegen. Aufräumen regelt hook-delete-policy.
  • Ein Chart-Test ist ein Pod mit helm.sh/hook: test. Exit-Code 0 heißt bestanden.
 helm upgrade:  pre-upgrade-Hooks ──> Manifest anwenden ──> post-upgrade-Hooks
                (Gewicht -10, 0, 5)    (Deployment, ...)     scheitert einer: failed
 helm test:     test-Hooks (Pods) ──> Exit-Code 0?

Drill 1: Migration als Hook-Job

Der Init-Container aus Tag 9 läuft bei jedem Pod-Start, also zweimal pro Rollout und bei jedem Neustart. Ein Job läuft genau einmal pro Upgrade – und hält das Upgrade an, wenn er scheitert.

# auf prod
mkdir -p ~/helm/tag11 && cd ~/helm/charts
cat > notes/templates/migrate-job.yaml <<'EOF'
{{/* notes/templates/migrate-job.yaml – Stand Tag 11 */}}
{{- $dbEnv := include "notes.dbEnv" . }}
{{- if and $dbEnv .Values.migration.enabled }}
apiVersion: batch/v1
kind: Job
metadata:
  name: {{ include "notes.fullname" . }}-migrate
  labels:
    {{- include "notes.labels" . | nindent 4 }}
  annotations:
    "helm.sh/hook": {{ .Values.migration.hook }}
    "helm.sh/hook-weight": "0"
    "helm.sh/hook-delete-policy": before-hook-creation
spec:
  backoffLimit: {{ .Values.migration.backoffLimit }}
  template:
    metadata:
      labels:
        app.kubernetes.io/name: {{ include "notes.name" . }}-migrate
        app.kubernetes.io/instance: {{ .Release.Name }}
    spec:
      restartPolicy: Never
      securityContext:
        {{- include "plattform.podSecurityContext" . | nindent 8 }}
      containers:
        - name: migrate
          image: {{ include "notes.image" . | quote }}
          args: ["migrate"]
          securityContext:
            {{- include "plattform.containerSecurityContext" . | nindent 12 }}
          env:
            {{- $dbEnv | nindent 12 }}
{{- end }}
EOF
cat >> notes/values.yaml <<'EOF'

migration:
  # -- Datenbank-Migration als Hook-Job
  enabled: true
  # -- Zeitpunkte des Hooks
  hook: pre-install,pre-upgrade
  # -- Versuche, bevor der Hook (und damit install/upgrade) scheitert
  backoffLimit: 2
EOF
sed -i 's/Stand Tag 09/Stand Tag 11/' notes/values.yaml
jq '.title = "notes – Stand Tag 11" | .properties.migration = {"type": "object",
  "properties": {"enabled": {"type": "boolean"}, "hook": {"type": "string"},
    "backoffLimit": {"type": "integer", "minimum": 0}}}' notes/values.schema.json \
  > /tmp/s.json && mv /tmp/s.json notes/values.schema.json
sed -i 's/^version: .*/version: 0.10.0/; s/Tag 10/Tag 11/' notes/Chart.yaml

Die Pods des Jobs bekommen bewusst nicht notes.selectorLabels: Sonst passten sie auf den Selektor des Service, und Traefik schickte Anfragen an einen Pod ohne Webserver. Der Init-Container fliegt aus dem Deployment:

# auf prod
cat > notes/templates/deployment.yaml <<'EOF'
{{/* notes/templates/deployment.yaml – Stand Tag 11 */}}
{{- $dbEnv := include "notes.dbEnv" . }}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "notes.fullname" . }}
  labels:
    {{- include "notes.labels" . | nindent 4 }}
spec:
  replicas: {{ hasKey .Values "replicaCount" | ternary .Values.replicaCount 2 }}
  selector:
    matchLabels:
      {{- include "notes.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "notes.labels" . | nindent 8 }}
      annotations:
        checksum/config: {{ include (print $.Template.BasePath "/config.yaml") .
          | sha256sum }}
    spec:
      terminationGracePeriodSeconds: {{ durationSeconds .Values.shutdownTimeout }}
      securityContext:
        {{- include "plattform.podSecurityContext" . | nindent 8 }}
      containers:
        - name: notes-api
          image: {{ include "notes.image" . | quote }}
          ports: [{name: http, containerPort: 8080}]
          securityContext:
            {{- include "plattform.containerSecurityContext" . | nindent 12 }}
          env:
            - name: NOTES_API_KEY
              valueFrom:
                secretKeyRef:
                  name: {{ required "apiKey.existingSecret fehlt"
                    .Values.apiKey.existingSecret }}
                  key: {{ .Values.apiKey.key }}
            {{- with $dbEnv }}
            {{- . | nindent 12 }}
            {{- end }}
          envFrom:
            - configMapRef:
                name: {{ include "notes.fullname" . }}-config
          readinessProbe:
            httpGet: {path: /healthz, port: http}
          resources:
            {{- toYaml .Values.resources | nindent 12 }}
      {{- with .Values.nodeSelector }}
      nodeSelector:
        {{- toYaml . | nindent 8 }}
      {{- end }}
EOF
helm lint notes -f values/prod.yaml | tail -1
helm upgrade notes ./notes -n notes -f values/prod.yaml --wait | grep REVISION
kubectl -n notes get jobs
helm get hooks notes -n notes | grep -E '^kind|hook'
helm get manifest notes -n notes | grep -c migrate
kubectl -n notes logs job/notes-migrate

Erwartet:

1 chart(s) linted, 0 chart(s) failed
REVISION: 22
NAME            STATUS     COMPLETIONS   DURATION   AGE
notes-migrate   Complete   1/1           5s         11s
kind: Job
    "helm.sh/hook": pre-install,pre-upgrade
    "helm.sh/hook-weight": "0"
    "helm.sh/hook-delete-policy": before-hook-creation
0
time=2026-11-20T01:54:27.594Z level=INFO msg="migration complete" table=notes

helm get hooks zeigt den Job, helm get manifest kennt ihn nicht. Erst nach dem erfolgreichen Job hat Helm das neue Deployment angewendet.

Fortschritt speichern? Kostenlos registrieren

Drill 2: pre-install und die leere Datenbank

Beim Upgrade gibt es die Datenbank schon. Bei der Erstinstallation nicht:

# auf prod
kubectl create namespace tag11
kubectl -n tag11 create secret generic notes-db --from-literal=password=lab-db-123
kubectl -n tag11 create secret generic notes-api-key --from-literal=api-key=lab-key-123
helm install t11 ./notes -n tag11 --set apiKey.existingSecret=notes-api-key \
  --set global.dbSecret=notes-db --set postgres.enabled=true --set replicaCount=1
helm list -n tag11
kubectl -n tag11 get all --no-headers
kubectl -n tag11 logs job/t11-notes-migrate 2>&1 | tail -1

Erwartet (gekürzt):

Error: INSTALLATION FAILED: failed pre-install: resource Job/tag11/t11-notes-migrate
not ready. status: Failed, message: Job Failed. failed: 3/1
NAME  NAMESPACE  REVISION  UPDATED   STATUS  CHART         APP VERSION
t11   tag11      1         2026-...  failed  notes-0.10.0  0.7.1
pod/t11-notes-migrate-5bzx8   0/1   Error   0     5s
pod/t11-notes-migrate-7hs5z   0/1   Error   0     38s
pod/t11-notes-migrate-v2vtf   0/1   Error   0     26s
job.batch/t11-notes-migrate   Failed   0/1   38s   38s
time=... level=ERROR msg="database unreachable" source=env err="failed to connect to
`user=notes database=notes`: hostname resolving error: lookup t11-postgres on
10.43.0.10:53: no such host"

pre-install läuft vor allem anderen – auch vor dem StatefulSet des Subcharts. Die Migration wartet auf eine Datenbank, die erst nach ihr entstehen würde. Nach drei Versuchen (backoffLimit: 2) gibt der Job auf, der Release ist failed.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Hooks bleiben liegen, post-install hilft

# auf prod
helm uninstall t11 -n tag11
kubectl -n tag11 get jobs
sed -i 's/^  hook: pre-install,pre-upgrade/  hook: post-install,pre-upgrade/' \
  notes/values.yaml
sed -i 's/^  backoffLimit: 2/  backoffLimit: 5/' notes/values.yaml
time helm install t11 ./notes -n tag11 --set apiKey.existingSecret=notes-api-key \
  --set global.dbSecret=notes-db --set postgres.enabled=true --set replicaCount=1 \
  | grep STATUS
kubectl -n tag11 get pods

Erwartet (gekürzt):

release "t11" uninstalled
NAME                STATUS   COMPLETIONS   DURATION   AGE
t11-notes-migrate   Failed   0/1           48s        48s
STATUS: deployed

real    0m39.011s
NAME                         READY   STATUS      RESTARTS      AGE
t11-notes-6fc946967c-8sfwx   1/1     Running     2 (28s ago)   38s
t11-notes-migrate-gm8dl      0/1     Completed   0             4s
t11-notes-migrate-rgdhx      0/1     Error       0             25s
t11-notes-migrate-z68nb      0/1     Error       0             37s
t11-postgres-0               1/1     Running     0             38s

Der gescheiterte Job hat helm uninstall überlebt – Hooks gehören nicht zum Release. Mit post-install legt Helm erst alle Objekte an, dann startet die Migration. Sie braucht trotzdem drei Anläufe, bis Postgres antwortet; darum mehr Versuche. Das gängige Muster lautet also post-install,pre-upgrade. Der Preis: Bei der Erstinstallation laufen die API-Pods kurz ohne Tabelle (hier zwei Neustarts, weil die DB noch fehlte).

# auf prod
helm upgrade notes ./notes -n notes -f values/prod.yaml --wait | grep REVISION
helm get hooks notes -n notes | grep '"helm.sh/hook"'

Erwartet:

REVISION: 23
    "helm.sh/hook": post-install,pre-upgrade

Fortschritt speichern? Kostenlos registrieren

Drill 4: Ein Secret, das es noch nicht gibt

Ein kleines Chart, dessen pre-install-Job ein Secret aus demselben Chart liest:

# auf prod
cd ~/helm/tag11 && mkdir -p hookdemo/templates
printf 'apiVersion: v2\nname: hookdemo\nversion: 0.1.0\n' > hookdemo/Chart.yaml
cat > hookdemo/templates/secret.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: {{ .Release.Name }}-token
stringData:
  token: lab-token-123
EOF
cat > hookdemo/templates/job.yaml <<'EOF'
apiVersion: batch/v1
kind: Job
metadata:
  name: {{ .Release.Name }}-vorher
  annotations:
    "helm.sh/hook": pre-install
spec:
  backoffLimit: 0
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: zeige
          image: curlimages/curl:8.23.0
          command: ["sh", "-c", "echo token=$TOKEN"]
          env:
            - name: TOKEN
              valueFrom:
                secretKeyRef: {name: "{{ .Release.Name }}-token", key: token}
EOF
helm install h1 ./hookdemo -n tag11 --timeout 30s
kubectl -n tag11 get pods -l job-name=h1-vorher

Erwartet:

Error: INSTALLATION FAILED: failed pre-install: resource Job/tag11/h1-vorher not ready.
status: InProgress, message: Job in progress
context deadline exceeded
NAME              READY   STATUS                       RESTARTS   AGE
h1-vorher-qfhrg   0/1     CreateContainerConfigError   0          31s

Normale Objekte legt Helm erst nach den pre-install-Hooks an – das Secret fehlt. Die Lösung: das Secret selbst zum Hook machen, mit niedrigerem Gewicht.

# auf prod
helm uninstall h1 -n tag11
cat > hookdemo/templates/secret.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: {{ .Release.Name }}-token
  annotations:
    "helm.sh/hook": pre-install
    "helm.sh/hook-weight": "-10"
    "helm.sh/hook-delete-policy": before-hook-creation
stringData:
  token: lab-token-123
EOF
P='    "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded'
sed -i "/\"helm.sh\/hook\": pre-install$/a\\$P" hookdemo/templates/job.yaml
helm install h1 ./hookdemo -n tag11 --timeout 60s | grep STATUS
kubectl -n tag11 get jobs,secrets -o name | grep h1
helm get manifest h1 -n tag11 | wc -l
helm uninstall h1 -n tag11
kubectl -n tag11 get secret h1-token

Erwartet:

release "h1" uninstalled
STATUS: deployed
secret/h1-token
secret/sh.helm.release.v1.h1.v1
1
release "h1" uninstalled
NAME       TYPE     DATA   AGE
h1-token   Opaque   1      7s

Das Secret entsteht zuerst (Gewicht -10), dann der Job (Gewicht 0). Der Job ist nach Erfolg weg (hook-succeeded), das Secret bleibt – auch nach helm uninstall, denn als Hook gehört es nicht mehr zum Release. Das Manifest ist leer.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Die drei Delete-Policies

Policy Hook-Objekt wird gelöscht Wofür
before-hook-creation vor dem nächsten Lauf (Standard) Logs bleiben bis dahin
hook-succeeded direkt nach Erfolg Aufräumen, Logs weg
hook-failed direkt nach Fehlschlag selten sinnvoll
# auf prod
kubectl -n tag11 delete secret h1-token
mkdir -p hookfail/templates
printf 'apiVersion: v2\nname: hookfail\nversion: 0.1.0\n' > hookfail/Chart.yaml
cat > hookfail/templates/job.yaml <<'EOF'
apiVersion: batch/v1
kind: Job
metadata:
  name: {{ .Release.Name }}-kaputt
  annotations:
    "helm.sh/hook": post-install
    "helm.sh/hook-delete-policy": hook-failed
spec:
  backoffLimit: 0
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: kaputt
          image: curlimages/curl:8.23.0
          command: ["sh", "-c", "echo scheitert; exit 1"]
EOF
helm install hf ./hookfail -n tag11 2>&1 | tail -1
kubectl -n tag11 get jobs
helm list -n tag11 --failed
helm uninstall hf -n tag11

Erwartet (gekürzt):

Error: INSTALLATION FAILED: failed post-install: resource Job/tag11/hf-kaputt not ready.
status: Failed, message: Job Failed. failed: 1/1
NAME                STATUS   COMPLETIONS   DURATION   AGE
t11-notes-migrate   Complete   1/1           37s        117s
NAME  NAMESPACE  REVISION  UPDATED   STATUS  CHART           APP VERSION
hf    tag11      1         2026-...  failed  hookfail-0.1.0
release "hf" uninstalled

hf-kaputt ist weg, die Fehlerursache auch. Ein gescheiterter post-install-Hook macht den Release failed, obwohl alle normalen Objekte schon angelegt sind.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Scheiternde Migration stoppt das Upgrade

# auf prod
cd ~/helm/charts
B='--set apiKey.existingSecret=notes-api-key --set global.dbSecret=notes-db'
B="$B --set postgres.enabled=true --set replicaCount=1"
kubectl -n tag11 get deploy t11-notes -o jsonpath='{.metadata.generation}{"\n"}'
helm upgrade t11 ./notes -n tag11 $B --set database.host=gibtsnicht \
  --set migration.backoffLimit=1
kubectl -n tag11 get deploy t11-notes -o jsonpath='{.metadata.generation}{"\n"}'
helm upgrade t11 ./notes -n tag11 $B --no-hooks --wait | grep REVISION
kubectl -n tag11 get jobs
helm history t11 -n tag11 -o json | jq -r '.[] | "\(.revision) \(.status)"'

Erwartet (gekürzt):

1
Error: UPGRADE FAILED: pre-upgrade hooks failed: resource Job/tag11/t11-notes-migrate
not ready. status: Failed, message: Job Failed. failed: 2/1
1
REVISION: 3
NAME                STATUS   COMPLETIONS   DURATION   AGE
t11-notes-migrate   Failed   0/1           16s        19s
1 superseded
2 failed
3 deployed

Die Generation des Deployments bleibt 1: Ein gescheiterter pre-upgrade-Hook verhindert, dass Helm überhaupt etwas anwendet. --no-hooks überspringt alle Hooks – der gescheiterte Job steht unverändert da. Nützlich im Notfall, gefährlich als Gewohnheit: Ein Upgrade ohne Migration kann eine neue App-Version auf ein altes Schema loslassen.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Chart-Test

# auf prod
mkdir -p notes/templates/tests
cat > notes/templates/tests/api-test.yaml <<'EOF'
{{/* notes/templates/tests/api-test.yaml – Stand Tag 11 */}}
apiVersion: v1
kind: Pod
metadata:
  name: {{ include "notes.fullname" . }}-test
  labels:
    {{- include "notes.labels" . | nindent 4 }}
  annotations:
    "helm.sh/hook": test
    "helm.sh/hook-delete-policy": before-hook-creation
spec:
  restartPolicy: Never
  securityContext:
    {{- include "plattform.podSecurityContext" . | nindent 4 }}
  containers:
    - name: test
      image: curlimages/curl:8.23.0
      securityContext:
        {{- include "plattform.containerSecurityContext" . | nindent 8 }}
      command: ["sh", "-c"]
      args:
        - |
          set -e
          base=http://{{ include "notes.fullname" . }}:{{ .Values.service.port }}
          curl -fsS $base/healthz
          test "$(curl -fsS $base/version)" = "{{ .Chart.AppVersion }}"
          echo "version ok"
          code=$(curl -s -o /dev/null -w '%{http_code}' -d '{"text":"x"}' $base/notes)
          test "$code" = 401
          echo "POST ohne Key: $code"
EOF
helm upgrade notes ./notes -n notes -f values/prod.yaml --wait | grep REVISION
helm test notes -n notes --logs

Erwartet (nach 5 Minuten, gekürzt):

REVISION: 24
TEST SUITE:     notes-test
Phase:          Failed
Error: resource Pod/notes/notes-test not ready. status: InProgress, message: Pod in
progress
context deadline exceeded
unable to get logs for pod notes-test, container test: container "test" in pod
"notes-test" is waiting to start: CreateContainerConfigError
# auf prod
kubectl -n notes get pod notes-test \
  -o jsonpath='{.status.containerStatuses[0].state.waiting.message}{"\n"}'

Erwartet:

container has runAsNonRoot and image has non-numeric user (curl_user), cannot verify
user is non-root (pod: "notes-test_notes(90f7215d-…)", container: test)

Das curl-Image nennt seinen Benutzer beim Namen, nicht als Nummer. Mit runAsNonRoot: true kann das Kubelet das nicht prüfen und startet den Container nicht. Die Lösung ist eine feste UID. Wichtig: helm test führt die Test-Hooks der gespeicherten Revision aus – nach der Korrektur braucht es ein Upgrade.

# auf prod
sed -i '/podSecurityContext" . | nindent 4/a\    runAsUser: 100' \
  notes/templates/tests/api-test.yaml
helm upgrade notes ./notes -n notes -f values/prod.yaml --wait | grep REVISION
helm test notes -n notes --logs | sed -n '/TEST SUITE/,$p'

Erwartet:

REVISION: 25
TEST SUITE:     notes-test
Last Started:   Fri Nov 20 02:07:18 2026
Last Completed: Fri Nov 20 02:07:22 2026
Phase:          Succeeded

POD LOGS: notes-test (test)
ok
version ok
POST ohne Key: 401

Chart-Tests prüfen den laufenden Release, nicht das Rendering:

Werkzeug Prüft Cluster? Tag
helm lint, Schema Struktur, Werte nein 2, 8
helm template + kubeconform, helm-unittest gerenderte Manifeste nein 17
helm test laufende Anwendung ja 11

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig alle Hook-Zeitpunkte des Releases notes. Zeitziel: 20 s
  2. Zeig das Log des letzten Migrations-Jobs. Zeitziel: 15 s
  3. Führe die Chart-Tests aus, nur die Phase. Zeitziel: 20 s
  4. Wie oft steht kind: Job im Manifest des Releases? Zeitziel: 15 s

Lösung

# auf prod
helm get hooks notes -n notes | grep '"helm.sh/hook"'
kubectl -n notes logs job/notes-migrate
helm test notes -n notes | grep Phase
helm get manifest notes -n notes | grep -c 'kind: Job'

Erwartet:

    "helm.sh/hook": test
    "helm.sh/hook": post-install,pre-upgrade
time=2026-11-20T02:07:13.743Z level=INFO msg="migration complete" table=notes
Phase:          Succeeded
0

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf prod
helm list -n notes --filter '^notes$'

Erwartet: Revision 25, notes-0.10.0, deployed.

# auf prod
kubectl -n notes get deploy notes -o jsonpath='{.spec.template.spec.initContainers}'

Erwartet: keine Ausgabe – die Migration läuft nur noch als Hook.

# auf prod
helm test notes -n notes | grep Phase

Erwartet: Phase: Succeeded

Challenge

Notizen sollen später Tags bekommen. Ergänze im Release t11 (Kopie des Charts) eine abwärtskompatible Schema-Änderung: eine nullable Spalte tags, angelegt von einem zweiten Hook-Job nach migrate. Prüfe, dass die alte App weiter schreibt, und dass ein helm rollback die Spalte nicht entfernt.

Hinweis: Das Postgres-Image bringt psql mit; die Variablen PGHOST, PGUSER, PGDATABASE und PGPASSWORD ersparen Kommandozeilen-Optionen.

Lösung

# auf prod
cd ~/helm/tag11 && rm -rf notes && cp -r ~/helm/charts/notes .
rm -rf notes/templates/tests
cat > notes/templates/schema-v2-job.yaml <<'EOF'
{{/* Challenge Tag 11: abwärtskompatible Schema-Änderung nach migrate */}}
apiVersion: batch/v1
kind: Job
metadata:
  name: {{ include "notes.fullname" . }}-schema-v2
  annotations:
    "helm.sh/hook": post-install,pre-upgrade
    "helm.sh/hook-weight": "5"
    "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded
spec:
  backoffLimit: 5
  template:
    spec:
      restartPolicy: Never
      securityContext:
        runAsNonRoot: true
        runAsUser: 70
        seccompProfile: {type: RuntimeDefault}
      containers:
        - name: psql
          image: docker.io/library/postgres:18.7-alpine
          command: ["psql", "-v", "ON_ERROR_STOP=1", "-c",
            "ALTER TABLE notes ADD COLUMN IF NOT EXISTS tags text"]
          securityContext:
            {{- include "plattform.containerSecurityContext" . | nindent 12 }}
          env:
            - {name: PGHOST, value: {{ printf "%s-postgres" .Release.Name }}}
            - {name: PGUSER, value: {{ .Values.database.user }}}
            - {name: PGDATABASE, value: {{ .Values.database.name }}}
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef: {name: {{ .Values.global.dbSecret }}, key: password}
EOF
B='--set apiKey.existingSecret=notes-api-key --set global.dbSecret=notes-db'
B="$B --set postgres.enabled=true --set replicaCount=1"
helm upgrade t11 ./notes -n tag11 $B --wait | grep REVISION
kubectl -n tag11 exec t11-postgres-0 -- psql -U notes -tAc '\d notes'
IP=$(kubectl -n tag11 get svc t11-notes -o jsonpath='{.spec.clusterIP}')
curl -s -H 'X-API-Key: lab-key-123' $IP/notes -d '{"text":"nach v2"}'; echo
helm rollback t11 1 -n tag11 --wait
kubectl -n tag11 exec t11-postgres-0 -- psql -U notes -tAc '\d notes' | grep tags
curl -s $IP/notes; echo

Erwartet (ID gekürzt):

REVISION: 4
id|uuid||not null|
text|text||not null|
created_at|timestamp with time zone||not null|now()
tags|text|||
{"id":"13f31aa5-…","text":"nach v2"}
Rollback was a success! Happy Helming!
tags|text|||
[{"id":"13f31aa5-…","text":"nach v2"}]

Gewicht 5 sorgt dafür, dass schema-v2 nach migrate (Gewicht 0) läuft. Eine neue nullable Spalte stört die alte App nicht – sie fragt nur die Spalten ab, die sie kennt. Der Rollback stellt die Manifeste von Revision 1 her, die Spalte und die Notiz bleiben. Abwärtskompatibel heißt: Erst Spalten ergänzen, die App umstellen, und erst eine spätere Version räumt Altes weg (Expand/Contract).

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf prod
helm uninstall t11 -n tag11
kubectl delete namespace tag11
cd ~/helm/charts
git add notes
git commit -qm "Tag 11: Migration als Hook-Job, Chart-Test, notes 0.10.0"

Erwartet:

release "t11" uninstalled
namespace "tag11" deleted

Interview-Notiz

  • Wie führst du Datenbank-Migrationen mit Helm aus? Als Job-Hook post-install,pre-upgrade mit backoffLimit und Delete-Policy. Scheitert er beim Upgrade, wendet Helm nichts an. Die Migration muss abwärtskompatibel sein, damit ein Rollback funktioniert.
  • Sind Hooks Teil des Releases? Nein. Sie stehen nicht im Manifest, helm uninstall löscht sie nicht, Aufräumen regelt hook-delete-policy.
  • Wie testest du ein Chart? In Schichten: lint und Schema, Unit-Tests auf das Rendering, Installation in einem Wegwerf-Cluster und helm test gegen den laufenden Release.

Enterprise-Notiz

  • GitOps-Werkzeuge übersetzen Helm-Hooks unterschiedlich (Argo CD: Sync-Hooks, Flux: echte Helm-Hooks) – Tag 18. Charts sollten auch ohne Hooks einen sinnvollen Zustand erreichen.
  • Lang laufende Migrationen gehören nicht in einen Hook mit fünf Minuten Timeout, sondern in einen eigenen, überwachten Ablauf.
  • Test-Pods brauchen dieselben Sicherheitsregeln wie die App: feste UID, keine Privilegien, Images aus der eigenen Registry.
  • helm test gehört in die Pipeline nach jedem Deployment in eine Testumgebung; das Ergebnis entscheidet über die Freigabe für Produktion.