Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Drei-Wege-Merge, Server-Side Apply und Helm 4

Ziel: Verstehen, wie Helm 3 und Helm 4 mit Änderungen von Hand umgehen, wem ein Feld gehört, und einen Helm-3-Release ohne Überraschung auf Helm 4 umstellen. · Dauer: ca. 75 min · Voraussetzung: Tag 13

Briefing

  • Helm 3 patcht client-seitig mit einem Drei-Wege-Merge aus altem Manifest, Live-Objekt und neuem Manifest. Drift in Feldern des Charts wird still überschrieben.
  • Helm 4 installiert neu mit Server-Side Apply (SSA). Jedes Feld hat einen Field Manager; will Helm ein fremdes Feld ändern, gibt es einen Konflikt.
  • Ein Release behält seine Methode (--server-side=auto). Helm-3-Releases bleiben client-seitig, bis du umstellst.
  • Helm 3 bekommt Sicherheitsupdates bis 10. Februar 2027. Beide Versionen lesen dieselben Release-Secrets.
  • Plugins haben in Helm 4 Typen (cli/v1, getter/v1, postrenderer/v1) und werden signiert geprüft.

Drill 1: Helm 3 daneben installieren

Für den Vergleich kommt Helm 3.22.1 als helm3 neben Helm 4 – mit Prüfsumme, wie in Tag 0:

# auf prod
mkdir -p ~/helm/tag14 && cd ~/helm/tag14
ARCH=$(dpkg --print-architecture)
curl -fsSLO https://get.helm.sh/helm-v3.22.1-linux-$ARCH.tar.gz
curl -fsSLO https://get.helm.sh/helm-v3.22.1-linux-$ARCH.tar.gz.sha256sum
sha256sum -c helm-v3.22.1-linux-$ARCH.tar.gz.sha256sum
tar -xzf helm-v3.22.1-linux-$ARCH.tar.gz --strip-components=1 linux-$ARCH/helm
sudo install -m 755 helm /usr/local/bin/helm3 && rm helm
helm3 version --short
helm version --short
helm3 list -A -q
diff <(helm env HELM_PLUGINS) <(helm3 env HELM_PLUGINS) && echo "gleicher Plugin-Ordner"

Erwartet:

helm-v3.22.1-linux-amd64.tar.gz: OK
v3.22.1+gd6c1a0e
v4.3.2+g8346aaa
gateway-api-crd
helper
notes
notes-crds
traefik
traefik-crd
zot
gleicher Plugin-Ordner

Helm 3 sieht alle Releases, die Helm 4 angelegt hat: Das Speicherformat (Secrets sh.helm.release.v1.*) ist gleich. Beide teilen sich auch Repositories, Registry-Login und den Plugin-Ordner – das wird in Drill 7 wichtig.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Drift unter Helm 3 – der Drei-Wege-Merge

Ein kleines Wegwerf-Chart, damit notes unberührt bleibt:

# auf prod
cd ~/helm/tag14 && mkdir -p drift/templates
cat > drift/Chart.yaml <<'EOF'
# drift/Chart.yaml – Stand Tag 14
apiVersion: v2
name: drift
version: 0.1.0
appVersion: "2.26.0"
EOF
cat > drift/values.yaml <<'EOF'
# drift/values.yaml – Stand Tag 14
replicaCount: 2
logLevel: info
EOF
cat > drift/templates/deployment.yaml <<'EOF'
{{/* drift/templates/deployment.yaml – Stand Tag 14 */}}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-drift
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app.kubernetes.io/instance: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app.kubernetes.io/instance: {{ .Release.Name }}
    spec:
      containers:
        - name: httpbin
          image: ghcr.io/mccutchen/go-httpbin:{{ .Chart.AppVersion }}
          env:
            - name: LOG_LEVEL
              value: {{ .Values.logLevel | quote }}
          resources:
            requests:
              cpu: 10m
              memory: 16Mi
EOF

Mit Helm 3 installieren, dann nachts „von Hand reparieren“ und ohne jede Änderung upgraden:

# auf prod
helm3 install d3 ./drift -n tag14 --create-namespace --wait | grep STATUS
kubectl -n tag14 scale deploy d3-drift --replicas=4
kubectl -n tag14 set env deploy/d3-drift LOG_LEVEL=debug EXTRA=hand
kubectl -n tag14 label deploy d3-drift notfall=ja
helm3 upgrade d3 ./drift -n tag14 --wait | grep REVISION
F='{.spec.replicas} {.metadata.labels.notfall} '
F+='{range .spec.template.spec.containers[0].env[*]}{.name}={.value} {end}{"\n"}'
kubectl -n tag14 get deploy d3-drift -o jsonpath="$F"

Erwartet:

STATUS: deployed
deployment.apps/d3-drift scaled
deployment.apps/d3-drift env updated
deployment.apps/d3-drift labeled
REVISION: 2
2 ja LOG_LEVEL=info EXTRA=hand
Feld alt / neu (Chart) live nach helm3 upgrade
replicas 2 / 2 4 2 – Drift überschrieben
LOG_LEVEL info / info debug info – Drift überschrieben
EXTRA – / – hand hand – bleibt
Label notfall – / – ja ja – bleibt

Helm 3 vergleicht das neue Manifest mit dem Live-Objekt und setzt alles zurück, was das Chart rendert. Was das Chart nicht kennt, bleibt. Die Skalierung der Nacht ist weg – ohne Warnung.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Dieselbe Drift unter Helm 4

# auf prod
helm install d4 ./drift -n tag14 --wait | grep STATUS
kubectl -n tag14 scale deploy d4-drift --replicas=4
kubectl -n tag14 set env deploy/d4-drift LOG_LEVEL=debug EXTRA=hand
kubectl -n tag14 label deploy d4-drift notfall=ja
helm upgrade d4 ./drift -n tag14 --wait
kubectl -n tag14 get deploy d4-drift -o jsonpath="$F"

Erwartet (gekürzt):

STATUS: deployed
deployment.apps/d4-drift scaled
deployment.apps/d4-drift env updated
deployment.apps/d4-drift labeled
Error: UPGRADE FAILED: conflict occurred while applying object tag14/d4-drift apps/v1, K
ind=Deployment: Apply failed with 2 conflicts: conflicts with "kubectl" with subresource
 "scale" using apps/v1:
- .spec.replicas
conflicts with "kubectl-set" using apps/v1:
- .spec.template.spec.containers[name="httpbin"].env[name="LOG_LEVEL"].value
4 ja LOG_LEVEL=debug EXTRA=hand

Vor der Fehlermeldung schreibt Helm 4 dieselbe Meldung noch einmal als level=WARN msg="upgrade failed". Statt still zu überschreiben, verweigert SSA das Upgrade und nennt Feld und Field Manager. Wer was besitzt, steht in managedFields:

# auf prod
kubectl -n tag14 get deploy d4-drift --show-managed-fields -o json \
  | jq -r '.metadata.managedFields[]
    | [.manager, .operation, .subresource // "-"] | @tsv'
helm upgrade d4 ./drift -n tag14 --force-conflicts --wait | grep REVISION
kubectl -n tag14 get deploy d4-drift -o jsonpath="$F"
helm history d4 -n tag14 -o json | jq -r '.[] | "\(.revision) \(.status)"'

Erwartet:

helm    Apply   -
kubectl Update  scale
kubectl-set     Update  -
kubectl-label   Update  -
k3s     Update  status
REVISION: 3
2 ja LOG_LEVEL=info EXTRA=hand
1 superseded
2 failed
3 deployed

Apply ist SSA, Update ein klassischer Schreibzugriff. kubectl scale schreibt über die Subresource scale, kubectl set env heißt kubectl-set. --force-conflicts holt sich die umkämpften Felder zurück; EXTRA und das Label gehören weiter ihren Managern und bleiben. Das Ergebnis gleicht Helm 3 – aber erst, nachdem jemand bewusst entschieden hat. Tag 19 zeigt denselben Konflikt im Betrieb.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Ein Helm-3-Release unter Helm 4

# auf prod
helm get metadata d3 -n tag14 | grep APPLY_METHOD
helm get metadata d4 -n tag14 | grep APPLY_METHOD
kubectl -n tag14 scale deploy d3-drift --replicas=3
helm upgrade d3 ./drift -n tag14 --wait | grep REVISION
helm get metadata d3 -n tag14 | grep APPLY_METHOD
kubectl -n tag14 get deploy d3-drift -o jsonpath='{.spec.replicas}{"\n"}'
kubectl -n tag14 get deploy d3-drift --show-managed-fields -o json \
  | jq -r '.metadata.managedFields[] | select(.manager=="helm") | .operation'

Erwartet:

APPLY_METHOD: client-side apply (defaulted)
APPLY_METHOD: server-side apply
deployment.apps/d3-drift scaled
REVISION: 3
APPLY_METHOD: client-side apply
2
Update

Helm 3 speichert keine Methode – Helm 4 nimmt dann client-side an („defaulted“). Mit dem Standard --server-side=auto bleibt Helm 4 dabei und benimmt sich wie Helm 3: Die Drift ist ohne Konflikt überschrieben. Umstellen ist ein Flag:

# auf prod
helm upgrade d3 ./drift -n tag14 --server-side=true --wait | grep REVISION
helm get metadata d3 -n tag14 | grep APPLY_METHOD
kubectl -n tag14 get deploy d3-drift --show-managed-fields -o json \
  | jq -r '.metadata.managedFields[] | select(.manager=="helm") | .operation'

Erwartet:

REVISION: 4
APPLY_METHOD: server-side apply
Apply

Helm hat seinen alten Update-Eintrag in einen Apply-Eintrag überführt; ab jetzt gilt auto = server-side. Vorsicht im Übergang, wenn noch jemand Helm 3 benutzt:

# auf prod
helm3 upgrade d4 ./drift -n tag14 --wait | grep REVISION
helm get metadata d4 -n tag14 | grep APPLY_METHOD
helm3 rollback d4 3 -n tag14 | tail -1
helm get metadata d4 -n tag14 | grep APPLY_METHOD
helm upgrade d4 ./drift -n tag14 --server-side=true --wait | grep REVISION

Erwartet:

REVISION: 4
APPLY_METHOD: client-side apply (defaulted)
Rollback was a success! Happy Helming!
APPLY_METHOD: client-side apply (defaulted)
REVISION: 6

Ein einziges helm3 upgrade stellt einen SSA-Release still auf client-side zurück – auch ein Rollback mit Helm 3 auf eine SSA-Revision. Deshalb: erst alle Pipelines und Admin-Rechner auf Helm 4, dann umstellen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Field Manager und Autoscaler

Das übliche Chart-Muster: Ist ein HPA an, rendert das Chart kein replicas. Version 0.2.0 von drift:

# auf prod
sed -i 's/^version: 0.1.0/version: 0.2.0/' drift/Chart.yaml
cat > drift/values.yaml <<'EOF'
# drift/values.yaml – Stand Tag 14
replicaCount: 2
logLevel: info
autoscaling:
  enabled: false
  minReplicas: 3
  maxReplicas: 5
EOF
cat > drift/templates/deployment.yaml <<'EOF'
{{/* drift/templates/deployment.yaml – Stand Tag 14 */}}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-drift
spec:
  {{- if not .Values.autoscaling.enabled }}
  replicas: {{ .Values.replicaCount }}
  {{- end }}
  selector:
    matchLabels:
      app.kubernetes.io/instance: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app.kubernetes.io/instance: {{ .Release.Name }}
    spec:
      containers:
        - name: httpbin
          image: ghcr.io/mccutchen/go-httpbin:{{ .Chart.AppVersion }}
          env:
            - name: LOG_LEVEL
              value: {{ .Values.logLevel | quote }}
          resources:
            requests:
              cpu: 10m
              memory: 16Mi
EOF
cat > drift/templates/hpa.yaml <<'EOF'
{{/* drift/templates/hpa.yaml – Stand Tag 14 */}}
{{- if .Values.autoscaling.enabled }}
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: {{ .Release.Name }}-drift
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: {{ .Release.Name }}-drift
  minReplicas: {{ .Values.autoscaling.minReplicas }}
  maxReplicas: {{ .Values.autoscaling.maxReplicas }}
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 80
{{- end }}
EOF
helm template d3 ./drift -s templates/deployment.yaml --set autoscaling.enabled=true \
  | sed -n 3,8p

Erwartet:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: d3-drift
spec:
  selector:

Jetzt einen laufenden Release auf HPA umstellen:

# auf prod
helm install h1 ./drift -n tag14 --wait | grep STATUS
helm upgrade h1 ./drift -n tag14 --set autoscaling.enabled=true | grep REVISION
sleep 20
kubectl -n tag14 get events -o custom-columns=MELDUNG:.message \
  --field-selector involvedObject.kind=Deployment,involvedObject.name=h1-drift

Erwartet:

STATUS: deployed
REVISION: 2
MELDUNG
Scaled up replica set h1-drift-654cfb8d45 from 0 to 2
Scaled down replica set h1-drift-654cfb8d45 from 2 to 1
Scaled up replica set h1-drift-654cfb8d45 from 1 to 3

Die Falle: replicas gehörte allein Helm. Rendert Helm das Feld nicht mehr, entfernt SSA es – Kubernetes setzt den Standard 1, und erst der HPA skaliert wieder hoch. Unter Last fehlen in diesem Moment Pods. (Das Labor hat keinen metrics-server; der HPA kann trotzdem auf minReplicas hochsetzen.) Sauber geht es, wenn das Feld vorher den Besitzer wechselt:

# auf prod
helm install h2 ./drift -n tag14 --wait | grep STATUS
kubectl -n tag14 scale deploy h2-drift --replicas=3
helm upgrade h2 ./drift -n tag14 --set autoscaling.enabled=true | grep REVISION
sleep 20
kubectl -n tag14 get events -o custom-columns=MELDUNG:.message \
  --field-selector involvedObject.kind=Deployment,involvedObject.name=h2-drift
kubectl -n tag14 get hpa h2-drift

Erwartet (gekürzt):

STATUS: deployed
deployment.apps/h2-drift scaled
REVISION: 2
MELDUNG
Scaled up replica set h2-drift-7bd5c8d666 from 0 to 2
Scaled up replica set h2-drift-7bd5c8d666 from 2 to 3
NAME       REFERENCE             TARGETS              MINPODS   MAXPODS   REPLICAS   ...
h2-drift   Deployment/h2-drift   cpu: <unknown>/80%   3         5         3          ...

kubectl scale übernimmt spec.replicas; Helm gibt beim Upgrade nur noch auf, was ihm nicht mehr gehört – nichts fällt auf 1. Nach demselben Prinzip arbeitet jeder weitere Akteur: Wer ein Feld dauerhaft verwaltet (HPA, VPA, ein Operator), dem darf das Chart es nicht rendern.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Was sich sonst ändert

# auf prod
helm upgrade d4 ./drift -n tag14 --atomic --force --dry-run=client 2>&1 | head -2
helm install weg ./drift -n tag14 --set replicaCount=0 | grep STATUS
helm uninstall weg -n tag14 --keep-history
helm list -n tag14 -q | tr '\n' ' '; echo
helm3 list -n tag14 -q | tr '\n' ' '; echo
helm3 list -n tag14 -q -a | tr '\n' ' '; echo
mkdir -p dur/templates && printf 'apiVersion: v2\nname: dur\nversion: 0.1.0\n' \
  > dur/Chart.yaml
cat > dur/templates/cm.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata:
  name: dur
data:
  sekunden: {{ durationSeconds "2m" | quote }}
EOF
helm template dur ./dur | tail -1
helm3 template dur ./dur 2>&1 | head -1

Erwartet:

Flag --atomic has been deprecated, use --rollback-on-failure instead
Flag --force has been deprecated, use --force-replace instead
STATUS: deployed
release "weg" uninstalled
d3 d4 h1 h2 weg
d3 d4 h1 h2
d3 d4 h1 h2 weg
  sekunden: "120"
Error: parse error at (dur/templates/cm.yaml:6): function "durationSeconds" not defined
Helm 3 Helm 4 Tag
--atomic, --force --rollback-on-failure, --force-replace 13, 19
--wait = alles bereit --wait=watcher (kstatus), Standard hookOnly 13
list nur deployed/failed, -a für alle list zeigt jeden Status 1
Post-Renderer = Programm Post-Renderer = Plugin 14
client-side Patch SSA für neue Releases 14

Charts, die Duration-Funktionen (neu in 4.3, Tag 7) nutzen, rendern unter Helm 3 nicht mehr. Ein Chart, das beide Versionen bedienen muss, verzichtet darauf oder setzt in Chart.yaml eine Annotation mit der Mindestversion als Doku.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Ein Post-Renderer als Plugin

Ein Post-Renderer bekommt das gerenderte YAML auf stdin und gibt es verändert aus – hier setzt Kustomize (in kubectl enthalten) ein Label team auf alles:

# auf prod
cd ~/helm/tag14 && mkdir -p team-label
cat > team-label/render.sh <<'EOF'
#!/bin/sh
# team-label/render.sh – Stand Tag 14
set -e
dir=$(mktemp -d)
cat > "$dir/all.yaml"
cat > "$dir/kustomization.yaml" <<'KEOF'
resources: [all.yaml]
labels:
  - pairs: {team: plattform}
    includeSelectors: false
KEOF
kubectl kustomize "$dir"
rm -rf "$dir"
EOF
chmod +x team-label/render.sh
helm3 template d4 ./drift --post-renderer ./team-label/render.sh \
  | grep -A1 'labels:' | head -2
helm template d4 ./drift --post-renderer ./team-label/render.sh 2>&1 | fold -w 88

Erwartet:

  labels:
    team: plattform
Error: invalid argument "./team-label/render.sh" for "--post-renderer" flag: plugin: {Na
me:./team-label/render.sh Type:postrenderer/v1} not found

Helm 3 nimmt einen Pfad, Helm 4 nur noch den Namen eines Plugins vom Typ postrenderer/v1. Das Plugin ist eine plugin.yaml neben dem Programm:

# auf prod
cat > team-label/plugin.yaml <<'EOF'
# team-label/plugin.yaml – Stand Tag 14
apiVersion: v1
type: postrenderer/v1
name: team-label
version: 0.1.0
runtime: subprocess
runtimeConfig:
  platformCommand:
    - command: ${HELM_PLUGIN_DIR}/render.sh
EOF
helm plugin install ./team-label
helm plugin list
helm upgrade d4 ./drift -n tag14 --post-renderer team-label --wait | grep REVISION
kubectl -n tag14 get deploy -l team=plattform
helm upgrade d4 ./drift -n tag14 --wait | grep REVISION
kubectl -n tag14 get deploy -l team=plattform
helm3 list -n tag14 -q 2>&1 | head -1 | fold -w 88

Erwartet:

Installing plugin from local directory (development mode)
Installed plugin: team-label
NAME        VERSION  TYPE             APIVERSION  PROVENANCE  SOURCE
team-label  0.1.0    postrenderer/v1  v1          local dev   unknown
REVISION: 7
NAME       READY   UP-TO-DATE   AVAILABLE   AGE
d4-drift   2/2     2            2           4m18s
REVISION: 8
No resources found in tag14 namespace.
failed to load plugins: failed to load plugin at "/home/ubuntu/.local/share/helm/plugins
/team-label/plugin.yaml": error unmarshaling JSON: while decoding JSON: json: unknown fi
eld "apiVersion"

Drei Lehren: Ein lokaler Ordner gilt als „local dev“ und braucht keine Signatur. Helm speichert den Post-Renderer nicht im Release – das nächste Upgrade ohne Flag nimmt das Label wieder weg. Und weil beide Versionen denselben Plugin-Ordner nutzen, beschwert sich Helm 3 über jedes Plugin im neuen Format (apiVersion: v1). Neben Subprozessen kennt Helm 4 auch WebAssembly-Plugins (runtime: extism/v1) – im Labor nicht nötig.

Fortschritt speichern? Kostenlos registrieren

Drill 8: helm-diff signiert installieren

Helm 4 prüft Plugin-Tarballs standardmäßig gegen eine .prov-Datei (Tag 16 zeigt dasselbe für Charts). helm-diff liefert beides:

# auf prod
mkdir -p ~/helm/tag14/diff && cd ~/helm/tag14/diff
ARCH=$(dpkg --print-architecture)
U=https://github.com/databus23/helm-diff/releases/download/v3.15.15
for f in diff-3.15.15-linux-$ARCH.tgz diff-3.15.15-linux-$ARCH.tgz.prov \
  helm-diff_3.15.15_checksums.txt pubkey.asc; do curl -fsSLO $U/$f; done
grep " diff-3.15.15-linux-$ARCH.tgz$" helm-diff_3.15.15_checksums.txt | sha256sum -c
helm plugin install diff-3.15.15-linux-$ARCH.tgz 2>&1 | tail -1 | fold -w 88
gpg --show-keys pubkey.asc | sed -n 2p
gpg --no-default-keyring --keyring ./helm-diff.kbx --import pubkey.asc 2>&1 | tail -1
helm plugin verify diff-3.15.15-linux-$ARCH.tgz --keyring ./helm-diff.kbx
helm plugin install diff-3.15.15-linux-$ARCH.tgz --keyring ./helm-diff.kbx | tail -1
helm plugin list | cut -c1-70

Erwartet (gekürzt):

diff-3.15.15-linux-amd64.tgz: OK
Error: plugin verification failed: reading keybox /home/ubuntu/.gnupg/pubring.kbx: keybo
x contains no OpenPGP keys
      C5645EF47482257A1F806D2BEA17A2A206AFF8CD
gpg:               imported: 1
Signed by: Fabian Ruff (helm-diff release key) <…>
Using Key With Fingerprint: C5645EF47482257A1F806D2BEA17A2A206AFF8CD
Plugin Hash Verified: sha256:504e9941…
Installed plugin: diff
NAME        VERSION  TYPE             APIVERSION  PROVENANCE             SO
diff        3.15.15  cli/v1           legacy      mismatched provenance  un
team-label  0.1.0    postrenderer/v1  v1          local dev              un

Ohne Schlüssel bricht die Installation ab – gut so. Mit eigenem Keyring, der nur den Release-Schlüssel enthält, klappt sie. Den Fingerabdruck vergleichst du mit der Projektseite. „mismatched provenance“ in der Liste ist Kosmetik: Die .prov nennt diff-3.15.15-linux-amd64.tgz, Helm legt die Kopie als diff-3.15.15.tgz ab. legacy heißt: altes Plugin-Format, läuft unter beiden Versionen. Jetzt der Nutzen:

# auf prod
cd ~/helm/tag14
helm diff upgrade d4 ./drift -n tag14 --set logLevel=debug -C 1
kubectl -n tag14 set env deploy/d4-drift LOG_LEVEL=warn
helm diff upgrade d4 ./drift -n tag14 -C 1 --detailed-exitcode; echo "Exit: $?"
helm diff upgrade d4 ./drift -n tag14 -C 1 --three-way-merge --detailed-exitcode
echo "Exit: $?"
helm upgrade d4 ./drift -n tag14 2>&1 | grep '^Error' \
  | grep -o 'conflict with "[a-z-]*"'
helm upgrade d4 ./drift -n tag14 --force-conflicts --wait | grep STATUS

Erwartet (gekürzt):

tag14, d4-drift, Deployment (apps) has changed:
...
              - name: LOG_LEVEL
-               value: "info"
+               value: "debug"
...
deployment.apps/d4-drift env updated
Exit: 0
tag14, d4-drift, Deployment (apps) has changed:
...
          - name: LOG_LEVEL
-           value: warn
+           value: info
...
Error: identified at least one change, exiting with non-zero exit code (…)
Error: plugin "diff" exited with error
Exit: 2
conflict with "kubectl-set"
STATUS: deployed

Ohne --three-way-merge vergleicht helm-diff gespeichertes und neues Manifest – die Drift bleibt unsichtbar (Exit 0). Mit dem Flag vergleicht es gegen das Live-Objekt und zeigt genau das Feld, an dem das SSA-Upgrade danach scheitert. --detailed-exitcode (2 = Änderungen) macht daraus eine Pipeline-Stufe.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeige für alle Releases in tag14 die Apply-Methode. Zeitziel: 30 s
  2. Wer besitzt spec.replicas von h2-drift? Zeitziel: 30 s
  3. Liste die installierten Plugins mit ihrem Typ. Zeitziel: 15 s
  4. Rendert drift mit HPA unter Helm 3 und Helm 4 dasselbe? Leerzeilen ignorieren. Zeitziel: 30 s

Lösung

# auf prod
for r in d3 d4 h1 h2; do echo "$r $(helm get metadata $r -n tag14 | grep APPLY_METHOD)"
done
kubectl -n tag14 get deploy h2-drift --show-managed-fields -o json \
  | jq -r '.metadata.managedFields[]
    | select(.fieldsV1."f:spec"."f:replicas") | .manager'
helm plugin list | awk 'NR>1 {print $1, $3}'
diff -B <(helm template x ./drift --set autoscaling.enabled=true) \
  <(helm3 template x ./drift --set autoscaling.enabled=true 2>/dev/null) \
  && echo identisch

Erwartet:

d3 APPLY_METHOD: server-side apply
d4 APPLY_METHOD: server-side apply
h1 APPLY_METHOD: server-side apply
h2 APPLY_METHOD: server-side apply
kubectl
diff cli/v1
team-label postrenderer/v1
identisch

Ohne -B meldet diff eine Zeile: Helm 4 setzt eine Leerzeile vor jedes ---. Wer in CI Renderings verschiedener Helm-Versionen vergleicht, stolpert darüber.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf prod
helm3 version --short 2>/dev/null

Erwartet: v3.22.1+gd6c1a0e

# auf prod
helm get metadata d3 -n tag14 | grep APPLY_METHOD

Erwartet: APPLY_METHOD: server-side apply – der Helm-3-Release ist umgestellt.

# auf prod
helm diff version

Erwartet: 3.15.15

# auf prod
helm status notes -n notes -o json | jq -r .info.status

Erwartet: deployed – notes wurde heute nicht angefasst.

Challenge

Installiere c mit Helm 3, skaliere es von Hand auf 3 und stelle es mit Helm 4 auf Server-Side Apply um. Vorher soll sichtbar sein, was sich ändert, und in der Historie darf kein gescheiterter Versuch stehen.

Hinweis: helm-diff mit --three-way-merge zeigt die Drift; ein Upgrade kann --server-side=true und --force-conflicts zugleich tragen.

Lösung

# auf prod
helm3 install c ./drift -n tag14 --wait 2>/dev/null | grep STATUS
kubectl -n tag14 scale deploy c-drift --replicas=3
helm diff upgrade c ./drift -n tag14 --three-way-merge -C 0 | grep '^[-+]'
helm upgrade c ./drift -n tag14 --server-side=true --force-conflicts --wait \
  | grep REVISION
helm get metadata c -n tag14 | grep APPLY_METHOD
kubectl -n tag14 get deploy c-drift -o jsonpath='{.spec.replicas}{"\n"}'
kubectl -n tag14 get deploy c-drift --show-managed-fields -o json \
  | jq -r '.metadata.managedFields[] | [.manager, .operation] | @tsv'
helm history c -n tag14 -o json | jq -r '.[] | "\(.revision) \(.status)"'

Erwartet:

STATUS: deployed
deployment.apps/c-drift scaled
-   replicas: 3
+   replicas: 2
REVISION: 2
APPLY_METHOD: server-side apply
2
helm    Apply
k3s     Update
1 superseded
2 deployed

2>/dev/null blendet die Plugin-Warnung von Helm 3 aus Drill 7 aus. Ohne --force-conflicts wäre das erste SSA-Upgrade am Manager kubectl gescheitert – und hätte trotzdem schon die Methode auf server-side gestellt. Der Diff vorher ist die bewusste Entscheidung: Die 3 Replikas der Nacht verschwinden.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf prod
helm uninstall d3 d4 h1 h2 c weg -n tag14
helm plugin uninstall team-label
kubectl delete namespace tag14

Erwartet:

release "d3" uninstalled
release "d4" uninstalled
release "h1" uninstalled
release "h2" uninstalled
release "c" uninstalled
release "weg" uninstalled
Uninstalled plugin: team-label
namespace "tag14" deleted

helm3 und helm-diff bleiben installiert. Am Chart notes hat sich nichts geändert, es gibt keinen Commit.

Interview-Notiz

  • Was passiert mit einer Änderung von Hand beim nächsten helm upgrade? Helm 3: Felder, die das Chart rendert, werden still zurückgesetzt (Drei-Wege-Merge), fremde Felder bleiben. Helm 4 mit SSA: Konflikt mit Feld und Field Manager; erst --force-conflicts übernimmt.
  • Wie migrierst du von Helm 3 auf Helm 4? Erst alle Clients auf Helm 4 (Helm 3 stellt SSA-Releases zurück), Plugins auf das neue Format prüfen, Drift per helm diff --three-way-merge sichtbar machen, dann je Release einmal --server-side=true.
  • Warum rendert ein Chart mit HPA kein replicas? Sonst kämpfen Helm und HPA um das Feld. Beim Umstellen muss das Feld den Besitzer wechseln, sonst fällt es kurz auf 1.

Enterprise-Notiz

  • Helm-Version in Pipelines, Admin-Images und GitOps-Werkzeugen zentral pinnen; ein vergessener Helm-3-Runner macht die Umstellung still rückgängig.
  • SSA-Konflikte sind ein Signal, keine Störung: Statt --force-conflicts pauschal in jede Pipeline zu schreiben, Drift-Prüfung (helm-diff, GitOps-Drift-Erkennung) einbauen und klären, wer das Feld wirklich verwalten soll.
  • Plugins nur signiert installieren, Schlüssel in einem eigenen Keyring pro Plugin, Fingerabdrücke dokumentieren. --verify=false gehört nicht in Automatisierung.
  • Post-Renderer sind unsichtbar für helm get – Ergebnis gehört in den Review (helm get manifest nach dem Deployment), das Plugin in jede Pipeline.
  • Lieber Charts per Digest als per Version installieren, sobald sie in einer Registry liegen (Tag 15).