Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 17: Was das Mesh kostet

Ziel: Du misst selbst, wie viel Latenz, CPU und Speicher der Proxy kostet, und steuerst seine Ressourcen per Annotation. · Dauer: ca. 90 min · Voraussetzung: Tag 4

Briefing

  • Jeder Request im Mesh durchläuft zwei Proxys: den des Clients und den des Servers. Das kostet Latenz und CPU auf beiden Seiten.
  • Glaub keinem Benchmark, auch keinem aus diesem Buch: gleiche Anordnung zweimal aufbauen, einmal ohne, einmal mit Proxy, mit fester Rate messen.
  • Labor-Messungen schwanken. Mehrere Läufe, Median nehmen, Spanne angeben.
  • Ressourcen des Proxys setzt du mit config.linkerd.io/proxy-cpu-request und Verwandten. Ohne Angabe ist der Proxy BestEffort.
 worker1                              worker2
 last-ohne (fortio) ───────────────> server-ohne (go-httpbin)
 last-mit  (fortio) ─> proxy ═mTLS═> proxy ─> server-mit (go-httpbin)

Drill 1: Zwei gleiche Anordnungen

Der Namespace bleibt ohne Injection. Nur die beiden -mit-Deployments bekommen den Proxy per Pod-Annotation. nodeSelector hält Clients und Server auf festen Nodes, sonst vergleichst du am Ende Nodes statt Proxys.

mkdir -p ~/linkerd/tag17 && cd ~/linkerd/tag17
kubectl create namespace tag17
cat > app.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: server-ohne, namespace: tag17}
spec:
  replicas: 1
  selector: {matchLabels: {app: server-ohne}}
  template:
    metadata: {labels: {app: server-ohne}}
    spec:
      nodeSelector: {kubernetes.io/hostname: worker2}
      containers:
      - name: httpbin
        image: ghcr.io/mccutchen/go-httpbin:2.26.0
        ports: [{containerPort: 8080, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: server-mit, namespace: tag17}
spec:
  replicas: 1
  selector: {matchLabels: {app: server-mit}}
  template:
    metadata:
      labels: {app: server-mit}
      annotations: {linkerd.io/inject: enabled}
    spec:
      nodeSelector: {kubernetes.io/hostname: worker2}
      containers:
      - name: httpbin
        image: ghcr.io/mccutchen/go-httpbin:2.26.0
        ports: [{containerPort: 8080, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last-ohne, namespace: tag17}
spec:
  replicas: 1
  selector: {matchLabels: {app: last-ohne}}
  template:
    metadata: {labels: {app: last-ohne}}
    spec:
      nodeSelector: {kubernetes.io/hostname: worker1}
      containers:
      - name: fortio
        image: docker.io/fortio/fortio:1.69.5
        args: [server]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last-mit, namespace: tag17}
spec:
  replicas: 1
  selector: {matchLabels: {app: last-mit}}
  template:
    metadata:
      labels: {app: last-mit}
      annotations: {linkerd.io/inject: enabled}
    spec:
      nodeSelector: {kubernetes.io/hostname: worker1}
      containers:
      - name: fortio
        image: docker.io/fortio/fortio:1.69.5
        args: [server]
EOF
kubectl apply -f app.yaml
kubectl -n tag17 create service clusterip server-ohne --tcp=80:8080
kubectl -n tag17 create service clusterip server-mit --tcp=80:8080
kubectl -n tag17 rollout status deploy/last-mit --timeout=180s
kubectl -n tag17 rollout status deploy/server-mit --timeout=180s
kubectl -n tag17 get pods
kubectl -n tag17 get pods \
  -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName,QOS:.status.qosClass

Erwartet:

NAME                          READY   STATUS    RESTARTS   AGE
last-mit-5d49799bd4-sgk2q     2/2     Running   0          8s
last-ohne-6d98856885-pb5h4    1/1     Running   0          8s
server-mit-66ddd9d74d-fnzrn   2/2     Running   0          8s
server-ohne-fcfff95d7-5g6lh   1/1     Running   0          8s
NAME                          NODE      QOS
last-mit-5d49799bd4-sgk2q     worker1   BestEffort
last-ohne-6d98856885-pb5h4    worker1   BestEffort
server-mit-66ddd9d74d-fnzrn   worker2   BestEffort
server-ohne-fcfff95d7-5g6lh   worker2   BestEffort

fortio ist ein Lastgenerator mit fester Rate und Latenzverteilung, das Image gibt es für amd64 und arm64. fortio server hält den Pod nur am Leben, die Messung startest du per exec. Merk dir die Spalte QOS: Alle Pods, auch die Proxys, haben keine Requests.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ein Proxy im Leerlauf

sleep 40
kubectl -n tag17 top pod --containers
linkerd diagnostics proxy-metrics -n tag17 deploy/server-mit \
  | grep -E '^process_(resident_memory|threads)'
kubectl -n tag17 logs deploy/server-mit -c linkerd-proxy | grep runtime

Erwartet (gekürzt):

POD                           NAME            CPU(cores)   MEMORY(bytes)
last-mit-5d49799bd4-sgk2q     fortio          0m           4Mi
last-mit-5d49799bd4-sgk2q     linkerd-proxy   2m           3Mi
last-ohne-6d98856885-pb5h4    fortio          0m           4Mi
server-mit-66ddd9d74d-fnzrn   httpbin         0m           2Mi
server-mit-66ddd9d74d-fnzrn   linkerd-proxy   2m           3Mi
server-ohne-fcfff95d7-5g6lh   httpbin         0m           1Mi
process_resident_memory_bytes 22282240
process_threads 2
...  INFO ThreadId(01) linkerd2_proxy::rt: Using single-threaded proxy runtime

Zwei Zahlen für denselben Speicher: kubectl top zeigt das Working Set der Container-Cgroup (3 Mi), der Proxy selbst meldet seinen RSS (22 MB). Der Unterschied sind vor allem Seiten des Proxy-Binarys, die sich alle Proxys auf einem Node teilen. Für Limits und Eviction zählt das Working Set, für eine vorsichtige Planung nimm den RSS als Obergrenze. Und: Der Proxy arbeitet standardmäßig mit einem Worker-Thread.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Latenz bei 100 Requests pro Sekunde

Gleiche Last auf beide Anordnungen: 100 QPS, 60 s, 4 Verbindungen. Mit -json - schreibt fortio das Ergebnis als JSON nach stdout, Logs gehen nach stderr.

kubectl -n tag17 exec deploy/last-ohne -- fortio load -qps 100 -t 60s -c 4 \
  -p 50,90,99 -json - http://server-ohne/get 2>/dev/null > ohne-100.json
kubectl -n tag17 exec deploy/last-mit -- fortio load -qps 100 -t 60s -c 4 \
  -p 50,90,99 -json - http://server-mit/get 2>/dev/null > mit-100.json
for f in ohne-100.json mit-100.json; do
  jq -c '[(.ActualQPS|round),
  (.DurationHistogram.Percentiles[] | .Value*10000|round/10)]' $f
done
jq -c .RetCodes mit-100.json

Erwartet (QPS, p50, p90, p99 in ms; Zahlen schwanken):

[100,4.8,21.4,116]
[100,13.3,35.8,96.2]
{"200":6000}

Ohne Proxy liegt der Median bei rund 4 ms, mit Proxy bei rund 13 ms. Das p99 der Variante ohne Proxy ist hier sogar schlechter als mit. Ein einzelner Lauf sagt wenig. Ohne -json schreibt fortio eine Textausgabe nach stderr, mit mehreren # target-Blöcken (Sleep-Zeiten, Antwortzeiten, Verbindungsaufbau) – leicht zu verwechseln.

Fortschritt speichern? Kostenlos registrieren

Drill 4: 500 Requests pro Sekunde und CPU unter Last

Während der Messung schaust du nach 45 s auf die CPU. kubectl top mittelt über ein Fenster, deshalb nicht am Anfang des Laufs messen.

kubectl -n tag17 exec deploy/last-mit -- fortio load -qps 500 -t 60s -c 4 \
  -p 50,90,99 -json - http://server-mit/get 2>/dev/null > mit-500.json &
sleep 45; kubectl -n tag17 top pod --containers; wait
kubectl -n tag17 exec deploy/last-ohne -- fortio load -qps 500 -t 60s -c 4 \
  -p 50,90,99 -json - http://server-ohne/get 2>/dev/null > ohne-500.json
for f in ohne-500.json mit-500.json; do
  jq -c '[(.ActualQPS|round),
  (.DurationHistogram.Percentiles[] | .Value*10000|round/10)]' $f
done

Erwartet (gekürzt, Zahlen schwanken):

POD                           NAME            CPU(cores)   MEMORY(bytes)
last-mit-5d49799bd4-sgk2q     fortio          86m          11Mi
last-mit-5d49799bd4-sgk2q     linkerd-proxy   232m         3Mi
server-mit-66ddd9d74d-fnzrn   httpbin         204m         7Mi
server-mit-66ddd9d74d-fnzrn   linkerd-proxy   222m         3Mi
[500,3.2,10,36.9]
[286,10,26.2,73.7]

Die Variante mit Proxy schafft keine 500 QPS, sondern nur 286. fortio arbeitet mit 4 Verbindungen geschlossen: Jede schickt erst den nächsten Request, wenn die Antwort da ist. Bei rund 14 ms im Mittel sind das höchstens 4 / 0,014 s ≈ 285 Requests pro Sekunde. Jeder Proxy braucht dafür mindestens so viel CPU wie die App selbst, der Speicher bleibt bei 3 Mi.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Mehrere Läufe, Median, Schwankung

Die Worker teilen sich die CPU mit allem anderen im Labor (Cilium, Prometheus, die notes-App, andere Namespaces). Wiederhole Drill 3 und 4 deshalb dreimal und trag die Werte ein. So sah es im Labor aus (Median aus drei Läufen, in Klammern die Spanne):

100 QPS p50 (ms) p90 (ms) p99 (ms)
ohne Proxy 3,7 (3,6–3,9) 11,7 (11,2–12,2) 45 (45–56)
mit Proxy 13,3 (13,3–13,8) 34,3 (34,1–39,6) 95 (92–120)
500 QPS erreicht p50 (ms) p99 (ms)
ohne Proxy 500 3,3 (3,3–3,3) 36 (33–39)
mit Proxy 277 (271–297) 10,2 (9,8–10,5) 74 (66–76)

Rund +10 ms im Median pro Request durch zwei Proxys – deutlich mehr als die „unter einer Millisekunde“, die man oft liest. Das liegt nicht am Proxy allein, sondern daran, wie er hier läuft. Das klärst du in Drill 7.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Control Plane und Hochrechnung

kubectl top pod -n linkerd --containers
kubectl top pod -n linkerd --containers --no-headers \
  | awk '{c+=$3; m+=$4} END {print c"m", m"Mi"}'
kubectl top pod -n linkerd-viz --no-headers \
  | awk '{c+=$2; m+=$3} END {print c"m", m"Mi"}'
kubectl top pod -A --containers --no-headers \
  | awk '$3=="linkerd-proxy" {n++; c+=$4; m+=$5} END {print n, c"m", m"Mi"}'

Erwartet (gekürzt):

POD                                      NAME             CPU(cores)   MEMORY(bytes)
linkerd-destination-794fdcc84c-8nsx8     destination      5m           25Mi
linkerd-destination-794fdcc84c-8nsx8     linkerd-proxy    7m           8Mi
linkerd-destination-794fdcc84c-8nsx8     policy           2m           5Mi
linkerd-destination-794fdcc84c-8nsx8     sp-validator     1m           10Mi
linkerd-identity-7f569dc484-kng2s        identity         1m           11Mi
...
linkerd-proxy-injector-98fbd8b8c-gdvnj   proxy-injector   2m           21Mi
24m 86Mi
16m 85Mi
24 105m 79Mi

Die Control Plane braucht knapp 90 Mi, viz noch einmal so viel. 24 Proxys laufen im ganzen Cluster. Hochgerechnet auf 100 Pods mit den Messwerten aus Drill 2 und 4:

Posten je Proxy 100 Pods
CPU Leerlauf 2 m 0,2 CPU
Speicher (Working Set) 3 Mi 300 Mi
Speicher (RSS, Obergrenze) 22 MB 2,2 GB
CPU unter Last ~0,8 m je Request/s 1000 Req/s: ~1,6 CPU

Die letzte Zeile zählt doppelt, weil jeder Request durch zwei Proxys geht. Die Control Plane wächst nicht pro Pod, sondern mit der Zahl der Endpunkte und Watches.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Proxy-Ressourcen per Annotation

Die Worker sind ausgelastet, und alle Pods sind BestEffort: Unter CPU-Druck bekommen sie nur Reste. Gib den beiden Proxys Requests:

R='{"spec":{"template":{"metadata":{"annotations":{
  "config.linkerd.io/proxy-cpu-request":"200m",
  "config.linkerd.io/proxy-memory-request":"20Mi"}}}}}'
for d in last-mit server-mit; do kubectl -n tag17 patch deploy $d -p "$R"; done
kubectl -n tag17 rollout status deploy/last-mit --timeout=120s
kubectl -n tag17 rollout status deploy/server-mit --timeout=120s
sleep 30
kubectl -n tag17 get pod -l app=server-mit -o \
  jsonpath='{.items[0].spec.initContainers[?(@.name=="linkerd-proxy")].resources}{"\n"}'
kubectl -n tag17 get pods -o custom-columns=NAME:.metadata.name,QOS:.status.qosClass

Erwartet:

{"requests":{"cpu":"200m","memory":"20Mi"}}
NAME                          QOS
last-mit-6b7695dc48-dth4k     Burstable
last-ohne-6d98856885-pb5h4    BestEffort
server-mit-76bc45d6c8-h6jd5   Burstable
server-ohne-fcfff95d7-5g6lh   BestEffort

Das sleep 30 ist nötig: Direkt nach dem Rollout liefert items[0] oft noch den alten, terminierenden Pod. Jetzt dieselben Messungen:

kubectl -n tag17 exec deploy/last-mit -- fortio load -qps 100 -t 60s -c 4 \
  -p 50,90,99 -json - http://server-mit/get 2>/dev/null > mit-100-req.json
kubectl -n tag17 exec deploy/last-mit -- fortio load -qps 500 -t 60s -c 4 \
  -p 50,90,99 -json - http://server-mit/get 2>/dev/null > mit-500-req.json
for f in mit-100-req.json mit-500-req.json; do
  jq -c '[(.ActualQPS|round),
  (.DurationHistogram.Percentiles[] | .Value*10000|round/10)]' $f
done

Erwartet (Zahlen schwanken):

[100,8.6,14.8,31.7]
[486,7,13.5,24.7]

Im Labor über drei Läufe (Median, Spanne):

mit Requests erreicht p50 (ms) p99 (ms)
100 QPS 100 8,7 (8,5–8,7) 27 (27–38)
500 QPS 487 (481–499) 7,0 (6,7–7,0) 26 (25–26)

Der Aufschlag im Median halbiert sich auf rund +5 ms, das p99 fällt von 95 auf 27 ms, und 500 QPS gehen fast durch. Der Vergleich ist jetzt allerdings nicht mehr fair: Der Request hebt das CPU-Gewicht des ganzen Pods, auch fortio und httpbin profitieren. Die -ohne-Pods bleiben BestEffort. Lehre: Requests wirken hier stärker als der Proxy.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Limits und Worker-Threads

Ein CPU-Limit drosselt den Proxy hart. Der Server-Proxy brauchte im Labor bei 100 QPS rund 90 m (gemessen wie in Drill 4) – gib ihm 50 m:

L='{"spec":{"template":{"metadata":{"annotations":{
  "config.linkerd.io/proxy-cpu-request":"50m",
  "config.linkerd.io/proxy-cpu-limit":"50m"}}}}}'
kubectl -n tag17 patch deploy server-mit -p "$L"
kubectl -n tag17 rollout status deploy/server-mit --timeout=120s
sleep 30
kubectl -n tag17 exec deploy/last-mit -- fortio load -qps 100 -t 60s -c 4 \
  -p 50,90,99 -json - http://server-mit/get 2>/dev/null > mit-100-limit.json
jq -c '[(.ActualQPS|round),
  (.DurationHistogram.Percentiles[] | .Value*10000|round/10)]' mit-100-limit.json

Erwartet (Zahlen schwanken):

[59,91.6,106.7,196.5]

Median über 90 ms, nur noch 59 QPS. Ein zu knappes Limit ist teurer als jedes Mesh.

Das CPU-Limit steuert außerdem die Worker-Threads. Der Proxy-Injector rechnet das Limit in LINKERD2_PROXY_CORES_MAX um (aufgerundet), ohne Limit bleibt es bei einem Thread. Versuch zwei Kerne:

Z='{"spec":{"template":{"metadata":{"annotations":{
  "config.linkerd.io/proxy-cpu-request":null,
  "config.linkerd.io/proxy-cpu-limit":"2"}}}}}'
kubectl -n tag17 patch deploy server-mit -p "$Z"
sleep 20
kubectl -n tag17 get pods -l app=server-mit
kubectl -n tag17 get events --field-selector reason=FailedScheduling \
  -o custom-columns=MSG:.message --no-headers | tail -1
kubectl -n tag17 get pod -l app=server-mit --field-selector=status.phase=Pending -o \
  jsonpath='{.items[0].spec.initContainers[?(@.name=="linkerd-proxy")].resources}{"\n"}'

Erwartet (gekürzt):

NAME                          READY   STATUS    RESTARTS   AGE
server-mit-788b76dfcc-27tf7   0/2     Pending   0          21s
server-mit-7dcdd7dc98-lbfx5   2/2     Running   0          2m21s
0/3 nodes are available: 1 Insufficient cpu, 1 node(s) didn't match Pod's node ...
{"limits":{"cpu":"2"},"requests":{"cpu":"2","memory":"20Mi"}}

Ohne CPU-Request setzt Kubernetes den Request gleich dem Limit: 2 CPU, mehr als ein Worker hat. Der alte Pod läuft weiter, der Rollout hängt. Request und Limit getrennt:

F='{"spec":{"template":{"metadata":{"annotations":{
  "config.linkerd.io/proxy-cpu-request":"200m",
  "config.linkerd.io/proxy-cpu-limit":"2"}}}}}'
kubectl -n tag17 patch deploy server-mit -p "$F"
kubectl -n tag17 rollout status deploy/server-mit --timeout=120s
sleep 30
kubectl -n tag17 logs deploy/server-mit -c linkerd-proxy | grep runtime
P=$(kubectl -n tag17 get pod -l app=server-mit -o name)
kubectl -n tag17 get $P -o \
  jsonpath='{.spec.initContainers[?(@.name=="linkerd-proxy")].env}' \
  | jq -c '.[] | select(.name | test("CORES"))'

Erwartet (gekürzt):

...  INFO ThreadId(01) linkerd2_proxy::rt: Using multi-threaded proxy runtime cores=2
{"name":"LINKERD2_PROXY_CORES","value":"1"}
{"name":"LINKERD2_PROXY_CORES_MIN","value":"1"}
{"name":"LINKERD2_PROXY_CORES_MAX","value":"2"}

Das Log sagt cores=2, die Umgebung CORES=1 – kein Widerspruch. CORES_MAX kommt aus dem Limit, CORES_MIN aus dem Request (beide aufgerundet, mindestens 1). LINKERD2_PROXY_CORES ist die alte, feste Einstellung (im Chart als veraltet markiert), der Injector setzt sie gleich CORES_MIN. Der Proxy startet so viele Threads, wie CORES_MAX und die CPUs des Nodes zulassen. Gegengeprüft, jeweils mit Request 200m:

Limit CORES_MAX Log des Proxys
1500m 2 multi-threaded proxy runtime cores=2
500m 1 single-threaded proxy runtime
4 4 cores=2 – die Worker haben nur zwei vCPUs

Ein Request von 1500m hebt CORES und CORES_MIN auf 2.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig die QoS-Klasse aller Pods in tag17. Zeitziel: 30 s
  2. Zeig CPU und Speicher aller Proxys in notes. Zeitziel: 30 s
  3. Zeig, mit wie vielen Threads der Proxy von server-mit läuft. Zeitziel: 20 s
  4. Miss in 10 s mit 50 QPS nur das p99 von server-mit in ms. Zeitziel: 60 s

Lösung

kubectl -n tag17 get pods -o custom-columns=NAME:.metadata.name,QOS:.status.qosClass
kubectl top pod -n notes --containers | grep -E 'NAME|linkerd-proxy'
kubectl -n tag17 logs deploy/server-mit -c linkerd-proxy | grep runtime
kubectl -n tag17 exec deploy/last-mit -- fortio load -qps 50 -t 10s -p 99 \
  -json - http://server-mit/get 2>/dev/null \
  | jq '.DurationHistogram.Percentiles[0].Value*1000'

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl -n tag17 get pods

Erwartet: vier Pods Running, die -mit-Pods 2/2.

kubectl -n tag17 get pod -l app=server-mit -o jsonpath='{.items[0].status.qosClass}'

Erwartet: Burstable

kubectl -n tag17 logs deploy/server-mit -c linkerd-proxy | grep -c multi-threaded

Erwartet: 1

jq -c .RetCodes mit-500-req.json

Erwartet: nur "200", kein anderer Code.

Challenge

Gib auch dem Proxy von last-mit zwei Worker-Threads, ohne dass der Pod hängen bleibt, und miss dreimal 500 QPS. Bringt der zweite Thread etwas gegenüber Drill 7?

Hinweis: Wie in Drill 8 – Request und Limit getrennt setzen.

Lösung

F='{"spec":{"template":{"metadata":{"annotations":{
  "config.linkerd.io/proxy-cpu-request":"200m",
  "config.linkerd.io/proxy-cpu-limit":"2"}}}}}'
kubectl -n tag17 patch deploy last-mit -p "$F"
kubectl -n tag17 rollout status deploy/last-mit --timeout=120s
sleep 30
kubectl -n tag17 logs deploy/last-mit -c linkerd-proxy | grep runtime
for i in 1 2 3; do
  kubectl -n tag17 exec deploy/last-mit -- fortio load -qps 500 -t 60s -c 4 \
    -p 50,90,99 -json - http://server-mit/get 2>/dev/null > mit-500-2t-$i.json
done
for i in 1 2 3; do
  jq -c '[(.ActualQPS|round),
  (.DurationHistogram.Percentiles[] | .Value*10000|round/10)]' mit-500-2t-$i.json
done

Erwartet (gekürzt, Zahlen schwanken):

...  INFO ThreadId(01) linkerd2_proxy::rt: Using multi-threaded proxy runtime cores=2
[458,7.3,14.3,28]
[440,7.7,15,29.2]
[463,7.3,14.3,27.4]

Kein Gewinn, eher etwas schlechter als mit einem Thread (Drill 7: 487 QPS, p99 26 ms). Ein Thread schafft 500 QPS mit rund 0,4 CPU. Auf Workern mit 2 vCPU, die ohnehin ausgelastet sind, gibt es keinen freien Kern für einen zweiten Thread. Mehr Threads lohnen sich erst bei Proxys mit sehr hohem Durchsatz, etwa an Ingress oder Gateways.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

kubectl delete namespace tag17

Interview-Notiz

  • Was kostet ein Service Mesh? Zwei Proxy-Hops pro Request (Latenz, CPU auf beiden Seiten), Speicher pro Pod und eine Control Plane. Zahlen nur aus eigener Messung mit fester Rate und Vergleich ohne Proxy.
  • Warum ist der Linkerd-Proxy sparsam? Rust, kein Garbage Collector, im Leerlauf wenige MB Working Set; standardmäßig ein Worker-Thread, mehr über das CPU-Limit.
  • Warum Requests für den Proxy setzen? Ohne sie ist er BestEffort und verliert auf vollen Nodes zuerst – die Latenz steigt stark.

Enterprise-Notiz

  • Proxy-Requests clusterweit über die Helm-Werte proxy.resources.* setzen, abweichende Workloads per Annotation am Pod oder Namespace.
  • CPU-Limits für den Proxy sparsam oder gar nicht: Drosselung trifft jeden Request des Pods. Wenn Limit, dann großzügig und immer mit eigenem Request.
  • Kapazitätsplanung: Proxy-CPU wächst mit Requests pro Sekunde, nicht mit der Pod-Zahl. Gateways und Ingress mit hohem Durchsatz einzeln messen und Threads freigeben.
  • Lasttests in Produktion nachbilden: echte Payloads, HTTP/2 und gRPC verhalten sich anders als /get über HTTP/1.1, mTLS-Handshakes fallen bei kurzen Verbindungen stärker ins Gewicht.
  • Dashboards für Proxy-CPU und container_cpu_cfs_throttled_periods_total je Pod zeigen, wo ein Proxy gedrosselt wird.