Comment évaluer les performances d’un serveur Redis sur Ubuntu 18.04

introduction

L'analyse comparative est une pratique importante lorsqu'il s'agit d'analyser les performances globales des serveurs de base de données. C’est utile pour identifier les goulots d’étranglement ainsi que les possibilités d’amélioration au sein de ces systèmes.

Redis est un magasin de données en mémoire qui peut être utilisé comme base de données, cache et courtier de messages. Il prend en charge des structures de données simples à complexes, y compris des hachages, des chaînes, des ensembles triés, des bitmaps, des données géospatiales. Dans ce guide, nous montrerons comment évaluer les performances d’un serveur Redis fonctionnant sous Ubuntu 18.04, à l’aide de plusieurs outils et méthodes.

Conditions préalables

Pour suivre ce guide, vous aurez besoin de:

[.note] #Note: Les commandes présentées dans ce didacticiel ont été exécutées sur un serveur Redis dédié fonctionnant sur un droplet DigitalOcean de 4 Go.
#

Utilisation de l'outilredis-benchmark inclus

Redis est livré avec un outil de référence appeléredis-benchmark. Ce programme peut être utilisé pour simuler un nombre arbitraire de clients se connectant en même temps et effectuant des actions sur le serveur, mesurant le temps nécessaire au traitement des demandes. Les données obtenues vous donneront une idée du nombre moyen de requêtes que votre serveur Redis est capable de traiter par seconde.

La liste suivante détaille certaines des options de commande courantes utilisées avecredis-benchmark:

  • -h: hôte Redis. La valeur par défaut est127.0.0.1.

  • -p: port Redis. La valeur par défaut est6379.

  • -a: si votre serveur requiert une authentification, vous pouvez utiliser cette option pour fournir le mot de passe.

  • -c: nombre de clients (connexions parallèles) à simuler. La valeur par défaut est 50.

  • -n: combien de requêtes à faire. La valeur par défaut est 100000.

  • -d: taille des données pour les valeursSET etGET, mesurée en octets. La valeur par défaut est 3.

  • -t: exécutez uniquement un sous-ensemble de tests. Par exemple, vous pouvez utiliser-t get,set pour évaluer les performances des commandesGET etSET.

  • -P: utilisez le pipelining pour améliorer les performances.

  • -q: mode silencieux, affiche uniquement les informations moyennes derequests per second.

Par exemple, si vous souhaitez vérifier le nombre moyen de requêtes par seconde que votre serveur Redis local peut gérer, vous pouvez utiliser:

redis-benchmark -q

Vous obtiendrez une sortie similaire à celle-ci, mais avec des nombres différents:

OutputPING_INLINE: 85178.88 requests per second
PING_BULK: 83056.48 requests per second
SET: 72202.16 requests per second
GET: 94607.38 requests per second
INCR: 84961.77 requests per second
LPUSH: 78988.94 requests per second
RPUSH: 88652.48 requests per second
LPOP: 87950.75 requests per second
RPOP: 80971.66 requests per second
SADD: 80192.46 requests per second
HSET: 84317.03 requests per second
SPOP: 78125.00 requests per second
LPUSH (needed to benchmark LRANGE): 84175.09 requests per second
LRANGE_100 (first 100 elements): 52383.45 requests per second
LRANGE_300 (first 300 elements): 21547.08 requests per second
LRANGE_500 (first 450 elements): 14471.78 requests per second
LRANGE_600 (first 600 elements): 9383.50 requests per second
MSET (10 keys): 71225.07 requests per second

Vous pouvez également limiter les tests à un sous-ensemble de commandes de votre choix en utilisant le paramètre-t. La commande suivante affiche les moyennes pour les commandesGET etSET uniquement:

redis-benchmark -t set,get -q
OutputSET: 76687.12 requests per second
GET: 82576.38 requests per second

Les options par défaut utiliseront 50 connexions parallèles pour créer 100 000 requêtes au serveur Redis. Si vous souhaitez augmenter le nombre de connexions parallèles pour simuler un pic d'utilisation, vous pouvez utiliser l'option-c pour cela:

redis-benchmark -t set,get -q -c 1000

Comme cela utilisera 1 000 connexions simultanées au lieu de 50 par défaut, vous devez vous attendre à une baisse des performances:

OutputSET: 69444.45 requests per second
GET: 70821.53 requests per second

Si vous voulez des informations détaillées dans la sortie, vous pouvez supprimer l'option-q. La commande suivante utilisera 100 connexions parallèles pour exécuter les 1 000 requêtes SET sur le serveur:

redis-benchmark -t set -c 100 -n 1000000

Vous obtiendrez une sortie similaire à celle-ci:

Output====== SET ======
  1000000 requests completed in 11.29 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

95.22% <= 1 milliseconds
98.97% <= 2 milliseconds
99.86% <= 3 milliseconds
99.95% <= 4 milliseconds
99.99% <= 5 milliseconds
99.99% <= 6 milliseconds
100.00% <= 7 milliseconds
100.00% <= 8 milliseconds
100.00% <= 8 milliseconds
88605.35 requests per second

Les paramètres par défaut utilisent 3 octets pour les valeurs de clé. Vous pouvez changer cela avec l'option-d. La commande suivante évaluera les commandesGET etSET en utilisant des valeurs de clé de 1 Mo:

redis-benchmark -t set,get -d 1000000 -n 1000 -q

Etant donné que le serveur fonctionne avec une charge utile beaucoup plus importante cette fois, une baisse significative des performances est attendue:

OutputSET: 1642.04 requests per second
GET: 822.37 requests per second

Il est important de réaliser que même si ces chiffres sont utiles pour évaluer rapidement les performances d’une instance Redis, ils ne représentent pas le débit maximal qu’une instance Redis peut gérer. En utilisantpipelining, les applications peuvent envoyer plusieurs commandes à la fois afin d'améliorer le nombre de requêtes par seconde que le serveur peut traiter. Avecredis-benchmark, vous pouvez utiliser l'option-P pour simuler des applications du monde réel qui utilisent cette fonctionnalité Redis.

Pour comparer la différence, exécutez d'abord la commanderedis-benchmark avec les valeurs par défaut et sans pipelining, pour les testsGET etSET:

redis-benchmark -t get,set -q
OutputSET: 86281.27 requests per second
GET: 89847.26 requests per second

La prochaine commande exécutera les mêmes tests, mais mettra en pipeline 8 commandes ensemble:

redis-benchmark -t get,set -q -P 8
OutputSET: 653594.81 requests per second
GET: 793650.75 requests per second

Comme vous pouvez le constater à la sortie, l’utilisation du traitement en pipeline améliore considérablement les performances.

Vérification de la latence avecredis-cli

Si vous souhaitez une simple mesure du temps moyen requis par une demande pour recevoir une réponse, vous pouvez utiliser le client Redis pour vérifier la latence moyenne du serveur. Dans le contexte de Redis, la latence est une mesure du temps nécessaire à une commandeping pour recevoir une réponse du serveur.

La commande suivante affiche les statistiques de latence en temps réel de votre serveur Redis:

redis-cli --latency

Vous obtiendrez une sortie similaire à celle-ci, affichant un nombre croissant d’échantillons et une latence moyenne variable:

Outputmin: 0, max: 1, avg: 0.18 (970 samples)

Cette commande continuera à fonctionner indéfiniment. Vous pouvez l'arrêter avec unCTRL+C.

Pour surveiller la latence sur une certaine période, vous pouvez utiliser:

redis-cli --latency-history

Cela suivra les moyennes de latence au fil du temps, avec un intervalle configurable défini par défaut sur 15 secondes. Vous obtiendrez une sortie similaire à celle-ci:

Outputmin: 0, max: 1, avg: 0.18 (1449 samples) -- 15.01 seconds range
min: 0, max: 1, avg: 0.16 (1449 samples) -- 15.00 seconds range
min: 0, max: 1, avg: 0.17 (1449 samples) -- 15.00 seconds range
min: 0, max: 1, avg: 0.17 (1444 samples) -- 15.01 seconds range
min: 0, max: 1, avg: 0.17 (1446 samples) -- 15.01 seconds range
min: 0, max: 1, avg: 0.17 (1449 samples) -- 15.00 seconds range
min: 0, max: 1, avg: 0.16 (1444 samples) -- 15.00 seconds range
min: 0, max: 1, avg: 0.17 (1445 samples) -- 15.01 seconds range
min: 0, max: 1, avg: 0.16 (1445 samples) -- 15.01 seconds range
...

Le serveur Redis de notre exemple étant inactif, il n’ya pas beaucoup de variation entre les échantillons de latence. Si vous avez un pic d'utilisation, cependant, cela devrait se traduire par une augmentation de la latence dans les résultats.

Si vous souhaitez mesurer uniquement la latence desystem, vous pouvez utiliser--intrinsic-latency pour cela. La latence intrinsèque est inhérente à l’environnement et dépend de facteurs tels que le matériel, le noyau, les voisins du serveur et d’autres facteurs non contrôlés par Redis.

Vous pouvez voir la latence intrinsèque comme base de vos performances globales sous Redis. La commande suivante vérifiera la latence intrinsèque du système en effectuant un test pendant 30 secondes:

redis-cli --intrinsic-latency 30

Vous devriez obtenir une sortie semblable à ceci:

Output…

498723744 total runs (avg latency: 0.0602 microseconds / 60.15 nanoseconds per run).
Worst run took 22975x longer than the average latency.

La comparaison des deux tests de latence peut être utile pour identifier les goulots d'étranglement matériels ou système susceptibles d'affecter les performances de votre serveur Redis. Étant donné que la latence totale d’une requête adressée à notre exemple de serveur a une moyenne de 0,18 microsecondes, une latence intrinsèque de 0,06 microsecondes signifie qu’un tiers du temps total de la requête est utilisé par le système dans des processus non contrôlés par Redis.

Utilisation de l'outil de référence Memtier

Memtier est un outil de référence à haut débit pour Redis etMemcached créé par Redis Labs. Bien que très similaire àredis-benchmark sous divers aspects, Memtier dispose de plusieurs options de configuration qui peuvent être réglées pour mieux émuler le type de charge que vous pourriez attendre sur votre serveur Redis, en plus d'offrir la prise en charge des clusters.

Pour installer Memtier sur votre serveur, vous devez compiler le logiciel à partir de la source. Commencez par installer les dépendances nécessaires à la compilation du code:

sudo apt-get install build-essential autoconf automake libpcre3-dev libevent-dev pkg-config zlib1g-dev

Ensuite, allez dans votre répertoire personnel et clonez le projetmemtier_benchmark à partir de sesGithub repository:

cd
git clone https://github.com/RedisLabs/memtier_benchmark.git

Accédez au répertoire du projet et exécutez la commandeautoreconf pour générer les scripts de configuration de l'application:

cd memtier_benchmark
autoreconf -ivf

Exécutez le scriptconfigure afin de générer les artefacts d'application nécessaires à la compilation:

./configure

Maintenant, exécutezmake pour compiler l'application:

make

Une fois la construction terminée, vous pouvez tester le fichier exécutable avec:

./memtier_benchmark --version

Cela vous donnera la sortie suivante:

Outputmemtier_benchmark 1.2.17
Copyright (C) 2011-2017 Redis Labs Ltd.
This is free software.  You may redistribute copies of it under the terms of
the GNU General Public License .
There is NO WARRANTY, to the extent permitted by law.

La liste suivante contient certaines des options les plus courantes utilisées avec la commandememtier_benchmark:

  • -s: hôte du serveur. La valeur par défaut estlocalhost.

  • -p: port du serveur. La valeur par défaut est6379.

  • -a: authentifie les demandes à l'aide du mot de passe fourni.

  • -n: nombre de requêtes par client (la valeur par défaut est 10000).

  • -c: nombre de clients (la valeur par défaut est 50).

  • -t: nombre de threads (la valeur par défaut est 4).

  • --pipeline: activer le pipelining.

  • --ratio: rapport entre les commandesSET etGET, la valeur par défaut est 1:10.

  • --hide-histogram: masque les informations de sortie détaillées.

La plupart de ces options sont très similaires aux options présentes dansredis-benchmark, mais Memtier teste les performances d'une manière différente. Pour mieux simuler les environnements réels courants, le benchmark par défaut effectué parmemtier_benchmark testera uniquement les requêtesGET etSET, dans un rapport de 1 à 10. Avec 10 opérations GET pour chaque opération SET du test, cet agencement est plus représentatif d'une application Web commune utilisant Redis comme base de données ou cache. Vous pouvez ajuster la valeur du rapport avec l'option--ratio.

La commande suivante exécutememtier_benchmark avec les paramètres par défaut, tout en fournissant uniquement des informations de sortie de haut niveau:

./memtier_benchmark --hide-histogram

[.Remarque]##

Note: si vous avez configuré votre serveur Redis pour exiger une authentification, vous devez fournir l'option-a avec votre mot de passe Redis à la commandememtier_benchmark:

./memtier_benchmark --hide-histogram -a your_redis_password

Vous verrez une sortie semblable à celle-ci:

Output...

4         Threads
50        Connections per thread
10000     Requests per client


ALL STATS
=========================================================================
Type         Ops/sec     Hits/sec   Misses/sec      Latency       KB/sec
-------------------------------------------------------------------------
Sets         8258.50          ---          ---      2.19800       636.05
Gets        82494.28     41483.10     41011.18      2.19800      4590.88
Waits           0.00          ---          ---      0.00000          ---
Totals      90752.78     41483.10     41011.18      2.19800      5226.93

Selon cette exécution dememtier_benchmark, notre serveur Redis peut exécuter environ 90000 opérations par seconde dans un rapport de 1:10SET /GET.

Il est important de noter que chaque outil de référence a son propre algorithme pour les tests de performance et la présentation des données. Pour cette raison, il est normal d’obtenir des résultats légèrement différents sur le même serveur, même lorsque vous utilisez des paramètres similaires.

Conclusion

Dans ce guide, nous avons montré comment effectuer des tests de référence sur un serveur Redis à l'aide de deux outils distincts: lesredis-benchmark inclus et l'outilmemtier_benchmark développé par Redis Labs. Nous avons également vu comment vérifier la latence du serveur à l'aide deredis-cli. Sur la base des données obtenues à partir de ces tests, vous comprendrez mieux ce à quoi s’attendre de votre serveur Redis en termes de performances et quels sont les goulets d’étranglement de votre configuration actuelle.