OpenStack使用Ceph存储,Ceph到底做了什么?

 

 

1 背景知识

 

1.1 Ceph简介

Ceph是当前非常流行的开源分布式存储系统,具有高扩展性、高性能、高可靠性等优点,同时提供块存储服务(rbd)、对象存储服务(rgw)以及文件系统存储服务(cephfs)。目前也是OpenStack的主流后端存储,和OpenStack亲如兄弟,为OpenStack提供统一共享存储服务。使用Ceph作为OpenStack后端存储,具有如下优点:

 

    所有的计算节点共享存储,迁移时不需要拷贝根磁盘,即使计算节点挂了,也能立即在另一个计算节点启动虚拟机(evacuate)。
  利用COW(Copy On Write)特性,创建虚拟机时,只需要基于镜像clone即可,不需要下载整个镜像,而clone操作基本是0开销,从而实现了秒级创建虚拟机。
  Ceph RBD支持thin provisioning,即按需分配空间,有点类似Linux文件系统的sparse稀疏文件。创建一个20GB的虚拟硬盘时,最开始并不占用物理存储空间,
    只有当写入数据时,才按需分配存储空间。

 

Ceph的更多知识可以参考官方文档,这里我们只关注RBD,RBD管理的核心对象为块设备(block device),通常我们称为volume,不过Ceph中习惯称之为image(注意和OpenStack image的区别)。Ceph中还有一个pool的概念,类似于namespace,不同的pool可以定义不同的副本数、pg数、放置策略等。每个image都必须指定pool。image的命名规范为pool_name/image_name@snapshot,比如openstack/test-volume@test-snap,表示在openstackpool中test-volumeimage的快照test-snap。因此以下两个命令效果是等同的:

 

rbd snap create --pool openstack --image test-image --snap test-snap rbd snap create openstack/test-image@test-snap

 

 

openstack pool上创建一个1G的image命令为:

 

rbd -p openstack create --size 1024 int32bit-test-1

 

image支持快照(snapshot)的功能,创建一个快照即保存当前image的状态,相当于git commit操作,用户可以随时把image回滚到任意快照点上(git reset)。创建快照命令如下:

rbd -p openstack snap create int32bit-test-1@snap-1

 

查看rbd列表:

 

$ rbd -p openstack ls -l | grep int32bit-test int32bit-test-1        1024M 2 int32bit-test-1@snap-1 1024M 2

 

 

基于快照可以创建一个新的image,称为clone,clone不会立即复制原来的image,而是使用COW策略,即写时拷贝,只有当需要写入一个对象时,才从parent中拷贝那个对象到本地,因此clone操作基本秒级完成,并且需要注意的是基于同一个快照创建的所有image共享快照之前的image数据,因此在clone之前我们必须保护(protect)快照,被保护的快照不允许删除。clone操作类似于git branch操作,clone一个image命令如下:

rbd -p openstack snap protect int32bit-test-1@snap-1 rbd -p openstack clone int32bit-test-1@snap-1 int32bit-test-2

 

 

我们可以查看一个image的子image(children)有哪些,也能查看一个image是基于哪个image clone的(parent):

$ rbd -p openstack children int32bit-test-1@snap-1 openstack/int32bit-test-2 $ rbd -p openstack info int32bit-test-2 | grep parent parent: openstack/int32bit-test-1@snap-1

 

以上我们可以发现int32bit-test-2int32bit-test-1的children,而int32bit-test-1int32bit-test-2的parent。

 

不断地创建快照并clone image,就会形成一条很长的image链,链很长时,不仅会影响读写性能,还会导致管理非常麻烦。可幸的是Ceph支持合并链上的所有image为一个独立的image,这个操作称为flatten,类似于git merge操作,flatten需要一层一层拷贝所有顶层不存在的数据,因此通常会非常耗时。

 

$ rbd -p openstack flatten int32bit-test-2 Image flatten: 31% complete...

 

 

此时我们再次查看其parrent-children关系:

rbd -p openstack children int32bit-test-1@snap-1

 

 

此时int32bit-test-1没有children了,int32bit-test-2完全独立了。

当然Ceph也支持完全拷贝,称为copy

 

rbd -p openstack cp int32bit-test-1 int32bit-test-3

 

copy会完全拷贝一个image,因此会非常耗时,但注意copy不会拷贝原来的快照信息。

Ceph支持将一个RBD image导出(export):

 

rbd -p openstack export int32bit-test-1 int32bit-1.raw

 

导出会把整个image导出,Ceph还支持差量导出(export-diff),即指定从某个快照点开始导出:

rbd -p openstack export-diff  int32bit-test-1 --from-snap snap-1  --snap snap-2 int32bit-test-1-diff.raw

 

 

以上导出从快照点snap-1到快照点snap-2的数据。

当然与之相反的操作为import以及import-diff。通过export/import支持image的全量备份,而export-diff/import-diff实现了image的差量备份。

Rbd image是动态分配存储空间,通过du命令可以查看image实际占用的物理存储空间:

 

$ rbd du int32bit-test-1 NAME            PROVISIONED   USED int32bit-test-1       1024M 12288k

 

 

以上image分配的大小为1024M,实际占用的空间为12288KB。

删除image,注意必须先删除其所有快照,并且保证没有依赖的children:

rbd -p openstack snap unprotect int32bit-test-1@snap-1 rbd -p openstack snap rm int32bit-test-1@snap-1 rbd -p openstack rm int32bit-test-1

 

1.2 OpenStack简介

OpenStack是一个IaaS层的云计算平台开源实现,关于OpenStack的更多介绍欢迎访问我的个人博客,这里只专注于当OpenStack对接Ceph存储系统时,基于源码分析一步步探测Ceph到底做了些什么工作。本文不会详细介绍OpenStack的整个工作流程,而只关心与Ceph相关的实现,如果有不清楚OpenStack源码架构的,可以参考我之前写的文章如何阅读OpenStack源码

阅读完本文可以理解以下几个问题:

  1. 为什么上传的镜像必须要转化为raw格式?
  2. 如何高效上传一个大的镜像文件?
  3. 为什么能够实现秒级创建虚拟机?
  4. 为什么创建虚拟机快照需要数分钟时间,而创建volume快照能够秒级完成?
  5. 为什么当有虚拟机存在时,不能删除镜像?
  6. 为什么一定要把备份恢复到一个空卷中,而不能覆盖已经存在的volume?
  7. 从镜像中创建volume,能否删除镜像?

注意本文都是在基于使用Ceph存储的前提下,即Glance、Nova、Cinder都是使用的Ceph,其它情况下结论不一定成立。

另外本文会先贴源代码,很长很枯燥,你可以快速跳到总结部分查看OpenStack各个操作对应的Ceph工作。

 

 

2 Glance

 

 

2.1 Glance介绍

Glance管理的核心实体是image,它是OpenStack的核心组件之一,为OpenStack提供镜像服务(Image as Service),主要负责OpenStack镜像以及镜像元数据的生命周期管理、检索、下载等功能。Glance支持将镜像保存到多种存储系统中,后端存储系统称为store,访问镜像的地址称为location,location可以是一个http地址,也可以是一个rbd协议地址。只要实现store的driver就可以作为Glance的存储后端,其中driver的主要接口如下:

    get: 获取镜像的location。
  get_size: 获取镜像的大小。
  get_schemes: 获取访问镜像的URL前缀(协议部分),比如rbd、swift+https、http等。
  add: 上传镜像到后端存储中。
  delete: 删除镜像。
  set_acls: 设置后端存储的读写访问权限。

 

 

为了便于维护,glance store目前已经作为独立的库从Glance代码中分离出来,由项目glance_store维护。目前社区支持的store列表如下:

    filesystem: 保存到本地文件系统,默认保存/var/lib/glance/images到目录下。
  cinder: 保存到Cinder中。
  rbd:保存到Ceph中。
  sheepdog:保存到sheepdog中。
  swift: 保存到Swift对象存储中。
  vmware datastore: 保存到Vmware datastore中。
  http: 以上的所有store都会保存镜像数据,唯独http store比较特殊,它不保存镜像的任何数据,因此没有实现add方法,它仅仅保存镜像的URL地址,
    启动虚拟机时由计算节点从指定的http地址中下载镜像。

 

本文主要关注rbd store,它的源码在这里,该store的driver代码主要由国内Fei Long Wang负责维护,其它store的实现细节可以参考源码glance store drivers.

2.2 镜像上传

由前面的介绍可知,镜像上传主要由store的add方法实现:

 

@capabilities.check def add(self, image_id, image_file, image_size, context=None,         verifier=None):     checksum = hashlib.md5()     image_name = str(image_id)     with self.get_connection(conffile=self.conf_file,                              rados_id=self.user) as conn:         fsid = None         if hasattr(conn, 'get_fsid'):             fsid = conn.get_fsid()         with conn.open_ioctx(self.pool) as ioctx:             order = int(math.log(self.WRITE_CHUNKSIZE, 2))             try:                 loc = self._create_image(fsid, conn, ioctx, image_name,                                          image_size, order)             except rbd.ImageExists:                 msg = _('RBD image %s already exists') % image_id                 raise exceptions.Duplicate(message=msg)                 ...

 

 

 

其中注意image_file不是一个文件,而是LimitingReader实例,该实例保存了镜像的所有数据,通过read(bytes)方法读取镜像内容。

从以上源码中看,glance首先获取ceph的连接session,然后调用_create_image方法创建了一个rbd image,大小和镜像的size一样:

 

def _create_image(self, fsid, conn, ioctx, image_name,                   size, order, context=None):     librbd = rbd.RBD()     features = conn.conf_get('rbd_default_features')     librbd.create(ioctx, image_name, size, order, old_format=False,                   features=int(features))     return StoreLocation({         'fsid': fsid,         'pool': self.pool,         'image': image_name,         'snapshot': DEFAULT_SNAPNAME,     }, self.conf)

 

因此以上步骤通过rbd命令表达大致为:

 

rbd -p ${rbd_store_pool} create  --size ${image_size} ${image_id}

 

 

在ceph中创建完rbd image后,接下来:

with rbd.Image(ioctx, image_name) as image:     bytes_written = 0     offset = 0     chunks = utils.chunkreadable(image_file,                                  self.WRITE_CHUNKSIZE)     for chunk in chunks:         offset += image.write(chunk, offset)         checksum.update(chunk)

 

可见Glance逐块从image_file中读取数据写入到刚刚创建的rbd image中并计算checksum,其中块大小由rbd_store_chunk_size配置,默认为8MB。

我们接着看最后步骤:

 

if loc.snapshot:     image.create_snap(loc.snapshot)     image.protect_snap(loc.snapshot)

 

 

从代码中可以看出,最后步骤为创建image快照(快照名为snap)并保护起来。

假设我们上传的镜像为cirros,镜像大小为39MB,镜像uuid为d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6,配置保存在ceph的openstack pool中,则对应ceph的操作流程大致为:

 

rbd -p openstack create  --size 39 d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6 rbd -p openstack snap create  d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap rbd -p openstack snap protect  d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap

 

我们可以通过rbd命令验证:

$ rbd ls -l | grep d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6 d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6      40162k  2 d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap 40162k  2 yes

 

 

启示

我们前面介绍了镜像上传到Ceph的过程,省略了镜像上传到Glance的流程,但毋容置疑的是镜像肯定是通过Glance API上传到Glance中的。当镜像非常大时,由于通过Glance API走HTTP协议,导致非常耗时且占用API管理网带宽。我们可以通过rbd import直接导入镜像的方式大幅度提高上传镜像的效率。

首先使用Glance创建一个空镜像,记下它的uuid:

glance image-create  d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6 | awk '/sids/{print $4}'} 

 

假设uuid为d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6,使用rbd命令直接导入镜像并创建快照:

rbd -p openstack import cirros.raw  --image=d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6 rbd -p openstack snap create  d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap rbd -p openstack snap protect  d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap

 

设置glance镜像location url:

 

FS_ID=`ceph -s | grep cluster | awk '{print $2}'` glance location-add  --url rbd://${FS_ID}/openstack/d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6/snap  d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6 

 

 

设置glance镜像其它属性:

 

glance image-update --name="cirros"  --disk-format=raw  --container-format=bare d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6

 

2.3 镜像删除

删除镜像就是相反的过程,即先执行unprotext -> snap rm -> rm,如下:

try:     self._unprotect_snapshot(image, snapshot_name)     image.remove_snap(snapshot_name) except rbd.ImageBusy as exc:     raise exceptions.InUseByStore() rbd.RBD().remove(ioctx, image_name) 

 

删除镜像必须保证当前rbd image没有子image,否则删除会失败。

3 Nova

 

3.1 Nova介绍

Nova管理的核心实体为server,为OpenStack提供计算服务,它是OpenStack最核心的组件。注意Nova中的server不只是指虚拟机,它可以是任何计算资源的抽象,除了虚拟机以外,也有可能是baremetal裸机、容器等。

不过我们在这里假定:

 

    server为虚拟机。
  image type为rbd。
  compute driver为libvirt。

 

启动虚拟机之前首先需要准备根磁盘(root disk),Nova称为image,和Glance一样,Nova的image也支持存储到本地磁盘、Ceph以及Cinder(boot from volume)中。需要注意的是,image保存到哪里是通过image type决定的,存储到本地磁盘可以是raw、qcow2、ploop等,如果image type为rbd,则image存储到Ceph中。不同的image type由不同的image backend负责,其中rbd的backend为nova/virt/libvirt/imageackend中的Rbd类模块实现。

3.2 创建虚拟机

创建虚拟机的过程不再详细分析,不清楚的可以查看我之前写的博客,我们直接进入研究Nova的libvirt driver是如何为虚拟机准备根磁盘image的,代码位于nova/virt/libvirt/driver.pyspawn方法,其中创建image调用了_create_image方法。

 

def spawn(self, context, instance, image_meta, injected_files,           admin_password, network_info=None, block_device_info=None):     ...     self._create_image(context, instance, disk_info['mapping'],                        injection_info=injection_info,                        block_device_info=block_device_info)     ... 

 

 

_create_image方法部分代码如下:

 

def _create_image(self, context, instance,                   disk_mapping, injection_info=None, suffix='',                   disk_images=None, block_device_info=None,                   fallback_from_host=None,                   ignore_bdi_for_swap=False):     booted_from_volume = self._is_booted_from_volume(block_device_info)     ...     # ensure directories exist and are writable     fileutils.ensure_tree(libvirt_utils.get_instance_path(instance))     ...     self._create_and_inject_local_root(context, instance,                                        booted_from_volume, suffix,                                        disk_images, injection_info,                                        fallback_from_host)     ...

 

该方法首先在本地创建虚拟机的数据目录/var/lib/nova/instances/${uuid}/,然后调用了_create_and_inject_local_root方法创建根磁盘。

 

 

def _create_and_inject_local_root(self, context, instance,                                   booted_from_volume, suffix, disk_images,                                   injection_info, fallback_from_host):     ...     if not booted_from_volume:         root_fname = imagecache.get_cache_fname(disk_images['image_id'])         size = instance.flavor.root_gb * units.Gi         backend = self.image_backend.by_name(instance, 'disk' + suffix,                                              CONF.libvirt.images_type)         if backend.SUPPORTS_CLONE:             def clone_fallback_to_fetch(*args, **kwargs):                 try:                     backend.clone(context, disk_images['image_id'])                 except exception.ImageUnacceptable:                     libvirt_utils.fetch_image(*args, **kwargs)             fetch_func = clone_fallback_to_fetch         else:             fetch_func = libvirt_utils.fetch_image         self._try_fetch_image_cache(backend, fetch_func, context,                                     root_fname, disk_images['image_id'],                                     instance, size, fallback_from_host)         ...

 

其中image_backend.by_name()方法通过image type名称返回image backend实例,这里是Rbd。从代码中看出,如果backend支持clone操作(SUPPORTS_CLONE),则会调用backend的clone()方法,否则通过fetch_image()方法下载镜像。显然Ceph rbd是支持clone的。我们查看Rbdclone()方法,代码位于nova/virt/libvirt/imagebackend.py模块:

 

def clone(self, context, image_id_or_uri):     ...     for location in locations:         if self.driver.is_cloneable(location, image_meta):             LOG.debug('Selected location: %(loc)s', {'loc': location})             return self.driver.clone(location, self.rbd_name)     ...

 

该方法遍历Glance image的所有locations,然后通过driver.is_cloneable()方法判断是否支持clone,若支持clone则调用driver.clone()方法。其中driver是Nova的storage driver,代码位于nova/virt/libvirt/storage,其中rbd driver在rbd_utils.py模块下,我们首先查看is_cloneable()方法:

 def is_cloneable(self, image_location, image_meta):         url = image_location['url']         try:             fsid, pool, image, snapshot = self.parse_url(url)         except exception.ImageUnacceptable as e:             return False         if self.get_fsid() != fsid:             return False         if image_meta.get('disk_format') != 'raw':             return False         # check that we can read the image         try:             return self.exists(image, pool=pool, snapshot=snapshot)         except rbd.Error as e:             LOG.debug('Unable to open image %(loc)s: %(err)s',                       dict(loc=url, err=e))             return False

 

 

可见如下情况不支持clone:

 

    Glance中的rbd image location不合法,rbd location必须包含fsid、pool、image id,snapshot 4个字段,字段通过/划分。
  Glance和Nova对接的是不同的Ceph集群。
  Glance镜像非raw格式。
  Glance的rbd image不存在名为snap的快照。

 

其中尤其注意第三条,如果镜像为非raw格式,Nova创建虚拟机时不支持clone操作,因此必须从Glance中下载镜像。这就是为什么Glance使用Ceph存储时,镜像必须转化为raw格式的原因。

最后我们看clone方法:

 

def clone(self, image_location, dest_name, dest_pool=None):     _fsid, pool, image, snapshot = self.parse_url(             image_location['url'])     with RADOSClient(self, str(pool)) as src_client:         with RADOSClient(self, dest_pool) as dest_client:             try:                 RbdProxy().clone(src_client.ioctx,                                  image,                                  snapshot,                                  dest_client.ioctx,                                  str(dest_name),                                  features=src_client.features)             except rbd.PermissionError:                 raise exception.Forbidden(_('no write permission on '                                             'storage pool %s') % dest_pool) 

 

该方法只调用了ceph的clone方法,可能会有人疑问都是使用同一个Ceph cluster,为什么需要两个ioctx?这是因为Glance和Nova可能使用的不是同一个Ceph pool,一个pool对应一个ioctx

以上操作大致相当于如下rbd命令:

 

rbd clone  ${glance_pool}/${镜像uuid}@snap  ${nova_pool}/${虚拟机uuid}.disk

 

 

假设Nova和Glance使用的pool都是openstack,Glance镜像uuid为d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6,Nova虚拟机的uuid为cbf44290-f142-41f8-86e1-d63c902b38ed,则对应的rbd命令大致为:

rbd clone  openstack/d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap  openstack/cbf44290-f142-41f8-86e1-d63c902b38ed_disk

 

我们进一步验证:

int32bit $ rbd -p openstack ls | grep cbf44290-f142-41f8-86e1-d63c902b38ed cbf44290-f142-41f8-86e1-d63c902b38ed_disk int32bit $ rbd -p openstack info cbf44290-f142-41f8-86e1-d63c902b38ed_disk rbd image 'cbf44290-f142-41f8-86e1-d63c902b38ed_disk':     size 2048 MB in 256 objects     order 23 (8192 kB objects)     block_name_prefix: rbd_data.9f756763845e     format: 2     features: layering, exclusive-lock, object-map, fast-diff, deep-flatten     flags:     create_timestamp: Wed Nov 22 05:11:17 2017     parent: openstack/d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap     overlap: 40162 kB

 

 

由输出可见,Nova确实创建了一个名为cbf44290-f142-41f8-86e1-d63c902b38ed_disk rbd image,并且它的parent为openstack/d1a06da9-8ccd-4d3e-9b63-6dcd3ead29e6@snap

启示

 

    创建虚拟机时并没有拷贝镜像,也不需要下载镜像,而是一个简单clone操作,因此创建虚拟机基本可以在秒级完成。
  如果镜像中还有虚拟机依赖,则不能删除该镜像,换句话说,删除镜像之前,必须删除基于该镜像创建的所有虚拟机。

 

3.3 创建虚拟机快照

首先说点题外话,我感觉Nova把create image和create snapshot弄混乱了,我理解的这二者的区别:

 

    create image:把虚拟机的根磁盘上传到Glance中。
  create snapshot: 根据image格式对虚拟机做快照,qcow2和rbd格式显然都支持快照。快照不应该保存到Glance中,由Nova或者Cinder(boot from Cinder)管理。

 

可事实上,Nova创建快照的子命令为image-create,API方法也叫_action_create_image(),之后调用的方法叫snapshot()。而实际上,对于大多数image type,如果不是从云硬盘启动(boot from volume),其实就是create image,即上传镜像到Glance中,而非真正的snapshot。

当然只是命名的区别而已,这里对create image和create snapshot不做任何区别。

虚拟机的快照由libvirtdriver的snapshot()方法实现,代码位于nova/virt/libvirt/driver.py,核心代码如下:

 

 

def snapshot(self, context, instance, image_id, update_task_state):     ...     root_disk = self.image_backend.by_libvirt_path(         instance, disk_path, image_type=source_type)     try:         update_task_state(task_state=task_states.IMAGE_UPLOADING,                           expected_state=task_states.IMAGE_PENDING_UPLOAD)         metadata['location'] = root_disk.direct_snapshot(             context, snapshot_name, image_format, image_id,             instance.image_ref)         self._snapshot_domain(context, live_snapshot, virt_dom, state,                               instance)         self._image_api.update(context, image_id, metadata,                                purge_props=False)     except (NotImplementedError, exception.ImageUnacceptable) as e:         ...

 

 

Nova首先通过disk_path获取对应的image backend,这里返回的是imagebackend.Rbd,然后调用了backend的direct_snapshot()方法,该方法如下:

def direct_snapshot(self, context, snapshot_name, image_format,                     image_id, base_image_id):     fsid = self.driver.get_fsid()     parent_pool = self._get_parent_pool(context, base_image_id, fsid)      self.driver.create_snap(self.rbd_name, snapshot_name, protect=True)     location = {'url': 'rbd://%(fsid)s/%(pool)s/%(image)s/%(snap)s' %                        dict(fsid=fsid,                             pool=self.pool,                             image=self.rbd_name,                             snap=snapshot_name)}     try:         self.driver.clone(location, image_id, dest_pool=parent_pool)         self.driver.flatten(image_id, pool=parent_pool)     finally:         self.cleanup_direct_snapshot(location)     self.driver.create_snap(image_id, 'snap', pool=parent_pool,                             protect=True)     return ('rbd://%(fsid)s/%(pool)s/%(image)s/snap' %             dict(fsid=fsid, pool=parent_pool, image=image_id))

 

从代码中分析,大体可分为以下几个步骤:

获取Ceph集群的fsid。
对虚拟机根磁盘对应的rbd image创建一个临时快照,快照名是一个随机uuid。将创建的快照保护起来(protect)。
基于快照clone一个新的rbd image,名称为snapshot uuid。
对clone的image执行flatten操作。
删除创建的临时快照。
对clone的rbd image创建快照,快照名为snap,并执行protect。

 

 

对应rbd命令,假设虚拟机uuid为cbf44290-f142-41f8-86e1-d63c902b38ed,快照的uuid为db2b6552-394a-42d2-9de8-2295fe2b3180,则对应rbd命令为:

# Snapshot the disk and clone it into Glance's storage pool rbd -p openstack snap create  cbf44290-f142-41f8-86e1-d63c902b38ed_disk@3437a9bbba5842629cc76e78aa613c70 rbd -p openstack snap protect  cbf44290-f142-41f8-86e1-d63c902b38ed_disk@3437a9bbba5842629cc76e78aa613c70 rbd -p openstack clone  cbf44290-f142-41f8-86e1-d63c902b38ed_disk@3437a9bbba5842629cc76e78aa613c70  db2b6552-394a-42d2-9de8-2295fe2b3180 # Flatten the image, which detaches it from the source snapshot rbd -p openstack flatten  db2b6552-394a-42d2-9de8-2295fe2b3180 # all done with the source snapshot, clean it up rbd -p openstack snap unprotect  cbf44290-f142-41f8-86e1-d63c902b38ed_disk@3437a9bbba5842629cc76e78aa613c70 rbd -p openstack snap rm  cbf44290-f142-41f8-86e1-d63c902b38ed_disk@3437a9bbba5842629cc76e78aa613c70 # Makes a protected snapshot called 'snap' on uploaded images  # and hands it out rbd -p openstack snap create  db2b6552-394a-42d2-9de8-2295fe2b3180@snap rbd -p openstack snap protect  db2b6552-394a-42d2-9de8-2295fe2b3180@snap

 

其中3437a9bbba5842629cc76e78aa613c70是产生的临时快照名称,它一个随机生成的uuid。

启示

 

其它存储后端主要耗时会在镜像上传过程,而当使用Ceph存储时,主要耗在rbd的flatten过程,因此创建虚拟机快照通常要好几分钟的时间。有人可能会疑问,为什么一定要执行flatten操作呢,直接clone不就完事了吗?社区这么做是有原因的:

 

如果不执行flatten操作,则虚拟机快照依赖于虚拟机,换句话说,虚拟机只要存在快照就不能删除虚拟机了,这显然不合理。
上一个问题继续延展,假设基于快照又创建虚拟机,虚拟机又创建快照,如此反复,整个rbd image的依赖会非常复杂,根本管理不了。
当rbd image链越来越长时,对应的IO读写性能也会越来越差。…

 

3.4 删除虚拟机

libvirt driver删除虚拟机的代码位于nova/virt/libvirt/driver.pydestroy方法:

 

def destroy(self, context, instance, network_info, block_device_info=None,                 destroy_disks=True):     self._destroy(instance)     self.cleanup(context, instance, network_info, block_device_info,                  destroy_disks)

 

注意前面的_destroy方法其实就是虚拟机关机操作,即Nova会首先让虚拟机先关机再执行删除操作。紧接着调用cleanup()方法,该方法执行资源的清理工作。这里我们只关注清理disks的过程:

 

if destroy_disks:     # NOTE(haomai): destroy volumes if needed     if CONF.libvirt.images_type == 'lvm':         self._cleanup_lvm(instance, block_device_info)     if CONF.libvirt.images_type == 'rbd':         self._cleanup_rbd(instance) ...

 

 

由于我们的image type为rbd,因此调用的_cleanup_rbd()方法:

 

def _cleanup_rbd(self, instance):     if instance.task_state == task_states.RESIZE_REVERTING:         filter_fn = lambda disk: (disk.startswith(instance.uuid) and                                   disk.endswith('disk.local'))     else:         filter_fn = lambda disk: disk.startswith(instance.uuid)     LibvirtDriver._get_rbd_driver().cleanup_volumes(filter_fn)

 

 

我们只考虑正常删除操作,忽略resize撤回操作,则filter_fnlambda disk: disk.startswith(instance.uuid),即所有以虚拟机uuid开头的disk(rbd image)。需要注意,这里没有调用imagebackendRbd driver,而是直接调用storage driver,代码位于nova/virt/libvirt/storage/rbd_utils.py:

def cleanup_volumes(self, filter_fn):     with RADOSClient(self, self.pool) as client:         volumes = RbdProxy().list(client.ioctx)         for volume in filter(filter_fn, volumes):             self._destroy_volume(client, volume)

 

该方法首先获取所有的rbd image列表,然后通过filter_fn方法过滤以虚拟机uuid开头的image,调用_destroy_volume方法:

 

def _destroy_volume(self, client, volume, pool=None):     """Destroy an RBD volume, retrying as needed.     """     def _cleanup_vol(ioctx, volume, retryctx):         try:             RbdProxy().remove(ioctx, volume)             raise loopingcall.LoopingCallDone(retvalue=False)         except rbd.ImageHasSnapshots:             self.remove_snap(volume, libvirt_utils.RESIZE_SNAPSHOT_NAME,                              ignore_errors=True)         except (rbd.ImageBusy, rbd.ImageHasSnapshots):             LOG.warning('rbd remove %(volume)s in pool %(pool)s failed',                         {'volume': volume, 'pool': self.pool})         retryctx['retries'] -= 1         if retryctx['retries'] <= 0:             raise loopingcall.LoopingCallDone()      # NOTE(danms): We let it go for ten seconds     retryctx = {'retries': 10}     timer = loopingcall.FixedIntervalLoopingCall(         _cleanup_vol, client.ioctx, volume, retryctx)     timed_out = timer.start(interval=1).wait()     if timed_out:         # NOTE(danms): Run this again to propagate the error, but         # if it succeeds, don't raise the loopingcall exception         try:             _cleanup_vol(client.ioctx, volume, retryctx)         except loopingcall.LoopingCallDone:             pass

 

 

该方法最多会尝试10+1次_cleanup_vol()方法删除rbd image,如果有快照,则会先删除快照。

假设虚拟机的uuid为cbf44290-f142-41f8-86e1-d63c902b38ed,则对应rbd命令大致为:

 

for image in $(rbd -p openstack ls | grep '^cbf44290-f142-41f8-86e1-d63c902b38ed'); do      rbd -p openstack rm "$image"; done

 

4 Cinder

4.1 Cinder介绍

Cinder是OpenStack的块存储服务,类似AWS的EBS,管理的实体为volume。Cinder并没有实现volume provide功能,而是负责管理各种存储系统的volume,比如Ceph、fujitsu、netapp等,支持volume的创建、快照、备份等功能,对接的存储系统我们称为backend。只要实现了cinder/volume/driver.pyVolumeDriver类定义的接口,Cinder就可以对接该存储系统。

Cinder不仅支持本地volume的管理,还能把本地volume备份到远端存储系统中,比如备份到另一个Ceph集群或者Swift对象存储系统中,本文将只考虑从源Ceph集群备份到远端Ceph集群中的情况。

4.2 创建volume

创建volume由cinder-volume服务完成,入口为cinder/volume/manager.pycreate_volume()方法,

 

def create_volume(self, context, volume, request_spec=None,                   filter_properties=None, allow_reschedule=True):     ...                   try:         # NOTE(flaper87): Driver initialization is         # verified by the task itself.         flow_engine = create_volume.get_flow(             context_elevated,             self,             self.db,             self.driver,             self.scheduler_rpcapi,             self.host,             volume,             allow_reschedule,             context,             request_spec,             filter_properties,             image_volume_cache=self.image_volume_cache,         )     except Exception:         msg = _("Create manager volume flow failed.")         LOG.exception(msg, resource={'type': 'volume', 'id': volume.id})         raise exception.CinderException(msg) ...        

 

Cinder创建volume的流程使用了taskflow框架,taskflow具体实现位于cinder/volume/flows/manager/create_volume.py,我们关注其execute()方法:

 

def execute(self, context, volume, volume_spec):     ...     if create_type == 'raw':         model_update = self._create_raw_volume(volume, **volume_spec)     elif create_type == 'snap':         model_update = self._create_from_snapshot(context, volume,                                                   **volume_spec)     elif create_type == 'source_vol':         model_update = self._create_from_source_volume(             context, volume, **volume_spec)     elif create_type == 'image':         model_update = self._create_from_image(context,                                                volume,                                                **volume_spec)     else:         raise exception.VolumeTypeNotFound(volume_type_id=create_type)     ...     

 

 

从代码中我们可以看出,创建volume分为4种类型:

raw: 创建空白卷。
create from snapshot: 基于快照创建volume。
create from volume: 相当于复制一个已存在的volume。
create from image: 基于Glance image创建一个volume。

 

raw

创建空白卷是最简单的方式,代码如下:

def _create_raw_volume(self, volume, **kwargs):     ret = self.driver.create_volume(volume)     ...

 

直接调用driver的create_volume()方法,这里driver是RBDDriver,代码位于cinder/volume/drivers/rbd.py:

def create_volume(self, volume):     with RADOSClient(self) as client:         self.RBDProxy().create(client.ioctx,                                vol_name,                                size,                                order,                                old_format=False,                                features=client.features)          try:             volume_update = self._enable_replication_if_needed(volume)         except Exception:             self.RBDProxy().remove(client.ioctx, vol_name)             err_msg = (_('Failed to enable image replication'))             raise exception.ReplicationError(reason=err_msg,                                              volume_id=volume.id)

 

 

其中size单位为MB,vol_namevolume-${volume_uuid}

假设volume的uuid为bf2d1c54-6c98-4a78-9c20-3e8ea033c3db,Ceph池为openstack,创建的volume大小为1GB,则对应的rbd命令相当于:

rbd -p openstack create  --new-format --size 1024  volume-bf2d1c54-6c98-4a78-9c20-3e8ea033c3db

 

我们可以通过rbd命令验证:

 

int32bit $ rbd -p openstack ls | grep bf2d1c54-6c98-4a78-9c20-3e8ea033c3db volume-bf2d1c54-6c98-4a78-9c20-3e8ea033c3db

 

create from snapshot

从快照中创建volume也是直接调用driver的方法,如下:

def _create_from_snapshot(self, context, volume, snapshot_id,                           **kwargs):     snapshot = objects.Snapshot.get_by_id(context, snapshot_id)     model_update = self.driver.create_volume_from_snapshot(volume,                                                            snapshot)

 

我们查看RBDDrivercreate_volume_from_snapshot()方法:

def create_volume_from_snapshot(self, volume, snapshot):     """Creates a volume from a snapshot."""     volume_update = self._clone(volume, self.configuration.rbd_pool,                                 snapshot.volume_name, snapshot.name)     if self.configuration.rbd_flatten_volume_from_snapshot:         self._flatten(self.configuration.rbd_pool, volume.name)     if int(volume.size):         self._resize(volume)     return volume_update

 

从代码中看出,从snapshot中创建快照分为3个步骤:

 

从rbd快照中执行clone操作。
如果rbd_flatten_volume_from_snapshot配置为True,则执行flatten操作。
如果创建中指定了size,则执行resize操作。

 

假设新创建的volume的uuid为e6bc8618-879b-4655-aac0-05e5a1ce0e06,快照的uuid为snapshot-e4e534fc-420b-45c6-8e9f-b23dcfcb7f86,快照的源volume uuid为bf2d1c54-6c98-4a78-9c20-3e8ea033c3db,指定的size为2,rbd_flatten_volume_from_snapshotFalse(默认值),则对应的rbd命令为:

 

rbd clone  openstack/volume-bf2d1c54-6c98-4a78-9c20-3e8ea033c3db@snapshot-e4e534fc-420b-45c6-8e9f-b23dcfcb7f86  openstack/volume-e6bc8618-879b-4655-aac0-05e5a1ce0e06 rbd resize --size 2048  openstack/volume-e6bc8618-879b-4655-aac0-05e5a1ce0e06

 

从源码上分析,Cinder从快照中创建volume时,用户可以配置是否执行flatten操作:

 

如果执行flatten操作,则从快照中创建volume可能需要数分钟的时间,创建后可以随时删除快照。
如果不执行flatten操作,则需要注意在删除所有基于该快照创建的volume之前,不能删除该快照,也不能删除快照的源volume。

 

第二点可能会更复杂,比如基于快照创建了一个volume,然后基于该volume又创建了快照,基于该快照创建了volume,则用户不能删除源volume,不能删除快照。

create from volume

从volume中创建volume,需要指定源volume id(source_volid):

def _create_from_source_volume(self, context, volume, source_volid,                                **kwargs):     srcvol_ref = objects.Volume.get_by_id(context, source_volid)     model_update = self.driver.create_cloned_volume(volume, srcvol_ref)

 

我们直接查看driver的create_cloned_volume()方法,该方法中有一个很重要的配置项rbd_max_clone_depth,即允许rbd image clone允许的最长深度,如果rbd_max_clone_depth <= 0,则表示不允许clone:

 

# Do full copy if requested if self.configuration.rbd_max_clone_depth <= 0:     with RBDVolumeProxy(self, src_name, read_only=True) as vol:         vol.copy(vol.ioctx, dest_name)         self._extend_if_required(volume, src_vref)     return 

 

此时相当于rbd的copy命令。

如果rbd_max_clone_depth > 0:

 

# Otherwise do COW clone. with RADOSClient(self) as client:     src_volume = self.rbd.Image(client.ioctx, src_name)     LOG.debug("creating snapshot='%s'", clone_snap)     try:         # Create new snapshot of source volume         src_volume.create_snap(clone_snap)         src_volume.protect_snap(clone_snap)         # Now clone source volume snapshot         LOG.debug("cloning '%(src_vol)s@%(src_snap)s' to "                   "'%(dest)s'",                   {'src_vol': src_name, 'src_snap': clone_snap,                    'dest': dest_name})         self.RBDProxy().clone(client.ioctx, src_name, clone_snap,                               client.ioctx, dest_name,                               features=client.features)

 

 

这个过程和创建虚拟机快照非常相似,二者都是先基于源image创建snapshot,然后基于snapshot执行clone操作,区别在于是否执行flatten操作,创建虚拟机快照时一定会执行flatten操作,而该操作则取决于clone深度:

 

depth = self._get_clone_depth(client, src_name) if depth >= self.configuration.rbd_max_clone_depth:         dest_volume = self.rbd.Image(client.ioctx, dest_name)         try:             dest_volume.flatten()         except Exception as e:             ...          try:             src_volume.unprotect_snap(clone_snap)             src_volume.remove_snap(clone_snap)         except Exception as e:             ...          

 

如果当前depth超过了允许的最大深度rbd_max_clone_depth则执行flatten操作,并删除创建的快照。

假设创建的volume uuid为3b8b15a4-3020-41a0-80be-afaa35ed5eef,源volume uuid为bf2d1c54-6c98-4a78-9c20-3e8ea033c3db,则对应的rbd命令为:

 

VOLID=3b8b15a4-3020-41a0-80be-afaa35ed5eef SOURCE_VOLID=bf2d1c54-6c98-4a78-9c20-3e8ea033c3db CINDER_POOL=openstack # Do full copy if rbd_max_clone_depth <= 0. if [[ "$rbd_max_clone_depth" -le 0 ]]; then     rbd copy ${CINDER_POOL}/volume-${SOURCE_VOLID} openstack/volume-${VOLID}     exit 0 fi # Otherwise do COW clone. # Create new snapshot of source volume rbd snap create  ${CINDER_POOL}/volume-${SOURCE_VOLID}@volume-${VOLID}.clone_snap rbd snap protect  ${CINDER_POOL}/volume-${SOURCE_VOLID}@volume-${VOLID}.clone_snap # Now clone source volume snapshot rbd clone  ${CINDER_POOL}/volume-${SOURCE_VOLID}@volume-${VOLID}.clone_snap  ${CINDER_POOL}/volume-${VOLID} # If dest volume is a clone and rbd_max_clone_depth reached, # flatten the dest after cloning. depth=$(get_clone_depth ${CINDER_POOL}/volume-${VOLID}) if [[ "$depth" -ge "$rbd_max_clone_depth" ]]; then     # Flatten destination volume      rbd flatten ${CINDER_POOL}/volume-${VOLID}     # remove temporary snap     rbd snap unprotect      ${CINDER_POOL}/volume-${SOURCE_VOLID}@volume-${VOLID}.clone_snap     rbd snap rm      ${CINDER_POOL}/volume-${SOURCE_VOLID}@volume-${VOLID}.clone_snap fi

 

rbd_max_clone_depth > 0depth < rbd_max_clone_depth时,通过rbd命令验证:

int32bit $ rbd info volume-3b8b15a4-3020-41a0-80be-afaa35ed5eef rbd image 'volume-3b8b15a4-3020-41a0-80be-afaa35ed5eef':         size 1024 MB in 256 objects         order 22 (4096 kB objects)         block_name_prefix: rbd_data.ae2e437c177a         format: 2         features: layering, exclusive-lock, object-map, fast-diff, deep-flatten         flags:         create_timestamp: Wed Nov 22 12:32:09 2017         parent: openstack/volume-bf2d1c54-6c98-4a78-9c20-3e8ea033c3db@volume-3b8b15a4-3020-41a0-80be-afaa35ed5eef.clone_snap         overlap: 1024 MB

 

 

可见volume-3b8b15a4-3020-41a0-80be-afaa35ed5eef的parent为:

 

volume-bf2d1c54-6c98-4a78-9c20-3e8ea033c3db@volume-3b8b15a4-3020-41a0-80be-afaa35ed5eef.clone_snap.

 

 

create from image

从镜像中创建volume,这里假定Glance和Cinder都使用的同一个Ceph集群,则Cinder可以直接从Glance中clone,不需要下载镜像:

 

def _create_from_image(self, context, volume,                        image_location, image_id, image_meta,                        image_service, **kwargs):     ...     model_update, cloned = self.driver.clone_image(         context,         volume,         image_location,         image_meta,         image_service)    ...

 

我们查看driver的clone_image()方法:

 

def clone_image(self, context, volume,                 image_location, image_meta,                 image_service):     # iterate all locations to look for a cloneable one.     for url_location in url_locations:         if url_location and self._is_cloneable(                 url_location, image_meta):             _prefix, pool, image, snapshot =                  self._parse_location(url_location)             volume_update = self._clone(volume, pool, image, snapshot)             volume_update['provider_location'] = None             self._resize(volume)             return volume_update, True     return ({}, False)

 

rbd直接clone,这个过程和创建虚拟机基本一致。如果创建volume时指定了新的大小,则调用rbd resize执行扩容操作。

假设新创建的volume uuid为87ee1ec6-3fe4-413b-a4c0-8ec7756bf1b4,glance image uuid为db2b6552-394a-42d2-9de8-2295fe2b3180,则rbd命令为:

rbd clone  openstack/db2b6552-394a-42d2-9de8-2295fe2b3180@snap  openstack/volume-87ee1ec6-3fe4-413b-a4c0-8ec7756bf1b4  if [[ -n "$size" ]]; then     rbd resize --size $size      openstack/volume-87ee1ec6-3fe4-413b-a4c0-8ec7756bf1b4 fi

 

通过rbd命令验证如下:

int32bit $ rbd info openstack/volume-87ee1ec6-3fe4-413b-a4c0-8ec7756bf1b4 rbd image 'volume-87ee1ec6-3fe4-413b-a4c0-8ec7756bf1b4':         size 3072 MB in 768 objects         order 22 (4096 kB objects)         block_name_prefix: rbd_data.affc488ac1a         format: 2         features: layering, exclusive-lock, object-map, fast-diff, deep-flatten         flags:         create_timestamp: Wed Nov 22 13:07:50 2017         parent: openstack/db2b6552-394a-42d2-9de8-2295fe2b3180@snap         overlap: 2048 MB

 

可见新创建的rbd image的parent为openstack/db2b6552-394a-42d2-9de8-2295fe2b3180@snap

 

注:其实我个人认为该方法需要执行flatten操作,否则当有volume存在时,Glance不能删除镜像,相当于Glance服务依赖于Cinder服务状态,这有点不合理。

4.3 创建快照

创建快照入口为cinder/volume/manager.pycreate_snapshot()方法,该方法没有使用taskflow框架,而是直接调用的driver create_snapshot()方法,如下:

... try:     utils.require_driver_initialized(self.driver)     snapshot.context = context     model_update = self.driver.create_snapshot(snapshot)     ... except Exception:     ...

 

RBDDrivercreate_snapshot()方法非常简单:

 

def create_snapshot(self, snapshot):     """Creates an rbd snapshot."""     with RBDVolumeProxy(self, snapshot.volume_name) as volume:         snap = utils.convert_str(snapshot.name)         volume.create_snap(snap)         volume.protect_snap(snap) 

 

因此volume的快照其实就是对应Ceph rbd image快照,假设snapshot uuid为e4e534fc-420b-45c6-8e9f-b23dcfcb7f86,volume uuid为bf2d1c54-6c98-4a78-9c20-3e8ea033c3db,则对应的rbd命令大致如下:

 

rbd -p openstack snap create  volume-bf2d1c54-6c98-4a78-9c20-3e8ea033c3db@snapshot-e4e534fc-420b-45c6-8e9f-b23dcfcb7f86 rbd -p openstack snap protect  volume-bf2d1c54-6c98-4a78-9c20-3e8ea033c3db@snapshot-e4e534fc-420b-45c6-8e9f-b23dcfcb7f86

 

从这里我们可以看出虚拟机快照和volume快照的区别,虚拟机快照需要从根磁盘rbd image快照中clone然后flatten,而volume的快照只需要创建rbd image快照,因此虚拟机快照通常需要数分钟的时间,而volume快照能够秒级完成。

4.4 创建volume备份

在了解volume备份之前,首先需要理清快照和备份的区别。我们可以通过git类比,快照类似git commit操作,只是表明数据提交了,主要用于回溯与回滚。当集群奔溃导致数据丢失,通常不能从快照中完全恢复数据。而备份则类似于git push,把数据安全推送到了远端存储系统中,主要用于保证数据安全,即使本地数据丢失,也能从备份中恢复。Cinder的磁盘备份也支持多种存储后端,这里我们只考虑volume和backup driver都是Ceph的情况,其它细节可以参考Cinder数据卷备份原理与实践。生产中volume和backup必须使用不同的Ceph集群,这样才能保证当volume ceph集群挂了,也能从另一个集群中快速恢复数据。本文只是为了测试功能,因此使用的是同一个Ceph集群,通过pool区分,volume使用openstackpool,而backup使用cinder_backuppool。

另外,Cinder支持增量备份,用户可以指定--incremental参数决定使用的是全量备份还是增量备份。但是对于Ceph后端来说,Cinder总是先尝试执行增量备份,只有当增量备份失败时,才会fallback到全量备份,而不管用户有没有指定--incremental参数。尽管如此,我们仍然把备份分为全量备份和增量备份两种情况,注意只有第一次备份才有可能是全量备份,剩下的备份都是增量备份。

全量备份(第一次备份)

我们直接查看CephBackupDriverbackup()方法,代码位于cinder/backup/drivers/ceph.py

 

 

if self._file_is_rbd(volume_file):     # If volume an RBD, attempt incremental backup.     LOG.debug("Volume file is RBD: attempting incremental backup.")     try:         updates = self._backup_rbd(backup, volume_file,                                    volume.name, length)     except exception.BackupRBDOperationFailed:         LOG.debug("Forcing full backup of volume %s.", volume.id)         do_full_backup = True 

 

 

这里主要判断源volume是否是rbd,即是否使用Ceph后端,只有当volume也使用Ceph存储后端情况下才能执行增量备份。

我们查看_backup_rbd()方法:

from_snap = self._get_most_recent_snap(source_rbd_image) base_name = self._get_backup_base_name(volume_id, diff_format=True) image_created = False with rbd_driver.RADOSClient(self, backup.container) as client:     if base_name not in self.rbd.RBD().list(ioctx=client.ioctx):         ...         # Create new base image         self._create_base_image(base_name, length, client)         image_created = True     else:         ...

 

from_snap为上一次备份时的快照点,由于我们这是第一次备份,因此from_snapNonebase_name格式为volume-%s.backup.base,这个base是做什么的呢?我们查看下_create_base_image()方法就知道了:

 

def _create_base_image(self, name, size, rados_client):     old_format, features = self._get_rbd_support()     self.rbd.RBD().create(ioctx=rados_client.ioctx,                           name=name,                           size=size,                           old_format=old_format,                           features=features,                           stripe_unit=self.rbd_stripe_unit,                           stripe_count=self.rbd_stripe_count)

 

可见base其实就是一个空卷,大小和之前的volume大小一致。

也就是说如果是第一次备份,在backup的Ceph集群首先会创建一个大小和volume一样的空卷。

我们继续看源码:

def _backup_rbd(self, backup, volume_file, volume_name, length):     ...     new_snap = self._get_new_snap_name(backup.id)     LOG.debug("Creating backup snapshot='%s'", new_snap)     source_rbd_image.create_snap(new_snap)      try:         self._rbd_diff_transfer(volume_name, rbd_pool, base_name,                                 backup.container,                                 src_user=rbd_user,                                 src_conf=rbd_conf,                                 dest_user=self._ceph_backup_user,                                 dest_conf=self._ceph_backup_conf,                                 src_snap=new_snap,                                 from_snap=from_snap)                              def _get_new_snap_name(self, backup_id):     return utils.convert_str("backup.%s.snap.%s"                              % (backup_id, time.time()))

 

首先在源volume中创建了一个新快照,快照名为backup.${backup_id}.snap.${timestamp},然后调用了rbd_diff_transfer()方法:

def _rbd_diff_transfer(self, src_name, src_pool, dest_name, dest_pool,                        src_user, src_conf, dest_user, dest_conf,                        src_snap=None, from_snap=None):     src_ceph_args = self._ceph_args(src_user, src_conf, pool=src_pool)     dest_ceph_args = self._ceph_args(dest_user, dest_conf, pool=dest_pool)      cmd1 = ['rbd', 'export-diff'] + src_ceph_args     if from_snap is not None:         cmd1.extend(['--from-snap', from_snap])     if src_snap:         path = utils.convert_str("%s/%s@%s"                                  % (src_pool, src_name, src_snap))     else:         path = utils.convert_str("%s/%s" % (src_pool, src_name))     cmd1.extend([path, '-'])      cmd2 = ['rbd', 'import-diff'] + dest_ceph_args     rbd_path = utils.convert_str("%s/%s" % (dest_pool, dest_name))     cmd2.extend(['-', rbd_path])      ret, stderr = self._piped_execute(cmd1, cmd2)     if ret:         msg = (_("RBD diff op failed - (ret=%(ret)s stderr=%(stderr)s)") %                {'ret': ret, 'stderr': stderr})         LOG.info(msg)         raise exception.BackupRBDOperationFailed(msg) 

 

 

方法调用了rbd命令,先通过export-diff子命令导出源rbd image的差量文件,然后通过import-diff导入到backup的image中。

假设源volume的uuid为075c06ed-37e2-407d-b998-e270c4edc53c,大小为1GB,backup uuid为db563496-0c15-4349-95f3-fc5194bfb11a,这对应的rbd命令大致如下:

VOLUME_ID=075c06ed-37e2-407d-b998-e270c4edc53c BACKUP_ID=db563496-0c15-4349-95f3-fc5194bfb11a rbd -p cinder_backup create  --size 1024  volume-${VOLUME_ID}.backup.base new_snap=volume-${VOLUME_ID}@backup.${BACKUP_ID}.snap.1511344566.67 rbd -p openstack snap create ${new_snap} rbd export-diff --pool openstack ${new_snap} -  | rbd import-diff --pool cinder_backup - volume-${VOLUME_ID}.backup.base

 

我们可以通过rbd命令验证如下:

 

# volume ceph cluster int32bit $ rbd -p openstack snap ls volume-075c06ed-37e2-407d-b998-e270c4edc53c SNAPID NAME                                                              SIZE TIMESTAMP     52 backup.db563496-0c15-4349-95f3-fc5194bfb11a.snap.1511344566.67 1024 MB Wed Nov 22 17:56:15 2017 # backup ceph cluster int32bit $ rbd -p cinder_backup ls -l NAME                                                                                                                   SIZE PARENT FMT PROT LOCK volume-075c06ed-37e2-407d-b998-e270c4edc53c.backup.base                                                                1024M 2 volume-075c06ed-37e2-407d-b998-e270c4edc53c.backup.base@backup.db563496-0c15-4349-95f3-fc5194bfb11a.snap.1511344566.67 1024M  2

 

从输出上看,源volume创建了一个快照,ID为52,在backup的Ceph集群中创建了一个空卷volume-075c06ed-37e2-407d-b998-e270c4edc53c.backup.base,并且包含一个快照backup.xxx.snap.1511344566.67,该快照是通过import-diff创建的。

增量备份

前面的过程和全量备份一样,我们直接跳到_backup_rbd()方法:

 

 

from_snap = self._get_most_recent_snap(source_rbd_image) with rbd_driver.RADOSClient(self, backup.container) as client:     if base_name not in self.rbd.RBD().list(ioctx=client.ioctx):         ...     else:         if not self._snap_exists(base_name, from_snap, client):             errmsg = (_("Snapshot='%(snap)s' does not exist in base "                         "image='%(base)s' - aborting incremental "                         "backup") %                       {'snap': from_snap, 'base': base_name})             LOG.info(errmsg)             raise exception.BackupRBDOperationFailed(errmsg)

 

首先获取源volume对应rbd image的最新快照最为parent,然后判断在backup的Ceph集群的base中是否存在相同的快照(根据前面的全量备份,一定存在和源volume一样的快照。

我们继续看后面的部分:

 

new_snap = self._get_new_snap_name(backup.id) source_rbd_image.create_snap(new_snap)  try:     before = time.time()     self._rbd_diff_transfer(volume_name, rbd_pool, base_name,                             backup.container,                             src_user=rbd_user,                             src_conf=rbd_conf,                             dest_user=self._ceph_backup_user,                             dest_conf=self._ceph_backup_conf,                             src_snap=new_snap,                             from_snap=from_snap)     if from_snap:         source_rbd_image.remove_snap(from_snap) 

 

这个和全量备份基本是一样的,唯一区别在于此时from_snap不是None,并且后面会删掉from_snap_rbd_diff_transfer方法可以翻前面代码。

假设源volume uuid为075c06ed-37e2-407d-b998-e270c4edc53c,backup uuid为e3db9e85-d352-47e2-bced-5bad68da853b,parent backup uuid为db563496-0c15-4349-95f3-fc5194bfb11a,则对应的rbd命令大致如下:

VOLUME_ID=075c06ed-37e2-407d-b998-e270c4edc53c BACKUP_ID=e3db9e85-d352-47e2-bced-5bad68da853b PARENT_ID=db563496-0c15-4349-95f3-fc5194bfb11a rbd -p openstack snap create  volume-${VOLUME_ID}@backup.${BACKUP_ID}.snap.1511348180.27  rbd export-diff  --pool openstack  --from-snap backup.${PARENT_ID}.snap.1511344566.67  openstack/volume-${VOLUME_ID}@backup.${BACKUP_ID}.snap.1511348180.27 -  | rbd import-diff --pool cinder_backup -  cinder_backup/volume-${VOLUME_ID}.backup.base rbd -p openstack snap rm  volume-${VOLUME_ID}.backup.base@backup.${PARENT_ID}.snap.1511344566.67

 

 

我们通过rbd命令验证如下:

 

int32bit $ rbd -p openstack snap ls volume-075c06ed-37e2-407d-b998-e270c4edc53c SNAPID NAME                                                              SIZE TIMESTAMP     53 backup.e3db9e85-d352-47e2-bced-5bad68da853b.snap.1511348180.27 1024 MB Wed Nov 22 18:56:20 2017 int32bit $ rbd -p cinder_backup ls -l NAME                                                                                                                    SIZE PARENT FMT PROT LOCK volume-075c06ed-37e2-407d-b998-e270c4edc53c.backup.base                                                                1024M          2 volume-075c06ed-37e2-407d-b998-e270c4edc53c.backup.base@backup.db563496-0c15-4349-95f3-fc5194bfb11a.snap.1511344566.67 1024M          2 volume-075c06ed-37e2-407d-b998-e270c4edc53c.backup.base@backup.e3db9e85-d352-47e2-bced-5bad68da853b.snap.1511348180.27 1024M          2

 

和我们分析的结果一致,源volume的快照会删除旧的而只保留最新的一个,backup则会保留所有的快照。

4.5 备份恢复

备份恢复是备份的逆过程,即从远端存储还原数据到本地。备份恢复的源码位于cinder/backup/drivers/ceph.pyrestore()方法,该方法直接调用了_restore_volume()方法,因此我们直接看_restore_volume()方法:

def _restore_volume(self, backup, volume, volume_file):     length = int(volume.size) * units.Gi      base_name = self._get_backup_base_name(backup.volume_id,                                            diff_format=True)     with rbd_driver.RADOSClient(self, backup.container) as client:         diff_allowed, restore_point =              self._diff_restore_allowed(base_name, backup, volume,                                        volume_file, client) 

 

其中_diff_restore_allowed()是一个非常重要的方法,该方法判断是否支持通过直接导入方式恢复,我们查看该方法实现:

 

def _diff_restore_allowed(self, base_name, backup, volume, volume_file,                           rados_client):     rbd_exists, base_name = self._rbd_image_exists(base_name,                                                    backup.volume_id,                                                    rados_client)     if not rbd_exists:         return False, None     restore_point = self._get_restore_point(base_name, backup.id)     if restore_point:         if self._file_is_rbd(volume_file):             if volume.id == backup.volume_id:                 return False, restore_point             if self._rbd_has_extents(volume_file.rbd_image):                 return False, restore_point             return True, restore_point

 

 

从该方法中我们可以看出支持差量导入方式恢复数据,需要满足以下所有条件:

 

backup集群对应volume的rbd base image必须存在。
恢复点必须存在,即backup base image对应的快照必须存在。
恢复目标的volume必须是RBD,即volume的存储后端也必须是Ceph。
恢复目标的volume必须是空卷,既不支持覆盖已经有内容的image。
恢复目标的volume uuid和backup的源volume uuid不能是一样的,即不能覆盖原来的volume。

 

换句话说,虽然Cinder支持将数据还复到已有的volume(包括源volume)中,但如果使用Ceph后端就不支持增量恢复,导致效率会非常低。

因此如果使用Ceph存储后端,官方文档中建议将备份恢复到空卷中(不指定volume),不建议恢复到已有的volume中

 

 

Note that Cinder supports restoring to a new volume or the original volume the backup was taken from. 
For the latter case, a full copy is enforced since this was deemed the safest action to take.
It is therefore recommended to always restore to a new volume (default).

 

这里假定我们恢复到空卷中,命令如下:

 

cinder backup-restore  --name int32bit-restore-1  e3db9e85-d352-47e2-bced-5bad68da853b

注意我们没有指定--volume参数。此时执行增量恢复,代码实现如下:

def _diff_restore_rbd(self, backup, restore_file, restore_name,                       restore_point, restore_length):     rbd_user = restore_file.rbd_user     rbd_pool = restore_file.rbd_pool     rbd_conf = restore_file.rbd_conf     base_name = self._get_backup_base_name(backup.volume_id,                                            diff_format=True)     before = time.time()     try:         self._rbd_diff_transfer(base_name, backup.container,                                 restore_name, rbd_pool,                                 src_user=self._ceph_backup_user,                                 src_conf=self._ceph_backup_conf,                                 dest_user=rbd_user, dest_conf=rbd_conf,                                 src_snap=restore_point)     except exception.BackupRBDOperationFailed:         raise     self._check_restore_vol_size(backup, restore_name, restore_length,                                  rbd_pool)

 

可见增量恢复非常简单,仅仅调用前面介绍的_rbd_diff_transfer()方法把backup Ceph集群对应的base image的快照export-diff到volume的Ceph集群中,并调整大小。

假设backup uuid为e3db9e85-d352-47e2-bced-5bad68da853b,源volume uuid为075c06ed-37e2-407d-b998-e270c4edc53c,目标volume uuid为f65cf534-5266-44bb-ad57-ddba21d9e5f9,则对应的rbd命令为:

 

BACKUP_ID=e3db9e85-d352-47e2-bced-5bad68da853b SOURCE_VOLUME_ID=075c06ed-37e2-407d-b998-e270c4edc53c DEST_VOLUME_ID=f65cf534-5266-44bb-ad57-ddba21d9e5f9 rbd export-diff --pool cinder_backup  cinder_backup/volume-${SOURCE_VOLUME_ID}.backup.base@backup.${BACKUP_ID}.snap.1511348180.27 -  | rbd import-diff --pool openstack -  openstack/volume-${DEST_VOLUME_ID} rbd -p openstack resize  --size ${new_size} volume-${DEST_VOLUME_ID} 

 

如果不满足以上5个条件之一,则Cinder会执行全量备份,全量备份就是一块一块数据写入:

def _transfer_data(self, src, src_name, dest, dest_name, length):     chunks = int(length / self.chunk_size)     for chunk in range(0, chunks):         before = time.time()         data = src.read(self.chunk_size)         dest.write(data)         dest.flush()         delta = (time.time() - before)         rate = (self.chunk_size / delta) / 1024         # yield to any other pending backups         eventlet.sleep(0)     rem = int(length % self.chunk_size)     if rem:         dest.write(data)         dest.flush()         # yield to any other pending backups         eventlet.sleep(0)

 

这种情况下效率很低,非常耗时,不建议使用。

5 总结

5.1 Glance

1. 上传镜像

 

 

rbd -p ${GLANCE_POOL} create --size ${SIZE} ${IMAGE_ID} rbd -p ${GLANCE_POOL} snap create ${IMAGE_ID}@snap rbd -p ${GLANCE_POOL} snap protect ${IMAGE_ID}@snap

 

2. 删除镜像

 

rbd -p ${GLANCE_POOL} snap unprotect ${IMAGE_ID}@snap rbd -p ${GLANCE_POOL} snap rm ${IMAGE_ID}@snap rbd -p ${GLANCE_POOL} rm ${IMAGE_ID} 

 

5.2 Nova

1 创建虚拟机

rbd clone  ${GLANCE_POOL}/${IMAGE_ID}@snap  ${NOVA_POOL}/${SERVER_ID}_disk

 

 

2 创建虚拟机快照

 

# Snapshot the disk and clone  # it into Glance's storage pool rbd -p ${NOVA_POOL} snap create  ${SERVER_ID}_disk@${RANDOM_UUID} rbd -p ${NOVA_POOL} snap protect  ${SERVER_ID}_disk@${RANDOM_UUID} rbd clone  ${NOVA_POOL}/${SERVER_ID}_disk@${RANDOM_UUID}  ${GLANCE_POOL}/${IMAGE_ID}  # Flatten the image, which detaches it from the  # source snapshot rbd -p ${GLANCE_POOL} flatten ${IMAGE_ID}  # all done with the source snapshot, clean it up rbd -p ${NOVA_POOL} snap unprotect  ${SERVER_ID}_disk@${RANDOM_UUID} rbd -p ${NOVA_POOL} snap rm  ${SERVER_ID}_disk@${RANDOM_UUID}  # Makes a protected snapshot called 'snap' on  # uploaded images and hands it out rbd -p ${GLANCE_POOL} snap create ${IMAGE_ID}@snap rbd -p ${GLANCE_POOL} snap protect ${IMAGE_ID}@snap

 

 

 

3 删除虚拟机

 

for image in $(rbd -p ${NOVA_POOL} ls | grep "^${SERVER_ID}"); do      rbd -p ${NOVA_POOL} rm "$image";  done 

 

 

5.3 Cinder

1 创建volume

(1) 创建空白卷

rbd -p ${CINDER_POOL} create  --new-format --size ${SIZE}  volume-${VOLUME_ID} 

 

(2) 从快照中创建

 

rbd clone  ${CINDER_POOL}/volume-${SOURCE_VOLUME_ID}@snapshot-${SNAPSHOT_ID}  ${CINDER_POOL}/volume-${VOLUME_ID} rbd resize --size ${SIZE}  openstack/volume-${VOLUME_ID} 

 

(3) 从volume中创建

 

# Do full copy if rbd_max_clone_depth <= 0. if [[ "$rbd_max_clone_depth" -le 0 ]]; then     rbd copy      ${CINDER_POOL}/volume-${SOURCE_VOLUME_ID}      ${CINDER_POOL}/volume-${VOLUME_ID}     exit 0 fi # Otherwise do COW clone. # Create new snapshot of source volume rbd snap create  ${CINDER_POOL}/volume-${SOURCE_VOLUME_ID}@volume-${VOLUME_ID}.clone_snap rbd snap protect  ${CINDER_POOL}/volume-${SOURCE_VOLUME_ID}@volume-${VOLUME_ID}.clone_snap # Now clone source volume snapshot rbd clone  ${CINDER_POOL}/volume-${SOURCE_VOLUME_ID}@volume-${VOLUME_ID}.clone_snap  ${CINDER_POOL}/volume-${VOLUME_ID} # If dest volume is a clone and rbd_max_clone_depth reached, # flatten the dest after cloning. depth=$(get_clone_depth ${CINDER_POOL}/volume-${VOLUME_ID}) if [[ "$depth" -ge "$rbd_max_clone_depth" ]]; then     # Flatten destination volume      rbd flatten ${CINDER_POOL}/volume-${VOLUME_ID}     # remove temporary snap     rbd snap unprotect      ${CINDER_POOL}/volume-${SOURCE_VOLUME_ID}@volume-${VOLUME_ID}.clone_snap     rbd snap rm      ${CINDER_POOL}/volume-${SOURCE_VOLUME_ID}@volume-${VOLUME_ID}.clone_snap fi

 

 

(4) 从镜像中创建

 

rbd clone  ${GLANCE_POOL}/${IMAGE_ID}@snap  ${CINDER_POOL}/volume-${VOLUME_ID} if [[ -n "${SIZE}" ]]; then     rbd resize --size ${SIZE} ${CINDER_POOL}/volume-${VOLUME_ID} fi

 

2 创建快照

 

rbd -p ${CINDER_POOL} snap create  volume-${VOLUME_ID}@snapshot-${SNAPSHOT_ID} rbd -p ${CINDER_POOL} snap protect  volume-${VOLUME_ID}@snapshot-${SNAPSHOT_ID} 

 

3 创建备份

(1) 第一次备份

 

rbd -p ${BACKUP_POOL} create  --size ${VOLUME_SIZE}  volume-${VOLUME_ID}.backup.base NEW_SNAP=volume-${VOLUME_ID}@backup.${BACKUP_ID}.snap.${TIMESTAMP} rbd -p ${CINDER_POOL} snap create ${NEW_SNAP} rbd export-diff ${CINDER_POOL}/volume-${VOLUME_ID}${NEW_SNAP} -  | rbd import-diff --pool ${BACKUP_POOL} -  volume-${VOLUME_ID}.backup.base

 

(2) 增量备份

 

rbd -p ${CINDER_POOL} snap create  volume-${VOLUME_ID}@backup.${BACKUP_ID}.snap.${TIMESTAMP}  rbd export-diff  --pool ${CINDER_POOL}  --from-snap backup.${PARENT_ID}.snap.${LAST_TIMESTAMP}  ${CINDER_POOL}/volume-${VOLUME_ID}@backup.${BACKUP_ID}.snap.${TIMESTRAMP} -  | rbd import-diff --pool ${BACKUP_POOL} -  ${BACKUP_POOL}/volume-${VOLUME_ID}.backup.base rbd -p ${CINDER_POOL} snap rm  volume-${VOLUME_ID}.backup.base@backup.${PARENT_ID}.snap.${LAST_TIMESTAMP} 

 

4 备份恢复

 

 

rbd export-diff --pool ${BACKUP_POOL}  volume-${SOURCE_VOLUME_ID}.backup.base@backup.${BACKUP_ID}.snap.${TIMESTRAMP} -  | rbd import-diff --pool ${CINDER_POOL} -  volume-${DEST_VOLUME_ID} rbd -p ${CINDER_POOL} resize  --size ${new_size} volume-${DEST_VOLUME_ID} 

 

参考:https://zhuanlan.zhihu.com/p/31581145

 

 

 

 

$ rbd -p openstack flatten int32bit-test-2 Image flatten: 31% complete...

文章标题:OpenStack使用Ceph存储,Ceph到底做了什么?
文章链接:https://www.dianjilingqu.com/3740.html
本文章来源于网络,版权归原作者所有,如果本站文章侵犯了您的权益,请联系我们删除,联系邮箱:saisai#email.cn,感谢支持理解。
THE END
< <上一篇
ES6
下一篇>>