9210e701 |
1 | # Redis configuration file example |
2 | |
3 | # Note on units: when memory size is needed, it is possible to specifiy |
4 | # it in the usual form of 1k 5GB 4M and so forth: |
5 | # |
6 | # 1k => 1000 bytes |
7 | # 1kb => 1024 bytes |
8 | # 1m => 1000000 bytes |
9 | # 1mb => 1024*1024 bytes |
10 | # 1g => 1000000000 bytes |
11 | # 1gb => 1024*1024*1024 bytes |
12 | # |
13 | # units are case insensitive so 1GB 1Gb 1gB are all the same. |
14 | |
15 | # By default Redis does not run as a daemon. Use 'yes' if you need it. |
16 | # Note that Redis will write a pid file in /var/run/redis.pid when daemonized. |
001f8da2 |
17 | daemonize yes |
9210e701 |
18 | |
19 | # When running daemonized, Redis writes a pid file in /var/run/redis.pid by |
20 | # default. You can specify a custom pid file location here. |
9a01957f |
21 | pidfile $PIDFILE |
9210e701 |
22 | |
23 | # Accept connections on the specified port, default is 6379. |
24 | # If port 0 is specified Redis will not listen on a TCP socket. |
25 | port $REDIS_PORT |
26 | |
27 | # If you want you can bind a single interface, if the bind option is not |
28 | # specified all the interfaces will listen for incoming connections. |
29 | # |
30 | # bind 127.0.0.1 |
31 | |
32 | # Specify the path for the unix socket that will be used to listen for |
33 | # incoming connections. There is no default, so Redis will not listen |
34 | # on a unix socket when not specified. |
35 | # |
36 | # unixsocket /tmp/redis.sock |
37 | |
38 | # Close the connection after a client is idle for N seconds (0 to disable) |
39 | timeout 300 |
40 | |
41 | # Set server verbosity to 'debug' |
42 | # it can be one of: |
43 | # debug (a lot of information, useful for development/testing) |
44 | # verbose (many rarely useful info, but not a mess like the debug level) |
45 | # notice (moderately verbose, what you want in production probably) |
46 | # warning (only very important / critical messages are logged) |
47 | loglevel verbose |
48 | |
49 | # Specify the log file name. Also 'stdout' can be used to force |
50 | # Redis to log on the standard output. Note that if you use standard |
51 | # output for logging but daemonize, logs will be sent to /dev/null |
52 | logfile $REDIS_LOG_FILE |
53 | |
54 | # To enable logging to the system logger, just set 'syslog-enabled' to yes, |
55 | # and optionally update the other syslog parameters to suit your needs. |
56 | # syslog-enabled no |
57 | |
58 | # Specify the syslog identity. |
59 | # syslog-ident redis |
60 | |
61 | # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7. |
62 | # syslog-facility local0 |
63 | |
64 | # Set the number of databases. The default database is DB 0, you can select |
65 | # a different one on a per-connection basis using SELECT <dbid> where |
66 | # dbid is a number between 0 and 'databases'-1 |
67 | databases 16 |
68 | |
69 | ################################ SNAPSHOTTING ################################# |
70 | # |
71 | # Save the DB on disk: |
72 | # |
73 | # save <seconds> <changes> |
74 | # |
75 | # Will save the DB if both the given number of seconds and the given |
76 | # number of write operations against the DB occurred. |
77 | # |
78 | # In the example below the behaviour will be to save: |
79 | # after 900 sec (15 min) if at least 1 key changed |
80 | # after 300 sec (5 min) if at least 10 keys changed |
81 | # after 60 sec if at least 10000 keys changed |
82 | # |
83 | # Note: you can disable saving at all commenting all the "save" lines. |
84 | |
85 | save 900 1 |
86 | save 300 10 |
87 | save 60 10000 |
88 | |
89 | # Compress string objects using LZF when dump .rdb databases? |
90 | # For default that's set to 'yes' as it's almost always a win. |
91 | # If you want to save some CPU in the saving child set it to 'no' but |
92 | # the dataset will likely be bigger if you have compressible values or keys. |
93 | rdbcompression yes |
94 | |
95 | # The filename where to dump the DB |
96 | dbfilename dump.rdb |
97 | |
98 | # The working directory. |
99 | # |
100 | # The DB will be written inside this directory, with the filename specified |
101 | # above using the 'dbfilename' configuration directive. |
102 | # |
103 | # Also the Append Only File will be created inside this directory. |
104 | # |
105 | # Note that you must specify a directory here, not a file name. |
106 | dir $REDIS_DATA_DIR |
107 | |
108 | ################################# REPLICATION ################################# |
109 | |
110 | # Master-Slave replication. Use slaveof to make a Redis instance a copy of |
111 | # another Redis server. Note that the configuration is local to the slave |
112 | # so for example it is possible to configure the slave to save the DB with a |
113 | # different interval, or to listen to another port, and so on. |
114 | # |
115 | # slaveof <masterip> <masterport> |
116 | |
117 | # If the master is password protected (using the "requirepass" configuration |
118 | # directive below) it is possible to tell the slave to authenticate before |
119 | # starting the replication synchronization process, otherwise the master will |
120 | # refuse the slave request. |
121 | # |
122 | # masterauth <master-password> |
123 | |
124 | # When a slave lost the connection with the master, or when the replication |
125 | # is still in progress, the slave can act in two different ways: |
126 | # |
127 | # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will |
128 | # still reply to client requests, possibly with out of data data, or the |
129 | # data set may just be empty if this is the first synchronization. |
130 | # |
131 | # 2) if slave-serve-stale data is set to 'no' the slave will reply with |
132 | # an error "SYNC with master in progress" to all the kind of commands |
133 | # but to INFO and SLAVEOF. |
134 | # |
135 | slave-serve-stale-data yes |
136 | |
137 | ################################## SECURITY ################################### |
138 | |
139 | # Require clients to issue AUTH <PASSWORD> before processing any other |
140 | # commands. This might be useful in environments in which you do not trust |
141 | # others with access to the host running redis-server. |
142 | # |
143 | # This should stay commented out for backward compatibility and because most |
144 | # people do not need auth (e.g. they run their own servers). |
145 | # |
146 | # Warning: since Redis is pretty fast an outside user can try up to |
147 | # 150k passwords per second against a good box. This means that you should |
148 | # use a very strong password otherwise it will be very easy to break. |
149 | # |
150 | # requirepass foobared |
151 | |
152 | # Command renaming. |
153 | # |
154 | # It is possilbe to change the name of dangerous commands in a shared |
155 | # environment. For instance the CONFIG command may be renamed into something |
156 | # of hard to guess so that it will be still available for internal-use |
157 | # tools but not available for general clients. |
158 | # |
159 | # Example: |
160 | # |
161 | # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52 |
162 | # |
163 | # It is also possilbe to completely kill a command renaming it into |
164 | # an empty string: |
165 | # |
166 | # rename-command CONFIG "" |
167 | |
168 | ################################### LIMITS #################################### |
169 | |
170 | # Set the max number of connected clients at the same time. By default there |
171 | # is no limit, and it's up to the number of file descriptors the Redis process |
172 | # is able to open. The special value '0' means no limits. |
173 | # Once the limit is reached Redis will close all the new connections sending |
174 | # an error 'max number of clients reached'. |
175 | # |
176 | # maxclients 128 |
177 | |
178 | # Don't use more memory than the specified amount of bytes. |
179 | # When the memory limit is reached Redis will try to remove keys with an |
180 | # EXPIRE set. It will try to start freeing keys that are going to expire |
181 | # in little time and preserve keys with a longer time to live. |
182 | # Redis will also try to remove objects from free lists if possible. |
183 | # |
184 | # If all this fails, Redis will start to reply with errors to commands |
185 | # that will use more memory, like SET, LPUSH, and so on, and will continue |
186 | # to reply to most read-only commands like GET. |
187 | # |
188 | # WARNING: maxmemory can be a good idea mainly if you want to use Redis as a |
189 | # 'state' server or cache, not as a real DB. When Redis is used as a real |
190 | # database the memory usage will grow over the weeks, it will be obvious if |
191 | # it is going to use too much memory in the long run, and you'll have the time |
192 | # to upgrade. With maxmemory after the limit is reached you'll start to get |
193 | # errors for write operations, and this may even lead to DB inconsistency. |
194 | # |
195 | # maxmemory <bytes> |
196 | |
197 | # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory |
198 | # is reached? You can select among five behavior: |
199 | # |
200 | # volatile-lru -> remove the key with an expire set using an LRU algorithm |
201 | # allkeys-lru -> remove any key accordingly to the LRU algorithm |
202 | # volatile-random -> remove a random key with an expire set |
203 | # allkeys->random -> remove a random key, any key |
204 | # volatile-ttl -> remove the key with the nearest expire time (minor TTL) |
205 | # noeviction -> don't expire at all, just return an error on write operations |
206 | # |
207 | # Note: with all the kind of policies, Redis will return an error on write |
208 | # operations, when there are not suitable keys for eviction. |
209 | # |
210 | # At the date of writing this commands are: set setnx setex append |
211 | # incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd |
212 | # sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby |
213 | # zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby |
214 | # getset mset msetnx exec sort |
215 | # |
216 | # The default is: |
217 | # |
218 | # maxmemory-policy volatile-lru |
219 | |
220 | # LRU and minimal TTL algorithms are not precise algorithms but approximated |
221 | # algorithms (in order to save memory), so you can select as well the sample |
222 | # size to check. For instance for default Redis will check three keys and |
223 | # pick the one that was used less recently, you can change the sample size |
224 | # using the following configuration directive. |
225 | # |
226 | # maxmemory-samples 3 |
227 | |
228 | ############################## APPEND ONLY MODE ############################### |
229 | |
230 | # By default Redis asynchronously dumps the dataset on disk. If you can live |
231 | # with the idea that the latest records will be lost if something like a crash |
232 | # happens this is the preferred way to run Redis. If instead you care a lot |
233 | # about your data and don't want to that a single record can get lost you should |
234 | # enable the append only mode: when this mode is enabled Redis will append |
235 | # every write operation received in the file appendonly.aof. This file will |
236 | # be read on startup in order to rebuild the full dataset in memory. |
237 | # |
238 | # Note that you can have both the async dumps and the append only file if you |
239 | # like (you have to comment the "save" statements above to disable the dumps). |
240 | # Still if append only mode is enabled Redis will load the data from the |
241 | # log file at startup ignoring the dump.rdb file. |
242 | # |
243 | # IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append |
244 | # log file in background when it gets too big. |
245 | |
246 | appendonly no |
247 | |
248 | # The name of the append only file (default: "appendonly.aof") |
249 | # appendfilename appendonly.aof |
250 | |
251 | # The fsync() call tells the Operating System to actually write data on disk |
252 | # instead to wait for more data in the output buffer. Some OS will really flush |
253 | # data on disk, some other OS will just try to do it ASAP. |
254 | # |
255 | # Redis supports three different modes: |
256 | # |
257 | # no: don't fsync, just let the OS flush the data when it wants. Faster. |
258 | # always: fsync after every write to the append only log . Slow, Safest. |
259 | # everysec: fsync only if one second passed since the last fsync. Compromise. |
260 | # |
261 | # The default is "everysec" that's usually the right compromise between |
262 | # speed and data safety. It's up to you to understand if you can relax this to |
263 | # "no" that will will let the operating system flush the output buffer when |
264 | # it wants, for better performances (but if you can live with the idea of |
265 | # some data loss consider the default persistence mode that's snapshotting), |
266 | # or on the contrary, use "always" that's very slow but a bit safer than |
267 | # everysec. |
268 | # |
269 | # If unsure, use "everysec". |
270 | |
271 | # appendfsync always |
272 | appendfsync everysec |
273 | # appendfsync no |
274 | |
275 | # When the AOF fsync policy is set to always or everysec, and a background |
276 | # saving process (a background save or AOF log background rewriting) is |
277 | # performing a lot of I/O against the disk, in some Linux configurations |
278 | # Redis may block too long on the fsync() call. Note that there is no fix for |
279 | # this currently, as even performing fsync in a different thread will block |
280 | # our synchronous write(2) call. |
281 | # |
282 | # In order to mitigate this problem it's possible to use the following option |
283 | # that will prevent fsync() from being called in the main process while a |
284 | # BGSAVE or BGREWRITEAOF is in progress. |
285 | # |
286 | # This means that while another child is saving the durability of Redis is |
287 | # the same as "appendfsync none", that in pratical terms means that it is |
288 | # possible to lost up to 30 seconds of log in the worst scenario (with the |
289 | # default Linux settings). |
290 | # |
291 | # If you have latency problems turn this to "yes". Otherwise leave it as |
292 | # "no" that is the safest pick from the point of view of durability. |
293 | no-appendfsync-on-rewrite no |
294 | |
295 | # Automatic rewrite of the append only file. |
296 | # Redis is able to automatically rewrite the log file implicitly calling |
297 | # BGREWRITEAOF when the AOF log size will growth by the specified percentage. |
298 | # |
299 | # This is how it works: Redis remembers the size of the AOF file after the |
300 | # latest rewrite (or if no rewrite happened since the restart, the size of |
301 | # the AOF at startup is used). |
302 | # |
303 | # This base size is compared to the current size. If the current size is |
304 | # bigger than the specified percentage, the rewrite is triggered. Also |
305 | # you need to specify a minimal size for the AOF file to be rewritten, this |
306 | # is useful to avoid rewriting the AOF file even if the percentage increase |
307 | # is reached but it is still pretty small. |
308 | # |
309 | # Specify a precentage of zero in order to disable the automatic AOF |
310 | # rewrite feature. |
311 | |
312 | auto-aof-rewrite-percentage 100 |
313 | auto-aof-rewrite-min-size 64mb |
314 | |
315 | ################################ LUA SCRIPTING ############################### |
316 | |
317 | # Max execution time of a Lua script in milliseconds. |
318 | # This prevents that a programming error generating an infinite loop will block |
319 | # your server forever. Set it to 0 or a negative value for unlimited execution. |
001f8da2 |
320 | #lua-time-limit 60000 |
9210e701 |
321 | |
322 | ################################## SLOW LOG ################################### |
323 | |
324 | # The Redis Slow Log is a system to log queries that exceeded a specified |
325 | # execution time. The execution time does not include the I/O operations |
326 | # like talking with the client, sending the reply and so forth, |
327 | # but just the time needed to actually execute the command (this is the only |
328 | # stage of command execution where the thread is blocked and can not serve |
329 | # other requests in the meantime). |
330 | # |
331 | # You can configure the slow log with two parameters: one tells Redis |
332 | # what is the execution time, in microseconds, to exceed in order for the |
333 | # command to get logged, and the other parameter is the length of the |
334 | # slow log. When a new command is logged the oldest one is removed from the |
335 | # queue of logged commands. |
336 | |
337 | # The following time is expressed in microseconds, so 1000000 is equivalent |
338 | # to one second. Note that a negative number disables the slow log, while |
339 | # a value of zero forces the logging of every command. |
340 | slowlog-log-slower-than 10000 |
341 | |
342 | # There is no limit to this length. Just be aware that it will consume memory. |
343 | # You can reclaim memory used by the slow log with SLOWLOG RESET. |
344 | slowlog-max-len 1024 |
345 | |
346 | ############################### ADVANCED CONFIG ############################### |
347 | |
348 | # Hashes are encoded in a special way (much more memory efficient) when they |
349 | # have at max a given numer of elements, and the biggest element does not |
350 | # exceed a given threshold. You can configure this limits with the following |
351 | # configuration directives. |
352 | hash-max-zipmap-entries 512 |
353 | hash-max-zipmap-value 64 |
354 | |
355 | # Similarly to hashes, small lists are also encoded in a special way in order |
356 | # to save a lot of space. The special representation is only used when |
357 | # you are under the following limits: |
358 | list-max-ziplist-entries 512 |
359 | list-max-ziplist-value 64 |
360 | |
361 | # Sets have a special encoding in just one case: when a set is composed |
362 | # of just strings that happens to be integers in radix 10 in the range |
363 | # of 64 bit signed integers. |
364 | # The following configuration setting sets the limit in the size of the |
365 | # set in order to use this special memory saving encoding. |
366 | set-max-intset-entries 512 |
367 | |
368 | # Similarly to hashes and lists, sorted sets are also specially encoded in |
369 | # order to save a lot of space. This encoding is only used when the length and |
370 | # elements of a sorted set are below the following limits: |
371 | zset-max-ziplist-entries 128 |
372 | zset-max-ziplist-value 64 |
373 | |
374 | # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in |
375 | # order to help rehashing the main Redis hash table (the one mapping top-level |
376 | # keys to values). The hash table implementation redis uses (see dict.c) |
377 | # performs a lazy rehashing: the more operation you run into an hash table |
378 | # that is rhashing, the more rehashing "steps" are performed, so if the |
379 | # server is idle the rehashing is never complete and some more memory is used |
380 | # by the hash table. |
381 | # |
382 | # The default is to use this millisecond 10 times every second in order to |
383 | # active rehashing the main dictionaries, freeing memory when possible. |
384 | # |
385 | # If unsure: |
386 | # use "activerehashing no" if you have hard latency requirements and it is |
387 | # not a good thing in your environment that Redis can reply form time to time |
388 | # to queries with 2 milliseconds delay. |
389 | # |
390 | # use "activerehashing yes" if you don't have such hard requirements but |
391 | # want to free memory asap when possible. |
392 | activerehashing yes |
393 | |
394 | ################################## INCLUDES ################################### |
395 | |
396 | # Include one or more other config files here. This is useful if you |
397 | # have a standard template that goes to all redis server but also need |
398 | # to customize a few per-server settings. Include files can include |
399 | # other files, so use this wisely. |
400 | # |
401 | # include /path/to/local.conf |
402 | # include /path/to/other.conf |