Java-Microservices mit gRPC - Beratung, Coaching und Schulung

Einführung: Microservices und gRPC

• Microservices mit gRPC: wann binäre RPC-Aufrufe REST überlegen sind und wann nicht
• Dienstübergreifende Kommunikation: synchron, asynchron, Kopplung und Verträge
• gRPC-Framework im Überblick: Herkunft, unterstützte Sprachen, gRPC-Java als Implementierung
• Funktionen von gRPC: Streaming, Deadlines, Abbruch, Metadaten, Interceptoren, Lastverteilung
• gRPC-Grundlagen: Dienst, Methode, Nachricht, Kanal und Stub
• Schritte zur Entwicklung eines gRPC-Dienstes: Vertrag, Codegenerierung, Implementierung, Client
• gRPC im Browser und für externe Partner: gRPC-Web, Transcoding nach JSON, REST-Gateway

HTTP/2 und Protocol Buffers

• Grenzen von HTTP/1.1: Head-of-Line-Blocking, Textprotokoll, viele Verbindungen
• Was HTTP/2 besser macht: Multiplexing, Streams, Header-Kompression mit HPACK, Flusskontrolle
• Protocol Buffers verstehen: Schema, Feldnummern und binäre Kodierung
• Protobuf in Java verwenden: Nachrichten mit Buildern erzeugen, serialisieren und parsen
• Schemas weiterentwickeln: Felder ergänzen, reserved, optional und Abwärtskompatibilität
• Well-Known Types wie Timestamp, Duration und Empty einsetzen
• Proto-Dateien mit Buf prüfen: Linting und Erkennen inkompatibler Änderungen

Bausteine von gRPC in Java

• gRPC-API einrichten: BOM von gRPC-Java, Netty-Transport, protoc und protoc-gen-grpc-java
• Dienstdefinition mit service und rpc in Protobuf, Optionen wie java_package
• Stubs generieren mit protoc oder dem Maven- bzw. Gradle-Plugin
• Generierte Klassen: Nachrichten, ImplBase, blockierender, asynchroner und Future-Stub
• Metadaten als Header, ManagedChannel aufbauen, wiederverwenden und sauber schließen
• Arten von gRPC-Aufrufen: unär, Server-Streaming, Client-Streaming und bidirektional
• StreamObserver richtig bedienen: onNext, onError, onCompleted und Gegendruck

Benutzerdienst mit gRPC erstellen

• Überblick über die Auftragsverwaltung aus Benutzer- und Bestelldienst
• Maven-gRPC-Projekt mit Plugin und eigenem API-Modul für die Proto-Dateien
• user.proto definieren und Service-Stubs generieren
• Datenbankcode einrichten: JDBC mit PostgreSQL oder H2 und Verbindungspool
• Datenbankmethode zum Abrufen von Benutzerdetails
• Service-Stub implementieren: Anfrage lesen, Antwort bauen, Fehler als Status melden
• Benutzerdienst mit ServerBuilder hosten, Ports und geordnetes Herunterfahren
• Benutzerdienst testen mit grpcurl und Server-Reflection

Auftragsverwaltungsdienst mit gRPC erstellen

• order.proto definieren, gemeinsame Nachrichten importieren und Stubs generieren
• Datenbankmethode zum Abrufen von Bestellungen
• Service-Methode für Bestelldetails, Bestellungen eines Benutzers per Server-Streaming
• Bestelldienst hosten, Port und Datenbankzugang aus der Konfiguration lesen
• Bestelldienst mit einem Java-Client testen
• Zusammenspiel planen: welcher Dienst wen aufruft und mit welchem Vertrag
• Client für den Bestelldienst schreiben: Kanal, Stub und Deadline
• Bestellclient aus dem Benutzerdienst aufrufen und Fehler gezielt weiterreichen
• Gesamten Ablauf der Auftragsverwaltung Ende zu Ende testen

Fehlerbehandlung, Deadlines und Resilienz

• Statuscodes wie NOT_FOUND, INVALID_ARGUMENT und UNAVAILABLE gezielt einsetzen
• Ausführliche Fehlerdetails mit google.rpc.Status und ErrorInfo
• Deadlines setzen, über Dienstgrenzen weitergeben und Abbrüche über Context erkennen
• Wiederholungen per Service Config, Keepalive und clientseitige Lastverteilung
• Server- und Client-Interceptoren für Authentifizierung, Logging und Korrelations-IDs

Sicherheit, Tests und Beobachtbarkeit

• Transportverschlüsselung mit TLS und gegenseitige Authentifizierung mit mTLS
• Tokens als Metadaten übertragen und prüfen, z. B. JWT im authorization-Header
• Unit-Tests ohne Netzwerk mit dem In-Process-Transport von gRPC-Java
• Integrationstests der Dienste mit Testcontainers
• Health-Checking-Protokoll von gRPC für Probes in Kubernetes
• Metriken und verteiltes Tracing mit OpenTelemetry

gRPC mit Spring Boot und Quarkus

• Spring gRPC: Starter für Server und Client, Dienste als Spring-Beans, Konfiguration per Properties
• Bestandsprojekte mit dem Community-Starter grpc-spring-boot-starter auf Spring gRPC umstellen
• Quarkus gRPC: Codegenerierung im Build, @GrpcService und Mutiny-Stubs
• Dev-Modus und Native Image mit Quarkus für schnelle Startzeiten

gRPC-Dienste mit Claude Code entwickeln

• Änderungen des Agenten an .proto-Dateien mit buf breaking gegen den Hauptzweig prüfen
• Generierten gRPC-Code nie editieren lassen – Änderungen nur im Vertrag und in der Implementierung
• Erst In-Process-Tests für den Vertrag, dann implementiert der Agent die Dienstmethode
• Aufrufe ohne Deadline und verschluckte StatusRuntimeExceptions im Review zurückweisen
• Agent fragt den laufenden gRPC-Dienst über Server-Reflection mit grpcurl ab und belegt seine Änderung

Praxisprojekt: Lagerbestand und Bestellannahme für einen Onlineshop

• Lagerdienst mit unärer Bestandsabfrage und Server-Streaming für Bestandsänderungen
• Bestelldienst reserviert Ware per gRPC mit Deadline und sauberer Abbildung der Statuscodes
• TLS zwischen den Diensten, Health-Checks und Traces mit OpenTelemetry
• Ein Dienst mit Spring gRPC, einer mit Quarkus – beide aus demselben Proto-Modul

Lernziele

• Sie beurteilen, wann gRPC für die Kommunikation zwischen Java-Microservices passt und wann REST die bessere Wahl ist
• Sie entwerfen Protobuf-Verträge, die sich abwärtskompatibel weiterentwickeln lassen, und generieren daraus Stubs
• Sie implementieren unäre und streamende gRPC-Dienste und -Clients in Java mit Datenbankanbindung
• Sie setzen Statuscodes, Deadlines, Interceptoren und TLS gezielt ein und testen Dienste mit In-Process-Transport
• Sie betreiben gRPC-Dienste mit Health-Checks und Tracing und setzen sie mit Spring Boot oder Quarkus um

Zielgruppe

• Java-Backend-Entwickler:innen, die Microservices bauen oder erweitern
• Architekt:innen, die die Kommunikation zwischen Diensten festlegen
• Teams, die bestehende REST-Schnittstellen zwischen internen Diensten durch gRPC ergänzen wollen