Redis 配置節

Redis

後面的配置基於4.0.9版本=>>>不指定版本信息的配置說明都是耍流氓

好比在4.0.9中沒有vm相關的及glueoutputbuf的配置信息

部分經常使用配置節（後面有詳細說明）：

• daemonize
• pidfile
• port
• bind
• timeout
• loglevel
• logfile
• databases
• save
• rdbcompression
• dbfilename
• dir
• slaveof
• masterauth
• requirepass
• maxclients
• maxmemory
• maxmemory-policy
• appendonly
• appendfilename
• appendfsync
• hash-max-zipmap-entries
• hash-max-zipmap-value
• activerehashing
• include

Redis介紹

開源內存數據庫，支持String、Hash、List、Set、Zset、Geo、Hyperloglogs等多數據結構。同事支持主從複製、Luau腳本、事務、數據持久化、高可用和集羣化等；

Redis特性

1. 高性能：Redis雖然是單線程的，可是它一樣擁有這超高的性能。有測試顯示每秒請求OPS可以達到10W左右；
2. 多樣化數據結構：Redis支持String、Hash、List、Set、Zset、Geo等多數據結構；
3. 持久化：
   1. RDB持久化（快照式持久化方式），將內存中的全量數據dump到磁盤。它的優點是加載速度比AOF快，劣勢是快照式的全量備份，沒有增量數據，形成數據丟失；
   2. AOF持久化：AOF記錄Redis執行的全部寫操做命令。恢復數據的過程至關於回放這些寫操做。使用AOF的持久化方式，優點是有靈活的刷盤策略，保證數據的安全性。劣勢是AOF文件體積比RDB大，佔用磁盤多，數據加載到內存的速度慢；
4. 多重數據刪除策略：
   1. 惰性刪除：當讀/寫一個已通過期的key時，會觸發惰性刪除策略，刪除掉這個過時key；
   2. 按期刪除：因爲惰性刪除策略沒法保證冷數據被及時刪掉，全部redis會按期主動淘汰一批已過時的key；
   3. 主動刪除：當已用內存超過maxmemory限定時，觸發主動清除策略，該策略由啓動參數的配置決定，可配置參數及說明以下：
      • volatile-lru：從已設置過時時間的樣本中根據LRU算法刪除數據 （redis3.0以前的默認策略）
      • volatile-ttl：從已設置過時時間的樣本中挑選過時時間最小的數據刪除
      • volatile-random：從已設置過時時間的樣本中隨機選擇數據刪除
      • allkeys-lru：從樣本中根據LRU算法刪除數據
      • allkeys-random：從樣本中任意選擇刪除數據
      • noenviction：禁止從內存中刪除數據 （從redis3.0 開始默認策略）
5. 高可用：Redis自身帶有哨兵（Sentinel）的組件，能夠監控Redis主從的運行轉態和自動的故障切換，實現Redis的高可用；

Redis安裝配置

Redis安裝

1.Redis下載並解壓（目前最新版本是4.0.9）

cd /usr/local/
wget http://download.redis.io/releases/redis-4.0.9.tar.gz
tar -zxzf redis-4.0.9.tar.gz

2.編譯並安裝

make install PREFIX=安裝路徑

cd /usr/local/redis-4.0.9
make install PREFIX=/usr/local/redis

能夠複製redis相關命令到/usr/sbin目錄下，這樣就能夠執行執行這些命令，不用謝全路徑

cd /usr/local/redis/bin
cp redis-cli redis-server redis-sentinel /usr/sbin

3.Redis配置（v4.0.9）

redis的配置文件（redis.conf）拷貝備份

我的習慣，喜歡把最原始的配置文件作一個備份，便於後期對比或還原

redis配置文件主要參數解析參考

• daemonize

配置Redis是否以守護進程的方式運行，默認爲no

# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
daemonize no

• pidfile

當Redis以守護進程方式運行時，Redis默認會把pid寫入/var/run/redis.pid文件，能夠經過pidfile指定

# If a pid file is specified, Redis writes it where specified at startup
# and removes it at exit.
#
# When the server runs non daemonized, no pid file is created if none is
# specified in the configuration. When the server is daemonized, the pid file
# is used even if not specified, defaulting to "/var/run/redis.pid".
#
# Creating a pid file is best effort: if Redis is not able to create it
# nothing bad happens, the server will start and run normally.
pidfile /var/run/redis_6379.pid

• port

指定Redis的監聽端口，端口默認6379（來源一個女歌手的名字）

# Accept connections on the specified port, default is 6379 (IANA #815344).
# If port 0 is specified Redis will not listen on a TCP socket.
port 6379

• bind

綁定的主機地址

# By default, if no "bind" configuration directive is specified, Redis listens
# for connections from all the network interfaces available on the server.
# It is possible to listen to just one or multiple selected interfaces using
# the "bind" configuration directive, followed by one or more IP addresses.
#
# Examples:
#
# bind 192.168.1.100 10.0.0.1
# bind 127.0.0.1 ::1
#
# ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
# internet, binding to all the interfaces is dangerous and will expose the
# instance to everybody on the internet. So by default we uncomment the
# following bind directive, that will force Redis to listen only into
# the IPv4 lookback interface address (this means Redis will be able to
# accept connections only from clients running into the same computer it
# is running).
#
# IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES
# JUST COMMENT THE FOLLOWING LINE.
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bind 127.0.0.1

• timeout

當客戶端閒置多長時間後關閉鏈接，若是指定爲0，表示關閉該功能

# Close the connection after a client is idle for N seconds (0 to disable)
timeout 0

• loglevel

指定日誌記錄級別，Redis共支持4個級別：debug、verbose、notice、warning，默認爲notice

# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel notice

• logfile

日誌記錄方式，默認爲標準輸出，若是配置Redis爲守護進程方式運行，而這裏又配置爲日誌記錄方式爲標準輸出，則將日誌發送給/dev/null

# Specify the log file name. Also the empty string can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
logfile ""

• databases

設置數據庫的數量，默認數據庫爲0，可使用SELECT <dbid> 命令在鏈接上指定數據庫id

# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT <dbid> where
# dbid is a number between 0 and 'databases'-1
databases 16

• save

指定在多長時間內，有多少次更新操做，就將數據同步到數據文件，能夠多個條件配合

默認的

# Save the DB on disk:
#
#   save <seconds> <changes>
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving completely by commenting out all "save" lines.
#
#   It is also possible to remove all the previously configured save
#   points by adding a save directive with a single empty string argument
#   like in the following example:
#
#   save ""

save 900 1
save 300 10
save 60 10000

• rdbcompression

指定存儲至本地數據庫時是否壓縮數據，默認爲yes，Redis採用LZF（Apache開源算法）壓縮，若是爲了節省CPU時間，能夠關閉該選項，但會致使數據庫文件變的巨大

# Compress string objects using LZF when dump .rdb databases?
# For default that's set to 'yes' as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes

• dbfilename

指定本地數據庫文件名，默認爲dump.rdb

# The filename where to dump the DB
dbfilename dump.rdb

• dir

指定本地數據庫存放目錄

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
#
# The Append Only File will also be created inside this directory.
#
# Note that you must specify a directory here, not a file name.
dir ./

• slaveof

設置當本機爲slave服務時，設置master服務的ip地址及端口，Redis啓動時，會自動從master進行數據同步

# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. A few things to understand ASAP about Redis replication.
#
# 1) Redis replication is asynchronous, but you can configure a master to
#    stop accepting writes if it appears to be not connected with at least
#    a given number of slaves.
# 2) Redis slaves are able to perform a partial resynchronization with the
#    master if the replication link is lost for a relatively small amount of
#    time. You may want to configure the replication backlog size (see the next
#    sections of this file) with a sensible value depending on your needs.
# 3) Replication is automatic and does not need user intervention. After a
#    network partition slaves automatically try to reconnect to masters
#    and resynchronize with them.
#
# slaveof <masterip> <masterport>

• masterauth

當master服務設置了密碼保護時，salve服務鏈接master的密碼

# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.
#
# masterauth <master-password>

• requirepass

設置Redis的鏈接密碼，若是配置了鏈接密碼，客戶端在鏈接Redis時，須要經過AUTH <password>命令提供密碼，默認關閉

# Require clients to issue AUTH <PASSWORD> before processing any other
# commands.  This might be useful in environments in which you do not trust
# others with access to the host running redis-server.
#
# This should stay commented out for backward compatibility and because most
# people do not need auth (e.g. they run their own servers).
#
# Warning: since Redis is pretty fast an outside user can try up to
# 150k passwords per second against a good box. This means that you should
# use a very strong password otherwise it will be very easy to break.
#
# requirepass foobared

• maxclients

設置同一時間最大客戶端鏈接數，默認無限制，Redis能夠同時打開的客戶端鏈接數爲Redis進程能夠打開的最大描述文件符數，若是設置maxclients 0，表示不限制。當客戶端鏈接數達到限制時，Redis會關閉新的鏈接，並想客戶端返回max number of clients reached錯誤信息

# Set the max number of connected clients at the same time. By default
# this limit is set to 10000 clients, however if the Redis server is not
# able to configure the process file limit to allow for the specified limit
# the max number of allowed clients is set to the current file limit
# minus 32 (as Redis reserves a few file descriptors for internal uses).
#
# Once the limit is reached Redis will close all the new connections sending
# an error 'max number of clients reached'.
#
# maxclients 10000

• maxmemory

指定Redis最大內存限制，Redis在啓動時會把數據加載到內存中，達到最大內存後，Redis將會沒法再進行寫入操做，但任然能夠進行讀取操做。內存清理使用下面的內存清理策略進行。Redis新的vm機制，會把Key存放內存，Value存放在swap區

# Set a memory usage limit to the specified amount of bytes.
# When the memory limit is reached Redis will try to remove keys
# according to the eviction policy selected (see maxmemory-policy).
#
# If Redis can't remove keys according to the policy, or if the policy is
# set to 'noeviction', Redis will start to reply with errors to commands
# that would use more memory, like SET, LPUSH, and so on, and will continue
# to reply to read-only commands like GET.
#
# This option is usually useful when using Redis as an LRU or LFU cache, or to
# set a hard memory limit for an instance (using the 'noeviction' policy).
#
# WARNING: If you have slaves attached to an instance with maxmemory on,
# the size of the output buffers needed to feed the slaves are subtracted
# from the used memory count, so that network problems / resyncs will
# not trigger a loop where keys are evicted, and in turn the output
# buffer of slaves is full with DELs of keys evicted triggering the deletion
# of more keys, and so forth until the database is completely emptied.
#
# In short... if you have slaves attached it is suggested that you set a lower
# limit for maxmemory so that there is some free RAM on the system for slave
# output buffers (but this is not needed if the policy is 'noeviction').
#
# maxmemory <bytes>

• maxmemory-policy

內存達到設置的最大內存後，將要使用哪一種策略進行內存清理

# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
# is reached. You can select among five behaviors:
#
# volatile-lru -> Evict using approximated LRU among the keys with an expire set.
# allkeys-lru -> Evict any key using approximated LRU.
# volatile-lfu -> Evict using approximated LFU among the keys with an expire set.
# allkeys-lfu -> Evict any key using approximated LFU.
# volatile-random -> Remove a random key among the ones with an expire set.
# allkeys-random -> Remove a random key, any key.
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
# noeviction -> Don't evict anything, just return an error on write operations.
#
# LRU means Least Recently Used
# LFU means Least Frequently Used
#
# Both LRU, LFU and volatile-ttl are implemented using approximated
# randomized algorithms.
#
# Note: with any of the above policies, Redis will return an error on write
#       operations, when there are no suitable keys for eviction.
#
#       At the date of writing these commands are: set setnx setex append
#       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
#       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
#       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
#       getset mset msetnx exec sort
#
# The default is:
#
# maxmemory-policy noeviction

• appendonly

指定是否在每次更新操做後進行日誌記錄，Redis默認狀況下是異步的把數據寫入磁盤，若是不開啓，可能會在斷電時致使一段時間內的數據丟失。由於Redis自己同步數據文件是按上面save條件來同步的，因此有的數據會在一段時間內只存在於內存中。默認爲no

# By default Redis asynchronously dumps the dataset on disk. This mode is
# good enough in many applications, but an issue with the Redis process or
# a power outage may result into a few minutes of writes lost (depending on
# the configured save points).
#
# The Append Only File is an alternative persistence mode that provides
# much better durability. For instance using the default data fsync policy
# (see later in the config file) Redis can lose just one second of writes in a
# dramatic event like a server power outage, or a single write if something
# wrong with the Redis process itself happens, but the operating system is
# still running correctly.
#
# AOF and RDB persistence can be enabled at the same time without problems.
# If the AOF is enabled on startup Redis will load the AOF, that is the file
# with the better durability guarantees.
#
# Please check http://redis.io/topics/persistence for more information.

appendonly no

• appendfilename

指定更新日誌文件名

# The name of the append only file (default: "appendonly.aof")

appendfilename "appendonly.aof"

• appendfsync

指定更新日誌條件，共有3個可選值

# The fsync() call tells the Operating System to actually write data on disk
# instead of waiting for more data in the output buffer. Some OS will really flush
# data on disk, some other OS will just try to do it ASAP.
#
# Redis supports three different modes:
#
# no: don't fsync, just let the OS flush the data when it wants. Faster.
# always: fsync after every write to the append only log. Slow, Safest.
# everysec: fsync only one time every second. Compromise.
#
# The default is "everysec", as that's usually the right compromise between
# speed and data safety. It's up to you to understand if you can relax this to
# "no" that will let the operating system flush the output buffer when
# it wants, for better performances (but if you can live with the idea of
# some data loss consider the default persistence mode that's snapshotting),
# or on the contrary, use "always" that's very slow but a bit safer than
# everysec.
#
# More details please check the following article:
# http://antirez.com/post/redis-persistence-demystified.html
#
# If unsure, use "everysec".

# appendfsync always
appendfsync everysec
# appendfsync no

• hash-max-zipmap-entries、hash-max-zipmap-value

指定在超過必定的數量或者最大的元素超過某個臨界值時，採用一種特殊的哈希算法

# Hashes are encoded using a memory efficient data structure when they have a
# small number of entries, and the biggest entry does not exceed a given
# threshold. These thresholds can be configured using the following directives.
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

• activerehashing

指定是否激活重置哈希，默認爲開啓

# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
# order to help rehashing the main Redis hash table (the one mapping top-level
# keys to values). The hash table implementation Redis uses (see dict.c)
# performs a lazy rehashing: the more operation you run into a hash table
# that is rehashing, the more rehashing "steps" are performed, so if the
# server is idle the rehashing is never complete and some more memory is used
# by the hash table.
#
# The default is to use this millisecond 10 times every second in order to
# actively rehash the main dictionaries, freeing memory when possible.
#
# If unsure:
# use "activerehashing no" if you have hard latency requirements and it is
# not a good thing in your environment that Redis can reply from time to time
# to queries with 2 milliseconds delay.
#
# use "activerehashing yes" if you don't have such hard requirements but
# want to free memory asap when possible.
activerehashing yes

• include

指定包含其它的配置文件，能夠在同一個主機上多個Redis實例之間使用同一份配置文件，而同時各個實例又擁有本身的特定配置文件

# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all Redis servers but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# Notice option "include" won't be rewritten by command "CONFIG REWRITE"
# from admin or Redis Sentinel. Since Redis always uses the last processed
# line as value of a configuration directive, you'd better put includes
# at the beginning of this file to avoid overwriting config change at runtime.
#
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
#
# include /path/to/local.conf
# include /path/to/other.conf