Ce guide détaillé vous accompagnera à travers les étapes d'installation de Redis sur différents systèmes d'exploitation et vous montrera comment interagir avec Redis via Python.

1. Installation de Redis sur Windows

Pour les utilisateurs de Windows, une version adaptée de Redis est disponible, généralement maintenue par la communauté ou des initiatives comme celles de Microsoft Open Technologies (bien que moins activement mise à jour que la version officielle Linux). Voici comment procéder pour une installation courante :

Téléchargement

1. Rendez-vous sur le dépôt GitHub qui propose des builds Windows de Redis. Une source fréquente est le projet MSOpenTech/redis sur GitHub (recherchez la section "Releases").
2. Sur la page des versions, identifiez la version qui vous convient (par exemple, la 3.2.100 si vous souhaitez une version stable plus ancienne, ou explorez des forks plus récents).
3. Dans la section "Assets" de la version choisie, téléchargez le package d'installation au format .msi. Ce format simplifie l'installation sur Windows.

Procédure d'Installation

1. Exécutez le fichier .msi téléchargé en double-cliquant dessus.
2. Suivez les invites de l'assistant d'installation :
   • Acceptez les termes du contrat de licence.
   • À l'étape de configuration, cochez l'option pour ajouter Redis au chemin d'accès système (variables d'environnement) afin de pouvoir l'exécuter depuis n'importe quel répertoire. Vous pouvez également modifier le répertoire d'installation par défaut si nécessaire.
   • Configurez le port de service Redis. Le port standard est 6379. Il est conseillé de cocher l'option pour ajouter une exception de pare-feu Windows, garantissant ainsi que Redis est accessible.
   • Définissez la taille maximale de la mémoire pour Redis. Pour une utilisation de développement ou d'apprentissage, la valeur par défaut (souvent 100 Mo) est généralement suffisante.
3. Cliquez sur "Install" pour lancer l'installation.
4. Une fois l'installation terminée, vérifiez que le service Redis est en cours d'exécution. Ouvrez le Gestionnaire des tâches (Ctrl + Shift + Esc), allez à l'onglet "Services", puis cliquez sur "Ouvrir les services". Recherchez un service nommé "Redis" et assurez-vous qu'il est "En cours d'exécution". Si ce n'est pas le cas, démarrez-le manuellement.

Validation de l'Installation

Pour confirmer que Redis est opérationnel, ouvrez une invite de commande (CMD) et exécutez :

redis-cli

Si la ligne de commande affiche 127.0.0.1:6379>, le client Redis est connecté. Vous pouvez alors effectuer un test simple :

127.0.0.1:6379> SET cle_test "ValeurStockee"
OK
127.0.0.1:6379> GET cle_test
"ValeurStockee"

Si vous obtenez "ValeurStockee", votre installation Redis sur Windows est fonctionnelle.

2. Installation de Redis sur Linux

L'installation de Redis à partir des sources est la méthode privilégiée sur les systèmes Linux, offrant un contrôle maximal sur la version et la configuration.

Compilation depuis les sources

# Téléchargement de l'archive source (remplacez par la version stable la plus récente si souhaité)
wget https://download.redis.io/releases/redis-6.2.6.tar.gz

# Extraction de l'archive
tar -xzf redis-6.2.6.tar.gz

# Accès au répertoire des sources
cd redis-6.2.6

# Compilation de Redis
make

Démarrage du Serveur Redis

Après la compilation, vous pouvez lancer le serveur Redis. Pour le faire fonctionner en arrière-plan, utilisez l'option --daemonize yes :

./src/redis-server --daemonize yes

Pour un démarrage simple en mode foreground (pour les tests) :

./src/redis-server

Utilisation du Client CLI

Pour interagir avec l'instance Redis en cours d'exécution, utilisez le client en ligne de commande :

./src/redis-cli
127.0.0.1:6379> SET produit:id:101 "Smartphone XYZ"
OK
127.0.0.1:6379> GET produit:id:101
"Smartphone XYZ"

3. Opérations Redis avec Python (Bibliothèque redis-py)

La bibliothèque redis-py est l'outil standard pour interagir avec Redis depuis des applications Python. Elle propose deux classes principales : Redis et StrictRedis. StrictRedis implémente les commandes Redis de manière fidèle à la syntaxe officielle, tandis que Redis est une sous-classe de StrictRedis qui offre une compatibilité ascendante avec d'anciennes conventions de la bibliothèque.

Installation du Module redis-py

Installez la bibliothèque via pip :

pip install redis

Connexion Simple à Redis

Voici un exemple de connexion directe et d'exécution de commandes de base :

import redis

# Établir une connexion à l'instance Redis locale par défaut
client_redis = redis.Redis(host='localhost', port=6379, db=0)

# Définir une paire clé-valeur
client_redis.set('nom_utilisateur_1', 'Alice Dupont')

# Récupérer la valeur associée à la clé
valeur_recuperee = client_redis.get('nom_utilisateur_1')

# Les valeurs sont retournées en bytes, il faut les décoder en string
print(f"Nom d'utilisateur récupéré : {valeur_recuperee.decode('utf-8')}")

# Exemples supplémentaires
client_redis.hset('profil:alice', mapping={'email': 'alice@example.com', 'age': 30})
profil_alice = client_redis.hgetall('profil:alice')
print("Profil d'Alice:", {k.decode('utf-8'): v.decode('utf-8') for k, v in profil_alice.items()})

Gestion des Connexions avec un Pool de Connexions

Pour optimiser la gestion des ressources et éviter les frais de création/fermeture de connexions à chaque requête, redis-py utilise des pools de connexions. Chaque instance Redis maintient son propre pool par défaut. Cependant, il est souvent préférable de créer un pool de connexions unique et de le partager entre plusieurs clients Redis. Cela est particulièrement pertinent dans un contexte d'application web où de nombreuses requêtes peuvent être effectuées.

Pour garantir qu'un seul pool de connexions est utilisé à travers votre application, vous pouvez implémenter un motif de conception "Singleton".

Exemple de Pool de Connexions Singleton

Créez un module qui expose un singleton pour votre pool de connexions Redis :

# Fichier : utilitaires_redis.py
import redis

class GestionnairePoolRedis:
    _instance = None
    _pool = None

    def __new__(cls, host='localhost', port=6379, db=0, max_conn=50):
        if cls._instance is None:
            cls._instance = super(GestionnairePoolRedis, cls).__new__(cls)
            # Initialisation du pool lors de la première instanciation
            cls._pool = redis.ConnectionPool(
                host=host,
                port=port,
                db=db,
                max_connections=max_conn,
                decode_responses=True # Décode automatiquement les réponses en UTF-8
            )
        return cls._instance

    def get_client(self):
        """Retourne un client Redis configuré pour utiliser le pool."""
        return redis.Redis(connection_pool=self._pool)

# Exportation d'une instance singleton pour une importation facile
redis_pool_manager = GestionnairePoolRedis(host='127.0.0.1', port=6379, max_conn=75)

Utilisez ce gestionnaire dans votre application pour obtenir des clients Redis :

# Fichier : mon_application.py
from utilitaires_redis import redis_pool_manager

# Obtenir un client Redis depuis le pool géré
client_app_1 = redis_pool_manager.get_client()

# Exécuter une commande
client_app_1.set('statut_service_a', 'actif')
print(f"Statut service A : {client_app_1.get('statut_service_a')}") # Plus besoin de décoder grâce à decode_responses=True

# Obtenir un autre client (qui utilisera le même pool sous-jacent)
client_app_2 = redis_pool_manager.get_client()
client_app_2.incr('compteur_evenements') # Incrémente une valeur numérique
print(f"Compteur événements : {client_app_2.get('compteur_evenements')}")

Cette approche garantit une utilisation efficace des ressources de connexion Redis, essentielle pour les applications à fort trafic.