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

22 Oct 2019 - Matthias Voigt

Mit der Einführung von gRPC in .NET Core bietet Microsoft eine leistungsstarke und effiziente Methode zur Kommunikation zwischen Microservices. gRPC (gRPC Remote Procedure Calls) ist ein modernes, Open-Source-RPC-Framework, das auf HTTP/2 basiert und Protokollpuffer (Protocol Buffers) zur Serialisierung von Daten verwendet. In diesem Artikel werde ich die Vorteile und die Implementierung von gRPC in .NET Core erläutern.

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

gRPC bietet eine moderne und effiziente Möglichkeit, Microservices zu kommunizieren. Mit seiner hohen Leistung, Typensicherheit und plattformübergreifenden Unterstützung ist gRPC eine hervorragende Wahl für den Aufbau skalierbarer und robuster Microservices-Architekturen. Es lohnt sich, diese Technologie in zukünftigen Projekten zu erkunden und zu nutzen.

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