OpenStack创建虚拟机流程

OpenStack创建虚拟机流程

 

云主机创建流程图：

dashboard发创建云主机的请求是先到novaclient，再由novaclient以http的形式发送到nova-api端，我们这里直接从nova端讲起，通过wsgi映射匹配，API映射匹配可以看我的另一篇博客：OpenStack Restful API框架介绍

创建云主机会首先调用到nova/api/openstack/compute/servers.py文件中的create()函数：

@wsgi.response(202)
@extensions.expected_errors((400, 403, 409))
@validation.schema(schema_server_create_v20, '2.0', '2.0')
@validation.schema(schema_server_create, '2.1', '2.18')
@validation.schema(schema_server_create_v219, '2.19', '2.31')
@validation.schema(schema_server_create_v232, '2.32', '2.36')
@validation.schema(schema_server_create_v237, '2.37', '2.41')
@validation.schema(schema_server_create_v242, '2.42')
def create(self, req, body):
    """Creates a new server for a given user."""
    ......
    # 前面的代码主要是做了传进参数的检查、转换和操作的权限检查，同时获取镜像
    # id和flavor对象，这些处理完后会调用：
    (instances, resv_id) = self.compute_api.create(context,
                                inst_type,
                                image_uuid,
                                display_name=name,
                                display_description=description,
                                availability_zone=availability_zone,
                                forced_host=host, forced_node=node,
                                metadata=server_dict.get('metadata', {}),
                                admin_password=password,
                                requested_networks=requested_networks,
                                check_server_group_quota=True,
                                group_id=server_dict.get('group_id', None),
                                os_type=server_dict.get('os_type', None),
                                boot_type='legacy',
                                store_id=server_dict.get('store_id', None),
                                enable_ha=server_dict.get('enable_ha', None),
                                thinputer_extra=server_dict.get('thinputer_extra', None),
                                **create_kwargs)

 

这里是调用到了nova/compute/api.py文件中的create函数

该函数进行网络是否有不合规操作，比如多个云主机却只指定了一个ip，检查可用域，生成过滤字典，然后调用_create_instance方法

主要是初始化一些参数，检查和检验参数和配额方面的检查，生成instances、request_specs和build_requests对象，request_specs和build_requests对象用以调度选择，instances用以返回给客户端，值可看注解，接着函数调用：

self.compute_task_api.schedule_and_build_instances(
                context,
                build_requests=build_requests,
                request_spec=request_specs,
                image=boot_meta,
                admin_password=admin_password,
                injected_files=injected_files,
                requested_networks=requested_networks,
                block_device_mapping=block_device_mapping)

 

实现文件是在nova/conductor/api.py，该api.py其实是对同级下的rpcapi.py做了层封装，真正实现在rpcapi.py文件。

api.py中的：

def schedule_and_build_instances(self, context, build_requests,
                                     request_spec, image,
                                     admin_password, injected_files,
                                     requested_networks, block_device_mapping):
        self.conductor_compute_rpcapi.schedule_and_build_instances(
            context, build_requests, request_spec, image,
            admin_password, injected_files, requested_networks,
            block_device_mapping)

 

这里调用了rpcapi.py中的schedule_and_build_instances方法：

def schedule_and_build_instances(self, context, build_requests,
                                      request_specs,
                                      image, admin_password, injected_files,
                                      requested_networks,
                                      block_device_mapping):
        version = '1.16'
        kw = {'build_requests': build_requests,
              'request_specs': request_specs,
              'image': jsonutils.to_primitive(image),
              'admin_password': admin_password,
              'injected_files': injected_files,
              'requested_networks': requested_networks,
              'block_device_mapping': block_device_mapping}

        cctxt = self.client.prepare(version=version)
        cctxt.cast(context, 'schedule_and_build_instances', **kw)

 

这里是远程调用到了nova/conductor/manager.py中的schedule_and_build_instances函数：

def schedule_and_build_instances(self, context, build_requests,
                                     request_specs, image,
                                     admin_password, injected_files,
                                     requested_networks, block_device_mapping):
        legacy_spec = request_specs[0].to_legacy_request_spec_dict()
        try:
            hosts = self._schedule_instances(context, legacy_spec,
                        request_specs[0].to_legacy_filter_properties_dict())
            ..........

 

这个函数主要前面部分主要是先通过scheduler选择合适的host，然后是将要创建的虚拟机的信息写入到数据库中，最后是调用build_and_run_instance函数，该函数实现是在nova/compute_rpcapi.py：

def build_and_run_instance(self, ctxt, instance, host, image, request_spec,
            filter_properties, admin_password=None, injected_files=None,
            requested_networks=None, security_groups=None,
            block_device_mapping=None, node=None, limits=None):

        version = '4.0'
        cctxt = self.router.by_host(ctxt, host).prepare(
                server=host, version=version)
        cctxt.cast(ctxt, 'build_and_run_instance', instance=instance,
                image=image, request_spec=request_spec,
                filter_properties=filter_properties,
                admin_password=admin_password,
                injected_files=injected_files,
                requested_networks=requested_networks,
                security_groups=security_groups,
                block_device_mapping=block_device_mapping, node=node,
                limits=limits)

 

通过host参数远程调用指定宿主机的build_and_run_instance方法，实现文件在nova/compute/manage.py：

@wrap_exception()
@reverts_task_state
@wrap_instance_fault
def build_and_run_instance(self, context, instance, image, request_spec,
                 filter_properties, admin_password=None,
                 injected_files=None, requested_networks=None,
                 security_groups=None, block_device_mapping=None,
                 node=None, limits=None):

    @utils.synchronized(instance.uuid)
    def _locked_do_build_and_run_instance(*args, **kwargs):
        # NOTE(danms): We grab the semaphore with the instance uuid
        # locked because we could wait in line to build this instance
        # for a while and we want to make sure that nothing else tries
        # to do anything with this instance while we wait.
        with self._build_semaphore:
            self._do_build_and_run_instance(*args, **kwargs)

    # NOTE(danms): We spawn here to return the RPC worker thread back to
    # the pool. Since what follows could take a really long time, we don't
    # want to tie up RPC workers.
    utils.spawn_n(_locked_do_build_and_run_instance,
                  context, instance, image, request_spec,
                  filter_properties, admin_password, injected_files,
                  requested_networks, security_groups,
                  block_device_mapping, node, limits)

这里的关键点是调用到了_do_build_and_run_instance函数，该函数的关键代码是调用了_build_and_run_instance函数来创建：

def _build_and_run_instance(self, context, instance, image, injected_files,
            admin_password, requested_networks, security_groups,
            block_device_mapping, node, limits, filter_properties):
    ..........

    # 这个函数的主要功能有进行事件通知、获取所需资源、创建好网络设备和磁盘设备，最
    # 后是通过配置文件的driver选定以哪种虚拟化方式实现虚拟机的生成，这里调用的函数是：
    self.driver.spawn(context, instance, image_meta,
                                              injected_files, admin_password,
                                              network_info=network_info,
                                              block_device_info=block_device_info)

 

对应的函数实现在nova/virt/libvirt/driver.py：

def spawn(self, context, instance, image_meta, injected_files,
              admin_password, network_info=None, block_device_info=None):
        disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,
                                            instance,
                                            image_meta,
                                            block_device_info)
        injection_info = InjectionInfo(network_info=network_info,
                                       files=injected_files,
                                       admin_pass=admin_password)
        gen_confdrive = functools.partial(self._create_configdrive,
                                          context, instance,
                                          injection_info)
        self._create_image(context, instance, disk_info['mapping'],
                           injection_info=injection_info,
                           block_device_info=block_device_info)

        # Required by Quobyte CI
        self._ensure_console_log_for_instance(instance)

        # 生成libvirt所需的xml文件
        xml = self._get_guest_xml(context, instance, network_info,
                                  disk_info, image_meta,
                                  block_device_info=block_device_info)
        self._create_domain_and_network(
            context, xml, instance, network_info, disk_info,
            block_device_info=block_device_info,
            post_xml_callback=gen_confdrive,
            destroy_disks_on_failure=True,
            power_on=False)
        LOG.debug("Instance is running", instance=instance)

 

在该函数中主要的功能是生成镜像、生成xml信息，最后调用_create_domain_and_network函数进行挂载上磁盘、网络初始化和虚拟机域生成。

虚拟机域生成通过调用了_create_domain函数来实现

 

总结下，虚拟机的创建流程如下：

（1）用户首先通过Restful Api向keystone组件获取认证信息

（2）然后向nova-api进程发送一个创建虚拟机的请求，并携带获取的认证信息和创建虚拟机的参数

（3）nova-api将认证信息发送到keystone里认证是否是有效的认证信息

（4）通过认证后且nova-api检查权限通过后向数据库写入新建虚拟机的数据库记录

（5）nova-api通过发消息到消息队列让nova-conductor去创建虚拟机

（6）nova-conductor通过发消息到消息队列让nova-scheduler筛选和选择可创建虚拟机的节点

（7）nova-scheduler返回经过筛选的可用宿主机给nova-conductor

（8）nova-conductor通过发消息到消息队列请求让目标节点nova-compute服务创建虚拟机

（9）nova-compute服务发消息到消息队列让控制节点上的nova-conductor服务获取要新建的虚拟机的元数据信息，比如内存、cpu等信息

（10）nova-compute获取到新建虚拟机的元数据信息后，为虚拟机分配资源，比如cpu、内存资源

（11）请求镜像服务获取新建虚拟机的镜像信息和创建镜像文件

（12）如果有网卡和数据盘创建请求，则会分别向neutron和cinder服务请求创建对应的资源

（13）虚拟机域的生成，如果是libvirt的driver，定义好虚拟机的XML信息

（14）初始化虚拟网络设备并启动虚拟机