Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Newer
Older
100644 368 lines (321 sloc) 15.187 kB
dac8d51 @evilkost redis-conf for new test case
authored
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.
17 daemonize yes
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 /var/run/redis.pid
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 6379
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 1
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 loglevel notice
49
50 # Specify the log file name. Also 'stdout' can be used to force
51 # Redis to log on the standard output. Note that if you use standard
52 # output for logging but daemonize, logs will be sent to /dev/null
53 #logfile stdout
54
55 # To enable logging to the system logger, just set 'syslog-enabled' to yes,
56 # and optionally update the other syslog parameters to suit your needs.
57 # syslog-enabled no
58
59 # Specify the syslog identity.
60 # syslog-ident redis
61
62 # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
63 # syslog-facility local0
64
65 # Set the number of databases. The default database is DB 0, you can select
66 # a different one on a per-connection basis using SELECT <dbid> where
67 # dbid is a number between 0 and 'databases'-1
68 databases 16
69
70 ################################ SNAPSHOTTING #################################
71 #
72 # Save the DB on disk:
73 #
74 # save <seconds> <changes>
75 #
76 # Will save the DB if both the given number of seconds and the given
77 # number of write operations against the DB occurred.
78 #
79 # In the example below the behaviour will be to save:
80 # after 900 sec (15 min) if at least 1 key changed
81 # after 300 sec (5 min) if at least 10 keys changed
82 # after 60 sec if at least 10000 keys changed
83 #
84 # Note: you can disable saving at all commenting all the "save" lines.
85
86 #save 900 1
87 #save 300 10
88 #save 60 10000
89
90 # Compress string objects using LZF when dump .rdb databases?
91 # For default that's set to 'yes' as it's almost always a win.
92 # If you want to save some CPU in the saving child set it to 'no' but
93 # the dataset will likely be bigger if you have compressible values or keys.
94 #rdbcompression yes
95
96 # The filename where to dump the DB
97 #dbfilename dump.rdb
98
99 # The working directory.
100 #
101 # The DB will be written inside this directory, with the filename specified
102 # above using the 'dbfilename' configuration directive.
103 #
104 # Also the Append Only File will be created inside this directory.
105 #
106 # Note that you must specify a directory here, not a file name.
107 #dir ./
108
109 ################################# REPLICATION #################################
110
111 # Master-Slave replication. Use slaveof to make a Redis instance a copy of
112 # another Redis server. Note that the configuration is local to the slave
113 # so for example it is possible to configure the slave to save the DB with a
114 # different interval, or to listen to another port, and so on.
115 #
116 # slaveof <masterip> <masterport>
117
118 # If the master is password protected (using the "requirepass" configuration
119 # directive below) it is possible to tell the slave to authenticate before
120 # starting the replication synchronization process, otherwise the master will
121 # refuse the slave request.
122 #
123 # masterauth <master-password>
124
125 # When a slave lost the connection with the master, or when the replication
126 # is still in progress, the slave can act in two different ways:
127 #
128 # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
129 # still reply to client requests, possibly with out of data data, or the
130 # data set may just be empty if this is the first synchronization.
131 #
132 # 2) if slave-serve-stale data is set to 'no' the slave will reply with
133 # an error "SYNC with master in progress" to all the kind of commands
134 # but to INFO and SLAVEOF.
135 #
136 # slave-serve-stale-data yes
137
138 ################################## SECURITY ###################################
139
140 # Require clients to issue AUTH <PASSWORD> before processing any other
141 # commands. This might be useful in environments in which you do not trust
142 # others with access to the host running redis-server.
143 #
144 # This should stay commented out for backward compatibility and because most
145 # people do not need auth (e.g. they run their own servers).
146 #
147 # Warning: since Redis is pretty fast an outside user can try up to
148 # 150k passwords per second against a good box. This means that you should
149 # use a very strong password otherwise it will be very easy to break.
150 #
151 # requirepass foobared
152
153 # Command renaming.
154 #
155 # It is possilbe to change the name of dangerous commands in a shared
156 # environment. For instance the CONFIG command may be renamed into something
157 # of hard to guess so that it will be still available for internal-use
158 # tools but not available for general clients.
159 #
160 # Example:
161 #
162 # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
163 #
164 # It is also possilbe to completely kill a command renaming it into
165 # an empty string:
166 #
167 # rename-command CONFIG ""
168
169 ################################### LIMITS ####################################
170
171 # Set the max number of connected clients at the same time. By default there
172 # is no limit, and it's up to the number of file descriptors the Redis process
173 # is able to open. The special value '0' means no limits.
174 # Once the limit is reached Redis will close all the new connections sending
175 # an error 'max number of clients reached'.
176 #
177 # maxclients 128
178
179 # Don't use more memory than the specified amount of bytes.
180 # When the memory limit is reached Redis will try to remove keys with an
181 # EXPIRE set. It will try to start freeing keys that are going to expire
182 # in little time and preserve keys with a longer time to live.
183 # Redis will also try to remove objects from free lists if possible.
184 #
185 # If all this fails, Redis will start to reply with errors to commands
186 # that will use more memory, like SET, LPUSH, and so on, and will continue
187 # to reply to most read-only commands like GET.
188 #
189 # WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
190 # 'state' server or cache, not as a real DB. When Redis is used as a real
191 # database the memory usage will grow over the weeks, it will be obvious if
192 # it is going to use too much memory in the long run, and you'll have the time
193 # to upgrade. With maxmemory after the limit is reached you'll start to get
194 # errors for write operations, and this may even lead to DB inconsistency.
195 #
196 # maxmemory <bytes>
197
198 # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
199 # is reached? You can select among five behavior:
200 #
201 # volatile-lru -> remove the key with an expire set using an LRU algorithm
202 # allkeys-lru -> remove any key accordingly to the LRU algorithm
203 # volatile-random -> remove a random key with an expire set
204 # allkeys->random -> remove a random key, any key
205 # volatile-ttl -> remove the key with the nearest expire time (minor TTL)
206 # noeviction -> don't expire at all, just return an error on write operations
207 #
208 # Note: with all the kind of policies, Redis will return an error on write
209 # operations, when there are not suitable keys for eviction.
210 #
211 # At the date of writing this commands are: set setnx setex append
212 # incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
213 # sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
214 # zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
215 # getset mset msetnx exec sort
216 #
217 # The default is:
218 #
219 # maxmemory-policy volatile-lru
220
221 # LRU and minimal TTL algorithms are not precise algorithms but approximated
222 # algorithms (in order to save memory), so you can select as well the sample
223 # size to check. For instance for default Redis will check three keys and
224 # pick the one that was used less recently, you can change the sample size
225 # using the following configuration directive.
226 #
227 # maxmemory-samples 3
228
229 ############################## APPEND ONLY MODE ###############################
230
231 # By default Redis asynchronously dumps the dataset on disk. If you can live
232 # with the idea that the latest records will be lost if something like a crash
233 # happens this is the preferred way to run Redis. If instead you care a lot
234 # about your data and don't want to that a single record can get lost you should
235 # enable the append only mode: when this mode is enabled Redis will append
236 # every write operation received in the file appendonly.aof. This file will
237 # be read on startup in order to rebuild the full dataset in memory.
238 #
239 # Note that you can have both the async dumps and the append only file if you
240 # like (you have to comment the "save" statements above to disable the dumps).
241 # Still if append only mode is enabled Redis will load the data from the
242 # log file at startup ignoring the dump.rdb file.
243 #
244 # IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
245 # log file in background when it gets too big.
246
247 appendonly no
248
249 # The name of the append only file (default: "appendonly.aof")
250 # appendfilename appendonly.aof
251
252 # The fsync() call tells the Operating System to actually write data on disk
253 # instead to wait for more data in the output buffer. Some OS will really flush
254 # data on disk, some other OS will just try to do it ASAP.
255 #
256 # Redis supports three different modes:
257 #
258 # no: don't fsync, just let the OS flush the data when it wants. Faster.
259 # always: fsync after every write to the append only log . Slow, Safest.
260 # everysec: fsync only if one second passed since the last fsync. Compromise.
261 #
262 # The default is "everysec" that's usually the right compromise between
263 # speed and data safety. It's up to you to understand if you can relax this to
264 # "no" that will will let the operating system flush the output buffer when
265 # it wants, for better performances (but if you can live with the idea of
266 # some data loss consider the default persistence mode that's snapshotting),
267 # or on the contrary, use "always" that's very slow but a bit safer than
268 # everysec.
269 #
270 # If unsure, use "everysec".
271
272 # appendfsync always
273 # appendfsync everysec
274 # appendfsync no
275
276 # When the AOF fsync policy is set to always or everysec, and a background
277 # saving process (a background save or AOF log background rewriting) is
278 # performing a lot of I/O against the disk, in some Linux configurations
279 # Redis may block too long on the fsync() call. Note that there is no fix for
280 # this currently, as even performing fsync in a different thread will block
281 # our synchronous write(2) call.
282 #
283 # In order to mitigate this problem it's possible to use the following option
284 # that will prevent fsync() from being called in the main process while a
285 # BGSAVE or BGREWRITEAOF is in progress.
286 #
287 # This means that while another child is saving the durability of Redis is
288 # the same as "appendfsync none", that in pratical terms means that it is
289 # possible to lost up to 30 seconds of log in the worst scenario (with the
290 # default Linux settings).
291 #
292 # If you have latency problems turn this to "yes". Otherwise leave it as
293 # "no" that is the safest pick from the point of view of durability.
294 # no-appendfsync-on-rewrite no
295
296 #################################### DISK STORE ###############################
297
298 # When disk store is active Redis works as an on-disk database, where memory
299 # is only used as a object cache.
300 #
301 # This mode is good for datasets that are bigger than memory, and in general
302 # when you want to trade speed for:
303 #
304 # - less memory used
305 # - immediate server restart
306 # - per key durability, without need for backgrond savig
307 #
308 # On the other hand, with disk store enabled MULTI/EXEC are no longer
309 # transactional from the point of view of the persistence on disk, that is,
310 # Redis transactions will still guarantee that commands are either processed
311 # all or nothing, but there is no guarantee that all the keys are flushed
312 # on disk in an atomic way.
313 #
314 # Of course with disk store enabled Redis is not as fast as it is when
315 # working with just the memory back end.
316
317 # diskstore-enabled no
318 # diskstore-path redis.ds
319 # cache-max-memory 0
320 # cache-flush-delay 0
321
322 ############################### ADVANCED CONFIG ###############################
323
324 # Hashes are encoded in a special way (much more memory efficient) when they
325 # have at max a given numer of elements, and the biggest element does not
326 # exceed a given threshold. You can configure this limits with the following
327 # configuration directives.
328 hash-max-zipmap-entries 512
329 hash-max-zipmap-value 64
330
331 # Similarly to hashes, small lists are also encoded in a special way in order
332 # to save a lot of space. The special representation is only used when
333 # you are under the following limits:
334 list-max-ziplist-entries 512
335 list-max-ziplist-value 64
336
337 # Sets have a special encoding in just one case: when a set is composed
338 # of just strings that happens to be integers in radix 10 in the range
339 # of 64 bit signed integers.
340 # The following configuration setting sets the limit in the size of the
341 # set in order to use this special memory saving encoding.
342 set-max-intset-entries 512
343
344 # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
345 # order to help rehashing the main Redis hash table (the one mapping top-level
346 # keys to values). The hash table implementation redis uses (see dict.c)
347 # performs a lazy rehashing: the more operation you run into an hash table
348 # that is rhashing, the more rehashing "steps" are performed, so if the
349 # server is idle the rehashing is never complete and some more memory is used
350 # by the hash table.
351 #
352 # The default is to use this millisecond 10 times every second in order to
353 # active rehashing the main dictionaries, freeing memory when possible.
354 #
355 # If unsure:
356 # use "activerehashing no" if you have hard latency requirements and it is
357 # not a good thing in your environment that Redis can reply form time to time
358 # to queries with 2 milliseconds delay.
359 #
360 # use "activerehashing yes" if you don't have such hard requirements but
361 # want to free memory asap when possible.
362 activerehashing yes
363
364 loglevel verbose
365 port 6379
366 pidfile /home/vgol/dev/github/brukva/redis.6379.pid
367 logfile /home/vgol/dev/github/brukva/tests/log/redis-server.6379.log
Something went wrong with that request. Please try again.