Redis Caching & Messaging (Pub/Sub, Streams) · درس

إدارة الجلسات باستخدام Redis

طبّقوا تخزينًا متينًا وقابلًا للتوسع لجلسات المستخدمين باستخدام Redis لتعزيز موثوقية التطبيقات.

الدرس 2 من 411 خطوة

إدارة الجلسات باستخدام Redis درس مجاني في Redis Caching & Messaging (Pub/Sub, Streams) على CoddyKit. هذا هو الدرس 2 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في Redis Caching & Messaging (Pub/Sub, Streams)، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة Redis Caching & Messaging (Pub/Sub, Streams) 4 دروس في المجموع.

بعض أجزاء هذا الدرس لم تُترجم بعد وتظهر باللغة الإنجليزية.

What are User Sessions?

User sessions are how web applications remember you! When you log in, add items to a cart, or navigate pages, your app tracks your state using a session.

Traditionally, sessions might be stored directly on the web server's memory or via small files (cookies) on your browser. This works for simple setups, but can become a bottleneck.

Why Redis for Sessions?

As applications grow, traditional session storage faces challenges:

Scalability: If you have multiple web servers, how do they all know about the same user's session?
Reliability: What happens if a server crashes and all in-memory sessions are lost?
Performance: Retrieving session data quickly is crucial for a smooth user experience.

Redis solves these by providing a fast, centralized, and persistent store for session data, accessible by all your application instances.

Storing Session Data in Redis

The best way to store session data in Redis is often using a Hash. A Redis Hash is like a small dictionary, perfect for holding multiple key-value pairs (your session attributes) under a single session ID.

We'll use a unique session ID (e.g., a UUID) as the main Redis key, like session:your_session_id, and inside that, store attributes like userId, username, loginTime, etc.

Creating a User Session

When a user logs in, your application generates a unique session ID. Then, it stores essential user information in Redis, along with a Time-To-Live (TTL) for automatic expiration.

Try running this Python example to create a new session:

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}")

Accessing Session Data

Once a session is created, your application needs to retrieve its data using the session ID (often sent via a cookie). We use HGETALL to fetch all attributes of a session Hash.

Run this code to see how to retrieve session data. Replace 'abc12345' with a session ID you created or a placeholder:

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")

Modifying Session Data

User actions might require updating session data, such as changing preferences or recording the lastActivity timestamp. It's also good practice to extend the session's expiration (refresh the TTL) with each activity.

Here's how to update an attribute and refresh the session's TTL:

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()))

Ending a User Session (Logout)

When a user logs out, or their session needs to be invalidated (e.g., due to inactivity), you simply delete the session key from Redis. This immediately removes all associated session data.

The DEL command is straightforward for this:

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")

Managing Session Expiration

Redis's Time-To-Live (TTL) feature is fundamental for session management. It ensures sessions are automatically cleaned up after a set period, saving memory and enhancing security by preventing stale sessions from lingering indefinitely.

You can use EXPIRE to set a TTL (as seen in previous examples) and TTL to check the remaining time. A return value of -2 means the key doesn't exist, and -1 means it exists but has no expiration.

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

Securing Your Sessions

While Redis provides robust storage, overall session security also relies on your application's practices:

Strong Session IDs: Always generate cryptographically secure, random IDs (like UUIDs) to prevent prediction.
HTTPS Only: Ensure all communication carrying session IDs (e.g., via cookies) is over HTTPS to prevent eavesdropping.
HttpOnly & Secure Flags: For cookies, use HttpOnly to prevent client-side script access and Secure to send only over HTTPS.
Short TTLs: Keep session expiration times as short as reasonably possible for user experience, balanced with security.
Re-authenticate for sensitive actions: For critical operations (e.g., changing passwords), always prompt for the user's password again.

Quick Check

Consider a web application using Redis for session management. A user logs in, performs some actions, and then logs out. Which sequence of Redis commands best represents these operations?

أجب عليها في الدرس التفاعلي

Recap & Next Steps

In this lesson, you learned how Redis excels at managing user sessions, offering a scalable and reliable alternative to traditional methods.

We explored using Redis Hashes to store diverse session attributes efficiently.
You practiced commands like HSET, HGETALL, EXPIRE, and DEL for managing the entire session lifecycle.
The importance of Time-To-Live (TTL) for automatic session cleanup and security was highlighted.
We also touched upon critical security considerations for handling sessions effectively.

By leveraging Redis, your applications can handle user sessions efficiently, even under high load, providing a consistent experience across multiple servers.

البدء مجانًا

تعلم Redis Caching & Messaging (Pub/Sub, Streams) مع معلم ذكاء اصطناعي — مجانًا

اكتب وقم بتشغيل أكوادك الفعلية في المتصفح، واحصل على مساعدة فورية من معلم ذكاء اصطناعي متاح 24/7، واستمر من حيث توقفت على الويب أو في التطبيق.

الدورات: 12
الدروس: 48

ابدأ التعلم مجانًا عرض الدورة الكاملة

الأسئلة الشائعة

هل درس «إدارة الجلسات باستخدام Redis» مجاني؟

نعم — نص درس «إدارة الجلسات باستخدام Redis» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة Redis Caching & Messaging (Pub/Sub, Streams)، انتقل إلى CoddyKit PRO. تتضمن دورة Redis Caching & Messaging (Pub/Sub, Streams) 4 دروس في المجموع.

ماذا ستتعلم في «إدارة الجلسات باستخدام Redis»؟

طبّقوا تخزينًا متينًا وقابلًا للتوسع لجلسات المستخدمين باستخدام Redis لتعزيز موثوقية التطبيقات. تتمرن على Redis Caching & Messaging (Pub/Sub, Streams) مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ Redis Caching & Messaging (Pub/Sub, Streams)؟

لا تُشترط خبرة سابقة. Redis Caching & Messaging (Pub/Sub, Streams) على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 2 من أصل 4.

كم من الوقت يستغرق درس «إدارة الجلسات باستخدام Redis»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس Redis Caching & Messaging (Pub/Sub, Streams) هذا؟

نعم. كل درس في Redis Caching & Messaging (Pub/Sub, Streams) يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

← العودة إلى Redis Caching & Messaging (Pub/Sub, Streams)