Redis的記憶體淘汰策略（八）

############################## APPEND ONLY MODE ###############################
# 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.
#預設redis使用的是rdb方式持久化，這種方式在許多應用中已經足夠用了。
但是redis如果中途宕機，會導致可能有幾分鐘的資料丟失，根據save來策略進行持久化，
Append Only File是另一種持久化方式，可以提供更好的持久化特性。
Redis會把每次寫入的資料在接收後都寫入 appendonly.aof 檔案，
每次啟動時Redis都會先把這個檔案的資料讀入記憶體裡，先忽略RDB檔案
appendonly no #如果要開啟，改為yes
# The name of the append only file (default: "appendonly.aof")
# aof檔名
appendfilename "appendonly.aof"
# 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
#aof持久化策略的設定
#no表示不執行fsync，由作業系統保證資料同步到磁碟，速度最快。
#always表示每次寫入都執行fsync，以保證資料同步到磁碟。
#everysec表示每秒執行一次fsync，可能會導致丟失這1s資料。
appendfsync everysec
# appendfsync no
# When the AOF fsync policy is set to always or everysec, and a background
# saving process (a background save or AOF log background rewriting) is
# performing a lot of I/O against the disk, in some Linux configurations
# Redis may block too long on the fsync() call. Note that there is no fix for
# this currently, as even performing fsync in a different thread will block
# our synchronous write(2) call.
#
# In order to mitigate this problem it's possible to use the following option
# that will prevent fsync() from being called in the main process while a
# BGSAVE or BGREWRITEAOF is in progress.
#
# This means that while another child is saving, the durability of Redis is
# the same as "appendfsync none". In practical terms, this means that it is
# possible to lose up to 30 seconds of log in the worst scenario (with the
# default Linux settings).
#
# If you have latency problems turn this to "yes". Otherwise leave it as
# "no" that is the safest pick from the point of view of durability.
# 在aof重寫或者寫入rdb檔案的時候，會執行大量IO，此時對於everysec和always的aof模式來說，
執行fsync會造成阻塞過長時間，no-appendfsync-on-rewrite欄位設定為預設設定為no。
如果對延遲要求很高的應用，這個欄位可以設定為yes，否則還是設定為no，
這樣對持久化特性來說這是更安全的選擇。設定為yes表示rewrite期間對新寫操作不fsync,
暫時存在記憶體中,等rewrite完成後再寫入，預設為no，建議yes。Linux的預設fsync策略是30秒。
可能丟失30秒資料。隨著aof檔案持續增大，會fork出一條程序去對aof檔案重寫
no-appendfsync-on-rewrite no
# Automatic rewrite of the append only file.
# Redis is able to automatically rewrite the log file implicitly calling
# BGREWRITEAOF when the AOF log size grows by the specified percentage.
#
# This is how it works: Redis remembers the size of the AOF file after the
# latest rewrite (if no rewrite has happened since the restart, the size of
# the AOF at startup is used).
#
# This base size is compared to the current size. If the current size is
# bigger than the specified percentage, the rewrite is triggered. Also
# you need to specify a minimal size for the AOF file to be rewritten, this
# is useful to avoid rewriting the AOF file even if the percentage increase
# is reached but it is still pretty small.
#
# Specify a percentage of zero in order to disable the automatic AOF
# rewrite feature.
#aof自動重寫設定。當目前aof檔案大小超過上一次重寫的aof檔案大小的百分之多少進行重寫，
即當aof檔案增長到一定大小的時候Redis能夠呼叫bgrewriteaof對紀錄檔檔案進行重寫。
當前AOF檔案大小是上次紀錄檔重寫得到AOF檔案大小的一倍（設定為100）時，
自動啟動新的紀錄檔重寫過程。
auto-aof-rewrite-percentage 100
#設定允許重寫的最小aof檔案大小，避免了達到約定百分比但尺寸仍然很小的情況還要重寫
auto-aof-rewrite-min-size 64mb
# An AOF file may be found to be truncated at the end during the Redis
# startup process, when the AOF data gets loaded back into memory.
# This may happen when the system where Redis is running
# crashes, especially when an ext4 filesystem is mounted without the
# data=ordered option (however this can't happen when Redis itself
# crashes or aborts but the operating system still works correctly).
#
# Redis can either exit with an error when this happens, or load as much
# data as possible (the default now) and start if the AOF file is found
# to be truncated at the end. The following option controls this behavior.
#
# If aof-load-truncated is set to yes, a truncated AOF file is loaded and
# the Redis server starts emitting a log to inform the user of the event.
# Otherwise if the option is set to no, the server aborts with an error
# and refuses to start. When the option is set to no, the user requires
# to fix the AOF file using the "redis-check-aof" utility before to restart
# the server.
#
# Note that if the AOF file will be found to be corrupted in the middle
# the server will still exit with an error. This option only applies when
# Redis will try to read more data from the AOF file but not enough bytes
# will be found.
#aof檔案可能在尾部是不完整的，當redis啟動的時候，aof檔案的資料被載入記憶體。
重啟可能發生在redis所在的主機作業系統宕機後，
尤其在ext4檔案系統沒有加上data=ordered選項（redis宕機或者異常終止不會造成尾部不完整現象。）
出現這種現象，可以選擇讓redis退出，或者匯入儘可能多的資料。如果選擇的是yes，
當截斷的aof檔案被匯入的時候，會自動釋出一個log給使用者端然後load。如果是no，
使用者必須手動redis-check-aof修復AOF檔案才可以。
aof-load-truncated yes
# When rewriting the AOF file, Redis is able to use an RDB preamble in the
# AOF file for faster rewrites and recoveries. When this option is turned
# on the rewritten AOF file is composed of two different stanzas:
#
#   [RDB file][AOF tail]
#
# When loading Redis recognizes that the AOF file starts with the "REDIS"
# string and loads the prefixed RDB file, and continues loading the AOF
# tail.
#
# This is currently turned off by default in order to avoid the surprise
# of a format change, but will at some point be used as the default.
#Redis4.0新增RDB-AOF混合持久化格式，在開啟了這個功能之後，
AOF重寫產生的檔案將同時包含RDB格式的內容和AOF格式的內容，
其中RDB格式的內容用於記錄已有的資料，而AOF格式的記憶體則用於記錄最近發生了變化的資料，
這樣Redis就可以同時兼有RDB持久化和AOF持久化的優點（既能夠快速地生成重寫檔案，
也能夠在出現問題時，快速地載入資料）。
aof-use-rdb-preamble no

# maxmemory <bytes>

maxmemory-samples 5