1
2
3
4
5
6
7
8
9
一、单机部署redis
二、redis主从结构部署
三、redis哨兵模式部署
四、redis集群部署
   redis集群部署配置秘密
五、redis主从方案
六、redis高可用部署
七、redis5.0之前版本搭配ruby的redis集群部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
https://blog.csdn.net/xch_yang/article/details/104019552 （linux单机安装部分）

#准备：
	yum -y install centos-release-scl
	yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
	scl enable devtoolset-9 bash
	#如果是离线的。则准备移植一些东西过去
        1）/opt/rh/devtoolset-9
        2）/usr/bin/scl
        3） /etc/scl
        4）在准备上面的rpm包，进行强制安装，最后别忘了scl enable devtoolset-9 bash
        #注意，里面有个报错Invalid argument， 没事，执行两次即可
        【(yum相关包离线安装：https://blog.csdn.net/tfner123/article/details/123832115)
        具体：
         	1）下载 yum -y install yum-utils
         	2）查看命令如何使用：repotrack  -h		查看repotrack相关命令
         	3）下载所需的依赖包：repotrack  包名  -p 下载到的路径
         	4）离线安装：进入下载的路径： 用：rpm -ivh *.rpm    【不用：rpm -Uvh --nodeps *.rpm】
        】
		

#step1:官网下载地址：https://redis.io/download，这里我们下载目前最新稳定版5.0.7，直接点击下载。
	wget http://download.redis.io/releases/redis-6.0.16.tar.gz
	tar xzf redis-5.0.7.tar.gz
	cd redis-5.0.7/
	make
	#这时候会看到redis-5.0.7 中会有对应的 src、conf 等文件
	
#step2:进入 src 文件夹，执行 make install 进行 Redis 安装。
	cd src/
	make install
	
#step3:由于 src 下文件非常多，我们可以将几个常用的命令和 conf 配置文件复制出来进行统一管理(为了方便使用)，如下
	cd /root/redis-5.0.7/
	mkdir etc
	mkdir bin
	cp redis.conf etc
	cd src/
	cp mkreleasehdr.sh redis-benchmark redis-check-aof redis-check-rdb redis-cli redis-server redis-sentinel ../bin/


#step4: 设置被外网访问
	cd etc
	vim redis.conf
	修改bind 127.0.0.1    为 bind 0.0.0.0

#step5:启动/关闭redis
	cd /root/redis-5.0.7/bin
	#启动
		./redis-server /root/redis-5.0.7/etc/redis.conf
	#关闭
		redis-cli -p 6379 shutdown
		
		

#完毕！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# redis进程是否以守护进程的方式运行，yes为是，no为否(不以守护进程的方式运行会占用一个终端)。
daemonize no
# 指定redis进程的PID文件存放位置
pidfile /var/run/redis.pid
# redis进程的端口号
port 6379
#是否开启保护模式，默认开启。要是配置里没有指定bind和密码。开启该参数后，redis只会本地进行访问，拒绝外部访问。要是开启了密码和bind，可以开启。否则最好关闭设置为no。
protected-mode yes
# 绑定的主机地址
bind 127.0.0.1
# 客户端闲置多长时间后关闭连接，默认此参数为0即关闭此功能
timeout 300
# redis日志级别，可用的级别有debug.verbose.notice.warning
loglevel verbose
# log文件输出位置，如果进程以守护进程的方式运行，此处又将输出文件设置为stdout的话，就会将日志信息输出到/dev/null里面去了
logfile stdout
# 设置数据库的数量，默认为0可以使用select <dbid>命令在连接上指定数据库id
databases 16
# 指定在多少时间内刷新次数达到多少的时候会将数据同步到数据文件
save <seconds> <changes>
# 指定存储至本地数据库时是否压缩文件，默认为yes即启用存储
rdbcompression yes
# 指定本地数据库文件名
dbfilename dump.db
# 指定本地数据问就按存放位置
dir ./
# 指定当本机为slave服务时，设置master服务的IP地址及端口，在redis启动的时候他会自动跟master进行数据同步
replicaof <masterip> <masterport>
# 当master设置了密码保护时，slave服务连接master的密码
masterauth <master-password>
# 设置redis连接密码，如果配置了连接密码，客户端在连接redis是需要通过AUTH<password>命令提供密码，默认关闭
requirepass footbared
# 设置同一时间最大客户连接数，默认无限制。redis可以同时连接的客户端数为redis程序可以打开的最大文件描述符，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回 max number of clients reached 错误信息
maxclients 128
# 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key。当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区
maxmemory<bytes>
# 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no。
appendonly no
# 指定跟新日志文件名默认为appendonly.aof
appendfilename appendonly.aof
# 指定更新日志的条件，有三个可选参数 - no：表示等操作系统进行数据缓存同步到磁盘(快)，always：表示每次更新操作后手动调用fsync()将数据写到磁盘(慢，安全)， everysec：表示每秒同步一次(折衷，默认值)；
appendfsync everysec

1
2
3
4
#Redis主从结构介绍：
	单纯的主从结构只是主库把数据复制给从库。
	-主库数据同步到从库， 从库一般情况不允许写，如果设置可以写则也只能写自己的库，没法同步到主库或者其他从库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
https://blog.csdn.net/xch_yang/article/details/104019552 （主从结构安装部分）

#step1:完成上述linux单机安装

#step2:把step1安装好的redis作为master,并把安装好的复制到两个solve。然后到两个slove的redis/src/中执行 "make install"

#step3:对master进行配置(redis/etc/redis.conf)
	bind 0.0.0.0
    port 6379
    protected-mode no
    daemonize yes
    logfile ./redis.log
    requirepass pwdtest@2019
    masterauth pwdtest@2019

1
2
3
4
5
6
7
8
9
10
#step4:对两个slove进行配置(redis/etc/redis.conf):从机的配置和主机相似，相同的地方我就不再详解，不同的地方是需要使用replicaof指定主机（master）的IP地址和端口，需要注意的是老版本使用的是 slaveof，目前我使用的5.0.7版本要使用 replicaof ，如下。
	bind 0.0.0.0
	port 6379
	protected-mode no
	daemonize yes
	logfile ./redis.log
	requirepass pwdtest@2019
	masterauth pwdtest@2019
	replicaof 192.168.231.130 6379 

1
2
3
4
5
6
7
8
9
#step5：启动所有结点redis:
	redis-server redis-5.0.7/etc/redis.conf
	上面我们主从节点的配置文件配置好后，重启 redis 服务，进入 bin 目录即可查看配置文件中指定的redis.log日志文件。
	
#step6:验证测试（下面内容可不看）
	1.进入redis, 输入：info replication.
	2.在主结点设置变量，其值会同步到从结点
	3.从节点不可以设置变量。(默认从结点没有写的权限，但是可以配置，即使配置了也只是写自己机子上的。)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#哨兵模式详解：
	Redis Sentinel是Redis 的高可用性解决方案，由一个或多个Sentinel（哨兵）实例组成。它可以监视任意多个主服务器，以及这些主服务器属下的所有从服务器，并在被监视的主服务器进入下线状态时，自动将下线主服务器属下的某个从服务器升级为新的主服务器，它的主要功能如下：
	-监控(Monitoring)：Sentinel会不断地检查你的主服务器和从服务器是否运作正常。
	-通知(Notification)：当被监控的某个 Redis 服务器出现问题时， Sentinel可以通过API向管理员或者其他应用程序发送通知。
	-故障迁移：当主服务器不能正常工作时，Sentinel会自动进行故障迁移，也就是主从切换。
	-统一的配置管理：连接者询问sentinel取得主从的地址。
	

#哨兵模式原理：
	Sentinel 使用的算法核心是 Raft 算法，主要用途就是用于分布式系统，系统容错，以及Leader选举，每个Sentinel都需要定期的执行以下任务：
	-每个 Sentinel 会自动发现其他 Sentinel 和从服务器，它以每秒钟一次的频率向它所知的主服务器、从服务器以及其他 Sentinel 实例发送一个 PING 命令。
	-如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 那么这个实例会被 Sentinel 标记为主观下线。 有效回复可以是： +PONG 、 -LOADING 或者 -MASTERDOWN 。
	-如果一个主服务器被标记为主观下线， 那么正在监视这个主服务器的所有Sentinel要以每秒一次的频率确认主服务器的确进入了主观下线状态。
	-如果一个主服务器被标记为主观下线， 并且有足够数量的Sentinel（至少要达到配置文件指定的数量）在指定的时间范围内同意这一判断， 那么这个主服务器被标记为客观下线。
	-在一般情况下， 每个Sentinel会以每 10 秒一次的频率向它已知的所有主服务器和从服务器发送 INFO 命令。 当一个主服务器被Sentinel标记为客观下线时，Sentinel向下线主服务器的所有从服务器发送 INFO 命令的频率会从 10 秒一次改为每秒一次。
	-当没有足够数量的Sentinel同意主服务器已经下线， 主服务器的客观下线状态就会被移除。 当主服务器重新向Sentinel的 PING 命令返回有效回复时， 主服务器的主管下线状态就会被移除。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#step1: 三台机子完成《主从结构安装》

#step2: 同样为了方便管理，首先将sentinel.conf复制到 etc 下。 编辑 sentinel.conf。【每个机子都配】
	cd /data/redis-5.0.7/
	cp sentinel.conf /data/redis-5.0.7/etc/
	cd etc/
	vi sentinel.conf
	配置文件修改如下，修改完毕后先按 esc ，然后:wq命令保存退出
        //端口默认为26379。
        port:26379
        //关闭保护模式，可以外部访问。
        protected-mode:no
        //设置为后台启动。
        daemonize:yes
        //日志文件。
        logfile:./sentinel.log
        //指定主机IP地址和端口，并且指定当有2台哨兵认为主机挂了，则对主机进行容灾切换。【注意这里的ip是自己主机ip】
        sentinel monitor mymaster 192.168.231.130 6379 2
        //当在Redis实例中开启了requirepass，这里就需要提供密码。
        sentinel auth-pass mymaster pwdtest@2019
        //这里设置了主机多少秒无响应，则认为挂了。
        sentinel down-after-milliseconds mymaster 3000
        //主备切换时，最多有多少个slave同时对新的master进行同步，这里设置为默认的1。
        snetinel parallel-syncs mymaster 1
        //故障转移的超时时间，这里设置为三分钟。
        sentinel failover-timeout mymaster 180000

#step3:先启动所有主从机子的redis，再启动所有主从机子的哨兵
		启动redis:
		启动哨兵：  redis-sentinel redis-5.0.7/etc/sentinel.conf
		
#step4:检查哨兵状态
		redis-cli -p 26379
		----------------------------------------------------------------------------------
		|127.0.0.1:26379> info sentinel                                                  |
        |# Sentinel                                                                      | 
        |sentinel_masters:1                                                              |
        |sentinel_tilt:0                                                                 |
        |sentinel_running_scripts:0                                                      |
        |sentinel_scripts_queue_length:0                                                 |
        |sentinel_simulate_failure_flags:0                                               |
        |master0:name=mymaster,status=ok,address=192.168.72.11:6379,slaves=2,sentinels=3 |
		----------------------------------------------------------------------------------
		可以看到，哨兵已经监听到当前的主机IP端口和运行状态，并且有2台从机，3个哨兵。
		#这里有个容易出现的bug,所有程序都正常执行了，就是发现sentinels=1 
			原因是：“哨兵的 配置文件中myid不能相同， 请删掉在启动，会自动分配”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 哨兵sentinel实例运行的端口，默认26379  
port 26379
# 哨兵sentinel的工作目录
dir ./
# 是否开启保护模式，默认开启。
protected-mode:no
# 是否设置为后台启动。
daemonize:yes

# 哨兵sentinel的日志文件
logfile:./sentinel.log

# 哨兵sentinel监控的redis主节点的 
## ip：主机ip地址
## port：哨兵端口号
## master-name：可以自己命名的主节点名字（只能由字母A-z、数字0-9 、这三个字符".-_"组成。）
## quorum：当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了  
# sentinel monitor <master-name> <ip> <redis-port> <quorum>  
sentinel monitor mymaster 127.0.0.1 6379 2

# 当在Redis实例中开启了requirepass，所有连接Redis实例的客户端都要提供密码。
# sentinel auth-pass <master-name> <password>  
sentinel auth-pass mymaster 123456  

# 指定主节点应答哨兵sentinel的最大时间间隔，超过这个时间，哨兵主观上认为主节点下线，默认30秒  
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000  

# 指定了在发生failover主备切换时，最多可以有多少个slave同时对新的master进行同步。这个数字越小，完成failover所需的时间就越长；反之，但是如果这个数字越大，就意味着越多的slave因为replication而不可用。可以通过将这个值设为1，来保证每次只有一个slave，处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1  

# 故障转移的超时时间failover-timeout，默认三分钟，可以用在以下这些方面：
## 1. 同一个sentinel对同一个master两次failover之间的间隔时间。  
## 2. 当一个slave从一个错误的master那里同步数据时开始，直到slave被纠正为从正确的master那里同步数据时结束。  
## 3. 当想要取消一个正在进行的failover时所需要的时间。
## 4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来同步数据了
# sentinel failover-timeout <master-name> <milliseconds>  
sentinel failover-timeout mymaster 180000

# 当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本。一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
# 对于脚本的运行结果有以下规则：  
## 1. 若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10。
## 2. 若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。  
## 3. 如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
# sentinel notification-script <master-name> <script-path>  
sentinel notification-script mymaster /var/redis/notify.sh

# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#注意：安装过程中暂时不考虑主从（既：master1-master2-master3）

#step1: 1台机子先安装好《linux单机安装》

#step2: 配置redis.conf（如下具体意思请核查）
	# 开启redis的集群模式
	cluster-enabled yes
	# 配置集群模式下的配置文件名称和位置,redis-cluster.conf这个文件是集群启动后自动生成的，不需要手动配置。
	cluster-config-file redis-cluster.conf
	protected-mode no
	port  6379
	daemonize    yes                         
	pidfile  redis_6379.pid                  
	cluster-node-timeout  5000   
	appendonly  yes   
	bind 0.0.0.0

#step3: 主机scp分发，node1,node2,node3...

#step4: 快速的部署集群:主机之间相互认识
	#注意：防火墙打开
	redis-cli --cluster create 192.168.72.11:6379 192.168.72.12:6379 192.168.72.13:6379 --cluster-replicas 0
	#--cluster-replicas 0表示没有从机。 如果是1，则后面的ip:port 分别是 主 从 主 从 主 从 ......
	#可能遇到的bug
	https://blog.csdn.net/qq_38151401/article/details/86741950
	https://blog.csdn.net/shudaqi2010/article/details/53261754
		#检查集群
			每个机子执行：redis-cli --cluster check 192.168.72.xxx:6379
		#修复集群：
			每个机子执行：redis-cli --cluster fix 192.168.72.xxx:6379
		#重新分配slot
			每个机子执行：redis-cli --cluster reshard 192.168.72.xxx:6379
			
	

#step5：测试
    执行完成后自动生成配置的redis-cluster.conf文件。

    登录集群：redis-cli -c -h 192.168.1.11 -p 6379 -a 123456 # -c，使用集群方式登录。

    查看集群信息：192.168.1.11:6379> CLUSTER INFO #集群状态。

    列出节点信息：192.168.1.11:6379> CLUSTER NODES #列出节点信息。

1
2
3
4
5
https://blog.csdn.net/Xin_101/article/details/122987210
https://blog.csdn.net/weixin_44432789/article/details/120450017
https://www.cnblogs.com/linjiqin/p/7462822.html
https://blog.csdn.net/xufei512/article/details/82758676

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
配置方法:
#step1：创建Redis集群之后再配置密码,所有Redis节点配置文件中添加。 [也可以先创建密码，再设置集群，如下]
	#所有Redis节点redis.conf配置文件中添加：
		requirepass 123456
		masterauth 123456
		
#命令连接测试
		redis-cli -c -a '密码'
	或者
		redis-cli -c  先进入
		然后 
		127.0.0.1:6379> auth "123456"  这个方法好像只能用在单个节点。
		
#scala 连接集群方式。 下文-程序连接Redis API/scala密码连接scala集群

#补充：先设置密码后创建集群， 只需要多加个 -a '密码' 即可。
redis-cli -a "123456" --cluster  create 192.168.72.31:6379 192.168.72.32:6379 192.168.72.33:6379 --cluster-replicas 0

1
2
	redis集群是一个由多个主从节点群组成的分布式服务器群，具有复制、高可用、分片等特性。Redis集群不需要哨兵也能完成主从切换和故障转移。redis集群具有水平扩展的特性。redis集群的性能和高可用性优于哨兵模式，而且配置相对简单。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#在一台机子上模拟6个实例吧。端口分别是 6381，6382，6383，6384，6385，6386


#创建文件夹 ./cluster/6381,  ./cluster/6382  ...........
#把redis.conf分别放置在其中，并且配置。（如下以6381为例）
 1. 在每台服务器的/usr/local下创建文件夹redis-cluster用于存放集群配置文件
	mkdir -p /usr/local/redis-cluster
	cd /usr/local/redis-cluster
	mkdir 8081 8082 8083 8084 8085 8086
 2. 把redis.conf复制到上面的文件夹中并修改一下内容
	（1）daemonize yes
	（2）port 6381（端口号分别设置）
	（3）pidfile /var/run/redis_6381.pid # 把pid进程号写入pidfile配置的文件
	（4）dir /usr/local/redis-6.0.16/cluster/6381/（指定数据文件存放位置，要指定不同的位置，不然会丢失数据）
	（5）cluster‐enabled yes（启动集群模式）
	（6）cluster‐config‐file nodes‐6381.conf（集群节点信息文件，这里808x最好和port对应上）
	（7）cluster‐node‐timeout 10000
	（8）bind 0.0.0.0（bind绑定的是自己机器网卡的ip，如果有多块网卡可以配多个ip，代表允许客户端通
过机器的哪些网卡ip去访问，内网一般可以不配置bind，注释掉即可）
	（9）protected‐mode no （关闭保护模式）
	（10）appendonly yes
	（11）如果要设置密码需要增加如下配置：
		requirepass 123456(设置redis访问密码)
		masterauth 123456(设置集群节点间访问密码，跟上面一致)
 3. 分别启动6个redis实例，并验证是否启动成功
	redis-server /usr/local/redis-6.0.16/cluster/6381/redis.conf
	redis-server /usr/local/redis-6.0.16/cluster/6382/redis.conf
	redis-server /usr/local/redis-6.0.16/cluster/6383/redis.conf
	redis-server /usr/local/redis-6.0.16/cluster/6384/redis.conf
	redis-server /usr/local/redis-6.0.16/cluster/6385/redis.conf
	redis-server /usr/local/redis-6.0.16/cluster/6386/redis.conf

	ps ‐ef | grep redis 查看是否启动成功
	
 4. 用redis‐cli创建整个redis集群
	# 执行这条命令需要确认三台机器之间的redis实例要能相互访问，可以先简单把所有机器防火墙关掉，
	(如果不关闭防火墙则需要打开redis服务端口和集群节点gossip通信端口16379(默认是在redis端口号上加1W)
	# 关闭防火墙
	# systemctl stop firewalld # 临时关闭防火墙



#组件集群命令
redis-cli -a '123456' 
--cluster create  192.168.0.61:6381 192.168.0.61:6382 192.168.0.61:6383 192.168.0.61:6384 192.168.0.61:6385 192.168.0.61:6386 
--cluster-replicas 1
#注意：cluster-replicas值取
	1 ： 表示有主从集群，前面一半是主，后面一半是对应的从。
    0 ： 表示全部为master
    
    
    
#验证集群
（1）连接任意一个客户端 ./redis-cli -c -h -p (-a访问服务端密码 -c表示集群模式，指定ip和端口号)
（2）进行验证 命令：cluster info（查看集群信息），cluster nodes（查看节点信息,可以看到主从关系）
（3）数据操作验证
（4）关闭集群需要逐个关闭redis客户端

1
2
3
4
5
#可根据cluster nodes看到主从关系
    6381 -> 6386
    6382 -> 6384
    6383 -> 6385

1
2
3
4
#shutdown 一个从节点(6384)
	可根据cluster nodes看到主从关系. 6384已经fail了。 、、
	且 集群还可以正常使用

1
2
3
#shutdown 一个从节点(6383)
	可以看到一段时间后，其从节点(6385) 变成了master

1
2
3
#启动刚刚挂掉的之前的master 6383
	现在6383只能沦为 slave了

1
2
#启动刚刚挂掉的之前的slave 6384

1
2
3
4
#总结：
	1）如果一个master挂掉，会由其slove 切换成master
	2）不可以同时挂半数以上master

1
2
3
4
5
6
7
8
9
yum安装
yum install -y centos-release-scl-rh
yum install -y rh-ruby24


redis-4.0.9部署教程 
http://t.zoukankan.com/alexlv-p-15070131.html
#下面步骤内容即为引用此链接博主的博文内容。

1
2
tar xf redis-4.0.9.tar.gz

1
2
yum install gcc zlib-devel -y

1
2
cd redis-4.0.9

1
2
make PREFIX=/apps/redis install

1
2
cp redis.conf /apps/redis/etc/

1
2
3
4
5
6
7
8
9
10
#守护进程模式运行（后台运行，默认前台运行）
daemonize yes
#设置密码
masterauth 123456
#日志文件存放位置
logfile "/apps/redis/logs/redis.log"
#开启集群（本次编译用来做集群，所以要取消注释这两项）
cluster-enabled yes
cluster-config-file nodes-6379.conf#修改监听端口0.0.0.0bind 0.0.0.0#设置本机密码requirepass 123456#设置主服务器密码（在集群中，这两个密码项非常重要，否则会导致主从数据不同步，并且不报错！！！）masterauth 123456

1
2
ln -s /apps/redis/bin/redis* /usr/bin/

1
2
redis-server /apps/redis/etc/redis.conf

1
2
ln -s /apps/redis-4.0.9/src/redis-trib.rb /usr/bin/

1
2
wget https://cache.ruby-lang.org/pub/ruby/ruby-2.5.0.tar.gz

1
2
tar xf ruby-2.5.0.tar.gz

1
2
cd ruby-2.5.0

1
2
3
1 ./configure 
2 make && make install

1
2
wget wget https://rubygems.org/downloads/redis-4.2.3.gem

1
2
gem install -l /apps/redis-4.2.3.gem

1
2
3
4
5
6
Successfully installed redis-4.2.3
Parsing documentation for redis-4.2.3
Installing ri documentation for redis-4.2.3
Done installing documentation for redis after 0 seconds
1 gem installed

1
2
redis-trib.rb create --replicas 1 192.168.1.9:6379 192.168.1.8:6379 192.168.1.7:6379 192.168.1.6:6379 192.168.1.5:6379 192.168.1.4:6379

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
redis-trib.rb create --replicas 1 192.168.1.9:6379 192.168.1.8:6379 192.168.1.7:6379 192.168.1.6:6379 192.168.1.5:6379 192.168.1.4:6379
>>> Creating cluster
>>> Performing hash slots allocation on 6 nodes...
Using 3 masters:#创建了三个主节点
192.168.1.9:6379
192.168.1.8:6379
192.168.1.7:6379
Adding replica 192.168.1.6:6379 to 192.168.1.9:6379  ### 192.168.1.6是192.168.1.9的从节点
Adding replica 192.168.1.5:6379 to 192.168.1.8:6379
Adding replica 192.168.1.4:6379 to 192.168.1.7:6379
M: 73a51b03d3ae1ae60573924a36e35a4160ea2a8a 192.168.1.9:6379 # M表示master 主节点，S表示slave 从节点
   slots:0-5460 (5461 slots) master
M: bc591a36af254e510488ab184b0e638e7298ff6d 192.168.1.8:6379 ##M后的一串数字是随机生成的，在集群中，以ID号区分主机，不以IP地址区分
   slots:5461-10922 (5462 slots) master ## slots是按照顺序分的，每台上的应该是差不多的，也会有原因导致无序分配，
M: 7226c301d028168f22f60930db0bf8b4260c2905 192.168.1.7:6379
   slots:10923-16383 (5461 slots) master
S: 3bcd400f071643f814d45479bfc3a56612eca471 192.168.1.6:6379
   replicates 73a51b03d3ae1ae60573924a36e35a4160ea2a8a  ## 这里的ID就是master的ID
S: 7a1ad13e2d2e3ad84a5da2d001e1680fcf8b2255 192.168.1.5:6379
   replicates bc591a36af254e510488ab184b0e638e7298ff6d  ##slave节点是没有slots的，master宕机后会自动继承
S: d53b5724df5ae6f6f5305cebb419e6b5ec2a6096 192.168.1.4:6379
   replicates 7226c301d028168f22f60930db0bf8b4260c2905Can I set the above configuration? (type 'yes' to accept): yes
##配置文件中dir /var/lib/redis这里定义了放在哪，这个配置就会保存在这个位置，配置文件自动生成，不需要手动更改

1
2
3
4
5
6
7
8
9
10
11
12
13
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
lots:10923-16383 (5461 slots) master
S: 3bcd400f071643f814d45479bfc3a56612eca471 192.168.1.6:6379
   replicates 73a51b03d3ae1ae60573924a36e35a4160ea2a8a  ## 这里的ID就是master的ID
S: 7a1ad13e2d2e3ad84a5da2d001e1680fcf8b2255 192.168.1.5:6379
   replicates bc591a36af254e510488ab184b0e638e7298ff6d  ##slave节点是没有slots的，master宕机后会自动继承
S: d53b5724df5ae6f6f5305cebb419e6b5ec2a6096 192.168.1.4:6379
   replicates 7226c301d028168f22f60930db0bf8b4260c2905Can I set the above configuration? (type 'yes' to accept): yes
##配置文件中dir /var/lib/redis这里定义了放在哪，这个配置就会保存在这个位置，配置文件自动生成，不需要手动更改

1
2
3
4
5
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.