打造完美的locust压测系统——使用docker部署locust+prometheus+grafana实现locust数据（半）持久化_locust docker

---

==这个博客可能对最新版的支持的不太好，如果想用的话需要使用旧版的locust，具体版本号自行查一下资料，在公司内部已经用influxdb重新二开了locust，做成了平台，后续有机会的话分享出来==

---

locust的缺点

• python性能太差 ：换语言，这篇不讲，后面的文章讲。
• 界面太简单,数据无法持久化，浏览器挂掉了好几小时的压测结果全丢了： prometheus+grafana数据持久化

---

1.环境准备

既然标题写的是用docker部署，那么本文就需要裸ubuntu系统一个，只安装docker即可。
ubuntu安装docker命令：

sudo apt install docker.io
1

之前看过一些教程，使用了docker将所有的端口都暴露在了外部，实际生产环境中的压测，申请端口手续比较复杂，所以本文按照生产环境来进行部署，可能会比较繁琐。但是安全性和稳定性会比较强。
本文需要多个docker容器，容器之间交互，需要建立一个docker bridge网络

sudo docker network create locust_net
1

创建完网络之后，可以使用已下命令查看一下

sudo docker network ls
1

环境部署完成

2.locust的master节点的准备（*重要）

locust使用分布式比较容易实现该需求。
master节点只需要负责收集数据即可
myzhan大佬已经在boomer代码中开源了一个非常好用的集成了prometheus的locust的master节点代码了，所以我就拿来主义，直接用https://github.com/myzhan/boomer/blob/master/prometheus_exporter.py就好了

# coding: utf8

import six
from itertools import chain

from flask import request, Response
from locust import stats as locust_stats, runners as locust_runners
from locust import User, task, events
from prometheus_client import Metric, REGISTRY, exposition

# This locustfile adds an external web endpoint to the locust master, and makes it serve as a prometheus exporter.
# Runs it as a normal locustfile, then points prometheus to it.
# locust -f prometheus_exporter.py --master

# Lots of code taken from [mbolek's locust_exporter](https://github.com/mbolek/locust_exporter), thx mbolek!


class LocustCollector(object):
    registry = REGISTRY

    def __init__(self, environment, runner):
        self.environment = environment
        self.runner = runner

    def collect(self):
        # collect metrics only when locust runner is spawning or running.
        runner = self.runner

        if runner and runner.state in (locust_runners.STATE_SPAWNING, locust_runners.STATE_RUNNING):
            stats = []
            for s in chain(locust_stats.sort_stats(runner.stats.entries), [runner.stats.total]):
                stats.append({
                    "method": s.method,
                    "name": s.name,
                    "num_requests": s.num_requests,
                    "num_failures": s.num_failures,
                    "avg_response_time": s.avg_response_time,
                    "min_response_time": s.min_response_time or 0,
                    "max_response_time": s.max_response_time,
                    "current_rps": s.current_rps,
                    "median_response_time": s.median_response_time,
                    "ninetieth_response_time": s.get_response_time_percentile(0.9),
                    # only total stats can use current_response_time, so sad.
                    #"current_response_time_percentile_95": s.get_current_response_time_percentile(0.95),
                    "avg_content_length": s.avg_content_length,
                    "current_fail_per_sec": s.current_fail_per_sec
                })

            # perhaps StatsError.parse_error in e.to_dict only works in python slave, take notices!
            errors = [e.to_dict() for e in six.itervalues(runner.stats.errors)]

            metric = Metric('locust_user_count', 'Swarmed users', 'gauge')
            metric.add_sample('locust_user_count', value=runner.user_count, labels={})
            yield metric
            
            metric = Metric('locust_errors', 'Locust requests errors', 'gauge')
            for err in errors:
                metric.add_sample('locust_errors', value=err['occurrences'],
                                  labels={'path': err['name'], 'method': err['method'],
                                          'error': err['error']})
            yield metric

            is_distributed = isinstance(runner, locust_runners.MasterRunner)
            if is_distributed:
                metric = Metric('locust_slave_count', 'Locust number of slaves', 'gauge')
                metric.add_sample('locust_slave_count', value=len(runner.clients.values()), labels={})
                yield metric

            metric = Metric('locust_fail_ratio', 'Locust failure ratio', 'gauge')
            metric.add_sample('locust_fail_ratio', value=runner.stats.total.fail_ratio, labels={})
            yield metric

            metric = Metric('locust_state', 'State of the locust swarm', 'gauge')
            metric.add_sample('locust_state', value=1, labels={'state': runner.state})
            yield metric

            stats_metrics = ['avg_content_length', 'avg_response_time', 'current_rps', 'current_fail_per_sec',
                             'max_response_time', 'ninetieth_response_time', 'median_response_time', 'min_response_time',
                             'num_failures', 'num_requests']

            for mtr in stats_metrics:
                mtype = 'gauge'
                if mtr in ['num_requests', 'num_failures']:
                    mtype = 'counter'
                metric = Metric('locust_stats_' + mtr, 'Locust stats ' + mtr, mtype)
                for stat in stats:
                    # Aggregated stat's method label is None, so name it as Aggregated
                    # locust has changed name Total to Aggregated since 0.12.1
                    if 'Aggregated' != stat['name']:
                        metric.add_sample('locust_stats_' + mtr, value=stat[mtr],
                                          labels={'path': stat['name'], 'method': stat['method']})
                    else:
                        metric.add_sample('locust_stats_' + mtr, value=stat[mtr],
                                          labels={'path': stat['name'], 'method': 'Aggregated'})
                yield metric


@events.init.add_listener
def locust_init(environment, runner, **kwargs):
    print("locust init event received")
    if environment.web_ui and runner:
        @environment.web_ui.app.route("/export/prometheus")
        def prometheus_exporter():
            registry = REGISTRY
            encoder, content_type = exposition.choose_encoder(request.headers.get('Accept'))
            if 'name[]' in request.args:
                registry = REGISTRY.restricted_registry(request.args.get('name[]'))
            body = encoder(registry)
            return Response(body, content_type=content_type)
        REGISTRY.register(LocustCollector(environment, runner))


class Dummy(User):
    @task(20)
    def hello(self):
        pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

ok,有了master节点的代码了，现在我们先用去将master节点启动起来

第一步： 将代码放进服务器

我比较懒，直接用vim把代码粘过去了

第二步： 启动locust的master节点容器

使用以下命令启动（如果worker节点也用python写，-p 5557:5557可以不要）

sudo docker run -p 8089:8089 -p 5557:5557 -v $PWD/prometheus_exporter.py:/mnt/locust/locustfile.py --name=locust_master --network=locust_net --network-alias=locust_master locustio/locust -f /mnt/locust/locustfile.py --master
1

如果没有locust镜像的话，会自动下载，懒，能省一步pull是非常舒服的。。。
等待下载完之后，容器启动成功。不出所料的会出现以下报错：

容器的环境里没有这个prometheus_client库
下面展示一下懒人的非常规操作，不重新编译locust镜像是如何启动该容器的(emmmmmm…坏习惯，不要学！！！)

①使用vim编辑本地的prometheus_exporter.py文件

sudo vim prometheus_exporter.py
1

在py文件第二行加入以下代码：

import os
os.system("tail -f /dev/null")
1
2

:wq保存

②重启docker并进入容器

以下命令重启docker：

 sudo docker restart locust_master
1

以下命令查看以下容器的运行状态：

sudo docker ps 
1

可以看到容器已经在运行了没有闪退

使用以下命令进入容器内部：

sudo docker exec -it locust_master /bin/bash
1

成功进入容器内部：
在容器内部使用命令

pip install prometheus_client
1

安装缺失的库，安装完毕后，使用exit命令退出容器，回到服务器

③还原prometheus_exporter.py文件

再次使用vim编辑prometheus_exporter.py文件
删除加的两行
保存文件

④重启docker容器

使用以下命令重启docker容器

sudo docker restart locust_master
1

master节点启动完成，在浏览器输入http://服务器ip:8089可以访问到locust的web页面
在使用http://服务器ip:8089/export/prometheus
如果出现如下图所示的prometheus数据，表示启动正确

3.启动locust的worker节点容器

worker节点应该是压测的业务代码
一般我都是用go来写，但是为了展示，先随手写个demo

from locust import HttpUser, task


class LocustWorker(HttpUser):

    @task(1)
    def get_root(self):
        self.client.get("/")
1
2
3
4
5
6
7
8

将代码放入服务器中命名为locust_worker.py
执行以下命令，启动worker节点

sudo docker run -d -v $PWD/locust_worker.py:/mnt/locust/locustfile.py --name=locust_worker --network=locust_net locustio/locust -f /mnt/locust/locustfile.py --worker --master-host locust_master --master-port 5557
1

// 使用该命令查看容器的运行状态
sudo docker ps 
1
2

此时，master和worker节点都已经起来了，进入web管理页面，看到worker数变为了1

4.启动prometheus

第一步： 创建prometheus.yml配置文件

使用vim创建prometheus.yml并输入以下内容
只需要编辑locust节点的targets处的内容即可
注意注意注意
前面的地址，就写master节点启动命令中的network-alias后面的参数locust_master就行
后面的端口号写死8089（容器内部端口），不要写映射出来的端口
这里是容器之间的交互，不用管端口映射，正式的生产环境中，master节点是不做端口映射的，这里是为了容易理解，做了端口的映射

global:
  scrape_interval:     10s
  evaluation_interval: 10s
 
scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ['localhost:9090']
        labels:
          instance: prometheus
          
  - job_name: locust
    
    metrics_path: '/export/prometheus'
    static_configs:
      - targets: ['locust_master:8089']  # 这里是locust的master节点启动命令中的network-alias后面的参数 + 内部端口，不要写外部映射的端口号
        labels:
          instance: locust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

第二步： 下载并创建容器

使用以下命令创建并下载prometheus

sudo docker run -d -p 9090:9090 -v $PWD/prometheus.yml:/etc/prometheus/prometheus.yml --name=prometheus --network=locust_net --network-alias=prometheus prom/prometheus
1

第三步： 验证

使用以下命令查看docker容器是否启动成功

sudo docker ps 
1

此时应该有这三个容器在
浏览器输入http://服务器ip:9090/targets

locust节点正常

5.启动grafana

第一步： 使用以下命令下载并运行grafana

sudo docker run -d -p 3000:3000 --name grafana --network=locust_net grafana/grafana
1

第二步： 浏览器打开 服务器ip:3000页面

①登录grafana并进入Configuration

首次登录用户名/密码admin，进去了之后需要改密码，登录后如图进入Configuration

②添加数据源

点击Add data source

③选择数据源

选择prometheus

④配置数据源url

url处输入建立prometheus容器时的–network-alias的别名:9090，端口输入内部端口，不要输入映射的端口，生成环境启动prometheus是没有-p的

⑤导入模板

保存成功后，导入模板

⑥载入仪表盘

输入id12081点击load

⑦仪表盘填入数据

选择一下prometheus然后import

大功告成

使用locust打一下压力，看看这个平性能监控平台吧

启动！

切换到grafana看看

齐活