~/blog/2019/08/zurueck-zum-monolithen-der-modular.md

Zurück zum Monolithen? Der modulare Monolith

7 min
Beitragsbild: Zurück zum Monolithen? Der modulare Monolith

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • Microservices lösen echte Probleme, bringen aber Kosten mit: Netzwerk, Konsistenz, Betrieb, Fehlersuche.
  • Ein modularer Monolith hat klare Module, eigene Datenbereiche pro Modul, definierte Schnittstellen und ein Deployment.
  • Grenzen lassen sich technisch absichern, etwa mit Maven-Modulen, Java-Modulen, ArchUnit-Tests oder getrennten Projekten in .NET.
  • Microservices lohnen sich vor allem bei unabhängigen Teams und stark unterschiedlicher Skalierung einzelner Teile.
  • Wer die Grenzen im Monolithen nicht sauber hinbekommt, wird sie verteilt erst recht nicht hinbekommen.

Seit ein paar Monaten fällt mir auf, dass sich der Ton verändert hat. Auf Konferenzen, in Blogs, in Gesprächen unter Entwicklern. Vor fünf Jahren klang „Monolith“ noch fast wie ein Schimpfwort, irgendwo zwischen Altlast und Technikschulden. Inzwischen liest man immer öfter Sätze wie „Wir haben uns bewusst für einen Monolithen entschieden“, und zwar von Leuten, denen man nicht vorwerfen kann, sie hätten die Entwicklung verschlafen.

Ich will das nicht als Rückwärtsbewegung abtun, aber auch nicht als neue Mode feiern. Mich interessiert eher, was dahintersteckt. Und was man davon mitnehmen kann, wenn man gerade vor der Frage steht, wie man ein System schneidet.

Wie wir hierhin gekommen sind

Der Auslöser für die große Microservice-Begeisterung war ziemlich klar: der Artikel von James Lewis und Martin Fowler aus dem Jahr 2014. Er hat beschrieben, was einige Firmen schon taten, und er hat dem Ganzen einen Namen gegeben. Kleine Dienste, jeweils für eine Fachlichkeit zuständig, unabhängig deploybar, lose gekoppelt. Das klang nach einem Ausweg aus den riesigen Anwendungen, die niemand mehr überblickt und bei denen jede Änderung drei Wochen Abstimmung kostet.

Ich fand die Idee damals überzeugend, und ich finde sie im Kern immer noch richtig. Über das Zerlegen eines großen Systems habe ich 2016 in meinem Beitrag „Monolith zerlegen“ geschrieben. Was ich dabei unterschätzt habe: Man kann die Idee der klaren Schnitte von der Idee der verteilten Prozesse trennen. Das eine ist Struktur, das andere ist Infrastruktur. In vielen Diskussionen werden beide Dinge in einen Topf geworfen, als gäbe es das eine nicht ohne das andere.

Stimmen für den gut geschnittenen Monolithen

Dass ich damit nicht allein bin, zeigt ein Blick auf einige Äußerungen der letzten Jahre.

Martin Fowler selbst hat 2015 unter dem Stichwort „MonolithFirst“ vorgeschlagen, bei einem neuen Projekt zunächst mit einem Monolithen zu beginnen. Sein Argument, sinngemäß: Am Anfang weiß man noch gar nicht, wo die richtigen Grenzen verlaufen, und falsche Grenzen zwischen verteilten Diensten zu korrigieren ist deutlich teurer als in einem einzigen Code-Repository.

Simon Brown spricht schon länger vom „modularen Monolithen“. Seine Haltung, die ich hier nur mit eigenen Worten wiedergebe: Wer es nicht schafft, innerhalb einer Anwendung ordentliche Module zu bauen, wird mit Microservices nicht plötzlich bessere Strukturen bekommen. Er bekommt dieselbe Unordnung, nur mit Netzwerkaufrufen dazwischen.

Dazu kommen Erfahrungsberichte. Segment hat 2018 öffentlich beschrieben, wie das Team seine Microservices wieder zu einem Dienst zusammengeführt hat, weil der Aufwand für Betrieb und Pflege den Nutzen überstiegen hat. Und Shopify hat Anfang dieses Jahres darüber geschrieben, wie sie ihren großen Rails-Monolithen intern in Komponenten gliedern, statt ihn in Dienste zu zerschlagen. Das sind keine Anfänger, die mit Verteilung überfordert waren. Das sind Leute, die abgewogen und sich anders entschieden haben.

Was ein modularer Monolith eigentlich ist

Der Begriff klingt nach Kompromiss, ist aber eigentlich ziemlich konkret. Für mich gehören vier Dinge dazu:

  • Klare Modulgrenzen. Ein Modul steht für einen fachlichen Bereich, etwa Bestellung, Lager oder Rechnungsstellung, und nicht für eine technische Schicht.
  • Eigene Datenbereiche. Jedes Modul besitzt seine Tabellen. Kein anderes Modul greift direkt darauf zu, auch wenn alles in derselben Datenbank liegt.
  • Definierte Schnittstellen. Module sprechen miteinander über eine kleine, bewusst veröffentlichte API, nicht über Klassen, die zufällig öffentlich waren.
  • Ein Deployment. Das Ganze wird als eine Einheit gebaut und ausgeliefert.

Der dritte Punkt ist der, an dem es in der Praxis meistens hakt. Ohne Disziplin wird aus „Modul“ sehr schnell ein Ordner, in dem trotzdem jeder alles aufruft. Und dann hat man den berüchtigten großen Haufen, nur mit schöneren Verzeichnisnamen.

Grenzen müssen technisch erzwungen werden

Meine Erfahrung ist: Abmachungen im Team halten genau so lange, bis eine Deadline kommt. Wenn eine Grenze nur auf einem Architekturdiagramm existiert, wird sie überschritten. Nicht aus Bosheit, sondern weil der kürzeste Weg meistens quer durch die Grenze führt.

Deshalb sollte der Compiler oder der Build das übernehmen. In der Java-Welt gibt es dafür mehrere Möglichkeiten, die sich kombinieren lassen:

  • Maven-Module (oder Gradle-Projekte): Jedes Modul ist ein eigenes Artefakt mit eigenen Abhängigkeiten. Was nicht in der Abhängigkeit steht, lässt sich nicht importieren. Das ist grob, aber wirksam.
  • Java-Module (JPMS) seit Java 9: Eine module-info.java legt fest, welche Pakete ein Modul nach außen freigibt.
  • Package-Konventionen: zum Beispiel ein api-Paket pro Modul für alles Öffentliche und ein intern-Paket für den Rest.
  • ArchUnit-Tests: Die Konventionen werden als Unit-Test geprüft, und der Build wird rot, wenn jemand sie bricht.

Ein Modul mit klar begrenzter Außenwirkung sieht in module-info.java so aus:

module shop.lager {
    exports de.beispiel.shop.lager.api;
}

Alles andere im Modul bleibt von außen unsichtbar. Mit ArchUnit kann man Regeln formulieren, die auch ohne JPMS funktionieren:

@Test
public void bestellung_nutzt_nicht_das_lager_innenleben() {
    JavaClasses klassen = new ClassFileImporter().importPackages("de.beispiel.shop");

    noClasses().that().resideInAPackage("..bestellung..")
        .should().dependOnClassesThat().resideInAPackage("..lager.intern..")
        .check(klassen);
}

Ich mag diesen Ansatz, weil er die Architektur ausführbar macht. Der Test sagt dem neuen Kollegen nach einer Woche genauer, wo die Grenzen liegen, als jedes Wiki.

In .NET ist es ähnlich: Getrennte Projekte in einer Solution, Klassen mit internal statt public und Projektreferenzen, die nur in eine Richtung zeigen. Auch hier gilt, dass der Compiler die Grenze durchsetzt, nicht die Absicht.

Was verteilte Systeme kosten

Wenn man über Microservices spricht, kommt der Nutzen meistens zuerst: unabhängige Deployments, freie Technologiewahl, gezielte Skalierung. Die Kosten werden gern später verbucht, und zwar oft erst dann, wenn sie anfallen.

Ein Aufruf zwischen zwei Modulen in einem Prozess ist ein Methodenaufruf. Zwischen zwei Diensten ist es ein Netzwerkaufruf, der langsam sein, scheitern oder doppelt ankommen kann. Man braucht Timeouts, Wiederholungen und Strategien für den Fall, dass der andere Dienst gerade nicht da ist.

Dazu kommt die Konsistenz. In einem Monolithen mit einer Datenbank ist eine Transaktion über mehrere Fachbereiche hinweg vergleichsweise unspektakulär. Sobald jeder Dienst seine eigene Datenhaltung hat, wird daraus ein Nachdenken über eventuelle Konsistenz, Kompensationen und Abläufe, die auf halber Strecke stehen bleiben können.

Und dann der Betrieb. Mehr Dienste bedeuten mehr Deployments, mehr Konfiguration, mehr Versionen, die zueinander passen müssen. Eine Fehlersuche, die früher aus einem Blick ins Log bestand, wird zur Spurensuche über mehrere Systeme. Ohne vernünftiges Monitoring, zentrale Logs und die Möglichkeit, eine Anfrage über Dienstgrenzen zu verfolgen, fliegt man ziemlich blind.

Das alles ist lösbar. Aber es ist Arbeit, die nichts zur Fachlichkeit beiträgt. Und kleine Teams spüren sie überproportional.

Wann Microservices trotzdem passen

Ich möchte nicht in das andere Extrem kippen. Es gibt gute Gründe für getrennte Dienste.

Der wichtigste ist für mich die Organisation. Wenn mehrere Teams unabhängig voneinander arbeiten und ausliefern sollen, ohne sich ständig abzustimmen, ist eine Trennung auf Prozessebene eine ehrliche Antwort. Die Struktur des Systems spiegelt dann die Struktur der Teams, und das ist meistens gesünder, als gegen sie anzukämpfen.

Der zweite Grund ist die Skalierung. Wenn ein einzelner Teil, sagen wir die Suche oder die Bildverarbeitung, völlig andere Lastprofile hat als der Rest, kann es sinnvoll sein, genau diesen Teil herauszulösen und getrennt zu betreiben. Man muss dafür nicht gleich das ganze System zerlegen.

Der schöne Nebeneffekt eines sauber geschnittenen Monolithen: Er hält diese Tür offen. Ein Modul mit klarer Schnittstelle und eigenem Datenbereich lässt sich später herauslösen, wenn der Bedarf wirklich da ist. Ein Haufen aus verwobenen Klassen nicht.

Was ich daraus mitnehme

Ich glaube, die eigentliche Lehre liegt weniger bei der Frage „Monolith oder Microservices“ als bei der Frage nach guten Grenzen. Wer sie findet und durchsetzt, hat viele Optionen. Wer sie nicht findet, hat mit beiden Architekturen Probleme, nur eben unterschiedlich teure.

Für ein neues System würde ich heute eher mit einem modularen Monolithen beginnen und die Grenzen früh absichern. Verteilen kann man später immer noch, wenn Teams oder Last es verlangen. Den umgekehrten Weg, also viele schlecht geschnittene Dienste wieder zusammenzuführen, haben dieses Jahr einige ziemlich eindrucksvoll beschrieben.

Und für bestehende Systeme gilt, was ich schon 2016 gedacht habe: Erst die Struktur verstehen, dann entscheiden, was herausgelöst werden muss. Wahrscheinlich weniger, als man zunächst denkt.

Wie seht ihr das, habt ihr eure Dienste schon wieder zusammengeführt oder seid ihr zufrieden mit der Verteilung? Mich interessieren eure Erfahrungen.

Beitragsbild: Foto Menhir auf dem Cham des Bondons von Myrabella, CC BY-SA 3.0 (via Wikimedia Commons; zugeschnitten auf 16:9).

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.