Redis Use Cases: Caching, Queues, and Rate Limiting

You've built a web app that works, but as traffic grows, you notice slow page loads, database bottlenecks, and occasional downtime. These are common scaling pains. Redis, an in-memory data store, can solve many of these problems elegantly. In this article, we'll explore three practical Redis use cases: caching, queues, and rate limiting. You'll learn how to implement each with code examples and best practices.

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, hashes, and sorted sets, making it suitable for a wide range of tasks. Because it keeps data in memory, reads and writes are extremely fast—often sub-millisecond. While it's not a replacement for a primary database, it excels as a complementary tool for performance and coordination.

1. Caching with Redis

Caching is the most common Redis use case. By storing frequently accessed data in Redis, you reduce load on your primary database and speed up responses.

How to implement caching

1. Check Redis first: When a request comes in, look for the data in Redis using a unique key.
2. On cache miss: If the data isn't in Redis, fetch it from your database.
3. Store in Redis: Save the result in Redis with an expiration time (TTL) to avoid stale data.
4. Return the data: Send the data to the client.

Here's a simple example in Python 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:

• Use meaningful key names with colons, e.g., user:123.
• Set a TTL to prevent stale data and memory bloat.
• Consider cache invalidation strategies: write-through, write-behind, or time-based expiration.
• For complex objects, serialize with JSON or MessagePack.

2. Queues with Redis

Redis lists and streams are perfect for building simple message queues. They allow you to decouple time-consuming tasks (like sending emails or processing images) from the main request flow, improving responsiveness.

Using lists as queues

Redis lists support atomic push and pop operations. Use LPUSH to add jobs to the left and BRPOP to block and pop from the right, creating a FIFO queue.

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

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

Considerations:

• Reliability: Lists are not persistent by default; enable AOF or RDB persistence if needed.
• At-least-once delivery: Use BRPOPLPUSH to move jobs to a processing list, then remove upon completion.
• Streams: For more advanced use cases (consumer groups, acknowledgments), consider Redis Streams.

3. Rate Limiting with Redis

Rate limiting protects your API from abuse and ensures fair usage. Redis's atomic operations and expiration make it ideal for implementing rate limiters.

Fixed window rate limiting

In a fixed window, you allow N requests per time window (e.g., 100 requests per hour). Use INCR and EXPIRE to track counts.

def is_rate_limited(user_id, limit=100, window=3600):
    key = f"rate:{user_id}"
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current > limit

Sliding window with sorted sets provides smoother limiting. Store timestamps of requests in a sorted set and remove old entries.

def is_rate_limited_sliding(user_id, limit=100, window=3600):
    key = f"rate:{user_id}"
    now = time.time()
    pipeline = r.pipeline()
    pipeline.zremrangebyscore(key, 0, now - window)
    pipeline.zadd(key, {now: now})
    pipeline.zcard(key)
    pipeline.expire(key, window)
    _, _, count, _ = pipeline.execute()
    return count > limit

Best practices:

• Use a unique key per user or IP.
• Combine with middleware for clean integration.
• Consider using Redis modules like redis-cell for advanced algorithms.

Comparison of Use Cases

FAQ

Is Redis persistent?

Redis offers persistence through RDB snapshots and AOF logs, but it's primarily an in-memory store. For critical data, always have a backup or use a primary database.

Can I use Redis for session storage?

Yes, Redis is commonly used for session storage because of its speed and automatic expiration. It allows you to share sessions across multiple servers.

What happens if Redis goes down?

If Redis is unavailable, your app should gracefully fall back to the database or return cached data from a local cache. Implement circuit breakers to avoid cascading failures.

Ready to optimize your web app? Start by integrating Redis for caching, queues, or rate limiting. For quick tasks like formatting JSON or analyzing logs, check out our JSON Formatter and Nginx Log Analyzer.