如何发起新 HTTP 请求

OpenResty 最主要的应用场景之一是 API Server，有别于传统 Nginx 的代理转发应用场景，API Server 中心内部有各种复杂的交易流程和判断逻辑，学会高效的与其他 HTTP Server 调用是必备基础。本文将介绍 OpenResty 中两个最常见 HTTP 接口调用方法。

我们先来模拟一个接口场景，一个公共服务专门用来对外提供加了“盐” md5 计算，业务系统调用这个公共服务完成业务逻辑，用来判断请求本身是否合法。

利用 proxy_pass

参考下面示例，利用 proxy_pass 完成 HTTP 接口访问的成熟配置+调用方法。

  1. http {
  2.     upstream md5_server{
  3.         server 127.0.0.1:81;        # ①
  4.         keepalive 20;               # ②
  5.     }
  7.     server {
  8.         listen    80;
  10.         location /test {
  11.             content_by_lua_block {
  12.                 ngx.req.read_body()
  13.                 local args, err = ngx.req.get_uri_args()
  15.                 -- ③
  16.                 local res = ngx.location.capture('/spe_md5',
  17.                     {
  18.                         method = ngx.HTTP_POST,
  19.                         body = args.data
  20.                     }
  21.                 )
  23.                 if 200 ~= res.status then
  24.                     ngx.exit(res.status)
  25.                 end
  27.                 if args.key == res.body then
  28.                     ngx.say("valid request")
  29.                 else
  30.                     ngx.say("invalid request")
  31.                 end
  32.             }
  33.         }
  35.         location /spe_md5 {
  36.             proxy_pass http://md5_server;   -- ④
  37.             #For HTTP, the proxy_http_version directive should be set to “1.1” and the “Connection”
  38.             #header field should be cleared.（from:http://nginx.org/en/docs/http/ngx_http_upstream_module.html#keepalive)
  39.             proxy_http_version 1.1;
  40.             proxy_set_header Connection "";
  41.         }
  42.     }
  44.     server {
  45.         listen    81;           -- ⑤
  47.         location /spe_md5 {
  48.             content_by_lua_block {
  49.                 ngx.req.read_body()
  50.                 local data = ngx.req.get_body_data()
  51.                 ngx.print(ngx.md5(data .. "*&^%$#$^&kjtrKUYG"))
  52.             }
  53.         }
  54.     }
  55. }

重点说明：

  • ① 上游访问地址清单（可以按需配置不同的权重规则）；
  • ② 上游访问长连接，是否开启长连接，对整体性能影响比较大（大家可以实测一下）；
  • ③ 接口访问通过 ngx.location.capture 的子查询方式发起；
  • ④ 由于 ngx.location.capture 方式只能是 Nginx 自身的子查询，需要借助 proxy_pass 发出 HTTP 连接信号；
  • ⑤ 公共 API 输出服务；

这里大家可以看到，借用 Nginx 周边成熟组件力量，为了发起一个 HTTP 请求，我们需要绕好几个弯子，甚至还有可能踩到坑（upstream 中长连接的细节处理），显然没有足够优雅，所以我们继续看下一章节。

利用 cosocket

立马开始我们的新篇章，给大家展示优雅的解决方式。

  1. http {
  2.     server {
  3.         listen    80;
  5.         location /test {
  6.             content_by_lua_block {
  7.                 ngx.req.read_body()
  8.                 local args, err = ngx.req.get_uri_args()
  10.                 local http = require("resty.http")   -- ①
  11.                 local httpc = http.new()
  12.                 local res, err = httpc:request_uri( -- ②
  13.                     "http://127.0.0.1:81/spe_md5",
  14.                         {
  15.                         method = "POST",
  16.                         body = args.data,
  17.                       }
  18.                 )
  20.                 if 200 ~= res.status then
  21.                     ngx.exit(res.status)
  22.                 end
  24.                 if args.key == res.body then
  25.                     ngx.say("valid request")
  26.                 else
  27.                     ngx.say("invalid request")
  28.                 end
  29.             }
  30.         }
  31.     }
  33.     server {
  34.         listen    81;
  36.         location /spe_md5 {
  37.             content_by_lua_block {
  38.                 ngx.req.read_body()
  39.                 local data = ngx.req.get_body_data()
  40.                 ngx.print(ngx.md5(data .. "*&^%$#$^&kjtrKUYG"))
  41.             }
  42.         }
  43.     }
  44. }

重点解释：

  • ① 引用 resty.http 库资源，它来自 github https://github.com/pintsized/lua-resty-http。
  • ② 参考 resty-http 官方 wiki 说明，我们可以知道 request_uri 函数完成了连接池、HTTP 请求等一系列动作。

题外话，为什么这么简单的方法我们还要求助外部开源组件呢？其实我也觉得这个功能太基础了，真的应该集成到 OpenResty 官方包里面，只不过目前官方默认包里还没有。

如果你的内部请求比较少，使用 ngx.location.capture+proxy_pass 的方式还没什么问题。但如果你的请求数量比较多，或者需要频繁的修改上游地址，那么 resty.http就更适合你。

另外 ngx.thread.* 与 resty.http 相互结合也是很不错的玩法，推荐大家有时间研究一下。