1.Redis基础 | Evergreen Notes
返回首页 1.Redis基础 1.Redis简介 简介 Redis 典型应用场景 https://www.redis.io 官网 https://github.com/redis/redis github https://redis.io/docs/about 文档 2.缓存简介 缓存分类 缓存的保存位置 缓存的特点 3.缓存简
1.Redis简介
简介
Redis(Remote Dictionary Server、远程字典服务)在2009年发布，开发者 萨尔瓦多·桑菲利波(Salvatore Sanfilippo)是意大利开发者，他本想为自 己的公司开发一个用于替换MySQL的产品Redis，但是没有想到他把Redis开源后大受欢迎，短短几年，Redis就有了很大的用户群体，目前国内外 使用的公司有知乎网、新浪微博、GitHub等 redis是一个开源的、遵循BSD协议的、基于内存的而且目前比较流行的键值数据库(key-value database)，是一个非关系型数据库，redis提供将内 存通过网络远程共享的一种服务，提供类似功能的还有memcache，但相比memcache，redis还提供了易扩展、高性能、具备数据持久性等功能。 Redis在高并发、低延迟环境要求比较高的环境使用量非常广泛，目前redis在DB-Engine月排行榜<https://db-engines.com/en/ranking> 中一 直比较靠前，而且一直是键值型存储类的首位 Redis 典型应用场景
Session 共享：常见于web集群中的Tomcat或者PHP中多web服务器session共享 消息队列：ELK的日志缓存、部分业务的订阅发布系统 计数器：访问排行榜、商品浏览数等和次数相关的数值统计场景 缓存：数据库查询缓存、电商网站商品信息、新闻内容 微博/微信社交场合：共同好友、点赞评论等 https://www.redis.io #官网
https://github.com/redis/redis #github
https://redis.io/docs/about #文档
2.缓存简介
缓存分类
本地缓存：将数据保存到本地，如浏览器、nginx等服务都有缓存，但无法多节点共享。 远程缓存：使用其它服务器的提供的服务作为缓存，多节点可以共享同一份缓存数据 缓存的保存位置
内存 硬盘 数据 缓存的特点
1.缓存的目的是为了调节速度不一致的两个或多个不同的服务的速度，在中间对速度较快的一方起到一个加速访问速度较慢的一方的作用。 2.缓存不会一直有效，有过期时间(设置过期时间、删除缓存、或强制更新(如CDN强制更新缓存))。 3.缓存命中率：命中率越高，表明缓存的使用率越高，计算方式为 返回数据成功次数/请求次数，如总请求100次，返回成功85次，则850/1000=85%。 4.缓存最大空间：如Redis会设置总内存使用空间，超出将触发强制内存空间回收(删除部分历史数据)。 3.缓存简介及使用场景
基于Redis的缓存业务架构
基于Redis的日志收集系统
4.Redis发行版历史及版本功能差异
5.Redis安装
5.1.centos安装Redis
5.2.ubuntu安装Redis
5.3.编译安装
提示： WARNING Memory overcommit must be enabled!
基于redis.service启动redis
root@ubuntu:/usr/local/src/redis-7.2.0/utils# pwd /usr/local/src/redis-7.2.0/utils root@ubuntu:/usr/local/src/redis-7.2.0/utils# cp ./systemd-redis_server.service 5.4.连接redis
本地命令行连接
远程命令行连接
图形化工具连接
https://github.com/qishibo/AnotherRedisDesktopManager/blob/master/README.zh-CN.md #下载地址
测试能否正常写入数据
python脚本
5.5.Redis常用命令
5.6.Redis性能压测
压测方式
redis-benchmark： Redis自带的压测工具，会对redis server进行常规的数据读写测试
inline 和 multibulk 是 Reids 定义的数据解析协
inline 旧版本的数据访问协议，现在主要用在像 redis-cli 这种做简单的调试
multibulk 新版本协议，目前被程序客户端普遍使用，它支持让空格和回车在 Redis 里面正确表达出来。
redis-benchmark 压测案例
6.Redis的常见数据类型的使用
6.1字符串(string)
字符串是使用最广泛的数据类型，字符串数据使用二进制保存，比如图片、视频等，默认一个字符串的value最大512M，可在redis.conf修改proto-max-bulk-len
示例
6.2列表(list)
列表是一个双向可读写的管道，其头部是左侧尾部是右侧，一个列表最多可以包含2^32-1个元素即4294967295个元素。
提示：一般我们都是约定从右侧消费，俗称FIFO（先进先出），先进的数据先被右侧消费
示例
6.3集合(set)
Set 是 String 类型的无序集合，集合中的成员是唯一的，这就意味着集合中不能出现重复的数据，可以在两个不同的集合中对数据进行对比并取值
示例
6.4.有序集合（orted set）
Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员，不同的是每个元素都会关联一个double(双精度浮点型)类型的分数，redis正是通过该分数来为集合中的成员进行从小到大的排序，有序集合的成员是唯一的,但分数(score)却可以重复，集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)， 集合中最大的成员数为 2^32 - 1 (4294967295, 每个集合可存储40多亿个成员)
示例
6.5.哈希表(hash)
hash是一个键值对(key=>value)的集合，一个hash数据里面可以包含多个key-value的数据，Redis中每个 hash 可以存储2^32 - 1 键值对（40多亿）
提示：As per Redis 4.0.0, HMSET is considered deprecated. Please use HSET in new code.
根据Redis 4.0.0，HMSET被视为已弃用。请在新代码中使用HSET。
在这之前HSET只能设置单个键值对，同时设置多个时必须使用HMSET。而现在HSET也允许接受多个键值对作参数了。
示例
6.6.生产者消费者模型示例、发布者订阅模式示例
生产者消费者模型示例
消息队列主要分为两种，分别是生产者消费者模式和发布者订阅者模式，这两种模式Redis都支持
在生产者消费者(Producer/Consumer)模式下，上层应用接收到的外部请求后开始处理其当前步骤的操作，在执行完成后将已经完成的操作发送至 指定的频道(channel)当中，并由其下层的应用监听该频道并继续下一步的操作，如果其处理完成后没有下一步的操作就直接返回数据给外部请求， 如果还有下一步的操作就再将任务发布到另外一个频道，由另外一个消费者继续监听和处理。
生产者消费者模式下，多个消费者同时监听一个队里，但是一个消息只能被最先抢到消息的消费者消费，即消息任务是一次性读取和处理，此模式 在分布式业务架构中非常常用，比较常用的软件还有RabbitMQ、Kafka、RocketMQ、ActiveMQ等。
队列介绍
队列当中的 消息由不同的生产者写入也会有不同的消费者取出进行消费处理，但是一个消息一定是只能被取出一次也就是被消费 一次。
生产者发布消息
发布者订阅模型示例
在发布者订阅者模式下，发布者将消息发布到指定的channel里面，凡是监听该channel的消费者都会收到同样的一份消息，这种模式类似于是收音机的广播模 式，即凡是收听某个频道的听众都会收到主持人发布的相同的消息内容。
此模式常用语群聊天、群通知、群公告等场景。
Subscriber：订阅者
Publisher：发布者
Channel：频道
7.redis.conf的基本配置
cat /apps/redis/etc/redis.conf 8.Redis的RDB快照及AOF机制
8.1.redis数据持久化简介
Redis虽然是一个内存级别的缓存程序，也就是redis是使用内存进行数据的缓存的，但是其可以将内存的数据按照一 定的策略保存到硬盘上，从而实现数据持久保存的目的，目前redis支持三种不同方式的数据持久化保存机制，分别是RDB和AOF，以及（RDB+AOF）混合制持久化
8.2.RDB模式
1.RDB(*Redis* DataBase)：基于时间的快照，其默认只保留当前最新的一次快照，特点是执行速度比较快，缺点是可能会丢失从 上次快照到当前时间点之间未做快照的数据。 2.RDB实现的具体过程Redis从主进程先fork出一个子进程，使用写时复制机制，子进程将内存的数据保存为一个临时文件，比如 dump.rdb.temp，当数据保存完成之后再将上一次保存的RDB文件替换掉，然后关闭子进程，这样可以保证每一次做RDB快照的 时候保存的数据都是完整的，因为直接替换RDB文件的时候可能会出现突然断电等问题而导致RDB文件还没有保存完整就突然关 机停止保存而导致数据丢失的情况，可以手动将每次生成的RDB文件进程备份，这样可以最大化保存历史数据 RDB的优缺点
优点
RDB快照保存了某个时间点的数据，可以通过脚本执行bgsave(非阻塞)或者save(阻塞)命令自定义时间点备份，可以保留多个备份，当出现问题可以恢复到不同时间点的版本。
可以最大化IO 的性能，因为父进程在保存RDB 文件的时候唯一要做的是fork出一个子进程，然后的-操作都会有这个子进程操作，父进程无需任何的IO操作
RDB在大量数据比如几个G的数据，恢复的速度比AOF的快
缺点
不能时时的保存数据，会丢失自上一次执行RDB备份到当前的内存数据
数据量非常大的时候，从父进程fork的时候需要一点时间，可能是毫秒或者秒或者分钟，取决于磁盘IO性能
基于RDB实现redis单机数据迁移
补充：
当AB主机的redis版本不一致，即rdb版本不一致的时候会报错
2754462:M 07 Sep 16:08:00.458 # Can't handle RDB format version 11
2754462:M 07 Sep 16:08:00.458 # Fatal error loading the DB: Invalid argument. Exiting.
8.3.AOF模式
AOF模式的简介
1.AOF：按照操作顺序依次将操作添加到指定的日志文件当中，特点是数据安全性相对较高，缺点是即使有些操作是重复的也会全部记录。 2.AOF和RDB一样使用了写时复制机制，AOF默认为每秒钟fsync一次，即将执行的命令保存到AOF文件当中，这样即使redis服务器发生故障的话顶多也就丢失1秒钟之内的数据，也可以设置不同的fsync策略，或者设置每次执行命令的时候执行fsync，fsync会在后台执行线程，所以主线程可以继续处理用户的正常请求而不受到写入AOF文件的IO影响。 AOF的优缺点
AOF的文件大小要大于RDB格式的文件
根据所使用的fsync策略(fsync是同步内存中redis所有已经修改的文件到存储设备)，默认是appendfsync everysec即每秒执 行一次fsync
8.4.混合模式（RDB+AOF）(推荐使用)
Redis 4.0支持AOF+RDB混合模式，配置文件开启 aof‐use‐rdb‐preamble yes
混合模式的执行过程
RDB-AOF混合持久化体现在aofrewrite时，先以RDB格式来保存全量数据，即Redis 会先把当前的内存数据以RDB方式写入到 AOF文件，同时把当前的命令记录到重写缓冲区中，最后RDB完成后再把缓冲区中的命令以追加AOF的形式存在AOF文件中。
混合模式的优缺点
优点：集成了AOF与RDB的优点
缺点：文件可读性不直观
使用示例
9.Redis ACL的基本使用
9.1.ACL的简介
ACL(Access Control List)即访问控制列表
Redis从6.0版本开始支持的访问权限控制 方式 通过ACL,可以控制客户端对不同redis命令和数据的访问权限
基于ACL的访问控制可以保证redis中的数据更加安全可靠
相比简单的密码认证,它提供了更丰富灵活的权限管理功能
9.2.ACL的命令
9.3.ACL规则
启用和禁用用户
on：启用用户
off：禁用用户，已经创建好的TCP链接不会强制中断
允许或禁止访问某些Key
：基于正则表达式匹配可以访问的key，例如和 allkeys 允许访问所有，mykey和Mykey是两个( key的名字区分大小写)。resetkeys：基于resetkeys指定只能访问的key，如： ~foo:* ~bar:* resetkeys ~objects:，则客户端只能访问匹配 object: 模式的 KEY。
允许和禁止调用命令
ACL示例
示例一:默认ACL
示例二:通过ACL为user qbn 设置任意权限
示例三:通过ACL为user zhangsan设置指定命令权限
9.4.做ACL权限持久化
上面通过命令设置的权限，重启redis会失效，所以需要写到配置文件使其永久生效
通过redis.conf定义ACL规则
通过外部文件定义ACL规则
补充：所以这个时候远程是访问不了的，因为触发了redis安全模式，要么关闭安全模式要么设置密码
10.基于redis-dump实现redis单机数据的迁移
redis-dump可以实现redis跨版本数据迁移
安装redis-dump
导数据
验证数据
测试基于redis-shake实现redis数据迁移**
https://blog.51cto.com/u_13626676/6041309 #redis-shak使用说明
https://github.com/tair-opensource/RedisShake #redis-shake项目地址
版本要求
go version > =go1.17 ubuntu 下载GO
root@ubuntu20:~# wget -c https://go.dev/dl/go1.20.linux-amd64.tar.gz 验证go版本
root@ubuntu20:~# go version go version go1.20 linux/amd64 安装redis-shake
编写toml文件
其他高级写法参考：https://tair-opensource.github.io/RedisShake/zh/guide/config.html
root@ubuntu20:~/RedisShake/bin# pwd /root/RedisShake/bin 启动 redis-shake
root@ubuntu20:~/RedisShake/bin# ./redis-shake rdb_20230907.toml
提示：
此时可以看到有数据一直在持续同步，开两个终端测试，可以看到一有数据写入，立马会进行同步。可以用ctrl+c暂停同步。
验证数据
5.数据删除策略：基于某种算法，删除历史数据、从而释放内存空间
[root@centos7 ~]# vi /etc/yum.repos.d/redis.repo [Redis] name = Redis baseurl = http://packages.redis.io/rpm/rhel7 enabled = 1 gpgcheck = 1 [root@centos7 ~]# curl -fsSL https://packages.redis.io/gpg > /tmp/redis.key #下载key文件 [root@centos7 ~]# sudo rpm --import /tmp/redis.key #导入key [root@centos7 ~]# sudo yum install epel-release [root@centos7 ~]# yum list redis-stack-server --showduplicates | sort -r #Redis Stack 是 Redis 的扩展，它添加了现代数据模型和处理引擎，以提供完整 的开发人员体验 [root@centos7 ~]# yum install redis-stack-server-7.2.0_v0-1.rhel7 -y #安装指定版本，不加的话默认最新版本 [root@centos7 ~]# systemctl restart redis-stack-server.service
root@ubuntu22-04-2:~# curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg root@ubuntu22-04-2:~# sudo chmod 644 /usr/share/keyrings/redis-archive-keyring.gpg root@ubuntu22-04-2:~#echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $( lsb_release -cs ) main" | sudo tee /etc/apt/sources.list.d/redis.list root@ubuntu22-04-2:~# sudo apt-get update root@ubuntu22-04-2:~# apt-cache madison redis-server root@ubuntu22-04-2:~# apt-cache madison redis-stack-server root@ubuntu22-04-2:~# apt install redis-server
root@ubuntu:~# apt update root@ubuntu:~# apt install iproute2 ntpdate tree libssl-dev gcc openssh-server lrzsz \ openssl libssl-dev libpcre3 libpcre3-dev zlib1g-dev ntpdate tcpdump telnet \ traceroute iotop unzip zip make libsystemd-dev pkg-config root@ubuntu:~# cd /usr/local/src/ root@ubuntu:/usr/local/src# wget http://download.redis.io/releases/redis-7.2.0.tar.gz root@ubuntu:/usr/local/src# tar xvf redis-7.2.0.tar.gz root@ubuntu:/usr/local/src# cd redis-7.2.0/
make test root@ubuntu:/usr/local/src/redis-7.2.0# make USE_SYSTEMD=yes PREFIX=/apps/redis install root@ubuntu:/usr/local/src/redis-7.2.0# ll /apps/redis/bin/ ----修改内核参数---- root@ubuntu:/usr/local/src/redis-7.2.0# echo "vm.overcommit_memory = 1" >> /etc/sysctl.conf root@ubuntu:/usr/local/src/redis-7.2.0# sysctl -p vm.overcommit_memory = 1 ----重启机器，确保机器重启之后内核参数依旧有效---- root@ubuntu:~# reboot root@ubuntu:~# redis-server /apps/redis/etc/redis.conf 1094:C 05 Sep 2023 09:34:17.000 * oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo 1094:C 05 Sep 2023 09:34:17.000 * Redis version=7.2.0, bits=64, commit=00000000, modified=0, pid=1094, just started 1094:C 05 Sep 2023 09:34:17.000 * Configuration loaded 1094:M 05 Sep 2023 09:34:17.001 * Increased maximum number of open files to 10032 (it was originally set to 1024). 1094:M 05 Sep 2023 09:34:17.001 * monotonic clock: POSIX clock_gettime _._ _.-``__ ''-._ _.-`` `. `_. ''-._ Redis 7.2.0 (00000000/0) 64 bit .-`` .-```. ```\/ _.,_ ''-._ ( ' , .-` | `, ) Running in standalone mode |`-._`-...-` __...-.``-._|'` _.-'| Port: 6379 | `-._ `._ / _.-' | PID: 1094 `-._ `-._ `-./ _.-' _.-' |`-._`-._ `-.__.-' _.-'_.-'| | `-._`-._ _.-'_.-' | https://redis.io `-._ `-._`-.__.-'_.-' _.-' |`-._`-._ `-.__.-' _.-'_.-'| | `-._`-._ _.-'_.-' | `-._ `-._`-.__.-'_.-' _.-' `-._ `-.__.-' _.-' `-._ _.-' `-.__.-'
1094:M 05 Sep 2023 09:34:17.006 * Server initialized 1094:M 05 Sep 2023 09:34:17.007 * Ready to accept connections tcp
/usr/lib/systemd/system/redis.service
----编写service文件---- root@ubuntu20:/usr/local/src/redis-7.2.0/utils# vi /usr/lib/systemd/system/redis.service [Unit] Description=Redis data structure server Documentation=https://redis.io/documentation Wants=network-online.target After=network-online.target [Service] ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis.conf --supervised systemd --daemonize no LimitNOFILE=10032 NoNewPrivileges=yes Type=notify TimeoutStartSec=infinity TimeoutStopSec=infinity UMask=0077 User=redis #配置了普通用户，所以需要把对应的目录权限改成普通用户权限 Group=redis #配置了普通用户组 WorkingDirectory=/apps/redis [Install] WantedBy=multi-user.target
root@ubuntu:/usr/local/src/redis-7.2.0/utils# groupadd -g 2023 redis && useradd -u 2023 -g 2023 redis -s /sbin/nologin root@ubuntu:/usr/local/src/redis-7.2.0/utils# chown redis.redis -R /apps/redis/ root@ubuntu:/usr/local/src/redis-7.2.0/utils# systemctl daemon-reload root@ubuntu:/usr/local/src/redis-7.2.0/utils# systemctl daemon-reload && systemctl enable redis.service && systemctl restart redis.service
root@ubuntu:~# redis-cli --help redis-cli -h HOSTNAME/IP -p PORT -a PASSWORD --user USER root@ubuntu:~# /apps/redis/bin/redis-cli 127.0.0.1:6379 > info # Server redis_version:7.2.0 redis_git_sha1:00000000 redis_git_dirty:0 redis_build_id:af067dcb17a8e211 redis_mode:standalone os:Linux 5.4.0-159-generic x86_64 ....
root@ubuntu:~# vi /apps/redis/etc/redis.conf .... bind 0.0.0.0 #设置监听地址地址，可以用空格隔开设置多个监听IP .... requirepass 123123 #设置连接的密码 .... root@ubuntu:~# systemctl restart redis root@ubuntu:~# redis-cli -h 192.168.20.247 192.168.20.247:6379 > auth 123123 OK 192.168.20.247:6379 >
192.168.20.247:6379 > select 0 OK 192.168.20.247:6379 > keys * 1 ) "name" 192.168.20.247:6379 > get name "luningbo" 192.168.20.247:6379 > 提示：DB在逻辑上隔离不同项目的数据，比如上面的db0的key “name”，只能存在一个，如果在db1则可以重复
cat redis-client.sh #!/bin/bash NUM = ` seq 1 100000 ` for i in ${ NUM }; do redis-cli -h 127.0.0.1 set key- ${ i } value- ${ i } echo "key-${ i } value-${ i } 写入完成" done echo "十万个key写入到Redis完成
apt install python3-pip
cat redis-client.py #!/bin/env python import redis import time pool = redis.ConnectionPool ( host = "127.0.0.1", port = 6379, password = "" ) r = redis.Redis ( connection_pool = pool ) for i in range ( 100 ) : r.set( "key%d" % i,"value%d" % i ) #time.sleep(0.1) data = r.get ( "key%d" % i ) data = data.decode ( "utf-8" ) print ( data )
CONFIG：config 命令用于查看当前redis配置、以及不重启更改redis配置等 127.0.0.1:6379 > CONFIG set maxmemory 8589934592 OK 127.0.0.1:6379 > CONFIG get maxmemory #查看某个配置项 maxmemory 8589934592 127.0.0.1:6379 > CONFIG GET * #获取当前所有配置 repl-diskless-sync-max-replicas 0 127.0.0.1:6379 > CONFIG SET requirepass 123456 O INFO：显示当前节点redis运行状态信息 DEL： 删除指定的key SELECT：切换数据库，等于MySQL的use DBNAME指令 keys:：查看当前库下的所有key： BGSAVE:手动在后台执行RDB持久化操作 DBSIZE: 返回当前库下的所有key 数量 FLUSHDB：强制清空当前库中的所有key FLUSHALL：强制清空当前redis服务器所有数据库中的所有key，即删除所有数据
redis-benchmark --help redis-benchmark [option] [option value -h 指定Redis 地址 -p 指定Redis 端口 -s 使用 socket文件连接 -c 指定并发连接数 -n 指定请求总数 -d 以字节的形式指定 SET/GET 值的数据大小 -k 是否开启会话保持，1 表示 keepalive；0 表示 reconnect，默认为 1。 -r SET/GET/INCR 使用随机 key, SADD使用随机值,ZADD使用随机值和评分 -P 是否使用Pipeline 请求 -q 静默模式，仅显示测试结果的 query/sec 值 --csv 将测试结果转换为 CSV 格式输出 -l(小写L) 生成循环，永久执行测试。 -t 运行以逗号分隔的单次多测试命令列表 -I(大写i) 空闲模式，打开 N 个空闲连接并等待连
# redis-benchmark -h 127.0.0.1 -p 6379 -n -a 123123 1000 -c 200 #并发200，累计1000个请求，加-q仅显示测试结果的 query/sec 值 Summary: #测试结果摘要 throughput summary: 90909.09 requests per second #吞吐量统计，每秒完成客户端请求数90909.09 latency summary (msec): #延迟统计(毫秒) avg min p50 p95 p99 max 1.236 0.376 1.007 2.431 2.591 2.63 # redis-benchmark -t set -n 1000 -c 100 #压测单个命令，累计1000个请求并发100 # redis-benchmark -t ping,set,get -n 100 --csv #压测多个命令，并以csv格式输出 # redis-benchmark -h 127.0.0.1 -p 6379 -n 1000 -c 200 -q #默认压测，并仅显示测试结果的 query/sec 值 # redis-benchmark -h 127.0.0.1 -p 6379 -t set -d 1024 -n 1000 -r 1000 -c 200 #指定每个key的大小为1024字节(1k) # redis-benchmark -r 100 -n 10000 lpush mylist __rand_int__ #测试向指定列表mylist 写入总数(-n 10000)个随机数据，每个数据随机在(-r 100 )以内选择
127.0.0.1:6379 > set key abc #添加一个key OK 127.0.0.1:6379 > get key #获取key的内容 "abc" 127.0.0.1:6379 > type key #查看key的类型 string 127.0.0.1:6379 > set name1 lnb ex 100 #设置key自动过期时间 OK 127.0.0.1:6379 > get name1 "lnb" 127.0.0.1:6379 > ttl name1 #查看key的剩余过期时间 ( integer ) 77 127.0.0.1:6379 > keys * #查看所有key 1 ) "zhangsan-key" 2 ) "name1" 3 ) "key" 4 ) "xxx" 127.0.0.1:6379 > del xxx #删除一个key ( integer ) 1 127.0.0.1:6379 > mset key-1 111 key-2 222 #批量创建多个key OK 127.0.0.1:6379 > mget key-1 key-2 #批量获取多个key 1 ) "111" 2 ) "222" 127.0.0.1:6379 > del key-1 key-2 #删除多个key ( integer ) 2 127.0.0.1:6379 > append key lnb #向key追加数据 ( integer ) 6 127.0.0.1:6379 > get key #查看key内容验证 "lnbqbn" 127.0.0.1:6379 > strlen key #返回value的长度 ( integer ) 6 127.0.0.1:6379 > exists key #判断key是否存在 ( integer ) 1 127.0.0.1:6379 > set num 10 #数值递增 OK 127.0.0.1:6379 > incr num ( integer ) 11 127.0.0.1:6379 > incr num ( integer ) 12 127.0.0.1:6379 > incr num ( integer ) 13 127.0.0.1:6379 > get num "13" 127.0.0.1:6379 > get num #数值递减 "13" 127.0.0.1:6379 > decr num ( integer ) 12 127.0.0.1:6379 > decr num ( integer ) 11 127.0.0.1:6379 > get num "11" 127.0.0.1:6379 > persist key #设置key永不过期 ( integer ) 1 127.0.0.1:6379 > TTL key ( integer ) -1 ttl #查看key的剩余生存时间 -1 #负一为永不过期，默认创建的key是永不过期，重新对key赋值，也会从有剩余生命周期变成永不过期 -2 #为没有此key num #key的剩余有效期 127.0.0.1:6379 > expire key 5555 #设置key到期时间，不修改值 ( integer ) 1 127.0.0.1:6379 > ttl key ( integer ) 5553 127.0.0.1:6379 > ttl key ( integer ) 5552
127.0.0.1:6379 > LPUSH list aaa bbb ccc #根据顺序逐个写入list，从左到右写 ( integer ) 3 127.0.0.1:6379 > TYPE list #获取列表类型 list 127.0.0.1:6379 > LPUSH list ddd #从列表左侧推入一个值 ( integer ) 4 127.0.0.1:6379 > LLEN list #获取列表长度 ( integer ) 4 127.0.0.1:6379 > RPOP list #右侧消费 "aaa" 127.0.0.1:6379 > RPOP list "bbb" 127.0.0.1:6379 > RPOP list "ccc" 127.0.0.1:6379 > RPOP list "ddd" 127.0.0.1:6379 > RPOP list ( nil ) 127.0.0.1:6379 > LPUSH list aaa bbb ccc ( integer ) 3 127.0.0.1:6379 > LPOP list #左侧消费 "ccc" 127.0.0.1:6379 > LPOP list "bbb" 127.0.0.1:6379 > LPOP list "aaa" 127.0.0.1:6379 > LRANGE list 1 2 #获取指定范围的值 1 ) "bbb" 2 ) "aaa" 127.0.0.1:6379 > LINDEX list -1 #获取倒第一个数的值 "aaa" 127.0.0.1:6379 > LINDEX list -2 #获取倒第二个数的值 "bbb"
127.0.0.1:6379 > SADD set1 v1 #生成集合key ( integer ) 1 127.0.0.1:6379 > SADD set2 v2 v4 ( integer ) 2 127.0.0.1:6379 > TYPE set1 #查看类型 set 127.0.0.1:6379 > TYPE set2 set 127.0.0.1:6379 > SADD set1 v2 v3 v4 #向集合set1添加一个或多个成员 ( integer ) 3 127.0.0.1:6379 > SADD set1 v2 #返回值为0表示0个数据操作成功 ( integer ) 0 127.0.0.1:6379 > SMEMBERS set1 #查看集合所有数据 1 ) "v1" 2 ) "v2" 3 ) "v3" 4 ) "v4" 127.0.0.1:6379 > SMEMBERS set2 #查看集合所有数据 1 ) "v2" 2 ) "v4" 127.0.0.1:6379 > SCARD set1 #获取集合长度 ( integer ) 4 127.0.0.1:6379 > SDIFF set1 set2 #获取set1和set2的差集 1 ) "v1" 2 ) "v3" 127.0.0.1:6379 > SINTER set1 set2 #获取set1和set2的交集 1 ) "v2" 2 ) "v4" 127.0.0.1:6379 > SUNION set1 set2 #获取set1和set2的并集 1 ) "v1" 2 ) "v2" 3 ) "v3" 4 ) "v4" 127.0.0.1:6379 > SISMEMBER set1 v1 #判断v1是否是集合set1的成员 ( integer ) 1 127.0.0.1:6379 > SISMEMBER set1 v5 #返回0表示不是 ( integer ) 0
127.0.0.1:6379> ZADD zset1 1 v1 #生成有序集合 (integer) 1 127.0.0.1:6379> ZADD zset1 2 v2 (integer) 1 127.0.0.1:6379> ZADD zset1 3 v3 (integer) 1 127.0.0.1:6379> ZADD zset1 4 v4 (integer) 1 127.0.0.1:6379> TYPE zset1 #获取key类型 zset 127.0.0.1:6379> ZADD zset2 1 v1 2 v2 3 v3 4 v4 5 v5 #一次生成多个数据 (integer) 5 127.0.0.1:6379> TYPE zset2 zset 127.0.0.1:6379> ZCARD zset1 #查看有序集合长度 (integer) 4 127.0.0.1:6379> ZCARD zset2 (integer) 5 127.0.0.1:6379> ZRANGE zset1 1 3 #基于索引返回数值 1) "v2" 2) "v3" 3) "v4" 127.0.0.1:6379> ZRANGE zset1 2 2 1) "v3" 127.0.0.1:6379> ZRANK zset1 v3 #返回某个数值的索引 (integer) 2 127.0.0.1:6379> ZRANK zset1 v1 (integer) 0 ----写入不通评分的数据，查看排列---- root@ubuntu20:~# redis-cli --raw #--raw 指定原生数据，不做转义 127.0.0.1:6379> auth 123123 OK 127.0.0.1:6379> ZADD paihangbang 90 nezha 199 zhanlang 60 zhuluoji 30 gangtiexia 99 封神榜 5 127.0.0.1:6379> ZRANGE paihangbang 0 -1 #显示集合内所有的key，升序排序 gangtiexia zhuluoji nezha 封神榜 zhanlang 127.0.0.1:6379> ZREVRANGE paihangbang 0 -1 withscores #显示指定集合内所有key和得分情况，并按照降序排序， zhanlang 199 封神榜 99 nezha 90 zhuluoji 60 gangtiexia 30
127.0.0.1:6379 > HSET hash1 name tom age 18 #生成hash key 2 127.0.0.1:6379 > TYPE hash1 hash ----获取hash key字段值---- 127.0.0.1:6379 > HGET hash1 name tom 127.0.0.1:6379 > HGET hash1 age 18127.0.0.1:6379 > HMSET hash3 name tom age 20 OK 127.0.0.1:6379 > HKEYS hash3 name age 127.0.0.1:6379 > HMGET hash3 name age tom 20 127.0.0.1:6379 > HGETALL hash3 name tom age 20 127.0.0.1:6379 > hkeys hash4 #删除hash4的key字段 1 ) "name" 2 ) "age" 127.0.0.1:6379 > hdel hash4 name ( integer ) 1 127.0.0.1:6379 > keys hash * 1 ) "hash1" 2 ) "hash3" 3 ) "hash4" 127.0.0.1:6379 > hdel hash4 age #删除hash4的第二个hash key字段 ( integer ) 1 127.0.0.1:6379 > keys hash * #当一个key的所有字段都被删除，key也被删除 1 ) "hash1" 2 ) "hash3"
#从管道的左侧写入 127.0.0.1:6379 > LPUSH channel1 msg1 1 127.0.0.1:6379 > LPUSH channel1 msg2 2 127.0.0.1:6379 > LPUSH channel1 msg3 3 127.0.0.1:6379 > LPUSH channel1 msg4 4 127.0.0.1:6379 > LPUSH channel1 msg5 5 查看队列所有消息： 127.0.0.1:6379 > LRANGE channel1 0 -1 msg5 msg4 msg3 msg2 msg1 #从管道的右侧消费 127.0.0.1:6379 > RPOP channel1 msg1 127.0.0.1:6379 > RPOP channel1 msg2 127.0.0.1:6379 > RPOP channel1 msg3 127.0.0.1:6379 > RPOP channel1 msg4 127.0.0.1:6379 > RPOP channel1 msg5 127.0.0.1:6379 > RPOP channel1 再次验证队列消息： 127.0.0.1:6379 > LRANGE channel1 0 -1 #队列中的消息已经被已全部消费完毕
#订阅者订阅指定的频道，频道不存在也可以订阅： 127.0.0.1:6379 > SUBSCRIBE channel1 subscribe channel1 1 发布者在另外一个终端发布消息： 127.0.0.1:6379 > PUBLISH channel1 test1 ( integer ) 1 127.0.0.1:6379 > PUBLISH channel1 test2 ( integer ) 1 各订阅者验证消息： 127.0.0.1:6379 > SUBSCRIBE channel1 subscribe channel1 1 message channel1 test1 message channel1 test2 message 同时订阅多个频道： 127.0.0.1:6379 > SUBSCRIBE channel1 channel2 subscribe channel1 1 subscribe channel2 2 基于正则订阅指定频道： 127.0.0.1:6379 > PSUBSCRIBE chann * psubscribe chann* 1 订阅匹配的频道： 127.0.0.1:6379 > PSUBSCRIBE * psubscribe * 1
################################## NETWORK ##################################### bind 0.0.0.0 #监听地址，可以用空格隔开后多个监听IP
protected-mode no#redis3.2 之后加入的新特性，在没有设置bind IP和密码的时候,redis只允许访问127.0.0.1:6379，远程访问将提示警告信息并拒绝远程访问
port 6379#监听端口
tcp-backlog 511#三次握手的时候，Redis server收到的的客户端请求在未建立好连接之前的未连接队列长度
unixsocket /apps/redis/run/redis.sock unixsocketperm 700 #redis socket文件路径,需要对目录有写入权限，且保证有这个路径
timeout 0 #客户端和Redis服务端的会话超时时间，即多少秒之后Redis会和客户端断开连接，默认是0，表示永不超时。
tcp-keepalive 300#Redis server定时向client发送tcp_ack包来探测client是否存活，即每间隔多少秒探测客户端是否存活 ################################# GENERAL（常规） ##################################### daemonize yes# 以守护进程运行，会生成一个pid文件记录当前进程的pid
supervised auto#可以设置通过upstart和systemd管理Redis守护进程，centos 7以后都使用systemd
pidfile /apps/redis/run/redis_6379.pid#pid文件路径
loglevel notice #日志级别 ----A主机先生成数据---- root@ubuntu20:/apps/redis/data# redis-cli 127.0.0.1:6379> auth 123123 OK 127.0.0.1:6379> set zhangsan xxx OK 127.0.0.1:6379> keys * 1) "zhangsan" 2) "aa" B主机停止redis服务 root@ubuntu20:~# systemctl stop redis-server.service 复制A主机的rdb文件到B主机 root@ubuntu20:/apps/redis/data# scp ./dump_6379.rdb root@45.15.10.203:/var/lib/redis/dump.rdb root@ubuntu20:/apps/redis/data# ll drwx------ 2 redis redis 4096 Sep 7 16:00 appendonlydir/ -rw------- 1 redis redis 100 Sep 7 16:01 dump_6379.rdb root@ubuntu20:/apps/redis/data# scp ./dump_6379.rdb root@45.15.10.203:/var/lib/redis/dump.rdb B主机重启redis服务，验证数据 root@ubuntu20:~# systemctl restart redis-server.service root@ubuntu20:~# redis-cli 127.0.0.1:6379> keys * 1) "aa" 2) "zhangsan" 127.0.0.1:6379>
----开启redis数据持久化混合模式---- root@ubuntu20:~# vim /apps/redis/etc/redis.conf .... aof-rewrite-incremental-fsync yes .... systemctl restart redis.service root@ubuntu20:~# ll /apps/redis/data/appendonlydir/ -rw------- 1 redis redis 88 Sep 6 10:29 appendonly.aof.1.base.rdb -rw------- 1 redis redis 2369 Sep 7 13:31 appendonly.aof.1.incr.aof -rw------- 1 redis redis 88 Sep 6 10:29 appendonly.aof.manifest ---AOF文件的保存路径，同RDB的路径一致---- root@ubuntu20:~# vim /apps/redis/etc/redis.conf .... ################################ SNAPSHOTTING################################ dir /apps/redis/data/ .... 注意：AOF的优先级比RDB高
127.0.0.1:6379 > acl help 1 ) ACL <subcommand> [ < arg > [value] [opt] ...]. Subcommands are: 2 ) LOAD #从ACL文件中重新载入用户信息 3 ) SAVE #保存当前的用户配置信息到ACL文件 4 ) LIST #以配置文件格式显示用户详细信息 5 ) USERS #列出所有已注册的用户名 6 ) SETUSER <username> [attribs ...] #创建或则修改一个用户 7 ) GETUSER <username> #得到一个用户的详细信息 8 ) DELUSER <username> [...] #删除列表中的用户 9 ) CAT #列出可用的ACL种类，如ACL CAT等内置的方法类 10 ) CAT <category> #列出指定类别中的命令，如ACL CAT READ 11 ) GENPASS [ < bits > ] #自动生成一个安全的用户密码. 12 ) WHOAMI #返回当前的连接用户名称
+ <command>：将命令添加到用户可以调用的命令列表中，多个命令用空格隔开 - <command>：将命令从用户可以调用的命令列表中移除 +@ <category>：允许用户调用 < categor y> 类别中的所有命令，有效类别为@admin，@set，@sortedset等 ( 使用命令acl cat查看 ) ，可通过调用ACL CAT命令查看完整列表，特殊类别@all表示所有命令，包括当前和未来版本中存在的所有命令 -@ <category>：禁止用户调用<category> 类别中的所有命令 + <command>| subcommand：允许使用已禁用命令的特定子命令 + <command>| subcommand：允许使用已禁用命令的特定子命令 allcommands等于+@all：包括当前存在的命令以及将来通过模块加载的所有命令 nocommands等于-@all：禁止调用所有命令
127.0.0.1:6379 > acl list 1 ) "user default on nopass sanitize-payload ~* &* +@all" ----默认ACL账户简介---- user default #当前用户名default on #账户已经启用 nopass #没有设置密码 ~ * #能访问所有的key（~ *） * #能访问所有的发布/订阅（Pub/Sub）频道 +@all #能执行所有的命令
127.0.0.1:6379 > acl setuser qbn on ~ * &* +@all >123123 OK 127.0.0.1:6379 > acl list 1 ) "user default on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* +@all" 2 ) "user qbn on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* +@all" ----远程通过qbn用户登录redis---- [root@host-45-15-10-203 ~]# redis-cli -h 45.15.10.135 --user qbn -a 123123 45.15.10.135:6379 > 45.15.10.135:6379 > acl whoami "qbn" 45.15.10.135:6379 > set key abc OK 45.15.10.135:6379 > get key "abc"
127.0.0.1:6379> acl setuser zhangsan on ~* &* +get +set >123123 OK 127.0.0.1:6379> acl list 1) "user default on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* +@all" 2) "user qbn on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* +@all" 3) "user zhangsan on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* -@all +get +set" ----使用zhangsan用户远程登录redis---- ----注意老版本的redis没有--user的参数，所以只能用auth命令登录对应用户---- [root@host-45-15-10-203 ~]# redis-cli -h 45.15.10.135 45.15.10.135:6379> auth zhangsan 123123 OK 45.15.10.135:6379> set zhangsan-key aaa OK 45.15.10.135:6379> get zhangsan-key "aaa" 45.15.10.135:6379> del zhangsan-key #验证无删除权限 (error) NOPERM User zhangsan has no permissions to run the 'del' command 45.15.10.135:6379> acl whoami #验证无权限 (error) NOPERM User zhangsan has no permissions to run the 'acl|whoami' command
root@ubuntu20:~# vi /apps/redis/etc/redis.conf .... user qbn on ~ * &* +@all >123123 user zhangsan on ~ * &* +get +set >123123 acllog-max-len 128 #大概放在这行附近就行 .... root@ubuntu20:~# systemctl restart redis.service ----验证重启是否失效---- root@ubuntu20:~# redis-cli 127.0.0.1:6379 > auth 123123 OK 127.0.0.1:6379 > acl list 1 ) "user default on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* +@all" 2 ) "user qbn on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* +@all" 3 ) "user zhangsan on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* -@all +get +set"
----创建自定义acl文件---- root@ubuntu20:~# cat /apps/redis/etc/uers.acl user qbn on ~ * &* +@all >123123 user zhangsan on ~ * &* +get +set >123123 ----编辑redis.conf，设置自定义acl文件指定路径---- root@ubuntu20:~# vi /apps/redis/etc/redis.conf # aclfile /etc/redis/users.acl aclfile /apps/redis/etc/user.acl ----本地验证权限---- root@ubuntu20:~# redis-cli #因为用了自定义acl文件，所以默认default用户没有密码 127.0.0.1:6379 > acl list 1 ) "user default on nopass sanitize-payload ~* &* +@all" 2 ) "user qbn on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* +@all" 3 ) "user zhangsan on sanitize-payload #96cae35ce8a9b0244178bf28e4966c2ce1b8385723a96a6b838858cdd6ca0a1e ~* &* -@all +get +set"
echo "user default on ~* &* +@all >123123" >> /apps/redis/etc/user.acl ----远程登录验证zangsan权限---- [root@host-45-15-10-203 ~]# redis-cli -h 45.15.10.135 45.15.10.135:6379 > auth zhangsan 123123 OK 45.15.10.135:6379 > get zhangsan-key "aaa" 45.15.10.135:6379 > del zhangsan-key ( error ) NOPERM User zhangsan has no permissions to run the 'del' command
----查看redis版本---- root@ubuntu20:~# redis-cli 127.0.0.1:6379 > info # Server redis_version:5.0.7
---安装ruby（任意一台主机装即可）---- root@ubuntu20:~# apt install ruby ruby-dev gcc
----安装redis-dump---- root@ubuntu20:~# gem install redis-dump
root@ubuntu20:~# redis-dump --help
----把数据导出到本地---- root@ubuntu20:~# redis-dump -a 123123 -u 127.0.0.1:6379 > /tmp/redis.json root@ubuntu20:~# cat /tmp/redis.json { "db" :0, "key" : "zhangsan" , "ttl" :-1, "type" : "string" , "value" : "xxx" , "size" :3} { "db" :0, "key" : "aa" , "ttl" :-1, "type" : "string" , "value" : "bb" , "size" :2} { "db" :2, "key" : "name" , "ttl" :-1, "type" : "string" , "value" : "zhangsan" , "size" :8}
----在本地把数据远程导入到其他机器---- root@ubuntu20:~# cat /tmp/redis.json | redis-load -a 123123 -u 45.15.10.203:6379
提示：也可以把导出的json文件scp到远程机器，再远程本地导入 A主机：scp /tmp/redis.json root@45.15.10.203:/tmp/redis.json B主机：cat /tmp/redis.json | redis-load -a 123123 -u 127.0.0.1:6379
----在被导入机器验证数据---- root@ubuntu20:~# redis-cli 127.0.0.1:6379 > auth 123123 OK 127.0.0.1:6379 > keys * 1 ) "aa" 2 ) "zhangsan" 127.0.0.1:6379 > select 2 OK 127.0.0.1:6379[2] > keys * 1 ) "name" 127.0.0.1:6379[2] >
-O
-
|
sudo
tar
-xz
-C
/usr/local
root@ubuntu20:~# git clone https://github.com/alibaba/RedisShake root@ubuntu20:~# cd RedisShake root@ubuntu20:~/RedisShake# sh build.sh root@ubuntu20:~/RedisShake# ll drwxr-xr-x 4 root root 4096 Feb 6 16:40 bin/ ### build.sh成功生成bin目录 -rwxr-xr-x 1 root root 966 Feb 6 16:32 build.sh * drwxr-xr-x 3 root root 4096 Feb 6 16:32 cmd/ drwxr-xr-x 2 root root 4096 Feb 6 16:32 filters/ drwxr-xr-x 8 root root 4096 Feb 6 16:34 .git/ drwxr-xr-x 4 root root 4096 Feb 6 16:32 .github/ -rw-r--r-- 1 root root 55 Feb 6 16:32 .gitignore -rw-r--r-- 1 root root 424 Feb 6 16:32 go.mod -rw-r--r-- 1 root root 3232 Feb 6 16:32 go.sum drwxr-xr-x 13 root root 4096 Feb 6 16:32 internal/ -rw-r--r-- 1 root root 1078 Feb 6 16:32 license.txt -rw-r--r-- 1 root root 3499 Feb 6 16:32 README.md -rw-r--r-- 1 root root 1924 Feb 6 16:32 restore.toml -rw-r--r-- 1 root root 1918 Feb 6 16:32 scan.toml drwxr-xr-x 4 root root 4096 Feb 6 16:32 scripts/ drwxr-xr-x 5 root root 4096 Feb 6 16:32 test/ root@ubuntu20-171:RedisShake# cd bin/ root@ubuntu20-171:bin# ll root@ubuntu20:~/RedisShake/bin# ll -rwxr-xr-x 1 root root 11437724 Sep 7 19:38 redis-shake * #可执行文件 -rw-r--r-- 1 root root 2671 Sep 7 19:38 shake.toml # 参数模板
----到目的主机验证---- root@ubuntu20:~# redis-cli 127.0.0.1:6379 > auth 123123 OK 127.0.0.1:6379 > keys * 1 ) "bbb" 2 ) "ccc" 3 ) "ddd" 4 ) "aa" 5 ) "qbn" 6 ) "zhangsan" 7 ) "aaa" 127.0.0.1:6379 >
-rwxr-xr-x 1 root root 10808448 Sep 5 08:36 redis-benchmark * #redis性能测试工具
lrwxrwxrwx 1 root root 12 Sep 5 08:36 redis-check-aof -> redis-server * #AOF文件检查工具
lrwxrwxrwx 1 root root 12 Sep 5 08:36 redis-check-rdb -> redis-server * #RBD文件检查工具
-rwxr-xr-x 1 root root 11356152 Sep 5 08:36 redis-cli * #客户端工具
lrwxrwxrwx 1 root root 12 Sep 5 08:36 redis-sentinel -> redis-server * #哨兵
-rwxr-xr-x 1 root root 22981944 Sep 5 08:36 redis-server * #服务启动命令
----做软链接，方便全局执行命令----
root@ubuntu:/usr/local/src/redis-7.2.0# ln -sv /apps/redis/bin/ * /usr/bin/
----创建配置文件，日志，数据等目录----
root@ubuntu:/usr/local/src/redis-7.2.0# mkdir /apps/redis/{etc,logs,data,run}
root@ubuntu:/usr/local/src/redis-7.2.0# ll /apps/redis/
drwxr-xr-x 2 root root 4096 Sep 5 08:36 bin/
drwxr-xr-x 2 root root 4096 Sep 5 09:04 data/
drwxr-xr-x 2 root root 4096 Sep 5 09:04 etc/
drwxr-xr-x 2 root root 4096 Sep 5 09:04 logs/
drwxr-xr-x 2 root root 4096 Sep 5 09:04 run/
root@ubuntu:/usr/local/src/redis-7.2.0# cp redis.conf /apps/redis/etc/
前台启动redis
root@ubuntu:/usr/local/src/redis-7.2.0# redis-server ./redis.conf
120435:C 05 Sep 2023 09:08:37.753 # WARNING Memory overcommit must be enabled! Without it, a background save or replication may fail under low memory condition. Being disabled, it can also cause failures without low memory condition, see https://github.com/jemalloc/jemalloc/issues/1328. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
120435:C 05 Sep 2023 09:08:37.753 * oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
120435:C 05 Sep 2023 09:08:37.753 * Redis version=7.2.0, bits=64, commit=00000000, modified=0, pid=120435, just started
120435:C 05 Sep 2023 09:08:37.753 * Configuration loaded
120435:M 05 Sep 2023 09:08:37.756 * Increased maximum number of open files to 10032 (it was originally set to 1024 ).
120435:M 05 Sep 2023 09:08:37.756 * monotonic clock: POSIX clock_gettime
_._
_.- `` __ ''-._
_.- `` ` . ` _. ''-._ Redis 7.2.0 (00000000/0) 64 bit
.- `` .- ``` . ``` \/ _.,_ ''-._
( ' , .-` | `, ) Running in standalone mode
|`-._`-...-` __...-.``-._|' ` _.-'| Port: 6379
| `-._ `._ / _.-' | PID: 120435
` -._ ` -._ ` -./ _.-' _.-'
| ` -._ ` -._ ` -.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | https://redis.io
`-._ `-._`-.__.-'_.-' _.-'
| ` -._ ` -._ ` -.__.- ' _.-' _.- '|
| `-._`-._ _.-' _.- ' |
`-._ `-._`-.__.-' _.- ' _.-'
` -._ ` -.__.- ' _.-'
` -._ _.-'
`-.__.-'
logfile "/apps/redis/logs/redis_6379.log"#日志路径
databases 16#设置db 库数量，默认16个库
always-show-logo yes#在启动redis 时是否显示redis log
set-proc-title yes# 设置进程标题信息以显示一些运行时信息，和下面的proc-title-template合并使用生效
proc-title-template "{title} {listen-addr} {server-mode}"# 进程格式
locale-collate ""#设置环境变量，用于lua脚本、
################################ SNAPSHOTTING （快照） ################################
----多久做一次快照----
save 3600 1
#3600秒内，一个key变化做一次快照
save 300 100
#300秒内，100个key变化做一次快照
#save ""
#值为空就是不做RDB快照
stop-writes-on-bgsave-error no#快照出错时是否禁止redis写入操作
rdbcompression yes#持久化到RDB文件时，是否压缩，"yes"为压缩，"no"为不压缩
rdbchecksum yes#是否开启CRC64校验以保证RDB文件的完整性，默认为开启。
dbfilename dump.rdb#快照文件名。
rdb-del-sync-files no#在没有开启数据持久化的情况下删除复制中使用的RDB文件
dir /apps/redis/data/#快照及AOF持久化文件的保存路径。
################################# REPLICATION (复制)#################################
# replicaof <masterip> <masterport># master ip及端口
# masterauth <master-password>#master 密码
# masteruser <username>#master 账户
replica-serve-stale-data yes
#当从库同主库失去连接或者复制正在进行，从机库有两种数据提供方式：
#1、如果replica-serve-stale-data设置为yes(默认设置)，从库会继续响应客户端的读请求。
#2、如果replica-serve-stale-data设置为no，除去指定的命令之外的任何请求都会返回一个错误"SYNC with master in progress"。
replica-read-only yes#是否设置从库只读
repl-diskless-sync yes
#是否使用socket方式复制数据(无盘同步)，新slave连接连接时候需要做数据的全量同步，redis server就要从内存dump出新的RDB文件，然后从master传到slave，有两种方式把RDB文件传输给客户端：
#1、基于硬盘（disk-backed）：master创建一个新进程dump RDB，RDB完成之后由父进程（即主进程）传给slaves。
#2、基于socket（diskless）：master创建一个新进程直接dump RDB到slave的socket，不经过主进程，不经过硬盘。
#基于硬盘的话，RDB文件创建后，一旦创建完毕，可以同时传输给多个slave，基于socket的也有延迟时间repl-diskless-sync-delay
# 在磁盘IO较慢并且网络较快的时候，可以用diskless(yes),如果磁盘IO很快而且网络也很快可以使用磁盘(no)，如果磁盘IO慢网络也慢，那就提升硬件
repl-diskless-sync-delay 5
#diskless即无盘复制的RDB快照延迟传输时间,在此时间内的slave 可以共用同一个RDB快照文件
repl-diskless-sync-max-replicas 0
#在延迟时间内的无盘复制的最大slave数量，0为不限制
repl-diskless-load disabled
#slave 是否使用无盘加载
#disabled：slave不使用无磁盘加载，先将rdb文件存储到磁盘,等文件传输成功后再加载
#swapdb：解析时在RAM中保留当前rdb内容的副本，直接从套接字获取数据，需要在内存保存rdb快照并再把快照还原为数据保存到内存，需要内存够用，否则容易发生OOM
#on-empty-db：仅在当前slave数据集为空时使用无盘加载
repl-ping-replica-period 10
#slave根据master指定的时间进行周期性的PING 监测
repl-timeout 60
#复制连接的超时时间，需要大于repl-ping-slave-period，否则会经常报超时
repl-disable-tcp-nodelay no
#在socket模式下是否在slave套接字发送SYNC之后禁用 TCP_NODELAY，关闭tcp不延迟
#如果选择yes(关闭tcp不延迟=是=延迟)，Redis将会延迟40ms并合并再此时间内产生的报文，那么redis将会使用较少的TCP 包和带宽来向slaves发送数据，但是这将使数据传输到slave上有延迟，
Linux 内核的默认配置会达到40 毫秒，如果为no ( 关闭tcp不延迟 =否=不延迟 ) ，数据传输到salve的延迟将会减少但要使用更多的带宽 ( 有额外的TCP报文包头封装 ) 。
repl-backlog-size 512mb
#复制缓冲区内存大小，只有在slave连接之后才分配内存
repl-backlog-ttl 600
#多长时间master没有slave连接，就清空backlog缓冲区
replica-priority 100
#当master不可用，Sentinel会根据slave的优先级选举一个master，最低的优先级的slave，当选master，而配置成0，永远不会被选举
propagation-error-behavior ignore
#从master同步数据或者从aof读取数据时可能会出错，也可能造成数据不一致，默认设置ignore，忽略这些错误并继续执行命令,设置为panic遇到错误则不会继续
replica-ignore-disk-write-errors no
#当slave无法将从master接收到的命令持久化到磁盘时，那么slave与master的同步将崩溃,需要通过集群监控及时发现集群同步异常并修复，为了保证集群数据的一致性，不建议修改默认值，但为了兼容老版本redis可以设置yes，这只会记录一个警告日志并执行收到的写命令(会导致master与slave的数据不一致)
replica-announced yes
#设置是否公布当前节点，默认情况下哨兵会公布全部节点，一个未公布的副本会忽略"sentinel replicas <master>"命令并且不会暴露给哨兵的客户端,相当于隐藏当前节点
#min-replicas-to-write 1
#min-replicas-max-lag 10
#当前主服务器至少3个已连接的slave服务器，并且与主服务器最后一次成功通讯的间隔小于10秒钟的情况下，主服务器才执行写命令，否则主服务器拒绝新的数据(只读)，默认最少3个slave,如果是单机不要开启，会导致无法写入数据，报错(error) NOREPLICAS Not enough good replicas to write.
# replica-announce-ip 5.5.5.5
# replica-announce-port 1234
#将当前slave的明确的ip和端口报告给master，非必须，master会获取slave的连接地址，在跨越子网的NAT网络，地址是会被SNAT转换的
############################### KEYS TRACKING #################################
# tracking-table-max-keys 1000000
#key失效管理,Redis通过失效表记录客户端访问了哪个key是失效的，并将失效的消息发送给客户端,0不限制,非必须
################################## SECURITY（安全） ###################################
acllog-max-len 128
#ACL 日志的最大长度,记录执行失败的命令和的登录失败的验证信息,使用ACL LOG查看
requirepass 123
#default user的访问密码
# rename-command CONFIG ""
#rename-command FLUSHALL rmalldata
#重命名指定(高危)命令 为 xx,如：rename-command FLUSHALL rmalldata
################################### CLIENTS（客户端） ####################################
# maxclients 10000
#最大客户端连接数,默认为10000，连接数用完后将报错“max number of clients reached”
############################## MEMORY MANAGEMENT（内存管理） ################################
# maxmemory <bytes>
# 最大内存空间使用，默认无限制,要预留一部分内存空间给内核及redis 缓冲区使用
# maxmemory-policy noeviction
# 内存用完后的策略，默认不删除任何其他key，而是返回数据写入失败的提示
# volatile-lru -> Evict using approximated LRU, only keys with an expire set.
# allkeys-lru -> Evict any key using approximated LRU.
# volatile-lfu -> Evict using approximated LFU, only keys with an expire set.
# allkeys-lfu -> Evict any key using approximated LFU.
# volatile-random -> Remove a random key having an expire set.
# allkeys-random -> Remove a random key, any key.
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
# noeviction -> Don't evict anything, just return an error on write operations.
# replica-ignore-maxmemory yes
#从redis 5开始。slave 角色忽略内存的最大设置，而是以master为准
# active-expire-effort 1
# 清理过去key的CPU分配比例，范围1~10，10会分配较多的CPU去清理过期的key，会消耗较多的CPU但是清理时间较短，1消耗的CPU少但是清理时间长
############################# LAZY FREEING ####################################
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
#是否看开启惰性数据删除即延迟数据删除(内存空间回收),在删除数据的时候提供异步延时释放键值的功能，把键值释放操作放在 BIO(Background I/O) 单独的子线程处理中，以减少删除删除对 Redis 主线程的阻塞，可以有效地避免删除 big key 时带来的性能和可用性问题,生产可以开启、可提高Redis主线程的执行效率
#lazyfree-lazy-eviction：表示当 Redis 运行内存超过 maxmeory 时，是否开启 lazy free 机制删除
#lazyfree-lazy-expire：表示设置了过期时间的键值，当过期之后是否开启 lazy free 机制删除
#lazyfree-lazy-server-del：有些指令在处理已存在的键时，会带有一个隐式的 del 键的操作，比如 rename 命令，当目标键已存在，Redis 会先删除目标键，如果这些目标键是一个 big key，就会造成阻塞删除的问题，此配置表示在这种场景中是否开启 lazy free 机制删除
#slave-lazy-flush：针对 slave(从节点) 进行全量数据同步，slave 在加载 master 的 RDB 文件前，会运行 flushall 来清理自己的数据，它表示此时是否开启 lazy free 机制删除。
lazyfree-lazy-user-del no
#是否将del设置为类似于UNLINK的删除功能，yes为等于UNLINK是非阻塞删除，no为阻塞删除数据
lazyfree-lazy-user-flush no
#是否设置清空DB的非阻塞删除,no为阻塞,yes为非阻塞
################################ THREADED I/O #################################
#io-threads 2
#是否开启多线程，处理网络I/O请求,数据读写还是单线程,超过8个以上对性能提升不大，4核心CPU可以设置2~3个redis线程，8核CPU可以设置6个redis 线程
#io-threads-do-reads yes
# 是否开启io多线程，和前面io-threads 4一起使用，默认不开启
############################ KERNEL OOM CONTROL ##############################
oom-score-adj no
#是否启用oom-score-adj设置
#on：对oom-score-adj不做任何修改（默认值）
#yes：是最后面relative的别名
#absolute：oom-score-adj-values配置的值将写入内核
#relative：当服务器启动时，使用相对于oom_score_adj初始值的值，然后将其限制在-1000到1000的范围内。
oom-score-adj-values 0 200 800
#分别控制Redis主进程、从进程和后台子进程的值
#################### KERNEL transparent hugepage CONTROL ######################
disable-thp yes
#关闭透明大页
############################## APPEND ONLY MODE ###############################
appendonly yes
#是否启用AOF日志文件
appendfilename "appendonly.aof"
#AOF日志文件名称
appenddirname "appendonlydir"
#AOF日志文件的目录名称
# appendfsync no
##aof持久化策略的配置,no表示不执行fsync，由操作系统保证数据同步到磁盘,always表示每次写入都执行fsync，以保证数据同步到磁盘,everysec表示每秒执行一次fsync，可能会导致丢失这1s数据。
no-appendfsync-on-rewrite no
#在aof rewrite期间,是否对aof新记录的append暂缓使用文件同步策略,主要考虑磁盘IO开支和请求阻塞时间。默认为no,表示"不暂缓",新的aof记录仍然会被立即同步，Linux的默认fsync策略是30秒，如果为yes 可能丢失30秒数据，但由于yes性能较好而且会避免出现阻塞因此比较推荐。
auto-aof-rewrite-percentage 100
# 当Aof log增长超过指定百分比例时，重写AOF文件， 设置为0表示不自动重写Aof 日志，重写是为了使aof体积保持最小，但是还可以确保保存最完整的数据，
auto-aof-rewrite-min-size 64mb
#触发aof rewrite的原始最小文件大小
aof-load-truncated yes
##是否加载由于其他原因导致的末尾异常的AOF文件(主进程被kill/断电等)
aof-use-rdb-preamble yes
# #redis4.0新增RDB-AOF混合持久化格式，在开启了这个功能之后，AOF重写产生的文件将同时包含RDB格式的内容和AOF格式的内容，其中RDB格式的内容用于记录已有的数据，而AOF格式的内存则用于记录最近发生了变化的数据，这样Redis就可以同时兼有RDB持久化和AOF持久化的优点（既能够快速地生成重写文件，也能够在出现问题时，快速地载入数据）
################################ SHUTDOWN #####################################
# shutdown-timeout 10
#在与slave同步数据的时候，关闭的最大宽限期，可以等10秒钟让slave复制数据、避免数据的不一致
# shutdown-on-sigint default
# shutdown-on-sigterm default
# 关闭动作
#default: 如果有需要保存的数据,则等待RDB保存、且等待Slave同步
#save ： 即使没有需要保存的数,也会执行RDB
#nosave : 即使配置了数据保存,也不执行RDB
#now ：跳过Slave同步
#force ： 忽略阻止Redis关闭遇到的问题(强制退出)
################ NON-DETERMINISTIC LONG BLOCKING COMMANDS #####################
# lua-time-limit 5000
# busy-reply-threshold 5000
# 设置lua脚本、函数以及某些情况下的模块最长执行时长，以毫秒为单位，busy-reply-threshold 等于lua-time-limit，是新加的别名
################################ REDIS CLUSTER ###############################
# cluster-enabled yes
# cluster-config-file nodes-6379.conf
#redis cluster的配置文件名称，配置文件由由node节点自动生成及动态更新
# cluster-node-timeout 15000
#集群中node节点连接超时时间，15000毫秒
# cluster-port 0
#集群端口，用于集群状态通信，默认是数据端口之上加10000，如6379，那集群端口默认是16379
# cluster-replica-validity-factor 10
#在执行故障转移的时候可能有些节点和master断开一段时间数据比较旧，这些节点就不适用于选举为master，超过这个时间的就不会被进行故障转移
# cluster-migration-barrier 1
#集群迁移屏障，一个主节点拥有的至少正常工作的从节点，即如果主节点的slave节点故障后会将多余的从节点分配到当前主节点成为其新的从节点。
# cluster-allow-replica-migration yes
#迁移后master节点至少还有1个slave节点才能做后期的节点迁移,比如 master A 节点有2个slave节点,当集群出现孤儿master B 节点时(没有slave的master是孤儿master),A节点富余的slave节点可以自动被迁移到master B节点作为B的slave,默认为yes表示允许自动迁移
# cluster-require-full-coverage yes
#集群请求槽位全部覆盖，如果一个主库宕机且没有备库就会出现集群槽位不全，那么yes情况下redis集群槽位验证不全就不再对外提供服务，而no则可以继续使用但是会出现查询数据查不到的情况(因为有数据丢失)
# cluster-replica-no-failover no
#默认配置为no，当配置成 yes，在master宕机时,当前slave 不会做故障转移升为 master,用于将特定节点始终设置为slave的时候使用
# cluster-allow-reads-when-down no
#是否允许集群部分主节点宕机,且无法自动选举的情况下,依然可从其它主节点中读取数据
# cluster-allow-pubsubshard-when-down yes
#是否允许集群部分主节点宕机,且无法自动选举的情况下，依然可以使用pub/sub
# cluster-link-sendbuf-limit 0
#设置集群客户端连接的发送字节缓冲区的内存使用限制，超过限制缓冲区将被清空
#默认禁用，可配合client-query-buffer-limit 的值使用，client-query-buffer-limit 默认为1gb，那么此处可以设置1gb
# cluster-announce-hostname ""
#配置集群使用主机名公布当前节点信息，默认使用主机IP，使用场景为配置TLS证书的时候
# cluster-announce-human-nodename ""
# 配置用于日志中调试的节点的唯一标识符
# cluster-preferred-endpoint-type ip
#集群首选的端点类型
########################## CLUSTER DOCKER/NAT support ########################
#在某些部署中，Redis Cluster节点的地址发现失败，原因是地址被NAT转发或端口被转发（典型的情况是Docker和其他容器）。
##为了使Redis集群能够在这样的环境中工作每个节点都知道需要其公共地址的配置，以下四个选项用于此范围，分别为：
# * cluster-announce-ip
# * cluster-announce-port
# * cluster-announce-tls-port
# * cluster-announce-bus-port #集群端口
# Example:
# cluster-announce-ip 10.1.1.5
# cluster-announce-tls-port 6379
# cluster-announce-port 0
# cluster-announce-bus-port 6380
################################## SLOW LOG ###################################
slowlog-log-slower-than 1
#以微秒为单位的慢日志记录，为负数会禁用慢日志，为0会记录每个命令操作，可以设置一定时间去看看什么操作慢，时间单位是微秒，1000000微秒=1秒
slowlog-max-len 128
#记录多少条慢日志保存在队列，超出后会删除最早的，以此滚动删除,使用SLOWLOG GET 查看慢日志
################################ LATENCY MONITOR ##############################
latency-monitor-threshold 0
#是否启用延迟监控，用于rdis性响应慢的时候的性能分析，单位为毫秒milliseconds,0为关闭
# latency-tracking-info-percentiles 50 99 99.9
#启用延迟监控后, 通过INFO latencystats命令导出百分比分布
############################# EVENT NOTIFICATION ##############################
notify-keyspace-events ""
#让客户端可以通过 "发布/订阅" 模式来获取redis 数据库中键的变化以及某事件的发生
############################### ADVANCED CONFIG（高级配置） ###############################
#在 Redis 7.0 版本散列表数据类型有两种数据结构保存数据，分别为散列表和 listpack。当数据量很小时，可以使用更高效的数据结构存储，从而达到在不影响性能的情况下节省内存
hash-max-listpack-entries 512
#listpack(紧凑列表)中，哈希对象保存的键值对数量最大值
hash-max-listpack-value 64
#listpack(紧凑列表)中，哈希对象所有键值对的键和值的字符串长度的字节数都小于hash-max-listpack-value的值
#Lists 也可以使用一种特殊方式进行编码来节省大量内存空间。在 Redis 7.0 之后，Lits 底层的数据结构使用 linkedlist 或者 listpack
#当list-max-ziplist-size 为负数时表示限制每个 quicklistNode 的 ziplist 的内存大小，超过这个大小就会使用 linkedlist 存储数据，每个值有以下含义
#-5：每个 quicklist 节点上的 ziplist 大小最大 64 kb <--- 正常环境不推荐
#-4：每个 quicklist 节点上的 ziplist 大小最大 32 kb <--- 不推荐
#-3：每个 quicklist 节点上的 ziplist 大小最大 16 kb <--- 可能不推荐
#-2：每个 quicklist 节点上的 ziplist 大小最大 8 kb <--- 推荐
#-1：每个 quicklist 节点上的 ziplist 大小最大 4kb <--- 推荐
list-max-listpack-size -2
#默认值为 -2，也是官方最推荐的值,也可以自己调整
list-compress-depth 0
#压缩深度配置，用来配置压缩Lists压缩的，默认是0表示不压缩
set-max-intset-entries 512
#整数集合内的元素最大值，长度不超过此值Sets 的底层会使用 intset 存储节省内存，超过后转换为散列表存储
#散列表-Hash table,也叫哈希表,是根据Key而直接访问在内存储存位置的数据结构
set-max-listpack-entries 128
#listpack(紧凑列表)中，无序集合保存的键值对数量最大值
set-max-listpack-value 64
#listpack(紧凑列表)中，无序集合所有键值对的键和值的字符串长度的字节数都小于set-max-listpack-value的值
zset-max-listpack-entries 128
#listpack(紧凑列表)中，有序集合保存的键值对数量最大值
zset-max-listpack-value 64
#listpack(紧凑列表)中，有序集合所有键值对的键和值的字符串长度的字节数都小于zset-max-listpack-value的值
hll-sparse-max-bytes 3000
#HyperLogLog 是一种高级数据结构，统计基数的利器。HyperLogLog 的存储结构分为密集存储结构和稀疏存储结构两种，默认为稀疏存储结构,稀疏结构占用的内存会更小
#默认配置是 hll-sparse-max-bytes 3000，单位是Byte,超过后转换为密集存储结构,推荐的值是0~3000，这样PFADD命令的并不会慢多少,还能节省空间,如果内存空间相对cpu资源更缺乏,可以将这个值提升到10000。
#Stream 是 Redis 5.0 版本新增的数据类型,每个节点中都存储着若干Stream条目,因此这些节点通常被称为宏节点
stream-node-max-bytes 4096
#单位为Byte,默认值4096,用于设定每个宏节点占用的内存上限为4096,0表示无限制
stream-node-max-entries 100
#用于设定每个宏节点存储元素个数, 默认值100,0表示无限制,当一个宏节点存储的Stream条目到达上限,新添加的条目会存储到新的宏节点中
activerehashing yes
#设置成yes后redis将每100毫秒使用1毫秒CPU时间来对redis的hash表重新hash，可降低内存的使用
#这三个配置是用来强制断开客户端连接的，当客户端没有及时把缓冲区的数据读取完毕，我会认为这个客户端可能已经异常了（一个常见的原因是 Pub/Sub 客户端处理发布者的消息不够快），于是断开连接
#一共分为三种不同类型的客户端，分别设置不同的限制
#normal（普通），普通客户端，包括 MONITOR 客户端。
#replica（副本客户端），slave 节点的客户端。
#pubsub（发布订阅客户端），至少订阅了一个 pubsub 频道或者模式的客户端。
#client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
# client-query-buffer-limit 1gb
#客户端query buffer（查询缓冲区或输入缓冲区），用于保存客户端发送命令，Redis Server从query buffer获取命令并执行。
#如果程序的Key设计不合理，客户端使用大量的query buffer，导致Redis很容易达到 maxmeory 限制,最好限制在一个固定的大小来避免占用过大内存的问题
#比如像图片视频就不要往redis写，以及key也不要太大
#7.0 版本特性，每个与服务端建立连接的客户端都会占用内存（查询缓冲区、输出缓冲区和其他缓冲区）
#大量的客户端可能会占用过大内存导致 OOM，为了避免这个情况,redis 可以基于（Client Eviction）客户端驱逐机制用于限制内存占用
# maxmemory-clients 1g
#限制所有客户端占用内存总和
# maxmemory-clients 5%
#表示如果maxmemory-clients的内存不足，那么占用内存达到5%的客户端将被驱逐，这里的5%是 maxmemory-clients设置的值的5%
# proto-max-bulk-len 512mb
#在redis协议中，单个大体积的字符串请求，最大限制为512mb，可以调大
#redis在后台调用一些函数来执行很多后台任务,比如关闭超时连接,清理不再被请求的过期的key,rehash、执行RDB内存快照和AOF持久化等操作，可以使用 hz 参数来决定执行这些任务的频率
hz 10
#默认配置是 hz 10，表示每秒执行 10 次，更大的值会消耗更多的 CPU 来处理后台任务，带来的效果就是更快的清理过期 key，清理的超时连接更精确。
dynamic-hz yes
#默认配置是 dynamic-hz yes,redis会根据上一个hz定义的数量内自动调整后台任务
rdb-save-incremental-fsync yes
#当子进程进行AOF重写时,如果配置成 aof-rewrite-incremental-fsync yes,每生成4MB数据就执行一次fsync操作,可以将一个较大的文件分批提交到硬盘来避免瞬间IO，推荐开启
# lfu-log-factor 10
#用于调整数据的访问增长频率,lfu-log-factor越大,counter增长的越慢
# lfu-decay-time 1
#整数据的访问统计减少值由衰减因子lfu-decay-time(单位为分钟)来控制，如果值是1分钟的话,N分钟没有访问就要减少N次
########################### ACTIVE DEFRAGMENTATION（活动碎片整理） #######################
# activedefrag no
# 是否启用内存在线整理
# active-defrag-ignore-bytes 100mb
#当redis数据量达到多大后,执行数据整理
# active-defrag-threshold-lower 10
#当碎片达到10%时,执行数据整理
# active-defrag-threshold-upper 100
#内存碎片超过100%后,则尽最大努力整理
# active-defrag-cycle-min 1
# 自动清理过程中，占用 CPU 时间的比例不低于 1%，从而保证能正常展开清理任务。
# active-defrag-cycle-max 25
#自动清理过程占用的CPU时间比例不能高于25%超过的话就立刻停止清理,避免对Redis的阻塞,造成高延迟
# active-defrag-max-scan-fields 1000
#碎片整理扫描到set/hash/zset/list 时，仅当 set/hash/zset/list的长度小于此阀值时，才会将此键值对加入碎片整理，大于此值的键值对会放在一个列表中延迟处理
jemalloc-bg-thread yes
#默认启用redis 自身的内存分配器线程
# 你可以将 Redis 的不同线程和进程绑定到特定的 CPU，减少上下文切换，提高 CPU L1、L2 Cache 命中率，实现最大化的性能。
# 可分为三个模块
#主线程和 I/O 线程：负责命令读取、解析、结果返回。命令执行由主线程完成。
#bio 线程：负责执行耗时的异步任务，如 close fd、AOF fsync 等。
#后台进程：fork 子进程（RDB bgsave、AOF rewrite bgrewriteaof）来执行耗时的命令
# Redis 支持分别配置上述模块的 CPU 亲合度，默认情况是关闭的
# Set redis server/io threads to cpu affinity 0,2,4,6:
# server_cpulist 0-7:2
#I/O 线程（包含主线程）相关操作绑定到 CPU 0、2、4、6, 定义基于指定的步长选择CPU
# Set bio threads to cpu affinity 1,3:
# bio_cpulist 1,3
#bio 线程相关的操作绑定到 CPU 1、3，定义指定的CPU核心
# Set aof rewrite child process to cpu affinity 8,9,10,11:
# aof_rewrite_cpulist 8-11
#aof rewrite 后台进程绑定到 CPU 8、9、10、11，定义连续的CPU核心
# Set bgsave child process to cpu affinity 1,10,11
# bgsave_cpulist 1,10-11
#bgsave 后台进程绑定到 CPU 1、10、11，定义指定的CPU加其他连续的CPU，即多个不同的指定方法
# to suppress
#忽略某些警告
# ignore-warnings ARM64-COW-BUG
#忽略ARM64平台的COW-BUG
