Nginx的upstream模块和反向代理(一)

Nginx 因其出色的处理并发连接的能力,越来越多地作为一个反向代理服务器被使用。所谓反向代理,即把Nginx置于用户接入的最前端,监听用户发来的请求,并把 它们转发给相应的后端服务器来处理具体的请求。后端服务器可以是缓存服务器(如Squid)或是处理动态/静态请求的服务器(如apache/Nginx /lighttpd),在这里不作深入讨论。本文对Nginx在upstream服务器的设置和"proxy_pass"的功能在代码层面进行分析,并讨 论在实际生产环境的出现的问题。

 
upstream模块主要有两个命令,"upstream"和"server"。在配置文件里面,大概的结构是这样的:
 
Nginx config代码   收藏代码
  1. http{  
  2.     #...  
  3.     upstream backend_name{  
  4.         server xx.xx.xx.xx:xx weight=2 max_fails=3;  
  5.         server www.xxx.com weight=1;  
  6.         server unix://xxx/xxx;  
  7.         #...  
  8.     }  
  9.     #...  
  10. }  
 
 
其中在"http"命令被解析的时候,会调用ngx_http_block()函数,而在这个函数里面会再次解析配置文件,从而发现"upstream"命令,调用它的set(),即ngx_http_upstream()函数。这个函数是这样的:
 
C代码   收藏代码
  1. ngx_http_upstream(...)  
  2. {  
  3.     //获取upstream服务器组的名字,即upstream命令的参数  
  4.     //...  
  5.     //这个函数初始化一个ngx_http_upstream_srv_conf_t类型,并存入umcf->upstreams数组里面  
  6.     //注意:这个函数还有一个作用,就是在"proxy_pass"的时候从umcf->upstreams找出match的upstream服务器组(不知道为啥要放在同一个函数里><)  
  7.     uscf = ngx_http_upstream_add(...);  
  8.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));  
  9.     //继承main_conf  
  10.     http_ctx = cf->ctx;  
  11.     ctx->main_conf = http_ctx->main_conf;  
  12.     //创建新的srv_conf  
  13.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);  
  14.     //把ngx_http_upstream_add()创建的ngx_http_upstream_srv_conf_t存入srv_conf  
  15.     ctx->srv_conf[ngx_http_upstream_module.ctx_index] = uscf;  
  16.     //虽然uscf本身是一个srv_conf,但是它的成员中也有srv_conf,指向全局的srv_conf  
  17.     uscf->srv_conf = ctx->srv_conf;  
  18.     //创建loc_conf  
  19.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);  
  20.     //for each NGX_HTTP_MODULE  
  21.     for (;;){  
  22.         //if this module has create_srv_conf() ...  
  23.         mconf = module->create_srv_conf(cf);  
  24.         ctx->srv_conf[ngx_modules[m]->ctx_index] = mconf;  
  25.         //if this module has create_loc_conf() ...  
  26.         mconf = module->create_loc_conf(cf);  
  27.         ctx->loc_conf[ngx_modules[m]->ctx_index] = mconf;   
  28.     }  
  29.     cf->ctx = ctx;  
  30.     cf->cmd_type = NGX_HTTP_UPS_CONF;  
  31.     //继续解析server的配置  
  32.     rv = ngx_conf_parse(cf, NULL);  
  33. }  
 
 
继续解析"server"的配置行,每行调用一次:
 
C代码   收藏代码
  1. ngx_http_upstream_server(...)  
  2. {  
  3.     ngx_http_upstream_server_t  *us;  
  4.     us = ngx_array_push(uscf->servers);  
  5.     //获取第一个参数,即url  
  6.     u.url = value[1];  
  7.     u.default_port = 80;  
  8.     ngx_parse_url(cf->pool, &u);  
  9.     //解析"server"后面的其他参数  
  10.     //...  
  11.     //存入us  
  12.     us->addrs = u.addrs;  
  13.     us->naddrs = u.naddrs;  
  14.     us->weight = weight;  
  15.     us->max_fails = max_fails;  
  16.     us->fail_timeout = fail_timeout;  
  17. }  
 
 
在ngx_http_core_module的server {...} block的 /location {...} block里面,如果有"proxy_pass"指令,就会调用它的set(),即ngx_http_proxy_pass():
 
C代码   收藏代码
  1. ngx_http_proxy_pass(...)  
  2. {  
  3.     ngx_http_proxy_loc_conf_t *plcf = conf;  
  4.     //获取当前的location,即在哪个location配置的"proxy_pass"指令  
  5.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);  
  6.     // 设置loc的handler,这个clcf->handler会在ngx_http_update_location_config()里面赋予 r->content_handler,从而在NGX_HTTP_CONTENT_PHASE里面调用这个handler,即 ngx_http_proxy_handler。  
  7.     clcf->handler = ngx_http_proxy_handler;  
  8.       
  9.     //如果"proxy_pass"第一个参数(即url)里面的变量  
  10.     //...  
  11.     //根据http/https设置port和add(位移)  
  12.     //...  
  13.   
  14.     u.url.len = url->len - add;//设置url的长度,除去http://(https://)  
  15.     u.url.data = url->data + add;//设置url,除去http://(https://),比如原来是"http://backend1",现在就是"backend1"  
  16.     u.default_port = port;//默认port  
  17.     u.uri_part = 1;  
  18.     u.no_resolve = 1;//不要resolve这个url的域名  
  19.   
  20.     //这儿从已经定义的upstream服务器组里面找到名字match的组  
  21.     plcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);  
  22.       
  23.     //设置plcf的成员  
  24.     //...  
  25.     //设置location的名字  
  26.     plcf->location = clcf->name;  
  27.     //...  
  28. }  
 
 
那么,当有请求访问到特定的location的时候(假设这个location配置了proxy_pass指令),跟其他请求一样,会调用各个 phase的checker和handler,到了NGX_HTTP_CONTENT_PHASE的checker,即 ngx_http_core_content_phase()的时候,会调用r->content_handler(r),即 ngx_http_proxy_handler
 
C代码   收藏代码
  1. ngx_http_proxy_handler(r)  
  2. {  
  3.     ngx_http_upstream_t        *u;  
  4.   
  5.     //生成一个新的ngx_http_upstream_t,赋值给r->upstream  
  6.     //...  
  7.     ngx_http_upstream_create(r);  
  8.     //设置r->ctx[ngx_http_proxy_module.ctx_index] = ctx  
  9.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_proxy_ctx_t));  
  10.     ngx_http_set_ctx(r, ctx, ngx_http_proxy_module);  
  11.     //获取ngx_http_proxy_loc_conf_t  
  12.     plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);  
  13.       
  14.     //...  
  15.       
  16.     //获取upstream server的信息,如标签、服务器ip、port等  
  17.     u->conf = &plcf->upstream;  
  18.     //生成发送到上游服务器的请求缓冲(或者一条缓冲链)  
  19.     u->create_request = ngx_http_proxy_create_request;  
  20.     //在后端服务器被重置的情况下(在create_request被第二次调用之前)被调用  
  21.     u->reinit_request = ngx_http_proxy_reinit_request;  
  22.     //处理上游服务器回复的第一个bit,时常是保存一个指向上游回复负载的指针  
  23.     u->process_header = ngx_http_proxy_process_status_line;  
  24.     //在客户端放弃请求的时候被调用  
  25.     u->abort_request = ngx_http_proxy_abort_request;  
  26.     //在Nginx完成从上游服务器读入回复以后被调用  
  27.     u->finalize_request = ngx_http_proxy_finalize_request;  
  28.       
  29.     //...  
  30.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));  
  31.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;  
  32.   
  33.     ngx_http_read_client_request_body(r, ngx_http_upstream_init);  
  34.     //没有special response  
  35.     return NGX_DONE;//-4  
  36. }  
 
 
ngx_http_read_client_request_body()里面会调用post_handler()即ngx_http_upstream_init():
 
C代码   收藏代码
  1. ngx_http_upstream_init(r)  
  2. {  
  3.     //...  
  4.     //如果是edge trigger事件机制(epoll/kqueue),添加一个NGX_WRITE_EVENT  
  5.     //这个事件用来检查与用户的连接是否断开  
  6.     ngx_add_event(c->write, NGX_WRITE_EVENT, NGX_CLEAR_EVENT);  
  7.     ngx_http_upstream_init_request(r);  
  8. }  
 
 
C代码   收藏代码
  1. ngx_http_upstream_init_request(r)  
  2. {  
  3.     ngx_http_upstream_t  *u;  
  4.     u = r->upstream;  
  5.     //设置r->read_event_handler和r->write_event_handler为事件调用函数  
  6.     r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;  
  7.     r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;  
  8.     //把用户来的request内容(如请求行,headers)放到r->upstream的成员变量中  
  9.     //如r->upstream->url存放请求的url  
  10.     //把请求(包括请求行,headers)放入r->upstream->request_bufs这个buf chain  
  11.     u->create_request(r);  
  12.   
  13.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);  
  14.     //初始化u->output(ngx_output_chain_ctx_s类型)  
  15.     u->output.alignment = clcf->directio_alignment;  
  16.     u->output.pool = r->pool;  
  17.     u->output.bufs.num = 1;  
  18.     u->output.bufs.size = clcf->client_body_buffer_size;  
  19.     u->output.output_filter = ngx_chain_writer;  
  20.     u->output.filter_ctx = &u->writer;  
  21.     u->writer.pool = r->pool;  
  22.   
  23.     //创建state(ngx_http_upstream_state_t类型)  
  24.     //...  
  25.   
  26.     //添加一个cleanup处理方法  
  27.     ngx_http_cleanup_add(r,0);  
  28.     cln->handler = ngx_http_upstream_cleanup;  
  29.     cln->data = r;  
  30.     u->cleanup = &cln->handler;  
  31.   
  32.     //获取ngx_http_upstream_srv_conf_t  
  33.     uscf = u->conf->upstream;  
  34.     ngx_http_upstream_connect(r,u);  
  35. }  
 
 
C代码   收藏代码
  1. ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)  
  2. {  
  3.     u->state = ngx_array_push(r->upstream_states);  
  4.     //获取时间,存入u->state  
  5.     //...  
  6.   
  7.     //创建一个socket,调用ngx_get_connection()获取一个空闲的connection并初始化  
  8.     //把这个connection添加到事件监听,并bind()以及connect()到peer  
  9.     //不等建立连接,直接返回,一般返回值EINPROGRESS,表示正在进行中  
  10.     rc = ngx_event_connect_peer(&u->peer);  
  11.       
  12.     c = u->peer.connection;  
  13.     c->data = r;  
  14.     c->write->handler = ngx_http_upstream_handler;  
  15.     c->read->handler = ngx_http_upstream_handler;  
  16.     u->write_event_handler = ngx_http_upstream_send_request_handler;  
  17.     u->read_event_handler = ngx_http_upstream_process_header;  
  18.     c->sendfile &= r->connection->sendfile;  
  19.     u->output.sendfile = c->sendfile;  
  20.     //init or reinit the ngx_output_chain() and ngx_chain_writer() contexts  
  21.     //...  
  22.   
  23.     //rc == NGX_AGAIN,连接进行中  
  24.     ngx_add_timer(c->write, u->conf->connect_timeout);  
  25.       
  26.     //rc == NGX_OK,连接成功  
  27.     ngx_http_upstream_send_request();  
  28. }  
 
 
返回之后就进入了ngx_http_finalize_request() --> ngx_http_finalize_connection() --> ngx_http_close_request(),但是不会关闭客户端的连接。然后触发一个EPOLLOUT事件(发生在和用户的连 接),进入ngx_http_request_handler()。这个事件是在ngx_http_upstream_init()里面添加的。而这个事 件处理函数在ngx_http_process_request()里面设置。这个函数很简单:
 
C代码   收藏代码
  1. ngx_http_request_handler(ngx_event_t *ev)  
  2. {  
  3.     c = ev->data;  
  4.     r = c->data;  
  5.     //if...  
  6.     r->write_event_handler(r);  
  7.     //else...  
  8.     r->read_event_handler(r);  
  9.     //subrequest...  
  10.     ngx_http_run_posted_requests(c);  
  11. }  
 
 
ngx_http_upstream_init_request()里面设置了r->read_event_handler 和r->write_event_handler,它们都指向 ngx_http_upstream_check_broken_connection,那么在上面的函数里,就会调用这个函数。它主要是检查与用户的连 接是否断开。
 
C代码   收藏代码
  1. ngx_http_upstream_check_broken_connection(r,ev)  
  2. {  
  3.     c = r->connection;  
  4.     u = r->upstream;  
  5.   
  6.     n = recv(c->fd, buf, 1, MSG_PEEK);  
  7.     //...  
  8.     //正常err应该是NGX_EAGAIN(11)  
  9.     err = ngx_socket_errno;  
  10.     //...  
  11. }  
 
 
处理完之后,另外一个事件也同时触发(在epoll处理事件循环里),是之前跟upstream建立的连接的写事件(向upstream服务器 发送)。调用c->write->handler即ngx_http_upstream_handler()。这个是在之前 ngx_http_upstream_connect()里面设置的:
 
C代码   收藏代码
  1. ngx_http_upstream_handler(ev)  
  2. {  
  3.     c = ev->data;  
  4.     r = c->data;  
  5.     u = r->upstream;  
  6.     c = r->connection;  
  7.     //if...  
  8.     u->write_event_handler(r, u);  
  9.     //else...  
  10.     u->read_event_handler(r, u);  
  11.     //subrequest...  
  12.     ngx_http_run_posted_requests(c);  
  13. }  
 
 
ngx_http_upstream_connect(),我们知道 u->write_event_handler = ngx_http_upstream_send_request_handler,这个函数主要调用了ngx_http_upstream_send_request()函数:
 
C代码   收藏代码
  1. ngx_http_upstream_send_request(r,u)  
  2. {  
  3.     c = u->peer.connection;  
  4.     //向后端发送请求  
  5.     rc = ngx_output_chain(&u->output, u->request_sent ? NULL : u->request_bufs);  
  6.     u->write_event_handler = ngx_http_upstream_dummy_handler;  
  7. }  
 
 
当后端(upstream)服务器处理完请求之后,会发回响应,这个时候事件被触发。再次调用 ngx_http_upstream_handler(),这次调用 u->read_event_handler,即 ngx_http_upstream_process_header():
 
C代码   收藏代码
  1. ngx_http_upstream_process_header(r,u)  
  2. {  
  3.     //...  
  4.   
  5.     for ( ;; ) {  
  6.         n = c->recv(c, u->buffer.last, u->buffer.end - u->buffer.last);  
  7.         //u->process_header = ngx_http_proxy_process_status_line  
  8.         //还调用了ngx_http_proxy_process_header(),处理回复的headers  
  9.         rc = u->process_header(r);  
  10.     }  
  11.     ngx_http_upstream_process_headers();  
  12.     //如果subrequest_in_memory == 0  
  13.     ngx_http_upstream_send_response(r, u);  
  14.   
  15.     //else...  
  16.     //...  
  17. }  
 
 
C代码   收藏代码
  1. ngx_http_upstream_send_response(r,u)  
  2. {  
  3.     //调用ngx_http_top_header_filter即ngx_http_header_filter()  
  4.     //ngx_http_header_filter()中会调用ngx_http_write_filter()  
  5.     //ngx_http_write_filter()遍历所有chain,然后输出所有数据  
  6.     rc = ngx_http_send_header(r);  
  7.   
  8.     //...  
  9.   
  10.     u->read_event_handler = ngx_http_upstream_process_upstream;  
  11.     r->write_event_handler = ngx_http_upstream_process_downstream;  
  12.       
  13.     ngx_http_upstream_process_upstream(r, u);  
  14. }  
 
 
C代码   收藏代码
  1. ngx_http_upstream_process_upstream(r,u)  
  2. {  
  3.     c = u->peer.connection;  
  4.     //如果没有timeout  
  5.     //  
  6.     ngx_event_pipe(u->pipe, 0);  
  7. }  

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值