Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: NetworkPolicies

Ziel: Du sperrst Pod-Verkehr standardmäßig und öffnest gezielt nur die nötigen Wege – eingehend und ausgehend. · Dauer: ca. 60 min · Voraussetzung: Tag 7

Briefing

CKA: „Define and enforce Network Policies” (Teil der 20 %).

  • Ohne Policy darf jeder Pod mit jedem sprechen.
  • Sobald eine Policy einen Pod auswählt, ist für ihn in der genannten Richtung (Ingress, Egress) nur noch erlaubt, was eine Policy erlaubt. Policies addieren sich.
  • Durchgesetzt werden sie vom CNI-Plugin – hier Calico. Ohne passendes CNI sind NetworkPolicies wirkungslos.
  other/outsider (role=frontend) --+
  tag09/frontend (role=frontend) --+--> tag09/api :8080
  tag09/intruder ------------------+

Drill 1: Das Testfeld

k create ns tag09
k create ns other
k config set-context --current --namespace=tag09
k create deployment api --image=registry.k8s.io/e2e-test-images/agnhost:2.53 \
  -- /agnhost netexec --http-port=8080
k expose deployment api --port=80 --target-port=8080
k run frontend --image=busybox:1.37 -l role=frontend -- sleep 3600
k run intruder --image=busybox:1.37 -- sleep 3600
k run outsider -n other --image=busybox:1.37 -l role=frontend -- sleep 3600

Ein kurzer Test pro Pod – ohne Hilfsskript, einfach drei Befehle:

k exec frontend -- wget -qO- -T2 http://api.tag09/hostname; echo
k exec intruder -- wget -qO- -T2 http://api.tag09/hostname; echo
k exec -n other outsider -- wget -qO- -T2 http://api.tag09/hostname; echo

Erwartet: dreimal ein Podname wie api-86b79696fd-qwcrs – alles offen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Default Deny

cat <<'EOF' | k apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
spec:
  podSelector: {}
  policyTypes:
  - Ingress
EOF

Die drei Testbefehle aus Drill 1 wiederholen.

Erwartet: dreimal

wget: download timed out
command terminated with exit code 1

podSelector: {} wählt alle Pods im Namespace, und es gibt keine ingress-Regel – also ist nichts erlaubt.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Nur das Frontend darf zur API

cat <<'EOF' | k apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-frontend
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - port: 8080
EOF

Testbefehle wiederholen.

Erwartet:

Pod Ergebnis
frontend Podname
intruder timed out
outsider (other) timed out

Zwei Details: Der Port in der Policy ist der Container-Port 8080, nicht der Service-Port 80. Und podSelector in from gilt nur im eigenen Namespace – deshalb bleibt outsider draußen, obwohl er dasselbe Label trägt.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Die UND-ODER-Falle

Jetzt soll outsider aus other hinein. Variante A – zwei Einträge in from:

cat <<'EOF' | k apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-other
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: other
    - podSelector:
        matchLabels:
          role: frontend
EOF
k run intruder -n other --image=busybox:1.37 -- sleep 3600
k wait -n other --for=condition=Ready pod/intruder
k exec -n other outsider -- wget -qO- -T2 http://api.tag09/hostname; echo
k exec -n other intruder -- wget -qO- -T2 http://api.tag09/hostname; echo

Erwartet: beide bekommen einen Podnamen. Zwei Listeneinträge bedeuten ODER: jeder Pod aus other oder jeder Frontend-Pod aus tag09.

Variante B – ein Eintrag mit beiden Selektoren (kein - vor podSelector):

cat <<'EOF' | k apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-other
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: other
      podSelector:
        matchLabels:
          role: frontend
EOF
k exec -n other outsider -- wget -qO- -T2 http://api.tag09/hostname; echo
k exec -n other intruder -- wget -qO- -T2 http://api.tag09/hostname; echo

Erwartet: outsider bekommt einen Podnamen, intruder läuft in den Timeout. Ein Eintrag mit beiden Selektoren bedeutet UND. Ein einziger Bindestrich entscheidet – die häufigste Falle in der Prüfung.

Das Label kubernetes.io/metadata.name setzt Kubernetes an jedem Namespace automatisch.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Egress sperren – und DNS vergessen

Das Frontend soll nur noch mit der API sprechen:

cat <<'EOF' | k apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-egress
spec:
  podSelector:
    matchLabels:
      role: frontend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: api
    ports:
    - port: 8080
EOF
k exec frontend -- wget -qO- -T3 http://api.tag09/hostname; echo

Erwartet:

wget: bad address 'api.tag09'
command terminated with exit code 1

Obwohl der Weg zur API erlaubt ist: Der Pod darf den DNS-Server nicht mehr fragen und findet api.tag09 nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 6: DNS erlauben

cat <<'EOF' | k apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-egress
spec:
  podSelector:
    matchLabels:
      role: frontend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: api
    ports:
    - port: 8080
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - port: 53
      protocol: UDP
    - port: 53
      protocol: TCP
EOF
k exec frontend -- wget -qO- -T3 http://api.tag09/hostname; echo
k exec frontend -- wget -qO- -T3 http://example.com

Erwartet:

api-86b79696fd-qwcrs
wget: download timed out
command terminated with exit code 1

Die API geht, das Internet nicht – genau so gewollt.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Policies lesen

k get networkpolicy
k describe networkpolicy frontend-egress | sed -n '/Spec/,$p'

Erwartet (gekürzt):

NAME                POD-SELECTOR    AGE
api-from-frontend   app=api         68s
api-from-other      app=api         51s
default-deny        <none>          75s
frontend-egress     role=frontend   34s
Spec:
  PodSelector:     role=frontend
  Not affecting ingress traffic
  Allowing egress traffic:
    To Port: 8080/TCP
    To:
      PodSelector: app=api
    ----------
    To Port: 53/UDP
    To Port: 53/TCP
    To:
      NamespaceSelector: kubernetes.io/metadata.name=kube-system
      PodSelector: k8s-app=kube-dns
  Policy Types: Egress

describe zeigt UND und ODER eindeutig: Einträge unter einem To: gelten zusammen, ---- trennt Alternativen. Lies damit fremde Policies, bevor du sie änderst.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Welche Policies wählen den Pod frontend aus? Zeitziel: 30 s
  2. Lege eine Policy deny-all an, die im Namespace other allen Ein- und Ausgangsverkehr sperrt. Zeitziel: 60 s

Lösung

k get netpol -o custom-columns=NAME:.metadata.name,SELECTOR:.spec.podSelector
cat <<'EOF' | k apply -n other -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
EOF

Erwartet (Ausschnitt):

NAME                SELECTOR
api-from-frontend   map[matchLabels:map[app:api]]
...
default-deny        map[]
frontend-egress     map[matchLabels:map[role:frontend]]
networkpolicy.networking.k8s.io/deny-all created

frontend wird von default-deny (leerer Selector = alle) und frontend-egress erfasst.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k exec intruder -- wget -qO- -T2 http://api.tag09/hostname

Erwartet: wget: download timed out

k exec frontend -- wget -qO- -T2 http://api.tag09/hostname; echo

Erwartet: ein Podname, der mit api- beginnt.

k exec -n other outsider -- wget -qO- -T2 http://api.tag09/hostname

Erwartet: wget: bad address 'api.tag09' – deny-all sperrt jetzt auch den Ausgang in other, schon die DNS-Anfrage scheitert.

Challenge

Im Namespace tag09 soll für alle Pods jeder ausgehende Verkehr gesperrt sein – außer DNS. Bestehende Ausnahmen (Frontend zur API) sollen weiter funktionieren.

Hinweis: Eine Egress-Regel nur mit ports und ohne to gilt für jedes Ziel.

Lösung

cat <<'EOF' | k apply -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-egress-allow-dns
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - ports:
    - port: 53
      protocol: UDP
    - port: 53
      protocol: TCP
EOF
k exec intruder -- nslookup api.tag09.svc.cluster.local
k exec intruder -- wget -qO- -T3 http://example.com
k exec frontend -- wget -qO- -T3 http://api.tag09/hostname; echo

Erwartet (gekürzt):

Name:   api.tag09.svc.cluster.local
Address: 10.106.144.111
wget: download timed out
command terminated with exit code 1
api-86b79696fd-qwcrs

Policies addieren sich: frontend-egress erlaubt dem Frontend zusätzlich den Weg zur API.

Aufräumen:

k config set-context --current --namespace=default
k delete ns tag09 other

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • Doku-Seite „Network Policies” öffnen und das Beispiel kopieren – dort stehen UND und ODER nebeneinander.
  • Nach jeder Policy mit k exec … -- wget -T2 oder nc -zv -w2 testen: einmal erlaubt, einmal verboten.
  • Egress-Aufgaben: An DNS (UDP und TCP 53) denken.

Enterprise-Notiz

  • Default Deny pro Namespace gehört in jedes Mandanten-Template.
  • Calico und Cilium bieten zusätzlich clusterweite Policies (GlobalNetworkPolicy, CiliumClusterwideNetworkPolicy) und L7-Regeln; Kubernetes selbst führt dafür gerade ClusterNetworkPolicy ein.
  • Netzwerkflüsse sichtbar machen (Calico Whisker, Cilium Hubble), bevor man sperrt.
  • Mehr Tiefe: „Kyverno & NetworkPolicies zum Anfassen”.