Mise en cache en TypeScript : Redis et autres outils |…

Mise en cache en TypeScript : Redis et autres outils

La mise en cache est l'une des stratégies clés pour optimiser les performances des applications web. Dans l'écosystème TypeScript et Node.js, il existe plusieurs bibliothèques puissantes permettant de gérer efficacement la mise en cache des données. Dans cet article, nous allons détailler les outils populaires, leur utilisation et les meilleures pratiques.

Pourquoi la mise en cache est-elle nécessaire ?

La mise en cache permet de stocker temporairement les données fréquemment demandées dans un stockage rapide, afin de ne pas exécuter des opérations coûteuses (requêtes à la base de données, calculs, API externes) à chaque fois. Cela réduit la charge sur le serveur et diminue le temps de réponse.

Outils principaux pour la mise en cache en TypeScript

1. Redis via la bibliothèque `ioredis`

Redis est un magasin de données en mémoire haute performance prenant en charge diverses structures de données. Pour TypeScript, le meilleur choix est ioredis — un client avec une prise en charge complète des types et des promesses.

import Redis from 'ioredis';

// Création du clientconst redis = new Redis({  host: 'localhost',  port: 6379,});

// Fonction pour la mise en cache avec TTLasync function cacheGet(key: string): Promise<string | null> {  const data = await redis.get(key);  return data;}

async function cacheSet(key: string, value: string, ttl: number = 3600): Promise<void> {  await redis.setex(key, ttl, value);}

// Exemple d'utilisationasync function getUserData(userId: string) {  const cacheKey = `user:${userId}`;  const cached = await cacheGet(cacheKey);  if (cached) {    return JSON.parse(cached);  }  // Simulation d'une requête coûteuse  const userData = { id: userId, name: 'John Doe' };  await cacheSet(cacheKey, JSON.stringify(userData), 3600);  return userData;}

2. `node-cache` — cache en mémoire pour les petits projets

node-cache est une bibliothèque simple en mémoire qui ne nécessite aucune dépendance externe. Idéale pour les prototypes et les microservices avec un volume de données réduit.

import NodeCache from 'node-cache';

const myCache = new NodeCache({ stdTTL: 600, checkperiod: 120 });

// Sauvegarde des donnéesmyCache.set('key', { data: 'value' });

// Récupération des donnéesconst value = myCache.get('key');if (value) {  console.log('Depuis le cache :', value);} else {  console.log('Cache vide, demande des données...');}

// Suppression par clémyCache.del('key');

// Vidage complet du cachemyCache.flushAll();

3. `async-cache-dedupe` — pour éviter les requêtes en double

Cette bibliothèque résout le problème de "cache stampede" (lorsque de nombreuses requêtes tentent simultanément de remplir le cache). Elle déduplique automatiquement les requêtes parallèles vers la même clé.

import { createCache } from 'async-cache-dedupe';

const cache = createCache({  ttl: 60, // durée de vie en secondes  stale: 10, // temps pendant lequel les données sont considérées comme obsolètes mais peuvent encore être servies});

// Encapsulation d'une fonction asynchroneconst getData = cache.define('getData', async (id: number) => {  // Requête coûteuse  const result = await fetch(`https://api.example.com/data/${id}`);  return result.json();});

// Utilisationconst result = await getData(42);

Stratégies d'invalidation du cache

L'une des tâches les plus complexes de la mise en cache est l'invalidation — la mise à jour des données obsolètes. Voici les principales approches :

TTL (Time-To-Live) — les données sont automatiquement supprimées après un temps défini. Méthode simple et fiable.
Invalidation paresseuse — vérification de l'actualité des données à chaque requête (par exemple, par version).
Invalidation pilotée par événements — lors de la modification des données dans la base de données, un événement est envoyé pour vider le cache correspondant.
Write-through — mise à jour du cache simultanément à l'écriture dans la base de données.