redis

目录

NoSQL

not only sql

存储结构与mysql这一种关系型数据库完全不同，nosql存储的是K-V形式

产品种类：Mongodb、redis、Hbase hadoop

NoSQL和sql的区别：

​ 应用场景不同，sql支持关系复杂的数据查询，nosql反之；sql支持事务性，nosql不支持。

Redis特性

redis是一个开源的(BSD许可)的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。

redis使c语言编写，支持数据持久化，使key-value类型数据库。

redis支持数据备份，也就是master-slave模式。

Redis优势

性能高，读取速度10万次/秒

写入速度8万次每秒

所有操作支持原子性

用作缓存数据库，数据放在内存中

替代某些场景下的mysql，如社交类app

大型系统中，可以存储session信息，购物车订单

Redis 高速缓存

  • 高速缓存利用内存保存数据，读写速度远超硬盘
  • 告诉缓存可以减少I/O操作

安装配置

  • yum安装redis

    # 安装redis
yum install redis -y
# 安装好，启动redis
systemctl start redis

  • 编译安装

    编译安装的优势是：

    • 编译安装时可以指定扩展的module（模块），php、apache、nginx都是一样有很多第三方扩展模块，如mysql，编译安装时候，如果需要就定制存储引擎（innodb，还是MyIASM）
    • 编译安装可以统一安装路径，linux软件约定安装目录在/opt/下面
    • 软件仓库版本一般比较低，编译源码安装可以根据需求，安装最新的版本
    1.下载redis源码
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
2.解压缩
tar -zxf redis-4.0.10.tar.gz
3.切换redis源码目录
cd redis-4.0.10.tar.gz
4.编译源文件
make 
5.编译好后，src/目录下有编译好的redis指令
6.make install 安装到指定目录，默认在/usr/local/bi

  • 检测redis是否工作

    redis-cli    #redis 客户端工具
#进入交互式环境后，执行ping，返回pong表示安装成功
127.0.0.1:6379> ping
PONG

  • redis.conf 配置文件

    绑定ip，如需要远程访问，需要填写服务器ip
bind 0.0.0.0 

端口，redis启动端口
port 6379

守护进程方式运行(后台运行)
daemonize yes

rdb数据文件
dbfilename dump.rdb

数据文件存放路径
dir /var/lib/redis/

日志文件
logfile /var/log/redis/redis-server.log

主从复制
slaveof

启动redis服务端

src/redis-server ./redis.conf	# 启动服务端，加载配置文件,默认端口6379.

src/redis-cli -p 端口		# 执行客户端命令

# 测试是否连接上redis
127.0.0.1:6379 > ping
返回pong代表连接成功

Redis五大数据类型

没有数值类型。

redis是一种高级的key：value存储系统，其中value支持五种数据类型
字符串（strings）
哈希（hashes）
列表（lists）
集合（sets）
有序集合（sorted sets）

基本命令：

keys *        查看所有key
type key      查看key类型
expire key seconds    过期时间
ttl key     查看key过期剩余时间        -2表示key已经不存在了
persist     取消key的过期时间   -1表示key存在，没有过期时间

exists key   判断key存在  存在返回1  否则0
del keys     删除key  可以删除多个
dbsize       计算key的数量

string字符串类型

set    设置key
get    获取key
append  追加string
mset   设置多个键值对
mget   获取多个键值对
del   删除key
incr  递增+1
decr  递减-1

list列表类型

lpush         从列表左边插
rpush         从列表右边插
lrange        获取一定长度的元素  lrange key  start stop
ltrim         截取一定长度列表
lpop          删除最左边一个元素
rpop          删除最右边一个元素
lpushx/rpushx     key存在则添加值，不存在不处理
llen 	长度

lpush age 18
lpush age 17
rpush age 19
lrange age 0 -1		# 查看全部的元素
llen age  # 3

sets集合类型

redis的集合，是一种无序的集合，集合中的元素没有先后顺序。去重

sadd/srem   添加/删除 元素
sismember   判断是否为set的一个元素
smembers    返回集合所有的成员
sdiff       返回一个集合和其他集合的差异(差集)
sinter      返回几个集合的交集
sunion      返回几个集合的并集

zset有序集合类型

保存排行榜、成绩、工资。

zset的每一个成员都有一个分数与之对应，并且分数是可以重复的。

zadd/zrem	添加/删除 元素
zreverange	倒序   
zrange		正序
zcard		基数

zadd mid_test 70 "aa"
zadd mid_test 80 "bb"
zadd mid_test 90 "cc"

zrange mid_test 0 -1 withscores
zcard mid_test		# 3

hashes哈希数据类型

哈希结构就是 k1 -> k1 : v1 如同字典 套字典 { k1 : { k2: v2 } }

hset  设置散列值
hget  获取散列值
hmset  设置多对散列值
hmget  获取多对散列值
hsetnx    如果散列已经存在，则不设置（防止覆盖key）
hkeys     返回所有keys
hvals     返回所有values
hlen      返回散列包含域（field）的数量
hdel      删除散列指定的域（field）
hexists   判断是否存在

Redis安全配置

redis没有用户概念，redis只有密码

redis默认在工作在保护模式下。不允许远程任何用户登录的（protected-mode）。

redis.conf设置：

protected-mode yes   # 打开保护模式
port 6380  # 更改默认启动端口
requirepass xxxxxx   # 设置redis启动密码，xxxx是自定义的密码

使用密码登录redis,使用6380端口。

Redis发布订阅

通过publish、subscribe 等命令实现订阅与发布模式。

image-20191223164321723

image-20191223164340784

单个发布者，多个接收者

PUBLISH channel msg
    将信息 message 发送到指定的频道 channel

SUBSCRIBE channel [channel ...]
    订阅频道，可以同时订阅多个频道

UNSUBSCRIBE [channel ...]
    取消订阅指定的频道, 如果不指定频道，则会取消订阅所有频道

PSUBSCRIBE pattern [pattern ...]
    订阅一个或多个符合给定模式的频道，每个模式以 * 作为匹配符，比如 it* 匹配所    有以 it 开头的频道( it.news 、 it.blog 、 it.tweets 等等)， news.* 匹配所有    以 news. 开头的频道( news.it 、 news.global.today 等等)，诸如此类
PUNSUBSCRIBE [pattern [pattern ...]]
    退订指定的规则, 如果没有参数则会退订所有规则
PUBSUB subcommand [argument [argument ...]]
    查看订阅与发布系统状态
注意：使用发布订阅模式实现的消息队列，当有客户端订阅channel后只能收到后续发布到该频道的消息，之前发送的不会缓存，必须Provider和Consumer同时在线。

发布者：

image-20191223165147038

订阅者：

image-20191223165238768

订阅一个或多个 通配符 *

发布：

PUBLISH python24 'jiayou'

订阅：

127.0.0.1:6379> PSUBSCRIBE python*

image-20191223170023062

Redis持久化RDB和AOF

Redis是一种内存型数据库，一旦服务器进程退出，数据库的数据就会丢失，为了解决这个问题，Redis提供了两种持久化的方案，将内存中的数据保存到磁盘中，避免数据的丢失。

RDB持久化

redis提供了RDB持久化的功能，这个功能可以将redis在内存中的的状态保存到硬盘中，它可以手动执行。也可以再redis.conf中配置，定期执行。

RDB持久化产生的RDB文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis可以通过这个文件还原数据库当时的状态。

在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）。

优点：速度快，适合做备份，主从复制就是基于RDB持久化功能实现。

rdb通过再redis中使用save命令触发 rdb。

dir /data/6379/
dbfilename  dbmp.rdb

每过900秒 有1个操作就进行持久化
save 900秒  1个修改类的操作
save 300秒  10个操作
save 60秒  10000个操作

save  900 1
save 300 10
save 60  10000

实践：

  • 1.配置文件
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379              #定义持久化文件存储位置
dbfilename  dbmp.rdb        #rdb持久化文件
bind 0.0.0.0      #redis绑定地址
requirepass redhat            #redis登录密码
save 900 1                    #rdb机制 每900秒 有1个修改记录
save 300 10                    #每300秒        10个修改记录
save 60 10000                #每60秒内        10000修改记录

  • 2.启动redis服务端

    src/redis-server ./redis.conf

  • 3.创建文件夹

    mkdir  -p  /data/6379

  • 4.检测目录，/data/6379下没有dbmp.rdb文件

  • 5.同save触发持久化，将数据写入RDB文件

    127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> save
OK

AOF持久化（推荐）

AOF（append-only log file），记录服务器执行的所有变更操作命令（例如set del等），并在服务器启动时，通过重新执行这些命令来还原数据集。(以日志形式，把修改类的操作，记录下来)

AOF 文件中的命令全部以redis协议的格式保存，新命令追加到文件末尾。

优点：最大程序保证数据不丢
缺点：日志记录非常大

redis-client   写入数据  >  redis-server   同步命令   >  AOF文件


AOF持久化配置，两条参数

appendonly yes
appendfsync  always    总是修改类的操作
             everysec   每秒做一次持久化
             no     依赖于系统自带的缓存大小机制

实践：

  • 配置文件

    daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
appendonly yes
appendfsync everysec

  • 启动redis服务

    src/redis-server ./redis.conf

  • 检查redis数据目录/data/6379/是否产生了aof文件

    [root@web02 6379]# ls
appendonly.aof  dbmp.rdb  redis.log

  • 登录redis-cli，写入数据，实时检查aof文件信息

    tail -f appendonly.aof

  • 开启客户端写入数据，然后关闭redis,检查数据是否持久化

    src/redis-cli
set name 'xx'

pkill -9 redis
src/redis-server myaof.conf
get name/redis-cli

切换rdb持久化为aof持久化

在不重启redis下切换

备份：cp dbmp.rdb /opt/

  1. 准备一个rdb的redis数据库

  2. 通过命令，直接切换aof
    127.0.0.1:6379> CONFIG set appendonly yes # 开启AOF功能
    OK
    127.0.0.1:6379> CONFIG SET save "" # 关闭RDB功能
    OK

  3. 正确情况下，会生成aof日志文件了，此时命令操作都是在aof里面了

  4. 还得修改配置文件，以上命令只是临时生效，改完以后，下次指定配置文件启动，就一直是aof。

    port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename  dbmp.rdb
save 900 1
save 300 10
save 60  10000
daemonize yes
appendonly yes  
appendfsync everysec

redis主从复制

Redis集群中的数据库复制是通过主从同步来实现的。

主节点（master）把数据分发给从而节点（slave）

主从同步的好处在于高可用，Redis节点有冗余设计。

概述：

主数据库可以进行读写操作，当发生写操作的时候自动将数据同步到从数据库，而从数据库一般是只读的，并接收主数据库同步过来的数据，一个主数据库可以有多个从数据库，而一个从数据库只能有一个主数据库。

过程：

1：当一个从数据库启动时，会向主数据库发送sync命令，

2：主数据库接收到sync命令后会开始在后台保存快照（执行rdb操作），并将保存期间接收到的命令缓存起来

3：当快照完成后，redis会将快照文件和所有缓存的命令发送给从数据库。

4：从数据库收到后，会载入快照文件并执行收到的缓存的命令。

环境准备：

创建文件夹

madir /data/638{0..2}

6380.conf

port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no

6381.conf

port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
protected-mode no

6382.conf

port 6382
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
protected-mode no

启动三个redis实例

src/redis-server ./6380.conf
src/redis-server ./6381.conf
src/redis-server ./6382.conf

6380做主节点，6381、6382做从节点

配置主从同步：

方式一：手动

  • 开启6381/6382的客户端src/redis-cli -p 6381

    slaveof 127.0.0.1 6380

info replication	# 查看检查主从状态

"""
# Replication
role:slave
master_host:127.0.0.1
master_port:6380

"""

  • 检查主数据库

    127.0.0.1:6380> info replication

"""
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=224,lag=0
slave1:ip=127.0.0.1,port=6382,state=online,offset=224,lag=0
"""

  • 测试读写数据

    # 主写入
127.0.0.1:6380> set age 18

# 从读取
127.0.0.1:6381> get age

# 从写入 报错
127.0.0.1:6381> set name aa
(error) READONLY You can't write against a read only replica.

方式二：配置文件

在每个从数据库的配置文件中加入slaveof 127.0.0.1 6380

port 6381
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
protected-mode no
slaveof  127.0.0.1 6380	# 在配置文件中，直接定义，直接启动，默认就是主从复制

手动进行主从复制切换

杀死从库，没有影响，可以再次启动。

杀死主库，必须解决故障，将其中一个从库切换为新的主库，继续主从复制。

  • 假设上面的6380端口的redis进程被杀死；

  • 选择6381端口为主库，只需将自身的从库身份去掉

    slaveof no one	# 关闭从库的身份

  • 将6382端口设为6381端口的从库

    127.0.0.1:6382> slaveof no one
127.0.0.1:6382> slaveof 127.0.0.1 6381

  • 检查主从信息

    info replication	# 查看检查主从状态

redis哨兵 -- sentinel

主从复制背景问题：

Redis主从复制可将主节点数据同步给从节点，从节点此时有两个作用：

  • 一旦主节点宕机，从节点作为主节点的备份可以随时顶上来。
  • 扩展主节点的读能力，分担主节点读压力。

问题：

  • 一旦主节点宕机，从节点上位，那么需要人为修改所有应用方的主节点地址（改为新的master地址），还需要命令所有从节点复制新的主节点

那么这个问题，redis-sentinel就可以解决。

Redis-Sentinel是redis官方推荐的高可用性解决方案，当用redis作master-slave的高可用时，如果master本身宕机，redis本身或者客户端都没有实现主从切换的功能。

而redis-sentinel就是一个独立运行的进程，用于监控多个master-slave集群，自动发现master宕机，进行自动切换slave > master。

sentinel主要功能如下：

  • 不时的监控redis是否良好运行，如果节点不可达就会对节点进行下线标识；
  • 如果被标识的是主节点，sentinel就会和其他的sentinel节点“协商”，如果其他节点也认为主节点不可达，就会选举一个sentinel节点来完成自动故障转义；
  • 在master-slave进行切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换。

Sentinel的工作方式

1. 每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令。

2. 如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线。

3. 如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。

4. 当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线。

5. 在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令，
   当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次。

6. 若没有足够数量的 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.

SDOWN适合于Master和Slave，只要一个 Sentinel 发现Master进入了ODOWN， 这个 Sentinel 就可能会被其他 Sentinel 推选出， 并对下线的主服务器执行自动故障迁移操作。

ODOWN只适用于Master，对于Slave的 Redis 实例，Sentinel 在将它们判断为下线前不需要进行协商， 所以Slave的 Sentinel 永远不会达到ODOWN。

监控流程图：

image-20191223211741356

Redis Sentinel架构

是redis的一个进程，但是不存储数据，只是监控redis。

架构图：

image-20191223211902984

故障切换：

image-20191223212032659

配置节点

主节点：6379.conf

port 6379
daemonize yes
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
dbfilename dump.rdb
dir /data/6379
protected-mode no

从节点：6380.conf

port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no
slaveof  127.0.0.1 6379

从节点：6381.conf

port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
protected-mode no
slaveof  127.0.0.1 6379

启动三个redis数据库节点

src/redis-cli -p 6379
src/redis-cli -p 6380
src/redis-cli -p 6381

配置Redis Sentinel

三个哨兵sentinel(哨兵)的配置文件，三个哨兵配置文件，仅仅是端口的不同，默认是26379,26380,26381 。

  • 创建配置文件

    touch sentinel1.conf

  • vim sentinel1.conf打开文件配置

    // Sentinel节点的端口
port 26379  
dir /var/redis/data/
logfile "26379.log"

// 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
// 2代表判断主节点失败至少需要2个Sentinel节点节点同意
// mymaster是主节点的别名

sentinel monitor mymaster 127.0.0.1 6379 2

//每个Sentinel节点都要定期PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30000毫秒30s且没有回复，则判定不可达
sentinel down-after-milliseconds mymaster 30000

//当Sentinel节点集合对主节点故障判定达成一致时，Sentinel领导者节点会做故障转移操作，选出新的主节点，
原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为1
sentinel parallel-syncs mymaster 1

//故障转移超时时间为180000毫秒
sentinel failover-timeout mymaster 180000

daemonize yes

  • 快速生成2个配置文件

    sed 's/26379/26380/g'   sentinel1.conf  > sentinel2.conf

sed 's/26379/26381/g'   sentinel1.conf  > sentinel3.conf

  • 创建数据文件夹

    mkdir -p /var/redis/data/

  • 开启三个哨兵进程

    src/redis-sentinel ./sentinel1.conf
src/redis-sentinel ./sentinel2.conf
src/redis-sentinel ./sentinel2.conf

  • 干掉master主库，哨兵会自动的选举一个从库为新的主库

    kill -9 进程号

  • 查看主从复制，81/80成为新的主库

    info replication

  • 将挂掉的主库，重新启动，查看主从复制信息，发现成了从库。

redis -cluster集群

为什么使用redis - cluster？

  • 解决高并发。redis官方表示生成可以达到10万/s,每秒执行10万条命令。而集群达到更高的并发。
  • 能够解决数据量太大的问题。，核心思想都是将数据分片（sharding）存储在多个redis实例中，每一片就是一个redis实例。

各大企业集群方案：

twemproxy由Twitter开源
Codis由豌豆荚开发，基于GO和C开发
redis-cluster官方3.0版本后的集群方案

客户端分片

​ redis3.0集群采用P2P模式，完全去中心化，将redis所有的key分成了16384个槽位，每个redis实例负责一部分slot，集群中的所有信息通过节点数据交换而更新。

redis实例集群主要思想是将redis数据的key进行散列，通过hash函数特定的key会映射到指定的redis节点上。

image-20191223221127425

数据分布理论：

分布式数据库首要解决把整个数据集按照分区规则映射到多个节点的问题，即把数据集划分到多个节点上，每个节点负责整个数据的一个子集。

常见的分区规则有哈希分区和顺序分区。Redis Cluster采用哈希分区规则，因此接下来会讨论哈希分区规则。

  • 节点取余分区
  • 一致性哈希分区
  • 虚拟槽分区(redis-cluster采用的方式)

哈希分区

节点取余：

例如按照节点取余的方式，分三个节点

1~100的数据对3取余，可以分为三类

  • 余数为0
  • 余数为1
  • 余数为2

那么同样的分4个节点就是hash(key)%4。

节点取余的优点是简单，客户端分片直接是哈希+取余

一致性分区：

客户端进行分片，哈希+顺时针取余。

虚拟槽分区：

Redis Cluster采用虚拟槽分区。

虚拟槽分区巧妙地使用了哈希空间，使用分散度良好的哈希函数把所有的数据映射到一个固定范围内的整数集合，整数定义为槽（slot）。

Redis Cluster槽的范围是0 ～ 16383。

槽是集群内数据管理和迁移的基本单位。采用大范围的槽的主要目的是为了方便数据的拆分和集群的扩展，

每个节点负责一定数量的槽。

image-20191223221510755

搭建redis-clister

搭建集群分为几部

  • 准备节点
  • 节点通信(分配主从)
  • 分配槽位给节点

redis-cluster集群架构

多个服务端，负责读写，彼此通信，redis指定了16384个槽。
每个服务器分配槽位，负责管理数据。
ruby脚本自动分配槽位。

image-20191223221913817

集群的搭建：

节点创建：

  • 准备6个数据库节点，搭建三主三从的数据库主从集群，端口7000——7005，6个基点。

    touch 7000.conf
touch 7001.conf 
touch 7002.conf 
touch 7003.conf 
touch 7004.conf 
touch 7005.conf

  • 配置文件vim 7000.conf

    port 7000
daemonize yes
dir "/opt/redis/data"
logfile "7000.log"
dbfilename "dump-7000.rdb"
cluster-enabled yes   #开启集群模式
cluster-config-file nodes-7000.conf　　# 集群内部的配置文件

  • 快速配置其他文件

    [root@localhost redis-5.0.7]# sed 's/7000/7001/g' 7000.conf > 7001.conf 
[root@localhost redis-5.0.7]# sed 's/7000/7002/g' 7000.conf > 7002.conf 
[root@localhost redis-5.0.7]# sed 's/7000/7003/g' 7000.conf > 7003.conf 
[root@localhost redis-5.0.7]# sed 's/7000/7004/g' 7000.conf > 7004.conf 
[root@localhost redis-5.0.7]# sed 's/7000/7005/g' 7000.conf > 7005.conf

  • 开启6个redis节点

    [root@localhost redis-5.0.7]# src/redis-server ./7000.conf
[root@localhost redis-5.0.7]# src/redis-server ./7001.conf
[root@localhost redis-5.0.7]# src/redis-server ./7002.conf
[root@localhost redis-5.0.7]# src/redis-server ./7003.conf
[root@localhost redis-5.0.7]# src/redis-server ./7004.conf
[root@localhost redis-5.0.7]# src/redis-server ./7005.conf

配置ruby环境，以及创建redis集群slot槽位分配：

  • yum安装

    yum install ruby -y

  • 下载ruby操作redis的模块

    wget http://rubygems.org/downloads/redis-3.3.0.gem

gem install -l redis-3.3.0.gem

  • 查找ruby工具位置

    find / -name redis-trib.rb

#   /opt/redis-5.0.7/src/redis-trib.rb

  • 开启redis集群槽位分配（redis版本5.0）

    每个主节点，有一个从节点，代表--replicas 1

    src/redis-cli --cluster create 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 --cluster-replicas 1

# redis 4.0版本开启方式
src/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

# 中间输入yes
# 发现7000/7001/7002是master主节点

    image-20191224124620377

  • 查看集群状态

    redis-cli -p 7000 cluster info  

redis-cli -p 7000 cluster nodes  #等同于查看nodes-7000.conf文件节点信息

集群主节点状态
redis-cli -p 7000 cluster nodes | grep master
集群从节点状态
redis-cli -p 7000 cluster nodes | grep slave

  • 测试写入集群数据，登录集群必须加 -c 参数，redis-cli -c -p 7000

    [root@localhost redis-5.0.7]# src/redis-cli -c -p 7000
127.0.0.1:7000> set name chao
-> Redirected to slot [5798] located at 127.0.0.1:7001
OK
127.0.0.1:7001> ping
PONG
127.0.0.1:7001> get name
"chao"
127.0.0.1:7001> set age 19
-> Redirected to slot [741] located at 127.0.0.1:7000
OK
127.0.0.1:7000> get name
-> Redirected to slot [5798] located at 127.0.0.1:7001
"chao"
127.0.0.1:7001> get age
-> Redirected to slot [741] located at 127.0.0.1:7000
"19"

    工作原理：redis客户端任意访问一个redis实例，如果数据不在该实例中，通过重定向引导客户端访问所需要的redis实例。

posted @ 2020-03-29 19:33  SensorError  阅读(169)  评论(0)  编辑  收藏  举报