1

int epoll_create(int size);

1

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

1

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

1
2
3
4

struct epoll_event {
    uint32_t events;    // 事件类型
    epoll_data_t data;  // 用户数据
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 编译环境准备
apt install build-essential gcc g++ libc6 libc6-dev libpcre3 libpcre3-dev libssl-dev libsystemd-dev zlib1g-dev

apt install libxml2 libxml2-dev libxslt1-dev php-gd libgd-dev geoip-database libgeoip-dev

# 创建运行用户
useradd -r -s /usr/sbin/nologin nginx

# 下载最新版源码并解压
wget https://nginx.org/download/nginx-1.24.2.tar.gz
tar xf nginx-1.24.2.tar.gz

# 定制配置
cd nginx-1.24.2/
./configure --prefix=/nginx --user=nginx --group=nginx --with-http_ssl_module --with-http_v2_module --with-http_realip_module --with-http_stub_status_module --with-http_gzip_static_module --with-pcre --with-stream --with-stream_ssl_module --with-stream_realip_module

./configure --prefix=/nginx --user=nginx --group=nginx --with-compat --with-debug --with-pcre-jit --with-http_ssl_module --with-http_stub_status_module --with-http_realip_module --with-http_auth_request_module --with-http_v2_module --with-http_dav_module --with-http_slice_module --with-threads --with-http_addition_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_secure_link_module --with-http_sub_module --with-mail_ssl_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-stream_realip_module --with-http_geoip_module=dynamic --with-http_image_filter_module=dynamic --with-http_perl_module=dynamic --with-http_xslt_module=dynamic --with-mail=dynamic --with-stream=dynamic --with-stream_geoip_module=dynamic

# 编译安装
make && make install

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 修改目录属主属组并查看
chown -R nginx:nginx /nginx/

# 创建软链接
ln -sv /nginx/sbin/nginx /usr/sbin/nginx

# 导入手册
cp man/nginx.8 /usr/share/man/man8/

mandb

# 创建PID 目录
mkdir /nginx/run

vim /nginx/conf/nginx.conf
pid    /nginx/run/nginx.pid;

# 创建nginx服务脚本
vim /usr/lib/systemd/system/nginx.service
[Unit]
Description=nginx - high performance web server
Documentation=http://nginx.org/en/docs/
After=network-online.target remote-fs.target nss-lookup.target
Wants=network-online.target

[Service]
Type=forking
PIDFile=/nginx/run/nginx.pid
ExecStart=/nginx/sbin/nginx -c /nginx/conf/nginx.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID
LimitNOFILE=100000

[Install]
WantedBy=multi-user.target

# 重载服务脚本
systemctl daemon-reload
systemctl start nginx

1
2
3
4
5
6
7

# 检查配置文件语法，并测试配置文件
nginx -t

nginx -g "worker_processes 3;"

# 前台运行
nginx -g "daemon off;"

1
2
3
4
5
6
7
8

stop                 #立即停止，没处理完的请求也会被立即断开，相当于信号 SIGTERM,SIGINT
quit                 #优雅退出，不再接收新的请求，但己建立的连接不受影响，相当于信号 SIGQUIT
reopen               #重开一个新的日志文件，日志内容写新文件，相当于信号 SIGUSR1
reload               #重新加载配置文件，重新生成worker 进程，不中断正在处理的请求，
                     #己建立的连接按旧配置处理，新连接用新配置处理
                     #同 systemctl reload nginx
SIGUSR2              #平滑升级二进制文件，适用于版本升级
SIGWINCH             #优雅的停止工作进程，适用于版本升级

1
2
3
4
5

# 服务端发送 stop 信号，客户端会立即断开
nginx -s stop

# 服务端发送 quit 信号，服务器完成传输后退出
nginx -s quit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

- 新版本或配置准备：
 准备好新版本的 Nginx 可执行文件或配置文件，并确保它们没有问题
- 新版本资源替换旧版本资源：
 进行资源替换，此步骤要备份旧版本资源，可以用作回滚
- 发送信号：
 使用 nginx -s SIGUSR2，nginx -s reload 等方式向 Nginx 主进程发送重新加载的信号
- 新的工作进程启动：
 Nginx 主进程接收到重新加载信号后，会启动新的工作进程，并使用新的配置文件或软件版本
- 平滑过渡：
 新的工作进程逐渐接管现有的连接。现有的连接会在旧的工作进程中继续处理，而新的连接会由新的工作
进程处理
- 旧的进程退出：
 当旧的工作进程不再有活动连接时，它会被关闭

1
2

nginx -V
# 查看现有版本配置，完全复制

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

./configure --with-cc-opt='-g -O2 -fno-omit-frame
pointer -mno-omit-leaf-frame-pointer -ffile-prefix-map=/build/nginx-DlMnQR/nginx
1.25.0=. -flto=auto -ffat-lto-objects -fstack-protector-strong -fstack-clash
protection -Wformat -Werror=format-security -fcf-protection -fdebug-prefix
map=/build/nginx-DlMnQR/nginx-1.25.0=/usr/src/nginx-1.25.0-2ubuntu7.1 -fPIC
Wdate-time -D_FORTIFY_SOURCE=3' --with-ld-opt='-Wl,-Bsymbolic-functions
flto=auto -ffat-lto-objects -Wl,-z,relro -Wl,-z,now -fPIC' -
prefix=/usr/share/nginx --conf-path=/etc/nginx/nginx.conf --http-log
path=/var/log/nginx/access.log --error-log-path=stderr --lock
path=/var/lock/nginx.lock --pid-path=/run/nginx.pid --modules
path=/usr/lib/nginx/modules --http-client-body-temp-path=/var/lib/nginx/body -
http-fastcgi-temp-path=/var/lib/nginx/fastcgi --http-proxy-temp
path=/var/lib/nginx/proxy --http-scgi-temp-path=/var/lib/nginx/scgi --http-uwsgi
temp-path=/var/lib/nginx/uwsgi --with-compat --with-debug --with-pcre-jit --with
http_ssl_module --with-http_stub_status_module --with-http_realip_module --with
http_auth_request_module --with-http_v2_module --with-http_dav_module --with
http_slice_module --with-threads --with-http_addition_module --with
http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with
http_mp4_module --with-http_random_index_module --with-http_secure_link_module -
with-http_sub_module --with-mail_ssl_module --with-stream_ssl_module --with
stream_ssl_preread_module --with-stream_realip_module --with
http_geoip_module=dynamic --with-http_image_filter_module=dynamic --with
http_perl_module=dynamic --with-http_xslt_module=dynamic --with-mail=dynamic -
with-stream=dynamic --with-stream_geoip_module=dynamic

1
2
3
4
5

make    # 不要执行 make install，make install可能会将旧配置替换
# 库文件都是携带版本号的，编译的时候，很多是不带版本号的，所以创建一个软连接
# 编译会报错，哪个库文件报错，创建哪个不带版本号的软链接
ln -s /usr/lib/x86_64-linux-gnu/libperl.so.5.38 /usr/lib/x86_64-linux-gnu/libperl.so
## --with-http_perl_module=dynamic

1
2

# 确认生成的文件
ls objs/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 新旧版本切换

# 备份旧执行文件
mv /usr/sbin/nginx /usr/sbin/nginx-1.24

# 应用新执行文件
chmod +x ./objs/nginx
cp ./objs/nginx /usr/sbin/

# 为了避免版本兼容性相关的问题，删除启用动态功能模块.
rm -rf /etc/nginx/modules-enabled/*

# nginx 检测，配置文件可用，版本己更新
nginx -t

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# master进程交接

# 向旧版本master进程发起信号
kill -USR2 26077

# kill -USR2 命令会让 Nginx 主进程通过发送 USR2 信号来启动一个新的主进程，该新主进程会加载新的二进制文件（比如升级后的 Nginx 可执行文件）。

# 新版本master挂再旧版本master下

# 让旧版本master下的工作进程 优雅退出；关闭旧的 woker 进程，新请求交由新的 worker 进程处理
kill -WINCH 26077

# 旧版本woker 进程全部退出，但是旧的master进程依然处于存活状态。

# 旧版本master退出
kill -QUIT 26077
# done

# 不直接使用QUIT信号的原因
# QUIT会停止nignx的接收后续请求；新请求也不会交给新的 worker 进程处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 执行文件替换
mv /usr/sbin/nginx /usr/sbin/nginx-1.25
mv /usr/sbin/nginx-1.24 /usr/sbin/nginx

# 依然是新版本的nginx提供服务访问

# 拉起旧版本master
kill -HUP 26077
# 旧master拉起俩worker

# 退出新版本master
kill -QUIT 31819

1
2
3
4

0 准备nginx源码- 如果本地没有源码的话，可以从官网下载一个同版本的nginx源码
1 下载模块
2 编译安装
3 测试效果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

ngx_http_upstream_hash_module
实现基于哈希的负载均衡，可以根据请求的某些特征（如URL、请求头等）来计算哈希值，并将请求分发到相应的后端服务器。这有助于实现更智能、更均衡的负载均衡策略。

echo-nginx-module
在Nginx中输出一些信息，可以用来实现简单接口或排错。通过配置该模块，可以在Nginx中直接打印变量值、处理结果等信息，方便开发者进行调试和测试。

WebDAV支持模块
为Nginx添加WebDAV（基于HTTP的远程文件访问协议）支持，使得用户可以通过HTTP协议对服务器上的文件进行上传、下载、删除等操作。

Lua脚本集成模块
允许在Nginx中集成Lua脚本，实现更复杂的请求处理和响应生成逻辑。通过Lua脚本，可以灵活地处理请求参数、访问后端服务、生成响应内容等。

https://github.com/vozlt/nginx-module-vts           # 第三方流量监控模块
https://github.com/openresty/echo-nginx-module        #  echo 模块，可以直接输出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 编译安装时带上
--add-module=/usr/local/echo-nginx-module-0.63

# 编译
make

# 替换执行文件
mv /usr/sbin/nginx /usr/sbin/nginx-1.24
chmod +x ./objs/nginx
cp ./objs/nginx /usr/sbin/

# 重启服务
systemctl restart nginx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# --- 全局配置段 --
user ...;
worker_processes ...;
...

# --- 事件驱动相关的配置 --
events {
    ...;
}

# --- http/https 协议相关配置段 ---
http {
    ...;
    server {
        ...;
        location {
            ...;
        }
    }
}

# --- mail 协议相关配置段，默认被注释 --
mail {
    server {
        ...;
    }
}

# --- stream 协议相关配置 --
stream {
    ...;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

user <user> [group];                    # 指定worker 进程运行时的用户和组，默认值为 nobody

worker_processes  auto|N;               # worker 进程数量

worker_cpu_affinity auto|cpumask;       # 绑定CPU核心
                                        # 几个CPU几个0
                                        # 双核：01   10
                                        # 四核：0001 0010 0100 1000

pid /path/file;                         # pid 文件路径

worker_priority N;                      # worker 进程优先级，默认值为0
                                        # 此处设定的是 nice 值，取值为 -20 到 19

worker_rlimit_nofile N;                 # 所有worker进程可以打开的文件描述符数量之和，默认不限制
                                        # 此值并不仅仅是指nginx 与客户端的连接数，包括与后端服务的连接数

daemon on|off;                          # 默认值为on, 表示以后台守护进程方式运行，off 表示前台运行

master_process on|off;                  # 默认值为on, 表示以 master-worker 模式运行，off 只有master进程，用于开发调试

include /path/file;                     # 文件包含,指定要包含的文件路径及规则，可以使用通配符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

events {

worker_connections N;                   # 默认值512，单个worker进程所支持的最大并发连接数

multi_accept on|off;                    # 默认值 off，on 表示worker 进程一次可以接收多个新的连接请求

accept_mutex on|off;                    # 默认值 off，表示master 进程获得客户端请求后，
                                        # 会通知所有的worker 进程，由当前状态最佳的worker进程处理请求；
                                        # 此过程也被称为 惊群。多个worker同时竞争致性能问题
                                        # on 表示 master 进程轮流给 worker进程分配要处理的连接，此处建议设置为 on

use method;                                 # 指定事件驱动模型,默认不设置此项，nginx 会根据当前系统自行选择
                                            # 可用值 select|pool|kqueue|epoll|/dev/poll|eventport
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

http {
charset  charset|off;                       # 是否在响应头 Content-Type 行中添加字符集，默认 off
                                            # 中文字符集 utf-8

sendfile on|off;                            # 默认值 off，on表示使用 sendfile 函数来传送数据,即零拷贝
                                            # on：在文件描述符之间传输数据，不需要在用户态和内核态之间反复切换。静态文件的高效传输
# 零拷贝技术，数据不经过用户缓冲区
# 1. sendfile 将静态数据直接从内核缓冲区发出
# 2. 内存映射（Memory Mapping，mmap）将内核空间地址映射到用户空间，这就可用直接处理内核空间的数据

tcp_nopush on|off;                          # 默认值 off。减少 TCP 数据包的分片，提升传输效率。将小数据合并

tcp_nodelay on|off;                         # Nagle 算法 相关的配置项，主要用于优化小数据包的发送。
                                            # off：小数据包延迟0.2秒发送
                                            # on：禁用 Nagle 算法。小数据包会立即发送，无需等待缓冲区填满或接收到ACK。

# tcp_nopush与tcp_nodelay同时开启时，小数据包会被合并，0.2秒后一起发送

keepalive_timeout timeout [header_timeout];   # 会话保持的时长，单位为秒，第二个值会出现在响应头中，可以和第一个值不一样

keepalive_requests number;                    # 一次请求不断开连接的情况下最多可以传送多少个资源
                                              # 默认值 keepalive_requests 1000;

types_hash_max_size N;                        # 默认值1024，用于设置 MIME 类型哈希表大小

server_tokens on|off|build|string;            # 默认值on，是否在响应头中显示 nginx 信息，off 表示不显示

server_names_hash_bucket_size N;              # 默认值32|64|128，服务器名哈希桶大小，当配置了大量虚拟主机时，
                                              #此项可用来提升性能

server_name_in_redirect on|off;               # 默认值off,表示在重定向时响应头中不包含 Server行
                                              # on 表示显示 Server 头
include /etc/nginx/mime.types;                # #规定了各种后缀文件在响应报文中的 Content-Type 对应的值

default_type application/octet-stream;        # 除了上述映射外，其它类型文件都用此值

ssl_protocols [SSLv2] [SSLv3] [TLSv1|.1|.2|.3];    # 当前nginx 可支持的 ssl协议版本

ssl_prefer_server_ciphers on|off;             # 默认off，表示在 SSL/TLS 握手时优先使用客户端加密套件

access_log path [format [buffer=size] [gzip[=level]] [flush=time] [if=condition]];

error_log file [level];

error_page code ... [=[response]] uri;        # 定义指定状态码的错误页面，可以多个状态码共用一个资源

# 压缩配置
gzip on|off;

gzip_vary on|off;                      #在启用了压缩的情况下，是否在响应头中添加 Vary: Accept-Encoding 行，默认off

gzip_proxied off|expired|no-cache|no-store|private|no_last_modified|no_etag|auth|any ...;

gzip_comp_level N;
gzip_buffers number size;

gzip_http_version N;

gzip_min_length length;                # 资源体积多大才启用压缩，默认20，

gzip_types mime-type ...;              # 根据 MIME 来决定是否对数据进行压缩,默认值text/html

# 站点配置
server { ... }
# 见下文
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

server {
listen address[:port] [default_server] [ssl];
listen port [default_server] [ssl];
listen unix:path [default_server] [ssl];

# default_server：将当前 server 块设置为默认服务器，处理未匹配任何 server_name 的请求。
# ssl：启用 SSL/TLS（HTTPS）支持

ssl_certificate  file;

ssl_certificate_key file;

ssl_session_cache off|none|[builtin[:size]] [shared:name:size];    # 是否启用 ssl 缓存，默认 none

ssl_session_timeout N;                      # 客户端连接可以复用 ssl session cache 中缓存的有效时长，默认5m

ssl_ciphers ciphers;                        # 指定 SSL/TLS 加密算法，默认值 HIGH:! aNULL:! MD5;

ssl_prefer_server_ciphers on|off;           # 默认 off，表示在 SSL/TLS 握手时优先使用客户端加密套件，
                                            # on 表示优先使用服务端套件



server_name example.com;                    # 虚拟主机域名，可以写多个值，客户端请求头中的 Host 字段会与此处匹配
                                            # 默认值是 ""，用来匹配请求头中 Host 字段值为空的请求
                                            # 还可以写成 _,@ 等用来表示无效域名，和 listen 中的 default_server 配合

root /nginx/html;                           # 当前虚拟主机网页文件目录，写在 location 中，文件路径是 root+location
index index.html index.htm;


}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

server {
    listen 80 default_server;
    server_name www.a.com;
    root /data/server/nginx/web1;
}

server {
    listen 80;
    server_name www.b.com;
    root /data/server/nginx/web2;
}

server {
    listen 80;
    server_name www.c.com;
    root /data/server/nginx/web3;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Location /  { ... }
Location /string  { ... }

Location [ = | ~ | ~* | ^~ ] uri { ... }
# = ：精确匹配。
# ~ ：区分大小写的正则匹配。
# ~* ：不区分大小写的正则匹配。
# ^~：优先的前缀匹配（用于关闭正则匹配）。

Location @name  { ... }
# 定义一个 name 的动作，供调用
error_page 404 = @not_found;
location @not_found {
        return 404 "Custom 404 Page Not Found";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Location {
alias path;                                            # 定义路径别名，把访问路径重新映射到其它目录

root path;                                             # 定义网站在文件系统上的家目录

index file ...;

return code [text]|code URL|URL;                       # 直接给客户端返回状态码+字符串或 URL

proxy_pass URL;                                        # 设置反向代理，将符合规则的请求转发到后端服务器进行处理

fastcgi_pass address;

fastcgi_index name;

fastcgi_param parameter value [if_not_empty];

deny address|CIDR|unix:|all;                           # 拒绝访问的客户端，黑名单

allow address|CIDR|unix:|all;                          # 允许访问的客户端，白名单，可以是具体 IP

try_files file ... uri|file ... = code;                # 按顺序查询文件是否存在，并返回匹配到的信息

}

1
2
3

location = /login {
    return 200 "This is the login page.";
}

1
2
3

location ~ \.php$ {
    fastcgi_pass 127.0.0.1:9000;
}

1
2
3
4

ocation ~* \.(jpg|jpeg|png|gif|ico)$ {
    expires max;
    log_not_found off;
}

1
2
3

location ^~ /static/ {
    root /var/www/static;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

location /img/ {
    alias /var/www/image/;
}
# http://localhost/img/，nginx 找/var/www/image/目录下的文件

location /img/ {
    root /var/www/image;
}
# http://localhost/img/，nginx 找/var/www/image/img/目录下的文件

# 一般情况下，在 location /中配置 root，在 location /other 中配置 alias

1
2
3
4
5
6
7

location /web3/ {
    alias /data/server/nginx/web3/;
    allow 127.0.0.1;    # 放行 127.1
    deny 10.0.0.13;     # 拒绝 10.0.0.13
    allow 10.0.0.0/24;  # 放行 10.0.0.0/24 所有 IP，但 10.0.0.13 在上一条被拒绝
    deny all;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

server {
    listen 80 default_server;
    error_page 400 502 503 504 error.html;

    location = /error.html {
        root /data/server/nginx/errors/;
    }

    location = /error2.html {
        # 通过 302 临时重定向到 index.hmtl
        error_page 400 404 = 302 /index.html;
    }

    error_page 404 @error;

     location @error {
         default_type text/html;
         return 200 "page not found\n";
     }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

server {
    listen 80 default_server;
    try_files $uri $ uri.html $uri/index.html /index.html;

    # 如果有 web1 或 web1.html 会匹配到，返回状态码是 200，如果没有则返回 404 错误页面
    location /web1 {
         try_files $uri $ uri.html = 404;
    }

}

1
2

# 自定义变量
set $variable value;

1
2
3
4

limit_rate rate;        #对单个客户端连接限速，默认单位为字节，其它单位需要显式指定，
                        #表示每秒的下载速度，限速只对单一连接而言，同一客户端两个连接，
                        #总速率为限速 2 倍，默认值 0，表示不限制
limit_rate_after size;  #在传输了多少数据之后开始限速，默认值 0，表示一开始就限速

1
2
3
4
5
6
7
8

limit_conn_zone key zone = name: size;        # 定义一个限速规则，供 limit_req 指令调用

limit_conn zone number;                       # zone 表示要调用的规则，number 表示要限制的连接数，不能写变量

# 定义一个名为 perip 的共享内存区域，用于存储基于客户端二进制 IP 地址的连接状态，内存大小为 10MB。
limit_conn_zone $binary_remote_addr zone = perip: 10m;
# 限制每个客户端最多允许 20 个并发连接。
limit_conn perip 20;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

limit_conn_zone \$binary_remote_addr zone = mylimit: 10m;

server {
    listen 80 default_server;
    root /data/server/nginx/web1;

    location /100M.img {
        limit_rate 10k;         #每秒下载速度为 10K
        limit_rate_after 1m;    #前 1M 不开启限速
    }

    location /200M.img {
        limit_rate 10k;         #每秒下载速度为 10K
        limit_conn mylimit 2;   #限制每个客户端最多允许 2 个并发连接。

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 定制 mylimit 内存区域，用于存储客户端二进制 IP 地址的连接状态，内存大小为 10MB。限制每秒请求数为 2 个。
# 2r/s，也就是说 nginx 在 500ms 里面可以处理 1 个请求
limit_req_zone \$binary_remote_addr zone = mylimit: 10m rate = 2r/s;

server {
    listen 80 default_server;
    root /data/server/nginx/web1;

    location / {
        limit_req zone = mylimit burst = 5 nodelay;     # 调用请求规则
        # burst = 5：允许额外的 5 个突发请求。
        # nodelay：立即处理突发请求，不引入额外延迟。
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

ssl on|off;

ssl_buffer_size size;                    # 在读取和写入 SSL/TLS 握手数据时使用的缓冲区大小，无关数据发送，默认值 16k

ssl_certificate file;                    # 虚拟主机的证书和 CA 机构的证书

ssl_certificate_key file;                # 私钥

ssl_protocols [SSLv2] [SSLv3] [TLSv1] [TLSv1.1] [TLSv1.2] [TLSv1.3];

ssl_session_cache off|none|[builtin[: size]] [shared:name:size];        # 配置 SSL 缓存

ssl_session_timeout time;                # 配置 SSL/TLS 会话缓存的超时时间，默认值 5m

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

 server {
        listen       443 default_server ssl;
        server_name  l00n9.icu;

        ssl_certificate      /nginx/conf/ssl/cert.pem;
        ssl_certificate_key  /nginx/conf/ssl/secret.key;

        ssl_session_cache    shared: SSL: 1m;
        ssl_session_timeout  5m;

        ssl_ciphers  HIGH:! aNULL:! MD5;
        ssl_prefer_server_ciphers  on;

        location / {
            root   html;
            index  index.html index.htm;
        }

    }

1
2
3
4
5
6
7

location ~* \.(jpg|jpeg|png|gif|mp4|webp)$ {
    valid_referers none blocked yourdomain.com *.yourdomain.com partner.com;

    if ($invalid_referer) {
        return 403;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

break;
# break 命令之后，ngx_http_rewrite_module 模块其他指令则不再生效，比如 set 和 return

return code [text];
return code URL;
return URL;
# 不写 code ，默认值为 302
# 直接向客户端返回状态码，字符串，或者 URL，
# 如果返回的字符串中包含空格，要加引号，如果返回 URL，要写完整
# 此指令后的其它指令或配置将不再执行，作用域 server, location, if

set $variable value;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

if (condition) { ... }
# if 指令仅能做单次判断，不支持 if else 多分支

# 支持的运算符
# =         比较变量和字符串是否相等
# !=        比较变量和字符串是否不相等
# ~         区分大小写，是否匹配正则，包含
# !~        区分大小写，是否不匹配正则，包含
# ~*        不区分大小写，是否匹配正则，包含
# !~*       不区分大小写，是否不匹配正则，不包含
# -f|!-f    判断文件是否存在|不存在
# -d|!-d    判断目录是否存在|不存在
# -x|!-x    判断文件是否可执行|不可执行
# -e|!-e    判断文件(包括文件，目录，软链接)是否存在|不存在

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

server {
    listen 80 default_server;
    root /data/server/nginx/web1;

    location /file {
        if (!-e \$request_filename){
            return 200 "\$request_filename 文件不存在";
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

server {
    listen 80 default_server;
    root /data/server/nginx/web1;

    location /noslow.img {
        break;
        set $slow 1;

        if ($slow) {
            limit_rate 10k;
        }
    }

    location /slow.img{
        set $slow 1;

        if ($slow) {
            limit_rate 10k;
        }
    }
}

1

rewrite regex replacement [flag]（可选）;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

location{
proxy_pass URL;                                      # 转发的后端服务器地址，可以写主机名,域名，IP地址，端口

proxy_pass_header field;                             # 显式指定要回传给客户端的后端服务器响应头中的字段

proxy_pass_request_body on|off;                      # 是否向后端服务器发送客户端 http 请求的body

proxy_pass_request_headers on|off;                   # 是否向后端服务器发送客户端 http 请求的头部信息

proxy_hide_header field;                             # 指定不回传的响应头字段

proxy_connect_timeout time;                          # Nginx与后端服务器建立连接超时时长

proxy_read_timeout time;                             # 等待后端服务器返回数据的超时时长

proxy_send_timeout time;                             # Nginx 向后端服务器发送请求的超时时长

proxy_set_body value;                                # 重新定义传给后端服务器的请求的正文

proxy_set_header field value;                        # 更改或添加请求头字段并发送到后端服务器

proxy_http_version 1.0|1.1;                          #

proxy_ignore_client_abort on|off;                    # 客户端中断连接，Nginx 是否继续执行与后端的连接

proxy_headers_hash_bucket_size size;                 # 设置nginx保存HTTP报文头的hash表的大小，默认值 64

proxy_headers_hash_max_size size;                    # hash表的大小上限，默认值 512

proxy_next_upstream error|timeout|invalid_header|...| off ...;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

server {
    listen 80 default_server;
    root /data/server/nginx/web1;

    location / {
        proxy_pass http://10.0.0.13:81; # 交给后端的81端口服务
        proxy_connect_timeout 2s; # 设置连接超时时间为2s
    }

    location /1 {
        proxy_pass http://10.0.0.13:88; # 交给后端的81端口服务
    }
}

server {
    listen 81 default_server;

    root /data/server/nginx/web2;
    access_log /var/log/nginx/access_client.log;
}

# 如果后端服务不可用，从客户端访问会返回502
# 如果连接后端服务器超时，会报504

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

proxy_cache zone|off;                    #  是否启用代理缓存

proxy_cache_path path [args];            # 开启代理缓存后指定缓存数据的存放路径

proxy_cache_key string;                  # 指定缓存数据的key，不同的key 对应不同的缓存文件
                                         # 默认$scheme$proxy_host$request_uri

proxy_cache_valid [code ...] time;       # 为不同响应状态码的数据设置不同的缓存时长

proxy_cache_use_stale error|timeout|invalid_header|...|off ...;
                                         # 在后端服务器报哪些错误的情况下，直接使用过期缓存数据响应请求
proxy_cache_methods GET|...;             # 缓存哪些请求类型的数据，默认值 GET HEAD

1
2
3
4

proxy_cache_path /tmp/proxycache levels=1:2 keys_zone=proxycache:20m inactive=60s max_size=1g;

# 这条proxy_cache_path指令配置了一个名为/tmp/proxycache的缓存目录，具有两级目录结构，
# 一个20MB的内存区域用于存储缓存键和元数据，缓存项在不活跃60秒后可以被删除，并且整个缓存目录的最大大小为1GB。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

proxy_cache_path /tmp/proxycache levels=1:2 keys_zone=proxycache:20m inactive=60s max_size=1g;

server {
    listen 80 default_server;
    server_name sswang.magedu.com;
    root /data/server/nginx/web1;

    location /static {
        rewrite ^/static(.*)$ /index.html break;  # 重写url

        proxy_pass http://10.0.0.14;
        proxy_set_header Host "static.magedu.com";
        proxy_cache proxycache;
        proxy_cache_key $request_uri;
        proxy_cache_valid 200 302 301 90s;
        proxy_cache_valid any 2m;
    }
}

1
2
3
4
5

# Apache Benchmark 模拟并发访问
ab -c 100 -n 10000 -H "sswang.magedu.com" 10.0.0.13/static+

# -c 100 并发数
# -n 10000 总请求数

1
2
3
4
5

# 记录代理服务器前一个IP
proxy_set_header X-Real-IP $remote_addr;

# 记录所有IP
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

stream {
     upstream mysqlserver{
        server 10.0.0.16:3306;
    }

    upstream redisserver{
        server 10.0.0.14:6379;
    }

    server{
        listen 3306;
        proxy_pass mysqlserver;
    }

    server{
        listen 6379;
        proxy_pass redisserver;
    }
}

1
2
3
4
5
6

fastcgi_index name;                # 后端 FastCGI 服务器默认资源，默认值为空

fastcgi_pass address;              # 指定后端 FastCGI 服务器地址，可以写 IP:port，也可以指定socket 文件

fastcgi_param parameter value [if_not_empty];
                                   # 设置传递给FastCGI服务器的参数值，

1
2
3
4
5
6

location ~ \.php$ {
        root           /nginx/html/wordpress;
        fastcgi_pass   127.0.0.1:9000;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        include        fastcgi_params;
}

1
2
3
4
5
6

upstream name {
    [...]
    server address [parameters];
    server address [parameters];
    ......
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

hash key [consistent];            # 使用自行指定的 Key 做 hash 运算后进行调度
                                  # consistent 表示使用一致性 hash,最大限度地减少了服务器变动

ip_hash;                          # 源地址hash调度方法,基于的客户端的remote_addr做hash

least_conn;                       # 最少连接调度算法，优先将客户端请求调度到当前连接最少的后端服务器

keepalive connections;            # 配置与后端服务器的 长连接数量

keepalive_time time;              # 保持活动连接的超时时间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

weight=number                        # 指定该 server 的权重，默认值都是1
max_conns=number                     # 该 Server 的最大活动连接数，达到后将不再给该 Server 发送请求，
                                     # 可以保持的连接数=代理服务器的进程数乘以max_conns,默认值0，表示不限制
max_fails=number                     # 后端服务器的下线条件,后端服务器连续进行检测多少次失败,而后标记为不可用，默认为1
                                     # 当客户端访问时，才会利用TCP触发对探测后端服务器健康性检查，而非周期性的探测

fail_timeout=time                    # 负载均衡池中被 排除的时间，超时后再次进行健康检查。默认为10秒
backup                               # 标记该 Server 为备用，当所有后端服务器不可用时，才使用此服务器
down                                 # 标记该 Server 临时不可用，可用于平滑下线后端服务器，
                                     # 新请求不再调度到此服务器，原有连接不受影响

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

upstream group1 {
    # 定制一个 三比一 的权重负载效果
    server 10.0.0.16 weight=3;
    server 10.0.0.15 backup；
    server 10.0.0.14 max_conns=2;
    server 10.0.0.14 down;           # 新请求不再调度到此服务器，原有连接不受影响
}

server {
    listen 80 default_server;
    location / {
        proxy_pass http://group1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

upstream group1 {
    ip_hash;
    server 10.0.0.16;
    server 10.0.0.14;
}

server {
    listen 80 default_server;
    location / {
        proxy_pass http://group1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

在一致性哈希中，所有可能的数据节点或服务器被映射到一个虚拟的环上。这个环的范围通常是一个固定的哈希空间，
比如0到2^32-1，每个数据节点或服务器被映射到环上的一个点，通过对其进行哈希计算得到。这个哈希值的范围也是在0到2^32-1之间。

在这个环上，数据会被分散到最接近它的节点。当有新的数据要存储时，首先通过哈希计算得到该数据的哈希值，
然后在环上找到离这个哈希值最近的节点，将数据存储在这个节点上。同样，当要查询数据时，也是通过哈希计算得到数据的哈希值，然后找到最近的节点进行查询。

由于哈希环是一个环形结构，节点的添加和删除对整体的影响相对较小。当添加或删除节点时，
只有相邻的节点受到影响，而其他节点保持不变。这使得一致性哈希算法在分布式系统中能够提供较好的负载均衡性能，同时减小了数据迁移的开销。

总的来说，一致性哈希中的哈希环是通过哈希计算将数据节点映射到环上，以实现数据分片和负载均衡的分布式算法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

upstream backend {
    hash $request_uri consistent;      # 一致性哈希，基于请求的 URI
    least_conn;                     # 最少连接调度算法
    keepalive 32;                   # 与后端服务器保持 32 个长连接
    keepalive_time 60s;             # 保持活动连接的时间为 60 秒

    server 192.168.1.1;
    server 192.168.1.2;
    server 192.168.1.3;
}

1
2
3

在一致性哈希中，哈希环可能会面临的一个问题是环偏移（Ring Wrapping）。环偏移指的是哈希环上的某个区域过于拥挤，而其他区域相对空闲，这可能导致负载不均衡。为了解决这个问题，一些改进的一致性哈希算法引入了虚拟节点（Virtual Nodes）的概念。

虚拟节点是对物理节点的一种扩展，通过为每个物理节点创建多个虚拟节点，将它们均匀地分布在哈希环上。这样一来，每个物理节点在环上的位置会有多个副本，而不是只有一个位置。这样一来，即使哈希环上的某个区域过于拥挤，也可以通过调整虚拟节点的数量来使得负载更均衡

1

least_conn;

1
2
3
4
5
6

upstream backend {
    zone backend_zone 64k;  # 创建名为 backend_zone 的共享内存区，大小为64K
    server backend1.example.com;
    server backend2.example.com;
    # ...其他配置如权重、失败重试等
}