Redis Session Storage — ใช้ Redis เก็บ Session สำหรับ Web Application

Categories

Session Management เป็นส่วนสำคัญของเว็บแอพพลิเคชันที่ต้องจดจำสถานะผู้ใช้ เช่น การล็อกอิน ตะกร้าสินค้า หรือค่า Preferences ต่าง ๆ การเก็บ Session ไว้ในฐานข้อมูลหรือไฟล์บนเซิร์ฟเวอร์อาจกลายเป็นคอขวดเมื่อมีผู้ใช้พร้อมกันจำนวนมาก Redis เป็นตัวเลือกยอดนิยมสำหรับ Session Storage เพราะอ่านเขียนข้อมูลได้เร็วมากและรองรับการกำหนดเวลาหมดอายุของข้อมูลได้อัตโนมัติ

บทความนี้จะอธิบายเหตุผลที่ควรใช้ Redis เก็บ Session, สถาปัตยกรรมที่เหมาะสม, การตั้งค่าใน Framework ยอดนิยม พร้อมแนวทาง Security ที่ควรปฏิบัติ

ทำไมต้องเก็บ Session ใน Redis

เว็บแอพพลิเคชันส่วนใหญ่เก็บ Session ในรูปแบบใดรูปแบบหนึ่ง เช่น เก็บเป็นไฟล์บนดิสก์ เก็บในฐานข้อมูล หรือเก็บใน Memory ของเว็บเซิร์ฟเวอร์ แต่ละวิธีมีข้อจำกัดต่างกัน การเก็บเป็นไฟล์ช้าเมื่อมี Session จำนวนมากเพราะต้องอ่านเขียนดิสก์ทุกครั้ง การเก็บในฐานข้อมูลเพิ่มภาระให้กับ Database Server การเก็บใน Memory ของเว็บเซิร์ฟเวอร์ทำให้ไม่สามารถ Scale เป็นหลายเครื่องได้เพราะ Session อยู่เฉพาะบนเครื่องที่สร้างมัน

Redis แก้ปัญหาเหล่านี้ได้เพราะเก็บข้อมูลใน Memory ทำให้อ่านเขียนเร็วในระดับ Sub-millisecond รองรับ TTL สำหรับให้ Session หมดอายุอัตโนมัติ เป็น External Storage ที่ทุกเว็บเซิร์ฟเวอร์เข้าถึงได้ทำให้ Scale แบบ Horizontal ได้ง่าย และรองรับ Persistence ด้วย RDB/AOF ป้องกันข้อมูล Session สูญหายเมื่อ Redis รีสตาร์ท

สถาปัตยกรรม Session Storage ด้วย Redis

ในสถาปัตยกรรมมาตรฐาน Redis จะทำหน้าที่เป็น Session Store กลางที่ทุก Application Server เข้าถึงร่วมกัน เมื่อผู้ใช้ล็อกอิน แอพพลิเคชันจะสร้าง Session ID แบบ Random แล้วเก็บข้อมูล Session ไว้ใน Redis โดยใช้ Session ID เป็น Key จากนั้นส่ง Session ID กลับไปเก็บใน Cookie ของผู้ใช้

# ขั้นตอนการทำงาน
# 1. ผู้ใช้ล็อกอินสำเร็จ
# 2. Application สร้าง Session ID (เช่น sess:a1b2c3d4e5f6)
# 3. เก็บข้อมูล Session ใน Redis: SET sess:a1b2c3d4e5f6 {user_data} EX 3600
# 4. ส่ง Session ID กลับเป็น Cookie
# 5. Request ถัดไป: อ่าน Cookie → ดึง Session จาก Redis → ตรวจสอบสิทธิ์
# 6. Session หมดอายุอัตโนมัติตาม TTL ที่ตั้งไว้

รูปแบบนี้รองรับ Load Balancer ได้โดยไม่ต้องใช้ Sticky Session เพราะไม่ว่า Request จะไปถึงเครื่องไหน ทุกเครื่องดึง Session จาก Redis ที่เดียวกันได้

การเก็บ Session ด้วย Redis ใน Python (Flask)

Flask สามารถใช้ Redis เก็บ Session ได้ผ่าน Flask-Session โดยแทนที่ Session แบบ Cookie-based ด้วย Server-side Session ที่เก็บใน Redis

# ติดตั้ง
# pip install flask flask-session redis

from flask import Flask, session
from flask_session import Session
import redis

app = Flask(__name__)

# ตั้งค่า Session ใช้ Redis
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_PERMANENT'] = True
app.config['PERMANENT_SESSION_LIFETIME'] = 3600  # 1 ชั่วโมง
app.config['SESSION_REDIS'] = redis.Redis(host='127.0.0.1', port=6379, db=0)
app.config['SESSION_KEY_PREFIX'] = 'sess:'
app.config['SECRET_KEY'] = 'your-secret-key-here'

Session(app)

@app.route('/login', methods=['POST'])
def login():
    # ตรวจสอบ Username/Password
    user = authenticate(request.form['username'], request.form['password'])
    if user:
        session['user_id'] = user.id
        session['username'] = user.username
        session['role'] = user.role
        return {'message': 'Login successful'}
    return {'error': 'Invalid credentials'}, 401

@app.route('/profile')
def profile():
    if 'user_id' not in session:
        return {'error': 'Not authenticated'}, 401
    return {
        'user_id': session['user_id'],
        'username': session['username']
    }

@app.route('/logout')
def logout():
    session.clear()
    return {'message': 'Logged out'}

การเก็บ Session ด้วย Redis ใน Node.js (Express)

Express ใช้ connect-redis เป็น Session Store ร่วมกับ express-session เพื่อเก็บข้อมูล Session ใน Redis แทนที่จะเก็บใน Memory ของ Node.js Process

// ติดตั้ง
// npm install express express-session connect-redis ioredis

const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const Redis = require('ioredis');

const app = express();
const redisClient = new Redis({ host: '127.0.0.1', port: 6379 });

app.use(session({
  store: new RedisStore({ client: redisClient, prefix: 'sess:' }),
  secret: 'your-secret-key-here',
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: true,       // ใช้ HTTPS เท่านั้น
    httpOnly: true,      // ป้องกัน XSS อ่าน Cookie
    maxAge: 3600000,     // 1 ชั่วโมง (มิลลิวินาที)
    sameSite: 'strict'   // ป้องกัน CSRF
  }
}));

app.post('/login', (req, res) => {
  const user = authenticate(req.body.username, req.body.password);
  if (user) {
    req.session.userId = user.id;
    req.session.username = user.username;
    req.session.role = user.role;
    return res.json({ message: 'Login successful' });
  }
  res.status(401).json({ error: 'Invalid credentials' });
});

app.get('/profile', (req, res) => {
  if (!req.session.userId) {
    return res.status(401).json({ error: 'Not authenticated' });
  }
  res.json({
    userId: req.session.userId,
    username: req.session.username
  });
});

app.post('/logout', (req, res) => {
  req.session.destroy((err) => {
    if (err) return res.status(500).json({ error: 'Logout failed' });
    res.clearCookie('connect.sid');
    res.json({ message: 'Logged out' });
  });
});

การเก็บ Session ด้วย Redis ใน PHP (Laravel)

Laravel รองรับ Redis Session Driver ในตัว เพียงแค่เปลี่ยน Session Driver เป็น Redis ในไฟล์ .env ก็พร้อมใช้งานทันที

# .env
SESSION_DRIVER=redis
SESSION_LIFETIME=60
REDIS_HOST=127.0.0.1
REDIS_PORT=6379

# config/session.php — ค่าสำคัญ
# 'driver' => env('SESSION_DRIVER', 'redis'),
# 'lifetime' => env('SESSION_LIFETIME', 120),
# 'expire_on_close' => false,
# 'encrypt' => true,
# 'cookie' => 'app_session',
# 'secure' => true,
# 'http_only' => true,
# 'same_site' => 'strict',
// ใช้งาน Session ใน Controller
class AuthController extends Controller
{
    public function login(Request $request)
    {
        $credentials = $request->only('email', 'password');

        if (Auth::attempt($credentials)) {
            $request->session()->regenerate();
            session(['user_role' => Auth::user()->role]);
            session(['login_at' => now()->toISOString()]);
            return response()->json(['message' => 'Login successful']);
        }

        return response()->json(['error' => 'Invalid credentials'], 401);
    }

    public function logout(Request $request)
    {
        Auth::logout();
        $request->session()->invalidate();
        $request->session()->regenerateToken();
        return response()->json(['message' => 'Logged out']);
    }
}

Session Management ด้วย Redis โดยตรง

ในบางกรณีอาจต้องการควบคุม Session เองทั้งหมดโดยไม่ใช้ Library สำเร็จรูป เช่น ต้องการโครงสร้าง Session ที่กำหนดเอง หรือใช้ภาษาที่ไม่มี Session Library สำหรับ Redis ตัวอย่างการจัดการ Session ด้วย Redis โดยตรงมีดังนี้

import redis
import json
import secrets
import hashlib
import time

r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)

SESSION_TTL = 3600       # 1 ชั่วโมง
SESSION_PREFIX = "sess:"

def create_session(user_data):
    """สร้าง Session ใหม่"""
    session_id = secrets.token_hex(32)  # 64 characters random hex
    session_key = f"{SESSION_PREFIX}{session_id}"

    session_data = {
        "user_id": user_data["id"],
        "username": user_data["username"],
        "role": user_data["role"],
        "created_at": int(time.time()),
        "ip": user_data.get("ip", ""),
        "user_agent": user_data.get("user_agent", "")
    }

    r.setex(session_key, SESSION_TTL, json.dumps(session_data))
    return session_id

def get_session(session_id):
    """อ่าน Session"""
    session_key = f"{SESSION_PREFIX}{session_id}"
    data = r.get(session_key)
    if not data:
        return None
    return json.loads(data)

def refresh_session(session_id):
    """ต่ออายุ Session (Sliding Expiration)"""
    session_key = f"{SESSION_PREFIX}{session_id}"
    if r.exists(session_key):
        r.expire(session_key, SESSION_TTL)
        return True
    return False

def destroy_session(session_id):
    """ลบ Session"""
    session_key = f"{SESSION_PREFIX}{session_id}"
    return r.delete(session_key)

def destroy_all_user_sessions(user_id):
    """ลบ Session ทั้งหมดของผู้ใช้คนหนึ่ง (Force Logout)"""
    cursor = 0
    while True:
        cursor, keys = r.scan(cursor, match=f"{SESSION_PREFIX}*", count=100)
        for key in keys:
            data = r.get(key)
            if data:
                session = json.loads(data)
                if session.get("user_id") == user_id:
                    r.delete(key)
        if cursor == 0:
            break

ใช้ Hash สำหรับ Session Data

แทนที่จะเก็บ Session เป็น JSON String สามารถใช้ Redis Hash เก็บแยก Field ได้ ข้อดีคืออ่านหรืออัพเดตเฉพาะ Field ที่ต้องการโดยไม่ต้องดึงทั้ง Session ออกมา เหมาะกับ Session ที่มีข้อมูลมากหรือต้องอัพเดตบ่อย

def create_session_hash(user_data):
    """สร้าง Session แบบ Hash"""
    session_id = secrets.token_hex(32)
    session_key = f"{SESSION_PREFIX}{session_id}"

    r.hset(session_key, mapping={
        "user_id": str(user_data["id"]),
        "username": user_data["username"],
        "role": user_data["role"],
        "created_at": str(int(time.time())),
        "cart_count": "0"
    })
    r.expire(session_key, SESSION_TTL)
    return session_id

def get_session_field(session_id, field):
    """อ่านเฉพาะ Field ที่ต้องการ"""
    return r.hget(f"{SESSION_PREFIX}{session_id}", field)

def update_cart_count(session_id, count):
    """อัพเดตเฉพาะจำนวนสินค้าในตะกร้า"""
    r.hset(f"{SESSION_PREFIX}{session_id}", "cart_count", str(count))

def get_full_session(session_id):
    """อ่านทั้ง Session"""
    return r.hgetall(f"{SESSION_PREFIX}{session_id}")

Session Security Best Practices

การเก็บ Session ต้องคำนึงถึงความปลอดภัยเป็นพิเศษเพราะ Session เป็นหลักฐานยืนยันตัวตนของผู้ใช้ แนวทางที่ควรปฏิบัติมีดังนี้

สร้าง Session ID ที่ปลอดภัย

Session ID ต้องใช้ Cryptographically Secure Random Generator สร้าง ห้ามใช้ค่าที่เดาได้ เช่น Timestamp หรือ Sequential Number ความยาวควรอย่างน้อย 128 bits (32 hex characters)

# ถูกต้อง — ใช้ Cryptographically Secure Random
import secrets
session_id = secrets.token_hex(32)  # 256 bits

# ผิด — เดาได้ง่าย
import hashlib, time
session_id = hashlib.md5(str(time.time()).encode()).hexdigest()  # ห้ามทำแบบนี้

Regenerate Session หลังล็อกอิน

เมื่อผู้ใช้ล็อกอินสำเร็จ ต้องสร้าง Session ID ใหม่ทุกครั้งเพื่อป้องกัน Session Fixation Attack ซึ่งผู้โจมตีอาจส่ง Session ID ที่รู้ให้เหยื่อใช้ล็อกอิน

def login(username, password, old_session_id):
    user = authenticate(username, password)
    if not user:
        return None

    # ลบ Session เก่า
    destroy_session(old_session_id)

    # สร้าง Session ใหม่ (Session Regeneration)
    new_session_id = create_session({
        "id": user.id,
        "username": user.username,
        "role": user.role
    })

    return new_session_id

ตั้งค่า Cookie อย่างปลอดภัย

Cookie ที่เก็บ Session ID ต้องตั้งค่า Flag ด้านความปลอดภัยให้ครบ Secure Flag บังคับให้ส่ง Cookie ผ่าน HTTPS เท่านั้น HttpOnly ป้องกัน JavaScript อ่าน Cookie ลดความเสี่ยง XSS SameSite ป้องกัน CSRF โดยไม่ส่ง Cookie ใน Cross-site Request

# Python Flask — ตั้งค่า Cookie ที่ปลอดภัย
app.config.update(
    SESSION_COOKIE_SECURE=True,      # HTTPS Only
    SESSION_COOKIE_HTTPONLY=True,     # ป้องกัน XSS
    SESSION_COOKIE_SAMESITE='Strict', # ป้องกัน CSRF
    SESSION_COOKIE_NAME='__Host-session',  # Cookie Prefix สำหรับ Security
)

จำกัดจำนวน Session ต่อผู้ใช้

เพื่อป้องกันการใช้ Account ร่วมกันหรือตรวจจับการเข้าถึงที่ผิดปกติ สามารถจำกัดจำนวน Active Session ต่อผู้ใช้ได้โดยเก็บรายการ Session ของผู้ใช้แต่ละคนไว้ใน Redis Set

MAX_SESSIONS = 5

def create_limited_session(user_data):
    """สร้าง Session พร้อมจำกัดจำนวน"""
    user_sessions_key = f"user_sessions:{user_data['id']}"
    session_id = secrets.token_hex(32)
    session_key = f"{SESSION_PREFIX}{session_id}"

    # ลบ Session ที่หมดอายุออกจากรายการ
    existing = r.smembers(user_sessions_key)
    for sid in existing:
        if not r.exists(f"{SESSION_PREFIX}{sid}"):
            r.srem(user_sessions_key, sid)

    # ตรวจสอบจำนวน Session
    if r.scard(user_sessions_key) >= MAX_SESSIONS:
        # ลบ Session เก่าสุด
        oldest = r.spop(user_sessions_key)
        if oldest:
            r.delete(f"{SESSION_PREFIX}{oldest}")

    # สร้าง Session ใหม่
    r.setex(session_key, SESSION_TTL, json.dumps(user_data))
    r.sadd(user_sessions_key, session_id)
    r.expire(user_sessions_key, SESSION_TTL)

    return session_id

Sliding vs Absolute Expiration

Session Expiration มี 2 แบบหลัก Absolute Expiration กำหนดเวลาหมดอายุตายตัว เช่น 1 ชั่วโมงหลังสร้าง ไม่ว่าจะมีการใช้งานหรือไม่ Session จะหมดอายุตามเวลาที่กำหนด เหมาะกับระบบที่ต้องการความปลอดภัยสูง Sliding Expiration ต่ออายุทุกครั้งที่มีการใช้งาน เช่น ตั้ง TTL 30 นาทีและรีเซ็ตทุกครั้งที่มี Request เข้ามา Session จะหมดอายุเฉพาะเมื่อผู้ใช้ไม่ได้ใช้งานนานเกินกำหนด เหมาะกับระบบที่ต้องการความสะดวกของผู้ใช้

def middleware_sliding_expiration(session_id):
    """Middleware สำหรับ Sliding Expiration"""
    session_key = f"{SESSION_PREFIX}{session_id}"

    data = r.get(session_key)
    if not data:
        return None  # Session หมดอายุ

    # ต่ออายุ Session ทุกครั้งที่มี Request
    r.expire(session_key, SESSION_TTL)
    return json.loads(data)

def middleware_absolute_expiration(session_id):
    """Middleware สำหรับ Absolute Expiration"""
    session_key = f"{SESSION_PREFIX}{session_id}"

    data = r.get(session_key)
    if not data:
        return None

    session = json.loads(data)
    created_at = session.get("created_at", 0)

    # ตรวจสอบอายุ Session (ไม่ต่ออายุ)
    if time.time() - created_at > SESSION_TTL:
        r.delete(session_key)
        return None

    return session

ในทางปฏิบัติหลายระบบใช้ทั้ง 2 แบบร่วมกัน คือต่ออายุเมื่อมีการใช้งาน แต่กำหนดอายุสูงสุดไว้ด้วย เช่น Session ต่ออายุได้ทุก 30 นาที แต่ไม่เกิน 24 ชั่วโมงนับจากล็อกอิน

Session Storage กับ Redis Cluster

สำหรับระบบขนาดใหญ่ที่มี Session จำนวนมากจนเครื่องเดียวไม่พอ สามารถใช้ Redis Cluster กระจาย Session ไปหลายเครื่องได้ Redis Cluster จะแบ่ง Key ตาม Hash Slot อัตโนมัติ ข้อสำคัญคือต้องออกแบบ Session Key ให้ไม่ต้องทำ Multi-key Operation ข้าม Slot เพราะ Cluster ไม่รองรับ Transaction ข้าม Node

# การเชื่อมต่อ Redis Cluster
from redis.cluster import RedisCluster

rc = RedisCluster(
    startup_nodes=[
        {"host": "redis-node-1", "port": 6379},
        {"host": "redis-node-2", "port": 6379},
        {"host": "redis-node-3", "port": 6379}
    ],
    decode_responses=True
)

# Session operations ทำงานเหมือนเดิม
def create_cluster_session(user_data):
    session_id = secrets.token_hex(32)
    session_key = f"sess:{session_id}"
    rc.setex(session_key, SESSION_TTL, json.dumps(user_data))
    return session_id

# ข้อควรระวัง: ถ้าต้องการเก็บ user_sessions set ร่วมด้วย
# ให้ใช้ Hash Tag เพื่อบังคับให้อยู่ Slot เดียวกัน
# เช่น sess:{user123}:abc123 และ user_sessions:{user123}
# จะอยู่ Slot เดียวกันเพราะ Hash จาก {user123}

Monitoring และ Troubleshooting

การตรวจสอบ Session Storage ช่วยให้รู้ว่าระบบทำงานปกติหรือไม่ คำสั่งที่ใช้บ่อยมีดังนี้

# นับจำนวน Active Session
redis-cli EVAL "return #redis.call('KEYS', 'sess:*')" 0

# ดูข้อมูล Session เฉพาะ (Debug)
redis-cli GET sess:a1b2c3d4e5f6

# ดู TTL ที่เหลือของ Session
redis-cli TTL sess:a1b2c3d4e5f6

# ดู Memory ที่ Session ทั้งหมดใช้ (ประมาณ)
redis-cli INFO memory | grep used_memory_human

# ลบ Session ทั้งหมด (ระวัง — ทุกคนจะถูก Logout)
# redis-cli EVAL "for _,k in ipairs(redis.call('KEYS','sess:*')) do redis.call('DEL',k) end" 0

# ดูจำนวน Key ทั้งหมด
redis-cli DBSIZE

สรุป

Redis เป็น Session Storage ที่เร็ว เสถียร และ Scale ได้ดี เหมาะกับเว็บแอพพลิเคชันทุกขนาดตั้งแต่โปรเจกต์เล็กไปจนถึงระบบที่รองรับผู้ใช้หลายล้านคน การเลือก Framework ที่มี Redis Session Driver ในตัวช่วยให้เริ่มต้นได้ง่าย แต่สิ่งที่ไม่ควรมองข้ามคือ Security Best Practices ทั้ง Session Regeneration, Cookie Security Flags และการจำกัดจำนวน Session เพื่อให้ระบบปลอดภัยจากการโจมตี

แนะนำบริการ DE

การรัน Redis สำหรับ Session Storage ในระบบ Production ต้องการเซิร์ฟเวอร์ที่มี RAM เพียงพอและ Uptime สูง Cloud VPS ของ DE รองรับการเลือก RAM ตามจำนวน Session ที่ต้องรองรับ พร้อม SSD NVMe สำหรับ Persistence ที่เร็ว เหมาะสำหรับรัน Redis ทั้ง Standalone และ Sentinel

สำหรับเว็บไซต์ที่ต้องการ Redis Session โดยไม่ต้องจัดการเซิร์ฟเวอร์เอง Cloud Hosting ของ DE รองรับ Redis ในตัว เหมาะสำหรับ WordPress หรือ PHP Application ที่ต้องการ Session Storage ที่เร็วกว่าไฟล์