Tag 5: Cluster-weite Regeln
Ziel: Leitplanken setzen, die kein Namespace-Admin aushebeln kann: mit
CiliumClusterwideNetworkPolicyund mit der neuen Kubernetes-APIClusterNetworkPolicy. · Dauer: ca. 120 min · Voraussetzung: Tag 4
Briefing
- NetworkPolicy gehört dem Namespace. Wer dort Rechte hat, kann alles öffnen. Die Plattform braucht Regeln darüber (Admin) und darunter (Baseline).
- SIG Network hat dafür AdminNetworkPolicy und
BaselineAdminNetworkPolicy (v1alpha1) gebaut. Seit network-policy-api
v0.2.0 (April 2026) sind beide in einem Typ
aufgegangen:
ClusterNetworkPolicy(v1alpha2) mittier: AdminoderBaseline. - Aktionen:
Accept(früherAllow),Deny,Pass.priority0–1000, kleiner = früher geprüft. - Cilium setzt die Upstream-API (noch) nicht um. Dort heißt das
Werkzeug
CiliumClusterwideNetworkPolicy(CCNP) mit expliziten Deny-Regeln.
Paket ─► Admin-Tier ──Accept/Deny──► fertig
│ Pass oder kein Treffer
▼
NetworkPolicy (Namespace) ──Treffer──► Allow / Default Deny
│ Pod von keiner NetworkPolicy erfasst
▼
Baseline-Tier ──Accept/Deny──► fertig (sonst: erlaubt)
Drill 1: Wer kann was?
Auf cilium-lab aus Tag 4 – welche Policy-Typen kennt der
Cluster?
mkdir -p ~/guard-lab/tag05 && cd ~/guard-lab/tag05
kubectl config use-context kind-cilium-lab
kubectl api-resources | grep -i networkpolicErwartet (gekürzt, kann je nach Version abweichen):
ciliumclusterwidenetworkpolicies ccnp cilium.io/v2 false CiliumClusterwide…
ciliumnetworkpolicies cnp cilium.io/v2 true CiliumNetworkPolicy
networkpolicies netpol networking.k8s.io/v1 true NetworkPolicy
Kein clusternetworkpolicies: Cilium bringt die CRD nicht
mit und hat keinen Controller dafür. Eine CRD von Hand anzulegen hilft
nicht – dann liegt die Policy nur als YAML im etcd. Stand der
Implementierungen (laut network-policy-api, 2026):
| Implementierung | ANP/BANP v1alpha1 | ClusterNetworkPolicy v1alpha2 |
|---|---|---|
| kube-network-policies | ja | ja (eigenes Image …-npa-v1alpha2) |
| Calico | 3.29–3.31 | ab 3.32 |
| OVN-Kubernetes, Antrea | ja | noch nicht |
| Kube-OVN | ja | experimentell |
| Cilium | nein (Tracking-Issue) | nein – stattdessen CCNP |
Achtung: Die Abkürzung
cnpist doppelt belegt: in Cilium fürCiliumNetworkPolicy, upstream fürClusterNetworkPolicy. Schreib im Team immer den vollen Namen.
Fortschritt speichern? Kostenlos registrieren
Drill 2: CCNP – Mandanten hart trennen
Erst öffnet ein Team seinen Namespace weit. Dann zieht die Plattform eine Linie, die keine Namespace-Policy überstimmen kann.
cat > open-tenant-a.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-all-ingress
namespace: tenant-a
spec:
podSelector: {}
ingress:
- {}
EOF
kubectl apply -f open-tenant-a.yaml
cc tenant-b/api http://api.tenant-aErwartet (gekürzt, kann je nach Version abweichen):
networkpolicy.networking.k8s.io/allow-all-ingress created
✔ erlaubt tenant-b/api -> http://api.tenant-a (HTTP 200)
Jetzt die Plattform-Regel. Eine CCNP hat keinen Namespace;
specs bündelt mehrere Regeln in einem Objekt.
cat > ~/guard-lab/code/cilium/ccnp-tenant-deny.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumClusterwideNetworkPolicy
metadata:
name: tenant-deny
specs: # mehrere Regeln in einem Objekt
- endpointSelector:
matchLabels:
k8s:io.kubernetes.pod.namespace: tenant-a
enableDefaultDeny:
ingress: false # nur verbieten, nicht alles andere schließen
ingressDeny:
- fromEndpoints:
- matchExpressions:
- {key: k8s:io.cilium.k8s.namespace.labels.tenant, operator: Exists}
- {key: k8s:io.kubernetes.pod.namespace, operator: NotIn, values: [tenant-a]}
- endpointSelector:
matchLabels:
k8s:io.kubernetes.pod.namespace: tenant-b
enableDefaultDeny:
ingress: false
ingressDeny:
- fromEndpoints:
- matchExpressions:
- {key: k8s:io.cilium.k8s.namespace.labels.tenant, operator: Exists}
- {key: k8s:io.kubernetes.pod.namespace, operator: NotIn, values: [tenant-b]}
EOF
kubectl apply -f ~/guard-lab/code/cilium/ccnp-tenant-deny.yaml
cc tenant-b/api http://api.tenant-a
cc shop/frontend http://api.tenant-a
cc tenant-a/api http://api.tenant-bErwartet (gekürzt, kann je nach Version abweichen):
ciliumclusterwidenetworkpolicy.cilium.io/tenant-deny created
✘ blockiert tenant-b/api -> http://api.tenant-a (Timeout)
✔ erlaubt shop/frontend -> http://api.tenant-a (HTTP 200)
✘ blockiert tenant-a/api -> http://api.tenant-b (Timeout)
In Cilium gewinnt Deny immer gegen Allow – egal aus welcher Policy.
Der Namespace-Admin von tenant-a kann die Sperre nicht
aufheben. shop trägt kein tenant-Label und
kommt weiter durch.
Warum enableDefaultDeny: false? Ohne das Feld schaltet
jede Policy mit Ingress-Regeln – auch reine Deny-Regeln – die erfassten
Pods in Default Deny. Dann wäre plötzlich auch
shop/frontend ausgesperrt – in tenant-b, das
keine eigene NetworkPolicy hat, sofort sichtbar.
Fortschritt speichern? Kostenlos registrieren
Drill 3: CCNP – Cloud-Metadaten sperren
Ein Klassiker für jede Plattform: Kein Pod darf den Metadaten-Dienst
der Cloud (169.254.169.254) erreichen, dort liegen
Node-Credentials.
cat > ~/guard-lab/code/cilium/ccnp-metadata-deny.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumClusterwideNetworkPolicy
metadata:
name: deny-cloud-metadata
spec:
endpointSelector: {} # alle Pods im Cluster
enableDefaultDeny:
egress: false
egressDeny:
- toCIDR:
- 169.254.169.254/32
EOF
kubectl apply -f ~/guard-lab/code/cilium/ccnp-metadata-deny.yaml
kubectl get ccnp
cc default/client http://169.254.169.254/latest/meta-data/
hubble observe -P --from-pod default/client --to-ip 169.254.169.254 --last 1Erwartet (gekürzt, kann je nach Version abweichen):
ciliumclusterwidenetworkpolicy.cilium.io/deny-cloud-metadata created
NAME VALID
deny-cloud-metadata True
tenant-deny True
✘ blockiert default/client -> http://169.254.169.254/latest/meta-data/ (Timeout)
... default/client:43120 (ID:23412) -> 169.254.169.254:80 (world) Policy denied by
denylist DROPPED (TCP Flags: SYN)
In kind gibt es dort keinen Dienst, ein Timeout käme auch ohne
Policy. Den Beweis liefert erst Hubble:
Policy denied by denylist heißt, eine Deny-Regel hat
zugeschlagen.
Fortschritt speichern? Kostenlos registrieren
Drill 4: np-lab mit ClusterNetworkPolicy
Für die Upstream-API brauchst du eine Implementierung. Die schlankste
ist kube-network-policies aus SIG Network – dieselbe
Engine, die in kindnet steckt, aber mit ClusterNetworkPolicy. Damit
kindnet nicht parallel NetworkPolicies durchsetzt, tauschst du sein
Image gegen eine ältere Version ohne Policy-Engine (so macht es auch die
CI des Projekts).
kind create cluster --config ~/guard-lab/kind/np-lab.yaml
kubectl -n kube-system set image ds kindnet \
kindnet-cni=docker.io/kindest/kindnetd:v20230809-80a64d96
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/\
network-policy-api/v0.2.0/config/crd/standard/\
policy.networking.k8s.io_clusternetworkpolicies.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/\
kube-network-policies/v1.1.2/install-cnp.yaml
kubectl -n kube-system rollout status ds kindnet
kubectl -n kube-system rollout status ds kube-network-policiesErwartet (gekürzt, kann je nach Version abweichen):
daemonset.apps/kindnet image updated
customresourcedefinition.apiextensions.k8s.io/clusternetworkpolicies.policy… created
daemonset.apps/kube-network-policies created
daemon set "kindnet" successfully rolled out
daemon set "kube-network-policies" successfully rolled out
Demo-App ausrollen und beweisen, dass NetworkPolicies weiter greifen
– jetzt durch kube-network-policies:
kubectl apply -f ~/guard-lab/code/demo/
kubectl wait --for=condition=Ready pod --all -A --timeout=300s
kubectl apply -f open-tenant-a.yaml
kubectl -n tenant-b create -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: deny-all}
spec: {podSelector: {}, policyTypes: [Ingress]}
EOF
cc default/client http://api.tenant-b
cc tenant-b/api http://api.tenant-aErwartet (gekürzt, kann je nach Version abweichen):
networkpolicy.networking.k8s.io/allow-all-ingress created
networkpolicy.networking.k8s.io/deny-all created
✘ blockiert default/client -> http://api.tenant-b (Timeout)
✔ erlaubt tenant-b/api -> http://api.tenant-a (HTTP 200)
Gleiche Ausgangslage wie in Drill 2: tenant-a ist offen,
tenant-b dicht.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Admin-Tier – Deny schlägt jede NetworkPolicy
cat > ~/guard-lab/code/cilium/cnp-tenant-deny.yaml <<'EOF'
apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
name: tenant-a-isolation
spec:
tier: Admin
priority: 10
subject:
namespaces:
matchLabels: {tenant: a}
ingress:
- name: deny-other-tenants
action: Deny
from:
- namespaces:
matchExpressions:
- {key: tenant, operator: Exists}
- {key: tenant, operator: NotIn, values: [a]}
---
apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
name: tenant-b-isolation
spec:
tier: Admin
priority: 10
subject:
namespaces:
matchLabels: {tenant: b}
ingress:
- name: deny-other-tenants
action: Deny
from:
- namespaces:
matchExpressions:
- {key: tenant, operator: Exists}
- {key: tenant, operator: NotIn, values: [b]}
EOF
kubectl apply -f ~/guard-lab/code/cilium/cnp-tenant-deny.yaml
kubectl get clusternetworkpolicy
cc tenant-b/api http://api.tenant-a
cc shop/frontend http://api.tenant-aErwartet (gekürzt, kann je nach Version abweichen):
clusternetworkpolicy.policy.networking.k8s.io/tenant-a-isolation created
clusternetworkpolicy.policy.networking.k8s.io/tenant-b-isolation created
NAME TIER PRIORITY AGE
tenant-a-isolation Admin 10 2s
tenant-b-isolation Admin 10 2s
✘ blockiert tenant-b/api -> http://api.tenant-a (Timeout)
✔ erlaubt shop/frontend -> http://api.tenant-a (HTTP 200)
Das Admin-Tier wird vor jeder NetworkPolicy ausgewertet.
allow-all-ingress kommt für tenant-b gar nicht
mehr zum Zug. Für alle anderen Quellen entscheidet weiter die
NetworkPolicy des Namespace – eine ClusterNetworkPolicy schaltet keinen
Default Deny ein.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Accept und Pass – Monitoring und Delegation
Die Plattform garantiert dem Monitoring Zugang zu Port 9113 – auch in
Namespaces, deren Team alles dichtgemacht hat (wie
tenant-b).
kubectl -n monitoring logs deploy/scraper --tail=3
cat > ~/guard-lab/code/cilium/cnp-monitoring.yaml <<'EOF'
apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
name: monitoring-accept
spec:
tier: Admin
priority: 20
subject:
namespaces:
matchLabels: {guard-lab: demo}
ingress:
- name: accept-scraper-metrics
action: Accept
from:
- namespaces:
matchLabels: {purpose: monitoring}
protocols:
- tcp:
destinationPort:
number: 9113
EOF
kubectl apply -f ~/guard-lab/code/cilium/cnp-monitoring.yaml
sleep 12; kubectl -n monitoring logs deploy/scraper --tail=3Erwartet (gekürzt, kann je nach Version abweichen):
ok shop
ok tenant-a
FAIL tenant-b
clusternetworkpolicy.policy.networking.k8s.io/monitoring-accept created
ok shop
ok tenant-a
ok tenant-b
Accept beendet die Auswertung: Die
deny-all-Policy in tenant-b sieht das Paket
nie. protocols ersetzt in v1alpha2 das alte
ports-Feld aus v1alpha1.
Jetzt will das shop-Team selbst bestimmen, wer scrapen
darf. Pass überspringt den Rest des Admin-Tiers und reicht
die Entscheidung an die NetworkPolicies weiter.
cat > ~/guard-lab/code/cilium/cnp-pass-shop.yaml <<'EOF'
apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
name: shop-delegate-monitoring
spec:
tier: Admin
priority: 15 # kleiner = früher geprüft: vor monitoring-accept
subject:
namespaces:
matchLabels: {kubernetes.io/metadata.name: shop}
ingress:
- name: pass-monitoring
action: Pass
from:
- namespaces:
matchLabels: {purpose: monitoring}
EOF
kubectl apply -f ~/guard-lab/code/cilium/cnp-pass-shop.yaml
kubectl -n shop create -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: deny-all}
spec: {podSelector: {}, policyTypes: [Ingress]}
EOF
cc monitoring/scraper http://api.shop:9113/metrics
cc monitoring/scraper http://api.tenant-b:9113/metricsErwartet (gekürzt, kann je nach Version abweichen):
clusternetworkpolicy.policy.networking.k8s.io/shop-delegate-monitoring created
networkpolicy.networking.k8s.io/deny-all created
✘ blockiert monitoring/scraper -> http://api.shop:9113/metrics (Timeout)
✔ erlaubt monitoring/scraper -> http://api.tenant-b:9113/metrics (HTTP 200)
Gleiche Ausgangslage (Team-deny-all), anderes Ergebnis:
In shop hat Pass mit Priorität 15 vor dem
Accept mit Priorität 20 gegriffen, also entscheidet die
NetworkPolicy des Teams.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Baseline-Tier – Default Deny, den Teams überschreiben
Baseline ist das Gegenstück: Regeln, die nur gelten, wenn keine NetworkPolicy den Pod erfasst. Ideal für einen cluster-weiten Default Deny. Erst Tabula rasa:
kubectl delete netpol -n shop --all
kubectl delete netpol -n tenant-a --all
kubectl delete netpol -n tenant-b --all
cat > ~/guard-lab/code/cilium/cnp-baseline.yaml <<'EOF'
apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
name: baseline-deny
spec:
tier: Baseline
priority: 50
subject:
namespaces:
matchLabels: {guard-lab: demo}
ingress:
- name: deny-all-pods
action: Deny
from:
- namespaces: {}
EOF
kubectl apply -f ~/guard-lab/code/cilium/cnp-baseline.yaml
cc default/client http://frontend.shop
cc monitoring/scraper http://api.tenant-a:9113/metricsErwartet (gekürzt, kann je nach Version abweichen):
clusternetworkpolicy.policy.networking.k8s.io/baseline-deny created
✘ blockiert default/client -> http://frontend.shop (Timeout)
✔ erlaubt monitoring/scraper -> http://api.tenant-a:9113/metrics (HTTP 200)
Das Monitoring kommt durch, weil monitoring-accept im
Admin-Tier vorher entscheidet. Jetzt öffnet das shop-Team
sein Frontend mit einer ganz normalen NetworkPolicy:
cat <<'EOF' | kubectl apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: frontend-public
namespace: shop
spec:
podSelector:
matchLabels: {app: frontend}
ingress:
- ports:
- {port: http}
EOF
cc default/client http://frontend.shop
cc default/client http://api.shopErwartet (gekürzt, kann je nach Version abweichen):
networkpolicy.networking.k8s.io/frontend-public created
✔ erlaubt default/client -> http://frontend.shop (HTTP 200)
✘ blockiert default/client -> http://api.shop (Timeout)
Sobald eine NetworkPolicy den Pod erfasst, ist das Baseline-Tier für
ihn aus dem Spiel. api hat keine eigene Policy, also greift
für sie weiter baseline-deny.
Achtung: Baseline ist kein Sicherheitsnetz gegen Teams, sondern ein Default. Was niemals offen sein darf, gehört ins Admin-Tier.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Vergleich – Calico GlobalNetworkPolicy
Calico kennt cluster-weite Regeln seit Jahren, mit eigenen Tiers. Dieselbe Mandanten-Trennung wie in Drill 5 sieht so aus (nur lesen, Calico läuft im Lab nicht):
cat > ~/guard-lab/code/cilium/calico-gnp.yaml <<'EOF'
apiVersion: projectcalico.org/v3
kind: Tier
metadata:
name: platform
spec:
order: 100 # vor Tier "default" (dort liegen die NetworkPolicies)
defaultAction: Pass
---
apiVersion: projectcalico.org/v3
kind: GlobalNetworkPolicy
metadata:
name: platform.tenant-a-isolation # Präfix = Tier-Name (ältere Calico-Versionen)
spec:
tier: platform
order: 10 # kleiner = früher geprüft
namespaceSelector: tenant == 'a'
types:
- Ingress
ingress:
- action: Deny
source:
namespaceSelector: has(tenant) && tenant != 'a'
- action: Pass # Rest: weiter zum nächsten Tier (NetworkPolicies)
EOF| Konzept | ClusterNetworkPolicy | CCNP (Cilium) | GlobalNetworkPolicy (Calico) |
|---|---|---|---|
| Vorrang | tier + priority |
Deny vor Allow | Tier-order + order |
| Delegieren | action: Pass |
– | action: Pass |
| Selektoren | Label-Selector | Labels mit Präfix | Ausdrücke (has(x) && …) |
| Extras | networks, FQDN (exp.) |
L7, toFQDNs, Entities |
Log, Host-Endpoints, HTTP |
Calico ab 3.32 setzt zusätzlich ClusterNetworkPolicy um.
Wer heute neu anfängt, schreibt Leitplanken bevorzugt in der
Upstream-API und nutzt CNI-Typen nur für deren Extras.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Auf np-lab:
cc=~/guard-lab/code/demo/conncheck.sh
kubectl get crd clusternetworkpolicies.policy.networking.k8s.io >/dev/null 2>&1 \
&& echo "✔ CRD ClusterNetworkPolicy" || echo "✘ CRD fehlt"
[ "$(kubectl get clusternetworkpolicy --no-headers | wc -l)" -ge 4 ] \
&& echo "✔ mindestens 4 ClusterNetworkPolicies" || echo "✘ Policies fehlen"
while read -r src url want; do
"$cc" "$src" "$url" "$want" >/dev/null \
&& echo "✔ $src -> $url ($want)" || echo "✘ $src -> $url (erwartet: $want)"
done <<'EOF'
tenant-b/api http://api.tenant-a deny
shop/frontend http://api.tenant-a allow
monitoring/scraper http://api.tenant-b:9113/metrics allow
default/client http://frontend.shop allow
default/client http://api.shop deny
EOFChallenge
Bau Drill 3 mit der Upstream-API nach: Kein Pod in einem
Demo-Namespace darf 169.254.169.254 erreichen – und kein
Team kann das per NetworkPolicy wieder öffnen.
Hinweis: Egress-Regeln nutzen to, und
für IP-Bereiche gibt es den Peer networks.
Lösung
cat > ~/guard-lab/code/cilium/cnp-metadata-deny.yaml <<'EOF'
apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
name: deny-cloud-metadata
spec:
tier: Admin
priority: 5
subject:
namespaces:
matchLabels: {guard-lab: demo}
egress:
- name: deny-metadata
action: Deny
to:
- networks: ["169.254.169.254/32"]
EOF
kubectl apply -f ~/guard-lab/code/cilium/cnp-metadata-deny.yaml
cc tenant-a/api http://169.254.169.254/
cc tenant-a/api http://api.tenant-aErwartet (gekürzt, kann je nach Version abweichen):
clusternetworkpolicy.policy.networking.k8s.io/deny-cloud-metadata created
✘ blockiert tenant-a/api -> http://169.254.169.254/ (Timeout)
✔ erlaubt tenant-a/api -> http://api.tenant-a (HTTP 200)
Wie in Drill 3 beweist der Timeout allein nichts, denn in kind antwortet dort niemand. Prüf die Gegenprobe ohne Policy, bevor du dem Ergebnis traust.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- ClusterNetworkPolicy ist
v1alpha2: Felder können sich noch ändern. In Produktion nur mit einer Implementierung, die die Conformance-Tests besteht, und mit festem CRD-Stand. - Prioritäten als Bänder vergeben (0–99 Sicherheit, 100–199 Plattform-Dienste, …) und im Git dokumentieren. Gleiche Priorität bei überlappenden Regeln ist undefiniert.
- Auf Cilium-Clustern CCNP mit
enableDefaultDeny: falsefür reine Leitplanken – sonst sperrst du ganze Namespaces aus. - Wer cluster-weite Policies anlegen darf, regelt RBAC: nur die Plattform-Gruppe, nie Namespace-Admins. Kyverno kann zusätzlich prüfen (Tag 13).
- Aufräumen:
kind delete cluster --name np-lab;cilium-labbrauchst du an Tag 6.