Redis 集群策略介绍与实现

持久化机制：

快照snapshotting（默认）：周期性的写入磁盘dump.rdb文件

snapshotting设置：

save 900 1 #900秒内如果超过1个key被修改则发起快照保存

save 300 10 #300秒内如果超过10个key被修改，则发起快照保存

日志AOF：把修改操作追加到文件中，由于快照方式是在一定时间间隔做一次，如果发生意外当机的情况会丢失最后一次快照后修改的数据，aof比快照方式有更好的持久化性，使用aof时 redis会将每一次写命令追加到文件中，当redis重新启动时会从新执行文件中保存的写命令来在内存中重建这个数据库的内容。开启AOF后快照方式就会关闭

aof设置：

appendonly yes #启动aof持久化

appendfsync always #收到写命令立即写入磁盘，效率低但保证完全的持久化

appendfsync everysec #每秒写入磁盘一次，性能和持久化方面做了很好的折中

appendfsync no #写入aof文件，不等待磁盘同步。性能最好，但是持久化没保证

集群策略：

1.主从模式：一台主节点机器写，多台从机器读

缺点：主节点挂了，集群就会变成不可用

2.哨兵模式：redis2.X 有一台机器作为哨兵机器，监控主节点，从节点机器，如果主节点挂了，会从从节点机器中选举出一台机器作为主节点，如果挂了的那台主节点恢复后会变成从节点继续加入到集群中

缺点：如果主节点有1个G的数据那么从节点都是同样的1个G的数据，无法做分布式

3.集群模式：redis3.0 多主多从模式 1个G的数据均摊到不同的多主多从机器上

主从复制：

Master主要用来写入数据，slave用来读取数据,类似数据库读写分离

1.Master可以拥有多个slave

2.多个slave可以连接同一个master外，还可以连接到其他的slave（一般不会这么多，都是一主多从）

3.主从复制不会阻塞master 在同步数据时，master可以继续处理client请求

主从复制过程:

1.slave与master建立连接，发送sync同步命令

2.master会开启一个后台进程将数据库快照保存到文件中，同事master主进程会开始收集新的写命令并缓存

3.后台完成保存后，就将文件发送给slave

4.slave将此文件保存到硬盘上

5.slave只能读不能写

主从复制配置

1.修改slave机器配置文件

slaveof <master ip> <master port>

slaveof 192.168.0.100 6379

masterauth <master password> (如何有密码则需要修改)

masterauth YY77653_mmdplay_******

info查看角色与slave信息

哨兵模式：

1.监控主数据库和从数据库是否正常运行

2.主数据库出现故障时，可以将从数据库转换为主数据库，实现自动切换

3.脱离了redis存储，只做监控

4.挂掉的主节点从新开启后会变成从节点继续使用

实现步骤:

1.在一台从服务器配置sentinel.conf

2. cp /usr/local/redis-3.0.0-rc2/sentinel.conf /usr/local/redis/etc/

3.修改此配置文件

dir /usr/local/redis/etc

sentinel monitor mymaster 192.168.0.100 6379 1 #名称主节点ip 端口选举通过票数

sentinel down-after-milliseconds mymaster 5000 #5秒检测一次主节点是否当机，（类似心跳系统），如果当机则开启选举

sentinel failover-timeout mymaster 180000 #选举过期时间，超过此时间就认为选举失败

sentinel auth-pass mymaster MySUPER--secret-0123passw0rd #如果有密码则需要填写

daemonize yes#加入此配置后启动哨兵为守护线程状态

4.启动哨兵

/usr/local/redis/bin/redis-server /usr/local/redis/etc/sentinel.conf --sentinel &

--sentinel ：监控

&：后台启动

5.查看哨兵信息

/usr/local/redis/bin/redis-cli -h 192.168.0.103 -p 26379 info Sentinel

集群模式：

1.分布式缓存，将数据存放在不同的机器上

实现步骤：

1.修改配置文件

daemonize yes #开启后台运行

bind 192.168.0.100 #绑定IP(需要写具体静态IP地址）

dir /usr/local/redis/etc #数据文件存放位置

cluster-enabled yes #启动集群模式

cluster-config-file nodes6379.conf #

cluster-node-timeout 5000 #集群失效时间

appendonly yes #开启aof

PS：如果之前有配置主从需要注释掉相关配置，集群会自动分配主从

2.redis集群需要使用到ruby命令，所以需要安装ruby

yum install ruby

yum install rubygems

gem install redis (安装redis和ruby的接口)

3.启动每个节点的redis-server服务

4.创建集群

cd /usr/local/redis-3.0.0-rc2/src/

./redis-trib.rb create --replicas 1 192.168.0.100:6379 192.168.0.101:6379 192.168.0.102:6379 192.168.0.103:6379 192.168.0.104:6379 192.168.0.105:6379

选项--replicas 1表示我们希望为集群中的每个主节点创建一个从节点

5.连接集群

./redis-cli -c -h -p (-c表示集群模式 -h指定IP地址 -p端口)

./redis-cli -c -h 192.168.0.101 -p 6379

cluster nodes 查看集群信息

集群与spring集成

1.pom

  <dependency>
   <groupId>org.springframework.data</groupId>
   <artifactId>spring-data-redis</artifactId>
   <version>1.7.2.RELEASE</version>
  </dependency>
  <dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>2.9.0</version>
  </dependency>

2.spring-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
 http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
 
  <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
   <property name="maxTotal" value="${redis.maxTotal}"></property>
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>  
    
    <!-- Redis集群配置 -->
    <bean id="redisClusterConfig" class="org.springframework.data.redis.connection.RedisClusterConfiguration">
       <property name="maxRedirects" value="3"></property>
       <property name="clusterNodes">
           <set>
               <bean class="org.springframework.data.redis.connection.RedisNode">
                   <constructor-arg name="host" value="192.168.0.100"></constructor-arg>
                   <constructor-arg name="port" value="6379"></constructor-arg>
               </bean>
               <bean class="org.springframework.data.redis.connection.RedisNode">
                   <constructor-arg name="host" value="192.168.0.101"></constructor-arg>
                   <constructor-arg name="port" value="6379"></constructor-arg>
               </bean>
               <bean class="org.springframework.data.redis.connection.RedisNode">
                   <constructor-arg name="host" value="192.168.0.102"></constructor-arg>
                   <constructor-arg name="port" value="6379"></constructor-arg>
               </bean>
               <bean class="org.springframework.data.redis.connection.RedisNode">
                   <constructor-arg name="host" value="192.168.0.103"></constructor-arg>
                   <constructor-arg name="port" value="6379"></constructor-arg>
               </bean>
               <bean class="org.springframework.data.redis.connection.RedisNode">
                   <constructor-arg name="host" value="192.168.0.104"></constructor-arg>
                   <constructor-arg name="port" value="6379"></constructor-arg>
               </bean>
               <bean class="org.springframework.data.redis.connection.RedisNode">
                   <constructor-arg name="host" value="192.168.0.105"></constructor-arg>
                   <constructor-arg name="port" value="6379"></constructor-arg>
               </bean>
           </set>
       </property>
    </bean> 
    
    <!-- 
    <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"/>  
      
     -->
    
    <!-- ReDis连接工厂 -->
    <bean id="connectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg name="clusterConfig" ref="redisClusterConfig" />
        <property name="timeout" value="${redis.timeout}" />
        <property name="poolConfig" ref="poolConfig" />
    </bean>
    
    <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  
        <property name="connectionFactory" ref="connectionFactory" />  
    </bean>
    
    
</beans>

Redis 集群策略介绍与实现

浏览过的版块