Nginx:访问第三方服务

参考资料<深入理解Nginx>

Nginx可以当做一个强大的反向代理服务器，其反向代理模块是基于upstream方式实现的。

upstream的使用方式

HTTP模块在处理任何一个请求时都有一个ngx_http_request_t结构对象r，而该对象又有一个ngx_http_upstream_t类型的成员upstream。

typedef struct ngx_http_request_s ngx_http_request_t
struct ngx_http_request_s {
    ...
    ngx_http_upstream_t *upstream;
    ...
};

如果要启用upstream机制，那么关键就在于如何设置r->upstream成员。

1.启用upstream机制

下图列出了使用HTTP模块启用upstream机制的示意图：

下面给出我们的mytest模块的ngx_http_mytest_handler方法中启动upstream机制的大概流程

static ngx_int_t
ngx_http_mytest_handler(ngx_http_request_t *r)
{
    ...
    //创建upstream，创建之前r->upstream==NULL;
    ngx_http_upstream_create(r);
    ngx_http_upstream_t *u=r->upstream;
    //设置第三方服务器地址(通过设置resovled成员)
    u->resolved->sockaddr=..;
    u->resolved->socklen=...;
    u->resolved->naddrs=;
    //设置upstream的回调方法(后面有这3个方法的描述)
    u->create_request=...;
    u->process_header=...;
    u->finalize_request=...;
    //启动upstream
    ngx_http_upstream_init(r);
    return NGX_DONE;
}

2.upstream的回调方法

upstream有最常用的3个回调方法:create_request、process_header、finalize_request。

create_request回调方法

下图演示了create_request的回调场景。该回调方法一般用来创建发送给上游服务器的HTTP请求(通过设置r->upstream->request_buf)。

process_header回调方法

process_header负责解析上游服务器发来的基于TCP的包头。

当process_header回调方法返回NGX_OK后，upstream模块开始把上游的包体直接转发到下游客户端。

finalize_request回调方法

当请求结束后，将会回调finalize_request方法来释放资源。

需要的数据结构

在编写我们的mytest模块之前应该先了解一下该模块需要的一些数据结构

1.ngx_http_upstream_t结构体

typedef ngx_http_upstream_s ngx_http_upstream_t;
struct ngx_http_upstream_s {
    ...
    //决定发送什么样的请求给上游服务器，在实现create_request方法时需要设置它
    ngx_chain_t request_bufs;
    //upstream访问时的所有限制性参数
    ngx_http_upstream_conf_t conf;
    //通过resolved可以直接指定上游服务器地址
    ngx_http_upstream_resolved_t resolved;
　  /*
       用于存储接收来自上游服务器的响应内容，由于它会被复用，所以具有多种意义，如:
       a.在process_header方法解析上游响应的包头时，buffer中将会保存完整的相应包头
       b.当buffering标志位为0时,buffer缓冲区被用于反复接收上游的包体，进而向下游转发
    */
    ngx_buf_t buffer;

    //3个必须的回调方法，详情可以查看上面
    ngx_int_t (*create_request)(ngx_http_request_t *r);
    ngx_int_t (*process_header)(ngx_http_request_t *r);
    void (*finalize_request) (ngx_http_request_t *r,ngx_int_t rc);

    unsigned buffering:1;
    ...
};

2.ngx_http_upstream_conf_t结构体

在我们的mytest模块中所有的请求将共享同一个ngx_http_upstream_conf_结构体。在ngx_http_mytest_create_loc_conf方法中创建跟初始化。

typedef struct{
    ngx_http_upstream_conf_t upstream;
} ngx_http_mytest_conf_t;

在启动upstream前，先将ngx_http_mytest_conf_t下的upstream成员赋给r->upstream->conf成员。

3.请求上下文

因为Nginx是异步非阻塞的，导致upstream上游服务器的响应包并不是一次性就接收跟解析好的，因此需要上下文才能正确地解析upstream上游服务器的响应包。

在解析HTTP响应行时，可以使用HTTP框架提供的ngx_http_status_t结构：

typedef struct {
    ngx_uint_t code;
    ngx_uint_t count;
    u_char *start;
    u_char *end;
} ngx_http_status_t;

把ngx_http_status_t结构放到上下文中，并在process_header解析响应行时使用

typedef struct {
    ngx_http_status_t   status;
    ngx_str_t           backendServer;
} ngx_http_mytest_ctx_t;

mytest模块的完整代码

mytest模块指定的上游服务器是www.baidu.com。在nginx.conf应该这样配置

location /test {
    mytest;
}

如果我们的请求是/test?lumia，该模块将会把它转化为www.baidu.com的搜索请求/s?wd=lumia，然后返回结果给客户端。

 #include <ngx_config.h>
 #include <ngx_core.h>
 #include <ngx_http.h>

 //所有的请求都将共享同一个ngx_http_upstream_conf_t结构体
 typedef struct{
     ngx_http_upstream_conf_t upstream;
 } ngx_http_mytest_conf_t;

 //HTTP请求的上下文
 typedef struct {
     ngx_http_status_t status;
     ngx_str_t backendServer;
 } ngx_http_mytest_ctx_t;

 //默认设置
 static ngx_str_t  ngx_http_proxy_hide_headers[] =
 {
     ngx_string("Date"),
     ngx_string("Server"),
     ngx_string("X-Pad"),
     ngx_string("X-Accel-Expires"),
     ngx_string("X-Accel-Redirect"),
     ngx_string("X-Accel-Limit-Rate"),
     ngx_string("X-Accel-Buffering"),
     ngx_string("X-Accel-Charset"),
     ngx_null_string
 };

 //部分函数的声明
 static ngx_int_t
 mytest_upstream_process_header(ngx_http_request_t *r);
 static char *
 ngx_http_mytest(ngx_conf_t *cf,ngx_command_t *cmd,void *conf);
 static ngx_int_t
 ngx_http_mytest_handler(ngx_http_request_t *r);

 //设置配置项
 static ngx_command_t ngx_http_mytest_commands[]={
     {
         //配置项名称
         ngx_string("mytest"),
         //配置项类型(可出现的位置，参数的个数)
         NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LMT_CONF|NGX_CONF_NOARGS,
         //出现了name中指定的配置项后，将会调用该方法处理配置项的参数
         ngx_http_mytest,
         NGX_HTTP_LOC_CONF_OFFSET,
         ,
         NULL
     },
     ngx_null_command
 };

 //处理出现mytest配置项时处理方法(挂载handler函数)
 static char *
 ngx_http_mytest(ngx_conf_t *cf,ngx_command_t *cmd,void *conf)
 {
     //找到mytest配置项所属的配置块
     ngx_http_core_loc_conf_t *clcf;
     clcf=ngx_http_conf_get_module_loc_conf(cf,ngx_http_core_module);
     /*
         HTTP框架在处理用户请求进行到NGX_HTTP_CONTENT_PHASE阶段时
         如果请求的主机域名、URI与mytest配置项所在的配置块相匹配，
         就将调用我们事先的ngx_http_mytest_handler方法处理这个请求
     */
     clcf->handler=ngx_http_mytest_handler;
     return NGX_CONF_OK;
 }

 //创建并初始化mytest模块对应的结构体ngx_http_mytest_conf;
 static void *ngx_http_mytest_create_loc_conf(ngx_conf_t *cf)
 {
     ngx_http_mytest_conf_t *mycf;
     mycf=(ngx_http_mytest_conf_t *)ngx_pcalloc(cf->pool,sizeof(ngx_http_mytest_conf_t));
     if(mycf==NULL){
         return NULL;
     }

     //设置ngx_http_upstream_conf_t结构中的各成员
     mycf->upstream.connect_timeout=;
     mycf->upstream.read_timeout=;
     mycf->upstream.send_timeout=;
     mycf->upstream.store_access=;

     mycf->upstream.buffering=;
     mycf->upstream.bufs.num=;
     mycf->upstream.bufs.size=ngx_pagesize;
     mycf->upstream.buffer_size=ngx_pagesize;
     mycf->upstream.busy_buffers_size= * ngx_pagesize;
     mycf->upstream.temp_file_write_size= * ngx_pagesize;
     mycf->upstream.max_temp_file_size= *  *;

     mycf->upstream.hide_headers=NGX_CONF_UNSET_PTR;
     mycf->upstream.pass_headers=NGX_CONF_UNSET_PTR;
     return mycf;
 }

 /*
     upstream模块要求hide_headers不可以为NULL。提供了ngx_http_upstream_hide_headers_hash方法来初始化该成员，
     但仅可用在合并配置项的方法内，因此该方法用于初始化hide_headers成员
 */

 static char *ngx_http_mytest_merge_loc_conf(ngx_conf_t *cf,void *parent,void *child)
 {
     ngx_http_mytest_conf_t *prev=(ngx_http_mytest_conf_t *)parent;
     ngx_http_mytest_conf_t *conf=(ngx_http_mytest_conf_t *)child;

     ngx_hash_init_t hash;
     hash.max_size=;
     hash.bucket_size=;
     hash.name="proxy_headers_hash";
     if(ngx_http_upstream_hide_headers_hash(cf,&conf->upstream,
       &prev->upstream,ngx_http_proxy_hide_headers,&hash)!=NGX_OK)
     {
         return NGX_CONF_ERROR;
     }
     return NGX_CONF_OK;
 }

 //HTTP模块的定义
 static ngx_http_module_t ngx_http_mytest_module_ctx={
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
     ngx_http_mytest_create_loc_conf,
     ngx_http_mytest_merge_loc_conf
 };

 //mytest模块的定义
 ngx_module_t ngx_http_mytest_module={
     NGX_MODULE_V1,
     //指向ngx_http_module_t结构体
     &ngx_http_mytest_module_ctx,
     //用来处理nginx.conf中的配置项
     ngx_http_mytest_commands,
     //表示该模块的类型
     NGX_HTTP_MODULE,
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
     NGX_MODULE_V1_PADDING
 };

 //创建发往google上游服务器的请求
 static ngx_int_t
 mytest_upstream_create_request(ngx_http_request_t *r)
 {
     //backendQueryLine为format字符串
     static ngx_str_t backendQueryLine=
                     ngx_string("GET /s?wd=%V HTTP/1.1\r\nHost:www.baidu.com\r\nConnection:close\r\n\r\n");
     ngx_int_t queryLineLen=backendQueryLine.len+r->args.len-;
     ngx_buf_t *b=ngx_create_temp_buf(r->pool,queryLineLen);
     //last指向请求的末尾
     b->last=b->pos+queryLineLen;
     ngx_snprintf(b->pos,queryLineLen,(char *)backendQueryLine.data,&r->args);
     //r->upstream->request_bufs包含要发送给上游服务器的请求
     r->upstream->request_bufs=ngx_alloc_chain_link(r->pool);
     if(r->upstream->request_bufs==NULL)
         return NGX_ERROR;
     r->upstream->request_bufs->buf=b;
     r->upstream->request_bufs->next=NULL;

     r->upstream->request_sent=;
     r->upstream->header_sent=;
     r->header_hash=;
     return NGX_OK;
 }

 //解析HTTP响应行
 static ngx_int_t
 mytest_process_status_line(ngx_http_request_t *r)
 {
     size_t len;
     ngx_int_t rc;
     ngx_http_upstream_t *u;
     //取出请求的上下文
     ngx_http_mytest_ctx_t *ctx=ngx_http_get_module_ctx(r,ngx_http_mytest_module);
     if(ctx==NULL){
         return NGX_ERROR;
     }

     u=r->upstream;
     //ngx_http_parse_status_line方法可以解析HTTP响应行
     rc=ngx_http_parse_status_line(r,&u->buffer,&ctx->status);
     //返回NGX_AGAIN时，表示还没有解析出完整的HTTP响应行
     if(rc==NGX_AGAIN){
         return rc;
     }
     //返回NGX_ERROR时，表示没有接收到合法的HTTP响应行
     if(rc==NGX_ERROR){
         ngx_log_error(NGX_LOG_ERR,r->connection->log,,
                       "upstream sent no valid HTTP/1.0 header");
         r->http_version=NGX_HTTP_VERSION_9;
         u->state->status=NGX_HTTP_OK;
         return NGX_OK;
     }
     //解析到完整的HTTP响应行
     if(u->state){
         u->state->status=ctx->status.code;
     }
     //将解析出的信息设置到r->upstream->headers_in结构体中。
     u->headers_in.status_n=ctx->status.code;
     len=ctx->status.end - ctx->status.start;
     u->headers_in.status_line.len=len;
     u->headers_in.status_line.data=ngx_pnalloc(r->pool,len);
     if(u->headers_in.status_line.data==NULL){
         return NGX_ERROR;
     }
     ngx_memcpy(u->headers_in.status_line.data,ctx->status.start,len);

     //下一步将开始解析HTTP头部。设置process_header回调方法之后在收到的新字符流将由mytest_upstream_process_header解析
     u->process_header=mytest_upstream_process_header;
     return mytest_upstream_process_header(r);
 }

 //解析HTTP响应头
 static ngx_int_t
 mytest_upstream_process_header(ngx_http_request_t *r)
 {
     ngx_int_t rc;
     ngx_table_elt_t *h;
     ngx_http_upstream_header_t *hh;
     ngx_http_upstream_main_conf_t *umcf;

     umcf=ngx_http_get_module_main_conf(r,ngx_http_upstream_module);

     //循环地解析所有的HTTP头部
     for(;;){
         //HTTP框架提供的ngx_http_parse_header_line方法，用于解析HTTP头部
         rc=ngx_http_parse_header_line(r,&r->upstream->buffer,);
         //返回NGX_OK时，表示解析出一行HTTP头部
         if(rc==NGX_OK){
             //向headers_in.headers这个ngx_list_t链表中添加HTTP头部
             h=ngx_list_push(&r->upstream->headers_in.headers);
             if(h==NULL){
                 return NGX_ERROR;
             }
             //构造刚刚添加的headers链表中的HTTP头部
             h->hash=r->header_hash;
             h->key.len=r->header_name_end - r->header_name_start;
             h->value.len=r->header_end - r->header_start;
             //分配存放HTTP头部的内存空间
             h->key.data=ngx_pnalloc(r->pool,
                 h->key.len++h->value.len++h->key.len);
             if(h->key.data==NULL){
                 return NGX_ERROR;
             }
             h->value.data=h->key.data + h->key.len + ;
             h->lowcase_key=h->key.data+h->key.len++h->value.len+;

             ngx_memcpy(h->key.data,r->header_name_start,h->key.len);
             h->key.data[h->key.len]='\0';
             ngx_memcpy(h->value.data,r->header_start,h->value.len);
             h->value.data[h->value.len]='\0';

             if(h->key.len==r->lowcase_index){
                 ngx_memcpy(h->lowcase_key,r->lowcase_header,h->key.len);
             }else{
                 ngx_strlow(h->lowcase_key,h->key.data,h->key.len);
             }

             //upstream模块会对一些HTTP头部做特殊处理
             hh=ngx_hash_find(&umcf->headers_in_hash,h->hash,
                              h->lowcase_key,h->key.len);
             if(hh&&hh->handler(r,h,hh->offset)!=NGX_OK){
                 return NGX_OK;
             }
             continue;
         }
         //返回NGX_HTTP_PARSE_HEADER_DONE时，表示响应中所有的HTTP头部全部解析完毕
         if(rc==NGX_HTTP_PARSE_HEADER_DONE){
             //根据HTTP协议规定添加两个头部
             if(r->upstream->headers_in.server==NULL){
                 h=ngx_list_push(&r->upstream->headers_in.headers);
                 if(h==NULL){
                     return NGX_ERROR;
                 }
                 h->hash=ngx_hash(ngx_hash(ngx_hash(ngx_hash(
                                  ngx_hash('s','e'),'r'),'v'),'e'),'r');
                 ngx_str_set(&h->key,"Server");
                 ngx_str_null(&h->value);
                 h->lowcase_key=(u_char *)"server";
             }
             if(r->upstream->headers_in.date==NULL){
                 h=ngx_list_push(&r->upstream->headers_in.headers);
                 if(h==NULL){
                     return NGX_ERROR;
                 }
                 h->hash=ngx_hash(ngx_hash(ngx_hash('d','a'),'t'),'e');
                 ngx_str_set(&h->key,"Date");
                 ngx_str_null(&h->value);
                 h->lowcase_key=(u_char *)"date";
             }
             return NGX_OK;
         }
         //如果返回NGX_AGAIN，表示还没有解析到完整的HTTP头部
         if(rc==NGX_AGAIN){
             return NGX_AGAIN;
         }
         //其他返回值都是非法的
         ngx_log_error(NGX_LOG_ERR,r->connection->log,,
                       "upstream sent invalid header");
         return NGX_HTTP_UPSTREAM_INVALID_HEADER;

     }
 }

 //释放资源
 static void
 mytest_upstream_finalize_request(ngx_http_request_t *r,ngx_int_t rc)
 {
     ngx_log_error(NGX_LOG_DEBUG,r->connection->log,,
                   "mytest_upstream_finalize_request");
 }

 //handler函数
 static ngx_int_t ngx_http_mytest_handler(ngx_http_request_t *r)
 {
     //首先建立HTTP上下文结构ngx_http_mytest_ctx_t
     ngx_http_mytest_ctx_t *myctx=ngx_http_get_module_ctx(r,ngx_http_mytest_module);
     if(myctx==NULL){
         myctx=ngx_palloc(r->pool,sizeof(ngx_http_mytest_ctx_t));
         if(myctx==NULL){
             return NGX_ERROR;
         }
         //将新建的上下文与请求关联起来
         ngx_http_set_ctx(r,myctx,ngx_http_mytest_module);
     }
     //初始化r->upstream成员
     if(ngx_http_upstream_create(r)!=NGX_OK){
         ngx_log_error(NGX_LOG_ERR,r->connection->log,,
                       "ngx_http_upstream create() failed");
         return NGX_ERROR;
     }
     //得到配置结构体ngx_http_mytest_conf_t
     ngx_http_mytest_conf_t *mycf=(ngx_http_mytest_conf_t *)
                                 ngx_http_get_module_loc_conf(r,ngx_http_mytest_module);
     ngx_http_upstream_t *u=r->upstream;
     //用配置文件中的结构体来赋给r->upstream->conf成员
     u->conf=&mycf->upstream;
     //决定转发包体时使用的缓冲区
     u->buffering=mycf->upstream.buffering;

     //初始化resolved结构体，用来保存上游服务器的地址
     u->resolved=(ngx_http_upstream_resolved_t *)ngx_pcalloc(r->pool,sizeof(ngx_http_upstream_resolved_t));
     if(u->resolved==NULL){
         ngx_log_error(NGX_LOG_ERR,r->connection->log,,
                       "ngx_pcalloc resolved error. %s.",strerror(errno));
         return NGX_ERROR;
     }

     //设置上游服务器地址
     static struct sockaddr_in backendSockAddr;
     struct hostent *pHost=gethostbyname((char *)"www.baidu.com");
     if(pHost==NULL){
         ngx_log_error(NGX_LOG_ERR,r->connection->log,,
                       "gethostbyname fail. %s",strerror(errno));
         return NGX_ERROR;
     }

     //访问上游服务器的80端口
     backendSockAddr.sin_family=AF_INET;
     backendSockAddr.sin_port=htons((in_port_t));
     char *pDmsIP=inet_ntoa(*(struct in_addr *)(pHost->h_addr_list[]));
     backendSockAddr.sin_addr.s_addr=inet_addr(pDmsIP);
     myctx->backendServer.data=(u_char *)pDmsIP;
     myctx->backendServer.len=strlen(pDmsIP);

     //将地址设置到resolved成员中
     u->resolved->sockaddr=(struct sockaddr *)&backendSockAddr;
     u->resolved->socklen=sizeof(struct sockaddr_in);
     u->resolved->naddrs=;

     //设置3个必须实现的回调方法
     u->create_request=mytest_upstream_create_request;
     u->process_header=mytest_process_status_line;
     u->finalize_request=mytest_upstream_finalize_request;

     //告诉HTTP框架暂时不要销毁请求
     r->main->count++;

     //启动upstream
     ngx_http_upstream_init(r);
     //必须返回NGX_DONE
     return NGX_DONE;

 }