Redis配置文件參數說明

配置文件參數說明: 

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 configuration file example 
          
 
          
# Note on units: when memory size  
          is needed, it  
          is possible to specifiy 
          
# 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 yes 
          
 
          
# 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 /usr/local/redis/run/redis.pid 
          
 
          
# Accept connections on the specified port,  
          default  
          is  
          6379 
          
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  
          192.168. 
          20.12 
          
 
          
# Close the connection after a client  
          is idle  
          for N seconds ( 
          0 to disable) 
          
timeout  
          300 
          
 
          
# Set server verbosity to  
          ' 
          debug 
          ' 
          
# it 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 verbose 
          
 
          
# 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 
          
logfile ./logs/redis.log 
          
 
          
# 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. 
          
 
          
save  
          900  
          1 
          
save  
          300  
          10 
          
save  
          60  
          10000 
          
 
          
# 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 
          
 
          
# 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. 
          
# 
          
# Also the Append Only File will be created inside  
          this directory. 
          
# 
          
# Note that you must specify a directory here, not a file name. 
          
dir ./data/ 
          
 
          
################################# 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> 
          
 
          
################################## 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 
          
 
          
################################### LIMITS #################################### 
          
 
          
# Set the max number of connected clients at the same time. By  
          default there 
          
#  
          is no limit, and it 
          ' 
          s up to the number of file descriptors the Redis process 
          
#  
          is able to open. The special value  
          ' 
          0 
          ' means no limits. 
          
# Once the limit  
          is reached Redis will close all the  
          new connections sending 
          
# an error  
          ' 
          max number of clients reached 
          '. 
          
# 
          
# maxclients  
          128 
          
 
          
# Don 
          ' 
          t use more memory than the specified amount of bytes. 
          
# When the memory limit  
          is reached Redis will  
          try to remove keys with an 
          
# EXPIRE  
          set. It will  
          try to start freeing keys that are going to expire 
          
#  
          in little time and preserve keys with a longer time to live. 
          
# Redis will also  
          try to remove objects  
          from free lists  
          if possible. 
          
# 
          
# If all  
          this fails, Redis will start to reply with errors to commands 
          
# that will use more memory, like SET, LPUSH, and so on, and will  
          continue 
          
# to reply to most read-only commands like GET. 
          
# 
          
# WARNING: maxmemory can be a good idea mainly  
          if you want to use Redis  
          as a 
          
#  
          ' 
          state 
          ' server or cache, not  
          as a real DB. When Redis  
          is used  
          as a real 
          
# database the memory usage will grow over the weeks, it will be obvious  
          if 
          
# it  
          is going to use too much memory  
          in the  
          long run, and you 
          ' 
          ll have the time 
          
# to upgrade. With maxmemory after the limit  
          is reached you 
          ' 
          ll start to get 
          
# errors  
          for write operations, and  
          this may even lead to DB inconsistency. 
          
# 
          
# maxmemory <bytes> 
          
 
          
############################## APPEND ONLY MODE ############################### 
          
 
          
# By  
          default Redis asynchronously dumps the dataset on disk. If you can live 
          
# with the idea that the latest records will be lost  
          if something like a crash 
          
# happens  
          this  
          is the preferred way to run Redis. If instead you care a lot 
          
# about your data and don 
          ' 
          t want to that a single record can get lost you should 
          
# enable the append only mode: when  
          this mode  
          is enabled Redis will append 
          
# every write operation received  
          in the file appendonly.aof. This file will 
          
# be read on startup  
          in order to rebuild the full dataset  
          in memory. 
          
# 
          
# Note that you can have both the async dumps and the append only file  
          if you 
          
# like (you have to comment the  
          " 
          save 
          " statements above to disable the dumps). 
          
# Still  
          if append only mode  
          is enabled Redis will load the data  
          from the 
          
# log file at startup ignoring the dump.rdb file. 
          
# 
          
# IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append 
          
# log file  
          in background when it gets too big. 
          
 
          
appendonly yes 
          
 
          
# 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  
          if one second passed since the last fsync. Compromise. 
          
# 
          
# The  
          default  
          is  
          " 
          everysec 
          " 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 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. 
          
# 
          
# If unsure, use  
          " 
          everysec 
          ". 
          
 
          
# appendfsync always 
          
appendfsync everysec 
          
# appendfsync no 
          
 
          
################################ VIRTUAL MEMORY ############################### 
          
 
          
# 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 ############################### 
          
 
          
# Glue small output buffers together  
          in order to send small replies  
          in a 
          
# single TCP packet. Uses a bit more CPU but most of the times it  
          is a win 
          
#  
          in terms of number of queries per second. Use  
          ' 
          yes 
          '  
          if unsure. 
          
glueoutputbuf yes 
          
 
          
# Hashes are encoded  
          in a special way (much more memory efficient) when they 
          
# have at max a given numer of elements, and the biggest element does not 
          
# exceed a given threshold. You can configure  
          this limits with the following 
          
# configuration directives. 
          
hash-max-zipmap-entries  
          64 
          
hash-max-zipmap-value  
          512 
          
 
          
# 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 rhashing, 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 
          
 
          
################################## 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