devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Redis的常用命令和配置文件

作者：木道寻08 | 2024-08-13 20:10:24

赞

踩

默认值是300s,我个人觉得300s还是太长

行业解决方案、产品招募中！想赚钱就来传！>>> hot3.png

常用命令

关键字忽略大小写，Redis的命令手册见redis中文网

redis中常用的数据类型 string, map, list, set, sortedset

常用命令

String

set key value, get key, del key （set命令集增改命令于一体）

list

lpush key value, rpush key value, lrange key start end, lpop key, rpop key

hashmap （注：下面的field是字段名）

hset key field value, hget key field, hdel key field, hgetall key

set （无需集合，元素不重复。key是一个set的名字，一个key中可以有好多元素）

sadd key value, smembers key， srem key value

sortedset（score是排序的依据，默认从小到大排序）

zadd key score value, zrange key start end [withscores], zrem key value

全局命令

keys *, type key, del key

select dbId dbId是数据库的id（默认0~15）

dbsize 当前库中key数量

fulshdb 清空当前库

fulshall 清空所有库

EXPIRE key "seconds" 为key设置过期时间（单位是秒）

PEXPIRE key "milliseconds" 为key设置过期时间（单位是毫秒）

TTL key，PTTL key返回剩余生存时间（前者返回的时间的单位是秒，后者是毫秒）如果key是永久的，返回-1；如果key不存在或者已过期，返回-2。

PERSIST key 移除key的过期时间，将其转换为永久状态。如果返回1，代表转换成功。如果返回0，代表key不存在或者之前就已经是永久状态。

SETEX key "seconds" "value" 等价于SET和EXPIRE合并的操作，区别之处在于SETEX是一条命令，而命令的执行是原子性的，所以不会出现并发问题

配置文件

以下是经过简单翻译的Redis v=5.0.5配置文件。转自这篇博客

  1. # Redis configuration file example. Redis配置文件示例
  2. #
  3. # Note that in order to read the configuration file, Redis must be
  4. # started with the file path as first argument:
  5. # 如果要使用自定义的Redis配置文件，则需要将配置文件的路径（绝对/相对）跟在"./redis-server"命令后的第一个参数，如：
  6. # ./redis-server /path/to/redis.conf
  7.  
  8. # Note on units: when memory size is needed, it is possible to specify
  9. # it in the usual form of 1k 5GB 4M and so forth:
  10. # 下面是对Redis内存申请单位的注释，比如1k代表1000字节，而1kb代表1024字节，依次类推，并且Redis并不区分大小写，1k 1K都是1000字节
  11. # 1k => 1000 bytes
  12. # 1kb => 1024 bytes
  13. # 1m => 1000000 bytes
  14. # 1mb => 1024*1024 bytes
  15. # 1g => 1000000000 bytes
  16. # 1gb => 1024*1024*1024 bytes
  17. #
  18. # units are case insensitive so 1GB 1Gb 1gB are all the same.
  19.  
  20. ################################## INCLUDES 包含 ###################################
  21.  
  22. # Include one or more other config files here.  This is useful if you
  23. # have a standard template that goes to all Redis servers but also need
  24. # to customize a few per-server settings.  Include files can include
  25. # other files, so use this wisely.
  26. #
  27. # Notice option "include" won't be rewritten by command "CONFIG REWRITE"
  28. # from admin or Redis Sentinel. Since Redis always uses the last processed
  29. # line as value of a configuration directive, you'd better put includes
  30. # at the beginning of this file to avoid overwriting config change at runtime.
  31. #
  32. # If instead you are interested in using includes to override configuration
  33. # options, it is better to use include as the last line.
  34. # 
  35. # 可以将公共配置抽取成模板，然后在主配置中使用"include"选项来外挂它，"include"可以在文件开始或者结束的时候使用
  36. # 如果在文件开始，那么主配置文件中指定的key会覆盖"include"挂进来的key,比如"include"挂进来配置文件port为6380，而主配置文件port=6379，那么这种情况Redis启动之后，监听的端口依然是6379
  37. # 如果在文件结束，上面举例的情况，Redis启动之后，监听的端口是6380
  38. # 其实在集群中可以使用这个特性，可以减少配置，如果使用共享文件(NFS)，还可以做到一处修改处处修改的效果，但是后者是通过分发文件实现的，这里是通过共享磁盘
  39. # include /path/to/local.conf
  40. # include /path/to/other.conf
  41.  
  42. ################################## MODULES 模块 #####################################
  43.  
  44. # Load modules at startup. If the server is not able to load modules
  45. # it will abort. It is possible to use multiple loadmodule directives.
  46. # 挂载官方或者其他大牛写的module，有哪些module可以在Redis官网中的module中查看https://redis.io/modules，比如
  47. # redis-cell(漏洞限流) RedisBloom(布隆过滤器) RedisSearch(全文检索) rediSQL(SQL操作redis)等等module
  48.  
  49. # loadmodule /path/to/my_module.so
  50. # loadmodule /path/to/other_module.so
  51.  
  52. ################################## NETWORK 网络 #####################################
  53.  
  54. # By default, if no "bind" configuration directive is specified, Redis listens
  55. # for connections from all the network interfaces available on the server.
  56. # It is possible to listen to just one or multiple selected interfaces using
  57. # the "bind" configuration directive, followed by one or more IP addresses.
  58. # 如果没有指定"bind"配置，则任何机器都可以连接到该Redis服务器，但也可以通过配置"bind"，让一个或者多个地址可以连接该Redis服务器
  59. # Examples:
  60. #
  61. # bind 192.168.1.100 10.0.0.1
  62. # bind 127.0.0.1 ::1
  63. # 通过配置可以发现，该配置是可以支持范围的，另外如果配置是某一个IP，其实整个网段都可以访问该Redis服务器
  64. #
  65. # ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
  66. # internet, binding to all the interfaces is dangerous and will expose the
  67. # instance to everybody on the internet. So by default we uncomment the
  68. # following bind directive, that will force Redis to listen only into
  69. # the IPv4 loopback interface address (this means Redis will be able to
  70. # accept connections only from clients running into the same computer it
  71. # is running).
  72. # 如果没有指定"bind"，那么将Redis服务器将暴露在互联网上，这是非常危险的，因此在生产系统上应该禁止这样的设置
  73. # 默认情况下是"bind"指定到本机IPV4的回环地址上，因此只有本机上运行的程序才可以访问该Redis服务器
  74.  
  75. # IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES
  76. # JUST COMMENT THE FOLLOWING LINE.
  77. # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  78. bind 192.168.10.20
  79. # 虽然我配置的本地IP地址，但是我192.168.10.12主机一样访问，整个192.168.10网段都可以访问
  80.  
  81. # Protected mode is a layer of security protection, in order to avoid that
  82. # Redis instances left open on the internet are accessed and exploited.
  83. # "protected mode"是一个安全保护层，可以避免Redis服务器被互联网上的机器访问和利用
  84. #
  85. # When protected mode is on and if:
  86. #
  87. # 1) The server is not binding explicitly to a set of addresses using the
  88. #    "bind" directive.
  89. # 2) No password is configured.
  90. #
  91. # The server only accepts connections from clients connecting from the
  92. # IPv4 and IPv6 loopback addresses 127.0.0.1 and ::1, and from Unix domain
  93. # sockets.
  94. # 当"protected mode"被设置为on(即设置为"protected-mode yes")，且没有显示用bind指定ip地址集合或者没有设置密码，那么Redis服务器只能被本机访问
  95. #
  96. # By default protected mode is enabled. You should disable it only if
  97. # you are sure you want clients from other hosts to connect to Redis
  98. # even if no authentication is configured, nor a specific set of interfaces
  99. # are explicitly listed using the "bind" directive.
  100. # 默认"protected mode"是开启的，如果确定自己的服务器需要暴露在互联网上，且不存在安全问题，可以将"protected mode"关闭掉
  101. protected-mode yes
  102.  
  103. # Accept connections on the specified port, default is 6379 (IANA #815344).
  104. # If port 0 is specified Redis will not listen on a TCP socket.
  105. # Redis Server的监听端口
  106. port 6379
  107.  
  108. # TCP listen() backlog.
  109. #
  110. # In high requests-per-second environments you need an high backlog in order
  111. # to avoid slow clients connections issues. Note that the Linux kernel
  112. # will silently truncate it to the value of /proc/sys/net/core/somaxconn so
  113. # make sure to raise both the value of somaxconn and tcp_max_syn_backlog
  114. # in order to get the desired effect.
  115. # 在高并发场景下，为了避免客户端连接缓慢问题，需要高的backlog，默认值是511。但是真正使用的值依赖于LINUX内核参数somaxconn，而somaxconn默认值是128，所以即便这里设置了511，最终生效的128。
  116. # 所以如果公司没有主机工程师一定要记得在安装新机器操作系统时就将一些内核参数改大一些，比如将somaxconn修改为20480
  117. tcp-backlog 511
  118.  
  119. # Unix socket.
  120. #
  121. # Specify the path for the Unix socket that will be used to listen for
  122. # incoming connections. There is no default, so Redis will not listen
  123. # on a unix socket when not specified.
  124. # 利用Unix socket可以提升同一服务器上的进程间通信速度，而且是数量级的提升，但通常Redis服务器和应用服务器是分开的，所以下面的两个参数可以不管
  125. # unixsocket 指定一个文件作为通信的媒介
  126. # unixscoketperm 对unixsocket指定文件的访问权限(读-写-执行)，如果真的用了这个特性，该值应该根据系统用户进行权限设置
  127. # unixsocket /tmp/redis.sock
  128. # unixsocketperm 700
  129.  
  130. # Close the connection after a client is idle for N seconds (0 to disable)
  131. # 当连接变得空闲了之后多少秒关闭连接，默认设置为0，表示禁用这个选项带来的效果--连接不关闭
  132. timeout 0
  133.  
  134. # TCP keepalive.
  135. #
  136. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
  137. # of communication. This is useful for two reasons:
  138. #
  139. # 1) Detect dead peers.
  140. # 2) Take the connection alive from the point of view of network
  141. #    equipment in the middle.
  142. # 如果tcp-keepalive值不为0，那么在客户端和服务器缺乏通信的情况下使用SO_KEEPALIVE，每隔"tcp-keepalive"指定的时间发送"TCP ACKS"给客户端
  143. # 这么做有两个原因：
  144. # 1.可以检测客户端是否还存活
  145. # 2.保持网络连接是活着的，这样避免客户端反复与服务器建立链接导致性能低下
  146. # 
  147. # On Linux, the specified value (in seconds) is the period used to send ACKs.
  148. # Note that to close the connection the double of the time is needed.
  149. # On other kernels the period depends on the kernel configuration.
  150. #
  151. # A reasonable value for this option is 300 seconds, which is the new
  152. # Redis default starting with Redis 3.2.1.
  153. # 默认值是300S，我个人觉得300S还是太长了，即使大的集群60S发送一次也不会造成大的网络流量
  154. tcp-keepalive 300
  155.  
  156. ################################# GENERAL #####################################
  157.  
  158. # By default Redis does not run as a daemon. Use 'yes' if you need it.
  159. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
  160. # 将"daemonize"设置为yes，Redis会以守护进程的方式运行，并且会在/var/run目录下生成一个redis.pid文件
  161. daemonize no
  162.  
  163. # If you run Redis from upstart or systemd, Redis can interact with your
  164. # supervision tree. Options:
  165. #   supervised no      - no supervision interaction
  166. #   supervised upstart - signal upstart by putting Redis into SIGSTOP mode
  167. #   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
  168. #   supervised auto    - detect upstart or systemd method based on
  169. #                        UPSTART_JOB or NOTIFY_SOCKET environment variables
  170. # 使用Linux系统的upstart或者systemd两种方式来管理redis的启动，需要结合linux的版本来决定，centos7设置为systemd，而ubuntu设置为upstart
  171. # Note: these supervision methods only signal "process is ready."
  172. #       They do not enable continuous liveness pings back to your supervisor.
  173. supervised no
  174.  
  175. # If a pid file is specified, Redis writes it where specified at startup
  176. # and removes it at exit.
  177. # 如果设置了pid文件，那么Redis启动时会写该pid文件到指定的目录下，退出时删除该pid文件
  178. #
  179. # When the server runs non daemonized, no pid file is created if none is
  180. # specified in the configuration. When the server is daemonized, the pid file
  181. # is used even if not specified, defaulting to "/var/run/redis.pid".
  182. # 如果redis是以守护进程方式运行的，如果没有指定"pidfile"的值，默认生成一个/var/run/redis.pid文件，否则使用指定的"pidfile"
  183. # 如果redis是以非守护进程方式运行，如果没有指定"pidfile"的值，则不会产生pid file
  184. #
  185. # Creating a pid file is best effort: if Redis is not able to create it
  186. # nothing bad happens, the server will start and run normally.
  187. pidfile /var/run/redis_6379.pid
  188.  
  189. # Specify the server verbosity level.
  190. # This can be one of:
  191. # debug (a lot of information, useful for development/testing)
  192. # verbose (many rarely useful info, but not a mess like the debug level)
  193. # notice (moderately verbose, what you want in production probably)
  194. # warning (only very important / critical messages are logged)
  195. # 指定Redis服务的详细日志级别，有debug\verbose\notice\warning四种级别，debug当然是不推荐的，日志太多了，除非有特殊情况，开发环境可以试试
  196. loglevel notice
  197.  
  198. # Specify the log file name. Also the empty string can be used to force
  199. # Redis to log on the standard output. Note that if you use standard
  200. # output for logging but daemonize, logs will be sent to /dev/null
  201. # 如果以非守护进程的方式运行，且没有指定"logfile"，那么日志会发送到/dev/null(空文件)，我们无法通过它看到任何日志,但如果指定了"logfile"，则输出到配置的文件当中
  202. # 如果以守护进程的方式运行，且没有指定"logfile"，那么日志会输出到标准输出(控制台)，但如果指定了"logfile"，则输出到配置的文件当中
  203. logfile ""
  204.  
  205. # 以下3个(syslog-enabled/syslog-ident/syslog-facility)参数感觉不需要关注，它们的目的就是将日志输出使用系统自带的logger，而且可以修改syslog的参数来实现自己特殊的需求
  206. # 我自己没有去测试过，感觉应该很少会用到，也许大企业专门负责Redis集群的会使用它来定制Redis的日志输出格式，然后使用程序来统计最后通过UI来展示
  207. # To enable logging to the system logger, just set 'syslog-enabled' to yes,
  208. # and optionally update the other syslog parameters to suit your needs.
  209. # 如果要使用system logger，则将"syslog-enabled"设置为yes
  210. # syslog-enabled no
  211.  
  212. # Specify the syslog identity.
  213. # 指定syslog的id，应该是随便指定吧，起到唯一标识的作用？？？
  214. # syslog-ident redis
  215.  
  216. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
  217. # 指定localxxx，需要配合/etc/rsyslog.conf文件使用，意思就是将日志文件输出导出到rsyslog.conf指定的文件中。如果开启了syslog-enable,也许自己指定的logfile就失效了，需要通过rsyslog.conf指定localxxx将日志导出指定的文件中
  218. # syslog-facility local0
  219.  
  220. # Set the number of databases. The default database is DB 0, you can select
  221. # a different one on a per-connection basis using SELECT <dbid> where
  222. # dbid is a number between 0 and 'databases'-1
  223. # 设置redis有多少个db，默认是16个，可以超过16，但是最大值是多少我也不知道。
  224. # 客户端连接上服务器之后，可以通过"select databases-1"来选择使用的db，比如要使用第15个db，则使用"select 14"
  225. databases 16
  226.  
  227. # By default Redis shows an ASCII art logo only when started to log to the
  228. # standard output and if the standard output is a TTY. Basically this means
  229. # that normally a logo is displayed only in interactive sessions.
  230. #
  231. # However it is possible to force the pre-4.0 behavior and always show a
  232. # ASCII art logo in startup logs by setting the following option to yes.
  233. # 是否启动的时候输出(显示)Redis的ASCII LOGO，这个没事就不要去动他了吧，看看也不错至少晓得它正在启动了
  234. always-show-logo yes
  235.  
  236. ################################ SNAPSHOTTING 持久化 ################################
  237. # 下持久化有三种，RDB\AOF\RDB+AOF混合，简答提一下对应的实现原理
  238. # RDB：将数据库以二进制存放在磁盘文件中，持久化的时间间隙比较大，丢失的数据比较多，单独只使用这种方式不推荐
  239. # AOF：将操作数据库的指令(包括协议信息)以文本方式存放在磁盘文件中，根据配置最多会丢失1S的数据，这种方式还可以
  240. # 混合：推荐这种方式，但是4.0开始才有此功能，混合持久化结合了RDB快速恢复数据和AOF丢失数据少的优点，而且减少了磁盘开销。。。关于它们更详细的介绍请查看
  241. # Redis设计与实现-RDB持久化 https://my.oschina.net/u/3049601/blog/3153571
  242. # Redis设计与实现-AOF持久化 https://my.oschina.net/u/3049601/blog/3153678
  243. # Redis设计与实现-混合持久化 https://my.oschina.net/u/3049601/blog/3158904
  244. #
  245. # Save the DB on disk: 
  246. # 保存DB到磁盘中
  247. #   save <seconds> <changes>
  248. #
  249. #   Will save the DB if both the given number of seconds and the given
  250. #   number of write operations against the DB occurred.
  251. #
  252. #   In the example below the behaviour will be to save:
  253. #   after 900 sec (15 min) if at least 1 key changed
  254. #   15分钟内至少有一个KEY改变了
  255. #   after 300 sec (5 min) if at least 10 keys changed
  256. #   5分钟内至少有10个KEY改变了
  257. #   after 60 sec if at least 10000 keys changed
  258. #   1分钟内至少有10000个KEY改变了
  259. #
  260. #   Note: you can disable saving completely by commenting out all "save" lines.
  261. #
  262. #   It is also possible to remove all the previously configured save
  263. #   points by adding a save directive with a single empty string argument
  264. #   like in the following example:
  265. #
  266. #   save ""
  267. #   如果想禁止RDB持久化，可以将下面的三个save配置项使用"#"注释掉。还可以使用save ""来代替使用"#"来注释掉三个save配置项
  268.  
  269. save 900 1
  270. save 300 10
  271. save 60 10000
  272.  
  273. # By default Redis will stop accepting writes if RDB snapshots are enabled
  274. # (at least one save point) and the latest background save failed.
  275. # This will make the user aware (in a hard way) that data is not persisting
  276. # on disk properly, otherwise chances are that no one will notice and some
  277. # disaster will happen.
  278. #
  279. # If the background saving process will start working again Redis will
  280. # automatically allow writes again.
  281. #
  282. # However if you have setup your proper monitoring of the Redis server
  283. # and persistence, you may want to disable this feature so that Redis will
  284. # continue to work as usual even if there are problems with disk,
  285. # permissions, and so forth.
  286. # 如果RDB开启了且最近的BGSAVE失败了，那么Redis默认是不会再接收新增或者修改请求了，但如果BGSAVE又恢复工作，那么新增和修改操作可以继续（表示可以自动恢复）
  287. # 如果公司有自己的监控系统可以很好的检测Redis服务和持久化情况，那么可以将此功能关闭，这样可以提高系统的可用性
  288. # 如果使用集群，且从节点够的情况下有自己的监控，真的可以将这个功能关闭掉
  289. stop-writes-on-bgsave-error yes
  290.  
  291. # Compress string objects using LZF when dump .rdb databases?
  292. # For default that's set to 'yes' as it's almost always a win.
  293. # If you want to save some CPU in the saving child set it to 'no' but
  294. # the dataset will likely be bigger if you have compressible values or keys.
  295. # 默认会采用LZF压缩dump出来的数据库并写入到xxx.rdb文件中。压缩会增加CPU的开销，如果想节约CPU的开销，可以将"rdbcompression"设置为"no"，但是会占用更多的磁盘
  296. rdbcompression yes
  297.  
  298. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  299. # This makes the format more resistant to corruption but there is a performance
  300. # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
  301. # for maximum performances.
  302. # 从Redis5版本开始，默认在RDB文件末尾有一个CRC64（一个随机算法，生成信息指纹用的）校验和，它可以让文件格式可以更强的抵抗风险，但是它会带来10左右的性能损失，我们可以禁止它以获得最大的性能输出
  303. #
  304. # RDB files created with checksum disabled have a checksum of zero that will
  305. # tell the loading code to skip the check.
  306. # 如果禁用掉"checksum"，那么生成的RDB文件结尾的校验和为"0"，那么加载程序则会跳过校验
  307. # 针对大企业（不差钱）个人觉得就保留默认设置应该比较好
  308. rdbchecksum yes
  309.  
  310. # The filename where to dump the DB
  311. # 指定RDB文件的名字，建议使用ip+port来指定，运维可以更好的分辨，甚至可以通过程序扫描展示到UI上
  312. dbfilename dump.rdb
  313.  
  314. # The working directory.
  315. #
  316. # The DB will be written inside this directory, with the filename specified
  317. # above using the 'dbfilename' configuration directive.
  318. #
  319. # The Append Only File will also be created inside this directory.
  320. #
  321. # Note that you must specify a directory here, not a file name.
  322. # 指定RDB和AOF文件的存储目录，注意：这里只能指定到目录，不要带文件名称
  323. dir ./
  324.  
  325. ################################# REPLICATION 主从 #################################
  326.  
  327. # Master-Replica replication. Use replicaof to make a Redis instance a copy of
  328. # another Redis server. A few things to understand ASAP（as soon as possible） about Redis replication.
  329. # Redis的主从复制，使用"replicaof"从一个Redis Server复制到另外一个去，下面有几个要点需要理解
  330. #   +------------------+      +---------------+
  331. #   |      Master      | ---> |    Replica    |
  332. #   | (receive writes) |      |  (exact copy) |
  333. #   +------------------+      +---------------+
  334. #
  335. # 1) Redis replication is asynchronous, but you can configure a master to
  336. #    stop accepting writes if it appears to be not connected with at least
  337. #    a given number of replicas.
  338. #    主从复制虽然是异步进行的，但是可以通过配置(min-replicas-to-write)让从节点小于特定值时，主节点不接受"write"请求
  339. #
  340. # 2) Redis replicas are able to perform a partial resynchronization with the
  341. #    master if the replication link is lost for a relatively small amount of
  342. #    time. You may want to configure the replication backlog size (see the next
  343. #    sections of this file) with a sensible value depending on your needs.
  344. #    Redis的老版本没有复制重同步，但是从2.8开始支持部分同步（使用复制挤压缓冲区实现），解决了断线后老版本"完全同步"低效、阻塞、循环同步的问题
  345. #    如果从节点与主节点断开联系一小段时间，则会发起部分同步，但是复制挤压缓冲区也有大小，可以设置缓冲区的大小来减少完全同步出现
  346. #
  347. # 3) Replication is automatic and does not need user intervention. After a
  348. #    network partition replicas automatically try to reconnect to masters
  349. #    and resynchronize with them.
  350. #    复制时自动进行的，且不需要人工介入。在出现网络分区后，从节点会自动尝试去重连主节点，连接成功之后发起部分同步，如果复制积压缓冲区中的数据丢失了，则会发起完全同步
  351. # 
  352. # 这段英文解释如果是入门学习Redis，可能不会太看得懂，推荐先看看Redis设计与实现这本书，会对这段描述有比较深刻的认识
  353. # replicaof <masterip> <masterport>
  354. # replicaof 主节点IP  主节点端口，注意一定要保证主从节点网络是通的，检查本机防火墙和第三方防火墙
  355.  
  356. # If the master is password protected (using the "requirepass" configuration
  357. # directive below) it is possible to tell the replica to authenticate before
  358. # starting the replication synchronization process, otherwise the master will
  359. # refuse the replica request.
  360. # 如果主节点设置了密码，那么在从节点的redis.conf中要设置masterauth配置项，将密码写在这里，如果没有
  361. # 设置，那么主节点会拒绝从节点的复制请求
  362. #
  363. # masterauth <master-password>
  364. # masterauth 主节点密码
  365.  
  366. # When a replica loses its connection with the master, or when the replication
  367. # is still in progress, the replica can act in two different ways:
  368. # 如果从节点与主节点失去连接或者正在从主节点同步数据，那么从节点根据配置可以工作在两种模式下：
  369. #
  370. # 1) if replica-serve-stale-data is set to 'yes' (the default) the replica will
  371. #    still reply to client requests, possibly with out of date data, or the
  372. #    data set may just be empty if this is the first synchronization.
  373. #	 如果"replica-serve-stale-data"设置为"yes"，这也是默认设置，那么从节点将会回复客户端的请求，但是得到的数据可能出现下面两种情况
  374. #     1.如果是与主节点失去连接，那么得到的数据可能是过时的
  375. #     2.如果是第一次从主节点同步数据，那么得到的数据集会是空的
  376. #
  377. # 2) if replica-serve-stale-data is set to 'no' the replica will reply with
  378. #    an error "SYNC with master in progress" to all the kind of commands
  379. #    but to INFO, replicaOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG,
  380. #    SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB,
  381. #    COMMAND, POST, HOST: and LATENCY.
  382. #    如果"replica-serve-stale-data"设置为"no"，从节点将回复客户端"SYNC with master in progress"错误
  383. #    但是INFO, replicaOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG等命令是可以成功执行并得到相应结果
  384. #
  385. replica-serve-stale-data yes
  386.  
  387. # You can configure a replica instance to accept writes or not. Writing against
  388. # a replica instance may be useful to store some ephemeral data (because data
  389. # written on a replica will be easily deleted after resync with the master) but
  390. # may also cause problems if clients are writing to it because of a
  391. # misconfiguration.
  392. # 我们可以配置从节点是否可以接受write请求，非常不建议将从节点设置为可接受write请求，因为同步可能会导致数据丢失
  393. # 因此从Redis2.6就将"replica-read-only"默认设置为"yes"了
  394. #
  395. # Since Redis 2.6 by default replicas are read-only.
  396. #
  397. # Note: read only replicas are not designed to be exposed to untrusted clients
  398. # on the internet. It's just a protection layer against misuse of the instance.
  399. # Still a read only replica exports by default all the administrative commands
  400. # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
  401. # security of read only replicas using 'rename-command' to shadow all the
  402. # administrative / dangerous commands.
  403. # 从节点(只读)在架构时建议不要设计为暴露给互联网上的不可信任客户端，它可以起到滥用实例的保护作用
  404. # 从节点依然支持所有的管理命令，比如CONFI,DEBUG等等，为了提高从节点的安全性，可以使用"rename-command"来屏蔽所有的"管理命令"
  405. replica-read-only yes
  406.  
  407. # Replication SYNC strategy: disk or socket.
  408. # 同步策略：通过磁盘(Disk-backed)或者通过SOCKET(Diskless)
  409. #
  410. # -------------------------------------------------------
  411. # WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY
  412. # -------------------------------------------------------
  413. # 很遗憾通过SOCKET同步还处在试验阶段
  414. #
  415. # New replicas and reconnecting replicas that are not able to continue the replication
  416. # process just receiving differences, need to do what is called a "full
  417. # synchronization". An RDB file is transmitted from the master to the replicas.
  418. # The transmission can happen in two different ways:
  419. # 新的从节点和重连接的从节点(从节点的最新偏移量不在主节点的复制积压缓冲区中)，则会执行"full synchronization"操作，一个RDB文件会采用以下两种方式中的一种传输给从节点：
  420. #
  421. # 1) Disk-backed: The Redis master creates a new process that writes the RDB
  422. #                 file on disk. Later the file is transferred by the parent
  423. #                 process to the replicas incrementally.
  424. #                 主节点fork一个子进程出来将RDB文件生成到磁盘上，然后父进程将RDB文件逐渐发给从节点
  425. # 2) Diskless: The Redis master creates a new process that directly writes the
  426. #              RDB file to replica sockets, without touching the disk at all.
  427. #              主节点fork一个子进程，然后创建一个和从节点的SOCKET连接，直接将数据发送给从节点，而不借助磁盘
  428. #
  429. # With disk-backed replication, while the RDB file is generated, more replicas
  430. # can be queued and served with the RDB file as soon as the current child producing
  431. # the RDB file finishes its work. With diskless replication instead once
  432. # the transfer starts, new replicas arriving will be queued and a new transfer
  433. # will start when the current one terminates.
  434. # 如果使用磁盘(disk-backed)，当子进程生成RDB文件后，多个从节点立即就可以使用RDB文件进行复制操作
  435. # 如果使用SOCKET(diskless)，一旦复制开始，当新的节点复制请求必须等已开始复制完成之后才能进行。
  436. #
  437. # When diskless replication is used, the master waits a configurable amount of
  438. # time (in seconds) before starting the transfer in the hope that multiple replicas
  439. # will arrive and the transfer can be parallelized.
  440. # 当使用SOCKET(diskless)时，主节点可以等一段时间（可配置），这段时间内过来的复制请求可以并行开始
  441. #
  442. # With slow disks and fast (large bandwidth) networks, diskless replication
  443. # works better.
  444. # 如果磁盘效率低，而网络速度快且带宽也大的情况下，Diskless方式完复制效果更好
  445. repl-diskless-sync no
  446.  
  447. # When diskless replication is enabled, it is possible to configure the delay
  448. # the server waits in order to spawn the child that transfers the RDB via socket
  449. # to the replicas.
  450. # 如果"repl-diskless-sync"设置为yes，就需要配置"repl-diskless-sync-delay"让主节点等待更多的复制请求过来，并让他们并发复制
  451. #
  452. # This is important since once the transfer starts, it is not possible to serve
  453. # new replicas arriving, that will be queued for the next RDB transfer, so the server
  454. # waits a delay in order to let more replicas arrive.
  455. # 因为一旦有复制开始进行，新来的复制请求就会排队，因此设置了延迟时间就可以让更多的复制同时执行
  456. #
  457. # The delay is specified in seconds, and by default is 5 seconds. To disable
  458. # it entirely just set it to 0 seconds and the transfer will start ASAP.
  459. # 延迟时间单位是"秒"，默认值是5秒。可以将"repl-diskless-sync-delay"设置为0，这样复制就会立即执行
  460. repl-diskless-sync-delay 5
  461.  
  462. # Replicas send PINGs to server in a predefined interval. It's possible to change
  463. # this interval with the repl_ping_replica_period option. The default value is 10
  464. # seconds.
  465. # 从节点使用"repl-ping-replica-period"指定的时长(单位：秒)定期发送"pings"给主节点，通过这个操作可以检测从节点是否和主节点失联。该值默认是10秒
  466. #
  467. # repl-ping-replica-period 10
  468.  
  469. # The following option sets the replication timeout for:
  470. # "repl-timeout"会影响复制过程中一下三种情况的超时时间
  471. #
  472. # 1) Bulk transfer I/O during SYNC, from the point of view of replica.
  473. # 2) Master timeout from the point of view of replicas (data, pings).
  474. # 3) Replica timeout from the point of view of masters (REPLCONF ACK pings).
  475. #
  476. # It is important to make sure that this value is greater than the value
  477. # specified for repl-ping-replica-period otherwise a timeout will be detected
  478. # every time there is low traffic between the master and the replica.
  479. # 一定要确保"repl-timeout"的值大于"repl-ping-replica-period"的值，否则当主从节点之间通信量很低时，每次判断超时都是成功的，默认值是60秒
  480. #
  481. # repl-timeout 60
  482.  
  483. # Disable TCP_NODELAY on the replica socket after SYNC?
  484. #
  485. # If you select "yes" Redis will use a smaller number of TCP packets and
  486. # less bandwidth to send data to replicas. But this can add a delay for
  487. # the data to appear on the replica side, up to 40 milliseconds with
  488. # Linux kernels using a default configuration.
  489. # 如果将"repl-disable-tcp-nodelay"设置为"yes"，那么主节点会使用更小的TCP packet和更少的带宽发送数据到从节点
  490. # 但是这会让从节点的数据延迟40毫秒(LINUX默认配置，也许可以通过tcp_delack_min修改)，关于tcp-nodelay可以看博客：https://blog.csdn.net/bytxl/article/details/17677495
  491. #
  492. # If you select "no" the delay for data to appear on the replica side will
  493. # be reduced but more bandwidth will be used for replication.
  494. # 如果将"repl-disable-tcp-nodelay"设置为no，那么从节点接收数据的延迟会减少，但是要求更多的带宽来完成复制工作
  495. #
  496. # By default we optimize for low latency, but in very high traffic conditions
  497. # or when the master and replicas are many hops away, turning this to "yes" may
  498. # be a good idea.
  499. # 默认我们使用低延迟的选项，也就是"repl-disable-tcp-nodelay"设置为no，但是在非常高的通信量情况下或者从主节点到从节点会经过很多次转发，将"repl-disable-tcp-nodelay"设置为yes是可能是更好的选择
  500. repl-disable-tcp-nodelay no
  501.  
  502. # Set the replication backlog size. The backlog is a buffer that accumulates
  503. # replica data when replicas are disconnected for some time, so that when a replica
  504. # wants to reconnect again, often a full resync is not needed, but a partial
  505. # resync is enough, just passing the portion of data the replica missed while
  506. # disconnected.
  507. # backlog设置复制积压缓冲区的大小，用以存放从节点与主节点断开连接后这段时间的write等命令，当从节点重新连接上来时，通常不需要做"完全同步"，只需要做部分同步（要求从节点偏移量在复制挤压缓冲区可以找到，表示数据可以使用偏移量后的命令进行恢复），将偏移量后面的命令发送给从节点执行
  508. #
  509. # The bigger the replication backlog, the longer the time the replica can be
  510. # disconnected and later be able to perform a partial resynchronization.
  511. # 更大的backlog意味着从节点可以断开连接更长时间，然后才可以执行部分同步
  512. #
  513. # The backlog is only allocated once there is at least a replica connected.
  514. # 一旦有从节点连接到主节点，复制积压缓冲区就会创建，此时并没有数据。
  515. #
  516. # 这个值到底设置多少，有一个计算公式：2*平均断线时间*每秒写入数据大小，因此和业务量强相关
  517. # repl-backlog-size 1mb
  518.  
  519. # After a master has no longer connected replicas for some time, the backlog
  520. # will be freed. The following option configures the amount of seconds that
  521. # need to elapse, starting from the time the last replica disconnected, for
  522. # the backlog buffer to be freed.
  523. # 当主节点在最后一个从节点断线之后的一段时间后(repl-backlog-ttl设置)，会将复制积压缓冲区释放
  524. #
  525. # Note that replicas never free the backlog for timeout, since they may be
  526. # promoted to masters later, and should be able to correctly "partially
  527. # resynchronize" with the replicas: hence they should always accumulate backlog.
  528. # 从节点永远都不会释放，因为它必须保存自己接收的最新偏移量，当出现断线重连时将这个偏移量发给主节点，主节点决定使用完全同步还是部分同步
  529. #
  530. # A value of 0 means to never release the backlog.
  531. # 如果设置为0，表示永不释放复制积压缓冲区
  532. #
  533. # repl-backlog-ttl 3600
  534.  
  535. # The replica priority is an integer number published by Redis in the INFO output.
  536. # It is used by Redis Sentinel in order to select a replica to promote into a
  537. # master if the master is no longer working correctly.
  538. # "replica-priority"是一个整数值，在哨兵的集群模式下，当"主事哨兵"被选举(选举采用过半原则)出来之后，由它决定挂掉主节点下的某一个从节点作为新的主节点，当其他条件都相同的情况下，"replica-priority"值越小的从节点会被选中作为新的主节点
  539. #
  540. # A replica with a low priority number is considered better for promotion, so
  541. # for instance if there are three replicas with priority 10, 100, 25 Sentinel will
  542. # pick the one with priority 10, that is the lowest.
  543. # 总结起来就是值越小优先级越高，其对应的从节点会优先被选择作为新的主节点
  544. #
  545. # However a special priority of 0 marks the replica as not able to perform the
  546. # role of master, so a replica with priority of 0 will never be selected by
  547. # Redis Sentinel for promotion.
  548. # 如果将"replica-priority"设置为0，则该从节点永远都不会被选择为新的主节点，根本就不参与选举。可以减少选举过程中过多的网络通信，加快选举过程
  549. # 我还只是一个理论派，没实战经验，个人感觉如果机器硬件够好，且机器所在的网络质量够好，可以将其优先级设置得高一些
  550. #
  551. # By default the priority is 100.
  552. # 默认值是100
  553. replica-priority 100
  554.  
  555. # It is possible for a master to stop accepting writes if there are less than
  556. # N replicas connected, having a lag less or equal than M seconds.
  557. # 如果连接的从节点小于N且它们的滞后时间小于或者等于M秒，那么主节点可能会停止接收写操作
  558. # 网上说这两个条件中一个不满足就可能导致主节点不能接收写操作，是很准确，必须是两个条件同时满足才会触发
  559. #
  560. # The N replicas need to be in "online" state.
  561. # 要求这N个从节点是"online"状态，还有在哨兵和Cluster模式下节点还有主观下线和客观下线状态
  562. #
  563. # The lag in seconds, that must be <= the specified value, is calculated from
  564. # the last ping received from the replica, that is usually sent every second.
  565. # 滞后时间的秒数必须小于指定值，滞后时间=当前时间-最后一次接收到的从replica发过来的ping时间
  566. #
  567. # This option does not GUARANTEE that N replicas will accept the write, but
  568. # will limit the window of exposure for lost writes in case not enough replicas
  569. # are available, to the specified number of seconds.
  570. # 这个选项并不能保证N个从节点接收写操作，但是可以将丢失的数据限制在指定秒数内
  571. #
  572. # For example to require at least 3 replicas with a lag <= 10 seconds use:
  573. #
  574. # min-replicas-to-write 3
  575. # min-replicas-max-lag 10
  576. #
  577. # Setting one or the other to 0 disables the feature.
  578. # 如果将这两个选项中的任何一个设置为0，表示禁用这个特征
  579. #
  580. # By default min-replicas-to-write is set to 0 (feature disabled) and
  581. # min-replicas-max-lag is set to 10.
  582. # 默认"min-replicas-to-write"被设置为0，即禁止了这个特征，"min-replicas-max-lag"默认值为10秒
  583.  
  584. # A Redis master is able to list the address and port of the attached
  585. # replicas in different ways. For example the "INFO replication" section
  586. # offers this information, which is used, among other tools, by
  587. # Redis Sentinel in order to discover replica instances.
  588. # Another place where this info is available is in the output of the
  589. # "ROLE" command of a master.
  590. #
  591. # The listed IP and address normally reported by a replica is obtained
  592. # in the following way:
  593. #
  594. #   IP: The address is auto detected by checking the peer address
  595. #   of the socket used by the replica to connect with the master.
  596. #
  597. #   Port: The port is communicated by the replica during the replication
  598. #   handshake, and is normally the port that the replica is using to
  599. #   listen for connections.
  600. #
  601. # However when port forwarding or Network Address Translation (NAT) is
  602. # used, the replica may be actually reachable via different IP and port
  603. # pairs. The following two options can be used by a replica in order to
  604. # report to its master a specific set of IP and port, so that both INFO
  605. # and ROLE will report those values.
  606. #
  607. # There is no need to use both the options if you need to override just
  608. # the port or the IP address.
  609. # 总结起来说：在主节点中使用info replication可以列出所有从节点的IP+PORT，本来主节点可以使用SOCKET拿到从节点的IP+PORT，但如果使用端口转发(docker,k8s)和NAT或者因为使用了代理，从节点不能直接通过IP+PORT到达，下面这两个从节点选项才有用，它可以将设置的IP和PORT报告给主节点，INFO和ROLE命令会显示设置的值
  610. #
  611. # replica-announce-ip 5.5.5.5
  612. # replica-announce-port 1234
  613.  
  614. ################################## SECURITY ###################################
  615.  
  616. # Require clients to issue AUTH <PASSWORD> before processing any other
  617. # commands.  This might be useful in environments in which you do not trust
  618. # others with access to the host running redis-server.
  619. # 为了让不信任的客户端访问Redis Server，可以要求客户端在执行任何命令之前先校验密码
  620. #
  621. # This should stay commented out for backward compatibility and because most
  622. # people do not need auth (e.g. they run their own servers).
  623. # 如果客户端和Redis server运行在同一个机器，我们也可以将"requirepass"注释掉，客户端就不需要校验密码。
  624. # 可以推广到：如果在一个局域网里面，如果安全做得足够好，则都可以不设置"requirepass"
  625. #
  626. # Warning: since Redis is pretty fast an outside user can try up to
  627. # 150k passwords per second against a good box. This means that you should
  628. # use a very strong password otherwise it will be very easy to break.
  629. # 因为Redis可以每秒可以验证150K个密码，因此如果要设置密码，一定要设置一个非常强壮的密码，否则很容易被破解
  630. #
  631. # requirepass foobared
  632.  
  633. # Command renaming.
  634. # 重命名command，可以保护我们的管理员命令和一些会导致Redis卡顿的命令
  635. #
  636. # It is possible to change the name of dangerous commands in a shared
  637. # environment. For instance the CONFIG command may be renamed into something
  638. # hard to guess so that it will still be available for internal-use tools
  639. # but not available for general clients.
  640. # 在共享环境中，可以将一些危险的命令进行重命名，这样可以让普通的客户端不可以使用那些被重命名的命令，只有内部工具可以使用
  641. #
  642. # Example:
  643. #
  644. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  645. #
  646. # It is also possible to completely kill a command by renaming it into
  647. # an empty string:
  648. # 可以将危险的命令重命名为一个空串，彻底的禁止该命令
  649. #
  650. # rename-command CONFIG ""
  651. #
  652. # Please note that changing the name of commands that are logged into the
  653. # AOF file or transmitted to replicas may cause problems.
  654. # 因为主节点的会将write命令使用缓冲区记录下来并传播给从节点执行，因此如果重命名的命令在从节点没有同步修改的话，这可能带来一些意想不到的问题，因此一定要小心这一点。
  655. # 比如将set命令重命名为myset，那么在主节点执行myset foo Messi之后，从节点并不会有foo这个key,因为从节点并不认识myset这个命令
  656.  
  657. ################################### CLIENTS ####################################
  658.  
  659. # Set the max number of connected clients at the same time. By default
  660. # this limit is set to 10000 clients, however if the Redis server is not
  661. # able to configure the process file limit to allow for the specified limit
  662. # the max number of allowed clients is set to the current file limit
  663. # minus 32 (as Redis reserves a few file descriptors for internal uses).
  664. #
  665. # Once the limit is reached Redis will close all the new connections sending
  666. # an error 'max number of clients reached'.
  667. # 设置同时可以连接到服务器的客户端数量，默认值是10000，但如果主机的最大文件打开数并没有比"maxclients"大，那么"maxclients"=最大文件打开数-32，这个32是提供给Redis内部使用的，比如集群之间的通信等也需要连接数
  668. #
  669. # maxclients 10000
  670.  
  671. ############################## MEMORY MANAGEMENT ################################
  672.  
  673. # Set a memory usage limit to the specified amount of bytes.
  674. # When the memory limit is reached Redis will try to remove keys
  675. # according to the eviction policy selected (see maxmemory-policy).
  676. # 设置Redis的工作最大内存为某一个特定的限制值。当内存使用达到限制值，根据设置的淘汰策略删除keys
  677. #
  678. # If Redis can't remove keys according to the policy, or if the policy is
  679. # set to 'noeviction', Redis will start to reply with errors to commands
  680. # that would use more memory, like SET, LPUSH, and so on, and will continue
  681. # to reply to read-only commands like GET.
  682. # 当Redis无法根据设置的淘汰策略删除keys时或者淘汰策略被设置为"noeviction"，像set lpush等命令会收到报错,此时管理员就应该特别注意了，及时的增加内存，但是此时读命令还是可以继续正常使用的
  683. #
  684. # This option is usually useful when using Redis as an LRU or LFU cache, or to
  685. # set a hard memory limit for an instance (using the 'noeviction' policy).
  686. # 如果将Redis作为一个LRU或者LFU的缓存，再或者将Redis作为hard memory limit for an instance使用时，这个选项就非常有用
  687. #
  688. # WARNING: If you have replicas attached to an instance with maxmemory on,
  689. # the size of the output buffers needed to feed the replicas are subtracted
  690. # from the used memory count, so that network problems / resyncs will
  691. # not trigger a loop where keys are evicted, and in turn the output
  692. # buffer of replicas is full with DELs of keys evicted triggering the deletion
  693. # of more keys, and so forth until the database is completely emptied.
  694. # 如果一个设置了"maxmemory"的主节点连接了一个从节点，那么用于主从复制传递命令的输出缓冲区占用的内存也在maxmemory当中，如果当内存被占满时而出现大量的删除key的操作写到缓冲区，而缓冲区又不够，又会触发删除更多的key,这样就会造成一个死循环，直到整个数据库变成空的。
  695. # 因此
  696. #
  697. # In short... if you have replicas attached it is suggested that you set a lower
  698. # limit for maxmemory so that there is some free RAM on the system for replica
  699. # output buffers (but this is not needed if the policy is 'noeviction').
  700. # 因为used memory是可以大于maxmemory的，只不过出现这种情时会导致内存回收而触发删除KEY的操作。因此，如果在主从模式下，主节点的maxmemory在设置得足够大的情况下，还要给输出缓冲区留出一点空间来，避免出现死循环而导致数据库被清空。不要物理内存有多少就设置多少，况且还有操作系统和其他程序在运行,一般设置为3/4。
  701. #
  702. # maxmemory <bytes>
  703.  
  704. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
  705. # is reached. You can select among five behaviors:
  706. #
  707. # volatile-lru -> Evict using approximated LRU among the keys with an expire set.
  708. # allkeys-lru -> Evict any key using approximated LRU.
  709. # volatile-lfu -> Evict using approximated LFU among the keys with an expire set.
  710. # allkeys-lfu -> Evict any key using approximated LFU.
  711. # volatile-random -> Remove a random key among the ones with an expire set.
  712. # allkeys-random -> Remove a random key, any key.
  713. # volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
  714. # noeviction -> Don't evict anything, just return an error on write operations.
  715. # 关于这几个策略的讲解百度可以找到非常好的描述，在这里就不详细描述了，篇幅也不够
  716. # 推荐一个：https://cloud.tencent.com/developer/article/1530553 讲了原理和使用说明
  717. #
  718. # LRU means Least Recently Used   最近没有被使用的
  719. # LFU means Least Frequently Used 最近使用频率最小的
  720. #
  721. # Both LRU, LFU and volatile-ttl are implemented using approximated randomized algorithms
  722. # LRU LFU 和volatile-ttl使用了较接近的随机算法
  723. #
  724. # Note: with any of the above policies, Redis will return an error on write
  725. #       operations, when there are no suitable keys for eviction.
  726. #       选择上面的任何一种策略，如果没有适合的KEY被淘汰，那么下面的这些写操作就会报错
  727. #
  728. #       At the date of writing these commands are: set setnx setex append
  729. #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
  730. #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
  731. #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
  732. #       getset mset msetnx exec sort
  733. #
  734. # The default is:
  735. # 默认设置是noeviction
  736. #
  737. # maxmemory-policy noeviction
  738.  
  739. # LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated
  740. # algorithms (in order to save memory), so you can tune it for speed or
  741. # accuracy. For default Redis will check five keys and pick the one that was
  742. # used less recently, you can change the sample size using the following
  743. # configuration directive.
  744. # LRU LFU TTL三种方式并不是精准的算法，这是为了提高速度和节省内存，同时达到了近似的效果。。。很妙
  745. # 我们可以基于速度或者精准度的要求去调整采样的数据大小，"maxmemory-samples"值越大精准度越高，速度越慢，消耗的内存也越多，反之速度快，但是精准度低，内存开销少
  746. #
  747. # The default of 5 produces good enough results. 10 Approximates very closely
  748. # true LRU but costs more CPU. 3 is faster but not very accurate.
  749. # 默认值是5，如果设置为10就非常接近真正的LRU算法了，但是CPU开销也越多了。如果设置为3，速度快了，但是没那么准确
  750. #
  751. # maxmemory-samples 5
  752.  
  753. # Starting from Redis 5, by default a replica will ignore its maxmemory setting
  754. # (unless it is promoted to master after a failover or manually). It means
  755. # that the eviction of keys will be just handled by the master, sending the
  756. # DEL commands to the replica as keys evict in the master side.
  757. # 从Redis 5开始，从节点默认是忽略掉maxmemory设置的，除非从节点在故障转移时变成了主节点
  758. # 正常情况下，从节点的Key淘汰是通过从主节点发送del命令过来实现的
  759. #
  760. # This behavior ensures that masters and replicas stay consistent, and is usually
  761. # what you want, however if your replica is writable, or you want the replica to have
  762. # a different memory setting, and you are sure all the writes performed to the
  763. # replica are idempotent, then you may change this default (but be sure to understand
  764. # what you are doing).
  765. # "replica-ignore-maxmemory"可以保证主从的数据一致性，除非你真的知道自己把"replica-ignore-maxmemory"
  766. # 设置为no带来的副作用，那建议你不要做着骚的操作，坑人哦
  767. #
  768. # Note that since the replica by default does not evict, it may end using more
  769. # memory than the one set via maxmemory (there are certain buffers that may
  770. # be larger on the replica, or data structures may sometimes take more memory and so
  771. # forth). So make sure you monitor your replicas and make sure they have enough
  772. # memory to never hit a real out-of-memory condition before the master hits
  773. # the configured maxmemory setting.
  774. # 由于从节点默认情况下是不主动删除KEY的，它可能比主节点消耗更多的内存(可能buffer更大，可能数据结构消耗的内存更多等等)，所以要使用你的monitor实时监控你的从节点，并保证主节点达到maxmemory时间先于从节点的内存超过真正的物理内存
  775. #
  776. # replica-ignore-maxmemory yes
  777.  
  778. ############################# LAZY FREEING 惰性回收 ####################################
  779.  
  780. # Redis has two primitives to delete keys. One is called DEL and is a blocking
  781. # deletion of the object. It means that the server stops processing new commands
  782. # in order to reclaim all the memory associated with an object in a synchronous
  783. # way. If the key deleted is associated with a small object, the time needed
  784. # in order to execute the DEL command is very small and comparable to most other
  785. # O(1) or O(log_N) commands in Redis. However if the key is associated with an
  786. # aggregated value containing millions of elements, the server can block for
  787. # a long time (even seconds) in order to complete the operation.
  788. # Redis提供了两个命令来手动删除keys，其中一个是大家熟知的del，另外一个是unlink
  789. # "del"命令：删除是阻塞式(执行删除时，后续的命令就要排队等待)删除以便释放空间，如果一个Key比较小则删除很快，影响小，但如果这个Key对应的对象非常大，那么删除会很耗时，在高并发的系统里面会阻塞后面的请求，如果系统架构设计不合理则可能导致整个业务系统不可供，造成严重的生产事故
  790. # "unlink"命令：是异步的尽可能快的逐步删除，它所需的时间复杂度是O(1)，Redis会启动另外一个线程来执行真正的删除并回收内存的操作，它不会阻塞后续命令。比如flushall flushdb命令也是异步执行的。
  791. #
  792. # For the above reasons Redis also offers non blocking deletion primitives
  793. # such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and
  794. # FLUSHDB commands, in order to reclaim memory in background. Those commands
  795. # are executed in constant time. Another thread will incrementally free the
  796. # object in the background as fast as possible.
  797. #
  798. # DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.
  799. # It's up to the design of the application to understand when it is a good
  800. # idea to use one or the other. However the Redis server sometimes has to
  801. # delete keys or flush the whole database as a side effect of other operations.
  802. # Specifically Redis deletes objects independently of a user call in the
  803. # following scenarios:
  804. # 除了用户可以使用del,unlink,flushall,flushdb删除key，Redis Server在某些情况下不得不删除Key，甚至清空整个db以保证服务的可用性，下面列举了4种情况
  805. #
  806. # 1) On eviction, because of the maxmemory and maxmemory policy configurations,
  807. #    in order to make room for new data, without going over the specified
  808. #    memory limit.
  809. #    为了避免Redis使用的内存超过"maxmemory"，且一直在这种状态下运行，Redis Server会根据选择的删除策略去自动删除一些Key，以释放空间给其他数据使用。
  810. #
  811. # 2) Because of expire: when a key with an associated time to live (see the
  812. #    EXPIRE command) must be deleted from memory.
  813. #    Key设置的过期时间到了，当用户访问这个Key会自动删除，或者Redis Server定期将这种Key删除。
  814. #
  815. # 3) Because of a side effect of a command that stores data on a key that may
  816. #    already exist. For example the RENAME command may delete the old key
  817. #    content when it is replaced with another one. Similarly SUNIONSTORE
  818. #    or SORT with STORE option may delete existing keys. The SET command
  819. #    itself removes any old content of the specified key in order to replace
  820. #    it with the specified string.
  821. #    一些命令的底层实现就是先删除再新增，所以再使用这些命令的时候会执行删除操作，比如SET,SORT,RENAME
  822. #
  823. # 4) During replication, when a replica performs a full resynchronization with
  824. #    its master, the content of the whole database is removed in order to
  825. #    load the RDB file just transferred.
  826. #    主从模式下，如果断网重连后触发了"完全同步"，也会将整个DB数据删除掉，然后再从RDB文件/SOCKET中加载所有数据
  827. #
  828. # In all the above cases the default is to delete objects in a blocking way,
  829. # like if DEL was called. However you can configure each case specifically
  830. # in order to instead release memory in a non-blocking way like if UNLINK
  831. # was called, using the following configuration directives:
  832. # 上面的4种情况，Redis Server删除数据都是阻塞式删除，就像"del"命令。我们可以将这4种情况的设置为异步删除，就像命令"unlink"一样
  833.  
  834. lazyfree-lazy-eviction no
  835. lazyfree-lazy-expire no
  836. lazyfree-lazy-server-del no
  837. replica-lazy-flush no
  838.  
  839. ############################## APPEND ONLY MODE ###############################
  840.  
  841. # By default Redis asynchronously dumps the dataset on disk. This mode is
  842. # good enough in many applications, but an issue with the Redis process or
  843. # a power outage may result into a few minutes of writes lost (depending on
  844. # the configured save points).
  845. # Redis的"bgsave"可以异步的将数据集导出到RDB文件中，这种持久化方式满足了大多数的应用，但是有一种情况是当因为一些情况挂掉，比如断电，根据"save xxx"的配置可能会导致几分钟的数据丢失，在一些要求高的系统中这种情况是不被允许的。
  846. #
  847. # The Append Only File is an alternative persistence mode that provides
  848. # much better durability. For instance using the default data fsync policy
  849. # (see later in the config file) Redis can lose just one second of writes in a
  850. # dramatic event like a server power outage, or a single write if something
  851. # wrong with the Redis process itself happens, but the operating system is
  852. # still running correctly.
  853. # Redis提供了"Append Only File"新的持久化技术，该技术理论上可以做到当发生断电时让丢失的数据小于等于1秒，或者服务器本身没有挂，只是Redis Server程序挂了，甚至只有一个single write丢失
  854. #
  855. # AOF and RDB persistence can be enabled at the same time without problems.
  856. # If the AOF is enabled on startup Redis will load the AOF, that is the file
  857. # with the better durability guarantees.
  858. # AOF和RDB两种持久化技术可以同时开启，如果AOF开启了，那么启动Redis时，是从AOF文件中加载数据的，因为它保存的数据更完整，提供更好的持久化功能
  859. #
  860. # Please check http://redis.io/topics/persistence for more information.
  861. # 更多的信息请出门左转到：http://redis.io/topics/persistence for more information
  862. # 开启AOF，"appendonly"设置为yes
  863. appendonly no
  864.  
  865. # The name of the append only file (default: "appendonly.aof")
  866. # 指定AOF文件名，此文件存放的目录和RDB是共用的，使用"dir"进行指定
  867. appendfilename "appendonly.aof"
  868.  
  869. # 对于没有OS知识的朋友，接下来的appendfsync功能可以先要去百度找操作系统写文件缓冲区的知识点，fsync不同的选项决定了写入缓冲区的数据什么时候真正写到磁盘上
  870. # The fsync() call tells the Operating System to actually write data on disk
  871. # instead of waiting for more data in the output buffer. Some OS will really flush
  872. # data on disk, some other OS will just try to do it ASAP.
  873. # 系统调用"fsync()"告诉OS要真正的将数据写入到磁盘上，而不是写入到缓冲区当中。一些OS会立即写到磁盘，一些OS可能会尽可能快的藏尸将数据写到磁盘
  874. #
  875. # Redis supports three different modes:
  876. # Redis支持三种不同的模式：
  877. #
  878. # no: don't fsync, just let the OS flush the data when it wants. Faster.
  879. # 模式1-"no"：不调用OS的fsync函数，让OS自己决定什么时候将缓冲区的数据写入到磁盘上，该模式对Redis来说速度最快
  880. #
  881. # always: fsync after every write to the append only log. Slow, Safest.
  882. # 模式2-"always"：每次"写操作"都会调用一次fsync函数，这种方式最安全，但是速度是最慢的
  883. #
  884. # everysec: fsync only one time every second. Compromise.
  885. # 模式3-"everysec"：每一秒钟调用一次fsync，这是一种这种折中方案。
  886. # 
  887. # 看到这里顺便提一下，在Redis中随处可见这种思想，比如前面近似LRU的随机算法，有序集合底层数据结构中结合Hash表和跳跃表实现高效的单个和范围查询，过期key的惰性删除等等
  888. # 在我们自己设计系统、开发模块、甚至生活中也可以将这个思想好好运用
  889. #
  890. # The default is "everysec", as that's usually the right compromise between
  891. # speed and data safety. It's up to you to understand if you can relax this to
  892. # "no" that will let the operating system flush the output buffer when
  893. # it wants, for better performances (but if you can live with the idea of
  894. # some data loss consider the default persistence mode that's snapshotting),
  895. # or on the contrary, use "always" that's very slow but a bit safer than
  896. # everysec.
  897. # 默认模式是"everysec"的，这是结合速度和安全性的这种方案。如果你不考虑系统DOWN可能带来的数据丢失，可以将模式设置为"no"，而如果你想数据完全不丢，且愿意牺牲性能，可以将模式设置为"always"
  898. #
  899. # More details please check the following article:
  900. # http://antirez.com/post/redis-persistence-demystified.html
  901. # 更多的细节请出门左转：http://antirez.com/post/redis-persistence-demystified.html
  902. # 另外大牛"antirez"还开发了基于Redis的神经网络训练模块(neural-redis)和分布式作业队列(Disque)
  903. # If unsure, use "everysec".
  904. # 如果自己不确定到底使用哪一种，就使用默认值everysec
  905.  
  906. # appendfsync always
  907. appendfsync everysec
  908. # appendfsync no
  909.  
  910. # When the AOF fsync policy is set to always or everysec, and a background
  911. # saving process (a background save or AOF log background rewriting) is
  912. # performing a lot of I/O against the disk, in some Linux configurations
  913. # Redis may block too long on the fsync() call. Note that there is no fix for
  914. # this currently, as even performing fsync in a different thread will block
  915. # our synchronous write(2) call.
  916. # 当AOF模式设置为"everysec"或者"always"，执行后台保存AOF文件操作或者AOF文件重写(可以单独百度一下，有的面试官会问这个问题)会产生大量的IO，而一些LINUX OS的fsync调用会被阻塞很长时间(目前还未解决这个问题)，这种情况会阻塞另外线程的同步写操作
  917. #
  918. # In order to mitigate this problem it's possible to use the following option
  919. # that will prevent fsync() from being called in the main process while a
  920. # BGSAVE or BGREWRITEAOF is in progress.
  921. # 为了减轻这个问题带来的影响，可以使用"no-appendfsync-on-rewrite"配置，一旦有BGSAVE和BGREWRITEAOF在执行，阻止fsync函数调用
  922. #
  923. # This means that while another child is saving, the durability of Redis is
  924. # the same as "appendfsync none". In practical terms, this means that it is
  925. # possible to lose up to 30 seconds of log in the worst scenario (with the
  926. # default Linux settings).
  927. # 简单点说就是：当"no-appendfsync-on-rewrit"设置为no,那么有一个进程在执行SAVE操作，AOF持久化模式相当于被设置成了"no"，也就是说根据OS的设置，糟糕的情况下可能丢失30秒以上的数据
  928. #
  929. # If you have latency problems turn this to "yes". Otherwise leave it as
  930. # "no" that is the safest pick from the point of view of durability.
  931. # 如果你知道上面说的潜在风险，可以将"no-appendfsync-on-rewrite"设置为yes，否则就不要瞎搞，就保持为no
  932.  
  933. no-appendfsync-on-rewrite no
  934.  
  935. # AOF文件重写是Redis面试的一个点，也是优化Redis的一个点，将它设置得足够大，可以保存更多日志数据
  936. # Automatic rewrite of the append only file.
  937. # Redis is able to automatically rewrite the log file implicitly calling
  938. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
  939. # 当AOF文件大小超过指定值"auto-aof-rewrite-min-size"，就会发生AOF文件重写
  940. #
  941. # This is how it works: Redis remembers the size of the AOF file after the
  942. # latest rewrite (if no rewrite has happened since the restart, the size of
  943. # the AOF at startup is used).
  944. # Redis会记住AOF重写后的AOF文件大小，如果重启后还未发生重写，那么记住的就是刚开始加载AOF文件的大小
  945. # 这个文件大小值会与下面的配置项值进行比较，决定什么时候做AOF文件重写
  946. #
  947. # This base size is compared to the current size. If the current size is
  948. # bigger than the specified percentage, the rewrite is triggered. Also
  949. # you need to specify a minimal size for the AOF file to be rewritten, this
  950. # is useful to avoid rewriting the AOF file even if the percentage increase
  951. # is reached but it is still pretty small.
  952. # 如果当"当前大小/最后一次重写大小"的比值大于"auto-aof-rewrite-percentage"指定的值，则会触发AOF重写
  953. # 为了避免AOF已经很小还进行AOF重写的尴尬情况，因此需要设置一个AOF重写最小AOF文件大小
  954. # 比如"auto-aof-rewrite-min-size"设置为64M，只有当AOF文件超过64M，且"当前大小/最后一次重写大小">"auto-aof-rewrite-percentage"才会触发AOF重写
  955. #
  956. # Specify a percentage of zero in order to disable the automatic AOF
  957. # rewrite feature.
  958. # 如果将"auto-aof-rewrite-percentage"设置为0，表示不允许执行自动AOF重写
  959.  
  960. auto-aof-rewrite-percentage 100
  961. auto-aof-rewrite-min-size 64mb
  962.  
  963. # An AOF file may be found to be truncated at the end during the Redis
  964. # startup process, when the AOF data gets loaded back into memory.
  965. # This may happen when the system where Redis is running
  966. # crashes, especially when an ext4 filesystem is mounted without the
  967. # data=ordered option (however this can't happen when Redis itself
  968. # crashes or aborts but the operating system still works correctly).
  969. # 如果运行Redis的OS崩溃掉，特别是ext4格式的文件系统使用"data=ordered"选项执行mount操作，在这些情况下
  970. # AOF文件可能是截断(损坏)的，重启Redis时如果"aof-load-truncated"被设置为yes，那么AOF文件在加载时可能会丢失掉崩溃前的一些数据
  971. #
  972. # Redis can either exit with an error when this happens, or load as much
  973. # data as possible (the default now) and start if the AOF file is found
  974. # to be truncated at the end. The following option controls this behavior.
  975. # 针对损坏的AOF文件，在重启Redis的时候，支持两种方式
  976. # 1.发现文件损坏，直接报错
  977. # 2.尽可能的从找到的截断(损坏)文件中恢复数据到内存中，这是Redis的默认方式
  978. #
  979. # If aof-load-truncated is set to yes, a truncated AOF file is loaded and
  980. # the Redis server starts emitting a log to inform the user of the event.
  981. # 如果"aof-load-truncated"被设置为yes，且发现了被截断的AOF文件，那么在启动Redis时日志或者控制台中会输出日志，让运维人员或者监控看到这条信息
  982. # Otherwise if the option is set to no, the server aborts with an error
  983. # and refuses to start. When the option is set to no, the user requires
  984. # to fix the AOF file using the "redis-check-aof" utility before to restart
  985. # the server.
  986. # 如果将"aof-load-truncated"设置no,且发现了被截断的AOF文件，重启Redis会报错，这个时候就需要借用redis-check-aof工具修复AOF文件
  987. # 其实在主从模式下，是否可以到从节点拿AOF文件进行恢复，好像这个方法是多想了，因为哨兵、Codis、Cluster模式会自动进行故障转移，只有单机和纯主从模式也许这种方式可以尝试，但是现在的企业至少应该是哨兵模式了，大企业都用Cluster了或者豌豆荚搞的Codis
  988. #
  989. # Note that if the AOF file will be found to be corrupted in the middle
  990. # the server will still exit with an error. This option only applies when
  991. # Redis will try to read more data from the AOF file but not enough bytes
  992. # will be found.
  993. # 如果AOF文件在文件中间损坏了，即使"aof-load-truncated"设置为yes，重启Redis一样会报错且退出启动
  994. # 这个选项只适合AOF被截断的情况，也就是AOF没有足够的字节
  995. aof-load-truncated yes
  996.  
  997. # 混合持久化，Redis 4提供的新功能
  998. # When rewriting the AOF file, Redis is able to use an RDB preamble in the
  999. # AOF file for faster rewrites and recoveries. When this option is turned
  1000. # on the rewritten AOF file is composed of two different stanzas:
  1001. # 如果"aof-use-rdb-preamble"设置为yes，那么AOF文件由"rdb file"+"aof tail"两部分组成，这种组合方式可以发挥RDB持久化加载速度快和压缩存储使用空间小的优势，与AOF持久化丢失数据小于1S的优势
  1002. # 
  1003. #   [RDB file][AOF tail]
  1004. #
  1005. # When loading Redis recognizes that the AOF file starts with the "REDIS"
  1006. # string and loads the prefixed RDB file, and continues loading the AOF
  1007. # tail.
  1008. # 该混合持久化方式下的AOF文件用"REDIS"字符串区分，前面是RDB内容，后面是AOF内容
  1009.  
  1010. aof-use-rdb-preamble yes
  1011.  
  1012. ################################ LUA SCRIPTING LUA脚本 ###############################
  1013. # LUA脚本我没有研究过，简单说下这个配置项是设置LUA脚本最大执行时间
  1014. # 另外LUA脚本执行是原子的，因此可以用它做一些特殊的实现，不过就像Oracle的存储过程一样，维护不方便，比较这个脚本语言会的人太少了
  1015. # 如果确实有需要，在考虑运维的情况下可以使用它来实现原子性等操作，慎用
  1016. # Max execution time of a Lua script in milliseconds.
  1017. #
  1018. # If the maximum execution time is reached Redis will log that a script is
  1019. # still in execution after the maximum allowed time and will start to
  1020. # reply to queries with an error.
  1021. #
  1022. # When a long running script exceeds the maximum execution time only the
  1023. # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
  1024. # used to stop a script that did not yet called write commands. The second
  1025. # is the only way to shut down the server in the case a write command was
  1026. # already issued by the script but the user doesn't want to wait for the natural
  1027. # termination of the script.
  1028. #
  1029. # Set it to 0 or a negative value for unlimited execution without warnings.
  1030. # 如果设置为0或者负值，表示不限制执行时间
  1031. lua-time-limit 5000
  1032.  
  1033. ################################ REDIS CLUSTER 集群 ###############################
  1034. # 在看下面的内容之前建议先去百度一下redis hash slots,以及集群的架构图
  1035. #
  1036. # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1037. # WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however
  1038. # in order to mark it as "mature" we need to wait for a non trivial percentage
  1039. # of users to deploy it in production.
  1040. # 虽然Redis Cluster被认为是稳定的，但是依然需要大量的用户在生产环境中使用它。。。这段注释应该从redis.conf中删除了，全世界已经有知名的大企业使用了Redis Cluster
  1041. # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1042. #
  1043. # Normal Redis instances can't be part of a Redis Cluster; only nodes that are
  1044. # started as cluster nodes can. In order to start a Redis instance as a
  1045. # cluster node enable the cluster support uncommenting the following:
  1046. # 将"cluster-enabled"设置为yes,redis instance才能成为集群的一部分，但集群要真正开始工作，还需要将
  1047. # 所有的slots分配给cluster node
  1048. #
  1049. # cluster-enabled yes
  1050.  
  1051. # Every cluster node has a cluster configuration file. This file is not
  1052. # intended to be edited by hand. It is created and updated by Redis nodes.
  1053. # Every Redis Cluster node requires a different cluster configuration file.
  1054. # Make sure that instances running in the same system do not have
  1055. # overlapping cluster configuration file names.
  1056. # 每个cluster node有自己的cluster configuration file，且该配置文件不能手工编辑，而是自动创建和更新的
  1057. # cluster configuration file不能重名
  1058. #
  1059. # cluster-config-file nodes-6379.conf
  1060.  
  1061. # Cluster node timeout is the amount of milliseconds a node must be unreachable
  1062. # for it to be considered in failure state.
  1063. # Most other internal time limits are multiple of the node timeout.
  1064. # 集群节点在"cluster-node-timeout"规定的超时时间内，如果不可达，则被认为是失败状态
  1065. # 注意：集群内的大多数其他内部时间限制是"cluster-node-timeout"的倍数
  1066. #
  1067. # cluster-node-timeout 15000
  1068.  
  1069. # A replica of a failing master will avoid to start a failover if its data
  1070. # looks too old.
  1071. # 如果一个掉线主节点的从节点数据太老了，是不允许参与故障转移的
  1072. #
  1073. # There is no simple way for a replica to actually have an exact measure of
  1074. # its "data age", so the following two checks are performed:
  1075. # 没得撒子简单的办法可以一下计算出数据的年龄，因此Redis提供下面的两点来校验数据年龄，以决定集群节点是否参与故障转移过程：
  1076. #
  1077. # 1) If there are multiple replicas able to failover, they exchange messages
  1078. #    in order to try to give an advantage to the replica with the best
  1079. #    replication offset (more data from the master processed).
  1080. #    Replicas will try to get their rank by offset, and apply to the start
  1081. #    of the failover a delay proportional to their rank.
  1082. #    根据从节点的偏移量(主从复制-复制挤压缓冲区里面的偏移量，这个偏移量会跟着命令发给从节点，并保存下来)谁是最新的，并且根据偏移量排序，根据这个排序结果将从节点作为候选主节点
  1083. #
  1084. # 2) Every single replica computes the time of the last interaction with
  1085. #    its master. This can be the last ping or command received (if the master
  1086. #    is still in the "connected" state), or the time that elapsed since the
  1087. #    disconnection with the master (if the replication link is currently down).
  1088. #    If the last interaction is too old, the replica will not try to failover
  1089. #    at all.
  1090. #    每个从节点都会计算它与主节点最后一次交互时间，比如最后一次ping时间、最后一次接收命令时间、与主节点断开连接过去的时长
  1091. #    如果最后一次交互时间太长，那么这个从节点也不会参与故障转移过程
  1092. #
  1093. # The point "2" can be tuned by user. Specifically a replica will not perform
  1094. # the failover if, since the last interaction with the master, the time
  1095. # elapsed is greater than:
  1096. # 前面讲到的第2点有一个计算公式来衡量"最后一次交互时间"是否太长
  1097. #
  1098. #   (node-timeout * replica-validity-factor) + repl-ping-replica-period
  1099. #
  1100. # So for example if node-timeout is 30 seconds, and the replica-validity-factor
  1101. # is 10, and assuming a default repl-ping-replica-period of 10 seconds, the
  1102. # replica will not try to failover if it was not able to talk with the master
  1103. # for longer than 310 seconds.
  1104. # 假设"cluster-node-timeout"是30S，"replica-validity-factor"是10，"repl-ping-replica-period"是10S
  1105. # 如果"最后一次交互"时间超过"30*10+10=310"就被认为太长，而不能参与故障转移
  1106. #
  1107. # A large replica-validity-factor may allow replicas with too old data to failover
  1108. # a master, while a too small value may prevent the cluster from being able to
  1109. # elect a replica at all.
  1110. # "replica-validity-factor"太大，从节点数据可能会太久，如果太小可能选举不成功，集群不可用，所以要根据实际情况设置
  1111. #
  1112. # For maximum availability, it is possible to set the replica-validity-factor
  1113. # to a value of 0, which means, that replicas will always try to failover the
  1114. # master regardless of the last time they interacted with the master.
  1115. # (However they'll always try to apply a delay proportional to their
  1116. # offset rank).
  1117. # 如果为了保证最大的可用性，可以将"cluster-replica-validity-factor"设置为0。此时所有的从节点考虑最后一次交互时间的大小，总是会参与故障转移过程
  1118. #
  1119. # Zero is the only value able to guarantee that when all the partitions heal
  1120. # the cluster will always be able to continue.
  1121. # "cluster-replica-validity-factor"的"0"是唯一可以让集群总是可用的选项值
  1122. #
  1123. # cluster-replica-validity-factor 10
  1124.  
  1125. # Cluster replicas are able to migrate to orphaned masters, that are masters
  1126. # that are left without working replicas. This improves the cluster ability
  1127. # to resist to failures as otherwise an orphaned master can't be failed over
  1128. # in case of failure if it has no working replicas.
  1129. # 再不看下面的配置项功能时，有可能集群从节点会变成一个孤立的从节点，针对这种情况，如果它再发生故障，因为没有备选的从节点，所以故障转移动作没法完成。
  1130. #
  1131. # Replicas migrate to orphaned masters only if there are still at least a
  1132. # given number of other working replicas for their old master. This number
  1133. # is the "migration barrier". A migration barrier of 1 means that a replica
  1134. # will migrate only if there is at least 1 other working replica for its master
  1135. # and so forth. It usually reflects the number of replicas you want for every
  1136. # master in your cluster.
  1137. # 为了避免上面的情况发生，Redis Cluster默认配置要求一个主节点至少有两个从节点，一旦主节点挂了被新选举出来的主节点至少有一个从节点在工作。"cluster-migration-barrier"可以指定该值的大小，默认值是"1"
  1138. #
  1139. # Default is 1 (replicas migrate only if their masters remain with at least
  1140. # one replica). To disable migration just set it to a very large value.
  1141. # A value of 0 can be set but is useful only for debugging and dangerous
  1142. # in production.
  1143. # 默认值是1，如果要想禁止"migration",可以将"cluster-migration-barrier"设置为一个超大的值
  1144. # 可以为了调试或者你想让自己的系统存在高风险的运行，可以设置为0。。。no zuo no die
  1145. #
  1146. # cluster-migration-barrier 1
  1147.  
  1148. # By default Redis Cluster nodes stop accepting queries if they detect there
  1149. # is at least an hash slot uncovered (no available node is serving it).
  1150. # This way if the cluster is partially down (for example a range of hash slots
  1151. # are no longer covered) all the cluster becomes, eventually, unavailable.
  1152. # It automatically returns available as soon as all the slots are covered again.
  1153. # Redis Cluster默认情况下如果有一个hash slot没有被分配(用一个Cluster Node接收它)，那么整个集群是不可用的
  1154. # 在这种模式下，一旦出现网络分区(一段hash slots 就变成未分配)，整个集群就不可用了，直到所有hash slots被分配，集群会自动变得可用
  1155. #
  1156. # However sometimes you want the subset of the cluster which is working,
  1157. # to continue to accept queries for the part of the key space that is still
  1158. # covered. In order to do so, just set the cluster-require-full-coverage
  1159. # option to no.
  1160. # 也许有时你想即使出现hash slots unconverd，而集群的部分节点仍然是可用的，可以将"cluster-require-full-coverage"设置为no
  1161. #
  1162. # cluster-require-full-coverage yes
  1163.  
  1164. # This option, when set to yes, prevents replicas from trying to failover its
  1165. # master during master failures. However the master can still perform a
  1166. # manual failover, if forced to do so.
  1167. # 如果将"cluster-replica-no-failover"设置为yes，那么该集群从节点不会参与自动故障转移过程，但是可以手动强制执行故障转移
  1168. #
  1169. # This is useful in different scenarios, especially in the case of multiple
  1170. # data center operations, where we want one side to never be promoted if not
  1171. # in the case of a total DC failure.
  1172. # 在不同场景可能非常有用，比如有多个数据中心，而我们又不希望整个集群中的某一个数据中心的从节点被提升为主节点
  1173. #
  1174. # cluster-replica-no-failover no
  1175.  
  1176. # In order to setup your cluster make sure to read the documentation
  1177. # available at http://redis.io web site.
  1178.  
  1179. ########################## CLUSTER DOCKER/NAT support  ########################
  1180.  
  1181. # In certain deployments, Redis Cluster nodes address discovery fails, because
  1182. # addresses are NAT-ted or because ports are forwarded (the typical case is
  1183. # Docker and other containers).
  1184. #
  1185. # In order to make Redis Cluster working in such environments, a static
  1186. # configuration where each node knows its public address is needed. The
  1187. # following two options are used for this scope, and are:
  1188. #
  1189. # * cluster-announce-ip
  1190. # * cluster-announce-port
  1191. # * cluster-announce-bus-port
  1192. #
  1193. # Each instruct the node about its address, client port, and cluster message
  1194. # bus port. The information is then published in the header of the bus packets
  1195. # so that other nodes will be able to correctly map the address of the node
  1196. # publishing the information.
  1197. #
  1198. # If the above options are not used, the normal Redis Cluster auto-detection
  1199. # will be used instead.
  1200. #
  1201. # Note that when remapped, the bus port may not be at the fixed offset of
  1202. # clients port + 10000, so you can specify any port and bus-port depending
  1203. # on how they get remapped. If the bus-port is not set, a fixed offset of
  1204. # 10000 will be used as usually.
  1205. #
  1206. # Example:
  1207. #
  1208. # cluster-announce-ip 10.1.1.5
  1209. # cluster-announce-port 6379
  1210. # cluster-announce-bus-port 6380
  1211.  
  1212. ################################## SLOW LOG 慢日志 ###################################
  1213.  
  1214. # The Redis Slow Log is a system to log queries that exceeded a specified
  1215. # execution time. The execution time does not include the I/O operations
  1216. # like talking with the client, sending the reply and so forth,
  1217. # but just the time needed to actually execute the command (this is the only
  1218. # stage of command execution where the thread is blocked and can not serve
  1219. # other requests in the meantime).
  1220. # 记录Redis执行耗时超过指定值的"查询命令"，整个"耗时"仅仅是执行命令的耗时(在这段时间内，因为线程被阻塞，其他命令会被阻塞)，不包括与客户端网络IO所耗时间或者发数据给客户端的耗时
  1221. #
  1222. # You can configure the slow log with two parameters: one tells Redis
  1223. # what is the execution time, in microseconds, to exceed in order for the
  1224. # command to get logged, and the other parameter is the length of the
  1225. # slow log. When a new command is logged the oldest one is removed from the
  1226. # queue of logged commands.
  1227. # 可以使用"slowlog-log-slower-than"指定耗时的阈值(单位是微妙)，一旦执行超过这个时间就会记录日志到缓冲区
  1228. # 可以使用"slowlog-max-len 128"指定队列长度，如果超过队列，最老的元素会被覆盖
  1229. #
  1230. # The following time is expressed in microseconds, so 1000000 is equivalent
  1231. # to one second. Note that a negative number disables the slow log, while
  1232. # a value of zero forces the logging of every command.
  1233. # 单位是微妙，不能设置为负值，如果设置为0，那么所有的查询命令都会记录到队列中
  1234. # 
  1235. slowlog-log-slower-than 10000
  1236.  
  1237. # There is no limit to this length. Just be aware that it will consume memory.
  1238. # 最大值没有限制，我们只需要考虑内存是否足够大
  1239. # You can reclaim memory used by the slow log with SLOWLOG RESET.
  1240. # 可以使用slowlog reset回收已使用的内存
  1241. slowlog-max-len 128
  1242.  
  1243. ################################ LATENCY MONITOR ##############################
  1244.  
  1245. # The Redis latency monitoring subsystem samples different operations
  1246. # at runtime in order to collect data related to possible sources of
  1247. # latency of a Redis instance.
  1248. # 延迟监控子系统通过采集运行时的不同操作去收集造成Redis实例延迟的相关可能来源
  1249. # 
  1250. #
  1251. # Via the LATENCY command this information is available to the user that can
  1252. # print graphs and obtain reports.
  1253. # 可以通过latency命令获得可用信息的图表，比如latency docter xxx/latency graph等
  1254. #
  1255. # The system only logs operations that were performed in a time equal or
  1256. # greater than the amount of milliseconds specified via the
  1257. # latency-monitor-threshold configuration directive. When its value is set
  1258. # to zero, the latency monitor is turned off.
  1259. # 该监控子系统只会记录那些耗时>="latency-monitor-threshold"指定的值对应的操作，如果设置为0，表示关闭延时监控
  1260. #
  1261. # By default latency monitoring is disabled since it is mostly not needed
  1262. # if you don't have latency issues, and collecting data has a performance
  1263. # impact, that while very small, can be measured under big load. Latency
  1264. # monitoring can easily be enabled at runtime using the command
  1265. # "CONFIG SET latency-monitor-threshold <milliseconds>" if needed.
  1266. # Redis默认是关闭了延迟监控的，因为绝大多数时间是用不着的，因为开启它有一定的性能损失，除非你的服务发生了延时而开启监控
  1267. # 当Redis是运行着的时候，可以通过config set latency-monitor-threshold xxx轻松开启监控
  1268. latency-monitor-threshold 0
  1269.  
  1270. ############################# EVENT NOTIFICATION ##############################
  1271. # 下面的条件说明很多看上去挺复杂的，其实很简单：就是多个字符代表的意思组合到一起而已
  1272. # Redis can notify Pub/Sub clients about events happening in the key space.
  1273. # This feature is documented at http://redis.io/topics/notifications
  1274. # Redis可以将关于"键空间(简单理解为Hash表中的键值对)"发生的事件以通知的形式发送给Pub/Sub客户端
  1275. # 更详细的请参考Redis的官方文档：http://redis.io/topics/notifications
  1276. #
  1277. # For instance if keyspace events notification is enabled, and a client
  1278. # performs a DEL operation on key "foo" stored in the Database 0, two
  1279. # messages will be published via Pub/Sub:
  1280. # 如果通过配置开启了键空间和键时间的通知，如果通过客户端在第0号database上执行一个DEL foo操作，那么会
  1281. # 发布两条消息
  1282. # PUBLISH __keyspace@0__:foo del
  1283. # PUBLISH __keyevent@0__:del foo
  1284. #
  1285. # It is possible to select the events that Redis will notify among a set
  1286. # of classes. Every class is identified by a single character:
  1287. # 我们可以通过组合下面的分类将事件通知发给客户端
  1288. #  "K"和"E"代表两大类，无论怎么组合，必须有其中一个，可以两个同时选择，K代表Keyspace事件，E代表Keyevent事件
  1289. #  K以为着一个或多个数据类型的所有符合规则事件都会生成通知
  1290. #  E以为着一个或多个数据类型的某一个命令的时间会生成通知
  1291. #  如果看到这里还没明白，建议去百度一下，推荐一个：http://redisdoc.com/topic/notification.html#id1
  1292. #  K     Keyspace events, published with __keyspace@<db>__ prefix.
  1293. #  E     Keyevent events, published with __keyevent@<db>__ prefix.
  1294. #
  1295. #  一般的命令，比如DEL SET EXPIRE RENAME等等，感觉像是所有会产生改变的命令都符合条件      
  1296. #  g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
  1297. #
  1298. #  下面的$ l s h z 分别代表大家都知道5种数据类型
  1299. #  $     String commands
  1300. #  l     List commands
  1301. #  s     Set commands
  1302. #  h     Hash commands
  1303. #  z     Sorted set commands
  1304. #
  1305. #  x 代表过期事件  e 代表内存使用超过maxmemory时KEY被淘汰的事件
  1306. #  x     Expired events (events generated every time a key expires)
  1307. #  e     Evicted events (events generated when a key is evicted for maxmemory)
  1308. #
  1309. #  A 是一个别名，代表了"g$lshzxe"的组合，可以增强阅读性
  1310. #  A     Alias for g$lshzxe, so that the "AKE" string means all the events.
  1311. #
  1312. #  The "notify-keyspace-events" takes as argument a string that is composed
  1313. #  of zero or multiple characters. The empty string means that notifications
  1314. #  are disabled.
  1315. #  可以给"notify-keyspace-events"设置0或者多个字符，如果设置为空字符串，则表示关闭此功能
  1316. #
  1317. #  Example: to enable list and generic events, from the point of view of the
  1318. #           event name, use:
  1319. #
  1320. #  notify-keyspace-events Elg
  1321. #
  1322. #  Example 2: to get the stream of the expired keys subscribing to channel
  1323. #             name __keyevent@0__:expired use:
  1324. #
  1325. #  notify-keyspace-events Ex
  1326. #
  1327. #  By default all notifications are disabled because most users don't need
  1328. #  this feature and the feature has some overhead. Note that if you don't
  1329. #  specify at least one of K or E, no events will be delivered.
  1330. #  因为开启此功能是有一定开销的，会影响性能，而且大多数用户不需要此功能，所以默认是关闭了此功能的，不会有事件通知被发送
  1331. notify-keyspace-events ""
  1332.  
  1333. ############################### ADVANCED CONFIG 高级配置 ###############################
  1334. # 下面的配置需要对Redis的原理，特别5中数据类型的底层数据结构有比较清楚的了解才能看得懂，总的来说就是根据自己的键-值选择5中数据类型在某些条件下使用何种数据结构来存放数据。
  1335. # 最常见的高效数据结构就是ziplist、intset,但是他们通常只有元素(条目)较小且元素(条目)较小时才适合
  1336. # 要学习这部分内容可以看看redis设计与实现和Redis资深历险两本书，前一本书将原理很多，且深度足够，但是Redis的版本有点太老了，后一步本书可以在原理上对前一本书进行补充，且Redis版本很新，已经到5了。而且它还将了很多实战的知识。
  1337. #
  1338. # Hashes are encoded using a memory efficient data structure when they have a
  1339. # small number of entries, and the biggest entry does not exceed a given
  1340. # threshold. These thresholds can be configured using the following directives.
  1341. #
  1342. # hash数据类型：如果条目数小于512，且条目大小不超过64字节，则使用ziplist作为hash数据类型的底层数据结构
  1343. hash-max-ziplist-entries 512
  1344. hash-max-ziplist-value 64
  1345.  
  1346. # 新版本的Redis针对list数据类型的底层数据结构做了优化采用的是"链表+ziplist"，其思想有点像Java HashMap的"数组+链表/红黑树"
  1347. # Lists are also encoded in a special way to save a lot of space.
  1348. # The number of entries allowed per internal list node can be specified
  1349. # as a fixed maximum size or a maximum number of elements.
  1350. # 可以通过"list-max-ziplist-size"设置链表中ziplist的条目数量，其值可以是条目数量，也可以最大字节数
  1351. # For a fixed maximum size, use -5 through -1, meaning:
  1352. # 下面是5个可能取值，建议使用-1 和 -2，其他选项不推荐使用，除非有特殊需求
  1353. # -5: max size: 64 Kb  <-- not recommended for normal workloads
  1354. # -4: max size: 32 Kb  <-- not recommended
  1355. # -3: max size: 16 Kb  <-- probably not recommended
  1356. # -2: max size: 8 Kb   <-- good
  1357. # -1: max size: 4 Kb   <-- good
  1358. #
  1359. # Positive numbers mean store up to _exactly_ that number of elements
  1360. # per list node.
  1361. # 上面的负值就是单个链表节点所包含的条目数
  1362. #
  1363. # The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size),
  1364. # but if your use case is unique, adjust the settings as necessary.
  1365. # 取值为-1 -2 发挥的性能是最好的
  1366. list-max-ziplist-size -2
  1367.  
  1368. # Lists may also be compressed.
  1369. # Compress depth is the number of quicklist ziplist nodes from *each* side of
  1370. # the list to *exclude* from compression.  The head and tail of the list
  1371. # are always uncompressed for fast push/pop operations.  Settings are:
  1372. # 0: disable all list compression
  1373. #    表示不压缩任何节点
  1374. # 1: depth 1 means "don't start compressing until after 1 node into the list,
  1375. #    going from either the head or tail"
  1376. #    So: [head]->node->node->...->node->[tail]
  1377. #    [head], [tail] will always be uncompressed; inner nodes will compress.
  1378. #    表示除链表的头尾以外，其他链表节点都压缩
  1379. # 2: [head]->[next]->node->node->...->node->[prev]->[tail]
  1380. #    2 here means: don't compress head or head->next or tail->prev or tail,
  1381. #    but compress all nodes between them.
  1382. #    依次类推，即前两个和后两个以外的都压缩
  1383. # 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]
  1384. #    依次类推
  1385. # etc.
  1386. # 默认压缩深度为0，也就是说不压缩。。。无论如何设置头尾是不会压缩的，比如当list被当做队列使用时，如果压缩了，还需要解压，降低了性能。
  1387. list-compress-depth 0
  1388.  
  1389. # Sets have a special encoding in just one case: when a set is composed
  1390. # of just strings that happen to be integers in radix 10 in the range
  1391. # of 64 bit signed integers.
  1392. # 当集合(set)存放的值都是64位的无符号10进制整数时，且条目数小于512时会采用intset作为集合的底层数据结构
  1393. # The following configuration setting sets the limit in the size of the
  1394. # set in order to use this special memory saving encoding.
  1395. set-max-intset-entries 512
  1396.  
  1397. # 和hash数据类型类似，如果条目数小于128，且条目大小<64会使用ziplist作为有序集合的底层数据结构
  1398. # Similarly to hashes and lists, sorted sets are also specially encoded in
  1399. # order to save a lot of space. This encoding is only used when the length and
  1400. # elements of a sorted set are below the following limits:
  1401. zset-max-ziplist-entries 128
  1402. zset-max-ziplist-value 64
  1403.  
  1404. # HyperLogLog sparse representation bytes limit. The limit includes the
  1405. # 16 bytes header. When an HyperLogLog using the sparse representation crosses
  1406. # this limit, it is converted into the dense representation.
  1407. #
  1408. # A value greater than 16000 is totally useless, since at that point the
  1409. # dense representation is more memory efficient.
  1410. #
  1411. # The suggested value is ~ 3000 in order to have the benefits of
  1412. # the space efficient encoding without slowing down too much PFADD,
  1413. # which is O(N) with the sparse encoding. The value can be raised to
  1414. # ~ 10000 when CPU is not a concern, but space is, and the data set is
  1415. # composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
  1416. # 这个是Redis高级功能，可以用这种数据结构统计网站的UV，能够去重，其准确度接近真实值
  1417. # 简单点说：当去重后统计出来的值小于"hll-sparse-max-bytes"指定的值时，Redis会使用稀疏矩阵来存放，一个Key占用的空间比稠密矩阵小，如果统计出来的值大于"hll-sparse-max-bytes"指定的值，那么使用稠密矩阵，此时一个Key占用的空间是12KB
  1418. # "hll-sparse-max-bytes"默认为3000，如果设置为16000以上完全是无用的，因为此时稠密矩阵效果更好
  1419. hll-sparse-max-bytes 3000
  1420.  
  1421. # Streams macro node max size / items. The stream data structure is a radix
  1422. # tree of big nodes that encode multiple items inside. Using this configuration
  1423. # it is possible to configure how big a single node can be in bytes, and the
  1424. # maximum number of items it may contain before switching to a new node when
  1425. # appending new stream entries. If any of the following settings are set to
  1426. # zero, the limit is ignored, so for instance it is possible to set just a
  1427. # max entires limit by setting max-bytes to 0 and max-entries to the desired
  1428. # value.
  1429. # 设置Stream的单个节点最大字节数和最多能有多少个条目，如果任何一个条件满足就会新增加一个节点用以保存新的数据
  1430. # 如果将任何一个配置项设置为0，表示不限制
  1431. stream-node-max-bytes 4096
  1432. stream-node-max-entries 100
  1433.  
  1434. # Redis数据库存放键值对数据结构是一个类型为字典长度为2的数组,假设这个数组名称为"ht"，在rehash的时候就是将其中一个字典(ht[0])中的所有数据搬到另一个字典(ht[1])中,而且rehash是惰性的(因为redis要高效的响应查询或者写，不可能去一次完成rehash操作，不像Java的HashMap)，当方式key时或者CPU比较空闲时会触发，因此也被称之为"渐进式hash"
  1435. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
  1436. # order to help rehashing the main Redis hash table (the one mapping top-level
  1437. # keys to values). The hash table implementation Redis uses (see dict.c)
  1438. # performs a lazy rehashing: the more operation you run into a hash table
  1439. # that is rehashing, the more rehashing "steps" are performed, so if the
  1440. # server is idle the rehashing is never complete and some more memory is used
  1441. # by the hash table.
  1442. #
  1443. # The default is to use this millisecond 10 times every second in order to
  1444. # actively rehash the main dictionaries, freeing memory when possible.
  1445. # 默认是使用1秒钟的10毫秒进行rehash，在适当的时候回收内存
  1446. #
  1447. # If unsure:
  1448. # use "activerehashing no" if you have hard latency requirements and it is
  1449. # not a good thing in your environment that Redis can reply from time to time
  1450. # to queries with 2 milliseconds delay.
  1451. # 如果系统有严格的延时要求，在2毫秒内不断的查询出结果，可以将"activerehashing"设置no
  1452. # 但是这对你的系统并不是一个好事情，因此不建议这样设置，所以保持不动吧
  1453. #
  1454. # use "activerehashing yes" if you don't have such hard requirements but
  1455. # want to free memory asap when possible.
  1456. # 如果没有非常严格的要求，建议将"activerehashing"设置为yes，这样可以让内存尽可能快的释放
  1457. activerehashing yes
  1458.  
  1459. # The client output buffer limits can be used to force disconnection of clients
  1460. # that are not reading data from the server fast enough for some reason (a
  1461. # common reason is that a Pub/Sub client can't consume messages as fast as the
  1462. # publisher can produce them).
  1463. # 可以通过设置客户端输出缓冲区大小将待接收数据超过缓冲区大小的客户端断开
  1464. # 通常使用pub/sub的时候，客户端没有及时消费而导致超过缓冲区大小
  1465. #
  1466. # The limit can be set differently for the three different classes of clients:
  1467. # 提供三种客户端的设置，分别是普通的、主从复制的、pub/sub的客户端，我们可以分别对这三种客户端的输出缓冲区设置大小
  1468. #
  1469. # normal -> normal clients including MONITOR clients
  1470. # replica  -> replica clients
  1471. # pubsub -> clients subscribed to at least one pubsub channel or pattern
  1472. #
  1473. # The syntax of every client-output-buffer-limit directive is the following:
  1474. # 下面是三种客户端缓冲区大小设置的语法
  1475. # 
  1476. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
  1477. #
  1478. # A client is immediately disconnected once the hard limit is reached, or if
  1479. # the soft limit is reached and remains reached for the specified number of
  1480. # seconds (continuously).
  1481. # 如果客户端输出缓冲区的大小达到了"hard limit"，服务器会立即断开连接
  1482. # 如果客户端输出缓冲区的大小达到了"soft limit"，且持续时间达到了"soft seconds"，服务器会立即断开连接
  1483. #
  1484. # So for instance if the hard limit is 32 megabytes and the soft limit is
  1485. # 16 megabytes / 10 seconds, the client will get disconnected immediately
  1486. # if the size of the output buffers reach 32 megabytes, but will also get
  1487. # disconnected if the client reaches 16 megabytes and continuously overcomes
  1488. # the limit for 10 seconds.
  1489. # 这上面是一个举例，省略。。。。
  1490. #
  1491. # By default normal clients are not limited because they don't receive data
  1492. # without asking (in a push way), but just after a request, so only
  1493. # asynchronous clients may create a scenario where data is requested faster
  1494. # than it can read.
  1495. # 默认情况下普通的client不限制，因为它们都是发起请求后等待接收数据，并不像异步的客户端(比如主从复制客户端和PUB/SUB)会造成数据的挤压，挤压的原因就是客户端处理速度跟不上数据产生的速度
  1496. #
  1497. # Instead there is a default limit for pubsub and replica clients, since
  1498. # subscribers and replicas receive data in a push fashion.
  1499. #
  1500. # Both the hard or the soft limit can be disabled by setting them to zero.
  1501. # hard or soft limit 都可以通过设置为0而禁止掉
  1502. client-output-buffer-limit normal 0 0 0
  1503. client-output-buffer-limit replica 256mb 64mb 60
  1504. client-output-buffer-limit pubsub 32mb 8mb 60
  1505.  
  1506. # Client query buffers accumulate new commands. They are limited to a fixed
  1507. # amount by default in order to avoid that a protocol desynchronization (for
  1508. # instance due to a bug in the client) will lead to unbound memory usage in
  1509. # the query buffer. However you can configure it here if you have very special
  1510. # needs, such us huge multi/exec requests or alike.
  1511. # 客户端查询缓冲区会累加新命令，默认情况下，缓冲区大小是一个固定值以避免协议同步失效(如客户端的bug)导致查询缓冲区出现未绑定的内存(即客户端都已经不存在了，但是它发过来的命令还在缓冲区当中)
  1512. # 如果有巨大的multi/exec请求，则可以修改这个值以满足我们的特殊需求
  1513. # 
  1514. # client-query-buffer-limit 1gb
  1515.  
  1516. # In the Redis protocol, bulk requests, that are, elements representing single
  1517. # strings, are normally limited ot 512 mb. However you can change this limit
  1518. # here.
  1519. # 如果一个大容量请求(即客户端单次发送过来的字符串)被限制为512MB，我们也可以通过修改"proto-max-bulk-len"值
  1520. # 不过我可能一辈子也不会用到
  1521. # proto-max-bulk-len 512mb
  1522.  
  1523. # Redis calls an internal function to perform many background tasks, like
  1524. # closing connections of clients in timeout, purging expired keys that are
  1525. # never requested, and so forth.
  1526. #
  1527. # Not all tasks are performed with the same frequency, but Redis checks for
  1528. # tasks to perform according to the specified "hz" value.
  1529. #
  1530. # By default "hz" is set to 10. Raising the value will use more CPU when
  1531. # Redis is idle, but at the same time will make Redis more responsive when
  1532. # there are many keys expiring at the same time, and timeouts may be
  1533. # handled with more precision.
  1534. #
  1535. # The range is between 1 and 500, however a value over 100 is usually not
  1536. # a good idea. Most users should use the default of 10 and raise this up to
  1537. # 100 only in environments where very low latency is required.
  1538. # 简单点说：Redis有后台任务，通过设置"hz"可提高或者降低检查这些任务是否应该执行的频率，值越大消耗的CPU越多，反之越少
  1539. # 值可以设置在1到500之间，通常不建议将该值设置得比100大，一般都使用10这个默认值，除非我们的系统有非常严格的延时要求，才会将"hz"设置得等于或者超过100
  1540. hz 10
  1541.  
  1542. # Normally it is useful to have an HZ value which is proportional to the
  1543. # number of clients connected. This is useful in order, for instance, to
  1544. # avoid too many clients are processed for each background task invocation
  1545. # in order to avoid latency spikes.
  1546. #
  1547. # Since the default HZ value by default is conservatively set to 10, Redis
  1548. # offers, and enables by default, the ability to use an adaptive HZ value
  1549. # which will temporary raise when there are many connected clients.
  1550. #
  1551. # When dynamic HZ is enabled, the actual configured HZ will be used as
  1552. # as a baseline, but multiples of the configured HZ value will be actually
  1553. # used as needed once more clients are connected. In this way an idle
  1554. # instance will use very little CPU time while a busy instance will be
  1555. # more responsive.
  1556. # 英文有时还真的描述很啰唆，还是中文编码更高效。。。吐槽一下英文
  1557. # 前面的"ht"配置项是固定值，当连接客户端非常多时，如果"ht"还是10，则可能会导致延迟比较高，因此Redis搞了一个
  1558. # "dynamic-hz"配置项，当设置为yes时，可以基于"ht"配置值动态的调整使用的"ht"值，比如连接的客户端很多事，动态将ht调高，可以减少延迟。而当连接客户端比较少，又可以动态降低"ht"，这样消耗的CPU会很少
  1559. # 默认值是yes，这个根本不需要我们自己去动，有了它我们也不需要去动"ht"配置
  1560. dynamic-hz yes
  1561.  
  1562. # When a child rewrites the AOF file, if the following option is enabled
  1563. # the file will be fsync-ed every 32 MB of data generated. This is useful
  1564. # in order to commit the file to the disk more incrementally and avoid
  1565. # big latency spikes.
  1566. # 当子进程在重写AOF文件时，如果将"aof-rewrite-incremental-fsync"设置为yes，那么一旦生成32M数据才会调用一次OS的fsync函数，这样可以降低出现访问峰值时系统的延迟。因为可以减少fsync调用次数和IO请求
  1567. aof-rewrite-incremental-fsync yes
  1568.  
  1569. # When redis saves RDB file, if the following option is enabled
  1570. # the file will be fsync-ed every 32 MB of data generated. This is useful
  1571. # in order to commit the file to the disk more incrementally and avoid
  1572. # big latency spikes.
  1573. # 和"aof-rewrite-incremental-fsync"一个意思，只不过是用在生成RDB文件时用。
  1574. # 如果持久化采用的混合方式，即AOF文件是由"RDB部分+AOF部分"组成的话，我想"aof-rewrite-incremental-fsync"和"rdb-save-incremental-fsync"都会使用到
  1575. rdb-save-incremental-fsync yes
  1576.  
  1577. # Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good
  1578. # idea to start with the default settings and only change them after investigating
  1579. # how to improve the performances and how the keys LFU change over time, which
  1580. # is possible to inspect via the OBJECT FREQ command.
  1581. #
  1582. # There are two tunable parameters in the Redis LFU implementation: the
  1583. # counter logarithm factor and the counter decay time. It is important to
  1584. # understand what the two parameters mean before changing them.
  1585. #
  1586. # Redis的LFU实现有两个可调整的参数：计数器对数因子(couter logarithm factor)和计数器衰退时间(counter decay time)
  1587. # 一定要充分理解这两个参数之后才能去修改，如果不懂就不要去瞎搞了，如果非要修改，一定要使用"OBJECT FREQ"命令充分调查并知道如何提升性能的情况下才能进行
  1588. # The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis
  1589. # uses a probabilistic increment with logarithmic behavior. Given the value
  1590. # of the old counter, when a key is accessed, the counter is incremented in
  1591. # this way:
  1592. # 在介绍maxmemory的时候提到了两个参数作用的原理，这里就不赘述了。
  1593. #
  1594. # 1. A random number R between 0 and 1 is extracted.
  1595. # 2. A probability P is calculated as 1/(old_value*lfu_log_factor+1).
  1596. # 3. The counter is incremented only if R < P.
  1597. #
  1598. # The default lfu-log-factor is 10. This is a table of how the frequency
  1599. # counter changes with a different number of accesses with different
  1600. # logarithmic factors:
  1601. # "lfu-log-factor"的默认值=10,下表是不同对数因子下计数器的改变频率:
  1602. #
  1603. # +--------+------------+------------+------------+------------+------------+
  1604. # | factor | 100 hits   | 1000 hits  | 100K hits  | 1M hits    | 10M hits   |
  1605. # +--------+------------+------------+------------+------------+------------+
  1606. # | 0      | 104        | 255        | 255        | 255        | 255        |
  1607. # +--------+------------+------------+------------+------------+------------+
  1608. # | 1      | 18         | 49         | 255        | 255        | 255        |
  1609. # +--------+------------+------------+------------+------------+------------+
  1610. # | 10     | 10         | 18         | 142        | 255        | 255        |
  1611. # +--------+------------+------------+------------+------------+------------+
  1612. # | 100    | 8          | 11         | 49         | 143        | 255        |
  1613. # +--------+------------+------------+------------+------------+------------+
  1614. #
  1615. # NOTE: The above table was obtained by running the following commands:
  1616. # 上面的表格可以通过下面的命令得到：
  1617. #
  1618. #   redis-benchmark -n 1000000 incr foo
  1619. #   redis-cli object freq foo
  1620. #
  1621. # NOTE 2: The counter initial value is 5 in order to give new objects a chance
  1622. # to accumulate hits.
  1623. # 默认counter的初始值是5，为了让新的对象有机会累加它的命中率
  1624. #
  1625. # The counter decay time is the time, in minutes, that must elapse in order
  1626. # for the key counter to be divided by two (or decremented if it has a value
  1627. # less <= 10).
  1628. # 计数器衰减时间是key计数器除以2(如果值小于<=10，则递减)所必须经过的时间，单位为分钟。
  1629. #
  1630. # The default value for the lfu-decay-time is 1. A Special value of 0 means to
  1631. # decay the counter every time it happens to be scanned.
  1632. # "lfu-decay-time" 的默认值为 1，0 表示每次都对计数器进行衰减
  1633. #
  1634. # lfu-log-factor 10
  1635. # lfu-decay-time 1
  1636.  
  1637. ########################### ACTIVE DEFRAGMENTATION #######################
  1638. ########################### 在线碎片整理 #######################
  1639. #
  1640. # WARNING THIS FEATURE IS EXPERIMENTAL. However it was stress tested
  1641. # even in production and manually tested by multiple engineers for some
  1642. # time.
  1643. # 这还只是一个实验功能，就像Redis Cluster一样，其实已经有很多人在使用了
  1644. # What is active defragmentation?
  1645. # -------------------------------
  1646. #
  1647. # Active (online) defragmentation allows a Redis server to compact the
  1648. # spaces left between small allocations and deallocations of data in memory,
  1649. # thus allowing to reclaim back memory.
  1650. #
  1651. # Fragmentation is a natural process that happens with every allocator (but
  1652. # less so with Jemalloc, fortunately) and certain workloads. Normally a server
  1653. # restart is needed in order to lower the fragmentation, or at least to flush
  1654. # away all the data and create it again. However thanks to this feature
  1655. # implemented by Oran Agra for Redis 4.0 this process can happen at runtime
  1656. # in an "hot" way, while the server is running.
  1657. # 活动碎片整理允许Redis服务器压缩内存中由于申请和释放数据块导致的碎片，从而回收内存，就好像window的磁盘整理一样
  1658. # 碎片是每次申请内存（幸运的是Jemalloc出现碎片的几率小很多）的时候会自然发生的
  1659. # 通常来说，为了降低碎片化程度需要重启服务，或者清除所有的数据然后重新创建。 得益于Oran Agra在Redis 4.0实现的这个特性，进程可以在服务运行时以"热"方式完成
  1660. #
  1661. # Basically when the fragmentation is over a certain level (see the
  1662. # configuration options below) Redis will start to create new copies of the
  1663. # values in contiguous memory regions by exploiting certain specific Jemalloc
  1664. # features (in order to understand if an allocation is causing fragmentation
  1665. # and to allocate it in a better place), and at the same time, will release the
  1666. # old copies of the data. This process, repeated incrementally for all the keys
  1667. # will cause the fragmentation to drop back to normal values.
  1668. # 通常来说当碎片化达到一定程度（查看下面的配置）Redis 会使用Jemalloc创建连续的内存空间，并在此内存空间对现有的值进行拷贝，拷贝完成后会释放掉旧的数据。
  1669. # 这个过程会对所有的导致碎片化的key以增量的形式进行，Redis处处使用渐进式的，真实辛苦设计者了
  1670. #
  1671. # Important things to understand:
  1672. # 要重点理解的三点：
  1673. #
  1674. # 1. This feature is disabled by default, and only works if you compiled Redis
  1675. #    to use the copy of Jemalloc we ship with the source code of Redis.
  1676. #    This is the default with Linux builds.
  1677. #    默认情况下，该功能是关闭的，并且只有在编译Redis时使用了代码中的Jemalloc才生效(这是 Linux 下的默认行为)
  1678. # 2. You never need to enable this feature if you don't have fragmentation
  1679. #    issues.
  1680. #    如果没有碎片问题，我们永远也不需要启用该功能
  1681. #
  1682. # 3. Once you experience fragmentation, you can enable this feature when
  1683. #    needed with the command "CONFIG SET activedefrag yes".
  1684. #    可以通过命令"CONFIG SET activefrag yes"来启用并试验
  1685. #
  1686. # The configuration parameters are able to fine tune the behavior of the
  1687. # defragmentation process. If you are not sure about what they mean it is
  1688. # a good idea to leave the defaults untouched.
  1689. # 相关的配置参数可以很好的调整碎片整理过程，如果你不知道这些选项的作用最好使用默认值。
  1690.  
  1691. # Enabled active defragmentation
  1692. # 开启在线整理
  1693. # activedefrag yes
  1694.  
  1695. # Minimum amount of fragmentation waste to start active defrag
  1696. # 有多少碎片时开始整理
  1697. # active-defrag-ignore-bytes 100mb
  1698.  
  1699. # Minimum percentage of fragmentation to start active defrag
  1700. # 有多少比例的碎片时开始整理
  1701. # active-defrag-threshold-lower 10
  1702.  
  1703. # Maximum percentage of fragmentation at which we use maximum effort
  1704. # 有多少比例的碎片时开始进行整理
  1705. # active-defrag-threshold-upper 100
  1706.  
  1707. # Minimal effort for defrag in CPU percentage
  1708. # 进行碎片整理时使用多少比例的CPU时间
  1709. # active-defrag-cycle-min 5
  1710.  
  1711. # Maximal effort for defrag in CPU percentage
  1712. # 进行整理时使用多少CPU时间
  1713. # active-defrag-cycle-max 75
  1714.  
  1715. # Maximum number of set/hash/zset/list fields that will be processed from
  1716. # the main dictionary scan
  1717. # 进行主字典扫描时处理的 set/hash/zset/list 字段的最大数量(就是说在进行主字典扫描时 set/hash/zset/list 的长度小于这个值才会处理，大于这个值的会放在一个列表中延迟处理)
  1718. # 因为如果某一个key过大，一次性处理完会非常耗时的
  1719. # active-defrag-max-scan-fields 1000
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/976336
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号