Sitzungsspeicherung und Leaderboard-Muster
Lagern Sie den HTTP-Sitzungsstatus mit ElastiCache von Ihren Anwendungsservern aus und implementieren Sie Echtzeit-Leaderboards mit sortierten Redis-Mengen.
Sitzungsspeicherung und Leaderboard-Muster ist eine kostenlose Cloud & IT Cert Prep-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Cloud & IT Cert Prep-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Cloud & IT Cert Prep-Kurs umfasst insgesamt 4 Lektionen.
Das Problem serverseitiger Sitzungen
Herkömmliche Webanwendungen speichern Sitzungsdaten im Arbeitsspeicher des Servers. Das funktioniert mit einem einzelnen Server, scheitert jedoch bei horizontaler Skalierung: Wenn die nächste Anfrage eines Benutzers an eine andere EC2-Instance weitergeleitet wird, kennt diese Instance die Sitzung des Benutzers nicht, und der Benutzer wird abgemeldet. Sticky Sessions (Sitzungsaffinität im Load Balancer) lösen dieses Problem teilweise, verringern jedoch die Effektivität des Load Balancing. Die skalierbare Lösung besteht darin, den Sitzungsstatus in einen gemeinsam genutzten Speicher mit niedriger Latenz zu verschieben, auf den alle Instances zugreifen können – genau das bietet ElastiCache Redis.
Redis für Sitzungsspeicher
Das Speichern von Sitzungen in Redis bietet Ihnen Folgendes: Sitzungslesevorgänge über alle Anwendungsserver hinweg in weniger als einer Millisekunde, integrierte TTLs für den automatischen Ablauf von Sitzungen, atomare Sitzungsaktualisierungen zur Vermeidung von Race Conditions sowie die Möglichkeit, eine Sitzung durch Löschen des Schlüssels sofort zu invalidieren. Die Anwendung speichert die Sitzungs-ID in einem Cookie. Bei jeder Anfrage sucht sie die Sitzungs-ID in Redis nach, um die Sitzungsdaten abzurufen. Alle Anwendungsserver verwenden dasselbe Redis, sodass jeder Server die Anfrage jedes Benutzers verarbeiten kann.
# 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 NoneSitzungs-TTL und gleitender Ablauf
Bei einer festen TTL läuft die Sitzung unabhängig von der Aktivität N Sekunden nach ihrer Erstellung ab. Eine gleitende TTL (bei der der Ablauf bei jedem Zugriff verlängert wird) ist benutzerfreundlicher: Die Sitzung läuft N Sekunden nach dem letzten Zugriff ab. Implementieren Sie eine gleitende TTL in Redis, indem Sie bei jedem erfolgreichen Lesen der Sitzung EXPIRE (oder EXPIREAT) für den Sitzungsschlüssel aufrufen, um den Ablauf-Countdown zurückzusetzen. Dadurch werden aktive Benutzer nicht unerwartet abgemeldet, während inaktive Sitzungen automatisch ablaufen und Speicher freigeben.
# 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 foundWarenkorb in Redis
Ein E-Commerce-Warenkorb eignet sich hervorragend für Redis. Jeder Warenkorb wird als Redis Hash gespeichert, wobei das Feld die Produkt-SKU und der Wert die Menge enthält. Hash-Operationen wie HINCRBY und HDEL ermöglichen atomare Aktualisierungen, ohne den gesamten Warenkorb abzurufen und neu zu schreiben. In Verbindung mit einer TTL (um verlassene Warenkörbe nach 24 Stunden ablaufen zu lassen) bietet Redis einen schnellen, beständigen Warenkorbspeicher, ohne dass für jedes Hinzufügen zum Warenkorb der Overhead einer relationalen Datenbank anfällt.
# 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)Leaderboard-Architektur
Eine Echtzeit-Rangliste ist ein klassischer Anwendungsfall für Redis, der durch Sorted Sets (ZSETs) ermöglicht wird. Jeder Spielereintrag hat einen Punktestand; das Sorted Set hält die Mitglieder jederzeit in aufsteigender Reihenfolge des Punktestands. Abfragen für Ranglisten (die besten N Spieler, der Rang eines Spielers, Spieler innerhalb eines Punktebereichs) haben eine Komplexität von O(log n) oder O(log n + m) — und sind selbst bei Millionen von Spielern extrem schnell. Redis Sorted Sets bilden die Grundlage vieler Ranglistenfunktionen für Spiele, Fitness- und soziale Anwendungen, ohne dass komplexe Datenbankabfragen oder eine Neuberechnung des Rangs bei jedem Seitenaufruf erforderlich sind.
# 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)Spielerrang und benachbarte Spieler
Zwei häufige Ranglistenfunktionen über „die besten 10 anzeigen“ hinaus sind den Rang eines Spielers anzeigen und Spieler in der Nähe eines bestimmten Spielers anzeigen. Mit Redis Sorted Sets sind beide Funktionen unkompliziert. ZREVRANK gibt den bei 0 beginnenden Rang eines Spielers in absteigender Reihenfolge des Punktestands zurück. Um 5 Spieler über und unter einem Spieler anzuzeigen, ermitteln Sie zunächst dessen Rang und verwenden dann ZREVRANGE vom Rang-5 bis zum Rang+5. Dadurch erhalten Sie mit zwei Redis-Befehlen eine personalisierte Ranglistenansicht — komplexe SQL-Fensterfunktionen sind nicht erforderlich.
# 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)Ratenbegrenzung mit Redis
Ratenbegrenzung (die Beschränkung, wie viele Anfragen ein Client innerhalb eines Zeitfensters stellen darf) ist ein weiterer wertvoller Anwendungsfall für Redis. Der Sliding-Window-Algorithmus verwendet ein Sorted Set, in dem jedes Mitglied einen Anfragezeitstempel darstellt. Bei jeder Anfrage werden Mitglieder entfernt, die älter als das Zeitfenster sind, die verbleibenden Mitglieder gezählt, die Anfrage abgelehnt, wenn die Anzahl das Limit überschreitet, und ein neuer Zeitstempel hinzugefügt. Damit lässt sich eine präzise Ratenbegrenzung mit Sliding Window und Millisekundenauflösung implementieren — deutlich genauer als Zähler mit festen Zeitfenstern und ohne den Overhead einer Datenbank.
# 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 limitedVerteilte Sperren mit Redis
Verteilte Sperren koordinieren den exklusiven Zugriff auf eine gemeinsam genutzte Ressource über mehrere Anwendungsserver hinweg. Der Redis-Befehl SET key value NX EX ttl ermöglicht eine atomare Sperrenerfassung — er setzt den Schlüssel nur, wenn dieser nicht vorhanden ist (NX = Not eXists), und legt eine TTL fest, um Deadlocks zu verhindern, falls der Halter abstürzt. Nach Abschluss des Vorgangs löscht der Halter den Schlüssel. Der Redlock-Algorithmus (mit mehreren Redis-Knoten für ein Quorum) bietet eine robustere verteilte Sperre, erhöht jedoch die Komplexität. Für die meisten Anwendungsfälle ist eine Sperre auf einem einzelnen Redis-Knoten ausreichend.
# 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)Sitzungsspeicherung: ElastiCache vs. DynamoDB
Sowohl ElastiCache Redis als auch DynamoDB können Sitzungsdaten speichern, jedoch mit unterschiedlichen Vor- und Nachteilen. ElastiCache Redis: Mikrosekunden-Latenz, im Arbeitsspeicher (flüchtig, sofern keine Persistenz aktiviert ist), einfacheres Datenmodell, VPC erforderlich. DynamoDB: Latenz im einstelligen Millisekundenbereich (DAX kann Redis entsprechen), vollständig verwaltet, ohne dass ein Cluster gewartet werden muss, standardmäßig dauerhaft, mit Global Tables global zugänglich, serverlos mit On-Demand-Kapazität. Für die SAA-C03-Prüfung gilt: Wenn die Frage Mikrosekunden-Latenz oder komplexe Operationen im Arbeitsspeicher hervorhebt, wählen Sie Redis. Wenn sie dauerhafte Speicherung, Serverless oder globale Skalierung betont, ziehen Sie DynamoDB in Betracht.
Georäumliche Indizierung mit Redis
Redis verfügt über einen integrierten georäumlichen Datentyp (GEO-Befehle), der Breiten- und Längengradkoordinaten speichert und Abfragen nach räumlicher Nähe ermöglicht. Mit GEOADD, GEODIST und GEORADIUS (in Redis 6.2 jetzt GEOSEARCH) können Sie alle Orte innerhalb eines bestimmten Radius um einen Punkt mit einer Laufzeit von O(n + log n) finden. Anwendungsfälle sind beispielsweise das Finden nahegelegener Fahrer (Ride-Sharing), das Finden von Restaurants innerhalb von 5 km oder das Sortieren von Suchergebnissen nach Entfernung. Dadurch ist keine separate georäumliche Datenbank erforderlich, und Standortabfragen behalten die Geschwindigkeit des Arbeitsspeichers.
# 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 zum Zählen eindeutiger Besucher
Ein HyperLogLog ist eine probabilistische Datenstruktur, die die Anzahl eindeutiger Elemente in einer Menge mit einem festen Speicherbedarf schätzt (12 KB in Redis), unabhängig davon, wie viele eindeutige Elemente hinzugefügt werden. Der Standardfehler beträgt ungefähr 0,81 %. Verwenden Sie PFADD, um Elemente hinzuzufügen, und PFCOUNT, um die Schätzung abzurufen. Dies eignet sich ideal zum Zählen täglich aktiver eindeutiger Benutzer, eindeutiger Seitenaufrufe oder eindeutiger IP-Adressen, wenn keine exakten Zählungen erforderlich sind und Speichereffizienz eine Rolle spielt. Das Speichern von Millionen eindeutiger Benutzer-IDs als Redis Set würde GB an Speicher belegen; HyperLogLog verwendet 12 KB.
# 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}')Kurzer Test
Testen Sie Ihr Verständnis der AWS-Solutions-Architect-Konzepte (SAA-C03) aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Redis-Sitzungsspeicherung ermöglicht zustandslose horizontale Skalierung, indem alle Instanzen mit einer Latenz von unter einer Millisekunde Zugriff auf einen gemeinsam genutzten Sitzungsstatus erhalten; Redis Sorted Sets ermöglichen Echtzeit-Ranglisten mit Rangabfragen in O(log n); und spezialisierte Redis-Datentypen (HyperLogLog für eindeutige Anzahlen, GEO für räumliche Nähe und verteilte Sperren) lösen gängige Architekturprobleme effizient. Damit ist der Kurs „Caching mit ElastiCache“ abgeschlossen — als Nächstes beschäftigen wir uns mit hochverfügbaren und fehlertoleranten Architekturen.
Häufig gestellte Fragen
Ist die Lektion „Sitzungsspeicherung und Leaderboard-Muster“ kostenlos?
Ja — der vollständige Text von „Sitzungsspeicherung und Leaderboard-Muster“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Cloud & IT Cert Prep-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Cloud & IT Cert Prep-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Sitzungsspeicherung und Leaderboard-Muster“?
Lagern Sie den HTTP-Sitzungsstatus mit ElastiCache von Ihren Anwendungsservern aus und implementieren Sie Echtzeit-Leaderboards mit sortierten Redis-Mengen. Du übst Cloud & IT Cert Prep mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Cloud & IT Cert Prep zu starten?
Keine Vorkenntnisse erforderlich. Cloud & IT Cert Prep auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Sitzungsspeicherung und Leaderboard-Muster“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Cloud & IT Cert Prep-Lektion Code schreiben und ausführen?
Ja. Jede Cloud & IT Cert Prep-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Redis im Vergleich zu Memcached: Die richtige Engine auswählen
- ElastiCache-Redis-Replikationsgruppen und Clustermodus
- Caching-Strategien: Lazy Loading und Write-Through
- Sitzungsspeicherung und Leaderboard-Muster