Test de charge d'API avec Locust
Test de charge d'API avec Locust : introduction
Vous avez probablement déjà été dans cette situation : vous écrivez du code qui fait quelque chose, un point de terminaison par exemple. Vous testez votre point de terminaison à l'aide de Postman ou Insomnia, et tout fonctionne bien. Vous transmettez le point de terminaison au développeur côté client, qui consomme ensuite le API et déploie l'application. Mais ensuite, l'API échoue lorsque les utilisateurs utilisent l'application.
Cela peut être une situation très ennuyeuse, sans parler des coûts pour une entreprise. C'est pourquoi les développeurs de logiciels effectuent une variété de tests sur les systèmes logiciels pour s'assurer qu'ils fonctionnent comme prévu. Les API ne sont pas différentes. Avant le déploiement, vous devez au moins effectuer des tests de performances et des tests de sécurité.
Les tests de performances peuvent être regroupés en tests de fonctionnalité et en tests de charge. Les tests de fonctionnalité sont ce pour quoi vous utilisez habituellement Postman ou Insomnia. Ils garantissent que votre API fonctionne comme prévu. Les tests de charge, en revanche, concernent davantage les performances de votre API avec une utilisation réelle et une charge de pointe, et c'est de cela qu'il s'agit dans cet article. Examinons les tests de charge plus en détail.
Qu'est-ce que le test de charge d'API ?
Le test de charge d'API est un type de test que les développeurs utilisent pour simuler une charge normale et maximale sur les points de terminaison. Ce type de test permet aux développeurs d'évaluer les performances réelles d'une API avant son déploiement. Il les aide à identifier la capacité de fonctionnement maximale d'un système, les goulots d'étranglement éventuels et la dégradation des performances. Les tests de charge d'API sont généralement effectués en créant des utilisateurs virtuels, puis en les utilisant pour tester simultanément les fonctionnalités de l'API.
Les tests de charge d'API mesurent des métriques telles que le temps de réponse, les utilisateurs simultanés, les taux de débit, les niveaux d'utilisation des ressources, le temps moyen entre pannes (MTBF), le temps moyen avant panne (MTTF), etc. Toutes ces métriques peuvent être utilisées pour déterminer les performances de l'API.
Types de test de charge
Il existe plusieurs types de tests de charge, chacun avec ses cas d'utilisation. Jetons un coup d'œil à certains d'entre eux.
Test de charge : C'est la forme de base d'un test de charge. Il est utilisé pour évaluer les performances d'un système (dans ce cas, une API) sous une charge normale et une charge de pointe attendue.
Tests de résistance : Ceci est utilisé pour évaluer les performances d'un système sous une charge très lourde. L'objectif de ce test est de voir si un système se rétablit après une panne, et combien de temps il faut pour le faire. La charge est généralement augmentée lentement jusqu'à ce qu'elle dépasse les capacités du système.
Test de pointe : Ceci est un peu similaire aux tests de résistance, sauf qu'une forte charge est appliquée soudainement, au lieu de l'augmenter lentement. Ce type de test représente ce qui se passe lorsqu'il y a un pic soudain de votre nombre moyen d'utilisateurs ou de visiteurs, ou lorsqu'il y a une attaque DDOS sur votre système.
Test de trempage : Ce test est différent des autres ci-dessus. Il met votre système sous 80% (ou environ) de la charge normale et le laisse fonctionner pendant une longue période, disons 12 à 14 heures. Ce type de test détermine la fiabilité d'un système dans le temps.
Test de charge de vos API avec Locust
Les développeurs ont accès à une variété d'options pour tester la charge de leurs API. Certains outils de test de charge courants sont Gatling, JMeter et Locust. Nous nous concentrerons sur Locust dans cet article.
Locust est un outil de test de charge open source basé sur python utilisé par les plus grandes entreprises telles que Google, Microsoft et Riot Games pour tester leurs API. Dans cet article, nous allons montrer comment tester en charge une API.
Pour ce tutoriel, je vais créer une API simple avec Flask. Vous pouvez suivre avec moi ou simplement créer votre API avec Node, ou n'importe quel framework avec lequel vous êtes à l'aise.
Exigences
Python 3
Configuration et installation
Tout d'abord, vous devez configurer un environnement virtuel sur votre PC afin de ne pas gâcher votre environnement Python global. Pour ce faire, exécutez les commandes suivantes. Notez que ces commandes s'appliquent à un terminal Windows.
Projet $mkdir
$ cd /d chemin\vers\projet
$ python -m venv venv
$ venv\Scripts\activer
Dans un premier temps, nous avons créé un Projet annuaire. Ensuite, nous avons changé notre répertoire actuel en Projet. Nous avons ensuite créé et activé un environnement virtuel pour Python dans ce répertoire.
Passons maintenant à l'installation Flacon(nous l'utiliserons pour créer les points de terminaison à tester en charge) et Criquet elle-même.
Pour installer Flask, exécutez. Assurez-vous que vous êtes dans le Projet où vous avez créé un environnement virtuel.
Flacon d'installation $ pip
Pour installer Locust, exécutez
$ pip installer criquet
Une fois cela fait, tapez les commandes suivantes. Assurez-vous d'être dans votre Projet répertoire lorsque vous faites cela.
$ copie nul __init__.py
application $mkdir
$ copie nulle app\app.py
$ copie nulle app\__init__.py
Cette commande crée des fichiers que nous utiliserons pour créer nos points de terminaison à l'aide de Flask. Vous pouvez également créer ces fichiers à l'aide de votre explorateur de fichiers. Mais quel est le plaisir là-dedans ? Une fois que vous avez fait cela, copiez le code ci-dessous dans app.py
depuis l'importation du flacon Flask, jsonify, request
app = Flacon (__ nom__)
modèles_voitures = [
{ 'marque' : 'Tesla', 'modèle' : 'Modèle S' }
]
avions_modèles = [
{ 'marque' : 'Boeing', 'modèle' : '747' }
]
@app.route('/voitures')
def get_cars() :
retourner jsonify(car_models)
@app.route('/avions')
def get_planes() :
retourner jsonify(plane_models)
si __name__ == '__main__':
app.run(debug=True)
Le code ci-dessus contient une méthode get_cars utilisé pour obtenir une liste des marques de voitures et de leurs modèles, et get_planes utilisé pour obtenir une liste des marques d'avions et de leurs modèles. Pour que nous puissions tester en charge ce point de terminaison, nous devons exécuter app.py. Pour ce faire, exécutez la commande ci-dessous.
$ chemin python\vers\app.py
Une fois que vous avez exécuté cela, vous devriez voir quelque chose comme ceci :
Si vous copiez l'URL du terminal et tapez voitures or avions après le /, vous devriez pouvoir y voir les données. Cependant, notre objectif est de tester le point de terminaison avec locust, pas avec le navigateur. Alors faisons ça. Exécutez la commande suivante à la racine de votre Projet répertoire.
$ copie nul locust_test.py
Cela crée un fichier 'locust_test.py' à la racine de votre Projet annuaire. Une fois que vous avez fait cela, ouvrez le fichier et collez le code ci-dessous. Nous l'expliquerons sous peu.
temps d'importation
from locust import HttpUser, tâche, entre
classe UserBehavior(HttpUser):
temps_d'attente = entre (5, 10)
@tâche
def get_cars(soi) :
self.client.get('/cars')
@tâche
def get_planes(soi) :
self.client.get('/planes')
Ceci est un exemple basique d'utilisation de Locust pour tester en charge une API. Tout d'abord, nous créons une classe Comportement de l'utilisateur, qui peut recevoir n'importe quel nom approprié mais doit s'étendre Utilisateur HTTP. Utilisateur HTTP est la classe qui s'occupe d'instancier plusieurs utilisateurs virtuels pour effectuer les tâches que nous spécifions dans le Comportement de l'utilisateur classe.
Une tâche est spécifiée en décorant une méthode avec le @tâche décorateur. Nous avons également une fonction appelée entre() qui nous permet de spécifier une plage de secondes à attendre avant d'exécuter la tâche suivante. Vous pouvez voir que nous avons attribué une plage de 5 à 10 secondes pour cela dans notre code.
Pour exécuter le code, assurez-vous que vous êtes toujours dans votre environnement virtuel. Si celui que vous avez créé est utilisé par le serveur servant l'API, ouvrez un nouveau terminal, changez votre répertoire pour votre Projet répertoire et activez l'environnement virtuel que vous avez créé. Vous pouvez trouver la commande pour activer un environnement virtuel ci-dessus. Maintenant, entrez la commande ci-dessous dans votre terminal.
$ locust -f locust_test.py
Vous devriez voir quelque chose comme ceci:
Par défaut, l'interface Web de locust se trouve à http://localhost/8089. Si vous visitez le site Web, vous devriez voir une interface comme celle-ci :
À partir de l'interface, nous pouvons spécifier le nombre d'utilisateurs, le taux d'apparition (utilisateurs créés par seconde) et l'hôte. Vous pouvez obtenir l'adresse de votre hôte en vérifiant le terminal sur lequel le serveur est exécuté. Dans notre cas, c'est au port 5000. Lorsque vous cliquez sur Commencez à essaimer, vous serez présenté avec l'interface ci-dessous.
Cela vous montre diverses mesures utiles telles que le nombre de demandes ayant échoué, le temps moyen pour une demande, le temps minimum pour une demande, les demandes par seconde, etc. Une fois que vous êtes satisfait de ce que vous voyez, vous pouvez cliquer sur le bouton d'arrêt.
Outre l' Statistique onglet, il y a un Charts onglet qui affiche plus d'information sous forme de graphique, comme l'image ci-dessous.
Il y a un nombre total de requêtes par seconde graphique, graphique des temps de réponse, ainsi que graphique du nombre d'utilisateurs, le tout tracé en fonction du temps. À l'aide des graphiques, vous pouvez déterminer le nombre d'utilisateurs acceptables pour un temps de réponse fixe, ou vous pouvez observer vos graphiques pour un temps de réponse constant malgré un nombre croissant d'utilisateurs, et d'autres informations similaires. Si vous souhaitez partager ces stats avec quelqu'un d'autre, vous pouvez télécharger un rapport à partir du Télécharger les données languette.
De conclure...
Le test de charge de votre API est une activité cruciale dans votre processus de développement, alors assurez-vous qu'il est intégré dans votre cycle de conception. Au fait, vous pouvez également effectuer d'autres types de tests de charge en faisant varier les valeurs du nombre d'utilisateurs et du taux d'apparition.
Si vous voulez faire un test de pointe, spécifiez une grande valeur (disons 2000) pour le nombre d'utilisateurs, puis une valeur tout aussi grande pour votre taux d'apparition (500 par exemple). Cela signifie qu'en 4 secondes, vous auriez tous les 2000 utilisateurs créés et accédant à vos terminaux. Un test de stress sera similaire, mais avec une valeur beaucoup plus faible pour le taux d'apparition. Pour découvrir tout ce que vous pouvez faire, consultez le Locust Documentation.
