Guide

Redis 8, structures de données et question de la licence

Redis 8 va bien au-delà du cache : structures de données, vector sets, durabilité et licence AGPLv3. Cache, pièges, Valkey, Upstash et bonnes pratiques.

L'équipe CodeWorlds14 min de lecture ·

Pratique NestJS dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article11

Redis garde les données dans la mémoire de travail et les sert par le réseau, donc une lecture prend une fraction de milliseconde plutôt que plusieurs. La version actuelle est la 8.10.1, datée du 17 août 2026.

Le plus grand malentendu sur cet outil est de le réduire à un cache. La mise en cache est l'usage le plus courant, mais la vraie valeur réside dans des structures de données qui font ce qui, dans une base de données ordinaire, demande plusieurs requêtes et un verrou.

La licence, ce qu'il faut régler d'abord

L'affaire est embrouillée et vaut la peine d'être démêlée, car elle revient dans toutes les conversations sur cet outil.

Pendant des années, le projet a été publié sous licence BSD, et les versions 7.2 et antérieures y restent soumises à ce jour. Le changement s'est fait en deux étapes, souvent condensées en une, et c'est là que commence la confusion. La première étape est arrivée le 20 mars 2024 et concernait la version 7.4 : un modèle double a été introduit, un choix entre RSALv2 et SSPLv1, qu'aucune des deux n'est reconnue comme ouverte par l'organisme qui évalue les licences ouvertes. Un fork nommé Valkey est alors apparu, tiré de la dernière version sous l'ancienne licence, dirigé par une fondation et soutenu par plusieurs grands fournisseurs cloud.

Depuis la version 8.0 de mai 2025, le projet propose un choix entre trois licences, dont l'AGPLv3, qui est reconnue comme ouverte. Formellement, le retour a eu lieu, mais sous une licence différente de l'originale.

Ce que cela signifie en pratique. Pour l'écrasante majorité des utilisateurs, rien, car l'AGPL impose des obligations à qui propose une version modifiée comme service plutôt qu'à qui se connecte à la base de données par le réseau depuis son application. Cela commence à compter dans deux situations : quand vous modifiez le code du serveur et le distribuez, et quand le service juridique de votre entreprise a une règle qui rejette cette famille de licences sans examiner les détails.

Les deux projets sont vivants et publient à un rythme similaire, donc le choix entre eux est réel plutôt qu'académique. Valkey reste sous l'ancienne licence BSD et c'est l'option par défaut chez certains fournisseurs cloud, ce qui est parfois l'argument décisif quand vous utilisez de toute façon leur service géré.

Les structures qui font la différence

Il vaut la peine d'aller au-delà du stockage et de la lecture de chaînes, car c'est la partie la moins intéressante.

Un ensemble trié contient des éléments auxquels est attribuée une valeur et permet d'interroger des plages. C'est un classement tout prêt : enregistrer le score d'un joueur et récupérer le top dix sont deux opérations, sans tri et sans verrou.

Une liste fonctionne comme une file depuis les deux extrémités. Ajouter une tâche à un bout et la prendre à l'autre, avec la possibilité d'attendre qu'un élément apparaisse, donne une file de tâches sans monter un système séparé.

Un ensemble à cardinalité approximative répond à la question du nombre d'éléments uniques en occupant une quantité de mémoire fixe et petite quelle que soit l'échelle. Compter les visiteurs uniques d'un site de plusieurs millions de visites tient dans une douzaine de kilooctets au prix de quelques pour cent de précision.

Un flux (stream) est un journal d'événements avec des groupes de consommateurs et des accusés de réception. C'est une voie raisonnable pour le traitement d'événements où un système de files complet serait excessif.

Un ajout plus récent de la huitième version est le vector set. Il permet de conserver des embeddings et de chercher par similarité sans monter une base vectorielle séparée, ce qui, pour de petites collections, suffit souvent et est bien plus simple à exploiter.

La mise en cache et où elle casse

Puisque la mise en cache est l'usage le plus courant, il vaut la peine de décrire où elle échoue habituellement.

Python
def get_product(id: str) -> dict:
    key = f"product:{id}"
    data = r.get(key)
    if data:
        return json.loads(data)

    product = db.get_product(id)
    r.set(key, json.dumps(product), ex=300)
    return product

Ce code est correct et contient trois problèmes qui n'apparaissent que sous charge.

Le premier est l'expiration simultanée de nombreuses clés. Si mille produits sont entrés dans le cache dans la même seconde après un déploiement, ils expirent tous dans la même seconde cinq minutes plus tard, et la base de données reçoit mille requêtes d'un coup. La réponse est d'ajouter une variation aléatoire à la durée de vie.

Le deuxième est une course sur une clé très sollicitée. Une clé demandée par cinq cents requêtes parallèles qui expire produit cinq cents requêtes vers la base, car chaque requête voit un cache vide. La réponse est un verrou qui laisse une requête rafraîchir la valeur pendant que les autres attendent ou reçoivent la précédente.

Le troisième est l'invalidation. Modifier un produit dans la base de données ne change rien dans le cache, donc les utilisateurs voient l'ancien prix pendant cinq minutes. Supprimer la clé à l'écriture est la bonne réponse et exige que chaque endroit qui modifie des données s'en souvienne, ce qui, dans une application plus grande, est plus difficile qu'il n'y paraît.

Retenez aussi le principe général : un cache doit accélérer les choses plutôt que d'être la source de vérité. Une application qui cesse de fonctionner après le redémarrage de ce serveur n'utilise pas un cache mais y stocke des données.

Durabilité et ce qui se passe en cas de panne

Les données se trouvent en mémoire, donc la question de ce qui survit à une coupure de courant est fondamentale.

Deux mécanismes existent. Le premier écrit périodiquement un instantané de l'état ; le second ajoute chaque opération à un journal. Un instantané est bon marché et perd tout ce qui s'est passé depuis la dernière écriture. Un journal perd moins et coûte plus cher en écriture et au démarrage.

Le point clé à comprendre : même la variante qui ajoute chaque opération se synchronise sur le disque une fois par seconde par défaut, donc une panne perd jusqu'à une seconde d'écritures. Régler la synchronisation à chaque opération supprime cette fenêtre et réduit fortement le débit.

La conclusion pratique est simple et souvent sautée. Ce n'est pas une base de données pour des données dont la perte est inacceptable. Sessions, caches, compteurs, files de tâches qu'on peut rejouer, oui. Soldes de comptes et commandes, non.

La réplication résout un problème différent de la durabilité : la disponibilité et la répartition des lectures. À retenir, car la réplication est asynchrone, donc l'accusé de réception d'une écriture ne signifie pas qu'un réplica la détient déjà.

Les vector sets et quand ils suffisent

Le nouveau type de données de la huitième version mérite un traitement séparé, car il résout un problème qu'on traite habituellement en montant une base de données séparée.

Il s'agit de stocker des embeddings, des vecteurs de nombres qui représentent le sens d'un texte, et de trouver ceux qui sont les plus proches d'une requête. C'est le fondement des applications qui répondent à des questions à partir de documents.

L'avantage est opérationnel plutôt que qualitatif. Si vous exploitez déjà ce serveur pour le cache et les sessions, ajouter une recherche par similarité n'exige aucun service supplémentaire à maintenir, aucun jeu de sauvegardes de plus et aucun endroit de plus où quelque chose peut tomber en panne.

La limite est tout aussi claire. Les données se trouvent en mémoire, donc la collection d'embeddings doit y tenir à côté de tout le reste, et les embeddings sont volumineux : cent mille fragments de texte à une dimension typique, c'est plusieurs centaines de mégaoctets. Sur des millions de documents, le bon choix est une base de données conçue pour cela, qui garde son index sur disque.

La règle pratique est la suivante : jusqu'à quelques dizaines de milliers de fragments, c'est une bonne réponse et cela économise toute une couche d'infrastructure. Au-delà, calculez la mémoire avant de découvrir que la recherche évince le cache qui fonctionnait auparavant.

Pensez aussi à la durabilité. Une collection d'embeddings construite au prix de nombreux appels à un modèle et stockée uniquement ici doit être reconstruite après une panne, et cela coûte à nouveau. Garder les fragments sources dans une base relationnelle et traiter la recherche comme une couche reproductible revient moins cher que de garantir la durabilité à cet endroit.

L'intégrer à une application

Quelques éléments liés à la connexion évitent des ennuis lors d'un premier déploiement.

Un pool de connexions est obligatoire. Ouvrir une connexion par requête gaspille du temps en poignées de main et, sous un trafic plus lourd, épuise la limite de descripteurs. Les bibliothèques clientes embarquent un pool et l'utiliser vaut mieux que créer un client à l'intérieur d'un gestionnaire de requêtes.

Réglez les délais d'expiration explicitement. Un serveur qui a cessé de répondre bloque une requête quand aucun délai n'existe, et avec un cache c'est particulièrement mauvais, car une couche censée accélérer les choses arrête l'application. La voie raisonnable est un délai court et un repli vers la source de données quand le cache reste muet.

Décidez délibérément du comportement en cas d'indisponibilité. Une application qui va à la base de données quand le cache manque survit à une panne lentement mais en tournant. Une application qui renvoie une erreur tombe entièrement à cause d'une couche qui était censée être facultative.

Pour la mémoire des agents et les données de session, il vaut la peine de réfléchir à l'endroit où passe la frontière entre ce serveur et une couche durable, celle décrite dans la mémoire dans LangGraph par exemple. L'état de la conversation en cours tient ici ; ce qui doit survivre pendant des semaines va dans une base de données.

Redis face aux alternatives

OptionModèleDurabilitéÀ choisir quand
RedisStructures en mémoireConfigurable, avec une fenêtre de perteCache, sessions, files, compteurs
ValkeyLa même chose, licence BSDProtocole oui, fichiers de données nonLa licence compte, ou votre cloud le propose
UpstashInterface compatible, facturation par requêteDu côté du fournisseurTrafic irrégulier, environnements serverless
Une base relationnelleDonnées sur disqueComplèteDonnées dont la perte est inacceptable

Les deux premières lignes sont compatibles au niveau du protocole, donc passer de l'une à l'autre se résume généralement à changer une adresse. La différence tient à la licence et à ce que propose votre fournisseur cloud plutôt qu'aux capacités.

La troisième ligne mérite réflexion en cas de trafic irrégulier. Un déploiement classique paie la mémoire retenue quelle que soit l'utilisation, alors que la facturation par requête convient à une application inactive la plupart de la journée. À trafic élevé et stable, l'économie s'inverse.

La dernière ligne n'est pas une alternative mais un rappel. Se tourner vers cet outil pour des données qui exigent des garanties de durabilité est une erreur d'architecture courante, qui vient de sa rapidité et de sa commodité.

Des usages au-delà du cache

Trois cas où cet outil l'emporte nettement sur les alternatives.

La limitation du débit des requêtes. Un compteur avec une durée de vie, ou une fenêtre glissante construite sur un ensemble trié, donne un mécanisme qui fonctionne correctement sur de nombreuses instances de l'application, ce que ne fait pas un compteur dans la mémoire du processus.

Les sessions utilisateur. Un endroit partagé visible de chaque instance, avec expiration automatique, et sans avoir besoin d'attacher un utilisateur à un serveur particulier.

Les verrous distribués. Définir une clé seulement si elle n'existe pas, avec une durée de vie, donne un mécanisme qui garantit qu'une tâche planifiée s'exécute une fois plutôt que sur chaque instance.

Connaissez la limite sur ce dernier point. Un verrou correct exige un identifiant de propriétaire aléatoire et une libération uniquement par celui qui l'a acquis, sinon une tâche lente libère un verrou qu'un autre processus détient déjà. C'est un endroit où utiliser une bibliothèque existante plutôt que d'écrire la vôtre.

La pratique quotidienne

Quelques éléments évitent des ennuis sur une maintenance plus longue.

Fixez une limite de mémoire et une politique d'éviction. Sans elles, le serveur grossit jusqu'à ce que la machine manque de mémoire, et le comportement dépend alors du système et tend à être désagréable. Une politique qui évince les clés les moins récemment utilisées convient à un cache ; refuser les écritures convient à des données qui ne doivent pas disparaître.

Donnez une durée de vie à tout ce qui est un cache. Une clé sans durée de vie reste pour toujours, et après un changement de schéma de clés, les anciennes restent comme des déchets que personne ne nettoiera.

N'utilisez pas en production la commande qui liste toutes les clés. Elle bloque le serveur pendant qu'elle parcourt tout l'ensemble, et sur des millions de clés cela se remarque pour tout le monde. Itérer par lots est à quoi sert la variante de parcours.

Regroupez les opérations au lieu de multiplier les appels. Cent requêtes séparées représentent cent allers-retours réseau ; la même chose envoyée en un seul lot en prend un. Sur des lectures dans une boucle, la différence est de plusieurs dizaines de fois.

Le dernier élément, ce sont les scripts exécutés côté serveur. Ils permettent à plusieurs opérations de s'exécuter de façon indivisible, ce qui, sur les compteurs et les verrous, supprime des courses impossibles à supprimer côté client.

Erreurs courantes

La première est l'absence de variation aléatoire dans les durées de vie des clés. Une expiration massive dans la même seconde reporte toute la charge sur la base de données.

La deuxième est de traiter cet outil comme la source de vérité. Une application qui cesse de fonctionner après le redémarrage de ce serveur ne met pas en cache mais stocke des données dans un endroit sans garanties.

La troisième est l'absence de limite de mémoire et de politique d'éviction. Le serveur grossit jusqu'à ce que la mémoire de la machine soit épuisée, et les symptômes apparaissent d'abord dans d'autres services.

La quatrième est de lister toutes les clés avec la commande bloquante. Sur un grand ensemble, cela arrête le serveur pour tous les clients.

La cinquième est un verrou distribué sans identifiant de propriétaire. Une tâche lente libère alors un verrou qui appartient déjà à un autre processus.

La sixième est de supposer qu'un réplica détient les données immédiatement après l'accusé de réception d'une écriture. La réplication est asynchrone, donc une lecture depuis un réplica peut renvoyer un état légèrement périmé.

FAQ

Redis est-il open source ?

Depuis la version 8.0 de mai 2025, un choix de licences est disponible, dont l'AGPLv3, qui est reconnue comme ouverte. Auparavant, à partir de mars 2024, une variante non reconnue comme ouverte s'appliquait, et c'est ce qui a mené au fork Valkey.

En quoi Valkey diffère-t-il ?

Par la licence, la gouvernance et, plus récemment, le format des fichiers de données. Valkey est issu de Redis 7.2.4, est dirigé par une fondation et soutenu par plusieurs grands fournisseurs cloud. La compatibilité avec le protocole et les bibliothèques clientes demeure, donc l'application n'a besoin d'aucun changement. Les fichiers de données sont une autre affaire : depuis Valkey 9.0, les formats ont divergé et un dump de Redis 8 tombe dans la plage que Valkey signale comme étrangère et rejette par défaut. Migrer en échangeant un fichier RDB n'est donc plus aussi simple qu'on le décrit souvent.

Les données survivront-elles à un redémarrage ?

Cela dépend de la configuration de la durabilité et comporte toujours une fenêtre de perte. La variante par défaut qui ajoute les opérations se synchronise sur le disque une fois par seconde, donc une panne perd jusqu'à une seconde d'écritures. Pour des données dont la perte est inacceptable, une base relationnelle est le bon choix.

Cela fonctionne-t-il comme file de tâches ?

Pour les cas simples oui, car une liste avec lecture bloquante donne une file sans infrastructure supplémentaire. Là où la livraison garantie, les nouvelles tentatives et la visibilité des tâches sont requises, un système conçu pour cela mérite réflexion, car ici une partie de ces fonctions est à construire soi-même.

Quand choisir une option gérée ?

Avec un trafic irrégulier et dans les environnements serverless, où la facturation par requête convient mieux que de payer la mémoire retenue. Upstash est le choix typique, tandis qu'à trafic élevé et stable, un déploiement classique revient moins cher.

La documentation se trouve sur le site du projet, et les versions dans le dépôt GitHub.

Dernières actualités : Redis 8

Toutes les actualités

À lire aussi