Scripting Lua avec Redis : Optimisez vos opérations

Introduction

Dans ce laboratoire, vous explorerez le scripting Lua Redis, en vous concentrant sur l'exécution de scripts Lua directement dans Redis pour effectuer des opérations complexes de manière efficace. Ce laboratoire couvre l'utilisation de la commande EVAL pour exécuter des scripts, la transmission d'arguments aux scripts, le chargement de scripts avec SCRIPT LOAD, et l'exécution de scripts chargés avec EVALSHA.

Nous commencerons par exécuter un script Lua simple qui incrémente un compteur Redis en utilisant EVAL, démontrant comment spécifier le script, le nombre de clés auxquelles il accède, et les noms des clés. Ensuite, nous apprendrons comment charger des scripts dans Redis et les exécuter en utilisant leur hachage SHA1, améliorant ainsi les performances en évitant la transmission répétée du script.

Exécuter un script Lua avec EVAL

Dans cette étape, nous allons explorer comment exécuter des scripts Lua directement dans Redis en utilisant la commande EVAL. Cela vous permet d'effectuer des opérations complexes sur vos données en une seule requête, réduisant ainsi la latence du réseau et améliorant les performances.

Avant de commencer, comprenons les bases de EVAL. La commande EVAL prend deux arguments principaux :

Le script Lua lui-même, sous forme de chaîne de caractères.
Le nombre de clés auxquelles le script accédera, suivi des noms de clés réels et de tous les arguments supplémentaires que vous souhaitez transmettre au script.

Voici un exemple simple pour vous aider à démarrer. Nous allons créer un script Lua qui incrémente un compteur Redis et renvoie la nouvelle valeur.

Ouvrez votre terminal et connectez-vous au serveur Redis en utilisant l'interface de ligne de commande Redis (redis-cli).
```
redis-cli
```
Maintenant, exécutons un script Lua en utilisant EVAL. Ce script incrémentera un compteur nommé mycounter et renverra la valeur incrémentée.
```
EVAL "local current = redis.call('INCR', KEYS[1]); return current" 1 mycounter
```
Décomposons cette commande :
- EVAL "local current = redis.call('INCR', KEYS[1]); return current": C'est le script Lua lui-même. Il utilise redis.call('INCR', KEYS[1]) pour incrémenter la valeur de la clé spécifiée dans KEYS[1]. Le tableau KEYS contient les noms de clés transmis au script. Enfin, il renvoie la valeur incrémentée.
- 1: Cela indique que le script accédera à une clé.
- mycounter: C'est le nom de la clé à laquelle le script accédera.
Vous devriez voir une sortie similaire à celle-ci :
```
(integer) 1
```
Si vous exécutez à nouveau la même commande, vous verrez le compteur s'incrémenter :
```
EVAL "local current = redis.call('INCR', KEYS[1]); return current" 1 mycounter
```
Sortie :
```
(integer) 2
```
Vérifions la valeur de la clé mycounter en utilisant la commande GET :
```
GET mycounter
```
Sortie :
```
"2"
```
Comme vous pouvez le constater, le script Lua a incrémenté le compteur avec succès.
Maintenant, essayons un autre exemple. Cette fois, nous allons créer un script qui définit une clé à une valeur spécifique si elle n'existe pas déjà.
```
EVAL "if redis.call('EXISTS', KEYS[1]) == 0 then redis.call('SET', KEYS[1], ARGV[1]); return 1 else return 0 end" 1 mykey myvalue
```
Dans cette commande :
- EVAL "if redis.call('EXISTS', KEYS[1]) == 0 then redis.call('SET', KEYS[1], ARGV[1]); return 1 else return 0 end": C'est le script Lua. Il vérifie si la clé KEYS[1] existe. Si ce n'est pas le cas, il définit la clé à la valeur ARGV[1] et renvoie 1. Sinon, il renvoie 0.
- 1: Cela indique que le script accédera à une clé.
- mykey: C'est le nom de la clé.
- myvalue: C'est la valeur à définir si la clé n'existe pas.
Vous devriez voir une sortie similaire à celle-ci :
```
(integer) 1
```
Cela indique que la clé mykey a été définie à myvalue.

Vérifions la valeur de mykey :

GET mykey

Sortie :

"myvalue"

Si vous exécutez à nouveau la commande EVAL :

EVAL "if redis.call('EXISTS', KEYS[1]) == 0 then redis.call('SET', KEYS[1], ARGV[1]); return 1 else return 0 end" 1 mykey myvalue

Sortie :

(integer) 0

Cette fois, le script a renvoyé 0 car la clé existait déjà.

Quittez redis-cli. Ceci est important pour que les modifications soient enregistrées.
```
exit
```

Passer des arguments à un script avec EVAL

Dans l'étape précédente, nous avons appris à exécuter des scripts Lua avec EVAL et à accéder aux clés. Maintenant, explorons comment transmettre des arguments à ces scripts. Cela permet de créer des scripts plus dynamiques et réutilisables.

Rappelez-vous que la commande EVAL prend les arguments suivants :

Le script Lua lui-même, sous forme de chaîne de caractères.
Le nombre de clés auxquelles le script accédera.
Les noms des clés.
Tous les arguments supplémentaires que vous souhaitez transmettre au script. Ces arguments sont accessibles dans le script Lua en utilisant le tableau ARGV.

Commençons par un exemple. Nous allons créer un script Lua qui ajoute une valeur à un compteur Redis. La clé du compteur et la valeur à ajouter seront transmises en tant qu'arguments.

Connectez-vous au serveur Redis en utilisant l'interface de ligne de commande Redis (redis-cli).
```
redis-cli
```
Maintenant, exécutons un script Lua en utilisant EVAL qui incrémente un compteur d'un montant spécifié.
```
EVAL "local current = redis.call('INCRBY', KEYS[1], ARGV[1]); return current" 1 mycounter 5
```
Décomposons cette commande :
- EVAL "local current = redis.call('INCRBY', KEYS[1], ARGV[1]); return current": C'est le script Lua. Il utilise redis.call('INCRBY', KEYS[1], ARGV[1]) pour incrémenter la valeur de la clé spécifiée dans KEYS[1] du montant spécifié dans ARGV[1].
- 1: Cela indique que le script accédera à une clé.
- mycounter: C'est le nom de la clé à laquelle le script accédera.
- 5: C'est l'argument qui sera transmis au script et accessible en tant que ARGV[1].
Vous devriez voir une sortie similaire à celle-ci (en supposant que mycounter était à 2 depuis l'étape précédente) :
```
(integer) 7
```
Le script a incrémenté la clé mycounter de 5.
Vérifions la valeur de la clé mycounter en utilisant la commande GET :
```
GET mycounter
```
Sortie :
```
"7"
```
Maintenant, essayons un autre exemple avec des arguments de type chaîne de caractères. Nous allons créer un script qui définit une clé à une valeur, où la clé et la valeur sont transmises en tant qu'arguments.
```
EVAL "redis.call('SET', KEYS[1], ARGV[1]); return ARGV[1]" 1 mynewkey mynewvalue
```
Dans cette commande :
- EVAL "redis.call('SET', KEYS[1], ARGV[1]); return ARGV[1]": C'est le script Lua. Il définit la clé KEYS[1] à la valeur ARGV[1] et renvoie la valeur.
- 1: Cela indique que le script accédera à une clé.
- mynewkey: C'est le nom de la clé.
- mynewvalue: C'est la valeur à définir.
Vous devriez voir une sortie similaire à celle-ci :
```
"mynewvalue"
```
Vérifions la valeur de mynewkey :
```
GET mynewkey
```
Sortie :
```
"mynewvalue"
```
Le script a défini avec succès la clé mynewkey à la valeur mynewvalue.
Vous pouvez transmettre plusieurs arguments au script. Par exemple, créons un script qui concatène deux chaînes de caractères transmises en tant qu'arguments et définit le résultat sur une clé.
```
EVAL "local result = ARGV[1] .. ARGV[2]; redis.call('SET', KEYS[1], result); return result" 1 combinedkey hello world
```
Dans cette commande :
- EVAL "local result = ARGV[1] .. ARGV[2]; redis.call('SET', KEYS[1], result); return result": C'est le script Lua. Il concatène ARGV[1] et ARGV[2] en utilisant l'opérateur .., définit la clé KEYS[1] au résultat, et renvoie le résultat.
- 1: Cela indique que le script accédera à une clé.
- combinedkey: C'est le nom de la clé.
- hello: C'est le premier argument de type chaîne de caractères.
- world: C'est le deuxième argument de type chaîne de caractères.
Vous devriez voir une sortie similaire à celle-ci :
```
"helloworld"
```
Vérifions la valeur de combinedkey :
```
GET combinedkey
```
Sortie :
```
"helloworld"
```
Quittez redis-cli. Ceci est important pour que les modifications soient enregistrées.
```
exit
```

Charger un script avec SCRIPT LOAD

Dans les étapes précédentes, nous avons exécuté des scripts Lua directement en utilisant la commande EVAL. Bien que cela soit utile pour les scripts simples, cela peut devenir fastidieux pour les scripts plus volumineux et plus complexes. Redis fournit la commande SCRIPT LOAD pour charger des scripts dans le cache de scripts du serveur Redis. Cela vous permet d'exécuter le script plusieurs fois sans avoir à envoyer l'intégralité du script à chaque fois, ce qui améliore les performances.

La commande SCRIPT LOAD prend un seul argument : le script Lua lui-même. Elle renvoie le hachage SHA1 du script, que vous pouvez ensuite utiliser pour exécuter le script à l'aide de la commande EVALSHA (que nous aborderons dans l'étape suivante).

Voyons comment cela fonctionne.

Connectez-vous au serveur Redis en utilisant l'interface de ligne de commande Redis (redis-cli).
```
redis-cli
```
Maintenant, chargeons un script Lua en utilisant SCRIPT LOAD. Nous utiliserons le même script que dans l'étape précédente qui incrémente un compteur d'un montant spécifié.
```
SCRIPT LOAD "local current = redis.call('INCRBY', KEYS[1], ARGV[1]); return current"
```
Cette commande chargera le script dans le cache de scripts du serveur Redis et renverra le hachage SHA1 du script. Vous devriez voir une sortie similaire à celle-ci :
```
"6b1e8dd2999cb08546e74339c0c9489f9f89a84b"
```
Il s'agit du hachage SHA1 du script. Prenez note de ce hachage, car vous en aurez besoin à l'étape suivante. La valeur exacte du hachage peut différer.
Maintenant, chargeons le script qui définit une clé à une valeur, où la clé et la valeur sont transmises en tant qu'arguments.
```
SCRIPT LOAD "redis.call('SET', KEYS[1], ARGV[1]); return ARGV[1]"
```
Vous devriez voir une sortie similaire à celle-ci :
```
"a8b2b3648969459a8198262a9166e945e890987c"
```
Encore une fois, prenez note de ce hachage.
Chargeons le script qui concatène deux chaînes de caractères transmises en tant qu'arguments et définit le résultat sur une clé.
```
SCRIPT LOAD "local result = ARGV[1] .. ARGV[2]; redis.call('SET', KEYS[1], result); return result"
```
Vous devriez voir une sortie similaire à celle-ci :
```
"d2a800a974ca96849295220424f9a0664a495345"
```
Prenez également note de ce hachage.
Vous pouvez vérifier que les scripts sont chargés en utilisant la commande SCRIPT EXISTS. Cette commande prend un ou plusieurs hachages SHA1 comme arguments et renvoie un tableau de 0 et de 1, où 1 indique que le script avec le hachage correspondant est chargé et 0 indique qu'il ne l'est pas.

Par exemple, pour vérifier si le premier script que nous avons chargé est toujours chargé, utilisez la commande suivante, en remplaçant le hachage par celui que vous avez obtenu à l'étape 2 :
```
SCRIPT EXISTS 6b1e8dd2999cb08546e74339c0c9489f9f89a84b
```
Sortie :
```
1) (integer) 1
```
Cela indique que le script est chargé.

Si vous essayez de vérifier un script qui n'est pas chargé :
```
SCRIPT EXISTS 0000000000000000000000000000000000000000
```
Sortie :
```
1) (integer) 0
```
Cela indique que le script n'est pas chargé.
Quittez redis-cli. Ceci est important pour que les modifications soient enregistrées.
```
exit
```

Exécuter un script chargé avec EVALSHA

Dans l'étape précédente, nous avons appris à charger des scripts Lua dans le cache de scripts du serveur Redis à l'aide de la commande SCRIPT LOAD. Maintenant, nous allons apprendre à exécuter ces scripts chargés à l'aide de la commande EVALSHA.

La commande EVALSHA prend les arguments suivants :

Le hachage SHA1 du script chargé.
Le nombre de clés auxquelles le script accédera.
Les noms des clés.
Tous les arguments supplémentaires que vous souhaitez transmettre au script.

L'utilisation de EVALSHA est plus efficace que EVAL lorsque vous devez exécuter le même script plusieurs fois, car cela évite d'envoyer l'intégralité du script au serveur à chaque fois.

Voyons comment cela fonctionne.

Connectez-vous au serveur Redis en utilisant l'interface de ligne de commande Redis (redis-cli).
```
redis-cli
```
Maintenant, exécutons le script Lua qui incrémente un compteur d'un montant spécifié en utilisant EVALSHA. Vous souvenez-vous du hachage SHA1 que vous avez obtenu à l'étape précédente pour le script local current = redis.call('INCRBY', KEYS[1], ARGV[1]); return current ? Si ce n'est pas le cas, vous devrez charger à nouveau le script en utilisant SCRIPT LOAD. Pour cet exemple, nous supposerons que le hachage est 6b1e8dd2999cb08546e74339c0c9489f9f89a84b.
```
EVALSHA 6b1e8dd2999cb08546e74339c0c9489f9f89a84b 1 mycounter 5
```
Décomposons cette commande :
- EVALSHA 6b1e8dd2999cb08546e74339c0c9489f9f89a84b: Cela spécifie que nous voulons exécuter le script avec le hachage SHA1 6b1e8dd2999cb08546e74339c0c9489f9f89a84b.
- 1: Cela indique que le script accédera à une clé.
- mycounter: C'est le nom de la clé à laquelle le script accédera.
- 5: C'est l'argument qui sera transmis au script et accessible en tant que ARGV[1].
Vous devriez voir une sortie similaire à celle-ci (en supposant que mycounter était à 7 depuis l'étape précédente) :
```
(integer) 12
```
Le script a incrémenté la clé mycounter de 5.
Vérifions la valeur de la clé mycounter en utilisant la commande GET :
```
GET mycounter
```
Sortie :
```
"12"
```
Maintenant, exécutons le script qui définit une clé à une valeur en utilisant EVALSHA. Vous souvenez-vous du hachage SHA1 que vous avez obtenu à l'étape précédente pour le script redis.call('SET', KEYS[1], ARGV[1]); return ARGV[1] ? Si ce n'est pas le cas, vous devrez charger à nouveau le script en utilisant SCRIPT LOAD. Pour cet exemple, nous supposerons que le hachage est a8b2b3648969459a8198262a9166e945e890987c.
```
EVALSHA a8b2b3648969459a8198262a9166e945e890987c 1 anotherkey anothervalue
```
Vous devriez voir une sortie similaire à celle-ci :
```
"anothervalue"
```
Vérifions la valeur de anotherkey :
```
GET anotherkey
```
Sortie :
```
"anothervalue"
```
Si vous essayez d'exécuter un script avec un hachage SHA1 invalide, vous obtiendrez une erreur :
```
EVALSHA 0000000000000000000000000000000000000000 1 mykey myvalue
```
Sortie :
```
(error) NOSCRIPT No matching script. Please use EVAL.
```
Cela indique que le script avec le hachage SHA1 spécifié n'est pas chargé.
Quittez redis-cli. Ceci est important pour que les modifications soient enregistrées.
```
exit
```

Résumé

Dans ce lab, vous avez exploré les scripts Lua Redis, en vous concentrant sur l'exécution directe de scripts à l'aide de la commande EVAL. Nous avons appris que EVAL prend le script Lua sous forme de chaîne de caractères, le nombre de clés accédées et les noms des clés eux-mêmes comme arguments. Nous nous sommes entraînés à incrémenter un compteur Redis à l'aide d'un script Lua dans EVAL, en observant comment le script accédait et modifiait la clé spécifiée.

De plus, nous avons appris à transmettre des arguments aux scripts Lua, à charger des scripts dans Redis à l'aide de SCRIPT LOAD et à exécuter des scripts chargés à l'aide de EVALSHA. N'oubliez pas de quitter redis-cli après chaque étape pour vous assurer que vos commandes sont correctement enregistrées (logged). Cela permet une exécution plus efficace des scripts complexes.