Øktlagring og mønstre for ledertavler
Bruk ElastiCache til å avlaste HTTP-øktstatus fra applikasjonsserverne, og implementer ledertavler i sanntid med Redis-sorterte mengder
Øktlagring og mønstre for ledertavler er en gratis leksjon i Cloud & IT Cert Prep på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Cloud & IT Cert Prep, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Cloud & IT Cert Prep inneholder totalt 4 leksjoner.
Problemet med økter på serversiden
Tradisjonelle webapplikasjoner lagrer øktdata i minnet på serveren. Dette fungerer med én server, men bryter sammen når De skalerer horisontalt – hvis den neste forespørselen fra en bruker rutes til en annen EC2-instans, kjenner ikke den instansen brukerens økt, og brukeren blir logget ut. Klistrede økter (øktaffinitet i lastbalansereren) løser dette delvis, men reduserer effektiviteten til lastbalanseringen. Den skalerbare løsningen er å flytte økttilstanden til et delt lager med lav ventetid som alle instanser har tilgang til – og det er nettopp dette ElastiCache Redis tilbyr.
Redis for lagring av økter
Ved å lagre økter i Redis får De: øktlesing på under ett millisekund på tvers av alle applikasjonsservere, innebygd TTL for automatisk utløp av økter, atomiske øktoppdateringer som hindrer kappløpstilstander, samt muligheten til å ugyldiggjøre en økt umiddelbart ved å slette nøkkelen. Applikasjonen lagrer økt-ID-en i en informasjonskapsel. Ved hver forespørsel slår den opp økt-ID-en i Redis for å hente øktdataene. Alle applikasjonsserverne deler samme Redis, slik at enhver server kan håndtere forespørselen fra enhver bruker.
# 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Øktens TTL og glidende utløp
En fast TTL betyr at økten utløper N sekunder etter opprettelsen, uavhengig av aktivitet. En glidende TTL (der utløpstiden forlenges ved hver tilgang) er mer brukervennlig – økten utløper N sekunder etter den siste tilgangen. I Redis implementerer De glidende TTL ved å kalle EXPIRE (eller EXPIREAT) på øktnøkkelen ved hver vellykkede lesing av økten, slik at nedtellingen til utløp tilbakestilles. Dette sikrer at aktive brukere aldri uventet logges ut, samtidig som inaktive økter utløper automatisk og frigjør minne.
# 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 foundHandlevogn i Redis
En handlevogn i en netthandelsløsning passer naturlig til Redis. Hver handlevogn lagres som en Redis Hash, der feltet er produktets SKU og verdien er antallet. Hash-operasjoner som HINCRBY og HDEL gjør atomiske oppdateringer mulig uten å hente og skrive om hele handlevognen. Kombinert med en TTL (for å utløpe forlatte handlevogner etter 24 timer) gir Redis et raskt og varig lager for handlevogner, uten kostnadene ved å bruke en relasjonsdatabase for hver «legg i handlevogn»-hendelse.
# 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)Arkitektur for ledertavler
En ledertavle i sanntid er et klassisk bruksområde for Redis, muliggjort av sorterte mengder (ZSET-er). Hver spilleroppføring har en poengsum, og den sorterte mengden holder medlemmene sortert i stigende poengsum til enhver tid. Forespørsler mot ledertavlen (de N beste spillerne, spillerens rangering, spillere innenfor et poengsumintervall) har kompleksiteten O(log n) eller O(log n + m) — ekstremt raskt, selv for millioner av spillere. Redis-sorterte mengder er grunnlaget for mange rangeringsfunksjoner innen spill, trening og sosiale tjenester, uten behov for komplekse databasespørringer eller ny beregning av rangeringen ved hver sidevisning.
# 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)Spillerens rangering og spillere i nærheten
To vanlige ledertavlefunksjoner utover «vis topp 10» er å vise spillerens rangering og å vise spillere i nærheten av en bestemt spiller. Begge deler er enkelt med Redis-sorterte mengder. ZREVRANK returnerer spillerens nullbaserte rangering i synkende poengsumrekkefølge. Hvis De vil vise 5 spillere over og under en spiller, henter De først rangeringen og bruker deretter ZREVRANGE fra rangering-5 til rangering+5. Dette gir en personlig ledertavlevisning med to Redis-kommandoer — uten behov for komplekse SQL-vindusfunksjoner.
# 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)Frekvensbegrensning med Redis
Frekvensbegrensning (å begrense hvor mange forespørsler en klient kan sende i løpet av et tidsvindu) er et annet verdifullt bruksområde for Redis. Algoritmen for et glidende vindu bruker en sortert mengde der hvert medlem er et tidsstempel for en forespørsel. Ved hver forespørsel fjernes medlemmer som er eldre enn tidsvinduet, de gjenværende medlemmene telles, forespørselen avvises hvis antallet overskrider grensen, og det nye tidsstempelet legges til. Dette implementerer presis frekvensbegrensning med glidende vindu og millisekundoppløsning — langt mer nøyaktig enn tellere for faste vinduer og uten belastningen ved å bruke en database.
# 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 limitedDistribuert låsing med Redis
Distribuerte låser koordinerer eksklusiv tilgang til en delt ressurs på tvers av flere applikasjonsservere. Redis-kommandoen SET key value NX EX ttl gir atomisk låseopptakelse — den setter nøkkelen bare hvis den ikke allerede finnes (NX = Not eXists), og angir en TTL for å forhindre vranglåser hvis innehaveren krasjer. Når operasjonen er fullført, sletter innehaveren nøkkelen. Redlock-algoritmen (som bruker flere Redis-noder for å oppnå flertall) gir en mer robust distribuert lås, men øker kompleksiteten. For de fleste bruksområder er en lås på én Redis-node tilstrekkelig.
# 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)Lagring av økter: ElastiCache kontra DynamoDB
Både ElastiCache Redis og DynamoDB kan lagre øktdata, men de har ulike avveininger. ElastiCache Redis: mikrosekundforsinkelse, lagring i minnet (flyktig hvis ikke persistens er aktivert), enklere datamodell og krav om VPC. DynamoDB: forsinkelse på ensifret antall millisekunder (DAX kan matche Redis), fullstendig administrert uten en klynge som må vedlikeholdes, varig som standard, globalt tilgjengelig med Global Tables og serverløst med kapasitet etter behov. For SAA-C03-eksamen: Hvis oppgaven vektlegger mikrosekundforsinkelse eller komplekse operasjoner i minnet, velger De Redis. Hvis den vektlegger varighet, serverløs drift eller global skala, bør De vurdere DynamoDB.
Geospatial indeksering med Redis
Redis har en innebygd geospatial datatype (GEO-kommandoer) som lagrer breddegrads- og lengdegradskoordinater og muliggjør nærhetssøk. Ved å bruke GEOADD, GEODIST og GEORADIUS (nå GEOSEARCH i Redis 6.2) kan De finne alle steder innenfor en gitt radius fra et punkt på O(n + log n)-tid. Bruksområder er å finne sjåfører i nærheten (samkjøringstjenester), finne restauranter innenfor 5 km og sortere søkeresultater etter avstand. Dette eliminerer behovet for en separat geospatial database og holder stedssøk på hastigheten til minnebaserte operasjoner.
# 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 for telling av unike besøkende
En HyperLogLog er en sannsynlighetsbasert datastruktur som anslår antallet unike elementer i en mengde ved å bruke en fast mengde minne (12 KB i Redis), uavhengig av hvor mange unike elementer som legges til. Den har en standardfeil på omtrent 0,81 %. Bruk PFADD for å legge til elementer og PFCOUNT for å hente anslaget. Dette passer perfekt til å telle unike daglig aktive brukere, unike sidevisninger eller unike IP-adresser når nøyaktige antall ikke er nødvendig og effektiv minnebruk er viktig. Lagring av millioner av unike bruker-ID-er som en Redis Set ville brukt flere GB; HyperLogLog bruker 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}')Hurtigsjekk
Test forståelsen Deres av AWS Solutions Architect-konsepter (SAA-C03) fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen har De lært at Redis for lagring av økter muliggjør tilstandsløs horisontal skalering ved å gi alle instanser tilgang til delt økttilstand med under millisekunds forsinkelse, at Redis-sorterte mengder driver ledertavler i sanntid med rangeringsspørringer på O(log n), og at spesialiserte Redis-datatyper (HyperLogLog for unike antall, GEO for nærhet og distribuerte låser) løser vanlige arkitekturproblemer effektivt. Dette fullfører kurset Caching with ElastiCache — neste tema er høy tilgjengelighet og feiltolerante arkitekturer.
Lær deg Cloud & IT Cert Prep med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 150
- Leksjoner
- 600
Ofte stilte spørsmål
Er leksjonen «Øktlagring og mønstre for ledertavler» gratis?
Ja – hele teksten i «Øktlagring og mønstre for ledertavler» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Cloud & IT Cert Prep-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Cloud & IT Cert Prep inneholder totalt 4 leksjoner.
Hva lærer jeg i «Øktlagring og mønstre for ledertavler»?
Bruk ElastiCache til å avlaste HTTP-øktstatus fra applikasjonsserverne, og implementer ledertavler i sanntid med Redis-sorterte mengder Du øver på Cloud & IT Cert Prep med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Cloud & IT Cert Prep?
Ingen tidligere erfaring er nødvendig. Cloud & IT Cert Prep på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Øktlagring og mønstre for ledertavler»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Cloud & IT Cert Prep-leksjonen?
Ja. Alle Cloud & IT Cert Prep-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Redis kontra Memcached: Velg riktig motor
- ElastiCache Redis-replikeringsgrupper og klyngemodus
- Bufringsstrategier: Lazy Loading og Write-Through
- Øktlagring og mønstre for ledertavler