nginx upstream模块详解（基础结构篇）

nginx upstream模块对于nginx 最为代理服务器提供了基础功能 结合upstream功能 nginx能对代理进行各种处理

nginx upstream基础数据结构

typedef struct {

    ngx_uint_t                       status;  //http状态码

    ngx_msec_t                     response_time; //上游服务器响应时间

    ngx_msec_t                     connect_time;  //成功连接上游服务器时间

    ngx_msec_t                     header_time; //头部时间耗费 处理完成上游服务器返回头部的时间和响应时间差

    off_t                                response_length;   //http包体和头部总长度

    off_t                                bytes_received; //upstream接收到的字节数

    ngx_str_t                       *peer; //上游服务器地址(ip或名称)

}  ngx_http_upstream_state_t；

state结构体中的成员可以绑定到nginx http变量中 从而可以在nginx access中打印出请求的对应上述变量信息

upstream main作用域可配置信息

typedef struct {

    ngx_hash_t                       headers_in_hash;  //其他模块配置的hash头部信息
    ngx_array_t                      upstreams; //可配置多个upstream

} ngx_http_upstream_main_conf_t;

upstream server结构

typedef struct {

    ngx_str_t                         name;      //server名称
    ngx_addr_t                      *addrs;   //server地址
    ngx_uint_t                       naddrs;   //地址数量
    ngx_uint_t                       weight;   //server对应的权重
    ngx_uint_t                       max_conns;  //指定server最大连接数
    ngx_uint_t                       max_fails;   //允许最多连接失败次数
    time_t                             fail_timeout; //连接超时时间
    ngx_msec_t                     slow_start;  //未使用
    ngx_uint_t                       down; //踢出
    unsigned                         backup:1; //作为备用

    NGX_COMPAT_BEGIN(6)
    NGX_COMPAT_END

} ngx_http_upstream_server_t;

upstream peer结构

typedef struct {
    ngx_http_upstream_init_pt            init_upstream;  //peer配置初始化
    ngx_http_upstream_init_peer_pt   init; //peer初始化
    void                            *data;         //传入的数据地址

} ngx_http_upstream_peer_t;

nginx server作用域配置结构

struct ngx_http_upstream_srv_conf_s {
    ngx_http_upstream_peer_t         peer;     //upstream peer
    void                                         **srv_conf;

    ngx_array_t                               *servers;  

    ngx_uint_t                       flags;  //可支持的标志
    ngx_str_t                        host;    //server主机地址
    u_char                          *file_name;  //conf配置文件名
    ngx_uint_t                       line;   //所在配置文件里行数
    in_port_t                         port;   //端口号
    ngx_uint_t                        no_port; //没有端口号
#if (NGX_HTTP_UPSTREAM_ZONE)

    ngx_shm_zone_t                  *shm_zone; // upstream共享内存

#endif

};

upstream local  上游服务器解析绑定到本机地址

typedef struct {
    ngx_addr_t                                 *addr;
    ngx_http_complex_value_t        *value;
#if (NGX_HAVE_TRANSPARENT_PROXY)
    ngx_uint_t                       transparent; /* unsigned  transparent:1; */
#endif

} ngx_http_upstream_local_t

upstream 可配置结构 可以被其它模块进行配置

typedef struct {
    ngx_http_upstream_srv_conf_t        *upstream;    //upstream server域配置指针
    ngx_msec_t                                       connect_timeout; //连接超时时间
    ngx_msec_t                                       send_timeout;  //可写数据超时时间
    ngx_msec_t                                       read_timeout;  //可读数据超时时间
    ngx_msec_t                                       next_upstream_timeout;  //满足next测试请求到另一台服务器超时时间


    size_t                           send_lowat;  //upstream发送低潮度值 
    size_t                           buffer_size; //nginx buffer缓冲区大小 默认ngx_pagesize大小
    size_t                           limit_rate; //读取upstream速度限制


    size_t                           busy_buffers_size;  // event_pipe "busy" 缓冲区大小  
    size_t                           max_temp_file_size;   //最大临时文件大小 默认1GB
    size_t                           temp_file_write_size;  //event_pipe临时文件写入大小 默认2 * buffer_size


    size_t                           busy_buffers_size_conf;    //busy_buffer配置大小
    size_t                           max_temp_file_size_conf; //最大临时文件配置大小
    size_t                           temp_file_write_size_conf; //临时写入配置大小


    ngx_bufs_t                       bufs; //event_pipe配置的buffer缓冲组

    ngx_uint_t                       ignore_headers;  //upstream配置的可忽略的头部
    ngx_uint_t                       next_upstream;//upstream配置的next请求位
    ngx_uint_t                       store_access; //store指令保存文件的权限
    ngx_uint_t                       next_upstream_tries;// upstream next尝试的次数
    ngx_flag_t                       buffering;  //是否进行buffering缓冲
    ngx_flag_t                       request_buffering; //是否缓存请求包体
    ngx_flag_t                       pass_request_headers; //请求头直接通过
    ngx_flag_t                       pass_request_body; //请求体直接通过


    ngx_flag_t                       ignore_client_abort;  //忽略客户端退出
    ngx_flag_t                       intercept_errors;  //可否被错误拦截
    ngx_flag_t                       cyclic_temp_file; //event_pipe临时文件能否循环使用
    ngx_flag_t                       force_ranges; //是否忽略代理的响应的"Accept-Ranges"


    ngx_path_t                      *temp_path; //临时文件路径


    ngx_hash_t                       hide_headers_hash;  //未使用
    ngx_array_t                     *hide_headers;  //隐藏的头部
    ngx_array_t                     *pass_headers;//允许通过的头部


    ngx_http_upstream_local_t       *local; //本地upstream


#if (NGX_HTTP_CACHE)
    ngx_shm_zone_t                  *cache_zone;   //缓存zone
    ngx_http_complex_value_t        *cache_value; //缓存zone变量


    ngx_uint_t                       cache_min_uses;  //缓存最少使用次数 超出便缓存
    ngx_uint_t                       cache_use_stale; //缓存出错 直接发送缓存中的旧数据
    ngx_uint_t                       cache_methods; //满足条件请求method进行缓存


    off_t                                 cache_max_range_offset; //最大可缓存大小


    ngx_flag_t                         cache_lock;  //是否启用缓存锁
    ngx_msec_t                       cache_lock_timeout;  //缓存锁超时时间
    ngx_msec_t                       cache_lock_age;  //缓存锁时间

    ngx_flag_t                       cache_revalidate;  //缓存信息更新

    ngx_flag_t                       cache_convert_head;  //HEAD变 GET
    ngx_flag_t                       cache_background_update; //缓存后台更新


    ngx_array_t                     *cache_valid; //缓存状态码有效期
    ngx_array_t                     *cache_bypass; //可通过测试的缓存
    ngx_array_t                     *cache_purge; //缓存清理规则
    ngx_array_t                     *no_cache;//不缓存的规则
#endif

    ngx_array_t                     *store_lengths; //保存变量长度数组
    ngx_array_t                     *store_values; //保存变量值数组
#if (NGX_HTTP_CACHE)
    signed                             cache:2; //是否缓存
#endif
    signed                             store:2;
    unsigned                         intercept_404:1; //404配置返回
    unsigned                         change_buffering:1; //buffering开关

#if (NGX_HTTP_SSL || NGX_COMPAT)
    ngx_ssl_t                         *ssl;
    ngx_flag_t                       ssl_session_reuse; //ssl session复用

    ngx_http_complex_value_t        *ssl_name; //ssl名
    ngx_flag_t                                   ssl_server_name;  //ssl 服务器名
    ngx_flag_t                                   ssl_verify;  //ssl校验
#endif


    ngx_str_t                        module;  //模块名
    NGX_COMPAT_BEGIN(2)
    NGX_COMPAT_END

} ngx_http_upstream_conf_t;

upstream上游服务器返回头部处理

typedef struct {

    ngx_str_t                                       name;  //http头部key值
    ngx_http_header_handler_pt       handler; //返回头部处理
    ngx_uint_t                                    offset; //上游服务器返回头部结构成员偏移量
    ngx_http_header_handler_pt       copy_handler; //头部信息拷贝
    ngx_uint_t                                    conf; //http返回头偏移量
    ngx_uint_t                                    redirect;  //是否随上游返回头部x_accel_redirect 跳转

} ngx_http_upstream_header_t

upstream DNS解析结构

typedef struct {
    ngx_str_t                              host;         //主机 可以为IP或者域名
    in_port_t                              port;         //端口
    ngx_uint_t                           no_port;   //无端口标记


    ngx_uint_t                           naddrs;   //解析出的地址数量
    ngx_resolver_addr_t          *addrs;    //解析出的地址信息


    struct sockaddr                 *sockaddr;      //socket地址
    socklen_t                            socklen;     //socket地址长度

    ngx_resolver_ctx_t             *ctx;   //域名解析器上下文

} ngx_http_upstream_resolved_t

upstream在http请求结构

struct ngx_http_upstream_s {
    ngx_http_upstream_handler_pt     read_event_handler;         //读事件处理函数

    ngx_http_upstream_handler_pt     write_event_handler;        //写事件处理函数

    ngx_peer_connection_t                  peer;           //同上游服务器连接描述
    ngx_event_pipe_t                          *pipe;          //event_pipe

    ngx_chain_t                                   *request_bufs;   //请求端产生的bufffer链


    ngx_output_chain_ctx_t                 output;    //输出chain上下文结构
    ngx_chain_writer_ctx_t                   writer;    //upstream写处理链


    ngx_http_upstream_conf_t        *conf;             //upstream配置信息
#if (NGX_HTTP_CACHE)
    ngx_array_t                                *caches;         //缓存数组  可以配置多个缓存目录
#endif


    ngx_http_upstream_headers_in_t   headers_in;      //上游服务器返回的头部数据(已经完成了头部解析)


    ngx_http_upstream_resolved_t    *resolved;           //upstream域名解析结构


    ngx_buf_t                        from_client;      //对请求端而言的upgrage buffer


    ngx_buf_t                        buffer;              //upstream处理上游数据缓冲
    off_t                                length;             //上游数据包体大小


    ngx_chain_t                     *out_bufs;         //响应到请求端的缓冲chain
    ngx_chain_t                     *busy_bufs;       //upstream 处理数据时用缓冲chain
    ngx_chain_t                     *free_bufs;       //空闲的缓冲chain 


    ngx_int_t                      (*input_filter_init)(void *data);            //上游返回的数据filter初始化 主要设置一些状态信息
    ngx_int_t                      (*input_filter)(void *data, ssize_t bytes);   //上游返回的头部数据filter
    void                            *input_filter_ctx;                             //input_filter上下文地址


#if (NGX_HTTP_CACHE)
    ngx_int_t     (*create_key)(ngx_http_request_t *r);          //用于指定缓存key值生成方式
#endif
    ngx_int_t     (*create_request)(ngx_http_request_t *r);         //创建对upstream上游服务器请求
    ngx_int_t     (*reinit_request)(ngx_http_request_t *r);          //重新初始化upstream   处理配置
    ngx_int_t     (*process_header)(ngx_http_request_t *r);       //指定处理上游服务器返回的头部
    void            (*abort_request)(ngx_http_request_t *r);          //指定放弃对上游请求处理
    void            (*finalize_request)(ngx_http_request_t *r,        //指定结束请求处理
                              ngx_int_t rc);
    ngx_int_t     (*rewrite_redirect)(ngx_http_request_t *r,        //upstream返回的refresh跳转
                                         ngx_table_elt_t *h, size_t prefix);
    ngx_int_t      (*rewrite_cookie)(ngx_http_request_t *r,         //返回请求端的cookie值重写
                                         ngx_table_elt_t *h);

    ngx_msec_t              timeout;


    ngx_http_upstream_state_t       *state;        //upstream处理过程的状态信息（可以通过变量打印到日志）


    ngx_str_t                        method;         //到上游服务器的请求方法
    ngx_str_t                        schema;         //协议名
    ngx_str_t                        uri;               
    ngx_str_t                        origin_host;


#if (NGX_HTTP_SSL)
    ngx_str_t                        ssl_name;
#endif

    ngx_http_cleanup_pt             *cleanup;

    unsigned                         store:1;
    unsigned                         cacheable:1;
    unsigned                         accel:1;
    unsigned                         ssl:1;
#if (NGX_HTTP_CACHE)
    unsigned                         cache_status:3;

#endif

    unsigned                         buffering:1;
    unsigned                         keepalive:1;
    unsigned                         upgrade:1;

    unsigned                         request_sent:1;
    unsigned                         request_body_sent:1;
    unsigned                         header_sent:1;
}

//upstream params (由其它模块配置 可以配置多个)

typedef struct {
    ngx_str_t    key;
    ngx_str_t    value;
    ngx_uint_t  skip_empty;  //跳过空格标记

} ngx_http_upstream_param_t

upstream上下游服务器数据处理关键结构 ngx_event_pipe结构详解

upstream 表示上游服务器      downstream 表示下游请求端

event_pipe 可以设置input_filter对上游服务器返回的数据进行处理 同时也能设置output_filter对响应到下游请求端的数据进行处理

struct ngx_event_pipe_s {

    ngx_connection_t  *upstream;            //与上游服务器的tcp连接
    ngx_connection_t  *downstream;       //与下游请求端的tcp连接

    ngx_chain_t       *free_raw_bufs;    //空闲的用于原始数据缓冲链
    ngx_chain_t       *in;                       //输入到event_pipe中的缓冲链
    ngx_chain_t      **last_in;                //缓冲in 最后一个

    ngx_chain_t       *writing;                  //用于将数据写入临时文件的链

    ngx_chain_t       *out;            //用于响应请求端缓冲链
    ngx_chain_t       *free;           //空闲的缓冲链
    ngx_chain_t       *busy;          //正在进行处理的缓冲链

    /*
     * the input filter i.e. that moves HTTP/1.1 chunks

     * from the raw bufs to an incoming chain   */

    ngx_event_pipe_input_filter_pt    input_filter;     //上游服务器返回数据filter
    void                             *input_ctx;  //filter对应的上下文信息

    ngx_event_pipe_output_filter_pt   output_filter;   //响应到请求端的数据filter
    void                             *output_ctx; 

#if (NGX_THREADS)                                                     //线程池相关
    ngx_int_t                       (*thread_handler)(ngx_thread_task_t *task,
                                                      ngx_file_t *file);
    void                              *thread_ctx;
    ngx_thread_task_t        *thread_task;
#endif

    unsigned           read:1;                    //读取状态标记
    unsigned           cacheable:1;           //可缓存标记
    unsigned           single_buf:1;          //单一buf标记 windows iocp下成立
    unsigned           free_bufs:1;           //释放缓冲标记
    unsigned           upstream_done:1;  //上游包体数据读取完毕
    unsigned           upstream_error:1;  //上游数据读取出错标记
    unsigned           upstream_eof:1;   //内核网络缓冲区读取完毕
    unsigned           upstream_blocked:1;  //upstream读取阻塞
    unsigned           downstream_done:1;   //downstream处理完毕
    unsigned           downstream_error:1;   //downstream处理出错
    unsigned           cyclic_temp_file:1;  //复用临时文件标记
    unsigned           aio:1;  //aio异步标记

    ngx_int_t            allocated;   //配置的buffer被分配使用的数量
    ngx_bufs_t         bufs; //配置的的buffer组
    ngx_buf_tag_t    tag;  //buffer的tag标记

    ssize_t                busy_size;   //busy buffer的大小

    off_t                   read_length;  //读取上游数据的长度
    off_t                   length; //动态变化的剩余上游包体长度

    off_t                   max_temp_file_size;     //最大临时文件大小
    ssize_t                temp_file_write_size;     //最大可写入文件大小

    ngx_msec_t        read_timeout;      //上游数据读取超时
    ngx_msec_t        send_timeout;     //下游数据发送超时
    ssize_t                send_lowat;  //设置的想用下游请求的低潮值

    ngx_pool_t        *pool;  //内存池
    ngx_log_t          *log;  

    ngx_chain_t       *preread_bufs;  //预读取upstream 的缓冲chain
    size_t                  preread_size;  //预读取的大小
    ngx_buf_t           *buf_to_file; //将数据写入临时文件所用的缓冲

    size_t                  limit_rate;  //upstream读取限速

    time_t                 start_sec; //event_pipe开始处理的时间

    ngx_temp_file_t  *temp_file;     //临时文件地址

    /* STUB */ int      num;   //STUB信息 buf使用计数
}