Tag 11: Observability
Ziel: Du siehst für jede Route Requests pro Sekunde, 5xx-Quote, p95-Latenz, Access Logs mit Routennamen, Traces und den Status jedes Gateways in Prometheus. · Dauer: ca. 120 min · Voraussetzung: Tag 10 (RKE2-Cluster)
Briefing
- Zwei Metrikquellen: der Controller
envoy-gateway(Port 19001,/metrics) und jeder Envoy-Proxy (Portmetrics19001,/stats/prometheus). - Envoy Gateway baut pro Route-Regel einen Envoy-Cluster mit dem Namen
httproute/<ns>/<name>/rule/<n>. Das Labelenvoy_cluster_nameist dein Routen-Schlüssel in PromQL. - Access Logs und Tracing stellst du im
EnvoyProxyunterspec.telemetryein, angehängt perinfrastructure.parametersRefam Gateway. - Den Gateway-API-Status (Programmed, Accepted) machst du mit kube-state-metrics (Custom Resource State) zur Metrik.
Envoy-Pods ──/stats/prometheus──┐
envoy-gateway ──/metrics────────┼──► Prometheus ◄── PodMonitor/ServiceMonitor
kube-state-metrics (CRS) ───────┘ │
Envoy-Pods ──OTLP gRPC 4317──► Jaeger └──► Regeln, Alerts, Grafana
Envoy-Pods ──stdout (JSON)──► kubectl logs / Loki
Achtung: Alle Drills laufen auf dem RKE2-Cluster aus Tag 9/10. Manifeste sind mit
kubeconform(CRDs Envoy Gateway v1.9.2, kube-prometheus-stack 92.2.0) undpromtoolgeprüft. Ausgaben sind nicht live erzeugt.
Drill 1: Rohmetriken ansehen
Bevor Prometheus ins Spiel kommt: Was liefern die beiden Endpunkte überhaupt?
export KUBECONFIG=~/.kube/rke2-lab.yaml
mkdir -p ~/gw-lab/tag11 && cd ~/gw-lab/tag11
kubectl -n envoy-gateway-system port-forward deploy/envoy-gateway 19001:19001 \
>/dev/null 2>&1 &
sleep 2
curl -s localhost:19001/metrics \
| grep -E '^(xds_snapshot_update_total|status_update_total)' | head -4
kill %1Erwartet (gekürzt, kann je nach Version abweichen):
status_update_total{kind="Gateway",status="success"} 6
status_update_total{kind="GatewayClass",status="success"} 2
status_update_total{kind="HTTPRoute",status="success"} 9
xds_snapshot_update_total{nodeID="envoy-infra-web-a97fc3bf-7c9b8d5f4-x2kqp",...} 14
Jetzt die Datenebene. Die Envoy-Pods von infra/web (seit
Tag 10 zwei Replikas) tragen die Owner-Labels:
SEL=gateway.envoyproxy.io/owning-gateway-namespace=infra
SEL+=,gateway.envoyproxy.io/owning-gateway-name=web
POD=$(kubectl -n envoy-gateway-system get pod -o name -l "$SEL" | head -1)
kubectl -n envoy-gateway-system port-forward "$POD" 19001:19001 >/dev/null 2>&1 &
sleep 2
for i in $(seq 20); do curl -s -o /dev/null http://shop.apps.lab.internal/; done
curl -s localhost:19001/stats/prometheus \
| grep -E '^envoy_cluster_upstream_rq_total\{envoy_cluster_name="httproute'
kill %1Erwartet (gekürzt, kann je nach Version abweichen):
envoy_cluster_upstream_rq_total{envoy_cluster_name="httproute/shop/shop/rule/0"} 11
Warum 11 statt 20? Der Service verteilt auf beide Envoy-Pods, du
siehst nur einen. Der Clustername kodiert Route und Regel – Regel 0 der
Route shop/shop ist eine Zeitreihe pro Pod, PromQL summiert
später.
Tipp: Solange nur ein Gateway läuft, reicht der Selector
app.kubernetes.io/component=proxy.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Schlanken Prometheus installieren
kube-prometheus-stack bringt Operator, Prometheus und
kube-state-metrics. Grafana kommt in Drill 8 dazu, Alertmanager und
Node-Exporter lassen wir im Lab weg.
Der Begleitcode liegt in ~/gw-lab/code/tag11. Der
wichtige Teil von kps-values.yaml:
prometheus:
prometheusSpec:
retention: 6h
scrapeInterval: 15s
# Monitore/Regeln aus allen Namespaces, ohne release-Label
serviceMonitorSelectorNilUsesHelmValues: false
podMonitorSelectorNilUsesHelmValues: false
ruleSelectorNilUsesHelmValues: falseOhne die drei ...NilUsesHelmValues: false sieht
Prometheus nur Monitore mit dem Label release: kps. Das ist
die häufigste Ursache für „Target fehlt”.
helm upgrade --install kps \
oci://ghcr.io/prometheus-community/charts/kube-prometheus-stack \
--version 92.2.0 -n monitoring --create-namespace \
-f ~/gw-lab/code/tag11/kps-values.yaml --wait
kubectl -n monitoring get podsErwartet (gekürzt, kann je nach Version abweichen):
NAME READY STATUS RESTARTS AGE
kps-kube-prometheus-stack-operator-6b9... 1/1 Running 0 60s
kps-kube-state-metrics-7d5c8... 1/1 Running 0 60s
prometheus-kps-kube-prometheus-stack-... 2/2 Running 0 45s
Fortschritt speichern? Kostenlos registrieren
Drill 3: PodMonitor und ServiceMonitor
monitors.yaml enthält zwei Objekte. Der PodMonitor für
die Datenebene:
apiVersion: monitoring.coreos.com/v1
kind: PodMonitor
metadata:
name: envoy-proxy
namespace: envoy-gateway-system
spec:
selector:
matchLabels:
app.kubernetes.io/name: envoy
app.kubernetes.io/component: proxy
namespaceSelector:
any: true
podMetricsEndpoints:
- {port: metrics, path: /stats/prometheus, interval: 15s}Dazu ein ServiceMonitor auf den Service envoy-gateway
(Label control-plane: envoy-gateway, Port
metrics, Pfad /metrics).
Warum PodMonitor für die Proxys? Envoy Gateway legt pro Gateway einen
LoadBalancer-Service an, aber ohne Metrik-Port. Die Pods tragen den Port
metrics dagegen immer.
kubectl apply -f ~/gw-lab/code/tag11/monitors.yaml
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090:9090 \
>/dev/null 2>&1 &
sleep 30
curl -s localhost:9090/api/v1/targets?state=active \
| jq -r '.data.activeTargets[] | [.scrapePool, .health] | @tsv' | grep envoyErwartet (gekürzt, kann je nach Version abweichen):
podMonitor/envoy-gateway-system/envoy-proxy/0 up
serviceMonitor/envoy-gateway-system/envoy-gateway/0 up
Den Port-Forward auf 9090 lässt du für die nächsten Drills laufen.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Last erzeugen und die drei Kernabfragen
Wir brauchen eine Route mit Fehlern. shop-broken zeigt
auf Port 9999 der shop-v2-Pods, dort lauscht niemand –
Envoy antwortet mit 503 (Flag UF).
kubectl apply -f ~/gw-lab/code/tag11/beta-route.yaml
~/gw-lab/code/demo/conds.sh httproute shop-beta shop | grep -c '=True'Erwartet (gekürzt, kann je nach Version abweichen):
2
Last im Hintergrund, zwei Minuten lang. Nur auf beta –
auf shop greift seit Tag 10 das Rate Limit (30/min pro
Client, dann 429):
cat > ~/gw-lab/tag11/load.sh <<'EOF'
#!/usr/bin/env bash
# Erzeugt gleichmäßige Last auf beta.apps.lab.internal (Tag 11)
end=$((SECONDS + ${1:-120}))
while [ $SECONDS -lt $end ]; do
curl -s -o /dev/null http://beta.apps.lab.internal/
done
EOF
chmod +x ~/gw-lab/tag11/load.sh
~/gw-lab/tag11/load.sh 120 &Die drei Kernabfragen – RPS, 5xx-Quote und p95 in Millisekunden – pro Route-Regel:
pq() { echo "== $1"; curl -s localhost:9090/api/v1/query --data-urlencode "query=$2" \
| jq -r '.data.result[] | "\(.metric.envoy_cluster_name)\t\(.value[1])"'; }
R='envoy_cluster_name=~"httproute/.*"'
pq RPS "sum by (envoy_cluster_name) (rate(envoy_cluster_upstream_rq_total{$R}[1m]))"
pq 5xx "sum by (envoy_cluster_name) (
rate(envoy_cluster_upstream_rq_xx{$R,envoy_response_code_class=\"5\"}[1m]))
/ sum by (envoy_cluster_name) (rate(envoy_cluster_upstream_rq_xx{$R}[1m]))"
pq p95 "histogram_quantile(0.95, sum by (envoy_cluster_name, le) (
rate(envoy_cluster_upstream_rq_time_bucket{$R}[1m])))"Erwartet (gekürzt, kann je nach Version abweichen):
== RPS
httproute/shop/shop/rule/0 0.17
httproute/shop/shop-beta/rule/0 41.2
== 5xx
httproute/shop/shop/rule/0 0
httproute/shop/shop-beta/rule/0 0.098
== p95
httproute/shop/shop/rule/0 4.6
httproute/shop/shop-beta/rule/0 3.1
Rund 10 % 5xx auf shop-beta – genau das Gewicht von
shop-broken.
Warum upstream_rq_time? Es misst die Zeit vom Router bis
zur Antwort des Backends. Verzögerungen in Filtern davor (Fault
Injection, ext_authz) siehst du nur in
envoy_http_downstream_rq_time – das gibt es aber nur pro
Listener, nicht pro Route.
Tipp: Statt dieselben Ausdrücke in jedes Dashboard zu kopieren, legst du Recording Rules an (
route:rps:rate5musw. inrules.yaml, Drill 7).
Fortschritt speichern? Kostenlos registrieren
Drill 5: Access Log als JSON mit Routenname
Ohne eigene Einstellung schreibt Envoy Gateway schon JSON nach stdout
(u. a. mit route_name und upstream_cluster),
aber mit über 20 Feldern. Für die Produktion willst du ein festes,
kurzes Schema – das ist der Vertrag mit dem Log-Team.
envoyproxy-telemetry.yaml ist die Datei aus Tag 10 plus
der Block telemetry:
spec:
provider: # unverändert aus Tag 9/10
...
telemetry: # neu an Tag 11
accessLog:
settings:
- format:
type: JSON
json:
time: "%START_TIME%"
method: "%REQ(:METHOD)%"
host: "%REQ(:AUTHORITY)%"
path: "%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%"
status: "%RESPONSE_CODE%"
flags: "%RESPONSE_FLAGS%"
duration_ms: "%DURATION%"
upstream: "%UPSTREAM_HOST%"
route: "%ROUTE_NAME%"
request_id: "%REQ(X-REQUEST-ID)%"
trace_id: "%TRACE_ID%"
sinks:
- type: File
file:
path: /dev/stdout
tracing:
samplingRate: 100 # Lab: jeder Request, Produktion: 1-10
provider:
type: OpenTelemetry
backendRefs:
- name: jaeger
namespace: monitoring
port: 4317Der Block provider ist unverändert aus Tag 10 (zwei
Replikas, Cilium-IP 10.10.20.100,
externalTrafficPolicy: Cluster). Lässt du ihn weg, verliert
das Gateway seine feste IP. Das Tracing-Ziel jaeger gibt es
erst in Drill 6; bis dahin gehen die Spans ins Leere.
cd ~/gw-lab/code/tag11
kubectl apply -f envoyproxy-telemetry.yaml
kubectl -n envoy-gateway-system rollout status deploy -l "$SEL" --timeout=3m
kubectl -n infra get gateway web -o jsonpath='{.status.addresses[0].value}{"\n"}'Erwartet (gekürzt, kann je nach Version abweichen):
envoyproxy.gateway.envoyproxy.io/web-proxy configured
deployment "envoy-infra-web-a97fc3bf" successfully rolled out
10.10.20.100
Das Gateway referenziert web-proxy seit Tag 9 per
infrastructure.parametersRef – eine Änderung am
EnvoyProxy rollt die Envoy-Pods neu aus.
Neue Pods, neues Format. Filtere über beide Pods nach 5xx und zähle nach Route:
~/gw-lab/tag11/load.sh 10
kubectl -n envoy-gateway-system logs -l "$SEL" -c envoy --since=1m | grep '^{' \
| jq -r 'select(.status >= 500) | "\(.route) \(.flags)"' | sort | uniq -cErwartet (gekürzt, kann je nach Version abweichen):
41 httproute/shop/shop-beta/rule/0/match/0/beta_apps_lab_internal UF
Warum select(.status >= 500) mit Zahl? Envoy gibt
%RESPONSE_CODE% und %DURATION% im JSON-Format
als Zahl aus, nicht als String. Das spart Casts in Loki oder
Elastic.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Tracing mit OpenTelemetry und Jaeger
Jaeger v2 nimmt OTLP direkt an. Für das Lab reicht die All-in-one-Variante mit Speicher im RAM:
grep 'image:' ~/gw-lab/code/tag11/jaeger.yaml
kubectl apply -f ~/gw-lab/code/tag11/jaeger.yaml
kubectl -n monitoring rollout status deploy/jaeger --timeout=2mErwartet (gekürzt, kann je nach Version abweichen):
image: jaegertracing/jaeger:2.22.0
deployment "jaeger" successfully rolled out
Der Service setzt appProtocol: grpc am Port 4317. Envoy
Gateway baut den Cluster zum Collector dann mit HTTP/2 – OTLP über gRPC
braucht das.
~/gw-lab/tag11/load.sh 10
kubectl -n monitoring port-forward svc/jaeger 16686:16686 >/dev/null 2>&1 &
sleep 2
curl -s 'localhost:16686/api/services' | jq -c .data
curl -s 'localhost:16686/api/traces?service=web.infra&limit=1' \
| jq -r '.data[0].spans[0].tags[] | select(.key|test("http.status_code|upstream"))
| "\(.key)=\(.value)"'Erwartet (gekürzt, kann je nach Version abweichen):
["web.infra","jaeger"]
http.status_code=200
upstream_cluster=httproute/shop/shop-beta/rule/0
Die Trace-ID steht auch im Access Log (trace_id). So
springst du von einer auffälligen Logzeile direkt in den Trace:
http://localhost:16686/trace/<trace_id>.
Tipp: Der Servicename ist
<gateway>.<namespace>(änderbar pertracing.provider.serviceName).echo-basicist nicht instrumentiert, du siehst nur den Gateway-Span. Echte Apps übernehmen dentraceparent-Header.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Gateway- und Route-Status als Metrik
Envoy-Metriken sagen nichts darüber, ob eine Route überhaupt
angenommen wurde. Eine abgelehnte Route erzeugt keinen Cluster – und
damit auch keine Zeitreihe. Den Status liest kube-state-metrics über
Custom Resource State (CRS) aus der API. Der Ausschnitt aus
kps-values.yaml:
- groupVersionKind:
group: gateway.networking.k8s.io
version: v1
kind: HTTPRoute
metricNamePrefix: gatewayapi_httproute
labelsFromPath:
name: [metadata, name]
namespace: [metadata, namespace]
metrics:
- name: accepted
help: Accepted-Condition pro Parent (1 = True)
each:
type: Gauge
gauge:
path: [status, parents]
labelsFromPath:
gateway: [parentRef, name]
listener: [parentRef, sectionName]
valueFrom: [conditions, "[type=Accepted]", status]"[type=Accepted]" sucht im Array das Element mit
passendem type. "True"/"False"
wird zu 1/0. Für Gateways gibt es analog
gatewayapi_gateway_status{type=...} und
gatewayapi_gateway_listener_attached_routes.
pq2() { curl -s localhost:9090/api/v1/query --data-urlencode "query=$1" \
| jq -r '.data.result[] | "\(.metric.namespace)/\(.metric.name) \(.metric.type
// .metric.listener // "") \(.value[1])"'; }
pq2 'gatewayapi_gateway_status'
pq2 'gatewayapi_httproute_accepted'Erwartet (gekürzt, kann je nach Version abweichen):
infra/web Accepted 1
infra/web Programmed 1
shop/shop 1
shop/shop-beta http 1
Jetzt eine kaputte Route – Hostname passt nicht zum Listener
https (*.apps.lab.internal):
kubectl -n shop create -f - <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: shop-falsch
spec:
parentRefs:
- {name: web, namespace: infra, sectionName: https}
hostnames: [shop.example.org]
rules:
- backendRefs: [{name: shop-v1, port: 80}]
EOF
sleep 40
pq2 'gatewayapi_httproute_accepted == 0'Erwartet (gekürzt, kann je nach Version abweichen):
shop/shop-falsch https 0
Die passenden Alerts und Recording Rules stehen in
rules.yaml (mit promtool check rules
geprüft):
grep -E 'record:|alert:' ~/gw-lab/code/tag11/rules.yaml
kubectl apply -f ~/gw-lab/code/tag11/rules.yamlErwartet:
- record: route:rps:rate5m
- record: route:error5xx:ratio5m
- record: route:latency:p95_5m
- alert: GatewayNotProgrammed
- alert: HTTPRouteNotAccepted
- alert: RouteHigh5xx
- alert: EnvoyGatewayXdsNack
prometheusrule.monitoring.coreos.com/gateway-api created
Nach fünf Minuten:
curl -s localhost:9090/api/v1/alerts \
| jq -r '.data.alerts[] | "\(.labels.alertname) \(.state) \(.labels.name // "")"'Erwartet (gekürzt, kann je nach Version abweichen):
HTTPRouteNotAccepted firing shop-falsch
RouteHigh5xx pending
RouteHigh5xx bleibt pending, solange keine
Last läuft – die Quote ist dann NaN. Für den schnellen
Blick ohne Prometheus gibt es egctl, die CLI von Envoy
Gateway:
brew install egctl # Linux: Release-Binary v1.9.2 nach ~/.local/bin
egctl version --remote=false
egctl x status httproute -n shopErwartet (gekürzt, kann je nach Version abweichen):
egctl version: v1.9.2
NAME PARENT TYPE STATUS REASON
shop gateway/web ResolvedRefs True ResolvedRefs
Accepted True Accepted
shop-falsch gateway/web ResolvedRefs True ResolvedRefs
Accepted False NoMatchingListenerHostname
Achtung: Das rohe Darwin-Binary aus dem GitHub-Release ist nicht signiert und wird auf Apple Silicon beim Start beendet (Exit 137). Nimm auf dem Mac Homebrew.
Räume danach auf:
kubectl -n shop delete httproute shop-falsch.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Offizielle Grafana-Dashboards
Envoy Gateway pflegt Dashboards im Chart
gateway-addons-helm unter dashboards/.
dashboards.sh lädt sie für die gewählte Version und legt je
eine ConfigMap mit dem Label grafana_dashboard=1 an – das
Label, auf das der Grafana-Sidecar von kube-prometheus-stack wartet.
cd ~/gw-lab/code/tag11 && ./dashboards.sh
jq -r '.templating.list[].name' dashboards/envoy-clusters.json | xargsErwartet:
envoy-proxy-global: Envoy Global
envoy-clusters: Envoy Clusters
envoy-gateway-global: Envoy Gateway Global
resources-monitor.gen: Resources Monitor
configmap/eg-dash-envoy-proxy-global created
configmap/eg-dash-envoy-clusters created
configmap/eg-dash-envoy-gateway-global created
configmap/eg-dash-resources-monitor created
datasource cluster namespace resource rule
Grafana schaltest du im selben Helm-Release zu; der Sidecar lädt alle ConfigMaps mit dem Label aus allen Namespaces:
helm upgrade kps oci://ghcr.io/prometheus-community/charts/kube-prometheus-stack \
--version 92.2.0 -n monitoring --reuse-values --set grafana.enabled=true --wait
kubectl -n monitoring get secret kps-grafana \
-o jsonpath='{.data.admin-password}' | base64 -d; echo
kubectl -n monitoring port-forward svc/kps-grafana 3000:80 >/dev/null 2>&1 &Unter http://localhost:3000 → Dashboards findest du die
vier Envoy-Dashboards. Das Dashboard „Envoy Clusters” filtert über das
Namensschema aus Drill 1
(.*?route/$namespace/$resource/rule/.*): Namespace → Route
→ Regel.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cat > ~/gw-lab/tag11/check.sh <<'EOF'
#!/usr/bin/env bash
q() { curl -s localhost:9090/api/v1/query --data-urlencode "query=$1" \
| jq -r '.data.result | length'; }
check() { if [ "$(q "$2")" -gt 0 ]; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "Proxy-Metriken in Prometheus" 'envoy_cluster_upstream_rq_total'
check "Control-Plane-Metriken" 'xds_snapshot_update_total'
check "Gateway-Status (CRS)" 'gatewayapi_gateway_status{type="Programmed"}==1'
check "Route-Status (CRS)" 'gatewayapi_httproute_accepted'
check "Recording Rule 5xx" 'route:error5xx:ratio5m'
POD=$(kubectl -n envoy-gateway-system get pod -o name \
-l app.kubernetes.io/component=proxy | head -1)
kubectl -n envoy-gateway-system logs "$POD" -c envoy --tail=20 | grep -q '"route":' \
&& echo "✔ JSON-Log mit route" || echo "✘ JSON-Log mit route"
curl -s localhost:16686/api/services | grep -q 'web.infra' \
&& echo "✔ Traces in Jaeger" || echo "✘ Traces in Jaeger"
EOF
chmod +x ~/gw-lab/tag11/check.sh && ~/gw-lab/tag11/check.shErwartet (gekürzt, kann je nach Version abweichen):
✔ Proxy-Metriken in Prometheus
✔ Control-Plane-Metriken
✔ Gateway-Status (CRS)
✔ Route-Status (CRS)
✔ Recording Rule 5xx
✔ JSON-Log mit route
✔ Traces in Jaeger
Challenge
Das Payments-Team will einen eigenen Alert: p95 der Route
payments über 300 ms für 10 Minuten. Schreib eine
PrometheusRule im Namespace payments, die nur
die Cluster dieser Route betrachtet.
Hinweis: GRPCRoutes heißen im Clusternamen
grpcroute/<ns>/<name>/rule/<n>.
Lösung
kubectl apply -f - <<'EOF'
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
name: payments-latency
namespace: payments
spec:
groups:
- name: payments.alerts
rules:
- alert: PaymentsP95High
expr: |
histogram_quantile(0.95, sum by (envoy_cluster_name, le) (
rate(envoy_cluster_upstream_rq_time_bucket{
envoy_cluster_name=~"grpcroute/payments/.*"}[5m]))) > 300
for: 10m
labels: {severity: warning, team: payments}
EOF
curl -s localhost:9090/api/v1/rules | jq -r '.data.groups[].name' | grep paymentsErwartet (gekürzt, kann je nach Version abweichen):
payments.alerts
upstream_rq_time ist in Millisekunden, daher
> 300. Weil ruleSelectorNilUsesHelmValues
auf false steht, findet Prometheus die Regel auch im
App-Namespace.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Kardinalität: pro Route-Regel entsteht ein Satz Cluster-Metriken.
Bei tausenden Routen filterst du mit
telemetry.metrics.matchesoder permetricRelabelingsim PodMonitor.mergeBackendsimEnvoyProxyteilt Cluster zwischen Routen – spart Metriken, kostet aber die Sicht pro Route. - Access Logs gehen in Produktion per OpenTelemetry-Sink an einen
Collector (Loki, Elastic, Splunk), nicht über
kubectl logs. Das JSON-Schema ist ein Vertrag – versionieren. - Sampling: 1–10 % reichen, Fehler per Tail-Sampling im OTel Collector vollständig behalten.
- Mit Rancher läuft oft schon Rancher Monitoring (kube-prometheus-stack). Dann nur Monitore, Regeln und die CRS-Konfiguration ergänzen, nicht doppelt installieren.
- SLOs pro Route (Verfügbarkeit aus
route:error5xx:ratio5m) mit Burn-Rate-Alerts statt fester Schwellen – sonst weckt dich jeder kurze Ausreißer.