Stockage des sessions et modèles de classements
Utilisez ElastiCache pour décharger l’état des sessions HTTP de vos serveurs d’application et implémentez des classements en temps réel avec les ensembles triés de Redis.
Stockage des sessions et modèles de classements est une leçon AWS Solutions Architect gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AWS Solutions Architect, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AWS Solutions Architect comprend 4 leçons au total.
Le problème des sessions côté serveur
Les applications web traditionnelles stockent les données de session dans la mémoire du serveur. Cette approche fonctionne avec un seul serveur, mais échoue lors d’une mise à l’échelle horizontale : si la requête suivante d’un utilisateur est acheminée vers une autre instance EC2, celle-ci ne connaît pas la session de l’utilisateur, qui est alors déconnecté. Les sessions persistantes (affinité de session au niveau de l’équilibreur de charge) résolvent partiellement le problème, mais réduisent l’efficacité de l’équilibrage de charge. La solution évolutive consiste à déplacer l’état des sessions vers un stockage partagé à faible latence, accessible depuis toutes les instances, ce que fournit précisément ElastiCache Redis.
Redis pour le stockage des sessions
Stocker les sessions dans Redis vous offre : des lectures de session en moins d’une milliseconde sur tous les serveurs d’application, un TTL intégré pour l’expiration automatique des sessions, des mises à jour atomiques des sessions afin d’éviter les conditions de concurrence, ainsi que la possibilité d’invalider immédiatement une session en supprimant la clé. L’application stocke l’identifiant de session dans un cookie ; à chaque requête, elle recherche cet identifiant dans Redis afin de récupérer les données de session. Tous les serveurs d’application partagent le même Redis, de sorte que n’importe quel serveur peut traiter la requête de n’importe quel utilisateur.
# Session storage with Redis (Python Flask example)
import redis, json, uuid
from datetime import timedelta
redis_client = redis.Redis(host='prod-redis-primary', port=6379)
SESSION_TTL = int(timedelta(hours=8).total_seconds())
def create_session(user_id):
session_id = str(uuid.uuid4())
session_data = {'user_id': user_id, 'logged_in': True}
redis_client.setex(f'session:{session_id}', SESSION_TTL, json.dumps(session_data))
return session_id
def get_session(session_id):
data = redis_client.get(f'session:{session_id}')
return json.loads(data) if data else NoneTTL des sessions et expiration glissante
Un TTL fixe signifie que la session expire N secondes après sa création, quelle que soit l’activité. Un TTL glissant (qui prolonge l’expiration à chaque accès) est plus convivial : la session expire N secondes après le dernier accès. Dans Redis, implémentez un TTL glissant en appelant EXPIRE (ou EXPIREAT) sur la clé de session après chaque lecture réussie de la session afin de réinitialiser le compte à rebours de l’expiration. Les utilisateurs actifs ne sont ainsi jamais déconnectés de manière inattendue, tandis que les sessions inactives expirent automatiquement et libèrent de la mémoire.
# Sliding TTL session implementation
def get_session_with_sliding_ttl(session_id, redis_client, ttl_seconds=1800):
session_key = f'session:{session_id}'
# Pipeline: GET + EXPIRE in one round trip
pipe = redis_client.pipeline()
pipe.get(session_key)
pipe.expire(session_key, ttl_seconds) # Reset TTL on access
results = pipe.execute()
data = results[0]
if data:
return json.loads(data)
return None # Session expired or not foundPanier d’achat dans Redis
Un panier d’achat de commerce électronique se prête naturellement à Redis. Chaque panier est stocké sous la forme d’un Hash Redis, où le champ correspond au SKU du produit et la valeur à la quantité. Des opérations sur les hachages comme HINCRBY et HDEL permettent d’effectuer des mises à jour atomiques sans récupérer puis réécrire l’intégralité du panier. Associé à un TTL (pour faire expirer les paniers abandonnés après 24 heures), Redis fournit un stockage de panier rapide et persistant, sans les coûts liés à l’utilisation d’une base de données relationnelle pour chaque ajout au panier.
# Shopping cart operations using Redis Hash
cart_key = f'cart:{user_id}'
# Add item (or increase quantity)
# HINCRBY cart:user42 SKU-001 2
redis_client.hincrby(cart_key, 'SKU-001', 2)
# Remove item
# HDEL cart:user42 SKU-001
redis_client.hdel(cart_key, 'SKU-001')
# Get all items in cart
# HGETALL cart:user42
cart = redis_client.hgetall(cart_key) # {b'SKU-001': b'2', b'SKU-002': b'1'}
# Set TTL for cart abandonment (24 hours)
redis_client.expire(cart_key, 86400)Architecture d’un classement
Un classement en temps réel est un cas d’utilisation classique de Redis, rendu possible par les ensembles triés (ZSETs). Chaque entrée de joueur possède un score ; l’ensemble trié maintient en permanence les membres dans l’ordre croissant des scores. Les requêtes de classement (les N meilleurs joueurs, le rang d’un joueur, les joueurs dans une plage de scores) s’exécutent en O(log n) ou O(log n + m) — elles sont extrêmement rapides, même avec des millions de joueurs. Les ensembles triés Redis constituent la base de nombreuses fonctionnalités de classement dans les jeux, le fitness et les réseaux sociaux, sans nécessiter de requête complexe dans une base de données ni de recalculer le rang à chaque affichage de page.
# Real-time leaderboard with Redis Sorted Set
# Add or update a player's score
# ZADD game:weekly:leaderboard 15750 'player:alice'
redis_client.zadd('game:weekly:leaderboard', {'player:alice': 15750})
# Increment score (atomic)
# ZINCRBY game:weekly:leaderboard 500 'player:alice'
redis_client.zincrby('game:weekly:leaderboard', 500, 'player:alice')
# Get top 10 players (highest scores first)
# ZREVRANGE game:weekly:leaderboard 0 9 WITHSCORES
top_10 = redis_client.zrevrange('game:weekly:leaderboard', 0, 9, withscores=True)Rang d’un joueur et joueurs à proximité
Deux fonctionnalités courantes d’un classement, au-delà de « afficher les 10 premiers », sont afficher le rang d’un joueur et afficher les joueurs proches d’un joueur donné. Ces deux fonctionnalités sont triviales avec les ensembles triés Redis. ZREVRANK renvoie le rang d’un joueur, indexé à partir de 0, dans l’ordre décroissant des scores. Pour afficher 5 joueurs au-dessus et au-dessous d’un joueur, récupérez son rang, puis utilisez ZREVRANGE du rang-5 au rang+5. Vous obtenez ainsi une vue personnalisée du classement avec deux commandes Redis seulement, sans avoir besoin de fonctions de fenêtrage SQL complexes.
# Get Alice's rank (0-indexed, so add 1 for display)
# ZREVRANK game:weekly:leaderboard 'player:alice'
rank = redis_client.zrevrank('game:weekly:leaderboard', 'player:alice')
print(f'Alice is rank #{rank + 1}')
# Get 5 players above and below Alice
start = max(0, rank - 5)
end = rank + 5
nearby = redis_client.zrevrange(
'game:weekly:leaderboard', start, end, withscores=True
)
print('Players near Alice:', nearby)Limitation du débit avec Redis
La limitation du débit (qui consiste à restreindre le nombre de requêtes qu’un client peut effectuer pendant une période donnée) est un autre cas d’utilisation particulièrement intéressant de Redis. L’algorithme de fenêtre glissante utilise un ensemble trié dont chaque membre est l’horodatage d’une requête. Pour chaque requête : supprimez les membres antérieurs à la fenêtre, comptez les membres restants, rejetez la requête si le nombre dépasse la limite, puis ajoutez le nouvel horodatage. Cette méthode met en œuvre une limitation précise par fenêtre glissante, avec une résolution à la milliseconde — bien plus exacte que les compteurs à fenêtre fixe et sans la surcharge d’une base de données.
# Sliding window rate limiter (100 requests per 60 seconds)
import time
def is_rate_limited(user_id, redis_client, limit=100, window_seconds=60):
key = f'ratelimit:{user_id}'
now = time.time()
window_start = now - window_seconds
pipe = redis_client.pipeline()
pipe.zremrangebyscore(key, '-inf', window_start) # Remove old
pipe.zcard(key) # Count current
pipe.zadd(key, {str(now): now}) # Add this request
pipe.expire(key, window_seconds)
results = pipe.execute()
request_count = results[1]
return request_count >= limit # True = rate limitedVerrouillage distribué avec Redis
Les verrous distribués coordonnent l’accès exclusif à une ressource partagée entre plusieurs serveurs d’application. La commande Redis SET key value NX EX ttl fournit une acquisition atomique du verrou : elle définit la clé uniquement si celle-ci n’existe pas (NX = Not eXists) et définit une durée de vie (TTL) afin d’éviter les interblocages si le détenteur tombe en panne. Lorsque l’opération est terminée, le détenteur supprime la clé. L’algorithme Redlock (qui utilise plusieurs nœuds Redis pour obtenir un quorum) fournit un verrou distribué plus robuste, au prix d’une complexité accrue. Pour la plupart des cas d’utilisation, le verrou d’un seul nœud Redis suffit.
# Distributed lock with Redis SET NX EX
import uuid
def acquire_lock(redis_client, resource, ttl_seconds=30):
lock_id = str(uuid.uuid4()) # Unique ID to identify this lock holder
key = f'lock:{resource}'
acquired = redis_client.set(key, lock_id, nx=True, ex=ttl_seconds)
return lock_id if acquired else None
def release_lock(redis_client, resource, lock_id):
key = f'lock:{resource}'
# Only delete if we still own the lock (Lua script for atomicity)
lua = 'if redis.call("get",KEYS[1])==ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end'
redis_client.eval(lua, 1, key, lock_id)Stockage des sessions : ElastiCache ou DynamoDB
ElastiCache Redis et DynamoDB peuvent tous deux stocker des données de session, mais leurs compromis sont différents. ElastiCache Redis : latence de l’ordre de la microseconde, stockage en mémoire (volatile sauf si la persistance est activée), modèle de données plus simple, VPC requis. DynamoDB : latence de quelques millisecondes (DAX peut égaler Redis), service entièrement géré sans cluster à maintenir, données durables par défaut, accès mondial avec les tables globales, architecture sans serveur avec capacité à la demande. Pour l’examen SAA-C03 : si la question met l’accent sur une latence de l’ordre de la microseconde ou des opérations complexes en mémoire, choisissez Redis. Si elle insiste sur la durabilité, l’architecture sans serveur ou l’échelle mondiale, envisagez DynamoDB.
Indexation géospatiale avec Redis
Redis possède un type de données géospatiales intégré (commandes GEO) qui stocke des coordonnées de latitude et de longitude et permet d’effectuer des requêtes de proximité. Avec GEOADD, GEODIST et GEORADIUS (désormais GEOSEARCH dans Redis 6.2), vous pouvez trouver tous les emplacements situés dans un rayon donné autour d’un point, en O(n + log n). Cas d’utilisation : trouver les chauffeurs à proximité (covoiturage), trouver les restaurants dans un rayon de 5 km, trier les résultats de recherche par distance. Vous évitez ainsi une base de données géospatiale distincte et conservez une vitesse de requête adaptée au stockage en mémoire.
# Store driver locations
# GEOADD drivers 13.361389 38.115556 'driver:001'
# GEOADD drivers 15.087269 37.502669 'driver:002'
# Find all drivers within 10 km of a point
# GEOSEARCH drivers FROMLONLAT 13.5 38.1 BYRADIUS 10 km ASC COUNT 5 WITHCOORD
# Result: sorted list of driver IDs within 10 km with coordinatesHyperLogLog pour compter les visiteurs uniques
Un HyperLogLog est une structure de données probabiliste qui estime le nombre d’éléments uniques d’un ensemble en utilisant une quantité fixe de mémoire (12 Ko dans Redis), quel que soit le nombre d’éléments uniques ajoutés. Il fournit une erreur standard d’environ 0,81 %. Utilisez PFADD pour ajouter des éléments et PFCOUNT pour obtenir l’estimation. Cette structure convient parfaitement pour compter les utilisateurs actifs uniques par jour, les consultations uniques de pages ou les adresses IP uniques lorsque le décompte exact n’est pas nécessaire et que l’efficacité mémoire est importante. Le stockage de millions d’identifiants utilisateur uniques dans un Set Redis consommerait des Go ; HyperLogLog utilise 12 Ko.
# Count unique daily visitors using HyperLogLog
date = '2024-01-15'
hll_key = f'unique_visitors:{date}'
# Track a visitor (PFADD is idempotent for the same user)
# PFADD unique_visitors:2024-01-15 'user:12345'
redis_client.pfadd(hll_key, 'user:12345')
redis_client.pfadd(hll_key, 'user:67890')
redis_client.pfadd(hll_key, 'user:12345') # Duplicate — not counted again
# Get estimated unique visitor count
# PFCOUNT unique_visitors:2024-01-15
count = redis_client.pfcount(hll_key)
print(f'Unique visitors today (estimate): {count}')Vérification rapide
Vérifiez votre compréhension des concepts AWS Solutions Architect (SAA-C03) abordés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que : le stockage des sessions Redis permet une mise à l’échelle horizontale sans état en donnant à toutes les Instances accès à un état de session partagé, avec une latence inférieure à la milliseconde ; les ensembles triés Redis alimentent les classements en temps réel avec des requêtes de rang en O(log n) ; et les types de données Redis spécialisés (HyperLogLog pour les décomptes uniques, GEO pour la proximité, verrous distribués) résolvent efficacement des problèmes d’architecture courants. Le cours sur la mise en cache avec ElastiCache est terminé ; nous allons maintenant étudier la haute disponibilité et les architectures tolérantes aux pannes.
Apprends AWS Solutions Architect avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Stockage des sessions et modèles de classements » est-elle gratuite ?
Oui — le texte complet de « Stockage des sessions et modèles de classements » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AWS Solutions Architect, passe à CoddyKit PRO. Le cours AWS Solutions Architect comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Stockage des sessions et modèles de classements » ?
Utilisez ElastiCache pour décharger l’état des sessions HTTP de vos serveurs d’application et implémentez des classements en temps réel avec les ensembles triés de Redis. Tu pratiques AWS Solutions Architect avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AWS Solutions Architect ?
Aucune expérience préalable n'est requise. AWS Solutions Architect sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Stockage des sessions et modèles de classements » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AWS Solutions Architect ?
Oui. Chaque leçon AWS Solutions Architect inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Redis ou Memcached : choisir le moteur adapté
- Groupes de réplication Redis ElastiCache et mode cluster
- Stratégies de mise en cache : chargement différé et écriture directe
- Stockage des sessions et modèles de classements