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: consecutiveplus...-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:
HTTPLocalRateLimitPolicyan einemServer, mittotal,identityundoverrides. 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 -cErwartet (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/webErwartet (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/webErwartet (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 -5Erwartet (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 -cErwartet:
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 -cErwartet (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 -1Erwartet:
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 - - -
doneErwartet (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 httplocalratelimitpolicyErwartet (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 -cErwartet (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
- Zeig die Failure-Accrual-Annotationen des Service
helper. Zeitziel: 20 s - Zeig, wie viele Endpunkte der Proxy von
webgerade aussperrt. Zeitziel: 30 s - Zeig die Rate-Limit-Policy mit Ziel und Limits. Zeitziel: 15 s
- 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 -cErwartet: 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' ' '; echoErwartet (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 tag08Interview-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.
identitysorgt für Fairness,totalist 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
identityeinen Topf – einer kann die anderen aushungern. - Alarm auf
inbound_http_local_ratelimit_totalproclient_id: zeigt, wer gedrosselt wird, bevor sich ein Team über 429 beschwert. - Bei
unifiedzählt 429 als Fehler: Ein Rate Limit kann dann gesunde Pods aus dem Load Balancer werfen. Beides zusammen testen.