Node API యొక్క పనితీరును మెరుగుపరిచే ఎక్కువ ఉపయోగపడే కాచింగ్ వ్యూహాలు ఏవి?

Question

Accepted Answer

**Caching** ఖరీదైన ఆపరేషన్ల (DB queries, computations, external API calls) ఫలితాలను సংગ్రహిస్తుంది, తద్వారా పదేపదే అభ్యర్థనలు చేసిన పనిని పునరావృత్తి చేయకుండా వేగంగా సేవ చేయవచ్చు. ఇది API కోసం అత్యధిక-ప్రభావం కలిగిన పనితీరు ఆప్టిమైజేషన్‌లలో ఒకటి.

## 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 అంతటా భాగస్వామ్యం చేయబడనిది) మరియు పునఃప్రారంభంపై కోల్పోవడం. చిన్న, వేడి డేటా కోసం మంచిది — కానీ మెమరీని సరిహద్దు చేయడానికి eviction అవసరం (`lru-cache` వంటి LRU cache ఉపయోగించండి).

## Distributed caching with 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** అనేది బహుళ సర్వర్ instances అంతటా caching కోసం ప్రామాణికమైనది — ఒక భాగస్వామ్యం చేయబడిన, వేగవంతమైన స్టోర్ ఇది పునఃప్రారంభాలను నిలుస్తుంది మరియు మీ app కట్టుకుని స్కేల్ చేస్తుంది. **TTL** (time-to-live) స్వయంచాలకంగా ఎంట్రీలను చెల్లుబాటు చేస్తుంది కాబట్టి డేటా శాశ్వతంగా పాతబడదు.

## 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 అనేది మీ సర్వర్‌కు ఎప్పుడూ చేరని అభ్యర్థన.

## కష్టమైన భాగం: 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
}
```

సీచింగ్ యొక్క సంబంధితమైన సవాలు **invalidation** — నవీకరణలు స్పష్టమైన/రీఫ్రెష్ ఆ cache entries అనుమితమైనవారు కాబట్టి వినియోగదారులు పాతబడిన డేటాను చూడరు. వ్యూహాలు: TTL (సంక్షిప్త staleness ఆమోదం చేయండి), write-through (write పై cache నవీకరించండి), లేదా mutation మీద స్పష్టమైన 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 మరియు వేగవంతమైన, స్కేలేబుల్ ఒకటి మధ్య వ్యత్యాసం.

లేయర్‌లను తెలుసుకోవడం — in-memory (అత్యంత వేగవంతమైన, per-instance, LRU తో సరిహద్దు), Redis (instances అంతటా భాగస్వామ్యం చేయబడిన), మరియు HTTP/CDN caching (పూర్తిగా బదిలీ) — మీరు సరైన వ్యూహాన్ని ఎంచుకోవడానికి అనుమతిస్తుంది.

మరియు caching యొక్క కేంద్ర కష్టానికి అర్థం చేసుకోవడం, **invalidation** (TTL ద్వారా లేదా writes మీద స్పష్టమైన క్లియర్‌కు), ఇది వినియోగదారులకు సేవ చేయుటలో caching యొక్క సాంప్రదాయక trade-off వైఫల్యకు నిరోధం చేస్తుంది.

प్రభావవంతమైన caching API పనితీరు మరియు scalability కోసం సరైన ప్రభావశీలమైన సాధనాలలో ఒకటి.