① 客户端 TCP 连接到达
   ↓
② worker accept，分配 ngx_connection_t，创建 connection pool
   ↓
③ 等待可读事件 → 读取请求行（GET /a/b?x=1 HTTP/1.1）
   ↓  超时由 client_header_timeout 控制
④ 读取并解析请求头，创建 request pool
   ↓  缓冲区由 client_header_buffer_size / large_client_header_buffers 控制
⑤ 根据 Host + listen 选出 server 块（虚拟主机匹配）
   ↓
⑥ 根据 URI 选出 location 块
   ↓
⑦ ★ 走 11 个阶段的 handler 链 ★
   ↓
⑧ content phase 产生响应（读文件 / 反代到上游 / return）
   ↓
⑨ 响应经过 header filter 链 和 body filter 链
   ↓  gzip、chunked、ssi、sub 等都在这里
⑩ 通过 sendfile / writev 发给客户端
   ↓
⑪ 写 access_log，销毁 request pool
   ↓
⑫ keepalive 则回到 ③ 等下一个请求，否则关闭连接、销毁 connection pool

location /api/ {
    proxy_pass http://backend;    # CONTENT 阶段
    limit_req  zone=one;          # PREACCESS 阶段
    deny 1.2.3.4;                 # ACCESS 阶段
    set $foo bar;                 # REWRITE 阶段
}

# ❌ 想在 rewrite 之后再判断，但 deny 属于 ACCESS 阶段，总在 rewrite 之后执行，
#    这里的顺序期望本来就不成立
location / {
    deny all;
    rewrite ^/old/(.*)$ /new/$1;
}

真实用户 1.2.3.4 → CDN 5.6.7.8 → 公司 SLB 10.0.0.1 → Nginx

http {
    # 声明哪些是可信代理（必须写全，否则会被伪造）
    set_real_ip_from 10.0.0.0/8;
    set_real_ip_from 172.16.0.0/12;
    set_real_ip_from 5.6.7.0/24;     # CDN 的回源段

    real_ip_header    X-Forwarded-For;
    real_ip_recursive on;    # 从右往左跳过所有可信 IP，取第一个不可信的
}

server {
    # SERVER_REWRITE 阶段：所有请求都会经过
    rewrite ^/old/(.*)$ /new/$1 last;
    set $api_version "v1";

    location /new/ {
        # REWRITE 阶段
        if ($http_x_beta = "1") {
            set $api_version "v2";
        }
        proxy_pass http://backend_$api_version;
    }
}

# ❌ 死循环
location / {
    rewrite ^(.*)$ /index.php$1 last;   # 改完还是匹配 location /，无限循环
}

http {
    limit_req_zone  $binary_remote_addr zone=perip:10m rate=10r/s;
    limit_conn_zone $binary_remote_addr zone=conn:10m;

    server {
        location /api/ {
            limit_req  zone=perip burst=20 nodelay;
            limit_conn conn 10;
            auth_request /auth;      # ACCESS 阶段，在限流之后
            proxy_pass http://backend;
        }
    }
}

location /admin/ {
    # 1. IP 黑白名单（access 模块）
    allow 192.168.1.0/24;
    allow 10.0.0.0/8;
    deny  all;

    # 2. HTTP Basic 认证
    auth_basic           "Admin Area";
    auth_basic_user_file /etc/nginx/.htpasswd;

    # 3. 子请求鉴权（把鉴权委托给后端服务）
    auth_request /auth-check;
}

location /internal/ {
    satisfy any;              # 任一通过即可（默认是 all，全部通过才行）
    allow 10.0.0.0/8;         # 内网直接放行
    deny  all;
    auth_basic "Login";       # 外网要输密码
    auth_basic_user_file /etc/nginx/.htpasswd;
}

location /api/ {
    auth_request /auth;
    # 从鉴权响应头里取值，传给后端
    auth_request_set $user_id $upstream_http_x_user_id;
    proxy_set_header X-User-Id $user_id;
    proxy_pass http://backend;
}

location = /auth {
    internal;                              # 只允许内部访问，外部请求返回 404
    proxy_pass http://auth-service/verify;
    proxy_pass_request_body off;           # 不转发请求体，鉴权服务不需要
    proxy_set_header Content-Length "";
    proxy_set_header X-Original-URI $request_uri;
}

location / {
    # 依次尝试：$uri 文件 → $uri/ 目录 → 交给 /index.html
    try_files $uri $uri/ /index.html;
}

location /api/ {
    # 最后一个参数可以是 =状态码，或者一个 location
    try_files $uri @backend;
}

location @backend {              # 命名 location，只能内部跳转
    proxy_pass http://app;
}

location /api/ {
    mirror /mirror;
    mirror_request_body on;
    proxy_pass http://prod-backend;
}

location = /mirror {
    internal;
    proxy_pass http://shadow-backend$request_uri;
}

location /test {
    return 200 "hello";
    proxy_pass http://backend;   # 永远执行不到
}

content handler 产生响应头
   ↓
ngx_http_not_modified_filter    处理 If-Modified-Since，可能改成 304
   ↓
ngx_http_headers_filter         执行 add_header / expires
   ↓
ngx_http_userid_filter          设置 cookie
   ↓
ngx_http_ssi_filter
   ↓
ngx_http_gzip_filter            决定是否压缩，设置 Content-Encoding
   ↓
ngx_http_range_filter           处理 Range 请求，可能改成 206
   ↓
ngx_http_chunked_filter         没有 Content-Length 时改成 chunked
   ↓
ngx_http_header_filter          把 header 序列化成字节流（链尾）

content handler 产生响应体（一个 ngx_chain_t 链表）
   ↓
ngx_http_sub_filter             sub_filter 字符串替换
   ↓
ngx_http_ssi_filter             SSI 指令处理
   ↓
ngx_http_gzip_filter            实际压缩数据
   ↓
ngx_http_range_body_filter      切出 Range 请求的片段
   ↓
ngx_http_chunked_filter         加 chunk 头
   ↓
ngx_http_write_filter           调用 sendfile/writev 真正写出去（链尾）

typedef struct ngx_chain_s {
    ngx_buf_t    *buf;
    ngx_chain_t  *next;
} ngx_chain_t;

rewrite ^/old/(.*)$ /new/$1 last;     # last → 内部重定向
try_files $uri /index.html;           # 回退到 /index.html → 内部重定向
error_page 404 /404.html;             # 错误页 → 内部重定向
X-Accel-Redirect                       # 上游返回这个头 → 内部重定向

location /download/ {
    proxy_pass http://backend;    # 后端校验权限后返回 X-Accel-Redirect: /protected/file.zip
}

location /protected/ {
    internal;                     # 客户端不能直接访问
    alias /data/files/;
    # Nginx 用 sendfile 高效发送，后端进程立刻释放
}

error_log /var/log/nginx/debug.log debug;

# 或者只对特定 IP 开 debug，避免日志爆炸
events {
    debug_connection 192.168.1.100;
}

[debug] http process request line
[debug] http request line: "GET /api/user HTTP/1.1"
[debug] http process request header line
[debug] test server name: "example.com"
[debug] rewrite phase: 1
[debug] test location: "/api/"
[debug] using configuration "/api/"
[debug] http cl:-1 max:1048576
[debug] rewrite phase: 3
[debug] post rewrite phase: 4
[debug] generic phase: 5          ← PREACCESS
[debug] generic phase: 6
[debug] access phase: 7
[debug] access phase: 8
[debug] post access phase: 9
[debug] generic phase: 10         ← PRECONTENT
[debug] http init upstream, client timer: 0
[debug] http upstream request: "/api/user"
[debug] http upstream process header
[debug] http proxy status 200 "200 OK"
[debug] http output filter "/api/user?"
[debug] http postpone filter
[debug] http write filter: l:1 f:0 s:1024
[debug] http finalize request: 0
[debug] http log handler                      ← LOG 阶段