gRPC zwischen .NET-Microservices

super-dev ✓

vor 7 Monaten • 9 min Lesezeit • 1,8k Aufrufe

▣

Minimal APIs, CQRS, gRPC, Source Generators: sauberes und testbares .NET 8, ohne unnötigen Overhead.

Zwischen Microservices bezahlt JSON über HTTP/1.1 seinen Komfort teuer: ausführliche Serialisierung, kein starker Vertrag, eine Verbindung pro Aufruf. gRPC antwortet auf genau diesen Kontext — kompaktes Binärformat über HTTP/2, ein geteilter Vertrag und generierter Code auf beiden Seiten. In .NET ist die Integration erstklassig.

Die .proto-Datei als einzige Quelle der Wahrheit

Alles beginnt mit einer .proto -Datei: Sie beschreibt die Nachrichten und den Service, unabhängig von der Sprache. Das ist der Vertrag — weder Client noch Server schreiben ihn von Hand. Darin deklariert man einen service Pricing , der einen rpc GetQuote (QuoteRequest) -Aufruf bereitstellt, der ein QuoteReply zurückgibt. Jedes Feld ist nummeriert ( string sku = 1; , int32 quantity = 2; ) — diese Nummern sind der Schlüssel zur Abwärtskompatibilität: Man darf sie niemals wiederverwenden.

Auf .NET-Seite referenziert man diese Datei im .csproj über <Protobuf Include="pricing.proto" /> . Das Package Grpc.Tools generiert dann zur Kompilierzeit die Server-Basisklasse und den typisierten Client — keine DTOs müssen manuell kopiert werden:

C#
 1// Généré par Grpc.Tools à partir de pricing.proto — ne pas éditer
 2public partial class QuoteRequest
 3{
 4    public string Sku { get; set; }
 5    public int Quantity { get; set; }
 6}

Typisierter Server und Client

Der Server leitet von der generierten Klasse Pricing.PricingBase ab und überschreibt die Methode. Kein Routing muss verdrahtet werden, keine manuelle Deserialisierung: Man empfängt eine stark typisierte Nachricht.

C#
 1public sealed class PricingService(IPriceBook book) : Pricing.PricingBase
 2{
 3    public override async Task<QuoteReply> GetQuote(
 4        QuoteRequest request, ServerCallContext context)
 5    {
 6        var unitPrice = await book.LookupAsync(request.Sku, context.CancellationToken);
 7
 8        return new QuoteReply { UnitPriceCents = unitPrice * request.Quantity };
 9    }
10}

Auf der aufrufenden Seite schreibt man ebenfalls keinen HttpClient . Man injiziert den generierten Client über AddGrpcClient und ruft ihn wie eine lokale Methode auf:

C#
 1builder.Services.AddGrpcClient<Pricing.PricingClient>(options =>
 2    options.Address = new Uri("https://pricing:443"));

Streaming als entscheidendes Argument

Wo REST an Grenzen stößt, glänzt gRPC: HTTP/2 ermöglicht Streaming in beide Richtungen. Ein serverseitiger stream liefert Ergebnisse fortlaufend aus; ein bidirektionaler stream öffnet einen Full-Duplex-Kanal, ideal für Telemetrie oder Chat. Man schreibt in einen IServerStreamWriter<T> und der Client iteriert mit await foreach — ohne Polling, ohne mühsam zusammengebauten WebSocket.

gRPC vs. REST: eine bewusste Wahl treffen

gRPC ist nicht universell. Seine Stärken — kompaktes Binärformat, starker Vertrag, Streaming, geringe Latenz — machen es zum idealen internen Werkzeug (Service-zu-Service). Seine Grenzen sind real: Ein Browser spricht gRPC nicht nativ (man benötigt gRPC-Web und einen Proxy), das Binärformat ist nicht mit bloßem Auge lesbar, und das Debugging erfordert dedizierte Tools. Für eine öffentliche API, die von Dritten konsumiert wird, bleibt REST/JSON oft die richtige Wahl. Der Microsoft-Leitfaden vergleicht beide in der doc gRPC pour .NET .

Der gesunde Reflex: REST als öffentliche Fassade, gRPC im Inneren . Der .proto-Vertrag wird so zur formalen Grenze zwischen Ihren Services — versioniert, geteilt, vom Compiler geprüft.

• super-dev — portfolio.app

// Weiter in .NET

{ }

Einen .NET 8-Monolithen stranglieren, ohne alles zu zerstören

9 min • 3,2k Aufrufe

ƒ()

Minimal APIs + EF Core: eine saubere .NET 8 API

8 min • 3,1k Aufrufe

⊕

CQRS und Vertical Slices ohne Overengineering

7 min • 2,3k Aufrufe

super-dev — full-stack

Die .proto-Datei als einzige Quelle der Wahrheit

Typisierter Server und Client

Streaming als entscheidendes Argument

gRPC vs. REST: eine bewusste Wahl treffen