Tag 1: NetworkPolicy-Grundlagen
Ziel: Den Namespace
shopper Default Deny abriegeln und dann gezielt öffnen, mitpodSelector,namespaceSelector, Ports und Egress. · Dauer: ca. 75 min · Voraussetzung: Tag 0
Briefing
- Ohne Policy ist alles erlaubt. Sobald eine Policy einen Pod für eine Richtung (Ingress oder Egress) auswählt, ist für diesen Pod in dieser Richtung alles verboten, was nicht ausdrücklich erlaubt ist.
- Policies sind additiv: Es gibt kein „deny”-Feld. Mehrere Policies ergeben die Vereinigung ihrer Erlaubnisse.
spec.podSelectorwählt die Pods, die geschützt werden.from/tobeschreiben die Gegenseite.- Ein
podSelectorinfrommeint nur Pods im eigenen Namespace.
Policy wählt api aus (podSelector app=api)
frontend ──────────── from: podSelector app=frontend ───► api :8080 ✔
client ─────────────────────────────────────────────X api ✘
Drill 1: Ausgangslage messen
cd ~/guard-lab/tag01
alias cc=~/guard-lab/code/demo/conncheck.sh
kubectl get networkpolicy -A
~/guard-lab/code/matrix.sh | head -3Erwartet:
No resources found
✔ erlaubt default/client -> http://frontend.shop (HTTP 200)
✔ erlaubt default/client -> http://api.shop (HTTP 200)
✔ erlaubt default/client -> tcp://db.shop:5432
Jeder darf alles, auch der Client aus default direkt an
die Datenbank. Das ist der Normalzustand eines frischen Clusters.
Tipp: Kein
matrix.sh? Dann hast du die Challenge aus Tag 0 übersprungen. Die Lösung steht dort.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Default Deny für Ingress
cat > default-deny.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-ingress
namespace: shop
spec:
podSelector: {}
policyTypes:
- Ingress
EOF
kubectl apply -f default-deny.yaml
cc default/client http://frontend.shop
cc shop/frontend http://api.shop
cc shop/api tcp://db.shop:5432
cc shop/frontend http://api.tenant-aErwartet:
networkpolicy.networking.k8s.io/default-deny-ingress created
✘ blockiert default/client -> http://frontend.shop (Timeout)
✘ blockiert shop/frontend -> http://api.shop (Timeout)
✘ blockiert shop/api -> tcp://db.shop:5432 (keine Verbindung)
✔ erlaubt shop/frontend -> http://api.tenant-a (HTTP 200)
podSelector: {} wählt alle Pods im Namespace.
policyTypes: [Ingress] ohne ingress-Regeln
heißt: nichts darf herein. Auch Pods im selben Namespace nicht. Nach
außen (tenant-a) geht es weiter, denn Egress ist nicht
betroffen.
kubectl -n shop get pods
kubectl -n monitoring logs deploy/scraper --tail=3Erwartet:
NAME READY STATUS RESTARTS AGE
api-5ccd4587ff-gwhbn 1/1 Running 0 4m4s
db-5d6755ff6b-z5vv9 1/1 Running 0 4m4s
frontend-5f9bb6b549-8hpqx 1/1 Running 0 4m4s
FAIL shop
ok tenant-a
ok tenant-b
Die Pods bleiben Ready: Die Readiness-Probes des kubelet
kommen in kindnet weiter durch (mehr dazu in Tag 2). Der Scraper dagegen
ist für shop ausgesperrt.
Fortschritt speichern? Kostenlos registrieren
Drill 3: podSelector – frontend darf zur api
cat > 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:
- protocol: TCP
port: 8080
EOF
kubectl apply -f api-from-frontend.yaml
cc shop/frontend http://api.shop
cc shop/db http://api.shop
cc default/client http://api.shopErwartet:
networkpolicy.networking.k8s.io/api-from-frontend created
✔ erlaubt shop/frontend -> http://api.shop (HTTP 200)
✘ blockiert shop/db -> http://api.shop (Timeout)
✘ blockiert default/client -> http://api.shop (Timeout)
Warum Port 8080 und nicht 80? Der Service übersetzt 80 auf den
targetPort 8080. Die Policy sieht das Paket erst danach, am
Pod. Der Port in einer Policy ist immer der Container-Port.
kubectl -n shop describe networkpolicy api-from-frontend | sed -n '/Spec/,$p'Erwartet:
Spec:
PodSelector: app=api
Allowing ingress traffic:
To Port: 8080/TCP
From:
PodSelector: app=frontend
Not affecting egress traffic
Policy Types: Ingress
describe ist dein schnellster Lesetest: Es übersetzt das
YAML in Sätze.
Fortschritt speichern? Kostenlos registrieren
Drill 4: namespaceSelector – frontend für alle
Das Frontend soll aus jedem Namespace erreichbar sein (später nur vom Ingress-Controller, Tag 3).
cat > frontend-from-all.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: frontend-from-all
namespace: shop
spec:
podSelector:
matchLabels:
app: frontend
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector: {}
ports:
- port: http
EOF
kubectl apply -f frontend-from-all.yaml
cc default/client http://frontend.shop
kubectl exec client -- curl -s http://frontend.shop/api/orders
cc default/client http://api.shopErwartet:
networkpolicy.networking.k8s.io/frontend-from-all created
✔ erlaubt default/client -> http://frontend.shop (HTTP 200)
{"svc":"api","ns":"shop","path":"/api/orders"}
✘ blockiert default/client -> http://api.shop (Timeout)
Zwei Lektionen: namespaceSelector: {} heißt „alle Pods
in allen Namespaces”. Und port: http ist ein Named Port: Er
zeigt auf den Port, den der Container http nennt. Der
Client erreicht die api jetzt nur über das Frontend, genau so soll es
sein.
Fortschritt speichern? Kostenlos registrieren
Drill 5: UND oder ODER – die Einrückungsfalle
Der Scraper aus monitoring soll /metrics
(Port 9113) der api lesen. Erst ein Störenfried im
Monitoring-Namespace:
kubectl -n monitoring run intruder --image=curlimages/curl:8.22.0 \
--labels=app=intruder -- sleep 3600
cat > api-metrics-or.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: api-metrics
namespace: shop
spec:
podSelector:
matchLabels:
app: api
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
purpose: monitoring
- podSelector:
matchLabels:
app: scraper
ports:
- port: metrics
EOF
kubectl apply -f api-metrics-or.yaml
cc monitoring/scraper http://api.shop:9113/metrics
cc monitoring/intruder http://api.shop:9113/metricsErwartet:
pod/intruder created
networkpolicy.networking.k8s.io/api-metrics created
✔ erlaubt monitoring/scraper -> http://api.shop:9113/metrics (HTTP 200)
✔ erlaubt monitoring/intruder -> http://api.shop:9113/metrics (HTTP 200)
Zwei Spiegelstriche unter from sind zwei Quellen, also
ODER: „jeder Pod in einem Monitoring-Namespace” oder „Pods mit
app=scraper im Namespace shop“. Der
Eindringling kommt durch. Jetzt ein einziger Strich, beide Selektoren in
einem Element, also UND:
sed -e 's/ - podSelector:/ podSelector:/' api-metrics-or.yaml \
> api-metrics-and.yaml
diff api-metrics-or.yaml api-metrics-and.yaml
kubectl apply -f api-metrics-and.yaml
cc monitoring/scraper http://api.shop:9113/metrics
cc monitoring/intruder http://api.shop:9113/metricsErwartet:
17c17
< - podSelector:
---
> podSelector:
networkpolicy.networking.k8s.io/api-metrics configured
✔ erlaubt monitoring/scraper -> http://api.shop:9113/metrics (HTTP 200)
✘ blockiert monitoring/intruder -> http://api.shop:9113/metrics (Timeout)
Zwei Leerzeichen und ein Bindestrich entscheiden über die Sicherheit.
Lies jede Policy mit describe gegen: Bei UND stehen
NamespaceSelector und PodSelector direkt
untereinander im selben From-Block.
Achtung:
purpose=monitoringist ein selbst gesetztes Label. Wer Namespaces labeln darf, kommt rein. Sicherer istkubernetes.io/metadata.name(Tag 3).
Fortschritt speichern? Kostenlos registrieren
Drill 6: Additiv – Policies addieren sich
Auf der api liegen jetzt zwei Policies. Welche gilt?
kubectl -n shop get networkpolicy
cc shop/frontend http://api.shop
cc shop/frontend http://api.shop:9113/metrics
cc monitoring/scraper http://api.shopErwartet:
NAME POD-SELECTOR AGE
api-from-frontend app=api 52s
api-metrics app=api 23s
default-deny-ingress <none> 78s
frontend-from-all app=frontend 34s
✔ erlaubt shop/frontend -> http://api.shop (HTTP 200)
✘ blockiert shop/frontend -> http://api.shop:9113/metrics (Timeout)
✘ blockiert monitoring/scraper -> http://api.shop (Timeout)
Beide gelten. Die erlaubte Menge ist die Vereinigung: frontend auf 8080 ODER scraper auf 9113. Port und Quelle bleiben dabei pro Regel gekoppelt. Das frontend bekommt nicht plötzlich 9113, nur weil eine andere Regel 9113 öffnet. Reihenfolge und Namen spielen keine Rolle, und es gibt keine Policy, die eine andere überstimmt.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Egress – die Datenbank spricht mit niemandem
cat > 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 db-no-egress.yaml
cc shop/db http://api.tenant-a
cc shop/db http://frontend.shop
cc shop/frontend http://api.tenant-aErwartet:
networkpolicy.networking.k8s.io/db-no-egress created
✘ blockiert shop/db -> http://api.tenant-a (Timeout)
✘ blockiert shop/db -> http://frontend.shop (Timeout)
✔ erlaubt shop/frontend -> http://api.tenant-a (HTTP 200)
Eine kompromittierte Datenbank kann jetzt keine Daten nach außen
schicken und keine Nachbarn scannen. Sie kann nicht einmal mehr DNS
fragen. Deshalb meldet conncheck.sh „Timeout” statt
„DNS-Fehler”: Die DNS-Anfrage verhungert. Warum das bei Pods, die reden
sollen, zum Problem wird, siehst du in Tag 2.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cc=~/guard-lab/code/demo/conncheck.sh
while read -r src url want; do
"$cc" "$src" "$url" "$want" >/dev/null \
&& echo "✔ $src -> $url ($want)" || echo "✘ $src -> $url (erwartet: $want)"
done <<'EOF'
shop/frontend http://api.shop allow
default/client http://frontend.shop allow
default/client http://api.shop deny
monitoring/scraper http://api.shop:9113/metrics allow
monitoring/intruder http://api.shop:9113/metrics deny
shop/db http://frontend.shop deny
EOF
kubectl -n shop get netpol default-deny-ingress >/dev/null 2>&1 \
&& echo "✔ default-deny-ingress" || echo "✘ default-deny-ingress fehlt"Challenge
Die Datenbank ist im Moment für niemanden erreichbar, auch nicht für
die api. Schreib eine Policy db-from-api: Nur Pods mit
tier=api dürfen auf den Named Port postgres.
Prüfe auch, ob tenant-a/api (hat ebenfalls
tier=api) hineinkommt.
Hinweis: Ein podSelector in
from gilt nur im Namespace der Policy.
Lösung
cat > db-from-api.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: db-from-api
namespace: shop
spec:
podSelector:
matchLabels:
tier: data
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
tier: api
ports:
- port: postgres
EOF
kubectl apply -f db-from-api.yaml
cc shop/api tcp://db.shop:5432 allow
cc shop/frontend tcp://db.shop:5432 deny
cc tenant-a/api tcp://db.shop:5432 denyErwartet:
networkpolicy.networking.k8s.io/db-from-api created
✔ erlaubt shop/api -> tcp://db.shop:5432
✘ blockiert shop/frontend -> tcp://db.shop:5432 (keine Verbindung)
✘ blockiert tenant-a/api -> tcp://db.shop:5432 (keine Verbindung)
tenant-a/api trägt zwar tier=api, lebt aber
in einem anderen Namespace. Ohne namespaceSelector zählt
nur shop.
Aufräumen für Tag 2:
kubectl -n shop delete networkpolicy --all
kubectl -n monitoring delete pod intruderFortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Starte jeden Namespace mit Default Deny, und zwar automatisch: Kyverno erzeugt die Policy beim Anlegen des Namespace (Tag 9).
- Verwende als Quelle Labels, die der App-Team-Owner nicht beliebig setzen kann, oder sichere sie per Admission ab (Tag 8, Tag 13).
- Prüfe jede Policy per
describeund per Verbindungstest. Ein Einrückungsfehler macht aus UND ein ODER, ohne dasskubectl applymeckert. - Standard-NetworkPolicies kennen nur L3/L4 und erlauben nur. Für L7, FQDNs und explizite Denies brauchst du CNI-Erweiterungen (Tag 4) oder AdminNetworkPolicies (Tag 5).
- Plane Rollouts im Audit-Stil: erst mit Tests im Staging, dann mit Monitoring der verworfenen Pakete in Produktion (Hubble, Tag 4).