optimiser les performances de votre API avec un cache Redis dans Node.js et Express

Introduction : pourquoi un cache Redis dans votre stack Node.js/Express ?

Les API REST souffrent souvent de latence due aux accès répétés à la base de données. En intégrant Redis (moteur de cache en mémoire ultra-rapide), vous pouvez réduire jusqu’à 80 % des requêtes vers votre base, et diminuer le temps de réponse moyen de 200 ms à 50 ms. Ce tutoriel détaille l’implémentation pas à pas dans une application Node.js avec Express, en local ou via Docker.

Étape 1 : installer et démarrer Redis

1. Via Docker :

   docker run -d --name redis-cache -p 6379:6379 redis:7.0

2. Ou en local (Ubuntu) :

   sudo apt-get update  
   sudo apt-get install redis-server  
   sudo systemctl enable redis-server --now

3. Vérifiez le statut : redis-cli ping doit renvoyer PONG.

Étape 2 : connecter Redis à votre application Express

Dans le répertoire de votre API :

npm install redis dotenv

Configuration du client

require('dotenv').config();  
const { createClient } = require('redis');

const redisClient = createClient({  
  url: process.env.REDIS_URL || 'redis://localhost:6379'  
});

redisClient.on('error', err => console.error('Redis Client Error', err));

(async () => {  
  await redisClient.connect();  
})();

Ajoutez REDIS_URL=redis://localhost:6379 dans votre .env.

Étape 3 : créer un middleware de mise en cache

async function cacheMiddleware(req, res, next) {  
  const key = req.originalUrl;  
  const cached = await redisClient.get(key);

  if (cached) {  
    console.log('→ réponse depuis Redis');  
    return res.json(JSON.parse(cached));  
  }  

  // Adapter res.json pour stocker la réponse  
  res.sendResponse = res.json;  
  res.json = (body) => {  
    redisClient.setEx(key, 60, JSON.stringify(body)); // TTL 60s  
    res.sendResponse(body);  
  };  

  next();  
}

Injectez ce middleware sur les routes les plus sollicitées :

app.get('/api/products', cacheMiddleware, productsController.list);

Étape 4 : gestion de l’invalidation du cache

Quand les données changent (POST, PUT, DELETE), supprimez la clé ou le pattern correspondant :

await redisClient.del('/api/products');  
// ou pour un pattern  
const keys = await redisClient.keys('/api/products*');  
await Promise.all(keys.map(k => redisClient.del(k)) );

Bonnes pratiques et tuning

• TTL ajusté selon la fréquence de mise à jour (de 10 s à plusieurs heures).
• Clustering Redis : pour haute disponibilité (Redis Sentinel, Cluster).
• Monitoring : utilisez Prometheus et Grafana pour suivre le hit rate et la latence.
• Politique d’éviction (LRU par défaut) à configurer si vous stockez beaucoup de données.
• Protégez l’accès avec NGINX et un firewall pour éviter les requêtes non autorisées.

Conclusion

En quelques lignes de code, vous réduisez significativement la charge de votre base et améliorez l’expérience utilisateur. Pour aller plus loin (sharding, geo-réplication, persistance sous formes de snapshots), Novane peut vous accompagner dans la mise en place d’une architecture hautement scalable et sécurisée. Contactez-nous pour un audit gratuit.

CTA discret : Envie de déployer rapidement votre cache Redis en production ? Demandez votre devis personnalisé.