Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: Retries und Timeouts

Ziel: /flaky gelingt mit Retries zu fast 100 Prozent, /slow bricht 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 parentRef und Annotationen: retry.linkerd.io/http, retry.linkerd.io/limit, retry.linkerd.io/timeout, timeout.linkerd.io/request (oder response, 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 POST womö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 pods

Erwartet (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 $PROM

Erwartet (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 $PROM

Erwartet (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 parentRef eine EndpointSlice cilium-gateway-<service> mit der Platzhalteradresse 192.192.192.192:9999 an. 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 notes hä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 -1

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

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

Erwartet:

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.txt

Erwartet:

  - 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

  1. Zeig alle HTTPRoutes in tag07 mit ihren Linkerd-Annotationen. Zeitziel: 30 s
  2. Erhöhe das Retry-Limit von helper-unstable auf 3, ohne die Datei zu ändern. Zeitziel: 30 s
  3. Zeig, wie viele Retries der Proxy von web bisher gesendet hat. Zeitziel: 30 s
  4. 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].reason

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

Erwartet: /flaky fast nur 200, /slow nur 504.

     48 /flaky 200
     25 /slow 504
linkerd viz stat-outbound -n tag07 deploy/web $PROM | grep -c HTTPRoute

Erwartet: 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/slow

Erwartet:

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-gateway

Erwartet: 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/timeout macht 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_total zu allen Requests, nicht nur auf die Erfolgsquote, die Retries schönrechnen.
  • Timeouts von außen nach innen kürzer werden lassen: Ingress > web > Backend.