Be Software Architecture Wise
Be Wise Apps

Read in English · Leer en español · Lire en français

Kapitel 9 von 12 · Mittelstufe bis Fortgeschritten

Performance, Skalierbarkeit, Resilienz und Betreibbarkeit

Dieses Kapitel macht aus den Performance- und Verfügbarkeitsszenarien aus Kapitel 2 funktionierende Systeme. Es behandelt Scale-up und Scale-out und den Scale Cube, Load Balancing und zustandslose Services, Queues, Backpressure und Rate Limiting, die Resilienzmuster, die die Ausbreitung von Ausfällen verhindern (Timeouts, Wiederholungen, Circuit Breaker, Bulkheads), SLIs, SLOs und Error Budgets, Observability mit Logs, Metriken und Traces, Kapazitätsplanung und Performancetests sowie Chaos Engineering und das Lernen aus Incidents. Es richtet sich an Entwicklungsteams und Architekten, die die verteilten Stile aus Kapitel 6 kennen und ein System unter realer Last schnell und lauffähig halten müssen.

Videoeinführung in Kapitel 9

7 Min. · auf Englisch gesprochen, mit Untertiteln
Nur anhören (Audio)
Transkript lesen

Willkommen zu Kapitel 9: Performance, Skalierbarkeit, Resilienz und Betreibbarkeit. Ein Entwurf, der seine Ziele im Diagramm erfüllt, kann trotzdem an einem Freitag um halb eins zusammenbrechen, wenn jedes Büro der Stadt Mittagessen bestellt. Der Unterschied liegt selten in cleverem Code. Er besteht aus Architekturentscheidungen: wie Kapazität hinzukommt, wie Last verteilt wird, wie Arbeit wartet, wie Ausfälle eingedämmt werden und wie die Betreiber erkennen, was das System tut.

Dieses Kapitel richtet sich an Entwicklungsteams und Architekten, die die verteilten Stile aus Kapitel 6 kennen und ein System unter realer Last schnell und lauffähig halten müssen. Es baut auf Kapitel 2 auf, das Performance und Verfügbarkeit als testbare Qualitätsszenarien präzise gemacht hat. Hier lernen Sie, diese Szenarien in einem laufenden System zu erreichen und sie auch am geschäftigsten Tag des Jahres einzuhalten. Für Replikation, Partitionierung und Caching verweist es auf Kapitel 7, statt sie zu wiederholen. Und es führt zu Kapitel 10 über die Cloud-Plattformen, Kubernetes-Funktionen und Multi-Region-Designs, auf denen diese Systeme meist laufen.

Zwei durchgehende Beispiele begleiten das Kapitel. Eine Essenslieferplattform mit ausgeprägten Spitzen mittags und abends. Und ein Ticket-Vorverkauf, bei dem die Nachfrage innerhalb von Sekunden von fast nichts auf ein Vielfaches der Systemkapazität steigt. Abschnitt neun Punkt eins vergleicht Scale-up mit Scale-out, trennt mit dem Scale Cube Klonen, Aufteilung nach Funktion und Aufteilung nach Daten und erklärt, warum Autoscaling anhand der CPU oft die falsche Wahl ist. Abschnitt neun Punkt zwei behandelt, was vor den Instanzen sitzt: Load Balancer, ihre Algorithmen, Health Checks, Connection Draining und warum Sticky Sessions einem Session-Zustand außerhalb der Instanz weichen sollten. Abschnitt neun Punkt drei behandelt, was passiert, wenn Arbeit schneller eintrifft, als sie erledigt werden kann: begrenzte Queues, Backpressure, Load Shedding und Rate Limiting, die entscheiden, was angenommen wird, was wartet und was höflich abgelehnt wird. Abschnitt neun Punkt vier befasst sich mit Ausfällen zwischen Services: Timeouts und Deadlines, Wiederholungen mit Backoff und Jitter, Circuit Breaker, Bulkheads und Fallbacks.

Das ausgearbeitete Beispiel in Abschnitt neun Punkt vier zeigt, wie ein einziger fehlender Timeout eine langsame Abhängigkeit alles lahmlegen lässt, was sie aufruft. Der Zahlungsdienstleister antwortet normalerweise in null Komma drei Sekunden. Heute antwortet er nicht mehr. Der Bestellservice ruft ihn ohne Timeout auf, also warten nach und nach alle zweihundert Threads auf Zahlungsaufrufe. Jetzt scheitert der Bezahlvorgang. Aber auch Bestellverlauf und Sendungsverfolgung scheitern, obwohl sie Zahlungen nie berühren, weil keine freien Threads mehr übrig sind. Die Datenbank ist völlig gesund, aber kein Thread ist frei, um sie aufzurufen. Timeouts, Circuit Breaker und Bulkheads sind die Muster, die eine solche Kaskade stoppen.

Die zweite Hälfte wendet sich von den Mechanismen dem Betrieb zu. Abschnitt neun Punkt fünf zeigt, wie Sie Zuverlässigkeit aus Nutzersicht formulieren und wie ein Error Budget ein Verfügbarkeitsziel in eine Menge erlaubter Ausfälle verwandelt, die Teams für Änderungen ausgeben können. Abschnitt neun Punkt sechs behandelt die Logs, Metriken und Traces, mit denen Fachleute einem Produktionssystem neue Fragen stellen können, sowie Distributed Tracing mit OpenTelemetry. Abschnitt neun Punkt sieben schließt den Kreis zwischen Prognosen und Belegen, mit Last-, Stress-, Soak-, Spike- und Breakpoint-Tests und einem Kapazitätsplan für einen Ticket-Vorverkauf. Und Abschnitt neun Punkt acht befasst sich mit den Ausfällen, die trotzdem passieren: gezielte Experimente, um Schwachstellen vor der Kundschaft zu finden, klare Rollen bei Incidents und schuldfreie Reviews, die das System ändern statt der Menschen.

Dieses Diagramm aus Abschnitt neun Punkt fünf bringt drei Begriffe auf eine Skala, anhand der Verfügbarkeit des Bezahlvorgangs über rollierende achtundzwanzig Tage. Das Service Level Objective, kurz SLO, ist das interne Ziel: hier neunundneunzig Komma neun Prozent. Das Service Level Agreement, kurz SLA, ist ein Vertrag mit Partnern, lockerer angesetzt, bei neunundneunzig Komma fünf Prozent. Der Service Level Indicator, kurz SLI, ist die Messung. Diesen Monat liegt er bei neunundneunzig Komma neun vier Prozent, in der Zone, in der der Service innerhalb seines Budgets liegt. Unterhalb des SLO ist das Ziel verfehlt, und eine schriftliche Error-Budget-Policy legt fest, was dann geschieht. Erst unterhalb des SLA sind Gutschriften fällig. Die Lücke zwischen SLO und SLA ist die Warnzone. Das Error Budget ist einfach eins minus SLO. Über dreißig Tage erlaubt ein Ziel von neunundneunzig Komma neun Prozent dreiundvierzig Komma zwei Minuten Totalausfall, oder dass eine von tausend Anfragen scheitert.

Die Abschnitte bilden eine Kette und führen zu einem Gedanken. Jede Ressource ist endlich, also hat jedes System eine Belastungsgrenze. Die Aufgabe der Architektur ist es, im Voraus zu entscheiden, was passiert, wenn sie erreicht ist. Ein gut entworfenes System wird unter übermäßiger Last kontrolliert langsamer und wirft die unwichtigste Arbeit zuerst ab. Es lehnt klar ab, statt stillschweigend in einen Timeout zu laufen. Es isoliert den ausfallenden Teil. Und es erholt sich von selbst, wenn der Druck nachlässt. Ein schlecht entworfenes System reiht ohne Grenze ein, wiederholt Anfragen, bis es zusammenbricht, und reißt seine Nachbarn mit. Diese Mechanismen lassen sich beim Entwurf günstig einbauen und nur teuer nachrüsten. Ob ein Service zustandslos ist, ob eine Queue begrenzt ist und ob eine Anfrage eine Deadline mitführt, wird lange vor dem ersten Incident entschieden.

Am Ende des Kapitels können Sie entscheiden, wie Sie skalieren, und eine Flotte mit Littles Gesetz und Kapazitätsreserve für eine bekannte Spitze dimensionieren. Sie können Timeouts, Deadlines, Wiederholungen mit Backoff und Jitter, Circuit Breaker, Bulkheads und Fallbacks kombinieren, um Ausfälle einzudämmen. Sie können Service Level Indicators und Objectives aus Nutzersicht definieren, Error Budgets berechnen und Alerts dafür entwerfen, wie schnell sie verbraucht werden. Und Sie können Kapazitäts- und Performancetests planen, Chaos-Experimente sicher durchführen und schuldfreie Post-Incident-Reviews leiten.

Weil die Abschnitte eine Kette bilden, lesen Sie sie am besten der Reihe nach. Jeder steht aber auch für sich, sodass Sie direkt zu dem Abschnitt gehen können, den Sie brauchen. Planen Sie etwa dreieinhalb Stunden ein, um das ganze Kapitel zu lesen. Am Ende jedes Abschnitts gibt es Fragen zur Selbstkontrolle. Beantworten Sie sie im Kopf, bevor Sie sich die Antworten ansehen. Wenn Sie so weit sind, gibt es einen optionalen Kapiteltest, der etwa fünfundvierzig Minuten dauert. Er umfasst zwanzig Multiple-Choice-Fragen und zwei schriftliche Antworten. Die Bestehensgrenze liegt bei achtzig Prozent.

So ist das Kapitel aufgebaut. Beginnen Sie mit Abschnitt neun Punkt eins über Scale-up, Scale-out und den Scale Cube. Bis gleich.

Kapitel herunterladen (PDF)In der App lesen

Auf einen Blick

Das lernen Sie

  • Zwischen vertikaler und horizontaler Skalierung und zwischen den X-, Y- und Z-Achsen des Scale Cube wählen und eine Flotte mit Littles Gesetz und Kapazitätsreserve für eine bekannte Spitzenlast dimensionieren.
  • Autoscaling-Signale und -Einstellungen wählen, die Verzögerung und Flapping vermeiden, und erklären, warum die CPU oft die falsche Metrik ist.
  • Load Balancing auf Layer 4 und Layer 7 sowie die wichtigsten Algorithmen vergleichen, Health Checks und Connection Draining entwerfen und den Session-Zustand auslagern.
  • Queues, begrenzte Puffer, Backpressure, Load Shedding und Rate Limiting (einschließlich Token Bucket) einsetzen, um Überlast unter Kontrolle zu halten.
  • Timeouts, Deadlines, Wiederholungen mit Backoff und Jitter, Retry-Budgets, Circuit Breaker, Bulkheads und Fallbacks kombinieren, um Ausfälle einzudämmen.
  • SLIs und SLOs aus Sicht der Nutzer definieren, Error Budgets und Burn Rates berechnen und darauf basierende Alerts entwerfen.
  • Ein System mit OpenTelemetry durch Logs, Metriken und Traces instrumentieren und Probleme mit der RED- und der USE-Methode diagnostizieren.
  • Kapazitäts- und Performancetests planen, Chaos-Experimente sicher durchführen und schuldfreie Post-Incident-Reviews leiten.

Bevor Sie beginnen

Kapitel 2, besonders die Abschnitte über Performance und Skalierbarkeit sowie über Verfügbarkeit und Zuverlässigkeit; Kapitel 6, besonders warum man verteilt, Kommunikation und APIs; und die Abschnitte aus Kapitel 7 über Replikation, Partitionierung und Caching.

Zeit

Etwa 3½ Stunden Lesezeit; 45 Minuten für den Test.

Schlüsselbegriffe

Scale Cube · Autoscaling · Zustandsloser Service · Layer-7-Load-Balancer · Power of Two Random Choices · Backpressure · Load Shedding · Token Bucket · Circuit Breaker · Bulkhead · Error Budget · Burn Rate · Distributed Tracing · Chaos Engineering

Von Qualitäten auf dem Papier zu Qualitäten in Produktion

Kapitel 2 hat Performance und Verfügbarkeit präzise gemacht: Latenzperzentile, Durchsatz, Littles Gesetz, Auslastung und die Neunen, formuliert als testbare Qualitätsszenarien. In diesem Kapitel geht es darum, diese Szenarien in einem laufenden System zu erreichen und sie auch am geschäftigsten Tag des Jahres einzuhalten. Ein Entwurf, der seine Ziele im Diagramm erfüllt, kann trotzdem an einem Freitag um 12:30 Uhr zusammenbrechen, wenn jedes Büro der Stadt Mittagessen bestellt, oder um 10:00 Uhr an dem Morgen, an dem der Vorverkauf für Konzertkarten beginnt. Der Unterschied liegt selten in cleverem Code. Er besteht aus einer Reihe von Architekturentscheidungen: wie Kapazität hinzukommt, wie Last verteilt wird, wie Arbeit wartet, wie Ausfälle eingedämmt werden und wie die Menschen, die das System betreiben, erkennen, was es gerade tut.

Zwei durchgehende Beispiele begleiten das Kapitel. Die Essenslieferplattform hat eine ausgeprägte tägliche Spitze zur Mittags- und Abendzeit, Dutzende Services und Abhängigkeiten von Drittanbietern wie Zahlungsdienstleistern und Karten-APIs. Der Ticket-Vorverkauf ist der Extremfall: Die Nachfrage steigt innerhalb von Sekunden von fast nichts auf ein Vielfaches der Systemkapazität, für ein festes Kontingent an Plätzen, während das ganze Land zusieht. Zusammen decken sie jede Technik des Kapitels ab.

Last bewältigen: skalieren, verteilen und warten

In den ersten vier Abschnitten geht es um Last. Skalierungsstrategien vergleicht Scale-up mit Scale-out, trennt mit dem Scale Cube von Abbott und Fisher das Klonen, die Aufteilung nach Funktion und die Aufteilung nach Daten und erklärt, warum Autoscaling anhand der CPU oft die falsche Wahl ist und wie Sie eine Flotte mit Littles Gesetz und einer Kapazitätsreserve für eine bekannte Spitze dimensionieren. Load Balancing, Zustandslosigkeit und Sessions behandelt, was vor den Instanzen sitzt: Load Balancer auf Layer 4 und Layer 7, die Algorithmen, die sie verwenden (einschließlich der Power of Two Random Choices), Health Checks, die nicht eine ganze Flotte auf einmal herausnehmen, Connection Draining und warum Sticky Sessions einem ausgelagerten Session-Zustand weichen sollten.

In Asynchronität, Queues und Backpressure geht es darum, was passiert, wenn Arbeit schneller eintrifft, als sie erledigt werden kann. Queues verwandeln Lastspitzen in Rückstände, was nur nützt, wenn der Rückstand begrenzt ist und in akzeptabler Zeit abgebaut wird. Backpressure, Load Shedding und Rate Limiting entscheiden, welche Arbeit angenommen wird, welche wartet und welche höflich mit HTTP 429 abgelehnt wird. Timeouts, Wiederholungen, Circuit Breaker, Bulkheads und Graceful Degradation befasst sich dann mit Ausfällen zwischen Services: Timeouts und Deadlines, Wiederholungen mit Backoff und Jitter und die Budgets, die Retry-Stürme verhindern, Circuit Breaker, Bulkheads, Fallbacks, Idempotenz und Hedged Requests. Das ausgearbeitete Beispiel zeigt, wie ein einziger fehlender Timeout zulässt, dass eine einzige langsame Abhängigkeit alles lahmlegt, was sie aufruft.

Das System betreiben: Ziele, Observability, Tests und Lernen

Die zweite Hälfte wendet sich von den Mechanismen dem Betrieb zu. SLIs, SLOs, SLAs und Error Budgets zeigt, wie Sie Zuverlässigkeit aus Sicht der Nutzer formulieren, wie ein Error Budget ein Verfügbarkeitsziel in eine Menge erlaubter Ausfälle verwandelt, die Teams für Änderungen ausgeben können, und wie Burn-Rate-Alerts Menschen nur dann alarmieren, wenn dieses Budget wirklich gefährdet ist. Observability behandelt die Logs, Metriken und Traces, mit denen Fachleute einem Produktionssystem neue Fragen stellen können, die RED- und die USE-Methode und die Four Golden Signals, Distributed Tracing mit OpenTelemetry und die Kosten von Daten mit hoher Kardinalität.

Kapazitätsplanung und Performancetests schließt den Kreis zwischen Prognosen und Belegen: Last-, Stress-, Soak-, Spike- und Breakpoint-Tests, offene und geschlossene Lastmodelle, Coordinated Omission und ein Kapazitätsplan für einen Ticket-Vorverkauf. Chaos Engineering, Incidents und schuldfreies Lernen befasst sich mit den Ausfällen, die trotzdem passieren: gezielte Experimente in Produktion, um Schwachstellen zu finden, bevor die Kundschaft es tut, Incidents mit klaren Rollen und schuldfreie Reviews, deren Maßnahmen das System ändern statt der Menschen.

Wie die Abschnitte zusammenhängen

Die Abschnitte bilden eine Kette. Skalierung und Load Balancing schaffen Kapazität; Queues und Backpressure entscheiden, was passiert, wenn die Kapazität trotzdem ausgeht; Resilienzmuster verhindern, dass ein lokales Problem zu einem globalen wird. SLOs legen fest, wie gut gut genug ist, Observability zeigt, ob das System diesen Maßstab erfüllt und warum nicht, Tests und Kapazitätsplanung sagen voraus, wann es ihn nicht mehr erfüllen wird, und Chaos Engineering und Incident-Reviews finden die Lücken in all dem. Die meisten Mechanismen lassen sich beim Entwurf günstig einbauen und nur teuer nachrüsten; deshalb sind sie Architektur und kein Betriebsdetail: Ob ein Service zustandslos ist, ob ein Aufruf idempotent ist, ob eine Queue begrenzt ist und ob eine Anfrage eine Deadline mitführt, wird lange vor dem ersten Incident entschieden.

Das Kapitel setzt die verteilten Stile aus Kapitel 6 und die Datenarchitektur aus Kapitel 7 voraus. Für Idempotenzschlüssel, Zustellgarantien, Replikation und Caching verweist es auf diese Kapitel zurück, statt sie zu wiederholen, und auf Kapitel 10 voraus für die Cloud-Plattformen, Kubernetes-Funktionen und Multi-Region-Designs, auf denen diese Systeme meist laufen.

Der eine Gedanke, den Sie mitnehmen sollten

Jede Ressource ist endlich, also hat jedes System eine Belastungsgrenze; die Aufgabe der Architektur ist es, im Voraus zu entscheiden, was passiert, wenn sie erreicht ist. Ein gut entworfenes System wird unter übermäßiger Last kontrolliert langsamer, wirft die unwichtigste Arbeit zuerst ab, lehnt klar ab statt stillschweigend in einen Timeout zu laufen, isoliert den ausfallenden Teil und erholt sich von selbst, wenn der Druck nachlässt. Ein schlecht entworfenes System reiht ohne Grenze in Warteschlangen ein, wiederholt Anfragen, bis es zusammenbricht, und reißt seine Nachbarn mit. Der Unterschied besteht aus kleinen, bewussten Entscheidungen (hier ein Timeout, dort eine begrenzte Queue, ein Retry-Budget, eine Readiness-Prüfung) und aus der Gewohnheit, das System so zu messen, zu testen und aus ihm zu lernen, wie es tatsächlich läuft.

Die 8 Abschnitte

9.1 · Mittelstufe · 28 Min.SkalierungScale-up und Scale-out und ihre Grenzen, der Scale Cube von Abbott und Fisher, Zustandslosigkeit, reaktives, zeitgesteuertes und prädiktives Autoscaling, die Wahl eines Skalierungssignals, die Vermeidung von Flapping und die Dimensionierung einer Flotte für eine Lastspitze.Lesen →9.2 · Mittelstufe · 27 Min.Load BalancingLoad Balancer auf Layer 4 und Layer 7, die wichtigsten Algorithmen einschließlich der Power of Two Random Choices, Liveness- und Readiness-Checks, Connection Draining, die Probleme mit Sticky Sessions, ausgelagerter Session-Zustand und globales Load Balancing.Lesen →9.3 · Mittelstufe · 29 Min.Queues und BackpressureWie Queues Lastspitzen in Rückstände verwandeln, Competing Consumers, die Dimensionierung von Queues mit Littles Gesetz, Backpressure, Load Shedding und Priorisierung, Token Bucket und andere Rate Limiter, HTTP 429 mit Retry-After und Dead Letter Queues.Lesen →9.4 · Fortgeschritten · 32 Min.ResilienzmusterDie Stabilitätsmuster, die verhindern, dass eine einzige langsame Abhängigkeit ein ganzes System lahmlegt: Timeouts und Deadlines, Wiederholungen mit Backoff, Jitter und Budgets, Circuit Breaker, Bulkheads, Fallbacks, Idempotenz und Hedged Requests.Lesen →9.5 · Mittelstufe · 24 Min.SLOs und Error BudgetsWie Sie Zuverlässigkeit aus Sicht der Nutzer mit SLIs messen, SLO-Ziele festlegen, daraus Error Budgets und Richtlinien ableiten, nach Burn Rate alarmieren und SLAs mit sicherem Abstand lockerer halten als die internen Ziele.Lesen →9.6 · Mittelstufe · 26 Min.ObservabilityWie Sie in ein laufendes verteiltes System hineinsehen: strukturierte Logs, Metriktypen und Histogramme, RED, USE und die Four Golden Signals, verteiltes Tracing mit W3C Trace Context und OpenTelemetry, Kardinalität und symptombasiertes Alerting.Lesen →9.7 · Fortgeschritten · 25 Min.Kapazität und TestsWie Sie Kapazität planen, bevor die Nachfrage kommt, und testen, ob sie wirklich vorhanden ist: Prognosen, Reserven und Vorlaufzeiten, Last-, Stress-, Soak-, Spike- und Breakpoint-Tests, offene und geschlossene Lastmodelle, Coordinated Omission und Performancebudgets.Lesen →9.8 · Mittelstufe · 25 Min.Chaos und IncidentsWie Sie Schwachstellen finden, bevor Nutzer es tun, und aus Ausfällen lernen, die trotzdem passieren: Chaos-Experimente und Game Days, Incident Command, Schweregrade und Statusseiten, schuldfreie Reviews, die Grenzen der MTTR und Maßnahmen, die das System verändern.Lesen →

Kapiteltest

Prüfen Sie Ihr Verständnis von Kapitel 9

Optional: 20 Multiple-Choice-Fragen und 2 kurze schriftliche Antworten, jedes Mal neu aus einem Pool von 72 Fragen gezogen. Bestehensgrenze 80 %. Wer jeden Kapiteltest und anschließend die Abschlussbewertung besteht, erhält das Be Wise Abschlusszertifikat.

Den Test zu Kapitel 9 in der App ablegen

Weiterführende Literatur