Redis servidor de caché (nginx + Tomcat + MySQL + Redis dan cuenta de sesiones compartidas sesión)

A, Redis Introducción

Redis es un sistema de almacenamiento de claves-valor. Y similares memcached, es compatible con el tipo de valor almacenado relativamente más, incluyendo la cadena (string), lista (lista), conjunto (colección), zConfigurar (conjunto ordenado --- colección ordenada) y el hash (tipo de hash). Al igual que con memcached, con el fin de garantizar la eficiencia, los datos se almacenan en caché en la memoria. Redis diferencia se actualiza periódicamente datos se escriben en el disco o para modificar la operación de escribir archivo de registro adicional, e implementos maestro-esclavo (maestro-esclavo) sincronizados sobre esta base.

Redis es una base de datos de alto rendimiento clave-valor. Redis aparece, en gran medida, compensar la falta de memcacehd tienda tan clave / valor, que puede desempeñar un muy buen complemento a la base de datos relacional en algunas situaciones. Proporciona Java, C / C ++, C #, PHP, JavaScript, Perl, Objeto-C, Python, Ruby y otros clientes, muy fácil de usar.
Si las diferencias entre simple y Redis memcached hay básicamente los tres puntos siguientes:
. 1, Redis sólo son compatibles con los tipos de datos clave / valor simples, mientras que también proporciona una lista de almacenamiento, juego, zConfigurar, hachís y otras estructuras de datos.
2, redis soporte de datos de copia de seguridad, es decir, de copia de seguridad datos en modo maestro-esclavo.
3, Redis apoyo persistencia de datos, los datos en la memoria se pueden guardar en el disco, reiniciar cuando se puede cargar ser utilizado de nuevo.

En los Reid, no todos los datos se han almacenado en la memoria. Esto se compara con un memcacehd y la mayor diferencia.
Redis en caché toda la información clave, si el uso de la memoria Reid hallazgo supera un cierto umbral, se activará la operación de canje, Redis basado en “swappability = age*log(size_in_memory)”la necesidad de discos de intercambio de valor correspondientes a las claves calculadas. A continuación, la tecla correspondiente al valor persistió en el disco, y claro en la memoria. Esta característica permite que los datos se pueden almacenar redis exceden su tamaño de la memoria de la propia máquina. Por supuesto, la propia máquina de memoria debe ser capaz de mantener todos eky, debido a que estos datos no se llevan a cabo operaciones de canje.
Al leer los datos de la Redis, si la clave correspondiente al valor de la memoria de lectura no, entonces Redis necesita para cargar los datos correspondientes del archivo de intercambio, y luego regresó al solicitante.

memcached y REDIS comparación
1, la red de modelo IO
memcacehd es multi-hilo, el bloqueo no modelo de red IO multiplexa en el hilo principal y el hilo del monitor del niño trabajador, la red de conexión de rosca oyente monitor, después de recibir la solicitud, el descriptor de conexión de tubo de entrega para el subproceso de trabajo, leer y escribir IO, red de capa paquete libevent repositorio de eventos, multi-hilo modelo multi-núcleo puede jugar un papel.
Redis IO multiplexación mediante un modelo de un solo subproceso que encapsula un simple AeEvent marco de gestión de eventos, el logro principal de epoll, kqueue y seleccione, sólo para una operación simple IO, la ventaja de un solo roscado velocidad puede jugar al máximo, pero Redis también proporciona algunas funciones de cálculo simples, tales como la clasificación, la polimerización, etc., para estas operaciones, el modelo actual de una sola rosca afectará seriamente el rendimiento general, el proceso de cálculo de la CPU, están bloqueados en vivo toda la programación IO.

2, la gestión de memoria
memcacehd usando la agrupación de memoria de forma pre-asignado utilizando diferentes tamaños losa y trozo de gestión de memoria, valor seleccione el tamaño de fragmento apropiado de acuerdo con el almacenamiento.
aplicación de uso de memoria en el lugar Redis manera de almacenar datos.

3, el almacenamiento y otros aspectos
memcached sustancialmente sólo apoyos simples almacén de claves-valor, y no soportan la replicación persistente y otras funciones, además de la tecla Redis / valor, lista de soportes, set, SortedSet, hash y otras estructuras de datos.

En segundo lugar, cómo mantener la sesión de la sesión

Actualmente, con el fin de ser capaces de adaptarse a acceso a la web a gran escala, la necesidad de lograr un despliegue aplicaciones en clúster. La solución más eficaz es la carga de clúster de equilibrio y el equilibrio de carga, cada uno solicitudes de los usuarios son propensos a ser asignados al servidor no es fijo, por lo que lo primero que debe resolver la sesión unificado para asegurar que, independientemente de la petición del usuario se envía al servidor en el que podemos garantizar el uso normal de los usuarios que necesitan para poner en práctica mecanismos para el intercambio de la sesión.

En la sesión de lograr sistema de clúster uniforme tiene las siguientes varias opciones:
1, solicitud de posicionamiento preciso (sessionsticky)
por ejemplo ip de política de acceso basado en hash, es decir, las definiciones petición de usuario actual se concentran a un servidor, el servidor almacena un único tales sesión de inicio de sesión del usuario, si el tiempo de inactividad es equivalente a un único punto de despliegue se perderán, la sesión no se copia. (No se utiliza)
2, la cuota de replicación de sesiones (sessionreplication):
como Tomcat viene recurso compartido de sesión, se refiere principalmente a la entorno de clúster, sesión de sincronización entre varios servidores de aplicaciones, manteniendo la sesión, transparente exterior. Si un servidor falla, según el principio de equilibrio de carga, el programador atravesar para encontrar nodos disponibles, solicitud de distribución, ya que la sesión se ha sincronizado, se puede asegurar que la información de sesión del usuario no se pierde, la replicación de sesiones.
Las deficiencias de este programa:
deben ser completado entre el mismo tipo de middleware (por ejemplo: entre Tomcat-Tomcat)
penalización de rendimiento replicación de sesiones se incrementará rápidamente, especialmente para guardar un objeto cuando la sesión y los objetos más grande cuando los rápidos cambios en la degradación del rendimiento es más importante, va a consumir el rendimiento del sistema. Esta característica permite la expansión horizontal de la aplicación web está limitada.
los contenidos sesión de sincronización de transmisión de los miembros, hará que los cuellos de botella de tráfico de la red, incluso en el cuello de botella de la red. En gran rendimiento concurrente no es bueno.
3, basado en la caché DB intercambio de caché de sesión
compartido de sesiones basadas memcache / Redis caché, es decir, utilizando la información de sesión cacheDB tienda, el servidor de aplicaciones para aceptar la nueva información de la sesión solicitudes se almacena en la memoria caché de base de datos cuando el servidor de aplicaciones falla, se repite el planificador buscando nodos disponibles, solicitud de distribución, cuando la sesión de servidor de aplicaciones no se encuentra en la memoria del equipo, la caché de base de datos para encontrar, si lo encuentra luego se copia en la máquina, por lo que para lograr el uso compartido de sesiones y alta disponibilidad. (Recomendado)

Tres, nginx + Tomcat + + Redis sesión de darse cuenta de MySQL compartir, balanceo de carga

1, entorno del proyecto

equipo host	sistema operativo	dirección IP
nginx	CentOS 7.3	172.16.1.100
tomcat-1	CentOS 7.3	172.16.1.110
tomcat-2	CentOS 7.3	172.16.1.120
MySQL	CentOS 7.3	172.16.1.130
Redis	CentOS 7.3	172.16.1.30

2, la topología de proyecto

En esta figura, el proxy inverso Nginx hacer para lograr la separación de estática y dinámica, solicitud de cliente dinámica al servidor asignados aleatoriamente a dos Tomcat acuerdo con el peso, como Redis dos Tomcat servidor de datos de la sesión acción, Tomcat MySQL de dos bases de datos back-end.

3, la ejecución del proyecto

1, la configuración de la instalación nginx
usando nginx como un gato equilibrador de carga, tomcat sesión almacenada en los redis datos de la sesión, 7x24 efecto se puede lograr con cero tiempo de inactividad. Debido a que la sesión se almacena en Redis, por lo que no tiene que configurar Nginx dijo palo de pegar una manera Tomcat, a fin de lograr más antecedentes Tomcat equilibrio de carga.

1）安装依赖工具包：
[root@nginx ~]#  yum -y install gcc* pcre-devel openssl-devel zlib-devel make vim 
2）创建nginx程序用户组和用户：
[root@nginx ~]# groupadd -r nginx && useradd -r -g nginx -s /bin/false -M nginx
3）编译安装nginx：
[root@nginx ~]# tar zxf nginx-1.8.0.tar.gz 
[root@nginx ~]# cd nginx-1.8.0
[root@nginx nginx-1.8.0]# ./configure --prefix=/usr/local/nginx --user=nginx --group=nginx \
>  --with-http_stub_status_module --with-http_ssl_module  --with-http_dav_module  --with-http_flv_module \
>  --with-http_mp4_module --with-http_gzip_static_module --with-http_gzip_static_module \
> --with-http_addition_module --with-http_sub_module  --with-pcre  --with-http_realip_module 
[root@nginx nginx-1.8.0]# make && make install
4）优化路径并检查：
[root@nginx nginx-1.8.0]# ln -s /usr/local/nginx/sbin/nginx /usr/local/sbin/
[root@nginx nginx-1.8.0]# nginx -t
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful
5）编写nginx服务脚本：
[root@nginx nginx-1.8.0]# vim /etc/init.d/nginx
#!/bin/bash
# chkconfig: 2345 99 20
# description: Nginx Service Control Script
PROG="/usr/local/nginx/sbin/nginx"
PIDF="/usr/local/nginx/logs/nginx.pid"
case "$1" in
start)
netstat -anplt |grep ":80" &> /dev/null && pgrep "nginx" &> /dev/null
if [ $? -eq 0 ]
then
echo "Nginx service already running."
else
$PROG -t &> /dev/null
if [ $? -eq 0 ] ; then
$PROG
echo "Nginx service start success."
else
$PROG -t
fi
fi
;;
stop)
netstat -anplt |grep ":80" &> /dev/null && pgrep "nginx" &> /dev/null
if [ $? -eq 0 ]
then
kill -s QUIT $(cat $PIDF)
echo "Nginx service stop success."
else
echo "Nginx service already stop"
fi
;;
restart)
$0 stop
$0 start
;;
status)
netstat -anplt |grep ":80" &> /dev/null && pgrep "nginx" &> /dev/null
if [ $? -eq 0 ]
then
echo "Nginx service is running."
else
echo "Nginx is stop."
fi
;;
reload)
netstat -anplt |grep ":80" &> /dev/null && pgrep "nginx" &> /dev/null
if [ $? -eq 0 ]
then
$PROG -t &> /dev/null
if [ $? -eq 0 ] ; then
kill -s HUP $(cat $PIDF)
echo "reload Nginx config success."
else
$PROG -t
fi
else
echo "Nginx service is not run."
fi
;;
*)
echo "Usage: $0 {start|stop|restart|reload}"
exit 1
esac
#并加入开机自启：
[root@nginx ~]# chkconfig --add nginx
[root@nginx ~]# chkconfig nginx on
#启动nginx：
[root@nginx ~]# systemctl daemon-reload
[root@nginx ~]# systemctl start nginx
[root@nginx ~]# netstat -anput | grep nginx
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      21812/nginx: master 

6) dispuesto nginx proxy inverso (inverso equilibrador de carga + + detección salud de proxy)
Nota: módulo proxy de extremo trasero para aguas arriba web y la carga de la unión de equilibrio;
módulo nginx y el valor predeterminado de unión viene módulo de servidor backend ngx_http_upstream_module ngx_http_proxy_module para control de salud ;

[root@nginx ~]# vim /usr/local/nginx/conf/nginx.conf
Añadir los siguientes elementos de configuración http {} campo:

#load balance Settings:
        upstream  backend_tomcat {   
                server 172.16.1.110:8080 weight=1 max_fails=2 fail_timeout=10s;
                server 172.16.1.120:8080 weight=1 max_fails=2 fail_timeout=10s;
}
# http_proxy Settings:
        proxy_connect_timeout 75;   #nginx 跟后端服务器连接超时时间(代理连接超时)
        proxy_send_timeout 75;   #定义后端服务器的数据回传时间，即在规定时间之内后端服务器必须传完所有的数据，否则，nginx将断开这个连接。
        proxy_read_timeout 75;  #定义从后端服务器读取响应的超时
        proxy_buffer_size 4k;  #设置缓冲区的大小（该缓冲区大小默认等于 proxy_buffers 指令设置的一块缓冲区的大小，但它也可以被设置得更小）
        proxy_buffers 4 32k;    #为每个连接设置缓冲区的数量和每块缓冲区的大小
        proxy_busy_buffers_size 64k;  #高负荷下缓冲大小（默认大小是 proxy_buffers 指令设置单块缓冲大小的 2 倍）
        proxy_temp_file_write_size 64k;  #当缓存被代理的服务器响应到临时文件时，这个选项限制每次写临时文件的大小

参数解释：
weight：轮询权值，也是可以用在ip_hash的，默认值为1
max_fails：运行请求失败的次数，默认为1。当超过最大次数时，返回proxy_next_upstream模块定义的错误。
fail_timeout：有两层含义，以时在10s时间内最多容许2次失败；二是在经历了2次失败以后，10s时间内不分配请求到这台服务器。

En el módulo de servidor para agregar:

#proxy_pass Settings：
        location ~* \.(jsp|do)$ {   #匹配到的动态请求将进行转发
        proxy_pass http://backend_tomcat;  #请求转向 backend 定义的服务器列表，即反向代理，对应 upstream 负载均衡器。
        proxy_redirect off;  #是否定义重定向规则
        proxy_set_header Host $host;  #允许重新定义或者添加发往后端服务器的请求头
        proxy_set_header X-Real-IP $remote_addr;   #web服务器端获得用户的真实ip， 也可以通过下面的X-Forward-For获取
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;    #后端的 Web 服务器可以通过 X-Forwarded-For 获取用户真实 IP
        proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;
#增加故障转移，如果后端的服务器返回502、 504、执行超时等错误，自动将请求转发到upstream负载均衡池中的另一台服务器，实现故障转移
}

7) Reiniciar nginx reglas de servicio y cortafuegos conjunto:

[root@nginx ~]# systemctl restart nginx
[root@nginx ~]# firewall-cmd --add-port=80/tcp --permanent
success
[root@nginx ~]# firewall-cmd --reload
success

2, la instalación y despliegue de Tomcat servidor
debe estar instalado antes de instalar Tomcat JDK, JDK se proporciona kit de desarrollo de software de lenguaje java sol libre, que incluye la Máquina Virtual Java (JVM), el código fuente de Java buena escritura puede compilarse a forma java código de bytes, siempre y cuando la instalación de JDK, puede utilizar la JVM interpreta los archivos de código de bytes, lo que garantiza la plataforma de java.

1) instalación de JDK, entorno Java dispuesto (instalación de servidor tomcat1 y tomcat2)

[root@tomcat-1 ~]# tar zxf jdk-8u211-linux-x64.tar.gz
[root@tomcat-1 ~]# mv jdk1.8.0_211/ /usr/local/java
[root@tomcat-1 ~]# vim /etc/profile
export JAVA_HOME=/usr/local/java
export PATH=$JAVA_HOME/bin:$PATH
[root@tomcat-1 ~]# source /etc/profile
[root@tomcat-1 ~]# java -version  #确保java版本与当前版本一致
java version "1.8.0_211"
Java(TM) SE Runtime Environment (build 1.8.0_211-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.211-b12, mixed mode)

2) Instalación de Tomcat (tomcat1 tomcat2 servidor y la misma operación)
versión disponible Tomcat web oficial de descarga requerido: https://tomcat.apache.org

[root@tomcat-1 ~]# tar zxf apache-tomcat-8.5.35.tar.gz 
[root@tomcat-1 ~]# mv apache-tomcat-8.5.35 /usr/local/tomcat8
[root@tomcat-1 ~]# vim /etc/profile
export CATALINA_HOME=/usr/local/tomcat8
export PATH=$JAVA_HOME/bin:$CATALINA_HOME/bin:$PATH
[root@tomcat-1 ~]# source /etc/profile
#启动tomcat：
[root@tomcat-1 ~]# /usr/local/tomcat8/bin/startup.sh   
#这里只是展示启动脚本的路径，因为上边设置了环境变量，可直接执行startup.sh脚本
Using CATALINA_BASE:   /usr/local/tomcat8
Using CATALINA_HOME:   /usr/local/tomcat8
Using CATALINA_TMPDIR: /usr/local/tomcat8/temp
Using JRE_HOME:        /usr/local/java
Using CLASSPATH:       /usr/local/tomcat8/bin/bootstrap.jar:/usr/local/tomcat8/bin/tomcat-juli.jar
Tomcat started.
[root@tomcat-1 ~]# netstat -anput | grep 8080
tcp6       0      0 :::8080                 :::*                    LISTEN      15408/java
#防火墙规则配置：
[root@tomcat-1 ~]# firewall-cmd --add-port=8080/tcp --permanent
success
[root@tomcat-1 ~]# firewall-cmd --reload
success

Dos acceso de prueba Tomcat buscador de servidores #

3) Modificar tomcat perfil (tomcat1 y operación tomcat2)

[root@tomcat-1 ~]# vim /usr/local/tomcat8/conf/server.xml
#设置默认虚拟主机，并增加jvmRoute
<Engine name="Catalina" defaultHost="localhost" jvmRoute="tomcat-1">
#修改默认虚拟主机，并将网站文件路径指向/web/webapp1，在host段增加context段
 <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
                <Context docBase="/web/webapp1" path="" reloadable="true"/>   #添加该行内容

# Archivo de configuración de Tomcat-2 servidor:

#两台配置只是jvmRoute不同，其他配置保持一致：
<Engine name="Catalina" defaultHost="localhost" jvmRoute="tomcat-2">

<Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
                  <Context docBase="/web/webapp1" path="" reloadable="true"/> 

Descripción: jvmRoute es logotipo de JVM, la página es la más superior de la ficha, en el entorno de producción real, todos los antecedentes Tomcat logotipo para que sea el mismo, aquí para el experimento ilustrativo, tengo dos Tomcat cambio de logo no es lo mismo. Con el fin de verificar un buen momento y así vamos a verificar.

4) Crear un archivo de directorio de la tela y la prueba: (Tomcat-1 y la misma operación Tomcat-2)

[root@tomcat-1 ~]# mkdir -p /web/webapp1
[root@tomcat-1 ~]# vim /web/webapp1/index.jsp  #编写动态网页文件
#内容如下：
<%@page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>tomcat-1</title>   
</head>
<body>
<h1><font color="red">Session serviced by tomcat</font></h1>
<table aligh="center" border="1">
<tr>
<td>Session ID</td>
<td><%=session.getId() %></td>
<% session.setAttribute("abc","abc");%>
</tr>
<tr>
<td>Created on</td>
<td><%= session.getCreationTime() %></td>
</tr>
</table>
</body>
<html>

# Nota: Para el equilibrio de carga de prueba, tomcat-2 nodos título del archivo index.jsp cambiado a "Tomcat-2" (entorno de producción de contenidos web Tomcat servidor proporciona dos son lo mismo), lo mismo que otras configuraciones.

5) Reiniciar servicio tomct, y verificar el equilibrio de carga

#tomcat-1和tomcat-2都需要重启
[root@tomcat-1 ~]# shutdown.sh 
[root@tomcat-1 ~]# startup.sh   
[root@tomcat-1 ~]# netstat -anput | grep 8080
tcp6       0      0 :::8080                 :::*                    LISTEN      15551/java  

# Los usuarios que utilizan un navegador al acceder al servicio web nginx, verificar el equilibrio de carga:
la primera visita de los resultados:

los resultados de la segunda visita de:

De los resultados anteriores se puede ver en dos visitas, nginx a las solicitudes de acceso se distribuyen al extremo trasero tomcat-1 y Tomcat-2, la solicitud de acceso de los clientes a lograr el equilibrio de carga, pero no el mismo identificador de sesión (es decir: no implementa la sesión permanecerá), por lo que, servidor back-end provocará una gran presión.

6) Verificar chequeo de salud

#可以关掉一台tomcat主机，模拟宕机，用客户端浏览器测试访问
[root@tomcat-1 ~]# shutdown.sh   
Using CATALINA_BASE:   /usr/local/tomcat8
Using CATALINA_HOME:   /usr/local/tomcat8
Using CATALINA_TMPDIR: /usr/local/tomcat8/temp
Using JRE_HOME:        /usr/local/java
Using CLASSPATH:       /usr/local/tomcat8/bin/bootstrap.jar:/usr/local/tomcat8/bin/tomcat-juli.jar

No importa cómo se actualiza la página, ha sido tomcat2 prestación de servicios, controles de salud explicación jugó un papel, la validación es correcta.

3, los restos de sesión Tomcat configuración se consigue mediante redis

# Frontal se puede decir que el trabajo de preparación, el siguiente es el foco del proyecto.
1) montada Redis
web oficial Descarga: http://download.redis.io/releases/
[la raíz @ Redis ~] # zxf los Redis tar-4.0.14.tar.gz
[la raíz ReDiS ~ @] Redis-CD # 4.0. 14 /
[@ Redis Redis la raíz-4.0.14] # && la marca el hacer la instalación


de la figura, podemos ver fácilmente, Redis instalado / usr / local, / usr / / bin local / usr / / recurso local A continuación, incluir, / usr / local / / / usr / local / lib, / usr / local / hombre comparten directorio.

# A continuación, cambie al siguiente directorio utils, ejecute Redis inicialización install_server.sh guión, de la siguiente manera:

[root@redis redis-4.0.14]# cd utils/
[root@redis utils]# ./install_server.sh 
Welcome to the redis service installer
This script will help you easily set up a running redis server

Please select the redis port for this instance: [6379] 
Selecting default: 6379
Please select the redis config file name [/etc/redis/6379.conf] 
Selected default - /etc/redis/6379.conf
Please select the redis log file name [/var/log/redis_6379.log] 
Selected default - /var/log/redis_6379.log
Please select the data directory for this instance [/var/lib/redis/6379] 
Selected default - /var/lib/redis/6379
Please select the redis executable path [/usr/local/bin/redis-server] 
Selected config: 
Port           : 6379  
Config file    : /etc/redis/6379.conf  
Log file       : /var/log/redis_6379.log
Data dir       : /var/lib/redis/6379
Executable     : /usr/local/bin/redis-server  
Cli Executable : /usr/local/bin/redis-cli
Is this ok? Then press ENTER to go on or Ctrl-C to abort.
Copied /tmp/6379.conf => /etc/init.d/redis_6379
Installing service...
Successfully added to chkconfig!
Successfully added to runlevels 345!
Starting Redis server...
Installation successful!
#上面全部默认回车就好

A través del proceso de montaje anterior, podemos ver que después de la inicialización Redis Redis perfil para /etc/redis/6379.conf, el archivo de registro se almacena en /var/log/redis_6379.log, archivos de datos dump.rdb / var / lib / Redis bajo el directorio / 6379, el script de inicio para el /etc/init.d/redis_6379.
# Si necesita utilizar systemd, puede crear una unidad redis_6379.service archivo con el nombre en el directorio / etc / systemd / sistema.

[root@redis utils]# vim /etc/systemd/system/redis_6379.service
#内容如下：
[Unit]
Description=Redis on port 6379
[Service]
Type=forking
ExecStart=/etc/init.d/redis_6379 start
ExecStop=/etc/init.d/redis_6379 stop
[Install]
WantedBy=multi-user.target
#注：这里Type=forking是后台运行的形式

# Inicio Redis
[root @ utils Redis] # systemctl daemon-recarga
[root @ Redis utils] # systemctl permiten redis_6379.service
[root @ Redis utils] systemctl inicio redis_6379.service #

# De la gráfica podemos ver que el estado del servicio es estado de muerte, la solución es reiniciar el servicio, como se muestra a continuación:

#防火墙规则设置：
[root@redis utils]# firewall-cmd --add-port=6379/tcp --permanent
success
[root@redis utils]# firewall-cmd --reload
success

2) Configuración Redis

[root@redis ~]# vim /etc/redis/6379.conf 
#修改内容如下（去掉注释并修改）：
bind 172.16.1.30   #将redis的监听地址修改为redis主机的ip
requirepass pwd@123   #考虑到安全性，需要启动redis的密码验证功能requirepass参数。

#重新启动redis服务：
[root@redis ~]# systemctl restart redis_6379.service
[root@redis ~]# netstat -anput | grep redis
tcp        0      0 172.16.1.30:6379        0.0.0.0:*               LISTEN      12261/redis-server 

#redis perfil Una vez configurado, la operación es simple y empezar Redis (prueba), de la siguiente manera:

[root@redis ~]# redis-cli -h 172.16.1.30 -p 6379 -a pwd@123
Warning: Using a password with '-a' option on the command line interface may not be safe.
172.16.1.30:6379> keys *
(empty list or set)
172.16.1.30:6379> set name lisi
OK
172.16.1.30:6379> get name
"lisi"
172.16.1.30:6379> quit   

Los parámetros anteriores se explican:

首先我们利用redis的命令行工具redis-cli，连接redis服务器，ip是172.16.1.30（这里就以本机进行测试），端口是6379，密码是pwd@123
keys *：是查看redis所有的键值对
set nam lisi：添加一个key（name）-value（lisi）
get name：查看name这个键值的内容
quit：退出连接
#redis的其他操作命令，会在后面讲解到

Esto, todo el despliegue Redis se ha completado, la siguiente sesión de sincronización de la configuración de Tomcat.

3) Configurar Tomcat sesión de sincronización Redis (tomcat1 misma operación y tomcat2)
# descarga Tomcat-Redis-session-gestor de paquetes jar correspondientes, hay principalmente tres:

tomcat85-session-redis-1.0.jar
jedis-2.9.0.jar
commons-pool2-2.4.2.jar

① 下载完成后分别拷贝到$TOMCAT_HOME/lib目录中：
[root@tomcat-1 ~]# cp tomcat85-session-redis-1.0.jar jedis-2.9.0.jar commons-pool2-2.4.2.jar  /usr/local/tomcat8/lib/

② 修改tomcat的context.xml文件：
[root@tomcat-1 ~]# vim /usr/local/tomcat8/conf/context.xml 
添加以下内容：

La figura siguiente:

        <Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" />
        <Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
        host="172.16.1.30"   #redis主机地址
        password="pwd@123"   #redis登录密码
        port="6379"        #监听端口
        database="0"   
        maxInactiveInterval="60" />    #session的失效时间（单位s）

③ 修改完，重启tomcat：
[root@tomcat-1 ~]# shutdown.sh 
[root@tomcat-1 ~]# startup.sh 
[root@tomcat-1 ~]# netstat -anput | grep 8080
tcp6       0      0 :::8080                 :::*                    LISTEN      16931/java  

Repita Tomcat-2 en el host.

④ Verificar sesión de la sesión por unanimidad
# http://172.16.1.100/index.jsp simular el acceso del usuario a través de una página de prueba del navegador
primera visita:

La segunda visita (para actualizar la página):

Como se puede ver, respectivamente, visitó los diferentes Tomcat, pero para llegar a la sesión es el mismo, lo que indica que la sesión de la sesión para mantener el ritmo, para lograr el propósito de la agrupación.
Nota: Desde el principio tomcat6 persistencia de sesión está habilitado de configuración predeterminada, puede cerrar la persistencia sesión local, de hecho, prueba muy simple, en el archivo en el directorio conf context.xml del Tomcat, elimine la siguiente sección se configura para:

#修改前:
    <!-- Uncomment this to disable session persistence across Tomcat restarts -->
    <!--
    <Manager pathname="" />
    -->
#修改后：
    <!-- Uncomment this to disable session persistence across Tomcat restarts -->
    <Manager pathname="" />

⑤ 查看redis:
[root@redis ~]# redis-cli -h 172.16.1.30 -p 6379 -a pwd@123
Warning: Using a password with '-a' option on the command line interface may not be safe.
172.16.1.30:6379> keys *
1) "3585F7426EBBC83802C0407575FEAC72tMLrlI.tomcat-2"
2) "name"
172.16.1.30:6379> quit

Como puede verse, se ReDiS sesión a sesión celebrada en los pares tomcat2 Mantener establecidos.

4, conectado a la base de datos de configuración tomcat

La sesión de Tomcat por restos de sesión Redis resolvió este problema fuera, ahora resuelve el problema Tomcat conexión a la base de datos. (Host 172.16.1.130 como servidor de base de datos MySQL)
1) instalar el servicio MySQL (binario)

[root@mysql ~]# vim mysql5.7.sh
#!/bin/bash
rpm -qa | grep mariadb  &> /dev/null
if [ $? -eq 0 ]
then
    rpm -e mariadb-libs --nodeps
fi
tar zxf  mysql-5.7.28-linux-glibc2.12-x86_64.tar.gz 
mv mysql-5.7.28-linux-glibc2.12-x86_64 /usr/local/mysql
ln -s /usr/local/mysql/bin/* /usr/local/bin
groupadd -r mysql && useradd -r -g mysql -s /bin/false -M mysql
mkdir /usr/local/mysql/data
chown -R mysql:mysql /usr/local/mysql
cat > /etc/my.cnf <<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/usr/local/mysql/data
pid-file=/usr/local/mysql/data/mysqld.pid
log-error=/usr/local/mysql/data/mysql.err
socket=/tmp/mysql.sock
[client]
socket=/tmp/mysql.sock
EOF
mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/usr/local/mysql/data
chown -R mysql:mysql /usr/local/mysql
cd /usr/local/mysql/
cp support-files/mysql.server /etc/init.d/mysqld
chmod +x /etc/init.d/mysqld
chkconfig --add mysqld
chkconfig mysqld on
service mysqld start
mypwd=`grep password /usr/local/mysql/data/mysql.err | awk -F'root@localhost: ' '{print $2}'`
mysql -uroot -p${mypwd} -e 'alter user root@localhost identified by"123.com"' --connect-expired-password

[root@mysql ~]# sh mysql5.7.sh 
Starting MySQL. SUCCESS! 
mysql: [Warning] Using a password on the command line interface can be insecure.
[root@mysql ~]# ss -anput | grep 3306
tcp    LISTEN     0      80       :::3306                 :::*                   users:(("mysqld",pid=16753,fd=12))
#防火墙规则设置：
[root@mysql ~]# firewall-cmd --add-port=3306/tcp --permanent
success
[root@mysql ~]# firewall-cmd --reload
success

2) crear los datos en la base de datos

[root@mysql ~]# mysql -uroot -p123.com
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql> grant all on *.* to javauser@'172.16.1.%' identified by 'pwd@123';   //授权一个用户
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> flush privileges;   
Query OK, 0 rows affected (0.00 sec)

mysql> create database javadb;   //创建库
Query OK, 1 row affected (0.00 sec)

mysql> use javadb
Database changed
mysql> create table testtb(id int primary key auto_increment,
    -> name varchar(25),
    -> age int(3));   //创建表
Query OK, 0 rows affected (0.00 sec)

mysql> insert into testtb(name,age) values('zhangsan','20'),('lisi','21'),('sunqian','22');   //插入数据
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> select * from testtb;  #查看一下
+----+----------+------+
| id | name     | age  |
+----+----------+------+
|  1 | zhangsan |   20 |
|  2 | lisi     |   21 |
|  3 | sunqian  |   22 |
+----+----------+------+
3 rows in set (0.00 sec)

3) Configurar Tomcat MySQL conexión de servidor de base de datos (la misma operación dos Tomcat)

（1）下载mysql-connector-java-5.1.22-bin.jar并复制到$CATALINA_HOME/lib目录下：
[root@tomcat-1 ~]# cp mysql-connector-java-5.1.22.jar  /usr/local/tomcat8/lib/

（2）Context文件设置：
[root@tomcat-1 ~]# vim /usr/local/tomcat8/conf/context.xml

#上图在<Context>中添加的内容如下：
        <Resource name="jdbc/TestDB" auth="Container" type="javax.sql.DataSource"
        maxActive="100" maxIdle="30" maxWait="10000"
        username="javauser" password="pwd@123" driverClassName="com.mysql.jdbc.Driver"
        url="jdbc:mysql://172.16.1.130:3306/javadb"/>

(3) en el directorio / web / webapp1 / root del nuevo directorio para el archivo de configuración xml sitio de almacenamiento de conexión de base de datos MySQL Tomcat

[root@tomcat-1 ~]# mkdir /web/webapp1/WEB-INF
[root@tomcat-1 ~]# vim /web/webapp1/WEB-INF/web.xml
添加内容如下：
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">
<description>MySQL Test App</description>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/TestDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
</web-app>

#保存修改并退出，重启tomcat服务：
[root@tomcat-1 ~]# shutdown.sh 
Using CATALINA_BASE:   /usr/local/tomcat8
Using CATALINA_HOME:   /usr/local/tomcat8
Using CATALINA_TMPDIR: /usr/local/tomcat8/temp
Using JRE_HOME:        /usr/local/java
Using CLASSPATH:       /usr/local/tomcat8/bin/bootstrap.jar:/usr/local/tomcat8/bin/tomcat-juli.jar
[root@tomcat-1 ~]# startup.sh 
Using CATALINA_BASE:   /usr/local/tomcat8
Using CATALINA_HOME:   /usr/local/tomcat8
Using CATALINA_TMPDIR: /usr/local/tomcat8/temp
Using JRE_HOME:        /usr/local/java
Using CLASSPATH:       /usr/local/tomcat8/bin/bootstrap.jar:/usr/local/tomcat8/bin/tomcat-juli.jar
Tomcat started.

tomcat-2 y tomcat-1 para la misma operación.
(4) el código de prueba
# Ahora crear una página de conectividad sencilla prueba .jsp, el gato de prueba y MySQL

[root@tomcat-1 ~]# vim /web/webapp1/test.jsp
#内容如下：（根据自己的环境，修改相对应的参数）
<%@ page language="java" import="java.sql.*" pageEncoding="GB2312"%>
<html>
<head>
<title>MySQL</title>
</head>
<body>
connect MySQL<br>
<%
String driverClass="com.mysql.jdbc.Driver";
String url="jdbc:mysql://172.16.1.130:3306/javadb";
String username = "javauser";
String password = "pwd@123";
Class.forName(driverClass);
Connection conn=DriverManager.getConnection(url, username, password);
Statement stmt=conn.createStatement();
ResultSet rs = stmt.executeQuery("select * from testtb");
while(rs.next()){
out.println("<br>name:"+rs.getString(2)+"age:"+rs.getString(3));
}
rs.close();
stmt.close();
conn.close();
%>
</body>
</html>

Nota: para crear el mismo código de prueba en el gato-2 nodos, pero con el fin de verificar mejor el título cambiado a "MySQL-2".

(5) acceder a través de una página de prueba del navegador, la URL de: http://172.16.1.100/test.jsp , o retroceso backend proxy de servidor Tomcat por nginx.


Como puede verse en la figura, ahora tomcat-1 tomcat-2 y está listo para conectarse a la base de datos.
Este proyecto conjunto se completa. . .

El paquete de instalación y el paquete frasco ha sido cargado en el disco de red: Enlace: https://pan.baidu.com/s/133H7oEbBWiBvaNWUoFgH3Q
código de extracción: 2fj1