Skip to content
Hands-on IT IT Drills

Day 14: Linkerd with Helm and Highly Available

Goal: On west, Linkerd runs from two Helm releases with a values file, as highly available as a single node allows, and you know what is missing for real HA. · Duration: approx. 75 min · Prerequisite: Day 12

Briefing

  • Production installs Linkerd via Helm: the chart linkerd-crds and the chart linkerd-control-plane, both from the repo linkerd-edge. Chart version 2026.11.1 belongs to edge-26.11.1.
  • Today you deliberately install the older edge version. Day 15 turns this into a real upgrade to edge-26.11.2.
  • Unlike linkerd install, Helm generates no certificates. You bring the trust anchor and issuer yourself.
  • values-ha.yaml from the chart makes the Control Plane highly available: three replicas, PodDisruptionBudgets, hard anti-affinity, resources. On a single node, only part of that works.
 west (one node)
 Helm release linkerd-crds           10 CRDs
 Helm release linkerd-control-plane  identity, destination, proxy-injector (2 each)
   values-ha.yaml + values-west.yaml
 up front via kubectl: Namespace, ConfigMap trust-roots, Secret identity-issuer

Drill 1: Take Inventory

Before you remove anything, you write down what is running. Since Day 12, west has been running the Control Plane and the multicluster extension, both installed via CLI:

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

Expected (abridged):

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

Every Pod with a proxy carries the label linkerd.io/control-plane-ns. Here it is only Linkerd Pods – no app on west is part of the mesh. Eleven CRDs: the ten from Day 1 plus links.multicluster.linkerd.io. No active link. The only Helm release belongs to k3s (Gateway API CRDs) and stays.

Save your progress? Sign up for free

Drill 2: Remove Cleanly

First the extension, then the Control Plane – the reverse of the installation. Both uninstall commands only print a manifest; deletion happens with 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

Expected (abridged):

      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

Warning: linkerd uninstall also deletes the CRDs – and with them every Linkerd Server, AuthorizationPolicy, and HTTPRoute resource in the cluster. On ost, the policies from Day 6 would be gone. On west, there are none.

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

Expected:

NAME              STATUS   AGE
default           Active   4h39m
kube-node-lease   Active   4h39m
kube-public       Active   4h39m
kube-system       Active   4h39m
0
No resources found

No namespaces, no CRDs, no webhooks. A forgotten webhook would be the most dangerous leftover: it would reject Pods whose injector no longer exists.

Save your progress? Sign up for free

Drill 3: Repo, Chart Version, Matching 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

Expected:

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

The chart version is the edge number with a four-digit year: edge-26.11.1 → 2026.11.1. The APP VERSION column confirms it. linkerd-crds has no app version, only the same chart version.

The CLI should match the Control Plane. /usr/local/bin holds edge-26.11.2, and it stays there. You put the older one next to it:

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

Expected (abridged):

f69701bec37964905d1cb06097e201ddf71e136824c3817f9a94a405fcbb6a07  linkerd2-cli-edge-...
...
"digest": "sha256:f69701bec37964905d1cb06097e201ddf71e136824c3817f9a94a405fcbb6a07"
...
Client version: edge-26.11.1

Until Day 15, you use ./linkerd-edge-26.11.1 for west.

Save your progress? Sign up for free

Drill 4: Certificates Up Front

Two approaches are pragmatic:

  • Issuer certificate and key as Helm values (--set-file). Then the private key sits in Helm’s release Secret, in every revision.
  • Create the issuer as a Secret up front and tell the chart that it comes from outside. This is how cert-manager works on ost on Day 5.

You take the second approach, but without cert-manager: west has none, and for a lab cluster an issuer valid for one year is enough. The benefit: no key in Helm, and a later switch to cert-manager changes not a single line in the 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

Expected:

Your certificate has been saved in issuer.crt.
Your private key has been saved in issuer.key.
verify-ok

The chart does not create the namespace (only linkerd install does). You need it beforehand, with the labels the CLI would set:

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[]'

Expected:

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 is not decoration: without this label, Kubernetes also sends the Control Plane Pods through the injector. With webhookFailurePolicy: Fail (coming up in the HA values), the Control Plane could then no longer start if no injector is running – it would wait for itself.

Warning: In testing, the Secret was first created with kubectl create secret tls, that is, without ca.crt. Linkerd started, but linkerd check reported: × 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 stores ca.crt on its own; by hand, you have to remember it.

Save your progress? Sign up for free

Drill 5: Helm Installation with HA Values

values-ha.yaml is inside the chart archive:

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

Expected (abridged):

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

Your own values go into a second file. Helm reads -f from left to right; the last one wins:

cat > values-west.yaml <<'EOF'
# Linkerd on west – Day 14
identity:
  externalCA: true          # trust anchor comes from the ConfigMap
  issuer:
    scheme: kubernetes.io/tls   # issuer comes from the Secret
controllerReplicas: 2       # one node: 3 would be false advertising
identityTrustAnchorsPEM: |  # only for checks, see below
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

Expected (abridged):

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

No values via --set: everything lives in files that you version and compare. The trust anchor is in there too, indented with sed – why, when it is already in the ConfigMap? With externalCA: true the chart does not create the ConfigMap; the proxies read the anchor from yours. But identityTrustAnchorsPEM ends up in linkerd-config, and that is where linkerd multicluster check reads the anchors of both clusters:

kubectl --context west -n linkerd get configmap linkerd-config \
  -o jsonpath='{.data.values}' | grep -A1 '^identityTrustAnchorsPEM'

Expected:

identityTrustAnchorsPEM: |
  -----BEGIN CERTIFICATE-----

Without the line it says identityTrustAnchorsPEM: "". Linkerd still runs, and so does mTLS. But as soon as a link to ost exists (Day 12, Drill 6), the check reports × clusters share trust anchors for west – a false alarm that hides real errors. When you rotate the anchor (Day 5), you maintain both places.

Back to the Pods: in each case, the second one is stuck. Why?

kubectl --context west -n linkerd get events --field-selector reason=FailedScheduling \
  | tail -1
kubectl --context west -n linkerd get pdb

Expected (abridged):

… 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

The anti-affinity from values-ha.yaml is hard (requiredDuringScheduling…, topologyKey: kubernetes.io/hostname): never two identical Pods on one node. With one node, replica 2 stays Pending forever. And the PDB now allows zero disruptions – a kubectl drain would hang.

Save your progress? Sign up for free

Drill 6: What Is Missing on One Node

You turn off the hard anti-affinity and apply the values:

cat >> values-west.yaml <<'EOF'
enablePodAntiAffinity: false  # one node: hard anti-affinity blocks replica 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

Expected (abridged):

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

The new Pods no longer have anti-affinity – and are stuck anyway. The event gives it away: didn't satisfy existing pods anti-affinity rules. The rule of the old, running Pods also applies to newcomers. The rollout waits for new Pods, the new Pods wait for the old ones to go away. The only way out is a short pause of the 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

Expected (abridged):

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

Scaling to 0 also sets the old ReplicaSets to 0; when scaling up, only the new one gets Pods. Running proxies notice nothing of this (Challenge). The honest balance:

Value from values-ha.yaml on west Consequence
controllerReplicas: 3 2 Pod failure bridged, node failure not
enablePodAntiAffinity: true off both replicas on the same node
PDB maxUnavailable: 1 on drain evicts, but to where? There is no other node
Resources, webhookFailurePolicy: Fail on as in production

Real HA needs at least three nodes, preferably three zones: the chart rule additionally prefers different topology.kubernetes.io/zone values.

Save your progress? Sign up for free

Drill 7: Verify, and a Test App

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'

Expected:

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

Without --all, you only see what you supplied – both files merged. --all shows the computed values including the chart defaults. No private key in the release. Then the check with the matching CLI:

./linkerd-edge-26.11.1 --context west check 2>&1 | grep -v '^√' | grep -v '^-*$'

Expected (abridged):

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 √

The warnings are intended: there is a newer edge version (Day 15). The linkerd-ha-checks section exists only because of highAvailability: true and checks multiple replicas of control plane pods. Now an app, following the pattern from Day 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}'

Expected (abridged):

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

The mesh works: 100 % success, a proxy certificate from the issuer from Drill 4. And the HA values do not apply only to the Control Plane: every proxy gets a 100m CPU request and a 250 MiB limit. With a hundred Pods, that is ten reserved CPU cores – do the math before you adopt values-ha.yaml unchecked.

Finally, what webhookFailurePolicy: Fail means:

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

Expected (wrapped):

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

Without the injector, no new Pod is created in meshed namespaces – better none than one without a proxy that bypasses policies. That is exactly why the injector needs multiple replicas. With the default Ignore, Pods would have started without a proxy.

Save your progress? Sign up for free

Drill 8: From linkerd install to Helm

ost has been running via CLI since Day 1. Simply running helm install on top does not work. Helm does not adopt objects it does not own. You can see this safely on west, where the CRDs belong to a different release:

helm --kube-context west install probe linkerd-edge/linkerd-crds \
  --version 2026.11.1 -n linkerd --dry-run=server

Expected (wrapped, abridged):

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"

On ost, the Helm metadata is missing entirely. The way there (only described, not executed on ost – the remaining days run there):

  • Add meta.helm.sh/release-name, meta.helm.sh/release-namespace, and the label app.kubernetes.io/managed-by=Helm to all Linkerd objects. Then helm install adopts them instead of aborting. First the CRDs, then the Control Plane, both with the same version that is running.
  • Derive the values from what exists, do not guess. linkerd-config-overrides shows what the CLI changed – but on Day 5 it even contained the private key of the old issuer. Do not copy any of it into a values file unchecked.
  • identity.externalCA: true and identity.issuer.scheme: kubernetes.io/tls must be included. If they are missing, the chart renders its own linkerd-identity-issuer and linkerd-identity-trust-roots objects and overwrites what cert-manager and trust-manager manage. The mesh loses its anchor.
  • Compare helm template with kubectl diff beforehand. The diff may only show labels and annotations – plus the webhook certificates, which every render regenerates (like linkerd upgrade on Day 5: the Control Plane restarts once).
  • Afterwards, never run linkerd upgrade on this cluster again. Extensions (viz, multicluster) are separate releases and need the same migration.

Warning: The lower-risk path is often the one you took on west today: reinstall. Running proxies survive a short pause of the Control Plane (Challenge), but linkerd uninstall deletes the CRDs and with them all policies. You have to back them up beforehand and reapply them afterwards.

Save your progress? Sign up for free

Exercise: Speed Drills

  1. Show the chart and app versions of both Linkerd releases on west. Target time: 15 s
  2. Show which values you set yourself. Target time: 15 s
  3. Show all revisions of the Control Plane. Target time: 20 s
  4. Render the Control Plane locally and count the replicas. Target time: 60 s

Solution

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

Expected (abridged):

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 needs no cluster – ideal for reviews in CI.

Save your progress? Sign up for free

Checkpoint

./linkerd-edge-26.11.1 --context west check 2>&1 | tail -1

Expected:

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

Expected:

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'

Expected:

linkerd-control-plane-2026.11.1
linkerd-crds-2026.11.1

Challenge

Shut down the entire Control Plane for one minute. Prove that traffic in tag14 keeps flowing anyway, and restore the previous state.

Hint: Proxies already have their certificate (24 h) and the endpoints in memory.

Solution

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

Expected:

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

Not a single error. What does not work without the Control Plane: new Pods (Drill 7), new certificates, changes to endpoints and policies. An outage of minutes is harmless, one of hours is not – HA buys you time, not invulnerability.

Save your progress? Sign up for free

Cleanup

kubectl --context west delete namespace tag14

The Control Plane stays; Day 15 upgrades it. linkerd-edge-26.11.1, the values files, and issuer.key (0600) remain in ~/linkerd/tag14/.

Interview Note

  • Why Helm instead of linkerd install? Versioned values, helm history and rollback, diffs before applying, GitOps-ready. In return, you have to bring the certificates and the namespace yourself.
  • What does values-ha.yaml do? Three replicas, PDB maxUnavailable: 1, hard anti-affinity per node, resources for the Control Plane and proxies, webhook Fail.
  • Why webhookFailurePolicy: Fail? Without the injector, no Pods without a proxy get created. The price: the injector must be highly available, and the Control Plane namespace needs config.linkerd.io/admission-webhooks: disabled.

Enterprise Note

  • Values files in Git, installation via Argo CD or Flux. CRDs as a separate release or a separate sync wave before the Control Plane.
  • Issuer from cert-manager (Day 5), with identity.externalCA and identity.issuer.scheme from the start – never keys as Helm values. The public anchor, on the other hand, also goes into Git as identityTrustAnchorsPEM, from the same source as the ConfigMap.
  • HA means: three nodes in three zones, hard anti-affinity on, PDBs on. A single-node cluster is not highly available with any values file.
  • Calculate the proxy resources from values-ha.yaml against the Pod count; they can be overridden per workload with config.linkerd.io/proxy-cpu-request and relatives.
  • Create the linkerd namespace with labels via GitOps, not via --create-namespace.