Mise en cache en Go (Golang) : Redis, in-memory et autres…

Mise en cache en Go (Golang) : Redis, in-memory et autres solutions

La mise en cache est l'une des stratégies clés pour améliorer les performances et réduire la charge sur les bases de données dans les applications Go. Dans cet article, nous examinerons les principales approches et bibliothèques pour implémenter la mise en cache : des solutions in-memory simples au cache distribué basé sur Redis. Vous apprendrez quand choisir quel outil et comment organiser correctement le cache dans les projets Go.

1. Fonctionnalités intégrées : map et sync.Map

La façon la plus simple de mettre en cache en Go est d'utiliser une map classique avec un mutex ou une sync.Map thread-safe. Ces approches conviennent aux petits projets ou prototypes où une politique d'invalidation complexe n'est pas nécessaire.

Exemple avec sync.Map :

package main

import (    "fmt"    "sync")

type Cache struct {    data sync.Map}

func (c *Cache) Set(key string, value interface{}) {    c.data.Store(key, value)}

func (c *Cache) Get(key string) (interface{}, bool) {    return c.data.Load(key)}

func main() {    cache := &Cache{}    cache.Set("user:1", "Alice")    if val, ok := cache.Get("user:1"); ok {        fmt.Println("Trouvé :", val)    }}

Avantages : simplicité, zéro dépendance.
Inconvénients : pas de TTL, pas de nettoyage automatique, mémoire non limitée.

2. Cache in-memory avec TTL : freecache

Freecache est une bibliothèque de cache in-memory rapide avec prise en charge du TTL (durée de vie des entrées). Elle utilise une architecture segmentée pour minimiser les verrous et gère efficacement la mémoire.

Installation :

go get github.com/coocood/freecache

Exemple d'utilisation :

package main

import (    "fmt"    "github.com/coocood/freecache")

func main() {    // Création d'un cache de 100 Mo    cache := freecache.NewCache(100 * 1024 * 1024)

    // Définition d'une valeur avec un TTL de 10 secondes    cache.Set([]byte("mykey"), []byte("myvalue"), 10)

    // Récupération de la valeur    if val, err := cache.Get([]byte("mykey")); err == nil {        fmt.Println("Valeur :", string(val))    } else {        fmt.Println("Clé non trouvée ou expirée")    }}

Avantages : nettoyage automatique basé sur le TTL, faible consommation CPU, prise en charge de grands volumes de données.
Inconvénients : uniquement pour un seul processus (non distribué).

3. BigCache — alternative à freecache

BigCache est une autre bibliothèque in-memory populaire, optimisée pour stocker un grand nombre d'entrées (des millions) avec un temps d'accès minimal. Elle prend également en charge le TTL et l'évacuation automatique des anciennes données.

Exemple :

package main

import (    "fmt"    "github.com/allegro/bigcache/v3"    "time")

func main() {    config := bigcache.Config{        Shards:             1024,        LifeWindow:         10 * time.Minute,        CleanWindow:        5 * time.Minute,        MaxEntriesInWindow: 1000 * 10 * 60,        MaxEntrySize:       500,        Verbose:            true,    }

    cache, _ := bigcache.NewBigCache(config)    cache.Set("mykey", []byte("valeur bigcache"))    val, _ := cache.Get("mykey")    fmt.Println(string(val))}

Avantages : hautes performances avec un grand nombre de clés, configuration flexible.
Inconvénients : comme freecache — cache local.

4. Mise en cache distribuée avec Redis et go-redis

Pour les systèmes distribués où plusieurs instances d'application doivent partager un cache unique, on utilise Redis. Le client le plus populaire pour Go est go-redis (anciennement go-redis/redis).