tar zxf openresty-1.19.9.1.tar.gzcd openresty-1.19.9.1/./configure --with-luajit --with-http_iconv_modulemake -j8 && sudo make install

/usr/local/openresty/bin/openresty -V

安装 Wrk

wrk 是现代的 HTTP 基准测试工具，当在单个多核 CPU 上运行时，能够产生显著的负载。它结合多线程设计和可扩展的事件通知系统，比如 epoll 和 kqueue。
可选的 LuaJIT 脚本可以执行 HTTP 请求生成、响应处理和自定义报告。

安装依赖包

sudo yum install -y gcc openssl openssl-devel git curl

克隆源码

git clone https://github.com/wg/wrk.git wrk

cd wrk/ make

编译

cd wrk/ make

./wrk -v

Wrk 脚本简介

概览

Wrk 支持在三个不同阶段期间执行 LuaJIT 脚本：Setup、Running 和 Done。每个 Wrk 线程拥有独立的脚本环境，Setup 和 Done 阶段在单独的环境中执行，该环境不参与 Running 阶段。

公有 Lua API 包含全局表和多个全局函数：

wrk = {    scheme  = "http",    host    = "localhost",    port    = nil,    method  = "GET",    path    = "/",    headers = {},    body    = nil,    thread  =                                                                                                         ,  }function wrk.format(method, path, headers, body)                                                

cp /usr/local/openresty/nginx/conf/mime.types .

python3 generate_image.py -t gif -w 100 -H 100 -o static/100x100.gif

python3 generate_image.py -t png -w 100 -H 100 -o static/100x100.png

python3 generate_image.py -t txt -s 131072 -o static/128k.txt

worker_processes

  auto;error_log

  logs/error.log;error_log

  logs/error.log

  notice;error_log

  logs/error.log

  info;pid

        logs/nginx.pid;events {

    worker_connections  4096;}http {

    include

       mime.types;

    default_type

  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '

                      '$status $body_bytes_sent "$http_referer" '

                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  logs/access.log  main;

    sendfile          on;

    tcp_nodelay       on;

    keepalive_timeout 15;

    open_file_cache          max=2048 inactive=30s;

    open_file_cache_valid    10s;

    open_file_cache_min_uses 1;

    open_file_cache_errors   on    # 请求体不能超过该设置。

    # 如果客户端需要传递更大的请求体，那么调整该设置    client_max_body_size 10m;

    # 预置策略。

    # 预置策略通过名称进行唯一标识。

    # 预置策略封装响应码、响应头和响应体（可选），可避免客户端重复传输这些内容。

    # 客户端通过请求头指定使用的策略。

    # 如此一来，客户端可以同时自由地定制请求和响应，只多出用于指定所用策略的请求头。

    # 服务端使用紧跟在策略名称后面的磁盘文件名称，获取响应体。

    # 因此，需要提前将生成的响应体存储到磁盘文件。

    # 如果未提供文件名称，并且策略中存在响应体，那么使用策略中的响应体。

    # 如果都未提供，那么返回空响应体。

    # 请求头类似 X-Predefined-Strategy: png,100x100.png 或 X-Predefined-Strategy: forbidden。

    # 注意：

    # 1. 预置的响应体不能太大，否则将占用太多的共享内存

    # 2. 预置策略名称不能包含 ","

    # 3. 预置策略中指定的响应头名称不会被规范化，因此设置时，需要注意

    lua_shared_dict predefined_stategies 128m;

    init_by_lua_block {

        -- 保存策略

        local function save_strategy(name, status_code, headers, body)

            if name == nil then return ngx.log(ngx.ERR, "no strategy name provided") end

            local t = {

                status_code = status_code or ngx.HTTP_OK,

                headers = {},

                body = body or ""

            }

            for name, value in pairs(headers or {}) do t.headers[name] = value end

            local cjson = require("cjson.safe")

            local j = cjson.encode(t)

            if j == nil then return end

            local s = ngx.shared.predefined_stategies

            local suc, err = s:set(name, j)

            if suc then ngx.log(ngx.INFO, "setting strategy " .. name .. " succeeded")

            else ngx.log(ngx.ERR, "setting strategy " .. name .. " failed with " .. err) end

        end        -- 按需添加策略

        save_strategy("png", ngx.HTTP_OK, {["Content-Type"]="image/png"})

        save_strategy("jpeg", ngx.HTTP_OK, {["Content-Type"]="image/jpeg"})

        save_strategy("gif", ngx.HTTP_OK, {["Content-Type"]="image/gif"})

        save_strategy("ico", ngx.HTTP_OK, {["Content-Type"]="image/x-icon"})

        save_strategy("text", ngx.HTTP_OK, {["Content-Type"]="text/plain"})

        save_strategy("json", ngx.HTTP_OK, {["Content-Type"]="application/json;charset=utf8"})

        save_strategy(

            "forbidden_default",

            ngx.HTTP_FORBIDDEN,

            {["Content-Type"]="text/plain"},

            "forbidden"

        )

        save_strategy(

            "notfound_default",

            ngx.HTTP_NOT_FOUND,

            {["Content-Type"]="text/plain"},

            "not found"

        )

    }

    server {

        listen       80;

        server_name  localhost;

        location /static {

            alias static/;

        }

        location / {

            content_by_lua_block {

                local cjson = require "cjson.safe"

                -- 规范化响应名称

                local normalize_header = function(name)

                    -- 1. _ 替换成 -

                    name = string.gsub(name, "_", "-")

                    -- 2. 第一个字符大写

                    name = string.gsub(name, "%w", function(m) return string.upper(m) end, 1)

                    -- 3. - 后面的字符大写

                    return string.gsub(name, "-%w", function(m) return string.upper(m) end)

                end

                -- 生成指定长度的随机字符串

                local function generate_random_string(length)

                    local chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

                    -- 使用当前时间作为随机种子

                    math.randomseed(os.time())

                    local r = ""

                    for _ = 1, length do

                        local idx = math.random(1, #chars)

                        r = r .. string.sub(chars, idx, idx)

                    end

                    return r

                end

                -- 当指定的策略或路径不存在时，返回该响应码

                local strategy_not_found_status = ngx.HTTP_NOT_FOUND

                local strategy

                local path

                local predefined_strategy_hdr = ngx.var.http_x_predefined_strategy

                -- 如果客户端指定策略

                if predefined_strategy_hdr ~= nil then

                    local start_pos, end_pos = string.find(predefined_strategy_hdr, ",", 1, true)

                    if start_pos == nil then

                        strategy = predefined_strategy_hdr

                    else

                        strategy = string.sub(predefined_strategy_hdr, 1, start_pos-1)

                        path = string.sub(predefined_strategy_hdr, end_pos+1)

                    end

                    -- 获取策略

                    local s = ngx.shared.predefined_stategies

                    strategy = s:get(strategy)

                    -- 如果策略不存在，那么返回错误

                    if strategy == nil then

                        ngx.status = strategy_not_found_status

                        ngx.header.content_type = "text/plain"

                        ngx.say("the provided stategy not found")

                        return ngx.exit(ngx.HTTP_OK)

                    end

                    -- 根据策略设置响应

                    strategy = cjson.decode(strategy)

                    ngx.status = strategy.status_code

                    for name, value in pairs(strategy.headers or {}) do

                        ngx.header[name] = value

                    end

                    -- 设置响应体

                    if path == nil then

                        ngx.print(strategy.body)

                        return ngx.exit(ngx.HTTP_OK)

                    end

                    -- 发起子请求，从磁盘获取响应体

                    local res = ngx.location.capture("/static".."/"..path)

                    if res.status == ngx.HTTP_OK then

                        ngx.print(res.body)

                    else

                        ngx.status = strategy_not_found_status

                        ngx.header.content_type = "text/plain"

                        ngx.say("the provided path not found")

                    end

                    return ngx.exit(ngx.HTTP_OK)

                end

                -- 非策略模式用于构建期望的响应

                -- 当请求体不合法时，返回该响应码

                local bad_request_status_code = ngx.HTTP_BAD_REQUEST

                -- 读取请求体

                ngx.req.read_body()

                local body_raw = ngx.req.get_body_data()

                -- 解析请求体

                local body, err = cjson.decode(body_raw)

                -- 解析请求体失败

                if err ~= nil then

                    ngx.status = bad_request_status_code

                    ngx.say(err)

                    return ngx.exit(ngx.HTTP_OK)

                end

                -- 设置响应码

                local status_code = body["status_code"]

                if status_code == nil then status_code = ngx.HTTP_OK end

                ngx.status = status_code

                -- 设置响应头

                for name, value in pairs(body["headers"] or {}) do

                    ngx.header[normalize_header(name)] = value

                end

                -- 设置响应体

                if body["body"] then

                    -- 使用客户端指定的响应体

                    ngx.print(body["body"])

                else

                     -- 使用客户端指定的随机响应体长度生成响应体。

                    -- 指定的长度越长，生成随机字符串的效率越低，请设置合理的长度

                    if body["random_body_length"] then

                        ngx.print(generate_random_string(tonumber(body["random_body_length"])))

                    else

                        -- 返回空响应体

                        ngx.print("")

                    end

                end

                return ngx.exit(ngx.HTTP_OK)

            }

        }

    }}

关于 generate_image.py 的内容，请参阅前一章节。

启动 Openresty

/usr/local/openresty/bin/openresty -p . -c nginx.conf

"GET /path/1 HTTP/1.1" 200 40181
"POST /path/2 HTTP/1.1" 200 141424
"PUT /path/3/arbitrary/here HTTP/1.1" 200 131086
"GET /path/4 HTTP/1.1" 200 78