Mise en cache en TypeScript : Redis et autres solutions pour Node.js

Mise en cache en TypeScript : Redis et autres outils pour Node.js

La mise en cache est l'un des mécanismes clés d'optimisation des performances des applications web. Dans les projets TypeScript sur Node.js, le cache permet de réduire le temps de réponse des API, de diminuer la charge sur les bases de données et de réduire les coûts des appels externes. Dans cet article, nous allons examiner les bibliothèques de mise en cache populaires, leur configuration et des exemples pratiques.

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

Sans cache, chaque requête au serveur peut entraîner un retraitement des données : lecture de la base de données, calculs complexes ou appels à des API externes. Le cache enregistre le résultat du premier appel et le renvoie pour les requêtes suivantes en quelques millisecondes. Les principaux scénarios :

• Mise en cache des réponses des services externes (météo, taux de change) ;
• Stockage des données fréquemment demandées (référentiels, configurations) ;
• Réduction du temps de rendu des pages ;
• Limitation du nombre de requêtes à la base de données.

Bibliothèques populaires pour la mise en cache en TypeScript

1. Redis (via ioredis)

Redis est un stockage de données in-memory fonctionnant comme un serveur. Pour TypeScript, le meilleur client est ioredis avec une prise en charge complète des types. Installation :

npm install ioredisnpm install -D @types/ioredis

Exemple de cache de base avec TTL (durée de vie) :

import Redis from 'ioredis';

const redis = new Redis({    host: 'localhost',    port: 6379,});

// Enregistrer les données pour 60 secondesawait redis.set('user:123', JSON.stringify({ name: 'Анна' }), 'EX', 60);

// Récupérer les donnéesconst cached = await redis.get('user:123');if (cached) {    const user = JSON.parse(cached);    console.log(user.name); // Анна}

Avantages : stockage distribué, suppression automatique des clés, prise en charge des structures complexes (listes, hachages). Inconvénients : nécessite un serveur Redis en cours d'exécution, latence due à l'appel réseau.

2. node-cache (in-memory)

node-cache est une bibliothèque simple pour la mise en cache en mémoire du processus. Elle ne nécessite pas de dépendances externes. Installation :

npm install node-cachenpm install -D @types/node-cache

Exemple :

import NodeCache from 'node-cache';

const myCache = new NodeCache({ stdTTL: 120 }); // TTL par défaut 120 sec

// EnregistrermyCache.set('config', { theme: 'dark', lang: 'ru' });

// Récupérerconst config = myCache.get('config');if (config) {    console.log(config.theme); // dark}

// SupprimermyCache.del('config');

Convient aux petites applications où la synchronisation entre serveurs n'est pas nécessaire.

3. memory-cache

Une autre bibliothèque in-memory avec une API minimaliste. Elle se distingue par sa simplicité et l'absence de dépendances :

npm install memory-cache

Exemple :

import cache from 'memory-cache';

cache.put('weather', { temp: 22, condition: 'sunny' }, 300_000); // 5 minutes

const weather = cache.get('weather');if (weather) {    console.log(`Температура: ${weather.temp}°C`);}

// Vérification de l'existence de la cléif (cache.keys().includes('weather')) {    // ...}

Stratégies de mise en cache pour TypeScript

Le choix de la stratégie dépend de la nature des données :

• Write-through — les données sont écrites simultanément dans le cache et la base de données. Garantit la cohérence, mais augmente le temps d'écriture.
• Write-behind — l'écriture dans le cache est instantanée, dans la base de données elle est asynchrone. Rapide, mais une perte de données est possible en cas de panne.
• Cache-aside — l'application vérifie elle-même le cache, en cas d'échec elle lit depuis la base de données et remplit le cache. Le modèle le plus populaire.

Implémentation de Cache-aside en TypeScript avec ioredis :

async function getUserById(id: number) {    const cacheKey = `user:${id}`;    const cached = await redis.get(cacheKey);

    if