Tutoriel Redis : premiers pas avec cette technologie de base de données

Ces dernières années, le système de base de données Redis n’a cessé de gagner en popularité. Ces avantages résident principalement dans sa rapidité et dans la structure simple des bases de données. Les données sont écrites directement dans la mémoire vive du serveur et peuvent ainsi être consultées nettement plus rapidement que dans d’autres bases de données. Sur le Web, Redis est par conséquent souvent utilisé comme mémoire cache. Les services Messenger utilisent également cette base de données afin de permettre une communication rapide. Nous vous expliquons comment mettre en place votre propre base de données Redis.

Étape 1 : installer Redis

Redis est en open source et peut donc être téléchargé, utilisé et édité librement par tout un chacun.

Note

Nous vous détaillons ci-dessous comment installer et paramétrer Redis sous Ubuntu. Il est toutefois également possible de travailler sous Mac ou Windows. Si dans un premier temps, vous souhaitez uniquement tester Redis sans installer le système sur votre ordinateur, il est recommandé d’utiliser l’environnement de test en ligne Try Redis.

La première étape consiste à télécharger Redis. Pour ce faire, nous utilisons le gestionnaire de paquets d’Ubuntu que nous mettons tout d’abord à jour.

sudo apt-get update
sudo apt-get install redis-server

Il est également possible de télécharger les fichiers depuis le site internet officiel de Redis. Dans ce cas, il vous faudra toutefois décompresser le paquet manuellement, puis procéder à l’installation. Il nous faut ensuite lancer Redis à l’aide d’une commande simple.

redis-server

Pour tester si Redis fonctionne correctement, vous pouvez utiliser l’interface permettant la communication avec Redis. Il faut donc commencer par la lancer.

redis-cli

L’interface affiche à présent l’adresse IP et le port via lequel Redis fonctionne. Ceci nous permet à présent de faire un ping sur ce port.

127.0.0.1:6397> ping
PONG

Redis répond et montre ainsi que le système de base de données a été installé avec succès. Il est également possible de tester si vous pouvez définir des contenus.

127.0.0.1:6397> set test "OK!"
127.0.0.1:6397> get test
"OK!"
Note

Vous souhaitez installer Redis sur votre propre serveur ? Les serveurs cloud de IONOS peuvent être redimensionnés pour de petits projets.

Étape 2 : configurer Redis

Redis a tout d’abord été installé avec la configuration standard. Il est possible de l’afficher à l’aide d’une commande.

127.0.0.1:6397> config get *

Dans la liste présentant l’ensemble des points de configuration, les paires sont toujours affichées les unes en dessous des autres. Par conséquent, le point « dbfilename » comprend la valeur « dump.rdb ». L’astérisque que nous avons utilisé pour consulter la liste n’est qu’une balise pour un point précis de la configuration. Si l’on souhaite uniquement examiner ce point en particulier, il est possible d’insérer le nom de l’entrée à la place de l’astérisque. De cette manière, la recherche porte toujours sur la partie supérieure de la paire de configuration qui correspond à la clé de la valeur correspondante.

127.0.0.1:6397> config get dbfilename
1) "dbfilename"
2) "dump.rdb"

Afin de modifier une entrée dans le fichier de configuration, on utilise la commande set. Elle peut par exemple être utilisée pour définir un mot de passe.

127.0.0.1:6397> config set requirepass "password"
OK

À présent, si l’on souhaite retrouver le mot de passe avec get, il nous est tout d’abord demandé de le saisir puisque nous venons de sécuriser Redis. Pour ce faire, nous utilisons la commande auth. Nous pouvons ensuite interroger l’entrée de configuration de la façon décrite.

127.0.0.1:6397> auth "password"
127.0.0.1:6397> config get requirepass
1) "requirepass"
2) "password"
Note

Il est également possible de sécuriser votre base de données d’autres façons. Différents points ont été résumés par les développeurs sur le site internet officiel.

Redis conserve les ensembles de données dans la mémoire vive. Néanmoins, pour garantir la persistance des données, il est possible de créer sur le disque dur une capture d’écran de la base de données qui sera enregistrée dans le fichier dump.rdb.

127.0.0.1:6397> save

La commandesave nous a permis de créer une capture d’écran. Les sauvegardes peuvent toutefois être automatisées.

127.0.0.1:6397> save 60 10

Dans cet exemple, la commande s’est vu attribuer deux paramètres : une sauvegarde est à présent effectuée toutes les 60 secondes, si dix modifications ont été effectuées dans cet intervalle.

En fonctionnement actif, la commande save n’est toutefois pas idéale, car elle empêche les clients d’accéder à la base de données. bgsave est mieux adaptée car elle fonctionne en arrière-plan.

En dehors de la variante avec capture d’écran, l’autre possibilité consiste en un Append Only File. Dans ce mode, Redis enregistre chaque processus réalisé dans un fichier. Par conséquent, si le serveur Redis devait crasher de façon inopinée, vous pourrez retrouver la dernière opération réalisée. Afin d’activer le mode AOF, il est nécessaire de procéder à une modification dans le fichier de configuration.

127.0.0.1:6397> config set appendonly yes
Conseil

Si vous avez besoin d’une sécurité maximale des données, vous devriez aussi bien générer des captures d’écran régulières qu’activer le mode AOF. Il vous sera alors pratiquement impossible de perdre des données. Toutefois, les processus ralentissent quelque peu la base de données.

Étape 3 : créer des entrées

Après avoir configuré Redis, vous pouvez maintenant utiliser la base de données. Différents types de données, ainsi que différentes commandes, sont utilisés dans ce cadre.

Chaînes

Le plus simple est de mettre en place des chaînes. Pour ce faire, il suffit d’utiliser la commandeset.

Note

L’utilisation des guillemets pour saisir les valeurs n’est pas indispensable. Pour permettre une meilleure lecture du code, on peut toutefois placer le texte entre guillemets et saisir les valeurs numériques sans guillemets.

127.0.0.1:6397> set foo "bar"
127.0.0.1:6397> set value 1

À présent, si l’on consulte les entrées foo et value avec get, les valeurs correspondantes sont affichées.

127.0.0.1:6397> get foo
"bar"
127.0.0.1:6397> get value
"1"

Afin de supprimer une entrée, on utilise la commandedel.

127.0.0.1:6397> del foo
(integer) 1
127.0.0.1:6397> get foo
(nil)

Si vous ne souhaitez pas passer par des lignes de code supplémentaires pour créer plusieurs entrées, vous pouvez utiliser la fonctionnalité avancée mset. La fonctionnalité mget permet par ailleurs de consulter les valeurs de plusieurs entrées simultanément.

127.0.0.1:6397> mset foo1 "bar1" foo2 "bar2" foo3 "bar3"
OK
127.0.0.1:6397> mget foo1 foo2 foo3
1) "bar1"
2) "bar2"
3) "bar3"

Listes

Grâce à Redis, vous pouvez également utiliser d’autres types de données. Les personnes travaillant avec cette base de données apprécient notamment les listes et les sets. Dans les deux cas, il s’agit de collections de valeurs. Alors que les sets ne sont pas triés, les valeurs des listes sont numérotées. Dans les listes, il est possible d’ajouter, de consulter et de supprimer des entrées.

127.0.0.1:6397> lpush mylist foo
(integer) 1
127.0.0.1:6397> lpush mylist bar
(integer) 2
127.0.0.1:6397> lrange mylist 0 10
1) "foo"
2) "bar"
127.0.0.1:6397> linsert mylist before "bar" "test"
(integer) 3
127.0.0.1:6397> lrange mylist 0 10
1) "foo"
2) "test"
3) "bar"
127.0.0.1:6397> lrem mylist 0 foo
(integer) 1
127.0.0.1:6397> lrange mylist 0 10
1) "test"
2) "bar"

Dans cet exemple, nous avons tout d’abord inséré deux éléments dans une liste (lpush) avant de les faire afficher. La commande lrange permet d’indiquer quelle plage (ici 0 à 10) doit être restituée. Il est possible d’utiliser des chiffres négatifs. Avec linsert, nous avons ensuite inséré une autre valeur avant une valeur existante (after serait également possible ici) ce qui a modifié la numérotation. La commande lrem peut supprimer de la liste des entrées avec une valeur spécifique.

Sets

Pour les sets, Redis dispose d’autres commandes fournissant des résultats similaires :

127.0.0.1:6397> sadd myset "foo"
(integer) 1
127.0.0.1:6397> sadd myset "bar"
(integer) 1
127.0.0.1:6397> smembers myset
1) "bar"
2) "foo"
127.0.0.1:6397> sismember myset "bar"
(integer) 1
127.0.0.1:6397> srem myset "bar"
(integer) 1
127.0.0.1:6397> smembers myset
1) "foo"

sadd permet d’autre part de reprendre plusieurs éléments simultanément dans le set, s’ils sont insérés les uns après les autres dans une commande. Pour afficher le set, il suffit d’utiliser la commande smembers et le nom du set désiré. À l’aide de la commande sismember, vous pouvez également rechercher une entrée précise. De façon analogue à la liste, il est possible de supprimer des entrées individuelles avec srem.

Toutefois, Redis offre également aux utilisateurs la possibilité d’utiliser des sets dans un format trié.

127.0.0.1:6397> zadd mysortedset 1 "foo"
(integer) 1
127.0.0.1:6397> zadd mysortedset 2 "bar"
(integer) 1
127.0.0.1:6397> zadd mysortedset 2 "foobar"
(integer) 1
127.0.0.1:6397> zrange mysortedset 0 10
1) "foo"
2) "bar"
3) "foobar"

Pour ajouter des éléments dans cette variante, on utilise la commande zadd et un score. Alors que les valeurs ne peuvent pas être répétées, le score permet d’indiquer plusieurs fois le même chiffre. Il ne s’agit donc pas d’une numérotation directe à l’intérieur d’un set, mais d’une pondération. Toutes les entrées avec le score 2 viennent après les éléments avec le score 1. zrange permet d’afficher toutes les entrées ou uniquement les entrées sélectionnées.

Hash

Le type de données hash constitue un cas particulier. De façon similaire aux sets et aux listes, il s’agit d’éléments individuels pouvant comporter plusieurs valeurs. Cependant, il existe également une clé pour chaque valeur créant ainsi des paires clé-valeur.

127.0.0.1:6397> hset user1 name "bob" email "bob@example.com" password "rK87_x"
OK
127.0.0.1:6397> hget user1 name
1) "bob"
127.0.0.1:6397> hgetall user1
1) "name"
2) "bob"
3) "email"
4) "bob@example.com"
5) "password"
6) "rK87_x"
127.0.0.1:6397> hvals user1
1) "bob"
2) "bob@example.com"
3) "rK87_x"
127.0.0.1:6397> hkeys user1
1) "name"
2) "email"
3) "password"
> hdel user1 password
(integer) 1
127.0.0.1:6397> hgetall user1
1) "name"
2) "bob"
3) "email"
4) "bob@example.com"
127.0.0.1:6397> del user1
(integer) 1
127.0.0.1:6397> hgetall user1
(empty list or set)

Dans cet exemple, hset nous a permis de créer un hash portant le nom user1. Le hash dispose de trois champs. La commande hget permet de consulter individuellement la valeur de chaque champ. hgetall peut être utilisée pour tous les afficher. hvals (affiche toutes les valeurs enregistrées dans le hash) et hkeys (affiche toutes les clés enregistrées dans le hash) offrent d’autres possibilités de consultation. hdel permet de supprimer des champs individuels et del de supprimer le hash complet comme d’habitude.

Note

La commande flushall permet de supprimer toutes les entrées de la base de données.

Étape 4 : autres options

Naturellement, Redis ne permet pas seulement de créer des entrées dans une base de données. Il est également possible d’accorder certaines propriétés aux données. L’augmentation ou la diminution incrémentielle peuvent par exemple s’avérer très utiles.

127.0.0.1:6397> set foo 1
OK
127.0.0.1:6397> get foo
"1"
127.0.0.1:6397> incr foo
(integer) 2
127.0.0.1:6397> incr foo
(integer) 3
127.0.0.1:6397> get foo
"3"
127.0.0.1:6397> decr foo
(integer) 2
127.0.0.1:6397> get foo
"2"

Ces fonctions permettent donc d’augmenter ou de diminuer les valeurs d’une unité. Il peut toutefois arriver que l’on souhaite définir des valeurs disponibles dans la base de données seulement pendant un intervalle de temps précis. La fonction expire est utilisée dans ce cadre.

127.0.0.1:6397> set foo "bar"
OK
127.0.0.1:6397> expire foo 100
(integer) 1
127.0.0.1:6397> ttl foo
(integer) 50
127.0.0.1:6397> ttl foo
(integer) -50
127.0.0.1:6397> get foo
(nil)

La commande expire exige un intervalle de temps en secondes. Dans cet exemple, nous avons donc défini la durée de l’entrée sur 100 secondes. Une fois la moitié de ce temps écoulé, nous avons demandé le « time to live », c’est-à-dire le temps restant, à l’aide de la commande ttl. Si l’on attend encore, le TTL passe en négatif. À ce moment, l’entrée n’existe plus.

La commande setex permet d’associer directement une entrée dans la base de données à un TTL lors de la création.

127.0.0.1:6397> setex foo 100 "bar"
OK

Lors de la toute première création d’une entrée, il est possible de l’étendre. La commande append ajoute une autre valeur à la valeur renseignée.

127.0.0.1:6397> set foo "Hello"
OK
127.0.0.1:6397> append foo " World"
(integer) 11
127.0.0.1:6397> get foo
"Hello World"
127.0.0.1:6397> set bar 5
OK
127.0.0.1:6397> append bar 10
(integer) 3
127.0.0.1:6397> get bar
"510"

Comme on peut le voir, lorsque l’on consulte les valeurs correspondantes : les nouveaux composants sont simplement annexés à la valeur existante. Si l’entrée n’existe pas encore, append fonctionne exactement comme set.

D’autre part, la commande rename permet de renommer des entrées.

127.0.0.1:6397> set foo 100
OK
127.0.0.1:6397> rename foo bar
OK
127.0.0.1:6397> get foo
(nil)
127.0.0.1:6397> get bar
"100"
Conseil

Il existe de nombreuses autres commandes permettant de travailler correctement avec Redis. Vous trouverez la description de toutes les commandes disponibles dans la documentation officielle.


Attendez ! Nous avons quelque chose pour vous !
Votre messagerie professionnelle

Créez une adresse personnalisée
Affichez votre sérieux sur Internet
Nom de domaine inclus
À partir d' 1 € TTC/mois
Conseiller personnel inclus !