redis---高级

最新推荐文章于 2024-05-20 18:29:27 发布
最新推荐文章于 2024-05-20 18:29:27 发布
阅读量3k 收藏
点赞数 1
分类专栏： redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52385631/article/details/123881159
版权

1. redis发布订阅

1.1 发布订阅的命令


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同时在线。

2. 持久化

2.1 介绍

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

  • rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于rdb持久化功能

  • aof：以追加的方式记录redis操作日志的文件。可以最大程度的保证redis数据安全，类似于mysql的binlog

2.2 RDB持久化

2.2.1 介绍

  • redis提供了RDB持久化的功能，这个功能可以将redis在内存中的的状态保存到硬盘中，它可以手动执行。
  • 也可以再redis.conf中配置，定期执行。
  • RDB持久化产生的RDB文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis可以通过这个文件还原数据库当时的状态。

2.2.2 RDB配置

RDB(持久化)
内存数据保存到磁盘
在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）
优点：速度快，适合做备份，主从复制就是基于RDB持久化功能实现
rdb通过再redis中使用save命令触发 rdb
rab 配置

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

2.2.3 案例

1.启动redis服务端,准备配置文件,需要创建一个文件夹/data/6379 

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

2.启动redis服务端
3.登录redis设置一个key
redis-cli -a redhat
4.此时检查目录，/data/6379底下没有dbmp.rdb文件
5.通过save触发持久化，将数据写入RDB文件
127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> save
OK
5.测试kill redis 在重新以配置文件启动，发现数不会丢

2. 3 AOF

2.3.1 介绍

  • rdb有缺点，可能会造成数据丢失，但是持久化速度最快
  • AOF（append-only log file）
  • 记录服务器执行的所有变更操作命令（例如set del等），并在服务器启动时，通过重新执行这些命令来还原数据集
  • AOF 文件中的命令全部以redis协议的格式保存，新命令追加到文件末尾。
  • 优点：最大程序保证数据不丢
  • 缺点：日志记录非常大

2.3.2 配置

AOF持久化配置，两条参数
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379              #定义持久化文件存储位置
appendonly yes
appendfsync  always    总是修改类的操作(一般默认是它)
             everysec   每秒做一次持久化
             no     依赖于系统自带的缓存大小机制

2.3.3 案例

1.准备aof配置文件 redis.conf

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

2.启动redis服务
redis-server /etc/redis.conf

3.检查redis数据目录/data/6379/是否产生了aof文件
[root@web02 6379]# ls
appendonly.aof  dbmp.rdb  redis.log

4.登录redis-cli，写入数据，实时检查aof文件信息
[root@web02 6379]# tail -f appendonly.aof

5.设置新key，检查aof信息，然后关闭redis，检查数据是否持久化
redis-cli -a redhat shutdown
redis-server /etc/redis.conf
redis-cli -a redhat

3. RDB持久化切换AOF持久化

3.1 环境准备

确保redis版本在2.2以上
本文在redis4.0中，通过config set命令，达到不重启redis服务，从RDB持久化切换为AOF

3.2 实验环境准备

# 1.redis.conf服务端配置文件 
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename  dbmp.rdb
save 900 1                    #rdb机制 每900秒 有1个修改记录
save 300 10                    #每300秒        10个修改记录
save 60  10000                #每60秒内        10000修改记录
# 2.启动redis服务端
redis-server redis.conf
# 3.登录redis-cli插入数据，手动持久化
127.0.0.1:6379> set name chaoge
OK
127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> set addr shahe
OK
127.0.0.1:6379> save
OK
# 4.检查RDB文件
[root@pyyuc /data 22:34:16]#ls 6379/
dbmp.rdb  redis.log
# 5.备份这个rdb文件，保证数据安全
[root@pyyuc /data/6379 22:35:38]#cp dbmp.rdb /opt/
# 6.执行命令，开启AOF持久化
127.0.0.1:6379> CONFIG set appendonly yes   #开启AOF功能
OK
127.0.0.1:6379> CONFIG SET save ""  #关闭RDB功能
OK
# 7.确保数据库的key数量正确
127.0.0.1:6379> keys *
1) "addr"
2) "age"
3) "name"
# 8.确保插入新的key，AOF文件会记录
127.0.0.1:6379> set title golang
OK
# 9.此时RDB已经正确切换AOF，注意还得修改redis.conf添加AOF设置，不然重启后，通过config set的配置将丢失
appendonly yes
appendfsync  always    总是修改类的操作

4. 主从同步

4.2 案例

redis的主从同步功能
主从同步，读写分离的功能，redis.conf配置文件中定义的
1.redis支持多实例的功能，通过配置文件生效，多实例的概念Ⅰ写多个配置文件，指定文件启动，端口区分数据库，就是多实例了
2. 创建文件夹
存配置文件
mkdir /data/638{0..2}  #创建6380 6381 6382文件夹
存数据记录  dir /data/6380
mkdir /data/638{0..2}  
4.配置文件示例：
vim   /data/6380/redis.conf
# redis-6379.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

# redis-6380. conf 从库1
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 6380 # 指明主的地址

# redis-6381.conf  从库2
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
slaveof 127.0.0.1 6380 # 指明主的地址

# 5.启动redis
redis-server /data/6380/redis.conf
redis-server /data/6381/redis.conf
redis-server /data/6382/redis.conf
# 6.检查主从状态
从库：
127.0.0.1:6382> info replication
127.0.0.1:6381> info replication
主库：
127.0.0.1:6380> info replication

4.3 redis主从复制故障修复

#redis的主从复制故障修复(这个是临时生效，永久需要到配置文件中修改配置)
1.手动杀死主库
kill 主库pid
2.选择一个从库为新的主库，例如6380是主，6381是从 
127.o.o.1:6380>slaveof no one
oK
3.去登录6381从库
127.0.0.1:6381> slalveof 127.0.0.1 6380
OK

5. redis哨兵高可用

5.1 介绍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的监控目标会随之调换

Redis-sentinel工作机制：
每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令
如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线。
如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。
当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线
在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令
当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次
若没有足够数量的 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。

5.2 环境准备

redis高可用之哨兵功能1.配置redis-sentinel环境准备

三个redis实例，准备一主两从的架构

# 主节点master的redis-6379.conf

port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/var/redis/data/"
# 从节点slave的redis-6380.conf

port 6380
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/var/redis/data/" 
slaveof 127.0.0.1 6379      // 从属主节点

# 从节点slave的redis-6381.conf

port 6381
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/var/redis/data/" 
slaveof 127.0.0.1 6379      // 从属主节点


# 根据需求创建文件夹
mkdir /...
# 启动redis主节点
redis-server /etc/redis-6379.conf
# 启动两slave节点
# 6379为master，6380和6381为slave
redis-server /etc/redis-6380.conf
redis-server /etc/redis-6381.conf
# 验证从节点的redis服务
[root@master  ~]$redis-cli   -p 6380 ping
PONG
[root@master  ~]$redis-cli   -p 6381 ping
PONG
# 检测主从关系
在主节点上查看主从通信关系
redis-cli  -p 6379 info replication
在从节点上查看主从关系（6380、6379）
redis-cli  -p 6380 info replication


# 三个redis-sentinel配置文件,运行三个哨兵进程

# 配置redis sentinel环境
redis-sentinel-26379.conf配置文件写入如下信息
# 介绍
redis-sentinel-26379.conf redis-sentinel-26380.conf redis-sentinel-26381.conf 的配置仅仅差异是port(端口)的不同。

// Sentinel节点的端口
port 26379  
dir /var/redis/data/
logfile "26379.log"
// 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
// 2代表判断主节点失败至少需要2个Sentinel节点节点同意 
// mymaster是主节点的别名  名称以及ip根据需求修改，如果是一台机器IP(127.0.0.1) 2--至少2台哨兵同意
sentinel monitor mymaster 192.168.119.10 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

# 根据需求创建数据文件夹
# 然后启动三个sentinel哨兵
redis-sentinel /etc/redis-sentinel-26379.conf
redis-sentinel /etc/redis-sentinel-26380.conf
redis-sentinel /etc/redis-sentinel-26381.conf
# 此时查看哨兵是否成功通信
redis-cli -p 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.119.10:6379,slaves=2,sentinels=3
#看到最后一条信息正确即成功了哨兵，哨兵主节点名字叫做mymaster，状态ok，监控地址是192.168.119.10:6379，有两个从节点，3个哨兵

5.3 redis高可用故障实验

大致思路

杀掉主节点的redis进程6379端口，观察从节点是否会进行新的master选举，进行切换
重新恢复旧的“master”节点，查看此时的redis身份

首先查看三个redis的进程状态
ps -ef|grep redis

检查三个节点的复制身份状态
 redis-cli -p 6381 info replication
 redis-cli -p 6380 info replication
 redis-cli -p 6379 info replication
此时，干掉master！！！然后等待其他两个节点是否能自动被哨兵sentienl，切换为master节点
ps -ef|grep 6380   #干掉master进程
稍等片刻之后，发现slave节点成为master节点！！
redis-cli -p 6379 info replication

5.4 redis集群

步骤一、通过配置，redis.conf开启redis-cluster

  • redis支持多实例的功能，我们在单机演示集群搭建，需要6个实例，三个是主节点，三个是从节点，数量为6个节点才能保证高可用的集群。
  • 每个节点仅仅是端口运行的不同！
  • [root@yugo /opt/redis/config 17:12:30]#ls
redis-7000.conf  redis-7002.conf  redis-7004.conf
redis-7001.conf  redis-7003.conf  redis-7005.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　　#集群内部的配置文件
cluster-require-full-coverage no　　#redis cluster需要16384个slot都正常的时候才能对外提供服务，换句话说，只要任何一个slot异常那么整个cluster不对外提供服务。 因此生产环境一般为no

步骤二、运行redis实例

  • 创建6个节点的redis实例
1855  2018-10-24 15:46:01 redis-server redis-7000.conf
 1856  2018-10-24 15:46:13 redis-server redis-7001.conf
 1857  2018-10-24 15:46:16 redis-server redis-7002.conf
 1858  2018-10-24 15:46:18 redis-server redis-7003.conf
 1859  2018-10-24 15:46:20 redis-server redis-7004.conf
 1860  2018-10-24 15:46:23 redis-server redis-7005.conf



redis-server redis-7000.conf
redis-server redis-7001.conf
redis-server redis-7002.conf
redis-server redis-7003.conf
redis-server redis-7004.conf
redis-server redis-7005.conf

步骤3、开启redis-cluster

  1. 下载、编译、安装Ruby
  2. 安装rubygem redis
  3. 安装redis-trib.rb命令

第一步、安装ruby

#下载ruby源码包
wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
#解压缩ruby源码包
tar -zxvf ruby-2.3.1.tar.gz
#编译且安装
./configure --prefix=/opt/ruby/
make && make install

第二步、配置ruby环境变量

vim /etc/profile
写入如下配置
PATH=$PATH:/opt/ruby/bin

第三步、安装ruby操作redis包

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

第四部、安装redis-trib.rb命令

[root@yugo /opt/redis/src 18:38:13]#cp /opt/redis/src/redis-trib.rb /usr/local/bin/

一键开启redis-cluster集群

#每个主节点，有一个从节点，代表--replicas 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
#集群自动分配主从关系  7000、7001、7002为 7003、7004、7005 主动关系

查看集群状态

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

写入redis-cluster集群数据

安装完毕后，检查集群状态

[root@yugo /opt/redis/src 18:42:14]#redis-cli -p 7000 cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:10468
cluster_stats_messages_pong_sent:10558
cluster_stats_messages_sent:21026
cluster_stats_messages_ping_received:10553
cluster_stats_messages_pong_received:10468
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:21026

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

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> exit
[root@yugo /opt/redis/src 18:46:07]#redis-cli -c -p 7000
127.0.0.1:7000> ping
PONG
127.0.0.1:7000> keys *
(empty list or set)
127.0.0.1:7000> get name
-> Redirected to slot [5798] located at 127.0.0.1:7001
"chao"

redis-python api

1、对redis的单实例进行连接操作
python3
>>>import redis
>>>r = redis.StrictRedis(host='localhost', port=6379, db=0,password='root')
>>>r.set('lufei', 'guojialei')
True
>>>r.get('lufei')
'bar'
--------------------
2、sentinel集群连接并操作
[root@db01 ~]# redis-server /data/6380/redis.conf
[root@db01 ~]# redis-server /data/6381/redis.conf
[root@db01 ~]# redis-server /data/6382/redis.conf 
[root@db01 ~]# redis-sentinel /data/26380/sentinel.conf &
--------------------------------
## 导入redis sentinel包
>>> from redis.sentinel import Sentinel  
##指定sentinel的地址和端口号
>>> sentinel = Sentinel([('localhost', 26380)], socket_timeout=0.1)  
##测试，获取以下主库和从库的信息
>>> sentinel.discover_master('mymaster')  
>>> sentinel.discover_slaves('mymaster')  
##配置读写分离
#写节点
>>> master = sentinel.master_for('mymaster', socket_timeout=0.1)  
#读节点
>>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)  
###读写分离测试   key     
>>> master.set('oldboy', '123')  
>>> slave.get('oldboy')  
'123'
----------------------
redis cluster的连接并操作（python2.7.2以上版本才支持redis cluster，我们选择的是3.5）
https://github.com/Grokzen/redis-py-cluster
3、python连接rediscluster集群测试
使用
python3
>>> from rediscluster import StrictRedisCluster  
>>> startup_nodes = [{"host": "127.0.0.1", "port": "7000"}]  
### Note: decode_responses must be set to True when used with python3  
>>> rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)  
>>> rc.set("foo", "bar")  
True  
>>>   
'bar'

骑猪去兜风z1
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
redis主从安装部署
percy_px的博客
06-23 998
redis主从部署 一、单机步骤（所以操作都在root下，如果需要根据自己设置权限）： 1、准备安装包：redis-3.0.7.tar.gz 2、在根目录创建soft文件夹        [root@localhost/]# mkdir soft 3、将安装包上传到soft目录下，并进行解压        [root@localhost soft]# tar -xvzf redis-3
Redis --- 高级篇
shuai_h的博客
01-09 1268
Redis分布式缓存
redis-cli使用说明
ppjsyw的博客
05-20 5920
介绍 redis-cli是Redis命令行界面,一个简单的程序，允许向 Redis 发送命令，然后从服务端读取发送的回复。 Redis对命令的大小写不区分,比如ping、Ping是同一个命令。 Redis对key名的大小写区分。 两种模式 交互模式:在redis-cli里面使用 另一种模式:在命令前面带上redis-cli的方式 基本使用 1、连接到Redis -h 用于指定 ip -p 用于指定端口 -a 用于指定认证密码 D:\work\redis>redis-cli -p 6379
redis-高级篇
kk_lina的博客
07-31 678
redis.conf配置详解，rdb和aof持久化操作，redis发布和订阅，redis的集群部署，redis集群，redis缓存穿透、缓存击穿、缓存雪崩
SpringBoot 高级 原理分析 -- 自定义redis-starter
天行健 君子以自强不息，地势坤 君子以厚德载物。
11-17 1884
1. 自定义redis-starter 需求： 自定义redis-starter。要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean。 1.1 参考mybatis-spring-boot-starter 引入mybatis-spring-boot-starter pom.xml <!--引入mybatis-stater--> <dependency> <groupId>org.mybatis.sp
Redis高级之——redis-trib.rb命令详解
weixin_45417821的博客
07-30 3104
redis-trib.rb命令详解 redis-trib.rb是官方提供的Redis Cluster的管理工具，无需额外下载，默认位于源码包的src目录下，但因该工具是用ruby开发的，所以需要准备相关的依赖环境。 准备redis-trib.rb的运行环境 安装ruby 步骤如下 wget https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.1.tar.gz yum -y install zlib-devel tar xvf ruby-2.5.1.tar.gz
Redis-Stack技术开源项目
cs880810的专栏
05-29 390
支持Redis多模块扩展,适应更多开发场景:像高性能搜索、高性能图查询、时序数据库、布隆过滤器等，它将多个领先的Redis模块集成为单个产品， 使得用户可以更轻松地利用基于 Redis 构建的搜索、文档存储、图数据和时间序列模型等,为redis开源生态和应用场景提供无限可能!
Linux下安装及配置redis-5.0.3详细步骤
qq_36803154的博客
03-17 727
告诉sentinel去监听地址为ip:port的一个master，这里的master-name可以自定义，quorum是一个数字，指明当有多少个sentinel认为一个master失效时，master才算真正失效。#当slave与master之间的连接断开或slave正在与master进行数据同步时，如果有slave请求，当设置为yes时，slave仍然响应请求，此时可能有问题，如果设置no时，slave会返回"SYNC with master in progress"错误信息。单位是毫秒，默认为30秒。
Redis-benchmark性能测试工具使用详解
祝我飞黄腾达
04-21 7071
一、说明 Redis客户端源码包含一个名为redis-benchmark的性能测试工具，它可以模拟N个客户端同时向Redis发送M条查询命令的应用场景。 下载并安装了redis的安装目录就默认有： 二、如何使用 准备工作：首先依次使用如下命令，分别开启redis服务，和连接客户端（可不连接，主要是确认服务是否能够被连接） -- 1. 开启服务 redis-server /usr/local/etc/redis.conf -- 2. 客户端连接服务 redis-cli -p 6379 .
bitnami-docker-redis-cluster
03-21
Redis（TM）是高级键值缓存和存储。它通常被称为数据结构服务器，因为键可以包含字符串，哈希，列表，集合，排序集合，位图和超级日志。 TL; DR $ docker run --name redis-cluster -e ALLOW_EMPTY_PASSWORD=yes ...
redis-rs — Rust中的Redis库-Rust开发
05-27
Redis-rs是Rust的高级Redis库。 它通过非常灵活但低级别的redis-rs提供了对所有Redis功能的便捷访问Redis-rs是Rust的高级redis库。 它通过非常灵活但底层的API，提供对所有Redis功能的便捷访问。 它使用可自定义的...
node-redis-connection-pool:Redis的node.js连接管理器
05-11
关于node-redis-connection-pool是高级Redis管理对象。 它管理池中的多个连接，根据需要使用它们，并将释放活动连接的所有方面保持在对象内部，因此用户无需担心忘记的连接会浪费资源。安装npm install redis - ...
Redis-高级篇资料
09-13
Redis-高级篇资料
redis-replicator:Redis复制工具。 支持同步，psync，psync2。 可以解析rdb，aof，混合的rdb和aof文件。 支持redis-6.2
05-02
4.高级主题 4.1。 命令扩展 4.1.1。 编写命令 4.1.2。 编写命令解析器 4.1.3。 注册此解析器 4.1.4。 处理命令事件 4.1.5。 放在一起 4.2。 模块扩展 4.2.1。 编译redis测试模块 4.2.2。 在redis.conf中打开评论 ...
分布式系统(一)-Redis
0x12的专栏
05-17 345
Redis作为当前主流的缓存组件，合理的运用将极大提高系统的性能。
golang session实现库 支持cookie, redis,mysql等多种存储方式
最新发布
05-20 355
GitHub - tekintian/go-sessions: go语言里面的Sessions实现库， 支持众多的Session存储方式，cookie, redis, mysql等。golang中官方是不支持session的， 如果想要实现session则需要自己动手来实现，或者使用第三方的go-session实现库， 今天就给大家介绍一个go语言的第三方session实现库 go-sessions，支持 的存储方式有 cookie, file, redis, mysql等众多的存储。
windows设置Redis服务后台自启动
m0_73774439的博客
05-15 649
windows设置Redis服务后台自启动
安装docker版redis并挂载配置文件redis.conf
小杰玩编程
05-17 215
默认情况下，启动docker redis容器没有redis.conf配置文件。因此这里用docker compose来启动容器，下面以redis5.0为例。
redis-enterprise
10-14
Redis Enterprise是Redis Labs公司提供的一种高级Redis解决方案，它提供了高可用性、线性扩展性、多租户支持、闪存优化和安全性等功能。Redis Enterprise还提供了一个Web管理界面，使得管理和监控Redis集群变得更加...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

骑猪去兜风z1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值