Client Redis pour Go (Golang) — go-redis et radix

Client Redis pour Go (Golang) : go-redis et radix

Redis est l'une des bases de données in-memory les plus populaires, utilisée pour la mise en cache, les files d'attente, les sessions et l'analyse en temps réel. Dans l'écosystème Go (Golang), il existe plusieurs clients matures pour travailler avec Redis. Dans cet article, nous allons détailler deux bibliothèques principales : go-redis (le client le plus populaire) et radix (plus performant et de bas niveau). Vous apprendrez comment les installer, vous connecter, effectuer des opérations de base, utiliser les pipelines, le Pub/Sub et travailler avec un cluster.

1. Pourquoi Redis est important pour un développeur Go

Go est souvent choisi pour créer des applications serveur à forte charge, des microservices et des gestionnaires d'événements. Redis complète parfaitement Go grâce à :

• Sa vitesse — les opérations s'effectuent en microsecondes.
• Sa simplicité — API minimaliste, structures de données intégrées (chaînes, listes, ensembles, hachages).
• Sa prise en charge du Pub/Sub, des transactions et des scripts Lua.

Le bon choix du client détermine les performances et la facilité de développement.

2. go-redis — le standard de facto

go-redis (dépôt github.com/redis/go-redis/v9) est le client Redis le plus populaire pour Go. Il fournit une API de haut niveau, la prise en charge des clusters, des sentinelles, des pipelines, du Pub/Sub et des verrous distribués.

2.1 Installation

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

2.2 Connexion à 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: "", // sans mot de passe        DB:       0,  // base par défaut    })

    // Vérification de la connexion    pong, err := rdb.Ping(ctx).Result()    if err != nil {        panic(err)    }    fmt.Println(pong) // PONG}

2.3 Opérations de base

// Définir une chaîneerr := rdb.Set(ctx, "key", "value", 0).Err()if err != nil {    panic(err)}

// Obtenir une chaîneval, err := rdb.Get(ctx, "key").Result()if err != nil {    panic(err)}fmt.Println("key:", val)

// Travailler avec des hachagesrdb.HSet(ctx, "user:1", "name", "Alice", "age", 30)name, _ := rdb.HGet(ctx, "user:1", "name").Result()fmt.Println("Nom :", name)

// Supprimer une clérdb.Del(ctx, "key")

2.4 Pipelines

Les pipelines permettent d'envoyer plusieurs commandes en un seul appel réseau, ce qui accélère considérablement les opérations par lots.

pipe := rdb.Pipeline()

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

// Exécuter toutes les commandes_, err := pipe.Exec(ctx)if err != nil {    panic(err)}

fmt.Println("Nouvelle valeur du compteur :", incr.Val())

2.5 Pub/Sub

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

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

// Éditeur (dans une autre goroutine)rdb.Publish(ctx, "mychannel", "Bonjour depuis Go!")

2.6 Travailler avec un cluster

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

// Utilisé comme un client normalerr := clusterClient.Set(ctx, "cluster_key", "value", 0).Err()if err != nil {    panic(err)}

3. radix — léger et rapide

radix (github.com/mediocregopher/radix/v4) est un client minimaliste avec un faible niveau d'abstraction. Il n'a pas de dépendances, fonctionne plus rapidement que go-redis sur les opérations simples et donne un contrôle total sur la couche réseau.

3.1 Installation

go get github.com/mediocregopher/radix/v4

3