Distributed Caching: Redis Clusters & CDN Mechanics

Introduction

In web architectures, query latency and database locks are the primary bottlenecks. Distributed caching mitigates these issues by maintaining high-speed memory caches closer to the user.

We partition our caching strategy into two tiers: Edge caching (using a Content Delivery Network - CDN) for static media, code files, and page responses; and Database caching (using Redis memory tables) for dynamic REST API queries and user session records.

System Diagram

This caching architecture illustrates the Cache-Aside validation check pattern used for database lookups:

[ Client ] ---> [ CDN Edge ] ---> [ App Server ] | +----------------+----------------+ | | [ Cache Hit: read Redis ] [ Cache Miss: Query DB ] | v [ Write query to Redis ]

Architecture & Mechanics

The core architecture of Redis depends on a single-threaded execution loop managing in-memory key-value data structures (strings, hashes, lists, sets, sorted sets). Redis keeps entire datasets in memory, delivering sub-millisecond response latencies.

CDNs operate by caching static resources at Edge Nodes geographically distributed near end-users. Dynamic requests bypass CDN locations and route to Application servers, which implement a Cache-Aside database pattern: query Redis first; if data is missing (cache miss), fetch from the database and write the results to Redis for future queries.

Concrete Examples

Here is a complete TypeScript snippet for an Express application implementing a Cache-Aside database query using Redis.

import { createClient } from 'redis';

const redisClient = createClient({ url: 'redis://localhost:6379' });
redisClient.connect();

async function getOrSetCache(key: string, dbQuery: () => Promise<any>, ttl = 300) {
  const cachedData = await redisClient.get(key);
  if (cachedData) {
    return JSON.parse(cachedData); # Cache Hit
  }

  const freshData = await dbQuery(); # Cache Miss
  await redisClient.setEx(key, ttl, JSON.stringify(freshData));
  return freshData;
}

Production Best Practices

- **Use Cache Eviction Policies**: Set Redis maxmemory-policy to volatile-lru or allkeys-lru to clean out oldest unused cache keys when storage limits are hit.

- **Apply Cache Expiration (TTL)**: Always define a time-to-live (TTL) on cache keys. Avoid leaving keys open indefinitely, which can result in data inconsistency.

- **Mitigate Cache Stampede**: Use locks or random jitter in TTL durations to prevent multiple application servers from querying the database simultaneously when a popular key expires.

References

- Redis Architecture Documentation: https://redis.io/docs/manual/architecture/

- AWS CDN Edge Caching Guidelines: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html

Conclusion

Combining Redis database caching with CDN file hosting reduces origin server load and cuts request latency. By moving content closer to consumers, applications can support high concurrent user traffic while keeping databases responsive.