1. # Redis configuration file example
2. # Note on units: when memory size is needed, it is possible to specify
3. # it in the usual form of 1k 5GB 4M and so forth:
4. #
5. # 1k => 1000 bytes
6. # 1kb => 1024 bytes
7. # 1m => 1000000 bytes
8. # 1mb => 1024*1024 bytes
9. # 1g => 1000000000 bytes
10. # 1gb => 1024*1024*1024 bytes
11. #
12. # units are case insensitive so 1GB 1Gb 1gB are all the same.
13. # By default Redis does not run as a daemon. Use 'yes' if you need it.
14. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
15. daemonize no
16. # When running daemonized, Redis writes a pid file in /var/run/redis.pid by
17. # default. You can specify a custom pid file location here.
18. pidfile /var/run/redis.pid
19. # Accept connections on the specified port, default is 6379.
20. # If port 0 is specified Redis will not listen on a TCP socket.
21. port 6379
22. # If you want you can bind a single interface, if the bind option is not
23. # specified all the interfaces will listen for incoming connections.
24. #
25. # bind 127.0.0.1
26. # Specify the path for the unix socket that will be used to listen for
27. # incoming connections. There is no default, so Redis will not listen
28. # on a unix socket when not specified.
29. #
30. # unixsocket /tmp/redis.sock
31. # unixsocketperm 755
32. # Close the connection after a client is idle for N seconds (0 to disable)
33. timeout 0
34. # TCP keepalive.
35. #
36. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
37. # of communication. This is useful for two reasons:
38. #
39. # 1) Detect dead peers.
40. # 2) Take the connection alive from the point of view of network
41. #    equipment in the middle.
42. #
43. # On Linux, the specified value (in seconds) is the period used to send ACKs.
44. # Note that to close the connection the double of the time is needed.
45. # On other kernels the period depends on the kernel configuration.
46. #
47. # A reasonable value for this option is 60 seconds.
48. tcp-keepalive 0
49. # Specify the server verbosity level.
50. # This can be one of:
51. # debug (a lot of information, useful for development/testing)
52. # verbose (many rarely useful info, but not a mess like the debug level)
53. # notice (moderately verbose, what you want in production probably)
54. # warning (only very important / critical messages are logged)
55. loglevel notice
56. # Specify the log file name. Also 'stdout' can be used to force
57. # Redis to log on the standard output. Note that if you use standard
58. # output for logging but daemonize, logs will be sent to /dev/null
59. logfile stdout
60. # To enable logging to the system logger, just set 'syslog-enabled' to yes,
61. # and optionally update the other syslog parameters to suit your needs.
62. # syslog-enabled no
63. # Specify the syslog identity.
64. # syslog-ident redis
65. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
66. # syslog-facility local0
67. # Set the number of databases. The default database is DB 0, you can select
68. # a different one on a per-connection basis using SELECT <dbid> where
69. # dbid is a number between 0 and 'databases'-1
70. databases 16
71. ################################ SNAPSHOTTING  #################################
72. #
73. # Save the DB on disk:
74. #
75. #   save <seconds> <changes>
76. #
77. #   Will save the DB if both the given number of seconds and the given
78. #   number of write operations against the DB occurred.
79. #
80. #   In the example below the behaviour will be to save:
81. #   after 900 sec (15 min) if at least 1 key changed
82. #   after 300 sec (5 min) if at least 10 keys changed
83. #   after 60 sec if at least 10000 keys changed
84. #
85. #   Note: you can disable saving at all commenting all the "save" lines.
86. #
87. #   It is also possible to remove all the previously configured save
88. #   points by adding a save directive with a single empty string argument
89. #   like in the following example:
90. #
91. #   save ""
92. save 900 1
93. save 300 10
94. save 60 10000
95. # By default Redis will stop accepting writes if RDB snapshots are enabled
96. # (at least one save point) and the latest background save failed.
97. # This will make the user aware (in an hard way) that data is not persisting
98. # on disk properly, otherwise chances are that no one will notice and some
99. # distater will happen.
100. #
101. # If the background saving process will start working again Redis will
102. # automatically allow writes again.
103. #
104. # However if you have setup your proper monitoring of the Redis server
105. # and persistence, you may want to disable this feature so that Redis will
106. # continue to work as usually even if there are problems with disk,
107. # permissions, and so forth.
108. stop-writes-on-bgsave-error yes
109. # Compress string objects using LZF when dump .rdb databases?
110. # For default that's set to 'yes' as it's almost always a win.
111. # If you want to save some CPU in the saving child set it to 'no' but
112. # the dataset will likely be bigger if you have compressible values or keys.
113. rdbcompression yes
114. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
115. # This makes the format more resistant to corruption but there is a performance
116. # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
117. # for maximum performances.
118. #
119. # RDB files created with checksum disabled have a checksum of zero that will
120. # tell the loading code to skip the check.
121. rdbchecksum yes
122. # The filename where to dump the DB
123. dbfilename dump.rdb
124. # The working directory.
125. #
126. # The DB will be written inside this directory, with the filename specified
127. # above using the 'dbfilename' configuration directive.
128. #
129. # The Append Only File will also be created inside this directory.
130. #
131. # Note that you must specify a directory here, not a file name.
132. dir ./
133. ################################# REPLICATION #################################
134. # Master-Slave replication. Use slaveof to make a Redis instance a copy of
135. # another Redis server. Note that the configuration is local to the slave
136. # so for example it is possible to configure the slave to save the DB with a
137. # different interval, or to listen to another port, and so on.
138. #
139. # slaveof <masterip> <masterport>
140. # If the master is password protected (using the "requirepass" configuration
141. # directive below) it is possible to tell the slave to authenticate before
142. # starting the replication synchronization process, otherwise the master will
143. # refuse the slave request.
144. #
145. # masterauth <master-password>
146. # When a slave loses its connection with the master, or when the replication
147. # is still in progress, the slave can act in two different ways:
148. #
149. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
150. #    still reply to client requests, possibly with out of date data, or the
151. #    data set may just be empty if this is the first synchronization.
152. #
153. # 2) if slave-serve-stale-data is set to 'no' the slave will reply with
154. #    an error "SYNC with master in progress" to all the kind of commands
155. #    but to INFO and SLAVEOF.
156. #
157. slave-serve-stale-data yes
158. # You can configure a slave instance to accept writes or not. Writing against
159. # a slave instance may be useful to store some ephemeral data (because data
160. # written on a slave will be easily deleted after resync with the master) but
161. # may also cause problems if clients are writing to it because of a
162. # misconfiguration.
163. #
164. # Since Redis 2.6 by default slaves are read-only.
165. #
166. # Note: read only slaves are not designed to be exposed to untrusted clients
167. # on the internet. It's just a protection layer against misuse of the instance.
168. # Still a read only slave exports by default all the administrative commands
169. # such as CONFIG, DEBUG, and so forth. To a limited extend you can improve
170. # security of read only slaves using 'rename-command' to shadow all the
171. # administrative / dangerous commands.
172. slave-read-only yes
173. # Slaves send PINGs to server in a predefined interval. It's possible to change
174. # this interval with the repl_ping_slave_period option. The default value is 10
175. # seconds.
176. #
177. # repl-ping-slave-period 10
178. # The following option sets a timeout for both Bulk transfer I/O timeout and
179. # master data or ping response timeout. The default value is 60 seconds.
180. #
181. # It is important to make sure that this value is greater than the value
182. # specified for repl-ping-slave-period otherwise a timeout will be detected
183. # every time there is low traffic between the master and the slave.
184. #
185. # repl-timeout 60
186. # Disable TCP_NODELAY on the slave socket after SYNC?
187. #
188. # If you select "yes" Redis will use a smaller number of TCP packets and
189. # less bandwidth to send data to slaves. But this can add a delay for
190. # the data to appear on the slave side, up to 40 milliseconds with
191. # Linux kernels using a default configuration.
192. #
193. # If you select "no" the delay for data to appear on the slave side will
194. # be reduced but more bandwidth will be used for replication.
195. #
196. # By default we optimize for low latency, but in very high traffic conditions
197. # or when the master and slaves are many hops away, turning this to "yes" may
198. # be a good idea.
199. repl-disable-tcp-nodelay no
200. # The slave priority is an integer number published by Redis in the INFO output.
201. # It is used by Redis Sentinel in order to select a slave to promote into a
202. # master if the master is no longer working correctly.
203. #
204. # A slave with a low priority number is considered better for promotion, so
205. # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
206. # pick the one wtih priority 10, that is the lowest.
207. #
208. # However a special priority of 0 marks the slave as not able to perform the
209. # role of master, so a slave with priority of 0 will never be selected by
210. # Redis Sentinel for promotion.
211. #
212. # By default the priority is 100.
213. slave-priority 100
214. ################################## SECURITY ###################################
215. # Require clients to issue AUTH <PASSWORD> before processing any other
216. # commands.  This might be useful in environments in which you do not trust
217. # others with access to the host running redis-server.
218. #
219. # This should stay commented out for backward compatibility and because most
220. # people do not need auth (e.g. they run their own servers).
221. #
222. # Warning: since Redis is pretty fast an outside user can try up to
223. # 150k passwords per second against a good box. This means that you should
224. # use a very strong password otherwise it will be very easy to break.
225. #
226. # requirepass foobared
227. # Command renaming.
228. #
229. # It is possible to change the name of dangerous commands in a shared
230. # environment. For instance the CONFIG command may be renamed into something
231. # hard to guess so that it will still be available for internal-use tools
232. # but not available for general clients.
233. #
234. # Example:
235. #
236. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
237. #
238. # It is also possible to completely kill a command by renaming it into
239. # an empty string:
240. #
241. # rename-command CONFIG ""
242. #
243. # Please note that changing the name of commands that are logged into the
244. # AOF file or transmitted to slaves may cause problems.
245. ################################### LIMITS ####################################
246. # Set the max number of connected clients at the same time. By default
247. # this limit is set to 10000 clients, however if the Redis server is not
248. # able to configure the process file limit to allow for the specified limit
249. # the max number of allowed clients is set to the current file limit
250. # minus 32 (as Redis reserves a few file descriptors for internal uses).
251. #
252. # Once the limit is reached Redis will close all the new connections sending
253. # an error 'max number of clients reached'.
254. #
255. # maxclients 10000
256. # Don't use more memory than the specified amount of bytes.
257. # When the memory limit is reached Redis will try to remove keys
258. # accordingly to the eviction policy selected (see maxmemmory-policy).
259. #
260. # If Redis can't remove keys according to the policy, or if the policy is
261. # set to 'noeviction', Redis will start to reply with errors to commands
262. # that would use more memory, like SET, LPUSH, and so on, and will continue
263. # to reply to read-only commands like GET.
264. #
265. # This option is usually useful when using Redis as an LRU cache, or to set
266. # an hard memory limit for an instance (using the 'noeviction' policy).
267. #
268. # WARNING: If you have slaves attached to an instance with maxmemory on,
269. # the size of the output buffers needed to feed the slaves are subtracted
270. # from the used memory count, so that network problems / resyncs will
271. # not trigger a loop where keys are evicted, and in turn the output
272. # buffer of slaves is full with DELs of keys evicted triggering the deletion
273. # of more keys, and so forth until the database is completely emptied.
274. #
275. # In short... if you have slaves attached it is suggested that you set a lower
276. # limit for maxmemory so that there is some free RAM on the system for slave
277. # output buffers (but this is not needed if the policy is 'noeviction').
278. #
279. # maxmemory <bytes>
280. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
281. # is reached. You can select among five behaviors:
282. #
283. # volatile-lru -> remove the key with an expire set using an LRU algorithm
284. # allkeys-lru -> remove any key accordingly to the LRU algorithm
285. # volatile-random -> remove a random key with an expire set
286. # allkeys-random -> remove a random key, any key
287. # volatile-ttl -> remove the key with the nearest expire time (minor TTL)
288. # noeviction -> don't expire at all, just return an error on write operations
289. #
290. # Note: with any of the above policies, Redis will return an error on write
291. #       operations, when there are not suitable keys for eviction.
292. #
293. #       At the date of writing this commands are: set setnx setex append
294. #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
295. #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
296. #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
297. #       getset mset msetnx exec sort
298. #
299. # The default is:
300. #
301. # maxmemory-policy volatile-lru
302. # LRU and minimal TTL algorithms are not precise algorithms but approximated
303. # algorithms (in order to save memory), so you can select as well the sample
304. # size to check. For instance for default Redis will check three keys and
305. # pick the one that was used less recently, you can change the sample size
306. # using the following configuration directive.
307. #
308. # maxmemory-samples 3
309. ############################## APPEND ONLY MODE ###############################
310. # By default Redis asynchronously dumps the dataset on disk. This mode is
311. # good enough in many applications, but an issue with the Redis process or
312. # a power outage may result into a few minutes of writes lost (depending on
313. # the configured save points).
314. #
315. # The Append Only File is an alternative persistence mode that provides
316. # much better durability. For instance using the default data fsync policy
317. # (see later in the config file) Redis can lose just one second of writes in a
318. # dramatic event like a server power outage, or a single write if something
319. # wrong with the Redis process itself happens, but the operating system is
320. # still running correctly.
321. #
322. # AOF and RDB persistence can be enabled at the same time without problems.
323. # If the AOF is enabled on startup Redis will load the AOF, that is the file
324. # with the better durability guarantees.
325. #
326. # Please check http://redis.io/topics/persistence for more information.
327. appendonly no
328. # The name of the append only file (default: "appendonly.aof")
329. # appendfilename appendonly.aof
330. # The fsync() call tells the Operating System to actually write data on disk
331. # instead to wait for more data in the output buffer. Some OS will really flush
332. # data on disk, some other OS will just try to do it ASAP.
333. #
334. # Redis supports three different modes:
335. #
336. # no: don't fsync, just let the OS flush the data when it wants. Faster.
337. # always: fsync after every write to the append only log . Slow, Safest.
338. # everysec: fsync only one time every second. Compromise.
339. #
340. # The default is "everysec", as that's usually the right compromise between
341. # speed and data safety. It's up to you to understand if you can relax this to
342. # "no" that will let the operating system flush the output buffer when
343. # it wants, for better performances (but if you can live with the idea of
344. # some data loss consider the default persistence mode that's snapshotting),
345. # or on the contrary, use "always" that's very slow but a bit safer than
346. # everysec.
347. #
348. # More details please check the following article:
349. # http://antirez.com/post/redis-persistence-demystified.html
350. #
351. # If unsure, use "everysec".
352. # appendfsync always
353. appendfsync everysec
354. # appendfsync no
355. # When the AOF fsync policy is set to always or everysec, and a background
356. # saving process (a background save or AOF log background rewriting) is
357. # performing a lot of I/O against the disk, in some Linux configurations
358. # Redis may block too long on the fsync() call. Note that there is no fix for
359. # this currently, as even performing fsync in a different thread will block
360. # our synchronous write(2) call.
361. #
362. # In order to mitigate this problem it's possible to use the following option
363. # that will prevent fsync() from being called in the main process while a
364. # BGSAVE or BGREWRITEAOF is in progress.
365. #
366. # This means that while another child is saving, the durability of Redis is
367. # the same as "appendfsync none". In practical terms, this means that it is
368. # possible to lose up to 30 seconds of log in the worst scenario (with the
369. # default Linux settings).
370. #
371. # If you have latency problems turn this to "yes". Otherwise leave it as
372. # "no" that is the safest pick from the point of view of durability.
373. no-appendfsync-on-rewrite no
374. # Automatic rewrite of the append only file.
375. # Redis is able to automatically rewrite the log file implicitly calling
376. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
377. #
378. # This is how it works: Redis remembers the size of the AOF file after the
379. # latest rewrite (if no rewrite has happened since the restart, the size of
380. # the AOF at startup is used).
381. #
382. # This base size is compared to the current size. If the current size is
383. # bigger than the specified percentage, the rewrite is triggered. Also
384. # you need to specify a minimal size for the AOF file to be rewritten, this
385. # is useful to avoid rewriting the AOF file even if the percentage increase
386. # is reached but it is still pretty small.
387. #
388. # Specify a percentage of zero in order to disable the automatic AOF
389. # rewrite feature.
390. auto-aof-rewrite-percentage 100
391. auto-aof-rewrite-min-size 64mb
392. ################################ LUA SCRIPTING  ###############################
393. # Max execution time of a Lua script in milliseconds.
394. #
395. # If the maximum execution time is reached Redis will log that a script is
396. # still in execution after the maximum allowed time and will start to
397. # reply to queries with an error.
398. #
399. # When a long running script exceed the maximum execution time only the
400. # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
401. # used to stop a script that did not yet called write commands. The second
402. # is the only way to shut down the server in the case a write commands was
403. # already issue by the script but the user don't want to wait for the natural
404. # termination of the script.
405. #
406. # Set it to 0 or a negative value for unlimited execution without warnings.
407. lua-time-limit 5000
408. ################################## SLOW LOG ###################################
409. # The Redis Slow Log is a system to log queries that exceeded a specified
410. # execution time. The execution time does not include the I/O operations
411. # like talking with the client, sending the reply and so forth,
412. # but just the time needed to actually execute the command (this is the only
413. # stage of command execution where the thread is blocked and can not serve
414. # other requests in the meantime).
415. #
416. # You can configure the slow log with two parameters: one tells Redis
417. # what is the execution time, in microseconds, to exceed in order for the
418. # command to get logged, and the other parameter is the length of the
419. # slow log. When a new command is logged the oldest one is removed from the
420. # queue of logged commands.
421. # The following time is expressed in microseconds, so 1000000 is equivalent
422. # to one second. Note that a negative number disables the slow log, while
423. # a value of zero forces the logging of every command.
424. slowlog-log-slower-than 10000
425. # There is no limit to this length. Just be aware that it will consume memory.
426. # You can reclaim memory used by the slow log with SLOWLOG RESET.
427. slowlog-max-len 128
428. ############################### ADVANCED CONFIG ###############################
429. # Hashes are encoded using a memory efficient data structure when they have a
430. # small number of entries, and the biggest entry does not exceed a given
431. # threshold. These thresholds can be configured using the following directives.
432. hash-max-ziplist-entries 512
433. hash-max-ziplist-value 64
434. # Similarly to hashes, small lists are also encoded in a special way in order
435. # to save a lot of space. The special representation is only used when
436. # you are under the following limits:
437. list-max-ziplist-entries 512
438. list-max-ziplist-value 64
439. # Sets have a special encoding in just one case: when a set is composed
440. # of just strings that happens to be integers in radix 10 in the range
441. # of 64 bit signed integers.
442. # The following configuration setting sets the limit in the size of the
443. # set in order to use this special memory saving encoding.
444. set-max-intset-entries 512
445. # Similarly to hashes and lists, sorted sets are also specially encoded in
446. # order to save a lot of space. This encoding is only used when the length and
447. # elements of a sorted set are below the following limits:
448. zset-max-ziplist-entries 128
449. zset-max-ziplist-value 64
450. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
451. # order to help rehashing the main Redis hash table (the one mapping top-level
452. # keys to values). The hash table implementation Redis uses (see dict.c)
453. # performs a lazy rehashing: the more operation you run into an hash table
454. # that is rehashing, the more rehashing "steps" are performed, so if the
455. # server is idle the rehashing is never complete and some more memory is used
456. # by the hash table.
457. #
458. # The default is to use this millisecond 10 times every second in order to
459. # active rehashing the main dictionaries, freeing memory when possible.
460. #
461. # If unsure:
462. # use "activerehashing no" if you have hard latency requirements and it is
463. # not a good thing in your environment that Redis can reply form time to time
464. # to queries with 2 milliseconds delay.
465. #
466. # use "activerehashing yes" if you don't have such hard requirements but
467. # want to free memory asap when possible.
468. activerehashing yes
469. # The client output buffer limits can be used to force disconnection of clients
470. # that are not reading data from the server fast enough for some reason (a
471. # common reason is that a Pub/Sub client can't consume messages as fast as the
472. # publisher can produce them).
473. #
474. # The limit can be set differently for the three different classes of clients:
475. #
476. # normal -> normal clients
477. # slave  -> slave clients and MONITOR clients
478. # pubsub -> clients subcribed to at least one pubsub channel or pattern
479. #
480. # The syntax of every client-output-buffer-limit directive is the following:
481. #
482. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
483. #
484. # A client is immediately disconnected once the hard limit is reached, or if
485. # the soft limit is reached and remains reached for the specified number of
486. # seconds (continuously).
487. # So for instance if the hard limit is 32 megabytes and the soft limit is
488. # 16 megabytes / 10 seconds, the client will get disconnected immediately
489. # if the size of the output buffers reach 32 megabytes, but will also get
490. # disconnected if the client reaches 16 megabytes and continuously overcomes
491. # the limit for 10 seconds.
492. #
493. # By default normal clients are not limited because they don't receive data
494. # without asking (in a push way), but just after a request, so only
495. # asynchronous clients may create a scenario where data is requested faster
496. # than it can read.
497. #
498. # Instead there is a default limit for pubsub and slave clients, since
499. # subscribers and slaves receive data in a push fashion.
500. #
501. # Both the hard or the soft limit can be disabled by setting them to zero.
502. client-output-buffer-limit normal 0 0 0
503. client-output-buffer-limit slave 256mb 64mb 60
504. client-output-buffer-limit pubsub 32mb 8mb 60
505. # Redis calls an internal function to perform many background tasks, like
506. # closing connections of clients in timeot, purging expired keys that are
507. # never requested, and so forth.
508. #
509. # Not all tasks are perforemd with the same frequency, but Redis checks for
510. # tasks to perform accordingly to the specified "hz" value.
511. #
512. # By default "hz" is set to 10. Raising the value will use more CPU when
513. # Redis is idle, but at the same time will make Redis more responsive when
514. # there are many keys expiring at the same time, and timeouts may be
515. # handled with more precision.
516. #
517. # The range is between 1 and 500, however a value over 100 is usually not
518. # a good idea. Most users should use the default of 10 and raise this up to
519. # 100 only in environments where very low latency is required.
520. hz 10
521. # When a child rewrites the AOF file, if the following option is enabled
522. # the file will be fsync-ed every 32 MB of data generated. This is useful
523. # in order to commit the file to the disk more incrementally and avoid
524. # big latency spikes.
525. aof-rewrite-incremental-fsync yes
526. ################################## INCLUDES ###################################
527. # Include one or more other config files here.  This is useful if you
528. # have a standard template that goes to all Redis server but also need
529. # to customize a few per-server settings.  Include files can include
530. # other files, so use this wisely.
531. #
532. # include /path/to/local.conf
533. # include /path/to/other.conf

redis.conf 默认配置：