【转载】redis4.0之RDB-AOF混合持久化

最新推荐文章于 2024-02-23 14:44:33 发布
最新推荐文章于 2024-02-23 14:44:33 发布
阅读量446 收藏
点赞数
分类专栏： 转载 文章标签： redis java 缓存 数据持久化 aof
原文链接：https://developer.aliyun.com/article/193034?spm=a2c6h.13262185.0.0.2ba445f4w0WwoU
版权

转自阿里云开发者社区，但是原文没有标点符号，看着很难受，于是自己加了一下……原文章在此

文章目录

简介

redis有两种持久化的方式——RDB和AOF，RDB是一份内存快照，AOF则为可回放的命令日志，他们两个各有特点也相互独立。4.0开始允许使用RDB-AOF混合持久化的方式，结合了两者的优点，通过aof-use-rdb-preamble配置项可以打开混合开关。

RDB V.S. AOF

1. RDB

RDB文件本质上是一份内存快照，保存了创建RDB文件那个时间点的redis全量数据，具有数据文件小、创建/恢复快的优点。但是由于快照的特性，无法保存创建RDB之后的增量数据。

2. AOF

AOF文件本质上是一份执行日志，保存所有对redis进行更改的命令，增量数据也就随命令写入AOF文件。刷盘的策略由配置项appendfsync控制，可以选择"everysec"或"always"。

AOF文件基本上是human-readable的文本，所以其体积相对较大。在从AOF文件恢复数据时，就是做日志回放，执行AOF文件中记录的所有命令，所以相对RDB而言恢复耗时较长。

随着redis的运行，AOF文件会不断膨胀，由aofrewrite机制来防止磁盘空间被撑满。详见《redis4.0之利用管道优化aofrewrite》。

RDB-AOF混合持久化

细细想来，aofrewrite时也是先写一份全量数据到新AOF文件中，再追加增量，只不过全量数据是以redis命令的格式写入。那么是否可以先以RDB格式写入全量数据，再追加增量日志呢？这样既可以提高aofrewrite和恢复速度，也可以减少文件大小，还可以保证数据的完毕性，整合RDB和AOF的优点。
那么现在4.0实现了这一特性——RDB-AOF混合持久化。

aofrewrite

综上所述，RDB-AOF混合持久化体现在aofrewrite时，那么我们就从这里开始来看4.0是如何实现的。

回忆下aofrewrite的过程，无论是serverCron触发，或者执行BGREWRITEAOF命令，最终redis都会走到rewriteAppendOnlyFileBackground()。该函数会fork子进程，进入rewriteAppendOnlyFile函数来生成新的AOF文件，混合持久化就从这里开始。

int rewriteAppendOnlyFile(char *filename) {
    ...
    if (server.aof_use_rdb_preamble) {
        int error;
        if (rdbSaveRio(&aof,&error,RDB_SAVE_AOF_PREAMBLE,NULL) == C_ERR) {
            errno = error;
            goto werr;
        }
    } else {
        if (rewriteAppendOnlyFileRio(&aof) == C_ERR) goto werr;
    }
    ...
}

可以看到当混合持久化开关打开时，就会进入rdbSaveRio函数，先以RDB格式来保存全量数据。

前文说到，子进程在做aofrewrite时，会通过管道从父进程读取增量数据，并缓存下来，那么在以RDB格式保存全量数据时也会从管道读取数据，并不会造成管道阻塞。

int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
    ...
    snprintf(magic,sizeof(magic),"REDIS%04d",RDB_VERSION);
    if (rdbWriteRaw(rdb,magic,9) == -1) goto werr;
    if (rdbSaveInfoAuxFields(rdb,flags,rsi) == -1) goto werr;

首先把RDB的版本（注意不是redis的版本）和辅助域写入文件。

    for (j = 0; j < server.dbnum; j++) {
        redisDb *db = server.db+j;
        dict *d = db->dict;
        if (dictSize(d) == 0) continue;
        di = dictGetSafeIterator(d);
        if (!di) return C_ERR;

        /* Write the SELECT DB opcode */
        if (rdbSaveType(rdb,RDB_OPCODE_SELECTDB) == -1) goto werr;
        if (rdbSaveLen(rdb,j) == -1) goto werr;

        /* Write the RESIZE DB opcode. We trim the size to UINT32_MAX, which
         * is currently the largest type we are able to represent in RDB sizes.
         * However this does not limit the actual size of the DB to load since
         * these sizes are just hints to resize the hash tables. */
        uint32_t db_size, expires_size;
        db_size = (dictSize(db->dict) <= UINT32_MAX) ?
                                dictSize(db->dict) :
                                UINT32_MAX;
        expires_size = (dictSize(db->expires) <= UINT32_MAX) ?
                                dictSize(db->expires) :
                                UINT32_MAX;
        if (rdbSaveType(rdb,RDB_OPCODE_RESIZEDB) == -1) goto werr;
        if (rdbSaveLen(rdb,db_size) == -1) goto werr;
        if (rdbSaveLen(rdb,expires_size) == -1) goto werr;

然后遍历DB，先把dbnum和db_size、expires_size写入文件。

        /* Iterate this DB writing every entry */
        while((de = dictNext(di)) != NULL) {
            sds keystr = dictGetKey(de);
            robj key, *o = dictGetVal(de);
            long long expire;

            initStaticStringObject(key,keystr);
            expire = getExpire(db,&key);
            if (rdbSaveKeyValuePair(rdb,&key,o,expire,now) == -1) goto werr;

            /* When this RDB is produced as part of an AOF rewrite, move
             * accumulated diff from parent to child while rewriting in
             * order to have a smaller final write. */
            if (flags & RDB_SAVE_AOF_PREAMBLE &&
                rdb->processed_bytes > processed+AOF_READ_DIFF_INTERVAL_BYTES)
            {
                processed = rdb->processed_bytes;
                aofReadDiffFromParent();
            }
        }
        dictReleaseIterator(di);
    }
    di = NULL; /* So that we don't release it again on error. */

在当前DB中遍历所有的key，把key-value对及过期时间（如果有设置的话）写入文件。

这里小插曲一下，在rdbSaveKeyValuePair函数中会判断expire是否已经到了过期时间，如果已经过期就不会写入文件。
同时如果flags标记了RDB_SAVE_AOF_PREAMBLE的话，说明是在aofrewrite且开启了RDB-AOF混合开关，此时就会从父进程去读取增量数据了。

    /* EOF opcode */
    if (rdbSaveType(rdb,RDB_OPCODE_EOF) == -1) goto werr;

    /* CRC64 checksum. It will be zero if checksum computation is disabled, the
     * loading code skips the check in this case. */
    cksum = rdb->cksum;
    memrev64ifbe(&cksum);
    if (rioWrite(rdb,&cksum,8) == 0) goto werr;
    return C_OK;
}

最后把代表RDB格式结束的RDB_OPCODE_EOF标记和校验和写入文件。

RDB-AOF混合持久化的RDB部分到此结束。
rdbSaveRio函数运行完后返回rewriteAppendOnlyFile，继续把增量数据写入AOF文件。也就是说AOF文件的前半段是RDB格式的全量数据后半段是redis命令格式的增量数据。

数据恢复

当appendonly配置项为no时，redis启动后会去加载RDB文件，以RDB格式来解析RDB文件自然没有问题。

而appendonly配置项为yes时，redis启动后会加载AOF文件来恢复数据。如果持久化时开启了RDB-AOF混合开关，那么AOF文件的前半段就是RDB格式，此时要如何正确加载数据呢？

一切数据都逃不过协议二字。不以正确的协议存储和解析，那就是乱码。既然允许RDB-AOF混合持久化，就要能够识别并恢复数据。

这一节我们来介绍如何以正确的姿势来恢复数据。

加载AOF文件的入口为loadAppendOnlyFile：

int loadAppendOnlyFile(char *filename) {
    ...
    /* Check if this AOF file has an RDB preamble. In that case we need to
     * load the RDB file and later continue loading the AOF tail. */
    char sig[5]; /* "REDIS" */
    if (fread(sig,1,5,fp) != 5 || memcmp(sig,"REDIS",5) != 0) {
        /* No RDB preamble, seek back at 0 offset. */
        if (fseek(fp,0,SEEK_SET) == -1) goto readerr;
    } else {
        /* RDB preamble. Pass loading the RDB functions. */
        rio rdb;

        serverLog(LL_NOTICE,"Reading RDB preamble from AOF file...");
        if (fseek(fp,0,SEEK_SET) == -1) goto readerr;
        rioInitWithFile(&rdb,fp);
        if (rdbLoadRio(&rdb,NULL) != C_OK) {
            serverLog(LL_WARNING,"Error reading the RDB preamble of the AOF file, AOF loading aborted");
            goto readerr;
        } else {
            serverLog(LL_NOTICE,"Reading the remaining AOF tail...");
        }
    }
    ...
}

打开AOF文件之后首先读取5个字符，如果是"REDIS"，那么就说明这是一个混合持久化的AOF文件。

正确的RDB格式一定是以"REDIS"开头，而纯AOF格式则一定以"*"开头

此时就会进入rdbLoadRio函数来加载数据。

rdbLoadRio函数此处就不详细展开了，就是以约定好的协议解析文件内容，直至遇到RDB_OPCODE_EOF结束标记返回，loadAppendOnlyFile函数继续以AOF格式解析文件直到结束，整个加载过程完成。

附录

1. RDB格式的文件

我们先向redis写入一些数据，并生成RDB文件：

$redis-cli
127.0.0.1:6379> set foo bar
OK
127.0.0.1:6379> expire foo 60
(integer) 1
127.0.0.1:6379> select 2
OK
127.0.0.1:6379[2]> set foo bar
OK
127.0.0.1:6379[2]> bgsave
Background saving started

看下RDB文件内容

$cat dump.rdb
REDIS0008    redis-ver4.0.1
redis-bits@ctimeYused-mem 
                                aof-preamblerepl-id(484f9d49a700c4b9b136f0fd40d2d6e5a8460438
                                                                                               repl-offa;^foobarfoobar^KJ_U

OMG…一堆乱码。隐约可以看到一些和redis相关的字符串。
为了更直观的感受下RDB的内容，我们用redis自带的工具redis-check-rdb来看下：

redis-check-rdb dump.rdb
[offset 0] Checking RDB file dump.rdb
[offset 26] AUX FIELD redis-ver = '4.0.1'
[offset 40] AUX FIELD redis-bits = '64'
[offset 52] AUX FIELD ctime = '1504234774'
[offset 67] AUX FIELD used-mem = '2139016'
[offset 83] AUX FIELD aof-preamble = '0'
[offset 133] AUX FIELD repl-id = '484f9d49a700c4b9b136f0fd40d2d6e5a8460438'
[offset 148] AUX FIELD repl-offset = '0'
[offset 150] Selecting DB ID 0
[offset 173] Selecting DB ID 2
[offset 194] Checksum OK
[offset 194] \o/ RDB looks OK! \o/
[info] 2 keys read
[info] 1 expires
[info] 0 already expired

这下就好看多了。首先可以看到是一些AUX FIELD辅助域（4.0特有），用来配合全新的主从同步方式PSYNC2（后面会专门来介绍PSYNC2），然后可以看到DB0和DB2是有内容的，Checksum也OK，最后是说一共有2个key，其中一个设置了过期时间，到目前为止还都没有过期。

2.AOF格式的文件

同样的数据，我们来看下在AOF文件中是如何保存的：

$cat appendonly.aof
*2
$6
SELECT
$1
0
*3
$3
set
$3
foo
$3
bar
*3
$9
PEXPIREAT
$3
foo
$13
1504255377087
*2
$6
SELECT
$1
2
*3
$3
set
$3
foo
$3
bar

很明显就是一条一条redis命令。

3. RDB-AOF混合持久化的文件

最后来看下RDB-AOF混合持久化的文件。

首先打开混合开关，执行BGREWRITEAOF，生成RDB-AOF混合文件，再追加写入一些数据：

$redis-cli
127.0.0.1:6379> config set aof-use-rdb-preamble yes
OK
127.0.0.1:6379> BGREWRITEAOF
Background append only file rewriting started
127.0.0.1:6379> set foo bar
OK
127.0.0.1:6379> quit

再来看下此时AOF文件内容：

$cat appendonly.aof
REDIS0008    redis-ver4.0.1
redis-bits@ctimeYused-memP 
                                  aof-preamblerepl-id(484f9d49a700c4b9b136f0fd40d2d6e5a8460438
                                                                                                 repl-offsetfoobar?I    Y*2
$6
SELECT
$1
0
*3
$3
set
$3
foo
$3
bar

显而易见前半段是RDB格式的全量数据后半段是redis命令格式的增量数据。

JungleNotTODO
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis的持久化详解
怪咖@的博客
06-05 2万+
Redis的持久化，Redis是一个基于内存的数据库，它的数据是存放在内存中，内存有个问题就是关闭服务或者断电会丢失。Redis的数据也支持写到硬盘中，这个过程就叫做持久化。RDB（Redis DataBase）：简而言之，就是在指定的时间间隔内，定时的将 redis 存储的数据生成Snapshot快照并存储到磁盘等介质上；AOF（Append Of File）：将 redis 执行过的所有写指令记录下来，在下次 redis 重新启动时，只要把这些写指令从前到后再重复执行一遍，就可以实现数据恢复了。
redis持久化（RDB、AOF、混合持久化）
weixin_38598961的博客
04-29 1113
redis持久化（RDB、AOF、混合持久化）
【Redis】三种持久化机制？RDB、AOF、混合？这下弄明白了
CYK_byte的博客
03-28 1878
首先来谈谈什么是持久化？持久化就是将数据从内存保存到磁盘的过程，其目的就是为了防止数据丢失。为什么要这样做？因为内存中的数据在重启服务器后就会丢失，而磁盘上的数据则不会，因此为了系统稳定，我们就需要把数据进行持久化。同时持久化功能也是 Redis 和 Memcached 最主要的区别之一，因为 Redis 支持持久化而 Memcached 不支持~那么 Redis 具体是如何实现持久化的呢？往下看~
Redis三种持久化方式详解
治愈里
08-20 2904
AOF（追加写文件）：AOF持久性记录服务器接收到的每个写入操作。于是在 Redis 重启的时候，可以 先加载 RDB 的内容，然后再重放增量 AOF 日志就可以完全替代之前的 AOF 全量文件重放，因此重启效率大幅得到提升。新的文件一开始不叫appendonly.aof，等到重写完新的AOF文件才会进行改名，覆盖原有的AOF文件，完成新旧两个AOF文件的替换。而是将重写这一刻之前的内存做RDB快照处理，并且将RDB快照内容和增量的AOF修改内存数据的命令存在一起，都写入新的AOF文件。
Redis持久化机制
weixin_30827565的博客
09-23 331
Redis持久化机制 众所周知，Redis是一个内存数据库。但它与其它内存数据库（如memcache）等有一个很大的区别，就是Redis可以持久化到磁盘。有了持久化方案，Redis就可以对数据进行备份、恢复、复制。 Redis提供了两种持久化方案：RDB和AOF。在Redis 4.0中，提供了一个新特性：两者的混合持久化。下面将介绍Redis的各种持久化方案的原理和配置。 使用...
Redis持久化RDB和AOF区别详解
12-14
**AOF持久化**： AOF（Append Only File）记录了所有对数据库的写操作，以命令追加形式保存在日志文件中。当Redis重启时，会重新执行AOF文件中的所有命令来恢复数据。AOF有三种同步策略： 1. `always`：每次写操作...
Redis 持久化之RDB和AOF.doc
10-09
Redis 持久化是确保数据安全的重要机制，它提供了两种主要的方法：RDB（Redis Database）和 AOF（Append Only File）。RDB 是一种快照式的持久化方式，而 AOF 则记录每次写操作的日志。 RDB 持久化在特定条件下将...
尚硅谷——Redis之RDB和AOF持久化
01-31
RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘。 也是默认的持久化方式，这种方式是就是将内存中数据以快照的方式写入到二进制文件中,默认的文件名为dump.rdb。
Redis持久化 - RDB和AOF
08-17
“Redis持久化 - RDB和AOF” Redis持久化是指将数据库中的数据保存到永久存储设备中，以避免数据丢失。Redis提供了两种持久化方式：RDB（快照方式）和AOF（写日志方式）。 RDB（Redis Database）是一种快照方式的...
Redis两种持久化方案RDB和AOF详解
09-09
**AOF持久化**： AOF（Append Only File）记录了所有的写操作日志，每次写操作都会追加到AOF文件的末尾。Redis启动时，会读取AOF文件来恢复数据。AOF的默认关闭状态可以通过在配置文件中设置`appendonly yes`来启用...
全面解析 Redis 持久化：RDB、AOF与混合持久化
最新发布
Henry313的博客
02-23 1247
RDB 适合需要定期备份的场景，AOF 适合对数据丢失有严格要求的应用，而混合持久化模式则是一种比较折中的方案，它结合了 RDB 的快速数据恢复能力和 AOF 的数据安全性。这是一个昂贵的操作，尤其当数据集很大时。混合持久化是 Redis 4.0 新引入的持久化策略，结合了 RDB 的快速恢复和 AOF 的数据完整性的优点，它首先以 RDB 格式保存当前数据状态，然后继续以 AOF 格式记录新的写操作，确保数据完整性并优化恢复速度。，顾名思义，指的是将短暂的、易失的数据转化为长时间保存，且不易丢失的格式。
redis的持久化方式详解
qq_52025132的博客
12-11 974
当内存中的数据被全部写入到新的AOF文件之后，收集的新的变更操作也将被一并追加到新的AOF文件中。redis是开源的，使用 C语言编写，支持网络交互，可以是基于内存可以持久化的key value 的数据库（非关系型的数据库），但是对于redis的存储方式，是存储在内存的，如果遇到如宕机等，存放在内存的数据救回丢失，所以就需要实现持久换来保证数据的完整性，安全性。rdb模式的特点是使用二进制的格式全量的保存redis中的数据,在存储上非常的紧凑,从而使可以控制文件的大小不至于太大.
redis 持久化AOF、RDB、混合持久化
CodingAnHour
05-24 1295
为什么要持久化数据？？？ Redis 的数据全部在内存里，如果突然宕机，数据就会全部丢失 即使只考虑缓存场景，如果未持久化，redis一旦服务宕机，内存中的数据将全部丢失。虽然可以从后端数据库恢复这些数据，但这种方式存在两个问题：一是，需要频繁访问数据库把缓存加载回来，会给数据库带来巨大的压力；二是，这些数据是从慢速数据库中读取出来的，性能肯定比不上从 Redis 中读取，导致使用这些数据的应用程序响应变慢。所以，对 Redis 来说，实现数据的持久化，避免从后端数据库中进行恢复，是至关重要的。 Red
Redis持久化策略——RDB、AOF、混合
天羽云龙的博客
02-19 3387
RDB、AOF、混合持久化、过期KEY清除策略
Redis-4.0以后的混合持久化
qq_36318234的博客
04-18 8403
Redis 当前支持 aof 和 rdb 这两种持久化方式。 有些对 Redis 不是特别的了解同学误解持久化是读写数据也会到磁盘。这里辟谣一下:Redis 读写都是全内存的, 持久化数据只是作为磁盘备份, 实例重启或者机器断电的时候可以从磁盘加载到内存由于本篇博客主要是为了分析 4.0 版本的 rdb 和 aof 混合存储的实现，所以不会详细介绍 rdb 和 aof。如果有想进一步了解可参考 《...
Redis4.0、5.0、6.0、7.0特性整理(持续更新)
热门推荐
zzhongcy的专栏
04-01 1万+
最近研究研究新版本redis的新特性，网上查了查资料，这里记录一下。 Redis 4 ¶ 模块系统 Redis 4.0 发生的最大变化就是加入了模块系统， 这个系统可以让用户通过自己编写的代码来扩展和实现 Redis 本身并不具备的功能，因为模块系统是通过高层次 API 实现的， 它与 Redis 内核本身完全分离、互不干扰， 所以用户可以在有需要的情况下才启用这个功能。目前已经有人使用这个功能开发了各种各样的模块， 比如 Redis Labs 开发的一些模块就可以在 http://...
Redis4 - 持久化
伊始的博客
09-21 229
rdb aof rdb eg. save 900 1 若900s内有一个键发生改变、则进行持久化存储 1. save 会使用主线程进行同步转储、 bgsave是创建一个子进程进行存储 2. save会阻塞服务器 bgsave、redis主进程会创建一个子进程将转储数据保存到一个temp-%s.rdb 的临时文件中、 转储完...
redis----RDB & AOF持久化 &混合持久化
m0_46598535的博客
06-16 401
redis
redis持久化rdb和aof区别
07-15
2. AOF持久化：AOF是通过将Redis的写命令追加到文件的末尾来记录数据库的操作。Redis重启时，通过重新执行AOF文件中的命令来恢复数据库状态。相比于RDB方式，AOF可以提供更高的数据安全性，因为它记录了每个写操作的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值