Rust में gRPC: Tonic और Grpc-rs लाइब्रेरीज़ के साथ उदाहरण

Rust के लिए gRPC: लाइब्रेरीज़ और उदाहरण

gRPC एक हाई-परफॉर्मेंस रिमोट प्रोसीजर कॉल (RPC) फ्रेमवर्क है जिसे Google ने विकसित किया है। यह डेटा सीरियलाइज़ेशन के लिए Protocol Buffers (protobuf) और ट्रांसपोर्ट के लिए HTTP/2 का उपयोग करता है। सख्त टाइपिंग, द्विदिशात्मक स्ट्रीमिंग और कम लेटेंसी के कारण, gRPC माइक्रोसर्विसेज आर्किटेक्चर के लिए एक मानक बन गया है। Rust इकोसिस्टम में gRPC के साथ काम करने के लिए दो मुख्य लाइब्रेरीज़ हैं: Tonic और grpc-rs। इस लेख में हम इनकी विशेषताओं को समझेंगे और व्यावहारिक उदाहरण देंगे।

1. Tonic — आधुनिक और एसिंक्रोनस

Tonic Rust के लिए सबसे लोकप्रिय gRPC लाइब्रेरी है। यह tokio और hyper पर आधारित है, पूरी तरह से एसिंक्रोनस है और Rust इकोसिस्टम के साथ बेहतरीन रूप से एकीकृत होती है। Tonic सभी चार प्रकार के gRPC कॉल को सपोर्ट करती है: यूनरी, सर्वर स्ट्रीमिंग, क्लाइंट स्ट्रीमिंग और द्विदिशात्मक स्ट्रीमिंग।

इंस्टॉलेशन और सेटअप

Cargo.toml में डिपेंडेंसी जोड़ें:

[dependencies]
tonic = "0.12"
prost = "0.13"
tokio = { version = "1", features = ["full"] }

[build-dependencies]
tonic-build = "0.12"

protobuf सर्विस डिफाइन करना

proto/hello.proto फ़ाइल बनाएं:

syntax = "proto3";

package hello;

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

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

protobuf बिल्ड करना

build.rs में लिखें:

fn main() -> Result<(), Box<dyn std::error::Error>> {
    tonic_build::compile_protos("proto/hello.proto")?;
    Ok(())
}

सर्वर इम्प्लीमेंटेशन

Tonic पर एक सरल gRPC सर्वर का उदाहरण:

use tonic::{transport::Server, Request, Response, Status};
use hello::greeter_server::{Greeter, GreeterServer};
use hello::{HelloRequest, HelloReply};

pub mod hello {
    tonic::include_proto!("hello");
}

#[derive(Default)]
pub struct MyGreeter;

#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn say_hello(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloReply>, Status> {
        let name = request.into_inner().name;
        let reply = HelloReply {
            message: format!("नमस्ते, {}!", name),
        };
        Ok(Response::new(reply))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    let greeter = MyGreeter::default();

    Server::builder()
        .add_service(GreeterServer::new(greeter))
        .serve(addr)
        .await?;

    Ok(())
}

क्लाइंट

use hello::greeter_client::GreeterClient;
use hello::HelloRequest;

pub mod hello {
    tonic::include_proto!("hello");
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GreeterClient::connect("http://[::1]:50051").await?;

    let request = tonic::Request::new(HelloRequest {
        name: "दुनिया".into(),
    });

    let response = client.say_hello(request).await?;
    println!("सर्वर का जवाब: {}", response.into_inner().message);
    Ok(())
}

2. grpc-rs — एक परिपक्व विकल्प

grpc-rs TiKV टीम द्वारा विकसित लाइब्रेरी है, जो C लाइब्रेरी gRPC Core पर आधारित है। यह आधिकारिक gRPC C फ्रेमवर्क के साथ अधिकतम संगतता प्रदान करती है, लेकिन सिस्टम डिपेंडेंसी (cmake, protobuf) इंस्टॉल करने की आवश्यकता होती है। grpc-rs सिंक्रोनस और एसिंक्रोनस दोनों कॉल को सपोर्ट करती है, लेकिन उपयोग में आसानी के मामले में Tonic से पीछे है।

grpc-rs पर सर्वर का उदाहरण

use grpc::{ServerBuilder, ServerHandlerContext, ServerRequestHandler, SingleResponse};
use std::sync::Arc;
use pro