nginx phase handler的原理和选择

谁借莪１个温暖的怀抱￠ 2022-08-18 00:45 47阅读 0赞

## nginx phase handler的原理和选择 ##

### PHASE HANDLER的种类 ###

nginx在接收并解析完请求行，请求头之后，就会依次调用各个phase handler。 phase handler是完成nginx主要功能的阶段。

Nginx有如下11种phase，phase会依次执行。同一个phase，可能会挂载多个handler。其中***斜体加粗***的phase，不允许挂载用户自定义的handler

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <th><strong>PHASE</strong></th> 
   <td><strong>备注</strong></td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_POST_READ_PHASE</th> 
   <td>读取请求内容阶段</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_SERVER_REWRITE_PHASE</th> 
   <td>Server请求地址重写阶段</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_FIND_CONFIG_PHASE</em></strong></th> 
   <td>配置查找阶段</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_REWRITE_PHASE</th> 
   <td>Location请求地址重写阶段</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_POST_REWRITE_PHASE</em></strong></th> 
   <td>请求地址重写提交阶段</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_PREACCESS_PHASE</th> 
   <td>访问权限检查准备阶段</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_ACCESS_PHASE</th> 
   <td>访问权限检查阶段</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_POST_ACCESS_PHASE</em></strong></th> 
   <td>访问权限检查提交阶段</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_TRY_FILES_PHASE</em></strong></th> 
   <td>配置项try_files处理阶段</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_CONTENT_PHASE</th> 
   <td>内容产生阶段</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_LOG_PHASE</th> 
   <td>日志模块处理阶段</td> 
  </tr> 
 </tbody> 
</table>

### 如何注册phase handler ###

一般情况下，我们自定义的模块，大多数是挂载在NGX\_HTTP\_CONTENT\_PHASE阶段的。挂载的动作一般是在模块上下文调用的postconfiguration函数中。

挂载的代码示例如下：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** ngx\_int\_t  
2.  ngx\_http\_hello\_init(ngx\_conf\_t \*cf)    // postconfiguration hook点  
3.  \{  
4.          ngx\_http\_handler\_pt        \*h;  
5.          ngx\_http\_core\_main\_conf\_t  \*cmcf;  
6.    
7.          cmcf = ngx\_http\_conf\_get\_module\_main\_conf(cf, ngx\_http\_core\_module);  
8.    
9.          h = ngx\_array\_push(&cmcf->phases\[NGX\_HTTP\_CONTENT\_PHASE\].handlers);  
10.         **if** (h == NULL) \{  
11.                 **return** NGX\_ERROR;  
12.         \}  
13.   
14.         \*h = ngx\_http\_hello\_handler;  
15.   
16.         **return** NGX\_OK;  
17. \}

cmcf->phases\[NGX\_HTTP\_CONTENT\_PHASE\].handlers 是content phase阶段的handler数组，类似的:

cmcf->phases\[NGX\_HTTP\_SERVER\_REWRITE\_PHASE\].handlers   
cmcf->phases\[NGX\_HTTP\_REWRITE\_PHASE\].handlers  
cmcf->phases\[NGX\_HTTP\_PREACCESS\_PHASE\].handlers  
。。。  
**每个可挂载的phase，都有一个phase handler数组, 你可以选择挂载在不同的phase数组里**

Nginx在解析http的配置时，会将多个phase handler数组，合成为一个数组

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **char** \*  
2.  ngx\_http\_block(ngx\_conf\_t \*cf, ngx\_command\_t \*cmd, **void** \*conf)  // http指令的hook函数  
3.  \{  
4.      。。。   
5.      **for** (m = 0; ngx\_modules\[m\]; m++) \{  
6.          **if** (ngx\_modules\[m\]->type != NGX\_HTTP\_MODULE) \{  
7.              **continue**;  
8.          \}  
9.    
10.         module = ngx\_modules\[m\]->ctx;  
11.   
12.         **if** (module->postconfiguration) \{  
13.             **if** (module->postconfiguration(cf) != NGX\_OK) \{ // 执行各模块的postconfigure hook, phase handler就在此时挂载  
14.                 **return** NGX\_CONF\_ERROR;  
15.             \}  
16.         \}  
17. 　　\}  
18. 　　。。。  
19. 　　  
20. 　　**if** (ngx\_http\_init\_phase\_handlers(cf, cmcf) != NGX\_OK) \{ // 将多个phase handler数组，合成为一个数组  
21. 　　    **return** NGX\_CONF\_ERROR;  
22. 　　\}  
23.    。。。  
24. \}

ngx\_http\_init\_phase\_handlers(cf, cmcf) 函数将(除log phase以外的)几个phase handler数组，合成为一个ngx\_http\_phase\_handler\_t类型的数组

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **struct** ngx\_http\_phase\_handler\_s \{  
2.      ngx\_http\_phase\_handler\_pt  checker; // 检查handler返回结果，决定下一个执行的handler  
3.      ngx\_http\_handler\_pt        handler; // handler 钩子  
4.      ngx\_uint\_t                 next;    // 指向下一个phase的第一个handler  
5.  \};

以下是不同的phase，对应不同的checker函数

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <th><strong>PHASE</strong></th> 
   <td><strong>checker</strong></td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_POST_READ_PHASE</th> 
   <td>ngx_http_core_generic_phase</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_SERVER_REWRITE_PHASE</th> 
   <td>ngx_http_core_rewrite_phase</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_FIND_CONFIG_PHASE</em></strong></th> 
   <td>ngx_http_core_find_config_phase</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_REWRITE_PHASE</th> 
   <td>ngx_http_core_rewrite_phase</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_POST_REWRITE_PHASE</em></strong></th> 
   <td>ngx_http_core_post_rewrite_phase</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_PREACCESS_PHASE</th> 
   <td>ngx_http_core_generic_phase</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_ACCESS_PHASE</th> 
   <td>ngx_http_core_access_phase</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_POST_ACCESS_PHASE</em></strong></th> 
   <td>ngx_http_core_post_access_phase</td> 
  </tr> 
  <tr> 
   <th><strong><em>NGX_HTTP_TRY_FILES_PHASE</em></strong></th> 
   <td>ngx_http_core_try_files_phase</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_CONTENT_PHASE</th> 
   <td>ngx_http_core_content_phase</td> 
  </tr> 
  <tr> 
   <th>NGX_HTTP_LOG_PHASE</th> 
   <td>ngx_http_core_generic_phase</td> 
  </tr> 
 </tbody> 
</table>

### Phase handler如何执行 ###

nginx在接收并解析完请求行，请求头之后，就会依次调用各个phase handler.

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **void**  
2.  ngx\_http\_core\_run\_phases(ngx\_http\_request\_t \*r)  
3.  \{  
4.      ngx\_int\_t                   rc;  
5.      ngx\_http\_phase\_handler\_t   \*ph;  
6.      ngx\_http\_core\_main\_conf\_t  \*cmcf;  
7.      cmcf = ngx\_http\_get\_module\_main\_conf(r, ngx\_http\_core\_module);  
8.      ph = cmcf->phase\_engine.handlers;  
9.      **while** (ph\[r->phase\_handler\].checker) \{  
10.         rc = ph\[r->phase\_handler\].checker(r, &ph\[r->phase\_handler\]);  
11.         **if** (rc == NGX\_OK) \{  
12.             **return**;  
13.         \}  
14.     \}  
15. \}

可以看到，其实依次执行的就是我们在初始化阶段，生成的ngx\_http\_phase\_handler\_t 数组

我们通过debug，来看一下ngx\_http\_phase\_handler\_t数组的实际内容

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <th colspan="4"><strong>运行中时ph数组的内容</strong></th> 
  </tr> 
  <tr> 
   <th><strong>数组下标</strong></th> 
   <td><strong>checker</strong></td> 
   <td><strong>handler</strong></td> 
   <td><strong>next</strong></td> 
  </tr> 
  <tr> 
   <th>0</th> 
   <td>ngx_http_core_rewrite_phase</td> 
   <td>ngx_http_rewrite_handler</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>ngx_http_core_find_config_phase</td> 
   <td>0</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>ngx_http_core_rewrite_phase</td> 
   <td>ngx_http_rewrite_handler</td> 
   <td>3</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>ngx_http_core_post_rewrite_phase</td> 
   <td>0</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <th>4</th> 
   <td>ngx_http_core_generic_phase</td> 
   <td>ngx_http_l7waf_handler</td> 
   <td>7</td> 
  </tr> 
  <tr> 
   <th>5</th> 
   <td>ngx_http_core_generic_phase</td> 
   <td>ngx_http_limit_req_handler</td> 
   <td>7</td> 
  </tr> 
  <tr> 
   <th>6</th> 
   <td>ngx_http_core_generic_phase</td> 
   <td>ngx_http_limit_conn_handler</td> 
   <td>7</td> 
  </tr> 
  <tr> 
   <th>7</th> 
   <td>ngx_http_core_access_phase</td> 
   <td>ngx_http_access_handler</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <th>8</th> 
   <td>ngx_http_core_access_phase</td> 
   <td>ngx_http_auth_basic_handler</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <th>9</th> 
   <td>ngx_http_core_post_access_phase</td> 
   <td>0</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <th>10</th> 
   <td>ngx_http_core_try_files_phase</td> 
   <td>0</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <th>11</th> 
   <td>ngx_http_core_content_phase</td> 
   <td>ngx_http_index_handler</td> 
   <td>14</td> 
  </tr> 
  <tr> 
   <th>12</th> 
   <td>ngx_http_core_content_phase</td> 
   <td>ngx_http_autoindex_handler</td> 
   <td>14</td> 
  </tr> 
  <tr> 
   <th>13</th> 
   <td>ngx_http_core_content_phase</td> 
   <td>ngx_http_static_handler</td> 
   <td>14</td> 
  </tr> 
  <tr> 
   <th>14</th> 
   <td>0</td> 
   <td>0</td> 
   <td>0</td> 
  </tr> 
 </tbody> 
</table>

我们来看一个具体的checker函数

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  ngx\_int\_t  
2.  ngx\_http\_core\_generic\_phase(ngx\_http\_request\_t \*r, ngx\_http\_phase\_handler\_t \*ph)  
3.  \{  
4.      ngx\_int\_t  rc;  
5.    
6.      /\* 
7.       \* generic phase checker, 
8.       \* used by the post read and pre-access phases 
9.       \*/  
10.   
11.     ngx\_log\_debug1(NGX\_LOG\_DEBUG\_HTTP, r->connection->log, 0,  
12.                    "generic phase: %ui", r->phase\_handler);  
13.   
14.     rc = ph->handler(r);          // 执行挂载的handler  
15.   
16.     **if** (rc == NGX\_OK) \{           // 返回值是NGX\_OK，说明这个phase执行完了，跳到下一个phase的第一个handler去  
17.         r->phase\_handler = ph->next;  
18.         **return** NGX\_AGAIN;  
19.     \}  
20.   
21.     **if** (rc == NGX\_DECLINED) \{     // 返回值NGX\_DECLINED，继续执行这个phase的下一个handler  
22.         r->phase\_handler++;  
23.         **return** NGX\_AGAIN;  
24.     \}  
25.   
26.     **if** (rc == NGX\_AGAIN || rc == NGX\_DONE) \{ //说明请求处理完了。下面所有的phase handler都不需要再执行了  
27.         **return** NGX\_OK;  
28.     \}  
29.   
30.     /\* rc == NGX\_ERROR || rc == NGX\_HTTP\_...  \*/  
31.   
32.     ngx\_http\_finalize\_request(r, rc);        // 返回错误，结束请求，返回相应的错误页  
33.   
34.     **return** NGX\_OK;  
35. \}

### 如何选择哪个phase ###

**读取请求内容阶段**

这个阶段没有默认的handler，主要用来读取请求体，并对请求体做相应的处理

**Server请求地址重写阶段**

这个阶段主要是处理全局的(server block)的rewrite规则

**配置查找阶段**

这个阶段主要是通过uri来查找对应的location。然后将uri和location的数据关联起来。这个阶段主要处理逻辑在checker函数中，*不能挂载自定义的handler*

**Location请求地址重写阶段**

这个主要处理location block的rewrite。

**请求地址重写提交阶段**

post rewrite，这个主要是进行一些校验以及收尾工作，以便于交给后面的模块。*这个phase不能挂载自定义handler*

**访问权限检查准备阶段**

比如流控这种类型的access就放在这个phase，也就是说它主要是进行一些比较粗粒度的access。

**访问权限检查阶段**

这个比如存取控制，权限验证就放在这个phase，一般来说处理动作是交给下面的模块做的.这个主要是做一些细粒度的access。

**访问权限检查提交阶段**

一般来说当上面的access模块得到access\_code之后就会由这个模块根据access\_code来进行操作 *这个phase不能挂载自定义handler*

**配置项try\_files处理阶段**

try\_file模块，也就是对应配置文件中的try\_files指令。 *这个phase不能挂载自定义handler*

按顺序检查文件是否存在，返回第一个找到的文件。结尾的斜线表示为文件夹 -$uri/。如果所有的文件都找不到，会进行一个内部重定向到最后一个参数。

**内容产生阶段**

内容处理模块，产生文件内容，如果是php，去调用phpcgi，如果是代理，就转发给相应的后端服务器

**日志模块处理阶段**

日志处理模块，是每个请求最后一定会执行的。用于打印访问日志。

通过如上对phase handler的分析，我们可以知道nginx划分不同的phase，是将不同功能，安排在不同的顺序执行。

**选择挂载在哪个phase，就选择了handler执行的顺序，并且选择了不同的checker函数。**

自定义的handler有时候可以挂载在不同的phase，都可以正常运行。

自定义的handler，如果依赖某一个phase的结果，则必须挂载在该phase后面的phase上。

自定义的handler需要遵守nginx对不同phase的功能划分，但不是必需的。

除去4个不能挂载的phase，和log phase，还有如下6个phase可以挂载

NGX\_HTTP\_POST\_READ\_PHASE  
NGX\_HTTP\_SERVER\_REWRITE\_PHASE  
NGX\_HTTP\_REWRITE\_PHASE  
NGX\_HTTP\_PREACCESS\_PHASE  
NGX\_HTTP\_ACCESS\_PHASE  
NGX\_HTTP\_CONTENT\_PHASE

很多功能挂载在这6个phase，都可以实现。挂载在越前面，我们的性能会越好，挂载在后面，我们的自由度会更大。

比如说，如果我们实现在NGX\_HTTP\_POST\_READ\_PHASE 阶段，我们就不能用 location if 这些后面阶段实现的指令来组合实现一些更复杂的功能。

推荐使用  
NGX\_HTTP\_PREACCESS\_PHASE  
NGX\_HTTP\_ACCESS\_PHASE  
NGX\_HTTP\_CONTENT\_PHASE

[view plain]: http://blog.csdn.net/liujiyong7/article/details/38817135#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/457718
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/457718/fork