Istuntojen tallennus ja tulostaulukuviot
Käytä ElastiCachea HTTP-istuntojen tilan siirtämiseen pois sovelluspalvelimilta ja toteuta reaaliaikaisia tulostauluja Redisin järjestetyillä joukoilla.
Istuntojen tallennus ja tulostaulukuviot on ilmainen Cloud & IT Cert Prep-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Cloud & IT Cert Prep-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Cloud & IT Cert Prep-kurssilla on yhteensä 4 oppituntia.
Palvelinpuolen istuntojen ongelma
Perinteiset verkkosovellukset tallentavat istuntotiedot palvelimen muistiin. Tämä toimii yhdellä palvelimella, mutta rikkoutuu vaakasuuntaisessa skaalauksessa — jos käyttäjän seuraava pyyntö reititetään toiselle EC2-instanssille, sillä instanssilla ei ole tietoa käyttäjän istunnosta ja käyttäjä kirjataan ulos. Tahmeat istunnot (istunnon sitominen kuormantasaajaan) ratkaisevat ongelman osittain, mutta heikentävät kuormantasaamisen tehokkuutta. Skaalautuva ratkaisu on siirtää istunnon tila jaettuun, pieniviiveiseen tallennussäilöön, johon kaikki instanssit pääsevät käsiksi — juuri tämän ElastiCache Redis tarjoaa.
Redis istuntojen tallennukseen
Istuntojen tallentaminen Redisiin tarjoaa seuraavat edut: alle millisekunnin istuntoluvut kaikilta sovelluspalvelimilta, sisäänrakennetun TTL:n istuntojen automaattiseen vanhenemiseen, atomiset istuntopäivitykset kilpailutilanteiden estämiseksi sekä mahdollisuuden mitätöidä istunto heti poistamalla avain. Sovellus tallentaa istunnon tunnisteen evästeeseen ja hakee jokaisen pyynnön yhteydessä istunnon tunnisteella istuntotiedot Redisistä. Kaikki sovelluspalvelimet käyttävät samaa Redis-instanssia, joten mikä tahansa palvelin voi käsitellä minkä tahansa käyttäjän pyynnön.
# 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 NoneIstunnon TTL ja liukuva vanheneminen
Kiinteä TTL tarkoittaa, että istunto vanhenee N sekuntia luomisen jälkeen toiminnasta riippumatta. Liukuva TTL (vanhenemisen jatkaminen jokaisen käyttökerran yhteydessä) on käyttäjäystävällisempi — istunto vanhenee N sekuntia viimeisimmän käyttökerran jälkeen. Toteuttakaa liukuva TTL Redisissä kutsumalla EXPIRE- (tai EXPIREAT-) komentoa istuntoavaimelle jokaisen onnistuneen istuntoluvun yhteydessä, jotta vanhenemisajan laskenta alkaa uudelleen. Näin aktiivisia käyttäjiä ei kirjata odottamatta ulos, kun taas epäaktiiviset istunnot vanhenevat automaattisesti ja vapauttavat muistia.
# 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 foundOstoskori Redisissä
Verkkokaupan ostoskori sopii luontevasti Redisiin. Kukin ostoskori tallennetaan Redis Hash -rakenteena, jossa kenttänä on tuotteen SKU ja arvona määrä. Hash-operaatiot, kuten HINCRBY ja HDEL, mahdollistavat atomiset päivitykset ilman koko ostoskorin lukemista ja uudelleenkirjoittamista. Kun tähän yhdistetään TTL (hylättyjen ostoskorien vanhentamiseen 24 tunnin jälkeen), Redis tarjoaa nopean ja pysyvän ostoskoritallennuksen ilman relaatiotietokannan käytön aiheuttamaa kuormaa jokaiselle ostoskoriin lisäämiselle.
# 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)Tulostauluarkkitehtuuri
Reaaliaikainen tulostaulu on perinteinen Redis-käyttötapa, jonka mahdollistavat järjestetyt joukot (ZSETit). Jokaisella pelaajatietueella on pistemäärä, ja järjestetty joukko pitää jäsenet jatkuvasti pistemäärän mukaisessa nousevassa järjestyksessä. Tulostaulukyselyt (parhaat N pelaajaa, pelaajan sijoitus ja tietyn pistemäärävälin pelaajat) ovat aikavaativuudeltaan O(log n) tai O(log n + m) — erittäin nopeita jopa miljoonille pelaajille. Redis-järjestetyt joukot muodostavat perustan monille pelien, kuntoilusovellusten ja sosiaalisten palvelujen sijoitusominaisuuksille ilman monimutkaisia tietokantakyselyitä tai sijoituksen uudelleenlaskentaa jokaisella sivun katselukerralla.
# 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)Pelaajan sijoitus ja lähellä olevat pelaajat
Kaksi yleistä tulostauluominaisuutta "näytä 10 parasta" -toiminnon lisäksi ovat pelaajan sijoituksen näyttäminen ja tietyn pelaajan lähellä olevien pelaajien näyttäminen. Molemmat ovat Redis-järjestettyjen joukkojen avulla yksinkertaisia. ZREVRANK palauttaa pelaajan nollapohjaisen sijoituksen laskevassa pistemääräjärjestyksessä. Jos haluat näyttää viisi pelaajaa pelaajan ylä- ja alapuolelta, hae ensin hänen sijoituksensa ja käytä sitten ZREVRANGE-komentoa välillä sijoitus−5–sijoitus+5. Näin saat henkilökohtaisen tulostaulunäkymän kahdella Redis-komennolla — monimutkaisia SQL-ikkunafunktioita ei tarvita.
# 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)Pyyntöjen rajoittaminen Redisillä
Pyyntöjen rajoittaminen (sen rajoittaminen, kuinka monta pyyntöä asiakas voi tehdä tietyn ajanjakson aikana) on toinen Redis-järjestelmän arvokas käyttötapa. Liukuva aikaikkuna-algoritmi käyttää järjestettyä joukkoa, jonka jokainen jäsen on pyynnön aikaleima. Jokaisen pyynnön yhteydessä poistetaan aikaikkunaa vanhemmat jäsenet, lasketaan jäljelle jäävät jäsenet, hylätään pyyntö, jos määrä ylittää rajan, ja lisätään uusi aikaleima. Näin toteutetaan tarkka liukuvan aikaikkunan rajoitus millisekunnin tarkkuudella — huomattavasti kiinteän aikaikkunan laskureita täsmällisemmin ja ilman tietokannan aiheuttamaa kuormitusta.
# 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 limitedHajautettu lukitus Redisillä
Hajautetut lukot koordinoivat jaetun resurssin yksinomaista käyttöä useiden sovelluspalvelinten välillä. Redisin SET key value NX EX ttl -komento tarjoaa atomisen lukon hankinnan: se asettaa avaimen vain, jos sitä ei ole olemassa (NX = Not eXists), ja määrittää TTL:n estämään lukkiutumisen, jos lukon haltija kaatuu. Kun toiminto valmistuu, haltija poistaa avaimen. Redlock-algoritmi (jossa käytetään useita Redis-solmuja päätösvaltaisuuden saavuttamiseksi) tarjoaa vankemman hajautetun lukon, mutta lisää monimutkaisuutta. Useimmissa käyttötapauksissa yhden Redis-solmun lukko riittää.
# 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)Istuntojen tallennus: ElastiCache vai DynamoDB
Sekä ElastiCache Redis että DynamoDB voivat tallentaa istuntotietoja, mutta niiden kompromissit ovat erilaiset. ElastiCache Redis: mikrosekuntien viive, muistissa oleva (haihtuva, ellei pysyvyyttä ole otettu käyttöön), yksinkertaisempi tietomalli, edellyttää VPC:tä. DynamoDB: yksinumeroisten millisekuntien viive (DAX voi yltää Redisin tasolle), täysin hallittu eikä ylläpidettävää klusteria, oletusarvoisesti kestävä, maailmanlaajuisesti käytettävissä Global Tables -ominaisuudella ja palvelimeton tarvittaessa varattavalla kapasiteetilla. SAA-C03-kokeessa: jos kysymyksessä korostetaan mikrosekuntien viivettä tai monimutkaisia muistissa suoritettavia toimintoja, valitse Redis. Jos siinä korostetaan kestävyyttä, palvelimettomuutta tai maailmanlaajuista skaalautuvuutta, harkitse DynamoDB:tä.
Paikkatietoindeksointi Redisillä
Redisissä on sisäänrakennettu paikkatietotietotyyppi (GEO-komennot), joka tallentaa leveys- ja pituuskoordinaatteja ja mahdollistaa läheisyyskyselyt. Komentojen GEOADD, GEODIST ja GEORADIUS (Redis 6.2:ssa nykyinen komento on GEOSEARCH) avulla voit etsiä kaikki sijainnit tietyn säteen sisältä pisteen ympäriltä ajassa O(n + log n). Käyttötapauksia ovat lähellä olevien kuljettajien etsiminen (kyytien jakaminen), 5 kilometrin säteellä olevien ravintoloiden etsiminen ja hakutulosten järjestäminen etäisyyden mukaan. Näin erillistä paikkatietokantaa ei tarvita ja sijaintikyselyt pysyvät muistissa suoritettavien operaatioiden nopeudella.
# 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 yksittäisten kävijöiden laskemiseen
HyperLogLog on probabilistinen tietorakenne, joka arvioi joukon yksittäisten alkioiden määrän käyttäen kiinteän määrän muistia (Redisissä 12 kt) riippumatta lisättyjen yksittäisten alkioiden määrästä. Sen vakiovirhe on noin 0,81 %. Lisää alkioita komennolla PFADD ja hae arvio komennolla PFCOUNT. Tämä sopii erinomaisesti päivittäin aktiivisten yksittäisten käyttäjien, yksittäisten sivukatselujen tai yksittäisten IP-osoitteiden laskemiseen, kun tarkkaa lukumäärää ei tarvita ja muistin tehokas käyttö on tärkeää. Miljoonien yksittäisten käyttäjätunnusten tallentaminen Redis Set -joukkona kuluttaisi gigatavuja, kun taas HyperLogLog käyttää 12 kt.
# 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}')Pikatarkistus
Testatkaa ymmärrystänne tämän oppitunnin AWS Solutions Architect (SAA-C03) -käsitteistä.
Oppitunnin yhteenveto
Tässä oppitunnissa opitte, että Redis-istuntojen tallennus mahdollistaa tilattoman horisontaalisen skaalauksen antamalla kaikille instansseille pääsyn jaettuun istunnon tilaan alle millisekunnin viiveellä, Redis-järjestetyt joukot mahdollistavat reaaliaikaiset tulostaulut O(log n) -sijoituskyselyillä ja Redis-erikoistietotyypit (HyperLogLog yksittäisten alkioiden laskemiseen, GEO läheisyyskyselyihin ja hajautetut lukot) ratkaisevat yleisiä arkkitehtuuriongelmia tehokkaasti. Tämä päättää ElastiCache-välimuistia käsittelevän kurssin — seuraavaksi tutustumme korkean käytettävyyden ja vikasietoisuuden arkkitehtuureihin.
Opi Cloud & IT Cert Prep tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 150
- Oppitunnit
- 600
Usein kysytyt kysymykset
Onko oppitunti ”Istuntojen tallennus ja tulostaulukuviot” ilmainen?
Kyllä – oppitunnin ”Istuntojen tallennus ja tulostaulukuviot” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Cloud & IT Cert Prep-kurssin, päivitä CoddyKit PROhon. Cloud & IT Cert Prep-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Istuntojen tallennus ja tulostaulukuviot”?
Käytä ElastiCachea HTTP-istuntojen tilan siirtämiseen pois sovelluspalvelimilta ja toteuta reaaliaikaisia tulostauluja Redisin järjestetyillä joukoilla. Harjoittelet Cloud & IT Cert Prep-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Cloud & IT Cert Prep-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Cloud & IT Cert Prep-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.
Kuinka kauan ”Istuntojen tallennus ja tulostaulukuviot”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Cloud & IT Cert Prep-oppitunnilla?
Kyllä. Jokainen Cloud & IT Cert Prep-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Redis vai Memcached: oikean moottorin valinta
- ElastiCache Redis -replikointiryhmät ja klusteritila
- Välimuististrategiat: lazy loading ja write-through
- Istuntojen tallennus ja tulostaulukuviot