Cache Redis pour applications web

Introduction

Redis est une base de données in-memory clé/valeur ultra rapide (souvent < 1ms par opération). Il est utilisé comme :

• Cache applicatif : réponses API, fragments HTML, requêtes SQL coûteuses
• Session store : sessions PHP/Node distribuées
• Queue / Pub-Sub : tasks asynchrones
• Rate limiting : compteurs distribués

Ce tuto se concentre sur l'usage cache qui est le plus immédiat : transformer une requête SQL de 200ms en lecture Redis de 0.5ms.

Prérequis

• VPS Linux (Debian 12 / Ubuntu 22.04+)
• 512 Mo de RAM minimum (1 Go recommandé)
• Une application web à accélérer

Étape 1 : Installation

sudo apt update
sudo apt install -y redis-server
sudo systemctl enable --now redis-server
sudo systemctl status redis-server

Testez :

redis-cli ping
# PONG

Étape 2 : Sécuriser Redis

Par défaut, Redis écoute uniquement sur 127.0.0.1 (localhost). C'est sûr si votre app est sur le même VPS. Sinon, il faut absolument mettre un mot de passe et restreindre les bind addresses.

sudo nano /etc/redis/redis.conf

Modifiez :

# Bind addresses (laisser localhost si app sur même VPS)
bind 127.0.0.1 ::1

# Mot de passe robuste
requirepass UnMotDePasseTresLong_AvecChiffres_42_ETSpecials!

# Protected mode (désactiver l'accès sans auth)
protected-mode yes

# Renommer les commandes dangereuses (optionnel mais recommandé)
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command KEYS ""
rename-command CONFIG "CONFIG_zP9aXkLm"

Redémarrez :

sudo systemctl restart redis-server

Testez avec auth :

redis-cli -a UnMotDePasseTresLong_AvecChiffres_42_ETSpecials! ping

Étape 3 : Configurer la mémoire max et la stratégie d'éviction

sudo nano /etc/redis/redis.conf

# Limite mémoire Redis (adapter selon RAM dispo)
maxmemory 1gb

# Stratégie quand la mémoire est pleine
# allkeys-lru : supprime les clés les moins récemment utilisées
maxmemory-policy allkeys-lru

Stratégies disponibles :

• noeviction : refuse les écritures quand plein (DB)
• allkeys-lru : LRU sur toutes les clés ⭐ recommandé pour du cache
• volatile-lru : LRU sur les clés avec TTL
• allkeys-random : aléatoire
• volatile-ttl : expire les clés au TTL le plus court

Étape 4 : Désactiver la persistance pour du cache pur

Si Redis sert uniquement de cache (données reconstructibles), désactivez la persistence pour gagner en perfs :

# Désactiver RDB snapshots
save ""

# Désactiver AOF
appendonly no

⚠️ Si Redis sert de session store ou contient des données critiques, gardez la persistence active (save 900 1, appendonly yes).

Étape 5 : Optimisations système pour Redis

Redis prévient à l'install :

WARNING: The TCP backlog setting of 511 cannot be enforced
WARNING: overcommit_memory is set to 0
WARNING: Transparent Huge Pages enabled

Corrigez :

sudo nano /etc/sysctl.conf

net.core.somaxconn = 1024
vm.overcommit_memory = 1

sudo sysctl -p

Désactivez Transparent Huge Pages :

echo never | sudo tee /sys/kernel/mm/transparent_hugepage/enabled

Pour persister :

sudo nano /etc/rc.local

#!/bin/bash
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag
exit 0

sudo chmod +x /etc/rc.local

Redémarrez Redis :

sudo systemctl restart redis-server

Étape 6 : Tester les performances

# Benchmark inclus
redis-benchmark -a UnMotDePasseTresLong... -q

Sortie type :

SET: 95238 req/s
GET: 103626 req/s
INCR: 102040 req/s
LPUSH: 99009 req/s

100k req/s sur un VPS standard. Comparé à MySQL (5-10k req/s sur du SELECT simple), c'est 10-20x plus rapide.

Étape 7 : Pattern Cache-Aside (le plus courant)

Voici comment l'utiliser dans une app PHP :

<?php
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->auth('UnMotDePasseTresLong...');

function getUser($id) {
    global $redis, $pdo;
    
    $cacheKey = "user:$id";
    
    // 1. Vérifier le cache
    $cached = $redis->get($cacheKey);
    if ($cached) {
        return json_decode($cached, true);
    }
    
    // 2. Cache miss : aller en DB
    $stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
    $stmt->execute([$id]);
    $user = $stmt->fetch(PDO::FETCH_ASSOC);
    
    // 3. Stocker dans le cache (TTL 1h)
    $redis->setex($cacheKey, 3600, json_encode($user));
    
    return $user;
}

// Invalider le cache lors d'un update
function updateUser($id, $data) {
    global $redis, $pdo;
    
    $stmt = $pdo->prepare("UPDATE users SET ... WHERE id = ?");
    $stmt->execute([...]);
    
    // Invalidation
    $redis->del("user:$id");
}

Étape 8 : Intégration avec WordPress

Installez le plugin Redis Object Cache :

1. Plugins → Add New → "Redis Object Cache" → Activate
2. Settings → Redis :
   • Host : 127.0.0.1
   • Port : 6379
   • Password : votre mot de passe Redis
   • Database : 0
3. Cliquez Enable Object Cache

Bénéfice typique : -50 à -70% de temps de chargement.

Étape 9 : Intégration avec Symfony

Dans config/packages/cache.yaml :

framework:
    cache:
        app: cache.adapter.redis
        default_redis_provider: 'redis://default:[email protected]:6379'

Et utilisez dans le code :

public function show(CacheInterface $cache, int $id): Response
{
    $product = $cache->get('product_' . $id, function (ItemInterface $item) use ($id) {
        $item->expiresAfter(3600);
        return $this->productRepo->find($id);
    });
    // ...
}

Étape 10 : Intégration avec Laravel

Dans .env :

CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=UnMotDePasseTresLong_AvecChiffres_42_ETSpecials!
REDIS_PORT=6379

Et :

Cache::remember('users:list', 3600, function () {
    return User::all();
});

Étape 11 : Monitorer Redis

En CLI

redis-cli -a UnMotDePasseTresLong... INFO stats
redis-cli -a UnMotDePasseTresLong... INFO memory
redis-cli -a UnMotDePasseTresLong... MONITOR  # ⚠️ trafic temps réel

En live (top-like)

sudo apt install -y redis-tools
redis-cli -a UnMotDePasseTresLong... --stat

Avec Grafana

Installez redis_exporter et créez un dashboard Redis. Voir le tuto Prometheus + Grafana.

Étape 12 : Sentinel pour la haute disponibilité

Si Redis devient critique, mettez en place Redis Sentinel (failover automatique) ou Redis Cluster (sharding + HA). Hors scope de ce tuto, mais à connaître pour les projets prod.

Dépannage

"OOM command not allowed when used memory > 'maxmemory'"

Redis a atteint sa limite mémoire. Soit augmentez maxmemory, soit vérifiez que maxmemory-policy = allkeys-lru (sinon il refuse les écritures).

Connexion refused

sudo systemctl status redis-server
sudo journalctl -u redis-server -n 50

Souvent un problème de fichier de config invalide après modif.

Persistance prend trop de temps (Redis bloque)

Sur des grosses bases (10+ Go), le snapshot RDB peut bloquer. Solutions :

• Migrer vers AOF (appendonly yes + appendfsync everysec)
• Désactiver la persistence si cache pur
• Utiliser Redis Sentinel/Cluster pour failover

Clés expirent trop vite

Vérifiez le TTL :

TTL user:42
# 3599

Pas de TTL ? setex ou expire non utilisé. Ou éviction LRU trop agressive (augmentez maxmemory).

Commandes utiles

# Connexion CLI
redis-cli -a PASSWORD

# Compter les clés
DBSIZE

# Lister les clés (DEV uniquement, lent)
KEYS *

# Scanner les clés (PROD)
SCAN 0 MATCH user:* COUNT 100

# Info détaillée
INFO

# Stats mémoire
INFO memory

# Flush DB courante (⚠️)
FLUSHDB

# Voir le TTL d'une clé
TTL ma_cle

# Set avec TTL
SETEX ma_cle 3600 "valeur"

# Liste des slow queries
SLOWLOG GET 10

Conclusion

Redis est l'outil le plus rentable pour accélérer une app. Bénéfices :

• Latence de réponse 10-100x plus basse sur les données cachées
• Charge MySQL/PostgreSQL réduite de 80-90%
• Possibilité de gérer 10x plus de trafic sans augmenter les ressources

Pour aller plus loin :

• Utilisez Redis Streams pour des queues persistantes
• Mettez en place du Pub/Sub pour communiquer entre micro-services
• Migrez vers KeyDB (fork Redis multi-thread, drop-in replacement)

Ressources

• Site officiel : https://redis.io
• Documentation : https://redis.io/docs/
• redis-cli : https://redis.io/docs/ui/cli/