[源码分析]Kubernests-csi与Openstack-Cinder使用Ceph-rbd创建快照过程对比及源码分析

最新推荐文章于 2025-04-18 11:10:25 发布
最新推荐文章于 2025-04-18 11:10:25 发布
阅读量1.3k 收藏
点赞数 3
CC 4.0 BY-SA版权
分类专栏： ceph-rbd k8s-csi 文章标签： ceph go golang 云计算 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42015987/article/details/116756612

Kubernests-csi与Openstack-Cinder使用Ceph-rbd创建快照过程对比及源码分析


Ceph版本：v14.2.20（nautilus）
Cinder版本：v3.5.0（queens）
ceph-csi版本：release-v3.3

Cinder

cinder是开源项目openstack中提供块存储服务的子项目，该项目由python开发，主要是为虚拟机实例提供虚拟磁盘。

代码链接如下：
openstack/cinder:queens

  • 创建快照：
    代码位于 cinder/cinder/volume/drivers/rbd.py
    方法create_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)

过程很简单，

  1. 直接创建快照
  2. 然后对快照进行protect
  • 快照恢复卷
    代码位于 cinder/cinder/volume/drivers/rbd.py
    方法 create_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

过程也很简单，
1、直接克隆快照，
2、根据用户配置参数判断是否还原快照克隆出来的镜像
3、扩容等

  • 克隆卷
    代码位于 cinder/cinder/volume/drivers/rbd.py
    方法 create_cloned_volume
    def create_cloned_volume(self, volume, src_vref):
        """Create a cloned volume from another volume.

        Since we are cloning from a volume and not a snapshot, we must first
        create a snapshot of the source volume.

        The user has the option to limit how long a volume's clone chain can be
        by setting rbd_max_clone_depth. If a clone is made of another clone
        and that clone has rbd_max_clone_depth clones behind it, the dest
        volume will be flattened.
        """
        src_name = utils.convert_str(src_vref.name)
        dest_name = utils.convert_str(volume.name)
        clone_snap = "%s.clone_snap" % dest_name

        # 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

        # 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)
            except Exception as e:
                src_volume.unprotect_snap(clone_snap)
                src_volume.remove_snap(clone_snap)
                src_volume.close()
                msg = (_("Failed to clone '%(src_vol)s@%(src_snap)s' to "
                         "'%(dest)s', error: %(error)s") %
                       {'src_vol': src_name,
                        'src_snap': clone_snap,
                        'dest': dest_name,
                        'error': e})
                LOG.exception(msg)
                raise exception.VolumeBackendAPIException(data=msg)

            depth = self._get_clone_depth(client, src_name)
            # If dest volume is a clone and rbd_max_clone_depth reached,
            # flatten the dest after cloning. Zero rbd_max_clone_depth means
            # infinite is allowed.
            if depth >= self.configuration.rbd_max_clone_depth:
                LOG.info("maximum clone depth (%d) has been reached - "
                         "flattening dest volume",
                         self.configuration.rbd_max_clone_depth)
                dest_volume = self.rbd.Image(client.ioctx, dest_name)
                try:
                    # Flatten destination volume
                    LOG.debug("flattening dest volume %s", dest_name)
                    dest_volume.flatten()
                except Exception as e:
                    msg = (_("Failed to flatten volume %(volume)s with "
                             "error: %(error)s.") %
                           {'volume': dest_name,
                            'error': e})
                    LOG.exception(msg)
                    src_volume.close()
                    raise exception.VolumeBackendAPIException(data=msg)
                finally:
                    dest_volume.close()

                try:
                    # remove temporary snap
                    LOG.debug("remove temporary snap %s", clone_snap)
                    src_volume.unprotect_snap(clone_snap)
                    src_volume.remove_snap(clone_snap)
                except Exception as e:
                    msg = (_("Failed to remove temporary snap "
                             "%(snap_name)s, error: %(error)s") %
                           {'snap_name': clone_snap,
                            'error': e})
                    LOG.exception(msg)
                    src_volume.close()
                    raise exception.VolumeBackendAPIException(data=msg)

            try:
                volume_update = self._enable_replication_if_needed(volume)
            except Exception:
                self.RBDProxy().remove(client.ioctx, dest_name)
                src_volume.unprotect_snap(clone_snap)
                src_volume.remove_snap(clone_snap)
                err_msg = (_('Failed to enable image replication'))
                raise exception.ReplicationError(reason=err_msg,
                                                 volume_id=volume.id)
            finally:
                src_volume.close()

            self._extend_if_required(volume, src_vref)

        LOG.debug("clone created successfully")
        return volume_update

代码逻辑较长，我们只看重点

                src_volume.create_snap(clone_snap)
                src_volume.protect_snap(clone_snap)
                self.RBDProxy().clone(client.ioctx, src_name, clone_snap,
                                      client.ioctx, dest_name,
                                      features=client.features)

排除异常和改变默认参数设定后，仅为3步：
1、创建快照
2、保护快照
2、克隆快照

Ceph-csi

csi（Container StorageInterface）是开源项目Kubernetes从1.9版本开始引入容器存储接口，用于在Kubernetes和外部存储系统之间建立一套标准的存储管理接口，通过该接口为容器提供存储服务。

ceph-csi是开源分布式存储项目Ceph是Kubernetes-csi的一个具体实现项目，该项目由golang开发，即实现了rbd块存储，也实现了cephfs文件存储。
代码链接如下：
ceph-csi:release-v3.3

  • 创建快照
    代码位于internal/rbd/controllerserver.go
    函数入口为CreateSnapshot，我们直接关注重点函数 doSnapshotClone（函数名有些怪异，如果分析错了，请指正）
func (cs *ControllerServer) doSnapshotClone(ctx context.Context, parentVol *rbdVolume, rbdSnap *rbdSnapshot, cr *util.Credentials) (bool, *rbdVolume, error) {
	// generate cloned volume details from snapshot
	cloneRbd := generateVolFromSnap(rbdSnap)
	defer cloneRbd.Destroy()
	// add image feature for cloneRbd
	f := []string{librbd.FeatureNameLayering, librbd.FeatureNameDeepFlatten}
	cloneRbd.imageFeatureSet = librbd.FeatureSetFromNames(f)
	ready := false

	err := cloneRbd.Connect(cr)
	if err != nil {
		return ready, cloneRbd, err
	}

	err = createRBDClone(ctx, parentVol, cloneRbd, rbdSnap, cr)
	if err != nil {
		util.ErrorLog(ctx, "failed to create snapshot: %v", err)
		return ready, cloneRbd, status.Error(codes.Internal, err.Error())
	}

	defer func() {
		if err != nil {
			if !errors.Is(err, ErrFlattenInProgress) {
				// cleanup clone and snapshot
				errCleanUp := cleanUpSnapshot(ctx, cloneRbd, rbdSnap, cloneRbd, cr)
				if errCleanUp != nil {
					util.ErrorLog(ctx, "failed to cleanup snapshot and clone: %v", errCleanUp)
				}
			}
		}
	}()

	if parentVol.isEncrypted() {
		cryptErr := parentVol.copyEncryptionConfig(&cloneRbd.rbdImage)
		if cryptErr != nil {
			util.WarningLog(ctx, "failed copy encryption "+
				"config for %q: %v", cloneRbd.String(), cryptErr)
			return ready, nil, status.Errorf(codes.Internal,
				err.Error())
		}
	}

	err = cloneRbd.createSnapshot(ctx, rbdSnap)
	if err != nil {
		// update rbd image name for logging
		rbdSnap.RbdImageName = cloneRbd.RbdImageName
		util.ErrorLog(ctx, "failed to create snapshot %s: %v", rbdSnap, err)
		return ready, cloneRbd, err
	}

	err = cloneRbd.getImageID()
	if err != nil {
		util.ErrorLog(ctx, "failed to get image id: %v", err)
		return ready, cloneRbd, err
	}
	var j = &journal.Connection{}
	// save image ID
	j, err = snapJournal.Connect(rbdSnap.Monitors, rbdSnap.RadosNamespace, cr)
	if err != nil {
		util.ErrorLog(ctx, "failed to connect to cluster: %v", err)
		return ready, cloneRbd, err
	}
	defer j.Destroy()

	err = j.StoreImageID(ctx, rbdSnap.JournalPool, rbdSnap.ReservedID, cloneRbd.ImageID)
	if err != nil {
		util.ErrorLog(ctx, "failed to reserve volume id: %v", err)
		return ready, cloneRbd, err
	}

	err = cloneRbd.flattenRbdImage(ctx, cr, false, rbdHardMaxCloneDepth, rbdSoftMaxCloneDepth)
	if err != nil {
		if errors.Is(err, ErrFlattenInProgress) {
			return ready, cloneRbd, nil
		}
		return ready, cloneRbd, err
	}
	ready = true
	return ready, cloneRbd, nil
}

其中第一步，函数createRBDClone(ctx, parentVol, cloneRbd, rbdSnap, cr)过程较为复杂，需要展开分析，
代码位于internal/rbd/snapshot.go

func createRBDClone(ctx context.Context, parentVol, cloneRbdVol *rbdVolume, snap *rbdSnapshot, cr *util.Credentials) error {
	// create snapshot
	err := parentVol.createSnapshot(ctx, snap)
	if err != nil {
		util.ErrorLog(ctx, "failed to create snapshot %s: %v", snap, err)
		return err
	}

	snap.RbdImageName = parentVol.RbdImageName
	// create clone image and delete snapshot
	err = cloneRbdVol.cloneRbdImageFromSnapshot(ctx, snap)
	if err != nil {
		util.ErrorLog(ctx, "failed to clone rbd image %s from snapshot %s: %v", cloneRbdVol.RbdImageName, snap.RbdSnapName, err)
		err = fmt.Errorf("failed to clone rbd image %s from snapshot %s: %w", cloneRbdVol.RbdImageName, snap.RbdSnapName, err)
	}
	errSnap := parentVol.deleteSnapshot(ctx, snap)
	if errSnap != nil {
		util.ErrorLog(ctx, "failed to delete snapshot: %v", errSnap)
		delErr := deleteImage(ctx, cloneRbdVol, cr)
		if delErr != nil {
			util.ErrorLog(ctx, "failed to delete rbd image: %s with error: %v", cloneRbdVol, delErr)
		}
		return err
	}

	err = cloneRbdVol.getImageInfo()
	if err != nil {
		util.ErrorLog(ctx, "failed to get rbd image: %s details with error: %v", cloneRbdVol, err)
		delErr := deleteImage(ctx, cloneRbdVol, cr)
		if delErr != nil {
			util.ErrorLog(ctx, "failed to delete rbd image: %s with error: %v", cloneRbdVol, delErr)
		}
		return err
	}

	return nil
}

其中有很多校验和异常场景我们忽略，只看正常流程，
1、克隆

​ a、 源image创建快照

​ b、克隆快照

​ c、删除1.a创建的快照

2、用1.b克隆快照得到的image创建快照

3、还原1.b快照克隆出来的镜像

存疑：源码中未看到快照保护和解保护流程，而进行clone与删除操作。欢迎讨论与指正

  • 快照恢复
    代码位于 internal/rbd/controllerserver.go
    函数createVolumeFromSnapshot
func (cs *ControllerServer) createVolumeFromSnapshot(ctx context.Context, cr *util.Credentials, secrets map[string]string, rbdVol *rbdVolume, snapshotID string) error {
	rbdSnap := &rbdSnapshot{}
	if acquired := cs.SnapshotLocks.TryAcquire(snapshotID); !acquired {
		util.ErrorLog(ctx, util.SnapshotOperationAlreadyExistsFmt, snapshotID)
		return status.Errorf(codes.Aborted, util.VolumeOperationAlreadyExistsFmt, snapshotID)
	}
	defer cs.SnapshotLocks.Release(snapshotID)

	err := genSnapFromSnapID(ctx, rbdSnap, snapshotID, cr, secrets)
	if err != nil {
		if errors.Is(err, util.ErrPoolNotFound) {
			util.ErrorLog(ctx, "failed to get backend snapshot for %s: %v", snapshotID, err)
			return status.Error(codes.InvalidArgument, err.Error())
		}
		return status.Error(codes.Internal, err.Error())
	}

	// update parent name(rbd image name in snapshot)
	rbdSnap.RbdImageName = rbdSnap.RbdSnapName
	// create clone image and delete snapshot
	err = rbdVol.cloneRbdImageFromSnapshot(ctx, rbdSnap)
	if err != nil {
		util.ErrorLog(ctx, "failed to clone rbd image %s from snapshot %s: %v", rbdVol, rbdSnap, err)
		return err
	}

	util.DebugLog(ctx, "create volume %s from snapshot %s", rbdVol.RequestName, rbdSnap.RbdSnapName)
	return nil
}

过程比较简单，只是clone快照

  • 克隆卷
    代码位于 internal/rbd/clone.gp
    函数 createCloneFromImage
func (rv *rbdVolume) createCloneFromImage(ctx context.Context, parentVol *rbdVolume) error {
	// generate temp cloned volume
	tempClone := rv.generateTempClone()
	// snapshot name is same as temporary cloned image, This helps to
	// flatten the temporary cloned images as we cannot have more than 510
	// snapshots on an rbd image
	tempSnap := &rbdSnapshot{}
	tempSnap.RbdSnapName = tempClone.RbdImageName
	tempSnap.Pool = rv.Pool

	cloneSnap := &rbdSnapshot{}
	cloneSnap.RbdSnapName = rv.RbdImageName
	cloneSnap.Pool = rv.Pool

	var (
		errClone   error
		errFlatten error
		err        error
	)
	var j = &journal.Connection{}

	j, err = volJournal.Connect(rv.Monitors, rv.RadosNamespace, rv.conn.Creds)
	if err != nil {
		return status.Error(codes.Internal, err.Error())
	}
	defer j.Destroy()

	// create snapshot and temporary clone and delete snapshot
	err = createRBDClone(ctx, parentVol, tempClone, tempSnap, rv.conn.Creds)
	if err != nil {
		return err
	}

	defer func() {
		if err != nil || errClone != nil {
			cErr := cleanUpSnapshot(ctx, tempClone, cloneSnap, rv, rv.conn.Creds)
			if cErr != nil {
				util.ErrorLog(ctx, "failed to cleanup image %s or snapshot %s: %v", cloneSnap, tempClone, cErr)
			}
		}

		if err != nil || errFlatten != nil {
			if !errors.Is(errFlatten, ErrFlattenInProgress) {
				// cleanup snapshot
				cErr := cleanUpSnapshot(ctx, parentVol, tempSnap, tempClone, rv.conn.Creds)
				if cErr != nil {
					util.ErrorLog(ctx, "failed to cleanup image %s or snapshot %s: %v", tempSnap, tempClone, cErr)
				}
			}
		}
	}()
	// flatten clone
	errFlatten = tempClone.flattenRbdImage(ctx, rv.conn.Creds, false, rbdHardMaxCloneDepth, rbdSoftMaxCloneDepth)
	if errFlatten != nil {
		return errFlatten
	}
	// create snap of temp clone from temporary cloned image
	// create final clone
	// delete snap of temp clone
	errClone = createRBDClone(ctx, tempClone, rv, cloneSnap, rv.conn.Creds)
	if errClone != nil {
		// set errFlatten error to cleanup temporary snapshot and temporary clone
		errFlatten = errors.New("failed to create user requested cloned image")
		return errClone
	}
	err = rv.getImageID()
	if err != nil {
		util.ErrorLog(ctx, "failed to get volume id %s: %v", rv, err)
		return err
	}

	if parentVol.isEncrypted() {
		err = parentVol.copyEncryptionConfig(&rv.rbdImage)
		if err != nil {
			return fmt.Errorf("failed to copy encryption config for %q: %w", rv, err)
		}
	}
	err = j.StoreImageID(ctx, rv.JournalPool, rv.ReservedID, rv.ImageID)
	if err != nil {
		util.ErrorLog(ctx, "failed to store volume %s: %v", rv, err)
		return err
	}
	return nil
}

函数createRBDClone(ctx, parentVol, cloneRbd, rbdSnap, cr)过程较为复杂，需要展开分析，
代码位于internal/rbd/snapshot.go

func createRBDClone(ctx context.Context, parentVol, cloneRbdVol *rbdVolume, snap *rbdSnapshot, cr *util.Credentials) error {
	// create snapshot
	err := parentVol.createSnapshot(ctx, snap)
	if err != nil {
		util.ErrorLog(ctx, "failed to create snapshot %s: %v", snap, err)
		return err
	}

	snap.RbdImageName = parentVol.RbdImageName
	// create clone image and delete snapshot
	err = cloneRbdVol.cloneRbdImageFromSnapshot(ctx, snap)
	if err != nil {
		util.ErrorLog(ctx, "failed to clone rbd image %s from snapshot %s: %v", cloneRbdVol.RbdImageName, snap.RbdSnapName, err)
		err = fmt.Errorf("failed to clone rbd image %s from snapshot %s: %w", cloneRbdVol.RbdImageName, snap.RbdSnapName, err)
	}
	errSnap := parentVol.deleteSnapshot(ctx, snap)
	if errSnap != nil {
		util.ErrorLog(ctx, "failed to delete snapshot: %v", errSnap)
		delErr := deleteImage(ctx, cloneRbdVol, cr)
		if delErr != nil {
			util.ErrorLog(ctx, "failed to delete rbd image: %s with error: %v", cloneRbdVol, delErr)
		}
		return err
	}

	err = cloneRbdVol.getImageInfo()
	if err != nil {
		util.ErrorLog(ctx, "failed to get rbd image: %s details with error: %v", cloneRbdVol, err)
		delErr := deleteImage(ctx, cloneRbdVol, cr)
		if delErr != nil {
			util.ErrorLog(ctx, "failed to delete rbd image: %s with error: %v", cloneRbdVol, delErr)
		}
		return err
	}

	return nil
}

1、克隆

​ a、 源image创建快照

​ b、克隆快照

​ c、删除1.a创建的快照

2、还原1.b快照克隆出来的镜像

3、克隆

​ a、 第2步还原得到的景象创建快照

​ b、克隆快照

​ c、删除3.a创建的快照

对比

对比项openstack-cinder-rbdkubernets-ceph-csi-rbd
开发语言pythongolang
复杂程度简单复杂
创建快照1、直接创建快照1、克隆
a、 源image创建快照
b、克隆快照
c、删除1.a创建的快照
2、用1.b克隆快照得到的image创建快照
3、还原1.b快照克隆出来的镜像
快照恢复1、快照克隆1、快照克隆
卷克隆1、创建快照
2、快照克隆		1、克隆
a、 源image创建快照
b、克隆快照
c、删除1.a创建的快照
2、还原1.b快照克隆出来的镜像
3、克隆
a、 第2步还原得到的景象创建快照
b、克隆快照
c、删除3.a创建的快照
耦合强度强耦合无耦合
Openstack liberty 中Cinder-api启动过程源码分析1
梦幻之巅
08-17 2320
在前面的博文中，主要分析了Glance及Nova相关的代码，从这篇文章开始我将转到Cinder的源码分析上来。Cinder模块在Openstack中为云主机提供块存储，主要包含：cinder-api,cinder-scheduler,cinder-volume及cinder-backup4个部分，后续将通过一系列文章逐个分析各个组件的源码。今天先来看看cinder-api启动过程的源码分析，预计将包
OpenStack cinder对接Ceph存储实验全过程
netcode100的博客
09-19 1732
Cinder-Ceph实验对接教程主要涉及到如何在OpenStack环境中配置Cinder以使用Ceph作为存储后端。Ceph是一个高性能、可扩展的分布式存储系统，而Cinder是OpenStack中的块存储服务，负责为虚拟机提供可扩展的块设备存储。
OpenStack Cinder源码分析之三
溜溜小哥
12-31 5361
同前~~~
Cinder常用命令
qq_57515401的博客
04-18 371
【代码】Cinder常用命令。
Openstack liberty 中Cinder-api启动过程源码分析2
梦幻之巅
08-19 2534
在前一篇博文中，我分析了cinder-api启动过程中WSGI应用的加载及路由的建立过程，本文将分析WSGI服务器的启动及其接收客户端请求并完成方法映射的过程，请看下文的分析内容：
【OpenStack Liberty】cinder创建卷过程源码解析
Wallace_Hsia的博客
02-03 1341
本文主要对cinder创建volume的主要调用点进行了梳理，篇幅较长，跟着文档阅读代码效果更佳～以上就是cinder创建volume的主要调用流程，仅仅贴上主要代码及注释，中间各项细节加载可以根据这个方向去仔细看，本文不再贴出。如有错误欢迎指教😘后面有更好的想法再补充。
OpenStack的Cinder服务开启快照功能的配置
ranweizheng的专栏
09-23 776
背景 实验环境，虚拟机中安装了swift，并使用NFS作为backend存储。默认未开启快照功能，当使用命令创建快照时，会报错并提示。 解决 参考文档：https://docs.openstack.org/cinder/rocky/configuration/block-storage/drivers/nfs-volume-driver.html 在存储节点上 sudo vi /etc/cinde...
cinder与ceph的区别_openstack-Cinder配置多Ceph后端步骤
weixin_39817122的博客
12-20 624
cinder backendopenstack与ceph集群的关联是通过cinder进行关联，cinder后端可以连接多种的 backend，配置多个backend连接类型，以实现openstack关联多个ceph集群环境准备openstack controller节点openstack compute1节点openstack compute2节点ceph 集群 ceph_sata(机械硬盘)ce...
Openstack平台Cinder后端存储对接Ceph
mo666777的博客
12-30 979
Opentack平台Cinder后端存储对接Ceph
Openstack Cinder Ceph(RBD)备份恢复过程(backup/restore)
余亚飞
09-24 2088
概要： 本节我们讨论openstack cinder volume rbd驱动的 backup/restore操作。 Backup 是将 volume 备份到别的地方（备份设备），将来可以通过 restore 操作恢复。 Backup VS Snapshot Backup 与 snapshot 都可以保存 volume 的当前状态，以备以后恢复。但二者在用途和实现上还是有区别的，具体表现在： S...
cinder与ceph的区别_云计算/云存储---Ceph和Openstack的cinder模块对接方法
weixin_39758048的博客
12-20 290
1.创建存储池在ceph节点中执行如下语句。#ceph osd pool create volumes 1282.配置 OPENSTACK 的 CEPH 客户端在ceph节点两次执行如下语句，两次{your-openstack-server}分别填控制节点和计算节点IP。如果显示在控制节点和计算节点中没有ceph文件夹，则在两节点中创建对应文件夹。#ssh {your-openstack-serv...
ceph快照分析
06-11
ceph的基本的特性之一，就是支持rbd的snapshot和clone功能。Ceph都可以完成秒级别的快照。 ceph支持两种类型的快照，一种poo snaps，也就是是pool级别的快照，是给整个pool中的对象整体做一个快照。另一个是self managed snaps. 目前rbd的快照就这类，用户写时必须自己提供SnapContex信息
ceph 之 快照
Dayu_log的博客
05-02 1554
ceph之RBD快照
openstack cinder volume创建流程以及源码分析(三)
一名运维开发工程师的日常记录
04-07 322
CreateVolumeFromSpecTask 中又根据创建类型，是普通volume，还是image，还是备份还是快照等动作会有区别，这里已使用ceph的image创建为例，最终调用rbd的 _clone 函数clone 出一个块设备，最终resize 一下大小，同时更新根据image 元数据更新volume相关信息，最终更新volume 数据库相关信息。CreateVolumeOnFinishTask 当volume创建完之后，更新volume 数据库状态信息。支持volume 已经创建完成！
基于ceph快照快速回滚openstack上的虚拟机
吴业亮的专栏
05-17 2063
作者：【吴业亮】 博客：http://blog.csdn.net/wylfengyujiancheng 查看虚拟机ID [root@node1 ~]# nova list --all | grep wyl | dc828fed-1c4f-4e5d-ae84-795a0e71eecc | wyl | ac33d3bc8fe54f52a2cc822adec7fe62 | ACTIVE ...
openstack cinder：快照VS备份
hhp_hhp的专栏
10-16 8069
块存储快照块存储的着重点是记录某个时间点卷的状态，特点是创建速度快。cinder-volume服务中实现了基于多种存储驱动的块存储备份，在打快照前，卷需要是available状态（即不能被挂载），并且快照对卷具有强依赖性。所以一旦卷打了快照，便不能直接被删除，需要先删除该卷关联的所有快照。对于卷快照的使用，可以基于卷快照生成一个新的卷，所以卷快照在实际生产中用来恢复到某个时间的状态，不过一旦快照关联
cinder与ceph的区别_配置cinder-volume服务使用ceph作为后端存储
weixin_39988930的博客
12-20 355
在ceph监视器上执行CINDER_PASSWD='cinder1234!'controllerHost='controller'RABBIT_PASSWD='0penstackRMQ'1.创建pool池为cinder-volume服务创建pool池(因为我只有一个OSD节点，所以要将副本数设置为1)ceph osd pool create cinder-volumes 32ceph osd po...
Kubernetes + CSI + opensds 学习笔记
YRZLL的博客
07-10 1813
1. Kubernetes是什么    Kubernetes是一种容器编排系统，又称k8s，是google整理了15年来borg的运行经验构建的新的开源产品。主要用于管理云上的多个主机上的容器化应用。能高效地满足用户的绝大多数需求。2. 什么是容器    容器不是简单的存储容器，可以理解为在主机或虚拟机上运行的应用程序。Docker将应用程序的可执行文件、命令都打包在一起，成为镜像（image），...
创建卷快照的源码分析
weixin_30344131的博客
06-13 869
基于ocata版本，创建快照的代码流程梳理 1、用户下发创建快照的命令 cinder --debug snapshot-create ee514adb-4e05-4ede-876a-c9a9d95cc1da curl -g -i -X POST http://10.27.244.33:8776/v2/ec5405bdbcd243bbaf5b40093181ff70/snapshots ...
快速部署的openstack与ceph-deploy部署的ceph集群对接
最新发布
05-23
### OpenStack与Ceph-deploy部署的Ceph集群对接配置指南 #### 1. 准备工作 在将OpenStack与通过`ceph-deploy`部署的Ceph集群进行对接之前，需确保以下条件已满足： - 已完成Ceph集群的正常部署并验证其功能[^1]。 - OpenStack环境已完成基本安装，并能够正常运行。 - 网络连通性：Ceph集群中的Monitor节点和OSD节点应能与OpenStack控制节点通信。 #### 2. 配置Ceph客户端环境 为了使OpenStack能够访问Ceph存储池，需要在OpenStack环境中设置Ceph客户端的相关参数。具体操作如下： ##### （1）复制Ceph配置文件至OpenStack节点 将Ceph集群的配置文件`ceph.conf`以及密钥环文件`ceph.client.admin.keyring`从Ceph管理节点拷贝到OpenStack控制节点和其他相关计算节点上： ```bash scp /etc/ceph/ceph.conf root@<openstack-control-node>:/etc/ceph/ scp /etc/ceph/ceph.client.admin.keyring root@<openstack-control-node>:/etc/ceph/ ``` ##### （2）修改权限 确保Ceph配置文件和密钥环文件具有适当的安全权限： ```bash chmod 644 /etc/ceph/ceph.conf chmod 600 /etc/ceph/ceph.client.admin.keyring chown ceph:ceph /etc/ceph/ceph.* ``` #### 3. 创建RBD Pool供OpenStack使用 创建一个新的RADOS Block Device (RBD) pool来专门服务于OpenStack实例的数据存储需求： ```bash ceph osd pool create volumes 128 128 replicated ``` 其中，“volumes”为新创建的pool名称；后面的两个数值分别表示副本数量和PG数（Placement Groups）。可以根据实际硬件资源调整这些参数[^2]。 #### 4. 修改Glance服务以支持Ceph作为镜像后端 编辑Glance的服务配置文件 `/etc/glance/glance-api.conf` ，添加或更新以下部分： ```ini [glance_store] stores = rbd, file default_store = rbd rbd_pool = images rbd_ceph_conf = /etc/ceph/ceph.conf rbd_user = glance rbd_secret_uuid = <uuid> ``` 注意替换 `<uuid>` 字段为你生成的实际UUID值。如果尚未存在名为 `images` 的pool，则先创建它： ```bash ceph osd pool create images 128 128 replicated ``` 接着，在数据库中注册该用户的secret key以便后续认证过程顺利进行： ```sql INSERT INTO secrets VALUES ('<uuid>', '<base64-encoded-secret>'); ``` 最后重启Glance API服务使其生效： ```bash systemctl restart openstack-glance-api.service ``` #### 5. Nova组件启用libvirt驱动程序连接Ceph RBD 对于Nova而言，默认情况下会利用libvirt库实现虚拟机磁盘映射到远程块设备的功能。因此我们需要确认nova-compute服务已经加载了必要的模块并且正确指向我们的Ceph集群地址。 打开 `/etc/nova/nova.conf` 文件查找 `[libvirt]` 节点下的选项做相应更改： ```ini [libvirt] disk_cachemodes="network=writeback" hw_disk_discard='unmap' inject_password=false inject_key=false inject_partition=-2 live_migration_flag=VIR_MIGRATE_UNDEFINE_SOURCE,VIR_MIGRATE_PEER2PEER,VIR_MIGRATE_LIVE,VIR_MIGRATE_TUNNELLED volume_clear=zero volume_clear_size=0 cpu_mode=host-passthrough image_backend=rbd rbd_pool=volumes rbd_user=cinder rbd_secret_uuid=<same-as-above> rados_mon_hosts=node01,node02,node03 ``` 同样记得把占位符替换成真实数据源信息之后保存退出再重新启动对应进程即可应用改动效果： ```bash systemctl daemon-reload && systemctl restart libvirtd nova-compute ``` #### 6. Cinder卷插件激活RBD类型持久化存储方案 为了让用户可以请求动态分配额外空间给自己的云服务器实例用作临时扩展用途或者长期归档资料之需的话还需要进一步配置好cinder-volume服务才行啊！ 前往路径 `/etc/cinder/cinder.conf` 查找合适位置追加下面几行内容进去吧： ```ini [cinder-ceph] enabled_backends = rbd backend_name = rbd volume_driver = cinder.volume.drivers.rbd.RBDDriver rbd_pool = volumes rbd_user = cinder rbd_secret_uuid = <same-as-above> flavor_id = auto auth_enabled = true keyring_conf_path = /etc/ceph/ceph.client.cinder.keyring report_discard_supported = True ``` 再次强调一遍哦~这里的用户名密码组合应该跟前面提到过的保持一致哈！另外由于涉及到跨域身份校验机制的缘故所以最好提前准备好相应的证书材料以免到时候遇到麻烦事呢😊 最终别忘了同步一下最新的元数据记录表单结构形式呀~ ```bash su -s /bin/sh -c "cinder-manage db sync" cinder ``` 至此整个流程就算大功告成了🎉 不过还是强烈建议大家按照官方文档指引逐步检验每一步骤的结果准确性从而最大程度降低潜在风险隐患的发生概率哟~ --- ###
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值