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

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

कैशिंग वेब एप्लिकेशन और सेवाओं के प्रदर्शन को बढ़ाने के लिए प्रमुख उपकरणों में से एक है। Go (Golang) इकोसिस्टम में, डेवलपर्स के पास बाहरी कैशिंग सिस्टम (Redis, Memcached) के साथ-साथ sync.Map या bigcache और freecache जैसी लाइब्रेरी जैसे अंतर्निहित समाधान भी उपलब्ध हैं। इस लेख में, हम प्रत्येक दृष्टिकोण के फायदे और नुकसान पर चर्चा करेंगे, कोड उदाहरण देंगे और आपके प्रोजेक्ट के लिए सर्वोत्तम उपकरण चुनने में मदद करेंगे।

1. अंतर्निहित कैशिंग: sync.Map और म्यूटेक्स के साथ map

Go एप्लिकेशन की मेमोरी में सीधे कैश बनाने के लिए बुनियादी प्रिमिटिव प्रदान करता है। सबसे सरल तरीका थ्रेड-सुरक्षा के लिए म्यूटेक्स के साथ एक सामान्य map का उपयोग करना है।

उदाहरण: सरल थ्रेड-सुरक्षित कैश

package main

import (    "fmt"    "sync"    "time")

type Cache struct {    mu    sync.RWMutex    items map[string]interface{}}

func NewCache() *Cache {    return &Cache{        items: make(map[string]interface{}),    }}

func (c *Cache) Set(key string, value interface{}) {    c.mu.Lock()    defer c.mu.Unlock()    c.items[key] = value}

func (c *Cache) Get(key string) (interface{}, bool) {    c.mu.RLock()    defer c.mu.RUnlock()    val, ok := c.items[key]    return val, ok}

func main() {    cache := NewCache()    cache.Set("user:1", "Alice")    val, _ := cache.Get("user:1")    fmt.Println(val) // Alice}

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

अंतर्निहित कैशिंग का उपयोग कब करें?

• माइक्रो-कैशिंग (एक अनुरोध या सत्र की अवधि के लिए)।
• सिंगलटन एप्लिकेशन बिना वितरित आर्किटेक्चर के।
• सरलता - बाहरी सेवाओं को चलाने की आवश्यकता नहीं है।

नुकसान: स्वचालित अमान्यकरण का अभाव, सीमित आकार (एप्लिकेशन मेमोरी पर निर्भर), कोई स्थायित्व नहीं।

2. BigCache और FreeCache: हल्के in-memory समाधान

bigcache और freecache लाइब्रेरी सीमित मेमोरी और GC (गार्बेज कलेक्शन) की समस्या का समाधान करती हैं। वे पूर्व-आवंटित बफ़र्स का उपयोग करते हैं और Go गार्बेज कलेक्टर पर लोड को कम करते हैं।

BigCache के साथ उदाहरण

package main

import (    "fmt"    "github.com/allegro/bigcache/v3"    "time")

func main() {    cache, _ := bigcache.NewBigCache(bigcache.DefaultConfig(10 * time.Minute))    cache.Set("mykey", []byte("myvalue"))    val, _ := cache.Get("mykey")    fmt.Println(string(val)) // myvalue}

FreeCache के साथ उदाहरण

package main

import (    "fmt"    "github.com/coocood/freecache")

func main() {    cache := freecache.NewCache(100 * 1024) // 100 KB    cache.Set([]byte("key"), []byte("value"), 60) // TTL 60 सेकंड    val, _ := cache.Get([]byte("key"))    fmt.Println(string(val)) // value}

दोनों लाइब्रेरी TTL (जीवनकाल) और पुरानी प्रविष्टियों को स्वचालित रूप से हटाने का समर्थन करती हैं। BigCache बड़े डेटा वॉल्यूम (सैकड़ों गीगाबाइट) के लिए बेहतर है, FreeCache बार-बार लिखने/पढ़ने के संचालन वाले परिदृश्यों के लिए बेहतर है।

3. Redis: प्रोडक्शन के लिए वितरित कैशिंग

Redis Go प्रोजेक्ट्स में कैशिंग के लिए सबसे लोकप्रिय विकल्प है। यह एक अलग सर्वर के रूप में काम करता है, जटिल डेटा संरचनाओं, स्थायित्व और क्लस्टरिंग का समर्थन करता है।

Go में Redis कनेक्शन

package main

import (    "context"    "fmt"    "github.com/redis/go-redis/v9")

func main() {    ctx := context.Background()    rdb := redis.NewClient(&redis.Options{        Addr:     "localhost:6379",        Password: "",        DB: