Redis Caching : Installer, Configurer et Optimiser pour la Production

Redis est un magasin de structures de donnees en memoire open source qui fonctionne comme base de donnees, cache, courtier de messages et moteur de streaming. Sa capacite a servir des donnees directement depuis la RAM le rend extraordinairement rapide, avec des temps de reponse typiques inferieurs a une milliseconde. Ce guide vous accompagne dans le deploiement de Redis sur Ubuntu Server, sa configuration pour les charges de travail de production, sa securisation contre les menaces courantes et la surveillance de ses performances avec les outils integres.

Prerequis

Avant de commencer, assurez-vous d’avoir :

• Ubuntu Server 20.04, 22.04 ou 24.04
• Acces terminal avec privileges sudo
• Au moins 1 Go de RAM disponible (plus pour les jeux de donnees de production)
• Familiarite basique avec la ligne de commande Linux
• Un pare-feu configure pour restreindre l’acces (consultez notre guide UFW)

Qu’est-ce que Redis ?

Redis signifie Remote Dictionary Server (Serveur de Dictionnaire Distant). Cree par Salvatore Sanfilippo en 2009, il est devenu l’un des magasins de donnees en memoire les plus largement utilises dans le monde. Contrairement aux bases de donnees traditionnelles qui lisent et ecrivent sur disque, Redis conserve l’ensemble du jeu de donnees en memoire, ce qui lui permet de delivrer une latence inferieure a une milliseconde pour les operations de lecture et d’ecriture.

Caracteristiques cles de Redis :

• Stockage en memoire — toutes les donnees resident en RAM pour une vitesse maximale
• Structures de donnees riches — supporte les chaines, hashes, listes, ensembles, ensembles tries, streams et plus encore
• Persistance optionnelle — peut ecrire les donnees sur disque pour la durabilite
• Replication — supporte l’architecture maitre-replica pour la haute disponibilite
• Operations atomiques — toutes les commandes sont executees de maniere atomique
• Messagerie Pub/Sub — systeme de publication/abonnement integre pour la communication en temps reel
• Scripting Lua — executez des scripts cote serveur pour des operations complexes

Cas d’Utilisation de Redis

Redis excelle dans les scenarios ou la vitesse est critique :

Couche de cache : Placez Redis entre votre application et la base de donnees principale pour servir les donnees frequemment demandees depuis la memoire. Cela reduit la charge de la base de donnees et ameliore considerablement les temps de reponse.

Stockage de sessions : Stockez les sessions utilisateur dans Redis au lieu de magasins bases sur disque. Cela permet le partage de sessions entre plusieurs serveurs d’application et fournit un acces rapide en lecture/ecriture.

Files de messages : Utilisez les listes ou streams Redis comme files de messages legeres pour le traitement asynchrone des taches. Les workers peuvent consommer les messages de maniere fiable en utilisant des pops bloquants ou des groupes de consommateurs.

Messagerie Pub/Sub : Diffusez des evenements en temps reel a plusieurs abonnes. Courant pour les applications de chat, les notifications en direct et les tableaux de bord en temps reel.

Limitation de debit : Implementez la limitation de debit d’API en utilisant les compteurs Redis avec expiration automatique. Les fonctionnalites d’increment atomique et de TTL rendent cela simple.

Classements et rankings : Les ensembles tries fournissent un support naturel pour les donnees classees avec insertion et recuperation O(log N) par score.

Installation de Redis sur Ubuntu

L’approche recommandee est d’installer Redis depuis le depot APT officiel pour obtenir la derniere version stable.

Ajouter le Depot Officiel de Redis

sudo apt update
sudo apt install -y lsb-release curl gpg
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
sudo apt update

Installer Redis

sudo apt install -y redis-server

Verifier l’Installation

redis-cli ping

Vous devriez recevoir :

PONG

Verifiez la version installee :

redis-server --version

Verifiez l’etat du service :

sudo systemctl status redis-server

Activez Redis pour demarrer au boot :

sudo systemctl enable redis-server

Bases de Configuration

Le fichier principal de configuration de Redis se trouve dans /etc/redis/redis.conf. Avant d’apporter des modifications, creez une sauvegarde :

sudo cp /etc/redis/redis.conf /etc/redis/redis.conf.backup

Ouvrez le fichier de configuration :

sudo nano /etc/redis/redis.conf

Liaison Reseau

Par defaut, Redis se lie a 127.0.0.1 (localhost uniquement). Pour une couche de cache accedee par des applications locales, c’est le parametre le plus sur :

bind 127.0.0.1 ::1

Si des clients distants ont besoin d’acces, ajoutez l’IP privee du serveur :

bind 127.0.0.1 192.168.1.100

Avertissement : Ne liez jamais Redis a 0.0.0.0 sur un serveur expose au public sans authentification adequate et regles de pare-feu. Les instances Redis exposees sont une cible frequente des attaques automatisees.

Configuration du Port

Le port par defaut est 6379. Changez-le si vous souhaitez reduire le scanning automatise :

port 6379

Memoire Maximale

Definissez une limite de memoire stricte pour empecher Redis de consommer toute la RAM du systeme :

maxmemory 256mb

Ajustez cette valeur en fonction de la memoire disponible de votre serveur. Une regle courante est de ne pas allouer plus de 75% de la RAM totale a Redis s’il constitue la charge de travail principale sur le serveur.

Politiques d’Eviction

Lorsque Redis atteint la limite de maxmemory, il utilise une politique d’eviction pour decider quelles cles supprimer. Definissez la politique avec :

maxmemory-policy allkeys-lru

Politiques d’eviction disponibles :

Politique	Description
noeviction	Retourne des erreurs lorsque la limite de memoire est atteinte (par defaut)
allkeys-lru	Evince les cles les moins recemment utilisees de toutes les cles
allkeys-lfu	Evince les cles les moins frequemment utilisees de toutes les cles
volatile-lru	Evince les cles les moins recemment utilisees ayant une expiration definie
volatile-lfu	Evince les cles les moins frequemment utilisees ayant une expiration definie
allkeys-random	Evince des cles aleatoires de toutes les cles
volatile-random	Evince des cles aleatoires ayant une expiration definie
volatile-ttl	Evince les cles avec le temps d’expiration le plus proche

Pour un cache a usage general, allkeys-lru est le choix le plus courant. Pour les charges de travail ou la frequence d’acces importe plus que la recence, utilisez allkeys-lfu.

Apres avoir modifie la configuration, redemarrez Redis :

sudo systemctl restart redis-server

Options de Persistance

Redis fournit deux mecanismes pour persister les donnees sur disque.

Instantanes RDB

RDB cree des instantanes ponctuels a des intervalles configures. Ceci est active par defaut :

save 3600 1 300 100 60 10000

Cela signifie :

• Sauvegarder si au moins 1 cle a change en 3600 secondes (1 heure)
• Sauvegarder si au moins 100 cles ont change en 300 secondes (5 minutes)
• Sauvegarder si au moins 10000 cles ont change en 60 secondes (1 minute)

Le fichier d’instantane est stocke dans :

dbfilename dump.rdb
dir /var/lib/redis

Avantages du RDB :

• Representation compacte en un seul fichier de vos donnees
• Parfait pour les sauvegardes et la reprise apres sinistre
• Impact minimal sur les performances pendant les operations normales
• Redemarrages plus rapides par rapport a AOF

Inconvenients du RDB :

• Perte de donnees entre les instantanes (jusqu’a plusieurs minutes)
• L’operation de fork peut etre lente sur de grands jeux de donnees

AOF (Append Only File)

AOF enregistre chaque operation d’ecriture pour une meilleure durabilite :

appendonly yes
appendfilename "appendonly.aof"

Configurez la politique de synchronisation :

# appendfsync always   # Synchroniser apres chaque ecriture (plus sur, plus lent)
appendfsync everysec    # Synchroniser une fois par seconde (recommande)
# appendfsync no        # Laisser l'OS gerer la synchronisation (plus rapide, moins sur)

Avantages de AOF :

• Meilleure durabilite (au maximum 1 seconde de perte de donnees avec everysec)
• Le format append-only est resistant a la corruption
• Se reecrit automatiquement pour compacter le journal

Inconvenients de AOF :

• Taille de fichier plus importante par rapport a RDB
• Redemarrages plus lents pour les grands jeux de donnees

Utiliser les Deux

Pour une securite maximale des donnees, activez a la fois RDB et AOF :

save 3600 1 300 100 60 10000
appendonly yes
appendfsync everysec

Lorsque les deux sont actives, Redis utilise le fichier AOF pour restaurer les donnees au demarrage car il est typiquement plus complet.

Renforcement de la Securite

Une instance Redis non securisee represente un risque de securite significatif. Appliquez les mesures suivantes pour les deploiements en production.

Definir un Mot de Passe

Configurez l’authentification avec un mot de passe fort :

requirepass votre-mot-de-passe-tres-fort-ici

Les clients doivent s’authentifier avant d’executer des commandes :

redis-cli
AUTH votre-mot-de-passe-tres-fort-ici

Ou connectez-vous avec le mot de passe en ligne :

redis-cli -a votre-mot-de-passe-tres-fort-ici

Renommer les Commandes Dangereuses

Desactivez ou renommez les commandes qui pourraient causer des dommages :

rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command DEBUG ""
rename-command CONFIG "ADMIN_CONFIG_b4f8e2a1"

Definir une commande a une chaine vide "" la desactive completement. La renommer en une longue chaine aleatoire la rend accessible uniquement aux administrateurs qui connaissent le nouveau nom.

Restreindre l’Acces Reseau

Liez toujours Redis a des interfaces specifiques et utilisez un pare-feu :

bind 127.0.0.1 192.168.1.100
protected-mode yes

Ajoutez une regle UFW pour restreindre l’acces a Redis :

sudo ufw allow from 192.168.1.0/24 to any port 6379

Activer TLS (Redis 6+)

Pour les connexions chiffrees, configurez TLS :

tls-port 6380
port 0
tls-cert-file /etc/redis/tls/redis.crt
tls-key-file /etc/redis/tls/redis.key
tls-ca-cert-file /etc/redis/tls/ca.crt

Generez des certificats pour les tests :

sudo mkdir -p /etc/redis/tls
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /etc/redis/tls/redis.key \
  -out /etc/redis/tls/redis.crt \
  -subj "/CN=redis-server"
sudo cp /etc/redis/tls/redis.crt /etc/redis/tls/ca.crt
sudo chown redis:redis /etc/redis/tls/*

Connectez-vous avec TLS :

redis-cli --tls --cert /etc/redis/tls/redis.crt --key /etc/redis/tls/redis.key --cacert /etc/redis/tls/ca.crt -p 6380

Desactiver l’Utilisateur par Defaut (ACLs Redis 6+)

Redis 6 a introduit les Listes de Controle d’Acces pour des permissions granulaires :

redis-cli
ACL SETUSER admin on >mot-de-passe-fort ~* +@all
ACL SETUSER default off

Cela cree un utilisateur admin avec acces complet et desactive l’utilisateur par defaut.

Types de Donnees et Operations

Redis supporte plusieurs structures de donnees, chacune optimisee pour des cas d’utilisation specifiques.

Chaines

Le type le plus basique. Stockez du texte, des nombres ou des donnees serialisees :

SET user:1:name "Alice"
GET user:1:name
# "Alice"

SET counter 100
INCR counter
# 101

SET session:abc123 "session_data" EX 3600
# Expire dans 3600 secondes

Hashes

Stockez des objets comme des paires champ-valeur :

HSET user:1 name "Alice" email "alice@example.com" age 30
HGET user:1 name
# "Alice"

HGETALL user:1
# 1) "name"
# 2) "Alice"
# 3) "email"
# 4) "alice@example.com"
# 5) "age"
# 6) "30"

Listes

Collections ordonnees (listes chainees) ideales pour les files d’attente :

LPUSH tasks "send_email"
LPUSH tasks "process_payment"
RPOP tasks
# "send_email"

LRANGE tasks 0 -1
# 1) "process_payment"

Ensembles

Collections non ordonnees d’elements uniques :

SADD tags:post:1 "redis" "caching" "nosql"
SMEMBERS tags:post:1
# 1) "redis"
# 2) "caching"
# 3) "nosql"

SISMEMBER tags:post:1 "redis"
# 1

Ensembles Tries

Ensembles ordonnes par un score, parfaits pour les classements :

ZADD leaderboard 100 "player1" 250 "player2" 175 "player3"
ZREVRANGE leaderboard 0 -1 WITHSCORES
# 1) "player2"
# 2) "250"
# 3) "player3"
# 4) "175"
# 5) "player1"
# 6) "100"

ZRANK leaderboard "player3"
# 1

Gestion de la Memoire et Politiques d’Eviction

La gestion efficace de la memoire est critique pour les performances et la stabilite de Redis.

Surveillance de l’Utilisation de la Memoire

redis-cli INFO memory

Metriques cles a surveiller :

Metrique	Description
used_memory	Total d’octets alloues par Redis
used_memory_human	Memoire utilisee en format lisible
used_memory_rss	Resident Set Size (RAM reelle utilisee)
used_memory_peak	Pic d’utilisation de la memoire
mem_fragmentation_ratio	Ratio de RSS a used_memory

Un mem_fragmentation_ratio significativement superieur a 1.5 indique une fragmentation de la memoire. Des valeurs inferieures a 1.0 signifient que Redis utilise le swap sur disque, ce qui degrade severement les performances.

Reduire l’Utilisation de la Memoire

Utilisez des noms de cles plus courts quand c’est pratique :

# Au lieu de
SET user:session:authentication:token:abc123 "data"

# Utilisez
SET u:s:t:abc123 "data"

Definissez un TTL sur les cles de cache pour garantir la suppression des donnees obsoletes :

SET cache:product:42 "product_data" EX 300

Utilisez des hashes pour les petits objets — Redis optimise les petits hashes avec l’encodage ziplist :

HSET user:1 name "Alice" email "alice@example.com"

Activez la liberation lazy pour eviter le blocage lors de la suppression de grandes cles :

lazyfree-lazy-eviction yes
lazyfree-lazy-expire yes
lazyfree-lazy-server-del yes

Defragmentation de la Memoire (Redis 4+)

Activez la defragmentation active pour recuperer la memoire fragmentee :

activedefrag yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10
active-defrag-threshold-upper 100

Surveillance avec redis-cli et la Commande INFO

Redis fournit plusieurs outils integres pour la surveillance.

La Commande INFO

La commande INFO retourne des informations completes sur le serveur :

redis-cli INFO

Demandez des sections specifiques :

redis-cli INFO server
redis-cli INFO memory
redis-cli INFO stats
redis-cli INFO replication
redis-cli INFO clients
redis-cli INFO keyspace

Surveillance en Temps Reel

Observez toutes les commandes traitees par Redis en temps reel :

redis-cli MONITOR

Attention : La commande MONITOR introduit une surcharge et ne devrait pas etre laissee en cours d’execution en production. Utilisez-la uniquement pour les sessions de debogage.

Journal des Requetes Lentes

Identifiez les commandes qui depassent un temps d’execution specifie :

redis-cli SLOWLOG GET 10

Configurez le seuil du slow log (en microsecondes) :

slowlog-log-slower-than 10000
slowlog-max-len 128

Cela enregistre toute commande prenant plus de 10 millisecondes.

Connexions des Clients

Listez tous les clients connectes :

redis-cli CLIENT LIST

Verifiez le nombre total de connexions :

redis-cli INFO clients

Metriques cles des clients :

connected_clients:15
blocked_clients:0
maxclients:10000

Surveillance de la Latence

Activez la surveillance de la latence et mesurez-la :

redis-cli CONFIG SET latency-monitor-threshold 100
redis-cli LATENCY LATEST
redis-cli LATENCY HISTORY event-name

Redis comme Magasin de Sessions

Redis est un excellent choix pour stocker les sessions applicatives, permettant le partage de sessions entre plusieurs serveurs.

Exemple avec Node.js et Express

const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');

const redisClient = createClient({
  url: 'redis://127.0.0.1:6379',
  password: 'your-redis-password'
});
redisClient.connect();

const app = express();

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'your-session-secret',
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: true,
    httpOnly: true,
    maxAge: 1800000 // 30 minutes
  }
}));

app.get('/', (req, res) => {
  req.session.views = (req.session.views || 0) + 1;
  res.send(`Views: ${req.session.views}`);
});

app.listen(3000, () => console.log('Server running on port 3000'));

Exemple avec Python et Flask

from flask import Flask, session
from flask_session import Session
import redis

app = Flask(__name__)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(
    host='127.0.0.1',
    port=6379,
    password='your-redis-password'
)
app.config['SESSION_PERMANENT'] = True
app.config['PERMANENT_SESSION_LIFETIME'] = 1800  # 30 minutes

Session(app)

@app.route('/')
def index():
    session['views'] = session.get('views', 0) + 1
    return f"Views: {session['views']}"

if __name__ == '__main__':
    app.run()

Reference des Commandes Essentielles de redis-cli

Commande	Description
redis-cli ping	Tester la connectivite du serveur
redis-cli INFO	Afficher les informations et statistiques du serveur
redis-cli INFO memory	Afficher les details d’utilisation de la memoire
redis-cli MONITOR	Observer toutes les commandes en temps reel
redis-cli DBSIZE	Retourner le nombre de cles dans la base de donnees actuelle
redis-cli KEYS pattern	Trouver les cles correspondant a un motif (utiliser avec prudence en production)
redis-cli SCAN 0 MATCH pattern COUNT 100	Scanner les cles iterativement (alternative sure pour la production a KEYS)
redis-cli SET key value EX seconds	Definir une cle avec expiration
redis-cli GET key	Recuperer la valeur d’une cle
redis-cli DEL key	Supprimer une ou plusieurs cles
redis-cli TTL key	Verifier le temps de vie restant d’une cle
redis-cli EXPIRE key seconds	Definir un delai d’expiration sur une cle
redis-cli FLUSHDB	Supprimer toutes les cles de la base de donnees actuelle
redis-cli SLOWLOG GET 10	Voir les 10 requetes lentes les plus recentes
redis-cli CLIENT LIST	Lister tous les clients connectes
redis-cli CONFIG GET maxmemory	Recuperer un parametre de configuration
redis-cli CONFIG SET maxmemory 512mb	Modifier un parametre de configuration a l’execution
redis-cli BGSAVE	Declencher un instantane RDB en arriere-plan
redis-cli BGREWRITEAOF	Declencher une reecriture de l’AOF
redis-cli SHUTDOWN SAVE	Arreter le serveur et sauvegarder les donnees sur disque

Depannage

Redis Ne Demarre Pas

Verifiez les journaux pour les erreurs :

sudo journalctl -u redis-server -n 50
sudo cat /var/log/redis/redis-server.log

Causes courantes :

• Erreur de syntaxe dans redis.conf — validez le fichier de configuration
• Port deja utilise — verifiez avec sudo ss -tlnp | grep 6379
• Memoire insuffisante — verifiez la RAM disponible avec free -h

Utilisation Elevee de la Memoire

redis-cli INFO memory
redis-cli MEMORY DOCTOR

Si mem_fragmentation_ratio est superieur a 1.5 :

• Activez la defragmentation active
• Redemarrez Redis pour recuperer la memoire fragmentee

Si used_memory est proche de maxmemory :

• Revisez et ajustez la politique d’eviction
• Definissez des valeurs TTL sur les cles de cache
• Augmentez la limite de maxmemory

Erreurs de Connexion Refusee

Verifiez que Redis ecoute sur l’interface attendue :

sudo ss -tlnp | grep redis

Verifiez la directive bind dans redis.conf et assurez-vous que votre pare-feu autorise les connexions :

sudo ufw status | grep 6379

Performances Lentes

Investiguez avec le slow log :

redis-cli SLOWLOG GET 25

Recherchez les grandes cles qui pourraient bloquer :

redis-cli --bigkeys

Evitez d’utiliser KEYS * en production. Utilisez SCAN a la place :

redis-cli SCAN 0 MATCH "user:*" COUNT 100

Erreurs de Persistance

Si les instantanes RDB echouent :

redis-cli INFO persistence

Recherchez rdb_last_bgsave_status:err. Corrections courantes :

• Assurez-vous que le repertoire de donnees Redis est inscriptible : sudo chown redis:redis /var/lib/redis
• Verifiez qu’il y a suffisamment d’espace disque : df -h /var/lib/redis
• Verifiez les parametres d’overcommit : sudo sysctl vm.overcommit_memory=1

Resume

Redis est un puissant magasin de donnees en memoire qui peut ameliorer considerablement les performances de votre application lorsqu’il est utilise comme couche de cache, stockage de sessions ou courtier de messages. En configurant correctement les limites de memoire, les politiques d’eviction, la persistance et les parametres de securite, vous pouvez executer Redis de maniere fiable dans des environnements de production.

Points cles :

• Installez Redis depuis le depot officiel pour obtenir la derniere version stable
• Definissez toujours maxmemory et une politique d’eviction appropriee pour prevenir la croissance inconcontrolee de la memoire
• Choisissez votre strategie de persistance en fonction des exigences de durabilite — RDB pour les instantanes periodiques, AOF pour une durabilite quasi temps reel, ou les deux
• Renforcez Redis avec l’authentification par mot de passe, les restrictions de liaison reseau et les commandes dangereuses renommees
• Surveillez les performances avec INFO, SLOWLOG et redis-cli --bigkeys pour detecter les problemes tot
• Utilisez SCAN au lieu de KEYS en production pour eviter de bloquer le serveur

Pour une configuration complete de securite serveur, consultez nos guides sur la Configuration du Pare-feu UFW et la Liste de Verification de Securite pour Serveurs Linux.