Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 17: NetworkPolicies

Ziel: Du sperrst den Verkehr deiner Anwendung standardmäßig, öffnest nur die nötigen Wege und liest vorhandene Policies so schnell, dass du die passenden Pod-Labels setzt. · Dauer: ca. 75 min · Voraussetzung: Tag 16

Briefing

CKAD: Services and Networking (20 %) – „Demonstrate basic understanding of NetworkPolicies”.

  • Ohne Policy darf jeder Pod mit jedem sprechen – auch über Namespaces hinweg.
  • Wählt eine Policy einen Pod aus, ist für ihn in dieser Richtung (Ingress, Egress) nur noch erlaubt, was irgendeine Policy erlaubt. Policies addieren sich, es gibt kein „deny”.
  • Durchgesetzt werden sie vom CNI-Plugin, hier Calico v3.33.1.
 tag17-other/reporter ──┐
 tag17/client ──────────┴─> tag17/notes :8080 ──> tag17/db :5432
                                  (alle: DNS ──> kube-system/kube-dns :53)

Drill 1: Das Testfeld

mkdir -p ~/ckad/tag17 && cd ~/ckad/tag17
k create ns tag17
k create ns tag17-other
k config set-context --current --namespace=tag17
cat > db.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: db
spec:
  selector:
    matchLabels:
      app: db
  template:
    metadata:
      labels:
        app: db
    spec:
      containers:
      - name: postgres
        image: docker.io/library/postgres:18
        env:
        - name: POSTGRES_USER
          value: notes
        - name: POSTGRES_PASSWORD
          value: lab-db-pw-123
        ports:
        - containerPort: 5432
        readinessProbe:
          exec:
            command: ["pg_isready", "-U", "notes"]
EOF
k apply -f db.yaml
k expose deployment db --port=5432
k rollout status deployment db

Die Readiness-Probe sorgt dafür, dass rollout status erst zurückkehrt, wenn Postgres Verbindungen annimmt – sonst bricht notes-api beim Start mit „database unreachable” ab.

cat > notes.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: notes
spec:
  replicas: 2
  selector:
    matchLabels:
      app: notes
  template:
    metadata:
      labels:
        app: notes
    spec:
      containers:
      - name: notes-api
        image: 172.16.0.126:30500/notes-api:1.0
        env:
        - name: NOTES_API_KEY
          value: lab-key-123
        - name: NOTES_DB_URL
          value: postgres://notes:lab-db-pw-123@db:5432/notes?sslmode=disable
        ports:
        - containerPort: 8080
          name: http
EOF
k apply -f notes.yaml
k expose deployment notes --port=80 --target-port=8080
k rollout status deployment notes
k run client --image=busybox:1.37 -- sleep 3600
k run outsider -n tag17-other --image=busybox:1.37 -- sleep 3600
k get pods

Erwartet (gekürzt):

deployment "notes" successfully rolled out
NAME                    READY   STATUS    RESTARTS   AGE
client                  1/1     Running   0          8s
db-7bb897448b-2zhfz     1/1     Running   0          18s
notes-fd744685f-74qrc   1/1     Running   0          3s
notes-fd744685f-qscvr   1/1     Running   0          3s

API-Key und Passwort sind reine Lab-Werte. Jetzt die Wege testen – immer mit Timeout (-T2 bei wget, -w2 bei nc), sonst wartest du bei gesperrtem Verkehr ewig:

k exec client -- wget -qO- -T2 http://notes/healthz
k exec client -- nc -zv -w2 db 5432
k exec -n tag17-other outsider -- wget -qO- -T2 http://notes.tag17/healthz
k exec -n tag17-other outsider -- nc -zv -w2 db.tag17 5432

Erwartet:

ok
db (10.97.47.147:5432) open
ok
db.tag17 (10.97.47.147:5432) open

Alles offen – auch der fremde Namespace kommt direkt an die Datenbank. /healthz liefert nur ok, wenn notes-api die Datenbank erreicht.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Default Deny für Ingress

cat > deny-all.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
spec:
  podSelector: {}
  policyTypes:
  - Ingress
EOF
k apply -f deny-all.yaml
k get netpol
k exec client -- wget -qO- -T2 http://notes/healthz
k exec client -- nc -zv -w2 db 5432
k exec deploy/notes -- nc -zv -w2 db 5432

Erwartet:

networkpolicy.networking.k8s.io/default-deny created
NAME           POD-SELECTOR   AGE
default-deny   <none>         0s
wget: download timed out
command terminated with exit code 1
nc: db (10.97.47.147:5432): Connection timed out
command terminated with exit code 1
nc: db (10.97.47.147:5432): Operation timed out
command terminated with exit code 1

podSelector: {} wählt alle Pods im Namespace, eine ingress-Liste fehlt – also ist nichts erlaubt. Gesperrt heißt bei Calico: Pakete werden verworfen, deshalb ein Timeout und kein „connection refused”.

Achtung: Bestehende Verbindungen bleiben offen. Im Labor meldete /healthz von notes-api noch rund eine Minute ok – bis der Connection-Pool die alte Datenbankverbindung schloss. Danach: 503 Service Unavailable.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Gezielt erlauben – podSelector und Ports

Nur Pods mit dem Label access=notes sollen notes-api erreichen. Erster Versuch mit dem Service-Port:

cat > notes-ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: notes-ingress
spec:
  podSelector:
    matchLabels:
      app: notes
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          access: notes
    ports:
    - port: 80
EOF
k apply -f notes-ingress.yaml
k label pod client access=notes
k exec client -- wget -qO- -T2 http://notes/version

Erwartet:

networkpolicy.networking.k8s.io/notes-ingress created
pod/client labeled
wget: download timed out
command terminated with exit code 1

Die Policy wirkt am Pod, nach der Service-Übersetzung. Gemeint ist also der Container-Port 8080 (oder sein Name http), nicht Port 80 des Service:

sed -i 's/port: 80$/port: 8080/' notes-ingress.yaml
k apply -f notes-ingress.yaml
k exec client -- wget -qO- -T2 http://notes/version
k label pod client access-
k exec client -- wget -qO- -T2 http://notes/version
k label pod client access=notes

Erwartet:

networkpolicy.networking.k8s.io/notes-ingress configured
1.0
pod/client unlabeled
wget: download timed out
command terminated with exit code 1
pod/client labeled

Das Label entscheidet – nicht der Podname. Jetzt die Datenbank: nur notes darf hin.

cat > db-ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-ingress
spec:
  podSelector:
    matchLabels:
      app: db
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: notes
    ports:
    - port: 5432
EOF
k apply -f db-ingress.yaml
k exec deploy/notes -- nc -zv -w2 db 5432
k exec client -- nc -zv -w2 db 5432
k exec client -- wget -qO- -T5 http://notes/healthz

Erwartet:

networkpolicy.networking.k8s.io/db-ingress created
db (10.97.47.147:5432) open
nc: db (10.97.47.147:5432): Connection timed out
command terminated with exit code 1
ok

Für /healthz hier -T5: notes-api wartet bis zu 2 s auf die Datenbank, bei -T2 kann wget vorher aufgeben.

Fortschritt speichern? Kostenlos registrieren

Drill 4: namespaceSelector – UND oder ODER

Jeder Namespace trägt automatisch das Label kubernetes.io/metadata.name=<name>:

k get ns tag17-other --show-labels
k run partner -n tag17-other --image=busybox:1.37 -l access=notes -- sleep 3600
k exec -n tag17-other partner -- wget -qO- -T2 http://notes.tag17/version

Erwartet:

NAME          STATUS   AGE     LABELS
tag17-other   Active   4m35s   kubernetes.io/metadata.name=tag17-other
pod/partner created
wget: download timed out
command terminated with exit code 1

partner hat zwar access=notes, aber ein podSelector allein gilt nur im eigenen Namespace der Policy. Variante A – zwei Einträge in from:

cat > notes-or.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: notes-from-other
spec:
  podSelector:
    matchLabels:
      app: notes
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: tag17-other
    - podSelector:
        matchLabels:
          access: notes
    ports:
    - port: 8080
EOF
k apply -f notes-or.yaml
k exec -n tag17-other partner -- wget -qO- -T2 http://notes.tag17/version
k exec -n tag17-other outsider -- wget -qO- -T2 http://notes.tag17/version

Erwartet:

networkpolicy.networking.k8s.io/notes-from-other created
1.0
1.0

Auch outsider ohne Label kommt durch: zwei Listeneinträge sind ODER – „irgendein Pod aus tag17-other” oder „Pod mit access=notes aus tag17”. Variante B – ein einziger Eintrag, also ein - weniger:

sed 's/^    - podSelector:/      podSelector:/' notes-or.yaml > notes-and.yaml
diff notes-or.yaml notes-and.yaml
k apply -f notes-and.yaml
k exec -n tag17-other partner -- wget -qO- -T2 http://notes.tag17/version
k exec -n tag17-other outsider -- wget -qO- -T2 http://notes.tag17/version
k describe netpol notes-from-other | sed -n '/Allowing ingress/,/Not affecting/p'

Erwartet:

16c16
<     - podSelector:
---
>       podSelector:
networkpolicy.networking.k8s.io/notes-from-other configured
1.0
wget: download timed out
command terminated with exit code 1
  Allowing ingress traffic:
    To Port: 8080/TCP
    From:
      NamespaceSelector: kubernetes.io/metadata.name=tag17-other
      PodSelector: access=notes
  Not affecting egress traffic

Ein Eintrag mit beiden Selektoren ist UND: Pods mit access=notes in tag17-other. k describe verrät es: Bei Variante A stehen zwei From:-Blöcke da, bei B einer.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Default Deny für Egress – mit DNS-Ausnahme

cat > deny-egress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-egress
spec:
  podSelector: {}
  policyTypes:
  - Egress
EOF
k apply -f deny-egress.yaml
k exec client -- wget -qO- -T2 http://notes/version
k exec client -- nslookup -timeout=2 notes

Erwartet:

networkpolicy.networking.k8s.io/default-deny-egress created
wget: bad address 'notes'
command terminated with exit code 1
;; connection timed out; no servers could be reached
command terminated with exit code 1

bad address statt timed out: Schon die DNS-Anfrage an CoreDNS ist Egress und damit gesperrt. Die Ausnahme für alle Pods im Namespace, UDP und TCP 53:

cat > allow-dns.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - 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 apply -f allow-dns.yaml
k exec client -- nslookup notes.tag17.svc.cluster.local
k exec client -- wget -qO- -T2 http://notes/version

Erwartet:

networkpolicy.networking.k8s.io/allow-dns created
Server:     10.96.0.10
Address:    10.96.0.10:53

Name:   notes.tag17.svc.cluster.local
Address: 10.102.130.4

wget: download timed out
command terminated with exit code 1

Der Name löst sich auf, die Verbindung zu notes bleibt gesperrt – sie braucht eine eigene Egress-Regel. Kurzform ohne to, die du oft in Aufgaben siehst (Drill 8): nur ports mit 53 erlaubt DNS zu jedem Ziel.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Egress für die Anwendung

Innerhalb eines Namespace mit Default Deny in beide Richtungen braucht jede Verbindung zwei Erlaubnisse: Egress beim Absender, Ingress beim Empfänger.

cat > egress-apps.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: client-egress
spec:
  podSelector:
    matchLabels:
      run: client
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: notes
    ports:
    - port: 8080
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: notes-egress
spec:
  podSelector:
    matchLabels:
      app: notes
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: db
    ports:
    - port: 5432
EOF
k apply -f egress-apps.yaml
k exec client -- wget -qO- -T2 http://notes/version
k exec client -- wget -qO- -T5 http://notes/healthz
k exec deploy/notes -- nc -zv -w2 db 5432
k exec client -- nc -zv -w2 db 5432

Erwartet:

networkpolicy.networking.k8s.io/client-egress created
networkpolicy.networking.k8s.io/notes-egress created
1.0
ok
db (10.97.47.147:5432) open
nc: db (10.97.47.147:5432): Connection timed out
command terminated with exit code 1

run: client ist das Label, das k run automatisch setzt. Egress-Regeln nennen ebenfalls den Container-Port (8080), nicht den Service-Port.

Fortschritt speichern? Kostenlos registrieren

Drill 7: ipBlock für Ziele außerhalb des Clusters

Für Adressen ohne Pod-Labels – Nodes, externe Datenbanken, Firmennetz – gibt es ipBlock, optional mit except:

k exec client -- nc -zv -w2 172.16.0.126 6443
cat > client-ipblock.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: client-to-nodes
spec:
  podSelector:
    matchLabels:
      run: client
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 172.16.0.0/24
        except:
        - 172.16.0.228/32
EOF
k apply -f client-ipblock.yaml
k exec client -- nc -zv -w2 172.16.0.126 6443
k exec client -- nc -zv -w2 172.16.0.83 10250
k exec client -- nc -zv -w2 172.16.0.228 10250

Erwartet:

nc: 172.16.0.126 (172.16.0.126:6443): Connection timed out
command terminated with exit code 1
networkpolicy.networking.k8s.io/client-to-nodes created
172.16.0.126 (172.16.0.126:6443) open
172.16.0.83 (172.16.0.83:10250) open
nc: 172.16.0.228 (172.16.0.228:10250): Connection timed out
command terminated with exit code 1

cp1 und worker2 sind erreicht, worker1 (except) nicht. Ein ipBlock darf nicht mit podSelector oder namespaceSelector im selben Eintrag stehen. Pod-IPs wechseln – für Pods immer Selektoren nehmen.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Prüfungsaufgabe – Policies lesen, Labels setzen

Typische Aufgabe: „Pod reporter in tag17-other soll notes in tag17 erreichen. Ändere keine NetworkPolicy.” Die Policies in tag17-other gibt es schon:

cat > other-policies.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: tag17-other
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
  egress:
  - ports:
    - port: 53
      protocol: UDP
    - port: 53
      protocol: TCP
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: to-notes
  namespace: tag17-other
spec:
  podSelector:
    matchLabels:
      team: notes-users
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: tag17
      podSelector:
        matchLabels:
          app: notes
    ports:
    - port: 8080
EOF
k apply -f other-policies.yaml
k run reporter -n tag17-other --image=busybox:1.37 -- sleep 3600
k exec -n tag17-other reporter -- wget -qO- -T2 http://notes.tag17/version

Erwartet: wget: download timed out. Jetzt lesen – zuerst den Absender-Namespace:

k get netpol -n tag17-other
k describe netpol -n tag17-other to-notes | sed -n '/^Spec/,$p'

Erwartet:

NAME           POD-SELECTOR       AGE
default-deny   <none>             5s
to-notes       team=notes-users   5s
Spec:
  PodSelector:     team=notes-users
  Not affecting ingress traffic
  Allowing egress traffic:
    To Port: 8080/TCP
    To:
      NamespaceSelector: kubernetes.io/metadata.name=tag17
      PodSelector: app=notes
  Policy Types: Egress
k label pod -n tag17-other reporter team=notes-users
k exec -n tag17-other reporter -- wget -qO- -T2 http://notes.tag17/version

Erwartet: wieder wget: download timed out – Egress ist frei, aber der Empfänger lässt nicht herein. Also auch dort lesen:

k get netpol -n tag17 -o wide | grep app=notes
k describe netpol -n tag17 notes-from-other | grep -A4 'Allowing ingress'
k label pod -n tag17-other reporter access=notes
k exec -n tag17-other reporter -- wget -qO- -T2 http://notes.tag17/version
k exec -n tag17-other reporter -- nc -zv -w2 db.tag17 5432

Erwartet (gekürzt):

notes-egress          app=notes      3m30s
notes-from-other      app=notes      4m29s
notes-ingress         app=notes      5m28s
  Allowing ingress traffic:
    To Port: 8080/TCP
    From:
      NamespaceSelector: kubernetes.io/metadata.name=tag17-other
      PodSelector: access=notes
pod/reporter labeled
1.0
nc: db.tag17 (10.97.47.147:5432): Connection timed out
command terminated with exit code 1

Zwei Labels, zwei Namespaces – und die Datenbank bleibt trotzdem zu. Genau so viel öffnen wie verlangt.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Schreibe eine Policy deny-all für tag17, die allen Pods Ingress und Egress verbietet, und prüfe sie nur mit --dry-run=server. Zeitziel: 60 s
  2. Welches Label braucht ein Pod in tag17, um db zu erreichen? Zeitziel: 20 s
  3. Erlaube Pods mit monitoring=true aus allen Namespaces den Zugriff auf notes, Port 8080 (nur --dry-run=server). Zeitziel: 90 s
  4. Ersetze client-to-nodes: client darf nur noch die NodePorts 30000–32767 im Netz 172.16.0.0/24 erreichen. Zeitziel: 90 s

Lösung

k apply --dry-run=server -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
EOF
k get netpol db-ingress -o jsonpath='{.spec.ingress[0].from[0].podSelector}'; echo
k apply --dry-run=server -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: notes-monitoring
spec:
  podSelector:
    matchLabels:
      app: notes
  ingress:
  - from:
    - namespaceSelector: {}
      podSelector:
        matchLabels:
          monitoring: "true"
    ports:
    - port: 8080
EOF
k delete netpol client-to-nodes
k apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: client-nodeports
spec:
  podSelector:
    matchLabels:
      run: client
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 172.16.0.0/24
    ports:
    - port: 30000
      endPort: 32767
EOF
k exec client -- wget -qO- -T2 http://172.16.0.126:30500/v2/_catalog
k exec client -- nc -zv -w2 172.16.0.126 6443

Erwartet:

networkpolicy.networking.k8s.io/deny-all created (server dry run)
{"matchLabels":{"app":"notes"}}
networkpolicy.networking.k8s.io/notes-monitoring created (server dry run)
networkpolicy.networking.k8s.io "client-to-nodes" deleted from tag17 namespace
networkpolicy.networking.k8s.io/client-nodeports created
{"repositories":["notes-api"]}
nc: 172.16.0.126 (172.16.0.126:6443): Connection timed out
command terminated with exit code 1

Zu 2: app=notes – ein k describe netpol db-ingress zeigt es ebenso. Zu 3: namespaceSelector: {} heißt „alle Namespaces”; ohne policyTypes setzt der API-Server Ingress, weil eine ingress-Liste da ist. Zu 4: endPort geht nur mit numerischem port.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get netpol -o custom-columns=NAME:.metadata.name,TYPES:.spec.policyTypes

Erwartet:

NAME                  TYPES
allow-dns             [Egress]
client-egress         [Egress]
client-nodeports      [Egress]
db-ingress            [Ingress]
default-deny          [Ingress]
default-deny-egress   [Egress]
notes-egress          [Egress]
notes-from-other      [Ingress]
notes-ingress         [Ingress]
k exec client -- wget -qO- -T5 http://notes/healthz

Erwartet: ok – client erreicht notes, notes erreicht db.

k exec client -- nc -zv -w2 db 5432

Erwartet: Connection timed out – client kommt nicht direkt an die Datenbank.

k get pod -n tag17-other reporter --show-labels

Erwartet: access=notes,run=reporter,team=notes-users

Aufräumen (nach der Challenge):

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

Challenge

In tag17-other läuft das Deployment exporter (k create deployment exporter --image=busybox:1.37 -- sleep 3600). Seine Pods sollen notes in tag17 erreichen – dauerhaft, auch nach jedem Neustart. Policies bleiben unverändert.

Hinweis: k label deployment beschriftet nur das Deployment, nicht seine Pods.

Lösung

k create deployment exporter -n tag17-other --image=busybox:1.37 -- sleep 3600
k label deployment -n tag17-other exporter team=notes-users access=notes
k exec -n tag17-other deploy/exporter -- wget -qO- -T2 http://notes.tag17/version
k patch deployment -n tag17-other exporter -p '{"spec":{"template":{"metadata":
  {"labels":{"team":"notes-users","access":"notes"}}}}}'
k rollout status -n tag17-other deployment exporter
k exec -n tag17-other deploy/exporter -- wget -qO- -T2 http://notes.tag17/version

Erwartet (gekürzt):

deployment.apps/exporter created
deployment.apps/exporter labeled
wget: download timed out
command terminated with exit code 1
deployment.apps/exporter patched
deployment "exporter" successfully rolled out
1.0

Die Labels gehören ins Pod-Template (spec.template.metadata.labels); die Änderung löst einen Rollout aus. k edit deployment geht genauso. Danach aufräumen wie im Kontrollpunkt.

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • Erst k get netpol -A -o wide, dann k describe netpol: Selektoren und Ports lesen, dann Labels setzen – Policies nur ändern, wenn die Aufgabe es erlaubt.
  • UND/ODER-Falle: namespaceSelector und podSelector im selben Listeneintrag = UND, als zwei Einträge (-) = ODER. Ports sind Container-Ports.
  • Bei Egress-Sperren DNS (UDP und TCP 53) mitdenken. Doku: „Network Policies” unter Concepts → Services, Load Balancing, and Networking.

Enterprise-Notiz

  • Default Deny pro Namespace gehört in die Namespace-Vorlage (Helm, Kustomize, GitOps), nicht in die Handarbeit einzelner Teams.
  • Clusterweite Regeln (DNS immer erlauben, Monitoring herein) lösen CNI-eigene Objekte wie Calico GlobalNetworkPolicy; die Standard-NetworkPolicy kennt nur Namespaces.
  • NetworkPolicies arbeiten auf L3/L4. HTTP-Pfade, mTLS und Identitäten regelt ein Service-Mesh (Istio, Linkerd) oder Cilium.
  • Policies testen wie Code: Verbindungsmatrix in der CI prüfen, Calico-Flow-Logs für verworfene Pakete auswerten.