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