Dans l'article d'introduction Locust, j'ai pu effectuer le test de charge pour le moment, mais cet article s'adresse à ceux qui veulent en savoir plus.
Cet article est http://docs.locust.io/en/latest/ Ceci est un résumé des informations répertoriées dans. L'exemple de code provient également du même site.
L'intervalle d'exécution pour chaque tâche est une valeur aléatoire entre min_wait et max_wait.
Les vrais utilisateurs n'exécutent pas l'API tout le temps. S'il s'agit d'un site de blog, il faudra du temps pour voir le texte, et même s'il s'agit d'une application de jeu, il y aura un intervalle entre les API et l'exécution de l'API en fonction du contenu. Si vous pouvez prédire le comportement de l'utilisateur dans une certaine mesure, la définition de min_wait et max_wait sur des valeurs appropriées entraînera une charge plus proche du fonctionnement réel.
La valeur par défaut est min_wait = 500, max_wait = 1500. (L'unité est la milliseconde)
from locust import Locust, TaskSet, task
class MyTaskSet(TaskSet):
@task
def my_task(self):
print "executing my_task"
class MyLocust(Locust):
task_set = MyTaskSet
min_wait = 5000
max_wait = 15000
Remplacer lors de la définition de min_wait et max_wait. Au fait
self.wait()
Utilise min_wait et max_wait pour une pondération temporelle aléatoire. Je ne peux pas le diviser en fonctions de tâche, mais je ne veux pas qu'il soit exécuté en continu sans temps d'attente Je pense qu'il peut être utilisé pour les tests d'enregistrement des utilisateurs, etc.
Il est peu probable que toutes les pages de sites Web et d'applications Web soient vues et visitées de la même manière. La page du haut est la plus importante et les conditions d'utilisation, etc. ne seront pas consultées très souvent.
À cette fin, les tâches peuvent être pondérées pour l'exécution.
class WebUserLocust(Locust):
weight = 3
....
class MobileUserLocust(Locust):
weight = 1
....
Avec la configuration ci-dessus, WebUserLocust s'exécute 3 fois plus souvent que MobileUserLocust.
Si la classe Locust est un troupeau de criquets, la classe TaskSet est le cerveau du criquet. Est-ce comme si la classe Locust détermine le comportement général et que la classe TaskSet détermine comment chacun fonctionne? (Je ne peux pas bien le transmettre car ma capacité de traduction en japonais est faible ...)
Vous pouvez déclarer explicitement qu'il s'agit d'une fonction de tâche en ajoutant un décorateur de tâche à la fonction membre dans la classe TaskSet.
from locust import Locust, TaskSet, task
class MyTaskSet(TaskSet):
@task
def my_task(self):
print "Locust instance (%r) executing my_task" % (self.locust)
class MyLocust(Locust):
task_set = MyTaskSet
Au contraire, il semble qu'il sera utilisé tel que l'implémentation d'une fonction de traitement commune dans la classe sans y attacher un décorateur de tâches.
De plus, ce décorateur de tâches peut définir la pondération mentionnée ci-dessus par un argument.
from locust import Locust, TaskSet, task
class MyTaskSet(TaskSet):
min_wait = 5000
max_wait = 15000
@task(3)
def task1(self):
pass
@task(6)
def task2(self):
pass
class MyLocust(Locust):
task_set = MyTaskSet
La différence par rapport à la pondération dans la classe Locust est de savoir si elle est par module ou par fonction. (En termes de site Web, unité de page ou unité d'action dans la page)
Les sites Web et les applications Web ont souvent des pages hiérarchisées. En imbriquant l'ensemble de tâches en conséquence, il est plus adapté au comportement réel de l'utilisateur. Vous pouvez écrire un scénario. De plus, en divisant l'ensemble de tâches comme un module, diverses combinaisons peuvent être faites. Vous pouvez implémenter le scénario avec un code minimal.
class ForumPage(TaskSet):
@task(20)
def read_thread(self):
pass
@task(1)
def new_thread(self):
pass
@task(5)
def stop(self):
self.interrupt()
class UserBehaviour(TaskSet):
tasks = {ForumPage:10}
@task
def index(self):
pass
À mesure que l'échelle de l'application augmente, l'API augmente également, alors pensez à la maintenabilité. C'est une bonne idée de diviser votre ensemble de tâches autant que possible.
interrupt( ) Dans le code ci-dessus, la fonction stop () exécute self.interruput (). interruput () quitte l'ensemble de tâches actuel et réaffecte les tâches à l'ensemble de tâches supérieur C'est une fonction à faire. Si vous n'appelez pas cela, l'instance Locust effectuera à l'infini les tâches du ForumPage. Continuer à courir. Étant donné que l'utilisateur réel doit déplacer plusieurs pages, utilisez la fonction d'interruption selon le cas. C'est important de le faire.
Bien que ce soit un contenu assez important http://docs.locust.io/en/latest/ Si vous n'avez pas lu, il est difficile de trouver l'idée d'exécuter explicitement interruption () ...
Puisque le décorateur peut également être appliqué à la classe, il peut être écrit comme suit.
class MyTaskSet(TaskSet):
@task
class SubTaskSet(TaskSet):
@task
def my_task(self):
pass
Je veux juste trouver un bon moyen de l'écrire car l'imbriquer aveuglément ne fait que le compliquer.
on_start on_start () est appelé au démarrage de l'ensemble de tâches. Les en-têtes HTTP requis pour l'API doivent être définis ici.
Je pense que HTTP Locust etc. est présenté dans l'article d'introduction ci-dessous, donc je les omettrai. Il y a beaucoup d'autres informations utiles http://docs.locust.io/en/latest/ Je vous recommande de le lire. (Bien qu'en anglais uniquement) De plus, le code source de Locust est sur github, il est donc intéressant de jeter un œil. https://github.com/locustio