redis.conf 57 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307
  1. # Redis configuration file example.
  2. #
  3. # Note that in order to read the configuration file, Redis must be
  4. # started with the file path as first argument:
  5. #
  6. # ./redis-server /path/to/redis.conf
  7. # Note on units: when memory size is needed, it is possible to specify
  8. # it in the usual form of 1k 5GB 4M and so forth:
  9. #
  10. # 1k => 1000 bytes
  11. # 1kb => 1024 bytes
  12. # 1m => 1000000 bytes
  13. # 1mb => 1024*1024 bytes
  14. # 1g => 1000000000 bytes
  15. # 1gb => 1024*1024*1024 bytes
  16. #
  17. # units are case insensitive so 1GB 1Gb 1gB are all the same.
  18. ################################## INCLUDES ###################################
  19. # Include one or more other config files here. This is useful if you
  20. # have a standard template that goes to all Redis servers but also need
  21. # to customize a few per-server settings. Include files can include
  22. # other files, so use this wisely.
  23. #
  24. # Notice option "include" won't be rewritten by command "CONFIG REWRITE"
  25. # from admin or Redis Sentinel. Since Redis always uses the last processed
  26. # line as value of a configuration directive, you'd better put includes
  27. # at the beginning of this file to avoid overwriting config change at runtime.
  28. #
  29. # If instead you are interested in using includes to override configuration
  30. # options, it is better to use include as the last line.
  31. #
  32. # include /path/to/local.conf
  33. # include /path/to/other.conf
  34. ################################## MODULES #####################################
  35. # Load modules at startup. If the server is not able to load modules
  36. # it will abort. It is possible to use multiple loadmodule directives.
  37. #
  38. # loadmodule /path/to/my_module.so
  39. # loadmodule /path/to/other_module.so
  40. ################################## NETWORK #####################################
  41. # By default, if no "bind" configuration directive is specified, Redis listens
  42. # for connections from all the network interfaces available on the server.
  43. # It is possible to listen to just one or multiple selected interfaces using
  44. # the "bind" configuration directive, followed by one or more IP addresses.
  45. #
  46. # Examples:
  47. #
  48. # bind 192.168.1.100 10.0.0.1
  49. # bind 127.0.0.1 ::1
  50. #
  51. # ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
  52. # internet, binding to all the interfaces is dangerous and will expose the
  53. # instance to everybody on the internet. So by default we uncomment the
  54. # following bind directive, that will force Redis to listen only into
  55. # the IPv4 lookback interface address (this means Redis will be able to
  56. # accept connections only from clients running into the same computer it
  57. # is running).
  58. #
  59. # IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES
  60. # JUST COMMENT THE FOLLOWING LINE.
  61. # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  62. bind 0.0.0.0
  63. # Protected mode is a layer of security protection, in order to avoid that
  64. # Redis instances left open on the internet are accessed and exploited.
  65. #
  66. # When protected mode is on and if:
  67. #
  68. # 1) The server is not binding explicitly to a set of addresses using the
  69. # "bind" directive.
  70. # 2) No password is configured.
  71. #
  72. # The server only accepts connections from clients connecting from the
  73. # IPv4 and IPv6 loopback addresses 127.0.0.1 and ::1, and from Unix domain
  74. # sockets.
  75. #
  76. # By default protected mode is enabled. You should disable it only if
  77. # you are sure you want clients from other hosts to connect to Redis
  78. # even if no authentication is configured, nor a specific set of interfaces
  79. # are explicitly listed using the "bind" directive.
  80. protected-mode yes
  81. # Accept connections on the specified port, default is 6379 (IANA #815344).
  82. # If port 0 is specified Redis will not listen on a TCP socket.
  83. port 6379
  84. # TCP listen() backlog.
  85. #
  86. # In high requests-per-second environments you need an high backlog in order
  87. # to avoid slow clients connections issues. Note that the Linux kernel
  88. # will silently truncate it to the value of /proc/sys/net/core/somaxconn so
  89. # make sure to raise both the value of somaxconn and tcp_max_syn_backlog
  90. # in order to get the desired effect.
  91. tcp-backlog 511
  92. # Unix socket.
  93. #
  94. # Specify the path for the Unix socket that will be used to listen for
  95. # incoming connections. There is no default, so Redis will not listen
  96. # on a unix socket when not specified.
  97. #
  98. # unixsocket /tmp/redis.sock
  99. # unixsocketperm 700
  100. # Close the connection after a client is idle for N seconds (0 to disable)
  101. timeout 0
  102. # TCP keepalive.
  103. #
  104. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
  105. # of communication. This is useful for two reasons:
  106. #
  107. # 1) Detect dead peers.
  108. # 2) Take the connection alive from the point of view of network
  109. # equipment in the middle.
  110. #
  111. # On Linux, the specified value (in seconds) is the period used to send ACKs.
  112. # Note that to close the connection the double of the time is needed.
  113. # On other kernels the period depends on the kernel configuration.
  114. #
  115. # A reasonable value for this option is 300 seconds, which is the new
  116. # Redis default starting with Redis 3.2.1.
  117. tcp-keepalive 300
  118. ################################# GENERAL #####################################
  119. # By default Redis does not run as a daemon. Use 'yes' if you need it.
  120. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
  121. daemonize no
  122. # If you run Redis from upstart or systemd, Redis can interact with your
  123. # supervision tree. Options:
  124. # supervised no - no supervision interaction
  125. # supervised upstart - signal upstart by putting Redis into SIGSTOP mode
  126. # supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
  127. # supervised auto - detect upstart or systemd method based on
  128. # UPSTART_JOB or NOTIFY_SOCKET environment variables
  129. # Note: these supervision methods only signal "process is ready."
  130. # They do not enable continuous liveness pings back to your supervisor.
  131. supervised no
  132. # If a pid file is specified, Redis writes it where specified at startup
  133. # and removes it at exit.
  134. #
  135. # When the server runs non daemonized, no pid file is created if none is
  136. # specified in the configuration. When the server is daemonized, the pid file
  137. # is used even if not specified, defaulting to "/var/run/redis.pid".
  138. #
  139. # Creating a pid file is best effort: if Redis is not able to create it
  140. # nothing bad happens, the server will start and run normally.
  141. pidfile /var/run/redis_6379.pid
  142. # Specify the server verbosity level.
  143. # This can be one of:
  144. # debug (a lot of information, useful for development/testing)
  145. # verbose (many rarely useful info, but not a mess like the debug level)
  146. # notice (moderately verbose, what you want in production probably)
  147. # warning (only very important / critical messages are logged)
  148. loglevel notice
  149. # Specify the log file name. Also the empty string can be used to force
  150. # Redis to log on the standard output. Note that if you use standard
  151. # output for logging but daemonize, logs will be sent to /dev/null
  152. logfile /var/log/redis_6379.log
  153. # To enable logging to the system logger, just set 'syslog-enabled' to yes,
  154. # and optionally update the other syslog parameters to suit your needs.
  155. # syslog-enabled no
  156. # Specify the syslog identity.
  157. # syslog-ident redis
  158. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
  159. # syslog-facility local0
  160. # Set the number of databases. The default database is DB 0, you can select
  161. # a different one on a per-connection basis using SELECT <dbid> where
  162. # dbid is a number between 0 and 'databases'-1
  163. databases 16
  164. # By default Redis shows an ASCII art logo only when started to log to the
  165. # standard output and if the standard output is a TTY. Basically this means
  166. # that normally a logo is displayed only in interactive sessions.
  167. #
  168. # However it is possible to force the pre-4.0 behavior and always show a
  169. # ASCII art logo in startup logs by setting the following option to yes.
  170. always-show-logo yes
  171. ################################ SNAPSHOTTING ################################
  172. #
  173. # Save the DB on disk:
  174. #
  175. # save <seconds> <changes>
  176. #
  177. # Will save the DB if both the given number of seconds and the given
  178. # number of write operations against the DB occurred.
  179. #
  180. # In the example below the behaviour will be to save:
  181. # after 900 sec (15 min) if at least 1 key changed
  182. # after 300 sec (5 min) if at least 10 keys changed
  183. # after 60 sec if at least 10000 keys changed
  184. #
  185. # Note: you can disable saving completely by commenting out all "save" lines.
  186. #
  187. # It is also possible to remove all the previously configured save
  188. # points by adding a save directive with a single empty string argument
  189. # like in the following example:
  190. #
  191. # save ""
  192. save 900 1
  193. save 300 10
  194. save 60 10000
  195. # By default Redis will stop accepting writes if RDB snapshots are enabled
  196. # (at least one save point) and the latest background save failed.
  197. # This will make the user aware (in a hard way) that data is not persisting
  198. # on disk properly, otherwise chances are that no one will notice and some
  199. # disaster will happen.
  200. #
  201. # If the background saving process will start working again Redis will
  202. # automatically allow writes again.
  203. #
  204. # However if you have setup your proper monitoring of the Redis server
  205. # and persistence, you may want to disable this feature so that Redis will
  206. # continue to work as usual even if there are problems with disk,
  207. # permissions, and so forth.
  208. stop-writes-on-bgsave-error yes
  209. # Compress string objects using LZF when dump .rdb databases?
  210. # For default that's set to 'yes' as it's almost always a win.
  211. # If you want to save some CPU in the saving child set it to 'no' but
  212. # the dataset will likely be bigger if you have compressible values or keys.
  213. rdbcompression yes
  214. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  215. # This makes the format more resistant to corruption but there is a performance
  216. # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
  217. # for maximum performances.
  218. #
  219. # RDB files created with checksum disabled have a checksum of zero that will
  220. # tell the loading code to skip the check.
  221. rdbchecksum yes
  222. # The filename where to dump the DB
  223. dbfilename dump.rdb
  224. # The working directory.
  225. #
  226. # The DB will be written inside this directory, with the filename specified
  227. # above using the 'dbfilename' configuration directive.
  228. #
  229. # The Append Only File will also be created inside this directory.
  230. #
  231. # Note that you must specify a directory here, not a file name.
  232. dir ./
  233. ################################# REPLICATION #################################
  234. # Master-Slave replication. Use slaveof to make a Redis instance a copy of
  235. # another Redis server. A few things to understand ASAP about Redis replication.
  236. #
  237. # 1) Redis replication is asynchronous, but you can configure a master to
  238. # stop accepting writes if it appears to be not connected with at least
  239. # a given number of slaves.
  240. # 2) Redis slaves are able to perform a partial resynchronization with the
  241. # master if the replication link is lost for a relatively small amount of
  242. # time. You may want to configure the replication backlog size (see the next
  243. # sections of this file) with a sensible value depending on your needs.
  244. # 3) Replication is automatic and does not need user intervention. After a
  245. # network partition slaves automatically try to reconnect to masters
  246. # and resynchronize with them.
  247. #
  248. # slaveof <masterip> <masterport>
  249. # If the master is password protected (using the "requirepass" configuration
  250. # directive below) it is possible to tell the slave to authenticate before
  251. # starting the replication synchronization process, otherwise the master will
  252. # refuse the slave request.
  253. #
  254. # masterauth <master-password>
  255. # When a slave loses its connection with the master, or when the replication
  256. # is still in progress, the slave can act in two different ways:
  257. #
  258. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
  259. # still reply to client requests, possibly with out of date data, or the
  260. # data set may just be empty if this is the first synchronization.
  261. #
  262. # 2) if slave-serve-stale-data is set to 'no' the slave will reply with
  263. # an error "SYNC with master in progress" to all the kind of commands
  264. # but to INFO and SLAVEOF.
  265. #
  266. slave-serve-stale-data yes
  267. # You can configure a slave instance to accept writes or not. Writing against
  268. # a slave instance may be useful to store some ephemeral data (because data
  269. # written on a slave will be easily deleted after resync with the master) but
  270. # may also cause problems if clients are writing to it because of a
  271. # misconfiguration.
  272. #
  273. # Since Redis 2.6 by default slaves are read-only.
  274. #
  275. # Note: read only slaves are not designed to be exposed to untrusted clients
  276. # on the internet. It's just a protection layer against misuse of the instance.
  277. # Still a read only slave exports by default all the administrative commands
  278. # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
  279. # security of read only slaves using 'rename-command' to shadow all the
  280. # administrative / dangerous commands.
  281. slave-read-only yes
  282. # Replication SYNC strategy: disk or socket.
  283. #
  284. # -------------------------------------------------------
  285. # WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY
  286. # -------------------------------------------------------
  287. #
  288. # New slaves and reconnecting slaves that are not able to continue the replication
  289. # process just receiving differences, need to do what is called a "full
  290. # synchronization". An RDB file is transmitted from the master to the slaves.
  291. # The transmission can happen in two different ways:
  292. #
  293. # 1) Disk-backed: The Redis master creates a new process that writes the RDB
  294. # file on disk. Later the file is transferred by the parent
  295. # process to the slaves incrementally.
  296. # 2) Diskless: The Redis master creates a new process that directly writes the
  297. # RDB file to slave sockets, without touching the disk at all.
  298. #
  299. # With disk-backed replication, while the RDB file is generated, more slaves
  300. # can be queued and served with the RDB file as soon as the current child producing
  301. # the RDB file finishes its work. With diskless replication instead once
  302. # the transfer starts, new slaves arriving will be queued and a new transfer
  303. # will start when the current one terminates.
  304. #
  305. # When diskless replication is used, the master waits a configurable amount of
  306. # time (in seconds) before starting the transfer in the hope that multiple slaves
  307. # will arrive and the transfer can be parallelized.
  308. #
  309. # With slow disks and fast (large bandwidth) networks, diskless replication
  310. # works better.
  311. repl-diskless-sync no
  312. # When diskless replication is enabled, it is possible to configure the delay
  313. # the server waits in order to spawn the child that transfers the RDB via socket
  314. # to the slaves.
  315. #
  316. # This is important since once the transfer starts, it is not possible to serve
  317. # new slaves arriving, that will be queued for the next RDB transfer, so the server
  318. # waits a delay in order to let more slaves arrive.
  319. #
  320. # The delay is specified in seconds, and by default is 5 seconds. To disable
  321. # it entirely just set it to 0 seconds and the transfer will start ASAP.
  322. repl-diskless-sync-delay 5
  323. # Slaves send PINGs to server in a predefined interval. It's possible to change
  324. # this interval with the repl_ping_slave_period option. The default value is 10
  325. # seconds.
  326. #
  327. # repl-ping-slave-period 10
  328. # The following option sets the replication timeout for:
  329. #
  330. # 1) Bulk transfer I/O during SYNC, from the point of view of slave.
  331. # 2) Master timeout from the point of view of slaves (data, pings).
  332. # 3) Slave timeout from the point of view of masters (REPLCONF ACK pings).
  333. #
  334. # It is important to make sure that this value is greater than the value
  335. # specified for repl-ping-slave-period otherwise a timeout will be detected
  336. # every time there is low traffic between the master and the slave.
  337. #
  338. # repl-timeout 60
  339. # Disable TCP_NODELAY on the slave socket after SYNC?
  340. #
  341. # If you select "yes" Redis will use a smaller number of TCP packets and
  342. # less bandwidth to send data to slaves. But this can add a delay for
  343. # the data to appear on the slave side, up to 40 milliseconds with
  344. # Linux kernels using a default configuration.
  345. #
  346. # If you select "no" the delay for data to appear on the slave side will
  347. # be reduced but more bandwidth will be used for replication.
  348. #
  349. # By default we optimize for low latency, but in very high traffic conditions
  350. # or when the master and slaves are many hops away, turning this to "yes" may
  351. # be a good idea.
  352. repl-disable-tcp-nodelay no
  353. # Set the replication backlog size. The backlog is a buffer that accumulates
  354. # slave data when slaves are disconnected for some time, so that when a slave
  355. # wants to reconnect again, often a full resync is not needed, but a partial
  356. # resync is enough, just passing the portion of data the slave missed while
  357. # disconnected.
  358. #
  359. # The bigger the replication backlog, the longer the time the slave can be
  360. # disconnected and later be able to perform a partial resynchronization.
  361. #
  362. # The backlog is only allocated once there is at least a slave connected.
  363. #
  364. # repl-backlog-size 1mb
  365. # After a master has no longer connected slaves for some time, the backlog
  366. # will be freed. The following option configures the amount of seconds that
  367. # need to elapse, starting from the time the last slave disconnected, for
  368. # the backlog buffer to be freed.
  369. #
  370. # Note that slaves never free the backlog for timeout, since they may be
  371. # promoted to masters later, and should be able to correctly "partially
  372. # resynchronize" with the slaves: hence they should always accumulate backlog.
  373. #
  374. # A value of 0 means to never release the backlog.
  375. #
  376. # repl-backlog-ttl 3600
  377. # The slave priority is an integer number published by Redis in the INFO output.
  378. # It is used by Redis Sentinel in order to select a slave to promote into a
  379. # master if the master is no longer working correctly.
  380. #
  381. # A slave with a low priority number is considered better for promotion, so
  382. # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
  383. # pick the one with priority 10, that is the lowest.
  384. #
  385. # However a special priority of 0 marks the slave as not able to perform the
  386. # role of master, so a slave with priority of 0 will never be selected by
  387. # Redis Sentinel for promotion.
  388. #
  389. # By default the priority is 100.
  390. slave-priority 100
  391. # It is possible for a master to stop accepting writes if there are less than
  392. # N slaves connected, having a lag less or equal than M seconds.
  393. #
  394. # The N slaves need to be in "online" state.
  395. #
  396. # The lag in seconds, that must be <= the specified value, is calculated from
  397. # the last ping received from the slave, that is usually sent every second.
  398. #
  399. # This option does not GUARANTEE that N replicas will accept the write, but
  400. # will limit the window of exposure for lost writes in case not enough slaves
  401. # are available, to the specified number of seconds.
  402. #
  403. # For example to require at least 3 slaves with a lag <= 10 seconds use:
  404. #
  405. # min-slaves-to-write 3
  406. # min-slaves-max-lag 10
  407. #
  408. # Setting one or the other to 0 disables the feature.
  409. #
  410. # By default min-slaves-to-write is set to 0 (feature disabled) and
  411. # min-slaves-max-lag is set to 10.
  412. # A Redis master is able to list the address and port of the attached
  413. # slaves in different ways. For example the "INFO replication" section
  414. # offers this information, which is used, among other tools, by
  415. # Redis Sentinel in order to discover slave instances.
  416. # Another place where this info is available is in the output of the
  417. # "ROLE" command of a master.
  418. #
  419. # The listed IP and address normally reported by a slave is obtained
  420. # in the following way:
  421. #
  422. # IP: The address is auto detected by checking the peer address
  423. # of the socket used by the slave to connect with the master.
  424. #
  425. # Port: The port is communicated by the slave during the replication
  426. # handshake, and is normally the port that the slave is using to
  427. # list for connections.
  428. #
  429. # However when port forwarding or Network Address Translation (NAT) is
  430. # used, the slave may be actually reachable via different IP and port
  431. # pairs. The following two options can be used by a slave in order to
  432. # report to its master a specific set of IP and port, so that both INFO
  433. # and ROLE will report those values.
  434. #
  435. # There is no need to use both the options if you need to override just
  436. # the port or the IP address.
  437. #
  438. # slave-announce-ip 5.5.5.5
  439. # slave-announce-port 1234
  440. ################################## SECURITY ###################################
  441. # Require clients to issue AUTH <PASSWORD> before processing any other
  442. # commands. This might be useful in environments in which you do not trust
  443. # others with access to the host running redis-server.
  444. #
  445. # This should stay commented out for backward compatibility and because most
  446. # people do not need auth (e.g. they run their own servers).
  447. #
  448. # Warning: since Redis is pretty fast an outside user can try up to
  449. # 150k passwords per second against a good box. This means that you should
  450. # use a very strong password otherwise it will be very easy to break.
  451. #
  452. # requirepass foobared
  453. # Command renaming.
  454. #
  455. # It is possible to change the name of dangerous commands in a shared
  456. # environment. For instance the CONFIG command may be renamed into something
  457. # hard to guess so that it will still be available for internal-use tools
  458. # but not available for general clients.
  459. #
  460. # Example:
  461. #
  462. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  463. #
  464. # It is also possible to completely kill a command by renaming it into
  465. # an empty string:
  466. #
  467. # rename-command CONFIG ""
  468. #
  469. # Please note that changing the name of commands that are logged into the
  470. # AOF file or transmitted to slaves may cause problems.
  471. ################################### CLIENTS ####################################
  472. # Set the max number of connected clients at the same time. By default
  473. # this limit is set to 10000 clients, however if the Redis server is not
  474. # able to configure the process file limit to allow for the specified limit
  475. # the max number of allowed clients is set to the current file limit
  476. # minus 32 (as Redis reserves a few file descriptors for internal uses).
  477. #
  478. # Once the limit is reached Redis will close all the new connections sending
  479. # an error 'max number of clients reached'.
  480. #
  481. # maxclients 10000
  482. ############################## MEMORY MANAGEMENT ################################
  483. # Set a memory usage limit to the specified amount of bytes.
  484. # When the memory limit is reached Redis will try to remove keys
  485. # according to the eviction policy selected (see maxmemory-policy).
  486. #
  487. # If Redis can't remove keys according to the policy, or if the policy is
  488. # set to 'noeviction', Redis will start to reply with errors to commands
  489. # that would use more memory, like SET, LPUSH, and so on, and will continue
  490. # to reply to read-only commands like GET.
  491. #
  492. # This option is usually useful when using Redis as an LRU or LFU cache, or to
  493. # set a hard memory limit for an instance (using the 'noeviction' policy).
  494. #
  495. # WARNING: If you have slaves attached to an instance with maxmemory on,
  496. # the size of the output buffers needed to feed the slaves are subtracted
  497. # from the used memory count, so that network problems / resyncs will
  498. # not trigger a loop where keys are evicted, and in turn the output
  499. # buffer of slaves is full with DELs of keys evicted triggering the deletion
  500. # of more keys, and so forth until the database is completely emptied.
  501. #
  502. # In short... if you have slaves attached it is suggested that you set a lower
  503. # limit for maxmemory so that there is some free RAM on the system for slave
  504. # output buffers (but this is not needed if the policy is 'noeviction').
  505. #
  506. # maxmemory <bytes>
  507. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
  508. # is reached. You can select among five behaviors:
  509. #
  510. # volatile-lru -> Evict using approximated LRU among the keys with an expire set.
  511. # allkeys-lru -> Evict any key using approximated LRU.
  512. # volatile-lfu -> Evict using approximated LFU among the keys with an expire set.
  513. # allkeys-lfu -> Evict any key using approximated LFU.
  514. # volatile-random -> Remove a random key among the ones with an expire set.
  515. # allkeys-random -> Remove a random key, any key.
  516. # volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
  517. # noeviction -> Don't evict anything, just return an error on write operations.
  518. #
  519. # LRU means Least Recently Used
  520. # LFU means Least Frequently Used
  521. #
  522. # Both LRU, LFU and volatile-ttl are implemented using approximated
  523. # randomized algorithms.
  524. #
  525. # Note: with any of the above policies, Redis will return an error on write
  526. # operations, when there are no suitable keys for eviction.
  527. #
  528. # At the date of writing these commands are: set setnx setex append
  529. # incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
  530. # sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
  531. # zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
  532. # getset mset msetnx exec sort
  533. #
  534. # The default is:
  535. #
  536. # maxmemory-policy noeviction
  537. # LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated
  538. # algorithms (in order to save memory), so you can tune it for speed or
  539. # accuracy. For default Redis will check five keys and pick the one that was
  540. # used less recently, you can change the sample size using the following
  541. # configuration directive.
  542. #
  543. # The default of 5 produces good enough results. 10 Approximates very closely
  544. # true LRU but costs more CPU. 3 is faster but not very accurate.
  545. #
  546. # maxmemory-samples 5
  547. ############################# LAZY FREEING ####################################
  548. # Redis has two primitives to delete keys. One is called DEL and is a blocking
  549. # deletion of the object. It means that the server stops processing new commands
  550. # in order to reclaim all the memory associated with an object in a synchronous
  551. # way. If the key deleted is associated with a small object, the time needed
  552. # in order to execute the DEL command is very small and comparable to most other
  553. # O(1) or O(log_N) commands in Redis. However if the key is associated with an
  554. # aggregated value containing millions of elements, the server can block for
  555. # a long time (even seconds) in order to complete the operation.
  556. #
  557. # For the above reasons Redis also offers non blocking deletion primitives
  558. # such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and
  559. # FLUSHDB commands, in order to reclaim memory in background. Those commands
  560. # are executed in constant time. Another thread will incrementally free the
  561. # object in the background as fast as possible.
  562. #
  563. # DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.
  564. # It's up to the design of the application to understand when it is a good
  565. # idea to use one or the other. However the Redis server sometimes has to
  566. # delete keys or flush the whole database as a side effect of other operations.
  567. # Specifically Redis deletes objects independently of a user call in the
  568. # following scenarios:
  569. #
  570. # 1) On eviction, because of the maxmemory and maxmemory policy configurations,
  571. # in order to make room for new data, without going over the specified
  572. # memory limit.
  573. # 2) Because of expire: when a key with an associated time to live (see the
  574. # EXPIRE command) must be deleted from memory.
  575. # 3) Because of a side effect of a command that stores data on a key that may
  576. # already exist. For example the RENAME command may delete the old key
  577. # content when it is replaced with another one. Similarly SUNIONSTORE
  578. # or SORT with STORE option may delete existing keys. The SET command
  579. # itself removes any old content of the specified key in order to replace
  580. # it with the specified string.
  581. # 4) During replication, when a slave performs a full resynchronization with
  582. # its master, the content of the whole database is removed in order to
  583. # load the RDB file just transfered.
  584. #
  585. # In all the above cases the default is to delete objects in a blocking way,
  586. # like if DEL was called. However you can configure each case specifically
  587. # in order to instead release memory in a non-blocking way like if UNLINK
  588. # was called, using the following configuration directives:
  589. lazyfree-lazy-eviction no
  590. lazyfree-lazy-expire no
  591. lazyfree-lazy-server-del no
  592. slave-lazy-flush no
  593. ############################## APPEND ONLY MODE ###############################
  594. # By default Redis asynchronously dumps the dataset on disk. This mode is
  595. # good enough in many applications, but an issue with the Redis process or
  596. # a power outage may result into a few minutes of writes lost (depending on
  597. # the configured save points).
  598. #
  599. # The Append Only File is an alternative persistence mode that provides
  600. # much better durability. For instance using the default data fsync policy
  601. # (see later in the config file) Redis can lose just one second of writes in a
  602. # dramatic event like a server power outage, or a single write if something
  603. # wrong with the Redis process itself happens, but the operating system is
  604. # still running correctly.
  605. #
  606. # AOF and RDB persistence can be enabled at the same time without problems.
  607. # If the AOF is enabled on startup Redis will load the AOF, that is the file
  608. # with the better durability guarantees.
  609. #
  610. # Please check http://redis.io/topics/persistence for more information.
  611. appendonly no
  612. # The name of the append only file (default: "appendonly.aof")
  613. appendfilename "appendonly.aof"
  614. # The fsync() call tells the Operating System to actually write data on disk
  615. # instead of waiting for more data in the output buffer. Some OS will really flush
  616. # data on disk, some other OS will just try to do it ASAP.
  617. #
  618. # Redis supports three different modes:
  619. #
  620. # no: don't fsync, just let the OS flush the data when it wants. Faster.
  621. # always: fsync after every write to the append only log. Slow, Safest.
  622. # everysec: fsync only one time every second. Compromise.
  623. #
  624. # The default is "everysec", as that's usually the right compromise between
  625. # speed and data safety. It's up to you to understand if you can relax this to
  626. # "no" that will let the operating system flush the output buffer when
  627. # it wants, for better performances (but if you can live with the idea of
  628. # some data loss consider the default persistence mode that's snapshotting),
  629. # or on the contrary, use "always" that's very slow but a bit safer than
  630. # everysec.
  631. #
  632. # More details please check the following article:
  633. # http://antirez.com/post/redis-persistence-demystified.html
  634. #
  635. # If unsure, use "everysec".
  636. # appendfsync always
  637. appendfsync everysec
  638. # appendfsync no
  639. # When the AOF fsync policy is set to always or everysec, and a background
  640. # saving process (a background save or AOF log background rewriting) is
  641. # performing a lot of I/O against the disk, in some Linux configurations
  642. # Redis may block too long on the fsync() call. Note that there is no fix for
  643. # this currently, as even performing fsync in a different thread will block
  644. # our synchronous write(2) call.
  645. #
  646. # In order to mitigate this problem it's possible to use the following option
  647. # that will prevent fsync() from being called in the main process while a
  648. # BGSAVE or BGREWRITEAOF is in progress.
  649. #
  650. # This means that while another child is saving, the durability of Redis is
  651. # the same as "appendfsync none". In practical terms, this means that it is
  652. # possible to lose up to 30 seconds of log in the worst scenario (with the
  653. # default Linux settings).
  654. #
  655. # If you have latency problems turn this to "yes". Otherwise leave it as
  656. # "no" that is the safest pick from the point of view of durability.
  657. no-appendfsync-on-rewrite no
  658. # Automatic rewrite of the append only file.
  659. # Redis is able to automatically rewrite the log file implicitly calling
  660. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
  661. #
  662. # This is how it works: Redis remembers the size of the AOF file after the
  663. # latest rewrite (if no rewrite has happened since the restart, the size of
  664. # the AOF at startup is used).
  665. #
  666. # This base size is compared to the current size. If the current size is
  667. # bigger than the specified percentage, the rewrite is triggered. Also
  668. # you need to specify a minimal size for the AOF file to be rewritten, this
  669. # is useful to avoid rewriting the AOF file even if the percentage increase
  670. # is reached but it is still pretty small.
  671. #
  672. # Specify a percentage of zero in order to disable the automatic AOF
  673. # rewrite feature.
  674. auto-aof-rewrite-percentage 100
  675. auto-aof-rewrite-min-size 64mb
  676. # An AOF file may be found to be truncated at the end during the Redis
  677. # startup process, when the AOF data gets loaded back into memory.
  678. # This may happen when the system where Redis is running
  679. # crashes, especially when an ext4 filesystem is mounted without the
  680. # data=ordered option (however this can't happen when Redis itself
  681. # crashes or aborts but the operating system still works correctly).
  682. #
  683. # Redis can either exit with an error when this happens, or load as much
  684. # data as possible (the default now) and start if the AOF file is found
  685. # to be truncated at the end. The following option controls this behavior.
  686. #
  687. # If aof-load-truncated is set to yes, a truncated AOF file is loaded and
  688. # the Redis server starts emitting a log to inform the user of the event.
  689. # Otherwise if the option is set to no, the server aborts with an error
  690. # and refuses to start. When the option is set to no, the user requires
  691. # to fix the AOF file using the "redis-check-aof" utility before to restart
  692. # the server.
  693. #
  694. # Note that if the AOF file will be found to be corrupted in the middle
  695. # the server will still exit with an error. This option only applies when
  696. # Redis will try to read more data from the AOF file but not enough bytes
  697. # will be found.
  698. aof-load-truncated yes
  699. # When rewriting the AOF file, Redis is able to use an RDB preamble in the
  700. # AOF file for faster rewrites and recoveries. When this option is turned
  701. # on the rewritten AOF file is composed of two different stanzas:
  702. #
  703. # [RDB file][AOF tail]
  704. #
  705. # When loading Redis recognizes that the AOF file starts with the "REDIS"
  706. # string and loads the prefixed RDB file, and continues loading the AOF
  707. # tail.
  708. #
  709. # This is currently turned off by default in order to avoid the surprise
  710. # of a format change, but will at some point be used as the default.
  711. aof-use-rdb-preamble no
  712. ################################ LUA SCRIPTING ###############################
  713. # Max execution time of a Lua script in milliseconds.
  714. #
  715. # If the maximum execution time is reached Redis will log that a script is
  716. # still in execution after the maximum allowed time and will start to
  717. # reply to queries with an error.
  718. #
  719. # When a long running script exceeds the maximum execution time only the
  720. # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
  721. # used to stop a script that did not yet called write commands. The second
  722. # is the only way to shut down the server in the case a write command was
  723. # already issued by the script but the user doesn't want to wait for the natural
  724. # termination of the script.
  725. #
  726. # Set it to 0 or a negative value for unlimited execution without warnings.
  727. lua-time-limit 5000
  728. ################################ REDIS CLUSTER ###############################
  729. #
  730. # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  731. # WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however
  732. # in order to mark it as "mature" we need to wait for a non trivial percentage
  733. # of users to deploy it in production.
  734. # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  735. #
  736. # Normal Redis instances can't be part of a Redis Cluster; only nodes that are
  737. # started as cluster nodes can. In order to start a Redis instance as a
  738. # cluster node enable the cluster support uncommenting the following:
  739. #
  740. # cluster-enabled yes
  741. # Every cluster node has a cluster configuration file. This file is not
  742. # intended to be edited by hand. It is created and updated by Redis nodes.
  743. # Every Redis Cluster node requires a different cluster configuration file.
  744. # Make sure that instances running in the same system do not have
  745. # overlapping cluster configuration file names.
  746. #
  747. # cluster-config-file nodes-6379.conf
  748. # Cluster node timeout is the amount of milliseconds a node must be unreachable
  749. # for it to be considered in failure state.
  750. # Most other internal time limits are multiple of the node timeout.
  751. #
  752. # cluster-node-timeout 15000
  753. # A slave of a failing master will avoid to start a failover if its data
  754. # looks too old.
  755. #
  756. # There is no simple way for a slave to actually have an exact measure of
  757. # its "data age", so the following two checks are performed:
  758. #
  759. # 1) If there are multiple slaves able to failover, they exchange messages
  760. # in order to try to give an advantage to the slave with the best
  761. # replication offset (more data from the master processed).
  762. # Slaves will try to get their rank by offset, and apply to the start
  763. # of the failover a delay proportional to their rank.
  764. #
  765. # 2) Every single slave computes the time of the last interaction with
  766. # its master. This can be the last ping or command received (if the master
  767. # is still in the "connected" state), or the time that elapsed since the
  768. # disconnection with the master (if the replication link is currently down).
  769. # If the last interaction is too old, the slave will not try to failover
  770. # at all.
  771. #
  772. # The point "2" can be tuned by user. Specifically a slave will not perform
  773. # the failover if, since the last interaction with the master, the time
  774. # elapsed is greater than:
  775. #
  776. # (node-timeout * slave-validity-factor) + repl-ping-slave-period
  777. #
  778. # So for example if node-timeout is 30 seconds, and the slave-validity-factor
  779. # is 10, and assuming a default repl-ping-slave-period of 10 seconds, the
  780. # slave will not try to failover if it was not able to talk with the master
  781. # for longer than 310 seconds.
  782. #
  783. # A large slave-validity-factor may allow slaves with too old data to failover
  784. # a master, while a too small value may prevent the cluster from being able to
  785. # elect a slave at all.
  786. #
  787. # For maximum availability, it is possible to set the slave-validity-factor
  788. # to a value of 0, which means, that slaves will always try to failover the
  789. # master regardless of the last time they interacted with the master.
  790. # (However they'll always try to apply a delay proportional to their
  791. # offset rank).
  792. #
  793. # Zero is the only value able to guarantee that when all the partitions heal
  794. # the cluster will always be able to continue.
  795. #
  796. # cluster-slave-validity-factor 10
  797. # Cluster slaves are able to migrate to orphaned masters, that are masters
  798. # that are left without working slaves. This improves the cluster ability
  799. # to resist to failures as otherwise an orphaned master can't be failed over
  800. # in case of failure if it has no working slaves.
  801. #
  802. # Slaves migrate to orphaned masters only if there are still at least a
  803. # given number of other working slaves for their old master. This number
  804. # is the "migration barrier". A migration barrier of 1 means that a slave
  805. # will migrate only if there is at least 1 other working slave for its master
  806. # and so forth. It usually reflects the number of slaves you want for every
  807. # master in your cluster.
  808. #
  809. # Default is 1 (slaves migrate only if their masters remain with at least
  810. # one slave). To disable migration just set it to a very large value.
  811. # A value of 0 can be set but is useful only for debugging and dangerous
  812. # in production.
  813. #
  814. # cluster-migration-barrier 1
  815. # By default Redis Cluster nodes stop accepting queries if they detect there
  816. # is at least an hash slot uncovered (no available node is serving it).
  817. # This way if the cluster is partially down (for example a range of hash slots
  818. # are no longer covered) all the cluster becomes, eventually, unavailable.
  819. # It automatically returns available as soon as all the slots are covered again.
  820. #
  821. # However sometimes you want the subset of the cluster which is working,
  822. # to continue to accept queries for the part of the key space that is still
  823. # covered. In order to do so, just set the cluster-require-full-coverage
  824. # option to no.
  825. #
  826. # cluster-require-full-coverage yes
  827. # In order to setup your cluster make sure to read the documentation
  828. # available at http://redis.io web site.
  829. ########################## CLUSTER DOCKER/NAT support ########################
  830. # In certain deployments, Redis Cluster nodes address discovery fails, because
  831. # addresses are NAT-ted or because ports are forwarded (the typical case is
  832. # Docker and other containers).
  833. #
  834. # In order to make Redis Cluster working in such environments, a static
  835. # configuration where each node knows its public address is needed. The
  836. # following two options are used for this scope, and are:
  837. #
  838. # * cluster-announce-ip
  839. # * cluster-announce-port
  840. # * cluster-announce-bus-port
  841. #
  842. # Each instruct the node about its address, client port, and cluster message
  843. # bus port. The information is then published in the header of the bus packets
  844. # so that other nodes will be able to correctly map the address of the node
  845. # publishing the information.
  846. #
  847. # If the above options are not used, the normal Redis Cluster auto-detection
  848. # will be used instead.
  849. #
  850. # Note that when remapped, the bus port may not be at the fixed offset of
  851. # clients port + 10000, so you can specify any port and bus-port depending
  852. # on how they get remapped. If the bus-port is not set, a fixed offset of
  853. # 10000 will be used as usually.
  854. #
  855. # Example:
  856. #
  857. # cluster-announce-ip 10.1.1.5
  858. # cluster-announce-port 6379
  859. # cluster-announce-bus-port 6380
  860. ################################## SLOW LOG ###################################
  861. # The Redis Slow Log is a system to log queries that exceeded a specified
  862. # execution time. The execution time does not include the I/O operations
  863. # like talking with the client, sending the reply and so forth,
  864. # but just the time needed to actually execute the command (this is the only
  865. # stage of command execution where the thread is blocked and can not serve
  866. # other requests in the meantime).
  867. #
  868. # You can configure the slow log with two parameters: one tells Redis
  869. # what is the execution time, in microseconds, to exceed in order for the
  870. # command to get logged, and the other parameter is the length of the
  871. # slow log. When a new command is logged the oldest one is removed from the
  872. # queue of logged commands.
  873. # The following time is expressed in microseconds, so 1000000 is equivalent
  874. # to one second. Note that a negative number disables the slow log, while
  875. # a value of zero forces the logging of every command.
  876. slowlog-log-slower-than 10000
  877. # There is no limit to this length. Just be aware that it will consume memory.
  878. # You can reclaim memory used by the slow log with SLOWLOG RESET.
  879. slowlog-max-len 128
  880. ################################ LATENCY MONITOR ##############################
  881. # The Redis latency monitoring subsystem samples different operations
  882. # at runtime in order to collect data related to possible sources of
  883. # latency of a Redis instance.
  884. #
  885. # Via the LATENCY command this information is available to the user that can
  886. # print graphs and obtain reports.
  887. #
  888. # The system only logs operations that were performed in a time equal or
  889. # greater than the amount of milliseconds specified via the
  890. # latency-monitor-threshold configuration directive. When its value is set
  891. # to zero, the latency monitor is turned off.
  892. #
  893. # By default latency monitoring is disabled since it is mostly not needed
  894. # if you don't have latency issues, and collecting data has a performance
  895. # impact, that while very small, can be measured under big load. Latency
  896. # monitoring can easily be enabled at runtime using the command
  897. # "CONFIG SET latency-monitor-threshold <milliseconds>" if needed.
  898. latency-monitor-threshold 0
  899. ############################# EVENT NOTIFICATION ##############################
  900. # Redis can notify Pub/Sub clients about events happening in the key space.
  901. # This feature is documented at http://redis.io/topics/notifications
  902. #
  903. # For instance if keyspace events notification is enabled, and a client
  904. # performs a DEL operation on key "foo" stored in the Database 0, two
  905. # messages will be published via Pub/Sub:
  906. #
  907. # PUBLISH __keyspace@0__:foo del
  908. # PUBLISH __keyevent@0__:del foo
  909. #
  910. # It is possible to select the events that Redis will notify among a set
  911. # of classes. Every class is identified by a single character:
  912. #
  913. # K Keyspace events, published with __keyspace@<db>__ prefix.
  914. # E Keyevent events, published with __keyevent@<db>__ prefix.
  915. # g Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
  916. # $ String commands
  917. # l List commands
  918. # s Set commands
  919. # h Hash commands
  920. # z Sorted set commands
  921. # x Expired events (events generated every time a key expires)
  922. # e Evicted events (events generated when a key is evicted for maxmemory)
  923. # A Alias for g$lshzxe, so that the "AKE" string means all the events.
  924. #
  925. # The "notify-keyspace-events" takes as argument a string that is composed
  926. # of zero or multiple characters. The empty string means that notifications
  927. # are disabled.
  928. #
  929. # Example: to enable list and generic events, from the point of view of the
  930. # event name, use:
  931. #
  932. # notify-keyspace-events Elg
  933. #
  934. # Example 2: to get the stream of the expired keys subscribing to channel
  935. # name __keyevent@0__:expired use:
  936. #
  937. # notify-keyspace-events Ex
  938. #
  939. # By default all notifications are disabled because most users don't need
  940. # this feature and the feature has some overhead. Note that if you don't
  941. # specify at least one of K or E, no events will be delivered.
  942. notify-keyspace-events ""
  943. ############################### ADVANCED CONFIG ###############################
  944. # Hashes are encoded using a memory efficient data structure when they have a
  945. # small number of entries, and the biggest entry does not exceed a given
  946. # threshold. These thresholds can be configured using the following directives.
  947. hash-max-ziplist-entries 512
  948. hash-max-ziplist-value 64
  949. # Lists are also encoded in a special way to save a lot of space.
  950. # The number of entries allowed per internal list node can be specified
  951. # as a fixed maximum size or a maximum number of elements.
  952. # For a fixed maximum size, use -5 through -1, meaning:
  953. # -5: max size: 64 Kb <-- not recommended for normal workloads
  954. # -4: max size: 32 Kb <-- not recommended
  955. # -3: max size: 16 Kb <-- probably not recommended
  956. # -2: max size: 8 Kb <-- good
  957. # -1: max size: 4 Kb <-- good
  958. # Positive numbers mean store up to _exactly_ that number of elements
  959. # per list node.
  960. # The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size),
  961. # but if your use case is unique, adjust the settings as necessary.
  962. list-max-ziplist-size -2
  963. # Lists may also be compressed.
  964. # Compress depth is the number of quicklist ziplist nodes from *each* side of
  965. # the list to *exclude* from compression. The head and tail of the list
  966. # are always uncompressed for fast push/pop operations. Settings are:
  967. # 0: disable all list compression
  968. # 1: depth 1 means "don't start compressing until after 1 node into the list,
  969. # going from either the head or tail"
  970. # So: [head]->node->node->...->node->[tail]
  971. # [head], [tail] will always be uncompressed; inner nodes will compress.
  972. # 2: [head]->[next]->node->node->...->node->[prev]->[tail]
  973. # 2 here means: don't compress head or head->next or tail->prev or tail,
  974. # but compress all nodes between them.
  975. # 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]
  976. # etc.
  977. list-compress-depth 0
  978. # Sets have a special encoding in just one case: when a set is composed
  979. # of just strings that happen to be integers in radix 10 in the range
  980. # of 64 bit signed integers.
  981. # The following configuration setting sets the limit in the size of the
  982. # set in order to use this special memory saving encoding.
  983. set-max-intset-entries 512
  984. # Similarly to hashes and lists, sorted sets are also specially encoded in
  985. # order to save a lot of space. This encoding is only used when the length and
  986. # elements of a sorted set are below the following limits:
  987. zset-max-ziplist-entries 128
  988. zset-max-ziplist-value 64
  989. # HyperLogLog sparse representation bytes limit. The limit includes the
  990. # 16 bytes header. When an HyperLogLog using the sparse representation crosses
  991. # this limit, it is converted into the dense representation.
  992. #
  993. # A value greater than 16000 is totally useless, since at that point the
  994. # dense representation is more memory efficient.
  995. #
  996. # The suggested value is ~ 3000 in order to have the benefits of
  997. # the space efficient encoding without slowing down too much PFADD,
  998. # which is O(N) with the sparse encoding. The value can be raised to
  999. # ~ 10000 when CPU is not a concern, but space is, and the data set is
  1000. # composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
  1001. hll-sparse-max-bytes 3000
  1002. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
  1003. # order to help rehashing the main Redis hash table (the one mapping top-level
  1004. # keys to values). The hash table implementation Redis uses (see dict.c)
  1005. # performs a lazy rehashing: the more operation you run into a hash table
  1006. # that is rehashing, the more rehashing "steps" are performed, so if the
  1007. # server is idle the rehashing is never complete and some more memory is used
  1008. # by the hash table.
  1009. #
  1010. # The default is to use this millisecond 10 times every second in order to
  1011. # actively rehash the main dictionaries, freeing memory when possible.
  1012. #
  1013. # If unsure:
  1014. # use "activerehashing no" if you have hard latency requirements and it is
  1015. # not a good thing in your environment that Redis can reply from time to time
  1016. # to queries with 2 milliseconds delay.
  1017. #
  1018. # use "activerehashing yes" if you don't have such hard requirements but
  1019. # want to free memory asap when possible.
  1020. activerehashing yes
  1021. # The client output buffer limits can be used to force disconnection of clients
  1022. # that are not reading data from the server fast enough for some reason (a
  1023. # common reason is that a Pub/Sub client can't consume messages as fast as the
  1024. # publisher can produce them).
  1025. #
  1026. # The limit can be set differently for the three different classes of clients:
  1027. #
  1028. # normal -> normal clients including MONITOR clients
  1029. # slave -> slave clients
  1030. # pubsub -> clients subscribed to at least one pubsub channel or pattern
  1031. #
  1032. # The syntax of every client-output-buffer-limit directive is the following:
  1033. #
  1034. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
  1035. #
  1036. # A client is immediately disconnected once the hard limit is reached, or if
  1037. # the soft limit is reached and remains reached for the specified number of
  1038. # seconds (continuously).
  1039. # So for instance if the hard limit is 32 megabytes and the soft limit is
  1040. # 16 megabytes / 10 seconds, the client will get disconnected immediately
  1041. # if the size of the output buffers reach 32 megabytes, but will also get
  1042. # disconnected if the client reaches 16 megabytes and continuously overcomes
  1043. # the limit for 10 seconds.
  1044. #
  1045. # By default normal clients are not limited because they don't receive data
  1046. # without asking (in a push way), but just after a request, so only
  1047. # asynchronous clients may create a scenario where data is requested faster
  1048. # than it can read.
  1049. #
  1050. # Instead there is a default limit for pubsub and slave clients, since
  1051. # subscribers and slaves receive data in a push fashion.
  1052. #
  1053. # Both the hard or the soft limit can be disabled by setting them to zero.
  1054. client-output-buffer-limit normal 0 0 0
  1055. client-output-buffer-limit slave 256mb 64mb 60
  1056. client-output-buffer-limit pubsub 32mb 8mb 60
  1057. # Client query buffers accumulate new commands. They are limited to a fixed
  1058. # amount by default in order to avoid that a protocol desynchronization (for
  1059. # instance due to a bug in the client) will lead to unbound memory usage in
  1060. # the query buffer. However you can configure it here if you have very special
  1061. # needs, such us huge multi/exec requests or alike.
  1062. #
  1063. # client-query-buffer-limit 1gb
  1064. # In the Redis protocol, bulk requests, that are, elements representing single
  1065. # strings, are normally limited ot 512 mb. However you can change this limit
  1066. # here.
  1067. #
  1068. # proto-max-bulk-len 512mb
  1069. # Redis calls an internal function to perform many background tasks, like
  1070. # closing connections of clients in timeout, purging expired keys that are
  1071. # never requested, and so forth.
  1072. #
  1073. # Not all tasks are performed with the same frequency, but Redis checks for
  1074. # tasks to perform according to the specified "hz" value.
  1075. #
  1076. # By default "hz" is set to 10. Raising the value will use more CPU when
  1077. # Redis is idle, but at the same time will make Redis more responsive when
  1078. # there are many keys expiring at the same time, and timeouts may be
  1079. # handled with more precision.
  1080. #
  1081. # The range is between 1 and 500, however a value over 100 is usually not
  1082. # a good idea. Most users should use the default of 10 and raise this up to
  1083. # 100 only in environments where very low latency is required.
  1084. hz 10
  1085. # When a child rewrites the AOF file, if the following option is enabled
  1086. # the file will be fsync-ed every 32 MB of data generated. This is useful
  1087. # in order to commit the file to the disk more incrementally and avoid
  1088. # big latency spikes.
  1089. aof-rewrite-incremental-fsync yes
  1090. # Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good
  1091. # idea to start with the default settings and only change them after investigating
  1092. # how to improve the performances and how the keys LFU change over time, which
  1093. # is possible to inspect via the OBJECT FREQ command.
  1094. #
  1095. # There are two tunable parameters in the Redis LFU implementation: the
  1096. # counter logarithm factor and the counter decay time. It is important to
  1097. # understand what the two parameters mean before changing them.
  1098. #
  1099. # The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis
  1100. # uses a probabilistic increment with logarithmic behavior. Given the value
  1101. # of the old counter, when a key is accessed, the counter is incremented in
  1102. # this way:
  1103. #
  1104. # 1. A random number R between 0 and 1 is extracted.
  1105. # 2. A probability P is calculated as 1/(old_value*lfu_log_factor+1).
  1106. # 3. The counter is incremented only if R < P.
  1107. #
  1108. # The default lfu-log-factor is 10. This is a table of how the frequency
  1109. # counter changes with a different number of accesses with different
  1110. # logarithmic factors:
  1111. #
  1112. # +--------+------------+------------+------------+------------+------------+
  1113. # | factor | 100 hits | 1000 hits | 100K hits | 1M hits | 10M hits |
  1114. # +--------+------------+------------+------------+------------+------------+
  1115. # | 0 | 104 | 255 | 255 | 255 | 255 |
  1116. # +--------+------------+------------+------------+------------+------------+
  1117. # | 1 | 18 | 49 | 255 | 255 | 255 |
  1118. # +--------+------------+------------+------------+------------+------------+
  1119. # | 10 | 10 | 18 | 142 | 255 | 255 |
  1120. # +--------+------------+------------+------------+------------+------------+
  1121. # | 100 | 8 | 11 | 49 | 143 | 255 |
  1122. # +--------+------------+------------+------------+------------+------------+
  1123. #
  1124. # NOTE: The above table was obtained by running the following commands:
  1125. #
  1126. # redis-benchmark -n 1000000 incr foo
  1127. # redis-cli object freq foo
  1128. #
  1129. # NOTE 2: The counter initial value is 5 in order to give new objects a chance
  1130. # to accumulate hits.
  1131. #
  1132. # The counter decay time is the time, in minutes, that must elapse in order
  1133. # for the key counter to be divided by two (or decremented if it has a value
  1134. # less <= 10).
  1135. #
  1136. # The default value for the lfu-decay-time is 1. A Special value of 0 means to
  1137. # decay the counter every time it happens to be scanned.
  1138. #
  1139. # lfu-log-factor 10
  1140. # lfu-decay-time 1
  1141. ########################### ACTIVE DEFRAGMENTATION #######################
  1142. #
  1143. # WARNING THIS FEATURE IS EXPERIMENTAL. However it was stress tested
  1144. # even in production and manually tested by multiple engineers for some
  1145. # time.
  1146. #
  1147. # What is active defragmentation?
  1148. # -------------------------------
  1149. #
  1150. # Active (online) defragmentation allows a Redis server to compact the
  1151. # spaces left between small allocations and deallocations of data in memory,
  1152. # thus allowing to reclaim back memory.
  1153. #
  1154. # Fragmentation is a natural process that happens with every allocator (but
  1155. # less so with Jemalloc, fortunately) and certain workloads. Normally a server
  1156. # restart is needed in order to lower the fragmentation, or at least to flush
  1157. # away all the data and create it again. However thanks to this feature
  1158. # implemented by Oran Agra for Redis 4.0 this process can happen at runtime
  1159. # in an "hot" way, while the server is running.
  1160. #
  1161. # Basically when the fragmentation is over a certain level (see the
  1162. # configuration options below) Redis will start to create new copies of the
  1163. # values in contiguous memory regions by exploiting certain specific Jemalloc
  1164. # features (in order to understand if an allocation is causing fragmentation
  1165. # and to allocate it in a better place), and at the same time, will release the
  1166. # old copies of the data. This process, repeated incrementally for all the keys
  1167. # will cause the fragmentation to drop back to normal values.
  1168. #
  1169. # Important things to understand:
  1170. #
  1171. # 1. This feature is disabled by default, and only works if you compiled Redis
  1172. # to use the copy of Jemalloc we ship with the source code of Redis.
  1173. # This is the default with Linux builds.
  1174. #
  1175. # 2. You never need to enable this feature if you don't have fragmentation
  1176. # issues.
  1177. #
  1178. # 3. Once you experience fragmentation, you can enable this feature when
  1179. # needed with the command "CONFIG SET activedefrag yes".
  1180. #
  1181. # The configuration parameters are able to fine tune the behavior of the
  1182. # defragmentation process. If you are not sure about what they mean it is
  1183. # a good idea to leave the defaults untouched.
  1184. # Enabled active defragmentation
  1185. # activedefrag yes
  1186. # Minimum amount of fragmentation waste to start active defrag
  1187. # active-defrag-ignore-bytes 100mb
  1188. # Minimum percentage of fragmentation to start active defrag
  1189. # active-defrag-threshold-lower 10
  1190. # Maximum percentage of fragmentation at which we use maximum effort
  1191. # active-defrag-threshold-upper 100
  1192. # Minimal effort for defrag in CPU percentage
  1193. # active-defrag-cycle-min 25
  1194. # Maximal effort for defrag in CPU percentage
  1195. # active-defrag-cycle-max 75