/usr/local/nginx/
├── client_body_temp
├── conf 					# 配置文件目录
│   ├── fastcgi.conf		# fastcgi 配置文件
│   ├── fastcgi.conf.default
│   ├── fastcgi_params
│   ├── fastcgi_params.default
│   ├── koi-utf
│   ├── koi-win
│   ├── mime.types
│   ├── mime.types.default
│   ├── nginx.conf
│   ├── nginx.conf.default
│   ├── scgi_params
│   ├── scgi_params.default
│   ├── uwsgi_params
│   ├── uwsgi_params.default
│   └── win-utf
├── fastcgi_temp
├── html
│   ├── 50x.html
│   └── index.html
├── logs
│   ├── access.log
│   ├── error.log
│   └── nginx.pid	# nginx的process id
├── proxy_temp
│   ├── 1
│   │   └── 00
│   ├── 2
│   │   └── 00
│   ├── 3
│   │   └── 00
│   ├── 4
│   │   └── 00
│   ├── 5
│   │   └── 00
│   └── 6
│       └── 00
├── sbin
│   └── nginx
├── scgi_temp
├── ssl
│   ├── 9584217_www.radsm.co.key
│   ├── 9584217_www.radsm.co_nginx.zip
│   ├── 9584217_www.radsm.co.pem
│   ├── nginx.crt
│   └── nginx.key
└── uwsgi_temp

# vim /usr/local/nginx/conf/nginx.conf
worker_processes  1;

# 全局块

events {
    # events块 配置网络连接相关内容
    worker_connections  1024;
}

# 全局块

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

    server {
        # server块，配置虚拟主机等功能，一个http可以由多个server块
        listen       80;
        server_name  localhost;
        location / {
            # location块，匹配到路径，取出资源，展示给用户
            root   html;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }

}

| 语法   | user user [group] |
| ------ | ----------------- |
| 默认值 | nobody            |
| 位置   | 全局块            |

user www;
# 默认为nobody
# 如果user 的值是普通用户，那么root /root/html 会产生403的错误

master_process on|off; # 是否开启工作进程，default on

worker_process num|auto; # 建议设置的和服务器cpu内核个数保持一致，生成工作进程的数量

daemon on|off  # 是否以守护进程启动，default on

pid /usr/local/nginx/logs # nginx.pid位置

error_log /usr/local/nginx/logs/ error # error_logs  可以配置在全局，http，server，location

# 其中日志级别的值有：debug|info|notice|warn|error|crit|alert|emerg，这块建议大家设置的时候不要设置成info以下的等级，因为会带来大量的磁盘I/O消耗，影响Nginx的性能。

include /usr/local/nginx/conf/aaa.conf  # 引入其他配置，可以在任何位置配置

默认值accept_mutex on;
accept_mutex on;   # 解决惊群，用来设置nginx网络链接序列化，一个个唤醒worker  将会对多个Nginx进程接收连接进行序列号，一个个来唤醒接收，就防止了多个进程对连接的争抢。

默认值multi_accept off;
multi_accept on;  # 是否允许同时接受多个网络链接
如果multi_accept被禁止了，nginx一个工作进程只能同时接受一个新的连接。否则，一个工作进程可以同时接受所有的新连接


worker_connections 512;  # 单个worker进程最大连接数，number值不能大于操作系统支持打开的最大文件句柄数量。

use epoll|select|poll|kqueue; 		# 来设置Nginx服务器选择哪种事件驱动来处理网络消息。建议epoll

events {
    accept_mutex on;
    multi_accept on;
    use epoll;
    worker_connections 1024;
}

# mime-type Nginx作为web服务器，也需要能够识别前端请求的资源类型。
Nginx的配置文件中，默认有两行配置
include mime.types;
default_type application/octet-stream;   # http,server,location 可以配置，默认二进制流，浏览器会下载文件

| 语法   | default_type mime-type;   |
| ------ | ------------------------- |
| 默认值 | default_type text/plain； |


location /get_text {
    default_type text/html;
    return 200 "<h1>shabi</h1>";
}

sendfile on;  # 配置位置 http,server,location

keepalive_timeout  75  # 长连接超时协议

keepalive_requests 100 # 长连接处理请求个数

access_log /usr/local/nginx/logs hahaha;   # http，server，location块配置
log_format hahaha 'fomat: $http_user_agent';

sendfile:用来设置Nginx服务器是否使用sendfile()传输文件，该属性可以大大提高Nginx处理静态资源的性能
默认值sendfile off;
位置http、server、location

# 使用keepalive模式，可以告诉服务器端在处理完一个请求后保持这个TCP连接的打开状态，若接收到来自这个客户端的其他请求，服务端就会利用这个未被关闭的连接，而不需要重新创建一个新连接，提升效率，但是这个连接也不能一直保持，这样的话，连接如果过多，也会是服务端的性能下降，这个时候就需要我们进行设置其的超时时间。
keepalive_timeout:用来设置长连接的超时时间。
默认值keepalive_timeout 75s;
位置http、server、location

keepalive_requests:用来设置一个keep-alive连接使用的次数。
默认值keepalive_requests 100;
位置http、server、location

server {
       listen       80;
       server_name  localhost;
       location / {
           root   html;
           index  index.html index.htm;
       }
      
       error_page   500 502 503 504 404  /50x.html;
       location = /50x.html {
           root   html;
       }
   }

# /home/www/conf.d/haha1.conf
	server {
        listen       8081;
        server_name  localhost;
	    access_log /usr/local/nginx/logs main1;
        location server1/location1 {
            root   /home/www/myweb;
            index  index_sr1_location1.html index_sr1_location1.htm;
        }
        location server1/location2 {
            root   /home/www/myweb;
            index  index_sr1_location2.html index_sr1_location2.htm;
        }
       
        error_page   500 502 503 504 404  /50x.html;
        location = /50x.html {
            root   /home/www/myweb;
        	index 404.html;
        }
    }

# /home/www/conf.d/haha2.conf    
    server {
        listen       8082;
        server_name  localhost;
        access_log /usr/local/nginx/logs main2;
        location server2/location2 {
            root   html;
            index  index_sr2_location2.html index_sr2_location2.htm;
        }

        error_page   500 502 503 504 404  /50x.html;
        location = /50x.html {
            root   /home/www/myweb;
        	index 404.html;
        }
	}

worker_processes  1;
user www;
error_log logs/error.log;
pid logs/nginx.pid;
daemon on;

events {
    accept_mutex on;
    multi_accept on;
    use epoll;
    worker_connections 1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;

    keepalive_timeout  65;
    keepalive_requests 100;
    
	log_format  main1  	'$remote_addr - $remote_user [$time_local] "$request" '
                       	'$status $body_bytes_sent "$http_referer" '
                       	'"$http_user_agent" "$http_x_forwarded_for"';
    
    log_format  main2  	'$remote_addr - $remote_user [$time_local] "$request" '
                   		'$status $body_bytes_sent "$http_referer" '
                   		'"$http_user_agent" "$http_x_forwarded_for"';



    resolver 8.8.8.8;

	include /home/www/conf.d/*.conf;

}

server {
       listen       80;
       server_name  localhost;  # 域名或主机名

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

       #error_page  404              /404.html;

       error_page   500 502 503 504  /50x.html;
       location = /50x.html {
           root   html;
       }
   }
server {
       listen       88;
       server_name  a.com;  # 域名或主机名

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

       #error_page  404              /404.html;

       error_page   500 502 503 504  /50x.html;
       location = /50x.html {
           root   html;
       }
   }

默认值listen *:80 | *:8000
位置server
listen *:80;
listen 8080;    # server 下配置  监听指定端口上的连接
listen 127.0.0.1:8000;
listen 127.0.0.1; # 监听指定IP的所有端口

-------------------------------------------------

# default_server属性是标识符，用来将此虚拟主机设置成默认主机。所谓的默认主机指的是如果没有匹配到对应的address:port，则会默认执行的。如果不指定默认使用的是第一个server。
如果没有匹配成功，使用第一个server响应请求
比如server_name 写的127.0.0.1，但是访问192.168.1.12，会匹配第一个server

如果配置了default_server ,会使用default_server 所在的server响应
listen 8080 default_server;

-------------------------------------------------

server_name 
默认值server_name  "";
位置server

配置方式1:精确配置
server_name www.baidu.com baidu.com;
如果你没有域名，你就要改hosts啦
匹配方式2:通配符匹配
server_name *.baidu.com;
*不能放在域名中间 ，比如 server_name www.*.com;
*不能在最后，比如 www.baidu.c*
匹配方式三：正则匹配
server_name ~^www\.(\w+)\.com$;
location / {
    default_type text/plain;
    return 200 '====$1';
    # ~后不能有空格
}
# 三种匹配方式都存在，且都能匹配，那么精确匹配 > 前置通配符 > 后置通配符 > 正则匹配 > default_server 

# location 用来设置请求的URI
位置server,location
1.不带任何符号
server {
    location /abc {
        # /abc /abcdef /abc/ /abc?tom=1  都可以被匹配到
        default_type text/plain;
        return 200 'success';
    }
    location = /abc {
        # 精确匹配 /abc /abc?tom=1 
        # 不能匹配 /abc/ /abcde
    }
    location ~^/abc\w$ {
        # abc_ 区分大小写
    }
    # ~ ： 用于表示当前uri中包含了正则表达式，并且区分大小写
	# ~*:  用于表示当前uri中包含了正则表达式，并且不区分大小写
    
    location ~*^/abc\w$ {
        # abc_ 不区分大小写 
    }
    # ^~: 用于不包含正则表达式的uri前，功能和不加符号的一致，唯一不同的是，如果模式匹配，那么就停止搜索其他模式了。
    location ^~/abcd {
        # 非贪婪
        # 不加^ 贪婪匹配
    }
}

# root  path为Nginx服务器接收到请求以后查找资源的根目录路径。
默认值root html;
位置http、server、location
# alias：用来更改location的URI
位置location

/usr/local/nginx/html/images/1.jpg
location /images {
    root html; # root处理结果 root路径+location
    alias html/images; #alias处理结果 直接使用Alisa路径替换location路径，如果location以/结尾,那么alias也要以/结尾
}

# 在`/usr/local/nginx/html`目录下创建一个 images目录,并在目录下放入一张图片mv.png图片
location /images {
	root /usr/local/nginx/html;
}
location /images {
	alias /usr/local/nginx/html/images/;
}
# 访问 http://192.168.200.133/images/mv.png 时，上述效果相同

# index
网站的默认页
默认值index index.html;位置http、server、location
index index.html index.htm;  从左往右匹配，一经匹配，立即执行

# error_page error_page:设置网站的错误页面
# 1.
server {
	error_page 404 www.baidu.com;
}

# 2.
error_page 500 404 /50x.html;
location /50x.html {
    root html;
}

# 3.不能直接访问的location
error_page 404 @hahaha;
location @hahaha {
    default_type text/plain;
    return 456 'shabi';
}

# 4.将相应代码更改为另外一个
error_page 404 =200 /50x.html;
location /50x.html {
	root html;
}

sendfile on;
tcp_nopush on;
tcp_nodelay on;

sendfile 高效的文件传输，http，server，location

tcp_nopush   # sendfile 打开才生效 位置http,server,location  提升传输效率，即存满缓冲区再发，不要立即push
tcp_nodelay  # keep-alive连接开启才生效 提高网络包传输实时性，即有数据不等缓冲区满立即发 不要延迟

gzip on   # 用于开启或者关闭gzip功能 http,server,location
gzip_types mine-type  # 默认text/html,对mime类型的资源做压缩，多个值空格分隔，使用*压缩所有，http，server，location.不建议压缩图片视频等资源
gzip_comp_level 1    # 默认1，取值1-9，值越大，压缩等级最高。设置越高，浪费cpu资源越大。建议6
gzip_vary off  # 默认off，是否携带“Vary:Accept-Encoding”头域的响应头部。主要是告诉接收方，所发送的数据经过了Gzip压缩处理
gzip_buffers 32 4k    # 主要实现的是申请number个每个大小为size的缓冲区空间。
gzip_disable "MSIE [1-6]\.";   # 针对不同客户端选择是否启用压缩
gzip_http_version 1.1    # 该指令是指定使用Gzip的HTTP最低版本，该指令一般采用默认值即可。
gzip_min_length 20  # 小于20字节不在压缩，可以加单位。但是使用了Chunk编码动态压缩，该指令将被忽略。建议设置为1K或以上
gzip_proxied off;  # 该指令设置是否对服务端返回的结果进行Gzip压缩。

gzip_proxied 取值
off - 关闭Nginx服务器对后台服务器返回结果的Gzip压缩
expired - 启用压缩，如果header头中包含 "Expires" 头信息
no-cache - 启用压缩，如果header头中包含 "Cache-Control:no-cache" 头信息
no-store - 启用压缩，如果header头中包含 "Cache-Control:no-store" 头信息
private - 启用压缩，如果header头中包含 "Cache-Control:private" 头信息
no_last_modified - 启用压缩,如果header头中不包含 "Last-Modified" 头信息
no_etag - 启用压缩 ,如果header头中不包含 "ETag" 头信息
auth - 启用压缩 , 如果header头中包含 "Authorization" 头信息
any - 无条件启用压缩

gzip on;
gzip_types *;
gzip_comp_level 6;
gzip_min_length 1024;
gzip_buffers 4 16K;
gzip_http_version 1.1;
gzip_vary  on;
gzip_disable "MSIE [1-6]\.";
gzip_proxied  off;


在nginx.conf 
include nginx_gzip.conf

gzip_static off;  # 检查与访问资源同名的.gz文件时，response中以gzip相关的header返回.gz文件的内容。
取值 on off always
always 浏览器不支持压缩都会发送，on会先判断

nginx 编译时默认没有该模块
./confighure --with-http_gzip_static_module 

expires off;  # expires:该指令用来控制页面缓存的作用。可以通过该指令控制HTTP应答中的“Expires"和”Cache-Control"
expires   [modified] time
expires epoch|max|off;

time:可以整数也可以是负数，指定过期时间，如果是负数，Cache-Control则为no-cache,如果为整数或0，则Cache-Control的值为max-age=time;
epoch: 指定Expires的值为'1 January,1970,00:00:01 GMT'(1970-01-01 00:00:00)，Cache-Control的值no-cache
max:指定Expires的值为'31 December2037 23:59:59GMT' (2037-12-31 23:59:59) ，Cache-Control的值为10年
off:默认不缓存。

location ~ .*\.(html|js|css|png)$ {
    expires 1000;
}
off												整数											负数

# add_header指令是用来添加指定的响应头和响应值。
add_header Cache-control no-store
# 也能实现不缓存

# 解决跨域问题
location {
    add_header Access-Control-Allow-Origin http://192.168.13.132:80;   # * 匹配所有
    add_header Access-Control-Allow-Methods GET,POST,PUT,DELETE;
}
location /getUser{
    add_header Access-Control-Allow-Origin *;
    add_header Access-Control-Allow-Methods GET,POST,PUT,DELETE;
    default_type application/json;
    return 200 '{"id":1,"name":"TOM","age":18}';
}

# 防盗链测试
curl 测试防盗链
curl -I 只返回响应头信息
curl -e "referer" -I "URL"

none: 如果Header中的Referer为空，允许访问
blocked:在Header中的Referer不为空，但是该值被防火墙或代理进行伪装过，如不带"http://" 、"https://"等协议头的资源允许访问。就是允许“http://”或"https//"以外的请求。
server_names:指定具体的域名或者IP
string: 可以支持正则表达式和*的字符串。如果是正则表达式，需要以`~`开头表示，例如

location ~ .*\.(png|jpg|gif)$ {
    vaild_referers none blocked www.g.com;
    if ($invalid_referer) {
		return 403;
	}
    root html/images;
}
# 针对目录进行防盗链
location /static {
    root html;
    vaild_referers none blocked www.g.com;
    if ($invalid_referer) {
		return 403;
	}
}

# 检测到盗链时返回403错误码
location ~*/(js|img|css) {
    valid_referers none 192.168.13.132;
    if ($invalid_referer) {
        return 403;
    }

    root   html;
    index  index.html index.htm; 
}

# 检测到盗链时返回指定页面
location ~*/(js|img|css) {
    valid_referers none 192.168.13.132;
    if ($invalid_referer) {
        return 401;
    }

    root   html;
    index  index.html index.htm; 
}

error_page  401  /401.html;
    location = /401.html {
        root   html;
    }
# 注意，只有打开图片链接才能看到指定页面

# 检测到盗链时返回指定图片
location ~ .*\.(png|jpg|gif)$ {
    vaild_referers none blocked www.g.com;
    if ($invalid_referer) {
		# return 403;
        rewrite ^/ /imgaes/a.png break;
	}
    root html/images;
}

# set  该指令用来设置一个新的变量。
# server、location、if
set $variable value;
variable:变量的名称，该变量名称要用"$"作为变量的第一个字符，且不能与Nginx服务器预设的全局变量同名。
value:变量的值，可以是字符串、其他变量或者变量的组合等。

server {
    listen 8890;
    server_name localhost;
    location /server {
        set $name shabi;
        set $age 18;
        default_type text/plain;
        return 200 $name=$age;
    }
}

# if  (condition){...}
# server、location

location /if {
    set $param '';
    default_type text/plain;
    if ($param) {
		return 200 $param;
    }

    if ($request_method = POST) {
        return 405;
    }
    if ($http_user_agent ~ Safari) {
        return 200;
    }
    if (!-f $request_filename) {
        return $request_filename;
    }
    return 200 'empty';
}

location /testbreak {
    if ($args) {
        set $username haha;
        break;
    }
    add_header $username 222;
    return 200;
}

return code [text];
return code URL;
return URL;

server /ret {
    default_type application/json;
    return 200 success;
    # return 302 http://www.baidu.com;
}

# rewrite regex replacement [flag];
# server、location、if

location /rewrite {
    rewrite ^/rewrite/url\w*$ https://www.baidu.com;
    rewrite ^/rewrite/(test)\w*$; /$1;
    rewrite ^/rewrite/(demo)\w*$  /$1;
}

server {
       listen       80;
       server_name  localhost;  # 域名或主机名

       location / {
       	rewrite ^/([0-9]+).html$ /index.jsp?pageNum=$1 break;
		proxy_pass http://192.168.13.155:8080;
       }

       #error_page  404              /404.html;

       error_page   500 502 503 504  /50x.html;
       location = /50x.html {
           root   html;
       }
   }

# 1.修改hosts
127.0.0.1       www.shinya.com
127.0.0.1       www.kbshire.com
127.0.0.1       www.shabi.com

# 2.修改conf
server {
    listen 80;
    server_name www.shinya.com;
    location / {
        default_type text/html;
        return 200 '<h1>shinya</h1>';
    }
}
server {
    listen 80;
    server_name www.kbshire.com www.shinya.com;
    # rewrite ^/ http://www.shinya.com/;
    rewrite ^(.*) http://www.shinya.com$1;
}

# 只对user子目录做镜像
server {
    listen 80;
    server_name www.shinya.com www.kbshire.com;
    location /user {
        rewrite ^/user(.*)$ http://www.shabi.com$1;
    }
    location /emp {
        default_type text/html;
        return 200;
    }
}

http://search.hm.com  访问商品搜索模块
http://item.hm.com	  访问商品详情模块
http://cart.hm.com	  访问商品购物车模块

server{
	listen 80;
	server_name search.hm.com;
	rewrite ^(.*) http://www.hm.com/bbs$1 last;
}
server{
	listen 81;
	server_name item.hm.com;
	rewrite ^(.*) http://www.hm.com/item$1 last;
}
server{
	listen 82;
	server_name cart.hm.com;
	rewrite ^(.*) http://www.hm.com/cart$1 last;
}

server {
    listen 8082;
    server_name localhost;
    server_name_in_redirect on;
    location /shabi {
        root html;
        index index.html;
        if (-d $request_filename) {
            rewrite ^(.*)([^/])$ http://$host:$server_port$1$2/ permanent;
        }
    }
}

server {
    listen 8083;
    server_name localhost;
    location /server {
        root html;
        index index.html;
        rewrite ^/server-([0-9]+)-([0-9]+)-([0-9]+)-([0-9]+)-([0-9]+)\.html$ /server/$1/$2/$3/$4/$5.html last;
        # /server/11/22/33/44/20.html
        # /server/11-22-33-44-20.html
    }
}

# 检测到盗链时返回指定图片
location ~ .*\.(png|jpg|gif)$ {
    vaild_referers none blocked www.g.com;
    if ($invalid_referer) {
		# return 403;
        rewrite ^/ /imgaes/a.png break;
	}
    root html/images;
}

# 访问192.168.13.155 82 代理到服务器，服务器认为是155访问的
server {
    listen 82;
    resolver 8.8.8.8;   # 设置DNSIP，用来继续proxy_pass中域名
    location / {
        proxy_pass http://$host$request_uri;
    }
}

proxy_pass # 设置被代理服务器的地址
位置location

server  {
    listen 8080;
    server_name localhost;
    location / {
        proxy_pass http://192.168.13.155;
    }
    location /server {
        # 此时访问的是/server/index.html
        proxy_pass http://192.168.13.155;
    }
    location /server {
        # 此时访问的是/index.html
        proxy_pass http://192.168.13.155/;
    }
    # 注意location /  proxy_pass 后面会帮你加上 / 
    # loction /xxx  后面不加 / 会出现上面的问题
}

proxy_set_header 
# 该指令可以更改Nginx服务器接收到的客户端请求的请求头信息，然后将新的请求头发送给代理的服务器
proxy_set_header Host $proxy_host;
proxy_set_header Connection close;

# 被带服务器
server {
    listen 8080;
    server_name localhost;
    location / {
        default_type text/html;
        return 200 $http_username;
    }
}

# 代理服务器
server  {
    listen 8080;
    server_name localhost;
    location / {
        proxy_pass http://192.168.13.155:8080;
        proxy_set_header username HAHA;
    }
}

# 实现功能 访问代理服务器的:8080/server 添加username header，在被代服务器回显给客户端

# proxy_redirect
该指令是用来重置头信息中的"Location"和"Refresh"的值。
proxy_redirect redirect replacement;
proxy_redirect default;
proxy_redirect off;
位置http、server、location

# 服务端
server {
    listen 8082;
    server_name localhost;
    location / {
        root html;
        index index.html;
        # 这样会暴露服务端真实ip
        #if (!-f $request_filename) {
        #    return 302 http://192.168.13.155/;
        #}
    }
}

# 代理服务器
server {
    listen 8082;
    server_name localhost;
    location / {
        proxy_pass http://192.168.13.155:8082;
        proxy_redirect http://192.168.13.155 http://192.168.13.132;
    }
}

# proxy_redirect redirect replacement;
redirect:目标,Location的值
replacement:要替换的值

# proxy_redirect default;
将location块的uri变量作为replacement,
将proxy_pass变量作为redirect进行替换

# 如果后端服务器每台上内容不一样
# 服务器1
server {
    listen 8083;
    server_name 192.168.13.155;
    default_type text/plain;
    location / {
        return 200 '155';
    }
}
# 服务器2
server {
    listen 8083;
    server_name 192.168.13.166;
    default_type text/plain;
    location / {
        return 200 '166';
    }
}

# 代理服务器
server {
    listen 8083;
    server_name localhost;
    location / {
        proxy_pass http://192.168.13.155:8083/;
    }
}
server {
    listen 8084;
    server_name localhost;
    location / {
        proxy_pass http://192.168.13.166:8083/;
    }
}

# 代理服务器 - 或者
server {
    listen 8083;
    server_name localhost;
    location /server1 {
        proxy_pass http://192.168.13.155:8083/;
    }
    location /server2 {
        proxy_pass http://192.168.13.166:8083/;
    }
}

ssl on;   # 开启ssl支持
位置http、server
或者
server {
    listen 443 ssl;
}
效果一样~

ssl_certificate ;   # 指定pem证书
ssl_certificate_key # 指定pem secret 文件
ssl_session_cache off;  # 设置ssl会话缓存

/*
ssl_session_cache 可选项如下
off:禁用会话缓存，客户端不得重复使用会话
none:禁止使用会话缓存，客户端可以重复使用，但是并没有在缓存中存储会话参数
builtin:内置OpenSSL缓存，仅在一个工作进程中使用。
shared:所有工作进程之间共享缓存，缓存的相关信息用name和size来指定
*/

ssl_session_timeout # 设置客户端能够反复使用储存在缓存中的会话参数时间
ssl_ciphers # 允许的密码，必须为openssl支持的格式，可以使用`openssl ciphers`查看openssl支持的格式。
ssl_prefer_server_ciphers on;  #该指令指定是否服务器密码优先客户端密码

相同点:
两种方式都是用来提供IO吞吐效率，都是用来提升Nginx代理的性能。
不同点:
缓冲主要用来解决不同设备之间数据传递速度不一致导致的性能低的问题，缓冲中的数据一旦此次操作完成后，就可以删除。
缓存主要是备份，将被代理服务器的数据缓存一份到代理服务器，这样的话，客户端再次获取相同数据的时候，就只需要从代理服务器上获取，效率较高，缓存中的数据可以重复使用，只有满足特定条件才会删除.

proxy_buffering on  :该指令用来开启或者关闭代理服务器的缓冲区；
proxy_buffers 8 4k   :该指令用来指定单个连接从代理服务器读取响应的缓存区的个数和大小。
proxy_buffer_size 4k :该指令用来设置从被代理服务器获取的第一部分响应数据的大小。保持与proxy_buffers中的size一致即可，当然也可以更小。
proxy_busy_buffers_size 8k  ：该指令用来限制同时处于BUSY状态的缓冲总大小
proxy_temp_path path  :当缓冲区存满后，仍未被Nginx服务器完全接受，响应数据就会被临时存放在磁盘文件上，该指令设置文件路径,最多只能三层目录
proxy_temp_file_write_size 8k ：该指令用来设置磁盘上缓冲文件的大小。

proxy_buffering on;
proxy_buffer_size 4 32k;
proxy_busy_buffers_size 64k;
proxy_temp_file_write_size 64k;

upstream 该指令是用来定义一组服务器，它们可以是监听不同端口的服务器，并且也可以是同时监听TCP和Unix socket的服务器。服务器可以指定不同的权重，默认为1。
位置http

server 该指令用来指定后端服务器的名称和一些参数，可以使用域名、IP、端口或者unix socket
位置upstream

upstream backend{
	server 192.168.200.146:9091;
	server 192.168.200.146:9092;
	server 192.168.200.146:9093;
}
server {
	listen 8083;
	server_name localhost;
	location /{
		proxy_pass http://backend;
	}
}

upstream backend{
	ip_hash;
     # hash $request_uri;
	server 192.168.200.146:9001 weight=2;
	server 192.168.200.146:9002;
	server 192.168.200.146:9003;
}
server {
	listen 8083;
	server_name localhost;
	location /{
		proxy_pass http://backend;
	}
}

upstream backend {
    fair;
}
https://github.com/gnosek/nginx-upstream-fair
./configure --add-module=/root/fair

# 实现带有URL重写的负载均衡
upstream backend{
	server 192.168.200.146:9001;
	server 192.168.200.146:9002;
	server 192.168.200.146:9003;
}
server {
	listen	80;
	server_name localhost;
	location /file/ {
		rewrite ^(/file/.*) /server/$1 last;
	}
	location / {
		proxy_pass http://backend;
	}
}

upstream httpds {
       sticky name=shabi expires=6h;
       server 192.168.13.155:8080;
       server 192.168.13.166:8080;
   }

   server {
       listen       80;
       server_name  localhost;

       #charset koi8-r;

       #access_log  logs/host.access.log  main;

       location / {
               proxy_pass http://httpds;
       }

      location ~*/(js|img|css) {
               root   /usr/local/nginx/html;
           }

--with-stream
# stream指令 该指令提供在其中指定流服务器指令的配置文件上下文。和http指令同级。
# 位置main

# upstream指令 该指令和http的upstream指令是类似的

stream {
    upstream backend {
        server 192.168.13.155:8888;
        server 192.168.13.155:8889;
    }
    upstream backendtomcat {
        server 192.168.13.155:8080;
    }
    server {
        listen 81;
        proxy_pass backend;
    }
    server {
        listen 82;
        proxy_pass backendtomcat;
    }
}

# proxy_cache_path 该指定用于设置缓存文件的存放路径
# 位置http
proxy_cache_path /usr/local/proxy_cache keys_zone=itcast:200m  levels=1:2 inactive=1d max_size=20g;
再加两层目录，第一层一个字母，第二层两个字母
缓存名称，大小
缓存超时时间，未被访问就会删除
设置最大缓存空间，如果缓存空间存满，默认会覆盖缓存时间最长的资源

# proxy_cache 该指令用来开启或关闭代理缓存，如果是开启则自定使用哪个缓存区来进行缓存。
# 位置http、server、location
proxy_cache itcast
# 这个名字需要和上面定义的keys_zone的名字相同

# proxy_cache_key 该指令用来设置web缓存的key值，Nginx会根据key值MD5哈希存缓存
# 默认值 proxy_cache_key \$scheme\$proxy_host$request_uri;
# 位置http、server、location

# proxy_cache_vaild 该指令用来对不同返回状态码的URL设置不同的缓存时间
# 位置http、server、location
proxy_cache_valid 200 302 10m;
proxy_cache_valid 404 1m;
# 为200和302的响应URL设置10分钟缓存，为404的响应URL设置1分钟缓存
proxy_cache_valid any 1m;
# 对所有响应状态码的URL都设置1分钟缓存
# 最小匹配优先

# proxy_cache_min_uses 该指令用来设置资源被访问多少次后被缓存
# 位置http、server、location
默认值为1

# proxy_cache_methdos 该指令用户设置缓存哪些HTTP方法
# 位置http、server、location
默认值为GET HEAD  ，支持get head post


# 断点续传缓存 range
当有完整的content-length之后即可断点续传
在反向代理服务器中需向后传递header

proxy_set_header Range $http_range;

http{
	proxy_cache_path /usr/local/proxy_cache levels=2:1 keys_zone=itcast:200m inactive=1d max_size=20g;
	upstream backend{
		server 192.168.200.146:8080;
	}
	server {
		listen       8080;
        server_name  localhost;
        location / {
        	proxy_cache itcast;
            # 建议使用默认值$schema$proxy_host$request_uri; 相同的proxy_cache_key会出现问题，即该location下不同uri会返回相同的缓存
            proxy_cache_key it;
            proxy_cache_min_uses 5;
            proxy_cache_valid 200 5d;
            proxy_cache_valid 404 30s;
            proxy_cache_valid any 1m;
            add_header nginx-cache "$upstream_cache_status";
        	proxy_pass http://backend/js/;
        }
	}
}