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

Go (Golang) में कैशिंग: Redis और अन्य उपकरण

कैशिंग वेब एप्लिकेशन और माइक्रोसर्विसेज के प्रदर्शन को अनुकूलित करने के लिए प्रमुख तंत्रों में से एक है। Go (Golang) इकोसिस्टम में कैशिंग को लागू करने के लिए कई पुस्तकालय मौजूद हैं, सरल in-memory समाधानों से लेकर Redis पर आधारित वितरित सिस्टम तक। इस लेख में हम तीन मुख्य दृष्टिकोणों पर विस्तार से चर्चा करेंगे: अंतर्निहित डेटा संरचनाएं (sync.Map), लोकप्रिय in-memory पुस्तकालय (go-cache, freecache, bigcache) और Redis के साथ एकीकरण।

1. अंतर्निहित साधन: sync.Map

Go एक थ्रेड-सुरक्षित map प्रदान करता है — sync.Map। यह कम डेटा और दुर्लभ अपडेट के साथ सरल कैशिंग के लिए उपयुक्त है। हालांकि, उच्च लोड पर इसका प्रदर्शन विशेष पुस्तकालयों से कमतर है।

sync.Map के उपयोग का उदाहरण:

package main

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

func main() {    var cache sync.Map

    // लेखन    cache.Store("user:42", map[string]interface{}{        "name": "Alice",        "age":  30,    })

    // जांच के साथ पढ़ना    if val, ok := cache.Load("user:42"); ok {        fmt.Println("कैश मिला:", val)    }

    // हटाना    cache.Delete("user:42")

    // TTL के साथ कैशिंग (मैन्युअल रूप से लागू करना होगा)    cache.Store("session:abc", time.Now().Unix())}

कमियां: स्वचालित TTL का अभाव, सीमित संचालन सेट, बार-बार लिखने पर प्रदर्शन संबंधी संभावित समस्याएं।

2. In-memory पुस्तकालय

अधिक जटिल परिदृश्यों के लिए विशेष पुस्तकालयों का उपयोग करें। आइए तीन लोकप्रिय पुस्तकालयों पर विचार करें:

2.1 go-cache

TTL समर्थन वाला सरल पुस्तकालय। छोटी परियोजनाओं के लिए आदर्श।

import "github.com/patrickmn/go-cache"

func main() {    c := cache.New(5*time.Minute, 10*time.Minute) // डिफ़ॉल्ट TTL, सफाई अंतराल

    c.Set("key", "value", cache.DefaultExpiration)    val, found := c.Get("key")    if found {        fmt.Println(val)    }}

2.2 freecache

निश्चित मेमोरी आकार वाला पुस्तकालय (कोई GC ओवरहेड नहीं)। TTL और उच्च प्रदर्शन का समर्थन करता है।

import "github.com/coocood/freecache"

func main() {    cache := freecache.NewCache(100 * 1024 * 1024) // 100 MB

    cache.Set([]byte("mykey"), []byte("myvalue"), 60) // TTL 60 सेकंड    val, err := cache.Get([]byte("mykey"))    if err == nil {        fmt.Println(string(val))    }}

2.3 bigcache

GC-रुकावटों के बिना बड़ी मात्रा में डेटा संग्रहीत करने के लिए अनुकूलित। क्रमबद्ध डेटा के साथ काम करता है।

import "github.com/allegro/bigcache/v3"

func main() {    cache, _ := bigcache.NewBigCache(bigcache.DefaultConfig(10 * time.Minute))

    cache.Set("key", []byte("value"))    val, _ := cache.Get("key")    fmt.Println(string(val))}

3. Redis: वितरित कैशिंग

वितरित सिस्टम और माइक्रोसर्विसेज के लिए Redis डी-फैक्टो मानक बना हुआ है। Go में go-redis/redis (v9+) पुस्तकालय का उपयोग करें।

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

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

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

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

    // पढ़ना    val, err := rdb.Get(ctx, "user:42").Result()    if err == redis.Nil {        fmt.Println("कैश नहीं मिला")    } else if err != nil {        panic(err)    } else {        fmt.Println("मान:", val)    }}