安装

Windows安装

进入官方下载地址，选择合适版本（nginx/Windows-xxx）。

解压到本地

启动

1
start ./nginx.exe

Linux 安装

在线安装

安装

1
sudo apt install nginx

查看 Nginx 版本

1
nginx -v

编译安装

安装编译环境
1
apt install -y build-essential libpcre3 libpcre3-dev zlib1g-dev libssl-dev
下载Nginx源码

进入官方下载地址，复制合适的适版本（nginx-xxx）。

使用wget下载：

1
2
3
4
5
6
# 下载源码
wget https://nginx.org/download/nginx-1.23.3.tar.gz
# 解压源码
tar -xzvf nginx-1.23.3.tar.gz
# 进入源代码内
cd nginx-1.23.3
编译

配置编译

1
2
3
./configure #使用默认编译
# 或者
./configure --prefix=/usr/local/nginx --with-http_ssl_module --with-http_stub_status_module --with-http_gzip_static_module --with-http_realip_module --with-http_sub_module --with-http_flv_module --with-http_mp4_module #我的编译配置
编译参数说明

–with开头的，默认是禁用的(没启动的，想使用的话需要在编译的时候加上)

–without开头的，默认是启用的(不想启用此模块时，可以在编译的时候加上这个参数)

–help

1
打印帮助信息。

–prefix=path

1
定义将保留服务器文件的目录。此相同目录还将用于设置的所有相对路径 configure（库源路径除外）和nginx.conf配置文件中。/usr/local/nginx默认情况下设置为目录。

–sbin-path=path

1
设置nginx可执行文件的名称。此名称仅在安装期间使用。默认情况下，文件名为 prefix/sbin/nginx。

–modules-path=path

1
定义将在其中安装nginx动态模块的目录。默认情况下使用prefix/modules目录。

–conf-path=path

1
设置nginx.conf配置文件的名称。如果需要，可以通过在命令行参数中指定nginx来始终使用其他配置文件来启动它 。默认情况下，文件名为 。 -c fileprefix/conf/nginx.conf

–error-log-path=path

1
设置主要错误，警告和诊断文件的名称。安装后，可以始终nginx.conf使用error_log伪指令在配置文件中 更改文件名 。默认情况下，文件名为 prefix/logs/error.log。

–pid-path=path

1
设置nginx.pid将存储主进程的进程ID 的文件名。安装后，可以始终nginx.conf使用pid伪指令在配置文件中 更改文件名 。默认情况下，文件名为 prefix/logs/nginx.pid。

–lock-path=path

1
为锁定文件的名称设置前缀。安装后，可以始终nginx.conf使用lock_file伪指令在配置文件中 更改该值 。默认情况下，值为 prefix/logs/nginx.lock。

–user=name

1
设置一个非特权用户的名称，其凭据将由工作进程使用。安装后，可以始终nginx.conf使用用户指令在配置文件中 更改名称 。默认用户名是nobody。

–group=name

1
设置其凭据将由工作进程使用的组的名称。安装后，可以始终nginx.conf使用用户指令在配置文件中 更改名称 。默认情况下，组名称设置为非特权用户的名称。

–build=name

1
设置一个可选的nginx构建名称。

–builddir=path

1
设置构建目录。

–with-select_module 和 –without-select_module

1
启用或禁用构建允许服务器使用该select()方法的模块。如果平台似乎不支持kqueue，epoll或/ dev / poll等更合适的方法，则会自动构建此模块。

–with-poll_module 和 –without-poll_module

1
启用或禁用构建允许服务器使用该poll()方法的模块。如果平台似乎不支持kqueue，epoll或/ dev / poll等更合适的方法，则会自动构建此模块。

–with-threads

1
启用线程池的使用 。

–with-file-aio

1
支持 在FreeBSD和Linux上使用 异步文件I / O（AIO）。

–with-http_ssl_module

1
启用构建将HTTPS协议支持添加 到HTTP服务器的模块的功能。默认情况下未构建此模块。需要OpenSSL库来构建和运行此模块。

–with-http_v2_module

1
支持构建一个模块，该模块提供对HTTP / 2的支持 。默认情况下未构建此模块。

–with-http_realip_module

1
支持构建ngx_http_realip_module 模块，该 模块将客户端地址更改为在指定的标头字段中发送的地址。默认情况下未构建此模块。

–with-http_addition_module

1
允许构建ngx_http_addition_module 模块，该 模块在响应之前和之后添加文本。默认情况下未构建此模块。

–with-http_xslt_module 和 –with-http_xslt_module=dynamic

1
支持构建ngx_http_xslt_module 模块，该 模块使用一个或多个XSLT样式表转换XML响应。默认情况下未构建此模块。该libxml2的和 的libxslt库需要构建和运行此模块。

–with-http_image_filter_module 和 –with-http_image_filter_module=dynamic

1
支持构建ngx_http_image_filter_module 模块，该 模块可以转换JPEG，GIF，PNG和WebP格式的图像。默认情况下未构建此模块。

–with-http_geoip_module 和 –with-http_geoip_module=dynamic

1
支持构建ngx_http_geoip_module 模块，该 模块根据客户端IP地址和预编译的MaxMind数据库创建变量 。默认情况下未构建此模块。

–with-http_sub_module

1
支持构建ngx_http_sub_module 模块，该 模块通过将一个指定的字符串替换为另一个指定的字符串来修改响应。默认情况下未构建此模块。

–with-http_dav_module

1
支持构建ngx_http_dav_module 模块，该 模块通过WebDAV协议提供文件管理自动化。默认情况下未构建此模块。

–with-http_flv_module

1
支持构建ngx_http_flv_module 模块，该 模块为Flash Video（FLV）文件提供伪流服务器端支持。默认情况下未构建此模块。

–with-http_mp4_module

1
支持构建ngx_http_mp4_module 模块，该 模块为MP4文件提供伪流服务器端支持。默认情况下未构建此模块。

–with-http_gunzip_module

1
支持为不支持“ gzip”编码方法的客户端构建ngx_http_gunzip_module 模块，该 模块使用“ Content-Encoding: gzip” 解压缩响应。默认情况下未构建此模块。

–with-http_gzip_static_module

1
支持构建ngx_http_gzip_static_module 模块，该 模块支持发送.gz扩展名为“ ”的预压缩文件，而不是常规文件。默认情况下未构建此模块。

–with-http_auth_request_module

1
允许构建ngx_http_auth_request_module 模块，该 模块基于子请求的结果实现客户端授权。默认情况下未构建此模块。

–with-http_random_index_module

1
支持构建ngx_http_random_index_module 模块，该 模块处理以斜杠（' /'）结尾的请求，并从目录中选择一个随机文件作为索引文件。默认情况下未构建此模块。

–with-http_secure_link_module

1
启用构建 ngx_http_secure_link_module 模块。默认情况下未构建此模块。

–with-http_degradation_module

1
启用构建 ngx_http_degradation_module模块。默认情况下未构建此模块。

–with-http_slice_module

1
支持构建ngx_http_slice_module 模块，该 模块将请求拆分为子请求，每个子请求返回一定范围的响应。该模块提供了更有效的大响应缓存。默认情况下未构建此模块。

–with-http_stub_status_module

1
支持构建ngx_http_stub_status_module 模块，该 模块提供对基本状态信息的访问。默认情况下未构建此模块。

–without-http_charset_module

1
禁用构建ngx_http_charset_module 模块，该 模块将指定的字符集添加到“ Content-Type”响应头字段中，并且可以将数据从一个字符集转换为另一个字符集。

–without-http_gzip_module

1
禁用构建可压缩 HTTP服务器响应的模块。zlib库是构建和运行此模块所必需的。

–without-http_ssi_module

1
禁用构建 处理通过SSI（服务器端包含）命令的 ngx_http_ssi_module模块的响应。

–without-http_userid_module

1
禁用构建ngx_http_userid_module 模块，该 模块设置适用于客户端标识的cookie。

–without-http_access_module

1
禁用构建ngx_http_access_module 模块，该 模块允许限制对某些客户端地址的访问。

–without-http_auth_basic_module

1
禁用构建ngx_http_auth_basic_module 模块，该 模块允许通过使用“ HTTP基本身份验证”协议验证用户名和密码来限制对资源的访问。

–without-http_mirror_module

1
禁用构建ngx_http_mirror_module 模块，该 模块通过创建后台镜像子请求来实现原始请求的镜像。

–without-http_autoindex_module

1
禁用构建 ngx_http_autoindex_module 模块，以处理以斜杠（' /'）结尾的请求，并在ngx_http_index_module模块找不到索引文件的情况下生成目录列表 。

–without-http_geo_module

1
禁用构建ngx_http_geo_module 模块，该 模块创建的变量的值取决于客户端IP地址。

–without-http_map_module

1
禁用构建ngx_http_map_module 模块，该 模块创建的变量的值取决于其他变量的值。

–without-http_split_clients_module

1
禁用构建ngx_http_split_clients_module 模块，该 模块创建用于A / B测试的变量。

–without-http_referer_module

1
禁用构建ngx_http_referer_module 模块，该 模块可以阻止对“ Referer”标头字段中具有无效值的请求的站点访问。

–without-http_rewrite_module

1
禁用构建允许HTTP服务器 重定向请求并更改请求URI的模块。构建和运行此模块需要PCRE库。

–without-http_proxy_module

1
禁用构建HTTP服务器 代理模块。

–without-http_fastcgi_module

1
禁用构建 将请求传递到FastCGI服务器的 ngx_http_fastcgi_module模块。

–without-http_uwsgi_module

1
禁用构建 将请求传递到uwsgi服务器的 ngx_http_uwsgi_module模块。

–without-http_scgi_module

1
禁用构建 将请求传递到SCGI服务器的 ngx_http_scgi_module模块。

–without-http_grpc_module

1
禁用构建 将请求传递到gRPC服务器的 ngx_http_grpc_module模块。

–without-http_memcached_module

1
禁用构建ngx_http_memcached_module 模块，该 模块从memcached服务器获取响应。

–without-http_limit_conn_module

1
禁用构建ngx_http_limit_conn_module 模块，该 模块限制每个键的连接数，例如，单个IP地址的连接数。

–without-http_limit_req_module

1
禁用构建ngx_http_limit_req_module 模块，该 模块限制每个密钥的请求处理速率，例如，来自单个IP地址的请求的处理速率。

–without-http_empty_gif_module

1
禁用构建发出单像素透明GIF的模块 。

–without-http_browser_module

1
禁用构建ngx_http_browser_module 模块，该 模块创建的变量的值取决于“ User-Agent”请求标头字段的值。

–without-http_upstream_hash_module

1
禁用构建实现哈希 负载平衡方法的模块 。

–without-http_upstream_ip_hash_module

1
禁用构建实现ip_hash 负载平衡方法的模块 。

–without-http_upstream_least_conn_module

1
禁用构建实现了minimum_conn 负载平衡方法的模块 。

–without-http_upstream_keepalive_module

1
禁用构建一个模块来提供 对上游服务器连接的缓存。

–without-http_upstream_zone_module

1
禁用构建模块，该模块可以将上游组的运行时状态存储在共享内存 区域中。

–with-http_perl_module 和 –with-http_perl_module=dynamic

1
支持构建 嵌入式Perl模块。默认情况下未构建此模块。

–with-perl_modules_path=path

1
定义一个目录，该目录将保留Perl模块。

–with-perl=path

1
设置Perl二进制文件的名称。

–http-log-path=path

1
设置HTTP服务器的主请求日志文件的名称。安装后，可以始终nginx.conf使用access_log伪指令在配置文件中 更改文件名 。默认情况下，文件名为 prefix/logs/access.log。

–http-client-body-temp-path=path

1
定义用于存储包含客户端请求正文的临时文件的目录。安装后，可以始终nginx.conf使用client_body_temp_path 指令在配置文件中 更改目录 。默认情况下，目录名为 prefix/client_body_temp。

–http-proxy-temp-path=path

1
定义一个目录，用于存储包含从代理服务器接收到的数据的临时文件。安装后，可以始终nginx.conf使用proxy_temp_path 指令在配置文件中 更改目录 。默认情况下，目录名为 prefix/proxy_temp。

–http-fastcgi-temp-path=path

1
定义一个目录，用于存储包含从FastCGI服务器接收到的数据的临时文件。安装后，可以始终nginx.conf使用fastcgi_temp_path 指令在配置文件中 更改目录 。默认情况下，目录名为 prefix/fastcgi_temp。

–http-uwsgi-temp-path=path

1
定义一个目录，用于存储带有从uwsgi服务器接收到的数据的临时文件。安装后，可以始终nginx.conf使用uwsgi_temp_path 指令在配置文件中 更改目录 。默认情况下，目录名为 prefix/uwsgi_temp。

–http-scgi-temp-path=path

1
定义一个目录，用于存储带有从SCGI服务器接收到的数据的临时文件。安装后，可以始终nginx.conf使用scgi_temp_path 指令在配置文件中 更改目录 。默认情况下，目录名为 prefix/scgi_temp。

–without-http

1
禁用HTTP服务器。

–without-http-cache

1
禁用HTTP缓存。

–with-mail 和 –with-mail=dynamic

1
启用POP3 / IMAP4 / SMTP 邮件代理服务器。

–with-mail_ssl_module

1
支持构建一个模块，该模块 向邮件代理服务器添加 SSL / TLS协议支持。默认情况下未构建此模块。需要OpenSSL库来构建和运行此模块。

–without-mail_pop3_module

1
在邮件代理服务器中 禁用POP3协议。

–without-mail_imap_module

1
在邮件代理服务器中 禁用IMAP协议。

–without-mail_smtp_module

1
在邮件代理服务器中 禁用SMTP协议。

–with-stream 和 –with-stream=dynamic

1
支持构建 用于通用TCP / UDP代理和负载平衡的 流模块。默认情况下未构建此模块。

–with-stream_ssl_module

1
支持构建一个模块，该模块 向流模块添加 SSL / TLS协议支持。默认情况下未构建此模块。需要OpenSSL库来构建和运行此模块。

–with-stream_realip_module

1
启用构建ngx_stream_realip_module 模块的功能，该 模块将客户端地址更改为PROXY协议标头中发送的地址。默认情况下未构建此模块。

–with-stream_geoip_module 和 –with-stream_geoip_module=dynamic

1
支持构建ngx_stream_geoip_module 模块，该 模块根据客户端IP地址和预编译的MaxMind数据库创建变量 。默认情况下未构建此模块。

–with-stream_ssl_preread_module

1
支持构建ngx_stream_ssl_preread_module 模块，该 模块允许从ClientHello 消息中提取信息， 而无需终止SSL / TLS。默认情况下未构建此模块。

–without-stream_limit_conn_module

1
禁用构建ngx_stream_limit_conn_module 模块，该 模块限制每个键的连接数，例如，单个IP地址的连接数。

–without-stream_access_module

1
禁用构建ngx_stream_access_module 模块，该 模块允许限制对某些客户端地址的访问。

–without-stream_geo_module

1
禁用构建ngx_stream_geo_module 模块，该 模块创建的变量值取决于客户端IP地址。

–without-stream_map_module

1
禁用构建ngx_stream_map_module 模块，该 模块创建的变量值取决于其他变量的值。

–without-stream_split_clients_module

1
禁用构建ngx_stream_split_clients_module 模块，该 模块创建用于A / B测试的变量。

–without-stream_return_module

1
禁用构建ngx_stream_return_module 模块，该 模块向客户端发送一些指定的值，然后关闭连接。

–without-stream_upstream_hash_module

1
禁用构建实现哈希 负载平衡方法的模块 。

–without-stream_upstream_least_conn_module

1
禁用构建实现了minimum_conn 负载平衡方法的模块 。

–without-stream_upstream_zone_module

1
禁用构建模块，该模块可以将上游组的运行时状态存储在共享内存 区域中。

–with-google_perftools_module

1
允许构建ngx_google_perftools_module 模块，该 模块可以使用Google Performance Tools对nginx工作进程进行 性能分析。该模块适用于Nginx开发人员，默认情况下未构建。

–with-cpp_test_module

1
启用构建 ngx_cpp_test_module模块。

–add-module=path

1
启用外部模块。

–add-dynamic-module=path

1
启用外部动态模块。

–with-compat

1
启用动态模块兼容性。

–with-cc=path

1
设置C编译器的名称。

–with-cpp=path

1
设置C预处理器的名称。

–with-cc-opt=parameters

1
设置将添加到CFLAGS变量的其他参数。在FreeBSD下使用系统PCRE库时， --with-cc-opt="-I /usr/local/include" 应指定。如果select()需要增加支持的文件数量，也可以在此处指定，例如： --with-cc-opt="-D FD_SETSIZE=2048"。

–with-ld-opt=parameters

1
设置将在链接期间使用的其他参数。在FreeBSD下使用系统PCRE库时， --with-ld-opt="-L /usr/local/lib" 应指定。

–with-cpu-opt=cpu

1
每个指定的CPU能够使建筑： pentium，pentiumpro， pentium3，pentium4， athlon，opteron， sparc32，sparc64， ppc64。

–without-pcre

1
禁用PCRE库的使用。

–with-pcre

1
强制使用PCRE库。

–with-pcre=path

1
设置PCRE库源的路径。需要从PCRE站点下载并分发库分发（版本4.4 — 8.43） 。其余的由nginx的./configure和完成 make。该库对于location指令中的正则表达式支持和 ngx_http_rewrite_module 模块是必需的 。

–with-pcre-opt=parameters

1
为PCRE设置其他构建选项。

–with-pcre-jit

1
使用“及时编译”支持（1.1.12，pcre_jit指令）构建PCRE库 。

–with-zlib=path

1
设置zlib库源的路径。需要从zlib站点下载库发行版（版本1.1.3-1.2.11） 并解压缩。其余的由nginx的./configure和完成 make。ngx_http_gzip_module模块需要该库 。

–with-zlib-opt=parameters

1
为zlib设置其他构建选项。

–with-zlib-asm=cpu

1
使得能够使用指定的CPU中的一个优化的zlib汇编源程序： pentium，pentiumpro。

–with-libatomic

1
强制使用libatomic_ops库。

–with-libatomic=path

1
设置libatomic_ops库源的路径。

–with-openssl=path

1
设置OpenSSL库源的路径。

–with-openssl-opt=parameters

1
为OpenSSL设置其他构建选项。

–with-debug

1
启用调试日志。

编译

1
make
安装
1
make install

查找安装路径： whereis nginx

启动
1
2
cd /usr/local/nginx/sbin
./nginx

注意：如何连接不上，检查阿里云安全组是否开放端口，或者服务器防火墙是否开放端口或者直接清除服务器防火墙所有规则，并将默认策略设置为接受所有流量：

1
2
3
4
5
sudo iptables -F
sudo iptables -X
sudo iptables -P INPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -P OUTPUT ACCEPT

如果你使用的是firewalld作为防火墙软件，可以使用以下命令来关闭防火墙：

1
2
sudo systemctl stop firewalld
sudo systemctl disable firewalld

第一条命令将停止firewalld服务，第二条命令将禁用firewalld服务，确保在系统重启后防火墙不会自动启动。

相关命令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 开启
service firewalld start
# 重启
service firewalld restart
# 关闭
service firewalld stop
# 查看防火墙规则
firewall-cmd --list-all
# 查询端口是否开放
firewall-cmd --query-port=8080/tcp
# 开放80端口
firewall-cmd --permanent --add-port=80/tcp
# 移除端口
firewall-cmd --permanent --remove-port=8080/tcp
#重启防火墙(修改配置后要重启防火墙)
firewall-cmd --reload
# 参数解释
1、firwall-cmd：是Linux提供的操作firewall的一个工具；
2、--permanent：表示设置为持久；
3、--add-port：标识添加的端口；

Docker安装

官方文档：https://hub.docker.com/_/nginx

安装命令：

1
2
3
4
5
6
docker run \
 --name="nginx" \
 -v html:/usr/share/nginx/html \
 -v nginx:/etc/nginx \
 -p:80:80 \
 -d nginx

卸载

停止 Nginx 软件

可以通过执行ps命令找到nginx程序的PID，然后kill其PID

1
2
ps -aux | grep nginx # 查询nginx的PID
kill -9 10333 10444 #10333 10444 代表两个PID，这里应该以实际为准

查找根下所有名字包含nginx的文件

1
find / -name nginx

执行命令 rm -rf * 删除nignx安装的相关文件

1
2
3
4
rm -rf /usr/local/sbin/nginx
rm -rf /usr/local/nginx
rm -rf /usr/src/nginx-1.11.1
rm -rf /var/spool/mail/nginx

如果设置了Nginx开机自启动的话，可能还需要下面两步

1
2
chkconfig nginx off
rm -rf /etc/init.d/nginx

Nginx常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
nginx -s stop                    # 快速关闭Nginx，可能不保存相关信息，并迅速终止web服务。
nginx -s quit                    # 平稳关闭Nginx，保存相关信息，有安排的结束web服务。
nginx -s reload                  # 因改变了Nginx相关配置，需要重新加载配置而重载。
nginx -s reopen                  # 重新打开日志文件。
nginx -c filename                # 为 Nginx 指定一个配置文件，来代替缺省的。
nginx -t                         # 不运行，仅仅测试配置文件。nginx 将检查配置文件的语法的正确性，并尝试打开配置文件中所引用到的文件。
nginx -v                         # 显示 nginx 的版本。
nginx -V                         # 显示 nginx 的版本，编译器版本和配置参数。
ps aux|grep nginx                #查看nginx进程
sudo kill -USR2 主进程号          # 平滑升级nginx
sudo kill -QUIT 主进程号          # 优雅关停nginx
sudo kill -9 主进程号             # 强制关闭nginx
netstat -an | grep :80 | wc -l   # 查看nginx连接数

Nginx配置

Nginx 大多数功能都可以通过修改配置文件来完成，使用者只需要简单修改一下nginx配置文件，便可以非常轻松的实现比如反向代理，负载均衡这些常用的功能

nginx配置文件默认都放在nginx安装路径下的conf目录，大多数情况下只需要修改主配置文件nginx.conf即可

nginx.conf 这个文件中的内容按照功能划分，我们通常将nginx配置文件分为三大块：全局块，events块，http块。

全局块

1
2
3
4
5
6
7
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

# Load dynamic modules. See /usr/share/doc/nginx/README.dynamic.
include /usr/share/nginx/modules/*.conf;

主要会设置一些影响 nginx 服务器整体运行的配置指令，主要包括配 置运行 Nginx 服务器的用户（组）、允许生成的 worker process 数，进程 PID 存放路径、日志存放路径和类型以及配置文件的引入等。

比如 worker_processes auto； 这一行，worker_processes 值越大，我们nginx可支持的并发数量就越多，很多人想这不就爽了吗，我设置成正无穷，无限并发flag达成，秒杀问题轻松解决，这个，受自己服务器硬件限制的，不能乱来。

events 块

1
2
3
events {
  worker_connections 1024;
}

events 块涉及的指令主要影响 Nginx 服务器与用户的网络连接，常用的设置包括是否开启对多 work process 下的网络连接进行序列化，是否允许同时接收多个网络连接，选取哪种事件驱动模型来处理连接请求，每个 word process 可以同时支持的最大连接数等。

http块

1
2
3
4
http {
  server {
  }
}

注意：http是一个大块，里面也可以包括很多小块，比如http全局块，server块等。

http 全局块配置的指令包括文件引入、MIME-TYPE 定义、日志自定义、连接超时时间、单链接请求数上限等。

而http块中的server块则相当于一个虚拟主机，一个http块可以拥有多个server块。

server块又包括全局server块，和location块。

全局server块主要包括了本虚拟机主机的监听配置和本虚拟主机的名称或 IP 配置。

location块则用来对虚拟主机名称之外的字符串进行匹配，对特定的请求进行处理。地址定向、数据缓存和应答控制等功能，还有许多第三方模块的配置也在这里进行。比如，对/usr相关的请求交给8080来处理，/admin则较给8081处理。

Nginx配置实战

配置文件实例

以下为一个 nginx.conf 配置文件实例：

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
#定义 nginx 运行的用户和用户组
user www www;

#nginx 进程数，建议设置为等于 CPU 总核心数。
worker_processes 8;

#nginx 默认没有开启利用多核 CPU, 通过增加 worker_cpu_affinity 配置参数来充分利用多核 CPU 以下是 8 核的配置参数
worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 00100000 01000000 10000000;

#全局错误日志定义类型，[ debug | info | notice | warn | error | crit ]
error_log /var/log/nginx/error.log info;

#进程文件
pid /var/run/nginx.pid;

#一个 nginx 进程打开的最多文件描述符数目，理论值应该是最多打开文件数（系统的值 ulimit -n）与 nginx 进程数相除，但是 nginx 分配请求并不均匀，所以建议与 ulimit -n 的值保持一致。
worker_rlimit_nofile 65535;

#工作模式与连接数上限
events
{
    #参考事件模型，use [ kqueue | rtsig | epoll | /dev/poll | select | poll ]; epoll 模型是 Linux 2.6 以上版本内核中的高性能网络 I/O 模型，如果跑在 FreeBSD 上面，就用 kqueue 模型。
    #epoll 是多路复用 IO(I/O Multiplexing) 中的一种方式，但是仅用于 linux2.6 以上内核，可以大大提高 nginx 的性能
    use epoll;

    ############################################################################
    #单个后台 worker process 进程的最大并发链接数
    #事件模块指令，定义 nginx 每个进程最大连接数，默认 1024。最大客户连接数由 worker_processes 和 worker_connections 决定
    #即 max_client=worker_processes*worker_connections, 在作为反向代理时：max_client=worker_processes*worker_connections / 4
    worker_connections 65535;
    ############################################################################
}

#设定 http 服务器
http {
    include mime.types; #文件扩展名与文件类型映射表
    default_type application/octet-stream; #默认文件类型
    #charset utf-8; #默认编码

    server_names_hash_bucket_size 128; #服务器名字的 hash 表大小
    client_header_buffer_size 32k; #上传文件大小限制
    large_client_header_buffers 4 64k; #设定请求缓
    client_max_body_size 8m; #设定请求缓
    sendfile on; #开启高效文件传输模式，sendfile 指令指定 nginx 是否调用 sendfile 函数来输出文件，对于普通应用设为 on，如果用来进行下载等应用磁盘 IO 重负载应用，可设置为 off，以平衡磁盘与网络 I/O 处理速度，降低系统的负载。注意：如果图片显示不正常把这个改成 off。
    autoindex on; #开启目录列表访问，合适下载服务器，默认关闭。
    tcp_nopush on; #防止网络阻塞
    tcp_nodelay on; #防止网络阻塞

    ##连接客户端超时时间各种参数设置##
    keepalive_timeout  120;          #单位是秒，客户端连接时时间，超时之后服务器端自动关闭该连接 如果 nginx 守护进程在这个等待的时间里，一直没有收到浏览发过来 http 请求，则关闭这个 http 连接
    client_header_timeout 10;        #客户端请求头的超时时间
    client_body_timeout 10;          #客户端请求主体超时时间
    reset_timedout_connection on;    #告诉 nginx 关闭不响应的客户端连接。这将会释放那个客户端所占有的内存空间
    send_timeout 10;                 #客户端响应超时时间，在两次客户端读取操作之间。如果在这段时间内，客户端没有读取任何数据，nginx 就会关闭连接
    ################################

    #FastCGI 相关参数是为了改善网站的性能：减少资源占用，提高访问速度。下面参数看字面意思都能理解。
    fastcgi_connect_timeout 300;
    fastcgi_send_timeout 300;
    fastcgi_read_timeout 300;
    fastcgi_buffer_size 64k;
    fastcgi_buffers 4 64k;
    fastcgi_busy_buffers_size 128k;
    fastcgi_temp_file_write_size 128k;

    ###作为代理缓存服务器设置#######
    ###先写到 temp 再移动到 cache
    #proxy_cache_path /var/tmp/nginx/proxy_cache levels=1:2 keys_zone=cache_one:512m inactive=10m max_size=64m;
    ###以上 proxy_temp 和 proxy_cache 需要在同一个分区中
    ###levels=1:2 表示缓存级别，表示缓存目录的第一级目录是 1 个字符，第二级目录是 2 个字符 keys_zone=cache_one:128m 缓存空间起名为 cache_one 大小为 512m
    ###max_size=64m 表示单个文件超过 128m 就不缓存了  inactive=10m 表示缓存的数据，10 分钟内没有被访问过就删除
    #########end####################

    #####对传输文件压缩###########
    #gzip 模块设置
    gzip on; #开启 gzip 压缩输出
    gzip_min_length 1k; #最小压缩文件大小
    gzip_buffers 4 16k; #压缩缓冲区
    gzip_http_version 1.0; #压缩版本（默认 1.1，前端如果是 squid2.5 请使用 1.0）
    gzip_comp_level 2; #压缩等级，gzip 压缩比，1 为最小，处理最快；9 为压缩比最大，处理最慢，传输速度最快，也最消耗 CPU；
    gzip_types text/plain application/x-javascript text/css application/xml;
    #压缩类型，默认就已经包含 text/html，所以下面就不用再写了，写上去也不会有问题，但是会有一个 warn。
    gzip_vary on;
    ##############################

    #limit_zone crawler $binary_remote_addr 10m; #开启限制 IP 连接数的时候需要使用

    upstream blog.ha97.com {
        #upstream 的负载均衡，weight 是权重，可以根据机器配置定义权重。weigth 参数表示权值，权值越高被分配到的几率越大。
        server 192.168.80.121:80 weight=3;
        server 192.168.80.122:80 weight=2;
        server 192.168.80.123:80 weight=3;
    }

    #虚拟主机的配置
    server {
        #监听端口
        listen 80;

        #############https##################
        #listen 443 ssl;
        #ssl_certificate /opt/https/xxxxxx.crt;
        #ssl_certificate_key /opt/https/xxxxxx.key;
        #ssl_protocols SSLv3 TLSv1;
        #ssl_ciphers HIGH:!ADH:!EXPORT57:RC4+RSA:+MEDIUM;
        #ssl_prefer_server_ciphers on;
        #ssl_session_cache shared:SSL:2m;
        #ssl_session_timeout 5m;
        ####################################end

        #域名可以有多个，用空格隔开
        server_name www.ha97.com ha97.com;
        index index.html index.htm index.php;
        root /data/www/ha97;
        location ~ .*.(php|php5)?$ {
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_index index.php;
            include fastcgi.conf;
        }

        #图片缓存时间设置
        location ~ .*.(gif|jpg|jpeg|png|bmp|swf)$ {
            expires 10d;
        }

        #JS 和 CSS 缓存时间设置
        location ~ .*.(js|css)?$ {
            expires 1h;
        }

        #日志格式设定
        log_format access '$remote_addr - $remote_user [$time_local] "$request" ' '$status $body_bytes_sent "$http_referer" ' '"$http_user_agent" $http_x_forwarded_for';

        #定义本虚拟主机的访问日志
        access_log /var/log/nginx/ha97access.log access;

        #对 "/" 启用反向代理
        location / {
            proxy_pass http://127.0.0.1:88;
            proxy_redirect off;
            proxy_set_header X-Real-IP $remote_addr;
            #后端的 Web 服务器可以通过 X-Forwarded-For 获取用户真实 IP
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            #以下是一些反向代理的配置，可选。
            proxy_set_header Host $host;
            client_max_body_size 10m; #允许客户端请求的最大单文件字节数
            client_body_buffer_size 128k; #缓冲区代理缓冲用户端请求的最大字节数，

            ##代理设置 以下设置是 nginx 和后端服务器之间通讯的设置##
            proxy_connect_timeout 90; #nginx 跟后端服务器连接超时时间（代理连接超时）
            proxy_send_timeout 90; #后端服务器数据回传时间（代理发送超时）
            proxy_read_timeout 90; #连接成功后，后端服务器响应时间（代理接收超时）
            proxy_buffering on;    #该指令开启从后端被代理服务器的响应内容缓冲 此参数开启后 proxy_buffers 和 proxy_busy_buffers_size 参数才会起作用
            proxy_buffer_size 4k;  #设置代理服务器（nginx）保存用户头信息的缓冲区大小
            proxy_buffers 4 32k;   #proxy_buffers 缓冲区，网页平均在 32k 以下的设置
            proxy_busy_buffers_size 64k; #高负荷下缓冲大小（proxy_buffers*2）
            proxy_max_temp_file_size 2048m; #默认 1024m, 该指令用于设置当网页内容大于 proxy_buffers 时，临时文件大小的最大值。如果文件大于这个值，它将从 upstream 服务器同步地传递请求，而不是缓冲到磁盘
            proxy_temp_file_write_size 512k; 这是当被代理服务器的响应过大时 nginx 一次性写入临时文件的数据量。
            proxy_temp_path  /var/tmp/nginx/proxy_temp;    ##定义缓冲存储目录，之前必须要先手动创建此目录
            proxy_headers_hash_max_size 51200;
            proxy_headers_hash_bucket_size 6400;
            #######################################################
        }

        #设定查看 nginx 状态的地址
        location /nginxStatus {
            stub_status on;
            access_log on;
            auth_basic "nginxStatus";
            auth_basic_user_file conf/htpasswd;
            #htpasswd 文件的内容可以用 apache 提供的 htpasswd 工具来产生。
        }

        #本地动静分离反向代理配置
        #所有 jsp 的页面均交由 tomcat 或 resin 处理
        location ~ .(jsp|jspx|do)?$ {
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_pass http://127.0.0.1:8080;
        }

        #所有静态文件由 nginx 直接读取不经过 tomcat 或 resin
        location ~ .*.(htm|html|gif|jpg|jpeg|png|bmp|swf|ioc|rar|zip|txt|flv|mid|doc|ppt|pdf|xls|mp3|wma)$
        { expires 15d; }

        location ~ .*.(js|css)?$
        { expires 1h; }
    }
}

正向代理

正向代理类似一个跳板机，代理访问外部资源
比如我们国内访问谷歌，直接访问访问不到，我们可以通过一个正向代理服务器，请求发到代理服，代理服务器能够访问谷歌，这样由代理去谷歌取到返回数据，再返回给我们，这样我们就能访问谷歌了

正向代理的用途：

  1. 访问原来无法访问的资源，如google
  2. 可以做缓存，加速访问资源
  3. 对客户端访问授权，上网进行认证
  4. 代理可以记录用户访问记录（上网行为管理），对外隐藏用户信息

反向代理

反向代理（Reverse Proxy）实际运行方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器

反向代理的作用：

  1. 保证内网的安全，阻止web攻击，大型网站，通常将反向代理作为公网访问地址，Web服务器是内网
  2. 负载均衡，通过反向代理服务器来优化网站的负载

一句话总结正向代理与方向代理的区别：

  • 正向代理即是客户端代理，代理客户端，服务端不知道实际发起请求的客户端
  • 反向代理即是服务端代理，代理服务端，客户端不知道实际提供服务的服务端.

http 反向代理

反向代理服务器和目标服务器对外就是一个服务器，暴露的是代理服务器地址，隐藏了真实服务器 IP 地址。

nginx.conf 配置文件如下：

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#运行用户
#user somebody;

#启动进程,通常设置成和cpu的数量相等
worker_processes  1;

#全局错误日志
error_log  D:/Tools/nginx-1.10.1/logs/error.log;
error_log  D:/Tools/nginx-1.10.1/logs/notice.log  notice;
error_log  D:/Tools/nginx-1.10.1/logs/info.log  info;

#PID文件，记录当前启动的nginx的进程ID
pid        D:/Tools/nginx-1.10.1/logs/nginx.pid;

#工作模式及连接数上限
events {
    worker_connections 1024;    #单个后台worker process进程的最大并发链接数
}

#设定http服务器，利用它的反向代理功能提供负载均衡支持
http {
    #设定mime类型(邮件支持类型),类型由mime.types文件定义
    include       D:/Tools/nginx-1.10.1/conf/mime.types;
    default_type  application/octet-stream;

    #设定日志
    log_format  main  '[$remote_addr] - [$remote_user] [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log    D:/Tools/nginx-1.10.1/logs/access.log main;
    rewrite_log     on;

    #sendfile 指令指定 nginx 是否调用 sendfile 函数（zero copy 方式）来输出文件，对于普通应用，
    #必须设为 on,如果用来进行下载等应用磁盘IO重负载应用，可设置为 off，以平衡磁盘与网络I/O处理速度，降低系统的uptime.
    sendfile        on;
    #tcp_nopush     on;

    #连接超时时间
    keepalive_timeout  120;
    tcp_nodelay        on;

    #gzip压缩开关
    #gzip  on;

    #设定实际的服务器列表
    upstream zp_server1{
        server 127.0.0.1:8089;
    }

    #HTTP服务器
    server {
        #监听80端口，80端口是知名端口号，用于HTTP协议
        listen       80;

        #定义使用www.xx.com访问
        server_name  www.helloworld.com;

        #首页
        index index.html

        #指向webapp的目录
        root D:\01_Workspace\Project\github\zp\SpringNotes\spring-security\spring-shiro\src\main\webapp;

        #编码格式
        charset utf-8;

        #代理配置参数
        proxy_connect_timeout 180;
        proxy_send_timeout 180;
        proxy_read_timeout 180;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarder-For $remote_addr;

        #反向代理的路径（和upstream绑定），location 后面设置映射的路径
        location / {
            proxy_pass http://zp_server1;
        }

        #静态文件，nginx自己处理
        location ~ ^/(images|javascript|js|css|flash|media|static)/ {
            root D:\01_Workspace\Project\github\zp\SpringNotes\spring-security\spring-shiro\src\main\webapp\views;
            #过期30天，静态文件不怎么更新，过期可以设大一点，如果频繁更新，则可以设置得小一点。
            expires 30d;
        }

        #设定查看Nginx状态的地址
        location /NginxStatus {
            stub_status           on;
            access_log            on;
            auth_basic            "NginxStatus";
            auth_basic_user_file  conf/htpasswd;
        }

        #禁止访问 .htxxx 文件
        location ~ /\.ht {
            deny all;
        }

        #错误处理页面（可选择性配置）
        #error_page   404              /404.html;
        #error_page   500 502 503 504  /50x.html;
        #location = /50x.html {
        #    root   html;
        #}
    }
}

location指令说明:

功能：用于匹配URL

语法如下：

1
2
3
4
5
6
7
1、= ：用于不含正则表达式的 uri 前，要求请求字符串与 uri 严格匹配，如果匹配
成功，就停止继续向下搜索并立即处理该请求。
2、~：用于表示 uri 包含正则表达式，并且区分大小写。
3、~*：用于表示 uri 包含正则表达式，并且不区分大小写。
4、^~：用于不含正则表达式的 uri 前，要求 Nginx 服务器找到标识 uri 和请求字
符串匹配度最高的 location 后，立即使用此 location 处理请求，而不再使用 location
块中的正则 uri 和请求字符串做匹配。

https 反向代理

使用 nginx 配置 https 需要知道几点：

  • HTTPS 的固定端口号是 443，不同于 HTTP 的 80 端口
  • SSL 标准需要引入安全证书，所以在 nginx.conf 中你需要指定证书和它对应的 key

其他和 http 反向代理基本一样，只是在 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
#HTTP服务器
server {
    #监听443端口。443为知名端口号，主要用于HTTPS协议
    listen       443 ssl;

    #定义使用www.xx.com访问
    server_name  www.helloworld.com;

    #ssl证书文件位置(常见证书文件格式为：crt/pem)
    ssl_certificate      cert.pem;
    #ssl证书key位置
    ssl_certificate_key  cert.key;

    #ssl配置参数（选择性配置）
    ssl_session_cache    shared:SSL:1m;
    ssl_session_timeout  5m;
    #数字签名，此处使用MD5
    ssl_ciphers  HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers  on;

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

负载均衡

前面的例子中，代理仅仅指向一个服务器。

但是，网站在实际运营过程中，大部分都是以集群的方式运行，这时需要使用负载均衡来分流。

nginx 也可以实现简单的负载均衡功能。

假设这样一个应用场景：将应用部署在 192.168.1.11:80、192.168.1.12:80、192.168.1.13:80 三台 linux 环境的服务器上。网站域名叫 www.helloworld.com，公网 IP 为 192.168.1.11。在公网 IP 所在的服务器上部署 nginx，对所有请求做负载均衡处理（下面例子中使用的是加权轮询策略）。

nginx.conf 配置如下：

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
http {
     #设定mime类型,类型由mime.type文件定义
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
    #设定日志格式
    access_log    /var/log/nginx/access.log;

    #设定负载均衡的服务器列表
    upstream load_balance_server {
        #weigth参数表示权值，权值越高被分配到的几率越大
        server 192.168.1.11:80   weight=5;
        server 192.168.1.12:80   weight=1;
        server 192.168.1.13:80   weight=6;
    }

   #HTTP服务器
   server {
        #侦听80端口
        listen       80;

        #定义使用www.xx.com访问
        server_name  www.helloworld.com;

        #对所有请求进行负载均衡请求
        location / {
            root        /root;                 #定义服务器的默认网站根目录位置
            index       index.html index.htm;  #定义首页索引文件的名称
            proxy_pass  http://load_balance_server ;#请求转向load_balance_server 定义的服务器列表

            #以下是一些反向代理的配置(可选择性配置)
            #proxy_redirect off;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            #后端的Web服务器可以通过X-Forwarded-For获取用户真实IP
            proxy_set_header X-Forwarded-For $remote_addr;
            proxy_connect_timeout 90;          #nginx跟后端服务器连接超时时间(代理连接超时)
            proxy_send_timeout 90;             #后端服务器数据回传时间(代理发送超时)
            proxy_read_timeout 90;             #连接成功后，后端服务器响应时间(代理接收超时)
            proxy_buffer_size 4k;              #设置代理服务器（nginx）保存用户头信息的缓冲区大小
            proxy_buffers 4 32k;               #proxy_buffers缓冲区，网页平均在32k以下的话，这样设置
            proxy_busy_buffers_size 64k;       #高负荷下缓冲大小（proxy_buffers*2）
            proxy_temp_file_write_size 64k;    #设定缓存文件夹大小，大于这个值，将从upstream服务器传

            client_max_body_size 10m;          #允许客户端请求的最大单文件字节数
            client_body_buffer_size 128k;      #缓冲区代理缓冲用户端请求的最大字节数
        }
    }
}

负载均衡策略

轮询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
upstream bck_testing_01 {
  # 默认所有服务器权重为 1
  server 192.168.250.220:8080
  server 192.168.250.221:8080
  server 192.168.250.222:8080
}

server {
  listen                9000;
  server_name           test.com;

  location / {
    proxy_pass          bck_testing_01;
    proxy_set_header    Host $proxy_host;
    proxy_set_header    X-Real-IP $remote_addr;
    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
upstream bck_testing_01 {
  server 192.168.250.220:8080   weight=3
  server 192.168.250.221:8080              # default weight=1
  server 192.168.250.222:8080              # default weight=1
}

server {
  listen                9000;
  server_name           test.com;

  location / {
    proxy_pass          bck_testing_01;
    proxy_set_header    Host $proxy_host;
    proxy_set_header    X-Real-IP $remote_addr;
    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
20
upstream bck_testing_01 {
  least_conn;

  # with default weight for all (weight=1)
  server 192.168.250.220:8080
  server 192.168.250.221:8080
  server 192.168.250.222:8080
}

server {
  listen                9000;
  server_name           test.com;

  location / {
    proxy_pass          bck_testing_01;
    proxy_set_header    Host $proxy_host;
    proxy_set_header    X-Real-IP $remote_addr;
    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
upstream bck_testing_01 {
  least_conn;

  server 192.168.250.220:8080   weight=3
  server 192.168.250.221:8080              # default weight=1
  server 192.168.250.222:8080              # default weight=1
}

server {
  listen                9000;
  server_name           test.com;

  location / {
    proxy_pass          bck_testing_01;
    proxy_set_header    Host $proxy_host;
    proxy_set_header    X-Real-IP $remote_addr;
    proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
  }
}
IP Hash

对客户端请求的ip进行hash操作，然后根据hash结果将同一个客户端ip的请求分发给同一台服务器进行处理，可以解决session不共享的问题。

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

  ip_hash;

  # with default weight for all (weight=1)
  server 192.168.250.220:8080
  server 192.168.250.221:8080
  server 192.168.250.222:8080

}

server {
  listen                9000;
  server_name           test.com;

  location / {
    proxy_pass          bck_testing_01;
    proxy_set_header    Host $proxy_host;
    proxy_set_header    X-Real-IP $remote_addr;
    proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
  }
}
普通 Hash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
upstream bck_testing_01 {

  hash $request_uri;

  # with default weight for all (weight=1)
  server 192.168.250.220:8080
  server 192.168.250.221:8080
  server 192.168.250.222:8080

}

server {
  listen                9000;
  server_name           test.com;

  location / {
    proxy_pass          bck_testing_01;
    proxy_set_header    Host $proxy_host;
    proxy_set_header    X-Real-IP $remote_addr;
    proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
  }
}

网站有多个 webapp 的配置

当一个网站功能越来越丰富时，往往需要将一些功能相对独立的模块剥离出来，独立维护。这样的话，通常，会有多个 webapp。

举个例子：假如 www.helloworld.com 站点有好几个 webapp，finance（金融）、product（产品）、admin（用户中心）。访问这些应用的方式通过上下文(context)来进行区分:

www.helloworld.com/finance/

www.helloworld.com/product/

www.helloworld.com/admin/

我们知道，http 的默认端口号是 80，如果在一台服务器上同时启动这 3 个 webapp 应用，都用 80 端口，肯定是不成的。所以，这三个应用需要分别绑定不同的端口号。

那么，问题来了，用户在实际访问 www.helloworld.com 站点时，访问不同 webapp，总不会还带着对应的端口号去访问吧。所以，你再次需要用到反向代理来做处理。

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
http {
    #此处省略一些基本配置

    upstream product_server{
        server www.helloworld.com:8081;
    }

    upstream admin_server{
        server www.helloworld.com:8082;
    }

    upstream finance_server{
        server www.helloworld.com:8083;
    }

    server {
        #此处省略一些基本配置
        #默认指向product的server
        location / {
            proxy_pass http://product_server;
        }

        location /product/{
            proxy_pass http://product_server;
        }

        location /admin/ {
            proxy_pass http://admin_server;
        }

        location /finance/ {
            proxy_pass http://finance_server;
        }
    }
}

动静分离

在我们的开发中，有些请求是需要后台处理的，有些请求是不需要经过后台处理的（如：css、html、jpg、js等等文件），这些不需要经过后台处理的文件称为静态文件。让动态网站里的动态网页根据一定规则把不变的资源和经常变的资源区分开来，动静资源做好了拆分以后，我们就可以根据静态资源的特点将其做缓存操作。提高资源响应的速度。

弄好一个动态资源一个静态资源：比如

  • /shisan/image/01.jpg
  • /shisan/html/01.html
1
2
3
4
5
6
7
8
9
10
11
12
server {
    listen        80;
    server_name        192.168.12.127;
    location /html/ {
        root        /shisan/;
        index        index.html index.htm;
    }
    location /image/ {
        root        /shisan/;
        autoindex        on;            // 列出文件的目录，可以自行观看对比就知道
    }
}

防盗链

1
2
3
4
5
6
7
8
9
10
11
# 在动静分离的location中开启防盗链机制
location ~* \.(html|htm|gif|jpg|jpeg|bmp|png|webp|ico|txt|js|css)$ {
    # 最后面的值在上线前可配置为允许的域名地址
    valid_referers none blocked ikisslover.com *.ikisslover.com;
    if ($invalid_referer) {
        # 可以配置成返回一张禁止盗取的图片
        # rewrite   ^/ http://xx.xx.com/NO.jpg;
        # 也可直接返回403
        return   403;
    }
}

静态站点

有时候，我们需要配置静态站点(即 html 文件和一堆静态资源)。

举例来说：如果所有的静态资源都放在了 /app/dist 目录下，我们只需要在 nginx.conf 中指定首页以及这个站点的 host 即可。

配置如下：

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
worker_processes  1;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    gzip on;
    gzip_types text/plain application/x-javascript text/css application/xml text/javascript application/javascript image/jpeg image/gif image/png;
    gzip_vary on;

    # 定义一个虚拟服务器块
    server {
        # 监听 80 端口，通常用于 HTTP 请求
        listen 80;
        # 服务器名称，可以是域名或 IP 地址
        server_name your_domain_or_ip;
    
        # 指定静态文件的根目录，Nginx 会从该目录查找请求的文件
        root /path/to/your/html/files;
        # 当访问目录时，默认显示的文件
        index index.html;
    
        # 处理所有的请求
        location / {
            # 尝试按顺序查找请求的 URI，如果找不到则返回 404 错误
            try_files $uri $uri/ =404;
        }
    }
   
}

然后，添加 HOST：

127.0.0.1 aaa.bbb.com

此时，在本地浏览器访问 aaa.bbb.com ，就可以访问静态站点了。

搭建文件服务器

有时候，团队需要归档一些数据或资料，那么文件服务器必不可少。使用 Nginx 可以非常快速便捷的搭建一个简易的文件服务。

Nginx 中的配置要点：

  • 将 autoindex 开启可以显示目录，默认不开启。
  • 将 autoindex_exact_size 开启可以显示文件的大小。
  • 将 autoindex_localtime 开启可以显示文件的修改时间。
  • root 用来设置开放为文件服务的根路径。
  • charset 设置为 charset utf-8,gbk;，可以避免中文乱码问题（windows 服务器下设置后，依然乱码，本人暂时没有找到解决方法）。

一个最简化的配置如下：

1
2
3
4
5
6
7
8
9
10
11
autoindex on;# 显示目录
autoindex_exact_size on;# 显示文件大小
autoindex_localtime on;# 显示文件时间

server {
    charset      utf-8,gbk; # windows 服务器下设置后，依然乱码，暂时无解
    listen       9050 default_server;
    listen       [::]:9050 default_server;
    server_name  _;
    root         /share/fs;
}

跨域配置

在后端服务器设置 HTTP 响应头，把你需要允许访问的域名加入 Access-Control-Allow-Origin 中。

首先，在 enable-cors.conf 文件中设置 cors ：

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

  ...

  add_header Access-Control-Allow-Origin *; # 表示允许所有域名域跨域调用
  add_header Access-Control-Allow-Methods *; # 表示允许所有请求方法跨域
  if ($request_method = OPTIONS) { # 检查请求的类型是不是预检命令
    return 200;
  }

  location / {
    root  /root/www/website/dist;
    index   index.html      index.htm;

  }

  ...
}

访问ip白名单

如果想对整个Nginx下所有网站设置IP访问白名单，可以配置在http段中，如：仅允许10.10.10.10的访问，其他所有IP均不能访问。

1
2
3
4
5
6
http {
  # ......
  allow 10.10.10.10;
  deny all;
  # ......
}

允许10.10.10.11和10.10.10.55访问blog.whsir.com域名，可直接在对应域名的server字段中配置：

1
2
3
4
5
6
7
server {
  server_name blog.whsir.com;
  allow 10.10.10.11;
  allow 10.10.10.55;
  deny all;
  # ......
}

注：如果http字段和server字段同时配置了多个allow的IP，server字段中的allow也会生效，当然server字段中的allow仅对当前server域名生效。

仅允许10.10.10.0~10.10.10.255对某个URI地址进行访问：

1
2
3
4
location /text/login {
  allow 10.10.10.0/24;
  deny all;
}

访问ip黑名单

同白名单的写法一样，只是关键字不一样，白名单是allow，黑名单是deny

1
2
3
location / {
  deny 123.13.123.12;
}

黑名单设置，deny后面接限制的IP，不用加 allow all ，因为这个默认是开启的。

隐藏 Nginx 版本信息

1
2
3
http {
  server_tokens         off;
}

禁止ip直接访问80端口

1
2
3
4
5
server {
  listen                80 default;
  server_name           _;
  return                500;
}

启动 web 服务 (vue 项目为例)

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
server {
  # 项目启动端口
  listen            80;
  # 域名（localhost）
  server_name       _;
  # 禁止 iframe 嵌套
  add_header        X-Frame-Options SAMEORIGIN;

  # 访问地址 根路径配置
  location / {
    # 项目目录
    root 	    html;
    # 默认读取文件
    index           index.html;
    # 配置 history 模式的刷新空白
    try_files       $uri $uri/ /index.html;
  }

  # 后缀匹配，解决静态资源找不到问题
  location ~* \.(gif|jpg|jpeg|png|css|js|ico)$ {
    root           html/static/;
  }

  # 图片防盗链
  location ~/static/.*\.(jpg|jpeg|png|gif|webp)$ {
    root              html;
    valid_referers    *.deeruby.com;
    if ($invalid_referer) {
      return          403;
    }
  }

  # 访问限制
  location /static {
    root               html;
    # allow 允许
    allow              39.xxx.xxx.xxx;
    # deny  拒绝
    deny               all;
  }
}

PC端和移动端使用不同的项目文件映射

1
2
3
4
5
6
7
8
9
10
server {
  ......
  location / {
    root /home/static/pc;
    if ($http_user_agent ~* '(mobile|android|iphone|ipad|phone)') {
      root /home/static/mobile;
    }
    index index.html;
  }
}

一个web服务，配置多个项目 (location 匹配路由区别)

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
67
68
69
70
71
72
73
74
75
76
77
server {
  listen                80;
  server_name           _;

  # 主应用
  location / {
    root          html/main;
    index               index.html;
    try_files           $uri $uri/ /index.html;
  }

  # 子应用一
  location ^~ /store/ {
    proxy_pass          http://localhost:8001;
    proxy_redirect      off;
    proxy_set_header    Host $host;
    proxy_set_header    X-Real-IP $remote_addr;
    proxy_set_header    X-Forwarded-For
    proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
  }

  # 子应用二
  location ^~ /school/ {
    proxy_pass          http://localhost:8002;
    proxy_redirect      off;
    proxy_set_header    Host $host;
    proxy_set_header    X-Real-IP $remote_addr;
    proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
  }

  # 静态资源读取不到问题处理
  rewrite ^/api/profile/(.*)$ /(替换成正确路径的文件的上一层目录)/$1 last;
}

# 子应用一服务
server {
  listen                8001;
  server_name           _;
  location / {
    root          html/store;
    index               index.html;
    try_files           $uri $uri/ /index.html;
  }

  location ^~ /store/ {
    alias               html/store/;
    index               index.html index.htm;
    try_files           $uri /store/index.html;
  }

  # 接口代理
  location  /api {
    proxy_pass          http://localhost:8089;
  }
}

# 子应用二服务
server {
  listen                8002;
  server_name           _;
  location / {
    root          html/school;
    index               index.html;
    try_files           $uri $uri/ /index.html;
  }

  location ^~ /school/ {
    alias               html/school/;
    index               index.html index.htm;
    try_files           $uri /school/index.html;
  }

  # 接口代理
  location  /api {
    proxy_pass          http://localhost:10010;
  }
}

SSL 配置 HTTPS

  1. 先去CA机构或从云控制台中申请对应的SSL证书，审核通过后下载Nginx版本的证书。

  2. 下载数字证书后，完整的文件总共有三个：.crt、.key、.pem：

    • .crt：数字证书文件，.crt是.pem的拓展文件，因此有些人下载后可能没有。

    • .key：服务器的私钥文件，及非对称加密的私钥，用于解密公钥传输的数据。

    • .pem：Base64-encoded编码格式的源证书文本文件，可自行根需求修改拓展名。

  3. 在Nginx目录下新建certificate目录，并将下载好的证书/私钥等文件上传至该目录。

④最后修改一下nginx.conf文件即可，如下：

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
# ----------HTTPS配置-----------
server {
    # 监听HTTPS默认的443端口
    listen 443;
    # 配置自己项目的域名
    server_name www.xxx.com;
    # 打开SSL加密传输
    ssl on;
    # 输入域名后，首页文件所在的目录
    root html;
    # 配置首页的文件名
    index index.html index.htm index.jsp index.ftl;
    # 配置自己下载的数字证书
    ssl_certificate  certificate/xxx.pem;
    # 配置自己下载的服务器私钥
    ssl_certificate_key certificate/xxx.key;
    # 停止通信时，加密会话的有效期，在该时间段内不需要重新交换密钥
    ssl_session_timeout 5m;
    # TLS握手时，服务器采用的密码套件
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
    # 服务器支持的TLS版本
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    # 开启由服务器决定采用的密码套件
    ssl_prefer_server_ciphers on;

    location / {
        ....
    }
}

# ---------HTTP请求转HTTPS-------------
server {
    # 监听HTTP默认的80端口
    listen 80;
    # 如果80端口出现访问该域名的请求
    server_name www.xxx.com;
    # 将请求改写为HTTPS（这里写你配置了HTTPS的域名）
    rewrite ^(.*)$ https://www.xxx.com;
}

重写

1
2
3
4
5
6
7
8
server {
    # 监听HTTP默认的80端口
    listen 80;
    # 如果80端口出现访问该域名的请求
    server_name www.xxx.com;
    # 将请求重写为HTTPS（这里写你配置了HTTPS的域名）
    rewrite ^(.*)$ https://www.xxx.com;
}

重定向

1
2
3
4
5
6
7
8
server {
    # 监听HTTP默认的80端口
    listen 80;
    # 如果80端口出现访问该域名的请求
    server_name www.xxx.com;
    # 将请求重定向为HTTPS（这里写你配置了HTTPS的域名）
    return 301 https://www.xxx.com;
}

缓存配置

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

  ...

  location / {
    root  /root/www/website/dist;
    index   index.html      index.htm;

    location ~ .*.(?:jpg|jpeg|png|svg)$ { # 匹配静态资源的文件后缀
      expires 7d; # 7天后过期
    }
  }

  ...
}

gzip压缩配置

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

  ...

  # 开启gzip压缩，同理，关闭为off
  gzip on;
  # 压缩的级别，一般取2-6，级别越高，压缩的越小，但越耗费服务器的cpu
  gzip_comp_level 6;
  # 超过1K的文件才进行压缩
  gzip_min_length 1k;
  # 文件类型
  gzip_types image/png image/jpeg image/gif image/webp image/svg+xml;
  # 在响应头中添加 Vary
  gzip_vary on;

  location / {
    root  /root/www/website/dist;
    index   index.html      index.htm;
  }

  ...
}

身份验证

1
2
3
4
5
6
location / {
    root   /usr/local/nginx/html;
    auth_basic "closed site";
    auth_basic_user_file /usr/local/nginx/conf/htpasswd;
    index  index.html index.htm;
}

auth_basic "closed site"中的``closed site`是弹出框（输入用户名和密码）的标题。

auth_basic_user_file /usr/local/nginx/conf/htpasswd; 中的``/usr/local/nginx/conf/htpasswd`是保存密码的文件。

密码文件生成，需要``apt install mini-httpd -y`

1
htpasswd -c /usr/local/nginx/conf/htpasswd 用户名

如果要添加或者修改另一个用户的密码，只需要省略-c选项

1
htpasswd /usr/local/nginx/conf/htpasswd 用户名

如果要删除一个用户的密码，只需要加-D选项

1
htpasswd -D /usr/local/nginx/conf/htpasswd 用户名

配置好后，重启，应该就可以了。

视频推流

下载模块

将模块放在/usr/local/src/目录下

1
git clone https://github.com/arut/nginx-rtmp-module.git

配置编译参数

在nginx源代码目录下，运行以下命令：

1
./configure --add-module=/usr/local/src/nginx-rtmp-module

配置nginx-rtmp

1
2
3
4
5
6
7
8
9
10
11
12
rtmp {
    server {
        listen 1935; // 监听端口
        chunk_size 4096;

        application live {
            live on;
            record off;
            push rtmp://livepush.bilibili.com/live-rec/你的直播码?streamname=你的流名称&key=你的直播码;
        }
    }
}

其中，listen指定了RTMP服务器监听的端口，chunk_size设置数据包大小，live开启直播流，record关闭录制。

push指令即为用于推送的指令，可以将数据流推送到Bilibili的RTMP服务。在指令中，直播码是在Bilibili申请直播时得到的，streamname指定流名称，key指定直播的密码密钥。

高可用

实现效果：
准备两台 nginx 服务器，通过浏览器地址栏访问虚拟 ip 地址，把主服务器的 nginx 停止，再次访问虚拟 ip 地址仍旧有效。
具体配置：
（1）在两台 nginx 服务器上安 keepalived。
keepalived 相当于一个路由，它通过一个脚本来检测当前服务器是否还活着，如果还活着则继续访问，否则就切换到另一台备份服务器。

下载安装包

在 https://www.keepalived.org/download.html 寻找合适的版本

1
2
3
4
5
6
# 下载
wget https://www.keepalived.org/software/keepalived-2.2.7.tar.gz
# 解压缩
tar -zxvf keepalived-2.2.7.tar.gz
# 进入目录
cd keepalived-2.2.7

编译

1
./configure

安装

1
make && make install

（2）修改主备服务器 /etc/keepalived/keepalivec.conf 配置文件（可直接替换），完成高可用主从配置。
keepalived 将 nginx 服务器绑定到一个虚拟 ip ， nginx 高可用集群对外统一暴露这个虚拟 ip，客户端都是通过访问这个虚拟 ip 来访问 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
33
34
global_defs {
    notification_email {
        acassen@firewall.loc
        failover@firewall.loc
        sysadmin@firewall.loc
    }
    notification_email_from_Alexandre.Cassen@firewall.loc
    smtp_server 192.168.4.32
    smtp_connect_timeout 30
    router_id LVS_DEVEL  # 在 /etc/hosts 文件中配置，通过它能访问到我们的主机
}

vrrp_script_chk_http_port {
    script "/usr/local/src/nginx_check.sh"

    interval 2      # 检测脚本执行的时间间隔

    weight 2        # 权重每次加2
}

vrrp_instance VI_1 {
    interface ens7f0 # 网卡，需根据情况修改
    state MASTER    # 备份服务器上将 MASTER 改为 BACKUP
    virtual_router_id 51 # 主备机的 virtual_router_id 必须相同
    priority 100   # 主备机取不同的优先级，主机值较大，备份机值较小
    advert_int 1  # 每隔多长时间（默认1s）发送一次心跳，检测服务器是否还活着
    authentication {
      auth_type PASS
      auth_pass 1111
    }
    virtual_ipaddress {
        192.168.1.100 # VRRP H 虚拟地址，可以绑定多个
    }
}

字段说明

  • router_id： 在 /etc/hosts 文件中配置，通过它能访问到我们的主机。
1
2
3
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
127.0.0.1   LVS_DEVEL
  • interval： 设置脚本执行的间隔时间
  • weight： 当脚本执行失败即 keepalived 或 nginx 挂掉时，权重增加的值（可为负数）。
  • interface： 输入 ifconfig 命令查看当前的网卡名是什么。
1
2
3
4
ens7f0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.4.32  netmask 255.255.252.0  broadcast 192.168.7.255
        inet6 fe80::e273:9c3c:e675:7c60  prefixlen 64  scopeid 0x20<link>
        ... ...

（3）在 /usr/local/src 目录下添加检测脚本 nginx_check.sh。

1
2
3
4
5
6
7
8
9
#!/bin/bash
A=`ps -C nginx -no-header |wc -l`
if [ $A -eq 0 ];then
    /usr/local/nginx/sbin/nginx
    sleep 2
    if [ ps -C nginx -no-header |wc -l` -eq 0 ];then
        killall keepalived
    fi
fi

（4）启动两台服务器的 nginx 和 keepalived。

1
2
3
4
5
# 启动 nginx
./nginx

# 启动 keepalived
systemctl start keepalived.service

（5）查看虚拟 ip 地址 ip a 。把主服务器 192.168.4.32 nginx 和 keepalived停止，再访问虚拟 ip 查看高可用效果。