精华内容
下载资源
问答
  • 公司内部自建k8s集群有一台节点挂了导致部分容器异常,redis未作数据持久化导致数据丢失,经查看原因为redis容器未作数据持久化,现对redis进行数据持久化以及安装redis-dump、redis-load导出原redis已有数据。...

    一、背景

    公司内部自建k8s集群有一台节点挂了导致部分容器异常,redis未作数据持久化导致数据丢失,经查看原因为redis容器未作数据持久化,现对redis进行数据持久化以及安装redis-dump、redis-load导出原redis已有数据。

    二、步骤

    1.拉取redis容器。
    docker pull redis
    docker tag redis:latest 10.0.16.250/fuliao-library/redis:latest
    docker push 10.0.16.250/fuliao-library/redis:latest
    
    2.编写k8s yaml配置。
    ####configmap.yaml
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: redis-conf-new
      namespace: k8s-gold-gourd-test-01
    data:
      redis.conf: |+
        requirepass ytflredis
        protected-mode no
        port 6379
        tcp-backlog 511
        timeout 0
        tcp-keepalive 300
        daemonize no
        supervised no
        pidfile /var/run/redis_6379.pid
        loglevel notice
        logfile ""
        databases 16
        always-show-logo yes
        save 900 1
        save 300 10
        save 60 10000
        stop-writes-on-bgsave-error yes
        rdbcompression yes
        rdbchecksum yes
        dbfilename dump.rdb
        dir /data
        slave-serve-stale-data yes
        slave-read-only yes
        repl-diskless-sync no
        repl-diskless-sync-delay 5
        repl-disable-tcp-nodelay no
        slave-priority 100
        lazyfree-lazy-eviction no
        lazyfree-lazy-expire no
        lazyfree-lazy-server-del no
        slave-lazy-flush no
        appendonly yes
        appendfilename "appendonly.aof"
        appendfsync everysec
        no-appendfsync-on-rewrite no
        auto-aof-rewrite-percentage 100
        auto-aof-rewrite-min-size 64mb
        aof-load-truncated yes
        aof-use-rdb-preamble no
        lua-time-limit 5000
        slowlog-log-slower-than 10000
        slowlog-max-len 128
        latency-monitor-threshold 0
        notify-keyspace-events Ex
        hash-max-ziplist-entries 512
        hash-max-ziplist-value 64
        list-max-ziplist-size -2
        list-compress-depth 0
        set-max-intset-entries 512
        zset-max-ziplist-entries 128
        zset-max-ziplist-value 64
        hll-sparse-max-bytes 3000
        activerehashing yes
        client-output-buffer-limit normal 0 0 0
        client-output-buffer-limit slave 256mb 64mb 60
        client-output-buffer-limit pubsub 32mb 8mb 60
        hz 10
        aof-rewrite-incremental-fsync yes
    
    ####redis-pv-pvc.yaml
    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: redis-pv
      namespace: k8s-gold-gourd-test-01
    spec:
      capacity:
        storage: 10Gi
      accessModes:
      - ReadWriteOnce
      persistentVolumeReclaimPolicy: Retain
      storageClassName: redis-nfs
      nfs:
        path: /k8s-data/test01-redis-data
        server: 10.0.16.167
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: redis-pvc
      namespace: k8s-gold-gourd-test-01
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi
      storageClassName: redis-nfs
    
    ####redis-svc.yaml
    apiVersion: v1
    kind: Service
    metadata:
      name: redis-svc
      namespace: k8s-gold-gourd-test-01
    spec:
      selector:
        name: redis
      ports:
      - protocol: TCP
        port: 6379
        targetPort: 6379
    
    ####deployment.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: redis
      namespace: k8s-gold-gourd-test-01
      labels:
        name: redis
    spec:
      strategy:
        type: Recreate
      selector:
        matchLabels:
          name: redis
      template:
        metadata:
          labels:
            name: redis
          annotations:
            version/date: "20210310"
            version/author: "lc"
        spec:
          containers:
          - name: redis
            image: 10.0.16.250/fuliao-library/redis:latest
            imagePullPolicy: IfNotPresent
            command: ["redis-server","/etc/redis/redis.conf"]
            ports:
            - containerPort: 6379
            volumeMounts:
            - name: redis-config
              mountPath: /etc/redis/redis.conf
              subPath: redis.conf
            - name: redis-persistent-storage
              mountPath: /data
          volumes:
          - name: redis-config
            configMap:
              name: redis-conf-new
              items:
              - key: redis.conf
                path: redis.conf
          - name: redis-persistent-storage
            persistentVolumeClaim:
              claimName: redis-pvc
    
    3.创建容器
    kubectl create -f configmap.yaml  deployment.yaml  redis-pv-pvc.yaml  redis-svc.yaml
    
    4.查看容器状态以及进入容器添加测试数据查看对应宿主机目录是否有文件生成。
    5.下载redis-dump和redis-load。
    yum -y install curl
    
    gpg2 --keyserver hkp://keys.gnupg.net --recv-keys D39DC0E3  
    curl -L get.rvm.io | bash -s stable   
    source /usr/local/rvm/scripts/rvm
    rvm list known
    rvm install 2.3.3
    rvm use 2.3.3
    rvm use 2.3.3 --default
    ruby --version
    
    yum install ruby rubygems ruby-devel -y
    gem install redis-dump -V
    gem install redis-dump -V
    
    redis-dump -u 10.244.1.156:6379 -a ytflredis > redis-data.json
    < redis-data.json redis-load -u 10.244.2.241:6379 -a ytflredis
    

    三、问题总结

    1.gem install redis-dump -V,报错redis requires Ruby version >= 2.3.0.需要安装ruby2.3.0版本
    具体可以查看上面第5步
    2.使用rvm 2.1.3 --default设置默认的ruby的命令时出现RVM is not a function, selecting rubies with ‘rvm use …’ will not work.
    先执行source /usr/local/rvm/scripts/rvm,并且将 /usr/local/rvm/bin添加到/etc/profile PATH中,使用./rvm 也会有问题。
    展开全文
  • 参考配置并且分享给各位,废话不多说,直接配置吧-------------------------------------------------分割线-----------------------------------------------------根据官网介绍,Redis持久化,...

    配置Redis持久化,我也是从官网地址:https://redis.io/topics/persistence 参考配置并且分享给各位,废话不多说,直接配置吧

    -------------------------------------------------分割线-----------------------------------------------------

    根据官网介绍,Redis持久化,有两种形式,一种是RDB,另外一种是AOF,默认情况下RDB持久化是开启的,那我们分别来介绍两种持久化的差异跟优缺点吧

    RDB持久化

    什么是RDB?

    持久性以指定的时间间隔执行数据集的时间点快照

    RDB的优点

    因为是定时备份,可以设置24小时内,RDB文件归档一次,保存30天,这样出现问题,你可以随意恢复当时的数据

    因为是定时备份,所以主线程不需要去做持久化的操作,子线程做备份操作就行

    RDB数据量比AOF更小,所以能更快速的启动

    RDB的缺点

    如果Redis突然停机,可能会导致某个时间点最新的的数据丢失

    为了使用子进程在磁盘上保留RDB,RDB需要经常fork()。如果数据集很大,Fork()会很费时,并且可能导致Redis在几毫秒内停止服务,或者如果数据集非常大并且CPU性能不佳,甚至会持续一秒。

    介绍过,RDB后,我们来说说RDB的具体操作吧

    默认情况下,RDB是开启的,可以查看redis.conf文件,可以看到如下内容

    76d299c7763419b2b20211bb70c91d75.png

    上述: save v1 v2, v2个key有变化,则v1秒候持久化一次

    然后我们可以看到 redis目录下会有一个dump.rdb文件,那就是RDB持久化后的文件

    a95da7f5ee88667c0a9f338d99fd8085.png

    如果我们kill掉redis进程,然后重启,可能会丢失最新写入的数据,重启候,会自动把dump.rdb的文件读入Redis当中

    定时持久化的策略可以自己设定, save 60 100 表示,如果有100个key有变化,则60秒后进行持久化

    需要注意一点的是,如果长时间没有进行RDB持久化的话,当你触发了修改多少个key后,多少时间候进行持久化,不会等多少时间,而是会马上持久化一次,除非,在上一次持久化的时间间隔内,有这么多key修改过,才会进行间隔时间持久化,篇幅有限,读者可以自己测试

    AOF持久化

    什么是AOF?

    持久性会记录服务器接收到的每个写入操作,这些操作将在服务器启动时再次写入,重建原始数据集

    AOF的优点

    AOF数据更全面,因为是追加每次写入操作,就算服务突然停止,也只会丢1S的数据

    当Redis数据很大的时候,AOF能够自动重写到一个新的文件内

    RDB的缺点

    AOF文件通常比相同数据集的等效RDB文件大

    AOF启动恢复数据,会比RDB慢。

    介绍过,AOF后,我们来说说AOF的具体操作吧

    默认情况下,AOF是不开启的,所以,需要我们手动开启

    71e07f08759d075720e9863a9929b8c7.png                              将 appendonly no 改成 appendonly yes

    然后重启redis,添加k v,在redis根目录下 就会发现 appendonly.aof 文件,就算添加了key,杀掉进程,也能恢复最新的数据

    如果我们只想要RDB的持久化,那么修改redis.conf文件的appenonly 为no就可以了

    如果我们只想要AOF的持久化,那么修改redis.conf文件的 save 后面变为空就可以了

    如果我们是要切换持久化方式,以前是RDB,想切换成AOF方式,那么我们需要这么做

    备份最新的dump.rdb文件,转移到安全的地方

    进入 redis-cli 执行如下命令

    config set appendonly yes

    config set save ""

    这样,我们就可以完成,在不重启的情况下,完成RDB->AOF持久化方式的切换

    如果我们一开始持久化的方式是AOF,要切换成RDB,我们这么操作

    进入 redis-cli 执行如下命令

    config set appendonly no

    config set save second chang

    等RDB持久化后,在 redis-cli 执行

    config set appendonly no

    这样,我们就可以完成,在不重启的情况下,完成AOF->RDB持久化的方式

    下篇我们介绍 Redis(五)Redis主从自动切换

    到这,文章就结束了!

    以上,均为本人测试而得出的结果,可能会有出入,或者错误,欢迎指正

    欢迎转载,请注明出处跟作者,谢谢!

    展开全文
  • Redis 数据持久化

    2021-11-09 17:10:16
    一,Redis 数据持久化背景。 Redis是一种内存数据库,在断电时数据可能会丢失。如果通过持久化将数据搞一份儿到磁盘上去, 然后再定期同步到一些云存储服务上去,那么就可以保证一些数据不丢失。 ==================...

    一,Redis 数据持久化背景。
    Redis是一种内存数据库,在断电时数据可能会丢失。如果通过持久化将数据搞一份儿到磁盘上去,
    然后再定期同步到一些云存储服务上去,那么就可以保证一些数据不丢失。
    =========================================================================
    二,持久化方式。
    1.Rdb方式是通过手动或周期性方式保存redis的一种机制,
    Rdb方式一般为redis的默认数据持久化方式.系统启动时会自动开启这种方式的持久化机制。
    2.Aof方式是通过记录写操作日志的方式,记录redis数据的一种持久化机制,这个机制默认是关闭的。
    ----------------------
    手动方式有两种
    1.save
    2.bgsave
    两者之间的区别
    Save 命令执行一个同步保存操作,将当前 Redis 实例的所有数据快照以 RDB 文件的形式保存到硬盘。
    bgsave命令执行之后立即返回 OK ,然后 Redis fork 出一个新子进程,
    原来的 Redis 进程(父进程)继续处理客户端请求,而子进程则负责将数据保存到磁盘,然后退出。
    =========================================================================
    三,RDB持久化机制有哪些优缺点?
    优点:
    1.RDB会生成多个数据文件,每个数据文件都代表了某一个时刻中redis的数据,这种多个数据文件的方式,
    非常适合做冷备,可以将这种完整的数据文件发送到一些远程云服务上去。
    2.RDB对redis对外提供的读写服务,影响非常小,可以让redis保持高性能,
    因为redis主进程只需要fork一个子进程,让子进程执行磁盘IO操作来进行RDB持久化即可。
    3.相对于AOF持久化机制来说,直接基于RDB数据文件来重启和恢复redis进程,更加快速。
    -----------------------------------------------
    缺点:
    RDB持久化机制一般都是每隔5分钟或更长时间做一次快照,
    这个时候一旦redis进程宕机,那么会丢失最近几分钟的数据。
    =========================================================================

    四,如何选择redis的持久化方式?
    1.不要仅仅使用RDB,因为那样会导致你丢失很多数据。
    2.也不要仅仅使用AOF,因为AOF做冷备没有RDB做冷备进行数据恢复的速度快。
    3.综合使用AOF和RDB两种持久化机制,用AOF来保证数据不丢失,
    作为数据恢复的第一选择; 用RDB来做不同程度的冷备。
    =========================================================================

    展开全文
  • Redis数据持久化和缓存淘汰机制 1、Redis持久化 持久化就是把内存的数据写到磁盘中去,防止服务宕机了内存数据丢失。持久化的话是Redis高可用中比较重要的一个环节,因为Redis数据在内存的特性,持久化必须得有。...

    Redis数据持久化和缓存淘汰机制

    在这里插入图片描述

    1、Redis持久化

    • 持久化就是把内存的数据写到磁盘中去,防止服务宕机了内存数据丢失。持久化的话是Redis高可用中比较重要的一个环节,因为Redis数据在内存的特性,持久化必须得有。

    • Redis 提供 RDB 和 AOF 两种持久化机制,RDB是Redis默认的持久化方式

    1.1、RDB原理

    • RDB持久化产生的RDB文件是一个经过压缩的二进制文件,这个文件被保存在硬盘中,redis可以通过这个文件还原数据库当时的状态。

    • RDB文件可以通过两个命令来生成:

      • SAVE:阻塞redis的服务器进程,直到RDB文件被创建完毕。
      • BGSAVE:派生(fork)一个子进程来创建新的RDB文件,记录接收到BGSAVE当时的数据库状态,父进程继续处理接收到的命令,子进程完成文件的创建之后,会发送信号给父进程,而与此同时,父进程处理命令的同时,通过轮询来接收子进程的信号。
    • RDB 是把内存中的数据集以快照形式写入磁盘,实际操作是通过 fork 子进程执行,采用二进制压缩存储;使用 fork 的目的最终一定是为了不阻塞主进程来提升 Redis 服务的可用性

    快照实现过程

    • Redis使用fork函数复制一份当前进程(父进程)的副本(子进程);
    • 父进程继续接收并处理客户端发来的命令,而子进程开始将内存中的数据写入硬盘中的临时文件;
    • 当子进程写入完所有数据后会用该临时文件替换旧的RDB文件,至此一次快照操作完成。
    • **在执行fork的时候操作系统(类Unix操作系统)会使用写时复制(copy-on-write)策略,即fork函数发生的一刻父子进程共享同一内存数据,当父进程要更改其中某片数据时(如执行一个写命令 ),操作系统会将该片数据复制一份以保证子进程的数据不受影响,**所以新的RDB文件存储的是执行fork一刻的内存数据。

    1.2、AOF原理

    • AOF持久化是备份数据库接收到的命令所有被写入AOF的命令都是以redis的协议格式来保存的。

    • AOF 是以文本日志的形式记录 Redis处理的每一个写入或删除操作。在AOF持久化的文件中,数据库会记录下所有变更数据库状态的命令,除了指定数据库的select命令,其他的命令都是来自client的,这些命令会以追加(append)的形式保存到文件中。

    • redis可以在AOF文件体积变得过大时,自动在后台重写AOF,重写后的新AOF文件包含了恢复当前数据集所需的最小命令集合,整个重写操作是绝对安全的,

    • 因为redis在创建新AOF文件的过程中,会继续将命令追加到现有的AOF文件里面,即使重写过程中停机,现有的AOF文件也不会丢失。而一旦新AOF文件创建完毕,redis就会从旧AOF文件切换到新AOF文件,并开始对新AOF文件进行追加操作。

    1.3、小结

    • RDB 是把内存中的数据集以**快照形式写入磁盘,实际操作是通过 fork 子进程执行,采用二进制压缩存储;AOF 是以文本日志的形式**记录 Redis 处理的每一个写入或删除操作。

    • RDB 把整个 Redis 的数据保存在单一文件中,比较适合用来做灾备,但缺点是快照保存完成之前如果宕机,这段时间的数据将会丢失,另外保存快照时可能导致服务短时间不可用。

    • AOF对日志文件的写入操作使用的追加模式,有灵活的同步策略,支持每秒同步、每次修改同步和不同步,缺点就是相同规模的数据集,AOF 要大于 RDB,AOF 在运行效率上往往会慢于 RDB。

    • Redis本身的机制是 AOF持久化开启且存在AOF文件时,优先加载AOF文件; 因为AOF的数据是比RDB更完整的

    2、Redis缓存淘汰机制

    2.1、key过期策略

    • Redis key的过期时间和永久有效分别EXPIREPERSIST命令进行设置

    • Redis的过期策略,是有定期过期和惰性过期两种

      • 定期过期:每隔一定的时间,会随机扫描一定数量的数据库的expires字典中一定数量的key,并清除其中已过期的key。默认100ms就随机抽一些设置了过期时间的key,去检查是否过期,过期了就删了。

      • 惰性过期只有当访问一个key时,才会判断该key是否已过期,过期则清除。

    但是仅仅通过设置过期时间还是有问题的。如果定期删除漏掉了很多过期 key,然后你也没及时去查,也就没走惰性删除,此时会怎么样?如果大量过期 key 堆积在内存里,导致 Redis 内存块耗尽了。怎么解决这个问题呢? Redis 内存淘汰策略

    2.2、内存淘汰策略

    Redis的内存淘汰策略是指在Redis的用于缓存的内存不足时,怎么处理需要新写入且需要申请额外空间的数据。

    • noeviction:当内存不足以容纳新写入数据时,新写入操作会报错。

    • allkeys-lru:当内存不足以容纳新写入数据时,在键空间中,移除最近最少使用的key。(这个是最常用的)

    • allkeys-random:当内存不足以容纳新写入数据时,在键空间中,随机移除某个key。

      设置过期时间的键空间选择性移除
    • volatile-lru:当内存不足以容纳新写入数据时,在设置了过期时间的键空间中,移除最近最少使用的key。

    • volatile-random:当内存不足以容纳新写入数据时,在设置了过期时间的键空间中,随机移除某个key。

    • volatile-ttl:当内存不足以容纳新写入数据时,在设置了过期时间的键空间中,有更早过期时间的key优先移除。

    Redis的内存淘汰策略的选取并不会影响过期的key的处理。

    内存淘汰策略用于处理内存不足时的需要申请额外空间的数据;过期策略用于处理过期的缓存数据。

    3、常见缓存淘汰算法

    FIFO(先入先出)

    • FIFO (First In FIrst Out) 是最简单的算法,原理跟名字一样,“如果一个数据最先进入缓存中,则应该最早淘汰掉”
    • 把缓存中的数据看成一个队列,最先加入的数据位于队列的头部,最后加入位于队列的尾部。当缓存空间不足需要执行缓存淘汰操作时,从队列的头部开始淘汰。

    LRU(最近最少被使用)

    • LRU (Least Recently Used) 的核心思想是基于**“如果数据最近被访问过,它在未来也极有可能访问过”**。
    • 同样把缓存看成一个队列,访问一个数据时,如果缓存中不存在,则插入到队列尾部;如果缓存中存在,则把该数据移动到队列尾部。当执行淘汰操作时,同样从队列的头部开始淘汰。
    • Java 中可以直接使用 LinkedHashMap 来实现

    LFU(最不经常使用)

    • LFU (Least Frequently Used)的核心思想是**“如果一个数据在最近一段时间内使用次数很少,那么在将来一段时间内被使用的可能性也很小”**,会记录数据访问的次数,当需要进行淘汰操作时,淘汰掉访问次数最少的数据。
    • 如果一开始 1 被连续访问了两次,接下来 2 被访问一次,3 被访问一次,按照访问次数排序,访问次数少的处于队列头部。当 4 加入时,执行缓存淘汰,2 位于队列头部被淘汰。

    4、手写LRU

    手写LRU是leetcode原题,同时也是我面试腾讯的一面面试真题,请务必会写!!!

    4.1、题目描述

    运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作: 获取数据 get 和 写入数据 put 。

    • 获取数据 get(key) - 如果关键字 (key) 存在于缓存中,则获取关键字的值(总是正数),否则返回 -1。
    • 写入数据 put(key, value) - 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字/值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。

    4.2 题解

    LeetCode原题地址

    LRU 缓存算法的核心数据结构就是哈希链表,双向链表和哈希表的结合体。

    HashLinkedList
    class LRUCache {
        // key -> Node(key, val)
        private HashMap<Integer, Node> map;
        // Node(k1, v1) <-> Node(k2, v2)...
        private DoubleList cache;
        // 最大容量
        private int cap;
        
        public LRUCache(int capacity) {
            this.cap = capacity;
            map = new HashMap<>();
            cache = new DoubleList();
        }
        
        public int get(int key) {
            if (!map.containsKey(key))
                return -1;
            int val = map.get(key).val;
            // 利用 put 方法把该数据提前
            put(key, val);
            return val;
        }
        
        public void put(int key, int val) {
            // 先把新节点 x 做出来
            Node x = new Node(key, val);
            
            if (map.containsKey(key)) {
                // 删除旧的节点,新的插到头部
                cache.remove(map.get(key));
                cache.addFirst(x);
                // 更新 map 中对应的数据
                map.put(key, x);
            } else {
                if (cap == cache.size()) {
                    // 删除链表最后一个数据
                    Node last = cache.removeLast();
                    map.remove(last.key);
                }
                // 直接添加到头部
                cache.addFirst(x);
                map.put(key, x);
            }
        }
    
        //定义双向链表节点类 为了简化,key 和 val 都认为是 int 类型
        class Node{
            private int key,value;
            private Node prev, next;
            public Node(int key,int value){
                this.key = key;
                this.value = value;
            }
        }
        // Node 类型构建一个双链表,实现几个需要的 API 这些操作的时间复杂度均为 O(1)
        class DoubleList {  
        	private Node head, tail; // 头尾虚节点
        	private int size; // 链表元素数
    
        	public DoubleList() {
            	head = new Node(0, 0);
            	tail = new Node(0, 0);
            	head.next = tail;
            	tail.prev = head;
            	size = 0;
        	}
    
        // 在链表头部添加节点 x
        	public void addFirst(Node x) {
            	x.next = head.next;
            	x.prev = head;
            	head.next.prev = x;
            	head.next = x;
            	size++;
        	}
    
        // 删除链表中的 x 节点(x 一定存在)
        	public void remove(Node x) {
            	x.prev.next = x.next;
            	x.next.prev = x.prev;
            	size--;
        	}
        
        // 删除链表中最后一个节点,并返回该节点
       		public Node removeLast() {
            	if (tail.prev == head)
                	return null;
            	Node last = tail.prev;
            	remove(last);
            	return last;
        	}
        
        // 返回链表长度
       	 	public int size() { return size; }
    	}
    
    }
    

    我是一名后端开发工程师,个人公众号:任冬学编程

    如果文章对你有帮助,不妨收藏,转发,在看起来~

    展开全文
  • redis数据持久化

    2021-07-06 19:58:13
    redis数据持久化RDB方式执行快照的场景AOF方式二者的区别二者优缺点RDB存在哪些优势呢?RDB又存在哪些劣势呢?AOF的优势有哪些呢?AOF的劣势有哪些呢?常用配置RDB持久化配置AOF持久化配置 Redis支持两种数据持久化...
  • Redis数据持久化

    2021-12-05 15:30:26
    redis数据持久化就是为了保障数据安全性问题。将内存数据存储到磁盘当中,即持久化问题。Redis提供了两种方式去保障数据的持久化问题。 RDB:内存快照 内存快照:就是指内存中数据在某一时刻的状态记录。 RDB是...
  • 在说redis持久化的时候,我们先来聊聊其他的知识。linux的父子进程。在Linux中使用fork()函数会给当前正在运行的进程创建一个子进程。那么现在问题就来了,fork时父子进程中的数据有什么关系呢?一般说到进程我们...
  • 原因:写数据redis里面写不进去,查看redis日志显示:Can't save in background: fork: Cannot allocate memory在小内存的进程上做一个fork,不需要太多资源,但当这个进程的内存空间以G为单位时,fork就成为一件...
  • redis数据持久化详解

    2021-08-27 16:03:04
    AOF持久化方式记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据,AOF命令以redis协议追加保存每次写的操作到文件末尾,redis还能对AOF文件进行后台重写,使得AOF文件的体积不至于...
  • 一.简单说明redis是非关系型数据库,是一种内存型数据库。数据存储在内存中,所以当我们关掉软件,或者拔掉电源时,内存中的数据就会丢失。针对此场景,这里提出持久化的...可以最大程度保证redis数据安全,类似于...
  • redis 非关系型数据库,C语言开发 在linux 上需要环境一,安装第一步:把安装包上传到linux 并解压第二步:在线安装c 环境命令--》 yum install gcc-c++第二步:进行编译 在解压后的包的路径下命令--》make第三步:...
  • 04-Redis 数据持久化实践

    千次阅读 多人点赞 2021-08-06 08:35:47
    简介 ...Redis中为了保证在系统宕机(类似进程被杀死)情况下,能更快的进行故障恢复,设计了两种数据持久化方案,分别为rdb和aof。 Rdb方式是通过手动(save-阻塞式,bgsave-异步)或周期性方式保存re
  • Redis实现数据持久化的两种实现方式:RDB:指定的时间间隔内保存数据快照AOF:先把命令追加到操作日志的尾部,保存所有的历史操作一、RDB实现Redis数据持久化(默认方式)1、编辑 redis.conf注:使用whereis redis命令...
  • Redis数据持久化实践

    2021-12-14 09:33:30
    第二步:停止redis并删除挂载目录下(/usr/local/docker/redis01/conf)的redis.conf配置文件. 第三步:将下载的redis.conf文件拷贝到redis挂载目录(/usr/local/docker/redis01/conf) 第四步:基于vim打开redis.conf文件,...
  • Redis 数据持久化、事务处理

    千次阅读 2021-12-14 09:31:16
    Redis 数据持久化 配置准备工作 1.从redis.io官方下载对应版本的redis.conf文件 https://redis.io/topics/config/ 2.停止redis并删除挂载目录下(/usr/local/docker/redis01/conf)的redis.conf配置文件. 3.将...
  • 1 配置Redis持久化 第一步,输入 cd /mydata/redis/conf命令,进入redis的配置文件所在目录。 第二步,输入vi redis.conf命令,进行编辑redis配置文件。 第三步,输入appendonly yes,按Esc键,输入:wq,...
  • 以非阻塞方式创建RDB文件通过配置选项自动创建RDB文件同时使用多个save选项默认设置SAVE命令和BGSAVE命令的选择数据丢失SAVE命令的停机情况BGSAVE命令的停机情况注意ROF的缺点AOF 持久化参考链接 概述 Redis与传统...
  • redis持久化
  • Redis相比Memcache有个最显著的区别就是支持数据持久化,可以将数据写入到硬盘中,而不仅仅是只能存放于内存,重启服务后数据就没了。Redis的持久化分为了rdb快照持久化和aof日志持久化两种方式: 1、RDB快照持久化...
  • Redis 数据持久化前言一、基于快照的持久化二、基于文件追加方式持久化总结 前言 本环境是基于 Centos 7.8 系统构建Redis学习环境 具体构建,请参考 Redis-5.0.9环境部署 为了本身数据的完整和安全性,虽然redis...
  • Redis 数据库的数据持久化进行介绍,对 RDB 和 AOF 方式和相关配置进行介绍
  • Redis数据持久化配置

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

    2021-01-30 07:16:07
    为了解决数据丢失问题,便需要将数据从内存保持到磁盘中,这就是redis数据持久化目前,redis实现了两种数据库持久化方案,一种是RDB,另一种是AOF,让我们来聊聊这两种方案RDBredis database,即将数据库的内容...
  • redis持久化有rdb和aof两种: rdb是记录一段时间内的操作,一般的配置是一段时间内操作超过多少次就持久化。 aof可以实现每次操作都持久化。 这里我们使用aof: 配置方式: 1. 打开redis的配置文件。找到...
  • 因为redis数据都保存在内存中,如果不进行及时的持久化,可能就会因为重启导致数据的丢失。这时候就需要对redis进行持久化操作,将数据保存在磁盘上。 redis提供了两种持久化方式,分别是AOF和RDB。下面分别对...
  • 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
收藏数 144,903
精华内容 57,961
关键字:

redis数据持久化

redis 订阅