哈喽,大家好,我是有勇气的牛排(全网同名)🐮🐮🐮
有问题的小伙伴欢迎在文末评论,点赞、收藏是对我最大的支持!!!。
文章目录
官方文档:https://redis.io/docs/management/persistence/
1 RDB持久化
1.1 官方介绍:
RDB (Redis DataBase) 持久性以指定的时间间隔执行数据集的时间点快照,这个快照文件就称为RDB(dump.rdb),在恢复的时候将快照文件读会到内存即可。
在保存快照的时候,它是备份全量快照,也就是把内存中的所有数据都记录到磁盘中。
配置
config get requirepass
config get port
启动
redis-server /usr/local/redis/redis.conf
redis-cli -a 123456
1.2 配置文件
1.2.1 Redis 6.0.16以下版本
语法:save m n
描述:如果m秒内数据集存在n次修改时,自动触发bgsave
# 每隔900s(15min), 如果超过1个key发生了变化,就写一份新的RDB文件
save 900 1
1.2.2 Redis 6.2/7.0以后版本
语法:save <seconds> <changes> [<seconds> <changes> ...]
Reids将会再如下两种情况保存快照:
# 禁用快照 空字符串
save ""
# Unless specified otherwise, by default Redis will save the DB:
# * After 3600 seconds (an hour) if at least 1 change was performed
# * After 300 seconds (5 minutes) if at least 100 changes were performed
# * After 60 seconds if at least 10000 changes were performed
# 例如
save 3600 1 300 100 60 10000
1.3 操作步骤
1.3.1 自动操作
Redis7
# 5s内有2次修改 则保存
save 5 2
# 504 自定义保存路径
dir /usr/local/redis/data
# 481 自定义保存文件名
dbfilename dump.rdb
1.3.2 手动触发
1、save
在住程序包中执行会阻塞当前redis服务器,直到持久化工作完成,在执行save命令期间,Redis不能处理其他命令,线上禁止使用。
2、bgsave
执行该命令时,Redis会在后台异步进行快照操作,快照同时还可以响应客户端请求。具体操作是Redis进程执行fork操作创建子进程,RDB持久化过程由子进程负责,完成后自动结束。阻塞只发生在fork阶段,一般时间很短。

3、lastsave
获取上一次成功快照时间
1.4 恢复数据
- 将备份文件(dump.rdb)移动到redis安装目录并启动服务即可。
- 一定要分机隔离,避免新数据丢失。
1.5 RDB优缺点
1.5.1 优点
- 适合大规模数据恢复
- 按照业务定时备份
- 对数据完整性和一致性要求不高
- RDB文件在内存中的加载速度要比AOF要快的多
1.5.2 缺点
- 在一定间隔时间做一次备份,如果redis意外down,就会丢失从当期至最近一次快照时间的数据。
- 内存数据全量同步,如果数据量太大会导致I/O验证影响服务器性能。
- RDB依赖于主进程fork,在跟打的数据集中,这可能会导致服务请求的瞬间延迟。fork的时候,内存中的数据备克隆了一份,大致2倍的膨胀性,需要考虑。
1.6 检查修复dump.rdb文件
修复命令
redis-check-rdb /usr/local/redis/redis.conf
1.7 哪些情况会触发RDB快照
- 配置文件中默认的快照配置
- 手动save/bgsave命令
- 执行flushall/flushdb命令也会产生dump.rdb文件,但里面是空白。
- 执行shutdown,且没有开启AOF持久化
- 主从复制比时,主节点自动触发
1.8 禁用快照
修改配置
save ""
命令修改
redis-cli config set save ""
1.9 RDB优化配置项
# yes(默认, 推荐)
# no: 表示不在户数据不一致or其他手段发现和控制这种不一致,那么在快照写入失败时,也能确保redis继续接受新的写请求。
stop-writes-on-bgsave-error yes
# yes(默认, 推荐): 对于存储到磁盘中的快照,可以设置是否进行压缩存储。
# 如果是:redis则会采用LZF算法进行压缩。
rdbcompression yes
# yes(默认, 推荐): 在存储快照后,还可以让redis使用CRC64算法进行数据校验,但是这样做会增大10%的性能消耗,如果希望性能最大提升,则可以关闭。
rdbchechsum yes
# 在没有持久性的情况下删除复制中使用的RDB文件启动
# 默认为no
rdb-del-sync-files no
2 AOF(Append only file)持久化
2.1 AOF介绍
定义:以日志的形式来记录每个写操作,将Redis执行过得所有写指令记录下来(读操作不记录),只许追加文件不可以写文件,redis启动之初会读取该文件重新构建数据,换言之,reids重启的话就根据日志文件的内容将写指令从前到后执行一次,以完成数据的恢复工作。
默认情况下,redis没有开启AOF。
保存文件为:appendonly.aof
2.2 AOF持久化工作流程
- Client作为命令的来源,会有多个源头以及源源不断的请求命令。
- 在这些命令到达Redis Server以后,并不是直接写入AOF文件,而是会将这些玩命令先放入到AOF缓存中进行保存。这里的AOF缓冲区实际上是内存中的一片区域,存在的目的是当这些命令到达一定量以后再写入磁盘,避免频繁的IO操作。
- AOF缓冲区会根据AOF缓冲区同步文件的三种写会策略,将命令写入磁盘上的AOF文件。
- 随着写入AOF内容的增加,为避免文件膨胀,会根据规则进行命令合并(又称AOF重写),从而起到AOF文件压缩的目的。
- 当Redis Server服务器重启的时候,就会从AOF文件载入数据。
2.3 AOF的三种写回策略
Always
:同步回写,每个命令执行完立刻同步地将日志写会磁盘。
everysec
:每秒写回,每个命令执行完,只是先把日志写到AOF文件的内存缓冲区,每隔1s把缓冲区的内容写入磁盘。
no
:操作系统控制写回,每隔命令执行完,只是先把日志写到AOF文件的内存缓冲区,由操作系统决定何时将缓冲区内容写回磁盘。
# 1379
appendonly everysec
配置项 |
写回时机 |
优点 |
缺点 |
Always |
同步写回 |
可靠性高,数据基本不丢失 |
每个写命令都要落盘,性能影响大 |
Everysec |
每秒写回 |
性能适中 |
宕机时丢失1s内的数据 |
No |
操作系统控制写回 |
性能好 |
宕机时丢失的数据较多 |
2.4 配置文件
在redis6中只用单个AOF文件,但是在redis7中,AOF被拆分为了3个文件(Multi Part AOF设计)
- base:一般由子进程通过重写产生,该文件最多只有一个。
- incr:一般会再AOFRW开始执行时被创建爱,每次AOFRW成功完成时,本次AOFRW之前对应的BASE和INCR AOF,都将变为HISTORY,HISTORY类型的AOF会被Redis自动删除。
- history
redis6
# AOF开启
appendonly yes
# 写回策略
appendfsync everysec
# 保存路径 与RDB一样
dir /usr/local/redis/data
# 文件名
appenddirname "appendonly.aof"
reids7
# AOF开启
appendonly yes
# 写回策略
appendfsync everysec
# RDB数据保存路径
dir /usr/local/redis/data
# AOF保存路径(自动拼接dir)
# 1412 {dir}/appendonlydir
appenddirname "appendonlydir"
# 1406 文件名
appenddirname "appendonly.aof"

Append only mode模块
# 是否开启aof
appendonly yes
# 文件名称
appendfilename "appendonly.aof"
# 同步方式: everysec/always/no
appendfsync "everysec"
# aof重写期间是否同步
no-appendfsync-on-wirte no
# 重写触发配置、文件重写策略
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
2.5 AOF文件修复
问题:AOF文件没有写完,宕机等情况
异常修复命令
redis-check-aof --fix ***.aof
2.6 优缺点
优点
缺点
- 就相同数据集的数据而言,AOF文件要远大于rdb文件,回复速度慢于rdb
- aof运行效率要慢于rdb,每秒同步策略效率要好。
2.7 AOF重写
- 在重写开始前,redis会创建一个"重写子进程",这个子进程会读取现有的AOF文件,并将其包含的指令进行分析压缩写入到一个临时文件中。
- 与此同时,主进程会将新收到的指令一遍积累到内存缓冲区中,一遍继续写入原有的AOF文件中,这样做是保证原有的AOF文件的可用性,避免在重写的过程中出现意外。
- 当“重写子进程”,完成重写工作后,它会给父进程发一个信号,父进程收到信号后就会将内存中的写指令追加到新AOF中
- 当追加结束后,redis就会用新AOF文件来替换旧AOF文件,之后再有新的指令,就会追加到新的AOF文件中。
- 重写AOF文件的操作,并没有读取旧的AOF文件,而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,这点和快照有点类似。
3 RDB-AOF混合持久化
默认在同时开启rdb和aof持久化时,重启时只会加载aof文件,不会加载rdb文件。
开启混合持久化方式后:
配置
# 开启混合持久化配置
aof-use-rdb-preamble yes
先使用RDB进行快照存储,然后使用AOF持久化记录所有的写操作,当重写策略满足或者手动触发重写的时候,将最新的数据存储为RDB记录。这样的话重启服务的时候会从RDB何AOF两部分恢复数据,既保证了数据完整性,又提高了恢复数据的性能。
4 纯缓存模式(同时关闭RDB+AOF)
# 禁用RDB
# 禁用后仍然可以使用save、bgsave生成RDB文件
save ""
# 禁用AOF
# 禁用后,仍然可以使用 bgrewrtteaof 生成aof文件
appendonly no
参考地址:
https://www.bilibili.com/video/BV13R4y1v7sP(尚硅谷~阳哥)
<p><font face="楷体,华文行楷,隶书,黑体" color="red" size="4"><strong>哈喽,大家好,我是有勇气的牛排(全网同名)🐮🐮🐮</strong></font></p>
<p><font face="楷体,华文行楷,隶书,黑体" color="blue" size="4"><strong>有问题的小伙伴欢迎在文末评论,点赞、收藏是对我最大的支持!!!。</strong></font></p>
<p><h3>文章目录</h3><ul><ul><li><a href="#1_RDB_10">1 RDB持久化</a></li><ul><li><a href="#11__12">1.1 官方介绍:</a></li><li><a href="#12__35">1.2 配置文件</a></li><ul><li><a href="#121_Redis_6016_37">1.2.1 Redis 6.0.16以下版本</a></li><li><a href="#122_Redis_6270_48">1.2.2 Redis 6.2/7.0以后版本</a></li></ul><li><a href="#13__75">1.3 操作步骤</a></li><ul><li><a href="#131__77">1.3.1 自动操作</a></li><li><a href="#132__92">1.3.2 手动触发</a></li></ul><li><a href="#14__112">1.4 恢复数据</a></li><li><a href="#15_RDB_119">1.5 RDB优缺点</a></li><ul><li><a href="#151__121">1.5.1 优点</a></li><li><a href="#152__130">1.5.2 缺点</a></li></ul><li><a href="#16_dumprdb_138">1.6 检查修复dump.rdb文件</a></li><li><a href="#17_RDB_148">1.7 哪些情况会触发RDB快照</a></li><li><a href="#18__158">1.8 禁用快照</a></li><li><a href="#19_RDB_174">1.9 RDB优化配置项</a></li></ul><li><a href="#2_AOFAppend_only_file_195">2 AOF(Append only file)持久化</a></li><ul><li><a href="#21_AOF_197">2.1 AOF介绍</a></li><li><a href="#22_AOF_207">2.2 AOF持久化工作流程</a></li><li><a href="#23_AOF_217">2.3 AOF的三种写回策略</a></li><li><a href="#24__238">2.4 配置文件</a></li><li><a href="#25_AOF_310">2.5 AOF文件修复</a></li><li><a href="#26__322">2.6 优缺点</a></li><li><a href="#27_AOF_335">2.7 AOF重写</a></li></ul><li><a href="#3_RDBAOF_345">3 RDB-AOF混合持久化</a></li><li><a href="#4_RDBAOF_371">4 纯缓存模式(同时关闭RDB+AOF)</a></li></ul></ul></p>
<p>官方文档:https://redis.io/docs/management/persistence/</p>
<h2><a id="1_RDB_10"></a>1 RDB持久化</h2>
<h3><a id="11__12"></a>1.1 官方介绍:</h3>
<p><strong>RDB (Redis DataBase)</strong> 持久性以<strong>指定的时间间隔</strong>执行数据集的时间点快照,这个<strong>快照</strong>文件就称为RDB(<strong>dump.rdb</strong>),在恢复的时候将快照文件读会到内存即可。</p>
<p>在保存快照的时候,它是备份<strong>全量快照</strong>,也就是把内存中的所有数据都记录到磁盘中。</p>
<p>配置</p>
<pre><div class="hljs"><code class="lang-shell">config get requirepass
config get port
</code></div></pre>
<p>启动</p>
<pre><div class="hljs"><code class="lang-shell">redis-server /usr/local/redis/redis.conf
redis-cli -a 123456
</code></div></pre>
<h3><a id="12__35"></a>1.2 配置文件</h3>
<h4><a id="121_Redis_6016_37"></a>1.2.1 Redis 6.0.16以下版本</h4>
<p>语法:<code>save m n</code></p>
<p>描述:如果m秒内数据集存在n次修改时,自动触发bgsave</p>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">每隔900s(15min), 如果超过1个key发生了变化,就写一份新的RDB文件</span>
save 900 1
</code></div></pre>
<h4><a id="122_Redis_6270_48"></a>1.2.2 Redis 6.2/7.0以后版本</h4>
<p>语法:<code>save <seconds> <changes> [<seconds> <changes> ...]</code></p>
<p>Reids将会再如下两种情况保存快照:</p>
<ul>
<li>超过给定的时间</li>
<li>对数据库操作超过给定次数</li>
</ul>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">禁用快照 空字符串</span>
save ""
<span class="hljs-meta">
# </span><span class="language-bash">Unless specified otherwise, by default Redis will save the DB:</span>
<span class="hljs-meta"># </span><span class="language-bash"> * After 3600 seconds (an hour) <span class="hljs-keyword">if</span> at least 1 change was performed</span>
<span class="hljs-meta"># </span><span class="language-bash"> * After 300 seconds (5 minutes) <span class="hljs-keyword">if</span> at least 100 changes were performed</span>
<span class="hljs-meta"># </span><span class="language-bash"> * After 60 seconds <span class="hljs-keyword">if</span> at least 10000 changes were performed</span>
<span class="hljs-meta"># </span><span class="language-bash">例如</span>
save 3600 1 300 100 60 10000
</code></div></pre>
<h3><a id="13__75"></a>1.3 操作步骤</h3>
<h4><a id="131__77"></a>1.3.1 自动操作</h4>
<p>Redis7</p>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">5s内有2次修改 则保存</span>
save 5 2
<span class="hljs-meta">
# </span><span class="language-bash">504 自定义保存路径</span>
dir /usr/local/redis/data
<span class="hljs-meta">
# </span><span class="language-bash">481 自定义保存文件名</span>
dbfilename dump.rdb
</code></div></pre>
<h4><a id="132__92"></a>1.3.2 手动触发</h4>
<p><strong>1、save</strong></p>
<p>在住程序包中执行<strong>会阻塞</strong>当前redis服务器,直到持久化工作完成,在执行save命令期间,Redis不能处理其他命令,<strong>线上禁止使用</strong>。</p>
<p><strong>2、bgsave</strong></p>
<p>执行该命令时,Redis会在后台异步进行快照操作,快照同时还可以响应客户端请求。具体操作是Redis进程执行fork操作创建子进程,RDB持久化过程由子进程负责,完成后自动结束。阻塞只发生在fork阶段,一般时间很短。</p>
<p><img src="https://static.couragesteak.com/article/f0561bcd902a93b588580e2d0a888e25.png" alt="bgsave后台异步进行快照" /></p>
<p><strong>3、lastsave</strong></p>
<p>获取上一次成功快照时间</p>
<h3><a id="14__112"></a>1.4 恢复数据</h3>
<ul>
<li>将备份文件(dump.rdb)移动到redis安装目录并启动服务即可。</li>
<li>一定要分机隔离,避免新数据丢失。</li>
</ul>
<h3><a id="15_RDB_119"></a>1.5 RDB优缺点</h3>
<h4><a id="151__121"></a>1.5.1 优点</h4>
<ul>
<li>适合大规模数据恢复</li>
<li>按照业务定时备份</li>
<li>对数据完整性和一致性要求不高</li>
<li>RDB文件在内存中的加载速度要比AOF要快的多</li>
</ul>
<h4><a id="152__130"></a>1.5.2 缺点</h4>
<ul>
<li>在一定间隔时间做一次备份,如果redis意外down,就会丢失从当期至最近一次快照时间的数据。</li>
<li>内存数据全量同步,如果数据量太大会导致I/O验证影响服务器性能。</li>
<li>RDB依赖于主进程fork,在跟打的数据集中,这可能会导致服务请求的瞬间延迟。fork的时候,内存中的数据备克隆了一份,大致2倍的膨胀性,需要考虑。</li>
</ul>
<h3><a id="16_dumprdb_138"></a>1.6 检查修复dump.rdb文件</h3>
<p>修复命令</p>
<pre><div class="hljs"><code class="lang-shell">redis-check-rdb /usr/local/redis/redis.conf
</code></div></pre>
<h3><a id="17_RDB_148"></a>1.7 哪些情况会触发RDB快照</h3>
<ul>
<li>配置文件中默认的快照配置</li>
<li>手动save/bgsave命令</li>
<li>执行flushall/flushdb命令也会产生dump.rdb文件,但里面是空白。</li>
<li>执行shutdown,且没有开启AOF持久化</li>
<li>主从复制比时,主节点自动触发</li>
</ul>
<h3><a id="18__158"></a>1.8 禁用快照</h3>
<p>修改配置</p>
<pre><div class="hljs"><code class="lang-shell">save ""
</code></div></pre>
<p>命令修改</p>
<pre><div class="hljs"><code class="lang-shell">redis-cli config set save ""
</code></div></pre>
<h3><a id="19_RDB_174"></a>1.9 RDB优化配置项</h3>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash"><span class="hljs-built_in">yes</span>(默认, 推荐)</span>
<span class="hljs-meta"># </span><span class="language-bash">no: 表示不在户数据不一致or其他手段发现和控制这种不一致,那么在快照写入失败时,也能确保redis继续接受新的写请求。</span>
stop-writes-on-bgsave-error yes
<span class="hljs-meta">
# </span><span class="language-bash"><span class="hljs-built_in">yes</span>(默认, 推荐): 对于存储到磁盘中的快照,可以设置是否进行压缩存储。</span>
<span class="hljs-meta"># </span><span class="language-bash">如果是:redis则会采用LZF算法进行压缩。</span>
rdbcompression yes
<span class="hljs-meta">
# </span><span class="language-bash"><span class="hljs-built_in">yes</span>(默认, 推荐): 在存储快照后,还可以让redis使用CRC64算法进行数据校验,但是这样做会增大10%的性能消耗,如果希望性能最大提升,则可以关闭。</span>
rdbchechsum yes
<span class="hljs-meta">
# </span><span class="language-bash">在没有持久性的情况下删除复制中使用的RDB文件启动</span>
<span class="hljs-meta"># </span><span class="language-bash">默认为no</span>
rdb-del-sync-files no
</code></div></pre>
<h2><a id="2_AOFAppend_only_file_195"></a>2 AOF(Append only file)持久化</h2>
<h3><a id="21_AOF_197"></a>2.1 AOF介绍</h3>
<p>定义:以日志的形式来记录每个写操作,将Redis执行过得所有写指令记录下来(读操作不记录),只许追加文件不可以写文件,redis启动之初会读取该文件重新构建数据,换言之,reids重启的话就根据日志文件的内容将写指令从前到后执行一次,以完成数据的恢复工作。</p>
<p>默认情况下,redis没有开启AOF。</p>
<p><strong>保存文件为</strong>:<code>appendonly.aof</code></p>
<h3><a id="22_AOF_207"></a>2.2 AOF持久化工作流程</h3>
<ol>
<li>Client作为命令的来源,会有多个源头以及源源不断的请求命令。</li>
<li>在这些命令到达Redis Server以后,并不是直接写入AOF文件,而是会将这些玩命令先放入到AOF缓存中进行保存。这里的AOF缓冲区实际上是内存中的一片区域,存在的目的是当这些命令到达一定量以后再写入磁盘,避免频繁的IO操作。</li>
<li>AOF缓冲区会根据AOF缓冲区<strong>同步文件的三种写会策略</strong>,将命令写入磁盘上的AOF文件。</li>
<li>随着写入AOF内容的增加,为避免文件膨胀,会根据规则进行命令合并(又称<strong>AOF重写</strong>),从而起到AOF文件压缩的目的。</li>
<li>当Redis Server服务器重启的时候,就会从AOF文件载入数据。</li>
</ol>
<h3><a id="23_AOF_217"></a>2.3 AOF的三种写回策略</h3>
<p><code>Always</code>:同步回写,每个命令执行完立刻同步地将日志写会磁盘。</p>
<p><code>everysec </code>:每秒写回,每个命令执行完,只是先把日志写到AOF文件的内存缓冲区,每隔1s把缓冲区的内容写入磁盘。</p>
<p><code>no</code>:操作系统控制写回,每隔命令执行完,只是先把日志写到AOF文件的内存缓冲区,由操作系统决定何时将缓冲区内容写回磁盘。</p>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">1379</span>
appendonly everysec
</code></div></pre>
<table>
<thead>
<tr>
<th>配置项</th>
<th>写回时机</th>
<th>优点</th>
<th>缺点</th>
</tr>
</thead>
<tbody>
<tr>
<td>Always</td>
<td>同步写回</td>
<td>可靠性高,数据基本不丢失</td>
<td>每个写命令都要落盘,性能影响大</td>
</tr>
<tr>
<td>Everysec</td>
<td>每秒写回</td>
<td>性能适中</td>
<td>宕机时丢失1s内的数据</td>
</tr>
<tr>
<td>No</td>
<td>操作系统控制写回</td>
<td>性能好</td>
<td>宕机时丢失的数据较多</td>
</tr>
</tbody>
</table>
<h3><a id="24__238"></a>2.4 配置文件</h3>
<p>在redis6中只用单个AOF文件,但是在redis7中,AOF被拆分为了3个文件(Multi Part AOF设计)</p>
<ul>
<li>base:一般由子进程通过重写产生,该文件最多只有一个。</li>
<li>incr:一般会再AOFRW开始执行时被创建爱,每次AOFRW成功完成时,本次AOFRW之前对应的BASE和INCR AOF,都将变为HISTORY,HISTORY类型的AOF会被Redis自动删除。</li>
<li>history</li>
</ul>
<p>redis6</p>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">AOF开启</span>
appendonly yes
<span class="hljs-meta">
# </span><span class="language-bash">写回策略</span>
appendfsync everysec
<span class="hljs-meta">
# </span><span class="language-bash">保存路径 与RDB一样</span>
dir /usr/local/redis/data
<span class="hljs-meta">
# </span><span class="language-bash">文件名</span>
appenddirname "appendonly.aof"
</code></div></pre>
<p>reids7</p>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">AOF开启</span>
appendonly yes
<span class="hljs-meta">
# </span><span class="language-bash">写回策略</span>
appendfsync everysec
<span class="hljs-meta">
# </span><span class="language-bash">RDB数据保存路径</span>
dir /usr/local/redis/data
<span class="hljs-meta">
# </span><span class="language-bash">AOF保存路径(自动拼接<span class="hljs-built_in">dir</span>)</span>
<span class="hljs-meta"># </span><span class="language-bash">1412 {<span class="hljs-built_in">dir</span>}/appendonlydir</span>
appenddirname "appendonlydir"
<span class="hljs-meta">
# </span><span class="language-bash">1406 文件名</span>
appenddirname "appendonly.aof"
</code></div></pre>
<p><img src="https://static.couragesteak.com/article/a494f83035c72b274c9bb1fda3e7176f.png" alt="image.png" /></p>
<p>Append only mode模块</p>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">是否开启aof</span>
appendonly yes
<span class="hljs-meta">
# </span><span class="language-bash">文件名称</span>
appendfilename "appendonly.aof"
<span class="hljs-meta">
# </span><span class="language-bash">同步方式: everysec/always/no</span>
appendfsync "everysec"
<span class="hljs-meta">
# </span><span class="language-bash">aof重写期间是否同步</span>
no-appendfsync-on-wirte no
<span class="hljs-meta">
# </span><span class="language-bash">重写触发配置、文件重写策略</span>
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
</code></div></pre>
<h3><a id="25_AOF_310"></a>2.5 AOF文件修复</h3>
<p>问题:AOF文件没有写完,宕机等情况</p>
<p>异常修复命令</p>
<pre><div class="hljs"><code class="lang-shell">redis-check-aof --fix ***.aof
</code></div></pre>
<h3><a id="26__322"></a>2.6 优缺点</h3>
<p>优点</p>
<ul>
<li>更好的保护数据不丢失、性能高、可做紧急恢复</li>
</ul>
<p>缺点</p>
<ul>
<li>就相同数据集的数据而言,AOF文件要远大于rdb文件,回复速度慢于rdb</li>
<li>aof运行效率要慢于rdb,每秒同步策略效率要好。</li>
</ul>
<h3><a id="27_AOF_335"></a>2.7 AOF重写</h3>
<ol>
<li>在重写开始前,redis会创建一个"重写子进程",这个子进程会读取现有的AOF文件,并将其包含的指令进行分析压缩写入到一个临时文件中。</li>
<li>与此同时,主进程会将新收到的指令一遍积累到内存缓冲区中,一遍继续写入原有的AOF文件中,这样做是保证原有的AOF文件的可用性,避免在重写的过程中出现意外。</li>
<li>当“重写子进程”,完成重写工作后,它会给父进程发一个信号,父进程收到信号后就会将内存中的写指令追加到新AOF中</li>
<li>当追加结束后,redis就会用新AOF文件来替换旧AOF文件,之后再有新的指令,就会追加到新的AOF文件中。</li>
<li>重写AOF文件的操作,并没有读取旧的AOF文件,而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,这点和快照有点类似。</li>
</ol>
<h2><a id="3_RDBAOF_345"></a>3 RDB-AOF混合持久化</h2>
<p>默认在同时开启rdb和aof持久化时,重启时只会加载aof文件,不会加载rdb文件。</p>
<p>开启混合持久化方式后:</p>
<ul>
<li>RDB快照做全量持久化</li>
<li>AOF做增量持久化</li>
</ul>
<p>配置</p>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">开启混合持久化配置</span>
aof-use-rdb-preamble yes
</code></div></pre>
<p>先使用RDB进行快照存储,然后使用AOF持久化记录所有的写操作,当重写策略满足或者手动触发重写的时候,将最新的数据存储为RDB记录。这样的话重启服务的时候会从RDB何AOF两部分恢复数据,既保证了数据完整性,又提高了恢复数据的性能。</p>
<h2><a id="4_RDBAOF_371"></a>4 纯缓存模式(同时关闭RDB+AOF)</h2>
<pre><div class="hljs"><code class="lang-shell"><span class="hljs-meta"># </span><span class="language-bash">禁用RDB</span>
<span class="hljs-meta"># </span><span class="language-bash">禁用后仍然可以使用save、bgsave生成RDB文件</span>
save ""
<span class="hljs-meta">
# </span><span class="language-bash">禁用AOF</span>
<span class="hljs-meta"># </span><span class="language-bash">禁用后,仍然可以使用 bgrewrtteaof 生成aof文件</span>
appendonly no
</code></div></pre>
<p>参考地址:</p>
<p>https://www.bilibili.com/video/BV13R4y1v7sP(尚硅谷~阳哥)</p>
留言