1# NGINX Layer 7 Load Balancer
2 
3upstream api_servers {
least_conn is better than round_robin for variable-latency workloads
4    least_conn;  # Better than round_robin for variable-latency requests
5 
6    server api-1.internal:3000 weight=2;  # 16 cores — gets 2x traffic
7    server api-2.internal:3000 weight=1;  # 8 cores
8    server api-3.internal:3000 weight=1;  # 8 cores
9    keepalive 32;
10}
11 
WebSocket connections must be sticky — the WS is stateful per-connection
12upstream ws_servers {
13    ip_hash;  # WebSocket connections must be sticky (stateful connection)
14    server ws-1.internal:3001;
15    server ws-2.internal:3001;
16}
17 
18server {
19    listen 443 ssl http2;
20 
21    location /ws/ {
22        proxy_pass http://ws_servers;
23        proxy_http_version 1.1;
24        proxy_set_header Upgrade $http_upgrade;
25        proxy_set_header Connection "upgrade";
26    }
27 
28    location /api/ {
29        proxy_pass http://api_servers;
30        proxy_connect_timeout 5s;
31        proxy_read_timeout 30s;
32        proxy_set_header X-Real-IP $remote_addr;
33        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
34    }
35}

1// Cache-Aside (Lazy Loading) Pattern
2const CACHE_TTL = 300; // 5 minutes
3 
4async function getUserById(userId: string) {
5  const cacheKey = `user:${userId}`;
6 
7  // 1. Check L2 cache first
8  const cached = await redis.get(cacheKey);
9  if (cached) return JSON.parse(cached);  // Cache HIT
10 
11  // 2. Miss → query database
12  const user = await db.query.users.findFirst({
13    where: eq(users.id, userId),
14  });
15  if (!user) return null;
16 
17  // 3. Populate cache with TTL
18  await redis.setex(cacheKey, CACHE_TTL, JSON.stringify(user));
19  return user;
20}
21 
22async function updateUser(userId: string, data: Partial<User>) {
23  const updated = await db.update(users)
24    .set(data).where(eq(users.id, userId)).returning();
Always invalidate cache on write — never leave stale data
25 
26  // Invalidate cache on write
27  await redis.del(`user:${userId}`);
28  return updated[0];
29}
Cache stampede: many concurrent misses all hit the DB simultaneously — use a lock
30 
31// Cache stampede prevention: distributed lock on cache miss
32async function getUserWithLock(userId: string) {
33  const cacheKey = `user:${userId}`;
34  const lockKey = `lock:user:${userId}`;
35 
36  const cached = await redis.get(cacheKey);
37  if (cached) return JSON.parse(cached);
38 
39  // Try to acquire lock (NX = only if not exists, EX = expire after 5s)
40  const lockAcquired = await redis.set(lockKey, '1', 'NX', 'EX', 5);
41  if (!lockAcquired) {
42    await new Promise(r => setTimeout(r, 50));
43    return getUserById(userId); // retry — cache likely populated now
44  }
45 
46  try {
47    const user = await db.query.users.findFirst({ where: eq(users.id, userId) });
48    if (user) await redis.setex(cacheKey, CACHE_TTL, JSON.stringify(user));
49    return user;
50  } finally {
51    await redis.del(lockKey); // always release lock
52  }
53}