Zum Inhalt springen
Trainingslager IT-Trainingslager

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 (Port metrics 19001, /stats/prometheus).
  • Envoy Gateway baut pro Route-Regel einen Envoy-Cluster mit dem Namen httproute/<ns>/<name>/rule/<n>. Das Label envoy_cluster_name ist dein Routen-Schlüssel in PromQL.
  • Access Logs und Tracing stellst du im EnvoyProxy unter spec.telemetry ein, angehängt per infrastructure.parametersRef am 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) und promtool geprü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 %1

Erwartet (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 %1

Erwartet (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: false

Ohne 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 pods

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

Erwartet (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:rate5m usw. in rules.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: 4317

Der 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 -c

Erwartet (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=2m

Erwartet (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 per tracing.provider.serviceName). echo-basic ist nicht instrumentiert, du siehst nur den Gateway-Span. Echte Apps übernehmen den traceparent-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.yaml

Erwartet:

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

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

Erwartet:

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

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

Erwartet (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.matches oder per metricRelabelings im PodMonitor. mergeBackends im EnvoyProxy teilt 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.