首页 > 代码库 > Redis 配置文件详解

Redis 配置文件详解

2024-07-27 12:52:20   233人阅读

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

Redis 配置文件详解


联系
我们