nginx ​

异常处理：
1、-bash: make: command not found
系统是mini最小化安装，缺少make、vim命令
解决：yum -y install gcc automake autoconf libtool make
2、缺少nginx.pid文件时，重新创建对应的目录 =》./nginx
3、启动时pid文件失效：./nginx -c nginx.conf所在的路径（重新指向配置文件后，重新生成pid文件）

# 向主进程发送信息，重新加载配置文件，热重启
./nginx -s reload

# 重启nginx
./nginx -s reopen

# 快速停止
./nginx -s stop

# 等待工作进程处理完成之后再关闭
./nginx -s quit

# 查看当前nginx的最终配置
./nginx -T

# 检查配置文件是否正确
./nginx -t

# 查看nginx版本号
./nginx -v

# 查看nginx版本号同时，显示安装时配置的相关参数
./nginx -V

# 查看相关命令参数
./nginx -h

# nginx的模块体系
    # nginx core核心模块，包含（http、main、event module、phase filter[请求]、upstream、load balancer[负载均衡]、extend module[继承]）

    # worker进程运行的用户。默认是nobody
    #user  nobody;
    # fork worker数量，一般配置和服务器的cpu核数一致
    worker_processes  auto;

    # nginx 日志级别：debug、info、notice、warn、error、crit
    # 在nginx安装的时候可以通过--error-log-path、--http-log-path来配置日志的存放路径
    #error_log  logs/error.log;
    #error_log  logs/error.log  notice;
    #error_log  logs/error.log  info;

    # 定义nginx进程号。可以在nginx安装的时候通过：--pid-path 配置路径
    #pid        logs/nginx.pid;


    events {
        # 操作模式。linux默认使用epoll模式，异步非阻塞
        use epoll;
        # 一个worker进程允许客户端最大连接数
        worker_connections  1024;
    }


    http {
        # 包含。即：导入一个外包的文件
        include       mime.types;
        # 默认的type类型
        default_type  application/octet-stream;

        # 日志格式化输出到指定文件
        # $remote_addr（客户端IP地址）
        # $remote_user（客户端用户名称）
        # $time_local（时间）
        # $request（请求的一些相关信息：请求内容、方法）
        # $status（请求状态）
        # $body_bytes_sent（相应客户端的body字节数）
        # $http_refere（来源地址，即：地方跳转访问）
        # $http_user_agent（用户代理：一般指浏览器）
        # $http_x_forwarded_for（客户端的IP地址）
        #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  logs/access.log  main;

        # 用于文件的高效传输的
        sendfile        on;
        # 只有sendfile值为on才起作用、发送的文件累计到一定大小再进行发送；减少网络报文段的数量
        #tcp_nopush     on;
        #tcp_nodelay    on;

        # 客户端连接服务器的超时时间，秒为单位。访问结束之后，连接存活的时间，如果在此期间还有访问直接使用此连接，不需要再次创建连接
        # 值为0时，代表访问结束后就关闭连接
        #keepalive_timeout  0;
        keepalive_timeout  65;

        # 经过压缩后传输。压缩后体积小、传输快、节约带宽，但是在压缩时需要耗费性能
        #gzip  on;
        # 限制最小压缩，小于1字节文件不会压缩
        g_zip_min_length 1;
        # 定义压缩级别（压缩比，文件大，压缩越多，但是cpu使用会越多）
        g_zip_comp_level 3;
        # 定义压缩文件的类型
        gzip_types text/plain application/javascript text/css;

        # 负载均衡 默认轮询方式
        # weight 负载均衡服务器的权重，权重值越大越容易命中
        # max_conns 服务器最大连接数，默认值为0,则表示没有限制；可以做限流作用，避免服务器过载
        # slow_start 设置权重值在指定的时间内由0慢慢增加到权重的指定值；随机轮询的负载、hash、单机的不支持；（开源版本不支持、只能在商业版本中使用）
        # down 标识服务器状态为不可用
        # backup 标记服务器为备用机，在负载均衡的服务器请求不到后端服务时，启用；例如：当192.168.1.11与192.168.1.5 对应后端的服务宕机，192.168.1.10 就会启用
        # max_fails 最大失败数，默认值：1。fial_timeout 失败的指定时间段，默认值：10s。
        #   在fial_timeout指定的时间段内，当失败数达到max_fails指定数，nginx就会认为指定的服务器已经宕机; 
        #   在fial_timeout的指定时间段内nginx就不会再分发到此服务器上，当过了这时间段，nginx会尝试继续分发到执行服务器, 如果还是失败，重复以上过程
        upstream tomcats {
            # 可以保证用户访问可以请求到上游服务中的固定服务器，前提是客户端用户IP没有发生更改
            # 但是当某一个用户短时间内发起大量请求，易导致指定上游服务器宕机
            # 当上游服务器宕机时，不能把执行上游服务器的nginx-server关闭，应该使用down标记，使用户不能继续访问指定的服务
            # 当有一台被标记为down时，hash的node_counts总数就会变更，hash算法根据node_counts求值，这会导致大部分的用户连接到的上游服务都会变更
            # 以上使用hash算法，当增加或者减少节点服务时，会导致大部分用户对应上游服务器变更使得session会话消失，所以可以使用一致性hash算法来减少此缺点。只能减少大部分用户的变更问题，还是有少数的用户受影响
            ip_hash;

            server 192.168.1.5 weight=1 max_conns=2 slow_start=60s down;
            server 192.168.1.10 weight=2 max_conns=2 backup;
            server 192.168.1.11 weight=5 max_conns=5 max_fails=2 fail_timeout=15s;

            # 设置长连接数量。即：有指定数的连接不会呗释放，处于长连接状态，可以提高服务器的吞吐量
            # 在指定的server块加上以下两项配置：长连接的版本号、清楚connection_header信息
            # proxy_http_version 1.1;
            # proxy_set_hdeader Connection "";
            keepalived 32;
        }

        upstream tomcats1 {
            # 使用url进行hash算法，$request_uri是内置的一个变量，获取的是url值
            hash $request_uri;
        }

        upstream tomcats2 {
            # 选择最少连接数的节点，进行负载
            least_conn;
        }


        # proxy_cache_path 设置缓存保存的目录（/usr/nginx/upstream_cache）
        #       设置共享内存共享以及占用的空间大小（keys_zone） 
        #       nginxCache名称、5m开辟时初始大小、1g最大的空间值
        #       inactive 超过此时间，缓存则自动清理
        #       use_temp_path关闭临时目录
        proxy_cache_path /usr/nginx/upstream_cache keys_zone=nginxCache:5m max_size=1g inactive=1h use_temp_path=off



        server {
            listen 88;
            server_name tomcat;

            location ^~ /tomcat {
                proxy_pass http://tomcats;

                proxy_http_version 1.1;
                proxy_set_hdeader Connection "";

                # 设置缓存的过期时间（控制对浏览器的缓存）
                # 指定具体时间
                # expires 10s;
                # 以天为节点，到达指定时间时缓存会过期
                # expires @22h33m;
                # 缓存提前过期，即代表不需要缓存
                # expires -1h;
                # 不设置缓存。no-cache
                # expires epoch;
                # 默认的浏览器的缓存机制
                # expires off;
                # 缓存永不过期
                expires max;

                # 设置缓存的过期时间（控制对上游服务器的缓存）
                # 开启并使用指定名称的缓存
                proxy_cache nginxCache;
                # 针对200和304状态码缓存时间为8小时
                proxy_cache_valid 200 304 8h;


            }
        }

        # 虚拟主机
        server {
            listen       80;
            server_name  localhost;

            #charset koi8-r;

            #access_log  logs/host.access.log  main;

            # 允许跨域请求的域，*代表所有
            add_header 'Access-Control-Allow-Origin' *;
            # 允许带上cookie请求
            add_header 'Access-Control-Allow-Credentials' 'true';
            # 允许请求的方法，比如：GET/POST/PUT/DELETE
            add_header 'Access-Control-Allow-Methods' *;
            # 允许请求的header
            add_header 'Access-Control-Allow-Headers' *;

            # 对源站点验证
            valid_referers *.huangjiliang.com;
            # 非法引用会进入下方判断  增加了如下判断，以上的跨域请求也会相对的失效
            if ($valid_referers) {
                return 403;
            }

            location / {
                root   html;
                index  index.html index.htm;
                deny 192.168.1.138; # 禁止访问的IP地址，可以为all
                allow 192.168.1.140; # 允许访问的IP地址，可以为all
            }

            #error_page  404              /404.html;

            # redirect server error pages to the static page /50x.html
            #
            error_page   500 502 503 504  /50x.html;
            location = /50x.html {
                root   html;
            }

            # proxy the PHP scripts to Apache listening on 127.0.0.1:80
            #
            #location ~ \.php$ {
            #    proxy_pass   http://127.0.0.1;
            #}

            # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
            #
            #location ~ \.php$ {
            #    root           html;
            #    fastcgi_pass   127.0.0.1:9000;
            #    fastcgi_index  index.php;
            #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
            #    include        fastcgi_params;
            #}

            # deny access to .htaccess files, if Apache's document root
            # concurs with nginx's one
            #
            #location ~ /\.ht {
            #    deny  all;
            #}
        }


        # another virtual host using mix of IP-, name-, and port-based configuration
        #
        #server {
        #    listen       8000;
        #    listen       somename:8080;
        #    server_name  somename  alias  another.alias;

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


        # HTTPS server
        #
        #server {
        #    listen       443 ssl;
        #    server_name  localhost;

        # 开启ssl
        # ssl on;
        # 配置ssl证书  存放证书路径文件
        # ssl_certificate 1_www.imoocdsp.com_bundle.crt;
        # 配置证书秘钥  存放密钥文件
        # ssl_certificate_key 2_www.imoocdsp.com.key;
        # ssl会话cache 
        # ssl_session_cache shared:SSL:1m;
        # ssl会话超时时间
        # ssl_session_timeout 5m;
        # 配置加密套件，写法遵循 openssl 标准
        # ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        # ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
        # ssl_prefer_server_ciphers on;

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

    }

user USERNAME [GROUP]
例：用户是nginx，组是lion
user nginx lion;

pid /home/nginx/logs/nginx.pid; # 指定master主进程的pid文件存放的路径

worker_rlimit_nofile 20480;

# 存放大小限制
worker_rlimit_core 50M;
# 存放的目录
working_directory /home/nginx/temp;

# 指定具体子进程数量
worker_processes_number 4;
# 与房前cpu物理核心数一致
worker_processes auto;

# 4个物理核心，4个worker子进程
worker_cpu_affinity 0001 0010 0100 1000;

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

worker_shutdown_timeout 5s;

timer_resolution 100ms;

# 默认时on，后台运行模式
daemon off;

# 不推荐配置此项，可以让nginx自己选择
use method;

# method的可选值：select、poll、kqueue、epoll、/dev/poll、eventport

# 每个子进程最大连接数为1024
worker_connections 1024;

# 默认是off关闭的，推荐打开
accept_mutex on;

server_name name1 name2 name3

# 示例
server_name www.huangjiliang.com

root <path>
# 示例
location /image {
	root /home/opt/static;
}
# 当用户访问 www.huangjiliang.com/image/1.png时，实际在服务器找的路径是 /home/nginx/static/image/1.png

location /image {
	alias /home/nginx/static/image/
}
# 当用户访问www.huangjiliang.com/image/1.png时，实际在服务器找的路径是：/home/nginx/static/image/1.png

location [ = | ~ | ^~ ] uri {
	...
}

# 示例1 ##############

location = / {
  # 精确匹配 / ，主机名后面不能带任何字符串
  [ configuration A ]
}
 
location / {
  # 因为所有的地址都以 / 开头，所以这条规则将匹配到所有请求
  # 但是正则和最长字符串会优先匹配
  [ configuration B ]
}
 
location /documents/ {
  # 匹配任何以 /documents/ 开头的地址，匹配符合以后，还要继续往下搜索
  # 只有后面的正则表达式没有匹配到时，这一条才会采用这一条
  [ configuration C ]
}
 
location ~ /documents/Abc {
  # 匹配任何以 /documents/ 开头的地址，匹配符合以后，还要继续往下搜索
  # 只有后面的正则表达式没有匹配到时，这一条才会采用这一条
  [ configuration CC ]
}
 
location ^~ /images/ {
  # 匹配任何以 /images/ 开头的地址，匹配符合以后，停止往下搜索正则，采用这一条。
  [ configuration D ]
}
 
location ~* \.(gif|jpg|jpeg)$ {
  # 匹配所有以 gif,jpg或jpeg 结尾的请求
  # 然而，所有请求 /images/ 下的图片会被 config D 处理，因为 ^~ 到达不了这一条正则
  [ configuration E ]
}
 
location /images/ {
  # 字符匹配到 /images/，继续往下，会发现 ^~ 存在
  [ configuration F ]
}
 
location /images/abc {
  # 最长字符匹配到 /images/abc，继续往下，会发现 ^~ 存在
  # F与G的放置顺序是没有关系的
  [ configuration G ]
}
 
location ~ /images/abc/ {
  # 只有去掉 config D 才有效：先最长匹配 config G 开头的地址，继续往下搜索，匹配到这一条正则，采用
    [ configuration H ]
}
 
location ~* /js/.*/\.js

# 示例2
server {
	listen 80;
	server_name wwww.huangjiliang.com;
	
	# 精准匹配
	# 只有访问www.huangjiliang.com/,atch_all/ 时才会匹配到/home/nginx/html/index.html
	location = /match_all/ {
		root /home/nginx/html;
		index index.html;
	}
	
	# 正则匹配【区分大小写】
	# 当访问www.huangjiliang.com/1.jpg 【uri以（.jpeg、.jpg、.png、.svg）结尾路径时】会去/home/nginx/images找相应的文件资源
	location ~ \.(jpeg|jpg|png|svg)$ {
		root /home/nginx/images;
	}
	
	# 匹配命中后，即停止搜索
	# 当访问www.huangjiliang.com/bbs/时会匹配上/home/nginx/html/bolg.html
	location ^~ /bbs/ {
		root /home/nginx/html;
		index blog.html;
	}
}

# 情况1
location /html {
	...
}
# 情况2
location /html/ {
	...
}

return code [text];

return code URL;

return URL;

# 示例

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

# 返回状态码 + 一段文本
location / {
	return 500 + "server error";
}

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

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

语法：rewrite 正则表达式 要替换的内容 [flag];

上下文：server、location、if

# $1是前面括号(.*\.jpg)的反向引用
示例：rewrite /images/(.*\.jpg)$ /pic/$1;

server {
	listen 80;
	server_name elang.vip;
	root html;
	location /search {
		# 重定向
		rewrite ^/(.*) http://www.huangjiliang.com redirect;
	}
	
	location /images {
		rewrite /images/(.*) /pics/$1
	}
	
	location /pics {
		rewrite /pics/(.*) /photos/$1;
	}
	
	location /photos {
		
	}
}

语法：
if (condition) {...}

上下文：server、location

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

server {
	listen 8080;
	server_name location;
	root html;
	location / {
		# 当访问http://127.0.0.1:8080/images/时，会通过if判断，然后执行rewrite重写命令
		if ($uri = '/images/') {
			rewrite (.*) /pics/ break;
		}
	}
}

server {
	listen 80;
	server_name elang.vip;
	location /download/ {
		root /home/source;
		# 打开autoindex，可选参数on | off
		autoindex on;
		# 修改为off，以KB、MB、GB显示文件大小，默认为on，以bytes显示出文件的确切大小
		autoindex_exact_size on;
		# 以html的方式进行格式化，可选参数 html | json |xml
		autoindex_format html;
		# 显示的文件时间为文件的服务器时间，默认为off，显示的文件时间为GMT时间
		autoindex_localtime off;
	}
}

server {
    listen 8081;
    server_name localhost;
    root html;
    index  index.html index.htm;
    location / {
        return 200 "
            remote_addr: $remote_addr
            remote_port: $remote_port
            server_addr: $server_addr
            server_port: $server_port
            server_protocol: $server_protocol
            binary_remote_addr: $binary_remote_addr
            connection: $connection
            uri: $uri
            request_uri: $request_uri
            scheme: $scheme
            request_method: $request_method
            request_length: $request_length
            args: $args
            arg_pid: $arg_pid
            is_args: $is_args
            query_string: $query_string
            host: $host
            http_user_agent: $http_user_agent
            http_referer: $http_referer
            http_via: $http_via
            request_time: $request_time
            https: $https
            request_filename: $request_filename
            document_root: $document_root
            ";
    }
}

upstream blog_server {
	# 定义共享内存，并设置共享内存空间的名字和大小
	zone test 10M;
	# 使用最少连接数负载均衡算法
	least_conn;
	# 定义3台后端应用程序进行轮询
	server 192.168.1.2:8081;
	server 192.168.1.2:8082;
	server 192.168.1.2:8083;
}

server {
	listen 80;
	server_name elang.vip;
	location /blog/ {
		proxy_pass http://blog_server;
	}
}

# 语法：
upstream name {
	...
}

# 上下文：
http

# 示例
upstream blog_server {
	server 192.168.1.138:8080
}

# 语法：
server address [parameters]

# 上下文：upstream

# 语法
keepalive connections;

# 上下文：upstream

# 示例
keepalive 16;

# 语法：
keepalive_requests number;

# 默认值：
keepalive_requests 100;

# 上下文：
upstream

# 语法：
keepalive_timeout time;

# 默认值：
keepalive_timeout 100s;

# 上下文：
upstream

# 语法
proxy_pass URL;

# 上下文：
location、if、limit_except

# 示例1
server {
	...
	location / {
		proxy_pass http://127.0.0.1:8081
	}
}
# 示例2
server {
	...
	location /proxy/ {
		proxy_pass http://127.0.0.1:8081/proxy
	}
}
# 示例3
server {
	...
	location /proxy/ {
		proxy_pass http://127.0.0.1:8081/proxy/
	}
}

语法：proxy_cache zone | off; # zone是共享内存的名称

默认值：proxy_cache off;

上下文：http、server、location

语法：proxy_cache_path path [level=levels]

默认值：proxy_chache_path off;

上下文：http

语法：proxy_cache_key

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

上下文：http、server、location

语法：proxy_cache_valid [code ...] time;

上下文：http、server、location

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

语法：proxy_no_cache string

上下文：http、server、location

示例：proxy_no_cache $http_pragma $http_authorization;

语法：proxy_cache_bypass string

上下文：http、server、location

示例：proxy_cache_bypass $http_pragma $http_authorization;

MISS：未命中缓存
HIT：命中缓存
EXPIRED：缓存过期
STALE：命中了陈旧缓存
REVALIDDATED：nginx验证陈旧缓存依然有效
UPDATING：内容陈旧，但正在更新
BYPASS：响应从原始服务器获取

server {
  listen 80;
  server_name www.huangjiliang.com;
  # 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; # 代理转发
  }
}

server {
        listen 443 ssl; 
        server_name test.huangjiliang.com;
        ssl_certificate test.huangjiliang.com_nginx/test.huangjiliang.com_bundle.crt;
        ssl_certificate_key test.huangjiliang.com_nginx/test.huangjiliang.com.key;
        ssl_session_timeout 5m;
        ssl_protocols TLSv1.2 TLSv1.3; 
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE; 
        ssl_prefer_server_ciphers on;
        location / {
            proxy_pass http://127.0.0.1:4037;
        }
    }

server {
	listen 80;
	server_name www.huangjiliang.com;
	location / {
		proxy_pass www.huangjiliang.com:8081;
	}
}

# # 默认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;

语法：client_max_body_size number;

示例1：
...
http {
	client_max_body_size 10M; # nginx默认上传大小限制是1M
	server {
		....
	}
}

示例2：
...
http {
	...
	server {
		client_max_body_size 10M; # nginx默认上传大小限制是1M
	}
}

上下文：http、server

[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/nginx/sbin/nginx -t
ExecStart=/usr/nginx/sbin/nginx
ExecReload=/usr/nginx/sbin/nginx -s reload
ExecStop=/usr/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

# 开机配置
systemctl enable nginx # 开机自动启动
systemctl disable nginx # 关闭开机自动启动

# 启动nginx
systemctl start nginx

# 停止nginx
systemctl stop nginx

# 重启nginx
systemctl restart nginx

# 重新加载nginx
systemctl reload nginx

# 查看nginx运行状态
systemctl status nginx

1、问题描述：修改配置文件后，执行systemctl stop nginx报错
异常错误提示：Stopping nginx (via systemctl):  Warning: nginx.service changed on disk. Run 'systemctl daemon-reload' to reload units.
解决方案：systemctl daemon-reload
2、问题描述：找不到PID文件
原因：找不到pid文件，因为没有相应的目录
解决方案：mkdir /var/run/nginx -p   或者  修改nginx.conf文件夹指定pid文件路径

语法：client_header_timeout time;

默认值：client_header_time 60s;

上下文：http、server、location

语法：keepalive_timeout timeout [header_timeout];

默认值：keepalive_timeout 75s;

上下文：http、server、location

语法：lingering_timeout time;

默认值：lingering_timeout 5s;

上下文：http、server、location

语法：resolver_timeout time;

默认值：resolver_timeout 30s;

上下文：http、server、location

语法：proxy_connect_timeout time;

默认值：proxy_connect_timeout 60s;

上下文：http、server、location

语法：proxy_read_timeout time;

默认值：resolver_timeout 60s;

上下文：http、server、location

语法：proxy_send_timeout time;

默认值：proxy_send_timeout 60s;

上下文：http、server、location

语法：server address [fail_timeout=30s]

默认值：10s;

上下文：upstream

1、location末尾加斜杠
location /api/ {
  proxy_pass http://127.0.0.1:8848;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance

2、location末尾不加斜杠
location /api {
  proxy_pass http://127.0.0.1:8848;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance

1、location末尾加斜杠
location /api/ {
  proxy_pass http://127.0.0.1:8848/;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848/nacos/v1/ns/instance

2、location末尾不加斜杠
location /api {
  proxy_pass http://127.0.0.1:8848/;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848//nacos/v1/ns/instance

1、location末尾加斜杠
location /api/ {
  proxy_pass http://127.0.0.1:8848/nacos;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848/nacosnacos/v1/ns/instance

2、location末尾不加斜杠
location /api {
  proxy_pass http://127.0.0.1:8848/nacos;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848/nacos/nacos/v1/ns/instance

1、location末尾加斜杠
location /api/ {
  proxy_pass http://127.0.0.1:8848/nacos/;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848/nacos/nacos/v1/ns/instance

2、location末尾不加斜杠
location /api {
  proxy_pass http://127.0.0.1:8848/nacos/;
  proxy_set_header Host $http_host; 
  proxy_set_header X-Real-IP $remote_addr; 
}
请求地址：http://127.0.0.1:8848/api/nacos/v1/ns/instance
代理地址：http://127.0.0.1:8848/nacos//nacos/v1/ns/instance

location /api {
	rewrite ^/api/(.*)$ /$1 break;
	proxy_pass http://192.168.26.130:9981;
}

// 将接口路径前的/api去除

# 访问路径在：/data/index.html
location / {
	root   /data;
	index  index.html index.htm;
}
# 访问路径在：/data/aa/bb/index.html
location /aa/bb {
	root   /data;
	index  index.html index.htm;
}

1、路由文件配置
export default new Router({
  // mode: 'hash',
  mode: 'history',
  base: '/szxc/',
  scrollBehavior: () => ({ y: 0 }),
  routes: constantRouterMap
});
==》主要：
mode: 'history',
base：base: '/szxc/',

2、vue.config.js配置
publicPath: '/szxc/',

3、nginx配置
# 访问=》 [域名+/szxc]
location /szxc {
	# 静态文件目录
	alias   /data/szxc/web/szxc/;
	try_files $uri $uri/ /szxc/index.html;
	index  index.html index.htm;
}

server {
  listen 80;
  server_name demo.com;
  rewrite ^(.*)$ https://$server_name$1 permanent;
}

#直接返回状态码
location / { 
   return 404;
}
#返回状态码 + 一段文本
location / { 
   return 404 "pages not found"; 
}
#返回状态码 + 重定向地址
location / { 
   return 302 /blog ; 
}
#返回重定向地址
location / { 
   return https://www.test.com ; 
}