redis配置文件

查看配置文件:https://raw.githubusercontent.com/antirez/redis/5.0.3/redis.conf

主要参数说明

redis.conf 配置项说明如下:

序号

配置项

说明

1

daemonize no

Redis 默认不是以守护进程的方式运行,可以通过该配置项修改,使用 yes 启用守护进程(Windows 不支持守护线程的配置为 no )

2

pidfile /var/run/redis.pid

当 Redis 以守护进程方式运行时,Redis 默认会把 pid 写入 /var/run/redis.pid 文件,可以通过 pidfile 指定

3

port 6379

指定 Redis 监听端口,默认端口为 6379,作者在自己的一篇博文中解释了为什么选用 6379 作为默认端口,因为 6379 在手机按键上 MERZ 对应的号码,而 MERZ 取自意大利歌女 Alessia Merz 的名字

4

bind 127.0.0.1

绑定的主机地址

5

timeout 300

当客户端闲置多长时间后关闭连接,如果指定为 0,表示关闭该功能

6

loglevel notice

指定日志记录级别,Redis 总共支持四个级别:debug、verbose、notice、warning,默认为 notice

7

logfile stdout

日志记录方式,默认为标准输出,如果配置 Redis 为守护进程方式运行,而这里又配置为日志记录方式为标准输出,则日志将会发送给 /dev/null

8

databases 16

设置数据库的数量,默认数据库为0,可以使用SELECT 命令在连接上指定数据库id

9

save <seconds> <changes> Redis 默认配置文件中提供了三个条件: save 900 1 save 300 10 save 60 10000 分别表示 900 秒(15 分钟)内有 1 个更改,300 秒(5 分钟)内有 10 个更改以及 60 秒内有 10000 个更改。

指定在多长时间内,有多少次更新操作,就将数据同步到数据文件,可以多个条件配合

10

rdbcompression yes

指定存储至本地数据库时是否压缩数据,默认为 yes,Redis 采用 LZF 压缩,如果为了节省 CPU 时间,可以关闭该选项,但会导致数据库文件变的巨大

11

dbfilename dump.rdb

指定本地数据库文件名,默认值为 dump.rdb

12

dir ./

指定本地数据库存放目录

13

slaveof <masterip> <masterport>

设置当本机为 slav 服务时,设置 master 服务的 IP 地址及端口,在 Redis 启动时,它会自动从 master 进行数据同步

14

masterauth <master-password>

当 master 服务设置了密码保护时,slav 服务连接 master 的密码

15

requirepass foobared

设置 Redis 连接密码,如果配置了连接密码,客户端在连接 Redis 时需要通过 AUTH <password> 命令提供密码,默认关闭

16

maxclients 128

设置同一时间最大客户端连接数,默认无限制,Redis 可以同时打开的客户端连接数为 Redis 进程可以打开的最大文件描述符数,如果设置 maxclients 0,表示不作限制。当客户端连接数到达限制时,Redis 会关闭新的连接并向客户端返回 max number of clients reached 错误信息

17

maxmemory <bytes>

指定 Redis 最大内存限制,Redis 在启动时会把数据加载到内存中,达到最大内存后,Redis 会先尝试清除已到期或即将到期的 Key,当此方法处理 后,仍然到达最大内存设置,将无法再进行写入操作,但仍然可以进行读取操作。Redis 新的 vm 机制,会把 Key 存放内存,Value 会存放在 swap 区

18

appendonly no

指定是否在每次更新操作后进行日志记录,Redis 在默认情况下是异步的把数据写入磁盘,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为 redis 本身同步数据文件是按上面 save 条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认为 no

19

appendfilename appendonly.aof

指定更新日志文件名,默认为 appendonly.aof

20

appendfsync everysec

指定更新日志条件,共有 3 个可选值: no:表示等操作系统进行数据缓存同步到磁盘(快) always:表示每次更新操作后手动调用 fsync() 将数据写到磁盘(慢,安全) everysec:表示每秒同步一次(折中,默认值)

21

vm-enabled no

指定是否启用虚拟内存机制,默认值为 no,简单的介绍一下,VM 机制将数据分页存放,由 Redis 将访问量较少的页即冷数据 swap 到磁盘上,访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析 Redis 的 VM 机制)

22

vm-swap-file /tmp/redis.swap

虚拟内存文件路径,默认值为 /tmp/redis.swap,不可多个 Redis 实例共享

23

vm-max-memory 0

将所有大于 vm-max-memory 的数据存入虚拟内存,无论 vm-max-memory 设置多小,所有索引数据都是内存存储的(Redis 的索引数据 就是 keys),也就是说,当 vm-max-memory 设置为 0 的时候,其实是所有 value 都存在于磁盘。默认值为 0

24

vm-page-size 32

Redis swap 文件分成了很多的 page,一个对象可以保存在多个 page 上面,但一个 page 上不能被多个对象共享,vm-page-size 是要根据存储的 数据大小来设定的,作者建议如果存储很多小对象,page 大小最好设置为 32 或者 64bytes;如果存储很大大对象,则可以使用更大的 page,如果不确定,就使用默认值

25

vm-pages 134217728

设置 swap 文件中的 page 数量,由于页表(一种表示页面空闲或使用的 bitmap)是在放在内存中的,,在磁盘上每 8 个 pages 将消耗 1byte 的内存。

26

vm-max-threads 4

设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4

27

glueoutputbuf yes

设置在向客户端应答时,是否把较小的包合并为一个包发送,默认为开启

28

hash-max-zipmap-entries 64 hash-max-zipmap-value 512

指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法

29

activerehashing yes

指定是否激活重置哈希,默认为开启(后面在介绍 Redis 的哈希算法时具体介绍)

30

include /path/to/local.conf

指定包含其它的配置文件,可以在同一主机上多个Redis实例之间使用同一份配置文件,而同时各个实例又拥有自己的特定配置文件

  • no:表示等操作系统进行数据缓存同步到磁盘(快)
  • always:表示每次更新操作后手动调用 fsync() 将数据写到磁盘(慢,安全)
  • everysec:表示每秒同步一次(折中,默认值)

21 vm-enabled no 指定是否启用虚拟内存机制,默认值为 no,简单的介绍一下,VM 机制将数据分页存放,由 Redis 将访问量较少的页即冷数据 swap 到磁盘上,访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析 Redis 的 VM 机制) 22 vm-swap-file /tmp/redis.swap 虚拟内存文件路径,默认值为 /tmp/redis.swap,不可多个 Redis 实例共享 23 vm-max-memory 0 将所有大于 vm-max-memory 的数据存入虚拟内存,无论 vm-max-memory 设置多小,所有索引数据都是内存存储的(Redis 的索引数据 就是 keys),也就是说,当 vm-max-memory 设置为 0 的时候,其实是所有 value 都存在于磁盘。默认值为 0 24 vm-page-size 32 Redis swap 文件分成了很多的 page,一个对象可以保存在多个 page 上面,但一个 page 上不能被多个对象共享,vm-page-size 是要根据存储的 数据大小来设定的,作者建议如果存储很多小对象,page 大小最好设置为 32 或者 64bytes;如果存储很大大对象,则可以使用更大的 page,如果不确定,就使用默认值 25 vm-pages 134217728 设置 swap 文件中的 page 数量,由于页表(一种表示页面空闲或使用的 bitmap)是在放在内存中的,,在磁盘上每 8 个 pages 将消耗 1byte 的内存。 26 vm-max-threads 4 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4 27 glueoutputbuf yes 设置在向客户端应答时,是否把较小的包合并为一个包发送,默认为开启 28 hash-max-zipmap-entries 64 hash-max-zipmap-value 512 指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法 29 activerehashing yes 指定是否激活重置哈希,默认为开启(后面在介绍 Redis 的哈希算法时具体介绍) 30 include /path/to/local.conf 指定包含其它的配置文件,可以在同一主机上多个Redis实例之间使用同一份配置文件,而同时各个实例又拥有自己的特定配置文件

Redis配置文件解析

Redis 3.2.100 配置文件解析

  1. # redis版本 3.2.100
  2. # 如果想要使用到配置文件,Redis服务必须以配置文件的路径作为第一个参数启动。如:
  3. ./redis-server /path/to/redis.conf
  4. # 单位说明:当需要指定内存大小时,可能会用到不同的单位,如1k、5GB、4M等,这里给出其单位含义:
  5. # 指定单位是大小写不敏感。如1GB、1gB、1Gb是一样的。
  6. # 1k => 1000 bytes
  7. # 1kb => 1024 bytes
  8. # 1m => 1000000 bytes
  9. # 1mb => 1024*1024 bytes
  10. # 1g => 1000000000 bytes
  11. # 1gb => 1024*1024*1024 bytes
  12. ######################### 引用 #########################
  13. # 不同redis server可以使用同一个模版配置作为主配置,并引用其它配置文
  14. # 件用于本server的个性化设置include并不会被CONFIG REWRITE命令覆盖。
  15. # 但是主配置文件的选项会被覆盖。想故意覆盖主配置的话就把include放文件前面,
  16. # 否则最好放末尾
  17. # include /path/to/local.conf
  18. # include /path/to/other.conf
  19. ######################### 网络 #########################
  20. # 不指定bind的话redis将会监听所有网络接口。这个配置是肯定需要指定的。
  21. # Examples:
  22. # bind 192.168.1.100 10.0.0.1
  23. # bind 127.0.0.1 ::1
  24. # 下面这个配置是只允许本地客户端访问。
  25. bind 127.0.0.1
  26. # 是否开启保护模式。默认开启,如果没有设置bind项的ip和redis密码的话,服务将只允许本地访问。
  27. protected-mode yes
  28. # 端口设置,默认为 6379
  29. # 如果port设置为0 redis将不会监听tcp socket
  30. port 6379
  31. # 在高并发环境下需要一个高backlog值来避免慢客户端连接问题。注意Linux内核默默将这个值减小到/proc/sys/net/core/somaxconn的值,所以需要确认增大somaxconn和tcp_max_syn_backlog 两个值来达到需要的效果。
  32. tcp-backlog 511
  33. # 指定用来监听Unix套套接字的路径。没有默认值,没有指定的情况下Redis不会监听Unix socket
  34. # unixsocket /tmp/redis.sock
  35. # unixsocketperm 700
  36. # 客户端空闲多少秒后关闭连接(0为不关闭)
  37. timeout 0
  38. # tcp-keepalive设置。如果非零,
  39. # 则设置SO_KEEPALIVE选项来向空闲连接的客户端发送ACK,用途如下:
  40. # 1)能够检测无响应的对端
  41. # 2)让该连接中间的网络设备知道这个连接还存活
  42. # 在Linux上,这个指定的值(单位秒)就是发送ACK的时间间隔。
  43. # 注意:要关闭这个连接需要两倍的这个时间值。
  44. # 在其他内核上这个时间间隔由内核配置决定
  45. tcp-keepalive 0
  46. ######################### 通用 #########################
  47. # 是否将Redis作为守护进程运行。如果需要的话配置成'yes'
  48. # 注意配置成守护进程后Redis会将进程号写入文件/var/run/redis.pid
  49. daemonize no
  50. # 是否通过upstart或systemd管理守护进程。默认no没有服务监控,其它选项有upstart, systemd, auto
  51. supervised no
  52. # pid文件在redis启动时创建,退出时删除。最佳实践为配置该项。
  53. pidfile /var/run/redis_6379.pid
  54. # 配置日志级别。选项有debug, verbose, notice, warning
  55. loglevel notice
  56. # 日志名称。空字符串表示标准输出。注意如果redis配置为后台进程,标准输出中信息会发送到/dev/null
  57. logfile ""
  58. # 是否启动系统日志记录。
  59. # syslog-enabled no
  60. # 指定系统日志身份。
  61. # syslog-ident redis
  62. # 指定syslog设备。必须是user或LOCAL0 ~ LOCAL7之一。
  63. # syslog-facility local0
  64. # 设置数据库个数。默认数据库是 DB 0
  65. # 可以通过SELECT where dbid is a number between 0 and 'databases'-1为每个连接使用不同的数据库。
  66. databases 16
  67. ######################### 备份 #########################
  68. # 持久化设置:
  69. # 下面的例子将会进行把数据写入磁盘的操作:
  70. # 900秒(15分钟)之后,且至少1次变更
  71. # 300秒(5分钟)之后,且至少10次变更
  72. # 60秒之后,且至少10000次变更
  73. # 不写磁盘的话就把所有 "save" 设置注释掉就行了。
  74. # 通过添加一条带空字符串参数的save指令也能移除之前所有配置的save指令,如: save ""
  75. save 900 1
  76. save 300 10
  77. save 60 10000
  78. # 默认情况下如果上面配置的RDB模式开启且最后一次的保存失败,redis 将停止接受写操作,
  79. # 让用户知道问题的发生。如果后台保存进程重新启动工作了,redis 也将自动的允许写操作。
  80. # 如果有其它监控方式也可关闭。
  81. stop-writes-on-bgsave-error yes
  82. # 是否在备份.rdb文件时是否用LZF压缩字符串,默认设置为yes。如果想节约cpu资源可以把它设置为no。
  83. rdbcompression yes
  84. # 因为版本5的RDB有一个CRC64算法的校验和放在了文件的末尾。这将使文件格式更加可靠,
  85. # 但在生产和加载RDB文件时,这有一个性能消耗(大约10%),可以关掉它来获取最好的性能。
  86. # 生成的关闭校验的RDB文件有一个0的校验和,它将告诉加载代码跳过检查
  87. rdbchecksum yes
  88. # rdb文件名称
  89. dbfilename dump.rdb
  90. # 备份文件目录,文件名就是上面的 "dbfilename" 的值。累加文件也放这里。
  91. # 注意你这里指定的必须是目录,不是文件名。
  92. dir ./
  93. ######################### 主从同步 #########################
  94. # 主从同步配置。
  95. # 1) redis主从同步是异步的,但是可以配置在没有指定slave连接的情况下使master停止写入数据。
  96. # 2) 连接中断一定时间内,slave可以执行部分数据重新同步。
  97. # 3) 同步是自动的,slave可以自动重连且同步数据。
  98. # slaveof <masterip> <masterport>
  99. # master连接密码
  100. # masterauth <master-password>
  101. # 当一个slave失去和master的连接,或者同步正在进行中,slave的行为有两种可能:
  102. # 1) 如果 slave-serve-stale-data 设置为 "yes" (默认值),slave会继续响应客户端请求,可能是正常数据,也可能是还没获得值的空数据。
  103. # 2) 如果 slave-serve-stale-data 设置为 "no",slave会回复"正在从master同步(SYNC with master in progress)"来处理各种请求,除了 INFO 和 SLAVEOF 命令。
  104. slave-serve-stale-data yes
  105. # 你可以配置salve实例是否接受写操作。可写的slave实例可能对存储临时数据比较有用(因为写入salve# 的数据在同master同步之后将很容被删除),但是如果客户端由于配置错误在写入时也可能产生一些问题。
  106. # 从Redis2.6默认所有的slave为只读
  107. # 注意:只读的slave不是为了暴露给互联网上不可信的客户端而设计的。它只是一个防止实例误用的保护层。
  108. # 一个只读的slave支持所有的管理命令比如config,debug等。为了限制你可以用'rename-command'来隐藏所有的管理和危险命令来增强只读slave的安全性。
  109. slave-read-only yes
  110. # 同步策略: 磁盘或socket,默认磁盘方式
  111. repl-diskless-sync no
  112. # 如果非磁盘同步方式开启,可以配置同步延迟时间,以等待master产生子进程通过socket传输RDB数据给slave。
  113. # 默认值为5秒,设置为0秒则每次传输无延迟。
  114. repl-diskless-sync-delay 5
  115. # slave根据指定的时间间隔向master发送ping请求。默认10秒。
  116. # repl-ping-slave-period 10
  117. # 同步的超时时间
  118. # 1)slave在与master SYNC期间有大量数据传输,造成超时
  119. # 2)在slave角度,master超时,包括数据、ping等
  120. # 3)在master角度,slave超时,当master发送REPLCONF ACK pings# 确保这个值大于指定的repl-ping-slave-period,否则在主从间流量不高时每次都会检测到超时
  121. # repl-timeout 60
  122. # 是否在slave套接字发送SYNC之后禁用 TCP_NODELAY
  123. # 如果选择yes,Redis将使用更少的TCP包和带宽来向slaves发送数据。但是这将使数据传输到slave上有延迟,Linux内核的默认配置会达到40毫秒。
  124. # 如果选择no,数据传输到salve的延迟将会减少但要使用更多的带宽。
  125. # 默认我们会为低延迟做优化,但高流量情况或主从之间的跳数过多时,可以设置为“yes”。
  126. repl-disable-tcp-nodelay no
  127. # 设置数据备份的backlog大小。backlog是一个slave在一段时间内断开连接时记录salve数据的缓冲,所以一个slave在重新连接时,不必要全量的同步,而是一个增量同步就足够了,将在断开连接的这段# 时间内把slave丢失的部分数据传送给它。
  128. # 同步的backlog越大,slave能够进行增量同步并且允许断开连接的时间就越长。
  129. # backlog只分配一次并且至少需要一个slave连接。
  130. # repl-backlog-size 1mb
  131. # 当master在一段时间内不再与任何slave连接,backlog将会释放。以下选项配置了从最后一个
  132. # slave断开开始计时多少秒后,backlog缓冲将会释放。
  133. # 0表示永不释放backlog
  134. # repl-backlog-ttl 3600
  135. # slave的优先级是一个整数展示在Redis的Info输出中。如果master不再正常工作了,sentinel将用它来选择一个slave提升为master。
  136. # 优先级数字小的salve会优先考虑提升为master,所以例如有三个slave优先级分别为10,100,25,sentinel将挑选优先级最小数字为10的slave。
  137. # 0作为一个特殊的优先级,标识这个slave不能作为master,所以一个优先级为0的slave永远不会被# sentinel挑选提升为master。
  138. # 默认优先级为100
  139. slave-priority 100
  140. # 如果master少于N个延时小于等于M秒的已连接slave,就可以停止接收写操作。
  141. # N个slave需要是“oneline”状态。
  142. # 延时是以秒为单位,并且必须小于等于指定值,是从最后一个从slave接收到的ping(通常每秒发送)开始计数。
  143. # 该选项不保证N个slave正确同步写操作,但是限制数据丢失的窗口期。
  144. # 例如至少需要3个延时小于等于10秒的slave用下面的指令:
  145. # min-slaves-to-write 3
  146. # min-slaves-max-lag 10
  147. # 两者之一设置为0将禁用这个功能。
  148. # 默认 min-slaves-to-write 值是0(该功能禁用)并且 min-slaves-max-lag 值是10。
  149. ######################### 安全 #########################
  150. # 要求客户端在处理任何命令时都要验证身份和密码。
  151. # requirepass foobared
  152. # 命令重命名
  153. # 在共享环境下,可以为危险命令改变名字。比如,你可以为 CONFIG 改个其他不太容易猜到的名字,这样内部的工具仍然可以使用。
  154. # 例如:
  155. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  156. # 也可以通过改名为空字符串来完全禁用一个命令
  157. # rename-command CONFIG ""
  158. # 请注意:改变命令名字被记录到AOF文件或被传送到从服务器可能产生问题。
  159. ######################### 限制 #########################
  160. # 设置最多同时连接的客户端数量。默认这个限制是10000个客户端,然而如果Redis服务器不能配置
  161. # 处理文件的限制数来满足指定的值,那么最大的客户端连接数就被设置成当前文件限制数减32(因为Redis服务器保留了一些文件描述符作为内部使用)
  162. # 一旦达到这个限制,Redis会关闭所有新连接并发送错误'max number of clients reached'
  163. # maxclients 10000
  164. # 不要使用比设置的上限更多的内存。一旦内存使用达到上限,Redis会根据选定的回收策略(参见:maxmemmory-policy)删除key。
  165. # 如果因为删除策略Redis无法删除key,或者策略设置为 "noeviction",Redis会回复需要更多内存的错误信息给命令。例如,SET,LPUSH等等,但是会继续响应像Get这样的只读命令。
  166. # 在使用Redis作为LRU缓存,或者为实例设置了硬性内存限制的时候(使用 "noeviction" 策略)的时候,这个选项通常事很有用的。
  167. # 警告:当有多个slave连上达到内存上限时,master为同步slave的输出缓冲区所需内存不计算在使用内存中。这样当移除key时,就不会因网络问题 / 重新同步事件触发移除key的循环,反过来slaves的输出缓冲区充满了key被移除的DEL命令,这将触发删除更多的key,直到这个数据库完全被清空为止。
  168. # 总之,如果你需要附加多个slave,建议你设置一个稍小maxmemory限制,这样系统就会有空闲的内存作为slave的输出缓存区(但是如果最大内存策略设置为"noeviction"的话就没必要了)
  169. # maxmemory <bytes>
  170. # 最大内存策略:如果达到内存限制了,Redis如何选择删除key。
  171. # volatile-lru -> 根据LRU算法删除设置过期时间的key
  172. # allkeys-lru -> 根据LRU算法删除任何key
  173. # volatile-random -> 随机移除设置过过期时间的key
  174. # allkeys-random -> 随机移除任何key
  175. # volatile-ttl -> 移除即将过期的key(minor TTL)
  176. # noeviction -> 不移除任何key,只返回一个写错误
  177. # 注意:对所有策略来说,如果Redis找不到合适的可以删除的key都会在写操作时返回一个错误。# 目前为止涉及的命令:set setnx setex append incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby getset mset msetnx exec sort
  178. # 默认策略:
  179. # maxmemory-policy noeviction
  180. # LRU和最小TTL算法的实现都不是很精确,但是很接近(为了省内存),所以你可以用样本量做检测。 例如:默认Redis会检查3个key然后取最旧的那个,你可以通过下面的配置指令来设置样本的个数。
  181. # 默认值为5,数字越大结果越精确但是会消耗更多CPU。
  182. # maxmemory-samples 5
  183. ######################### APPEND ONLY MODE #########################
  184. # 默认情况下,Redis是异步的把数据导出到磁盘上。这种模式在很多应用里已经足够好,但Redis进程出问题或断电时可能造成一段时间的写操作丢失(这取决于配置的save指令)。
  185. # AOF是一种提供了更可靠的替代持久化模式,例如使用默认的数据写入文件策略(参见后面的配置)。
  186. # 在遇到像服务器断电或单写情况下Redis自身进程出问题但操作系统仍正常运行等突发事件时,Redis能只丢失1秒的写操作。
  187. # AOF和RDB持久化能同时启动并且不会有问题。
  188. # 如果AOF开启,那么在启动时Redis将加载AOF文件,它更能保证数据的可靠性。
  189. appendonly no
  190. # AOF文件名(默认:"appendonly.aof")
  191. appendfilename "appendonly.aof"
  192. # fsync() 系统调用告诉操作系统把数据写到磁盘上,而不是等更多的数据进入输出缓冲区。
  193. # 有些操作系统会真的把数据马上刷到磁盘上;有些则会尽快去尝试这么做。
  194. # Redis支持三种不同的模式:
  195. # no:不要立刻刷,只有在操作系统需要刷的时候再刷。比较快。
  196. # always:每次写操作都立刻写入到aof文件。慢,但是最安全。
  197. # everysec:每秒写一次。折中方案。
  198. # 默认的 "everysec" 通常来说能在速度和数据安全性之间取得比较好的平衡。
  199. # appendfsync always
  200. appendfsync everysec
  201. # appendfsync no
  202. # 如果AOF的同步策略设置成 "always" 或者 "everysec",并且后台的存储进程(后台存储或写入AOF 日志)会产生很多磁盘I/O开销。某些Linux的配置下会使Redis因为 fsync()系统调用而阻塞很久。
  203. # 注意,目前对这个情况还没有完美修正,甚至不同线程的 fsync() 会阻塞我们同步的write(2)调用。
  204. # 为了缓解这个问题,可以用下面这个选项。它可以在 BGSAVE 或 BGREWRITEAOF 处理时阻止fsync()。
  205. # 这就意味着如果有子进程在进行保存操作,那么Redis就处于"不可同步"的状态。
  206. # 这实际上是说,在最差的情况下可能会丢掉30秒钟的日志数据。(默认Linux设定)
  207. # 如果把这个设置成"yes"带来了延迟问题,就保持"no",这是保存持久数据的最安全的方式。
  208. no-appendfsync-on-rewrite no
  209. # 自动重写AOF文件。如果AOF日志文件增大到指定百分比,Redis能够通过 BGREWRITEAOF 自动重写AOF日志文件。# 工作原理:Redis记住上次重写时AOF文件的大小(如果重启后还没有写操作,就直接用启动时的AOF大小)
  210. # 这个基准大小和当前大小做比较。如果当前大小超过指定比例,就会触发重写操作。你还需要指定被重写日志的最小尺寸,这样避免了达到指定百分比但尺寸仍然很小的情况还要重写。
  211. # 指定百分比为0会禁用AOF自动重写特性。
  212. auto-aof-rewrite-percentage 100
  213. auto-aof-rewrite-min-size 64mb
  214. # 如果设置为yes,如果一个因异常被截断的AOF文件被redis启动时加载进内存,redis将会发送日志通知用户。如果设置为no,erdis将会拒绝启动。此时需要用"redis-check-aof"工具修复文件。
  215. aof-load-truncated yes
  216. ######################### LUA脚本 #########################
  217. # Lua 脚本的最大执行时间,毫秒为单位
  218. lua-time-limit 5000
  219. ######################### 集群 #########################
  220. # 只有开启了以下选项,redis才能成为集群服务的一部分
  221. # cluster-enabled yes
  222. # 配置redis自动生成的集群配置文件名。确保同一系统中运行的各redis实例该配置文件不要重名。
  223. # cluster-config-file nodes-6379.conf
  224. # 集群节点超时毫秒数。超时的节点将被视为不可用状态。
  225. # cluster-node-timeout 15000
  226. # 如果数据太旧,集群中的不可用master的slave节点会避免成为备用master。如果slave和master失联时间超过:(node-timeout * slave-validity-factor) + repl-ping-slave-period则不会被提升为master。
  227. # 如node-timeout为30秒,slave-validity-factor为10, 默认default repl-ping-slave-period为10秒,失联时间超过310秒slave就不会成为master。
  228. # 较大的slave-validity-factor值可能允许包含过旧数据的slave成为master,同时较小的值可能会阻止集群选举出新master。
  229. #为了达到最大限度的高可用性,可以设置为0,即slave不管和master失联多久都可以提升为master
  230. # cluster-slave-validity-factor 10
  231. # 只有在之前master有其它指定数量的工作状态下的slave节点时,slave节点才能提升为master。默认为1(即该集群至少有3个节点,1 master+2 slaves,master宕机,仍有另外1个slave的情况下其中1个slave可以提升)
  232. # 测试环境可设置为0,生成环境中至少设置为1
  233. # cluster-migration-barrier 1
  234. # 默认情况下如果redis集群如果检测到至少有1个hash slot不可用,集群将停止查询数据。
  235. # 如果所有slot恢复则集群自动恢复。
  236. # 如果需要集群部分可用情况下仍可提供查询服务,设置为no。
  237. # cluster-require-full-coverage yes
  238. ######################### 慢查询日志 #########################
  239. # 慢查询日志,记录超过多少微秒的查询命令。查询的执行时间不包括客户端的IO执行和网络通信时间,只是查询命令执行时间。
  240. # 1000000等于1秒,设置为0则记录所有命令
  241. slowlog-log-slower-than 10000
  242. # 记录大小,可通过SLOWLOG RESET命令重置
  243. slowlog-max-len 128
  244. ######################### 旧监控系统 #########################
  245. # redis延时监控系统在运行时会采样一些操作,以便收集可能导致延时的数据根源。
  246. # 通过 LATENCY命令 可以打印一些图样和获取一些报告,方便监控
  247. # 这个系统仅仅记录那个执行时间大于或等于预定时间(毫秒)的操作,
  248. # 这个预定时间是通过latency-monitor-threshold配置来指定的,
  249. # 当设置为0时,这个监控系统处于停止状态
  250. latency-monitor-threshold 0
  251. ######################### 事件通知 #########################
  252. # K 键空间通知,所有通知以 __keyspace@<db>__ 为前缀
  253. # E 键事件通知,所有通知以 __keyevent@<db>__ 为前缀
  254. # g DEL 、 EXPIRE 、 RENAME 等类型无关的通用命令的通知
  255. # $ 字符串命令的通知
  256. # l 列表命令的通知
  257. # s 集合命令的通知
  258. # h 哈希命令的通知
  259. # z 有序集合命令的通知
  260. # x 过期事件:每当有过期键被删除时发送
  261. # e 驱逐(evict)事件:每当有键因为 maxmemory 政策而被删除时发送
  262. # A 参数 g$lshzxe 的别名
  263. # Example: to enable list and generic events, from the point of view of the
  264. # event name, use:
  265. #
  266. # notify-keyspace-events Elg
  267. #
  268. # Example 2: to get the stream of the expired keys subscribing to channel
  269. # name __keyevent@0__:expired use:
  270. #
  271. # notify-keyspace-events Ex
  272. # Redis能通知 Pub/Sub 客户端关于键空间发生的事件,默认关闭
  273. notify-keyspace-events ""
  274. ############################### 高级配置 ###############################
  275. # 当hash只有少量的entry时,并且最大的entry所占空间没有超过指定的限制时,会用一种节省内存的
  276. # 数据结构来编码。可以通过下面的指令来设定限制
  277. hash-max-ziplist-entries 512
  278. hash-max-ziplist-value 64
  279. # 当取正值的时候,表示按照数据项个数来限定每个quicklist节点上的ziplist长度。比如,当这个参数配置
  280. # 成5的时候,表示每个quicklist节点的ziplist最多包含5个数据项。
  281. # 当取负值的时候,表示按照占用字节数来限定每个quicklist节点上的ziplist长度。这时,它只能取-1到-5
  282. # 这五个值,每个值含义如下:
  283. # -5: 每个quicklist节点上的ziplist大小不能超过64 Kb。(注:1kb => 1024 bytes)
  284. # -4: 每个quicklist节点上的ziplist大小不能超过32 Kb。
  285. # -3: 每个quicklist节点上的ziplist大小不能超过16 Kb。
  286. # -2: 每个quicklist节点上的ziplist大小不能超过8 Kb。(-2是Redis给出的默认值)
  287. # -1: 每个quicklist节点上的ziplist大小不能超过4 Kb。
  288. list-max-ziplist-size -2
  289. # 这个参数表示一个quicklist两端不被压缩的节点个数。
  290. # 注:这里的节点个数是指quicklist双向链表的节点个数,而不是指ziplist里面的数据项个数。
  291. # 实际上,一个quicklist节点上的ziplist,如果被压缩,就是整体被压缩的。
  292. # 参数list-compress-depth的取值含义如下:
  293. # 0: 是个特殊值,表示都不压缩。这是Redis的默认值。
  294. # 1: 表示quicklist两端各有1个节点不压缩,中间的节点压缩。
  295. # 2: 表示quicklist两端各有2个节点不压缩,中间的节点压缩。
  296. # 3: 表示quicklist两端各有3个节点不压缩,中间的节点压缩。
  297. # 依此类推…
  298. # 由于0是个特殊值,很容易看出quicklist的头节点和尾节点总是不被压缩的,以便于在表的两端进行快速存取。
  299. list-compress-depth 0
  300. # set有一种特殊编码的情况:当set数据全是十进制64位有符号整型数字构成的字符串时。
  301. # 下面这个配置项就是用来设置set使用这种编码来节省内存的最大长度。
  302. set-max-intset-entries 512
  303. # 与hash和list相似,有序集合也可以用一种特别的编码方式来节省大量空间。
  304. # 这种编码只适合长度和元素都小于下面限制的有序集合
  305. zset-max-ziplist-entries 128
  306. zset-max-ziplist-value 64
  307. # HyperLogLog稀疏结构表示字节的限制。该限制包括
  308. # 16个字节的头。当HyperLogLog使用稀疏结构表示
  309. # 这些限制,它会被转换成密度表示。
  310. # 值大于16000是完全没用的,因为在该点
  311. # 密集的表示是更多的内存效率。
  312. # 建议值是3000左右,以便具有的内存好处, 减少内存的消耗
  313. hll-sparse-max-bytes 3000
  314. # 启用哈希刷新,每100个CPU毫秒会拿出1个毫秒来刷新Redis的主哈希表(顶级键值映射表)
  315. activerehashing yes
  316. # 客户端的输出缓冲区的限制,可用于强制断开那些因为某种原因从服务器读取数据的速度不够快的客户端
  317. client-output-buffer-limit normal 0 0 0
  318. client-output-buffer-limit slave 256mb 64mb 60
  319. client-output-buffer-limit pubsub 32mb 8mb 60
  320. # 默认情况下,“hz”的被设定为10。提高该值将在Redis空闲时使用更多的CPU时,但同时当有多个key
  321. # 同时到期会使Redis的反应更灵敏,以及超时可以更精确地处理
  322. hz 10
  323. # 当一个子进程重写AOF文件时,如果启用下面的选项,则文件每生成32M数据会被同步
  324. aof-rewrite-incremental-fsync yes

Redis 5.0.0 配置文件解析

  1. # redis版本 5.0.0
  2. # 如果想要使用到配置文件,Redis服务必须以配置文件的路径作为第一个参数启动。如:
  3. ./redis-server /path/to/redis.conf
  4. # 单位说明:当需要指定内存大小时,可能会用到不同的单位,如1k、5GB、4M等,这里给出其单位含义:
  5. # 指定单位是大小写不敏感。如1GB、1gB、1Gb是一样的。
  6. # 1k => 1000 bytes
  7. # 1kb => 1024 bytes
  8. # 1m => 1000000 bytes
  9. # 1mb => 1024*1024 bytes
  10. # 1g => 1000000000 bytes
  11. # 1gb => 1024*1024*1024 bytes
  12. ######################### 引用 #########################
  13. # 不同redis server可以使用同一个模版配置作为主配置,并引用其它配置文
  14. # 件用于本server的个性化设置include并不会被CONFIG REWRITE命令覆盖。
  15. # 但是主配置文件的选项会被覆盖。想故意覆盖主配置的话就把include放文件前面,
  16. # 否则最好放末尾
  17. # include /path/to/local.conf
  18. # include /path/to/other.conf
  19. ######################### 模块 #########################
  20. # 启动时加载模块。如果服务器无法加载模块,则会中止。可以使用多个loadmodule指令。
  21. # loadmodule /path/to/my_module.so
  22. # loadmodule /path/to/other_module.so
  23. ######################### 网络 #########################
  24. # 不指定bind的话redis将会监听所有网络接口。这个配置是肯定需要指定的。
  25. # Examples:
  26. # bind 192.168.1.100 10.0.0.1
  27. # bind 127.0.0.1 ::1
  28. # 下面这个配置是只允许本地客户端访问。
  29. bind 127.0.0.1
  30. # 是否开启保护模式。默认开启,如果没有设置bind项的ip和redis密码的话,服务将只允许本地访问。
  31. protected-mode yes
  32. # 端口设置,默认为 6379
  33. # 如果port设置为0 redis将不会监听tcp socket
  34. port 6379
  35. # 在高并发环境下需要一个高backlog值来避免慢客户端连接问题。注意Linux内核默默将这个值减小到/proc/sys/net/core/somaxconn的值,所以需要确认增大somaxconn和tcp_max_syn_backlog 两个值来达到需要的效果。
  36. tcp-backlog 511
  37. # 指定用来监听Unix套套接字的路径。没有默认值,没有指定的情况下Redis不会监听Unix socket
  38. # unixsocket /tmp/redis.sock
  39. # unixsocketperm 700
  40. # 客户端空闲多少秒后关闭连接(0为不关闭)
  41. timeout 0
  42. # tcp-keepalive设置。如果非零,
  43. # 则设置SO_KEEPALIVE选项来向空闲连接的客户端发送ACK,用途如下:
  44. # 1)能够检测无响应的对端
  45. # 2)让该连接中间的网络设备知道这个连接还存活
  46. # 在Linux上,这个指定的值(单位秒)就是发送ACK的时间间隔。
  47. # 注意:要关闭这个连接需要两倍的这个时间值。
  48. # 在其他内核上这个时间间隔由内核配置决定
  49. tcp-keepalive 300
  50. ######################### 通用 #########################
  51. # 是否将Redis作为守护进程运行。如果需要的话配置成'yes'
  52. # 注意配置成守护进程后Redis会将进程号写入文件/var/run/redis.pid
  53. daemonize no
  54. # 是否通过upstart或systemd管理守护进程。默认no没有服务监控,其它选项有upstart, systemd, auto
  55. supervised no
  56. # pid文件在redis启动时创建,退出时删除。最佳实践为配置该项。
  57. pidfile /var/run/redis_6379.pid
  58. # 配置日志级别。选项有debug, verbose, notice, warning
  59. loglevel notice
  60. # 日志名称。空字符串表示标准输出。注意如果redis配置为后台进程,标准输出中信息会发送到/dev/null
  61. logfile ""
  62. # 是否启动系统日志记录。
  63. # syslog-enabled no
  64. # 指定系统日志身份。
  65. # syslog-ident redis
  66. # 指定syslog设备。必须是user或LOCAL0 ~ LOCAL7之一。
  67. # syslog-facility local0
  68. # 设置数据库个数。默认数据库是 DB 0
  69. # 可以通过SELECT where dbid is a number between 0 and 'databases'-1为每个连接使用不同的数据库。
  70. databases 16
  71. # redis启动时是否显示Logo
  72. always-show-logo yes
  73. ######################### 备份 #########################
  74. # 持久化设置:
  75. # 下面的例子将会进行把数据写入磁盘的操作:
  76. # 900秒(15分钟)之后,且至少1次变更
  77. # 300秒(5分钟)之后,且至少10次变更
  78. # 60秒之后,且至少10000次变更
  79. # 不写磁盘的话就把所有 "save" 设置注释掉就行了。
  80. # 通过添加一条带空字符串参数的save指令也能移除之前所有配置的save指令,如: save ""
  81. save 900 1
  82. save 300 10
  83. save 60 10000
  84. # 默认情况下如果上面配置的RDB模式开启且最后一次的保存失败,redis 将停止接受写操作,
  85. # 让用户知道问题的发生。如果后台保存进程重新启动工作了,redis 也将自动的允许写操作。
  86. # 如果有其它监控方式也可关闭。
  87. stop-writes-on-bgsave-error yes
  88. # 是否在备份.rdb文件时是否用LZF压缩字符串,默认设置为yes。如果想节约cpu资源可以把它设置为no。
  89. rdbcompression yes
  90. # 因为版本5的RDB有一个CRC64算法的校验和放在了文件的末尾。这将使文件格式更加可靠,
  91. # 但在生产和加载RDB文件时,这有一个性能消耗(大约10%),可以关掉它来获取最好的性能。
  92. # 生成的关闭校验的RDB文件有一个0的校验和,它将告诉加载代码跳过检查
  93. rdbchecksum yes
  94. # rdb文件名称
  95. dbfilename dump.rdb
  96. # 备份文件目录,文件名就是上面的 "dbfilename" 的值。累加文件也放这里。
  97. # 注意你这里指定的必须是目录,不是文件名。
  98. dir ./
  99. ######################### 主从同步 #########################
  100. # 主从同步配置。
  101. # 1) redis主从同步是异步的,但是可以配置在没有指定slave连接的情况下使master停止写入数据。
  102. # 2) 连接中断一定时间内,slave可以执行部分数据重新同步。
  103. # 3) 同步是自动的,slave可以自动重连且同步数据。
  104. # replicaof <masterip> <masterport>
  105. # master连接密码
  106. # masterauth <master-password>
  107. # 当一个slave失去和master的连接,或者同步正在进行中,slave的行为有两种可能:
  108. # 1) 如果 replica-serve-stale-data 设置为 "yes" (默认值),slave会继续响应客户端请求,可能是正常数据,也可能是还没获得值的空数据。
  109. # 2) 如果 replica-serve-stale-data 设置为 "no",slave会回复"正在从master同步(SYNC with master in progress)"来处理各种请求,除了 INFO 和 SLAVEOF 命令。
  110. replica-serve-stale-data yes
  111. # 你可以配置salve实例是否接受写操作。可写的slave实例可能对存储临时数据比较有用(因为写入salve# 的数据在同master同步之后将很容被删除),但是如果客户端由于配置错误在写入时也可能产生一些问题。
  112. # 从Redis2.6默认所有的slave为只读
  113. # 注意:只读的slave不是为了暴露给互联网上不可信的客户端而设计的。它只是一个防止实例误用的保护层。
  114. # 一个只读的slave支持所有的管理命令比如config,debug等。为了限制你可以用'rename-command'来隐藏所有的管理和危险命令来增强只读slave的安全性。
  115. replica-read-only yes
  116. # 同步策略: 磁盘或socket,默认磁盘方式
  117. repl-diskless-sync no
  118. # 如果非磁盘同步方式开启,可以配置同步延迟时间,以等待master产生子进程通过socket传输RDB数据给slave。
  119. # 默认值为5秒,设置为0秒则每次传输无延迟。
  120. repl-diskless-sync-delay 5
  121. # slave根据指定的时间间隔向master发送ping请求。默认10秒。
  122. # repl-ping-replica-period 10
  123. # 同步的超时时间
  124. # 1)slave在与master SYNC期间有大量数据传输,造成超时
  125. # 2)在slave角度,master超时,包括数据、ping等
  126. # 3)在master角度,slave超时,当master发送REPLCONF ACK pings# 确保这个值大于指定的repl-ping-slave-period,否则在主从间流量不高时每次都会检测到超时
  127. # repl-timeout 60
  128. # 是否在slave套接字发送SYNC之后禁用 TCP_NODELAY
  129. # 如果选择yes,Redis将使用更少的TCP包和带宽来向slaves发送数据。但是这将使数据传输到slave上有延迟,Linux内核的默认配置会达到40毫秒。
  130. # 如果选择no,数据传输到salve的延迟将会减少但要使用更多的带宽。
  131. # 默认我们会为低延迟做优化,但高流量情况或主从之间的跳数过多时,可以设置为“yes”。
  132. repl-disable-tcp-nodelay no
  133. # 设置数据备份的backlog大小。backlog是一个slave在一段时间内断开连接时记录salve数据的缓冲,所以一个slave在重新连接时,不必要全量的同步,而是一个增量同步就足够了,将在断开连接的这段# 时间内把slave丢失的部分数据传送给它。
  134. # 同步的backlog越大,slave能够进行增量同步并且允许断开连接的时间就越长。
  135. # backlog只分配一次并且至少需要一个slave连接。
  136. # repl-backlog-size 1mb
  137. # 当master在一段时间内不再与任何slave连接,backlog将会释放。以下选项配置了从最后一个
  138. # slave断开开始计时多少秒后,backlog缓冲将会释放。
  139. # 0表示永不释放backlog
  140. # repl-backlog-ttl 3600
  141. # slave的优先级是一个整数展示在Redis的Info输出中。如果master不再正常工作了,sentinel将用它来选择一个slave提升为master。
  142. # 优先级数字小的salve会优先考虑提升为master,所以例如有三个slave优先级分别为10,100,25,sentinel将挑选优先级最小数字为10的slave。
  143. # 0作为一个特殊的优先级,标识这个slave不能作为master,所以一个优先级为0的slave永远不会被# sentinel挑选提升为master。
  144. # 默认优先级为100
  145. slave-priority 100
  146. # 如果master少于N个延时小于等于M秒的已连接slave,就可以停止接收写操作。
  147. # N个slave需要是“oneline”状态。
  148. # 延时是以秒为单位,并且必须小于等于指定值,是从最后一个从slave接收到的ping(通常每秒发送)开始计数。
  149. # 该选项不保证N个slave正确同步写操作,但是限制数据丢失的窗口期。
  150. # 例如至少需要3个延时小于等于10秒的slave用下面的指令:
  151. # min-replicas-to-write 3
  152. # min-replicas-max-lag 10
  153. # 两者之一设置为0将禁用这个功能。
  154. # 默认 min-replicas-to-write 值是0(该功能禁用)并且 min-replicas-max-lag 值是10。
  155. # A Redis master is able to list the address and port of the attached
  156. # replicas in different ways. For example the "INFO replication" section
  157. # offers this information, which is used, among other tools, by
  158. # Redis Sentinel in order to discover replica instances.
  159. # Another place where this info is available is in the output of the
  160. # "ROLE" command of a master.
  161. #
  162. # The listed IP and address normally reported by a replica is obtained
  163. # in the following way:
  164. #
  165. # IP: The address is auto detected by checking the peer address
  166. # of the socket used by the replica to connect with the master.
  167. #
  168. # Port: The port is communicated by the replica during the replication
  169. # handshake, and is normally the port that the replica is using to
  170. # listen for connections.
  171. #
  172. # However when port forwarding or Network Address Translation (NAT) is
  173. # used, the replica may be actually reachable via different IP and port
  174. # pairs. The following two options can be used by a replica in order to
  175. # report to its master a specific set of IP and port, so that both INFO
  176. # and ROLE will report those values.
  177. #
  178. # There is no need to use both the options if you need to override just
  179. # the port or the IP address.
  180. #
  181. # replica-announce-ip 5.5.5.5
  182. # replica-announce-port 1234
  183. ######################### 安全 #########################
  184. # 要求客户端在处理任何命令时都要验证身份和密码。
  185. # requirepass foobared
  186. # 命令重命名
  187. # 在共享环境下,可以为危险命令改变名字。比如,你可以为 CONFIG 改个其他不太容易猜到的名字,这样内部的工具仍然可以使用。
  188. # 例如:
  189. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  190. # 也可以通过改名为空字符串来完全禁用一个命令
  191. # rename-command CONFIG ""
  192. # 请注意:改变命令名字被记录到AOF文件或被传送到从服务器可能产生问题。
  193. ######################### 限制 #########################
  194. # 设置最多同时连接的客户端数量。默认这个限制是10000个客户端,然而如果Redis服务器不能配置
  195. # 处理文件的限制数来满足指定的值,那么最大的客户端连接数就被设置成当前文件限制数减32(因为Redis服务器保留了一些文件描述符作为内部使用)
  196. # 一旦达到这个限制,Redis会关闭所有新连接并发送错误'max number of clients reached'
  197. # maxclients 10000
  198. # 不要使用比设置的上限更多的内存。一旦内存使用达到上限,Redis会根据选定的回收策略(参见:maxmemmory-policy)删除key。
  199. # 如果因为删除策略Redis无法删除key,或者策略设置为 "noeviction",Redis会回复需要更多内存的错误信息给命令。例如,SET,LPUSH等等,但是会继续响应像Get这样的只读命令。
  200. # 在使用Redis作为LRU缓存,或者为实例设置了硬性内存限制的时候(使用 "noeviction" 策略)的时候,这个选项通常事很有用的。
  201. # 警告:当有多个slave连上达到内存上限时,master为同步slave的输出缓冲区所需内存不计算在使用内存中。这样当移除key时,就不会因网络问题 / 重新同步事件触发移除key的循环,反过来slaves的输出缓冲区充满了key被移除的DEL命令,这将触发删除更多的key,直到这个数据库完全被清空为止。
  202. # 总之,如果你需要附加多个slave,建议你设置一个稍小maxmemory限制,这样系统就会有空闲的内存作为slave的输出缓存区(但是如果最大内存策略设置为"noeviction"的话就没必要了)
  203. # maxmemory <bytes>
  204. # 最大内存策略:如果达到内存限制了,Redis如何选择删除key。
  205. # volatile-lru -> 根据LRU算法删除设置过期时间的key
  206. # allkeys-lru -> 根据LRU算法删除任何key
  207. # volatile-random -> 随机移除设置过过期时间的key
  208. # allkeys-random -> 随机移除任何key
  209. # volatile-ttl -> 移除即将过期的key(minor TTL)
  210. # noeviction -> 不移除任何key,只返回一个写错误
  211. # 注意:对所有策略来说,如果Redis找不到合适的可以删除的key都会在写操作时返回一个错误。# 目前为止涉及的命令:set setnx setex append incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby getset mset msetnx exec sort
  212. # 默认策略:
  213. # maxmemory-policy noeviction
  214. # LRU和最小TTL算法的实现都不是很精确,但是很接近(为了省内存),所以你可以用样本量做检测。 例如:默认Redis会检查3个key然后取最旧的那个,你可以通过下面的配置指令来设置样本的个数。
  215. # 默认值为5,数字越大结果越精确但是会消耗更多CPU。
  216. # maxmemory-samples 5
  217. # Starting from Redis 5, by default a replica will ignore its maxmemory setting
  218. # (unless it is promoted to master after a failover or manually). It means
  219. # that the eviction of keys will be just handled by the master, sending the
  220. # DEL commands to the replica as keys evict in the master side.
  221. #
  222. # This behavior ensures that masters and replicas stay consistent, and is usually
  223. # what you want, however if your replica is writable, or you want the replica to have
  224. # a different memory setting, and you are sure all the writes performed to the
  225. # replica are idempotent, then you may change this default (but be sure to understand
  226. # what you are doing).
  227. #
  228. # Note that since the replica by default does not evict, it may end using more
  229. # memory than the one set via maxmemory (there are certain buffers that may
  230. # be larger on the replica, or data structures may sometimes take more memory and so
  231. # forth). So make sure you monitor your replicas and make sure they have enough
  232. # memory to never hit a real out-of-memory condition before the master hits
  233. # the configured maxmemory setting.
  234. #
  235. # replica-ignore-maxmemory yes
  236. ######################### APPEND ONLY MODE #########################
  237. # Redis has two primitives to delete keys. One is called DEL and is a blocking
  238. # deletion of the object. It means that the server stops processing new commands
  239. # in order to reclaim all the memory associated with an object in a synchronous
  240. # way. If the key deleted is associated with a small object, the time needed
  241. # in order to execute the DEL command is very small and comparable to most other
  242. # O(1) or O(log_N) commands in Redis. However if the key is associated with an
  243. # aggregated value containing millions of elements, the server can block for
  244. # a long time (even seconds) in order to complete the operation.
  245. #
  246. # For the above reasons Redis also offers non blocking deletion primitives
  247. # such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and
  248. # FLUSHDB commands, in order to reclaim memory in background. Those commands
  249. # are executed in constant time. Another thread will incrementally free the
  250. # object in the background as fast as possible.
  251. #
  252. # DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.
  253. # It's up to the design of the application to understand when it is a good
  254. # idea to use one or the other. However the Redis server sometimes has to
  255. # delete keys or flush the whole database as a side effect of other operations.
  256. # Specifically Redis deletes objects independently of a user call in the
  257. # following scenarios:
  258. #
  259. # 1) On eviction, because of the maxmemory and maxmemory policy configurations,
  260. # in order to make room for new data, without going over the specified
  261. # memory limit.
  262. # 2) Because of expire: when a key with an associated time to live (see the
  263. # EXPIRE command) must be deleted from memory.
  264. # 3) Because of a side effect of a command that stores data on a key that may
  265. # already exist. For example the RENAME command may delete the old key
  266. # content when it is replaced with another one. Similarly SUNIONSTORE
  267. # or SORT with STORE option may delete existing keys. The SET command
  268. # itself removes any old content of the specified key in order to replace
  269. # it with the specified string.
  270. # 4) During replication, when a replica performs a full resynchronization with
  271. # its master, the content of the whole database is removed in order to
  272. # load the RDB file just transferred.
  273. #
  274. # In all the above cases the default is to delete objects in a blocking way,
  275. # like if DEL was called. However you can configure each case specifically
  276. # in order to instead release memory in a non-blocking way like if UNLINK
  277. # was called, using the following configuration directives:
  278. lazyfree-lazy-eviction no
  279. lazyfree-lazy-expire no
  280. lazyfree-lazy-server-del no
  281. replica-lazy-flush no
  282. # 默认情况下,Redis是异步的把数据导出到磁盘上。这种模式在很多应用里已经足够好,但Redis进程出问题或断电时可能造成一段时间的写操作丢失(这取决于配置的save指令)。
  283. # AOF是一种提供了更可靠的替代持久化模式,例如使用默认的数据写入文件策略(参见后面的配置)。
  284. # 在遇到像服务器断电或单写情况下Redis自身进程出问题但操作系统仍正常运行等突发事件时,Redis能只丢失1秒的写操作。
  285. # AOF和RDB持久化能同时启动并且不会有问题。
  286. # 如果AOF开启,那么在启动时Redis将加载AOF文件,它更能保证数据的可靠性。
  287. appendonly no
  288. # AOF文件名(默认:"appendonly.aof")
  289. appendfilename "appendonly.aof"
  290. # fsync() 系统调用告诉操作系统把数据写到磁盘上,而不是等更多的数据进入输出缓冲区。
  291. # 有些操作系统会真的把数据马上刷到磁盘上;有些则会尽快去尝试这么做。
  292. # Redis支持三种不同的模式:
  293. # no:不要立刻刷,只有在操作系统需要刷的时候再刷。比较快。
  294. # always:每次写操作都立刻写入到aof文件。慢,但是最安全。
  295. # everysec:每秒写一次。折中方案。
  296. # 默认的 "everysec" 通常来说能在速度和数据安全性之间取得比较好的平衡。
  297. # appendfsync always
  298. appendfsync everysec
  299. # appendfsync no
  300. # 如果AOF的同步策略设置成 "always" 或者 "everysec",并且后台的存储进程(后台存储或写入AOF 日志)会产生很多磁盘I/O开销。某些Linux的配置下会使Redis因为 fsync()系统调用而阻塞很久。
  301. # 注意,目前对这个情况还没有完美修正,甚至不同线程的 fsync() 会阻塞我们同步的write(2)调用。
  302. # 为了缓解这个问题,可以用下面这个选项。它可以在 BGSAVE 或 BGREWRITEAOF 处理时阻止fsync()。
  303. # 这就意味着如果有子进程在进行保存操作,那么Redis就处于"不可同步"的状态。
  304. # 这实际上是说,在最差的情况下可能会丢掉30秒钟的日志数据。(默认Linux设定)
  305. # 如果把这个设置成"yes"带来了延迟问题,就保持"no",这是保存持久数据的最安全的方式。
  306. no-appendfsync-on-rewrite no
  307. # 自动重写AOF文件。如果AOF日志文件增大到指定百分比,Redis能够通过 BGREWRITEAOF 自动重写AOF日志文件。# 工作原理:Redis记住上次重写时AOF文件的大小(如果重启后还没有写操作,就直接用启动时的AOF大小)
  308. # 这个基准大小和当前大小做比较。如果当前大小超过指定比例,就会触发重写操作。你还需要指定被重写日志的最小尺寸,这样避免了达到指定百分比但尺寸仍然很小的情况还要重写。
  309. # 指定百分比为0会禁用AOF自动重写特性。
  310. auto-aof-rewrite-percentage 100
  311. auto-aof-rewrite-min-size 64mb
  312. # 如果设置为yes,如果一个因异常被截断的AOF文件被redis启动时加载进内存,redis将会发送日志通知用户。如果设置为no,erdis将会拒绝启动。此时需要用"redis-check-aof"工具修复文件。
  313. aof-load-truncated yes
  314. # [RDB file][AOF tail]
  315. # 加载时Redis识别出AOF文件以“REDIS”开头字符串,
  316. # 并加载带此前缀的RDB文件,然后继续加载AOF
  317. # 尾巴。
  318. aof-use-rdb-preamble yes
  319. ######################### LUA脚本 #########################
  320. # Lua 脚本的最大执行时间,毫秒为单位
  321. lua-time-limit 5000
  322. ######################### 集群 #########################
  323. # 只有开启了以下选项,redis才能成为集群服务的一部分
  324. # cluster-enabled yes
  325. # 配置redis自动生成的集群配置文件名。确保同一系统中运行的各redis实例该配置文件不要重名。
  326. # cluster-config-file nodes-6379.conf
  327. # 集群节点超时毫秒数。超时的节点将被视为不可用状态。
  328. # cluster-node-timeout 15000
  329. # 如果数据太旧,集群中的不可用master的slave节点会避免成为备用master。如果slave和master失联时间超过:(node-timeout * slave-validity-factor) + repl-ping-slave-period则不会被提升为master。
  330. # 如node-timeout为30秒,slave-validity-factor为10, 默认default repl-ping-slave-period为10秒,失联时间超过310秒slave就不会成为master。
  331. # 较大的slave-validity-factor值可能允许包含过旧数据的slave成为master,同时较小的值可能会阻止集群选举出新master。
  332. #为了达到最大限度的高可用性,可以设置为0,即slave不管和master失联多久都可以提升为master
  333. # cluster-replica-validity-factor 10
  334. # 只有在之前master有其它指定数量的工作状态下的slave节点时,slave节点才能提升为master。默认为1(即该集群至少有3个节点,1 master+2 slaves,master宕机,仍有另外1个slave的情况下其中1个slave可以提升)
  335. # 测试环境可设置为0,生成环境中至少设置为1
  336. # cluster-migration-barrier 1
  337. # 默认情况下如果redis集群如果检测到至少有1个hash slot不可用,集群将停止查询数据。
  338. # 如果所有slot恢复则集群自动恢复。
  339. # 如果需要集群部分可用情况下仍可提供查询服务,设置为no。
  340. # cluster-require-full-coverage yes
  341. # 选项设置为yes时,会阻止replicas尝试对其master在主故障期间进行故障转移
  342. # 然而,master仍然可以执行手动故障转移,如果强制这样做的话。
  343. # cluster-replica-no-failover no
  344. ########################## CLUSTER DOCKER/NAT support ########################
  345. # In certain deployments, Redis Cluster nodes address discovery fails, because
  346. # addresses are NAT-ted or because ports are forwarded (the typical case is
  347. # Docker and other containers).
  348. #
  349. # In order to make Redis Cluster working in such environments, a static
  350. # configuration where each node knows its public address is needed. The
  351. # following two options are used for this scope, and are:
  352. #
  353. # * cluster-announce-ip
  354. # * cluster-announce-port
  355. # * cluster-announce-bus-port
  356. #
  357. # Each instruct the node about its address, client port, and cluster message
  358. # bus port. The information is then published in the header of the bus packets
  359. # so that other nodes will be able to correctly map the address of the node
  360. # publishing the information.
  361. #
  362. # If the above options are not used, the normal Redis Cluster auto-detection
  363. # will be used instead.
  364. #
  365. # Note that when remapped, the bus port may not be at the fixed offset of
  366. # clients port + 10000, so you can specify any port and bus-port depending
  367. # on how they get remapped. If the bus-port is not set, a fixed offset of
  368. # 10000 will be used as usually.
  369. #
  370. # Example:
  371. #
  372. # cluster-announce-ip 10.1.1.5
  373. # cluster-announce-port 6379
  374. # cluster-announce-bus-port 6380
  375. ######################### 慢查询日志 #########################
  376. # 慢查询日志,记录超过多少微秒的查询命令。查询的执行时间不包括客户端的IO执行和网络通信时间,只是查询命令执行时间。
  377. # 1000000等于1秒,设置为0则记录所有命令
  378. slowlog-log-slower-than 10000
  379. # 记录大小,可通过SLOWLOG RESET命令重置
  380. slowlog-max-len 128
  381. ######################### LATENCY MONITOR #########################
  382. # redis延时监控系统在运行时会采样一些操作,以便收集可能导致延时的数据根源。
  383. # 通过 LATENCY命令 可以打印一些图样和获取一些报告,方便监控
  384. # 这个系统仅仅记录那个执行时间大于或等于预定时间(毫秒)的操作,
  385. # 这个预定时间是通过latency-monitor-threshold配置来指定的,
  386. # 当设置为0时,这个监控系统处于停止状态
  387. latency-monitor-threshold 0
  388. ######################### 事件通知 #########################
  389. # K 键空间通知,所有通知以 __keyspace@<db>__ 为前缀
  390. # E 键事件通知,所有通知以 __keyevent@<db>__ 为前缀
  391. # g DEL 、 EXPIRE 、 RENAME 等类型无关的通用命令的通知
  392. # $ 字符串命令的通知
  393. # l 列表命令的通知
  394. # s 集合命令的通知
  395. # h 哈希命令的通知
  396. # z 有序集合命令的通知
  397. # x 过期事件:每当有过期键被删除时发送
  398. # e 驱逐(evict)事件:每当有键因为 maxmemory 政策而被删除时发送
  399. # A 参数 g$lshzxe 的别名
  400. # Example: to enable list and generic events, from the point of view of the
  401. # event name, use:
  402. #
  403. # notify-keyspace-events Elg
  404. #
  405. # Example 2: to get the stream of the expired keys subscribing to channel
  406. # name __keyevent@0__:expired use:
  407. #
  408. # notify-keyspace-events Ex
  409. # Redis能通知 Pub/Sub 客户端关于键空间发生的事件,默认关闭
  410. notify-keyspace-events ""
  411. ############################### ADVANCED CONFIG ###############################
  412. # 当hash只有少量的entry时,并且最大的entry所占空间没有超过指定的限制时,会用一种节省内存的
  413. # 数据结构来编码。可以通过下面的指令来设定限制
  414. hash-max-ziplist-entries 512
  415. hash-max-ziplist-value 64
  416. # 当取正值的时候,表示按照数据项个数来限定每个quicklist节点上的ziplist长度。比如,当这个参数配置
  417. # 成5的时候,表示每个quicklist节点的ziplist最多包含5个数据项。
  418. # 当取负值的时候,表示按照占用字节数来限定每个quicklist节点上的ziplist长度。这时,它只能取-1到-5
  419. # 这五个值,每个值含义如下:
  420. # -5: 每个quicklist节点上的ziplist大小不能超过64 Kb。(注:1kb => 1024 bytes)
  421. # -4: 每个quicklist节点上的ziplist大小不能超过32 Kb。
  422. # -3: 每个quicklist节点上的ziplist大小不能超过16 Kb。
  423. # -2: 每个quicklist节点上的ziplist大小不能超过8 Kb。(-2是Redis给出的默认值)
  424. # -1: 每个quicklist节点上的ziplist大小不能超过4 Kb。
  425. list-max-ziplist-size -2
  426. # 这个参数表示一个quicklist两端不被压缩的节点个数。
  427. # 注:这里的节点个数是指quicklist双向链表的节点个数,而不是指ziplist里面的数据项个数。
  428. # 实际上,一个quicklist节点上的ziplist,如果被压缩,就是整体被压缩的。
  429. # 参数list-compress-depth的取值含义如下:
  430. # 0: 是个特殊值,表示都不压缩。这是Redis的默认值。
  431. # 1: 表示quicklist两端各有1个节点不压缩,中间的节点压缩。
  432. # 2: 表示quicklist两端各有2个节点不压缩,中间的节点压缩。
  433. # 3: 表示quicklist两端各有3个节点不压缩,中间的节点压缩。
  434. # 依此类推…
  435. # 由于0是个特殊值,很容易看出quicklist的头节点和尾节点总是不被压缩的,以便于在表的两端进行快速存取。
  436. list-compress-depth 0
  437. # set有一种特殊编码的情况:当set数据全是十进制64位有符号整型数字构成的字符串时。
  438. # 下面这个配置项就是用来设置set使用这种编码来节省内存的最大长度。
  439. set-max-intset-entries 512
  440. # 与hash和list相似,有序集合也可以用一种特别的编码方式来节省大量空间。
  441. # 这种编码只适合长度和元素都小于下面限制的有序集合
  442. zset-max-ziplist-entries 128
  443. zset-max-ziplist-value 64
  444. # HyperLogLog稀疏结构表示字节的限制。该限制包括
  445. # 16个字节的头。当HyperLogLog使用稀疏结构表示
  446. # 这些限制,它会被转换成密度表示。
  447. # 值大于16000是完全没用的,因为在该点
  448. # 密集的表示是更多的内存效率。
  449. # 建议值是3000左右,以便具有的内存好处, 减少内存的消耗
  450. hll-sparse-max-bytes 3000
  451. # Streams宏节点最大大小/项目。 流数据结构是基数编码内部多个项目的大节点树。 使用此配置
  452. # 可以配置单个节点的字节数,以及切换到新节点之前可能包含的最大项目数
  453. # 追加新的流条目。 如果以下任何设置设置为0,忽略限制,因此例如可以设置一个
  454. # 大入口限制将max-bytes设置为0,将max-entries设置为所需的值
  455. stream-node-max-bytes 4096
  456. stream-node-max-entries 100
  457. # 启用哈希刷新,每100个CPU毫秒会拿出1个毫秒来刷新Redis的主哈希表(顶级键值映射表)
  458. activerehashing yes
  459. # 客户端的输出缓冲区的限制,可用于强制断开那些因为某种原因从服务器读取数据的速度不够快的客户端
  460. client-output-buffer-limit normal 0 0 0
  461. client-output-buffer-limit slave 256mb 64mb 60
  462. client-output-buffer-limit pubsub 32mb 8mb 60
  463. # 客户端查询缓冲区累积新命令。 它们仅限于固定的默认情况下,
  464. # 多数情况下为了避免协议不同步导致客户端查询缓冲区中未绑定的内存使用量的错误
  465. # 但是,如果你有使用的话,你可以在这里配置它,比如我们有很多执行请求或类似的。
  466. # client-query-buffer-limit 1gb
  467. # 在Redis协议中,批量请求,即表示单个的元素strings,通常限制为512 MB。
  468. # 但是,您可以z更改此限制
  469. # proto-max-bulk-len 512mb
  470. # 默认情况下,“hz”的被设定为10。提高该值将在Redis空闲时使用更多的CPU时,但同时当有多个key
  471. # 同时到期会使Redis的反应更灵敏,以及超时可以更精确地处理
  472. hz 10
  473. # Normally it is useful to have an HZ value which is proportional to the
  474. # number of clients connected. This is useful in order, for instance, to
  475. # avoid too many clients are processed for each background task invocation
  476. # in order to avoid latency spikes.
  477. #
  478. # Since the default HZ value by default is conservatively set to 10, Redis
  479. # offers, and enables by default, the ability to use an adaptive HZ value
  480. # which will temporary raise when there are many connected clients.
  481. #
  482. # When dynamic HZ is enabled, the actual configured HZ will be used as
  483. # as a baseline, but multiples of the configured HZ value will be actually
  484. # used as needed once more clients are connected. In this way an idle
  485. # instance will use very little CPU time while a busy instance will be
  486. # more responsive.
  487. dynamic-hz yes
  488. # 当一个子进程重写AOF文件时,如果启用下面的选项,则文件每生成32M数据会被同步
  489. aof-rewrite-incremental-fsync yes
  490. # 当redis保存RDB文件时,如果启用了以下选项,每生成32 MB数据,文件将被fsync-ed。
  491. # 这很有用,以便以递增方式将文件提交到磁盘并避免大延迟峰值。
  492. rdb-save-incremental-fsync yes
  493. # Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good
  494. # idea to start with the default settings and only change them after investigating
  495. # how to improve the performances and how the keys LFU change over time, which
  496. # is possible to inspect via the OBJECT FREQ command.
  497. #
  498. # There are two tunable parameters in the Redis LFU implementation: the
  499. # counter logarithm factor and the counter decay time. It is important to
  500. # understand what the two parameters mean before changing them.
  501. #
  502. # The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis
  503. # uses a probabilistic increment with logarithmic behavior. Given the value
  504. # of the old counter, when a key is accessed, the counter is incremented in
  505. # this way:
  506. #
  507. # 1. A random number R between 0 and 1 is extracted.
  508. # 2. A probability P is calculated as 1/(old_value*lfu_log_factor+1).
  509. # 3. The counter is incremented only if R < P.
  510. #
  511. # The default lfu-log-factor is 10. This is a table of how the frequency
  512. # counter changes with a different number of accesses with different
  513. # logarithmic factors:
  514. #
  515. # +--------+------------+------------+------------+------------+------------+
  516. # | factor | 100 hits | 1000 hits | 100K hits | 1M hits | 10M hits |
  517. # +--------+------------+------------+------------+------------+------------+
  518. # | 0 | 104 | 255 | 255 | 255 | 255 |
  519. # +--------+------------+------------+------------+------------+------------+
  520. # | 1 | 18 | 49 | 255 | 255 | 255 |
  521. # +--------+------------+------------+------------+------------+------------+
  522. # | 10 | 10 | 18 | 142 | 255 | 255 |
  523. # +--------+------------+------------+------------+------------+------------+
  524. # | 100 | 8 | 11 | 49 | 143 | 255 |
  525. # +--------+------------+------------+------------+------------+------------+
  526. #
  527. # NOTE: The above table was obtained by running the following commands:
  528. #
  529. # redis-benchmark -n 1000000 incr foo
  530. # redis-cli object freq foo
  531. #
  532. # NOTE 2: The counter initial value is 5 in order to give new objects a chance
  533. # to accumulate hits.
  534. #
  535. # The counter decay time is the time, in minutes, that must elapse in order
  536. # for the key counter to be divided by two (or decremented if it has a value
  537. # less <= 10).
  538. #
  539. # The default value for the lfu-decay-time is 1. A Special value of 0 means to
  540. # decay the counter every time it happens to be scanned.
  541. #
  542. # lfu-log-factor 10
  543. # lfu-decay-time 1
  544. ########################### ACTIVE DEFRAGMENTATION #######################
  545. # 启用主动碎片整理
  546. # activedefrag yes
  547. # 启动活动碎片整理的最小碎片浪费量
  548. # active-defrag-ignore-bytes 100mb
  549. # 启动碎片整理的最小碎片百分比
  550. # active-defrag-threshold-lower 10
  551. # 使用最大消耗时的最大碎片百分比
  552. # active-defrag-threshold-upper 100
  553. # 在CPU百分比中进行碎片整理的最小消耗
  554. # active-defrag-cycle-min 5
  555. # 磁盘碎片整理的最大消耗
  556. # active-defrag-cycle-max 75
  557. # 将从主字典扫描处理的最大set / hash / zset / list字段数
  558. # active-defrag-max-scan-fields 1000

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券