【转载】Nginx反向代理，负载均衡，redis session共享，keepalived高可用

发表于 | 更新于 | 分类于
本文字数： 258k | 阅读时长 ≈ 3:55

来自：MrLinFeng - 博客园 链接：www.cnblogs.com/mrlinfeng/p/6146866.html

使用的资源：

nginx主服务器一台，nginx备服务器一台，使用keepalived进行宕机切换。

tomcat服务器两台，由nginx进行反向代理和负载均衡，此处可搭建服务器集群。

redis服务器一台，用于session的分离共享。

nginx主服务器：192.168.50.133

nginx备服务器：192.168.50.135

tomcat项目服务器1:192.168.50.137

tomcat项目服务器2:192.168.50.139

redis服务器：192.168.50.140

注意访问时需要配置防火墙规则，或者关闭防火墙

Nginx反向代理与负载均衡

架构图：

img此时需要用到三台服务器，一台nginx服务器，两台正式部署项目的服务器：选择的是192.168.50.133主nginx和192.168.50.137,192.168.50.139两台tomcat服务器

首先在两台服务器上安装tomcat：这个也是简单，不多说

安装tomcat：上传解压即可使用，bin目录下 startup.sh启动，shutdown.sh关闭

配置防火墙端口：vim /etc/sysconfig/iptables 编辑，开放8080端口，80端口等一些常用端口，当然后边有用到一些端口都是需要配置开放的，不建议关闭防火墙

img

编辑好后 service iptables restart 重新加载防火墙配置

img

如果是自己测试嫌配置麻烦，关闭防火墙： service iptables stop 重启后防火墙打开，即在此次开机状态下有效，完全关闭再使用 chkconfig iptables off ,即会在重启后也关闭防火墙，注意有时候服务都起了但访问出错，可能就是防火墙问题哦

启动tomcat访问：192.168.50.137:8080，192.168.50.139:8080，打开tomcat首页即成功。

然后编写测试项目，部署到两台tomcat上，eclipse新建web项目，项目名为testproject，在webapp下新建一个jsp页面为index.jsp,添加如下内容

img将项目中web.xml中的访问顺序index.jsp上移到第一个访问

然后右键导出为war包，testproject.war，将该war包上传到两台服务器的tomcat的webapps中

img

然后修改tomcat的server.xml文件，在tomcat conf目录中：可以使用notepad++的插件NppFTP直接连上linux，然后使用notepad++修改文件哦，保存记得使用UTF-8无BOM格式，具体去百度吧，哈哈

修改Engine标签中，添加jvmRoute，用于标识nginx访问的是哪个服务器tomcat，137服务器标识为137Server1，139服务器标识为139Server2

img

在两台tomcat的server.xml文件，Host标签中添加：，path标识访问路径，docBase为项目名，表示访问项目

img

此时，重新启动tomcat，访问192.168.50.137:8080，192.168.50.139:8080,显示index.jsp内容：两台服务器访问显示如下

img

img

至此，两台tomcat服务器搭建完成。

在nginx主机192.168.50.133上安装nginx：

先使用yum命令安装gcc，安装pcre，zlib，openssl：

1
yum install -y gcc``yum install -y pcre pcre-devel``yum install -y zlib zlib-devel``yum install -y openssl openssl-devel

在/usr/local/目录下新建nginx-src目录，将nginx-1.8.0.tar.gz放到此处，解压 

1
tar -zxvf nginx-1.8.0.tar.gz

进入解压后目录

img

依次执行命令：

1
./configure` `make` `mkae install

此时nginx安装完毕，安装目录是/usr/local/nginx，nginx默认占用80端口

img

其中，sbin目录为nginx执行命令，conf目录下的nginx.conf为默认加载的配置文件

启动nginx：

1
./sbin/nginx

关闭nginx：

1
./sbin/nginx -s stop

启动nginx后访问192.168.50.133:80即可访问nginx：显示nginx欢迎页

img

至此，nginx安装完毕。

反向代理与负载均衡配置

现有两台服务器，一台为192.168.50.137，一台为192.168.50.139，服务器上各有一台tomcat，端口均为8080，在192.168.50.133上有nginx，经过配置nginx，当访问192.168.50.133:80时，即可访问192.168.50.137:8080，192.168.50.139:8080中随机一台，此时192.168.50.133:80被nginx监听，当有请求时，代理到192.168.50.137:8080，192.168.50.139:8080随机一台即可，即为nginx反向代理功能，同时此时可以通过nginx将请求进行转发，保证了一个入口，将所有请求转发到两台服务器上也减轻了任何一台的负载压力，当有大量请求时，可以搭建大量服务器，在入口代理服务器上使用nginx进行转发，即是负载均衡功能。

img

配置即是配置nginx安装目录中conf目录下的nginx.conf文件即可：具体配置如下，重点是红色部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#Nginx所用用户和组
#user  niumd niumd;

#工作的子进程数量（通常等于CPU数量或者2倍于CPU）
worker_processes  2;

#错误日志存放路径
#error_log  logs/error.log;
#error_log  logs/error.log  notice;
error_log  logs/error.log  info;

#指定pid存放文件
pid        logs/nginx.pid;

events {
    #使用网络IO模型linux建议epoll，FreeBSD建议采用kqueue
    #use epoll;
    
    #允许最大连接数
    worker_connections  1024;
}

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


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

    #access_log  off;
    access_log  logs/access.log;

    client_header_timeout  3m;
    client_body_timeout    3m;
    send_timeout           3m;
 
    client_header_buffer_size    1k;
    large_client_header_buffers  4 4k;

    sendfile        on;
    tcp_nopush      on;
    tcp_nodelay     on;

    #fastcgi_intercept_errors on; 
   
    error_page 404  /404.html;

    #keepalive_timeout  75 20;

    gzip                 on;
    gzip_min_length      1000;
    gzip_types           text/plain text/css application/x-javascript;

    #配置被代理的服务器
    upstream blank {
        #ip_hash;
        server 192.168.50.137:8080;
        server 192.168.50.139:8080;
    }

    server {
            #nginx监听80端口，请求该端口时转发到真实目标
            listen       80;
            #配置访问域名
            server_name  localhost;                  
        
            location / {
                #这里配置代理是指上面定义的两个被代理目标，blank名字必须一致
                proxy_pass http://blank;
                
                #proxy_redirect          off;
                #如果是非80端口，配置为Host $host：端口号，目的是将代理服务器收到的用户的信息传到真实服务器上
                proxy_set_header        Host $host;
                proxy_set_header        X-Real-IP $remote_addr;
                proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
                client_max_body_size    10m;
                client_body_buffer_size 128k;
                proxy_connect_timeout   300;
                proxy_send_timeout      300;
                proxy_read_timeout      300;
                proxy_buffer_size       4k;
                proxy_buffers           4 32k;
                proxy_busy_buffers_size 64k;
                proxy_temp_file_write_size 64k;
                add_header Access-Control-Allow-Origin *;
            }
            
            #此处定义500 502 503 504的错误页面
            error_page   500 502 503 504  /50x.html;
            #错误页面位置
            location = /50x.html {
            #root表示路径 html为nginx安装目录中的html文件夹
            #位于/usr/local/nginx/html/下
               root   html;
            }        
    }
}

启动两台tomcat，重新启动nginx：

访问192.168.50.133:80将会随机访问192.168.50.137:8080和192.168.50.139:8080其中一台。（问题：每次刷新nginx服务器地址sessionid会变，session不能共享。）

img

nginx轮询策略：

nginx负载均衡到多台服务器上时，默认采用轮询策略：

常见策略：

1、轮询

每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。

2、weight
指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况，数字越大命中率越高。
例如：轮询几率是2:1
upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

2、ip_hash
每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题。
例如：
upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查询学习,nginx还有很多其他可配置项，静态资源缓存，重定向等，想深入的童鞋请自行学习

nginx配置详解

实际问题：虽然解决了，但是不是很理解，记录一下

其中192.168.50.133:80是有外网映射的，外网55.125.55.55:5555映射到192.168.50.133:80上，此时使用55.125.55.55:5555访问，会映射到192.168.50.133:80上，然后会被转发到192.168.50.137:8080或192.168.50.139:8080，但是此时却出现图片，js，css等静态文件无法访问的情况，通过两种方法解决。

<1>.映射非80端口

让55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然后再在nginx配置文件中配置如下，注意红色加大部分：这地方不理解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
........ upstream blank {
        #ip_hash;
        server 192.168.50.137:8080;
        server 192.168.50.139:8080;
    }
 
    server {
        #nginx监听5555端口，请求该端口时转发到真实目标
            listen       5555;
        #配置访问域名
            server_name  192.168.11.133;              
         
            location / {
        #这里配置代理是指上面定义的两个被代理目标，blank名字必须一致
                proxy_pass http://blank;
                 
        #proxy_redirect          off;
        #非80端口使用，目的是将代理服务器收到的用户的信息传到真实服务器上
        proxy_set_header        Host $host:$server_port;
        proxy_set_header        X-Real-IP $remote_addr;
    　　　　 proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
        client_max_body_size    10m;
        client_body_buffer_size 128k;
        proxy_connect_timeout   300;
        proxy_send_timeout      300;
        proxy_read_timeout      300;
        proxy_buffer_size       4k;
        proxy_buffers           4 32k;
        proxy_busy_buffers_size 64k;
        proxy_temp_file_write_size 64k;
        add_header Access-Control-Allow-Origin *;
            }........

此时访问55.125.55.55:5555，映射到192.168.50.133:5555上，然后转发到192.168.50.137:8080或192.168.50.139:8080上，此时静态文件均能访问。

<2>.使用域名在外网服务器上使用nginx进行转发

将55.125.55.55绑定域名为test.baidubaidu.com，此时在55.125.55.55服务器上使用nginx,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
........location / {
        #加入判断，如果域名为test.baidubaidu.com，转发到192.168.50.133:80，然后再进行转发，注意，此处未进行测试，貌似是这么写的，$host为nginx变量，可以获取域名    
        if($host = "test.baidubaidu.com" ){
        　　proxy_pass http://192.168.50.133:80;
        }
                 
        #proxy_redirect          off;
        #非80端口使用，目的是将代理服务器收到的用户的信息传到真实服务器上，我也不是很理解
        proxy_set_header        Host $host:$server_port;
        proxy_set_header        X-Real-IP $remote_addr;
        proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
        client_max_body_size    10m;
        client_body_buffer_size 128k;
        proxy_connect_timeout   300;
        proxy_send_timeout      300;
        proxy_read_timeout      300;
        proxy_buffer_size       4k;
        proxy_buffers           4 32k;
        proxy_busy_buffers_size 64k;
        proxy_temp_file_write_size 64k;
        add_header Access-Control-Allow-Origin *;
            }........

以上即nginx反向代理与负载均衡介绍，经过此次学习，发现nginx确实是博大精深，一个配置文件搞得我不要不要的。。。

session共享问题

由于nginx是随机分配请求，假设一个用户登录时访问网站登录时被分配到192.168.50.137:8080上，然后进行了登录操作，此时该服务器上就会有该用户登录的session信息，然后登陆后重定向到网站首页或个人中心时，此时如果被分配到192.168.50.139:8080上，那么这台服务器上没有该用户session信息，于是又会变成未登录状态，所以由于nginx的负载均衡会导致session共享的问题。

解决方法：

1.nginx提供了ip_hash策略，可以保持用户ip进行hash值计算固定分配到某台服务器上，然后只要是该ip则会保持分配到该服务器上，保证用户访问的是同一台服务器，那么session问题就不存在了。这也是解决session共享的一种方式，也称为黏性session。但是假设一台tomcat服务器挂了的话，那么session也会丢失。所以比较好的方案是抽取session。

2.session存在memcache或者redis中，以这种方式来同步session，把session抽取出来，放到内存级数据库里面，解决了session共享问题，同时读取速度也是非常之快。

img

本例中：

img

Redis解决session共享：

在redis服务器192.168.50.140上搭建redis，redis默认端口为6379

Redis搭建：

redis依赖gcc，先安装：

1
yum install -y gcc-c++

下载redis，我使用的是redis-3.2.1.tar.gz，上传至linux /usr/local/redis-src/中，解压

进入解压后目录redis-3.2.1，执行make命令进行编译

安装到目录/usr/local/redis

执行：

1
make PREFIX=/usr/local/redis install

安装完成之后将redis配置文件拷贝到安装目录下，redis.conf是redis的配置文件，redis.conf在redis源码目录,port默认6379。

执行命令：

1
cp /usr/local/redis-src/redis-``3.2``.``1``/redis.conf /usr/local/redis/

在redis安装目录启动和关闭redis：

启动：

1
./bin/redis-server ./redis.conf

img

这种启动方式叫做前端启动，必须保持在当前窗口，如果ctrl + c 退出，那么redis也就退出了，不建议使用

那么后端启动：

首先修改redis.conf中daemonize的值，打开可以看到默认是no，修改为daemonize yes，启动即可。也可以在该配置文件中修改redis默认端口6379为其他值。

img

关闭redis：

1
./bin/redis-cli shutdown

至此，redis服务器搭建完成。

tomcat与redis集成实现session共享：

环境为tomcat7 + jdk1.6的话：

在所有需要共享session的服务器的tomcat中目录下：

lib目录中添加以下三个jar包，注意版本最好一致，不然极容易出现错误，下边的测试是可用的：

img

conf目录中content.xml中加入：配置redis服务

1
2
3
4
5
6
<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0"  
maxInactiveInterval="60" />

环境为tomcat7 + jdk1.7或1.8的话：

在所有需要共享session的服务器的tomcat中目录下：

lib目录中添加以下三个jar包，测试通过：

img

conf目录中content.xml中加入：配置redis服务

1
2
3
4
5
6
<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" />       
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140"  
port="6379"  
database="0"              
maxInactiveInterval="60"/>

根据我这测试，是jkd1.8+tomcat7，在137和139两台tomcat中加入jar包且进行如上配置：

上传jar包

img

修改content.xml

img

启动redis服务，重新启动所有tomcat，启动nginx，刷新nginx页面,两台tomcat页面可以看到sessionid值不变，关闭某台tomcat，nginx中sessionid不变，说明session是共享的。

问题：

有可能此时访问会报错，redis无法访问，这是由于redis的安全机制，默认只有127.0.0.1才能访问，在redis.conf中可以找到bind 127.0.0.1，你可以将此ip改为访问者ip，

如果有多个访问者，也可以把bind 127.0.0.1注释掉，然后在配置文件中找到protected-mode，修改protected-mode yes改为protected-mode no 关闭redis保护模式即可

详细可以参考这：http://www.cnblogs.com/liusxg/p/5712493.html

经过大牛指点：添加两个注意点：

1.按照如上配置,使用redis数据库,放入session中的对象必须要实现java.io.Serializable接口，使用memcache的可以不用实现Serializable接口

原因是:因为tomcat里使用的将session放置redis使用的工具类,是使用的jdk序列化模式存储的，这一点也是很容易理解的，session.setAttribute(String key, Object value)，存储Object类型

object放入redis中又要能取出来，只能是序列化进行存储了，然后取出的时候进行反序列化。

所以我们在session中存储的任何对象，都必须实现序列化接口。

2.按照如上配置,使用redis做session存储空间时,web应用的session-time的时间单位会变成[秒],而不是原本的[分]

原因是:因为tomcat里使用的将session放置redis使用的工具类,在存储时为对tomcat容器时间做转换，

在redis中设置过期时间是使用秒作为单位的，有个命令叫expire可以设置redis键值过期时间，所以在context.xml配置文件中我们需要制定session过期时间（默认是60秒，配成1800即30分钟），这一点很重要。

请注意！！！！

context.xml配置说明：

1
2
3
4
5
6
7
8
9
10
<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" />      
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//这里是redis服务器地址
host="192.168.50.140"
//这里是redis端口，redis默认端口是6379
port="6379"
//这里是redis数据库中的标识，标识第0个，默认使用0即可
database="0"            
//需要注意的是这里由于redis过期时间默认设置为60，单位是秒，session过期时间为30分钟，所以需要设置为1800对应30分钟
maxInactiveInterval="1800"/>

keepalived高可用

架构图：

img

上图画的不对称好难看，将就下吧

根据上边一路走来，已经是搭好了从nginx主到服务器的这条线的，那么同理，使用nginx备机192.168.50.135上再搭建nginx，也是代理192.168.137和139两台服务器。搞了一次之后也就简单了

在192.168.50.135上安装nginx，配置nginx配置即可，不再赘述，nginx备机配置如下：

配置和上边的是一样的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
........upstream blank {
        #ip_hash;
        server 192.168.50.137:8080;
        server 192.168.50.139:8080;
}
     
    server {
        listen       80;
        server_name  localhost;
 
        #charset koi8-r;
 
        #access_log  logs/host.access.log  main;
 
        location / {
            proxy_pass http://blank;
            root   html;
            index  index.html index.htm;
        }........

那么现在就是相当于有两套nginx了，代理的服务器是一样的，为什么要搞两套？

假设只有一台nginx的话，这个nginx服务器挂了。那怎么办？

所以需要一台备份nginx。

正常情况下，主nginx作为反向代理服务器即可，假设nginx服务器挂了的话，能够立即切换到备份机上，保证用户可以访问，然后运维人员把主nginx服务器故障修好之后，又能够自动切换到主nginx提供服务。通过keepalived来监测两台服务器，正常情况时，将nginx主服务器ip（192.168.50.133）绑定到keepalived定义的一个虚拟ip（我设置为192.168.50.88）上，通过这个虚拟IP可以访问nginx，然后备机（192.168.50.135）啥事不干，就是每隔一小段时间（设置为1秒）keepalived会告诉备机，你不用管，我还活着呢，如果突然主机死了，那么就会超过一秒备机没有收到主机或者的消息，那么备机马上接管主机，keeplived将虚拟ip绑定到备机身上，网站继续提供服务。

突然主机又复活了（运维人员排除故障了），那么备机又将收到主机的活着的消息，于是将管理权交回给主机，虚拟ip又绑到主机上，大概就是这么个过程，个人理解。

img

先在两台nginx服务器（主备）上都装上keepalived：

下载：这里使用rpm安装，是区分32,64位的，不要搞错了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必须是openssl-1.0.1e或以上才行、如果版本已经符合（因为安装nginx时已经安装openssl，使用yum安装应该是符合的）、不用再安装openssl，使用 rpm -q openssl 查看当前openssl版本，我这已经是1.0.1e 48的，所以就不安装了

img

将两个rpm安装包上传到两台nginx服务器，进入上传到的目录，运行以下命令安装:–nodeps是忽略依赖包，当然最好是把依赖包装上，去掉–nodeps可以看到错误，需要哪些依赖包

如果需要安装openssl

1
rpm –Uvh --nodeps ./openssl-``1.0``.1e-``30``.el6_6.``4``.x86_64.rpm

安装keepalived：

1
``rpm -Uvh --nodeps ./keepalived-``1.2``.``7``-``3``.el6.x86_64.rpm

安装完毕后再/etc/keepalived/目录下有个文件 keepalived.conf即是本台服务器keepalived的核心配置文件了：

重点：keepalived配置，配置文件上边部分按照下面的配置就行了，配置文件后面的内容可以不用管，还没有去研究其他部分

先配置主机192.168.50.133的keepalived，按下边进行配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
! Configuration File for keepalived
 
#这是全局配置
global_defs {
   #指定keepalived在发生切换时需要发送email到的对象，一行一个
   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   }
   #指定发件人
   notification_email_from Alexandre.Cassen@firewall.loc
   #指定smtp服务器地址
   #smtp_server 192.168.200.1
   #指定smtp连接超时时间
   #smtp_connect_timeout 30
   #运行keepalived机器的一个标识
   router_id LVS_DEVEL
}
 
#主备配置
vrrp_instance VI_1 {
    #标示状态为MASTER 备份机为BACKUP
    state MASTER
    #设置keepalived实例绑定的服务器网卡，一般为eth0，linux使用ifconfig命令可查看当前服务器网卡标识名
    interface eth0
    #同一实例下（即同一组主备机下）virtual_router_id必须相同
    virtual_router_id 51
    #MASTER权重要高于BACKUP，MASTER为100则BACKUP最大为99
    priority 100
    #MASTER与BACKUP负载均衡器之间同步检查的时间间隔，单位是秒，设置为1秒
    advert_int 1
    #设置认证
    authentication {
        #主从服务器验证方式，PASS为明文密码验证
        auth_type PASS
        #密码
        auth_pass 1111
    }
    #设置虚拟IP，与我们的主备机在同一网段下，最后一位随便给就是拉，可以设置多个，换行即可
    virtual_ipaddress {
        192.168.50.88
    }
}

备机192.168.50.135的keepalived配置：

备机配置注意的地方：需要修改state为BACKUP , priority比MASTER低，virtual_router_id和master的值一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
! Configuration File for keepalived
 
#这是全局配置
global_defs {
   #指定keepalived在发生切换时需要发送email到的对象，一行一个
   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   }
   #指定发件人
   notification_email_from Alexandre.Cassen@firewall.loc
   #指定smtp服务器地址
   #smtp_server 192.168.200.1
   #指定smtp连接超时时间
   #smtp_connect_timeout 30
   #运行keepalived机器的一个标识
   router_id LVS_DEVEL
}
 
#主备配置
vrrp_instance VI_1 {
    #备机为BACKUP
    state BACKUP
    #备机网卡标识，一般都是eth0，先查询一下
    interface eth0
    #virtual_router_id必须与主机相同
    virtual_router_id 51
    #权重，备机必须比主机小
    priority 99
    #MASTER与BACKUP负载均衡器之间同步检查的时间间隔，单位是秒，设置为1秒
    advert_int 1
    #认证，与主机一致
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    #虚拟IP，绑定的虚拟ip与主机一致
    virtual_ipaddress {
        192.168.50.135
    }
}

酱紫，keepalived就配置完成了。

keeplived启动关闭命令：

1
service keepalived start``service keepalived stop

启动两台nginx，启动主机keepalived，启动备机keepalived服务。

这时，nginx主机在提供服务，备机是闲着的，虚拟ip是192.168.50.88，在主机和备机上使用命令

1
ip addr

可以发现：

主机：可以看到，192.168.50.133 带有虚拟ip192.168.50.88，在浏览器中输入192.168.50.88，即可访问到主nginx192.168.50.133.然后转发到tomcat服务器上

img

浏览器访问虚拟ip：192.168.50.88，效果如下

img

备机：ip addr命令执行：可以看到，备机nginx没有绑定虚拟ip

img

以上是初始状态下的情况，也是正常服务的情况。

现在测试高可用，假设主机nginx服务器挂了，模拟为关闭nginx主机或者将keepalived服务停止，那么主机上keepalived死了就没办法告诉备机自己活着，而备机超过1秒没有接收到主机给自己的消息，马上接管虚拟ip，同时在配置文件中配置切换主备机时发送邮件，此时开发团队收到邮件即知道主机挂了，马上去排除主机的故障。

将主机上的keepalived服务停止，service keepalived stop ,然后查看虚拟ip绑定情况，

主机挂了：可以看到虚拟ip就没有绑在主机上

img

备机情况：虚拟ip已经绑定到备机，此时主机虽然挂了，但是切换到备机上了（发现故障和切换的时间差最大也就是1秒），虚拟ip也绑到备机上了，访问虚拟ip，就会请求备机nginx然后转发到web服务器实现高可用。

img

运维人员收到邮件后就去排除主机故障了，搞定之后（模拟为keepalived服务启动），这时主机告诉备机，我又活了，于是备机将管理权又交给主机（切换为主机nginx提供服务）：

主机keepalived服务启动后，即吧主机维护好之后：可以看到，虚拟ip又自动绑到了主机上

img

备机情况，主机活了之后，备机转交管理权，虚拟ip切换到主机上，备机不绑定虚拟ip,貌似启动keepalived服务之后并不能马上切回，应该是起服务需要点时间吧，但是不影响，这段时间还是备机绑定虚拟IP的

img

这就是keepalived高可用的模拟。

注意问题：

主机挂了之后，主机nginx恢复时，一定要将nginx也启动，否则即使虚拟ip切换到了主机上，但是主机nginx没起那也是没法转发的。所以要把\nginx启动要加在开机启动中。****

Nginx服务开机自启动

在linux系统的/etc/init.d/目录下创建nginx文件，使用如下命令：（vim命令不会的自己去学吧哈哈）

1
vi /etc/init.d/nginx

将如下内容搞到该文件中:注意红色部分修改成你的路径即可，nginxd值是启动nginx的nginx路径，nginx_config值是nginx配置文件nginx.conf路径，nginx_pid值是nginx.pid所在路径，如果按照我方法安装的话，是在nginx安装目录的logs里边的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#!/bin/bash
# nginx Startup script for the Nginx HTTP Server
# it is v.0.0.2 version.
# chkconfig: - 85 15
# description: Nginx is a high-performance web and proxy server.
#              It has a lot of features, but it's not for everyone.
# processname: nginx
# pidfile: /usr/local/nginx/logs/nginx.pid
# config: /usr/local/nginx/conf/nginx.conf
nginxd=/usr/local/nginx/sbin/nginx
nginx_config=/usr/local/nginx/conf/nginx.conf
nginx_pid=/usr/local/nginx/logs/nginx.pid
RETVAL=0
prog="nginx"
# Source function library.
. /etc/rc.d/init.d/functions
# Source networking configuration.
. /etc/sysconfig/network
# Check that networking is up.
[ ${NETWORKING} = "no" ] && exit 0
[ -x $nginxd ] || exit 0
# Start nginx daemons functions.
start() {
if [ -e $nginx_pid ];then
   echo "nginx already running...."
   exit 1
fi
   echo -n $"Starting $prog: "
   daemon $nginxd -c ${nginx_config}
   RETVAL=$?
   echo
   [ $RETVAL = 0 ] && touch /var/lock/subsys/nginx
   return $RETVAL
}
# Stop nginx daemons functions.
stop() {
        echo -n $"Stopping $prog: "
        killproc $nginxd
        RETVAL=$?
        echo
        [ $RETVAL = 0 ] && rm -f /var/lock/subsys/nginx /var/run/nginx.pid
}
# reload nginx service functions.
reload() {
    echo -n $"Reloading $prog: "
    #kill -HUP `cat ${nginx_pid}`
    killproc $nginxd -HUP
    RETVAL=$?
    echo
}
# See how we were called.
case "$1" in
start)
        start
        ;;
stop)
        stop
        ;;
reload)
        reload
        ;;
restart)
        stop
        start
        ;;
status)
        status $prog
        RETVAL=$?
        ;;
*)
        echo $"Usage: $prog {start|stop|restart|reload|status|help}"
        exit 1
esac
exit $RETVAL

然后设置该文件的访问权限：执行以下命令，意为所有用户可访问

1
chmod a+x /etc/init.d/nginx

最后将ngix加入到rc.local文件中，这样开机的时候nginx就默认启动了

1
vi /etc/rc.local

添加

1
/etc/init.d/nginx start

img

保存并退出，下次重启就会生效，nginx的开机自启动。测试无误的。

解决nginx进程和keepalived不同时存在问题

keepalived是通过检测keepalived进程是否存在判断服务器是否宕机，如果keepalived进程在，但是nginx进程不在了，那么keepalived是不会做主备切换。因为是nginx挂了，然后无法做代理，keepalived还在不会切换到备机。

所以一直检测nginx是否还在，如果不在，那么让keepalived也停止，同生共死。

注：只需要在主机上搞就行了，备机没必要检测nginx，因为基本是主机在服务。

解决：写个脚本来监控nginx进程是否存在，如果nginx不存在就将keepalived进程杀掉。

注：keepalived不需要开机启动，假如开机自启的话，如果keepalived比nginx 更快启动的话，脚本检测会把keepalived停掉的，所以没必要，只需要nginx开机启动，启动主机后自行手动的把keepalived服务启动即可。

在主nginx上编写nginx进程检测脚本（check_nginx_dead.sh）,在keepalived配置文件目录下创建脚本:

1
vi /etc/keepalived/check_nginx_dead.sh

把下边这些内容搞到脚本文件中，内容如下：

1
2
3
4
5
6
#!/bin/bash
# 如果进程中没有nginx则将keepalived进程kill掉
A=`ps -C nginx --no-header |wc -l`      ## 查看是否有 nginx进程 把值赋给变量A
if [ $A -eq 0 ];then                    ## 如果没有进程值得为 零
       service keepalived stop          ## 则结束 keepalived 进程
fi

给访问权限：不然不行哦，这里卡了我半小时

1
chmod a+x /etc/keepalived/check_nginx_dead.sh

先测试一下脚本：

把nginx停了，此时keepalived还在运行，所以不会切换，虚拟ip无法访问到web服务器

img

然后执行脚本：

主机脚本检测nginx不在了，把keepalived停掉，从输出可以看到确实停止了，主机虚拟没有绑定虚拟ip

img

备机：成功绑定虚拟ip

img

所以，只需要让该脚本一直执行，即一直检测nginx进程是否在，如果没得了，那么直接停止主机keepalived，切换备机，保证能够访问web服务器。

按如下修改keepalived配置文件keepalived.conf，添加脚本定义检测：

只需要在正确的位置添加红色部分即可：那么脚本则是两秒执行一次，一旦发现主机nginx不在了，keepalived停止，切换备机

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
! Configuration File for keepalived
 
#这是全局配置
global_defs {
   #指定keepalived在发生切换时需要发送email到的对象，一行一个
   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   }
   #指定发件人
   notification_email_from Alexandre.Cassen@firewall.loc
   #指定smtp服务器地址
   #smtp_server 192.168.200.1
   #指定smtp连接超时时间
   #smtp_connect_timeout 30
   #运行keepalived机器的一个标识
   router_id LVS_DEVEL
}
 
vrrp_script check_nginx_dead {
    ##监控脚本路径
    script "/etc/keepalived/check_nginx_dead.sh"
    ##时间间隔，2秒
    interval 2
    ##权重
    weight 2                                            
}
 
#主备配置
vrrp_instance VI_1 {
    #标示状态为MASTER 备份机为BACKUP
    state MASTER
    #设置keepalived实例绑定的服务器网卡，一般为eth0，linux使用ifconfig命令可查看当前服务器网卡标识名
    interface eth0
    #同一实例下（即同一组主备机下）virtual_router_id必须相同
    virtual_router_id 51
    #MASTER权重要高于BACKUP，MASTER为100则BACKUP最大为99
    priority 100
    #MASTER与BACKUP负载均衡器之间同步检查的时间间隔，单位是秒，设置为1秒
    advert_int 1
    #设置认证
    authentication {
    #主从服务器验证方式，PASS为明文密码验证
        auth_type PASS
    #密码
        auth_pass 1111
    }
     
    track_script {
    #监控脚本
        check_nginx_dead     
    }
     
    #设置虚拟IP，与我们的主备机在同一网段下，最后一位随便给就是拉，可以设置多个，换行即可
    virtual_ipaddress {
        192.168.50.88
    }
}

保存后，重新启动主机keepalived服务即可。

测试：

回到负载均衡高可用的初始状态，保证主、备上的keepalived、nginx全部启动。

停止主nginx服务：

主机查看keepalived进程，发现没有，说明已经停止了，虚拟ip也没有绑在主机上

img

备机：绑定虚拟ip，切换成功。

img

测试通过，如果主机nginx挂了之后，keepalived也会随着挂掉，然后切换备机。

nginx.conf配置文件详解

Nginx 配置文件主要分成四部分：main（全局设置）、server（主机设置）、upstream（上游服务器设置，主要为反向代理、负载均衡相关配置）和 location（URL匹配特定位置后的设置）。main 部分设置的指令影响其他所有部分的设置；server 部分的指令主要用于制定虚拟主机域名、IP 和端口号；upstream 的指令用于设置一系列的后端服务器，设置反向代理及后端服务器的负载均衡；location 部分用于匹配网页位置（比如，根目录“/”，“/images”，等等）。他们之间的关系：server 继承 main，location 继承 server；upstream 既不会继承指令也不会被继承。

当前 nginx 支持的几个指令上下文()：

nginx.conf 配置文件

下面是 nginx.conf 详细的配置文件介绍（以下配置参数很多时候并不一定用的到，只是作为配置参数说明参考，可以看下面的通用版介绍）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
#定义Nginx运行的用户和用户组
user www www; 

#nginx进程数，通常设置成和cpu的数量相等
worker_processes 4; 

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


#进程pid文件
#pid        logs/nginx.pid;


#指定进程可以打开的最大描述符：数目
#工作模式与连接数上限
##这个指令是指当一个nginx进程打开的最多文件描述符数目，理论值应该是最多打开文件数（ulimit -n）与nginx进程数相除，但是nginx分配请求并不是那么均匀，所以最好与ulimit -n 的值保持一致。
#这是因为nginx调度时分配请求到进程并不是那么的均衡，所以假如填写10240，总并发量达到3-4万时就有进程可能超过10240了，这时会返回502错误。
worker_rlimit_nofile 65535;


events {
    #参考事件模型，use [ kqueue | rtsig | epoll | /dev/poll | select | poll ]; epoll模型
    #是Linux 2.6以上版本内核中的高性能网络I/O模型，linux建议epoll，如果跑在FreeBSD上面，就用kqueue模型。
    #补充说明：
    #与apache相类，nginx针对不同的操作系统，有不同的事件模型
    #A）标准事件模型
    #Select、poll属于标准事件模型，如果当前系统不存在更有效的方法，nginx会选择select或poll
    #B）高效事件模型
    #Kqueue：使用于FreeBSD 4.1+, OpenBSD 2.9+, NetBSD 2.0 和 MacOS X.使用双处理器的MacOS X系统使用kqueue可能会造成内核崩溃。
    #Epoll：使用于Linux内核2.6版本及以后的系统。
    #/dev/poll：使用于Solaris 7 11/99+，HP/UX 11.22+ (eventport)，IRIX 6.5.15+ 和 Tru64 UNIX 5.1A+。
    #Eventport：使用于Solaris 10。 为了防止出现内核崩溃的问题， 有必要安装安全补丁。
    use epoll
    
    
    #单个进程最大连接数（最大连接数=连接数+进程数）
    #根据硬件调整，和前面工作进程配合起来用，尽量大，但是别把cup跑到100%就行。
    worker_connections  1024;
    
    #keepalive 超时时间
    keepalive_timeout 60;
    
    #客户端请求头部的缓冲区大小。这个可以根据你的系统分页大小来设置，一般一个请求头的大小不会超过1k，不过由于一般系统分页都要大于1k，所以这里设置为分页大小。
    #分页大小可以用命令getconf PAGESIZE 取得。
    #[root@web001 ~]# getconf PAGESIZE
    #但也有client_header_buffer_size超过4k的情况，但是client_header_buffer_size该值必须设置为“系统分页大小”的整倍数。
    client_header_buffer_size 4k;
    
    #这个将为打开文件指定缓存，默认是没有启用的，max指定缓存数量，建议和打开文件数一致，inactive是指经过多长时间文件没被请求后删除缓存。
    open_file_cache max=65535 inactive=60s;
    
    
    #这个是指多长时间检查一次缓存的有效信息。
    #语法:open_file_cache_valid time 默认值:open_file_cache_valid 60 使用字段:http, server, location 这个指令指定了何时需要检查open_file_cache中缓存项目的有效信息.
    open_file_cache_valid 80s;
    
    
    #open_file_cache指令中的inactive参数时间内文件的最少使用次数，如果超过这个数字，文件描述符一直是在缓存中打开的，如上例，如果有一个文件在inactive时间内一次没被使用，它将被移除。
    #语法:open_file_cache_min_uses number 默认值:open_file_cache_min_uses 1 使用字段:http, server, location  这个指令指定了在open_file_cache指令无效的参数中一定的时间范围内可以使用的最小文件数,如果使用更大的值,文件描述符在cache中总是打开状态.
    open_file_cache_min_uses 1;
    
    #语法:open_file_cache_errors on | off 默认值:open_file_cache_errors off 使用字段:http, server, location 这个指令指定是否在搜索一个文件是记录cache错误.
    open_file_cache_errors on;
}


#设定http服务器，利用它的反向代理功能提供负载均衡支持
http{
    #文件扩展名与文件类型映射表
    include mime.types;
    
    #默认文件类型
    default_type application/octet-stream;
    
    #默认编码
    charset utf-8;
    
    #服务器名字的hash表大小
    #保存服务器名字的hash表是由指令server_names_hash_max_size 和server_names_hash_bucket_size所控制的。参数hash bucket size总是等于hash表的大小，并且是一路处理器缓存大小的倍数。在减少了在内存中的存取次数后，使在处理器中加速查找hash表键值成为可能。如果hash bucket size等于一路处理器缓存的大小，那么在查找键的时候，最坏的情况下在内存中查找的次数为2。第一次是确定存储单元的地址，第二次是在存储单元中查找键 值。因此，如果Nginx给出需要增大hash max size 或 hash bucket size的提示，那么首要的是增大前一个参数的大小.
    server_names_hash_bucket_size 128;
    
    #客户端请求头部的缓冲区大小。这个可以根据你的系统分页大小来设置，一般一个请求的头部大小不会超过1k，不过由于一般系统分页都要大于1k，所以这里设置为分页大小。分页大小可以用命令getconf PAGESIZE取得。
    client_header_buffer_size 32k;
    
    #客户请求头缓冲大小。nginx默认会用client_header_buffer_size这个buffer来读取header值，如果header过大，它会使用large_client_header_buffers来读取。
    large_client_header_buffers 4 64k;
    
    #设定通过nginx上传文件的大小
    client_max_body_size 8m;
    
    #开启高效文件传输模式，sendfile指令指定nginx是否调用sendfile函数来输出文件，对于普通应用设为 on，如果用来进行下载等应用磁盘IO重负载应用，可设置为off，以平衡磁盘与网络I/O处理速度，降低系统的负载。注意：如果图片显示不正常把这个改成off。
    #sendfile指令指定 nginx 是否调用sendfile 函数（zero copy 方式）来输出文件，对于普通应用，必须设为on。如果用来进行下载等应用磁盘IO重负载应用，可设置为off，以平衡磁盘与网络IO处理速度，降低系统uptime。
    sendfile on;
    
     #开启目录列表访问，合适下载服务器，默认关闭。
    autoindex on;
    
      #此选项允许或禁止使用socke的TCP_CORK的选项，此选项仅在使用sendfile的时候使用
    tcp_nopush on;
     
    tcp_nodelay on;
    
    #长连接超时时间，单位是秒
    keepalive_timeout 120;
    
    #FastCGI相关参数是为了改善网站的性能：减少资源占用，提高访问速度。下面参数看字面意思都能理解。
    fastcgi_connect_timeout 300;
    fastcgi_send_timeout 300;
    fastcgi_read_timeout 300;
    fastcgi_buffer_size 64k;
    fastcgi_buffers 4 64k;
    fastcgi_busy_buffers_size 128k;
    fastcgi_temp_file_write_size 128k;
    
    #gzip模块设置
    gzip on; #开启gzip压缩输出
    gzip_min_length 1k;    #最小压缩文件大小
    gzip_buffers 4 16k;    #压缩缓冲区
    gzip_http_version 1.0; #压缩版本（默认1.1，前端如果是squid2.5请使用1.0）
    gzip_comp_level 2;     #压缩等级
    gzip_types text/plain application/x-javascript text/css application/xml;    #压缩类型，默认就已经包含textml，所以下面就不用再写了，写上去也不会有问题，但是会有一个warn。
    gzip_vary on;

    #开启限制IP连接数的时候需要使用
    #limit_zone crawler $binary_remote_addr 10m;
    
    
    #负载均衡配置
    upstream piao.jd.com {
     
        #upstream的负载均衡，weight是权重，可以根据机器配置定义权重。weigth参数表示权值，权值越高被分配到的几率越大。
        server 192.168.80.121:80 weight=3;
        server 192.168.80.122:80 weight=2;
        server 192.168.80.123:80 weight=3;

        #nginx的upstream目前支持4种方式的分配
        #1、轮询（默认）
        #每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。
        #2、weight
        #指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况。
        #例如：
        #upstream bakend {
        #    server 192.168.0.14 weight=10;
        #    server 192.168.0.15 weight=10;
        #}
        #2、ip_hash
        #每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题。
        #例如：
        #upstream bakend {
        #    ip_hash;
        #    server 192.168.0.14:88;
        #    server 192.168.0.15:80;
        #}
        #3、fair（第三方）
        #按后端服务器的响应时间来分配请求，响应时间短的优先分配。
        #upstream backend {
        #    server server1;
        #    server server2;
        #    fair;
        #}
        #4、url_hash（第三方）
        #按访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，后端服务器为缓存时比较有效。
        #例：在upstream中加入hash语句，server语句中不能写入weight等其他的参数，hash_method是使用的hash算法
        #upstream backend {
        #    server squid1:3128;
        #    server squid2:3128;
        #    hash $request_uri;
        #    hash_method crc32;
        #}

        #tips:
        #upstream bakend{#定义负载均衡设备的Ip及设备状态}{
        #    ip_hash;
        #    server 127.0.0.1:9090 down;
        #    server 127.0.0.1:8080 weight=2;
        #    server 127.0.0.1:6060;
        #    server 127.0.0.1:7070 backup;
        #}
        #在需要使用负载均衡的server中增加 proxy_pass http://bakend/;

        #每个设备的状态设置为:
        #1.down表示单前的server暂时不参与负载
        #2.weight为weight越大，负载的权重就越大。
        #3.max_fails：允许请求失败的次数默认为1.当超过最大次数时，返回proxy_next_upstream模块定义的错误
        #4.fail_timeout:max_fails次失败后，暂停的时间。
        #5.backup： 其它所有的非backup机器down或者忙的时候，请求backup机器。所以这台机器压力会最轻。

        #nginx支持同时设置多组的负载均衡，用来给不用的server来使用。
        #client_body_in_file_only设置为On 可以讲client post过来的数据记录到文件中用来做debug
        #client_body_temp_path设置记录文件的目录 可以设置最多3层目录
        #location对URL进行匹配.可以进行重定向或者进行新的代理 负载均衡
    }
    
    
    #虚拟主机的配置
    server {
        #监听端口
        listen 80;

        #域名可以有多个，用空格隔开
        server_name www.jd.com jd.com;
        #默认入口文件名称
        index index.html index.htm index.php;
        root /data/www/jd;

        #对******进行负载均衡
        location ~ .*.(php|php5)?$
        {
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_index index.php;
            include fastcgi.conf;
        }
         
        #图片缓存时间设置
        location ~ .*.(gif|jpg|jpeg|png|bmp|swf)$
        {
            expires 10d;
        }
         
        #JS和CSS缓存时间设置
        location ~ .*.(js|css)?$
        {
            expires 1h;
        }
         
        #日志格式设定
        #$remote_addr与$http_x_forwarded_for用以记录客户端的ip地址；
        #$remote_user：用来记录客户端用户名称；
        #$time_local： 用来记录访问时间与时区；
        #$request： 用来记录请求的url与http协议；
        #$status： 用来记录请求状态；成功是200，
        #$body_bytes_sent ：记录发送给客户端文件主体内容大小；
        #$http_referer：用来记录从那个页面链接访问过来的；
        #$http_user_agent：记录客户浏览器的相关信息；
        #通常web服务器放在反向代理的后面，这样就不能获取到客户的IP地址了，通过$remote_add拿到的IP地址是反向代理服务器的iP地址。反向代理服务器在转发请求的http头信息中，可以增加x_forwarded_for信息，用以记录原有客户端的IP地址和原来客户端的请求的服务器地址。
        log_format access '$remote_addr - $remote_user [$time_local] "$request" '
        '$status $body_bytes_sent "$http_referer" '
        '"$http_user_agent" $http_x_forwarded_for';
         
        #定义本虚拟主机的访问日志
        access_log  /usr/local/nginx/logs/host.access.log  main;
        access_log  /usr/local/nginx/logs/host.access.404.log  log404;
         
        #对 "/connect-controller" 启用反向代理
        location /connect-controller {
            proxy_pass http://127.0.0.1:88; #请注意此处端口号不能与虚拟主机监听的端口号一样（也就是server监听的端口）
            proxy_redirect off;
            proxy_set_header X-Real-IP $remote_addr;
             
            #后端的Web服务器可以通过X-Forwarded-For获取用户真实IP
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
             
            #以下是一些反向代理的配置，可选。
            proxy_set_header Host $host;

            #允许客户端请求的最大单文件字节数
            client_max_body_size 10m;

            #缓冲区代理缓冲用户端请求的最大字节数，
            #如果把它设置为比较大的数值，例如256k，那么，无论使用firefox还是IE浏览器，来提交任意小于256k的图片，都很正常。如果注释该指令，使用默认的client_body_buffer_size设置，也就是操作系统页面大小的两倍，8k或者16k，问题就出现了。
            #无论使用firefox4.0还是IE8.0，提交一个比较大，200k左右的图片，都返回500 Internal Server Error错误
            client_body_buffer_size 128k;

            #表示使nginx阻止HTTP应答代码为400或者更高的应答。
            proxy_intercept_errors on;

            #后端服务器连接的超时时间_发起握手等候响应超时时间
            #nginx跟后端服务器连接超时时间(代理连接超时)
            proxy_connect_timeout 90;

            #后端服务器数据回传时间(代理发送超时)
            #后端服务器数据回传时间_就是在规定时间之内后端服务器必须传完所有的数据
            proxy_send_timeout 90;

            #连接成功后，后端服务器响应时间(代理接收超时)
            #连接成功后_等候后端服务器响应时间_其实已经进入后端的排队之中等候处理（也可以说是后端服务器处理请求的时间）
            proxy_read_timeout 90;

            #设置代理服务器（nginx）保存用户头信息的缓冲区大小
            #设置从被代理服务器读取的第一部分应答的缓冲区大小，通常情况下这部分应答中包含一个小的应答头，默认情况下这个值的大小为指令proxy_buffers中指定的一个缓冲区的大小，不过可以将其设置为更小
            proxy_buffer_size 4k;

            #proxy_buffers缓冲区，网页平均在32k以下的设置
            #设置用于读取应答（来自被代理服务器）的缓冲区数目和大小，默认情况也为分页大小，根据操作系统的不同可能是4k或者8k
            proxy_buffers 4 32k;

            #高负荷下缓冲大小（proxy_buffers*2）
            proxy_busy_buffers_size 64k;

            #设置在写入proxy_temp_path时数据的大小，预防一个工作进程在传递文件时阻塞太长
            #设定缓存文件夹大小，大于这个值，将从upstream服务器传
            proxy_temp_file_write_size 64k;
        }
        
        #本地动静分离反向代理配置
        #所有jsp的页面均交由tomcat或resin处理
        location ~ .(jsp|jspx|do)?$ {
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_pass http://127.0.0.1:8080;
        }
    }
}