Rust में कैशिंग: Redis, Memcached और अंतर्निहित समाधान

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

कैशिंग प्रदर्शन अनुकूलन के प्रमुख तंत्रों में से एक है। Rust में, गति और सुरक्षा पर इसके जोर के साथ, कैशिंग के लिए सही उपकरण चुनना महत्वपूर्ण लाभ दे सकता है। इस लेख में हम लोकप्रिय लाइब्रेरीज़ पर विचार करेंगे: redis-rs (कनेक्शन पूल के साथ), moka (in-memory कैश) और cached (फ़ंक्शन डेकोरेटर)।

1. Redis: redis-rs और deadpool के माध्यम से बाहरी कैश

Redis सबसे आम बाहरी कैश है। Rust में इसके साथ काम करने के लिए redis-rs क्रेट का उपयोग किया जाता है। Production लोड के लिए deadpool-redis के माध्यम से कनेक्शन पूल कनेक्ट करने की अनुशंसा की जाती है।

स्थापना

[dependencies]\nredis = { version = "0.25", features = ["tokio-comp"] }\ndeadpool-redis = "0.14"\ntokio = { version = "1", features = ["full"] }\nserde = { version = "1", features = ["derive"] }\nserde_json = "1"

उदाहरण: Redis के साथ बुनियादी कार्य

use redis::AsyncCommands;\nuse deadpool_redis::{Config, Runtime};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    // कनेक्शन पूल बनाएँ\n    let cfg = Config::from_url("redis://127.0.0.1:6379");\n    let pool = cfg.create_pool(Some(Runtime::Tokio1))?;\n\n    // पूल से कनेक्शन लें\n    let mut conn = pool.get().await?;\n\n    // 60 सेकंड TTL के साथ मान सेट करें\n    conn.set_ex("user:42", "{\\"name\\":\\"Alice\\",\\"role\\":\\"admin\\"}", 60).await?;\n\n    // पढ़ें\n    let value: String = conn.get("user:42").await?;\n    println!("प्राप्त: {}", value);\n\n    // हटाएँ\n    conn.del("user:42").await?;\n\n    Ok(())\n}

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

use serde::{Serialize, Deserialize};\n\n#[derive(Serialize, Deserialize, Debug)]\nstruct User {\n    id: u64,\n    name: String,\n    email: String,\n}\n\nasync fn cache_user(conn: &mut redis::aio::Connection, user: &User) -> redis::RedisResult<()> {\n    let key = format!("user:{}", user.id);\n    let json = serde_json::to_string(user).unwrap();\n    conn.set_ex(key, json, 300).await\n}\n\nasync fn get_cached_user(conn: &mut redis::aio::Connection, id: u64) -> Option<User> {\n    let key = format!("user:{}", id);\n    let result: Option<String> = conn.get(key).await.ok()?;\n    result.and_then(|json| serde_json::from_str(&json).ok())\n}

2. Moka: तेज़ in-memory कैश

Moka एक उच्च-प्रदर्शन in-memory कैश है, जो Caffeine (Java) से प्रेरित है। यह TTL, आकार सीमा और एसिंक्रोनस अपडेट का समर्थन करता है।

स्थापना

[dependencies]\nmoka = { version = "0.12", features = ["future"] }\ntokio = { version = "1", features = ["full"] }

उदाहरण: 1000 आइटम सीमा और 10 मिनट TTL वाला कैश

use moka::future::Cache;\nuse std::time::Duration;\n\n#[tokio::main]\nasync fn main() {\n    let cache: Cache<String, String> = Cache::builder()\n        .max_capacity(1000)\n        .time_to_live(Duration::from_secs(600))\n        .build();\n\n    // डालें\n    cache.insert("key1".to_string(), "value1".to_string()).await;\n\n    // पढ़ें\n    if let Some(v) = cache.get(&"key1".to_string()).await {\n        println!("मिला: {}", v);\n    }\n\n    // हटाएँ\n    cache.invalidate(&"key1".to_string()).await;\n}

TTL समाप्ति पर स्वचालित अपडेट

let cache: Cache<String, String> = Cache::builder()\n    .time_to_live(Duration::from_secs(60))\n    .time_to_idle(Duration::from_secs(30)) // पढ़ने पर TTL रीसेट\n    .build();

3. Cached: फ़ंक्शन के लिए डेकोरेटर

cached क्रेट आपको एट्रीब्यूट्स के माध्यम से फ़ंक्शन के परिणामों को कैश करने की अनुमति देता है। यह Redis और in-memory सहित विभिन्न बैकएंड का समर्थन करता है।

स्थापना

[dependencies]\ncach