# 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](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/quest-ce-que-redis/ "Qu’est-ce que 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](http://try.redis.io/ "Try Redis sur la page officielle de 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.

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

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

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

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

```none
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](https://www.ionos.fr/cloud/serveurs-cloud "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.

```none
127.0.0.1:6397> config get *
```

[![Image: Extrait du fichier de configuration de Redis](https://www.ionos.fr/digitalguide/fileadmin/_processed_/5/4/csm_redis-konfigurationsdatei_74a168f586.webp "Extrait du fichier de configuration de Redis")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/redis-konfigurationsdatei.png) Extrait du fichier de configuration de Redis 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.

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

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

```none
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](https://redis.io/topics/security "Redis Security") 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*.

```none
127.0.0.1:6397> save
```

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

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

```none
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 **commande *set***.

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.

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

```none
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 **commande *del***.

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

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

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

```none
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é**.

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

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

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

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

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

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

```none
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](https://redis.io/commands "Description de toutes les commandes Redis") dans la documentation officielle.


This is a markdown version of: [https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/redis-tutoriel/](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/redis-tutoriel/) for AI/LLM consumption.