在CentOS上使用Nginx和Tomcat搭建高可用高并发网站

夜雨飘零

发布于 2020-05-06 11:46:12

1.2K0

发布于 2020-05-06 11:46:12

文章被收录于专栏：CSDN博客CSDN博客

原文博客：Doi技术团队链接地址：https://blog.doiduoyi.com/authors/1584446358138 初心：记录优秀的Doi技术团队学习经历

前言

本篇文章将介绍如何搭建使用Nginx和Tomcat的高可用高并发的网站，我们将会在CentOS系统上搭建这样一个网站后端。这个系统的架构如下：

虚拟IP地址：192.168.204.221
主虚拟服务器：192.168.204.121
备虚拟服务器：192.168.204.122
Nginx服务器1：192.168.204.123
Nginx服务器2：192.168.204.124
Tomcat服务器1：192.168.204.123
Tomcat服务器2：192.168.204.124

创建CentOS虚拟机

我们这次安装的虚拟机是CentOS迷你版，镜像为：CentOS-6.5-x86_64-minimal.iso，该镜像可以到这里下载：http://vault.centos.org/6.5/isos/x86_64/CentOS-6.5-x86_64-minimal.iso。参考笔者的这一篇文章CentOS搭建云服务平台的前半部分创建4个CentOS虚拟机，用来模仿后台的多个系统，要注意的是这篇文章CentOS搭建云服务平台安装的的桌面版，我们在本文章用的迷你版，但是安装步骤差不多，可以参考b部分的安装操作。关于创建CentOS虚拟机就不用重复介绍了，主要是说明这四个虚拟机的网络配置。当然读者的网段跟读者的可能不一样，所以读者要根据自己的情况配置网络。

node1的网络配置：

DEVICE=eth0
TYPE=Ethernet
ONBOOT=yes
NM_CONTROLLED=yes
BOOTPROTO=static
IPADDR=192.168.204.121
NETMASK=255.255.255.0
GATEWAY=192.168.204.2

node2的网络配置：

DEVICE=eth0
TYPE=Ethernet
ONBOOT=yes
NM_CONTROLLED=yes
BOOTPROTO=static
IPADDR=192.168.204.122
NETMASK=255.255.255.0
GATEWAY=192.168.204.2

node3的网络配置：

DEVICE=eth0
TYPE=Ethernet
ONBOOT=yes
NM_CONTROLLED=yes
BOOTPROTO=static
IPADDR=192.168.204.123
NETMASK=255.255.255.0
GATEWAY=192.168.204.2

node4的网络配置：

DEVICE=eth0
TYPE=Ethernet
ONBOOT=yes
NM_CONTROLLED=yes
BOOTPROTO=static
IPADDR=192.168.204.124
NETMASK=255.255.255.0
GATEWAY=192.168.204.2

安装Nginx

接下来是安装Nginx服务器，这个也是一个完整的服务器，可以当做普通的网站服务器。但是在这个结构中，我们是使用它来做反向代理，使它代理更多的Tomcat，在起分流的同时，也有高可用的作用，因为就算一个Nginx服务器泵机了，还有其他的运行。我们在node3和node4的虚拟机下安装Nginx。

安装Nginx之前，先要安装依赖库：

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

如果没有安装wget命令，要先安装这个命令，因为下面会用到这个命令：

yum -y install wget

下载Nginx并放在/opt下：

cd /opt
wget http://tengine.taobao.org/download/tengine-2.1.0.tar.gz

解压Nginx压缩包：

tar -zxvf tengine-2.1.0.tar.gz

进入到刚才解压得到的文件夹tengine-2.1.0，开始配置tengine，配置命令如下：

./configure \
  --prefix=/opt/sxt/soft/tengine-2.1.0/ \
  --error-log-path=/var/log/nginx/error.log \
  --http-log-path=/var/log/nginx/access.log \
  --pid-path=/var/run/nginx/nginx.pid  \
  --lock-path=/var/lock/nginx.lock \
  --with-http_ssl_module \
  --with-http_flv_module \
  --with-http_stub_status_module \
  --with-http_gzip_static_module \
  --http-client-body-temp-path=/var/tmp/nginx/client/ \
  --http-proxy-temp-path=/var/tmp/nginx/proxy/ \
  --http-fastcgi-temp-path=/var/tmp/nginx/fcgi/ \
  --http-uwsgi-temp-path=/var/tmp/nginx/uwsgi \
  --http-scgi-temp-path=/var/tmp/nginx/scgi \
  --with-pcre

配置完成之后，开始安装，执行安装之后，tengine会安装在/opt/sxt/soft/tengine-2.1.0/目录下：

make && make install

使用vim命令创建一个文件/etc/init.d/nginx用于启动服务的，并添加以下内容：

#!/bin/bash
#
# chkconfig: - 85 15
# description: nginx is a World Wide Web server. It is used to serve
# Source function library.
. /etc/rc.d/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

# Check that networking is up.
[ "$NETWORKING" = "no" ] && exit 0

nginx="/opt/sxt/soft/tengine-2.1.0/sbin/nginx"
prog=$(basename $nginx)

NGINX_CONF_FILE="/opt/sxt/soft/tengine-2.1.0/conf/nginx.conf"

#[ -f /etc/sysconfig/nginx ] && . /etc/sysconfig/nginx

lockfile=/var/lock/subsys/nginx


start() {
    [ -x $nginx ] || exit 5
    [ -f $NGINX_CONF_FILE ] || exit 6
    echo -n $"Starting $prog: "
    daemon $nginx -c $NGINX_CONF_FILE
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    killproc $prog -QUIT
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}

restart() {
    configtest || return $?
    stop
    sleep 1
    start
}

reload() {
    configtest || return $?
    echo -n $"Reloading $prog: "
#  -HUP是nginx平滑重启参数  
    killproc $nginx -HUP
    RETVAL=$?
    echo
}

force_reload() {
    restart
}

configtest() {
  $nginx -t -c $NGINX_CONF_FILE
}

rh_status() {
    status $prog
}

rh_status_q() {
    rh_status >/dev/null 2>&1
}

case "$1" in
    start)
        rh_status_q && exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart|configtest)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
            ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
        exit 2
esac

然后对刚才创建的文件分配权限：

chmod +x /etc/init.d/nginx

添加该文件到系统服务中

chkconfig --add /etc/init.d/nginx

查看是否添加成功：

chkconfig --list nginx

创建一个临时目录：

mkdir -p /var/tmp/nginx/client/

启动Nginx：

service nginx start

关闭防火墙：

service iptables stop

最后输入对应的IP地址，就可以访问Nginx的网站了：

http://192.168.204.123
http://192.168.204.124

安装Tomcat

接下来就是安装我们最终的服务器，Tomcat服务器是我们真正部署网站的服务器，因为我们搭建的是一个Java web网站。所以这一部分介绍如何在CentOS下安装Tomcat。我们在node3和node4的虚拟机下安装Tomcat，理论上面Tomcat不应该是跟Nginx同一个机器的，但是由于笔者的电脑安装不了那么多的虚拟机，就暂且公用一个机器。

首先要先有Java环境，先是下载JDK：

wget --no-check-certificate --no-cookies --header "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u131-b11/d54c1d3a095b4ff2b6607d096fa80163/jdk-8u131-linux-x64.rpm

下载完成之后可以进行安装JDK：

rpm -ivh jdk-8u131-linux-x64.rpm

安装完成之后，可以使用以下命令检测安装版本，如果正常输出版本信息，那证明安装成功了：

java -version

在/opt中下载Tomcat压缩包：

cd /opt
wget http://mirrors.hust.edu.cn/apache/tomcat/tomcat-7/v7.0.88/bin/apache-tomcat-7.0.88.tar.gz

下载完成之后，要解压Tomcat：

tar -zxvf apache-tomcat-7.0.88.tar.gz

解压之后可以得到一个文件夹apache-tomcat-7.0.88，然后我们可以启动Tomcat：

cd /opt/apache-tomcat-7.0.88/bin
./startup.sh

如果需要外界访问的话，还要关闭防火墙：

service iptables stop

访问网网站：

http://192.168.204.123:8080
http://192.168.204.124:8080

安装lvs和keepalived

我们安装lvs和keepalived是为了保证高可用，首先使用l可以设置虚拟IP，这样我们就可以只需要访问一个虚拟IP就可以访问所有的服务器了。keepalived是为了保证虚拟服务器一直在运行，当主服务器挂掉了，马上就启动备用服务器，以确保网站一直正常运行。以下的操作在node1和node2下操作。

一、配置负载均衡服务器

首先安装lvs和keepalived，命令如下：

yum -y install ipvsadm keepalived

备份keepalived的配置文件，如果以后需要还可以使用：

cp -a /etc/keepalived/keepalived.conf /etc/keepalived/backup.keepalived.conf

在主的负载均衡服务器中编辑配置文件/etc/keepalived/keepalived.conf，清空里面的内容，加入以下的配置信息：

! Configuration File for keepalived

global_defs {
   notification_email {
     root@localhost   #发送提醒邮件的目标地址可有多个
     goldbin@126.com
  }
   notification_email_from test@localhost   #发送邮件的from地址，可以随意写，邮件地址不存在都无所谓
   smtp_server 127.0.0.1    #邮件服务的地址，一般写本地
   smtp_connect_timeout 30
   router_id LVS_DEVEL
}

vrrp_instance VI_1 {
    state MASTER      # MASTER 主 和 BACKUP 从
    interface eth0    #VIP需要绑定的网卡名称
    virtual_router_id 51
    priority 101      #优先级 主的优先级要高
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.204.221/24 dev eth0 label eth0:0    #设置VIP
    }
}

virtual_server 192.168.204.221 80 {    #设置虚拟lvs服务，VIP PORT
    delay_loop 6
    lb_algo rr    #调度算法wrr
    lb_kind DR    #lvs的模式
    nat_mask 255.255.255.0
    persistence_timeout 50   #同一个IP地址在50秒内lvs转发给同一个后端服务器
    protocol TCP

    real_server 192.168.204.123 80 {   #设置真实服务器的心跳机制 RID PORT
        weight 1      #权重
        HTTP_GET {    #心跳检测的方式
            url {
              path /  #心跳检查的地址
              status_code 200   #心跳检查返回的状态
            }
            connect_timeout 2    #超时时间
            nb_get_retry 3       #重复检查3次
            delay_before_retry 1 #每隔1秒钟再次检查
        }
    }
    real_server 192.168.204.124 80 {  #第二个真实服务器设置
        weight 1
        HTTP_GET {
            url {
              path /
              status_code 200
            }
            connect_timeout 2
            nb_get_retry 3
            delay_before_retry 1
        }
    }
}

在备的负载均衡服务器中同样以上的配置方式，但需要修改两个地方，一个是state设置为BACKUP，也就是备用的意思。另一个是priority，这个是优先级，需要设置比主的要低。

vrrp_instance VI_1 {
    state BACKUP      # MASTER 主 和 BACKUP 从
    interface eth0    #VIP需要绑定的网卡名称
    virtual_router_id 51
    priority 50      #优先级 主的优先级要高
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.204.221/24 dev eth0 label eth0:0    #设置VIP
    }
}

配置好keepalived之后就可以启动它了，命令如下：

service keepalived start

然后使用ipvsadm -L查看映射的IP地址，启动一会再查看，因为可能不会那么快就映射，正常的话应该输出以下信息，主备虚拟服务器都是一样：

IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
  -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
TCP  192.168.204.221:http rr persistent 50
  -> 192.168.204.123:http         Route   1      0          0         
  -> 192.168.204.124:http         Route   1      0          2

二、配置真实服务器

负载均衡服务器（虚拟服务器）设置好了，然后就可以设置真实服务器（Nginx服务器）了。通过命令输入有点麻烦，我们可以编写一个脚本，让它来帮我们处理这些。node3和node4这个两真实服务器都要配置，创建文件vim realserver.sh并添加以下信息：

#!/bin/bash
#description: Config realserver

VIP=192.168.204.221

/etc/rc.d/init.d/functions

case "$1" in
start)
       /sbin/ifconfig lo:0 $VIP netmask 255.255.255.255 broadcast $VIP
       /sbin/route add -host $VIP dev lo:0
       echo "1" >/proc/sys/net/ipv4/conf/lo/arp_ignore
       echo "2" >/proc/sys/net/ipv4/conf/lo/arp_announce
       echo "1" >/proc/sys/net/ipv4/conf/all/arp_ignore
       echo "2" >/proc/sys/net/ipv4/conf/all/arp_announce
       sysctl -p >/dev/null 2>&1
       echo "RealServer Start OK"
       ;;
stop)
       /sbin/ifconfig lo:0 down
       /sbin/route del $VIP >/dev/null 2>&1
       echo "0" >/proc/sys/net/ipv4/conf/lo/arp_ignore
       echo "0" >/proc/sys/net/ipv4/conf/lo/arp_announce
       echo "0" >/proc/sys/net/ipv4/conf/all/arp_ignore
       echo "0" >/proc/sys/net/ipv4/conf/all/arp_announce
       echo "RealServer Stoped"
       ;;
*)
       echo "Usage: $0 {start|stop}"
       exit 1
esac

exit 0

然后执行这个脚本就可以自动配置了，命令如下：

sh realserver.sh start

然后使用ifconfig查看是否有添加以下网络信息：

lo:0      Link encap:Local Loopback  
          inet addr:192.168.204.221  Mask:255.255.255.255
          UP LOOPBACK RUNNING  MTU:16436  Metric:1

安装完成之后，可以测试是否可以正常工作，如何还没启动Nginx，首先启动Nginx：

service nginx start

需要关闭防火墙：

service iptables stop

最后我们只需要通过虚拟IP地址就可以访问真实服务器了。

http://192.168.204.221

我们可以手动关闭keepalived，观察是否会自动启动备的服务器。这就是keepalived的作用，当主服务器挂了，会自动启动备虚拟服务器来指向真实服务器。

service keepalived stop

反向代理

我们希望是使用Nginx来代理更多的Tomcat服务器，来对用户进行分流，以应对高并发时对单个服务器的压力。所以我们要设置node3和node4的Nginx。

要配置这个反向代理，只要修改一个配置文件就可以了。如下：

vim /opt/sxt/soft/tengine-2.1.0/conf/nginx.conf

我们主要是添加upstream cluster1这个内容，这就是反向代理的服务器IP地址，同时也可以设置健康检查的配置信息。然后要在server中添加反向代理，还可以创建对各个代理的服务器进行健康检查location /status。其他的地方不用修改。

upstream cluster1 {
    # 服务器访问的路径，可以指定多个服务器
    server 192.168.204.123:8080;
    server 192.168.204.124:8080;

    # 健康检查
    check interval=3000 rise=2 fall=5 timeout=1000 type=http;
    check_http_send "HEAD / HTTP/1.0\r\n\r\n";
    check_http_expect_alive http_2xx http_3xx;
}

server {
    listen       80;
    server_name  localhost;

    # 根目录访问路径
    location / {
        # 指定反向代理，跟上面的名称一样cluster1
        proxy_pass http://cluster1;
        root   html;
        index  index.html index.htm;
    }

    # 健康检查路径
    location /status {
        check_status;
    }
}

修改配置文件之后，需要重启Nginx：

service nginx restart

在访问之前，要确保Tomcat是正常启动了，因为我们是反向代理了Tomcat的服务器，所以需要启动Tomcat服务器。

如果在访问路径的时候加上健康检查的路径/status，就可查看各个服务器的健康问题。

http://192.168.204.123/status
http://192.168.204.124/status

通过访问上面的地址就可以看到类似以下的页面信息：

最后我们在正常访问Nginx服务器的时候，就会访问都Tomcat服务器了。而且Nginx是访问到多个Tomcat。比如笔者只是访问其中的一个Nginx，如下：

http://192.168.204.123

上面是访问Nginx服务器的IP地址的，我们在安装lvs和keepalived这部分设置了虚拟IP，所以我们可以直接访问这个虚拟IP就可以了。最终网站只需要访问一个IP地址就可以了：

http://192.168.204.221/

部署网站

经过上面的搭建，已经组建好一个高可用高并发的的服务器，现在我们只要把Java web项目部署到Tomcat服务器就可以。接下来我们编写一个简单的实现登录的网站。

搭建数据库

我们使用的是MySQL数据库，所以我们需要先安装MySQL数据库，然后对它进行一些配置就可以使用。现在我们在node4服务器上操作。

我们可以使用以下命令查看MySQL是否安装了：

rpm -qa | grep mysql

应该会输出一下日志：

[root@localhost ~]# rpm -qa | grep mysql
mysql-libs-5.1.71-1.el6.x86_64

然后我们可以先移除这个MySQL，重新安装一个：

yum -y remove mysql-libs-5.1.71-1.el6.x86_64

移除之前的MySQL之后，可以重新安装MySQL：

yum -y install mysql-server mysql mysql-devel

最后在查看安装情况：

rpm -qa | grep mysql

正常的应该会输出以下信息：

mysql-5.1.73-8.el6_8.x86_64
mysql-libs-5.1.73-8.el6_8.x86_64
mysql-server-5.1.73-8.el6_8.x86_64
mysql-devel-5.1.73-8.el6_8.x86_64

如果已经安装了MySQL，那么我们可以直接启动MySQL：

service mysqld start

然后我们可以把MySQL服务添加到开机自动启，这样就不用每次都启动了。

chkconfig mysqld on

我们可以使用以下的命令查看是否成功添加到开机服务中了。

chkconfig --list | grep mysqld

设置MySQL数据库的密码：

mysqladmin -u root password 'root'

登录数据库，输入该命令之后还有输入数据库的密码，这个密码就是上面设置的root：

mysql -u root -p

因为我们的网站是在其他的服务器，当连接这个数据库的话，就是远程连接数据库了，所以要设置数据库支持远程连接，在登录数据库之后输入以下命令：

mysql> GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION;
mysql> FLUSH PRIVILEGES;

配置好数据库之后，就可以创建数据表了，我们在MySQL自带的test数据库上面创建一张user表。

首先我们可以使用命令查看当前有那些数据库了：

mysql> SHOW DATABASES;

以下是输出信息，可以看到有3个数据库，我们使用test数据库作为我们的项目数据库：

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| test               |
+--------------------+
3 rows in set (0.01 sec)

然后我们使用test数据库，开始创建数据表。

mysql> USE test

然后在这个数据库中创建一个user表，这个表只要两个字段。

mysql> CREATE TABLE user(`number` VARCHAR(100) NOT NULL, `password` VARCHAR(100) NOT NULL);

然后在user表中添加一条数据，方便之后的登录。

mysql> INSERT INTO user(number, password) VALUES('hello', 'world');

然后我们查询看看有没有添加成功数据：

mysql> select * from user;

可以看到已经成功添加数据了：

+--------+----------+
| number | password |
+--------+----------+
| hello  | world    |
+--------+----------+
1 row in set (0.00 sec)

编写网站项目

我们这项目比较简单，只有登录功能。虽然是简单，但是完全可以测试整个网站的运行情况了。我们主要的创建3个页面和一个Servlet，具体代码如下：

index.jsp代码，主要完成登录页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
<form action="/Test2/login" method="post">
    账号：<input type="text" name="number"><br>
    密码：<input type="password" name="password"><br>
    <button type="submit">登录</button>
</form>
</body>
</html>

success.jsp代码，主要是完成登录成功页面，可以在session中获取登录成功的用户名：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录成功</title>
</head>
<body>
<h1>登录成功，欢迎<% out.print(session.getAttribute("number"));%></h1>
</body>
</html>

fail.jsp代码，登录失败页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录失败</title>
</head>
<body>
<h1>登录失败</h1>
</body>
</html>

LoginServlet.java代码，登录验证Servlet：

package com.test.test;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@WebServlet(name = "LoginServlet",urlPatterns = {"/login"})
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ConnectionDBUtil dbUtil = new ConnectionDBUtil();
        String number = request.getParameter("number");
        String password = request.getParameter("password");
        String sql = "SELECT  * FROM user WHERE number = ? AND password = ?";
        Boolean result = false;
        try {
            PreparedStatement ps = dbUtil.getConn().prepareStatement(sql);
            ps.setString(1, number);
            ps.setString(2, password);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                result = true;
            }
            ps.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        dbUtil.closeConn();
        if (result){
            HttpSession session = request.getSession();
            session.setAttribute("number", number);
            response.sendRedirect("/Test2/success.jsp");
        }else {
            response.sendRedirect("/Test2/fail.jsp");
        }
    }
}

ConnectionDBUtil.jsp代码，主要的用于连接数据库的工具，别忘了还要导入连接数据库的jar包mysql-connector-java-5.1.46-bin.jar。我们连接数据库的node4的数据库，所以IP地址是192.168.204.124。

package com.test.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionDBUtil {
    private Connection conn= null;
    private static final String DBURL = "jdbc:mysql://192.168.204.124:3306/test";
    private static final String DBUSER = "root";
    private static final String DBPASSWD = "root";

    public ConnectionDBUtil(){
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(DBURL, DBUSER,  DBPASSWD);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public Connection getConn(){
        return conn;
    }

    public void closeConn(){
        if (conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

然后使用这些代码在开发环境上编译，得到一个war的文件或者是文件夹，然后我们把这个文件或者文件夹放在node3和node4的Tomcat服务器上，目录为/opt/apache-tomcat-7.0.88/webapps。最后可以在浏览器上访问我们的虚拟IP地址加上项目名称就可以访问到这个网站了。如下：

http://192.168.204.221/Test2/

这个是登录的页面：

这个是登录成功的页面，在这里就可以看到登录成功的用户名：

这个是登录失败的页面：

这个就是我们的网站项目，虽然是简单，但是我们已经让这个项目在我们的高可用高并发的服务器上正常运行工作了。这个已经证明我们的服务器已经可以正常工作了。

解决session一致性

现在有一个问题，就是我们的Tomcat服务器有好几个，而且都不在同一个机器上，那问题就来了。我们使用session保存了用户名，但是当我们在次访问的时候，也行不是原来的那个Tomcat服务器，那之前保存的session就不存在了，我们可以验证看看。

这个是我们的登录成功的界面，我们在登录成功之后，会把用户名保存的session中。然后在这个页面就可以查看到，但是我们通过不断刷新，可以看到用户名有时候会为空，这就是去到了其他的Tomcat服务器，也就没有了之前保存的session。

在当前登录成功的服务器上：

已经去到其他服务器了：

那么我们现在就来解决这个session一致性问题。我们是使用Redis来解决session一致性的。以下操作在node3和node4下操作。

下载session一致性的jar包，把里面的三个jar包复制到Tomcat的lib目录下，路径如下：

cd /opt/apache-tomcat-7.0.88/lib/

然后编辑server.xml配置文件，node3和node4都要操作：

vim /opt/apache-tomcat-7.0.61/conf/server.xml

第一个Tomcat的上找到Engine，然后在上面加上jvmRoute="tomcat1"，同样在第二个Tomcat加上jvmRoute="tomcat2"，如下：

    <Engine name="Catalina" defaultHost="localhost" jvmRoute="tomcat1">

      <!--For clustering, please take a look at documentation at:
          /docs/cluster-howto.html  (simple how to)
          /docs/config/cluster.html (reference documentation) -->

    <Engine name="Catalina" defaultHost="localhost" jvmRoute="tomcat2">

      <!--For clustering, please take a look at documentation at:
          /docs/cluster-howto.html  (simple how to)
          /docs/config/cluster.html (reference documentation) -->

然后编辑context.xml配置文件，node3和node4都要操作：

vim /opt/apache-tomcat-7.0.61/conf/context.xml

在<Context>和</Context>之间添加如下内容，其中host是Redis所在的服务器，笔者在node3上安装Redis，所以这里是node3的IP地址。

    <Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" />
    <Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
        host="192.168.204.123"
        port="6379"
        database="0"
        maxInactiveInterval="60" />

上面说到Redis缓存数据库，所以我们还有安装Redis缓存数据库。我们在node3上安装Redis缓存数据库。

cd /opt/
wget http://download.redis.io/releases/redis-4.0.2.tar.gz
tar -zxvf redis-4.0.2.tar.gz
cd redis-4.0.2
make
make install

安装完成之后，我们编辑vim /opt/redis-4.0.2/redis.conf这个配置文件，修改里面的bind地址，把地址改成node3的IP地址。如下：

# bind 127.0.0.1
bind 192.168.204.123

然后就可以启动Redis了，注意这里要回车两次。

/opt/redis-4.0.2/src/redis-server /opt/redis-4.0.2/redis.conf &

启动的界面如下：

[root@node3 src]# /opt/redis-4.0.2/src/redis-server /opt/redis-4.0.2/redis.conf &
[2] 4809
[1]   Done                    /opt/redis-4.0.2/src/redis-server redis.conf  (wd: /opt/redis-4.0.2)
(wd now: /opt/redis-4.0.2/src)
[root@node3 src]# 4809:C 22 Jun 16:21:13.162 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
4809:C 22 Jun 16:21:13.162 # Redis version=4.0.2, bits=64, commit=00000000, modified=0, pid=4809, just started
4809:C 22 Jun 16:21:13.162 # Configuration loaded
4809:M 22 Jun 16:21:13.165 * Increased maximum number of open files to 10032 (it was originally set to 1024).
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 4.0.2 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 4809
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

4809:M 22 Jun 16:21:13.171 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
4809:M 22 Jun 16:21:13.171 # Server initialized

最后启动Tomcat服务器就可以了，如果之前已经启动过了，需要关闭Tomcat再重新启动，node3和node4都需要。

启动之后，再重新登录，在登录成功页面无论我们如何刷新都会显示用户名，这是因为我们已经保持了每一个Tomcat的session都是一一致的。

本章是介绍网站的逻辑部分的分布式部署，要应对真实的高并发还有对数据库做分布式部署，以应对庞大的数据查询。在下一章的《CentOS下安装和使用Mycat实现分布式数据库》介绍如何在CentOS上部署分布式数据库。

注意

这里要说一下的是，我们为了方便外界可以访问到服务器的端口，我们把防火墙关闭了，但是这种是非常不安全的。所以我们可以单独开放某一端口，比如我们要开放MySQL数据库的3306端口号，操作如下：

编辑防火墙配置文件：

vim /etc/sysconfig/iptables

添加以下信息：

-A INPUT -m state --state NEW -m tcp -p tcp --dport 3306 -j ACCEPT

如下图所示：

保存退出，最后重启防火墙：

service iptables restart

开放其他端口也是同样的操作。

参考资料

https://blog.csdn.net/u010392801/article/details/52085394
https://blog.csdn.net/u012852986/article/details/52412174
https://blog.csdn.net/love_zngy/article/details/78581995
https://www.cnblogs.com/renzhicai/p/7773080.html
https://blog.csdn.net/ymf827311945/article/details/76461115

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2018-06-19 ，如有侵权请联系 cloudcommunity@tencent.com 删除

node.js

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！