Tonic Rust: पूरी गाइड उदाहरणों के साथ

Tonic क्या है और इसकी आवश्यकता क्यों है?

Tonic Rust भाषा में gRPC सर्वर और क्लाइंट बनाने के लिए एक आधुनिक, हाई-परफॉर्मेंस लाइब्रेरी है। यह Tokio async रनटाइम और Hyper HTTP/2 फ्रेमवर्क पर आधारित है, जो अधिकतम प्रदर्शन और gRPC स्टैंडर्ड के साथ पूर्ण संगतता सुनिश्चित करता है।

Tonic के मुख्य लाभ:

• नेटिव एसिंक्रोनस — पूरी तरह से async/await, बिना किसी ब्लॉकिंग के
• टाइप सेफ्टी — कंपाइल टाइम पर proto फाइलों से कोड जनरेशन
• सभी gRPC पैटर्न का सपोर्ट — unary, server streaming, client streaming, bidirectional streaming
• Rust इकोसिस्टम के साथ इंटीग्रेशन — Tokio, Tower, Hyper और अन्य लोकप्रिय क्रेट्स के साथ काम करता है
• परफॉर्मेंस — सबसे तेज़ gRPC फ्रेमवर्क में से एक

इस लाइब्रेरी का उपयोग प्रोडक्शन में Discord, Microsoft, Amazon जैसी कंपनियों द्वारा किया जाता है। Tonic माइक्रोसर्विसेज, API गेटवे और किसी भी डिस्ट्रीब्यूटेड सिस्टम के लिए आदर्श है जहां सर्विसेज के बीच कुशल संचार की आवश्यकता होती है।

Tonic की इंस्टॉलेशन

Tonic के साथ काम करने के लिए आपको कुछ डिपेंडेंसी इंस्टॉल करनी होंगी। इन्हें अपने Cargo.toml में जोड़ें:

[dependencies]
tonic = "0.12"
prost = "0.13"
tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }

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

डिपेंडेंसी की व्याख्या:

• tonic — gRPC के लिए मुख्य लाइब्रेरी
• prost — Rust के लिए Protocol Buffers कोड जनरेटर
• tokio — एसिंक्रोनस रनटाइम
• tonic-build — बिल्ड टाइम पर .proto फाइलों को कंपाइल करने के लिए

साथ ही आपको protoc — Protocol Buffers कंपाइलर इंस्टॉल करना होगा। Ubuntu/Debian पर:

sudo apt install protobuf-compiler

macOS पर:

brew install protobuf

Windows पर आधिकारिक रिपॉजिटरी से बाइनरी डाउनलोड करें और इसे PATH में जोड़ें।

त्वरित शुरुआत: gRPC पर Hello World

एक सरल सर्विस बनाते हैं जो नाम लेती है और अभिवादन लौटाती है।

चरण 1. proto/helloworld.proto फाइल बनाएं:

syntax = "proto3";

package helloworld;

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

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

चरण 2. प्रोजेक्ट की रूट में build.rs बनाएं:

fn main() -> Result<(), Box> {
    tonic_build::compile_protos("proto/helloworld.proto")?;
    Ok(())
}

चरण 3. सर्वर इम्प्लीमेंट करें (src/server.rs):

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

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

#[derive(Default)]
pub struct MyGreeter;

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

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

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

    Ok(())
}

चरण 4. क्लाइंट बनाएं