gRPC in .NET Core: Moderne Kommunikation für Microservices

• .NET
• ASP.NET

Dienstag, 22. Oktober 2019 - Matt

gRPC ist ein RPC-Framework auf Basis von HTTP/2, das Protocol Buffers zur Serialisierung nutzt. Seit .NET Core lässt es sich ohne Umwege einsetzen. Hier geht es darum, wofür sich das gegenüber einer JSON-Web-API lohnt und wie die Umsetzung aussieht.

Was ist gRPC?

gRPC ermöglicht es, Remote Procedure Calls (RPCs) zwischen Anwendungen durchzuführen. Es bietet viele Vorteile gegenüber traditionellen HTTP-APIs, darunter:

• Hohe Leistung: Dank HTTP/2 und Protokollpuffern ist gRPC äußerst performant und effizient.
• Strukturierte Kommunikation: Die Verwendung von Protokollpuffern gewährleistet eine klare und typensichere Kommunikation zwischen Diensten.
• Plattformübergreifend: gRPC unterstützt eine Vielzahl von Programmiersprachen und Plattformen, was es ideal für Microservices-Architekturen macht.

Vorteile von gRPC

1. Effizienz: gRPC nutzt HTTP/2, was zu geringerer Latenz und besserer Komprimierung führt.
2. Typensicherheit: Protokollpuffer sorgen für eine strenge Typprüfung und verhindern viele Arten von Fehlern zur Laufzeit.
3. Einfache Definition: Mit gRPC können Schnittstellen einfach definiert und implementiert werden, was die Entwicklung beschleunigt.

Ein einfaches gRPC-Beispiel

Schritt 1: Projekt einrichten

Erstelle ein neues gRPC-Projekt in Visual Studio:

1. Öffne Visual Studio.
2. Gehe zu “Datei” > “Neues Projekt”.
3. Wähle “ASP.NET Core gRPC Service” und klicke auf “Weiter”.
4. Gib deinem Projekt einen Namen und wähle den Speicherort aus.
5. Klicke auf “Erstellen”.

Schritt 2: Protobuf-Datei definieren

Erstelle eine .proto-Datei zur Definition der gRPC-Dienste und Nachrichten:

syntax = "proto3";

option csharp_namespace = "GrpcService";

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

Schritt 3: Dienst implementieren

Implementiere den gRPC-Dienst in C#:

using Grpc.Core;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

public class GreeterService : Greeter.GreeterBase
{
    private readonly ILogger<GreeterService> _logger;
    public GreeterService(ILogger<GreeterService> logger)
    {
        _logger = logger;
    }

    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = "Hello " + request.Name
        });
    }
}

Schritt 4: Dienst konfigurieren

Konfiguriere den gRPC-Dienst in der Startup.cs-Datei:

public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGrpcService<GreeterService>();

        endpoints.MapGet("/", async context =>
        {
            await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client.");
        });
    });
}

Schritt 5: Client erstellen

Erstelle einen gRPC-Client, um den Dienst zu testen:

using Grpc.Net.Client;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        using var channel = GrpcChannel.ForAddress("https://localhost:5001");
        var client = new Greeter.GreeterClient(channel);
        var reply = await client.SayHelloAsync(new HelloRequest { Name = "World" });
        Console.WriteLine("Greeting: " + reply.Message);
    }
}

Fazit

Der Gewinn gegenüber JSON über HTTP liegt vor allem im Vertrag: Die .proto-Datei ist die einzige Wahrheit, Client und Server werden daraus erzeugt. Dafür handelt man sich ein Binärformat ein, das sich nicht mehr eben im Browser mitlesen lässt.

Für weitere Details und eine ausführliche Anleitung besuche die offizielle Microsoft-Dokumentation.

Der offizielle Einstieg: gRPC-Dienste mit .NET.