Python Redis : Guide du débutant

L'utilisation de Redis avec Python est une combinaison puissante pour les ingénieurs de données qui cherchent à construire des systèmes performants, évolutifs et faciles à maintenir. Que vous souhaitiez optimiser les couches de mise en cache, gérer des flux d'événements en temps réel ou mettre en œuvre un verrouillage distribué, Redis constitue une solution flexible et efficace.

Dans ce guide, nous allons couvrir les bases de l'utilisation de Redis avec Python pour vous aider à l'intégrer de manière transparente dans vos flux de travail d'ingénierie des données.

Qu'est-ce que Python Redis ?

Redis est un magasin de structures de données en mémoire open-source qui est utilisé comme base de données, cache et courtier de messages. Il est l'acronyme de Remote Dictionary Server et a été conçu à l'origine pour être un système de stockage de valeurs clés avec des temps d'accès rapides.

Il prend en charge diverses structures de données telles que les chaînesles hachages, les listes, les ensembles et les ensembles triés avec des requêtes d'étendue. Redis offre également des fonctionnalités avancées telles que les transactions, la messagerie pub/sub, les scripts Lua, la réplication intégrée et les capacités de clustering pour une meilleure disponibilité et une meilleure évolutivité.

Cas d'utilisation courants de Redis

Les cas d'utilisation potentiels de Redis sont vastes et variés.

Parmi les cas d'utilisation les plus courants en matière d'ingénierie des données, on peut citer 

• Mise en cache : Accélérez les requêtes dans les bases de données et les réponses aux API.
• Files d'attente de messages : Alimentez les architectures événementielles et les pipelines de traitement des tâches.
• Analyse en temps réel: Traitez et analysez les données en continu avec une latence minimale.
• Classements : Classez et récupérez efficacement les entités les mieux notées.
• Stockage de la session : Maintenez une gestion rapide et évolutive de l'état des sessions.
• Gestion des files d'attente : Assurer une planification et une exécution efficaces des tâches.
• Indexation géospatiale : Stocker et interroger des données géolocalisées.

Redis est également couramment utilisé en combinaison avec d'autres technologies telles que les serveurs web (par exemple NGINX), les bases de données (par exemple MySQL) et les systèmes de messagerie (par exemple Kafka) afin d'optimiser les performances et l'évolutivité.

Pourquoi utiliser Redis avec Python ?

Python est un langage dominant dans l'ingénierie des données en raison de sa flexibilité, de son écosystème étendu et de sa facilité d'intégration avec les technologies big data. 

Sa combinaison avec Redis peut apporter de nombreux avantages à vos applications :

• Performance rapide: Comme Redis stocke les données en mémoire, il peut offrir des temps d'accès beaucoup plus rapides que les bases de données traditionnelles. bases de données traditionnelles qui stockent les données sur disque. Il est donc idéal pour les cas d'utilisation nécessitant des performances élevées, tels que la mise en cache et les applications en temps réel.
• Évolutivité: Redis a été conçu dans un souci d'évolutivité, ce qui permet de traiter facilement de grandes quantités de données sans compromettre les performances.
• Facilité d'utilisation: La syntaxe simple de Python et son riche écosystème de bibliothèques permettent de travailler facilement avec Redis. La bibliothèque client officielle Redis-py fournit également une interface conviviale pour interagir avec Redis depuis votre code Python.

Qu'est-ce que Redis-py ?

Redis-py est la bibliothèque officielle du client Redis pour Python. Il fournit une interface conviviale pour communiquer avec Redis depuis votre code Python.

Voici quelques-unes de ses principales caractéristiques :

• Prise en charge de tous les types de données Redis
• Prise en charge des pipelines et des transactions pour des opérations efficaces et atomiques
• Prise en charge de la messagerie Pub/sub
• Codage/décodage automatique des données vers/depuis des octets, des chaînes de caractères et d'autres types Python.
• Support du mode cluster pour travailler avec les clusters Redis

Configuration de Redis pour le développement Python

Voyons comment nous pouvons configurer Redis pour nous-mêmes en utilisant Python.

Il y a trois façons principales de faire fonctionner Redis :

1. Docker (Recommandé pour les ingénieurs de données)
2. Sous-système Windows pour Linux (WSL)
3. Constructions par des tiers (par exemple, Memurai, tporadowski/redis)

Méthode A : Utiliser Docker

Tout d'abord, lorsque vous utilisez Docker, vous devez avoir installé Docker desktop sur votre machine. Vous pouvez le télécharger à partir du site site web DockerHub.

Une fois Docker installé, ouvrez votre invite de commande et saisissez la commande suivante.

docker pull redis

Ensuite, nous allons démarrer un nouveau conteneur.

docker run --name my-redis -p 6379:6379 -d redis

docker pull redis télécharge la dernière image officielle de Redis. docker run --name my-redis -p 6379:6379 -d redis démarre un nouveau conteneur nommé my-redis. Le paramètre -p 6379:6379 fait correspondre le port 6379 de votre machine locale au port 6379 du conteneur, de sorte que vous pouvez vous connecter à Redis à l'adresse localhost:6379. L'option -d permet d'exécuter le conteneur en arrière-plan (mode détaché).

Pour vérifier, exécutez :

docker exec -it my-redis redis-cli ping

Il devrait répondre par PONG.

Méthode B : Utilisation du sous-système Windows pour Linux (WSL)

Pour les machines Windows, une autre méthode possible consiste à utiliser le sous-système Windows pour l'installation. L'installation se fera sous Linux.

wsl --install

Cette commande installe et configure la distribution Ubuntu par défaut dans WSL. Redémarrez si nécessaire.

Ensuite, ouvrez votre terminal Ubuntu (à partir du Microsoft Store ou en tapant wsl dans PowerShell) et exécutez :

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

Ensuite, démarrez votre serveur Redis.

sudo service redis-server start

Effectuons un test pour voir si le serveur est opérationnel.

redis-cli ping

Voici une description détaillée des commandes que nous avons utilisées ci-dessus :

• sudo apt-get update récupère les dernières définitions de paquets.
• sudo apt-get install redis-server installe Redis dans l'environnement Ubuntu.
• sudo service redis-server start démarre immédiatement le service Redis.
• redis-cli ping teste la connectivité avec le serveur Redis local et renvoie PONG en cas de succès.

Méthode C : Constructions de tiers

• Memurai : Memurai.com
• tporadowski/redis : Publications sur GitHub

Ces solutions fournissent des binaires natifs pour Windows. Après le téléchargement et l'installation ou la décompression, exécutez :

redis-server.exe

Une fois lancé, redis-server.exe devrait afficher des journaux indiquant qu'il écoute sur 127.0.0.1:6379.

Vous pouvez confirmer en utilisant le CLI inclus (s'il est fourni) :

redis-cli.exe ping

Vous devez vous attendre à un résultat PONG en cas de succès.

Installation de la bibliothèque redis-py

Ensuite, vous devrez installer la bibliothèque redis-py pour pouvoir accéder à la base de données à l'aide de Python. Avant d'installer la bibliothèque, assurez-vous que Python et Redis sont installés séparément.

pip install redis

Cette commande télécharge et installe la bibliothèque client Python Redis (redis-py) depuis PyPI. Si vous utilisez un environnement virtuel, assurez-vous de l'activer avant d'exécuter cette commande.

Vérifier en utilisant :

python -c "import redis; print(redis.__version__)"

Un numéro de version doit être imprimé (par exemple, 5.2.1).

Mise en place d'un serveur Redis

Si vous avez suivi l'une des méthodes ci-dessus (Docker, WSL, ou une construction tierce), vous devriez maintenant avoir un serveur Redis fonctionnant sur localhost:6379. C'est suffisant pour le développement local sous Windows.

Travailler avec les structures de données Redis

Vous trouverez ci-dessous des exemples Python démontrant comment se connecter à différents types de données Redis et les manipuler. Chaque bloc de code comprend des commentaires explicatifs détaillant le fonctionnement des méthodes ou des commandes.

Chaînes de caractères dans Redis

import redis

# Instantiate a Redis client, connecting to localhost on port 6379
r = redis.Redis(
    host='localhost',
    port=6379,
    db=0  # The default Redis database index
)

# 1. SET command: store a string under 'mykey'
r.set("mykey", "hello from Windows")

# 2. GET command: retrieve the value stored at 'mykey'
value = r.get("mykey")
print(value)   # Output is b'hello from Windows', since redis-py returns bytes.

# 3. Convert bytes to string
print(value.decode())  # prints "hello from Windows"

# 4. DEL command: remove 'mykey' from Redis
r.delete("mykey")

Nous créons un objet Redis qui se connecte au serveur Redis local.

• r.set("mykey", "hello from Windows") stocke la chaîne "hello from Windows" sous la clé "mykey".
• r.get("mykey") récupère la valeur stockée dans mykey. Redis renvoie des octets, nous les décodons donc pour obtenir une sortie lisible par l'homme.
• r.delete("mykey") supprime complètement la clé mykey.

Exemple : Stockage et récupération des sessions d'utilisateurs

Voici un exemple de code de gestion de session utilisateur :

import uuid

def store_user_session(user_id):
    """
    Generates a unique session token (UUID) for a user and stores it in Redis.
    The session is stored under the key pattern: user:{user_id}:session
    """
    session_key = f"user:{user_id}:session"
    token = str(uuid.uuid4())   # Generate a random UUID as a session token
    r.set(session_key, token)   # Store token in Redis
    return token

def get_user_session(user_id):
    """
    Retrieves the stored session token for the given user_id.
    Returns None if the session does not exist or is expired.
    """
    session_key = f"user:{user_id}:session"
    token = r.get(session_key)
    return token.decode('utf-8') if token else None

def delete_user_session(user_id):
    """
    Deletes the session entry from Redis for the specified user_id.
    """
    session_key = f"user:{user_id}:session"
    r.delete(session_key)

# Usage demonstration
session_token = store_user_session(1001)
print(f"Stored session token: {session_token}")

retrieved_token = get_user_session(1001)
print(f"Retrieved session token: {retrieved_token}")

delete_user_session(1001)
print(f"Session after delete: {get_user_session(1001)}")  # Should be None or empty

store_user_session(user_id): Crée un identifiant unique au niveau mondial via uuid.uuid4() et le stocke sous une clé spécifique à l'utilisateur. get_user_session(user_id): Lit le jeton de session. Si None, la session est manquante ou a expiré. delete_user_session(user_id): Supprime la clé de session de Redis, ce qui a pour effet de déconnecter l'utilisateur.

Listes dans Redis

Les listes Redis sont des séquences ordonnées de chaînes de caractères. Ils permettent des opérations aux deux extrémités, ce qui les rend pratiques pour les files d'attente, les piles ou les journaux.

# LPUSH: Push an element to the head (left) of the list
r.lpush("task_queue", "task1")

# RPUSH: Push an element to the tail (right) of the list
r.rpush("task_queue", "task2")
r.rpush("task_queue", "task3")

# LPOP: Pop (remove and return) the element at the head
task = r.lpop("task_queue")
print(task)  # b'task1'

# Optional: RPOP removes and returns the element at the tail
task = r.rpop("task_queue")
print(task)  # b'task3'

lpush("task_queue", "task1") ajoute "task1" à la partie gauche d'une liste appelée "task_queue". rpush("task_queue", "task2") et rpush("task_queue", "task3") ajoutent des tâches à la partie droite. lpop("task_queue") and rpop("task_queue") retire et renvoie des éléments des extrémités respectives de la liste.

Exemple : Implémentation d'une file d'attente simple soutenue par Redis

def enqueue_task(queue_name, task):
    """
    Appends a task to the end (right) of the Redis list named queue_name.
    """
    r.rpush(queue_name, task)

def dequeue_task(queue_name):
    """
    Removes a task from the front (left) of the Redis list named queue_name.
    Returns the task as a string, or None if the queue is empty.
    """
    task = r.lpop(queue_name)
    return task.decode('utf-8') if task else None

# Example usage:
enqueue_task("my_queue", "send_email")
enqueue_task("my_queue", "generate_report")

while True:
    task = dequeue_task("my_queue")
    if not task:
        print("No more tasks in queue.")
        break
    print(f"Processing task: {task}")

enqueue_task ajoute toujours de nouvelles tâches à la fin de la liste, ce qui simule une file d'attente FIFO traditionnelle. dequeue_task supprime les tâches du début de la liste. Si la liste est vide, il renvoie None.

La boucle while traite les tâches jusqu'à ce que la file d'attente soit vide, puis s'arrête.

Hachures dans Redis

Les hachages sont similaires aux dictionnaires Python, mais ils sont stockés dans Redis. Elles sont idéales pour regrouper des champs apparentés (par exemple, les coordonnées d'un utilisateur).

# HSET: Store 'name' and 'email' fields for a user hash key
r.hset("user:1001", "name", "Alice")
r.hset("user:1001", "email", "alice@example.com")

# HGET: Retrieve a single field from the hash
email = r.hget("user:1001", "email")
print(email.decode('utf-8'))  # alice@example.com

# HDEL: Remove a field from the hash
r.hdel("user:1001", "email")

hset("user:1001", "name", "Alice") définit le champ "name" à la valeur "Alice" dans le hachage à la clé "user:1001". hget("user:1001", "email") récupère le champ "email". hdel("user:1001", "email") supprime le champ "email" de ce hachage.

Exemple : Stockage et accès à des profils d'utilisateurs structurés

def create_user_profile(user_id, name, email):
    """
    Creates a user profile in Redis under the key 'user:{user_id}'.
    'name' and 'email' are stored as separate fields in the hash.
    """
    user_key = f"user:{user_id}"
    r.hset(user_key, mapping={"name": name, "email": email})

def get_user_profile(user_id):
    """
    Retrieves and returns all fields in the user profile hash
    as a Python dictionary. Keys and values are decoded from bytes.
    """
    user_key = f"user:{user_id}"
    profile_data = r.hgetall(user_key)
    return {k.decode('utf-8'): v.decode('utf-8') for k, v in profile_data.items()}

def delete_user_profile(user_id):
    """
    Deletes the entire user profile key from Redis.
    """
    user_key = f"user:{user_id}"
    r.delete(user_key)

# Usage demonstration
create_user_profile(1002, "Bob", "bob@example.com")
print(get_user_profile(1002))  # e.g. {'name': 'Bob', 'email': 'bob@example.com'}
delete_user_profile(1002)

Nous stockons le nom et l'adresse électronique d'un utilisateur dans une clé de hachage. mapping={"name": name, "email": email} utilise la capacité de redis-pyà définir plusieurs champs à la fois. r.hgetall(user_key) récupère tous les champs et toutes les valeurs, sous la forme d'un dictionnaire d'octets bruts que nous décodons en chaînes de caractères. delete_user_profile supprime la clé de hachage dans son intégralité.

Ensembles et ensembles triés

Les données dans Redis peuvent être gérées à l'aide d'ensembles ou d'ensembles triés. 

Les ensembles sont des collections de valeurs uniques, tandis que les ensembles triés sont des collections de paires clé-valeur avec un score associé à chaque valeur. Ces structures de données permettent de stocker et d'extraire des données de manière efficace, ce qui les rend utiles pour les applications nécessitant des recherches rapides.

Jeux

Un ensemble dans Redis est similaire à un ensemble mathématique - il contient une collection d'éléments uniques, et aucun élément dupliqué n'est autorisé. Les ensembles peuvent être utilisés pour modéliser les relations entre différentes entités, telles que les utilisateurs qui ont aimé un message sur les médias sociaux.

Voici une démonstration d'ensembles :

# SADD: Add multiple members to a set
r.sadd("tags:python", "redis", "windows", "backend")

# SMEMBERS: Retrieve all unique members in the set
tags = r.smembers("tags:python")
print(tags)  # {b'redis', b'windows', b'backend'}

Les ensembles Redis garantissent l'unicité des membres. Toute tentative d'ajout d'un membre en double n'aura aucun effet.

Le résultat de smembers est un ensemble d'octets Python.

Ensembles triés

Les ensembles triés dans Redis sont similaires aux ensembles normaux, mais chaque membre a également un score correspondant. Cela permet d'effectuer des opérations de tri et de classement efficaces sur l'ensemble.

Les ensembles triés sont souvent utilisés pour les tableaux de classement, où le score représente le rang ou les points d'un joueur.

Voici une démonstration d'ensembles triés :

# ZADD: Add members with scores
r.zadd("leaderboard", {"player1": 10, "player2": 20})

# ZRANGE: Retrieve members in ascending order of score
leaders = r.zrange("leaderboard", 0, -1, withscores=True)
print(leaders)  # [(b'player1', 10.0), (b'player2', 20.0)]

Les ensembles triés stockent les membres dans un ordre spécifique déterminé par leurs scores numériques. zrange("leaderboard", 0, -1, withscores=True) renvoie tous les membres du rang 0 à la fin, y compris leurs scores.

Exemple : Gestion des tags ou des classements

L'utilisation d'ensembles triés peut s'avérer utile pour gérer les étiquettes ou créer des classements. 

def add_tag(post_id, tag):
    """
    Adds a 'tag' to the set of tags belonging to a specific post.
    Each post has its own set under 'post:{post_id}:tags'.
    """
    r.sadd(f"post:{post_id}:tags", tag)

def get_tags(post_id):
    """
    Retrieves all tags for a specific post, decoding the bytes into strings.
    """
    raw_tags = r.smembers(f"post:{post_id}:tags")
    return {tag.decode('utf-8') for tag in raw_tags}

def update_leaderboard(player, score):
    """
    Updates or inserts a player's score in the 'game:leaderboard' sorted set.
    A higher score indicates a better position if sorting descending.
    """
    r.zadd("game:leaderboard", {player: score})

def get_leaderboard():
    """
    Returns an ascending list of (player, score) tuples from the leaderboard.
    To invert the sorting (highest first), you'd use ZREVRANGE.
    """
    entries = r.zrange("game:leaderboard", 0, -1, withscores=True)
    return [(player.decode('utf-8'), score) for player, score in entries]

# Usage demonstration
add_tag(123, "python")
add_tag(123, "redis")
print(get_tags(123))

update_leaderboard("Alice", 300)
update_leaderboard("Bob", 450)
print(get_leaderboard())

add_tag et get_tags présentent un système de balisage un à plusieurs, en stockant les balises dans un ensemble. update_leaderboard et get_leaderboard montrent comment vous pourriez mettre en place un tableau de classement pour un jeu.

Fonctionnalités de Redis dans les applications Python

Redis dispose de plusieurs fonctionnalités qui en font un choix populaire pour le stockage de données dans les applications Python : la mise en file d'attente, le verrouillage et la mise en cache. 

Voici leurs implémentations en Python ci-dessous :

Redis comme une file d'attente (avec blocage)

Explorons l'utilisation de Redis en tant que file d'attente avec blocage en utilisant BLPOP.

BLPOP est une opération bloquante qui attend qu'un élément soit disponible dans une liste.

def blocking_consumer(queue_name):
    """
    Continuously listens to the specified queue (Redis list) using BLPOP,
    which blocks until new items are pushed. Once an item arrives,
    it is removed from the queue and processed.
    """
    print(f"Waiting on queue: {queue_name}")
    while True:
        result = r.blpop(queue_name)
        if result:
            list_name, task_bytes = result
            task = task_bytes.decode('utf-8')
            print(f"Received task: {task}")
        else:
            print("Queue is empty or an error occurred.")
            break

def enqueue_task(queue_name, task):
    """
    Pushes a task to the end of a Redis list (queue).
    """
    r.rpush(queue_name, task)

# Example usage:
enqueue_task("blocking_queue", "task_block_1")
enqueue_task("blocking_queue", "task_block_2")

# In a real application, the consumer might run in a separate thread or process
blocking_consumer("blocking_queue")

blocking_consumer utilise blpop dans une boucle. Si la liste est vide, blpop attendra qu'un autre élément soit poussé.

Dès qu'un article est reçu, il est retiré de la liste et imprimé.

Cette approche est idéale pour les modèles producteur-consommateur dans lesquels les travailleurs exécutent les tâches au fur et à mesure qu'elles se présentent.

Implémentation de verrous dans Redis

Les verrous distribués empêchent plusieurs clients ou processus de modifier simultanément la même ressource. Redis peut aider à éviter les conditions de course dans un environnement distribué.

import time
from redis.exceptions import LockError

def process_critical_section():
    """
    Acquires a lock named 'resource_lock' with a timeout of 10 seconds.
    The lock automatically expires after 10 seconds to prevent deadlocks.
    """
    lock = r.lock("resource_lock", timeout=10)
    try:
        # Attempt to acquire the lock, wait for up to 5 seconds if another process holds it
        acquired = lock.acquire(blocking=True, blocking_timeout=5)
        if acquired:
            print("Lock acquired; performing critical operation...")
            time.sleep(3)  # Simulate some operation
        else:
            print("Failed to acquire lock within 5 seconds.")
    except LockError:
        print("A LockError occurred, possibly releasing already released lock.")
    finally:
        # Always release the lock in a finally block to ensure cleanup
        lock.release()
        print("Lock released.")

# Usage demonstration
process_critical_section()

Nous créons un verrou avec timeout=10, ce qui signifie que si le verrou n'est pas libéré manuellement, Redis l'enlèvera automatiquement dans 10 secondes pour éviter un blocage indéfini (deadlock). lock.acquire(blocking=True, blocking_timeout=5) tente d'acquérir le verrou pendant 5 secondes avant d'abandonner. Après avoir terminé, lock.release() libère la ressource pour d'autres processus.

Mise en cache avec Redis

La mise en cache est un scénario d'utilisation courant : il s'agit de stocker les données fréquemment consultées dans la mémoire, ce qui réduit la charge des bases de données ou des API externes.

import requests
import json

def get_user_data(user_id):
    """
    Retrieves user data from a hypothetical API endpoint.
    If the data is found in Redis (cache), use that. Otherwise, call the API,
    store the response in Redis with a 60-second expiration, and return it.
    """
    cache_key = f"user_data:{user_id}"
    cached_data = r.get(cache_key)
    if cached_data:
        print("Cache hit!")
        return json.loads(cached_data)

    print("Cache miss. Fetching from API...")
    response = requests.get(f"https://api.example.com/users/{user_id}")
    user_info = response.json()

    # Store in Redis for 60 seconds
    r.setex(cache_key, 60, json.dumps(user_info))
    return user_info

# Usage
user = get_user_data(42)  # First call => cache miss
user_again = get_user_data(42)  # Subsequent call => cache hit

Nous vérifions si user_data:{user_id} existe dans Redis. Si c'est le cas, il s'agit d'une correspondance avec le cache, et nous ignorons l'appel à l'API. Si ce n'est pas le cas, nous récupérons les données de l'API distante, puis setex (ensemble + expiration) pendant 60 secondes. Les appels ultérieurs dans ce délai récupèrent les données mises en cache, ce qui réduit le temps de latence.

Sujets avancés sur Redis

Vous pensez avoir déjà maîtrisé Redis ? Passons à des sujets plus avancés.

Utiliser Pub/Sub avec Redis

Pub/Sub (Publish/Subscribe) est un modèle de messagerie populaire pour la communication en temps réel. Les éditeurs envoient des messages à un canal, et tous les abonnés à ce canal reçoivent les messages.

import threading

def subscriber(r, channel_name):
    """
    Subscribes to the given Redis channel and listens for messages.
    When a new message is published on that channel, it is printed.
    """
    pubsub = r.pubsub()
    pubsub.subscribe(channel_name)
    print(f"Subscribed to {channel_name}")

    # pubsub.listen() yields messages from the subscribed channel(s) in real time
    for message in pubsub.listen():
        if message['type'] == 'message':
            print(f"Received message: {message['data'].decode('utf-8')}")

def publisher(r, channel_name, message):
    """
    Publishes a message to the specified Redis channel.
    All subscribers to this channel immediately receive the message.
    """
    r.publish(channel_name, message)

# Example usage
channel = "updates"

# Start subscriber in a separate thread to avoid blocking the main thread
sub_thread = threading.Thread(target=subscriber, args=(r, channel))
sub_thread.start()

# Publish messages
publisher(r, channel, "Hello from Windows!")
publisher(r, channel, "Another update!")

pubsub = r.pubsub() crée un objet PubSub. pubsub.subscribe(channel_name) demande à Redis d'envoyer des messages de ce canal à l'objet PubSub. pubsub.listen() est un itérateur infini, produisant des messages au fur et à mesure qu'ils arrivent. r.publish(channel_name, message) envoie un message à tous les abonnés de channel_name.

Expiration des clés dans Redis

Redis prend en charge le temps de vie (TTL). Ceci est essentiel pour les données temporaires telles que les sessions ou les caches de courte durée.

# EXPIRE: Set a 30-second expiration on a key
r.set("temp_key", "some value")
r.expire("temp_key", 30)

# SETEX: Combined set + expire in one command
r.setex("temp_key2", 60, "another value")

r.expire("temp_key", 30) définit un TTL de 30 secondes. Après 30 secondes, temp_key est automatiquement supprimé. r.setex("temp_key2", 60, "another value") est un raccourci qui définit la clé et l'expiration en même temps.

Exemple : Expiration de la session

Voici un exemple de la manière dont vous pouvez utiliser les clés d'expiration pour définir l'expiration d'une session après une durée spécifiée.

def store_session_with_expiry(user_id, token, ttl=3600):
    """
    Stores a session token for a specific user with a time-to-live (TTL).
    By default, the session expires after 1 hour (3600 seconds).
    """
    session_key = f"user:{user_id}:session"
    r.setex(session_key, ttl, token)

def get_session_with_expiry(user_id):
    """
    Retrieves the session token for the user. Returns None if the key doesn't exist
    or if it has expired.
    """
    session_key = f"user:{user_id}:session"
    token = r.get(session_key)
    return token.decode('utf-8') if token else None

# Usage
store_session_with_expiry(2001, "session_token_abc", 3600)
retrieved_token = get_session_with_expiry(2001)
print(f"Retrieved token: {retrieved_token}")

store_session_with_expiry utilise setex sous le capot pour stocker user:{user_id}:session avec un TTL spécifié. Si vous n'indiquez pas de TTL, la clé peut être conservée indéfiniment.

Lorsque le TTL expire, Redis supprime automatiquement la clé, ce qui rend impossible la récupération de la session.

Meilleures pratiques pour l'utilisation de Redis avec Python

L'utilisation de Redis nécessite quelques considérations et bonnes pratiques pour garantir des performances optimales et éviter les pièges les plus courants.

Voici quelques conseils à garder à l'esprit :

• Configurez correctement les options de persistance pour assurer la sécurité des données.
• Surveillez l'utilisation de la mémoire pour éviter les erreurs de mémoire.
• Utilisez le pipelining pour des opérations par lots efficaces.
• Gardez un œil sur la latence du réseau, car elle peut avoir un impact sur les performances lorsque vous travaillez avec un serveur Redis distant.
• Sécurisez les connexions Redis à l'aide de mots de passe et de pare-feu.

Conclusion

Redis est un outil puissant et polyvalent pour la gestion des données dans les applications Python. L'utilisation de Python avec Redis peut donner lieu à de nombreuses applications et cas d'utilisation, de la mise en cache de données à la gestion de files d'attente. 

Vous souhaitez en savoir plus sur Redis ? Notre Introduction à NoSQL peut vous aider à apprendre à gérer les données clé-valeur. Vous êtes plutôt intéressé par Python ? Dans ce cas, notre Fondamentaux des données Python est peut-être le meilleur endroit pour commencer.