精华内容
下载资源
问答
  • Redis数据持久化机制及数据恢复
    千次阅读
    2019-12-29 15:50:27

    什么是数据持久化?

    我们知道Redis是基于内存的非关系型数据库,对数据的增删改查操作都直接在内存中进行,再加上Redis不用维护数据之间的“关系”,导致它性能很高,速度很快。

    但是基于内存有一个问题是:一旦机器断电,内存中的数据会丢失。

    数据丢失是很严重的问题,所以Redis是支持数据持久化的。

    数据持久化:将内存中的数据写入到磁盘,数据永久保存。

    Redis的持久化机制

    Redis支持两种持久化机制:RDB和AOF,4.0版本以后还加入了混合持久化机制。

    RDB持久化

    RDB全称:Redis DataBase。

    RDB是Redis默认的持久化机制,在指定的时间间隔内,进行了指定次数的写操作,Redis就会触发RDB持久化,RDB持久化的是数据的二进制文件,节省空间。

    Redis会fork一个和主进程一模一样的子进程,子进程将内存中的所有数据先写入到一个临时文件中,持久化结束以后,将这个临时文件替换正式的dump.rdb文件,整个持久化的过程中主进程不进行任何磁盘IO操作,这就确保了Redis极高的性能。

    持久化文件存放在哪里?
    redis.conf文件中的dir配置的目录 + dbfilename配置的文件名。

    RDB触发时机

    • 在指定的时间间隔内,执行指定次数的写操作。
    • 手动执行save、bgsave时。
    • 执行FlushAll命令时,数据是空的,没有意义。
    • shutdown时,如果没有开启AOF就会触发。
    • 主从复制时。

    save和bgsave

    • save
      阻塞当前Redis服务,直到持久化完成,期间所有请求都会被阻塞,线上一般不使用。

    • bgsave
      Redis服务不受影响,fork一个子进程去异步的持久化,将内存数据写到到临时文件,持久化完成后替换dump.rdb文件。

    RDB的优缺点

    优点

    • 性能高
    • RDB文件占用空间小
    • 数据恢复很快

    缺点

    • 数据完整性和一致性要求不高,可能丢失数据。
    • 备份时占用内存,fork的子进程会让内存突然飙升。

    AOF持久化

    AOF全称:Append Only File。

    AOF持久化在Redis中默认是关闭的,需要手动开启,AOF的出现是为了弥补RDB的不足。

    AOF通过追加日志的方式来做持久化,将涉及到数据增删改的命令以日志的方式追加到aof文件中,Redis服务重启时执行一遍aof中的命令来完成数据的恢复。

    如何开启AOF

    修改配置文件,重启服务。

    # 开启AOF
    appendonly yes
    
    # aof文件名
    appendfilename "appendonly.aof"
    
    # AOF触发时机:
    # always 每次写操作都写入磁盘,效率低。
    # everysec 每秒写入一次磁盘。
    # no Redis不主动写磁盘,由操作系统来决定调用,线上不推荐使用。
    # appendfsync always
    appendfsync everysec
    # appendfsync no
    

    AOF重写机制

    因为AOF文件存储的是命令,就导致它比较庞大,比rdb文件要大很多,Redis需要对其进行“瘦身”。

    AOF重写就是对AOF文件进行“瘦身”,采用的方案是:将多条写操作优化为一条写操作,记录最终结果,而无需记录中间每一步的操作记录,重写之后AOF文件会小很多。

    如下例子:

    rpush a 1
    rpush a 2
    rpush a 3
    
    重写后:
    
    rpush a 1 2 3 (3条命令变成1条)
    

    配置AOF重写策略

    # 当AOF文件大小的增长率大于该配置项时触发重写。
    auto-aof-rewrite-percentage 100
    
    # 当AOF文件大小大于此配置时,触发重写。线上环境要调大该值。
    auto-aof-rewrite-min-size 64mb
    

    手动触发AOF重写

    BGREWRITEAOF

    混合持久化机制

    Redis4.0版本推出了混合持久化机制,5.0之前默认关闭,5.0版本已经默认开启了。

    修改配置文件开启

    aof-use-rdb-preamble yes
    

    混合持久化是通过BGREWRITEAOF来实现的,未开启混合持久化时,AOF重写的方式是将多条指令优化为一条,开启混合持久化后,AOF前半段是RDB格式的二进制数据全量文件,后半段以日志命令的方式追加,AOF文件也采用混合存储。

    数据恢复

    Redis重启后,需要对数据进行恢复,将RDB/AOF中持久化的数据重新加载到内存,步骤大致如下图所示:

    在这里插入图片描述

    更多相关内容
  • Redis持久化机制

    2021-03-29 23:30:10
    支持数据持久化,支持 RDB 和 AOF 两种持久化方式 支持主从复制,主机会自动将数据同步到从机,可以进行读写分离 支持丰富的数据结构,支持 String,List,Set,Zset(有序集合),Hash 五种数据结构 缺点 Redis 不...

    Redis 的优点和缺点

    优点

    • 读写性能优异
    • 支持数据的持久化,支持 RDBAOF 两种持久化方式
    • 支持主从复制,主机会自动将数据同步到从机,可以进行读写分离
    • 支持丰富的数据结构,支持 String,List,Set,Zset(有序集合),Hash 五种数据结构

    缺点

    • Redis 不具备自动容错和恢复功能。主机,从机的宕机都会导致读写请求失败,需要等待机器重启才能恢复
    • 主机宕机,宕机前有部分数据未能及时同步到从机,切换 IP 后还会引入数据不一致的问题,降低了系统的可用性

    Redis 持久化机制

    持久化数据:也就是将内存中的数据写入到硬盘里面,大部分原因是为了之后重用数据(比如重启机器、机器故障之后恢复数据),或者是为了防止系统故障而将数据备份到一个远程位置。Redis 的持久化方式: RDBAOF

    在这里插入图片描述

    RDB 快照持久化

    Redis 可以通过创建快照来获得存储在内存里面的数据。创建快照之后,可以对快照进行备份,可以将快照复制到其他服务器从而创建具有相同数据的服务器副本( Redis 主从结构,主要用来提高 Redis 性能),还可以将快照留在原地以便重启服务器的时候使用

    在这里插入图片描述

    RDB 快照持久化方式

    快照持久化是 Redis 默认采用的持久化方式,在 redis.conf 配置文件中默认有此下配置

    # 在 900 秒(15分钟)之后,如果至少有 1 个 key 发生变化,Redis 就会自动触发 BGSAVE 命令创建快照
    save 900 1     
    # 在 300 秒(5分钟)之后,如果至少有 10 个 key 发生变化,Redis 就会自动触发 BGSAVE 命令创建快照      
    save 300 10 
    # 在 60 秒(1分钟)之后,如果至少有 10000 个 key 发生变化,Redis 就会自动触发 BGSAVE命令创建快照         
    save 60 10000        
    

    RDB 快照持久化优点

    • RDB 是一个非常紧凑的文件,它保存了某个时间点的数据集,非常适用于数据集的备份,比如你可以在每个小时保存一下过去 24 小时内的数据,同时每天保存过去 30 天的数据,这样即使出了问题你也可以根据需求恢复到不同版本的数据集
    • RDB 是一个紧凑的单一文件,很方便传送到另一个远端数据中心或者亚马逊的 S3 (可能加密),非常适用于灾难恢复
    • AOF 相比,在恢复大的数据集的时候,RDB 方式会更快一些

    RDB 快照持久化缺点

    • 耗时、耗性能
    • 不可控、丢失数据

    AOF 持久化

    与快照 RDB 持久化相比,AOF 持久化的实时性更好,因此已成为主流的持久化方案

    默认情况下 Redis 没有开启 AOF 方式的持久化,可以通过 appendonly 参数开启

    # 开启 AOF 持久化
    appendonly yes       
    

    开启 AOF 持久化后每执行一条会更改 Redis 中的数据的命令,Redis 就会将该命令写入硬盘中的 AOF 文件。AOF 文件的保存位置和 RDB 文件的位置相同,都是通过 dir 参数设置的,默认的文件名是 appendonly.aof

    AOF 的运行原理-创建

    在这里插入图片描述

    AOF 的运行原理-恢复

    在这里插入图片描述

    AOF 快照持久化方式

    Redis 的配置文件中存在三种不同的 AOF 持久化方式,它们分别是

    # 每次有数据修改发生时都会写入 AOF 文件,速度缓慢但是最安全
    appendfsync always    
    # 每秒钟同步一次,显示地将多个写命令同步到硬盘。AOF 默认使用的
    appendfsync everysec  
    # 让操作系统决定何时进行同步,速度最快
    appendfsync no        
    

    为了兼顾数据和写入性能,用户可以考虑 appendfsync everysec 选项(AOF 默认使用) ,让 Redis 每秒同步一次 AOF 文件,Redis 性能几乎没受到任何影响。而且这样即使出现系统崩溃,用户最多只会丢失一秒之内产生的数据。当硬盘忙于执行写入操作的时候,Redis 还会优雅的放慢自己的速度以便适应硬盘的最大写入速度

    RDBAOF 的对比选择

    - RDB AOF
    启动优先级
    文件大小
    恢复速度
    数据安全性丢数据根据策略决定
    展开全文
  • 这就是今日总结的Redis持久化机制。 何为持久化? 正常redis数据是保存在内存中的,若遇到redis宕机或者需要重启等场景,数据就会丢失,所以需要将数据存储,将数据备份到磁盘的过程就叫做redis持久化。 redis安装...

    Redis是一种高级key-value数据库,数据存储在内存中,速度很快是优势,但是紧接着带来的则是数据变化瞬息万变,数据该如何保存呢?这就是今日总结的Redis持久化机制。

    一、何为持久化?

    正常redis数据是保存在内存中的,若遇到redis宕机或者需要重启等场景,数据就会丢失,所以需要将数据存储,将数据备份到磁盘的过程就叫做redis持久化。

    redis安装完成之后,所有的配置都是在redis.conf文件中,里面保存了RDB和AOF两种持久化机制的各种配置。

    二、RDB(snapshot)

    全称redis database,在指定的时间间隔内将内存中的数据集快照写入磁盘,也就是行话讲的Snapshot快照,保存在名字为dump.rdb的二进制文件中。它恢复时 直接将快照文件直接读到内存里;

    • 如何开启?

    (1)自动触发

    1、在redis.conf配置文件中,搜索关键字save 则会看到RDB的持久化方式,如下图:
    在这里插入图片描述

    如上图则就是RDB触发的机制,默认值是如上三种情况:

    触发条件说明
    save 900 a如果900秒内至少1个key发生变化(CUD),则重写rdb文件
    save 300 10如果300秒内至少10个key发生变化(CUD),则重写rdb文件
    save 60 10000如果60秒内至少10000个key发生变化(CUD),则重写rdb文件

    若不想开启,则直接把几个注释掉即可。

    除了自动触发,也可以选择手动触发的方式

    (2)手动触发-save命令

    直接执行save命令,则保存成功。每次执行命令都会将所有的redis内存快照到一个新的rdb文件里,覆盖原有的rdb快照文件。默认的是bgsave方式,异步操作。

    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [9:49:44] C:127
    $ redis-cli
    127.0.0.1:6379> save
    OK
    

    看RDB的更新时间,如图:
    在这里插入图片描述
    在这里插入图片描述

    (3)手动触发-bgsave命令

    COW机制
    Copy-On-Write顾名思义,在生成快照的同时,依旧可以正常的处理写命令。
    进行rdb文件生成的并非是主进程,而是由主进程fork生成的子进程完成的。主进程依旧是执行数据操作命令。

    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [10:26:47] C:127
    $ redis-cli
    127.0.0.1:6379> bgsave
    Background saving started
    

    在这里插入图片描述

    (4)save VS bgsave

    命令savebgsave
    IO类型同步异步
    是否阻塞redis其他命令yesno(在生成子进程调用fork函数会有短暂阻塞)
    复杂度O(n)O(n)
    优点不会消耗额外内存不阻塞客户端命令
    缺点阻塞客户端命令需要fork子进程,消耗内存
    • 如何关闭?
      直接注释掉对应的save命令即可。

    三、AOF(append-only file)

    RDB,快照功能并不是非常耐久,如果Redis宕机,服务器肯定就会丢失最近写入且未保存到快照中的数据,所以则多了一种新的持久化方式,记录到appendonly.aof中(先写入os cache,定期写到磁盘)

    (1)开启AOF持久化

    redis.conf文件中,appendonly yes/no 修改为yes即可。
    重启redis,则会发现aof文件。
    PS:若重启了依旧未发现,则执行如下两个命令:

    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [11:43:03]
    $ redis-cli config set appendonly yes
    OK
    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [11:43:20]
    $ redis-cli config set save ""
    OK
    

    在这里插入图片描述

    (2)查看aof文件

    我们执行一个set huo 111的命令,然后查看aof文件:

    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [11:47:09]
    $ redis-cli
    127.0.0.1:6379> set huo 111
    OK
    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [11:47:29]
    $ cat appendonly.aof
    *3
    $3
    set
    $3
    huo
    $3
    111
    

    这是一种resp协议格式数据,*后边代表的数字表示该命令有多少参数;
    $后边代表的数字代表这个参数有几个字符。

    可以通过配置来决定多久fsync到磁盘一次,配置命令依旧再redis.conf中。

    # appendfsync always
    appendfsync everysec
    # appendfsync no
    
    命令说明
    appendfsync always有新命令就执行一次,非常慢但是也非常安全
    appendfsync everysec每秒fsync一次,足够快,并且在故障时只会丢失1秒的数据
    appendfsync no从不fsync,将数据交由操作系统处理,更快,但是更不安全,不采纳

    (3)AOF重写

    想象有这样一种场景,比如string的原则性操作,incr

    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [11:59:45]
    $ redis-cli
    127.0.0.1:6379> incr huocount
    (integer) 1
    127.0.0.1:6379> incr huocount
    (integer) 2
    127.0.0.1:6379> incr huocount
    (integer) 3
    127.0.0.1:6379> incr huocount
    (integer) 4
    127.0.0.1:6379> incr huocount
    (integer) 5
    
    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [12:00:22]
    $ cat appendonly.aof
    $3
    huo
    $3
    111
    *2
    $4
    incr
    $8
    huocount
    *2
    $4
    incr
    $8
    huocount
    *2
    $4
    incr
    $8
    huocount
    *2
    $4
    incr
    $8
    huocount
    *2
    $4
    incr
    $8
    huocount
    

    最快的方式不就是设置huocount=5就OK了。也有对应的配置来控制AOF自动重写频率。

    #aof文件至少要达到64才会自动重写,文件太小恢复速度本来就很快,重写的意义不大
    auto-aof-rewrite-percentage 100
    #aof文件自上一次重写后文件大小增长了100%则再次触发重写
    auto-aof-rewrite-min-size 64mb
    

    重写进程依旧是主进程fork出一个子进程来执行,不会对redis这种正常命令有太多影响。文件太小也就无所谓重写不重写了,自动重写需要条件符合,所以也肯定就有手动重写的命令: bgrewriteaof
    PS :以下会讲述混合模式,我是6.0redis演示,混合模式默认是开启的,所以当我执行了重写命令,aof文件会变为二进制模式,无法再cat查看

    四、RDB VS AOF

    命令RDBAOF
    启动优先级
    体积
    恢复速度
    数据安全性容易丢失数据根据策略决定

    五、混合持久化

    各自了解了两种持久化的优缺点,发现混合使用效果更好。Redis 4.0则采用了混合持久化方式。

    aof-use-rdb-preamble yes/no
    

    混合持久化AOF文件结构如下:
    在这里插入图片描述
    新操作的命令则会继续以AOF的样式在aof文件中存储,之前的则以RDB的二进制文件存储着。

    # huoyajing @ huoyajingdeMBP in /usr/local/redis-6.0.15 [14:15:50]
    $ cat appendonly.aof
    REDIS0009�	redis-ver6.0.15�
    redis-bits�@�ctime�w�!aused-mem�po�
                                       aof-preamble���huo�huocount��g�r�ÁwJ*2
    *3
    $3
    set
    $6
    huohuo
    $3
    232
    
    展开全文
  • 1.Redis 持久化的意义 redis数据全部在内存中,如果突然宕机,数据就会全部丢失,因此必须有一种机制来保证redis数据在发生突发状况时不会...每种持久化机制各有优缺点,了解每种持久化机制的原理对我们使用Redis

    1.Redis 持久化的意义

    redis的数据全部在内存中,如果突然宕机,数据就会全部丢失,因此必须有一种机制来保证redis的数据在发生突发状况时不会丢失、或者只丢失少量,于是必须根据一些策略来把redis内存中的数据写到磁盘中,这样当redis服务重启时,就会将硬盘中的数据恢复到内存中。Redis持久化的意义就是为了保证突然宕机,内存数据不会全部丢失。

    2.Redis 持久化机制

    redis有两种持久化机制:RDB和AOF。每种持久化机制各有优缺点,了解每种持久化机制的原理对我们使用Redis有很大的帮助。Redis4.0后支持RDB和AOF两种持久化机制混合使用,所以存在三种持久化策略。

    (1)RDB持久化

    RDB是基于快照一次的全量备份,即周期性的把redis当前内存中的全量数据写入到一个快照文件中(周期时间可以通过配置来调整)。redis是单线程程序,这个线程要同时负责多个客户端的读写请求,还要负责周期性的把当前内存中的数据写到快照文件中RDB中,数据写到RDB文件是IO操作,IO操作会严重影响redis的性能,甚至在持久化的过程中,读写请求会阻塞,为了解决这些问题,Redis采用多进程来同时进行读写请求和持久化操作。这样又会导致另外的问题,持久化的过程中,内存中的数据还在改变,假如redis正在进行持久化一个大的数据结构,在这个过程中客户端发送一个删除请求,把这个大的数据结构删掉了,这时候持久化的动作还没有完成,那么redis该怎么办呢?

    redis使用操作系统的多进程COW(Copy On Write)机制来实现快照的持久化,在持久化过程中调用 glibc(Linux下的C函数库) 的函数fork()产生一个子进程,快照持久化完全交给子进程来处理,父进程继续处理客户端的读写请求。子进程刚刚产生时,和父进程共享内存里面的代码段和数据段,这是Linux操作系统的机制,为了节约内存资源,所以尽可能让父子进程共享内存,这样在进程分离的一瞬间,内存的增长几乎没有明显变化。

    #1、linux中若父进程退出,子进程尚未结束,子进程不会立即退出。
    	在linux中,所有进程都有一个共同的父进程systemd,如果父进程退出了,子进程还没运行结束,子进程会被systemd(老版本的linux是initd)收养。
    
    #2、RDB持久化时,Redis会fork()一个子进程,快照持久化完全交给子进程来处理,父进程继续处理客户端的读写请求。

    子进程对当前内存中的数据进行持久化时,并不会修改当前的数据结构,如果父进程收到了读写请求,那么会把处理的那一部分数据复制一份到内存,对复制后的数据进行修改。所以即使对某个数据进行了修改,redis持久化到RDB中的数据也是未修改的数据,这也是把RDB文件称为"快照"文件的原因,子进程所看到的数据在它被创建的一瞬间就固定下来了,父进程修改的某个数据只是该数据的复制品。

    实际上,内存中的全量数据由一个个的"数据段页面"组成,每个数据段页面的大小为4K,客户端要修改的数据在哪个页面中,就会复制一份这个页面到内存中,这个复制的过程称为"页面分离",在持久化过程中,随着分离出的页面越来越多,内存就会持续增长,但是不会超过原内存的2倍,因为在一次持久化的过程中,几乎不会出现所有的页面都会分离的情况,读写请求针对的只是原数据中的小部分,大部分redis数据还是"冷数据"。RDB过程整个过程如下图:

    热点数据和冷数据是什么

    • 热点数据:读取频率高,如果不做缓存,给数据库造成很大的压力,可能被击穿。
    • 冷数据:读取频率低,数据设置缓存后有可能没有被访问就被挤出内存(超时dele)。

    RDB有两种触发方式:自动触发和手动触发。

    • (1)自动触发:在 redis.conf 配置文件中的 SNAPSHOTTING 下配置save参数,来触发Redis的 RDB 持久化条件,也就是什么时候将内存中的数据保存到硬盘。比如“save m n”:表示m秒内数据集存在n次修改时,自动触发bgsave。
    //默认如下配置:
    save 900 1:每隔900s(15min),如果有超过1个key发生了变化,就写一份新的RDB文件
    save 300 10:每隔300s(5min),如果有超过10个key发生了变化,就写一份新的RDB文件
    save 60 10000:每隔60s(1min),如果有超过10000个key发生了变化,就写一份新的RDB文件
    (配置多种策略可以同时生效,无论满足哪一种条件都会写一份新的RDB文件)
    • (2)手动触发:手动生成新的RDB文件,执行Redis的save、bgsave命令。
    save:阻塞主进程,直到生成新的RDB文件;执行save命令期间,Redis不能处理其他命令。
    bgsave:异步生成RDB文件,fork子进程去生成新的RDB文件,主进程不阻塞。

    (2)AOF持久化

    AOF(Append-only file)日志存储的是redis服务器的顺序指令序列,即对内存中数据进行修改的指令记录。当redis收到客户端修改指令后,先进行参数校验,如果校验通过,先把该指令存储到AOF日志文件中,也就是先存到磁盘,然后再执行该修改指令。

    redis把操作指令追加到AOF文件这个过程,并不是直接写到AOF文件中,而是先写到操作系统的内存缓存中,这个内存缓存是由操作系统内核分配的,然后操作系统内核会异步地把内存缓存中的redis操作指令刷写到AOF文件中。当redis宕机后重启后,可以读取该AOF文件中的指令,进行数据恢复,恢复的过程就是把记录的指令再顺序执行一次,这样就可以恢复到宕机之前的状态。

    这儿存在一个问题,假如内存缓存中的redis指令还没有来得及刷写到AOF文件中就宕机了,那么这部分未刷写的指令就会丢失,不过,glibc函数库提供了 fsync() 函数,该函数可以将指定文件的内容强制从内存缓存中刷写到磁盘上。fsync操作的周期对redis的性能有很大影响,如何配置将在本文后续的内容中给出建议。AOF过程如下图:

    redis在长期运行过程中,AOF日志会越来越大,如果redis服务重启后根据很大的AOF文件来顺序执行指令,将会非常耗时,导致redis服务长时间无法对外提供服务,所以需要对AOF文件进行"瘦身""瘦身"的过程称作AOF重写(rewrite)。

    AOF Rewrite 的原理是,主进程fork一个子进程,对当前内存中的数据进行遍历,转换成一系列的redis操作指令,并序列化到一个新的AOF日志中,然后把序列化操作期间新收到的操作指令追加到新的AOF文件中,追加完毕后就立即替换旧的AOF文件,这样就完成了"瘦身"工作,即AOF Rewrite。AOF Rewrite过程如下图:

    #1、AOF持久策略:fsync的策略,默认为everysec
    appendfsync everysec
    # everysec:每秒fsync一次,如果Redis宕机,1秒内的指令丢失。
    # no:redis不主动fsync,完全交由操作系统决定
    # always:1条指令fsync一次,保证数据一条不丢失

     

    (3)混合持久化

    redis-4.x后支持了RDB和AOF混合使用。重启redis时,我们很少使用RDB来恢复内存状态,因为会丢失大量数据。我们通常使用AOF日志重放,但是重放AOF日志性能相对RDB来说要慢很多,这样在redis实例很大的情况下,启动需要花费很长的时间。redis-4.0为了解决这个问题,带来了一个新的持久化选项——混合持久化。将RDB文件的内容和增量的AOF日志文件存在一起,这里的AOF日志不再是全量 的日志,而是RDB久化开始 到 RDB持久化结束的这段时间发生的增量AOF日志,通常这部分AOF日志很小。redis-4.x混合持久化机制如下图:

    3.redis 持久化机制对比

    (1)RDB的优缺点

    优点:

    • RDB会生成多个数据文件,每个数据文件都代表了某一个时刻中redis的数据,这种多个数据文件的方式,非常适合做冷备,可以将这种完整的数据文件发送到一些远程的安全存储上去。

    • 生成RDB文件的时候,主进程不需要进行任何磁盘IO操作。当进行RDB持久化时,对redis服务处理读写请求的影响非常小,可以让redis保持高性能,因为redis主进程只需要fork一个子进程,让子进程执行磁盘IO操作来进行RDB持久化即可。生成一次RDB文件的过程就是把当前时刻内存中的数据一次性写入文件中,而AOF则需要先把当前内存中的小量数据转换为操作指令,然后把指令写到内存缓存中,然后再刷写入磁盘。

    • RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。AOF存放的是指令日志,做数据恢复的时候,要回放和执行所有的指令日志,从而恢复内存中的所有数据;而RDB,就是一份数据文件,恢复的时候,直接加载到内存中即可。

    缺点:

    • RDB方式数据没办法做到实时持久化/秒级持久化,会导致数据丢失。一般来说,RDB数据快照文件,都是每隔5分钟,或者更长时间生成一次,这个时候就得接受一旦redis进程宕机,那么会丢失最近5分钟的数据。这个问题,也是RDB最大的缺点,就是不适合做第一优先的恢复方案,如果你依赖RDB做第一优先恢复方案,会导致数据丢失的比较多。

    • RDB文件使用特定二进制格式保存,Redis版本演进过程中有多个格式的RDB版本,存在老版本Redis服务无法兼容新版RDB格式的问题(版本不兼容)。

    • RDB每次在fork子进程来执行RDB快照数据文件生成的时候,如果数据文件特别大,可能会导致对客户端提供的服务暂停数毫秒,甚至数秒。所以一般不要让生成RDB文件的间隔太长,否则每次生成的RDB文件太大了,对redis本身的性能会有影响。

    (2)AOF的优缺点

    优点:

    • AOF可以更好的保护数据不丢失,一般AOF会每隔1秒,通过一个后台线程执行一次fsync操作,最多丢失1秒钟的数据。

    • AOF日志文件以append-only模式(追加)写入,所以没有任何磁盘寻址的开销,写入性能非常高,而且文件不容易破损,即使文件尾部破损,也很容易修复。

    • AOF日志文件即使过大的时候,出现后台重写操作,也不会影响客户端的读写。因为在rewrite的时候,会对其中的指令进行压缩,会创建出一份需要恢复数据的最小日志出来。

    • AOF日志文件的命令通过非常可读的方式进行记录,这个特性非常适合做灾难性的误删除的紧急恢复。比如某人不小心用flushall命令清空了所有数据,只要这个时候后台rewrite还没有发生,那么就可以立即拷贝AOF文件,将最后一条flushall命令给删了,然后再将该AOF文件放回去,就可以通过恢复机制,自动恢复所有数据。

    缺点:

    • 对于同一份数据来说,AOF日志文件通常比RDB数据快照文件更大。因为AOF是指令文件,RDB是二进制文件。

    • AOF的写性能比RDB的写性能低,因为AOF一般会配置成每秒fsync一次日志文件,当然,每秒一次fsync,性能也还是很高的,只不过比起RDB来说性能低,如果要保证一条数据都不丢,也是可以的,AOF的fsync设置成每写入一条数据,fsync一次,但是这样,redis的性能会大大下降。

    • 基于AOF文件做恢复的速度不如基于RDB文件做恢复的速度。

    (3)混合持久化的优缺点

    • 优点:结合了RDB和AOF的优点,使得数据恢复的效率大幅提升

    • 缺点:兼容性不好,redis-4.x新增,虽然最终的文件也是.aof格式的文件,但在4.0之前版本都不识别该aof文件,同时由于前部分是RDB格式,阅读性较差。

    (4)如何选择redis持久化机制

    RDB和AOF到底该如何选择

    • 不要仅仅使用RDB,因为那样会导致丢失很多数据。

    • 也不要仅仅使用AOF,一是数据恢复慢,二是可靠性也不如RDB,毕竟RDB文件中存储的就是某一时刻实实在在的数据,而AOF只是操作指令,把数据转换为操作指令不一定是百分百没问题的。

    • 综合使用AOF和RDB两种持久化机制,用AOF来保证数据不丢失,作为数据恢复的第一选择; 用RDB来做不同程度的冷备,在AOF文件都丢失或损坏不可用的时候,还可以使用RDB来进行快速的数据恢复。

    (5)AOF和RDB同时工作

    • redis在写RDB文件的时候不会执行AOF rewrite;redis在执行AOF rewrite的时候不会生成新的RDB。

    • 如果redis正在生成新的RDB文件,此时用户执行bgrewriteaof命令手动重写AOF文件,那么等RDB快照生成之后,才会去执行AOF rewrite。

    • 同时有RDB文件和AOF日志文件,那么redis重启的时候,会优先使用AOF进行数据恢复,因为其中的日志更完整。

    4.redis 持久化机制的配置

    ######################### 通用 #########################
    
    # 持久化文件(包括RDB文件和AOF文件)的存储目录,默认.
    dir dir /home/hadoop/data/redis/6379
    
    ######################### RDB #########################
    
    # RDB文件的文件名称,默认dump.rdb
    dbfilename dump.rdb
    
    # 生成RDB文件的策略,默认为以下3种,意思是:
    # 每隔60s(1min),如果有超过10000个key发生了变化,就写一份新的RDB文件
    # 每隔300s(5min),如果有超过10个key发生了变化,就写一份新的RDB文件
    # 每隔900s(15min),如果有超过1个key发生了变化,就写一份新的RDB文件
    # 配置多种策略可以同时生效,无论满足哪一种条件都会写一份新的RDB文件
    save 900 1
    save 300 10
    save 60 10000
    
    # 是否开启RDB文件压缩,该功能可以节约磁盘空间,默认为yes
    rdbcompression yes
    
    # 在写入文件和读取文件时是否开启rdb文件检查,检查是否有无损坏
    # 如果在启动时检查发现文件损坏,则停止启动,默认yes
    rdbchecksum yes
    
    ######################### AOF #########################
    
    # 是否开启AOF机制,默认为no
    appendonly yes
    
    # AOF文件的名称,默认为appendonly.aof
    appendfilename "appendonly.aof"
    
    # fsync的策略,默认为everysec
    # everysec:每秒fsync一次
    # no:redis不主动fsync,完全交由操作系统决定
    # always:1条指令fsync一次
    appendfsync everysec
    
    # AOF文件rewrite策略
    # 当上一次重写后的AOF文件的增长比例达到100%
    # 比如上一次重写AOF文件后,新文件大小为128M
    # 当新文件再次增长了100%,达到了256M
    # 并且增长了100%后的文件的大小大于64M,那么开始重写AOF文件
    auto-aof-rewrite-percentage 100
    auto-aof-rewrite-min-size 64mb
    
    # 是否加载破损的AOF文件,默认为yes,如果设置为no
    # 那么redis启动时如果发现AOF文件破损,就会报错并且拒绝启动redis服务。
    aof-load-truncated yes
    
    ######################### 混合持久化 #########################
    
    # 是否开启混合持久化机制,默认为no
    aof-use-rdb-preamble no

    5.其他相关命令

    • 手动生成新的RDB文件
    # 阻塞主进程,直到生成新的RDB文件
    save 
    # 异步生成RDB文件,fork子进程去生成新的RDB文件,主进程不阻塞
    bgsave
    • 手动重写AOF文件
    bgrewriteaof
    • 停止redis服务
    # 安全停止redis服务,在停止之前会生成一份新的RDB文件
    redis-cli SHUTDOWN
    # 不安全,会造成数据丢失
    kill -9 redis_pid
    • 检查持久化文件
    # 检查AOF文件
    redis-check-aof /your/path/appendonly.aof
    # 检查RDB文件
    redis-check-rdb /your/path/dump.rdb
    • 修复AOF文件
    #如果redis在append数据到AOF文件时,机器宕机了,可能会导致AOF文件破损,使用以下命令修复AOF文件
    $REDIS_HOME/bin/redis-check-aof --fix
    • 查看持久化信息
    # 查看持久化信息
    info Persistence
    # 查看状态信息
    info stats

                                                           

                                                                                                                               202年06月06日 晚 于北京记

     

    展开全文
  • Redis持久化机制

    2022-03-29 08:56:37
    Redis持久化机制
  • Redis在我们日常开发中是必不可少的,但是有可能会造成数据的丢失,因此就有了持久化机制,而 Redis持久化机制也是面试中的高频问题,决定整理一下;如有错误还请个位指正!
  • Redis持久化机制

    千次阅读 2020-09-28 14:21:09
    Redis提供两种持久化机制,一种RDB持久化(默认) 另一种是AOF(append only file)持久化。 RDB是什么? 原理是redis会单独创建(fork)一个与当前进程一模一样的子进程来进行持久化,这个子进程的所有数据...
  • Redis数据持久化配置

    2021-12-01 10:47:11
    注:默认情况下,持久化配置是关闭的 #持久化开关配置(yes开启no关闭) appendonly no #持久化类型 #always:每次操作都会立即写入aof文件中(性能最低,不推荐) #everysec:每秒持久化一次(默认配置)(折中方案,...
  • Redis 数据持久化机制 RDB 和 AOF介绍

    千次阅读 多人点赞 2022-03-06 21:01:41
    Redis数据持久化 , 异步删除, 集群之间数据同步是由其他线程完成的 Redis快的原因 避免了维护多线程共享数据安全的开销 基于内存操作 ``高效的数据结构 跳表 和 哈希表 采用多路IO复用,能在网络IO...
  • Redis_持久化机制

    2022-03-24 20:41:57
    Redis持久化机制 概述: redis是一个内存数据库,当redis服务器重启,数据会丢失,所以我们可以将redis内存中的数据持久化保存到硬盘的文件中。 一般都是两种结合使用; 持久化的两种机制: RDB:默认方式,在...
  • 1. Redis使用的持久化机制(存储数据的方式) (1)RDB 1) RDB:是redis的默认持久化机制。 RDB相当于照快照,保存的是一种状态。如果你有几十G数据 ,它能把它压缩为 几KB的快照 2)快照是默认的持久化方式,这种方式...
  • Redis提供两种持久化机制 RDB 和 AOF 机制: 1、RDBRedis DataBase)持久化方式: 是指用数据集快照的方式半持久化模式)记录 redis 数据库的所有键值对,在某个时间点将数据写入一个临时文件, 持久化结束后,用这个...
  • #详解 redis持久化机制 1.什么是持久化? 持久化就是把 数据从内存中保存到磁盘上,这就是持久化机制。 是redis本身就有的,不需要配置或者其他操作。 reids默认的持久化机制 redis默认的持久化机制是RDB...
  • 详细介绍了Redis持久化机制,包括RDB与AOF持久化,以及混合持久化。
  • 关于redis中的持久化机制

    千次阅读 2020-07-17 20:33:45
    2.redis 中默认支持持久化机制; a.快照持久化:生成某个时刻的redis server 中的数据 快照 xxx.rdb格式 ,redis宕机之后,可以读取xxx.rdb格式的文件恢复数据。 创建快照的几种方式: 1.手动快照: 客户端执行...
  • 1、RDB、AOF(Redis官网中关于持久化的解释) Redis persistence | Redis How Redis writes data to disk (append-only files, snapshots, etc.) Persistence refers to the writing of data to durable storage...
  • Redis持久化机制-浅入

    2021-01-07 12:00:00
    Redis持久化就是将数据存入磁盘,以保证数据redis在崩溃时减小对数据的影响,redis提供两种持久化方式。 1.快照(snapshotting)方式RDB,RDB是redis默认的持久化方式,可以再redis.conf中配置其存储频度,如图: ...
  • Redis 数据持久化方案

    千次阅读 2020-11-04 10:36:47
    对于 Redis 持久化来说,其实就是将存储在内存中的数据写入到磁盘里,只不过写入的方式是有一定策略的。 那么我们先来看下第一种持久化,首先出场的是 RDB。 1、什么是RDB持久化 英文名称是 Redis DataBase,它还有...
  • Redis支持RDB与AOF两种持久化机制,持久化可以避免因进程异常退出或down机导致的数据丢失问题,在下次重启时能利用之前的持久化文件实现数据恢复。 RDB持久化 RDB持久化即通过创建快照(压缩的二进制文件)的方式...
  • Redis持久化面试题

    2021-11-16 18:28:52
    Redis持久化面试题1.redis中有哪些持久化方式?2.RDB的工作原理3.RDB触发机制4.RDB...​ RDB持久化方式会创建(fork)一个子进程,子进程中的数据信息和主进程中的数据信息完全相同,主进程进行客户端的数据交互,子进.
  • 在说redis持久化的时候,我们先来聊聊其他的知识。linux的父子进程。在Linux中使用fork()函数会给当前正在运行的进程创建一个子进程。那么现在问题就来了,fork时父子进程中的数据有什么关系呢?一般说到进程我们...
  • 你必须得用 redis持久化机制,将数据写入内存的同时,异步的慢慢的将数据写入磁盘文件里,进行持久化。 如果 redis 宕机重启,自动从磁盘上加载之前持久化的一些数据就可以了,也许会丢失少许数据,但是至少不会...
  • RDB方式的持久化redis内存直接把snapshot保存到文件系统。将整个内存数据存放到dump.rdb file 中。配置如下: [allen@localhost src]$ cd redis-5.0.3 [allen@localhost redis-5.0.3]$ vi redis.conf 配置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,008
精华内容 33,603
关键字:

redis数据持久化机制