Reids 技术分享

目的

技术探讨，互相学习。

分享人

孔留锋

Reids概述及单体安装

一、版本选择

Redis 官方网站：https://redis.io/

官网最新稳定版版本推荐：redis-6.2.6.tar.gz

redis-6.2.6.tar.gz为 Redis 6.0 后最新稳定版， Redis 6.0 引入了 SSL、新的 RESP3 协议、ACL、客户端缓存、无盘副本、I/O 线程、更快的 RDB 加载、新的模块 API 以及更多改进。

二、Redis 简介

Redis 是一种开源（BSD 许可）、内存中数据结构存储，用作数据库、缓存和消息代理。 Redis 提供了数据结构，例如字符串、散列、列表、集合、带有范围查询的排序集合、位图、超级日志、地理空间索引和流。 Redis 内置复制、Lua 脚本、LRU 驱逐、事务和不同级别的磁盘持久化，并通过 Redis Sentinel 和 Redis Cluster 自动分区提供高可用性。

总结：

1、Redis是一个开源的key-value存储系统。

2、和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型）。

3、这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。

4、在此基础上，Redis支持各种不同方式的排序。

5、与memcached一样，为了保证效率，数据都是缓存在内存中。

6、区别的是Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件。

7、并且在此基础上实现了master-slave(主从)同步。

三、单体安装

（1）、安装包

redis-6.2.6.tar.gz

（2）、注意事项

a. 从源代码编译安装Reids

b.安装必要GCC、li’bc依赖环境

（3）、安装流程

#以我本地虚拟机为例子
#1.上传文件redis-6.2.6.tar.gz到/opt/software/下
#2.解压文件到/opt/module/reids
cd /opt/module
mkdir redis 
tar -zxvf /opt/software/redis-6.2.6.tar.gz -C /opt/module/redis/

#检查是否安装gcc
gcc -version 
# 若没安装安装如下
yum install centos-release-scl scl-utils-build
yum install -y devtoolset-8-toolchain
scl enable devtoolset-8 bash

#编译
cd /opt/module/redis/redis-6.2.6
make 
#安装
make install 

（4）、安装目录

安装目录：/usr/local/bin

查看默认安装目录：
redis-benchmark:性能测试工具，可以在自己本子运行，看看自己本子性能如何
redis-check-aof：修复有问题的AOF文件，rdb和aof后面讲
redis-check-dump：修复有问题的dump.rdb文件
redis-sentinel：Redis集群使用
redis-server：Redis服务器启动命令
redis-cli：客户端，操作入口

（5）、启动方式

#前台启动
reids-service

#后台启动
#需要修改配置文件, daemonize no 改为 yes
#拷贝一份新的配置文件,在上面修改
cp /opt/module/redis/redis-6.2.6/redis.conf  /opt/module/redis/
cd /opt/module/redis/
vim redis.conf
# 257行修改如下
# 257 daemonize yes
# 后台启动Redis
redis-server redis.conf

# 查看是否启动
redis-cli -p 6379
ping

#Redis 关闭
redis-cli shutdown

#默认16个数据库，类似数组下标从0开始，初始默认使用0号库 使用命令 select <dbid> 来切换数据库。如: select 8 统一密码管理，所有库同样密码。
#dbsize 查看当前数据库的key的数量
#flushdb 清空当前库
#flushall 通杀全部库

（6）、6.2版本配置文件详解

https://raw.githubusercontent.com/redis/redis/6.2/redis.conf

#Redis 配置文件示例。
#
# 注意为了读取配置文件，Redis必须是
# 以文件路径作为第一个参数开始：
#
# ./redis-server /path/to/redis.conf

# 单位注意：当需要内存大小时，可以指定
# 它以通常的 1k 5GB 4M 等形式出现：
#
# 1k => 1000 字节
# 1kb => 1024 字节
# 1m => 1000000 字节
# 1mb => 1024*1024 字节
# 1g => 1000000000 字节
# 1GB => 1024*1024*1024 字节
#
# 单位不区分大小写，所以 1GB 1Gb 1gB 都是一样的。

################################ INCLUDES ############### ####################

# 在此处包含一个或多个其他配置文件。这很有用，如果你
# 有一个适用于所有 Redis 服务器的标准模板，但也需要
# 自定义一些每个服务器的设置。包含文件可以包含
# 其他文件，所以明智地使用它。
#
# 注意选项“include”不会被命令“CONFIG REWRITE”重写
# 来自管理员或 Redis Sentinel。由于 Redis 总是使用最后处理的
# 行作为配置指令的值，你最好把包含
# 在此文件的开头，以避免在运行时覆盖配置更改。
#
# 如果你有兴趣使用包含来覆盖配置
# 选项，最好使用 include 作为最后一行。
#
# 包含 /path/to/local.conf
# 包含 /path/to/other.conf

################################ 模块############### ######################

# 启动时加载模块。如果服务器无法加载模块
# 它将中止。可以使用多个 loadmodule 指令。
#
# 加载模块 /path/to/my_module.so
# 加载模块 /path/to/other_module.so

＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ 网络 ＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ ######################

# 默认情况下，如果没有指定“bind”配置指令，Redis 会监听
# 用于来自主机上所有可用网络接口的连接。
# 可以只听一个或多个选定的接口使用
# "bind" 配置指令，后跟一个或多个 IP 地址。
# 每个地址都可以加“-”前缀，表示redis不会失败
# 如果地址不可用则启动。不可用仅指
# 不对应任何网络接口的地址。地址
# are already in use 总是会失败，不受支持的协议总是会是
#默默跳过。
#
＃ 例子：
#
# bind 192.168.1.100 10.0.0.1 # 监听两个特定的 IPv4 地址
# 绑定 127.0.0.1 ::1 # 监听环回 IPv4 和 IPv6
# 绑定 * -::* # 和默认一样，所有可用的接口
#
#~~~ WARNING ~~~ 如果运行Redis的电脑直接暴露在
# 互联网，绑定到所有接口是危险的，会暴露
# 实例给互联网上的每个人。所以默认情况下我们取消注释
# 遵循绑定指令，这将强制 Redis 只监听
# IPv4 和 IPv6（如果可用）环回接口地址（这意味着 Redis
# 将只能接受来自同一主机的客户端连接
# 继续运行）。
#
# 如果您确定要让您的实例收听所有接口
# 只需注释掉以下行。
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~
bind 127.0.0.1 -::1

# 保护模式是一层安全保护，以避免
# 在互联网上保持打开状态的 Redis 实例被访问和利用。
#
# 当保护模式开启并且如果：
#
# 1) 服务器没有使用显式绑定到一组地址
# “绑定”指令。
# 2) 没有配置密码。
#
# 服务器只接受来自客户端的连接
# IPv4 和 IPv6 环回地址 127.0.0.1 和 ::1，来自 Unix 域
# 套接字。
#
# 默认情况下启用保护模式。您应该仅在以下情况下禁用它
# 您确定要让其他主机的客户端连接到 Redis
# 即使没有配置身份验证，也没有配置特定的接口集
# 使用“bind”指令明确列出。
protected-mode yes

# 接受指定端口上的连接，默认为 6379 (IANA #815344)。
# 如果指定了端口 0，Redis 将不会监听 TCP 套接字。
port 6379

# TCP 监听（）积压。
#
# 在高每秒请求数的环境中，您需要大量的积压订单
# 避免慢速客户端连接问题。请注意，Linux 内核
# 将默默地将其截断为 /proc/sys/net/core/somaxconn 的值，所以
# 确保提高 somaxconn 和 tcp_max_syn_backlog 的值
# 以获得想要的效果。
tcp-backlog 511

# Unix 套接字。
#
# 指定将用于侦听的 Unix 套接字的路径
# 传入连接。没有默认值，所以Redis不会监听
# 未指定时在 unix 套接字上。
#
# unixsocket /run/redis.sock
# unixsocketperm 700

# 客户端空闲 N 秒后关闭连接（0 表示禁用）
timeout 0

# TCP 保持连接。
#
# 如果非零，则使用 SO_KEEPALIVE 发送 TCP ACK 给不存在的客户端
# 沟通。这很有用，原因有二：
#
# 1) 检测死对等点。
#2) 强制中间的网络设备考虑连接
#活着。
#
# 在 Linux 上，指定的值（以秒为单位）是用于发送 ACK 的时间段。
# 注意关闭连接需要双倍的时间。
# 在其他内核上，周期取决于内核配置。
#
# 这个选项的合理值是 300 秒，这是新的
# Redis 默认从 Redis 3.2.1 开始。
tcp-keepalive 300

############################### TLS/SSL ############# #######################

# 默认情况下，TLS/SSL 处于禁用状态。要启用它，“tls-port”配置
# 指令可用于定义 TLS 侦听端口。启用 TLS
# 默认端口，使用：
#
# 端口 0
# tls 端口 6379

# 配置 X.509 证书和私钥以用于验证
# 服务器连接到客户端、主节点或集群节点。这些文件应该是
# PEM 格式。
#
# tls-cert-file redis.crt 
# tls-key-file redis.key
#
# 如果密钥文件是使用密码加密的，则可以将其包含在此处
#也一样。
#
# tls-key-file-pass 秘密

# 通常Redis对两个服务器功能使用相同的证书（接受
# 连接）和客户端功能（从主服务器复制，建立
# 集群总线连接等）。
#
# 有时颁发的证书带有将它们指定为的属性
# 仅限客户端或仅限服务器的证书。在这种情况下，可能需要使用
# 传入（服务器）和传出（客户端）的不同证书
# 连接。为此，请使用以下指令：
#
# tls-client-cert-file client.crt
# tls-client-key-file client.key
#
# 如果密钥文件是使用密码加密的，则可以将其包含在此处
#也一样。
#
# tls-client-key-file-pass 秘密

# 配置DH参数文件以启用Diffie-Hellman（DH）密钥交换：
#
# tls-dh-params-file redis.dh

# 配置 CA 证书包或目录以验证 TLS/SSL
# 客户和同行。Redis 需要至少一个显式配置
# 这些，并且不会隐式使用系统范围的配置。
#
# tls-ca-cert-file ca.crt
# tls-ca-cert-dir /etc/ssl/certs

# 默认情况下，TLS 端口上的客户端（包括副本服务器）是必需的
# 使用有效的客户端证书进行身份验证。
#
# 如果指定“no”，则不需要且不接受客户端证书。
# 如果指定了“可选”，客户端证书被接受并且必须是
# 如果提供则有效，但不是必需的。
#
# tls-auth-clients 没有
# tls-auth-clients 可选

# 默认情况下，Redis 副本不会尝试建立 TLS 连接
# 与它的主人。
#
# 使用以下指令在复制链接上启用 TLS。
#
# tls-replication 是

# 默认情况下，Redis Cluster 总线使用普通 TCP 连接。启用
# TLS 为总线协议，使用以下指令：
#
# tls-cluster 是

# 默认情况下，只启用了 TLSv1.2 和 TLSv1.3，强烈推荐
# 旧的正式弃用版本保持禁用状态以减少攻击面。
# 您可以明确指定要支持的 TLS 版本。
# 允许的值不区分大小写，包括“TLSv1”、“TLSv1.1”、“TLSv1.2”、
# "TLSv1.3" (OpenSSL >= 1.1.1) 或任意组合。
# 要仅启用 TLSv1.2 和 TLSv1.3，请使用：
#
# tls-protocols "TLSv1.2 TLSv1.3"

# 配置允许的密码。有关详细信息，请参阅 ciphers(1ssl) 联机帮助页
# 关于这个字符串的语法。
#
# 注意：此配置仅适用于<= TLSv1.2。
#
# tls-ciphers DEFAULT:!MEDIUM

# 配置允许的TLSv1.3 ciphersuites。有关更多信息，请参阅 ciphers(1ssl) 联机帮助页
# 关于这个字符串的语法的信息，特别是 TLSv1.3
# 密码套件。
#
# tls-ciphersuites TLS_CHACHA20_POLY1305_SHA256

# 选择密码时，使用服务器的首选项而不是客户端
# 偏爱。默认情况下，服务器遵循客户端的偏好。
#
# tls-prefer-server-ciphers 是

# 默认情况下，启用 TLS 会话缓存以允许更快和更便宜
# 由支持它的客户端重新连接。使用以下指令禁用
# 缓存。
#
# tls-session-caching 没有

# 更改缓存的默认 TLS 会话数。零值设置缓存
# 到无限大小。默认大小为 20480。
#
# tls-session-cache-size 5000

# 更改缓存 TLS 会话的默认超时时间。默认超时时间为 300
#秒。
#
# tls-session-cache-timeout 60

＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ 一般的 ＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ #####################

# 默认情况下，Redis 不作为守护进程运行。如果需要，请使用“是”。
# 注意Redis在daemonized时会在/var/run/redis.pid中写入pid文件。
# 当Redis被upstart或者systemd监管时，这个参数没有影响。
daemonize no

# 如果您从 upstart 或 systemd 运行 Redis，Redis 可以与您的
# 监督树。选项：
# 没有监督 - 没有监督交互
# 受监督的暴发户 - 通过将 Redis 置于 SIGSTOP 模式来向暴发户发出信号
# 在你的新贵工作配置中需要“expect stop”
# 受监督的 systemd - 通过将 READY=1 写入 $NOTIFY_SOCKET 来向 systemd 发出信号
# 启动时，定期更新Redis状态
# 基础。
# 监督自动 - 检测 upstart 或 systemd 方法基于
# UPSTART_JOB 或 NOTIFY_SOCKET 环境变量
# 注意：这些监督方法只发出“进程准备就绪”的信号。
# 他们不能连续 ping 回你的主管。
#
# 默认为“否”。要在 upstart/systemd 下运行，您可以简单地取消注释
# 下面一行：
#
# 监督自动

# 如果指定了pid文件，Redis在启动时将其写入指定位置
# 并在退出时将其删除。
#
# 当服务器运行非守护进程时，如果没有，则不创建 pid 文件
# 在配置中指定。当服务器被守护时，pid 文件
# 即使未指定也会使用，默认为“/var/run/redis.pid”。
#
# 创建一个pid文件是最好的努力：如果Redis不能创建它
# 没有什么不好的事情发生，服务器将正常启动和运行。
#
# 请注意，在现代 Linux 系统上，"/run/redis.pid" 更符合标准
# 并且应该被使用。
pidfile /var/run/redis_6379.pid

# 指定服务器详细级别。
# 这可以是以下之一：
# debug（很多信息，对开发/测试有用）
# 详细（许多很少有用的信息，但不像调试级别那样混乱）
# 通知（适度冗长，你可能在生产中想要什么）
# 警告（只记录非常重要/关键的消息）
loglevel notice

# 指定日志文件名。空字符串也可用于强制
# Redis 登录标准输出。请注意，如果您使用标准
# 日志输出但守护进程，日志将发送到/dev/null
logfile ""

# 要启用系统记录器的日志记录，只需将 'syslog-enabled' 设置为 yes，
# 并可选择更新其他系统日志参数以满足您的需要。
# 启用系统日志 否

# 指定系统日志标识。
# syslog-ident redis

# 指定系统日志工具。必须是 USER 或介于 LOCAL0-LOCAL7 之间。
# syslog-facility local0

# 禁用内置崩溃日志，这可能会产生更清洁的内核
# 需要时转储，取消注释以下内容：
#
# 启用崩溃日志 否

# 禁用作为崩溃日志的一部分运行的快速内存检查，
# 可能会让 redis 更快终止，取消注释以下内容：
#
# crash-memcheck-enabled 没有

# 设置数据库数量。默认数据库是DB 0，可以选择
# 在每个连接的基础上使用 SELECT <dbid> 一个不同的，其中
# dbid 是一个介于 0 和 'databases'-1 之间的数字
databases 16

# 默认情况下，Redis 仅在开始登录时显示 ASCII 艺术标志
# 标准输出，如果标准输出是 TTY 并且系统日志是
# 禁用。基本上这意味着通常一个标志只显示在
# 互动环节。
#
# 但是，可以强制执行 4.0 之前的行为并始终显示
# 通过将以下选项设置为 yes，启动日志中的 ASCII 艺术标志。
always-show-logo no

# 默认情况下，Redis将进程标题（如'top'和'ps'中看到的）修改为
# 提供一些运行时信息。可以禁用此功能并离开
# 通过将以下设置为 no 执行的进程名称。
set-proc-title yes

# 更改进程标题时，Redis使用如下模板构建
# 修改后的标题。
#
# 模板变量在大括号中指定。以下变量是
# 支持的：
#
# {title} 执行的进程名称（如果是父进程）或子进程的类型。
# {listen-addr} 绑定地址或 '*' 后跟 TCP 或 TLS 端口监听，或
# Unix 套接字，如果只有它可用。
# {server-mode} 特殊模式，即“[sentinel]”或“[cluster]”。
# {port} TCP 端口监听，或 0。
# {tls-port} TLS 端口监听，或 0。
# {unixsocket} Unix 域套接字侦听，或“”。
# {config-file} 使用的配置文件的名称。
#
proc-title-template "{title} {listen-addr} {server-mode}"

############################## 快照################# ################

# 将数据库保存到磁盘。
#
# 保存 <秒> <更改>
#
# 如果给定的秒数和给定的时间，Redis 将保存数据库
# 发生对 DB 的写操作数。
#
# 可以使用单个空字符串参数完全禁用快照
# 如下例：
#
# save ""
#
# 除非另有说明，默认情况下Redis将保存数据库：
# * 3600 秒（一小时）后，如果至少更改了 1 个键
# * 300 秒（5 分钟）后，如果至少有 100 个键更改
# * 如果至少有 10000 个键更改，则 60 秒后
#
# 您可以通过取消注释以下三行来显式设置这些。
#
# save 3600 1
# save 300 100
# save 60 10000

# 默认情况下，如果启用了 RDB 快照，Redis 将停止接受写入
#（至少一个保存点）和最新的后台保存失败。
# 这将使用户意识到（以一种艰难的方式）数据不是持久化的
# 正确地在磁盘上，否则很可能没有人会注意到，有些人会注意到
#灾难会发生。
#
# 如果后台保存进程重新开始工作，Redis 将
# 自动允许再次写入。
#
# 但是，如果您已经设置了对 Redis 服务器的适当监控
# 和持久性，你可能想禁用这个功能，以便 Redis
# 继续照常工作，即使磁盘有问题，
# 权限等。
stop-writes-on-bgsave-error yes

# 在转储 .rdb 数据库时使用 LZF 压缩字符串对象？
# 默认情况下启用压缩，因为它几乎总是一个胜利。
# 如果你想在保存子节点中节省一些 CPU 将其设置为“否”但是
# 如果您有可压缩的值或键，数据集可能会更大。
rdbcompression yes

# 由于 RDB 的第 5 版，CRC64 校验和被放置在文件的末尾。
# 这使得格式更能抵抗损坏，但有一个性能
# 保存和加载 RDB 文件时点击支付（大约 10%），因此您可以禁用它
# 以获得最佳性能。
#
# 在禁用校验和的情况下创建的 RDB 文件的校验和为零
# 告诉加载代码跳过检查。
rdbchecksum yes

# 启用或禁用对 ziplist 和 listpack 等的完整卫生检查，当
# 加载 RDB 或 RESTORE 负载。这减少了断言或
# 稍后在处理命令时崩溃。
# 选项：
# no - 永远不要进行全面卫生
# 是 - 始终执行全面卫生
# 客户端 - 仅对用户连接执行完全卫生。
# 不包括：RDB 文件、从 master 收到的 RESTORE 命令
# 连接，以及具有
#skip-sanitize-payload ACL 标志。
# 默认应该是 'clients' 但因为它当前影响集群
# 通过 MIGRATE 重新分片，默认情况下暂时设置为“no”。
#
# sanitize-dump-payload no

# 转储数据库的文件名
dbfilename dump.rdb

# 删除非持久化实例中复制使用的RDB文件
# 启用。默认情况下禁用此选项，但是有环境
# 出于法规或其他安全考虑，RDB 文件保留在何处
# 磁盘由主节点提供副本，或由副本存储在磁盘上
# 为了加载它们用于初始同步，应该删除
# 尽快。请注意，此选项仅适用于同时具有 AOF
# 和 RDB 持久化禁用，否则完全忽略。
#
# 获得相同效果的另一种（有时更好）方法是
# 在主实例和副本实例上使用无盘复制。然而
# 在副本的情况下，无盘并不总是一种选择。
rdb-del-sync-files no

# 工作目录。
#
# 数据库将写入此目录中，并指定文件名
# 以上使用“dbfilename”配置指令。
#
# 附加文件也将在此目录中创建。
#
# 注意这里必须指定目录，而不是文件名。
dir ./

############################### 复制################ #################

# 主副本复制。使用replicaof使Redis实例复制
# 另一个Redis服务器。需要尽快了解 Redis 复制的一些事项。
#
# +------------------------+ +--------------+
# | 硕士 | ---> | 副本 |
# | （接收写入） | | （精确副本） |
# +------------------------+ +--------------+
#
# 1) Redis 复制是异步的，但是你可以配置一个master
# 停止接受写入，如果它似乎与至少没有连接
# 给定数量的副本。
# 2) Redis 副本能够与
# master 如果复制链接丢失相对较少
# 时间。您可能需要配置复制积压大小（请参阅下一个
# 本文件的部分）根据您的需要具有合理的值。
# 3) 复制是自动的，不需要用户干预。之后
# 网络分区副本自动尝试重新连接到主节点
# 并与它们重新同步。
#
#replicaof <masterip> <masterport>

# 如果 master 受密码保护（使用“requirepass”配置
#下面的指令）可以告诉副本之前进行身份验证
# 启动复制同步过程，否则master会
# 拒绝副本请求。
#
# masterauth <主密码>
#
# 但是，如果您使用 Redis ACL，这还不够（对于 Redis 版本
# 6 或更高），并且默认用户无法运行 PSYNC
# 命令和/或复制所需的其他命令。在这种情况下是
# 最好配置一个特殊用户用于复制，并指定
# masteruser 配置如下：
#
# masteruser <用户名>
#
# 当 masteruser 被指定时，副本将对其进行身份验证
# master 使用新的 AUTH 形式：AUTH <username> <password>。

# 当一个副本失去与主的连接时，或者当复制时
# 仍在进行中，副本可以以两种不同的方式运行：
#
# 1) 如果 replica-serve-stale-data 设置为“yes”（默认），副本将
# 仍然回复客户端请求，可能有过时的数据，或者
# 如果这是第一次同步，数据集可能只是空的。
#
# 2) 如果replica-serve-stale-data 设置为'no'，副本将回复
# 除以下命令外，所有命令都出现“SYNC with master in progress”错误：
# INFO, REPLICAOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG, SUBSCRIBE,
# 取消订阅、订阅、取消订阅、发布、发布订阅、命令、发布、
# 主机和延迟。
#
replica-serve-stale-data yes

# 您可以配置副本实例接受或不接受写入。写反对
# 副本实例可能有助于存储一些临时数据（因为数据
# 写在副本上的在与主服务器重新同步后很容易被删除）但是
# 如果客户端写入它，也可能会导致问题
# 错误配置。
#
# 由于 Redis 2.6 默认副本是只读的。
#
# 注意：只读副本不会暴露给不受信任的客户端
# 在网上。它只是一个防止滥用实例的保护层。
# 仍然是只读副本默认导出所有管理命令
# 如 CONFIG、DEBUG 等。在有限的范围内，您可以改进
# 只读副本的安全性使用“重命名命令”来隐藏所有
# 管理/危险命令。
replica-read-only yes

# 复制同步策略：磁盘或套接字。
#
# 无法继续的新副本和重新连接的副本
# 复制过程只是接收差异，需要做所谓的a
#“完全同步”。RDB 文件从 master 传输到
# 副本。
#
# 传输可以通过两种不同的方式发生：
#
# 1）Disk-backed：Redis master创建一个新的进程来写入RDB
# 磁盘上的文件。后来文件由父传输
# 以增量方式处理副本。
# 2) 无盘：Redis master 创建一个新进程，直接写入
# RDB 文件复制套接字，根本不接触磁盘。
#
# 使用磁盘备份复制，在生成 RDB 文件的同时，更多的副本
# 可以在当前子进程中排队并与 RDB 文件一起提供服务
# 生成 RDB 文件完成它的工作。用无盘复制代替
# 一旦传输开始，新的副本到达将排队，一个新的
# 传输将在当前终止时开始。
#
# 当使用无盘复制时，master 等待一个可配置的数量
# 开始传输前的时间（以秒为单位），希望多次
# 副本将到达并且传输可以并行化。
#
# 使用慢速磁盘和快速（大带宽）网络，无盘复制
# 效果更好。
repl-diskless-sync no

# 启用无盘复制时，可以配置延迟
# 服务器等待以生成通过套接字传输 RDB 的子进程
# 到副本。
#
# 这很重要，因为一旦传输开始，就无法提供服务
# 新副本到达，将排队等待下一次 RDB 传输，因此
# 服务器等待延迟以便让更多副本到达。
#
# 延迟以秒为单位指定，默认为 5 秒。禁用
# 它完全只是将其设置为 0 秒，传输将尽快开始。
repl-diskless-sync-delay 5

# ------------------------------------------------- -----------------------------
# 警告：RDB 无盘负载是实验性的。由于在此设置中复制品
# 不会立即将 RDB 存储在磁盘上，可能会导致数据丢失
# 故障转移。RDB 无盘负载 + Redis 模块不处理 I/O 读取也可能
# 导致Redis在初始同步过程中出现I/O错误时中止
# 与主人一起舞台。仅当您知道自己在做什么时才使用。
# ------------------------------------------------- -----------------------------
#
# Replica可以直接从replica加载它从replication link读取的RDB
# 套接字，或者将 RDB 存储到一个文件中，并在它完全完成后读取该文件
# 从主人那里收到。
#
# 很多情况下磁盘比网络慢，存储和加载
# RDB 文件可能会增加复制时间（甚至会增加 master 的
# 复制写入内存和备用缓冲区）。
# 然而，直接从套接字解析 RDB 文件可能意味着我们有
# 在整个 rdb 被刷新之前刷新当前数据库的内容
# 已收到。为此，我们有以下选择：
#
# "disabled" - 不要使用无盘加载（先将 rdb 文件存储到磁盘）
# "on-empty-db" - 只有在完全安全的情况下才使用无盘加载。
# "swapdb" - 解析时在 RAM 中保留当前数据库内容的副本
# 直接来自套接字的数据。请注意，这需要
# 足够的内存，如果你没有它，你就有被 OOM 杀死的风险。
repl-disk-load 禁用

# 副本在预定义的时间间隔内向服务器发送 PING。有可能
# 使用 repl_ping_replica_period 选项更改此间隔。默认的
# 值为 10 秒。
#
# repl-ping-replica-period 10

# 以下选项设置复制超时：
#
# 1) 从副本的角度来看，SYNC 期间的批量传输 I/O。
#2) 从副本（数据，ping）的角度来看主超时。
# 3) 从主节点的角度来看副本超时（REPLCONF ACK ping）。
#
# 重要的是要确保这个值大于这个值
# 指定为 repl-ping-replica-period 否则会检测到超时
# 每次 master 和副本之间的流量较低时。默认的
# 值为 60 秒。
#
# repl-timeout 60

# 在同步后禁用副本套接字上的 TCP_NODELAY？
#
# 如果选择“是”Redis 将使用较少数量的 TCP 数据包和
# 减少将数据发送到副本的带宽。但这会增加延迟
# 数据出现在副本端，最多 40 毫秒
# Linux 内核使用默认配置。
#
# 如果选择“no”，则数据在副本端出现的延迟将
# 减少，但更多的带宽将用于复制。
#
# 默认情况下，我们优化低延迟，但在非常高的流量条件下
# 或者当 master 和 replicas 相距很多跳时，将其设置为“yes”可能
# 是个好主意。
repl-disable-tcp-nodelay no

# 设置复制backlog大小。积压是累积的缓冲区
# 当副本断开一段时间时复制数据，这样当一个
# 副本想要再次重新连接，通常不需要完全重新同步，但是
# 部分重新同步就足够了，只需将部分数据传递给副本
# 断开连接时丢失。
#
# 复制积压越大，副本可以承受的时间越长
# 断开连接，稍后能够执行部分重新同步。
#
# 只有至少有一个副本连接时才会分配积压。
#
# repl-backlog-size 1mb

# 一个master一段时间没有连接的replicas后，backlog会变成
#释放。以下选项配置需要的秒数
# 过去，从最后一个副本断开连接的时间开始，对于积压
# 要释放的缓冲区。
#
# 请注意，副本永远不会因超时而释放积压，因为它们可能是
# 后期晋升大师，应该可以正确“部分
# 与其他副本重新同步”：因此它们应该总是累积积压。
#
# 值为 0 表示永远不会释放积压。
#
# repl-backlog-ttl 3600

# 副本优先级是Redis在INFO中发布的整数
# 输出。Redis Sentinel 使用它来选择要提升的副本
# 如果 master 不再正常工作，则进入 master。
#
# 优先级低的副本被认为更适合提升，所以
# 例如，如果有三个副本的优先级分别为 10、100、25 Sentinel
# 将选择优先级为 10 的那个，即最低的。
#
# 然而，一个特殊的优先级 0 将副本标记为无法执行
# master 的角色，所以优先级为 0 的副本永远不会被选中
# Redis Sentinel 进行推广。
#
# 默认优先级为100。
replica-priority 100

# ------------------------------------------------- -----------------------------
# 默认情况下，Redis Sentinel 在其报告中包含所有副本。复制品
# 可以从Redis Sentinel的公告中排除。一个未公布的复制品
# 将被 'sentinel replicas <master>' 命令忽略并且不会被
# 暴露给 Redis Sentinel 的客户端。
#
# 该选项不会改变副本优先级的行为。即使
#replica-announced 设置为'no'，副本可以提升为主。到
# 防止这种行为，将副本优先级设置为 0。
#
# 副本宣布是

# 如果少于
# N 个副本连接，延迟小于或等于 M 秒。
#
# N 个副本需要处于“在线”状态。
#
# 以秒为单位的延迟，必须 <= 指定的值，计算公式为
# 从副本收到的最后一个 ping，通常每秒发送一次。
#
# 这个选项不保证N个副本会接受写，但是
# 将限制丢失写入的暴露窗口，以防没有足够的副本
# 可用，到指定的秒数。
#
# 例如，需要至少 3 个延迟 <= 10 秒的副本，请使用：
#
# min-replicas-to-write 3
# min-replicas-max-lag 10
#
# 将一个或另一个设置为 0 将禁用该功能。
#
# 默认情况下，min-replicas-to-write 设置为 0（禁用功能）和
# min-replicas-max-lag 设置为 10。

# Redis master 能够列出附加的地址和端口
# 以不同方式复制。例如“信息复制”部分
# 提供此信息，除其他工具外，这些信息由
# Redis Sentinel 以发现副本实例。
# 此信息可用的另一个地方是在输出
# "ROLE" 命令的主人。
#
# 副本通常报告的列出的IP地址和端口是
# 获取方式如下：
#
# IP：通过检查对端地址自动检测地址
# 副本用于连接主服务器的套接字的。
#
# 端口：复制期间副本通信的端口
# 握手，通常是副本使用的端口
# 监听连接。
#
# 但是，当端口转发或网络地址转换 (NAT) 为
# 使用，副本实际上可以通过不同的 IP 和端口访问
# 对。副本可以使用以下两个选项来
# 向其主控报告一组特定的 IP 和端口，以便双方 INFO
# 和 ROLE 将报告这些值。
#
# 如果您只需要覆盖，则无需同时使用这两个选项
#端口或IP地址。
#
#replica-announce-ip 5.5.5.5
#replica-announce-port 1234

############################# 密钥跟踪################# ################

# Redis 实现了对客户端值缓存的服务器辅助支持。
# 这是使用记住的失效表实现的，使用
# 一个由键名索引的基数键，什么客户端有哪些键。反过来
# 这用于向客户端发送失效消息。请
# 查看此页面以了解有关该功能的更多信息：
#
# https://redis.io/topics/client-side-caching
#
# 为客户端启用跟踪时，假定所有只读查询
# to be cached：这将强制Redis在失效中存储信息
# 桌子。当键被修改时，这些信息会被清除，并且
# 失效消息被发送到客户端。但是，如果工作量是
# 以读取为主，Redis 可以按顺序使用越来越多的内存
# 跟踪许多客户端获取的密钥。
#
# 出于这个原因，可以配置一个最大填充值
# 失效表。默认情况下它设置为 1M 的密钥，一旦这个限制
# 达到，Redis 将开始驱逐失效表中的键
# 即使它们没有被修改，也只是为了回收内存：这会反过来
# 强制客户端使缓存的值无效。基本上是表
# 最大大小是您要花费服务器的内存之间的权衡
# side 跟踪谁缓存了什么信息，以及客户端的能力
# 将缓存的对象保留在内存中。
#
# 如果设置为0，则表示没有限制，Redis会
# 根据需要在失效表中保留尽可能多的键。
# 在“统计”信息部分，您可以找到有关数量的信息
# 在每个给定时刻失效表中的键。
#
# 注意：在广播模式下使用按键跟踪时，不使用内存
# 在服务器端所以这个设置没用。
#
# tracking-table-max-keys 1000000

＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ 安全 ＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ ####################

# 警告：由于 Redis 速度非常快，外部用户可以尝试
# 每秒 100 万个密码在现代机器上。这意味着你
# 应该使用很强的密码，否则很容易破解。
# 注意因为密码真的是客户端之间共享的秘密
# 和服务器，不应该被任何人记住，密码
# 可以很容易地成为 /dev/urandom 或其他任何东西的长字符串，因此通过使用
# 长且不可猜测的密码不可能进行强力攻击。

# Redis ACL 用户的定义格式如下：
#
# 用户 <用户名> ... acl 规则 ...
#
# 例如：
#
# user worker +@list +@connection ~jobs:* on >ffa9203c493aa99
#
# 特殊用户名“default”用于新连接。如果这个用户
# 有“nopass”规则，那么新的连接将立即被认证
# 作为“默认”用户，不需要通过提供的任何密码
# AUTH 命令。否则，如果“默认”用户没有被标记为“nopass”
# 连接将以未验证状态开始，并且需要
# AUTH（或 HELLO 命令 AUTH 选项）以便进行身份验证和
# 开始工作。
#
# 描述用户可以做什么的 ACL 规则如下：
#
# on 启用用户：可以作为该用户进行身份验证。
# off 禁用用户：无法再进行身份验证
# 使用这个用户，但是已经通过身份验证的连接
# 仍然有效。
# skip-sanitize-payload RESTORE dump-payload 卫生被跳过。
# sanitize-payload RESTORE dump-payload 已清理（默认）。
# +<command> 允许执行该命令
# -<command> 禁止执行该命令
# +@<category> 允许执行该类别中的所有命令
# 有效类别如@admin, @set, @sortedset, ...
# 等等，请查看 server.c 文件中的完整列表，其中
# Redis 命令表的描述和定义。
# 特殊类别@all 表示所有命令，但目前
# 存在于服务器中，将来会加载
# 通过模块。
# +<command>|subcommand 允许一个其他的特定子命令
# 禁用命令。注意这个表格不是
# 允许像 -DEBUG|SEGFAULT 这样的负数，但是
# 仅以“+”开头的添加剂。
# allcommands +@all 的别名。请注意，它意味着能够执行
# 通过模块系统加载的所有未来命令。
# nocommands -@all 的别名。
# ~<pattern> 添加可以作为一部分提及的键的模式
# 命令。例如 ~* 允许所有键。图案
# 是一种类似于 KEYS 的全局样式模式。
# 可以指定多个模式。
# allkeys ~* 的别名
# resetkeys 刷新允许的键模式列表。
# &<pattern> 添加 glob 样式的 Pub/Sub 通道模式，可以
# 用户访问。可以指定多个通道
# 模式。
# allchannels &* 的别名
# resetchannels 刷新允许的通道模式列表。
# ><password> 将此密码添加到用户的有效密码列表中。
# 例如 >mypass 会将“mypass”添加到列表中。
# 该指令清除“nopass”标志（见下文）。
# <<password> 从有效密码列表中删除此密码。
# nopass 把用户设置的密码全部去掉，用户
# 被标记为不需要密码：这意味着每个
# 密码将对这个用户起作用。如果这个指令是
# 用于默认用户，每个新连接都会
# 立即使用默认用户进行身份验证，无需
# 需要任何明确的 AUTH 命令。注意“resetpass”
# 指令将清除此条件。
# resetpass 刷新允许的密码列表。此外删除
# "nopass" 状态。“resetpass”后用户没有关联
# 密码，没有添加就无法进行身份验证
# 一些密码（或稍后将其设置为“nopass”）。
# reset 执行以下操作：resetpass、resetkeys、off、
# -@全部。用户立即返回到相同的状态
# 在它创建之后。
#
# ACL 规则可以按任何顺序指定：例如，您可以从
# 密码，然后是标志或密钥模式。但请注意，添加剂
# 和减法规则将根据顺序改变含义。
# 例如看下面的例子：
#
# user alice on +@all -DEBUG ~* >somepassword
#
# 这将允许“alice”使用所有命令，除了
# DEBUG 命令，因为 +@all 将所有命令添加到命令集中
# alice 可以用，后来DEBUG被去掉了。但是，如果我们颠倒顺序
# 两条 ACL 规则的结果将不同：
#
# 用户 alice 在 -DEBUG +@all ~* >somepassword
#
# 现在当 alice 在允许的集合中没有命令时，DEBUG 被删除
# 命令，之后所有的命令都被添加了，这样用户就可以
# 执行一切。
#
# 基本上 ACL 规则是从左到右处理的。
#
# ACL配置的更多信息请参考
# Redis 网站 https://redis.io/topics/acl

# ACL 日志
#
# ACL 日志跟踪失败的命令和关联的身份验证事件
# 带有 ACL。ACL 日志可用于对被阻止的失败命令进行故障排除
# 通过 ACL。ACL 日志存储在内存中。你可以回收内存
# ACL 日志重置。在下面定义 ACL 日志的最大条目长度。
acllog-max-len 128

# 使用外部 ACL 文件
#
# 不是在这个文件这里配置用户，而是可以使用
# 一个只列出用户的独立文件。这两种方法不能混用：
# 如果你在这里配置用户，同时你激活了外部
# ACL 文件，服务器将拒绝启动。
#
# 外部ACL用户文件的格式和上面的完全一样
# 在 redis.conf 中用于描述用户的格式。
#
# aclfile /etc/redis/users.acl

# 重要提示：从 Redis 6 开始，“requirepass”只是一种兼容性
# 位于新 ACL 系统之上的层。选项效果将只是设置
# 默认用户的密码。客户端仍将使用身份验证
# AUTH <password> 像往常一样，或者更明确地使用 AUTH 默认 <password>
# 如果他们遵循新协议：两者都可以工作。
#
# requirepass 与 aclfile 选项和 ACL LOAD 不兼容
# 命令，这些将导致 requirepass 被忽略。
#
# requirepass foobared

# 默认情况下，新用户使用限制性权限进行初始化，通过
# 相当于这个 ACL 规则 'off resetkeys -@all'。从 Redis 6.2 开始，它
# 也可以使用 ACL 规则管理对 Pub/Sub 频道的访问。这
# 如果新用户受控制，则默认发布/订阅频道权限 
# acl-pubsub-default 配置指令，它接受以下值之一：
#
# allchannels：授予对所有 Pub/Sub 频道的访问权限
# resetchannels：撤销对所有 Pub/Sub 频道的访问权限
#
# 为确保在升级Redis 6.0时向后兼容，acl-pubsub-default
# 默认为“allchannels”权限。
#
# 未来兼容性注意事项：很有可能在未来的Redis版本中
# 指令的默认值“allchannels”将更改为“resetchannels”
# 为了提供更好的开箱即用的 Pub/Sub 安全性。因此它是
# 建议您为所有用户明确定义 Pub/Sub 权限
# 而不是依赖隐式默认值。一旦你设置了显式
# Pub/Sub 对于所有现有用户，您应该取消注释以下行。
#
# acl-pubsub-default resetchannels

# 命令重命名（已弃用）。
#
# ------------------------------------------------- -----------------------
# 警告：如果可能，请避免使用此选项。而是使用 ACL 来删除
# 来自默认用户的命令，并将它们仅放在您的某些管理员用户中
# 出于管理目的而创建。
# ------------------------------------------------- -----------------------
#
# 可以在共享中更改危险命令的名称
# 环境。例如 CONFIG 命令可以重命名为一些东西
# 难以猜测，因此它仍可用于内部使用的工具
# 但不适用于一般客户。
#
# 例子：
#
# 重命名命令配置 b840fc02d524045429941cc15f59e41cb7be6c52
#
# 也可以通过将命令重命名为完全杀死命令
# 空字符串：
#
# 重命名命令配置“”
#
# 请注意，更改登录到的命令的名称
# AOF 文件或传输到副本可能会导致问题。

################################# 客户############## ######################

# 设置同时连接的最大客户端数。默认情况下
# 此限制设置为 10000 个客户端，但是如果 Redis 服务器不是
# 能够配置进程文件限制以允许指定的限制
# 允许的最大客户端数设置为当前文件限制
# 减去 32（因为 Redis 保留了一些文件描述符供内部使用）。
#
# 一旦达到限制，Redis 将关闭所有发送的新连接
# 错误“达到最大客户端数”。
#
# 重要：当使用Redis Cluster时，最大连接数也是
# 与集群总线共享：集群中的每个节点都会使用两个
# 连接，一个传入，另一个传出。调整大小很重要
# 在非常大的集群的情况下相应地进行限制。
#
# maxclients  10000

＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ 内存管理 ＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃ ##############

# 将内存使用限制设置为指定的字节数。
# 当达到内存限制时，Redis 将尝试删除键
# 根据选择的驱逐策略（参见 maxmemory-policy）。
#
# 如果Redis不能根据策略删除key，或者如果策略是
# 设置为'noeviction'，Redis 将开始回复错误命令
# 会使用更多内存，如 SET、LPUSH 等，并将继续
# 回复像 GET 这样的只读命令。
#
# 这个选项在使用 Redis 作为 LRU 或 LFU 缓存时通常很有用，或者
# 为实例设置硬内存限制（使用“noeviction”策略）。
#
# 警告：如果您将副本附加到启用了 maxmemory 的实例，
# 减去提供副本所需的输出缓冲区的大小
# 从使用的内存计数，以便网络问题/重新同步
# 不触发一个循环，其中键被逐出，然后输出
# 副本缓冲区已满，被驱逐的键的 DEL 触发删除
# 更多的键，依此类推，直到数据库完全清空。
#
# 简而言之...如果您附加了副本，建议您设置一个较低的
# 限制 maxmemory 以便系统上有一些空闲 RAM 用于副本
# 输出缓冲区（但如果策略是“noeviction”则不需要）。
#
# maxmemory <字节>

# MAXMEMORY POLICY：当达到最大内存时，Redis 将如何选择要删除的内容
# 到达了。您可以从以下行为中选择一种：
#
# volatile-lru -> Evict 使用近似 LRU，只有带有过期集的键。
# allkeys-lru -> 使用近似 LRU 驱逐任何键。
# volatile-lfu -> 使用近似 LFU 驱逐，只有设置了过期时间的键。
# allkeys-lfu -> 使用近似 LFU 驱逐任何键。
# volatile-random -> 删除设置了过期时间的随机密钥。
# allkeys-random -> 删除一个随机密钥，任何密钥。
# volatile-ttl -> 删除过期时间最近的key（次TTL）
# noeviction -> 不要驱逐任何东西，只是在写操作时返回一个错误。
#
# LRU 表示最近最少使用
# LFU 表示最不常用
#
# LRU、LFU 和 volatile-ttl 都是使用近似实现的
# 随机算法。
#
# 注意：使用上述任何一种策略，当没有合适的密钥时
# eviction, Redis 将在需要的写操作上返回错误
# 更多内存。这些通常是创建新密钥、添加数据或
# 修改现有的键。几个例子是：SET、INCR、HSET、LPUSH、SUNIONSTORE、
# SORT（由于 STORE 参数）和 EXEC（如果交易包括任何
# 需要内存的命令）。
#
# 默认为：
#
# maxmemory-policy noeviction

# LRU、LFU 和最小 TTL 算法不是精确算法而是近似算法
# 算法（为了节省内存），所以你可以调整它的速度或
# 准确性。默认情况下，Redis 将检查五个键并选择一个
# 最近最少使用，您可以使用以下命令更改样本大小
# 配置指令。
#
# 默认值 5 会产生足够好的结果。10 非常接近
# 真正的 LRU 但花费更多的 CPU。3 更快，但不是很准确。
#
# 最大内存样本 5

# 驱逐处理设计为在默认设置下运行良好。
# 如果有异常大的写流量，这个值可能需要
# 增加。降低此值可能会减少延迟，但有以下风险
# 驱逐处理有效性
# 0 = 最小延迟，10 = 默认，100 = 不考虑延迟的进程
#
# 最大内存驱逐坚韧 10

# 从 Redis 5 开始，默认情况下副本将忽略其 maxmemory 设置
#（除非在故障转移后或手动将其提升为 master）。它的意思是
# 密钥的驱逐将仅由 master 处理，发送
# DEL 命令到副本作为键在主端驱逐。
#
# 这个行为保证了masters和replicas保持一致，通常是
# 你想要什么，但是如果你的副本是可写的，或者你想要副本
# 具有不同的内存设置，并且您确定所有写入都已执行
# 到副本是幂等的，那么你可以改变这个默认值（但要确保
# 了解你在做什么）。
#
# 请注意，由于默认情况下副本不会驱逐，因此它可能会结束使用更多
# 内存比通过 maxmemory 设置的内存（有某些缓冲区可能
# 在副本上更大一些，否则数据结构有时可能会占用更多内存
# 等等）。因此，请确保您监控您的副本并确保它们
# 有足够的内存永远不会遇到真正的内存不足情况
# master 命中配置的 maxmemory 设置。
#
#replica-ignore-maxmemory 是

# Redis 以两种方式回收过期的键：当这些键被访问时
# 发现已过期，也在后台，在所谓的
#“活动过期密钥”。按键空间缓慢交互扫描
# 寻找过期的键来回收，以便可以释放内存
# 已过期且在短时间内永远不会再次访问的密钥。
#
# 过期周期的默认努力将尽量避免超过
# 10% 的过期键仍在内存中，并且会尽量避免消耗
# 超过总内存的 25% 并增加系统延迟。然而
# 可以增加通常设置为的过期“努力”
# "1", 到更大的值，直到值 "10"。在其最大值时
# 系统会使用更多的 CPU，更长的周期（技术上可能会引入
# 更多延迟），并且可以容忍更少的已经过期的密钥仍然存在
#在系统中。这是内存、CPU 和延迟之间的权衡。
#
# 主动过期努力 1

########################### 懒惰释放################## #################

# Redis 有两个原语来删除键。一个叫做 DEL，是一个阻塞
# 删除对象。这意味着服务器停止处理新命令
# 为了在同步中回收与对象关联的所有内存
#道路。如果删除的key与一个小对象关联，需要的时间
#为了执行DEL命令非常小，可与大多数其他命令相媲美
# Redis 中的 O(1) 或 O(log_N) 命令。但是，如果密钥与
# 包含数百万个元素的聚合值，服务器可以阻塞
# 很长时间（甚至几秒）才能完成操作。
#
# 基于以上原因，Redis 还提供了非阻塞删除原语
# 比如UNLINK（非阻塞DEL）和FLUSHALL的ASYNC选项和
# FLUSHDB 命令，以便在后台回收内存。那些命令
# 在恒定时间内执行。另一个线程将逐步释放
# 背景中的物体尽可能快。
#
# FLUSHALL 和 FLUSHDB 的 DEL、UNLINK 和 ASYNC 选项是用户控制的。
# 由应用程序的设计来理解它什么时候是好的
# 使用其中一个的想法。然而，Redis 服务器有时必须
# 删除键或刷新整个数据库作为其他操作的副作用。
# 具体来说，Redis 删除对象是独立于用户调用的
# 以下场景：
#
# 1) 在驱逐时，由于 maxmemory 和 maxmemory 策略配置，
# 为了给新数据腾出空间，而不是越过指定的
# 内存限制。
# 2) 因为过期：当一个键具有关联的生存时间（参见
# EXPIRE 命令）必须从内存中删除。
# 3) 由于将数据存储在密钥上的命令的副作用，该命令可能
# 已经存在。例如 RENAME 命令可能会删除旧密钥
# 替换为另一个时的内容。同样的SUNIONSTORE
# 或 SORT 与 STORE 选项可能会删除现有的键。SET 命令
# 本身删除指定键的任何旧内容以替换
# 使用指定的字符串。
# 4) 在复制期间，当一个副本与
# 它的主人，整个数据库的内容都被删除了，以便
# 加载刚刚传输的 RDB 文件。
#
# 在上述所有情况下，默认是以阻塞方式删除对象，
# 就像 DEL 被调用一样。但是，您可以专门配置每个案例
# 以一种非阻塞的方式释放内存，比如 if UNLINK
# 被调用，使用以下配置指令。

lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no

# 也可以，用于替换用户代码DEL调用的情况
#用UNLINK调用不容易，修改DEL的默认行为
# 命令与 UNLINK 完全一样，使用以下配置
# 指令：

lazyfree-lazy-user-del no

# FLUSHDB、FLUSHALL 和 SCRIPT FLUSH 同时支持异步和同步
# 删除，可以通过将 [SYNC|ASYNC] 标志传递到
# 命令。当两个标志都没有传递时，该指令将用于确定
# 如果数据应该被异步删除。

lazyfree-lazy-user-flush no

###############################THREADED I/O ############## ###################

# Redis 主要是单线程的，但也有一定的线程
# 诸如 UNLINK、慢速 I/O 访问等操作
# 在侧线程上执行。
#
# 现在也可以处理Redis客户端的socket读写
# 在不同的 I/O 线程中。由于特别是写字很慢，通常
# Redis 用户使用流水线来加速每个 Redis 的性能
# 核心，并产生多个实例以扩展更多。使用输入/输出
# 线程可以轻松地将Redis加速两倍而无需求助
# 对实例进行流水线或分片。
#
# 默认情况下线程是禁用的，我们建议只在机器上启用它
# 至少有 4 个或更多内核，至少留下一个备用内核。
# 使用超过 8 个线程不太可能有太大帮助。我们还建议使用
# 线程 I/O 仅当你确实有性能问题时，使用 Redis
# 实例能够使用相当大比例的 CPU 时间，否则
# 使用此功能没有意义。
#
# 所以例如如果你有一个四核盒子，尝试使用 2 或 3 个 I/O
# 线程，如果您有 8 个内核，请尝试使用 6 个线程。为了
# 启用 I/O 线程使用以下配置指令：
#
# io 线程 4
#
# 将 io-threads 设置为 1 将像往常一样使用主线程。
# 当I/O线程开启时，我们只使用线程进行写操作，即
# 线程化 write(2) 系统调用并将客户端缓冲区传输到
# 插座。但是，也可以启用读取和线程化
# 协议解析使用以下配置指令，通过设置
# 对是：
#
# io-threads-do-reads 没有
#
# 通常线程读取没有多大帮助。
#
# 注意 1：这个配置指令不能在运行时通过
# 配置集。Aso 此功能当前在 SSL 时不起作用
# 启用。
#
# 注意 2：如果你想使用 redis-benchmark 测试 Redis 加速，请执行
# 确保您也在线程模式下运行基准测试本身，使用
# --threads 选项来匹配 Redis 线程的数量，否则你不会
# 能够注意到改进。

##########################内核OOM 控制################## ############

# 在 Linux 上，可以在哪些进程上提示内核 OOM 杀手
# 内存不足时应该首先被杀死。
#
# 启用该功能使Redis主动控制oom_score_adj值
# 用于所有进程，取决于它们的角色。默认分数将
# 尝试在所有其他进程之前杀死后台子进程，并且
# 副本在主节点之前被杀死。
#
# Redis 支持三个选项：
#
# no：不要更改 oom-score-adj（默认）。
# yes：“relative”的别名见下文。
# absolute：oom-score-adj-values 中的值按原样写入内核。
# relative: 值是相对于 oom_score_adj 的初始值使用的
# 服务器启动，然后被限制在 -1000 到 1000 的范围内。
# 因为通常初始值是 0，它们通常会匹配
# 绝对值。
oom-score-adj no

# 当使用 oom-score-adj 时，该指令控制使用的具体值
# 用于主进程、副本进程和后台子进程。值范围 -2000 到
# 2000（更高意味着更有可能被杀死）。
#
# 非特权进程（不是 root，并且没有 CAP_SYS_RESOURCE 功能）
# 可以自由增加它们的值，但不能将其降低到初始值以下
# 设置。这意味着将 oom-score-adj 设置为“relative”并设置
# oom-score-adj-values 到正值总是会成功。
oom-score-adj-values 0 200 800


#################### 内核透明大页面控制#####################

# 通常内核 Transparent Huge Pages 控件设置为“madvise”或
# 或默认为“从不”（/sys/kernel/mm/transparent_hugepage/enabled），其中
# case 这个配置没有效果。在设置为“始终”的系统上，
# redis 将尝试专门为 redis 进程禁用它
# 专门针对 fork(2) 和 CoW 避免延迟问题。
# 如果由于某种原因您更喜欢保持启用状态，您可以将此配置设置为
# "no" 和内核全局为 "always"。

disable-thp yes

############################# 仅附加模式################# ##############

# 默认情况下，Redis 异步转储磁盘上的数据集。这种模式是
# 在许多应用程序中已经足够好，但是 Redis 进程有问题或
# 停电可能会导致几分钟的写入丢失（取决于
# 配置的保存点）。
#
# Append Only File 是另一种持久化模式，它提供
# 更好的耐用性。例如使用默认的数据同步策略
#（见后面的配置文件）Redis 可能只丢失一秒的写入
# 戏剧性的事件，比如服务器断电，或者一次写入，如果有的话
# Redis 进程本身有问题，但操作系统是
# 仍然正常运行。
#
# AOF 和 RDB 持久化可以同时启用，没有问题。
# 如果启动时启用了AOF，Redis会加载AOF，即文件
# 具有更好的耐用性保证。
#
# 请查看 https://redis.io/topics/persistence 了解更多信息。

appendonly no

# 仅追加文件的名称（默认：“appendonly.aof”）

appendfilename "appendonly.aof"

# fsync() 调用告诉操作系统将数据实际写入磁盘
# 而不是等待输出缓冲区中的更多数据。有些操作系统真的会刷新
# 磁盘上的数据，其他一些操作系统将尝试尽快完成。
#
# Redis 支持三种不同的模式：
#
# no：不要fsync，让操作系统在需要的时候刷新数据。快点。
# always：每次写入仅附加日志后的 fsync。慢，最安全。
#everysec：每秒只fsync一次。妥协。
#
# 默认是“everysec”，因为这通常是两者之间的正确折衷
# 速度和数据安全。这取决于你是否可以放松
# "no" 会让操作系统在以下情况刷新输出缓冲区
# 它想要，为了更好的表现（但如果你能接受
# 一些数据丢失考虑快照的默认持久性模式），
# 或者相反，使用 "always" 这很慢但比
#每一秒。
#
# 更多详情请查看以下文章：
# http://antirez.com/post/redis-persistence-demystified.html
#
# 如果不确定，请使用“everysec”。

# 始终追加同步
appendfsync everysec
# appendfsync 否

# 当AOF fsync 策略设置为always 或everysec 时，以及一个后台
# 保存过程（后台保存或AOF日志后台重写）是
# 在某些 Linux 配置中对磁盘执行大量 I/O
# Redis 可能在 fsync() 调用上阻塞太久。请注意，没有修复
# 这是目前，因为即使在不同的线程中执行 fsync 也会阻塞
# 我们的同步 write(2) 调用。
#
# 为了缓解这个问题，可以使用以下选项
# 这将阻止 fsync() 在主进程中被调用，而
# BGSAVE 或 BGREWRITEAOF 正在进行中。
#
# 这意味着当另一个孩子在储蓄时，Redis 的持久性是
# 与“appendfsync none”相同。实际上，这意味着它是
# 在最坏的情况下可能会丢失多达 30 秒的日志（使用
# 默认 Linux 设置）。
#
# 如果您有延迟问题，请将其设为“是”。否则将其保留为
# 从耐用性的角度来看，“不”是最安全的选择。

no-appendfsync-on-rewrite no

# 自动重写附加文件。
# Redis 能够自动重写日志文件隐式调用
# BGREWRITEAOF 当 AOF 日志大小增长指定百分比时。
#
# 这是它的工作原理：Redis 会记住 AOF 文件的大小
# 最新重写（如果重启后没有发生重写，则为
# 使用启动时的 AOF）。
#
# 这个基本大小与当前大小进行比较。如果当前大小是
# 大于指定的百分比，重写被触发。还
# 你需要为要重写的AOF文件指定一个最小的大小，这个
# 即使百分比增加，也有助于避免重写 AOF 文件
# 已达到，但它仍然很小。
#
# 指定百分比为零以禁用自动 AOF
# 重写功能。

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# Redis执行过程中可能会发现AOF文件在末尾被截断
# 启动过程，当 AOF 数据被加载回内存时。
# Redis运行的系统可能会出现这种情况
# 崩溃，特别是当 ext4 文件系统被挂载时
# data=ordered 选项（但是这不会发生在 Redis 本身
# 崩溃或中止，但操作系统仍能正常工作）。
#
# Redis 可以在发生这种情况时退出并显示错误，也可以加载尽可能多的内容
# data as possible（现在默认），如果找到AOF文件就启动
# 在最后被截断。以下选项控制此行为。
#
# 如果aof-load-truncated设置为yes，则加载一个截断的AOF文件并
# Redis 服务器开始发送日志以通知用户该事件。
# 否则，如果该选项设置为 no，则服务器会因错误而中止
# 并拒绝启动。当该选项设置为 no 时，用户需要
# 在重启前使用“redis-check-aof”工具修复AOF文件
# 服务器。
#
# 注意如果中间会发现AOF文件损坏
# 服务器仍然会出现错误退出。此选项仅适用于
# Redis 会尝试从 AOF 文件中读取更多数据但字节数不足
# 会被发现。
aof-use-rdb-preamble yes

# 重写AOF文件时，Redis可以使用RDB preamble
# AOF 文件用于更快的重写和恢复。当这个选项被打开时
# 重写后的 AOF 文件由两个不同的节组成：
#
# [RDB文件][AOF尾]
#
# 加载时，Redis 识别到 AOF 文件以“REDIS”开头
# 字符串并加载带前缀的RDB文件，然后继续加载AOF
＃ 尾巴。
aof-use-rdb-preamble yes

##############################LUA 脚本################ ################

# Lua 脚本的最大执行时间（以毫秒为单位）。
#
# 如果达到最大执行时间Redis将记录脚本
# 在最大允许时间后仍在执行并将开始执行
# 回复有错误的查询。
#
# 当长时间运行的脚本超过最大执行时间时，只有
# SCRIPT KILL 和 SHUTDOWN NOSAVE 命令可用。第一个可以
# 用于停止尚未调用任何写入命令的脚本。第二
# 是在写入命令的情况下关闭服务器的唯一方法
# 已经由脚本发出但用户自然不想等待
# 终止脚本。
#
# 将其设置为 0 或负值以无警告地无限执行。
lua-time-limit 5000

##############################REDIS 集群################ ################

# 普通Redis实例不能成为Redis集群的一部分；只有节点是
# 以集群节点的方式启动。为了启动一个Redis实例作为
# 集群节点启用集群支持取消注释以下内容：
#
# 集群启用是

# 每个集群节点都有一个集群配置文件。这个文件不是
# 打算手动编辑。它由 Redis 节点创建和更新。
# 每个Redis Cluster节点需要不同的集群配置文件。
# 确保在同一系统中运行的实例没有
# 重叠集群配置文件名。
#
# cluster-config-file nodes-6379.conf

# 集群节点超时是一个节点必须不可达的毫秒数
# 使其在失败状态下被考虑。
# 大多数其他内部时间限制是节点超时的倍数。
#
# 集群节点超时 15000

# 一个失败的 master 的副本将避免启动故障转移，如果它的数据
# 看起来太老了。
#
# 没有简单的方法可以让副本实际拥有准确的测量值
# 其“数据年龄”，因此执行以下两项检查：
#
# 1) 如果有多个副本能够进行故障转移，它们会交换消息
# 为了尽量让最好的复制品占优势
# 复制偏移量（处理来自主服务器的更多数据）。
# 副本将尝试通过偏移量获得他们的排名，并应用于开始
# 故障转移延迟与其等级成正比。
#
# 2) 每个副本都计算与上次交互的时间
#它的主人。这可以是收到的最后一个 ping 或命令（如果主
# 仍处于“已连接”状态），或自连接以来经过的时间
# 与 master 断开连接（如果复制链接当前已关闭）。
# 如果上次交互太旧，副本将不会尝试故障转移
# 一点。
#
# 点“2”可以由用户调整。具体来说，副本不会执行
# 故障转移 if, 自上次与 master 交互以来，时间
# 已用时间大于：
#
# (node-timeout * cluster-replica-validity-factor) + repl-ping-replica-period
#
# 例如，如果节点超时是 30 秒，并且集群副本有效性因子
# 为 10，假设默认的 repl-ping-replica-period 为 10 秒，则
# 如果副本无法与主服务器通信，它不会尝试进行故障转移
# 超过 310 秒。
#
# 较大的集群副本有效性因子可能允许具有过旧数据的副本进行故障转移
# 一个master，而一个太小的值可能会阻止集群能够
# 选择一个副本。
#
# 为了获得最大的可用性，可以设置 cluster-replica-validity-factor
# 值为 0，这意味着副本将始终尝试故障转移
# master 不管他们上次与 master 交互的时间。
#（然而他们总是会尝试应用与他们的成比例的延迟
# 偏移排名）。
#
# 零是唯一能够保证所有分区都恢复的值
# 集群将始终能够继续。
#
# cluster-replica-validity-factor 10

# 集群副本能够迁移到孤立的主节点，也就是主节点
# 剩下的没有工作副本。这提高了集群能力
# 抵抗失败，否则孤立的 master 不能被故障转移
# 在失败的情况下，如果它没有工作副本。
#
# 只有当至少还有一个副本时，副本才会迁移到孤立的主节点
# 给定他们旧主节点的其他工作副本数量。这个号码
# 是“迁移障碍”。迁移屏障为 1 意味着副本
# 仅当其 master 至少有 1 个其他工作副本时才会迁移
#等等。它通常反映了您想要的每个副本的数量
# 集群中的主节点。
#
# 默认值为 1（副本仅在其主节点保持至少
# 一个副本）。要禁用迁移，只需将其设置为一个非常大的值或
# 将 cluster-allow-replica-migration 设置为“否”。
# 可以设置值 0 但仅用于调试和危险
# 生产中。
#
# 集群迁移屏障 1

# 关闭此选项允许使用较少的自动集群配置。
# 它同时禁止迁移到孤立的 master 和从 master 迁移
# 变成空的。
#
# 默认为“是”（允许自动迁移）。
#
# cluster-allow-replica-migration 是

# 默认情况下，Redis 集群节点在检测到那里时停止接受查询
# 至少是一个未覆盖的哈希槽（没有可用的节点为其提供服务）。
# 这种方式如果集群部分关闭（例如一系列哈希槽
# 不再涵盖）所有集群最终都变得不可用。
# 一旦所有插槽再次被覆盖，它就会自动返回可用。
#
# 但是有时您想要正在工作的集群的子集，
# 继续接受对仍然存在的那部分键空间的查询
# 覆盖。为此，只需设置 cluster-require-full-coverage
# 选项为 no。
#
# cluster-require-full-coverage 是

# 此选项设置为 yes 时，可防止副本尝试对其进行故障转移
# master 故障期间的 master。但是，副本仍然可以执行
# 手动故障转移，如果被迫这样做。
#
# 这在不同的场景下很有用，尤其是在多个的情况下
# 数据中心运营，如果没有，我们希望一方永远不会被提升
# 在完全 DC 故障的情况下。
#
# cluster-replica-no-failover no

# 此选项设置为 yes 时，允许节点在读取流量时提供服务
# 集群处于关闭状态，只要它相信它拥有插槽。 
#
# 这对两种情况很有用。第一种情况是当一个应用程序
# 在节点故障或网络分区期间不需要数据的一致性。
# 一个例子是缓存，只要节点有数据
# 应该能够为它服务。 
#
# 第二个用例是针对不符合推荐的配置  
# 三个分片，但想要启用集群模式并稍后扩展。一种
# 1 或 2 分片配置中的主服务器中断会导致读/写中断
# 没有设置这个选项的整个集群，设置了它只会出现写中断。
# 没有法定人数的主人，插槽所有权不会自动更改。 
#
# cluster-allow-reads-when-down 否

# 为了设置你的集群，请务必阅读文档
# 可在 https://redis.io 网站获得。

######################### CLUSTER DOCKER/NAT 支持################## #####

# 在某些部署中，Redis Cluster 节点地址发现失败，因为
# 地址是 NAT-ted 或因为端口被转发（典型情况是
# Docker 和其他容器）。
#
# 为了让Redis Cluster工作在这样的环境中，一个静态的
# 需要每个节点知道其公共地址的配置。这
# 以下四个选项用于此范围，分别是：
#
# * cluster-announce-ip
# * 集群公告端口
# * cluster-announce-tls-port
# * 集群公告总线端口
#
# 每个都向节点指示其地址、客户端端口（用于连接
# 没有和有 TLS）和集群消息总线端口。然后信息是
# 发布在总线数据包的头部，以便其他节点能够
# 正确映射发布信息的节点地址。
#
# 如果 cluster-tls 设置为 yes 并且 cluster-announce-tls-port 被省略或设置
# 为零，则 cluster-announce-port 指的是 TLS 端口。还要注意的是
# 如果 cluster-tls 设置为 no，则 cluster-announce-tls-port 无效。
#
# 如果不使用以上选项，正常的Redis Cluster自动检测
# 将被使用。
#
# 注意重映射时，总线端口可能不在固定偏移量
# 客户端端口 + 10000，因此您可以根据需要指定任何端口和总线端口
# 关于它们如何重新映射。如果未设置总线端口，则固定偏移量为
# 10000 将照常使用。
#
# 例子：
#
# cluster-announce-ip 10.1.1.5
# cluster-announce-tls-port 6379
# 集群公告端口 0
# 集群公告总线端口 6380

#################################慢日志############## #####################

# Redis 慢日志是一个记录超过指定的查询的系统
# 执行时间处理时间。执行时间不包括 I/O 操作
# 像与客户交谈，发送回复等，
# 但只是实际执行命令所需的时间（这是唯一的
# 线程被阻塞且无法服务的命令执行阶段
# 在此期间的其他请求）。
#
# 可以用两个参数配置慢日志：一个告诉Redis
# 执行时间是多少，以微秒为单位，以超过顺序
# 获取日志的命令，另一个参数是日志的长度
# 慢日志。当记录新命令时，最旧的命令将从
# 记录命令的队列。

# 以下时间以微秒表示，所以1000000等价
# 到一秒。请注意，负数会禁用慢速日志，而
# 零值强制记录每个命令。
slowlog-log-slower-than 10000

# 这个长度没有限制。请注意，它会消耗内存。
# 您可以使用 SLOWLOG RESET 回收慢日志使用的内存。
slowlog-max-len 128

##############################LATENCY MONITOR ################ ###############

# Redis 延迟监控子系统对不同的操作进行采样
# 在运行时收集与可能来源相关的数据
# Redis 实例的延迟。
#
# 通过 LATENCY 命令，该信息可供用户使用
# 打印图表并获取报告。
#
# 系统只记录在等于或
# 大于通过指定的毫秒数
# 延迟监视器阈值配置指令。当它的值被设置时
# 为零，延迟监视器关闭。
#
# 默认情况下延迟监控是禁用的，因为它几乎不需要
# 如果你没有延迟问题，并且收集数据有性能
# 影响，虽然很小，但可以在大负载下测量。潜伏
# 可以在运行时使用命令轻松启用监控
# "CONFIG SET delay-monitor-threshold <milliseconds>" 如果需要。
latency-monitor-threshold 0

############################ 事件通知################## ############

# Redis 可以将密钥空间中发生的事件通知 Pub/Sub 客户端。
# 此功能记录在 https://redis.io/topics/notifications
#
# 例如，如果启用了键空间事件通知，并且客户端
# 对存储在数据库 0、2 中的键 "foo" 执行 DEL 操作
# 消息将通过 Pub/Sub 发布：
#
# 发布 __keyspace@0__:foo del
# 发布 __keyevent@0__:del foo
#
# 可以在集合中选择Redis将通知的事件
# 班级。每个类都由一个字符标识：
#
# K Keyspace 事件，以 __keyspace@<db>__ 前缀发布。
# E Keyevent 事件，以 __keyevent@<db>__ 前缀发布。
# g 通用命令（非特定于类型），如 DEL、EXPIRE、RENAME、...
# $ 字符串命令
# l 列出命令
#s 设置命令
# h 哈希命令
# z 排序集命令
# x 过期事件（每次密钥过期时生成的事件）
# e Evicted 事件（当一个 key 被驱逐以获得 maxmemory 时产生的事件）
# t 流命令
# d 模块键类型事件
# m Key-miss事件（注意：它不包括在'A'类中）
# g$lshzxetd 的别名，因此“AKE”字符串表示所有事件
#（除了因“A”而被排除在外的关键未命中事件
#独特的性质）。
#
# “notify-keyspace-events” 将组成的字符串作为参数
# 零个或多个字符。空字符串表示通知
# 被禁用。
#
# 示例：启用列表和通用事件，从
# 事件名称，使用：
#
# 通知键空间事件 Elg
#
# 示例2：获取订阅频道的过期key的流
# name __keyevent@0__:过期使用：
#
# 通知键空间事件前
#
# 默认情况下所有通知都被禁用，因为大多数用户不需要
# 这个特性和特性有一些开销。请注意，如果您不
# 至少指定 K 或 E 之一，不会传递任何事件。
notify-keyspace-events ""

############################# GOPHER 服务器################ ################

# Redis 包含 Gopher 协议的实现，如中所述
# RFC 1436 (https://www.ietf.org/rfc/rfc1436.txt)。
#
# Gopher 协议在 90 年代后期非常流行。这是一个替代方案
# 到web，服务端和客户端的实现就这么简单
#Redis服务器只有100行代码来实现这个
# 支持。
#
# 你现在用 Gopher 做什么？好吧，Gopher从未*真的*死过，而且
# 最近有一个动作是为了让 Gopher 的内容更有层次
# 只由纯文本文件组成，要复活。有些人想要更简单的
#互联网，其他人认为主流互联网变得太多了
# 受控制，为那些愿意的人创造一个替代空间很酷
# 想要呼吸新鲜空气。
#
# 无论如何，为了 Redis 的 10 岁生日，我们给了它 Gopher 协议
# 作为礼物。
#
#  - - 这个怎么运作？---
#
# Redis Gopher 支持使用Redis 的内联协议，特别是
# 两种无论如何都是非法的内联请求：空请求
# 或任何以“/”开头的请求（没有 Redis 命令开始
# 带有这样的斜线）。正常的 RESP2/RESP3 请求完全超出
# Gopher 协议实现的路径，也照常提供。
#
# 如果在启用 Gopher 时打开与 Redis 的连接并发送它
# 像“/foo”这样的字符串，如果有一个名为“/foo”的键，它通过
# 地鼠协议。
#
# 为了创建一个真正的Gopher“洞”（Gopher中一个Gopher站点的名称
# 说话），你可能需要一个像下面这样的脚本：
#
# https://github.com/antirez/gopher2redis
#
#  - - 安全警告  - -
#
# 如果您打算将 Redis 放在 Internet 上可公开访问的地址中
# 到服务器 Gopher 页面确保为实例设置密码。
# 设置密码后：
#
# 1. Gopher 服务器（启用时，不是默认情况下）仍将提供服务
# 内容来自 Gopher。
# 2. 但是在客户端调用之前不能调用其他命令
# 认证。
#
# 所以使用'requirepass'选项来保护你的实例。
#
# 请注意，当 'io-threads-do-reads' 时，当前不支持 Gopher
# 已启用。
#
# 要启用 Gopher 支持，取消注释以下行并设置选项
# 从 no（默认）到 yes。
#
# gopher 已启用 否

############################# 高级配置################# ###############

# 哈希在具有内存效率的数据结构时被编码
# 条目数少，最大条目不超过给定
# 临界点。可以使用以下指令配置这些阈值。
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

# 列表也以特殊方式编码，以节省大量空间。
# 可以指定每个内部列表节点允许的条目数
# 作为固定的最大尺寸或最大元素数。
# 对于固定的最大大小，使用 -5 到 -1，意思是：
# -5：最大大小：64 Kb <-- 不推荐用于正常工作负载
# -4：最大大小：32 Kb <-- 不推荐
# -3: 最大大小：16 Kb <-- 可能不推荐
# -2: 最大大小：8 Kb <-- 好
# -1: 最大大小：4 Kb <-- 好
# 正数意味着最多存储 _exactly_ 那个数量的元素
# 每个列表节点。
# 性能最高的选项通常是 -2（8 Kb 大小）或 -1（4 Kb 大小），
# 但如果您的用例是独一无二的，请根据需要调整设置。
list-max-ziplist-size -2

# 列表也可以被压缩。
# 压缩深度是来自 *each* 侧的 quicklist ziplist 节点的数量
# 从压缩中*排除*的列表。列表的头部和尾部
# 始终未压缩以进行快速推送/弹出操作。设置是：
# 0: 禁用所有列表压缩
# 1：深度 1 表示“直到 1 个节点进入列表后才开始压缩，
# 从头部或尾部开始”
# 所以：[head]->node->node->...->node->[tail]
# [head], [tail] 将始终未压缩；内部节点会压缩。
# 2: [head]->[next]->node->node->...->node->[prev]->[tail]
# 2 这里的意思是：不要压缩 head 或 head->next 或 tail->prev 或 tail，
# 但压缩它们之间的所有节点。
# 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]
＃ 等等。
list-compress-depth 0

# 集合只有在一种情况下有一种特殊的编码：当一个集合被组合时
# 恰好是范围内基数为 10 的整数的字符串
# 64 位有符号整数。
# 下面的配置设置设置了大小的限制
# 设置以使用这种特殊的内存节省编码。
set-max-intset-entries 512

# 与散列和列表类似，有序集也被特殊编码在
#为了节省大量空间。这种编码仅在长度和
# 有序集合的元素低于以下限制：
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# HyperLogLog 稀疏表示字节限制。限制包括
# 16 字节的标题。当使用稀疏表示的 HyperLogLog 交叉时
# 这个限制，它被转换成密集表示。
#
# 一个大于 16000 的值是完全没有用的，因为在那个时候
# 密集表示的内存效率更高。
#
# 建议值为 ~ 3000 以获得以下好处
# 节省空间的编码而不会减慢太多 PFADD，
# 这是 O(N) 与稀疏编码。该值可以提高到
# ~ 10000 当 CPU 不是问题，但空间是，并且数据集是
# 由许多基数在 0 - 15000 范围内的 HyperLogLog 组成。
hll-sparse-max-bytes 3000

# 流宏节点最大大小/项目。流数据结构是一个基数
# 编码多个项目的大节点树。使用这个配置
# 可以配置单个节点的大小（以字节为单位），以及
# 在切换到新节点之前它可能包含的最大项目数
# 附加新的流条目。如果以下任何设置被设置为
# 零，限制被忽略，因此例如可以只设置一个
# 通过将 max-bytes 设置为 0 并将 max-entries 设置为所需的最大条目来限制
＃ value。
stream-node-max-bytes 4096
stream-node-max-entries 100

# 主动重新散列每 100 毫秒的 CPU 时间使用 1 毫秒
#为了帮助rehashing主Redis哈希表（映射顶级
# 键值）。Redis 使用的哈希表实现（参见 dict.c）
# 执行惰性重新散列：运行到哈希表中的操作越多
# 即重新哈希，执行的重新哈希“步骤”越多，因此如果
# 服务器空闲，重新散列永远不会完成，并且使用了更多内存
# 通过哈希表。
#
# 默认是每秒使用这个毫秒 10 次，以便
# 主动重新哈希主词典，尽可能释放内存。
#
# 如果不确定：
# 如果您有硬延迟要求，请使用“activerehashing no”
# Redis可以不时回复在你的环境中不是一件好事
# 以 2 毫秒的延迟查询。
#
# 如果你没有这么严格的要求，请使用“activerehashing yes”
# 想在可能的情况下尽快释放内存。
activerehashing yes

# 客户端输出缓冲区限制可用于强制断开客户端
# 由于某种原因没有足够快地从服务器读取数据（a
# 常见的原因是 Pub/Sub 客户端不能像
# 出版商可以制作它们）。
#
# 可以为三类不同的客户端设置不同的限制：
#
# 普通 -> 普通客户端，包括 MONITOR 客户端
# 副本 -> 副本客户端
# pubsub -> 客户端订阅了至少一个 pubsub 频道或模式
#
# 每个 client-output-buffer-limit 指令的语法如下：
#
# client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
#
# 一旦达到硬限制，客户端立即断开连接，或者如果
# 达到软限制并保持达到指定数量
# 秒（连续）。
# 例如，如果硬限制是 32 兆字节，软限制是
# 16 MB / 10 秒，客户端将立即断开连接
# 如果输出缓冲区的大小达到 32 兆字节，但也会得到
# 如果客户端达到 16 兆字节并不断克服，则断开连接
# 10 秒的限制。
#
# 默认情况下，普通客户端不受限制，因为它们不接收数据
# 没有询问（以推送方式），但只是在请求之后，所以只有
# 异步客户端可能会创建更快请求数据的场景
# 比它可以读取。
#
# 相反，发布订阅和副本客户端有一个默认限制，因为
# 订阅者和副本以推送方式接收数据。
#
# 硬限制或软限制都可以通过将它们设置为零来禁用。
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

# 客户端查询缓冲区累积新命令。它们仅限于固定
# 默认情况下，为了避免协议不同步（对于
# 实例由于客户端中的错误）将导致未绑定的内存使用
# 查询缓冲区。但是，如果您有非常特殊的需求，可以在此处进行配置
# 需求，比如我们巨大的 multi/exec 请求或类似的请求。
#
# 客户端查询缓冲区限制 1GB

# 在Redis协议中，批量请求，即代表单个的元素
# 字符串，通常限制为 512 mb。但是您可以更改此限制
# 这里，但必须是 1mb 或更大
#
# proto-max-bulk-len 512mb

# Redis 调用一个内部函数来执行许多后台任务，比如
# 超时关闭客户端的连接，清除过期的密钥
# 从未请求过，等等。
#
# 并非所有任务都以相同的频率执行，但 Redis 会检查
# 根据指定的“hz”值执行的任务。
#
# 默认情况下，"hz" 设置为 10。提高该值将使用更多 CPU
# Redis 是空闲的，但同时会让 Redis 响应更快
# 有多个key同时过期，可能会超时
# 更精确地处理。
#
# 范围在 1 到 500 之间，但是通常不会超过 100 的值
＃ 一个好主意。大多数用户应该使用默认值 10 并将其提高到
# 100 仅在需要极低延迟的环境中。
hz 10

# 通常有一个 HZ 值是有用的，它与
# 连接的客户端数量。这很有用，例如，为了
# 避免为每个后台任务调用处理过多的客户端
# 为了避免延迟峰值。
#
# 由于默认的默认HZ值保守设置为10，Redis
# 提供并默认启用使用自适应 HZ 值的能力
# 当有很多连接的客户端时会暂时升高。
#
# 启用动态 HZ 时，将使用实际配置的 HZ
# 作为基线，但实际上是配置的 HZ 值的倍数
# 连接更多客户端后根据需要使用。就这样闲着
# 实例将使用很少的 CPU 时间，而繁忙的实例将
# 反应更灵敏。
dynamic-hz yes

# 当孩子重写AOF文件时，如果启用了以下选项
# 文件将每生成 32 MB 数据进行 fsync-ed。这很有用
# 为了更增量地将文件提交到磁盘并避免
# 大延迟峰值。
aof-rewrite-incremental-fsync yes

#当redis保存RDB文件时，如果启用了以下选项
# 文件将每生成 32 MB 数据进行 fsync-ed。这很有用
# 为了更增量地将文件提交到磁盘并避免
# 大延迟峰值。
rdb-save-incremental-fsync yes

# Redis LFU 驱逐（见 maxmemory 设置）可以调整。然而这是一个很好的
# 想法从默认设置开始，只有在调查后才更改它们
# 如何提高性能以及密钥 LFU 如何随时间变化，其中
# 可以通过 OBJECT FREQ 命令进行检查。
#
# Redis LFU 实现中有两个可调参数：
# 计数器对数因子和计数器衰减时间。重要的是要
# 在更改之前了解这两个参数的含义。
#
# LFU 计数器每个键只有 8 位，最大值是 255，所以 Redis
# 使用具有对数行为的概率增量。鉴于价值
# 旧计数器，当访问一个键时，计数器增加
# 这边走：
#
# 1. 抽取一个介于 0 和 1 之间的随机数 R。
# 2. 概率 P 计算为 1/(old_value*lfu_log_factor+1)。
# 3. 只有当 R < P 时，计数器才会增加。
#
# 默认的 lfu-log-factor 是 10。这是一个频率如何的表
# 计数器随着不同的访问次数而变化
# 对数因子：
#
# +--------+------------+------------+------------+ ------------+------------+
# | 因素 | 100 次点击 | 1000 次点击 | 10 万次点击 | 100 万次点击 | 1000 万次点击 |
# +--------+------------+------------+------------+ ------------+------------+
# | 0 | 104 | 255 | 255 | 255 | 255 |
# +--------+------------+------------+------------+ ------------+------------+
# | 1 | 18 | 49 | 255 | 255 | 255 |
# +--------+------------+------------+------------+ ------------+------------+
# | 10 | 10 | 18 | 142 | 255 | 255 |
# +--------+------------+------------+------------+ ------------+------------+
# | 100 | 8 | 11 | 49 | 143 | 255 |
# +--------+------------+------------+------------+ ------------+------------+
#
# 注意：上表是通过运行以下命令获得的：
#
# redis-benchmark -n 1000000 incr foo
# redis-cli 对象频率 foo
#
# 注意 2：计数器初始值为 5，以便给新对象一个机会
# 累积命中。
#
# 计数器衰减时间是按顺序必须经过的时间，以分钟为单位
# 将关键计数器除以二（如果有值则递减）
# 少 <= 10)。
#
# lfu-decay-time 的默认值为 1。特殊值 0 表示
# 每次碰巧被扫描时都会衰减计数器。
#
# lfu-log-factor 10
# lfu 衰减时间 1

########################## 主动碎片整理#################### ##
#
# 什么是主动碎片整理？
# -------------------------------
#
# 主动（在线）碎片整理允许 Redis 服务器压缩
# 内存中数据的小分配和释放之间留下的空间，
# 从而允许回收内存。
#
# 分片是每个分配器都会发生的自然过程（但是
# 幸运的是，Jemalloc 的情况较少）和某些工作负载。通常是服务器
# 需要重新启动以降低碎片，或至少刷新
# 删除所有数据并重新创建。不过多亏了这个功能
# 由 Oran Agra 为 Redis 4.0 实现这个过程可以在运行时发生
# 在服务器运行时以“热”方式。
#
# 基本上当碎片超过一定程度时（见
# 配置选项）Redis 将开始创建新的副本
# 通过利用某些特定的 Jemalloc 在连续内存区域中的值
# 功能（为了了解分配是否导致碎片
# 并将其分配到更好的地方），同时将释放
# 数据的旧副本。这个过程，对所有的键递增地重复
# 将导致碎片回落到正常值。
#
# 需要了解的重要事项：
#
# 1.这个功能默认是关闭的，只有你编译了Redis才有效
# 要使用我们随 Redis 源代码一起提供的 Jemalloc 副本。
# 这是 Linux 构建的默认设置。
#
# 2. 如果你没有碎片，你永远不需要启用这个功能
# 问题。
#
# 3.一旦遇到碎片，您可以在以下情况下启用此功能
# 需要命令“CONFIG SET activedefrag yes”。
#
# 配置参数可以微调
# 碎片整理过程。如果你不确定他们的意思是什么
# 保持默认值不变是个好主意。

# 启用主动碎片整理
# activedefrag 否

# 启动主动碎片整理的最小碎片浪费量
# 活动碎片整理忽略字节 100mb

# 启动活动碎片整理的最小碎片百分比
# 活动碎片整理阈值下限 10

# 我们使用最大努力的最大碎片百分比
# 活动碎片整理阈值上限 100

# 最小的 CPU 百分比碎片整理工作，当较低时使用
# 达到阈值
# 活动碎片整理周期分钟 1

# 在 CPU 百分比中为碎片整理的最大努力，在上限时使用
# 达到阈值
# 活动碎片整理周期最大 25

# 将从中处理的 set/hash/zset/list 字段的最大数量
# 主字典扫描
# 活动碎片整理最大扫描字段 1000

# 用于清除的 Jemalloc 后台线程将默认启用
jemalloc-bg-thread yes

# 可以将Redis的不同线程和进程pin到特定的
# 系统中的 CPU，以最大限度地提高服务器的性能。
# 这对于将不同的 Redis 线程固定在不同的
# CPU，也是为了确保多个Redis实例运行
# 在同一个主机中将被固定到不同的 CPU。
#
# 通常你可以使用“taskset”命令来做到这一点，但它也是
# 在 Linux 和 FreeBSD 中都可以直接通过 Redis 配置来实现。
#
# 你可以pin服务器/IO线程，bio线程，aof重写子进程，以及
# bgsave 子进程。指定 cpu 列表的语法与
# 任务集命令：
#
# 设置 redis server/io 线程为 cpu 亲和度 0,2,4,6:
# server_cpulist 0-7:2
#
# 将 bio 线程设置为 cpu 亲和度 1,3：
# bio_cpulist 1,3
#
# 设置aof重写子进程为cpu亲和度8,9,10,11：
# aof_rewrite_cpulist 8-11
#
# 设置 bgsave 子进程为 cpu 亲和度 1,10,11
# bgsave_cpulist 1,10-11

# 在某些情况下，redis 会发出警告，如果检测到甚至会拒绝启动
# 系统处于不良状态，可以抑制这些警告
# 通过设置以下配置，它需要一个空格分隔的警告列表
# 压制
#
# 忽略警告 ARM64-COW-BUG

Redis简单使用

一、Redis-key

#查看当前库所有key    (匹配：keys *1)
keys *
# 判断某个key是否存在
exists key
# 查看你的key是什么类型
type key
#  删除指定的key数据
del key    
# 根据value选择非阻塞删除 仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。
unlink key   
# 10秒钟：为给定的key设置过期时间
expire key 10  
# 查看还有多少秒过期，-1表示永不过期，-2表示已过期
ttl key 
#命令切换数据库
select 2
#查看当前数据库的key的数量
dbsize
#清空当前库
flushdb
#通杀全部库
flushall

二、Redis-String

*String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M。

*String类型是二进制安全的（简单来说，二进制安全就是，字符串不是根据某种特殊的标志来解析的，无论输入是什么，总能保证输出是处理的原始输入而不是根据某种特殊格式来处理。详细可参考：https://blog.csdn.net/zry1266/article/details/52856895）。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。

# 添加键值对
set key value [EX seconds|PX milliseconds|EXAT timestamp|PXAT milliseconds-timestamp|KEEPTTL]
#注意
#NX：当数据库中key不存在时，可以将key-value添加数据库
#XX：当数据库中key存在时，可以将key-value添加数据库，与NX参数互斥
#EX：key的超时秒数
#PX：key的超时毫秒数，与EX互斥

#查询对应键值
get <key>
#将给定的<value> 追加到原值的末尾
append <key> <value>
#获得值的长度
strlen <key>
#只有在key不存在时设置 key 的值
setnx <key> <value>
#将 key 中储存的数字值增1 只能对数字值操作，如果为空，新增值为1 
#原子性: 操作是指不会被线程调度机制打断的操作
incr <key>
#将 key 中储存的数字值减1 只能对数字值操作，如果为空，新增值为-
decr  <key>
#key 中储存的数字值增减。自定义步长
incrby key increment
#同时设置一个或多个 key-value对
mset key value [key value ...]
#同时获取一个或多个 value
mget key [key ...]
#同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
msetnx key value [key value ...]
#获得值的范围，类似java中的substring，前包，后包
getrange key start end
#用 <value>  覆写<key>所储存的字符串值，从<起始位置>开始(索引从0开始)。
setrange key offset value
#设置键值的同时，设置过期时间，单位秒。
setex key seconds value
#以新换旧，设置了新值同时获得旧值
getset key value

三、Redis-List

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。特点：单键多值。

它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。

#从左边/右边插入一个或多个值。
lpush/rpush <key> <value1> <value2> <value3>
#从左边/右边吐出一个值。值在键在，值光键亡。
lpop/rpop <key>
#列表右边吐出一个值，插到<key2>列表左边。
rpoplpush  <key1><key2>从<key1>
#按照索引下标获得元素(从左到右)
lrange <key> <start> <stop>
#按照索引下标获得元素(从左到右)
lindex <key> <index>
#获得列表长度 
llen <key>
#在<value>的后面插入<newvalue>插入值
linsert <key> before <value> <newvalue>
#从左边删除n个value(从左到右)
lrem <key> <n> <value>
#将列表key下标为index的值替换成value
lset <key> <index> <value>

四、Redis-Set

Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。

Set数据结构是dict字典，字典是用哈希表实现的。Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。

#将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略
sadd <key> <value1> <value2> 
#取出该集合的所有值。
smembers <key>
#判断集合<key>是否为含有该<value>值，有1，没有0
sismember <key> <value>
#返回该集合的元素个数。
scard <key>
#删除集合中的某个元素。
srem <key><value1><value2> .... 
#随机从该集合中吐出一个值。
spop <key>
#随机从该集合中取出n个值。不会从集合中删除 。
srandmember <key ><n>
#把集合中一个值从一个集合移动到另一个集合
smove <source> <destination> value
#返回两个集合的交集元素。
sinter <key1> <key2>
#返回两个集合的并集元素。
sunion <key1> <key2>
#返回两个集合的差集元素(key1中的，不包含key2中的)
sdiff <key1> <key2>

五、Redis-Hash

Redis hash 是一个键值对集合。Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。类似Java里面的Map<String,Object>.

#给<key>集合中的  <field>键赋值<value>
hset <key> <field> <value>
#从<key1>集合<field>取出 value 
hget <key1> <field>
#批量设置hash的值
hmset <key1> <field1> <value1> <field2> <value2>
#查看哈希表 key 中，给定域 field 是否存在。
hexists <key1> <field>
#列出该hash集合的所有field
hkeys <key>
#列出该hash集合的所有value
hvals <key>
#为哈希表 key 中的域 field 的值加上增量 1   -1
hincrby <key> <field> <increment>
#将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 .
hsetnx <key> <field> <value>

六、Redis-Zset(sorted set)

Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。
不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了 。

因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。
访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map<String, Double>，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。

#将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
zadd <key> <score1> <value1> <score2> <value2>
#返回有序集 key 中，下标在<start><stop>之间的元素 带WITHSCORES，可以让分数一起和值返回到结果集。
zrange <key> <start> <stop>  [WITHSCORES]   
#返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
zrangebyscore key minmax [withscores] [limit offset count]
#同上，改为从大到小排列。 
zrevrangebyscore key maxmin [withscores] [limit offset count]               
#  为元素的score加上增量
zincrby <key> <increment> <value>   
#删除该集合下，指定值的元素 
zrem  <key> <value>
#统计该集合，分数区间内的元素个数 
zcount <key> <min> <max>
#返回该值在集合中的排名，从0开始。
zrank <key> <value>

七、Redis-Bitmaps

（1） Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。

（2） Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量。

#设置Bitmaps中某个偏移量的值（0或1）
setbit <key> <offset> <value>
#获取Bitmaps中某个偏移量的值 获取键的第offset位的值（从0开始算）
getbit <key> <offset>
#统计字符串从start字节到end字节比特值为1的数量
bitcount <key> [start end]

八、Redis-Geospatial

Redis 3.2 中增加了对GEO类型的支持。GEO，Geographic，地理信息的缩写。该类型，就是元素的2维坐标，在地图上就是经纬度。redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。

#添加地理位置（经度，纬度，名称）
geoadd <key> <longitude> <latitude> <member> [longitude latitude member...]
#获得指定地区的坐标值
geopos <key> <member> [member...]  
#获取两个位置之间的直线距离
geodist <key> <member1> <member2>  [m|km|ft|mi ]

#测试数据
127.0.0.1:6379> geoadd china:city 106.50 29.53 zhengzhou 114.05 22.52 jincheng 116.38 39.90 zhoukou
(integer) 3
127.0.0.1:6379> GEOPOS china:city zhengzhou
1) 1) "106.49999767541885376"
   2) "29.52999957900659211"
127.0.0.1:6379> geodist china:city jincheng zhoukou km
"1945.5740"
127.0.0.1:6379> 

Redis持久化

官网地址：https://redis.io/topics/persistence

Redis 提供了2个不同形式的持久化方式。

RDB（Redis DataBase）

AOF（Append Of File）

一、RDB

在指定的时间间隔内将内存中的数据集快照写入磁盘， 也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

Fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量、环境变量、程序计数器等） 数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程
在Linux程序中，fork()会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，Linux中引入了“写时复制技术”
一般情况父进程和子进程会共用同一段物理内存，只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。

RDB持久化流程图：

#dump.rdb文件
#在redis.conf中配置文件名称，默认为dump.rdb
dbfilename dump.rdb

#rdb文件的保存路径，也可以修改。默认为Redis启动时命令行所在的目录下
#在redis.conf中配置,有说明
dir ./

#如何触发RDB快照；保持策略,配置文件中默认的快照配置
# Unless specified otherwise, by default Redis will save the DB:
#   * After 3600 seconds (an hour) if at least 1 key changed
#   * After 300 seconds (5 minutes) if at least 100 keys changed
#   * After 60 seconds if at least 10000 keys changed
#
# You can set these explicitly by uncommenting the three following lines.
#
# save 3600 1
# save 300 100
# save 60 10000

#当Redis无法写入磁盘的话，直接关掉Redis的写操作。默认yes.
stop-writes-on-bgsave-error yes
#对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用LZF算法进行压缩。默认yes.
rdbcompression yes
#在存储快照后，还可以让redis使用CRC64算法来进行数据校验，但是这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能。 默认yes
rdbchecksum yes




#rdb 备份
redis-cli -p 6379
#查询rdb文件的目录
config get dir 
#将上文件中的.rdb的文件拷贝到别的地方

#rdb的恢复
#关闭Redis
#先把备份的文件拷贝到工作目录下 cp dump2.rdb dump.rdb
#启动Redis, 备份数据会直接加载

优势：

适合大规模的数据恢复

对数据完整性和一致性要求不高更适合使用

节省磁盘空间

恢复速度快

劣势：

Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑

虽然Redis在fork时使用了写时拷贝技术,但是如果数据庞大时还是比较消耗性能。

在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会丢失最后一次快照后的所有修改。

二、AOF

以日志的形式来记录每个写操作（增量保存），将Redis执行过的所有写指令记录下来(读操作不记录)， 只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis 重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。

AOF持久化流程

（1）客户端的请求写命令会被append追加到AOF缓冲区内；

（2）AOF缓冲区根据AOF持久化策 略[always,everysec,no]将操作sync同步到磁盘的AOF文件中；

（3）AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量；

（4）Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的；

#AOF 默认不开启
appendonly no
#可以在redis.conf中配置文件名称，默认为 appendonly.aof
appendfilename "appendonly.aof"
#A0F同步频率设置
#始终同步，每次Redis的写入都会立刻记入日志；性能较差但数据完整性比较好
appendfsync always
#每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失。
appendfsync everysec
#redis不主动进行同步，把同步时机交给操作系统。
appendfsync no

#注意
#AOF和RDB同时开启，系统默认取AOF的数据（数据不会存在丢失）
#AOF文件持续增长而过大时，会fork出一条新进程来将文件重写(也是先写临时文件最后再rename)，redis4.0版本后的重写，是指上就是把rdb 的快照，以二级制的形式附在新的aof头部，作为已有的历史数据，替换掉原来的流水账操作。
#如果 no-appendfsync-on-rewrite=yes ,不写入aof文件只写入缓存，用户请求不会阻塞，但是在这段时间如果宕机会丢失这段时间的缓存数据。（降低数据安全性，提高性能）
#如果 no-appendfsync-on-rewrite=no,  还是会把数据往磁盘里刷，但是遇到重写操作，可能会发生阻塞。（数据安全，但是性能降低）
no-appendfsync-on-rewrite no
#设置重写的基准值，文件达到100%时开始重写（文件是原来重写后文件的2倍时触发）
auto-aof-rewrite-percentage
#设置重写的基准值，最小文件64MB。达到这个值开始重写。文件达到70MB开始重写，降到50MB，下次什么时候开始重写？100MB系统载入时或者上次重写完毕时，Redis会记录此时AOF大小，设为base_size,如果Redis的AOF当前大小>= base_size +base_size*100% (默认)且当前大小>=64mb(默认)的情况下，Redis会对AOF进行重写。 
auto-aof-rewrite-min-size 

优势：

备份机制更稳健，丢失数据概率更低。

可读的日志文本，通过操作AOF稳健，可以处理误操作。

劣势:

比起RDB占用更多的磁盘空间。

恢复备份速度要慢。

每次读写都同步的话，有一定的性能压力。

存在个别Bug，造成恢复不能。

三、推荐

RDB持久化方式能够在指定的时间间隔能对你的数据进行快照存储

AOF持久化方式记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据,AOF命令以redis协议追加保存每次写的操作到文件末尾.

Redis还能对AOF文件进行后台重写,使得AOF文件的体积不至于过大

只做缓存：如果你只希望你的数据在服务器运行的时候存在,你也可以不使用任何持久化方式.

同时开启两种持久化方式

在这种情况下,当redis重启的时候会优先载入AOF文件来恢复原始的数据, 因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整.

RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件。那要不要只使用AOF呢？

建议不要，因为RDB更适合用于备份数据库(AOF在不断变化不好备份)， 快速重启，而且不会有AOF可能潜在的bug，留着作为一个万一的手段。

性能建议:

因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留save 900 1这条规则。

如果使用AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了。

代价,一是带来了持续的IO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。

只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上。

默认超过原大小100%大小时重写可以改到适当的数值。

Redis-主从搭建

特点：读写分离，性能扩展，容灾快速恢复

# 一主三从
cd /opt/module/redis/
vim redis-master-slave.conf
#---输入---
#引入外部文件
include /opt/module/redis/redis.config
#指定pidfile
pidfile /var/run/redis_6379.pid
#指定端口
port 6379
#更改rdb文件名称
dbfilename dump6379.rdb
#---输入---
cp /opt/module/redis/redis-master-slave.conf /opt/module/redis/redis6389.conf
cp /opt/module/redis/redis-master-slave.conf /opt/module/redis/redis6390.conf
cp /opt/module/redis/redis-master-slave.conf /opt/module/redis/redis6391.conf
cp /opt/module/redis/redis-master-slave.conf /opt/module/redis/redis6392.conf

#修改对应的端口
#修改对应端口即可

#启动四个Rdis
redis-server redis6389.conf
redis-server redis6390.conf
redis-server redis6391.conf
redis-server redis6392.conf
#登录查看节点信息,role都是master
redis-cli -p 6389
info replication
role:master

#现在起没有主从
#设置主从命令
slaveof <ip> <port>
#分别登录6390、6391、6392执行如下
redis-cli -p 6390
SLAVEOF 127.0.0.1 6389

#注意事项
#1.主节点挂掉, 从节点角色依旧. 重启主节点. 一切如初.
#可利用下面指定,将从节点变成主节点
slaveof no one

#哨兵模式sentinel
#能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库
#
cd /opt/module/redis/
vim sentinel.conf
#其中mymaster为监控对象起的服务器名称， 1 为至少有多少个哨兵同意迁移的数量
sentinel monitor mymaster 127.0.0.1 6389 1
#启动哨兵
redis-sentinel sentinel

Reids集群搭建

Redis 集群实现了对Redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数据的1/N。

Redis 集群通过分区（partition）来提供一定程度的可用性（availability）： 即使集群中有一部分节点失效或者无法进行通讯， 集群也可以继续处理命令请求。

一、集群规划

集群类型	服务器地址(内网地址)	端口	配置文件路径
master	114.115.132.141(192.168.200.249)	6379	/zzsn/module/redis/redis6379.conf
slave	114.115.132.141(192.168.200.249)	6380	/zzsn/module/redis/redis6380.conf
master	114.115.215.192 (192.168.200.185)	6380	/zzsn/module/redis/redis6380.conf
slave	114.115.215.192(192.168.200.185)	6381	/zzsn/module/redis/redis6381.conf
master	114.115.159.144(192.168.0.102)	6381	/zzsn/module/redis/redis6381.conf
slave	114.115.159.144(192.168.0.102)	6379	/zzsn/module/redis/redis6379.conf

二、配置

1.基础文件配置

2.集群文件配置

以114.115.132.141- /zzsn/module/redis/redis6379.conf 配置如下:

剩下几个配置按如下更改端口即可

include /zzsn/module/redis/redis.conf
port 6379
pidfile "/var/run/redis_6379.pid"
dbfilename "dump6379.rdb"
dir "/zzsn/module/redis/"
logfile "/zzsn/module/redis/redis_err_6379.log"
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 15000
appendonly yes
masterauth @!@ZZsn9988. 
requirepass @!@ZZsn9988. 

# slave 配置打开如下
# save 900 1

三、启动集群

# 启动集群
cd /zzsn/module/redis/redis-6.2.6/src


#内网配置
    ./redis-cli -a '@!@ZZsn9988.' --cluster create --cluster-replicas 1 192.168.200.249:6379 192.168.200.185:6380 192.168.0.102:6381 192.168.200.249:6380 192.168.200.185:6381 192.168.0.102:6379 
 
#---
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 192.168.200.185:6381 to 192.168.200.249:6379
Adding replica 192.168.0.102:6379 to 192.168.200.185:6380
Adding replica 192.168.200.249:6380 to 192.168.0.102:6381
M: 28cd49566c4cb66eafbda0c273681f107a7ad4fd 192.168.200.249:6379
   slots:[0-5460] (5461 slots) master
M: 1707a1bbbe5d70bf09c51d4438c5de134727d6b0 192.168.200.185:6380
   slots:[5461-10922] (5462 slots) master
M: d0f876f972e0f9b49ab8373fe4ea2b581e36b755 192.168.0.102:6381
   slots:[10923-16383] (5461 slots) master
S: 87bbe2f34d74a29ea93d533d6e572848705afa49 192.168.200.249:6380
   replicates d0f876f972e0f9b49ab8373fe4ea2b581e36b755
S: 2263ce328587307259c3bb3f54ba02bf371e50c4 192.168.200.185:6381
   replicates 28cd49566c4cb66eafbda0c273681f107a7ad4fd
S: 7243ec7e5166afa51b2639c97c59829b3dc763e7 192.168.0.102:6379
   replicates 1707a1bbbe5d70bf09c51d4438c5de134727d6b0
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
.....
>>> Performing Cluster Check (using node 192.168.200.249:6379)
M: 28cd49566c4cb66eafbda0c273681f107a7ad4fd 192.168.200.249:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 2263ce328587307259c3bb3f54ba02bf371e50c4 192.168.200.185:6381
   slots: (0 slots) slave
   replicates 28cd49566c4cb66eafbda0c273681f107a7ad4fd
M: 1707a1bbbe5d70bf09c51d4438c5de134727d6b0 192.168.200.185:6380
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: 7243ec7e5166afa51b2639c97c59829b3dc763e7 192.168.0.102:6379
   slots: (0 slots) slave
   replicates 1707a1bbbe5d70bf09c51d4438c5de134727d6b0
M: d0f876f972e0f9b49ab8373fe4ea2b581e36b755 192.168.0.102:6381
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 87bbe2f34d74a29ea93d533d6e572848705afa49 192.168.200.249:6380
   slots: (0 slots) slave
   replicates d0f876f972e0f9b49ab8373fe4ea2b581e36b755
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.







./redis-cli --cluster create --cluster-replicas 1 114.115.132.141:6379 114.115.215.192:6380 114.115.159.144:6381 114.115.132.141:6380 114.115.215.192:6381 114.115.159.144:6379

#外网配置
[root@zzsn01 src]# ./redis-cli -a '@!@ZZsn9988.' --cluster create --cluster-replicas 1 114.115.132.141:6379 114.115.215.192:6380 114.115.159.144:6381 114.115.132.141:6380 114.115.215.192:6381 114.115.159.144:6379
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 114.115.215.192:6381 to 114.115.132.141:6379
Adding replica 114.115.159.144:6379 to 114.115.215.192:6380
Adding replica 114.115.132.141:6380 to 114.115.159.144:6381
M: 7013e7e3b8689381a837bf41faea254e544af9ed 114.115.132.141:6379
   slots:[0-5460] (5461 slots) master
M: a62482d339631708d81da555e6af1987081faa42 114.115.215.192:6380
   slots:[5461-10922] (5462 slots) master
M: b4c39592711c665b729e200364716ad719c5908f 114.115.159.144:6381
   slots:[10923-16383] (5461 slots) master
S: 286aae161a10b5baa1793faec7782bd9cb1176fe 114.115.132.141:6380
   replicates b4c39592711c665b729e200364716ad719c5908f
S: 19429f88ef193337a62a1634804219e78cdc6099 114.115.215.192:6381
   replicates 7013e7e3b8689381a837bf41faea254e544af9ed
S: 5deb705ea8a3ed6aac4ea4980981b5d1d69d5731 114.115.159.144:6379
   replicates a62482d339631708d81da555e6af1987081faa42
Can I set the above configuration? (type 'yes' to accept): yes 
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
.
>>> Performing Cluster Check (using node 114.115.132.141:6379)
M: 7013e7e3b8689381a837bf41faea254e544af9ed 114.115.132.141:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 5deb705ea8a3ed6aac4ea4980981b5d1d69d5731 114.115.159.144:6379
   slots: (0 slots) slave
   replicates a62482d339631708d81da555e6af1987081faa42
M: a62482d339631708d81da555e6af1987081faa42 114.115.215.192:6380
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: b4c39592711c665b729e200364716ad719c5908f 114.115.159.144:6381
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 286aae161a10b5baa1793faec7782bd9cb1176fe 114.115.132.141:6380
   slots: (0 slots) slave
   replicates b4c39592711c665b729e200364716ad719c5908f
S: 19429f88ef193337a62a1634804219e78cdc6099 114.115.215.192:6381
   slots: (0 slots) slave
   replicates 7013e7e3b8689381a837bf41faea254e544af9ed
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

四、集群测试

# 114.115.132.141 服务器上
redis-cli -c -p 6379
auth @!@ZZsn9988.

#查看集群状态
cluster nodes