Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Zusammenspiel – Kyverno erzwingt NetworkPolicies

Ziel: Kyverno sorgt dafür, dass jeder Mandant isoliert startet und isoliert bleibt, Onboarding ist ein Namespace mit Label, und Argo CD liefert alles aus Git. · Dauer: ca. 120 min · Voraussetzung: Tag 3, Tag 9, Tag 12

Briefing

  • NetworkPolicies schützen nur, wenn sie da sind. Kyverno macht aus „sollte“ ein „ist“: generieren (Tag 9), prüfen (Audit) und gefährliche Policies ablehnen (Deny).
  • Mandanten-Vertrag = Label tenant am Namespace. Daran hängen Default Deny, DNS, Quota, RBAC und Pod Security.
  • Argo CD liefert Policies vor den Mandanten aus (Sync-Waves). Kyverno ergänzt den Rest im Cluster.
  • Cluster-Ausgaben sind nicht live getestet. Live geprüft: Kyverno-CLI 1.19.1, helm template, kubeconform.
Git ──► Argo CD ──► Welle -1: Kyverno-Policies
                    Welle  0: Namespace tenant-d (Label tenant=d)
                                 │ Kyverno generiert / mutiert
                                 ▼
                     default-deny, allow-dns, allow-same-namespace,
                     tenant-quota, team-edit, PSA restricted
                    Welle  1: Deployment api

Drill 1: Default Deny als Pflicht prüfen

Tag 9 generiert die Default-Deny-Policy. Diese ValidatingPolicy prüft unabhängig davon jeden Mandanten-Namespace, auch im Background-Scan. resource.List liest die NetworkPolicies des Namespace live aus dem Cluster.

mkdir -p ~/guard-lab/tag13 && cd ~/guard-lab/tag13
cp -R ~/guard-lab/code/kyverno-ops/tag13/. .
sed -n '/variables:/,$p' policies/require-default-deny.yaml

Erwartet:

  variables:
  - name: nps
    expression: >-
      dyn(resource.List('networking.k8s.io/v1', 'networkpolicies',
        object.metadata.name).items)
  validations:
  - expression: >-
      variables.nps.exists(np,
        size(np.spec.podSelector) == 0 &&
        !has(np.spec.ingress) && !has(np.spec.egress) &&
        'Ingress' in np.spec.policyTypes && 'Egress' in np.spec.policyTypes)
    messageExpression: >-
      'Namespace ' + object.metadata.name + ' hat keine Default-Deny-Policy'

Warum dyn(...)? resource.List liefert den Typ any. Ohne Cast verweigert der CEL-Compiler exists() mit „expression of type ‘any’ cannot be range of a comprehension“.

Offline ersetzt eine Context-Datei den Cluster. tenant-a hat dort eine Default-Deny- Policy, tenant-b nur allow-dns:

grep -E 'kind: Context|name: ' tests/require-default-deny/context.yaml
kyverno test tests/require-default-deny --remove-color | grep -E '│ [0-9]|Summary'

Erwartet:

kind: Context
  name: netpols
    metadata: {name: default-deny, namespace: tenant-a}
    metadata: {name: allow-dns, namespace: tenant-b}
│ 1  │ require-default-deny │      │ v1/Namespace//tenant-a │ Pass   │ Ok     │
│ 2  │ require-default-deny │      │ v1/Namespace//tenant-b │ Pass   │ Ok     │
Test Summary: 2 tests passed and 0 tests failed

Im Cluster prüfst du den Report der Namespaces. Tag 9 hat tenant-netpol am Ende wieder gelöscht – spiel die Policy deshalb zuerst erneut ein:

kubectl apply -f ~/guard-lab/code/kyverno/tag09/tenant-netpol.yaml
kubectl apply -f policies/require-default-deny.yaml
kubectl -n tenant-b delete netpol default-deny
sleep 30
kubectl get clusterpolicyreports -o json | jq -r '.items[]
  | select(.scope.name | test("^tenant-")) | .scope.name + " "
  + ([.results[] | select(.policy=="require-default-deny") | .result] | join(","))'
kubectl -n tenant-b get netpol default-deny

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

networkpolicy.networking.k8s.io "default-deny" deleted
tenant-a pass
tenant-b pass
NAME           POD-SELECTOR   AGE
default-deny   <none>         4s

Die gelöschte Policy ist sofort zurück: synchronize: true in tenant-netpol (Tag 9). Generieren und Prüfen ergänzen sich. Fällt die Generierung aus (Background-Controller weg, RBAC kaputt), meldet der Report fail.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Kein Egress ins Internet

Default Deny nützt wenig, wenn ein Team danach 0.0.0.0/0 freigibt. Die Policy lehnt in Mandanten-Namespaces zwei Muster ab: ipBlock mit 0.0.0.0/0 oder ::/0 und Egress-Regeln ganz ohne to (die erlauben jedes Ziel), außer für Port 53.

sed -n '/validations:/,$p' policies/no-world-egress.yaml
kyverno apply policies/no-world-egress.yaml -r tests/no-world-egress/netpols.yaml \
  --values-file tests/no-world-egress/values.yaml --remove-color | tail -6

Erwartet:

  validations:
  - expression: >-
      !variables.egress.exists(r, has(r.to) && r.to.exists(p,
        has(p.ipBlock) && p.ipBlock.cidr in variables.world))
    messageExpression: >-
      'NetworkPolicy ' + object.metadata.name +
      ': Egress nach 0.0.0.0/0 oder ::/0 ist für Mandanten verboten'
  - expression: >-
      variables.egress.all(r, has(r.to) && size(r.to) > 0 ||
        (has(r.ports) && r.ports.all(p, has(p.port) && p.port == 53)))
    message: Egress-Regel ohne 'to' erlaubt alle Ziele (nur für Port 53 ok).
policy no-world-egress -> resource tenant-a/NetworkPolicy/internet failed:
1 -  NetworkPolicy internet: Egress nach 0.0.0.0/0 oder ::/0 ist für Mandanten verboten
policy no-world-egress -> resource tenant-a/NetworkPolicy/alles-raus failed:
1 -  Egress-Regel ohne 'to' erlaubt alle Ziele (nur für Port 53 ok).

pass: 2, fail: 2, warn: 0, error: 0, skip: 0

Fünf Testobjekte, vier Ergebnisse: shop/internet öffnet auch 0.0.0.0/0, aber shop trägt kein Label tenant. Die Plattform darf das, Mandanten nicht. Der Test dazu:

kyverno test tests/no-world-egress --remove-color | grep Summary
kubectl apply -f policies/no-world-egress.yaml
kubectl apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: internet, namespace: tenant-a}
spec:
  podSelector: {}
  policyTypes: [Egress]
  egress:
  - to: [{ipBlock: {cidr: 0.0.0.0/0, except: [10.0.0.0/8]}}]
EOF

Erwartet (erste Zeile live, Rest gekürzt, nicht live getestet):

Test Summary: 4 tests passed and 0 tests failed
validatingpolicy.policies.kyverno.io/no-world-egress created
Error from server: error when creating "STDIN": admission webhook "…" denied the
request: Policy no-world-egress failed: NetworkPolicy internet: Egress nach 0.0.0.0/0
oder ::/0 ist für Mandanten verboten

Sicherheit: except: [10.0.0.0/8] macht es nicht besser. Die Regel öffnet trotzdem das ganze Internet. Externe Ziele laufen über einen Egress-Proxy oder FQDN-Policies (Tag 4).

Fortschritt speichern? Kostenlos registrieren

Drill 3: Generieren – das Onboarding-Paket

tenant-netpol aus Tag 9 liefert default-deny und allow-dns. tenant-onboarding ergänzt, was ein Mandant sonst noch braucht:

grep -E '"kind": dyn' policies/tenant-onboarding.yaml
grep -E 'synchronize|generateExisting' -A1 policies/tenant-onboarding.yaml

Erwartet:

          "kind": dyn("NetworkPolicy"),
          "kind": dyn("ResourceQuota"),
          "kind": dyn("RoleBinding"),
    synchronize:
      enabled: true
    generateExisting:
      enabled: true
  • allow-same-namespace: Pods eines Mandanten sprechen miteinander, mit niemandem sonst.
  • tenant-quota: 20 Pods, 2 CPU Requests, 4 Gi Memory-Limits.
  • team-edit: Die Gruppe aus dem Label team bekommt edit im eigenen Namespace.

synchronize stellt gelöschte oder veränderte Objekte wieder her. generateExisting versorgt beim Anlegen der Policy auch bestehende Mandanten (tenant-a, tenant-b).

Fortschritt speichern? Kostenlos registrieren

Drill 4: Pod Security per Label nachziehen

Der dritte Baustein ist Pod Security Admission (PSA). Eine MutatingPolicy setzt die PSA-Labels, sobald ein Namespace das Label tenant trägt:

sed -n '/applyConfiguration:/,$p' policies/tenant-psa-labels.yaml
kyverno apply policies/tenant-psa-labels.yaml -r tenant-d.yaml --remove-color \
  | grep -E 'pod-security|pass:'

Erwartet:

    applyConfiguration:
      expression: >-
        Object{
          metadata: Object.metadata{
            labels: {
              "pod-security.kubernetes.io/enforce": "restricted",
              "pod-security.kubernetes.io/enforce-version": "latest",
              "pod-security.kubernetes.io/warn": "restricted"
            }
          }
        }
        pod-security.kubernetes.io/enforce: restricted
        pod-security.kubernetes.io/enforce-version: latest
        pod-security.kubernetes.io/warn: restricted
pass: 2, fail: 0, warn: 0, error: 0, skip: 0

ApplyConfiguration mergt: Bestehende Labels wie team bleiben erhalten.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Onboarding – ein Namespace, ein Label

Vorschau ohne Cluster: alle drei Policies gegen den neuen Namespace tenant-d.

cat tenant-d.yaml
kyverno apply ~/guard-lab/code/kyverno/tag09/tenant-netpol.yaml \
  policies/tenant-onboarding.yaml policies/tenant-psa-labels.yaml \
  -r tenant-d.yaml --remove-color | grep -E '^kind:' | sort | uniq -c

Erwartet:

apiVersion: v1
kind: Namespace
metadata:
  name: tenant-d
  labels: {guard-lab: demo, team: tenant-d, tenant: d}
   1 kind: Namespace
   3 kind: NetworkPolicy
   1 kind: ResourceQuota
   1 kind: RoleBinding

Ein Objekt rein, sechs raus. Jetzt im Cluster und mit conncheck.sh aus Tag 0:

kubectl apply -f policies/
kubectl apply -f tenant-d.yaml
sleep 10
kubectl -n tenant-d get netpol,resourcequota,rolebinding -o name
kubectl get ns tenant-d -o jsonpath='{.metadata.labels}' | jq -c
kubectl apply -f gitops/tenants/tenant-d/10-api.yaml
kubectl -n tenant-d rollout status deploy api --timeout=90s
cc=~/guard-lab/code/demo/conncheck.sh
$cc tenant-a/api http://api.tenant-d deny
$cc tenant-d/api http://api.tenant-a deny
$cc tenant-d/api http://api.tenant-d allow

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

networkpolicy.networking.k8s.io/allow-dns
networkpolicy.networking.k8s.io/allow-same-namespace
networkpolicy.networking.k8s.io/default-deny
resourcequota/tenant-quota
rolebinding.rbac.authorization.k8s.io/team-edit
{"guard-lab":"demo","kubernetes.io/metadata.name":"tenant-d","pod-security.kubernetes…
deployment "api" successfully rolled out
✘ blockiert tenant-a/api -> http://api.tenant-d (Timeout)
✘ blockiert tenant-d/api -> http://api.tenant-a (Timeout)
✔ erlaubt   tenant-d/api -> http://api.tenant-d (HTTP 200)

Achtung: Kyverno generiert asynchron (Background-Controller). Zwischen Namespace und NetworkPolicy liegen ein bis zwei Sekunden. Wer sofort Pods startet, hat ein kurzes offenes Fenster. Abhilfe: Workloads eine Sync-Welle später (Drill 6).

Fortschritt speichern? Kostenlos registrieren

Drill 6: GitOps mit Argo CD

Struktur: App-of-Apps guard-lab-root, darin die Policies (Welle -1) und ein ApplicationSet, das pro Ordner unter tenants/ eine Application erzeugt (Welle 0). Im Mandanten-Ordner kommt der Namespace in Welle 0, die Workload in Welle 1.

cd ~/guard-lab/tag13/gitops
mkdir -p platform/policies
cp ../policies/*.yaml ~/guard-lab/code/kyverno/tag09/tenant-netpol.yaml \
  platform/policies/
grep -rh 'sync-wave' argocd tenants | sort | uniq -c
grep -A4 'directories' argocd/apps/tenants.yaml

Erwartet:

   1     argocd.argoproj.io/sync-wave: "-1"
   2     argocd.argoproj.io/sync-wave: "0"
   3   annotations: {argocd.argoproj.io/sync-wave: "1"}
      directories:
      - path: tenants/*
  template:
    metadata:
      name: 'tenant-{{.path.basename}}'

Statisch prüfen, bevor Argo CD es tut:

SCHEMA='https://raw.githubusercontent.com/datreeio/CRDs-catalog/main/'\
'{{.Group}}/{{.ResourceKind}}_{{.ResourceAPIVersion}}.json'
kubeconform -summary -schema-location default -schema-location "$SCHEMA" \
  argocd/root.yaml argocd/apps/ tenants/
helm template argocd argo/argo-cd --version 10.10.2 -n argocd \
  -f argocd/values-argocd.yaml | grep -h 'image:' | sort -u

Erwartet:

Summary: 7 resources found in 5 files - Valid: 7, Invalid: 0, Errors: 0, Skipped: 0
          image: quay.io/argoproj/argocd:v3.5.4
        image: ecr-public.aws.com/docker/library/redis:8.6.4-alpine
        image: quay.io/argoproj/argocd:v3.5.4

Installation und Start (Argo CD braucht ca. 1 GB RAM und ein Git-Repo, das der Cluster erreicht; git.example.com ersetzt du durch dein Repo):

helm install argocd argo/argo-cd --version 10.10.2 -n argocd --create-namespace \
  -f argocd/values-argocd.yaml --wait
kubectl apply -f argocd/root.yaml
kubectl -n argocd get applications

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

NAME               SYNC STATUS   HEALTH STATUS
guard-lab-root     Synced        Healthy
kyverno-policies   Synced        Healthy
tenant-tenant-d    Synced        Healthy

Zwei Stolpersteine sind schon eingebaut:

  • Die PSA-Labels stehen auch im Git-Namespace. Sonst sieht Argo CD die Kyverno-Mutation als Drift und meldet OutOfSync, und selfHeal kämpft gegen Kyverno.
  • Die generierten Objekte stehen nicht in Git und tragen kein Argo-Tracking. Argo CD ignoriert sie, prune löscht sie nicht. Kyverno-Reports schließt Argo CD ab 3.0 per Default aus (resource.exclusions in argocd-cm).

Fortschritt speichern? Kostenlos registrieren

Drill 7: Pod Security Admission vs. Kyverno

Beide prüfen Pods. PSA ist eingebaut und ausfallsicher, aber starr. Kyverno ist flexibel, hängt aber an einem Webhook. Der direkte Vergleich in tenant-d:

kubectl -n tenant-d run root-shell --image=curlimages/curl:8.22.0 \
  --dry-run=server -- sleep 1
kubectl label --dry-run=server --overwrite ns shop \
  pod-security.kubernetes.io/enforce=restricted

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

Error from server (Forbidden): pods "root-shell" is forbidden: violates PodSecurity
"restricted:latest": allowPrivilegeEscalation != false (container "root-shell" must set
securityContext.allowPrivilegeEscalation=false), unrestricted capabilities (…),
runAsNonRoot != true (…), seccompProfile (…)
namespace/shop labeled (server dry run)

Der erste Request scheitert an PSA, bevor ein Webhook gefragt wird. Der zweite zeigt per Dry-Run, ob shop schon restricted verträgt: keine Warnungen, also ja.

Kriterium Pod Security Admission Kyverno
Läuft wo im API-Server, kein Webhook Webhook + Controller
Regeln 3 feste Profile beliebig (CEL, Kontext)
Ausnahmen nur pro Namespace / global PolicyException, fein, befristet
Mutieren, Generieren nein ja (Defaults, NetworkPolicies)
Reports, Audit Warnungen, Audit-Log PolicyReports, Background-Scan
Ausfallrisiko keins failurePolicy (Tag 12)
Andere Objekte nur Pods alle Kinds, auch NetworkPolicies

Empfehlung: PSA restricted als Fundament für Mandanten (per Label aus Drill 4), Kyverno für alles, was PSA nicht kann: Registries, Tags, Labels, NetworkPolicies, Ausnahmen. Die Pod-Security-Regeln aus Tag 8 bleiben als Audit für Reports und als Netz für Namespaces ohne PSA-Label.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
cd ~/guard-lab/tag13
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
kyverno test tests >/dev/null 2>&1 && ok "Offline-Tests" || nok "Offline-Tests"
for np in default-deny allow-dns allow-same-namespace; do
  kubectl -n tenant-d get netpol "$np" >/dev/null 2>&1 \
    && ok "tenant-d/$np" || nok "tenant-d/$np"
done
[ "$(kubectl get ns tenant-d \
  -o jsonpath='{.metadata.labels.pod-security\.kubernetes\.io/enforce}')" \
  = restricted ] && ok "PSA restricted" || nok "PSA restricted"
kubectl apply --dry-run=server -f tests/no-world-egress/netpols.yaml \
  2>&1 | grep -q 'für Mandanten verboten' \
  && ok "0.0.0.0/0 wird abgelehnt" || nok "0.0.0.0/0 wird abgelehnt"
~/guard-lab/code/demo/conncheck.sh tenant-a/api http://api.tenant-d deny \
  >/dev/null && ok "tenant-a -> tenant-d blockiert" || nok "tenant-a -> tenant-d"

Challenge

Ein Team umgeht no-world-egress mit 0.0.0.0/1 (die halbe IPv4-Welt). Schreibe eine Policy, die in Mandanten nur ipBlock-Bereiche ab /16 erlaubt.

Hinweis: Die Kubernetes-CEL-Bibliothek kennt cidr('…').prefixLength().

Lösung

sed -n '/validations:/,$p' challenge-max-prefix.yaml
kyverno apply challenge-max-prefix.yaml -r challenge-netpols.yaml \
  --values-file tests/no-world-egress/values.yaml --remove-color | tail -4

Erwartet:

  validations:
  - expression: >-
      object.spec.?egress.orValue([]).all(r,
        r.?to.orValue([]).all(p, !has(p.ipBlock) ||
          cidr(p.ipBlock.cidr).prefixLength() >= 16))
    message: ipBlock im Egress höchstens /16 breit.
policy egress-max-prefix -> resource tenant-a/NetworkPolicy/halbes-internet failed:
1 -  ipBlock im Egress höchstens /16 breit.

pass: 1, fail: 1, warn: 0, error: 0, skip: 0

Die Partner-Regel mit 203.0.113.0/24 besteht. 0.0.0.0/0 fängt diese Policy ebenfalls, no-world-egress bleibt trotzdem für die klarere Meldung.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Mandanten-Onboarding als Git-Merge-Request: ein Ordner unter tenants/, Review durch die Plattform, ApplicationSet erzeugt den Rest. Kein kubectl für Teams.
  • Labels tenant und team sind sicherheitsrelevant: Wer sie setzen darf, bekommt RoleBindings und Netzfreigaben. Namespaces nur über GitOps anlegen, RBAC für namespaces/update eng halten.
  • Bei Argo CD und Kyverno: Mutationen in Git spiegeln oder per ignoreDifferences ausnehmen, sonst Drift-Schleifen mit selfHeal.
  • Default Deny generieren und zusätzlich per Audit prüfen. Den Report des Background-Scans als Compliance-Nachweis (z. B. DORA, ISO 27001) exportieren.
  • Für clusterweite Leitplanken, die kein Mandant überschreiben kann, zusätzlich AdminNetworkPolicy oder CiliumClusterwideNetworkPolicy (Tag 5) nutzen.