Mise en cache en JavaScript (Node.js) : Redis et autres…

Mise en cache en JavaScript (Node.js) : Redis et autres outils

La mise en cache est l'un des moyens les plus efficaces d'améliorer les performances des applications web Node.js. Elle permet de réduire le temps de réponse, de diminuer la charge sur les bases de données et de réduire les coûts d'infrastructure. Dans cet article, nous allons examiner les principaux outils de mise en cache dans l'environnement Node.js : Redis, Memcached et la mise en cache intégrée en mémoire (in-memory cache). Vous apprendrez quand choisir quel outil et verrez des exemples de code fonctionnels.

Pourquoi la mise en cache dans Node.js ?

Node.js est monothread mais asynchrone. Chaque requête à une base de données ou à une API externe implique une attente (I/O). Le cache permet de stocker le résultat d'une opération coûteuse (par exemple, une requête SQL complexe ou l'analyse HTML) et de le restituer instantanément. Les principaux cas d'utilisation :

Stockage des résultats de requêtes à la base de données (notamment les requêtes d'agrégation)
Mise en cache des réponses d'API externes (météo, taux de change)
Stockage des sessions utilisateur
Stockage temporaire des données calculées (par exemple, le rendu de templates)

1. Redis — le roi de la mise en cache

Redis est un magasin de données en mémoire souvent utilisé comme cache. Il fonctionne dans un processus séparé, prend en charge des structures de données complexes (chaînes, hachages, listes, ensembles) et dispose de mécanismes TTL intégrés (durée de vie des clés).

Installation et connexion

Pour fonctionner, vous aurez besoin d'un serveur Redis installé (localement ou dans Docker). Dans Node.js, nous utilisons le package redis :

npm install redis

Exemple : mise en cache de données avec TTL

const redis = require('redis');const client = redis.createClient();

client.on('error', (err) => console.error('Erreur Redis :', err));

// Fonction asynchrone pour récupérer des données avec cacheasync function getCachedData(key, fetchFunction, ttlSeconds = 60) {  // Essayer de récupérer depuis le cache  const cached = await client.get(key);  if (cached) {    return JSON.parse(cached);  }

  // Sinon, appeler la fonction coûteuse  const freshData = await fetchFunction();

  // Sauvegarder dans le cache avec TTL  await client.setEx(key, ttlSeconds, JSON.stringify(freshData));  return freshData;}

// Utilisation : mise en cache du résultat d'une requête à la base de donnéesconst users = await getCachedData('users:list', () => db.query('SELECT * FROM users'), 120);

Avantages de Redis

Haute performance (des millions d'opérations par seconde)
Prise en charge de TTL, pub/sub, transactions
Persistance (possibilité de sauvegarder sur disque)
Adapté aux systèmes distribués (plusieurs serveurs Node.js)

Inconvénients

Nécessite un serveur/conteneur dédié
Consomme de la mémoire vive
Superflu pour les applications monothread simples

2. Memcached — léger et rapide

Memcached est un autre cache en mémoire populaire, mais plus simple que Redis : uniquement des chaînes, pas de persistance, pas de structures complexes. Idéal pour une mise en cache simple de données.

Installation et exemple

npm install memcached

const Memcached = require('memcached');const memcached = new Memcached('localhost:11211');

async function getCachedData(key, fetchFunction, ttlSeconds = 60) {  return new Promise((resolve, reject) => {    memcached.get(key, async (err, data) => {      if (data) return resolve(JSON.parse(data));

      const freshData = await fetchFunction();      memcached.set(key, JSON.stringify(freshData), ttlSeconds, (err) => {        if (err) reject(err);        resolve(freshData);      });    });  });}