Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: Cluster-weite Regeln

Ziel: Leitplanken setzen, die kein Namespace-Admin aushebeln kann: mit CiliumClusterwideNetworkPolicy und mit der neuen Kubernetes-API ClusterNetworkPolicy. · 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) mit tier: Admin oder Baseline.
  • Aktionen: Accept (früher Allow), Deny, Pass. priority 0–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 networkpolic

Erwartet (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 cnp ist doppelt belegt: in Cilium für CiliumNetworkPolicy, upstream für ClusterNetworkPolicy. 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-a

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

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

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

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

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

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

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

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

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

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

Challenge

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

Erwartet (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: false fü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-lab brauchst du an Tag 6.