Browse Source

Add redis.conf

Pete Shadbolt 1 year ago
parent
commit
a7df9da416
1 changed files with 540 additions and 0 deletions
  1. 540
    0
      redis.conf

+ 540
- 0
redis.conf View File

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