Cheveo Cheatsheet

NetworkPolicy Cheatsheet

12 produktionsreife YAML-Patterns zum Copy-Pasten. Von Deny-All bis Prometheus-Scraping, inkl. AND-vs-OR-Falle und häufige Fehler.

Blog-Artikel lesen →

Der Workflow

1 Deny-All

2 Ingress

3 Egress

4 Testen

5 Monitoring

Deny-Defaults

Deny All Ingress

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-ingress
  namespace: <ns>
spec:
  podSelector: {}
  policyTypes:
    - Ingress

→ Blockiert allen eingehenden Traffic. Basis für Zero-Trust.

Deny All Egress

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-egress
  namespace: <ns>
spec:
  podSelector: {}
  policyTypes:
    - Egress

→ Blockiert allen ausgehenden Traffic. Immer mit DNS-Egress (Pattern 10) kombinieren.

Deny All (beides)

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: <ns>
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress

→ Komplette Namespace-Isolation. Von hier aus Pattern für Pattern öffnen.

Namespace & Pod

Allow Same Namespace

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-same-namespace
  namespace: <ns>
spec:
  podSelector: {}
  ingress:
    - from:
        - podSelector: {}
  policyTypes:
    - Ingress

→ Pods im eigenen Namespace dürfen sich erreichen, nichts von außen.

Allow from Namespace

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-from-namespace
  namespace: <ns>
spec:
  podSelector: {}
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              name: backend
  policyTypes:
    - Ingress

→ Erlaubt Traffic aus einem bestimmten Namespace (Label nötig).

Allow Specific Port

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-http-only
  namespace: <ns>
spec:
  podSelector:
    matchLabels:
      app: web
  ingress:
    - ports:
        - port: 8080
          protocol: TCP
      from:
        - podSelector: {}
  policyTypes:
    - Ingress

→ Nur Port 8080/TCP, nur aus dem eigenen Namespace.

Infrastruktur

Allow Ingress Controller

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-from-ingress
  namespace: <ns>
spec:
  podSelector:
    matchLabels:
      app: web
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              name: ingress-nginx
  policyTypes:
    - Ingress

→ Ingress-Controller darf an App. Ohne das: App von außen unerreichbar.

Allow Prometheus (AND)

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-prometheus
  namespace: <ns>
spec:
  podSelector: {}
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              name: monitoring
          podSelector:
            matchLabels:
              app.kubernetes.io/name: prometheus
      ports:
        - port: 9090
          protocol: TCP
  policyTypes:
    - Ingress

→ AND-Variante: nur Prometheus aus dem Monitoring-Namespace.

Allow Backend → DB

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-backend-to-db
  namespace: <ns>
spec:
  podSelector:
    matchLabels:
      app: database
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: backend
      ports:
        - port: 5432
          protocol: TCP
  policyTypes:
    - Ingress

→ Nur Backend darf an DB, nur Port 5432.

Egress-Kontrolle

Allow DNS Only

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns-egress
  namespace: <ns>
spec:
  podSelector: {}
  egress:
    - ports:
        - port: 53
          protocol: UDP
        - port: 53
          protocol: TCP
  policyTypes:
    - Egress

→ Wichtigstes Egress-Pattern. Ohne DNS kein Service-Discovery.

Allow External CIDR

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-egress-to-db
  namespace: <ns>
spec:
  podSelector:
    matchLabels:
      app: backend
  egress:
    - to:
        - ipBlock:
            cidr: 10.0.0.0/24
      ports:
        - port: 5432
          protocol: TCP
    - ports:
        - port: 53
          protocol: UDP
  policyTypes:
    - Egress

→ Egress zu externer DB (Subnet + Port) plus DNS.

Allow Internal Service

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-api
  namespace: <ns>
spec:
  podSelector:
    matchLabels:
      app: frontend
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: api
      ports:
        - port: 8080
          protocol: TCP
    - ports:
        - port: 53
          protocol: UDP
  policyTypes:
    - Egress

→ Frontend darf nur mit API-Service reden plus DNS.

5 häufigste Fehler

Jeder davon hat uns in Production schon mindestens einmal Stunden gekostet.

DNS-Egress vergessen

Deny-All-Egress ohne Port 53 → alles bricht

AND vs OR verwechselt

Ein Bindestrich öffnet Zugriff viel weiter als gewollt

Namespace-Labels fehlen

namespaceSelector matcht Labels, nicht den Namen

CNI enforced nicht

kubenet ignoriert Policies, Cilium/Calico/Weave nötig

Nur Ingress, kein Egress

Ingress allein kontrolliert nicht den ausgehenden Traffic

Schnelle Entscheidungen

Pods können auf alles zugreifen

→ Deny-All + explizite Allows

Service nach Policy unerreichbar

→ DNS-Egress (Pattern 10) vergessen

Ingress-Controller kommt nicht durch

→ Allow from Ingress-NS (Pattern 7)

Prometheus scrapet nicht mehr

→ Allow from Monitoring-NS (Pattern 8)

Policy zeigt keine Wirkung

→ CNI prüfen (Cilium/Calico?)

1-Tag Intensiv-Workshop

Kubernetes Debugging - systematisch statt raten

Echte Production-Incidents nachstellen, kubectl-Workflows verinnerlichen, Root-Causes in Minuten finden.

Workshop-Details ansehen