Redis 持久化 rdb、Aof對比

./redis-cli -h ip -p port save

./redis-cli -h ip -p port bgsave 

################################ SNAPSHOTTING  ################################
#
# 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 行，然后配置save "" 來停用保存功能。

save 900 1    #表示900 秒內如果至少有 1 個 key 的值變化，則保存
save 300 10   #表示60 秒內如果至少有 10000 個 key 的值變化，則保存
save 60 10000 #表示60 秒內如果至少有 10000 個 key 的值變化，則保存

# By default Redis will stop accepting writes if RDB snapshots are enabled
# (at least one save point) and the latest background save failed.
# By default Redis will stop accepting writes if RDB snapshots are enabled
# (at least one save point) and the latest background save failed.
# This will make the user aware (in a hard way) that data is not persisting
# on disk properly, otherwise chances are that no one will notice and some
# disaster will happen.
#
# If the background saving process will start working again Redis will
# automatically allow writes again.
#
# However if you have setup your proper monitoring of the Redis server
# and persistence, you may want to disable this feature so that Redis will
# continue to work as usual even if there are problems with disk,
# permissions, and so forth.
stop-writes-on-bgsave-error yes   #默認值為yes。當snapshot時出現錯誤無法繼續時是否阻塞客戶端“變更操作”。“錯誤”可能因為磁盤已滿/磁盤故障/OS級別異常等。如果Redis重啟了，那么又可以重新開始接收數據了

# 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  #默認值是yes。對于存儲到磁盤中的快照，可以設置是否進行壓縮存儲。

# Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
# This makes the format more resistant to corruption but there is a performance
# hit to pay (around 10%) when saving and loading RDB files, so you can disable it
# for maximum performances.
#
# RDB files created with checksum disabled have a checksum of zero that will
# tell the loading code to skip the check.
rdbchecksum yes  #默認值是yes。在存儲快照后，我們還可以讓redis使用CRC64算法來進行數據校驗，但是這樣做會增加大約10%的性能消耗，如果希望獲取到最大的性能提升，可以關閉此功能。

# The filename where to dump the DB
dbfilename dump.rdb      #設置快照的文件名，默認是 dump.rdb

# 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 /home/cmhy/redis-5.0.5   #設置快照文件的存放路徑，這個配置項一定是個目錄，而不能是文件名

7639:M 22 May 2020 10:12:54.048 * 10000 changes in 60 seconds. Saving...  //根據redis.conf 中save 60 1000配置，觸發持久化
7639:M 22 May 2020 10:12:54.240 * Background saving started by pid 28173       //fork一個后臺子進程
28173:C 22 May 2020 10:13:41.728 * DB saved on disk                            //保存到磁盤
28173:C 22 May 2020 10:13:41.876 * RDB: 585 MB of memory used by copy-on-write
7639:M 22 May 2020 10:13:42.221 * Background saving terminated with success

appendfsync always     //每次修改，同步持久化，每次發生數據變更會被立即記錄到磁盤 性能較差但數據完整性比較好
appendfsync everysec   //每秒同步，異步操作，每秒記錄 如果一秒內宕機，有數據丟失
appendfsync no         //從不同步

############################## 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.

appendonly no       //是否開啟AOF持久化

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

appendfilename "appendonly.aof"       //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  
appendfsync everysec
//指定aof操作文件同步策略，always、eversec、no，默認為everysec是每s進行一次fsync調用，將緩沖區中的數據同步到磁盤。但是當這一次的fsync調用時間超過1s時Redis會采取延遲fsynccel，再等1s鐘。也就是在2s后再進行一次fsync，這一次的fsync不管執行多久都會進行。這時候由于在fsync時文件描述符會被阻塞，所以當前的寫操作會被阻塞。
//結論：絕大多數情況下Redis會每隔1s進行fsync，最壞情況下，2s鐘會進行一次fsync。

# appendfsync no
//如果同步策略設置為always或everysec，會造成后臺存儲進程（后臺存儲或寫入aof文件）會產生很多磁盤I/O開銷，當設置為no時，Redis不會主動調用fsync去將aof日志同步到磁盤，所以這一切都要靠操作系統的調試了，對大多數操作系統，是每30/s進行一次fsync，將緩沖區中數據同步到磁盤；
# 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.

no-appendfsync-on-rewrite no
#注意，目前對這個情況還沒有完美修正，甚至不同線程的 fsync() 會阻塞我們同步的write(2)調用。
#為了緩解這個問題，可以用下面這個選項。它可以在 BGSAVE 或 BGREWRITEAOF 處理時阻止fsync()。
#這就意味著如果有子進程在進行保存操作，那么Redis就處于"不可同步"的狀態。
#這實際上是說，在最差的情況下可能會丟掉30秒鐘的日志數據。（默認Linux設定）
#如果把這個設置成"yes"帶來了延遲問題，就保持"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.

auto-aof-rewrite-percentage 100
#自動重寫AOF文件。如果AOF日志文件增大到指定百分比，Redis能夠通過 BGREWRITEAOF 自動重寫AOF日志文件。
#工作原理：Redis記住上次重寫時AOF文件的大小（如果重啟后還沒有寫操作，就直接用啟動時的AOF大小）
#這個基準大小和當前大小做比較。如果當前大小超過指定比例，就會觸發重寫操作。
#你還需要指定被重寫日志的最小尺寸，這樣避免了達到指定百分比但尺寸仍然很小的情況還要重寫。
#指定百分比為0會禁用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-load-truncated yes
#如果設置為yes，如果一個因異常被截斷的AOF文件被redis啟動時加載進內存，redis將會發送日志通知用戶
#如果設置為no，erdis將會拒絕啟動。此時需要用"redis-check-aof"工具修復文件。

# 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.
aof-use-rdb-preamble yes
#加載時Redis識別出AOF文件以“REDIS”開頭字符串，
#并加載帶此前綴的RDB文件，然后繼續加載AOF

Save 900 1      

Save 300 10    

Save 60 10000