Mise en cache en JavaScript : Redis, Memcached et solutions intégrées pour Node.js

Mise en cache en JavaScript : Redis, Memcached et solutions intégrées

La mise en cache est l'une des stratégies clés pour optimiser les performances des applications web. Dans l'écosystème JavaScript (notamment Node.js), les développeurs disposent d'outils puissants : des mécanismes intégrés aux systèmes distribués comme Redis et Memcached. Dans cet article, nous allons détailler comment et quand utiliser chaque approche, avec des exemples de code concrets.

Pourquoi la mise en cache est-elle nécessaire dans Node.js ?

Sans mise en cache, chaque requête au serveur peut entraîner des opérations coûteuses : lecture depuis la base de données, calculs complexes ou appels à des API externes. Le cache stocke le résultat de la première requête et le fournit lors des requêtes suivantes. Cela réduit la charge du serveur, diminue le temps de réponse et améliore l'expérience utilisateur.

Principaux cas d'utilisation de la mise en cache dans Node.js :

• Résultats de requêtes de base de données (notamment les agrégations)
• Réponses d'API externes (météo, taux de change)
• Calculs lourds (génération de rapports, traitement d'images)
• Sessions utilisateur et jetons d'authentification

Mise en cache intégrée en JavaScript (Node.js)

La méthode la plus simple consiste à utiliser un Map ou un Object pour stocker les données dans la mémoire du processus. C'est rapide, mais présente des limites : les données ne vivent que tant que le serveur est en cours d'exécution et la mémoire n'est pas illimitée.

Exemple : Cache basé sur Map avec TTL (durée de vie)

class SimpleCache {    constructor(ttl = 60000) {        this.cache = new Map();        this.ttl = ttl; // durée de vie en ms (1 minute par défaut)    }

    set(key, value) {        this.cache.set(key, {            value,            timestamp: Date.now()        });    }

    get(key) {        const item = this.cache.get(key);        if (!item) return null;        if (Date.now() - item.timestamp > this.ttl) {            this.cache.delete(key);            return null;        }        return item.value;    }

    delete(key) {        this.cache.delete(key);    }

    clear() {        this.cache.clear();    }}

// Utilisationconst cache = new SimpleCache(30000); // 30 secondescache.set('user_123', { name: 'Ivan', role: 'admin' });const user = cache.get('user_123');console.log(user); // { name: 'Ivan', role: 'admin' }

Avantages : latence nulle, simplicité, aucune dépendance externe requise.
Inconvénients : les données sont perdues lors du redémarrage, limitées par la mémoire d'un seul processus, inadaptées aux systèmes distribués.

Pour un cache intégré plus avancé, vous pouvez utiliser le package node-cache, qui ajoute le nettoyage automatique, les statistiques et la prise en charge des clés sous forme de chaînes.

Redis : cache distribué pour Node.js

Redis est un magasin de données en mémoire souvent utilisé comme cache. Dans Node.js, le package ioredis (plus moderne que redis) est utilisé pour travailler avec Redis.

Installation et connexion de base

npm install ioredis

const Redis = require('ioredis');const redis = new Redis({    host: 'localhost',    port: 6379,    // password: 'votre-mot-de-passe' // si requis});

redis.on('connect', () => console.log('Connecté à Redis'));redis.on('error', (err) => console.error('Erreur Redis :', err));

Exemple : Mise en cache des données avec TTL

const Redis = require('ioredis');const redis = new Redis();

async function getCachedData(key, fetchFunction, ttl = 3600) {    // Essayer de récupérer depuis le cache    const cached = await redis.get(key);    if (cached) {        return JSON.parse(cached);    }

    // Si non trouvé — récupérer les données et les sauvegarder    const data = await fetchFunction();    await redis.setex(key, ttl, JSON.stringify(data));    return data;}

// Exemple d'utilisation : mise en cache