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.
ipBlockist 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.localErwartet:
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:8080Erwartet:
✘ 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.localErwartet (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
shopund die echte Top-Level-Domain.shopbeißen sich. Busybox-nslookupignoriert die Suchliste aus/etc/resolv.conf:kubectl -n shop exec deploy/frontend -- nslookup api.shopliefert eine öffentliche IP (bei uns185.180.19.198).curlundgetent hosts api.shopnutzen die Suchliste und landen richtig beiapi.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.shopErwartet:
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.shopErwartet:
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/metricsErwartet:
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/metricsErwartet:
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.yamlErwartet (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/versionErwartet:
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/versionErwartet:
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:8080Erwartet:
✘ 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 aufipBlock, 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=apiErwartet:
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:8080Erwartet:
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 hostnetSicherheit:
hostNetwork: trueumgeht 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 denyErwartet (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 --allFortschritt 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
hostNetworkumgeht. OpenShift (OVN-Kubernetes) und RKE2 (Canal) verhalten sich nicht identisch. - Verwende in App-Configs vollständige DNS-Namen
(
svc.cluster.local) und setze bei BedarfdnsConfig.options: ndots, um unnötige Upstream-Abfragen zu vermeiden.