Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Hybrid und On-Prem beim Kunden

Ziel: Gateway und Modellserver als Helm-Chart samt Images und Modellgewichten in ein Air-Gap-Bundle packen, offline installieren, aktualisieren und supporten · Dauer: ca. 180 min · Voraussetzung: Tag 7, Tag 13

Briefing

  • Air-Gap heißt: kein Docker Hub, kein Hugging Face, kein ollama.com. Alles kommt über die Datenschleuse.
  • Ein Bundle = Chart + Images + Modellgewichte + Prüfsummen + Signatur. Was nicht drin ist, fehlt beim Kunden.
  • Das Chart kennt nur eine Stellschraube für den Ort: global.imageRegistry.
  • Upgrades sind neue Bundles; Rollback heißt helm rollback – Modelle bleiben im PVC.
  • Support ohne Zugang: der Kunde schickt dir ein Support-Bundle ohne Secrets.
Build-Seite (online)                  Datenschleuse        Kunde (offline)
helm package, skopeo, ollama-export --> bundle/ (USB, --> kunde-registry:5000
SHA256SUMS + cosign sign-blob           SFTP, Diode)     helm install (Chart aus OCI)

Drill 1: Das Chart llm-platform

Das Chart liegt im Begleitcode. Es enthält Gateway (Tag 4), Ollama (Tag 5), PVC, NetworkPolicy und Secret:

mkdir -p ~/sre-lab/tag14 && cd ~/sre-lab/tag14
C=~/sre-lab/code/llm-platform-chart
ls "$C" "$C/templates"
helm lint --strict "$C"
helm template llm "$C" | kubeconform -strict -summary -

Erwartet:

/Users/tz/sre-lab/code/llm-platform-chart:
Chart.yaml  examples  templates  values.yaml

/Users/tz/sre-lab/code/llm-platform-chart/templates:
_helpers.tpl             gateway-service.yaml    model-service.yaml
gateway-deployment.yaml  model-deployment.yaml   networkpolicy.yaml
gateway-secret.yaml      model-pvc.yaml          NOTES.txt
==> Linting /Users/.../llm-platform-chart
[INFO] Chart.yaml: icon is recommended

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

Kern des Air-Gap-Supports ist der Helper llm-platform.image in _helpers.tpl: Er stellt jedem Image global.imageRegistry voran. Der Modellserver bekommt seine Gewichte auf drei Wegen (Ausschnitt values.yaml):

modelServer:
  image:
    repository: ollama/ollama
    tag: "0.40.2"
  models:
    - ministral-3:3b
  pullOnStart: true        # initContainer "ollama pull" – braucht Internet
  modelImage:              # Air-Gap: OCI-Image mit fertigem Modellverzeichnis
    repository: ""
    tag: ""
  persistence:
    enabled: true          # PVC mit helm.sh/resource-policy: keep
    size: 20Gi

Warum? pullOnStart ist bequem im Lab, beim Kunden verboten. modelImage kopiert per initContainer (cp -Rn) aus einem Image in das PVC – Gewichte reisen damit über denselben Weg wie jedes andere Image. Ohne beides muss das PVC vorbefüllt sein.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Kundenwerte und Image-Liste

Pro Kunde eine Values-Datei, versioniert, ohne Secrets:

cat "$C/examples/values-kunde-acme.yaml"
helm template llm "$C" -f "$C/examples/values-kunde-acme.yaml" \
  | awk '$1=="image:"{print $2}' | sort -u

Erwartet:

# Kunde ACME, Air-Gap, CPU-only. Secret "acme-tenant-keys" legt der Kunde an.
global:
  imageRegistry: registry.acme.internal:5000
  imagePullSecrets: [acme-registry]
gateway:
  replicas: 3
  existingSecret: acme-tenant-keys
  tenants: {}
  rateLimit: {rps: 20, burst: 40}
modelServer:
  pullOnStart: false
  modelImage:
    repository: models/ministral-3
    tag: 3b-q4km
  persistence:
    size: 30Gi
    storageClass: ceph-rbd
registry.acme.internal:5000/llm-gateway:dev
registry.acme.internal:5000/models/ministral-3:3b-q4km
registry.acme.internal:5000/ollama/ollama:0.40.2

Diese Liste ist dein Packzettel: genau diese drei Images müssen ins Bundle. existingSecret heißt: Mandanten-Keys erzeugt der Kunde selbst (oder sein OpenBao, Tag 13) – sie verlassen nie dein Haus.

helm template llm "$C" --set gateway.tenants=null

Erwartet:

Error: execution error at (llm-platform/templates/gateway-secret.yaml:3:4):
gateway.tenants oder gateway.existingSecret muss gesetzt sein

Warum? Ein fail im Template stoppt fehlerhafte Kundenwerte schon bei helm template – nicht erst um 2 Uhr nachts beim Pod-Start.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Images spiegeln

Zielarchitektur festlegen: beim Kunden meist amd64, im Lab die deiner kind-Nodes.

ARCH=$(kubectl get nodes -o jsonpath='{.items[0].status.nodeInfo.architecture}')
mkdir -p bundle/images
skopeo copy --override-os linux --override-arch "$ARCH" \
  docker://docker.io/ollama/ollama:0.40.2 oci-archive:bundle/images/ollama_0.40.2.tar
docker save llm-gateway:dev -o bundle/images/llm-gateway_dev.tar
ls -lh bundle/images

Erwartet (Größen variieren je nach Architektur):

Copying blob ...
Writing manifest to image destination
-rw-------  1 tz  staff   4,1M  llm-gateway_dev.tar
-rw-r--r--  1 tz  staff   2,6G  ollama_0.40.2.tar

Warum zwei Werkzeuge? skopeo kopiert Registry → Datei ohne Docker-Daemon und wählt mit --override-arch genau eine Plattform (das Ollama-Image bringt CUDA-Bibliotheken mit, jede Architektur kostet GB). docker save brauchst du für lokal gebaute Images, die in keiner Registry liegen. Alternative: crane pull --platform linux/amd64 <ref> datei.tar.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Modellgewichte spiegeln, prüfen, signieren

Ollama speichert ein Modell als Manifest plus Blobs, deren Dateiname ihr SHA-256 ist:

cat > ollama-export.sh <<'EOF'
#!/usr/bin/env bash
# Exportiert ein Ollama-Modell (Manifest + Blobs) in ein Verzeichnis
set -euo pipefail
model=${1:?Modell, z. B. ministral-3:3b}; out=${2:?Zielverzeichnis}
src=${OLLAMA_MODELS:-$HOME/.ollama/models}
name=${model%%:*}; tag=${model##*:}
man=manifests/registry.ollama.ai/library/$name/$tag
[ -f "$src/$man" ] || { echo "Manifest fehlt: $src/$man" >&2; exit 1; }
mkdir -p "$out/models/$(dirname "$man")" "$out/models/blobs"
cp "$src/$man" "$out/models/$man"
for d in $(jq -r '.config.digest, .layers[].digest' "$src/$man"); do
  cp "$src/blobs/${d/:/-}" "$out/models/blobs/"
done
echo "exportiert: $model -> $out/models ($(du -sh "$out/models" | cut -f1))"
EOF
chmod +x ollama-export.sh
./ollama-export.sh ministral-3:3b bundle/model
(cd bundle/model && find models -type f | sort | xargs sha256sum) \
  > bundle/SHA256SUMS-model
(cd bundle/model && sha256sum -c --quiet ../SHA256SUMS-model) && echo "✔ Summen ok"

Erwartet:

exportiert: ministral-3:3b -> bundle/model/models (2,8G)
✔ Summen ok

Auf der VM aus Tag 5 liegt das Modell unter OLLAMA_MODELS=/var/lib/ollama/models – dann sudo OLLAMA_MODELS=/var/lib/ollama/models ./ollama-export.sh .... Import auf einem Offline-Host: Verzeichnis models/ nach OLLAMA_MODELS kopieren, ollama list zeigt das Modell sofort.

Für vLLM (Tag 7) spiegelst du stattdessen das Hugging-Face-Repo, gepinnt auf einen Commit:

hf download mistralai/Ministral-3-8B-Instruct-2512 \
  --revision <commit-sha> --local-dir bundle/hf/Ministral-3-8B-Instruct-2512
# beim Kunden: HF_HUB_OFFLINE=1, vllm serve /models/Ministral-3-8B-Instruct-2512 ...

hf download gibt am Ende den lokalen Pfad aus (nicht live getestet; die Lab-Messungen unten sind ohne bundle/hf).

Prüfsummen schützen vor Bitfehlern, nicht vor Manipulation. Dafür signierst du die Prüfsummenliste mit dem Lab-Schlüssel aus Tag 13:

export COSIGN_PASSWORD=lab-cosign-pw            # Lab-Passwort
cp ~/sre-lab/tag13/cosign.key ~/sre-lab/tag13/cosign.pub .
cosign signing-config create --out offline.json
cosign sign-blob --key cosign.key --signing-config offline.json -y \
  --bundle bundle/SHA256SUMS-model.sigstore.json bundle/SHA256SUMS-model
cosign verify-blob --key cosign.pub --insecure-ignore-tlog \
  --bundle bundle/SHA256SUMS-model.sigstore.json bundle/SHA256SUMS-model
cp bundle/SHA256SUMS-model fake.txt && echo "# manipuliert" >> fake.txt
cosign verify-blob --key cosign.pub --insecure-ignore-tlog \
  --bundle bundle/SHA256SUMS-model.sigstore.json fake.txt >/dev/null 2>&1 \
  || echo "✔ manipulierte Liste abgelehnt"

Erwartet:

Signing artifact...
Wrote bundle to file bundle/SHA256SUMS-model.sigstore.json
WARNING: Skipping tlog verification is an insecure practice ...
Verified OK
✔ manipulierte Liste abgelehnt

Warum nur die Liste signieren? Eine Signatur über 3 GB Gewichte ist teuer und ändert nichts: wer die Liste prüft und dann sha256sum -c laufen lässt, hat beides abgesichert. Beim Kunden liegt nur cosign.pub.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Modell als OCI-Image

Das Modellverzeichnis wird eine Image-Schicht auf busybox – dann reist es wie jedes Image und landet per initContainer im PVC:

tar -cf model-layer.tar -C bundle/model models
crane append --platform "linux/$ARCH" -b busybox:1.37 -f model-layer.tar \
  -t models/ministral-3:3b-q4km -o bundle/images/model-ministral-3-3b.tar
ls -lh bundle/images/model-ministral-3-3b.tar
du -sh bundle && rm model-layer.tar

Erwartet:

-rw-r--r--  1 tz  staff   2,7G  model-ministral-3-3b.tar
8,1G    bundle

Warum? GGUF lässt sich kaum komprimieren (2,8 GB → 2,7 GB), der Gewinn ist der Transportweg: Registry-Replikation, Pull-Secrets, Scans und Signaturen (Tag 13) gelten ab jetzt auch für Modelle. -o schreibt eine Tar-Datei statt zu pushen – auf der Build-Seite gibt es keine Kunden-Registry.

Zum Schluss Chart und eine Gesamtprüfsumme ins Bundle:

helm package "$C" -d bundle/charts
(cd bundle && find . -type f ! -name SHA256SUMS | sort | xargs sha256sum > SHA256SUMS)
wc -l bundle/SHA256SUMS

Erwartet:

Successfully packaged chart and saved it to: bundle/charts/llm-platform-0.1.0.tgz
12 bundle/SHA256SUMS

Fortschritt speichern? Kostenlos registrieren

Drill 6: Offline-Installation gegen eine lokale Registry

Simuliere die Kunden-Registry als registry:2 im kind-Netz:

docker run -d --name kunde-registry -p 127.0.0.1:5050:5000 registry:2
docker network connect kind kunde-registry
for n in $(kind get nodes --name sre-lab); do
  docker exec "$n" mkdir -p /etc/containerd/certs.d/kunde-registry:5000
  printf '[host."http://kunde-registry:5000"]\n  capabilities = ["pull", "resolve"]\n' \
    | docker exec -i "$n" tee /etc/containerd/certs.d/kunde-registry:5000/hosts.toml
done

Erwartet: pro Node einmal die zwei hosts.toml-Zeilen (nicht live getestet, Cluster gehört Tag 7).

Warum? Vom Laptop pushst du an 127.0.0.1:5050, die kind-Nodes ziehen von kunde-registry:5000 – wie beim Kunden mit eigenem DNS-Namen. hosts.toml erlaubt containerd HTTP für genau diese Registry.

Ab hier bist du „beim Kunden”: nur Dateien aus bundle/, keine Internet-Referenzen.

(cd bundle && sha256sum -c --quiet SHA256SUMS) && echo "✔ Bundle vollständig"
R=127.0.0.1:5050
push() { skopeo copy -q --dest-tls-verify=false "$1" "docker://$R/$2"; }
push oci-archive:bundle/images/ollama_0.40.2.tar ollama/ollama:0.40.2
push docker-archive:bundle/images/llm-gateway_dev.tar llm-gateway:dev
push docker-archive:bundle/images/model-ministral-3-3b.tar models/ministral-3:3b-q4km
helm push bundle/charts/llm-platform-0.1.0.tgz oci://$R/charts --plain-http
crane catalog --insecure $R

Erwartet:

✔ Bundle vollständig
Pushed: 127.0.0.1:5050/charts/llm-platform:0.1.0
Digest: sha256:eae132f3fea1de9bea9b64fac086d3a982aeb919a198f4e28232c4bb8cfc7e98
charts/llm-platform
llm-gateway
models/ministral-3
ollama/ollama

Preflight: Sind alle Images, die das Chart rendert, in der Registry?

helm template llm oci://$R/charts/llm-platform --version 0.1.0 --plain-http \
  -f "$C/examples/values-lab-kind.yaml" \
  | awk '$1=="image:"{print $2}' | sort -u | sed "s|kunde-registry:5000|$R|" \
  > preflight.txt
while read -r img; do
  if crane digest --insecure "$img" >/dev/null 2>&1; then echo "✔ $img"
  else echo "✘ $img"; fi
done < preflight.txt

Erwartet:

Pulled: 127.0.0.1:5050/charts/llm-platform:0.1.0
Digest: sha256:eae132f3fea1de9bea9b64fac086d3a982aeb919a198f4e28232c4bb8cfc7e98
✔ 127.0.0.1:5050/llm-gateway:dev
✔ 127.0.0.1:5050/models/ministral-3:3b-q4km
✔ 127.0.0.1:5050/ollama/ollama:0.40.2

Fehlt ein Image, siehst du hier ✘ statt später ImagePullBackOff – genau das passiert beim Kunden mit dem vergessenen Sidecar.

helm install llm oci://$R/charts/llm-platform --version 0.1.0 --plain-http \
  -n llm-system --create-namespace -f "$C/examples/values-lab-kind.yaml" \
  --wait --timeout 10m
kubectl -n llm-system get pods
kubectl -n llm-system get pods -o jsonpath='{.items[*].spec.containers[*].image}'; echo

Erwartet (gekürzt, kann je nach Version abweichen):

NAME: llm
STATUS: deployed
REVISION: 1
NAME                                    READY   STATUS    RESTARTS   AGE
llm-llm-platform-gateway-6d9f7c8b5-x2k4p  1/1     Running   0          3m
llm-llm-platform-model-7c5d8f9b6-9qzrt    1/1     Running   0          3m
kunde-registry:5000/llm-gateway:dev kunde-registry:5000/ollama/ollama:0.40.2

Achtung: Der Pod zieht 3 GB Modell-Image in den kind-Node, die Registry hält weitere 6 GB. Vorher docker system df prüfen (oder crane registry serve --disk <dir> als Registry auf der Laptop-Platte). Laufen noch Modellserver aus Tag 7, entferne sie, sonst reicht der RAM nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Upgrade, Canary, Rollback

Vor jedem Upgrade: Was ändert sich wirklich?

diff <(helm template llm "$C" -f "$C/examples/values-kunde-acme.yaml") \
     <(helm template llm "$C" -f "$C/examples/values-kunde-acme.yaml" \
         --set modelServer.modelImage.tag=3b-q8 --set modelServer.image.tag=0.40.3)

Erwartet:

216c216
<           image: registry.acme.internal:5000/models/ministral-3:3b-q4km
---
>           image: registry.acme.internal:5000/models/ministral-3:3b-q8
226c226
<           image: registry.acme.internal:5000/ollama/ollama:0.40.2
---
>           image: registry.acme.internal:5000/ollama/ollama:0.40.3

Canary für eine neue Modellversion: eine zweite Release im selben Namespace, nur mit einem Pilot-Mandanten. Alle Namen tragen den Release-Namen, die NetworkPolicy trennt per app.kubernetes.io/instance. Im Lab nimmst du dasselbe Modell (Gerendertes Secret: TENANT_KEYS: "acme:lab-key-acme-canary"), beim Kunden zusätzlich --set modelServer.modelImage.tag=<neu>. Zwei Modellserver brauchen 2 × 3 GiB – bei 8 GB Docker-RAM vorher Tag-7-Workloads stoppen.

helm install llm-canary oci://$R/charts/llm-platform --version 0.1.0 --plain-http \
  -n llm-system -f "$C/examples/values-lab-kind.yaml" \
  --set modelServer.persistence.enabled=false \
  --set gateway.tenants.acme=lab-key-acme-canary --set gateway.tenants.globex=null
kubectl -n llm-system get svc -l app.kubernetes.io/component=gateway

Erwartet (gekürzt, kann je nach Version abweichen):

NAME                              TYPE        CLUSTER-IP     PORT(S)
llm-canary-llm-platform-gateway   ClusterIP   10.96.31.7     8080/TCP
llm-llm-platform-gateway          ClusterIP   10.96.144.12   8080/TCP

Der Pilot (ACME) zeigt für 1–2 Tage auf den Canary-Service; du vergleichst Fehlerquote und TTFT p95 (Tag 8, Tag 10). Danach Hauptrelease umstellen – mit automatischem Rückweg:

helm upgrade llm oci://$R/charts/llm-platform --version 0.1.0 --plain-http \
  -n llm-system -f "$C/examples/values-lab-kind.yaml" \
  --set gateway.rateLimit.rps=10 --rollback-on-failure --timeout 10m
helm history llm -n llm-system
helm rollback llm 1 -n llm-system --wait
helm uninstall llm-canary -n llm-system

Erwartet (gekürzt, kann je nach Version abweichen):

REVISION  STATUS      CHART               APP VERSION  DESCRIPTION
1         superseded  llm-platform-0.1.0  0.1.0        Install complete
2         deployed    llm-platform-0.1.0  0.1.0        Upgrade complete
Rollback was a success! Happy Helming!
release "llm-canary" uninstalled

Warum? --rollback-on-failure (Helm 4, früher --atomic) wartet auf Readiness und rollt selbst zurück. Das PVC hat helm.sh/resource-policy: keep – Modelle überleben Rollback und Uninstall, ein Rollback lädt nichts neu. Bewusst nicht im Chart: Schema-Migrationen. Was nicht zurückrollbar ist, gehört in die Release Notes.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Support-Bundle und Kundenkommunikation

Der Kunde führt ein Skript aus und schickt dir eine Datei – ohne Secrets:

cat > support-bundle.sh <<'EOF'
#!/usr/bin/env bash
# support-bundle.sh <namespace> [release] – Diagnosedaten ohne Secrets sammeln
set -uo pipefail
ns=${1:?Namespace}; rel=${2:-llm}
dir="support-$ns-$(date -u +%Y%m%dT%H%M%SZ)"
mkdir -p "$dir"

redact() {
  sed -E \
    -e 's/(Bearer )[^ "]+/\1***REDACTED***/g' \
    -e 's/(lab-key-|sk-|hf_)[A-Za-z0-9_-]+/\1***REDACTED***/g' \
    -e 's/((TOKEN|token|PASSWORD|password)["]?[:=] *"?)[^ ",}]+/\1***REDACTED***/g' \
    -e 's/((SECRET_?KEY|api_?key)["]?[:=] *"?)[^ ",}]+/\1***REDACTED***/g'
}
run() { # run <datei> <befehl...>
  local f="$dir/$1"; shift
  echo "\$ $*" > "$f"
  "$@" 2>&1 | redact >> "$f"
}

run versions.txt     kubectl version
run nodes.txt        kubectl describe nodes
run helm-status.txt  helm status "$rel" -n "$ns"
run helm-history.txt helm history "$rel" -n "$ns"
run helm-values.txt  helm get values "$rel" -n "$ns"
run pods.txt         kubectl get pods,svc,pvc,netpol -n "$ns" -o wide
run describe.txt     kubectl describe pods -n "$ns"
run events.txt       kubectl get events -n "$ns" --sort-by=.lastTimestamp
run secrets.txt      kubectl get secrets -n "$ns"   # nur Namen, nie Inhalte
for p in $(kubectl get pods -n "$ns" -o name 2>/dev/null); do
  run "logs-${p#pod/}.txt" kubectl logs -n "$ns" "$p" --all-containers \
    --timestamps --tail=2000
  run "logs-${p#pod/}-previous.txt" kubectl logs -n "$ns" "$p" \
    --all-containers --previous --tail=500
done

if grep -rqE 'lab-key-[a-z0-9]|Bearer [A-Za-z0-9]{8}' "$dir"; then
  echo "✘ möglicher Klartext-Key gefunden – Bundle NICHT verschicken" >&2
  exit 1
fi
tar -czf "$dir.tar.gz" "$dir" && rm -rf "$dir"
sha256sum "$dir.tar.gz"
EOF
chmod +x support-bundle.sh && shellcheck support-bundle.sh
printf 'acme: lab-key-acme\nAuthorization: Bearer lab-key-globex\n%s\n' \
  '{"token":"abc123","tenant":"acme"}' > probe.txt
source <(sed -n '/^redact()/,/^}/p' support-bundle.sh) && redact < probe.txt
./support-bundle.sh llm-system llm

Erwartet (Redaktion live mit BSD- und GNU-sed geprüft; Hash variiert):

acme: lab-key-***REDACTED***
Authorization: Bearer ***REDACTED***
{"token":"***REDACTED***","tenant":"acme"}
67f0431b8737bd262143ed1900a0008bd70c7f759056ebb0f48fde469ca8556a  support-llm-system-...

Warum helm get values ohne --all? Nur die vom Kunden gesetzten Werte, keine Defaults – kürzer und ohne Lab-Keys aus values.yaml. Die Schlussprüfung ist dein Sicherheitsnetz: Ein Bundle mit Key wird gar nicht erst gepackt.

Wartungsankündigung (Vorlage, 5 Werktage vorher):

Betreff: [Wartung] LLM-Plattform – Upgrade auf 0.2.0 am <Datum>, 18–19 Uhr
Was:        Neue Modellversion ministral-3 (Q8), Ollama 0.40.3
Auswirkung: Bis zu 5 min keine Antworten (Modell lädt neu), Clients mit Retry
Vorbereitung bei Ihnen: Bundle 0.2.0 einspielen, Preflight grün melden
Rückweg:    helm rollback (< 10 min), Modelle bleiben erhalten
Kontakt:    <Bereitschaft / Ticket-Queue>

RCA-Kurzfassung (Details im Post-Mortem, Tag 11):

Betreff: [RCA] Störung LLM-Plattform <Datum> 09:12–09:47 (35 min)
Auswirkung: 41 % der Anfragen von Mandant ACME mit HTTP 503
Ursache:    Modellserver OOMKilled – num_ctx 32k bei 4 GiB Limit (KV-Cache)
Behebung:   num_ctx 8k, Limit 8 GiB; Alarm auf OOMKill ergänzt
Vorbeugung: Sizing-Check (Tag 5) als Preflight im Chart, Upgrade-Test mit Kundenwerten

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/sre-lab/tag14
check "Chart lint ok" "helm lint --strict ~/sre-lab/code/llm-platform-chart"
check "Bundle-Prüfsummen ok" "(cd bundle && sha256sum -c --quiet SHA256SUMS)"
check "Signatur Modellliste ok" "cosign verify-blob --key cosign.pub \
  --insecure-ignore-tlog --bundle bundle/SHA256SUMS-model.sigstore.json \
  bundle/SHA256SUMS-model"
check "Chart in Kunden-Registry" "crane digest --insecure \
  127.0.0.1:5050/charts/llm-platform:0.1.0"
check "Preflight ohne ✘" "! grep -q . <(while read -r i; do
  crane digest --insecure \$i >/dev/null 2>&1 || echo \$i; done < preflight.txt)"
check "Support-Bundle redigiert" "! (tar -xzOf support-llm-system-*.tar.gz \
  | grep -q 'lab-key-[a-z]')"

Erwartet:

✔ Chart lint ok
✔ Bundle-Prüfsummen ok
✔ Signatur Modellliste ok
✔ Chart in Kunden-Registry
✔ Preflight ohne ✘
✔ Support-Bundle redigiert

Challenge

Schreibe verify-bundle.sh, das der Kunde vor jeder Installation laufen lässt: Signatur der Modellliste prüfen, alle Prüfsummen prüfen, bei Fehler mit Exit-Code ≠ 0 abbrechen. Teste es mit einem absichtlich beschädigten Blob.

Hinweis: Die Reihenfolge zählt – erst die Signatur, dann den Listen vertrauen.

Lösung

cat > bundle/verify-bundle.sh <<'EOF'
#!/usr/bin/env bash
# verify-bundle.sh <cosign.pub> – im Bundle-Verzeichnis ausführen
set -euo pipefail
pub=${1:?Pfad zu cosign.pub}
cosign verify-blob --key "$pub" --insecure-ignore-tlog \
  --bundle SHA256SUMS-model.sigstore.json SHA256SUMS-model >/dev/null 2>&1 \
  || { echo "✘ Signatur ungültig"; exit 2; }
echo "✔ Signatur"
(cd model && sha256sum -c --quiet ../SHA256SUMS-model) \
  || { echo "✘ Modelldateien beschädigt"; exit 3; }
echo "✔ Modell"
sha256sum -c --quiet SHA256SUMS || { echo "✘ Bundle unvollständig"; exit 4; }
echo "✔ Bundle"
EOF
chmod +x bundle/verify-bundle.sh
cd bundle && ./verify-bundle.sh ../cosign.pub
B=$(ls model/models/blobs | head -1)
cp "model/models/blobs/$B" /tmp/blob.bak
printf 'x' >> "model/models/blobs/$B"
./verify-bundle.sh ../cosign.pub; echo "exit=$?"
cp /tmp/blob.bak "model/models/blobs/$B" && cd ..

Erwartet:

✔ Signatur
✔ Modell
✔ Bundle
✔ Signatur
models/blobs/sha256-12d848b3c47b...: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match
✘ Modelldateien beschädigt
exit=3

verify-bundle.sh steht nicht in SHA256SUMS (erst danach erzeugt) – lege es in der nächsten Bundle-Version vor die Prüfsummenbildung.

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • „Wie lieferst du an einen Kunden ohne Internet?” – Ein versioniertes Bundle: Chart (OCI), Images per skopeo als Archive, Gewichte mit SHA-256-Liste, Liste mit cosign signiert; beim Kunden Preflight gegen seine Registry, dann helm install nur mit global.imageRegistry.
  • „Und Updates?” – Neues Bundle, gerenderter Diff vor dem Upgrade, Canary als zweite Release für einen Pilot-Mandanten, --rollback-on-failure, Modelle im PVC mit resource-policy: keep.
  • „Wie debuggst du ohne Zugang?” – Support-Bundle-Skript mit Redaktion und Selbstprüfung; Kunde schickt Hash mit, du arbeitest reproduzierbar.
  • Brücke aus deiner Praxis (an deine Projekte anpassen): „Vault/OpenBao bei regulierten Kunden heißt auch dort: Artefakte spiegeln, signieren, Vier-Augen-Freigabe. Für Modelle kommt nur das Volumen dazu.”
  • Datenhoheit als Verkaufsargument: offene Gewichte (Apache 2.0) laufen in der EU-Region oder im eigenen Rechenzentrum, Prompts verlassen das Haus nicht.

Enterprise-Notiz

  • GPU-Verfügbarkeit ist der Engpass: Kapazität früh reservieren, Chart für CPU, eine GPU-Klasse und Multi-GPU (Tensor Parallel) testen; Fallback-Modell (kleiner, quantisiert) einplanen.
  • Data Residency: Region und Speicherort der Logs/Traces festlegen (Prompts können personenbezogen sein), Aufbewahrung und Redaktion vertraglich regeln.
  • EU-Souveränität: europäische Clouds (z. B. OVHcloud, Scaleway, STACKIT, IONOS) oder On-Prem; Abhängigkeiten von US-Registries (Docker Hub, ghcr.io) im Bundle auflösen.
  • Hybrid: gleiche Chart-Version in Cloud und On-Prem, nur Values unterscheiden sich; Bundles reproduzierbar per CI bauen und mit SBOM (Tag 13) ausliefern.
  • Registry beim Kunden ist meist Harbor, Quay oder Artifactory mit TLS und Pull-Secret – imagePullSecrets und eigene CA im Lab einmal durchspielen.