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

परिचय: Rust में कैशिंग क्यों करें?

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

इस लेख में, हम Rust में कैशिंग के तीन दृष्टिकोणों पर विचार करेंगे: बाहरी सिस्टम (Redis, Memcached) और अंतर्निहित समाधान (lru-rs, moka)। आप सीखेंगे कि उन्हें कोड में कैसे एकीकृत करें, प्रत्येक उपकरण किन समस्याओं का समाधान करता है, और अपने प्रोजेक्ट के लिए सर्वोत्तम विकल्प कैसे चुनें।

1. बाहरी कैशिंग: Redis और Memcached

बाहरी कैश सिस्टम अलग-अलग सेवाओं के रूप में काम करते हैं, जिन तक एप्लिकेशन नेटवर्क के माध्यम से पहुँचता है। वे वितरित सिस्टम के लिए आदर्श हैं, जब कई प्रक्रियाओं या सर्वरों के पास एक सामान्य कैश होना चाहिए।

1.1. क्रेट redis के माध्यम से Redis

Redis सबसे लोकप्रिय in-memory store है, जो जटिल डेटा संरचनाओं (सूचियाँ, सेट, हैश) का समर्थन करता है। Rust में Redis से कनेक्ट करने के लिए क्रेट redis का उपयोग किया जाता है।

स्थापना: Cargo.toml में जोड़ें:

[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 सेकंड के लिए कैश में लिखना    let _: () = con.set_ex("user:42", "Alice", 60).await?;    // पढ़ना    let val: Option = con.get("user:42").await?;    println!("कैश किया गया मान: {:?}", val);    Ok(())}

Redis सत्रों, API प्रतिक्रियाओं और कार्य कतारों को कैश करने के लिए उपयुक्त है। इसकी कमी यह है कि एक अलग सर्वर स्थापित करने और बनाए रखने की आवश्यकता होती है।

1.2. क्रेट memcache के माध्यम से Memcached

Memcached Redis का एक हल्का विकल्प है, जो सरल key-value भंडारण पर केंद्रित है। क्रेट memcache सिंक्रोनस और एसिंक्रोनस API प्रदान करता है।

क्रेट memcache के साथ उदाहरण:

use memcache::{Client, MemcacheError};

fn main() -> Result<(), MemcacheError> {    let client = Client::connect("memcache://127.0.0.1:11211")?;    client.set("counter", 100, 30)?; // TTL = 30 सेकंड    let val: Option = client.get("counter")?;    println!("मान: {:?}", val);    Ok(())}

Memcached सरल get/set ऑपरेशनों में Redis से तेज़ है, लेकिन जटिल डेटा संरचनाओं का समर्थन नहीं करता है। इसे चुनें यदि आपको न्यूनतम ओवरहेड के साथ केवल "key-value" की आवश्यकता है।

2. अंतर्निहित कैशिंग लाइब्रेरीज़

एकल-प्रक्रिया अनुप्रयोगों (CLI-उपयोगिताएँ, डेस्कटॉप प्रोग्राम, गेम सर्वर) के लिए बाहरी कैशिंग अतिरिक्त है। अंतर्निहित समाधान प्रक्रिया की मेमोरी में काम करते हैं, नेटवर्क की आवश्यकता नहीं होती है और अधिकतम तेज़ होते हैं।

2.1. lru-rs — सरल LRU-कैश

क्रेट lru Least Recently Used निष्कासन के साथ कैश लागू करता है। पार्सिंग परिणामों, कॉन्फ़िगरेशन या छोटी वस्तुओं को कैश करने के लिए आदर्श।

use lru::LruCache;use std::num::NonZeroUsize;

fn main() {    let mut cache: LruCache = LruCache::new(NonZeroUsize::new(3).unwrap());    cache.put("a", 1);    cache.put("b", 2);    cache.put("c", 3);    cache.put("d", 4); // "a" निष्कासित हो जाएगा, क्योंकि कैश भरा हुआ है

    println!("{:?}", cache.get(&"a")); // None    println!("{:?}", cache.get(&"d")); // Some(4)}

लाभ: न्यूनतम, पूर्वानुमानित संचालन समय, thread-safe जब उपयोग किया जाता है