Buchvorstellung: Microservices mit Go

Vom Rheinwerk Verlag erhielt ich im August die Anfrage, eine Review für das neue Buch „Microservices mit Go“ von Kristian Köhler zu übernehmen. Das Buch wird im November erscheinen und ist ein Fachbuch in deutscher Sprache, das kompakte aber zugleich tiefergehende Einblicke sowohl in das Thema Microservices allgemein als auch in die Programmiersprache Go im Besonderen bietet.

Es eignet sich sowohl für alle Einsteiger*innen, die sich mit diesen beiden Themen beschäftigen wollen, aber auch für Softwareentwickler*innen, die ihr Wissen zu Microservices ausbauen und bei dieser Gelegenheit die Vorteile von Go kennenlernen möchten. In diesem Blog-Post möchte ich euch mehr Details verraten und erzählen, warum es sich lohnt, diesem Buch Beachtung zu schenken.

Der Inhalt – Microservices mit Go

Microservices mit Go, Rheinwerk Verlag

Microservices mit Go
Konzepte, Werkzeuge, Best Practices

Autor: Kristian Köhler
Verlag: Rheinwerk Verlag
: 20.11.2020
Preis: 39,90 €
(Auch als eBook erhältlich)
Das Buch im Shop

Das Buch beginnt im ersten Kapitel mit Basics zur Motivation in Sachen Go(lang) und Microservices sowie vorbereitend mit der Installation und Verwendung von Go auf verschiedenen Betriebssystemen. Neben den Go Developer Tools werden Setup von Workspace und Grundlagen des Compilers erklärt. Schnell wird klar, dass Go mit Compiler, Linter, Debugger, Doc Generator, Profiler und Benchmark alle Tools bereits mitbringt, die man als Entwickler*in im Alltag braucht.

Auch Besonderheiten von Go wie beispielsweise der Go Generator oder das integrierte (Unit und E2E) Testing werden angesprochen. Oder der Cross-Compiler für andere OS.

Vergleichbare Publikationen aus der englischsprachigen Fachliteratur sind an dieser Stelle oftmals weniger detailliert und vollständig wie „Microservices mit Go“.

Go und seine Facetten

Im zweiten Kapitel werden Typen und Verwendung von Interfaces und Pointern in Go nachvollziehbar erklärt, ebenso wie alle Schlüsselwörter (und deren Einsatz) sowie Go-Konstrukte wie Schleifen, Switch und If-Statements im Vergleich zu anderen Programmiersprachen.

Module spielen in Go eine grosse Rolle, und so werden Imports von Go Modules mit allen Besonderheiten ausführlich angesprochen. Auch die speziellen Go-Elemente wie Defer, Variadic Parameters, Zero Values und Type Inference sowie die wenigen Go-Datenstrukturen Struct, Slice und Array werden vorgestellt und erklärt.

Das Error-Handling in Go führt bei manchen Entwickler*innen, die Sprachen wie Java oder PHP gewohnt sind, anfangs zu Verwirrung. Hier zeigt das Buch wieder seine Stärke, Themen nicht einfach nur kurz anzusprechen, sondern auch den Hintergrund dazu aufzugreifen. Denn mit Kontextinformationen fällt es leichter, die Konzepte von Go zu verinnerlichen. Man erfährt hier mehr, als in vielen anderen Go-Einführungen.

Im weiteren erfährt man anhand von Programmbeispielen unter anderem, wie typischerweise die Implementierung erfolgt von:

  • Ansteuerung einer Oracle-SQL-Datenbank
  • einer MongoDB-NoSQL-Datenbank
  • ORM Libraries unter Go
  • Build von RESTful APIs mit Gorilla-Mux und Gin-Gonic als Router
  • Einsatz von Middleware im Router
  • Configuration Management mit ENV-Variablen
  • Strukturiertes JSON-Logging mit Logrus
  • Messaging über NATS Event Bus
  • gRPC mit ProtoBuf

Spannend und im Detail sehr gut beschrieben – aber zugleich kompakt formuliert – sind spezielle Themen wie u.a. Nebenläufigkeit in Go:

  • Go Routines (die „light-weight Threads“ von Go)
  • Kommunikation über G-Channels
  • Go Context Package

Teilaspekte von Microservices

Das dritte Kapitel beschreibt Microservices im Fokus seiner zahlreichen Teilaspekte. Begleitend wird eine kleine Applikation in Go programmiert: die Anwendung „Training Fellow“, ein Buchungssystem für Anbieter von Trainings. Die Applikation dient als Beispiel für die Erläuterung von Konzepten und Techniken und hat keinen Anspruch, eine vollständige Anwendung zu sein.

Weitergehende Ansätze für Software-Architekturen, wie zum Beispiel Domain-driven Design oder Techniken wie Event Storming und Domain Story Telling, werden nur kurz angesprochen und auf weitere Quellen verwiesen. Sie sind nicht Gegenstand des Buches, der Fokus liegt klar auf Microservices mit Go. Dafür werden Konzepte wie Container und Bounded Context und deren Auswirkung auf die Microservices-Architektur sehr schön dargestellt und beschrieben.

Kommunikation bei Microservices kann auf verschiedene Weise stattfinden. Das Buch stellt alle wesentlichen Implementierungen wie REST, RPC und Messaging vor. Häufig eingesetzte Techniken in diesem Kontext wie beispielsweise Google ProtoBuf, NATS.io oder SSL-Verschlüsselung werden angesprochen und die Basics erklärt. Ebenso wird auf Strategien zur Fehlerbehandlung und Skalierung eingegangen. Eine kurze Einführung in das Thema Metriken mit Prometheus rundet dieses umfangreiche Kapitel ab. 

Der gute Überblick zu allen relevanten Themen rund um Microservices erlaubt dem/der Leser/in, sich weiter mit diesen Themen im Detail zu beschäftigen. Das Buch gibt hierfür den notwendigen Einstieg und bereits einen sehr guten, praktischen Leitfaden für den Programmieralltag.

Im vierten und fünften Kapitel werden weitere Best Practices zu Go vorgestellt. Es geht um Unit Tests, Benchmarking und Profiling. Die Programmierung in Go unterscheidet sich in einigen wesentlichen Punkten zu anderen Sprachen; der Autor erklärt anhand passender Beispiele, wie man Dinge in Go typischerweise löst und welche Vorteile Go damit gegenüber anderen Sprachen bietet. Auch die Organisation der Code Base wird angesprochen.

Ein abschliessendes sechstes Kapitel erklärt in Grundzügen die Verwendung von Docker und Kubernetes.

Über Kristian Köhler

Kristian Köhler ist freiberuflicher Software-Architekt, Berater, Trainer, Entwickler und Consultant. Seine Kunden berät er rund um alle Fragen der Software-Architektur. Seine mehrtätigen Seminare und Praxisworkshops zur Programmiersprache Go sind bei Programmierern heiß begehrt. Frühere Publikationen sind ein Buch über den Application Server Apache Geronimo und J2EE Entwicklung mit Open-Source-Tools. Hinzu kommen Tätigkeiten auf Konferenzen und Artikel in Fachzeitschriften.

Die Meinung

Das Buch zitiert immer wieder Konzepte bekannter Autoren und Köpfe wie Adrian Cockcroft, Rob Pike oder Martin Fowler und spannt damit einen grossen Bogen, der von Theorie und und Konzeption von Microservices-Architekturen bis hin zu deren praktischen Umsetzung mit Go reicht.

Dieser Verweis auf andere Autoren und Wegbereiter gefiel mir sehr gut. Dabei bleibt das Buch stets freundlich zu Neueinsteigern auf diesem Gebiet, begibt sich aber genauso immer wieder etwas tiefer in die Materie. Es ist sehr verständlich geschrieben und bleibt auf ca. 400 Seiten seinem Stil auch treu. Es entsteht ein passender und stimmiger Mix, der eine angenehme Lernkurve reich an Informationen und Details beinhaltet.

Neben Architekturentscheidungen werden auch Libraries und Frameworks vorgestellt, die sich sehr gut in den Microservices-Kontext einreihen. Fast beiläufig erfährt man eine ganze Menge in Sachen Entwicklung. Nicht nur über die Syntax und Verwendung von Go, sondern auch über typische Idiome dieser Sprache. Vor allem, warum Go einiges anders macht und woher diese Entscheidungen der Erfinder von Go kommen, wird sehr schön dargestellt. Man bekommt dadurch ein sehr gutes Gefühl für die Stärken und Schwächen dieser Sprache. Es macht definitiv Lust auf Go allgemein und auf Microservices im Speziellen.

Der Microservice-Aspekt

Das Buch ist empfehlenswert für fortgeschrittene Softwareentwickler*innen, als sehr gute Zusammenfassung relevanter Aspekte von Microservices und wie man typische Szenarien in dieser Software-Architektur löst. Aber auch für ambitionierte Junior-Entwickler*innen, denen Microservices bisher fremd waren.

Die Komplexität von Microservices wird in diesem Buch in ihre einzelnen Aspekte aufgeschlüsselt. Es wird klar, wie und wo Microservices funktionieren, was man tun und was man besser tunlichst lassen sollte.

Allein mit diesem Buch wird man sicher noch kein Profi mit Microservices. Aber mehr als andere Bücher zu diesem Thema erhält man hier alles, was man für den Start benötigt – und sogar mehr: der Weg, auf dem man sich weiter und noch tiefergehend mit Microservices beschäftigen kann, wird hier deutlich erkennbar aufgezeigt. Eine unschätzbare Hilfe an Orientierung und Wegfindung im weiten Feld der Microservices.

Dinge die … fehlen?

Was das Buch nicht bietet, ist ein tieferer Einblick in Infrastruktur-Themen wie Kubernetes-Cluster oder Cloud-Anbieter. Hier wird Grundsätzliches kurz angesprochen, damit man eine erste Vorstellung davon bekommt. Mehr würde aber den Umfang des Buches sehr deutlich anwachsen lassen – und dieses mehr liegt auch nicht im Fokus des Autors. Man erfährt jedoch, wie und wo man sich weiter mit der Thematik beschäftigen kann.

Auch das Programmierbeispiel in Go ist für meinen Geschmack etwas kurz geraten. Es wird immer wieder in Fragmenten verwendet, die grösseren Zusammenhänge werden jedoch einmal kurz beschrieben.

Es gibt im Laufe des Buches viele kleine Details und Code-Fragmente aus der Gesamtapplikation. Das erhöht den Durchblick beim jeweiligen Teilaspekt, dennoch wäre gefühlt am Ende eine Zusammenfassung schön gewesen. Andererseits muss man auch wissen, dass sich Microservices in Go einfach und effizient umsetzen lassen … Weniger ist oft mehr, das sieht man dann auch an den Code-Beispielen im Buch.

Da es in deutscher Sprache verfasst ist, erlaubt dies deutschsprachigen Entwickler*innen auch mal, einige Kapitel schneller quer zu lesen. 

Insgesamt eine klare Empfehlung von mir, sich dieses Buch anzuschauen und durchzuarbeiten – als Einstieg in Go und umfassenden Überblick zu Microservices.

Für neue Blogupdates anmelden:


Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.