├── Dockerfile ├── LICENSE ├── README.md ├── redis.conf └── render.yaml /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM redis:6-alpine 2 | 3 | COPY redis.conf . 4 | 5 | ENTRYPOINT ["redis-server", "./redis.conf"] 6 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Render Developers 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Redis on Render 2 | 3 | This is an example repo with a Dockerfile for running a Redis cache with persistence as a **private service** on Render. 4 | 5 | Render private services are only visible to other Render services in your account. They have internal URLs (e.g. `redis:6379`), can speak any protocol (like [RESP](https://redis.io/topics/protocol)), and can listen on any port. 6 | 7 | Backing Redis with a disk makes it resilient to data loss in the case of restarts or deploys, and Render makes this easy to do with Render Disks. 8 | 9 | ## Deployment 10 | 11 | ### One Click Deploy 12 | 13 | Use the button below to deploy a persistent Redis instance on Render. 14 | 15 | [![Deploy to Render](http://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy) 16 | 17 | ### Manual Deployment 18 | 19 | 1. Select **New Private Service** on your Render dashboard and use your fork of this repo to create the service. 20 | 21 | 2. Make sure the `Environment` is set to `Docker`, and enter a name for the service (this will be used to generate the private URL). 22 | 23 | 3. Add a new disk in the `Advanced` section. Give it a name and set the mount path to `/var/lib/redis`. You can also change the default size for your disk: `1 GB` should be enough for small projects. 24 | 25 | Click `Save` and you're good to go! Once deployed, your Redis instance will be available on a URL similar to `redis:10000`, and you can start using your Redis URL from other services in your Render account. Be sure to prepend `redis://` to the URL displayed in your dashboard. 26 | 27 | If you need help, you can always chat with us at https://render.com/chat. 28 | 29 | -------------------------------------------------------------------------------- /redis.conf: -------------------------------------------------------------------------------- 1 | # Redis configuration file example. 2 | # 3 | # Note that in order to read the configuration file, Redis must be 4 | # started with the file path as first argument: 5 | # 6 | # ./redis-server /path/to/redis.conf 7 | 8 | # Note on units: when memory size is needed, it is possible to specify 9 | # it in the usual form of 1k 5GB 4M and so forth: 10 | # 11 | # 1k => 1000 bytes 12 | # 1kb => 1024 bytes 13 | # 1m => 1000000 bytes 14 | # 1mb => 1024*1024 bytes 15 | # 1g => 1000000000 bytes 16 | # 1gb => 1024*1024*1024 bytes 17 | # 18 | # units are case insensitive so 1GB 1Gb 1gB are all the same. 19 | 20 | ################################## INCLUDES ################################### 21 | 22 | # Include one or more other config files here. This is useful if you 23 | # have a standard template that goes to all Redis servers but also need 24 | # to customize a few per-server settings. Include files can include 25 | # other files, so use this wisely. 26 | # 27 | # Notice option "include" won't be rewritten by command "CONFIG REWRITE" 28 | # from admin or Redis Sentinel. Since Redis always uses the last processed 29 | # line as value of a configuration directive, you'd better put includes 30 | # at the beginning of this file to avoid overwriting config change at runtime. 31 | # 32 | # If instead you are interested in using includes to override configuration 33 | # options, it is better to use include as the last line. 34 | # 35 | # include /path/to/local.conf 36 | # include /path/to/other.conf 37 | 38 | ################################## MODULES ##################################### 39 | 40 | # Load modules at startup. If the server is not able to load modules 41 | # it will abort. It is possible to use multiple loadmodule directives. 42 | # 43 | # loadmodule /path/to/my_module.so 44 | # loadmodule /path/to/other_module.so 45 | 46 | ################################## NETWORK ##################################### 47 | 48 | # By default, if no "bind" configuration directive is specified, Redis listens 49 | # for connections from all the network interfaces available on the server. 50 | # It is possible to listen to just one or multiple selected interfaces using 51 | # the "bind" configuration directive, followed by one or more IP addresses. 52 | # 53 | # Examples: 54 | # 55 | # bind 192.168.1.100 10.0.0.1 56 | # bind 127.0.0.1 ::1 57 | # 58 | # ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the 59 | # internet, binding to all the interfaces is dangerous and will expose the 60 | # instance to everybody on the internet. So by default we uncomment the 61 | # following bind directive, that will force Redis to listen only into 62 | # the IPv4 loopback interface address (this means Redis will be able to 63 | # accept connections only from clients running into the same computer it 64 | # is running). 65 | # 66 | # IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES 67 | # JUST COMMENT THE FOLLOWING LINE. 68 | # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 69 | # bind 127.0.0.1 70 | 71 | # Protected mode is a layer of security protection, in order to avoid that 72 | # Redis instances left open on the internet are accessed and exploited. 73 | # 74 | # When protected mode is on and if: 75 | # 76 | # 1) The server is not binding explicitly to a set of addresses using the 77 | # "bind" directive. 78 | # 2) No password is configured. 79 | # 80 | # The server only accepts connections from clients connecting from the 81 | # IPv4 and IPv6 loopback addresses 127.0.0.1 and ::1, and from Unix domain 82 | # sockets. 83 | # 84 | # By default protected mode is enabled. You should disable it only if 85 | # you are sure you want clients from other hosts to connect to Redis 86 | # even if no authentication is configured, nor a specific set of interfaces 87 | # are explicitly listed using the "bind" directive. 88 | # protected-mode yes 89 | 90 | # Accept connections on the specified port, default is 6379 (IANA #815344). 91 | # If port 0 is specified Redis will not listen on a TCP socket. 92 | port 10000 93 | 94 | # TCP listen() backlog. 95 | # 96 | # In high requests-per-second environments you need an high backlog in order 97 | # to avoid slow clients connections issues. Note that the Linux kernel 98 | # will silently truncate it to the value of /proc/sys/net/core/somaxconn so 99 | # make sure to raise both the value of somaxconn and tcp_max_syn_backlog 100 | # in order to get the desired effect. 101 | tcp-backlog 128 102 | 103 | # Unix socket. 104 | # 105 | # Specify the path for the Unix socket that will be used to listen for 106 | # incoming connections. There is no default, so Redis will not listen 107 | # on a unix socket when not specified. 108 | # 109 | # unixsocket /tmp/redis.sock 110 | # unixsocketperm 700 111 | 112 | # Close the connection after a client is idle for N seconds (0 to disable) 113 | timeout 0 114 | 115 | # TCP keepalive. 116 | # 117 | # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence 118 | # of communication. This is useful for two reasons: 119 | # 120 | # 1) Detect dead peers. 121 | # 2) Take the connection alive from the point of view of network 122 | # equipment in the middle. 123 | # 124 | # On Linux, the specified value (in seconds) is the period used to send ACKs. 125 | # Note that to close the connection the double of the time is needed. 126 | # On other kernels the period depends on the kernel configuration. 127 | # 128 | # A reasonable value for this option is 300 seconds, which is the new 129 | # Redis default starting with Redis 3.2.1. 130 | tcp-keepalive 300 131 | 132 | ################################# GENERAL ##################################### 133 | 134 | # By default Redis does not run as a daemon. Use 'yes' if you need it. 135 | # Note that Redis will write a pid file in /var/run/redis.pid when daemonized. 136 | daemonize no 137 | 138 | # If you run Redis from upstart or systemd, Redis can interact with your 139 | # supervision tree. Options: 140 | # supervised no - no supervision interaction 141 | # supervised upstart - signal upstart by putting Redis into SIGSTOP mode 142 | # supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET 143 | # supervised auto - detect upstart or systemd method based on 144 | # UPSTART_JOB or NOTIFY_SOCKET environment variables 145 | # Note: these supervision methods only signal "process is ready." 146 | # They do not enable continuous liveness pings back to your supervisor. 147 | supervised no 148 | 149 | # If a pid file is specified, Redis writes it where specified at startup 150 | # and removes it at exit. 151 | # 152 | # When the server runs non daemonized, no pid file is created if none is 153 | # specified in the configuration. When the server is daemonized, the pid file 154 | # is used even if not specified, defaulting to "/var/run/redis.pid". 155 | # 156 | # Creating a pid file is best effort: if Redis is not able to create it 157 | # nothing bad happens, the server will start and run normally. 158 | pidfile /var/run/redis_10000.pid 159 | 160 | # Specify the server verbosity level. 161 | # This can be one of: 162 | # debug (a lot of information, useful for development/testing) 163 | # verbose (many rarely useful info, but not a mess like the debug level) 164 | # notice (moderately verbose, what you want in production probably) 165 | # warning (only very important / critical messages are logged) 166 | loglevel notice 167 | 168 | # Specify the log file name. Also the empty string can be used to force 169 | # Redis to log on the standard output. Note that if you use standard 170 | # output for logging but daemonize, logs will be sent to /dev/null 171 | logfile "" 172 | 173 | # To enable logging to the system logger, just set 'syslog-enabled' to yes, 174 | # and optionally update the other syslog parameters to suit your needs. 175 | # syslog-enabled no 176 | 177 | # Specify the syslog identity. 178 | # syslog-ident redis 179 | 180 | # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7. 181 | # syslog-facility local0 182 | 183 | # Set the number of databases. The default database is DB 0, you can select 184 | # a different one on a per-connection basis using SELECT where 185 | # dbid is a number between 0 and 'databases'-1 186 | databases 16 187 | 188 | # By default Redis shows an ASCII art logo only when started to log to the 189 | # standard output and if the standard output is a TTY. Basically this means 190 | # that normally a logo is displayed only in interactive sessions. 191 | # 192 | # However it is possible to force the pre-4.0 behavior and always show a 193 | # ASCII art logo in startup logs by setting the following option to yes. 194 | always-show-logo yes 195 | 196 | ################################ SNAPSHOTTING ################################ 197 | # 198 | # Save the DB on disk: 199 | # 200 | # save 201 | # 202 | # Will save the DB if both the given number of seconds and the given 203 | # number of write operations against the DB occurred. 204 | # 205 | # In the example below the behaviour will be to save: 206 | # after 900 sec (15 min) if at least 1 key changed 207 | # after 300 sec (5 min) if at least 10 keys changed 208 | # after 60 sec if at least 10000 keys changed 209 | # 210 | # Note: you can disable saving completely by commenting out all "save" lines. 211 | # 212 | # It is also possible to remove all the previously configured save 213 | # points by adding a save directive with a single empty string argument 214 | # like in the following example: 215 | # 216 | # save "" 217 | 218 | save "" 219 | # save 900 1 220 | # save 300 10 221 | # save 60 10000 222 | 223 | # By default Redis will stop accepting writes if RDB snapshots are enabled 224 | # (at least one save point) and the latest background save failed. 225 | # This will make the user aware (in a hard way) that data is not persisting 226 | # on disk properly, otherwise chances are that no one will notice and some 227 | # disaster will happen. 228 | # 229 | # If the background saving process will start working again Redis will 230 | # automatically allow writes again. 231 | # 232 | # However if you have setup your proper monitoring of the Redis server 233 | # and persistence, you may want to disable this feature so that Redis will 234 | # continue to work as usual even if there are problems with disk, 235 | # permissions, and so forth. 236 | stop-writes-on-bgsave-error yes 237 | 238 | # Compress string objects using LZF when dump .rdb databases? 239 | # For default that's set to 'yes' as it's almost always a win. 240 | # If you want to save some CPU in the saving child set it to 'no' but 241 | # the dataset will likely be bigger if you have compressible values or keys. 242 | rdbcompression yes 243 | 244 | # Since version 5 of RDB a CRC64 checksum is placed at the end of the file. 245 | # This makes the format more resistant to corruption but there is a performance 246 | # hit to pay (around 10%) when saving and loading RDB files, so you can disable it 247 | # for maximum performances. 248 | # 249 | # RDB files created with checksum disabled have a checksum of zero that will 250 | # tell the loading code to skip the check. 251 | rdbchecksum yes 252 | 253 | # The filename where to dump the DB 254 | dbfilename dump.rdb 255 | 256 | # The working directory. 257 | # 258 | # The DB will be written inside this directory, with the filename specified 259 | # above using the 'dbfilename' configuration directive. 260 | # 261 | # The Append Only File will also be created inside this directory. 262 | # 263 | # Note that you must specify a directory here, not a file name. 264 | dir /var/lib/redis 265 | 266 | ################################# REPLICATION ################################# 267 | 268 | # Master-Replica replication. Use replicaof to make a Redis instance a copy of 269 | # another Redis server. A few things to understand ASAP about Redis replication. 270 | # 271 | # +------------------+ +---------------+ 272 | # | Master | ---> | Replica | 273 | # | (receive writes) | | (exact copy) | 274 | # +------------------+ +---------------+ 275 | # 276 | # 1) Redis replication is asynchronous, but you can configure a master to 277 | # stop accepting writes if it appears to be not connected with at least 278 | # a given number of replicas. 279 | # 2) Redis replicas are able to perform a partial resynchronization with the 280 | # master if the replication link is lost for a relatively small amount of 281 | # time. You may want to configure the replication backlog size (see the next 282 | # sections of this file) with a sensible value depending on your needs. 283 | # 3) Replication is automatic and does not need user intervention. After a 284 | # network partition replicas automatically try to reconnect to masters 285 | # and resynchronize with them. 286 | # 287 | # replicaof 288 | 289 | # If the master is password protected (using the "requirepass" configuration 290 | # directive below) it is possible to tell the replica to authenticate before 291 | # starting the replication synchronization process, otherwise the master will 292 | # refuse the replica request. 293 | # 294 | # masterauth 295 | 296 | # When a replica loses its connection with the master, or when the replication 297 | # is still in progress, the replica can act in two different ways: 298 | # 299 | # 1) if replica-serve-stale-data is set to 'yes' (the default) the replica will 300 | # still reply to client requests, possibly with out of date data, or the 301 | # data set may just be empty if this is the first synchronization. 302 | # 303 | # 2) if replica-serve-stale-data is set to 'no' the replica will reply with 304 | # an error "SYNC with master in progress" to all the kind of commands 305 | # but to INFO, replicaOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG, 306 | # SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB, 307 | # COMMAND, POST, HOST: and LATENCY. 308 | # 309 | replica-serve-stale-data yes 310 | 311 | # You can configure a replica instance to accept writes or not. Writing against 312 | # a replica instance may be useful to store some ephemeral data (because data 313 | # written on a replica will be easily deleted after resync with the master) but 314 | # may also cause problems if clients are writing to it because of a 315 | # misconfiguration. 316 | # 317 | # Since Redis 2.6 by default replicas are read-only. 318 | # 319 | # Note: read only replicas are not designed to be exposed to untrusted clients 320 | # on the internet. It's just a protection layer against misuse of the instance. 321 | # Still a read only replica exports by default all the administrative commands 322 | # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve 323 | # security of read only replicas using 'rename-command' to shadow all the 324 | # administrative / dangerous commands. 325 | replica-read-only yes 326 | 327 | # Replication SYNC strategy: disk or socket. 328 | # 329 | # ------------------------------------------------------- 330 | # WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY 331 | # ------------------------------------------------------- 332 | # 333 | # New replicas and reconnecting replicas that are not able to continue the replication 334 | # process just receiving differences, need to do what is called a "full 335 | # synchronization". An RDB file is transmitted from the master to the replicas. 336 | # The transmission can happen in two different ways: 337 | # 338 | # 1) Disk-backed: The Redis master creates a new process that writes the RDB 339 | # file on disk. Later the file is transferred by the parent 340 | # process to the replicas incrementally. 341 | # 2) Diskless: The Redis master creates a new process that directly writes the 342 | # RDB file to replica sockets, without touching the disk at all. 343 | # 344 | # With disk-backed replication, while the RDB file is generated, more replicas 345 | # can be queued and served with the RDB file as soon as the current child producing 346 | # the RDB file finishes its work. With diskless replication instead once 347 | # the transfer starts, new replicas arriving will be queued and a new transfer 348 | # will start when the current one terminates. 349 | # 350 | # When diskless replication is used, the master waits a configurable amount of 351 | # time (in seconds) before starting the transfer in the hope that multiple replicas 352 | # will arrive and the transfer can be parallelized. 353 | # 354 | # With slow disks and fast (large bandwidth) networks, diskless replication 355 | # works better. 356 | repl-diskless-sync no 357 | 358 | # When diskless replication is enabled, it is possible to configure the delay 359 | # the server waits in order to spawn the child that transfers the RDB via socket 360 | # to the replicas. 361 | # 362 | # This is important since once the transfer starts, it is not possible to serve 363 | # new replicas arriving, that will be queued for the next RDB transfer, so the server 364 | # waits a delay in order to let more replicas arrive. 365 | # 366 | # The delay is specified in seconds, and by default is 5 seconds. To disable 367 | # it entirely just set it to 0 seconds and the transfer will start ASAP. 368 | repl-diskless-sync-delay 5 369 | 370 | # Replicas send PINGs to server in a predefined interval. It's possible to change 371 | # this interval with the repl_ping_replica_period option. The default value is 10 372 | # seconds. 373 | # 374 | # repl-ping-replica-period 10 375 | 376 | # The following option sets the replication timeout for: 377 | # 378 | # 1) Bulk transfer I/O during SYNC, from the point of view of replica. 379 | # 2) Master timeout from the point of view of replicas (data, pings). 380 | # 3) Replica timeout from the point of view of masters (REPLCONF ACK pings). 381 | # 382 | # It is important to make sure that this value is greater than the value 383 | # specified for repl-ping-replica-period otherwise a timeout will be detected 384 | # every time there is low traffic between the master and the replica. 385 | # 386 | # repl-timeout 60 387 | 388 | # Disable TCP_NODELAY on the replica socket after SYNC? 389 | # 390 | # If you select "yes" Redis will use a smaller number of TCP packets and 391 | # less bandwidth to send data to replicas. But this can add a delay for 392 | # the data to appear on the replica side, up to 40 milliseconds with 393 | # Linux kernels using a default configuration. 394 | # 395 | # If you select "no" the delay for data to appear on the replica side will 396 | # be reduced but more bandwidth will be used for replication. 397 | # 398 | # By default we optimize for low latency, but in very high traffic conditions 399 | # or when the master and replicas are many hops away, turning this to "yes" may 400 | # be a good idea. 401 | repl-disable-tcp-nodelay no 402 | 403 | # Set the replication backlog size. The backlog is a buffer that accumulates 404 | # replica data when replicas are disconnected for some time, so that when a replica 405 | # wants to reconnect again, often a full resync is not needed, but a partial 406 | # resync is enough, just passing the portion of data the replica missed while 407 | # disconnected. 408 | # 409 | # The bigger the replication backlog, the longer the time the replica can be 410 | # disconnected and later be able to perform a partial resynchronization. 411 | # 412 | # The backlog is only allocated once there is at least a replica connected. 413 | # 414 | # repl-backlog-size 1mb 415 | 416 | # After a master has no longer connected replicas for some time, the backlog 417 | # will be freed. The following option configures the amount of seconds that 418 | # need to elapse, starting from the time the last replica disconnected, for 419 | # the backlog buffer to be freed. 420 | # 421 | # Note that replicas never free the backlog for timeout, since they may be 422 | # promoted to masters later, and should be able to correctly "partially 423 | # resynchronize" with the replicas: hence they should always accumulate backlog. 424 | # 425 | # A value of 0 means to never release the backlog. 426 | # 427 | # repl-backlog-ttl 3600 428 | 429 | # The replica priority is an integer number published by Redis in the INFO output. 430 | # It is used by Redis Sentinel in order to select a replica to promote into a 431 | # master if the master is no longer working correctly. 432 | # 433 | # A replica with a low priority number is considered better for promotion, so 434 | # for instance if there are three replicas with priority 10, 100, 25 Sentinel will 435 | # pick the one with priority 10, that is the lowest. 436 | # 437 | # However a special priority of 0 marks the replica as not able to perform the 438 | # role of master, so a replica with priority of 0 will never be selected by 439 | # Redis Sentinel for promotion. 440 | # 441 | # By default the priority is 100. 442 | replica-priority 100 443 | 444 | # It is possible for a master to stop accepting writes if there are less than 445 | # N replicas connected, having a lag less or equal than M seconds. 446 | # 447 | # The N replicas need to be in "online" state. 448 | # 449 | # The lag in seconds, that must be <= the specified value, is calculated from 450 | # the last ping received from the replica, that is usually sent every second. 451 | # 452 | # This option does not GUARANTEE that N replicas will accept the write, but 453 | # will limit the window of exposure for lost writes in case not enough replicas 454 | # are available, to the specified number of seconds. 455 | # 456 | # For example to require at least 3 replicas with a lag <= 10 seconds use: 457 | # 458 | # min-replicas-to-write 3 459 | # min-replicas-max-lag 10 460 | # 461 | # Setting one or the other to 0 disables the feature. 462 | # 463 | # By default min-replicas-to-write is set to 0 (feature disabled) and 464 | # min-replicas-max-lag is set to 10. 465 | 466 | # A Redis master is able to list the address and port of the attached 467 | # replicas in different ways. For example the "INFO replication" section 468 | # offers this information, which is used, among other tools, by 469 | # Redis Sentinel in order to discover replica instances. 470 | # Another place where this info is available is in the output of the 471 | # "ROLE" command of a master. 472 | # 473 | # The listed IP and address normally reported by a replica is obtained 474 | # in the following way: 475 | # 476 | # IP: The address is auto detected by checking the peer address 477 | # of the socket used by the replica to connect with the master. 478 | # 479 | # Port: The port is communicated by the replica during the replication 480 | # handshake, and is normally the port that the replica is using to 481 | # listen for connections. 482 | # 483 | # However when port forwarding or Network Address Translation (NAT) is 484 | # used, the replica may be actually reachable via different IP and port 485 | # pairs. The following two options can be used by a replica in order to 486 | # report to its master a specific set of IP and port, so that both INFO 487 | # and ROLE will report those values. 488 | # 489 | # There is no need to use both the options if you need to override just 490 | # the port or the IP address. 491 | # 492 | # replica-announce-ip 5.5.5.5 493 | # replica-announce-port 1234 494 | 495 | ################################## SECURITY ################################### 496 | 497 | # Require clients to issue AUTH before processing any other 498 | # commands. This might be useful in environments in which you do not trust 499 | # others with access to the host running redis-server. 500 | # 501 | # This should stay commented out for backward compatibility and because most 502 | # people do not need auth (e.g. they run their own servers). 503 | # 504 | # Warning: since Redis is pretty fast an outside user can try up to 505 | # 150k passwords per second against a good box. This means that you should 506 | # use a very strong password otherwise it will be very easy to break. 507 | # 508 | # requirepass foobared 509 | 510 | # Command renaming. 511 | # 512 | # It is possible to change the name of dangerous commands in a shared 513 | # environment. For instance the CONFIG command may be renamed into something 514 | # hard to guess so that it will still be available for internal-use tools 515 | # but not available for general clients. 516 | # 517 | # Example: 518 | # 519 | # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52 520 | # 521 | # It is also possible to completely kill a command by renaming it into 522 | # an empty string: 523 | # 524 | # rename-command CONFIG "" 525 | # 526 | # Please note that changing the name of commands that are logged into the 527 | # AOF file or transmitted to replicas may cause problems. 528 | 529 | ################################### CLIENTS #################################### 530 | 531 | # Set the max number of connected clients at the same time. By default 532 | # this limit is set to 10000 clients, however if the Redis server is not 533 | # able to configure the process file limit to allow for the specified limit 534 | # the max number of allowed clients is set to the current file limit 535 | # minus 32 (as Redis reserves a few file descriptors for internal uses). 536 | # 537 | # Once the limit is reached Redis will close all the new connections sending 538 | # an error 'max number of clients reached'. 539 | # 540 | # maxclients 10000 541 | 542 | ############################## MEMORY MANAGEMENT ################################ 543 | 544 | # Set a memory usage limit to the specified amount of bytes. 545 | # When the memory limit is reached Redis will try to remove keys 546 | # according to the eviction policy selected (see maxmemory-policy). 547 | # 548 | # If Redis can't remove keys according to the policy, or if the policy is 549 | # set to 'noeviction', Redis will start to reply with errors to commands 550 | # that would use more memory, like SET, LPUSH, and so on, and will continue 551 | # to reply to read-only commands like GET. 552 | # 553 | # This option is usually useful when using Redis as an LRU or LFU cache, or to 554 | # set a hard memory limit for an instance (using the 'noeviction' policy). 555 | # 556 | # WARNING: If you have replicas attached to an instance with maxmemory on, 557 | # the size of the output buffers needed to feed the replicas are subtracted 558 | # from the used memory count, so that network problems / resyncs will 559 | # not trigger a loop where keys are evicted, and in turn the output 560 | # buffer of replicas is full with DELs of keys evicted triggering the deletion 561 | # of more keys, and so forth until the database is completely emptied. 562 | # 563 | # In short... if you have replicas attached it is suggested that you set a lower 564 | # limit for maxmemory so that there is some free RAM on the system for replica 565 | # output buffers (but this is not needed if the policy is 'noeviction'). 566 | # 567 | # maxmemory 568 | 569 | # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory 570 | # is reached. You can select among five behaviors: 571 | # 572 | # volatile-lru -> Evict using approximated LRU among the keys with an expire set. 573 | # allkeys-lru -> Evict any key using approximated LRU. 574 | # volatile-lfu -> Evict using approximated LFU among the keys with an expire set. 575 | # allkeys-lfu -> Evict any key using approximated LFU. 576 | # volatile-random -> Remove a random key among the ones with an expire set. 577 | # allkeys-random -> Remove a random key, any key. 578 | # volatile-ttl -> Remove the key with the nearest expire time (minor TTL) 579 | # noeviction -> Don't evict anything, just return an error on write operations. 580 | # 581 | # LRU means Least Recently Used 582 | # LFU means Least Frequently Used 583 | # 584 | # Both LRU, LFU and volatile-ttl are implemented using approximated 585 | # randomized algorithms. 586 | # 587 | # Note: with any of the above policies, Redis will return an error on write 588 | # operations, when there are no suitable keys for eviction. 589 | # 590 | # At the date of writing these commands are: set setnx setex append 591 | # incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd 592 | # sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby 593 | # zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby 594 | # getset mset msetnx exec sort 595 | # 596 | # The default is: 597 | # 598 | # maxmemory-policy noeviction 599 | 600 | # LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated 601 | # algorithms (in order to save memory), so you can tune it for speed or 602 | # accuracy. For default Redis will check five keys and pick the one that was 603 | # used less recently, you can change the sample size using the following 604 | # configuration directive. 605 | # 606 | # The default of 5 produces good enough results. 10 Approximates very closely 607 | # true LRU but costs more CPU. 3 is faster but not very accurate. 608 | # 609 | # maxmemory-samples 5 610 | 611 | # Starting from Redis 5, by default a replica will ignore its maxmemory setting 612 | # (unless it is promoted to master after a failover or manually). It means 613 | # that the eviction of keys will be just handled by the master, sending the 614 | # DEL commands to the replica as keys evict in the master side. 615 | # 616 | # This behavior ensures that masters and replicas stay consistent, and is usually 617 | # what you want, however if your replica is writable, or you want the replica to have 618 | # a different memory setting, and you are sure all the writes performed to the 619 | # replica are idempotent, then you may change this default (but be sure to understand 620 | # what you are doing). 621 | # 622 | # Note that since the replica by default does not evict, it may end using more 623 | # memory than the one set via maxmemory (there are certain buffers that may 624 | # be larger on the replica, or data structures may sometimes take more memory and so 625 | # forth). So make sure you monitor your replicas and make sure they have enough 626 | # memory to never hit a real out-of-memory condition before the master hits 627 | # the configured maxmemory setting. 628 | # 629 | # replica-ignore-maxmemory yes 630 | 631 | ############################# LAZY FREEING #################################### 632 | 633 | # Redis has two primitives to delete keys. One is called DEL and is a blocking 634 | # deletion of the object. It means that the server stops processing new commands 635 | # in order to reclaim all the memory associated with an object in a synchronous 636 | # way. If the key deleted is associated with a small object, the time needed 637 | # in order to execute the DEL command is very small and comparable to most other 638 | # O(1) or O(log_N) commands in Redis. However if the key is associated with an 639 | # aggregated value containing millions of elements, the server can block for 640 | # a long time (even seconds) in order to complete the operation. 641 | # 642 | # For the above reasons Redis also offers non blocking deletion primitives 643 | # such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and 644 | # FLUSHDB commands, in order to reclaim memory in background. Those commands 645 | # are executed in constant time. Another thread will incrementally free the 646 | # object in the background as fast as possible. 647 | # 648 | # DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled. 649 | # It's up to the design of the application to understand when it is a good 650 | # idea to use one or the other. However the Redis server sometimes has to 651 | # delete keys or flush the whole database as a side effect of other operations. 652 | # Specifically Redis deletes objects independently of a user call in the 653 | # following scenarios: 654 | # 655 | # 1) On eviction, because of the maxmemory and maxmemory policy configurations, 656 | # in order to make room for new data, without going over the specified 657 | # memory limit. 658 | # 2) Because of expire: when a key with an associated time to live (see the 659 | # EXPIRE command) must be deleted from memory. 660 | # 3) Because of a side effect of a command that stores data on a key that may 661 | # already exist. For example the RENAME command may delete the old key 662 | # content when it is replaced with another one. Similarly SUNIONSTORE 663 | # or SORT with STORE option may delete existing keys. The SET command 664 | # itself removes any old content of the specified key in order to replace 665 | # it with the specified string. 666 | # 4) During replication, when a replica performs a full resynchronization with 667 | # its master, the content of the whole database is removed in order to 668 | # load the RDB file just transferred. 669 | # 670 | # In all the above cases the default is to delete objects in a blocking way, 671 | # like if DEL was called. However you can configure each case specifically 672 | # in order to instead release memory in a non-blocking way like if UNLINK 673 | # was called, using the following configuration directives: 674 | 675 | lazyfree-lazy-eviction no 676 | lazyfree-lazy-expire no 677 | lazyfree-lazy-server-del no 678 | replica-lazy-flush no 679 | 680 | ############################## APPEND ONLY MODE ############################### 681 | 682 | # By default Redis asynchronously dumps the dataset on disk. This mode is 683 | # good enough in many applications, but an issue with the Redis process or 684 | # a power outage may result into a few minutes of writes lost (depending on 685 | # the configured save points). 686 | # 687 | # The Append Only File is an alternative persistence mode that provides 688 | # much better durability. For instance using the default data fsync policy 689 | # (see later in the config file) Redis can lose just one second of writes in a 690 | # dramatic event like a server power outage, or a single write if something 691 | # wrong with the Redis process itself happens, but the operating system is 692 | # still running correctly. 693 | # 694 | # AOF and RDB persistence can be enabled at the same time without problems. 695 | # If the AOF is enabled on startup Redis will load the AOF, that is the file 696 | # with the better durability guarantees. 697 | # 698 | # Please check http://redis.io/topics/persistence for more information. 699 | 700 | appendonly yes 701 | 702 | # The name of the append only file (default: "appendonly.aof") 703 | 704 | appendfilename "appendonly.aof" 705 | 706 | # The fsync() call tells the Operating System to actually write data on disk 707 | # instead of waiting for more data in the output buffer. Some OS will really flush 708 | # data on disk, some other OS will just try to do it ASAP. 709 | # 710 | # Redis supports three different modes: 711 | # 712 | # no: don't fsync, just let the OS flush the data when it wants. Faster. 713 | # always: fsync after every write to the append only log. Slow, Safest. 714 | # everysec: fsync only one time every second. Compromise. 715 | # 716 | # The default is "everysec", as that's usually the right compromise between 717 | # speed and data safety. It's up to you to understand if you can relax this to 718 | # "no" that will let the operating system flush the output buffer when 719 | # it wants, for better performances (but if you can live with the idea of 720 | # some data loss consider the default persistence mode that's snapshotting), 721 | # or on the contrary, use "always" that's very slow but a bit safer than 722 | # everysec. 723 | # 724 | # More details please check the following article: 725 | # http://antirez.com/post/redis-persistence-demystified.html 726 | # 727 | # If unsure, use "everysec". 728 | 729 | # appendfsync always 730 | appendfsync everysec 731 | # appendfsync no 732 | 733 | # When the AOF fsync policy is set to always or everysec, and a background 734 | # saving process (a background save or AOF log background rewriting) is 735 | # performing a lot of I/O against the disk, in some Linux configurations 736 | # Redis may block too long on the fsync() call. Note that there is no fix for 737 | # this currently, as even performing fsync in a different thread will block 738 | # our synchronous write(2) call. 739 | # 740 | # In order to mitigate this problem it's possible to use the following option 741 | # that will prevent fsync() from being called in the main process while a 742 | # BGSAVE or BGREWRITEAOF is in progress. 743 | # 744 | # This means that while another child is saving, the durability of Redis is 745 | # the same as "appendfsync none". In practical terms, this means that it is 746 | # possible to lose up to 30 seconds of log in the worst scenario (with the 747 | # default Linux settings). 748 | # 749 | # If you have latency problems turn this to "yes". Otherwise leave it as 750 | # "no" that is the safest pick from the point of view of durability. 751 | 752 | no-appendfsync-on-rewrite no 753 | 754 | # Automatic rewrite of the append only file. 755 | # Redis is able to automatically rewrite the log file implicitly calling 756 | # BGREWRITEAOF when the AOF log size grows by the specified percentage. 757 | # 758 | # This is how it works: Redis remembers the size of the AOF file after the 759 | # latest rewrite (if no rewrite has happened since the restart, the size of 760 | # the AOF at startup is used). 761 | # 762 | # This base size is compared to the current size. If the current size is 763 | # bigger than the specified percentage, the rewrite is triggered. Also 764 | # you need to specify a minimal size for the AOF file to be rewritten, this 765 | # is useful to avoid rewriting the AOF file even if the percentage increase 766 | # is reached but it is still pretty small. 767 | # 768 | # Specify a percentage of zero in order to disable the automatic AOF 769 | # rewrite feature. 770 | 771 | auto-aof-rewrite-percentage 100 772 | auto-aof-rewrite-min-size 64mb 773 | 774 | # An AOF file may be found to be truncated at the end during the Redis 775 | # startup process, when the AOF data gets loaded back into memory. 776 | # This may happen when the system where Redis is running 777 | # crashes, especially when an ext4 filesystem is mounted without the 778 | # data=ordered option (however this can't happen when Redis itself 779 | # crashes or aborts but the operating system still works correctly). 780 | # 781 | # Redis can either exit with an error when this happens, or load as much 782 | # data as possible (the default now) and start if the AOF file is found 783 | # to be truncated at the end. The following option controls this behavior. 784 | # 785 | # If aof-load-truncated is set to yes, a truncated AOF file is loaded and 786 | # the Redis server starts emitting a log to inform the user of the event. 787 | # Otherwise if the option is set to no, the server aborts with an error 788 | # and refuses to start. When the option is set to no, the user requires 789 | # to fix the AOF file using the "redis-check-aof" utility before to restart 790 | # the server. 791 | # 792 | # Note that if the AOF file will be found to be corrupted in the middle 793 | # the server will still exit with an error. This option only applies when 794 | # Redis will try to read more data from the AOF file but not enough bytes 795 | # will be found. 796 | aof-load-truncated yes 797 | 798 | # When rewriting the AOF file, Redis is able to use an RDB preamble in the 799 | # AOF file for faster rewrites and recoveries. When this option is turned 800 | # on the rewritten AOF file is composed of two different stanzas: 801 | # 802 | # [RDB file][AOF tail] 803 | # 804 | # When loading Redis recognizes that the AOF file starts with the "REDIS" 805 | # string and loads the prefixed RDB file, and continues loading the AOF 806 | # tail. 807 | aof-use-rdb-preamble yes 808 | 809 | ################################ LUA SCRIPTING ############################### 810 | 811 | # Max execution time of a Lua script in milliseconds. 812 | # 813 | # If the maximum execution time is reached Redis will log that a script is 814 | # still in execution after the maximum allowed time and will start to 815 | # reply to queries with an error. 816 | # 817 | # When a long running script exceeds the maximum execution time only the 818 | # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be 819 | # used to stop a script that did not yet called write commands. The second 820 | # is the only way to shut down the server in the case a write command was 821 | # already issued by the script but the user doesn't want to wait for the natural 822 | # termination of the script. 823 | # 824 | # Set it to 0 or a negative value for unlimited execution without warnings. 825 | lua-time-limit 5000 826 | 827 | ################################ REDIS CLUSTER ############################### 828 | # 829 | # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 830 | # WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however 831 | # in order to mark it as "mature" we need to wait for a non trivial percentage 832 | # of users to deploy it in production. 833 | # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 834 | # 835 | # Normal Redis instances can't be part of a Redis Cluster; only nodes that are 836 | # started as cluster nodes can. In order to start a Redis instance as a 837 | # cluster node enable the cluster support uncommenting the following: 838 | # 839 | # cluster-enabled yes 840 | 841 | # Every cluster node has a cluster configuration file. This file is not 842 | # intended to be edited by hand. It is created and updated by Redis nodes. 843 | # Every Redis Cluster node requires a different cluster configuration file. 844 | # Make sure that instances running in the same system do not have 845 | # overlapping cluster configuration file names. 846 | # 847 | # cluster-config-file nodes-6379.conf 848 | 849 | # Cluster node timeout is the amount of milliseconds a node must be unreachable 850 | # for it to be considered in failure state. 851 | # Most other internal time limits are multiple of the node timeout. 852 | # 853 | # cluster-node-timeout 15000 854 | 855 | # A replica of a failing master will avoid to start a failover if its data 856 | # looks too old. 857 | # 858 | # There is no simple way for a replica to actually have an exact measure of 859 | # its "data age", so the following two checks are performed: 860 | # 861 | # 1) If there are multiple replicas able to failover, they exchange messages 862 | # in order to try to give an advantage to the replica with the best 863 | # replication offset (more data from the master processed). 864 | # Replicas will try to get their rank by offset, and apply to the start 865 | # of the failover a delay proportional to their rank. 866 | # 867 | # 2) Every single replica computes the time of the last interaction with 868 | # its master. This can be the last ping or command received (if the master 869 | # is still in the "connected" state), or the time that elapsed since the 870 | # disconnection with the master (if the replication link is currently down). 871 | # If the last interaction is too old, the replica will not try to failover 872 | # at all. 873 | # 874 | # The point "2" can be tuned by user. Specifically a replica will not perform 875 | # the failover if, since the last interaction with the master, the time 876 | # elapsed is greater than: 877 | # 878 | # (node-timeout * replica-validity-factor) + repl-ping-replica-period 879 | # 880 | # So for example if node-timeout is 30 seconds, and the replica-validity-factor 881 | # is 10, and assuming a default repl-ping-replica-period of 10 seconds, the 882 | # replica will not try to failover if it was not able to talk with the master 883 | # for longer than 310 seconds. 884 | # 885 | # A large replica-validity-factor may allow replicas with too old data to failover 886 | # a master, while a too small value may prevent the cluster from being able to 887 | # elect a replica at all. 888 | # 889 | # For maximum availability, it is possible to set the replica-validity-factor 890 | # to a value of 0, which means, that replicas will always try to failover the 891 | # master regardless of the last time they interacted with the master. 892 | # (However they'll always try to apply a delay proportional to their 893 | # offset rank). 894 | # 895 | # Zero is the only value able to guarantee that when all the partitions heal 896 | # the cluster will always be able to continue. 897 | # 898 | # cluster-replica-validity-factor 10 899 | 900 | # Cluster replicas are able to migrate to orphaned masters, that are masters 901 | # that are left without working replicas. This improves the cluster ability 902 | # to resist to failures as otherwise an orphaned master can't be failed over 903 | # in case of failure if it has no working replicas. 904 | # 905 | # Replicas migrate to orphaned masters only if there are still at least a 906 | # given number of other working replicas for their old master. This number 907 | # is the "migration barrier". A migration barrier of 1 means that a replica 908 | # will migrate only if there is at least 1 other working replica for its master 909 | # and so forth. It usually reflects the number of replicas you want for every 910 | # master in your cluster. 911 | # 912 | # Default is 1 (replicas migrate only if their masters remain with at least 913 | # one replica). To disable migration just set it to a very large value. 914 | # A value of 0 can be set but is useful only for debugging and dangerous 915 | # in production. 916 | # 917 | # cluster-migration-barrier 1 918 | 919 | # By default Redis Cluster nodes stop accepting queries if they detect there 920 | # is at least an hash slot uncovered (no available node is serving it). 921 | # This way if the cluster is partially down (for example a range of hash slots 922 | # are no longer covered) all the cluster becomes, eventually, unavailable. 923 | # It automatically returns available as soon as all the slots are covered again. 924 | # 925 | # However sometimes you want the subset of the cluster which is working, 926 | # to continue to accept queries for the part of the key space that is still 927 | # covered. In order to do so, just set the cluster-require-full-coverage 928 | # option to no. 929 | # 930 | # cluster-require-full-coverage yes 931 | 932 | # This option, when set to yes, prevents replicas from trying to failover its 933 | # master during master failures. However the master can still perform a 934 | # manual failover, if forced to do so. 935 | # 936 | # This is useful in different scenarios, especially in the case of multiple 937 | # data center operations, where we want one side to never be promoted if not 938 | # in the case of a total DC failure. 939 | # 940 | # cluster-replica-no-failover no 941 | 942 | # In order to setup your cluster make sure to read the documentation 943 | # available at http://redis.io web site. 944 | 945 | ########################## CLUSTER DOCKER/NAT support ######################## 946 | 947 | # In certain deployments, Redis Cluster nodes address discovery fails, because 948 | # addresses are NAT-ted or because ports are forwarded (the typical case is 949 | # Docker and other containers). 950 | # 951 | # In order to make Redis Cluster working in such environments, a static 952 | # configuration where each node knows its public address is needed. The 953 | # following two options are used for this scope, and are: 954 | # 955 | # * cluster-announce-ip 956 | # * cluster-announce-port 957 | # * cluster-announce-bus-port 958 | # 959 | # Each instruct the node about its address, client port, and cluster message 960 | # bus port. The information is then published in the header of the bus packets 961 | # so that other nodes will be able to correctly map the address of the node 962 | # publishing the information. 963 | # 964 | # If the above options are not used, the normal Redis Cluster auto-detection 965 | # will be used instead. 966 | # 967 | # Note that when remapped, the bus port may not be at the fixed offset of 968 | # clients port + 10000, so you can specify any port and bus-port depending 969 | # on how they get remapped. If the bus-port is not set, a fixed offset of 970 | # 10000 will be used as usually. 971 | # 972 | # Example: 973 | # 974 | # cluster-announce-ip 10.1.1.5 975 | # cluster-announce-port 6379 976 | # cluster-announce-bus-port 6380 977 | 978 | ################################## SLOW LOG ################################### 979 | 980 | # The Redis Slow Log is a system to log queries that exceeded a specified 981 | # execution time. The execution time does not include the I/O operations 982 | # like talking with the client, sending the reply and so forth, 983 | # but just the time needed to actually execute the command (this is the only 984 | # stage of command execution where the thread is blocked and can not serve 985 | # other requests in the meantime). 986 | # 987 | # You can configure the slow log with two parameters: one tells Redis 988 | # what is the execution time, in microseconds, to exceed in order for the 989 | # command to get logged, and the other parameter is the length of the 990 | # slow log. When a new command is logged the oldest one is removed from the 991 | # queue of logged commands. 992 | 993 | # The following time is expressed in microseconds, so 1000000 is equivalent 994 | # to one second. Note that a negative number disables the slow log, while 995 | # a value of zero forces the logging of every command. 996 | slowlog-log-slower-than 10000 997 | 998 | # There is no limit to this length. Just be aware that it will consume memory. 999 | # You can reclaim memory used by the slow log with SLOWLOG RESET. 1000 | slowlog-max-len 128 1001 | 1002 | ################################ LATENCY MONITOR ############################## 1003 | 1004 | # The Redis latency monitoring subsystem samples different operations 1005 | # at runtime in order to collect data related to possible sources of 1006 | # latency of a Redis instance. 1007 | # 1008 | # Via the LATENCY command this information is available to the user that can 1009 | # print graphs and obtain reports. 1010 | # 1011 | # The system only logs operations that were performed in a time equal or 1012 | # greater than the amount of milliseconds specified via the 1013 | # latency-monitor-threshold configuration directive. When its value is set 1014 | # to zero, the latency monitor is turned off. 1015 | # 1016 | # By default latency monitoring is disabled since it is mostly not needed 1017 | # if you don't have latency issues, and collecting data has a performance 1018 | # impact, that while very small, can be measured under big load. Latency 1019 | # monitoring can easily be enabled at runtime using the command 1020 | # "CONFIG SET latency-monitor-threshold " if needed. 1021 | latency-monitor-threshold 0 1022 | 1023 | ############################# EVENT NOTIFICATION ############################## 1024 | 1025 | # Redis can notify Pub/Sub clients about events happening in the key space. 1026 | # This feature is documented at http://redis.io/topics/notifications 1027 | # 1028 | # For instance if keyspace events notification is enabled, and a client 1029 | # performs a DEL operation on key "foo" stored in the Database 0, two 1030 | # messages will be published via Pub/Sub: 1031 | # 1032 | # PUBLISH __keyspace@0__:foo del 1033 | # PUBLISH __keyevent@0__:del foo 1034 | # 1035 | # It is possible to select the events that Redis will notify among a set 1036 | # of classes. Every class is identified by a single character: 1037 | # 1038 | # K Keyspace events, published with __keyspace@__ prefix. 1039 | # E Keyevent events, published with __keyevent@__ prefix. 1040 | # g Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ... 1041 | # $ String commands 1042 | # l List commands 1043 | # s Set commands 1044 | # h Hash commands 1045 | # z Sorted set commands 1046 | # x Expired events (events generated every time a key expires) 1047 | # e Evicted events (events generated when a key is evicted for maxmemory) 1048 | # A Alias for g$lshzxe, so that the "AKE" string means all the events. 1049 | # 1050 | # The "notify-keyspace-events" takes as argument a string that is composed 1051 | # of zero or multiple characters. The empty string means that notifications 1052 | # are disabled. 1053 | # 1054 | # Example: to enable list and generic events, from the point of view of the 1055 | # event name, use: 1056 | # 1057 | # notify-keyspace-events Elg 1058 | # 1059 | # Example 2: to get the stream of the expired keys subscribing to channel 1060 | # name __keyevent@0__:expired use: 1061 | # 1062 | # notify-keyspace-events Ex 1063 | # 1064 | # By default all notifications are disabled because most users don't need 1065 | # this feature and the feature has some overhead. Note that if you don't 1066 | # specify at least one of K or E, no events will be delivered. 1067 | notify-keyspace-events "" 1068 | 1069 | ############################### ADVANCED CONFIG ############################### 1070 | 1071 | # Hashes are encoded using a memory efficient data structure when they have a 1072 | # small number of entries, and the biggest entry does not exceed a given 1073 | # threshold. These thresholds can be configured using the following directives. 1074 | hash-max-ziplist-entries 512 1075 | hash-max-ziplist-value 64 1076 | 1077 | # Lists are also encoded in a special way to save a lot of space. 1078 | # The number of entries allowed per internal list node can be specified 1079 | # as a fixed maximum size or a maximum number of elements. 1080 | # For a fixed maximum size, use -5 through -1, meaning: 1081 | # -5: max size: 64 Kb <-- not recommended for normal workloads 1082 | # -4: max size: 32 Kb <-- not recommended 1083 | # -3: max size: 16 Kb <-- probably not recommended 1084 | # -2: max size: 8 Kb <-- good 1085 | # -1: max size: 4 Kb <-- good 1086 | # Positive numbers mean store up to _exactly_ that number of elements 1087 | # per list node. 1088 | # The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size), 1089 | # but if your use case is unique, adjust the settings as necessary. 1090 | list-max-ziplist-size -2 1091 | 1092 | # Lists may also be compressed. 1093 | # Compress depth is the number of quicklist ziplist nodes from *each* side of 1094 | # the list to *exclude* from compression. The head and tail of the list 1095 | # are always uncompressed for fast push/pop operations. Settings are: 1096 | # 0: disable all list compression 1097 | # 1: depth 1 means "don't start compressing until after 1 node into the list, 1098 | # going from either the head or tail" 1099 | # So: [head]->node->node->...->node->[tail] 1100 | # [head], [tail] will always be uncompressed; inner nodes will compress. 1101 | # 2: [head]->[next]->node->node->...->node->[prev]->[tail] 1102 | # 2 here means: don't compress head or head->next or tail->prev or tail, 1103 | # but compress all nodes between them. 1104 | # 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail] 1105 | # etc. 1106 | list-compress-depth 0 1107 | 1108 | # Sets have a special encoding in just one case: when a set is composed 1109 | # of just strings that happen to be integers in radix 10 in the range 1110 | # of 64 bit signed integers. 1111 | # The following configuration setting sets the limit in the size of the 1112 | # set in order to use this special memory saving encoding. 1113 | set-max-intset-entries 512 1114 | 1115 | # Similarly to hashes and lists, sorted sets are also specially encoded in 1116 | # order to save a lot of space. This encoding is only used when the length and 1117 | # elements of a sorted set are below the following limits: 1118 | zset-max-ziplist-entries 128 1119 | zset-max-ziplist-value 64 1120 | 1121 | # HyperLogLog sparse representation bytes limit. The limit includes the 1122 | # 16 bytes header. When an HyperLogLog using the sparse representation crosses 1123 | # this limit, it is converted into the dense representation. 1124 | # 1125 | # A value greater than 16000 is totally useless, since at that point the 1126 | # dense representation is more memory efficient. 1127 | # 1128 | # The suggested value is ~ 3000 in order to have the benefits of 1129 | # the space efficient encoding without slowing down too much PFADD, 1130 | # which is O(N) with the sparse encoding. The value can be raised to 1131 | # ~ 10000 when CPU is not a concern, but space is, and the data set is 1132 | # composed of many HyperLogLogs with cardinality in the 0 - 15000 range. 1133 | hll-sparse-max-bytes 3000 1134 | 1135 | # Streams macro node max size / items. The stream data structure is a radix 1136 | # tree of big nodes that encode multiple items inside. Using this configuration 1137 | # it is possible to configure how big a single node can be in bytes, and the 1138 | # maximum number of items it may contain before switching to a new node when 1139 | # appending new stream entries. If any of the following settings are set to 1140 | # zero, the limit is ignored, so for instance it is possible to set just a 1141 | # max entires limit by setting max-bytes to 0 and max-entries to the desired 1142 | # value. 1143 | stream-node-max-bytes 4096 1144 | stream-node-max-entries 100 1145 | 1146 | # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in 1147 | # order to help rehashing the main Redis hash table (the one mapping top-level 1148 | # keys to values). The hash table implementation Redis uses (see dict.c) 1149 | # performs a lazy rehashing: the more operation you run into a hash table 1150 | # that is rehashing, the more rehashing "steps" are performed, so if the 1151 | # server is idle the rehashing is never complete and some more memory is used 1152 | # by the hash table. 1153 | # 1154 | # The default is to use this millisecond 10 times every second in order to 1155 | # actively rehash the main dictionaries, freeing memory when possible. 1156 | # 1157 | # If unsure: 1158 | # use "activerehashing no" if you have hard latency requirements and it is 1159 | # not a good thing in your environment that Redis can reply from time to time 1160 | # to queries with 2 milliseconds delay. 1161 | # 1162 | # use "activerehashing yes" if you don't have such hard requirements but 1163 | # want to free memory asap when possible. 1164 | activerehashing yes 1165 | 1166 | # The client output buffer limits can be used to force disconnection of clients 1167 | # that are not reading data from the server fast enough for some reason (a 1168 | # common reason is that a Pub/Sub client can't consume messages as fast as the 1169 | # publisher can produce them). 1170 | # 1171 | # The limit can be set differently for the three different classes of clients: 1172 | # 1173 | # normal -> normal clients including MONITOR clients 1174 | # replica -> replica clients 1175 | # pubsub -> clients subscribed to at least one pubsub channel or pattern 1176 | # 1177 | # The syntax of every client-output-buffer-limit directive is the following: 1178 | # 1179 | # client-output-buffer-limit 1180 | # 1181 | # A client is immediately disconnected once the hard limit is reached, or if 1182 | # the soft limit is reached and remains reached for the specified number of 1183 | # seconds (continuously). 1184 | # So for instance if the hard limit is 32 megabytes and the soft limit is 1185 | # 16 megabytes / 10 seconds, the client will get disconnected immediately 1186 | # if the size of the output buffers reach 32 megabytes, but will also get 1187 | # disconnected if the client reaches 16 megabytes and continuously overcomes 1188 | # the limit for 10 seconds. 1189 | # 1190 | # By default normal clients are not limited because they don't receive data 1191 | # without asking (in a push way), but just after a request, so only 1192 | # asynchronous clients may create a scenario where data is requested faster 1193 | # than it can read. 1194 | # 1195 | # Instead there is a default limit for pubsub and replica clients, since 1196 | # subscribers and replicas receive data in a push fashion. 1197 | # 1198 | # Both the hard or the soft limit can be disabled by setting them to zero. 1199 | client-output-buffer-limit normal 0 0 0 1200 | client-output-buffer-limit replica 256mb 64mb 60 1201 | client-output-buffer-limit pubsub 32mb 8mb 60 1202 | 1203 | # Client query buffers accumulate new commands. They are limited to a fixed 1204 | # amount by default in order to avoid that a protocol desynchronization (for 1205 | # instance due to a bug in the client) will lead to unbound memory usage in 1206 | # the query buffer. However you can configure it here if you have very special 1207 | # needs, such us huge multi/exec requests or alike. 1208 | # 1209 | # client-query-buffer-limit 1gb 1210 | 1211 | # In the Redis protocol, bulk requests, that are, elements representing single 1212 | # strings, are normally limited ot 512 mb. However you can change this limit 1213 | # here. 1214 | # 1215 | # proto-max-bulk-len 512mb 1216 | 1217 | # Redis calls an internal function to perform many background tasks, like 1218 | # closing connections of clients in timeout, purging expired keys that are 1219 | # never requested, and so forth. 1220 | # 1221 | # Not all tasks are performed with the same frequency, but Redis checks for 1222 | # tasks to perform according to the specified "hz" value. 1223 | # 1224 | # By default "hz" is set to 10. Raising the value will use more CPU when 1225 | # Redis is idle, but at the same time will make Redis more responsive when 1226 | # there are many keys expiring at the same time, and timeouts may be 1227 | # handled with more precision. 1228 | # 1229 | # The range is between 1 and 500, however a value over 100 is usually not 1230 | # a good idea. Most users should use the default of 10 and raise this up to 1231 | # 100 only in environments where very low latency is required. 1232 | hz 10 1233 | 1234 | # Normally it is useful to have an HZ value which is proportional to the 1235 | # number of clients connected. This is useful in order, for instance, to 1236 | # avoid too many clients are processed for each background task invocation 1237 | # in order to avoid latency spikes. 1238 | # 1239 | # Since the default HZ value by default is conservatively set to 10, Redis 1240 | # offers, and enables by default, the ability to use an adaptive HZ value 1241 | # which will temporary raise when there are many connected clients. 1242 | # 1243 | # When dynamic HZ is enabled, the actual configured HZ will be used as 1244 | # as a baseline, but multiples of the configured HZ value will be actually 1245 | # used as needed once more clients are connected. In this way an idle 1246 | # instance will use very little CPU time while a busy instance will be 1247 | # more responsive. 1248 | dynamic-hz yes 1249 | 1250 | # When a child rewrites the AOF file, if the following option is enabled 1251 | # the file will be fsync-ed every 32 MB of data generated. This is useful 1252 | # in order to commit the file to the disk more incrementally and avoid 1253 | # big latency spikes. 1254 | aof-rewrite-incremental-fsync yes 1255 | 1256 | # When redis saves RDB file, if the following option is enabled 1257 | # the file will be fsync-ed every 32 MB of data generated. This is useful 1258 | # in order to commit the file to the disk more incrementally and avoid 1259 | # big latency spikes. 1260 | rdb-save-incremental-fsync yes 1261 | 1262 | # Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good 1263 | # idea to start with the default settings and only change them after investigating 1264 | # how to improve the performances and how the keys LFU change over time, which 1265 | # is possible to inspect via the OBJECT FREQ command. 1266 | # 1267 | # There are two tunable parameters in the Redis LFU implementation: the 1268 | # counter logarithm factor and the counter decay time. It is important to 1269 | # understand what the two parameters mean before changing them. 1270 | # 1271 | # The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis 1272 | # uses a probabilistic increment with logarithmic behavior. Given the value 1273 | # of the old counter, when a key is accessed, the counter is incremented in 1274 | # this way: 1275 | # 1276 | # 1. A random number R between 0 and 1 is extracted. 1277 | # 2. A probability P is calculated as 1/(old_value*lfu_log_factor+1). 1278 | # 3. The counter is incremented only if R < P. 1279 | # 1280 | # The default lfu-log-factor is 10. This is a table of how the frequency 1281 | # counter changes with a different number of accesses with different 1282 | # logarithmic factors: 1283 | # 1284 | # +--------+------------+------------+------------+------------+------------+ 1285 | # | factor | 100 hits | 1000 hits | 100K hits | 1M hits | 10M hits | 1286 | # +--------+------------+------------+------------+------------+------------+ 1287 | # | 0 | 104 | 255 | 255 | 255 | 255 | 1288 | # +--------+------------+------------+------------+------------+------------+ 1289 | # | 1 | 18 | 49 | 255 | 255 | 255 | 1290 | # +--------+------------+------------+------------+------------+------------+ 1291 | # | 10 | 10 | 18 | 142 | 255 | 255 | 1292 | # +--------+------------+------------+------------+------------+------------+ 1293 | # | 100 | 8 | 11 | 49 | 143 | 255 | 1294 | # +--------+------------+------------+------------+------------+------------+ 1295 | # 1296 | # NOTE: The above table was obtained by running the following commands: 1297 | # 1298 | # redis-benchmark -n 1000000 incr foo 1299 | # redis-cli object freq foo 1300 | # 1301 | # NOTE 2: The counter initial value is 5 in order to give new objects a chance 1302 | # to accumulate hits. 1303 | # 1304 | # The counter decay time is the time, in minutes, that must elapse in order 1305 | # for the key counter to be divided by two (or decremented if it has a value 1306 | # less <= 10). 1307 | # 1308 | # The default value for the lfu-decay-time is 1. A Special value of 0 means to 1309 | # decay the counter every time it happens to be scanned. 1310 | # 1311 | # lfu-log-factor 10 1312 | # lfu-decay-time 1 1313 | 1314 | ########################### ACTIVE DEFRAGMENTATION ####################### 1315 | # 1316 | # WARNING THIS FEATURE IS EXPERIMENTAL. However it was stress tested 1317 | # even in production and manually tested by multiple engineers for some 1318 | # time. 1319 | # 1320 | # What is active defragmentation? 1321 | # ------------------------------- 1322 | # 1323 | # Active (online) defragmentation allows a Redis server to compact the 1324 | # spaces left between small allocations and deallocations of data in memory, 1325 | # thus allowing to reclaim back memory. 1326 | # 1327 | # Fragmentation is a natural process that happens with every allocator (but 1328 | # less so with Jemalloc, fortunately) and certain workloads. Normally a server 1329 | # restart is needed in order to lower the fragmentation, or at least to flush 1330 | # away all the data and create it again. However thanks to this feature 1331 | # implemented by Oran Agra for Redis 4.0 this process can happen at runtime 1332 | # in an "hot" way, while the server is running. 1333 | # 1334 | # Basically when the fragmentation is over a certain level (see the 1335 | # configuration options below) Redis will start to create new copies of the 1336 | # values in contiguous memory regions by exploiting certain specific Jemalloc 1337 | # features (in order to understand if an allocation is causing fragmentation 1338 | # and to allocate it in a better place), and at the same time, will release the 1339 | # old copies of the data. This process, repeated incrementally for all the keys 1340 | # will cause the fragmentation to drop back to normal values. 1341 | # 1342 | # Important things to understand: 1343 | # 1344 | # 1. This feature is disabled by default, and only works if you compiled Redis 1345 | # to use the copy of Jemalloc we ship with the source code of Redis. 1346 | # This is the default with Linux builds. 1347 | # 1348 | # 2. You never need to enable this feature if you don't have fragmentation 1349 | # issues. 1350 | # 1351 | # 3. Once you experience fragmentation, you can enable this feature when 1352 | # needed with the command "CONFIG SET activedefrag yes". 1353 | # 1354 | # The configuration parameters are able to fine tune the behavior of the 1355 | # defragmentation process. If you are not sure about what they mean it is 1356 | # a good idea to leave the defaults untouched. 1357 | 1358 | # Enabled active defragmentation 1359 | # activedefrag yes 1360 | 1361 | # Minimum amount of fragmentation waste to start active defrag 1362 | # active-defrag-ignore-bytes 100mb 1363 | 1364 | # Minimum percentage of fragmentation to start active defrag 1365 | # active-defrag-threshold-lower 10 1366 | 1367 | # Maximum percentage of fragmentation at which we use maximum effort 1368 | # active-defrag-threshold-upper 100 1369 | 1370 | # Minimal effort for defrag in CPU percentage 1371 | # active-defrag-cycle-min 5 1372 | 1373 | # Maximal effort for defrag in CPU percentage 1374 | # active-defrag-cycle-max 75 1375 | 1376 | # Maximum number of set/hash/zset/list fields that will be processed from 1377 | # the main dictionary scan 1378 | # active-defrag-max-scan-fields 1000 1379 | -------------------------------------------------------------------------------- /render.yaml: -------------------------------------------------------------------------------- 1 | services: 2 | - type: pserv 3 | name: redis 4 | env: docker 5 | autoDeploy: false 6 | disk: 7 | name: data 8 | mountPath: /var/lib/redis 9 | sizeGB: 10 10 | --------------------------------------------------------------------------------