Cloud & IT Cert Prep · Leçon

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.

Leçon 4 sur 413 étapes

Stockage des sessions et modèles de classements est une leçon Cloud & IT Cert Prep 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 Cloud & IT Cert Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Cloud & IT Cert Prep 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 None

TTL 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 found

Panier 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 limited

Verrouillage 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 coordinates

HyperLogLog 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.

Gratuit pour commencer

Apprends Cloud & IT Cert Prep 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
150
Leçons
600

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 Cloud & IT Cert Prep, passe à CoddyKit PRO. Le cours Cloud & IT Cert Prep 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 Cloud & IT Cert Prep 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 Cloud & IT Cert Prep ?

Aucune expérience préalable n'est requise. Cloud & IT Cert Prep 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 Cloud & IT Cert Prep ?

Oui. Chaque leçon Cloud & IT Cert Prep 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

  1. Redis ou Memcached : choisir le moteur adapté
  2. Groupes de réplication Redis ElastiCache et mode cluster
  3. Stratégies de mise en cache : chargement différé et écriture directe
  4. Stockage des sessions et modèles de classements
← Retour à Cloud & IT Cert Prep