Redis 配置文件详解

# Redis 配置文件

# 当配置中需要配置内存大小时，可以使用 1k, 5GB, 4M 等类似的格式，其转换方式如下(不区分大小写)
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# 内存配置大小写是一样的.比如 1gb 1Gb 1GB 1gB

# daemonize no 默认情况下，redis不是在后台运行的，如果需要在后台运行，把该项的值更改为yes
daemonize yes

# 当redis在后台运行的时候，Redis默认会把pid文件放在/var/run/redis.pid，你可以配置到其他地址。
# 当运行多个redis服务时，需要指定不同的pid文件和端口
pidfile /var/run/redis.pid

# 指定redis运行的端口，默认是6379
port 6379

# 指定redis只接收来自于该IP地址的请求，如果不进行设置，那么将处理所有请求，
# 在生产环境中最好设置该项
# bind 127.0.0.1

# Specify the path for the unix socket that will be used to listen for
# incoming connections. There is no default, so Redis will not listen
# on a unix socket when not specified.
#
# unixsocket /tmp/redis.sock
# unixsocketperm 755

# 设置客户端连接时的超时时间，单位为秒。当客户端在这段时间内没有发出任何指令，那么关闭该连接
# 0是关闭此设置
timeout 0

# 指定日志记录级别
# Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose
# debug 记录很多信息，用于开发和测试
# varbose 有用的信息，不像debug会记录那么多
# notice 普通的verbose，常用于生产环境
# warning 只有非常重要或者严重的信息会记录到日志
loglevel debug

# 配置log文件地址
# 默认值为stdout，标准输出，若后台模式会输出到/dev/null
#logfile stdout
logfile /var/log/redis/redis.log

# To enable logging to the system logger, just set 'syslog-enabled' to yes,
# and optionally update the other syslog parameters to suit your needs.
# syslog-enabled no

# Specify the syslog identity.
# syslog-ident redis

# Specify the syslog facility.  Must be USER or between LOCAL0-LOCAL7.
# syslog-facility local0

# 可用数据库数
# 默认值为16，默认数据库为0，数据库范围在0-（database-1）之间
databases 16

################################ 快照  #################################
#
# 保存数据到磁盘，格式如下:
#
#   save <seconds> <changes>
#
#   指出在多长时间内，有多少次更新操作，就将数据同步到数据文件rdb。
#   相当于条件触发抓取快照，这个可以多个条件配合
#    
#   比如默认配置文件中的设置，就设置了三个条件
#
#   save 900 1  900秒内至少有1个key被改变
#   save 300 10  300秒内至少有300个key被改变
#   save 60 10000  60秒内至少有10000个key被改变

save 900 1
save 300 10
save 60 10000

# 存储至本地数据库时（持久化到rdb文件）是否压缩数据，默认为yes
rdbcompression yes

# 本地持久化数据库文件名，默认值为dump.rdb
dbfilename dump.rdb

# 工作目录
#
# 数据库镜像备份的文件放置的路径。
# 这里的路径跟文件名要分开配置是因为redis在进行备份时，先会将当前数据库的状态写入到一个临时文件中，等备份完成时，
# 再把该该临时文件替换为上面所指定的文件，而这里的临时文件和上面所配置的备份文件都会放在这个指定的路径当中。
# 
# AOF文件也会存放在这个目录下面
# 
# 注意这里必须制定一个目录而不是文件
dir ./

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

# 主从复制. 设置该数据库为其他数据库的从数据库. 
# 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步
#
# slaveof <masterip> <masterport>

# 当master服务设置了密码保护时(用requirepass制定的密码)
# slav服务连接master的密码
# 
# masterauth <master-password>

# 当从库同主机失去连接或者复制正在进行，从机库有两种运行方式：
#
# 1) 如果slave-serve-stale-data设置为yes(默认设置)，从库会继续相应客户端的请求
# 
# 2) 如果slave-serve-stale-data是指为no，出去INFO和SLAVOF命令之外的任何请求都会返回一个
#    错误"SYNC with master in progress"
#
slave-serve-stale-data yes

# 从库会按照一个时间间隔向主库发送PINGs.可以通过repl-ping-slave-period设置这个时间间隔，默认是10秒
#
# repl-ping-slave-period 10

# repl-timeout 设置主库批量数据传输时间或者ping回复时间间隔，默认值是60秒
# 一定要确保repl-timeout大于repl-ping-slave-period
# repl-timeout 60

################################## 安全 ###################################

# 设置客户端连接后进行任何其他指定前需要使用的密码。
# 警告：因为redis速度相当快，所以在一台比较好的服务器下，一个外部的用户可以在一秒钟进行150K次的密码尝试，这意味着你需要指定非常非常强大的密码来防止暴力破解
#
# requirepass foobared

# 命令重命名.
#
# 在一个共享环境下可以重命名相对危险的命令。比如把CONFIG重名为一个不容易猜测的字符。
#
# 举例:
#
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
#
# 如果想删除一个命令，直接把它重命名为一个空字符""即可，如下：
#
# rename-command CONFIG ""

################################### 约束 ####################################

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

# 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key
# Redis同时也会移除空的list对象
#
# 当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作
# 
# 注意：Redis新的vm机制，会把Key存放内存，Value会存放在swap区
#
# maxmemory的设置比较适合于把redis当作于类似memcached的缓存来使用，而不适合当做一个真实的DB。
# 当把Redis当做一个真实的数据库使用的时候，内存使用将是一个很大的开销
# maxmemory <bytes>

# 当内存达到最大值的时候Redis会选择删除哪些数据？有五种方式可供选择
# 
# volatile-lru -> 利用LRU算法移除设置过过期时间的key (LRU:最近使用 Least Recently Used )
# allkeys-lru -> 利用LRU算法移除任何key
# volatile-random -> 移除设置过过期时间的随机key
# allkeys->random -> remove a random key, any key 
# volatile-ttl -> 移除即将过期的key(minor TTL)
# noeviction -> 不移除任何可以，只是返回一个写错误
# 
# 注意：对于上面的策略，如果没有合适的key可以移除，当写的时候Redis会返回一个错误
#
#       写命令包括: set setnx setex append
#       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
#       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
#       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
#       getset mset msetnx exec sort
#
# 默认是:
#
# maxmemory-policy volatile-lru

# LRU 和 minimal TTL 算法都不是精准的算法，但是相对精确的算法(为了节省内存)，随意你可以选择样本大小进行检测。
# Redis默认的灰选择3个样本进行检测，你可以通过maxmemory-samples进行设置
#
# maxmemory-samples 3

############################## AOF ###############################

# 默认情况下，redis会在后台异步的把数据库镜像备份到磁盘，但是该备份是非常耗时的，而且备份也不能很频繁，如果发生诸如拉闸限电、拔插头等状况，那么将造成比较大范围的数据丢失。
# 所以redis提供了另外一种更加高效的数据库备份及灾难恢复方式。
# 开启append only模式之后，redis会把所接收到的每一次写操作请求都追加到appendonly.aof文件中，当redis重新启动时，会从该文件恢复出之前的状态。
# 但是这样会造成appendonly.aof文件过大，所以redis还支持了BGREWRITEAOF指令，对appendonly.aof 进行重新整理。
# 你可以同时开启asynchronous dumps 和 AOF

appendonly no

# AOF文件名称 (默认: "appendonly.aof")
# appendfilename appendonly.aof

# Redis支持三种同步AOF文件的策略:
#
# no: 不进行同步，系统去操作 . Faster.
# always: always表示每次有写操作都进行同步. Slow, Safest.
# everysec: 表示对写操作进行累积，每秒同步一次. Compromise.
#
# 默认是"everysec"，按照速度和安全折中这是最好的。
# 如果想让Redis能更高效的运行，你也可以设置为"no"，让操作系统决定什么时候去执行
# 或者相反想让数据更安全你也可以设置为"always"
#
# 如果不确定就用 "everysec".

# appendfsync always
appendfsync everysec
# appendfsync no

# AOF策略设置为always或者everysec时，后台处理进程(后台保存或者AOF日志重写)会执行大量的I/O操作
# 在某些Linux配置中会阻止过长的fsync()请求。注意现在没有任何修复，即使fsync在另外一个线程进行处理
#
# 为了减缓这个问题，可以设置下面这个参数no-appendfsync-on-rewrite
#
# This means that while another child is saving the durability of Redis is
# the same as "appendfsync none", that in pratical terms means that it is
# possible to lost up to 30 seconds of log in the worst scenario (with the
# default Linux settings).
# 
# If you have latency problems turn this to "yes". Otherwise leave it as
# "no" that is the safest pick from the point of view of durability.
no-appendfsync-on-rewrite no

# Automatic rewrite of the append only file.
# AOF 自动重写
# 当AOF文件增长到一定大小的时候Redis能够调用 BGREWRITEAOF 对日志文件进行重写 
# 
# 它是这样工作的：Redis会记住上次进行些日志后文件的大小(如果从开机以来还没进行过重写，那日子大小在开机的时候确定)
#
# 基础大小会同现在的大小进行比较。如果现在的大小比基础大小大制定的百分比，重写功能将启动
# 同时需要指定一个最小大小用于AOF重写，这个用于阻止即使文件很小但是增长幅度很大也去重写AOF文件的情况
# 设置 percentage 为0就关闭这个特性

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

################################## SLOW LOG ###################################

# Redis Slow Log 记录超过特定执行时间的命令。执行时间不包括I/O计算比如连接客户端，返回结果等，只是命令执行时间
# 
# 可以通过两个参数设置slow log：一个是告诉Redis执行超过多少时间被记录的参数slowlog-log-slower-than(微妙)，
# 另一个是slow log 的长度。当一个新命令被记录的时候最早的命令将被从队列中移除

# 下面的时间以微妙微单位，因此1000000代表一分钟。
# 注意制定一个负数将关闭慢日志，而设置为0将强制每个命令都会记录
slowlog-log-slower-than 10000

# 对日志长度没有限制，只是要注意它会消耗内存
# 可以通过 SLOWLOG RESET 回收被慢日志消耗的内存
slowlog-max-len 1024

################################ VM ###############################

### WARNING! Virtual Memory is deprecated in Redis 2.4
### The use of Virtual Memory is strongly discouraged.

# Virtual Memory allows Redis to work with datasets bigger than the actual
# amount of RAM needed to hold the whole dataset in memory.
# In order to do so very used keys are taken in memory while the other keys
# are swapped into a swap file, similarly to what operating systems do
# with memory pages.
#
# To enable VM just set 'vm-enabled' to yes, and set the following three
# VM parameters accordingly to your needs.

vm-enabled no
# vm-enabled yes

# This is the path of the Redis swap file. As you can guess, swap files
# can't be shared by different Redis instances, so make sure to use a swap
# file for every redis process you are running. Redis will complain if the
# swap file is already in use.
#
# The best kind of storage for the Redis swap file (that's accessed at random) 
# is a Solid State Disk (SSD).
#
# *** WARNING *** if you are using a shared hosting the default of putting
# the swap file under /tmp is not secure. Create a dir with access granted
# only to Redis user and configure Redis to create the swap file there.
vm-swap-file /tmp/redis.swap

# vm-max-memory configures the VM to use at max the specified amount of
# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
# is, if there is still enough contiguous space in the swap file.
#
# With vm-max-memory 0 the system will swap everything it can. Not a good
# default, just specify the max amount of RAM you can in bytes, but it's
# better to leave some margin. For instance specify an amount of RAM
# that's more or less between 60 and 80% of your free RAM.
vm-max-memory 0

# Redis swap files is split into pages. An object can be saved using multiple
# contiguous pages, but pages can't be shared between different objects.
# So if your page is too big, small objects swapped out on disk will waste
# a lot of space. If you page is too small, there is less space in the swap
# file (assuming you configured the same number of total swap file pages).
#
# If you use a lot of small objects, use a page size of 64 or 32 bytes.
# If you use a lot of big objects, use a bigger page size.
# If unsure, use the default :)
vm-page-size 32

# Number of total memory pages in the swap file.
# Given that the page table (a bitmap of free/used pages) is taken in memory,
# every 8 pages on disk will consume 1 byte of RAM.
#
# The total swap size is vm-page-size * vm-pages
#
# With the default of 32-bytes memory pages and 134217728 pages Redis will
# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
#
# It's better to use the smallest acceptable value for your application,
# but the default is large in order to work in most conditions.
vm-pages 134217728

# Max number of VM I/O threads running at the same time.
# This threads are used to read/write data from/to swap file, since they
# also encode and decode objects from disk to memory or the reverse, a bigger
# number of threads can help with big objects even if they can't help with
# I/O itself as the physical device may not be able to couple with many
# reads/writes operations at the same time.
#
# The special value of 0 turn off threaded I/O and enables the blocking
# Virtual Memory implementation.
vm-max-threads 4

############################### ADVANCED CONFIG ###############################

# 当hash中包含超过指定元素个数并且最大的元素没有超过临界时，
# hash将以一种特殊的编码方式（大大减少内存使用）来存储，这里可以设置这两个临界值
# Redis Hash对应Value内部实际就是一个HashMap，实际这里会有2种不同实现，
# 这个Hash的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会采用真正的HashMap结构，对应的value redisObject的encoding为zipmap,
# 当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。
hash-max-zipmap-entries 512
hash-max-zipmap-value 64

# list数据类型多少节点以下会采用去指针的紧凑存储格式。
# list数据类型节点值大小小于多少字节会采用紧凑存储格式。
list-max-ziplist-entries 512
list-max-ziplist-value 64

# set数据类型内部数据如果全部是数值型，且包含多少节点以下会采用紧凑格式存储。
set-max-intset-entries 512

# zsort数据类型多少节点以下会采用去指针的紧凑存储格式。
# zsort数据类型节点值大小小于多少字节会采用紧凑存储格式。
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# Redis将在每100毫秒时使用1毫秒的CPU时间来对redis的hash表进行重新hash，可以降低内存的使用
# 
# 当你的使用场景中，有非常严格的实时性需要，不能够接受Redis时不时的对请求有2毫秒的延迟的话，把这项配置为no。
#
# 如果没有这么严格的实时性要求，可以设置为yes，以便能够尽可能快的释放内存
activerehashing yes

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

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

# include /path/to/local.conf
# include /path/to/other.conf

redis.conf 默认配置：

1. # Redis configuration file example
2. # Note on units: when memory size is needed, it is possible to specify
3. # it in the usual form of 1k 5GB 4M and so forth:
4. #
5. # 1k => 1000 bytes
6. # 1kb => 1024 bytes
7. # 1m => 1000000 bytes
8. # 1mb => 1024*1024 bytes
9. # 1g => 1000000000 bytes
10. # 1gb => 1024*1024*1024 bytes
11. #
12. # units are case insensitive so 1GB 1Gb 1gB are all the same.
13. # By default Redis does not run as a daemon. Use 'yes' if you need it.
14. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
15. daemonize no
16. # When running daemonized, Redis writes a pid file in /var/run/redis.pid by
17. # default. You can specify a custom pid file location here.
18. pidfile /var/run/redis.pid
19. # Accept connections on the specified port, default is 6379.
20. # If port 0 is specified Redis will not listen on a TCP socket.
21. port 6379
22. # If you want you can bind a single interface, if the bind option is not
23. # specified all the interfaces will listen for incoming connections.
24. #
25. # bind 127.0.0.1
26. # Specify the path for the unix socket that will be used to listen for
27. # incoming connections. There is no default, so Redis will not listen
28. # on a unix socket when not specified.
29. #
30. # unixsocket /tmp/redis.sock
31. # unixsocketperm 755
32. # Close the connection after a client is idle for N seconds (0 to disable)
33. timeout 0
34. # TCP keepalive.
35. #
36. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
37. # of communication. This is useful for two reasons:
38. #
39. # 1) Detect dead peers.
40. # 2) Take the connection alive from the point of view of network
41. #    equipment in the middle.
42. #
43. # On Linux, the specified value (in seconds) is the period used to send ACKs.
44. # Note that to close the connection the double of the time is needed.
45. # On other kernels the period depends on the kernel configuration.
46. #
47. # A reasonable value for this option is 60 seconds.
48. tcp-keepalive 0
49. # Specify the server verbosity level.
50. # This can be one of:
51. # debug (a lot of information, useful for development/testing)
52. # verbose (many rarely useful info, but not a mess like the debug level)
53. # notice (moderately verbose, what you want in production probably)
54. # warning (only very important / critical messages are logged)
55. loglevel notice
56. # Specify the log file name. Also 'stdout' can be used to force
57. # Redis to log on the standard output. Note that if you use standard
58. # output for logging but daemonize, logs will be sent to /dev/null
59. logfile stdout
60. # To enable logging to the system logger, just set 'syslog-enabled' to yes,
61. # and optionally update the other syslog parameters to suit your needs.
62. # syslog-enabled no
63. # Specify the syslog identity.
64. # syslog-ident redis
65. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
66. # syslog-facility local0
67. # Set the number of databases. The default database is DB 0, you can select
68. # a different one on a per-connection basis using SELECT <dbid> where
69. # dbid is a number between 0 and 'databases'-1
70. databases 16
71. ################################ SNAPSHOTTING  #################################
72. #
73. # Save the DB on disk:
74. #
75. #   save <seconds> <changes>
76. #
77. #   Will save the DB if both the given number of seconds and the given
78. #   number of write operations against the DB occurred.
79. #
80. #   In the example below the behaviour will be to save:
81. #   after 900 sec (15 min) if at least 1 key changed
82. #   after 300 sec (5 min) if at least 10 keys changed
83. #   after 60 sec if at least 10000 keys changed
84. #
85. #   Note: you can disable saving at all commenting all the "save" lines.
86. #
87. #   It is also possible to remove all the previously configured save
88. #   points by adding a save directive with a single empty string argument
89. #   like in the following example:
90. #
91. #   save ""
92. save 900 1
93. save 300 10
94. save 60 10000
95. # By default Redis will stop accepting writes if RDB snapshots are enabled
96. # (at least one save point) and the latest background save failed.
97. # This will make the user aware (in an hard way) that data is not persisting
98. # on disk properly, otherwise chances are that no one will notice and some
99. # distater will happen.
100. #
101. # If the background saving process will start working again Redis will
102. # automatically allow writes again.
103. #
104. # However if you have setup your proper monitoring of the Redis server
105. # and persistence, you may want to disable this feature so that Redis will
106. # continue to work as usually even if there are problems with disk,
107. # permissions, and so forth.
108. stop-writes-on-bgsave-error yes
109. # Compress string objects using LZF when dump .rdb databases?
110. # For default that's set to 'yes' as it's almost always a win.
111. # If you want to save some CPU in the saving child set it to 'no' but
112. # the dataset will likely be bigger if you have compressible values or keys.
113. rdbcompression yes
114. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
115. # This makes the format more resistant to corruption but there is a performance
116. # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
117. # for maximum performances.
118. #
119. # RDB files created with checksum disabled have a checksum of zero that will
120. # tell the loading code to skip the check.
121. rdbchecksum yes
122. # The filename where to dump the DB
123. dbfilename dump.rdb
124. # The working directory.
125. #
126. # The DB will be written inside this directory, with the filename specified
127. # above using the 'dbfilename' configuration directive.
128. #
129. # The Append Only File will also be created inside this directory.
130. #
131. # Note that you must specify a directory here, not a file name.
132. dir ./
133. ################################# REPLICATION #################################
134. # Master-Slave replication. Use slaveof to make a Redis instance a copy of
135. # another Redis server. Note that the configuration is local to the slave
136. # so for example it is possible to configure the slave to save the DB with a
137. # different interval, or to listen to another port, and so on.
138. #
139. # slaveof <masterip> <masterport>
140. # If the master is password protected (using the "requirepass" configuration
141. # directive below) it is possible to tell the slave to authenticate before
142. # starting the replication synchronization process, otherwise the master will
143. # refuse the slave request.
144. #
145. # masterauth <master-password>
146. # When a slave loses its connection with the master, or when the replication
147. # is still in progress, the slave can act in two different ways:
148. #
149. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
150. #    still reply to client requests, possibly with out of date data, or the
151. #    data set may just be empty if this is the first synchronization.
152. #
153. # 2) if slave-serve-stale-data is set to 'no' the slave will reply with
154. #    an error "SYNC with master in progress" to all the kind of commands
155. #    but to INFO and SLAVEOF.
156. #
157. slave-serve-stale-data yes
158. # You can configure a slave instance to accept writes or not. Writing against
159. # a slave instance may be useful to store some ephemeral data (because data
160. # written on a slave will be easily deleted after resync with the master) but
161. # may also cause problems if clients are writing to it because of a
162. # misconfiguration.
163. #
164. # Since Redis 2.6 by default slaves are read-only.
165. #
166. # Note: read only slaves are not designed to be exposed to untrusted clients
167. # on the internet. It's just a protection layer against misuse of the instance.
168. # Still a read only slave exports by default all the administrative commands
169. # such as CONFIG, DEBUG, and so forth. To a limited extend you can improve
170. # security of read only slaves using 'rename-command' to shadow all the
171. # administrative / dangerous commands.
172. slave-read-only yes
173. # Slaves send PINGs to server in a predefined interval. It's possible to change
174. # this interval with the repl_ping_slave_period option. The default value is 10
175. # seconds.
176. #
177. # repl-ping-slave-period 10
178. # The following option sets a timeout for both Bulk transfer I/O timeout and
179. # master data or ping response timeout. The default value is 60 seconds.
180. #
181. # It is important to make sure that this value is greater than the value
182. # specified for repl-ping-slave-period otherwise a timeout will be detected
183. # every time there is low traffic between the master and the slave.
184. #
185. # repl-timeout 60
186. # Disable TCP_NODELAY on the slave socket after SYNC?
187. #
188. # If you select "yes" Redis will use a smaller number of TCP packets and
189. # less bandwidth to send data to slaves. But this can add a delay for
190. # the data to appear on the slave side, up to 40 milliseconds with
191. # Linux kernels using a default configuration.
192. #
193. # If you select "no" the delay for data to appear on the slave side will
194. # be reduced but more bandwidth will be used for replication.
195. #
196. # By default we optimize for low latency, but in very high traffic conditions
197. # or when the master and slaves are many hops away, turning this to "yes" may
198. # be a good idea.
199. repl-disable-tcp-nodelay no
200. # The slave priority is an integer number published by Redis in the INFO output.
201. # It is used by Redis Sentinel in order to select a slave to promote into a
202. # master if the master is no longer working correctly.
203. #
204. # A slave with a low priority number is considered better for promotion, so
205. # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
206. # pick the one wtih priority 10, that is the lowest.
207. #
208. # However a special priority of 0 marks the slave as not able to perform the
209. # role of master, so a slave with priority of 0 will never be selected by
210. # Redis Sentinel for promotion.
211. #
212. # By default the priority is 100.
213. slave-priority 100
214. ################################## SECURITY ###################################
215. # Require clients to issue AUTH <PASSWORD> before processing any other
216. # commands.  This might be useful in environments in which you do not trust
217. # others with access to the host running redis-server.
218. #
219. # This should stay commented out for backward compatibility and because most
220. # people do not need auth (e.g. they run their own servers).
221. #
222. # Warning: since Redis is pretty fast an outside user can try up to
223. # 150k passwords per second against a good box. This means that you should
224. # use a very strong password otherwise it will be very easy to break.
225. #
226. # requirepass foobared
227. # Command renaming.
228. #
229. # It is possible to change the name of dangerous commands in a shared
230. # environment. For instance the CONFIG command may be renamed into something
231. # hard to guess so that it will still be available for internal-use tools
232. # but not available for general clients.
233. #
234. # Example:
235. #
236. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
237. #
238. # It is also possible to completely kill a command by renaming it into
239. # an empty string:
240. #
241. # rename-command CONFIG ""
242. #
243. # Please note that changing the name of commands that are logged into the
244. # AOF file or transmitted to slaves may cause problems.
245. ################################### LIMITS ####################################
246. # Set the max number of connected clients at the same time. By default
247. # this limit is set to 10000 clients, however if the Redis server is not
248. # able to configure the process file limit to allow for the specified limit
249. # the max number of allowed clients is set to the current file limit
250. # minus 32 (as Redis reserves a few file descriptors for internal uses).
251. #
252. # Once the limit is reached Redis will close all the new connections sending
253. # an error 'max number of clients reached'.
254. #
255. # maxclients 10000
256. # Don't use more memory than the specified amount of bytes.
257. # When the memory limit is reached Redis will try to remove keys
258. # accordingly to the eviction policy selected (see maxmemmory-policy).
259. #
260. # If Redis can't remove keys according to the policy, or if the policy is
261. # set to 'noeviction', Redis will start to reply with errors to commands
262. # that would use more memory, like SET, LPUSH, and so on, and will continue
263. # to reply to read-only commands like GET.
264. #
265. # This option is usually useful when using Redis as an LRU cache, or to set
266. # an hard memory limit for an instance (using the 'noeviction' policy).
267. #
268. # WARNING: If you have slaves attached to an instance with maxmemory on,
269. # the size of the output buffers needed to feed the slaves are subtracted
270. # from the used memory count, so that network problems / resyncs will
271. # not trigger a loop where keys are evicted, and in turn the output
272. # buffer of slaves is full with DELs of keys evicted triggering the deletion
273. # of more keys, and so forth until the database is completely emptied.
274. #
275. # In short... if you have slaves attached it is suggested that you set a lower
276. # limit for maxmemory so that there is some free RAM on the system for slave
277. # output buffers (but this is not needed if the policy is 'noeviction').
278. #
279. # maxmemory <bytes>
280. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
281. # is reached. You can select among five behaviors:
282. #
283. # volatile-lru -> remove the key with an expire set using an LRU algorithm
284. # allkeys-lru -> remove any key accordingly to the LRU algorithm
285. # volatile-random -> remove a random key with an expire set
286. # allkeys-random -> remove a random key, any key
287. # volatile-ttl -> remove the key with the nearest expire time (minor TTL)
288. # noeviction -> don't expire at all, just return an error on write operations
289. #
290. # Note: with any of the above policies, Redis will return an error on write
291. #       operations, when there are not suitable keys for eviction.
292. #
293. #       At the date of writing this commands are: set setnx setex append
294. #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
295. #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
296. #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
297. #       getset mset msetnx exec sort
298. #
299. # The default is:
300. #
301. # maxmemory-policy volatile-lru
302. # LRU and minimal TTL algorithms are not precise algorithms but approximated
303. # algorithms (in order to save memory), so you can select as well the sample
304. # size to check. For instance for default Redis will check three keys and
305. # pick the one that was used less recently, you can change the sample size
306. # using the following configuration directive.
307. #
308. # maxmemory-samples 3
309. ############################## APPEND ONLY MODE ###############################
310. # By default Redis asynchronously dumps the dataset on disk. This mode is
311. # good enough in many applications, but an issue with the Redis process or
312. # a power outage may result into a few minutes of writes lost (depending on
313. # the configured save points).
314. #
315. # The Append Only File is an alternative persistence mode that provides
316. # much better durability. For instance using the default data fsync policy
317. # (see later in the config file) Redis can lose just one second of writes in a
318. # dramatic event like a server power outage, or a single write if something
319. # wrong with the Redis process itself happens, but the operating system is
320. # still running correctly.
321. #
322. # AOF and RDB persistence can be enabled at the same time without problems.
323. # If the AOF is enabled on startup Redis will load the AOF, that is the file
324. # with the better durability guarantees.
325. #
326. # Please check http://redis.io/topics/persistence for more information.
327. appendonly no
328. # The name of the append only file (default: "appendonly.aof")
329. # appendfilename appendonly.aof
330. # The fsync() call tells the Operating System to actually write data on disk
331. # instead to wait for more data in the output buffer. Some OS will really flush
332. # data on disk, some other OS will just try to do it ASAP.
333. #
334. # Redis supports three different modes:
335. #
336. # no: don't fsync, just let the OS flush the data when it wants. Faster.
337. # always: fsync after every write to the append only log . Slow, Safest.
338. # everysec: fsync only one time every second. Compromise.
339. #
340. # The default is "everysec", as that's usually the right compromise between
341. # speed and data safety. It's up to you to understand if you can relax this to
342. # "no" that will let the operating system flush the output buffer when
343. # it wants, for better performances (but if you can live with the idea of
344. # some data loss consider the default persistence mode that's snapshotting),
345. # or on the contrary, use "always" that's very slow but a bit safer than
346. # everysec.
347. #
348. # More details please check the following article:
349. # http://antirez.com/post/redis-persistence-demystified.html
350. #
351. # If unsure, use "everysec".
352. # appendfsync always
353. appendfsync everysec
354. # appendfsync no
355. # When the AOF fsync policy is set to always or everysec, and a background
356. # saving process (a background save or AOF log background rewriting) is
357. # performing a lot of I/O against the disk, in some Linux configurations
358. # Redis may block too long on the fsync() call. Note that there is no fix for
359. # this currently, as even performing fsync in a different thread will block
360. # our synchronous write(2) call.
361. #
362. # In order to mitigate this problem it's possible to use the following option
363. # that will prevent fsync() from being called in the main process while a
364. # BGSAVE or BGREWRITEAOF is in progress.
365. #
366. # This means that while another child is saving, the durability of Redis is
367. # the same as "appendfsync none". In practical terms, this means that it is
368. # possible to lose up to 30 seconds of log in the worst scenario (with the
369. # default Linux settings).
370. #
371. # If you have latency problems turn this to "yes". Otherwise leave it as
372. # "no" that is the safest pick from the point of view of durability.
373. no-appendfsync-on-rewrite no
374. # Automatic rewrite of the append only file.
375. # Redis is able to automatically rewrite the log file implicitly calling
376. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
377. #
378. # This is how it works: Redis remembers the size of the AOF file after the
379. # latest rewrite (if no rewrite has happened since the restart, the size of
380. # the AOF at startup is used).
381. #
382. # This base size is compared to the current size. If the current size is
383. # bigger than the specified percentage, the rewrite is triggered. Also
384. # you need to specify a minimal size for the AOF file to be rewritten, this
385. # is useful to avoid rewriting the AOF file even if the percentage increase
386. # is reached but it is still pretty small.
387. #
388. # Specify a percentage of zero in order to disable the automatic AOF
389. # rewrite feature.
390. auto-aof-rewrite-percentage 100
391. auto-aof-rewrite-min-size 64mb
392. ################################ LUA SCRIPTING  ###############################
393. # Max execution time of a Lua script in milliseconds.
394. #
395. # If the maximum execution time is reached Redis will log that a script is
396. # still in execution after the maximum allowed time and will start to
397. # reply to queries with an error.
398. #
399. # When a long running script exceed the maximum execution time only the
400. # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
401. # used to stop a script that did not yet called write commands. The second
402. # is the only way to shut down the server in the case a write commands was
403. # already issue by the script but the user don't want to wait for the natural
404. # termination of the script.
405. #
406. # Set it to 0 or a negative value for unlimited execution without warnings.
407. lua-time-limit 5000
408. ################################## SLOW LOG ###################################
409. # The Redis Slow Log is a system to log queries that exceeded a specified
410. # execution time. The execution time does not include the I/O operations
411. # like talking with the client, sending the reply and so forth,
412. # but just the time needed to actually execute the command (this is the only
413. # stage of command execution where the thread is blocked and can not serve
414. # other requests in the meantime).
415. #
416. # You can configure the slow log with two parameters: one tells Redis
417. # what is the execution time, in microseconds, to exceed in order for the
418. # command to get logged, and the other parameter is the length of the
419. # slow log. When a new command is logged the oldest one is removed from the
420. # queue of logged commands.
421. # The following time is expressed in microseconds, so 1000000 is equivalent
422. # to one second. Note that a negative number disables the slow log, while
423. # a value of zero forces the logging of every command.
424. slowlog-log-slower-than 10000
425. # There is no limit to this length. Just be aware that it will consume memory.
426. # You can reclaim memory used by the slow log with SLOWLOG RESET.
427. slowlog-max-len 128
428. ############################### ADVANCED CONFIG ###############################
429. # Hashes are encoded using a memory efficient data structure when they have a
430. # small number of entries, and the biggest entry does not exceed a given
431. # threshold. These thresholds can be configured using the following directives.
432. hash-max-ziplist-entries 512
433. hash-max-ziplist-value 64
434. # Similarly to hashes, small lists are also encoded in a special way in order
435. # to save a lot of space. The special representation is only used when
436. # you are under the following limits:
437. list-max-ziplist-entries 512
438. list-max-ziplist-value 64
439. # Sets have a special encoding in just one case: when a set is composed
440. # of just strings that happens to be integers in radix 10 in the range
441. # of 64 bit signed integers.
442. # The following configuration setting sets the limit in the size of the
443. # set in order to use this special memory saving encoding.
444. set-max-intset-entries 512
445. # Similarly to hashes and lists, sorted sets are also specially encoded in
446. # order to save a lot of space. This encoding is only used when the length and
447. # elements of a sorted set are below the following limits:
448. zset-max-ziplist-entries 128
449. zset-max-ziplist-value 64
450. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
451. # order to help rehashing the main Redis hash table (the one mapping top-level
452. # keys to values). The hash table implementation Redis uses (see dict.c)
453. # performs a lazy rehashing: the more operation you run into an hash table
454. # that is rehashing, the more rehashing "steps" are performed, so if the
455. # server is idle the rehashing is never complete and some more memory is used
456. # by the hash table.
457. #
458. # The default is to use this millisecond 10 times every second in order to
459. # active rehashing the main dictionaries, freeing memory when possible.
460. #
461. # If unsure:
462. # use "activerehashing no" if you have hard latency requirements and it is
463. # not a good thing in your environment that Redis can reply form time to time
464. # to queries with 2 milliseconds delay.
465. #
466. # use "activerehashing yes" if you don't have such hard requirements but
467. # want to free memory asap when possible.
468. activerehashing yes
469. # The client output buffer limits can be used to force disconnection of clients
470. # that are not reading data from the server fast enough for some reason (a
471. # common reason is that a Pub/Sub client can't consume messages as fast as the
472. # publisher can produce them).
473. #
474. # The limit can be set differently for the three different classes of clients:
475. #
476. # normal -> normal clients
477. # slave  -> slave clients and MONITOR clients
478. # pubsub -> clients subcribed to at least one pubsub channel or pattern
479. #
480. # The syntax of every client-output-buffer-limit directive is the following:
481. #
482. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
483. #
484. # A client is immediately disconnected once the hard limit is reached, or if
485. # the soft limit is reached and remains reached for the specified number of
486. # seconds (continuously).
487. # So for instance if the hard limit is 32 megabytes and the soft limit is
488. # 16 megabytes / 10 seconds, the client will get disconnected immediately
489. # if the size of the output buffers reach 32 megabytes, but will also get
490. # disconnected if the client reaches 16 megabytes and continuously overcomes
491. # the limit for 10 seconds.
492. #
493. # By default normal clients are not limited because they don't receive data
494. # without asking (in a push way), but just after a request, so only
495. # asynchronous clients may create a scenario where data is requested faster
496. # than it can read.
497. #
498. # Instead there is a default limit for pubsub and slave clients, since
499. # subscribers and slaves receive data in a push fashion.
500. #
501. # Both the hard or the soft limit can be disabled by setting them to zero.
502. client-output-buffer-limit normal 0 0 0
503. client-output-buffer-limit slave 256mb 64mb 60
504. client-output-buffer-limit pubsub 32mb 8mb 60
505. # Redis calls an internal function to perform many background tasks, like
506. # closing connections of clients in timeot, purging expired keys that are
507. # never requested, and so forth.
508. #
509. # Not all tasks are perforemd with the same frequency, but Redis checks for
510. # tasks to perform accordingly to the specified "hz" value.
511. #
512. # By default "hz" is set to 10. Raising the value will use more CPU when
513. # Redis is idle, but at the same time will make Redis more responsive when
514. # there are many keys expiring at the same time, and timeouts may be
515. # handled with more precision.
516. #
517. # The range is between 1 and 500, however a value over 100 is usually not
518. # a good idea. Most users should use the default of 10 and raise this up to
519. # 100 only in environments where very low latency is required.
520. hz 10
521. # When a child rewrites the AOF file, if the following option is enabled
522. # the file will be fsync-ed every 32 MB of data generated. This is useful
523. # in order to commit the file to the disk more incrementally and avoid
524. # big latency spikes.
525. aof-rewrite-incremental-fsync yes
526. ################################## INCLUDES ###################################
527. # Include one or more other config files here.  This is useful if you
528. # have a standard template that goes to all Redis server but also need
529. # to customize a few per-server settings.  Include files can include
530. # other files, so use this wisely.
531. #
532. # include /path/to/local.conf
533. # include /path/to/other.conf