Zum Inhalt springen
Trainingslager IT-Trainingslager

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 cep

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

Erwartet:

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 frontend

Erwartet (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/version

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

Erwartet (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/$ID

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

Erwartet (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/version

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

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

  1. Zeige alle Endpunkte in tag14 mit ihrer Identitäts-ID in zwei Spalten. Zeitziel: 45 s
  2. Zeige die Security-Labels der Identität von admin. Zeitziel: 60 s
  3. Erlaube admin zusätzlich GET /version, ohne andere Regeln anzufassen. Zeitziel: 2 min
  4. 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 list

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

Erwartet: 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 list

Erwartet:

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=default

Erwartet (gekürzt): GLEICH, mesh-auth-enabled false; der Namespace cilium-spire samt PVC ist weg.

Achtung: Nicht per --reuse-values --set authentication=null zurü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: X im fromEndpoints.
  • L7-Regeln stehen unter toPorts[].rules.http (Methode, Pfad als Regex, Header); ein L7-Nein ist 403, ein L3/L4-Nein ein Timeout – beides in hubble observe.
  • authentication.mode: required steht auf Höhe von fromEndpoints in 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 labels einschränken – weniger Identitäten, weniger Policy-Last bei großen Clustern.