Zum Inhalt springen
Trainingslager IT-Trainingslager

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, mit trafficPolicy: Allow oder Deny.
  • 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; echo

Erwartet (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-api

Erwartet (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-allow

Erwartet (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 auch notes.

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; echo

Erwartet (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; echo

Erwartet (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.com

Erwartet:

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

  1. Zeig alle Routen in tag11, die am EgressNetwork hängen. Zeitziel: 30 s
  2. Schalte internet auf Allow und zurück auf Deny. Zeitziel: 45 s
  3. Zeig, welche Hostnamen für client zuletzt gesperrt wurden. Zeitziel: 20 s
  4. Prüfe, ob notes-api Hostnamen 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.com

Erwartet: 200, dann 000 mit Exit-Code 35.

$C curl -s -H 'X-API-Key: lab-key-123' http://notes-api/upstream; echo

Erwartet: {"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 %1

Erwartet (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 tag11

Interview-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: Deny und 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 Allow mit Hostname-Labels, daraus die Freigabeliste bauen, dann Deny.
  • 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.