Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

Mettre en cache les réponses (CacheModule)

Cette leçon accélère une API avec @nestjs/cache-manager. Les mesures réelles comparent une réponse calculée en 300 ms et la même réponse servie par le cache en quelques millisecondes. Elle couvre Cach...

0 chapitres 0 QCM Accès gratuit
Mettre en cache les réponses (CacheModule)

À propos de ce cours

Cette leçon accélère une API avec @nestjs/cache-manager. Les mesures réelles comparent une réponse calculée en 300 ms et la même réponse servie par le cache en quelques millisecondes. Elle couvre CacheInterceptor et @CacheTTL, avec des durées en millisecondes, l'invalidation après une modification, et le cache manuel avec get, set et del. Elle démontre aussi un piège : une réponse propre à un utilisateur mise en cache est servie à un autre. Enfin, Redis remplace la mémoire comme stockage : clés visibles avec redis-cli, et cache conservé après un redémarrage. Activités corrigées.

Objectifs de la leçon

  • Mettre en cache automatiquement des réponses GET.
  • Utiliser le cache manuellement et l'invalider.
  • Éviter de servir les données d'un utilisateur à un autre.
  • Partager le cache entre instances avec Redis.
Pourquoi un cache ?

Certaines réponses coûtent cher (jointures, statistiques, appel à une API externe) mais changent rarement. Les garder quelques secondes ou minutes en mémoire évite de refaire le calcul à chaque requête. La contrepartie : pendant cette durée (le TTL, time to live), le client peut recevoir une donnée qui n'est plus à jour.

npm install @nestjs/cache-manager cache-manager

Fonctionnement du cache

Si la clé est présente, le contrôleur n'est pas appelé.

📄 src/app.module.ts

import { CacheModule } from '@nestjs/cache-manager';
import { Module } from '@nestjs/common';
import { FormationsController } from './formations.controller';
import { FormationsService } from './formations.service';

@Module({
  imports: [CacheModule.register({ ttl: 5000 })],     // durée par défaut : 5 s (en millisecondes)
  controllers: [FormationsController],
  providers: [FormationsService],
})
export class AppModule {}

📄 src/formations.service.ts

import { Injectable } from '@nestjs/common';

// Simule une requête lente (grosse jointure, API externe…)
@Injectable()
export class FormationsService {
  appels = 0;
  private formations = [{ id: 1, intitule: 'Développement web' }, { id: 2, intitule: 'Réseaux' }];

  async lister() {
    this.appels++;
    await new Promise((r) => setTimeout(r, 300));
    return [...this.formations];
  }

  ajouter(intitule: string) {
    const f = { id: this.formations.length + 1, intitule };
    this.formations.push(f);
    return f;
  }
}

📄 src/formations.controller.ts

import { CACHE_MANAGER, CacheInterceptor, CacheKey, CacheTTL } from '@nestjs/cache-manager';
import { Body, Controller, Get, Headers, Inject, Post, UseInterceptors } from '@nestjs/common';
import type { Cache } from 'cache-manager';
import { FormationsService } from './formations.service';

@Controller()
export class FormationsController {
  constructor(private readonly service: FormationsService, @Inject(CACHE_MANAGER) private readonly cache: Cache) {}

  // 1. Cache automatique : la réponse est gardée sous la clé = URL
  @Get('formations')
  @UseInterceptors(CacheInterceptor)
  @CacheTTL(2000)                                   // 2 secondes (en millisecondes)
  lister() {
    return this.service.lister();
  }

  @Post('formations')
  async ajouter(@Body('intitule') intitule: string) {
    const f = this.service.ajouter(intitule);
    await this.cache.del('/api/formations');        // invalider la liste mise en cache
    return f;
  }

  // 2. Cache manuel : get / set
  @Get('statistiques')
  async statistiques() {
    const enCache = await this.cache.get<{ total: number; calculeLe: string }>('statistiques');
    if (enCache) return { ...enCache, source: 'cache' };
    const stats = { total: (await this.service.lister()).length, calculeLe: new Date().toISOString().slice(11, 19) };
    await this.cache.set('statistiques', stats, 60_000);
    return { ...stats, source: 'calcul' };
  }

  // 3. DANGER : données propres à chaque utilisateur + CacheInterceptor
  @Get('mon-profil')
  @UseInterceptors(CacheInterceptor)
  @CacheKey('mon-profil')
  profil(@Headers('x-utilisateur') moi: string) {
    return { utilisateur: moi, notes: moi === 'sami' ? [15, 12] : [9] };
  }
}
  • CacheModule.register({ ttl }): cache en mémoire, durée par défaut. Les durées sont en millisecondes (5000 = 5 s) dans les versions actuelles. Les anciens tutoriels les donnent en secondes.
  • @UseInterceptors(CacheInterceptor): met en cache les réponses des routes GET, avec l'URL comme clé. @CacheTTL change la durée pour une route, @CacheKey fixe la clé.
  • @Inject(CACHE_MANAGER) donne accès au cache : get, set(clé, valeur, ttl), del. Le type Cache s'importe avec import type.

Résultat réellement obtenu :

— 1. CacheInterceptor
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 334 ms]
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 5 ms]
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 3 ms]
   appels réels au service : 1
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 305 ms]
   après expiration (2 s), appels réels : 2
POST /api/formations → 201 {"id":3,"intitule":"Cybersécurité"}
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"},{"id":3,"intitule":"Cybersécurité"}]  [durée: 304 ms]

— 2. Cache manuel
GET /api/statistiques → 200 {"total":3,"calculeLe":"12:05:33","source":"calcul"}
GET /api/statistiques → 200 {"total":3,"calculeLe":"12:05:33","source":"cache"}

— 3. Données personnelles en cache
GET /api/mon-profil → 200 {"utilisateur":"sami","notes":[15,12]}
GET /api/mon-profil → 200 {"utilisateur":"sami","notes":[15,12]}
Lecture
  • Premier appel : 334 ms (calcul). Les deux suivants : 3 à 5 ms, et le service n'a été appelé qu'une fois.
  • Après 2 secondes (@CacheTTL(2000)), l'entrée a expiré : nouveau calcul.
  • Après l'ajout d'une formation, cache.del('/api/formations') invalide la liste : la suivante contient « Cybersécurité ». Sans cette ligne, la nouvelle formation n'apparaîtrait qu'à l'expiration du cache.
  • Le cache manuel indique sa source : calcul puis cache, avec la même heure de calcul.
  • Le piège: Ines reçoit le profil et les notes de Sami. La clé ne dépend pas de l'utilisateur, et ce serait pareil avec la clé par défaut, puisque l'URL est la même pour tous. Ne mettez jamais en cache avec CacheInterceptor une route dont la réponse dépend de l'utilisateur connecté, ou utilisez une clé qui contient son identifiant (activité 2).
Redis : un cache partagé et persistant

Le cache en mémoire disparaît au redémarrage et n'est pas partagé entre plusieurs instances. Redis, une base clé-valeur en mémoire très rapide, résout ces deux problèmes. Le cache s'appuie sur la bibliothèque Keyv : il suffit de lui donner un stockage Redis.

npm install @keyv/redis
# Redis en local : sudo apt install redis-server   ou   docker run -d -p 6379:6379 redis

📄 src/app.module.ts

import KeyvRedis from '@keyv/redis';
import { CacheModule } from '@nestjs/cache-manager';
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { FormationsController } from './formations.controller';
import { FormationsService } from './formations.service';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    CacheModule.registerAsync({
      isGlobal: true,
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        ttl: 5000,
        stores: [new KeyvRedis(config.get('REDIS_URL', 'redis://localhost:6379'), { namespace: 'api-formation' })],
      }),
    }),
  ],
  controllers: [FormationsController],
  providers: [FormationsService],
})
export class AppModule {}

Résultat réellement obtenu :

$ redis-cli FLUSHALL
OK

GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 349 ms]
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 7 ms]
GET /api/statistiques → 200 {"total":2,"calculeLe":"12:05:37","source":"calcul"}

$ redis-cli KEYS "*"
api-formation::statistiques
api-formation::/api/formations

$ redis-cli PTTL (durée restante, ms)
59908

$ relancer l'application : le cache a survécu
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 37 ms]
GET /api/formations → 200 [{"id":1,"intitule":"Développement web"},{"id":2,"intitule":"Réseaux"}]  [durée: 5 ms]
GET /api/statistiques → 200 {"total":2,"calculeLe":"12:05:37","source":"cache"}

Les clés apparaissent dans Redis, préfixées par l'espace de noms api-formation, avec leur durée restante (PTTL, en millisecondes). Après le redémarrage de l'application, la première requête est servie par le cache (37 ms au lieu de 349 ms) : le cache a survécu.

Quoi mettre en cache ? Des données lues souvent, coûteuses à calculer, identiques pour tous et qui tolèrent un léger retard : catalogue, statistiques, paramètres, résultats d'une API externe. À éviter: données personnelles, données qui doivent être exactes à la seconde (solde, places restantes), réponses d'erreur. Le cache ne remplace pas une requête optimisée (index, chapitre 11) : il vient après.

Activités

Activité 1 Mesurer

Dans le projet du TP 8, mettez en cache GET /api/groupes pendant 30 secondes (admin uniquement, réponse identique pour tous les admins). Mesurez la durée et le nombre de requêtes SQL (logging: true) sur 5 appels. Invalidez le cache à la création d'un groupe et à l'affectation d'un stagiaire.

Voir le corrigé

1er appel : requête SQL ; appels 2 à 5 : aucune requête. Invalidation : await this.cache.del('/api/groupes') dans les deux méthodes qui modifient les groupes. Attention : la liste des groupes d'un formateur dépend de l'utilisateur ; si la route sert aussi les formateurs, utilisez le cache manuel avec une clé par utilisateur (activité 2).

Activité 2 Une clé par utilisateur

Écrivez un intercepteur CacheParUtilisateurInterceptor qui étend CacheInterceptor et redéfinit trackBy(context) pour que la clé soit utilisateur:<id>:<url> (avec req.user.id du chapitre 13). Vérifiez que Sami et Ines reçoivent chacun leur profil.

Voir le corrigé
@Injectable()
export class CacheParUtilisateurInterceptor extends CacheInterceptor {
  protected trackBy(context: ExecutionContext): string | undefined {
    const req = context.switchToHttp().getRequest();
    if (req.method !== 'GET' || !req.user) return undefined;   // undefined = pas de cache
    return `utilisateur:${req.user.id}:${req.originalUrl}`;
  }
}

Inconvénient : invalider les entrées de tous les utilisateurs après une modification devient difficile (il faudrait connaître toutes les clés). On réserve ce cache à des données propres à l'utilisateur et peu sensibles au retard, avec un TTL court.

Activité 3 Vrai ou faux ?

(a) CacheInterceptor met aussi en cache les réponses des POST. (b) ttl: 60 garde les données une minute. (c) Avec deux instances et un cache en mémoire, l'invalidation faite par l'instance A vide aussi le cache de l'instance B. (d) Redis garde le cache après un redémarrage de l'application.

Voir le corrigé

(a) Faux : seules les requêtes GET. (b) Faux : 60 millisecondes. (c) Faux : chaque instance a sa propre mémoire ; B continue de servir l'ancienne donnée. C'est une raison d'utiliser Redis. (d) Vrai : le cache est dans Redis, pas dans le processus Node.js (et Redis peut lui-même être configuré pour persister sur disque).

Activité 4 Cache d'une API externe

Une route GET /api/meteo/:ville appelle une API météo payante (1 000 appels par jour maximum). Écrivez le service avec un cache manuel de 10 minutes par ville. Que renvoyer si l'API externe est en panne mais qu'une ancienne valeur existe ?

Voir le corrigé
async meteo(ville: string) {
  const cle = `meteo:${ville.toLowerCase()}`;
  const enCache = await this.cache.get<Meteo>(cle);
  if (enCache) return enCache;
  try {
    const donnees = await this.appelerApiExterne(ville);
    await this.cache.set(cle, donnees, 10 * 60_000);
    await this.cache.set(cle + ':secours', donnees, 24 * 3600_000);   // copie de secours, 24 h
    return donnees;
  } catch {
    const secours = await this.cache.get<Meteo>(cle + ':secours');
    if (secours) return { ...secours, perimee: true };
    throw new ServiceUnavailableException('Service météo indisponible');
  }
}

La copie de secours permet de répondre avec une donnée ancienne, signalée comme telle, plutôt qu'avec une erreur.

À retenir

  • CacheModule.register({ ttl }) ; durées en millisecondes.
  • CacheInterceptor (GET, clé = URL), @CacheTTL, @CacheKey ; cache manuel : get / set / del via CACHE_MANAGER.
  • Invalider après chaque modification, sinon données périmées jusqu'à l'expiration.
  • Jamais de CacheInterceptor sur une réponse propre à l'utilisateur (clé identique pour tous).
  • Redis (@keyv/redis) : cache partagé entre instances et conservé au redémarrage.

Cet article vous a-t-il aidé ?