Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Linkerd mit Helm und hochverfügbar

Ziel: Auf west lä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-crds und Chart linkerd-control-plane, beide aus dem Repo linkerd-edge. Die Chartversion 2026.11.1 gehört zu edge-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 install erzeugt Helm keine Zertifikate. Trust Anchor und Issuer bringst du mit.
  • values-ha.yaml aus 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 -A

Erwartet (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 -1

Erwartet (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 uninstall löscht auch die CRDs – und damit jede Server-, AuthorizationPolicy- und HTTPRoute-Ressource von Linkerd im Cluster. Auf ost wären die Policies aus Tag 6 weg. Auf west gibt es keine.

kubectl --context west get ns
kubectl --context west get crd -o name | grep -c linkerd
kubectl --context west get mutatingwebhookconfigurations,validatingwebhookconfigurations

Erwartet:

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 -4

Erwartet:

"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 --client

Erwartet (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-ok

Erwartet:

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 ohne ca.crt. Linkerd startete, aber linkerd check meldete: × 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 legt ca.crt von 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.yaml

Erwartet (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 pods

Erwartet (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 pdb

Erwartet (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 pods

Erwartet (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 pdb

Erwartet (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=180s

Erwartet (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=server

Erwartet (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-namespace und dem Label app.kubernetes.io/managed-by=Helm versehen. Dann übernimmt helm install sie, 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-overrides zeigt, 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: true und identity.issuer.scheme: kubernetes.io/tls müssen rein. Fehlen sie, rendert das Chart eigene Objekte linkerd-identity-issuer und linkerd-identity-trust-roots und überschreibt, was cert-manager und trust-manager verwalten. Das Mesh verliert seinen Anchor.
  • Vorher helm template mit kubectl diff vergleichen. Der Diff darf nur Labels und Annotationen zeigen – plus die Webhook-Zertifikate, die jedes Rendern neu erzeugt (wie linkerd upgrade an Tag 5: Die Control Plane startet einmal neu).
  • Danach nie wieder linkerd upgrade auf diesem Cluster. Extensions (viz, multicluster) sind eigene Releases und brauchen denselben Umzug.

Achtung: Der risikoärmere Weg ist oft der, den du heute auf west gegangen bist: neu installieren. Laufende Proxys überstehen eine kurze Pause der Control Plane (Challenge), aber linkerd uninstall löscht die CRDs und damit alle Policies. Die musst du vorher sichern und danach wieder anwenden.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig Chart- und App-Version beider Linkerd-Releases auf west. Zeitziel: 15 s
  2. Zeig, welche Werte du selbst gesetzt hast. Zeitziel: 15 s
  3. Zeig alle Revisionen der Control Plane. Zeitziel: 20 s
  4. 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 -c

Erwartet (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 -1

Erwartet:

Status check results are √
kubectl --context west -n linkerd get deploy

Erwartet:

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 -1

Erwartet:

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 tag14

Die 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 history und rollback, Diffs vor dem Einspielen, GitOps-tauglich. Dafür musst du Zertifikate und Namespace selbst mitbringen.
  • Was macht values-ha.yaml? Drei Replikas, PDB maxUnavailable: 1, harte Anti-Affinity pro Node, Ressourcen für Control Plane und Proxys, Webhook Fail.
  • Warum webhookFailurePolicy: Fail? Ohne Injector entstehen keine Pods ohne Proxy. Der Preis: Der Injector muss hochverfügbar sein, und der Namespace der Control Plane braucht config.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.externalCA und identity.issuer.scheme von Anfang an – nie Schlüssel als Helm-Wert. Den öffentlichen Anchor dagegen auch als identityTrustAnchorsPEM ins 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.yaml gegen die Pod-Zahl rechnen; pro Workload überschreibbar mit config.linkerd.io/proxy-cpu-request und Verwandten.
  • Den Namespace linkerd mit Labels per GitOps anlegen, nicht per --create-namespace.