Tag 7: Retries und Timeouts
Ziel:
/flakygelingt mit Retries zu fast 100 Prozent,/slowbricht nach einer Sekunde ab – und du weißt, was Retries kosten und wann sie gefährlich sind. · Dauer: ca. 60 min · Voraussetzung: Tag 6
Briefing
- Retries und Timeouts macht der Client-Proxy (outbound). Die App merkt nichts.
- Konfiguriert wird über eine Gateway-API-HTTPRoute
mit dem Service als
parentRefund Annotationen:retry.linkerd.io/http,retry.linkerd.io/limit,retry.linkerd.io/timeout,timeout.linkerd.io/request(oderresponse,idle). - Hängt eine Route an einem Service, gilt für ihn nur noch, was eine Route trifft.
- Ein Retry ist ein zusätzlicher Request: mehr Last, und bei
POSTwomöglich eine doppelte Bestellung.
last ──> web ──(outbound-Proxy: Route, Retry, Timeout)──> helper (2 Pods)
/unstable Retry bei 5xx, max. 2 Retries
/delay Timeout 1 s
Drill 1: Eine Kopie für Experimente
notes bleibt unangetastet. In tag07 läuft
eine kleine Kopie von web, helper und
last mit eigenen ServiceAccounts. Der Lastgenerator ruft
hier zweimal /flaky und einmal /slow auf.
mkdir -p ~/linkerd/tag07 && cd ~/linkerd/tag07
kubectl create namespace tag07
kubectl annotate namespace tag07 linkerd.io/inject=enabled
for a in web helper last; do kubectl -n tag07 create serviceaccount $a; done
cat > app.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata: {name: web-conf, namespace: tag07}
data:
default.conf: |
server {
listen 8080;
location /flaky {
proxy_pass http://helper.tag07.svc.cluster.local/unstable?failure_rate=0.3;
}
location /slow {
proxy_pass http://helper.tag07.svc.cluster.local/delay/2;
}
}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag07}
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: tag07}
spec:
selector: {app: web}
ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: helper, namespace: tag07}
spec:
replicas: 2
selector: {matchLabels: {app: helper}}
template:
metadata: {labels: {app: helper}}
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: tag07}
spec:
selector: {app: helper}
ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last, namespace: tag07}
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 /flaky /flaky /slow; 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 tag07 rollout status deploy/helper --timeout=180s
kubectl -n tag07 get podsErwartet (gekürzt):
NAME READY STATUS RESTARTS AGE
helper-79d57fbbbb-cxfnr 2/2 Running 0 13s
helper-79d57fbbbb-wknd2 2/2 Running 0 14s
last-84d85f57b9-rbfjf 2/2 Running 0 14s
web-7d94ccc84d-bgq62 2/2 Running 0 14s
Für die Messung pro Route gibt es
linkerd viz stat-outbound. Es fragt Prometheus von
deinem Rechner aus – mit dem Prometheus aus
monitoring also über einen Port-Forward, den du heute offen
lässt:
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
>/dev/null 2>&1 &
PROM=--prometheusURL=http://localhost:9090
sleep 60
kubectl -n tag07 logs deploy/last -c last --since=60s | awk '{print $2, $3}' \
| sort | uniq -c
linkerd viz stat-outbound -n tag07 deploy/web $PROMErwartet (gekürzt, Zahlen schwanken):
20 /flaky 200
14 /flaky 500
17 /slow 200
NAME SERVICE ROUTE TYPE BACKEND SUCCESS RPS ... TIMEOUTS RETRIES
web helper:80 [default] 76.00% 0.83 ... 0.00% 0.00%
└─────────────► helper:80 76.00% 0.83 ... 0.00%
Ohne $PROM versucht die CLI, den Service-Namen aus der
viz-Konfiguration direkt aufzulösen, und scheitert mit
lookup kps-kube-prometheus-stack-prometheus... server misbehaving.
[default] ist die Route, die Linkerd ohne eigene HTTPRoute
annimmt.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Retries für /unstable
cat > route-retry.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: helper-unstable
namespace: tag07
annotations:
retry.linkerd.io/http: 5xx
retry.linkerd.io/limit: "2"
spec:
parentRefs:
- {group: core, kind: Service, name: helper, port: 80}
rules:
- matches:
- path: {type: PathPrefix, value: /unstable}
EOF
kubectl apply -f route-retry.yaml
kubectl -n tag07 get httproute helper-unstable -o yaml | grep -E 'controllerName|reason'
sleep 70
kubectl -n tag07 logs deploy/last -c last --since=60s | awk '{print $2, $3}' \
| sort | uniq -c
linkerd viz stat-outbound -n tag07 deploy/web $PROMErwartet (gekürzt, Zahlen schwanken):
reason: Accepted
reason: ResolvedRefs
controllerName: linkerd.io/policy-controller
83 /flaky 200
1 /flaky 500
42 /slow 404
ROUTE TYPE BACKEND SUCCESS RPS ... TIMEOUTS RETRIES
helper-unstable HTTPRoute 100.00% 1.35 ... 0.00% 27.03%
└────────────────────────► helper:80 72.32% 1.87 ... 0.00%
Achtung: Auch Cilium liest HTTPRoutes und legt für eine Route mit Service als
parentRefeine EndpointSlicecilium-gateway-<service>mit der Platzhalteradresse192.192.192.192:9999an. Sie gehört zu keinem echten Service und stört Linkerd nicht, bleibt aber nach dem Löschen der Route liegen. Den Status der Route setzt nur Linkerd. Anzeigen:kubectl get endpointslices -A | grep cilium-gateway.
/flaky springt von rund 70 auf fast 100 Prozent: Drei
Versuche scheitern nur mit 0,3 × 0,3 × 0,3 ≈ 3 Prozent. Die Zeile der
Route zeigt, was web erlebt, die Zeile darunter, was
helper wirklich liefert – unverändert 72 Prozent. Und
/slow?
Fortschritt speichern? Kostenlos registrieren
Drill 3: Die Falle mit den übrigen Pfaden
/slow liefert plötzlich 404, schneller als
vorher. Sobald eine HTTPRoute am Service hängt, ersetzt sie die
Standardroute. Pfade, die keine Regel trifft, beantwortet der
Client-Proxy selbst mit 404. Also eine Route für den Rest:
cat > route-rest.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: helper-rest, namespace: tag07}
spec:
parentRefs:
- {group: core, kind: Service, name: helper, port: 80}
rules:
- matches:
- path: {type: PathPrefix, value: /}
EOF
kubectl apply -f route-rest.yaml
sleep 70
kubectl -n tag07 logs deploy/last -c last --since=60s | awk '{print $2, $3}' \
| sort | uniq -c
linkerd viz stat-outbound -n tag07 deploy/web $PROM | grep -v '└'Erwartet (gekürzt):
36 /flaky 200
17 /slow 200
ROUTE TYPE BACKEND SUCCESS RPS ... TIMEOUTS RETRIES
helper-unstable HTTPRoute 100.00% 0.55 ... 0.00% 26.67%
helper-rest HTTPRoute 100.00% 0.30 ... 0.00% 0.00%
Die Gateway API wählt die spezifischste Regel: /unstable
gewinnt gegen /.
Achtung: In
noteshätte derselbe Fehler alle Pfade außer dem einen lahmgelegt. Wer die erste Route an einen Service hängt, legt immer gleich die für/mit an.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Der Preis
In Drill 2 stand es schon: web schickt 1,35 Requests pro
Sekunde, helper bekommt 1,87. Retries sind Last. Wie
schlimm es wird, wenn helper ganz ausfällt, zeigt ein
Aufruf direkt aus last – dessen Proxy kennt dieselbe
Route:
kubectl -n tag07 exec deploy/last -c last -- sh -c 'for i in $(seq 20); do
curl -s -o /dev/null -w "%{http_code}\n" "http://helper/unstable?failure_rate=1"
done' | sort | uniq -c
linkerd diagnostics proxy-metrics -n tag07 deploy/last \
| grep -E '^outbound_http_route_retry_(requests|limit_exceeded)_total' \
| sed -E 's/\{.*\}//'Erwartet:
20 500
outbound_http_route_retry_limit_exceeded_total 20
outbound_http_route_retry_requests_total 40
last hat helper vorher nie direkt
aufgerufen, die Zähler gehören also nur zu diesem Test. 20 Requests, 40
Retries: helper sieht die dreifache Last – genau dann, wenn
er ohnehin am Boden liegt. Bei Ketten multipliziert sich das: Drei
Dienste mit je zwei Retries machen aus einem Request bis zu 27.
Früher begrenzte ein Retry-Budget im ServiceProfile
das (retryRatio: 0.2 hieß: höchstens 20 Prozent zusätzliche
Last). Die Annotationen an HTTPRoutes kennen kein Budget, nur
limit. Halte es klein und verlass dich gegen Dauerfehler
auf Circuit Breaking (Tag 8). Beides mischen geht nicht: Gibt es für
einen Service ein ServiceProfile, ignoriert der Proxy die
Annotationen.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Timeouts
/slow hängt zwei Sekunden. Dein Ziel: nach einer Sekunde
aufgeben.
cat > route-delay.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: helper-delay
namespace: tag07
annotations:
timeout.linkerd.io/request: 1s
spec:
parentRefs:
- {group: core, kind: Service, name: helper, port: 80}
rules:
- matches:
- path: {type: PathPrefix, value: /delay}
EOF
kubectl apply -f route-delay.yaml
sleep 5
kubectl -n tag07 exec deploy/last -c last -- \
curl -s -o /dev/null -w '%{http_code} %{time_total}s\n' http://web/slow
kubectl -n tag07 logs deploy/web -c linkerd-proxy --since=30s \
| grep -o 'route HTTPRoute[^:]*: [^,]*request timeout: 1s' | tail -1Erwartet (gekürzt):
504 1.019408s
route HTTPRoute.tag07.helper-delay: backend Service.tag07.helper:80: ...
Der Proxy von web bricht nach einer Sekunde ab und
antwortet 504 Gateway Timeout, nginx reicht das durch. Nach
einer Minute:
sleep 60
kubectl -n tag07 logs deploy/last -c last --since=60s | awk '{print $2, $3}' \
| sort | uniq -c
linkerd viz stat-outbound -n tag07 deploy/web $PROM | grep helper-delayErwartet (gekürzt):
49 /flaky 200
1 /flaky 500
24 /slow 504
helper-delay HTTPRoute 0.00% 0.42 ... 100.00% 0.00%
Die Spalte TIMEOUTS zeigt 100 Prozent. Die Latenzspalten
in stat-outbound sind bei Timeouts wenig aussagekräftig –
sie werden aus groben Histogramm-Eimern geschätzt. Ein Timeout wird
nicht wiederholt. Wer das will, setzt
retry.linkerd.io/timeout (Zeit pro Versuch) zusammen mit
retry.linkerd.io/http.
Fortschritt speichern? Kostenlos registrieren
Drill 6: POST ist nicht idempotent
Die Route helper-unstable matcht jede Methode. Was
passiert mit einer Bestellung?
timeout 15 linkerd viz tap -n tag07 deploy/helper --method POST > tap-post.txt &
sleep 5
kubectl -n tag07 exec deploy/last -c last -- curl -s -o /dev/null -w '%{http_code}\n' \
-X POST -d 'bestellung=1' 'http://helper/unstable?failure_rate=1'
sleep 12
grep -c '^req' tap-post.txtErwartet:
500
3
Ein POST vom Client, drei bei helper. Hätte der erste
Versuch die Bestellung gespeichert und erst danach mit 500 geantwortet,
gäbe es sie jetzt dreimal. Linkerd prüft die Methode nicht – nur Bodys
über 64 KiB wiederholt es nie. Also nur GET:
sed -i 's| - path: {type: PathPrefix, value: /unstable}|&\n method: GET|' \
route-retry.yaml
tail -3 route-retry.yaml
kubectl apply -f route-retry.yaml
sleep 5
timeout 15 linkerd viz tap -n tag07 deploy/helper --method POST > tap-post.txt &
sleep 5
kubectl -n tag07 exec deploy/last -c last -- curl -s -o /dev/null -w '%{http_code}\n' \
-X POST -d 'bestellung=1' 'http://helper/unstable?failure_rate=1'
sleep 12
grep -c '^req' tap-post.txtErwartet:
- matches:
- path: {type: PathPrefix, value: /unstable}
method: GET
httproute.gateway.networking.k8s.io/helper-unstable configured
500
1
Der POST fällt jetzt auf helper-rest ohne Retries.
GET, HEAD, PUT und
DELETE sind laut HTTP idempotent – ob deine App das auch so
umsetzt, prüfst du, bevor du Retries einschaltest.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Retries in Prometheus
Für Dashboards und Alarme zählst du direkt:
Q='sum by (route_name) (rate(outbound_http_route_retry_requests_total{
namespace="tag07", deployment="web"}[2m]))'
curl -s localhost:9090/api/v1/query --data-urlencode "query=$Q" \
| jq -r '.data.result[] | .metric.route_name + " " + .value[1]'
Q='sum by (route_name, http_status) (rate(outbound_http_route_request_statuses_total{
namespace="tag07", deployment="web"}[2m]))'
curl -s localhost:9090/api/v1/query --data-urlencode "query=$Q" \
| jq -r '.data.result[] | .metric.route_name + " " + .metric.http_status
+ " " + .value[1]' | grep -v ' 0$'Erwartet (gekürzt, Zahlen schwanken):
helper-unstable 0.23636363636363636
helper-unstable 200 0.7999999999999999
helper-delay 0.3818181818181818
helper-delay 200 0.027166000000000003
Abgebrochene Requests haben keinen http_status – die
Lücke bei helper-delay sind die Timeouts. Ein steigendes
Verhältnis von Retries zu Requests ist ein früher Alarm: Der Dienst
dahinter wird schlechter, auch wenn die Nutzer noch nichts merken.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig alle HTTPRoutes in
tag07mit ihren Linkerd-Annotationen. Zeitziel: 30 s - Erhöhe das Retry-Limit von
helper-unstableauf 3, ohne die Datei zu ändern. Zeitziel: 30 s - Zeig, wie viele Retries der Proxy von
webbisher gesendet hat. Zeitziel: 30 s - Zeig, ob der Policy-Controller alle Routen akzeptiert hat. Zeitziel: 45 s
Lösung
kubectl -n tag07 describe httproute | grep -E '^Name:|linkerd.io/'
kubectl -n tag07 annotate httproute helper-unstable retry.linkerd.io/limit=3 --overwrite
linkerd diagnostics proxy-metrics -n tag07 deploy/web \
| grep '^outbound_http_route_retry_requests_total' | grep -oE '[0-9]+$'
kubectl -n tag07 get httproute \
-o custom-columns=NAME:.metadata.name,STATUS:.status.parents[0].conditions[0].reasonErwartet (gekürzt):
Name: helper-delay
Annotations: timeout.linkerd.io/request: 1s
...
Name: helper-unstable
Annotations: retry.linkerd.io/http: 5xx
retry.linkerd.io/limit: 2
httproute.gateway.networking.k8s.io/helper-unstable annotated
145
NAME STATUS
helper-delay Accepted
helper-rest Accepted
helper-unstable Accepted
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
kubectl -n tag07 logs deploy/last -c last --since=60s | awk '{print $2, $3}' \
| sort | uniq -cErwartet: /flaky fast nur
200, /slow nur 504.
48 /flaky 200
25 /slow 504
linkerd viz stat-outbound -n tag07 deploy/web $PROM | grep -c HTTPRouteErwartet: 2 –
helper-unstable und helper-delay. Über
helper-rest läuft vom Lastgenerator nichts mehr, seit
/delay eine eigene Route hat.
Challenge
Stell den Timeout für /delay auf drei Sekunden um –
diesmal über das Feld der Gateway API statt per Annotation – und finde
heraus, was gilt, wenn beides gesetzt ist.
Hinweis: Das Feld heißt
timeouts.request und sitzt in der Regel
(rules[]).
Lösung
kubectl -n tag07 annotate httproute helper-delay timeout.linkerd.io/request-
kubectl -n tag07 patch httproute helper-delay --type=json \
-p '[{"op":"add","path":"/spec/rules/0/timeouts","value":{"request":"3s"}}]'
sleep 5
kubectl -n tag07 exec deploy/last -c last -- \
curl -s -o /dev/null -w '%{http_code} %{time_total}s\n' http://web/slow
kubectl -n tag07 annotate httproute helper-delay timeout.linkerd.io/request=1s
sleep 5
kubectl -n tag07 exec deploy/last -c last -- \
curl -s -o /dev/null -w '%{http_code} %{time_total}s\n' http://web/slowErwartet:
httproute.gateway.networking.k8s.io/helper-delay annotated
httproute.gateway.networking.k8s.io/helper-delay patched
200 2.026916s
httproute.gateway.networking.k8s.io/helper-delay annotated
504 1.039460s
Mit 3 s kommt /slow wieder durch. Sind Feld und
Annotation gesetzt, gewinnt die Annotation. Für response-
und idle-Timeouts gibt es nur die Annotationen.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
kill %1
kubectl delete namespace tag07
kubectl get endpointslices -A | grep cilium-gatewayErwartet: keine Zeile aus tag07 mehr –
mit dem Namespace verschwindet auch die EndpointSlice von Cilium.
Löschst du nur eine Route, entfernst du sie selbst:
kubectl -n <ns> delete endpointslice cilium-gateway-<service>.
Interview-Notiz
- Wo laufen Retries in Linkerd? Im Client-Proxy, konfiguriert
per HTTPRoute oder Service-Annotation (
retry.linkerd.io/*). Die App merkt nichts. - Warum nicht überall Retries? Sie vervielfachen die Last genau im Fehlerfall und sind bei nicht-idempotenten Methoden wie POST gefährlich.
- Timeout oder Retry zuerst? Beides: Timeout begrenzt die
Wartezeit des Nutzers,
retry.linkerd.io/timeoutmacht langsame Versuche wiederholbar.
Enterprise-Notiz
- Retry-Regeln gehören dem Team, das den Dienst betreibt – die Route liegt im Namespace des Service und wirkt für alle Clients im Mesh.
- Pro Kette nur eine Stelle mit Retries, sonst multiplizieren sie sich.
- ServiceProfiles aus älteren Installationen vor dem Umstieg entfernen, sonst greifen die Annotationen nicht.
- Alarm auf das Verhältnis von
outbound_http_route_retry_requests_totalzu allen Requests, nicht nur auf die Erfolgsquote, die Retries schönrechnen. - Timeouts von außen nach innen kürzer werden lassen: Ingress > web > Backend.