Redis-Client für Go (Golang) — go-redis und radix

Redis-Client für Go (Golang): go-redis und radix

Redis ist eine der beliebtesten In-Memory-Datenbanken, die für Caching, Warteschlangen, Sitzungen und Echtzeit-Analysen verwendet wird. Im Go-Ökosystem (Golang) gibt es mehrere ausgereifte Clients für die Arbeit mit Redis. In diesem Artikel werden wir zwei Hauptbibliotheken im Detail besprechen: go-redis (der beliebteste Client) und radix (leistungsfähiger und niedrigerer Ebene). Sie erfahren, wie Sie diese installieren, eine Verbindung herstellen, grundlegende Operationen ausführen, Pipelines, Pub/Sub nutzen und mit einem Cluster arbeiten.

1. Warum Redis für Go-Entwickler wichtig ist

Go wird oft für die Erstellung hochbelastbarer Serveranwendungen, Microservices und Event-Handler gewählt. Redis ergänzt Go hervorragend durch:

• Geschwindigkeit – Operationen werden in Mikrosekunden ausgeführt.
• Einfachheit – minimalistische API, integrierte Datenstrukturen (Strings, Listen, Sets, Hashes).
• Unterstützung für Pub/Sub, Transaktionen und Lua-Skripte.

Die richtige Wahl des Clients bestimmt die Leistung und den Entwicklungskomfort.

2. go-redis – der De-facto-Standard

go-redis (Repository github.com/redis/go-redis/v9) ist der beliebteste Redis-Client für Go. Er bietet eine hochwertige API, Unterstützung für Cluster, Sentinels, Pipelines, Pub/Sub und verteilte Sperren.

2.1 Installation

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

2.2 Verbindung zu 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: "", // ohne Passwort        DB:       0,  // Standard-Datenbank    })

    // Verbindung prüfen    pong, err := rdb.Ping(ctx).Result()    if err != nil {        panic(err)    }    fmt.Println(pong) // PONG}

2.3 Grundlegende Operationen

// String setzenerr := rdb.Set(ctx, "key", "value", 0).Err()if err != nil {    panic(err)}

// String abrufenval, err := rdb.Get(ctx, "key").Result()if err != nil {    panic(err)}fmt.Println("key:", val)

// Arbeiten mit Hashesrdb.HSet(ctx, "user:1", "name", "Alice", "age", 30)name, _ := rdb.HGet(ctx, "user:1", "name").Result()fmt.Println("Name:", name)

// Schlüssel löschenrdb.Del(ctx, "key")

2.4 Pipelines

Pipelines ermöglichen das Senden mehrerer Befehle in einem einzigen Netzwerkaufruf, was Batch-Operationen erheblich beschleunigt.

pipe := rdb.Pipeline()

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

// Alle Befehle ausführen_, err := pipe.Exec(ctx)if err != nil {    panic(err)}

fmt.Println("Neuer Wert von counter:", incr.Val())

2.5 Pub/Sub

// Abonnentsub := rdb.Subscribe(ctx, "mychannel")ch := sub.Channel()

for msg := range ch {    fmt.Printf("Empfangen: %s", msg.Payload)}

// Herausgeber (in einer anderen Goroutine)rdb.Publish(ctx, "mychannel", "Hello from Go!")

2.6 Arbeiten mit einem Cluster

clusterClient := redis.NewClusterClient(&redis.ClusterOptions{    Addrs: []string{        "localhost:7000",        "localhost:7001",        "localhost:7002",    },})

// Wird wie ein normaler Client verwendeterr := clusterClient.Set(ctx, "cluster_key", "value", 0).Err()if err != nil {    panic(err)}

3. radix – leicht und schnell

radix (github.com/mediocregopher/radix/v4) ist ein minimalistischer Client mit niedrigem Abstraktionsniveau. Er hat keine Abhängigkeiten, ist bei einfachen Operationen schneller als go-redis und bietet volle Kontrolle über die Netzwerkebene.

3.1 Installation

go get github.com/mediocregopher/radix/v4

3