Go (Golang) के लिए Redis क्लाइंट: go-redis और redigo - संपूर्ण गाइड

Go (Golang) के लिए Redis क्लाइंट: go-redis और redigo

Redis एक हाई-परफॉर्मेंस in-memory डेटा स्टोर है जिसे अक्सर डेटाबेस, कैश और मैसेज ब्रोकर के रूप में उपयोग किया जाता है। Go (Golang) में Redis के साथ काम करने के लिए कई लोकप्रिय क्लाइंट उपलब्ध हैं। इस लेख में हम दो मुख्य लाइब्रेरीज़ पर विस्तार से चर्चा करेंगे: go-redis (सबसे लोकप्रिय और आधुनिक विकल्प) और redigo (अधिक लो-लेवल लेकिन समय-परीक्षित)।

हम आपको दिखाएंगे कि इनमें से प्रत्येक को कैसे इंस्टॉल करें, सर्वर से कनेक्ट करें, बेसिक ऑपरेशन करें, कनेक्शन पूल के साथ काम करें, pub/sub और पाइपलाइन (pipeline) का उपयोग करें। यह सामग्री शुरुआती और अनुभवी डेवलपर्स दोनों के लिए उपयोगी होगी जो अपने Go एप्लिकेशन में Redis को इंटीग्रेट करना चाहते हैं।

1. go-redis — आधुनिक और फीचर-समृद्ध क्लाइंट

go-redis Go में लिखी गई एक Redis क्लाइंट लाइब्रेरी है। यह Redis 6 और 7 की सभी प्रमुख सुविधाओं को सपोर्ट करती है, जिसमें क्लस्टरिंग, Sentinel, pub/sub, ट्रांजेक्शन, पाइपलाइन और Lua स्क्रिप्ट शामिल हैं। यह लाइब्रेरी सक्रिय रूप से विकसित हो रही है और इसमें एक आसान API है।

go-redis इंस्टॉल करना

इंस्टॉल करने के लिए टर्मिनल में यह कमांड चलाएं:

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

कनेक्शन और बेसिक ऑपरेशन

एक सरल एप्लिकेशन का उदाहरण जो 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:       0,  // डिफ़ॉल्ट डेटाबेस
    })

    // कनेक्शन जांचें
    pong, err := rdb.Ping(ctx).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(pong) // PONG

    // वैल्यू सेट करें
    err = rdb.Set(ctx, "key", "Go से नमस्ते", 0).Err()
    if err != nil {
        panic(err)
    }

    // वैल्यू पढ़ें
    val, err := rdb.Get(ctx, "key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("key:", val)
}

हैश, लिस्ट और सेट के साथ काम करना

go-redis सभी Redis डेटा प्रकारों को सपोर्ट करता है। हैश के साथ काम करने का उदाहरण:

// हैश लिखें
err := rdb.HSet(ctx, "user:1000", map[string]interface{}{
    "name":  "राहुल",
    "age":   28,
    "city":  "दिल्ली",
}).Err()
if err != nil {
    panic(err)
}

// एक फील्ड पढ़ें
name, err := rdb.HGet(ctx, "user:1000", "name").Result()
fmt.Println("नाम:", name)

// पूरा हैश पढ़ें
user, err := rdb.HGetAll(ctx, "user:1000").Result()
fmt.Println("यूज़र:", user)

कनेक्शन पूल और कॉन्फ़िगरेशन

go-redis स्वचालित रूप से कनेक्शन पूल को मैनेज करता है। आप इसका आकार सेट कर सकते हैं:

rdb := redis.NewClient(&redis.Options{
    Addr:         "localhost:6379",
    PoolSize:     10, // पूल में अधिकतम कनेक्शन
    MinIdleConns: 3,  // न्यूनतम idle कनेक्शन
})

Pub/Sub (प्रकाशक-सदस्यता)

चैनल की सदस्यता लेने और संदेश प्रकाशित करने का उदाहरण:

// सदस्यता लें
sub := rdb.Subscribe(ctx, "mychannel")
ch := sub.Channel()

// अलग goroutine में संदेश सुनें
go func() {
    for msg := range ch {
        fmt.Printf("प्राप्त: %s, %s से\n", msg.Payload, msg.Channel)
    }
}()

// संदेश प्रकाशित करें
err := rdb.Publish(ctx, "mychannel", "नमस्ते सब्सक्राइबर्स!").Err()

पाइपलाइन (Pipeline)

यह एक ही रिक्वेस्ट में कई कमांड भेजने की अनुमति देता है, जिससे काम काफी तेज़ हो जाता है:

pipe := rdb.Pipeline()

incr := pipe.Incr(ctx, "counter")
pipe.Expire(ctx, "counter", time.Hour)

// सभी कमांड निष्पादित करें
_, err := pipe.Exec(ctx)
if err != nil {
    panic(err)
}
fmt.Println("काउंटर:", incr.Val())

2. Redigo — हल्का और तेज़ क्लाइंट

Redigo Redis के साथ काम करने के लिए एक न्यूनतम लाइब्रेरी है। यह तेज़ और सरल है, जो उन डेवलपर्स के लिए आदर्श है जिन्हें अधिक नियंत्रण की आवश्यकता है।