Redis ஐ cache ஆக எவ்வாறு பயன்படுத்தப்படுகிறது?

Question

Accepted Answer

**Caching** என்பது Redis இன் மிகவும் பொதுவான பயன்பாடு — அடிக்கடி அணுகப்படும் தரவை வேகமான நினைவகத்தில் சேமிப்பது, இதன் மூலம் பயன்பாடுகள் மெதுவான நடவடிக்கைகளைத் தவிர்க்கின்றன (தரவுசேகர வினவல்கள், API அழைப்புகள், கணக்கீடுகள்). அடிப்படை caching முறையைப் புரிந்துகொள்வது அத்தியாவசிய அன்றாட அறிவு.

## The cache-aside pattern (மிகவும் பொதுவான)

```text
1. App needs data → CHECK Redis first (cache lookup)
2. CACHE HIT (found) → return it immediately (fast!) ✓
3. CACHE MISS (not found) → query the database, store the result in Redis (with TTL),
   then return it. Next time it'll be a hit.
```

```js
async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // CACHE HIT — fast, skip the DB

const user = await db.users.findById(id);        // CACHE MISS — query the DB
  await redis.set(`user:${id}`, JSON.stringify(user), "EX", 3600);  // cache it (1h TTL)
  return user;
}
```

பயன்பாடு முதலில் Redis ஐ சரிபார்க்கிறது; miss இல், இது மூலத்திலிருந்து பெறுகிறது, முடிவை cache செய்கிறது (TTL உடன்), மற்றும் அதை வழங்குகிறது. அடுத்தடுத்த கோரிக்கைகள் வேகமான cache hits ஆகும்.

## Caching ஏன் உதவுகிறது

```text
✓ SPEED — Redis (in-memory) is far faster than a database (disk) or external API
✓ REDUCED LOAD — fewer queries hit the database (it handles less, scales better)
✓ Result: faster responses, lower database load, better scalability
→ Caching is one of the most effective ways to improve application performance.
```

## Cache invalidation (கடினமான பகுதி)

```js
// when data changes, the cache must be updated or removed (else it's STALE)
async function updateUser(id, data) {
  await db.users.update(id, data);
  await redis.del(`user:${id}`);    // INVALIDATE the cache (next read re-fetches fresh)
}
```

```text
Stale data is the main caching challenge:
  → Use TTLs (data auto-expires, eventually refreshing)
  → Invalidate (delete/update the cache) when the source data changes
  → "There are only two hard things: cache invalidation and naming things."
```

## இது ஏன் முக்கியம்

Redis ஐ cache ஆக பயன்படுத்துவது அதன் மிகவும் பொதுவான மற்றும் प्रभावकारी பயன்பாடு, எனவே அடிப்படை caching முறையைப் புரிந்துகொள்வது திறமையான பயன்பாடுகளை உருவாக்குவதற்கான அத்தியாவசிய, பரவலாக-பொருந்தக்கூடிய அறிவு.

மূல நுட்பம் — அடிக்கடி அணுகப்படும் தரவை Redis இன் வேகமான நினைவகத்தில் சேமிப்பது, இதன் மூலம் பயன்பாடு மெதுவான நடவடிக்கைகளைத் தவிர்க்கிறது (தரவுசேகர வினவல்கள், API அழைப்புகள், महंगी கணக்கீடுகள்) — செயல்திறன் மற்றும் স्केலेबिलिटி மேம்படுத்த மிகவும் प्रभावकारী வழிகளில் ஒன்றாகும், இது பல்வேறு உत்பादன அமைப்புகளில் பயன்படுத்தப்படுகிறது.

**Cache-aside pattern** ஐப் புரிந்துகொள்வது (முதலில் Redis ஐ சரிபார்க்கவும்; hit இல் உடனடியாக திரும்பவும்; miss இல் மூலத்திலிருந்து பெறவும், TTL உடன் முடிவை cache செய்யவும், மற்றும் திரும்பவும்) அடிப்படை caching நுட்பம் ஆகும், ஒவ்வொரு உருவாக்குனரும் அறிந்திருக்க வேண்டும் — இது எவ்வாறு பெரும்பாலான caching வேலை செய்கிறது.

**Caching ஏன் உதவுகிறது** என்பதைப் புரிந்துகொள்வது (நினைவகத்தில் உள்ள Redis வட்டு-அடிப்படையிலான தரவுசேகரங்கள் அல்லது வெளிப்புற API களை விட மிக வேகமாக உள்ளது, மேலும் caching தரவுசேகரத்தில் சுமையைக் குறைக்கிறது, இதனால் இது சிறப்பாக அளவிடப்படுகிறது) வேகம் மற்றும் குறைந்த backend சுமை ஆகியவற்றின் இரட்டை நன்மைகளை விளக்குகிறது.

சுயாதீனமாக, **cache invalidation** ஐப் புரிந்துகொள்வது — cached தரவு பழையதாக இல்லாமல் இருப்பதைக் கண்ணியாக