关于nginx proxy_set部分常见配置

坐看雲起

nginx proxy_set部分常见配置

1. proxy_set_header Host $host;
   
2. #用途：设置要发送到代理服务器的HTTP请求头的Host字段。$host变量将被替换为客户端请求中的实际主机名。
   
3. 
   
4. proxy_set_header Connection "";
   
5. # 用途：清空要发送到代理服务器的HTTP请求头的Connection字段。这可以避免由于Connection字段的错误配置而导致的代理连接无法正常关闭的问题。
   
6. 
   
7. proxy_set_header User-Agent $http_user_agent;
   
8. #用途：设置要发送到代理服务器的HTTP请求头的User-Agent字段。$http_user_agent变量将被替换为客户端请求中的实际User-Agent字符串。
   
9. 
   
10. proxy_set_header Referer $http_referer;
    
11. #用途：设置要发送到代理服务器的HTTP请求头的Referer字段。$http_referer变量将被替换为客户端请求中的实际Referer字符串。
    
12. 
    
13. proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    
14. #用途：设置要发送到代理服务器的HTTP请求头的X-Forwarded-For字段。该字段用于记录原始客户端的IP地址。$proxy_add_x_forwarded_for变量将会在原有X-Forwarded-For字段的基础上添加一个新的IP地址。
    
15. 
    
16. proxy_set_header X-Real-IP $remote_addr;
    
17. #用途：设置要发送到代理服务器的HTTP请求头的X-Real-IP字段。该字段用于记录客户端的真实IP地址。$remote_addr变量将被替换为客户端的真实IP地址。
    
18. 
    
19. proxy_set_header Accept-Encoding "";
    
20. #用途：清空要发送到代理服务器的HTTP请求头的Accept-Encoding字段。这可以避免由于Accept-Encoding字段的错误配置而导致的代理服务器无法正确解压缩响应的问题。

复制代码

需要注意的是：
这些指令的具体配置可能会因实际情况而异，例如需要设置的请求头字段等，需要根据实际需求进行配置

记录Nginx proxy_set_header的坑


背景

一个项目，使用nginx进行代理回源，新版本提交给测试同学后反馈说，回源Host被修改成固定的origin_upstream了。
第一反应：不应该啊，这个版本我没改回源Host相关的内容啊，是不是你环境问题？哈哈。但又一想，origin_upstream这个值莫名其妙，恰好是proxy_pass配置中url出现的，明显是有问题。
首先看了下代码提交记录，lua代码没有修改回源Host，排除；在回源的location中，增加了两行配置。然后就没有其他改动了。难道是location中的配置导致的？
配置文件结构如下：

1. http {
   
2.         ...
   
3.         upstream origin_upstream {
   
4.                 ...
   
5.         }
   
6.         server {
   
7.                 proxy_set_header Host $host;
   
8.                 proxy_set_header Connection "";
   
9.                 proxy_http_version 1.1;
   
10.                 ...
    
11.                 location x {
    
12.                         ...
    
13.                 }
    
14.                 location y {
    
15.                         ...
    
16.                 }
    
17.                
    
18.                 location @origin{
    
19.                         ...
    
20.                         # 如下两行是新版新增的，此处不是重复，是根据配置设置源站长连接
    
21.                         proxy_set_header Connection $switch;
    
22.                         proxy_http_version 1.1;
    
23.                        
    
24.                         proxy_pass http://origin_upstream$request_uri;
    
25.                         ...
    
26.                 }
    
27.         }
    
28. }

复制代码

去掉location中上述新增的两行配置后，就正常了！最终确认，是proxy_set_header Connection $switch;的问题。
解决办法：
在location中再加上如下配置，即可解决：

1. proxy_set_header Host $host;

复制代码

原理

为什么location中的Host不会继承server块中配置的呢？
看下nginx文档，如果在当前级别中没有配置，则继承上级配置。
默认情况，Host和Connection 会被重定义。

1. Syntax: proxy_set_header field value;
   
2. Default:
   
3. proxy_set_header Host $proxy_host;
   
4. proxy_set_header Connection close;
   
5. Context: http, server, location
   
6. 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:
   
7. proxy_set_header Host $proxy_host;
   
8. proxy_set_header Connection close;

复制代码

到底什么情况下，Host和Connection 才会被覆盖呢？
怀着疑问，去看proxy_set_header这个指令的实现。

1.     { ngx_string("proxy_set_header"),
   
2.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
   
3.       ngx_conf_set_keyval_slot,
   
4.       NGX_HTTP_LOC_CONF_OFFSET,
   
5.       offsetof(ngx_http_proxy_loc_conf_t, headers_source),
   
6.       NULL },

复制代码

通过ngx_conf_set_keyval_slot这函数设置了ngx_http_proxy_loc_conf_t结构体重的headers_source字段。
从下面实现可以看出，这个字段是一个kv键值对的数组。

1. char *
   
2. ngx_conf_set_keyval_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
   
3. {
   
4.     char  *p = conf;
   
5. 
   
6.     ngx_str_t         *value;
   
7.     ngx_array_t      **a;
   
8.     ngx_keyval_t      *kv;
   
9.     ngx_conf_post_t   *post;
   
10. 
    
11.     a = (ngx_array_t **) (p + cmd->offset);
    
12. 
    
13.     if (*a == NULL) {
    
14.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
    
15.         if (*a == NULL) {
    
16.             return NGX_CONF_ERROR;
    
17.         }
    
18.     }
    
19. 
    
20.     kv = ngx_array_push(*a);
    
21.     if (kv == NULL) {
    
22.         return NGX_CONF_ERROR;
    
23.     }
    
24. 
    
25.     value = cf->args->elts;
    
26. 
    
27.     kv->key = value[1];
    
28.     kv->value = value[2];
    
29. 
    
30.     if (cmd->post) {
    
31.         post = cmd->post;
    
32.         return post->post_handler(cf, post, kv);
    
33.     }
    
34. 
    
35.     return NGX_CONF_OK;
    
36. }

复制代码

headers_source字段在什么地方使用呢？
一处是在在ngx_http_proxy_merge_loc_conf合并配置时，一处是在ngx_http_proxy_init_headers这个函数中。
继续看，发现，ngx_http_proxy_init_headers这个函数在ngx_http_proxy_merge_loc_conf有调用。

1. static char *
   
2. ngx_http_proxy_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
   
3. {
   
4.     ngx_http_proxy_loc_conf_t *prev = parent;
   
5.     ngx_http_proxy_loc_conf_t *conf = child;
   
6.     ...
   
7.    
   
8.     if (conf->headers_source == NULL) {
   
9.         conf->headers = prev->headers;
   
10. #if (NGX_HTTP_CACHE)
    
11.         conf->headers_cache = prev->headers_cache;
    
12. #endif
    
13.                 // 如果location中没有proxy_set_header配置，就集成上级配置
    
14.         conf->headers_source = prev->headers_source;
    
15.     }
    
16.     //紧接着就是调用ngx_http_proxy_init_headers
    
17.     rc = ngx_http_proxy_init_headers(cf, conf, &conf->headers,
    
18.                                      ngx_http_proxy_headers);
    
19.     if (rc != NGX_OK) {
    
20.         return NGX_CONF_ERROR;
    
21.     }
    
22.     ...
    
23.    }

复制代码

我们继续看下ngx_http_proxy_init_headers的逻辑：

1. static ngx_int_t
   
2. ngx_http_proxy_init_headers(ngx_conf_t *cf, ngx_http_proxy_loc_conf_t *conf,
   
3.     ngx_http_proxy_headers_t *headers, ngx_keyval_t *default_headers)
   
4. {
   
5.     u_char                       *p;
   
6.     size_t                        size;
   
7.     uintptr_t                    *code;
   
8.     ngx_uint_t                    i;
   
9.     ngx_array_t                   headers_names, headers_merged;
   
10.     ngx_keyval_t                 *src, *s, *h;
    
11.     ngx_hash_key_t               *hk;
    
12.     ngx_hash_init_t               hash;
    
13.     ngx_http_script_compile_t     sc;
    
14.     ngx_http_script_copy_code_t  *copy;
    
15. 
    
16.     if (headers->hash.buckets) {
    
17.         return NGX_OK;
    
18.     }
    
19. 
    
20.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
    
21.         != NGX_OK)
    
22.     {
    
23.         return NGX_ERROR;
    
24.     }
    
25. 
    
26.     if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
    
27.         != NGX_OK)
    
28.     {
    
29.         return NGX_ERROR;
    
30.     }
    
31. 
    
32.     headers->lengths = ngx_array_create(cf->pool, 64, 1);
    
33.     if (headers->lengths == NULL) {
    
34.         return NGX_ERROR;
    
35.     }
    
36. 
    
37.     headers->values = ngx_array_create(cf->pool, 512, 1);
    
38.     if (headers->values == NULL) {
    
39.         return NGX_ERROR;
    
40.     }
    
41. 
    
42.     // location中有配置proxy_set_header,则将其放入到headers_merged中。
    
43.     if (conf->headers_source) {
    
44. 
    
45.         src = conf->headers_source->elts;
    
46.         for (i = 0; i < conf->headers_source->nelts; i++) {
    
47. 
    
48.             s = ngx_array_push(&headers_merged);
    
49.             if (s == NULL) {
    
50.                 return NGX_ERROR;
    
51.             }
    
52. 
    
53.             *s = src[i];
    
54.         }
    
55.     }
    
56. 
    
57.     h = default_headers;
    
58.        
    
59.         // while语句对default_headers对了一次遍历，如果headers_merged没有相同的key值，则使用default_headers的覆盖
    
60.         // default_headers是什么？我们下面来看
    
61.     while (h->key.len) {
    
62. 
    
63.         src = headers_merged.elts;
    
64.         for (i = 0; i < headers_merged.nelts; i++) {
    
65.             if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
    
66.                 goto next;
    
67.             }
    
68.         }
    
69. 
    
70.         s = ngx_array_push(&headers_merged);
    
71.         if (s == NULL) {
    
72.             return NGX_ERROR;
    
73.         }
    
74. 
    
75.         *s = *h;
    
76. 
    
77.     next:
    
78. 
    
79.         h++;
    
80.     }
    
81. 
    
82.     // 下面流程是将headers_merged合并如到入参headers->hash中，即请求的信息中。
    
83.     src = headers_merged.elts;
    
84.     for (i = 0; i < headers_merged.nelts; i++) {
    
85. 
    
86.         hk = ngx_array_push(&headers_names);
    
87.         if (hk == NULL) {
    
88.             return NGX_ERROR;
    
89.         }
    
90. 
    
91.         hk->key = src[i].key;
    
92.         hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
    
93.         hk->value = (void *) 1;
    
94. 
    
95.         if (src[i].value.len == 0) {
    
96.             continue;
    
97.         }
    
98. 
    
99.         copy = ngx_array_push_n(headers->lengths,
    
100.                                 sizeof(ngx_http_script_copy_code_t));
     
101.         if (copy == NULL) {
     
102.             return NGX_ERROR;
     
103.         }
     
104. 
     
105.         copy->code = (ngx_http_script_code_pt) (void *)
     
106.                                                  ngx_http_script_copy_len_code;
     
107.         copy->len = src[i].key.len;
     
108. 
     
109.         size = (sizeof(ngx_http_script_copy_code_t)
     
110.                 + src[i].key.len + sizeof(uintptr_t) - 1)
     
111.                & ~(sizeof(uintptr_t) - 1);
     
112. 
     
113.         copy = ngx_array_push_n(headers->values, size);
     
114.         if (copy == NULL) {
     
115.             return NGX_ERROR;
     
116.         }
     
117. 
     
118.         copy->code = ngx_http_script_copy_code;
     
119.         copy->len = src[i].key.len;
     
120. 
     
121.         p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
     
122.         ngx_memcpy(p, src[i].key.data, src[i].key.len);
     
123. 
     
124.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
     
125. 
     
126.         sc.cf = cf;
     
127.         sc.source = &src[i].value;
     
128.         sc.flushes = &headers->flushes;
     
129.         sc.lengths = &headers->lengths;
     
130.         sc.values = &headers->values;
     
131. 
     
132.         if (ngx_http_script_compile(&sc) != NGX_OK) {
     
133.             return NGX_ERROR;
     
134.         }
     
135. 
     
136.         code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
     
137.         if (code == NULL) {
     
138.             return NGX_ERROR;
     
139.         }
     
140. 
     
141.         *code = (uintptr_t) NULL;
     
142. 
     
143.         code = ngx_array_push_n(headers->values, sizeof(uintptr_t));
     
144.         if (code == NULL) {
     
145.             return NGX_ERROR;
     
146.         }
     
147. 
     
148.         *code = (uintptr_t) NULL;
     
149.     }
     
150. 
     
151.     code = ngx_array_push_n(headers->lengths, sizeof(uintptr_t));
     
152.     if (code == NULL) {
     
153.         return NGX_ERROR;
     
154.     }
     
155. 
     
156.     *code = (uintptr_t) NULL;
     
157. 
     
158. 
     
159.     hash.hash = &headers->hash;
     
160.     hash.key = ngx_hash_key_lc;
     
161.     hash.max_size = conf->headers_hash_max_size;
     
162.     hash.bucket_size = conf->headers_hash_bucket_size;
     
163.     hash.name = "proxy_headers_hash";
     
164.     hash.pool = cf->pool;
     
165.     hash.temp_pool = NULL;
     
166. 
     
167.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
     
168. }

复制代码

从上面可以看到，location中如果headers_source为空，会使用default_headers进行覆盖。
入参default_headers其实是ngx_http_proxy_headers，定义如下：

1. static ngx_keyval_t  ngx_http_proxy_headers[] = {
   
2.     { ngx_string("Host"), ngx_string("$proxy_host") },
   
3.     { ngx_string("Connection"), ngx_string("close") },
   
4.     { ngx_string("Content-Length"), ngx_string("$proxy_internal_body_length") },
   
5.     { ngx_string("Transfer-Encoding"), ngx_string("$proxy_internal_chunked") },
   
6.     { ngx_string("TE"), ngx_string("") },
   
7.     { ngx_string("Keep-Alive"), ngx_string("") },
   
8.     { ngx_string("Expect"), ngx_string("") },
   
9.     { ngx_string("Upgrade"), ngx_string("") },
   
10.     { ngx_null_string, ngx_null_string }
    
11. };

复制代码

我们看到Host对应的默认值为$proxy_host。
$proxy_host怎么获取的呢？查看代码可知，是通过对proxy_pass配置的url进行解析得出的。
而我们的配置文件中，$proxy_host会被解析为origin_upstream。

1. proxy_pass http://origin_upstream$request_uri;

复制代码

$proxy_host解析的相关代码：

1. static ngx_http_variable_t  ngx_http_proxy_vars[] = {
   
2. 
   
3.     { ngx_string("proxy_host"), NULL, ngx_http_proxy_host_variable, 0,
   
4.       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },
   
5.      ...
   
6. }
   
7. 
   
8. //proxy_host就是ctx->vars.host_header
   
9. static ngx_int_t
   
10. ngx_http_proxy_host_variable(ngx_http_request_t *r,
    
11.     ngx_http_variable_value_t *v, uintptr_t data)
    
12. {
    
13.     ngx_http_proxy_ctx_t  *ctx;
    
14. 
    
15.     ctx = ngx_http_get_module_ctx(r, ngx_http_proxy_module);
    
16. 
    
17.     if (ctx == NULL) {
    
18.         v->not_found = 1;
    
19.         return NGX_OK;
    
20.     }
    
21. 
    
22.     v->len = ctx->vars.host_header.len;
    
23.     v->valid = 1;
    
24.     v->no_cacheable = 0;
    
25.     v->not_found = 0;
    
26.     v->data = ctx->vars.host_header.data;
    
27. 
    
28.     return NGX_OK;
    
29. }
    
30. 
    
31. //在proxy_pass指令解析函数中，解析url，得到host，然后通过ngx_http_proxy_set_vars将host设置给host_header
    
32. static char *
    
33. ngx_http_proxy_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
    
34. {
    
35.     ngx_str_t                  *value, *url;
    
36.     ngx_url_t                   u;
    
37.     ...
    
38.    
    
39.     u.url.len = url->len - add;
    
40.     u.url.data = url->data + add;
    
41.     u.default_port = port;
    
42.     u.uri_part = 1;
    
43.     u.no_resolve = 1;
    
44.        
    
45.         // ngx_http_upstream_add中，会调用ngx_parse_url(cf->pool, u)对url进行解析。
    
46.     plcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
    
47.     if (plcf->upstream.upstream == NULL) {
    
48.         return NGX_CONF_ERROR;
    
49.     }
    
50. 
    
51.     plcf->vars.schema.len = add;
    
52.     plcf->vars.schema.data = url->data;
    
53.     plcf->vars.key_start = plcf->vars.schema;
    
54.        
    
55.         // 完成对host_header的设置
    
56.     ngx_http_proxy_set_vars(&u, &plcf->vars);
    
57.         ...
    
58. }
    
59. 
    
60. static void
    
61. ngx_http_proxy_set_vars(ngx_url_t *u, ngx_http_proxy_vars_t *v)
    
62. {
    
63.     if (u->family != AF_UNIX) {
    
64. 
    
65.         if (u->no_port || u->port == u->default_port) {
    
66. 
    
67.             v->host_header = u->host;
    
68. 
    
69.             if (u->default_port == 80) {
    
70.                 ngx_str_set(&v->port, "80");
    
71. 
    
72.             } else {
    
73.                 ngx_str_set(&v->port, "443");
    
74.             }
    
75. 
    
76.         } else {
    
77.             v->host_header.len = u->host.len + 1 + u->port_text.len;
    
78.             v->host_header.data = u->host.data;
    
79.             v->port = u->port_text;
    
80.         }
    
81. 
    
82.         v->key_start.len += v->host_header.len;
    
83. 
    
84.     } else {
    
85.         ngx_str_set(&v->host_header, "localhost");
    
86.         ngx_str_null(&v->port);
    
87.         v->key_start.len += sizeof("unix:") - 1 + u->host.len + 1;
    
88.     }
    
89. 
    
90.     v->uri = u->uri;
    
91. }

复制代码

到这里，其实已经很清楚了：
旧版本中，location中没有proxy_set_header这个指令，合并配置时headers_source会继承server中设置的Host、Connecion头，从而不会被default_headers给覆盖。所以，回源Host正确。
新版本中，location中新增了Connecion头的配置，但是没有Host头，headers_source不会继承server中的配置，从而导致Host头被默认头覆盖。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

来源:https://www.jb51.net/server/321096nc6.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！