devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

redisCluster_gcc-8.5.0-10.0.1

作者：木道寻08 | 2024-06-20 03:07:41

赞

踩

gcc-8.5.0-10.0.1

1、redis下载地址

http://redis官网

2、验证环境

  1. 查看 gcc版本
  2.  
  3. [root@yuanlnet ~]# gcc -v
  4. Using built-in specs.
  5. COLLECT_GCC=gcc
  6. COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper
  7. OFFLOAD_TARGET_NAMES=nvptx-none
  8. OFFLOAD_TARGET_DEFAULT=1
  9. Target: x86_64-redhat-linux
  10. Configured with: ../configure --enable-bootstrap --enable-languages=c,c++,fortran,lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://bugzilla.openanolis.cn --enable-shared --enable-threads=posix --enable-checking=release --disable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
  11. Thread model: posix
  12. gcc version 8.5.0 20210514 (Anolis 8.5.0-10.0.1) (GCC) 
  13.  
  14. 以上信息表明，当前的linux系统上已经安装gcc；
  15. 如果没有安装，则用一下命令安装：
  16. yum install -y gcc
  17.  
  18. [root@yuanlnet ~]# yum install -y gcc
  19. Last metadata expiration check: 0:48:14 ago on Wed 22 Mar 2023 12:55:02 PM CST.
  20. Package gcc-8.5.0-10.1.0.1.an8_6.x86_64 is already installed.
  21. Dependencies resolved.
  22. Nothing to do.
  23. Complete!

3、解压、编译

  1. #将文件上传到home目录中
  2. [root@yuanlnet home]# cd /opt/
  3. #解压
  4. [root@yuanlnet home]# tar -zxvf redis-7.2.0.tar.gz
  5. #编译
  6. [root@yuanlnet redis-7.2.0]# make
  7. #安装
  8. [root@yuanlnet redis-7.2.0]# make install PREFIX=/home/redisCluster/redis/redis-7.2.0

4、创建目录

  1. [root@localhost ~]# cd /home/redisCluster/
  2. [root@localhost redisCluster]# ll
  3. 总用量 0
  4. drwxr-xr-x. 2 root root 144 10月 17 15:08 conf
  5. drwxr-xr-x. 2 root root   6 10月 17 15:08 data
  6. drwxr-xr-x. 2 root root   6 10月 17 15:08 logs
  7. drwxr-xr-x. 3 root root  51 10月 17 15:10 redis

conf：存放配置文件

data：存放redis数据文件

logs：存放日志

redis：存放解压、编、译安装后的redis数据库

5、集群配置文件

  1. [root@localhost redisCluster]# cd conf/
  2. [root@localhost conf]# ll
  3. 总用量 648
  4. -rw-r--r--. 1 root root 107583 10月 17 15:08 redis-8001.conf
  5. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8002.conf
  6. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8003.conf
  7. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8004.conf
  8. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8005.conf
  9. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8006.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. # Note that 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. # Included paths may contain wildcards. All files matching the wildcards will
  36. # be included in alphabetical order.
  37. # Note that if an include path contains a wildcards but no files match it when
  38. # the server is started, the include statement will be ignored and no error will
  39. # be emitted.  It is safe, therefore, to include wildcard files from empty
  40. # directories.
  41. #
  42. # include /path/to/local.conf
  43. # include /path/to/other.conf
  44. # include /path/to/fragments/*.conf
  45. #
  47. ################################## MODULES #####################################
  49. # Load modules at startup. If the server is not able to load modules
  50. # it will abort. It is possible to use multiple loadmodule directives.
  51. #
  52. # loadmodule /path/to/my_module.so
  53. # loadmodule /path/to/other_module.so
  55. ################################## NETWORK #####################################
  57. # By default, if no "bind" configuration directive is specified, Redis listens
  58. # for connections from all available network interfaces on the host machine.
  59. # It is possible to listen to just one or multiple selected interfaces using
  60. # the "bind" configuration directive, followed by one or more IP addresses.
  61. # Each address can be prefixed by "-", which means that redis will not fail to
  62. # start if the address is not available. Being not available only refers to
  63. # addresses that does not correspond to any network interface. Addresses that
  64. # are already in use will always fail, and unsupported protocols will always BE
  65. # silently skipped.
  66. #
  67. # Examples:
  68. #
  69. # bind 192.168.1.100 10.0.0.1     # listens on two specific IPv4 addresses
  70. # bind 127.0.0.1 ::1              # listens on loopback IPv4 and IPv6
  71. # bind * -::*                     # like the default, all available interfaces
  72. #
  73. # ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
  74. # internet, binding to all the interfaces is dangerous and will expose the
  75. # instance to everybody on the internet. So by default we uncomment the
  76. # following bind directive, that will force Redis to listen only on the
  77. # IPv4 and IPv6 (if available) loopback interface addresses (this means Redis
  78. # will only be able to accept client connections from the same host that it is
  79. # running on).
  80. #
  81. # IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES
  82. # COMMENT OUT THE FOLLOWING LINE.
  83. #
  84. # You will also need to set a password unless you explicitly disable protected
  85. # mode.
  86. # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  87. bind 192.168.1.8
  89. # By default, outgoing connections (from replica to master, from Sentinel to
  90. # instances, cluster bus, etc.) are not bound to a specific local address. In
  91. # most cases, this means the operating system will handle that based on routing
  92. # and the interface through which the connection goes out.
  93. #
  94. # Using bind-source-addr it is possible to configure a specific address to bind
  95. # to, which may also affect how the connection gets routed.
  96. #
  97. # Example:
  98. #
  99. # bind-source-addr 10.0.0.1
  101. # Protected mode is a layer of security protection, in order to avoid that
  102. # Redis instances left open on the internet are accessed and exploited.
  103. #
  104. # When protected mode is on and the default user has no password, the server
  105. # only accepts local connections from the IPv4 address (127.0.0.1), IPv6 address
  106. # (::1) or Unix domain sockets.
  107. #
  108. # By default protected mode is enabled. You should disable it only if
  109. # you are sure you want clients from other hosts to connect to Redis
  110. # even if no authentication is configured.
  111. protected-mode no
  113. # Redis uses default hardened security configuration directives to reduce the
  114. # attack surface on innocent users. Therefore, several sensitive configuration
  115. # directives are immutable, and some potentially-dangerous commands are blocked.
  116. #
  117. # Configuration directives that control files that Redis writes to (e.g., 'dir'
  118. # and 'dbfilename') and that aren't usually modified during runtime
  119. # are protected by making them immutable.
  120. #
  121. # Commands that can increase the attack surface of Redis and that aren't usually
  122. # called by users are blocked by default.
  123. #
  124. # These can be exposed to either all connections or just local ones by setting
  125. # each of the configs listed below to either of these values:
  126. #
  127. # no    - Block for any connection (remain immutable)
  128. # yes   - Allow for any connection (no protection)
  129. # local - Allow only for local connections. Ones originating from the
  130. #         IPv4 address (127.0.0.1), IPv6 address (::1) or Unix domain sockets.
  131. #
  132. # enable-protected-configs no
  133. # enable-debug-command no
  134. # enable-module-command no
  136. # Accept connections on the specified port, default is 6379 (IANA #815344).
  137. # If port 0 is specified Redis will not listen on a TCP socket.
  138. port 8001
  140. # TCP listen() backlog.
  141. #
  142. # In high requests-per-second environments you need a high backlog in order
  143. # to avoid slow clients connection issues. Note that the Linux kernel
  144. # will silently truncate it to the value of /proc/sys/net/core/somaxconn so
  145. # make sure to raise both the value of somaxconn and tcp_max_syn_backlog
  146. # in order to get the desired effect.
  147. tcp-backlog 511
  149. # Unix socket.
  150. #
  151. # Specify the path for the Unix socket that will be used to listen for
  152. # incoming connections. There is no default, so Redis will not listen
  153. # on a unix socket when not specified.
  154. #
  155. # unixsocket /run/redis.sock
  156. # unixsocketperm 700
  158. # Close the connection after a client is idle for N seconds (0 to disable)
  159. timeout 0
  161. # TCP keepalive.
  162. #
  163. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
  164. # of communication. This is useful for two reasons:
  165. #
  166. # 1) Detect dead peers.
  167. # 2) Force network equipment in the middle to consider the connection to be
  168. #    alive.
  169. #
  170. # On Linux, the specified value (in seconds) is the period used to send ACKs.
  171. # Note that to close the connection the double of the time is needed.
  172. # On other kernels the period depends on the kernel configuration.
  173. #
  174. # A reasonable value for this option is 300 seconds, which is the new
  175. # Redis default starting with Redis 3.2.1.
  176. tcp-keepalive 300
  178. # Apply OS-specific mechanism to mark the listening socket with the specified
  179. # ID, to support advanced routing and filtering capabilities.
  180. #
  181. # On Linux, the ID represents a connection mark.
  182. # On FreeBSD, the ID represents a socket cookie ID.
  183. # On OpenBSD, the ID represents a route table ID.
  184. #
  185. # The default value is 0, which implies no marking is required.
  186. # socket-mark-id 0
  188. ################################# TLS/SSL #####################################
  190. # By default, TLS/SSL is disabled. To enable it, the "tls-port" configuration
  191. # directive can be used to define TLS-listening ports. To enable TLS on the
  192. # default port, use:
  193. #
  194. # port 0
  195. # tls-port 6379
  197. # Configure a X.509 certificate and private key to use for authenticating the
  198. # server to connected clients, masters or cluster peers.  These files should be
  199. # PEM formatted.
  200. #
  201. # tls-cert-file redis.crt
  202. # tls-key-file redis.key
  203. #
  204. # If the key file is encrypted using a passphrase, it can be included here
  205. # as well.
  206. #
  207. # tls-key-file-pass secret
  209. # Normally Redis uses the same certificate for both server functions (accepting
  210. # connections) and client functions (replicating from a master, establishing
  211. # cluster bus connections, etc.).
  212. #
  213. # Sometimes certificates are issued with attributes that designate them as
  214. # client-only or server-only certificates. In that case it may be desired to use
  215. # different certificates for incoming (server) and outgoing (client)
  216. # connections. To do that, use the following directives:
  217. #
  218. # tls-client-cert-file client.crt
  219. # tls-client-key-file client.key
  220. #
  221. # If the key file is encrypted using a passphrase, it can be included here
  222. # as well.
  223. #
  224. # tls-client-key-file-pass secret
  226. # Configure a DH parameters file to enable Diffie-Hellman (DH) key exchange,
  227. # required by older versions of OpenSSL (<3.0). Newer versions do not require
  228. # this configuration and recommend against it.
  229. #
  230. # tls-dh-params-file redis.dh
  232. # Configure a CA certificate(s) bundle or directory to authenticate TLS/SSL
  233. # clients and peers.  Redis requires an explicit configuration of at least one
  234. # of these, and will not implicitly use the system wide configuration.
  235. #
  236. # tls-ca-cert-file ca.crt
  237. # tls-ca-cert-dir /etc/ssl/certs
  239. # By default, clients (including replica servers) on a TLS port are required
  240. # to authenticate using valid client side certificates.
  241. #
  242. # If "no" is specified, client certificates are not required and not accepted.
  243. # If "optional" is specified, client certificates are accepted and must be
  244. # valid if provided, but are not required.
  245. #
  246. # tls-auth-clients no
  247. # tls-auth-clients optional
  249. # By default, a Redis replica does not attempt to establish a TLS connection
  250. # with its master.
  251. #
  252. # Use the following directive to enable TLS on replication links.
  253. #
  254. # tls-replication yes
  256. # By default, the Redis Cluster bus uses a plain TCP connection. To enable
  257. # TLS for the bus protocol, use the following directive:
  258. #
  259. # tls-cluster yes
  261. # By default, only TLSv1.2 and TLSv1.3 are enabled and it is highly recommended
  262. # that older formally deprecated versions are kept disabled to reduce the attack surface.
  263. # You can explicitly specify TLS versions to support.
  264. # Allowed values are case insensitive and include "TLSv1", "TLSv1.1", "TLSv1.2",
  265. # "TLSv1.3" (OpenSSL >= 1.1.1) or any combination.
  266. # To enable only TLSv1.2 and TLSv1.3, use:
  267. #
  268. # tls-protocols "TLSv1.2 TLSv1.3"
  270. # Configure allowed ciphers.  See the ciphers(1ssl) manpage for more information
  271. # about the syntax of this string.
  272. #
  273. # Note: this configuration applies only to <= TLSv1.2.
  274. #
  275. # tls-ciphers DEFAULT:!MEDIUM
  277. # Configure allowed TLSv1.3 ciphersuites.  See the ciphers(1ssl) manpage for more
  278. # information about the syntax of this string, and specifically for TLSv1.3
  279. # ciphersuites.
  280. #
  281. # tls-ciphersuites TLS_CHACHA20_POLY1305_SHA256
  283. # When choosing a cipher, use the server's preference instead of the client
  284. # preference. By default, the server follows the client's preference.
  285. #
  286. # tls-prefer-server-ciphers yes
  288. # By default, TLS session caching is enabled to allow faster and less expensive
  289. # reconnections by clients that support it. Use the following directive to disable
  290. # caching.
  291. #
  292. # tls-session-caching no
  294. # Change the default number of TLS sessions cached. A zero value sets the cache
  295. # to unlimited size. The default size is 20480.
  296. #
  297. # tls-session-cache-size 5000
  299. # Change the default timeout of cached TLS sessions. The default timeout is 300
  300. # seconds.
  301. #
  302. # tls-session-cache-timeout 60
  304. ################################# GENERAL #####################################
  306. # By default Redis does not run as a daemon. Use 'yes' if you need it.
  307. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
  308. # When Redis is supervised by upstart or systemd, this parameter has no impact.
  309. daemonize yes
  311. # If you run Redis from upstart or systemd, Redis can interact with your
  312. # supervision tree. Options:
  313. #   supervised no      - no supervision interaction
  314. #   supervised upstart - signal upstart by putting Redis into SIGSTOP mode
  315. #                        requires "expect stop" in your upstart job config
  316. #   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
  317. #                        on startup, and updating Redis status on a regular
  318. #                        basis.
  319. #   supervised auto    - detect upstart or systemd method based on
  320. #                        UPSTART_JOB or NOTIFY_SOCKET environment variables
  321. # Note: these supervision methods only signal "process is ready."
  322. #       They do not enable continuous pings back to your supervisor.
  323. #
  324. # The default is "no". To run under upstart/systemd, you can simply uncomment
  325. # the line below:
  326. #
  327. # supervised auto
  329. # If a pid file is specified, Redis writes it where specified at startup
  330. # and removes it at exit.
  331. #
  332. # When the server runs non daemonized, no pid file is created if none is
  333. # specified in the configuration. When the server is daemonized, the pid file
  334. # is used even if not specified, defaulting to "/var/run/redis.pid".
  335. #
  336. # Creating a pid file is best effort: if Redis is not able to create it
  337. # nothing bad happens, the server will start and run normally.
  338. #
  339. # Note that on modern Linux systems "/run/redis.pid" is more conforming
  340. # and should be used instead.
  341. pidfile /var/run/redis_6379.pid
  343. # Specify the server verbosity level.
  344. # This can be one of:
  345. # debug (a lot of information, useful for development/testing)
  346. # verbose (many rarely useful info, but not a mess like the debug level)
  347. # notice (moderately verbose, what you want in production probably)
  348. # warning (only very important / critical messages are logged)
  349. # nothing (nothing is logged)
  350. loglevel nothing
  352. # Specify the log file name. Also the empty string can be used to force
  353. # Redis to log on the standard output. Note that if you use standard
  354. # output for logging but daemonize, logs will be sent to /dev/null
  355. logfile "//opt//redisCluster/logs/redis-8001.log"
  357. # To enable logging to the system logger, just set 'syslog-enabled' to yes,
  358. # and optionally update the other syslog parameters to suit your needs.
  359. # syslog-enabled no
  361. # Specify the syslog identity.
  362. # syslog-ident redis
  364. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
  365. # syslog-facility local0
  367. # To disable the built in crash log, which will possibly produce cleaner core
  368. # dumps when they are needed, uncomment the following:
  369. #
  370. # crash-log-enabled no
  372. # To disable the fast memory check that's run as part of the crash log, which
  373. # will possibly let redis terminate sooner, uncomment the following:
  374. #
  375. # crash-memcheck-enabled no
  377. # Set the number of databases. The default database is DB 0, you can select
  378. # a different one on a per-connection basis using SELECT <dbid> where
  379. # dbid is a number between 0 and 'databases'-1
  380. databases 16
  382. # By default Redis shows an ASCII art logo only when started to log to the
  383. # standard output and if the standard output is a TTY and syslog logging is
  384. # disabled. Basically this means that normally a logo is displayed only in
  385. # interactive sessions.
  386. #
  387. # However it is possible to force the pre-4.0 behavior and always show a
  388. # ASCII art logo in startup logs by setting the following option to yes.
  389. always-show-logo no
  391. # By default, Redis modifies the process title (as seen in 'top' and 'ps') to
  392. # provide some runtime information. It is possible to disable this and leave
  393. # the process name as executed by setting the following to no.
  394. set-proc-title yes
  396. # When changing the process title, Redis uses the following template to construct
  397. # the modified title.
  398. #
  399. # Template variables are specified in curly brackets. The following variables are
  400. # supported:
  401. #
  402. # {title}           Name of process as executed if parent, or type of child process.
  403. # {listen-addr}     Bind address or '*' followed by TCP or TLS port listening on, or
  404. #                   Unix socket if only that's available.
  405. # {server-mode}     Special mode, i.e. "[sentinel]" or "[cluster]".
  406. # {port}            TCP port listening on, or 0.
  407. # {tls-port}        TLS port listening on, or 0.
  408. # {unixsocket}      Unix domain socket listening on, or "".
  409. # {config-file}     Name of configuration file used.
  410. #
  411. proc-title-template "{title} {listen-addr} {server-mode}"
  413. # Set the local environment which is used for string comparison operations, and 
  414. # also affect the performance of Lua scripts. Empty String indicates the locale 
  415. # is derived from the environment variables.
  416. locale-collate ""
  418. ################################ SNAPSHOTTING  ################################
  420. # Save the DB to disk.
  421. #
  422. # save <seconds> <changes> [<seconds> <changes> ...]
  423. #
  424. # Redis will save the DB if the given number of seconds elapsed and it
  425. # surpassed the given number of write operations against the DB.
  426. #
  427. # Snapshotting can be completely disabled with a single empty string argument
  428. # as in following example:
  429. #
  430. # save ""
  431. #
  432. # Unless specified otherwise, by default Redis will save the DB:
  433. #   * After 3600 seconds (an hour) if at least 1 change was performed
  434. #   * After 300 seconds (5 minutes) if at least 100 changes were performed
  435. #   * After 60 seconds if at least 10000 changes were performed
  436. #
  437. # You can set these explicitly by uncommenting the following line.
  438. #
  439. # save 3600 1 300 100 60 10000
  441. # By default Redis will stop accepting writes if RDB snapshots are enabled
  442. # (at least one save point) and the latest background save failed.
  443. # This will make the user aware (in a hard way) that data is not persisting
  444. # on disk properly, otherwise chances are that no one will notice and some
  445. # disaster will happen.
  446. #
  447. # If the background saving process will start working again Redis will
  448. # automatically allow writes again.
  449. #
  450. # However if you have setup your proper monitoring of the Redis server
  451. # and persistence, you may want to disable this feature so that Redis will
  452. # continue to work as usual even if there are problems with disk,
  453. # permissions, and so forth.
  454. stop-writes-on-bgsave-error yes
  456. # Compress string objects using LZF when dump .rdb databases?
  457. # By default compression is enabled as it's almost always a win.
  458. # If you want to save some CPU in the saving child set it to 'no' but
  459. # the dataset will likely be bigger if you have compressible values or keys.
  460. rdbcompression yes
  462. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  463. # This makes the format more resistant to corruption but there is a performance
  464. # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
  465. # for maximum performances.
  466. #
  467. # RDB files created with checksum disabled have a checksum of zero that will
  468. # tell the loading code to skip the check.
  469. rdbchecksum yes
  471. # Enables or disables full sanitization checks for ziplist and listpack etc when
  472. # loading an RDB or RESTORE payload. This reduces the chances of a assertion or
  473. # crash later on while processing commands.
  474. # Options:
  475. #   no         - Never perform full sanitization
  476. #   yes        - Always perform full sanitization
  477. #   clients    - Perform full sanitization only for user connections.
  478. #                Excludes: RDB files, RESTORE commands received from the master
  479. #                connection, and client connections which have the
  480. #                skip-sanitize-payload ACL flag.
  481. # The default should be 'clients' but since it currently affects cluster
  482. # resharding via MIGRATE, it is temporarily set to 'no' by default.
  483. #
  484. # sanitize-dump-payload no
  486. # The filename where to dump the DB
  487. dbfilename dump-8001.rdb
  489. # Remove RDB files used by replication in instances without persistence
  490. # enabled. By default this option is disabled, however there are environments
  491. # where for regulations or other security concerns, RDB files persisted on
  492. # disk by masters in order to feed replicas, or stored on disk by replicas
  493. # in order to load them for the initial synchronization, should be deleted
  494. # ASAP. Note that this option ONLY WORKS in instances that have both AOF
  495. # and RDB persistence disabled, otherwise is completely ignored.
  496. #
  497. # An alternative (and sometimes better) way to obtain the same effect is
  498. # to use diskless replication on both master and replicas instances. However
  499. # in the case of replicas, diskless is not always an option.
  500. rdb-del-sync-files no
  502. # The working directory.
  503. #
  504. # The DB will be written inside this directory, with the filename specified
  505. # above using the 'dbfilename' configuration directive.
  506. #
  507. # The Append Only File will also be created inside this directory.
  508. #
  509. # Note that you must specify a directory here, not a file name.
  510. dir "//opt//redisCluster/data"
  512. ################################# REPLICATION #################################
  514. # Master-Replica replication. Use replicaof to make a Redis instance a copy of
  515. # another Redis server. A few things to understand ASAP about Redis replication.
  516. #
  517. #   +------------------+      +---------------+
  518. #   |      Master      | ---> |    Replica    |
  519. #   | (receive writes) |      |  (exact copy) |
  520. #   +------------------+      +---------------+
  521. #
  522. # 1) Redis replication is asynchronous, but you can configure a master to
  523. #    stop accepting writes if it appears to be not connected with at least
  524. #    a given number of replicas.
  525. # 2) Redis replicas are able to perform a partial resynchronization with the
  526. #    master if the replication link is lost for a relatively small amount of
  527. #    time. You may want to configure the replication backlog size (see the next
  528. #    sections of this file) with a sensible value depending on your needs.
  529. # 3) Replication is automatic and does not need user intervention. After a
  530. #    network partition replicas automatically try to reconnect to masters
  531. #    and resynchronize with them.
  532. #
  533. # replicaof <masterip> <masterport>
  535. # If the master is password protected (using the "requirepass" configuration
  536. # directive below) it is possible to tell the replica to authenticate before
  537. # starting the replication synchronization process, otherwise the master will
  538. # refuse the replica request.
  539. #
  540. # masterauth "redis_123456"
  541. #
  542. # However this is not enough if you are using Redis ACLs (for Redis version
  543. # 6 or greater), and the default user is not capable of running the PSYNC
  544. # command and/or other commands needed for replication. In this case it's
  545. # better to configure a special user to use with replication, and specify the
  546. # masteruser configuration as such:
  547. #
  548. # masteruser <username>
  549. #
  550. # When masteruser is specified, the replica will authenticate against its
  551. # master using the new AUTH form: AUTH <username> <password>.
  553. # When a replica loses its connection with the master, or when the replication
  554. # is still in progress, the replica can act in two different ways:
  555. #
  556. # 1) if replica-serve-stale-data is set to 'yes' (the default) the replica will
  557. #    still reply to client requests, possibly with out of date data, or the
  558. #    data set may just be empty if this is the first synchronization.
  559. #
  560. # 2) If replica-serve-stale-data is set to 'no' the replica will reply with error
  561. #    "MASTERDOWN Link with MASTER is down and replica-serve-stale-data is set to 'no'"
  562. #    to all data access commands, excluding commands such as:
  563. #    INFO, REPLICAOF, AUTH, SHUTDOWN, REPLCONF, ROLE, CONFIG, SUBSCRIBE,
  564. #    UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB, COMMAND, POST,
  565. #    HOST and LATENCY.
  566. #
  567. replica-serve-stale-data yes
  569. # You can configure a replica instance to accept writes or not. Writing against
  570. # a replica instance may be useful to store some ephemeral data (because data
  571. # written on a replica will be easily deleted after resync with the master) but
  572. # may also cause problems if clients are writing to it because of a
  573. # misconfiguration.
  574. #
  575. # Since Redis 2.6 by default replicas are read-only.
  576. #
  577. # Note: read only replicas are not designed to be exposed to untrusted clients
  578. # on the internet. It's just a protection layer against misuse of the instance.
  579. # Still a read only replica exports by default all the administrative commands
  580. # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
  581. # security of read only replicas using 'rename-command' to shadow all the
  582. # administrative / dangerous commands.
  583. replica-read-only yes
  585. # Replication SYNC strategy: disk or socket.
  586. #
  587. # New replicas and reconnecting replicas that are not able to continue the
  588. # replication process just receiving differences, need to do what is called a
  589. # "full synchronization". An RDB file is transmitted from the master to the
  590. # replicas.
  591. #
  592. # The transmission can happen in two different ways:
  593. #
  594. # 1) Disk-backed: The Redis master creates a new process that writes the RDB
  595. #                 file on disk. Later the file is transferred by the parent
  596. #                 process to the replicas incrementally.
  597. # 2) Diskless: The Redis master creates a new process that directly writes the
  598. #              RDB file to replica sockets, without touching the disk at all.
  599. #
  600. # With disk-backed replication, while the RDB file is generated, more replicas
  601. # can be queued and served with the RDB file as soon as the current child
  602. # producing the RDB file finishes its work. With diskless replication instead
  603. # once the transfer starts, new replicas arriving will be queued and a new
  604. # transfer will start when the current one terminates.
  605. #
  606. # When diskless replication is used, the master waits a configurable amount of
  607. # time (in seconds) before starting the transfer in the hope that multiple
  608. # replicas will arrive and the transfer can be parallelized.
  609. #
  610. # With slow disks and fast (large bandwidth) networks, diskless replication
  611. # works better.
  612. repl-diskless-sync yes
  614. # When diskless replication is enabled, it is possible to configure the delay
  615. # the server waits in order to spawn the child that transfers the RDB via socket
  616. # to the replicas.
  617. #
  618. # This is important since once the transfer starts, it is not possible to serve
  619. # new replicas arriving, that will be queued for the next RDB transfer, so the
  620. # server waits a delay in order to let more replicas arrive.
  621. #
  622. # The delay is specified in seconds, and by default is 5 seconds. To disable
  623. # it entirely just set it to 0 seconds and the transfer will start ASAP.
  624. repl-diskless-sync-delay 5
  626. # When diskless replication is enabled with a delay, it is possible to let
  627. # the replication start before the maximum delay is reached if the maximum
  628. # number of replicas expected have connected. Default of 0 means that the
  629. # maximum is not defined and Redis will wait the full delay.
  630. repl-diskless-sync-max-replicas 0
  632. # -----------------------------------------------------------------------------
  633. # WARNING: Since in this setup the replica does not immediately store an RDB on
  634. # disk, it may cause data loss during failovers. RDB diskless load + Redis
  635. # modules not handling I/O reads may cause Redis to abort in case of I/O errors
  636. # during the initial synchronization stage with the master.
  637. # -----------------------------------------------------------------------------
  638. #
  639. # Replica can load the RDB it reads from the replication link directly from the
  640. # socket, or store the RDB to a file and read that file after it was completely
  641. # received from the master.
  642. #
  643. # In many cases the disk is slower than the network, and storing and loading
  644. # the RDB file may increase replication time (and even increase the master's
  645. # Copy on Write memory and replica buffers).
  646. # However, when parsing the RDB file directly from the socket, in order to avoid
  647. # data loss it's only safe to flush the current dataset when the new dataset is
  648. # fully loaded in memory, resulting in higher memory usage.
  649. # For this reason we have the following options:
  650. #
  651. # "disabled"    - Don't use diskless load (store the rdb file to the disk first)
  652. # "swapdb"      - Keep current db contents in RAM while parsing the data directly
  653. #                 from the socket. Replicas in this mode can keep serving current
  654. #                 dataset while replication is in progress, except for cases where
  655. #                 they can't recognize master as having a data set from same
  656. #                 replication history.
  657. #                 Note that this requires sufficient memory, if you don't have it,
  658. #                 you risk an OOM kill.
  659. # "on-empty-db" - Use diskless load only when current dataset is empty. This is 
  660. #                 safer and avoid having old and new dataset loaded side by side
  661. #                 during replication.
  662. repl-diskless-load disabled
  664. # Master send PINGs to its replicas in a predefined interval. It's possible to
  665. # change this interval with the repl_ping_replica_period option. The default
  666. # value is 10 seconds.
  667. #
  668. # repl-ping-replica-period 10
  670. # The following option sets the replication timeout for:
  671. #
  672. # 1) Bulk transfer I/O during SYNC, from the point of view of replica.
  673. # 2) Master timeout from the point of view of replicas (data, pings).
  674. # 3) Replica timeout from the point of view of masters (REPLCONF ACK pings).
  675. #
  676. # It is important to make sure that this value is greater than the value
  677. # specified for repl-ping-replica-period otherwise a timeout will be detected
  678. # every time there is low traffic between the master and the replica. The default
  679. # value is 60 seconds.
  680. #
  681. # repl-timeout 60
  683. # Disable TCP_NODELAY on the replica socket after SYNC?
  684. #
  685. # If you select "yes" Redis will use a smaller number of TCP packets and
  686. # less bandwidth to send data to replicas. But this can add a delay for
  687. # the data to appear on the replica side, up to 40 milliseconds with
  688. # Linux kernels using a default configuration.
  689. #
  690. # If you select "no" the delay for data to appear on the replica side will
  691. # be reduced but more bandwidth will be used for replication.
  692. #
  693. # By default we optimize for low latency, but in very high traffic conditions
  694. # or when the master and replicas are many hops away, turning this to "yes" may
  695. # be a good idea.
  696. repl-disable-tcp-nodelay no
  698. # Set the replication backlog size. The backlog is a buffer that accumulates
  699. # replica data when replicas are disconnected for some time, so that when a
  700. # replica wants to reconnect again, often a full resync is not needed, but a
  701. # partial resync is enough, just passing the portion of data the replica
  702. # missed while disconnected.
  703. #
  704. # The bigger the replication backlog, the longer the replica can endure the
  705. # disconnect and later be able to perform a partial resynchronization.
  706. #
  707. # The backlog is only allocated if there is at least one replica connected.
  708. #
  709. # repl-backlog-size 1mb
  711. # After a master has no connected replicas for some time, the backlog will be
  712. # freed. The following option configures the amount of seconds that need to
  713. # elapse, starting from the time the last replica disconnected, for the backlog
  714. # buffer to be freed.
  715. #
  716. # Note that replicas never free the backlog for timeout, since they may be
  717. # promoted to masters later, and should be able to correctly "partially
  718. # resynchronize" with other replicas: hence they should always accumulate backlog.
  719. #
  720. # A value of 0 means to never release the backlog.
  721. #
  722. # repl-backlog-ttl 3600
  724. # The replica priority is an integer number published by Redis in the INFO
  725. # output. It is used by Redis Sentinel in order to select a replica to promote
  726. # into a master if the master is no longer working correctly.
  727. #
  728. # A replica with a low priority number is considered better for promotion, so
  729. # for instance if there are three replicas with priority 10, 100, 25 Sentinel
  730. # will pick the one with priority 10, that is the lowest.
  731. #
  732. # However a special priority of 0 marks the replica as not able to perform the
  733. # role of master, so a replica with priority of 0 will never be selected by
  734. # Redis Sentinel for promotion.
  735. #
  736. # By default the priority is 100.
  737. replica-priority 100
  739. # The propagation error behavior controls how Redis will behave when it is
  740. # unable to handle a command being processed in the replication stream from a master
  741. # or processed while reading from an AOF file. Errors that occur during propagation
  742. # are unexpected, and can cause data inconsistency. However, there are edge cases
  743. # in earlier versions of Redis where it was possible for the server to replicate or persist
  744. # commands that would fail on future versions. For this reason the default behavior
  745. # is to ignore such errors and continue processing commands.
  746. #
  747. # If an application wants to ensure there is no data divergence, this configuration
  748. # should be set to 'panic' instead. The value can also be set to 'panic-on-replicas'
  749. # to only panic when a replica encounters an error on the replication stream. One of
  750. # these two panic values will become the default value in the future once there are
  751. # sufficient safety mechanisms in place to prevent false positive crashes.
  752. #
  753. # propagation-error-behavior ignore
  755. # Replica ignore disk write errors controls the behavior of a replica when it is
  756. # unable to persist a write command received from its master to disk. By default,
  757. # this configuration is set to 'no' and will crash the replica in this condition.
  758. # It is not recommended to change this default, however in order to be compatible
  759. # with older versions of Redis this config can be toggled to 'yes' which will just
  760. # log a warning and execute the write command it got from the master.
  761. #
  762. # replica-ignore-disk-write-errors no
  764. # -----------------------------------------------------------------------------
  765. # By default, Redis Sentinel includes all replicas in its reports. A replica
  766. # can be excluded from Redis Sentinel's announcements. An unannounced replica
  767. # will be ignored by the 'sentinel replicas <master>' command and won't be
  768. # exposed to Redis Sentinel's clients.
  769. #
  770. # This option does not change the behavior of replica-priority. Even with
  771. # replica-announced set to 'no', the replica can be promoted to master. To
  772. # prevent this behavior, set replica-priority to 0.
  773. #
  774. # replica-announced yes
  776. # It is possible for a master to stop accepting writes if there are less than
  777. # N replicas connected, having a lag less or equal than M seconds.
  778. #
  779. # The N replicas need to be in "online" state.
  780. #
  781. # The lag in seconds, that must be <= the specified value, is calculated from
  782. # the last ping received from the replica, that is usually sent every second.
  783. #
  784. # This option does not GUARANTEE that N replicas will accept the write, but
  785. # will limit the window of exposure for lost writes in case not enough replicas
  786. # are available, to the specified number of seconds.
  787. #
  788. # For example to require at least 3 replicas with a lag <= 10 seconds use:
  789. #
  790. # min-replicas-to-write 3
  791. # min-replicas-max-lag 10
  792. #
  793. # Setting one or the other to 0 disables the feature.
  794. #
  795. # By default min-replicas-to-write is set to 0 (feature disabled) and
  796. # min-replicas-max-lag is set to 10.
  798. # A Redis master is able to list the address and port of the attached
  799. # replicas in different ways. For example the "INFO replication" section
  800. # offers this information, which is used, among other tools, by
  801. # Redis Sentinel in order to discover replica instances.
  802. # Another place where this info is available is in the output of the
  803. # "ROLE" command of a master.
  804. #
  805. # The listed IP address and port normally reported by a replica is
  806. # obtained in the following way:
  807. #
  808. #   IP: The address is auto detected by checking the peer address
  809. #   of the socket used by the replica to connect with the master.
  810. #
  811. #   Port: The port is communicated by the replica during the replication
  812. #   handshake, and is normally the port that the replica is using to
  813. #   listen for connections.
  814. #
  815. # However when port forwarding or Network Address Translation (NAT) is
  816. # used, the replica may actually be reachable via different IP and port
  817. # pairs. The following two options can be used by a replica in order to
  818. # report to its master a specific set of IP and port, so that both INFO
  819. # and ROLE will report those values.
  820. #
  821. # There is no need to use both the options if you need to override just
  822. # the port or the IP address.
  823. #
  824. # replica-announce-ip 5.5.5.5
  825. # replica-announce-port 1234
  827. ############################### KEYS TRACKING #################################
  829. # Redis implements server assisted support for client side caching of values.
  830. # This is implemented using an invalidation table that remembers, using
  831. # a radix key indexed by key name, what clients have which keys. In turn
  832. # this is used in order to send invalidation messages to clients. Please
  833. # check this page to understand more about the feature:
  834. #
  835. #   https://redis.io/topics/client-side-caching
  836. #
  837. # When tracking is enabled for a client, all the read only queries are assumed
  838. # to be cached: this will force Redis to store information in the invalidation
  839. # table. When keys are modified, such information is flushed away, and
  840. # invalidation messages are sent to the clients. However if the workload is
  841. # heavily dominated by reads, Redis could use more and more memory in order
  842. # to track the keys fetched by many clients.
  843. #
  844. # For this reason it is possible to configure a maximum fill value for the
  845. # invalidation table. By default it is set to 1M of keys, and once this limit
  846. # is reached, Redis will start to evict keys in the invalidation table
  847. # even if they were not modified, just to reclaim memory: this will in turn
  848. # force the clients to invalidate the cached values. Basically the table
  849. # maximum size is a trade off between the memory you want to spend server
  850. # side to track information about who cached what, and the ability of clients
  851. # to retain cached objects in memory.
  852. #
  853. # If you set the value to 0, it means there are no limits, and Redis will
  854. # retain as many keys as needed in the invalidation table.
  855. # In the "stats" INFO section, you can find information about the number of
  856. # keys in the invalidation table at every given moment.
  857. #
  858. # Note: when key tracking is used in broadcasting mode, no memory is used
  859. # in the server side so this setting is useless.
  860. #
  861. # tracking-table-max-keys 1000000
  863. ################################## SECURITY ###################################
  865. # Warning: since Redis is pretty fast, an outside user can try up to
  866. # 1 million passwords per second against a modern box. This means that you
  867. # should use very strong passwords, otherwise they will be very easy to break.
  868. # Note that because the password is really a shared secret between the client
  869. # and the server, and should not be memorized by any human, the password
  870. # can be easily a long string from /dev/urandom or whatever, so by using a
  871. # long and unguessable password no brute force attack will be possible.
  873. # Redis ACL users are defined in the following format:
  874. #
  875. #   user <username> ... acl rules ...
  876. #
  877. # For example:
  878. #
  879. #   user worker +@list +@connection ~jobs:* on >ffa9203c493aa99
  880. #
  881. # The special username "default" is used for new connections. If this user
  882. # has the "nopass" rule, then new connections will be immediately authenticated
  883. # as the "default" user without the need of any password provided via the
  884. # AUTH command. Otherwise if the "default" user is not flagged with "nopass"
  885. # the connections will start in not authenticated state, and will require
  886. # AUTH (or the HELLO command AUTH option) in order to be authenticated and
  887. # start to work.
  888. #
  889. # The ACL rules that describe what a user can do are the following:
  890. #
  891. #  on           Enable the user: it is possible to authenticate as this user.
  892. #  off          Disable the user: it's no longer possible to authenticate
  893. #               with this user, however the already authenticated connections
  894. #               will still work.
  895. #  skip-sanitize-payload    RESTORE dump-payload sanitization is skipped.
  896. #  sanitize-payload         RESTORE dump-payload is sanitized (default).
  897. #  +<command>   Allow the execution of that command.
  898. #               May be used with `|` for allowing subcommands (e.g "+config|get")
  899. #  -<command>   Disallow the execution of that command.
  900. #               May be used with `|` for blocking subcommands (e.g "-config|set")
  901. #  +@<category> Allow the execution of all the commands in such category
  902. #               with valid categories are like @admin, @set, @sortedset, ...
  903. #               and so forth, see the full list in the server.c file where
  904. #               the Redis command table is described and defined.
  905. #               The special category @all means all the commands, but currently
  906. #               present in the server, and that will be loaded in the future
  907. #               via modules.
  908. #  +<command>|first-arg  Allow a specific first argument of an otherwise
  909. #                        disabled command. It is only supported on commands with
  910. #                        no sub-commands, and is not allowed as negative form
  911. #                        like -SELECT|1, only additive starting with "+". This
  912. #                        feature is deprecated and may be removed in the future.
  913. #  allcommands  Alias for +@all. Note that it implies the ability to execute
  914. #               all the future commands loaded via the modules system.
  915. #  nocommands   Alias for -@all.
  916. #  ~<pattern>   Add a pattern of keys that can be mentioned as part of
  917. #               commands. For instance ~* allows all the keys. The pattern
  918. #               is a glob-style pattern like the one of KEYS.
  919. #               It is possible to specify multiple patterns.
  920. # %R~<pattern>  Add key read pattern that specifies which keys can be read 
  921. #               from.
  922. # %W~<pattern>  Add key write pattern that specifies which keys can be
  923. #               written to. 
  924. #  allkeys      Alias for ~*
  925. #  resetkeys    Flush the list of allowed keys patterns.
  926. #  &<pattern>   Add a glob-style pattern of Pub/Sub channels that can be
  927. #               accessed by the user. It is possible to specify multiple channel
  928. #               patterns.
  929. #  allchannels  Alias for &*
  930. #  resetchannels            Flush the list of allowed channel patterns.
  931. #  ><password>  Add this password to the list of valid password for the user.
  932. #               For example >mypass will add "mypass" to the list.
  933. #               This directive clears the "nopass" flag (see later).
  934. #  <<password>  Remove this password from the list of valid passwords.
  935. #  nopass       All the set passwords of the user are removed, and the user
  936. #               is flagged as requiring no password: it means that every
  937. #               password will work against this user. If this directive is
  938. #               used for the default user, every new connection will be
  939. #               immediately authenticated with the default user without
  940. #               any explicit AUTH command required. Note that the "resetpass"
  941. #               directive will clear this condition.
  942. #  resetpass    Flush the list of allowed passwords. Moreover removes the
  943. #               "nopass" status. After "resetpass" the user has no associated
  944. #               passwords and there is no way to authenticate without adding
  945. #               some password (or setting it as "nopass" later).
  946. #  reset        Performs the following actions: resetpass, resetkeys, resetchannels,
  947. #               allchannels (if acl-pubsub-default is set), off, clearselectors, -@all.
  948. #               The user returns to the same state it has immediately after its creation.
  949. # (<options>)   Create a new selector with the options specified within the
  950. #               parentheses and attach it to the user. Each option should be 
  951. #               space separated. The first character must be ( and the last 
  952. #               character must be ).
  953. # clearselectors            Remove all of the currently attached selectors. 
  954. #                           Note this does not change the "root" user permissions,
  955. #                           which are the permissions directly applied onto the
  956. #                           user (outside the parentheses).
  957. #
  958. # ACL rules can be specified in any order: for instance you can start with
  959. # passwords, then flags, or key patterns. However note that the additive
  960. # and subtractive rules will CHANGE MEANING depending on the ordering.
  961. # For instance see the following example:
  962. #
  963. #   user alice on +@all -DEBUG ~* >somepassword
  964. #
  965. # This will allow "alice" to use all the commands with the exception of the
  966. # DEBUG command, since +@all added all the commands to the set of the commands
  967. # alice can use, and later DEBUG was removed. However if we invert the order
  968. # of two ACL rules the result will be different:
  969. #
  970. #   user alice on -DEBUG +@all ~* >somepassword
  971. #
  972. # Now DEBUG was removed when alice had yet no commands in the set of allowed
  973. # commands, later all the commands are added, so the user will be able to
  974. # execute everything.
  975. #
  976. # Basically ACL rules are processed left-to-right.
  977. #
  978. # The following is a list of command categories and their meanings:
  979. # * keyspace - Writing or reading from keys, databases, or their metadata 
  980. #     in a type agnostic way. Includes DEL, RESTORE, DUMP, RENAME, EXISTS, DBSIZE,
  981. #     KEYS, EXPIRE, TTL, FLUSHALL, etc. Commands that may modify the keyspace,
  982. #     key or metadata will also have `write` category. Commands that only read
  983. #     the keyspace, key or metadata will have the `read` category.
  984. # * read - Reading from keys (values or metadata). Note that commands that don't
  985. #     interact with keys, will not have either `read` or `write`.
  986. # * write - Writing to keys (values or metadata)
  987. # * admin - Administrative commands. Normal applications will never need to use
  988. #     these. Includes REPLICAOF, CONFIG, DEBUG, SAVE, MONITOR, ACL, SHUTDOWN, etc.
  989. # * dangerous - Potentially dangerous (each should be considered with care for
  990. #     various reasons). This includes FLUSHALL, MIGRATE, RESTORE, SORT, KEYS,
  991. #     CLIENT, DEBUG, INFO, CONFIG, SAVE, REPLICAOF, etc.
  992. # * connection - Commands affecting the connection or other connections.
  993. #     This includes AUTH, SELECT, COMMAND, CLIENT, ECHO, PING, etc.
  994. # * blocking - Potentially blocking the connection until released by another
  995. #     command.
  996. # * fast - Fast O(1) commands. May loop on the number of arguments, but not the
  997. #     number of elements in the key.
  998. # * slow - All commands that are not Fast.
  999. # * pubsub - PUBLISH / SUBSCRIBE related
  1000. # * transaction - WATCH / MULTI / EXEC related commands.
  1001. # * scripting - Scripting related.
  1002. # * set - Data type: sets related.
  1003. # * sortedset - Data type: zsets related.
  1004. # * list - Data type: lists related.
  1005. # * hash - Data type: hashes related.
  1006. # * string - Data type: strings related.
  1007. # * bitmap - Data type: bitmaps related.
  1008. # * hyperloglog - Data type: hyperloglog related.
  1009. # * geo - Data type: geo related.
  1010. # * stream - Data type: streams related.
  1011. #
  1012. # For more information about ACL configuration please refer to
  1013. # the Redis web site at https://redis.io/topics/acl
  1015. # ACL LOG
  1016. #
  1017. # The ACL Log tracks failed commands and authentication events associated
  1018. # with ACLs. The ACL Log is useful to troubleshoot failed commands blocked
  1019. # by ACLs. The ACL Log is stored in memory. You can reclaim memory with
  1020. # ACL LOG RESET. Define the maximum entry length of the ACL Log below.
  1021. acllog-max-len 128
  1023. # Using an external ACL file
  1024. #
  1025. # Instead of configuring users here in this file, it is possible to use
  1026. # a stand-alone file just listing users. The two methods cannot be mixed:
  1027. # if you configure users here and at the same time you activate the external
  1028. # ACL file, the server will refuse to start.
  1029. #
  1030. # The format of the external ACL user file is exactly the same as the
  1031. # format that is used inside redis.conf to describe users.
  1032. #
  1033. # aclfile /etc/redis/users.acl
  1035. # IMPORTANT NOTE: starting with Redis 6 "requirepass" is just a compatibility
  1036. # layer on top of the new ACL system. The option effect will be just setting
  1037. # the password for the default user. Clients will still authenticate using
  1038. # AUTH <password> as usually, or more explicitly with AUTH default <password>
  1039. # if they follow the new protocol: both will work.
  1040. #
  1041. # The requirepass is not compatible with aclfile option and the ACL LOAD 1
  1042. # command, these will cause requirepass to be ignored.
  1043. #
  1044. requirepass "myRedisCluster"
  1046. # New users are initialized with restrictive permissions by default, via the
  1047. # equivalent of this ACL rule 'off resetkeys -@all'. Starting with Redis 6.2, it
  1048. # is possible to manage access to Pub/Sub channels with ACL rules as well. The
  1049. # default Pub/Sub channels permission if new users is controlled by the
  1050. # acl-pubsub-default configuration directive, which accepts one of these values:
  1051. #
  1052. # allchannels: grants access to all Pub/Sub channels
  1053. # resetchannels: revokes access to all Pub/Sub channels
  1054. #
  1055. # From Redis 7.0, acl-pubsub-default defaults to 'resetchannels' permission.
  1056. #
  1057. # acl-pubsub-default resetchannels
  1059. # Command renaming (DEPRECATED).
  1060. #
  1061. # ------------------------------------------------------------------------
  1062. # WARNING: avoid using this option if possible. Instead use ACLs to remove
  1063. # commands from the default user, and put them only in some admin user you
  1064. # create for administrative purposes.
  1065. # ------------------------------------------------------------------------
  1066. #
  1067. # It is possible to change the name of dangerous commands in a shared
  1068. # environment. For instance the CONFIG command may be renamed into something
  1069. # hard to guess so that it will still be available for internal-use tools
  1070. # but not available for general clients.
  1071. #
  1072. # Example:
  1073. #
  1074. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  1075. #
  1076. # It is also possible to completely kill a command by renaming it into
  1077. # an empty string:
  1078. #
  1079. # rename-command CONFIG ""
  1080. #
  1081. # Please note that changing the name of commands that are logged into the
  1082. # AOF file or transmitted to replicas may cause problems.
  1084. ################################### CLIENTS ####################################
  1086. # Set the max number of connected clients at the same time. By default
  1087. # this limit is set to 10000 clients, however if the Redis server is not
  1088. # able to configure the process file limit to allow for the specified limit
  1089. # the max number of allowed clients is set to the current file limit
  1090. # minus 32 (as Redis reserves a few file descriptors for internal uses).
  1091. #
  1092. # Once the limit is reached Redis will close all the new connections sending
  1093. # an error 'max number of clients reached'.
  1094. #
  1095. # IMPORTANT: When Redis Cluster is used, the max number of connections is also
  1096. # shared with the cluster bus: every node in the cluster will use two
  1097. # connections, one incoming and another outgoing. It is important to size the
  1098. # limit accordingly in case of very large clusters.
  1099. #
  1100. # maxclients 10000
  1102. ############################## MEMORY MANAGEMENT ################################
  1104. # Set a memory usage limit to the specified amount of bytes.
  1105. # When the memory limit is reached Redis will try to remove keys
  1106. # according to the eviction policy selected (see maxmemory-policy).
  1107. #
  1108. # If Redis can't remove keys according to the policy, or if the policy is
  1109. # set to 'noeviction', Redis will start to reply with errors to commands
  1110. # that would use more memory, like SET, LPUSH, and so on, and will continue
  1111. # to reply to read-only commands like GET.
  1112. #
  1113. # This option is usually useful when using Redis as an LRU or LFU cache, or to
  1114. # set a hard memory limit for an instance (using the 'noeviction' policy).
  1115. #
  1116. # WARNING: If you have replicas attached to an instance with maxmemory on,
  1117. # the size of the output buffers needed to feed the replicas are subtracted
  1118. # from the used memory count, so that network problems / resyncs will
  1119. # not trigger a loop where keys are evicted, and in turn the output
  1120. # buffer of replicas is full with DELs of keys evicted triggering the deletion
  1121. # of more keys, and so forth until the database is completely emptied.
  1122. #
  1123. # In short... if you have replicas attached it is suggested that you set a lower
  1124. # limit for maxmemory so that there is some free RAM on the system for replica
  1125. # output buffers (but this is not needed if the policy is 'noeviction').
  1126. #
  1127. # maxmemory <bytes>
  1129. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
  1130. # is reached. You can select one from the following behaviors:
  1131. #
  1132. # volatile-lru -> Evict using approximated LRU, only keys with an expire set.
  1133. # allkeys-lru -> Evict any key using approximated LRU.
  1134. # volatile-lfu -> Evict using approximated LFU, only keys with an expire set.
  1135. # allkeys-lfu -> Evict any key using approximated LFU.
  1136. # volatile-random -> Remove a random key having an expire set.
  1137. # allkeys-random -> Remove a random key, any key.
  1138. # volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
  1139. # noeviction -> Don't evict anything, just return an error on write operations.
  1140. #
  1141. # LRU means Least Recently Used
  1142. # LFU means Least Frequently Used
  1143. #
  1144. # Both LRU, LFU and volatile-ttl are implemented using approximated
  1145. # randomized algorithms.
  1146. #
  1147. # Note: with any of the above policies, when there are no suitable keys for
  1148. # eviction, Redis will return an error on write operations that require
  1149. # more memory. These are usually commands that create new keys, add data or
  1150. # modify existing keys. A few examples are: SET, INCR, HSET, LPUSH, SUNIONSTORE,
  1151. # SORT (due to the STORE argument), and EXEC (if the transaction includes any
  1152. # command that requires memory).
  1153. #
  1154. # The default is:
  1155. #
  1156. # maxmemory-policy noeviction
  1158. # LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated
  1159. # algorithms (in order to save memory), so you can tune it for speed or
  1160. # accuracy. By default Redis will check five keys and pick the one that was
  1161. # used least recently, you can change the sample size using the following
  1162. # configuration directive.
  1163. #
  1164. # The default of 5 produces good enough results. 10 Approximates very closely
  1165. # true LRU but costs more CPU. 3 is faster but not very accurate.
  1166. #
  1167. # maxmemory-samples 5
  1169. # Eviction processing is designed to function well with the default setting.
  1170. # If there is an unusually large amount of write traffic, this value may need to
  1171. # be increased.  Decreasing this value may reduce latency at the risk of
  1172. # eviction processing effectiveness
  1173. #   0 = minimum latency, 10 = default, 100 = process without regard to latency
  1174. #
  1175. # maxmemory-eviction-tenacity 10
  1177. # Starting from Redis 5, by default a replica will ignore its maxmemory setting
  1178. # (unless it is promoted to master after a failover or manually). It means
  1179. # that the eviction of keys will be just handled by the master, sending the
  1180. # DEL commands to the replica as keys evict in the master side.
  1181. #
  1182. # This behavior ensures that masters and replicas stay consistent, and is usually
  1183. # what you want, however if your replica is writable, or you want the replica
  1184. # to have a different memory setting, and you are sure all the writes performed
  1185. # to the replica are idempotent, then you may change this default (but be sure
  1186. # to understand what you are doing).
  1187. #
  1188. # Note that since the replica by default does not evict, it may end using more
  1189. # memory than the one set via maxmemory (there are certain buffers that may
  1190. # be larger on the replica, or data structures may sometimes take more memory
  1191. # and so forth). So make sure you monitor your replicas and make sure they
  1192. # have enough memory to never hit a real out-of-memory condition before the
  1193. # master hits the configured maxmemory setting.
  1194. #
  1195. # replica-ignore-maxmemory yes
  1197. # Redis reclaims expired keys in two ways: upon access when those keys are
  1198. # found to be expired, and also in background, in what is called the
  1199. # "active expire key". The key space is slowly and interactively scanned
  1200. # looking for expired keys to reclaim, so that it is possible to free memory
  1201. # of keys that are expired and will never be accessed again in a short time.
  1202. #
  1203. # The default effort of the expire cycle will try to avoid having more than
  1204. # ten percent of expired keys still in memory, and will try to avoid consuming
  1205. # more than 25% of total memory and to add latency to the system. However
  1206. # it is possible to increase the expire "effort" that is normally set to
  1207. # "1", to a greater value, up to the value "10". At its maximum value the
  1208. # system will use more CPU, longer cycles (and technically may introduce
  1209. # more latency), and will tolerate less already expired keys still present
  1210. # in the system. It's a tradeoff between memory, CPU and latency.
  1211. #
  1212. # active-expire-effort 1
  1214. ############################# LAZY FREEING ####################################
  1216. # Redis has two primitives to delete keys. One is called DEL and is a blocking
  1217. # deletion of the object. It means that the server stops processing new commands
  1218. # in order to reclaim all the memory associated with an object in a synchronous
  1219. # way. If the key deleted is associated with a small object, the time needed
  1220. # in order to execute the DEL command is very small and comparable to most other
  1221. # O(1) or O(log_N) commands in Redis. However if the key is associated with an
  1222. # aggregated value containing millions of elements, the server can block for
  1223. # a long time (even seconds) in order to complete the operation.
  1224. #
  1225. # For the above reasons Redis also offers non blocking deletion primitives
  1226. # such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and
  1227. # FLUSHDB commands, in order to reclaim memory in background. Those commands
  1228. # are executed in constant time. Another thread will incrementally free the
  1229. # object in the background as fast as possible.
  1230. #
  1231. # DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.
  1232. # It's up to the design of the application to understand when it is a good
  1233. # idea to use one or the other. However the Redis server sometimes has to
  1234. # delete keys or flush the whole database as a side effect of other operations.
  1235. # Specifically Redis deletes objects independently of a user call in the
  1236. # following scenarios:
  1237. #
  1238. # 1) On eviction, because of the maxmemory and maxmemory policy configurations,
  1239. #    in order to make room for new data, without going over the specified
  1240. #    memory limit.
  1241. # 2) Because of expire: when a key with an associated time to live (see the
  1242. #    EXPIRE command) must be deleted from memory.
  1243. # 3) Because of a side effect of a command that stores data on a key that may
  1244. #    already exist. For example the RENAME command may delete the old key
  1245. #    content when it is replaced with another one. Similarly SUNIONSTORE
  1246. #    or SORT with STORE option may delete existing keys. The SET command
  1247. #    itself removes any old content of the specified key in order to replace
  1248. #    it with the specified string.
  1249. # 4) During replication, when a replica performs a full resynchronization with
  1250. #    its master, the content of the whole database is removed in order to
  1251. #    load the RDB file just transferred.
  1252. #
  1253. # In all the above cases the default is to delete objects in a blocking way,
  1254. # like if DEL was called. However you can configure each case specifically
  1255. # in order to instead release memory in a non-blocking way like if UNLINK
  1256. # was called, using the following configuration directives.
  1258. lazyfree-lazy-eviction no
  1259. lazyfree-lazy-expire no
  1260. lazyfree-lazy-server-del no
  1261. replica-lazy-flush no
  1263. # It is also possible, for the case when to replace the user code DEL calls
  1264. # with UNLINK calls is not easy, to modify the default behavior of the DEL
  1265. # command to act exactly like UNLINK, using the following configuration
  1266. # directive:
  1268. lazyfree-lazy-user-del no
  1270. # FLUSHDB, FLUSHALL, SCRIPT FLUSH and FUNCTION FLUSH support both asynchronous and synchronous
  1271. # deletion, which can be controlled by passing the [SYNC|ASYNC] flags into the
  1272. # commands. When neither flag is passed, this directive will be used to determine
  1273. # if the data should be deleted asynchronously.
  1275. lazyfree-lazy-user-flush no
  1277. ################################ THREADED I/O #################################
  1279. # Redis is mostly single threaded, however there are certain threaded
  1280. # operations such as UNLINK, slow I/O accesses and other things that are
  1281. # performed on side threads.
  1282. #
  1283. # Now it is also possible to handle Redis clients socket reads and writes
  1284. # in different I/O threads. Since especially writing is so slow, normally
  1285. # Redis users use pipelining in order to speed up the Redis performances per
  1286. # core, and spawn multiple instances in order to scale more. Using I/O
  1287. # threads it is possible to easily speedup two times Redis without resorting
  1288. # to pipelining nor sharding of the instance.
  1289. #
  1290. # By default threading is disabled, we suggest enabling it only in machines
  1291. # that have at least 4 or more cores, leaving at least one spare core.
  1292. # Using more than 8 threads is unlikely to help much. We also recommend using
  1293. # threaded I/O only if you actually have performance problems, with Redis
  1294. # instances being able to use a quite big percentage of CPU time, otherwise
  1295. # there is no point in using this feature.
  1296. #
  1297. # So for instance if you have a four cores boxes, try to use 2 or 3 I/O
  1298. # threads, if you have a 8 cores, try to use 6 threads. In order to
  1299. # enable I/O threads use the following configuration directive:
  1300. #
  1301. # io-threads 4
  1302. #
  1303. # Setting io-threads to 1 will just use the main thread as usual.
  1304. # When I/O threads are enabled, we only use threads for writes, that is
  1305. # to thread the write(2) syscall and transfer the client buffers to the
  1306. # socket. However it is also possible to enable threading of reads and
  1307. # protocol parsing using the following configuration directive, by setting
  1308. # it to yes:
  1309. #
  1310. # io-threads-do-reads no
  1311. #
  1312. # Usually threading reads doesn't help much.
  1313. #
  1314. # NOTE 1: This configuration directive cannot be changed at runtime via
  1315. # CONFIG SET. Also, this feature currently does not work when SSL is
  1316. # enabled.
  1317. #
  1318. # NOTE 2: If you want to test the Redis speedup using redis-benchmark, make
  1319. # sure you also run the benchmark itself in threaded mode, using the
  1320. # --threads option to match the number of Redis threads, otherwise you'll not
  1321. # be able to notice the improvements.
  1323. ############################ KERNEL OOM CONTROL ##############################
  1325. # On Linux, it is possible to hint the kernel OOM killer on what processes
  1326. # should be killed first when out of memory.
  1327. #
  1328. # Enabling this feature makes Redis actively control the oom_score_adj value
  1329. # for all its processes, depending on their role. The default scores will
  1330. # attempt to have background child processes killed before all others, and
  1331. # replicas killed before masters.
  1332. #
  1333. # Redis supports these options:
  1334. #
  1335. # no:       Don't make changes to oom-score-adj (default).
  1336. # yes:      Alias to "relative" see below.
  1337. # absolute: Values in oom-score-adj-values are written as is to the kernel.
  1338. # relative: Values are used relative to the initial value of oom_score_adj when
  1339. #           the server starts and are then clamped to a range of -1000 to 1000.
  1340. #           Because typically the initial value is 0, they will often match the
  1341. #           absolute values.
  1342. oom-score-adj no
  1344. # When oom-score-adj is used, this directive controls the specific values used
  1345. # for master, replica and background child processes. Values range -2000 to
  1346. # 2000 (higher means more likely to be killed).
  1347. #
  1348. # Unprivileged processes (not root, and without CAP_SYS_RESOURCE capabilities)
  1349. # can freely increase their value, but not decrease it below its initial
  1350. # settings. This means that setting oom-score-adj to "relative" and setting the
  1351. # oom-score-adj-values to positive values will always succeed.
  1352. oom-score-adj-values 0 200 800
  1355. #################### KERNEL transparent hugepage CONTROL ######################
  1357. # Usually the kernel Transparent Huge Pages control is set to "madvise" or
  1358. # or "never" by default (/sys/kernel/mm/transparent_hugepage/enabled), in which
  1359. # case this config has no effect. On systems in which it is set to "always",
  1360. # redis will attempt to disable it specifically for the redis process in order
  1361. # to avoid latency problems specifically with fork(2) and CoW.
  1362. # If for some reason you prefer to keep it enabled, you can set this config to
  1363. # "no" and the kernel global to "always".
  1365. disable-thp yes
  1367. ############################## APPEND ONLY MODE ###############################
  1369. # By default Redis asynchronously dumps the dataset on disk. This mode is
  1370. # good enough in many applications, but an issue with the Redis process or
  1371. # a power outage may result into a few minutes of writes lost (depending on
  1372. # the configured save points).
  1373. #
  1374. # The Append Only File is an alternative persistence mode that provides
  1375. # much better durability. For instance using the default data fsync policy
  1376. # (see later in the config file) Redis can lose just one second of writes in a
  1377. # dramatic event like a server power outage, or a single write if something
  1378. # wrong with the Redis process itself happens, but the operating system is
  1379. # still running correctly.
  1380. #
  1381. # AOF and RDB persistence can be enabled at the same time without problems.
  1382. # If the AOF is enabled on startup Redis will load the AOF, that is the file
  1383. # with the better durability guarantees.
  1384. #
  1385. # Please check https://redis.io/topics/persistence for more information.
  1387. appendonly no
  1389. # The base name of the append only file.
  1390. #
  1391. # Redis 7 and newer use a set of append-only files to persist the dataset
  1392. # and changes applied to it. There are two basic types of files in use:
  1393. #
  1394. # - Base files, which are a snapshot representing the complete state of the
  1395. #   dataset at the time the file was created. Base files can be either in
  1396. #   the form of RDB (binary serialized) or AOF (textual commands).
  1397. # - Incremental files, which contain additional commands that were applied
  1398. #   to the dataset following the previous file.
  1399. #
  1400. # In addition, manifest files are used to track the files and the order in
  1401. # which they were created and should be applied.
  1402. #
  1403. # Append-only file names are created by Redis following a specific pattern.
  1404. # The file name's prefix is based on the 'appendfilename' configuration
  1405. # parameter, followed by additional information about the sequence and type.
  1406. #
  1407. # For example, if appendfilename is set to appendonly.aof, the following file
  1408. # names could be derived:
  1409. #
  1410. # - appendonly.aof.1.base.rdb as a base file.
  1411. # - appendonly.aof.1.incr.aof, appendonly.aof.2.incr.aof as incremental files.
  1412. # - appendonly.aof.manifest as a manifest file.
  1414. appendfilename "appendonly.aof"
  1416. # For convenience, Redis stores all persistent append-only files in a dedicated
  1417. # directory. The name of the directory is determined by the appenddirname
  1418. # configuration parameter.
  1420. appenddirname "appendonlydir"
  1422. # The fsync() call tells the Operating System to actually write data on disk
  1423. # instead of waiting for more data in the output buffer. Some OS will really flush
  1424. # data on disk, some other OS will just try to do it ASAP.
  1425. #
  1426. # Redis supports three different modes:
  1427. #
  1428. # no: don't fsync, just let the OS flush the data when it wants. Faster.
  1429. # always: fsync after every write to the append only log. Slow, Safest.
  1430. # everysec: fsync only one time every second. Compromise.
  1431. #
  1432. # The default is "everysec", as that's usually the right compromise between
  1433. # speed and data safety. It's up to you to understand if you can relax this to
  1434. # "no" that will let the operating system flush the output buffer when
  1435. # it wants, for better performances (but if you can live with the idea of
  1436. # some data loss consider the default persistence mode that's snapshotting),
  1437. # or on the contrary, use "always" that's very slow but a bit safer than
  1438. # everysec.
  1439. #
  1440. # More details please check the following article:
  1441. # http://antirez.com/post/redis-persistence-demystified.html
  1442. #
  1443. # If unsure, use "everysec".
  1445. # appendfsync always
  1446. appendfsync everysec
  1447. # appendfsync no
  1449. # When the AOF fsync policy is set to always or everysec, and a background
  1450. # saving process (a background save or AOF log background rewriting) is
  1451. # performing a lot of I/O against the disk, in some Linux configurations
  1452. # Redis may block too long on the fsync() call. Note that there is no fix for
  1453. # this currently, as even performing fsync in a different thread will block
  1454. # our synchronous write(2) call.
  1455. #
  1456. # In order to mitigate this problem it's possible to use the following option
  1457. # that will prevent fsync() from being called in the main process while a
  1458. # BGSAVE or BGREWRITEAOF is in progress.
  1459. #
  1460. # This means that while another child is saving, the durability of Redis is
  1461. # the same as "appendfsync no". In practical terms, this means that it is
  1462. # possible to lose up to 30 seconds of log in the worst scenario (with the
  1463. # default Linux settings).
  1464. #
  1465. # If you have latency problems turn this to "yes". Otherwise leave it as
  1466. # "no" that is the safest pick from the point of view of durability.
  1468. no-appendfsync-on-rewrite no
  1470. # Automatic rewrite of the append only file.
  1471. # Redis is able to automatically rewrite the log file implicitly calling
  1472. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
  1473. #
  1474. # This is how it works: Redis remembers the size of the AOF file after the
  1475. # latest rewrite (if no rewrite has happened since the restart, the size of
  1476. # the AOF at startup is used).
  1477. #
  1478. # This base size is compared to the current size. If the current size is
  1479. # bigger than the specified percentage, the rewrite is triggered. Also
  1480. # you need to specify a minimal size for the AOF file to be rewritten, this
  1481. # is useful to avoid rewriting the AOF file even if the percentage increase
  1482. # is reached but it is still pretty small.
  1483. #
  1484. # Specify a percentage of zero in order to disable the automatic AOF
  1485. # rewrite feature.
  1487. auto-aof-rewrite-percentage 100
  1488. auto-aof-rewrite-min-size 64mb
  1490. # An AOF file may be found to be truncated at the end during the Redis
  1491. # startup process, when the AOF data gets loaded back into memory.
  1492. # This may happen when the system where Redis is running
  1493. # crashes, especially when an ext4 filesystem is mounted without the
  1494. # data=ordered option (however this can't happen when Redis itself
  1495. # crashes or aborts but the operating system still works correctly).
  1496. #
  1497. # Redis can either exit with an error when this happens, or load as much
  1498. # data as possible (the default now) and start if the AOF file is found
  1499. # to be truncated at the end. The following option controls this behavior.
  1500. #
  1501. # If aof-load-truncated is set to yes, a truncated AOF file is loaded and
  1502. # the Redis server starts emitting a log to inform the user of the event.
  1503. # Otherwise if the option is set to no, the server aborts with an error
  1504. # and refuses to start. When the option is set to no, the user requires
  1505. # to fix the AOF file using the "redis-check-aof" utility before to restart
  1506. # the server.
  1507. #
  1508. # Note that if the AOF file will be found to be corrupted in the middle
  1509. # the server will still exit with an error. This option only applies when
  1510. # Redis will try to read more data from the AOF file but not enough bytes
  1511. # will be found.
  1512. aof-load-truncated yes
  1514. # Redis can create append-only base files in either RDB or AOF formats. Using
  1515. # the RDB format is always faster and more efficient, and disabling it is only
  1516. # supported for backward compatibility purposes.
  1517. aof-use-rdb-preamble yes
  1519. # Redis supports recording timestamp annotations in the AOF to support restoring
  1520. # the data from a specific point-in-time. However, using this capability changes
  1521. # the AOF format in a way that may not be compatible with existing AOF parsers.
  1522. aof-timestamp-enabled no
  1524. ################################ SHUTDOWN #####################################
  1526. # Maximum time to wait for replicas when shutting down, in seconds.
  1527. #
  1528. # During shut down, a grace period allows any lagging replicas to catch up with
  1529. # the latest replication offset before the master exists. This period can
  1530. # prevent data loss, especially for deployments without configured disk backups.
  1531. #
  1532. # The 'shutdown-timeout' value is the grace period's duration in seconds. It is
  1533. # only applicable when the instance has replicas. To disable the feature, set
  1534. # the value to 0.
  1535. #
  1536. # shutdown-timeout 10
  1538. # When Redis receives a SIGINT or SIGTERM, shutdown is initiated and by default
  1539. # an RDB snapshot is written to disk in a blocking operation if save points are configured.
  1540. # The options used on signaled shutdown can include the following values:
  1541. # default:  Saves RDB snapshot only if save points are configured.
  1542. #           Waits for lagging replicas to catch up.
  1543. # save:     Forces a DB saving operation even if no save points are configured.
  1544. # nosave:   Prevents DB saving operation even if one or more save points are configured.
  1545. # now:      Skips waiting for lagging replicas.
  1546. # force:    Ignores any errors that would normally prevent the server from exiting.
  1547. #
  1548. # Any combination of values is allowed as long as "save" and "nosave" are not set simultaneously.
  1549. # Example: "nosave force now"
  1550. #
  1551. # shutdown-on-sigint default
  1552. # shutdown-on-sigterm default
  1554. ################ NON-DETERMINISTIC LONG BLOCKING COMMANDS #####################
  1556. # Maximum time in milliseconds for EVAL scripts, functions and in some cases
  1557. # modules' commands before Redis can start processing or rejecting other clients.
  1558. #
  1559. # If the maximum execution time is reached Redis will start to reply to most
  1560. # commands with a BUSY error.
  1561. #
  1562. # In this state Redis will only allow a handful of commands to be executed.
  1563. # For instance, SCRIPT KILL, FUNCTION KILL, SHUTDOWN NOSAVE and possibly some
  1564. # module specific 'allow-busy' commands.
  1565. #
  1566. # SCRIPT KILL and FUNCTION KILL will only be able to stop a script that did not
  1567. # yet call any write commands, so SHUTDOWN NOSAVE may be the only way to stop
  1568. # the server in the case a write command was already issued by the script when
  1569. # the user doesn't want to wait for the natural termination of the script.
  1570. #
  1571. # The default is 5 seconds. It is possible to set it to 0 or a negative value
  1572. # to disable this mechanism (uninterrupted execution). Note that in the past
  1573. # this config had a different name, which is now an alias, so both of these do
  1574. # the same:
  1575. # lua-time-limit 5000
  1576. # busy-reply-threshold 5000
  1578. ################################ REDIS CLUSTER  ###############################
  1580. # Normal Redis instances can't be part of a Redis Cluster; only nodes that are
  1581. # started as cluster nodes can. In order to start a Redis instance as a
  1582. # cluster node enable the cluster support uncommenting the following:
  1583. #
  1584. cluster-enabled yes
  1586. # Every cluster node has a cluster configuration file. This file is not
  1587. # intended to be edited by hand. It is created and updated by Redis nodes.
  1588. # Every Redis Cluster node requires a different cluster configuration file.
  1589. # Make sure that instances running in the same system do not have
  1590. # overlapping cluster configuration file names.
  1591. #
  1592. cluster-config-file redis-nodes-8001.conf
  1594. # Cluster node timeout is the amount of milliseconds a node must be unreachable
  1595. # for it to be considered in failure state.
  1596. # Most other internal time limits are a multiple of the node timeout.
  1597. #
  1598. cluster-node-timeout 15000
  1600. # The cluster port is the port that the cluster bus will listen for inbound connections on. When set 
  1601. # to the default value, 0, it will be bound to the command port + 10000. Setting this value requires 
  1602. # you to specify the cluster bus port when executing cluster meet.
  1603. # cluster-port 0
  1605. # A replica of a failing master will avoid to start a failover if its data
  1606. # looks too old.
  1607. #
  1608. # There is no simple way for a replica to actually have an exact measure of
  1609. # its "data age", so the following two checks are performed:
  1610. #
  1611. # 1) If there are multiple replicas able to failover, they exchange messages
  1612. #    in order to try to give an advantage to the replica with the best
  1613. #    replication offset (more data from the master processed).
  1614. #    Replicas will try to get their rank by offset, and apply to the start
  1615. #    of the failover a delay proportional to their rank.
  1616. #
  1617. # 2) Every single replica computes the time of the last interaction with
  1618. #    its master. This can be the last ping or command received (if the master
  1619. #    is still in the "connected" state), or the time that elapsed since the
  1620. #    disconnection with the master (if the replication link is currently down).
  1621. #    If the last interaction is too old, the replica will not try to failover
  1622. #    at all.
  1623. #
  1624. # The point "2" can be tuned by user. Specifically a replica will not perform
  1625. # the failover if, since the last interaction with the master, the time
  1626. # elapsed is greater than:
  1627. #
  1628. #   (node-timeout * cluster-replica-validity-factor) + repl-ping-replica-period
  1629. #
  1630. # So for example if node-timeout is 30 seconds, and the cluster-replica-validity-factor
  1631. # is 10, and assuming a default repl-ping-replica-period of 10 seconds, the
  1632. # replica will not try to failover if it was not able to talk with the master
  1633. # for longer than 310 seconds.
  1634. #
  1635. # A large cluster-replica-validity-factor may allow replicas with too old data to failover
  1636. # a master, while a too small value may prevent the cluster from being able to
  1637. # elect a replica at all.
  1638. #
  1639. # For maximum availability, it is possible to set the cluster-replica-validity-factor
  1640. # to a value of 0, which means, that replicas will always try to failover the
  1641. # master regardless of the last time they interacted with the master.
  1642. # (However they'll always try to apply a delay proportional to their
  1643. # offset rank).
  1644. #
  1645. # Zero is the only value able to guarantee that when all the partitions heal
  1646. # the cluster will always be able to continue.
  1647. #
  1648. # cluster-replica-validity-factor 10
  1650. # Cluster replicas are able to migrate to orphaned masters, that are masters
  1651. # that are left without working replicas. This improves the cluster ability
  1652. # to resist to failures as otherwise an orphaned master can't be failed over
  1653. # in case of failure if it has no working replicas.
  1654. #
  1655. # Replicas migrate to orphaned masters only if there are still at least a
  1656. # given number of other working replicas for their old master. This number
  1657. # is the "migration barrier". A migration barrier of 1 means that a replica
  1658. # will migrate only if there is at least 1 other working replica for its master
  1659. # and so forth. It usually reflects the number of replicas you want for every
  1660. # master in your cluster.
  1661. #
  1662. # Default is 1 (replicas migrate only if their masters remain with at least
  1663. # one replica). To disable migration just set it to a very large value or
  1664. # set cluster-allow-replica-migration to 'no'.
  1665. # A value of 0 can be set but is useful only for debugging and dangerous
  1666. # in production.
  1667. #
  1668. # cluster-migration-barrier 1
  1670. # Turning off this option allows to use less automatic cluster configuration.
  1671. # It both disables migration to orphaned masters and migration from masters
  1672. # that became empty.
  1673. #
  1674. # Default is 'yes' (allow automatic migrations).
  1675. #
  1676. # cluster-allow-replica-migration yes
  1678. # By default Redis Cluster nodes stop accepting queries if they detect there
  1679. # is at least a hash slot uncovered (no available node is serving it).
  1680. # This way if the cluster is partially down (for example a range of hash slots
  1681. # are no longer covered) all the cluster becomes, eventually, unavailable.
  1682. # It automatically returns available as soon as all the slots are covered again.
  1683. #
  1684. # However sometimes you want the subset of the cluster which is working,
  1685. # to continue to accept queries for the part of the key space that is still
  1686. # covered. In order to do so, just set the cluster-require-full-coverage
  1687. # option to no.
  1688. #
  1689. # cluster-require-full-coverage yes
  1691. # This option, when set to yes, prevents replicas from trying to failover its
  1692. # master during master failures. However the replica can still perform a
  1693. # manual failover, if forced to do so.
  1694. #
  1695. # This is useful in different scenarios, especially in the case of multiple
  1696. # data center operations, where we want one side to never be promoted if not
  1697. # in the case of a total DC failure.
  1698. #
  1699. # cluster-replica-no-failover no
  1701. # This option, when set to yes, allows nodes to serve read traffic while the
  1702. # cluster is in a down state, as long as it believes it owns the slots.
  1703. #
  1704. # This is useful for two cases.  The first case is for when an application
  1705. # doesn't require consistency of data during node failures or network partitions.
  1706. # One example of this is a cache, where as long as the node has the data it
  1707. # should be able to serve it.
  1708. #
  1709. # The second use case is for configurations that don't meet the recommended
  1710. # three shards but want to enable cluster mode and scale later. A
  1711. # master outage in a 1 or 2 shard configuration causes a read/write outage to the
  1712. # entire cluster without this option set, with it set there is only a write outage.
  1713. # Without a quorum of masters, slot ownership will not change automatically.
  1714. #
  1715. # cluster-allow-reads-when-down no
  1717. # This option, when set to yes, allows nodes to serve pubsub shard traffic while
  1718. # the cluster is in a down state, as long as it believes it owns the slots.
  1719. #
  1720. # This is useful if the application would like to use the pubsub feature even when
  1721. # the cluster global stable state is not OK. If the application wants to make sure only
  1722. # one shard is serving a given channel, this feature should be kept as yes.
  1723. #
  1724. # cluster-allow-pubsubshard-when-down yes
  1726. # Cluster link send buffer limit is the limit on the memory usage of an individual
  1727. # cluster bus link's send buffer in bytes. Cluster links would be freed if they exceed
  1728. # this limit. This is to primarily prevent send buffers from growing unbounded on links
  1729. # toward slow peers (E.g. PubSub messages being piled up).
  1730. # This limit is disabled by default. Enable this limit when 'mem_cluster_links' INFO field
  1731. # and/or 'send-buffer-allocated' entries in the 'CLUSTER LINKS` command output continuously increase.
  1732. # Minimum limit of 1gb is recommended so that cluster link buffer can fit in at least a single
  1733. # PubSub message by default. (client-query-buffer-limit default value is 1gb)
  1734. #
  1735. # cluster-link-sendbuf-limit 0
  1736.  
  1737. # Clusters can configure their announced hostname using this config. This is a common use case for 
  1738. # applications that need to use TLS Server Name Indication (SNI) or dealing with DNS based
  1739. # routing. By default this value is only shown as additional metadata in the CLUSTER SLOTS
  1740. # command, but can be changed using 'cluster-preferred-endpoint-type' config. This value is 
  1741. # communicated along the clusterbus to all nodes, setting it to an empty string will remove 
  1742. # the hostname and also propagate the removal.
  1743. #
  1744. # cluster-announce-hostname ""
  1746. # Clusters can configure an optional nodename to be used in addition to the node ID for
  1747. # debugging and admin information. This name is broadcasted between nodes, so will be used
  1748. # in addition to the node ID when reporting cross node events such as node failures.
  1749. # cluster-announce-human-nodename ""
  1751. # Clusters can advertise how clients should connect to them using either their IP address,
  1752. # a user defined hostname, or by declaring they have no endpoint. Which endpoint is
  1753. # shown as the preferred endpoint is set by using the cluster-preferred-endpoint-type
  1754. # config with values 'ip', 'hostname', or 'unknown-endpoint'. This value controls how
  1755. # the endpoint returned for MOVED/ASKING requests as well as the first field of CLUSTER SLOTS. 
  1756. # If the preferred endpoint type is set to hostname, but no announced hostname is set, a '?' 
  1757. # will be returned instead.
  1758. #
  1759. # When a cluster advertises itself as having an unknown endpoint, it's indicating that
  1760. # the server doesn't know how clients can reach the cluster. This can happen in certain 
  1761. # networking situations where there are multiple possible routes to the node, and the 
  1762. # server doesn't know which one the client took. In this case, the server is expecting
  1763. # the client to reach out on the same endpoint it used for making the last request, but use
  1764. # the port provided in the response.
  1765. #
  1766. # cluster-preferred-endpoint-type ip
  1768. # In order to setup your cluster make sure to read the documentation
  1769. # available at https://redis.io web site.
  1771. ########################## CLUSTER DOCKER/NAT support  ########################
  1773. # In certain deployments, Redis Cluster nodes address discovery fails, because
  1774. # addresses are NAT-ted or because ports are forwarded (the typical case is
  1775. # Docker and other containers).
  1776. #
  1777. # In order to make Redis Cluster working in such environments, a static
  1778. # configuration where each node knows its public address is needed. The
  1779. # following four options are used for this scope, and are:
  1780. #
  1781. # * cluster-announce-ip
  1782. # * cluster-announce-port
  1783. # * cluster-announce-tls-port
  1784. # * cluster-announce-bus-port
  1785. #
  1786. # Each instructs the node about its address, client ports (for connections
  1787. # without and with TLS) and cluster message bus port. The information is then
  1788. # published in the header of the bus packets so that other nodes will be able to
  1789. # correctly map the address of the node publishing the information.
  1790. #
  1791. # If tls-cluster is set to yes and cluster-announce-tls-port is omitted or set
  1792. # to zero, then cluster-announce-port refers to the TLS port. Note also that
  1793. # cluster-announce-tls-port has no effect if tls-cluster is set to no.
  1794. #
  1795. # If the above options are not used, the normal Redis Cluster auto-detection
  1796. # will be used instead.
  1797. #
  1798. # Note that when remapped, the bus port may not be at the fixed offset of
  1799. # clients port + 10000, so you can specify any port and bus-port depending
  1800. # on how they get remapped. If the bus-port is not set, a fixed offset of
  1801. # 10000 will be used as usual.
  1802. #
  1803. # Example:
  1804. #
  1805. # cluster-announce-ip 10.1.1.5
  1806. # cluster-announce-tls-port 6379
  1807. # cluster-announce-port 0
  1808. # cluster-announce-bus-port 6380
  1810. ################################## SLOW LOG ###################################
  1812. # The Redis Slow Log is a system to log queries that exceeded a specified
  1813. # execution time. The execution time does not include the I/O operations
  1814. # like talking with the client, sending the reply and so forth,
  1815. # but just the time needed to actually execute the command (this is the only
  1816. # stage of command execution where the thread is blocked and can not serve
  1817. # other requests in the meantime).
  1818. #
  1819. # You can configure the slow log with two parameters: one tells Redis
  1820. # what is the execution time, in microseconds, to exceed in order for the
  1821. # command to get logged, and the other parameter is the length of the
  1822. # slow log. When a new command is logged the oldest one is removed from the
  1823. # queue of logged commands.
  1825. # The following time is expressed in microseconds, so 1000000 is equivalent
  1826. # to one second. Note that a negative number disables the slow log, while
  1827. # a value of zero forces the logging of every command.
  1828. slowlog-log-slower-than 10000
  1830. # There is no limit to this length. Just be aware that it will consume memory.
  1831. # You can reclaim memory used by the slow log with SLOWLOG RESET.
  1832. slowlog-max-len 128
  1834. ################################ LATENCY MONITOR ##############################
  1836. # The Redis latency monitoring subsystem samples different operations
  1837. # at runtime in order to collect data related to possible sources of
  1838. # latency of a Redis instance.
  1839. #
  1840. # Via the LATENCY command this information is available to the user that can
  1841. # print graphs and obtain reports.
  1842. #
  1843. # The system only logs operations that were performed in a time equal or
  1844. # greater than the amount of milliseconds specified via the
  1845. # latency-monitor-threshold configuration directive. When its value is set
  1846. # to zero, the latency monitor is turned off.
  1847. #
  1848. # By default latency monitoring is disabled since it is mostly not needed
  1849. # if you don't have latency issues, and collecting data has a performance
  1850. # impact, that while very small, can be measured under big load. Latency
  1851. # monitoring can easily be enabled at runtime using the command
  1852. # "CONFIG SET latency-monitor-threshold <milliseconds>" if needed.
  1853. latency-monitor-threshold 0
  1855. ################################ LATENCY TRACKING ##############################
  1857. # The Redis extended latency monitoring tracks the per command latencies and enables
  1858. # exporting the percentile distribution via the INFO latencystats command,
  1859. # and cumulative latency distributions (histograms) via the LATENCY command.
  1860. #
  1861. # By default, the extended latency monitoring is enabled since the overhead
  1862. # of keeping track of the command latency is very small.
  1863. # latency-tracking yes
  1865. # By default the exported latency percentiles via the INFO latencystats command
  1866. # are the p50, p99, and p999.
  1867. # latency-tracking-info-percentiles 50 99 99.9
  1869. ############################# EVENT NOTIFICATION ##############################
  1871. # Redis can notify Pub/Sub clients about events happening in the key space.
  1872. # This feature is documented at https://redis.io/topics/notifications
  1873. #
  1874. # For instance if keyspace events notification is enabled, and a client
  1875. # performs a DEL operation on key "foo" stored in the Database 0, two
  1876. # messages will be published via Pub/Sub:
  1877. #
  1878. # PUBLISH __keyspace@0__:foo del
  1879. # PUBLISH __keyevent@0__:del foo
  1880. #
  1881. # It is possible to select the events that Redis will notify among a set
  1882. # of classes. Every class is identified by a single character:
  1883. #
  1884. #  K     Keyspace events, published with __keyspace@<db>__ prefix.
  1885. #  E     Keyevent events, published with __keyevent@<db>__ prefix.
  1886. #  g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
  1887. #  $     String commands
  1888. #  l     List commands
  1889. #  s     Set commands
  1890. #  h     Hash commands
  1891. #  z     Sorted set commands
  1892. #  x     Expired events (events generated every time a key expires)
  1893. #  e     Evicted events (events generated when a key is evicted for maxmemory)
  1894. #  n     New key events (Note: not included in the 'A' class)
  1895. #  t     Stream commands
  1896. #  d     Module key type events
  1897. #  m     Key-miss events (Note: It is not included in the 'A' class)
  1898. #  A     Alias for g$lshzxetd, so that the "AKE" string means all the events
  1899. #        (Except key-miss events which are excluded from 'A' due to their
  1900. #         unique nature).
  1901. #
  1902. #  The "notify-keyspace-events" takes as argument a string that is composed
  1903. #  of zero or multiple characters. The empty string means that notifications
  1904. #  are disabled.
  1905. #
  1906. #  Example: to enable list and generic events, from the point of view of the
  1907. #           event name, use:
  1908. #
  1909. #  notify-keyspace-events Elg
  1910. #
  1911. #  Example 2: to get the stream of the expired keys subscribing to channel
  1912. #             name __keyevent@0__:expired use:
  1913. #
  1914. #  notify-keyspace-events Ex
  1915. #
  1916. #  By default all notifications are disabled because most users don't need
  1917. #  this feature and the feature has some overhead. Note that if you don't
  1918. #  specify at least one of K or E, no events will be delivered.
  1919. notify-keyspace-events ""
  1921. ############################### ADVANCED CONFIG ###############################
  1923. # Hashes are encoded using a memory efficient data structure when they have a
  1924. # small number of entries, and the biggest entry does not exceed a given
  1925. # threshold. These thresholds can be configured using the following directives.
  1926. hash-max-listpack-entries 512
  1927. hash-max-listpack-value 64
  1929. # Lists are also encoded in a special way to save a lot of space.
  1930. # The number of entries allowed per internal list node can be specified
  1931. # as a fixed maximum size or a maximum number of elements.
  1932. # For a fixed maximum size, use -5 through -1, meaning:
  1933. # -5: max size: 64 Kb  <-- not recommended for normal workloads
  1934. # -4: max size: 32 Kb  <-- not recommended
  1935. # -3: max size: 16 Kb  <-- probably not recommended
  1936. # -2: max size: 8 Kb   <-- good
  1937. # -1: max size: 4 Kb   <-- good
  1938. # Positive numbers mean store up to _exactly_ that number of elements
  1939. # per list node.
  1940. # The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size),
  1941. # but if your use case is unique, adjust the settings as necessary.
  1942. list-max-listpack-size -2
  1944. # Lists may also be compressed.
  1945. # Compress depth is the number of quicklist ziplist nodes from *each* side of
  1946. # the list to *exclude* from compression.  The head and tail of the list
  1947. # are always uncompressed for fast push/pop operations.  Settings are:
  1948. # 0: disable all list compression
  1949. # 1: depth 1 means "don't start compressing until after 1 node into the list,
  1950. #    going from either the head or tail"
  1951. #    So: [head]->node->node->...->node->[tail]
  1952. #    [head], [tail] will always be uncompressed; inner nodes will compress.
  1953. # 2: [head]->[next]->node->node->...->node->[prev]->[tail]
  1954. #    2 here means: don't compress head or head->next or tail->prev or tail,
  1955. #    but compress all nodes between them.
  1956. # 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]
  1957. # etc.
  1958. list-compress-depth 0
  1960. # Sets have a special encoding when a set is composed
  1961. # of just strings that happen to be integers in radix 10 in the range
  1962. # of 64 bit signed integers.
  1963. # The following configuration setting sets the limit in the size of the
  1964. # set in order to use this special memory saving encoding.
  1965. set-max-intset-entries 512
  1967. # Sets containing non-integer values are also encoded using a memory efficient
  1968. # data structure when they have a small number of entries, and the biggest entry
  1969. # does not exceed a given threshold. These thresholds can be configured using
  1970. # the following directives.
  1971. set-max-listpack-entries 128
  1972. set-max-listpack-value 64
  1974. # Similarly to hashes and lists, sorted sets are also specially encoded in
  1975. # order to save a lot of space. This encoding is only used when the length and
  1976. # elements of a sorted set are below the following limits:
  1977. zset-max-listpack-entries 128
  1978. zset-max-listpack-value 64
  1980. # HyperLogLog sparse representation bytes limit. The limit includes the
  1981. # 16 bytes header. When a HyperLogLog using the sparse representation crosses
  1982. # this limit, it is converted into the dense representation.
  1983. #
  1984. # A value greater than 16000 is totally useless, since at that point the
  1985. # dense representation is more memory efficient.
  1986. #
  1987. # The suggested value is ~ 3000 in order to have the benefits of
  1988. # the space efficient encoding without slowing down too much PFADD,
  1989. # which is O(N) with the sparse encoding. The value can be raised to
  1990. # ~ 10000 when CPU is not a concern, but space is, and the data set is
  1991. # composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
  1992. hll-sparse-max-bytes 3000
  1994. # Streams macro node max size / items. The stream data structure is a radix
  1995. # tree of big nodes that encode multiple items inside. Using this configuration
  1996. # it is possible to configure how big a single node can be in bytes, and the
  1997. # maximum number of items it may contain before switching to a new node when
  1998. # appending new stream entries. If any of the following settings are set to
  1999. # zero, the limit is ignored, so for instance it is possible to set just a
  2000. # max entries limit by setting max-bytes to 0 and max-entries to the desired
  2001. # value.
  2002. stream-node-max-bytes 4096
  2003. stream-node-max-entries 100
  2005. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
  2006. # order to help rehashing the main Redis hash table (the one mapping top-level
  2007. # keys to values). The hash table implementation Redis uses (see dict.c)
  2008. # performs a lazy rehashing: the more operation you run into a hash table
  2009. # that is rehashing, the more rehashing "steps" are performed, so if the
  2010. # server is idle the rehashing is never complete and some more memory is used
  2011. # by the hash table.
  2012. #
  2013. # The default is to use this millisecond 10 times every second in order to
  2014. # actively rehash the main dictionaries, freeing memory when possible.
  2015. #
  2016. # If unsure:
  2017. # use "activerehashing no" if you have hard latency requirements and it is
  2018. # not a good thing in your environment that Redis can reply from time to time
  2019. # to queries with 2 milliseconds delay.
  2020. #
  2021. # use "activerehashing yes" if you don't have such hard requirements but
  2022. # want to free memory asap when possible.
  2023. activerehashing yes
  2025. # The client output buffer limits can be used to force disconnection of clients
  2026. # that are not reading data from the server fast enough for some reason (a
  2027. # common reason is that a Pub/Sub client can't consume messages as fast as the
  2028. # publisher can produce them).
  2029. #
  2030. # The limit can be set differently for the three different classes of clients:
  2031. #
  2032. # normal -> normal clients including MONITOR clients
  2033. # replica -> replica clients
  2034. # pubsub -> clients subscribed to at least one pubsub channel or pattern
  2035. #
  2036. # The syntax of every client-output-buffer-limit directive is the following:
  2037. #
  2038. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
  2039. #
  2040. # A client is immediately disconnected once the hard limit is reached, or if
  2041. # the soft limit is reached and remains reached for the specified number of
  2042. # seconds (continuously).
  2043. # So for instance if the hard limit is 32 megabytes and the soft limit is
  2044. # 16 megabytes / 10 seconds, the client will get disconnected immediately
  2045. # if the size of the output buffers reach 32 megabytes, but will also get
  2046. # disconnected if the client reaches 16 megabytes and continuously overcomes
  2047. # the limit for 10 seconds.
  2048. #
  2049. # By default normal clients are not limited because they don't receive data
  2050. # without asking (in a push way), but just after a request, so only
  2051. # asynchronous clients may create a scenario where data is requested faster
  2052. # than it can read.
  2053. #
  2054. # Instead there is a default limit for pubsub and replica clients, since
  2055. # subscribers and replicas receive data in a push fashion.
  2056. #
  2057. # Note that it doesn't make sense to set the replica clients output buffer
  2058. # limit lower than the repl-backlog-size config (partial sync will succeed
  2059. # and then replica will get disconnected).
  2060. # Such a configuration is ignored (the size of repl-backlog-size will be used).
  2061. # This doesn't have memory consumption implications since the replica client
  2062. # will share the backlog buffers memory.
  2063. #
  2064. # Both the hard or the soft limit can be disabled by setting them to zero.
  2065. client-output-buffer-limit normal 0 0 0
  2066. client-output-buffer-limit replica 256mb 64mb 60
  2067. client-output-buffer-limit pubsub 32mb 8mb 60
  2069. # Client query buffers accumulate new commands. They are limited to a fixed
  2070. # amount by default in order to avoid that a protocol desynchronization (for
  2071. # instance due to a bug in the client) will lead to unbound memory usage in
  2072. # the query buffer. However you can configure it here if you have very special
  2073. # needs, such us huge multi/exec requests or alike.
  2074. #
  2075. # client-query-buffer-limit 1gb
  2077. # In some scenarios client connections can hog up memory leading to OOM
  2078. # errors or data eviction. To avoid this we can cap the accumulated memory
  2079. # used by all client connections (all pubsub and normal clients). Once we
  2080. # reach that limit connections will be dropped by the server freeing up
  2081. # memory. The server will attempt to drop the connections using the most 
  2082. # memory first. We call this mechanism "client eviction".
  2083. #
  2084. # Client eviction is configured using the maxmemory-clients setting as follows:
  2085. # 0 - client eviction is disabled (default)
  2086. #
  2087. # A memory value can be used for the client eviction threshold,
  2088. # for example:
  2089. # maxmemory-clients 1g
  2090. #
  2091. # A percentage value (between 1% and 100%) means the client eviction threshold
  2092. # is based on a percentage of the maxmemory setting. For example to set client
  2093. # eviction at 5% of maxmemory:
  2094. # maxmemory-clients 5%
  2096. # In the Redis protocol, bulk requests, that are, elements representing single
  2097. # strings, are normally limited to 512 mb. However you can change this limit
  2098. # here, but must be 1mb or greater
  2099. #
  2100. # proto-max-bulk-len 512mb
  2102. # Redis calls an internal function to perform many background tasks, like
  2103. # closing connections of clients in timeout, purging expired keys that are
  2104. # never requested, and so forth.
  2105. #
  2106. # Not all tasks are performed with the same frequency, but Redis checks for
  2107. # tasks to perform according to the specified "hz" value.
  2108. #
  2109. # By default "hz" is set to 10. Raising the value will use more CPU when
  2110. # Redis is idle, but at the same time will make Redis more responsive when
  2111. # there are many keys expiring at the same time, and timeouts may be
  2112. # handled with more precision.
  2113. #
  2114. # The range is between 1 and 500, however a value over 100 is usually not
  2115. # a good idea. Most users should use the default of 10 and raise this up to
  2116. # 100 only in environments where very low latency is required.
  2117. hz 10
  2119. # Normally it is useful to have an HZ value which is proportional to the
  2120. # number of clients connected. This is useful in order, for instance, to
  2121. # avoid too many clients are processed for each background task invocation
  2122. # in order to avoid latency spikes.
  2123. #
  2124. # Since the default HZ value by default is conservatively set to 10, Redis
  2125. # offers, and enables by default, the ability to use an adaptive HZ value
  2126. # which will temporarily raise when there are many connected clients.
  2127. #
  2128. # When dynamic HZ is enabled, the actual configured HZ will be used
  2129. # as a baseline, but multiples of the configured HZ value will be actually
  2130. # used as needed once more clients are connected. In this way an idle
  2131. # instance will use very little CPU time while a busy instance will be
  2132. # more responsive.
  2133. dynamic-hz yes
  2135. # When a child rewrites the AOF file, if the following option is enabled
  2136. # the file will be fsync-ed every 4 MB of data generated. This is useful
  2137. # in order to commit the file to the disk more incrementally and avoid
  2138. # big latency spikes.
  2139. aof-rewrite-incremental-fsync yes
  2141. # When redis saves RDB file, if the following option is enabled
  2142. # the file will be fsync-ed every 4 MB of data generated. This is useful
  2143. # in order to commit the file to the disk more incrementally and avoid
  2144. # big latency spikes.
  2145. rdb-save-incremental-fsync yes
  2147. # Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good
  2148. # idea to start with the default settings and only change them after investigating
  2149. # how to improve the performances and how the keys LFU change over time, which
  2150. # is possible to inspect via the OBJECT FREQ command.
  2151. #
  2152. # There are two tunable parameters in the Redis LFU implementation: the
  2153. # counter logarithm factor and the counter decay time. It is important to
  2154. # understand what the two parameters mean before changing them.
  2155. #
  2156. # The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis
  2157. # uses a probabilistic increment with logarithmic behavior. Given the value
  2158. # of the old counter, when a key is accessed, the counter is incremented in
  2159. # this way:
  2160. #
  2161. # 1. A random number R between 0 and 1 is extracted.
  2162. # 2. A probability P is calculated as 1/(old_value*lfu_log_factor+1).
  2163. # 3. The counter is incremented only if R < P.
  2164. #
  2165. # The default lfu-log-factor is 10. This is a table of how the frequency
  2166. # counter changes with a different number of accesses with different
  2167. # logarithmic factors:
  2168. #
  2169. # +--------+------------+------------+------------+------------+------------+
  2170. # | factor | 100 hits   | 1000 hits  | 100K hits  | 1M hits    | 10M hits   |
  2171. # +--------+------------+------------+------------+------------+------------+
  2172. # | 0      | 104        | 255        | 255        | 255        | 255        |
  2173. # +--------+------------+------------+------------+------------+------------+
  2174. # | 1      | 18         | 49         | 255        | 255        | 255        |
  2175. # +--------+------------+------------+------------+------------+------------+
  2176. # | 10     | 10         | 18         | 142        | 255        | 255        |
  2177. # +--------+------------+------------+------------+------------+------------+
  2178. # | 100    | 8          | 11         | 49         | 143        | 255        |
  2179. # +--------+------------+------------+------------+------------+------------+
  2180. #
  2181. # NOTE: The above table was obtained by running the following commands:
  2182. #
  2183. #   redis-benchmark -n 1000000 incr foo
  2184. #   redis-cli object freq foo
  2185. #
  2186. # NOTE 2: The counter initial value is 5 in order to give new objects a chance
  2187. # to accumulate hits.
  2188. #
  2189. # The counter decay time is the time, in minutes, that must elapse in order
  2190. # for the key counter to be decremented.
  2191. #
  2192. # The default value for the lfu-decay-time is 1. A special value of 0 means we
  2193. # will never decay the counter.
  2194. #
  2195. # lfu-log-factor 10
  2196. # lfu-decay-time 1
  2198. ########################### ACTIVE DEFRAGMENTATION #######################
  2199. #
  2200. # What is active defragmentation?
  2201. # -------------------------------
  2202. #
  2203. # Active (online) defragmentation allows a Redis server to compact the
  2204. # spaces left between small allocations and deallocations of data in memory,
  2205. # thus allowing to reclaim back memory.
  2206. #
  2207. # Fragmentation is a natural process that happens with every allocator (but
  2208. # less so with Jemalloc, fortunately) and certain workloads. Normally a server
  2209. # restart is needed in order to lower the fragmentation, or at least to flush
  2210. # away all the data and create it again. However thanks to this feature
  2211. # implemented by Oran Agra for Redis 4.0 this process can happen at runtime
  2212. # in a "hot" way, while the server is running.
  2213. #
  2214. # Basically when the fragmentation is over a certain level (see the
  2215. # configuration options below) Redis will start to create new copies of the
  2216. # values in contiguous memory regions by exploiting certain specific Jemalloc
  2217. # features (in order to understand if an allocation is causing fragmentation
  2218. # and to allocate it in a better place), and at the same time, will release the
  2219. # old copies of the data. This process, repeated incrementally for all the keys
  2220. # will cause the fragmentation to drop back to normal values.
  2221. #
  2222. # Important things to understand:
  2223. #
  2224. # 1. This feature is disabled by default, and only works if you compiled Redis
  2225. #    to use the copy of Jemalloc we ship with the source code of Redis.
  2226. #    This is the default with Linux builds.
  2227. #
  2228. # 2. You never need to enable this feature if you don't have fragmentation
  2229. #    issues.
  2230. #
  2231. # 3. Once you experience fragmentation, you can enable this feature when
  2232. #    needed with the command "CONFIG SET activedefrag yes".
  2233. #
  2234. # The configuration parameters are able to fine tune the behavior of the
  2235. # defragmentation process. If you are not sure about what they mean it is
  2236. # a good idea to leave the defaults untouched.
  2238. # Active defragmentation is disabled by default
  2239. # activedefrag no
  2241. # Minimum amount of fragmentation waste to start active defrag
  2242. # active-defrag-ignore-bytes 100mb
  2244. # Minimum percentage of fragmentation to start active defrag
  2245. # active-defrag-threshold-lower 10
  2247. # Maximum percentage of fragmentation at which we use maximum effort
  2248. # active-defrag-threshold-upper 100
  2250. # Minimal effort for defrag in CPU percentage, to be used when the lower
  2251. # threshold is reached
  2252. # active-defrag-cycle-min 1
  2254. # Maximal effort for defrag in CPU percentage, to be used when the upper
  2255. # threshold is reached
  2256. # active-defrag-cycle-max 25
  2258. # Maximum number of set/hash/zset/list fields that will be processed from
  2259. # the main dictionary scan
  2260. # active-defrag-max-scan-fields 1000
  2262. # Jemalloc background thread for purging will be enabled by default
  2263. jemalloc-bg-thread yes
  2265. # It is possible to pin different threads and processes of Redis to specific
  2266. # CPUs in your system, in order to maximize the performances of the server.
  2267. # This is useful both in order to pin different Redis threads in different
  2268. # CPUs, but also in order to make sure that multiple Redis instances running
  2269. # in the same host will be pinned to different CPUs.
  2270. #
  2271. # Normally you can do this using the "taskset" command, however it is also
  2272. # possible to this via Redis configuration directly, both in Linux and FreeBSD.
  2273. #
  2274. # You can pin the server/IO threads, bio threads, aof rewrite child process, and
  2275. # the bgsave child process. The syntax to specify the cpu list is the same as
  2276. # the taskset command:
  2277. #
  2278. # Set redis server/io threads to cpu affinity 0,2,4,6:
  2279. # server_cpulist 0-7:2
  2280. #
  2281. # Set bio threads to cpu affinity 1,3:
  2282. # bio_cpulist 1,3
  2283. #
  2284. # Set aof rewrite child process to cpu affinity 8,9,10,11:
  2285. # aof_rewrite_cpulist 8-11
  2286. #
  2287. # Set bgsave child process to cpu affinity 1,10,11
  2288. # bgsave_cpulist 1,10-11
  2290. # In some cases redis will emit warnings and even refuse to start if it detects
  2291. # that the system is in bad state, it is possible to suppress these warnings
  2292. # by setting the following config which takes a space delimited list of warnings
  2293. # to suppress
  2294. #
  2295. # ignore-warnings ARM64-COW-BUG

6、启动节点

  1. #启动节点
  2. [root@localhost conf]# cd /home/redisCluster/redis/redis-7.2.0/src/
  3. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8001.conf
  4. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8002.conf
  5. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8003.conf
  6. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8004.conf
  7. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8005.conf
  8. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8006.conf
  9. #检查节点状态
  10. [root@localhost src]# ps -ef|grep redis
  11. root     16995     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8001 [cluster]
  12. root     17048     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8002 [cluster]
  13. root     17081     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8003 [cluster]
  14. root     17115     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8004 [cluster]
  15. root     17155     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8005 [cluster]
  16. root     17202     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8006 [cluster]
  17.  
  18.

7、配置集群

  1. # --cluster-replicas 1 自动创建合适的 master 节点且分配一个 slave 节点
  2. # -a myRedisCluster 密码
  3.  
  4. [root@localhost src]# ./redis-cli --cluster create 192.168.1.8:8001 192.168.1.8:8002  192.168.1.8:8003 192.168.1.8:8004 192.168.1.8:8005 192.168.1.8:8006 --cluster-replicas 1 -a myRedisCluster

8、检查集群节点

  1.  
  2. [root@localhost src]# ./redis-cli --cluster check  192.168.1.8:8001  -a myRedisCluster                                                                                                     Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
  3. 192.168.1.8:8001 (6cfb694c...) -> 0 keys | 5461 slots | 1 slaves.
  4. 192.168.1.8:8002 (1e0a126e...) -> 0 keys | 5462 slots | 1 slaves.
  5. 192.168.1.8:8003 (a4264904...) -> 0 keys | 5461 slots | 1 slaves.
  6. [OK] 0 keys in 3 masters.
  7. 0.00 keys per slot on average.
  8. >>> Performing Cluster Check (using node 192.168.1.8:8001)
  9. M: 6cfb694c8bce46b243bdc42fc37f8bf560073111 192.168.1.8:8001
  10.    slots:[0-5460] (5461 slots) master
  11.    1 additional replica(s)
  12. S: 28d346a4141f20acbbfb4100ba4ccb0debfb4523 192.168.1.8:8006
  13.    slots: (0 slots) slave
  14.    replicates 6cfb694c8bce46b243bdc42fc37f8bf560073111
  15. S: 011b8f519a2b01bfc7edc0659c70767e31198da6 192.168.1.8:8005
  16.    slots: (0 slots) slave
  17.    replicates a4264904468809c2838f9cb84ce36316d9a62f99
  18. S: 70908e2eef9e361f96b79db00dd65842f9107c4c 192.168.1.8:8004
  19.    slots: (0 slots) slave
  20.    replicates 1e0a126ebd2872a923330058575623f8285e3e68
  21. M: 1e0a126ebd2872a923330058575623f8285e3e68 192.168.1.8:8002
  22.    slots:[5461-10922] (5462 slots) master
  23.    1 additional replica(s)
  24. M: a4264904468809c2838f9cb84ce36316d9a62f99 192.168.1.8:8003
  25.    slots:[10923-16383] (5461 slots) master
  26.    1 additional replica(s)
  27. [OK] All nodes agree about slots configuration.
  28. >>> Check for open slots...
  29. >>> Check slots coverage...
  30. [OK] All 16384 slots covered.

9、查看集群节点状态

  1. [root@localhost src]# ./redis-cli -c -h 192.168.1.8 -p 8001 -a myRedisCluster
  2. Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
  3. 192.168.1.8:8001> cluster nodes
  4. 28d346a4141f20acbbfb4100ba4ccb0debfb4523 192.168.1.8:8006@18006 slave 6cfb694c8bce46b243bdc42fc37f8bf560073111 0 1697600098427 1 connected
  5. 6cfb694c8bce46b243bdc42fc37f8bf560073111 192.168.1.8:8001@18001 myself,master - 0 1697600096000 1 connected 0-5460
  6. 011b8f519a2b01bfc7edc0659c70767e31198da6 192.168.1.8:8005@18005 slave a4264904468809c2838f9cb84ce36316d9a62f99 0 1697600098000 3 connected
  7. 70908e2eef9e361f96b79db00dd65842f9107c4c 192.168.1.8:8004@18004 slave 1e0a126ebd2872a923330058575623f8285e3e68 0 1697600099000 2 connected
  8. 1e0a126ebd2872a923330058575623f8285e3e68 192.168.1.8:8002@18002 master - 0 1697600099429 2 connected 5461-10922
  9. a4264904468809c2838f9cb84ce36316d9a62f99 192.168.1.8:8003@18003 master - 0 1697600098000 3 connected 10923-16383
  10. 192.168.1.8:8001>
  11. [root@localhost src]# ^C
  12. [root@localhost src]#

10、测试

  1. [root@localhost src]# ./redis-cli -c -h 192.168.1.8 -p 8001 -a myRedisCluster
  2. Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
  3. 192.168.1.8:8001> set firstRedisName myRedisCluster
  4. OK
  5. 192.168.1.8:8001> get firstRedisName
  6. "myRedisCluster"
  7. 192.168.1.8:8001>

11、添加节点

  1. #配置文件
  2. [root@localhost redisCluster]# cd conf/
  3. [root@localhost conf]# ll
  4. 总用量 648
  5. -rw-r--r--. 1 root root 107583 10月 17 15:08 redis-8001.conf
  6. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8002.conf
  7. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8003.conf
  8. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8004.conf
  9. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8005.conf
  10. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8006.conf
  11. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8007.conf
  12. -rw-r--r--. 1 root root 107581 10月 17 15:08 redis-8008.conf
  13.  
  14. #启动节点
  15. #启动节点
  16. [root@localhost conf]# cd /home/redisCluster/redis/redis-7.2.0/src/
  17. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8007.conf
  18. [root@localhost src]# ./redis-server /home/redisCluster/conf/redis-8008.conf
  19. #检查节点状态
  20. [root@localhost src]# ps -ef|grep redis
  21. root     16995     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8001 [cluster]
  22. root     17048     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8002 [cluster]
  23. root     17081     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8003 [cluster]
  24. root     17115     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8004 [cluster]
  25. root     17155     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8005 [cluster]
  26. root     17202     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8006 [cluster]
  27. root     17202     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8007 [cluster]
  28. root     17202     1  0 11:11 ?   00:00:00 ./redis-server 172.18.1.58:8008 [cluster]
  29. #添加节点8007
  30. [root@localhost src]# ./redis-cli --cluster add-node 192.168.1.8:8007  192.168.1.8:8001  -a myRedisCluster
  31. #检查节点8007，得到节点id
  32. [root@localhost src]# ./redis-cli --cluster check  192.168.1.8:8007  -a myRedisCluster
  33. #添加节点8008为8007的从节点
  34. [root@localhost src]# ./redis-cli --cluster add-node --cluster-master-id xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx --cluster-slave 192.168.1.8:8008 192.168.1.8:8001 -a myredis
  35. #分槽
  36. [root@localhost src]# ./redis-cli --cluster reshard 192.168.1.8:8007  -a myRedisCluster
  37.

12、移除节点

  1. #移除分槽
  2. [root@localhost src]# ./redis-cli --cluster reshard 192.168.1.8:8007  -a myRedisCluster
  3. #移除节点
  4. [root@localhost src]# ./redis-cli  --cluster del-node 192.168.1.8:8007 xxxxxxxxxxxxxxxx

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/738443
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号