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_error
def 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中，不同于通常理解的快照用于数据恢复