Warum einfach? Es geht auch komplex!
Wie zu erwarten zieht das heißdiskutierte Thema Microservices auch an Microsoft nicht vorüber. Grund genug, einmal näher zu betrachten, wie man als .NET-Entwickler bei der Entwicklung von Microservices mit Docker von technischer Seite unterstützt wird.
Mit „.NET Microservices: Architecture for Containerized .NET Applications“ hat Microsoft nun ein mehr als dreihundertseitiges E-Book veröffentlicht, in dem das Unternehmen seine Sicht auf das Thema umfassend vorstellt und insbesondere die Benutzung von Docker bei der Entwicklung von Anwendungen mit Microservices-Architektur empfiehlt [1].
In diesem Beitrag soll Microsofts Sicht auf das Thema Microservices näher beleuchtet und mit Blick auf unsere eigene Erfahrung kommentiert werden. Weiterhin werden wir darauf eingehen, wie Docker bei der Entwicklung von Microservices genutzt werden kann.
Was ist eine Microservices-Architektur?
Das zentrale Erkennungsmerkmal einer Microservices-Architektur ist, dass sich die gesamte Anwendung aus einzelnen, voneinander unabhängigen Services zusammensetzt. Durch Dezentralisierung und Autonomiemaximierung soll auch bei komplexen Anwendungen eine gute Skalierbarkeit in der Entwicklung – gegenüber einer monolithischen Architektur – erreicht werden. Die Entwicklung kann in kleinen, unabhängigen Teams mit geringem Kommunikationsbedarf untereinander stattfinden. Um einen Vorteil gegenüber einer monolithischen Anwendung zu erreichen, sollten die Microservices jeweils folgende Bedingungen erfüllen:
Ein Service erfüllt genau einen fachlichen Zweck und diesen vollständig
Jeder Service umfasst sämtliche benötigte Schichten, Teams arbeiten unabhängig voneinander (vertikaler Schnitt)
Asynchrone Kommunikation zwischen Services (keine zentral steuernde Einheit)
Keine gemeinsamen Daten oder Code (shared Nothing)
Jeder Service ist unabhängig deploybar
Unabhängige Datenmodelle und minimale APIs zur Gewährleistung eigenständiger Entwicklungszyklen
Der Name „Microservices“ impliziert, dass die einzelnen Services klein sein sollen. Diese Charakterisierung bezieht sich aber nicht auf die Lines of Code oder die Anzahl der Klassen je Service. Stattdessen bedeutet es, dass ein Service nur genau eine sinnvolle Funktion im Sinne der fachlichen Logik erfüllen soll. Diese Idee folgt dem Konzept des Bounded Context aus dem Domain-driven Design [2]. Danach wird ein großer fachlicher Themenbereich in kleinere Bereiche, die Bounded Contexts (Abb. 1), aufgeteilt, die jeweils ihre eigenen, eindeutigen Fachbegriffe benutzen (Ubiquitous Language). Ein Microservice überschreitet keinesfalls die Grenzen eines Bounded Contexts. Er implementiert maximal den gesamten Bounded Context, typischerweise aber nur einen Teilbereich.
Abb. 1: Illustration zweier Bounded Contexts (Quelle: [2])Man sollte die kleinsten Microservices implementieren, die die oben genannten Bedingung erfüllen. Wird die optimale Größe unterschritten, wachsen die Abhängigkeiten der Services untereinander. Das verschlechtert die Performance der Anwendung zur Laufzeit und während der Entwicklung durch erhöhten Kommunikationsbedarf über Service- und Teamgrenzen hinweg. Der Schnitt der Microservices sollte deren innere Kohäsion maximieren und die Abhängigkeiten nach außen minimieren. Gemäß dem Gesetz von Conway [3] sollten sich die Service-Grenzen hierbei an der Organisationsstruktur des Unternehmens orientieren. Es kann sich auch lohnen, dieses Prinzip umzukehren, und die Organisation so anzupassen, dass man den aus Softwaresicht sinnvollsten Service-Schnitt wählen kann.
Bei richtiger Umsetzung erhält man ein skalierbares System lose gekoppelter Services, die unabhängig voneinander entwickelt und ausgeliefert werden können. Releasezyklus, Entwicklungs- und Betriebsumgebung können je Service passend gewählt werden. Der Testaufwand je Service sinkt, da er nicht übermäßig komplex ist und nur über Schnittstellen kommuniziert. Die Entwicklung in kleinen Teams erzeugt nur geringen organisatorischen Aufwand. Ausgehend von Amazons „2-Pizza-Regel“ liegt die maximale Teamgröße bei fünf bis neun Personen [4].
Eine verteilte Anwendung bringt allerdings auch zusätzliche Schwierigkeiten mit sich, die bei falscher Vorgehensweise zu einer Verschlechterung gegenüber einem Monolith führen können: Es gibt keine zentrale Steuerung, sodass querschnittliche Aufgaben wie Service-übergreifendes Monitoring oder Logging zusätzlichen Entwicklungsaufwand mit sich bringen. Externe Tools wie der ELK-Stack [5], Zipkin [6], Jaeger [7] und AppDynamics [8] können hier Abhilfe schaffen. Die Durchführung von Service-übergreifenden Integrationstests oder Refactorings wird schwieriger. Transaktionen sind auf einzelne Microservices begrenzt. Das Prinzip des „shared Nothing“ erzwingt, dass jeder Service seine benötigten Daten replizieren oder über Schnittstellen von anderen Services abfragen muss. Jedes Entwicklerteam hat zusätzlichen Aufwand durch erschwertes Debugging, eine eigene Fehlerbehandlun...

