Rust में कैशिंग: Redis और अन्य उपकरण

Rust में कैशिंग: Redis और अन्य कुशल समाधान

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

1. `redis-rs` क्रेट के माध्यम से Redis

redis-rs Rust में Redis के साथ काम करने के लिए मुख्य और सबसे परिपक्व लाइब्रेरी है। यह एसिंक्रोनस ऑपरेशन (tokio या async-std के माध्यम से), क्लस्टरिंग, pub/sub और सभी लोकप्रिय Redis डेटा प्रकारों का समर्थन करता है।

स्थापना

[dependencies]redis = { version = "0.25", features = ["tokio-comp"] }tokio = { version = "1", features = ["full"] }

मूल उदाहरण: स्ट्रिंग्स को कैश करना

use redis::AsyncCommands;

#[tokio::main]async fn main() -> redis::RedisResult<()> {    let client = redis::Client::open("redis://127.0.0.1:6379/")?;    let mut con = client.get_multiplexed_async_connection().await?;

    // 60 सेकंड TTL के साथ कैश सेट करें    let _: () = con.set_ex("user:123", "{\\"name\\":\\"Alice\\"}", 60).await?;

    // मान प्राप्त करें    let cached: String = con.get("user:123").await?;    println!("कैश किया गया डेटा: {}", cached);

    // कुंजी के अस्तित्व की जाँच करें    let exists: bool = con.exists("user:123").await?;    println!("कुंजी मौजूद है: {}", exists);

    Ok(())}

जटिल संरचनाओं का सीरियलाइज़ेशन

डेटा संरचनाओं को कैश करने के लिए redis के साथ serde का उपयोग करें:

use serde::{Serialize, Deserialize};use redis::AsyncCommands;

#[derive(Debug, Serialize, Deserialize)]struct User {    id: u32,    name: String,    email: String,}

async fn cache_user(con: &mut redis::aio::MultiplexedConnection, user: &User) {    let json = serde_json::to_string(user).unwrap();    let _: () = con.set_ex(format!("user:{}", user.id), json, 300).await.unwrap();}

async fn get_cached_user(con: &mut redis::aio::MultiplexedConnection, id: u32) -> Option<User> {    let json: Option<String> = con.get(format!("user:{}", id)).await.unwrap();    json.and_then(|data| serde_json::from_str(&data).ok())}

2. In-memory कैशिंग: `moka` क्रेट

Moka मेमोरी में कैशिंग के लिए एक उच्च-प्रदर्शन लाइब्रेरी है, जो Caffeine (Java) से प्रेरित है। यह उन परिदृश्यों के लिए आदर्श है जहाँ बाहरी सर्वर की आवश्यकता नहीं है, बल्कि अधिकतम गति की आवश्यकता है।

moka की विशेषताएँ:

समय (TTL, TTI) और आकार के अनुसार स्वचालित निष्कासन
एसिंक्रोनस सिंक्रोनाइज़ेशन (background refresh)
मल्टी-थ्रेडेड उपयोग के लिए सुरक्षा (Arc + RwLock)
भार नीतियों का समर्थन (weighted cache)

उदाहरण: TTL और आकार सीमा के साथ कैश

use moka::sync::Cache;use std::time::Duration;

fn main() {    // 1000 तत्वों और 10 मिनट TTL के साथ कैश बनाएँ    let cache: Cache<String, String> = Cache::builder()        .max_capacity(1000)        .time_to_live(Duration::from_secs(600))        .build();

    // सम्मिलन और प्राप्ति    cache.insert("key1".to_string(), "value1".to_string());    if let Some(v) = cache.get("key1") {        println!("मान: {}", v);    }}

एसिंक्रोनस वेरिएंट (moka::future::Cache)

use moka::future::Cache;

#[tokio::main]async fn main() {    let cache: Cache<u64, String> = Cache::new(10_000);

    // एसिंक्रोनस सम्मिलन    cache.insert(42, "Hello async".to_string()).await;

    // एसिंक्रोनस प्राप्ति    if let Some(val) = cache.get(&42).await {        println!("{}", val);    }}