Hogyan kezeli a Redis a memóriát?

Question

Accepted Answer

Mivel a Redis az adatokat a RAM-ban tárja, **a memóriagazdálkodás** kritikus — a `maxmemory` limit, **kiürítési szabályzatok**, memóriaoptimalizálás és monitoring ismerete elengedhetetlen a Redis megbízható futtatásához anélkül, hogy kifogyunk a memóriából.

## maxmemory és kiürítés

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

A `maxmemory` beállítása plus egy **kiürítési szabályzat** szabályozza a viselkedést, amikor a memória megtöltődik — elengedhetetlen ahhoz, hogy megakadályozzuk, hogy a Redis kimerítse a rendszermemóriát vagy összeomoljon.

## Memóriamonitoring

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

## Memóriaoptimalizálási technikák

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

## Miért fontos a memória a Redisben

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

## Miért számít ez

A Redis memóriagazdálkodásának megértése fontos a **Redis megbízható futtatásához**, mivel a Redis az adatokat korlátozott, viszonylag drága RAM-ban tárja, így a memória kezelése elengedhetetlen annak megakadályozásához, hogy kifogyjon (kiürítéseket, elutasított írásokat vagy összeomlásokat okozva).

Az alapvető gyakorlat — a **`maxmemory`** beállítása (a Redis memóriájának korlátozása) plus egy **kiürítési szabályzat** — kritikus: szabályozza, mi történik, amikor a limit elérik (kulcsok kiürítése olyan szabályzatok szerint, mint az `allkeys-lru` tiszta gyorsítótárhoz, vagy a `noeviction` az írások elutasításához, amikor a Redis fontos adatokat tárol), megakadályozva, hogy a Redis kimerítse a rendszermemóriát.

A megfelelő kiürítési szabályzat kiválasztása az adott felhasználási esethez (LRU/LFU gyorsítótárakhoz, noeviction vagy volatilis szabályzatok, amikor az adatok fontosak) kulcsfontosságú konfigurációs döntés. **A memória monitorozása** (`INFO memory` a felhasználáshoz, csúcshoz, fragmentációhoz és kiürített kulcsokhoz; `MEMORY USAGE` kulcsonként) elengedhetetlen az operatív tudatossághoz — a felhasználás megfigyelése a limit ellen és a problémák időben történő felismerése.

A **memóriaoptimalizálási technikák** ismerete — TTL-ek használata a szükségtelen adatok lejáratásához, hatékony adatstruktúrák kiválasztása (kis hash-ek/listák kompakt kódolást használnak, sokkal olcsóbb, mint sok külön kulcs), hatalmas kulcsok elkerülése (amelyek késleltetési csúcsokat okoznak), és csak a szükséges adatok tárolása — segít több adat elférésében a memóriában és hatékony futásban.

Mivel a Redis memórián belüli természete a memóriát véges, kritikus erőforrássá teszi, és mivel a megfelelő memóriagazdálkodás (maxmemory + kiürítési szabályzat, monitoring és optimalizálás) az, ami a Redis-t egészségesnek tartja és megakadályozza a memóriavéget, a Redis memóriagazdálkodásának megértése fontos, gyakorlatilag releváns tudás a Redis megbízható üzemeltetéséhez, egy kulcsfontosságú operatív szempont, amely megkülönbözteti azokat, akik tudnak Redis-t produkciós környezetben futtatni, azoktól, akik csak annak használatát tudják, és elengedhetetlen az olyan valós hibák elkerüléséhez, amelyek a kezeletlen memóriafejlődésből erednek.