• 1、下载镜像文件
• 2、创建实例并启动
• 3、使用 redis 镜像执行 redis-cli 命令连接
• 配置文件
• Docker 集群设置
  • 1、脚本：创建 6 份配置文件 + 启动 6 份 Redis
  • 2、建立集群，进入一个 master 节点【每个节点 1 个副本】
  • 3、测试集群
    • 1、连入集群，要加 -c
    • 2、设置一些值查看有什么不同【重定向到其他槽】
  • 4、模拟宕机
• Redis 配置文件样例

1、下载镜像文件

docker pull redis:5.0.7

2、创建实例并启动

接下来就是要将redis 的配置文件进行挂载，以配置文件方式启动 redis 容器。（挂载：即将宿主的文件和容器内部目录相关联，相互绑定，在宿主机内修改文件的话也随之修改容器内部文件）

1. 挂载 redis 的配置文件
2. 挂载 redis 的持久化文件（为了数据的持久化）(可以自己决定位置)。
   liunx 下 redis.conf 文件位置：/mydata/redis/conf/redis.conf
   liunx 下 redis 的 data 文件位置 ： /mydata/redis/data

sudo mkdir -p /mydata/redis
sudo mkdir -p /mydata/redis/conf
sudo mkdir -p /mydata/redis/data
sudo mkdir -p /mydata/redis/logs
sudo touch /mydata/redis/conf/redis.conf

不先生成 conf 文件，docker-redis 会默认认为是一个目录而不是文件

docker run --name redis -p 6379:6379  \
--privileged=true  \
--restart=always  \
-m 100m \
--cpus=0.5 \
--log-opt max-size=100m --log-opt max-file=2  \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf  \
-v /mydata/redis/data:/data  \
-v /mydata/redis/logs/redis.log:/var/log/redis/redis-server.log \
-d redis:5.0.7 redis-server /etc/redis/redis.conf  \
--appendonly yes  \
--requirepass "tmesh729"

• docker 参数不能写在 -d 命令后面

1. --restart=always 总是开机启动
2. --log 是日志方面的
3. -p 6379:6379 将容器的 6379 端口挂载到 16379 出去
4. --name 给这个容器取一个名字
5. -v 数据卷挂载
   • /mydata/redis/redis.conf:/etc/redis/redis.conf 这里是将 liunx 路径下的redis.conf 和redis下的redis.conf 挂载在一起。
   • /mydata/redis/data:/data 这个同上
6. -d redis 表示后台启动redis
7. redis-server /etc/redis/redis.conf 以配置文件启动 redis，加载容器内的 conf 文件，最终找到的是挂载的目录 /etc/redis/redis.conf 也就是 liunx 下的/mydata/redis/redis.conf
8. –appendonly yes 开启 redis 持久化
9. –requirepass "tmesh729" 设置密码 （如果你是通过 docker 容器内部连接的话，就随意，可设可不设。但是如果想向外开放的话，一定要设置，我被搞过，可以看这篇文章“阿里云服务器中毒‘Kirito666’经历”）

3、使用 redis 镜像执行 redis-cli 命令连接

进入容器
命令：docker exec -it <容器名> /bin/bash

docker exec -it redis redis-cli

配置文件

redis.conf

# bind 192.168.1.100 10.0.0.1
# bind 127.0.0.1 ::1
# bind 127.0.0.1

protected-mode no
port 6379
tcp-backlog 511
requirepass "tmesh729"
timeout 0
tcp-keepalive 300
daemonize no
supervised no
pidfile /var/run/redis.pid
loglevel notice
logfile ""
databases 30
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir ./
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-disable-tcp-nodelay no
replica-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly yes
appendfilename "appendonly.aof"
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-max-len 128
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes

Docker 集群设置

数据分区
3主3从，从为了同步备份，主进行slot数据分片

1. 高可用【主机宕机从机替代】
2. 数据分片【槽机制】
3. 容灾备份【主从备份】
4. 单点读取压力分担【这里应该没有读写分离，分开读写操作，让读高效进行】

1、脚本：创建 6 份配置文件 + 启动 6 份 Redis

for port in $(seq 7001 7006);  \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF > /mydata/redis/node-${port}/conf/redis.conf
port ${port}
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 192.168.52.131
cluster-announce-port ${port}
cluster-announce-bus-port 1${port}
appendonly yes
EOF
docker run -p ${port}:${port} -p 1${port}:1${port} --name redis-${port} --restart always \
--privileged=true \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d redis:5.0.7 redis-server /etc/redis/redis.conf; \
done

2、建立集群，进入一个 master 节点【每个节点 1 个副本】

然后从 6 个节点挑出 3 个主节点，然后给每个主节点挑一个从节点

docker exec -it redis-7001 /bin/bash 

redis-cli  --cluster create 192.168.52.131:7001 192.168.52.131:7002 192.168.52.131:7003 192.168.52.131:7004 192.168.52.131:7005 192.168.52.131:7006 --cluster-replicas 1

3、测试集群

1、连入集群，要加 -c

redis-cli -c -h 192.168.52.131 -p 7001

2、设置一些值查看有什么不同【重定向到其他槽】

set hello 111
set a aaa

4、模拟宕机

1. 使用 redis 客户端连接一个 master 和 slaver，可以查看到数据拷贝现象
2. cluster info：查看当前集群状态
3. cluster nodes：查看集群节点信息
4. 模拟宕机 docker stop redis-7001
5. cluster info：7001 宕机，7006 从机晋升主机
6. docker start redis-7001：7001 成为 7006 的从节点

Redis 配置文件样例

# 单位注意事项：当需要内存大小时，可以指定，它以通常的形式 1k 5GB 4M 等等：
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
# 单位不区分大小写，所以 1GB 1Gb 1gB 都是一样的
 
################### INCLUDES（包含） ）########################
#这在你有标准配置模板但是每个redis服务器又需要个性设置的时候很有用。等同import导入
# include /path/to/local.conf
# include /path/to/other.conf
 

################### GENERAL（通配）########################
# 是否显示redis的logo
always-show-logo no

# 是否在后台执行，yes：后台运行；no：不是后台运行（老版本默认）
daemonize no
 
# 当Redis以上述守护进程方式运行时，Redis默认会把进程文件写入/var/run/redis.pid文件
pidfile /var/run/redis.pid
 
# 是否开启保护模式。如配置里没有指定bind和密码。开启该参数后，redis只允许本地访问，拒绝外部访问
# 要是开启了密码和bind，可以开启。否则最好关闭，设置为no。
protected-mode no
 
# Redis监听端口号，默认为6379，如果指定0端口，表示Redis不监听TCP连接
port 6379
 
# 只允许来自bind指定网卡的Redis请求。如没有指定，则可以接受来自任意一个网卡的Redis请求
# bind 127.0.0.1
 
#配置unix socket来让redis支持监听本地连接。
# unixsocket /var/run/redis/redis.sock
 
#配置unix socket使用文件的权限
# unixsocketperm 755
 
# 连接超时时间，单位秒；超过timeout，服务端会断开连接，为0则服务端不会主动断开连接，不能小于0
timeout 0
 
# tcp keepalive参数。如果设置不为0，就使用配置tcp的SO_KEEPALIVE值
# 使用keepalive有两个好处:
#  1) 检测挂掉的对端。降低中间设备出问题而导致网络看似连接却已经与对端端口的问题。
#  2) 在Linux内核中，设置了keepalive，redis会定时给对端发送ack。检测到对端关闭需两倍的设置值
tcp-keepalive 0
 
# 指定日志记录级别，四个级别：
# 1) debug：很多信息，方便开发、测试
# 2) verbose：许多有用的信息，但是没有debug级别信息多（默认）
# 3) notice：适当的日志级别，适合生产环境
# 4) warning：只记录非常重要/关键的消息
loglevel verbose
 
# 指定日志文件记录的位置。logfile ""：标准输出。则日志将会发送给/dev/null
logfile ""
 
# 是否将日志输出到系统日志
# syslog-enabled no
 
# syslog的标识符。
# syslog-ident redis
 
# 日志的来源、设备；指定系统日志工具。必须是 USER 或介于 LOCAL0-LOCAL7 之间
# syslog-facility local0
 
# 数据库的数量，默认数据库为0。可通过”SELECT [index]“命令指定数据库
databases 16

# 可以通过upstart和systemd管理Redis守护进程
supervised no

# Redis能通知 Pub/Sub 客户端关于键空间发生的事件，默认关闭("")，notify-keyspace-events的参数可以是字符的任意组合 
# notify-keyspace-events ""

################### SNAPSHOTTING (快照方式)  ########################
 
# 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
# 注释掉“save”这一行配置项就可以让保存数据库功能失效
# 900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化） 
# 300秒（5分钟）内至少10个key值改变（则进行数据库保存--持久化） 
# 60秒（1分钟）内至少10000个key值改变（则进行数据库保存--持久化）
save 900 1
save 300 10
save 60 10000
 
# 当RDB持久化出现错误后，是否依然进行继续进行工作，yes：不能进行工作，no：可以继续进行工作
# 可以通过info中的rdb_last_bgsave_status了解RDB持久化是否有错误
stop-writes-on-bgsave-error yes
 
# 指定存储至本地数据库时是否压缩数据，耗cpu资源，默认为yes，Redis采用LZF压缩
# 如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大
rdbcompression yes
 
# 保存rdb文件时，是否进行错误检查校验。
# 从rdb格式的第五个版本开始，在rdb文件的末尾会带上CRC64的校验和。这跟有利于文件的容错性
# 但是在保存rdb文件的时候，会有大概10%的性能损耗，如果你追求高性能，可以关闭该配置。
rdbchecksum yes
 
# 指定本地数据库文件名（rdb文件的名称），默认值为dump.rdb
dbfilename dump.rdb
 
# 数据目录，数据库的写入会在这个目录。rdb、aof文件也会写在这个目录
# 指定本地数据库存放目录（dump.rdb文件存放目录），rdb、aof文件也会写在这个目录
# 注意，这里只能指定一个目录，不能指定文件名（文件名由上一个dbfilename配置项指定）
dir ./

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

# 接收完RDB文件后清空数据选项，默认值no。
replica-lazy-flush no

################### REPLICATION（主从复制）########################

# 主从复制。使用slaveof从 Redis服务器复制一个Redis实例。注意，该配置仅限于当前slave有效
# 设置当本机为slav服务时，设置master服务的ip地址及端口，Redis启动时，自动从master进行数据同步
# slaveof <masterip> <masterport>
 
# 如master设置了requirepass密码，slave用此选项指定master认证密码
# 下文的“requirepass”配置项可以指定密码
# masterauth <master-password>
 
# 从库同主机失去连接或者复制正在进行，从机库的两种运行方式
# 当slave与master之间的连接断开或slave正在与master进行数据同步时，如果有slave请求
# 1) yes：slave仍然响应请求，此时可能有问题
# 2) no：slave会返回"SYNC with master in progress"错误信息。但INFO和SLAVEOF命令除外。
slave-serve-stale-data yes
 
# 作为从服务器，默认情况下是只读的（yes），可以修改成NO，用于写（不建议）。
slave-read-only yes
 
# 是否使用socket方式复制数据。目前redis复制提供两种方式，disk和socket。如果新的slave连上来或# 者重连的slave无法部分同步，就会执行全量同步，master会生成rdb文件。
# 有2种方式：
#   1) disk：master创建一个新的进程把rdb文件保存到磁盘，再把磁盘上的rdb文件传递给slave。
#   2) socket：master创建一个新的进程，直接把rdb文件以socket的方式发给slave。
# disk方式时，当一个rdb保存的过程中，多个slave都能共享这个rdb文件。
# socket方式就得一个个slave顺序复制。在磁盘速度缓慢，网速快的情况下推荐用socket方式。
repl-diskless-sync no
 
# diskless复制的延迟时间，防止设置为0。一旦复制开始
# 节点不会再接收新slave的复制请求直到下一个rdb传输。所以最好等待一段时间，等更多的slave连上来
repl-diskless-sync-delay 5
 
# slave根据指定的时间间隔向服务器发送ping请求。默认10秒。
# repl-ping-slave-period 10
 
# 复制连接超时时间。master和slave都有超时时间的设置。
# master检测到slave上次发送的时间超过repl-timeout，即认为slave离线，清除该slave信息。
# slave检测到上次和master交互的时间超过repl-timeout，则认为master离线。
# 需注意repl-timeout需设置一个比repl-ping-slave-period更大的值，不然会经常检测到超时。
# repl-timeout 60
 
# 是否禁止复制tcp链接的tcp nodelay参数，默认是no，即使用tcp nodelay。
# 如master设置了yes，在把数据复制给slave时，会减少包的数量和更小的网络带宽。
# 但这也可能带来数据的延迟。默认我们推荐更小的延迟，但在数据量传输很大的场景下，建议选择yes。
repl-disable-tcp-nodelay no
 
# 复制缓冲区大小，这是一个环形复制缓冲区，用来保存最新复制的命令。
# 这样在slave离线时，无需完全复制master的数据，如果可以执行部分同步，只需把缓冲区的部分数据复制# 给slave，就能恢复正常复制状态。缓冲区的大小越大，slave离线的时间可以更长，复制缓冲区只有在有
# slave连接的时候才分配内存。没有slave的一段时间，内存会被释放出来，默认1m。
# repl-backlog-size 5mb
 
# master没有slave一段时间会释放复制缓冲区的内存，repl-backlog-ttl设置该时间长度。单位为秒
# repl-backlog-ttl 3600
 
# 当master不可用，Sentinel会根据slave的优先级选举一个master。
# 最低的优先级的slave，当选master。而配置成0，永远不会被选举。
slave-priority 100
 
# master停止写入的方式，健康的slave的个数小于N，mater就禁止写入。master最少得有多少个健康的
# slave存活才能执行写命令。这个配置虽然不能保证N个slave都一定能接收到master的写操作，
# 但能避免没有足够健康的slave时，master不能写入来避免数据丢失。设置为0是关闭该功能。
# min-slaves-to-write 3
 
# 延迟小于min-slaves-max-lag 秒的slave才认为是健康的slave。
# min-slaves-max-lag 10

# 当一个slave失去和master的连接，或者同步正在进行中，slave的行为有两种可能： 
# 1) 如果 replica-serve-stale-data 设置为 "yes" (默认值)，slave会继续响应客户端请求，可能是正常数据，也可能是还没获得值的空数据。
# 2) 如果 replica-serve-stale-data 设置为 "no"，slave会回复"正在从master同步（SYNC with master in progress）"来处理各种请求，除了 INFO 和 SLAVEOF 命令。
replica-serve-stale-data yes

# 你可以配置salve实例是否接受写操作。可写的slave实例可能对存储临时数据比较有用(因为写入salve# 的数据在同master同步之后将很容被删除)，但是如果客户端由于配置错误在写入时也可能产生一些问题。
# 从Redis2.6默认所有的slave为只读
# 注意:只读的slave不是为了暴露给互联网上不可信的客户端而设计的。它只是一个防止实例误用的保护层。
# 一个只读的slave支持所有的管理命令比如config,debug等。为了限制你可以用'rename-command'来隐藏所有的管理和危险命令来增强只读slave的安全性。
replica-read-only yes

# 从机竞争主机的优先级，值越小优先级越高
# replica-priority 100

################### SECURITY（安全）########################
 
# 配置redis连接认证密码
# 如果配置了，则客户端在连接Redis时需通过auth <password>命令提供密码（默认关闭）
# 注意：因为redis太快了，每秒可认证15w次密码，简单的很容易被攻破，最好使用一个更复杂的密码
# requirepass foobared
 
# 把危险的命令给修改成其他名称。比如CONFIG命令可以重命名为一个很难被猜到的命令
# 这样用户不能使用，而内部工具还能接着使用。
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
 
# 设置成一个空的值，可以禁止一个命令
# rename-command CONFIG ""

################### LIMITS（限制）########################
 
# 设置连上redis的最大客户端连接数量。默认10000。设置0表示不作限制。
# 超出此数，Redis会关闭新的连接并向客户端返回max Number of clients reached错误
# redis不区分连接是客户端连接还是内部打开文件或和slave连接等，故maxclients最小建议设置到32
# maxclients 10000
 
# 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中
# 当内存满了，配合maxmemory-policy策略进行处理
# 当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。
# maxmemory <bytes>
 
# 内存容量超过maxmemory后的处理策略如下几种策略：
#  1) volatile-lru：只对设置过期时间的key进行LRU算法删除（默认）
#  2) allkeys-lru：删除不经常使用的key
#  3) volatile-random：随机删除即将过期的key
#  4) allkeys->random：随机删除一个key
#  5) volatile-ttl：删除即将过期的的key
#  6) noeviction：不移除任何key，对于写命令返回报错
# maxmemory-policy volatile-lru

# lru检测的样本数。
# 使用lru或ttl淘汰算法，从需要淘汰的列表中随机选择sample个key，选出闲置时间最长的key移除。
# maxmemory-samples 3

# 在`linux`系统中控制tcp三次握手`已完成连接队列`的长度，默认值511
# tcp-backlog 511
 
################### APPEND ONLY MODE （附加模式）########################
 
# AOF持久化，指定是否在每次更新操作后进行日志记录，默认redis是异步（快照）的把数据写入本地磁盘
# redis默认使用的是rdb方式持久化，此方式在许多应用中已足够用。
# 但redis如果中途宕机，会导致可能有几分钟的数据丢失，按照上面save条件来策略进行持久化
# Append Only File是另一种持久化方式，可提供更好的持久化特性。
# Redis会把每次写入的数据在接收后都写入appendonly.aof 文件
# 每次启动时Redis都会先把这个文件的数据读入内存里，先忽略RDB文件。
appendonly no
 
# 指定aof文件名，默认为appendonly.aof
# appendfilename appendonly.aof
 
# AOF持久化三种同步策略：
#   1) no：不同步（不执行fsync），数据不会持久化
#   2) always：每次有数据发生变化时都会写入appendonly.aof（慢，安全）
#   3) everysec：每秒同步一次到appendonly.aof，可能会导致丢失这1s数据（折中选择，默认值）
appendfsync everysec
 
# 在AOF重写或写入rdb文件时，会执行大量IO
# 对于everysec和always的AOF模式来说，执行fsync会造成阻塞过长时间
# yes：表示rewrite期间对新写操作不fsync,暂时存在内存中,等rewrite完成后再写入
# 默认为no，建议yes。Linux的默认fsync策略是30秒。可能丢失30秒数据。
no-appendfsync-on-rewrite no

# AOF自动重写配置。当目前AOF文件大小超过上一次重写的aof文件大小的百分之多少进行重写
# 即当AOF文件增长到一定大小时，Redis能调用bgrewriteaof对日志文件进行重写。
# 当前AOF文件大小是上次日志重写得到AOF文件大小的二倍（设置为100）时，自动启动新的日志重写过程。
auto-aof-rewrite-percentage 100
 
# 设置允许重写的最小AOF文件大小，避免了达到约定百分比但尺寸仍然很小的情况还要重写
auto-aof-rewrite-min-size 64mb
 
#aof文件可能在尾部是不完整的，当redis启动的时候，aof文件的数据被载入内存。重启可能发生在redis所在的主机操作系统宕机后，尤其在ext4文件系统没有加上data=ordered选项（redis宕机或者异常终止不会造成尾部不完整现象。）出现这种现象，可以选择让redis退出，或者导入尽可能多的数据。如果选择的是yes，当截断的aof文件被导入的时候，会自动发布一个log给客户端然后load。如果是no，用户必须手动redis-check-aof修复AOF文件才可以。
aof-load-truncated yes

# 在AOF重写时，如果打开了aof-rewrite-incremental-fsync开关，系统会每32MB执行一次fsync。
# 这对于把文件写入磁盘是有帮助的，可以避免过大的延迟峰值。
aof-rewrite-incremental-fsync yes

# 加载时Redis识别出AOF文件以“REDIS”开头字符串， #并加载带此前缀的RDB文件，然后继续加载AOF 
# aof-use-rdb-preamble yes

################### LUA SCRIPTING（LUA 脚本）########################
 
# 如果达到最大时间限制（毫秒），redis会记个log，然后返回error。当一个脚本超过了最大时限。
# 只有SCRIPT KILL和SHUTDOWN NOSAVE可以用。第一个可以杀没有调write命令的东西。
# 要是已经调用了write，只能用第二个命令杀。
lua-time-limit 5000

################### REDIS CLUSTER（Redis集群）########################
 
# 集群开关，默认是不开启集群模式。
# cluster-enabled yes
 
# 集群配置文件的名称，每个节点都有一个集群相关的配置文件，持久化保存集群的信息。
# 这个文件无需手动配置，这个配置文件有Redis生成并更新，每个Redis集群节点需要一个单独的配置文件，# 请确保与实例运行的系统中配置文件名称不冲突
# cluster-config-file nodes-6379.conf
 
# 节点互连超时的阀值。集群节点超时毫秒数
# cluster-node-timeout 15000
 
# 在进行故障转移时，全部slave会请求申请为master，有些slave可能与master断开连接一段时间了，
# 导致数据过于陈旧，这种slave不该提升为master。该参数判断slave与master断线的时间是否过长。
# 判断方法是：比较slave断开连接的时间和
#   (node-timeout * slave-validity-factor) + repl-ping-slave-period
# 如果节点超时时间为三十秒, 并且slave-validity-factor为10
# 假设默认的repl-ping-slave-period是10秒，即如果超过310秒slave将不会尝试进行故障转移 
# cluster-slave-validity-factor 10
 
# master的slave数量大于该值，slave才能迁移到其他孤立master上，如这个参数若被设为2，
# 那么只有当一个主节点拥有2 个可工作的从节点时，它的一个从节点会尝试迁移。
# cluster-migration-barrier 1
 
# 默认情况下，集群全部的slot有节点负责，集群状态才为ok，才能提供服务。
# 设置为no，可以在slot没有全部分配的时候提供服务。
# 不建议打开该配置，这样会造成分区时，小分区的master一直在接受写请求，而造成很长时间数据不一致。
# cluster-require-full-coverage yes

################### SLOW LOG （慢日志）########################
 
# slog log是用来记录redis运行中执行比较慢的命令耗时。
# 当命令的执行超过了指定时间，就记录在slow log中，slog log保存在内存中，所以没有IO操作。
# 执行时间比slowlog-log-slower-than大的请求记录到slowlog里面，单位是微秒
# 所以1000000就是1秒。注意，负数时间会禁用慢查询日志，而0则会强制记录所有命令。
slowlog-log-slower-than 10000
 
# 慢查询日志长度。当一个新的命令被写进日志时，最老的那个记录会被删掉。
# 这个长度没有限制。只要有足够的内存就行。你可以通过 SLOWLOG RESET 来释放内存。
slowlog-max-len 1024

################### VIRTUAL MEMORY（ 虚拟内存）########################
 
# 指定是否启用虚拟内存机制，默认no，
# VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上（内存占用多，最好关闭）
# 访问多的页面由磁盘自动换出到内存中
vm-enabled no

# 虚拟内存文件位置，默认值为/tmp/redis.swap，不可多个Redis实例共享
# Redis交换文件最好的存储是SSD（固态硬盘）
vm-swap-file /tmp/redis.swap
 
# redis使用的最大内存上限，保护redis不会因过多使用物理内存影响性能
# 将大于vm-max-memory的数据存入虚拟内存，但无论设置多少，所有索引数据都是内存存储的（即keys）
# 当vm-max-memory设置为0时，所有value都存在于磁盘。默认值为0
vm-max-memory 0
 
# Redis swap文件分成了很多的page，一个对象可以保存在多个page上面
# 但一个page上不能被多个对象共享，vm-page-size是要根据存储的数据大小来设定的。
# 建议：
#    如果存储很多小对象，page大小设置为32或64字节；
#    如果存储很大的对象，则可以使用更大的page，如果不确定，就使用默认值
# 每个页面的大小设置为32字节
vm-page-size 32
 
# 设置swap文件中页面数量
# 由于页表（一种表示页面空闲或使用的bitmap）是存放在内存中的，在磁盘上每8个页将消耗1byte的内存
# swap空间总容量为 vm-page-size * vm-pages
vm-pages 134217728
 
# 设置访问swap文件的线程数，最后不要超过机器的核数
# 如果设置为0，那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟，默认值为4
vm-max-threads 4

################### ADVANCED CONFIG（高级配置）########################

# 当hash只有少量的entry时，并且最大的entry所占空间没有超过指定的限制时，会用一种节省内存的 #数据结构来编码。可以通过下面的指令来设定限制 
hash-max-ziplist-entries 512 
hash-max-ziplist-value 64

# 哈希表中元素（条目）总个数<=512个，采用ziplist，否则使用hash
hash-max-zipmap-entries 512   
 
# 哈希表中每个value的长度<=64字节时，采用ziplist，否则使用hash
hash-max-zipmap-value 64     

# list元素<=512个，采用ziplist，否则用linkedlist
list-max-ziplist-entries 512
 
# list内某个元素大小<=64字节时，采用ziplist，否则用linkedlist 
list-max-ziplist-value 64

#当取正值的时候，表示按照数据项个数来限定每个quicklist节点上的ziplist长度。比如，当这个参数配置 #成5的时候，表示每个quicklist节点的ziplist最多包含5个数据项。 #当取负值的时候，表示按照占用字节数来限定每个quicklist节点上的ziplist长度。这时，它只能取-1到-5 #这五个值，每个值含义如下： #-5: 每个quicklist节点上的ziplist大小不能超过64 Kb。（注：1kb => 1024 bytes） #-4: 每个quicklist节点上的ziplist大小不能超过32 Kb。 #-3: 每个quicklist节点上的ziplist大小不能超过16 Kb。 #-2: 每个quicklist节点上的ziplist大小不能超过8 Kb。（-2是Redis给出的默认值） #-1: 每个quicklist节点上的ziplist大小不能超过4 Kb。 
# list-max-ziplist-size -2

# 这个参数表示一个quicklist两端不被压缩的节点个数。 #注：这里的节点个数是指quicklist双向链表的节点个数，而不是指ziplist里面的数据项个数。 #实际上，一个quicklist节点上的ziplist，如果被压缩，就是整体被压缩的。 #参数list-compress-depth的取值含义如下： #0: 是个特殊值，表示都不压缩。这是Redis的默认值。 #1: 表示quicklist两端各有1个节点不压缩，中间的节点压缩。 #2: 表示quicklist两端各有2个节点不压缩，中间的节点压缩。 #3: 表示quicklist两端各有3个节点不压缩，中间的节点压缩。 #依此类推… #由于0是个特殊值，很容易看出quicklist的头节点和尾节点总是不被压缩的，以便于在表的两端进行快速存取。 
# list-compress-depth 0

# set内元素数量<=512个，且都是整数型值，采用inset，否则使用hashtable
set-max-intset-entries 512

# zset内元素数量<=128个，采用ziplist，否则用skiplist跳表 
zset-max-ziplist-entries 128
 
# zset内某个元素大小<=64字节时，采用ziplist，否则用skiplist跳表 
zset-max-ziplist-value 64

# value大小 <= hll-sparse-max-bytes使用稀疏数据结构（sparse）
# value大小 > hll-sparse-max-bytes使用稠密的数据结构（dense）。
# 一个比16000大的value是几乎没用的，建议的value大概为3000。
# 如果对CPU要求不高，对空间要求较高的，建议设置到10000左右。
hll-sparse-max-bytes 3000

# Streams宏节点最大大小/项目。流数据结构是基数编码内部多个项目的大节点树。使用此配置 #可以配置单个节点的字节数，以及切换到新节点之前可能包含的最大项目数 #追加新的流条目。如果以下任何设置设置为0，忽略限制，因此例如可以设置一个 #大入口限制将max-bytes设置为0，将max-entries设置为所需的值 
stream-node-max-bytes 4096 
stream-node-max-entries 100

# Redis将在每100毫秒时使用1毫秒的CPU时间来对redis的hash表进行重新hash，可以降低内存的使用。
# 当你的使用场景中，有非常严格的实时性需要，不能够接受Redis时不时的对请求有2毫秒的延迟的话
# 把这项配置为no。如果没有这么严格的实时性要求，可以设置为yes，以便能够尽可能快的释放内存。
# 指定是否激活重置哈希，默认为开启
activerehashing yes
 
# 对客户端输出缓冲进行限制,可以强迫那些不从服务器读取数据的客户端断开连接
# 用来强制关闭传输缓慢的客户端。
# 对于normal client，第一个0表示取消hard limit，第二个0和第三个0表示取消soft limit
# normal client默认取消限制，因为如果没有寻问，他们是不会接收数据的。
client-output-buffer-limit normal 0 0 0
 
# 对于slave client和 MONITER client，如果client-output-buffer一旦超过256mb
# 又或者超过64mb持续60秒，那么服务器就会立即断开客户端连接。
client-output-buffer-limit slave 256mb 64mb 60
 
# 对于pubsub client，如果client-output-buffer一旦超过32mb，又或者超过8mb持续60秒，
# 那么服务器就会立即断开客户端连接。
client-output-buffer-limit pubsub 32mb 8mb 60
 
# redis执行任务的频率为1s除以hz。
hz 10

# 开启动态hz 
dynamic-hz yes

# lazy freeing 懒惰释放
# lazy free应用于被动删除中，目前有4种场景，每种场景对应一个配置参数； 默认都是关闭。
# 内存满时逐出，默认值no；
lazyfree-lazy-eviction no
# 删除过期key，默认值no；
lazyfree-lazy-expire no
# 内部删除，比如rename oldkey newkey时，如果newkey存在需要删除newkey，默认值no；
lazyfree-lazy-server-del no