Locust présente l'installation et l'utilisation de base

1. Introduction au criquet

Locust (locust) est un outil de test de performance open source, l'idée principale est de simuler un groupe d'utilisateurs accédant à votre système

2. Caractéristiques

(1) Définir le comportement de l'utilisateur dans le code

Pas besoin d'installer de logiciel encombrant, juste du code Python simple

(2) Distribué et évolutif

Locust prend en charge l'exécution de tests de charge sur plusieurs machines, il peut donc être utilisé pour simuler les demandes de millions d'utilisateurs

(3) Éprouvé et testé au combat

Le criquet est utilisé dans de nombreux projets réels

(4) Locust a une interface utilisateur HTML + JS soignée qui affiche les détails de test pertinents en temps réel

L'interface utilisateur étant basée sur le Web, elle est multiplateforme et facilement extensible

2. Installation de criquets

Commande d'installation :

pip install locust

Vérification de l'installation réussie :

locust --version    # 查看安装的版本

locust -h           # 查看使用帮助

Remarque : La version de python est de préférence supérieure à 3.0

3. Comment utiliser Locust

1. Étapes principales

Définir la tâche (demande d'interface) : fonction ordinaire, doit avoir un paramètre formel, doit utiliser @task pour modifier la fonction
Définir l'ensemble de tâches (comportement de l'utilisateur) : une classe doit hériter de TaskSet et les tâches définies sont à l'intérieur de la classe
Définir la classe d'utilisateurs (utilisateur) : une classe qui doit hériter de HttpUser, configurer l'adresse de l'hôte, remplacer les tâches, le format est une liste ou un dictionnaire et la valeur est le nom de l'ensemble de tâches défini
Démarrez le service et configurez l'exécution : locust -f nom du fichier

exemple:

from locust import HttpUser, TaskSet, task


# 定义任务集
class TaskTest(TaskSet):
    # 定义任务
    @task
    def say(params):
        print("正在说话")

    @task
    def sing(params):
        print("正在唱歌")


# 定义用户类
class Test(HttpUser):
    tasks = [TaskTest]
    host = "http://localhost"

Exécutez l'étape locust :

(1) Ouvrez le terminal pycharm et entrez le nom du fichier locust -f à exécuter

(2) Ouvrez le navigateur et entrez localhost:8089 pour exécuter l'interface de lutte antiacridienne

(3) Entrez les données et cliquez sur commencer à essaimer pour exécuter le code

Nombre d'utilisateurs (pic simultanéité) : le nombre d'utilisateurs simultanés correspond au nombre d'utilisateurs
Taux d'apparition (utilisateurs démarrés/seconde) : le nombre d'utilisateurs chargés par seconde
Hôte (par exemple http://www.exemple.com) : adresse de l'hôte, s'il y en a une dans le code, elle peut être exécutée par défaut

2. Méthodes couramment utilisées pour les ensembles de tâches

(1) on_start : pré-méthode (pré-tâche), appelée une fois avant toutes les tâches

(2) on_stop : méthode post (post task), appelée une fois lorsque l'ensemble de tâches s'arrête

(3) @task(weight) : modifie la fonction et définit la fonction comme une tâche. poids représente le poids, plus le poids est élevé, plus il y a de temps d'exécution, la valeur par défaut est 1

from locust import TaskSet, task


# 定义任务集
class TaskTest(TaskSet):
    # 定义任务
    @task(10)
    def say(params):
        print("正在说话")

    @task(5)
    def sing(params):
        print("正在唱歌")

    def on_start(self):
        self.say()

    def on_stop(self):
        self.sing()

3. Attributs communs des classes d'utilisateurs

(1) min_wait : limite inférieure du temps d'attente entre les tâches d'exécution de l'utilisateur, unité : millisecondes, valeur par défaut : 1000

(2) max_wait : la limite supérieure du temps d'attente entre les tâches d'exécution de l'utilisateur, unité : millisecondes, valeur par défaut : 1000

(3) host : URL de l'application testée, par exemple : http://localhost

(4) poids : la probabilité que l'utilisateur soit sélectionné, plus le poids est élevé, plus la chance d'être sélectionné est grande, la valeur par défaut : 10

from locust import HttpUser

# 定义用户类
class Test(HttpUser):
    tasks = [TaskTest]
    host = "http://localhost"
    min_wait = 1000
    max_wait = 2000
    weight = 10

4. Application distribuée Locust - implémentation de l'interface Web

(1) Hôte (ordinateur de contrôle)

locust -f 目录\执行文件名 --master

(2) Hôte esclave (machine exécutive)

locust -f 目录\执行文件名 --worker --master-host=主机ip地址 --master-port=主机端口

Points clés sur lesquels les hôtes esclaves doivent s'appuyer :

Doit avoir un environnement python et locust

Doit avoir une copie du script hôte

Si l'hôte esclave se trouve sur la même machine que le maître, --master-host et --master-port peuvent être omis

5. Application distribuée Locust - implémentation du mode no-graph (interface non-web)

locust -f 目录\执行文件名 --master --headless -u 200 -r 20 --expect-workers 2 --run-time 20s --csv ./result.csv


--headless:不使用web界面
-u:虚拟用户数
-r:每秒生成的用户数
--expect-workers:执行机数量
--run-time:运行时间（h:小时,m:分钟,s:秒）
--csv:保存执行结果

4. Application de Locust dans les tests d'interface

Mise en œuvre simple du cas :

from locust import HttpUser, TaskSet, task

headers = {"content-type": "application/json;charset=UTF-8"}
data = {"username": "hogwarts", "passwords": "test12345", "code": ""}
params = {"page": 1, "limit": 20, "goodsSn": "11111", "name": ""}


# 定义任务集
class TaskTest(TaskSet):

    # 定义任务
    # 登录方法
    @task(1)
    def login(r):
        response = r.client.post(url="/admin/auth/login", json=data, headers=headers)
        headers["x-litemall-admin-token"] = response.json()["data"]["token"]
        print(response.json())

    # 获取商品列表方法
    @task(1)
    def list(r):
        response = r.client.get(url="/admin/goods/list", params=params, headers=headers)
        print(response.json())

    def on_start(self):
        self.login()

    def on_stop(self):
        self.list()

# 定义用户类
class Test(HttpUser):
    tasks = [TaskTest]
    host = "https://litemall.hogwarts.ceshiren.com"
    min_wait = 1000
    max_wait = 3000

résultat de l'opération :