Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 1: NetworkPolicy-Grundlagen

Ziel: Den Namespace shop per Default Deny abriegeln und dann gezielt öffnen, mit podSelector, 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.podSelector wählt die Pods, die geschützt werden. from/to beschreiben die Gegenseite.
  • Ein podSelector in from meint 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 -3

Erwartet:

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

Erwartet:

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

Erwartet:

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

Erwartet:

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

Erwartet:

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

Erwartet:

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

Erwartet:

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=monitoring ist ein selbst gesetztes Label. Wer Namespaces labeln darf, kommt rein. Sicherer ist kubernetes.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.shop

Erwartet:

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

Erwartet:

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 deny

Erwartet:

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 intruder

Fortschritt 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 describe und per Verbindungstest. Ein Einrückungsfehler macht aus UND ein ODER, ohne dass kubectl apply meckert.
  • 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).