OpenStack虚拟机创建快照实际上是将虚拟机的磁盘创建为一个新的镜像，其操作实际就是创建镜像，我们可以通过dashboard页面或者命令行来调用对应的接口，创建快照的基本流程如下：
一. 获取token（获取token接口）
二. 查询虚拟机状态（查询接口）
三. 创建虚拟机快照
可以通过OpenStack提供的CLI命令创建快照：
通过OpenStack Dashboard或者nova命令可以发起快照，快照命令格式：
nova image-create {server} {name}
下面的命令对id=814a8ad8-9217-4c45-91c7-c2be2016e5da的云主机执行快照，快照名称为snapshot1
nova image-create 814a8ad8-9217-4c45-91c7-c2be2016e5da snapshot1
也可以通过curl命令来调用对应的api接口：
curl -i http://186.100.8.214:8774/v2/814a8ad8-9217-4c45-91c7-c2be2016e5da/servers/6c2504f4-efa-47ec-b6f4-06a9fde8a00b/action -X POST -H "X-Auth-Project-Id: admin" -H "User-Agent: python-novaclient" -H "Content-Type: application/json" -H "Accept: application/json" -H "X-Auth-Token: " -d '{"createImage": {"name": " snapshot1", "metadata": {}}}'
可以看到，创建快照的实际操作关键词为“createImage”！
从镜像启动的云主机离线快照
1.1. nova-api部分
根据nova-api部分代码提供的API接口，结合使用curl命令调用创建快照的命令，我们可以很容易的知道快照函数入口是： nova/api/openstack/compute/servers.py/ServersController._action_create_image， 下面一起来看看代码：
@wsgi.response(202) @extensions.expected_errors((400, 403, 404, 409)) @wsgi.action('createImage') @common.check_snapshots_enabled@validation.schema(schema_servers.create_image, '2.0', '2.0') @validation.schema(schema_servers.create_image, '2.1')def _action_create_image(self, req, id, body): """Snapshot a server instance. 输入参数如下： req = Request对象，包含本次请求的上下文 id = 814a8ad8-9217-4c45-91c7-c2be2016e5da body = {u'createImage': {u'name': u'snapshot1', u'metadata': {}}} """ # 得到请求的上下文，并执行权限验证 context = req.environ['nova.context'] context.can(server_policies.SERVERS % 'create_image') # 从body中获取快照的名称及相关属性 entity = body["createImage"] image_name = common.normalize_name(entity["name"]) metadata = entity.get('metadata', {}) snapshot_id = entity.get("snapshot_id", None) # Starting from microversion 2.39 we don't check quotas on createImage if api_version_request.is_supported(req, max_version=api_version_request.MAX_IMAGE_META_PROXY_API_VERSION): common.check_img_metadata_properties_quota(context, metadata) # 从nova数据库中获取实例信息，包括：metadata，system_metadata，security_groups, # info_cache, flavor及pci_devices等属性信息，并返回一个Instance V2对象 instance = self._get_server(context, req, id) snapshot = snapshot_current(context, instance, self.compute_rpcapi) if snapshot: # if there are snapshots, then create an image with snashots. if not snapshot_id: snapshot_id = snapshot["id"] image = snapshot_create_image(context, snapshot_id, instance, self.compute_rpcapi, entity) else: # 从数据库中获取该实例关联的所有块设备，返回BlockDeviceMappingList对象 bdms = objects.BlockDeviceMappingList.get_by_instance_uuid(context, instance.uuid) try: if compute_utils.is_volume_backed_instance(context, instance, bdms): context.can(server_policies.SERVERS % 'create_image:allow_volume_backed') # 这里判断系统磁盘类型是否是volume,如果是，说明是从磁盘启动的实例 image = self.compute_api.snapshot_volume_backed( context, instance, image_name, extra_properties=metadata ) else: # 镜像启动的实例，执行快照走这个分支，调用：nova/compute/api.py/API执行快照 image = self.compute_api.snapshot(context, instance, image_name, extra_properties=metadata) except exception.InstanceUnknownCell as e: raise exc.HTTPNotFound(explanation=e.format_message()) except exception.InstanceInvalidState as state_error: common.raise_http_conflict_for_instance_invalid_state(state_error, 'createImage', id) except exception.Invalid as err: raise exc.HTTPBadRequest(explanation=err.format_message()) except exception.OverQuota as e: raise exc.HTTPForbidden(explanation=e.format_message()) # Starting with microversion 2.45 we return a response body containing # the snapshot image id without the Location header. if api_version_request.is_supported(req, '2.45'): return { 'image_id': image['id']} # build location of newly-created image entity image_id = str(image['id']) # 根据glance.conf配置，生成镜像url，我的例子中是： # http://$glance_host:$glance_port/images/'ffb841fd-d5f8-4146-bb29-b12eb5bbf6b2' image_ref = glance.generate_image_url(image_id) resp = webob.Response(status_int=202) resp.headers['Location'] = image_ref return resp
当执行镜像启动的快照后，就会调用nova/compute/api.py中的API.snapshot方法，代码分析如下：
@check_instance_cell@check_instance_state(vm_state=[vm_states.ACTIVE, vm_states.STOPPED, vm_states.PAUSED, vm_states.SUSPENDED])def snapshot(self, context, instance, name, extra_properties=None): """Snapshot the given instance. :param context: 请求上下文 :param instance: InstanceV2实例对象 :param name:快照名 ‘snapshot1’ :param extra_properties: dict of extra image properties to include when creating the image.快照属性 {} :returns: A dict containing image metadata """ """ 在glance数据库（images表）中添加一条类型为'snapshot'的条目， 每个properties属性作为一条记录添加到image_properties表； { 'status': u'queued', 'name': u'snapshot1', 'deleted': False, 'container_format': u'bare', 'created_at': datetime.datetime(2018,9,26,7,26,29,tzinfo=<iso8601.Utc>), 'disk_format': u'raw', 'updated_at': datetime.datetime(2018,9,26,7,26,29,tzinfo=<iso8601.Utc>), 'id': u'ffb841fd-d5f8-4146-bb29-b12eb5bbf6b2', 'owner': u'25520b29dce346d38bc4b055c5ffbfcb', 'min_ram': 0, 'checksum': None, 'min_disk': 20, 'is_public': False, 'deleted_at': None, 'properties': { u'image_type': u'snapshot', u'instance_uuid': u'814a8ad8-9217-4c45-91c7-c2be2016e5da', u'user_id': u'b652f9bd65844f739684a20ed77e9a0f', u'base_image_ref': u'e0cc468f-6501-4a85-9b19-70e782861387' }, 'size': 0 } """ # 调用glance api创建image entry，为后将snapshot上传为镜像做准备， # 虽然镜像和snapshot在可以上传到glance作为镜像启动虚拟机， # 但是为了区分二者的不同，glance将镜像和snapshot标记卫不同的类型：type=image 和 type=snapshot image_meta = self._create_image(context, instance, name, 'snapshot', extra_properties=extra_properties) # NOTE(comstud): Any changes to this method should also be made # to the snapshot_instance() method in nova/cells/messaging.py # 更新实例的状态为：镜像快照等待中 instance.task_state = task_states.IMAGE_SNAPSHOT_PENDING # 中间异常处理省略 instance.save(expected_task_state=[None]) # 通过rpc调用将消息‘snapshot_instance’投递到消息队列，nova-compute会接受该消息，做对应的处理 self.compute_rpcapi.snapshot_instance(context, instance, image_meta['id']) return image_meta
当代码走到self.compute_rpcapi.snapshot_instance(context, instance, image_meta['id'])，会调用rpc，发送一个创建快照的消息到消息队列，rpc消息部分代码如下：
def snapshot_instance(self, ctxt, instance, image_id): version = '4.0' cctxt = self.router.client(ctxt).prepare( server=_compute_host(None, instance), version=version) cctxt.cast(ctxt, 'snapshot_instance', instance=instance, image_id=image_id)
梳理下流程：
1. 用户发起create snapshot的请求;
2. nova-api服务接收到这个请求并进行前期处理，即api中的snapshot方法;
3. 真正的snapshot操作是需要在nova-compute节点上执行的，所以nova-api需要向nova-compute发送message；
由于OpenStack环境中会有很多个nova-compute,所以需要通过server=_compute_host(None, instance)来获取虚拟机所在的host，并向其发送message。
1.2. nova-compute部分
当nova-compute接收到来自nova-api发来的“snapshot_instance”快照请求后，nova-compute会调用 nova/compute/manager.py/ComputeManager.snapshot_instance方法处理该请求，如下：
@wrap_exception() @reverts_task_state@wrap_instance_fault@delete_image_on_errordef snapshot_instance(self, context, image_id, instance): """Snapshot an instance on this host. :param context: security context :param image_id: glance.db.sqlalchemy.models.Image.Id :param instance: a nova.objects.instance.Instance object 该方法实现很简单：设置实例任务状态后，直接将请求转交给_snapshot_instance方法处理 """ try: # 更新实例的状态为“快照中” instance.task_state = task_states.IMAGE_SNAPSHOT instance.save(expected_task_state=task_states.IMAGE_SNAPSHOT_PENDING) except exception.InstanceNotFound: # possibility instance no longer exists, no point in continuing LOG.debug("Instance not found, could not set state %s for instance.", task_states.IMAGE_SNAPSHOT, instance=instance) return except exception.UnexpectedDeletingTaskStateError: LOG.debug("Instance being deleted, snapshot cannot continue", instance=instance) return self._snapshot_instance(context, image_id, instance, task_states.IMAGE_SNAPSHOT)
snapshot_instance在做完基本处理后，实际上是调用self._snapshot_instance(context, image_id, instance, task_states.IMAGE_SNAPSHOT)来实现具体的快照功能，如下（去掉异常处理）：
def _snapshot_instance(self, context, image_id, instance, expected_task_state): context = context.elevated() # 获取虚拟机的电源状态 instance.power_state = self._get_power_state(context, instance) instance.save() LOG.info('instance snapshotting', instance=instance) # 若虚拟机处于非运行状态，记录告警日志 if instance.power_state != power_state.RUNNING: state = instance.power_state running = power_state.RUNNING LOG.warning('trying to snapshot a non-running instance: ' '(state: %(state)s expected: %(running)s)', { 'state': state, 'running': running}, instance=instance) # 通过“notifier”发送“snapshot.start”通知消息，改消息应该是投递给ceilometer self._notify_about_instance_usage(context, instance, "snapshot.start") compute_utils.notify_about_instance_action( context, instance, self.host, action=fields.NotificationAction.SNAPSHOT, phase=fields.NotificationPhase.START) # 实例状态更新辅助函数 def update_task_state(task_state, expected_state=expected_task_state): instance.task_state = task_state instance.save(expected_task_state=expected_state) # 调用LibvirtDriver.snapshot执行快照具体操作 self.driver.snapshot(context, instance, image_id, update_task_state) # 更新虚拟机的状态为None instance.task_state = None instance.save(expected_task_state=task_states.IMAGE_UPLOADING) # 通过“notifier”发送一个"snapshot.end"消息，通知ceilometer快照结束 self._notify_about_instance_usage(context, instance, "snapshot.end") compute_utils.notify_about_instance_action( context, instance, self.host, action=fields.NotificationAction.SNAPSHOT, phase=fields.NotificationPhase.END)
通过以上代码，可以看到执行快照实际上是调用libvirt的具体接口来做的，即调用“self.driver.snapshot”来做快照（代码位置：nova/virt/libvirt/driver.py/LibvirtDriver.snapshot）：
def snapshot(self, context, instance, image_id, update_task_state): """Create snapshot from a running VM instance. This command only works with qemu 0.14+ """ try: # 通过libvirt获取instance对应的virDomain对象 guest = self._host.get_guest(instance) virt_dom = guest._domain except exception.InstanceNotFound: raise exception.InstanceNotRunning(instance_id=instance.uuid) # 从glance数据库中获取快照的信息，该信息在调用nova-api时已经记录到数据库中 snapshot = self._image_api.get(context, image_id) # 这一步是要从实例的xml文件中解析出实例的磁盘信息，包括磁盘路径disk_path和磁盘格式 # source_format is an on-disk format，如raw disk_path, source_format = libvirt_utils.find_disk(guest) # source_type is a backend type，解析出该disk_path的后端存储类型，如rbd，或者思华的flexblock source_type = libvirt_utils.get_disk_type_from_path(disk_path) LOG.info('disk_path: %s', disk_path) # 修正后端存储类型及快照磁盘类型 # 如果未能从磁盘路径中解析出后端存储类型，就用磁盘格式类型作为后端类型 # 使用'snapshot_image_format '或者后端存储类型作为快照磁盘类型， # 如果快照类型为lvm或者rbd，就修改为raw格式 if source_type is None: source_type = source_format image_format = CONF.libvirt.snapshot_image_format or source_type if image_format == 'lvm' or image_format == 'rbd' or image_format == 'flexblock': image_format = 'raw' """根据系统盘镜像属性，快照属性及快照磁盘格式生成快照属性字典， 用来上传快照文件时更新glance数据库条目，属性字典信息如下： { 'status': 'active', 'name': u'snapshot1', 'container_format': u'bare', 'disk_format': 'raw', 'is_public': False, 'properties': { 'kernel_id': u'', 'image_location': 'snapshot', 'image_state': 'available', 'ramdisk_id': u'', 'owner_id': u'25520b29dce346d38bc4b055c5ffbfcb' } } """ metadata = self._create_snapshot_metadata(instance.image_meta, instance, image_format, snapshot['name']) # 本地的临时快照文件名 snapshot_name = uuid.uuid4().hex # 获取实例电源状态，用来判断是执行在线快照还是离线快照 state = guest.get_power_state(self._host) """判断是执行在线快照还是离线快照，在线快照需要同时满足下面的条件： 1. QEMU >= 1.3 && libvirt >= 1.0.0 2. nova后端存储非lvm或者rbd 3. 未开启外部存储加密功能 ephemeral_storage_encryption = False 4. 未关闭在线快照disable_libvirt_livesnapshot = False """ if (self._host.has_min_version(hv_type=host.HV_DRIVER_QEMU) and source_type not in ('lvm', 'rbd', 'flexblock') and not CONF.ephemeral_storage_encryption.enabled and not CONF.workarounds.disable_libvirt_livesnapshot): live_snapshot = True # Abort is an idempotent operation, so make sure any block # jobs which may have failed are ended. This operation also # confirms the running instance, as opposed to the system as a # whole, has a new enough version of the hypervisor (bug 1193146). try: guest.get_block_device(disk_path).abort_job() except libvirt.libvirtError as ex: error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_CONFIG_UNSUPPORTED: live_snapshot = False else: pass else:
# 比如后端存储使用的是ceph RBD，则执行的快照即为离线快照 live_snapshot = False # NOTE(rmk): We cannot perform live snapshots when a managedSave # file is present, so we will use the cold/legacy method # for instances which are shutdown.
# 在管理状态下执行离线快照 if state == power_state.SHUTDOWN: live_snapshot =False # 如果采取的是非“LXC”虚拟化，在执行并且实例处于运行或者暂停状态时，在快照前需要卸载pci设备及sriov端口 self._prepare_domain_for_snapshot(context, live_snapshot, state, instance) """ “_prepare_domain_for_snapshot”就是在判断底层虚拟化的类型和处理实例的设备,内容为： def _prepare_domain_for_snapshot(self, context, live_snapshot, state, instance): if CONF.libvirt.virt_type != 'lxc' and not live_snapshot: if state == power_state.RUNNING or state == power_state.PAUSED: self.suspend(context, instance) 调用到了suspend方法，来卸载pci设备和sriov端口： def suspend(self, context, instance): """Suspend the specified instance.""" guest = self._host.get_guest(instance) self._detach_pci_devices(guest, pci_manager.get_instance_pci_devs(instance)) self._detach_direct_passthrough_ports(context, instance, guest) guest.save_memory_state() """ root_disk = self.image_backend.by_libvirt_path(instance, disk_path, image_type=source_type) LOG.info('root_disk: %s', root_disk) # 显示不同类型快照的日志 if live_snapshot: LOG.info("Beginning live snapshot process", instance=instance) else: LOG.info("Beginning cold snapshot process", instance=instance) # 当在调用“driver.snapshot”时，会给snapshot传递一个辅助函数“update_task_state”，这里进行调用，实际上也就是更新一下虚拟机的状态为“IMAGE_PENDING_UPLOAD”和“IMAGE_UPLOADING”，然后更新metadata信息。 update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD) 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, exception.Forbidden) as e: if type(e) != NotImplementedError: LOG.warning('Performing standard snapshot because direct ' 'snapshot failed: %(error)s', { 'error': e}) failed_snap = metadata.pop('location', None) if failed_snap: failed_snap = { 'url': str(failed_snap)} root_disk.cleanup_direct_snapshot(failed_snap, also_destroy_volume=True, ignore_errors=True) update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD, expected_state=task_states.IMAGE_UPLOADING) # TODO(nic): possibly abstract this out to the root_disk if source_type in ('rbd','flexblock') and live_snapshot: # 当出现异常时（更新虚拟机状态时失败），将在线快照离线 # Standard snapshot uses qemu-img convert from RBD which is # not safe to run with live_snapshot. live_snapshot = False # Suspend the guest, so this is no longer a live snapshot self._prepare_domain_for_snapshot(context, live_snapshot, state, instance) # 从配置文件中获取生成本地快照的存放路径，例如/opt/nova/data/nova/instances/snapshots snapshot_directory = CONF.libvirt.snapshots_directory fileutils.ensure_tree(snapshot_directory) # 接着需要生成一个临时的目录 with utils.tempdir(dir=snapshot_directory) as tmpdir: try: # 拼接出完整的快照文件路径 out_path = os.path.join(tmpdir, snapshot_name) LOG.info('out_path: %s', out_path) if live_snapshot: # NOTE(xqueralt): libvirt needs o+x in the tempdir # 在线快照需要设定快照文件的访问权限为701 os.chmod(tmpdir, 0o701) self._live_snapshot(context, instance, guest, disk_path, out_path, source_format, image_format, instance.image_meta) # 调用后端存储驱动执行快照，Rbd.snapshot_extract，内部实现 # 调用'qemu-img convert'拷贝系统磁盘到out_path文件中，命令如下： """ qemu-img convert -O raw rbd:vms/814a8ad8-9217- 4c45-91c7-c2be2016e5da_disk:id=cinder: conf=/etc/ceph/ceph.conf' /opt/stack/data/nova/instances/snapshots/tmptR6hog/e44639af86434069b38f835847083697 """ else: root_disk.snapshot_extract(out_path, image_format) finally: # 上文卸载了pci设备及sriov端口，快照完成后需要重新挂载上 self._snapshot_domain(context, live_snapshot, virt_dom, state, instance) LOG.info("Snapshot extracted, beginning image upload", instance=instance) # Upload that image to the image service # 接着再次调用传递进来的辅助函数，更新实例的状态为“IMAGE_UPLOADING” update_task_state(task_state=task_states.IMAGE_UPLOADING, expected_state=task_states.IMAGE_PENDING_UPLOAD) # 最后一步，通过glance api将快照文件上传到后端存储，过程类似于上传镜像 with libvirt_utils.file_open(out_path, 'rb') as image_file: self._image_api.update(context, image_id, metadata, image_file) except Exception: with excutils.save_and_reraise_exception(): LOG.exception(_("Failed to snapshot image")) failed_snap = metadata.pop('location', None) if failed_snap: failed_snap = { 'url': str(failed_snap)} root_disk.cleanup_direct_snapshot(failed_snap, also_destroy_volume=True, ignore_errors=True) LOG.info("Snapshot image upload complete", instance=instance)
到这里，从镜像启动的云主机的离线快照就分析完了，总结如下：
l 快照时，需要先在本地生成临时快照，再上传到glance，效率比较低
l 快照过程中，云主机包括如下任何状态转换：（None）镜像快照等待中 -> 快照中 -> 等待镜像上传 -> 上传镜像中 -> None
l 如果nova以lvm或者ceph rbd做后端存储，则任何情况下都不支持在线快照
l openstack中的实例快照以镜像形式存储在glance中，不同于通常理解的快照用于数据恢复