一、Redis管理

(一)CacheCloud简介

  CacheCloud提供一个Redis云管理平台：实现多种类型(Redis Standalone、Redis Sentinel、Redis Cluster)自动部署、解决Redis实例碎片化现象、提供完善统计、监控、运维功能、减少运维成本和误操作，提高机器的利用率，提供灵活的伸缩性，提供方便的接入客户端。

CacheCloud架构

(二)CacheCloud功能

• 监控统计：提供了机器、应用、实例下各个维度数据的监控和统计界面。
• 一键开启： Redis Standalone、Redis Sentinel、Redis Cluster三种类型的应用，无需手动配置初始化。
• Failover： 支持哨兵,集群的高可用模式。
• 伸缩： 提供完善的垂直和水平在线伸缩功能。
• 完善运维： 提供自动运维和简化运维操作功能，避免纯手工运维出错。
• 方便的客户端 方便快捷的客户端接入。
• 元数据管理： 提供机器、应用、实例、用户信息管理。
• 流程化： 提供申请，运维，伸缩，修改等完善的处理流程
• 一键导入： 一键导入已经存在Redis

(三)CacheCloud安装

1.下载地址：https://github.com/sohutv/cachecloud
2.下载源码
[root@iz2ze78abfa21jjsp4u9wlz ~]# yum –y install git

克隆源码：

[root@localhost ~]# git clone https://github.com/sohutv/cachecloud

3.前置条件
1)安装Maven

[root@localhost ~]# yum install -y maven
[root@localhost ~]# mvn -v
Apache Maven 3.0.5 (Red Hat 3.0.5-17)
Maven home: /usr/share/maven
Java version: 1.8.0_191, vendor: Oracle Corporation
Java home: /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.191.b12-0.el7_5.x86_64/jre
Default locale: zh_CN, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-514.el7.x86_64", arch: "amd64", family: "unix"

2)安装MySql

A、安装仓库
[root@localhost ~]# wget http://repo.mysql.com/mysql57-community-release-el7-8.noarch.rpm
[root@localhost ~]# rpm -ivh mysql57-community-release-el7-8.noarch.rpm
B、安装MySql
[root@localhost ~]# yum -y install mysql-server
安装完毕后，运行mysql，然后在  /var/log/mysqld.log 文件中会自动生成一个随机的密码，我们需要先取得这个随机密码，以用于登录 MySQL 服务端：
[root@localhost ~]# service mysqld start
[root@localhost ~]# grep "password" /var/log/mysqld.log
将会返回如下内容，末尾字符串就是密码，把它复制下来：
A temporary password is generated for root@localhost: hilX0U!9i3_6
C、登录到 MySQL 服务端并更新用户 root 的密码：
注意：由于 MySQL5.7 采用了密码强度验证插件 validate_password，故此我们需要设置一个有一定强度的密码；
[root@localhost ~]# mysql -uroot -p
hilX0U!9i3_6
然后更改密码
mysql>SET PASSWORD = PASSWORD('your new password');
mysql>ALTER USER 'root'@'localhost' PASSWORD EXPIRE NEVER;
mysql>flush privileges;
设置用户 root 可以在任意 IP 下被访问：
mysql>grant all privileges on *.* to root@"%" identified by "new password";
设置用户 root 可以在本地被访问：
mysql>grant all privileges on *.* to root@"localhost" identified by "new password";
刷新权限使之生效：
mysql>flush privileges;
D、MySQL控制命令：启动、停止、重启、查看状态
[root@localhost ~]# systemctl start mysqld
[root@localhost ~]# systemctl status mysqld
E、设置 MySQL 的字符集为 UTF-8
打开 /etc 目录下的 my.cnf 文件（此文件是 MySQL 的主配置文件）：
[root@localhost ~]# vi /etc/my.cnf

4.创建数据库（cachecloud）

[root@localhost cachecloud]# mysql -h192.168.146.141 -uroot -p
[root@localhost ~]# cd cachecloud/
[root@localhost cachecloud]# ls
cachecloud-open-client  cachecloud-open-web  pom.xml    script
cachecloud-open-common  LICENSE              README.md
执行script/cachecloud.sql脚本。
mysql> source /root/cachecloud/script/cachecloud.sql
修改本地DB 的相关连接参数：
[root@iZ2ze78abfa21jjsp4u9wcZ ~]# vi /root/cachecloud/cachecloud-open-web/src/main/swap/local.properties
cachecloud.db.url = jdbc:mysql://192.168.146.141:3306/cache-cloud
cachecloud.db.user = root
cachecloud.db.password = 1234
cachecloud.maxPoolSize = 20

isClustered = true
isDebug = true
spring-file = classpath:spring/spring-local.xml
log_base = /opt/cachecloud-web/logs
web.port = 9999
log.level = INFO
修改在线DB 的相关连接参数：
[root@iz2ze78abfa21jjsp4u9wlz cachecloud-open-web]# vi /root/cachecloud/cachecloud-open-web/src/main/swap/online.properties
cachecloud.db.url = jdbc:mysql://127.0.0.1:3306/cache-cloud
cachecloud.db.user = root
cachecloud.db.password = 12346
cachecloud.maxPoolSize = 20

isClustered = true
isDebug = false
spring-file=classpath:spring/spring-online.xml
log_base=/opt/cachecloud-web/logs
web.port=8585
log.level=WARN

5、Maven编译运行

1)编译
在cachecloud根目录下运行:
[root@localhost cachecloud]# mvn clean compile install -Plocal
注意：一定要先编译本地
2)本地启动
在cachecloud-open-web模块下运行:
[root@localhost cachecloud]# cd cachecloud-open-web/
本地运行测试数据库是否正确。
[root@localhost cachecloud-open-web]# mvn spring-boot:run
http://101.200.42.192:9999
3)生产环境
[root@localhost cachecloud-open-web]# mvn clean compile install -Ponline
注意：只有编译了本地，才可以编译在线。

sh start.sh #如果机器内存不足，可以适当调小:-Xmx和-Xms(默认是4g)
sh stop.sh

执行deploy.sh脚本：
[root@localhost cachecloud]#  bash /root/cachecloud/script/deploy.sh /root/
启动服务：
[root@localhost cachecloud]# bash /opt/cachecloud-web/start.sh
在线访问：
http://192.138.146.141:8585

4)常见问题：
中文乱码：
修改数据库连接：

[root@iz2ze78abfa21jjsp4u9wlz swap]# vi online.properties
[root@iz2ze78abfa21jjsp4u9wlz swap]# vi local.properties

cachecloud.db.url = jdbc:mysql://172.17.244.159:3306/cache-cloud?useUnicode=true&characterEncoding=UTF-8
cachecloud.db.user = root
cachecloud.db.password =B*wI0AMszG
cachecloud.maxPoolSize = 20

isClustered = true
isDebug = true
spring-file = classpath:spring/spring-local.xml
log_base = /opt/cachecloud-web/logs
web.port = 9999
log.level = INFO

5、添加机器
运行脚本：
[root@localhost script]# chmod +x cachecloud-init.sh

创建一个新用户进行安装 用户名为redis 密码自已设定

[root@iZ2ze78abfa21jjsp4u9wcZ script]# bash cachecloud-init.sh redis

redis安装

添加机器

机器管理

启动redis服务：
[root@iz2ze78abfa21jjsp4u9wcz script]# redis-server &

客户端连接：

[root@iz2ze78abfa21jjsp4u9wcz script]# redis-cli
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> quit

6、登录访问

本地访问：
http://192.168.146.141:9999
SQL 脚本初始化时，预留了一个admin 的超级管理员账号（密码：admin）。

登录

后台管理：

后台管理

系统配置：

系统配置管理

7、导入应用

导入应用

添加应用

应用列表

应用查看

应用查看

8、应用列表

应用列表

9、应用申请
提前初始化脚本:
[root@iz2ze78abfa21jjsp4u9wcz script]# bash cachecloud-init.sh redis

主要用于申请后，管理员审批成功后可用。
(1) redis sentinel
Redis-Sentinel是Redis官方推荐的高可用性(HA)解决方案，redis-sentinel又叫哨兵，它去监控主从数据库运行状态，当用Redis做Master-slave的高可用方案时，假如master宕机了，Redis本身(包括它的很多客户端)都没有实现自动进行主备切换，而Redis-sentinel本身也是一个独立运行的进程，它能监控多个master-slave集群，发现master宕机后能进行自懂切换，从而实现高可用。哨兵可以配置多个, 如果配置了多个，当主发生故障的时候，sentinel需要投票选举是否切换。
提交创建redis-sentinel申请:

申请 sentinel

后台管理：

申批处理

![申批处理]](https://upload-images.jianshu.io/upload_images/14929498-6bb1ba81586c95ed.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
172.17.244.148:8192:172.17.244.149
172.17.244.148
172.17.244.149
172.17.244.152

实例列表

(2)Redis Cluster
redis cluster群集，是通过主从来实现分片高可用，官方解释：
Redis 集群是一个提供在多个Redis间节点间共享数据的程序集。
Redis集群并不支持处理多个keys的命令,因为这需要在不同的节点间移动数据,从而达不到像Redis那样的性能,在高负载的情况下可能会导致不可预料的错误.
Redis 集群通过分区来提供一定程度的可用性,在实际环境中当某个节点宕机或者不可达的情况下继续处理命令. Redis 集群的优势:
自动分割数据到不同的节点上。
整个集群的部分节点失败或者不可达的情况下能够继续处理命令。

cluster: 每行都是数据节点，不分主从：
172.17.244.152:4096:172.17.244.149
172.17.244.149:6144:172.17.244.148
172.17.244.148:6144:172.17.244.152

头部菜单：
D:\cachecloud-master\cachecloud-open-web\src\main\webapp\WEB-INF\include\headMenu.jsp

配置：

#redis配置
# Redis服务器地址
#spring.redis.host=192.168.0.4
#spring.redis.host=39.96.32.130

#redis集群配置
spring.redis.cluster.nodes=101.200.42.192:6381,101.200.42.192:6382,47.94.238.74:6383,47.94.238.74:6384,39.96.32.130:6383,39.96.32.130:6384
spring.redis.cluster.max-redirects=3
# Redis服务器连接端口
#spring.redis.port=6379
# Redis服务器连接密码（默认为空）
#spring.redis.password=java123456
spring.redis.password=eoN68fGxRm1meZWY
# 连接超时时间（毫秒）
spring.redis.timeout=10000
# Redis默认情况下有16个分片，这里配置具体使用的分片，默认是0
spring.redis.database=4
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=300
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=100
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=20

配置代码：

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.Serializable;
import java.time.Duration;
import java.util.HashSet;
import java.util.Set;

/**
 * @作 者: 侯建军
 * @日 期: 2018/12/04 09:28:39
 * @描 述:
 */
@Configuration
@EnableCaching
public class LettuceRedisConfig {

    @Value("${spring.redis.database}")
    private int database;

//    @Value("${spring.redis.host}")
//    private String host;

    @Value("${spring.redis.password}")
    private String password;

//    @Value("${spring.redis.port}")
//    private int port;

    @Value("${spring.redis.cluster.nodes}")
    private String clusterNodes;

    @Value("${spring.redis.cluster.max-redirects}")
    private int maxRedirects;

    @Value("${spring.redis.timeout}")
    private long timeout;

    @Value("${spring.redis.lettuce.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.lettuce.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.lettuce.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.lettuce.pool.max-wait}")
    private long maxWait;

    /**
     * redis字符串模板
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Serializable> redisCacheTemplate(LettuceConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Serializable> template = new RedisTemplate<>();
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    /**
     * 连接工厂
     *
     * @param genericObjectPoolConfig
     * @return
     */
    @Bean
    LettuceConnectionFactory lettuceConnectionFactory(GenericObjectPoolConfig genericObjectPoolConfig) {
        // 单机版配置
//        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
//        redisStandaloneConfiguration.setDatabase(database);
//        redisStandaloneConfiguration.setHostName(host);
//        redisStandaloneConfiguration.setPort(port);
//        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));

        // 集群版配置
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        String[] serverArray = clusterNodes.split(",");
        Set<RedisNode> nodes = new HashSet<RedisNode>();
        for (String ipPort : serverArray) {
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
        }
        redisClusterConfiguration.setPassword(RedisPassword.of(password));
        redisClusterConfiguration.setClusterNodes(nodes);
        redisClusterConfiguration.setMaxRedirects(maxRedirects);

        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(genericObjectPoolConfig)
                .build();

//        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration,clientConfig);
        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisClusterConfiguration, clientConfig);
        return factory;
    }

    /**
     * GenericObjectPoolConfig 连接池配置
     * 需引入commons-pool2
     *
     * @return
     */
    @Bean
    public GenericObjectPoolConfig genericObjectPoolConfig() {
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        return genericObjectPoolConfig;
    }
}