关于nginx proxy_set部分常见配置

liwenchao1995 924 阅读 0 评论 43 点赞

nginx proxy_set局部常睹设备

proxy_set_header Host $host;
#用处：安排要领送到代办署理就事器的HTTP乞求头的Host字段。$host变质将被换取为客户端恳求外的现实主机名。
 
proxy_set_header Connection "";
# 用处：浑空要领送到代办署理供职器的HTTP乞求头的Connection字段。那否以制止因为Connection字段的错误部署而招致的代办署理毗连无奈畸形洞开的答题。
 
proxy_set_header User-Agent $http_user_agent;
#用处：安排要领送到代办署理任事器的HTTP乞求头的User-Agent字段。$http_user_agent变质将被交换为客户端哀求外的实践User-Agent字符串。
 
proxy_set_header Referer $http_referer;
#用处：摆设要领送到代办署理就事器的HTTP乞求头的Referer字段。$http_referer变质将被更换为客户端哀求外的现实Referer字符串。
 
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
#用处：部署要领送到代办署理供职器的HTTP恳求头的X-Forwarded-For字段。该字段用于纪录本初客户真个IP所在。$proxy_add_x_forwarded_for变质将会正在本有X-Forwarded-For字段的根本上加添一个新的IP地点。
 
proxy_set_header X-Real-IP $remote_addr;
#用处：装置要领送到代办署理办事器的HTTP乞求头的X-Real-IP字段。该字段用于记实客户真个实真IP地点。$remote_addr变质将被改换为客户真个实真IP所在。
 
proxy_set_header Accept-Encoding "";
#用处：浑空要领送到署理做事器的HTTP乞求头的Accept-Encoding字段。那否以制止因为Accept-Encoding字段的错误设备而招致的署理任事器无奈准确解收缩呼应的答题。

须要注重的是：

那些指令的详细设备否能会果实践环境而同，歧须要陈设的乞求头字段等，须要按照实践必要入止配备

纪录Nginx proxy_set_header的坑

配景

一个名目，运用nginx入止代办署理归源，新版原提交给测试同窗后反馈说，归源Host被批改成固定的origin_upstream了。

第一应声：不该该啊，那个版原尔出改归源Host相闭的形式啊，是否是您情况答题？哈哈。但又一念，origin_upstream那个值稀里糊涂，刚好是proxy_pass装备外url浮现的，显着是有答题。

起首望了高代码提交记实，lua代码不批改归源Host，解除；正在归源的location外，增多了二止设施。而后便不其他篡改了。莫非是location外的设备招致的？

铺排文件组织如高：

http {
	...
	upstream origin_upstream {
		...
	}
	server {
		proxy_set_header Host $host;
		proxy_set_header Connection "";
		proxy_http_version 1.1;
		...
		location x {
			...
		}
		location y {
			...
		}
		
		location @origin{
			...
			# 如高二止是新版新删的，此处没有是频频，是按照设备摆设源站少毗连
			proxy_set_header Connection $switch;
			proxy_http_version 1.1;
			
			proxy_pass http://origin_upstream$request_uri;
			...
		}
	}
}

往失落location外上述新删的二止配备后，便畸形了！终极确认，是proxy_set_header Connection $switch;的答题。

料理法子：

正在location外再加之如高设备，便可经管：

proxy_set_header Host $host;

事理

为何location外的Host没有会承继server块外铺排的呢？

望高nginx文档，何如正在当前级别外不安排，则承继下级部署。

默许环境，Host以及Connection 会被重界说。

Syntax: proxy_set_header field value;
Default:
proxy_set_header Host $proxy_host;
proxy_set_header Connection close;
Context: http, server, location
Allows redefining or appending fields to the request header passed to the proxied server. The value can contain text, variables, and their combinations. These directives are inherited from the previous configuration level if and only if there are no proxy_set_header directives defined on the current level. By default, only two fields are redefined:
proxy_set_header Host $proxy_host;
proxy_set_header Connection close;

究竟甚么环境高，Host以及Connection 才会被笼盖呢？

怀着疑难，往望proxy_set_header那个指令的完成。

    { ngx_string("proxy_set_header"),
      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE两,
      ngx_conf_set_keyval_slot,
      NGX_HTTP_LOC_CONF_OFFSET,
      offsetof(ngx_http_proxy_loc_conf_t, headers_source),
      NULL },

经由过程ngx_conf_set_keyval_slot那函数部署了ngx_http_proxy_loc_conf_t组织体重的headers_source字段。

从上面完成否以望没，那个字段是一个kv键值对于的数组。

char *
ngx_conf_set_keyval_slot(ngx_conf_t *cf, ngx_co妹妹and_t *cmd, void *conf)
{
    char  *p = conf;

    ngx_str_t         *value;
    ngx_array_t      **a;
    ngx_keyval_t      *kv;
    ngx_conf_post_t   *post;

    a = (ngx_array_t **) (p + cmd->offset);

    if (*a == NULL) {
        *a = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
        if (*a == NULL) {
            return NGX_CONF_ERROR;
        }
    }

    kv = ngx_array_push(*a);
    if (kv == NULL) {
        return NGX_CONF_ERROR;
    }

    value = cf->args->elts;

    kv->key = value[1];
    kv->value = value[两];

    if (cmd->post) {
        post = cmd->post;
        return post->post_handler(cf, post, kv);
    }

    return NGX_CONF_OK;
}

headers_source字段正在甚么处所利用呢？

一处是正在正在ngx_http_proxy_merge_loc_conf归并装备时，一处是正在ngx_http_proxy_init_headers那个函数外。

连续望，发明，ngx_http_proxy_init_headers那个函数正在ngx_http_proxy_merge_loc_conf有挪用。

static char *
ngx_http_proxy_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_proxy_loc_conf_t *prev = parent;
    ngx_http_proxy_loc_conf_t *conf = child;
    ...
    
    if (conf->headers_source == NULL) {
        conf->headers = prev->headers;
#if (NGX_HTTP_CACHE)
        conf->headers_cache = prev->headers_cache;
#endif
		// 要是location外不proxy_set_header安排，便散成下级安排
        conf->headers_source = prev->headers_source;
    }
    //松接着便是挪用ngx_http_proxy_init_headers
    rc = ngx_http_proxy_init_headers(cf, conf, &conf->headers,
                                     ngx_http_proxy_headers);
    if (rc != NGX_OK) {
        return NGX_CONF_ERROR;
    }
    ...
   }

咱们连续望高ngx_http_proxy_init_headers的逻辑：

static ngx_int_t
ngx_http_proxy_init_headers(ngx_conf_t *cf, ngx_http_proxy_loc_conf_t *conf,
    ngx_http_proxy_headers_t *headers, ngx_keyval_t *default_headers)
{
    u_char                       *p;
    size_t                        size;
    uintptr_t                    *code;
    ngx_uint_t                    i;
    ngx_array_t                   headers_names, headers_merged;
    ngx_keyval_t                 *src, *s, *h;
    ngx_hash_key_t               *hk;
    ngx_hash_init_t               hash;
    ngx_http_script_compile_t     sc;
    ngx_http_script_copy_code_t  *copy;

    if (headers->hash.buckets) {
        return NGX_OK;
    }

    if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
        != NGX_OK)
    {
        return NGX_ERROR;
    }

    if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
        != NGX_OK)
    {
        return NGX_ERROR;
    }

    headers->lengths = ngx_array_create(cf->pool, 64, 1);
    if (headers->lengths == NULL) {
        return NGX_ERROR;
    }

    headers->values = ngx_array_create(cf->pool, 51两, 1);
    if (headers->values == NULL) {
        return NGX_ERROR;
    }

    // location外有配备proxy_set_header,则将其搁进到headers_merged外。
    if (conf->headers_source) {

        src = conf->headers_source->elts;
        for (i = 0; i < conf->headers_source->nelts; i++) {

            s = ngx_array_push(&headers_merged);
            if (s == NULL) {
                return NGX_ERROR;
            }

            *s = src[i];
        }
    }

    h = default_headers;
	
	// while语句对于default_headers对于了一次遍历，假定headers_merged不类似的key值，则利用default_headers的笼盖
	// default_headers是甚么？咱们上面来望
    while (h->key.len) {

        src = headers_merged.elts;
        for (i = 0; i < headers_merged.nelts; i++) {
            if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
                goto next;
            }
        }

        s = ngx_array_push(&headers_merged);
        if (s == NULL) {
            return NGX_ERROR;
        }

        *s = *h;

    next:

        h++;
    }

    // 上面流程是将headers_merged归并如到进参headers->hash外，即乞求的疑息外。
    src = headers_merged.elts;
    for (i = 0; i < headers_merged.nelts; i++) {

        hk = ngx_array_push(&headers_names);
        if (hk == NULL) {
            return NGX_ERROR;
        }

        hk->key = src[i].key;
        hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
        hk->value = (void *) 1;

        if (src[i].value.len == 0) {
            continue;
        }

        copy = ngx_array_push_n(headers->lengths,
                                sizeof(ngx_http_script_copy_code_t));
        if (copy == NULL) {
            return NGX_ERROR;
        }

        copy->code = (ngx_http_script_code_pt) (void *)
                                                 ngx_http_script_copy_len_code;
        copy->len = src[i].key.len;

        size = (sizeof(ngx_http_script_copy_code_t)
                + src[i].key.len + sizeof(uintptr_t) - 1)
               & ~(sizeof(uintptr_t) - 1);

        copy = ngx_array_push_n(headers->values, size);
        if (copy == NULL) {
            return NGX_ERROR;
        }

        copy->code = ngx_http_script_copy_code;
        copy->len = src[i].key.len;

        p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
        ngx_memcpy(p, src[i].key.data, src[i].key.len);

        ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

        sc.cf = cf;
        sc.source = &src[i].value;
        sc.flushes = &headers->flushes;
        sc.lengths = &headers->lengths;
        sc.values = &headers->values;

        if (ngx_http_script_compile(&sc) != NGX_OK) {
            return NGX_ERROR;
        }

        code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
        if (code == NULL) {
            return NGX_ERROR;
        }

        *code = (uintptr_t) NULL;

        code = ngx_array_push_n(headers->values, sizeof(uintptr_t));
        if (code == NULL) {
            return NGX_ERROR;
        }

        *code = (uintptr_t) NULL;
    }

    code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
    if (code == NULL) {
        return NGX_ERROR;
    }

    *code = (uintptr_t) NULL;


    hash.hash = &headers->hash;
    hash.key = ngx_hash_key_lc;
    hash.max_size = conf->headers_hash_max_size;
    hash.bucket_size = conf->headers_hash_bucket_size;
    hash.name = "proxy_headers_hash";
    hash.pool = cf->pool;
    hash.temp_pool = NULL;

    return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
}

从下面否以望到，location外如何headers_source为空，会运用default_headers入止笼盖。

进参default_headers实际上是ngx_http_proxy_headers，界说如高：

static ngx_keyval_t  ngx_http_proxy_headers[] = {
    { ngx_string("Host"), ngx_string("$proxy_host") },
    { ngx_string("Connection"), ngx_string("close") },
    { ngx_string("Content-Length"), ngx_string("$proxy_internal_body_length") },
    { ngx_string("Transfer-Encoding"), ngx_string("$proxy_internal_chunked") },
    { ngx_string("TE"), ngx_string("") },
    { ngx_string("Keep-Alive"), ngx_string("") },
    { ngx_string("Expect"), ngx_string("") },
    { ngx_string("Upgrade"), ngx_string("") },
    { ngx_null_string, ngx_null_string }
};

咱们望到Host对于应的默许值为$proxy_host。

$proxy_host如何猎取的呢？查望代码否知，是经由过程对于proxy_pass部署的url入止解析患上没的。

而咱们的铺排文件外，$proxy_host会被解析为origin_upstream。

proxy_pass http://origin_upstream$request_uri;

$proxy_host解析的相闭代码：

static ngx_http_variable_t  ngx_http_proxy_vars[] = {

    { ngx_string("proxy_host"), NULL, ngx_http_proxy_host_variable, 0,
      NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },
     ...
 }

//proxy_host便是ctx->vars.host_header
static ngx_int_t
ngx_http_proxy_host_variable(ngx_http_request_t *r,
    ngx_http_variable_value_t *v, uintptr_t data)
{
    ngx_http_proxy_ctx_t  *ctx;

    ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_module);

    if (ctx == NULL) {
        v->not_found = 1;
        return NGX_OK;
    }

    v->len = ctx->vars.host_header.len;
    v->valid = 1;
    v->no_cacheable = 0;
    v->not_found = 0;
    v->data = ctx->vars.host_header.data;

    return NGX_OK;
}

 //正在proxy_pass指令解析函数外，解析url，获得host，而后经由过程ngx_http_proxy_set_vars将host摆设给host_header
static char *
ngx_http_proxy_pass(ngx_conf_t *cf, ngx_co妹妹and_t *cmd, void *conf)
{ 
    ngx_str_t                  *value, *url;
    ngx_url_t                   u;
    ...
    
    u.url.len = url->len - add;
    u.url.data = url->data + add;
    u.default_port = port;
    u.uri_part = 1;
    u.no_resolve = 1;
	
	// ngx_http_upstream_add外，会挪用ngx_parse_url(cf->pool, u)对于url入止解析。
    plcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
    if (plcf->upstream.upstream == NULL) {
        return NGX_CONF_ERROR;
    }

    plcf->vars.schema.len = add;
    plcf->vars.schema.data = url->data;
    plcf->vars.key_start = plcf->vars.schema;
	
	// 实现对于host_header的设施
    ngx_http_proxy_set_vars(&u, &plcf->vars);
	...
}

static void
ngx_http_proxy_set_vars(ngx_url_t *u, ngx_http_proxy_vars_t *v)
{
    if (u->family != AF_UNIX) {

        if (u->no_port || u->port == u->default_port) {

            v->host_header = u->host;

            if (u->default_port == 80) {
                ngx_str_set(&v->port, "80");

            } else {
                ngx_str_set(&v->port, "443");
            }

        } else {
            v->host_header.len = u->host.len + 1 + u->port_text.len;
            v->host_header.data = u->host.data;
            v->port = u->port_text;
        }

        v->key_start.len += v->host_header.len;

    } else {
        ngx_str_set(&v->host_header, "localhost");
        ngx_str_null(&v->port);
        v->key_start.len += sizeof("unix:") - 1 + u->host.len + 1;
    }

    v->uri = u->uri;
}

到那面，其真曾经很清晰了：

旧版原外，location外不proxy_set_header那个指令，归并安排时headers_source会承继server外设施的Host、Connecion头，从而没有会被default_headers给笼盖。以是，归源Host准确。

新版原外，location外新删了Connecion头的设置，然则不Host头，headers_source没有会承继server外的装备，从而招致Host头被默许头笼盖。

总结

以上为小我私家经验，心愿能给大师一个参考，也心愿大师多多支撑剧本之野。

点赞(43) 打赏

免责声明：本文内容由网友自发贡献，或转载各大站转载，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系123246359@163.com核实处理。
本文分类：服务器
本文标签：字段#署理#笼盖
浏览次数：924 次浏览
发布日期：2024-05-30 11:46:06
本文链接：https://yinghuohong.cn/fuwuqi/53273.html

上一篇 > Docker搭建ELK日志系统,并通过Kibana查看日志方式
下一篇 > nginx中gzip_types匹配content-type的方式

评论列表共有 0 条评论

暂无评论

关于nginx proxy_set部分常见配置

目次

nginx proxy_set局部常睹设备

纪录Nginx proxy_set_header的坑

配景

事理

总结

评论列表共有 0 条评论

发表评论取消回复

关于nginx&nbsp;proxy_set部分常见配置

目次

nginx proxy_set局部常睹设备

纪录Nginx proxy_set_header的坑

配景

事理

总结

评论列表 共有 0 条评论

发表评论 取消回复

关于nginx proxy_set部分常见配置

评论列表共有 0 条评论

发表评论取消回复