Redis Use Cases: Caching, Queues, and Rate Limiting

You've built a web app that's gaining traction, but now every page load hits the database, background jobs are piling up, and a few users are hammering your API. You need a fast, in-memory data store to handle these challenges. Redis is the go-to solution for caching, queues, and rate limiting. In this article, we'll explore these three core use cases with practical examples and best practices.

Why Redis for Caching, Queues, and Rate Limiting?

Redis is an in-memory key-value store known for its speed and versatility. It supports rich data structures like strings, lists, sets, sorted sets, and hashes, making it ideal for diverse tasks. Its atomic operations and pub/sub capabilities further extend its utility. Whether you're reducing database load, decoupling services, or protecting APIs, Redis offers a simple yet powerful toolkit.

1. Caching with Redis

Caching is Redis's most common use case. By storing frequently accessed data in memory, you reduce latency and database load. Redis's TTL (time-to-live) feature automatically expires stale data.

How to Implement Caching

1. Check the cache: Before querying the database, check if the data exists in Redis.
2. On cache miss: Fetch from the database and store the result in Redis with an expiration time.
3. On cache hit: Return the cached data directly.

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 DB fetch
    user = fetch_user_from_db(user_id)
    r.setex(cache_key, 3600, json.dumps(user))  # Cache for 1 hour
    return user

Best Practices for Caching

• Set appropriate TTLs: Balance freshness and hit rate. Short TTLs for volatile data, longer for static content.
• Use cache invalidation: When data changes, delete or update the cache key to avoid stale reads.
• Handle cache stampedes: Use locks or probabilistic early expiration to prevent many requests from hitting the database simultaneously on cache miss.
• Monitor hit rate: Aim for a high hit ratio (e.g., >80%) to ensure caching is effective.

2. Queues with Redis

Redis lists and sorted sets enable simple yet robust message queues. They're perfect for background jobs, task queues, and event processing. Unlike dedicated message brokers, Redis queues are lightweight and easy to set up.

Implementing a Basic Queue

Use LPUSH to add jobs and BRPOP to consume them in a blocking manner:

# Producer
r.lpush('job_queue', json.dumps({'task': 'send_email', 'to': 'user@example.com'}))

# Consumer
while True:
    _, job = r.brpop('job_queue', timeout=30)
    if job:
        process_job(json.loads(job))

Advanced Queues with Sorted Sets

For delayed jobs or priority queues, use sorted sets with timestamps as scores. Consumers fetch jobs with scores