Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 6: Policies testen und visualisieren

Ziel: NetworkPolicies wie Code behandeln: Soll-Matrix als Datei, Prüfskript mit ✔/✘-Tabelle, statische Analyse, Hubble UI und ein CI-Job mit kind. · Dauer: ca. 90 min · Voraussetzung: Tag 5

Briefing

  • Eine Policy ist erst fertig, wenn ein Test beweist, was sie erlaubt und was sie verbietet. Die Negativ-Fälle sind die wichtigeren.
  • Die Soll-Matrix gehört als Datei ins Git (von nach soll). Ein Skript vergleicht sie mit der Wirklichkeit und liefert einen Exit-Code für CI.
  • Statische Analyse (policy-assistant) braucht keinen Cluster und erklärt, warum. Laufzeit-Tests (conncheck.sh) beweisen, dass das CNI es auch tut.
  • Hubble UI und editor.networkpolicy.io machen Policies und Flows sichtbar – gut für Reviews mit Teams, die kein YAML lesen wollen.
 matrix.tsv ──► np-matrix.sh ──► conncheck.sh ──► kubectl exec ──► ✔/✘ + Exit-Code
 policies/  ──► policy-assistant (offline)    ──► Erklär- und Probe-Tabellen
 Hubble     ──► UI (Service Map) / flows.json  ──► editor.networkpolicy.io

Drill 1: Gelände vorbereiten

Weiter auf cilium-lab. Die Cilium-Policies aus Tag 4 und 5 räumst du ab, dann kommt ein sauberer Soll-Zustand für shop – eine Datei pro Policy.

mkdir -p ~/guard-lab/tag06 ~/guard-lab/code/np-tests/policies
cd ~/guard-lab/code/np-tests
kubectl config use-context kind-cilium-lab
kubectl delete cnp --all -A
kubectl delete ccnp --all
cat > policies/10-default-deny.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: shop
spec:
  podSelector: {}
  policyTypes: [Ingress]
EOF
cat > policies/20-frontend-public.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-public
  namespace: shop
spec:
  podSelector:
    matchLabels: {app: frontend}
  policyTypes: [Ingress]
  ingress:
  - ports:
    - {port: 8080, protocol: TCP}
EOF
cat > policies/30-api-from-frontend.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-frontend
  namespace: shop
spec:
  podSelector:
    matchLabels: {app: api}
  policyTypes: [Ingress]
  ingress:
  - from:
    - podSelector:
        matchLabels: {app: frontend}
    ports:
    - {port: 8080, protocol: TCP}
  - from:
    - namespaceSelector:
        matchLabels: {purpose: monitoring}
    ports:
    - {port: 9113, protocol: TCP}
EOF
cat > policies/40-db-from-api.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-from-api
  namespace: shop
spec:
  podSelector:
    matchLabels: {app: db}
  policyTypes: [Ingress]
  ingress:
  - from:
    - podSelector:
        matchLabels: {app: api}
    ports:
    - {port: 5432, protocol: TCP}
EOF
kubectl apply -f policies/

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

ciliumnetworkpolicy.cilium.io "api-l4" deleted
...
ciliumclusterwidenetworkpolicy.cilium.io "tenant-deny" deleted
networkpolicy.networking.k8s.io/default-deny created
networkpolicy.networking.k8s.io/frontend-public created
networkpolicy.networking.k8s.io/api-from-frontend created
networkpolicy.networking.k8s.io/db-from-api created

Warum explizit policyTypes, obwohl der API-Server es ergänzen würde? Offline-Werkzeuge (Drill 4) sehen nur die Datei, nicht den vom Server ergänzten Default.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Soll-Matrix und Prüfskript

Die Matrix ist eine schlichte Textdatei: Quelle, Ziel, Erwartung. Negativ-Fälle zuerst denken – was darf nie gehen?

cat > matrix.tsv <<'EOF'
# von                 nach                                 soll
default/client        http://frontend.shop                 allow
default/client        http://api.shop                      deny
default/client        tcp://db.shop:5432                   deny
shop/frontend         http://api.shop                      allow
shop/frontend         tcp://db.shop:5432                   deny
shop/api              tcp://db.shop:5432                   allow
monitoring/scraper    http://api.shop:9113/metrics         allow
monitoring/scraper    http://api.shop                      deny
tenant-a/api          http://api.shop                      deny
EOF
cat > np-matrix.sh <<'EOF'
#!/usr/bin/env bash
# np-matrix.sh - Testmatrix für NetworkPolicies: von -> nach, Soll gegen Ist
#
#   np-matrix.sh [--md] <matrix.tsv>
#
#   matrix.tsv  Zeilen "<ns>/<pod|app> <url> allow|deny", # = Kommentar
#   --md        Ausgabe als Markdown-Tabelle (z. B. für $GITHUB_STEP_SUMMARY)
#
# Exit 0 = alles wie erwartet, 1 = mindestens eine Abweichung, 2 = Aufruffehler.
# CC zeigt auf conncheck.sh (Standard: ~/guard-lab/code/demo/conncheck.sh).
set -uo pipefail

md=false
[[ ${1:-} == --md ]] && { md=true; shift; }
file=${1:-}
cc=${CC:-$HOME/guard-lab/code/demo/conncheck.sh}
if [[ -z $file || ! -r $file ]]; then
  echo "Aufruf: $0 [--md] <matrix.tsv>" >&2
  exit 2
fi

if $md; then
  echo "| von | nach | soll | ist |"
  echo "|---|---|---|---|"
else
  printf '%-22s %-34s %-6s %s\n' VON NACH SOLL IST
fi

ok=0 bad=0
while read -r src url want _; do
  [[ -z ${src:-} || $src == \#* ]] && continue
  "$cc" "$src" "$url" </dev/null >/dev/null 2>&1
  case $? in
    0) got=allow ;;
    1) got=deny ;;
    *) got=error ;;
  esac
  if [[ $got == "$want" ]]; then mark="✔"; ok=$((ok + 1))
  else mark="✘"; bad=$((bad + 1)); fi
  if $md; then
    echo "| \`$src\` | \`$url\` | $want | $mark $got |"
  else
    printf '%-22s %-34s %-6s %s %s\n' "$src" "$url" "$want" "$mark" "$got"
  fi
done < "$file"

echo
echo "$((ok + bad)) Tests: $ok ✔, $bad ✘"
[[ $bad -eq 0 ]]
EOF
chmod +x np-matrix.sh
./np-matrix.sh matrix.tsv; echo "rc=$?"

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

VON                    NACH                               SOLL   IST
default/client         http://frontend.shop               allow  ✔ allow
default/client         http://api.shop                    deny   ✔ deny
default/client         tcp://db.shop:5432                 deny   ✔ deny
shop/frontend          http://api.shop                    allow  ✔ allow
shop/frontend          tcp://db.shop:5432                 deny   ✔ deny
shop/api               tcp://db.shop:5432                 allow  ✔ allow
monitoring/scraper     http://api.shop:9113/metrics       allow  ✔ allow
monitoring/scraper     http://api.shop                    deny   ✔ deny
tenant-a/api           http://api.shop                    deny   ✔ deny

9 Tests: 9 ✔, 0 ✘
rc=0

Zwei Details: </dev/null am conncheck.sh-Aufruf verhindert, dass ein Befehl in der Schleife die restlichen Zeilen der Matrix vom Standard-Input frisst. Und error (Exit 2, z. B. Quell-Pod fehlt) zählt immer als Abweichung – ein Test, der nicht läuft, ist rot.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Regression provozieren

Ein Kollege „räumt Labels auf” und benennt im Selector frontend in web um.

sed 's/app: frontend}/app: web}/' policies/30-api-from-frontend.yaml \
  | kubectl apply -f -
./np-matrix.sh matrix.tsv > ~/guard-lab/tag06/run.txt; echo "rc=$?"
grep -E '✘|Tests' ~/guard-lab/tag06/run.txt

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

networkpolicy.networking.k8s.io/api-from-frontend configured
rc=1
shop/frontend          http://api.shop                    allow  ✘ deny
9 Tests: 8 ✔, 1 ✘

Genau ein Fehler, genau an der richtigen Stelle. Das Frontend selbst läuft weiter (/ liefert 200), nur /api/… scheitert – ohne Matrix fällt das oft erst in Produktion auf. Zurück zum Soll:

kubectl apply -f policies/30-api-from-frontend.yaml
./np-matrix.sh matrix.tsv | tail -1

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

networkpolicy.networking.k8s.io/api-from-frontend configured
9 Tests: 9 ✔, 0 ✘

Fortschritt speichern? Kostenlos registrieren

Drill 4: Statische Analyse mit policy-assistant

policy-assistant aus dem SIG-Projekt network-policy-api ist der Nachfolger von cyclonus (seit 2024 ohne Pflege). Er liest Policies aus Dateien und simuliert Verbindungen – ganz ohne Cluster. Es gibt ein Release-Binary nur für amd64; auf Apple Silicon läuft es per Rosetta.

cd /tmp
curl -sLO https://github.com/kubernetes-sigs/network-policy-api/releases/download/\
v0.0.1-policy-assistant/policy-assistant_darwin_amd64.tar.gz
tar xzf policy-assistant_darwin_amd64.tar.gz
PA=/tmp/policy-assistant_darwin_amd64/policy-assistant
cd ~/guard-lab/code/np-tests
$PA analyze -v warn --mode explain --policy-path policies/ | cut -c1-86 | head -9

Erwartet:

explained policies:
+---------+-------------------+-------------------------------+-----------------------
|  TYPE   |      SUBJECT      |         SOURCE RULES          |          PEER
+---------+-------------------+-------------------------------+-----------------------
| Ingress | Namespace:        | [NPv1] shop/api-from-frontend | Namespace:
|         |    shop           |                               |    shop
|         | Pod:              |                               | Pod:
|         |    app = api      |                               |    app = frontend
+         +                   +                               +-----------------------

Achtung: policy-assistant liest pro Datei nur das erste YAML-Dokument und verlangt policyTypes. Deshalb eine Policy pro Datei (Drill 1).

Für die Simulation beschreibst du Pods und Namespaces in einer JSON-Datei – ein kleines Modell der Demo-App:

cat > probe.json <<'EOF'
{
  "Probes": [
    {"Protocol": "TCP", "Port": 8080},
    {"Protocol": "TCP", "Port": 5432}
  ],
  "Resources": {
    "Namespaces": {
      "shop": {"kubernetes.io/metadata.name": "shop", "guard-lab": "demo"},
      "monitoring": {"kubernetes.io/metadata.name": "monitoring",
                     "purpose": "monitoring"},
      "default": {"kubernetes.io/metadata.name": "default"}
    },
    "Pods": [
      {"Namespace": "shop", "Name": "frontend", "IP": "10.244.1.10",
       "Labels": {"app": "frontend", "tier": "web"},
       "Containers": [{"Name": "nginx", "Port": 8080, "PortName": "http",
                       "Protocol": "TCP"}]},
      {"Namespace": "shop", "Name": "api", "IP": "10.244.1.11",
       "Labels": {"app": "api", "tier": "api"},
       "Containers": [{"Name": "nginx", "Port": 8080, "PortName": "http",
                       "Protocol": "TCP"}]},
      {"Namespace": "shop", "Name": "db", "IP": "10.244.1.12",
       "Labels": {"app": "db", "tier": "data"},
       "Containers": [{"Name": "nginx", "Port": 5432, "PortName": "postgres",
                       "Protocol": "TCP"}]},
      {"Namespace": "default", "Name": "client", "IP": "10.244.2.20",
       "Labels": {"app": "client"},
       "Containers": [{"Name": "curl", "Port": 80, "PortName": "none",
                       "Protocol": "TCP"}]}
    ]
  }
}
EOF
$PA analyze -v warn --mode probe --policy-path policies/ --probe-path probe.json \
  | grep -A8 Combined

Erwartet:

Combined:
+----------------+----------------+----------+---------+---------------+
|                | DEFAULT/CLIENT | SHOP/API | SHOP/DB | SHOP/FRONTEND |
+----------------+----------------+----------+---------+---------------+
| default/client | N              | X        | N       | .             |
| shop/api       | N              | #        | N       | .             |
| shop/db        | N              | X        | N       | .             |
| shop/frontend  | N              | .        | N       | #             |
+----------------+----------------+----------+---------+---------------+
--
Combined:
...
| default/client | N              | N        | X       | N             |
| shop/api       | N              | N        | .       | N             |
| shop/frontend  | N              | N        | X       | N             |

Zeilen sind Quellen, Spalten Ziele; je eine Tabelle pro Probe (8080, dann 5432). . = erlaubt, X = blockiert, N = das Ziel lauscht nicht auf dem Port, # = der Pod selbst. Ergebnis wie in Drill 2 – nur in Millisekunden und ohne Cluster. Probier die Regression aus Drill 3 offline: Die Zelle shop/frontend → SHOP/API wird zu X.

Tipp: policy-assistant kennt NetworkPolicy und ANP/BANP v1alpha1, aber noch keine ClusterNetworkPolicy v1alpha2 und keine Cilium-Typen. Für die gilt: Laufzeit-Test.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Hubble UI – die Service Map

Zurück im Cluster. Die UI hast du an Tag 4 mitinstalliert.

cilium hubble ui --open-browser=false &
sleep 3
for i in 1 2 3; do ~/guard-lab/code/np-tests/np-matrix.sh \
  ~/guard-lab/code/np-tests/matrix.tsv >/dev/null; done

Der Befehl baut einen Port-Forward zum Service hubble-ui auf (Standard-Port 12000). Öffne http://localhost:12000, wähle oben den Namespace shop. Du siehst die Kästen frontend, api, db und die eingehenden Pfeile von client, scraper und tenant-a/api. Verworfene Flows sind rot markiert, in der Flow-Tabelle unten steht dropped mit dem Grund Policy denied. Ein Klick auf einen Flow zeigt Quell- und Ziel-Labels – genau die Labels, auf die deine Selektoren passen müssen.

kill %1

Sicherheit: Die UI zeigt alle Flows aller Namespaces. In Produktion nie ohne Authentifizierung (Ingress mit OIDC) und nie per LoadBalancer veröffentlichen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: editor.networkpolicy.io

Der Policy-Editor der Cilium-Community läuft im Browser und kennt NetworkPolicy und CiliumNetworkPolicy. Er zeigt eine Policy als Bild: Pod in der Mitte, erlaubte Quellen und Ziele links und rechts, Default Deny als rote Fläche.

cat ~/guard-lab/code/np-tests/policies/30-api-from-frontend.yaml | pbcopy
  1. https://editor.networkpolicy.io öffnen, „Upload” bzw. YAML-Feld wählen, einfügen.
  2. Prüfen: Ingress zeigt app=frontend auf 8080 und purpose=monitoring auf 9113.
  3. Egress ist offen (grün), weil die Policy nur Ingress regelt.
  4. Änderungen im Bild vornehmen und das YAML wieder herunterladen.

Der Editor kann außerdem aus Hubble-Flows Policy-Vorschläge erzeugen:

hubble observe -P --namespace shop --last 200 -o json > ~/guard-lab/tag06/flows.json
wc -l ~/guard-lab/tag06/flows.json

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

200 /Users/<du>/guard-lab/tag06/flows.json

Sicherheit: Flows enthalten IPs, Namen und URLs. Echte Kunden-Flows lädst du nicht in ein öffentliches Web-Werkzeug. Für Produktion: Vorschläge lokal erzeugen und im Review prüfen – ein generierter Allow-All-Observed ist keine Sicherheitsarchitektur.

Fortschritt speichern? Kostenlos registrieren

Drill 7: CI-Job mit kind

Was lokal läuft, läuft auch in der Pipeline: frischer kind-Cluster (kindnet setzt NetworkPolicies durch), Demo-App, Policies, Matrix. Annahme: Dein Repo enthält code/demo/ und code/np-tests/ wie ~/guard-lab/code/.

mkdir -p ~/guard-lab/code/np-tests/ci && cd ~/guard-lab/code/np-tests/ci
cat > github-np-tests.yaml <<'EOF'
# Tag 6: GitHub Actions - nach .github/workflows/np-tests.yaml kopieren
name: np-tests
on:
  pull_request:
    paths: ["code/**"]
  workflow_dispatch:
jobs:
  matrix:
    runs-on: ubuntu-24.04
    timeout-minutes: 20
    defaults:
      run:
        shell: bash               # = bash -eo pipefail: tee schluckt den rc nicht
    steps:
    - uses: actions/checkout@v7
    - uses: helm/[email protected]      # kindnet setzt NetworkPolicies durch
      with:
        version: v0.33.0
        cluster_name: np-ci
    - name: Demo-App ausrollen
      run: |
        kubectl apply -f code/demo/
        kubectl wait --for=condition=Ready pod --all -A --timeout=300s
    - name: Policies anwenden
      run: kubectl apply -f code/np-tests/policies/
    - name: Testmatrix
      env:
        CC: ${{ github.workspace }}/code/demo/conncheck.sh
      run: |
        sleep 5
        code/np-tests/np-matrix.sh --md code/np-tests/matrix.tsv \
          | tee -a "$GITHUB_STEP_SUMMARY"
EOF

Kopiert nach .github/workflows/np-tests.yaml läuft der Job bei jedem Pull Request, der code/ ändert. --md schreibt die Tabelle in die Job-Zusammenfassung – Reviewer sehen ✔/✘ direkt im PR. shell: bash ist nötig, damit pipefail gilt und tee den Exit-Code von np-matrix.sh nicht verschluckt.

Prüf den Workflow lokal mit actionlint, bevor du pushst:

go run github.com/rhysd/actionlint/cmd/actionlint@latest github-np-tests.yaml \
  && echo "✔ actionlint"

Erwartet:

✔ actionlint

In GitLab läuft kind in Docker-in-Docker. Der API-Server liegt dann nicht auf 127.0.0.1 des Jobs, sondern im Service-Container docker – daher die eigene kind-Konfiguration:

cat > kind-ci.yaml <<'EOF'
# Tag 6: kind in GitLab CI (Docker-in-Docker) - API-Server über den Service "docker"
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
networking:
  apiServerAddress: "0.0.0.0"   # nur im Wegwerf-CI-Job vertretbar
  apiServerPort: 6443
kubeadmConfigPatches:
- |
  kind: ClusterConfiguration
  apiServer:
    certSANs: ["docker"]
EOF
cat > gitlab-np-tests.yaml <<'EOF'
# Tag 6: GitLab CI - als Job in .gitlab-ci.yml übernehmen (Runner mit privileged dind)
np-tests:
  image: docker:29.1
  services:
  - name: docker:29.1-dind
    alias: docker
  variables:
    DOCKER_HOST: tcp://docker:2375
    DOCKER_TLS_CERTDIR: ""
    KUBECTL_URL: https://dl.k8s.io/release/v1.37.0/bin/linux/amd64/kubectl
  rules:
  - changes: ["code/**/*"]
  before_script:
  - apk add --no-cache bash curl
  - curl -sLo /usr/local/bin/kind https://kind.sigs.k8s.io/dl/v0.33.0/kind-linux-amd64
  - curl -sLo /usr/local/bin/kubectl "$KUBECTL_URL"
  - chmod +x /usr/local/bin/kind /usr/local/bin/kubectl
  script:
  - kind create cluster --name np-ci --config code/np-tests/ci/kind-ci.yaml
  - sed -i 's#https://0.0.0.0:6443#https://docker:6443#' ~/.kube/config
  - kubectl apply -f code/demo/
  - kubectl wait --for=condition=Ready pod --all -A --timeout=300s
  - kubectl apply -f code/np-tests/policies/
  - sleep 5
  - CC=$PWD/code/demo/conncheck.sh code/np-tests/np-matrix.sh code/np-tests/matrix.tsv
EOF

Den Job übernimmst du in deine .gitlab-ci.yml. Der Runner muss privileged laufen (für docker:dind) – das gehört auf einen eigenen Runner, nicht auf den geteilten. Der GitLab-Job ist nicht live getestet; der GitHub-Workflow ist mit actionlint geprüft.

Tipp: Willst du Cilium-Policies in CI testen, installierst du Cilium wie an Tag 4 per Helm in den kind-Cluster. Plane dafür 3–5 Minuten zusätzliche Laufzeit ein.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/guard-lab/code/np-tests
PA=${PA:-/tmp/policy-assistant_darwin_amd64/policy-assistant}
[ "$(ls policies/*.yaml | wc -l)" -ge 4 ] \
  && echo "✔ Policies einzeln abgelegt" || echo "✘ policies/ unvollständig"
grep -q deny matrix.tsv && echo "✔ Matrix mit Negativ-Fällen" \
  || echo "✘ keine deny-Zeilen in der Matrix"
./np-matrix.sh matrix.tsv >/dev/null && echo "✔ Matrix grün" || echo "✘ Matrix rot"
./np-matrix.sh >/dev/null 2>&1; [ $? -eq 2 ] \
  && echo "✔ Aufruffehler = Exit 2" || echo "✘ Exit-Code bei Aufruffehler"
$PA analyze -v warn --mode probe --policy-path policies/ --probe-path probe.json \
  | grep -q 'shop/frontend  | N              | .' \
  && echo "✔ policy-assistant: frontend -> api erlaubt" || echo "✘ policy-assistant"

Challenge

Ergänze die Matrix um einen Egress-Fall: Die Datenbank darf nicht ins Internet (shop/db https://example.com deny). Lass die Matrix rot werden und mach sie mit einer neuen Policy-Datei wieder grün, ohne andere Zeilen zu brechen.

Hinweis: Eine Egress-Policy für db ohne erlaubte Ziele reicht – db baut selbst keine Verbindungen auf.

Lösung

cd ~/guard-lab/code/np-tests
echo "shop/db               https://example.com                  deny" >> matrix.tsv
./np-matrix.sh matrix.tsv | tail -1
cat > policies/50-db-no-egress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-no-egress
  namespace: shop
spec:
  podSelector:
    matchLabels: {app: db}
  policyTypes: [Egress]
EOF
kubectl apply -f policies/50-db-no-egress.yaml
./np-matrix.sh matrix.tsv | tail -1

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

10 Tests: 9 ✔, 1 ✘
networkpolicy.networking.k8s.io/db-no-egress created
10 Tests: 10 ✔, 0 ✘

Die Antworten der db an die api laufen weiter: NetworkPolicies sind zustandsbehaftet, Rückpakete einer erlaubten Verbindung brauchen keine Egress-Regel.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Die Matrix ist ein Vertrag mit den Teams: Änderungen daran gehen durch Review wie Code. Pro Mandant eine Datei, gemeinsame Plattform-Fälle in einer eigenen.
  • Laufzeit-Tests gehören nach jedem CNI-Upgrade und jedem Plattform-Rollout in die Pipeline (Smoke-Test-Namespace mit client-Pod im echten Cluster).
  • Statische Analyse vor dem Merge, Laufzeit-Test nach dem Deploy – beides, nicht eins.
  • Hubble-Flows ins SIEM exportieren und auf policy-verdict:none … DENIED alarmieren: Das sind die Verbindungen, für die jemand eine Policy vergessen hat.
  • Aufräumen: kind delete cluster --name cilium-lab; ab Tag 7 geht es mit kyverno-lab weiter.