Leny Bernard
le 

Réaliser un test de charge de son site avec Artillery

5 minutes de lecture

Les équipes ont bien travaillé et les dernières PR ne sont pas encore mergées... On prépare la mise en production de manière prudente mais le site a une forte audience et la campagne est importante. On prévoit un envoi de plus de 500 000 mails.

On a beau être confiant quant à la solidité de notre code ou la robustesse de notre serveur, l'angoisse persiste. Bien sur, le demi-million de personnes ne va pas se connecter en même temps sur le site et utiliser l'application dans son ensemble mais quel est le seuil à partir duquel le site va être en difficulté ?


Je vous présente Artillery.io ! C'est un outil (open-source bien sur) permettant de créer et lancer des tests de charge.

On va pouvoir obtenir en une ligne de commande (artillery quick --count 10 -n 20 https://monsite.com) seulement test "basique" qui va bombarder de manière générale le site...

Et puis on va pouvoir programmer des frappes chirurgicales, des scénarios plus précis, identifiés comme étant particulièrement gourmand en ressource ou bien simplement plus révélateur de l'activité attendue du site.

Pour commencer, vous allez devoir installer Artillery, ça se fait avec la commande suivante :

1npm install -g artillery

Accéder à la documentation complète

Une fois que c'est fait, dans le projet que vous souhaitez tester (à côté de vos tests unitaires ou fonctionnels par exemple) ou dans un repo séparé vous allez avoir à créer un fichier de configuration au format YAML.

Artillery apporte 2 concepts principaux qu'on retrouvera dans ce fichier :

  • les phases
  • les scénarios

Qu'est-ce qu'une phase Artillery ?

Lorsqu'on lance un test de charge, on veut identifier à quel moment notre serveur souffre. Les phases vont nous permettre de pondérer le nombre d'utilisateurs virtuels ainsi que la manière d'arriver sur le site (flux linéaire ou progressif).

Une phase de flux linéaire se configure comme ceci :

1config:
2  phases:
3    - duration: 300
4      arrivalRate: 25
5      name: "Warming up"

Cette phase va simuler l'activité de 25 utilisateurs pendant 300 secondes (5 minutes).

1config:
2  phases:
3    - duration: 300
4      rampTo: 50

Cette phase va faire monter la pression tout doucement, pour arriver au bout de 5 minutes à 50 utilisateurs concurents sur le site.

Construisez vos phases jusqu'à faire tomber votre serveur, c'est le but, connaitre les limites de votre système. Donc faites-le idéalement en pleine nuit, là où il n'y a pas grand monde sur votre site.

Boom

Par exemple, voici les phases que j'ai utilisé pour un test de charge que je viens de réaliser :

  • commencer tranquillement avec 25 personnes sur 5 minutes
  • puis rampe linéaire à 50 personnes sur 5 minutes
  • idem avec rampe linéaire 75 personnes sur 5 minutes
  • idem avec rampe linéaire 150 personnes sur 5 minutes
  • idem avec rampe linéaire 300 personnes sur 5 minutes
  • idem avec rampe linéaire 500 personnes sur 5 minutes
  • idem avec rampe linéaire 1000 personnes sur 5 minutes
<script src="https://gist.github.com/lenybernard/af6f6fd2a52177125e845d2514e9fa4f.js"></script>

Compris ? Si besoin, allez voir la doc à ce sujet, elle est très cool !

Qu'est-ce qu'un scénario Artillery ?

On a vu que lors des phases de test, Artillery allait invoquer des utilisateurs virtuels. Mais que doivent-ils faire ? Comment doivent-ils se comporter sur notre site ? Artillery va distribuer les scénarios aux différents utilisateurs virtuels ce qui leur donnera les instructions à effectuer.

On va pouvoir pondérer les scénarios avec un poids (weight) afin que certains scénarios soient plus distribués que d'autres.

Quels types d'instructions un scénario Artillery donne-il ?

Si vous avez l'habitude des tests fonctionnels, le principe est assez proche. On va créer des requêtes de toute part (url, headers, params, verb) et pour ce faire, on va pouvoir s'appuyer sur :

  • un fichier de données CSV pour importer une grande varieté de données (payload files).
  • des listes de variables
  • des fonctions javascript personnalisées (processors) qui vont préparer des variables pour chaque session

La ligne de commande (CLI)

Lorsque vous aurez écrit votre fichier de test yaml, vous allez vouloir lancer votre test. C'est alors que vous devrez jouer avec le CLI. Rassurez-vous, il est facile d'utilisation mais voici quelques pro-tips que j'ai mis un peu de temps à trouver et qui sont très importants pour ne pas perdre du temps et exploiter le potentiel d'Artillery :

Lancer un test... simple, basique

1artillery run -k test.yml

Lancer un test en debuggant request ou response ou les 2 (très cool quand on fait des trucs un peu compliqué et qu'on ne comprend pas pourquoi on obtient un erreur 400)

1DEBUG=http:request artillery run -k test.yml
2DEBUG=http:response artillery run -k test.yml
3DEBUG=http:* artillery run -k test.yml

Générer un rapport à la fin du test

1artillery run -k test.yml -o output.json
2artillery report ouptut.json
Rapport d'un test Artillery

Bon, le rapport est pas incroyable mais il est tout de même beaucoup plus digeste que le log donné par le CLI et plus compréhensible si vous souhaitez le montrer à un client où une personne non technique.

Exemple complet et concrêt

Personnellement, j'aime beaucoup avoir un exemple complet et fonctionnel donc j'espère qu'il vous fera gagner du temps notamment avec les processors et les boucles (loop).

Enjoy !