آموزش پیاده سازی کلاینت و سرور gRPC در فلاتر و زبان Go + ویدیو

gRPC پیاده‌سازی جدیدی از RPC است که توسط گوگل در سال ۲۰۱۵ توسعه یافت و به صورت متن‌باز (Open-source) منتشر شد. کلاینت فلاتر grpc

gRPC یک فریمورک قدرتمند و مبتنی بر اسکیما است که ارتباط بین سرویس‌های مختلف را در محیط‌های توزیع‌شده به شدت ساده می‌کند.

این فریمورک در واقع یک پیاده‌سازی مدرن و مستقل از زبان از پروتکل RPC (مخفف Remote Procedure Call) است که با بهره‌گیری از HTTP/2 و بافرهای پروتکل (Protocol Buffers)، از قابلیت‌هایی مانند استریم داده و قراردادهای سرویس کاملاً تایپ‌شده (Strongly Typed) پشتیبانی می‌کند.

در این مقاله، ما به بررسی تاریخچه gRPC، نحوه عملکرد آن و مقایسه آن با معماری محبوب REST خواهیم پرداخت.

همچنین با کمک زبان Go یک سرور gRPC طراحی میکنیم و نحوه دسترسی به این سرور را در فریمورک فلاتر بررسی میکنیم.

تاریخچه gRPC از کجا شروع شد؟

عبارت RPC در gRPC مخفف "فراخوانی رویه از راه دور" (Remote Procedure Call) است. مفهوم RPC اولین بار در اواخر دهه ۱۹۷۰ و ۱۹۸۰ میلادی معرفی شد و هدف آن این بود که به کلاینت‌ها و سرورها اجازه دهد طوری با یکدیگر تعامل کنند که انگار هر دو روی یک ماشین واحد قرار دارند.

gRPC پیاده‌سازی جدیدی از RPC است که توسط گوگل در سال ۲۰۱۵ توسعه یافت و به صورت متن‌باز (Open-source) منتشر شد.

ایده اولیه آن، ساخت نسل بعدی زیرساخت RPC داخلی گوگل به نام "Stubby" بود که از سال ۲۰۰۱ برای اتصال تعداد بسیار زیادی میکروسرویس در دیتاسنترهای مختلف این شرکت استفاده می‌شد. امروزه، gRPC بخشی از بنیاد محاسبات ابری نیتیو (CNCF) است.

gRPC از چه اجزایی تشکیل شده است؟

برای درک بهتر gRPC، ابتدا باید با مفهوم RPC آشنا شویم.

RPC یک روش ارتباط بین-فرایندی (Inter-process Communication) است که اپلیکیشن‌های نرم‌افزاری از آن برای برقراری ارتباط با یکدیگر از طریق شبکه استفاده می‌کنند.

gRPC بر پایه RPC ساخته شده و از پروتکل HTTP/2 به عنوان لایه انتقال (Transport Layer) خود برای ارتباطات بهره می‌برد.

از آنجایی که gRPC مبتنی بر RPC است، کلاینت‌ها می‌توانند هر یک از متدهای سرویس gRPC را فراخوانی کنند، چه آن سرویس روی ماشین محلی در حال اجرا باشد و چه روی یک سرور از راه دور.

آموزش کار با Supabse در فلاتر

این ویژگی، gRPC را به ابزاری همه‌کاره تبدیل می‌کند که بسیار فراتر از درخواست‌های ساده GET و PUT عمل می‌کند.

برای تعریف رابط API، gRPC به جای استفاده از فرمت‌های رایجی مانند JSON یا XML، از بافرهای پروتکل (Protocol Buffers یا Protobuf) به عنوان زبان تعریف رابط خود استفاده می‌کند.

توسعه‌دهندگان یک ساختار داده (Data Structure) را برای مشخص کردن فرمت پیام بین کلاینت و سرور تعریف می‌کنند و کامپایلر Protobuf این ساختار را به یک فرمت باینری فشرده، یعنی همان Protobuf، تبدیل می‌کند.a

اجزای کلیدی gRPC

بافرهای پروتکل (Protocol Buffers): یک مکانیزم مستقل از زبان برای سریال‌سازی (Serializing) داده‌های ساختاریافته.

پروتکل HTTP/2: پروتکل انتقال پایه که قابلیت‌هایی مانند چندگانه‌سازی (Multiplexing) و فشرده‌سازی هدرها را فراهم می‌کند.

کانال (Channel): یک اتصال به سرور gRPC روی یک هاست و پورت مشخص.

استاب (Stub): یک آبجکت سمت کلاینت که همان متدهایی را پیاده‌سازی می‌کند که در سرور gRPC وجود دارد.

gRPC چگونه کار می‌کند؟

برای پیاده‌سازی APIهای gRPC، شما سرویس‌هایی با متدهای قابل فراخوانی توسط کلاینت ایجاد می‌کنید. سپس یک قرارداد (Contract) بین کلاینت و سرور تعریف می‌کنید.

این قرارداد مشخص می‌کند که کلاینت‌ها کدام رویه‌ها (Procedures) را می‌توانند از سرویس فراخوانی کنند، چه پارامترهایی را می‌توانند به آن رویه‌ها ارسال کنند و چه نوع داده‌ای به عنوان خروجی بازگردانده خواهد شد.

کلاینت و سرور با استفاده از این قرارداد، کدهای لازم برای فراخوانی رویه‌ها و تبادل داده را به زبان برنامه‌نویسی خودشان تولید می‌کنند.

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

همانطور که پیش‌تر اشاره شد، gRPC از HTTP/2 برای انتقال داده و از بافرهای پروتکل برای سریال‌سازی پیام استفاده می‌کند.

کلاینت، آبجکت‌های محلی یا استاب‌هایی (Stubs) برای متدهای API ایجاد کرده و آن متدها را به صورت محلی فراخوانی می‌کند.

سپس gRPC runtime درخواست‌های کلاینت را به سرور از راه دور ارسال کرده و پاسخ‌ها را از آن دریافت می‌کند.

مزایای gRPC: چرا باید از gRPC به جای REST استفاده کنیم؟

gRPC (گِی‌آر‌پی‌سی) یک چارچوب مدرن برای ارتباط بین سرویس‌ها (Inter-Service Communication) است که توسط گوگل توسعه یافته و امروزه به یکی از استانداردهای طلایی در سیستم‌های توزیع‌شده تبدیل شده است.

در این بخش، مهم‌ترین مزایای gRPC را بررسی می‌کنیم.

عملکرد بالا و ترافیک کم

  • gRPC از Protocol Buffers (protobuf) به‌عنوان فرمت سریال‌سازی استفاده می‌کند که:
    • باینری است (نه متنی مانند JSON).
    • حجم داده را تا 70% نسبت به JSON کاهش می‌دهد.
    • سرعت سریال‌سازی و دی‌سریال‌سازی بسیار بالاتری دارد.
  • این ویژگی‌ها باعث کاهش تأخیر (latency) و صرفه‌جویی در پهنای باند می‌شود — به‌ویژه در شبکه‌های موبایل یا IoT.

پشتیبانی از چندین الگوی ارتباطی

برخلاف REST که فقط از درخواست-پاسخ یک‌طرفه (Request-Response) پشتیبانی می‌کند، gRPC چهار الگوی ارتباطی ارائه می‌دهد.

این انعطاف‌پذیری، gRPC را برای سیستم‌های بلادرنگ ایده‌آل می‌کند.

امنیت پیش‌فرض

  • gRPC از HTTP/2 به‌عنوان لایه انتقال استفاده می‌کند که:
    • پشتیبانی از TLS/SSL به‌صورت پیش‌فرض دارد.
    • امکان احراز هویت با گواهی‌های دیجیتال (mTLS) را فراهم می‌کند.
  • حتی در محیط توسعه، می‌توان با ChannelCredentials.insecure() از امنیت صرف‌نظر کرد.

انواع متدهای سرویس در gRPC API

gRPC از چهار نوع متد سرویس پشتیبانی می‌کند:

Unary RPC (یوناری): یک متد سرویس یوناری، یک ورودی دریافت کرده و یک خروجی بازمی‌گرداند.

Server Streaming RPC (استریم سرور): این نوع متد، یک ورودی از کلاینت دریافت کرده و جریانی (Stream) از خروجی‌ها را برای آن ارسال می‌کند. سرور می‌تواند به محض آماده شدن داده‌ها، چندین خروجی را به صورت متوالی بفرستد.

Client Streaming RPC (استریم کلاینت): در این حالت، کلاینت یک اتصال با سرور برقرار کرده و پس از تایید سرور، شروع به ارسال جریانی از داده‌ها می‌کند تا زمانی که خود استریم را خاتمه دهد.

Bidirectional Streaming RPC (استریم دوطرفه): متدهای استریم دوطرفه به کلاینت و سرور اجازه می‌دهند تا به صورت همزمان، جریان‌های داده را در هر دو جهت ارسال و دریافت کنند.

هر کدام از این متدها مزایا و موارد استفاده خاص خود را دارند.

به عنوان مثال، متدهای Unary برای فراخوانی‌های ساده ایده‌آل هستند، در حالی که متدهای Server Streaming برای وظایفی که نیاز به پردازش سنگین داده دارند، عالی عمل می‌کنند.

از متدهای Client Streaming می‌توان در شرایطی که تاخیر (Latency) اهمیت دارد استفاده کرد و متدهای Bidirectional Streaming برای ارتباطات آنی و دوطرفه (Real-time) بی‌نظیر هستند.

ساخت فایل Proto

در این بخش، ساختار اولیه یک سرویس gRPC را با استفاده از Protocol Buffers (protobuf) تعریف می‌کنیم که پایه‌ای برای ارتباط بین کلاینت فلاتر و سرور گولنگ خواهد بود.

این فایل .proto نقش اصلی را در تعریف قرارداد ارتباطی (contract) بین دو سمت ایفا می‌کند.

آموزش Rest api در فلاتر

کد کامل فایل student.proto

syntax = "proto3";

option go_package = "./;proto";

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

message GetUserRequest {
  int32 id = 1;
}

message GetUserResponse {
  User user = 1;
}

service Students {
  rpc GetUser(GetUserRequest) returns (GetUserResponse) {}
}
  • message User: یک نوع داده سفارشی به نام User تعریف می‌کند.
  • فیلدها شامل:
    • id: شناسه منحصربه‌فرد کاربر (عدد صحیح 32 بیتی).
    • name: نام کاربر (رشته متنی).
    • email: آدرس ایمیل کاربر (رشته متنی).
  • اعداد پس از = (مانند = 1) شماره‌های فیلد (field numbers) هستند که در سریال‌سازی باینری استفاده می‌شوند و باید یکتا باشند.

تعریف درخواست و پاسخ برای متد GetUser

message GetUserRequest {
  int32 id = 1;
}

message GetUserResponse {
  User user = 1;
}
  • GetUserRequest: ساختار داده‌ای که کلاینت (فلاتر) برای درخواست اطلاعات یک کاربر بر اساس id ارسال می‌کند.
  • GetUserResponse: ساختار پاسخی که سرور (گولنگ) با اطلاعات کامل کاربر (User) بازمی‌گرداند.

تعریف سرویس gRPC

service Students {
  rpc GetUser(GetUserRequest) returns (GetUserResponse) {}
}
  • service Students: یک سرویس gRPC به نام Students تعریف می‌کند.
  • rpc GetUser(...): یک روال فراخوانی از راه دور (Remote Procedure Call) به نام GetUser ایجاد می‌کند که:
    • ورودی: GetUserRequest
    • خروجی: GetUserResponse
  • این متد به کلاینت اجازه می‌دهد تا با ارسال id، اطلاعات کاربر را از سرور دریافت کند.

کامپایل کدهای پروتوبافر

قبل از اجرا، مطمئن شوید که موارد زیر نصب شده‌اند:

  1. protoc (Protocol Buffer Compiler) — دانلود از GitHub

پلاگین Go:

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

پلاگین Dart:

dart pub global activate protoc_plugin
flutter pub global activate protoc_plugin

مسیر pub global باید در متغیر محیطی PATH سیستم شما باشد.

ساختار پیشنهادی پروژه:

your-project/
├── proto/
│   └── student.proto          ← فایل شما
├── pb/                        ← خروجی Go
└── lib/proto/                 ← خروجی Dart (برای فلاتر)

دستور کامپایل برای گولنگ (Go)

این دستور کدهای message و gRPC service را برای گولنگ در فولدر pb تولید می‌کند:

protoc \
  --go_out=./pb \
  --go-grpc_out=./pb \
  --proto_path=./proto \
  ./proto/student.proto

دستور کامپایل برای فلاتر (Dart)

protoc \
  --dart_out=grpc:./lib/proto \
  --proto_path=./proto \
  ./proto/student.proto

پس از اجرا، فایل student.pb.dart و student.pbenum.dart (و گاهی student.pbgrpc.dart) در lib/proto ایجاد می‌شوند.

کار با gRPC در فلاتر

در فلاتر، حتماً پکیج‌های زیر را در pubspec.yaml اضافه کنید:

  grpc
  protobuf

بعد از نصب پکیج های مورد نیاز برای شروع به ساخت کلاینت gRPC با فریموک فلاتر میپردازیم.

var result = "";
late ClientChannel _channel;
  • result: رشته‌ای برای نمایش پاسخ در رابط کاربری.
  • _channel: کانال ارتباطی gRPC که با تأخیر (late) مقداردهی می‌شود (چون در initState ساخته می‌شود).

در ادامه : ایجاد کانال gRPC در initState

_channel = grpc.ClientChannel(
  "10.0.2.2",
  port: 8000,
  options: const grpc.ChannelOptions(
    credentials: grpc.ChannelCredentials.insecure(),
  ),
);
  • "10.0.2.2": آدرس خاص Android Emulator برای دسترسی به localhost ماشین میزبان.
    • در iOS Simulator: از "127.0.0.1" استفاده کنید.
    • در دستگاه فیزیکی: از IP محلی شبکه (مثل 192.168.x.x) استفاده کنید.
  • port: 8000: همان پورتی که سرور گولنگ روی آن گوش می‌دهد.
  • ChannelCredentials.insecure(): چون از TLS/SSL استفاده نمی‌کنیم (برای محیط توسعه).

تابع _fetchUser() — ارسال درخواست gRPC

Future<void> _fetchUser() async {
  try {
    final client = StudentsClient(_channel);
    final req = GetUserRequest(id: 5);
    final response = await client.getUser(req);
    debugPrint("Response: ${response.toString()}");
    setState(() {
      result = '''
        ID: ${response.user.id}
        name: ${response.user.name}
        email: ${response.user.email}
      ''';
    });
  } catch (e) {
    setState(() {
      result = "Error";
    });
  }
}
  • StudentsClient: کلاس تولیدشده از روی student.pb.dart که کلاینت gRPC را پیاده‌سازی می‌کند.
  • GetUserRequest(id: 5): ایجاد شیء درخواست با id = 5.
  • client.getUser(req): فراخوانی متد GetUser به‌صورت غیرهمزمان (async/await).

کد کامل:

var result = "";

late ClientChannel _channel;

Future<void> _fetchUser() async {
  try {
    final client = StudentsClient(_channel);
    final req = GetUserRequest(id: 5);
    final response = await client.getUser(req);
    debugPrint("Response: ${response.toString()}");
    setState(() {
      result = '''
        ID: ${response.user.id}
        name: ${response.user.name}
        email: ${response.user.email}
      ''';
    });
  } catch (e) {
    setState(() {
      result = "Error";
    });
  }
}

@override
void initState() {
  super.initState();
  _channel = grpc.ClientChannel(
    "10.0.2.2",
    port: 8000,
    options: const grpc.ChannelOptions(
      credentials: grpc.ChannelCredentials.insecure(),
    ),
  );
}

@override
Widget build(BuildContext context) {
  return Scaffold(
    body: SafeArea(
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.center,
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Text("Response: $result"),
          ElevatedButton(
            onPressed: _fetchUser,
            child: Text("Call gRPC"),
          ),
        ],
      ),
    ),
  );
}

کد فلاتر نوشته شده یک کلاینت gRPC ساده و کارآمد است که:

  • با سرور گولنگ روی پورت 8000 ارتباط برقرار می‌کند.
  • درخواست کاربر با id=5 را ارسال می‌کند.
  • پاسخ را در صفحه نمایش می‌دهد.
  • خطاها را به‌درستی مدیریت می‌کند.

با ترکیب این کلاینت فلاتر و سرور گولنگ، یک سیستم کامل gRPC برای اپلیکیشن‌های موبایل و بک‌اند ساخته‌اید که سریع، سبک و مقیاس‌پذیر است.

دیدگاه‌ها (0)

    دیدگاه خود را بنویسید

    ایمیل شما نمایش داده نمی‌شود. دیدگاه پس از تأیید نمایش داده می‌شود.