Redis કેવી રીતે મેમોરી ম્યાનેજ કરે છે?

Question

Accepted Answer

Redis ડેટા RAM માં સંગ્રહિત કરતું હોવાથી, **મેમોરી ম્યાનેજમેન્ટ** અત્યંત મહત્વપૂર્ણ છે — `maxmemory` લિમિટ, **eviction policies**, મેમોરી ઑપ્ટિમાઈઝેશન, અને મોનિટરિંગને સમજવું Redis ને વિશ્વસનીયતા સાથે ચલાવવા અને મેમોરી ઉપર ન આવવા માટે આવશ્યક છે.

## maxmemory અને eviction

```text
Set a memory limit so Redis doesn't consume all RAM:
  maxmemory 2gb                       # cap Redis at 2GB
  maxmemory-policy allkeys-lru        # what to do when the limit is reached

When the limit is hit, Redis EVICTS keys per the policy (or rejects writes):
  allkeys-lru   → evict least-recently-used (any key) — common for a pure cache
  allkeys-lfu   → evict least-frequently-used
  volatile-lru  → evict LRU among keys WITH a TTL only
  volatile-ttl  → evict keys closest to expiry
  noeviction    → reject writes when full (good if Redis holds important data)
```

`maxmemory` સેટ કરવું અને **eviction policy** ઉપયોગ કરવું મેમોરી ભરાતી વખતે વર્તન નિયંત્રિત કરે છે — Redis ને સિસ્ટમ મેમોરી ખતમ કરવાથી અથવા ક્રેશ થવાથી બચાવવું આવશ્યક છે.

## મેમોરી મોનિટરિંગ

```bash
INFO memory               # used_memory, peak, fragmentation ratio, etc.
MEMORY USAGE key          # memory used by a specific key
MEMORY DOCTOR             # diagnostics/recommendations
DBSIZE                    # number of keys
# watch: used_memory vs maxmemory, evicted_keys, fragmentation
```

## મેમોરી ઑપ્ટિમાઈઝેશન તકનીકો

```text
✓ Set TTLs → expire data that's no longer needed (don't let data accumulate forever)
✓ Use efficient data structures → small hashes/lists/sets use compact encodings (ziplist/
  listpack) → much less memory than many separate keys
✓ Shorter key names (minor, but adds up at scale)
✓ Store only what you need; consider compression for large values
✓ Avoid huge keys (a single huge value/collection) — they cause latency spikes
```

## Redis માં મેમોરી શા માટે મહત્વપૂર્ણ છે

```text
RAM is LIMITED and more expensive than disk. Running out of memory →
  evictions (cache misses), rejected writes, or crashes.
→ Capacity planning, eviction policy, TTLs, and monitoring keep Redis healthy.
```

## શા માટે આ મહત્વપૂર્ણ છે

Redis મેમોરી ម్యાનેજમેન્ટને સમજવું **Redis ને વિશ્વસનીયતા સાથે ચલાવવા** માટે મહત્વપૂર્ણ છે, કારણ કે Redis મર્યાદિત અને પ્રમાણમાં મોંઘા RAM માં ડેટા સંગ્રહિત કરે છે, તેથી મેમોરી ખતમ થવાથી બચાવવું આવશ્યક છે (evictions, અસ્વીકૃત writes, અથવા ક્રેશ થવાને કારણે).

મૂળભૂત પ્રથા — **`maxmemory`** સેટ કરવું (Redis ની મેમોરી મર્યાદિત કરવી) વતી **eviction policy** — નિર્ણાયક છે: તે નિયંત્રિત કરે છે કે જ્યારે લિમિટ પહોંચાય ત્યારે શું થાય (policies જેમ કે `allkeys-lru` શુદ્ધ cache માટે કીઓને evict કરવું, અથવા Redis મહત્વપૂર્ણ ડેટા રાખે છે તેવી વખતે `noeviction` લખવા માટે મનાદીવણી કરવી), Redis ને સિસ્ટમ મેમોરી ખતમ કરવાથી બચાવવું.

ઉપયોગ-કેસ માટે સાચો eviction policy પસંદ કરવો (caches માટે LRU/LFU, noeviction અથવા volatile policies જ્યારે ડેટા મહત્વપૂર્ણ હોય) મુખ્ય કૉન્ફિગરેશન નિર્ણય છે. **મેમોરી મોનિટરિંગ** (`INFO memory` માટે usage, peak, fragmentation, અને evicted-keys; `MEMORY USAGE` પ્રતિ key) ચલણ જાગૃતી માટે આવશ્યક છે — usage તુલના કરવી લિમિટ સાથે અને સમસ્યાઓ પકડવી.

**મેમોરી ઑપ્ટિમાઈઝેશન તકનીકો** જાણવી — TTLs ઉપયોગ કરવી બિનજરૂરી ડેટા સમય પર સમાપ્ત કરવા માટે, કાર્યક્ષમ ડેટા સ્ટ્રક્ચર્સ પસંદ કરવી (નાના hashes/lists કમ્પેક્ટ encodings ઉપયોગ કરે છે, ઘણી અલગ કીઓ કરતાં ઘણું સસ્તું), વિશાળ કીઓ ટાળવી (જે latency spikes સર્જે છે), અને જરૂરી માત્ર જ સંગ્રહિત કરવું — મેમોરીમાં વધુ ફિટ કરવામાં સહાય કરે છે અને કાર્યક્ષમતા સાથે ચલાવે છે.

Redis ની in-memory પ્રકૃતি મેમોરીને મર્યાદિત, નિર્ણાયક સંસાધન બનાવે છે, અને યોગ્ય મેમોરી ম્યાનેજમેન્ટ (maxmemory + eviction policy, મોનિટરિંગ, અને ઑપ્ટિમાઈઝેશન) જે Redis ને સુસ્થ રાખે છે અને out-of-memory નિષ્ફળતાથી બચાવે છે, તેથી Redis મેમોરી ម్యાનેજમેન્ટને સમજવું મહત્વપૂર્ણ, વ્યવહારીક જ્ઞાન છે Redis ને વિશ્વસનીયતા સાથે ચલાવવા માટે, એક મુખ્ય ચલણ સંબંધિત ચિંતા જે તેઓને અલગ કરે છે જેઓ Redis ને ઉત્પાદનમાં ચલાવી શકે છે તેમણે જેઓ ફક્ત આનો ઉપયોગ કરવો જાણે છે, અને અપ્રતિબંધિત મેમોરી વૃદ્ધિ થી આવતી વાસ્તવિક નિષ્ફળતાઓ ટાળવા માટે આવશ્યક છે.