Redis Caching Patterns for Web Applications

Redis is the go-to solution for caching in web applications. Here are patterns for implementing effective caching strategies.

Basic Operations#

import Redis from 'ioredis';

const redis = new Redis(process.env.REDIS_URL);

// Basic set/get
await redis.set('key', 'value');
const value = await redis.get('key');

// Set with expiration (seconds)
await redis.setex('key', 3600, 'value'); // 1 hour

// Set with expiration (milliseconds)
await redis.psetex('key', 60000, 'value'); // 1 minute

// Set if not exists
const wasSet = await redis.setnx('key', 'value');

// Set with options
await redis.set('key', 'value', 'EX', 3600, 'NX'); // Expire + not exists

// Get and set
const oldValue = await redis.getset('key', 'newValue');

// Delete
await redis.del('key');

// Check existence
const exists = await redis.exists('key');

// Get remaining TTL
const ttl = await redis.ttl('key'); // seconds
const pttl = await redis.pttl('key'); // milliseconds

Cache-Aside Pattern#

// Most common caching pattern
class CacheAside {
  constructor(
    private redis: Redis,
    private ttl = 3600
  ) {}

  async get<T>(key: string, fetchFn: () => Promise<T>): Promise<T> {
    // Try cache first
    const cached = await this.redis.get(key);

    if (cached) {
      return JSON.parse(cached) as T;
    }

    // Cache miss - fetch from source
    const data = await fetchFn();

    // Store in cache
    await this.redis.setex(key, this.ttl, JSON.stringify(data));

    return data;
  }

  async invalidate(key: string): Promise<void> {
    await this.redis.del(key);
  }

  async invalidatePattern(pattern: string): Promise<void> {
    const keys = await this.redis.keys(pattern);
    if (keys.length > 0) {
      await this.redis.del(...keys);
    }
  }
}

// Usage
const cache = new CacheAside(redis, 3600);

const user = await cache.get(`user:${userId}`, () =>
  prisma.user.findUnique({ where: { id: userId } })
);

// Invalidate on update
await prisma.user.update({ where: { id: userId }, data });
await cache.invalidate(`user:${userId}`);

Write-Through Cache#

// Write to cache and database together
class WriteThroughCache<T> {
  constructor(
    private redis: Redis,
    private repository: Repository<T>,
    private keyPrefix: string,
    private ttl = 3600
  ) {}

  async get(id: string): Promise<T | null> {
    const key = `${this.keyPrefix}:${id}`;
    const cached = await this.redis.get(key);

    if (cached) {
      return JSON.parse(cached);
    }

    // Cache miss
    const data = await this.repository.findById(id);

    if (data) {
      await this.redis.setex(key, this.ttl, JSON.stringify(data));
    }

    return data;
  }

  async save(id: string, data: T): Promise<T> {
    const key = `${this.keyPrefix}:${id}`;

    // Write to both cache and database
    const [saved] = await Promise.all([
      this.repository.save(id, data),
      this.redis.setex(key, this.ttl, JSON.stringify(data)),
    ]);

    return saved;
  }

  async delete(id: string): Promise<void> {
    const key = `${this.keyPrefix}:${id}`;

    await Promise.all([
      this.repository.delete(id),
      this.redis.del(key),
    ]);
  }
}

Cache with Stampede Prevention#

// Prevent cache stampede with locking
class StampedeProtectedCache {
  constructor(
    private redis: Redis,
    private ttl = 3600,
    private lockTtl = 10
  ) {}

  async get<T>(key: string, fetchFn: () => Promise<T>): Promise<T> {
    // Try cache
    const cached = await this.redis.get(key);
    if (cached) {
      return JSON.parse(cached);
    }

    // Try to acquire lock
    const lockKey = `lock:${key}`;
    const acquired = await this.redis.set(
      lockKey,
      '1',
      'EX',
      this.lockTtl,
      'NX'
    );

    if (acquired) {
      try {
        // We have the lock - fetch and cache
        const data = await fetchFn();
        await this.redis.setex(key, this.ttl, JSON.stringify(data));
        return data;
      } finally {
        await this.redis.del(lockKey);
      }
    } else {
      // Another process is fetching - wait and retry
      await this.sleep(100);
      return this.get(key, fetchFn);
    }
  }

  private sleep(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

// Or use probabilistic early expiration
class EarlyExpirationCache {
  async get<T>(key: string, fetchFn: () => Promise<T>, ttl: number): Promise<T> {
    const result = await this.redis.hgetall(key);

    if (result.data) {
      const expiry = parseInt(result.expiry);
      const delta = parseInt(result.delta);

      // Probabilistic early recomputation
      const shouldRecompute =
        Date.now() - delta * Math.log(Math.random()) > expiry;

      if (!shouldRecompute) {
        return JSON.parse(result.data);
      }
    }

    // Recompute
    const start = Date.now();
    const data = await fetchFn();
    const delta = Date.now() - start;

    await this.redis.hset(key, {
      data: JSON.stringify(data),
      expiry: Date.now() + ttl * 1000,
      delta: delta,
    });

    await this.redis.expire(key, ttl + 60); // Buffer

    return data;
  }
}

Session Storage#

// Session management with Redis
class RedisSessionStore {
  constructor(
    private redis: Redis,
    private prefix = 'session:',
    private ttl = 86400 // 24 hours
  ) {}

  async create(data: SessionData): Promise<string> {
    const sessionId = crypto.randomUUID();
    const key = `${this.prefix}${sessionId}`;

    await this.redis.setex(key, this.ttl, JSON.stringify(data));

    return sessionId;
  }

  async get(sessionId: string): Promise<SessionData | null> {
    const key = `${this.prefix}${sessionId}`;
    const data = await this.redis.get(key);

    if (!data) return null;

    // Refresh TTL on access
    await this.redis.expire(key, this.ttl);

    return JSON.parse(data);
  }

  async update(sessionId: string, data: Partial<SessionData>): Promise<void> {
    const key = `${this.prefix}${sessionId}`;
    const existing = await this.get(sessionId);

    if (existing) {
      await this.redis.setex(
        key,
        this.ttl,
        JSON.stringify({ ...existing, ...data })
      );
    }
  }

  async destroy(sessionId: string): Promise<void> {
    const key = `${this.prefix}${sessionId}`;
    await this.redis.del(key);
  }

  async destroyAllForUser(userId: string): Promise<void> {
    const pattern = `${this.prefix}*`;
    const keys = await this.redis.keys(pattern);

    for (const key of keys) {
      const data = await this.redis.get(key);
      if (data) {
        const session = JSON.parse(data);
        if (session.userId === userId) {
          await this.redis.del(key);
        }
      }
    }
  }
}

Rate Limiting#

// Sliding window rate limiting
class RateLimiter {
  constructor(
    private redis: Redis,
    private limit: number,
    private windowMs: number
  ) {}

  async check(key: string): Promise<{ allowed: boolean; remaining: number }> {
    const now = Date.now();
    const windowStart = now - this.windowMs;

    const multi = this.redis.multi();

    // Remove old entries
    multi.zremrangebyscore(key, 0, windowStart);

    // Count current entries
    multi.zcard(key);

    // Add current request
    multi.zadd(key, now, `${now}-${Math.random()}`);

    // Set expiry
    multi.expire(key, Math.ceil(this.windowMs / 1000));

    const results = await multi.exec();
    const count = results?.[1]?.[1] as number;

    const allowed = count < this.limit;
    const remaining = Math.max(0, this.limit - count - 1);

    if (!allowed) {
      // Remove the request we just added
      await this.redis.zremrangebyscore(key, now, now);
    }

    return { allowed, remaining };
  }
}

// Token bucket
class TokenBucket {
  constructor(
    private redis: Redis,
    private maxTokens: number,
    private refillRate: number // tokens per second
  ) {}

  async consume(key: string, tokens = 1): Promise<boolean> {
    const script = `
      local key = KEYS[1]
      local max_tokens = tonumber(ARGV[1])
      local refill_rate = tonumber(ARGV[2])
      local now = tonumber(ARGV[3])
      local requested = tonumber(ARGV[4])

      local data = redis.call('HMGET', key, 'tokens', 'last_update')
      local current_tokens = tonumber(data[1]) or max_tokens
      local last_update = tonumber(data[2]) or now

      local elapsed = now - last_update
      local refill = math.floor(elapsed * refill_rate / 1000)
      current_tokens = math.min(max_tokens, current_tokens + refill)

      if current_tokens >= requested then
        current_tokens = current_tokens - requested
        redis.call('HMSET', key, 'tokens', current_tokens, 'last_update', now)
        redis.call('EXPIRE', key, math.ceil(max_tokens / refill_rate) + 1)
        return 1
      end

      return 0
    `;

    const result = await this.redis.eval(
      script,
      1,
      key,
      this.maxTokens,
      this.refillRate,
      Date.now(),
      tokens
    );

    return result === 1;
  }
}

Pub/Sub for Cache Invalidation#

// Distributed cache invalidation
class DistributedCache {
  private subscriber: Redis;
  private localCache: Map<string, any> = new Map();

  constructor(private redis: Redis) {
    this.subscriber = redis.duplicate();

    this.subscriber.subscribe('cache:invalidate');
    this.subscriber.on('message', (channel, message) => {
      if (channel === 'cache:invalidate') {
        const { pattern } = JSON.parse(message);
        this.invalidateLocal(pattern);
      }
    });
  }

  async get<T>(key: string, fetchFn: () => Promise<T>): Promise<T> {
    // Check local cache first
    if (this.localCache.has(key)) {
      return this.localCache.get(key);
    }

    // Check Redis
    const cached = await this.redis.get(key);
    if (cached) {
      const data = JSON.parse(cached);
      this.localCache.set(key, data);
      return data;
    }

    // Fetch and cache
    const data = await fetchFn();
    await this.redis.setex(key, 3600, JSON.stringify(data));
    this.localCache.set(key, data);

    return data;
  }

  async invalidate(pattern: string): Promise<void> {
    // Invalidate in Redis
    const keys = await this.redis.keys(pattern);
    if (keys.length > 0) {
      await this.redis.del(...keys);
    }

    // Notify all instances
    await this.redis.publish(
      'cache:invalidate',
      JSON.stringify({ pattern })
    );
  }

  private invalidateLocal(pattern: string): void {
    const regex = new RegExp(pattern.replace('*', '.*'));
    for (const key of this.localCache.keys()) {
      if (regex.test(key)) {
        this.localCache.delete(key);
      }
    }
  }
}

Best Practices#

Keys:
✓ Use consistent naming: type:id:field
✓ Keep keys short but descriptive
✓ Use colons as separators
✓ Avoid special characters

TTL:
✓ Always set TTL on cache entries
✓ Use shorter TTL for volatile data
✓ Consider cache warming for critical data
✓ Handle cache misses gracefully

Performance:
✓ Use pipelines for multiple operations
✓ Avoid KEYS in production (use SCAN)
✓ Monitor memory usage
✓ Use appropriate data structures

Redis caching significantly improves application performance. Use cache-aside for most cases, implement stampede protection for high-traffic scenarios, and leverage pub/sub for distributed invalidation. Monitor cache hit rates and adjust TTLs based on data volatility.