集群
 
现在如果要构造一个真正在生产环境上可使用的可靠的系统，基本都离不开集群的概念，总的来说集群是指由若干互相独立的机器通过高速网络组成的一个整体服务，整个集群的内部实现相对外部是透明的，对外部而言它就像一个独立的服务器。要使若干机器协同工作不是一件简单的事，其核心是如何在多机器之间进行通信及各种任务调度使之协同工作。
在工程上常见的两种集群是——负载均衡集群和高可用集群。
负载均衡集群（Load Balance Cluster），随着系统的处理量的不断增加，很快到达一台机器的处理极限，所以需要更多的机器来分担处理，负载均衡集群一般是通过一定的分发算法把访问流量均匀分布到集群里面的各个机器上进行处理，理想的集群是通过添加机器使处理能力达到线性增长，但现实中往往处理过程并非是无状态的，会涉及到一些共享状态变量，所以当集群数量达到一定程度后处理能力并不能按线性增长且可靠性可能也会降低。关于负载均衡集群如何协调分配分发请求的问题，即可以使用专门的负载均衡硬件如F5，也可以使用软件级别的方式实现负载均衡如LVS、HAProxy等。
高可用集群（High Available Cluster），高可用集群通过软件把若干机器连接起来，这种集群更偏重的是当集群中某个机器发生故障后能通过自动切换或流量转移等措施来保证整个集群对外的可用性。在实际运用中很经典的就是mysql数据库的主从节点，一般情况如果是一主多从我们会使用读写分离措施，主节点负责执行写操作而从节点执行读操作，一旦主节点发生故障后系统将自动从多个从节点中选举出一个节点作为主节点继续对外提供服务，保证了服务的高可用。高可用集群与负载均衡集群一般不会绝对地划分开，我们不会将一台机器什么也不做就放着就等其他机器出故障再去候补，为了使用地更加高效可以把这些备用（standby）的机器用于负载均衡，故障发生后再接管故障节点的职责。
 
========广告时间========
 
鄙人的新书《Tomcat内核设计剖析》已经在京东销售了，有需要的朋友可以到 https://item.jd.com/12185360.html 进行预定。感谢各位朋友。
 
为什么写《Tomcat内核设计剖析》
 
=========================
 
欢迎关注：
 

有问题可联系本人QQ：1016401546，备注来意，否则不加
 
redis集群搭建
 
作者：陈土锋
 
时间：2020年6月2日
 
目录
 
一、环境介绍... 1
 
1、机器准备... 1
 
2、关闭防护墙和selinux. 1
 
3、时间同步... 1
 
二、Redis Cluster（Redis集群）简介... 2
 
三、集群搭建需要的环境... 2
 
四、集群搭建... 2
 
1、所有服务器安装redis单点... 2
 
2、修改redis配置... 3
 
3、搭建集群... 6
 
五、验证集群... 7
 
1、检查集群状态... 7
 
2、检查主从节点... 7
 
3、启动集群验证增删改查... 7
 
4、验证故障转移主从切换... 8
 
4.1 原来175是slave，92是master：... 8
 
4.2 停了192.168.20.92的master 9
 
4.3 查看切换后的节点状态... 10
 
六、重建集群... 10
 
1、停了所有节点... 10
 
2、删除相关配置... 10
 
3、启动集群各个节点... 10
 
4、重新执行创建集群命令... 10
 
5、注意事项... 11
 
5.1 dump.rdb. 11
 
5.2 appendonly.aof（数据持久化）... 11
 
5.3 nodes.conf 11
 
七、redis-cluster常用命令... 12
 
1、查看集群：... 12
 
2、节点(node)  命令... 12
 
3、槽(slot命令... 12
 
4、键 (key) 命令... 13
 
5、说明：redis-cli --cluster help. 13
 
八、可能会遇到的报错... 15
 
 
 
一、环境介绍
 
、机器准备 
 
 
                  ip
 
 
系统类型
 
 
主从关系
 
 
CPU/内存
 
 
数据盘目录大小
 
 
                  192.168.20.44
 
 
redhat 7.6
 
 
主
 
 
4核16G
 
 
100G    /data
 
 
                 192.168.20.92
 
 
redhat 7.6
 
 
主
 
 
4核16G
 
 
100G    /data
 
 
                 192.168.20.102
 
 
redhat 7.6
 
 
主
 
 
4核16G
 
 
100G    /data
 
 
                 192.168.20.106
 
 
redhat 7.6
 
 
从
 
 
4核16G
 
 
100G    /data
 
 
                 192.168.20.175
 
 
redhat 7.6
 
 
从
 
 
4核16G
 
 
100G    /data
 
 
                192.168.20.189
 
 
redhat 7.6
 
 
从
 
 
4核16G
 
 
100G    /data
 
CPU型号：Intel(R) Xeon(R) CPU E7-4820 v2 @ 2.00GHz 
 
机器分配wiki地址：
 
http://cmic.tools.bigcloudsys.cn/wiki/pages/viewpage.action?pageId=46084618
 
2、关闭防护墙和selinux
 
所有机器执行：
 
systemctl stop firewalld
systemctl disable firewalld
systemctl status firewalld
 
临时关闭：
 
setenforce 0
 
永久关闭：
 
vim /etc/selinux/config
SELINUX=disabled
 
 
3、时间同步
 
 
 
 
二、Redis Cluster（Redis集群）简介
 
 
    redis是一个开源的key value存储系统，受到了广大互联网公司的青睐。redis3.0版本之前只支持单例模式，在3.0版本及以后才支持集群，我这里用的是redis3.0.0版本；
 
    redis集群采用P2P模式，是完全去中心化的，不存在中心节点或者代理节点；
 
    redis集群是没有统一的入口的，客户端（client）连接集群的时候连接集群中的任意节点（node）即可，集群内部的节点是相互通信的（PING-PONG机制），每个节点都是一个redis实例；
 
    为了实现集群的高可用，即判断节点是否健康（能否正常使用），redis-cluster有这么一个投票容错机制：如果集群中超过半数的节点投票认为某个节点挂了，那么这个节点就挂了（fail）。这是判断节点是否挂了的方法；
 
    那么如何判断集群是否挂了呢? -> 如果集群中任意一个节点挂了，而且该节点没有从节点（备份节点），那么这个集群就挂了。这是判断集群是否挂了的方法；
 
    那么为什么任意一个节点挂了（没有从节点）这个集群就挂了呢？ -> 因为集群内置了16384个slot（哈希槽），并且把所有的物理节点映射到了这16384[0-16383]个slot上，或者说把这些slot均等的分配给了各个节点。当需要在Redis集群存放一个数据（key-value）时，redis会先对这个key进行crc16算法，然后得到一个结果。再把这个结果对16384进行求余，这个余数会对应[0-16383]其中一个槽，进而决定key-value存储到哪个节点中。所以一旦某个节点挂了，该节点对应的slot就无法使用，那么就会导致集群无法正常工作。
 
    综上所述，每个Redis集群理论上最多可以有16384个节点。
 
 
三、集群搭建需要的环境
 
2.1 Redis集群至少需要3个节点，因为投票容错机制要求超过半数节点认为某个节点挂了该节点才是挂了，所以2个节点无法构成集群。
 
2.2 要保证集群的高可用，需要每个节点都有从节点，也就是备份节点，所以Redis集群至少需要6台服务器。
 
2.3 redis5.0以后，安装集群不在依赖ruby环境。直接使用集群配置的命令即可搭建。
 
四、集群搭建
 
1、所有服务器安装redis单点
 
1.获取redis资源
 
cd /usr/local
wget http://download.redis.io/releases/redis-5.0.0.tar.gz
 
2.解压
 
　tar xzvf redis-5.0.0.tar.gz
 
3.安装
 
cd redis-5.0.0
make
cd src
make install PREFIX=/usr/local/redis
 
4.移动配置文件到安装目录下　　
 
cd /usr/local/redis
mkdir /usr/local/redis/etc
grep -Ev "^#|^$" /usr/local/redis-5.0.0/redis.conf >> /usr/local/redis/etc/redis.conf
 
5.配置redis为后台启动
 
vi /usr/local/redis/etc/redis.conf
将daemonize no 改成daemonize yes
设置密码：requirepass 123456
允许所有机器连接：bind 0.0.0.0
 
6、添加redis命令到系统中
 
vim /etc/profile
export REDIS_HOME="/usr/local/redis"
export REDIS_BIN=${REDIS_HOME}/bin
export PATH=${REDIS_BIN}:${PATH}
source /etc/profile
 
7.将redis加入到开机启动
 
vi /etc/rc.local 
在里面添加内容：/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf (意思就是开机调用这段开启redis的命令)
 
8.开启redis
 
redis-server /usr/local/redis/etc/redis.conf 
或者
/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf 
 
9、停止redis
 
redis-cli  -p 6379 shutdown
/usr/local/redis/bin/redis-cli -a 123456 -p 6379 shutdown
 
2、修改redis配置
 
以192.168.20.44为例：
 
vim /usr/local/redis/etc/redis.conf 
 
bind 0.0.0.0
protected-mode yes
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize yes
supervised no
pidfile /var/run/redis_6379.pid
#打开集群
cluster-enabled yes
cluster-config-file /usr/local/redis/etc/redis_node.conf
#节点互连超时时间，毫秒为单位
cluster-node-timeout 5000  
#开启主从切换，50s超时主从切换。
cluster-require-full-coverage no
cluster-slave-validity-factor 10
#设置密码
requirepass 123456
#设置主从同步密码
masterauth 123456
loglevel notice
logfile "/var/log/redis.log"
databases 16
always-show-logo yes
#关闭rdb
#save 900 1
#save 300 10
#save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
#dbfilename dump.rdb
dir ./
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
#开启aof模式
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
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
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes
 
 
其他节点的配置和上面一样即可。
 
 
配置文件简要解析：
 
　我们即将创建示例集群部署。在继续之前，让我们介绍一下Redis Cluster在redis.conf文件中引入的配置参数。有些命令的意思是显而易见的，有些命令在你阅读下面的解释后才会更加清晰。

1、cluster-enabled <yes/no>：如果想在特定的Redis实例中启用Redis群集支持就设置为yes。 否则，实例通常作为独立实例启动。
2、cluster-config-file <filename>：请注意，尽管有此选项的名称，但这不是用户可编辑的配置文件，而是Redis群集节点每次发生更改时自动保留群集配置（基本上为状态）的文件，以便能够 在启动时重新读取它。 该文件列出了群集中其他节点，它们的状态，持久变量等等。 由于某些消息的接收，通常会将此文件重写并刷新到磁盘上。注意：该配置文件不是redis的原始配置文件！而是集群配置文件，名字自定义，创建集群会自动创建该配置文件。
3、cluster-node-timeout <milliseconds>：Redis群集节点可以不可用的最长时间，而不会将其视为失败。 如果主节点超过指定的时间不可达，它将由其从属设备进行故障切换。 此参数控制Redis群集中的其他重要事项。 值得注意的是，每个无法在指定时间内到达大多数主节点的节点将停止接受查询。
4、cluster-slave-validity-factor <factor>：如果设置为0，无论主设备和从设备之间的链路保持断开连接的时间长短，从设备都将尝试故障切换主设备。 如果该值为正值，则计算最大断开时间作为节点超时值乘以此选项提供的系数，如果该节点是从节点，则在主链路断开连接的时间超过指定的超时值时，它不会尝试启动故障切换。 例如，如果节点超时设置为5秒，并且有效因子设置为10，则与主设备断开连接超过50秒的从设备将不会尝试对其主设备进行故障切换。 请注意，如果没有从服务器节点能够对其进行故障转移，则任何非零值都可能导致Redis群集在主服务器出现故障后不可用。 在这种情况下，只有原始主节点重新加入集群时，集群才会返回可用。
5、cluster-migration-barrier <count>：主设备将保持连接的最小从设备数量，以便另一个从设备迁移到不受任何从设备覆盖的主设备。有关更多信息，请参阅本教程中有关副本迁移的相应部分。
6、cluster-require-full-coverage <yes / no>：如果将其设置为yes，则默认情况下，如果key的空间的某个百分比未被任何节点覆盖，则集群停止接受写入。 如果该选项设置为no，则即使只处理关于keys子集的请求，群集仍将提供查询。
 
 
、搭建集群
 
只需要在其中一个节点执行创建命令，我选择在192.168.20.44执行：
 
redis-cli -a "123456" --cluster create 192.168.20.44:6379 192.168.20.92:6379 192.168.20.102:6379 192.168.20.106:6379 192.168.20.175:6379 192.168.20.189:6379 --cluster-replicas 1
 
 
 
五、验证集群
 
1、检查集群状态
 
redis-cli    -a "123456" cluster info
redis-cli -a "123456" cluster nodes
 
可以通过node-id看出master192.168.20.92节点的redis slave是192.168.20.175。
 
 
 
2、检查主从节点
 
redis-cli    -a "123456" cluster nodes
 
 
可以看到主节点是：
  
 
51b5182464948142211fd9181db83c0c99bf3efe 192.168.20.92:6379@16379 master - 0 1591005631568 2 connected 5461-10922
179939f264ed3b46c4764a21e4231d9b882751be 192.168.20.44:6379@16379 myself,master - 0 1591005631000 1 connected 0-5460
e51edb0d70cd0c60a2b12be12b4b13b46263ee57 192.168.20.102:6379@16379 master - 0 1591005630967 3 connected 10923-16383
 
从节点：
 
43840f24c975c17d9fdcaeb3caa537d086679202 192.168.20.106:6379@16379 slave 179939f264ed3b46c4764a21e4231d9b882751be 0 1591006232546 4 connected
f57716d5cf46782e70f653540585ee6ff79b3ce9 192.168.20.189:6379@16379 slave e51edb0d70cd0c60a2b12be12b4b13b46263ee57 0 1591006234050 6 connected
30f45c1c4b3fdade7b32a4ca4cbd24ae20786759 192.168.20.175:6379@16379 slave 51b5182464948142211fd9181db83c0c99bf3efe 0 1591006233548 5 connected
 
 
3、启动集群验证增删改查
 
redis-cli    -a "123456"  -c     --必须加-c才能启动集群
或者：
redis-cli    -a "123456"  -c -h 192.168.20.44 -p 6379
127.0.0.1:6379> set test 1
-> Redirected to slot [6918] located at 192.168.20.92:6379  
OK
192.168.20.92:6379>
解析：
-> Redirected to slot [6918] located at 192.168.20.92:6379    --redis集群会根据key来重定向到其他的节点
在其他节点get的时候会从对应的节点查出这个key值：
192.168.20.44:6379> get test
-> Redirected to slot [6918] located at 192.168.20.92:6379
"1"
测试正常删除：
192.168.20.92:6379> del test
(integer) 1
192.168.20.92:6379> get test
(nil)
 
 
4、验证故障转移主从切换
 
redis-cli    -a "123456" cluster nodes
 
4.1 原来175是slave，92是master：
 
黄色是nodeid
 
ce6d458e136cd887cef631c062c1c66203dda396 192.168.20.175:6379@16379 slave 04fd20500fcf96f077394640e0e8554d795f6284 0 1591026117513 5 connected
 
ed25d3f5aafcd0dd3ca7f76287b5dd017ecf99dd 192.168.20.44:6379@16379 myself,master - 0 1591026117000 1 connected 0-5460
 
696f5d31840d9b5acdf895cd7bee3d8fde759b38 192.168.20.102:6379@16379 master - 0 1591026116000 3 connected 10923-16383
 
04fd20500fcf96f077394640e0e8554d795f6284 192.168.20.92:6379@16379 master - 0 1591026116511 2 connected 5461-10922
 
f28ee3463614d3c5fb37a859ac074c3384e91ab4 192.168.20.106:6379@16379 slave ed25d3f5aafcd0dd3ca7f76287b5dd017ecf99dd 0 1591026117513 4 connected
 
5c71a8d35d30b495713ff9fee9d7cfd44d8157ea 192.168.20.189:6379@16379 slave 696f5d31840d9b5acdf895cd7bee3d8fde759b38 0 1591026117000 6 connected
 
4.2 停了192.168.20.92的master
 
看着192.168.20.175的redis日志会看到有日志输出，如果切换成功也会有日志输出：
 
故障转移成功提示：
 
6009:S 01 Jun 2020 23:42:17.486 # Error condition on socket for SYNC: Connection refused
 
6009:S 01 Jun 2020 23:42:17.560 * Marking node 04fd20500fcf96f077394640e0e8554d795f6284 as failing (quorum reached).
 
6009:S 01 Jun 2020 23:42:17.586 # Start of election delayed for 543 milliseconds (rank #0, offset 207).
 
6009:S 01 Jun 2020 23:42:18.188 # Starting a failover election for epoch 7
 
 
6009:S 01 Jun 2020 23:42:27.540 * Connecting to MASTER 192.168.20.92:6379
 
6009:S 01 Jun 2020 23:42:27.540 * MASTER <-> REPLICA sync started
 
6009:S 01 Jun 2020 23:42:27.540 # Error condition on socket for SYNC: Connection refused
 
6009:S 01 Jun 2020 23:42:27.641 # Currently unable to failover: Waiting for votes, but majority still not reached.
 
6009:S 01 Jun 2020 23:42:28.144 # Currently unable to failover: Failover attempt expired.
 
6009:S 01 Jun 2020 23:42:28.546 * Connecting to MASTER 192.168.20.92:6379
 
6009:S 01 Jun 2020 23:42:38.195 # Start of election delayed for 511 milliseconds (rank #0, offset 207).
 
6009:S 01 Jun 2020 23:42:38.296 # Currently unable to failover: Waiting the delay before I can start a new failover.
 
6009:S 01 Jun 2020 23:42:38.598 * MASTER <-> REPLICA sync started
 
6009:S 01 Jun 2020 23:42:38.598 # Error condition on socket for SYNC: Connection refused
 
6009:S 01 Jun 2020 23:42:38.799 # Starting a failover election for epoch 8.
 
6009:S 01 Jun 2020 23:42:38.803 # Currently unable to failover: Waiting for votes, but majority still not reached.
 
6009:S 01 Jun 2020 23:42:38.804 # Failover election won: I'm the new master.
 
6009:S 01 Jun 2020 23:42:38.804 # configEpoch set to 8 after successful failover
 
6009:M 01 Jun 2020 23:42:38.804 # Setting secondary replication ID to 13472b6e2c05dd941917971c5c7a11bf30e2f9f7, valid up to offset: 208. New replication ID is fcae76ac0d571744e4f4f5ef1d8b6186147c49bf
 
6009:M 01 Jun 2020 23:42:38.804 * Discarding previously cached master state.
 
 
4.3 查看切换后的节点状态
 
再去查看redis集群状态发现，175已经是成功成为master，再重启192.168.20.92的redis，则会变成salve，92后面跟着175的nodeid，说明正在同步175的数据。
 
redis-cli    -a "123456" cluster nodes
 
ce6d458e136cd887cef631c062c1c66203dda396 192.168.20.175:6379@16379 master - 0 1591026308567 8 connected 5461-10922
ed25d3f5aafcd0dd3ca7f76287b5dd017ecf99dd 192.168.20.44:6379@16379 myself,master - 0 1591026308000 1 connected 0-5460
696f5d31840d9b5acdf895cd7bee3d8fde759b38 192.168.20.102:6379@16379 master - 0 1591026309567 3 connected 10923-16383
04fd20500fcf96f077394640e0e8554d795f6284 192.168.20.92:6379@16379 slave ce6d458e136cd887cef631c062c1c66203dda396 0 1591026308165 8 connected
f28ee3463614d3c5fb37a859ac074c3384e91ab4 192.168.20.106:6379@16379 slave ed25d3f5aafcd0dd3ca7f76287b5dd017ecf99dd 0 1591026309968 4 connected
5c71a8d35d30b495713ff9fee9d7cfd44d8157ea 192.168.20.189:6379@16379 slave 696f5d31840d9b5acdf895cd7bee3d8fde759b38 0 1591026308967 6 connected
 
 
 
 
六、重建集群
 
、停了所有节点
 
ansible rediscluster --sudo -m shell -a ' /usr/local/redis/bin/redis-cli -a "123456" shutdown'
 
2、删除相关配置
 
将每个节点下aof、rdb、nodes.conf本地备份文件删除； 
 
 
3、启动集群各个节点
 
4、重新执行创建集群命令
 
redis-cli -a "123456" --cluster create 192.168.20.44:6379 192.168.20.92:6379 192.168.20.102:6379 192.168.20.106:6379 192.168.20.175:6379 192.168.20.189:6379 --cluster-replicas 1
 
 
5、注意事项
 
为什么要删除aof、rdb、nodes.conf本地备份文件？
 
5.1 dump.rdb
 
dump.rdb是由Redis服务器自动生成的 默认情况下 每隔一段时间redis服务器程序会自动对数据库做一次遍历，把内存快照写在一个叫做“dump.rdb”的文件里，这个持久化机制叫做SNAPSHOT。有了SNAPSHOT后，如果服务器宕机，重新启动redis服务器程序时redis会自动加载dump.rdb，将数据库状态恢复到上一次做SNAPSHOT时的状态。
 
 
5.2 appendonly.aof（数据持久化）
 
默认情况下Redis会异步的将数据导出到磁盘上。这种模式对许多应用程序已经足够了，但是如果断电或者redis进程出问题就会导致一段时间内的更新数据丢失（取决与配置项）；
 
这种只增文件是可选的能够提供更好的体验的数据持久化策略。
 
举个例子，如果使用默认的配置数据fsync策略，在服务器意外断电的情况下redis只会丢失一秒中内的更新数据，或者当redis进程出问题但操作系统运转正常时，redis只会丢失一个数据更新操作。
 
AOF 和 RDB 持久化方式可以同时启动并且无冲突。
 
如果AOF开启，启动redis时会加载aof文件，这些文件能够提供更好的保证。
 
 
5.3 nodes.conf
 
每个集群节点都有一个集群配置文件。它是由Redis节点自动创建和更新的。每个Redis集群节点都需要一个不同的集群配置文件。
 
注：确保在同一系统中运行的实例没有重叠的集群配置文件名。集群的配置,配置文件首次启动自动生成。
 
 
七、redis-cluster常用命令
 
1、查看集群：
 
 
CLUSTER INFO 打印集群的信息
 
CLUSTER NODES 列出集群当前已知的所有节点（node），以及这些节点的相关信息。 
 
redis-cli -c -p 6379 cluster nodes
 
redis-cli -c -p 6379 cluster info
 
redis-trib.rb  check  10.26.25.115:6379
 
redis-trib.rb info 10.26.25.115:6379
 
2、节点(node)  命令
 
1、加入节点：将 ip 和 port 所指定的节点添加到集群当中，让它成为集群的一份子。 
 
1）CLUSTER MEET <ip> <port>
 
2）redis-trib.rb add-node <ip> <port>  10.25.157.78:7022
 
例如：新增节点：10.80.82.74:7029
 
redis-trib.rb add-node 10.80.82.74:7029 10.25.157.78:7022
 
2、移除节点：
 
1）、登陆集群任意节点：执行：CLUSTER FORGET <node_id>
 
2)、redis-trib.rb del-node  <ip> <port>  <node_id>
 
例如
 
redis-trib.rb del-node 10.80.82.74:7030 923e869b3fda8add429fb200ea00ce94bdbc84e6
 
CLUSTER FORGET 923e869b3fda8add429fb200ea00ce94bdbc84e6
 
3、设置主从节点：
 
CLUSTER REPLICATE <node_id> 将当前节点设置为 node_id 指定的节点的从节点。 
 
4、节点数据备份到硬盘：
 
CLUSTER SAVECONFIG 将节点的配置文件保存到硬盘里面。 
 
 
3、槽(slot命令
 
CLUSTER ADDSLOTS <slot> [slot ...] 将一个或多个槽（slot）指派（assign）给当前节点。 
 
CLUSTER DELSLOTS <slot> [slot ...] 移除一个或多个槽对当前节点的指派。 
 
CLUSTER FLUSHSLOTS 移除指派给当前节点的所有槽，让当前节点变成一个没有指派任何槽的节点。 
 
CLUSTER SETSLOT <slot> NODE <node_id> 将槽 slot 指派给 node_id 指定的节点，如果槽已经指派给另一个节点，那么先让另一个节点删除该槽>，然后再进行指派。 
 
CLUSTER SETSLOT <slot> MIGRATING <node_id> 将本节点的槽 slot 迁移到 node_id 指定的节点中。 
 
CLUSTER SETSLOT <slot> IMPORTING <node_id> 从 node_id 指定的节点中导入槽 slot 到本节点。 
 
CLUSTER SETSLOT <slot> STABLE 取消对槽 slot 的导入（import）或者迁移（migrate）。
 
 
4、键 (key) 命令
 
CLUSTER KEYSLOT <key> 计算键 key 应该被放置在哪个槽上。
 
CLUSTER COUNTKEYSINSLOT <slot> 返回槽 slot 目前包含的键值对数量。
 
CLUSTER GETKEYSINSLOT <slot> <count> 返回 count 个 slot 槽中的键。
 
 
5、说明：redis-cli --cluster help
 
redis-cli --cluster help
Cluster Manager Commands:
  create         host1:port1 ... hostN:portN   #创建集群
                 --cluster-replicas <arg>      #从节点个数
  check          host:port                     #检查集群
                 --cluster-search-multiple-owners #检查是否有槽同时被分配给了多个节点
  info           host:port                     #查看集群状态
  fix            host:port                     #修复集群
                 --cluster-search-multiple-owners #修复槽的重复分配问题
  reshard        host:port                     #指定集群的任意一节点进行迁移slot，重新分slots
                 --cluster-from <arg>          #需要从哪些源节点上迁移slot，可从多个源节点完成迁移，以逗号隔开，传递的是节点的node id，还可以直接传递--from all，这样源节点就是集群的所有节点，不传递该参数的话，则会在迁移过程中提示用户输入
                 --cluster-to <arg>            #slot需要迁移的目的节点的node id，目的节点只能填写一个，不传递该参数的话，则会在迁移过程中提示用户输入
                 --cluster-slots <arg>         #需要迁移的slot数量，不传递该参数的话，则会在迁移过程中提示用户输入。
                 --cluster-yes                 #指定迁移时的确认输入
                 --cluster-timeout <arg>       #设置migrate命令的超时时间
                 --cluster-pipeline <arg>      #定义cluster getkeysinslot命令一次取出的key数量，不传的话使用默认值为10
                 --cluster-replace             #是否直接replace到目标节点
  rebalance      host:port                                      #指定集群的任意一节点进行平衡集群节点slot数量 
                 --cluster-weight <node1=w1...nodeN=wN>         #指定集群节点的权重
                 --cluster-use-empty-masters                    #设置可以让没有分配slot的主节点参与，默认不允许
                 --cluster-timeout <arg>                        #设置migrate命令的超时时间
                 --cluster-simulate                             #模拟rebalance操作，不会真正执行迁移操作
                 --cluster-pipeline <arg>                       #定义cluster getkeysinslot命令一次取出的key数量，默认值为10
                 --cluster-threshold <arg>                      #迁移的slot阈值超过threshold，执行rebalance操作
                 --cluster-replace                              #是否直接replace到目标节点
  add-node       new_host:new_port existing_host:existing_port  #添加节点，把新节点加入到指定的集群，默认添加主节点
                 --cluster-slave                                #新节点作为从节点，默认随机一个主节点
                 --cluster-master-id <arg>                      #给新节点指定主节点
  del-node       host:port node_id                              #删除给定的一个节点，成功后关闭该节点服务
  call           host:port command arg arg .. arg               #在集群的所有节点执行相关命令
  set-timeout    host:port milliseconds                         #设置cluster-node-timeout
  import         host:port                                      #将外部redis数据导入集群
                 --cluster-from <arg>                           #将指定实例的数据导入到集群
                 --cluster-copy                                 #migrate时指定copy
                 --cluster-replace                              #migrate时指定replace
  help           

For check, fix, reshard, del-node, set-timeout you can specify the host and port of any working node in the cluster.


 
 
 
八、可能会遇到的报错
 
1、[root@yyxx-vvm-node01 ~]# redis-cli -a "123456" --cluster create 192.168.20.44:6379 192.168.20.92:6379 192.168.20.102:6379 192.168.20.106:6379 192.168.20.175:6379 192.168.20.189:6379 --cluster-replicas 1
 
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
 
Could not connect to Redis at 192.168.20.189:6379: No route to host
 
原因：192.168.20.189的防火墙没关，导致端口连不上。
 
 
九、出现什么情况导致集群不可用
 
通常出现以下2种情况：
 1、如果cluster中任意master挂掉，且当前master没有slave，集群进入fail状态情况下。即集群的slot映射[0-16383]不完成时进入fail态。
 2、如果cluster中超过半数以上master挂掉，无论是否有slave，集群进入fail状态。

redis集群搭建
 
在开始redis集群搭建之前，我们先简单回顾一下redis单机版的搭建过程
 
下载redis压缩包，然后解压压缩文件；
进入到解压缩后的redis文件目录（此时可以看到Makefile文件），编译redis源文件；
把编译好的redis源文件安装到/usr/local/redis目录下，如果/local目录下没有redis目录，会自动新建redis目录；
进入/usr/local/redis/bin目录，直接./redis-server启动redis（此时为前端启动redis）；
将redis启动方式改为后端启动，具体做法：把解压缩的redis文件下的redis.conf文件复制到/usr/local/redis/bin目录下，然后修改该redis.conf文件->daemonize：no 改为daemonize：yse；
在/bin目录下通过./redis-server redis.conf启动redis（此时为后台启动）。
 综上redis单机版安装启动完成。
 具体详细带图步骤请参考 -> redis入门
 请原谅我的啰嗦，ok，接着咱们回到本次话题----redis集群搭建！
 
一、Redis Cluster（Redis集群）简介
 
redis是一个开源的key value存储系统，受到了广大互联网公司的青睐。redis3.0版本之前只支持单例模式，在3.0版本及以后才支持集群，我这里用的是redis3.0.0版本；
redis集群采用P2P模式，是完全去中心化的，不存在中心节点或者代理节点；
redis集群是没有统一的入口的，客户端（client）连接集群的时候连接集群中的任意节点（node）即可，集群内部的节点是相互通信的（PING-PONG机制），每个节点都是一个redis实例；
为了实现集群的高可用，即判断节点是否健康（能否正常使用），redis-cluster有这么一个投票容错机制：如果集群中超过半数的节点投票认为某个节点挂了，那么这个节点就挂了（fail）。这是判断节点是否挂了的方法；
那么如何判断集群是否挂了呢? -> 如果集群中任意一个节点挂了，而且该节点没有从节点（备份节点），那么这个集群就挂了。这是判断集群是否挂了的方法；
那么为什么任意一个节点挂了（没有从节点）这个集群就挂了呢？ -> 因为集群内置了16384个slot（哈希槽），并且把所有的物理节点映射到了这16384[0-16383]个slot上，或者说把这些slot均等的分配给了各个节点。当需要在Redis集群存放一个数据（key-value）时，redis会先对这个key进行crc16算法，然后得到一个结果。再把这个结果对16384进行求余，这个余数会对应[0-16383]其中一个槽，进而决定key-value存储到哪个节点中。所以一旦某个节点挂了，该节点对应的slot就无法使用，那么就会导致集群无法正常工作。
综上所述，每个Redis集群理论上最多可以有16384个节点。
 
二、集群搭建需要的环境
 2.1 Redis集群至少需要3个节点，因为投票容错机制要求超过半数节点认为某个节点挂了该节点才是挂了，所以2个节点无法构成集群。
 2.2 要保证集群的高可用，需要每个节点都有从节点，也就是备份节点，所以Redis集群至少需要6台服务器。因为我没有那么多服务器，也启动不了那么多虚拟机，所在这里搭建的是伪分布式集群，即一台服务器虚拟运行6个redis实例，修改端口号为（7001-7006），当然实际生产环境的Redis集群搭建和这里是一样的。
 2.3 安装ruby
 三、集群搭建具体步骤如下（注意要关闭防火墙）
 3.1 在usr/local目录下新建redis-cluster目录，用于存放集群节点
 
 3.2 把redis目录下的bin目录下的所有文件复制到/usr/local/redis-cluster/redis01目录下，不用担心这里没有redis01目录，会自动创建的。操作命令如下（注意当前所在路径）：
 
cp -r redis/bin/ redis-cluster/redis01
 

 3.3 删除redis01目录下的快照文件dump.rdb，并且修改该目录下的redis.cnf文件，具体修改两处地方：一是端口号修改为7001，二是开启集群创建模式，打开注释即可。分别如下图所示：
 删除dump.rdb文件
 
 修改端口号为7001,默认是6379
 
 将cluster-enabled yes 的注释打开
 
 3.4 将redis-cluster/redis01文件复制5份到redis-cluster目录下（redis02-redis06），创建6个redis实例，模拟Redis集群的6个节点。然后将其余5个文件下的redis.conf里面的端口号分别修改为7002-7006。分别如下图所示：
 创建redis02-06目录
 
 
分别修改redis.conf文件端口号为7002-7006
 
 3.5 接着启动所有redis节点，由于一个一个启动太麻烦了，所以在这里创建一个批量启动redis节点的脚本文件，命令为start-all.sh，文件内容如下：
 
cd redis01
./redis-server redis.conf
cd ..
cd redis02
./redis-server redis.conf
cd ..
cd redis03
./redis-server redis.conf
cd ..
cd redis04
./redis-server redis.conf
cd ..
cd redis05
./redis-server redis.conf
cd ..
cd redis06
./redis-server redis.conf
cd ..

 
3.6 创建好启动脚本文件之后，需要修改该脚本的权限，使之能够执行，指令如下：
 
chmod +x start-all.sh
 

 3.7 执行start-all.sh脚本，启动6个redis节点
 
 3.8 ok，至此6个redis节点启动成功，接下来正式开启搭建集群，以上都是准备条件。大家不要觉得图片多看起来冗长所以觉得麻烦，其实以上步骤也就一句话的事情：创建6个redis实例（6个节点）并启动。
 要搭建集群的话，需要使用一个工具（脚本文件），这个工具在redis解压文件的源代码里。因为这个工具是一个ruby脚本文件，所以这个工具的运行需要ruby的运行环境，就相当于java语言的运行需要在jvm上。所以需要安装ruby，指令如下：
 
yum install ruby
 
然后需要把ruby相关的包安装到服务器，我这里用的是redis-3.0.0.gem，大家需要注意的是：redis的版本和ruby包的版本最好保持一致。
 将Ruby包安装到服务器：需要先下载再安装，如图
 
 安装命令如下：
 
gem install redis-3.0.0.gem
 
 
3.9 上一步中已经把ruby工具所需要的运行环境和ruby包安装好了，接下来需要把这个ruby脚本工具复制到usr/local/redis-cluster目录下。那么这个ruby脚本工具在哪里呢？之前提到过，在redis解压文件的源代码里，即redis/src目录下的redis-trib.rb文件。
 
 
 3.10 将该ruby工具（redis-trib.rb）复制到redis-cluster目录下，指令如下：
 
cp redis-trib.rb /usr/local/redis-cluster
 
然后使用该脚本文件搭建集群，指令如下：
 
./redis-trib.rb create --replicas 1 47.106.219.251:7001 47.106.219.251:7002 47.106.219.251:7003 47.106.219.251:7004 47.106.219.251:7005 47.106.219.251:7006
 
注意：此处大家应该根据自己的服务器ip输入对应的ip地址！
 
 
中途有个地方需要手动输入yes即可
 
 至此，Redi集群搭建成功！大家注意最后一段文字，显示了每个节点所分配的slots（哈希槽），这里总共6个节点，其中3个是从节点，所以3个主节点分别映射了0-5460、5461-10922、10933-16383solts。
 
3.11 最后连接集群节点，连接任意一个即可：
 
redis01/redis-cli -p 7001 -c 
 
注意：一定要加上-c，不然节点之间是无法自动跳转的！如下图可以看到，存储的数据（key-value）是均匀分配到不同的节点的：
 
 
四、结语
 呼~~~长舒一口气…终于搭建好了Redis集群。
 整个过程其实挺简单，本篇主要正对入门级别的小伙伴，插入了很多图片，所以显得冗长，希望大家多多理解，如果不当之处，还望及时指正~
 
最后，加上两条redis集群基本命令：
 1.查看当前集群信息
 
cluster info
 
2.查看集群里有多少个节点
 
cluster nodes

初学k8s,对集群里面的IP真的不是很理解，一会是PodIP,一会是ClusterIP,总结一下这些IP。
 
Kubernetes集群里有三种IP地址，分别如下：
 
Node IP：Node节点的IP地址，即物理网卡的IP地址。
Pod IP：Pod的IP地址，即docker容器的IP地址，此为虚拟IP地址。
Cluster IP：Service的IP地址，此为虚拟IP地址。
 
Node IP
 
可以是物理机的IP（也可能是虚拟机IP）。每个Service都会在Node节点上开通一个端口，外部可以通过NodeIP:NodePort即可访问Service里的Pod,和我们访问服务器部署的项目一样，IP:端口/项目名

 在kubernetes查询Node IP
 1.kubectl get nodes
 2.kubectl describe node nodeName
 3.显示出来的InternalIP就是NodeIP
 
 
Pod IP
 
Pod IP是每个Pod的IP地址，他是Docker Engine根据docker网桥的IP地址段进行分配的，通常是一个虚拟的二层网络
 
同Service下的pod可以直接根据PodIP相互通信
不同Service下的pod在集群间pod通信要借助于 cluster ip
pod和集群外通信，要借助于node ip
 
在kubernetes查询Pod IP
 1.kubectl get pods
 2.kubectl describe pod podName
 
 
Cluster IP
 
Service的IP地址，此为虚拟IP地址。外部网络无法ping通，只有kubernetes集群内部访问使用。

 在kubernetes查询Cluster IP
 kubectl -n 命名空间 get Service即可看到ClusterIP
 
 
 
Cluster IP是一个虚拟的IP，但更像是一个伪造的IP网络，原因有以下几点
 
Cluster IP仅仅作用于Kubernetes Service这个对象，并由Kubernetes管理和分配P地址
Cluster IP无法被ping，他没有一个“实体网络对象”来响应
Cluster IP只能结合Service Port组成一个具体的通信端口，单独的Cluster IP不具备通信的基础，并且他们属于Kubernetes集群这样一个封闭的空间。
在不同Service下的pod节点在集群间相互访问可以通过Cluster IP
 

 
三种IP网络间的通信
 
service地址和pod地址在不同网段，service地址为虚拟地址，不配在pod上或主机上，外部访问时，先到Node节点网络，再转到service网络，最后代理给pod网络。
 

 Kubernetes在其所有节点上开放一个端口给外部访问（所有节点上都使用相同的端口号）， 并将传入的连接转发给作为Service服务对象的pod。这样我们的pod就可以被外部请求访问到
 
 
 
 
注：
 k8s暴露服务给外部访问有三种方式，NodePort、LoadBalane、Ingress三种暴露服务的方式，上图是用了NodePort的方式，缺点是服务一旦多起来，NodePort 在每个节点上开启的端口数量会极其庞大，难以维护，详解k8s暴露服务的三种方式：k8s-(七）暴露服务的三种方式
 
 
其他网络知识
 《计算机网络-DHCP的工作原理，IP地址如何获取》
 《计算机网络-学习交换机》
 《计算机网络-学习路由器》
 



 k8s-学习笔记总结（从入门到放弃的学习路线）
 k8s-(五） 最全的安装教程（使用kubeadm在Centos7上部署kubernetes1.18）