Python-VMware SDK

VMware SDK Pyvmomi

• 虚拟机克隆部署
• 搜索虚拟机IP，返回虚拟机列表
• 通过虚拟机Name，返回虚拟机列表
• 网卡管理
• 快照管理
• 磁盘管理

# -*- coding:utf-8 -*-

import os
import atexit
import datetime
from pyVmomi import vim, vmodl
from pyVim.connect import SmartConnectNoSSL, Disconnect
from configparser import ConfigParser
import datetime
import xlwt
# from change_vm_nic import edit_nic_from_vm
import time

# 搜索虚拟机通过IP，返回虚拟机列表
def VmSearchByIp(si, ip):
	vms = si.content.searchIndex.FindAllByIp(None, ip, vmSearch=True)
	return vms


def get_obj(content, vimtype, name):
	obj = None
	container = content.viewManager.CreateContainerView(content.rootFolder, vimtype, True)
	for c in container.view:
		if c.name == name:
			# print(c.name)
			obj = c
			break
		else:
			# obj = c 
			# print("The value is not get please check")
			obj = None
	return obj

# 搜索虚拟机通过Name
def vm_search_by_name(si, name):
	vms = get_obj(si, si.content.rootFolder, [vim.VirtualMachine])
	for vm in vms:
		print(vm.config.name)
	return vm


def wait_for_task(task):
	task_done = False
	while not task_done:
		if task.info.state == "success":
			time.sleep(5)
			return task.info.result
		if task.info.state == 'error':
			print("there was an error")
			task_done = True


def add_nic(content, vm_name, network_name):
    """
    :param content: Service Instance
    :param vm: Virtual Machine Object
    :param network_name: Name of the Virtual Network
    """
    vm_obj = get_obj(content, [vim.VirtualMachine], vm_name)
    network_obj = get_obj(content, [vim.Network], network_name)
    nic_changes = []
    spec = vim.vm.ConfigSpec()
    nic_spec = vim.vm.device.VirtualDeviceSpec()
    nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
    nic_spec.device = vim.vm.device.VirtualVmxnet3()
    # nic_spec.device = vim.vm.device.VirtualE1000()
    nic_spec.device.deviceInfo = vim.Description()
    nic_spec.device.deviceInfo.summary = 'VirtualMachine Nic'

    nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
    nic_spec.device.backing.useAutoDetect = False
    nic_spec.device.backing.network = network_obj
    nic_spec.device.backing.deviceName = network_name

    nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
    nic_spec.device.connectable.startConnected = True
    nic_spec.device.connectable.allowGuestControl = True
    nic_spec.device.connectable.connected = False
    nic_spec.device.connectable.status = 'untried'

    nic_changes.append(nic_spec)
    spec.deviceChange = nic_changes
    add_nic_task = vm_obj.ReconfigVM_Task(spec=spec)
    wait_for_task(add_nic_task)
    # print("Nic add complate")


def remove_nic_from_vm(vm_name):
	"""delete all nic"""
	vm_obj = get_obj(content, [vim.VirtualMachine], vm_name)
	nic_changes = []
	for dev in vm_obj.config.hardware.device:
		if isinstance(dev, vim.vm.device.VirtualEthernetCard):
			virtual_nic_device = dev
			virtual_nic_spec = vim.vm.device.VirtualDeviceSpec()
			virtual_nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.remove
			virtual_nic_spec.device = virtual_nic_device
			nic_changes.append(virtual_nic_spec)

	spec = vim.vm.ConfigSpec()
	spec.deviceChange = nic_changes
	task = vm_obj.ReconfigVM_Task(spec=spec)
	wait_for_task(task)


def edit_nic_from_vm(content, vm_name, network_name):
	nic_changes = []
	vm_obj = get_obj(content, [vim.VirtualMachine], vm_name)
	network_obj = get_obj(content, [vim.Network], network_name)
	# 判断给到的vlan标签是否为分布式交换机或者标准交换机,返回bool值
	switch_distributed = isinstance(network_obj, vim.dvs.DistributedVirtualPortgroup)
	for dev in vm_obj.config.hardware.device:
		if isinstance(dev, vim.vm.device.VirtualEthernetCard):
			virtual_nic_device = dev 
			virtual_nic_spec = vim.vm.device.VirtualDeviceSpec()
			virtual_nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
			virtual_nic_spec.device = virtual_nic_device
			if switch_distributed:
			# 分布式交换机portgroup上配置内容
				virtual_nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo()
				virtual_nic_spec.device.backing.port =vim.dvs.PortConnection()
				virtual_nic_spec.device.backing.port.switchUuid = network_obj.config.distributedVirtualSwitch.uuid
				virtual_nic_spec.device.backing.port.portgroupKey = network_obj._moId
			else:
			# 标准交换机上portgroup上配置内容
				virtual_nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
				virtual_nic_spec.device.backing.useAutoDetect = False
				virtual_nic_spec.device.backing.network = network_obj
				virtual_nic_spec.device.backing.deviceName = network_name
			nic_changes.append(virtual_nic_spec)
	spec = vim.vm.ConfigSpec()
	spec.deviceChange = nic_changes
	task = vm_obj.ReconfigVM_Task(spec=spec)
	wait_for_task(task)


def Clone_vm(content, vm_folder,datacenter_name, datastore_name, resource_pool, vm_name, template, nic_adapter, vmconf):
	datacent = get_obj(content, [vim.Datacenter], datacenter_name)
	if vm_folder:
		destfolder = get_obj(content, [vim.Folder], vm_folder)
	else:
		destfolder = datacent.vmFolder

	if datastore_name:
		datastore = get_obj(content, [vim.Datastore], datastore_name)
	else:
		datastore = get_obj(content, [vim.Datastore], template.datastore[0].info.name)

	if resource_pool:
		resource_pool = get_obj(content, [vim.ResourcePool], resource_pool)
	else:
		resource_pool = cluster.resourcePool

	relospec = vim.vm.RelocateSpec()
	relospec.datastore = datastore
	relospec.pool = resource_pool

	clonespec = vim.vm.CloneSpec()
	clonespec.location = relospec
	clonespec.config = vmconf
	clonespec.powerOn = True
	clonespec.template = False

	clonespec.customization = nic_adapter

	clonetask =	template.CloneVM_Task(folder=destfolder, name=vm_name, spec=clonespec)
	wait_for_task(clonetask)


def Vm_Ip_Setting_Spec(vm_name, ipaddr, subnetMask, gateway, dns, dnsDomain="transsion.com"):
	# vm_obj = get_obj(content, [vim.VirtualMachine], vm_name)

	nicSpec = vim.vm.customization.IPSettings()
	nicSpec.dnsDomain = dnsDomain
	nicSpec.gateway = gateway
	nicSpec.subnetMask = subnetMask
	nicSpec.ip = vim.vm.customization.FixedIp()
	nicSpec.ip.ipAddress = ipaddr

	linuxprep = vim.vm.customization.LinuxPrep()
	linuxprep.domain = dnsDomain
	linuxprep.hostName = vim.vm.customization.FixedName()
	linuxprep.hostName.name = vm_name
	linuxprep.hwClockUTC = True
	linuxprep.timeZone = "Asia/Shanghai"

	globalIPSettings = vim.vm.customization.GlobalIPSettings()
	globalIPSettings.dnsServerList = dns

	nic_adapter_specs = []
	nic_adapter_config = vim.vm.customization.AdapterMapping()
	nic_adapter_config.adapter = nicSpec
	nic_adapter_specs.append(nic_adapter_config) 

	nic_adapter = vim.vm.customization.Specification()
	nic_adapter.nicSettingMap = nic_adapter_specs
	nic_adapter.identity = linuxprep
	nic_adapter.globalIPSettings = globalIPSettings

	return nic_adapter

def Vm_Config_Spec(cpus, memoryMB, annotation):
	vmconf = vim.vm.ConfigSpec()
	vmconf.annotation = annotation
	vmconf.cpuHotAddEnabled = True
	vmconf.cpuHotRemoveEnabled = True
	vmconf.memoryHotAddEnabled = True
	vmconf.numCoresPerSocket = 2
	vmconf.numCPUs = cpus
	vmconf.memoryMB = memoryMB
	return vmconf

def Snapshot_create(vm_obj, snap_name, desc):
	Snap_create_task = vm_obj.CreateSnapshot_Task(name=snap_name, description=desc, memory=False, quiesce=False)
	wait_for_task(Snap_create_task)

def Get_vm_snap(vm_obj):
	snap_info = vm_obj.snapshot
	tree = snap_info.rootSnapshotList
	while tree[0].childSnapshotList is not None:
		print("SnapName:{0} desc: {1}".format(tree[0].name, tree[0].description))
		if len(tree[0].childSnapshotList) < 1:
			break
		tree = tree[0].childSnapshotList

def Remove_vm_snap(vm_obj):
	task = vm_obj.RemoveAllSnapshots_Task()
	wait_for_task(task)



def Create_disk_for_vm(vm_boj):
	task = vm_obj.CreateVirtualDisk_Task()

if __name__ == "__main__":
    try:
        base_dir = os.path.dirname(os.path.abspath(__file__))
        config_file = os.path.join(base_dir, os.path.join("etc", "vSphere.ini"))
        config = ConfigParser()
        config.read(config_file, encoding="utf-8")
        for section in config.sections():
            cfg = dict(config.items(section))
            try:
                si = SmartConnectNoSSL(host=section, port=cfg["port"], user=cfg["user"], pwd=cfg["passwd"])
            except Exception as e:
                print("Login Error:" + cfg["info"])
                continue
            else:
                print("Login Success:" + cfg["info"])
                content = si.RetrieveContent()
                datastore_name = 'vsanDatastore'
                resource_pool = 'test'
                vm_folder = 'vm'
                datacenter_name = 'VSAN-Datacenter-TEST'
                vm_name = "test09"
                template_name = '16-Nginx'
                vlan_name = "VM Network"
                # template = None
                ip = "10.250.100.202"
                subnetMask = "255.255.255.0"
                gateway = "10.250.100.254"
                dns = "10.250.101.52"
                cpus = 4
                memory = 2048
                note = "this is a test"
                desc = "snap test"
                snap_name = "20201014"
                template = get_obj(content, [vim.VirtualMachine], template_name)
                # vm_obj = get_obj(content, [vim.VirtualMachine], vm_name)
                # edit_nic_from_vm(content, vm_name, vlan_name)
                # vm_obj.CustomizeVM_Task(spec=spec)
                vm_obj = get_obj(content, [vim.VirtualMachine], vm_name)
                # Snapshot_create(vm_obj, snap_name, desc)
                Get_vm_snap(vm_obj)
                Remove_vm_snap(vm_obj)

                # if template:
                # 	nic_adapter = Vm_Ip_Setting_Spec(vm_name, ip, subnetMask, gateway, dns)
                # 	vmconf = Vm_Config_Spec(cpus, memory, note)
                # 	Clone_vm(content, vm_folder, datacenter_name, datastore_name, resource_pool, vm_name, template, nic_adapter, vmconf)
                # 	edit_nic_from_vm(content, vm_name, vlan_name)

                	# if vlan_name:
                		# vm = get_obj(content, [vim.VirtualMachine], vm_name)
                		# print(vm.name)
                		# change_vm_nic.remove_nic_from_vm(vm)
                		# change_vm_nic.add_nic(content, vm, vlan_name)
                # else:
                	# print("The template is not avaliable!")
                Disconnect(si)
    except Exception as err:
        print(err)
    finally:
        exit()