Vom Monolithen zu Microservices: eine Schritt-für-Schritt-Migrationsstrategie

Die meisten Microservices-Migrationen scheitern aus denselben wenigen Gründen: falsche Grenzen, eine Neuschreibung auf einen Schlag und eine Datenschicht, die niemand geplant hat. Hier ist ein in Schritten geordneter Leitfaden, der alle paar Wochen Wert liefert und es dir erlaubt aufzuhören, sobald die Rechnung nicht mehr aufgeht.

4 Min. Lesezeit7 Abschnitte22. Juni 2026

Geschrieben von

Kostadin Stamboliev

Gründer und Imaginator

Gründer und Imaginator von Pineido. Arbeitet in IT-Beratung, App- und Webentwicklung, technischem SEO sowie KI und Automatisierung. Liefert Produktionscode in 30-Tage-Sprints mit festem Umfang und klarer Verantwortung.

LinkedIn

Entscheide zuerst, ob du überhaupt migrieren solltest

Die ehrliche Antwort für viele Teams lautet: noch nicht. Die CNCF-Umfrage 2025 ergab, dass rund 42% der Organisationen, die Microservices eingeführt haben, einige Services wieder in größere Einheiten zurückführen, weil die Betriebskosten den Nutzen übertroffen haben. Eine gängige Schwelle aus der Praxis: unter etwa 30 Entwicklern oder bei einem Monolithen unter 100.000 Zeilen fügen Microservices meist Kosten mit wenig Ertrag hinzu. Migriere, wenn mehrere Teams beim Bearbeiten derselben Codebasis blockiert sind, wenn eine Funktion wirklich andere Skalierungsbedürfnisse als der Rest hat oder wenn eine Fähigkeit ihr eigenes dediziertes Team und ihren eigenen Release-Takt braucht. Wenn der Treiber nur ist, dass sich Monolithen alt anfühlen, behebe zuerst die Modularität innerhalb des Monolithen (einen modularen Monolithen) und spare dir die Steuer der verteilten Systeme.

Nutze das Strangler-Fig-Pattern, keine Neuschreibung auf einen Schlag

Komplette Neuschreibungen sind der zuverlässigste Weg zu scheitern: lange Zeitpläne, verdreifachte Cloud-Rechnungen und Produktionsausfälle, die niemand eingrenzen kann, weil sich alles auf einmal geändert hat. Das Strangler-Fig-Pattern, von Martin Fowler bereits 2004 benannt, lässt das neue System um das alte herum wachsen und zieht den Monolithen Stück für Stück aus dem Verkehr. Du führst eine Fassade ein (meist dein API-Gateway oder eine Routing-Schicht wie Istio oder einen Envoy-basierten Proxy), die jede Anfrage abfängt. Anfangs leitet sie nahezu alles an den Monolithen. Während du jede Funktion herauslöst, schaltest du ihre Route auf den neuen Service um. Nutzer sehen nie einen Stichtag. Und bei jedem Schritt ist der alte Codepfad noch da, was dein sofortiges Rollback ist, falls sich der neue Service danebenbenimmt.

Ziehe Grenzen nach Geschäftsdomäne, nicht nach technischer Schicht

Die Ursache Nummer eins gescheiterter Migrationen ist die Aufteilung nach technischer Schicht: ein UI-Service, ein Logik-Service, ein Datenbank-Service. Das erzeugt einen verteilten Monolithen, den ganzen Netzwerk-Overhead ohne jegliche Unabhängigkeit. Teile stattdessen nach Geschäftsfähigkeit auf: Bestellungen, Inventar, Zahlungen, Benachrichtigungen. Der schnellste Weg, diese Linien zu finden, ist ein Event-Storming-Workshop (die Technik von Alberto Brandolini): Bring Domänenexperten und Ingenieure in einen Raum, kartiere als Zeitlinie von Ereignissen, was im System geschieht, und gruppiere sie dann. Bounded Contexts treten dort hervor, wo sich die Sprache ändert. Produkt in einem Katalogkontext (Name, Bilder, SEO) ist etwas anderes als Produkt im Inventar (SKU, Lager, Nachbestellschwelle). Bemiss sie am Verhalten, nicht an Entitäten, sonst landest du bei anämischen Services, die für sich allein nichts tun.

Beginne an den Rändern, arbeite dich dann nach innen vor

Der Instinkt ist, zuerst den einfachen Kern herauszulösen: Authentifizierung, Benutzerverwaltung, das zentrale Domänenmodell. Widerstehe ihm. Das sind genau die Teile, von denen alles andere abhängt, also bricht ihr Zerbrechen das gesamte System. Beginne an den Rändern, den Blattfunktionen mit wenigen eingehenden Abhängigkeiten und klaren API-Grenzen. Ein Reporting-Endpunkt, ein Benachrichtigungs-Worker, ein PDF- oder Export-Job, eine öffentliche Nur-Lese-API. Diese verschaffen dir einen echten Produktionserfolg, weisen die Pipeline nach (Gateway-Routing, Deployment, Observability) und bauen den Rückhalt der Führung auf, den du brauchst, um es zu Ende zu bringen. Eine risikoarme erste Scheibe zu wählen ist auch das, was eine Migration davor bewahrt, in einem dauerhaft halb-und-halb Frankenstein steckenzubleiben, der häufigsten Art, wie diese Projekte still und leise sterben.

Teile die Daten mit CDC auf, nicht mit Doppelschreibungen

Daten sind der schwierigste Teil jeder Migration, und Doppelschreibungen (die App schreibt sowohl in die alte als auch in die neue Datenbank) sind eine Falle: gleichzeitige Schreibvorgänge verlieren stillschweigend Daten, und du hast keine Transaktionsgarantie über zwei Stores hinweg. Nutze stattdessen logbasiertes Change Data Capture. Debezium (2.x und neuer, mit Konnektoren für PostgreSQL, MySQL, MongoDB, SQL Server und Oracle) liest das Transaktionslog der Datenbank und gibt für jede committete Änderung ein Ereignis aus, sodass der neue Service seinen eigenen Datenspeicher aufbauen und synchron halten kann, ohne den Schreibpfad des Monolithen zu berühren. Jüngere Versionen fügten sperrfreie inkrementelle Snapshots und bessere Exactly-once-Semantik hinzu. Für neue Services, die ihre eigenen Ereignisse zuverlässig veröffentlichen müssen, kombiniere CDC mit dem Outbox-Pattern: Schreibe die Geschäftszeile und die Ereigniszeile in einer lokalen Transaktion und lass CDC sie weiterleiten. Und akzeptiere den echten Kompromiss von vornherein: serviceübergreifende ACID-Transaktionen sind weg. Wo du früher alles in eine Transaktion gewickelt hast, entwirfst du jetzt für eventuelle Konsistenz mit Sagas.

Stelle eine Funktion nach der anderen um und verifiziere parallel

Pro Funktion lautet die Schleife: Löse den Service heraus, richte einen kleinen Teil des Verkehrs über das Gateway auf ihn und lass den alten und den neuen Pfad nebeneinander laufen, während du die Ergebnisse vergleichst. Werkzeuge zum Aufteilen des Verkehrs (Istio, Linkerd oder ein Envoy-Gateway) lassen dich 1%, dann 10%, dann 100% verschieben und in Sekunden zurückrollen, indem du die Route rückgängig machst. Stelle Observability vor dem Herauslösen auf, nicht nach dem ersten Vorfall: strukturierte Logs, verteiltes Tracing (OpenTelemetry) und Metriken pro Service in Prometheus oder dem APM deiner Wahl. Der Grund, warum Teams Microservices bereuen, ist meist betrieblich: eine App durch fünfzig zu ersetzen bedeutet rund fünfzigmal so viele Deployments, Logs und Dashboards, also muss die Plattform bereit sein, bevor die Services eintreffen. Sobald eine Funktion bei vollem Verkehr sauber gelaufen ist, lösche den toten Codepfad im Monolithen. Erst wenn die letzte Funktion draußen ist, nimmst du den Monolithen außer Betrieb. Das Ziel ist ein klares Endspiel, nicht zwei Systeme, die du für immer hütest.

Setze realistische Zeitpläne und eine Abbruchbedingung

Unabhängige Analysen von Unternehmensmigrationen beziffern den typischen Ende-zu-Ende-Zeitplan für ein großes System auf etwa 18-36 Monate, wobei eine Handvoll Risikofaktoren (Grenzen, Daten, betriebliche Reife) für die meisten Misserfolge verantwortlich ist. Budgetiere die Plattformarbeit, nicht nur die Services: CI/CD, Container-Orchestrierung, Tracing und Bereitschaftsdienst müssen alle parallel reifen. Ebenso wichtig: definiere im Voraus eine Abbruchbedingung. Weil der Strangler-Ansatz alle paar Wochen funktionierende Software liefert, darfst du innehalten, sobald die schmerzhaften Teile draußen sind und der Rest des Monolithen dort, wo er ist, in Ordnung ist. Eine teilweise Migration ist ein legitimes, oft optimales Ergebnis. Das Scheitern besteht nicht darin, früh aufzuhören, sondern sich durch Services zu quälen, die sich nie hätten bewegen müssen.

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.

Wir prüfen kurz, ob Sie ein Mensch sind. Gleich können Sie senden.

Kein Spam. Jederzeit abbestellbar.

Sie sind angemeldet! Die nächste Ausgabe kommt in Ihr Postfach.

Häufig gestellte Fragen

Was ist das Strangler-Fig-Pattern bei einer Migration?

Es ist ein schrittweiser Ansatz, bei dem du neue Services um den bestehenden Monolithen herum wachsen lässt und ihn Stück für Stück aus dem Verkehr ziehst. Eine Routing-Schicht (meist dein API-Gateway) sitzt davor, schickt den Großteil des Verkehrs an den Monolithen, und du schaltest die Route jeder Funktion auf einen neuen Service um, sobald dieser bereit und verifiziert ist. Es gibt keinen Stichtag, und der alte Codepfad ist bei jedem Schritt dein Rollback.

Wie lange dauert eine Migration vom Monolithen zu Microservices?

Für ein großes Unternehmenssystem beziffern unabhängige Analysen den typischen Zeitplan auf etwa 18-36 Monate Ende zu Ende, einschließlich der Plattformarbeit (CI/CD, Orchestrierung, Observability), von der die Services abhängen. Weil der Strangler-Ansatz alle paar Wochen Wert liefert, bekommst du Nutzen lange bevor die vollständige Migration abgeschlossen ist, und du kannst aufhören, sobald die hochwertigen Services draußen sind.

Wie teilt man eine gemeinsame Datenbank über Services hinweg auf?

Vermeide Doppelschreibungen, die bei Nebenläufigkeit Daten verlieren. Nutze logbasiertes Change Data Capture (zum Beispiel Debezium, das das Transaktionslog liest), damit ein neuer Service seinen eigenen Datenspeicher aufbauen und synchronisieren kann, ohne die Schreibvorgänge des Monolithen zu berühren. Kombiniere es mit dem Outbox-Pattern für zuverlässiges Veröffentlichen von Ereignissen und entwirf für eventuelle Konsistenz mit Sagas statt für serviceübergreifende Transaktionen.

Welchen Service sollte ich zuerst herauslösen?

Beginne an den Rändern, nicht im Kern. Wähle eine Blattfunktion mit wenigen eingehenden Abhängigkeiten und einer sauberen Grenze, etwa Reporting, Benachrichtigungen oder einen Export-Job. Authentifizierung oder das zentrale Domänenmodell zuerst herauszulösen ist riskant, weil alles davon abhängt. Ein früher, risikoarmer Erfolg weist die Pipeline nach und bewahrt die Migration vor dem Steckenbleiben.

Sollte ich überhaupt zu Microservices migrieren?

Nur, wenn du ein echtes Problem hast, das Microservices lösen: mehrere Teams, die an einer Codebasis blockiert sind, eine Funktion mit wirklich anderen Skalierungsbedürfnissen oder eine Fähigkeit, die ihr eigenes Team und ihren eigenen Takt braucht. Rund 42% der Anwender (CNCF 2025) konsolidieren Services wieder zusammen. Wenn dein Team klein oder der Monolith bescheiden ist, liefert ein modularer Monolith meist den Großteil des Nutzens ohne jeglichen Overhead verteilter Systeme.

Warum scheitern die meisten Microservices-Migrationen?

Drei wiederkehrende Ursachen: Aufteilung nach technischer Schicht statt nach Geschäftsdomäne (was einen verteilten Monolithen erzeugt), der Versuch einer Neuschreibung auf einen Schlag, bei der kein Fehler eingegrenzt werden kann, und das Unterschätzen der Daten- und Betriebskomplexität. Falsche Grenzen sind am häufigsten. Nutze Event Storming, um Domänengrenzen zu finden, das Strangler-Pattern, um schrittweise zu migrieren, und stelle Observability auf, bevor du irgendetwas herauslöst.

Bereit zum Launch?

Sagen Sie uns, wo Sie feststecken. Wir prüfen es und senden Ihnen innerhalb eines Werktags eine konkrete Empfehlung.