locust多进程实现分布式压测遇到的问题-数字星空

多进程分布式的实现:

locust分布式时，需借助命令locust 一个一个启动worker，在使用中有点繁琐，
下面借助于多进程，按既定worker数量，一键启动；


from locust import FastHttpUser, task, User, events, HttpUser



#class WebsiteUser(FastHttpUser): 错误的使用!!!
class WebsiteUser(HttpUser):  #正确的使用
    tasks = [TaskSet]
    host = "https://www.baidu.com"
    wait_time = between(0, 0)

def processFun(cmd):
    os.system(cmd)


def start_by_process(tst_locust_file, slave_num, master_host='127.0.0.1', locust_web_port=8090, no_web=False,
                     user_num=10, user_rate=1, result_log='result.log', run_log='run.log'):
    p_lst = []
    if no_web:
        slave_cmd = f"locust -f {tst_locust_file}  --worker --master-host={master_host}"
        master_cmd = f"locust -f {tst_locust_file} --headless -u {user_num} -r {user_rate} --master"
    else:
        slave_cmd = f"locust -f {tst_locust_file}  --worker --master-host={master_host}"
        master_cmd = f"locust -f {tst_locust_file} --web-host {master_host} --web-port {locust_web_port} --master"
    master_cmd += f' --logfile {result_log} --loglevel INFO 1>{run_log} 2>&1'
    # 启动master
    process_master = multiprocessing.Process(target=processFun, args=(master_cmd,))
    process_master.start()
    p_lst.append(process_master)
    # 启动 worker
    for index_num in range(slave_num):
        process = multiprocessing.Process(target=processFun, args=(slave_cmd,))
        process.start()
        p_lst.append(process)

    # 阻塞等待
    for process in p_lst:
        process.join()
        
        
if __name__ == "__main__":
    tst_locust_path = 'wms/wms_test'
    slave_num = 3  # 计划所启动worker数量, 不可超过运行机的CPU数量
    master_host = '127.0.0.1'
    master_host = '192.168.1.102'
    locust_web_port = 8099  # locust web页面挂载端口
    no_web = False
    tst_locust_file = os.path.basename(__file__)  # 本脚本名
    os.chdir(os.getcwd().replace(tst_locust_path.replace('/', os.sep), ''))
    tst_locust_file = f'{tst_locust_path}/{tst_locust_file}'
    start_by_process(tst_locust_file, slave_num, master_host, locust_web_port, no_web=no_web)

问题:

在上述代码中,我使用了class WebsiteUser(FastHttpUser): 错误的使用!!!这个方式,来使用locust的User类,当执行压测时,work会因CPU过高而miss掉,导致压测终止.当切换成class WebsiteUser(HttpUser): #正确的使用时,可以正常执行locust的压测.

HttpUser和FastHttpUser介绍:

在Locust中，HttpUser 和 FastHttpUser 是两种不同的用户行为模拟类，它们分别用于模拟不同的HTTP客户端行为。以下是这两种类的主要区别：

HttpUser

HttpUser 是Locust的基本HTTP用户模拟类，它使用requests库来发送HTTP请求。
HttpUser 支持多线程或多进程模式，具体取决于你的配置。
它提供了丰富的功能和灵活性，包括支持重试、会话管理、以及使用requests库的所有特性。
由于requests库本身是同步的，因此在高并发场景下，HttpUser可能会导致较高的CPU使用率，尤其是当请求之间没有足够的等待时间时。
HttpUser适用于大多数HTTP负载测试场景，特别是那些对复杂性和灵活性有较高要求的测试。

FastHttpUser

FastHttpUser 是一个较新的类，它使用httpx库来发送HTTP请求，这是一个异步的HTTP客户端库。
FastHttpUser 提供了更高的性能和更低的CPU使用率，因为它使用了异步I/O，可以在等待网络响应时执行其他任务。
它特别适合于高并发的场景，可以显著减少CPU使用率，尤其是在大量并发用户的情况下。
FastHttpUser 相对于HttpUser来说，可能不支持requests库的所有高级特性，但在大多数情况下，基本的功能如GET、POST请求等都是支持的。
如果你的目标是进行大规模并发测试，同时保持较低的CPU使用率，FastHttpUser是一个很好的选择。

总结

如果你的测试场景需要高度定制化的请求设置或者你已经在使用requests库的高级功能，那么HttpUser可能更适合你。
如果你希望在高并发场景下减少CPU使用率，并且能够接受一定的功能限制，那么FastHttpUser是一个更好的选择。

示例

以下是使用HttpUser和FastHttpUser的简单示例：

HttpUser 示例

from locust import HttpUser, task, between

class MyHttpUser(HttpUser):
    wait_time = between(1, 5)

    @task
    def my_task(self):
        self.client.get("/some_endpoint")

FastHttpUser 示例

from locust import FastHttpUser, task, between

class MyFastHttpUser(FastHttpUser):
    wait_time = between(1, 5)

    @task
    def my_task(self):
        self.client.get("/some_endpoint")

请注意，在使用FastHttpUser时，你需要确保你的Locust版本支持该类。如果不确定，可以检查你的Locust版本或者查阅官方文档。