# Mise en cache

## Ce que c'est

La mise en cache consiste à enregistrer le résultat d'un travail, comme une réponse HTTP, un résultat de requête ou une page rendue, puis à servir ce résultat enregistré aux requêtes suivantes selon des règles précisant combien de temps il est fiable et ce qui provoque son retrait. Le verbe est mettre en cache, et un résultat conservé de cette manière est en cache. La mise en cache des valeurs renvoyées par une fonction à l'intérieur d'un programme est généralement appelée mémoïsation.

L'espace de stockage qui contient les copies est le cache. La mise en cache est la politique qui l'entoure et répond à trois questions. Pendant combien de temps une copie est-elle fraîche, c'est-à-dire utilisable sans rien demander à personne ? Une fois périmée, comment la vérifie-t-on ? Et lorsque l'original change, qu'est-ce qui supprime ou remplace la copie ?

HTTP répond aux trois questions par des en-têtes. La RFC 9111 appelle une réponse stockée fraîche tant que son âge est inférieur à sa durée de fraîcheur. L'origine fixe celle-ci avec la directive `max-age` de `Cache-Control` ou avec une date `Expires`. Au-delà, la réponse est périmée, et un cache doit normalement la valider avant de la réutiliser. Il envoie une requête conditionnelle portant un validateur conservé, généralement l'`ETag` de la réponse dans un en-tête `If-None-Match`. Si rien n'a changé, l'origine répond 304 Not Modified, sans corps. La revalidation coûte encore un aller-retour, mais épargne le transfert et le travail de reconstruction du corps.

```http
HTTP/1.1 200 OK
Cache-Control: max-age=3600, stale-while-revalidate=60
ETag: "v42"
```

Dans une application, les mêmes questions prennent d'autres formes. Avec le modèle cache-aside, le code lit d'abord le cache puis, s'il n'y trouve rien, lit la base de données et remplit lui-même le cache. Avec le modèle write-through, chaque écriture actualise le cache en même temps que la base : une lecture trouve donc la valeur courante. Une expiration sur chaque entrée, sa durée de vie ou TTL, joue le rôle de `max-age`. Même une base de données peut mettre en cache : une vue matérialisée PostgreSQL stocke le résultat d'une requête comme une table, et ce résultat ne change que lorsque quelqu'un exécute `REFRESH MATERIALIZED VIEW`.

## Pourquoi c'est important

Chaque règle de mise en cache échange de la fraîcheur contre de la vitesse, et le bon compromis dépend du type de données. Un logo peut avoir un an. Le prix d'un produit peut avoir une minute. Un solde ou un nombre de places doit être confirmé auprès de la source avant que quelqu'un agisse sur cette base. La mise en cache échoue le plus souvent lorsqu'une règle unique est appliquée aux trois.

Pour les fichiers statiques, la réponse est la plus simple. Lorsqu'une compilation inscrit dans le nom de chaque fichier un hachage de son contenu, un fichier modifié reçoit une nouvelle URL. L'ancienne peut donc être mise en cache pendant un an. La RFC 8246 ajoute la directive `immutable`, qui indique au navigateur que la réponse restera identique tant qu'elle est fraîche. Même un rechargement peut ainsi éviter de la revalider. La page HTML qui nomme ces fichiers doit garder une durée de vie courte ou être revalidée à chaque utilisation, sinon les visiteurs continuent à charger les fichiers sous les anciens noms.

Deux directives se confondent facilement. `no-cache` permet de stocker la réponse, mais interdit de la réutiliser sans validation préalable auprès de l'origine ; `no-store` interdit tout stockage. Pour une page qui change souvent, `no-cache` avec un `ETag` donne un contenu à jour tout en économisant le transfert si rien n'a changé.

L'invalidation est la partie difficile. La RFC 9111 exige qu'un cache invalide une URL lorsqu'une requête non sûre vers elle, comme `POST`, `PUT` ou `DELETE`, réussit. La même section précise que seuls les caches traversés par cette requête sont concernés. Un navigateur, un CDN et un cache applicatif sont trois emplacements distincts. Retirer une copie de l'un laisse les deux autres en place. La plupart des systèmes comptent donc sur l'expiration comme filet de sécurité et utilisent l'invalidation explicite pour être à jour plus tôt.

Les données périmées peuvent aussi être utiles. La RFC 5861 définit `stale-while-revalidate`, qui permet de servir une réponse périmée pendant un nombre indiqué de secondes tout en récupérant une réponse fraîche en arrière-plan, et `stale-if-error`, qui permet de continuer à servir une copie périmée si l'origine renvoie une erreur. Les deux transforment une expiration stricte en expiration souple : le visiteur reçoit immédiatement une réponse, et la mise à jour suit.

## À quoi cela ressemble en pratique

De nombreux utilisateurs d'une plateforme sont des marins et du personnel de terrain en mer, sur téléphone et souvent hors ligne. Pour eux, la mise en cache a rendu l'application Web installable et utilisable en mer. Le service worker est configuré par next-pwa. Le cache d'exécution de Workbox sert polices, images, audio, vidéo et ressources CDN en donnant la priorité au cache : depuis l'appareil lorsqu'une copie existe, depuis le réseau seulement sinon. Ce sont des fichiers qui restent identiques d'une requête à l'autre, accompagnés d'en-têtes HTTP de contrôle du cache. Les service workers nécessitant HTTPS, l'installation et le fonctionnement hors ligne ont été testés en HTTPS sur de véritables appareils. Le résultat est une application qui s'installe, continue à fonctionner hors ligne et se recharge depuis le cache plutôt que depuis le réseau lors des visites suivantes. Une règle donnant la priorité au cache ne vérifie pas du tout la fraîcheur tant qu'une entrée existe. C'est pourquoi elle convient aux fichiers dont le contenu est lié à l'adresse.

À l'autre bout d'un système se trouve une base PostgreSQL rendue dix fois plus rapide, contenant utilisateurs, organisations clientes, données géographiques et relevés électriques quotidiens. La mise en cache était une mesure parmi plusieurs. En parallèle d'index ciblés — GiST pour les requêtes spatiales et composites pour les filtres sur l'organisation cliente et la date — et du partitionnement temporel de la table de relevés électriques, certains résultats de requête ont été conservés comme vues matérialisées. La mise en cache des requêtes et un pool de connexions ont aussi été mis en place pour réduire la surcharge. Les temps de réponse se sont améliorés d'un facteur 10, les opérations critiques s'exécutaient en millisecondes et l'utilisation des ressources a baissé de 40 %. Ces gains résultent de l'ensemble du travail : la contribution de la mise en cache n'est donc pas mesurée séparément.

## Où les problèmes surviennent

Après un déploiement, certains visiteurs reçoivent encore l'ancienne version. La réponse ne précisait pas de durée de fraîcheur, et les caches en ont donc estimé une. La RFC 9111 les autorise à utiliser une fraction du temps écoulé depuis `Last-Modified` et cite 10 % comme valeur habituelle. Un fichier modifié pour la dernière fois un mois auparavant peut donc être réutilisé environ trois jours sans vérification. Envoyez un `Cache-Control` explicite pour chaque réponse, placez un hachage du contenu dans les noms des fichiers statiques et donnez une durée de vie courte au HTML qui les désigne.

Une purge vide le CDN, et les navigateurs gardent l'ancienne copie. Une purge retire la copie du CDN et rien d'autre. Chaque navigateur ayant stocké la réponse la conserve jusqu'à l'expiration de sa propre durée de vie. Donnez aux réponses publiques un `max-age` court pour les navigateurs et un `s-maxage` plus long, appliqué seulement par les caches partagés. La copie qui peut être purgée est ainsi celle qui vit le plus longtemps. Lorsqu'une copie du navigateur doit changer immédiatement, changez l'URL.

Une page brièvement absente le reste. La RFC 9110 rend une réponse 404 susceptible d'être mise en cache de façon heuristique. Un cache peut donc conserver une telle réponse sans information de fraîcheur pendant une durée qu'il estime lui-même. Un lien suivi juste avant la publication d'une page peut continuer à renvoyer 404 après sa création. Donnez aux réponses d'erreur une durée de vie courte explicite et purgez l'URL à la mise en ligne de la page.

Une ancienne valeur est réinscrite après une mise à jour. Avec cache-aside, un lecteur ne trouve rien dans le cache et lit la ligne. Avant qu'il stocke la valeur, un processus d'écriture actualise la ligne et supprime l'entrée. Le lecteur stocke ensuite ce qu'il avait lu, et l'ancienne valeur reste jusqu'à sa suppression. Supprimez l'entrée après la validation de la transaction et donnez un TTL à chaque entrée, pour qu'une valeur périmée finisse par expirer même si une invalidation a été manquée ou perturbée par une exécution concurrente. Dans Redis, un simple `SET` supprime toute expiration antérieure. Fixez donc le TTL dans la même commande :

```text
SET price:42 "19.90" EX 300
```

## Pour aller plus loin
* RFC 9111, section 3 : stockage des réponses dans les caches — les conditions de stockage d'une réponse, puis les règles de fraîcheur, de revalidation et d'invalidation.
* RFC 9110, section 13 : requêtes conditionnelles — `ETag`, `If-None-Match` et la réponse 304 qui rendent la revalidation peu coûteuse.
* RFC 5861 : extensions HTTP de Cache-Control pour le contenu périmé — les deux directives permettant de servir volontairement des réponses périmées.
* RFC 8246 : réponses HTTP immuables — la directive `immutable` pour les fichiers dont l'URL change avec le contenu.
* Workbox : stratégies de mise en cache — priorité au cache, priorité au réseau et stale-while-revalidate dans un service worker, avec du code.
* PostgreSQL : vues matérialisées — conserver un résultat de requête dans la base et l'actualiser à la demande.

=> /fr/portfolio/delivered-full-progressive-web-app-support/ la mise en cache a rendu l'application Web installable et utilisable en mer
=> /fr/portfolio/accelerated-postgresql-performance-by-10x/ une base PostgreSQL rendue dix fois plus rapide
=> https://www.rfc-editor.org/rfc/rfc9111#section-3 RFC 9111, section 3 : stockage des réponses dans les caches
=> https://www.rfc-editor.org/rfc/rfc9110#section-13 RFC 9110, section 13 : requêtes conditionnelles
=> https://www.rfc-editor.org/rfc/rfc5861 RFC 5861 : extensions HTTP de Cache-Control pour le contenu périmé
=> https://www.rfc-editor.org/rfc/rfc8246 RFC 8246 : réponses HTTP immuables
=> https://developer.chrome.com/docs/workbox/caching-strategies-overview Workbox : stratégies de mise en cache
=> https://www.postgresql.org/docs/current/rules-materializedviews.html PostgreSQL : vues matérialisées

=> https://engineer.company/fr/glossary/caching/ Cette page sur le Web
