The databasePart 5 of 6

Deploy ist eine Branch-Promotion, keine Migration

Ein Release in die Produktion bedeutet normalerweise, Daten zu verschieben: dev dumpen, in eine separate Prod-Datenbank zurückspielen, die Migrationen laufen lassen und hoffen, dass nichts auseinandergedriftet ist. Auf Copy-on-Write-Timelines in Postgres hat das eine ganz andere Form — Produktion ist ein Branch, und Live-Gehen ist eine Promotion. Es bewegen sich keine Bytes, wenn Prod vom Head von dev geforkt wird (und standardmäßig behält Prod nur das Schema); Re-Deploys behalten die Prod-Daten und wenden nur die ausstehenden Migrationen an; ein Rollback deployt einen gepinnten Commit erneut, optional mit einem Point-in-Time-Restore der Daten; und jede Umgebung skaliert unabhängig auf null. Hier sind das Modell und die Mechanik darunter.

Deploy ist eine Branch-Promotion, keine Migration

Der übliche Weg in die Produktion verschiebt Daten. Du ziehst einen Snapshot von dev, spielst ihn in eine separate Prod-Datenbank zurück, lässt dort die Migrationen laufen und hoffst, dass die beiden Schemas zwischenzeitlich nicht auseinandergedriftet sind. Jetzt betreibst du zwei Datenbanken, die gleich sein sollen und es langsam nicht mehr sind — und der Kopierschritt wird träger, je mehr deine Daten anwachsen.

Wenn deine Datenbanken Copy-on-Write-Timelines auf einem gemeinsamen Page-Store sind, hat ein Deploy eine völlig andere Form. Produktion ist keine separate Datenbank, in die du hineinkopierst — sie ist ein Branch. Live-Gehen ist eine Promotion: eine Metadaten-Operation, die einen Pointer verschiebt, keine Bytes. Dieser Beitrag ist das Modell, um das herum die Timeline-Architektur der Plattform gebaut ist — und die Mechanik darunter.

Er baut auf zwei Primitiven auf, die anderswo behandelt werden: Copy-on-Write-Branching an einer LSN und Scale-to-Zero-Compute. Falls dir das neu ist, überflieg sie zuerst — dieser Beitrag setzt sie zusammen.


Das Modell: Prod ist ein dauerhafter Branch, geforkt von dev

Die Datenbank eines Projekts ist eine Timeline. Im Alltag ist diese Timeline die dev-Umgebung — hier baut und iteriert der Agent. Die Produktion ist eine zweite Timeline: ein dauerhafter Branch, auf den der Traffic der Nutzer trifft.

Der erste Deploy forkt den aktuellen Head von dev in eine neue, dauerhafte Prod-Timeline. Ab da ist Prod seine eigene Timeline, die die Daten echter Nutzer tragen wird, und dev läuft unberührt auf seiner eigenen Timeline weiter. Weil Branching O(1) Copy-on-Write ist, kopiert der Fork keine Daten. Die Datenbankseite eines Deploys kostet gleich viel, ob die Datenbank ein Kilobyte oder hundert Gigabyte hält.

Womit Prod startet, ist eine eigene Entscheidung. Eine dev-Datenbank ist voller Demo- und Faker-Zeilen, die in einer Live-App nichts verloren haben, deshalb startet die Produktion standardmäßig nur mit dem Schema. Ein Copy-on-Write-Fork lässt sich nicht leer anlegen, also forkt der Release zuerst und leert die Tabellen der App, sobald das Prod-Compute läuft. Wer deployt, kann stattdessen die Zeilen von dev übernehmen (copyDevData). Die Verifikations-Accounts der Plattform werden auch dann entfernt, bevor die App live geht.

first deploy: fork dev head → prod

shared history up to the fork

dev timeline
agent builds here · keeps running

prod timeline
durable · customer traffic

Eine Konsequenz ergibt sich direkt aus „Prod und dev sind dieselbe Engine, einen Branch auseinander": kein Provisioning-Drift. Prod ist keine separat hochgezogene Datenbank, die du per Dump und Restore befüllst. Es ist ein Fork, der beim Abzweigen das Migrations-Ledger von dev geerbt hat. Ein Deploy wendet nur die wirklich ausstehenden Migrationen an (das DDL, das dev ausgeführt hat und Prod noch nicht), also entsteht keine „läuft auf dev, bricht auf Prod"-Lücke, wie sie zwei unabhängig provisionierte und migrierte Datenbanken aufreißen.


Die Mechanik der Promotion

Die erste Promotion ist ein einziger Metadaten-Schritt: den Head von dev in eine dauerhafte Prod-Timeline forken. Die Entscheidung ist rein — anhand der aktuellen Branches, was zu Prod wird — und die Ausführung ist eine Branch-Operation ohne Datenkopie:

pageserverneon-conn-proxybackend (promotion)deploy triggerpageserverneon-conn-proxybackend (promotion)deploy triggerpromoteToProduction(project)planPromotion(branches) %% pick the dev-serving timelinefork dev head → prod timeline (O(1), CoW)create_timeline(ancestor=dev head)record prod branchprovision prod compute credentials (Vault + proxy cache)setServingBranch("prod")release flip step: neon-compute-prod in proj-{id}-prod

Die Promotion-Logik ist eine kleine reine Funktion — planPromotion —, die auf die Branches des Projekts schaut und entscheidet, welche Timeline zu Prod wird (und ein No-op ist, wenn dev bereits gleich Prod ist). Die Ausführungsschicht, promoteToProduction, forkt den Head von dev, verzeichnet den neuen Prod-Branch, provisioniert dafür die Zugangsdaten des Prod-Computes und markiert ihn erst dann als den Branch, der prod ausliefert — so liefert Prod nie eine Timeline aus, mit der sich nichts verbinden kann. Das Prod-Compute selbst lebt in einem eigenen Namespace, proj-{id}-prod. Der Flip-Schritt des Releases legt diesen Namespace samt Quota an und wendet dort neon-compute-prod an.

Das war die erste Promotion. Ein Re-Deploy forkt nicht neu: Er behält die laufende Prod-Timeline, die Daten echter Nutzer bleiben also über Releases hinweg erhalten. Er setzt vor dem Deploy einen LSN-Checkpoint auf den Head von Prod, als Rollback-Anker (anchorProdRedeploy; ein Re-Deploy ohne Anker wird abgelehnt), pinnt den frisch releasten Commit und wendet die ausstehenden db/migrations jeder App als forward-only DDL auf Prod an (migrateProduction → runPendingMigrations(…, { env: "prod" })). Ein Deploy führt also sehr wohl Schema-Migrationen gegen Prod aus; was er nie tut, ist Daten kopieren. Prod-Daten mit denen von dev zu überschreiben, verlangt eine ausdrückliche Entscheidung des Owners und ist nie ein Seiteneffekt des Ausrollens. Solche Entscheidungen gibt es genau zwei: einen Daten-Reset oder einen frischen Start von dev, wenn nach einem Undeploy, der die alten Daten behalten hat, erneut deployt wird. Beide legen vorher einen Restore-Punkt auf den Daten an, die sie ersetzen.

Einen schlechten Deploy zurückzurollen heißt, den gepinnten Commit eines früheren Releases erneut zu deployen. Das Release-Ledger ist append-only und jeder Release ist an einen Git-Commit gepinnt, der alte Code ist also exakt derselbe. Die Daten wiederherzustellen ist optional und nutzt dasselbe Branch-an-einer-LSN-Primitiv wie Time-Travel. Restore-Punkt ist der Pre-Deploy-Checkpoint des Releases, der den Ziel-Release abgelöst hat. Der Rollback forkt Prod von dort und biegt das Prod-Compute auf den Fork um. Kein Restore aus dem Backup, und die Daten werden wiederhergestellt, bevor der alte Code zurückkommt — alter Code liefert also nie Daten aus, die erst nach ihm entstanden sind.


Getrenntes Compute pro Umgebung — und beide skalieren auf null

Prod und dev müssen gleichzeitig live sein: Kunden treffen auf Prod, während der Agent auf dev weiter iteriert. Ein einzelner Postgres-Prozess ist beim Start an eine Timeline gebunden, also bekommen die Umgebungen getrennte Computes — neon-compute für dev, neon-compute-prod für Prod — jedes auf seine eigene Timeline gerichtet.

Das klingt nach doppelten Kosten, und das wäre es auch, würden nicht beide Computes unabhängig auf null skalieren (der Scale-to-Zero-Proxy routet pro Umgebung nach Datenbanknamen und weckt jedes bei Bedarf):

  • App ohne Besucher und niemand baut → beide auf null.
  • Ein Kunde kommt vorbei → Prod wacht auf; dev bleibt auf null.
  • Der Agent iteriert → dev wacht auf; Prod bleibt auf null.

Du zahlst pro zugegriffener Umgebung, nicht pro provisionierter. Die Manifeste werden pro Umgebung aus einer einzigen Vorlage generiert (generateNeonComputeManifests(projectId, { env })), ein Prod-Compute ist also dasselbe Ressourcen-Set wie dev, nur mit eigenem Namen, eigenem Namespace und eigener Timeline.

Die Materialisierung ist lazy: ein Projekt, das noch nie deployt wurde, hat genau ein Compute (dev). Die Prod-Timeline und ihr Compute entstehen erst bei der ersten Promotion — der lange Schwanz nie deployter Experimente trägt also überhaupt keinen Prod-Overhead.


Was dir das bringt

  • Die Datenbankseite eines Deploys ist sofort fertig und unabhängig von der Datenmenge. Es ist ein Fork plus ein Pointer-Move, kein Dump/Restore. Eine 50-GB-Datenbank wird genauso schnell promotet wie eine leere.
  • Prod-Daten sind dauerhaft. Der erste Deploy startet Prod standardmäßig leer; Re-Deploys behalten die Daten und migrieren sie nur vorwärts. Dev-Daten erreichen eine Live-Prod nur durch eine ausdrückliche Entscheidung des Owners, abgesichert durch einen Restore-Punkt.
  • Kein Provisioning-Drift. Dieselbe Engine, einen Branch auseinander — Prod wurde von dev geforkt und hat dessen Migrations-Ledger geerbt, ein Deploy wendet also nur das ausstehende DDL an, nie einen blinden Full-Re-Run gegen eine separat gebaute Datenbank.
  • Rollback ist exakt, auf Wunsch inklusive Daten. Den gepinnten Commit erneut deployen; optional die Prod-Daten auf den Stand dieses Releases zurücksetzen — mit derselben Branch-an-einer-LSN-Operation wie Code-und-Daten-Time-Travel, angewandt auf Prod.
  • Leerlauf ist kostenlos, pro Umgebung. Scale-to-Zero auf jedem Compute heißt, die zweite Umgebung ist kein stehender Kostenfaktor; sie ist da, wenn darauf zugegriffen wird, und weg, wenn nicht.

Die Form der Sache

Hör auf, dir die Produktion als einen Ort vorzustellen, an den du deine Datenbank kopierst, und fang an, sie als einen Branch zu begreifen, den du promotest. Auf Postgres mit getrenntem Storage und Compute hört „Deploy" auf, ein Datenmigrations-Ereignis mit Kopierschritt und Drift-Risiko zu sein, und wird zu dem, was es sein sollte: einen Pointer verschieben, der sagt „diese Version bekommen die Kunden". Der Storage war schon da — geteilt, Copy-on-Write, einen Branch von jeder Umgebung entfernt.

Bau auf der Plattform, die diese Beiträge beschreiben.

Beschreib deine App in einfachem Deutsch — igentik schreibt den Code, richtet die Datenbank ein und bringt sie live.

Kostenlos loslegen