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

Introduction : Pourquoi la mise en cache est nécessaire en JavaScript

Les applications web modernes sur Node.js traitent des millions de requêtes chaque jour. Sans une mise en cache appropriée, chaque appel à une base de données ou à une API externe crée un délai, augmente la charge du serveur et dégrade l'expérience utilisateur. La mise en cache est une technique qui consiste à stocker temporairement les données fréquemment demandées dans un stockage rapide, afin que les opérations lourdes ne soient pas effectuées à nouveau lors des requêtes suivantes.

Dans l'écosystème JavaScript (Node.js), il existe trois approches principales de mise en cache :

• Solutions intégrées (cache en mémoire) — des bibliothèques simples qui stockent les données dans la mémoire du processus Node.js.
• Memcached — un système de mise en cache distribué qui fonctionne en RAM.
• Redis — un magasin de données en mémoire avancé avec prise en charge de structures de données complexes.

Dans cet article, nous analyserons chaque approche en détail, fournirons des exemples de code en JavaScript et vous aiderons à choisir la solution optimale pour votre projet.

Solutions intégrées pour la mise en cache dans Node.js

La façon la plus simple d'organiser la mise en cache est d'utiliser les capacités intégrées de JavaScript ou des bibliothèques légères. Ces solutions ne nécessitent pas l'installation de services externes et sont idéales pour les petits projets ou les prototypes.

Cache d'objet simple

Un exemple basique de mise en cache utilisant un objet JavaScript classique :

class SimpleCache {  constructor() {    this.cache = {};  }

  get(key) {    return this.cache[key];  }

  set(key, value, ttl = 60000) {    this.cache[key] = value;    setTimeout(() => {      delete this.cache[key];    }, ttl);  }

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

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

// Usageconst cache = new SimpleCache();cache.set('user:123', { name: 'Anna', role: 'admin' }, 30000);console.log(cache.get('user:123')); // { name: 'Anna', role: 'admin' }

Inconvénients de cette approche : pas de nettoyage automatique de la mémoire, fuites mémoire avec un grand nombre de clés, pas de prise en charge de la mise en cache distribuée.

Bibliothèque node-cache

Une option plus avancée consiste à utiliser le package node-cache :

const NodeCache = require('node-cache');const myCache = new NodeCache({ stdTTL: 100, checkperiod: 120 });

// Save datamyCache.set('key', { data: 'value' });

// Get dataconst value = myCache.get('key');if (value === undefined) {  // Data not found — need to fetch from DB  console.log('Cache miss');} else {  console.log('Cache hit:', value);}

// Delete by keymyCache.del('key');

// Statisticsconsole.log(myCache.getStats());

node-cache prend en charge le TTL (time to live), le nettoyage automatique des clés expirées et les statistiques de base. Cependant, il ne convient pas aux applications multi-processus — chaque processus Node.js stocke sa propre copie des données.

Memcached : Mise en cache distribuée légère

Memcached est un système de mise en cache d'objets distribué haute performance en RAM. Il est idéal pour la mise en cache des résultats de requêtes de base de données, des sessions utilisateur et des fragments HTML.

Installation et connexion de Memcached

Commencez par installer le serveur Memcached et le client pour Node.js :

# Install server (Ubuntu/Debian)sudo apt-get install memcached

# Install client for Node.jsnpm install memcached

Exemple de travail avec Memcached dans Node.js

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

// Save data with TTL (in seconds)memcached.set('user:456', { name: 'Ivan', email: 'ivan@example.com' }, 3600, (err) => {  if (err) console.error('Error saving:', err);});

// Get datamemcached.get('user:456', (err, data) => {  if