经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 数据库/运维 » Redis » 查看文章
redis
来源：cnblogs　　作者：zylyehuo　　时间：2023/9/10 14:36:27　　对本文有异议

博客地址：https://www.cnblogs.com/zylyehuo/

五大数据类型

参考链接：redis学习

  • string，字符串类型
  • hash，哈希类型，如同python的dict
  • set，无序集合
  • zset，有序集合
  • list，双向队列，向左插入数据，向右插入数据，向左、右，提取数据

redis安全启动与配置文件，运维相关操作

redis如何在linux安装

  • rpm包安装
  • yum自动化安装，在阿里的yum仓库中，有redis的软件包
  • 源代码编译安装

redis是内存性数据库，断电，数据丢失，进程重启，数据丢失

得配置redis的数据持久化，防止数据丢失

redis支持ms复制，读写分离，防止单点故障，数据丢失

1.安装redis

  1. [root@localhost ~]# cd /opt/
  2. [root@localhost opt]# yum install redis -y

2.修改redis.conf，更改默认端口，设置密码，开启安全模式等操作

用yum安装的redis，默认配置文件在/etc/redis.conf

  1. [root@localhost opt]# vim /etc/redis.conf  # 打开如下参数即可

注释版

  1. # 这里是绑定redis的启动地址，如果你支持远程连接，就改为0.0.0.0
  2. bind 0.0.0.0  
  3. # 更改端口
  4. port 6500
  5. # 设置redis的密码
  6. requirepass haohaio
  7. # 默认打开了安全模式
  8. protected-mode yes  
  9. # 打开一个redis后台运行的参数
  10. daemonize yes

无注释版

  1. bind 0.0.0.0  
  2. port 6500
  3. requirepass haohaio
  4. protected-mode yes  
  5. daemonize yes

3.启动redis

  1. [root@localhost opt]# ps -ef | grep redis
  2. root      27057   3041  0 00:04 pts/1    00:00:00 grep --color=auto redis
  3. [root@localhost opt]# systemctl start redis
  4. [root@localhost opt]# ps -ef | grep redis
  5. root      27131   3041  0 00:04 pts/1    00:00:00 grep --color=auto redis
  6. # 为什么systemctl start redis无法连接呢？
  7. # 是因为这个命令默认连接的是6379端口，我们更改了redis端口，因此无法连接了
  8. # 使用如下的命令，指定配置文件启动
  9. [root@localhost opt]# redis-server /etc/redis.conf
  11. # 检查redis的进程
  12. [root@localhost opt]# ps -ef | grep redis
  13. root      27178      1  0 00:05 ?        00:00:00 redis-server 0.0.0.0:6500
  14. root      27184   3041  0 00:05 pts/1    00:00:00 grep --color=auto redis

4.连接redis服务端，指定ip地址和端口，以及密码连接redis

  1. -p 指定端口
  2. -h 指定ip地址
  3. auth指令，用于密码验证
  1. [root@localhost opt]# redis-cli -p 6500 -h 10.0.0.129
  2. 10.0.0.129:6500> ping
  3. (error) NOAUTH Authentication required.
  4. 10.0.0.129:6500>
  5. 10.0.0.129:6500> auth haohaio
  6. OK
  7. 10.0.0.129:6500> ping
  8. PONG

5.redis常用命令

  1. 10.0.0.129:6500> flushdb  # 清空redis库
  2. OK
  3. 10.0.0.129:6500> keys *  # 列出redis所有的key
  4. (empty list or set)

redis数据持久化之RDB机制

向redis中写入一些数据，重启进程，查看数据是否会丢失

1.环境准备，准备一个redis.conf配置文件，不开启数据数据持久化

  1. # 先杀死所有的redis进程，再重新写一个配置文件
  2. [root@localhost opt]# pkill -9 redis
  3. [root@localhost opt]# mkdir /s25redis
  4. [root@localhost opt]# cd /s25redis/
  5. [root@localhost s25redis]# vim no_rdb_redis.conf
  7. bind 0.0.0.0
  8. daemonize yes

2.指定该文件启动

  1. [root@localhost s25redis]# redis-server no_rdb_redis.conf
  2. [root@localhost s25redis]# ps -ef | grep redis
  3. root     111958      1  0 23:06 ?        00:00:00 redis-server 0.0.0.0:6379
  4. root     111964   3041  0 23:06 pts/1    00:00:00 grep --color=auto redis

3.登录数据库，写入数据，然后杀死redis进程，查看数据是否存在

以下的操作，都是为了演示，redis如果不配置持久化，数据会丢失

  1. [root@localhost s25redis]# redis-cli 
  2. 127.0.0.1:6379> ping
  3. PONG
  4. 127.0.0.1:6379> set name wohaoe
  5. OK
  6. 127.0.0.1:6379> set name2 nimenebue
  7. OK
  8. 127.0.0.1:6379> keys *
  9. 1) "name2"
  10. 2) "name"
  11. 127.0.0.1:6379> exit
  12. [root@localhost s25redis]# pkill -9 redis
  13. [root@localhost s25redis]# redis-server no_rdb_redis.conf 
  14. [root@localhost s25redis]# redis-cli 
  15. 127.0.0.1:6379> keys *
  16. (empty list or set)
  17. 127.0.0.1:6379>

4.配置RDB机制的数据持久化，数据文件是一个看不懂的二进制文件，且配置触发的时间机制

  1. [root@localhost s25redis]# cd /s25redis
  2. [root@localhost s25redis]# vim s25_rdb_redis.conf

注释版

  1. daemonize yes		          # 后台运行
  2. port 6379				      # 端口 
  3. logfile /data/6379/redis.log  # 指定redis的运行日志，存储位置
  4. dir /data/6379		          # 指定redis的数据文件，存放路径 
  5. dbfilename  s25_dump.rdb	  # 指定数据持久化的文件名字 
  6. bind 127.0.0.1		          # 指定redis的运行ip地址
  7. # redis触发save指令，用于数据持久化的时间机制  
  8. # 900秒之内有1个修改的命令操作，如set .mset,del
  9. save 900 1		
  10. # 在300秒内有10个修改类的操作
  11. save 300 10
  12. # 60秒内有10000个修改类的操作
  13. save 60  10000

无注释版

  1. daemonize yes
  2. port 6379 
  3. logfile /data/6379/redis.log
  4. dir /data/6379
  5. dbfilename  s25_dump.rdb
  6. bind 127.0.0.1
  7. save 900 1		
  8. save 300 10
  9. save 60  10000
  1. # 写入了一个key
  2. set  name  很快就下课让大家去吃饭 
  3. # 快速的执行了10次的修改类的操作
  4. set name hehe
  5. set name1 haha
  6. ...
  8. # 新浪微博，1秒中内，写入了20w个新的key，因此也就是每分钟，进行一次数据持久化了
  9. # 2.创建redis的数据文件夹，
  10. [root@localhost s25redis]# mkdir -p /data/6379
  12. # 3.杀死之前所有的redis，防止扰乱实验
  13. [root@localhost s25redis]# pkill -9 redis
  15. # 4.指定配置了rdb的redis配置文件，启动
  16. [root@localhost s25redis]# redis-server s25_rdb_redis.conf
  17. [root@localhost s25redis]# ps -ef | grep redis
  18. root     113393      1  0 23:29 ?        00:00:00 redis-server 127.0.0.1:6379
  19. root     113406   3041  0 23:29 pts/1    00:00:00 grep --color=auto redis
  21. # 5.如果没有触发redis的持久化时间机制，数据文件是不会生成的，数据重启进程也会丢
  23. # 6.可以通过编写脚本，让redis手动执行save命令，触发持久化，在redis命令行中，直接输入save即可触发持久化
  24. 127.0.0.1:6379> set name chaochao
  25. OK
  26. 127.0.0.1:6379> set addr shahe
  27. OK
  28. 127.0.0.1:6379> set age 18
  29. OK
  30. 127.0.0.1:6379> keys *
  31. 1) "age"
  32. 2) "addr"
  33. 3) "name"
  34. 127.0.0.1:6379> save
  35. OK
  36. 127.0.0.1:6379> exit
  37. [root@localhost s25redis]# pkill -9 redis
  38. [root@localhost s25redis]# redis-server s25_rdb_redis.conf
  39. [root@localhost s25redis]# redis-cli 
  40. 127.0.0.1:6379> keys *
  41. 1) "addr"
  42. 2) "age"
  43. 3) "name"
  44. 127.0.0.1:6379> 
  46. # 7.存在了rdb持久化的文件之后，重启redis进程，数据也不会丢了，redis在重启之后，会读取s25_dump.rdb文件中的数据
  47. [root@localhost ~]# cd /data/6379/
  48. [root@localhost 6379]# ls
  49. redis.log  s25_dump.rdb
  51. # 8.rdb的弊端在于什么，如果没有触发持久化机制，就发生了机器宕机，数据就会丢失了，因此redis有一个更好的AOF持久化机制

redis数据持久化之AOF机制

把修改类的redis命令操作，记录下来，追加写入到AOF文件中，且是我们能够看得懂的日志文件

1.准备一个新的配置文件，里面定义AOF的功能性参数即可使用

  1. [root@localhost ~]# cd /s25redis/
  2. [root@localhost s25redis]# pkill -9 redis
  3. [root@localhost s25redis]# vim s25_aof_redis.conf

注释版

  1. # 写入如下内容
  2. daemonize yes
  3. port 6379
  4. logfile /data/6379aof/redis.log
  5. dir /data/6379aof/
  6. appendonly yes	        # 开启aof功能
  7. appendfsync everysec	# 每秒钟持久化一次

无注释版

  1. daemonize yes
  2. port 6379
  3. logfile /data/6379aof/redis.log
  4. dir /data/6379aof/
  5. appendonly yes
  6. appendfsync everysec

2.创建AOF的数据文件夹

  1. [root@localhost s25redis]# mkdir -p /data/6379aof/

3.启动AOF的redis的数据库

  1. [root@localhost s25redis]# redis-server s25_aof_redis.conf
  2. [root@localhost s25redis]# ps -ef | grep redis
  3. root     114730      1  0 23:49 ?        00:00:00 redis-server *:6379
  4. root     114750   3041  0 23:49 pts/1    00:00:00 grep --color=auto redis

4.AOF机制的数据库，在首次启动的时候，就会生成AOF数据文件了，如下

  1. [root@localhost ~]# cd /data/
  2. [root@localhost data]# ls
  3. 6379  6379aof
  4. [root@localhost data]# cd 6379aof/
  5. [root@localhost 6379aof]# ls
  6. appendonly.aof  redis.log

5.登录redis,写入数据

  1. [root@localhost s25redis]# redis-cli
  2. 127.0.0.1:6379> keys *
  3. (empty list or set)
  4. 127.0.0.1:6379> set name zhunbeixiakechifan
  5. OK
  6. 127.0.0.1:6379> set name2 xinkudajiale
  7. OK
  8. 127.0.0.1:6379> keys *
  9. 1) "name2"
  10. 2) "name"
  11. 127.0.0.1:6379>

6.写入的操作，会被记录到AOF文件日志中

7.杀死所有的redis进程，且重启

  1. 127.0.0.1:6379> exit
  2. [root@localhost s25redis]# pkill -9 redis
  3. [root@localhost s25redis]# redis-server s25_aof_redis.conf
  4. [root@localhost s25redis]# redis-cli 
  5. 127.0.0.1:6379> keys *
  6. 1) "name"
  7. 2) "name2"
  8. 127.0.0.1:6379>

8.redis的AOF持久化机制，是在重启的时候，redis重新执行一遍AOF文件中的命令，实现数据复现

9.如果该AOF日志文件被删除，数据也就无法恢复了

redis数据同步复制

在一台机器上运行2个及以上的redis，是redis支持多实例的功能，基于端口号的不同，就能够运行多个相互独立的redis数据库

  1. 什么是多实例
  2. 就是机器上运行了多个redis相互独立的进程
  3. 互不干扰的独立的数据库
  4. 叫做多个redis数据库的实例，基于配置文件区分即可

如图是redis的多实例功能，且配置主从同步的图

1.准备好2个redis的配置文件，分别写入如下内容

  1. [root@localhost s25redis]# vim s25-master-redis.conf 
  1. port 6379
  2. daemonize yes
  3. pidfile /s25/6379/redis.pid
  4. loglevel notice
  5. logfile "/s25/6379/redis.log"
  6. dbfilename dump.rdb
  7. dir /s25/6379
  8. protected-mode no

2.准备第二个配置文件

  1. [root@localhost s25redis]# vim s25-slave-redis.conf 
  1. port 6389
  2. daemonize yes
  3. pidfile /s25/6389/redis.pid
  4. loglevel notice
  5. logfile "/s25/6389/redis.log"
  6. dbfilename dump.rdb
  7. dir /s25/6389
  8. protected-mode no
  9. slaveof  127.0.0.1  6379  # 也可直接在配置文件中，定义好复制关系，启动后，立即就会建立复制

3.分别生成2个redis的数据文件夹

  1. [root@localhost s25redis]# mkdir -p /s25/{6379,6389}

4.分别启动2个redis数据库，查看他们的身份复制关系

  1. [root@localhost s25redis]# redis-server s25-master-redis.conf
  2. [root@localhost s25redis]# redis-server s25-slave-redis.conf

5.分别检查他们的进程，以及复制关系

  1. [root@localhost s25redis]# ps -ef | grep redis
  2. root       4476      1  0 09:54 ?        00:00:00 redis-server *:6379
  3. root       4480      1  0 09:54 ?        00:00:00 redis-server *:6389
  4. root       4493   3186  0 09:55 pts/0    00:00:00 grep --color=auto redis
  1. # 通过一条命令，配置他们的复制关系，注意，这个命令只是临时配置redis的复制关系，想要永久修改，还得修改配置文件
  2. [root@s25linux s25redis]# redis-cli -p 6389 slaveof 127.0.0.1 6379
  3. OK
  4. [root@localhost s25redis]# redis-cli -p 6379 info replication
  5. # Replication
  6. role:master
  7. connected_slaves:1
  8. slave0:ip=127.0.0.1,port=6389,state=online,offset=141,lag=1
  9. master_repl_offset:141
  10. repl_backlog_active:1
  11. repl_backlog_size:1048576
  12. repl_backlog_first_byte_offset:2
  13. repl_backlog_histlen:140
  14. [root@localhost s25redis]# redis-cli -p 6389 info replication
  15. # Replication
  16. role:slave
  17. master_host:127.0.0.1
  18. master_port:6379
  19. master_link_status:up
  20. master_last_io_seconds_ago:2
  21. master_sync_in_progress:0
  22. slave_repl_offset:169
  23. slave_priority:100
  24. slave_read_only:1
  25. connected_slaves:0
  26. master_repl_offset:0
  27. repl_backlog_active:0
  28. repl_backlog_size:1048576
  29. repl_backlog_first_byte_offset:0
  30. repl_backlog_histlen:0

6.此时6379已然是主库，6389已然是从库

此时可以向6379中写入数据，能够同步到6389中
6389是一个只读的数据库，无法写入数据

  1. [root@localhost s25redis]# redis-cli -p 6389
  2. 127.0.0.1:6389> keys *
  3. (empty list or set)
  4. 127.0.0.1:6389> 
  5. [root@localhost s25redis]# redis-cli -p 6379
  6. 127.0.0.1:6379> keys *
  7. (empty list or set)
  8. 127.0.0.1:6379> 
  9. [root@localhost s25redis]# redis-cli -p 6379
  10. 127.0.0.1:6379> set name nichousha
  11. OK
  12. 127.0.0.1:6379> keys *
  13. 1) "name"
  14. 127.0.0.1:6379> get name
  15. "nichousha"
  16. 127.0.0.1:6379> 
  17. [root@localhost s25redis]# redis-cli -p 6389
  18. 127.0.0.1:6389> keys *
  19. 1) "name"
  20. 127.0.0.1:6389> get name
  21. "nichousha"
  22. 127.0.0.1:6389> set name1 "chounizadi"
  23. (error) READONLY You can't write against a read only slave.
  24. 127.0.0.1:6389> 
  25. [root@localhost s25redis]# redis-cli -p 6379
  26. 127.0.0.1:6379> keys *
  27. 1) "name"
  28. 127.0.0.1:6379> set name2 "chounizadile"
  29. OK
  30. 127.0.0.1:6379> keys *
  31. 1) "name2"
  32. 2) "name"
  33. 127.0.0.1:6379> 
  34. [root@localhost s25redis]# redis-cli -p 6389
  35. 127.0.0.1:6389> keys *
  36. 1) "name2"
  37. 2) "name"
  38. 127.0.0.1:6389>

一主多从的形式，以及主从复制故障切换

1.再创建一个配置文件，port是6399，且加入到一主一从的复制关系中去

  1. [root@localhost s25redis]# vim s25-slave2-redis.conf 
  1. port 6399
  2. daemonize yes
  3. pidfile /s25/6399/redis.pid
  4. loglevel notice
  5. logfile "/s25/6399/redis.log"
  6. dbfilename dump.rdb
  7. dir /s25/6399
  8. protected-mode no
  9. slaveof  127.0.0.1  6379

2.创建数据文件夹

  1. [root@localhost s25redis]# mkdir -p /s25/6399

3.启动6399的数据库，查看他的身份复制关系

  1. [root@localhost s25redis]# redis-server s25-slave2-redis.conf
  2. [root@localhost s25redis]# redis-cli -p 6399 info replication
  3. # Replication
  4. role:slave
  5. master_host:127.0.0.1
  6. master_port:6379
  7. master_link_status:up
  8. master_last_io_seconds_ago:6
  9. master_sync_in_progress:0
  10. slave_repl_offset:3003
  11. slave_priority:100
  12. slave_read_only:1
  13. connected_slaves:0
  14. master_repl_offset:0
  15. repl_backlog_active:0
  16. repl_backlog_size:1048576
  17. repl_backlog_first_byte_offset:0
  18. repl_backlog_histlen:0
  19. [root@localhost s25redis]# redis-cli -p 6399
  20. 127.0.0.1:6399> keys *
  21. 1) "name"
  22. 2) "name2"

故障模拟

主库挂掉，从库不挂的场景

  1. # 1.环境准备，准备3个redis的数据库实例，分别是 6379、6389、6399，配置好一主两从的关系
  2. [root@localhost s25redis]# ps -ef | grep redis
  3. root       4476      1  0 09:54 ?        00:00:02 redis-server *:6379
  4. root       4480      1  0 09:54 ?        00:00:01 redis-server *:6389
  5. root       5049      1  0 10:29 ?        00:00:00 redis-server *:6399
  6. root       5153   3186  0 10:34 pts/0    00:00:00 grep --color=auto redis
  7. # 分别查看复制关系
  8. [root@localhost s25redis]# redis-cli -p 6379 info replication
  9. # Replication
  10. role:master
  11. connected_slaves:2
  12. slave0:ip=127.0.0.1,port=6389,state=online,offset=3507,lag=1
  13. slave1:ip=127.0.0.1,port=6399,state=online,offset=3507,lag=1
  14. master_repl_offset:3507
  15. repl_backlog_active:1
  16. repl_backlog_size:1048576
  17. repl_backlog_first_byte_offset:2
  18. repl_backlog_histlen:3506
  20. # 2.此时直接干掉主库即可
  21. # kill 6379的pid即可
  22. [root@localhost s25redis]# kill -9 4476
  24. # 3.此时留下2个孤零零的从库，没有了主人，还没法写入数据，很难受
  26. # 4.此时一位从库，不乐意了，翻身农奴做主人，去掉自己的从库身份，没有这个从库的枷锁，我就是我自己的主人
  27. [root@localhost s25redis]# redis-cli -p 6399 slaveof no one
  28. OK
  29. [root@localhost s25redis]# redis-cli -p 6399 info replication
  30. # Replication
  31. role:master
  32. connected_slaves:0
  33. master_repl_offset:0
  34. repl_backlog_active:0
  35. repl_backlog_size:1048576
  36. repl_backlog_first_byte_offset:0
  37. repl_backlog_histlen:0
  39. # 5.此时6399已然是主库了，修改6389的复制信息，改为6399即可
  40. [root@localhost s25redis]# redis-cli -p 6389 slaveof 127.0.0.1 6399
  41. OK
  43. # 6.此时检查他们的复制关系
  44. [root@localhost s25redis]# redis-cli -p 6389 info replication
  45. # Replication
  46. role:slave
  47. master_host:127.0.0.1
  48. master_port:6399
  49. master_link_status:up
  50. master_last_io_seconds_ago:8
  51. master_sync_in_progress:0
  52. slave_repl_offset:29
  53. slave_priority:100
  54. slave_read_only:1
  55. connected_slaves:0
  56. master_repl_offset:0
  57. repl_backlog_active:0
  58. repl_backlog_size:1048576
  59. repl_backlog_first_byte_offset:0
  60. repl_backlog_histlen:0
  61. [root@localhost s25redis]# redis-cli -p 6399 info replication
  62. # Replication
  63. role:master
  64. connected_slaves:1
  65. slave0:ip=127.0.0.1,port=6389,state=online,offset=43,lag=0
  66. master_repl_offset:43
  67. repl_backlog_active:1
  68. repl_backlog_size:1048576
  69. repl_backlog_first_byte_offset:2
  70. repl_backlog_histlen:42
  72. # 7.此时可以向主库6399写入数据，6389查看数据即可

主库不挂，从库挂掉的场景

从库挂掉，无所谓，重新再建立一个从库，加入主从复制即可

你会发现，如此的手动切换复制关系，是很难受的，如果在夜里凌晨四点，redis主库突然挂了，该怎么办？

因此该怎么办？

  • 希望有一个人，能24h盯着这个主从复制，发现主库宕机之后，自动地进行主从切换

redis高可用哨兵

redis哨兵的工作原理

  1. 配置好redis的哨兵进程，一般都是使用3个哨兵（保安）
  2. 哨兵的作用是盯着redis主库，不断询问它是否存活，如果超过30s（设置的时间阈值）都没有回应，3个哨兵会判断主库宕机，谈话进行投票机制，因为3个哨兵，要自动的去选择从库为新的主库，每个哨兵的意见可能不一样
  3. 因此引出投票机制，少数服从多数
  4. 当多个哨兵达成一致，选择某一个从库阶段，自动的修改他们的配置文件，切换新的主库
  5. 此时如果宕机的主库，恢复后，哨兵也会自动将其加入集群，且自动分配为新的从库
  6. 这一切都是自动化，无需人为干预

redis集群

redis-sentinel

哨兵集群的配置

1.准备3个redis节点，1主2从的redis集群

  1. # redis支持多实例        -------基于多个配置文件，运行处多个redis相互独立的进程
  2. # s25-redis-6379.conf   -----主
  3. [root@localhost ~]# pkill -9 redis
  4. [root@localhost ~]# mkdir /s25sentinel
  5. [root@localhost ~]# cd /s25sentinel/
  6. [root@localhost s25sentinel]# mkdir -p /var/redis/data/
  7. [root@localhost s25sentinel]# vim s25-redis-6379.conf
  1. port 6379
  2. daemonize yes
  3. logfile "6379.log"
  4. dbfilename "dump-6379.rdb"
  5. dir "/var/redis/data/" 
  1. # s25-redis-6380.conf  ------从1
  2. [root@localhost s25sentinel]# vim s25-redis-6380.conf
  1. port 6380
  2. daemonize yes
  3. logfile "6380.log"
  4. dbfilename "dump-6380.rdb"
  5. dir "/var/redis/data/" 
  6. slaveof 127.0.0.1 6379
  1. # s25-redis-6381.conf  -----从2
  2. [root@localhost s25sentinel]# vim s25-redis-6381.conf
  1. port 6381
  2. daemonize yes
  3. logfile "6381.log"
  4. dbfilename "dump-6381.rdb"
  5. dir "/var/redis/data/" 
  6. slaveof 127.0.0.1 6379
  1. # 查看3个配置文件，准备分别启动该进程
  2. [root@localhost s25sentinel]# ls
  3. s25-redis-6379.conf  s25-redis-6380.conf  s25-redis-6381.conf
  5. # 分别启动3个进程后，检查进程情况 
  6. [root@localhost s25sentinel]# redis-server s25-redis-6379.conf
  7. [root@localhost s25sentinel]# redis-server s25-redis-6380.conf
  8. [root@localhost s25sentinel]# redis-server s25-redis-6381.conf
  9. [root@localhost s25sentinel]# ps -ef | grep redis
  10. root       6763      1  0 12:36 ?        00:00:00 redis-server *:6379
  11. root       6767      1  0 12:36 ?        00:00:00 redis-server *:6380
  12. root       6772      1  0 12:36 ?        00:00:00 redis-server *:6381
  13. root       6777   3186  0 12:36 pts/0    00:00:00 grep --color=auto redis
  15. # 确认3个库的主从关系
  16. [root@localhost s25sentinel]# redis-cli -p 6379 info replication
  17. # Replication
  18. role:master
  19. connected_slaves:2
  20. slave0:ip=127.0.0.1,port=6380,state=online,offset=71,lag=1
  21. slave1:ip=127.0.0.1,port=6381,state=online,offset=71,lag=1
  22. master_repl_offset:71
  23. repl_backlog_active:1
  24. repl_backlog_size:1048576
  25. repl_backlog_first_byte_offset:2
  26. repl_backlog_histlen:70

1主2从的环境搭建好了，准备招来3个值班的,也就是redis的哨兵

分别准备3个哨兵的配置文件，修改如下

三个哨兵的配置文件，仅仅是端口号的不同

  1. [root@localhost s25sentinel]# vim s25-sentinel-26379.conf

注释版

  1. port 26379  
  2. dir /var/redis/data/
  3. logfile "26379.log"
  5. // 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
  6. // 2代表判断主节点失败至少需要2个Sentinel节点节点同意
  7. // mymaster是主节点的别名
  8. sentinel monitor s25msredis 127.0.0.1 6379 2
  10. // 每个Sentinel节点都要定期PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30000毫秒30s且没有回复，则判定不可达
  11. sentinel down-after-milliseconds s25msredis 30000
  13. // 当Sentinel节点集合对主节点故障判定达成一致时，Sentinel领导者节点会做故障转移操作，选出新的主节点，
  14. // 原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为1
  15. sentinel parallel-syncs s25msredis 1
  17. // 故障转移超时时间为180000毫秒
  18. sentinel failover-timeout s25msredis 180000
  19. daemonize yes

无注释版

  1. port 26379
  2. dir /var/redis/data/
  3. logfile "26379.log"
  4. sentinel monitor s25msredis 127.0.0.1 6379 2
  5. sentinel down-after-milliseconds s25msredis 30000
  6. sentinel parallel-syncs s25msredis 1
  7. sentinel failover-timeout s25msredis 180000
  8. daemonize yes
  1. [root@localhost s25sentinel]# vim s25-sentinel-26380.conf 
  1. port 26380
  2. dir /var/redis/data/
  3. logfile "26380.log"
  4. sentinel monitor s25msredis 127.0.0.1 6379 2
  5. sentinel down-after-milliseconds s25msredis 30000
  7. sentinel parallel-syncs s25msredis 1
  9. sentinel failover-timeout s25msredis 180000
  10. daemonize yes
  1. [root@localhost s25sentinel]# vim s25-sentinel-26381.conf 
  1. port 26381
  2. dir /var/redis/data/
  3. logfile "26381.log"
  4. sentinel monitor s25msredis 127.0.0.1 6379 2
  5. sentinel down-after-milliseconds s25msredis 30000
  7. sentinel parallel-syncs s25msredis 1
  9. sentinel failover-timeout s25msredis 180000
  10. daemonize yes
  1. # 分别启动3个哨兵进程，以及查看进程信息
  2. [root@localhost s25sentinel]# redis-sentinel s25-sentinel-26379.conf
  3. [root@localhost s25sentinel]# redis-sentinel s25-sentinel-26380.conf
  4. [root@localhost s25sentinel]# redis-sentinel s25-sentinel-26381.conf
  5. [root@localhost s25sentinel]# ps -ef | grep redis
  6. root       6763      1  0 12:36 ?        00:00:00 redis-server *:6379
  7. root       6767      1  0 12:36 ?        00:00:00 redis-server *:6380
  8. root       6772      1  0 12:36 ?        00:00:00 redis-server *:6381
  9. root       6910      1  0 12:46 ?        00:00:00 redis-sentinel *:26379 [sentinel]
  10. root       6914      1  0 12:46 ?        00:00:00 redis-sentinel *:26380 [sentinel]
  11. root       6918      1  0 12:46 ?        00:00:00 redis-sentinel *:26381 [sentinel]
  12. root       6922   3186  0 12:46 pts/0    00:00:00 grep --color=auto redis
  14. # 检查redis哨兵的配置文件，以及哨兵的状态
  15. [root@localhost s25sentinel]# redis-cli -p 26379 info sentinel
  16. # Sentinel
  17. sentinel_masters:1
  18. sentinel_tilt:0
  19. sentinel_running_scripts:0
  20. sentinel_scripts_queue_length:0
  21. sentinel_simulate_failure_flags:0
  22. master0:name=s25msredis,status=ok,address=127.0.0.1:6379,slaves=2,sentinels=3

在哨兵搭建好了之后，模拟干掉主库，然后等待主从的一个自动化切换

  1. # 1.检查6379的进程，杀死后，哨兵能够自动的，进行投票选举，剩下来的一个slave为新的master，然后重新分配主从关系
  2. [root@localhost s25sentinel]#  ps -ef | grep redis
  3. root       6763      1  0 12:36 ?        00:00:01 redis-server *:6379
  4. root       6767      1  0 12:36 ?        00:00:01 redis-server *:6380
  5. root       6772      1  0 12:36 ?        00:00:01 redis-server *:6381
  6. root       6910      1  0 12:46 ?        00:00:01 redis-sentinel *:26379 [sentinel]
  7. root       6914      1  0 12:46 ?        00:00:01 redis-sentinel *:26380 [sentinel]
  8. root       6918      1  0 12:46 ?        00:00:01 redis-sentinel *:26381 [sentinel]
  9. root       7163   3186  0 13:02 pts/0    00:00:00 grep --color=auto redis
  10. [root@localhost s25sentinel]# redis-cli -p 6379 info replication
  11. # Replication
  12. role:master
  13. connected_slaves:2
  14. slave0:ip=127.0.0.1,port=6380,state=online,offset=249366,lag=0
  15. slave1:ip=127.0.0.1,port=6381,state=online,offset=249366,lag=0
  16. master_repl_offset:249366
  17. repl_backlog_active:1
  18. repl_backlog_size:1048576
  19. repl_backlog_first_byte_offset:2
  20. repl_backlog_histlen:249365
  21. [root@localhost s25sentinel]# kill 6763
  22. [root@localhost s25sentinel]# redis-cli -p 6380 info replication
  23. # Replication
  24. role:slave
  25. master_host:127.0.0.1
  26. master_port:6379
  27. master_link_status:down
  28. master_last_io_seconds_ago:-1
  29. master_sync_in_progress:0
  30. slave_repl_offset:272470
  31. master_link_down_since_seconds:27
  32. slave_priority:100
  33. slave_read_only:1
  34. connected_slaves:0
  35. master_repl_offset:0
  36. repl_backlog_active:0
  37. repl_backlog_size:1048576
  38. repl_backlog_first_byte_offset:0
  39. repl_backlog_histlen:0
  40. [root@localhost s25sentinel]# redis-cli -p 6381 info replication
  41. # Replication
  42. role:slave
  43. master_host:127.0.0.1
  44. master_port:6379
  45. master_link_status:down
  46. master_last_io_seconds_ago:-1
  47. master_sync_in_progress:0
  48. slave_repl_offset:272470
  49. master_link_down_since_seconds:29
  50. slave_priority:100
  51. slave_read_only:1
  52. connected_slaves:0
  53. master_repl_offset:0
  54. repl_backlog_active:0
  55. repl_backlog_size:1048576
  56. repl_backlog_first_byte_offset:0
  57. repl_backlog_histlen:0
  58. [root@localhost s25sentinel]# redis-cli -p 6380 info replication
  59. # Replication
  60. role:master
  61. connected_slaves:0
  62. master_repl_offset:0
  63. repl_backlog_active:0
  64. repl_backlog_size:1048576
  65. repl_backlog_first_byte_offset:0
  66. repl_backlog_histlen:0
  67. [root@localhost s25sentinel]# redis-cli -p 6381 info replication
  68. # Replication
  69. role:slave
  70. master_host:127.0.0.1
  71. master_port:6380
  72. master_link_status:up
  73. master_last_io_seconds_ago:1
  74. master_sync_in_progress:0
  75. slave_repl_offset:834
  76. slave_priority:100
  77. slave_read_only:1
  78. connected_slaves:0
  79. master_repl_offset:0
  80. repl_backlog_active:0
  81. repl_backlog_size:1048576
  82. repl_backlog_first_byte_offset:0
  83. repl_backlog_histlen:0
  85. # 2.故障的修复，修复6379这个redis数据库，且检查它的一个复制关系
  86. # 6379数据库会重新假如到主从复制，且变为一个新的从库
  88. # 3.如果想恢复他们的主从关系，全部kill掉，重新启动，默认就会以配置文件分配主从关系了

redis-cluster 搭建

准备好6匹马儿，也就是6个redis节点，也就是6个配置文件，redis集群节点最少是使用6个

这6个配置文件，仅仅是端口号的不同而已

  1. [root@localhost s25sentinel]# mkdir /s25rediscluster
  2. [root@localhost s25sentinel]# cd /s25rediscluster/
  3. [root@localhost s25rediscluster]# vim s25-redis-7000.conf
  1. port 7000
  2. daemonize yes
  3. dir "/opt/redis/data"
  4. logfile "7000.log"
  5. dbfilename "dump-7000.rdb"
  6. cluster-enabled yes   #开启集群模式
  7. cluster-config-file nodes-7000.conf　　#集群内部的配置文件
  8. cluster-require-full-coverage no　　#redis cluster需要16384个slot都正常的时候才能对外提供服务，换句话说，只要任何一个slot异常那么整个cluster不对外提供服务。 因此生产环境一般为no
  1. [root@localhost s25rediscluster]# vim s25-redis-7001.conf
  1. port 7001
  2. daemonize yes
  3. dir "/opt/redis/data"
  4. logfile "7001.log"
  5. dbfilename "dump-7001.rdb"
  6. cluster-enabled yes
  7. cluster-config-file nodes-7001.conf
  8. cluster-require-full-coverage no
  1. [root@localhost s25rediscluster]# vim s25-redis-7002.conf
  1. port 7002
  2. daemonize yes
  3. dir "/opt/redis/data"
  4. logfile "7002.log"
  5. dbfilename "dump-7002.rdb"
  6. cluster-enabled yes
  7. cluster-config-file nodes-7002.conf
  8. cluster-require-full-coverage no
  1. [root@localhost s25rediscluster]# vim s25-redis-7003.conf
  1. port 7003
  2. daemonize yes
  3. dir "/opt/redis/data"
  4. logfile "7003.log"
  5. dbfilename "dump-7003.rdb"
  6. cluster-enabled yes
  7. cluster-config-file nodes-7003.conf
  8. cluster-require-full-coverage no
  1. [root@localhost s25rediscluster]# vim s25-redis-7004.conf
  1. port 7004
  2. daemonize yes
  3. dir "/opt/redis/data"
  4. logfile "7004.log"
  5. dbfilename "dump-7004.rdb"
  6. cluster-enabled yes
  7. cluster-config-file nodes-7004.conf
  8. cluster-require-full-coverage no
  1. [root@localhost s25rediscluster]# vim s25-redis-7005.conf
  1. port 7005
  2. daemonize yes
  3. dir "/opt/redis/data"
  4. logfile "7005.log"
  5. dbfilename "dump-7005.rdb"
  6. cluster-enabled yes
  7. cluster-config-file nodes-7005.conf
  8. cluster-require-full-coverage no
  1. # 生成数据文件夹  
  2. [root@localhost s25rediscluster]# mkdir -p /opt/redis/data
  1. # 分别启动6个redis节点，且检查进程
  2. [root@s25linux s25rediscluster]# redis-server s25-redis-7000.conf
  3. [root@s25linux s25rediscluster]# redis-server s25-redis-7001.conf
  4. [root@s25linux s25rediscluster]# redis-server s25-redis-7002.conf
  5. [root@s25linux s25rediscluster]# redis-server s25-redis-7003.conf
  6. [root@s25linux s25rediscluster]# redis-server s25-redis-7004.conf
  7. [root@s25linux s25rediscluster]# redis-server s25-redis-7005.conf
  8. [root@localhost s25rediscluster]# ps -ef | grep redis
  9. root       6767      1  0 12:36 ?        00:00:05 redis-server *:6380
  10. root       6772      1  0 12:36 ?        00:00:05 redis-server *:6381
  11. root       6910      1  0 12:46 ?        00:00:08 redis-sentinel *:26379 [sentinel]
  12. root       6914      1  0 12:46 ?        00:00:08 redis-sentinel *:26380 [sentinel]
  13. root       6918      1  0 12:46 ?        00:00:08 redis-sentinel *:26381 [sentinel]
  14. root       8137      1  0 14:15 ?        00:00:00 redis-server *:7000 [cluster]
  15. root       8141      1  0 14:15 ?        00:00:00 redis-server *:7001 [cluster]
  16. root       8146      1  0 14:15 ?        00:00:00 redis-server *:7002 [cluster]
  17. root       8150      1  0 14:15 ?        00:00:00 redis-server *:7003 [cluster]
  18. root       8154      1  0 14:15 ?        00:00:00 redis-server *:7004 [cluster]
  19. root       8166      1  0 14:15 ?        00:00:00 redis-server *:7005 [cluster]
  20. root       8170   3186  0 14:15 pts/0    00:00:00 grep --color=auto redis
  1. # 此时尝试写入数据，发现不能写入数据
  2. # 因为现在仅仅是启动了6个redis节点，准备好了6匹马儿，马儿身上的框还没分配
  3. [root@localhost s25rediscluster]# redis-cli -p 7000
  4. 127.0.0.1:7000> keys *
  5. (empty list or set)
  6. 127.0.0.1:7000> set name hahahahahaha
  7. (error) CLUSTERDOWN Hash slot not served
  8. 127.0.0.1:7000>

此时准备好ruby的环境，用于一键创建redis集群，给马儿分配框，给redis节点分配slot槽位，用于写入数据

1.直接yum安装ruby解释器ruby和python一样是一个解释性编程语言，日本大神开发的

  1. # ruby=====python    gem====pip3   gem是ruby的包管理工具
  2. [root@localhost s25rediscluster]# yum install ruby -y

2.检查ruby和gem的环境

  1. [root@localhost s25rediscluster]# ruby -v
  2. ruby 2.0.0p648 (2015-12-16) [x86_64-linux]
  4. [root@localhost s25rediscluster]# gem -v
  5. 2.0.14.1

3.下载ruby操作redis的模块，用于创建集群

  1. [root@localhost s25rediscluster]# wget http://rubygems.org/downloads/redis-3.3.0.gem

4.用gem安装此模块,ruby就可以操作redis数据库了

  1. [root@localhost s25rediscluster]# gem install -l redis-3.3.0.gem   # 就如同python的 pip3 install xxxx

5.搜索ruby创建redis集群的脚本

  1. # redis-trib.rb 如何知道它的绝对路径？
  2. # which 是搜索PATH环境变量中的命令的绝对路径
  3. # find  才是搜索系统上的文件路径
  4. [root@localhost s25rediscluster]# find / -name "redis-trib.rb"  # 默认会在redis数据库的编译安装路径下

6.一键创建集群，且自动分配槽位，可以写入数据了

  1. redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005

7.进入集群写入数据，查看数据重定向

原文链接：https://www.cnblogs.com/zylyehuo/p/17686391.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Redis热门文章

  • Redis-复制
  • Redis
  • 关于SpringBoot整合redis使用Lettuce客户端超时问题
  • RedisTemplate常用方法封装
  • RedisTemplate中opsForValue和opsForList方法的使用详解
  • Redis7.0部署集群的实现步骤
  • Java Redis Redisson配置教程详解
  • Go语言开发redis封装及简单使用详解
  • SpringBoot Redis批量存取数据的操作
  • .NetCore下基于FreeRedis实现的Redis6.0客户端缓存之缓存键条件优雅过滤

    • Redis推荐文章

  • Redis系列：使用Stream实现消息队列 （图文总结+Go案例） - Hello-Brand
  • 记一次 redis 事件注册不当导致的内存泄露
  • Java Redis多限流
  • 【Azure Developer】一个复制Redis Key到另一个Redis服务的工具(redis_copy_net8)
  • Redis 高阶应用
  • 【长文】带你搞明白Redis
  • StackExchange.Redis跑起来，为什么这么溜？
  • 【进阶篇】基于 Redis 实现分布式锁的全过程
  • Higress 基于自定义插件访问 Redis
  • 美团二面：如何保证Redis与Mysql双写一致性？连续两个面试问到了！

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号