Formations — 1 037 leçons en français

Accueil › Node.js › Le cache, et ce qu'il coûte

Le cache, et ce qu'il coûte

Performance et montée en chargeavance

Un cache ne supprime pas un problème. Il l'échange contre trois autres : l'invalidation, la cohérence entre instances, et la ruée quand l'entrée expire.

Les trois décisions

const cache = new Map();

function cle(params) {
  // canonique : seuls les paramètres qui changent la réponse, triés
  return ["produits", params.categorie, params.tri ?? "defaut", params.page ?? 1].join("|");
}

async function lireProduits(params) {
  const k = cle(params);
  const entree = cache.get(k);
  if (entree && entree.expireA > Date.now()) return entree.valeur;

  const valeur = await requeteBase(params);
  cache.set(k, { valeur, expireA: Date.now() + 60_000 });   // durée explicite
  return valeur;
}

Trois choses sont décidées ici, et chacune se discute : la clé est canonique, la durée de vie est explicite, et le cache est local au processus — donc huit instances servent huit versions différentes.

La ruée

À l'instant où expireA est dépassé, toutes les requêtes en cours trouvent le cache vide et partent toutes vers la base. Si le recalcul prend 300 ms sous 200 requêtes par seconde, cela fait soixante requêtes identiques.

const enVol = new Map();

function lireAvecVerrou(k, calculer) {
  const entree = cache.get(k);
  if (entree && entree.expireA > Date.now()) return entree.valeur;
  if (enVol.has(k)) return enVol.get(k);            // un seul recalcul

  const p = calculer().then((valeur) => {
    cache.set(k, { valeur, expireA: Date.now() + 60_000 });
    enVol.delete(k);
    return valeur;
  }, (e) => { enVol.delete(k); throw e; });

  enVol.set(k, p);
  return p;
}

Stocker la promesse et non la valeur suffit : les demandes concurrentes reçoivent la même, et un seul recalcul part.

Ce qu'un cache coûte

De la mémoire, de l'incohérence, et un chemin de code de plus à déboguer. Il ne se justifie que si le taux de coups au but est élevé et la donnée tolérante au retard.

Les termes à connaître

Clé canonique

Une clé construite de façon déterministe à partir des paramètres qui changent la réponse, et d'eux seuls. Deux requêtes équivalentes doivent produire la même clé.

Durée de vie

Le temps pendant lequel une entrée reste servie sans être recalculée. Elle est toujours explicite : un cache sans durée de vie est une fuite de mémoire qui sert des données périmées.

Invalidation

Retirer une entrée devenue fausse avant son expiration. C'est le problème difficile du cache, parce qu'il faut savoir quelles clés une écriture rend fausses.

Ruée à l'expiration

À l'instant où une entrée très demandée expire, toutes les requêtes en cours recalculent la même valeur en même temps.

Verrou de rafraîchissement

Un marqueur qui autorise un seul recalcul à la fois pour une clé donnée. Les autres demandes attendent ou servent la valeur périmée.

Rafraîchissement anticipé

Recalculer une entrée un peu avant son expiration, pendant qu'elle est encore servie. Il n'y a alors jamais de trou.

Taux de coups au but

La part des lectures servies depuis le cache. En dessous d'un certain seuil, le cache coûte plus qu'il ne rapporte.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.