Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: Circuit Breaking und Rate Limiting

Ziel: Ein Pod, der nur noch Fehler liefert, bekommt kaum noch Verkehr, und ein lauter Client wird mit 429 gebremst, ohne die anderen zu stören. · Dauer: ca. 60 min · Voraussetzung: Tag 7

Briefing

  • Circuit Breaking heißt bei Linkerd Failure Accrual: Der Client-Proxy zählt Fehler pro Endpunkt und nimmt einen Pod nach N Fehlern in Folge aus dem Load Balancer.
  • Gesteuert per Annotation am Service: balancer.linkerd.io/failure-accrual: consecutive plus ...-max-failures, ...-min-penalty, ...-max-penalty.
  • Ein gesperrter Pod bekommt nach der Penalty einen echten Request als Probe. Grüne Readiness-Probes holen ihn nicht zurück.
  • Rate Limiting macht der Server-Proxy: HTTPLocalRateLimitPolicy an einem Server, mit total, identity und overrides. Zu viel gibt 429. „Local“ heißt: pro Pod.
 last ──> web ──(Failure Accrual)──> helper  gesund
                                └──> helper  gesund
                                └─X  helper-kaputt (immer 500, Readiness grün)
 burst ──(zu viele Requests)──> helper: 429 (HTTPLocalRateLimitPolicy)

Drill 1: Aufbau

Wieder eine Kopie in eigenem Namespace. web leitet nur /get an helper weiter, der Lastgenerator ruft es dreimal pro Runde auf.

mkdir -p ~/linkerd/tag08 && cd ~/linkerd/tag08
kubectl create namespace tag08
kubectl annotate namespace tag08 linkerd.io/inject=enabled
for a in web helper last; do kubectl -n tag08 create serviceaccount $a; done
cat > app.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata: {name: web-conf, namespace: tag08}
data:
  default.conf: |
    server {
      listen 8080;
      location /get {
        proxy_pass http://helper.tag08.svc.cluster.local/get;
      }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag08}
spec:
  replicas: 1
  selector: {matchLabels: {app: web}}
  template:
    metadata: {labels: {app: web}}
    spec:
      serviceAccountName: web
      containers:
      - name: web
        image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
        ports: [{containerPort: 8080, name: http}]
        volumeMounts: [{name: conf, mountPath: /etc/nginx/conf.d}]
      volumes: [{name: conf, configMap: {name: web-conf}}]
---
apiVersion: v1
kind: Service
metadata: {name: web, namespace: tag08}
spec:
  selector: {app: web}
  ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: helper, namespace: tag08}
spec:
  replicas: 2
  selector: {matchLabels: {app: helper, variante: gesund}}
  template:
    metadata: {labels: {app: helper, variante: gesund}}
    spec:
      serviceAccountName: helper
      containers:
      - name: helper
        image: ghcr.io/mccutchen/go-httpbin:2.26.0
        ports: [{containerPort: 8080, name: http}]
        readinessProbe:
          httpGet: {path: /status/200, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: helper, namespace: tag08}
spec:
  selector: {app: helper}
  ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last, namespace: tag08}
spec:
  replicas: 1
  selector: {matchLabels: {app: last}}
  template:
    metadata: {labels: {app: last}}
    spec:
      serviceAccountName: last
      containers:
      - name: last
        image: docker.io/curlimages/curl:8.23.0
        command: [sh, -c]
        args:
        - |
          while true; do
            for p in /get /get /get; do
              code=$(curl -s -o /dev/null -w "%{http_code}" -m 5 http://web$p)
              echo "$(date +%T) $p $code"
            done
            sleep 1
          done
EOF
kubectl apply -f app.yaml
kubectl -n tag08 rollout status deploy/helper --timeout=180s
kubectl -n tag08 rollout status deploy/last --timeout=180s
sleep 60
kubectl -n tag08 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet (Zahlen schwanken):

    126 /get 200

Der Service wählt nur app: helper – das Label variante dient dir gleich zur Unterscheidung.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ein Pod geht kaputt

Der schlimmste Fall für einen Load Balancer: Ein Pod ist bereit, liefert aber nur Fehler. Hier ein nginx, der /status/200 (Readiness) beantwortet und sonst 500 liefert:

cat > kaputt.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata: {name: kaputt-conf, namespace: tag08}
data:
  default.conf: |
    server {
      listen 8080;
      location = /status/200 { return 200 "ok\n"; }
      location / { return 500 "kaputt\n"; }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: helper-kaputt, namespace: tag08}
spec:
  replicas: 1
  selector: {matchLabels: {app: helper, variante: kaputt}}
  template:
    metadata: {labels: {app: helper, variante: kaputt}}
    spec:
      serviceAccountName: helper
      containers:
      - name: helper
        image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
        ports: [{containerPort: 8080, name: http}]
        readinessProbe:
          httpGet: {path: /status/200, port: http}
        volumeMounts: [{name: conf, mountPath: /etc/nginx/conf.d}]
      volumes: [{name: conf, configMap: {name: kaputt-conf}}]
EOF
kubectl apply -f kaputt.yaml
kubectl -n tag08 rollout status deploy/helper-kaputt --timeout=180s
sleep 65
kubectl -n tag08 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n tag08 po -l app=helper --from deploy/web

Erwartet (gekürzt, Zahlen schwanken):

     83 /get 200
     43 /get 500
NAME                              STATUS   MESHED   SUCCESS      RPS   LATENCY_P50
helper-5897c7498b-skj58          Running      1/1   100.00%   0.8rps           0ms
helper-5897c7498b-xsxmm          Running      1/1   100.00%   0.8rps           6ms
helper-kaputt-7c75dc7d79-pkcwx   Running      1/1     0.00%   0.7rps           3ms

Ein Drittel Fehler, gleichmäßig verteilt: Kubernetes hält den Pod für gesund, und der Load Balancer von Linkerd wählt nach Latenz – der kaputte Pod antwortet sogar schnell.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Failure Accrual einschalten

Nach drei Fehlern in Folge soll der Pod 10 Sekunden Pause bekommen, bei weiteren Fehlern immer länger, höchstens eine Minute:

kubectl -n tag08 annotate service helper \
  balancer.linkerd.io/failure-accrual=consecutive \
  balancer.linkerd.io/failure-accrual-consecutive-max-failures=3 \
  balancer.linkerd.io/failure-accrual-consecutive-min-penalty=10s \
  balancer.linkerd.io/failure-accrual-consecutive-max-penalty=1m
sleep 75
kubectl -n tag08 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n tag08 po -l app=helper --from deploy/web

Erwartet (gekürzt, Zahlen schwanken):

service/helper annotated
    124 /get 200
      1 /get 500
NAME                              STATUS   MESHED   SUCCESS      RPS   LATENCY_P50
helper-5897c7498b-skj58          Running      1/1   100.00%   1.3rps           3ms
helper-5897c7498b-xsxmm          Running      1/1   100.00%   0.9rps           8ms
helper-kaputt-7c75dc7d79-pkcwx   Running      1/1     0.00%   0.0rps           0ms

Von 34 auf unter 1 Prozent Fehler, ohne Neustart und ohne Änderung an web: Die Annotation am Service liest jeder Client-Proxy. Der kaputte Pod läuft weiter und steht weiter im Service – nur web schickt ihm nichts mehr.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Probezeit

Wann kommt der Pod zurück? Der Proxy von web zählt ausgesperrte Endpunkte als pending:

linkerd diagnostics proxy-metrics -n tag08 deploy/web \
  | grep '^outbound_http_balancer_endpoints.*pending' | grep -oE '[0-9]+$'
kubectl -n tag08 logs deploy/last -c last --since=120s | awk '$3==500 {print $1}' \
  | tail -5

Erwartet (Zeiten schwanken):

1
21:30:58
21:31:07
21:31:08
21:31:21
21:31:50

Bis 21:31:08 kamen die Fehler dicht – so lange brauchte die Annotation bis in den Proxy von web. Dann ein Fehler nach 13 Sekunden, der nächste nach 29: Jeder Probe-Request scheitert, die Pause wächst (mit etwas Zufall) bis zur Grenze von einer Minute. Ein paar Minuten später:

kubectl -n tag08 logs deploy/last -c last --since=300s | awk '$3==500 {print $1}'

Erwartet (Zeiten schwanken):

21:31:50
21:32:31
21:33:31
21:34:31
21:35:31
21:36:32

Ein Probe-Request pro Minute, das ist der Preis. Er ist ein echter Nutzer-Request – mit einem Retry aus Tag 7 auf derselben Route merkt der Nutzer auch den nicht.

Achtung: Sind alle Endpunkte gesperrt, antwortet der Proxy mit 503. Failure Accrual schützt vor einzelnen schlechten Pods, nicht vor einem kaputten Release. Und wie bei Retries gilt: Ein ServiceProfile für den Service schaltet es ab.

Neben consecutive gibt es unified: zusätzlich eine Mindest-Erfolgsquote in einem Zeitfenster (balancer.alpha.linkerd.io/failure-accrual-success-rate-threshold). Das fängt auch Pods, die nur jeden zweiten Request verlieren und nie drei Fehler in Folge haben.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Rate Limit für alle

Für das Rate Limiting nimmst du den kaputten Pod heraus und holst einen lauten Client:

kubectl -n tag08 delete deploy helper-kaputt
kubectl -n tag08 delete configmap kaputt-conf
kubectl -n tag08 create serviceaccount burst
kubectl -n tag08 create deployment burst --image=docker.io/curlimages/curl:8.23.0 \
  -- sleep infinity
kubectl -n tag08 set serviceaccount deploy/burst burst
kubectl -n tag08 rollout status deploy/burst --timeout=120s
kubectl -n tag08 exec deploy/burst -c curl -- sh -c 'for i in $(seq 40); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; done' | sort | uniq -c

Erwartet:

     40 200

Rund zehn Requests pro Sekunde, alle durch. Ein Rate Limit hängt an einem Server. In tag08 gilt keine Default-Deny-Policy, deshalb setzt du accessPolicy ausdrücklich auf all-unauthenticated – sonst sperrt der neue Server alles, wie an Tag 6.

cat > ratelimit.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1beta3
kind: Server
metadata: {name: helper-http, namespace: tag08}
spec:
  podSelector: {matchLabels: {app: helper}}
  port: http
  proxyProtocol: HTTP/1
  accessPolicy: all-unauthenticated
---
apiVersion: policy.linkerd.io/v1alpha1
kind: HTTPLocalRateLimitPolicy
metadata: {name: helper-rl, namespace: tag08}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: helper-http}
  total:
    requestsPerSecond: 4
EOF
kubectl apply -f ratelimit.yaml
sleep 5
kubectl -n tag08 get httplocalratelimitpolicy helper-rl -o yaml | grep -A6 '^status'
kubectl -n tag08 exec deploy/burst -c curl -- sh -c 'for i in $(seq 40); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; done' | sort | uniq -c
kubectl -n tag08 logs deploy/last -c last --since=10s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet (gekürzt, Zahlen schwanken):

    reason: Accepted
    status: "True"
    type: Accepted
     18 200
     22 429
     15 /get 200
      6 /get 429

burst wird gebremst – aber last über web auch. total ist ein gemeinsamer Topf: Wer zuerst kommt, verbraucht ihn. Und er gilt pro Pod: Zwei helper-Pods lassen zusammen rund 8 Requests pro Sekunde durch. Die Antwort kommt vom Proxy, ohne Body:

kubectl -n tag08 exec deploy/burst -c curl -- sh -c 'for i in $(seq 15); do
  curl -si http://helper/get; done' | grep -m1 -A2 '^HTTP/1.1 429'
kubectl -n tag08 logs deploy/helper -c linkerd-proxy --since=1m \
  | grep -o 'total rate limit exceeded: [0-9]*rps' | tail -1

Erwartet:

HTTP/1.1 429 Too Many Requests
date: Thu, 19 Nov 2026 19:43:50 GMT
content-length: 0
total rate limit exceeded: 4rps

Fortschritt speichern? Kostenlos registrieren

Drill 6: Fair pro Identität

Jeder Client soll höchstens 1 Request pro Sekunde und Pod bekommen, web als wichtiger Kunde 4 – per overrides auf seinen ServiceAccount. Erster Versuch mit total: 6:

sed -i 's/requestsPerSecond: 4$/requestsPerSecond: 6/' ratelimit.yaml
cat >> ratelimit.yaml <<'EOF'
  identity:
    requestsPerSecond: 1
  overrides:
  - requestsPerSecond: 4
    clientRefs:
    - {kind: ServiceAccount, name: web}
EOF
kubectl apply -f ratelimit.yaml
sleep 70
kubectl -n tag08 exec deploy/burst -c curl -- sh -c 'for i in $(seq 40); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; done' | sort | uniq -c
kubectl -n tag08 logs deploy/last -c last --since=6s | awk '{print $2, $3}' \
  | sort | uniq -c
for p in $(kubectl -n tag08 get pod -l app=helper -o name); do
  linkerd diagnostics proxy-metrics -n tag08 $p | grep '^inbound_http_local_ratelimit' \
    | grep -oE 'ratelimit_scope="[^"]*"|client_id="[a-z]+|tls="no_identity"|\} [0-9]+' \
    | paste - - -
done

Erwartet (gekürzt, Zahlen schwanken):

      6 200
     34 429
     10 /get 200
      5 /get 429
ratelimit_scope="total"     client_id="web    } 11
ratelimit_scope="identity"  client_id="burst  } 18
ratelimit_scope="total"     client_id="burst  } 35
...

burst hängt jetzt am Identitäts-Limit. web scheitert trotzdem – im Scope total. Auch abgelehnte Requests von burst verbrauchen den gemeinsamen Topf. total ist darum eine Notbremse für den Pod, kein Werkzeug für Fairness: deutlich höher setzen.

cat > ratelimit-rl.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: HTTPLocalRateLimitPolicy
metadata: {name: helper-rl, namespace: tag08}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: helper-http}
  total:
    requestsPerSecond: 20
  identity:
    requestsPerSecond: 1
  overrides:
  - requestsPerSecond: 4
    clientRefs:
    - {kind: ServiceAccount, name: web}
EOF
kubectl apply -f ratelimit-rl.yaml
sleep 10
kubectl -n tag08 exec deploy/burst -c curl -- sh -c 'for i in $(seq 40); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; done' | sort | uniq -c
kubectl -n tag08 logs deploy/last -c last --since=6s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag08 get httplocalratelimitpolicy

Erwartet (Zahlen schwanken):

httplocalratelimitpolicy.policy.linkerd.io/helper-rl configured
      4 200
     36 429
     15 /get 200
NAME        TARGET_KIND   TARGET_NAME   TOTAL_RPS   IDENTITY_RPS
helper-rl   Server        helper-http   20          1

burst bleibt gebremst, last läuft ungestört weiter.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Wer bekommt wie viel?

Beide Clients mit gleichem Tempo, rund 5 Requests pro Sekunde:

kubectl -n tag08 exec deploy/web -c web -- sh -c 'for i in $(seq 30); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; sleep 0.2
  done' | sort | uniq -c
kubectl -n tag08 exec deploy/burst -c curl -- sh -c 'for i in $(seq 30); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; sleep 0.2
  done' | sort | uniq -c

Erwartet (Zahlen schwanken):

     27 200
      3 429
     13 200
     17 429

web darf 4 pro Pod; die paar 429 entstehen, weil der Lastgenerator gleichzeitig über web läuft. burst bekommt nur einen Request pro Sekunde und Pod. Die Zuordnung läuft über die mTLS-Identität. Ein Client ohne Proxy hat keine – er fällt trotzdem unter identity, in der Metrik mit tls="no_identity" statt client_id. Im Labor teilten sich zwei solche Clients ein Limit.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig die Failure-Accrual-Annotationen des Service helper. Zeitziel: 20 s
  2. Zeig, wie viele Endpunkte der Proxy von web gerade aussperrt. Zeitziel: 30 s
  3. Zeig die Rate-Limit-Policy mit Ziel und Limits. Zeitziel: 15 s
  4. Zeig, welche Clients in welchem Scope am Limit gescheitert sind. Zeitziel: 45 s

Lösung

kubectl -n tag08 describe service helper | grep -A4 Annotations
linkerd diagnostics proxy-metrics -n tag08 deploy/web \
  | grep '^outbound_http_balancer_endpoints.*pending' | grep -oE '[0-9]+$'
kubectl -n tag08 get httplocalratelimitpolicy
linkerd diagnostics proxy-metrics -n tag08 deploy/helper \
  | grep '^inbound_http_local_ratelimit' \
  | grep -oE 'ratelimit_scope="[^"]*"|client_id="[a-z]+|tls="no_identity"|\} [0-9]+' \
  | paste - - -

Erwartet (gekürzt):

Annotations:   balancer.linkerd.io/failure-accrual: consecutive
               balancer.linkerd.io/failure-accrual-consecutive-max-failures: 3
               balancer.linkerd.io/failure-accrual-consecutive-max-penalty: 1m
               balancer.linkerd.io/failure-accrual-consecutive-min-penalty: 10s
0
NAME        TARGET_KIND   TARGET_NAME   TOTAL_RPS   IDENTITY_RPS
helper-rl   Server        helper-http   20          1
ratelimit_scope="total"     client_id="burst  } 37
ratelimit_scope="identity"  client_id="burst  } 73
ratelimit_scope="identity"  client_id="web    } 33
...

Der kaputte Pod ist seit Drill 5 weg, darum 0 gesperrte Endpunkte.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl -n tag08 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet: nur /get 200.

kubectl -n tag08 exec deploy/burst -c curl -- sh -c 'for i in 1 2 3 4; do
  curl -s -o /dev/null -w "%{http_code} " http://helper/get; done; echo'

Erwartet: nach ein, zwei 200 auch 429, etwa 200 200 429 429.

Challenge

Hol den kaputten Pod zurück. Er soll höchstens alle 10 Sekunden einen Probe-Request bekommen. Weise es im Log des Lastgenerators nach.

Hinweis: max-penalty muss größer als min-penalty sein.

Lösung

kubectl apply -f kaputt.yaml
kubectl -n tag08 rollout status deploy/helper-kaputt --timeout=120s
kubectl -n tag08 annotate service helper --overwrite \
  balancer.linkerd.io/failure-accrual-consecutive-min-penalty=5s \
  balancer.linkerd.io/failure-accrual-consecutive-max-penalty=10s
sleep 75
kubectl -n tag08 logs deploy/last -c last --since=60s | awk '$3==500 {print $1}' \
  | tr '\n' ' '; echo

Erwartet (Zeiten schwanken):

19:50:24 19:50:34 19:50:45 19:50:56 19:51:06 19:51:19

Ein Fehler alle gut 10 Sekunden – die Pause wächst nicht mehr über die Grenze. Kürzere Penalties holen einen reparierten Pod schneller zurück und kosten mehr Probe-Fehler.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

kubectl delete namespace tag08

Interview-Notiz

  • Wie macht Linkerd Circuit Breaking? Failure Accrual im Client-Proxy, pro Endpunkt; nach N Fehlern in Folge Sperre mit exponentieller Pause, Rückkehr über echte Probe-Requests. Konfiguration per Annotation am Service.
  • Warum reicht die Readiness-Probe nicht? Sie prüft einen Pfad, nicht das Verhalten bei echten Requests; ein Pod kann bereit und trotzdem kaputt sein.
  • Wo wirkt das Rate Limit? Im Server-Proxy jedes Pods – lokal, nicht clusterweit. identity sorgt für Fairness, total ist die Notbremse.

Enterprise-Notiz

  • Failure Accrual und Retries zusammen planen: Retries überbrücken die Probe-Fehler, Failure Accrual verhindert, dass Retries einen kaputten Pod weiter füttern.
  • Rate Limits pro Pod: Beim Skalieren steigt das Gesamtlimit mit. Für harte globale Grenzen (API-Kontingente) braucht es ein zentrales Rate Limit am Gateway.
  • Clients ohne Proxy haben keine Identität und teilen sich im Scope identity einen Topf – einer kann die anderen aushungern.
  • Alarm auf inbound_http_local_ratelimit_total pro client_id: zeigt, wer gedrosselt wird, bevor sich ein Team über 429 beschwert.
  • Bei unified zählt 429 als Fehler: Ein Rate Limit kann dann gesunde Pods aus dem Load Balancer werfen. Beides zusammen testen.