Be Software Architecture Wise
Be Wise Apps

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

Kapitel 5 von 12 · Mittelstufe

Architekturstile I: Monolithen und modulare Designs

Die meiste Software, darunter einige der größten und erfolgreichsten Produkte, läuft als eine einzige deploybare Anwendung. Dieses Kapitel erklärt, wie solche Anwendungen im Inneren strukturiert sein sollten. Es führt das Vokabular von Architekturstilen, Mustern, Taktiken und dem Architekturquantum ein, behandelt dann Schichtenarchitektur, den modularen Monolithen, Pipes and Filters, Microkernel- und Plug-in-Architektur, hexagonale, Onion- und Clean Architecture sowie strategisches Domain-Driven Design und endet mit der Frage, wann ein Monolith die richtige Antwort ist. Es richtet sich an Entwicklungsteams und Architekten, die Geschäftsanwendungen entwerfen oder warten und eine Struktur bewusst wählen und durchsetzen wollen.

Videoeinführung in Kapitel 5

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

Willkommen zu Kapitel 5: Architekturstile, Teil eins, Monolithen und modulare Designs. Die meiste Software, darunter einige der größten und erfolgreichsten Produkte, läuft als eine einzige deploybare Anwendung. Dieses Kapitel erklärt, wie solche Anwendungen im Inneren strukturiert sein sollten und wann eine einzige Anwendung die richtige Antwort ist.

Die Kapitel 3 und 4 haben Ihnen die Prinzipien guter Struktur und die Werkzeuge zu ihrer Beschreibung vermittelt. Dieses und das nächste Kapitel machen daraus die wiederkehrenden Formen, die reale Systeme annehmen. Wer die wichtigsten Stile kennt, kann von einer bewährten Form für bestimmte Qualitäten ausgehen, sie in einem Satz erklären und früh erkennen, wann ein System von ihr abdriftet. Dieses Kapitel behandelt Stile, bei denen die ganze Anwendung eine Deployment-Einheit ist: ein Build, ein Release, meist eine Datenbank. Primitiv sind Monolithen deshalb nicht. Ob die Arbeit an einem Monolithen Freude oder Qual ist, hängt fast vollständig davon ab, wie er im Inneren aufgeteilt ist.

Das Kapitel richtet sich an Entwicklungsteams und Architekten, die Geschäftsanwendungen entwerfen oder warten und eine Struktur bewusst wählen und durchsetzen wollen. Es baut auf den Kapiteln 3 und 4 auf, insbesondere auf Modularität, Kopplung und Kohäsion, Abhängigkeiten und Schichtenbildung sowie dem C4-Modell. Die Qualitätsmerkmale aus Kapitel 2 werden durchgehend verwendet. Und es führt zu Kapitel 6, das dieselben Fragen über ein Netzwerk trägt, wo alles schwieriger wird. Ein Monolith vermeidet die Netzwerkfehler, Teilausfälle und Konsistenzprobleme verteilter Systeme. Diesen widmet sich Kapitel 6.

Zuerst eine Definition. Ein Architekturstil ist ein benannter Satz von Randbedingungen dafür, welche Arten von Teilen ein System hat und wie sie verbunden sein dürfen. Auf die Randbedingungen kommt es an. Verbieten Sie etwa einem Geschäftsmodul, die Tabellen eines anderen anzufassen, und Sie erhalten vorhersagbare Vorteile zu einem vorhersagbaren Preis.

Das Kapitel hat acht Abschnitte. Abschnitt fünf Punkt eins legt das Vokabular für jeden Stil in den Kapiteln 5 und 6 fest: Stile, Muster, Taktiken und Referenzarchitekturen. Er erklärt den Unterschied zwischen technischer Partitionierung nach Schicht und fachlicher Partitionierung nach Geschäftsfähigkeit. Und er führt das Architekturquantum ein: einen unabhängig deploybaren Teil samt Daten, für den ein Satz von Qualitäten gilt.

Darum ist die Partitionierung wichtig. Angenommen, ein Essenslieferunternehmen lässt Kunden ein Trinkgeld für den Kurier hinzufügen. Bei technischer Partitionierung betrifft diese eine Änderung die Präsentationsschicht, die Geschäftslogik und die Persistenzschicht. Bei fachlicher Partitionierung landet dieselbe Änderung fast vollständig im Liefermodul, das intern trotzdem in Schichten aufgebaut sein kann. Die meisten fachlichen Änderungswünsche sind in Begriffen der Domäne formuliert, daher hält fachliche Partitionierung eine Änderung meist an einem Ort. Und sie lässt jedes Team eine Geschäftsfähigkeit durchgängig verantworten.

Die Abschnitte fünf Punkt zwei bis fünf Punkt fünf beschreiben vier Stile im gleichen Format, mit Diagramm, Beispiel, Merkmalstabelle, Einsatzempfehlung und Durchsetzung im Code. Die Schichtenarchitektur ist der vertraute Stapel aus Präsentations-, Geschäfts- und Persistenzschicht. Der modulare Monolith teilt eine deploybare Anwendung nach Fachdomänen auf, mit expliziten Modulschnittstellen und klarer Datenhoheit, veranschaulicht an den Erfahrungen von Shopify. Pipes and Filters ordnet die Verarbeitung als Kette unabhängiger Schritte an, von Unix-Pipes bis zu Datenpipelines. Und der Microkernel baut einen minimalen Kern, den Plug-ins erweitern, wie bei Entwicklungswerkzeugen, Browsern und Regel-Engines.

Dieses Diagramm aus Abschnitt fünf Punkt drei zeigt einen modularen Monolithen von innen. Die gestrichelte Grenze ist eine Deployment-Einheit: die Essensliefer-Anwendung. Jedes Modul, hier Bestellungen und Zahlungen, hat eine kleine öffentliche API. Bestellungen darf Zahlungen nur über diese API nutzen. Alles andere in einem Modul ist intern. Aus den Interna eines Moduls in die eines anderen hineinzugreifen ist verboten. Und jedes Modul besitzt sein eigenes Schema, ohne Joins über Schemagrenzen hinweg. Halten Sie sich an diese Regeln, und jedes Modul lässt sich später mit überschaubarem Aufwand in einen Service herauslösen.

Abschnitt fünf Punkt sechs behandelt hexagonale, Onion- und Clean Architecture. Sie stellen die Geschäftslogik ins Zentrum und machen Datenbanken, Benutzeroberflächen und externe Dienste von ihr abhängig, nie umgekehrt. Abschnitt fünf Punkt sieben zu strategischem Domain-Driven Design liefert die Methode, um gute Grenzen zu finden: Subdomänen, Bounded Contexts und ihre Beziehungen in einer Context Map. Schließlich fragt Abschnitt fünf Punkt acht, wann ein Monolith die richtige Antwort ist, wie weit er skalieren kann und welche Anzeichen sagen, dass es Zeit für eine Aufteilung ist. Er endet mit einer Entscheidungshilfe und einer Vergleichstabelle für alle Stile des Kapitels.

Wenn Sie sich nur eines merken, dann dies: Die Grenzen innerhalb eines Systems sind wichtiger als die Grenzen zwischen Deployment-Einheiten. Services, die sich eine Datenbank teilen und gegenseitig ihre Interna aufrufen, sind immer noch ein verworrenes System, nun zusätzlich mit Netzwerkfehlern. Daraus folgen zwei Gewohnheiten. Erstens: Wählen Sie den einfachsten Stil, dessen Merkmale die architekturrelevanten Anforderungen erfüllen, und halten Sie Wahl und Abwägungen in einem Entscheidungsdokument fest. Zweitens: Setzen Sie die Regeln des Stils mit Architekturtests im Build durch, denn jeder Stil erodiert, wenn seine Randbedingungen nur in den Köpfen existieren.

Lesen Sie zuerst Abschnitt fünf Punkt eins, denn jeder spätere Abschnitt nutzt sein Vokabular. Danach können Sie die Stile der Reihe nach durchgehen oder gezielt den lesen, den Sie brauchen. Das Kapitel zu lesen dauert etwa drei Stunden. Verfolgen Sie die Essenslieferplattform, die sich durch das ganze Kapitel zieht. Stile an einem vertrauten System zu vergleichen ist viel leichter als an zusammenhanglosen Spielzeugbeispielen. Jeder Abschnitt endet mit einigen Fragen zur Selbstkontrolle. Beantworten Sie sie im Kopf, bevor Sie nachsehen. Wenn Sie so weit sind, legen Sie den optionalen Kapiteltest ab: zwanzig Multiple-Choice-Fragen und zwei schriftliche Antworten, in etwa fünfundvierzig Minuten. Die Bestehensgrenze liegt bei achtzig Prozent.

Das ist der Überblick über Kapitel 5. Beginnen Sie mit Abschnitt fünf Punkt eins, wo wir das Vokabular von Stilen, Mustern und Taktiken festlegen, auf das die nächsten beiden Kapitel aufbauen. Bis gleich.

Kapitel herunterladen (PDF)In der App lesen

Auf einen Blick

Das lernen Sie

  • Architekturstile, Muster, Taktiken und Referenzarchitekturen unterscheiden und erklären, warum die Randbedingungen eines Stils seine Qualitäten hervorbringen.
  • Technische und fachliche Partitionierung vergleichen und vorhersagen, wie sich jede auf die Kosten einer typischen Änderung und auf die Organisation der Teams auswirkt.
  • Die Architekturquanten in einem Entwurf erkennen und erklären, warum gemeinsam genutzte Datenbanken Services zu einem einzigen Quantum verbinden.
  • Schichtenarchitektur, modularen Monolithen, Pipes and Filters und Microkernel beschreiben, ihre Merkmale bewerten und ihre Anti-Patterns erkennen.
  • Hexagonale, Onion- oder Clean Architecture anwenden, um die Geschäftslogik unabhängig von Frameworks und Infrastruktur zu halten.
  • Mit strategischem Domain-Driven Design Bounded Contexts finden und ihre Beziehungen in einer Context Map beschreiben.
  • Strukturregeln im Code mit Architekturtests und Modulwerkzeugen wie import-linter, ArchUnit und Spring Modulith durchsetzen.
  • Entscheiden, wann ein Monolith die richtige Wahl ist, wie man ihn skaliert und welche Anzeichen darauf hindeuten, dass es Zeit ist, Services herauszulösen.

Bevor Sie beginnen

Kapitel 3, insbesondere Modularität, Kopplung und Kohäsion sowie Abhängigkeiten und Schichtenbildung; Kapitel 4, insbesondere das C4-Modell. Die Qualitätsmerkmale aus Kapitel 2 werden durchgehend verwendet.

Zeit

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

Schlüsselbegriffe

Architekturstil · Architekturmuster · Taktik · technische Partitionierung · fachliche Partitionierung · Architekturquantum · geschlossene und offene Schichten · Architecture Sinkhole · modularer Monolith · Pipes and Filters · Backpressure · Microkernel · Ports and Adapters · Bounded Context

Warum Stile wichtig sind

Die Kapitel 3 und 4 haben Ihnen die Prinzipien guter Struktur (Modularität, Kopplung und Kohäsion, Abhängigkeitsrichtung) und die Werkzeuge zu ihrer Beschreibung vermittelt. Dieses und das nächste Kapitel machen aus diesen Prinzipien die wiederkehrenden Formen, die reale Systeme annehmen. Ein Architekturstil ist ein benannter Satz von Randbedingungen dafür, welche Arten von Teilen ein System hat und wie sie verbunden sein dürfen. Auf die Randbedingungen kommt es an: Verbieten Sie den Teilen einer Pipeline, Zustand zu teilen, oder einem Geschäftsmodul, die Tabellen eines anderen anzufassen, und Sie erhalten vorhersagbare Vorteile zu einem vorhersagbaren Preis. Wer die wichtigsten Stile kennt, kann von einer Form ausgehen, die sich für bestimmte Qualitäten bewährt hat, sie in einem Satz erklären und früh erkennen, wann ein System von ihr abdriftet.

Dieses Kapitel behandelt Stile, bei denen die gesamte Anwendung eine einzige Deployment-Einheit ist: ein Build, ein Release, meist eine Datenbank, und die Teile rufen einander im Arbeitsspeicher auf. Eine solche monolithische Architektur vermeidet die Netzwerkfehler, Teilausfälle und Konsistenzprobleme verteilter Systeme, denen sich Kapitel 6 widmet. Primitiv sind Monolithen deshalb nicht. Ob die Arbeit an einem Monolithen Freude oder Qual ist, hängt fast vollständig davon ab, wie er im Inneren aufgeteilt ist, und genau darum geht es in diesem Kapitel.

Wie das Kapitel zusammenhängt

Abschnitt 5.1 legt das Vokabular fest, das für jeden Stil in den Kapiteln 5 und 6 verwendet wird: Stile, Muster, Taktiken und Referenzarchitekturen; den Unterschied zwischen technischer Partitionierung (nach Schicht) und fachlicher Partitionierung (nach Geschäftsfähigkeit); monolithisches gegenüber verteiltem Deployment; und das Architekturquantum, die unabhängig deploybare Einheit, für die ein Satz von Qualitäten gilt. Er endet mit einer Übersichtstabelle aller Stile der beiden Kapitel.

Die Abschnitte 5.2 bis 5.5 beschreiben dann vier Stile in einheitlichem Format: Definition und Ursprung, ein Diagramm, Funktionsweise, ein Beispiel, eine Tabelle der Merkmale, wann man ihn einsetzt und wann nicht, Anti-Patterns und wie man ihn im Code durchsetzt. Die Schichtenarchitektur (5.2) ist der vertraute Stapel aus Präsentation, Geschäftslogik und Persistenz, mit geschlossenen und offenen Schichten und dem Sinkhole-Anti-Pattern. Der modulare Monolith (5.3) teilt eine deploybare Anwendung nach Fachdomänen auf, mit expliziten Modul-APIs und klarer Datenhoheit, veranschaulicht an den Erfahrungen von Shopify und einer Modulkarte einer Essenslieferplattform. Pipes and Filters (5.4) ordnet die Verarbeitung als Kette unabhängiger Schritte an, von Unix-Pipes bis zu Datenpipelines. Der Microkernel (5.5) baut einen minimalen Kern, den Plug-ins erweitern, wie bei IDEs, Browsern und Regel-Engines.

Die Abschnitte 5.6 und 5.7 handeln von der Struktur innerhalb von und zwischen Modulen statt vom Deployment. Hexagonale, Onion- und Clean Architecture (5.6) stellen die Geschäftslogik ins Zentrum und machen Datenbanken, Benutzeroberflächen und externe Dienste von ihr abhängig, nie umgekehrt; dadurch wird der Kern testbar und seine Infrastruktur austauschbar. Strategisches Domain-Driven Design (5.7) liefert die Methode, um gute Grenzen zu finden: Subdomänen, Bounded Contexts und ihre Beziehungen in einer Context Map. Schließlich fragt Abschnitt 5.8, wann ein Monolith die richtige Antwort ist, wie weit er skalieren kann und welche Anzeichen sagen, dass es Zeit für eine Aufteilung ist, und bietet eine Entscheidungshilfe und eine Vergleichstabelle für die Stile des Kapitels.

Ein durchgehendes Beispiel

Wie in den früheren Kapiteln zieht sich eine Essenslieferplattform durch das ganze Kapitel: Kunden bestellen bei Restaurants, Kuriere liefern, Zahlungen laufen über einen externen Anbieter. In Abschnitt 5.1 wird sie anhand von vier Entwurfskandidaten eingeordnet; in 5.2 ist sie eine klassische Webanwendung in Schichtenarchitektur; in 5.3 wird sie zu acht Modulen mit einer Abhängigkeitsregel, die im Build geprüft wird; in 5.4 fließen ihre Bestellereignisse durch eine Pipeline in ein Data Warehouse, und den Engpass zu finden ist eine ausgearbeitete Rechnung. Spätere Abschnitte kehren zur selben Plattform zurück, am ausführlichsten in der Context Map von Abschnitt 5.7, damit sich die Stile an einem vertrauten System statt an zusammenhanglosen Spielzeugbeispielen vergleichen lassen.

Die Idee zum Mitnehmen

Wenn Sie sich nur eines aus diesem Kapitel merken, dann dies: Die Grenzen innerhalb eines Systems sind wichtiger als die Grenzen zwischen Deployment-Einheiten. Ein nach Domänen aufgeteilter Monolith mit expliziten Modul-APIs, einem Eigentümer für jede Tabelle und automatisch geprüften Abhängigkeitsregeln kann von mehreren Teams viele Jahre lang sicher verändert werden, und jedes Modul kann später zu einem Service werden, wenn es das wirklich braucht. Eine Gruppe von Services, die sich eine Datenbank teilen und gegenseitig ihre Interna aufrufen, ist immer noch ein einziges verworrenes System, nun zusätzlich mit Netzwerkfehlern. Stile sind Werkzeuge, um gute Grenzen zu schaffen und zu erhalten; keiner von ihnen ist ein Ziel an sich.

Daraus folgen zwei Gewohnheiten. Erstens: Wählen Sie den einfachsten Stil, dessen Merkmale die architekturrelevanten Anforderungen des Systems erfüllen, und halten Sie die Wahl und ihre Abwägungen in einem Entscheidungsdokument fest. Zweitens: Setzen Sie die Regeln des Stils mit Architekturtests im Build durch, denn jeder Stil erodiert, wenn seine Randbedingungen nur in den Köpfen der Beteiligten existieren.

Die 8 Abschnitte

5.1 · Mittelstufe · 22 Min.Stile und MusterDas Vokabular für die nächsten beiden Kapitel: Stile, Muster, Taktiken und Referenzarchitekturen, technische gegenüber fachlicher Partitionierung, monolithisches gegenüber verteiltem Deployment und das Architekturquantum.Lesen →5.2 · Mittelstufe · 24 Min.SchichtenDer bekannteste Stil: Präsentations-, Geschäfts-, Persistenz- und Datenbankschicht. Geschlossene und offene Schichten, Isolationsschichten, das Sinkhole-Anti-Pattern, warum jedes Feature jede Schicht berührt und wie man die Regeln durchsetzt.Lesen →5.3 · Mittelstufe · 26 Min.Modularer MonolithEine deploybare Anwendung, nach fachlicher Domäne in Module mit expliziten APIs und eigenen Daten aufgeteilt. Wie man die Grenzen durchsetzt, wie Module kommunizieren, was Shopify gelernt hat und wie er die Option erhält, später Services herauszulösen.Lesen →5.4 · Mittelstufe · 23 Min.Pipes and FiltersDaten, die durch eine Kette unabhängiger Schritte fließen: Producer, Transformer, Tester und Consumer, verbunden durch Pipes. Von Unix-Pipes über ETL und Compiler bis zur Stream-Verarbeitung, mit Durchsatz, Backpressure und Fehlerbehandlung.Lesen →5.5 · Mittelstufe · 24 Min.MicrokernelWie ein kleines Kernsystem plus unabhängige Plug-ins Erweiterbarkeit liefert: Registries, Verträge, Isolation und Versionierung, echte Beispiele aus IDEs und Browsern und ein durchgearbeiteter Plug-in-Vertrag für länderspezifische Steuerregeln.Lesen →5.6 · Mittelstufe · 25 Min.Hexagonal und CleanPorts and Adapters, Onion- und Clean Architecture: die Geschäftslogik im Zentrum, Abhängigkeiten zeigen nach innen, treibende und getriebene Ports, ein Python-Beispiel mit einem echten Adapter und einem Test Double sowie die Kosten.Lesen →5.7 · Mittelstufe · 26 Min.Domain-Driven DesignGrenzen in der Fachdomäne finden: Ubiquitous Language, Core-, Supporting- und generische Subdomänen, Bounded Contexts, Beziehungen in der Context Map, Event Storming, Aggregate und eine Context Map der Essenslieferplattform.Lesen →5.8 · Mittelstufe · 24 Min.Einen Monolithen wählenMonolithFirst, die Microservice Premium und der Majestic Monolith; wann eine einzige Deployment-Einheit die richtige Wahl ist, wie weit ein Monolith skaliert, die Anzeichen, dass es Zeit für eine Aufteilung ist, und eine Entscheidungshilfe für die Stile aus Kapitel 5.Lesen →

Kapiteltest

Prüfen Sie Ihr Verständnis von Kapitel 5

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 5 in der App ablegen

Weiterführende Literatur