Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: Zertifikate

Ziel: Das Mesh vertraut einem eigenen Trust Anchor mit zehn Jahren Laufzeit, der Wechsel lief ohne TLS-Fehler, und cert-manager erneuert den Issuer von selbst. · Dauer: ca. 90 min · Voraussetzung: Tag 4

Briefing

  • Drei Ebenen: Der Trust Anchor signiert den Issuer, der Issuer (in linkerd-identity) signiert die 24-Stunden-Zertifikate der Proxys (Tag 3).
  • linkerd install hat an Tag 1 ein einziges selbstsigniertes Zertifikat erzeugt, das beides ist: Anchor und Issuer, ein Jahr gültig, ohne Erneuerung.
  • Den Anchor tauschst du in drei Runden: Bundle aus alt und neu, Issuer tauschen, alten Anchor entfernen. Nach jeder Runde starten alle Proxys neu, weil sie die Anchors nur beim Start lesen.
  • Danach übernimmt cert-manager den Issuer (48 Stunden, automatisch erneuert) und trust-manager die ConfigMap mit dem Anchor.
  • ca.crt und ca.key bleiben als Dateien liegen: Der zweite Cluster an Tag 12 braucht denselben Anchor.
 ca.crt/ca.key (10 Jahre, Datei + Secret in cert-manager)
   └─ signiert ─> linkerd-identity-issuer (48 h, cert-manager)
                    └─ signiert ─> Proxy-Zertifikate (24 h, linkerd-identity)
 trust-manager: ca.crt ─> ConfigMap linkerd/linkerd-identity-trust-roots

Drill 1: Bestand und Werkzeug

mkdir -p ~/linkerd/tag05 && cd ~/linkerd/tag05
kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.data.ca-bundle\.crt}' > original-trust.crt
openssl x509 -in original-trust.crt -noout -subject -issuer -enddate

Erwartet:

subject=CN = identity.linkerd.
issuer=CN = identity.linkerd.
notAfter=Nov 19 11:23:11 2027 GMT

Subject gleich Issuer: selbstsigniert. Dasselbe Zertifikat steckt auch im Secret linkerd-identity-issuer. In einem Jahr stünde das ganze Mesh still.

Für eigene Zertifikate nimmst du die step-CLI von Smallstep:

ARCH=$(dpkg --print-architecture)
V=0.31.0
curl -fsSLO \
  https://github.com/smallstep/cli/releases/download/v$V/step_linux_${V}_$ARCH.tar.gz
curl -fsSL https://api.github.com/repos/smallstep/cli/releases/tags/v$V \
  | grep -c "$(sha256sum step_linux_${V}_$ARCH.tar.gz | cut -d' ' -f1)"
tar xzf step_linux_${V}_$ARCH.tar.gz
sudo install -m 0755 step_$V/bin/step /usr/local/bin/step
step version

Erwartet:

1
Smallstep CLI/0.31.0 (linux/amd64)
Release Date: 2026-09-25T19:53:51Z

Die 1 heißt: Die Prüfsumme deiner Datei steht im Release – wie bei der Linkerd-CLI an Tag 1.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Eigener Trust Anchor und Issuer

step certificate create root.linkerd.cluster.local ca.crt ca.key \
  --profile root-ca --no-password --insecure --not-after 87600h
step certificate create identity.linkerd.cluster.local issuer.crt issuer.key \
  --profile intermediate-ca --not-after 8760h --no-password --insecure \
  --ca ca.crt --ca-key ca.key
chmod 600 ca.key issuer.key
step certificate inspect ca.crt --short
step certificate inspect issuer.crt --short
step certificate verify issuer.crt --roots ca.crt && echo verify-ok

Erwartet:

Your certificate has been saved in ca.crt.
Your private key has been saved in ca.key.
Your certificate has been saved in issuer.crt.
Your private key has been saved in issuer.key.
X.509v3 Root CA Certificate (ECDSA P-256) [Serial: 6266...5288]
  Subject:     root.linkerd.cluster.local
  Issuer:      root.linkerd.cluster.local
  Valid from:  2026-11-19T15:51:50Z
          to:  2036-11-16T15:51:50Z
X.509v3 Intermediate CA Certificate (ECDSA P-256) [Serial: 1187...8861]
  Subject:     identity.linkerd.cluster.local
  Issuer:      root.linkerd.cluster.local
  Valid from:  2026-11-19T15:51:50Z
          to:  2027-11-19T15:51:50Z
verify-ok

87 600 Stunden sind zehn Jahre. Die Namen folgen der Linkerd-Doku: Der Issuer heißt identity.linkerd.<trust-domain>. --no-password --insecure lässt die Schlüssel unverschlüsselt – für den Issuer nötig, für ca.key nur im Labor vertretbar.

Achtung: ca.key ist ab jetzt der wertvollste Schlüssel des Mesh. Wer ihn hat, kann jede Identität fälschen. In Produktion liegt er offline oder in einem Vault.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Runde 1 – beide Anchors

Merk dir die Startzeit; in Drill 6 misst du damit den ganzen Wechsel.

date +%s > start.txt
step certificate bundle ca.crt original-trust.crt bundle.crt
grep -c 'BEGIN CERTIFICATE' bundle.crt
linkerd upgrade --identity-trust-anchors-file=./bundle.crt > upgrade-1.yaml
kubectl apply -f upgrade-1.yaml | grep -E 'trust-roots|identity '
kubectl -n linkerd rollout status deploy --timeout=300s
linkerd check --proxy 2>&1 | grep -A4 'match CA'

Erwartet (gekürzt):

Your certificate has been saved in bundle.crt.
2
configmap/linkerd-identity-trust-roots configured
...
deployment "linkerd-proxy-injector" successfully rolled out
‼ data plane proxies certificate match CA
    Some pods do not have the current trust bundle and must be restarted:
        * linkerd-viz/metrics-api-6cfdd5799-kzwzj
        * linkerd-viz/tap-854d684c76-s554k
...

Die Control Plane ist schon neu gestartet – linkerd upgrade erzeugt bei jedem Lauf neue Webhook-Zertifikate. Alle anderen Proxys kennen erst nach einem Neustart beide Anchors:

kubectl -n linkerd-viz rollout restart deploy
kubectl -n notes rollout restart deploy
kubectl -n notes rollout restart statefulset
kubectl -n linkerd-viz rollout status deploy --timeout=300s
kubectl -n notes rollout status deploy/notes-api --timeout=300s
kubectl -n notes rollout status statefulset/postgres --timeout=300s
sleep 20
linkerd check --proxy 2>&1 | grep -E '‼|×|Status'

Erwartet:

Status check results are √

Kommt noch ein ‼, hängt ein alter Pod im Beenden. Warte und prüf erneut. Gibt es bei dir weitere Namespaces mit Proxys, startest du sie genauso neu.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Runde 2 – neuer Issuer

linkerd upgrade --identity-issuer-certificate-file=./issuer.crt \
  --identity-issuer-key-file=./issuer.key > upgrade-2.yaml
kubectl apply -f upgrade-2.yaml | grep -E 'identity-issuer|identity '
kubectl -n linkerd rollout status deploy --timeout=300s
kubectl get events -n linkerd --field-selector reason=IssuerUpdated

Erwartet (gekürzt):

secret/linkerd-identity-issuer configured
deployment.apps/linkerd-identity configured
...
LAST SEEN   TYPE     REASON          OBJECT                        MESSAGE
26s         Normal   IssuerUpdated   deployment/linkerd-identity   Updated identity iss…

Ab jetzt stellt identity Zertifikate unter dem neuen Anchor aus. Das klappt, weil jeder Proxy seit Runde 1 beiden Anchors vertraut. Wieder alle Proxys neu starten, damit sie neue Zertifikate holen:

kubectl -n linkerd-viz rollout restart deploy
kubectl -n notes rollout restart deploy
kubectl -n notes rollout restart statefulset
kubectl -n linkerd-viz rollout status deploy --timeout=300s
kubectl -n notes rollout status deploy/notes-api --timeout=300s
kubectl -n notes rollout status statefulset/postgres --timeout=300s
sleep 15
linkerd identity -n notes -l app=web | grep 'Issuer:' | sort | uniq -c

Erwartet:

      2         Issuer: CN=identity.linkerd.cluster.local

Vorher stand dort CN=identity.linkerd. – der alte, selbstsignierte Issuer.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Runde 3 – alten Anchor entfernen

linkerd upgrade --identity-trust-anchors-file=./ca.crt > upgrade-3.yaml
kubectl apply -f upgrade-3.yaml | grep trust-roots
kubectl -n linkerd rollout status deploy --timeout=300s
kubectl -n linkerd-viz rollout restart deploy
kubectl -n notes rollout restart deploy
kubectl -n notes rollout restart statefulset
kubectl -n linkerd-viz rollout status deploy --timeout=300s
kubectl -n notes rollout status deploy/notes-api --timeout=300s
kubectl -n notes rollout status statefulset/postgres --timeout=300s
sleep 20
kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.data.ca-bundle\.crt}' | step certificate inspect --short -
linkerd check --proxy 2>&1 | grep -E '‼|×|Status'

Erwartet (gekürzt):

‼ Rotating the trust anchors will affect existing proxies
See https://linkerd.io/2/tasks/rotating_identity_certificates/ for more information
configmap/linkerd-identity-trust-roots configured
...
X.509v3 Root CA Certificate (ECDSA P-256) [Serial: 6266...5288]
  Subject:     root.linkerd.cluster.local
  Issuer:      root.linkerd.cluster.local
  Valid from:  2026-11-19T15:51:50Z
          to:  2036-11-16T15:51:50Z
Status check results are √

Die Warnung von linkerd upgrade ist der Hinweis auf genau den Neustart, den du gerade gemacht hast. Der alte Anchor ist raus.

Achtung: Wer Runde 2 überspringt und den alten Anchor direkt entfernt, legt das Mesh lahm: Die Proxys halten dann Zertifikate, denen niemand mehr vertraut.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Der Beweis

Drei Runden Neustarts – was hat der Lastgenerator abbekommen? Sein Log ist mit jedem Neustart weg, Prometheus hat aber alles:

kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
  >/dev/null 2>&1 &
sleep 4
R=$(( $(date +%s) - $(cat start.txt) ))s
Q="sum by (dst_deployment, status_code) (increase(response_total{namespace=\"notes\",
 deployment=\"web\", direction=\"outbound\"}[$R]))"
curl -s localhost:9090/api/v1/query --data-urlencode "query=$Q" | jq -r \
  '.data.result[] | .metric.dst_deployment + " " + .metric.status_code + " "
   + (.value[1] | tonumber | round | tostring)'

Erwartet (Zahlen schwanken):

helper 200 425
helper 500 156
notes-api 200 1224
notes-api 500 8

helper liefert seine üblichen 30 Prozent Fehler. Kein einziges 502 oder 503 – das wären die Antworten des Proxys bei gescheitertem TLS. Bleiben acht 500er von notes-api. Wann kamen sie?

Q='sum(increase(response_total{namespace="notes",deployment="web",
 direction="outbound",dst_deployment="notes-api",classification="failure"}[1m]))'
curl -s localhost:9090/api/v1/query_range --data-urlencode "query=$Q" \
  --data-urlencode start=$(cat start.txt) --data-urlencode end=$(date +%s) \
  --data-urlencode step=20 \
  | jq -r '.data.result[0].values[] | (.[0]|todate)+" "+.[1]' | awk '$2>0'
Q='max(kube_pod_start_time{namespace="notes",pod="postgres-0"})'
curl -s localhost:9090/api/v1/query_range --data-urlencode "query=$Q" \
  --data-urlencode start=$(cat start.txt) --data-urlencode end=$(date +%s) \
  --data-urlencode step=30 \
  | jq -r '[.data.result[0].values[][1]] | unique | .[] | tonumber | todate'
kill %1

Erwartet (gekürzt):

2026-11-19T15:53:17Z 4
2026-11-19T15:53:37Z 4
2026-11-19T15:55:37Z 4.295
2026-11-19T15:55:57Z 4
2026-11-19T15:56:17Z 3.705
2026-11-19T15:41:16Z
2026-11-19T15:52:47Z
2026-11-19T15:55:19Z
2026-11-19T15:57:29Z

Die erste Startzeit ist der Neustart von Tag 4, danach folgen die drei Runden. Die Fehler fallen auf die Neustarts von postgres-0 in Runde 1 und 2: eine einzige Replika, die für ein paar Sekunden weg ist. Mit den Zertifikaten hat das nichts zu tun – dasselbe hast du an Tag 4 ohne Wechsel gesehen. Der Anchor-Wechsel selbst lief ohne Ausfall.

Fortschritt speichern? Kostenlos registrieren

Drill 7: trust-manager übernimmt den Anchor

cert-manager v1.21.3 läuft im Labor schon (Namespace cert-manager). Fehlt er bei dir: helm install cert-manager oci://quay.io/jetstack/charts/cert-manager --version v1.21.3 -n cert-manager --create-namespace --set crds.enabled=true.

helm install trust-manager oci://quay.io/jetstack/charts/trust-manager \
  --version v0.26.0 -n cert-manager --set app.trust.namespace=cert-manager --wait
kubectl -n cert-manager create secret tls linkerd-trust-anchor \
  --cert=ca.crt --key=ca.key
cat > cert-manager.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata: {name: linkerd-identity-issuer}
spec:
  ca: {secretName: linkerd-trust-anchor}
---
apiVersion: trust.cert-manager.io/v1alpha1
kind: Bundle
metadata: {name: linkerd-identity-trust-roots}
spec:
  sources:
  - secret: {name: linkerd-trust-anchor, key: tls.crt}
  target:
    configMap: {key: ca-bundle.crt}
    namespaceSelector:
      matchLabels: {linkerd.io/is-control-plane: "true"}
EOF
kubectl apply -f cert-manager.yaml
sleep 10
kubectl get clusterissuer linkerd-identity-issuer
kubectl get bundle linkerd-identity-trust-roots
kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.metadata.ownerReferences[0].kind}{"\n"}'

Erwartet (gekürzt):

STATUS: deployed
secret/linkerd-trust-anchor created
clusterissuer.cert-manager.io/linkerd-identity-issuer created
bundle.trust.cert-manager.io/linkerd-identity-trust-roots created
NAME                      READY   AGE
linkerd-identity-issuer   True    11s
NAME                           CONFIGMAP TARGET   SECRET TARGET   SYNCED   REASON   AGE
linkerd-identity-trust-roots   ca-bundle.crt                      True     Synced   11s
Bundle
  • Der Anchor kommt als Secret nach cert-manager. trust-manager darf nur aus seinem Trust-Namespace lesen, der ClusterIssuer sucht dort auch seine Secrets.
  • Der Bundle-Name ist der Name der Ziel-ConfigMap. trust-manager hat die bestehende ConfigMap übernommen; der Inhalt bleibt derselbe Anchor, kein Neustart nötig.
  • Das Label linkerd.io/is-control-plane=true hat linkerd install schon gesetzt.

Fortschritt speichern? Kostenlos registrieren

Drill 8: cert-manager übernimmt den Issuer

cat > identity-issuer.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Certificate
metadata: {name: linkerd-identity-issuer, namespace: linkerd}
spec:
  issuerRef: {name: linkerd-identity-issuer, kind: ClusterIssuer}
  secretName: linkerd-identity-issuer
  isCA: true
  commonName: identity.linkerd.cluster.local
  duration: 48h0m0s
  renewBefore: 25h0m0s
  privateKey: {rotationPolicy: Always, algorithm: ECDSA}
EOF
kubectl apply -f identity-issuer.yaml
sleep 15
kubectl -n linkerd get certificate
kubectl -n linkerd get secret linkerd-identity-issuer -o jsonpath='{.data}' \
  | jq -r 'keys[]'

Erwartet:

certificate.cert-manager.io/linkerd-identity-issuer created
NAME                      READY   SECRET                    AGE
linkerd-identity-issuer   True    linkerd-identity-issuer   15s
ca.crt
crt.pem
key.pem
tls.crt
tls.key

cert-manager schreibt in das vorhandene Secret: tls.* kommen dazu, die alten crt.pem/key.pem aus Runde 2 bleiben. Jetzt stellst du Linkerd auf den externen Issuer um – erst dann liest identity die tls.*-Schlüssel:

linkerd upgrade --set identity.externalCA=true \
  --set identity.issuer.scheme=kubernetes.io/tls > upgrade-4.yaml
grep -c 'name: linkerd-identity-issuer$' upgrade-4.yaml
kubectl apply -f upgrade-4.yaml | grep 'identity '
kubectl -n linkerd rollout status deploy --timeout=300s
kubectl -n linkerd logs deploy/linkerd-identity -c identity | grep 'Issuer cert loaded'
linkerd check 2>&1 | grep -A1 '‼'

Erwartet (gekürzt):

0
deployment.apps/linkerd-identity configured
...
level=info msg="Issuer cert loaded" invalid_after=1795276812 ... ttl_seconds=172762
‼ issuer cert is valid for at least 60 days
    issuer certificate will expire on 2026-11-21T16:00:12Z

Das Manifest enthält weder Issuer-Secret noch Trust-ConfigMap mehr – beide gehören jetzt cert-manager und trust-manager. Die Warnung zur 60-Tage-Frist ist bei einem 48-Stunden-Issuer gewollt; linkerd check endet trotzdem mit √.

Ein Fallstrick wartet beim nächsten linkerd upgrade – also sofort:

linkerd upgrade > /dev/null

Erwartet (umbrochen):

--identity-issuer-certificate-file must not be specified if
--identity-external-issuer=true

Die CLI merkt sich alle Werte früherer Upgrades im Secret linkerd-config-overrides – auch Zertifikat und privaten Schlüssel des Issuers aus Runde 2. Beides muss raus:

(umask 077; kubectl -n linkerd get secret linkerd-config-overrides \
  -o jsonpath='{.data.linkerd-config-overrides}' | base64 -d > overrides.yaml)
sed -i '/^    tls:/,/^identityTrustAnchorsPEM/{/^identityTrustAnchorsPEM/!d}' \
  overrides.yaml
grep -c 'PRIVATE KEY' overrides.yaml
head -5 overrides.yaml
kubectl -n linkerd patch secret linkerd-config-overrides \
  -p "{\"data\":{\"linkerd-config-overrides\":\"$(base64 -w0 overrides.yaml)\"}}"
rm overrides.yaml
linkerd upgrade > upgrade-5.yaml && echo upgrade-ok
kubectl apply -f upgrade-5.yaml | grep 'configmap/linkerd-config '
kubectl -n linkerd rollout status deploy --timeout=300s

Erwartet (gekürzt):

0
identity:
  externalCA: true
  issuer:
    scheme: kubernetes.io/tls
identityTrustAnchorsPEM: |
secret/linkerd-config-overrides patched
upgrade-ok
configmap/linkerd-config configured

Der Bereich tls: unter issuer: ist weg, der Anchor bleibt. Jetzt läuft linkerd upgrade wieder, und das Ergebnis enthält keinen Schlüssel mehr.

Jetzt der eigentliche Gewinn – eine Erneuerung im laufenden Betrieb. cmctl stößt sie sofort an, statt 23 Stunden zu warten:

ARCH=$(dpkg --print-architecture)
curl -fsSLO https://github.com/cert-manager/cmctl/releases/download/v2.6.2/\
cmctl_linux_$ARCH.tar.gz
curl -fsSL https://api.github.com/repos/cert-manager/cmctl/releases/tags/v2.6.2 \
  | grep -c "$(sha256sum cmctl_linux_$ARCH.tar.gz | cut -d' ' -f1)"
tar xzf cmctl_linux_$ARCH.tar.gz cmctl
sudo install -m 0755 cmctl /usr/local/bin/cmctl
cmctl renew -n linkerd linkerd-identity-issuer
sleep 15
kubectl -n linkerd get certificate linkerd-identity-issuer \
  -o jsonpath='{.status.revision} {.status.notAfter}{"\n"}'
kubectl get events -n linkerd --field-selector reason=IssuerUpdated | tail -1
kubectl -n linkerd get secret linkerd-identity-issuer -o jsonpath='{.data.tls\.crt}' \
  | base64 -d | step certificate inspect --format json - \
  | jq -r '.extensions.subject_key_id'
kubectl -n notes rollout restart deploy/helper
kubectl -n notes rollout status deploy/helper --timeout=180s
sleep 5
linkerd identity -n notes -l app=helper | grep -A1 'Authority Key' | grep keyid

Erwartet (gekürzt):

1
Manually triggered issuance of Certificate linkerd/linkerd-identity-issuer
2 2026-11-21T16:02:00Z
15s         Normal   IssuerUpdated   deployment/linkerd-identity   Updated identity iss…
ae3e4dc7e07f4657ad799822da17c000b387c4e1
...
                keyid:AE:3E:4D:C7:E0:7F:46:57:AD:79:98:22:DA:17:C0:00:B3:87:C4:E1
                keyid:AE:3E:4D:C7:E0:7F:46:57:AD:79:98:22:DA:17:C0:00:B3:87:C4:E1

Neuer Schlüssel (rotationPolicy: Always), identity lädt ihn ohne Neustart, und die neuen helper-Proxys tragen genau diese Key-ID als Aussteller. Die übrigen Proxys wechseln bei ihrer nächsten Erneuerung – alle Issuer hängen am selben Anchor.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig, bis wann der Trust Anchor im Cluster gilt. Zeitziel: 30 s
  2. Zeig, wann cert-manager den Issuer das nächste Mal erneuert. Zeitziel: 30 s
  3. Beweise per Fingerprint, dass im Cluster dein ca.crt steckt. Zeitziel: 45 s
  4. Zähl die IssuerUpdated-Events. Zeitziel: 20 s

Lösung

kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.data.ca-bundle\.crt}' | step certificate inspect --short - | grep to:
kubectl -n linkerd get certificate linkerd-identity-issuer \
  -o jsonpath='{.status.notAfter} {.status.renewalTime}{"\n"}'
step certificate fingerprint ca.crt
kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.data.ca-bundle\.crt}' | step certificate fingerprint -
kubectl get events -n linkerd --field-selector reason=IssuerUpdated --no-headers | wc -l

Erwartet (Zahlen schwanken):

          to:  2036-11-16T15:51:50Z
2026-11-21T16:02:00Z 2026-11-20T15:02:00Z
8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81
8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81
3

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

linkerd check 2>&1 | tail -1

Erwartet:

Status check results are √
kubectl -n linkerd get certificate linkerd-identity-issuer
kubectl get bundle linkerd-identity-trust-roots

Erwartet: beide True.

ls ~/linkerd/tag05/ca.crt ~/linkerd/tag05/ca.key
kubectl -n notes get pods

Erwartet: beide Dateien vorhanden, alle Pods 2/2 Running.

Challenge

Bevor du ca.crt und ca.key für den zweiten Cluster aufhebst: Beweise, dass der Schlüssel zum Zertifikat passt und dass der Issuer im Cluster von genau diesem Anchor signiert ist.

Hinweis: step kann den öffentlichen Schlüssel aus beiden Dateien ziehen.

Lösung

kubectl -n linkerd get secret linkerd-identity-issuer -o jsonpath='{.data.tls\.crt}' \
  | base64 -d > issuer-cm.crt
step certificate verify issuer-cm.crt --roots ca.crt && echo "Issuer passt zu ca.crt"
diff <(step crypto key public ca.key) <(step certificate key ca.crt) \
  && echo "ca.key passt zu ca.crt"
rm issuer-cm.crt

Erwartet:

Issuer passt zu ca.crt
ca.key passt zu ca.crt

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Der Issuer aus Runde 2 ist noch ein Jahr gültig und hängt am Anchor. Sein Schlüssel steckt im Secret und in deinen Upgrade-Manifesten – weg damit:

kubectl -n linkerd patch secret linkerd-identity-issuer --type=json \
  -p '[{"op":"remove","path":"/data/crt.pem"},{"op":"remove","path":"/data/key.pem"}]'
kubectl -n linkerd get secret linkerd-identity-issuer -o jsonpath='{.data}' \
  | jq -r 'keys[]'
rm -f issuer.key issuer.crt upgrade-*.yaml cmctl
rm -f step_linux_*.tar.gz cmctl_linux_*.tar.gz
rm -rf step_0.31.0

Erwartet:

secret/linkerd-identity-issuer patched
ca.crt
tls.crt
tls.key

ca.crt und ca.key bleiben in ~/linkerd/tag05/ – Tag 12 braucht sie.

Interview-Notiz

  • Wie tauschst du den Trust Anchor ohne Ausfall? Bundle aus alt und neu verteilen, alles neu starten, Issuer tauschen, neu starten, alten Anchor entfernen, neu starten.
  • Was automatisiert cert-manager, was nicht? Den Issuer vollständig. Den Anchor verteilt trust-manager – ausstellen, tauschen und die Neustarts der Proxys bleiben Handarbeit.
  • Warum braucht Multicluster denselben Anchor? Proxys prüfen die Kette bis zum Anchor; nur mit gemeinsamem Anchor vertrauen sich Workloads über Clustergrenzen.

Enterprise-Notiz

  • Anchor-Schlüssel nicht im Cluster: cert-manager mit Vault- oder externem CA-Issuer statt CA-Issuer mit Secret.
  • Ablauf von Anchor und Issuer überwachen (certmanager_certificate_expiration_timestamp_ seconds), nicht nur die Proxy-Zertifikate.
  • Anchor-Wechsel als Runbook mit Wartungsfenster: Jede Runde startet jeden Pod im Mesh, Einzel-Replikas wie Datenbanken fallen kurz aus.
  • Mit Helm statt CLI: identity.externalCA=true und identity.issuer.scheme=kubernetes.io/tls gehören von Anfang an in die Values (Tag 14).