Python Redis: Hướng dẫn cho người mới bắt đầu

Kết hợp Redis với Python là một lựa chọn mạnh mẽ cho kỹ sư dữ liệu muốn xây dựng hệ thống hiệu năng cao, có khả năng mở rộng và dễ bảo trì. Dù bạn đang tối ưu lớp bộ nhớ đệm, quản lý luồng sự kiện theo thời gian thực hay triển khai khóa phân tán, Redis mang đến một giải pháp linh hoạt và hiệu quả.

Trong hướng dẫn này, chúng tôi sẽ trình bày những kiến thức cơ bản về sử dụng Redis với Python để giúp bạn tích hợp liền mạch vào quy trình làm việc kỹ thuật dữ liệu.

Python Redis là gì?

Redis là kho cấu trúc dữ liệu trong bộ nhớ, mã nguồn mở, được dùng làm cơ sở dữ liệu, bộ nhớ đệm và trình môi giới thông điệp. Tên đầy đủ là Remote Dictionary Server và ban đầu được thiết kế như một hệ thống lưu trữ key-value với thời gian truy cập cực nhanh.

Nó hỗ trợ nhiều cấu trúc dữ liệu như chuỗi, hash, list, set và sorted set với truy vấn theo khoảng. Redis còn cung cấp các tính năng nâng cao như giao dịch (transactions), nhắn tin pub/sub, chạy script Lua, và khả năng sao chép, cụm hóa tích hợp sẵn để tăng tính sẵn sàng và khả năng mở rộng.

Các trường hợp sử dụng phổ biến của Redis

Các trường hợp sử dụng tiềm năng của Redis rất rộng và đa dạng.

Một số trường hợp phổ biến trong kỹ thuật dữ liệu gồm: 

• Caching: Tăng tốc truy vấn cơ sở dữ liệu và phản hồi API.
• Hàng đợi thông điệp: Vận hành kiến trúc hướng sự kiện và pipeline xử lý job.
• Phân tích thời gian thực: Xử lý và phân tích dữ liệu streaming với độ trễ tối thiểu.
• Bảng xếp hạng: Xếp hạng và truy xuất thực thể điểm cao một cách hiệu quả.
• Lưu trữ phiên: Duy trì quản lý trạng thái phiên nhanh và có khả năng mở rộng.
• Quản lý hàng đợi công việc: Đảm bảo lập lịch và thực thi tác vụ hiệu quả.
• Lập chỉ mục không gian địa lý: Lưu trữ và truy vấn dữ liệu theo vị trí.

Redis cũng thường được dùng kết hợp với các công nghệ khác như web server (ví dụ NGINX), cơ sở dữ liệu (ví dụ MySQL) và hệ thống nhắn tin (ví dụ Kafka) để tối ưu hiệu năng và khả năng mở rộng.

Vì sao dùng Redis với Python?

Python là ngôn ngữ chủ đạo trong kỹ thuật dữ liệu nhờ tính linh hoạt, hệ sinh thái phong phú và khả năng tích hợp dễ dàng với công nghệ dữ liệu lớn. 

Kết hợp với Redis có thể mang lại nhiều lợi ích cho ứng dụng của bạn:

• Hiệu năng nhanh: Do Redis lưu dữ liệu trong bộ nhớ, nó mang lại thời gian truy cập nhanh hơn đáng kể so với các cơ sở dữ liệu truyền thống lưu dữ liệu trên đĩa. Điều này lý tưởng cho các tình huống yêu cầu hiệu năng cao như caching và ứng dụng thời gian thực.
• Khả năng mở rộng: Redis được thiết kế hướng đến khả năng mở rộng, giúp xử lý lượng dữ liệu lớn mà không đánh đổi hiệu năng.
• Dễ sử dụng: Cú pháp đơn giản của Python và hệ sinh thái thư viện phong phú giúp làm việc với Redis dễ dàng. Thư viện client chính thức Redis-py cũng cung cấp giao diện thân thiện để tương tác với Redis ngay trong mã Python của bạn.

Redis-py là gì?

Redis-py là thư viện client chính thức của Redis cho Python. Nó cung cấp giao diện thân thiện để giao tiếp với Redis ngay trong mã Python của bạn.

Một số tính năng chính gồm:

• Hỗ trợ tất cả kiểu dữ liệu của Redis
• Hỗ trợ pipeline và transaction cho các thao tác hiệu quả và nguyên tử
• Hỗ trợ nhắn tin pub/sub
• Tự động mã hóa/giải mã dữ liệu giữa bytes, string và các kiểu Python khác
• Hỗ trợ chế độ cluster để làm việc với các cụm Redis

Thiết lập Redis cho phát triển Python

Hãy xem cách chúng ta có thể tự thiết lập Redis bằng Python.

Có ba cách chính để chạy Redis:

1. Docker (Khuyến nghị cho kỹ sư dữ liệu)
2. Windows Subsystem for Linux (WSL)
3. Bản dựng của bên thứ ba (ví dụ, Memurai, tporadowski/redis)

Cách A: Dùng Docker

Trước hết, khi dùng Docker, bạn cần cài đặt Docker Desktop trên máy. Bạn có thể tải từ trang DockerHub.

Sau khi cài Docker, mở command prompt và nhập lệnh sau.

docker pull redisĐược hỗ trợ bởi

Tiếp theo, chúng ta sẽ khởi chạy một container mới.

docker run --name my-redis -p 6379:6379 -d redisĐược hỗ trợ bởi

docker pull redis tải image Redis chính thức mới nhất. docker run --name my-redis -p 6379:6379 -d redis khởi chạy một container mới tên là my-redis. Tham số -p 6379:6379 ánh xạ cổng 6379 của máy cục bộ đến cổng 6379 của container, nhờ đó bạn có thể kết nối tới Redis tại localhost:6379. Cờ -d chạy container ở chế độ nền (detached).

Để kiểm tra, chạy:

docker exec -it my-redis redis-cli pingĐược hỗ trợ bởi

Bạn sẽ nhận phản hồi PONG.

Cách B: Dùng Windows Subsystem for Linux (WSL)

Với máy Windows, một cách khác là dùng Windows Subsystem để cài đặt. Cách này sẽ sử dụng Linux để thực hiện cài đặt.

wsl --installĐược hỗ trợ bởi

Lệnh này cài đặt và cấu hình bản phân phối Ubuntu mặc định trong WSL. Khởi động lại nếu được yêu cầu.

Sau đó, mở terminal Ubuntu (từ Microsoft Store hoặc gõ wsl trong PowerShell) và chạy:

sudo apt-get update
sudo apt-get install redis-serverĐược hỗ trợ bởi

Tiếp theo, khởi động máy chủ Redis.

sudo service redis-server startĐược hỗ trợ bởi

Hãy kiểm tra xem server đã chạy chưa.

redis-cli pingĐược hỗ trợ bởi

Mô tả chi tiết các lệnh đã dùng ở trên:

• sudo apt-get update lấy về định nghĩa gói mới nhất.
• sudo apt-get install redis-server cài Redis trong môi trường Ubuntu.
• sudo service redis-server start khởi động dịch vụ Redis ngay lập tức.
• redis-cli ping kiểm tra kết nối tới Redis cục bộ, trả về PONG nếu thành công.

Cách C: Bản dựng của bên thứ ba

• Memurai: Memurai.com
• tporadowski/redis: Bản phát hành trên GitHub

Các giải pháp này cung cấp binary gốc cho Windows. Sau khi tải và cài đặt hoặc giải nén, chạy:

redis-server.exeĐược hỗ trợ bởi

Khi khởi chạy, redis-server.exe sẽ in log cho biết đang lắng nghe tại 127.0.0.1:6379.

Bạn có thể xác nhận bằng cách dùng CLI kèm theo (nếu có):

redis-cli.exe pingĐược hỗ trợ bởi

Nếu thành công, bạn sẽ thấy kết quả PONG.

Cài đặt thư viện redis-py

Tiếp theo, bạn cần cài thư viện redis-py để truy cập cơ sở dữ liệu bằng Python. Trước khi cài, hãy đảm bảo bạn đã cài đặt riêng cả Python và Redis.

pip install redisĐược hỗ trợ bởi

Lệnh này tải và cài thư viện client Redis cho Python (redis-py) từ PyPI. Nếu bạn dùng môi trường ảo, hãy kích hoạt trước khi chạy lệnh.

Xác minh bằng:

python -c "import redis; print(redis.__version__)"Được hỗ trợ bởi

Lệnh sẽ in ra số phiên bản (ví dụ, 5.2.1).

Thiết lập máy chủ Redis

Nếu bạn đã làm theo một trong các cách trên (Docker, WSL, hoặc bản dựng bên thứ ba), bây giờ bạn đã có máy chủ Redis chạy trên localhost:6379. Như vậy là đủ cho phát triển cục bộ trên Windows.

Làm việc với cấu trúc dữ liệu Redis

Dưới đây là các ví dụ Python minh họa cách kết nối và thao tác với các kiểu dữ liệu khác nhau của Redis. Mỗi khối mã đều có chú thích giải thích cách hoạt động của phương thức hoặc lệnh.

Chuỗi (Strings) trong Redis

import redis

# Instantiate a Redis client, connecting to localhost on port 6379
r = redis.Redis(
    host='localhost',
    port=6379,
    db=0  # The default Redis database index
)

# 1. SET command: store a string under 'mykey'
r.set("mykey", "hello from Windows")

# 2. GET command: retrieve the value stored at 'mykey'
value = r.get("mykey")
print(value)   # Output is b'hello from Windows', since redis-py returns bytes.

# 3. Convert bytes to string
print(value.decode())  # prints "hello from Windows"

# 4. DEL command: remove 'mykey' from Redis
r.delete("mykey")Được hỗ trợ bởi

Chúng ta tạo một đối tượng Redis kết nối tới máy chủ Redis cục bộ.

• r.set("mykey", "hello from Windows") lưu chuỗi "hello from Windows" dưới khóa "mykey".
• r.get("mykey") lấy giá trị được lưu trong mykey. Redis trả về bytes, nên chúng ta giải mã để có kết quả hiển thị dễ đọc.
• r.delete("mykey") xóa hoàn toàn khóa mykey.

Ví dụ: Lưu trữ và truy xuất phiên người dùng

Dưới đây là ví dụ về quản lý phiên người dùng:

import uuid

def store_user_session(user_id):
    """
    Generates a unique session token (UUID) for a user and stores it in Redis.
    The session is stored under the key pattern: user:{user_id}:session
    """
    session_key = f"user:{user_id}:session"
    token = str(uuid.uuid4())   # Generate a random UUID as a session token
    r.set(session_key, token)   # Store token in Redis
    return token

def get_user_session(user_id):
    """
    Retrieves the stored session token for the given user_id.
    Returns None if the session does not exist or is expired.
    """
    session_key = f"user:{user_id}:session"
    token = r.get(session_key)
    return token.decode('utf-8') if token else None

def delete_user_session(user_id):
    """
    Deletes the session entry from Redis for the specified user_id.
    """
    session_key = f"user:{user_id}:session"
    r.delete(session_key)

# Usage demonstration
session_token = store_user_session(1001)
print(f"Stored session token: {session_token}")

retrieved_token = get_user_session(1001)
print(f"Retrieved session token: {retrieved_token}")

delete_user_session(1001)
print(f"Session after delete: {get_user_session(1001)}")  # Should be None or emptyĐược hỗ trợ bởi

store_user_session(user_id): Tạo ID duy nhất toàn cục qua uuid.uuid4() và lưu dưới khóa theo người dùng. get_user_session(user_id): Đọc lại token phiên. Nếu None, phiên thiếu hoặc đã hết hạn. delete_user_session(user_id): Xóa khóa phiên khỏi Redis, tương đương đăng xuất người dùng.

Danh sách (Lists) trong Redis

List của Redis là dãy chuỗi có thứ tự. Chúng cho phép thao tác ở cả hai đầu, hữu ích cho hàng đợi, ngăn xếp hoặc log.

# LPUSH: Push an element to the head (left) of the list
r.lpush("task_queue", "task1")

# RPUSH: Push an element to the tail (right) of the list
r.rpush("task_queue", "task2")
r.rpush("task_queue", "task3")

# LPOP: Pop (remove and return) the element at the head
task = r.lpop("task_queue")
print(task)  # b'task1'

# Optional: RPOP removes and returns the element at the tail
task = r.rpop("task_queue")
print(task)  # b'task3'Được hỗ trợ bởi

lpush("task_queue", "task1") thêm "task1" vào bên trái list "task_queue". rpush("task_queue", "task2") và rpush("task_queue", "task3") thêm task vào bên phải. lpop("task_queue") và rpop("task_queue") loại bỏ và trả về phần tử ở mỗi đầu tương ứng.

Ví dụ: Triển khai hàng đợi đơn giản dùng Redis

def enqueue_task(queue_name, task):
    """
    Appends a task to the end (right) of the Redis list named queue_name.
    """
    r.rpush(queue_name, task)

def dequeue_task(queue_name):
    """
    Removes a task from the front (left) of the Redis list named queue_name.
    Returns the task as a string, or None if the queue is empty.
    """
    task = r.lpop(queue_name)
    return task.decode('utf-8') if task else None

# Example usage:
enqueue_task("my_queue", "send_email")
enqueue_task("my_queue", "generate_report")

while True:
    task = dequeue_task("my_queue")
    if not task:
        print("No more tasks in queue.")
        break
    print(f"Processing task: {task}")Được hỗ trợ bởi

enqueue_task luôn thêm tác vụ mới vào cuối danh sách, mô phỏng hàng đợi FIFO truyền thống. dequeue_task loại bỏ tác vụ ở đầu. Nếu list trống, hàm trả về None.

Vòng lặp while xử lý tác vụ cho đến khi hàng đợi trống, rồi dừng.

Hash trong Redis

Hash tương tự từ điển (dictionary) trong Python nhưng được lưu trong Redis. Chúng phù hợp để gom nhóm các trường liên quan (ví dụ, thông tin người dùng).

# HSET: Store 'name' and 'email' fields for a user hash key
r.hset("user:1001", "name", "Alice")
r.hset("user:1001", "email", "[email protected]")

# HGET: Retrieve a single field from the hash
email = r.hget("user:1001", "email")
print(email.decode('utf-8'))  # [email protected]

# HDEL: Remove a field from the hash
r.hdel("user:1001", "email")Được hỗ trợ bởi

hset("user:1001", "name", "Alice") đặt trường "name" với giá trị "Alice" trong hash tại khóa "user:1001". hget("user:1001", "email") lấy trường "email". hdel("user:1001", "email") xóa trường "email" khỏi hash đó.

Ví dụ: Lưu trữ và truy cập hồ sơ người dùng có cấu trúc

def create_user_profile(user_id, name, email):
    """
    Creates a user profile in Redis under the key 'user:{user_id}'.
    'name' and 'email' are stored as separate fields in the hash.
    """
    user_key = f"user:{user_id}"
    r.hset(user_key, mapping={"name": name, "email": email})

def get_user_profile(user_id):
    """
    Retrieves and returns all fields in the user profile hash
    as a Python dictionary. Keys and values are decoded from bytes.
    """
    user_key = f"user:{user_id}"
    profile_data = r.hgetall(user_key)
    return {k.decode('utf-8'): v.decode('utf-8') for k, v in profile_data.items()}

def delete_user_profile(user_id):
    """
    Deletes the entire user profile key from Redis.
    """
    user_key = f"user:{user_id}"
    r.delete(user_key)

# Usage demonstration
create_user_profile(1002, "Bob", "[email protected]")
print(get_user_profile(1002))  # e.g. {'name': 'Bob', 'email': '[email protected]'}
delete_user_profile(1002)Được hỗ trợ bởi

Chúng ta lưu tên và email của người dùng trong một hash. mapping={"name": name, "email": email} dùng khả năng của redis-py để đặt nhiều trường cùng lúc. r.hgetall(user_key) truy xuất tất cả trường và giá trị, trả về dạng từ điển bytes mà chúng ta sẽ giải mã thành chuỗi. delete_user_profile xóa toàn bộ khóa hash.

Set và Sorted Set

Dữ liệu trong Redis có thể được quản lý bằng set hoặc sorted set. 

Set là tập hợp các giá trị duy nhất, còn sorted set là tập hợp các cặp khóa-giá trị với một điểm số (score) gắn với mỗi giá trị. Các cấu trúc dữ liệu này cung cấp cách lưu trữ và truy xuất hiệu quả, hữu ích cho ứng dụng cần tra cứu nhanh.

Set

Set trong Redis giống như tập hợp trong toán học – chứa các phần tử duy nhất, không cho phép trùng lặp. Set có thể dùng để mô hình hóa quan hệ giữa các thực thể, như người dùng đã thích một bài đăng trên mạng xã hội.

Ví dụ về set:

# SADD: Add multiple members to a set
r.sadd("tags:python", "redis", "windows", "backend")

# SMEMBERS: Retrieve all unique members in the set
tags = r.smembers("tags:python")
print(tags)  # {b'redis', b'windows', b'backend'}Được hỗ trợ bởi

Set của Redis đảm bảo tính duy nhất của phần tử. Thêm trùng lặp sẽ không có tác dụng.

Kết quả của smembers là một set Python của bytes.

Sorted set

Sorted set trong Redis tương tự set thường, nhưng mỗi phần tử có kèm một điểm số. Điều này cho phép sắp xếp và xếp hạng hiệu quả trên tập dữ liệu.

Sorted set thường được dùng cho bảng xếp hạng, nơi điểm số biểu thị thứ hạng hoặc điểm của người chơi.

Ví dụ về sorted set:

# ZADD: Add members with scores
r.zadd("leaderboard", {"player1": 10, "player2": 20})

# ZRANGE: Retrieve members in ascending order of score
leaders = r.zrange("leaderboard", 0, -1, withscores=True)
print(leaders)  # [(b'player1', 10.0), (b'player2', 20.0)]Được hỗ trợ bởi

Sorted set lưu các phần tử theo thứ tự xác định bởi điểm số. zrange("leaderboard", 0, -1, withscores=True) trả về tất cả phần tử từ hạng 0 đến cuối cùng, kèm điểm số.

Ví dụ: Quản lý thẻ hoặc bảng xếp hạng

Sorted set hữu ích khi quản lý thẻ hoặc tạo bảng xếp hạng. 

def add_tag(post_id, tag):
    """
    Adds a 'tag' to the set of tags belonging to a specific post.
    Each post has its own set under 'post:{post_id}:tags'.
    """
    r.sadd(f"post:{post_id}:tags", tag)

def get_tags(post_id):
    """
    Retrieves all tags for a specific post, decoding the bytes into strings.
    """
    raw_tags = r.smembers(f"post:{post_id}:tags")
    return {tag.decode('utf-8') for tag in raw_tags}

def update_leaderboard(player, score):
    """
    Updates or inserts a player's score in the 'game:leaderboard' sorted set.
    A higher score indicates a better position if sorting descending.
    """
    r.zadd("game:leaderboard", {player: score})

def get_leaderboard():
    """
    Returns an ascending list of (player, score) tuples from the leaderboard.
    To invert the sorting (highest first), you'd use ZREVRANGE.
    """
    entries = r.zrange("game:leaderboard", 0, -1, withscores=True)
    return [(player.decode('utf-8'), score) for player, score in entries]

# Usage demonstration
add_tag(123, "python")
add_tag(123, "redis")
print(get_tags(123))

update_leaderboard("Alice", 300)
update_leaderboard("Bob", 450)
print(get_leaderboard())Được hỗ trợ bởi

add_tag và get_tags minh họa hệ thống gắn thẻ một-nhiều, lưu trữ thẻ trong Set. update_leaderboard và get_leaderboard cho thấy cách triển khai bảng xếp hạng trò chơi.

Tính năng Redis trong ứng dụng Python

Redis có một số tính năng khiến nó phổ biến cho lưu trữ dữ liệu trong ứng dụng Python: hàng đợi, khóa và bộ nhớ đệm. 

Dưới đây là cách triển khai bằng Python:

Redis làm hàng đợi (có blocking)

Hãy khám phá việc dùng Redis như một hàng đợi với blocking bằng BLPOP.

BLPOP là thao tác blocking, chờ đến khi có phần tử trong list.

def blocking_consumer(queue_name):
    """
    Continuously listens to the specified queue (Redis list) using BLPOP,
    which blocks until new items are pushed. Once an item arrives,
    it is removed from the queue and processed.
    """
    print(f"Waiting on queue: {queue_name}")
    while True:
        result = r.blpop(queue_name)
        if result:
            list_name, task_bytes = result
            task = task_bytes.decode('utf-8')
            print(f"Received task: {task}")
        else:
            print("Queue is empty or an error occurred.")
            break

def enqueue_task(queue_name, task):
    """
    Pushes a task to the end of a Redis list (queue).
    """
    r.rpush(queue_name, task)

# Example usage:
enqueue_task("blocking_queue", "task_block_1")
enqueue_task("blocking_queue", "task_block_2")

# In a real application, the consumer might run in a separate thread or process
blocking_consumer("blocking_queue")Được hỗ trợ bởi

blocking_consumer dùng blpop trong vòng lặp. Nếu list trống, blpop sẽ chờ đến khi có phần tử mới được đẩy vào.

Khi nhận phần tử, nó được loại bỏ khỏi list và in ra.

Cách tiếp cận này lý tưởng cho mô hình producer-consumer nơi worker xử lý tác vụ ngay khi có.

Triển khai khóa trong Redis

Khóa phân tán ngăn nhiều client hoặc tiến trình đồng thời sửa cùng một tài nguyên. Redis giúp tránh điều kiện tranh chấp trong môi trường phân tán.

import time
from redis.exceptions import LockError

def process_critical_section():
    """
    Acquires a lock named 'resource_lock' with a timeout of 10 seconds.
    The lock automatically expires after 10 seconds to prevent deadlocks.
    """
    lock = r.lock("resource_lock", timeout=10)
    try:
        # Attempt to acquire the lock, wait for up to 5 seconds if another process holds it
        acquired = lock.acquire(blocking=True, blocking_timeout=5)
        if acquired:
            print("Lock acquired; performing critical operation...")
            time.sleep(3)  # Simulate some operation
        else:
            print("Failed to acquire lock within 5 seconds.")
    except LockError:
        print("A LockError occurred, possibly releasing already released lock.")
    finally:
        # Always release the lock in a finally block to ensure cleanup
        lock.release()
        print("Lock released.")

# Usage demonstration
process_critical_section()Được hỗ trợ bởi

Chúng ta tạo một khóa với timeout=10, nghĩa là nếu khóa không được giải phóng thủ công, Redis sẽ tự động gỡ sau 10 giây để tránh khóa chết (deadlock). lock.acquire(blocking=True, blocking_timeout=5) cố gắng chiếm khóa trong 5 giây trước khi bỏ cuộc. Sau khi xong, lock.release() giải phóng tài nguyên cho tiến trình khác.

Caching với Redis

Caching là kịch bản phổ biến: lưu dữ liệu truy cập thường xuyên trong bộ nhớ để giảm tải cho cơ sở dữ liệu hoặc API bên ngoài.

import requests
import json

def get_user_data(user_id):
    """
    Retrieves user data from a hypothetical API endpoint.
    If the data is found in Redis (cache), use that. Otherwise, call the API,
    store the response in Redis with a 60-second expiration, and return it.
    """
    cache_key = f"user_data:{user_id}"
    cached_data = r.get(cache_key)
    if cached_data:
        print("Cache hit!")
        return json.loads(cached_data)

    print("Cache miss. Fetching from API...")
    response = requests.get(f"https://api.example.com/users/{user_id}")
    user_info = response.json()

    # Store in Redis for 60 seconds
    r.setex(cache_key, 60, json.dumps(user_info))
    return user_info

# Usage
user = get_user_data(42)  # First call => cache miss
user_again = get_user_data(42)  # Subsequent call => cache hitĐược hỗ trợ bởi

Chúng ta kiểm tra xem user_data:{user_id} có tồn tại trong Redis không. Nếu có, đó là cache hit và ta bỏ qua gọi API. Nếu không, ta lấy từ API từ xa rồi dùng setex (set + hết hạn) 60 giây. Các lần gọi tiếp theo trong khoảng thời gian này sẽ lấy dữ liệu từ cache, giảm độ trễ.

Chủ đề nâng cao trong Redis

Bạn đã nắm vững Redis? Hãy đi tiếp một số chủ đề nâng cao.

Sử dụng Pub/Sub với Redis

Pub/Sub (Publish/Subscribe) là mẫu nhắn tin phổ biến cho giao tiếp thời gian thực. Publisher gửi thông điệp đến một kênh và mọi subscriber của kênh đó sẽ nhận thông điệp.

import threading

def subscriber(r, channel_name):
    """
    Subscribes to the given Redis channel and listens for messages.
    When a new message is published on that channel, it is printed.
    """
    pubsub = r.pubsub()
    pubsub.subscribe(channel_name)
    print(f"Subscribed to {channel_name}")

    # pubsub.listen() yields messages from the subscribed channel(s) in real time
    for message in pubsub.listen():
        if message['type'] == 'message':
            print(f"Received message: {message['data'].decode('utf-8')}")

def publisher(r, channel_name, message):
    """
    Publishes a message to the specified Redis channel.
    All subscribers to this channel immediately receive the message.
    """
    r.publish(channel_name, message)

# Example usage
channel = "updates"

# Start subscriber in a separate thread to avoid blocking the main thread
sub_thread = threading.Thread(target=subscriber, args=(r, channel))
sub_thread.start()

# Publish messages
publisher(r, channel, "Hello from Windows!")
publisher(r, channel, "Another update!")Được hỗ trợ bởi

pubsub = r.pubsub() tạo một đối tượng PubSub. pubsub.subscribe(channel_name) yêu cầu Redis gửi thông điệp từ kênh đó tới PubSub. pubsub.listen() là một iterator vô hạn, phát thông điệp khi đến. r.publish(channel_name, message) gửi thông điệp tới mọi subscriber của channel_name.

Thiết lập thời hạn (expire) cho khóa trong Redis

Redis hỗ trợ time-to-live (TTL). Điều này rất cần cho dữ liệu tạm như phiên hoặc cache ngắn hạn.

# EXPIRE: Set a 30-second expiration on a key
r.set("temp_key", "some value")
r.expire("temp_key", 30)

# SETEX: Combined set + expire in one command
r.setex("temp_key2", 60, "another value")Được hỗ trợ bởi

r.expire("temp_key", 30) đặt TTL 30 giây. Sau 30 giây, temp_key sẽ tự động bị xóa. r.setex("temp_key2", 60, "another value") là lệnh tắt đặt khóa kèm thời hạn cùng lúc.

Ví dụ: Hết hạn phiên

Ví dụ sau minh họa cách dùng khóa có thời hạn để đặt phiên tự hết hạn sau một khoảng thời gian xác định.

def store_session_with_expiry(user_id, token, ttl=3600):
    """
    Stores a session token for a specific user with a time-to-live (TTL).
    By default, the session expires after 1 hour (3600 seconds).
    """
    session_key = f"user:{user_id}:session"
    r.setex(session_key, ttl, token)

def get_session_with_expiry(user_id):
    """
    Retrieves the session token for the user. Returns None if the key doesn't exist
    or if it has expired.
    """
    session_key = f"user:{user_id}:session"
    token = r.get(session_key)
    return token.decode('utf-8') if token else None

# Usage
store_session_with_expiry(2001, "session_token_abc", 3600)
retrieved_token = get_session_with_expiry(2001)
print(f"Retrieved token: {retrieved_token}")Được hỗ trợ bởi

store_session_with_expiry sử dụng setex để lưu user:{user_id}:session với TTL chỉ định. Nếu bạn không truyền TTL, khóa có thể tồn tại vô thời hạn.

Khi TTL hết hạn, Redis tự động xóa khóa, khiến không thể truy xuất phiên.

Thực hành tốt khi dùng Redis với Python

Làm việc với Redis cần một số lưu ý và thực hành tốt để đảm bảo hiệu năng tối ưu và tránh lỗi thường gặp.

Một số gợi ý cần nhớ:

• Cấu hình đúng các tùy chọn lưu bền dữ liệu để đảm bảo an toàn.
• Theo dõi việc sử dụng bộ nhớ để tránh lỗi tràn bộ nhớ.
• Dùng pipelining cho các thao tác lô hiệu quả.
• Theo dõi độ trễ mạng vì nó có thể ảnh hưởng hiệu năng khi làm việc với Redis từ xa.
• Bảo mật kết nối Redis bằng mật khẩu và tường lửa.

Kết luận

Redis là công cụ mạnh mẽ và linh hoạt để quản lý dữ liệu trong ứng dụng Python. Việc dùng Python với Redis mở ra nhiều ứng dụng và trường hợp sử dụng, từ caching dữ liệu đến quản lý hàng đợi. 

Muốn tìm hiểu thêm về Redis? Khóa học Giới thiệu về NoSQL của chúng tôi sẽ giúp bạn học cách xử lý dữ liệu key-value. Quan tâm đến Python hơn? Vậy Lộ trình Kỹ năng Nền tảng Dữ liệu với Python có thể là điểm khởi đầu tốt nhất.