Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) · Les

Sessiebeheer met Redis

Implementeer robuuste en schaalbare opslag van gebruikerssessies met Redis om de betrouwbaarheid van applicaties te verbeteren.

Les 2 van 411 stappen

Sessiebeheer met Redis is een gratis Redis-caching en berichtenuitwisseling (Pub/Sub, Streams)-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Redis-caching en berichtenuitwisseling (Pub/Sub, Streams). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) bevat in totaal 4 lessen.

Wat zijn gebruikerssessies?

Gebruikerssessies zorgen ervoor dat webapplicaties je onthouden! Wanneer je inlogt, items aan een winkelmandje toevoegt of door pagina's navigeert, houdt je app je toestand bij met behulp van een sessie.

Traditioneel worden sessies rechtstreeks in het geheugen van de webserver opgeslagen of via kleine bestanden (cookies) in je browser. Dit werkt voor eenvoudige opstellingen, maar kan een knelpunt worden.

Waarom Redis voor sessies?

Naarmate applicaties groeien, levert traditionele sessieopslag verschillende problemen op:

Schaalbaarheid: Als je meerdere webservers hebt, hoe weten die dan allemaal van de sessie van dezelfde gebruiker?
Betrouwbaarheid: Wat gebeurt er als een server crasht en alle sessies in het geheugen verloren gaan?
Prestaties: Sess gegevens snel ophalen is cruciaal voor een soepele gebruikerservaring.

Redis lost deze problemen op door een snelle, gecentraliseerde en blijvende opslag voor sessiegegevens te bieden, die toegankelijk is voor al je applicatie-instanties.

Sessiegegevens opslaan in Redis

De beste manier om sessiegegevens in Redis op te slaan is vaak met een Hash. Een Redis Hash lijkt op een klein woordenboek en is perfect voor het bevatten van meerdere sleutel-waardeparen (de kenmerken van je sessie) onder één sessie-ID.

We gebruiken een unieke sessie-ID (bijvoorbeeld een UUID) als de belangrijkste Redis-sleutel, zoals session:your_session_id. Daarin slaan we kenmerken op zoals userId, username, loginTime enzovoort.

Een gebruikerssessie maken

Wanneer een gebruiker inlogt, genereert je applicatie een unieke sessie-ID. Vervolgens slaat de applicatie essentiële gebruikersinformatie op in Redis, samen met een Time-To-Live (TTL) voor automatische verwijdering.

Voer dit Python-voorbeeld uit om een nieuwe sessie te maken:

import redis
import uuid
import time

r = redis.Redis(decode_responses=True)

def create_session(user_id, username):
    session_id = str(uuid.uuid4())
    session_key = f"session:{session_id}"
    r.hset(session_key, mapping={
        "userId": user_id,
        "username": username,
        "loginTime": int(time.time())
    })
    r.expire(session_key, 3600) # Session expires in 1 hour (3600 seconds)
    print(f"Created session {session_id} for {username}")
    return session_id

if __name__ == "__main__":
    new_session_id = create_session("101", "Alice")
    print(f"New session ID: {new_session_id}")

Sessiegegevens ophalen

Nadat een sessie is gemaakt, moet je applicatie de gegevens ervan ophalen met de sessie-ID (die vaak via een cookie wordt verzonden). We gebruiken HGETALL om alle kenmerken van een sessie-Hash op te halen.

Voer deze code uit om te zien hoe je sessiegegevens ophaalt. Vervang 'abc12345' door een sessie-ID die je hebt gemaakt of door een tijdelijke waarde:

import redis

r = redis.Redis(decode_responses=True)

def get_session_data(session_id):
    session_key = f"session:{session_id}"
    data = r.hgetall(session_key)
    if data:
        print(f"Session {session_id} data: {data}")
    else:
        print(f"Session {session_id} not found or expired.")
    return data

if __name__ == "__main__":
    # Replace with an actual session ID from previous step or a dummy one
    get_session_data("abc12345")

Sessiegegevens wijzigen

Door gebruikersacties moeten sessiegegevens mogelijk worden bijgewerkt, bijvoorbeeld wanneer voorkeuren worden gewijzigd of de tijdstempel lastActivity wordt vastgelegd. Het is ook een goede gewoonte om de vervaltijd van de sessie bij elke activiteit te verlengen (de TTL te vernieuwen).

Zo werk je een kenmerk bij en vernieuw je de TTL van de sessie:

import redis
import time

r = redis.Redis(decode_responses=True)

def update_session(session_id, key, value):
    session_key = f"session:{session_id}"
    r.hset(session_key, key, value)
    r.expire(session_key, 3600) # Refresh TTL for 1 hour
    print(f"Updated '{key}' in session {session_id}. TTL refreshed.")

if __name__ == "__main__":
    # Replace with an actual session ID
    update_session("abc12345", "lastActivity", int(time.time()))

Een gebruikerssessie beëindigen (uitloggen)

Wanneer een gebruiker uitlogt of de sessie ongeldig moet worden gemaakt (bijvoorbeeld wegens inactiviteit), verwijder je eenvoudig de sessiesleutel uit Redis. Hierdoor worden alle bijbehorende sessiegegevens onmiddellijk verwijderd.

De opdracht DEL is hiervoor eenvoudig te gebruiken:

import redis

r = redis.Redis(decode_responses=True)

def delete_session(session_id):
    session_key = f"session:{session_id}"
    deleted_count = r.delete(session_key)
    if deleted_count > 0:
        print(f"Session {session_id} deleted successfully.")
    else:
        print(f"Session {session_id} not found.")

if __name__ == "__main__":
    # Replace with an actual session ID
    delete_session("abc12345")

Het verlopen van sessies beheren

De Time-To-Live-functie (TTL) van Redis is essentieel voor sessiebeheer. Deze zorgt ervoor dat sessies na een bepaalde periode automatisch worden opgeschoond. Zo bespaar je geheugen en verbeter je de beveiliging doordat verlopen sessies niet onbeperkt blijven bestaan.

Je kunt EXPIRE gebruiken om een TTL in te stellen (zoals in eerdere voorbeelden) en TTL om de resterende tijd te controleren. Een retourwaarde van -2 betekent dat de sleutel niet bestaat; -1 betekent dat de sleutel wel bestaat, maar geen vervaltijd heeft.

import redis
import time

r = redis.Redis(decode_responses=True)

def check_session_ttl(session_id):
    session_key = f"session:{session_id}"
    ttl = r.ttl(session_key)
    if ttl == -2:
        print(f"Session {session_id} does not exist.")
    elif ttl == -1:
        print(f"Session {session_id} exists but has no expiration.")
    else:
        print(f"Session {session_id} expires in {ttl} seconds.")

if __name__ == "__main__":
    # Create a temporary session for demonstration
    temp_session_id = "temp_session_123"
    r.hset(f"session:{temp_session_id}", "testKey", "testValue")
    r.expire(f"session:{temp_session_id}", 60) # Expires in 60 seconds
    print(f"Created temporary session {temp_session_id} with 60s TTL.")
    time.sleep(1) # Wait a moment
    check_session_ttl(temp_session_id)
    r.delete(f"session:{temp_session_id}") # Clean up

Je sessies beveiligen

Hoewel Redis krachtige opslag biedt, hangt de algemene sessiebeveiliging ook af van de werkwijze in je applicatie:

Sterke sessie-ID's: Genereer altijd cryptografisch veilige, willekeurige ID's (zoals UUID's) om voorspelling te voorkomen.
Alleen HTTPS: Zorg ervoor dat alle communicatie met sessie-ID's (bijvoorbeeld via cookies) via HTTPS verloopt om afluisteren te voorkomen.
HttpOnly- en Secure-vlaggen: Gebruik voor cookies HttpOnly om toegang vanuit scripts aan de clientzijde te voorkomen en Secure om cookies alleen via HTTPS te verzenden.
Korte TTL's: Houd de vervaltijden van sessies, voor zover redelijk binnen een goede gebruikerservaring, zo kort mogelijk met het oog op de beveiliging.
Opnieuw authenticeren voor gevoelige acties: Vraag bij kritieke bewerkingen (bijvoorbeeld het wijzigen van wachtwoorden) altijd opnieuw om het wachtwoord van de gebruiker.

Snelle controle

Stel je een webapplicatie voor die Redis gebruikt voor sessiebeheer. Een gebruiker logt in, voert enkele acties uit en logt vervolgens uit. Welke reeks Redis-opdrachten geeft deze bewerkingen het beste weer?

Beantwoord dit in de interactieve les

Samenvatting en volgende stappen

In deze les heb je geleerd hoe Redis uitblinkt in het beheren van gebruikerssessies en een schaalbaar en betrouwbaar alternatief biedt voor traditionele methoden.

We hebben onderzocht hoe je Redis-hashes gebruikt om verschillende sessiekenmerken efficiënt op te slaan.
Je hebt opdrachten zoals HSET, HGETALL, EXPIRE en DEL geoefend voor het beheren van de volledige levenscyclus van een sessie.
We hebben het belang van Time-To-Live (TTL) voor het automatisch opschonen van sessies en de beveiliging benadrukt.
Ook hebben we belangrijke beveiligingsoverwegingen voor effectief sessiebeheer besproken.

Door Redis te gebruiken, kunnen je applicaties gebruikerssessies efficiënt beheren, zelfs bij een hoge belasting. Zo bieden ze op meerdere servers een consistente ervaring.

Gratis beginnen

Leer Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Sessiebeheer met Redis” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Redis-caching en berichtenuitwisseling (Pub/Sub, Streams), waaronder “Sessiebeheer met Redis”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) bevat in totaal 4 lessen.

Wat leer ik in “Sessiebeheer met Redis”?

Implementeer robuuste en schaalbare opslag van gebruikerssessies met Redis om de betrouwbaarheid van applicaties te verbeteren. Je oefent met Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) te beginnen?

Ervaring vooraf is niet nodig. Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Sessiebeheer met Redis”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Redis-caching en berichtenuitwisseling (Pub/Sub, Streams)?

Ja. Elke les over Redis-caching en berichtenuitwisseling (Pub/Sub, Streams) bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Redis-caching en berichtenuitwisseling (Pub/Sub, Streams)