春哥，请教一个subrequest性能的问题

onyourmarkrun

Hi，

我这边测下来，让nginx发送向上游服务器的子请求的情景下，理想情况可以达到的qps如下：

Requests per second: 6464.19 [#/sec] (mean)

而不带subrequest时，可以达到38000:

keepalive_with_cache_100000_500: Requests per second: 38026.88 [#/sec] (mean)

配置：4核CPU，4GB内存，10Mbps网卡带宽；

此外，上游服务器是用的内网地址，如果用外网地址的情况下，测试结果：

Requests per second: 1343.96 [#/sec] (mean)

可是按照我的理解，纯异步的子请求发送，网络延迟应该不回影响性能才对。因此无论是之后1000多的qps，还是单子请求下的最好表现6000多qps，似乎都因某个瓶颈而没能达到性能极限。我认为单子请求情况下，理论上（不带任何业务，不耗费cpu时间）应该与echo server的38000 qps很接近才对。

春哥您怎么看？有哪些可以优化的地方吗？

Zhiqian

yuansheng

2016-11-22 16:49 GMT+08:00 Zhiqian Yuan <onyour...@gmail.com>:

Hi，

我这边测下来，让nginx发送向上游服务器的子请求的情景下，理想情况可以达到的qps如下：

Requests per second: 6464.19 [#/sec] (mean)

而不带subrequest时，可以达到38000:

nginx 内部子请求自身的代价消耗还是比较高的，具体可以参考 nginx 源码。

提供一下你的配置文件、lua 代码，给出更好的做法之前需要知道你想要什么。

keepalive_with_cache_100000_500: Requests per second: 38026.88 [#/sec] (mean)

配置：4核CPU，4GB内存，10Mbps网卡带宽；

此外，上游服务器是用的内网地址，如果用外网地址的情况下，测试结果：

Requests per second: 1343.96 [#/sec] (mean)

可是按照我的理解，纯异步的子请求发送，网络延迟应该不回影响性能才对。因此无论是之后1000多的qps，还是单子请求下的最好表现6000多qps，似乎都因某个瓶颈而没能达到性能极限。我认为单子请求情况下，理论上（不带任何业务，不耗费cpu时间）应该与echo server的38000 qps很接近才对。

春哥您怎么看？有哪些可以优化的地方吗？

Zhiqian

--

YuanSheng Wang

---------------------------------------

My Github: https://github.com/membphis

OpenResty lover ^_^

onyourmarkrun

Hi，非常感谢您的解答。

我只贴lua代码吧，conf文件先不贴了；

代码贴在了最后，我的应用场景是接到一个对方服务器发来的请求，在给出回应之前先发http请求访问一个（或并发请求多个）上游服务器，拿到结果后，根据上游服务器的返回内容给出原始请求的回应。

除了subrequest我不知道是否还有其他更好的解决方案，因为我是想让子请求过程进入事件模型，不阻塞nginx的worker。不知这样的场景通常会怎样解决呢？

比如一个ad exchange，通常会有并发请求几十个dsp的需求，不知他们会怎样选型呢？

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝代码部分＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

local action = "">

ngx.req.read_body();

-- get request body

local data = "">

-- get request uri's args

local args = ngx.req.get_uri_args();

-- issue subrequest.

local res1,res2,res3 = ngx.location.capture_multi({

{"/sub1"..ngx.var.request_uri},

--{"/sub2"..ngx.var.request_uri},

--{"/sub3"..ngx.var.request_uri},

--{"/sub4"..ngx.var.request_uri},

--{"/sub5"..ngx.var.request_uri},

--{"/sub6"..ngx.var.request_uri},

--{"/sub7"..ngx.var.request_uri}

-- TODO: N's subrequests

})

ngx.say("");

在 2016年11月22日星期二 UTC+8下午7:48:00，YuanSheng写道：

2016-11-22 16:49 GMT+08:00 Zhiqian Yuan <onyour...@gmail.com>:
Hi，

我这边测下来，让nginx发送向上游服务器的子请求的情景下，理想情况可以达到的qps如下：

Requests per second:    6464.19 [#/sec] (mean)

而不带subrequest时，可以达到38000:

nginx 内部子请求自身的代价消耗还是比较高的，具体可以参考 nginx 源码。

提供一下你的配置文件、lua 代码，给出更好的做法之前需要知道你想要什么。

keepalive_with_cache_100000_500: Requests per second:    38026.88 [#/sec] (mean)

配置：4核CPU，4GB内存，10Mbps网卡带宽；

此外，上游服务器是用的内网地址，如果用外网地址的情况下，测试结果：

Requests per second:    1343.96 [#/sec] (mean)

可是按照我的理解，纯异步的子请求发送，网络延迟应该不回影响性能才对。因此无论是之后1000多的qps，还是单子请求下的最好表现6000多qps，似乎都因某个瓶颈而没能达到性能极限。我认为单子请求情况下，理论上（不带任何业务，不耗费cpu时间）应该与echo server的38000 qps很接近才对。

春哥您怎么看？有哪些可以优化的地方吗？

Zhiqian

--

--

YuanSheng Wang
---------------------------------------
My Github: https://github.com/membphis
OpenResty lover ^_^

yuansheng

2016-11-22 21:07 GMT+08:00 Zhiqian Yuan <onyour...@gmail.com>:

Hi，非常感谢您的解答。

我只贴lua代码吧，conf文件先不贴了；

代码贴在了最后，我的应用场景是接到一个对方服务器发来的请求，在给出回应之前先发http请求访问一个（或并发请求多个）上游服务器，拿到结果后，根据上游服务器的返回内容给出原始请求的回应。

这里还可以用 https://github.com/iresty/nginx-lua-module-zh-wiki#ngxthreadspawn + https://github.com/pintsized/lua-resty-http

也就是 “轻线程” + cosocket http 方式，尤其是当你有1：N 的上游请求时，这种方式更合适。

之前优酷的同学也遇到类似的问题，他们用同样方法解决的。

除了subrequest我不知道是否还有其他更好的解决方案，因为我是想让子请求过程进入事件模型，不阻塞nginx的worker。不知这样的场景通常会怎样解决呢？

比如一个ad exchange，通常会有并发请求几十个dsp的需求，不知他们会怎样选型呢？

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝代码部分＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
local action = "">

ngx.req.read_body();

-- get request body
local data = "">
-- get request uri's args
local args = ngx.req.get_uri_args();

-- issue subrequest.
local res1,res2,res3 = ngx.location.capture_multi({
{"/sub1"..ngx.var.request_uri},
--{"/sub2"..ngx.var.request_uri},
--{"/sub3"..ngx.var.request_uri},
--{"/sub4"..ngx.var.request_uri},
--{"/sub5"..ngx.var.request_uri},
--{"/sub6"..ngx.var.request_uri},
--{"/sub7"..ngx.var.request_uri}
-- TODO: N's subrequests
})

ngx.say("");

在 2016年11月22日星期二 UTC+8下午7:48:00，YuanSheng写道：

2016-11-22 16:49 GMT+08:00 Zhiqian Yuan <onyour...@gmail.com>:
Hi，

我这边测下来，让nginx发送向上游服务器的子请求的情景下，理想情况可以达到的qps如下：

Requests per second:    6464.19 [#/sec] (mean)

而不带subrequest时，可以达到38000:

nginx 内部子请求自身的代价消耗还是比较高的，具体可以参考 nginx 源码。

提供一下你的配置文件、lua 代码，给出更好的做法之前需要知道你想要什么。

keepalive_with_cache_100000_500: Requests per second:    38026.88 [#/sec] (mean)

配置：4核CPU，4GB内存，10Mbps网卡带宽；

此外，上游服务器是用的内网地址，如果用外网地址的情况下，测试结果：

Requests per second:    1343.96 [#/sec] (mean)

可是按照我的理解，纯异步的子请求发送，网络延迟应该不回影响性能才对。因此无论是之后1000多的qps，还是单子请求下的最好表现6000多qps，似乎都因某个瓶颈而没能达到性能极限。我认为单子请求情况下，理论上（不带任何业务，不耗费cpu时间）应该与echo server的38000 qps很接近才对。

春哥您怎么看？有哪些可以优化的地方吗？

Zhiqian

--

--

YuanSheng Wang
---------------------------------------
My Github: https://github.com/membphis
OpenResty lover ^_^

--

YuanSheng Wang

---------------------------------------

My Github: https://github.com/membphis

OpenResty lover ^_^

onyourmarkrun

好的，我去调研一下。真是太感谢了：）

在 2016年11月22日下午9:19，YuanSheng Wang <yuan...@openresty.org>写道：

2016-11-22 21:07 GMT+08:00 Zhiqian Yuan <onyour...@gmail.com>:
Hi，非常感谢您的解答。

我只贴lua代码吧，conf文件先不贴了；

代码贴在了最后，我的应用场景是接到一个对方服务器发来的请求，在给出回应之前先发http请求访问一个（或并发请求多个）上游服务器，拿到结果后，根据上游服务器的返回内容给出原始请求的回应。

这里还可以用 https://github.com/iresty/nginx-lua-module-zh-wiki#ngxthreadspawn + https://github.com/pintsized/lua-resty-http

也就是 “轻线程” + cosocket http 方式，尤其是当你有1：N 的上游请求时，这种方式更合适。

之前优酷的同学也遇到类似的问题，他们用同样方法解决的。

除了subrequest我不知道是否还有其他更好的解决方案，因为我是想让子请求过程进入事件模型，不阻塞nginx的worker。不知这样的场景通常会怎样解决呢？

比如一个ad exchange，通常会有并发请求几十个dsp的需求，不知他们会怎样选型呢？

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝代码部分＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
local action = "">

ngx.req.read_body();

-- get request body
local data = "">
-- get request uri's args
local args = ngx.req.get_uri_args();

-- issue subrequest.
local res1,res2,res3 = ngx.location.capture_multi({
{"/sub1"..ngx.var.request_uri},
--{"/sub2"..ngx.var.request_uri},
--{"/sub3"..ngx.var.request_uri},
--{"/sub4"..ngx.var.request_uri},
--{"/sub5"..ngx.var.request_uri},
--{"/sub6"..ngx.var.request_uri},
--{"/sub7"..ngx.var.request_uri}
-- TODO: N's subrequests
})

ngx.say("");

在 2016年11月22日星期二 UTC+8下午7:48:00，YuanSheng写道：

2016-11-22 16:49 GMT+08:00 Zhiqian Yuan <onyour...@gmail.com>:
Hi，

我这边测下来，让nginx发送向上游服务器的子请求的情景下，理想情况可以达到的qps如下：

Requests per second:    6464.19 [#/sec] (mean)

而不带subrequest时，可以达到38000:

nginx 内部子请求自身的代价消耗还是比较高的，具体可以参考 nginx 源码。

提供一下你的配置文件、lua 代码，给出更好的做法之前需要知道你想要什么。

keepalive_with_cache_100000_500: Requests per second:    38026.88 [#/sec] (mean)

配置：4核CPU，4GB内存，10Mbps网卡带宽；

此外，上游服务器是用的内网地址，如果用外网地址的情况下，测试结果：

Requests per second:    1343.96 [#/sec] (mean)

可是按照我的理解，纯异步的子请求发送，网络延迟应该不回影响性能才对。因此无论是之后1000多的qps，还是单子请求下的最好表现6000多qps，似乎都因某个瓶颈而没能达到性能极限。我认为单子请求情况下，理论上（不带任何业务，不耗费cpu时间）应该与echo server的38000 qps很接近才对。

春哥您怎么看？有哪些可以优化的地方吗？

Zhiqian

--

--

YuanSheng Wang
---------------------------------------
My Github: https://github.com/membphis
OpenResty lover ^_^

--

--

YuanSheng Wang
---------------------------------------
My Github: https://github.com/membphis
OpenResty lover ^_^

--