Tag 14: Pod-Authentifizierung und -Autorisierung
Ziel: Du liest, wie Cilium aus Labels Identitäten macht, erlaubst HTTP-Aufrufe je Identität und verlangst mit Mutual Authentication (SPIFFE/SPIRE), dass sich beide Seiten kryptografisch ausweisen, bevor ein Paket durchkommt. · Dauer: ca. 90 min · Voraussetzung: Tag 12
Briefing
- CKNE: Network Security and Policy – „Implementing Pod-level Authentication and Authorization“.
- Cilium filtert nicht nach IPs, sondern nach Identitäten: Jede Kombination sicherheitsrelevanter Labels (inklusive Namespace und ServiceAccount) bekommt eine numerische ID, die im Paket mitreist.
- Autorisierung: CiliumNetworkPolicy mit L7-Regeln je Identität
(Methode, Pfad, Header). Authentifizierung:
authentication.mode: required– erst nach einem mTLS-Handshake der Agenten mit SPIFFE-Zertifikaten öffnet sich der Weg. - Mutual Authentication ist in Cilium 1.20 Beta; sie verschlüsselt nichts.
tag14/frontend (SA frontend) ── GET /notes, /version ──┐
tag14/admin (SA admin) ── GET/POST /notes ───────┴─> notes-api :8080
cilium-agent <── mTLS (SVID spiffe://spiffe.cilium/identity/N) ──>
SPIRE-Server + Agenten (cilium-spire)
Drill 1: Labels werden zur Identität
Drei ServiceAccounts, die notes-api mit zwei Replikas, zwei Clients:
mkdir -p ~/ckne/tag14 && cd ~/ckne/tag14
k create namespace tag14
k config set-context --current --namespace=tag14
k create sa notes-api; k create sa frontend; k create sa admin
k create deployment notes-api --image=ghcr.io/thomaszachmann/notes-api:0.5.1 \
--replicas=2 --port=8080 $do > notes-api.yaml
k set env --local -f notes-api.yaml NOTES_API_KEY=lab-key-123 -o yaml \
> notes-api-env.yaml
k set serviceaccount --local -f notes-api-env.yaml notes-api -o yaml \
> notes-api-sa.yaml
k apply -f notes-api-sa.yaml
k expose deployment notes-api --port=80 --target-port=8080
k run frontend --image=curlimages/curl:8.17.0 \
--overrides='{"spec":{"serviceAccountName":"frontend"}}' --command -- sleep infinity
k run admin --image=curlimages/curl:8.17.0 \
--overrides='{"spec":{"serviceAccountName":"admin"}}' --command -- sleep infinity
k rollout status deployment notes-api
k wait --for=condition=Ready pod frontend admin
k get cepErwartet (gekürzt):
deployment "notes-api" successfully rolled out
pod/frontend condition met
pod/admin condition met
NAME SECURITY IDENTITY ENDPOINT STATE IPV4 IPV6
admin 51657 ready 10.0.2.130
frontend 38567 ready 10.0.1.183
notes-api-97d957675-4jdq4 61704 ready 10.0.2.25
notes-api-97d957675-z7vg6 61704 ready 10.0.1.152
Beide notes-api-Pods teilen eine Identität, egal auf welchem Node. Woraus sie besteht:
ID=$(k get cep -l app=notes-api -o jsonpath='{.items[0].status.identity.id}')
k get ciliumidentity $ID -o yaml | sed -n '/security-labels/,$p'
k get pod -l app=notes-api --show-labels | head -2Erwartet:
security-labels:
k8s:app: notes-api
k8s:io.cilium.k8s.namespace.labels.kubernetes.io/metadata.name: tag14
k8s:io.cilium.k8s.policy.cluster: default
k8s:io.cilium.k8s.policy.serviceaccount: notes-api
k8s:io.kubernetes.pod.namespace: tag14
NAME READY STATUS RESTARTS AGE LABELS
notes-api-97d957675-4jdq4 1/1 Running 0 24m app=notes-api,pod-temp...
Namespace, Namespace-Labels und ServiceAccount gehören dazu,
pod-template-hash nicht – Cilium filtert flüchtige Labels
heraus, sonst bekäme jedes Rollout neue IDs.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Ein Label ändert die Identität
k label pod frontend team=blue
sleep 15; k get cep frontend
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg identity get \
$(k get cep frontend -o jsonpath='{.status.identity.id}') | grep -E 'ID|team'
k label pod frontend team-
sleep 15; k get cep frontendErwartet (gekürzt):
pod/frontend labeled
NAME SECURITY IDENTITY ENDPOINT STATE IPV4 IPV6
frontend 6975 ready 10.0.1.183
ID LABELS
k8s:team=blue
pod/frontend unlabeled
NAME SECURITY IDENTITY ENDPOINT STATE IPV4 IPV6
frontend 38567 ready 10.0.1.183
Zwischendurch kann ENDPOINT STATE kurz
waiting-for-identity zeigen. Für dich heißt das: Wer Labels
an Pods setzen darf, kann seine Identität wechseln – Policies deshalb
lieber am ServiceAccount festmachen, den RBAC schützt.
Fortschritt speichern? Kostenlos registrieren
Drill 3: L7-Autorisierung je Identität
frontend darf lesen, admin darf zusätzlich
schreiben – aber nur mit API-Key im Header. Das Label
io.cilium.k8s.policy.serviceaccount wählt nach
ServiceAccount:
cat > cnp-l7.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
name: notes-api-l7
spec:
endpointSelector:
matchLabels:
app: notes-api
ingress:
- fromEndpoints:
- matchLabels:
io.cilium.k8s.policy.serviceaccount: frontend
toPorts:
- ports:
- port: "8080"
protocol: TCP
rules:
http:
- method: GET
path: /notes
- method: GET
path: /version
- fromEndpoints:
- matchLabels:
io.cilium.k8s.policy.serviceaccount: admin
toPorts:
- ports:
- port: "8080"
protocol: TCP
rules:
http:
- method: GET
path: /notes
- method: POST
path: /notes
headers:
- "X-API-Key: lab-key-123"
EOF
k apply -f cnp-l7.yaml
k get cnp
for p in frontend admin; do
echo "== $p"
k exec $p -- curl -s -w ' %{http_code}\n' notes-api/version
k exec $p -- curl -s -o /dev/null -w 'GET /notes %{http_code}\n' notes-api/notes
k exec $p -- curl -s -w ' %{http_code}\n' -X POST notes-api/notes \
-H 'X-API-Key: lab-key-123' -d "{\"text\":\"von $p\"}"
done
k run fremd --image=curlimages/curl:8.17.0 --rm -i --restart=Never -- \
curl -s -m3 -w '%{http_code}\n' notes-api/versionErwartet (gekürzt):
ciliumnetworkpolicy.cilium.io/notes-api-l7 created
NAME AGE VALID
notes-api-l7 5s True
== frontend
0.5.1
200
GET /notes 200
Access denied
403
== admin
Access denied
403
GET /notes 200
{"id":"f510a6a1-ef13-4a1c-83b6-c9edcfcc2805","text":"von admin"}
201
000
pod "fremd" deleted from tag14 namespace
Zwei Arten von Nein: 403 Access denied kommt vom
Envoy-Proxy (L4 erlaubt, L7 nicht), 000 nach Timeout heißt:
Paket schon auf L3/L4 verworfen – fremd (ServiceAccount
default) steht in keiner Regel.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Nachweis mit Hubble
k exec frontend -- curl -s -o /dev/null -X POST notes-api/notes \
-H 'X-API-Key: lab-key-123' -d '{}'
k exec admin -- curl -s -o /dev/null notes-api/notes
hubble observe -P --port-forward-port 0 --namespace tag14 --type l7 --last 4
hubble observe -P --port-forward-port 0 --namespace tag14 --verdict DROPPED --last 2Erwartet (gekürzt):
... tag14/frontend:60666 (ID:38567) -> tag14/notes-api-97d957675-4jdq4:8080 (ID:61704)
http-request DROPPED (HTTP/1.1 POST http://notes-api/notes)
... tag14/frontend:60666 (ID:38567) <- tag14/notes-api-97d957675-4jdq4:8080 (ID:61704)
http-response FORWARDED (HTTP/1.1 403 0ms (POST http://notes-api/notes))
... tag14/admin:34468 (ID:51657) -> tag14/notes-api-97d957675-z7vg6:8080 (ID:61704)
http-request FORWARDED (HTTP/1.1 GET http://notes-api/notes)
... tag14/admin:34468 (ID:51657) <- tag14/notes-api-97d957675-z7vg6:8080 (ID:61704)
http-response FORWARDED (HTTP/1.1 200 2ms (GET http://notes-api/notes))
... tag14/fremd:56230 (ID:64062) <> tag14/notes-api-97d957675-z7vg6:8080 (ID:61704)
policy-verdict:none INGRESS DENIED (TCP Flags: SYN)
... tag14/fremd:56230 (ID:64062) <> tag14/notes-api-97d957675-z7vg6:8080 (ID:61704)
Policy denied DROPPED (TCP Flags: SYN)
Jede Zeile nennt die Identität beider Seiten. Bisher ist das aber nur eine Behauptung: Die Quell-Identität steckt im Tunnel-Header – wer einen Node kontrolliert oder Pakete fälscht, kann sie vortäuschen. Das schließt Drill 6.
Fortschritt speichern? Kostenlos registrieren
Drill 5: SPIRE installieren
Cilium bringt einen SPIRE-Server und SPIRE-Agenten als Teil des
Helm-Charts mit. Der Server speichert seine Daten in einem PVC
(Default-StorageClass local-path).
helm get values cilium -n kube-system -o yaml > values-vorher.yaml
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values \
--set authentication.enabled=true \
--set authentication.mutual.spire.enabled=true \
--set authentication.mutual.spire.install.enabled=true \
--set authentication.mutual.spire.install.server.securityContext.runAsUser=0 \
--set authentication.mutual.spire.install.server.securityContext.runAsGroup=0 \
--set authentication.mutual.spire.install.agent.securityContext.runAsUser=0 \
--set authentication.mutual.spire.install.agent.securityContext.runAsGroup=0
k -n kube-system rollout restart deployment/cilium-operator
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
k -n cilium-spire rollout status statefulset spire-server
k -n cilium-spire rollout status ds spire-agent
k -n cilium-spire get pods,pvc
cilium config view | grep -E '^mesh-auth-(enabled|mutual-enabled|spiffe-trust-domain)'Erwartet (gekürzt):
daemon set "cilium" successfully rolled out
statefulset rolling update complete 1 pods at revision spire-server-...
daemon set "spire-agent" successfully rolled out
NAME READY STATUS RESTARTS AGE
pod/spire-agent-2pbh8 1/1 Running 0 16s
pod/spire-agent-bt5rc 1/1 Running 0 16s
pod/spire-agent-bwjtr 1/1 Running 0 17s
pod/spire-server-0 2/2 Running 0 27s
NAME STATUS ... STORAGECLASS
persistentvolumeclaim/spire-data-spire-server-0 Bound ... local-path
mesh-auth-enabled true
mesh-auth-mutual-enabled true
mesh-auth-spiffe-trust-domain spiffe.cilium
Achtung: Die vier
securityContext-Zeilen sind ein Labor-Fund. Ohne sie startet der SPIRE-Server 1.15.5 aus dem Chart 1.20.5 nicht: Das Image läuft als UID 1000 und darf im hostPath/var/run/spire-server/sockets(root, 755) seinen Admin-Socket nicht anlegen. Der Server loggt nur „Starting Server APIs“ und sofort „Stopping Server APIs“, hängt dann und wird nach der Liveness-Probe neu gestartet; die Agenten warten im Init-Container „Waiting for spire server to be reachable“.
Der SPIRE-Server hat jetzt drei Agenten (einer pro Node, per Projected Service Account Token beglaubigt) und vom Operator je Cilium-Identität einen Eintrag. Waren Identitäten schon vor SPIRE da, hilft ein Neustart des Operators beim Nachtragen:
k -n kube-system rollout restart deploy cilium-operator
k -n kube-system rollout status deploy cilium-operator
S="kubectl -n cilium-spire exec spire-server-0 -c spire-server -- \
/opt/spire/bin/spire-server"
$S healthcheck
$S agent list | grep 'Attestation type'
$S entry show | grep -c 'identity/'
$S entry show -spiffeID spiffe://spiffe.cilium/identity/$IDErwartet (gekürzt):
Server is healthy.
Attestation type : k8s_psat
Attestation type : k8s_psat
Attestation type : k8s_psat
112
Found 1 entry
Entry ID : 6d6f3e03-bcd8-4bc4-b961-c3dc50a48175
SPIFFE ID : spiffe://spiffe.cilium/identity/61704
Parent ID : spiffe://spiffe.cilium/cilium-operator
Selector : cilium:mutual-auth
Die SPIFFE-ID kodiert die Cilium-Identität. Die Agenten holen sich die passenden Zertifikate (SVIDs) und weisen sich damit gegenseitig aus.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Authentifizierung erzwingen
Ein Feld pro Regel – authentication.mode: required:
k explain cnp.spec.ingress.authentication.mode | sed -n '/ENUM/,/DESCRIPTION/p'
AUTH=' - authentication:\n mode: required\n fromEndpoints:'
sed "s/^ - fromEndpoints:/$AUTH/" cnp-l7.yaml > cnp-auth.yaml
sed -n '/ingress:/,/toPorts/p' cnp-auth.yaml
k apply -f cnp-auth.yaml
for p in frontend admin; do
k exec $p -- curl -s -m5 -w ' %{http_code}\n' notes-api/version
done
hubble observe -P --port-forward-port 0 --namespace tag14 --verdict DROPPED \
--last 5 | grep -i auth
CP=$(k -n kube-system get pod -l k8s-app=cilium --field-selector spec.nodeName=worker1 \
-o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf auth listErwartet (gekürzt):
ENUM:
disabled
required
test-always-fail
ingress:
- authentication:
mode: required
fromEndpoints:
- matchLabels:
io.cilium.k8s.policy.serviceaccount: frontend
toPorts:
ciliumnetworkpolicy.cilium.io/notes-api-l7 configured
0.5.1
200
Access denied
403
... tag14/frontend:50714 (ID:38567) <> tag14/notes-api-97d957675-z7vg6:8080 (ID:61704)
Authentication required DROPPED (TCP Flags: SYN)
... tag14/admin:42274 (ID:51657) <> tag14/notes-api-97d957675-4jdq4:8080 (ID:61704)
Authentication required DROPPED (TCP Flags: SYN)
SRC IDENTITY DST IDENTITY REMOTE NODE ID AUTH TYPE EXPIRATION
61704 51657 47089 spire 2026-11-19 01:44:45 +0000 UTC
61704 38567 0 spire 2026-11-19 01:44:44 +0000 UTC
So funktioniert es: Das erste SYN verwirft der Datenpfad
(„Authentication required“) und stößt den Handshake an. Die Agenten
beider Nodes prüfen per mTLS (Port 4250) die SVIDs der beiden
Identitäten und tragen das Paar in die Map cilium_auth_map
ein – gültig bis zum Zertifikatsablauf. Die TCP-Wiederholung des SYN
kommt durch; für den Client sieht das aus wie eine Sekunde Latenz.
REMOTE NODE ID 0 heißt: beide auf demselben Node.
Gegenprobe mit dem Testmodus, der jeden Handshake scheitern lässt:
sed 's/mode: required/mode: test-always-fail/' cnp-auth.yaml | k apply -f -
k exec frontend -- curl -s -m5 -w ' %{http_code}\n' notes-api/version
hubble observe -P --port-forward-port 0 --namespace tag14 --verdict DROPPED --last 1
k apply -f cnp-auth.yaml
k exec frontend -- curl -s -m5 -w ' %{http_code}\n' notes-api/versionErwartet (gekürzt):
ciliumnetworkpolicy.cilium.io/notes-api-l7 configured
000
command terminated with exit code 28
... tag14/frontend:<Port> (ID:38567) <> tag14/notes-api-…:8080 (ID:61704)
Authentication required DROPPED (TCP Flags: SYN)
ciliumnetworkpolicy.cilium.io/notes-api-l7 configured
0.5.1
200
Fortschritt speichern? Kostenlos registrieren
Drill 7: Authentifiziert heißt nicht verschlüsselt
Der Handshake läuft neben der Verbindung („out-of-band“), die
Nutzdaten selbst bleiben unberührt. Auf worker2 am Tunnel
mitlesen, während admin den Pod auf worker1
direkt aufruft:
P=$(k get pod -l app=notes-api --field-selector spec.nodeName=worker1 \
-o jsonpath='{.items[0].status.podIP}')
ssh [email protected] \
"sudo timeout 8 tcpdump -i eth0 -A -n udp port 8472 | grep -m1 'GET /version'" &
sleep 2
for i in 1 2 3; do k exec admin -- curl -s -m3 -o /dev/null http://$P:8080/version; done
waitErwartet (gekürzt):
IP 10.0.2.130.43106 > 10.0.1.152.8080: Flags [P.], seq 1:87, ack 1, win 507, options
[nop,nop,TS val 3357360675 ecr 3655487247], length 86: HTTP: GET /version HTTP/1.1
Die HTTP-Anfrage steht im Klartext im VXLAN-Paket (UDP 8472). Mutual Authentication beantwortet „wer spricht?“, nicht „wer hört mit?“. Die Cilium-Doku verlangt deshalb zusätzlich Verschlüsselung (WireGuard oder IPsec, Tag 13). Die Kopplung beider steht auf der Roadmap noch auf „TODO“.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeige alle Endpunkte in
tag14mit ihrer Identitäts-ID in zwei Spalten. Zeitziel: 45 s - Zeige die Security-Labels der Identität von
admin. Zeitziel: 60 s - Erlaube
adminzusätzlichGET /version, ohne andere Regeln anzufassen. Zeitziel: 2 min - Zeige die Authentifizierungs-Einträge auf
worker2. Zeitziel: 60 s
Lösung
k get cep -o custom-columns=NAME:.metadata.name,ID:.status.identity.id
k get ciliumidentity $(k get cep admin -o jsonpath='{.status.identity.id}') \
-o jsonpath='{.security-labels}'; echo
k get cnp notes-api-l7 -o jsonpath='{.spec.ingress[1].toPorts[0].rules.http}'; echo
k patch cnp notes-api-l7 --type=json -p '[{"op":"add",
"path":"/spec/ingress/1/toPorts/0/rules/http/-",
"value":{"method":"GET","path":"/version"}}]'
k exec admin -- curl -s -w ' %{http_code}\n' notes-api/version
CP=$(k -n kube-system get pod -l k8s-app=cilium --field-selector spec.nodeName=worker2 \
-o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf auth listErwartet (gekürzt):
NAME ID
admin 51657
frontend 38567
notes-api-97d957675-4jdq4 61704
notes-api-97d957675-z7vg6 61704
{"k8s:io.cilium.k8s.namespace.labels.kubernetes.io/metadata.name":"tag14",...,
"k8s:io.cilium.k8s.policy.serviceaccount":"admin",...,"k8s:run":"admin"}
[{"method":"GET","path":"/notes"},{"headers":["X-API-Key: lab-key-123"],...}]
ciliumnetworkpolicy.cilium.io/notes-api-l7 patched
0.5.1
200
SRC IDENTITY DST IDENTITY REMOTE NODE ID AUTH TYPE EXPIRATION
61704 38567 52624 spire 2026-11-19 01:44:44 +0000 UTC
61704 51657 0 spire 2026-11-19 01:44:49 +0000 UTC
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
k get cnp notes-api-l7 -o jsonpath='{.spec.ingress[*].authentication.mode}{"\n"}'Erwartet: required required
k exec frontend -- curl -s -w ' %{http_code}\n' -X POST notes-api/notes -d '{}'Erwartet: Access denied, darunter
403.
k -n cilium-spire exec spire-server-0 -c spire-server -- \
/opt/spire/bin/spire-server healthcheckErwartet: Server is healthy.
hubble observe -P --port-forward-port 0 --namespace tag14 --verdict DROPPED \
--last 20 | grep -c 'Authentication required'Erwartet: eine Zahl größer 0.
Challenge
Starte einen zweiten Pod frontend2 mit denselben Labels
und demselben ServiceAccount wie frontend auf
worker1. Braucht er einen eigenen Handshake?
Hinweis: Vergleiche Identität und
cilium-dbg bpf auth list vor und nach seinem ersten
Aufruf.
Lösung
k run frontend2 -l run=frontend --image=curlimages/curl:8.17.0 \
--overrides='{"spec":{"serviceAccountName":"frontend","nodeName":"worker1"}}' \
--command -- sleep infinity
k wait --for=condition=Ready pod/frontend2
k get cep frontend frontend2
CP=$(k -n kube-system get pod -l k8s-app=cilium --field-selector spec.nodeName=worker1 \
-o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf auth list
k exec frontend2 -- curl -s -m5 -w ' %{http_code}\n' notes-api/version
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf auth listErwartet:
pod/frontend2 created
pod/frontend2 condition met
NAME SECURITY IDENTITY ENDPOINT STATE IPV4 IPV6
frontend 38567 ready 10.0.1.183
frontend2 38567 ready 10.0.1.79
SRC IDENTITY DST IDENTITY REMOTE NODE ID AUTH TYPE EXPIRATION
61704 51657 47089 spire 2026-11-19 01:44:45 +0000 UTC
61704 38567 0 spire 2026-11-19 01:44:44 +0000 UTC
0.5.1
200
SRC IDENTITY DST IDENTITY REMOTE NODE ID AUTH TYPE EXPIRATION
61704 51657 47089 spire 2026-11-19 01:44:45 +0000 UTC
61704 38567 0 spire 2026-11-19 01:44:44 +0000 UTC
Kein neuer Eintrag, kein „Authentication required“-Drop: Authentifiziert wird pro Identitätspaar, nicht pro Pod oder Verbindung (Roadmap: „Per-connection handshake – TODO“). Wer die Labels eines berechtigten Pods trägt, erbt dessen Freigabe – ein weiterer Grund, Labels und ServiceAccounts per RBAC und Admission zu schützen.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Mutual Authentication ist Beta und belegt auf jedem Node einen
SPIRE-Agenten – zurück auf den Stand vor Tag 14. Die Sicherung aus Drill
5 kennt keine authentication-Werte; ohne
--reuse-values gelten wieder die Chart-Defaults (beide
aus), und Helm entfernt Server, Agenten und RBAC:
k delete namespace tag14
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 -f values-vorher.yaml
diff values-vorher.yaml <(helm get values cilium -n kube-system -o yaml) && echo GLEICH
k -n kube-system rollout restart deployment/cilium-operator
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
k delete namespace cilium-spire --ignore-not-found
cilium config view | grep -E '^mesh-auth-enabled'
k config set-context --current --namespace=defaultErwartet (gekürzt): GLEICH,
mesh-auth-enabled false; der Namespace
cilium-spire samt PVC ist weg.
Achtung: Nicht per
--reuse-values --set authentication=nullzurücksetzen – das Chart rendert im Labortest dann weiter mit Mutual Authentication und SPIRE.
Prüfungstipp
- Identität = Labels + Namespace + ServiceAccount. Für „nur Pods mit
ServiceAccount X“ matcht
io.cilium.k8s.policy.serviceaccount: XimfromEndpoints. - L7-Regeln stehen unter
toPorts[].rules.http(Methode, Pfad als Regex, Header); ein L7-Nein ist403, ein L3/L4-Nein ein Timeout – beides inhubble observe. authentication.mode: requiredsteht auf Höhe vonfromEndpointsin der Ingress-Regel; Drop-Grund „Authentication required“. Doku: docs.cilium.io „Mutual Authentication (Beta)“.
Enterprise-Notiz
- Cilium Mutual Authentication ist Beta: kein Per-Connection-Handshake, nicht mit ClusterMesh kombinierbar, nur mit SPIRE getestet. Für Compliance-mTLS heute eher ein Mesh (Istio Ambient, Linkerd) oder Ciliums ztunnel-Integration (ebenfalls Beta).
- Mutual Authentication immer mit WireGuard oder IPsec kombinieren – sie ersetzt keine Verschlüsselung.
- SPIRE produktiv: eigener HA-Server mit externer Datenbank, Upstream-CA aus Vault oder PKI, Monitoring der SVID-Ausstellung; Ausfall heißt: neue Identitätspaare kommen nicht mehr durch.
- Labels sind Sicherheitsattribute: per Admission-Policy (Kyverno,
VAP) verhindern, dass Teams fremde
app-Labels oder ServiceAccounts nutzen. - Die Identitäts-Labels lassen sich per Helm-Wert
labelseinschränken – weniger Identitäten, weniger Policy-Last bei großen Clustern.