09. High-Performance Caching with Redis & Invalidation Strategies • Node.js Backend Architecture: Libuv to High-Scale Microservices • Rishabh Ki Kaksha

PostgreSQL / MongoDB disk lookups me 50ms - 200ms lagte hain.  
**Redis** in-memory C-based data store hai jo RAM me **sub-millisecond (< 1ms)** responses deta hai!

```
[ Incoming Request ] ➔ [ Redis Cache Check (0.5ms) ] ➔ Hit? ➔ Return instantly!
                                       ⬇ Miss?
                       [ Database Query (150ms) ] ➔ Save in Redis ➔ Return
```

---

### 2. Cache-Aside Pattern (Standard Implementation)

```typescript
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL);

export async function getProductById(id: string) {
    const cacheKey = `product:${id}`;

// 1. Check Redis:
    const cached = await redis.get(cacheKey);
    if (cached) {
        return JSON.parse(cached); // ⚡ Cache Hit!
    }

// 2. Cache Miss: Fetch from DB
    const product = await db.products.findUnique({ where: { id } });
    if (!product) return null;

// 3. Store in Redis with TTL (1 Hour):
    await redis.set(cacheKey, JSON.stringify(product), "EX", 3600);
    return product;
}
```

---

### 3. The 3 Cache Disasters & Fixes (Big Tech Interview Gold 👑)

1. **Cache Stampede (Dogpiling):** Jab trending item ka cache expire hota hai, toh lakho concurrent users ek sath DB par girte hain aur DB crash ho jata hai!  
   *Fix:* **Mutex Locks (`redlock`)** ya Probabilistic Early Expiration (XFetch).
2. **Cache Penetration:** Hacker aisi IDs query karta hai jo DB me exist hi nahi karti (Har request DB hit karegi!).  
   *Fix:* **Bloom Filters** ya `redis.set(key, "null", "EX", 60)`.
3. **Cache Avalanche:** Agar saare keys ka TTL same ho (e.g. 1 hour), toh ek sath saare keys expire honge.  
   *Fix:* **Add Random Jitter** (`TTL = 3600 + Math.random() * 300`).

---

### 4. Cache Invalidation Strategies

> *"There are only two hard things in Computer Science: cache invalidation and naming things." — Phil Karlton*

```typescript
export async function updateProduct(id: string, updateData: any) {
    // Step 1: Update Database
    const updated = await db.products.update({ where: { id }, data: updateData });

// Step 2: Invalidate / Purge Cache
    await redis.del(`product:${id}`);
    return updated;
}
```

---

### 5. Master Comparison Matrix

---

### 6. Interview Ke 3 Sawal Is Topic Se

1. **Cache Stampede se bachne ka best architectural solution kya hai?** -> Distributed locking pattern (Redlock) jisme sirf 1 worker thread DB se data fetch karta hai jabki baki pending requests us lock ke release hone ka wait karti hain.
2. **Redis me `EX` aur `PX` me kya difference hai?** -> `EX` expiry time seconds me leta hai; `PX` expiry time milliseconds me leta hai.
3. **Redis me LRU vs LFU eviction policy kya hoti hai?** -> RAM full hone par LRU (Least Recently Used) sabse purane accessed keys delete karta hai; LFU (Least Frequently Used) sabse kam bar access huye keys delete karta hai.

---
**Next Topic:** 10. Authentication Architecture: JWT Access/Refresh Tokens & Sliding Sessions

Loading lesson content...

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track