Datenbankmigration ohne Ausfallzeit: ein Playbook für die Produktion
Die meisten Migrationsausfälle entstehen aus einem einzigen Fehler: eine Schemaänderung und den davon abhängigen Code im selben Atemzug auszuliefern. Entkoppeln Sie beides, lassen Sie Alt und Neu eine Weile nebeneinander laufen, und die furchteinflößenden Teile werden langweilig. Hier ist das Playbook, das wir nutzen, um Schemata zu ändern und Datenbanken in der Produktion ohne Wartungsfenster zu verschieben.
Die Gliederung8
- Was "keine Ausfallzeit" wirklich bedeutet
- Das Expand-Contract-Muster ist das ganze Spiel
- Dual-Write: beide Kopien ehrlich halten
- Backfill, ohne die Datenbank zu schmelzen
- Validieren, bevor Sie der neuen Kopie vertrauen
- Locking ist die wahre Quelle der Ausfallzeit
- Umzug auf eine neue Datenbank: Bulk-Load, CDC, Cutover
- Wo das zu unserer Arbeitsweise passt
Was "keine Ausfallzeit" wirklich bedeutet
Keine Ausfallzeit bedeutet keine Magie. Es bedeutet, dass es nie einen Moment gibt, in dem die laufende Anwendung nicht lesen und schreiben kann, was sie braucht. Die ehrliche Version, geborgt von Leuten, die beruflich große Datenbanken verschieben, lautet "Cutover nahe null": Der neue Zustand spiegelt den alten eng genug wider, dass Nutzer nie eine Lücke bemerken.
Unter derselben Formulierung verbergen sich zwei verschiedene Probleme, und sie brauchen verschiedene Taktiken. Das erste ist Schemaevolution: das Ändern von Tabellen, Spalten, Typen und Constraints innerhalb einer Datenbank, die an Ort und Stelle bleibt. Das zweite ist Verlagerung: das Verschieben von Daten in eine neue Datenbank, eine neue Engine oder eine neue Region. Die verbindende Regel für beide ist dieselbe. Eine Migration muss abgeschlossen werden, während der alte Anwendungscode noch läuft, und der neue Code muss während der Überlappung gegen die alte und die neue Form funktionieren. Entkoppeln Sie die Schemaänderung vom Deploy, und die ganze Sache hört auf, ein einziges schreckliches Ereignis zu sein.
Das Expand-Contract-Muster ist das ganze Spiel
Fast jede sichere Schemaänderung ist eine Variante von Expand-Contract, auch Parallel Change genannt. Statt einer atomaren Migration, die alles auf einmal umlegt, teilen Sie die Arbeit in Phasen auf, die jeweils unabhängig ausgeliefert werden und jeweils rückwärtskompatibel bleiben.
Expand: Fügen Sie die neue Spalte, Tabelle oder den neuen Index neben der alten hinzu. Nichts bricht, weil nichts entfernt wird. Die Anwendung beginnt, in beide Repräsentationen zu schreiben (Dual-Write), liest aber weiterhin aus der alten.
Migrate: Füllen Sie historische Zeilen in die neue Form nach, validieren Sie dann, und schalten Sie dann die Lesezugriffe auf die neue Spalte um, während der Dual-Write weiterläuft.
Contract: Hören Sie auf, in die alte Spalte zu schreiben, benennen Sie sie um, damit jede vergessene Referenz laut scheitert, beobachten Sie, und erst dann löschen Sie sie.
Der Grund, warum das funktioniert, ist, dass die Grenze zwischen den Phasen der Ort ist, an dem Sie ausliefern und beobachten. Wenn etwas nicht stimmt, ist die vorherige Phase noch voll funktionsfähig. Sie können unbegrenzt pausieren, statt eine halb angewendete Änderung umzukehren, während die Pager losgehen. Rein additive Änderungen sind der einfache Fall, alter Code ignoriert die neue Spalte einfach. Die Disziplin zählt am meisten, wenn Sie etwas ändern oder entfernen, von dem die laufende App abhängt.
Dual-Write: beide Kopien ehrlich halten
Während des Überlappungsfensters muss jeder Schreibvorgang sowohl am alten als auch am neuen Ort landen, sonst fällt die neue Kopie still zurück. Sie haben zwei Möglichkeiten, das zu tun, und die Wahl hat reale Konsequenzen.
Dual-Write auf Anwendungsebene bedeutet, dass Ihr Code explizit an beide Orte schreibt. Es taucht in Traces und Logs auf, sodass Sie bei einer Divergenz über den Observability-Stack debuggen können, dem Sie bereits vertrauen. Datenbank-Trigger können Spalten mit weniger App-Code synchron halten, aber das Verhalten passiert innerhalb der Datenbank, wo Ihr normales Werkzeug es nicht sehen kann, was das Debugging zur Qual macht. Für die meisten Teams sind die kleinen Kosten eines expliziten App-Schreibvorgangs die Nachvollziehbarkeit wert.
Die scharfe Kante des Dual-Write ist, dass zwei Schreibvorgänge keine eine atomare Transaktion sind. Wenn der erste gelingt und der zweite scheitert, driften die Kopien auseinander. Für alles, wo das zählt, leiten Sie Schreibvorgänge über ein transaktionales Outbox oder eine queue-basierte Propagation, sodass eine einzige committete Transaktion die Quelle der Wahrheit ist und der zweite Schreibvorgang daraus abgeleitet wird. Hier verfolgt auch ein Werkzeug wie pgroll auf Postgres einen anderen Ansatz: Es stellt versionsspezifische Views bereit, sodass alte und neue App-Versionen jeweils das Schema sehen, das sie erwarten, und behandelt die duale Logik auf der Datenbankebene statt in Ihrem Code.
Backfill, ohne die Datenbank zu schmelzen
Neue Schreibvorgänge gehen in dem Moment, in dem Dual-Write aktiv ist, an beide Kopien, aber historische Zeilen bewegen sich nicht von selbst. Backfill kopiert die vorhandenen Daten in die neue Form. Tun Sie es in Batches, typischerweise ein paar tausend Zeilen auf einmal, mit einer bewussten Pause zwischen den Batches, damit Sie nicht die I/O sättigen und den Live-Traffic aushungern.
Halten Sie den Backfill in einem von der Schemaänderung getrennten Job. Eine NOT-NULL-Spalte mit Default hinzuzufügen und Millionen Zeilen in derselben Migration nachzufüllen, ist die Art, wie aus einer Zwei-Sekunden-Änderung ein stundenlanger Lock wird. Auf Postgres fügen Sie ein NOT-NULL-Constraint zuerst als NOT VALID hinzu, was sofort geht, weil es den Tabellenscan überspringt, und führen dann VALIDATE CONSTRAINT separat aus, das einen leichteren Lock nimmt, der Lese- und Schreibvorgänge fortsetzen lässt.
Planen Sie schwere Backfills für verkehrsarme Fenster, drosseln Sie sie und beobachten Sie Ihre Replikate. Wenn Sie Read-Replikate betreiben, können diese kurzzeitig ein anderes Schema als das Primary tragen, also muss die App diese Verzögerung während der Migration tolerieren.
Validieren, bevor Sie der neuen Kopie vertrauen
Zeilen zu zählen ist keine Validierung. Zeilenzahlen können übereinstimmen, während die Inhalte abweichen. Bevor Sie die Lesezugriffe verschieben, verifizieren Sie mit Prüfsummen oder Hashes auf den kritischen Tabellen und Invarianten-Checks auf gesampelten Daten, nicht nur mit Summen. Wenn Sie für einige Abfragen bereits aus beiden Kopien lesen, ist ein Vergleich auf Anwendungsebene, der Abweichungen in Echtzeit markiert, das stärkste Signal, das Sie bekommen können.
Der Backfill ist auch Ihre Chance, die Datenqualität zu reparieren. Das Migrieren historischer Zeilen bringt die Inkonsistenzen an die Oberfläche, die die Produktion seit Jahren still toleriert hat, also behandeln Sie den Backfill als Bereinigungslauf, nicht nur als Kopie.
Schneiden Sie den Dual-Write nicht zu früh ab. Halten Sie beide Kopien für mindestens einen vollen Geschäftszyklus nach dem Umschalten der Lesezugriffe live und synchronisiert. Den alten Pfad früh zu deaktivieren versteckt Abweichungen, die Sie noch nicht erwischt haben, und nimmt Ihnen Ihr billigstes Rollback.
Locking ist die wahre Quelle der Ausfallzeit
Das DDL-Statement selbst ist meist schnell. Der Ausfall kommt von der Lock-Contention drumherum. Ein häufiges Versagen: Ein ALTER fordert einen exklusiven Lock an, bleibt hinter einer langlaufenden Transaktion oder einer vergessenen offenen Session stecken, und jede Abfrage, die danach ankommt, reiht sich hinter dem Lock ein. Eine einfache Schemaänderung eskaliert zu einem dienstweiten Stillstand.
Wehren Sie sich. Setzen Sie immer ein kurzes lock_timeout, damit ein blockiertes DDL schnell scheitert, statt die Warteschlange zu verstopfen. Auf Postgres bauen Sie Indizes mit CREATE INDEX CONCURRENTLY, sodass Schreibvorgänge während des Baus weiterlaufen, und denken Sie daran, dass es auf Transaktionen wartet, die vor ihm begonnen haben, also beenden Sie zuerst verirrte langlaufende Abfragen. Postgres wickelt DDL zudem in Transaktionen ein, sodass eine fehlgeschlagene Migration sauber zurückrollt.
Auf MySQL ist das Bild versionsabhängig. Prüfen Sie, ob Ihre Änderung ALGORITHM=INPLACE, LOCK=NONE unterstützt, und beachten Sie, dass einige Operationen vor 8.0.29 die ganze Tabelle neu aufbauen und Schreibvorgänge blockieren. Für Tabellen mit hoher Zeilenzahl, bei denen selbst ein Online-ALTER riskant ist, greifen Sie zu einem externen Werkzeug: gh-ost oder pt-online-schema-change auf MySQL, pgroll oder pg_osc auf Postgres. Sie bauen eine Schattenkopie, synchronisieren sie in Chunks und tauschen atomar, während das Original voll nutzbar bleibt.
Umzug auf eine neue Datenbank: Bulk-Load, CDC, Cutover
Eine Datenbank zu verlagern, über Engines, Versionen oder Regionen hinweg, folgt drei Phasen. Erstens stellt ein Bulk-Load eine Baseline her: ein nativer Dump und Restore oder ein Snapshot in das Ziel. Zweitens streamt Change Data Capture oder logische Replikation jeden Insert, Update und Delete von der Quelle zum Ziel, sodass die Lücke weiter Richtung nahezu null Lag schrumpft. Für Umzüge innerhalb derselben Engine ist Postgres-Logical-Replication oder MySQL-Binlog-Replication meist der sauberste Weg, und logische Replikation überspannt sogar Major-Versionen. Wenden Sie das Schema zuerst auf dem Ziel an, weil logische Replikation kein DDL überträgt.
Drittens ist der Cutover. Planen Sie ihn als ein Read-only-Fenster von Sekunden, nicht Minuten: Stoppen Sie kurz die Schreibvorgänge auf der Quelle, bestätigen Sie, dass der Replikations-Lag null erreicht hat, und leiten Sie dann den Traffic um, indem Sie den Connection-String, das DNS oder die Load-Balancer-Route tauschen. Achten Sie auf Sequence- und Auto-Increment-Drift: Wenn die Sequenz des Ziels der Quelle hinterherhinkt, kollidieren neue Inserts mit replizierten IDs. Führen Sie nach dem Cutover VACUUM/ANALYZE oder OPTIMIZE TABLE aus und fahren Sie die Quelle nicht herunter. Halten Sie sie live, idealerweise read-only, für mindestens 24 Stunden als Ihr Rollback. Bevor irgendetwas davon die Produktion berührt, machen Sie einen vollständigen Probe-Cutover in Staging gegen Daten in Produktionsgröße, denn eine Änderung, die auf einem Laptop zwei Sekunden dauert, kann bei echtem Volumen Stunden dauern.
Wöchentliche Impulse für den Betrieb
Schließen Sie sich Betreibern von Dienstleistungsunternehmen an, die jede Woche einen umsetzbaren Impuls zu Betrieb, Automatisierung und Wachstum erhalten.
Kein Spam. Jederzeit abbestellbar.
Sie sind angemeldet! Die nächste Ausgabe kommt in Ihr Postfach.
Das hat nicht geklappt. Bitte versuchen Sie es erneut oder schreiben Sie an [email protected].
Wo das zu unserer Arbeitsweise passt
Keiner dieser Schritte ist für sich genommen schwer. Das Risiko liegt darin, sie korrekt zu sequenzieren, zu wissen, in welcher Phase Sie sicher pausieren können, und ein Rollback zu haben, das unter Druck wirklich funktioniert. Genau diese Art von Arbeit ist das, wofür unsere Sprints mit festem Umfang über 30 Tage gemacht sind: eine klar definierte Migration, geplant als Expand-Migrate-Contract, mit dem Runbook für Backfill, Validierung und Cutover aufgeschrieben und geprobt, bevor irgendetwas ausgeliefert wird.
Wenn Sie ganz von einem alten System wegmigrieren, statt das aktuelle umzuformen, treiben dieselben Prinzipien eine saubere Außerbetriebnahme: Doppelbetrieb, den neuen Pfad beweisen, dann den alten auf einer dokumentierten Zeitleiste stilllegen. Und wenn Sie es lieber hätten, dass jemand die übergreifende Daten- und Infrastrukturstrategie über mehrere dieser Änderungen hinweg verantwortet, ist das Fractional-CTO-Terrain. So oder so ist das Ziel dasselbe wie bei diesem ganzen Artikel: die Migration langweilig zu machen.
Bereit zum Launch?
Sagen Sie uns, wo Sie feststecken. Wir prüfen es und senden Ihnen innerhalb eines Werktags eine konkrete Empfehlung.
Häufig gestellte Fragen
Kann ich eine Migration ohne Ausfallzeit in einem einzigen Deploy machen?
Nein, nicht für irgendetwas jenseits einer rein additiven Änderung. Eine sichere Migration, die eine Spalte oder Tabelle ändert oder entfernt, braucht mindestens zwei Release-Zyklen: einen, um die neue Struktur hinzuzufügen, per Dual-Write zu schreiben und nachzufüllen, und einen späteren, um die Lesezugriffe umzuschalten und die alte Struktur zu löschen. Der ganze Sinn besteht darin, alten Code während der Überlappung gegen das neue Schema funktionsfähig zu halten, was ein einzelner atomarer Deploy nicht garantieren kann.
Sollte Dual-Write in der Anwendung oder in Datenbank-Triggern leben?
Bevorzugen Sie in den meisten Fällen die Anwendungsebene. Explizite Dual-Writes erscheinen in Ihren Traces und Logs, sodass Sie bei einer Divergenz der beiden Kopien mit den Observability-Tools debuggen können, die Sie bereits nutzen. Trigger halten die Logik aus Ihrem Code heraus, laufen aber innerhalb der Datenbank, wo Ihr normales Tracing sie nicht sehen kann, was Vorfälle viel schwerer diagnostizierbar macht. Für atomaritätskritische Schreibvorgänge leiten Sie über ein transaktionales Outbox oder eine Queue, damit Divergenz nicht still geschehen kann.
Wie verifiziere ich, dass die alten und neuen Daten wirklich übereinstimmen?
Verlassen Sie sich nicht auf Zeilenzahlen. Verwenden Sie Prüfsummen oder Hashes auf Ihren kritischen Tabellen plus Invarianten-Checks auf gesampelten Zeilen, denn Zahlen können übereinstimmen, während Inhalte abweichen. Wenn Ihre App für einige Abfragen bereits aus beiden Kopien liest, fügen Sie einen Echtzeitvergleich hinzu, der Abweichungen markiert. Lassen Sie den Dual-Write laufen und gleichen Sie für mindestens einen vollen Geschäftszyklus nach dem Umschalten der Lesezugriffe ab, bevor Sie der neuen Kopie allein vertrauen.
Warum verursacht eine schnelle Schemaänderung trotzdem einen Ausfall?
Fast immer Lock-Contention, nicht das DDL selbst. Ein ALTER, das einen exklusiven Lock braucht, kann hinter einer langlaufenden Transaktion oder einer vergessenen offenen Session stecken bleiben, und jede danach ankommende Abfrage reiht sich hinter dem Lock ein, was eine schnelle Änderung in einen dienstweiten Stillstand verwandelt. Setzen Sie ein kurzes lock_timeout, damit blockiertes DDL schnell scheitert, nutzen Sie CREATE INDEX CONCURRENTLY auf Postgres und räumen Sie verirrte langlaufende Abfragen ab, bevor Sie beginnen.
Was ist mit Tabellen, die zu groß für ein normales ALTER sind?
Nutzen Sie ein Online-Schema-Change-Werkzeug, das eine Schattenkopie baut und sie einwechselt. Auf MySQL kopieren gh-ost oder pt-online-schema-change Daten in Chunks und tauschen atomar, während das Original nutzbar bleibt. Auf Postgres behandelt pgroll das Expand-Contract-Muster mit versionsbewussten Views, oder pg_osc behandelt einmalige große Änderungen. Sie müssen Locking trotzdem verstehen; die Werkzeuge verwalten die Datei und Ausführung, aber lock_timeout, CONCURRENTLY und kleine sichere Schritte liegen weiterhin bei Ihnen.
Wie sieht ein echter Rollback-Plan aus?
Rollback wird einfacher, je früher Sie in den Phasen sind. Aus der Expand-Phase ist die neue Spalte additiv und für Lesezugriffe ungenutzt, also entfernen Sie einfach den Dual-Write-Code und liefern aus. Mitten im Cutover schalten Sie das Lese-Flag zurück auf die alte Spalte, lassen den Dual-Write laufen und untersuchen, ohne die neuen Daten zu verlieren. Beim Verlagern auf eine neue Datenbank halten Sie die Quelle nach dem Cutover für mindestens 24 Stunden live und read-only, damit Sie den Traffic zurückleiten können, falls etwas auftaucht.