Nginx 性能调优与负载均衡

# nginx.conf 全局段
# worker 进程数：建议等于 CPU 物理核心数（不含超线程）
# 可通过 nproc 查看，或 auto 自动匹配
worker_processes auto;

# CPU 亲和性：将 worker 绑定到固定 CPU 核心，减少缓存失效
# 假设 8 核，对应 8 个 worker
worker_cpu_affinity 00000001 00000010 00000100 00001000 \
                    00010000 00100000 01000000 10000000;

# worker_rlimit_nofile：每个 worker 可打开的最大文件描述符
# 需与系统 ulimit -n 配合，建议 ≥ worker_connections 的 2 倍
worker_rlimit_nofile 65535;

events {
    # Linux 必选 epoll，FreeBSD 选 kqueue，兼容默认 select 性能极差
    use epoll;
    
    # 每个 worker 的最大连接数
    # 反向代理场景下，每个连接会占用 2 个 FD（客户端 + upstream）
    # 因此实际并发 = worker_connections * worker_processes / 2
    worker_connections 10240;
    
    # 允许一个 worker 同时接收多个连接（仅 Linux 支持）
    # 在高并发突增场景下显著提升 accept 吞吐
    multi_accept on;
}

http {
    # 启用 sendfile：内核态直接拷贝文件到 socket，跳过用户态缓冲
    # 对静态资源服务提升明显，动态代理场景下意义不大
    sendfile on;
    
    # 与 sendfile 配合：将响应头与文件内容合并为一次发送
    # 适用于大文件下载、静态资源分发
    tcp_nopush on;
    
    # 禁用 Nagle 算法：小包立即发送，降低交互式请求延迟
    # 对 API 网关、WebSocket 等小包场景友好
    tcp_nodelay on;
    
    # keepalive 超时：65s 是常见值，长连接场景可调到 120s
    keepalive_timeout 65s;
    # 单个 keepalive 连接上的最大请求数，达到后强制关闭
    keepalive_requests 10000;
}

http {
    upstream backend {
        server 10.0.0.1:8080 max_fails=3 fail_timeout=30s;
        server 10.0.0.2:8080 max_fails=3 fail_timeout=30s;
        
        # 保持到后端的长连接池大小
        # 每个 worker 独立维护，总连接数 = keepalive * worker_processes
        keepalive 64;
        
        # 控制单次请求的连接复用策略
        keepalive_requests 1000;
        keepalive_timeout 60s;
    }
    
    server {
        location /api/ {
            proxy_pass http://backend;
            
            # 必须设置 HTTP/1.1 才能复用长连接，默认是 HTTP/1.0
            proxy_http_version 1.1;
            # 清除 Connection: close，让长连接生效
            proxy_set_header Connection "";
            
            # 请求体缓冲：小于 buffer 则内存暂存，大于则写临时文件
            proxy_request_buffering on;
            client_body_buffer_size 16k;
            client_max_body_size 10m;
            
            # 响应缓冲：避免 Nginx 边收边转发给客户端导致后端连接被占用
            proxy_buffering on;
            proxy_buffer_size 4k;
            proxy_buffers 8 4k;
            proxy_busy_buffers_size 8k;
        }
    }
}

http {
    # gzip：兼容性最好，CPU 开销低
    gzip on;
    gzip_min_length 1k;              # 小于 1KB 不压缩
    gzip_comp_level 6;               # 压缩级别 1-9，6 是性价比平衡点
    gzip_types text/plain application/json application/javascript
               text/css application/xml image/svg+xml;
    gzip_vary on;                    # 在响应头加 Vary: Accept-Encoding
    gzip_proxied any;                # 反向代理场景下也启用压缩
    
    # brotli：需 ngx_brotli 模块（1.27.x 已可通过动态模块加载）
    # 压缩率比 gzip 高 15-25%，但 CPU 开销略大
    # 对 API 网关返回的 JSON、前端静态资源收益明显
    # brotli on;
    # brotli_comp_level 4;
    # brotli_types text/plain application/json application/javascript text/css;
}

http {
    # 1. 加权轮询：按服务器能力分配
    upstream weighted_backend {
        server 10.0.0.1:8080 weight=5;   # 高配机器
        server 10.0.0.2:8080 weight=3;   # 中配机器
        server 10.0.0.3:8080 weight=2;   # 低配机器
        keepalive 64;
    }
    
    # 2. 最少连接 + 权重：动态负载均衡
    upstream least_conn_backend {
        least_conn;
        server 10.0.0.1:8080 weight=5 max_fails=3 fail_timeout=30s;
        server 10.0.0.2:8080 weight=3 max_fails=3 fail_timeout=30s;
        server 10.0.0.3:8080 weight=2 max_fails=3 fail_timeout=30s;
        keepalive 64;
    }
    
    # 3. IP 哈希：会话保持
    upstream session_backend {
        ip_hash;
        server 10.0.0.1:8080;
        server 10.0.0.2:8080;
        # 注意：ip_hash 与 keepalive 不冲突，但后端需支持会话
    }
    
    # 4. 一致性哈希：基于请求 URI 哈希，缓存友好
    upstream cache_backend {
        hash $request_uri consistent;
        server 10.0.0.1:8080;
        server 10.0.0.2:8080;
        server 10.0.0.3:8080;
    }
    
    # 5. 随机 + two_choice：随机选两个，挑连接数少的（减少羊群效应）
    upstream random_backend {
        random two;
        server 10.0.0.1:8080;
        server 10.0.0.2:8080;
        server 10.0.0.3:8080;
    }
}

# 被动健康检查（开源版内置）
upstream backend {
    server 10.0.0.1:8080 max_fails=3 fail_timeout=30s;
    server 10.0.0.2:8080 max_fails=3 fail_timeout=30s;
    # max_fails=3：30s 内失败 3 次则标记为不可用
    # fail_timeout=30s：不可用持续 30s 后再次尝试
}

# 主动健康检查（Nginx Plus 或第三方模块）
# location /health {
#     health_check interval=5s fails=3 passes=2 uri=/healthz;
#     proxy_pass http://backend;
# }

server {
    # 同时监听 TCP（HTTP/2 兼容）与 UDP（HTTP/3）
    listen 443 ssl;
    listen 443 quic reuseport;          # reuseport 让多 worker 共享 UDP socket
    http2 on;
    http3 on;
    
    server_name api.example.com;
    
    ssl_certificate     /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;
    ssl_protocols       TLSv1.3;        # HTTP/3 强制要求 TLS 1.3
    
    # 通告客户端可升级到 HTTP/3
    add_header Alt-Svc 'h3=":443"; ma=86400';
    
    location / {
        proxy_pass http://backend;
    }
}

http {
    # 限流区域定义：基于客户端 IP，每秒 100 请求，突发 50
    # zone=api_rl:10m 表示用 10MB 内存存 IP 状态，约可记录 16 万个 IP
    limit_req_zone $binary_remote_addr zone=api_rl:10m rate=100r/s;
    
    # 并发连接数限流：单 IP 同时最多 50 个连接
    limit_conn_zone $binary_remote_addr zone=conn_rl:10m;
    
    server {
        location /api/ {
            # 限流：burst=50 突发请求排队，nodelay 不延迟突发请求
            limit_req zone=api_rl burst=50 nodelay;
            limit_conn conn_rl 50;
            
            # 限流响应码：默认 503，建议改为 429 让客户端识别
            limit_req_status 429;
            limit_conn_status 429;
            
            proxy_pass http://backend;
        }
        
        # 分级限流：不同接口不同速率
        location /api/login {
            # 登录接口：每秒 10 请求，防止暴力破解
            limit_req zone=api_rl burst=5 nodelay;
            proxy_pass http://backend;
        }
        
        location /api/search {
            # 搜索接口：每秒 200 请求
            limit_req zone=api_rl burst=100 nodelay;
            proxy_pass http://backend;
        }
    }
}

upstream backend {
    server 10.0.0.1:8080 max_fails=5 fail_timeout=30s;
    server 10.0.0.2:8080 max_fails=5 fail_timeout=30s;
    # 备用后端：主集群全部失败后启用
    server 10.0.0.10:8080 backup;
}

server {
    location /api/ {
        proxy_pass http://backend;
        
        # 触发切换到下一台的错误条件
        proxy_next_upstream error timeout http_502 http_503 http_504;
        # 重试次数与时间限制，避免雪崩
        proxy_next_upstream_tries 3;
        proxy_next_upstream_timeout 5s;
        
        # 后端全部失败时的兜底页面
        error_page 502 503 504 /fallback.html;
        location = /fallback.html {
            root /usr/share/nginx/html;
            internal;
        }
    }
}

# 通过 split_clients 按比例分流
split_clients "${remote_addr}${http_user_agent}" $upstream_pool {
    10%  canary;          # 10% 流量到灰度集群
    *    stable;          # 90% 流量到稳定集群
}

upstream stable {
    server 10.0.0.1:8080;
    server 10.0.0.2:8080;
}

upstream canary {
    server 10.0.0.10:8080;   # 灰度版本实例
}

server {
    location /api/ {
        # 指定用户强制走灰度（通过 Cookie 或 Header）
        # 配合 map 实现精细化路由
        map $cookie_gray_release $target_pool {
            "true"  canary;
            default $upstream_pool;
        }
        
        proxy_pass http://$target_pool;
    }
}

# 通过 Lua 访问 Redis 实现动态路由
location /api/ {
    access_by_lua_block {
        local redis = require "resty.redis"
        local red = redis:new()
        red:set_timeout(100)  -- 100ms 超时
        
        local ok, err = red:connect("10.0.0.5", 6379)
        if not ok then
            ngx.log(ngx.WARN, "redis connect failed: ", err)
            return  -- 连接失败时走默认路由
        end
        
        -- 根据请求路径查询路由表
        local route = red:get("route:" .. ngx.var.uri)
        if route and route ~= ngx.null then
            ngx.var.upstream = route  -- 动态修改 upstream
        end
        
        red:set_keepalive(10000, 100)  -- 连接池复用
    }
    
    set $upstream "default_backend";
    proxy_pass http://$upstream;
}