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

परिचय: Go में उन्नत स्तर पर कैशिंग की आवश्यकता क्यों है?

Go (Golang) पर उच्च-लोड सिस्टम में, डेटा तक पहुँच की गति अक्सर एक अड़चन बन जाती है। डेटाबेस हमेशा बिना महत्वपूर्ण देरी के प्रति सेकंड हजारों अनुरोधों को संसाधित करने में सक्षम नहीं होता है। कैशिंग डेटाबेस पर लोड कम करने और API प्रतिक्रिया को गति देने के लिए एक महत्वपूर्ण उपकरण है।

शुरुआती स्तर पर, डेवलपर्स अक्सर म्यूटेक्स के साथ सरल map का उपयोग करते हैं। हालाँकि, प्रोडक्शन में अधिक उन्नत समाधानों की आवश्यकता होती है: वितरित कैश (Redis, Memcached) और उच्च-प्रदर्शन वाली in-memory लाइब्रेरी (BigCache, FreeCache)। इस लेख में, हम उनकी विशेषताओं का विश्लेषण करेंगे, प्रदर्शन की तुलना करेंगे और प्रत्येक विकल्प के लिए Go में कोड उदाहरण दिखाएंगे।

1. अंतर्निहित समाधान: sync.Map और BigCache/FreeCache लाइब्रेरी

1.1. sync.Map — जब बाहरी निर्भरता की आवश्यकता न हो

पैकेज sync.Map एक थ्रेड-सुरक्षित map है, जो उन परिदृश्यों के लिए अनुकूलित है जहाँ कुंजियाँ एक बार लिखी जाती हैं और कई बार पढ़ी जाती हैं। इसे पढ़ने पर लॉक की आवश्यकता नहीं होती है, जो प्रदर्शन में वृद्धि देता है।

उपयोग का उदाहरण:

package main\n\nimport (\n    "fmt"\n    "sync"\n)\n\nfunc main() {\n    var cache sync.Map\n\n    // लिखना\n    cache.Store("user:1", "Alice")\n\n    // पढ़ना\n    if value, ok := cache.Load("user:1"); ok {\n        fmt.Println("मिला:", value)\n    }\n\n    // हटाना\n    cache.Delete("user:1")\n}

कमियाँ: TTL द्वारा स्वचालित अमान्यकरण नहीं है, मेमोरी की कोई सीमा नहीं है। यह कॉन्फ़िगरेशन या शायद ही कभी बदले जाने वाले डेटा के अस्थायी भंडारण के लिए उपयुक्त है।

1.2. BigCache — TTL के साथ तेज़ in-memory कैश

BigCache (Allegro द्वारा) एक लाइब्रेरी है जो डेटा को बाइट ऐरे में संग्रहीत करती है, जिससे GC के ओवरहेड से बचा जा सकता है। यह TTL और पुरानी प्रविष्टियों के स्वचालित निष्कासन का समर्थन करता है।

उदाहरण:

import (\n    "github.com/allegro/bigcache/v3"\n    "time"\n)\n\nfunc main() {\n    cache, _ := bigcache.NewBigCache(bigcache.DefaultConfig(10 * time.Minute))\n\n    // लिखना\n    cache.Set("mykey", []byte("myvalue"))\n\n    // पढ़ना\n    entry, _ := cache.Get("mykey")\n    println(string(entry))\n}

लाभ: GC पर न्यूनतम दबाव, उच्च गति (प्रति सेकंड लाखों ऑपरेशन)। कमियाँ: डेटा केवल बाइट्स में संग्रहीत होता है, सीरियलाइज़ेशन के बिना जटिल संरचनाओं का समर्थन नहीं करता है।

1.3. FreeCache — निश्चित आकार के साथ विकल्प

FreeCache एक और in-memory लाइब्रेरी है जिसमें कैश का आकार समायोज्य होता है। यह लॉक को कम करने के लिए सेगमेंटेशन का उपयोग करता है।

import "github.com/coocood/freecache"\n\nfunc main() {\n    // कैश का आकार — 100 MB\n    cache := freecache.NewCache(100 * 1024 * 1024)\n\n    cache.Set([]byte("key"), []byte("value"), 60) // TTL 60 सेकंड\n    got, _ := cache.Get([]byte("key"))\n    println(string(got))\n}

2. Redis — उन्नत संरचनाओं के साथ वितरित कैशिंग

Redis Go अनुप्रयोगों के लिए सबसे लोकप्रिय बाहरी कैश है। यह न केवल स्ट्रिंग्स, बल्कि सूचियाँ, हैश, सेट, साथ ही TTL, Pub/Sub और ट्रांज़ैक्शन का भी समर्थन करता है।

2.1. कनेक्शन और बुनियादी संचालन

Go में Redis के साथ काम करने के लिए ड्राइवर go-redis/redis (या redis/v8) का उपयोग किया जाता है।

import (\n    "github.com/go-redis/redis/v8"\n    "context"\n)\n\nvar ctx = context.Background()\n\nfunc main() {\n    rdb := redis.NewClient(&redis.Options{\n        Addr:     "localhost:6379",\n        Password: "",\n        DB:       0,\n    })\n\n    // 10 सेकंड TTL के साथ सेट करना\n    err := rdb.Set(ctx, "key", "value", 10*time.Second).Err()\n    if err != nil {\n        panic(err)\n    }\n\n    val, err := rdb.Get(c