Utilisation des commandes Redis Scan sur Linux : Un guide complet

Redis est un magasin de structures de données en mémoire, haute performance et open-source, largement utilisé comme base de données clé-valeur, cache et courtier de messages. Parmi ses fonctionnalités les plus puissantes — mais souvent sous-utilisées — se trouvent les commandes scan, qui vous permettent d’itérer progressivement à travers de grands ensembles de données sans bloquer votre serveur ni dégrader les performances.

Si vous exécutez Redis sur un serveur basé sur Linux, maîtriser les commandes scan est essentiel pour construire des applications scalables et prêtes pour la production. Contrairement à la dangereuse commande KEYS, qui récupère toutes les clés correspondantes en une seule opération bloquante, les commandes scan retournent les données par petits lots gérables — ce qui en fait l’outil correct pour tout environnement traitant des volumes de données importants.

Dans ce guide complet, vous apprendrez exactement comment utiliser SCAN, SSCAN, HSCAN et ZSCAN dans Redis sur Linux, avec des exemples concrets, des scripts shell et les meilleures pratiques pour les déploiements en production.

Qu’est-ce que les commandes Redis Scan ?

Les commandes Redis scan fournissent un mécanisme basé sur un curseur et non bloquant pour itérer sur les clés, les ensembles, les hashes et les ensembles triés. Chaque commande retourne un petit sous-ensemble d’éléments par appel ainsi qu’une valeur de curseur, que vous utilisez pour continuer l’itération lors des appels suivants. Lorsque le curseur revient à 0, l’ensemble complet des données a été parcouru.

Cette approche est fondamentalement plus sûre et plus efficace que KEYS, qui bloque l’ensemble du serveur Redis jusqu’à ce qu’il termine le scan — un problème critique dans les environnements de production avec des millions de clés.

Les quatre commandes Scan principales

Syntaxe de base des commandes de scan

Les quatre commandes de scan partagent une structure de syntaxe cohérente :

SCAN cursor [MATCH pattern] [COUNT count]
SSCAN key cursor [MATCH pattern] [COUNT count]
HSCAN key cursor [MATCH pattern] [COUNT count]
ZSCAN key cursor [MATCH pattern] [COUNT count]

Paramètres expliqués

• cursor — Un entier représentant la position actuelle dans l’itération. Commencez toujours par 0 pour démarrer un nouveau scan. Redis retourne un nouveau curseur avec chaque réponse ; utilisez-le dans l’appel suivant pour continuer.
• MATCH pattern *(optionnel)* — Filtre les résultats en utilisant la correspondance de motifs de style glob (par exemple, user:*, *session*). Remarque : le filtrage se fait *après* la récupération, donc les correspondances de faible densité peuvent nécessiter de nombreuses itérations.
• COUNT count *(optionnel)* — Un conseil à Redis suggérant le nombre d’éléments à retourner par itération. Ce n’est pas une limite stricte ; Redis peut retourner plus ou moins. La valeur par défaut est 10.

Installation de Redis sur Linux

Avant d’utiliser les commandes scan, vous devez avoir Redis installé et en cours d’exécution sur votre serveur Linux. Que vous soyez dans un environnement de production à fort trafic ou sur une machine de développement, le processus d’installation est simple.

> Conseil : Pour les charges de travail de production nécessitant Redis à grande échelle, envisagez de déployer sur un plan VPS Hosting ou un Serveur Dédié pour vous assurer que vous disposez de la mémoire, du CPU et des ressources I/O que Redis exige.

Installation de Redis sur Debian/Ubuntu

sudo apt update
sudo apt install redis-server -y

Installation de Redis sur CentOS/RHEL

sudo yum install redis -y

Démarrage du service Redis

sudo systemctl start redis
sudo systemctl enable redis

Vérification de l’installation

sudo systemctl status redis

Vous devriez voir active (running) dans la sortie. Maintenant, connectez-vous à Redis CLI :

redis-cli

Une fois dans le CLI, testez la connexion :

127.0.0.1:6379> PING
PONG

Vous êtes prêt à commencer à utiliser les commandes scan.

Utilisation de la commande SCAN

La commande SCAN itère sur toutes les clés de l’espace de clés Redis. C’est le remplacement à usage général de la commande KEYS dans les environnements de production.

Exemple 1 : SCAN basique

Pour commencer à analyser toutes les clés de la base de données, commencez avec le curseur 0 :

SCAN 0

Exemple de sortie :

1) "14"
2) 1) "session:abc123"
   2) "user:1001"
   3) "product:55"

Le premier élément (14) est le curseur suivant. Utilisez-le dans votre prochain appel SCAN. Lorsque le curseur renvoyé est 0, l’itération complète est terminée.

Exemple 2 : Filtrage des clés avec MATCH

Pour récupérer uniquement les clés correspondant à un modèle spécifique — par exemple, toutes les clés préfixées par user: :

SCAN 0 MATCH user:*

Cela renvoie uniquement les clés dont les noms commencent par user:. Continuez à itérer jusqu’à ce que le curseur renvoie 0 pour vous assurer que vous avez analysé l’ensemble de l’espace de clés.

Exemple 3 : Contrôle de la taille du lot avec COUNT

Pour suggérer à Redis de renvoyer environ 100 clés par itération :

SCAN 0 COUNT 100

Rappelez-vous : COUNT est un *indice*, pas une garantie. Redis peut renvoyer légèrement plus ou moins de résultats selon les structures de données internes.

Exemple 4 : Itération complète de l’espace de clés avec un script shell

Dans les scénarios réels, vous devrez parcourir l’espace de clés entier par programmation. Voici un script Bash prêt pour la production qui itère sur toutes les clés correspondant à un modèle :

#!/bin/bash

cursor=0
echo "Starting full keyspace scan..."

while true; do
    # Execute SCAN and capture the result
    result=$(redis-cli SCAN $cursor MATCH user:* COUNT 100)

    # Extract the new cursor (first line of output)
    cursor=$(echo "$result" | head -n 1)

    # Extract and display the keys (remaining lines)
    keys=$(echo "$result" | tail -n +2)
    echo "Keys found:"
    echo "$keys"

    # Break the loop when cursor returns to 0
    if [[ "$cursor" == "0" ]]; then
        echo "Scan complete."
        break
    fi
done

Pour exécuter ce script :

chmod +x scan_keys.sh
./scan_keys.sh

Utilisation de la commande SSCAN

SSCAN est utilisé pour itérer progressivement à travers les membres d’un Set Redis. Il suit le même modèle basé sur le curseur que SCAN.

Étape 1 : Créer un Set et ajouter des membres

SADD myset "apple"
SADD myset "banana"
SADD myset "cherry"
SADD myset "date"
SADD myset "elderberry"
SADD myset "mango"
SADD myset "mango:tropical"
SADD myset "mango:dried"

Étape 2 : SSCAN basique

Analyser tous les éléments dans myset en commençant par le curseur 0 :

SSCAN myset 0

Étape 3 : Filtrer les éléments avec MATCH

Pour récupérer uniquement les éléments qui correspondent au motif mango:* :

SSCAN myset 0 MATCH mango:*

Étape 4 : Itérer à travers un Set avec un script Shell

#!/bin/bash

cursor=0
echo "Scanning through myset:"

while true; do
    # Scan the set
    result=$(redis-cli SSCAN myset $cursor COUNT 10)

    # Update cursor
    cursor=$(echo "$result" | head -n 1)

    # Print elements returned
    elements=$(echo "$result" | tail -n +2)
    echo "Elements: $elements"

    # Stop when cursor returns to 0
    if [[ "$cursor" == "0" ]]; then
        echo "Set scan complete."
        break
    fi
done

Enregistrer sous scan_myset.sh, le rendre exécutable et exécuter :

chmod +x scan_myset.sh
./scan_myset.sh

Utilisation de la commande HSCAN

HSCAN itère à travers les champs et valeurs d’un Hash Redis. C’est particulièrement utile quand un hash contient des centaines ou des milliers de champs et que vous devez les traiter sans charger tout en mémoire à la fois.

Étape 1 : Créer un Hash et ajouter des champs

HSET myhash name "John Doe"
HSET myhash age "30"
HSET myhash occupation "Software Developer"
HSET myhash city "San Francisco"
HSET myhash country "USA"
HSET myhash email "john@example.com"

Étape 2 : HSCAN basique

HSCAN myhash 0

Exemple de résultat :

1) "0"
2) 1) "name"
   2) "John Doe"
   3) "age"
   4) "30"
   5) "occupation"
   6) "Software Developer"
   ...

Les résultats sont retournés sous forme de paires champ-valeur alternées.

Étape 3 : Filtrer les champs du Hash avec MATCH

Pour récupérer uniquement les champs dont les noms contiennent "city" ou correspondent à un motif :

HSCAN myhash 0 MATCH *city*

Étape 4 : Itérer à travers un Hash avec un script Shell

#!/bin/bash

cursor=0
echo "Scanning hash: myhash"

while true; do
    result=$(redis-cli HSCAN myhash $cursor COUNT 10)
    cursor=$(echo "$result" | head -n 1)
    fields=$(echo "$result" | tail -n +2)

    echo "Fields and values:"
    echo "$fields"

    if [[ "$cursor" == "0" ]]; then
        echo "Hash scan complete."
        break
    fi
done

Utilisation de la commande ZSCAN

ZSCAN itère à travers les membres et scores d’un ensemble trié Redis. Les ensembles triés sont couramment utilisés pour les classements, les files d’attente prioritaires et les données de séries chronologiques — tous des scénarios où l’analyse efficace de grandes collections est critique.

Étape 1 : Créer un ensemble trié et ajouter des membres

ZADD mysortedset 1 "apple"
ZADD mysortedset 2 "banana"
ZADD mysortedset 3 "cherry"
ZADD mysortedset 4 "date"
ZADD mysortedset 5 "elderberry"

Étape 2 : ZSCAN basique

ZSCAN mysortedset 0

Exemple de sortie :

1) "0"
2) 1) "apple"
   2) "1"
   3) "banana"
   4) "2"
   5) "cherry"
   6) "3"

Les résultats sont renvoyés sous forme de paires membre-score alternées.

Étape 3 : Filtrer les membres avec MATCH

Pour trouver tous les membres dont les noms contiennent la lettre "e" :

ZSCAN mysortedset 0 MATCH *e*

Étape 4 : Script complet d’itération d’ensemble trié

#!/bin/bash

cursor=0
echo "Scanning sorted set: mysortedset"

while true; do
    result=$(redis-cli ZSCAN mysortedset $cursor COUNT 10)
    cursor=$(echo "$result" | head -n 1)
    members=$(echo "$result" | tail -n +2)

    echo "Members and scores:"
    echo "$members"

    if [[ "$cursor" == "0" ]]; then
        echo "Sorted set scan complete."
        break
    fi
done

Comparaison des commandes Scan : Référence rapide

Meilleures pratiques pour l’utilisation des commandes Redis Scan en production

1. Utilisez toujours SCAN au lieu de KEYS en production

La commande KEYS est single-threaded et bloque toutes les autres opérations Redis jusqu’à son achèvement. Sur une base de données avec des millions de clés, cela peut causer des pics de latence sévères. N’utilisez jamais KEYS en production. SCAN est l’alternative correcte et non-bloquante.

2. Ajustez COUNT en fonction de la taille de votre dataset

Pour les petits datasets (< 1 000 clés), la valeur par défaut COUNT 10 convient. Pour les grands datasets, augmentez COUNT à 100–1000 pour réduire le nombre d’allers-retours tout en gardant les réponses individuelles gérables.

3. Ne vous fiez pas à MATCH seul pour l’efficacité

Le filtre MATCH est appliqué *après* que Redis récupère les éléments en interne. Si votre motif ne correspond qu’à une petite fraction des clés, Redis scanne quand même l’ensemble du dataset en interne. Utilisez des conventions de nommage de clés (par exemple, des préfixes cohérents) pour rendre MATCH plus efficace.

4. Traitez les résultats par lots

N’accumulez jamais tous les résultats de scan en mémoire avant le traitement. À la place, traitez chaque lot immédiatement dès qu’il est retourné. C’est particulièrement important sur les serveurs à mémoire limitée.

5. Gérez l’état du curseur avec soin

Initialisez toujours le curseur à 0 et mettez-le à jour avec chaque réponse. Si votre application s’arrête brutalement pendant un scan, redémarrez à partir de 0. Les curseurs Redis ne sont pas persistants après les redémarrages du serveur.

6. Testez complètement en développement d’abord

Avant de déployer la logique basée sur scan en production, validez-la dans un environnement de staging avec un dataset représentatif. Vérifiez que votre boucle se termine correctement quand le curseur revient à 0.

7. Sécurisez votre instance Redis

Redis ne doit jamais être exposé à l’internet public sans authentification. Utilisez requirepass dans votre configuration Redis, liez-vous à localhost ou à une interface réseau privée, et utilisez des règles de pare-feu pour restreindre l’accès.

Choisir le bon environnement d’hébergement pour Redis

Les performances de Redis sont directement liées à la RAM disponible, à la vitesse du CPU et à la latence du réseau. Choisir la bonne infrastructure d’hébergement est aussi important que d’écrire des commandes Redis efficaces.

• Développement et petits projets : L’hébergement web partagé peut suffire pour une utilisation légère de Redis, bien que des instances Redis dédiées soient toujours préférées.
• Applications en croissance : Un plan VPS Hosting vous offre des ressources dédiées, un accès root et la possibilité d’ajuster la configuration de Redis (maxmemory, paramètres de persistance, etc.) selon vos besoins exacts.
• Systèmes de production à fort trafic : Les serveurs dédiés fournissent les ressources maximales en RAM et CPU que Redis peut utiliser, éliminant complètement la contention de ressources.
• Charges de travail IA et ML utilisant Redis comme magasin de vecteurs : GPU Hosting offre la puissance de calcul nécessaire pour la génération d’embeddings et la recherche de similarité aux côtés de Redis.

Pour les applications qui nécessitent également un panneau de contrôle web pour une gestion plus facile, VPS avec cPanel fournit une interface conviviale aux côtés du contrôle complet du serveur.

Dépannage des problèmes courants

SCAN retourne 0 éléments à plusieurs reprises

Cela signifie généralement que votre modèle MATCH ne correspond à aucune clé, ou que l’ensemble de données est vide. Vérifiez votre dénomination de clés avec DBSIZE pour vérifier le nombre total de clés.

127.0.0.1:6379> DBSIZE
(integer) 15420

Le curseur ne revient jamais à 0

Cela ne devrait pas se produire dans une instance Redis stable. Si c’est le cas, vérifiez la compatibilité de la version Redis (les commandes scan nécessitent Redis 2.8+) ou les interruptions de connexion qui réinitialisent votre suivi de curseur.

Le script se bloque indéfiniment

Assurez-vous que votre boucle lit correctement le curseur à partir de la première ligne de la sortie redis-cli. Une erreur d’analyse qui produit toujours un curseur non nul causera une boucle infinie.

Conclusion

Les commandes de scan Redis — SCAN, SSCAN, HSCAN et ZSCAN — sont des outils indispensables pour tout développeur ou administrateur système travaillant avec Redis à grande échelle sur Linux. Elles fournissent un mécanisme sûr, non-bloquant et basé sur un curseur pour itérer à travers de grands ensembles de données sans les risques de performance associés aux commandes comme KEYS.

En combinant les commandes de scan avec les motifs MATCH, les indices COUNT appropriés et les scripts shell bien structurés, vous pouvez construire des pipelines de traitement de données efficaces qui s’adaptent gracieusement à la taille de votre ensemble de données. En suivant les meilleures pratiques décrites dans ce guide — particulièrement autour de la sécurité en production, de la gestion de la mémoire et de la sélection de l’infrastructure — vous assurerez que vos déploiements Redis restent performants et fiables.

Pour les options de commande les plus actuelles et les détails de configuration avancée, consultez toujours la documentation officielle de Redis. Et quand vous serez prêt à déployer Redis dans un environnement Linux de qualité production, explorez l’Hébergement VPS et les Serveurs Dédiés d’AlexHost pour une infrastructure construite pour gérer des charges de travail exigeantes et gourmandes en mémoire.