redis配置文件详解

2re

# 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 plaincopyprint?

• # Redis configuration file example
  
• 
  
• # Note on units: when memory size is needed, it is possible to specify
  
• # it in the usual form of 1k 5GB 4M and so forth:
  
• #
  
• # 1k => 1000 bytes
  
• # 1kb => 1024 bytes
  
• # 1m => 1000000 bytes
  
• # 1mb => 1024*1024 bytes
  
• # 1g => 1000000000 bytes
  
• # 1gb => 1024*1024*1024 bytes
  
• #
  
• # units are case insensitive so 1GB 1Gb 1gB are all the same.
  
• 
  
• # By default Redis does not run as a daemon. Use 'yes' if you need it.
  
• # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
  
• daemonize no
  
• 
  
• # When running daemonized, Redis writes a pid file in /var/run/redis.pid by
  
• # default. You can specify a custom pid file location here.
  
• pidfile /var/run/redis.pid
  
• 
  
• # Accept connections on the specified port, default is 6379.
  
• # If port 0 is specified Redis will not listen on a TCP socket.
  
• port 6379
  
• 
  
• # If you want you can bind a single interface, if the bind option is not
  
• # specified all the interfaces will listen for incoming connections.
  
• #
  
• # 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
  
• 
  
• # Close the connection after a client is idle for N seconds (0 to disable)
  
• timeout 0
  
• 
  
• # TCP keepalive.
  
• #
  
• # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
  
• # of communication. This is useful for two reasons:
  
• #
  
• # 1) Detect dead peers.
  
• # 2) Take the connection alive from the point of view of network
  
• #    equipment in the middle.
  
• #
  
• # On Linux, the specified value (in seconds) is the period used to send ACKs.
  
• # Note that to close the connection the double of the time is needed.
  
• # On other kernels the period depends on the kernel configuration.
  
• #
  
• # A reasonable value for this option is 60 seconds.
  
• tcp-keepalive 0
  
• 
  
• # Specify the server verbosity level.
  
• # This can be one of:
  
• # debug (a lot of information, useful for development/testing)
  
• # verbose (many rarely useful info, but not a mess like the debug level)
  
• # notice (moderately verbose, what you want in production probably)
  
• # warning (only very important / critical messages are logged)
  
• loglevel notice
  
• 
  
• # Specify the log file name. Also 'stdout' can be used to force
  
• # Redis to log on the standard output. Note that if you use standard
  
• # output for logging but daemonize, logs will be sent to /dev/null
  
• logfile stdout
  
• 
  
• # 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
  
• 
  
• # Set the number of databases. The default database is DB 0, you can select
  
• # a different one on a per-connection basis using SELECT <dbid> where
  
• # dbid is a number between 0 and 'databases'-1
  
• databases 16
  
• 
  
• ################################ SNAPSHOTTING  #################################
  
• #
  
• # Save the DB on disk:
  
• #
  
• #   save <seconds> <changes>
  
• #
  
• #   Will save the DB if both the given number of seconds and the given
  
• #   number of write operations against the DB occurred.
  
• #
  
• #   In the example below the behaviour will be to save:
  
• #   after 900 sec (15 min) if at least 1 key changed
  
• #   after 300 sec (5 min) if at least 10 keys changed
  
• #   after 60 sec if at least 10000 keys changed
  
• #
  
• #   Note: you can disable saving at all commenting all the "save" lines.
  
• #
  
• #   It is also possible to remove all the previously configured save
  
• #   points by adding a save directive with a single empty string argument
  
• #   like in the following example:
  
• #
  
• #   save ""
  
• 
  
• save 900 1
  
• save 300 10
  
• save 60 10000
  
• 
  
• # By default Redis will stop accepting writes if RDB snapshots are enabled
  
• # (at least one save point) and the latest background save failed.
  
• # This will make the user aware (in an hard way) that data is not persisting
  
• # on disk properly, otherwise chances are that no one will notice and some
  
• # distater will happen.
  
• #
  
• # If the background saving process will start working again Redis will
  
• # automatically allow writes again.
  
• #
  
• # However if you have setup your proper monitoring of the Redis server
  
• # and persistence, you may want to disable this feature so that Redis will
  
• # continue to work as usually even if there are problems with disk,
  
• # permissions, and so forth.
  
• stop-writes-on-bgsave-error yes
  
• 
  
• # Compress string objects using LZF when dump .rdb databases?
  
• # For default that's set to 'yes' as it's almost always a win.
  
• # If you want to save some CPU in the saving child set it to 'no' but
  
• # the dataset will likely be bigger if you have compressible values or keys.
  
• rdbcompression yes
  
• 
  
• # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  
• # This makes the format more resistant to corruption but there is a performance
  
• # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
  
• # for maximum performances.
  
• #
  
• # RDB files created with checksum disabled have a checksum of zero that will
  
• # tell the loading code to skip the check.
  
• rdbchecksum yes
  
• 
  
• # The filename where to dump the DB
  
• dbfilename dump.rdb
  
• 
  
• # The working directory.
  
• #
  
• # The DB will be written inside this directory, with the filename specified
  
• # above using the 'dbfilename' configuration directive.
  
• #  
  
• # The Append Only File will also be created inside this directory.
  
• #  
  
• # Note that you must specify a directory here, not a file name.
  
• dir ./
  
• 
  
• ################################# REPLICATION #################################
  
• 
  
• # Master-Slave replication. Use slaveof to make a Redis instance a copy of
  
• # another Redis server. Note that the configuration is local to the slave
  
• # so for example it is possible to configure the slave to save the DB with a
  
• # different interval, or to listen to another port, and so on.
  
• #
  
• # slaveof <masterip> <masterport>
  
• 
  
• # If the master is password protected (using the "requirepass" configuration
  
• # directive below) it is possible to tell the slave to authenticate before
  
• # starting the replication synchronization process, otherwise the master will
  
• # refuse the slave request.
  
• #
  
• # masterauth <master-password>
  
• 
  
• # When a slave loses its connection with the master, or when the replication
  
• # is still in progress, the slave can act in two different ways:
  
• #
  
• # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
  
• #    still reply to client requests, possibly with out of date data, or the
  
• #    data set may just be empty if this is the first synchronization.
  
• #
  
• # 2) if slave-serve-stale-data is set to 'no' the slave will reply with
  
• #    an error "SYNC with master in progress" to all the kind of commands
  
• #    but to INFO and SLAVEOF.
  
• #
  
• slave-serve-stale-data yes
  
• 
  
• # You can configure a slave instance to accept writes or not. Writing against
  
• # a slave instance may be useful to store some ephemeral data (because data
  
• # written on a slave will be easily deleted after resync with the master) but
  
• # may also cause problems if clients are writing to it because of a
  
• # misconfiguration.
  
• #
  
• # Since Redis 2.6 by default slaves are read-only.
  
• #
  
• # Note: read only slaves are not designed to be exposed to untrusted clients
  
• # on the internet. It's just a protection layer against misuse of the instance.
  
• # Still a read only slave exports by default all the administrative commands
  
• # such as CONFIG, DEBUG, and so forth. To a limited extend you can improve
  
• # security of read only slaves using 'rename-command' to shadow all the
  
• # administrative / dangerous commands.
  
• slave-read-only yes
  
• 
  
• # Slaves send PINGs to server in a predefined interval. It's possible to change
  
• # this interval with the repl_ping_slave_period option. The default value is 10
  
• # seconds.
  
• #
  
• # repl-ping-slave-period 10
  
• 
  
• # The following option sets a timeout for both Bulk transfer I/O timeout and
  
• # master data or ping response timeout. The default value is 60 seconds.
  
• #
  
• # It is important to make sure that this value is greater than the value
  
• # specified for repl-ping-slave-period otherwise a timeout will be detected
  
• # every time there is low traffic between the master and the slave.
  
• #
  
• # repl-timeout 60
  
• 
  
• # Disable TCP_NODELAY on the slave socket after SYNC?
  
• #
  
• # If you select "yes" Redis will use a smaller number of TCP packets and
  
• # less bandwidth to send data to slaves. But this can add a delay for
  
• # the data to appear on the slave side, up to 40 milliseconds with
  
• # Linux kernels using a default configuration.
  
• #
  
• # If you select "no" the delay for data to appear on the slave side will
  
• # be reduced but more bandwidth will be used for replication.
  
• #
  
• # By default we optimize for low latency, but in very high traffic conditions
  
• # or when the master and slaves are many hops away, turning this to "yes" may
  
• # be a good idea.
  
• repl-disable-tcp-nodelay no
  
• 
  
• # The slave priority is an integer number published by Redis in the INFO output.
  
• # It is used by Redis Sentinel in order to select a slave to promote into a
  
• # master if the master is no longer working correctly.
  
• #
  
• # A slave with a low priority number is considered better for promotion, so
  
• # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
  
• # pick the one wtih priority 10, that is the lowest.
  
• #
  
• # However a special priority of 0 marks the slave as not able to perform the
  
• # role of master, so a slave with priority of 0 will never be selected by
  
• # Redis Sentinel for promotion.
  
• #
  
• # By default the priority is 100.
  
• slave-priority 100
  
• 
  
• ################################## SECURITY ###################################
  
• 
  
• # Require clients to issue AUTH <PASSWORD> before processing any other
  
• # commands.  This might be useful in environments in which you do not trust
  
• # others with access to the host running redis-server.
  
• #
  
• # This should stay commented out for backward compatibility and because most
  
• # people do not need auth (e.g. they run their own servers).
  
• #  
  
• # Warning: since Redis is pretty fast an outside user can try up to
  
• # 150k passwords per second against a good box. This means that you should
  
• # use a very strong password otherwise it will be very easy to break.
  
• #
  
• # requirepass foobared
  
• 
  
• # Command renaming.
  
• #
  
• # It is possible to change the name of dangerous commands in a shared
  
• # environment. For instance the CONFIG command may be renamed into something
  
• # hard to guess so that it will still be available for internal-use tools
  
• # but not available for general clients.
  
• #
  
• # Example:
  
• #
  
• # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  
• #
  
• # It is also possible to completely kill a command by renaming it into
  
• # an empty string:
  
• #
  
• # rename-command CONFIG ""
  
• #
  
• # Please note that changing the name of commands that are logged into the
  
• # AOF file or transmitted to slaves may cause problems.
  
• 
  
• ################################### LIMITS ####################################
  
• 
  
• # Set the max number of connected clients at the same time. By default
  
• # this limit is set to 10000 clients, however if the Redis server is not
  
• # able to configure the process file limit to allow for the specified limit
  
• # the max number of allowed clients is set to the current file limit
  
• # minus 32 (as Redis reserves a few file descriptors for internal uses).
  
• #
  
• # Once the limit is reached Redis will close all the new connections sending
  
• # an error 'max number of clients reached'.
  
• #
  
• # maxclients 10000
  
• 
  
• # Don't use more memory than the specified amount of bytes.
  
• # When the memory limit is reached Redis will try to remove keys
  
• # accordingly to the eviction policy selected (see maxmemmory-policy).
  
• #
  
• # If Redis can't remove keys according to the policy, or if the policy is
  
• # set to 'noeviction', Redis will start to reply with errors to commands
  
• # that would use more memory, like SET, LPUSH, and so on, and will continue
  
• # to reply to read-only commands like GET.
  
• #
  
• # This option is usually useful when using Redis as an LRU cache, or to set
  
• # an hard memory limit for an instance (using the 'noeviction' policy).
  
• #
  
• # WARNING: If you have slaves attached to an instance with maxmemory on,
  
• # the size of the output buffers needed to feed the slaves are subtracted
  
• # from the used memory count, so that network problems / resyncs will
  
• # not trigger a loop where keys are evicted, and in turn the output
  
• # buffer of slaves is full with DELs of keys evicted triggering the deletion
  
• # of more keys, and so forth until the database is completely emptied.
  
• #
  
• # In short... if you have slaves attached it is suggested that you set a lower
  
• # limit for maxmemory so that there is some free RAM on the system for slave
  
• # output buffers (but this is not needed if the policy is 'noeviction').
  
• #
  
• # maxmemory <bytes>
  
• 
  
• # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
  
• # is reached. You can select among five behaviors:
  
• #  
  
• # volatile-lru -> remove the key with an expire set using an LRU algorithm
  
• # allkeys-lru -> remove any key accordingly to the LRU algorithm
  
• # volatile-random -> remove a random key with an expire set
  
• # allkeys-random -> remove a random key, any key
  
• # volatile-ttl -> remove the key with the nearest expire time (minor TTL)
  
• # noeviction -> don't expire at all, just return an error on write operations
  
• #  
  
• # Note: with any of the above policies, Redis will return an error on write
  
• #       operations, when there are not suitable keys for eviction.
  
• #
  
• #       At the date of writing this commands are: 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
  
• #
  
• # The default is:
  
• #
  
• # maxmemory-policy volatile-lru
  
• 
  
• # LRU and minimal TTL algorithms are not precise algorithms but approximated
  
• # algorithms (in order to save memory), so you can select as well the sample
  
• # size to check. For instance for default Redis will check three keys and
  
• # pick the one that was used less recently, you can change the sample size
  
• # using the following configuration directive.
  
• #
  
• # maxmemory-samples 3
  
• 
  
• ############################## APPEND ONLY MODE ###############################
  
• 
  
• # By default Redis asynchronously dumps the dataset on disk. This mode is
  
• # good enough in many applications, but an issue with the Redis process or
  
• # a power outage may result into a few minutes of writes lost (depending on
  
• # the configured save points).
  
• #
  
• # The Append Only File is an alternative persistence mode that provides
  
• # much better durability. For instance using the default data fsync policy
  
• # (see later in the config file) Redis can lose just one second of writes in a
  
• # dramatic event like a server power outage, or a single write if something
  
• # wrong with the Redis process itself happens, but the operating system is
  
• # still running correctly.
  
• #
  
• # AOF and RDB persistence can be enabled at the same time without problems.
  
• # If the AOF is enabled on startup Redis will load the AOF, that is the file
  
• # with the better durability guarantees.
  
• #
  
• # Please check http://redis.io/topics/persistence for more information.
  
• 
  
• appendonly no
  
• 
  
• # The name of the append only file (default: "appendonly.aof")
  
• # appendfilename appendonly.aof
  
• 
  
• # The fsync() call tells the Operating System to actually write data on disk
  
• # instead to wait for more data in the output buffer. Some OS will really flush  
  
• # data on disk, some other OS will just try to do it ASAP.
  
• #
  
• # Redis supports three different modes:
  
• #
  
• # no: don't fsync, just let the OS flush the data when it wants. Faster.
  
• # always: fsync after every write to the append only log . Slow, Safest.
  
• # everysec: fsync only one time every second. Compromise.
  
• #
  
• # The default is "everysec", as that's usually the right compromise between
  
• # speed and data safety. It's up to you to understand if you can relax this to
  
• # "no" that will let the operating system flush the output buffer when
  
• # it wants, for better performances (but if you can live with the idea of
  
• # some data loss consider the default persistence mode that's snapshotting),
  
• # or on the contrary, use "always" that's very slow but a bit safer than
  
• # everysec.
  
• #
  
• # More details please check the following article:
  
• # http://antirez.com/post/redis-persistence-demystified.html
  
• #
  
• # If unsure, use "everysec".
  
• 
  
• # appendfsync always
  
• appendfsync everysec
  
• # appendfsync no
  
• 
  
• # When the AOF fsync policy is set to always or everysec, and a background
  
• # saving process (a background save or AOF log background rewriting) is
  
• # performing a lot of I/O against the disk, in some Linux configurations
  
• # Redis may block too long on the fsync() call. Note that there is no fix for
  
• # this currently, as even performing fsync in a different thread will block
  
• # our synchronous write(2) call.
  
• #
  
• # In order to mitigate this problem it's possible to use the following option
  
• # that will prevent fsync() from being called in the main process while a
  
• # BGSAVE or BGREWRITEAOF is in progress.
  
• #
  
• # This means that while another child is saving, the durability of Redis is
  
• # the same as "appendfsync none". In practical terms, this means that it is
  
• # possible to lose 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.
  
• # Redis is able to automatically rewrite the log file implicitly calling
  
• # BGREWRITEAOF when the AOF log size grows by the specified percentage.
  
• #  
  
• # This is how it works: Redis remembers the size of the AOF file after the
  
• # latest rewrite (if no rewrite has happened since the restart, the size of
  
• # the AOF at startup is used).
  
• #
  
• # This base size is compared to the current size. If the current size is
  
• # bigger than the specified percentage, the rewrite is triggered. Also
  
• # you need to specify a minimal size for the AOF file to be rewritten, this
  
• # is useful to avoid rewriting the AOF file even if the percentage increase
  
• # is reached but it is still pretty small.
  
• #
  
• # Specify a percentage of zero in order to disable the automatic AOF
  
• # rewrite feature.
  
• 
  
• auto-aof-rewrite-percentage 100
  
• auto-aof-rewrite-min-size 64mb
  
• 
  
• ################################ LUA SCRIPTING  ###############################
  
• 
  
• # Max execution time of a Lua script in milliseconds.
  
• #
  
• # If the maximum execution time is reached Redis will log that a script is
  
• # still in execution after the maximum allowed time and will start to
  
• # reply to queries with an error.
  
• #
  
• # When a long running script exceed the maximum execution time only the
  
• # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
  
• # used to stop a script that did not yet called write commands. The second
  
• # is the only way to shut down the server in the case a write commands was
  
• # already issue by the script but the user don't want to wait for the natural
  
• # termination of the script.
  
• #
  
• # Set it to 0 or a negative value for unlimited execution without warnings.
  
• lua-time-limit 5000
  
• 
  
• ################################## SLOW LOG ###################################
  
• 
  
• # The Redis Slow Log is a system to log queries that exceeded a specified
  
• # execution time. The execution time does not include the I/O operations
  
• # like talking with the client, sending the reply and so forth,
  
• # but just the time needed to actually execute the command (this is the only
  
• # stage of command execution where the thread is blocked and can not serve
  
• # other requests in the meantime).
  
• #  
  
• # You can configure the slow log with two parameters: one tells Redis
  
• # what is the execution time, in microseconds, to exceed in order for the
  
• # command to get logged, and the other parameter is the length of the
  
• # slow log. When a new command is logged the oldest one is removed from the
  
• # queue of logged commands.
  
• 
  
• # The following time is expressed in microseconds, so 1000000 is equivalent
  
• # to one second. Note that a negative number disables the slow log, while
  
• # a value of zero forces the logging of every command.
  
• slowlog-log-slower-than 10000
  
• 
  
• # There is no limit to this length. Just be aware that it will consume memory.
  
• # You can reclaim memory used by the slow log with SLOWLOG RESET.
  
• slowlog-max-len 128
  
• 
  
• ############################### ADVANCED CONFIG ###############################
  
• 
  
• # Hashes are encoded using a memory efficient data structure when they have a
  
• # small number of entries, and the biggest entry does not exceed a given
  
• # threshold. These thresholds can be configured using the following directives.
  
• hash-max-ziplist-entries 512
  
• hash-max-ziplist-value 64
  
• 
  
• # Similarly to hashes, small lists are also encoded in a special way in order
  
• # to save a lot of space. The special representation is only used when
  
• # you are under the following limits:
  
• list-max-ziplist-entries 512
  
• list-max-ziplist-value 64
  
• 
  
• # Sets have a special encoding in just one case: when a set is composed
  
• # of just strings that happens to be integers in radix 10 in the range
  
• # of 64 bit signed integers.
  
• # The following configuration setting sets the limit in the size of the
  
• # set in order to use this special memory saving encoding.
  
• set-max-intset-entries 512
  
• 
  
• # Similarly to hashes and lists, sorted sets are also specially encoded in
  
• # order to save a lot of space. This encoding is only used when the length and
  
• # elements of a sorted set are below the following limits:
  
• zset-max-ziplist-entries 128
  
• zset-max-ziplist-value 64
  
• 
  
• # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
  
• # order to help rehashing the main Redis hash table (the one mapping top-level
  
• # keys to values). The hash table implementation Redis uses (see dict.c)
  
• # performs a lazy rehashing: the more operation you run into an hash table
  
• # that is rehashing, the more rehashing "steps" are performed, so if the
  
• # server is idle the rehashing is never complete and some more memory is used
  
• # by the hash table.
  
• #  
  
• # The default is to use this millisecond 10 times every second in order to
  
• # active rehashing the main dictionaries, freeing memory when possible.
  
• #
  
• # If unsure:
  
• # use "activerehashing no" if you have hard latency requirements and it is
  
• # not a good thing in your environment that Redis can reply form time to time
  
• # to queries with 2 milliseconds delay.
  
• #
  
• # use "activerehashing yes" if you don't have such hard requirements but
  
• # want to free memory asap when possible.
  
• activerehashing yes
  
• 
  
• # The client output buffer limits can be used to force disconnection of clients
  
• # that are not reading data from the server fast enough for some reason (a
  
• # common reason is that a Pub/Sub client can't consume messages as fast as the
  
• # publisher can produce them).
  
• #
  
• # The limit can be set differently for the three different classes of clients:
  
• #
  
• # normal -> normal clients
  
• # slave  -> slave clients and MONITOR clients
  
• # pubsub -> clients subcribed to at least one pubsub channel or pattern
  
• #
  
• # The syntax of every client-output-buffer-limit directive is the following:
  
• #
  
• # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
  
• #
  
• # A client is immediately disconnected once the hard limit is reached, or if
  
• # the soft limit is reached and remains reached for the specified number of
  
• # seconds (continuously).
  
• # So for instance if the hard limit is 32 megabytes and the soft limit is
  
• # 16 megabytes / 10 seconds, the client will get disconnected immediately
  
• # if the size of the output buffers reach 32 megabytes, but will also get
  
• # disconnected if the client reaches 16 megabytes and continuously overcomes
  
• # the limit for 10 seconds.
  
• #
  
• # By default normal clients are not limited because they don't receive data
  
• # without asking (in a push way), but just after a request, so only
  
• # asynchronous clients may create a scenario where data is requested faster
  
• # than it can read.
  
• #
  
• # Instead there is a default limit for pubsub and slave clients, since
  
• # subscribers and slaves receive data in a push fashion.
  
• #
  
• # Both the hard or the soft limit can be disabled by setting them to zero.
  
• client-output-buffer-limit normal 0 0 0
  
• client-output-buffer-limit slave 256mb 64mb 60
  
• client-output-buffer-limit pubsub 32mb 8mb 60
  
• 
  
• # Redis calls an internal function to perform many background tasks, like
  
• # closing connections of clients in timeot, purging expired keys that are
  
• # never requested, and so forth.
  
• #
  
• # Not all tasks are perforemd with the same frequency, but Redis checks for
  
• # tasks to perform accordingly to the specified "hz" value.
  
• #
  
• # By default "hz" is set to 10. Raising the value will use more CPU when
  
• # Redis is idle, but at the same time will make Redis more responsive when
  
• # there are many keys expiring at the same time, and timeouts may be
  
• # handled with more precision.
  
• #
  
• # The range is between 1 and 500, however a value over 100 is usually not
  
• # a good idea. Most users should use the default of 10 and raise this up to
  
• # 100 only in environments where very low latency is required.
  
• hz 10
  
• 
  
• # When a child rewrites the AOF file, if the following option is enabled
  
• # the file will be fsync-ed every 32 MB of data generated. This is useful
  
• # in order to commit the file to the disk more incrementally and avoid
  
• # big latency spikes.
  
• aof-rewrite-incremental-fsync yes
  
• 
  
• ################################## INCLUDES ###################################
  
• 
  
• # Include one or more other config files here.  This is useful if you
  
• # have a standard template that goes to all Redis server but also need
  
• # to customize a few per-server settings.  Include files can include
  
• # other files, so use this wisely.
  
• #
  
• # include /path/to/local.conf
  
• # include /path/to/other.conf