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.txtErwartet (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 -1Erwartet (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 -9Erwartet:
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 CombinedErwartet:
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; doneDer 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 %1Sicherheit: Die UI zeigt alle Flows aller Namespaces. In Produktion nie ohne Authentifizierung (Ingress mit OIDC) und nie per
LoadBalancerverö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 | pbcopyhttps://editor.networkpolicy.ioöffnen, „Upload” bzw. YAML-Feld wählen, einfügen.- Prüfen: Ingress zeigt
app=frontendauf 8080 undpurpose=monitoringauf 9113. - Egress ist offen (grün), weil die Policy nur
Ingressregelt. - Ä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.jsonErwartet (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"
EOFKopiert 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
EOFDen 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 -1Erwartet (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 … DENIEDalarmieren: 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 mitkyverno-labweiter.