Mise en cache en TypeScript : Redis, Memcached et solutions intégrées

Mise en cache en TypeScript : Redis, Memcached et solutions intégrées

Les applications web modernes en TypeScript nécessitent une vitesse de réponse élevée et une gestion efficace des ressources. L'un des outils clés pour atteindre cet objectif est la mise en cache. Dans cet article, nous allons détailler trois approches principales de mise en cache dans l'écosystème TypeScript/Node.js : l'utilisation de Redis, Memcached et des solutions intégrées (in-memory cache). Vous apprendrez comment choisir l'outil adapté à votre tâche et verrez des exemples de code fonctionnels.

Pourquoi la mise en cache en TypeScript ?

La mise en cache permet de stocker temporairement les données fréquemment demandées dans un stockage rapide afin de réduire le temps de réponse et de diminuer la charge sur les bases de données ou les API externes. En TypeScript, fonctionnant sur Node.js, la mise en cache est particulièrement utile pour :

• Accélérer les requêtes répétitives à la base de données ;
• Réduire les latences lors de l'accès aux services externes ;
• Optimiser les opérations coûteuses en calcul ;
• Gérer les sessions utilisateur.

Examinons les trois principaux types de mise en cache disponibles pour un développeur TypeScript.

1. Mise en cache intégrée (In-Memory Cache)

La méthode la plus simple et la plus rapide consiste à stocker les données dans la mémoire du processus Node.js lui-même. Pour cela, vous pouvez utiliser Map ou des bibliothèques plus avancées comme node-cache.

Avantages :

• Vitesse maximale (absence d'appels réseau) ;
• Simplicité de mise en œuvre ;
• Ne nécessite pas l'installation de services externes.

Inconvénients :

• Les données sont perdues lors du redémarrage de l'application ;
• Limitation par la quantité de mémoire vive d'un seul processus ;
• Ne fonctionne pas en mode cluster (chaque processus a son propre cache).

Exemple avec node-cache

Installez la bibliothèque :

npm install node-cache

Implémentation d'un service de cache simple :

import NodeCache from 'node-cache';

class MemoryCacheService {  private cache: NodeCache;

  constructor(ttlSeconds: number = 600) {    this.cache = new NodeCache({ stdTTL: ttlSeconds, checkperiod: 120 });  }

  public get<T>(key: string): T | undefined {    return this.cache.get<T>(key);  }

  public set<T>(key: string, value: T, ttl?: number): boolean {    return this.cache.set(key, value, ttl);  }

  public has(key: string): boolean {    return this.cache.has(key);  }

  public del(key: string): number {    return this.cache.del(key);  }

  public flush(): void {    this.cache.flushAll();  }}

// Utilisationconst cacheService = new MemoryCacheService(300); // TTL = 5 minutes

async function getData(id: string): Promise<any> {  const cached = cacheService.get<any>(`data:${id}`);  if (cached) {    return cached;  }

  // Simulation d'une opération coûteuse  const data = await fetchFromDatabase(id);  cacheService.set(`data:${id}`, data);  return data;}

2. Mise en cache avec Redis

Redis est un puissant stockage de données en mémoire souvent utilisé comme cache. Il prend en charge des structures de données complexes (chaînes, hachages, listes, ensembles) et peut fonctionner en mode cluster.

Avantages :

• Persistance (optionnelle) ;
• Prise en charge de structures de données complexes (par exemple, les ensembles triés) ;
• Mécanismes TTL (Time-To-Live) intégrés ;
• Excellentes performances (jusqu'à 100 000 opérations/s) ;
• Prise en charge de Pub/Sub pour l'échange de messages.

Inconvénients :

• Nécessite l'installation et la configuration d'un serveur séparé ;
• Utilise plus de mémoire que les solutions intégrées ;
• Latences réseau (bien que minimes).

Exemple de travail avec Redis en TypeScript