Verteilte Dienste mit Go

Einleitung

Das Buch „Distributed Services with Go“ (auf Deutsch: „Verteilte Dienste mit Go“) von Travis Jeffrey erschien 2021 und erregte sofort die Aufmerksamkeit von Entwicklern, die mit der Sprache Go (Golang) arbeiten. Es ist kein weiteres Nachschlagewerk zur Syntax, sondern ein praktischer Leitfaden zur Erstellung realer verteilter Systeme. Der Autor führt den Leser vom Schreiben eines einfachen HTTP-Servers bis zum Deployment eines vollwertigen, ausfallsicheren Dienstes in Kubernetes unter Verwendung von gRPC, dem Raft-Protokoll und modernen Praktiken der Beobachtbarkeit (Observability).

Das Buch umfasst 256 Seiten und richtet sich an diejenigen, die bereits mit den Grundlagen von Go vertraut sind und tiefer in die Architektur verteilter Anwendungen eintauchen möchten. Travis Jeffrey ist ein erfahrener Ingenieur, der bei Heroku und anderen Technologieunternehmen gearbeitet hat, daher sind seine Ratschläge durch praktische Erfahrung untermauert.

Worum es in dem Buch geht

Die Hauptidee des Buches ist es zu zeigen, wie man einen verteilten Dienst „von Grund auf“ aufbaut, indem man nur die Standardwerkzeuge und -bibliotheken von Go verwendet, und dann schrittweise Funktionalität hinzufügt: Replikation, Service Discovery, Sicherheit und Deployment. Jedes Kapitel widmet sich einem bestimmten Aspekt:

• Kapitel 1-2: Grundlagen von gRPC und Protocol Buffers – wie man eine API definiert und Code generiert.
• Kapitel 3-4: Implementierung von Server und Client, Fehlerbehandlung, Datenstreaming.
• Kapitel 5: Einführung in den Konsensalgorithmus Raft und seine Implementierung mit der Bibliothek hashicorp/raft.
• Kapitel 6: Log-Replikation und Gewährleistung von Ausfallsicherheit.
• Kapitel 7: Service Discovery und dynamische Konfiguration.
• Kapitel 8: Sicherheit: TLS, Authentifizierung und Autorisierung.
• Kapitel 9: Beobachtbarkeit: Logging (strukturiertes Logging), Metriken (Prometheus) und Tracing (OpenTelemetry).
• Kapitel 10: Deployment in Kubernetes: Erstellung von Dockerfile, Manifesten, Helm-Charts.

Jedes Kapitel enthält praktische Codebeispiele, die ausgeführt und modifiziert werden können. Am Ende des Buches erhält der Leser einen fertigen verteilten Dienst zur Speicherung und Replikation von Logs.

Für wen ist dieses Buch geeignet

Das Buch richtet sich an Go-Entwickler mittleren Niveaus, die bereits einfache Anwendungen in Go schreiben können und nun zu verteilten Systemen übergehen möchten. Es wird auch nützlich sein für:

• Backend-Ingenieure, die sich für Microservices-Architektur interessieren.
• DevOps-Spezialisten, die das Innenleben von Diensten besser verstehen möchten.
• Studenten und Dozenten von Kursen über verteiltes Rechnen.

Für die Lektüre sind Grundkenntnisse in Go (Goroutinen, Channels, Interfaces) und ein allgemeines Verständnis von Netzwerkprotokollen (TCP/IP, HTTP) wünschenswert. Kenntnisse in Kubernetes und gRPC sind nicht erforderlich – der Autor erklärt alles von Grund auf.

Was der Leser lernen wird

Nach der Lektüre des Buches werden Sie in der Lage sein:

• gRPC-APIs mit Protocol Buffers zu entwerfen und zu implementieren.
• Den Konsensalgorithmus Raft zur Gewährleistung von Ausfallsicherheit zu integrieren.
• Service Discovery mit einem etcd-Client oder Consul einzurichten.
• Verschlüsselung und Authentifizierung über TLS hinzuzufügen.
• Strukturiertes Logging, Metriken und verteiltes Tracing zu integrieren.
• Die Anwendung in ein Docker-Image zu packen und in Kubernetes bereitzustellen.
• Tests für verteilte Komponenten zu schreiben.

Stärken

Eine der Hauptstärken des Buches ist seine praktische Ausrichtung. Sie lesen nicht nur Theorie, sondern schreiben Code, der sofort verwendet werden kann. Der Autor verwendet aktuelle Versionen von Bibliotheken und Werkzeugen (Go 1.16+, gRPC, Kubernetes).

Das Buch ist gut strukturiert: Jedes Kapitel beginnt mit einer Problemstellung und endet mit einer Zusammenfassung. Der Code ist mit Kommentaren versehen, und komplexe Konzepte (z. B. Raft) werden erklärt.