• 10 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 25/04/2022

Vérifiez la performance d’une application avec Locust

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Les tests de performance sont des procédures de test qui permettent de tester la vitesse, le temps de réponse, la stabilité et l'utilisation des ressources d'une application logicielle sous une charge de travail particulière.

Par exemple, un critère de performance peut spécifier qu'une application doit être capable de gérer 500 utilisateurs simultanés. Le but ici n’est pas forcément de couvrir 80 % ou 90 % du code par des tests de performance comme pour les tests unitaires, mais de couvrir les fonctionnalités qui présentent un risque sur l'utilisation des ressources de l’application.

L'objectif principal des tests de performance est d'identifier et d'éliminer les goulots d'étranglement qui pourraient interrompre le flux de données d’une application.

Dans ce chapitre, nous allons découvrir Locust, le framework de test de performance facile à utiliser et open source.

Découvrez les métriques de performance

Un certain nombre de métriques peuvent être mesurées lors du test. Ces indicateurs de performance permettront d’identifier les points de blocage, ou de valider les seuils définis dans la spécification. Voici quelques indicateurs de performance intéressants à mesurer lors d’un test de performance :

  • débit : quantité d'informations transmises ;

  • mémoire : quantité de données stockées ;

  • temps de réponse : le temps écoulé entre l'envoi de la requête et la réception de la réponse ;

  • CPU : utilisation du CPU.

Enfin, l’analyse des différentes métriques permettra de prévoir un paramétrage de la configuration ou un potentiel changement du code afin d’obtenir les valeurs attendues.

Voyons maintenant comment nous allons tirer parti du framework Locust pour faire nos tests de performance ! Locust permet de mesurer essentiellement les temps de réponse des différentes fonctionnalités, en prenant en compte le nombre d’utilisateurs et le nombre de requêtes sur l’application.

Configurez Locust

Avant de commencer à créer votre premier test de performance, vous devez installer Locust sur votre environnement à l’aide de la commandepip install locust.

Une fois l’installation terminée, vous pouvez tester si Locust s’est bien installé en exécutant la commande suivante dans le terminal :locust --help.

Vous devriez maintenant avoir une belle documentation des commandes de Locust, comme dans l’image ci-dessous.

Utilisez la commande `locust --help`  sur le terminal pour vérifier son téléchargement et son installation.
L’installation de Locust est un franc succès.

Dans la suite du chapitre, nous explorerons les fonctionnalités de base fournies par Locust et verrons comment écrire un script de test pour tester notre projet Django OC-commerce.

Écrivez un script Locust

Pour commencer, nous devons créer un dossier qui contiendra le script. Afin de garder la même logique que dans les autres types de tests, vous allez créer un dossierperformance_testsdans l’arborescence detests/. Enfin, vous pouvez créer le fichierlocustfile.pydans ce nouveau dossier.

Nous allons tout d’abord créer un test simple qui testera la réponse de la page d’accueil (/home).

Dans votre nouveau fichierlocustfile.py, ajoutez-y l'instruction d'importation suivante :

from locust import HttpUser, task

Ensuite, créez une classe qui hérite de la classeHttpUser, nous la nommeronsProjectPerfTest.

class ProjectPerfTest(HttpUser):

La classeHttpUserest une instance deHttpSessionqui fournit un client de test. Comme pour les tests unitaires, le client permettra de faire la requête sur l’URL de votre choix.

Autrement dit, lorsqu'un test démarre, Locust créera une instance de cette classe pour chaque utilisateur qu'il simule, et chacun de ces utilisateurs s'exécutera dans son propre thread.

Vous pouvez maintenant implémenter votre scénario dans une méthode précédée par le décorateur@task. En effet, Locust considère que chaque méthode contenant le décorateur@taskest une tâche à lancer.

Voici notre test qui permettra de faire des requêtes sur la page d'accueil :

class ProjectPerfTest(HttpUser):
@task
def home(self):
self.client.get("/home")

Contrôlez le nombre d'occurrences d’une tâche

Vous pouvez contrôler la charge de travail de vos différentes tâches en fonction d’une tâche de référence, et donc augmenter le nombre de lancements d’une ou plusieurs tâches. Concernant les tâches suivantes, vous pouvez rajouter un entiernen argument du décorateur@taskpour augmenter le nombre de lancements de cette tâche. En effet, si vous spécifiez cet entiern, cette tâche sera exécutéenfois plus que la première tâche.

Par exemple :

@task(3)
def login(self):
response = self.client.get("/user/login")

Dans cet exemple, la tâchelogin()sera exécutée 3 fois plus de fois que la tâchehome(). Si nous ajoutons une nouvelle tâche avec le décorateur@task(6), cette tâche sera exécutée 6 fois plus que la tâche de référence, qui est dans notre cas la tâchehome().

Créez une requête POST

Vous pouvez aussi effectuer des requêtesPOSTen fournissant la data en deuxième argument de la méthodepost(). Vous pouvez faire le code suivant dans le cas d’une connexion d’un utilisateur :

self.client.post("/user/login", {"username":"userTest", "password":"passwordTest"})

De plus, la classeHttpUserfournit deux méthodes qui seront appelées lors du démarrage et de l'arrêt de Locust :

  • on_start();

  • on_stop().

Ainsi, ces méthodes peuvent servir pour configurer un utilisateur et tester la connexion et la déconnexion, par exemple.

Notez que seules les méthodes contenant le décorateur@tasksont considérées comme un scénario à exécuter. Vous pouvez donc ajouter d'autres méthodes pour factoriser ou configurer votre scénario.

Lancez un script Locust

Nous avons finalement le script suivant :

from locust import HttpUser, task
class ProjectPerfTest(HttpUser):
@task
def home(self):
response = self.client.get("/home")
@task(3)
def login(self):
response = self.client.get("/user/login")

Testons-le en ouvrant un terminal pointant sur le répertoire contenant le fichierlocustfile.py.

Si vous avez donnélocustfile.pycomme nom de fichier de votre script, vous pouvez simplement exécuter dans le terminal la commandelocust.

Sinon, vous devez préciser le nom du fichier précédé de l’option-f, comme ceci :locust -f nom_du_fichier.py.

Vous devriez avoir la sortie suivante sur votre terminal :

La commande `locust` permet d'exécuter le serveur avec le fichier `locustfile.py` contenu dans le répertoire courant.
Le serveur Locust est démarré.

Ouvrez votre navigateur et entrez l’URLhttp://0.0.0.0:8089comme indiqué sur le terminal afin d'accéder à l’interface web de Locust. Vous devriez avoir la page suivante : 

Une fois le navigateur ouvert sur l’URL `http://0.0.0.0:8089`, il faut configurer le nombre d’utilisateurs, le taux de création d’utilisateurs et l’URL de l’application.
Il est temps de lancer les tests.

Sur cette page, vous devez préciser :

  • Number of total users to simulate : le nombre total d'utilisateurs à simuler.

  • Spawn rate : le taux de création d'utilisateurs, il correspond au nombre d’utilisateurs créés par seconde jusqu’à atteindre le nombre total d’utilisateurs. 

  • Host : l’adresse de votre application, dans notre cas l’application est lancée sur le localhost.

Cliquez maintenant sur le boutonStart swarmingune fois que vous êtes prêt. Le framework exécutera les tâches indéfiniment jusqu’à ce que vous arrêtiez le test manuellement en appuyant sur le boutonStopen haut à droite de la page.

Vous pourrez ensuite analyser les résultats grâce au tableau récapitulatif ou grâce à l’onglet Charts qui représente les résultats graphiques du test. 

Une fois que le test est stoppé, un tableau récapitule les résultats de chaque tâche du fichier de test.
Résultat du test de performance

Les statistiques fournies par le tableau permettent d’analyser les performances de notre application. Voici les différents paramètres : 

  • Requests : Nombre total de demandes effectuées jusqu'à présent.

  • Fails : Nombre de demandes qui ont échoué.

  • Median : Vitesse de réponse pour 50 centiles en ms.

  • 90%ile : Vitesse de réponse pour 90 centiles en ms.

  • Average : Vitesse de réponse moyenne en ms.

  • Min : Vitesse de réponse minimale en ms.

  • Max : Vitesse de réponse maximale en ms.

  • Average size : Taille moyenne des réponses en octets.

  • Current RPS : Requêtes actuelles par seconde.

  • Current Failure/s : Nombre total d'échecs par seconde.

À vous de jouer !

Maintenant que vous avez vu comment créer vos tests de performance à l’aide de Locust, je vous propose de reprendre le fichierlocustfile.pyet d’ajouter de nouvelles tâches.

Votre mission :

  • Ajoutez une tâche pour :

    • l’inscription d’un utilisateur ;

    • le profil de l’utilisateur ;

    • les favoris de l’utilisateur.

  • Variez le ratio de lancement des tâches avec le décorateur@task.

  • Modifiez le nombre d’utilisateurs et le nombre d’utilisateurs par seconde.

Retrouvez une proposition de correction sur GitHub !

En résumé

  • Les tests de performance consistent à évaluer les performances d'une application en termes de réactivité et de stabilité.

  • Locust est un outil de test de performance open source. Il permet de tester la charge de l’application en simulant des milliers d’utilisateurs simultanément sur notre application.

  • Chaque test sera implémenté dans une méthode d’une classe héritant deHttpUser.

  • Les tâches devront être implémentées dans une méthode précédée du décorateur@task, sinon elles ne seront pas exécutées.

Maintenant que vous êtes incollable sur l’ensemble des types de tests de la pyramide, nous allons voir un dernier point concernant une méthodologie de test utilisée dans toutes les entreprises. Allez, plus qu’un chapitre !

Exemple de certificat de réussite
Exemple de certificat de réussite