高性能 Http 压测工具 wrk 的使用,wrk2入门-http性能压测工具总结

admin

wrk 是一种高效的 HTTP 基准测试工具，能够在单个多核 CPU 上运行时产生大量负载。它将多线程设计与 epoll 和 kqueue 等可伸缩事件通知系统相结合。因此，使用 wrk 使用较少的线程即可以压测出非常可观的请求数据。

并且我们可以通过一个可选的 LuaJIT(Lua) 脚本来提供更多的请求参数的定制，参数加密、鉴权请求等。

基础使用
使用类 Unix 环境，在 CentOs 或 MacOs 上进行测试

wrk 开源 GitHub 地址: https://github.com/wg/wrk
通过 git clone 的形式下载 源码包，进入目录下，执行 make ，然后开始编译安装，等待一会即可完成。

wrk 使用参数说明
1 {: p+ C( ?& p) f9 `-c, --connections:  总的连接数（每个线程处理的连接数=总连接数/线程数）
) e! N0 N* j9 ~3 G. ?. r-d, --duration:        测试的持续时间，如2s(2second)，2m(2minute)，2h(hour)
) j/ L3 L9 X5 C% f+ @+ G-t, --threads:         需要执行的线程总数
' |: a/ `4 x1 ]0 m; |-s, --script:          执行Lua脚本，这里写lua脚本的路径和名称，后面会给出案例
-H, --header:      需要添加的头信息，注意header的语法，举例，-H “token: abcdef”，说明一下，token，冒号，空格，abcdefg（不要忘记空格，否则会报错的）。
--latency:     显示延迟统计信息
--timeout:     超时的时间
3 F# w. I$ s/ T例子
wrk -t12 -c400 -d30s http://127.0.0.1:8080/index.html
该请求意思为： 使用 wrk 使用12个线程，400个连接，请求 url 30s

压测结束后的结果:
Running 30s test @ http://127.0.0.1:8080/index.html
  12 threads and 400 connections
5 j5 _2 Z* X# j7 w  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   635.91us    0.89ms  12.92ms   93.69%
2 e( G. {" V# q/ O5 J7 S1 [    Req/Sec    56.20k     8.07k   62.00k    86.54%
4 x: M8 w, z! m% x% j* W  22464657 requests in 30.00s, 17.76GB read
Requests/sec: 748868.53
Transfer/sec:    606.33MB
返回结果说明：

Latency：响应时间Req/Sec：每个线程每秒钟的执行的连接数
Avg：平均
! J  b  k$ X& U0 U9 v8 R5 sMax：最大
Stdev：标准差+/- Stdev： 正负一个标准差占比
# P% _6 _( C5 n3 c1 hRequests/sec：每秒请求数（也就是QPS），这是一项压力测试的性能指标，通过这个参数可以看出吞吐量
6 j* V% y! P2 a6 z8 ?Latency Distribution，如果命名中添加了
latency就会出现相关信息
; {! f9 z8 |9 {, ?) A, o实战
使用 wrk 对鉴权的接口进行调用压测。由于是鉴权的接口，需要根据密钥和时间戳动态的生成 secret 然后对后端进行请求，才能通过验证。这里我们引入 lua 脚本
3 g8 D2 z( ~# j5 M: a由于 wrk 工具里面 自带 luaJit ，所以我们不用下载。但是需要 md5 的模块，所以需要使用 luarocks 来管理和下载 lua 模块和包。

安装Luarocks 包管理工具
* {4 n4 l$ m4 t& [. VLuaRocks 是 Lua 模块的包管理器。它允许您将 Lua 模块创建并安装为自包含包(称为 rocks )。您可以在 Unix 和 Windows 上下载和安装 LuaRocks。官网：https://luarocks.org/

通过 curl 下载
curl -o luarockt-3.0.3.tar.gz http://luarocks.github.io/luarocks/releases/luarocks-3.0.3.tar.gz
- d5 L: q8 W+ D/ a0 H- |8 c- C解压 luarockt-3.0.3.tar.gz后，进入目录下 指定到 wrk 里 LuaJit 的目录进行 configure

//这里指定你自己的 `wrk` 路径
./configure --with-lua=../wrk/obj
2 Y% k2 v3 X: M' c# y编译安装
) j. t, P- `; ?2 S- H! hmake install
: W6 m$ k$ A* K" c8 n! G2 T6 q3 ~通过 Luarocks 安装 md5 模块
: K( V0 r: s8 z5 N# W" X$ X9 |luarocks install md5

开始请求
5 A5 v+ [) M5 S我们需要像 url http://127.0.0.1:9000 网关进行 POST 请求，该网关会对请求进行鉴权和验证，并判断请求的实效性。所以我们需要在请求时动态改变请求参数，因此需要结合 Lua 脚本。

Lua 脚本 helloDemo.lua
md5=require("md5")
6 I' t+ h; C% w# C; C9 w- q5 W-- md5加密，拼接请求对象
function buildJson(json)
  local apiKey = "abcdefg1234567"
  local password = "qwerxxxx"
  local timestamp = os.time() .. "000"
  local secret = md5.sumhexa(apiKey .. timestamp ..  password)
  local body = json .. "×tamp=" .. timestamp .. "&secret=" .. secret
  
  return body
# u! B* Y' Q/ h3 R! R3 Q# j5 Uend

wrk.method = "POST"
0 Y# C4 r8 h" ]3 zwrk.body = buildJson("serviceName=com.github.dapeng.service.HelloService&version=1.0.0&methodName=sayHello¶meter={\"body\": {\"request\": {\"bizTag\": \"order\", \"step\": 100}}}")
& F) A6 {% Z( J3 p, kwrk.headers["Content-Type"] = "application/x-www-form-urlencoded"
) m3 w* d, b$ w4 W- w8 F& i6 g请求脚本

#!/usr/bin/env bash
time1=`date +%s`
echo "开始时间 `date +%Y%m%d%H%S`"
# wrk 安装目录 -s 后指定上面写好的lua脚本
~/ideaspace/dapeng/benchmark/wrk/wrk -t4 -c400 --timeout 5s -d 60s -s lua/$1.lua --latency 'http://127.0.0.1:9000/api/e1bfd762321e409cee4ac0b6e841963c'
time2=`date +%s`
0 _0 p1 y9 z3 Q9 N  q* GuseTime=$[time2 - time1]
' g  i2 O0 V4 H1 y/ ~- [7 lecho "结束时间 `date +%Y%m%d%H%S`"
) ~) S# L1 h5 I& i+ Q: [1 f/ Uecho "总共花费 $useTime s"
执行脚本

sh start-wrk.sh helloDemo
, j) u9 P: g. m$ j通过上面方式，我们就可以开始请求已鉴权的接口

总结
wrk 是一款高性能的 http 请求压测工具，它使用了 Epoll 模型，使所有请求都是异步非阻塞模式的，因此对系统资源能够应用到极致，可以压满 cpu。
+ l  [' ~# R9 K0 }5 O/ Y4 Lwrk 可以落站使用 Lua 脚本。该特性可以使我们通过 脚本动态的改变请求参数，对请求压测提供的多样性的选择和定制。

后续
1. 去除 CO
关于 wrk 测试延迟分布不准确的问题，涉及到 Coordinated Omission 的原因，可 Google
! z% h' B- C- o* |6 m在 src/wrk.c
将下面部分代码注释：
//  if(complete / cfg.connections > 0) {
5 `+ V5 o3 u# @9 X6 J  O% d//       int64_t interval = runtime_us / ( complete / cfg.connections);
# G  i& J6 t" T, w6 l9 a% ], b//       stats_correct(statistics,latency,interval);
关于 wrk 测试延迟分布不准确的问题，涉及到 Coordinated Omission 的原因，可 Google，也可以参考 wrk2

) u' o1 C" q( c1 o( o
[color=rgba(0, 0, 0, 0.75)]wrk入门总结

• 
  , d. J5 E" ^' _5 G1 U# x" E3 u
  • 
      r' a7 s) j( [& A* `2 [+ N* d
    • 一、功能介绍：
    • 二、安装过程：
    • 
      
      • 
        / {* |' t7 r$ t6 ~2 @# T' ]+ {
        • git地址：
        • make编译过程中问题解决：
        • 创建软链接到指定目录
        • 验证是否安装成功
          
        
        
    • 三、wrk 初步使用
    • 
      
      • 
        . m' U# b0 Q9 |
        • 基本用法:
        • 
          
          • 使用方法--readme
          • 参数设定经验
            : a6 r3 E7 a, ?0 z! Z9 Z
          
          " G+ U* i2 P/ k5 \& {( s5 _; [
        
        
    • 四 测试场景
    • 
      8 B4 W( {0 Q4 t! g
      • 测试HTTP协议网络的性能
      • 测试当前服务的最大QPS
      • 使用Lua脚本个性化wrk压测
        8 Q" s) M! L7 T; |
      
      
    
    : M0 @7 i2 }( R, l  w( D
  
  

" t" s" x/ b& ]' `% s一、功能介绍：

  wrk2是一个主要基于wrk的HTTP基准测试工具，wrk2经过修改后能够提供稳定的吞吐量负载以及更精确的延时统计，即通过设置参数，wrk2增加了–rate或-R参数设置吞吐量（每秒总请求数）及–u_latency参数显示延时统计。

二、安装过程：

wrk安装过程非常简单，下载源码后在项目目录下执行make命令即可。

• git地址：

  https://github.com/giltene/wrk2

  # git clone https://github.com/giltene/wrk2.git 下载源码# cd wrk2  安装目录# make
  

/ x/ b7 I: X# f4 e# ^5 m

• make编译过程中问题解决：

  1. -bash: make: command not found

  [root@XXX wrk2-master]# make-bash: make: command not found
  # Y" N2 I$ b( J  ~5 M

0 W( J$ ?- x/ Z. d( `

  系统无法使用make，make install，一般出现== -bash: make: command not found ==的提示，是因为安装系统的时候使用的是最小化安装，缺少make、vim等常用命令。
; D: k& T5 u3 ~  d  直接安装make即可解决问题：

[root@XXX wrk2-master]#yum -y install gcc automake autoconf libtool make
. F, Z: M* {9 W1 a  J
5 v( \$ z. a( i0 _3 m' Q. B8 ^, x

  安装g++:

[root@XXX wrk2-master]#yum install gcc gcc-c++

2. src/wrk.h:11:25: fatal error: openssl/ssl.h: No such file or directory
+ G% F7 O5 V: \8 O2 ]https://img-blog.csdnimg.cn/2020052220505566.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NjY2NzeTk5,size_16,color_FFFFFF,t_70
  问题在于：系统中缺少openssl库，安装即可

[root@XXX wrk2-master]# yum install openssl-devel  或者[root@XXX wrk2-master]# yum install libssl-dev

: F8 z4 m$ j6 m1 f

• 创建软链接到指定目录[root@XXX wrk2-master]# ln -s /export/ccc/wrk2-master/wrk /usr/local/bin
  

•   这一步必须进行设置，否则会出现报错，-bash: wrk: command not found

• 验证是否安装成功

    make完成后当前路径下会生成可执行文件wrk，表示可以使用wrk进行http压测了。 https://img-blog.csdnimg.cn/20200522205120190.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NjY2NzeTk5,size_16,color_FFFFFF,t_70

  
  8 {# a3 A3 z) Z5 H

三、wrk 初步使用

• 基本用法:

  Basic Usage: wrk <options> <url>

  Options:                                                -c, --connections <N>  Connections to keep open
  

     # HTTP连接数，如1k,1M,1G，    -d, --duration  <T>  Duration of test  
    # 测试持续时间，如 2s 2m 2h              -t, --threads <N>  Number of threads to use  
6 C2 d: g; B3 o: m( G- s6 E; Y( S( `    # 开启的线程数                                                           -s, --script   <S>  Load Lua script file
  # 进阶功能，使用 lua 脚本    -H, --header   <H>  Add header to request  
  # 添加请求头                    
# 打印详细延迟统计    -L  --latency    Print latency statistics       -U  --u_latency  Print uncorrceted latency statistics                     ==
# 设置请求超时时间，大于该时间的请求将被记录==          --timeout     <T>  Socket/request timeout         -B, --batch_latency    Measure latency of whole                              batches of pipelined ops                              (as opposed to each op)        -v, --version          Print version details          -R, --rate        <T>  work rate (throughput)   
. P4 n- R' T) u4 F4 ?#工作速率（吞吐量）即每个线程每秒钟完成的请求数                           in requests/sec (total)                               [Required Parameter]

; [/ r- L0 s' V" U; R/ s

• 使用方法–readme
  

[color=rgba(0, 0, 0, 0.75)][td]

使用方法	说明	吞吐量/每秒总请求数
wrk -t2 -c100 -d30s -R2000 http://127.0.0.1:8080/index.html	2个线程，100个连接，持续时间30s 每秒2000个请求	Requests/sec: 2000.12
wrk -t2 -c100 -d30s -R2000 --latency url	2个线程，100个连接，持续时间30s，每秒2000个请求	延迟标识，延迟百分比

4 _# F4 F# I2 a# `/ ^

• 参数设定经验https://img-blog.csdnimg.cn/20200601181254484.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NjY2NzeTk5,size_16,color_FFFFFF,t_70
  / u! n: I" d/ Y/ A! Y

四 测试场景

• 测试HTTP协议网络的性能[root@XXX scripts]# wrk -t2 -c1000 -d15 -R1000 --latency https://www.baidu.com/
  4 C+ t, p# k, F; E
  • 1
    
  Running 15s test @ https://www.baidu.com/    ------压测时间15s  2 threads and 1000 connections                         -------共2个测试线程，1000个连接  Thread calibration: mean lat.: 24.071ms, rate sampling interval: 41ms  Thread calibration: mean lat.: 24.373ms, rate sampling interval: 40ms  Thread Stats   Avg      Stdev     Max   +/- Stdev     -----平均值 标准差 最大值 正负一个标准差所占的比例    Latency    13.10ms    5.09ms 124.16ms   95.55%  -----延迟    Req/Sec   449.03    706.21     5.15k    94.26%        -----处理中的请求数  Latency Distribution (HdrHistogram - Recorded Latency)   -----延迟分布 50.000%   12.34ms 75.000%   13.68ms 90.000%   15.83ms                  -----90分位的延迟 99.000%   21.14ms                   ----99分位的延迟 99.900%  107.97ms 99.990%  124.22ms 99.999%  124.22ms              100.000%  124.22ms#[Mean    =       13.101, StdDeviation   =        5.093]#[Max     =      124.160, Total count    =         2201]#[Buckets =           27, SubBuckets     =         2048]----------------------------------------------------------  13795 requests in 15.00s, 206.31MB read   ----15s内共处理完成了13795个请求，读取了206.31MB数据Requests/sec:    919.62                                     -----平均每秒处理完成919.62个请求Transfer/sec:     13.75MB                                   -----平均每秒读取数据13.75MB

3 ]9 ]/ I/ {5 o9 b2 c& Z. Y

  压测简单说明：以上使用了2个线程1000个http连接，对baidu进行了15s的压测，并要求在压测结果中输出响应延迟信息。

• 测试当前服务的最大QPS

    进入安装目录，运行

  
  

[color=rgba(0, 0, 0, 0.75)][td]

通过-R参数获取吞吐量参数	每秒请求量的结果
./wrk2 -t10 -c50 -d30 -R3000 -H “Host:xxx.com” http://localhost/a/a.mp4 -L	Requests/sec: 3000.12
./wrk2 -t10 -c50 -d30 -R5000 -H “Host:xxx.com” http://localhost/a/a.mp4 -L	Requests/sec: 5000.12
./wrk2 -t10 -c50 -d30 -R10000 -H “Host:xxx.com” http://localhost/a/a.mp4 -L	Requests/sec: 9800.12
./wrk2 -t10 -c50 -d30 -R20000 -H “Host:xxx.com” http://localhost/a/a.mp4 -L	Requests/sec: 12500.12
./wrk2 -t10 -c50 -d30 -R30000 -H “Host:xxx.com” http://localhost/a/a.mp4 -L	Requests/sec: 13000.12

* e7 T/ n; g3 f" P  H

从以上的测试过程中可以看出，服务最大的每秒请求量为13000，可见性能压测的QPS为1.3万左右，考虑本机测试性能损耗问题，即QPS>1.2万。

• 使用Lua脚本个性化wrk压测
  ! d2 g" \& N( A! T

  以上是介绍wrk的安装及简单的使用，可以看出wrk的使用较简单方便，且测试结果清晰，一般情况下关注的指标主要是：90分位延迟、99分位延迟及Requests/sec。但是工作上往往需要较复杂的测试场景，这种简单的压测可能就不满足需求。比如，使用POST 方法跟服务器交互；每次请求使用不同的参数；为了更好的模拟服务场景，需要使用wrk的script lua脚本来定制压测过程，即满足定制化的需求。
  有关wrk高级使用方法，可以查看我的另一篇博客：wrk2的高级使用方法

admin

软件简介
wrk 是一个比较先进的 HTTP 压力测试工具，当在单个多核 CPU 上运行时，能够产生大量负载。它结合了多线程设计和可扩展的事件通知系统，例如 epoll 和 kqueue。
( e# `  t  f+ z& F. L% y( C" z
! B$ k3 c* U  w, U可选的 LuaJIT 脚本可以执行 HTTP 请求生成，响应处理和自定义报告。
3 ^, H4 [2 K; W+ d0 ~
! J+ A0 W' c/ u+ B3 j" U测试方法：
( [7 Z6 u$ ^: ^
wrk -t8 -c400 -r10m http://localhost:8080/index.html
输出结果：

  Making 10000000 requests to http://localhost:8080/index.html
2 u$ V+ J( C2 R- F& o' h    8 threads and 400 connections
    Thread Stats   Avg      Stdev     Max   +/- Stdev
      Latency   439.75us  350.49us   7.60ms   92.88%
      Req/Sec    61.13k     8.26k   72.00k    87.54%
    10000088 requests in 19.87s, 3.42GB read
2 s6 `7 `% I  e0 [* n9 ^( `  Requests/sec: 503396.23
9 F/ l6 i9 u- o  Transfer/sec:    176.16MB
7 f8 Q: L' d* f3 |9 [( L8 u

admin

一、简介
" I) c9 v$ B8 A7 x  {
$ y" A% o* d0 w; ?　　wrk 是一款针对 Http 协议的基准测试工具，它能够在单机多核 CPU 的条件下，使用系统自带的高性能 I/O 机制，如 epoll，kqueue 等，通过多线程和事件模式，对目标机器产生大量的负载。

8 z. L; y. ~( y. y6 `* dwrk是开源的, 代码在 github 上：https://github.com/wg/wrk

安装：https://www.cnblogs.com/savorboard/p/wrk.html
9 n) B: P2 p4 j' Q  M


优势：
* b. q5 |* T- s6 b9 c
轻量级性能测试工具
- S' v4 q/ H1 ?9 c9 M安装简单
学习曲线基本为0，几分钟就学会使用了
基于系统自带的高性能I/O机制，如epoll，kqueue，利用异步的事件驱动框架，通过很少的线程就可以压出很大的并发量，例如几万、几十万，这是很多性能测试工具无法做到的。
' W( a' i) p( c8 r5 j) V0 I3 N1 k劣势：

: D5 I+ |5 y, f% Q. {/ Lwrk 目前仅支持单机压测，后续也不太可能支持多机器对目标机压测，因为它本身的定位，并不是用来取代 JMeter, LoadRunner 等专业的测试工具。


# A- H" r3 |$ c% z 二、格式及用法
2 Q- ]  l/ ^6 ~: {4 o! ]# V
' d( {' ]" _% [: l. G- @$ `复制代码
Usage: wrk <options> <url>                           
2 l* Y2 X  c- }- g! \3 x9 B/ Y
  Options:                                          
5 Y: [8 w1 l% H    -c, --connections <N>  Connections to keep open  
    -d, --duration    <T>  Duration of test         
    -t, --threads     <N>  Number of threads to use  
3 |5 L3 k! v4 G7 K, o2 B+ m5 C                                                     
1 {6 i6 i# W9 X) f8 G& z    -s, --script      <S>  Load Lua script file      
    -H, --header      <H>  Add header to request     
        --latency          Print latency statistics  
        --timeout     <T>  Socket/request timeout   
    -v, --version          Print version details     
# x5 S8 b7 f' A; \0 g" t# K                                                
  Numeric arguments may include a SI unit (1k, 1M, 1G)
  Time arguments may include a time unit (2s, 2m, 2h)
复制代码
$ x" f0 @0 {* M
2 P2 J. R' c- ^$ a
翻译成中文：

' `0 x: a4 y$ s复制代码
使用方法: wrk <选项> <被测HTTP服务的URL>                           

7 d- {+ z) E5 A0 ?% o8 g' Z  Options:                                          
& v+ O: @% M6 n  l- F+ a! y+ Q% s    -c, --connections <N>  跟服务器建立并保持的TCP连接数量
: e4 Y& J# R0 C8 [  H- m    -d, --duration    <T>  压测时间         
, R0 e3 W4 J/ R/ Y. k" r    -t, --threads     <N>  使用多少个线程进行压测，压测时，是有一个主线程来控制我们设置的n个子线程间调度  
                                                   
    -s, --script      <S>  指定Lua脚本路径      
% t, @  f* `/ I& B& w2 ^    -H, --header      <H>  为每一个HTTP请求添加HTTP头     
. E1 R% ]+ M- t' \% |& _' y  U        --latency          在压测结束后，打印延迟统计信息  
        --timeout     <T>  超时时间   
5 t% N- Q+ f. ?8 `    -v, --version          打印正在使用的wrk的详细版本信                                             
- c# ~2 L6 s. R) C  T4 Q$ F% Q1 \4 ]
, U5 j2 i4 o; w6 j# S) e  <N>代表数字参数，支持国际单位 (1k, 1M, 1G)
  <T>代表时间参数，支持时间单位 (2s, 2m, 2h)
复制代码
1 E7 f& _6 P/ \5 E5 Q' w' y



三、简单压测及结果分析
, Q, F0 g; t( K7 o7 T2 |2 O
9 I& r4 f* n* s0 l做一个简单的压测，分析下结果：
, h$ |: {& }9 @7 q; W1 w1 m
3 P; R! u" Y- Q# }: A+ swrk -t8 -c200 -d30s --latency  http://www.bing.com
8 k$ S" c7 `: }% |. v7 q4 n

* Y6 Q$ U8 J  E3 h) e. V8 g% q输出：

复制代码
7 z7 J+ @! H0 N/ `& N" HRunning 30s test @ http://www.bing.com

  8 threads and 200 connections
' a# |  O/ j  R1 a( w% t; P3 s
2 u9 S9 {" ^" B0 ?1 c  Thread Stats   Avg      Stdev     Max   +/- Stdev
$ c7 [+ a' R5 P    Latency    46.67ms  215.38ms   1.67s    95.59%
+ O! {; E2 g; G$ S    Req/Sec     7.91k     1.15k   10.26k    70.77%
: n- W! b) g& E
3 Y" T- [1 l% T! h( k7 z6 g0 ]  Latency Distribution
  O: X% _4 J8 ^& ]! L3 n4 Z     50%    2.93ms
* I, j, i) G, h2 [# a+ K5 s- _     75%    3.78ms
     90%    4.73ms
     99%    1.35s
  1790465 requests in 30.01s, 684.08MB read
4 ?0 {: T- V! E/ PRequests/sec:  59658.29
Transfer/sec:     22.79MB
复制代码
# q$ F) ?1 C% C9 Q7 |以上是使用8个线程200个连接，对bing首页进行了30秒的压测，并要求在压测结果中输出响应延迟信息。
2 L$ I/ E# j( V  K
以下是解释压测结果：
7 S4 q% F# q( D4 _6 a: g& e" O/ u
' R+ G& u0 N! X: A/ O! Y复制代码
- ^: ]" B. }* K3 }- _Running 30s test @ http://www.bing.com （压测时间30s）
, v" U, u7 }1 ^/ W; s5 n
  8 threads and 200 connections （共8个测试线程，200个连接）

  Thread Stats   Avg      Stdev     Max   +/- Stdev
8 U1 H) U; x, _3 c              （平均值） （标准差）（最大值）（正负一个标准差所占比例）
! b% t4 M* q7 W" K    Latency    46.67ms  215.38ms   1.67s    95.59%
    （延迟）
    Req/Sec     7.91k     1.15k   10.26k    70.77%
    （处理中的请求数）
* u% O( a4 |  x; {
  Latency Distribution （延迟分布）
, B* G. T% W' w$ M     50%    2.93ms
# @: l- r( V1 x# t# Y     75%    3.78ms
     90%    4.73ms
     99%    1.35s （99分位的延迟：%99的请求在1.35s以内）
: l; b9 F/ q) p4 c" S* o& j  1790465 requests in 30.01s, 684.08MB read （30.01秒内共处理完成了1790465个请求，读取了684.08MB数据）
Requests/sec:  59658.29 （平均每秒处理完成59658.29个请求）
Transfer/sec:     22.79MB （平均每秒读取数据22.79MB）
复制代码
6 N$ o; X1 T) ?5 t) O* ~7 k8 q/ r( E
8 g4 Q! b1 Z1 G4 T4 Z. k
7 _5 T' }9 b& p& n4 o) C
$ Q$ e( O1 y# Z
5 C8 @- o9 S. N1 ~  J" [) ~6 w0 O4 h四、使用lua脚本进行压测

　　lua脚本是一种轻量小巧的脚本语言，用标准c语言编写，并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为程序提供灵活的扩展和定制功能。wrk工具嵌入了lua脚本语言，因此，在自定义压测场景时，可在wrk目录下使用lua定制压测场景。

2 E- P& h+ _, L　　1、lua声明周期

　　　　共有三个阶段，启动阶段，运行阶段，结束阶段。wrk支持在这三个阶段对压测进行个性化。　　　

  |1 }5 d3 X+ c" h* Z6 u启动阶段
function setup(thread)


在脚本文件中实现setup方法，wrk就会在测试线程已经初始化但还没有启动的时候调用该方法。wrk会为每一个测试线程调用一次setup方法，并传入代表测试线程的对象thread作为参数。setup方法中可操作该thread对象，获取信息、存储信息、甚至关闭该线程。
4 S3 R8 h$ _/ L  G& C  A% p0 P# u! c7 g
thread.addr - get or set the thread's server address
5 D# L' \1 k& E; r2 T7 k& Zthread:get(name) - get the value of a global in the thread's env
thread:set(name, value) - set the value of a global in the thread's env
! {& B4 y9 t0 W% f5 U6 b/ }; n. Wthread:stop() - stop the thread

7 O4 W! E( @! O. k5 ~
运行阶段
function init(args)  --由测试线程调用，只会在进入运行阶段时，调用一次。支持从启动wrk的命令中，获取命令行参数；
function delay()  --在每次发送request之前调用，如果需要delay，那么delay相应时间；
function request()  --用来生成请求；每一次请求都会调用该方法，所以注意不要在该方法中做耗时的操作；
function response(status, headers, body)  --在每次收到一个响应时调用；为提升性能，如果没有定义该方法，那么wrk不会解析headers和body；


结束阶段
function done(summary, latency, requests)  --在整个测试过程中只会调用一次，可从参数给定的对象中，获取压测结果，生成定制化的测试报告。
: Z3 }5 c1 e( x( C3 e 　　
' ~9 `/ N! `2 ~# y
　　2、自定义脚本中可访问的变量和方法：

! h) b$ c$ O: p7 f8 A　　变量：wrk

复制代码
4 M$ G. _1 X4 \* Z) \; Ewrk = {
0 {, c2 g' v6 F3 m    scheme  = "http",
    host    = "localhost",
    port    = nil,
    method  = "GET",
4 ^8 J+ k( x% g* M! R4 p/ E    path    = "/",
    headers = {},
% T6 E: S" c6 A3 `% ]' f; f2 y    body    = nil,
    thread  = <userdata>,
# l( |+ f! N/ ]. B0 D: m* i  }
复制代码
! o( X" C) r" v/ h" v0 k7 C  ^7 ^$ d
( W& J3 n' l7 p# w
　　方法：wrk.fomat wrk.lookup wrk.connect                  
1 \" X5 S! Z0 F, g* i
# ?3 g6 ~) A, m' u6 Jfunction wrk.format(method, path, headers, body)  --根据参数和全局变量wrk，生成一个HTTP rquest string。
function wrk.lookup(host, service)  --给定host和service（port/well known service name），返回所有可用的服务器地址信息。
7 l* _6 K* g. V6 m- |: d7 dfunction wrk.connect(addr)  --测试与给定的服务器地址信息是否可以成功创建连接
' J. k% F/ D5 @) k1 S! |

3、lua脚本压测实例
6 k- y! t$ O6 }$ k: Z+ K
　　压测命令：wrk -t8 -c200 -d30s --latency  -s test.lua http://www.bing.com

　　test.lua是用lua写的压测脚本，如下是压测脚本的实例：
6 I  |$ l4 F; G" m
9 p2 ]0 |% b9 c& t　　使用post方法压测

复制代码
5 E" B1 D& M' {1 \$ _( \& e: t9 lwrk.method = "POST"
wrk.headers["S-COOKIE2"]="a=2&b=Input&c=10.0&d=20191114***"
6 ]4 B7 N3 t  s, F% bwrk.body = "recent_seven=20191127_32;20191128_111"
wrk.headers["Host"]="api.shouji.**.com"
% d1 c( H% l, k  K& ^& ]
9 Q7 l# j, Y1 G" E7 H$ Bfunction response(status,headers,body)
        if status ~= 200 then --将服务器返回状态码不是200的请求结果打印出来
                print(body)
        --      wrk.thread:stop()
        end
end
复制代码
- v: _' @' u3 Z0 C

　　 发送json
4 u$ U/ s# V& N( F& T8 B& v
复制代码
request = function()
1 R+ `5 s1 m( R    local headers = { }
    headers['Content-Type'] = "application/json"
    body = {
( M, x4 B! |) r2 [: y  X& D        mobile={"1533899828"},
5 J" |, j7 L- N8 J$ p        params={code=math.random(1000,9999)}
    }
8 S1 K# F" q5 z8 ]: B    local cjson = require("cjson")
    body_str = cjson.encode(body)
2 L  U: c! @2 g- f0 k7 O    return wrk.format('POST', nil, headers, body_str)
end
复制代码


wrk读取文件，实现随机header-cookie
/ a. g/ ^/ k5 W' c% q
. j( N  q& C$ ]复制代码
- w: X- [9 d6 p/ }idArr = {}
falg = 0
" ]+ X( l5 ?- l) Xwrk.method = "POST"
2 ~0 W% j: ~8 @" U% o" cwrk.body = "a=1"
$ X8 j3 T3 c6 m4 {function init(args)
, ^3 x! b9 P# s1 H        for line in io.lines("integral/cookies.txt") do
: W, k* R: |# l. k4 a8 a! h' Q                print(line)
, N$ d" n7 y7 e, V1 |                idArr[falg] = line
% E$ S/ j4 }% v+ |8 M1 {$ n* l                falg = falg+1
        end
7 S0 f- e5 s4 A& b        falg = 0
end

--wrk.method = "POST"
7 \& g3 L. ^, E0 f# P$ ^3 L0 @--wrk.body = "a=1"
4 A# t. z. c* B: C3 g  \1 H--wrk.path = "/v1/points/reading"

request = function()
/ S, E: k) ?2 \2 T; i& q        parms = idArr[math.random(0,4)] --随机传递文件中的参数
        --parms = idArr[falg%(table.getn(idArr)+1)] 循环传递文件中的参数
        wrk.headers["S-COOKIE2"] = parms
        falg = falg+1
: U# ~! M& M. M: I1 C& {8 D        return wrk.format()
" H$ t( O& _6 `) L( x. q" ]end
" T: M/ ]0 b* b( l) d复制代码
* O. A9 l$ o% u9 k) [, p
' l1 K0 V5 E* w6 `4 ]
　　wrk创建数组并初始化，拼接随机参数
5 A' z7 I0 Z8 `+ K. D: C5 N
复制代码
idArr = {};
function init(args)
        idArr[1] = "1";
. X" b. n3 x& Y; G        idArr[2] = "2";
        idArr[3] = "3";
/ q6 R/ G/ @6 h( c6 A( d" S        idArr[4] = "4";
; l( x& X+ \7 |) e1 m+ H$ ~2 v& fend

  d7 R. i0 e4 Jrequest = function()
        parms = idArr[math.random(1,4)]
; G) ]+ t' x) P+ Q5 g4 D        path = "/v1/points/reading?id="..parms
: B0 l+ g4 O( A# o" E4 q        return wrk.format("GET",path)
end
复制代码