Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Du löst 16 Aufgaben quer durch das Buch in 120 Minuten – ein eigenes Chart vom ersten Template bis zur signierten Auslieferung, dazu Betrieb und Fehlersuche – und bewertest dich selbst. · Dauer: 120 min · Voraussetzung: Tag 0–20

Spielregeln

  • Zeit: 120 Minuten, Uhr stellen. Jede Aufgabe hat ein Gewicht in Prozent, zusammen 100 %.
  • Ein Zertifikat gibt es nicht. Die eigene Messlatte: ab 70 % sitzt das Handwerk.
  • Erlaubt: helm.sh/docs, --help, kubectl explain und deine eigenen Dateien unter ~/helm als Vorlage. Nicht erlaubt: dieses Buch während der Zeit.
  • Alles läuft auf prod im Namespace pruefung, Dateien in ~/helm/pruefung. In zot benutzt du nur den Pfad oci://localhost:30500/pruefung.
  • notes, zot und ~/helm/charts fasst du nicht an.
  • Aufgabe 2 bis 11 bauen aufeinander auf, Aufgabe 12 bis 14 setzen Aufgabe 11 voraus. Aufgabe 13 und 14 haben eine Vorbereitung, die du erst ausführst, wenn du dort angekommen bist.
  • Die Lösungen stehen am Ende. Erst nach Ablauf der Zeit lesen.

Vorbereitung

Ein Release, den ein Kollege „nur kurz zum Testen“ angelegt hat (Chart tresor aus Tag 16):

# auf prod
mkdir -p ~/helm/pruefung && cd ~/helm/pruefung
kubectl create namespace pruefung
helm install leck ~/helm/tag16/tresor -n pruefung --set dbPassword=lab-geheim-123 \
  | grep STATUS

Erwartet:

namespace/pruefung created
STATUS: deployed

Aufgabe 1: Bestandsaufnahme (5 %)

Liste alle Releases im Cluster mit Namespace, Chart-Version, Status und Revision in einer Zeile je Release. Welcher Release hat die meisten Revisionen?

Aufgabe 2: Das Chart kasse (8 %)

Baue in ~/helm/pruefung/kasse ein Chart kasse 0.1.0 (appVersion “2.26.0”) für go-httpbin auf Basis des Library Charts plattform 0.2.x aus zot – Deployment und Service kommen vollständig aus der Bibliothek. Standard: zwei Replikas, Port 8080, readinessProbe auf /status/200. Installiere es als Release kasse und warte.

Aufgabe 3: Werte für Produktion (6 %)

Lege kasse-prod.yaml an: eine Replika, Requests 20m/32Mi, Limit 96Mi. Zeige mit helm template, dass die Datei wirkt und dass --set replicaCount=3 sie schlägt.

Aufgabe 4: Optionaler Ingress (7 %)

kasse bekommt einen Ingress, der nur entsteht, wenn er eingeschaltet ist und Hosts hat. Hostnamen dürfen den Release-Namen enthalten ({{ .Release.Name }}…). Für Produktion: kasse.pruefung.lab. Beweise mit curl über Traefik.

Aufgabe 5: Schema (6 %)

Schreibe ein values.schema.json, das unbekannte Schlüssel verbietet, mindestens eine Replika verlangt und image.repository zur Pflicht macht. Zeige beide Fehler mit helm lint.

Aufgabe 6: Hook (6 %)

Nach jeder Installation und jedem Upgrade soll ein Job kasse-ping den Service auf /status/200 prüfen; ein alter Job wird vor dem nächsten Lauf ersetzt. Der Job muss unter restricted laufen können.

Aufgabe 7: Chart-Test (5 %)

Ein Test-Pod ruft /get des Service auf. helm test muss grün sein.

Aufgabe 8: Unit-Tests (7 %)

Mindestens vier Tests mit helm-unittest: Image-Tag aus appVersion, kein Ingress ohne Hosts, Host mit Release-Namen, Schema lehnt 0 Replikas ab. Die Tests gehören nicht ins Paket.

Aufgabe 9: Prüfen ohne Cluster (5 %)

helm lint --strict und kubeconform -strict gegen das Produktions-Rendering – so, dass ein Fehler beim Rendern die Prüfung rot macht.

Aufgabe 10: Signiert ausliefern (7 %)

Paketiere kasse mit GPG-Signatur (Schlüssel aus Tag 16), schiebe es mit Provenienz nach oci://localhost:30500/pruefung und signiere den Digest mit cosign.

Aufgabe 11: Aus der Registry ausrollen (6 %)

Rolle kasse aus zot aus: nur nach erfolgreicher Signaturprüfung, per Digest, mit den Produktionswerten. Was passiert, wenn du zusätzlich --verify setzt?

Aufgabe 12: Ein Upgrade, das scheitern darf (6 %)

Ein Upgrade mit dem Image-Tag 0.0.0-kaputt darf den Dienst nicht beschädigen. Zeige in der Historie, wohin zurückgerollt wurde.

Aufgabe 13: Die Nachtschicht (6 %)

Vorbereitung (erst jetzt ausführen):

# auf prod
kubectl -n pruefung scale deploy kasse --replicas=4

Das nächste Upgrade von kasse mit den Produktionswerten scheitert. Finde die Ursache und bring die Replikazahl wieder unter die Kontrolle des Charts.

Aufgabe 14: Die Sperre (6 %)

Vorbereitung (erst jetzt ausführen):

# auf prod
cd ~/helm/pruefung
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml --set image.tag=0.0.0-kaputt \
  --wait --timeout 5m >/dev/null 2>&1 &
sleep 5; kill -9 $!

Löse die Sperre, ohne ein Secret zu löschen, und beweise, dass das richtige Image läuft.

Aufgabe 15: Das Leck (5 %)

Zeige drei Stellen, an denen das Passwort von leck im Klartext lesbar ist, und entferne es vollständig aus dem Cluster.

Aufgabe 16: Kurzfragen (9 %)

Je 1,5 % pro Antwort, ein bis zwei Sätze:

  1. Was unterscheidet Chart, Release und Revision?
  2. Was stellt helm rollback wieder her – und was nicht?
  3. Warum aktualisiert helm upgrade keine CRDs aus crds/?
  4. Warum include statt template?
  5. Was ändert sich für ein Chart unter Argo CD gegenüber helm upgrade?
  6. Was ist der Unterschied zwischen --reuse-values und --reset-then-reuse-values?

Lösungen

Alle Lösungen sind live gelaufen; Revisionsnummern hängen von deinen Versuchen ab.

Lösung 1

# auf prod
helm list -A -o json \
  | jq -r '.[] | "\(.namespace)/\(.name) \(.chart) \(.status) \(.revision)"'
helm list -A -o json | jq -r 'max_by(.revision | tonumber) | .name'

Erwartet:

kube-system/gateway-api-crd gateway-api-crd-1.6.301 deployed 1
notes/helper helper-0.2.1 deployed 3
pruefung/leck tresor-0.1.0 deployed 1
notes/notes notes-0.12.1 deployed 32
notes/notes-crds notes-crds-0.2.0 deployed 3
kube-system/traefik traefik-41.6.101+up41.6.1 deployed 1
kube-system/traefik-crd traefik-crd-41.6.101+up41.6.1 deployed 1
zot/zot zot-0.1.135 deployed 7
notes

Helm 4 listet ohne Flag jeden Status (Tag 1). Die Revision steht im JSON als String – ohne tonumber gewänne „7“ gegen „32“. Gespeichert sind von notes nur die letzten zehn Revisionen – die Nummer zählt trotzdem weiter.

Lösung 2

# auf prod
cd ~/helm/pruefung && mkdir -p kasse/templates
cat > kasse/Chart.yaml <<'EOF'
# kasse/Chart.yaml – Prüfung
apiVersion: v2
name: kasse
description: Kassendienst (go-httpbin) auf Basis von plattform
version: 0.1.0
appVersion: "2.26.0"
dependencies:
  - name: plattform
    version: "~0.2.0"
    repository: oci://localhost:30500/charts
EOF
cat > kasse/values.yaml <<'EOF'
# kasse/values.yaml – Prüfung
replicaCount: 2
image:
  repository: ghcr.io/mccutchen/go-httpbin
  tag: ""
port: 8080
probePath: /status/200
resources:
  requests: {cpu: 10m, memory: 16Mi}
  limits: {memory: 64Mi}
ingress:
  enabled: false
  className: traefik
  hosts: []
EOF
printf '{{ include "plattform.deployment" . }}\n' > kasse/templates/deployment.yaml
printf '{{ include "plattform.service" . }}\n' > kasse/templates/service.yaml
helm dependency update kasse --plain-http 2>&1 | grep -E 'Saving|Pulled'
helm install kasse ./kasse -n pruefung --wait | grep -E '^(STATUS|REVISION)'
kubectl -n pruefung get deploy kasse \
  -o jsonpath='{.spec.replicas} {.spec.template.spec.containers[0].image}{"\n"}'

Erwartet:

Saving 1 charts
Pulled: localhost:30500/charts/plattform:0.2.0
STATUS: deployed
REVISION: 1
2 ghcr.io/mccutchen/go-httpbin:2.26.0

Wie helper in Tag 10 und 15: Die Bibliothek liefert Namen, Labels, restricted-SecurityContexts, Probe und Service. --plain-http braucht schon dependency update (Tag 15).

Lösung 3

# auf prod
cat > kasse-prod.yaml <<'EOF'
# kasse-prod.yaml – Prüfung
replicaCount: 1
resources:
  requests: {cpu: 20m, memory: 32Mi}
  limits: {memory: 96Mi}
EOF
helm template kasse ./kasse -f kasse-prod.yaml -s templates/deployment.yaml \
  | grep -E 'replicas:|memory:'
helm template kasse ./kasse -f kasse-prod.yaml --set replicaCount=3 \
  -s templates/deployment.yaml | grep 'replicas:'

Erwartet:

  replicas: 1
              memory: 96Mi
              memory: 32Mi
  replicas: 3

values.yaml < -f < --set (Tag 3). Maps wie resources werden gemischt, hier ersetzt die Datei beide Schlüssel.

Lösung 4

# auf prod
cat > kasse/templates/ingress.yaml <<'EOF'
{{- if and .Values.ingress.enabled .Values.ingress.hosts }}
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: {{ include "plattform.fullname" . }}
  labels:
    {{- include "plattform.labels" . | nindent 4 }}
spec:
  ingressClassName: {{ .Values.ingress.className }}
  rules:
    {{- range .Values.ingress.hosts }}
    - host: {{ tpl . $ | quote }}
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: {{ include "plattform.fullname" $ }}
                port:
                  number: 80
    {{- end }}
{{- end }}
EOF
cat >> kasse-prod.yaml <<'EOF'
ingress:
  enabled: true
  hosts:
    - "{{ .Release.Name }}.pruefung.lab"
EOF
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml --wait | grep REVISION
sleep 3
curl -s -o /dev/null -w '%{http_code}\n' -H 'Host: kasse.pruefung.lab' localhost/get

Erwartet:

REVISION: 2
200

and mit beiden Bedingungen, tpl . $ für den Hostnamen und $ für alles im range (Tag 5, 7). Nach --wait liefert Traefik kurz noch 502 – deshalb die drei Sekunden.

Lösung 5

# auf prod
cat > kasse/values.schema.json <<'EOF'
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "replicaCount": {"type": "integer", "minimum": 1},
    "image": {
      "type": "object",
      "required": ["repository"],
      "properties": {"repository": {"type": "string", "minLength": 1},
                     "tag": {"type": "string"}}
    },
    "port": {"type": "integer"},
    "probePath": {"type": ["string", "null"]},
    "resources": {"type": "object"},
    "ingress": {"type": "object"},
    "global": {"type": "object"},
    "plattform": {"type": "object"}
  }
}
EOF
helm lint kasse -f kasse-prod.yaml | tail -1
helm lint kasse --set replicaCount=0 2>&1 | grep -o "at '/replicaCount'.*" | head -1
helm lint kasse --set replica=3 2>&1 | grep -o "additional properties.*" | head -1
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml --wait | grep REVISION

Erwartet:

1 chart(s) linted, 0 chart(s) failed
at '/replicaCount': minimum: got 0, want 1
additional properties 'replica' not allowed
REVISION: 3

global und plattform (Werte des Subcharts) müssen erlaubt sein, sonst lehnt das Schema die eigene Abhängigkeit ab (Tag 9). minimum: 1 hat einen guten Grund: plattform rendert replicaCount | default 1 – eine 0 käme als 1 an (Tag 10).

Lösung 6

# auf prod
cat > kasse/templates/ping-job.yaml <<'EOF'
apiVersion: batch/v1
kind: Job
metadata:
  name: {{ include "plattform.fullname" . }}-ping
  annotations:
    "helm.sh/hook": post-install,post-upgrade
    "helm.sh/hook-weight": "0"
    "helm.sh/hook-delete-policy": before-hook-creation
spec:
  backoffLimit: 3
  template:
    spec:
      restartPolicy: Never
      securityContext:
        {{- include "plattform.podSecurityContext" . | nindent 8 }}
      containers:
        - name: ping
          image: curlimages/curl:8.23.0
          command: ["curl", "-fsS",
            "http://{{ include "plattform.fullname" . }}/status/200"]
          securityContext:
            runAsUser: 100
            {{- include "plattform.containerSecurityContext" . | nindent 12 }}
EOF
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml --wait | grep REVISION
helm get hooks kasse -n pruefung | grep -c 'kind: Job'
kubectl -n pruefung get job kasse-ping -o jsonpath='{.status.succeeded}{"\n"}'

Erwartet:

REVISION: 4
1
1

post-*, weil der Service vorher existieren muss (Tag 11). runAsUser: 100, weil das curl-Image einen nicht-numerischen Benutzer hat und runAsNonRoot sonst den Start verweigert (Tag 11).

Lösung 7

# auf prod
mkdir -p kasse/templates/tests
cat > kasse/templates/tests/get-test.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: {{ include "plattform.fullname" . }}-test
  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
      command: ["curl", "-fsS", "http://{{ include "plattform.fullname" . }}/get"]
      securityContext:
        runAsUser: 100
        {{- include "plattform.containerSecurityContext" . | nindent 8 }}
EOF
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml --wait | grep REVISION
helm test kasse -n pruefung | grep -E 'NAME:|Phase'

Erwartet:

REVISION: 5
NAME: kasse
Phase:          Succeeded

helm test nutzt die Test-Hooks der gespeicherten Revision – deshalb erst das Upgrade (Tag 11).

Lösung 8

# auf prod
mkdir -p kasse/tests
cat > kasse/tests/kasse_test.yaml <<'EOF'
suite: kasse
templates:
  - templates/deployment.yaml
  - templates/ingress.yaml
release:
  name: kasse
tests:
  - it: nimmt appVersion als Tag
    template: templates/deployment.yaml
    asserts:
      - equal:
          path: spec.template.spec.containers[0].image
          value: ghcr.io/mccutchen/go-httpbin:2.26.0
  - it: lässt den Ingress ohne Hosts weg
    template: templates/ingress.yaml
    set:
      ingress.enabled: true
    asserts:
      - hasDocuments:
          count: 0
  - it: rendert Hosts mit dem Release-Namen
    template: templates/ingress.yaml
    set:
      ingress.enabled: true
      ingress.hosts: ["{{ .Release.Name }}.pruefung.lab"]
    asserts:
      - equal:
          path: spec.rules[0].host
          value: kasse.pruefung.lab
  - it: lehnt null Replikas ab
    template: templates/deployment.yaml
    set:
      replicaCount: 0
    asserts:
      - failedTemplate:
          errorPattern: "minimum: got 0, want 1"
EOF
printf '/tests/\n' >> kasse/.helmignore
helm unittest kasse | grep -E 'PASS|FAIL|^Tests:'

Erwartet:

 PASS  kasse    kasse/tests/kasse_test.yaml
Tests:       4 passed, 4 total

/tests/ mit Schrägstrich – tests/ würde auch templates/tests/ aus dem Paket nehmen, und der Chart-Test aus Aufgabe 7 wäre weg (Tag 17).

Lösung 9

# auf prod
set -o pipefail
helm lint kasse --strict -f kasse-prod.yaml | tail -1
helm template kasse ./kasse -f kasse-prod.yaml | kubeconform -strict -summary

Erwartet:

1 chart(s) linted, 0 chart(s) failed
Summary: 5 resources found parsing stdin - Valid: 5, Invalid: 0, Errors: 0, Skipped: 0

Fünf Objekte: Deployment, Service, Ingress, Hook-Job und Test-Pod. Ohne pipefail wäre ein Renderfehler grün (Tag 17).

Lösung 10

# auf prod
K=~/helm/tag16
helm package kasse --sign --key 'Helm Lab' --keyring $K/secring.gpg | tail -1
helm verify kasse-0.1.0.tgz --keyring $K/pubring.gpg | tail -1 | cut -c1-40
D=$(helm push kasse-0.1.0.tgz oci://localhost:30500/pruefung --plain-http \
  | awk '/^Digest/{print $2}'); test -n "$D" && echo "${D:0:19}…"
curl -s -u lab-zot-user:lab-zot-123 \
  -H 'Accept: application/vnd.oci.image.manifest.v1+json' \
  localhost:30500/v2/pruefung/kasse/manifests/0.1.0 | jq -r '.layers[].mediaType'
export COSIGN_PASSWORD=lab-cosign-123
cosign sign --key $K/cosign.key -y --signing-config $K/offline.json \
  --allow-http-registry localhost:30500/pruefung/kasse@$D 2>&1 | tail -1

Erwartet:

Successfully packaged chart and saved it to: /home/ubuntu/helm/pruefung/kasse-0.1.0.tgz
Chart Hash Verified: sha256:4ef6748eea4c
sha256:e266e9e6341a…
application/vnd.cncf.helm.chart.content.v1.tar+gzip
application/vnd.cncf.helm.chart.provenance.v1.prov
Pushing signature to: localhost:30500/pruefung/kasse

Der Digest kommt von stdout (Tag 18), die .prov reist als zweite Schicht mit (Tag 16).

Lösung 11

# auf prod
cosign verify --key $K/cosign.pub --allow-http-registry --insecure-ignore-tlog \
  localhost:30500/pruefung/kasse@$D >/dev/null 2>&1 \
  && helm upgrade kasse oci://localhost:30500/pruefung/kasse@$D -n pruefung \
     -f kasse-prod.yaml --plain-http --verify --keyring $K/pubring.gpg --wait \
  2>&1 | grep -E '^(STATUS|REVISION|Error)' | fold -w 88
helm upgrade kasse oci://localhost:30500/pruefung/kasse --version 0.1.0 -n pruefung \
  -f kasse-prod.yaml --plain-http --verify --keyring $K/pubring.gpg --wait \
  | grep -E '^(STATUS|REVISION)'
cosign verify --key $K/cosign.pub --allow-http-registry --insecure-ignore-tlog \
  localhost:30500/pruefung/kasse@$D >/dev/null 2>&1 \
  && helm upgrade kasse oci://localhost:30500/pruefung/kasse@$D -n pruefung \
     -f kasse-prod.yaml --plain-http --wait | grep -E '^(STATUS|REVISION)'

Erwartet:

Error: provenance does not contain a SHA for a file named "kasse@sha256-e266e9e6341a2d42
8cae2c9c9ab436b2db11ffffbed0cde509eba2b07bdcc251.tgz"
STATUS: deployed
REVISION: 6
STATUS: deployed
REVISION: 7

Die Antwort auf die Zusatzfrage: Helm 4.3.2 benennt ein per Digest geladenes Chart kasse@sha256-….tgz und sucht diesen Namen in der .prov – --verify scheitert an jeder Digest-Referenz. Per --version klappt die GPG-Prüfung; sie sichert den Inhalt, aber nicht, welche signierte Fassung gerade hinter dem überschreibbaren Tag steht. Der saubere Weg ist die cosign-Prüfung des Digests vor dem Upgrade per Digest.

Lösung 12

# auf prod
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml --set image.tag=0.0.0-kaputt \
  --rollback-on-failure --timeout 40s 2>&1 \
  | grep -o 'release kasse failed, and has been rolled back'
helm history kasse -n pruefung --max 2 --show-rollback-revision -o json \
  | jq -r '.[] | "\(.revision) \(.status) \(.rollback_revision // "-")"'
kubectl -n pruefung get deploy kasse \
  -o jsonpath='{.spec.template.spec.containers[0].image}{"\n"}'

Erwartet:

release kasse failed, and has been rolled back
8 failed -
9 deployed 7
ghcr.io/mccutchen/go-httpbin:2.26.0

--rollback-on-failure schaltet --wait ein; die Probe aus der Bibliothek erkennt den kaputten Rollout (Tag 13).

Lösung 13

# auf prod
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml 2>&1 | grep '^Error' \
  | grep -o 'conflict with "[a-z-]*" with subresource "[a-z]*"'
helm upgrade kasse ./kasse -n pruefung -f kasse-prod.yaml --force-conflicts --wait \
  | grep REVISION
kubectl -n pruefung get deploy kasse -o jsonpath='{.spec.replicas}{"\n"}'

Erwartet:

conflict with "kubectl" with subresource "scale"
REVISION: 11
1

kubectl scale hat spec.replicas übernommen, Server-Side Apply verweigert das Upgrade (Tag 14, 19). --force-conflicts gibt das Feld dem Chart zurück. Wäre das Skalieren gewollt (HPA), gehörte replicas aus dem Template.

Lösung 14

# auf prod
helm history kasse -n pruefung --max 2 -o json | jq -r '.[] | "\(.revision) \(.status)"'
pgrep -a helm || echo "kein helm-Prozess"
R=$(helm history kasse -n pruefung -o json \
  | jq -r '[.[] | select(.status=="deployed")][-1].revision')
helm rollback kasse $R -n pruefung --wait --description "Prüfung: Sperre gelöst" \
  | tail -1
helm history kasse -n pruefung --max 1 -o json \
  | jq -r '.[] | "\(.revision) \(.status) \(.description)"'
kubectl -n pruefung get deploy kasse \
  -o jsonpath='{.spec.template.spec.containers[0].image}{"\n"}'

Erwartet:

11 deployed
12 pending-upgrade
kein helm-Prozess
Rollback was a success! Happy Helming!
13 deployed Prüfung: Sperre gelöst
ghcr.io/mccutchen/go-httpbin:2.26.0

Erst prüfen, dass kein Helm mehr läuft, dann Rollback auf die letzte deployed-Revision (Tag 19, Drill 3).

Lösung 15

# auf prod
helm get values leck -n pruefung
helm get manifest leck -n pruefung | grep password
kubectl -n pruefung get secret -l owner=helm,name=leck \
  -o jsonpath='{.items[0].data.release}' \
  | base64 -d | base64 -d | gzip -d | grep -o 'lab-geheim-123' | sort -u
helm uninstall leck -n pruefung
kubectl -n pruefung get secret -l owner=helm,name=leck -o name | wc -l

Erwartet:

USER-SUPPLIED VALUES:
dbPassword: lab-geheim-123
  password: "lab-geheim-123"
lab-geheim-123
release "leck" uninstalled
0

Die drei Stellen: Werte, Manifest, Release-Secret. Das erzeugte Secret selbst ist der vorgesehene Ort und zählt nicht mit. helm uninstall ohne --keep-history entfernt alle Revisionen. Ein Passwort, das einmal in Helm war, gilt als bekannt: rotieren (Tag 13, 16).

Lösung 16

  1. Das Chart ist das Paket (Templates, Werte, Metadaten), der Release eine Installation davon unter einem Namen in einem Namespace, jede Änderung daran eine neue Revision (Tag 1).
  2. Er stellt das gespeicherte Manifest einer früheren Revision als neue Revision wieder her – keine Daten, PVC-Inhalte oder Datenbank-Schemas (Tag 13).
  3. Weil eine CRD-Änderung clusterweit alle Objekte betrifft und Helm das bewusst nicht automatisch tut; CRDs gehören in ein eigenes Chart oder werden gesondert per SSA aktualisiert (Tag 12).
  4. include liefert einen String, der sich weiterverarbeiten lässt (nindent, sha256sum); template schreibt direkt in die Ausgabe (Tag 6).
  5. Argo CD rendert mit helm template und wendet selbst an: kein Release, lookup leer, .Release.Revision bleibt 1, Hooks werden Sync-Hooks (Tag 18).
  6. --reuse-values übernimmt die berechneten Werte der letzten Revision samt alter Standards; --reset-then-reuse-values nimmt die neuen Standards des Charts und legt nur die eigenen Werte darüber (Tag 3, 20).

Auswertung

Die Endkontrolle vor dem Aufräumen:

# auf prod
helm status kasse -n pruefung -o json | jq -r .info.status
helm test kasse -n pruefung | grep Phase
helm unittest kasse | grep '^Tests:'

Erwartet:

deployed
Phase:          Succeeded
Tests:       4 passed, 4 total
Ergebnis Einschätzung
85–100 % Du schreibst, prüfst und betreibst Charts wie ein Plattformteam.
70–84 % Handwerk sitzt; die Tage der verlorenen Aufgaben wiederholen.
unter 70 % Tag 5–11 (Chart bauen) und 13–19 (ausliefern, betreiben) noch einmal.

Teilpunkte: Funktioniert die Lösung, fehlt aber der Beweis-Befehl, gibt es die Hälfte. Wer in Aufgabe 14 ein Release-Secret gelöscht hat, bekommt 0 – der Rollback ging.

Aufräumen

# auf prod
helm uninstall kasse -n pruefung
kubectl delete namespace pruefung
A=lab-zot-user:lab-zot-123
D=$(helm show chart oci://localhost:30500/pruefung/kasse --version 0.1.0 --plain-http \
  2>&1 >/dev/null | awk '/^Digest/{print $2}')
for r in $(curl -s -u $A localhost:30500/v2/pruefung/kasse/referrers/$D \
  | jq -r '.manifests[].digest') $D; do
  curl -s -o /dev/null -w "%{http_code}\n" -u $A -X DELETE \
    localhost:30500/v2/pruefung/kasse/manifests/$r
done
curl -s -u $A localhost:30500/v2/_catalog | jq -r '.repositories[]'

Erwartet:

release "kasse" uninstalled
namespace "pruefung" deleted
202
202
charts/helper
charts/notes
charts/plattform
charts/postgres
charts/probe
mirror/zot

Erst die Signatur (Referrer), dann das Chart selbst. ~/helm/pruefung bleibt als Vorlage für dein nächstes eigenes Chart.

Kontrollpunkt

# auf prod
helm list -A --failed --pending | wc -l

Erwartet: 1 (nur die Kopfzeile).

# auf prod
helm list -n notes --filter '^notes$' -o json | jq -r '.[0] | "\(.chart) \(.status)"'

Erwartet: notes-0.12.1 deployed