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-requestund 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.qosClassErwartet:
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 runtimeErwartet (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.jsonErwartet (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
doneErwartet (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.qosClassErwartet:
{"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
doneErwartet (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.jsonErwartet (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
- Zeig die QoS-Klasse aller Pods in
tag17. Zeitziel: 30 s - Zeig CPU und Speicher aller Proxys in
notes. Zeitziel: 30 s - Zeig, mit wie vielen Threads der Proxy von
server-mitläuft. Zeitziel: 20 s - Miss in 10 s mit 50 QPS nur das p99 von
server-mitin 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 podsErwartet: 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-threadedErwartet: 1
jq -c .RetCodes mit-500-req.jsonErwartet: 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
doneErwartet (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 tag17Interview-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_totalje Pod zeigen, wo ein Proxy gedrosselt wird.