Redis Use Cases: Caching, Queues, and Rate Limiting

You've built a web application that works well in development, but as traffic grows, you notice slow response times and database overload. The culprit is often repeated expensive operations: fetching the same data from the database, processing tasks synchronously, or allowing abusive request rates. Redis, an in-memory data store, offers elegant solutions for these problems. In this article, we'll explore three practical Redis use cases: caching, queues, and rate limiting. You'll learn how to implement each pattern with code examples and understand when to apply them.

Why Redis?

Redis is an open-source, in-memory key-value store known for its speed and versatility. It supports data structures like strings, lists, sets, and hashes, making it suitable for various tasks beyond simple caching. Because it keeps data in memory, Redis delivers sub-millisecond latency, which is ideal for high-performance scenarios. It also provides persistence options, so you don't lose data on restart. Let's dive into the three use cases.

1. Caching with Redis

Caching is the most common Redis use case. The idea is simple: store the results of expensive operations (like database queries or API calls) in Redis, and serve them directly for subsequent requests. This reduces load on your primary database and speeds up response times.

How to Implement Caching

1. Check the cache: Before hitting the database, query Redis for the data using a unique key (e.g., user:123).
2. If found (cache hit): Return the cached data immediately.
3. If not found (cache miss): Fetch data from the database, store it in Redis with an expiration time (TTL), and return it.

Here's a Python example using redis-py:

import redis
import json

r = redis.Redis(host='localhost', port=6379, db=0)

def get_user(user_id):
    cache_key = f'user:{user_id}'
    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)
    # Simulate database fetch
    user = fetch_user_from_db(user_id)
    r.setex(cache_key, 3600, json.dumps(user))  # Cache for 1 hour
    return user

Best practices: Choose meaningful keys, set appropriate TTLs to avoid stale data, and consider cache invalidation strategies. For read-heavy workloads, caching can reduce database load by orders of magnitude.

2. Queues with Redis

Queues decouple time-consuming tasks from the request-response cycle. For example, sending emails, processing images, or generating reports can be done asynchronously. Redis lists or streams are perfect for implementing simple queues.

Implementing a Basic Queue

Use LPUSH to add jobs to the left of a list and BRPOP to block and pop from the right. This creates a FIFO queue.

# Producer: add job
r.lpush('email_queue', json.dumps({'to': 'user@example.com', 'subject': 'Welcome'}))

# Consumer: process jobs
while True:
    _, job = r.brpop('email_queue', timeout=30)
    if job:
        process_email(json.loads(job))

For more advanced needs, Redis Streams provide consumer groups, acknowledgments, and replayability, making them suitable for robust message processing.

3. Rate Limiting with Redis

Rate limiting protects your API from abuse and ensures fair usage. Redis's atomic operations make it easy to implement counters that expire automatically.

Fixed Window Rate Limiting

In a fixed window approach, you allow N requests per time window (e.g., 100 requests per hour per IP). Use INCR and EXPIRE:

def is_allowed(ip, limit=100, window=3600):
    key = f'rate:{ip}'
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current