Python 使用pyVmomi 模块获取主机相关信息

May I Suggest ?

#leanote #leanote blog #code #hello world

? pyvmomi ? ? python ? ? vmware ? 3076 0 0

swimming ? pyvmomi ? ? python ? ? vmware ?

> 此文主要解释了如何使用python获取Vmware虚拟机状态，参考文章：
1.[python结合pyvmomi 监控esxi的磁盘等信息](https://blog.csdn.net/reblue520/article/details/82720182)
2.[授之以渔-运维平台应用模块二（Vmware控制台篇）](https://www.jianshu.com/p/3256e0857407)

---

### **获取虚拟机信息**
getAllVms = vm._get_all_objs([vim.VirtualMachine])
虚拟机IP：vm.summary.guest.ipAddress/vm.guest.ipAddress
双地址获取方式：
for i in vm.guest.net:
	print(i.ipAddress[0])
虚拟机hostname： vm.summary.guest.hostName
虚拟机内存：vm.summary.config.memorySizeMB
虚拟机名称：vm.summary.config.name/vm.name
虚拟机CPU：vm.summary.config.numCpu
虚拟机网卡数：vm.summary.config.numEthernetCards
虚拟机磁盘数量：vm.summary.config.numVirtualDisks
虚拟机创建时间：(vm.summary.config.annotation).split('-')[-1]
虚拟机磁盘路径：vm.summary.config.vmPathName
虚拟机磁盘所在存储地点：vm.datastore
虚拟机状态：vm.overallStatus   'green'
宿主机IP地址：vm.runtime.host.name **此方法可关联宿主机**
\# 文件夹：vm.parent.parent.name  只到出现vm

### **获取宿主机信息**
res = vm._get_all_objs([vim.HostSystem])
虚拟机主机型号：i.summary.hardware.model
虚拟机主机序列号：
for i in res:
	for h in i.summary.hardware.otherIdentifyingInfo:
		if h.identifierType.key == 'ServiceTag':
			print(h.identifierValue)
虚拟主机CPU型号：i.summary.hardware.cpuModel
CPU 速度：i.summary.hardware.cpuMhz
CPU 数量：i.summary.hardware.numCpuPkgs
CPU 总核心数（不带超线程）：i.summary.hardware.numCpuCores
CPU 内存：i.summary.hardware.memorySize/1024/1024/1024 [单位G]
虚拟主机网卡接口：i.summary.hardware.numNics
虚拟主机IP: i.summary.config.name
虚拟机软件版本：i.summary.config.product.fullName/version
虚拟主机状态：i.summary.config.product.overallStatus    'green'
res = vm._get_all_objs([vim.ClusterComputeResource]

### **其他内容获取方式**

[参考文章](https://www.jianshu.com/p/3256e0857407)

>getAllVms = vm._get_all_objs([vim.VirtualMachine])
虚拟机IP：vm.summary.guest.ipAddress/vm.guest.ipAddress
双地址获取方式：
for i in vm.guest.net:
	print(i.ipAddress[0])
虚拟机hostname： vm.summary.guest.hostName
虚拟机内存：vm.summary.config.memorySizeMB
虚拟机名称：vm.summary.config.name/vm.name
虚拟机CPU：vm.summary.config.numCpu
虚拟机网卡数：vm.summary.config.numEthernetCards
虚拟机磁盘数量：vm.summary.config.numVirtualDisks
虚拟机创建时间：(vm.summary.config.annotation).split('-')[-1]
虚拟机磁盘路径：vm.summary.config.vmPathName
虚拟机磁盘所在存储地点：vm.datastore
虚拟机状态：vm.overallStatus   'green'
宿主机IP地址：vm.runtime.host.name
\# 文件夹：vm.parent.parent.name  只到出现vm
\# 获取虚拟主机信息
res = vm._get_all_objs([vim.HostSystem])
虚拟机主机型号：i.summary.hardware.model
虚拟机主机序列号：
for i in res:
	for h in i.summary.hardware.otherIdentifyingInfo:
		if h.identifierType.key == 'ServiceTag':
			print(h.identifierValue)
虚拟主机CPU型号：i.summary.hardware.cpuModel
CPU 速度：i.summary.hardware.cpuMhz
CPU 数量：i.summary.hardware.numCpuPkgs
CPU 总核心数（不带超线程）：i.summary.hardware.numCpuCores
CPU 内存：i.summary.hardware.memorySize/1024/1024/1024 [单位G]
虚拟主机网卡接口：i.summary.hardware.numNics
虚拟主机IP: i.summary.config.name
虚拟机软件版本：i.summary.config.product.fullName/version
虚拟主机状态：i.summary.overallStatus    'green'

> res = vm._get_all_objs([vim.ClusterComputeResource])

---
```python
# -*- coding: utf8 -*-

from pyVmomi import vim,vmodl
from pyVim.connect import SmartConnect, Disconnect
import atexit
import sys
import time
import ssl

class VCenter:
    def __init__(self):
        self.pyVmomi = __import__("pyVmomi")
        self.vcenter_server = '1.1.1.1'
        self.vcenter_username = 'test'
        self.vcenter_password = 'test'
        self.port = 443
        self.isDHCP=False,
        self.vm_ip='10.7.42.91',
        self.subnet= '255.255.255.0',
        self.gateway= '10.7.42.40',
        self.dns= ['company.com', 'company.com'],
        self.domain= 'esx10g.company.com'

def add_nic(vm, network):
        spec = vim.vm.ConfigSpec()

# add Switch here
        dev_changes = []
        switch_spec                = vim.vm.device.VirtualDeviceSpec()
        switch_spec.operation      = vim.vm.device.VirtualDeviceSpec.Operation.add
        switch_spec.device         = vim.vm.device.VirtualVmxnet3()

switch_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
        switch_spec.device.backing.useAutoDetect = False
        switch_spec.device.backing.deviceName = network.name
        switch_spec.device.backing.network = network
        switch_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
        switch_spec.device.connectable.startConnected = True
        switch_spec.device.connectable.connected = True

dev_changes.append(switch_spec)

spec.deviceChange = dev_changes
        output = vm.ReconfigVM_Task(spec=spec)
        time.sleep(2)
        print output.info

def connect_to_vcenter(self):
        context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
        context.verify_mode = ssl.CERT_NONE
        self.service_instance = SmartConnect(
                                        host = self.vcenter_server,
                                        user = self.vcenter_username,
                                        pwd = self.vcenter_password,
                                        port = self.port,
                                        sslContext = context)
        self.content = self.service_instance.RetrieveContent()
        atexit.register(Disconnect, self.service_instance)

def wait_for_task(self, task, actionName='job', hideResult=False):
         while task.info.state == (self.pyVmomi.vim.TaskInfo.State.running or self.pyVmomi.vim.TaskInfo.State.queued):
             time.sleep(2)
         if task.info.state == self.pyVmomi.vim.TaskInfo.State.success:
             if task.info.result is not None and not hideResult:
                 out = '%s completed successfully, result: %s' % (actionName, task.info.result)
                 print out
             else:
                 out = '%s completed successfully.' % actionName
                 print out
         elif task.info.state == self.pyVmomi.vim.TaskInfo.State.error:
             out = 'Error - %s did not complete successfully: %s' % (actionName, task.info.error)
             raise ValueError(out)
         return task.info.result

def answer_vm_question(self,vm):
        choices = vm.runtime.question.choice.choiceInfo
        default_option = None
        choice = ""
        if vm.runtime.question.choice.defaultIndex is not None:
            ii = vm.runtime.question.choice.defaultIndex
            default_option = choices[ii]
            choice = None
        while choice not in [o.key for o in choices]:
            print "VM power on is paused by this question:\n\n"
            for option in choices:
                print "\t %s: %s " % (option.key, option.label)
            if default_option is not None:
                print "default (%s): %s\n" % (default_option.label,
                                              default_option.key)
            choice = raw_input("\nchoice number: ").strip()
            print "..."
        return choice

def poweroff(self, si, vm):
        task = vm.PowerOff()
        actionName = 'job'
        while task.info.state not in [self.pyVmomi.vim.TaskInfo.State.success or self.pyVmomi.vim.TaskInfo.State.error]:
            time.sleep(2)
        if task.info.state == self.pyVmomi.vim.TaskInfo.State.success:
            out = '%s completed successfully.' % actionName
            print out
        elif task.info.state == self.pyVmomi.vim.TaskInfo.State.error:
            out = 'Error - %s did not complete successfully: %s' % (actionName, task.info.error)
            raise ValueError(out)
        return

def poweron(self, si, vm):
        task = vm.PowerOn()
        actionName = 'job'
        answers = {}
        while task.info.state not in [self.pyVmomi.vim.TaskInfo.State.success or self.pyVmomi.vim.TaskInfo.State.error]:
            if vm.runtime.question is not None:
                question_id = vm.runtime.question.id
                if question_id not in answers.keys():
                    answers[question_id] = self.answer_vm_question(vm)
                    vm.AnswerVM(question_id, answers[question_id])
            time.sleep(2)
        if task.info.state == self.pyVmomi.vim.TaskInfo.State.success:
            out = '%s completed successfully.' % actionName
            print out
        elif task.info.state == self.pyVmomi.vim.TaskInfo.State.error:
            out = 'Error - %s did not complete successfully: %s' % (actionName, task.info.error)
            raise ValueError(out)
        return

def set_dvs_mtu(self, dvs, mtu):
        dvs_config_spec = self.pyVmomi.vim.VmwareDistributedVirtualSwitch.ConfigSpec()
        dvs_config_spec.configVersion = dvs.config.configVersion
        dvs_config_spec.maxMtu = int(mtu)
        task = dvs.ReconfigureDvs_Task(dvs_config_spec)
        self.wait_for_task(task)
        print "Successfully reconfigured DVS %s with mtu %s" %(dvs.name, mtu)
        return dvs

def get_dvs_portgroup(self, vimtype, portgroup_name, dvs_name):
        obj = None
        container = self.content.viewManager.CreateContainerView(self.content.rootFolder, vimtype, True)
        for c in container.view:
            if c.name == portgroup_name:
                if c.config.distributedVirtualSwitch.name == dvs_name:
                    obj = c
                    break
        return obj

def list_obj(self, vimtype):
        container = self.content.viewManager.CreateContainerView(self.content.rootFolder, vimtype, True)
        return container.view

def get_obj(self, vimtype, name):
        obj = None
        container = self.content.viewManager.CreateContainerView(self.content.rootFolder, vimtype, True)
        for c in container.view:
            if c.name == name:
                obj = c
                break
        return obj

def get_folder(self, folder_name=''):
        """获取文件夹"""
        folder_list = []
        if folder_name == '':
            listOBJ = self.list_obj([vim.Folder])
        else:
            listOBJ = self.get_obj([vim.Folder],folder_name)
        for each in listOBJ:
            folder_list.append(each)
        return folder_list

def get_vcenters(self):
        """获取所有数据中心"""
        listOBJ = self.list_obj([vim.Datacenter])
        vcenters_list = []
        for each in listOBJ:
            vcenters_list.append(each)
        return each

def get_vcenters_alarm(self):
        """获取所有数据中心报警"""
        listOBJ = self.list_obj([vim.Datacenter])
        vcenters_alarm_dict = {}
        for i in listOBJ[0].triggeredAlarmState:
            vcenters_alarm_dict[i.entity.name] =  i.alarm.info.name.decode()
        return vcenters_alarm_dict

def get_datastore(self, datastore_name=''):
        """获取存储"""
        datastore_list = []
        if datastore_name == '':
            listOBJ = self.list_obj([vim.Datastore])
        else:
            listOBJ = self.get_obj([vim.Datastore],datastore_name)
        for each in listOBJ:
            datastore_list.append(each.name)
        return datastore_list

def get_clusters(self,clusters_name=''):
        """获取所有的集群"""
        clusters_list = []
        if clusters_name == '':
            listOBJ = self.list_obj([vim.ClusterComputeResource])
        else:
            listOBJ = self.get_obj([vim.ClusterComputeResource],clusters_name)
        for each in listOBJ:
            clusters_list.append(each.name)
        return clusters_list

def get_resource_pool(self,resource_pool_name=''):
        """获取所有的资源池"""
        resource_pool_list = []
        if resource_pool_name == '':
            listOBJ = self.list_obj([vim.ResourcePool])
        else:
            listOBJ = self.get_obj([vim.ResourcePool],resource_pool_name)
        for each in listOBJ:
            resource_pool_list.append(each.name)
        return resource_pool_list

def get_hosts(self):
        """获取所有的宿主机"""
        listOBJ = self.list_obj([vim.HostSystem])
        index = 0
        for each in listOBJ:
            tupleVNic=sys._getframe().f_code.co_name, index, each.config.network.vnic
            for eachvnic in tupleVNic[2]:
                index = index + 1
                print sys._getframe().f_code.co_name, \
                    index, \
                    each, \
                    eachvnic.portgroup, \
                    eachvnic.spec.mac, \
                    eachvnic.spec.ip.ipAddress, eachvnic.spec.ip.subnetMask

def get_pnic(self):
        """获取所有的上行口"""
        listOBJ = self.list_obj([vim.HostSystem])
        index = 0
        for each in listOBJ:
            tuplePNic=sys._getframe().f_code.co_name, index, each.config.network.pnic
            for eachpnic in tuplePNic[2]:
                index = index + 1
                print sys._getframe().f_code.co_name, index, each, eachpnic.device

def get_vswitchs(self):
        """获取所有的交换机（包括标准交换机和分布式交换机)"""
        listOBJ = self.list_obj([vim.HostSystem])
        index = 0
        for each in listOBJ:
            tupleVswitch = sys._getframe().f_code.co_name, index, each.config.network.vswitch
            for eachsw in tupleVswitch[2]:
                index = index + 1
                print sys._getframe().f_code.co_name, index, eachsw.name

def get_portgroups(self):
        """获取所有的交换机端口组（包括标准交换机和分布式交换机)"""
        listOBJ = self.list_obj([vim.Network])
        index = 0
        for each in listOBJ:
            index = index + 1
            print sys._getframe().f_code.co_name, index, each

def get_vns(self):
        """获取所有的虚拟网络（包括标准交换机端口组和分布式交换机端口组)"""
        listOBJ = self.list_obj([vim.Network])
        index = 0
        for each in listOBJ:
            index = index + 1
            print sys._getframe().f_code.co_name, index, each

def get_dvswitchs(self):
        """获取所有的分布式交换机"""
        listOBJ = self.list_obj([vim.DistributedVirtualSwitch])
        index = 0
        for each in listOBJ:
            index = index + 1
            print sys._getframe().f_code.co_name,index,each

def get_dvportgroups(self):
        """获取所有的分布式交换机端口组"""
        listOBJ = self.list_obj([vim.DistributedVirtualSwitch])
        index = 0
        for each in listOBJ:
            for eachportgroup in each.portgroup:
                index = index + 1
                print sys._getframe().f_code.co_name,index,eachportgroup

def get_vnic(self):
        """获取所有的虚拟网卡"""
        listOBJ = self.list_obj([vim.VirtualMachine])
        index = 0
        for each in listOBJ:
            index = index + 1
            vmdeviceList = each.config.hardware.device
            for eachdevice in vmdeviceList:
                index = index + 1
                if isinstance(eachdevice, vim.vm.device.VirtualEthernetCard ):
                    if isinstance( eachdevice.backing,vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo ):
                        print sys._getframe().f_code.co_name,\
                            index, \
                            eachdevice.deviceInfo.label, \
                            eachdevice.macAddress, \
                            eachdevice.deviceInfo.summary, \
                            eachdevice.backing.port.portgroupKey
                    else:
                        print sys._getframe().f_code.co_name,\
                            index, \
                            eachdevice.deviceInfo.label, \
                            eachdevice.macAddress, \
                            eachdevice.backing.deviceName, \
                            eachdevice.backing.network

def get_allvms(self):
        """获取所有的虚机"""
        listOBJ = self.list_obj([vim.VirtualMachine])
        index = 0
        for each in listOBJ:
            index = index + 1
            print sys._getframe().f_code.co_name,index,each.name

def print_vm_info(self, virtual_machine, depth=1):
        """打印虚机信息"""
        maxdepth = 10
        if hasattr(virtual_machine, 'childEntity'):
            if depth > maxdepth:
                return
            vmList = virtual_machine.childEntity
            for c in vmList:
                self.print_vm_info(c, depth + 1)
            return
        summary = virtual_machine.summary
        print "Name       : ", summary.config.name
        print "Path       : ", summary.config.vmPathName
        print "Guest      : ", summary.config.guestFullName
        annotation = summary.config.annotation
        if annotation:
            print "Annotation : ", annotation
        print "State      : ", summary.runtime.powerState
        if summary.guest is not None:
            ip_address = summary.guest.ipAddress
            if ip_address:
                print "IP         : ", ip_address
        if summary.runtime.question is not None:
            print "Question  : ", summary.runtime.question.text
        print ""

def get_acquireTicket(self,virtual_machine):
        """获取主机Console授权"""
        acquireTickets_dict = {}
        listOBJ = self.get_obj([vim.VirtualMachine],virtual_machine)
        try:
            acquireTickets = listOBJ.AcquireTicket('webmks')
        except Exception as err:
            print 'acquireTickets_err:',err
        acquireTickets_dict['host'] = acquireTickets.host
        acquireTickets_dict['port'] = acquireTickets.port
        acquireTickets_dict['ticket'] = acquireTickets.ticket
        print acquireTickets_dict
        return acquireTickets_dict

def get_hosts_exsi_version(self,virtual_machine):
        """获得主机Esxi版本"""
        try:
            hosts_name = self.get_obj([vim.VirtualMachine],virtual_machine).summary.runtime.host
            for i in self.list_obj([vim.HostSystem]):
                if i == hosts_name:
                    hosts_ip = i.name
            listOBJ = self.get_obj([vim.HostSystem],hosts_ip)
            try:
                exsi_version = listOBJ.summary.config.product.fullName
            except Exception as err:
                print err
                exsi_version = ''
        except Exception as err:
            print err
            exsi_version = ''
        return exsi_version
```
### 测试实例
```python
# -*- coding: utf-8 -*-

from pyVim.connect import SmartConnect
from pyVmomi import vim
import ssl

# si= SmartConnect(host="10.10.10.30", user="administrator@ylpay.vm", pwd="I7GdS]=fe1[13VkoBmbG",sslContext=s)
# # si= SmartConnect(host="10.8.9.20", user="administrator@ylpay.cn", pwd="50qgfFZKniKzu!J3zgL",sslContext=s)
# content=si.content

class GetVmData(object):
        """docstring for GetVmData,获取VM相关数据"""
        def __init__(self, host, user, password):
                super(GetVmData, self).__init__()
                # 主机房信息
                # self.host = "10.10.10.30"
                # self.user = "administrator@ylpay.vm"
                # self.passwd = "I7GdS]=fe1[13VkoBmbG"
                # 测试环境信息
                # self.host = "10.8.9.20"
                # self.user = "administrator@ylpay.cn"
                # self.passwd = "50qgfFZKniKzu!J3zgL"
                self.user = user
                self.host = host
                self.password = password
                s = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
                s.verify_mode=ssl.CERT_NONE
                self.sslContext = s

try:
                        self.client = SmartConnect(host=host,
                                user=user,
                                pwd=password,
                                sslContext=self.sslContext
                                )
                        self.content = self.client.content
                        self.result = True
                except Exception as e:
                        self.result = False
                        self.message = e

def get_all_objs(self, obj_type, folder=None):
                if folder is None:
                        container = self.content.viewManager.CreateContainerView(self.content.rootFolder,obj_type,True)
                else:
                        container = self.content.viewManager.CreateContainerView(folder,obj_type,True)
                return container.view

def get_obj(self, obj_type, name):
                obj = None
                content = self.content
                container = content.viewManager.CreateContainerView(content.rootFolder,obj_type,True)
                for c in container.view:
                        if c.name == name:
                                obj = c
                                break
                return obj

# 获取数据中心
        def get_datacenter(self):
                return self._get_all_objs([vim.Datecenter])

# 根据数据中心名称获取数据中心对象
        def get_datacenter_by_name(self ,datacenter_name):
                return self._get_all_objs([vim.Datacenter],datacenter_name)

vm = GetVmData(host="10.8.9.20", user="administrator@ylpay.cn", password="50qgfFZKniKzu!J3zgL")

getAllVms = vm._get_all_objs([vim.VirtualMachine])
res = vm._get_all_objs([vim.HostSystem])

for vm in getAllVms:
        print(vm.summary.guest.hostName)

try:
        if len(temp_ip.split('.')[2]) == 1:
                temp['app_ip'] = temp_ip
        if len(temp_ip.split('.')[2]) == 2:
                temp['manager_ip'] = temp_ip
except Exception as e:
        print("======> ERROR IS %s"%e)
```

觉得不错，点个赞？

文章目录