Rust में कार्य कतारें: एसिंक्रोनस प्रोसेसिंग के लिए लाइब्रेरीज़ का अवलोकन

Rust के लिए कार्य कतारें: उपकरणों और लाइब्रेरीज़ का पूर्ण अवलोकन

Rust एक सिस्टम प्रोग्रामिंग भाषा है जो वेब डेवलपमेंट और उच्च-लोड माइक्रोसर्विसेज़ बनाने में लोकप्रियता प्राप्त कर रही है। आधुनिक backend-अनुप्रयोगों के लिए प्रमुख आवश्यकताओं में से एक बैकग्राउंड कार्यों की एसिंक्रोनस प्रोसेसिंग है: ईमेल भेजना, रिपोर्ट जनरेट करना, अपलोड की गई फ़ाइलों को प्रोसेस करना या बाहरी API के साथ इंटरैक्ट करना। इस लेख में, हम देखेंगे कि Rust में कार्य कतार कैसे व्यवस्थित करें, इसके लिए कौन सी लाइब्रेरीज़ मौजूद हैं और उन्हें व्यवहार में कैसे लागू करें।

कार्य कतार की आवश्यकता क्यों है?

सिंक्रोनस एप्लिकेशन में, प्रत्येक ऑपरेशन क्रमिक रूप से निष्पादित होता है। यदि कोई उपयोगकर्ता कोई लंबा कार्य शुरू करता है (जैसे वीडियो प्रोसेसिंग), तो सर्वर उसके पूरा होने तक ब्लॉक रहेगा। कार्य कतार इस समस्या का समाधान करती है: कार्यों को एक ब्रोकर (कतार) में रखा जाता है, और विशेष वर्कर (workers) उन्हें एसिंक्रोनस रूप से लेते हैं और निष्पादित करते हैं। यह अनुमति देता है:

• एप्लिकेशन के मुख्य थ्रेड को अनलोड करना;
• प्रोसेसिंग को क्षैतिज रूप से स्केल करना (वर्कर जोड़ना);
• विफलताओं के बावजूद कार्य निष्पादन की गारंटी देना (पुष्टिकरण और पुनः प्रयासों के कारण)।

Rust में कतारें व्यवस्थित करने के लिए लोकप्रिय लाइब्रेरीज़

Rust पारिस्थितिकी तंत्र कई परिपक्व समाधान प्रदान करता है। आइए तीन मुख्य दृष्टिकोणों पर विचार करें।

1. Celery-rs (Rust Celery)

Celery-rs लोकप्रिय Python Celery का Rust कार्यान्वयन है। यह लाइब्रेरी Redis या RabbitMQ ब्रोकर का उपयोग करने की अनुमति देती है। यह आदर्श है यदि आप Python से Rust पर माइग्रेट कर रहे हैं या मौजूदा Celery बुनियादी ढांचे के साथ संगतता चाहते हैं।

बेसिक वर्कर का उदाहरण:

use celery::Celery;use celery::task::Task;

#[celery::task]fn add(x: i32, y: i32) -> i32 {    x + y}

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let celery = Celery::builder("redis://localhost:6379/0")        .with_task(add)        .build().await?;

    // वर्कर शुरू करें    celery.run().await?;

    // कार्य भेजें    let task_id = add.delay(&celery, 1, 2).await?;    println!("कार्य ID: {}", task_id);

    Ok(())}

लाभ: Python डेवलपर्स के लिए परिचित API, जटिल परिदृश्यों के लिए समर्थन (retry, ETA, कॉर्डिक कार्य)।
नुकसान: Redis/RabbitMQ पर निर्भरता, सरल मामलों के लिए थोड़ा भारी।

2. Lapin + Tokio (RabbitMQ के साथ सीधा काम)

Lapin Tokio पर चलने वाला Rust के लिए एक उच्च-प्रदर्शन AMQP क्लाइंट है। यदि आपको कतारों, एक्सचेंजों और रूटिंग कुंजियों पर पूर्ण नियंत्रण चाहिए, तो Lapin सबसे अच्छा विकल्प है। यह "बॉक्स से बाहर" कार्य अमूर्तता प्रदान नहीं करता है, लेकिन लचीलापन देता है।

संदेश भेजने और प्राप्त करने का उदाहरण:

use lapin::{options::*, types::FieldTable, Connection, ConnectionProperties};use tokio_amqp::*;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let conn = Connection::connect(        "amqp://guest:guest@localhost:5672",        ConnectionProperties::default().with_tokio(),    ).await?;

    let channel = conn.create_channel().await?;    let queue = channel.queue_declare(        "task_queue",        QueueDeclareOptions::default(),        FieldTable::default(),    ).await?;

    // कार्य भेजें    let payload = b"Hello, task!";    channel.basic_publish(        "",        "task_queue",        BasicPublishOptions::default(),        payload,        BasicProperties::default(),    ).await?;

    // कार्य प्राप्त करें (वर्कर)    let consumer = channel.basic_consume(        "task_queue",        "consumer",        BasicConsumeOptions::default(),        FieldTable::default(),    ).await?;

    while let Some(delivery) = consumer.next().await {        let delivery = delivery?;        println!("कार्य प्राप्त हुआ: {:?}", delivery.data);        delivery.a