Gambaran umum untuk gRPC di .NET

Oleh James Newton-King

gRPC adalah kerangka kerja Panggilan Prosedur Jarak Jauh (RPC ) agnostic bahasa dengan performa tinggi.

Manfaat utama gRPC adalah:

• Kerangka kerja RPC modern, berperforma tinggi, dan ringan.
• Pengembangan API yang mengutamakan kontrak, menggunakan Protocol Buffers secara default, memungkinkan implementasi agnostik bahasa.
• Alat tersedia untuk banyak bahasa guna menghasilkan server dan klien yang bersifat strongly typed.
• Mendukung klien, server, dan panggilan streaming dua arah.
• Mengurangi penggunaan jaringan dengan serialisasi biner Protobuf.

Manfaat ini menjadikan gRPC ideal untuk:

• Layanan mikro ringan di mana efisiensi sangat penting.
• Sistem poliglot di mana banyak bahasa diperlukan untuk pengembangan.
• Layanan real time point-to-point yang perlu menangani permintaan atau respons streaming.

Dukungan Alat C# untuk file .proto

gRPC menggunakan pendekatan yang mengutamakan kontrak untuk pengembangan API. Layanan dan pesan ditentukan dalam file .proto:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Jenis .NET untuk layanan, klien, dan pesan dibuat secara otomatis dengan menyertakan file .proto dalam proyek:

• Tambahkan referensi paket ke paket Grpc.Tools.
• Tambahkan file .proto ke grup item <Protobuf>.

<ItemGroup>
  <Protobuf Include="Protos\greet.proto" />
</ItemGroup>

Untuk informasi lebih lanjut tentang dukungan alat gRPC, lihat layanan gRPC dengan C#.

Layanan gRPC di ASP.NET Core

Layanan gRPC dapat dihosting di ASP.NET Core. Layanan memiliki integrasi penuh dengan fitur ASP.NET Core seperti pengelogan, injeksi dependensi (DI), autentikasi, dan otorisasi.

Menambahkan layanan gRPC ke aplikasi ASP.NET Core

gRPC memerlukan paket Grpc.AspNetCore. Untuk informasi tentang mengonfigurasi gRPC di aplikasi .NET, lihat Mengonfigurasi gRPC.

Template proyek layanan gRPC

Template proyek Layanan gRPC ASP.NET Core menyediakan layanan starter:

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)
    {
        _logger.LogInformation("Saying hello to {Name}", request.Name);
        return Task.FromResult(new HelloReply 
        {
            Message = "Hello " + request.Name
        });
    }
}

GreeterService mewarisi dari jenis GreeterBase, yang dihasilkan dari layanan Greeter dalam file .proto. Layanan dapat diakses oleh klien di Program.cs:

app.MapGrpcService<GreeterService>();

Untuk mempelajari lebih lanjut tentang layanan gRPC di ASP.NET Core, lihat Layanan gRPC dengan ASP.NET Core.

Memanggil layanan gRPC dengan klien .NET

Klien gRPC adalah jenis klien konkret yang dihasilkan dari file .proto. Klien gRPC konkret memiliki metode yang diterjemahkan ke layanan gRPC dalam file .proto.

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);

var response = await client.SayHelloAsync(
    new HelloRequest { Name = "World" });

Console.WriteLine(response.Message);

Klien gRPC dibuat menggunakan saluran, yang mewakili koneksi berumur panjang ke layanan gRPC. Saluran dapat dibuat menggunakan GrpcChannel.ForAddress.

Untuk informasi lebih lanjut tentang membuat klien, dan memanggil metode layanan yang berbeda, lihat Memanggil layanan gRPC dengan klien .NET.

Sumber Daya Tambahan:

• Layanan gRPC dengan C#
• Layanan gRPC dengan ASP.NET Core
• Memanggil layanan gRPC dengan klien .NET
• Integrasi pabrik klien gRPC di .NET
• Membuat klien dan server gRPC .NET Core di ASP.NET Core