Tag 14: Linkerd mit Helm und hochverfügbar
Ziel: Auf
westläuft Linkerd aus zwei Helm-Releases mit einer Values-Datei, so hochverfügbar, wie ein einzelner Node es zulässt, und du weißt, was zur echten HA fehlt. · Dauer: ca. 75 min · Voraussetzung: Tag 12
Briefing
- Produktion installiert Linkerd per Helm: Chart
linkerd-crdsund Chartlinkerd-control-plane, beide aus dem Repolinkerd-edge. Die Chartversion2026.11.1gehört zuedge-26.11.1. - Du installierst heute bewusst die ältere
Edge-Version. Tag 15 macht daraus ein echtes Upgrade auf
edge-26.11.2. - Anders als
linkerd installerzeugt Helm keine Zertifikate. Trust Anchor und Issuer bringst du mit. values-ha.yamlaus dem Chart macht die Control Plane hochverfügbar: drei Replikas, PodDisruptionBudgets, harte Anti-Affinity, Ressourcen. Auf einem Node geht davon nur ein Teil.
west (ein Node)
Helm-Release linkerd-crds 10 CRDs
Helm-Release linkerd-control-plane identity, destination, proxy-injector (je 2)
values-ha.yaml + values-west.yaml
vorab per kubectl: Namespace, ConfigMap trust-roots, Secret identity-issuer
Drill 1: Bestand aufnehmen
Bevor du etwas entfernst, schreibst du auf, was läuft. Auf
west stehen seit Tag 12 die Control Plane und die
Multicluster-Extension, beide per CLI installiert:
mkdir -p ~/linkerd/tag14 && cd ~/linkerd/tag14
linkerd --context west version --short
kubectl --context west get pods -A -l linkerd.io/control-plane-ns=linkerd
kubectl --context west get crd -o name | grep -c linkerd
kubectl --context west get links -A
helm --kube-context west list -AErwartet (gekürzt):
edge-26.11.2
edge-26.11.2
NAMESPACE NAME READY STATUS
linkerd-multicluster linkerd-gateway-6f49696d65-d75nl 2/2 Running
linkerd-multicluster linkerd-local-service-mirror-759d5b44f8-dqvbn 2/2 Running
linkerd linkerd-destination-9d599d975-kxzpn 4/4 Running
linkerd linkerd-identity-5bd7546d55-njdz5 2/2 Running
linkerd linkerd-proxy-injector-68dccb95cf-cfhmn 2/2 Running
11
No resources found
NAME NAMESPACE REVISION ... CHART APP VERSION
gateway-api-crd kube-system 1 ... gateway-api-crd-1.6.301 v1.6.3
Das Label linkerd.io/control-plane-ns trägt jeder Pod
mit Proxy. Hier sind es nur Linkerd-Pods – keine App auf
west hängt am Mesh. Elf CRDs: die zehn aus Tag 1 plus
links.multicluster.linkerd.io. Kein Link aktiv. Das einzige
Helm-Release gehört k3s (Gateway-API-CRDs) und bleibt.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Sauber entfernen
Erst die Extension, dann die Control Plane – umgekehrt zur
Installation. Beide uninstall-Befehle geben nur ein
Manifest aus, gelöscht wird mit kubectl:
linkerd --context west multicluster uninstall > mc-uninstall.yaml
grep '^kind:' mc-uninstall.yaml | sort | uniq -c
kubectl --context west delete -f mc-uninstall.yaml | tail -2
linkerd --context west uninstall > cp-uninstall.yaml
grep -c '^kind: CustomResourceDefinition' cp-uninstall.yaml
kubectl --context west delete -f cp-uninstall.yaml | tail -1Erwartet (gekürzt):
3 kind: ClusterRole
2 kind: ClusterRoleBinding
1 kind: CustomResourceDefinition
1 kind: Namespace
customresourcedefinition.apiextensions.k8s.io "links.multicluster.linkerd.io" deleted
namespace "linkerd-multicluster" deleted
10
namespace "linkerd" deleted
Achtung:
linkerd uninstalllöscht auch die CRDs – und damit jedeServer-,AuthorizationPolicy- undHTTPRoute-Ressource von Linkerd im Cluster. Aufostwären die Policies aus Tag 6 weg. Aufwestgibt es keine.
kubectl --context west get ns
kubectl --context west get crd -o name | grep -c linkerd
kubectl --context west get mutatingwebhookconfigurations,validatingwebhookconfigurationsErwartet:
NAME STATUS AGE
default Active 4h39m
kube-node-lease Active 4h39m
kube-public Active 4h39m
kube-system Active 4h39m
0
No resources found
Keine Namespaces, keine CRDs, keine Webhooks. Ein vergessener Webhook wäre das gefährlichste Überbleibsel: Er würde Pods abweisen, deren Injector nicht mehr existiert.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Repo, Chartversion, passende CLI
helm repo add linkerd-edge https://helm.linkerd.io/edge
helm repo update linkerd-edge
helm search repo linkerd-edge/linkerd-control-plane --versions | head -4Erwartet:
"linkerd-edge" has been added to your repositories
Update Complete. ...
NAME CHART VERSION APP VERSION DESCRIPTION
linkerd-edge/linkerd-control-plane 2026.11.2 edge-26.11.2 Linkerd gives you…
linkerd-edge/linkerd-control-plane 2026.11.1 edge-26.11.1 Linkerd gives you…
Die Chartversion ist die Edge-Nummer mit vierstelligem Jahr:
edge-26.11.1 → 2026.11.1. Die Spalte
APP VERSION bestätigt es. linkerd-crds hat
keine App-Version, nur dieselbe Chartversion.
Die CLI soll zur Control Plane passen. In /usr/local/bin
liegt edge-26.11.2 und bleibt dort. Die ältere legst du
daneben:
ARCH=$(dpkg --print-architecture)
V=edge-26.11.1
curl -fsSLO \
https://github.com/linkerd/linkerd2/releases/download/$V/linkerd2-cli-$V-linux-$ARCH
sha256sum linkerd2-cli-$V-linux-$ARCH
curl -fsSL https://api.github.com/repos/linkerd/linkerd2/releases/tags/$V \
| grep -o '"digest": "sha256:[0-9a-f]*"'
install -m 0755 linkerd2-cli-$V-linux-$ARCH linkerd-$V
rm linkerd2-cli-$V-linux-$ARCH
./linkerd-$V version --clientErwartet (gekürzt):
f69701bec37964905d1cb06097e201ddf71e136824c3817f9a94a405fcbb6a07 linkerd2-cli-edge-...
...
"digest": "sha256:f69701bec37964905d1cb06097e201ddf71e136824c3817f9a94a405fcbb6a07"
...
Client version: edge-26.11.1
Bis Tag 15 nutzt du für west
./linkerd-edge-26.11.1.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Zertifikate vorab
Zwei Wege sind pragmatisch:
- Issuer-Zertifikat und Schlüssel als Helm-Werte
(
--set-file). Dann steht der private Schlüssel im Release-Secret von Helm, in jeder Revision. - Issuer als Secret vorab anlegen und dem Chart sagen, dass es von
außen kommt. So arbeitet cert-manager an Tag 5 auf
ost.
Du nimmst den zweiten Weg, aber ohne cert-manager: west
hat keinen, und für einen Labor-Cluster reicht ein Issuer mit einem Jahr
Laufzeit. Der Gewinn: Kein Schlüssel in Helm, und ein späterer Wechsel
zu cert-manager ändert keine Zeile in den Values.
step certificate create identity.linkerd.cluster.local issuer.crt issuer.key \
--profile intermediate-ca --not-after 8760h --no-password --insecure \
--ca ../tag05/ca.crt --ca-key ../tag05/ca.key
chmod 600 issuer.key
step certificate verify issuer.crt --roots ../tag05/ca.crt && echo verify-okErwartet:
Your certificate has been saved in issuer.crt.
Your private key has been saved in issuer.key.
verify-ok
Den Namespace legt das Chart nicht an (nur
linkerd install tut das). Du brauchst ihn vorher, mit den
Labels, die die CLI setzen würde:
cat > ns.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
name: linkerd
annotations: {linkerd.io/inject: disabled}
labels:
linkerd.io/is-control-plane: "true"
linkerd.io/control-plane-ns: linkerd
config.linkerd.io/admission-webhooks: disabled
pod-security.kubernetes.io/enforce: privileged
EOF
kubectl --context west apply -f ns.yaml
kubectl --context west -n linkerd create configmap linkerd-identity-trust-roots \
--from-file=ca-bundle.crt=../tag05/ca.crt
kubectl --context west -n linkerd create secret generic linkerd-identity-issuer \
--type=kubernetes.io/tls --from-file=tls.crt=issuer.crt \
--from-file=tls.key=issuer.key --from-file=ca.crt=../tag05/ca.crt
kubectl --context west -n linkerd get secret linkerd-identity-issuer \
-o jsonpath='{.data}' | jq -r 'keys[]'Erwartet:
namespace/linkerd created
configmap/linkerd-identity-trust-roots created
secret/linkerd-identity-issuer created
ca.crt
tls.crt
tls.key
config.linkerd.io/admission-webhooks: disabled ist kein
Schmuck: Ohne das Label schickt Kubernetes auch die Pods der Control
Plane durch den Injector. Mit webhookFailurePolicy: Fail
(gleich in den HA-Werten) könnte die Control Plane dann nicht mehr
starten, wenn kein Injector läuft – sie wartet auf sich selbst.
Achtung: Im Test entstand das Secret zuerst mit
kubectl create secret tls, also ohneca.crt. Linkerd startete, aberlinkerd checkmeldete:× certificate config is valid – key ca.crt containing the trust anchors needs to exist in secret linkerd-identity-issuer if --identity-external-issuer=true. cert-manager legtca.crtvon selbst ab, von Hand musst du daran denken.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Helm-Installation mit HA-Werten
values-ha.yaml steckt im Chart-Archiv:
helm pull linkerd-edge/linkerd-control-plane --version 2026.11.1 --untar
cp linkerd-control-plane/values-ha.yaml . && rm -rf linkerd-control-plane
grep -vE '^ *#|^$' values-ha.yamlErwartet (gekürzt):
enablePodDisruptionBudget: true
controller:
podDisruptionBudget:
maxUnavailable: 1
deploymentStrategy:
rollingUpdate:
maxUnavailable: 1
maxSurge: 25%
enablePodAntiAffinity: true
proxy:
resources:
cpu:
request: 100m
memory:
limit: 250Mi
request: 20Mi
controllerReplicas: 3
...
webhookFailurePolicy: Fail
highAvailability: true
Deine eigenen Werte kommen in eine zweite Datei. Helm liest
-f von links nach rechts, die letzte gewinnt:
cat > values-west.yaml <<'EOF'
# Linkerd auf west – Tag 14
identity:
externalCA: true # Trust Anchor kommt aus der ConfigMap
issuer:
scheme: kubernetes.io/tls # Issuer kommt aus dem Secret
controllerReplicas: 2 # ein Node: 3 wären Etikettenschwindel
identityTrustAnchorsPEM: | # nur für Checks, siehe unten
EOF
sed 's/^/ /' ../tag05/ca.crt >> values-west.yaml
helm --kube-context west install linkerd-crds linkerd-edge/linkerd-crds \
--version 2026.11.1 -n linkerd
helm --kube-context west install linkerd-control-plane \
linkerd-edge/linkerd-control-plane --version 2026.11.1 -n linkerd \
-f values-ha.yaml -f values-west.yaml
sleep 60
kubectl --context west -n linkerd get podsErwartet (gekürzt):
NAME: linkerd-crds
STATUS: deployed
REVISION: 1
...
NAME: linkerd-control-plane
STATUS: deployed
REVISION: 1
NAME READY STATUS RESTARTS AGE
linkerd-destination-74c76f978-gqdz7 0/4 Pending 0 60s
linkerd-destination-74c76f978-xqc2m 4/4 Running 0 60s
linkerd-identity-659b86db9d-24vkr 0/2 Pending 0 60s
linkerd-identity-659b86db9d-n6mmd 2/2 Running 0 60s
linkerd-proxy-injector-59c4d59bf9-8xmmn 2/2 Running 0 60s
linkerd-proxy-injector-59c4d59bf9-kqrjd 0/2 Pending 0 60s
Keine Werte per --set: Alles steht in Dateien, die du
versionierst und vergleichst. Auch der Trust Anchor steht darin,
eingerückt per sed – warum, wenn er doch schon in der
ConfigMap liegt? Mit externalCA: true legt das Chart die
ConfigMap nicht an, die Proxys lesen den Anchor aus deiner.
identityTrustAnchorsPEM landet aber in
linkerd-config, und dort liest
linkerd multicluster check die Anchors beider Cluster:
kubectl --context west -n linkerd get configmap linkerd-config \
-o jsonpath='{.data.values}' | grep -A1 '^identityTrustAnchorsPEM'Erwartet:
identityTrustAnchorsPEM: |
-----BEGIN CERTIFICATE-----
Ohne die Zeile steht dort identityTrustAnchorsPEM: "".
Linkerd läuft trotzdem, mTLS auch. Aber sobald ein Link zu
ost existiert (Tag 12, Drill 6), meldet der Check
× clusters share trust anchors für west – ein
Fehlalarm, der echte Fehler verdeckt. Bei einer Anchor-Rotation (Tag 5)
pflegst du beide Stellen.
Zurück zu den Pods: Jeweils der zweite hängt. Warum?
kubectl --context west -n linkerd get events --field-selector reason=FailedScheduling \
| tail -1
kubectl --context west -n linkerd get pdbErwartet (gekürzt):
… 0/1 nodes are available: 1 node(s) didn't match pod anti-affinity rules. …
NAME MIN AVAILABLE MAX UNAVAILABLE ALLOWED DISRUPTIONS AGE
linkerd-dst N/A 1 0 69s
linkerd-identity N/A 1 0 69s
linkerd-proxy-injector N/A 1 0 69s
Die Anti-Affinity aus values-ha.yaml ist
hart (requiredDuringScheduling…,
topologyKey: kubernetes.io/hostname): nie zwei gleiche Pods
auf einem Node. Mit einem Node bleibt Replika 2 für immer
Pending. Und das PDB erlaubt jetzt null
Unterbrechungen – ein kubectl drain würde hängen.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Was auf einem Node fehlt
Du schaltest die harte Anti-Affinity ab und spielst die Werte ein:
cat >> values-west.yaml <<'EOF'
enablePodAntiAffinity: false # ein Node: harte Anti-Affinity blockiert Replika 2
EOF
helm --kube-context west upgrade linkerd-control-plane \
linkerd-edge/linkerd-control-plane --version 2026.11.1 -n linkerd \
-f values-ha.yaml -f values-west.yaml
sleep 120
kubectl --context west -n linkerd get podsErwartet (gekürzt):
REVISION: 2
NAME READY STATUS RESTARTS AGE
linkerd-destination-74c76f978-xqc2m 4/4 Running 0 6m28s
linkerd-destination-755db578f5-5z7m7 0/4 Pending 0 115s
linkerd-destination-755db578f5-ps572 0/4 Pending 0 116s
...
Die neuen Pods haben keine Anti-Affinity mehr – und hängen trotzdem.
Das Event verrät es:
didn't satisfy existing pods anti-affinity rules. Die Regel
der alten, laufenden Pods gilt auch für Neuankömmlinge.
Der Rollout wartet auf neue Pods, die neuen Pods warten auf das Ende der
alten. Auflösen geht nur mit einer kurzen Pause der Control Plane:
kubectl --context west -n linkerd scale deploy --all --replicas=0
kubectl --context west -n linkerd scale deploy --all --replicas=2
kubectl --context west -n linkerd rollout status deploy --timeout=240s
kubectl --context west -n linkerd get pods
kubectl --context west -n linkerd get pdbErwartet (gekürzt):
deployment "linkerd-destination" successfully rolled out
deployment "linkerd-identity" successfully rolled out
deployment "linkerd-proxy-injector" successfully rolled out
NAME READY STATUS RESTARTS AGE
linkerd-destination-755db578f5-hq2zk 4/4 Running 0 13s
linkerd-destination-755db578f5-j9fm4 4/4 Running 0 13s
linkerd-identity-868c4f959b-qxfq5 2/2 Running 0 13s
linkerd-identity-868c4f959b-ws2c2 2/2 Running 0 13s
linkerd-proxy-injector-7bc79fd998-dmctq 2/2 Running 0 13s
linkerd-proxy-injector-7bc79fd998-tl4dn 2/2 Running 0 13s
NAME MIN AVAILABLE MAX UNAVAILABLE ALLOWED DISRUPTIONS AGE
linkerd-dst N/A 1 1 7m7s
linkerd-identity N/A 1 1 7m7s
linkerd-proxy-injector N/A 1 1 7m7s
Skalieren auf 0 setzt auch die alten ReplicaSets auf 0, beim Hochskalieren bekommt nur das neue Pods. Laufende Proxys merken davon nichts (Challenge). Die ehrliche Bilanz:
| Wert aus values-ha.yaml | auf west | Folge |
|---|---|---|
controllerReplicas: 3 |
2 | Pod-Ausfall überbrückt, Node-Ausfall nicht |
enablePodAntiAffinity: true |
aus | beide Replikas auf demselben Node |
PDB maxUnavailable: 1 |
an | Drain evakuiert, aber wohin? Es gibt keinen Node |
Ressourcen, webhookFailurePolicy: Fail |
an | wie in Produktion |
Echte HA braucht mindestens drei Nodes, besser drei Zonen: Die
Chart-Regel bevorzugt zusätzlich verschiedene
topology.kubernetes.io/zone.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Prüfen und eine Testapp
helm --kube-context west get values linkerd-control-plane -n linkerd | head -12
helm --kube-context west get values linkerd-control-plane -n linkerd --all \
| grep -E '^(controllerReplicas|enablePodAntiAffinity|webhookFailurePolicy|linkerdV)'
helm --kube-context west get values linkerd-control-plane -n linkerd --all \
| grep -c 'PRIVATE KEY'Erwartet:
USER-SUPPLIED VALUES:
controller:
podDisruptionBudget:
maxUnavailable: 1
controllerReplicas: 2
controllerResources:
cpu:
limit: ""
request: 100m
memory:
limit: 250Mi
request: 50Mi
controllerReplicas: 2
enablePodAntiAffinity: false
linkerdVersion: edge-26.11.1
webhookFailurePolicy: Fail
0
Ohne --all siehst du nur, was du mitgegeben hast – beide
Dateien zusammengeführt. --all zeigt die berechneten Werte
inklusive Chart-Vorgaben. Kein privater Schlüssel im Release. Dann der
Check mit der passenden CLI:
./linkerd-edge-26.11.1 --context west check 2>&1 | grep -v '^√' | grep -v '^-*$'Erwartet (gekürzt):
kubernetes-api
...
linkerd-version
‼ cli is up-to-date
is running version 26.11.1 but the latest edge version is 26.11.2
control-plane-version
‼ control plane is up-to-date
is running version 26.11.1 but the latest edge version is 26.11.2
linkerd-control-plane-proxy
‼ control plane proxies are up-to-date
some proxies are not running the current version:
* linkerd-destination-755db578f5-hq2zk (edge-26.11.1)
...
linkerd-ha-checks
linkerd-extension-checks
Status check results are √
Die Warnungen sind gewollt: Es gibt eine neuere Edge-Version (Tag
15). Der Abschnitt linkerd-ha-checks existiert nur wegen
highAvailability: true und prüft
multiple replicas of control plane pods. Jetzt eine App,
nach dem Muster von Tag 12:
cat > app.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
name: tag14
annotations: {linkerd.io/inject: enabled}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: helper, namespace: tag14}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: last, namespace: tag14}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: helper, namespace: tag14}
spec:
replicas: 2
selector: {matchLabels: {app: helper}}
template:
metadata: {labels: {app: helper}}
spec:
serviceAccountName: helper
containers:
- name: helper
image: ghcr.io/mccutchen/go-httpbin:2.26.0
ports: [{containerPort: 8080, name: http}]
readinessProbe:
httpGet: {path: /status/200, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: helper, namespace: tag14}
spec:
selector: {app: helper}
ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last, namespace: tag14}
spec:
replicas: 1
selector: {matchLabels: {app: last}}
template:
metadata: {labels: {app: last}}
spec:
serviceAccountName: last
containers:
- name: last
image: docker.io/curlimages/curl:8.23.0
command: [sh, -c]
args:
- |
while true; do
code=$(curl -s -o /dev/null -w "%{http_code}" -m 5 http://helper/get)
echo "$(date +%T) /get $code"
sleep 0.5
done
EOF
kubectl --context west apply -f app.yaml
kubectl --context west -n tag14 rollout status deploy --timeout=180s
sleep 60
kubectl --context west -n tag14 logs deploy/last -c last --since=55s \
| awk '{print $2, $3}' | sort | uniq -c
./linkerd-edge-26.11.1 --context west identity -n tag14 -l app=helper \
| grep -E 'Issuer:|Subject:'
kubectl --context west -n tag14 get pod -l app=helper -o \
jsonpath='{.items[0].spec.initContainers[?(@.name=="linkerd-proxy")].resources}'Erwartet (gekürzt):
deployment "helper" successfully rolled out
deployment "last" successfully rolled out
101 /get 200
Issuer: CN=identity.linkerd.cluster.local
Subject: CN=helper.tag14.serviceaccount.identity.linkerd.cluster.local
{"limits":{"memory":"250Mi"},"requests":{"cpu":"100m","memory":"20Mi"}}
Das Mesh läuft: 100 % Erfolg, ein Proxy-Zertifikat vom Issuer aus
Drill 4. Und die HA-Werte gelten nicht nur für die Control Plane: Jeder
Proxy bekommt 100m CPU Request und 250 MiB Limit. Bei hundert Pods sind
das zehn reservierte CPU-Kerne – rechne das nach, bevor du
values-ha.yaml ungeprüft übernimmst.
Zum Schluss, was webhookFailurePolicy: Fail
bedeutet:
kubectl --context west -n linkerd scale deploy linkerd-proxy-injector --replicas=0
kubectl --context west -n tag14 rollout restart deploy/last
sleep 15
kubectl --context west -n tag14 get events --field-selector reason=FailedCreate \
-o jsonpath='{.items[-1:].message}{"\n"}'
kubectl --context west -n linkerd scale deploy linkerd-proxy-injector --replicas=2
kubectl --context west -n tag14 rollout status deploy/last --timeout=180sErwartet (umbrochen):
Error creating: Internal error occurred: failed calling webhook
"linkerd-proxy-injector.linkerd.io": failed to call webhook: Post
"https://linkerd-proxy-injector.linkerd.svc:443/?timeout=10s": no endpoints available
for service "linkerd-proxy-injector"
deployment.apps/linkerd-proxy-injector scaled
deployment "last" successfully rolled out
Ohne Injector entsteht in gemeshten Namespaces kein
neuer Pod – lieber keiner als einer ohne Proxy, der an Policies
vorbeiläuft. Genau deshalb braucht der Injector mehrere Replikas. Mit
der Vorgabe Ignore wären Pods ohne Proxy gestartet.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Von linkerd install zu Helm
ost läuft seit Tag 1 per CLI. Einfach
helm install darüber geht nicht. Helm übernimmt keine
Objekte, die ihm nicht gehören. Das siehst du gefahrlos auf
west, wo die CRDs einem anderen Release gehören:
helm --kube-context west install probe linkerd-edge/linkerd-crds \
--version 2026.11.1 -n linkerd --dry-run=serverErwartet (umbrochen, gekürzt):
Error: INSTALLATION FAILED: unable to continue with install: CustomResourceDefinition
"authorizationpolicies.policy.linkerd.io" in namespace "" exists and cannot be imported
into the current release: invalid ownership metadata; annotation validation error: key
"meta.helm.sh/release-name" must equal "probe": current value is "linkerd-crds"
Auf ost fehlen die Helm-Metadaten ganz. Der Weg dorthin
(nur beschrieben, nicht auf ost ausgeführt – dort laufen
die übrigen Tage):
- Alle Objekte von Linkerd mit
meta.helm.sh/release-name,meta.helm.sh/release-namespaceund dem Labelapp.kubernetes.io/managed-by=Helmversehen. Dann übernimmthelm installsie, statt abzubrechen. Erst die CRDs, dann die Control Plane, beide mit derselben Version, die läuft. - Die Values aus dem Bestand ableiten, nicht raten.
linkerd-config-overrideszeigt, was die CLI geändert hat – aber an Tag 5 stand dort sogar der private Schlüssel des alten Issuers. Nichts davon ungeprüft in eine Values-Datei kopieren. identity.externalCA: trueundidentity.issuer.scheme: kubernetes.io/tlsmüssen rein. Fehlen sie, rendert das Chart eigene Objektelinkerd-identity-issuerundlinkerd-identity-trust-rootsund überschreibt, was cert-manager und trust-manager verwalten. Das Mesh verliert seinen Anchor.- Vorher
helm templatemitkubectl diffvergleichen. Der Diff darf nur Labels und Annotationen zeigen – plus die Webhook-Zertifikate, die jedes Rendern neu erzeugt (wielinkerd upgradean Tag 5: Die Control Plane startet einmal neu). - Danach nie wieder
linkerd upgradeauf diesem Cluster. Extensions (viz, multicluster) sind eigene Releases und brauchen denselben Umzug.
Achtung: Der risikoärmere Weg ist oft der, den du heute auf
westgegangen bist: neu installieren. Laufende Proxys überstehen eine kurze Pause der Control Plane (Challenge), aberlinkerd uninstalllöscht die CRDs und damit alle Policies. Die musst du vorher sichern und danach wieder anwenden.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig Chart- und App-Version beider Linkerd-Releases auf
west. Zeitziel: 15 s - Zeig, welche Werte du selbst gesetzt hast. Zeitziel: 15 s
- Zeig alle Revisionen der Control Plane. Zeitziel: 20 s
- Rendere die Control Plane lokal und zähl die Replikas. Zeitziel: 60 s
Lösung
helm --kube-context west list -n linkerd
helm --kube-context west get values linkerd-control-plane -n linkerd
helm --kube-context west history linkerd-control-plane -n linkerd
helm template linkerd-control-plane linkerd-edge/linkerd-control-plane \
--version 2026.11.1 -n linkerd -f values-ha.yaml -f values-west.yaml \
| grep -E '^ replicas:' | sort | uniq -cErwartet (gekürzt):
NAME NAMESPACE REVISION … CHART APP VERSION
linkerd-control-plane linkerd 2 … linkerd-control-plane-2026.11.1 edge-26.11.1
linkerd-crds linkerd 1 … linkerd-crds-2026.11.1
...
REVISION UPDATED STATUS CHART … DESCRIPTION
1 Thu Nov 19 20:04:09 2026 superseded linkerd-control-plan… Install complete
2 Thu Nov 19 20:08:41 2026 deployed linkerd-control-plan… Upgrade complete
3 replicas: 2
helm template braucht keinen Cluster – ideal für Reviews
in der CI.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
./linkerd-edge-26.11.1 --context west check 2>&1 | tail -1Erwartet:
Status check results are √
kubectl --context west -n linkerd get deployErwartet:
NAME READY UP-TO-DATE AVAILABLE AGE
linkerd-destination 2/2 2 2 12m
linkerd-identity 2/2 2 2 12m
linkerd-proxy-injector 2/2 2 2 12m
helm --kube-context west list -n linkerd -o json | jq -r '.[].chart'Erwartet:
linkerd-control-plane-2026.11.1
linkerd-crds-2026.11.1
Challenge
Schalte die komplette Control Plane eine Minute lang ab. Beweise,
dass der Verkehr in tag14 trotzdem fließt, und stell den
alten Zustand wieder her.
Hinweis: Proxys haben ihr Zertifikat (24 h) und die Endpunkte schon im Speicher.
Lösung
kubectl --context west -n linkerd scale deploy --all --replicas=0
sleep 60
kubectl --context west -n tag14 logs deploy/last -c last --since=55s \
| awk '{print $2, $3}' | sort | uniq -c
kubectl --context west -n linkerd scale deploy --all --replicas=2
kubectl --context west -n linkerd rollout status deploy --timeout=180s | tail -1Erwartet:
deployment.apps/linkerd-destination scaled
deployment.apps/linkerd-identity scaled
deployment.apps/linkerd-proxy-injector scaled
101 /get 200
...
deployment "linkerd-proxy-injector" successfully rolled out
Kein einziger Fehler. Was ohne Control Plane nicht geht: neue Pods (Drill 7), neue Zertifikate, Änderungen an Endpunkten und Policies. Ein Ausfall von Minuten ist harmlos, einer von Stunden nicht – HA kauft dir Zeit, keine Unverwundbarkeit.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
kubectl --context west delete namespace tag14Die Control Plane bleibt, Tag 15 aktualisiert sie.
linkerd-edge-26.11.1, die Values-Dateien und
issuer.key (0600) bleiben in
~/linkerd/tag14/.
Interview-Notiz
- Warum Helm statt
linkerd install? Versionierte Values,helm historyundrollback, Diffs vor dem Einspielen, GitOps-tauglich. Dafür musst du Zertifikate und Namespace selbst mitbringen. - Was macht
values-ha.yaml? Drei Replikas, PDBmaxUnavailable: 1, harte Anti-Affinity pro Node, Ressourcen für Control Plane und Proxys, WebhookFail. - Warum
webhookFailurePolicy: Fail? Ohne Injector entstehen keine Pods ohne Proxy. Der Preis: Der Injector muss hochverfügbar sein, und der Namespace der Control Plane brauchtconfig.linkerd.io/admission-webhooks: disabled.
Enterprise-Notiz
- Values-Dateien ins Git, Installation per Argo CD oder Flux. CRDs als eigenes Release bzw. eigene Sync-Welle vor der Control Plane.
- Issuer von cert-manager (Tag 5), mit
identity.externalCAundidentity.issuer.schemevon Anfang an – nie Schlüssel als Helm-Wert. Den öffentlichen Anchor dagegen auch alsidentityTrustAnchorsPEMins Git, aus derselben Quelle wie die ConfigMap. - HA heißt: drei Nodes in drei Zonen, harte Anti-Affinity an, PDBs an. Ein Single-Node-Cluster ist mit keiner Values-Datei hochverfügbar.
- Proxy-Ressourcen aus
values-ha.yamlgegen die Pod-Zahl rechnen; pro Workload überschreibbar mitconfig.linkerd.io/proxy-cpu-requestund Verwandten. - Den Namespace
linkerdmit Labels per GitOps anlegen, nicht per--create-namespace.