Utiliser Redis comme moteur de publication/abonnement en Go (2023)

Introduction

Dans le paysage dynamique du développement logiciel, la gestion efficace des données en mémoire est cruciale. Redis, en tant que base de données en mémoire, offre des fonctionnalités exceptionnelles pour le stockage, le cache et le courtage de messages. Dans cet article, nous explorerons comment utiliser Redis comme moteur de publication/abonnement (Pub/Sub) en Go, en mettant l'accent sur la mise en œuvre d'une application de gestion d'utilisateurs en temps réel.

Comprendre Redis

Redis, un magasin de données clé-valeur, stocke les données directement en mémoire, offrant une vitesse exceptionnelle. Bien qu'il soit souvent utilisé comme cache, Redis persiste les données par des instantanés, minimisant la perte en cas de panne système. Cependant, il est important de noter que le modèle Pub/Sub de Redis envoie chaque message à tous les abonnés et oublie les messages une fois publiés.

Configuration de l'environnement

Pour commencer, nous utiliserons Docker pour exécuter Redis et deux applications Go. La configuration se fait à l'aide de Docker Compose, assurant une mise en place fluide. Le fichier de configuration Redis spécifie la persistence des données et les paramètres du réseau.

Configuration de Redis

Le fichier redis.conf spécifie un mot de passe et utilise le nom "redis" pour la liaison, adapté à l'environnement conteneurisé.

requirepass superSecret
bind redis

Après avoir démarré l'environnement avec Docker Compose, Redis est prêt à accepter des connexions.

Applications de publication et d'abonnement

Nous créons deux applications Go, l'une pour la publication et l'autre pour l'abonnement. Ces applications se connectent à Redis et partagent un modèle utilisateur.

Application de Publication

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "math/rand"
    "time"

    "github.com/go-redis/redis/v8"
)

// ...

func main() {
    // Création d'un client Redis
    redisClient := redis.NewClient(&redis.Options{
        Addr:     "redis:6379",
        Password: "superSecret",
        DB:       0,
    })

    // Vérification de la connexion à Redis
    err := redisClient.Ping(context.Background()).Err()
    if err != nil {
        time.Sleep(3 * time.Second)
        err := redisClient.Ping(context.Background()).Err()
        if err != nil {
            panic(err)
        }
    }

    // Création d'un contexte de fond
    ctx := context.Background()

    // Boucle pour générer et publier des utilisateurs aléatoires
    for {
        err := redisClient.Publish(ctx, "new_users", GenerateRandomUser()).Err()
        if err != nil {
            panic(err)
        }

        // Attente d'une durée aléatoire
        rand.Seed(time.Now().UnixNano())
        n := rand.Intn(4)
        time.Sleep(time.Duration(n) * time.Second)
    }
}

// ...

Application d'Abonnement

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "time"

    "github.com/go-redis/redis/v8"
)

// ...

func main() {
    // Création d'un client Redis
    redisClient := redis.NewClient(&redis.Options{
        Addr:     "redis:6379",
        Password: "superSecret",
        DB:       0,
    })

    // Vérification de la connexion à Redis
    err := redisClient.Ping(context.Background()).Err()
    if err != nil {
        time.Sleep(3 * time.Second)
        err := redisClient.Ping(context.Background()).Err()
        if err != nil {
            panic(err)
        }
    }

    // Création d'un contexte de fond
    ctx := context.Background()

    // Abonnement au sujet "new_users"
    topic := redisClient.Subscribe(ctx, "new_users")
    channel := topic.Channel()

    // Itération des messages sur le canal
    for msg := range channel {
        u := &User{}
        err := u.UnmarshalBinary([]byte(msg.Payload))
        if err != nil {
            panic(err)
        }
        fmt.Println(u)
    }
}

Conclusion

En conclusion, l'utilisation de Redis comme moteur de Pub/Sub en Go offre une solution efficace pour la gestion en temps réel des données. En combinant la puissance de Redis avec les fonctionnalités avancées de Go, nous avons créé un environnement robuste pour la publication et l'abonnement d'utilisateurs générés aléatoirement. Cette approche peut être étendue pour répondre à des besoins plus complexes, offrant une flexibilité et une extensibilité exceptionnelles.

Avec cette mise en œuvre, vous êtes prêt à explorer les possibilités infinies de Redis dans votre application Go, ouvrant la porte à des scénarios tels que la distribution de travail entre microservices, la gestion centralisée des journaux, et bien plus encore. Redis et Go forment une alliance puissante pour des performances optimales et une gestion agile des données en mémoire.