Anleitung

p95-Latenz auf Kubernetes senken: Gateway-Logs lesen, Indizes finden, Ressourcen und HPA richtig setzen

Wenn eine SaaS-Plattform wächst und die Antwortzeiten im 95. Perzentil steigen, liegt die Ursache fast immer an einer von vier Stellen: fehlende Datenbankindizes, falsch gesetzte Requests und Limits, ein Autoscaler, der zu spät oder auf die falsche Metrik skaliert, oder ein Gateway, das Timeouts verdeckt. Dieser Artikel zeigt, in welcher Reihenfolge Sie suchen und wie Sie jede Änderung messen.

Er richtet sich an Teams, die Kubernetes in AWS oder GCP betreiben und gerade einen großen Kunden aufnehmen.

1. Warum p95 und nicht der Durchschnitt

Der Durchschnitt versteckt das Problem. Wenn 94 von 100 Anfragen in 80 ms antworten und sechs in 4 Sekunden, liegt der Mittelwert bei etwa 315 ms und sieht harmlos aus. Die sechs Nutzer, die vier Sekunden warten oder abbrechen, sind aber genau die, die sich beschweren. Das 95. Perzentil (p95) ist der Wert, unter dem 95 Prozent der Anfragen liegen; im Beispiel sind das 4 Sekunden. p99 entsprechend, für das langsamste Prozent. Beide zeigen, was die langsamsten Nutzer erleben.

Als wir die Plattform-SRE-Verantwortung für eine Logistik-SaaS übernahmen, stand ein Kunde mit rund 50.000 Nutzern vor dem Onboarding, und die Timeouts begannen schon in der Vorbereitung. Die Reihenfolge, in der wir damals gesucht haben, ist die Reihenfolge dieses Artikels: zuerst sehen, was die Nutzer tatsächlich trifft, dann die Datenbank, dann die Ressourcen, zuletzt der Autoscaler.

2. Zuerst messen: ein SLO und ein Fehlerbudget

Bevor Sie etwas ändern, legen Sie fest, was „gut” heißt. Ein Service Level Objective (SLO) ist eine Zusage in Zahlen, etwa: „95 Prozent der API-Anfragen antworten in unter 500 ms, gemessen am Gateway, über 30 Tage.” Aus dem SLO folgt das Fehlerbudget: der Anteil Anfragen, der langsamer sein oder fehlschlagen darf, bevor die Zusage verletzt ist. Steht ein Service Level Agreement (SLA) mit dem Kunden, leitet sich das SLO daraus ab und ist strenger als das SLA.

Das Fehlerbudget ist das Steuerinstrument. Ist es aufgebraucht, stoppt das Team Feature-Releases und arbeitet an Zuverlässigkeit; ist es gut gefüllt, darf riskanter ausgerollt werden. Ohne diese Zahl bleibt jede Latenzdiskussion eine Meinungsfrage.

3. Gateway-Logs: was die Nutzer tatsächlich erleben

Anwendungs-Metriken zeigen, was der Dienst gemessen hat. Das Gateway am Rand (Edge) zeigt, was der Nutzer bekommen hat, einschließlich der Anfragen, die den Dienst nie erreicht haben, weil ein Upstream-Timeout vorher zuschlug.

Lassen Sie die Gateway-Logs automatisch auswerten, nicht von Hand. Ein kleiner Job, der stündlich läuft, reicht:

  • Gruppieren nach Route (ohne IDs im Pfad), Statuscode und Upstream.
  • Je Gruppe: Anzahl, p50, p95, p99 der Antwortzeit, Anteil 5xx und 504.
  • Abweichungen gegen die Vorwoche markieren.

Das Ergebnis ist eine Liste der zehn Routen, die das Fehlerbudget am stärksten belasten. In der Praxis sind es selten mehr als drei, die den Großteil ausmachen. Diese drei sind die Arbeitsliste; alles andere wartet.

Ein typischer Fund an dieser Stelle: 504-Antworten des Gateways, die in den Anwendungs-Metriken gar nicht auftauchen, weil die Anwendung die Anfrage noch bearbeitet, während das Gateway sie schon aufgegeben hat. Das Gateway-Timeout und das Anwendungs-Timeout müssen aufeinander abgestimmt sein: Das Gateway wartet länger als die Anwendung, damit der Nutzer eine Fehlermeldung der Anwendung sieht und keinen leeren 504.

4. Datenbank: fehlende Indizes sind der häufigste Grund

Eine Route, die bei 1.000 Nutzern schnell war und bei 50.000 langsam wird, hat sehr oft eine Abfrage, die eine ganze Tabelle liest. Die Tabelle war früher klein. Zwei Werkzeuge finden das in Minuten:

pg_stat_statements (PostgreSQL) sammelt je Abfragemuster Aufrufzahl und Gesamtzeit. Sortiert nach Gesamtzeit steht die teuerste Abfrage oben.

SELECT calls, round(total_exec_time) AS total_ms,
       round(mean_exec_time) AS mean_ms, left(query, 80) AS q
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 10;

EXPLAIN (ANALYZE, BUFFERS) zeigt für diese Abfrage, ob ein sequenzieller Scan über eine große Tabelle läuft. Steht dort Seq Scan auf einer Tabelle mit Millionen Zeilen und ein Filter auf eine Spalte ohne Index, ist der Fall klar.

Zwei Regeln beim Anlegen:

  1. CREATE INDEX CONCURRENTLY, damit die Tabelle während des Aufbaus nicht gesperrt wird. Auf einer Produktionsdatenbank ist das keine Option, sondern Pflicht.
  2. Vorher und nachher messen, mit derselben Abfrage und EXPLAIN ANALYZE. Ein Index, der nicht benutzt wird, kostet nur Schreibzeit.

Was ein Index nicht löst: N+1-Abfragen (eine Abfrage je Listenelement) und fehlende Verbindungs-Pools. Beides zeigt sich ebenfalls in pg_stat_statements, als sehr viele sehr kurze Aufrufe. Die Lösung liegt dann in der Anwendung oder in einem Pooler wie PgBouncer.

5. Requests und Limits: die Ressourcenvergabe auf Kubernetes

Kubernetes plant Pods anhand ihrer requests und begrenzt sie mit limits. Falsche Werte erzeugen Latenz auf drei Arten:

  • CPU-Limit zu niedrig: Der Container wird gedrosselt (CPU throttling), obwohl der Knoten frei ist. Die Metrik container_cpu_cfs_throttled_periods_total zeigt es. Für latenzkritische Dienste sind CPU-Limits oft kontraproduktiv; requests korrekt setzen und das Limit weglassen oder großzügig wählen.
  • Memory-Limit zu niedrig: Der Container wird mit OOM beendet, Anfragen brechen ab, der Neustart kostet Sekunden. Sichtbar an OOMKilled in den Pod-Ereignissen.
  • Requests zu hoch: Der Scheduler findet keinen Platz, neue Pods bleiben Pending, der Autoscaler skaliert ins Leere. Knotenpools und Requests müssen zusammenpassen.

Die richtigen Werte kommen aus der Messung: kubectl top oder die Metriken des Clusters über eine Woche, mit p95 des tatsächlichen Verbrauchs als Request. Startwerte aus einer Vorlage sind nach dem ersten Lasttest zu ersetzen.

6. HPA: wann und worauf skalieren

Der Horizontal Pod Autoscaler (HPA) erhöht die Zahl der Pods, wenn eine Metrik einen Zielwert überschreitet. Der Standard, CPU-Auslastung, ist für viele Dienste die falsche Metrik: Ein Dienst, der auf die Datenbank wartet, hat niedrige CPU und trotzdem lange Antwortzeiten. Skaliert der HPA nicht, weil die CPU bei 30 Prozent liegt, bleibt die Latenz hoch.

Besser: eine Metrik, die den Engpass abbildet. Anfragen pro Sekunde je Pod, Länge der Warteschlange, oder direkt p95 der Antwortzeit über einen Metrik-Adapter (Prometheus Adapter oder KEDA). Dazu drei Einstellungen, die oft fehlen:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api
  minReplicas: 3
  maxReplicas: 30
  metrics:
    - type: Pods
      pods:
        metric:
          name: http_requests_per_second
        target:
          type: AverageValue
          averageValue: '50'
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
        - type: Percent
          value: 100
          periodSeconds: 30
    scaleDown:
      stabilizationWindowSeconds: 300
  • minReplicas hoch genug, dass ein Knotenausfall keinen Engpass erzeugt.
  • behavior.scaleUp schnell, scaleDown langsam. Ein Autoscaler, der nach einer Lastspitze sofort abbaut, erzeugt die nächste Spitze selbst.
  • Readiness-Probes, die erst grün werden, wenn der Pod wirklich Anfragen bedienen kann, sonst bekommt ein kalter Pod sofort Last und antwortet langsam.

Der HPA skaliert Pods, nicht Knoten. Ohne Cluster-Autoscaler oder Karpenter bleiben neue Pods Pending, wenn der Knotenpool voll ist. Beides zusammen testen, bevor der große Kunde kommt.

7. Das Onboarding als Lasttest

Ein Onboarding mit zehntausenden Nutzern ist planbar, und genau deshalb ist es der beste Lasttest, den Sie bekommen. Vorgehen:

  1. Erwartete Last je Route aus den Zahlen des Kunden ableiten (Nutzer, Spitzenstunden, typische Aktionen).
  2. Diese Last gegen eine Umgebung mit Produktionsdaten-Größe fahren, mit einem Lastwerkzeug, das p95 und Fehlerquote je Route ausgibt.
  3. Die drei langsamsten Routen nach den Abschnitten 4 bis 6 bearbeiten, erneut fahren.
  4. Den Onboarding-Tag mit einem Dashboard begleiten, das Fehlerbudget-Verbrauch in Echtzeit zeigt, und einer Person, die am Gateway drosseln kann, falls nötig.

Rate-Limiting am Gateway ist dabei kein Zeichen von Schwäche, sondern der Schutz der bestehenden Kunden: Ein neuer Mandant, der beim Import zehntausend Anfragen pro Sekunde erzeugt, darf nicht alle anderen ausbremsen.

8. Dashboards, die das Team benutzt

Ein Dashboard je Dienst mit genau vier Reihen: Anfragen pro Sekunde, p50/p95/p99, Fehlerquote, Sättigung (CPU-Drosselung, Speicher, Verbindungs-Pool). Darüber eine Zeile mit dem Fehlerbudget des Monats. Alles andere gehört in Detail-Ansichten.

In dem erwähnten Projekt haben wir die Dashboards mit ELK für die Log-Auswertung und Grafana für die Metriken aufgebaut, die Platform-Dailies moderiert und ein eigenes Platform-SRE-Team aufgebaut; am Ende lag das p95 der Antwortzeiten um rund 80 Prozent niedriger, und die Fehlerquote passte in das Fehlerbudget aus dem SLA. Die Zahl ist weniger wichtig als die Reihenfolge: Erst die drei teuersten Routen, erst die Datenbank, dann die Ressourcen, dann der Autoscaler.

9. Checkliste

Messen:

  • SLO je Dienst schriftlich; Fehlerbudget berechnet; Dashboard zeigt den Verbrauch.
  • Gateway-Logs automatisch ausgewertet: Top-10-Routen nach p95 und 5xx.
  • Gateway-Timeout länger als Anwendungs-Timeout.

Datenbank:

  • pg_stat_statements aktiv; Top-10 nach Gesamtzeit geprüft.
  • EXPLAIN ANALYZE für jede dieser Abfragen; Seq Scans auf großen Tabellen beseitigt.
  • Indizes mit CONCURRENTLY angelegt, Wirkung gemessen.
  • N+1-Muster und Verbindungs-Pool geprüft.

Ressourcen:

  • Requests aus gemessenem p95-Verbrauch; CPU-Drosselung geprüft; keine OOMKilled.
  • Knotenpool passt zu den Requests; keine Pending-Pods unter Last.

Autoscaling:

  • HPA-Metrik bildet den Engpass ab, nicht nur CPU.
  • minReplicas, schnelles scaleUp, langsames scaleDown, Readiness-Probes.
  • Cluster-Autoscaler oder Karpenter getestet.

Onboarding:

  • Lasttest mit den Zahlen des Kunden gefahren; drei langsamste Routen bearbeitet.
  • Rate-Limiting am Gateway je Mandant konfiguriert.
  • Onboarding-Tag mit Dashboard und Eingriffsmöglichkeit begleitet.

10. Häufige Fragen

Sollte ich zuerst mehr Pods oder mehr Knoten hinzufügen? Weder noch, bevor Sie wissen, was langsam ist. Ein fehlender Index wird durch mehr Pods nicht schneller; er erzeugt nur mehr parallele Scans auf der Datenbank.

Wie finde ich heraus, ob die Datenbank oder die Anwendung der Engpass ist? Vergleichen Sie die Zeit, die die Anwendung in der Datenbank verbringt (aus Tracing oder den Treiber-Metriken), mit der Gesamtantwortzeit. Liegt der Datenbankanteil über der Hälfte, beginnen Sie dort.

Brauche ich Tracing? Für die ersten drei Routen reichen Logs und pg_stat_statements. Verteiltes Tracing lohnt, sobald eine Anfrage mehr als drei Dienste durchläuft und niemand mehr sagen kann, wo die Zeit bleibt.

Wie oft sollte das Fehlerbudget überprüft werden? Täglich im Platform-Daily, als eine Zahl. Wöchentlich im Rückblick, mit den Routen, die es verbraucht haben.

Wo das hinführt

Wir betreiben eigene Hardware in einem Rechenzentrum in München und Plattformen unserer Kunden in AWS und GCP. Wie wir SRE-Arbeit wie die hier beschriebene anbieten, von der Gateway-Auswertung bis zum Aufbau eines Platform-SRE-Teams, beschreibt DevOps & SRE für AWS und GCP.

Praxisbeispiel: Logistik-SaaS: Onboarding eines Kunden mit 50.000 Nutzern.

Wie Sie Änderungen wie diese vor dem Release in einer eigenen Umgebung testen: Release-Umgebungen auf Kubernetes mit Crossplane und Argo Workflows.

Englische Fassung: Reducing p95 latency on Kubernetes: read gateway logs, find indexes, set resources and HPA right.

Quellen

Alle abgerufen am 20.10.2026.

Ein Onboarding steht an?

Schreiben Sie uns, welche Last Sie erwarten und wo es heute schon eng wird. Im Erstgespräch gehen wir Ihre Gateway-Zahlen und die drei teuersten Routen durch.