精华内容
下载资源
问答
  • scrapy持久化存储

    千次阅读 2021-02-14 15:20:43
    1.基于终端指令的持久化存储 保证爬虫文件的parse方法中有可迭代类型对象(通常为列表or字典)的返回,该返回值可以通过终端指令的形式写入指定格式的文件中进行持久化操作。 执行输出指定格式进行存储:将爬取到的...

    1.基于终端指令的持久化存储

    保证爬虫文件的parse方法中有可迭代类型对象(通常为列表or字典)的返回,该返回值可以通过终端指令的形式写入指定格式的文件中进行持久化操作。

    执行输出指定格式进行存储:将爬取到的数据写入不同格式的文件中进行存储
        scrapy crawl 爬虫名称 -o xxx.json
        scrapy crawl 爬虫名称 -o xxx.xml
        scrapy crawl 爬虫名称 -o xxx.csv
    

    2.基于管道的持久化存储

    scrapy框架中已经为我们专门集成好了高效、便捷的持久化操作功能,我们直接使用即可。要想使用scrapy的持久化操作功能,我们首先来认识如下两个文件:

    items.py:数据结构模板文件。定义数据属性。
    pipelines.py:管道文件。接收数据(items),进行持久化操作。
    

    持久化流程:
    1.爬虫文件爬取到数据后,需要将数据封装到items对象中。
    2.使用yield关键字将items对象提交给pipelines管道进行持久化操作。
    3.在管道文件中的process_item方法中接收爬虫文件提交过来的item对象,然后编写持久化存储的代码将item对象中存储的数据进行持久化存储
    4.settings.py配置文件中开启管道

    小试牛刀:将糗事百科首页中的段子和作者数据爬取下来,然后进行持久化存储

    • 爬虫文件:qiubaiDemo.py
    # -*- coding: utf-8 -*-
    import scrapy
    from secondblood.items import SecondbloodItem
    
    class QiubaidemoSpider(scrapy.Spider):
        name = 'qiubaiDemo'
        allowed_domains = ['www.qiushibaike.com']
        start_urls = ['http://www.qiushibaike.com/']
    
        def parse(self, response):
            odiv = response.xpath('//div[@id="content-left"]/div')
            for div in odiv:
                # xpath函数返回的为列表,列表中存放的数据为Selector类型的数据。我们解析到的内容被封装在了Selector对象中,需要调用extract()函数将解析的内容从Selecor中取出。
                author = div.xpath('.//div[@class="author clearfix"]//h2/text()').extract_first()
                author = author.strip('\n')#过滤空行
                content = div.xpath('.//div[@class="content"]/span/text()').extract_first()
                content = content.strip('\n')#过滤空行
    
                #将解析到的数据封装至items对象中
                item = SecondbloodItem()
                item['author'] = author
                item['content'] = content
    
                yield item#提交item到管道文件(pipelines.py)
    
    • items文件:items.py
    import scrapy
    
    
    class SecondbloodItem(scrapy.Item):
        # define the fields for your item here like:
        # name = scrapy.Field()
        author = scrapy.Field() #存储作者
        content = scrapy.Field() #存储段子内容
    
    • 管道文件:pipelines.py
    # -*- coding: utf-8 -*-
    
    # Define your item pipelines here
    #
    # Don't forget to add your pipeline to the ITEM_PIPELINES setting
    # See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html
    
    
    class SecondbloodPipeline(object):
        #构造方法
        def __init__(self):
            self.fp = None  #定义一个文件描述符属性
      #下列都是在重写父类的方法:
        #开始爬虫时,执行一次
        def open_spider(self,spider):
            print('爬虫开始')
            self.fp = open('./data.txt', 'w')
    
       #因为该方法会被执行调用多次,所以文件的开启和关闭操作写在了另外两个只会各自执行一次的方法中。
        def process_item(self, item, spider):
            #将爬虫程序提交的item进行持久化存储
            self.fp.write(item['author'] + ':' + item['content'] + '\n')
            return item
    
        #结束爬虫时,执行一次
        def close_spider(self,spider):
            self.fp.close()
            print('爬虫结束')
    
    • 配置文件:settings.py
    #开启管道
    ITEM_PIPELINES = {
        'secondblood.pipelines.SecondbloodPipeline': 300, #300表示为优先级,值越小优先级越高
    }
    

    2.1 基于mysql的管道存储

    小试牛刀案例中,在管道文件里将item对象中的数据值存储到了磁盘中,如果将item数据写入mysql数据库的话,只需要将上述案例中的管道文件修改成如下形式:

    • pipelines.py文件
    # -*- coding: utf-8 -*-
    
    # Define your item pipelines here
    #
    # Don't forget to add your pipeline to the ITEM_PIPELINES setting
    # See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html
    
    #导入数据库的类
    import pymysql
    class QiubaiproPipelineByMysql(object):
    
        conn = None  #mysql的连接对象声明
        cursor = None#mysql游标对象声明
        def open_spider(self,spider):
            print('开始爬虫')
            #链接数据库
            self.conn = pymysql.Connect(host='127.0.0.1',port=3306,user='root',password='123456',db='qiubai')
        #编写向数据库中存储数据的相关代码
        def process_item(self, item, spider):
            #1.链接数据库
            #2.执行sql语句
            sql = 'insert into qiubai values("%s","%s")'%(item['author'],item['content'])
            self.cursor = self.conn.cursor()
            #执行事务
            try:
                self.cursor.execute(sql)
                self.conn.commit()
            except Exception as e:
                print(e)
                self.conn.rollback()
    
            return item
        def close_spider(self,spider):
            print('爬虫结束')
            self.cursor.close()
            self.conn.close()
    
    • settings.py
    ITEM_PIPELINES = {
        'qiubaiPro.pipelines.QiubaiproPipelineByMysql': 300,
    }
    

    2.2 基于redis的管道存储

    小试牛刀案例中,在管道文件里将item对象中的数据值存储到了磁盘中,如果将item数据写入redis数据库的话,只需要将上述案例中的管道文件修改成如下形式:

    # -*- coding: utf-8 -*-
    
    # Define your item pipelines here
    #
    # Don't forget to add your pipeline to the ITEM_PIPELINES setting
    # See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html
    
    import redis
    
    class QiubaiproPipelineByRedis(object):
        conn = None
        def open_spider(self,spider):
            print('开始爬虫')
            #创建链接对象
            self.conn = redis.Redis(host='127.0.0.1',port=6379)
        def process_item(self, item, spider):
            dict = {
                'author':item['author'],
                'content':item['content']
            }
            #写入redis中
            self.conn.lpush('data', dict)
            return item
    
    • settings.py
    ITEM_PIPELINES = {
        'qiubaiPro.pipelines.QiubaiproPipelineByRedis': 300,
    }
    
    • 面试题:如果最终需要将爬取到的数据值一份存储到磁盘文件,一份存储到数据库中,则应该如何操作scrapy?

    • 答:管道文件中的代码为

    #该类为管道类,该类中的process_item方法是用来实现持久化存储操作的。
    class DoublekillPipeline(object):
    
        def process_item(self, item, spider):
            #持久化操作代码 (方式1:写入磁盘文件)
            return item
    
    #如果想实现另一种形式的持久化操作,则可以再定制一个管道类:
    class DoublekillPipeline_db(object):
    
        def process_item(self, item, spider):
            #持久化操作代码 (方式1:写入数据库)
            return item
    

    在settings.py开启管道操作代码为:

    #下列结构为字典,字典中的键值表示的是即将被启用执行的管道文件和其执行的优先级。
    ITEM_PIPELINES = {
       'doublekill.pipelines.DoublekillPipeline': 300,
        'doublekill.pipelines.DoublekillPipeline_db': 200,
    }
    
    #上述代码中,字典中的两组键值分别表示会执行管道文件中对应的两个管道类中的process_item方法,实现两种不同形式的持久化操作。
    
    展开全文
  • 容器的持久化存储

    2020-06-17 21:22:02
    绑定宿主机的目录并非持久化存储



    在 k8s 中,并非绑定宿主机的目录即为存储持久化;


    存储插件会在容器里挂载一个基于网络或者其他机制的远程数据卷,
    使得在容器里创建的文件,实际上是保存在远程存储服务器上,或者以分布式的方式保存在多个节点上,
    而与当前宿主机没有任何绑定关系。

    这才是容器的持久化存储的含义。


    这样,
    无论你在其他哪个宿主机上启动新的容器,都可以请求挂载指定的持久化存储卷,从而访问到数据卷里保存的内容。


    Pod 通过 Persistent Volume(PV)和 Persistent Volume Claim(PVC)的方式,在容器里挂载数据卷。
    // PVC:描述的是 Pod 想要使用的持久化存储的属性,比如存储的大小,读写权限等
    // PV: 是一个具体的 Volume 属性,比如 Volume 的类型,挂载目录等( 由 StorageClass 充当 PV 的模板 )


    可以考虑的存储插件有:
    Ceph、
    GlusterFS、
    NFS 、
    Rook //基于Ceph,贯彻云原生思路( 即 Kubernetes 原生思路 )




    参考文档:张磊老师的 深入剖析Kubernetes

    展开全文
  • Kubernetes之持久化存储

    千次阅读 2018-09-14 18:26:47
    当pod被调度到某个节点上时,它们随pod的创建而创建,临时占用节点存储资源,当pod离开节点时,存储资源被交还给节点,pod一旦离开它们就失效,不具备持久化存储数据的能力。与此相反,持久化存储拥有独立的生命周期...

    ConfigMap、Secret、emptyDir、hostPath等属于临时性存储,当pod被调度到某个节点上时,它们随pod的创建而创建,临时占用节点存储资源,当pod离开节点时,存储资源被交还给节点,pod一旦离开它们就失效,不具备持久化存储数据的能力。与此相反,持久化存储拥有独立的生命周期,具备持久化存储能力,其后端一般是独立的存储系统如NFS、iSCSI、cephfs、glusterfs等。

    PV与PVC

    Kubernetes中的node代表计算资源,而PersistentVolume(PC)则代表存储资源,它是对各种诸如NFS、iSCSI、云存储等各种存储后端所提供存储块的统一抽象,通过它屏蔽低层实现细节。与普通volume不同,PC拥有完全独立的生命周期。

    因为PC表示的是集群能力,它是一种集群资源,所以用户不能直接使用PC,就像不能直接使用内存一样,需要先向系统申请。Kubernetes通过PersistentVolumeClaim(PVC)代理用户行为,用户通过对PVC的操作实现对PC申请、使用、释放等操作,PVC是用户层面的资源。

    静态PV与动态PV

    静态PV由系统管理员负责创建、提供、维护,系统管理员为用户屏蔽真正提供存储的后端及其实现细节,普通用户作为消费者,只需通过PVC申请、使用此类资源。

    当用户通过PVC申请PV时,如果系统无法从静态PV为用户分配资源,则尝试创建动态PV。前提条件是用户需要在PVC中给出“storage class”名称,指示系统创建动态PV的具体方式。“storage class”可以理解成某种具体的后端存储,它也是Kubernetes集群中的一种资源,当然在使用之前,需要先由集群管理员负责创建、配置。如果用户的PVC中“storage class”的值为"",则表示不能为此PVC动态创建PV。

    想要开启基于“storage class”的动态存储供应功能,需要为apiServer启用"DefaultStorageClass"入口控制器,具体方法为在apiServer选项--enable-admission-plugins中包含"DefaultStorageClass"字符串。

    PV与PVC绑定

    用户创建包含容量、访问模式等信息的PVC,向系统请求存储资源。系统查找已存在PV或者监控新创建PV,如果与PVC匹配则将两者绑定。如果PVC创建动态PV,则系统将一直将两者绑定。PV与PVC的绑定是一一对应关系,不能重复绑定与被绑定。如果系统一直没有为PVC找到匹配PV,则PVC无限期维持在"unbound"状态,直到系统找到匹配PV。实际绑定的PV容量可能大于PVC中申请的容量。

    在POD中使用PVC

    当系统为用户创建的PVC绑定PV后,表明用户成功申请了存储资源。用户在pod中定义PVC类型的volume,当创建POD实例时系统将与PVC绑定的PV挂载到POD实例。如果PV支持多种访问模式,用户需要pod的PVC volume中指定期望的类型。注意,pod与PVC必需位于相同namespace之下。

    存储对象使用中保护

    如果启用了存储对象使用中保护特性,则不允许将正在被pod使用的活动PVC或者绑定到PVC的PV从系统中移除,防止数据丢失。活动PVC指使用PVC的pod处于pending状态并且已经被指派节点或者处于running状态。

    如果已经启用存储对象使用中保护特性,且用户删除正在被pod使用的活动PVC,不会立即删除PVC,而是延后到其状态变成非活动。同样如果用户删除已经绑定的PV,则删除动作延后到PV解除绑定后。

    当PVC处于保护中时,其状态为"Terminating"并且其"Finalizers"包含"kubernetes.io/pvc-protection":

    kubectl describe pvc hostpath
    Name:          hostpath
    Namespace:     default
    StorageClass:  example-hostpath
    Status:        Terminating
    Volume:        
    Labels:        <none>
    Annotations:   volume.beta.kubernetes.io/storage-class=example-hostpath
                   volume.beta.kubernetes.io/storage-provisioner=example.com/hostpath
    Finalizers:    [kubernetes.io/pvc-protection]
    ...

     正处在保护中的PV,其状态为"Terminating"且"Finalizers"包含"kubernetes.io/pv-protection":

    kubectl describe pv task-pv-volume
    Name:            task-pv-volume
    Labels:          type=local
    Annotations:     <none>
    Finalizers:      [kubernetes.io/pv-protection]
    StorageClass:    standard
    Status:          Available
    Claim:           
    Reclaim Policy:  Delete
    Access Modes:    RWO
    Capacity:        1Gi
    Message:         
    Source:
        Type:          HostPath (bare host directory volume)
        Path:          /tmp/data
        HostPathType:  
    Events:            <none>

     Reclaiming

    用户删除PVC释放对PV的占用后,系统根据PV的"reclaim policy"决定对PV执行何种回收操作。 目前,"reclaim policy"有三种方式:Retained、Recycled、Deleted。

    Retained

    保护被PVC释放的PV及其上数据,并将PV状态改成"released",不将被其它PVC绑定。集群管理员手动通过如下步骤释放存储资源:

    1. 手动删除PV,但与其相关的后端存储资源如(AWS EBS, GCE PD, Azure Disk, or Cinder volume)仍然存在。
    2. 手动清空后端存储volume上的数据。
    3. 手动删除后端存储volume,或者重复使用后端volume,为其创建新的PV。

    Delete

    删除被PVC释放的PV及其后端存储volume。对于动态PV其"reclaim policy"继承自其"storage class",默认是Delete。集群管理员负责将"storage class"的"reclaim policy"设置成用户期望的形式,否则需要用户手动为创建后的动态PV编辑"reclaim policy"。

    Recycle 

    保留PV,但清空其上数据,已废弃

    RESIZING

    PVC

    FEATURE STATE: Kubernetes v1.8 alpha

    FEATURE STATE: Kubernetes v1.11 beta

    此特性默认启用。支持PVC扩容的的volume类型:

    • gcePersistentDisk
    • awsElasticBlockStore
    • Cinder
    • glusterfs
    • rbd
    • Azure File
    • Azure Disk
    • Portworx

    如果对PVC扩容,则其对应的"storage class"中allowVolumeExpansion字段需要设置成true:

    kind: StorageClass
    apiVersion: storage.k8s.io/v1
    metadata:
      name: gluster-vol-default
    provisioner: kubernetes.io/glusterfs
    parameters:
      resturl: "http://192.168.10.100:8080"
      restuser: ""
      secretNamespace: ""
      secretName: ""
    allowVolumeExpansion: true

    编辑PVC为其指定更大容量,自动触发与其绑定的PV的扩容,不是创建新的PV,而是在原有基础上resize。

    PV

    只能对包含XFS, Ext3, or Ext4文件系统的PV执行resize操作,并且resize操作不会立即生效,只有当新pod通过ReadWrite模式的PVC使用PV,真正的resize才会生效。所以当为云存储供应商提供的PV执行resize后,必需删除旧pod并创建新pod后,resize才会生效。查看PVC是否正在等待resize:

    kubectl describe pvc <pvc_name>

    当PVC的状态为"FileSystemResizePending"时,删除旧的pod并用PVC创建新pod是安全的,也就是不会丢失数据。

    PV类型

    Kubernetes通过插件支持各种PV类型,目前支持的插件有:

    • GCEPersistentDisk
    • AWSElasticBlockStore
    • AzureFile
    • AzureDisk
    • FC (Fibre Channel)
    • FlexVolume
    • Flocker
    • NFS
    • iSCSI
    • RBD (Ceph Block Device)
    • CephFS
    • Cinder (OpenStack block storage)
    • Glusterfs
    • VsphereVolume
    • Quobyte Volumes
    • HostPath (Single node testing only – local storage is not supported in any way and WILL NOT WORK in a multi-node cluster)
    • Portworx Volumes
    • ScaleIO Volumes
    • StorageOS

    PV对象

    PV对象与POD对象类似,包含spec与status两部分:

    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: pv0003
    spec:
      capacity:
        storage: 5Gi
      volumeMode: Filesystem
      accessModes:
        - ReadWriteOnce
      persistentVolumeReclaimPolicy: Recycle
      storageClassName: slow
      mountOptions:
        - hard
        - nfsvers=4.1
      nfs:
        path: /tmp
        server: 172.17.0.2

    Capacity

    .spec.capacity字段,目前只包含表示PV容量的storage字段,未来可能增加IOPS、throughput等。

    Volume Mode

    在1.9及之前的版本中,所有的volume插件都会在PV上创建文件系统(什么类型的文件系统?)。1.9以后的版本,此字段可以设置成"raw",则此时创建的PV为raw类型的存储块设备。如果此字段省略,默认为"Filesystem"。

    Access Modes

    不同存储后端支持的访问模式不同,同一种存储后端的不同PV也可以各自设置访问模式。如NFS支持多客端read/write,但其某一个具体PV的访问模式可能是read-only。每个PV的访问模式取决于其PV对象中accessModes字段设置。

    具体的访问模式有:

    • ReadWriteOnce – volume可以被单节点以read-write模式挂开。
    • ReadOnlyMany – volume可以被多节点以read-only模式挂载。
    • ReadWriteMany – volume可以被多个节点以read-write模式挂载。

    Volume可以同时支持多种访问模式,但是在具体挂载时只能使用一种,这一点需要在pod中定义PVC类型的volume时说明。命令行支持缩写:

    • RWO - ReadWriteOnce
    • ROX - ReadOnlyMany
    • RWX - ReadWriteMany

    不同存储后端对访问模式的支持:

    Volume Plugin ReadWriteOnce ReadOnlyMany ReadWriteMany
    AWSElasticBlockStore - -
    AzureFile
    AzureDisk - -
    CephFS
    Cinder - -
    FC -
    FlexVolume -
    Flocker - -
    GCEPersistentDisk -
    Glusterfs
    HostPath - -
    iSCSI -
    Quobyte
    NFS
    RBD -
    VsphereVolume - - (works when pods are collocated)
    PortworxVolume -
    ScaleIO -
    StorageOS - -

     Class

    "storageClassName"的值为某个"storage class"的名称,表示PV由那个具体的存储后端提供。特定"storage class"的PV只能被绑定给具有相同"storage class"的PVC。如果PV不包含"storage class",则这种类型的PV只能被绑定给同样不包含"storage class"的PVC。

    以前,使用注解"volume.beta.kubernetes.io/storage-class"存储"storage class"而非"storageClassName",目前前一种方式仍然可以工作,但在将来的Kubernetes版本中将会完全废弃。

    Reclaim Policy

    前文提到过,有三种:

    • Retain – manual reclamation
    • Recycle – basic scrub (rm -rf /thevolume/*)
    • Delete – associated storage asset such as AWS EBS, GCE PD, Azure Disk, or OpenStack Cinder volume is deleted

    目前只有NFS与hostPath支持Recycle, AWS EBS, GCE PD, Azure Disk, and Cinder支持Delete。

    Mount Options

    由集群管理员为PV指定的,当PV挂载到node的选项(动态PV如何指定?从storage class继承吗?)

    支持挂载选项的后端存储类型:

    • GCEPersistentDisk
    • AWSElasticBlockStore
    • AzureFile
    • AzureDisk
    • NFS
    • iSCSI
    • RBD (Ceph Block Device)
    • CephFS
    • Cinder (OpenStack block storage)
    • Glusterfs
    • VsphereVolume
    • Quobyte Volumes

    系统不验证挂载选项的可用性,如果设置错误,则仅仅返回挂载失败。
    以前,用注解volume.beta.kubernetes.io/mount-options表示挂载选项,目前仍然工作,但在将来版本中会被完全废弃。

    Phase

    PV可能的phase:

    • Available – 没有绑定的free资源。
    • Bound – 已经被PVC绑定。
    • Released – PVC被删除,但PV被保留,并且不可以被新PVC绑定。
    • Failed – reclaim policy执行失败。

    可以通过命令行查看绑定PV的PVC。

    PVC对象

    同样,一个PVC对象也包括spec与status两部分:

    kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: myclaim
    spec:
      accessModes:
        - ReadWriteOnce
      volumeMode: Filesystem
      resources:
        requests:
          storage: 8Gi
      storageClassName: slow
      selector:
        matchLabels:
          release: "stable"
        matchExpressions:
          - {key: environment, operator: In, values: [dev]}

     Access Modes

    与PV含义相同,应该是PV与PVC相匹配才可以绑定。

    Volume Modes

    与PV含义相同,应该是PV与PVC相匹配才可以绑定。

    Resources

    指明所请求PV的大小。

    Selector

    选择器PVC通过选择器进一步过滤可选PV,支持matchLabels与matchExpressions两种匹配表达式。

    Class

    含义与PV相同,只有此字段相同的PV与PVC可以相互绑定。但是如果PVC中完全没有出现此字段,结果取决于:
    DefaultStorageClass入口管理器是否被打开:

    如果此入口管理器被管理员打开并指定了默认的storage class,则为PVC指定此默认storage class,如果打开入口控制器但没有设置默认storage则与没有打开效果相同。如果有多个默认storage class,禁止所有PVC创建。

    如果没有打开此入口控制器,则PVC中完此字段与将此字段设置成""等效。

    参考:https://kubernetes.io/docs/concepts/storage/persistent-volumes/

    后续问题:如何在副本控制器中为每个pod实例指定PVC,持久化存储与StatefulSet什么关系?

     

    展开全文
  • redis持久化存储

    2017-09-18 11:10:04
    redis持久化存储支持两种方式:RDB和AOF。RDB一定时间取存储文件,AOF默认每秒去存储历史命令,官方建议两种方式同时使用 没有持久化的redis和memcache一样,相当于一个纯内存的数据库   一、RDB(Redis ...
    redis持久化存储支持两种方式:RDB和AOF。RDB一定时间取存储文件,AOF默认每秒去存储历史命令,官方建议两种方式同时使用
    没有持久化的redis和memcache一样,相当于一个纯内存的数据库
     
    一、RDB(Redis DataBase)
    RDB是将数据写入一个临时文件,持久化结束后,用这个临时文件替换上次持久化的文件,达到数据恢复。
    优点:使用单独子进程来进行持久化,主进程不会进行任何IO操作,保证了redis的高性能
    缺点:RDB是间隔一段时间进行持久化,如果持久化之间redis发生故障,会发生数据丢失。所以这种方式更适合数据要求不严谨的时候
     
    RDB默认开启,redis.conf中的具体配置参数如下
    #dbfilename:持久化数据存储在本地的文件
    dbfilename dump.rdb
    #dir:持久化数据存储在本地的路径,如果是在/redis/redis-3.0.6/src下启动的redis-cli,则数据会存储在当前src目录下
    dir ./
    #save时间,以下分别表示更改了1个key时间隔900s进行持久化存储;更改了10个key300s进行存储;更改10000个key60s进行存储。
    save 900 1
    save 300 10
    save 60 10000
     
    持久化过程:
    当满足save的条件时,比如更改了1个key,900s后会将数据写入临时文件,持久化完成后将临时文件替换旧的dump.rdb。(存储数据的节点是到触发时间时的的节点)
     
    使用RDB恢复数据:
    自动的持久化数据存储到dump.rdb后。实际只要重启redis服务即可完成(启动redis的server时会从dump.rdb中先同步数据)
     
    使用命令进行持久化save存储:
    ./redis-cli -h ip -p port save
    ./redis-cli -h ip -p port bgsave
    一个是在前台进行存储,一个是在后台进行存储。我的client就在server这台服务器上,所以不需要连其他机器,直接./redis-cli bgsave
     
    二、AOF(AppendOnly File)
    AOF是将执行过的指令记录下来,数据恢复时按照从前到后的顺序再将指令执行一遍,实现数据恢复
    优点:可以保持更高的数据完整性,如果设置追加file的时间是1s,如果redis发生故障,最多会丢失1s的数据;且如果日志写入不完整支持redis-check-aof来进行日志修复;AOF文件没被rewrite之前(文件过大时会对命令进行合并重写),可以删除其中的某些命令(比如误操作的flushall)。
    缺点:AOF文件比RDB文件大,且恢复速度慢。
     
    AOF默认关闭,开启方法,修改配置文件reds.conf:appendonly yes
    其他相关配置项:
    #AOF保存的文件名
    appendfilename ""
     
    以下为同步方式相关的配置:
    #一旦插入命令,立即同步到磁盘,保证了完全的持久化,但是速度慢,不推荐
    appendfsync always
     
    #AOF每秒进行同步
    appendfsync everysec
     
    #不自动同步,性能最好,但是持久化没有保证
    appendfsync no
     
    存储过程:将快照内容以命令的形式追加到AOF文件中,所以随着追加AOF文件会越来越大
    保存的AOF文件存储了执行的所有命令,所以可以进行修改文件来撤销输错的命令(在重写之前,如果重写了就没有办法了)
     
    针对AOF文件越来越大的问题,可以对AOF文件进行重写,命令如下:
    redis-cli -h ip -p port bgrewriteaof
    重写命令的操作过程:在当前的快照保存工作结束后,开启一个子进程,将AOF文件进行重写,合并set命令等操作到一个临时文件,达到缩小文件大小的目的。重写结束后后将临时文件替换为新的AOF文件(重写过程中如果有新的redis操作命令,会提交到缓存中,重写结束后追加到AOF文件内)
     
    说明:redis2.4以上版本,重写机制自动触发。触发的相关redis.conf配置如下:
    auto-aof-rewrite-percentage 100(当目前的AOF文件大小超过上一次重写文件大小的百分之几时进行重写,如果没有重启过,则以启动时的AOF文件大小为依据);
    auto-aof-rewrite-min-size 64mb(允许重写的最小AOF文件大小);
    数据恢复:
    重启redis服务,前提是配置文件必须设置了appendonly yes,然后会从appendfile的文件加载文件。反之是从RDB中加载数据的。
    展开全文
  • Python Scrapy持久化存储

    2019-07-31 21:16:51
    基于终端指令的持久化存储  保证爬虫文件的parse方法中有可迭代类型对象(通常为列表or字典)的返回,该返回值可以通过终端指令的形式写入指定格式的文件中进行持久化操作; 执行输出指定格式进行存储:将爬取到的...
  • scrapy框架持久化存储

    2019-06-26 20:35:56
    1.基于终端指令的持久化存储 保证爬虫文件的parse方法中有可迭代类型对象(通常为列表or字典)的返回,该返回值可以通过终端指令的形式写入指定格式的文件中进行持久化操作。 2.基于管道的持久化存储 scrapy...
  • redis 持久化存储数据

    千次阅读 2018-04-08 19:07:46
    在用scrapy-redis分布式抓爬虫的时候,忘记对redis进行持久化存储了,第二天打开redis里面数据没了。。。所以要研究下redis持久化的问题。。。redis分两种持久化分别是RDB和AOF方式。1. RDBRDB是快照,RDB是一个文件...
  • Redis持久化存储

    2018-03-08 23:19:42
    Redis持久化存储Redis是一个开源(BSD许可),内存存储的数据结构服务器,可用作数据库,高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合,位图,hyperloglogs等数据类型。内置复制、Lua脚本、...
  • 文件持久化存储 目录 文件持久化存储 脑图 文件的操作 with 语句 OS模块 json模块 存储为Excel文件 脑图 文件的操作 import os import platform # 1. 获取操作系统类型 print(os.name) # 2. 获取主机...
  • Redis持久化存储之四

    2019-05-15 10:06:14
    持久化存储的方式: 1、rdb存储:二进制文件方式,不是实时存储,存储10key以上,开始持久化机制,体积小 2、aof存储:实时存储,日志文件方式存储,文件大 redis默认开启持久化机制 rdb redis如果宕机之后,...
  • k8s实现持久化存储

    2020-08-27 23:02:32
    但当pod被删除或重启后这些数据会随之消失,如果想要长久的保留这些数据就要用到数据持久化存储。 本次采用NFS作为k8s集群持久化存储的方案 安装nfs master节点作为nfs服务端,node节点作为客户端 master节点安装nfs...
  • vuex数据持久化存储

    2019-01-19 16:18:00
    想想好还是说下vuex数据的持久化存储吧。依稀还记得在做第一个vue项目时,由于刚刚使用vue,对vue的一些基本概念只是有一个简单的了解。当涉及到非父子组件之间通信时,选择了vuex。只是后来竟然发现,刷新页面,数据...
  • GridFS图片持久化存储

    2019-03-04 20:49:58
    GridFS是MongoDB提供的用于持久化存储文件的模块,CMS使用MongoDB存储数据,使用GridFS可以快速集成 开发。 它的工作原理是: 在GridFS存储文件是将文件分块存储,文件会按照256KB的大小分割成多个块进行存储,...
  • Flutter持久化存储之key-value存储

    千次阅读 2019-03-04 03:33:34
    应用开发时会有很多的数据存储需求,这个时候就需要用到持久化存储技术,与iOS、安卓一样,Flutter中也有很多种持久化存储方式,比如key-value存储、文件存储、数据库存储等,但其实质都是通过平台对应的模块来实现...
  • SQLite持久化存储

    2017-05-22 18:43:37
    回忆一下Android的SQLite持久化存储,有一段时间没用了,又或是使用的第三方封装的,顺手写了个小记事本,回忆一下温故而知新嘛。。最后给下载地址 效果: 可以自定义首页的item,点击最后一个添加的item就ok,名字...
  • Python模型本地持久化存储

    千次阅读 2018-12-04 21:35:38
    Python模型本地持久化存储 通常我们线下训练好的模型,部署到线上运行,这就需要把模型进行本地硬盘持久化,比如保持到文件中,然后再在其他主机上导入内存进行分类和预测。下面就介绍几种模型持久化存储方法。 1....
  • 为什么要做持久化存储? 持久化存储是将 Redis 存储在内存中的数据存储在硬盘中,实现数据的永久保存。我们都知道 Redis 是一个基于内存的 nosql 数据库,内存存储很容易造成数据的丢失,因为当服务器关机等一些...
  • Redis 持久化存储方案

    千次阅读 2018-01-12 22:57:15
    从严格意义上说,Redis服务提供四种持久化存储方案:RDB、AOF、虚拟内存(VM)和 DISKSTORE。虚拟内存(VM)方式,从Redis Version 2.4开始就被官方明确表示不再建议使用,Version 3.2版本中更找不到关于虚拟内存...
  • redis的持久化存储

    2017-11-17 11:09:47
    Redis中数据存储模式有2种:cache-only,persistence; cache-only即只做为“缓存”服务,不持久数据,数据在服务终止后将消失,此模式下也将不存在“数据恢复”的手段,是一种安全性...对于persistence持久化存储,Red
  • 本文首发于我的博客:... 前言:本文主要讲解Scrapy的数据持久化,主要包括存储到数据库、json文件以及内置数据存储 持久化存储——JSON pipelins.py `import json from scrapy.exceptions import Drop
  • 但大量的事件如果都存储在etcd中,会带来较大的性能与容量压力,所以etcd中默认只保存最近1小时,而在日常的kubernetes环境排查过程中有需要借助到event所反映的问题提供思路,所以就需要借助其他工具进行持久化存储 ...
  • Android数据持久化存储

    千次阅读 2016-05-05 14:51:19
    Android数据持久化存储共有四种方式,分别是文件存储、SharedPreferences、Sqlite数据库和ContentProvider。在本篇幅中只介绍前面三种存储方式,因为ContentProvider属于android四大组件之一,所以它的数据存储方式...
  • 有状态的应用和对数据有持久化的应用,我们有通过 hostPath 或者 emptyDir 的方式来持久化我们的数据,但是显然我们还需要更加可靠的存储来保存应用的持久化数据,这样容器在重建后,依然可以使用之前的数据。...
  • flutter 持久化存储-----数据库sqflite

    千次阅读 2019-03-13 16:28:54
    Flutter中持久化存储数据有多种方案, 一般常用的有 shared_preferences 和 sqfite shared_preferences: 包含NSUserDefaults(在iOS上)和SharedPreferences(在Android上),为简单数据提供持久存储。数据以异步...
  • ios 数据持久化存储

    千次阅读 2014-12-24 19:50:43
    相对复杂的App仅靠内存的数据肯定无法满足,数据写磁盘作持久化存储是几乎每个客户端软件都需要做的。简单如“是否第一次打开”的BOOL值,大到游戏的进度和状态等数据,都需要进行本地持久化存储。这些数据的存储...
  • 本文详细整理了自己对PV和PVC存储体系、CSI 自定义存储插件等容器持久化存储方面的设计思想和知识理解,是在学习张磊老师Kubernetes课程中持久化存储过程中的学习笔记。 【Kevin亓】 一、Kubernetes 本身的持久化...
  • Kubernetes持久化存储Cephfs

    千次阅读 2018-05-24 18:00:00
    &#13; &#13; &#13; &#13; &#13; &#13; &#13; 女主宣言上一篇 kubernetes持久化存储Ceph RBD 介绍了Ceph RBD在kubern...
  • 引入vuex-persist 插件,它就是为 Vuex 持久化存储而生的一个插件。不需要你手动存取 storage ,而是直接将状态保存至 cookie 或者 localStorage 中。具体用法如下: pexels-photo-1211847.jpeg 安装: npm ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,962
精华内容 13,184
关键字:

持久化存储