A Redis parancsok, amiket minden fejlesztőnek ismernie kell

A mai gyorsan változó szoftverfejlesztési világban a teljesítmény és a skálázhatóság kulcsfontosságú. Ahogy az alkalmazások egyre komplexebbé válnak, és egyre nagyobb adatmennyiséget kell kezelniük, úgy nő a gyors, hatékony és rugalmas adatkezelési megoldások iránti igény. Itt lép színre a Redis.

A Redis (Remote Dictionary Server) egy nyílt forráskódú, memóriában tárolt, kulcs-érték alapú adattároló, amely adatszerkezet-szerverként is funkcionál. Ez azt jelenti, hogy nem csupán egyszerű stringeket képes tárolni, hanem számos komplexebb adatszerkezetet, mint például listákat, halmazokat, hash-eket vagy rendezett halmazokat is, mindezt villámgyors sebességgel. A Redis széles körben használt gyorsítótárként, üzenetsor-kezelőként, valós idejű analitikához, munkamenet-kezeléshez és még sok másra. Képességei miatt vált nélkülözhetetlen eszközzé a modern fejlesztői eszköztárban.

Ahhoz, hogy teljes mértékben kihasználhassuk a Redis erejét, elengedhetetlen ismerni a legalapvetőbb és leggyakrabban használt parancsait. Ez a cikk egy átfogó útmutatót nyújt a legfontosabb Redis parancsokhoz, amelyeket minden fejlesztőnek ismernie kell, adatszerkezetekre bontva, példákkal és gyakorlati felhasználási javaslatokkal.

A Redis alapjai: Kulcsok és Adatszerkezetek

Minden adatot a Redisben egy kulccsal (key) azonosítunk. Ezek a kulcsok binárisan biztonságosak, ami azt jelenti, hogy bármilyen string (akár bináris adat) lehet kulcs vagy érték. A Redis ereje abban rejlik, hogy nem csupán egyszerű kulcs-érték párokat, hanem komplexebb adatszerkezeteket is képes kezelni, mint például:

Stringek (Strings): Egyszerű szöveges vagy bináris értékek.
Listák (Lists): Rendezett gyűjtemények, elemek hozzáadása és kivétele a lista elejéről vagy végéről.
Hash-ek (Hashes): Objektumok tárolására alkalmas kulcs-érték párok gyűjteménye.
Halmazok (Sets): Rendezettlen, egyedi elemekből álló gyűjtemények.
Rendezett Halmazok (Sorted Sets): Halmazok, ahol minden elemhez egy lebegőpontos szám (score) tartozik, ami alapján rendezve van.

Most nézzük meg részletesebben ezeket az adatszerkezeteket és a hozzájuk tartozó parancsokat.

1. String (Karakterlánc) Parancsok

A stringek a Redis legegyszerűbb adattípusai, egy kulcshoz egy string érték tartozik. Akár 512 MB méretű is lehet egy string. Ideálisak gyorsítótárazáshoz, számlálókhoz vagy munkamenet-azonosítókhoz.

SET key value: Beállítja a megadott kulcs értékét. Ha a kulcs már létezik, felülírja azt.
```
SET mykey "Hello Redis"
```
GET key: Lekéri a megadott kulcs értékét.
```
GET mykey  # "Hello Redis"
```
DEL key [key ...]: Töröl egy vagy több kulcsot. Ez a parancs minden adattípusra érvényes.
```
DEL mykey
```
INCR key: Atomikus módon növeli a kulcs értékét 1-gyel. Csak egész számokat tartalmazó stringeken működik.
```
SET counter 0
INCR counter   # 1
INCR counter   # 2
```
DECR key: Atomikus módon csökkenti a kulcs értékét 1-gyel.
```
DECR counter   # 1
```
INCRBY key increment: Növeli a kulcs értékét a megadott increment értékkel.
```
INCRBY counter 5  # 6
```
APPEND key value: Hozzáfüzi az value-t a kulcs aktuális értékéhez.
```
SET mykey "Hello"
APPEND mykey " World" # "Hello World"
```
GETRANGE key start end: Lekéri a string egy részét a megadott indexek között.
```
GETRANGE mykey 0 4 # "Hello"
```
SETEX key seconds value: Beállítja a kulcs értékét és egyidejűleg lejárati időt (TTL) ad hozzá másodpercekben. Kiváló gyorsítótárazáshoz.
```
SETEX cache:item:123 60 "cached_data" # A kulcs 60 másodperc múlva lejár
```
MSET key1 value1 [key2 value2 ...]: Több kulcs-érték pár beállítása egyszerre.
```
MSET user:1:name "Alice" user:1:email "[email protected]"
```
MGET key1 [key2 ...]: Több kulcs értékének lekérése egyszerre.
```
MGET user:1:name user:1:email # ["Alice", "[email protected]"]
```

2. List (Lista) Parancsok

A listák rendezett string gyűjtemények. Kettős láncolt listaként vannak implementálva, ami lehetővé teszi a gyors hozzáadást és eltávolítást mind a lista elejéről, mind a végéről. Ideálisak üzenetsorok, feladatlisták vagy a legutóbbi elemek tárolására.

LPUSH key value [value ...]: Egy vagy több elemet ad hozzá a lista elejéhez (bal oldal).
```
LPUSH mylist "task1" "task2"
# A lista most: ["task2", "task1"]
```
RPUSH key value [value ...]: Egy vagy több elemet ad hozzá a lista végéhez (jobb oldal).
```
RPUSH mylist "task3"
# A lista most: ["task2", "task1", "task3"]
```
LPOP key: Eltávolítja és visszaadja a lista első elemét. Stack-ként való használathoz (LIFO).
```
LPOP mylist # "task2"
# A lista most: ["task1", "task3"]
```
RPOP key: Eltávolítja és visszaadja a lista utolsó elemét. Queue-ként való használathoz (FIFO).
```
RPOP mylist # "task3"
# A lista most: ["task1"]
```

LRANGE key start stop: Lekéri a lista elemeinek egy tartományát. Az 0 az első elem, -1 az utolsó.

RPUSH recent:posts "Post A" "Post B" "Post C"
LRANGE recent:posts 0 -1 # ["Post A", "Post B", "Post C"]
LRANGE recent:posts 0 1 # ["Post A", "Post B"]

LLEN key: Visszaadja a lista hosszát.
```
LLEN recent:posts # 3
```
LINDEX key index: Visszaadja a lista index pozícióján lévő elemét.
```
LINDEX recent:posts 1 # "Post B"
```
LTRIM key start stop: Csak a megadott tartományban lévő elemeket tartja meg, a többit törli. Gyakran használják korlátozott méretű listák fenntartására (pl. a 10 legutóbbi elem).
```
LPUSH logs "log_entry_1" "log_entry_2" "log_entry_3"
LTRIM logs 0 1 # Csak az első két elemet tartja meg
LRANGE logs 0 -1 # ["log_entry_3", "log_entry_2"]
```

3. Hash (Hashmap/Objektum) Parancsok

A hash-ek tökéletesek objektumok, például felhasználói profilok vagy termékadatok tárolására. Egy hash egy kulcs-érték párok gyűjteménye, ahol minden kulcs egy mezőnek (field) felel meg, és az értéke ennek a mezőnek a string értéke. Képzeljünk el egy JSON objektumot.

HSET key field value [field value ...]: Beállít egy vagy több mező-érték párt a hash-ben.
```
HSET user:100 name "John Doe" email "[email protected]" age 30
```
HGET key field: Lekéri a megadott mező értékét a hash-ből.
```
HGET user:100 name # "John Doe"
```

HGETALL key: Lekéri az összes mezőt és értékét a hash-ből.

HGETALL user:100
# 1) "name"
# 2) "John Doe"
# 3) "email"
# 4) "[email protected]"
# 5) "age"
# 6) "30"

HMGET key field1 [field2 ...]: Lekér több mező értékét a hash-ből.
```
HMGET user:100 name email # ["John Doe", "[email protected]"]
```
HDEL key field [field ...]: Töröl egy vagy több mezőt a hash-ből.
```
HDEL user:100 age
```

HEXISTS key field: Ellenőrzi, hogy egy mező létezik-e a hash-ben.

HEXISTS user:100 name # 1 (true)
HEXISTS user:100 password # 0 (false)

HKEYS key: Lekéri a hash összes mezőnevét.
```
HKEYS user:100 # ["name", "email"]
```

HVALS key: Lekéri a hash összes értékét.

HVALS user:100 # ["John Doe", "[email protected]"]

4. Set (Halmaz) Parancsok

A halmazok rendezetlen gyűjtemények, amelyek egyedi string elemeket tartalmaznak. Ideálisak egyedi azonosítók tárolására, címkék kezelésére, vagy közös elemek keresésére több halmaz között.

SADD key member [member ...]: Egy vagy több elemet ad hozzá a halmazhoz. Ha egy elem már létezik, figyelmen kívül hagyja.
```
SADD tags:article:1 "redis" "database" "nosql" "redis"
# A halmaz most: {"redis", "database", "nosql"}
```

SMEMBERS key: Lekéri a halmaz összes elemét.

SMEMBERS tags:article:1 # {"redis", "database", "nosql"} (a sorrend nem garantált)

SISMEMBER key member: Ellenőrzi, hogy egy adott elem tagja-e a halmaznak.

SISMEMBER tags:article:1 "redis" # 1 (true)
SISMEMBER tags:article:1 "cache" # 0 (false)

SREM key member [member ...]: Eltávolít egy vagy több elemet a halmazból.
```
SREM tags:article:1 "database"
```
SCARD key: Visszaadja a halmaz elemeinek számát.
```
SCARD tags:article:1 # 2
```
SUNION key1 [key2 ...]: Visszaadja az összes halmaz egyesítését (union).
```
SADD set1 "A" "B"
SADD set2 "B" "C"
SUNION set1 set2 # {"A", "B", "C"}
```
SINTER key1 [key2 ...]: Visszaadja az összes halmaz metszetét (intersection).
```
SINTER set1 set2 # {"B"}
```
SDIFF key1 [key2 ...]: Visszaadja az első halmaz és a többi halmaz különbségét (difference).
```
SDIFF set1 set2 # {"A"}
```

5. Sorted Set (Rendezett Halmaz) Parancsok

A rendezett halmazok a halmazokhoz hasonlóan egyedi string elemeket tárolnak, de minden elemhez tartozik egy lebegőpontos szám (score). Ezek az elemek a score alapján vannak rendezve, így ideálisak ranglisták, pontszámok vagy időbélyegek kezelésére.

ZADD key score member [score member ...]: Hozzáad egy vagy több elemet a rendezett halmazhoz, a hozzájuk tartozó score-ral.
```
ZADD leaderboard 100 "PlayerA" 150 "PlayerB" 75 "PlayerC"
```
ZRANGE key start stop [WITHSCORES]: Lekéri az elemeket a megadott index tartományból, növekvő score sorrendben. A WITHSCORES opcióval a score-okat is visszaadja.
```
ZRANGE leaderboard 0 -1 WITHSCORES
# 1) "PlayerC"
# 2) "75"
# 3) "PlayerA"
# 4) "100"
# 5) "PlayerB"
# 6) "150"
```

ZREVRANGE key start stop [WITHSCORES]: Ugyanaz, mint a ZRANGE, de csökkenő score sorrendben. Kiváló ranglistákhoz.

ZREVRANGE leaderboard 0 1 WITHSCORES # Az első két helyezett
# 1) "PlayerB"
# 2) "150"
# 3) "PlayerA"
# 4) "100"

ZRANGEBYSCORE key min max [WITHSCORES]: Lekéri az elemeket a megadott score tartományból.
```
ZRANGEBYSCORE leaderboard 100 200 WITHSCORES # PlayerA és PlayerB
```
ZSCORE key member: Lekéri egy adott tag score-ját.
```
ZSCORE leaderboard "PlayerA" # "100"
```
ZREM key member [member ...]: Eltávolít egy vagy több tagot a rendezett halmazból.
```
ZREM leaderboard "PlayerC"
```
ZINCRBY key increment member: Növeli egy tag score-ját a megadott értékkel.
```
ZINCRBY leaderboard 50 "PlayerA" # PlayerA score-ja 150 lesz
```

Általános Kulcskezelési és Rendszer Parancsok

Ezek a parancsok az adatszerkezettől függetlenül működnek, és a kulcsok, valamint a Redis szerver általános kezelésére szolgálnak.

EXPIRE key seconds: Beállít egy lejárati időt (TTL) egy kulcsra másodpercekben. A kulcs automatikusan törlődik a megadott idő elteltével.
```
SET cache:data "valuable_info"
EXPIRE cache:data 3600 # 1 óra múlva lejár
```
TTL key: Visszaadja a kulcs hátralévő lejárati idejét másodpercekben.
```
TTL cache:data # pl. 3590
```
PERSIST key: Eltávolítja a lejárati időt egy kulcsról, így az nem jár le automatikusan.
```
PERSIST cache:data
```
TYPE key: Visszaadja egy kulcs adattípusát (pl. string, list, hash, set, zset, none ha nem létezik).
```
TYPE mykey # "string"
```
EXISTS key [key ...]: Ellenőrzi, hogy egy vagy több kulcs létezik-e.
```
EXISTS mykey # 1 (true)
```

KEYS pattern: Visszaadja az összes olyan kulcsot, amely megfelel a megadott mintának.

KEYS user:* # Óvatosan használd éles környezetben, mert nagy adatbázis esetén blokkolhatja a szervert!

Pub/Sub (Publish/Subscribe)

A Redis beépített Publish/Subscribe (Pub/Sub) mechanizmusával valós idejű üzenetküldő rendszereket építhetünk ki. A kliensek feliratkozhatnak (SUBSCRIBE) csatornákra, és üzeneteket küldhetnek (PUBLISH) ezekre a csatornákra. Ideális chatekhez, értesítésekhez vagy esemény-streameléshez.

PUBLISH channel message: Üzenetet küld egy adott csatornára.
```
PUBLISH chat:general "Hello everyone!"
```
SUBSCRIBE channel [channel ...]: Feliratkozik egy vagy több csatornára. Egy külön kliens kapcsolat szükséges a feliratkozáshoz, mivel az blokkoló művelet.
```
SUBSCRIBE chat:general system:alerts
```

Tranzakciók a Redisben (MULTI, EXEC, DISCARD)

A Redis támogatja a tranzakciókat, amelyek lehetővé teszik több parancs atomikus végrehajtását. Ez azt jelenti, hogy az összes parancs egyetlen lépésben, megszakítás nélkül fut le, garantálva az adatok konzisztenciáját.

MULTI: Elindít egy tranzakciót. Az ezután küldött parancsok sorba kerülnek, de nem futnak le azonnal.
```
MULTI
```

EXEC: Végrehajtja a sorba állított parancsokat.

SET user:200:posts 0
INCR user:200:posts
RPUSH user:200:activity "post_created"
EXEC
# Mindkét parancs atomikusan fut le

DISCARD: Megszakítja a tranzakciót, törli az összes sorba állított parancsot.
```
DISCARD
```
WATCH key [key ...]: Optimista zárolás biztosítására szolgál. Figyeli a megadott kulcsok változásait a MULTI parancs előtt. Ha a WATCH-olt kulcsok bármelyike megváltozik az WATCH és az EXEC között, a tranzakció meghiúsul.
```
WATCH mykey
GET mykey
MULTI
SET mykey "newvalue"
EXEC # Csak akkor fut le, ha a mykey nem változott WATCH óta
```

Redis a Gyakorlatban: Jó Tanácsok és Haladó Funkciók

A fenti parancsok ismerete elengedhetetlen, de a Redis valódi ereje a megfelelő használatában és a haladó funkciók kiaknázásában rejlik.

Adattípus választás: Mindig a feladathoz legmegfelelőbb adatszerkezetet válaszd. Egy számlálóhoz stringet, egy felhasználói profilhoz hash-t, egy ranglistához rendezett halmazt használj. A helyes választás drámaian javítja a teljesítményt és csökkenti a memóriahasználatot.
Memória-optimalizálás: A Redis memóriában tárolja az adatokat, ezért fontos odafigyelni a memóriahasználatra. Használj rövid kulcsneveket és értékeket, ahol lehetséges. A MEMORY USAGE parancs segít a memóriafogyasztás elemzésében.
Perzisztencia: A Redis adatokat képes a lemezre írni (RDB snapshotting és AOF – Append Only File), így az adatok megmaradnak a szerver újraindítása után is. Éles környezetben ez alapvető a megbízhatóság érdekében.
Pipelining: Több parancsot küldhetsz a Redis szervernek egyetlen hálózati oda-vissza út (round-trip) során. Ez jelentősen csökkentheti a hálózati késleltetést, és növelheti az átviteli sebességet, különösen sok kis parancs esetén.
```
# A kliens oldalon:
pipeline.SET("key1", "value1")
pipeline.GET("key2")
pipeline.INCR("counter")
results = pipeline.execute()
```
Lua szkriptek: A Redis támogatja a Lua szkriptek futtatását a szerveren. Ezek a szkriptek atomikusan futnak, ami azt jelenti, hogy egyetlen szkript végrehajtása során a Redis nem hajt végre más parancsokat. Ez rendkívül hasznos komplexebb, több lépésből álló műveletek atomikus végrehajtásához.
Redis Cluster: Nagyméretű, skálázható alkalmazásokhoz a Redis Cluster biztosítja az adatok automatikus felosztását több Redis példány között (sharding) és a magas rendelkezésre állást.
Tranzakciók és WATCH: A WATCH parancs, kombinálva a MULTI és EXEC parancsokkal, lehetővé teszi az optimista zárolást, ami kritikus a konzisztens adatok fenntartásához versengő környezetekben.

Összegzés

A Redis egy rendkívül sokoldalú és nagy teljesítményű eszköz, amely modern alkalmazások széles skálájának gerincét képezi. A fenti parancsok megismerése és megértése alapvető lépés a Redis mesterévé váláshoz. Legyen szó gyorsítótárazásról, valós idejű kommunikációról, adatsorok kezeléséről vagy komplex adatszerkezetek tárolásáról, a Redis a megfelelő parancsokkal a kezedben képes lesz felgyorsítani és leegyszerűsíteni a fejlesztési folyamatokat.

Ne félj kísérletezni! Indíts el egy helyi Redis szervert, és próbáld ki a parancsokat a redis-cli segítségével. Ez a legjobb módja annak, hogy mélyebben megértsd a működését és felfedezd a benne rejlő potenciált. A Redis-zel a kezedben olyan alkalmazásokat építhetsz, amelyek nem csak funkcionálisak, hanem villámgyorsak és rendkívül hatékonyak is.