前言

作为一名前端开发人员，你是不是经常碰到领导让你上服务器去修改Nginx配置，然而你会以“我是前端，这个我不会”为理由搪塞过去呢！今天就让我们一起告别这种尴尬，向“真正”的程序员迈进！！！
如果本文对你有所帮助，请点个👍 👍 👍 吧！

Nginx 概述

nginx - 图1
Nginx是开源、高性能、高可靠的Web和反向代理服务器，而且支持热部署，几乎可以做到 7 * 24 小时不间断运行，即使运行几个月也不需要重新启动，还能在不间断服务的情况下对软件版本进行热更新。性能是Nginx最重要的考量，其占用内存少、并发能力强、能支持高达 5w 个并发连接数，最重要的是，Nginx是免费的并可以商业化，配置使用也比较简单。

Nginx 特点

  • 高并发、高性能；
  • 模块化架构使得它的扩展性非常好；
  • 异步非阻塞的事件驱动模型这点和Node.js相似；
  • 相对于其它服务器来说它可以连续几个月甚至更长而不需要重启服务器使得它具有高可靠性；
  • 热部署、平滑升级；
  • 完全开源，生态繁荣；

    Nginx 作用

    Nginx 的最重要的几个使用场景：
  1. 静态资源服务，通过本地文件系统提供服务；
  2. 反向代理服务，延伸出包括缓存、负载均衡等；
  3. API服务，OpenResty；

对于前端来说Node.js并不陌生，Nginx和Node.js的很多理念类似，HTTP服务器、事件驱动、异步非阻塞等，且Nginx的大部分功能使用Node.js也可以实现，但Nginx和Node.js并不冲突，都有自己擅长的领域。Nginx擅长于底层服务器端资源的处理（静态资源处理转发、反向代理，负载均衡等），Node.js更擅长上层具体业务逻辑的处理，两者可以完美组合。
用一张图表示：
nginx - 图2

Nginx 安装

本文演示的是LinuxcentOS 7.x的操作系统上安装Nginx，至于在其它操作系统上进行安装可以网上自行搜索，都非常简单的。
使用 yum安装Nginx：

  1. yum install nginx -y

安装完成后，通过rpm -ql nginx命令查看Nginx的安装信息：

  1. # Nginx配置文件
  2. /etc/nginx/nginx.conf # nginx 主配置文件
  3. /etc/nginx/nginx.conf.default
  5. # 可执行程序文件
  6. /usr/bin/nginx-upgrade
  7. /usr/sbin/nginx
  9. # nginx库文件
  10. /usr/lib/systemd/system/nginx.service # 用于配置系统守护进程
  11. /usr/lib64/nginx/modules # Nginx模块目录
  13. # 帮助文档
  14. /usr/share/doc/nginx-1.16.1
  15. /usr/share/doc/nginx-1.16.1/CHANGES
  16. /usr/share/doc/nginx-1.16.1/README
  17. /usr/share/doc/nginx-1.16.1/README.dynamic
  18. /usr/share/doc/nginx-1.16.1/UPGRADE-NOTES-1.6-to-1.10
  20. # 静态资源目录
  21. /usr/share/nginx/html/404.html
  22. /usr/share/nginx/html/50x.html
  23. /usr/share/nginx/html/index.html
  25. # 存放Nginx日志文件
  26. /var/log/nginx

主要关注的文件夹有两个：

  1. /etc/nginx/conf.d/是子配置项存放处，/etc/nginx/nginx.conf主配置文件会默认把这个文件夹中所有子配置项都引入；
  2. /usr/share/nginx/html/静态文件都放在这个文件夹，也可以根据你自己的习惯放在其他地方；

Nginx 常用命令

systemctl系统命令：

  1. # 开机配置
  2. systemctl enable nginx # 开机自动启动
  3. systemctl disable nginx # 关闭开机自动启动
  5. # 启动Nginx
  6. systemctl start nginx # 启动Nginx成功后，可以直接访问主机IP，此时会展示Nginx默认页面
  8. # 停止Nginx
  9. systemctl stop nginx
  11. # 重启Nginx
  12. systemctl restart nginx
  14. # 重新加载Nginx
  15. systemctl reload nginx
  17. # 查看 Nginx 运行状态
  18. systemctl status nginx
  20. # 查看Nginx进程
  21. ps -ef | grep nginx
  23. # 杀死Nginx进程
  24. kill -9 pid # 根据上面查看到的Nginx进程号，杀死Nginx进程，-9 表示强制结束进程

Nginx应用程序命令：

  1. nginx -s reload  # 向主进程发送信号，重新加载配置文件，热重启
  3. nginx -s reopen  # 重启 Nginx
  5. nginx -s stop    # 快速关闭
  7. nginx -s quit    # 等待工作进程处理完成后关闭
  9. nginx -T         # 查看当前 Nginx 最终的配置
  11. nginx -t         # 检查配置是否有问题

Nginx 核心配置

配置文件结构

Nginx的典型配置示例：

  1. # main段配置信息
  2. user  nginx;                        # 运行用户，默认即是nginx，可以不进行设置
  3. worker_processes  auto;             # Nginx 进程数，一般设置为和 CPU 核数一样
  4. error_log  /var/log/nginx/error.log warn;   # Nginx 的错误日志存放目录
  5. pid        /var/run/nginx.pid;      # Nginx 服务启动时的 pid 存放位置
  7. # events段配置信息
  8. events {
  9.     use epoll;     # 使用epoll的I/O模型(如果你不知道Nginx该使用哪种轮询方法，会自动选择一个最适合你操作系统的)
  10.     worker_connections 1024;   # 每个进程允许最大并发数
  11. }
  13. # http段配置信息
  14. # 配置使用最频繁的部分，代理、缓存、日志定义等绝大多数功能和第三方模块的配置都在这里设置
  15. http {
  16.     # 设置日志模式
  17.     log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
  18.                       '$status $body_bytes_sent "$http_referer" '
  19.                       '"$http_user_agent" "$http_x_forwarded_for"';
  21.     access_log  /var/log/nginx/access.log  main;   # Nginx访问日志存放位置
  23.     sendfile            on;   # 开启高效传输模式
  24.     tcp_nopush          on;   # 减少网络报文段的数量
  25.     tcp_nodelay         on;
  26.     keepalive_timeout   65;   # 保持连接的时间，也叫超时时间，单位秒
  27.     types_hash_max_size 2048;
  29.     include             /etc/nginx/mime.types;      # 文件扩展名与类型映射表
  30.     default_type        application/octet-stream;   # 默认文件类型
  32.     include /etc/nginx/conf.d/*.conf;   # 加载子配置项
  34.     # server段配置信息
  35.     server {
  36.      listen       80;       # 配置监听的端口
  37.      server_name  localhost;    # 配置的域名
  39.      # location段配置信息
  40.      location / {
  41.       root   /usr/share/nginx/html;  # 网站根目录
  42.       index  index.html index.htm;   # 默认首页文件
  43.       deny 172.168.22.11;   # 禁止访问的ip地址，可以为all
  44.       allow 172.168.33.44；# 允许访问的ip地址，可以为all
  45.      }
  47.      error_page 500 502 503 504 /50x.html;  # 默认50x对应的访问页面
  48.      error_page 400 404 error.html;   # 同上
  49.     }
  50. }
  • main全局配置，对全局生效；
  • events配置影响Nginx服务器与用户的网络连接；
  • http配置代理，缓存，日志定义等绝大多数功能和第三方模块的配置；
  • server配置虚拟主机的相关参数，一个http块中可以有多个server块；
  • location用于配置匹配的uri；
  • upstream配置后端服务器具体地址，负载均衡配置不可或缺的部分；

用一张图清晰的展示它的层级结构：
nginx - 图3

user

指定运行Nginx的woker子进程的属主和属组，其中组可以不指定。

  1. user USERNAME [GROUP]
  3. user nginx lion; # 用户是nginx;组是lion

pid

指定运行Nginxmaster主进程的pid文件存放路径。

  1. pid /opt/nginx/logs/nginx.pid # master主进程的的pid存放在nginx.pid的文件

worker_rlimit_nofile_number

指定worker子进程可以打开的最大文件句柄数。

  1. worker_rlimit_nofile 20480; # 可以理解成每个worker子进程的最大连接数量。

worker_rlimit_core

指定worker子进程异常终止后的core文件，用于记录分析问题。

  1. worker_rlimit_core 50M; # 存放大小限制working_directory /opt/nginx/tmp; # 存放目录复制代码

worker_processes_number

指定Nginx启动的worker子进程数量。

  1. # 指定具体子进程数量worker_processes auto; # 与当前cpu物理核心数一致复制代码
  2. worker_processes 4;

worker_cpu_affinity

将每个worker子进程与我们的cpu物理核心绑定。

  1. worker_cpu_affinity 0001 0010 0100 1000; # 4个物理核心，4个worker子进程复制代码

nginx - 图4
将每个worker子进程与特定CPU物理核心绑定，优势在于，避免同一个worker子进程在不同的CPU核心上切换，缓存失效，降低性能。但其并不能真正的避免进程切换。

worker_priority

指定worker子进程的nice值，以调整运行Nginx的优先级，通常设定为负值，以优先调用Nginx。

  1. worker_priority -10; # 120-10=110，110就是最终的优先级

Linux默认进程的优先级值是120，值越小越优先；nice定范围为-20到+19。
[备注] 应用的默认优先级值是120加上nice值等于它最终的值，这个值越小，优先级越高。

worker_shutdown_timeout

指定worker子进程优雅退出时的超时时间。

  1. worker_shutdown_timeout 5s;

timer_resolution

worker子进程内部使用的计时器精度，调整时间间隔越大，系统调用越少，有利于性能提升；反之，系统调用越多，性能下降。

  1. timer_resolution 100ms;

在Linux系统中，用户需要获取计时器时需要向操作系统内核发送请求，有请求就必然会有开销，因此这个间隔越大开销就越小。

daemon

指定Nginx的运行方式，前台还是后台，前台用于调试，后台用于生产。

  1. daemon off; # 默认是on，后台运行模式

配置文件 events 段核心参数

use

Nginx使用何种事件驱动模型。

  1. use method; # 不推荐配置它，让nginx自己选择method 可选值为：select、poll、kqueue、epoll、/dev/poll、eventport复制代码

worker_connections

worker子进程能够处理的最大并发连接数。

  1. worker_connections 1024 # 每个子进程的最大连接数为1024复制代码

accept_mutex

是否打开负载均衡互斥锁。

  1. accept_mutex on # 默认是off关闭的，这里推荐打开复制代码

server_name 指令

指定虚拟主机域名。

  1. server_name name1 name2 name3# 示例：server_name www.nginx.com;复制代码

域名匹配的四种写法：

  • 精确匹配：server_name www.nginx.com;
  • 左侧通配：server_name *.nginx.com;
  • 右侧统配：server_name www.nginx.*;
  • 正则匹配：server_name ~^www.nginx.*$;

匹配优先级：精确匹配 > 左侧通配符匹配 > 右侧通配符匹配 > 正则表达式匹配
server_name配置实例：
1、配置本地 DNS解析vim /etc/hosts（macOS系统）

  1. # 添加如下内容，其中 121.42.11.34 是阿里云服务器IP地址
  2. 121.42.11.34 www.nginx-test.com
  3. 121.42.11.34 mail.nginx-test.com
  4. 121.42.11.34 www.nginx-test.org
  5. 121.42.11.34 doc.nginx-test.com
  6. 121.42.11.34 www.nginx-test.cn
  7. 121.42.11.34 fe.nginx-test.club

[注意] 这里使用的是虚拟域名进行测试，因此需要配置本地DNS解析，如果使用阿里云上购买的域名，则需要在阿里云上设置好域名解析。

2、配置阿里云Nginx，vim /etc/nginx/nginx.conf

  1. # 这里只列举了http端中的sever端配置
  3. # 左匹配
  4. server {
  5.  listen 80;
  6.  server_name *.nginx-test.com;
  7.  root /usr/share/nginx/html/nginx-test/left-match/;
  8.  location / {
  9.   index index.html;
  10.  }
  11. }
  13. # 正则匹配
  14. server {
  15.  listen 80;
  16.  server_name ~^.*\.nginx-test\..*$;
  17.  root /usr/share/nginx/html/nginx-test/reg-match/;
  18.  location / {
  19.   index index.html;
  20.  }
  21. }
  23. # 右匹配
  24. server {
  25.  listen 80;
  26.  server_name www.nginx-test.*;
  27.  root /usr/share/nginx/html/nginx-test/right-match/;
  28.  location / {
  29.   index index.html;
  30.  }
  31. }
  33. # 完全匹配
  34. server {
  35.  listen 80;
  36.  server_name www.nginx-test.com;
  37.  root /usr/share/nginx/html/nginx-test/all-match/;
  38.  location / {
  39.   index index.html;
  40.  }
  41. }

3、访问分析

  • 当访问www.nginx-test.com时，都可以被匹配上，因此选择优先级最高的“完全匹配”；
  • 当访问mail.nginx-test.com时，会进行“左匹配”；
  • 当访问www.nginx-test.org时，会进行“右匹配”；
  • 当访问doc.nginx-test.com时，会进行“左匹配”；
  • 当访问www.nginx-test.cn时，会进行“右匹配”；
  • 当访问fe.nginx-test.club时，会进行“正则匹配”；

    root

    指定静态资源目录位置，它可以写在http、server、location等配置中。
    1. root path例如：location /image { root /opt/nginx/static;}当用户访问 www.test.com/image/1.png 时，实际在服务器找的路径是 /opt/nginx/static/image/1.png复制代码

[注意]root会将定义路径与URI叠加，alias则只取定义路径。

alias

它也是指定静态资源目录位置，它只能写在location中。

  1. location /image { alias /opt/nginx/static/image/;}当用户访问 www.test.com/image/1.png 时，实际在服务器找的路径是 /opt/nginx/static/image/1.png复制代码

[注意] 使用 alias 末尾一定要添加/，并且它只能位于location中。

location

配置路径。

  1. location [ = | ~ | ~* | ^~ ] uri { ...}复制代码

匹配规则：

  • =精确匹配；
  • ~正则匹配，区分大小写；
  • ~*正则匹配，不区分大小写；
  • ^~匹配到即停止搜索；

匹配优先级：=>^~> ~>~*> 不带任何字符。
实例：

  1. server {
  2.   listen 80;
  3.   server_name www.nginx-test.com;
  5.   # 只有当访问 www.nginx-test.com/match_all/ 时才会匹配到/usr/share/nginx/html/match_all/index.html
  6.   location = /match_all/ {
  7.       root /usr/share/nginx/html
  8.       index index.html
  9.   }
  11.   # 当访问 www.nginx-test.com/1.jpg 等路径时会去 /usr/share/nginx/images/1.jpg 找对应的资源
  12.   location ~ \.(jpeg|jpg|png|svg)$ {
  13.    root /usr/share/nginx/images;
  14.   }
  16.   # 当访问 www.nginx-test.com/bbs/ 时会匹配上 /usr/share/nginx/html/bbs/index.html
  17.   location ^~ /bbs/ {
  18.    root /usr/share/nginx/html;
  19.     index index.html index.htm;
  20.   }
  21. }

location 中的反斜线

  1. location /test {
  2.  ...
  3. }
  5. location /test/ {
  6.  ...
  7. }
  • 不带/当访问www.nginx-test.com/test时，Nginx先找是否有test目录，如果有则找test目录下的index.html；如果没有test目录，nginx则会找是否有test文件。
  • 带/当访问www.nginx-test.com/test时，Nginx先找是否有test目录，如果有则找test目录下的index.html，如果没有它也不会去找是否存在test文件。

    return

    停止处理请求，直接返回响应码或重定向到其他URL；执行return指令后，location中后续指令将不会被执行。 ```shell return code [text]; return code URL; return URL;

例如： location / { return 404; # 直接返回状态码 }

location / { return 404 “pages not found”; # 返回状态码 + 一段文本 }

location / { return 302 /bbs ; # 返回状态码 + 重定向地址 }

location / { return https://www.baidu.com ; # 返回重定向地址 }

  3. <a name="RxT13"></a>
  4. ## [rewrite](https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247487551&idx=1&sn=18f64ba49f3f0f9d8be9d1fdef8857d9&scene=21#wechat_redirect)
  5. 根据指定正则表达式匹配规则，重写URL。
  6. ```shell
  7. 语法：rewrite 正则表达式 要替换的内容 [flag];
  9. 上下文：server、location、if
  11. 示例：rewirte /images/(.*\.jpg)$ /pic/$1; # $1是前面括号(.*\.jpg)的反向引用

flag可选值的含义：

  • last重写后的URL发起新请求，再次进入server段，重试location的中的匹配；
  • break直接使用重写后的URL，不再匹配其它location中语句；
  • redirect返回302临时重定向；

  • permanent返回301永久重定向；

    1. server{
    2. listen 80;
    3. server_name fe.lion.club; # 要在本地hosts文件进行配置
    4. root html;
    5. location /search {
    6.  rewrite ^/(.*) https://www.baidu.com redirect;
    7. }
    9. location /images {
    10.  rewrite /images/(.*) /pics/$1;
    11. }
    13. location /pics {
    14.  rewrite /pics/(.*) /photos/$1;
    15. }
    17. location /photos {
    19. }
    20. }

按照这个配置我们来分析：

  • 当访问fe.lion.club/search时，会自动帮我们重定向到https://www.baidu.com。
  • 当访问fe.lion.club/images/1.jpg时，第一步重写URL为fe.lion.club/pics/1.jpg，找到pics的location，继续重写URL为fe.lion.club/photos/1.jpg，找到/photos的location后，去html/photos目录下寻找1.jpg静态资源。

    if 指令

    ```shell 语法：if (condition) {…}

上下文：server、location

示例： if($http_user_agent ~ Chrome){ rewrite /(.*)/browser/$1 break; }

  3. condition判断条件：
  5. - $variable仅为变量时，值为空或以0开头字符串都会被当做false处理；
  6. - =或!=相等或不等；
  7. - ~正则匹配；
  8. - ! ~非正则匹配；
  9. - ~*正则匹配，不区分大小写；
  10. - -f或! -f检测文件存在或不存在；
  11. - -d或! -d检测目录存在或不存在；
  12. - -e或! -e检测文件、目录、符号链接等存在或不存在；
  13. - -x或! -x检测文件可以执行或不可执行；
  15. 实例：
  16. ```shell
  17. server {
  18.   listen 8080;
  19.   server_name localhost;
  20.   root html;
  22.   location / {
  23.    if ( $uri = "/images/" ){
  24.      rewrite (.*) /pics/ break;
  25.     }
  26.   }
  27. }

当访问localhost:8080/images/时，会进入if判断里面执行rewrite命令。

autoindex

用户请求以/结尾时，列出目录结构，可以用于快速搭建静态资源下载网站。
autoindex.conf配置信息：

  1. server {
  2.   listen 80;
  3.   server_name fe.lion-test.club;
  5.   location /download/ {
  6.     root /opt/source;
  8.     autoindex on; # 打开 autoindex，，可选参数有 on | off
  9.     autoindex_exact_size on; # 修改为off，以KB、MB、GB显示文件大小，默认为on，以bytes显示出⽂件的确切⼤⼩
  10.     autoindex_format html; # 以html的方式进行格式化，可选参数有 html | json | xml
  11.     autoindex_localtime off; # 显示的⽂件时间为⽂件的服务器时间。默认为off，显示的⽂件时间为GMT时间
  12.   }
  13. }

当访问fe.lion.com/download/时，会把服务器/opt/source/download/路径下的文件展示出来，如下图所示：
image.png

变量

Nginx提供给使用者的变量非常多，但是终究是一个完整的请求过程所产生数据，Nginx将这些数据以变量的形式提供给使用者。
下面列举些项目中常用的变量：

变量名 含义
remote_addr 客户端
IP
地址
remote_port 客户端端口
server_addr 服务端
IP
地址
server_port 服务端端口
server_protocol 服务端协议
binary_remote_addr 二进制格式的客户端
IP
地址
connection TCP
连接的序号，递增
connection_request TCP
连接当前的请求数量
uri 请求的URL，不包含参数
request_uri 请求的URL，包含参数
scheme 协议名，
http
或
https
request_method 请求方法
request_length 全部请求的长度，包含请求行、请求头、请求体
args 全部参数字符串
arg_参数名 获取特定参数值
is_args URL
中是否有参数，有的话返回
?
，否则返回空
query_string 与
args
相同
host 请求信息中的
Host
，如果请求中没有
Host
行，则在请求头中找，最后使用
nginx
中设置的
server_name
。
http_user_agent 用户浏览器
http_referer 从哪些链接过来的请求
http_via 每经过一层代理服务器，都会添加相应的信息
http_cookie 获取用户
cookie
request_time 处理请求已消耗的时间
https 是否开启了
https
，是则返回
on
，否则返回空
request_filename 磁盘文件系统待访问文件的完整路径
document_root 由
URI
和
root/alias
规则生成的文件夹路径
limit_rate 返回响应时的速度上限值

实例演示var.conf：

  1. server{
  2.  listen 8081;
  3.  server_name var.lion-test.club;
  4.  root /usr/share/nginx/html;
  5.  location / {
  6.   return 200 "
  7. remote_addr: $remote_addr
  8. remote_port: $remote_port
  9. server_addr: $server_addr
  10. server_port: $server_port
  11. server_protocol: $server_protocol
  12. binary_remote_addr: $binary_remote_addr
  13. connection: $connection
  14. uri: $uri
  15. request_uri: $request_uri
  16. scheme: $scheme
  17. request_method: $request_method
  18. request_length: $request_length
  19. args: $args
  20. arg_pid: $arg_pid
  21. is_args: $is_args
  22. query_string: $query_string
  23. host: $host
  24. http_user_agent: $http_user_agent
  25. http_referer: $http_referer
  26. http_via: $http_via
  27. request_time: $request_time
  28. https: $https
  29. request_filename: $request_filename
  30. document_root: $document_root
  31. ";
  32.  }
  33. }

当我们访问http://var.lion-test.club:8081/test?pid=121414&cid=sadasd时，由于Nginx中写了return方法，因此chrome浏览器会默认为我们下载一个文件，下面展示的就是下载的文件内容：

  1. remote_addr: 27.16.220.84
  2. remote_port: 56838
  3. server_addr: 172.17.0.2
  4. server_port: 8081
  5. server_protocol: HTTP/1.1
  6. binary_remote_addr: 茉
  7. connection: 126
  8. uri: /test/
  9. request_uri: /test/?pid=121414&cid=sadasd
  10. scheme: http
  11. request_method: GET
  12. request_length: 518
  13. args: pid=121414&cid=sadasd
  14. arg_pid: 121414
  15. is_args: ?
  16. query_string: pid=121414&cid=sadasd
  17. host: var.lion-test.club
  18. http_user_agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36
  19. http_referer:
  20. http_via:
  21. request_time: 0.000
  22. https:
  23. request_filename: /usr/share/nginx/html/test/
  24. document_root: /usr/share/nginx/html

Nginx的配置还有非常多，以上只是罗列了一些常用的配置，在实际项目中还是要学会查阅文档。

Nginx 应用核心概念

代理是在服务器和客户端之间假设的一层服务器，代理将接收客户端的请求并将它转发给服务器，然后将服务端的响应转发给客户端。
不管是正向代理还是反向代理，实现的都是上面的功能。
image.png

正向代理

正向代理，意思是一个位于客户端和原始服务器(origin server)之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)，然后代理向原始服务器转交请求并将获得的内容返回给客户端。
正向代理是为我们服务的，即为客户端服务的，客户端可以根据正向代理访问到它本身无法访问到的服务器资源。
正向代理对我们是透明的，对服务端是非透明的，即服务端并不知道自己收到的是来自代理的访问还是来自真实客户端的访问。

反向代理

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

反向代理是为服务端服务的，反向代理可以帮助服务器接收来自客户端的请求，帮助服务器做请求转发，负载均衡等。
反向代理对服务端是透明的，对我们是非透明的，即我们并不知道自己访问的是代理服务器，而服务器知道反向代理在为他服务。
反向代理的优势：

  • 隐藏真实服务器；
  • 负载均衡便于横向扩充后端动态服务；
  • 动静分离，提升系统健壮性；

那么“动静分离”是什么？负载均衡又是什么？

动静分离

动静分离是指在web服务器架构中，将静态页面与动态页面或者静态内容接口和动态内容接口分开不同系统访问的架构设计方法，进而提示整个服务的访问性和可维护性。
image.png
一般来说，都需要将动态资源和静态资源分开，由于Nginx的高并发和静态资源缓存等特性，经常将静态资源部署在Nginx上。如果请求的是静态资源，直接到静态资源目录获取资源，如果是动态资源的请求，则利用反向代理的原理，把请求转发给对应后台应用去处理，从而实现动静分离。
使用前后端分离后，可以很大程度提升静态资源的访问速度，即使动态服务不可用，静态资源的访问也不会受到影响。

负载均衡

一般情况下，客户端发送多个请求到服务器，服务器处理请求，其中一部分可能要操作一些资源比如数据库、静态资源等，服务器处理完毕后，再将结果返回给客户端。
这种模式对于早期的系统来说，功能要求不复杂，且并发请求相对较少的情况下还能胜任，成本也低。随着信息数量不断增长，访问量和数据量飞速增长，以及系统业务复杂度持续增加，这种做法已无法满足要求，并发量特别大时，服务器容易崩。
很明显这是由于服务器性能的瓶颈造成的问题，除了堆机器之外，最重要的做法就是负载均衡。
请求爆发式增长的情况下，单个机器性能再强劲也无法满足要求了，这个时候集群的概念产生了，单个服务器解决不了的问题，可以使用多个服务器，然后将请求分发到各个服务器上，将负载分发到不同的服务器，这就是负载均衡，核心是「分摊压力」。Nginx实现负载均衡，一般来说指的是将请求转发给服务器集群。
举个具体的例子，晚高峰乘坐地铁的时候，入站口经常会有地铁工作人员大喇叭“请走B口，B口人少车空….”，这个工作人员的作用就是负载均衡。image.png
Nginx实现负载均衡的策略：

  • 轮询策略：默认情况下采用的策略，将所有客户端请求轮询分配给服务端。这种策略是可以正常工作的，但是如果其中某一台服务器压力太大，出现延迟，会影响所有分配在这台服务器下的用户。
  • 最小连接数策略：将请求优先分配给压力较小的服务器，它可以平衡每个队列的长度，并避免向压力大的服务器添加更多的请求。
  • 最快响应时间策略：优先分配给响应时间最短的服务器。
  • 客户端ip绑定策略：来自同一个ip的请求永远只分配一台服务器，有效解决了动态网页存在的session共享问题。

    Nginx 实战配置

    在配置反向代理和负载均衡等等功能之前，有两个核心模块是我们必须要掌握的，这两个模块应该说是Nginx应用配置中的核心，它们分别是：upstream、proxy_pass。

    upstream

    用于定义上游服务器（指的就是后台提供的应用服务器）的相关信息。
    image.png
    1. 语法：upstream name { ...}上下文：http示例：upstream back_end_server{  server 192.168.100.33:8081}复制代码

在upstream内可使用的指令：

  • server定义上游服务器地址；
  • zone定义共享内存，用于跨worker子进程；
  • keepalive对上游服务启用长连接；
  • keepalive_requests一个长连接最多请求HTTP的个数；
  • keepalive_timeout空闲情形下，一个长连接的超时时长；
  • hash哈希负载均衡算法；
  • ip_hash依据IP进行哈希计算的负载均衡算法；
  • least_conn最少连接数负载均衡算法；
  • least_time最短响应时间负载均衡算法；
  • random随机负载均衡算法；

    server

    定义上游服务器地址。 ```shell 语法：server address [parameters]

上下文：upstream

  3. parameters可选值：
  5. - weight=number权重值，默认为1；
  6. - max_conns=number上游服务器的最大并发连接数；
  7. - fail_timeout=time服务器不可用的判定时间；
  8. - max_fails=numer服务器不可用的检查次数；
  9. - backup备份服务器，仅当其他服务器都不可用时才会启用；
  10. - down标记服务器长期不可用，离线维护；
  11. <a name="Rw08P"></a>
  12. ### [keepalive](https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247487551&idx=1&sn=18f64ba49f3f0f9d8be9d1fdef8857d9&scene=21#wechat_redirect)
  13. 限制每个worker子进程与上游服务器空闲长连接的最大数量。
  14. ```shell
  15. keepalive connections;
  17. 上下文：upstream
  19. 示例：keepalive 16;

keepalive_requests

单个长连接可以处理的最多HTTP请求个数。

  1. 语法：keepalive_requests number;
  3. 默认值：keepalive_requests 100;
  5. 上下文：upstream

keepalive_timeout

空闲长连接的最长保持时间。

  1. 语法：keepalive_timeout time;默认值：keepalive_timeout 60s;上下文：upstream复制代码

配置实例

  1. upstream back_end{
  2.  server 127.0.0.1:8081 weight=3 max_conns=1000 fail_timeout=10s max_fails=2;
  3.   keepalive 32;
  4.   keepalive_requests 50;
  5.   keepalive_timeout 30s;
  6. }

proxy_pass

用于配置代理服务器。

  1. 语法：proxy_pass URL;
  3. 上下文：location、if、limit_except
  5. 示例：
  6. proxy_pass http://127.0.0.1:8081
  7. proxy_pass http://127.0.0.1:8081/proxy前言
  8. 作为一名前端开发人员，你是不是经常碰到领导让你上服务器去修改Nginx配置，然而你会以“我是前端，这个我不会”为理由搪塞过去呢！今天就让我们一起告别这种尴尬，向“真正”的程序员迈进！！！
  9. 如果本文对你有所帮助，请点个👍 👍 👍 吧！
  10. Nginx 概述
  11. 
  12. 
  13. 
  14. Nginx是开源、高性能、高可靠的Web和反向代理服务器，而且支持热部署，几乎可以做到 7 * 24 小时不间断运行，即使运行几个月也不需要重新启动，还能在不间断服务的情况下对软件版本进行热更新。性能是Nginx最重要的考量，其占用内存少、并发能力强、能支持高达 5w 个并发连接数，最重要的是，Nginx是免费的并可以商业化，配置使用也比较简单。
  15. Nginx 特点
  16. ●
  17. 高并发、高性能；
  18. ●
  19. 模块化架构使得它的扩展性非常好；
  20. ●
  21. 异步非阻塞的事件驱动模型这点和Node.js相似；
  22. ●
  23. 相对于其它服务器来说它可以连续几个月甚至更长而不需要重启服务器使得它具有高可靠性；
  24. ●
  25. 热部署、平滑升级；
  26. ●
  27. 完全开源，生态繁荣；
  28. Nginx 作用
  29. Nginx 的最重要的几个使用场景：
  30. 1
  31. 静态资源服务，通过本地文件系统提供服务；
  32. 2
  33. 反向代理服务，延伸出包括缓存、负载均衡等；
  34. 3
  35. API服务，OpenResty；
  36. 对于前端来说Node.js并不陌生，Nginx和Node.js的很多理念类似，HTTP服务器、事件驱动、异步非阻塞等，且Nginx的大部分功能使用Node.js也可以实现，但Nginx和Node.js并不冲突，都有自己擅长的领域。Nginx擅长于底层服务器端资源的处理（静态资源处理转发、反向代理，负载均衡等），Node.js更擅长上层具体业务逻辑的处理，两者可以完美组合。
  37. 用一张图表示：
  38. 
  39. 
  40. 
  41. Nginx 安装
  42. 本文演示的是LinuxcentOS 7.x的操作系统上安装Nginx，至于在其它操作系统上进行安装可以网上自行搜索，都非常简单的。
  43. 使用 yum安装Nginx：
  45. 
  46. 1
  47. yum install nginx -y
  49. 安装完成后，通过rpm -ql nginx命令查看Nginx的安装信息：
  51. 
  52. 1
  53. # Nginx配置文件
  54. 2
  55. /etc/nginx/nginx.conf # nginx 主配置文件
  56. 3
  57. /etc/nginx/nginx.conf.default
  58. 4
  60. 5
  61. # 可执行程序文件
  62. 6
  63. /usr/bin/nginx-upgrade
  64. 7
  65. /usr/sbin/nginx
  66. 8
  68. 9
  69. # nginx库文件
  70. 10
  71. /usr/lib/systemd/system/nginx.service # 用于配置系统守护进程
  72. 11
  73. /usr/lib64/nginx/modules # Nginx模块目录
  74. 12
  76. 13
  77. # 帮助文档
  78. 14
  79. /usr/share/doc/nginx-1.16.1
  80. 15
  81. /usr/share/doc/nginx-1.16.1/CHANGES
  82. 16
  83. /usr/share/doc/nginx-1.16.1/README
  84. 17
  85. /usr/share/doc/nginx-1.16.1/README.dynamic
  86. 18
  87. /usr/share/doc/nginx-1.16.1/UPGRADE-NOTES-1.6-to-1.10
  88. 19
  90. 20
  91. # 静态资源目录
  92. 21
  93. /usr/share/nginx/html/404.html
  94. 22
  95. /usr/share/nginx/html/50x.html
  96. 23
  97. /usr/share/nginx/html/index.html
  98. 24
  100. 25
  101. # 存放Nginx日志文件
  102. 26
  103. /var/log/nginx
  105. 主要关注的文件夹有两个：
  106. 1
  107. /etc/nginx/conf.d/是子配置项存放处，/etc/nginx/nginx.conf主配置文件会默认把这个文件夹中所有子配置项都引入；
  108. 2
  109. /usr/share/nginx/html/静态文件都放在这个文件夹，也可以根据你自己的习惯放在其他地方；
  111. Nginx 常用命令
  112. systemctl系统命令：
  116. 
  117. 1
  118. # 开机配置
  119. 2
  120. systemctl enable nginx # 开机自动启动
  121. 3
  122. systemctl disable nginx # 关闭开机自动启动
  123. 4
  125. 5
  126. # 启动Nginx
  127. 6
  128. systemctl start nginx # 启动Nginx成功后，可以直接访问主机IP，此时会展示Nginx默认页面
  129. 7
  131. 8
  132. # 停止Nginx
  133. 9
  134. systemctl stop nginx
  135. 10
  137. 11
  138. # 重启Nginx
  139. 12
  140. systemctl restart nginx
  141. 13
  143. 14
  144. # 重新加载Nginx
  145. 15
  146. systemctl reload nginx
  147. 16
  149. 17
  150. # 查看 Nginx 运行状态
  151. 18
  152. systemctl status nginx
  153. 19
  155. 20
  156. # 查看Nginx进程
  157. 21
  158. ps -ef | grep nginx
  159. 22
  161. 23
  162. # 杀死Nginx进程
  163. 24
  164. kill -9 pid # 根据上面查看到的Nginx进程号，杀死Nginx进程，-9 表示强制结束进程
  165. 25
  168. Nginx应用程序命令：
  171. 
  172. 1
  173. nginx -s reload  # 向主进程发送信号，重新加载配置文件，热重启
  174. 2
  176. 3
  177. nginx -s reopen  # 重启 Nginx
  178. 4
  180. 5
  181. nginx -s stop    # 快速关闭
  182. 6
  184. 7
  185. nginx -s quit    # 等待工作进程处理完成后关闭
  186. 8
  188. 9
  189. nginx -T         # 查看当前 Nginx 最终的配置
  190. 10
  192. 11
  193. nginx -t         # 检查配置是否有问题
  195. Nginx 核心配置
  196. 配置文件结构
  197. Nginx的典型配置示例：
  200. 
  201. 1
  202. # main段配置信息
  203. 2
  204. user  nginx;                        # 运行用户，默认即是nginx，可以不进行设置
  205. 3
  206. worker_processes  auto;             # Nginx 进程数，一般设置为和 CPU 核数一样
  207. 4
  208. error_log  /var/log/nginx/error.log warn;   # Nginx 的错误日志存放目录
  209. 5
  210. pid        /var/run/nginx.pid;      # Nginx 服务启动时的 pid 存放位置
  211. 6
  213. 7
  214. # events段配置信息
  215. 8
  216. events {
  217. 9
  218.     use epoll;     # 使用epoll的I/O模型(如果你不知道Nginx该使用哪种轮询方法，会自动选择一个最适合你操作系统的)
  219. 10
  220.     worker_connections 1024;   # 每个进程允许最大并发数
  221. 11
  222. }
  223. 12
  225. 13
  226. # http段配置信息
  227. 14
  228. # 配置使用最频繁的部分，代理、缓存、日志定义等绝大多数功能和第三方模块的配置都在这里设置
  229. 15
  230. http {
  231. 16
  232.     # 设置日志模式
  233. 17
  234.     log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
  235. 18
  236.                       '$status $body_bytes_sent "$http_referer" '
  237. 19
  238.                       '"$http_user_agent" "$http_x_forwarded_for"';
  239. 20
  241. 21
  242.     access_log  /var/log/nginx/access.log  main;   # Nginx访问日志存放位置
  243. 22
  245. 23
  246.     sendfile            on;   # 开启高效传输模式
  247. 24
  248.     tcp_nopush          on;   # 减少网络报文段的数量
  249. 25
  250.     tcp_nodelay         on;
  251. 26
  252.     keepalive_timeout   65;   # 保持连接的时间，也叫超时时间，单位秒
  253. 27
  254.     types_hash_max_size 2048;
  255. 28
  257. 29
  258.     include             /etc/nginx/mime.types;      # 文件扩展名与类型映射表
  259. 30
  260.     default_type        application/octet-stream;   # 默认文件类型
  261. 31
  263. 32
  264.     include /etc/nginx/conf.d/*.conf;   # 加载子配置项
  265. 33
  267. 34
  268.     # server段配置信息
  269. 35
  270.     server {
  271. 36
  272.      listen       80;       # 配置监听的端口
  273. 37
  274.      server_name  localhost;    # 配置的域名
  275. 38
  277. 39
  278.      # location段配置信息
  279. 40
  280.      location / {
  281. 41
  282.       root   /usr/share/nginx/html;  # 网站根目录
  283. 42
  284.       index  index.html index.htm;   # 默认首页文件
  285. 43
  286.       deny 172.168.22.11;   # 禁止访问的ip地址，可以为all
  287. 44
  288.       allow 172.168.33.44；# 允许访问的ip地址，可以为all
  289. 45
  290.      }
  291. 46
  293. 47
  294.      error_page 500 502 503 504 /50x.html;  # 默认50x对应的访问页面
  295. 48
  296.      error_page 400 404 error.html;   # 同上
  297. 49
  298.     }
  299. 50
  300. }
  302. ●
  303. main全局配置，对全局生效；
  304. ●
  305. events配置影响Nginx服务器与用户的网络连接；
  306. ●
  307. http配置代理，缓存，日志定义等绝大多数功能和第三方模块的配置；
  308. ●
  309. server配置虚拟主机的相关参数，一个http块中可以有多个server块；
  310. ●
  311. location用于配置匹配的uri；
  312. ●
  313. upstream配置后端服务器具体地址，负载均衡配置不可或缺的部分；
  315. 用一张图清晰的展示它的层级结构：
  316. 
  317. 
  318. 
  319. user
  320. 指定运行Nginx的woker子进程的属主和属组，其中组可以不指定。
  322. 
  323. 1
  324. user USERNAME [GROUP]
  325. 2
  327. 3
  328. user nginx lion; # 用户是nginx;组是lion
  329. 4
  333. pid
  334. 指定运行Nginxmaster主进程的pid文件存放路径。
  336. 
  337. 1
  338. pid /opt/nginx/logs/nginx.pid # master主进程的的pid存放在nginx.pid的文件
  340. worker_rlimit_nofile_number
  341. 指定worker子进程可以打开的最大文件句柄数。
  343. 
  344. 1
  345. worker_rlimit_nofile 20480; # 可以理解成每个worker子进程的最大连接数量。
  347. worker_rlimit_core
  348. 指定worker子进程异常终止后的core文件，用于记录分析问题。
  351. 
  352. 1
  353. worker_rlimit_core 50M; # 存放大小限制working_directory /opt/nginx/tmp; # 存放目录复制代码
  355. worker_processes_number
  356. 指定Nginx启动的worker子进程数量。
  358. 
  359. 1
  360. # 指定具体子进程数量worker_processes auto; # 与当前cpu物理核心数一致复制代码
  361. 2
  362. worker_processes 4;
  364. worker_cpu_affinity
  365. 将每个worker子进程与我们的cpu物理核心绑定。
  368. 
  369. 1
  370. worker_cpu_affinity 0001 0010 0100 1000; # 4个物理核心，4个worker子进程复制代码
  372. 
  373. 
  374. 
  375. 将每个worker子进程与特定CPU物理核心绑定，优势在于，避免同一个worker子进程在不同的CPU核心上切换，缓存失效，降低性能。但其并不能真正的避免进程切换。
  377. worker_priority
  378. 指定worker子进程的nice值，以调整运行Nginx的优先级，通常设定为负值，以优先调用Nginx。
  380. 
  381. 1
  382. worker_priority -10; # 120-10=110，110就是最终的优先级
  384. Linux默认进程的优先级值是120，值越小越优先；nice定范围为-20到+19。
  385. [备注] 应用的默认优先级值是120加上nice值等于它最终的值，这个值越小，优先级越高。
  386. worker_shutdown_timeout
  387. 指定worker子进程优雅退出时的超时时间。
  390. 
  391. 1
  392. worker_shutdown_timeout 5s;
  394. timer_resolution
  395. worker子进程内部使用的计时器精度，调整时间间隔越大，系统调用越少，有利于性能提升；反之，系统调用越多，性能下降。
  397. 
  398. 1
  399. timer_resolution 100ms;
  403. 在Linux系统中，用户需要获取计时器时需要向操作系统内核发送请求，有请求就必然会有开销，因此这个间隔越大开销就越小。
  404. daemon
  405. 指定Nginx的运行方式，前台还是后台，前台用于调试，后台用于生产。
  407. 
  408. 1
  409. daemon off; # 默认是on，后台运行模式
  412. 配置文件 events 段核心参数
  413. use
  414. Nginx使用何种事件驱动模型。
  416. 
  417. 1
  418. use method; # 不推荐配置它，让nginx自己选择method 可选值为：select、poll、kqueue、epoll、/dev/poll、eventport复制代码
  421. worker_connections
  422. worker子进程能够处理的最大并发连接数。
  424. 
  425. 1
  426. worker_connections 1024 # 每个子进程的最大连接数为1024复制代码
  429. accept_mutex
  430. 是否打开负载均衡互斥锁。
  432. 
  433. 1
  434. accept_mutex on # 默认是off关闭的，这里推荐打开复制代码
  437. server_name 指令
  438. 指定虚拟主机域名。
  440. 
  441. 1
  442. server_name name1 name2 name3# 示例：server_name www.nginx.com;复制代码
  445. 域名匹配的四种写法：
  446. ●
  447. 精确匹配：server_name www.nginx.com;
  448. ●
  449. 左侧通配：server_name *.nginx.com;
  450. ●
  451. 右侧统配：server_name www.nginx.*;
  452. ●
  453. 正则匹配：server_name ~^www\.nginx\.*$;
  454. 匹配优先级：精确匹配 > 左侧通配符匹配 > 右侧通配符匹配 > 正则表达式匹配
  455. server_name配置实例：
  456. 1、配置本地 DNS解析vim /etc/hosts（macOS系统）
  458. 
  459. 1
  460. # 添加如下内容，其中 121.42.11.34 是阿里云服务器IP地址
  461. 2
  462. 121.42.11.34 www.nginx-test.com
  463. 3
  464. 121.42.11.34 mail.nginx-test.com
  465. 4
  466. 121.42.11.34 www.nginx-test.org
  467. 5
  468. 121.42.11.34 doc.nginx-test.com
  469. 6
  470. 121.42.11.34 www.nginx-test.cn
  471. 7
  472. 121.42.11.34 fe.nginx-test.club
  476. [注意] 这里使用的是虚拟域名进行测试，因此需要配置本地DNS解析，如果使用阿里云上购买的域名，则需要在阿里云上设置好域名解析。
  478. 2、配置阿里云Nginx，vim /etc/nginx/nginx.conf
  480. 
  481. 1
  482. # 这里只列举了http端中的sever端配置
  483. 2
  485. 3
  486. # 左匹配
  487. 4
  488. server {
  489. 5
  490.  listen 80;
  491. 6
  492.  server_name *.nginx-test.com;
  493. 7
  494.  root /usr/share/nginx/html/nginx-test/left-match/;
  495. 8
  496.  location / {
  497. 9
  498.   index index.html;
  499. 10
  500.  }
  501. 11
  502. }
  503. 12
  505. 13
  506. # 正则匹配
  507. 14
  508. server {
  509. 15
  510.  listen 80;
  511. 16
  512.  server_name ~^.*\.nginx-test\..*$;
  513. 17
  514.  root /usr/share/nginx/html/nginx-test/reg-match/;
  515. 18
  516.  location / {
  517. 19
  518.   index index.html;
  519. 20
  520.  }
  521. 21
  522. }
  523. 22
  525. 23
  526. # 右匹配
  527. 24
  528. server {
  529. 25
  530.  listen 80;
  531. 26
  532.  server_name www.nginx-test.*;
  533. 27
  534.  root /usr/share/nginx/html/nginx-test/right-match/;
  535. 28
  536.  location / {
  537. 29
  538.   index index.html;
  539. 30
  540.  }
  541. 31
  542. }
  543. 32
  545. 33
  546. # 完全匹配
  547. 34
  548. server {
  549. 35
  550.  listen 80;
  551. 36
  552.  server_name www.nginx-test.com;
  553. 37
  554.  root /usr/share/nginx/html/nginx-test/all-match/;
  555. 38
  556.  location / {
  557. 39
  558.   index index.html;
  559. 40
  560.  }
  561. 41
  562. }
  566. 3、访问分析
  567. ●
  568. 当访问www.nginx-test.com时，都可以被匹配上，因此选择优先级最高的“完全匹配”；
  569. ●
  570. 当访问mail.nginx-test.com时，会进行“左匹配”；
  571. ●
  572. 当访问www.nginx-test.org时，会进行“右匹配”；
  573. ●
  574. 当访问doc.nginx-test.com时，会进行“左匹配”；
  575. ●
  576. 当访问www.nginx-test.cn时，会进行“右匹配”；
  577. ●
  578. 当访问fe.nginx-test.club时，会进行“正则匹配”；
  579. root
  580. 指定静态资源目录位置，它可以写在http、server、location等配置中。
  582. 
  583. 1
  584. root path例如：location /image { root /opt/nginx/static;}当用户访问 www.test.com/image/1.png 时，实际在服务器找的路径是 /opt/nginx/static/image/1.png复制代码
  587. [注意]root会将定义路径与URI叠加，alias则只取定义路径。
  588. alias
  589. 它也是指定静态资源目录位置，它只能写在location中。
  591. 
  592. 1
  593. location /image { alias /opt/nginx/static/image/;}当用户访问 www.test.com/image/1.png 时，实际在服务器找的路径是 /opt/nginx/static/image/1.png复制代码
  596. [注意] 使用 alias 末尾一定要添加/，并且它只能位于location中。
  597. location
  598. 配置路径。
  600. 
  601. 1
  602. location [ = | ~ | ~* | ^~ ] uri { ...}复制代码
  605. 匹配规则：
  606. ●
  607. =精确匹配；
  608. ●
  609. ~正则匹配，区分大小写；
  610. ●
  611. ~*正则匹配，不区分大小写；
  612. ●
  613. ^~匹配到即停止搜索；
  614. 匹配优先级：=>^~> ~>~*> 不带任何字符。
  615. 实例：
  617. 
  618. 1
  619. server {
  620. 2
  621.   listen 80;
  622. 3
  623.   server_name www.nginx-test.com;
  624. 4
  626. 5
  627.   # 只有当访问 www.nginx-test.com/match_all/ 时才会匹配到/usr/share/nginx/html/match_all/index.html
  628. 6
  629.   location = /match_all/ {
  630. 7
  631.       root /usr/share/nginx/html
  632. 8
  633.       index index.html
  634. 9
  635.   }
  636. 10
  638. 11
  639.   # 当访问 www.nginx-test.com/1.jpg 等路径时会去 /usr/share/nginx/images/1.jpg 找对应的资源
  640. 12
  641.   location ~ \.(jpeg|jpg|png|svg)$ {
  642. 13
  643.    root /usr/share/nginx/images;
  644. 14
  645.   }
  646. 15
  648. 16
  649.   # 当访问 www.nginx-test.com/bbs/ 时会匹配上 /usr/share/nginx/html/bbs/index.html
  650. 17
  651.   location ^~ /bbs/ {
  652. 18
  653.    root /usr/share/nginx/html;
  654. 19
  655.     index index.html index.htm;
  656. 20
  657.   }
  658. 21
  659. }
  663. location 中的反斜线
  665. 
  666. 1
  667. location /test {
  668. 2
  669.  ...
  670. 3
  671. }
  672. 4
  674. 5
  675. location /test/ {
  676. 6
  677.  ...
  678. 7
  679. }
  683. ●
  684. 不带/当访问www.nginx-test.com/test时，Nginx先找是否有test目录，如果有则找test目录下的index.html；如果没有test目录，nginx则会找是否有test文件。
  685. ●
  686. 带/当访问www.nginx-test.com/test时，Nginx先找是否有test目录，如果有则找test目录下的index.html，如果没有它也不会去找是否存在test文件。
  687. return
  688. 停止处理请求，直接返回响应码或重定向到其他URL；执行return指令后，location中后续指令将不会被执行。
  690. 
  691. 1
  692. return code [text];
  693. 2
  694. return code URL;
  695. 3
  696. return URL;
  697. 4
  699. 5
  700. 例如：
  701. 6
  702. location / {
  703. 7
  704.  return 404; # 直接返回状态码
  705. 8
  706. }
  707. 9
  709. 10
  710. location / {
  711. 11
  712.  return 404 "pages not found"; # 返回状态码 + 一段文本
  713. 12
  714. }
  715. 13
  717. 14
  718. location / {
  719. 15
  720.  return 302 /bbs ; # 返回状态码 + 重定向地址
  721. 16
  722. }
  723. 17
  725. 18
  726. location / {
  727. 19
  728.  return https://www.baidu.com ; # 返回重定向地址
  729. 20
  730. }
  734. rewrite
  735. 根据指定正则表达式匹配规则，重写URL。
  737. 
  738. 1
  739. 语法：rewrite 正则表达式 要替换的内容 [flag];
  740. 2
  742. 3
  743. 上下文：server、location、if
  744. 4
  746. 5
  747. 示例：rewirte /images/(.*\.jpg)$ /pic/$1; # $1是前面括号(.*\.jpg)的反向引用
  751. flag可选值的含义：
  752. ●
  753. last重写后的URL发起新请求，再次进入server段，重试location的中的匹配；
  754. ●
  755. break直接使用重写后的URL，不再匹配其它location中语句；
  756. ●
  757. redirect返回302临时重定向；
  758. ●
  759. permanent返回301永久重定向；
  761. 
  762. 1
  763. server{
  764. 2
  765.   listen 80;
  766. 3
  767.   server_name fe.lion.club; # 要在本地hosts文件进行配置
  768. 4
  769.   root html;
  770. 5
  771.   location /search {
  772. 6
  773.    rewrite ^/(.*) https://www.baidu.com redirect;
  774. 7
  775.   }
  776. 8
  778. 9
  779.   location /images {
  780. 10
  781.    rewrite /images/(.*) /pics/$1;
  782. 11
  783.   }
  784. 12
  786. 13
  787.   location /pics {
  788. 14
  789.    rewrite /pics/(.*) /photos/$1;
  790. 15
  791.   }
  792. 16
  794. 17
  795.   location /photos {
  796. 18
  798. 19
  799.   }
  800. 20
  801. }
  805. 按照这个配置我们来分析：
  806. ●
  807. 当访问fe.lion.club/search时，会自动帮我们重定向到https://www.baidu.com。
  808. ●
  809. 当访问fe.lion.club/images/1.jpg时，第一步重写URL为fe.lion.club/pics/1.jpg，找到pics的location，继续重写URL为fe.lion.club/photos/1.jpg，找到/photos的location后，去html/photos目录下寻找1.jpg静态资源。
  810. if 指令
  812. 
  813. 1
  814. 语法：if (condition) {...}
  815. 2
  817. 3
  818. 上下文：server、location
  819. 4
  821. 5
  822. 示例：
  823. 6
  824. if($http_user_agent ~ Chrome){
  825. 7
  826.   rewrite /(.*)/browser/$1 break;
  827. 8
  828. }
  832. condition判断条件：
  833. ●
  834. $variable仅为变量时，值为空或以0开头字符串都会被当做false处理；
  835. ●
  836. =或!=相等或不等；
  837. ●
  838. ~正则匹配；
  839. ●
  840. ! ~非正则匹配；
  841. ●
  842. ~*正则匹配，不区分大小写；
  843. ●
  844. -f或! -f检测文件存在或不存在；
  845. ●
  846. -d或! -d检测目录存在或不存在；
  847. ●
  848. -e或! -e检测文件、目录、符号链接等存在或不存在；
  849. ●
  850. -x或! -x检测文件可以执行或不可执行；
  851. 实例：
  853. 
  854. 1
  855. server {
  856. 2
  857.   listen 8080;
  858. 3
  859.   server_name localhost;
  860. 4
  861.   root html;
  862. 5
  864. 6
  865.   location / {
  866. 7
  867.    if ( $uri = "/images/" ){
  868. 8
  869.      rewrite (.*) /pics/ break;
  870. 9
  871.     }
  872. 10
  873.   }
  874. 11
  875. }
  879. 当访问localhost:8080/images/时，会进入if判断里面执行rewrite命令。
  880. autoindex
  881. 用户请求以/结尾时，列出目录结构，可以用于快速搭建静态资源下载网站。
  882. autoindex.conf配置信息：
  884. 
  885. 1
  886. server {
  887. 2
  888.   listen 80;
  889. 3
  890.   server_name fe.lion-test.club;
  891. 4
  893. 5
  894.   location /download/ {
  895. 6
  896.     root /opt/source;
  897. 7
  899. 8
  900.     autoindex on; # 打开 autoindex，，可选参数有 on | off
  901. 9
  902.     autoindex_exact_size on; # 修改为off，以KB、MB、GB显示文件大小，默认为on，以bytes显示出⽂件的确切⼤⼩
  903. 10
  904.     autoindex_format html; # 以html的方式进行格式化，可选参数有 html | json | xml
  905. 11
  906.     autoindex_localtime off; # 显示的⽂件时间为⽂件的服务器时间。默认为off，显示的⽂件时间为GMT时间
  907. 12
  908.   }
  909. 13
  910. }
  914. 当访问fe.lion.com/download/时，会把服务器/opt/source/download/路径下的文件展示出来，如下图所示：
  915. 
  916. 
  917. 
  918. 变量
  919. Nginx提供给使用者的变量非常多，但是终究是一个完整的请求过程所产生数据，Nginx将这些数据以变量的形式提供给使用者。
  920. 下面列举些项目中常用的变量：
  922. 变量名
  923. 含义
  924. remote_addr
  925. 客户端
  926. IP
  927. 地址
  928. remote_port
  929. 客户端端口
  930. server_addr
  931. 服务端
  932. IP
  933. 地址
  934. server_port
  935. 服务端端口
  936. server_protocol
  937. 服务端协议
  938. binary_remote_addr
  939. 二进制格式的客户端
  940. IP
  941. 地址
  942. connection
  943. TCP
  944. 连接的序号，递增
  945. connection_request
  946. TCP
  947. 连接当前的请求数量
  948. uri
  949. 请求的URL，不包含参数
  950. request_uri
  951. 请求的URL，包含参数
  952. scheme
  953. 协议名，
  954. http
  955. 或
  956. https
  957. request_method
  958. 请求方法
  959. request_length
  960. 全部请求的长度，包含请求行、请求头、请求体
  961. args
  962. 全部参数字符串
  963. arg_参数名
  964. 获取特定参数值
  965. is_args
  966. URL
  967. 中是否有参数，有的话返回
  968. ?
  969. ，否则返回空
  970. query_string
  971. 与
  972. args
  973. 相同
  974. host
  975. 请求信息中的
  976. Host
  977. ，如果请求中没有
  978. Host
  979. 行，则在请求头中找，最后使用
  980. nginx
  981. 中设置的
  982. server_name
  983. 。
  984. http_user_agent
  985. 用户浏览器
  986. http_referer
  987. 从哪些链接过来的请求
  988. http_via
  989. 每经过一层代理服务器，都会添加相应的信息
  990. http_cookie
  991. 获取用户
  992. cookie
  993. request_time
  994. 处理请求已消耗的时间
  995. https
  996. 是否开启了
  997. https
  998. ，是则返回
  999. on
  1000. ，否则返回空
  1001. request_filename
  1002. 磁盘文件系统待访问文件的完整路径
  1003. document_root
  1004. 由
  1005. URI
  1006. 和
  1007. root/alias
  1008. 规则生成的文件夹路径
  1009. limit_rate
  1010. 返回响应时的速度上限值
  1012. 实例演示var.conf：
  1014. 
  1015. 1
  1016. server{
  1017. 2
  1018.  listen 8081;
  1019. 3
  1020.  server_name var.lion-test.club;
  1021. 4
  1022.  root /usr/share/nginx/html;
  1023. 5
  1024.  location / {
  1025. 6
  1026.   return 200 "
  1027. 7
  1028. remote_addr: $remote_addr
  1029. 8
  1030. remote_port: $remote_port
  1031. 9
  1032. server_addr: $server_addr
  1033. 10
  1034. server_port: $server_port
  1035. 11
  1036. server_protocol: $server_protocol
  1037. 12
  1038. binary_remote_addr: $binary_remote_addr
  1039. 13
  1040. connection: $connection
  1041. 14
  1042. uri: $uri
  1043. 15
  1044. request_uri: $request_uri
  1045. 16
  1046. scheme: $scheme
  1047. 17
  1048. request_method: $request_method
  1049. 18
  1050. request_length: $request_length
  1051. 19
  1052. args: $args
  1053. 20
  1054. arg_pid: $arg_pid
  1055. 21
  1056. is_args: $is_args
  1057. 22
  1058. query_string: $query_string
  1059. 23
  1060. host: $host
  1061. 24
  1062. http_user_agent: $http_user_agent
  1063. 25
  1064. http_referer: $http_referer
  1065. 26
  1066. http_via: $http_via
  1067. 27
  1068. request_time: $request_time
  1069. 28
  1070. https: $https
  1071. 29
  1072. request_filename: $request_filename
  1073. 30
  1074. document_root: $document_root
  1075. 31
  1076. ";
  1077. 32
  1078.  }
  1079. 33
  1080. }
  1084. 当我们访问http://var.lion-test.club:8081/test?pid=121414&cid=sadasd时，由于Nginx中写了return方法，因此chrome浏览器会默认为我们下载一个文件，下面展示的就是下载的文件内容：
  1086. 
  1087. 1
  1088. remote_addr: 27.16.220.84
  1089. 2
  1090. remote_port: 56838
  1091. 3
  1092. server_addr: 172.17.0.2
  1093. 4
  1094. server_port: 8081
  1095. 5
  1096. server_protocol: HTTP/1.1
  1097. 6
  1098. binary_remote_addr: 茉
  1099. 7
  1100. connection: 126
  1101. 8
  1102. uri: /test/
  1103. 9
  1104. request_uri: /test/?pid=121414&cid=sadasd
  1105. 10
  1106. scheme: http
  1107. 11
  1108. request_method: GET
  1109. 12
  1110. request_length: 518
  1111. 13
  1112. args: pid=121414&cid=sadasd
  1113. 14
  1114. arg_pid: 121414
  1115. 15
  1116. is_args: ?
  1117. 16
  1118. query_string: pid=121414&cid=sadasd
  1119. 17
  1120. host: var.lion-test.club
  1121. 18
  1122. http_user_agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36
  1123. 19
  1124. http_referer:
  1125. 20
  1126. http_via:
  1127. 21
  1128. request_time: 0.000
  1129. 22
  1130. https:
  1131. 23
  1132. request_filename: /usr/share/nginx/html/test/
  1133. 24
  1134. document_root: /usr/share/nginx/html
  1138. Nginx的配置还有非常多，以上只是罗列了一些常用的配置，在实际项目中还是要学会查阅文档。
  1139. Nginx 应用核心概念
  1140. 代理是在服务器和客户端之间假设的一层服务器，代理将接收客户端的请求并将它转发给服务器，然后将服务端的响应转发给客户端。
  1141. 不管是正向代理还是反向代理，实现的都是上面的功能。
  1142. 
  1143. 
  1144. 
  1145. 正向代理
  1146. 正向代理，意思是一个位于客户端和原始服务器(origin server)之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)，然后代理向原始服务器转交请求并将获得的内容返回给客户端。
  1147. 正向代理是为我们服务的，即为客户端服务的，客户端可以根据正向代理访问到它本身无法访问到的服务器资源。
  1148. 正向代理对我们是透明的，对服务端是非透明的，即服务端并不知道自己收到的是来自代理的访问还是来自真实客户端的访问。
  1149. 反向代理
  1150. ●
  1151. 反向代理*（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。
  1152. 反向代理是为服务端服务的，反向代理可以帮助服务器接收来自客户端的请求，帮助服务器做请求转发，负载均衡等。
  1153. 反向代理对服务端是透明的，对我们是非透明的，即我们并不知道自己访问的是代理服务器，而服务器知道反向代理在为他服务。
  1154. 反向代理的优势：
  1155. ●
  1156. 隐藏真实服务器；
  1157. ●
  1158. 负载均衡便于横向扩充后端动态服务；
  1159. ●
  1160. 动静分离，提升系统健壮性；
  1161. 那么“动静分离”是什么？负载均衡又是什么？
  1162. 动静分离
  1163. 动静分离是指在web服务器架构中，将静态页面与动态页面或者静态内容接口和动态内容接口分开不同系统访问的架构设计方法，进而提示整个服务的访问性和可维护性。
  1164. 
  1165. 
  1166. 
  1167. 一般来说，都需要将动态资源和静态资源分开，由于Nginx的高并发和静态资源缓存等特性，经常将静态资源部署在Nginx上。如果请求的是静态资源，直接到静态资源目录获取资源，如果是动态资源的请求，则利用反向代理的原理，把请求转发给对应后台应用去处理，从而实现动静分离。
  1168. 使用前后端分离后，可以很大程度提升静态资源的访问速度，即使动态服务不可用，静态资源的访问也不会受到影响。
  1169. 负载均衡
  1170. 一般情况下，客户端发送多个请求到服务器，服务器处理请求，其中一部分可能要操作一些资源比如数据库、静态资源等，服务器处理完毕后，再将结果返回给客户端。
  1171. 这种模式对于早期的系统来说，功能要求不复杂，且并发请求相对较少的情况下还能胜任，成本也低。随着信息数量不断增长，访问量和数据量飞速增长，以及系统业务复杂度持续增加，这种做法已无法满足要求，并发量特别大时，服务器容易崩。
  1172. 很明显这是由于服务器性能的瓶颈造成的问题，除了堆机器之外，最重要的做法就是负载均衡。
  1173. 请求爆发式增长的情况下，单个机器性能再强劲也无法满足要求了，这个时候集群的概念产生了，单个服务器解决不了的问题，可以使用多个服务器，然后将请求分发到各个服务器上，将负载分发到不同的服务器，这就是负载均衡，核心是「分摊压力」。Nginx实现负载均衡，一般来说指的是将请求转发给服务器集群。
  1174. 举个具体的例子，晚高峰乘坐地铁的时候，入站口经常会有地铁工作人员大喇叭“请走B口，B口人少车空....”，这个工作人员的作用就是负载均衡。
  1175. 
  1176. 
  1177. Nginx实现负载均衡的策略：
  1178. ●
  1179. 轮询策略：默认情况下采用的策略，将所有客户端请求轮询分配给服务端。这种策略是可以正常工作的，但是如果其中某一台服务器压力太大，出现延迟，会影响所有分配在这台服务器下的用户。
  1180. ●
  1181. 最小连接数策略：将请求优先分配给压力较小的服务器，它可以平衡每个队列的长度，并避免向压力大的服务器添加更多的请求。
  1182. ●
  1183. 最快响应时间策略：优先分配给响应时间最短的服务器。
  1184. ●
  1185. 客户端ip绑定策略：来自同一个ip的请求永远只分配一台服务器，有效解决了动态网页存在的session共享问题。
  1186. Nginx 实战配置
  1187. 在配置反向代理和负载均衡等等功能之前，有两个核心模块是我们必须要掌握的，这两个模块应该说是Nginx应用配置中的核心，它们分别是：upstream、proxy_pass。
  1188. upstream
  1189. 用于定义上游服务器（指的就是后台提供的应用服务器）的相关信息。
  1190. 
  1191. 
  1192. 
  1194. 
  1195. 1
  1196. 语法：upstream name { ...}上下文：http示例：upstream back_end_server{  server 192.168.100.33:8081}复制代码
  1199. 在upstream内可使用的指令：
  1200. ●
  1201. server定义上游服务器地址；
  1202. ●
  1203. zone定义共享内存，用于跨worker子进程；
  1204. ●
  1205. keepalive对上游服务启用长连接；
  1206. ●
  1207. keepalive_requests一个长连接最多请求HTTP的个数；
  1208. ●
  1209. keepalive_timeout空闲情形下，一个长连接的超时时长；
  1210. ●
  1211. hash哈希负载均衡算法；
  1212. ●
  1213. ip_hash依据IP进行哈希计算的负载均衡算法；
  1214. ●
  1215. least_conn最少连接数负载均衡算法；
  1216. ●
  1217. least_time最短响应时间负载均衡算法；
  1218. ●
  1219. random随机负载均衡算法；
  1220. server
  1221. 定义上游服务器地址。
  1223. 
  1224. 1
  1225. 语法：server address [parameters]
  1226. 2
  1228. 3
  1229. 上下文：upstream
  1233. parameters可选值：
  1234. ●
  1235. weight=number权重值，默认为1；
  1236. ●
  1237. max_conns=number上游服务器的最大并发连接数；
  1238. ●
  1239. fail_timeout=time服务器不可用的判定时间；
  1240. ●
  1241. max_fails=numer服务器不可用的检查次数；
  1242. ●
  1243. backup备份服务器，仅当其他服务器都不可用时才会启用；
  1244. ●
  1245. down标记服务器长期不可用，离线维护；
  1246. keepalive
  1247. 限制每个worker子进程与上游服务器空闲长连接的最大数量。
  1249. 
  1250. 1
  1251. keepalive connections;
  1252. 2
  1254. 3
  1255. 上下文：upstream
  1256. 4
  1258. 5
  1259. 示例：keepalive 16;
  1263. keepalive_requests
  1264. 单个长连接可以处理的最多HTTP请求个数。
  1266. 
  1267. 1
  1268. 语法：keepalive_requests number;
  1269. 2
  1271. 3
  1272. 默认值：keepalive_requests 100;
  1273. 4
  1275. 5
  1276. 上下文：upstream
  1280. keepalive_timeout
  1281. 空闲长连接的最长保持时间。
  1283. 
  1284. 1
  1285. 语法：keepalive_timeout time;默认值：keepalive_timeout 60s;上下文：upstream复制代码
  1288. 配置实例
  1290. 
  1291. 1
  1292. upstream back_end{
  1293. 2
  1294.  server 127.0.0.1:8081 weight=3 max_conns=1000 fail_timeout=10s max_fails=2;
  1295. 3
  1296.   keepalive 32;
  1297. 4
  1298.   keepalive_requests 50;
  1299. 5
  1300.   keepalive_timeout 30s;
  1301. 6
  1302. }
  1306. proxy_pass
  1307. 用于配置代理服务器。
  1309. 
  1310. 1
  1311. 语法：proxy_pass URL;
  1312. 2
  1314. 3
  1315. 上下文：location、if、limit_except
  1316. 4
  1318. 5
  1319. 示例：
  1320. 6
  1321. proxy_pass http://127.0.0.1:8081
  1322. 7
  1323. proxy_pass http://127.0.0.1:8081/prox
  1327. URL参数原则
  1328. 1
  1329. URL必须以http或https开头；
  1330. 2
  1331. URL中可以携带变量；
  1332. 3
  1333. URL中是否带URI，会直接影响发往上游请求的URL；
  1334. 接下来让我们来看看两种常见的URL用法：
  1335. 1
  1336. proxy_pass http://192.168.100.33:8081
  1337. 2
  1338. proxy_pass http://192.168.100.33:8081/
  1339. 这两种用法的区别就是带/和不带/，在配置代理时它们的区别可大了：
  1340. ●
  1341. 不带/意味着Nginx不会修改用户URL，而是直接透传给上游的应用服务器；
  1342. ●
  1343. 带/意味着Nginx会修改用户URL，修改方法是将location后的URL从用户URL中删除；
  1344. 不带/的用法：
  1345. location /bbs/{
  1346.   proxy_pass http://127.0.0.1:8080;
  1347. }
  1350. 分析：
  1351. 1
  1352. 用户请求URL：/bbs/abc/test.html
  1353. 2
  1354. 请求到达Nginx的URL：/bbs/abc/test.html
  1355. 3
  1356. 请求到达上游应用服务器的URL：/bbs/abc/test.html
  1357. 带/的用法：
  1358. location /bbs/{
  1359.   proxy_pass http://127.0.0.1:8080/;
  1360. }
  1363. 分析：
  1364. 1
  1365. 用户请求URL：/bbs/abc/test.html
  1366. 2
  1367. 请求到达Nginx的URL：/bbs/abc/test.html
  1368. 3
  1369. 请求到达上游应用服务器的URL：/abc/test.html
  1370. 并没有拼接上/bbs，这点和root与alias之间的区别是保持一致的。
  1371. 配置反向代理
  1372. 这里为了演示更加接近实际，作者准备了两台云服务器，它们的公网IP分别是：121.42.11.34与121.5.180.193。
  1373. 我们把121.42.11.34服务器作为上游服务器，做如下配置：
  1374. # /etc/nginx/conf.d/proxy.conf
  1375. server{
  1376.   listen 8080;
  1377.   server_name localhost;
  1379.   location /proxy/ {
  1380.     root /usr/share/nginx/html/proxy;
  1381.     index index.html;
  1382.   }
  1383. }
  1385. # /usr/share/nginx/html/proxy/index.html
  1386. <h1> 121.42.11.34 proxy html </h1>
  1389. 配置完成后重启Nginx服务器nginx -s reload。
  1390. 把121.5.180.193服务器作为代理服务器，做如下配置：
  1391. # /etc/nginx/conf.d/proxy.conf
  1392. upstream back_end {
  1393.   server 121.42.11.34:8080 weight=2 max_conns=1000 fail_timeout=10s max_fails=3;
  1394.   keepalive 32;
  1395.   keepalive_requests 80;
  1396.   keepalive_timeout 20s;
  1397. }
  1399. server {
  1400.   listen 80;
  1401.   server_name proxy.lion.club;
  1402.   location /proxy {
  1403.    proxy_pass http://back_end/proxy;
  1404.   }
  1405. }
  1408. 本地机器要访问proxy.lion.club域名，因此需要配置本地hosts，通过命令：vim /etc/hosts进入配置文件，添加如下内容：
  1409. 121.5.180.193 proxy.lion.club
  1412. 
  1413. 
  1414. 
  1415. 分析：
  1416. 1
  1417. 当访问proxy.lion.club/proxy时通过upstream的配置找到121.42.11.34:8080；
  1418. 2
  1419. 因此访问地址变为http://121.42.11.34:8080/proxy；
  1420. 3
  1421. 连接到121.42.11.34服务器，找到8080端口提供的server；
  1422. 4
  1423. 通过server找到/usr/share/nginx/html/proxy/index.html资源，最终展示出来。
  1424. 配置负载均衡
  1425. 配置负载均衡主要是要使用upstream指令。
  1426. 我们把121.42.11.34服务器作为上游服务器，做如下配置（/etc/nginx/conf.d/balance.conf）：
  1427. server{
  1428.   listen 8020;
  1429.   location / {
  1430.    return 200 'return 8020 \n';
  1431.   }
  1432. }
  1434. server{
  1435.   listen 8030;
  1436.   location / {
  1437.    return 200 'return 8030 \n';
  1438.   }
  1439. }
  1441. server{
  1442.   listen 8040;
  1443.   location / {
  1444.    return 200 'return 8040 \n';
  1445.   }
  1446. }
  1449. 配置完成后：
  1450. 1
  1451. nginx -t检测配置是否正确；
  1452. 2
  1453. nginx -s reload重启Nginx服务器；
  1454. 3
  1455. 执行ss -nlt命令查看端口是否被占用，从而判断Nginx服务是否正确启动。
  1456. 把121.5.180.193服务器作为代理服务器，做如下配置（/etc/nginx/conf.d/balance.conf）：
  1457. upstream demo_server {
  1458.   server 121.42.11.34:8020;
  1459.   server 121.42.11.34:8030;
  1460.   server 121.42.11.34:8040;
  1461. }
  1463. server {
  1464.   listen 80;
  1465.   server_name balance.lion.club;
  1467.   location /balance/ {
  1468.    proxy_pass http://demo_server;
  1469.   }
  1470. }
  1473. 配置完成后重启Nginx服务器。并且在需要访问的客户端配置好ip和域名的映射关系。
  1474. # /etc/hosts
  1476. 121.5.180.193 balance.lion.club
  1479. 在客户端机器执行curl http://balance.lion.club/balance/命令：
  1480. 
  1481. 
  1482. 
  1483. 不难看出，负载均衡的配置已经生效了，每次给我们分发的上游服务器都不一样。就是通过简单的轮询策略进行上游服务器分发。
  1484. 接下来，我们再来了解下Nginx的其它分发策略。
  1485. hash 算法
  1486. 通过制定关键字作为hash key，基于hash算法映射到特定的上游服务器中。关键字可以包含有变量、字符串。
  1487. upstream demo_server {
  1488.   hash $request_uri;
  1489.   server 121.42.11.34:8020;
  1490.   server 121.42.11.34:8030;
  1491.   server 121.42.11.34:8040;
  1492. }
  1494. server {
  1495.   listen 80;
  1496.   server_name balance.lion.club;
  1498.   location /balance/ {
  1499.    proxy_pass http://demo_server;
  1500.   }
  1501. }
  1504. hash $request_uri表示使用request_uri变量作为hash的key值，只要访问的URI保持不变，就会一直分发给同一台服务器。
  1505. ip_hash
  1506. 根据客户端的请求ip进行判断，只要ip地址不变就永远分配到同一台主机。它可以有效解决后台服务器session保持的问题。
  1507. upstream demo_server {
  1508.   ip_hash;
  1509.   server 121.42.11.34:8020;
  1510.   server 121.42.11.34:8030;
  1511.   server 121.42.11.34:8040;
  1512. }
  1514. server {
  1515.   listen 80;
  1516.   server_name balance.lion.club;
  1518.   location /balance/ {
  1519.    proxy_pass http://demo_server;
  1520.   }
  1521. }
  1524. 最少连接数算法
  1525. 各个worker子进程通过读取共享内存的数据，来获取后端服务器的信息。来挑选一台当前已建立连接数最少的服务器进行分配请求。
  1526. 语法：least_conn;
  1528. 上下文：upstream;
  1531. 示例：
  1532. upstream demo_server {
  1533.   zone test 10M; # zone可以设置共享内存空间的名字和大小
  1534.   least_conn;
  1535.   server 121.42.11.34:8020;
  1536.   server 121.42.11.34:8030;
  1537.   server 121.42.11.34:8040;
  1538. }
  1540. server {
  1541.   listen 80;
  1542.   server_name balance.lion.club;
  1544.   location /balance/ {
  1545.    proxy_pass http://demo_server;
  1546.   }
  1547. }
  1550. 最后你会发现，负载均衡的配置其实一点都不复杂。
  1551. 配置缓存
  1552. 缓存可以非常有效的提升性能，因此不论是客户端（浏览器），还是代理服务器（Nginx），乃至上游服务器都多少会涉及到缓存。可见缓存在每个环节都是非常重要的。下面让我们来学习Nginx中如何设置缓存策略。
  1553. proxy_cache
  1554. 存储一些之前被访问过、而且可能将要被再次访问的资源，使用户可以直接从代理服务器获得，从而减少上游服务器的压力，加快整个访问速度。
  1555. 语法：proxy_cache zone | off ; # zone 是共享内存的名称
  1557. 默认值：proxy_cache off;
  1559. 上下文：http、server、location
  1562. proxy_cache_path
  1563. 设置缓存文件的存放路径。
  1564. 语法：proxy_cache_path path [level=levels] ...可选参数省略，下面会详细列举
  1566. 默认值：proxy_cache_path off
  1568. 上下文：http
  1571. 参数含义：
  1572. ●
  1573. path缓存文件的存放路径；
  1574. ●
  1575. level path的目录层级；
  1576. ●
  1577. keys_zone设置共享内存；
  1578. ●
  1579. inactive在指定时间内没有被访问，缓存会被清理，默认10分钟；
  1580. proxy_cache_key
  1581. 设置缓存文件的key。
  1582. 语法：proxy_cache_key
  1584. 默认值：proxy_cache_key $scheme$proxy_host$request_uri;
  1586. 上下文：http、server、location
  1589. proxy_cache_valid
  1590. 配置什么状态码可以被缓存，以及缓存时长。
  1591. 语法：proxy_cache_valid [code...] time;
  1593. 上下文：http、server、location
  1595. 配置示例：proxy_cache_valid 200 304 2m;; # 说明对于状态为200和304的缓存文件的缓存时间是2分钟
  1598. proxy_no_cache
  1599. 定义相应保存到缓存的条件，如果字符串参数的至少一个值不为空且不等于“ 0”，则将不保存该响应到缓存。
  1600. 语法：proxy_no_cache string;
  1602. 上下文：http、server、location
  1604. 示例：proxy_no_cache $http_pragma    $http_authorization;
  1607. proxy_cache_bypass
  1608. 定义条件，在该条件下将不会从缓存中获取响应。
  1609. 语法：proxy_cache_bypass string;
  1611. 上下文：http、server、location
  1613. 示例：proxy_cache_bypass $http_pragma    $http_authorization;
  1616. upstream_cache_status 变量
  1617. 它存储了缓存是否命中的信息，会设置在响应头信息中，在调试中非常有用。
  1618. MISS: 未命中缓存
  1619. HIT： 命中缓存
  1620. EXPIRED: 缓存过期
  1621. STALE: 命中了陈旧缓存
  1622. REVALIDDATED: Nginx验证陈旧缓存依然有效
  1623. UPDATING: 内容陈旧，但正在更新
  1624. BYPASS: X响应从原始服务器获取
  1627. 配置实例
  1628. 我们把121.42.11.34服务器作为上游服务器，做如下配置（/etc/nginx/conf.d/cache.conf）：
  1629. server {
  1630.   listen 1010;
  1631.   root /usr/share/nginx/html/1010;
  1632.   location / {
  1633.    index index.html;
  1634.   }
  1635. }
  1637. server {
  1638.   listen 1020;
  1639.   root /usr/share/nginx/html/1020;
  1640.   location / {
  1641.    index index.html;
  1642.   }
  1643. }
  1646. 把121.5.180.193服务器作为代理服务器，做如下配置（/etc/nginx/conf.d/cache.conf）：
  1647. proxy_cache_path /etc/nginx/cache_temp levels=2:2 keys_zone=cache_zone:30m max_size=2g inactive=60m use_temp_path=off;
  1649. upstream cache_server{
  1650.   server 121.42.11.34:1010;
  1651.   server 121.42.11.34:1020;
  1652. }
  1654. server {
  1655.   listen 80;
  1656.   server_name cache.lion.club;
  1657.   location / {
  1658.     proxy_cache cache_zone; # 设置缓存内存，上面配置中已经定义好的
  1659.     proxy_cache_valid 200 5m; # 缓存状态为200的请求，缓存时长为5分钟
  1660.     proxy_cache_key $request_uri; # 缓存文件的key为请求的URI
  1661.     add_header Nginx-Cache-Status $upstream_cache_status # 把缓存状态设置为头部信息，响应给客户端
  1662.     proxy_pass http://cache_server; # 代理转发
  1663.   }
  1664. }
  1667. 缓存就是这样配置，我们可以在/etc/nginx/cache_temp路径下找到相应的缓存文件。
  1668. 对于一些实时性要求非常高的页面或数据来说，就不应该去设置缓存，下面来看看如何配置不缓存的内容。
  1669. ...
  1671. server {
  1672.   listen 80;
  1673.   server_name cache.lion.club;
  1674.   # URI 中后缀为 .txt 或 .text 的设置变量值为 "no cache"
  1675.   if ($request_uri ~ \.(txt|text)$) {
  1676.    set $cache_name "no cache"
  1677.   }
  1679.   location / {
  1680.     proxy_no_cache $cache_name; # 判断该变量是否有值，如果有值则不进行缓存，如果没有值则进行缓存
  1681.     proxy_cache cache_zone; # 设置缓存内存
  1682.     proxy_cache_valid 200 5m; # 缓存状态为200的请求，缓存时长为5分钟
  1683.     proxy_cache_key $request_uri; # 缓存文件的key为请求的URI
  1684.     add_header Nginx-Cache-Status $upstream_cache_status # 把缓存状态设置为头部信息，响应给客户端
  1685.     proxy_pass http://cache_server; # 代理转发
  1686.   }
  1687. }
  1690. HTTPS
  1691. 在学习如何配置HTTPS之前，我们先来简单回顾下HTTPS的工作流程是怎么样的？它是如何进行加密保证安全的？
  1692. HTTPS 工作流程
  1693. 1
  1694. 客户端（浏览器）访问https://www.baidu.com百度网站；
  1695. 2
  1696. 百度服务器返回HTTPS使用的CA证书；
  1697. 3
  1698. 浏览器验证CA证书是否为合法证书；
  1699. 4
  1700. 验证通过，证书合法，生成一串随机数并使用公钥（证书中提供的）进行加密；
  1701. 5
  1702. 发送公钥加密后的随机数给百度服务器；
  1703. 6
  1704. 百度服务器拿到密文，通过私钥进行解密，获取到随机数（公钥加密，私钥解密，反之也可以）；
  1705. 7
  1706. 百度服务器把要发送给浏览器的内容，使用随机数进行加密后传输给浏览器；
  1707. 8
  1708. 此时浏览器可以使用随机数进行解密，获取到服务器的真实传输内容；
  1709. 这就是HTTPS的基本运作原理，使用对称加密和非对称机密配合使用，保证传输内容的安全性。
  1710. 关于HTTPS更多知识，可以查看作者的另外一篇文章《学习 HTTP 协议》。
  1711. 配置证书
  1712. 下载证书的压缩文件，里面有个Nginx文件夹，把xxx.crt和xxx.key文件拷贝到服务器目录，再进行如下配置：
  1713. server {
  1714.   listen 443 ssl http2 default_server;   # SSL 访问端口号为 443
  1715.   server_name lion.club;         # 填写绑定证书的域名(我这里是随便写的)
  1716.   ssl_certificate /etc/nginx/https/lion.club_bundle.crt;   # 证书地址
  1717.   ssl_certificate_key /etc/nginx/https/lion.club.key;      # 私钥地址
  1718.   ssl_session_timeout 10m;
  1719.   ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # 支持ssl协议版本，默认为后三个，主流版本是[TLSv1.2]
  1721.   location / {
  1722.     root         /usr/share/nginx/html;
  1723.     index        index.html index.htm;
  1724.   }
  1725. }
  1728. 如此配置后就能正常访问HTTPS版的网站了。
  1729. 配置跨域 CORS
  1730. 先简单回顾下跨域究竟是怎么回事。
  1731. 跨域的定义
  1732. 同源策略限制了从同一个源加载的文档或脚本如何与来自另一个源的资源进行交互。这是一个用于隔离潜在恶意文件的重要安全机制。通常不允许不同源间的读操作。
  1733. 同源的定义
  1734. 如果两个页面的协议，端口（如果有指定）和域名都相同，则两个页面具有相同的源。
  1735. 下面给出了与 URLhttp://store.company.com/dir/page.html的源进行对比的示例:
  1736. http://store.company.com/dir2/other.html 同源
  1737. https://store.company.com/secure.html 不同源，协议不同
  1738. http://store.company.com:81/dir/etc.html 不同源，端口不同
  1739. http://news.company.com/dir/other.html 不同源，主机不同
  1742. 不同源会有如下限制：
  1743. ●
  1744. Web数据层面，同源策略限制了不同源的站点读取当前站点的Cookie、IndexDB、LocalStorage等数据。
  1745. ●
  1746. DOM层面，同源策略限制了来自不同源的JavaScript脚本对当前DOM对象读和写的操作。
  1747. ●
  1748. 网络层面，同源策略限制了通过XMLHttpRequest等方式将站点的数据发送给不同源的站点。
  1749. Nginx 解决跨域的原理
  1750. 例如：
  1751. ●
  1752. 前端server的域名为：fe.server.com
  1753. ●
  1754. 后端服务的域名为：dev.server.com
  1755. 现在我在fe.server.com对dev.server.com发起请求一定会出现跨域。
  1756. 现在我们只需要启动一个Nginx服务器，将server_name设置为fe.server.com然后设置相应的location以拦截前端需要跨域的请求，最后将请求代理回dev.server.com。如下面的配置：
  1757. server { listen      80; server_name  fe.server.com; location / {  proxy_pass dev.server.com; }}复制代码
  1759. 这样可以完美绕过浏览器的同源策略：fe.server.com访问Nginx的fe.server.com属于同源访问，而Nginx对服务端转发的请求不会触发浏览器的同源策略。
  1760. 配置开启 gzip 压缩
  1761. GZIP是规定的三种标准HTTP压缩格式之一。目前绝大多数的网站都在使用GZIP传输HTML、CSS、JavaScript等资源文件。
  1762. 对于文本文件，GZiP的效果非常明显，开启后传输所需流量大约会降至1/4~1/3。
  1763. 并不是每个浏览器都支持gzip的，如何知道客户端是否支持gzip呢，请求头中的Accept-Encoding来标识对压缩的支持。
  1764. 
  1765. 启用gzip同时需要客户端和服务端的支持，如果客户端支持gzip的解析，那么只要服务端能够返回gzip的文件就可以启用gzip了,我们可以通过Nginx的配置来让服务端支持gzip。下面的respone中content-encoding:gzip，指服务端开启了gzip的压缩方式。
  1766. 
  1767. 在/etc/nginx/conf.d/文件夹中新建配置文件gzip.conf：
  1768. # # 默认off，是否开启gzip
  1769. gzip on;
  1770. # 要采用 gzip 压缩的 MIME 文件类型，其中 text/html 被系统强制启用；
  1771. gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
  1773. # ---- 以上两个参数开启就可以支持Gzip压缩了 ---- #
  1775. # 默认 off，该模块启用后，Nginx 首先检查是否存在请求静态文件的 gz 结尾的文件，如果有则直接返回该 .gz 文件内容；
  1776. gzip_static on;
  1778. # 默认 off，nginx做为反向代理时启用，用于设置启用或禁用从代理服务器上收到相应内容 gzip 压缩；
  1779. gzip_proxied any;
  1781. # 用于在响应消息头中添加 Vary：Accept-Encoding，使代理服务器根据请求头中的 Accept-Encoding 识别是否启用 gzip 压缩；
  1782. gzip_vary on;
  1784. # gzip 压缩比，压缩级别是 1-9，1 压缩级别最低，9 最高，级别越高压缩率越大，压缩时间越长，建议 4-6；
  1785. gzip_comp_level 6;
  1787. # 获取多少内存用于缓存压缩结果，16 8k 表示以 8k*16 为单位获得；
  1788. gzip_buffers 16 8k;
  1790. # 允许压缩的页面最小字节数，页面字节数从header头中的 Content-Length 中进行获取。默认值是 0，不管页面多大都压缩。建议设置成大于 1k 的字节数，小于 1k 可能会越压越大；
  1791. # gzip_min_length 1k;
  1793. # 默认 1.1，启用 gzip 所需的 HTTP 最低版本；
  1794. gzip_http_version 1.1;
  1797. 其实也可以通过前端构建工具例如webpack、rollup等在打生产包时就做好Gzip压缩，然后放到Nginx服务器中，这样可以减少服务器的开销，加快访问速度。
  1798. 关于Nginx的实际应用就学习到这里，相信通过掌握了Nginx核心配置以及实战配置，之后再遇到什么需求，我们也能轻松应对。接下来，让我们再深入一点学习下Nginx的架构。
  1799. Nginx 架构
  1800. 进程结构
  1801. 多进程结构Nginx的进程模型图：
  1802. 
  1803. 
  1804. 
  1805. 多进程中的Nginx进程架构如下图所示，会有一个父进程（Master Process），它会有很多子进程（Child Processes）。
  1806. ●
  1807. Master Process用来管理子进程的，其本身并不真正处理用户请求。
  1808. ○
  1809. 某个子进程down掉的话，它会向Master进程发送一条消息，表明自己不可用了，此时Master进程会去新起一个子进程。
  1810. ○
  1811. 某个配置文件被修改了Master进程会去通知work进程获取新的配置信息，这也就是我们所说的热部署。
  1812. ●
  1813. 子进程间是通过共享内存的方式进行通信的。
  1814. 配置文件重载原理
  1815. reload重载配置文件的流程：
  1816. 1
  1817. 向master进程发送HUP信号（reload命令）；
  1818. 2
  1819. master进程检查配置语法是否正确；
  1820. 3
  1821. master进程打开监听端口；
  1822. 4
  1823. master进程使用新的配置文件启动新的worker子进程；
  1824. 5
  1825. master进程向老的worker子进程发送QUIT信号；
  1826. 6
  1827. 老的worker进程关闭监听句柄，处理完当前连接后关闭进程；
  1828. 7
  1829. 整个过程Nginx始终处于平稳运行中，实现了平滑升级，用户无感知；
  1830. Nginx 模块化管理机制
  1831. Nginx的内部结构是由核心部分和一系列的功能模块所组成。这样划分是为了使得每个模块的功能相对简单，便于开发，同时也便于对系统进行功能扩展。Nginx的模块是互相独立的,低耦合高内聚。
  1832. 
  1833. 
  1834. 总结
  1835. 相信通过本文的学习，你应该会对Nginx有一个更加全面的认识。
  1836. 都看到这里了，就点个👍 👍 👍 吧。
  1838. 参考 #

URL参数原则

  1. URL必须以http或https开头；
  2. URL中可以携带变量；
  3. URL中是否带URI，会直接影响发往上游请求的URL；

接下来让我们来看看两种常见的URL用法：

  1. proxy_pass http://192.168.100.33:8081
  2. proxy_pass http://192.168.100.33:8081/

这两种用法的区别就是带/和不带/，在配置代理时它们的区别可大了：

  • 不带/意味着Nginx不会修改用户URL，而是直接透传给上游的应用服务器；
  • 带/意味着Nginx会修改用户URL，修改方法是将location后的URL从用户URL中删除；

不带/的用法：
location /bbs/{
proxy_pass http://127.0.0.1:8080;
}

分析：

  1. 用户请求URL：/bbs/abc/test.html
  2. 请求到达Nginx的URL：/bbs/abc/test.html
  3. 请求到达上游应用服务器的URL：/bbs/abc/test.html

带/的用法：
location /bbs/{
proxy_pass http://127.0.0.1:8080/;
}

分析：

  1. 用户请求URL：/bbs/abc/test.html
  2. 请求到达Nginx的URL：/bbs/abc/test.html
  3. 请求到达上游应用服务器的URL：/abc/test.html

并没有拼接上/bbs，这点和root与alias之间的区别是保持一致的。

配置反向代理

这里为了演示更加接近实际，作者准备了两台云服务器，它们的公网IP分别是：121.42.11.34与121.5.180.193。
我们把121.42.11.34服务器作为上游服务器，做如下配置：
# /etc/nginx/conf.d/proxy.conf
server{
listen 8080;
server_name localhost;

location /proxy/ {
root /usr/share/nginx/html/proxy;
index index.html;
}
}

/usr/share/nginx/html/proxy/index.html

121.42.11.34 proxy html

配置完成后重启Nginx服务器nginx -s reload。
把121.5.180.193服务器作为代理服务器，做如下配置：
# /etc/nginx/conf.d/proxy.conf
upstream back_end {
server 121.42.11.34:8080 weight=2 max_conns=1000 fail_timeout=10s max_fails=3;
keepalive 32;
keepalive_requests 80;
keepalive_timeout 20s;
}

server {
listen 80;
server_name proxy.lion.club;
location /proxy {
proxy_pass http://back_end/proxy;
}
}

本地机器要访问proxy.lion.club域名，因此需要配置本地hosts，通过命令：vim /etc/hosts进入配置文件，添加如下内容：
121.5.180.193 proxy.lion.club

image.png
分析：

  1. 当访问proxy.lion.club/proxy时通过upstream的配置找到121.42.11.34:8080；
  2. 因此访问地址变为http://121.42.11.34:8080/proxy；
  3. 连接到121.42.11.34服务器，找到8080端口提供的server；
  4. 通过server找到/usr/share/nginx/html/proxy/index.html资源，最终展示出来。

    配置负载均衡

    配置负载均衡主要是要使用upstream指令。
    我们把121.42.11.34服务器作为上游服务器，做如下配置（/etc/nginx/conf.d/balance.conf）：
    server{
    listen 8020;
    location / {
    return 200 ‘return 8020 \n’;
    }
    }

server{
listen 8030;
location / {
return 200 ‘return 8030 \n’;
}
}

server{
listen 8040;
location / {
return 200 ‘return 8040 \n’;
}
}

配置完成后：

  1. nginx -t检测配置是否正确；
  2. nginx -s reload重启Nginx服务器；
  3. 执行ss -nlt命令查看端口是否被占用，从而判断Nginx服务是否正确启动。

把121.5.180.193服务器作为代理服务器，做如下配置（/etc/nginx/conf.d/balance.conf）：
upstream demo_server {
server 121.42.11.34:8020;
server 121.42.11.34:8030;
server 121.42.11.34:8040;
}

server {
listen 80;
server_name balance.lion.club;

location /balance/ {
proxy_pass http://demo_server;
}
}

配置完成后重启Nginx服务器。并且在需要访问的客户端配置好ip和域名的映射关系。
# /etc/hosts

121.5.180.193 balance.lion.club

在客户端机器执行curl http://balance.lion.club/balance/命令：
image.png
不难看出，负载均衡的配置已经生效了，每次给我们分发的上游服务器都不一样。就是通过简单的轮询策略进行上游服务器分发。
接下来，我们再来了解下Nginx的其它分发策略。

hash 算法

通过制定关键字作为hash key，基于hash算法映射到特定的上游服务器中。关键字可以包含有变量、字符串。
upstream demo_server {
hash $request_uri;
server 121.42.11.34:8020;
server 121.42.11.34:8030;
server 121.42.11.34:8040;
}

server {
listen 80;
server_name balance.lion.club;

location /balance/ {
proxy_pass http://demo_server;
}
}

hash $request_uri表示使用request_uri变量作为hash的key值，只要访问的URI保持不变，就会一直分发给同一台服务器。

ip_hash

根据客户端的请求ip进行判断，只要ip地址不变就永远分配到同一台主机。它可以有效解决后台服务器session保持的问题。
upstream demo_server {
ip_hash;
server 121.42.11.34:8020;
server 121.42.11.34:8030;
server 121.42.11.34:8040;
}

server {
listen 80;
server_name balance.lion.club;

location /balance/ {
proxy_pass http://demo_server;
}
}

最少连接数算法

各个worker子进程通过读取共享内存的数据，来获取后端服务器的信息。来挑选一台当前已建立连接数最少的服务器进行分配请求。
语法：least_conn;

上下文：upstream;

示例：
upstream demo_server {
zone test 10M; # zone可以设置共享内存空间的名字和大小
least_conn;
server 121.42.11.34:8020;
server 121.42.11.34:8030;
server 121.42.11.34:8040;
}

server {
listen 80;
server_name balance.lion.club;

location /balance/ {
proxy_pass http://demo_server;
}
}

最后你会发现，负载均衡的配置其实一点都不复杂。

配置缓存

缓存可以非常有效的提升性能，因此不论是客户端（浏览器），还是代理服务器（Nginx），乃至上游服务器都多少会涉及到缓存。可见缓存在每个环节都是非常重要的。下面让我们来学习Nginx中如何设置缓存策略。

proxy_cache

存储一些之前被访问过、而且可能将要被再次访问的资源，使用户可以直接从代理服务器获得，从而减少上游服务器的压力，加快整个访问速度。
语法：proxy_cache zone | off ; # zone 是共享内存的名称

默认值：proxy_cache off;

上下文：http、server、location

proxy_cache_path

设置缓存文件的存放路径。
语法：proxy_cache_path path [level=levels] …可选参数省略，下面会详细列举

默认值：proxy_cache_path off

上下文：http

参数含义：

  • path缓存文件的存放路径；
  • level path的目录层级；
  • keys_zone设置共享内存；
  • inactive在指定时间内没有被访问，缓存会被清理，默认10分钟；

    proxy_cache_key

    设置缓存文件的key。
    语法：proxy_cache_key

默认值：proxy_cache_key $scheme$proxy_host$request_uri;

上下文：http、server、location

proxy_cache_valid

配置什么状态码可以被缓存，以及缓存时长。
语法：proxy_cache_valid [code…] time;

上下文：http、server、location

配置示例：proxy_cache_valid 200 304 2m;; # 说明对于状态为200和304的缓存文件的缓存时间是2分钟

proxy_no_cache

定义相应保存到缓存的条件，如果字符串参数的至少一个值不为空且不等于“ 0”，则将不保存该响应到缓存。
语法：proxy_no_cache string;

上下文：http、server、location

示例：proxy_no_cache $http_pragma $http_authorization;

proxy_cache_bypass

定义条件，在该条件下将不会从缓存中获取响应。
语法：proxy_cache_bypass string;

上下文：http、server、location

示例：proxy_cache_bypass $http_pragma $http_authorization;

upstream_cache_status 变量

它存储了缓存是否命中的信息，会设置在响应头信息中，在调试中非常有用。
MISS: 未命中缓存
HIT： 命中缓存
EXPIRED: 缓存过期
STALE: 命中了陈旧缓存
REVALIDDATED: Nginx验证陈旧缓存依然有效
UPDATING: 内容陈旧，但正在更新
BYPASS: X响应从原始服务器获取

配置实例

我们把121.42.11.34服务器作为上游服务器，做如下配置（/etc/nginx/conf.d/cache.conf）：
server {
listen 1010;
root /usr/share/nginx/html/1010;
location / {
index index.html;
}
}

server {
listen 1020;
root /usr/share/nginx/html/1020;
location / {
index index.html;
}
}

把121.5.180.193服务器作为代理服务器，做如下配置（/etc/nginx/conf.d/cache.conf）：
proxy_cache_path /etc/nginx/cache_temp levels=2:2 keys_zone=cache_zone:30m max_size=2g inactive=60m use_temp_path=off;

upstream cache_server{
server 121.42.11.34:1010;
server 121.42.11.34:1020;
}

server {
listen 80;
server_name cache.lion.club;
location / {
proxy_cache cache_zone; # 设置缓存内存，上面配置中已经定义好的
proxy_cache_valid 200 5m; # 缓存状态为200的请求，缓存时长为5分钟
proxy_cache_key $request_uri; # 缓存文件的key为请求的URI
add_header Nginx-Cache-Status $upstream_cache_status # 把缓存状态设置为头部信息，响应给客户端
proxy_pass http://cache_server; # 代理转发
}
}

缓存就是这样配置，我们可以在/etc/nginx/cache_temp路径下找到相应的缓存文件。
对于一些实时性要求非常高的页面或数据来说，就不应该去设置缓存，下面来看看如何配置不缓存的内容。
…

server {
listen 80;
server_name cache.lion.club;
# URI 中后缀为 .txt 或 .text 的设置变量值为 “no cache”
if ($request_uri ~ .(txt|text)$) {
set $cache_name “no cache”
}

location / {
proxy_no_cache $cache_name; # 判断该变量是否有值，如果有值则不进行缓存，如果没有值则进行缓存
proxy_cache cache_zone; # 设置缓存内存
proxy_cache_valid 200 5m; # 缓存状态为200的请求，缓存时长为5分钟
proxy_cache_key $request_uri; # 缓存文件的key为请求的URI
add_header Nginx-Cache-Status $upstream_cache_status # 把缓存状态设置为头部信息，响应给客户端
proxy_pass http://cache_server; # 代理转发
}
}

HTTPS

在学习如何配置HTTPS之前，我们先来简单回顾下HTTPS的工作流程是怎么样的？它是如何进行加密保证安全的？

HTTPS 工作流程

  1. 客户端（浏览器）访问https://www.baidu.com百度网站；
  2. 百度服务器返回HTTPS使用的CA证书；
  3. 浏览器验证CA证书是否为合法证书；
  4. 验证通过，证书合法，生成一串随机数并使用公钥（证书中提供的）进行加密；
  5. 发送公钥加密后的随机数给百度服务器；
  6. 百度服务器拿到密文，通过私钥进行解密，获取到随机数（公钥加密，私钥解密，反之也可以）；
  7. 百度服务器把要发送给浏览器的内容，使用随机数进行加密后传输给浏览器；
  8. 此时浏览器可以使用随机数进行解密，获取到服务器的真实传输内容；

这就是HTTPS的基本运作原理，使用对称加密和非对称机密配合使用，保证传输内容的安全性。
关于HTTPS更多知识，可以查看作者的另外一篇文章《学习 HTTP 协议》。

配置证书

下载证书的压缩文件，里面有个Nginx文件夹，把xxx.crt和xxx.key文件拷贝到服务器目录，再进行如下配置：
server {
listen 443 ssl http2 default_server; # SSL 访问端口号为 443
server_name lion.club; # 填写绑定证书的域名(我这里是随便写的)
ssl_certificate /etc/nginx/https/lion.club_bundle.crt; # 证书地址
ssl_certificate_key /etc/nginx/https/lion.club.key; # 私钥地址
ssl_session_timeout 10m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # 支持ssl协议版本，默认为后三个，主流版本是[TLSv1.2]

location / {
root /usr/share/nginx/html;
index index.html index.htm;
}
}

如此配置后就能正常访问HTTPS版的网站了。

配置跨域 CORS

先简单回顾下跨域究竟是怎么回事。

跨域的定义

同源策略限制了从同一个源加载的文档或脚本如何与来自另一个源的资源进行交互。这是一个用于隔离潜在恶意文件的重要安全机制。通常不允许不同源间的读操作。

同源的定义

如果两个页面的协议，端口（如果有指定）和域名都相同，则两个页面具有相同的源。
下面给出了与 URLhttp://store.company.com/dir/page.html的源进行对比的示例:
http://store.company.com/dir2/other.html 同源
https://store.company.com/secure.html 不同源，协议不同
http://store.company.com:81/dir/etc.html 不同源，端口不同
http://news.company.com/dir/other.html 不同源，主机不同

不同源会有如下限制：

  • Web数据层面，同源策略限制了不同源的站点读取当前站点的Cookie、IndexDB、LocalStorage等数据。
  • DOM层面，同源策略限制了来自不同源的JavaScript脚本对当前DOM对象读和写的操作。

  • 网络层面，同源策略限制了通过XMLHttpRequest等方式将站点的数据发送给不同源的站点。

    Nginx 解决跨域的原理

    例如：

  • 前端server的域名为：fe.server.com

  • 后端服务的域名为：dev.server.com

现在我在fe.server.com对dev.server.com发起请求一定会出现跨域。
现在我们只需要启动一个Nginx服务器，将server_name设置为fe.server.com然后设置相应的location以拦截前端需要跨域的请求，最后将请求代理回dev.server.com。如下面的配置：
server { listen 80; server_name fe.server.com; location / { proxy_pass dev.server.com; }}复制代码

这样可以完美绕过浏览器的同源策略：fe.server.com访问Nginx的fe.server.com属于同源访问，而Nginx对服务端转发的请求不会触发浏览器的同源策略。

配置开启 gzip 压缩

GZIP是规定的三种标准HTTP压缩格式之一。目前绝大多数的网站都在使用GZIP传输HTML、CSS、JavaScript等资源文件。
对于文本文件，GZiP的效果非常明显，开启后传输所需流量大约会降至1/4~1/3。
并不是每个浏览器都支持gzip的，如何知道客户端是否支持gzip呢，请求头中的Accept-Encoding来标识对压缩的支持。image.png启用gzip同时需要客户端和服务端的支持，如果客户端支持gzip的解析，那么只要服务端能够返回gzip的文件就可以启用gzip了,我们可以通过Nginx的配置来让服务端支持gzip。下面的respone中content-encoding:gzip，指服务端开启了gzip的压缩方式。image.png在/etc/nginx/conf.d/文件夹中新建配置文件gzip.conf：
# # 默认off，是否开启gzip
gzip on;
# 要采用 gzip 压缩的 MIME 文件类型，其中 text/html 被系统强制启用；
gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

—— 以上两个参数开启就可以支持Gzip压缩了 ——

默认 off，该模块启用后，Nginx 首先检查是否存在请求静态文件的 gz 结尾的文件，如果有则直接返回该 .gz 文件内容；
gzip_static on;

默认 off，nginx做为反向代理时启用，用于设置启用或禁用从代理服务器上收到相应内容 gzip 压缩；
gzip_proxied any;

用于在响应消息头中添加 Vary：Accept-Encoding，使代理服务器根据请求头中的 Accept-Encoding 识别是否启用 gzip 压缩；
gzip_vary on;

gzip 压缩比，压缩级别是 1-9，1 压缩级别最低，9 最高，级别越高压缩率越大，压缩时间越长，建议 4-6；
gzip_comp_level 6;

获取多少内存用于缓存压缩结果，16 8k 表示以 8k*16 为单位获得；
gzip_buffers 16 8k;

允许压缩的页面最小字节数，页面字节数从header头中的 Content-Length 中进行获取。默认值是 0，不管页面多大都压缩。建议设置成大于 1k 的字节数，小于 1k 可能会越压越大；
# gzip_min_length 1k;

默认 1.1，启用 gzip 所需的 HTTP 最低版本；
gzip_http_version 1.1;

其实也可以通过前端构建工具例如webpack、rollup等在打生产包时就做好Gzip压缩，然后放到Nginx服务器中，这样可以减少服务器的开销，加快访问速度。
关于Nginx的实际应用就学习到这里，相信通过掌握了Nginx核心配置以及实战配置，之后再遇到什么需求，我们也能轻松应对。接下来，让我们再深入一点学习下Nginx的架构。

Nginx 架构

进程结构

多进程结构Nginx的进程模型图：
image.png
多进程中的Nginx进程架构如下图所示，会有一个父进程（Master Process），它会有很多子进程（Child Processes）。

  • Master Process用来管理子进程的，其本身并不真正处理用户请求。
    • 某个子进程down掉的话，它会向Master进程发送一条消息，表明自己不可用了，此时Master进程会去新起一个子进程。
    • 某个配置文件被修改了Master进程会去通知work进程获取新的配置信息，这也就是我们所说的热部署。
  • 子进程间是通过共享内存的方式进行通信的。

    配置文件重载原理

    reload重载配置文件的流程：
  1. 向master进程发送HUP信号（reload命令）；
  2. master进程检查配置语法是否正确；
  3. master进程打开监听端口；
  4. master进程使用新的配置文件启动新的worker子进程；
  5. master进程向老的worker子进程发送QUIT信号；
  6. 老的worker进程关闭监听句柄，处理完当前连接后关闭进程；
  7. 整个过程Nginx始终处于平稳运行中，实现了平滑升级，用户无感知；

    Nginx 模块化管理机制

    Nginx的内部结构是由核心部分和一系列的功能模块所组成。这样划分是为了使得每个模块的功能相对简单，便于开发，同时也便于对系统进行功能扩展。Nginx的模块是互相独立的,低耦合高内聚。nginx - 图15

    总结

    相信通过本文的学习，你应该会对Nginx有一个更加全面的认识。
    都看到这里了，就点个👍 👍 👍 吧。

参考 #