Redis Use Cases: Caching, Queues, and Rate Limiting

You've built a web application that's gaining traction, but as traffic grows, you notice slow database queries and occasional timeouts. Your server struggles under the load, and users complain about latency. You need a fast, in-memory data store to offload repetitive tasks and manage traffic spikes. Redis is the go-to solution for many backend challenges, and in this article, we'll explore three practical use cases: caching, queues, and rate limiting.

Why Redis?

Redis is an open-source, in-memory key-value store known for its speed and versatility. It supports data structures like strings, hashes, lists, sets, and sorted sets, making it suitable for a wide range of tasks. Unlike traditional databases, Redis keeps data in RAM, delivering sub-millisecond latency. It also offers persistence options, replication, and clustering for high availability.

1. Caching with Redis

Caching is the most common Redis use case. By storing frequently accessed data in Redis, you reduce the load on your primary database and speed up response times. For example, if your application displays a list of popular products, you can cache the query result for a few minutes.

How to Implement Caching

1. Check the cache: Before querying the database, check if the data exists in Redis.
2. If found (cache hit): Return the cached data.
3. If not found (cache miss): Query the database, store the result in Redis with an expiration time (TTL), and return the data.

Here's a Python example using redis-py:

import redis
import json

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

def get_products():
    cache_key = 'products:popular'
    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)
    # Simulate database query
    products = [{'id': 1, 'name': 'Product A'}, {'id': 2, 'name': 'Product B'}]
    r.setex(cache_key, 300, json.dumps(products))  # Cache for 5 minutes
    return products

Best practices: Use meaningful cache keys, set appropriate TTLs, and consider cache invalidation strategies. For frequently changing data, use short TTLs or implement write-through caching.

2. Queues with Redis

Redis lists and streams are excellent for building simple message queues. They allow you to decouple time-consuming tasks (like sending emails or processing images) from the request-response cycle, improving user experience and scalability.

Using Lists as a Queue

You can use LPUSH to add jobs to a list and BRPOP to atomically pop jobs from the other end. This creates a FIFO queue.

Producer:

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

Consumer (in a worker process):

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

Considerations: Redis lists are simple but lack advanced features like acknowledgments. For more robust needs, consider Redis Streams, which support consumer groups and message acknowledgment.

3. Rate Limiting with Redis

Rate limiting protects your API from abuse and ensures fair usage. Redis's atomic operations make it ideal for implementing rate limiters. A common algorithm is the sliding window counter, but a simpler fixed window approach works well too.

Fixed Window Rate Limiter

Increment a counter for each user and set an expiration. If the counter exceeds the limit, deny the request.

def is_allowed(user_id, limit=100, window=60):
    key = f'rate_limit:{user_id}'
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current