注意不同版本之間有一點點區別，如日志級別# 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## 單位是不區分大小寫的，你寫 1K 5GB 4M 也行 ################################## INCLUDES ################################### # 假如說你有一個可用于所有的 redis server 的標準配置模板，# 但針對某些 server 又需要一些個性化的設置，# 你可以使用 include 來包含一些其他的配置文件，這對你來說是非常有用的。## 但是要注意哦，include 是不能被 config rewrite 命令改寫的# 由于 redis 總是以最后的加工線作為一個配置指令值，所以你最好是把 include 放在這個文件的最前面，# 以避免在運行時覆蓋配置的改變，相反，你就把它放在后面（外國人真啰嗦）。## include /path/to/local.conf# include /path/to/other.conf ################################ 常用 ##################################### # 默認情況下 redis 不是作為守護進程運行的，如果你想讓它在后臺運行，你就把它改成 yes。# 當redis作為守護進程運行的時候，它會寫一個 pid 到 /var/run/redis.pid 文件里面。daemonize no # 當redis作為守護進程運行的時候，它會把 pid 默認寫到 /var/run/redis.pid 文件里面，# 但是你可以在這里自己制定它的文件位置。pidfile /var/run/redis.pid # 監聽端口號，默認為 6379，如果你設為 0 ，redis 將不在 socket 上監聽任何客戶端連接。port 6379 # TCP 監聽的最大容納數量## 在高并發的環境下，你需要把這個值調高以避免客戶端連接緩慢的問題。# linux 內核會一聲不響的把這個值縮小成 /PRoc/sys/net/core/somaxconn 對應的值，# 所以你要修改這兩個值才能達到你的預期。tcp-backlog 511 # 默認情況下，redis 在 server 上所有有效的網絡接口上監聽客戶端連接。# 你如果只想讓它在一個網絡接口上監聽，那你就綁定一個ip或者多個IP。## 示例，多個IP用空格隔開:## bind 192.168.1.100 10.0.0.1# bind 127.0.0.1 # 指定 unix socket 的路徑。## unixsocket /tmp/redis.sock# unixsocketperm 755 # 指定在一個 client 空閑多少秒之后關閉連接（0 就是不管它）timeout 0 # tcp 心跳包。## 如果設置為非零，則在與客戶端缺乏通訊的時候使用 SO_KEEPALIVE 發送 tcp acks 給客戶端。# 這個之所有有用，主要由兩個原因：## 1) 防止死的 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.# 推薦一個合理的值就是60秒tcp-keepalive 0 # 定義日志級別。# 可以是下面的這些值：# debug (適用于開發或測試階段)# verbose (many rarely useful info, but not a mess like the debug level)# notice (適用于生產環境)# warning (僅僅一些重要的消息被記錄)loglevel notice # 指定日志文件的位置logfile "" # 要想把日志記錄到系統日志，就把它改成 yes，# 也可以可選擇性的更新其他的syslog 參數以達到你的要求# syslog-enabled no # 設置 syslog 的 identity。# syslog-ident redis # 設置 syslog 的 facility，必須是 USER 或者是 LOCAL0-LOCAL7 之間的值。# syslog-facility local0 # 設置數據庫的數目。# 默認數據庫是 DB 0，你可以在每個連接上使用 select <dbid> 命令選擇一個不同的數據庫，# 但是 dbid 必須是一個介于 0 到 databasees - 1 之間的值databases 16 ################################ 快照 ################################## 存 DB 到磁盤：## 格式：save <間隔時間（秒）> <寫入次數>## 根據給定的時間間隔和寫入次數將數據保存到磁盤## 下面的例子的意思是：# 900 秒內如果至少有 1 個 key 的值變化，則保存# 300 秒內如果至少有 10 個 key 的值變化，則保存# 60 秒內如果至少有 10000 個 key 的值變化，則保存# # 注意：你可以注釋掉所有的 save 行來停用保存功能。# 也可以直接一個空字符串來實現停用：# save "" save 900 1save 300 10save 60 10000 # 默認情況下，如果 redis 最后一次的后臺保存失敗，redis 將停止接受寫操作，# 這樣以一種強硬的方式讓用戶知道數據不能正確的持久化到磁盤，# 否則就會沒人注意到災難的發生。## 如果后臺保存進程重新啟動工作了，redis 也將自動的允許寫操作。## 然而你要是安裝了靠譜的監控，你可能不希望 redis 這樣做，那你就改成 no 好了。stop-writes-on-bgsave-error yes # 是否在 dump .rdb 數據庫的時候使用 LZF 壓縮字符串# 默認都設為 yes# 如果你希望保存子進程節省點 cpu ，你就設置它為 no ，# 不過這個數據集可能就會比較大rdbcompression yes # 是否校驗rdb文件rdbchecksum yes # 設置 dump 的文件位置dbfilename dump.rdb # 工作目錄# 例如上面的 dbfilename 只指定了文件名，# 但是它會寫入到這個目錄下。這個配置項一定是個目錄，而不能是文件名。dir ./ ################################# 主從復制 ################################# # 主從復制。使用 slaveof 來讓一個 redis 實例成為另一個reids 實例的副本。# 注意這個只需要在 slave 上配置。## slaveof <masterip> <masterport> # 如果 master 需要密碼認證，就在這里設置# masterauth <master-passWord> # 當一個 slave 與 master 失去聯系，或者復制正在進行的時候，# slave 可能會有兩種表現：## 1) 如果為 yes ，slave 仍然會應答客戶端請求，但返回的數據可能是過時，# 或者數據可能是空的在第一次同步的時候## 2) 如果為 no ，在你執行除了 info he salveof 之外的其他命令時，# slave 都將返回一個 "SYNC with master in progress" 的錯誤，#slave-serve-stale-data yes # 你可以配置一個 slave 實體是否接受寫入操作。# 通過寫入操作來存儲一些短暫的數據對于一個 slave 實例來說可能是有用的，# 因為相對從 master 重新同步數而言，據數據寫入到 slave 會更容易被刪除。# 但是如果客戶端因為一個錯誤的配置寫入，也可能會導致一些問題。## 從 redis 2.6 版起，默認 slaves 都是只讀的。## 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 extent you can improve# security of read only slaves using 'rename-command' to shadow all the# administrative / dangerous commands.# 注意：只讀的 slaves 沒有被設計成在 internet 上暴露給不受信任的客戶端。# 它僅僅是一個針對誤用實例的一個保護層。slave-read-only yes # Slaves 在一個預定義的時間間隔內發送 ping 命令到 server 。# 你可以改變這個時間間隔。默認為 10 秒。## repl-ping-slave-period 10 # The following option sets the replication timeout for:# 設置主從復制過期時間## 1) Bulk transfer I/O during SYNC, from the point of view of slave.# 2) Master timeout from the point of view of slaves (data, pings).# 3) Slave timeout from the point of view of masters (REPLCONF ACK pings).## 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-ping-slave-period 大## 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 # 設置主從復制容量大小。這個 backlog 是一個用來在 slaves 被斷開連接時# 存放 slave 數據的 buffer，所以當一個 slave 想要重新連接，通常不希望全部重新同步，# 只是部分同步就夠了，僅僅傳遞 slave 在斷開連接時丟失的這部分數據。## The biggest the replication backlog, the longer the time the slave can be# disconnected and later be able to perform a partial resynchronization.# 這個值越大，salve 可以斷開連接的時間就越長。## The backlog is only allocated once there is at least a slave connected.## repl-backlog-size 1mb # After a master has no longer connected slaves for some time, the backlog# will be freed. The following option configures the amount of seconds that# need to elapse, starting from the time the last slave disconnected, for# the backlog buffer to be freed.# 在某些時候，master 不再連接 slaves，backlog 將被釋放。## A value of 0 means to never release the backlog.# 如果設置為 0 ，意味著絕不釋放 backlog 。## repl-backlog-ttl 3600 # 當 master 不能正常工作的時候，Redis Sentinel 會從 slaves 中選出一個新的 master，# 這個值越小，就越會被優先選中，但是如果是 0 ， 那是意味著這個 slave 不可能被選中。## 默認優先級為 100。slave-priority 100 # It is possible for a master to stop accepting writes if there are less than# N slaves connected, having a lag less or equal than M seconds.## The N slaves need to be in "online" state.## The lag in seconds, that must be <= the specified value, is calculated from# the last ping received from the slave, that is usually sent every second.## This option does not GUARANTEES that N replicas will accept the write, but# will limit the window of exposure for lost writes in case not enough slaves# are available, to the specified number of seconds.## For example to require at least 3 slaves with a lag <= 10 seconds use:## min-slaves-to-write 3# min-slaves-max-lag 10## Setting one or the other to 0 disables the feature.## By default min-slaves-to-write is set to 0 (feature disabled) and# min-slaves-max-lag is set to 10. ################################## 安全 ################################### # 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. ################################### 限制 #################################### # 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).## 一旦達到最大限制，redis 將關閉所有的新連接# 并發送一個‘max number of clients reached’的錯誤。## maxclients 10000 # 如果你設置了這個值，當緩存的數據容量達到這個值， redis 將根據你選擇的# eviction 策略來移除一些 keys。## 如果 redis 不能根據策略移除 keys ，或者是策略被設置為 ‘noeviction’，# redis 將開始響應錯誤給命令，如 set，lpush 等等，# 并繼續響應只讀的命令，如 get## This option is usually useful when using Redis as an LRU cache, or to set# a 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> # 最大內存策略，你有 5 個選擇。# # volatile-lru -> remove the key with an expire set using an LRU algorithm# volatile-lru -> 使用 LRU 算法移除包含過期設置的 key 。# allkeys-lru -> remove any key accordingly to the LRU algorithm# allkeys-lru -> 根據 LRU 算法移除所有的 key 。# 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# noeviction -> 不讓任何 key 過期，只是給寫入操作返回一個錯誤# # 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 noeviction # LRU and minimal TTL algorithms are not precise algorithms but approximated# algorithms (in order to save memory), so you can tune it for speed or# accuracy. For default Redis will check five keys and pick the one that was# used less recently, you can change the sample size using the following# configuration directive.## The default of 5 produces good enough results. 10 Approximates very closely# true LRU but costs a bit more CPU. 3 is very fast but not very accurate.## maxmemory-samples 5 ############################## 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 alwaysappendfsync 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 100auto-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 ################################ REDIS 集群 ################################# 啟用或停用集群# cluster-enabled yes # Every cluster node has a cluster configuration file. This file is not# intended to be edited by hand. It is created and updated by Redis nodes.# Every Redis Cluster node requires a different cluster configuration file.# Make sure that instances running in the same system does not have# overlapping cluster configuration file names.## cluster-config-file nodes-6379.conf # Cluster node timeout is the amount of milliseconds a node must be unreachable # for it to be considered in failure state.# Most other internal time limits are multiple of the node timeout.## cluster-node-timeout 15000 # A slave of a failing master will avoid to start a failover if its data# looks too old.## There is no simple way for a slave to actually have a exact measure of# its "data age", so the following two checks are performed:## 1) If there are multiple slaves able to failover, they exchange messages# in order to try to give an advantage to the slave with the best# replication offset (more data from the master processed).# Slaves will try to get their rank by offset, and apply to the start# of the failover a delay proportional to their rank.## 2) Every single slave computes the time of the last interaction with# its master. This can be the last ping or command received (if the master# is still in the "connected" state), or the time that elapsed since the# disconnection with the master (if the replication link is currently down).# If the last interaction is too old, the slave will not try to failover# at all.## The point "2" can be tuned by user. Specifically a slave will not perform# the failover if, since the last interaction with the master, the time# elapsed is greater than:## (node-timeout * slave-validity-factor) + repl-ping-slave-period## So for example if node-timeout is 30 seconds, and the slave-validity-factor# is 10, and assuming a default repl-ping-slave-period of 10 seconds, the# slave will not try to failover if it was not able to talk with the master# for longer than 310 seconds.## A large slave-validity-factor may allow slaves with too old data to failover# a master, while a too small value may prevent the cluster from being able to# elect a slave at all.## For maximum availability, it is possible to set the slave-validity-factor# to a value of 0, which means, that slaves will always try to failover the# master regardless of the last time they interacted with the master.# (However they'll always try to apply a delay proportional to their# offset rank).## Zero is the only value able to guarantee that when all the partitions heal# the cluster will always be able to continue.## cluster-slave-validity-factor 10 # Cluster slaves are able to migrate to orphaned masters, that are masters# that are left without working slaves. This improves the cluster ability# to resist to failures as otherwise an orphaned master can't be failed over# in case of failure if it has no working slaves.## Slaves migrate to orphaned masters only if there are still at least a# given number of other working slaves for their old master. This number# is the "migration barrier". A migration barrier of 1 means that a slave# will migrate only if there is at least 1 other working slave for its master# and so forth. It usually reflects the number of slaves you want for every# master in your cluster.## Default is 1 (slaves migrate only if their masters remain with at least# one slave). To disable migration just set it to a very large value.# A value of 0 can be set but is useful only for debugging and dangerous# in production.## cluster-migration-barrier 1 # In order to setup your cluster make sure to read the documentation# available at http://redis.io web site. ################################## 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 ############################# Event notification ############################## # Redis can notify Pub/Sub clients about events happening in the key space.# This feature is documented at http://redis.io/topics/keyspace-events# # For instance if keyspace events notification is enabled, and a client# performs a DEL operation on key "foo" stored in the Database 0, two# messages will be published via Pub/Sub:## PUBLISH __keyspace@0__:foo del# PUBLISH __keyevent@0__:del foo## It is possible to select the events that Redis will notify among a set# of classes. Every class is identified by a single character:## K Keyspace events, published with __keyspace@<db>__ prefix.# E Keyevent events, published with __keyevent@<db>__ prefix.# g Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...# $ String commands# l List commands# s Set commands# h Hash commands# z Sorted set commands# x Expired events (events generated every time a key expires)# e Evicted events (events generated when a key is evicted for maxmemory)# A Alias for g$lshzxe, so that the "AKE" string means all the events.## The "notify-keyspace-events" takes as argument a string that is composed# by zero or multiple characters. The empty string means that notifications# are disabled at all.## Example: to enable list and generic events, from the point of view of the# event name, use:## notify-keyspace-events Elg## Example 2: to get the stream of the expired keys subscribing to channel# name __keyevent@0__:expired use:## notify-keyspace-events Ex## By default all notifications are disabled because most users don't need# this feature and the feature has some overhead. Note that if you don't# specify at least one of K or E, no events will be delivered.notify-keyspace-events "" ############################### 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 512hash-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 512list-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 128zset-max-ziplist-value 64 # HyperLogLog sparse representation bytes limit. The limit includes the# 16 bytes header. When an HyperLogLog using the sparse representation crosses# this limit, it is converted into the dense representation.## A value greater than 16000 is totally useless, since at that point the# dense representation is more memory efficient.# # The suggested value is ~ 3000 in order to have the benefits of# the space efficient encoding without slowing down too much PFADD,# which is O(N) with the sparse encoding. The value can be raised to# ~ 10000 when CPU is not a concern, but space is, and the data set is# composed of many HyperLogLogs with cardinality in the 0 - 15000 range.hll-sparse-max-bytes 3000 # 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 a 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 subscribed 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 0client-output-buffer-limit slave 256mb 64mb 60client-output-buffer-limit pubsub 32mb 8mb 60 # Redis calls an internal function to perform many background tasks, like# closing connections of clients in timeout, purging expired keys that are# never requested, and so forth.## Not all tasks are performed 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配置文件參數說明:
1. Redis默認不是以守護進程的方式運行，可以通過該配置項修改，使用yes啟用守護進程
daemonize no
2. 當Redis以守護進程方式運行時，Redis默認會把pid寫入/var/run/redis.pid文件，可以通過pidfile指定
pidfile /var/run/redis.pid
3. 指定Redis監聽端口，默認端口為6379，作者在自己的一篇博文中解釋了為什么選用6379作為默認端口，因為6379在手機按鍵上MERZ對應的號碼，而MERZ取自意大利歌女Alessia Merz的名字
port 6379
4. 綁定的主機地址
bind 127.0.0.1
5.當 客戶端閑置多長時間后關閉連接，如果指定為0，表示關閉該功能
timeout 300
6. 指定日志記錄級別，Redis總共支持四個級別：debug、verbose、notice、warning，默認為verbose
loglevel verbose
7. 日志記錄方式，默認為標準輸出，如果配置Redis為守護進程方式運行，而這里又配置為日志記錄方式為標準輸出，則日志將會發送給/dev/null
logfile stdout
8. 設置數據庫的數量，默認數據庫為0，可以使用SELECT <dbid>命令在連接上指定數據庫id
databases 16
9. 指定在多長時間內，有多少次更新操作，就將數據同步到數據文件，可以多個條件配合
save <seconds> <changes>
Redis默認配置文件中提供了三個條件：
save 900 1
save 300 10
save 60 10000
分別表示900秒（15分鐘）內有1個更改，300秒（5分鐘）內有10個更改以及60秒內有10000個更改。
10. 指定存儲至本地數據庫時是否壓縮數據，默認為yes，Redis采用LZF壓縮，如果為了節省CPU時間，可以關閉該選項，但會導致數據庫文件變的巨大
rdbcompression yes
11. 指定本地數據庫文件名，默認值為dump.rdb
dbfilename dump.rdb
12. 指定本地數據庫存放目錄
dir ./
13. 設置當本機為slav服務時，設置master服務的IP地址及端口，在Redis啟動時，它會自動從master進行數據同步
slaveof <masterip> <masterport>
14. 當master服務設置了密碼保護時，slav服務連接master的密碼
masterauth <master-password>
15. 設置Redis連接密碼，如果配置了連接密碼，客戶端在連接Redis時需要通過AUTH <password>命令提供密碼，默認關閉
requirepass foobared
16. 設置同一時間最大客戶端連接數，默認無限制，Redis可以同時打開的客戶端連接數為Redis進程可以打開的最大文件描述符數，如果設置 maxclients 0，表示不作限制。當客戶端連接數到達限制時，Redis會關閉新的連接并向客戶端返回max number of clients reached錯誤信息
maxclients 128
17. 指定Redis最大內存限制，Redis在啟動時會把數據加載到內存中，達到最大內存后，Redis會先嘗試清除已到期或即將到期的Key，當此方法處理 后，仍然到達最大內存設置，將無法再進行寫入操作，但仍然可以進行讀取操作。Redis新的vm機制，會把Key存放內存，Value會存放在swap區
maxmemory <bytes>
18. 指定是否在每次更新操作后進行日志記錄，Redis在默認情況下是異步的把數據寫入磁盤，如果不開啟，可能會在斷電時導致一段時間內的數據丟失。因為 redis本身同步數據文件是按上面save條件來同步的，所以有的數據會在一段時間內只存在于內存中。默認為no
appendonly no
19. 指定更新日志文件名，默認為appendonly.aof
appendfilename appendonly.aof
20. 指定更新日志條件，共有3個可選值： no：表示等操作系統進行數據緩存同步到磁盤（快） always：表示每次更新操作后手動調用fsync()將數據寫到磁盤（慢，安全） everysec：表示每秒同步一次（折衷，默認值）
appendfsync everysec
21. 指定是否啟用虛擬內存機制，默認值為no，簡單的介紹一下，VM機制將數據分頁存放，由Redis將訪問量較少的頁即冷數據swap到磁盤上，訪問多的頁面由磁盤自動換出到內存中（在后面的文章我會仔細分析Redis的VM機制）
vm-enabled no
22. 虛擬內存文件路徑，默認值為/tmp/redis.swap，不可多個Redis實例共享
vm-swap-file /tmp/redis.swap
23. 將所有大于vm-max-memory的數據存入虛擬內存,無論vm-max-memory設置多小,所有索引數據都是內存存儲的(Redis的索引數據 就是keys),也就是說,當vm-max-memory設置為0的時候,其實是所有value都存在于磁盤。默認值為0
vm-max-memory 0
24. Redis swap文件分成了很多的page，一個對象可以保存在多個page上面，但一個page上不能被多個對象共享，vm-page-size是要根據存儲的 數據大小來設定的，作者建議如果存儲很多小對象，page大小最好設置為32或者64bytes；如果存儲很大大對象，則可以使用更大的page，如果不 確定，就使用默認值
vm-page-size 32
25. 設置swap文件中的page數量，由于頁表（一種表示頁面空閑或使用的bitmap）是在放在內存中的，，在磁盤上每8個pages將消耗1byte的內存。
vm-pages 134217728
26. 設置訪問swap文件的線程數,最好不要超過機器的核數,如果設置為0,那么所有對swap文件的操作都是串行的，可能會造成比較長時間的延遲。默認值為4
vm-max-threads 4
27. 設置在向客戶端應答時，是否把較小的包合并為一個包發送，默認為開啟
glueoutputbuf yes
28. 指定在超過一定的數量或者最大的元素超過某一臨界值時，采用一種特殊的哈希算法
hash-max-zipmap-entries 64
hash-max-zipmap-value 512
29. 指定是否激活重置哈希，默認為開啟（后面在介紹Redis的哈希算法時具體介紹）
activerehashing yes
30. 指定包含其它的配置文件，可以在同一主機上多個Redis實例之間使用同一份配置文件，而同時各個實例又擁有自己的特定配置文件
include /path/to/local.conf
----------------------
Redis配置文件被分成幾大塊區域，分別是:
1.通用(general)
2.快照(snapshotting)
3.復制(replication)
4.安全(security)
5.限制(limits)
6.追加模式(append only mode)
7.LUA腳本(lua scripting)
8.Redis集群(redis cluster)
9.慢日志(slow log)
10.延遲監控(latency monitor)
11.事件通知(event notification)
12.高級配置(advanced config)
注: INCLUDES配置:當機器不只存在1個Redis實例時，可以實現每個Redis實例的"個性化"配置，此時，可以將這些實例的共有配置寫到redis.conf中，而個性化的配置寫到由include配置路徑指定的文件中。
1. 通用(general):
############################ GENERAL #################################daemonize no ##是否以后臺daemon方式運行(默認為no)pidfile /var/run/redis/redis.pid ##Pid文件位置port 6379 ##監聽端口tcp-backlog 511 ##客戶端連接隊列值, 在高并發的環境中，為避免慢客戶端的連接問題，需要設置一個高速后臺日志bind 127.0.0.1 ##指定redis所響應的連接請求(默認響應本機所有網卡的連接請求)timeout 0 ##請求超時時間(0表示永不關閉)tcp-keepalive 0 ##TCP存活檢測(單位為秒,0表示不進行檢測)loglevel notice ##log信息級別(分四級，即debug、verbose、notice、warning)logfile /var/log/redis/redis.log ##log文件位置，如設置為[logfile ""]空字符串，則redis會將日志輸出到標準輸出，被寫到/dev/null中databases 16 ##開啟數據庫數量(默認數據庫是編號為0的數據庫,可使用select <DBid>來選擇相應數據庫)2. 快照(snapshotting) ----主要涉及的是redis的RDB持久化相關的配置
save * *: 保存快照的頻率,第一個*表示多長時間,第二個*表示執行多少次寫操作。在一定時間內執行一定數量的寫操作時，自動保存快照，可設置多個條件。如想禁用RDB持久化策略，不設置任何save指令即以，或設置[save ""]
########################## SNAPSHOTTING #############################save 900 1 ##每15分鐘且至少有1個key改變，就觸發一次持久化save 300 10 ##每5分鐘且至少有10個key改變，就觸發一次持久化save 60 10000 ##每60秒至少有10000個key改變，就觸發一次持久化stop-writes-on-bgsave-error yes ##redis持久化數據到磁盤時如出現失敗，默認redis會停止接受所有的寫請求rdbcompression yes ##是否使用壓縮rdbchecksum yes ##是否使用CRC64算法來進行數據校驗dbfilename dump.rdb ##設置數據快照文件名(只是文件名,不包括目錄)dir /var/lib/redis/ ##設置數據快照的保存目錄(這個是目錄)3. 復制(replication)
############################### REPLICATION ##########################
通過slaveof配置項可控制某一個redis作為另一個redis的從服務器，通過指定IP和端口來定位到主redis的位置
# slaveof <masterip> <masterport>如主redis設置驗證密碼(使用requirepass設置)，則需在從redis的配置中使用masterauth來設置校驗密碼，否則主redis會拒絕從redis的訪問請求
# masterauth <master-password>從redis失去與主redis的連接，或者主從同步正在進行時，redis對外部發來的訪問請求的兩種處理選擇:
選擇1:設置為yes(默認)，從redis仍會繼續響應客戶端的讀寫請求
選擇2:設置為no，從redis會對客戶端的請求返回“SYNC with master in progress”(例外:當客戶端發來INFO請求和SLAVEOF請求，從redis還是會進行處理)
slave-serve-stale-data yes slave-read-only yes ##設置從redis只讀復制同步策略：磁盤或者socket
新的從redis上線或主redis重新上線時應做數據全同步。需要將一個新的RDB文件dump出來，然后從主redis傳到從redis。有兩種情況：
1. 基于硬盤(disk-backed):主redis創建一個新進程dump RDB，之后由父進程(即主進程)增量傳給從redis
2. 基于socket(diskless):主redis創建一個新進程直接dump RDB到從redis的socket，不經過主進程，不經過硬盤
如基于硬盤，RDB文件創建后，一旦創建完畢，可以同時服務更多從redis；如基于socket，新的從redis加入后，需進行排隊(如超出repl-diskless-sync-delay設定時時)；當用diskless時，主redis等待repl-diskless-sync-delay設定的秒數后，如無新的從redis加入，就直接傳，后來的需排隊等待。(默認用disk-based)
repl-diskless-sync norepl-diskless-sync-delay 5 ##每五秒傳輸一次(需開啟diskless)# repl-ping-slave-period 10 ##設置從redis向主redis發出PING包的周期(默認10秒)在主從同步時，可能在這些情況下會有超時發生:
1. 以從redis的角度來看，當有大規模IO傳輸時。
2. 以從redis的角度來看，當數據傳輸或PING時，主redis超時
3. 以主redis的角度來看，在回復從redis的PING時，從redis超時
用戶可以設置上述超時的時限，不過要確保這個時限比repl-ping-slave-period的值要大，否則每次主redis都會認為從redis超時。
# repl-timeout 60設置主從同步時是否禁用TCP_NODELAY。如開啟TCP_NODELAY，主redis會使用更少的TCP包和更少的帶寬來向從redis傳輸數據，但可能會增加同步延遲(40ms)。如關閉TCP_NODELAY，那數據同步的延遲時間會降低，但會消耗更多的帶寬
repl-disable-tcp-nodelay no設置同步隊列長度。隊列長度（backlog)是主redis中的一個緩沖區，在與從redis斷開連接期間，主redis會用這個緩沖區來緩存應該發給從redis的數據。這樣，當從redis重新連接上后，就不必重新全量同步數據，只需要同步這部分增量數據即可
# repl-backlog-size 1mb設置主redis清理緩沖隊列等待的時間長度(設置為0表示永不清理,默認為1個小時)
# repl-backlog-ttl 3600slave-priority 100 ##設置從redis優先級，編號越小，優先級越高(默認100)如主redis發現有超過M個從redis的連接延時大于N秒，那么主redis就停止接受外來的寫請求
# min-slaves-to-write 3# min-slaves-max-lag 10假如有大于等于3個從redis的連接延遲大于10秒，那么主redis就不再接受外部的寫請求。上述兩個配置中有一個被置為0，則這個特性將被關閉
4. 安全(security)
############################# SECURITY ###################################設置redis客戶端在向redis-server發送請求之前，先進行密碼驗證。# requirepass foobared ##設置密碼為"foobared"# rename-command CONFIG b840fc02d524045429941...... ##對redis指令進行更名# rename-command CONFIG "" ##禁用CONFIG命令5. 限制(limits)
############################### LIMITS ################################# maxclients 10000 ##設置redis可以同時與多少個客戶端進行連接(默認為10000個客戶端)# maxmemory <bytes>設置redis可使用的內存量。一旦到達內存使用上限，redis將會試圖移除內部數據，移除規則可以通過maxmemory-policy來指定。如redis無法根據移除規則來移除內存中的數據，或者我們設置了“不允許移除”，那么redis則會針對那些需要申請內存的指令返回錯誤信息
如果你的redis是主redis，那么在設置內存使用上限時，需要在系統中留出一些內存空間給同步隊列緩存，只有在設置的是“不移除”的情況下，才不用考慮這個因素。
對于內存移除規則來說，redis提供了多達6種的移除規則。他們是:
1. volatile-lru：使用LRU算法移除過期集合中的key
2. allkeys-lru：使用LRU算法移除key
3. volatile-random：在過期集合中移除隨機的key
4. allkeys-random：移除隨機的key
5. volatile-ttl：移除那些TTL值最小的key，即那些最近才過期的key。
6. noeviction：不進行移除。針對寫操作，只是返回錯誤信息。(默認規則)
無論使用上述哪一種移除規則，如果沒有合適的key可以移除的話，redis都會針對寫請求返回錯誤信息。
# maxmemory-policy noeviction ##不進行移除# maxmemory-samples 5 ##設置LRU算法的樣本數6. 追加模式(append only mode)
########################## APPEND ONLY MODE ###########################appendonly on ##打開AOF功能appendfilename "appendonly.aof" ##設置AOF文件的名稱AOF持久化策略，fsync()調用，用來告訴操作系統立即將緩存的指令寫入磁盤，redis支持三種不同的模式:
1. always:每次寫請求都強制調用fsync，該模式下，redis會相對較慢，但數據最安全
2. everysec:每秒調用一次fsync
3. on:不調用fsync等待系統自己同步[fsync是指把緩存中的寫指令記錄到磁盤中]
appendfsync everysec ##每秒調用一次fsync當BGSAVE或BGWRITEAOF運行時，fsync()在主進程中的調用會被阻止。這意味著當另一路進程正在對AOF文件進行重構時，redis的持久化功能就失效了，就像設置了“appendsync none”一樣。 如果redis有時延問題， 那么將選項設置為yes。 否則請保持no，因為這是保證數據完整性的最安全的選擇。
no-appendfsync-on-rewrite no允許redis自動重寫aof。當aof增長到一定規模時，redis會隱式調用BGREWRITEAOF來重寫log文件，以縮減文件體積。redis是這樣工作的:redis會記錄上次重寫時的aof大小。如redis自啟動至今還沒有進行過重寫，那么啟動時aof文件的大小會被作為基準值。該基準值會和當前的aof大小進行比較。如當前aof大小超出所設置的增長比例，則會觸發重寫。另外還需要設置一個最小大小，是為了防止在aof很小時就觸發重寫。如設置auto-aof-rewrite-percentage為0，則會關閉此重寫功能。
auto-aof-rewrite-percentage 100auto-aof-rewrite-min-size 64mbaof-load-truncated yes ##當aof文件被損壞時,redis將返回錯誤并退出7. LUA腳本(lua scripting)
############################ LUA SCRIPTING #########################lua-time-limit 5000 ##設置lua腳本最大運行時間(默認毫秒，設置為0或負數，既不會報錯也無時間限制)8. Redis集群(redis cluster)
############################ REDIS CLUSTER ########################### cluster-enabled yes ##開啟redis集群# cluster-config-file nodes-6379.conf ##集群配置文件(啟動自動生成)# cluster-node-timeout 15000 ##節點互聯超時的閥值# cluster-slave-validity-factor 10 ##slave節點檢測因素，開始failover的超時時限是通過factor與timeout的乘積來確定的# cluster-migration-barrier 1 ##設置master只有在關聯多少slave時才會觸發遷移過程# cluster-require-full-coverage yes ##集群各節點在檢測到至少一個hash槽位遺漏的情況下將停止處理查詢請求。如集群部分節點宕機(例如部分hash槽位沒有被分配)會造成整個集群不可用，直到所有槽位均被分配時才會自動恢復為可用狀態9. 慢日志(slow log)
############################### SLOW LOG ###############################redis慢日志是指一個系統進行日志查詢超過了指定時長。這個時長不包括IO操作，如與客戶端的交互、發送響應內容等，而僅包括實際執行查詢命令的時間。針對慢日志，可設置兩個參數，一個是執行時長，單位是微秒;另一個是慢日志的長度。當一個新的命令被寫入日志時，最老的一條會從命令日志隊列中被移除。slowlog-log-slower-than 10000 ##設置執行時長為10000微秒(單位為微秒，負數表示禁用慢日志功能，而0則表示強制記錄每一個命令)slowlog-max-len 128 ##設置慢日志最大長度10. 延遲監控(latency monitor)
############################# LATENCY MONITOR ####################latency-monitor-threshold 0 ##用LATENCY打印redis實例在跑命令時的耗時圖表，只記錄大于等于所設置值的操作(0表示關閉監控)11. 事件通知(event notification) ----向客戶端通知某些事件的發生
########################## EVENT NOTIFICATION #######################notify-keyspace-events "" ##通知pub/sub客戶端關于key空間的變化(默認關閉)12. 高級配置(advanced config)
############################# ADVANCED CONFIG ##########################有關哈希數據結構的配置項hash-max-ziplist-entries 512hash-max-ziplist-value 64##有關列表數據結構的配置項list-max-ziplist-entries 512list-max-ziplist-value 64##有關集合數據結構的配置項set-max-intset-entries 512##有關有序集合數據結構的配置項zset-max-ziplist-entries 128zset-max-ziplist-value 64##有關HyperLogLog字節限制的配置項hll-sparse-max-bytes 3000##關于是否需要再哈希的配置項activerehashing yes##關于客戶端輸出緩沖的控制項client-output-buffer-limit normal 0 0 0client-output-buffer-limit slave 256mb 64mb 60client-output-buffer-limit pubsub 32mb 8mb 60##有關頻率的配置項hz 10##有關重寫aof的配置項aof-rewrite-incremental-fsync yes
新聞熱點
疑難解答
