redis的默认配置

最新推荐文章于 2023-10-20 18:20:19 发布

golden_lion

最新推荐文章于 2023-10-20 18:20:19 发布

阅读量1k

点赞数

分类专栏： redis

本文链接：https://blog.csdn.net/xyw591238/article/details/51199549

版权

redis 专栏收录该内容

46 篇文章 0 订阅

订阅专栏

redis.conf 默认配置：

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