Rust में Kafka के साथ काम: rdkafka और Franz लाइब्रेरी

Rust में Kafka के साथ काम: लाइब्रेरी का परिचय

Apache Kafka एक डिस्ट्रीब्यूटेड डेटा स्ट्रीमिंग प्लेटफॉर्म है, जिसका उपयोग माइक्रोसर्विसेज, इवेंट प्रोसेसिंग और रियल-टाइम सिस्टम में व्यापक रूप से किया जाता है। Rust भाषा, अपनी उच्च प्रदर्शन और मेमोरी सुरक्षा के कारण, उच्च-लोड वाले Kafka एप्लिकेशन लिखने के लिए बेहतरीन है। इस लेख में हम Rust में Kafka के साथ काम करने के लिए दो मुख्य लाइब्रेरी देखेंगे: rdkafka (librdkafka पर आधारित) और Franz (शुद्ध Rust)।

Kafka के लिए Rust क्यों चुनें?

• उच्च प्रदर्शन — Rust नेटिव कोड में कंपाइल होता है, जिससे ओवरहेड कम होता है।
• मेमोरी सुरक्षा — ओनरशिप सिस्टम डेटा रेस और मेमोरी लीक को रोकता है।
• शून्य-लागत एब्स्ट्रैक्शन — अभिव्यक्ति खोए बिना कुशल कोड लिखने की अनुमति देता है।
• एसिंक्रोनस सपोर्ट — async/await के साथ थ्रेड्स को संभालना आसान बनाता है।

rdkafka लाइब्रेरी

rdkafka Rust में Kafka के लिए सबसे लोकप्रिय लाइब्रेरी है। यह librdkafka का रैपर है — एक उच्च-प्रदर्शन C लाइब्रेरी जिसका उपयोग कई प्रोजेक्ट्स (Node.js, Python, Go सहित) में किया जाता है।

rdkafka की स्थापना

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

[dependencies]
rdkafka = { version = "0.36", features = ["cmake-build"] }
tokio = { version = "1", features = ["full"] }

उदाहरण: Producer (मैसेज भेजना)

use rdkafka::producer::{FutureProducer, FutureRecord};
use rdkafka::ClientConfig;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let producer: FutureProducer = ClientConfig::new()
        .set("bootstrap.servers", "localhost:9092")
        .create()
        .expect("Producer creation error");

    let record = FutureRecord::to("my-topic")
        .payload("Hello from Rust!")
        .key("key-1");

    let delivery_status = producer
        .send(record, Duration::from_secs(0))
        .await;

    match delivery_status {
        Ok(delivery) => println!("Sent: {:?}", delivery),
        Err(e) => eprintln!("Error: {:?}", e),
    }
}

उदाहरण: Consumer (मैसेज पढ़ना)

use rdkafka::consumer::{Consumer, StreamConsumer};
use rdkafka::ClientConfig;
use rdkafka::message::Message;
use futures::stream::StreamExt;

#[tokio::main]
async fn main() {
    let consumer: StreamConsumer = ClientConfig::new()
        .set("bootstrap.servers", "localhost:9092")
        .set("group.id", "my-group")
        .set("auto.offset.reset", "earliest")
        .create()
        .expect("Consumer creation error");

    consumer.subscribe(&["my-topic"]).unwrap();

    let mut stream = consumer.stream();
    while let Some(message) = stream.next().await {
        match message {
            Ok(msg) => {
                let payload = msg.payload_view::<str>().unwrap_or(None);
                if let Some(text) = payload {
                    println!("Received: {}", text);
                }
            }
            Err(e) => eprintln!("Error: {}", e),
        }
    }
}

Franz लाइब्रेरी

Franz एक आधुनिक Kafka लाइब्रेरी है जो पूरी तरह से Rust में लिखी गई है (C बाइंडिंग के बिना)। यह सुरक्षित और एर्गोनोमिक API प्रदान करती है, async/await का उपयोग करती है, और Kafka प्रोटोकॉल के नवीनतम संस्करणों (KIP-848 सहित) को सपोर्ट करती है।

Franz की स्थापना

[dependencies]
franz = "0.7"
tokio = { version = "1", features = ["full"] }

उदाहरण: Franz में Producer

use franz::client::Client;
use franz::record::Record;
use franz::producer::Producer;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(vec!["localhost:9092".to_string()]).await?;
    let mut producer = Pr