redis的配置文件redis.conf常见配置

一时失言乱红尘 2022-08-13 00:48 169阅读 0赞

\# 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 默认配置：**

**\[python\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

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

[view plain]: http://blog.csdn.net/ithomer/article/details/9232891#