Délai d'expiration et éviction du magasin de sessions Redis : résoudre les déconnexions prématurées

Pourquoi les utilisateurs sont-ils déconnectés de manière inattendue ?

Lorsque Redis est utilisé comme magasin de sessions, il peut arriver que les utilisateurs soient déconnectés prématurément. Cela se produit généralement lorsque Redis atteint sa limite de mémoire et commence à évincer des clés, y compris les clés de session actives. Par défaut, Redis utilise la politique d'éviction noeviction, qui renvoie une erreur lorsque la mémoire est pleine, mais d'autres politiques comme allkeys-lru ou volatile-lru peuvent supprimer des sessions si elles ne sont pas correctement configurées.

Comprendre les mécanismes en jeu

1. Politique d'éviction (maxmemory-policy)

Redis propose plusieurs politiques d'éviction pour gérer la mémoire lorsqu'elle atteint la limite définie par maxmemory :

• noeviction : aucune éviction, les nouvelles écritures échouent.
• allkeys-lru : évince les clés les moins récemment utilisées parmi toutes les clés.
• volatile-lru : évince les clés avec un TTL défini, en utilisant LRU.
• allkeys-random : évince des clés aléatoirement.
• volatile-random : évince aléatoirement des clés avec TTL.
• volatile-ttl : évince les clés avec le TTL le plus court.

Pour les sessions, il est recommandé d'utiliser volatile-ttl ou volatile-lru afin que seules les sessions expirées ou les moins utilisées soient évincées.

2. TTL (Time To Live)

Chaque session Redis doit avoir un TTL défini. Cela permet à Redis de supprimer automatiquement les sessions expirées. Si le TTL est trop court, les utilisateurs seront déconnectés prématurément. Si le TTL est trop long, les sessions inactives occuperont de la mémoire inutilement.

3. Délai d'inactivité (Idle Timeout)

Le délai d'inactivité est souvent géré au niveau de l'application. Il s'agit de la durée pendant laquelle une session peut rester inactive avant d'être considérée comme expirée. Ce délai doit être synchronisé avec le TTL Redis pour éviter des déconnexions inattendues.

Configuration recommandée

Étape 1 : Définir une politique d'éviction appropriée

Dans le fichier de configuration Redis (redis.conf) :

maxmemory 256mb
maxmemory-policy volatile-ttl

Cela garantit que Redis évince d'abord les sessions avec le TTL le plus court, c'est-à-dire les sessions les plus anciennes ou inactives.

Étape 2 : Configurer le TTL des sessions

Dans votre application (exemple avec Node.js et connect-redis) :

const session = require('express-session');
const RedisStore = require('connect-redis')(session);

app.use(session({
    store: new RedisStore({
        host: 'localhost',
        port: 6379,
        ttl: 86400 // 24 heures en secondes
    }),
    secret: 'votre-secret',
    resave: false,
    saveUninitialized: false,
    cookie: {
        maxAge: 86400000 // 24 heures en millisecondes
    }
}));

Étape 3 : Synchroniser les délais d'inactivité

Assurez-vous que le TTL Redis est au moins égal au délai d'inactivité de l'application. Par exemple, si votre application définit un délai d'inactivité de 30 minutes, le TTL Redis doit être d'au moins 30 minutes (1800 secondes).

Surveillance et dépannage

Vérifier l'utilisation de la mémoire Redis

redis-cli INFO memory

Voir les clés de session et leur TTL

redis-cli KEYS "sess:*"
redis-cli TTL sess:12345

Tester l'éviction

Si vous suspectez une éviction, surveillez les métriques evicted_keys :

redis-cli INFO stats | grep evicted_keys

Conclusion

Pour éviter les déconnexions prématurées des utilisateurs :

1. Utilisez une politique d'éviction qui respecte les sessions actives (volatile-ttl ou volatile-lru).
2. Définissez un TTL approprié pour les sessions, en fonction de votre délai d'inactivité.
3. Surveillez régulièrement l'utilisation de la mémoire et les évictions.

Avec ces configurations, vos sessions Redis resteront actives aussi longtemps que nécessaire, sans gaspillage de mémoire.