Tag 11: Egress
Ziel: Du siehst, welche Ziele außerhalb des Clusters deine Dienste aufrufen, sperrst ausgehenden Verkehr standardmäßig und gibst einzelne Ziele per TLS- und HTTP-Route frei. · Dauer: ca. 60 min · Voraussetzung: Tag 10
Briefing
- Ohne Konfiguration lässt der Proxy jeden Verkehr nach außen durch.
In den Metriken heißt das
egress-fallback, bei HTTPS siehst du nur IP-Adressen. - Ein EgressNetwork (
policy.linkerd.io) beschreibt „alles außerhalb des Clusters“ für die Clients in seinem Namespace, mittrafficPolicy: AllowoderDeny. - TLSRoute, HTTPRoute oder TCPRoute mit dem EgressNetwork als Parent geben einzelne Ziele frei – per SNI-Hostname oder per HTTP-Host, Pfad und Methode.
- Egress im Mesh ist Sichtbarkeit und Leitplanke, keine Firewall: Ein Pod ohne Proxy läuft daran vorbei.
client ─> proxy ─┬─ TLSRoute example.com ──────> EgressNetwork internet ─> Internet
├─ HTTPRoute GET example.com ─> EgressNetwork internet ─> Internet
├─ HTTPRoute /version ────────> Service notes-api (im Cluster)
└─ alles andere ──> Deny: 403 bzw. Verbindungsabbruch
Drill 1: Wohin geht der Verkehr?
notes-api ruft unter /upstream die Adresse
aus NOTES_UPSTREAM auf. Dazu ein Client-Pod für eigene
Versuche. Die Annotation
config.linkerd.io/proxy-metrics-hostname-labels schreibt
den Zielnamen in die Metriken – standardmäßig aus, weil jeder Name eine
neue Zeitreihe ist.
mkdir -p ~/linkerd/tag11 && cd ~/linkerd/tag11
kubectl create namespace tag11
kubectl annotate namespace tag11 linkerd.io/inject=enabled
cat > app.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: notes-api, namespace: tag11}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: client, namespace: tag11}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api, namespace: tag11}
spec:
replicas: 1
selector: {matchLabels: {app: notes-api}}
template:
metadata:
labels: {app: notes-api}
annotations:
config.linkerd.io/proxy-metrics-hostname-labels: "true"
spec:
serviceAccountName: notes-api
containers:
- name: notes-api
image: ghcr.io/thomaszachmann/notes-api:0.7.1
env:
- {name: NOTES_API_KEY, value: lab-key-123}
- {name: NOTES_UPSTREAM, value: https://example.com}
ports: [{containerPort: 8080, name: http}]
readinessProbe:
httpGet: {path: /healthz, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: notes-api, namespace: tag11}
spec:
selector: {app: notes-api}
ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: client, namespace: tag11}
spec:
replicas: 1
selector: {matchLabels: {app: client}}
template:
metadata:
labels: {app: client}
annotations:
config.linkerd.io/proxy-metrics-hostname-labels: "true"
spec:
serviceAccountName: client
terminationGracePeriodSeconds: 2
containers:
- name: client
image: docker.io/curlimages/curl:8.23.0
command: [sleep, infinity]
EOF
kubectl apply -f app.yaml
kubectl -n tag11 rollout status deploy --timeout=120s
C="kubectl -n tag11 exec deploy/client -c client --"
for u in https://example.com http://example.com https://linkerd.io; do
$C curl -s -o /dev/null -w "$u %{http_code}\n" $u
done
$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echoErwartet (gekürzt):
https://example.com 200
http://example.com 200
https://linkerd.io 200
{"status":200,"url":"https://example.com"}
Was hat der Proxy von client gesehen? Die Metriken sind
lang; diese Zeile zieht Art, Route, Ziel, Status und Zähler heraus. Du
brauchst sie heute oft:
M() { linkerd diagnostics proxy-metrics -n tag11 deploy/client \
| grep -E '^outbound_(http_route_request_statuses|t(cp|ls)_route_open)_total' \
| sed -E 's/^outbound_([a-z]+)_.*route_name="([^"]*)",[a-z_]+="([^"]*)"/ \1 \2 \3 /' \
| sed -E 's/,http_status="([0-9]*)".*\}/\1/; s/[^ ]*\}//'; }
M | grep -v notes-apiErwartet (gekürzt):
http egress-fallback example.com 200 1
tcp egress-fallback 172.66.147.243 1
tcp egress-fallback 188.114.96.0 1
HTTP siehst du mit Hostname und Status. HTTPS ist für den Proxy nur eine TCP-Verbindung zu einer IP – welcher Dienst dahintersteckt, verrät die Metrik nicht.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Ein EgressNetwork
cat > egress.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: EgressNetwork
metadata: {name: internet, namespace: tag11}
spec:
trafficPolicy: Allow
EOF
kubectl apply -f egress.yaml
sleep 5
kubectl -n tag11 get egressnetwork internet \
-o jsonpath='{.status.conditions[0].reason}{"\n"}'
for u in https://example.com http://example.com https://linkerd.io; do
$C curl -s -o /dev/null -w "$u %{http_code}\n" $u
done
M | grep egress-allowErwartet (gekürzt):
egressnetwork.policy.linkerd.io/internet created
Accepted
https://example.com 200
http://example.com 200
https://linkerd.io 200
http http-egress-allow example.com 200 1
tcp tcp-egress-allow 104.20.23.154 1
tcp tcp-egress-allow 172.66.147.243 1
Ohne networks umfasst das EgressNetwork alles außerhalb
von clusterNetworks aus der Linkerd-Konfiguration. Noch
ändert sich am Verhalten nichts, aber der Verkehr hat jetzt einen
Parent: http-egress-allow und tcp-egress-allow
sind die eingebauten Standardrouten. Kein Neustart nötig – der Proxy
holt die Policy live.
Tipp: Ein EgressNetwork gilt nur für Clients im eigenen Namespace. Eines im Namespace
linkerd-egress(egress.globalEgressNetworkNamespace) gilt für alle. Das legst du im Labor bewusst nicht an – es träfe auchnotes.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Alles sperren
kubectl -n tag11 patch egressnetwork internet --type=merge \
-p '{"spec":{"trafficPolicy":"Deny"}}'
sleep 5
for u in https://example.com http://example.com https://linkerd.io; do
$C curl -s -o /dev/null -w "$u %{http_code}\n" $u; echo "exit $?"
done
M | grep egress-deny
$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echo
kubectl -n tag11 rollout restart deploy/notes-api
kubectl -n tag11 rollout status deploy/notes-api
$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echoErwartet (gekürzt):
https://example.com 000
command terminated with exit code 35
exit 35
http://example.com 403
exit 0
https://linkerd.io 000
command terminated with exit code 35
exit 35
http http-egress-deny example.com 403 1
tcp tcp-egress-deny 104.20.23.154 1
tcp tcp-egress-deny 188.114.97.4 1
{"status":200,"url":"https://example.com"}
deployment "notes-api" successfully rolled out
{"error":"Get \"https://example.com\": read tcp 10.0.1.67:47058-\u003e104.20.23.154:443:
read: connection reset by peer"}
HTTP bekommt vom Proxy ein 403. HTTPS kann er nicht
beantworten, er bricht die Verbindung ab – curl meldet
Exit-Code 35 (TLS-Handshake gescheitert).
Aber notes-api kommt noch durch! Die Policy gilt für
neue Verbindungen. Der Go-HTTP-Client von
notes-api hält seine Verbindung zu example.com
aus Drill 1 offen (Keep-Alive), und die bleibt bestehen. Erst nach dem
Neustart greift die Sperre. Nach einer Policy-Änderung immer mit
frischen Verbindungen testen – und im Betrieb damit rechnen, dass eine
Sperre erst nach Minuten oder einem Rollout vollständig wirkt.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Ein Ziel per TLSRoute freigeben
Bei HTTPS bleibt dem Proxy der Hostname aus dem TLS-Handshake (SNI):
cat > tls-example.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: TLSRoute
metadata: {name: example-com, namespace: tag11}
spec:
parentRefs:
- {group: policy.linkerd.io, kind: EgressNetwork, name: internet, port: 443}
hostnames: [example.com]
rules:
- backendRefs:
- {group: policy.linkerd.io, kind: EgressNetwork, name: internet}
EOF
kubectl apply -f tls-example.yaml
sleep 5
kubectl -n tag11 get tlsroute example-com \
-o jsonpath='{.status.parents[*].controllerName}{"\n"}'
for u in https://example.com https://www.example.com https://linkerd.io; do
$C curl -s -o /dev/null -w "$u %{http_code}\n" $u
done
$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echo
M | grep '^ tls'Erwartet (gekürzt):
tlsroute.gateway.networking.k8s.io/example-com created
linkerd.io/policy-controller
https://example.com 200
https://www.example.com 000
command terminated with exit code 35
https://linkerd.io 000
command terminated with exit code 35
{"status":200,"url":"https://example.com"}
tls tls-egress-deny linkerd.io 1
tls tls-egress-deny www.example.com 1
tls example-com example.com 1
Der Backend-Verweis auf das EgressNetwork selbst heißt: „durchlassen
an das ursprüngliche Ziel“. Sobald es eine TLSRoute gibt, prüft der
Proxy auf Port 443 den Handshake – aus tcp mit IP wird
tls mit Hostname, auch für gesperrte Ziele. Nur Linkerd hat
die Route angenommen: Mit einem EgressNetwork als Parent kann Cilium
nichts anfangen.
Fortschritt speichern? Kostenlos registrieren
Drill 5: HTTP genauer steuern
Bei Klartext-HTTP sieht der Proxy alles: Host, Methode, Pfad. Erlaubt
sei nur GET auf example.com;
/version leitest du auf notes-api im Cluster
um – etwa um eine externe API im Test zu ersetzen:
cat > http-example.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: example-http, namespace: tag11}
spec:
parentRefs:
- {group: policy.linkerd.io, kind: EgressNetwork, name: internet, port: 80}
hostnames: [example.com]
rules:
- matches:
- {method: GET, path: {type: PathPrefix, value: /}}
backendRefs:
- {group: policy.linkerd.io, kind: EgressNetwork, name: internet}
- matches:
- {path: {type: PathPrefix, value: /version}}
backendRefs:
- {name: notes-api, port: 80}
EOF
kubectl apply -f http-example.yaml
sleep 5
$C curl -s -o /dev/null -w 'GET %{http_code}\n' http://example.com/
$C curl -s -o /dev/null -w 'POST %{http_code}\n' -X POST http://example.com/
$C curl -s -o /dev/null -w 'neverssl %{http_code}\n' http://neverssl.com/
$C curl -s -w ' %{http_code}\n' http://example.com/version
M | grep -E 'example-http|neverssl'Erwartet (gekürzt):
GET 200
POST 403
neverssl 403
0.7.1
200
http http-egress-deny neverssl.com 403 1
http example-http example.com 200 2
/version passt auf beide Regeln; der längere Pfad
gewinnt. Die Antwort 0.7.1 kommt von notes-api
aus dem Cluster, obwohl curl example.com
aufgerufen hat. Der gesperrte POST zählt unter
http-egress-deny mit Hostname example.com –
M | grep http-egress-deny zeigt ihn.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Das zweite Ziel für die App
notes-api soll künftig https://linkerd.io
abfragen:
kubectl -n tag11 set env deploy/notes-api NOTES_UPSTREAM=https://linkerd.io
kubectl -n tag11 rollout status deploy/notes-api
$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echo
kubectl -n tag11 patch tlsroute example-com --type=json \
-p '[{"op":"add","path":"/spec/hostnames/-","value":"linkerd.io"}]'
sleep 5
$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echoErwartet (gekürzt):
deployment "notes-api" successfully rolled out
{"error":"Get \"https://linkerd.io\": EOF"}
tlsroute.gateway.networking.k8s.io/example-com patched
{"status":200,"url":"https://linkerd.io"}
Ein neues Ziel ist eine Änderung an der Route, nicht an der App. Im
Betrieb landet sie im selben Pull Request wie die neue
NOTES_UPSTREAM. Damit Prometheus etwas zu zählen hat, etwas
Last und dann die Ziele pro Dienst:
for i in $(seq 30); do
$C curl -s -o /dev/null -H 'X-API-Key: lab-key-123' http://notes-api/upstream
$C curl -s -o /dev/null https://www.example.com
sleep 2
done
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
>/dev/null 2>&1 &
sleep 4
Q='sum by (deployment, route_name, hostname)
(outbound_tls_route_open_total{namespace="tag11"})'
curl -s localhost:9090/api/v1/query --data-urlencode "query=$Q" | jq -r \
'.data.result[] | [.metric.deployment, .metric.route_name, .metric.hostname,
(.value[1] | tonumber | round | tostring)] | join(" ")'Erwartet (Zahlen schwanken):
client tls-egress-deny www.example.com 30
client example-com example.com 1
client tls-egress-deny linkerd.io 1
notes-api tls-egress-deny linkerd.io 1
notes-api example-com linkerd.io 1
Die Metrik zählt Verbindungen, nicht Requests:
client öffnet für jedes curl eine neue (30),
notes-api hat 30 Requests über eine einzige
Keep-Alive-Verbindung geschickt (1) – dieselbe Ursache wie der
Fallstrick in Drill 3. Das ist die Egress-Übersicht für den ganzen
Namespace: wer, wohin, erlaubt oder gesperrt. Ein Alarm auf
route_name=~".*-egress-deny" meldet Apps, die an ein nicht
freigegebenes Ziel wollen. Den Port-Forward brauchst du gleich noch.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Die Grenze
kubectl -n tag11 run ohne --image=curlimages/curl:8.23.0 --restart=Never \
--annotations=linkerd.io/inject=disabled --command -- sleep 3600
kubectl -n tag11 wait --for=condition=Ready pod/ohne --timeout=60s
kubectl -n tag11 exec ohne -- curl -s -o /dev/null -w '%{http_code}\n' \
https://www.example.comErwartet:
pod/ohne created
pod/ohne condition met
200
Kein Proxy, keine Regel. Dasselbe gilt für Pods mit
hostNetwork oder einem Container mit
NET_ADMIN, der die iptables-Regeln ändert. Die Linkerd-Doku
sagt es ausdrücklich: Egress-Kontrolle im Mesh ist keine
Sicherheitsgarantie. Eine harte Grenze ziehst du zusätzlich im Netzwerk
– mit Cilium etwa eine CiliumNetworkPolicy mit
toFQDNs, die du in diesem Labor aber nicht anfasst.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig alle Routen in
tag11, die am EgressNetwork hängen. Zeitziel: 30 s - Schalte
internetaufAllowund zurück aufDeny. Zeitziel: 45 s - Zeig, welche Hostnamen für
clientzuletzt gesperrt wurden. Zeitziel: 20 s - Prüfe, ob
notes-apiHostnamen in seine Metriken schreibt. Zeitziel: 30 s
Lösung
kubectl -n tag11 get httproute,tlsroute
kubectl -n tag11 patch egressnetwork internet --type=merge \
-p '{"spec":{"trafficPolicy":"Allow"}}'
kubectl -n tag11 patch egressnetwork internet --type=merge \
-p '{"spec":{"trafficPolicy":"Deny"}}'
M | grep egress-deny
kubectl -n tag11 get deploy notes-api \
-o jsonpath='{.spec.template.metadata.annotations}'Erwartet (Auszug für 1 und 4):
NAME HOSTNAMES AGE
httproute.gateway.networking.k8s.io/example-http ["example.com"] 6m
NAME AGE
tlsroute.gateway.networking.k8s.io/example-com 9m
{"config.linkerd.io/proxy-metrics-hostname-labels":"true"}
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
$C curl -s -o /dev/null -w '%{http_code}\n' https://example.com
$C curl -s -o /dev/null -w '%{http_code}\n' https://www.example.comErwartet: 200, dann 000
mit Exit-Code 35.
$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echoErwartet:
{"status":200,"url":"https://linkerd.io"}
kubectl -n tag11 get egressnetwork internet -o jsonpath='{.spec.trafficPolicy}{"\n"}'Erwartet: Deny
Challenge
Gib alle Subdomains von example.com frei, ohne sie
einzeln aufzuzählen. Prüfe, ob example.com selbst danach
noch über diesen Eintrag erreichbar wäre.
Hinweis: hostnames in
Gateway-API-Routen kennen Wildcards am Anfang.
Lösung
kubectl -n tag11 patch tlsroute example-com --type=json \
-p '[{"op":"add","path":"/spec/hostnames/-","value":"*.example.com"}]'
sleep 5
for u in https://example.com https://www.example.com https://linkerd.io; do
$C curl -s -o /dev/null -w "$u %{http_code}\n" $u
done
kubectl -n tag11 patch tlsroute example-com --type=json \
-p '[{"op":"remove","path":"/spec/hostnames/0"}]'
sleep 5
$C curl -s -o /dev/null -w '%{http_code}\n' https://example.com
kill %1Erwartet (gekürzt):
tlsroute.gateway.networking.k8s.io/example-com patched
https://example.com 200
https://www.example.com 200
https://linkerd.io 200
tlsroute.gateway.networking.k8s.io/example-com patched
000
command terminated with exit code 35
Nach dem Entfernen von example.com (Index 0) bleibt nur
*.example.com – und der passt nicht auf
example.com selbst. Willst du beides, brauchst du beide
Einträge.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
kubectl delete namespace tag11Interview-Notiz
- Wie siehst du, welche externen Ziele ein Dienst aufruft?
Mit einem EgressNetwork (auch auf
Allow) und Hostname-Labels: Die Proxy-Metriken zeigen Route, SNI- oder HTTP-Hostname und Status. - Wie sperrst du Egress mit Linkerd?
trafficPolicy: Denyund Ziele über TLS-, HTTP- oder TCP-Routen mit dem EgressNetwork als Parent und Backend freigeben. - Ist das eine Sicherheitsgrenze? Nein – Pods ohne Proxy umgehen sie. Für harte Grenzen Netzwerk-Policies oder ein Egress-Gateway dazu.
Enterprise-Notiz
- Erst beobachten, dann sperren: wochenlang
Allowmit Hostname-Labels, daraus die Freigabeliste bauen, dannDeny. - Hostname-Labels erhöhen die Kardinalität – nur dort einschalten, wo du sie brauchst, oder per Recording Rule verdichten.
- Ein globales EgressNetwork im
linkerd-egress-Namespace setzt eine clusterweite Grundregel; Namespaces ergänzen ihre eigenen Freigaben. - SNI-Freigaben prüfen nur den Namen im Handshake. Gegen Domain Fronting hilft nur eine Netzwerk-Policy auf Ziel-IPs oder ein Proxy, der TLS aufbricht.
- Egress-Routen gehören in das Repo der App: Ein neues Ziel ist eine Code-Änderung mit Review.