Im Einführungsartikel von Locust konnte ich den Belastungstest vorerst durchführen, aber dieser Artikel richtet sich an diejenigen, die mehr wissen möchten.
Dieser Artikel ist http://docs.locust.io/en/latest/ Dies ist eine Zusammenfassung der in aufgeführten Informationen. Der Beispielcode stammt ebenfalls von derselben Site.
Das Ausführungsintervall für jede Aufgabe ist ein zufälliger Wert zwischen min_wait und max_wait.
Echte Benutzer führen die API nicht immer aus. Wenn es sich um eine Blog-Site handelt, dauert es einige Zeit, bis der Text angezeigt wird. Selbst wenn es sich um eine Spieleanwendung handelt, gibt es je nach Inhalt ein Intervall zwischen APIs und API-Ausführung. Wenn Sie das Benutzerverhalten bis zu einem gewissen Grad vorhersagen können, führt das Setzen von min_wait und max_wait auf geeignete Werte zu einer Last, die näher am tatsächlichen Betrieb liegt.
Der Standardwert ist min_wait = 500, max_wait = 1500. (Einheit ist Millisekunde)
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
Überschreiben beim Setzen von min_wait und max_wait. Apropos
self.wait()
Verwendet min_wait und max_wait für die zufällige Zeitgewichtung. Ich kann es nicht in Aufgabenfunktionen unterteilen, aber ich möchte nicht, dass es ohne Wartezeit kontinuierlich ausgeführt wird Ich denke, es kann für Benutzerregistrierungstests usw. verwendet werden.
Es ist unwahrscheinlich, dass alle Seiten von Websites und Web-Apps gleichermaßen angezeigt und besucht werden. Die oberste Seite ist die meiste, und die Nutzungsbedingungen usw. werden nicht sehr oft angezeigt.
Zu diesem Zweck können Aufgaben für die Ausführung gewichtet werden.
class WebUserLocust(Locust):
weight = 3
....
class MobileUserLocust(Locust):
weight = 1
....
Mit der obigen Konfiguration wird WebUserLocust dreimal häufiger ausgeführt als MobileUserLocust.
Wenn die Locust-Klasse eine Herde von Heuschrecken ist, ist die TaskSet-Klasse das Locust-Gehirn. Ist es so, als ob die Locust-Klasse das Gesamtverhalten bestimmt und die TaskSet-Klasse bestimmt, wie jede funktioniert? (Ich kann es nicht gut vermitteln, weil meine japanischen Übersetzungsfähigkeiten gering sind ...)
Sie können explizit deklarieren, dass es sich um eine Aufgabenfunktion handelt, indem Sie der Elementfunktion in der TaskSet-Klasse einen Aufgabendekorator hinzufügen.
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
Im Gegenteil, es scheint, dass es verwendet wird, um beispielsweise eine gemeinsame Verarbeitungsfunktion in der Klasse zu implementieren, ohne einen Aufgabendekorateur anzuhängen.
Zusätzlich kann dieser Aufgabendekorateur die oben erwähnte Gewichtung durch ein Argument festlegen.
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
Der Unterschied zur Gewichtung in der Locust-Klasse besteht darin, ob es sich um ein Modul oder eine Funktion handelt. (In Bezug auf Website, Seiteneinheit oder Aktionseinheit innerhalb der Seite)
Websites und Web-Apps haben häufig hierarchisierte Seiten. Durch die entsprechende Verschachtelung des Aufgabensatzes wird dieser besser auf das tatsächliche Benutzerverhalten zugeschnitten. Sie können ein Szenario schreiben. Durch Teilen des Aufgabensatzes wie ein Modul können verschiedene Kombinationen vorgenommen werden. Sie können das Szenario mit minimalem Code implementieren.
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
Wenn der Umfang der Anwendung zunimmt, nimmt auch die API zu. Berücksichtigen Sie daher die Wartbarkeit. Es ist eine gute Idee, Ihre Aufgaben so weit wie möglich aufzuteilen.
interrupt( ) Im obigen Code führt die Funktion stop () self.interruput () aus. interruput () beendet den aktuellen Aufgabensatz und weist Aufgaben dem höheren Aufgabensatz zu Es ist eine Funktion zu machen. Wenn Sie dies nicht aufrufen, erledigt die Locust-Instanz die Aufgaben auf der ForumPage endlos. Laufen Sie weiter. Da der tatsächliche Benutzer verschiedene Seiten verschieben sollte, verwenden Sie die entsprechende Interrupt-Funktion. Es ist wichtig, es zu tun.
Obwohl es ziemlich wichtiger Inhalt ist http://docs.locust.io/en/latest/ Wenn Sie nicht gelesen haben, ist es schwierig, auf die Idee zu kommen, Interrupt () explizit auszuführen ...
Da der Dekorateur auch auf die Klasse angewendet werden kann, kann er wie folgt geschrieben werden.
class MyTaskSet(TaskSet):
@task
class SubTaskSet(TaskSet):
@task
def my_task(self):
pass
Ich möchte nur einen guten Weg finden, es zu schreiben, weil das blinde Verschachteln es nur kompliziert macht.
on_start on_start () wird aufgerufen, wenn der Task-Set gestartet wird. Hier sollten die für die API erforderlichen HTTP-Header festgelegt werden.
Ich denke, dass HTTP Locust usw. im folgenden Einführungsartikel vorgestellt werden, daher werde ich sie weglassen. Es gibt viele andere nützliche Informationen http://docs.locust.io/en/latest/ Ich empfehle Ihnen, es zu lesen. (Obwohl nur in Englisch) Außerdem befindet sich der Quellcode für Locust auf Github, daher ist es interessant, einen Blick darauf zu werfen. https://github.com/locustio