redis主从配置及通过keepalived实现redis自动切换，redis主从实现10秒检查与恢复

一：环境介绍：

Master: 192.168.1.4

Slave: 192.168.1.5

Virtural IP Address (VIP): 192.168.1.253

二：设计思路：

当 Master 与 Slave 均运作正常时, Master负责服务，Slave负责Standby；

当 Master 挂掉，Slave 正时, Slave接管服务，同时关闭主从复制功能；

当 Master 恢复正常，则从Slave同步数据，同步数据之后关闭主从复制功能，恢复Master身份，于此同时Slave等待Master同步数据完成之后，恢复Slave身份。

然后依次循环。

需要注意的是，这样做需要在Master与Slave上都开启本地化策略，否则在互相自动切换的过程中，未开启本地化的一方会将另一方的数据清空，造成数据完全丢失。

三：安装配置前准备工作

1.在主服务器192.168.1.4上面做下面操作

echo "192.168.1.4 test01" >> /etc/hosts

echo "192.168.1.5 test" >> /etc/hosts

2.在从服务器192.168.1.5上面做下面操作

echo "192.168.1.4 test01" >> /etc/hosts

echo "192.168.1.5 test" >> /etc/hosts

四：主服务器配置redis

1.下载安装redis软件包

wget http://download.redis.io/releases/redis-2.8.12.tar.gztar xf redis-2.8.12.tar.gz 
cd redis-2.8.12
make && make install
cd src/
cp redis-server redis-cli redis-benchmark redis-check-aof redis-check-dump /usr/local/bin
cd /usr/local/bin
ls -ll
然后将源码中的 redis.conf 复制到 /etc/redis.conf
cp /root/redis-2.8.12/redis.conf /etc/redis.conf
修改 /etc/redis.conf里面可以把  daemonize no 修改为daemonize yes
就可以默认在后台执行redis-server了。

再制作一个 init.d 的启动脚本：
vim /etc/init.d/redis-server
#!/usr/bin/env bash
#
# redis start up the redis server daemon
#
# chkconfig: 345 99 99
# description: redis service in /etc/init.d/redis \
#             chkconfig --add redis or chkconfig --list redis \
#             service redis start  or  service redis stop
# processname: redis-server
# config: /etc/redis.conf

PATH=/usr/local/bin:/sbin:/usr/bin:/bin

REDISPORT=6379
EXEC=/usr/local/bin/redis-server
REDIS_CLI=/usr/local/bin/redis-cli

PIDFILE=/var/run/redis.pid
CONF="/etc/redis.conf"
#make sure some dir exist
if [ ! -d /var/lib/redis ] ;then
    mkdir -p /var/lib/redis
    mkdir -p /var/log/redis
fi

case "$1" in
    status)
        ps -A|grep redis
        ;;
    start)
        if [ -f $PIDFILE ]
        then
                echo "$PIDFILE exists, process is already running or crashed"
        else
                echo "Starting Redis server..."
                $EXEC $CONF
        fi
        if [ "$?"="0" ]
        then
              echo "Redis is running..."
        fi
        ;;
    stop)
        if [ ! -f $PIDFILE ]
        then
                echo "$PIDFILE does not exist, process is not running"
        else
                PID=$(cat $PIDFILE)
                echo "Stopping ..."
                $REDIS_CLI -p $REDISPORT SHUTDOWN
                while [ -x ${PIDFILE} ]
               do
                    echo "Waiting for Redis to shutdown ..."
                    sleep 1
                done
                echo "Redis stopped"
        fi
        ;;
   restart|force-reload)
        ${0} stop
        ${0} start
        ;;
  *)
    echo "Usage: /etc/init.d/redis {start|stop|restart|force-reload}" >&2
        exit 1
esac

chmod o+x /etc/init.d/redis-server

chkconfig --add redis-server

service redis-server start 

五：从发服务器配置redis

从服务器，配置一样，只不过 修改/etc/redis.conf 中 

slaveof <masterip> <masterport>修改为

slaveof 192.168.1.4 6379

然后开启从服务器的redis服务。

start redis-server start

六：进行redis主从测试

#主服务器

redis-cli -p 6379 set hello world

#从服务器

redis-cli -p 6379 get hello

"world"

#主服务器

redis-cli -p 6379 set hello world2

#从服务器

redis-cli -p 6379 get hello

"world2"

redis-cli -p 6379 set hello world

(error) READONLY You can't write against a read only slave.

成功配置主从redis服务器，由于配置中有一条从服务器是只读的，所以从服务器没法设置数据，只可以读取数据。

七：安装和配置keepalived

1.在Master和Slave上安装Keepalived

$ yum install keepalived -y

2.默认安装完成keepalived之后是没有配置文件的，因此我们需要手动创建：

首先，在Master上创建如下配置文件：

$  vim /etc/keepalived/keepalived.conf

! Configuration File for keepalived

vrrp_script chk_redis {
    script "/etc/keepalived/scripts/redis_check.sh"     ###监控脚本   
    interval 2                                          ###监控时间
    }

vrrp_instance VI_1 {
    state MASTER                 ###设置为MASTER  
    interface eth1                ###监控网卡     
    virtual_router_id 51
    priority 100            ###权重值  
    authentication {
        auth_type PASS        ###加密  
        auth_pass 1111        ###密码
    }

track_script {
    chk_redis             ###执行上面定义的chk_redis  
    }

    virtual_ipaddress {
        192.168.1.253         ######VIP 
    }

         notify_master /etc/keepalived/scripts/redis_master.sh
         notify_backup /etc/keepalived/scripts/redis_backup.sh
         notify_fault  /etc/keepalived/scripts/redis_fault.sh
         notify_stop   /etc/keepalived/scripts/redis_stop.sh
}

3.然后，在Slave上创建如下配置文件：

$ vim /etc/keepalived/keepalived.conf

! Configuration File for keepalived

vrrp_script chk_redis {
    script "/etc/keepalived/scripts/redis_check.sh"     ###监控脚本  
    interval 2                   ###监控时间
    }

vrrp_instance VI_1 {
    state BACKUP         ###设置为BACKUP   
    interface eth1       ###监控网卡
    virtual_router_id 51
    priority 10          ###比MASTRE权重值低   
    authentication {
        auth_type PASS
        auth_pass 1111        ###密码与MASTRE相同  
    }

track_script {
    chk_redis        ###执行上面定义的chk_redis  
    }

    virtual_ipaddress {
        192.168.1.253   ####vip
    }

         notify_master /etc/keepalived/scripts/redis_master.sh
         notify_backup /etc/keepalived/scripts/redis_backup.sh
         notify_fault  /etc/keepalived/scripts/redis_fault.sh
         notify_stop   /etc/keepalived/scripts/redis_stop.sh

}

4.在Master和Slave上创建监控Redis的脚本

$  mkdir /etc/keepalived/scripts

$  vim /etc/keepalived/scripts/redis_check.sh

#!/bin/bash  
ALIVE=`/usr/local/bin/redis-cli PING`  
if [ "$ALIVE" == "PONG" ]; then 
echo $ALIVE  
exit 0  
else 
echo $ALIVE  
exit 1  
fi

5.编写以下负责运作的关键脚本：

notify_master /etc/keepalived/scripts/redis_master.sh

notify_backup /etc/keepalived/scripts/redis_backup.sh

notify_fault /etc/keepalived/scripts/redis_fault.sh

notify_stop /etc/keepalived/scripts/redis_stop.sh 

因为Keepalived在转换状态时会依照状态来呼叫：

当进入Master状态时会呼叫notify_master

当进入Backup状态时会呼叫notify_backup

当发现异常情况时进入Fault状态呼叫notify_fault

当Keepalived程序终止时则呼叫notify_stop

1)首先，在Redis Master上创建notity_master与notify_backup脚本：

$  vim /etc/keepalived/scripts/redis_master.sh

#!/bin/bash
REDISCLI="/usr/local/bin/redis-cli"
LOGFILE="/var/log/keepalived-redis-state.log"
echo "[master]" >> $LOGFILE
date >> $LOGFILE
echo "Being master...." >> $LOGFILE 2>&1

echo "Run SLAVEOF cmd ..." >> $LOGFILE
$REDISCLI SLAVEOF 192.168.1.5 6379 >> $LOGFILE  2>&1
sleep 10 #延迟10秒以后待数据同步完成后再取消同步状态  

echo "Run SLAVEOF NO ONE cmd ..." >> $LOGFILE
$REDISCLI SLAVEOF NO ONE >> $LOGFILE 2>&1

$  vim /etc/keepalived/scripts/redis_backup.sh

#!/bin/bash  
REDISCLI="/usr/local/bin/redis-cli"
LOGFILE="/var/log/keepalived-redis-state.log"

echo "[backup]" >> $LOGFILE
date >> $LOGFILE
echo "Being slave...." >> $LOGFILE 2>&1

sleep 15 #延迟15秒待数据被对方同步完成之后再切换主从角色  
echo "Run SLAVEOF cmd ..." >> $LOGFILE
$REDISCLI SLAVEOF 192.168.1.5 6379 >> $LOGFILE  2>&1

2)在Redis Slave上创建notity_master与notify_backup脚本：

$  vim /etc/keepalived/scripts/redis_master.sh

#!/bin/bash  
REDISCLI="/usr/local/bin/redis-cli"
LOGFILE="/var/log/keepalived-redis-state.log"

echo "[master]" >> $LOGFILE
date >> $LOGFILE
echo "Being master...." >> $LOGFILE 2>&1

echo "Run SLAVEOF cmd ..." >> $LOGFILE
$REDISCLI SLAVEOF 192.168.1.4 6379 >> $LOGFILE  2>&1
sleep 10 #延迟10秒以后待数据同步完成后再取消同步状态  

echo "Run SLAVEOF NO ONE cmd ..." >> $LOGFILE
$REDISCLI SLAVEOF NO ONE >> $LOGFILE 2>&1

$  vim /etc/keepalived/scripts/redis_backup.sh

#!/bin/bash  
REDISCLI="/usr/local/bin/redis-cli"
LOGFILE="/var/log/keepalived-redis-state.log"

echo "[backup]" >> $LOGFILE
date >> $LOGFILE
echo "Being slave...." >> $LOGFILE 2>&1

sleep 15 #延迟15秒待数据被对方同步完成之后再切换主从角色  
echo "Run SLAVEOF cmd ..." >> $LOGFILE
$REDISCLI SLAVEOF 192.168.1.4 6379 >> $LOGFILE  2>&1

3)然后在Master与Slave创建如下相同的脚本：

$  vim /etc/keepalived/scripts/redis_fault.sh

#!/bin/bash  
LOGFILE=/var/log/keepalived-redis-state.log
echo "[fault]" >> $LOGFILE
date >> $LOGFILE

$  vim /etc/keepalived/scripts/redis_stop.sh

#!/bin/bash  
LOGFILE=/var/log/keepalived-redis-state.log
echo "[stop]" >> $LOGFILE
date >> $LOGFILE

6.在主从服务器上面给脚本都加上可执行权限：

$  chmod +x /etc/keepalived/scripts/*.sh

7.进行相关功能测试

启动Master和slave上的Redis

$  /etc/init.d/redis start

启动Master和slave上的Keepalived

$  /etc/init.d/keepalived start

尝试通过VIP连接Redis:

$ redis-cli -h 192.168.0.253 INFO

连接成功，Slave也连接上来了。

role:master

slave0:192.168.1.5,6379,online

尝试插入一些数据：

$ redis-cli -h 192.168.0.253 SET Hello Redis

OK

从VIP读取数据

$ redis-cli -h 192.168.0.253 GET Hello

"Redis"

从Master读取数据

$ redis-cli -h 192.168.0.1 GET Hello

"Redis"

从Slave读取数据

$ redis-cli -h 192.168.0.2 GET Hello

"Redis"

8.通过模拟相关故障，进行功能测试

将Master上的Redis进程杀死：

$  killall -9 redis-server

查看Master上的Keepalived日志

$ tail -f /var/log/keepalived-redis-state.log

[fault]

Thu Sep 27 08:29:01 CST 2012

同时Slave上的日志显示：

$ tail -f /var/log/keepalived-redis-state.log

[master]

2014年 07月 07日 星期一 16:42:52 CST

Being master....

Run SLAVEOF cmd ...

OK Already connected to specified master

Run SLAVEOF NO ONE cmd ...

OK

然后我们可以发现，Slave已经接管服务，并且担任Master的角色了。

$ redis-cli -h 192.168.1.253 INFO

$ redis-cli -h 192.168.1.5 INFO

role:master

然后我们恢复Master的Redis进程

$  /etc/init.d/redis start

查看Master上的Keepalived日志

$ tail -f /var/log/keepalived-redis-state.log

[master]

2014年 07月 07日 星期一 16:48:08 CST

Being master....

Run SLAVEOF cmd ...

OK

Run SLAVEOF NO ONE cmd ...

OK

同时Slave上的日志显示：

$ tail -f /var/log/keepalived-redis-state.log

[backup]

Fri Sep 28 14:16:37 CST 2012

Being slave....

Run SLAVEOF cmd ...

OK

发现目前的Master已经再次恢复了Master的角色，故障切换以及自动恢复都成功了。

参考：http://chwshuang.iteye.com/blog/1881169

     http://birdinroom.blog.51cto.com/7740375/1401663 

     http://birdinroom.blog.51cto.com/7740375/1401493 

Saltstack 利用pillar实现redis多实例部署

http://binbin158.blog.51cto.com/2659767/1383885 

redis主从实现10秒检查与恢复

redis主从架构

问题：redis down重启后，能恢复key值，时间会有延迟，down机之间的值将会丢失。

实验环境，主从做在一台服务器上，利用不同端口。

解决方案：redis主从至今还不算完善，我们利用redis主从主要做redis备份，master宕机后，实现10s内尽可能的恢复key值，主主要做读写，实现快速读写，不做任何备份方式，从就简单实用rdb方式实现备份。

思路原理：

redis有两种持久化方式，rdb 与aof模式，考虑到aof模式增长过快，恢复比较缓慢，就在从上做rdb模式，主down之后，脚本检查主的状态，之后在从上做bgsave，把从上的rdb文件copy到主的data目录里，重新启动主。通过判断主上key值得数量，是否跟从上的数量一样，来判断是否恢复正常，然后就可以实现key值得完全恢复。备份方式为，一个小时copy一次从上的rbd文件，做一个小时一次的备份。

脚本的思路 主要实现上述思路原理，脚本有点别扭，2做了主，1做的redis从。

#!/bin/bash
 
DATE=`date +%Y%m%d%M%s`
REDIS_DIR=/usr/local/redis
REDIS2_DIR=/usr/local/redis2
BIN_DIR=/usr/local/redis/bin
DATA1_DIR=/usr/local/redis/data
DATA2_DIR=/usr/local/redis2/data
PORT1=6378
PORT2=6379
 
function BACKUP_RDB {
    ps -ef |grep $PORT2 >/dev/null
    if  [ $? -eq 0 ];then
        ${BIN_DIR}/redis-cli -p $PORT2 bgsave >/dev/null
        if [ $? -eq 0 ];then
            echo -e "\033[31m MASTER REDIS DOWN AND SLAVE bgsave DONE\033[0m"
            ${BIN_DIR}/redis-cli -p $PORT2 SLAVEOF NO ONE >/dev/null
        fi
     fi
}
 
function CP_RDB {
    [ -d ${DATA1_DIR}/redisbackup ]  || mkdir ${DATA1_DIR}/redisbackup
    if [ -f $DATA2_DIR/dump.rdb ];then
        mv ${DATA1_DIR}/dump.rdb  ${DATA1_DIR}/redisbackup/dump.rdb.$DATE
        cp ${DATA2_DIR}/dump.rdb  ${DATA1_DIR}/
    fi
}
 
function  START_REDIS {
    KEY2_NUM=`${BIN_DIR}/redis-cli -p $PORT2 INFO  |grep db[0-9]*.key |awk -F[:=,] '{total+=$3}END{print total}'`
    ${BIN_DIR}/redis-server ${REDIS_DIR}/etc/redis.conf
    netstat -tnlp |grep "$PORT1" >/dev/null
    a=$?
    if [ $a -ne 0 ];then
        while [ $a -ne 0 ];do
            sleep 2
            netstat -tnlp | grep "127.0.0.1:$PORT1" 1>/dev/null 2>/dev/null
            a=$?
        done
        echo -e "\033[32m MASTER REDIS RUNNING ........\033[0m"
        sleep 7
        KEY1_NUM=`${BIN_DIR}/redis-cli -p $PORT1  INFO  |grep db[0-9]*.key |awk -F[:=,] '{total+=$3}END{print 
 
total}'`
#        echo ${KEY1_NUM}
        if [ $KEY1_NUM -ge $KEY2_NUM ];then
            ${BIN_DIR}/redis-cli -p $PORT2 SLAVEOF 127.0.0.1 $PORT1 >/dev/null
            echo -e "\033[32m MASTER AND SLAVE are Normal sync \033[0m"
        else
            echo -e "\033[31m KEY NUM are not equal, MASTER AND SLAVE are not Normal sync,place to check ! \033[0m"
            break
        fi
    else
        echo -e "\033[32m MASTER REDIS RUNNING ........\033[0m"
        sleep 7
        KEY1_NUM=`${BIN_DIR}/redis-cli -p $PORT1 INFO  |grep db[0-9]*.key |awk -F[:=,] '{total+=$3}END{print total}'`
#        echo ${KEY1_NUM}
        if [ $KEY1_NUM -ge $KEY2_NUM ];then
            ${BIN_DIR}/redis-cli -p $PORT2 SLAVEOF 127.0.0.1 $PORT1 >/dev/null
            echo -e "\033[32m MASTER AND SLAVE are Normal sync \033[0m"
        else
            echo -e "\033[31m KEY NUM are not equal, MASTER AND SLAVE are not Normal sync,place to check ! \033[0m"
            break
        fi
    fi
}
 
 
while true;do
    sleep 10
    netstat -tnlp | grep "127.0.0.1:$PORT1" 1>/dev/null 2>/dev/null
    TRAP1=$?
    ps -ef |grep "$PORT1" >/dev/null
    TRAP2=$?
    if [ $TRAP1 -ne  0 ] || [ $TRAP2 -ne  0 ];then
        #echo redis-master down
        BACKUP_RDB
        CP_RDB
        START_REDIS
    fi
done

在恢复的过程中，比较主的key和主宕机后从的key，来判断是否恢复正常，

遇到的问题：在恢复过程中，主key的值一直小于从的key的值，但是主启动完全正常，key值也完全一样，经过思考发现，是程序执行问题，脚本执行太快，当执行到比较的时候，key值得数量未完全恢复，只是时间的问题，所以执行了sleep 3 秒之后，一切正常。大家要根据自己key值得数量的大小来决定判断sleep的时间。

转载于:https://blog.51cto.com/hao360/1435297