Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 2: DNS, Egress und Fallen

Ziel: Egress sauber abriegeln, ohne DNS, API-Server oder Ports zu verlieren, und die typischen Fallen selbst auslösen. · Dauer: ca. 90 min · Voraussetzung: Tag 1

Briefing

  • Default Deny für Egress sperrt auch DNS. Fast jede „kaputte” Policy ist in Wahrheit ein DNS-Problem.
  • Policies sehen Pod-IPs und Container-Ports, nicht Service-IPs und Service-Ports.
  • Eine Verbindung zwischen zwei abgeriegelten Pods braucht zwei Erlaubnisse: Egress beim Sender, Ingress beim Empfänger.
  • ipBlock ist für Ziele außerhalb des Clusters gedacht. Für Pods nimm Selektoren.
  • Host-Traffic (kubelet-Probes, hostNetwork-Pods) behandelt jedes CNI etwas anders.
 frontend ──DNS──► kube-dns (kube-system) :53 UDP/TCP     braucht Egress
    │
    └── api.shop:80 ──Service-DNAT──► api-Pod :8080        Policy sieht :8080
                                       braucht Ingress

Drill 1: Deny All – und DNS ist weg

cd ~/guard-lab/tag02
alias cc=~/guard-lab/code/demo/conncheck.sh
kubectl -n shop get networkpolicy
cat > default-deny-all.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: shop
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
EOF
kubectl apply -f default-deny-all.yaml
cc shop/frontend http://api.tenant-a
kubectl -n shop exec deploy/frontend -- nslookup api.tenant-a.svc.cluster.local

Erwartet:

No resources found in shop namespace.
networkpolicy.networking.k8s.io/default-deny-all created
✘ blockiert shop/frontend -> http://api.tenant-a (Timeout)
;; connection timed out; no servers could be reached

command terminated with exit code 1

Der Name lässt sich nicht mehr auflösen. Das Paket an CoreDNS (10.96.0.10:53) ist Egress, und Egress ist jetzt komplett zu. Gegenprobe mit der Pod-IP:

IP=$(kubectl -n tenant-a get pod -l app=api -o jsonpath='{.items[0].status.podIP}')
cc shop/frontend http://$IP:8080

Erwartet:

✘ blockiert shop/frontend -> http://10.244.0.8:8080 (Timeout)

Auch ohne DNS kein Weg nach draußen. Default Deny wirkt in beide Richtungen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: DNS erlauben

cat > allow-dns.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
  namespace: shop
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - protocol: UDP
      port: 53
    - protocol: TCP
      port: 53
EOF
kubectl apply -f allow-dns.yaml
kubectl -n shop exec deploy/frontend -- nslookup api.tenant-a.svc.cluster.local
cc shop/frontend http://api.shop
cc shop/frontend http://nix.shop.svc.cluster.local

Erwartet (gekürzt):

networkpolicy.networking.k8s.io/allow-dns created
Server:     10.96.0.10
Name:   api.tenant-a.svc.cluster.local
Address: 10.96.4.91
✘ blockiert shop/frontend -> http://api.shop (Timeout)
✘ blockiert shop/frontend -> http://nix.shop.svc.cluster.local (DNS-Fehler)

DNS läuft wieder, das zeigt der DNS-Fehler beim nicht existierenden Namen: Die Antwort „gibt es nicht” kommt an. api.shop wird aufgelöst, aber die Verbindung selbst ist noch nicht erlaubt. Beide Ports, UDP und TCP: Große Antworten (DNSSEC, viele Records) fallen auf TCP zurück.

Achtung: Namespace shop und die echte Top-Level-Domain .shop beißen sich. Busybox-nslookup ignoriert die Suchliste aus /etc/resolv.conf: kubectl -n shop exec deploy/frontend -- nslookup api.shop liefert eine öffentliche IP (bei uns 185.180.19.198). curl und getent hosts api.shop nutzen die Suchliste und landen richtig bei api.shop.svc.cluster.local. In Policies und Configs daher immer den vollen Namen verwenden.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Service-Port oder Container-Port?

Das frontend soll mit der api reden. Erste Idee: Egress auf Port 80, so steht es im Service.

cat > frontend-to-api.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-to-api
  namespace: shop
spec:
  podSelector:
    matchLabels:
      app: frontend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: api
    ports:
    - port: 80
EOF
kubectl apply -f frontend-to-api.yaml
cc shop/frontend http://api.shop

Erwartet:

networkpolicy.networking.k8s.io/frontend-to-api created
✘ blockiert shop/frontend -> http://api.shop (Timeout)

Port 80 existiert nur am Service. Nach dem DNAT durch kube-proxy geht das Paket an Pod-IP:8080. Also 8080:

sed -i.bak 's/    - port: 80/    - port: 8080/' frontend-to-api.yaml
kubectl apply -f frontend-to-api.yaml
cc shop/frontend http://api.shop

Erwartet:

networkpolicy.networking.k8s.io/frontend-to-api configured
✘ blockiert shop/frontend -> http://api.shop (Timeout)

Immer noch zu. Egress beim frontend ist jetzt offen, aber die api hat Default Deny für Ingress. Die Gegenseite fehlt:

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:
    - port: http
EOF
kubectl apply -f api-from-frontend.yaml
cc shop/frontend http://api.shop
cc shop/frontend http://api.shop:9113/metrics

Erwartet:

networkpolicy.networking.k8s.io/api-from-frontend created
✔ erlaubt   shop/frontend -> http://api.shop (HTTP 200)
✘ blockiert shop/frontend -> http://api.shop:9113/metrics (Timeout)

Merksatz: Bei Deny All in beide Richtungen braucht jede Verbindung zwei Policies, eine pro Ende. Named Ports (http) schützen dich vor der 80/8080-Falle, weil sie direkt den Container-Port meinen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Portbereiche mit endPort

Manche Dienste nutzen ganze Portbereiche. Seit Kubernetes 1.25 ist endPort stabil:

cat > api-range.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-range
  namespace: shop
spec:
  podSelector:
    matchLabels:
      app: frontend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: api
    ports:
    - protocol: TCP
      port: 9000
      endPort: 9200
EOF
cat > api-metrics-in.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-metrics-in
  namespace: shop
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector: {}
    ports:
    - port: metrics
EOF
kubectl apply -f api-range.yaml -f api-metrics-in.yaml
cc shop/frontend http://api.shop:9113/metrics

Erwartet:

networkpolicy.networking.k8s.io/api-range created
networkpolicy.networking.k8s.io/api-metrics-in created
✔ erlaubt   shop/frontend -> http://api.shop:9113/metrics (HTTP 200)

Und die Kombination aus Named Port und Bereich?

cat > bad-range.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: bad-range
  namespace: shop
spec:
  podSelector: {}
  egress:
  - ports:
    - port: metrics
      endPort: 9200
EOF
kubectl apply -f bad-range.yaml

Erwartet (umbrochen):

The NetworkPolicy "bad-range" is invalid: spec.egress[0].ports[0].endPort: Invalid
value: 9200: may not be specified when `port` is non-numeric

Gut so: Die API-Validierung fängt den Fehler ab. Ob das CNI endPort auch umsetzt, prüfst du trotzdem immer per Test. Ältere CNIs haben das Feld stillschweigend ignoriert.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der API-Server – die ipBlock-Falle

Operatoren, Sidecars und Controller sprechen mit dem API-Server. Unter Deny All geht das nicht mehr:

cc shop/api https://kubernetes.default.svc/version
kubectl get svc kubernetes -o jsonpath='{.spec.clusterIP}{"\n"}'
kubectl get endpointslice -l kubernetes.io/service-name=kubernetes \
  -o jsonpath='{.items[0].endpoints[0].addresses[0]}:{.items[0].ports[0].port}{"\n"}'

Erwartet:

✘ blockiert shop/api -> https://kubernetes.default.svc/version (Timeout)
10.96.0.1
172.18.0.8:6443

Naheliegend wäre ein ipBlock mit der Service-IP 10.96.0.1/32 und Port 443:

cat > api-to-apiserver.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-to-apiserver
  namespace: shop
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 10.96.0.1/32
    ports:
    - port: 443
EOF
kubectl apply -f api-to-apiserver.yaml
cc shop/api https://kubernetes.default.svc/version

Erwartet:

networkpolicy.networking.k8s.io/api-to-apiserver created
✘ blockiert shop/api -> https://kubernetes.default.svc/version (Timeout)

Dieselbe DNAT-Falle wie in Drill 3, nur mit IPs: Die Policy sieht die echte Adresse des API-Servers und dessen Port 6443.

EP=$(kubectl get endpointslice -l kubernetes.io/service-name=kubernetes \
  -o jsonpath='{.items[0].endpoints[0].addresses[0]}')
sed -i.bak -e "s#10.96.0.1/32#$EP/32#" -e 's/port: 443/port: 6443/' \
  api-to-apiserver.yaml
kubectl apply -f api-to-apiserver.yaml
cc shop/api https://kubernetes.default.svc/version

Erwartet:

networkpolicy.networking.k8s.io/api-to-apiserver configured
✔ erlaubt   shop/api -> https://kubernetes.default.svc/version (HTTP 200)

Achtung: Die Endpoint-IPs ändern sich mit jedem neuen Control-Plane-Node. Bei mehreren Control-Plane-Nodes musst du alle eintragen. Cilium löst das eleganter mit toEntities: [kube-apiserver] (Tag 4).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Internet ja, Cluster nein – ipBlock mit except

Die api soll externe HTTPS-Dienste erreichen, aber nicht die Nachbarn im Cluster:

cc shop/api https://example.com
cat > api-to-internet.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-to-internet
  namespace: shop
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 10.0.0.0/8
        - 172.16.0.0/12
        - 192.168.0.0/16
    ports:
    - port: 443
    - port: 8080
EOF
kubectl apply -f api-to-internet.yaml
cc shop/api https://example.com
cc shop/api http://api.tenant-a
IP=$(kubectl -n tenant-a get pod -l app=api -o jsonpath='{.items[0].status.podIP}')
cc shop/api http://$IP:8080

Erwartet:

✘ blockiert shop/api -> https://example.com (Timeout)
networkpolicy.networking.k8s.io/api-to-internet created
✔ erlaubt   shop/api -> https://example.com (HTTP 200)
✘ blockiert shop/api -> http://api.tenant-a (Timeout)
✘ blockiert shop/api -> http://10.244.0.8:8080 (Timeout)

Port 8080 ist in der Policy offen, trotzdem kommt die api nicht an tenant-a heran: Die Pod-IP 10.244.0.8 liegt in 10.0.0.0/8 und damit in except. Ohne except wäre 0.0.0.0/0 ein Freifahrtschein in den ganzen Cluster.

Achtung: Ob ipBlock überhaupt auf Pod-IPs greift, lässt die Spezifikation offen. Verlass dich für Cluster-Ziele nie auf ipBlock, sondern auf Selektoren. Und in Clouds liegen Pod- und Node-Netze oft in Bereichen, die du nicht ausschließen willst.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Probes und hostNetwork

Unter Deny All hat kein Pod Ingress-Erlaubnis vom Node. Überleben die Readiness-Probes?

kubectl -n shop delete pod -l app=api --wait=false
sleep 25
kubectl -n shop get pods -l app=api

Erwartet:

pod "api-5ccd4587ff-gwhbn" deleted from shop namespace
NAME                   READY   STATUS    RESTARTS   AGE
api-5ccd4587ff-m5966   1/1     Running   0          25s

Der neue Pod wird Ready. kindnet lässt die Probes des kubelet durch, ebenso wie Calico und Cilium in ihrer Standardeinstellung. Jetzt ein Pod im Host-Netz des Nodes:

cat > hostnet.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: hostnet
  namespace: default
  labels: {app: hostnet}
spec:
  hostNetwork: true
  terminationGracePeriodSeconds: 1
  containers:
  - name: curl
    image: curlimages/curl:8.22.0
    command: [sleep, "3600"]
EOF
kubectl apply -f hostnet.yaml
kubectl wait --for=condition=Ready pod/hostnet --timeout=60s
kubectl get pod hostnet -o wide | awk '{print $1, $6}'
IP=$(kubectl -n shop get pod -l app=api -o jsonpath='{.items[0].status.podIP}')
cc default/hostnet http://$IP:8080

Erwartet:

pod/hostnet created
pod/hostnet condition met
NAME IP
hostnet 172.18.0.8
✘ blockiert default/hostnet -> http://10.244.0.13:8080 (Timeout)

Ein hostNetwork-Pod hat die IP des Nodes und kein eigenes Pod-Label im Paket. In unserem kindnet-Test wird er blockiert, die kubelet-Probes vom selben Node aber nicht. Andere CNIs entscheiden hier anders, denn die Spezifikation lässt Host-Traffic bewusst offen. Teste es auf jedem Zielsystem selbst.

kubectl delete pod hostnet

Sicherheit: hostNetwork: true umgeht die Pod-Identität. Verbiete es per Pod Security oder Kyverno für alle App-Namespaces (Tag 8).

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
shop/frontend http://api.shop:9113/metrics allow
shop/frontend http://api.tenant-a deny
shop/api https://kubernetes.default.svc/version allow
shop/api https://example.com allow
shop/api http://api.tenant-a deny
shop/db http://api.shop deny
EOF
kubectl -n shop get netpol allow-dns >/dev/null 2>&1 \
  && echo "✔ allow-dns" || echo "✘ allow-dns fehlt"

Challenge

Der Client soll http://frontend.shop/api/orders wieder abrufen können, die api selbst aber weiter nicht direkt. Das frontend löst api.shop zur Laufzeit per nginx-resolver auf.

Hinweis: Es fehlt genau eine Policy. Egress vom frontend zur api und DNS hast du schon.

Lösung

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
kubectl exec client -- curl -s -m 5 http://frontend.shop/api/orders
cc default/client http://api.shop deny

Erwartet (gekürzt, kann je nach Version abweichen):

networkpolicy.networking.k8s.io/frontend-from-all created
{"svc":"api","ns":"shop","path":"/api/orders"}
✘ blockiert default/client -> http://api.shop (Timeout)

Ohne allow-dns liefert nginx nach etwa 2 s einen 5xx-Fehler: Die Verbindung zum frontend steht, aber der Name api.shop.svc.cluster.local lässt sich nicht auflösen.

Aufräumen für Tag 3:

kubectl -n shop delete networkpolicy --all

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Rolle Default Deny für Egress immer zusammen mit einer allow-dns-Policy aus. Sonst bricht jeder Namespace sofort.
  • Pflege die Erlaubnis zum API-Server zentral (AdminNetworkPolicy oder CiliumClusterwideNetworkPolicy, Tag 5), nicht in jedem Team-Namespace mit festen IPs.
  • Externe Ziele per IP sind zerbrechlich. Für SaaS-Endpunkte mit wechselnden IPs brauchst du FQDN-Policies (Cilium toFQDNs, Tag 4) oder einen Egress-Proxy.
  • Prüfe beim Kunden, wie das CNI mit Host-Traffic, Node-Ports und hostNetwork umgeht. OpenShift (OVN-Kubernetes) und RKE2 (Canal) verhalten sich nicht identisch.
  • Verwende in App-Configs vollständige DNS-Namen (svc.cluster.local) und setze bei Bedarf dnsConfig.options: ndots, um unnötige Upstream-Abfragen zu vermeiden.