精华内容
下载资源
问答
  • nova evacuate功能分析

    2021-08-05 15:46:59
    nova evacuate [--password <password>] <server> [<host>] 参数详解: <server> 故障计算节点上的虚拟机 <host> 目标计算节点的名称或ID。如果没有指定特定的计算节点,则...

    宕机疏散对外呈现的命令行

    nova evacuate [--password <password>] <server> [<host>]

    参数详解:

    <server> 故障计算节点上的虚拟机

    <host> 目标计算节点的名称或ID。如果没有指定特定的计算节点,则nova scheduler调度器随机选择选择一个可用的计算节点

    password <password> 设置宕机疏散后虚机的登录密码

    Part 2

    nova evacuate应用场景

    nova evacuate 的应用场景主要是,当虚拟机所在nova-compute计算节点出现宕机后,虚拟机可以通过nova evacuate将虚拟机从宕机的nova-compute计算节点迁移至其它可用的计算节点上。当原compute节点再重新恢复后,会对疏散后的虚机进行删除。

    Part 3

    nova evacuate代码梳理

    当nova接受到用户下发的nova evacuate请求时,nova各模块处理的主体流程如下:

    • 1) nova-api服务接受用户请求,对用户的请求参数进行有效性校验,然后向nova-conductor服务发送rpc请求,把处理流程交给nova-conductor服务进行处理

    • 2) nova-conductor服务接受到rpc消息后,根据用户下发的参数进行不同逻辑判断,如果用户没有指定特定的计算节点,那么会进一步的调用nova-scheduler服务,来选择一个可用的计算节点

    • 3) nova-conductor服务给选中的nova-compute计算节点发送cast类型的rpc消息,交由具体的计算节点来进行处理

    • 4) nova-compute节点接受到rpc消息后,进行虚机的创建操作

    Part 4

    nova-api服务阶段

    nova-api服务执行api目录下代码阶段

    • 1)用户下发 nova evacuate 命令时,使用post方法,给nova-api服务发送http请求,http body体里面,使用的action动作为 evacuate

    • 2)获取http请求body体里面的内容,从而获取 host,force,password,on_shared_storage,这些参数的值

    • 3)如果指定了host 参数的值,那么首先判断该host节点是否存在,如果不存在的话,那么抛出找不到该Host的异常,存在的话,执行第四步

    • 4)如果指定的Host,与虚机所在的host相同,那么抛出异常,不允许指定的计算节点与虚机的host相同

    D:\tran_code\nova_v1\nova\api\openstack\compute\evacuate.py

        def _evacuate(self, req, id, body):

            """Permit admins to evacuate a server from a failed host

            to a new one.

            """

            context = req.environ["nova.context"]

            instance = common.get_instance(self.compute_api, context, id)

            context.can(evac_policies.BASE_POLICY_NAME,

                        target={'user_id': instance.user_id,

                                'project_id': instance.project_id})

            evacuate_body = body["evacuate"]

            host = evacuate_body.get("host")

            force = None

            ..........

            if host is not None:

                try:

                    self.host_api.service_get_by_compute_host(context, host)

                except (exception.ComputeHostNotFound,

                        exception.HostMappingNotFound):

                    msg = _("Compute host %s not found.") % host

                    raise exc.HTTPNotFound(explanation=msg)

            if instance.host == host:

                msg = _("The target host can't be the same one.")

                raise exc.HTTPBadRequest(explanation=msg)

            try:

                self.compute_api.evacuate(context, instance, host,

                                          on_shared_storage, password, force)

            except exception.InstanceUnknownCell as e:

                raise exc.HTTPNotFound(explanation=e.format_message())

            .......

    nova-api服务执行compute目录模块代码阶段

    • 1)获取虚机的host信息

    • 2)判断虚机Host的nova-compue服务是否处于Up状态,如果是Up状态,那么就抛出一个异常(宕机疏散,只有在虚机所在节点宕机的情况下,才进行宕机疏散的),不在执行后续的操作,如果非up,那么执行3以下步骤

    • 3)创建Migration表,来记录该虚机宕机疏散的操作信息,便于后续函数,获取该虚机的信息

    • 4)如果指定了特定host主机,那么把这个host更新到migration的dest_compute字段里面

    • 5)根据虚机的 uuid,获取虚机的request_spec信息。在T版本中,虚机的request_spect内容,存放在nova_api.request_specs表spec字段里面

    • 6)如果指定了目标主机,但是不强制进行宕机疏散的话,把host参数置为none,由nova-scheduler随机选择一个可有的计算节点

    这个函数,只用了instance, host, on_shared_storage,admin_password=None, force=None,recreate=True这五个参数,其他的参数没有用,使用默认值,传递给nova conductor服务的rebuild_instance方法

    代码逻辑如下:

    D:\tran_code\nova_v1\nova\compute\api.py

        def evacuate(self, context, instance, host, on_shared_storage,

                     admin_password=None, force=None):

            LOG.debug('vm evacuation scheduled', instance=instance)

    获取虚机的所在host节点

            inst_host = instance.host

    根据虚机的host来获取其nova-compute service信息

            service = objects.Service.get_by_compute_host(context, inst_host)

    对虚机所在的nova-compute节点状态进行判断,宕机疏散是在虚机所在的nova-compute节点为down的情况下,疏散的,

    因此如果虚机所在的nova-compute服务为up,会抛出异常

            if self.servicegroup_api.service_is_up(service):

                LOG.error('Instance compute service state on %s '

                          'expected to be down, but it was up.', inst_host)

                raise exception.ComputeServiceInUse(host=inst_host)

            设置虚机的任务状态为rebuiding,重建状态

            instance.task_state = task_states.REBUILDING

            instance.save(expected_task_state=[None])

            self._record_action_start(context, instance, instance_actions.EVACUATE)

    创建这个migration记录,是为源计算节点创建一个醒目标志,为了找到它及以后清理,这个参数不会通过参数的形式,下发下去,迁移的类型为evacuate

            migration = objects.Migration(context,

                                          source_compute=instance.host,

                                          source_node=instance.node,

                                          instance_uuid=instance.uuid,

                                          status='accepted',

                                          migration_type='evacuation')

    如果指定了目标主机,那么把目标主机记录到Migration表里面

            if host:

                migration.dest_compute = host

            migration.create()

            compute_utils.notify_about_instance_usage(

                self.notifier, context, instance, "evacuate")

            try:

                request_spec = objects.RequestSpec.get_by_instance_uuid(

                    context, instance.uuid)

            except exception.RequestSpecNotFound:

                # Some old instances can still have no RequestSpec object attached

                # to them, we need to support the old way

                request_spec = None

            # NOTE(sbauza): Force is a boolean by the new related API version

    如果不强制进行宕机疏散并且还强制指定了特定的host主机,那么就走这段逻辑,其他情况是,不走。

            if force is False and host:

                nodes = objects.ComputeNodeList.get_all_by_host(context, host)

                # NOTE(sbauza): Unset the host to make sure we call the scheduler

    虽然形参赋值了,但是在这里把host赋值为空,让它走nova-scheduler调度

                host = None

                # FIXME(sbauza): Since only Ironic driver uses more than one

                # compute per service but doesn't support evacuations,

                # let's provide the first one.

                target = nodes[0]

                if request_spec:

                    destination = objects.Destination(

                        host=target.host,

                        node=target.hypervisor_hostname

                    )

                    request_spec.requested_destination = destination

            return self.compute_task_api.rebuild_instance(context,

                           instance=instance,

                           new_pass=admin_password,

                           injected_files=None,

                           image_ref=None,

                           orig_image_ref=None,

                           orig_sys_metadata=None,

                           bdms=None,

                           recreate=True,

                           on_shared_storage=on_shared_storage,

                           host=host,

                           request_spec=request_spec,

                           )

    Part 5

    nova-conductor服务阶段

    nova-conductor服务接受到nova-api发送的rpc请求以后,nova-conductor阶段 manager.py阶段处理

    1) 根据虚机的uuid,获取虚机的migrantion表信息

    2) 对传入的Host进行不同逻辑判断

    3) host有值的情景

    • 第一种情景:在虚机原始的host上,使用虚机原始的镜像进行重建rebuild;

    • 第二种情景:指定特定的主机,并且进行强制的宕机疏散。

    这两种情况下,node这个参数是为空的

    4) host无值的情况

    三种情景:

    • 第一种情景:要么没有指定主机进行宕机疏散;

    • 第二种情景:要么指定主机了,但是没有进行强制宕机疏散;

    • 第三种情景:要么就是在虚机所在主机上,使用新的镜像进行rebuild重建虚机。

    在nova-scheduler的过程中,instance的host是会被排除的,避免选择到这个相同的主机,这种情况下,选择目标主机后,host和Node是非空的,host用于设置消息的目标主机路由参数,node用于后续函数中。

    5) 给nova-compute服务发送rpc请求

    代码逻辑如下:

    D:\tran_code\nova_v1\nova\conductor\manager.py

        def rebuild_instance(self, context, instance, orig_image_ref, image_ref,

                             injected_files, new_pass, orig_sys_metadata,

                             bdms, recreate, on_shared_storage,

                             preserve_ephemeral=False, host=None,

                             request_spec=None):

            with compute_utils.EventReporter(context, 'rebuild_server', instance.uuid):

                node = limits = None

                try:

    根据虚机的Uuid,来获取到虚机的migration表信息,如果没有找到,那么抛异常

                    migration = objects.Migration.get_by_instance_and_status(

                        context, instance.uuid, 'accepted')

                except exception.MigrationNotFoundByStatus:

                    LOG.debug("No migration record for the rebuild/evacuate "

                              "request.", instance=instance)

                    migration = None

                有两种情况,host变量是被传递的,

    第一种是虚机的host被传递过去,要在虚机所在的主机上进行重建,这个会跳过nova scheduler调度器;

    虚机重建有两种情况,一种是虚机使用原始的镜像,另一种是虚机使用非原始镜像

    第二种情况,在指定特定的目标主机,并且强制疏散的情况下,那么就不通过nova scheduler调度器

                if host:

                    # We only create a new allocation on the specified host if

                    # we're doing an evacuate since that is a move operation.

                    if host != instance.host:

                        self._allocate_for_evacuate_dest_host(

                            context, instance, host, request_spec)

                else:

    在相同的主机上使用新的镜像进行重建或者指定特定的主机,进行宕机疏散,但是不强制

    没有指定request_spec的情况下,根据虚机的镜像信息,来构造image元数据,并且来构造request_spec信息

                    if not request_spec:

                        filter_properties = {'ignore_hosts': [instance.host]}

                        # build_request_spec expects a primitive image dict

                        image_meta = nova_object.obj_to_primitive(

                            instance.image_meta)

                        request_spec = scheduler_utils.build_request_spec(

                                context, image_meta, [instance])

                        request_spec = objects.RequestSpec.from_primitives(

                            context, request_spec, filter_properties)

                    elif recreate:宕机疏散是要走这个的

    通过在RequestSpec中增加source host来排除调度器调度到它

                        # NOTE(sbauza): Augment the RequestSpec object by excluding

                        # the source host for avoiding the scheduler to pick it

                        request_spec.ignore_hosts = [instance.host]排除掉虚机的host

                        # NOTE(sbauza): Force_hosts/nodes needs to be reset

                        # if we want to make sure that the next destination

                        # is not forced to be the original host

                        request_spec.reset_forced_destinations()

                    try:

                        request_spec.ensure_project_id(instance)

    nova scheduler服务,根据request_spec来调度选择一个可用的计算节点

                        hosts = self._schedule_instances(context, request_spec,

                                                         [instance.uuid])

                        host_dict = hosts.pop(0)

                        host, node, limits = (host_dict['host'],

                                              host_dict['nodename'],

                                              host_dict['limits'])

    .......

                compute_utils.notify_about_instance_usage(

                    self.notifier, context, instance, "rebuild.scheduled")

                instance.availability_zone = (

                    availability_zones.get_host_availability_zone(

                        context, host))

                self.compute_rpcapi.rebuild_instance(context,

                        instance=instance,

                        new_pass=new_pass,

                        injected_files=injected_files,

                        image_ref=image_ref,

                        orig_image_ref=orig_image_ref,

                        orig_sys_metadata=orig_sys_metadata,

                        bdms=bdms,

                        recreate=recreate,

                        on_shared_storage=on_shared_storage,

                        preserve_ephemeral=preserve_ephemeral,

                        migration=migration, 此时传递了migration这个结构体

                        host=host, node=node, limits=limits)

    Part 6

    目标节点的nova-compute 服务阶段

    nova-compute阶段 manager.py阶段

    • 1) 根据recreate值来区分是nova evacuate宕机疏散操作还是nova rebuild操作

    • 2) Recreate参数为真的情况下,nova evacuate宕机疏散,recreate为假的情况下,nova rebuild操作

    • 3) 根据选择的sceduler node 来对目标节点进行资源申请

    • 4) 获取虚机的镜像信息

    • 5) 根据虚机的uuid,读取 block_device_mapping 表来获取虚机的块设备信息,

    • 6) 获取虚机的网络信息

    • 7) 把虚机的块设备进行卸载

    • 8) 因为libvirt没有实现rebuild驱动,所以实际调用了_rebuild_default_impl方法来实现,宕机疏散和rebuild重建

    • 9) 如果是宕机疏散nova evacuate操作,那么就在目标节点上,调用spawn驱动,进行新建操作

    • 10) 如果是rebuild操作,那么先在目标节点上destory虚机,然后再调用spawn驱动,进行新建操作,如果是evacuate操作,那么直接进行重建虚机

    整个nova-compute服务调用的主要函数流程如下:

    rebuild_instance------->

    _do_rebuild_instance_with_claim----->

    _do_rebuild_instance----->

    _rebuild_default_impl

    展开全文
  • Nova服务安装配置

    千次阅读 2017-05-09 16:28:08
    Openstack项目中的Nova计算服务是IaaS云计算平台的核心服务组件,控制着虚拟机实例和网络功能,通过对用户和项目的设置,管理对Openstack云资源的访问。Nova计算服务组件没有创建新的虚拟化技术(如KVM或Xen等虚拟化...

    Openstack项目中的Nova计算服务是IaaS云计算平台的核心服务组件,控制着虚拟机实例和网络功能,通过对用户和项目的设置,管理对Openstack云资源的访问。Nova计算服务组件没有创建新的虚拟化技术(如KVM或Xen等虚拟化技术)而是定义了与底层虚拟化技术进行交互的各种驱动,从而实现更多功能,通过基于Web的API将这些功能公开。

    一,安装和配置控制节点

    准备:

    在安装和配置Nova计算服务组件之前,首先创建数据库、服务证书和API endpoint

    (1)创建数据库

    1,在操作系统终端连接数据库

    2,创建Nova数据库

    3,Nova数据库的访问权限设置

    4,退出数据库

    (2)加载admin用户的环境变量

    (3)创建认证服务凭据

    1,创建Nova用户

    2,将admin role赋予Nova user和service project

    3,创建Nova的service entity

    4,创建Nova服务组件的API endpoint

    (4)安装和配置Nova服务组件

    1)安装软件包

    2)编辑文件/etc/nova/nova.conf,完成如下操作

    1,配置数据库连接[database]...connection

    2,在[DEFAULT]和[oslo_messaging_rabbit],配置RabbitMQ消息队列连接

    3,在[DEFAULT]和[keystone_authtoken]项,配置keystone身份认证服务组件访问

    4,在[DEFAULT]项配置my_ip参数为控制节点的管理/数据网络IP地址

    5,在[DEFAULT],定义Nova支持的Neutron网络服务组件

    6,在[vnc]项,配置VNC使用控制节点的管理/数据网络IP地址

    7,在[GLANCE]项,定义Glance镜像服务组件所在的主机节点

    8,在[oslo_concurrency]项,配置lock路径

    9,在[DEFAULT]项,停止使用EC2 API

    10,打开日志记录功能,方便问题跟踪和解决

    二,安装和配置计算节点

    详细介绍如何在计算节点上安装和配置Nova计算服务组件,Nova计算服务组件支持多种虚拟化技术,如KVM、XEN和QEMU等,Nova计算服务组件支持横向扩展,以利用自动化工具以同样的方式安装和配置多个节点,每个计算节点都需要一个唯一的IP地址,下面以QEMU虚拟化技术进行配置

    (1)安装软件包

    (2)编辑文件/etc/nova/nova.conf,完成如下操作

    1,在[DEFAULT]和[oslo_messaging_rabbit],配置RabbitMQ消息队列连接

    2,在[DEFAULT]和[keystone_authtoken]项,配置keystone身份认证服务组件访问

    3,在[DEFAULT]项配置my_ip参数为控制节点的管理/数据网络IP地址,如果有多个计算节点,则以此类推

    4,在[DEFAULT],定义Nova支持的Neutron网络服务组件

    5,在[vnc]项,定义和配置远程控制台访问

    6,在[GLANCE]项,定义Glance镜像服务组件所在的主机节点

    7,在[oslo_concurrency]项,配置lock路径

    8,打开日志记录功能,方便问题跟踪和解决

    (3)加载nbd内核模块

    (4)编辑文件/etc/modules-load.d/nbd.conf,确保每次操作系统重启,能够自动加载nbd模块

    (5)检查Compute Node是否支持硬件加速


    展开全文
  • Nova服务-VNC服务

    2019-09-16 22:19:04
    nova-novncproxy的功能 将公网(public network)和私网(private network)隔离 vnc client运行在公网上,vnc server运行在私网上 vnc proxy作为连接二者的桥梁 通过token对vnc client进行验证 可以同时支持...

    VNC 访问方式原理

    VNC访问方式:
    host_ip:port,比如221.130.253.135:1
    如何获得虚拟机对应的vnc port?
    vncdisplay domain_id
    客户端软件: vnc viewer,tightVNC等等
    VNC 访问原理:
    基于RFB协议,即Remote FrameBuffer protocol
    有两部分组成:vnc server和vnc client
    Server和client端共享图形界面

    由两个服务构成:nova-novncproxy和nova-consoleauth
    nova-novncproxy的功能
    将公网(public network)和私网(private network)隔离
    vnc client运行在公网上,vnc server运行在私网上
    vnc proxy作为连接二者的桥梁
    通过token对vnc client进行验证
    可以同时支持多种vnc client
    novnc,基于html5 websockets, Canvas和JavaScripts实现
    Spice,redhat的虚拟桌面技术

    nova-consoleauth服务
    用于进行token的验证

    VNC服务流程图

    在这里插入图片描述
    noVNC访问原理
    一个用户试图从浏览器里面打开连接到虚拟机的VNC Client
    浏览器向nova-api发送请求,要求返回访问vnc的url
    nova-api调用nova-compute的get_vnc_console方法,要求返回连接VNC的信息
    nova-compute调用libvirt的get_vnc_console函数
    libvirt会通过解析虚拟机的的配置文件/instance-00000001.xml来获得VNC Server的信息
    libvirt将host, port等信息以json格式返回给nova-compute
    nova-compute会随机生成一个UUID作为Token

    nova-api会调用nova-consoleauth的authorize_console函数
    nova-api将connect_info中的access url信息返回给浏览器
    当浏览器试图打开这个链接时,会将请求发送给nova-novncproxy
    nova-novncproxy调用nova-consoleauth的check_token函数
    nova-consoleauth验证了这个token,将这个instance对应的connect_info返回给nova-novncproxy
    nova-novncproxy通过connect_info中的host, port等信息,连接compute节点上的VNC Server,从而开始了proxy的工作
    nova-compute将libvirt返回的信息以及配置文件中的信息综合成connect_info返回给nova-api

    展开全文
  • Nova Conductor服务

    万次阅读 2016-11-07 21:34:24
    Nova Conductor服务的大部分方法都是数据库的查询操作(/nova/conductor/manager.py ConductorManager类)。主 要作用是避免Nova Compute服务直接访问数据库,增加系统的安全性。 一、引入nova conductor服务 1、...

    Nova Conductor服务的大部分方法都是数据库的查询操作(/nova/conductor/manager.py ConductorManager类)。主

    作用是避免Nova Compute服务直接访问数据库,增加系统的安全性。


    一、引入nova conductor服务

    1、nova compute服务的数据库查询更新操作都需要通过向nova conductor服务发送RPC请求来实现。

    2、在创建Nova Compute服务的Service对象时,会调用conductor_api的wait_until_ready方法等待nova conductor服

    务完成初始化工作。以下是Service类的初始化代码片段(/nova/service.py)。

    class Service(service.Service):
        def __init__(self, host, binary, topic, manager, report_interval=None,
                     periodic_enable=None, periodic_fuzzy_delay=None,
                     periodic_interval_max=None, db_allowed=True,
                     *args, **kwargs):
            ...
    		#创建conductor_api对象
            self.conductor_api = conductor.API(use_local=db_allowed)
    		#等待nova conductor服务开始工作
            self.conductor_api.wait_until_ready(context.get_admin_context())

    初始化方法中,有一个与conductor_api相关的重要参数db_allowed,指定服务是否有访问数据库的权限。

    db_allowed默认值是True。nova compute服务的启动脚本(/bin/nova-compute),显式设置参数为False。

    注意:nova scheduler启动脚本中,没有显式设置db_allowed参数。因此,db_allowed的值为默认值True。所以,具

    有访问数据库的权限。

    二、conductor.API方法

    conductor.API方法定义如下:

    def API(*args, **kwargs):
    	#获取外部传入的use_local参数
        use_local = kwargs.pop('use_local', False)
    	#如果nova.conf配置文件中配置了use_local配置项为True
    	#或者外部传入的use_local参数为True,则使用LocalAPI对象
        if oslo_config.cfg.CONF.conductor.use_local or use_local:
            api = conductor_api.LocalAPI
    	#否则创建远程API对象
        else:
            api = conductor_api.API
        return api(*args, **kwargs)

    API方法检查nova.conf配置文件中的use_local配置项和use_local参数。如果 use_local配置项和use_local参数为

    True,则为Nova服务创建LocalAPI对象;否则创建远程API对象。

    注意:nova.conf配置文件use_local配置项默认值False。conductor.API方法会为nova compute服务创建远程API对

    象;由于nova scheduler服务传入的use_local值为True,为nova scheduler服务创建Local API对象。

    三、conductor_api对象的定义

    Nova服务的conductor_api对象的类型可能是LocalAPI对象或者API类。LocalAPI类和API类初始化方法和

    wait_until_ready方法。

    1、LocalAPI类

    LocalAPI类的初始化方法定义如下:

    class LocalAPI(object):
        def __init__(self):
            self._manager = utils.ExceptionHelper(manager.ConductorManager())
    (1)创建了一个ConductorManager对象。  在ConductorManager类中,定义许多数据库访问的方法,这些方法都在本

    机建立与数据库的连接。

    (2)LocalAPI类定义了许多接口方法供Nova其他服务(Nova Scheduler)调用,底层都是直接调用ConductorManager

    对象中定义的相应的方法,并没有向nova conductor服务发送RPC请求。

    注意:Nova Scheduler服务使用的conductor_api是LocalAPI对象。当Nova Scheduler调用conductor_api访问数据库

    时,直接在本地建立与数据库的连接。因此Nova Scheduler服务的运行并不依赖nova conductor服务。

    (3)既然不依赖nova conductor服务,nova scheduler没有必要等待nova conductor服务开始运行。实现代码重用,

    创建nova scheduler服务对象时,调用conductor_api的wait_until_ready方法。 LocalAPI类为空。

    2、远程API方法

    远程API类的初始化方法定义:

    class API(LocalAPI):
        def __init__(self):
            self._manager = rpcapi.ConductorAPI()
    (1)创建了一个Conductor RPC API对象。Conductor RPC API类中定义许多接口方法向nova conductor发送RPC请求。

    而nova consuctor服务处理RPC请求的manager对象是一个ConductorManager对象。API类中定义的接口方法底层会调

    用Conductor RPC API对象中相应的方法。

    注意:

    (1)默认,nova compute服务使用的conductor_api是API对象。当nova compute调用conductor_api访问数据库时,会

    通过Conductor RPC服务向Nova Conductor服务发送RPC请求。因此conpute服务依赖于conductor服务。

    (2)既然nova compute服务访问数据库需要通过nova conductor服务中转,效率比nova scheduler服务低。


    (2)创建Nova Compute服务对象时,调用API对象的wait_until_ready方法,定义如下:

    class API(LocalAPI):
        def wait_until_ready(self, context, early_timeout=10, early_attempts=10):
            #尝试次数
            attempt = 0
    	#请求等待时间
            timeout = early_timeout
            
            has_timedout = False
    	#不断尝试ping Nova conductor服务
            while True:
                #如果尝试此时达到early_attempts,则不设置RPC请求等待时间
                if attempt == early_attempts:
                    timeout = None
                attempt += 1
    
                try:
    		#尝试向nova conductor服务发送RPC请求
                    self.base_rpcapi.ping(context, '1.21 GigaWatts',
                                          timeout=timeout)
                    if has_timedout:
                        LOG.info(_LI('nova-conductor connection '
                                     'established successfully'))
    		#如果请求成功,说明nova conductor服务正常工作,结束循环
                    break
    	    #如果请求失败,进入下一个循环,继续发送RPC请求
                except messaging.MessagingTimeout:
                    has_timedout = True
                    LOG.warning(_LW('Timed out waiting for nova-conductor.  '
                                    'Is it running? Or did this service start '
                                    'before nova-conductor?  '
                                    'Reattempting establishment of '
                                    'nova-conductor connection...'))
    不断向Nova Conductor服务发送ping RPC请求。当请求等待正常响应时,则认为nova conductor服务已经正常工作

    了。nova conductor服务最终会把ping RPC请求交给ConductorManager对象的ping方法处理。


    总结:

    1、创建虚拟机请求的处理流程

    通过虚拟机创建请求,分析Nova API、Nova Scheduler和Nova Compute服务的工作和协作机制。

    虚拟机创建请求的处理流程:


    servers资源底层(nova.api.openstack.compute.legacy_v2.servers.py) Controller类的create方法

    2、调度算法

    虚拟机调度算法是Nova Scheduler服务实现的最主要的功能,算法的框架定义在FilterScheduler类的_scheduler方

    法中。_scheduler工作流程:

    (1)调用HostManager对象的get_all_hosts方法获取所有的计算节点列表。

    (2)调用HostManager对象的get_filtered_hosts方法获取可用的计算节点列表。

    (3)调用HostManager对象的get_weighted_hosts方法计算可用计算节点的权值。

    (4)从权值最高的scheduler_host_subset_size个计算节点中随机选择一个计算节点作为创建虚拟机的节点。

    (5)调用被选中计算节点对应的 HostState对象的 consume_from_instance方法,更新选择的计算节点的硬件资源信

    息,为虚拟机预留资源。

    (6)HostManager对象的get_all_hosts方法首先调用HostManager对象的_choose_host_filters方法获取过滤器类列

    表,然后调用HostFilterHandler对象的get_filtered_objects方法使用过滤器检查计算节点。

    (7)HostFilterHandler对象的get_filtered_objects方法依次调用每个过滤器对象的filter_all方法。过滤器的

    filter_all方法返回的是通过该过滤器的主机列表。只有通过所有的过滤器检查的节点才是可用的节点。

    (8)HostManager对象的get_weighted_hosts方法调用了HostWeightHandler对象的get_weighted_objects方法。

    (9)HostWeightHandler对象的get_weighted_objects方法首先为每个主机创建一个WeightedObject对象。然后,依

    调用权值对象的weigh_objects方法不断修改主机WeightedObject对象的权值。

    主机最终的权值是所有权值对象赋予给主机权值的加权和。最后将主机按照权值由高到低顺序排列


    展开全文
  • Nova API服务Nova API服务的启动

    千次阅读 2016-10-28 22:25:50
    Nova API服务是一个RESTful API服务。 1、Nova API服务的启动 2、着重介绍与虚拟机资源有关的url请求的处理流程 3、虚拟机创建的HTTP请求处理过程 15.2.1 Nova API服务的启动 1、Nova API的地图引导: /etc/nov
  • nova计算服务

    2019-06-05 21:48:00
     Nova 是 OpenStack 最核心的服务,负责维护和管理云环境的计算资源。OpenStack 作为 IaaS 的云操作系统,虚拟机生命周期管理也就是通过 Nova 来实现的。计算资源只是内存跟cpu。 用途与功能 : 1、实例生命周期...
  • OpenStack Compute(Nova)功能分析 2011-11-29 10:24 Alice 译 openstack.org.cn 我要评论(0) 字号:T | T OpenStack Compute是由几个主要的组件所组成的。云控制器(cloud controller)包含了很多组件,...
  • Nova计算服务介绍

    2020-12-28 09:05:00
    ● 计算服务是openstack最核心的服务之一 , 负责维护和管理云环境的计算资源,它在openstack项目中代号是nova。 ● Nova自身并没有提供任何虚拟化能力,它提供计算服务,使用不同的虚拟化驱动来与底层支持的...
  • OpenStack:Nova基本功能介绍

    万次阅读 2012-10-29 23:46:31
    Nova基本功能介绍 一 初识Openstack 1.1 openstack是什么  Openstack是一个跟Eucalyptus,AWS(Amazon web Services)类似的IaaS框架,目前它包括三个主要的项目:Nova,Swift,Glance。下面分别对3个项目做简单...
  • Nova Scheduler的启动脚本中,最终的代码是创建Service类的create...分析Nova Scheduler服务的启动流程。 1、Service类的create方法 class Service(object): @classmethod def create(cls, host=None, binar
  • OpenStack之Nova分析——Nova API服务

    千次阅读 2015-01-19 15:51:01
    Nova是OpenStack中最核心的组件,可以说OpenStack中的其它组件都是为Nova服务的。所以Nova也是OpenStack最复杂的组件。Nova服务由多个子服务组成,这些子服务通过RPC实现通信,而其它组件(如glance等)是通过Nova...
  • OpenStack 控制节点Nova计算服务配置 1.进入MySQL数据库,有设置密码的输入密码进入 [root#]mysql 创库授权 CREATE DATABASE nova_api; CREATE DATABASE nova; GRANT ALL PRIVILEGES ON nova_api.* TO 'nova'@'...
  • openstack云计算之nova服务篇 #Nova 服务组件为openstack 核心组件之一,基于消息、无共享、松耦合、无状态的架构。openstack 核心组件均运行在多台主机节点上,包括Nova、Cinder、Glance、Neutron等,状态信息均存在...
  • nova 之compute服务

    千次阅读 2017-11-30 11:34:15
    云计算,openstck中nova 之compute服务
  • OpenStack Nova计算管理功能介绍 技术创新变革未来 前言 Nova作为OpenStack的核心项目提供大规模可扩展按需弹性和自助服务的计 算资源是整个OpenStack中最核心的项目 本章节分为两个部分理论和实验 理论部分主要讲解...
  • openstack(五)配置nova服务控制节点

    千次阅读 2019-08-24 17:15:44
    5、配置nova服务控制节点 6、配置nova服务计算节点 7、配置neutron服务控制节点 8、配置neutron服务计算节点 9、创建实例 10、配置dashboard服务 布署nova控制节点 nova分为控制节点和计算节点,计算节点通过nova ...
  • openstack的Nova计算服务

    2020-12-29 22:21:15
    目录一、Nova 简介二、Nova 系统架构三、组件介绍3.1、API-通讯接口3.2、Scheduler-调度器3.3、Compute–计算器3.3.1、支持方式3.3.2、功能3.4、Conductor–管理器3.5、PlacementAPI–安置接口四、Nova 的 Cell 架构...
  • 在继续介绍Nova虚拟机创建过程之前,我们来穿插一个很重要的内容,这就是Nova组件的“大脑”——Nova ...Nova Scheduler属于RPC服务(至于什么是RPC服务可以关注我之前的文章),这篇文章我们先来分析一下Nova Schedule
  • 文章目录一、Nova计算服务1.1Nova计算服务概述1.2Nova系统架构二、Nova组件-API三、Nova组件-Scheduler3.1Scheduler调度器3.2Nova调度器的类型3.3Scheduler过滤调度器四、Nova组件-Compute五、OpenStack-placement...
  • Nova作为OpenStack的核心项目提供大规模可扩展按需弹性和自助服务的计算资源是整个OpenStack中最核心的项目 本章节分为两个部分理论和实验 理论部分主要讲解Nova作用架构工作原理和流程 实验部分重点锻炼学员Nova...
  • nova计算服务分布式

    2019-06-12 22:00:00
    #第一步 控制节点下载nova-conpute包 #安装依赖包 #vim /etc/nova/nova.conf [DEFAULT] my_ip=#当前节点IP use_neutron = True firewall_driver = nova.virt.firewall.NoopFirewallDriver enabled_apis=os...
  • Conductor服务nova-conductor最初于Grizzly版本发布,目的是为数据库访问提供一层安全机制。在此之前,nova-compute都是直接访问数据库,一旦被攻破,则数据库会面临直接暴露的危险。此外,nova-conductor的加入也...
  • nova— 计算服务

    2018-12-21 18:36:00
    Nova 是 OpenStack 最核心的服务,负责维护和管理云环境的计算资源。OpenStack 作为 IaaS 的云操作系统,虚拟机生命周期管理也就是通过 Nova 来实现的。 用途与功能 : 1) 实例生命周期管理 2) 管理计算资源 3)...
  • Openstavk计算服务-Nova什么是novanova组件的工作流程Nova组件的简述nova-api 什么是nova 计算服务是openstack最核心的服务之一- ,负责维护和管理云环境的计算资源它在openstack项目中代号是novaNova自身并没有...
  • Nova 是 OpenStack 最核心的服务,负责维护和管理云环境的计算资源。OpenStack 作为 IaaS 的云操作系统,虚拟机生命周期管理也就是通过 Nova 来实现的。 用途与功能 : 1) 实例生命周期管理 2) 管理计算资源 3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,652
精华内容 3,060
关键字:

nova服务功能