Node API च्या परफॉर्मन्सला सुधार करणारी कॅशिंग स्ट्रॅटेजी कोणत्या आहेत?

Question

Accepted Answer

**कॅशिंग** हे महाग ऑपरेशन्सचे परिणाम (DB क्वेरी, गणना, बाह्य API कॉल) संचयित करते जेणेकरून पुनरावृत्त विनंत्या त्वरीत सेवा केल्या जाऊ शकतात आणि काम पुन्हा करण्याची गरज नाही. API साठी परफॉर्मन्स ऑप्टिमाइজेशनचा हा एक सर्वोच्च प्रभाव असलेला पर्याय आहे.

## इन-मेमरी कॅशिंग (सर्वात वेगवान, सिंगल-इन्स्टन्स)

```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;
}
```

सोपी आणि अत्यंत वेगवान, परंतु कॅश **प्रति-प्रक्रिया** आहे (इन्स्टन्सेसमध्ये सामायिक नाही) आणि पुनरारंभवर हरवले जाते. लहान, हॉट डेटासाठी योग्य — परंतु मेमरी बाउंड करण्यासाठी इविक्शन आवश्यक आहे (`lru-cache` सारखे LRU कॅश वापरा).

## Redis सह वितरित कॅशिंग (सामायिक, स्केलेबल)

```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** हा अनेक सर्व्हर इन्स्टन्सेसमध्ये कॅशिंगचा मानक आहे — एक सामायिक, वेगवान स्टोर जो पुनरारंभ लक्षात राखतो आणि आपल्या अॅपसह स्केल करतो. **TTL** (time-to-live) प्रविष्टी स्वयंचलितपणे माफ करते जेणेकरून डेटा कायमचे जुना न राहता.

## HTTP कॅशिंग (क्लायंट्स/CDN कॅश करू द्या)

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

HTTP कॅश हेडर्स कॅशिंग पूर्णपणे ब्राउজर्स आणि CDN मध्ये अपलोड करतात — सर्वात वेगवान कॅश म्हणजे विनंती जी कधीच आपल्या सर्व्हरवर पोचत नाही.

## कठीण भाग: कॅश अमान्यकरण

```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
}
```

सर्वात मोठी कॅशिंग आव्हान **अमान्यकरण** आहे — प्रभावित कॅश प्रविष्टी स्पष्ट/रीफ्रेश करणे नक्की करणे जेणेकरून वापरकर्त्यांना जुना डेटा न दिसता. स्ट्रॅटेजी: TTL (थोडक्या स्टेलनेस स्वीकारा), write-through (लेखनात कॅश अपडेट करा), किंवा म्यूटेशनवर स्पष्ट हटवणे.

## काय कॅश करायचे (आणि नाही)

```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
```

## हे महत्वाचे का आहे

कॅशिंग नाटकीयपणे लेटन्सी आणि डेटाबेस/बाह्य लोड कमी करते, बहुतेकदा हा संपूर्ण API आणि वेगवान, स्केलेबल API मधील फरक आहे.

स्तर जाणणे — इन-मेमरी (सर्वात वेगवान, प्रति-इन्स्टन्स, LRU सह बाउंडेड), Redis (इन्स्टन्सेसमध्ये सामायिक), आणि HTTP/CDN कॅशिंग (पूर्णपणे अपलोड) — आपल्याला योग्य स्ट्रॅटेजी निवडू देते.

आणि कॅशिंगचा केंद्रीय अडचण समजणे, **अमान्यकरण** (TTL किंवा लेखनात स्पष्ट क्लीयरिंगद्वारे), हे सक्लासिक ट्रेड-ऑफ अपयश रोखते ज्यामुळे वापरकर्त्यांना जुना डेटा सेवा दिला जातो.

प्रभावी कॅशिंग API परफॉर्मन्स आणि स्केलेबिलिटीसाठी सर्वात प्रभावशाली साधने आहे.