注册 X
提交 注:点击提交后系统会发送邮件到邮箱验证!(仅支持中国大陆邮箱)
我已阅读并同意 服务条款
首页 > IT技术笔记 > 查看笔记

SpringCloud高可用Redis集群环境搭建

前言

一般的小项目,比如几百人左右访问的项目,访问量几万的项目,如果想用缓存,单机实例完全够用。小黄图就是用的阿里云256MB配置的Redis缓存,日几千的访问量是妥妥够用的了。

Redis号称可以支撑10w+qps,当然这也给机器配置有一定的关系,如果单实例满足不了需求,想追求更高的性能和稳定性,可以选择主从、哨兵已经更好的解决方案Redis-Cluster 集群。

架构

集群部署

如题,我们这里直接使用 Redis-Cluster 高可用集群。

Redis-Cluster集群采用无中心结构,它的特点如下:

  • 所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽。

  • 节点的fail是通过集群中超过半数的节点检测失效时才生效。

  • 客户端与redis节点直连,不需要中间代理层,客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可。

生产环境redis集群至少需要一个备份节点,才能更好的保证集群的高可用。一个集群里面有 M1-S1、M2-S2、M3-S3 六个主从节点,其中节点 M1 包含 0-5500号哈希槽,节点 M2 包含5501-11000 号哈希槽,节点 M3 包含11001-16384号哈希槽。如果是 M1 宕掉,集群便会选举S1 为新节点继续服务,整个集群还会正常运行。当 M1、S1 都宕掉了,这时候集群就不可用了。

建议使用至少六台单独的服务器进行部署,这里为了搭建方便,撸主在一台服务器上进行实操。

下载最新版本:


	        
wget http://download.redis.io/releases/redis-6.0.5.tar.gz			
	      

升级基础组件,否则编译安装会报错:

	        
# 升级到gcc 9.3:
yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
scl enable devtoolset-9 bash
# 需要注意的是scl命令启用只是临时的,退出shell或重启就会恢复原系统gcc版本。
# 如果要长期使用gcc 9.3的话:
echo "source /opt/rh/devtoolset-9/enable" >>/etc/profile			
	      

编译安装:


make && make install

创建集群配置:


mkdir redis-cluster

创建集群文件夹,然后在该文件夹下创建6个文件,同redis.conf配置一致,7001.conf、7002.conf、7003.conf、7004.conf、7005.conf、7006.conf

然后修改各个配置:


	        
port  700x                             // 端口700X
bind 内网ip                 // 需要改为其他节点机器可访问的ip 否则创建集群时无法访问对应的端口,无法创建集群
daemonize    yes                       // redis后台运行
pidfile  /var/run/redis_700x.pid       // pidfile文件对应7001,7002
cluster-enabled  yes                   // 开启集群  把注释#去掉
cluster-config-file  nodes_700x.conf   // 集群的配置  配置文件首次启动自动生成 7001,7002
cluster-node-timeout  15000            // 请求超时  默认15秒,可自行设置
appendonly  yes    // # AOF 持久化,按需要选择是否开启			
	      

启动服务:

	        
redis-server ../redis-cluster/7001.conf
redis-server ../redis-cluster/7002.conf
redis-server ../redis-cluster/7003.conf
redis-server ../redis-cluster/7004.conf
redis-server ../redis-cluster/7005.conf
redis-server ../redis-cluster/7006.conf			
	      

创建集群:

	        
--replicas参数指定集群中每个主节点配备几个从节点,这里设置为1。
redis-cli --cluster create 172.17.1.218:7001 172.17.1.218:7002 172.17.1.218:7003 172.17.1.218:7004 172.17.1.218:7005 172.17.1.218:7006 --cluster-replicas 1			
	      

查看集群:

	        
redis-cli --cluster check 172.17.1.218:7001
172.17.1.218:7002 (406a1d6e...) -> 0 keys | 5461 slots | 1 slaves.
172.17.1.218:7003 (85df8dc9...) -> 0 keys | 5462 slots | 1 slaves.
172.17.1.218:7004 (54f13720...) -> 2 keys | 5461 slots | 1 slaves.
[OK] 2 keys in 3 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 172.17.1.218:7001)
S: 2d589d0077771ca9a7b2909b351e350aa69bea45 172.17.1.218:7001
   slots: (0 slots) slave
   replicates 54f13720da944d3dcc75351c4042fcaf3b2300e0
M: 406a1d6e9bcc760501c6b8f71f9151e020b247bd 172.17.1.218:7002
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: e52eda05e4df779e15437f7f42522459a3e26b27 172.17.1.218:7005
   slots: (0 slots) slave
   replicates 85df8dc9b649e02740fa0f932aa1df135d44953e
M: 85df8dc9b649e02740fa0f932aa1df135d44953e 172.17.1.218:7003
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 54f13720da944d3dcc75351c4042fcaf3b2300e0 172.17.1.218:7004
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 60f49255085936fbcf682bafc81319f9393150c9 172.17.1.218:7006
   slots: (0 slots) slave
   replicates 406a1d6e9bcc760501c6b8f71f9151e020b247bd
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.			
	      

从集群信息,我们可以看出有三组主从关系:

  • 7004(主)-7001(从)

  • 7003(主)-7005(从)

  • 7002(主)-7006(从)

其实一开始7001是主,为了测试主从切换,把7001杀掉,由7004接管,然后重启7001变为从服务。

整合

pom.xml 引入:


	        
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>			
	      

配置文件 bootstrap.yml

	        
spring:
  redis:
    timeout: 30000
    password: 123456
    cluster:
      nodes:
        - 172.17.1.218:7001
        - 172.17.1.218:7002
        - 172.17.1.218:7003
        - 172.17.1.218:7004
        - 172.17.1.218:7005
        - 172.17.1.218:7006
      max-redirects: 3
    lettuce:
      max-active: 1000
      max-idle: 10
      max-wait: -1
      min-idle: 5			
	      

开发者可以对 RedisTemplate 进行一个简单的封装成 RedisUtil ,可参考下面的缓存工具类。

小结

这就是微服务版本的 Redis 高可用集群,是不是有点简单。不过,生产环境建议配置内网地址,开启防火墙,配置必要的鉴权访问机制,这玩意一旦被嗅探到可以会被老板扣工资的。还有一点,一定要搭建有效的监控预警系统,这样可以针对性的对其进行扩容、修复。


	        
package com.tools.common.util;

import net.coobird.thumbnailator.Thumbnails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redisTemplate封装
 * 爪哇笔记:https://blog.52itstyle.vip
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public static String PREFIX = "cloud:bed:";

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(PREFIX+key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(PREFIX+key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(PREFIX+key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(PREFIX+key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(PREFIX+key));
            }
        }
    }

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return PREFIX+key==null?null:redisTemplate.opsForValue().get(PREFIX+key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(PREFIX+key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(PREFIX+key, value, time, TimeUnit.SECONDS);
            }else{
                set(PREFIX+key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(PREFIX+key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(PREFIX+key, -delta);
    }

    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(PREFIX+key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(PREFIX+key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(PREFIX+key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String,Object> map, long time){
        try {
            redisTemplate.opsForHash().putAll(PREFIX+key, map);
            if(time>0){
                expire(PREFIX+key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key,String item,Object value) {
        try {
            redisTemplate.opsForHash().put(PREFIX+key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key,String item,Object value,long time) {
        try {
            redisTemplate.opsForHash().put(PREFIX+key, item, value);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(PREFIX+key,item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(PREFIX+key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(PREFIX+key, item, by);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(PREFIX+key, item,-by);
    }

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(PREFIX+key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(PREFIX+key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(PREFIX+key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(PREFIX+key, values);
            if(time>0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(PREFIX+key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(PREFIX+key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(PREFIX+key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(PREFIX+key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
     * @return
     */
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(PREFIX+key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(PREFIX+key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(PREFIX+key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(PREFIX+key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(PREFIX+key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(PREFIX+key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(PREFIX+key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 模糊查询获取key值
     * @param pattern
     * @return
     */
    public Set keys(String pattern){
        return redisTemplate.keys(pattern);
    }

    /**
     * 使用Redis的消息队列
     * @param channel
     * @param message 消息内容
     */
    public void convertAndSend(String channel, Object message){
        redisTemplate.convertAndSend(channel,message);
    }

    /**
     *将数据添加到Redis的list中(从右边添加)
     * @param listKey
     * @param time 有效期
     * @param values 待添加的数据
     */
    public void addToListRight(String listKey, long time, TimeUnit timeUnit, Object... values) {
        //绑定操作
        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
        //插入数据
        boundValueOperations.rightPushAll(values);
        //设置过期时间
        boundValueOperations.expire(time,timeUnit);
    }
    /**
     * 根据起始结束序号遍历Redis中的list
     * @param listKey
     * @param start  起始序号
     * @param end  结束序号
     * @return
     */
    public List<Object> rangeList(String listKey, long start, long end) {
        //绑定操作
        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
        //查询数据
        return boundValueOperations.range(start, end);
    }
    /**
     * 弹出右边的值 --- 并且移除这个值
     * @param listKey
     */
    public Object rifhtPop(String listKey){
        //绑定操作
        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
        return boundValueOperations.rightPop();
    }

    public static void main(String[] args) throws IOException {
        String fromPic = "D:\\1239d1b727874bf09f3127d2ed498f0e.png";
        File file = new File(fromPic);
        File toPic = new File("D:\\1239d1b727874bf09f3127d2ed498f0e_1.png");
        Thumbnails.of(file).scale(0.5f).outputQuality(1f).toFile(toPic);
    }
}			
	      

 打赏        分享



评论

邮箱: 昵称:
\n