Go (Golang) में कैशिंग: Redis, समूह और इन-मेमोरी कैशिंग

Go (Golang) में कैशिंग: Redis और अन्य समाधान

कैशिंग Go अनुप्रयोगों के प्रदर्शन को बढ़ाने के लिए प्रमुख उपकरणों में से एक है। यह प्रतिक्रिया समय को कम करने, डेटाबेस और बाहरी API पर लोड कम करने में मदद करता है। इस लेख में, हम Go में कैशिंग के मुख्य दृष्टिकोणों पर चर्चा करेंगे: बाहरी भंडारण के रूप में Redis का उपयोग, अंतर्निहित इन-मेमोरी कैशिंग, और groupcache लाइब्रेरी के साथ समूह कैशिंग।

1. Go में कैशिंग की आवश्यकता क्यों है?

Go एक उच्च-प्रदर्शन उन्मुख भाषा है, लेकिन DB या बाहरी सेवाओं के सबसे तेज़ क्वेरी भी बाधा बन सकते हैं। कैशिंग मदद करता है:

• बार-बार आने वाले अनुरोधों में विलंब कम करना।
• डेटाबेस और तृतीय-पक्ष API पर लोड कम करना।
• सर्वर की थ्रूपुट क्षमता बढ़ाना।
• पीक लोड को संतुलित करना।

2. Redis — वितरित कैशिंग

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

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

Go में Redis के साथ काम करने के लिए अक्सर go-redis लाइब्रेरी का उपयोग किया जाता है। स्थापना:

go get github.com/redis/go-redis/v9

उदाहरण: TTL के साथ सरल कैशिंग

package main

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

var ctx = context.Background()

func main() {    rdb := redis.NewClient(&redis.Options{        Addr: "localhost:6379",    })

    // 10 सेकंड TTL के साथ मान सेट करें    err := rdb.Set(ctx, "user:42", `{"name":"Alice"}`, 10*time.Second).Err()    if err != nil {        panic(err)    }

    // मान प्राप्त करें    val, err := rdb.Get(ctx, "user:42").Result()    if err != nil {        fmt.Println("कैश मिस")    } else {        fmt.Println("कैश हिट:", val)    }}

Redis में कैश अमान्यकरण रणनीतियाँ

• TTL (Time To Live) — समय समाप्त होने पर स्वचालित हटाना।
• लेज़ी-अमान्यकरण — डेटा अपडेट होने पर कैश साफ़ करना।
• कुंजी द्वारा हटाना — विशिष्ट कुंजी के लिए DEL कॉल करना।
• "Cache-Aside" पैटर्न — एप्लिकेशन स्वयं कैश प्रबंधित करता है: पहले Redis जांचें, मिस होने पर DB से लोड करें और कैश में सहेजें।

3. Go में इन-मेमोरी कैशिंग

बाहरी निर्भरता के बिना स्थानीय कैशिंग के लिए, आप Go की अंतर्निहित संरचनाओं या विशेष लाइब्रेरीज़ का उपयोग कर सकते हैं।

sync.Map के साथ सरल इन-मेमोरी कैश

package main

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

type CacheItem struct {    Value      interface{}    Expiration int64}

type Cache struct {    items sync.Map}

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {    c.items.Store(key, CacheItem{        Value:      value,        Expiration: time.Now().Add(ttl).UnixNano(),    })}

func (c *Cache) Get(key string) (interface{}, bool) {    item, found := c.items.Load(key)    if !found {        return nil, false    }    cacheItem := item.(CacheItem)    if time.Now().UnixNano() > cacheItem.Expiration {        c.items.Delete(key)        return nil, false    }    return cacheItem.Value, true}

func main() {    cache := &Cache{}    cache.Set("key1", "value1", 5*time.Second)    val, ok := cache.Get("key1")    if ok {        fmt.Println("मिला:", val)    }}

freecache लाइब्रेरी

freecache — TTL और कम मेमोरी खपत के साथ एक उच्च-प्रदर्शन इन-मेमोरी लाइब्रेरी है। स्थापना:

go get github.com/coocood/freecache

cache := freecache.NewCache(100 * 1024 * 1024) // 100 MBcache.Set([]by