எந்த caching strategies ஒரு Node API-இன் செயல்திறனை மேம்படுத்துகின்றன?

Question

Accepted Answer

**Caching** விலையுயர்ந்த operations-இன் (DB queries, computations, external API calls) முடிவுகளைச் சேமிக்கிறது, இதனால் மீண்டும் வரும் requests வேலையை மீண்டும் செய்யாமல் வேகமாக வழங்கப்படலாம். இது ஒரு API-க்கான மிக அதிக-தாக்க செயல்திறன் 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-ஐ bound செய்ய 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-க்கான standard — restarts-ஐ தாண்டி உயிர்வாழும் மற்றும் உங்கள் app உடன் scale ஆகும் ஒரு பகிரப்பட்ட, வேகமான store. **TTL** (time-to-live) entries-ஐ auto-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-க்கு offload செய்கின்றன — வேகமான cache என்பது உங்கள் server-ஐ ஒருபோதும் அடையாத request.

## கடினமான பகுதி: 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 செய்வதை உறுதிசெய்தல், இதனால் பயனர்கள் stale data-ஐப் பார்க்க மாட்டார்கள். Strategies: 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 உடன் bounded), Redis (instances முழுவதும் பகிரப்பட்டது), மற்றும் HTTP/CDN caching (முழுவதுமாக offload) — சரியான strategy-ஐ தேர்வு செய்ய உங்களை அனுமதிக்கிறது.

மேலும் caching-இன் மைய சிரமமான **invalidation**-ஐ (TTL அல்லது writes-இல் explicit clearing மூலம்) புரிந்துகொள்வது தான் பயனர்களுக்கு stale data வழங்கும் உன்னதமான trade-off தோல்வியைத் தடுக்கிறது.

பயனுள்ள caching API செயல்திறன் மற்றும் scalability-க்கான மிக தாக்கம் கொண்ட tools-இல் ஒன்று.