一、Redis简介

Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

Redis官网地址：http://redis.io/

Redis中文网地址：http://redis.cn

Redis中文文档地址：http://redisdoc.com

二、Redis安装

系统环境：CentOS 6.8 mininal 初始化完成

      下载，解压，编译:

wget http://download.redis.io/releases/redis-3.2.3.tar.gz -P /usr/local/src/

cd /usr/local/src && tar zxvf redis-3.2.3.tar.gz && cd redis-3.2.3 && make

#make test 报错

解决：

yum -y install tcl

#make test 报错

*** [err]: Test replication partial resync: ok psync 

■ 解决办法：

1，只用单核运行 make test：

taskset -c 1 sudo make test

2，更改 tests/integration/replication-psync.tcl 文件：

vi tests/integration/replication-psync.tcl

把对应报错的那段代码中的 after后面的数字，从100改成 500。我个人觉得，这个参数貌似是等待的毫秒数。

这两种方法都可以解决这个报错。

#设置系统内核参数

echo 512 > /proc/sys/net/core/somaxconn

sysccp mkreleasehdr.sh redis-benchmark redis-sentinel redis-server redis-trib.rb redis-cli /opt/cluster/tl -w vm.overcom/此处的命令和添加一个主节点命令类似，此处并没有指定添加的这个从节点的主节点，这种情况下系统会在其他的复制集中的主节点中随机选取一个作为这个从节点的主节点。
你redis-trib.rb check 127.0.0.1:7000可以通过下面的命令指定主节点:optredis-trib.rb add-node --slave 127.0.0.1:7006 127.0.0.1:7000

/cluster/bin/redis-server /opt/cluster/7001/7001.confmit_memory=1

三、Redis集群教程

Redis 集群是一个提供在多个Redis间节点间共享数据的程序集。
Redis集群并不支持处理多个keys的命令,因为这需要在不同的节点间移动数据,从而达不到像Redis那样的性能,在高负载的情况下可能会导致不可预料的错误.
Redis 集群通过分区来提供一定程度的可用性,在实际环境中当某个节点宕机或者不可达的情况下继续处理命令.

Redis 集群是一个分布式（distributed）、容错（fault-tolerant）的 Redis 实现， 集群可以使用的功能是普通单机 Redis 所能使用的功能的一个子集（subset）。

Redis 集群中不存在中心（central）节点或者代理（proxy）节点， 集群的其中一个主要设计目标是达到线性可扩展性（linear scalability）。

Redis 集群为了保证一致性（consistency）而牺牲了一部分容错性： 系统会在保证对网络断线（net split）和节点失效（node failure）具有有限（limited）抵抗力的前提下， 尽可能地保持数据的一致性。

3.2、Redis 集群的优势:

自动分割数据到不同的节点上。
整个集群的部分节点失败或者不可达的情况下能够继续处理命令。
Redis 集群的数据分片
Redis 集群没有使用一致性hash, 而是引入了 哈希槽的概念.
Redis 集群有16384个哈希槽,每个key通过CRC16校验后对16384取模来决定放置哪个槽.集群的每个节点负责一部分hash槽,举个例子,比如当前集群有3个节点,那么:
节点 A 包含 0 到 5500号哈希槽.
节点 B 包含5501 到 11000 号哈希槽.
节点 C 包含11001 到 16384号哈希槽.
这种结构很容易添加或者删除节点. 比如如果我想新添加个节点D, 我需要从节点 A, B, C中得部分槽到D上. 如果我像移除节点A,需要将A中得槽移到B和C节点上,然后将没有任何槽的A节点从集群中移除即可. 由于从一个节点将哈希槽移动到另一个节点并不会停止服务,所以无论添加删除或者改变某个节点的哈希槽的数量都不会造成集群不可用的状态.

为了使在部分节点失败或者大部分节点无法通信的情况下集群仍然可用，所以集群使用了主从复制模型,每个节点都会有N-1个复制品.
在我们例子中具有A，B，C三个节点的集群,在没有复制模型的情况下,如果节点B失败了，那么整个集群就会以为缺少5501-11000这个范围的槽而不可用.
然而如果在集群创建的时候（或者过一段时间）我们为每个节点添加一个从节点A1，B1，C1,那么整个集群便有三个master节点和三个slave节点组成，这样在节点B失败后，集群便会选举B1为新的主节点继续服务，整个集群便不会因为槽找不到而不可用了
不过当B和B1 都失败后，集群是不可用的.
Redis 一致性保证
Redis 并不能保证数据的强一致性. 这意味这在实际中集群在特定的条件下可能会丢失写操作.
第一个原因是因为集群是用了异步复制. 写操作过程:
客户端向主节点B写入一条命令.
主节点B向客户端回复命令状态.
主节点将写操作复制给他得从节点 B1, B2 和 B3.
主节点对命令的复制工作发生在返回命令回复之后， 因为如果每次处理命令请求都需要等待复制操作完成的话， 那么主节点处理命令请求的速度将极大地降低 —— 我们必须在性能和一致性之间做出权衡。 注意：Redis 集群可能会在将来提供同步写的方法。 Redis 集群另外一种可能会丢失命令的情况是集群出现了网络分区， 并且一个客户端与至少包括一个主节点在内的少数实例被孤立。
举个例子 假设集群包含 A 、 B 、 C 、 A1 、 B1 、 C1 六个节点， 其中 A 、B 、C 为主节点， A1 、B1 、C1 为A，B，C的从节点， 还有一个客户端 Z1 假设集群中发生网络分区，那么集群可能会分为两方，大部分的一方包含节点 A 、C 、A1 、B1 和 C1 ，小部分的一方则包含节点 B 和客户端 Z1 .
Z1仍然能够向主节点B中写入, 如果网络分区发生时间较短,那么集群将会继续正常运作,如果分区的时间足够让大部分的一方将B1选举为新的master，那么Z1写入B中得数据便丢失了.
注意， 在网络分裂出现期间， 客户端 Z1 可以向主节点 B 发送写命令的最大时间是有限制的， 这一时间限制称为节点超时时间（node timeout）， 是 Redis 集群的一个重要的配置选项：

3.3、搭建并使用Redis集群

#随意移动到一个新目录下，本文以/opt为例：

cd /opt && mkdir cluster && cd cluster

mkdir 7000 7001 7002 7003 7004 7005

#拷贝redis.conf到上面创建的6个子目录中，本文以7000为例

#修改redis.conf相关配置参数
daemonize yes
pidfile /var/run/redis/7000.pid
port 7000
logfile "/var/log/redis/7000.log"

#注释掉以下信息，不需要RDB持久化
#save 900 1
#save 300 10
#save 60 10000

#更改以下参数
appendonly yes
appendfilename "appendonly-7000.aof"

#取消以下参数注释，使redis工作在集群模式下
cluster-enabled yes   #启动cluster模式
cluster-config-file nodes-7000.conf   #集群信息文件名。由redis自己维护
cluster-node-timeout 15000   #15秒联系不到对方的node，即认为对方有故障可能

#修改MAXMEMORY POLICY
maxmemory-policy allkeys-lru
maxmemory-samples 5

#完整redis.conf配置如下：

bind 192.168.0.51 127.0.0.1
protected-mode yes
port 7000
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize yes
supervised no
pidfile /var/run/redis/7000.pid
loglevel notice
logfile "/var/log/redis/7000.log"
databases 16
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump_7000.rdb
dir /opt/cluster/rdb/
slave-serve-stale-data yes
slave-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
slave-priority 100
maxmemory-policy allkeys-lru
maxmemory-samples 5
appendonly yes
appendfilename "appendonly-7000.aof"
appendfsync everysec

protected-mode yes
port 7000
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize yes
supervised no
pidfile /var/run/redis/7000.pid
loglevel notice
logfile "/var/log/redis/7000.log"
databases 16
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump_7000.rdb
dir /opt/cluster/rdb/
slave-serve-stale-data yes
slave-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
slave-priority 100
maxmemory-policy allkeys-lru
maxmemory-samples 5
appendonly yes
appendfilename "appendonly-7000.aof"
appendfsync everysec
no-appendfsync-on-rewrite no

appendfilename "appendonly-7000.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
lua-time-limit 5000
cluster-enabled yes
cluster-config-file /opt/cluster/nodes/nodes-7000.conf
cluster-node-timeout 15000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes

#拷贝redis的相关命令到/opt/cluster/bin目录下，并设置环境变量

mkdir /opt/cluster/bin

cd /usr/local/src/redis-3.2.3/src/

cp mkreleasehdr.sh redis-benchmark redis-sentinel redis-server redis-trib.rb redis-cli /opt/cluster/bin

cp /usr/local/src/redis-3.2.3/^Cntest runtest-sentinel runtest-cluster /opt/cluster/bin/

#查看

#创建软链接

ln -s /opt/cluster/bin/* /usr/bin/

#把修改好的redis.conf文件，分别拷贝到6个子目录下，以目录名命名配置文件（自定义），然后依次修改配置文件中的端口号，以7000.conf文件为例：

sed -i 's/7000/7001/g' /opt/cluster/7001/7001.conf

sed -i 's/7000/7002/g' /opt/cluster/7002/7002.conf

...

sed -i 's/7000/7005/g' /opt/cluster/7005/7005.conf

#创建配置文件中修改的目录

 mkdir -p /var/run/redis /var/log/redis /opt/cluster/{rdb,nodes}

#依次启动redis实例

/opt/cluster/bin/redis-server /opt/cluster/7000/7000.conf

/opt/cluster/bin/redis-server /opt/cluster/7001/7001.conf

...

#查看redis启动日志，检查是否有启动报错，如下图：

#warning处理

1432:M 17 Oct 11:21:35.952 # Server started, Redis version 3.2.3
1432:M 17 Oct 11:21:35.952 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
1432:M 17 Oct 11:21:35.952 * The server is now ready to accept connections on port 7005

#启动redis需要调整个别内核参数，根据提示修改sysct.conf,执行下面命令（如果之前设置过，不需要重复操作）

sysctl -a | grep vm.overcommit_memory  #查看vm.overcommit_memory的值，如为1，不需要修改，若为0 ，执行

sysctl vm.overcommit_memory=1

#从redis的启动日志及服务状态可以看出，到此redis的6个实例都已启动完成。

四、搭建redis集群

   现在有了六个正在运行中的 Redis 实例， 接下来需要使用这些实例来创建集群， 并为每个节点编写配置文件。通过使用 Redis 集群命令行工具 redis-trib ， 编写节点配置文件的工作可以非常容易地完成： redis-trib 位于 Redis 源码的 src 文件夹中， 它是一个 Ruby 程序， 这个程序通过向实例发送特殊命令来完成创建新集群， 检查集群， 或者对集群进行重新分片（reshared）等工作。

4.1、安装ruby环境,及安装redis的ruby依赖接口

yum install ruby ruby-devel rubygems -y && gem install redis

require './cluster'

startup_nodes = [

{:host => "127.0.0.1", :port => 7000},

{:host => "127.0.0.1", :port => 7001}

]

rc = RedisCluster.new(startup_nodes,32,:timeout => 0.1)

last = false

while not last

begin

last = rc.get("__last__")

last = 0 if !last

rescue => e

puts "error #{e.to_s}"

sleep 1

end

end

((last.to_i+1)..1000000000).each{|x|

begin

rc.set("foo#{x}",x)

puts rc.get("foo#{x}")

rc.set("__last__",x)

rescue => e

puts "error #{e.to_s}"

end

sleep 0.1

}

#这个应用所做的工作非常简单： 它不断地以 foo<number> 为键， number 为值， 使用 SET 命令向数据库设置键值对:
SET foo0 0
SET foo1 1
SET foo2 2
And so forth…
代码中的每个集群操作都使用一个 begin 和 rescue 代码块（block）包裹着， 因为我们希望在代码出错时， 将错误打印到终端上面， 而不希望应用因为异常（exception）而退出。
代码的第七行是代码中第一个有趣的地方， 它创建了一个 Redis 集群对象， 其中创建对象所使用的参数及其意义如下：第一个参数是记录了启动节点的 startup_nodes 列表， 列表中包含了两个集群节点的地址。第二个参数指定了对于集群中的各个不同的节点， Redis 集群对象可以获得的最大连接数 ，第三个参数 timeout 指定了一个命令在执行多久之后， 才会被看作是执行失败。
启动列表中并不需要包含所有集群节点的地址， 但这些地址中至少要有一个是有效的： 一旦 redis-rb-cluster 成功连接上集群中的某个节点时， 集群节点列表就会被自动更新， 任何真正的的集群客户端都应该这样做。
现在， 程序创建的 Redis 集群对象实例被保存到 rc 变量里面， 我们可以将这个对象当作普通 Redis 对象实例来使用。
在十一至十九行， 我们先尝试阅读计数器中的值， 如果计数器不存在的话， 我们才将计数器初始化为 0 ： 通过将计数值保存到 Redis 的计数器里面， 我们可以在示例重启之后， 仍然继续之前的执行过程， 而不必每次重启之后都从 foo0 开始重新设置键值对。为了让程序在集群下线的情况下， 仍然不断地尝试读取计数器的值， 我们将读取操作包含在了一个 while 循环里面， 一般的应用程序并不需要如此小心。
二十一至三十行是程序的主循环， 这个循环负责设置键值对， 并在设置出错时打印错误信息。程序在主循环的末尾添加了一个 sleep 调用， 让写操作的执行速度变慢， 帮助执行示例的人更容易看清程序的输出。执行 example.rb 程序将产生以下输出：

consistency-test.rb

require './cluster'

class ConsistencyTester

def initialize(redis)

@r = redis

@working_set = 1000

@keyspace = 10000

@writes = 0

@reads = 0

@failed_writes = 0

@failed_reads = 0

@lost_writes = 0

@not_ack_writes = 0

@delay = 0

@cached = {} # We take our view of data stored in the DB.

@prefix = [Process.pid.to_s,Time.now.usec,@r.object_id,""].join("|")

@errtime = {}

end

def genkey

# Write more often to a small subset of keys

ks = rand() > 0.5 ? @keyspace : @working_set

@prefix+"key_"+rand(ks).to_s

end

def check_consistency(key,value)

expected = @cached[key]

return if !expected # We lack info about previous state.

if expected > value

@lost_writes += expected-value

elsif expected < value

@not_ack_writes += value-expected

end

end

def puterr(msg)

if !@errtime[msg] || Time.now.to_i != @errtime[msg]

puts msg

end

@errtime[msg] = Time.now.to_i

end

def test

last_report = Time.now.to_i

while true

# Read

key = genkey

begin

val = @r.get(key)

check_consistency(key,val.to_i)

@reads += 1

rescue => e

puterr "Reading: #{e.to_s}"

@failed_reads += 1

end

# Write

begin

@cached[key] = @r.incr(key).to_i

@writes += 1

rescue => e

puterr "Writing: #{e.to_s}"

@failed_writes += 1

end

# Report

sleep @delay

if Time.now.to_i != last_report

report = "#{@reads} R (#{@failed_reads} err) | " +

"#{@writes} W (#{@failed_writes} err) | "

report += "#{@lost_writes} lost | " if @lost_writes > 0

report += "#{@not_ack_writes} noack | " if @not_ack_writes > 0

last_report = Time.now.to_i

puts report

end

end

end

end

if ARGV.length != 2

puts "Usage: consistency-test.rb <hostname> <port>"

exit 1

else

startup_nodes = [

{:host => ARGV[0], :port => ARGV[1].to_i}

]

end

rc = RedisCluster.new(startup_nodes,32,:timeout => 0.1)

tester = ConsistencyTester.new(rc)

tester.test

#运行 consistency-test 程序将产生类似以下的输出：
$ ruby consistency-test.rb
925 R (0 err) | 925 W (0 err) |
5030 R (0 err) | 5030 W (0 err) |
9261 R (0 err) | 9261 W (0 err) |
13517 R (0 err) | 13517 W (0 err) |
17780 R (0 err) | 17780 W (0 err) |
22025 R (0 err) | 22025 W (0 err) |
25818 R (0 err) | 25818 W (0 err) |
结果展示了执行的读和 写,和错误(由于系统不可用而没有接受的查询发生的错误）的数量.
如果程序察觉了不一致的情况出现， 它将在输出行的末尾显式不一致的详细情况。比如说， 如果我们在 consistency-test.rb 运行的过程中， 手动修改某个计数器的值：
$ redis 127.0.0.1:7000> set key_217 0
OK

(in the other tab I see...)

94774 R (0 err) | 94774 W (0 err) |
98821 R (0 err) | 98821 W (0 err) |
102886 R (0 err) | 102886 W (0 err) | 114 lost |
107046 R (0 err) | 107046 W (0 err) | 114 lost |
在我们修改计数器值的时候， 计数器的正确值是 114 （执行了 114 次 INCR 命令）， 因为我们将计数器的值设成了 0 ， 所以 consistency-test.rb 会向我们报告说丢失了 114 个 INCR 命令。
这个程序作为测试程序很有意思，所以我们用这个程序来测试故障恢复.

添加一个新节点

使用同样的方法移除主节点,不过在移除主节点前，需要确保这个主节点是空的. 如果不是空的,需要将这个节点的数据重新分片到其他主节点上.

替代移除主节点的方法是手动执行故障恢复，被移除的主节点会作为一个从节点存在，不过这种情况下不会减少集群节点的数量，也需要重新分片数据.

4.9、从节点的迁移

在Redis集群中会存在改变一个从节点的主节点的情况，需要执行如下命令 :

redis-trib.rb check 127.0.0.1:7000，或者redis-cli -p 7000，cluster nodes查看节点状态

#可以看出：

master：7000 7004 7005

slave: 7003 7001 7002

这里我把slave 7003让其成为7005的slave

redis-cli -p 7003 CLUSTER REPLICATE d7ebd55a131c2180cb7758ec205a0f8c9f9bf990

#从图中可以看出，7003 和7002都已经成为7005的slave。

五、总结

注意自定义相关文件目录的创建，各个节点的配置文件需一致，本文做实验时主要的错误出在redis.conf文件上面，修改bind使其监听本机的地址。