redis 持久化 + 主从复制+ 集群

最新推荐文章于 2024-08-30 11:19:20 发布

weixin_33842304

最新推荐文章于 2024-08-30 11:19:20 发布

阅读量72

点赞数

原文链接：https://my.oschina.net/maoguangdong/blog/850111

版权

2019独角兽企业重金招聘Python工程师标准>>>

一、 Linux 下的 Redis 安装 && 启动 && 关闭 && 卸载

http://blog.csdn.net/zgf19930504/article/details/51850594

注：设置 redis.conf bind=***.***.*.(127.0.0.1) redis启动： redis-cli -h * -p *

auth 密码

二、持久化转：

https://my.oschina.net/u/780876/blog/544061

注：关闭 rdb 配置文件开启 save “”注释

三、redis 主从复制+sentinel(哨兵）

http://www.cnblogs.com/think-in-java/p/5123884.html

注：在做sentinel 配置时，一台虚拟机做主机master ,另为一台设置两个从机slave，当主机这台虚拟机断开（此处断开不是手动关闭redis,是指redis 没关闭情况下，关闭虚拟机。开始大约有1分多钟一直没有切换过来，最终切换成功。这里延迟时间较长，可能会丢失数据）

redis一主多从的spring配置

http://blog.csdn.net/xiaobao5214/article/details/52057232

注：sentinel 配置，配置文件只需写 sentinel 主机、端口，不必写主从机配置。

常出现一下问题

DENIED Redis is running in protected mode because protected mode is enabled, no bind address was 
specified, no authentication password is requested to    clients.......

protected-mode no

http://blog.csdn.net/alaska_bibi/article/details/52594639

Redis Sentinel 系统如何实现系统高可用的原理：

http://blog.csdn.net/lihao21/article/details/60359633 （sentinel 实现redis的高可用性，其负载能力还是单机负载能力）

四、集群

集群配置前依赖安装

1):安装redis-cluster依赖:redis-cluster的依赖库在使用时有兼容问题,在reshard时会遇到各种错误,请按指定版本安装.

(1)确保系统安装zlib,否则gem install会报(no such file to load -- zlib)

Java代码收藏代码

#download:zlib-1.2.6.tar  
./configure  
make  
make install

(1)安装ruby:version(1.9.2)

Java代码收藏代码

# ruby1.9.2   
cd /path/ruby  
./configure -prefix=/usr/local/ruby  
make  
make install  
sudo cp ruby /usr/local/bin

(2)安装rubygem:version(1.8.16)

Java代码收藏代码

# rubygems-1.8.16.tgz  
cd /path/gem  
sudo ruby setup.rb  
sudo cp bin/gem /usr/local/bin

(3)安装gem-redis:version(3.0.0)

Java代码收藏代码

gem install redis --version 3.0.0  
#由于源的原因，可能下载失败，就手动下载下来安装  
#download地址:http://rubygems.org/gems/redis/versions/3.0.0  
gem install -l /data/soft/redis-3.0.0.gem

2)安装redis-cluster

参考：http://blog.csdn.net/myrainblues/article/details/25881535/

集群配置：

http://www.cnblogs.com/wuxl360/p/5920330.html

注：针对配置上例中，三主三从情况。当主机挂了，从机上位成为新的主机，实现了高可用性。但当主从都挂了的时候，需要通过复制迁移（备份迁移redis.conf）:修改cluster-migration-barrier配置。预先可使一个主机挂多个从机，当某主从都挂了的时候，可以迁移其他主机多余的从机用来代替。

http://lib.csdn.net/article/redis/18568

节点加入到集群,使用 cluster meet ip port，注意是在客户端执行该命令哦～～

192.168.1.103:7001> cluster meet 192.168.1.103 7006 OK

重新查询集群信息

192.168.1.103:7001> cluster nodes

Redis 3.0的集群方案有以下两个问题。

一个Redis实例具备了“数据存储”和“路由重定向”，完全去中心化的设计。这带来的好处是部署非常简单，直接部署Redis就行，不像Codis有那么多的组件和依赖。但带来的问题是很难对业务进行无痛的升级，如果哪天Redis集群出了什么严重的Bug，就只能回滚整个Redis集群。

对协议进行了较大的修改，对应的Redis客户端也需要升级。升级Redis客户端后谁能确保没有Bug？而且对于线上已经大规模运行的业务，升级代码中的Redis客户端也是一个很麻烦的事情。

redis 集群的节点是分槽存储的，每次 get key 需要重定向到存放改key 槽的 master上

在第一台机器上连接集群的7002端口的节点，在另外一台连接7005节点，连接方式为 redis-cli -h 192.168.31.245 -c -p 7002 ,加参数 -C 可连接到集群，因为上面 redis.conf 将 bind 改为了ip地址，所以 -h 参数不可以省略。

在7005节点执行命令 set hello world ，执行结果如下：

输入图片说明

然后在另外一台7002端口，查看 key 为 hello 的内容， get hello ，执行结果如下：

输入图片说明

简单说一下原理

redis cluster在设计的时候，就考虑到了去中心化，去中间件，也就是说，集群中的每个节点都是平等的关系，都是对等的，每个节点都保存各自的数据和整个集群的状态。每个节点都和其他所有节点连接，而且这些连接保持活跃，这样就保证了我们只需要连接集群中的任意一个节点，就可以获取到其他节点的数据。

Redis 集群没有并使用传统的一致性哈希来分配数据，而是采用另外一种叫做哈希槽 (hash slot)的方式来分配的。redis cluster 默认分配了 16384 个slot，当我们set一个key 时，会用CRC16算法来取模得到所属的slot，然后将这个key 分到哈希槽区间的节点上，具体算法就是：CRC16(key) % 16384。所以我们在测试的时候看到set 和 get 的时候，直接跳转到了7000端口的节点。

Redis 集群会把数据存在一个 master 节点，然后在这个 master 和其对应的salve 之间进行数据同步。当读取数据时，也根据一致性哈希算法到对应的 master 节点获取数据。只有当一个master 挂掉之后，才会启动一个对应的 salve 节点，充当 master 。

需要注意的是：必须要3个或以上的主节点，否则在创建集群时会失败，并且当存活的主节点数小于总节点数的一半时，整个集群就无法提供服务了。

spring data redis 操作redis 单机版和集群 xml配置信息；

http://blog.csdn.net/hdf734839030/article/details/52293230

注：redis cluster 出现 CLUSTERDOWN The cluster is down（虚拟机关闭再次重启所有节点容易出现）

root@ubuntu:~# ./redis-3.0.1/src/redis-trib.rb check 127.0.0.1:7000|more

输入图片说明

说明 866这个分片没有费给7005节点或者有误输入图片说明添加这个分片

127.0.0.1:7005> cluster addslots 866

输入图片说明

cluster-migration-barrier 1 master的slave数量大于该值，slave才能迁移到其他孤立master上，如这个参数若被设为2，那么只有当一个主节点拥有2个可工作的从节点时，它的一个从节点才会尝试迁移。

SpringMVC application-redis.xml:

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd ">  
            
  	<bean id="propertyConfig1"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="order" value="1" />
		<property name="location">
			<value>/WEB-INF/config/redis.properties</value>
		</property>
		<property name="ignoreUnresolvablePlaceholders" value="true" />  
	</bean>
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
        <property name="maxIdle" value="${redis.maxIdle}" />  
        <property name="maxTotal" value="${redis.maxActive}" />  
        <property name="MaxWaitMillis" value="${redis.maxWait}" />  
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
    </bean>  
     <!-- 1.redis单例模式 -->
   <!--  <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
        p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.password}" p:pool-config-ref="poolConfig"/>   -->
     <!-- 2.redis主从复制+sentinel -->
      <!-- <bean id="redisSentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">  
        <property name="master">  
            <bean class="org.springframework.data.redis.connection.RedisNode">  
                <property name="name" value="mymaster"/>  
            </bean>  
        </property>  
        <property name="sentinels">  
            <set>  
                <bean class="org.springframework.data.redis.connection.RedisNode">  
                    <constructor-arg name="host" value="192.168.65.129"></constructor-arg>  
                    <constructor-arg name="port" value="26379"></constructor-arg>  
                </bean>  
                <bean class="org.springframework.data.redis.connection.RedisNode">  
                    <constructor-arg name="host" value="192.168.65.130"></constructor-arg>  
                    <constructor-arg name="port" value="26379"></constructor-arg>  
                </bean>  
            </set>  
        </property>  
    </bean>
    <bean id="connectionFactory"  
          class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">  
        <constructor-arg ref="redisSentinelConfiguration"/>  
    </bean>  -->
      <!--3.配置RedisClusterConfiguration-->
    <bean id="redisClusterConfiguration" class="org.springframework.data.redis.connection.RedisClusterConfiguration">
        <property name="maxRedirects" value="${redis.maxRedirects}"></property>
        <property name="clusterNodes">
            <set>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host1}"/>
                    <constructor-arg name="port" value="${redis.port1}"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host2}"/>
                    <constructor-arg name="port" value="${redis.port2}"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host3}"/>
                    <constructor-arg name="port" value="${redis.port3}"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host4}"/>
                    <constructor-arg name="port" value="${redis.port4}"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host5}"/>
                    <constructor-arg name="port" value="${redis.port5}"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host6}"/>
                    <constructor-arg name="port" value="${redis.port6}"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host7}"/>
                    <constructor-arg name="port" value="${redis.port7}"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.host8}"/>
                    <constructor-arg name="port" value="${redis.port8}"/>
                </bean>
            </set>
        </property>
    </bean>
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg name="poolConfig" ref="poolConfig"/>
        <constructor-arg name="clusterConfig" ref="redisClusterConfiguration"/>
    </bean>
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  
        <property name="connectionFactory"   ref="connectionFactory" />  
        <property name="keySerializer">  
         <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
	     </property>     
	     <property name="valueSerializer">  
	         <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />  
	     </property>  
	     <property name="hashKeySerializer">    
	        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
	     </property>  
	     <property name="hashValueSerializer">  
	        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
	     </property>  
        
    </bean>   
    <bean id="redisUtil" class="com.general.common.util.RedisUtil">
	 	<property name="redisTemplate" ref="redisTemplate"/>
	</bean>   
    <!-- 启动对@AspectJ注解的支持 -->
    <!-- proxy-target-class等于true是强制使用cglib代理，proxy-target-class默认是false，如果你的类实现了接口 就走JDK代理，如果没有，走cglib代理  -->
    <!-- 注：对于单利模式建议使用cglib代理，虽然JDK动态代理比cglib代理速度快，但性能不如cglib -->

    <!--如果不写proxy-target-class="true"这句话也没问题-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>     
</beans>

redis.properties

#redis 1.单例模式
#redis.host=120.210.153.11
#redis.port=6379
#redis.password=maoguangdong
#redis 2.主从复制 +sentinel
#redis.master_host=192.168.65.130
#redis.master_port=6379
#redis.slave1_host=192.168.65.130
#redis.slave1_port=6380
#redis.slave2_host=192.168.65.129
#redis.slave2_port=6379
#redis 3.集群RedisClusterConfiguration配置
redis.host1=192.168.65.131
redis.port1=7000
redis.host2=192.168.65.131
redis.port2=7001
redis.host3=192.168.65.131
redis.port3=7002
redis.host4=192.168.65.131
redis.port4=7006
redis.host5=192.168.65.130
redis.port5=7003
redis.host6=192.168.65.130
redis.port6=7004
redis.host7=192.168.65.130
redis.port7=7005
redis.host8=192.168.65.130
redis.port8=7006
redis.maxRedirects=3
redis.maxIdle=100
redis.maxActive=300
redis.maxWait=1000
redis.testOnBorrow=true
redis.timeout=100000
com.service.impl.xxxRecordManager= 60
com.service.impl.xxxSetRecordManager= 60
defaultCacheExpireTime=3600
  
fep.local.cache.capacity =10000

转载于:https://my.oschina.net/maoguangdong/blog/850111