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

Introduction : Pourquoi la mise en cache est cruciale pour les applications TypeScript

Les applications web modernes en TypeScript sont confrontées à des charges croissantes et à des exigences de rapidité de réponse. La mise en cache n'est pas simplement une option, mais une nécessité pour toute application de niveau production. Sans elle, chaque requête vers une base de données ou une API externe se transforme en une opération coûteuse, augmentant le temps de réponse de 10 à 100 fois.

Dans cet article, nous allons détailler trois approches principales de mise en cache en TypeScript : Redis — un cache distribué, Memcached — une alternative légère, et les solutions intégrées (cache en mémoire). Vous apprendrez comment choisir l'outil approprié et le mettre en œuvre avec des exemples de code.

1. Mise en cache intégrée : Cache en mémoire (In-Memory Cache) en TypeScript

La méthode la plus simple et la plus rapide consiste à stocker les données directement dans la mémoire vive du processus. Pour TypeScript/Node.js, cela est parfaitement adapté aux applications monolithiques ou aux microservices avec une seule instance.

Implémentation d'un cache en mémoire simple

Créons une classe SimpleCache avec prise en charge du TTL (durée de vie) :

interface CacheEntry<T> {
  value: T;
  expiresAt: number;
}

class SimpleCache<T> {
  private store = new Map<string, CacheEntry<T>>();
  private defaultTTL: number; // en millisecondes

  constructor(defaultTTL: number = 60000) {
    this.defaultTTL = defaultTTL;
  }

  set(key: string, value: T, ttl?: number): void {
    const expiresAt = Date.now() + (ttl ?? this.defaultTTL);
    this.store.set(key, { value, expiresAt });
  }

  get(key: string): T | null {
    const entry = this.store.get(key);
    if (!entry) return null;
    if (Date.now() > entry.expiresAt) {
      this.store.delete(key);
      return null;
    }
    return entry.value;
  }

  has(key: string): boolean {
    return this.get(key) !== null;
  }

  delete(key: string): void {
    this.store.delete(key);
  }

  clear(): void {
    this.store.clear();
  }
}

// Exemple d'utilisation
const userCache = new SimpleCache<User>(30000); // TTL 30 secondes
userCache.set('user:123', { id: 123, name: 'Anna' });
const cachedUser = userCache.get('user:123');

Avantages et inconvénients du cache en mémoire

• Avantages : vitesse maximale (nanosecondes), pas de latence réseau, simplicité d'implémentation.
• Inconvénients : les données sont perdues lors du redémarrage de l'application, limitées par la RAM d'un seul processus, ne fonctionnent pas avec la mise à l'échelle horizontale.

Quand l'utiliser : pour mettre en cache les résultats de calculs lourds, les configurations, les données statiques qui changent rarement.

2. Redis : Mise en cache distribuée pour TypeScript

Redis est le magasin de données en mémoire le plus populaire, utilisé comme cache, courtier de messages et base de données. Pour TypeScript, nous utilisons la bibliothèque ioredis.

Installation et configuration de base

npm install ioredis
npm install @types/ioredis -D

Créons un service pour travailler avec Redis :

import Redis from 'ioredis';

class RedisCacheService {
  private client: Redis;
  private defaultTTL: number;

  constructor(ttlSeconds: number = 3600) {
    this.client = new Redis({
      host: process.env.REDIS_HOST || 'localhost',
      port: Number(process.env.REDIS_PORT) || 6379,
      retryStrategy: (times) => Math.min(times * 50, 2000),
    });
    this.defaultTTL = ttlSeconds;
  }

  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
    const serialized = JSON.stringify(value);
    const ttlToUse = ttl ?? this.defaultTTL;
    await this.client.setex(key, ttlToUse, serialized);
  }

  async get<T>(key: string): Promise<T | null> {
    const data = await this.client.get(key);
    if (!data) return null;
    try {
      return
```