精华内容
下载资源
问答
  • 1. nginx 11 个处理阶段 nginx实际把请求处理流程划分为了11阶段,这样划分的原因是将请求的执行逻辑细分,各阶段按照处理时机定义了清晰的执行语义,开发者...接收完请求头之后的第一个阶段,它位于uri重写之...

    1. nginx 11 个处理阶段

    nginx实际把请求处理流程划分为了11个阶段,这样划分的原因是将请求的执行逻辑细分,各阶段按照处理时机定义了清晰的执行语义,开发者可以很容易分辨自己需要开发的模块应该定义在什么阶段,其定义在http/ngx_http_core_module.h中有定义:


    NGX_HTTP_POST_READ_PHASE:
    接收完请求头之后的第一个阶段,它位于uri重写之前,实际上很少有模块会注册在该阶段,默认的情况下,该阶段被跳过

    NGX_HTTP_SERVER_REWRITE_PHASE:
    server级别的uri重写阶段,也就是该阶段执行处于server块内,location块外的重写指令,在读取请求头的过程中nginx会根据host及端口找到对应的虚拟主机配置

    NGX_HTTP_FIND_CONFIG_PHASE:
    寻找location配置阶段,该阶段使用重写之后的uri来查找对应的location,值得注意的是该阶段可能会被执行多次,因为也可能有location级别的重写指令

    NGX_HTTP_REWRITE_PHASE:
    location级别的uri重写阶段,该阶段执行location基本的重写指令,也可能会被执行多次

    NGX_HTTP_POST_REWRITE_PHASE:
    location级别重写的后一阶段,用来检查上阶段是否有uri重写,并根据结果跳转到合适的阶段

    NGX_HTTP_PREACCESS_PHASE:
    访问权限控制的前一阶段,该阶段在权限控制阶段之前,一般也用于访问控制,比如限制访问频率,链接数等

    NGX_HTTP_ACCESS_PHASE:
    访问权限控制阶段,比如基于ip黑白名单的权限控制,基于用户名密码的权限控制等

    NGX_HTTP_POST_ACCESS_PHASE:
    问权限控制的后一阶段,该阶段根据权限控制阶段的执行结果进行相应处理

    NGX_HTTP_TRY_FILES_PHASE:
    try_files指令的处理阶段,如果没有配置try_files指令,则该阶段被跳过

    NGX_HTTP_CONTENT_PHASE:
    内容生成阶段,该阶段产生响应,并发送到客户端

    NGX_HTTP_LOG_PHASE:
    日志记录阶段,该阶段记录访问日志

    2. nginx lua 8个处理阶段

    init_by_lua            http
    set_by_lua             server, server if, location, location if
    rewrite_by_lua         http, server, location, location if
    access_by_lua          http, server, location, location if
    content_by_lua         location, location if
    header_filter_by_lua   http, server, location, location if
    body_filter_by_lua     http, server, location, location if
    log_by_lua             http, server, location, location if
    {
        set_by_lua: 流程分支处理判断变量初始化
        rewrite_by_lua: 转发、重定向、缓存等功能(例如特定请求代理到外网)
        access_by_lua: IP准入、接口权限等情况集中处理(例如配合iptable完成简单防火墙)
        content_by_lua: 内容生成
        header_filter_by_lua: 应答HTTP过滤处理(例如添加头部信息)
        body_filter_by_lua: 应答BODY过滤处理(例如完成应答内容统一成大写)
        log_by_lua: 会话完成后本地异步完成日志记录(日志可以记录在本地,还可以同步到其他机器)
    }
     

    参考文献:

    https://blog.csdn.net/yangguanghaozi/article/details/54139258

    展开全文
  • nginx 11 处理阶段

    千次阅读 2018-12-02 22:01:23
    nginx 11 处理阶段     nginx实际把http请求处理流程划分为了11个阶段,这样划分的原因是将请求的执行逻辑细分,以模块为单位进行处理,各个阶段可以包含任意多http模块并以流水线的方式处理请求。这样做的...

    nginx 11 个处理阶段

     

     

    nginx实际把http请求处理流程划分为了11个阶段,这样划分的原因是将请求的执行逻辑细分,以模块为单位进行处理,各个阶段可以包含任意多个http模块并以流水线的方式处理请求。这样做的好处是使处理过程更加灵活、降低耦合度。这11个http阶段如下所示:

    1)ngx_http_post_read_phase:

    接收到完整的http头部后处理的阶段,它位于uri重写之前,实际上很少有模块会注册在该阶段,默认的情况下,该阶段被跳过。

    2)ngx_http_server_rewrite_phase:

    uri与location匹配前,修改uri的阶段,用于重定向,也就是该阶段执行处于server块内,location块外的重写指令,在读取请求头的过程中nginx会根据host及端口找到对应的虚拟主机配置。

    3)ngx_http_find_config_phase:

    根据uri寻找匹配的location块配置项阶段,该阶段使用重写之后的uri来查找对应的location,值得注意的是该阶段可能会被执行多次,因为也可能有location级别的重写指令。

    4)ngx_http_rewrite_phase:

    上一阶段找到location块后再修改uri,location级别的uri重写阶段,该阶段执行location基本的重写指令,也可能会被执行多次。

    5)ngx_http_post_rewrite_phase:

    防止重写url后导致的死循环,location级别重写的后一阶段,用来检查上阶段是否有uri重写,并根据结果跳转到合适的阶段。

    6)ngx_http_preaccess_phase:

    下一阶段之前的准备,访问权限控制的前一阶段,该阶段在权限控制阶段之前,一般也用于访问控制,比如限制访问频率,链接数等。

    7)ngx_http_access_phase:

    让http模块判断是否允许这个请求进入nginx服务器,访问权限控制阶段,比如基于ip黑白名单的权限控制,基于用户名密码的权限控制等。

    8)ngx_http_post_access_phase:

    访问权限控制的后一阶段,该阶段根据权限控制阶段的执行结果进行相应处理,向用户发送拒绝服务的错误码,用来响应上一阶段的拒绝。

    9)ngx_http_try_files_phase:

    为访问静态文件资源而设置,try_files指令的处理阶段,如果没有配置try_files指令,则该阶段被跳过。

    10)ngx_http_content_phase:

    处理http请求内容的阶段,大部分http模块介入这个阶段,内容生成阶段,该阶段产生响应,并发送到客户端。

    11)ngx_http_log_phase:

    处理完请求后的日志记录阶段,该阶段记录访问日志。

    以上11个阶段中,http无法介入的阶段有4个:

    3)ngx_http_find_config_phase

    5)ngx_http_post_rewrite_phase

    8)ngx_http_post_access_phase

    9)ngx_http_try_files_phase

    剩余的7个阶段,http模块均能介入,每个阶段可介入模块的个数也是没有限制的,多个http模块可同时介入同一阶段并作用于同一请求。

     

    展开全文
  • nginx http每个阶段的处理、比较详细、其实我是想放到博客里、但是不支持文件上传~~~
  • nginx 执行的11个阶段

    2019-12-02 08:05:17
    nginx代码执行的的顺序与执行阶段有关,与代码的实际顺序无关(在有阶段区分时)

    nginx代码执行的的顺序与执行阶段有关,与代码的实际顺序无关(在有阶段区分时)

    展开全文
  • Nginx处理请求的11个阶段(agentzh的Nginx 教程学习记录).pdf
  • nginx的十一个阶段处理

    千次阅读 2014-04-19 00:46:47
    nginx的源码确实比较难读,怎么说呢, nginxda

       nginx的源码确实比较难读,怎么说呢, 一大堆的函数回调指针,没有理清脉络,看源码就很费劲。

    首先要弄清楚的就是要理顺nginx调用的主框架,nginx是以配置为中心的处理架构,想读懂,先了解配置。

       言归正传,这里说nginx处理的是一个阶段,

           

    typedef enum {
        NGX_HTTP_POST_READ_PHASE = 0,   //读取请求头
    
        NGX_HTTP_SERVER_REWRITE_PHASE,   //执行rewrite
    
        NGX_HTTP_FIND_CONFIG_PHASE,  //根据uri替换location
        NGX_HTTP_REWRITE_PHASE,      //根据替换结果继续执行rewrite
        NGX_HTTP_POST_REWRITE_PHASE, //执行rewrite后处理
    
        NGX_HTTP_PREACCESS_PHASE,    //认证预处理   请求限制,连接限制
    
        NGX_HTTP_ACCESS_PHASE,       //认证处理
        NGX_HTTP_POST_ACCESS_PHASE,  //认证后处理, 认证不通过, 丢包
    
        NGX_HTTP_TRY_FILES_PHASE,    //尝试try标签
        NGX_HTTP_CONTENT_PHASE,      //内容处理
    
        NGX_HTTP_LOG_PHASE           //日志处理
    } ngx_http_phases;
    

    以上每个阶段的处理都是一个数组回调。数据的初始化如下:

    static ngx_int_t
    ngx_http_init_phases(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
    {
        if (ngx_array_init(&cmcf->phases[NGX_HTTP_POST_READ_PHASE].handlers,
                           cf->pool, 1, sizeof(ngx_http_handler_pt))
            != NGX_OK)
        {
            return NGX_ERROR;
        }
    
        if (ngx_array_init(&cmcf->phases[NGX_HTTP_SERVER_REWRITE_PHASE].handlers,
                           cf->pool, 1, sizeof(ngx_http_handler_pt))
            != NGX_OK)
        {
            return NGX_ERROR;
        }
    
        if (ngx_array_init(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers,
                           cf->pool, 1, sizeof(ngx_http_handler_pt))
            != NGX_OK)
        {
            return NGX_ERROR;
        }
    
        if (ngx_array_init(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers,
                           cf->pool, 1, sizeof(ngx_http_handler_pt))
            != NGX_OK)
        {
            return NGX_ERROR;
        }
    
        if (ngx_array_init(&cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers,
                           cf->pool, 2, sizeof(ngx_http_handler_pt))
            != NGX_OK)
        {
            return NGX_ERROR;
        }
    
        if (ngx_array_init(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers,
                           cf->pool, 4, sizeof(ngx_http_handler_pt))
            != NGX_OK)
        {
            return NGX_ERROR;
        }
    
        if (ngx_array_init(&cmcf->phases[NGX_HTTP_LOG_PHASE].handlers,
                           cf->pool, 1, sizeof(ngx_http_handler_pt))
            != NGX_OK)
        {
            return NGX_ERROR;
        }
    
        return NGX_OK;
    }

    可以看到

     NGX_HTTP_FIND_CONFIG_PHASE,  //根据uri替换location
     NGX_HTTP_POST_REWRITE_PHASE, //执行rewrite后处理
     NGX_HTTP_POST_ACCESS_PHASE,  //认证后处理, 认证不通过, 丢包
    

    以上几个阶段都没有做数组的初始化化。

    还要说一点的是,真正执行的时候,并不是调用cmcf->phases处理的, 而是调用cmcf->phase_engine.handlers
    void
    ngx_http_core_run_phases(ngx_http_request_t *r)
    {
        ngx_int_t                   rc;
        ngx_http_phase_handler_t   *ph;
        ngx_http_core_main_conf_t  *cmcf;
    
        cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
    
        ph = cmcf->phase_engine.handlers;
    
        while (ph[r->phase_handler].checker) {
    
            rc = ph[r->phase_handler].checker(r, &ph[r->phase_handler]);
    
            if (rc == NGX_OK) {  //只要return不为NGX_OK就继续执行。
                return;
            }
        }
    }
    

    phase_engine的初始化如下
    static ngx_int_t
    ngx_http_init_phase_handlers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
    {
        ngx_int_t                   j;
        ngx_uint_t                  i, n;
        ngx_uint_t                  find_config_index, use_rewrite, use_access;
        ngx_http_handler_pt        *h;
        ngx_http_phase_handler_t   *ph;
        ngx_http_phase_handler_pt   checker;
    
        cmcf->phase_engine.server_rewrite_index = (ngx_uint_t) -1;
        cmcf->phase_engine.location_rewrite_index = (ngx_uint_t) -1;
        find_config_index = 0;
        use_rewrite = cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers.nelts ? 1 : 0;
        use_access = cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers.nelts ? 1 : 0;
    
        n = use_rewrite + use_access + cmcf->try_files + 1 /* find config phase */;
    
        for (i = 0; i < NGX_HTTP_LOG_PHASE; i++) {
            n += cmcf->phases[i].handlers.nelts;
        }
    
        ph = ngx_pcalloc(cf->pool,
                         n * sizeof(ngx_http_phase_handler_t) + sizeof(void *));
        if (ph == NULL) {
            return NGX_ERROR;
        }
    
        cmcf->phase_engine.handlers = ph;
        n = 0;
    
        for (i = 0; i < NGX_HTTP_LOG_PHASE; i++) {
            h = cmcf->phases[i].handlers.elts;
    
            switch (i) {
    
            case NGX_HTTP_SERVER_REWRITE_PHASE:
                if (cmcf->phase_engine.server_rewrite_index == (ngx_uint_t) -1) {
                    cmcf->phase_engine.server_rewrite_index = n;
                }
                checker = ngx_http_core_rewrite_phase;
    
                break;
    
            case NGX_HTTP_FIND_CONFIG_PHASE:
                find_config_index = n;
    
                ph->checker = ngx_http_core_find_config_phase;
                n++;
                ph++;
    
                continue;
    
            case NGX_HTTP_REWRITE_PHASE:
                if (cmcf->phase_engine.location_rewrite_index == (ngx_uint_t) -1) {
                    cmcf->phase_engine.location_rewrite_index = n;
                }
                checker = ngx_http_core_rewrite_phase;
    
                break;
    
            case NGX_HTTP_POST_REWRITE_PHASE:
                if (use_rewrite) {
                    ph->checker = ngx_http_core_post_rewrite_phase;
                    ph->next = find_config_index;
                    n++;
                    ph++;
                }
    
                continue;
    
            case NGX_HTTP_ACCESS_PHASE:
                checker = ngx_http_core_access_phase;
                n++;
                break;
    
            case NGX_HTTP_POST_ACCESS_PHASE:
                if (use_access) {
                    ph->checker = ngx_http_core_post_access_phase;
                    ph->next = n;
                    ph++;
                }
    
                continue;
    
            case NGX_HTTP_TRY_FILES_PHASE:
                if (cmcf->try_files) {
                    ph->checker = ngx_http_core_try_files_phase;
                    n++;
                    ph++;
                }
    
                continue;
    
            case NGX_HTTP_CONTENT_PHASE:
                checker = ngx_http_core_content_phase;
                break;
    
            default:
                checker = ngx_http_core_generic_phase;
            }
    
            n += cmcf->phases[i].handlers.nelts;
    
            for (j = cmcf->phases[i].handlers.nelts - 1; j >=0; j--) {
                ph->checker = checker;
                ph->handler = h[j];  //数组是反向赋值的,刚好对应了数组操作的顺序
                ph->next = n;        //next永远执行下一个阶段的执行索引
                ph++;
            }
        }
    
        return NGX_OK;
    }
    

    从上面可以看到,nginx把所有阶段的回调函数组成了一个串行的执行函数数组。
    cheker指针指向检测调用函数指针,hander指向该阶段的函数调用指针,next则指向下一阶段的ph索引。
    当执行某一阶段到一半的时候,想跳到下一个阶段,只需要r->phase_handler = ph->next;

    ph的返回值为NGX_OK时, 函数会跳出阶段的执行,但是在阶段执行的hander中却不是这样的。

    NGX_DECLINED:   会直接执行下一个ph调用。
    NGX_AGAIN:  会重复调用本ph
    NGX_DOWN:终止阶段函数回调调用。

    展开全文
  • Nginx 请求的11个阶段

    2019-04-13 15:56:00
    1:当请求进入Nginx后先READ REQUEST HEADERS 读取头部 然后再分配由哪个指令操作 2:Identity 寻找匹配哪个Location 3:Apply Rate Limits 是否要对该请求限制 4:Preform Authertication 权限验证 5:Generate...
  • Nginx 处理请求的全过程一共划分为 11 个阶段(如图),按阶段由上到下依次执行(上一阶段的所有指令执行完毕,才进入下一阶段) 各阶段的含义如下: ²post-read:接收到完整的http头部后处理的阶段,在uri重写...
  • 接收完请求头之后的第一个阶段,它位于uri重写之前,实际上很少有模块会注册在该阶段,默认的情况下,该阶段被跳过; NGX_HTTP_SERVER_REWRITE_PHASE:   server级别的uri重写阶段,也就是该阶段执行
  • nginx http 请求处理时的11个阶段.pdf
  • Nginx 处理请求的过程一共划分为 11 个阶段,按照执行顺序依次是post-read、server-rewrite、find-config、rewrite、post-rewrite、preaccess、access、post-access、try-files、content以及log。 1、post-read 最先...
  • nginx一个HTTP请求分为11个处理阶段,这样做让每个HTTP模块可以仅仅专注于完成一个独立,简单的功能。而一个请求的完整处理过程可以由多个HTTP模块共同合作完成。可以极大的提高多个模块合作的协同性,可测试性,...
  • Nginx的启动阶段讲解

    2019-08-24 09:16:29
    Nginx的启动阶段讲解 概述 nginx启动阶段指从nginx初始化直至准备好按最新配置提供服务的过程。 在不考虑nginx单进程工作的情况下,这过程包含三种方式: 启动新的nginx reload配置 热替换nginx代码 三种...
  • Nginx的执行阶段详解

    2021-04-01 20:47:36
    在了解nginx的执行阶段前,先看一个例子 对echo不熟悉的,可以先看文章Nginx调试必备了解下echo扩展 回到上面这个例子,在server块中配置这样的location,你觉得输出是什么样子? 按照正常的逻辑,输出应该...
  • Nginx Lua的执行阶段

    2021-02-04 11:52:01
    Nginx11个执行阶段,每个阶段都有自己能够执行的指令,并可以实现不同的功能。Ngx_Lua的功能大部分是基于Nginx11个执行阶段开发和配置的,Lua代码在这些指令块中执行,并依赖于它们的执行顺序。本章将对Ngx_Lua...
  • 参考:...11个阶段 typedef enum { NGX_HTTP_POST_READ_PHASE = 0, NGX_HTTP_SERVER_REWRITE_PHASE, NGX_HTTP_FIND_CONFIG_PHASE, NGX_HTTP_REWRITE_PHASE, NGX_HTTP_POST_REWRITE_P
  • nginx一个HTTP请求分为11个处理阶段,这样做让每个HTTP模块可以仅仅专注于完成一个独立,简单的功能。而一个请求的完整处理过程可以由多个HTTP模块共同合作完成。可以极大的提高多个模块合作的协同性,可测试性,...
  • Nginx极客时间:详解HTTP请求的11个阶段.pdf
  • nginx-lua 运行阶段

    千次阅读 2017-03-15 18:46:17
    Nginx 处理请求的过程一共划分为 11 个阶段,按照执行顺序依次是
  • Nginx执行阶段

    2019-02-24 13:37:13
    Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件(IMAP/POP3)代理服务器,并在一个BSD-like 协议下发行。其特点是占有内存少,并发能力强 OpenResty介绍 OpenResty 是一个基于 Nginx 与 Lua 的高性能 W...
  • 除了 HTTP过滤模块 和 只提供变量的Nginx模块 之外,所有...当一个请求进入到图中黄色的框 也就是Nginx之中时,先进行 “Read Request Headers”,即读取到请求的头部,并且决定使用哪一个server块的配置去处理这个请求

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,702
精华内容 18,280
关键字:

nginx11个阶段