redis高阶

redis介绍

redis八个特性

速度快：10w ops（每秒10w读写），数据存在内存中，c语言实现，单线程模型
持久化：rdb和aof

多种数据结构

5大数据结构
   BitMaps位图：布隆过滤器 本质是 字符串
   HyperLogLog：超小内存唯一值计数，12kb HyperLogLog 本质是 字符串
   GEO：地理信息定位 本质是有序集合

支持多种编程语言：基于TCP通信协议，各大编程语言都支持
功能丰富：发布订阅（消息）lua脚本，事务（pipeline)
简单:源代码几万行，不依赖外部库
主从复制，主服务器和从服务器，主服务器可以同步到从服务器中

高可用和分布式：

2.8版本以后使用redis-sentinel支持高可用
3.0版本以后支持分布式

redis linux下安装

# 没有wget工具 切到su root 用户下载 yum -y install wget

# 1 下载（源代码，c语言）
   wget http://download.redis.io/releases/redis-6.2.9.tar.gz
#2 解压
   tar -xzf redis-6.2.9.tar.gz
#3 建立软连接
   ln -s redis-6.2.9 redis  # 目的就是为了之后升级redis版本的时候不用一 一改配置
   cd redis
   make&&make install  编译并安装
#4 在src目录下可以看到
   #redis-server--->redis服务器
   #redis-cli---》redis命令行客户端
   #redis-benchmark---》redis性能测试工具
   #redis-check-aof--->aof文件修复工具
   #redis-check-rdb---》rdb文件检查工具
   #redis-sentinel---》sentinel服务器，哨兵
   #redis作者对windows维护不好，window自己有安装包
   
# 卸载redis
# 1、查看redis进程；
   ps aux|grep redis
# 2、kill掉进程；
   kill 进程id
# 3、进入到redis目录
   cd /usr/local/
# 4、删除redis对应的文件
   rm -f /usr/local/redis/bin/redis*
   rm -f /usr/local/bin/redis*
# 5、删除对应的文件
   rm -rf redis

redis启动方式

最简单启动方式

#最简启动
redis-server
ps -ef|grep redis  #查看进程
#yum install net-tools -y # 没有ps 命令执行这句
netstat -antpl|grep redis #查看端口
redis-cli -h ip -p port ping #命令查看

动态参数启动

#动态参数启动
redis-serve --port 6380 #启动，监听6380端口  可写-h主机和-p端口

配置文件启动

# 默认配置文件：redis.conf

#配置文件启动（6379对应手机按键MERZ，意大利女歌手Alessia Merz的名字）
#####通过redis-cli连接，输入config get * 可以获得默认配置
#在redis目录下创建config目录，copy一个redis.conf文件
#daemonize--》是否是守护进程启动（no|yes）
#port---》端口号
#logfile--》redis系统日志
#dir--》redis工作目录


daemonize yes
pidfile /var/run/redis.pid
port 6379
dir "/root/redis/data"
logfile 6379.log
# 创建data文件夹
mkdir data
# 启动
redis-server redis.conf

客户端连接命令

redis-cli -h 地址 -p 端口
redis-cli -h 127.0.0.1 -p 6379 info  # 直接返回redis的运行信息---》redis监控平台

CONFIG GET *  # 获取redis的配置信息
# 296 对配置文件，只需要关注咱们讲过的即可 dir，port，daemonize
#requirepass 设置的密码是什么，如果是空，没有密码
# 直接修改redis的配置信息，修改后同步到硬盘，永久生效
CONFIG SET requirepass 123456  # 密码设置上了
CONFIG REWRITE # 写到硬盘上了

# 下次再连接，必须使用如下两种方式
	-方式一：直接连接，指定密码：redis-cli -a 123456
    -方式二：先连接进去redis-cli，再执行r  auth 密码
    
    
    
# 注意的redis配置文件：
    # bind    127.0.0.1  0.0.0.0
    # port   端口
    # requirepass  密码
    # dir  工作目录
	#logfile 日志文件
    #daemonize 是否以守护进程运行
    # pidfile 放的是进程id号
    # maxmemory 可以使用的最大内存
    # databases  有多少个库
    # dbfilename  rdb的持久化方案的存储文件dump.rdb

redis 典型场景

使用最多就是redis缓存

# 缓存系统：使用最广泛的就是缓存
# 计数器：网站访问量，转发量，评论数（文章转发，商品销量，单线程模型，不会出现并发问题）
# 消息队列：发布订阅，阻塞队列实现（简单的分布式，blpop：阻塞队列，生产者消费者） celery的消息队列
# 排行榜：有序集合（阅读排行，点赞排行，推荐（销量高的，推荐））
# 社交网络：很多特效跟社交网络匹配，粉丝数，关注数，简单的推荐
# 实时系统：垃圾邮件处理系统，黑白名单系统
# 地理位置信息：附近的人

redis通用命令

# 算法性能衡量标准： 大O表示法
	时间：运行算法的实际     o(1)  o(log n)   o(n)   o(n方)
    
    空间：运行算法占用的内存  o(1)  o(log n)   o(n)   o(n方)


1.keys 
    #打印出所有key
        keys * 
    #打印出所有以he开头的key
        keys he*
    #打印出所有以he开头，第三个字母是h到l的范围
        keys he[h-l]
    #三位长度，以he开头，？表示任意一位
        keys he？
    #keys命令一般不在生产环境中使用，生产环境key很多，时间复杂度为o(n),用scan命令

2. dbsize   计算key的总数
	dbsize #redis内置了计数器，插入删除值该计数器会更改，所以可以在生产环境使用，时间复杂度是o(1)

3. exists key 时间复杂度o(1)
    #设置a
        set a b
    #查看a是否存在
        exists a
        (integer) 1

#存在返回1 不存在返回0
4.del key  时间复杂度o(1)
    删除成功返回1，key不存在返回0
    
5.expire key seconds  时间复杂度o(1)
	expire name 3 #3s 过期
	ttl name  #查看name还有多长时间过期
	persist name #去掉name的过期时间
    
6. type key  时间复杂度o(1)
	type name #查看name类型，返回string


7. 其他
    info命令：内存，cpu，主从相关
    client list  # 正在连接的会话
    client kill ip:端口   # 强制停掉某连接
    dbsize    # 总共有多少个key
    flushall  # 清空所有  # 谨慎操作
    flushdb    # 只清空当前库
    select 数字   # 选择某个库  总共16个库
    monitor       # 记录操作日志，夯住----》记录某个ip+端口操作了什么-----》用来监听每一步操作

数据结构和内部编码

# redis的跳跃表吗？
   -他是reids的有序集合类型的底层实现
   
#单线程为什么这么快
   1 纯内存
   2 非阻塞IO （epoll），自身实现了事件处理，不在网络io上浪费过多时间
   3 避免线程间切换和竞态消耗

redis字符串类型

# 字符串key value不能大于512m，一般建议100k以内


1.基本使用get，set，del
    get name       #时间复杂度 o(1)
    set name lqz   #时间复杂度 o(1)
    del name       #时间复杂度 o(1)
    
2. 其他使用incr,decr,incrby,decrby
    incr age  #对age这个key的value值自增1
    decr age  #对age这个key的value值自减1
    incrby age 10  #对age这个key的value值增加10
    decrby age 10  #对age这个key的value值减10
    #统计网站访问量（单线程无竞争，天然适合做计数器）
    #缓存mysql的信息（json格式）
    #分布式id生成（多个机器同时并发着生成，不会重复）
    
3. set，setnx，setxx
    set name lqz  #不管key是否存在，都设置 
    setnx name lqz #key不存在时才设置（新增操作）
    set name lqz nx #同上
    set name lqz xx #key存在，才设置（更新操作）
    
4. mget mset
    mget key1 key2 key3     #批量获取key1，key2.。。时间复杂度o(n)
    mset key1 value1 key2 value2 key3 value3    #批量设置时间复杂度o(n)
    #n次get和mget的区别
        #n次get时间=n次命令时间+n次网络时间
        #mget时间=1次网络时间+n次命令时间
        
5. 其他：getset，append，strlen
    getset name lqznb #设置新值并返回旧值 时间复杂度o(1)
    append name 666 #将value追加到旧的value 时间复杂度o(1)
    strlen name  #计算字符串长度(注意中文)  时间复杂度o(1)
    
6. 其他：incrybyfloat,getrange,setrange
    increbyfloat age 3.5  #为age自增3.5，传负值表示自减 时间复杂度o(1)
    getrange key start end #获取字符串制定下标所有的值  时间复杂度o(1)
    setrange key index value #从指定index开始设置value值  时间复杂度o(1)

哈希类型

1.hget,hset,hdel
    hget key field  #获取hash key对应的field的value 时间复杂度为 o(1)
    hset key field value #设置hash key对应的field的value值 时间复杂度为 o(1)
    hdel key field #删除hash key对应的field的值 时间复杂度为 o(1)
    #测试
    hset user:1:info age 23
    hget user:1:info ag
    hset user:1:info name lqz
    hgetall user:1:info
    hdel user:1:info age
2.hexists,hlen
    hexists key field  #判断hash key 是否存在field 时间复杂度为 o(1)
    hlen key   #获取hash key field的数量  时间复杂度为 o(1)
    hexists user:1:info name
    hlen user:1:info  #返回数量
        
3.hmget，hmset
    hmget key field1 field2 ...fieldN  #批量获取hash key 的一批field对应的值  时间复杂度是o(n)
    hmset key field1 value1 field2 value2  #批量设置hash key的一批field value 时间复杂度是o(n)

4. hgetall,hvals，hkeys
    hgetall key  #返回hash key 对应的所有field和value  时间复杂度是o(n)
    hvals key   #返回hash key 对应的所有field的value  时间复杂度是o(n)
    hkeys key   #返回hash key对应的所有field  时间复杂度是o(n)
     #小心使用hgetall
        
  
5. 其他操作 hsetnx，hincrby，hincrbyfloat
    hsetnx key field value #设置hash key对应field的value（如果field已存在，则失败），时间复杂度o(1)
    hincrby key field intCounter #hash key 对英的field的value自增intCounter 时间复杂度o(1)
    hincrbyfloat key field floatCounter #hincrby 浮点数 时间复杂度o(1)
    
 """
  1.计算网站每个用户主页的访问量
  	hincrby user:1:info pageview count
  2.缓存mysql的信息，直接设置hash格式
  """

列表

1.插入操作
    #rpush 从右侧插入
    rpush key value1 value2 ...valueN  #时间复杂度为o(1~n)
    #lpush 从左侧插入

    #linsert
    linsert key before|after value newValue   #从元素value的前或后插入newValue 时间复杂度o(n) ，需要遍历列表
    linsert listkey before b java
    linsert listkey after b php

2.删除操作

    lpop key #从列表左侧弹出一个item 时间复杂度o(1)

    rpop key #从列表右侧弹出一个item 时间复杂度o(1)

    lrem key count value
    #根据count值，从列表中删除所有value相同的项 时间复杂度o(n)
    1 count>0 从左到右，删除最多count个value相等的项
    2 count<0 从右向左，删除最多 Math.abs(count)个value相等的项
    3 count=0 删除所有value相等的项
    lrem listkey 0 a #删除列表中所有值a
    lrem listkey -1 c #从右侧删除1个c

    ltrim key start end #按照索引范围修剪列表 o(n)
    ltrim listkey 1 4 #只保留下表1--4的元素

3.查询操作
    lrange key start end #包含end获取列表指定索引范围所有item  o(n)
    lrange listkey 0 2
    lrange listkey 1 -1 #获取第一个位置到倒数第一个位置的元素

    lindex key index #获取列表指定索引的item  o(n)
    lindex listkey 0
    lindex listkey -1

    llen key #获取列表长度

5.修改操作

    lset key index newValue #设置列表指定索引值为newValue o(n)
    lset listkey 2 ppp #把第二个位置设为ppp

# 实战

实现timeLine功能，时间轴，微博关注的人，按时间轴排列，在列表中放入关注人的微博的即可


6.其他操作

    blpop key timeout #lpop的阻塞版，timeout是阻塞超时时间，timeout=0为拥有不阻塞 o(1)
    brpop key timeout #rpop的阻塞版，timeout是阻塞超时时间，timeout=0为拥有不阻塞 o(1)

    
#要实现栈的功能
lpush+lpop   先进后出
#实现队列功能
lpush+rpop   先进先出
#固定大小的列表
lpush+ltrim
#消息队列
lpush+brpop

集合类型set

sadd key element  # 向集合key添加element（如果element存在，添加失败） o(1)
srem key element  #从集合中的element移除掉 o(1)
scard key  #计算集合大小
sismember key element  #判断element是否在集合中
srandmember key count  #从集合中随机取出count个元素，不会破坏集合中的元素
spop key  #从集合中随机弹出一个元素
smembers key  #获取集合中所有元素 ，无序，小心使用，会阻塞住 


sdiff user:1:follow user:2:follow  #计算user:1:follow和user:2:follow的差集
sinter user:1:follow user:2:follow  #计算user:1:follow和user:2:follow的交集     
sunion user:1:follow user:2:follow  #计算user:1:follow和user:2:follow的并集
                
   
sdiff|sinter|suion + store destkey... #将差集，交集，并集结果保存在destkey集合中


# 应用场景
去重场景
抽奖系统 ：通过spop来弹出用户的id，活动取消，直接删除
点赞，点踩，喜欢等，用户如果点了赞，就把用户id放到该条记录的集合中
标签：给用户/文章等添加标签，sadd user:1:tags 标签1 标签2 标签3
给标签添加用户，关注该标签的人有哪些
共同好友：集合间的操作

有序集合（zset)

# 特点：不能重复 有一个分值字段，来保证顺序
key                  score                value
user:ranking           1                   lqz
user:ranking           99                  lqz2
user:ranking           88                  lqz3
    
#集合有序集合
集合：无重复元素，无序，element
有序集合：无重复元素，有序，element+score

#列表和有序集合
列表：可以重复，有序，element
有序集合：无重复元素，有序，element+score

#  API使用
zadd key score element #score可以重复，可以多个同时添加，element不能重复 o(logN) 
zrem key element #删除元素，可以多个同时删除 o(1)
zscore key element #获取元素的分数 o(1)
zincrby key increScore element #增加或减少元素的分数  o(1)
zcard key #返回元素总个数 o(1)
zrank key element #返回element元素的排名（从小到大排）

zrange key 0 -1 #返回排名，不带分数  o(log(n)+m) n是元素个数，m是要获取的值
zrange player:rank 0 -1 withscores #返回排名，带分数

zrangebyscore key minScore maxScore #返回指定分数范围内的升序元素 o(log(n)+m) n是元素个数，m是要获取的值
zrangebyscore user:1:ranking 90 210 withscores #获取90分到210分的元素

zcount key minScore maxScore #返回有序集合内在指定分数范围内的个数 o(log(n)+m)

zremrangebyrank key start end #删除指定排名内的升序元素 o(log(n)+m)
zremrangebyrank user:1:rangking 1 2 #删除升序排名中1到2的元素
        
zremrangebyscore key minScore maxScore #删除指定分数内的升序元素 o(log(n)+m)
zremrangebyscore user:1:ranking 90 210 #删除分数90到210之间的元素

# 实战

排行榜：音乐排行榜，销售榜，关注榜，游戏排行榜

#其他操作
zrevrank #返回某个元素从高到低排序的顺序 
#zrevrank girls dlrb  返回迪丽热巴 按分数降序排的排名
zrevrange #从高到低排序取一定范围
zrevrangebyscore #返回指定分数范围内的降序元素

zinterstore #对两个有序集合交集
zunionstore #对两个有序集合求并集

慢查询

单线程架构，命令一个个执行，会有长慢命令，造成整个redis的阻塞。redis提供一种方式，可以记录长慢命令【放到慢查询队列中】，用于后续的排查修改工作

# 配置慢查询
	-slowlog-max-len ：慢查询队列的长度
    - slowly-log-slower-than ：超过多少微妙，就算慢命令，就会记录到慢查询队列中
    
    
# 实战
config set slowlog-log-slower-than 0
config set slowlog-max-len 100
config rewrite  # 写了永久生效，如果不写，只是暂时生效

# 查看慢查询队列
slowlog len #获取慢查询队列长度
slowlog reset #清空慢查询队列
slowlog get  # 获取慢查询队列的所有命令

pipeline与事务

Redis的pipeline(管道)功能在命令行中没有，但redis是支持pipeline的，而且在各个语言版的client中都有相应的实现(Redis模块)，将一批命令，批量打包，在redis服务端批量计算(执行)，然后把结果批量返回。

1次pipeline(n条命令)=1次网络时间+n次命令时间

# python实现pipline
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
#创建pipeline
pipe = r.pipeline(transaction=True)
#开启事务
pipe.multi()
pipe.set('name', 'lqz')
#其他代码，可能出异常

pipe.set('role', 'nb')
 
pipe.execute()



# redis原生实现事务   实现事务mutil
# 1 mutil  开启事务，放到管道中一次性执行
multi   # 开启事务
set name lqz
set age 18
exec



# 2 模拟实现乐观锁  watch+multi实现乐观锁
# 在开启事务之前，先watch
watch age
multi
decr age
exec

# 另一台机器
multi
decr age
exec  # 先执行，上面的执行就会失败(乐观锁，被wathc的事务不会执行成功，除非age还是原来被监听的数据，修改才会变)

发布订阅

发布订阅是 观察者模式，只要订阅了某个东西，这个东西变化了，所有订阅的人都能收到。

发布者发布了消息，所有的订阅者都可以收到，就是生产者消费者模型（后订阅了，无法获取历史消息）

# 一个客户端发送消息
publish lqz hello  # 只要有订阅者，客户端发送消息，所有订阅者都能收到

# 另外两个客户端，订阅频道，等待接收消息
subscribe lqz

# 查看某个频道有几个订阅者
pubsub numsub lqz


# 列出活跃的频道
pubsub channels

#发布订阅和消息队列
发布订阅数全收到，消息队列有个抢的过程，只有一个抢到

Bitmap位图

Bitmap位图：是字符串类型，但是以二进制形式存储的，获取，设置某个二进制位的.

# set hello big
# getbit hello 0/1/2  返回比特位是0或1

# setbit hello 7 1   把第7，也就是8个比特位设置为1 
# big就变成了cit
# bitcount hello  0 1  字节数  返回8

# 独立用户统计
	-假设：1亿用户，5千万活跃用户     统计今天活跃用户是多选   用户iduserid是整形，32位整型
    	-int32 类型  4个字节表示一个数字---》 正负 2的31次方-1 的范围
        	1    4个字节
            1001 4个字节
    	-方式一：登录，把id放到集合中---》统计集合大小
        -方式二：登录，操作位图，把id对应的数字设为1 ，以后统计1的个数

HyperLogLog

redis中支持这种算法，基于HyperLogLog算法：极小的空间完成独立数量统计。很类似于布隆过滤器。

pfadd key element # 向hyperloglog添加元素,可以同时添加多个
pfcount key #计算hyperloglog的独立总数

pfadd uuids "uuid1" "uuid2" "uuid3" "uuid4" #向uuids中添加4个uuid
pfcount uuids #返回4


#也可以做独立用户统计

持久化方案

持久化

redis的所有数据保存在内存中，把内存中的数据同步到硬盘上这个过程称之为持久化。

持久化的实现方式

快照：某时某刻数据的一个完成备份

mysql的Dump # 数据库表转存储

redis的RDB
日志：任何操作记录日志，要恢复数据，只要把日志重新走一遍即可

mysql的 Binlog

redis的AOF

1. RDB

rdb持久化配置方式

方式一：通过命令：同步操作

save:生成rdb持久化文件

方式二：异步持久化：不会阻塞住其他命令的执行

bgsave

方式三：配置文件配置：这个条件触发，就执行bgsave

redis中的配置文件配置下列内容

save 900 1
save 300 10
save 60 10000
dbfilename dump.rdb
dir "/root/redis-6.2.9/data"
如果60s中改变了1w条数据，自动生成rdb
如果300s中改变了10条数据，自动生成rdb
如果900s中改变了1条数据，自动生成rdb

2.AOF方案

使用aof方案的情景？

可能数据会丢失

aof是什么？

客户端每写入一条命令，都记录一条日志，放到日志文件中，如果出现岩机，可以将数据完全恢复。

AOF的三种策略

日志不是直接写到硬盘中，而是先放在缓冲区，缓冲区根据一些策略，写入硬盘中。

always : redis----》写命令刷新的缓存区---》每条命令fsync到硬盘---》AOF文件
everysec(默认值)：redis----》写命令刷新的缓冲区---》每秒把缓冲区fsync到硬盘中----》AOF文件
no: redis ---》写命令刷新的缓冲区--》操作系统决定，缓冲区fsync到硬盘---》AOF文件

AOF重写

随着命令的逐步写入，并发量的变大，AOF文件会越来越大，通过AOF重写来解决该问题。

本质就是把过期的、无用的、重复的，可以优化的命令来优化，这样可以减少磁盘占用量，加速恢复速度。

# AOF重写配置参数
	auto-aof-rewrite-min-size：500m
    auto-aof-rewrite-percentage:增长率
        
        
# aof持久化的配置
appendonly yes #将该选项设置为yes，打开
appendfilename "appendonly.aof" #文件保存的名字
appendfsync everysec #采用第二种策略
no-appendfsync-on-rewrite yes #在aof重写的时候，是否要做aof的append操作，因为aof重写消耗性能，磁盘消耗，正常aof写磁盘有一定的冲突，这段期间的数据，允许丢失

3.混合持久化

可以同时开启AOF和RDB，他们是互相不影响的。

redis 4.x以后出现了混合持久化，其实就是AOF + RDB 来解决恢复速度问题。开启了混合持久化，AOF在重写时，不再是单纯将内存数据转换为RESP命令写入AOF文件，而是将重写这一刻之前的内存做RDB快照处理。

# 配置参数：必须先开启AOF
# 开启 aof
appendonly yes
# 开启 aof复写
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
# 开启 混合持久化
aof-use-rdb-preamble yes  # 这正有用的是这句话
# 关闭 rdb
save ""



# aof重写可以使用配置文件触发，也可以手动触发：bgrewriteaof

主从复制原理和方案

为什么需要注册复制方案？

机器故障，从库切为主库，保证数据正常运行
容器瓶颈
QPS瓶颈

主从解决了qps问题，机器故障问题

主从实现的功能：

一主一从，一主多从

做读写分离

做数据副本

提高并发量

注意：一个master可以有多个slave

一个slave只能有一个master

数据流向是单向的，从master到slave，从库只能读，不能写，主库既能读又能写

redis主从复制流程和原理

副本(从)库通过slaveof 127.0.0.1 6379命令,连接主库,并发送SYNC给主库
主库收到SYNC,会立即触发BGSAVE,后台保存RDB,发送给副本库
副本库接收后会应用RDB快照，load进内存
主库会陆续将中间产生的新的操作,保存并发送给副本库
到此,我们主复制集就正常工作了
再此以后,主库只要发生新的操作,都会以命令传播的形式自动发送给副本库.
所有复制相关信息,从info信息中都可以查到.即使重启任何节点,他的主从关系依然都在.
如果发生主从关系断开时,从库数据没有任何损坏,在下次重连之后,从库发送PSYNC给主库
主库只会将从库缺失部分的数据同步给从库应用,达到快速恢复主从的目的··

#克隆虚拟机之后，你把新的这一台的ip改了（vim /etc/sysconfig/network-scripts/具体网卡文件），然后重启网卡：systemctl restart network就行了

1.启动两台redis服务  # 根据业务来

2.主从复制配置
	-1 命令方式，在从库上执行
    	slaveof 127.0.0.1 6379 #异步  # 主库能写能读
    	# 从库不能写，从库只能读
        
        slaveof no one  # 从库：断开主从关系
    
    -2 配置文件方式，在从库加入
    	slaveof 127.0.0.1 6379 #配置从节点ip和端口
		slave-read-only yes #从节点只读，因为可读可写，数据会乱
    	autpass 123456

    	
# 辅助配置（给主库用的）
min-slaves-to-write 1
min-slaves-max-lag 3
#那么在从服务器的数量少于1个，或者三个从服务器的延迟（lag）值都大于或等于3秒时，主服务器将拒绝执行写命令


# 主从同步主库是否要开启持久化？
  看情况：但如果不开，有可能重启操作，会造成所有主从数据丢失！

哨兵高可用

哨兵：Sentinel 实现高可用，是指服务可用性高。主从复制不是高可用。

主从存在的问题

主从复制，当主节点发生故障，需要做故障转移，可以手动转移，让其中一个slave变成master，需要借助哨兵来实现。

主从复制，只能主库写数据，所以写能力和存储能力有限，需要借助于集群

哨兵工作原理

多个sentinel发现并确认master有问题
选举触一个sentinel作为领导
选取一个slave作为新的master
通知其余slave成为新的master的slave
通知客户端主从变化
等待老的master复活成为新master的slave

高可用搭建步骤


第一步：先搭建一主两从
第二步：哨兵配置文件，启动哨兵（redis的进程，也要监听端口，启动进程有配置文件）
# 各自的配置文件
port 26379
daemonize yes
dir /root/redis/data
bind 0.0.0.0
logfile "redis_sentinel.log"
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 30000


port 26380
daemonize yes
dir /root/redis/data1
bind 0.0.0.0
logfile "redis_sentinel.log"
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 30000


port 26381
daemonize yes
dir /root/redis/data2
bind 0.0.0.0
logfile "redis_sentinel.log"
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 30000

第三步：启动三个哨兵

./src/redis-sentinel ./sentinal_26379.conf
./src/redis-sentinel ./sentinal_26380.conf
./src/redis-sentinel ./sentinal_26381.conf

第四步：停止主库，发现80变成了主库，以后79启动，变成了从库

集群原理及搭建

集群原理

即使做了读写分离和高可用，还存在下面的问题：

并发量: 单机redis---》qps为10w/s，但是需要百万级别的并发量时，单机redis远远不能支持。
数据量：机器内存只有16g---256g，但是需要500g数据呢？

针对上述问题，可以采用集群解决这个问题。添加机器和分布式，redis cluster ,在2015年的 3.0版本加入了满足分布式的需求。

数据库的多机数据分别方案

单机redis无法满足要存的数据，需要进行分区，分到若干子集中。主流分区方式（数据分片方式）分别时哈希分布和顺序分布

分布方式	特点	产品
哈希分布	数据分散度高，建值分布于业务无关，无法顺序访问，支持批量操作	一致性哈希memcache，redis cluster，其他缓存产品
顺序分布	数据分散度易倾斜，建值业务相关，可顺序访问，支持批量操作	BigTable，HBase

顺序分布

原理：100个数据分到3个节点上

1-33 第一个节点

34-66 第二个节点

67-100 第三个节点

很多关系型数据库使用的是顺序分布

哈希分区

原理：hash分区：节点取余，假如有3台机器，hash(key)%3，落到不同节点（余数落在什么节点就是哪个节点）

1. 节点取余分区:扩容缩容麻烦，很多数据需要偏移，总偏量大于80%--->推荐翻倍扩容，数据偏移量为50%
    # 总结：
        客户端分片，通过hash+取余
        节点伸缩，数据节点关系发生变化，导致影响数据迁移过大
        迁移数量和添加节点数量有关：建议翻倍扩容
     
2.一致性哈希分区
    每个节点负责一部分数据，对key进行hash，得到结果在node1和node2之间，就放到node2中，顺时针查找
    # 总结：
         客户端分片：哈希+顺时针（优化取余）
         节点伸缩：只影响临近节点，但是还有数据迁移的情况
         伸缩：保证最小迁移数据和无法保证负载均衡（这样总共5个节点，数据就不均匀了），翻倍扩容可以实现负载均衡
        
3.虚拟槽
    预设虚拟槽：每个槽映射一个数据子集，一般比节点数大
    良好的哈希函数：如CRC16
    服务端管理节点、槽、数据：如redis cluster（槽的范围0–16383
    
    
    
# redis使用了虚拟槽
    对key进行hash得到数据对16384取余，就知道这个数据是归哪个槽管理，节点管理哪些槽是知道的，数据存在哪个节点就知道了

节点取余扩容

一致性哈希分区

虚拟槽

集群搭建

节点：相当于某一台机器，

ment：节点于节点之间通过meet通信

指派槽: 16384个槽分给几个节点

复制: 主从复制

高可用：当主节点挂掉，从节点顶上

指派槽

搭建步骤

# 准备6台机器 （6个redis-server进程）
   准备6个虚拟机，去配置文件(vi /etc/sysconfig/network-scripts/ifcfg-eth0)中修改ip地址(ipaddr)
   重启：systemctl restart network    # ip -a 查看修改成功没
   修改主机名：hostnamectl set-hostname 主机名----》bash

# 第一步：准备6台机器，写6个配置文件
    配置文件redis.conf
port 7000   # 指定端口
daemonize yes
dir "/root/redis/data/"
logfile "7000.log"

cluster-enabled yes   # 开启cluster
cluster-node-timeout 15000  # 故障转移超时时间15s
cluster-config-file nodes-7000.conf   # 给cluster节点增加一个自己的配置文件
cluster-require-full-coverage yes  #只要集群中有一个故障了，整个就不对外提供服务了，这个实际不合理，假设有50个节点，一个节点故障了，所有不提供服务了；，需要设置成no


#第二步：快速复制6个配置问题，并修改配置
快速生成其他配置
sed 's/7000/7001/g' redis-7000.conf > redis-7001.conf
sed 's/7000/7002/g' redis-7000.conf > redis-7002.conf
sed 's/7000/7003/g' redis-7000.conf > redis-7003.conf
sed 's/7000/7004/g' redis-7000.conf > redis-7004.conf
sed 's/7000/7005/g' redis-7000.conf > redis-7005.conf


#第三步：启动6个redis服务
./src/redis-server ./redis-7000.conf
./src/redis-server ./redis-7001.conf
./src/redis-server ./redis-7002.conf
./src/redis-server ./redis-7003.conf
./src/redis-server ./redis-7004.conf
./src/redis-server ./redis-7005.conf
ps -ef |grep redis

# 第四步：  启动所有的redis服务
./src/redis-cli --cluster create --cluster-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
                        
                        
# 第五步：
redis-cli -p 7000 cluster info  
redis-cli -p 7000 cluster nodes  # 查看服务nodes
redis-cli -p 7000 cluster slots # 查看槽的信息


# 第六步：测试，存数据
./src/redis-cli -p 7000 -c

集群扩容

#1 准备两台机器
sed 's/7000/7006/g' redis-7000.conf > redis-7006.conf
sed 's/7000/7007/g' redis-7000.conf > redis-7007.conf
#2 启动两台机器
./src/redis-server ./redis-7006.conf
./src/redis-server ./redis-7007.conf

# 3 两台机器加入到集群中去
./src/redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000
./src/redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7000
        
# 4 让7007复制7006
./src/redis-cli -p 7007 cluster replicate baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a
        
# 5 迁移槽
./src/redis-cli --cluster reshard 127.0.0.1:7000 
    -迁移4096个槽
    -7006的机器接收槽
    -all
    
    
 # 注意：期间再执行上述操作，可能会报redis7006文件不为空，那是redis数据生成了持久化文件RDB，需要删除之前生成的文件。

集群缩容

# 第一步：下线迁槽（把7006的1366个槽迁移到7000上）
redis-cli --cluster reshard --cluster-from baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a --cluster-to 050bfd3608514d4db5d2ce5411ef5989bbe50867 --cluster-slots 1365 127.0.0.1:7000
yes

redis-cli --cluster reshard --cluster-from baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a --cluster-to 9cb2a9b8c2e7b63347a9787896803c0954e65b40 --cluster-slots 1366 127.0.0.1:7001
yes

redis-cli --cluster reshard --cluster-from baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a --cluster-to d3aea3d0b4cf90f58252cf3bcd89530943f52d36 --cluster-slots 1366 127.0.0.1:7002
yes


#第二步：下线节点 忘记节点，关闭节点
./src/redis-cli --cluster del-node 127.0.0.1:7000 9c2abbfaa4d1fb94b74df04ce2b481512e6edbf3 # 先下从，再下主，因为先下主会触发故障转移
./src/redis-cli --cluster del-node 127.0.0.1:7000 baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a

# 第三步：关掉其中一个主，另一个从立马变成主顶上， 重启停止的主，发现变成了从

posted @ 2023-04-17 21:00 魔女宅急便阅读(48) 评论(0) 收藏举报

刷新页面返回顶部

kimi

redis高阶

redis高阶

redis介绍

redis linux下安装

redis启动方式

redis 典型场景

redis通用命令

数据结构和内部编码

redis字符串类型

哈希类型

列表

集合类型set

有序集合（zset)

慢查询

pipeline与事务

发布订阅

Bitmap位图

HyperLogLog

持久化方案

1. RDB

2.AOF方案

3.混合持久化

主从复制原理和方案

哨兵高可用

集群原理及搭建

集群原理

集群搭建

集群扩容

集群缩容

公告