Redis là gì? Tìm hiểu In-Memory Database mạnh mẽ cho ứng dụng hiện đại

# Set một giá trị
SET user:1000 "John Doe"

# Get giá trị
GET user:1000

# Set với expiration (10 giây)
SETEX session:abc123 10 "user_data"

# Increment counter
INCR page_views

# Add vào list
LPUSH notifications "New message"

import redis
import json

# Kết nối Redis
r = redis.Redis(host='localhost', port=6379, db=0)

def get_user_profile(user_id):
    # Kiểm tra cache trước
    cache_key = f"user:profile:{user_id}"
    cached_data = r.get(cache_key)
    
    if cached_data:
        # Cache hit - trả về dữ liệu từ Redis
        return json.loads(cached_data)
    
    # Cache miss - query từ database
    user = query_database(user_id)
    
    # Lưu vào cache với TTL 1 giờ
    r.setex(cache_key, 3600, json.dumps(user))
    
    return user

// Node.js với express-session
const session = require('express-session');
const RedisStore = require('connect-redis')(session);
const redis = require('redis');

const redisClient = redis.createClient({
  host: 'localhost',
  port: 6379
});

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'your-secret-key',
  resave: false,
  saveUninitialized: false,
  cookie: {
    maxAge: 1000 * 60 * 60 * 24 // 24 hours
  }
}));

from datetime import datetime

# Track page views
def track_page_view(page_url):
    today = datetime.now().strftime('%Y-%m-%d')
    r.incr(f"pageviews:{page_url}:{today}")
    r.incr(f"pageviews:{page_url}:total")

# Track unique visitors với HyperLogLog
def track_unique_visitor(page_url, visitor_id):
    today = datetime.now().strftime('%Y-%m-%d')
    r.pfadd(f"unique_visitors:{page_url}:{today}", visitor_id)

# Get statistics
def get_page_stats(page_url):
    today = datetime.now().strftime('%Y-%m-%d')
    return {
        'views_today': r.get(f"pageviews:{page_url}:{today}") or 0,
        'views_total': r.get(f"pageviews:{page_url}:total") or 0,
        'unique_visitors': r.pfcount(f"unique_visitors:{page_url}:{today}")
    }

# Cập nhật điểm cho player
def update_score(player_id, score):
    r.zadd("game:leaderboard", {player_id: score})

# Lấy top 10 players
def get_top_players(limit=10):
    return r.zrevrange("game:leaderboard", 0, limit-1, withscores=True)

# Lấy rank của một player
def get_player_rank(player_id):
    rank = r.zrevrank("game:leaderboard", player_id)
    return rank + 1 if rank is not None else None

# Lấy players xung quanh một rank
def get_players_around_rank(player_id, range=5):
    rank = r.zrevrank("game:leaderboard", player_id)
    if rank is None:
        return []
    
    start = max(0, rank - range)
    end = rank + range
    return r.zrevrange("game:leaderboard", start, end, withscores=True)

# Publisher
def publish_notification(channel, message):
    r.publish(channel, json.dumps(message))

# Subscriber
def subscribe_to_notifications():
    pubsub = r.pubsub()
    pubsub.subscribe('notifications')
    
    for message in pubsub.listen():
        if message['type'] == 'message':
            data = json.loads(message['data'])
            process_notification(data)

# List-based queue
def add_to_queue(queue_name, task):
    r.lpush(queue_name, json.dumps(task))

def process_queue(queue_name):
    while True:
        # Blocking pop - đợi cho đến khi có item
        _, task = r.brpop(queue_name, timeout=1)
        if task:
            process_task(json.loads(task))

from datetime import datetime, timedelta

def check_rate_limit(user_id, max_requests=100, window_seconds=60):
    """
    Sliding window rate limiter
    Cho phép max_requests trong window_seconds
    """
    now = datetime.now().timestamp()
    window_start = now - window_seconds
    
    key = f"rate_limit:{user_id}"
    
    # Xóa các requests cũ ngoài window
    r.zremrangebyscore(key, 0, window_start)
    
    # Đếm số requests trong window
    request_count = r.zcard(key)
    
    if request_count >= max_requests:
        return False, 0  # Rate limit exceeded
    
    # Thêm request hiện tại
    r.zadd(key, {now: now})
    r.expire(key, window_seconds)
    
    remaining = max_requests - request_count - 1
    return True, remaining

# Sử dụng trong API
def api_endpoint(user_id):
    allowed, remaining = check_rate_limit(user_id, max_requests=100, window_seconds=60)
    
    if not allowed:
        return {"error": "Rate limit exceeded"}, 429
    
    # Process request
    return {"data": "...", "rate_limit_remaining": remaining}, 200

import uuid
import time

def acquire_lock(lock_name, timeout=10):
    """
    Acquire a distributed lock
    Returns lock_id if successful, None otherwise
    """
    lock_id = str(uuid.uuid4())
    lock_key = f"lock:{lock_name}"
    
    # SET với NX (only if not exists) và EX (expiration)
    acquired = r.set(lock_key, lock_id, nx=True, ex=timeout)
    
    return lock_id if acquired else None

def release_lock(lock_name, lock_id):
    """
    Release lock only if we own it
    """
    lock_key = f"lock:{lock_name}"
    
    # Lua script để atomic check và delete
    lua_script = """
    if redis.call("get", KEYS[1]) == ARGV[1] then
        return redis.call("del", KEYS[1])
    else
        return 0
    end
    """
    
    return r.eval(lua_script, 1, lock_key, lock_id)

# Sử dụng
def critical_section():
    lock_id = acquire_lock("my_resource", timeout=10)
    
    if lock_id:
        try:
            # Perform critical operations
            process_shared_resource()
        finally:
            release_lock("my_resource", lock_id)
    else:
        print("Could not acquire lock")

# Update package index
sudo apt update

# Cài đặt Redis
sudo apt install redis-server

# Kiểm tra version
redis-server --version

# Start Redis service
sudo systemctl start redis-server

# Enable Redis khởi động cùng hệ thống
sudo systemctl enable redis-server

# Kiểm tra status
sudo systemctl status redis-server

# Sử dụng Homebrew
brew install redis

# Start Redis
brew services start redis

# Hoặc chạy foreground
redis-server

# Pull Redis image
docker pull redis:latest

# Chạy Redis container
docker run --name my-redis -p 6379:6379 -d redis

# Chạy với persistence
docker run --name my-redis \
  -p 6379:6379 \
  -v redis-data:/data \
  -d redis redis-server --appendonly yes

# Connect vào Redis CLI
docker exec -it my-redis redis-cli

# Bind address (mặc định localhost)
bind 127.0.0.1

# Port (mặc định 6379)
port 6379

# Enable password authentication
requirepass your_strong_password_here

# Max memory limit
maxmemory 256mb

# Eviction policy khi đầy memory
maxmemory-policy allkeys-lru

# Enable AOF persistence
appendonly yes
appendfilename "appendonly.aof"

# RDB snapshots
save 900 1      # Save nếu có ít nhất 1 change trong 900 seconds
save 300 10     # Save nếu có ít nhất 10 changes trong 300 seconds
save 60 10000   # Save nếu có ít nhất 10000 changes trong 60 seconds

# Log level
loglevel notice
logfile /var/log/redis/redis-server.log

pip install redis

import redis

# Kết nối đơn giản
r = redis.Redis(host='localhost', port=6379, db=0, password='your_password')

# Kết nối với connection pool
pool = redis.ConnectionPool(host='localhost', port=6379, db=0, max_connections=10)
r = redis.Redis(connection_pool=pool)

# Test connection
r.ping()  # Returns True nếu connected

npm install redis

const redis = require('redis');

const client = redis.createClient({
  host: 'localhost',
  port: 6379,
  password: 'your_password'
});

client.on('connect', () => {
  console.log('Connected to Redis');
});

client.on('error', (err) => {
  console.log('Redis error:', err);
});

composer require predis/predis

<?php
require 'vendor/autoload.php';

$client = new Predis\Client([
    'scheme' => 'tcp',
    'host'   => '127.0.0.1',
    'port'   => 6379,
    'password' => 'your_password'
]);

$client->set('key', 'value');
echo $client->get('key');

# ❌ Không tối ưu - lưu JSON string
r.set("user:1000", json.dumps({"name": "John", "age": 30, "email": "john@example.com"}))

# ✅ Tốt hơn - dùng Hash
r.hset("user:1000", mapping={
    "name": "John",
    "age": 30,
    "email": "john@example.com"
})

# Benefits: Có thể update từng field riêng
r.hset("user:1000", "age", 31)

# Set key với expiration
r.setex("session:abc123", 3600, "user_data")  # Expire sau 1 giờ

# Hoặc set expiration sau
r.set("key", "value")
r.expire("key", 3600)

# Check TTL còn lại
ttl = r.ttl("key")  # Returns seconds remaining, -1 nếu không expire, -2 nếu key không tồn tại

# ❌ Không tối ưu - multiple roundtrips
for i in range(1000):
    r.set(f"key:{i}", f"value:{i}")

# ✅ Tối ưu - single roundtrip
pipe = r.pipeline()
for i in range(1000):
    pipe.set(f"key:{i}", f"value:{i}")
pipe.execute()

# Kiểm tra memory usage
redis-cli INFO memory

# Kiểm tra size của specific key
redis-cli MEMORY USAGE key_name

# Xem các keys lớn nhất
redis-cli --bigkeys

import redis
from redis.exceptions import ConnectionError, TimeoutError

try:
    r = redis.Redis(
        host='localhost',
        port=6379,
        socket_timeout=5,
        socket_connect_timeout=5,
        retry_on_timeout=True
    )
    
    result = r.get('key')
    
except ConnectionError:
    # Fallback to database hoặc return cached data
    print("Redis connection failed")
    
except TimeoutError:
    print("Redis operation timeout")
    
except Exception as e:
    print(f"Unexpected error: {e}")

# Good naming conventions
"user:{user_id}:profile"
"session:{session_id}"
"cache:product:{product_id}"
"queue:emails:pending"
"lock:resource:{resource_id}"

# Với namespace
"app_name:user:1000:profile"
"app_name:cache:api_response:12345"

# redis.conf

# 1. Bind to specific interfaces
bind 127.0.0.1 ::1

# 2. Enable password
requirepass very_strong_password_here

# 3. Rename dangerous commands
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command CONFIG "CONFIG_a8b4c9d2e3"

# 4. Disable protected mode for production
protected-mode yes

# 5. Use TLS/SSL for encryption
tls-port 6380
tls-cert-file /path/to/redis.crt
tls-key-file /path/to/redis.key

# Eviction policies
maxmemory-policy allkeys-lru    # Remove least recently used keys
maxmemory-policy volatile-lru   # Remove LRU keys với expire set
maxmemory-policy allkeys-lfu    # Remove least frequently used keys
maxmemory-policy volatile-lfu   # Remove LFU keys với expire set
maxmemory-policy allkeys-random # Remove random keys
maxmemory-policy volatile-random # Remove random keys với expire set
maxmemory-policy volatile-ttl   # Remove keys với soonest expiration
maxmemory-policy noeviction     # Return errors when memory limit reached

# Lua script cho atomic complex operation
lua_script = """
local current = redis.call('GET', KEYS[1])
if current then
    return redis.call('SET', KEYS[1], current + ARGV[1])
else
    return redis.call('SET', KEYS[1], ARGV[1])
end
"""

# Register script
increment_script = r.register_script(lua_script)

# Execute
result = increment_script(keys=['counter'], args=[5])

# Enable slow log
redis-cli CONFIG SET slowlog-log-slower-than 10000  # 10ms

# View slow queries
redis-cli SLOWLOG GET 10

# Check slow log length
redis-cli SLOWLOG LEN