[Redis]()简介

Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库 ，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。

Redis（REmote DIctionary Server，远程数据字典服务器）是开源的内存数据库，常用作缓存或者消息队列。

Redis的特点：

Redis存在于内存，使用硬盘作为持久化；每秒十万读写。
具有丰富的数据结构，字符串、哈希表、列表、集合、有序集合；提供交集、并集、差集等操作。
设置TTL存活时间，到期自动删除。
Redis单线程、Memcached多线程；对于一般的应用场景，单线程也足够使用，优势还是在于多数据类型、持久化。
可以将数据复制到任意数量的从服务器。

[Redis]()部署

一.环境介绍
当前环境：centos7.3一台
软件版本：redis-4.0.6
部署目录：/usr/local/redis
启动端口：6379
配置文件：/usr/local/redis/redis.conf
二.安装
1.安装依赖
yum -y install gcc
2.编译安装redis
wget http://download.redis.io/releases/redis-4.0.6.tar.gz
tar xzf redis-4.0.6.tar.gz
cd redis-4.0.6
此编译只是将命令文件编译，将会在当前目录生成bin目录
make && make install
返回上一级并移动到/usr/local下
cd ..
mv redis-4.0.6 /usr/local/redis
3.创建环境变量
echo ‘PATH=$PATH’:/usr/local/redis/bin/ >> /etc/profile
source /etc/profile

[Redis]()单点部署

一 . 部署 redis

1.如果没安装redis，或未设置环境变量请参照文章来安装

2.放后台运行，并将日志输出到/tmp/redis
nohup redis-server &> /tmp/redis.log &

3.查看端口
netstat -unltp | grep :6379

二 . 测试

连接redis服务
redis-cli

创建值并读取
set name xx
get name

[Redis]()集群部署

一.介绍

官方介绍

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

当某个主节点挂掉，从节点将接任做主，如果都挂掉集群将报错。当从一个节点操作，根据一致性哈希计算后将存储在其中一个主节点中，从节点将同步主的数据

二.环境介绍

当前环境：centos7.3 二台
启动端口：7000 7001 7002 7003 7004 7005
配置文件：/usr/local/redis/cluster/

三.部署redis

1.如果没安装redis，请参照文章来安装

2.移动到安装目录，每台机器创建3个节点

cd /usr/local/redis
 mkdir -p cluster/{7000,7001,7002}

四.创建节点

在7000目录创建7000.conf配置文件，以此类推
更改如下4处，依次修改后，删除注释

vim cluster/7000/7000.conf
1.    bind 0.0.0.0
2.    protected-mode yes
3.    port 7000    #更改为对应端口
4.    cluster-enabled yes
5.    cluster-config-file nodes_7000.conf  #更改为对应文件
6.    cluster-node-timeout 5000
7.    tcp-backlog 511
8.    timeout 0
9.    tcp-keepalive 300
10.    daemonize yes
11.    supervised no
12.    pidfile redis_7000.pid #更改为对应pid文件
13.    loglevel notice
14.    logfile redis-server.log
15.    databases 16
16.    save 900 1
17.    save 300 10
18.    save 60 10000
19.    stop-writes-on-bgsave-error yes
20.    rdbcompression yes
21.    rdbchecksum yes
22.    dbfilename dump.rdb
23.    dir /root/redis/cluster/7000 #不同端口分开
24.    slave-serve-stale-data yes
25.    slave-read-only yes
26.    repl-diskless-sync no
27.    repl-diskless-sync-delay 5
28.    repl-disable-tcp-nodelay no
29.    slave-priority 100
30.    appendonly yes
31.    appendfilename "appendonly.aof"
32.    appendfsync everysec
33.    no-appendfsync-on-rewrite no
34.    auto-aof-rewrite-percentage 100
35.    auto-aof-rewrite-min-size 64mb
36.    aof-load-truncated yes
37.    lua-time-limit 5000
38.    slowlog-log-slower-than 10000
39.    slowlog-max-len 128
40.    latency-monitor-threshold 0
41.    notify-keyspace-events ""
42.    hash-max-ziplist-entries 512
43.    hash-max-ziplist-value 64
44.    list-max-ziplist-size -2
45.    list-compress-depth 0
46.    set-max-intset-entries 512
47.    zset-max-ziplist-entries 128
48.    zset-max-ziplist-value 64
49.    hll-sparse-max-bytes 3000
50.    activerehashing yes
51.    client-output-buffer-limit normal 0 0 0
52.    client-output-buffer-limit slave 256mb 64mb 60
53.    client-output-buffer-limit pubsub 32mb 8mb 60
54.    hz 10
55.    aof-rewrite-incremental-fsync yes

4.创建启动脚本（所有机器操作）
每个节点创建一个启动脚本，当前机器将创建3个

cd /usr/local/bin
vim redis-7000
1.    #!/bin/sh
2.    
3.    REDISPORT=7000   ##更改全局变量端口
4.    install_dir=/usr/local/redis
5.    
6.    EXEC=${install_dir}/bin/redis-server
7.    CLIEXEC=${install_dir}/bin/redis-cli
8.    PIDFILE=${install_dir}/redis_${REDISPORT}.pid
9.    CONF="${install_dir}/cluster/${REDISPORT}/${REDISPORT}.conf"
10.    
11.    case "$1" in
12.        start)
13.            if [ -f $PIDFILE ]
14.            then
15.                    echo "$PIDFILE exists, process is already running or crashed"
16.            else
17.                    echo "Starting Redis server..."
18.                    $EXEC $CONF
19.            fi
20.            ;;
21.        stop)
22.            if [ ! -f $PIDFILE ]
23.            then
24.                    echo "$PIDFILE does not exist, process is not running"
25.            else
26.                    PID=$(cat $PIDFILE)
27.                    echo "Stopping ..."
28.                    $CLIEXEC -p $REDISPORT shutdown
29.                    while [ -x /proc/${PID} ]
30.                    do
31.                        echo "Waiting for Redis to shutdown ..."
32.                        sleep 1
33.                    done
34.                    echo "Redis stopped"
35.            fi
36.            ;;
37.        *)
38.            echo "Please use start or stop as first argument"
39.            ;;
40.    esac

5.启动所有节点，每个脚本启动一次

chmod +x redis-*
redis-7000 start

使用ps -ef |grep redis查看是否启动
netstat -tnulp 查看端口是否被监听

五.创建集群

选择其中一台机器做集群的创建端

1.安装依赖包

yum install ruby ruby-devel rubygems rpm-build

如果提示ruby版本太低，yum没装上，请参考这篇文章安装ruby

gem install redis

2.启动集群
集群要求最低6个节点--replicas 1 表示为每个主节点创建一个从节点，如果为2就要一主两从了。前一半的节点皆为主，后面为从
这个ip地址为集群互相可以通信的ip

/usr/local/redis/src/redis-trib.rb create --replicas 1 172.26.98.239:7000 172.26.98.239:7001 172.26.98.239:7002 172.26.98.240:7003 172.26.98.240:7004 172.26.98.240:7005

六.集群测试

连接集群要加-c

redis-cli -c -p 7000

打印集群的信息

cluster info

列出集群当前已知的所有节点（node），以及这些节点的相关信息。

cluster nodes

[Redis]()主从部署

一.介绍

redis主从和其他服务的主从一样，一个主节点，后面可以有多个从节点。
1.避免Redis单点故障
2.构建读写分离架构，满足读多写少的应用场景

二.环境介绍

当前环境：centos7.3 一台
启动端口：6380 6381 6382

三.准备

1.进行单实例部署
到部署目录，创建3个文件夹，一次修改

mkdir master_6380 slave_6381 slave_6382

2.将单实例的配置文件依次复制到文件夹

cp redis.conf master_6380/

四.配置master

1.修改端口为6380

vim master_6380/redis.conf
1.    # Accept connections on the specified port, default is 6379 (IANA #815344).
2.    # If port 0 is specified Redis will not listen on a TCP socket.
3.    port 6380

往下拉找到pidfile，修改为6380.pid

1.    # If a pid file is specified, Redis writes it where specified at startup
2.    # and removes it at exit.
3.    #
4.    # When the server runs non daemonized, no pid file is created if none is
5.    # specified in the configuration. When the server is daemonized, the pid file
6.    # is used even if not specified, defaulting to "/var/run/redis.pid".
7.    #
8.    # Creating a pid file is best effort: if Redis is not able to create it
9.    # nothing bad happens, the server will start and run normally.
10.    pidfile /var/run/redis_6380.pid

2.设置读写分离（可选）
在配置文件中加一行，让从只能读

1.   slave-read-only yes

3.启动

nohup bin/redis-server master_6380/redis.conf &> /tmp/redis.log &
netstat -unltp |grep redis

3.验证是否为master

src/redis-cli -p 6380 info | grep role

五.配置slave

2个从和master配置一样，修改不同端口号，但不要启动，并且不要加读写分离那一行

1.永久为从

1.在配置文件中配置从服务，配置文件往下拉

我们可以在配置文件中直接修改 slaveof 属性，我们直接配置主服务器的ip 地址，和端口号，如果这里主服务器有配置密码可以通过配置masterauth 来设置链接密码

启动

nohup src/redis-server slave_6381/redis.conf &> /tmp/two.log &
 netstat -unltp |grep redis

验证是否为slave

src/redis-cli -p 6381 info | grep role

特点
在当前slave掉线后，再启动会自动链接到master

2.临时做从

在启动后配置

nohup src/redis-server slave_6382/redis.conf &> /tmp/three.log &
netstat -unltp |grep redis

查看是否为master

src/redis-cli -p 6382 info | grep role

命令行切换到从

src/redis-cli -p 6382
127.0.0.1:6382> slaveof 127.0.0.1 6380

特点
在当前slave掉线后，再启动会从服务器会读取自己本地的 rdb 回复数据，而不会去自动链接主服务

[Redis]()哨兵部署

一.介绍

参考1
参考2

Sentinel(哨兵)是用于监控redis集群中Master状态的工具，其已经被集成在redis2.4+的版本中

Sentinel系统时刻监控着主和从，当主挂掉后选择其中一个从来升任成主，可以启动多个Sentinel来避免监控挂掉

Sentinel作用

Master状态检测
如果Master异常，则会进行Master-Slave切换，将其中一个Slave作为Master，将之前的Master作为Slave
Master-Slave切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换

Sentinel工作方式

每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令
如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值，则这个实例会被 Sentinel 标记为主观下线。
如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。
当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态，则Master会被标记为客观下线
在一般情况下，每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令
当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次
若没有足够数量的 Sentinel 同意 Master 已经下线， Master 的客观下线状态就会被移除。
若 Master 重新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。

主观下线和客观下线

主观下线：Subjectively Down，简称 SDOWN，指的是当前 Sentinel 实例对某个redis服务器做出的下线判断。
客观下线：Objectively Down，简称 ODOWN，指的是多个 Sentinel 实例在对Master Server做出 SDOWN 判断，并且通过 SENTINEL is-master-down-by-addr 命令互相交流之后，得出的Master Server下线判断，然后开启failover.

二.准备

如果没有安装redis主从，请参考这篇文章

三.配置Sentinel 哨兵

1.配置端口，和redis一样，要启动多个实例，可以复制配置文件不同名字和修改不同端口启动
vim sentinel.conf

2.配置主服务器的ip 和端口
找到那一行，默认开启了需要修改
mymaster 后跟的是master的ip和端口，最后一个1代表我要启动1个实例，只要有1个sentinel认为master下线，就认为该master客观下线。选举产生新的master。
通常最后一个参数不能多于启动的sentinel实例数。否则，掉线后会没反应

3.启动

src/redis-sentinel sentinel.conf

sentinel 启动之后，就会监视到现在有一个主服务器，两个从服务器
开启另一个终端，当我们把其中一个从服务器关闭之后，我们可以看到日志变动

4.关闭master
我们手动关闭Master 之后，sentinel 在监听master 确实是断线了之后，将会开始计算权值，然后重新分配主服务器

在master重新连接后，将变成从

四.Sentinel命令

连接哨兵：

src/redis-cli -p 26379

命令：
sentinel的基本状态信息
INFO

列出所有被监视的主服务器，以及这些主服务器的当前状态
SENTINEL masters

列出给定主服务器的所有从服务器，以及这些从服务器的当前状态
SENTINEL slaves

返回给定名字的主服务器的 IP 地址和端口号
SENTINEL get-master-addr-by-name

重置所有名字和给定模式 pattern 相匹配的主服务器。重置操作清除主服务器目前的所有状态，包括正在执行中的故障转移，并移除目前已经发现和关联的，主服务器的所有从服务器和 Sentinel 。
SENTINEL reset

当主服务器失效时，在不询问其他 Sentinel 意见的情况下，强制开始一次自动故障迁移，但是它会给其他sentinel发送一个最新的配置，其他sentinel会根据这个配置进行更新
SENTINEL failover

[Redis-browser]()

一.介绍

官网

redis浏览器
特征

列出所有键为树
查看所有redis类型的内容
列表分页
漂亮的打印JSON值
搜索键
可以作为引擎安装到Rails应用程序
可以连接到多个数据库

二.环境

当前环境：centos7.3 一台
软件版本：redis-browser
部署目录：/usr/local/redis-browser
日志目录：/tmp/redis-brower.log
启动端口：1234
配置文件：/usr/local/redis-browser/config.yml

三.安装

安装gem

yum -y install gem

安装nodejs，如果提示没有这个包单独装

yum -y install nodejs

更新gem

gem update --system

更换源

gem sources --add https://gems.ruby-china.org/ --remove https://rubygems.org/

安装redis-browser，如果提示版本小于2.4.1，往后拉，看报错板块

gem install redis redis-browser

四.启动

1.监听单台

nohup redis-browser -B 0.0.0.0 -p 6380 -P 1234 &> /tmp/redis-browser.log

2.监听多台

创建目录

mkdir /usr/local/redis-browser
cd /usr/local/redis-browser

创建配置文件，service2为名称，会在图形界面看到，从第二台开始添加

vim config.yml
1.    connections:
2.      service2:
3.        host: 192.168.1.11
4.        port: 7002
5.        db: 0
6.        url_db_0: redis://192.168.1.11:7002/0
7.      service3:
8.        host: 192.168.1.12
9.        port: 7004
10.        db: 0
11.        url_db_0: redis://192.168.1.12:7004/0

第一台的ip和端口写到命令行中

nohup redis-browser -C config.yml -U redis://192.168.1.10:7000 -B 0.0.0.0 -P 1234 >> /tmp/redis-browser.log &

登陆后右上角可以切换不同redis

#### 五.报错合集

YAML safe loading is not available. Please upgrade psych to a version that supports safe loading (>=

ruby版本太低
使用rvm安装新版本，会较慢，耐心等待
rvm install 2.4.1

设置默认2.4.1
rvm use 2.4.1 --default

# [Redis info]()参数

官网

info命令可以获取信息
提示：集群中每个几点获取的信息不一样

1.    # Server
2.    redis_version:2.6.9
3.    redis_git_sha1:00000000    
4.    redis_git_dirty:0
5.    redis_mode:standalone
6.    os:Linux 3.4.9-gentoo x86_64
7.    arch_bits:64
8.    multiplexing_api:epoll            # redis的事件循环机制
9.    gcc_version:4.6.3
10.    process_id:18926
11.    run_id:df8ad7574f3ee5136e8be94aaa6602a0079704cc    # 标识redis server的随机值
12.    tcp_port:6379
13.    uptime_in_seconds:120            # redis server启动的时间(单位s)
14.    uptime_in_days:0                # redis server启动的时间(单位d)
15.    lru_clock:321118                # Clock incrementing every minute, for LRU management TODO 不清楚是如何计算的
16.    
17.    # Clients
18.    connected_clients:3                # 连接的客户端数
19.    client_longest_output_list:0    # 当前客户端连接的最大输出列表    TODO
20.    client_biggest_input_buf:0        # 当前客户端连接的最大输入buffer TODO
21.    blocked_clients:0                # 被阻塞的客户端数
22.    
23.    # Memory
24.    used_memory:573456                # 使用内存，单位B
25.    used_memory_human:560.02K        # human read显示使用内存
26.    used_memory_rss:1798144            # 系统给redis分配的内存（即常驻内存）
27.    used_memory_peak:551744            # 内存使用的峰值大小
28.    used_memory_peak_human:538.81K    # human read显示内存使用峰值
29.    used_memory_lua:31744            # lua引擎使用的内存
30.    mem_fragmentation_ratio:3.14    # used_memory_rss/used_memory比例，一般情况下，used_memory_rss略高于used_memory，当内存碎片较多时，则mem_fragmentation_ratio会较大，可以反映内存碎片是否很多
31.    mem_allocator:jemalloc-3.3.1    # 内存分配器
32.    
33.    # Persistence
34.    ##########################
35.    # rdb和aof事redis的两种持久化机制
36.    #
37.    # rdb是通过配置文件设置save的时间的改动数量来操作
38.    # 把上次改动后的数据达到设置的指标后保存到db
39.    # 如果中间发生了crash，则数据会丢失
40.    # 这种策略被叫做快照
41.    #
42.    # aof是持续的把写操作执行写入一个类似日志的文件
43.    # 但是会影响应能
44.    # 分为appendfsync always和appendfsync eversec
45.    # 前者每次写操作都同步，数据安全性高，但是特别消耗性能
46.    # 后者每秒同步一次，如果发生crash，则可能会丢失1s的数据
47.    ##########################
48.    loading:0                        #
49.    rdb_changes_since_last_save:0    # 自上次dump后rdb的改动
50.    rdb_bgsave_in_progress:0        # 标识rdb save是否进行中
51.    rdb_last_save_time:1366359865    # 上次save的时间戳
52.    rdb_last_bgsave_status:ok        # 上次的save操作状态
53.    rdb_last_bgsave_time_sec:-1        # 上次rdb save操作使用的时间(单位s)
54.    rdb_current_bgsave_time_sec:-1    # 如果rdb save操作正在进行，则是所使用的时间
55.    ----------------------------
56.    aof_enabled:0                    # 是否开启aof，默认没开启
57.    aof_rewrite_in_progress:0        # 标识aof的rewrite操作是否在进行中
58.    aof_rewrite_scheduled:0            # 标识是否将要在rdb save操作结束后执行
59.    aof_last_rewrite_time_sec:-1    # 上次rewrite操作使用的时间(单位s)
60.    aof_current_rewrite_time_sec:-1 # 如果rewrite操作正在进行，则记录所使用的时间
61.    aof_last_bgrewrite_status:ok    # 上次rewrite操作的状态
62.    -----------------------------
63.    # 开启aof后增加的一些info信息
64.    aof_current_size:0                # aof当前大小
65.    aof_base_size:0                    # aof上次启动或rewrite的大小
66.    aof_pending_rewrite:0            # 同上面的aof_rewrite_scheduled
67.    aof_buffer_length:0                # aof buffer的大小
68.    aof_rewrite_buffer_length:0        # aof rewrite buffer的大小
69.    aof_pending_bio_fsync:0            # 后台IO队列中等待fsync任务的个数
70.    aof_delayed_fsync:0                # 延迟的fsync计数器 TODO
71.    -----------------------------
72.    
73.    # Stats
74.    total_connections_received:7    # 自启动起连接过的总数
75.    total_commands_processed:7        # 自启动起运行命令的总数
76.    instantaneous_ops_per_sec:0        # 每秒执行的命令个数
77.    rejected_connections:0            # 因为最大客户端连接书限制，而导致被拒绝连接的个数
78.    expired_keys:0                    # 自启动起过期的key的总数
79.    evicted_keys:0                    # 因为内存大小限制，而被驱逐出去的键的个数
80.    keyspace_hits:0                    # 在main dictionary(todo)中成功查到的key个数
81.    keyspace_misses:0                # 同上，未查到的key的个数
82.    pubsub_channels:0                # 发布/订阅频道数
83.    pubsub_patterns:0                # 发布/订阅模式数
84.    latest_fork_usec:0                # 上次的fork操作使用的时间（单位ms）
85.    ##########################
86.    # pubsub是一种消息传送的方式，分为频道和模式两种
87.    # 消息不支持持久化，消息方中断后再连接，前面的消息就会没了
88.    # 频道是指通过SUBSCRIBE指定一个固定的频道来订阅
89.    # 模式是指通过PSUBSCRIBE模式匹配来订阅相关的匹配给定模式的频道
90.    ##########################
91.    
92.    # Replication
93.    role:master                        # 角色
94.    connected_slaves:1                # 连接的从库数
95.    slave0:127.0.0.1,7777,online
96.    -----------------------------
97.    role:slave
98.    master_host:127.0.0.1
99.    master_port:6379
100.    master_link_status:up
101.    master_last_io_seconds_ago:4
102.    master_sync_in_progress:0        # 标识主redis正在同步到从redis
103.    slave_priority:100
104.    slave_read_only:1
105.    connected_slaves:0
106.    
107.    
108.    # CPU
109.    used_cpu_sys:0.00            # redis server的sys cpu使用率
110.    used_cpu_user:0.12            # redis server的user cpu使用率
111.    used_cpu_sys_children:0.00    # 后台进程的sys cpu使用率
112.    used_cpu_user_children:0.00    # 后台进程的user cpu使用率
113.    
114.    # Keyspace
115.    db0:keys=2,expires=0
116.    db1:keys=1,expires=0

[Redis]()配置文件详解待补全

[Redis]()集群操作

redis集群命令

1.检查集群状态

src/redis-trib.rb check 127.0.0.1:7000

在分配key的时候，它会使用 CRC16(‘my_name’)%16384 算法，来计算，将这个 key 放到哪个节点

主节点挂掉再启动，会变成从节点

2.集群加入新节点

redis-trib.rb add-node 127.0.0.1:7006 127.0.0.1:7000

add-node是加入指令，127.0.0.1:7006 表示新加入的节点，127.0.0.1:7000 表示加入
的集群的一个节点，用来辨识是哪个集群，理论上哪个都可以

新加入的0个slots

3.迁移节点

redis-trib.rb reshard 127.0.0.1:7000

它提示我们需要迁移多少slot到7006上，我们可以算一下： 16384/4 = 4096 ，也就是说，为了平衡分配起见，我们需要移动4096个槽点到7006上。

接着， redis-trib 会向你询问重新分片的源节点（source node）, 要从哪个节点中取出 4096
个哈希槽，并将这些槽移动到7006节点上面。
如果我们不打算从特定的节点上取出指定数量的哈希槽，那么可以向 redis-trib 输入all ，这样集群中的所有主节点都会成为源节点， redis-trib 将从各个源节点中各取出一
部分哈希槽，凑够 4096 个，然后移动到7006节点上：

接下来就开始迁移了，并且会询问你是否确认：

输入 yes 并使用按下回车之后， redis-trib 就会正式开始执行重新分片操作，将指定的哈希槽从源节点一个个地移动到7006节点上面。

#### 4.添加slave节点

我们再新建一个节点7007，步骤类似，就先省略了。建好后，启动起来，我们看如何把它加
入到集群中的从节点中：

redis-trib.rb add-node --slave 127.0.0.1:7007 127.0. 0.1:7000

add-node的时候加上 —slave 表示是加入到从节点中，但是这样加，是随机的。这里的命令
行完全像我们在添加一个新主服务器时使用的一样，所以我们没有指定要给哪个主服务器添加
副本。这种情况下，redis-trib 会将7007作为一个具有较少副本的随机的主服务器的副本。

5.移除一个master节点

redis-trib.rb reshard 127.0.0.1:7000

先移动槽点到其他节点

再

redis-trib.rb del-node 127.0.0.1:7000 86d05e7c2b197dc182b5e71069e791d033cf899e

6.移除一个slave节点

redis-trib.rb del-node 127.0.0.1:7008 44321e7d619410dc4e0a8745366610a0d06d2395

[迁移备份]()

[redis-migrate-tool]()

官网

一.简介

redis-migrate-tool是在redis之间迁移数据的一个方便且有用的工具。

特征

快速。
多线程。
基于redis复制。
实时迁移。
在迁移数据的过程中，源redis也可以为用户提供服务。
异构迁移。
Twemproxy和Redis群集支持。
当目标是twemproxy时，按键直接导入到twemproxy后面的redis中。
迁移状态视图。
数据验证机制。

二.测试

环境：
源 192.168.1.91的7001,7002 192.168.1.92的7003,7004 192.168.1.94的7005,7006
目标 192.168.1.91的7007,7008 192.168.1.92的7007,7008 192.168.1.94的7007,7008

连接192.168.1.91的7001端口，查看是否有数据，没有则创建

#### 三.安装

1.安装依赖

yum -y install automake libtool autoconf bzip2 unzip

2.安装软件

wget https://github.com/vipshop/redis-migrate-tool/archive/master.zip
 unzip master.zip
 cd redis-migrate-tool-master
 autoreconf -fvi
 ./configure
 make
 src/redis-migrate-tool -h

3.从集群到集群，其他方式访问官网查看

vim rmt.conf
1.    [source]
2.    type: redis cluster
3.    servers:
4.     - 127.0.0.1:7000
5.    
6.    [target]
7.    type: redis cluster
8.    servers:
9.     - 192.168.1.10:7001
10.    
11.    [common]
12.    listen: 0.0.0.0:8888

src/redis-migrate-tool -c rmt.conf -o log -d

启动后将监听8888端口，不断进行增量同步

四.验证

一致性效验

src/redis-migrate-tool -c rmt.conf log -C redis_check

插入数据效验

src/redis-migrate-tool -c mgr.conf log -C redis_testinsert

## [单点到集群迁移]()

1.环境
源 192.168.1.185的6379
目标 192.168.1.91的7001,7002 192.168.1.92的7003,7004 192.168.1.94的7005,7006

2.准备存储文件
在集群任意节点上查看节点信息，发现当前192.168.1.91的7001端口是master

在192.168.1.185上查询当前key数量并保存，将dump.rdb和appendonly.aof文件发送到192.168.1.91上

3.数据恢复到集群
切换到192.168.1.91上查看集群状态
redis-trib.rb check 192.168.1.91:7001

从刚才的集群状态得知
192.168.1.91:7001 的runid为 f2ebf72a78f2637eead82c219f2fca737a36a371 ，其有 5461 个slots
192.168.1.92:7005 的runid为 99439ae72385633d3c9530a5e4f2afdca22a3e25 ，其有 5462 个slots
192.168.1.94:7003 的runid为 19bc53185ae3e103cf4e9ce15772d88f4900256a ，其有 5461 个slots

将92的slots移动到91上

redis-trib.rb reshard —from 19bc53185ae3e103cf4e9ce15772d88f4900256a —to f2ebf72a78f2637eead82c219f2fca737a36a371 —slots 5461 —yes 192.168.1.91:7001

将94的slots移动到91上

redis-trib.rb reshard —from 99439ae72385633d3c9530a5e4f2afdca22a3e25 —to f2ebf72a78f2637eead82c219f2fca737a36a371 —slots 5462 —yes 192.168.1.91:7001

查看slots是否全部在91上

redis-trib.rb check 192.168.1.91:7001

查找192.168.1.91的存储路径，删除存储文件

复制存储文件

cp /appendonly.aof /dump.rdb /root/

查询当前key数量是否和185单点数量一样

redis-cli -c -p 7001 dbsize

91将slots移动到92上

redis-trib.rb reshard —from f2ebf72a78f2637eead82c219f2fca737a36a371 —to 19bc53185ae3e103cf4e9ce15772d88f4900256a —slots 5461 —yes 192.168.1.91:7001

91将slots移动到94上

redis-trib.rb reshard —from f2ebf72a78f2637eead82c219f2fca737a36a371 —to 99439ae72385633d3c9530a5e4f2afdca22a3e25 —slots 5462 —yes 192.168.1.91:7001

4.测试
查询节点是否归位

redis-trib.rb check 192.168.1.91:7001

查询每个主节点key总量，是否和185单点一样

redis-cli -c -p 7001 dbsize
 redis-cli -c -p 7003 -h 192.168.1.92 dbsize
 redis-cli -c -p 7005 -h 192.168.1.94 dbsize

[报错合集]()1

1.redis连接集群操作报错（error）MOVED

这种情况一般是因为启动redis-cli时没有设置集群模式所导致。redis-cli -p 7000

2.节点关闭后再启动，集群检测不到

当某节点关闭后再启动，用cluster nodes看不到启动的节点，则将那个节点再重启一遍就可以了

3.redis集群关闭后重启报错

[ERR] Node 172.168.63.202:7001 is not empty.
Either the nodealready knows other nodes (check with CLUSTER NODES) or contains some key in database 0.

集群重新启动每个节点不能有数据和配置文件
rm -rf dump.db
rm -rf appendonly.aof
rm -rf nodes.conf

再重新创建集群

4.Redis (error) NOAUTH Authentication required

出现认证问题，应该是设置了认证密码，输入密码既可以啦

注意密码是字符串形式！
auth “yourpassword”