.Net Core + gRPC = Best Friends

Mit der Neu-Entwicklung des .NET Core hat Microsoft die Karten neu gemischt und sich stärker aufgestellt. Das .NET Framework 4.x ist bekanntlich ein großer Monolith und die starren Strukturen wurden bei der Portierung auf .NET Core modularisiert. Microsoft hat im Zuge der Portierung einige Libraries (z.B. WCF) nicht mehr unterstützt.

Firmen, die in Ihren Anwendungen WCF im Einsatz haben, suchen in .NET Core vergeblich nach einer offiziellen Portierung. Es bieten sich allerdings interessante Möglichkeiten an, die Anwendungen auf .NET Core zu portieren.

Ob es ein Zufall war oder nicht, ab der .NET Core 3.0 bietet Google mit gRPC eine Kommunikationstechnologie erstmal für .NET an, die in Zukunft mit großer Sicherheit seinen Platz im klassischen Service – Layer und Microservices innehat. Vielleicht ist das auch der Grund warum Microsoft WCF fallengelassen hat.

Die Aussage von Scott Hunter (Mitarbeiter, Microsoft) ist eindeutig:

„If you are a remoting or WCF Server developer and want to build a new application on .NET Core, we would recommend either ASP.NET Core Web APIs or gRPC“

In diesem Blog-Artikel erhalten Sie eine umfassende Übersicht zum Thema gRPC und welche Portierungsmöglichkeiten von WCF auf .NET Core sich anbieten.

Welcome gRPC

Google kann man aktuell als treibende Kraft betrachten, wenn es um die Entwicklung von RPC-Frameworks handelt.

Anfang der Jahrtausendwende hat Google eine Lösung gesucht, wie sie ihre dezentrale organisierte interne Technik am besten miteinander verbinden kann. Genauso soll das RPC Framework die Service-Anfragen Ihrer Suchmaschine tragen können.

Der Vorgänger mit dem Namen „Stubby“ wurde geboren und Google hatte zur Jahrtausendwende schon in Microservices gedacht, da hatte z.B. Martin Fowler das Buch „Patterns of Enterprise Application Architecture“ publiziert.

Die Vorteile einer einheitlichen, plattformübergreifenden RPC-Infrastruktur konnten Verbesserungen in Bezug auf Effizienz, Sicherheit, Zuverlässigkeit und Verhaltensanalyse erzielt werden, die für das unglaubliche Wachstum in diesem Zeitraum von entscheidender Bedeutung waren.

Das Ende von „Stubby“ hat pragmatische Gründe. Mit dem Aufkommen von SPDY, HTTP / 2 und QUIC sind viele dieser Funktionen in öffentlichen Standards erschienen, zusammen mit anderen Funktionen, die Stubby nicht bietet. Es wurde klar, dass es an der Zeit war, Stubby zu überarbeiten, um die Vorteile dieser Standardisierung zu nutzen und ihre Anwendbarkeit auf mobile, IoT- und Cloud-Anwendungsfälle auszudehnen. Der Startschuss für gRPC

gRPC stellt sich vor

Der Kern von gRPC – Framework ist in C/C++ geschrieben, dieser umfasst den Serverdienst, Proto-File Compiler, Kommunikation, Authentifizierung, sowie eine Toolsammlung u.a. für das generieren der Serverseitigen Schnittstellenimplementierung in Form einer Code-Behind Datei.

Die erste Beta Version von gRPC wurde im März 2015 veröffentlicht und unterstützt heute fast jede gängige Programmiersprache.

Die Kommunikation zwischen Client und Service verläuft mithilfe von Channels und verwenden in der Basis die HTTP/2 Stream – Funktionalität.

Vorteile von gRPC:

- Leistungsstarkes und leichtes RPC-Framework.

- Contract-First-API-Entwicklung

- Sprachneutrale Definitionen von Services und Typen mithilfe von Protocol Buffer.

- Protokoll Puffer Compiler unterstützt das Generieren stark typisierter Server und Clients.

- Unterstützt Client-, Server- und bidirektionale Streaming-Anrufe.

- Reduzierte Netzwerknutzung durch binäre Serialisierung von Protobuf.

Der Einsatz ist für folgende Use Cases fast schon prädestiniert:

- Microservices, bei denen Effizienz entscheidend ist.

- Polyglott-Systeme, bei denen für die Entwicklung mehrere Sprachen erforderlich sind.

- Point-to-Point Realtime Service, die Streaming-Requests oder -Responses verarbeiten müssen.

- Durch die binäre und kompakte Übertragung wird gRPC auch für den Mobile-App Markt ein interessanter Service-Variante sein.

Seit den Versionen .NET Core 3.0 kann, mithilfe von Visual Studio 2019, über ein Projekt-Template einen gRPC-Service sehr einfach erstellen.

Microsofts Engagement und eine weitere interessante gRPC Variante

Wenn wir von gRPC reden, ist in erster Linie die Google-Variante (Grpc.Core) gemeint.

Seit dem November 2018 arbeiten Microsoft in Zusammenarbeit mit dem gRPC-Team an einer weiteren gRPC-Variante mit dem Namen grpc-dotnet. Der Sourcecode von grpc-dotnet basiert auf dem .NET Core 3.0 und ist eine reine C#-Implementierung.

Im Gegensatz zur vorhandenen C-Core basierten Implementierung (Grpc.Core) verwenden die neuen Bibliotheken (grpc-dotnet) die vorhandenen .NET Core Base Class Libraries (BCL).

Der Vorteil der grpc-dontnet soll eine bessere Einbettung in das Asp.net Core ECO-System ermöglichen.

Ein Blick in beide Motorhauben: (Diagrammquelle: https://grpc.io/blog/grpc-on-dotnetcore/)

image_thumb[2]

Beide Implementierungen sind in GitHub zu finden:

Grpc.Core: https://github.com/grpc/grpc/tree/master/src/csharp

grpc-dotnet: https://github.com/grpc/grpc-dotnet

Contract-First Ansatz

Das Konzept von gRPC ist sehr einfach gehalten und basiert (wie WCF), auf einem Contract-First Ansatz.

Ein gRPC-Service wird über eine Schnittstelle definiert, die Methoden und dessen Parameter und Rückgabewerte für einen Remote Call bereitstellen.

Für die Definierung der Schnittstelle, wird in gRPC standardgemäß die Protocol Buffer Engine verwendet. Diese beschreibt den gRPC-Service in einer Proto – File und verwendet als IDL (Interface Definition Language) die Protocol Buffers in der Version 3.

Falls gewünscht, kann Protocol Buffers als IDL durch eine Alternative Markup-Language ausgetauscht werden.

Damit wir einen Eindruck von Protocol Buffers erhalten, schauen wir und eine Schnittstellen-Definition in einer Proto-Datei an.

// The greeting service definition.
service Greeter {   // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply);
}
 
// The request message containing the user's name.
message HelloRequest {   string name = 1;
}
 
// The response message containing the greetings.
message HelloReply {   string message = 1;
}

Der gRPC-Service heißt in unserem Beispiel HelloService und beinhaltet die Methode SayHello mit dem Parameter HelloRequest und den Rückgabe HelloResponse.

HelloRequest und HelloResponse werden als Message-Struktur separat definiert. Innerhalt jeder Message-Struktur wird jede Variablendefinition mit einem Index versehen. Dieser gibt die Reihenfolge der Variablen bei der Serialisierung und Deserialisierung der Nachricht an.

Was wird jetzt aus WCF?

Microsoft hat angekündigt, dass alle WCF Lösungen in Asp.net Core eine Portierung bevorsteht, oder auch doch nicht.

Eine kleine Schar um den Microsoft-Entwickler Matt Connew hat sich mit Erfolg drauf und dran gemacht WCF auf Asp.Net Core zu portieren. Das Projekt heißt nicht anders erwartet CoreWCF.

Aktuell hat allerdings CoreWCF den tristen Status einer „Dritt-Library“. Vielleicht ist es ja gerade Matt Connew, der vielleicht CoreWCF zu einem späteren in eine zukünftige .NET Framework Version wieder mit auf die Roadmap bringt. Für WCF-Liebende hört sich das nach einem Hoffnung-Wink an.

CoreWCF – Repository:

https://github.com/CoreWCF/CoreWCF

Kommentare sind geschlossen