gRPC چیست و چرا باید به آن اهمیت دهیم؟

gRPC یک فریم‌ورک متن‌باز و مدرن برای فراخوانی رویه‌های از راه دور (Remote Procedure Call - RPC) است که توسط گوگل توسعه یافته است. این فریم‌ورک به یک کلاینت اجازه می‌دهد تا متدی را بر روی یک اپلیکیشن سرور که در ماشینی دیگر قرار دارد، مستقیماً و به سادگی فراخوانی کند، گویی که آن متد یک شیء محلی است.

برخلاف REST که معمولاً از JSON بر بستر HTTP/1.1 استفاده می‌کند، gRPC از مزایای زیر بهره می‌برد:

• کارایی بالا: gRPC از Protocol Buffers (Protobuf) برای سریال‌سازی داده‌ها استفاده می‌کند. Protobuf یک فرمت باینری فشرده است که به مراتب سریع‌تر و کم‌حجم‌تر از JSON است. علاوه بر این، gRPC بر روی HTTP/2 ساخته شده است که قابلیت‌هایی مانند مالتی‌پلکسینگ (ارسال چندین درخواست و پاسخ همزمان روی یک اتصال)، فشرده‌سازی هدر و ارتباطات دوطرفه را فراهم می‌کند. این ویژگی‌ها منجر به کاهش چشمگیر تأخیر (latency) و افزایش توان عملیاتی (throughput) می‌شوند.

• قرارداد محور (Contract-First): در gRPC، ابتدا باید سرویس‌ها و پیام‌ها را در فایل‌های .proto تعریف کنید. این فایل‌ها به عنوان یک "قرارداد" بین کلاینت و سرور عمل می‌کنند. از این فایل‌ها می‌توان به صورت خودکار کدهای سمت کلاینت و سرور را برای زبان‌های مختلف تولید کرد که این امر باعث کاهش خطاها و تسریع فرآیند توسعه می‌شود.

• پشتیبانی از استریمینگ (Streaming): gRPC به صورت ذاتی از چهار نوع ارتباط پشتیبانی می‌کند:

  1. Unary: مدل کلاسیک درخواست و پاسخ (مانند REST).

  2. Server Streaming: کلاینت یک درخواست ارسال می‌کند و سرور جریانی از پاسخ‌ها را برمی‌گرداند.

  3. Client Streaming: کلاینت جریانی از درخواست‌ها را به سرور ارسال می‌کند و سرور در نهایت یک پاسخ واحد برمی‌گرداند.

  4. Bidirectional Streaming: کلاینت و سرور می‌توانند به صورت همزمان و مستقل از هم، جریانی از پیام‌ها را برای یکدیگر ارسال کنند. این قابلیت برای سناریوهای بلادرنگ مانند چت یا بازی‌های آنلاین ایده‌آل است.

• چند زبانه بودن: gRPC به گونه‌ای طراحی شده است که مستقل از زبان برنامه‌نویسی باشد و ابزارهای قدرتمندی برای تولید کد در زبان‌های مختلفی از جمله C#, Java, Python, Go و بسیاری دیگر فراهم می‌کند.

طراحی سرویس gRPC: اصول و بهترین شیوه‌ها

طراحی یک سرویس gRPC با تعریف آن در یک فایل .proto آغاز می‌شود. این فایل قلب سرویس شماست و ساختار داده‌ها (پیام‌ها) و عملیات (سرویس‌ها) را مشخص می‌کند.

تعریف پیام‌ها و سرویس‌ها در Protocol Buffers

فرض کنید می‌خواهیم یک سرویس ساده برای مدیریت اطلاعات کاربران طراحی کنیم. فایل user.proto ما به شکل زیر خواهد بود:

Protocol Buffers

syntax = "proto3";

option csharp_namespace = "UserManagement.Grpc";

package user;

// تعریف سرویس کاربر
service UserService {
  // یک متد Unary برای گرفتن اطلاعات کاربر
  rpc GetUser (GetUserRequest) returns (UserResponse);

  // یک متد Server Streaming برای دریافت لیستی از کاربران
  rpc GetAllUsers (GetAllUsersRequest) returns (stream UserResponse);
}

// پیام درخواست برای GetUser
message GetUserRequest {
  int32 user_id = 1;
}

// پیام درخواست خالی برای GetAllUsers
message GetAllUsersRequest {
}

// پیام پاسخ شامل اطلاعات کاربر
message UserResponse {
  int32 user_id = 1;
  string first_name = 2;
  string last_name = 3;
  string email = 4;
}

در این مثال:

• syntax = "proto3"; نسخه سینتکس Protobuf را مشخص می‌کند.

• service UserService یک سرویس با دو متد RPC تعریف می‌کند.

• rpc GetUser (GetUserRequest) returns (UserResponse); یک متد Unary تعریف می‌کند که یک GetUserRequest دریافت و یک UserResponse برمی‌گرداند.

• returns (stream UserResponse) نشان‌دهنده یک متد Server Streaming است.

• message ها ساختارهای داده‌ای هستند که بین کلاینت و سرور رد و بدل می‌شوند. هر فیلد دارای یک نوع داده و یک شماره منحصر به فرد است که برای سریال‌سازی باینری استفاده می‌شود.

مدیریت خطا (Error Handling)

مدیریت خطا در gRPC با استفاده از کدهای وضعیت (Status Codes) استاندارد انجام می‌شود. به جای استفاده از try-catch های سنتی برای خطاهای تجاری، باید یک RpcException با کد وضعیت مناسب پرتاب کنید.

برای مثال، اگر کاربری یافت نشد، به جای بازگرداندن null، باید یک استثنا با کد StatusCode.NotFound پرتاب کنید:

public override async Task GetUser(GetUserRequest request, ServerCallContext context)
{
    var user = await _userService.FindUserByIdAsync(request.UserId);

    if (user == null)
    {
        throw new RpcException(new Status(StatusCode.NotFound, $"User with ID {request.UserId} not found."));
    }

    // ... map user to UserResponse
    return userResponse;
}

برای سناریوهای پیچیده‌تر، مانند خطاهای اعتبارسنجی، می‌توانید از "Rich Error Model" استفاده کنید که به شما اجازه می‌دهد جزئیات بیشتری را در مورد خطا به کلاینت ارسال نمایید.

پیاده‌سازی gRPC در ASP.NET Core

با استفاده از قالب‌های پروژه دات‌نت، ایجاد یک سرویس gRPC بسیار ساده است.

ساخت سرور gRPC

1. ایجاد پروژه: یک پروژه جدید از نوع "ASP.NET Core gRPC Service" در ویژوال استودیو یا با استفاده از دستور dotnet new grpc ایجاد کنید.

2. پیاده‌سازی سرویس: کلاس سرویس شما باید از کلاس پایه‌ای که به صورت خودکار از فایل .proto تولید شده، ارث‌بری کند. برای مثال بالا، کلاسی به نام UserServiceImpl ایجاد می‌کنیم که از UserService.UserServiceBase ارث‌بری می‌کند و متدهای RPC را پیاده‌سازی می‌نماید.

public class UserServiceImpl : UserService.UserServiceBase
{
    private readonly ILogger _logger;
    private readonly IUserRepository _userRepository;

    public UserServiceImpl(ILogger logger, IUserRepository userRepository)
    {
        _logger = logger;
        _userRepository = userRepository;
    }

    public override async Task GetUser(GetUserRequest request, ServerCallContext context)
    {
        var user = await _userRepository.GetByIdAsync(request.UserId);
        if (user == null)
        {
            throw new RpcException(new Status(StatusCode.NotFound, "User not found."));
        }
        return new UserResponse { /* ... asembling response ... */ };
    }

    public override async Task GetAllUsers(GetAllUsersRequest request, IServerStreamWriter responseStream, ServerCallContext context)
    {
        var allUsers = await _userRepository.GetAllAsync();
        foreach (var user in allUsers)
        {
            await responseStream.WriteAsync(new UserResponse { /* ... asembling response ... */ });
        }
    }
}

3. پیکربندی: سرویس خود را در فایل Program.cs ثبت کنید:

builder.Services.AddGrpc();

var app = builder.Build();

app.MapGrpcService();
app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client.");

app.Run();

ساخت کلاینت gRPC

کلاینت gRPC مسئول برقراری ارتباط با سرور و فراخوانی متدهای آن است.

1. ایجاد پروژه: یک پروژه کنسول یا هر نوع پروژه دات‌نت دیگر برای کلاینت ایجاد کنید.

2. افزودن بسته‌ها: بسته‌های NuGet زیر را اضافه کنید:

   • Grpc.Net.Client

   • Google.Protobuf

   • Grpc.Tools

3. ارجاع به فایل .proto: فایل .proto را از پروژه سرور به پروژه کلاینت اضافه کنید و در فایل .csproj آن را به عنوان کلاینت مشخص نمایید:

4. فراخوانی سرویس: یک کانال ارتباطی با سرور ایجاد کرده و سپس یک نمونه از کلاینت بسازید.

using var channel = GrpcChannel.ForAddress("https://localhost:7001");
var client = new UserService.UserServiceClient(channel);

// فراخوانی متد Unary
try
{
    var user = await client.GetUserAsync(new GetUserRequest { UserId = 1 });
    Console.WriteLine($"User: {user.FirstName} {user.LastName}");
}
catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
{
    Console.WriteLine(ex.Status.Detail);
}

// فراخوانی متد Server Streaming
using var call = client.GetAllUsers(new GetAllUsersRequest());
await foreach (var user in call.ResponseStream.ReadAllAsync())
{
    Console.WriteLine($"Found user: {user.FirstName}");
}

ملاحظات پیشرفته

احراز هویت و مجوزدهی (Authentication & Authorization)

gRPC به خوبی با مکانیزم‌های احراز هویت و مجوزدهی ASP.NET Core ادغام می‌شود. می‌توانید از توکن‌های JWT، گواهی‌های کلاینت یا هر روش دیگری که در ASP.NET Core پشتیبانی می‌شود، استفاده کنید. توکن‌ها معمولاً به عنوان متادیتا (Metadata) در هدر هر درخواست ارسال می‌شوند و یک Middleware در سمت سرور مسئول اعتبارسنجی آن‌هاست.

تست کردن سرویس‌های gRPC

برای تست سرویس‌های gRPC در دات‌نت دو رویکرد اصلی وجود دارد:

• تست واحد (Unit Testing): می‌توانید منطق سرویس خود را با ماک کردن (Mocking) وابستگی‌ها و ServerCallContext تست کنید.

• تست یکپارچه‌سازی (Integration Testing): با استفاده از WebApplicationFactory و Grpc.Net.Client می‌توانید یک سرور تستی در حافظه اجرا کرده و یک کلاینت واقعی را برای فراخوانی سرویس‌های آن به کار بگیرید. این روش تست کامل‌تری از کل پایپ‌لاین درخواست ارائه می‌دهد.

نسخه‌بندی (Versioning)

همانند هر API دیگری، مدیریت تغییرات در سرویس‌های gRPC نیز حائز اهمیت است. بهترین روش، ایجاد تغییرات غیرشکننده (Non-breaking changes) است، مانند افزودن فیلدهای جدید به پیام‌ها یا افزودن متدهای RPC جدید. برای تغییرات شکننده (Breaking changes)، مانند تغییر نوع یک فیلد یا حذف یک متد، باید یک پکیج یا سرویس جدید با شماره نسخه متفاوت ایجاد کنید (مثلاً package user.v2;).

نتیجه‌گیری

gRPC یک انتخاب قدرتمند و آینده‌نگر برای ارتباطات میکروسرویسی در اکوسیستم دات‌نت است. با بهره‌گیری از کارایی بالای HTTP/2 و Protobuf، مدل برنامه‌نویسی قرارداد-محور و پشتیبانی عالی از استریمینگ، gRPC به توسعه‌دهندگان این امکان را می‌دهد که سیستم‌های توزیع‌شده سریع‌تر، قوی‌تر و مقیاس‌پذیرتری بسازند. با ابزارها و یکپارچه‌سازی عمیقی که در ASP.NET Core فراهم شده، شروع کار با gRPC و پیاده‌سازی آن در پروژه‌های دات‌نت ساده‌تر از همیشه است.