कौन सी caching strategies एक Node API के performance को बेहतर बनाती हैं?

Question

Accepted Answer

**Caching** महंगे operations (DB queries, computations, external API calls) के परिणामों को store करती है ताकि बार-बार आने वाले requests को काम दोबारा किए बिना तेज़ी से serve किया जा सके। यह एक API के लिए सबसे अधिक प्रभाव वाले performance optimizations में से एक है।

## In-memory caching (सबसे तेज़, single-instance)

```js
const cache = new Map();

async function getUser(id) {
  if (cache.has(id)) return cache.get(id); // cache HIT — instant
  const user = await db.findUser(id);       // cache MISS — do the work
  cache.set(id, user);
  return user;
}
```

सरल और अत्यंत तेज़, लेकिन cache **per-process** होता है (instances के बीच साझा नहीं) और restart पर खो जाता है। छोटे, hot data के लिए अच्छा — लेकिन memory को सीमित करने के लिए eviction की आवश्यकता होती है (`lru-cache` जैसे LRU cache का उपयोग करें)।

## Redis के साथ distributed caching (साझा, scalable)

```js
import { createClient } from "redis";
const redis = createClient();

async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // hit

const user = await db.findUser(id);
  await redis.setEx(`user:${id}`, 3600, JSON.stringify(user)); // cache for 1h (TTL)
  return user;
}
```

**Redis** कई server instances के बीच caching के लिए मानक है — एक साझा, तेज़ store जो restarts के बाद बना रहता है और आपके app के साथ scale करता है। **TTL** (time-to-live) entries को अपने-आप expire कर देता है ताकि data हमेशा के लिए stale न रहे।

## HTTP caching (clients/CDNs को cache करने दें)

```js
res.set("Cache-Control", "public, max-age=3600"); // browsers/CDN cache for 1h
res.set("ETag", hash);                            // conditional requests (304 Not Modified)
```

HTTP cache headers caching को पूरी तरह से browsers और CDNs पर डाल देते हैं — सबसे तेज़ cache वह request है जो कभी आपके server तक पहुंचता ही नहीं।

## कठिन भाग: cache invalidation

```js
// when data changes, the cache must be updated or cleared, or users see stale data
async function updateUser(id, data) {
  await db.updateUser(id, data);
  await redis.del(`user:${id}`); // INVALIDATE — next read repopulates with fresh data
}
```

सबसे बड़ी caching चुनौती **invalidation** है — यह सुनिश्चित करना कि updates प्रभावित cache entries को clear/refresh करें ताकि users को stale data न दिखे। रणनीतियाँ: TTL (संक्षिप्त staleness स्वीकार करें), write-through (write पर cache update करें), या mutation पर explicit deletion।

## क्या cache करें (और क्या नहीं)

```text
✓ Read-heavy, infrequently-changing data (config, product catalogs, user profiles)
✓ Expensive computations, external API responses
✗ Highly dynamic/personalized or rapidly-changing data (or use very short TTLs)
✗ Sensitive data without care for who can read the cache
```

## यह क्यों महत्वपूर्ण है

Caching latency और database/external load को नाटकीय रूप से कम करती है, जो अक्सर एक धीमे API और एक तेज़, scalable API के बीच का अंतर होता है।

layers को जानना — in-memory (सबसे तेज़, per-instance, LRU के साथ सीमित), Redis (instances के बीच साझा), और HTTP/CDN caching (पूरी तरह से offload) — आपको सही रणनीति चुनने देता है।

और caching की केंद्रीय कठिनाई, **invalidation** (TTL के माध्यम से या writes पर explicit clearing के माध्यम से) को समझना ही वह चीज़ है जो users को stale data परोसने की क्लासिक trade-off विफलता को रोकती है।

प्रभावी caching API performance और scalability के लिए सबसे प्रभावशाली tools में से एक है।