Redis : guide pratique

## Redis : guide pratique

## Pourquoi Redis : guide pratique ?
- Contexte réel : pourquoi un dev a besoin de ca au quotidien
Redis est une base de données en mémoire clé-valeur qui offre des performances exceptionnelles, ce qui la rend idéale pour les applications nécessitant des centaines ou même des milliers d'opérations par seconde. Elle est souvent utilisée comme un cache pour améliorer les temps de réponse et comme une base de données en mémoire pour stocker des données temporaires.

- Un cas d'utilisation concret en 2-3 phrases
Un exemple concret serait la mise en cache d'articles dans un blog, où Redis pourrait être utilisé pour stocker les articles populaires en mémoire pour les rendre accessibles instantanément. Ailleurs, il peut servir à stocker des sessions utilisateur, ce qui permet de récupérer rapidement les informations nécessaires sans avoir à les récupérer de la base de données principale.

## Prerequis
- Liste à puces des connaissances nécessaires
  - Comprendre le concept de base-clé-valeur
  - Connaître les bases de l'interaction avec Redis en ligne de commande
  - Avoir une connaissance de base de Python (pour la mise en pratique)
- Outils à installer (versions)
  - Python 3.x
  - pip (Python package installer)

## Concepts fondamentaux

### 1. Installation et connexion à Redis
Pour commencer, nous devons installer Redis sur notre système. Sous Linux, vous pouvez utiliser les commandes suivantes :

```bash
## Installer Redis via apt
sudo apt update
sudo apt install redis-server

Après l'installation, vous pouvez vérifier que Redis est en cours d'exécution avec la commande suivante :

sudo systemctl status redis-server

Pour vous connecter à Redis en ligne de commande, utilisez la commande suivante :

redis-cli

2. Les commandes de base

Redis dispose d'une multitude de commandes pour manipuler les données stockées en mémoire. Voici quelques-unes des plus utilisées :

## SET : Ajoute une clé-valeur dans Redis
SET mykey "Hello, Redis!"

## GET : Récupère la valeur associée à une clé
GET mykey

## DEL : Supprime une clé et sa valeur
DEL mykey

3. Les structures de données avancées

Redis offre également des types de données complexes comme les listes, les ensembles, les hash et les zsets (ensembles ordonnés). Voici quelques exemples :

## LISTS : Ajoute des éléments à une liste
RPUSH mylist "element1"
RPUSH mylist "element2"

## GETALL : Récupère tous les éléments d'une liste
LRANGE mylist 0 -1

## SETS : Ajoute un élément à un ensemble
SADD myset "element1"

## SMEMBERS : Récupère tous les membres d'un ensemble
SMEMBERS myset

4. Transactions et pipelines

Les transactions en Redis vous permettent de regrouper plusieurs commandes pour les exécuter atomiquement. Les pipelines vous permettent d'envoyer plusieurs commandes à Redis en une seule requête, ce qui peut améliorer les performances.

## MULTI : Démarre une transaction
MULTI

## SET : Ajoute une clé-valeur dans la transaction
SET mykey "Transaction Value"

## EXEC : Exécute toutes les commandes de la transaction
EXEC

## Pipelining : Envoi de plusieurs commandes en une seule requête
PUSH mypipeline "command1"
PUSH mypipeline "command2"
EXEC mypipeline

Mise en pratique : projet fil rouge

1. Création du projet et installation des dépendances

mkdir redis-todo-app
cd redis-todo-app
python3 -m venv venv
source venv/bin/activate
pip install redis flask

2. Structure de base du projet

Le projet sera une application Flask simple qui utilise Redis comme backend pour stocker les tâches.

mkdir app
touch app/__init__.py app/todo.py app/templates/index.html

3. Configuration de l'application

Dans app/__init__.py :

from flask import Flask, render_template, request, redirect, url_for
import redis

app = Flask(__name__)
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

@app.route('/')
def index():
    tasks = redis_client.lrange('tasks', 0, -1)
    return render_template('index.html', tasks=tasks)

@app.route('/add', methods=['POST'])
def add_task():
    task = request.form['task']
    redis_client.rpush('tasks', task)
    return redirect(url_for('index'))

if __name__ == '__main__':
    app.run(debug=True)

4. Création de la page HTML

Dans app/templates/index.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Todo App</title>
</head>
<body>
    <h1>To Do List</h1>
    <ul>
        {% for task in tasks %}
            <li>task.decode('utf-8')</li>
        {% endfor %}
    </ul>
    <form action="/add" method="post">
        <input type="text" name="task" placeholder="Add a new task" required>
        <button type="submit">Add</button>
    </form>
</body>
</html>

5. Exécution de l'application

Pour exécuter l'application, lancez la commande suivante :

python app/__init__.py

Allez sur http://127.0.0.1:5000/ pour voir votre application en action.

Erreurs fréquentes et debugging

1. Erreur : "Connection refused"

Code incorrect :

redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

Code correct :

Assurez-vous que Redis est en cours d'exécution sur le port 6379.

2. Erreur : "Unknown command"

Code incorrect :

redis_client.mypipeline('command1', 'command2')

Code correct :

pipeline = redis_client.pipeline()
pipeline.push('command1')
pipeline.push('command2')
pipeline.execute()

3. Erreur : "No such key"

Code incorrect :

value = redis_client.get('nonexistentkey')

Code correct :

value = redis_client.get('nonexistentkey')
if value is not None:
    print(value)
else:
    print("Key does not exist")

Pour aller plus loin

1. Utilisation de Redis avec des modèles de données complexes

Redis peut être utilisé pour stocker des modèles de données complexes en utilisant des hash et des listes.

Liens :

• Redis Hash
• Redis List

2. Utilisation de Redis avec le modèle client-server

Redis est souvent utilisé comme un modèle client-server où les clients s'interfacent avec le serveur Redis pour effectuer des opérations.

Liens :

• Client-Server Model in Redis

3. Utilisation de Redis avec la réplication

La réplication permet de déployer plusieurs instances de Redis pour assurer une haute disponibilité et des performances optimales.

Liens :

• Replication in Redis

Défi pratique

Créez une application Flask qui utilise Redis pour stocker des utilisateurs avec les champs suivants :

• Nom
• Email
• Mot de passe (stocké en hachage)

Ajoutez les fonctionnalités suivantes :

1. Inscription d'un utilisateur
2. Connexion d'un utilisateur
3. Affichage des informations de l'utilisateur courant

Indice : Utilisez Redis pour stocker les utilisateurs sous forme de hash.

Ce tutoriel vous a permis de comprendre le fonctionnement de Redis et de mettre en pratique une application simple en utilisant Flask. En suivant ces étapes, vous devriez être capable de développer des applications plus complexes utilisant Redis comme backend pour stocker des données temporaires ou à cache. ```