openstack-nova源码分析(六）availability_zone 可用区

不念不忘少年蓝@ 2022-02-24 11:55 339阅读 0赞

Availability zones (os-availability-zone)  
可用区 在openstack中并没有很明确的定义  
注： Openstack 对于可用区的定义可能跟一些可用区定义不一样，只以openstack做分析  
官方将解释为主机的聚合（Host Aggregates）， 可用区在openstack中没有相应的表定义，创建更新接口则使用Host Aggregates功能，  
主机组可以被认为是可用区的进一步划分，主机组只对管理员可见而可用区用户可见  
然而，主机组与可用区并不是同一个概念  
可用区是主机的metadata 的一组聚合  
注：  
1.一个主机可以属于多个主机组，但是只能属于一个可用区  
2.主机默认属于default可用区，即使主机不属于任何主机组

Lists and gets detailed availability zone information.
    An availability zone is created or updated by setting the availability_zone parameter 
    in the create, update, or create or update methods of the Host Aggregates API. 
    See Host Aggregates for more details.

官方解释为：

Host aggregates can be regarded as a mechanism to further partition an availability zone; 
    while availability zones are visible to users, host aggregates are only visible to administrators
    
    Availability Zones are the end-user visible logical abstraction for partitioning a cloud without knowing the physical infrastructure. 
    That abstraction doesn’t come up in Nova with an actual database model since the availability zone is actually a specific metadata information 
    attached to an aggregate. Adding that specific metadata to an aggregate makes the aggregate visible from an end-user perspective and consequently 
    allows to schedule upon a specific set of hosts (the ones belonging to the aggregate).
    That said, there are a few rules to know that diverge from an API perspective between aggregates and availability zones:
    1.one host can be in multiple aggregates, but it can only be in one availability zone
    2. by default a host is part of a default availability zone even if it doesn’t belong to an aggregate (the configuration option is named default_availability_zone)

##### 一. url及命令行 #####

1.  url  
    url只有GET 获取列表的方法 ：

/os-availability-zone
    /os-availability-zone/detail

1.  命令行

nova availability-zone-list

##### 二. 源码 #####

availability_zone = nova.api.openstack.compute.availability_zone:AvailabilityZone

AvailabilityZone定义如下：

class AvailabilityZone(extensions.V21APIExtensionBase):
        """1. Add availability_zone to the Create Server API.
           2. Add availability zones describing.
        """
    
        name = "AvailabilityZone"
        alias = ALIAS
        version = 1
    
        def get_resources(self):
            resource = [extensions.ResourceExtension(ALIAS,
                AvailabilityZoneController(),
                collection_actions={'detail': 'GET'})]
            return resource

处理方法映射到AvailabilityZoneController 并新增了detail 处理get方法

这里先分析detail 列表功能， 命令行nova availability-zone-list 实际上调用的是detail方法  
在client中默认的调用也是detail

class AvailabilityZoneController(wsgi.Controller):
        """The Availability Zone API controller for the OpenStack API."""
    
        def __init__(self):
            super(AvailabilityZoneController, self).__init__()
            self.servicegroup_api = servicegroup.API()
            
          ....
          
          
         @extensions.expected_errors(())
        def detail(self, req):
            """Returns a detailed list of availability zone."""
            context = req.environ['nova.context']
            context.can(az_policies.POLICY_ROOT % 'detail')
    
            return self._describe_availability_zones_verbose(context)

\_describe\_availability\_zones\_verbose定义如下：

1.  先获取可用区列表
2.  查询所有启用状态的服务列表
3.  循环扫描Service 对象的availability\_zone 过滤 (‘nova-osapi\_compute’, ‘nova-ec2’, ‘nova-metadata’)，将主机放入不同的availability\_zone 列表中
4.  将可用区信息数据，拼装成\{‘zoneName’: zone, ‘zoneState’: \{‘available’: True\}, “hosts”: hosts\} 的列表进行返回

def _describe_availability_zones_verbose(self, context, **kwargs):
            ctxt = context.elevated()
            available_zones, not_available_zones = \
                availability_zones.get_availability_zones(ctxt)
    
            # Available services
            enabled_services = objects.ServiceList.get_all(context, disabled=False,
                                                           set_zones=True)
            zone_hosts = {}
            host_services = {}
            api_services = ('nova-osapi_compute', 'nova-ec2', 'nova-metadata')
            for service in enabled_services:
                if service.binary in api_services:
                    # Skip API services in the listing since they are not
                    # maintained in the same way as other services
                    continue
                zone_hosts.setdefault(service['availability_zone'], [])
                if service['host'] not in zone_hosts[service['availability_zone']]:
                    zone_hosts[service['availability_zone']].append(
                        service['host'])
    
                host_services.setdefault(service['availability_zone'] +
                        service['host'], [])
                host_services[service['availability_zone'] + service['host']].\
                        append(service)
    
            result = []
            for zone in available_zones:
                hosts = {}
                for host in zone_hosts.get(zone, []):
                    hosts[host] = {}
                    for service in host_services[zone + host]:
                        alive = self.servicegroup_api.service_is_up(service)
                        hosts[host][service['binary']] = {'available': alive,
                                          'active': True != service['disabled'],
                                          'updated_at': service['updated_at']}
                result.append({'zoneName': zone,
                               'zoneState': {'available': True},
                               "hosts": hosts})
    
            for zone in not_available_zones:
                result.append({'zoneName': zone,
                               'zoneState': {'available': False},
                               "hosts": None})
            return {'availabilityZoneInfo': result}

get\_availability\_zones定义如下：

1.  通过object对象层 objects.ServiceList.get\_all 获取启用的服务enabled\_services 以及get\_only\_available 禁用服务
2.  with\_hosts 表示是否带出host信息， 这里默认不需要
3.  如果get\_only\_available 为默认的false 则返回为一个tuple的list, 否则返回单个list

def get_availability_zones(context, get_only_available=False,
                               with_hosts=False):
        """Return available and unavailable zones on demand.
    
            :param get_only_available: flag to determine whether to return
                available zones only, default False indicates return both
                available zones and not available zones, True indicates return
                available zones only
            :param with_hosts: whether to return hosts part of the AZs
            :type with_hosts: bool
        """
        enabled_services = objects.ServiceList.get_all(context, disabled=False,
                                                       set_zones=True)
    
        available_zones = []
        for (zone, host) in [(service['availability_zone'], service['host'])
                             for service in enabled_services]:
            if not with_hosts and zone not in available_zones:
                available_zones.append(zone)
            elif with_hosts:
                _available_zones = dict(available_zones)
                zone_hosts = _available_zones.setdefault(zone, set())
                zone_hosts.add(host)
                # .items() returns a view in Py3, casting it to list for Py2 compat
                available_zones = list(_available_zones.items())
    
        if not get_only_available:
    				.... 
            return (available_zones, not_available_zones)
        else:
            return available_zones

可见az是与Service服务有关联的，原因是，compute 主机会将服务注册到Service中，通过Service可以获取集群所有主机  
objects.ServiceList.get\_all

get\_all 定义：

@base.remotable_classmethod
       def get_all(cls, context, disabled=None, set_zones=False):
           db_services = db.service_get_all(context, disabled=disabled)
           if set_zones:
               db_services = availability_zones.set_availability_zones(
                   context, db_services)
           return base.obj_make_list(context, cls(context), objects.Service,
                                     db_services)

这里获取所有主机  
在\_describe\_availability\_zones\_verbose 会获取zone信息， 这里进行分析

set\_zone 使用 availability\_zones.set\_availability\_zones(context, db\_services)进行分析

set\_availability\_zones定义如下：

def set_availability_zones(context, services):
        # Makes sure services isn't a sqlalchemy object
        services = [dict(service) for service in services]
        hosts = set([service['host'] for service in services])
        aggregates = objects.AggregateList.get_by_metadata_key(context,
                'availability_zone', hosts=hosts)
        metadata = _build_metadata_by_host(aggregates, hosts=hosts)
        # gather all of the availability zones associated with a service host
        for service in services:
            az = CONF.internal_service_availability_zone
            if service['topic'] == "compute":
                if metadata.get(service['host']):
                    az = u','.join(list(metadata[service['host']]))
                else:
                    az = CONF.default_availability_zone
                    # update the cache
                    update_host_availability_zone_cache(context,
                                                        service['host'], az)
            service['availability_zone'] = az
        return services

这里可以看出，Aggregate 与zone的关系

zone是在aggregate上通过metadata 打上了availability\_zone 标签的一组集合

\[dict(service) for service in services\]将一组service 对象转换成一个dict 列表  
取出host service\[‘host’\] 放入set中，可以自动去重  
获取availability\_zone metedta的主机组  
拼装数据返回

index：

实际调用：

def _describe_availability_zones(self, context, **kwargs):
            ctxt = context.elevated()
            available_zones, not_available_zones = \
                availability_zones.get_availability_zones(ctxt)
    
            filtered_available_zones = \
                self._get_filtered_availability_zones(available_zones, True)
            filtered_not_available_zones = \
                self._get_filtered_availability_zones(not_available_zones, False)
            return {'availabilityZoneInfo': filtered_available_zones +
                                            filtered_not_available_zones}

可见，该函数返回的是简单的列表信息，详细信息是通过detail进行处理的， index函数这里不做详细分析  
具体差异主要在是否返回hosts信息：  
由， “hosts”: None 可以看出

result.append({'zoneName': zone,
                               'zoneState': {'available': is_available},
                               "hosts": None})