Introduction to wrk pressure test tool

What is? wrk

wrk  It's about  Http  Protocol benchmarking tools , It can be used in single machine and multi-core  CPU  Under the condition of , Use the high performance of the system  I/O  Mechanism , Such as  epoll,kqueue  etc. , Through multithreading and event mode , Generate a lot of load on the target machine .

PS:  Actually ,wrk  It's reuse  redis  Of  ae  Asynchronous event driven framework , To be precise  ae  Event driven frameworks are not  redis  Invented ,  It comes to  Tcl  Interpreter  jim,  This compact and efficient framework ,  Because being  redis  Adopted and well known .

wrk  The advantages of ：

• Lightweight performance testing tool ;

• Simple installation （ relative  Apache ab  Come on ）;

• Learning curve is basically zero , I can learn how to use it in a few minutes ;

• High performance based on the system  I/O  Mechanism , Such as  epoll, kqueue,  Using asynchronous event driven framework , A large amount of concurrency can be squeezed out through a small number of threads ;

Inferiority :

wrk  At present, only single unit pressure test is supported , In the future, it is unlikely to support multiple machines to press test the target machine , Because of its position , Not to replace  JMeter, LoadRunner  And other professional testing tools ,wrk  Features provided , For our back-end developers , It is friendly to deal with daily interface performance verification .

wrk Installation

mac:

brew install wrk


linux:

git clone https:``//github.com/wg/wrk.git wrk``cd wrk``make``#  Move executable to  /usr/local/bin  Location ``sudo cp wrk /usr/local/bin


Easy to use

wrk -t12 -c400 -d30s http:``//www.baidu.com


This command indicates , utilize  wrk  Yes  www.baidu.com  Initiate stress test , The number of threads is  12, simulation  400  Four concurrent requests , continued  30  second .

wrk  Command parameter description

In addition to the subcommand parameters used in the simple example above ,

wrk

  There are more functions , Enter... On the command line  

wrk --help

,  You can see that the following subcommands are supported ：

wrk --help``Usage: wrk <options> <url> `` ``Options: `` ``-c, --connections <N> Connections to keep open  Established and maintained with the server TCP Number of connections   The total number of connections （ Number of connections processed per thread = Total connections / Number of threads ）`` ``-d, --duration <T> Duration of test  Measurement time  `` ``-t, --threads <N> Number of threads to use  How many threads are used for pressure testing `` ` ` ``-s, --script <S> Load Lua script file  Appoint Lua Script path  `` ``-H, --header <H> Add header to request  For every one HTTP Request add HTTP head `` ``--latency Print latency statistics  After pressure test , Print delay statistics `` ``--timeout <T> Socket/request timeout  Timeout time `` ``-v, --version Print version details  Print in use wrk Detailed version information for `` ` ` ``Numeric arguments may include a SI unit (1k, 1M, 1G)`` ``Time arguments may include a time unit (2s, 2m, 2h)<N> For digital parameters , Support international units  (1k, 1M, 1G) <T> Represents time parameter , Time units supported  (2s, 2m, 2h)


About the number of threads , It's not that the larger the setting , The better the effect of pressure measurement , Thread set too large , On the contrary, it will lead to too frequent thread switching , Effect reduced , Generally speaking , Recommended setting as pressure measuring machine  CPU  Of the core number  2  Times to  4  Double it .

Test report

Execute pressure test command :

wrk -t12 -c400 -d30s --latency http:``//www.baidu.com


Execute the above pressure test command ,30  Seconds after pressure measurement , Generate the following pressure test report ：

Running 30s test @ http:``//www.baidu.com （ Measurement time 30s）`` ``12 threads and 400 connections （ common 12 Test threads ,400 A connection ）``（ Average ） （ Standard deviation ） （ Maximum ）（ Proportion of plus or minus one standard deviation ）`` ``Thread Stats Avg Stdev Max +/- Stdev`` ``Latency 386.32ms 380.75ms 2.00s 86.66% ( Delay `` ``Req/Sec 17.06 13.91 252.00 87.89% （ Requests per second `` ``Latency Distribution （ Delay distribution `` ``50% 218.31ms`` ``75% 520.60ms`` ``90% 955.08ms`` ``99% 1.93s`` ``4922 requests in 30.06s, 73.86MB read (30.06s Internal processing 4922 A request , Consumed flow 73.86MB)`` ``Socket errors: connect 0, read 0, write 0, timeout 311 （ Number of errors ``Requests/sec: 163.76 (QPS 163.76, That is, the average number of requests processed per second is 163.76)``Transfer/sec: 2.46MB ( Average traffic per second 2.46MB)


What does standard deviation mean ？ If the standard deviation is too large, the sample itself has a high degree of dispersion , It is possible that the system performance fluctuates greatly . The standard deviation is 0  It's a straight line

Use  Lua  Script for complex testing

You may have questions , You do this  GET  It's a good request , I want to  POST  What to do with the request ？ And I think every request parameter is different , It is used to simulate the actual scene used by users , How to do it again ？

For this need , We can write  Lua  How to script , When running the pressure test command , Through parameters  

--script

  To specify the  Lua  Script , To meet individual needs .

wrk  Yes  Lua  Script support

wrk  Support the personalization of pressure measurement in three stages , They are the start-up phase 、 Operation phase and end phase . Each test thread , All have independent Lua  Running environment .

Start-up phase :

function setup(thread)


Implement... In script file  setup  Method ,wrk  The test thread will be initialized , But call this method before it starts .wrk Will be called once for each test thread  setup  Method , And pass in the object representing the test thread  thread  As a parameter .setup  Method  thread  object , pick up information 、 Store information 、 Even shut down the thread .

thread.addr - get or set the thread's server address``thread: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``thread:stop() - stop the thread


Operation phase :

function init(args)``function delay()``function request()``function response(status, headers, body)


• init(args)
  :  Called by test thread , Only when entering the operation phase , Call once . Support starting from  wrk  In command , Get command line parameters ;

• delay()
  ：  Calls before each request is sent , If you need to customize the delay time , You can set it in this method ;

• request()
  :  Used to generate requests ,  This method is called every time , So be careful not to do time-consuming operations in this method ;

• response(status, headers, body)
  :  Called every time a response is received , To improve performance , If the method is not defined , that wrk No resolution  
  headers
    and  
  body
  ;

Closing phase ：

function done(summary, latency, requests)
done()  Method will only be called once during the entire test , We can choose from the given parameters , Obtain pressure test results , Generate customized test reports .


Customize  Lua  Accessible variables and methods in the script ：

Variable ：wrk

wrk = {`` ``scheme = ``&quot;http&quot;``,`` ``host = ``&quot;localhost&quot;``,`` ``port = 8080,`` ``method = ``&quot;GET&quot;``,`` ``path = ``&quot;/&quot;``,`` ``headers = {},`` ``body = nil,`` ``thread = <userdata>,`` ``}


The above defines a  

table

  Global variable of type , Modify this  

wrk

  Variable , Affects all requests .

Method ：

• wrk.fomat

• wrk.lookup

• wrk.connect

The above three methods are explained as follows

function wrk.format(method, path, headers, body)` ` ``wrk.format returns a HTTP request string containing the passed parameters`` ``merged with values from the wrk table.`` ``#  According to parameters and global variables  wrk, Generate a  HTTP rquest  character string .` `function wrk.lookup(host, service)` ` ``wrk.lookup returns a table containing all known addresses ``for` `the host`` ``and service pair. This corresponds to the POSIX getaddrinfo() function.`` ``#  Given  host  and  service（port/well known service name）, Return all available server address information .` `function wrk.connect(addr)` ` ``wrk.connect returns true ``if` `the address can be connected to, otherwise`` ``it returns false. The address must be one returned from wrk.lookup().`` ``#  Test whether the given server address information can successfully create a connection


Case study ： adopt  Lua  Script pressure test example

call  POST  Interface ：

wrk.method = ``"POST"``wrk.body = ``"foo=bar&baz=quux"``wrk.headers[``"Content-Type"``] = ``"application/x-www-form-urlencoded"


Be careful : wrk  It's a global variable , It has been modified here , Make all requests use  POST  The way , And designated  body  and  Content-Type head .

Customize parameters for each request ：

request = function()`` ``uid = math.random(1, 10000000)`` ``path = ``"/test?uid="` `.. uid`` ``return` `wrk.format(nil, path)``end


stay  request  In the method , Random generation  1~10000000  Between  uid, And generate requests dynamically  URL.

Before each request , Delay  10ms:

function delay()`` ``return` `10``end


The requested interface needs to be authenticated first , obtain  token  after , To initiate a request , To do ？

token = nil``path = ``"/auth"` `request = function()`` ``return` `wrk.format(``"GET"``, path)``end` `response = function(status, headers, body)`` ``if` `not token and status == 200 then`` ``token = headers[``"X-Token"``]`` ``path = ``"/test"`` ``wrk.headers[``"X-Token"``] = token`` ``end``end


The script above represents , stay  token  In the null case , Ask first  

/auth

  Interface to authenticate , obtain  token,  Get  token  in the future , take  token  Place in request header , Ask again what really needs to be pressure tested  

/test

  Interface .

Piezometric support  HTTP pipeline  Service for ：

init = function(args)`` ``local r = {}`` ``r[1] = wrk.format(nil, ``"/?foo"``)`` ``r[2] = wrk.format(nil, ``"/?bar"``)`` ``r[3] = wrk.format(nil, ``"/?baz"``)` ` ``req = table.concat(r)``end` `request = function()`` ``return` `req``end


By means of  init  Method will have three  HTTP Request stitching together , Implementation sends three requests at a time , To use the  HTTP pipeline.