Surveillance des performances Redis

Introduction

Dans ce laboratoire, vous apprendrez à surveiller et à résoudre les problèmes de performance de Redis. Le laboratoire se concentre sur l'identification et la résolution des problèmes de latence, l'analyse de l'utilisation de la mémoire et l'optimisation des performances des requêtes.

Vous utiliserez la commande LATENCY DOCTOR pour diagnostiquer la latence, MEMORY STATS pour vérifier l'utilisation de la mémoire, SLOWLOG GET pour analyser les requêtes lentes, et MEMORY PURGE pour optimiser la mémoire. En suivant le guide étape par étape, vous acquerrez une expérience pratique dans la maintenance d'un déploiement Redis réactif et efficace.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL redis(("Redis")) -.-> redis/RedisGroup(["Redis"]) redis/RedisGroup -.-> redis/access_cli("Connect Using CLI") subgraph Lab Skills redis/access_cli -.-> lab-552100{{"Surveillance des performances Redis"}} end

Surveiller la latence avec LATENCY DOCTOR

Dans cette étape, nous allons explorer comment utiliser la commande LATENCY DOCTOR dans Redis pour diagnostiquer et résoudre les problèmes de latence. Comprendre et traiter la latence est crucial pour maintenir un déploiement Redis réactif et efficace.

Qu'est-ce que la latence ?

La latence fait référence au délai entre l'envoi d'une requête à un serveur Redis et la réception d'une réponse. Une latence élevée peut avoir un impact négatif sur les performances de l'application, entraînant des temps de réponse lents et une mauvaise expérience utilisateur.

Présentation de LATENCY DOCTOR

La commande LATENCY DOCTOR est un outil puissant intégré à Redis qui aide à identifier les sources potentielles de latence. Il analyse divers aspects du fonctionnement de Redis et fournit des informations sur ce qui pourrait causer des retards.

Guide étape par étape

Se connecter à Redis :

Tout d'abord, connectez-vous à votre serveur Redis en utilisant la commande redis-cli. Ouvrez un terminal dans votre VM LabEx et exécutez ce qui suit :
```
redis-cli
```
Cela ouvrira l'interface de ligne de commande Redis.
Exécuter LATENCY DOCTOR :

Une fois connecté, exécutez simplement la commande LATENCY DOCTOR :
```
LATENCY DOCTOR
```
Redis analysera alors le système et fournira un rapport.
Interprétation de la sortie :

La sortie de LATENCY DOCTOR peut être assez verbeuse, mais elle fournit des informations précieuses. Décomposons un exemple de sortie :
```
127.0.0.1:6379> LATENCY DOCTOR
I am The Doctor, and I am here to help you with your latency problems.
Please wait...

--- SUMMARY ---

Nominal latency seems ok.

--- DETAILS ---

* Key lookup seems ok.
* Slow calls:
    - command: slowlog get 128
      occurred 1 times
      max latency: 1 milliseconds

--- ADVICE ---

Check the slowlog to understand what queries are taking the most time.
```
- SUMMARY (Résumé) : Cette section fournit un aperçu général de la situation de la latence. Dans cet exemple, il indique que la latence nominale semble correcte.
- DETAILS (Détails) : Cette section offre des informations plus spécifiques sur les zones de problèmes potentiels. Ici, il met en évidence les "Slow calls" (appels lents) et suggère de vérifier le slowlog.
- ADVICE (Conseils) : Cette section fournit des recommandations sur la façon d'enquêter plus avant et de résoudre les problèmes identifiés.
Analyse des requêtes lentes (comme suggéré par LATENCY DOCTOR) :

La sortie de LATENCY DOCTOR suggère souvent d'examiner le slowlog (journal des requêtes lentes). Le slowlog est une fonctionnalité de Redis qui enregistre les requêtes qui dépassent un temps d'exécution spécifié. Nous explorerons le slowlog plus en détail dans la prochaine étape. Pour l'instant, visualisons simplement le slowlog comme suggéré.
```
SLOWLOG GET 128
```
Cette commande récupère les 128 entrées les plus récentes du slowlog. La sortie vous montrera les commandes qui ont mis le plus de temps à s'exécuter, ainsi que leurs temps d'exécution et leurs horodatages.
Quitter redis-cli :

Pour vous assurer que les commandes sont enregistrées, quittez redis-cli en tapant :
```
exit
```

Comprendre l'importance

En utilisant LATENCY DOCTOR et en analysant le slowlog, vous pouvez obtenir des informations précieuses sur les performances de votre déploiement Redis. Cela vous permet d'identifier et de résoudre les goulots d'étranglement, d'optimiser vos requêtes et de garantir une expérience utilisateur fluide et réactive.

Vérifier la mémoire avec MEMORY STATS

Dans cette étape, nous allons apprendre à utiliser la commande MEMORY STATS dans Redis pour surveiller et comprendre l'utilisation de la mémoire. Une gestion efficace de la mémoire est cruciale pour la stabilité et les performances de votre serveur Redis.

Pourquoi surveiller la mémoire ?

Redis est un magasin de données en mémoire (in-memory data store), ce qui signifie qu'il stocke toutes ses données dans la RAM. Si Redis manque de mémoire, cela peut entraîner une dégradation des performances, une perte de données, voire des plantages. La surveillance de l'utilisation de la mémoire vous permet d'identifier et de résoudre de manière proactive les problèmes potentiels liés à la mémoire.

Présentation de MEMORY STATS

La commande MEMORY STATS fournit une vue d'ensemble détaillée de la consommation de mémoire de Redis. Elle décompose l'utilisation de la mémoire en différentes catégories, vous donnant un aperçu de l'endroit où votre mémoire est utilisée.

Guide étape par étape

Se connecter à Redis :

Connectez-vous à votre serveur Redis en utilisant la commande redis-cli. Ouvrez un terminal dans votre VM LabEx et exécutez ce qui suit :
```
redis-cli
```
Cela ouvrira l'interface de ligne de commande Redis.
Exécuter MEMORY STATS :

Une fois connecté, exécutez la commande MEMORY STATS :
```
MEMORY STATS
```
Redis collectera alors les statistiques de mémoire et affichera les résultats.
Interprétation de la sortie :

La sortie de MEMORY STATS est un dictionnaire de paires clé-valeur, où chaque clé représente une statistique de mémoire et la valeur représente sa valeur correspondante. Examinons un exemple de sortie et expliquons certaines des métriques clés :
```
127.0.0.1:6379> MEMORY STATS
 1) "peak.allocated"
 2) (integer) 1114480
 3) "total.allocated"
 4) (integer) 1114480
 5) "startup.allocated"
 6) (integer) 948480
 7) "replication.buffer"
 8) (integer) 0
 9) "clients.slaves"
10) (integer) 0
11) "clients.normal"
12) (integer) 6456
13) "aof.buffer"
14) (integer) 0
15) "lua.vm"
16) (integer) 0
17) "overhead.total"
18) (integer) 165992
19) "keys.count"
20) (integer) 0
21) "keys.bytes-per-key"
22) (integer) 0
23) "dataset.bytes"
24) (integer) 948488
25) "dataset.percentage"
26) "0.00%"
27) "bytes-per-replica.avg"
28) (integer) 0
29) "bytes-per-replica.min"
30) (integer) 0
31) "bytes-per-replica.max"
32) (integer) 0
33) "allocator.fragratio"
34) "1.00"
35) "allocator.fragbytes"
36) (integer) 0
37) "allocator.rss"
38) (integer) 835584
39) "allocator.peak"
40) (integer) 1114112
41) "total.system"
42) (integer) 4194304
43) "allocator.resident"
44) (integer) 835584
```
Voici une explication de certaines des métriques clés :
- peak.allocated (Pic alloué) : La quantité maximale de mémoire que Redis a allouée depuis son démarrage.
- total.allocated (Total alloué) : La quantité totale de mémoire actuellement allouée par Redis.
- dataset.bytes (Taille des données) : La taille totale des données stockées dans Redis (hors surcharge).
- overhead.total (Surcharge totale) : La quantité totale de mémoire utilisée pour la surcharge de Redis (par exemple, les structures de données, les métadonnées).
- keys.count (Nombre de clés) : Le nombre de clés actuellement stockées dans Redis.
- allocator.fragratio (Taux de fragmentation de l'allocateur) : Le taux de fragmentation de l'allocateur de mémoire. Une valeur plus élevée indique une plus grande fragmentation.
- allocator.rss (RSS de l'allocateur) : La quantité de mémoire que Redis utilise, telle que rapportée par le système d'exploitation (Resident Set Size).
- total.system (Total système) : La quantité totale de mémoire disponible sur le système.
Quitter redis-cli :

Pour vous assurer que les commandes sont enregistrées, quittez redis-cli en tapant :
```
exit
```

Utilisation des informations

Les informations fournies par MEMORY STATS peuvent être utilisées pour :

Identifier les fuites de mémoire.
Optimiser les structures de données pour réduire l'utilisation de la mémoire.
Ajuster les paramètres de configuration de Redis pour améliorer l'efficacité de la mémoire.
Déterminer si vous devez augmenter la quantité de RAM disponible pour votre serveur Redis.

Analyser les requêtes lentes avec SLOWLOG GET

Dans cette étape, nous allons approfondir l'analyse des requêtes lentes à l'aide de la commande SLOWLOG GET dans Redis. L'identification et l'optimisation des requêtes lentes sont essentielles pour maintenir un déploiement Redis réactif et efficace. Comme suggéré par LATENCY DOCTOR dans la première étape, l'analyse du slowlog (journal des requêtes lentes) est une étape cruciale pour déboguer les problèmes de latence.

Qu'est-ce que le Slowlog ?

Le slowlog est un système dans Redis qui enregistre les requêtes qui dépassent un temps d'exécution spécifié. Cela vous permet d'identifier les requêtes qui prennent plus de temps que prévu et qui ont potentiellement un impact sur les performances.

Guide étape par étape

Se connecter à Redis :

Connectez-vous à votre serveur Redis en utilisant la commande redis-cli. Ouvrez un terminal dans votre VM LabEx et exécutez ce qui suit :
```
redis-cli
```
Cela ouvrira l'interface de ligne de commande Redis.
Récupérer les entrées du Slowlog :

Utilisez la commande SLOWLOG GET pour récupérer les entrées du slowlog. Vous pouvez spécifier le nombre d'entrées à récupérer. Par exemple, pour récupérer les 10 entrées les plus récentes du slowlog, utilisez la commande suivante :
```
SLOWLOG GET 10
```
Si vous souhaitez récupérer toutes les entrées du slowlog, vous pouvez utiliser :
```
SLOWLOG GET
```
Interprétation de la sortie :

La sortie de SLOWLOG GET est un tableau d'entrées du slowlog. Chaque entrée contient les informations suivantes :
- Unique ID (Identifiant unique) : Un identifiant unique pour l'entrée du slowlog.
- Timestamp (Horodatage) : L'horodatage Unix (Unix timestamp) du moment où la requête a été exécutée.
- Execution Time (Temps d'exécution) : Le temps d'exécution de la requête en microsecondes.
- Command (Commande) : La commande complète qui a été exécutée.
- Client IP and Port (if available) (Adresse IP et port du client (si disponible)) : L'adresse IP et le port du client qui a exécuté la commande.
- Client Name (if set) (Nom du client (si défini)) : Le nom du client qui a exécuté la commande.
Voici un exemple d'entrée du slowlog :
```
1) 1) (integer) 1
   2) (integer) 1678886400
   3) (integer) 12345
   4) 1) "KEYS"
      2) "*"
```
Dans cet exemple :
- L'identifiant unique est 1.
- L'horodatage est 1678886400.
- Le temps d'exécution est de 12345 microsecondes (12,345 millisecondes).
- La commande était KEYS *.
Analyse du Slowlog :

Une fois que vous avez récupéré les entrées du slowlog, vous pouvez les analyser pour identifier les requêtes lentes. Recherchez les requêtes avec des temps d'exécution élevés. Considérez les points suivants :
- Frequency (Fréquence) : À quelle fréquence la requête lente se produit-elle ? Si elle se produit fréquemment, elle est susceptible d'avoir un impact plus important sur les performances.
- Command Type (Type de commande) : Quel type de commande est-ce ? Certaines commandes, telles que KEYS *, sont connues pour être lentes et doivent être évitées dans les environnements de production.
- Data Size (Taille des données) : La requête opère-t-elle sur une grande quantité de données ? Si c'est le cas, envisagez d'optimiser les structures de données ou la requête elle-même.
Exemple : Simulation d'une requête lente

Pour démontrer comment les requêtes lentes peuvent être identifiées, insérons un grand nombre de clés dans Redis, puis utilisons la commande KEYS *, qui est connue pour être lente.

Tout d'abord, ajoutons des données. Exécutez les commandes suivantes dans redis-cli :
```
for i in $(seq 1 1000); do SET key$i value$i; done
```
Cela créera 1000 clés dans votre base de données Redis.

Maintenant, exécutez la commande KEYS * :
```
KEYS *
```
Cette commande récupérera toutes les clés de la base de données. Parce que nous avons un grand nombre de clés, cette commande sera probablement lente.

Maintenant, vérifiez le slowlog :
```
SLOWLOG GET 1
```
Vous devriez voir une entrée pour la commande KEYS * dans le slowlog, ainsi que son temps d'exécution.
Quitter redis-cli :

Pour vous assurer que les commandes sont enregistrées, quittez redis-cli en tapant :
```
exit
```

Utilisation des informations

En analysant le slowlog, vous pouvez identifier les requêtes lentes et prendre des mesures pour les optimiser. Cela pourrait impliquer :

Réécrire la requête pour qu'elle soit plus efficace.
Optimiser les structures de données utilisées par la requête.
Ajouter des index pour améliorer les performances des requêtes.
Éviter les commandes connues pour être lentes, telles que KEYS *.

Résumé

Dans ce labo, nous avons exploré les techniques de surveillance des performances de Redis. Nous avons commencé par utiliser la commande LATENCY DOCTOR pour diagnostiquer et résoudre les problèmes de latence, en comprenant que la latence est le délai entre une requête et une réponse. La commande analyse le fonctionnement de Redis et fournit des informations sur les causes potentielles des retards.

Le labo a démontré comment se connecter à Redis en utilisant redis-cli et exécuter la commande LATENCY DOCTOR. Nous avons ensuite appris à interpréter la sortie, en nous concentrant sur les sections SUMMARY (résumé), DETAILS (détails) et ADVICE (conseils) pour identifier les goulots d'étranglement potentiels et comprendre les requêtes lentes.