Mise en cache en Go (Golang) : Redis, mise en cache groupée et en mémoire

Mise en cache en Go (Golang) : Redis et autres solutions

La mise en cache est l'un des outils clés pour améliorer les performances des applications Go. Elle permet de réduire le temps de réponse, de diminuer la charge sur les bases de données et les API externes. Dans cet article, nous examinerons les principales approches de mise en cache en Go : l'utilisation de Redis comme stockage externe, la mise en cache intégrée en mémoire et la mise en cache groupée avec la bibliothèque groupcache.

1. Pourquoi la mise en cache en Go ?

Go est un langage axé sur les hautes performances, mais même les requêtes les plus rapides vers une base de données ou des services externes peuvent devenir un goulot d'étranglement. La mise en cache permet de :

• Réduire les latences pour les requêtes répétitives.
• Diminuer la charge sur les bases de données et les API tierces.
• Augmenter le débit du serveur.
• Lisser les pics de charge.

2. Redis — mise en cache distribuée

Redis est la solution la plus populaire pour le cache externe en Go. Il fonctionne comme un stockage en mémoire avec prise en charge du TTL, de la persistance et des structures de données complexes.

Connexion à Redis en Go

Pour travailler avec Redis en Go, la bibliothèque go-redis est la plus couramment utilisée. Installation :

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

Exemple : mise en cache simple avec TTL

package main

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

var ctx = context.Background()

func main() {    rdb := redis.NewClient(&redis.Options{        Addr: "localhost:6379",    })

    // Définit une valeur avec un TTL de 10 secondes    err := rdb.Set(ctx, "user:42", `{"name":"Alice"}`, 10*time.Second).Err()    if err != nil {        panic(err)    }

    // Récupère la valeur    val, err := rdb.Get(ctx, "user:42").Result()    if err != nil {        fmt.Println("Échec du cache")    } else {        fmt.Println("Succès du cache :", val)    }}

Stratégies d'invalidation du cache dans Redis

• TTL (Time To Live) — suppression automatique après expiration du temps.
• Invalidation paresseuse — nettoyage du cache lors de la mise à jour des données.
• Suppression par clé — appel de DEL pour une clé spécifique.
• Modèle "Cache-Aside" — l'application gère elle-même le cache : vérifie d'abord Redis, en cas d'échec, charge depuis la base de données et enregistre dans le cache.

3. Mise en cache en mémoire en Go

Pour une mise en cache locale sans dépendances externes, vous pouvez utiliser les structures intégrées de Go ou des bibliothèques spécialisées.

Cache en mémoire simple avec sync.Map

package main

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

type CacheItem struct {    Value      interface{}    Expiration int64}

type Cache struct {    items sync.Map}

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {    c.items.Store(key, CacheItem{        Value:      value,        Expiration: time.Now().Add(ttl).UnixNano(),    })}

func (c *Cache) Get(key string) (interface{}, bool) {    item, found := c.items.Load(key)    if !found {        return nil, false    }    cacheItem := item.(CacheItem)    if time.Now().UnixNano() > cacheItem.Expiration {        c.items.Delete(key)        return nil, false    }    return cacheItem.Value, true}

func main() {    cache := &Cache{}    cache.Set("key1", "value1", 5*time.Second)    val, ok := cache.Get("key1")    if ok {        fmt.Println("Trouvé :", val)    }}

Bibliothèque freecache

freecache est une bibliothèque en mémoire performante avec prise en charge du TTL et une faible consommation mémoire. Installation :

go get github.com/coocood/freecache

cache := freecache.NewCache(100 * 1024 * 1024) // 100 Mocache.Set([]by