从VMware的vCenter中读取事件

最新推荐文章于 2024-09-05 16:12:29 发布
最新推荐文章于 2024-09-05 16:12:29 发布
阅读量2.6k 收藏 4
点赞数 1
分类专栏： 开发 文章标签： VMware 事件 vCenter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhigang0529/article/details/83182854
版权

从VMware的vCenter中读取事件，每几分钟从vCenter中的事件管理中读取事件，得到事件后，再对事件做处理。上代码。

连接vCenter的连接类



import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.vmware.vim25.mo.ServiceInstance;

/**
 * @Title: vCenter连接池
 */

public class VmwareConnectionUtil  {
	private static Logger logger = LogManager.getLogger(VmwareConnectionUtil.class);

	private static final VmwareConnectionUtil instance = new VmwareConnectionUtil();

	private Map<String, ServiceInstance> poolMap = new HashMap<String, ServiceInstance>(); // Map<ip,ServiceInstance>

	private static final int GETTESTSTATUSTIMEOUT = 60;

	private VmwareConnectionUtil() {
	}

    /**
     * 单例模式
     * @return
     */
    public static synchronized VmwareConnectionUtil getInstance() {
        return instance;
    }

    /**
     * 建立与vCenter的连接
     * @param url数组: IP, port, username, password
     * @return
     */
    public synchronized ServiceInstance getConnection(String[] url) {
        String key = getKey(url);
        ServiceInstance conn = poolMap.get(key);

        if (conn != null) {
            try {
                conn.currentTime();
            } catch (Exception e) {
            	logger.error("Get VmWare vCenter connection exception", e);
            	poolMap.remove(key);
                conn.getServerConnection().logout();
                conn = null;
            }
        } else {
            poolMap.remove(key);
            conn = initConnection(url);
            poolMap.put(key, conn);
        }

        return conn;
    }

    private ServiceInstance initConnection(String[] param) {
    	try {
//			ignoreSsl();
		} catch (Exception e1) {
			logger.error("Ignore SSL error", e1);
		}
    	
        ServiceInstance conn = null;
        URL url = null;
        String spec = "";
        if(param[1] == null || param[1].trim().equals(""))
        	spec = "https://" + param[0] + "/sdk";	//没有端口
        else
        	spec = "https://" + param[0] + ":" + param[1] + "/sdk";
    
        try {
        	url = new URL(spec);
        	logger.info("Connect to VmWare vCenter " + url);
        } catch (MalformedURLException e) {
            logger.error("Connect to VmWare vCenter exception", e);
            return conn;
        }

        try {
            conn = new ServiceInstance(url, param[2], param[3], true);
        } catch (Exception e) {
            if (conn != null) {
                conn.getServerConnection().logout();
            }
            conn = null;
            logger.error("Failed to init VmWare vCenter webservice connection URL " +  spec + ", user:" + param[2], e);
        }

        return conn;
    }

    private ServiceInstance initConnectTimeOut(final String[] param) {
        ServiceInstance conn = null;
        final ExecutorService exec = Executors.newFixedThreadPool(1);
        Callable<ServiceInstance> call = new Callable<ServiceInstance>() {
            
            public ServiceInstance call() throws Exception {
                ServiceInstance conn = initConnection(param);
                return conn;
            }
        };
        try {
            Future<ServiceInstance> future = exec.submit(call);
            conn = future.get(GETTESTSTATUSTIMEOUT, TimeUnit.SECONDS); // 任务处理超时时间设为60 秒
        } catch (TimeoutException ex) {
            logger.error("Init connect time out", ex);
        } catch (Exception e) {
            logger.error("Init connect exception", e);
        }
        exec.shutdown(); // 关闭线程池
        return conn;
    }

    /**
     * IP:userName|password
     * @param url
     * @return
     */
    private String getKey(String[] url) {
        return url[0] + ":" + url[2] + "|" + url[3];
    }

    public boolean testConnection(String ip, String port, String username, String password) {
        String[] param = new String[] { ip, port, username, password };
        ServiceInstance serviceInstance = null;

        serviceInstance = initConnectTimeOut(param);
        if (serviceInstance == null) {
            return false;
        }

        return true;
    }

    public Map<String, ServiceInstance> getPoolMap() {
        return poolMap;
    }

    public void setPoolMap(Map<String, ServiceInstance> poolMap) {
        this.poolMap = poolMap;
    }

    public void deleteConnPoolMap(String key) {
        this.poolMap.remove(key);
    }
    
  
    
}

从vCenter中读取事件



import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.collector.vm.vmware.util.VmwareConnectionUtil;
import com.vmware.vim25.ComputeResourceEventArgument;
import com.vmware.vim25.DatacenterEventArgument;
import com.vmware.vim25.Event;
import com.vmware.vim25.EventEx;
import com.vmware.vim25.EventFilterSpec;
import com.vmware.vim25.EventFilterSpecByTime;
import com.vmware.vim25.ExtendedEvent;
import com.vmware.vim25.HostEventArgument;
import com.vmware.vim25.ManagedObjectReference;
import com.vmware.vim25.VmEventArgument;
import com.vmware.vim25.mo.EventManager;
import com.vmware.vim25.mo.ServiceInstance;

/**
 * @Title:采集Vmware事件
 * @description 从vCenter中的事件管理器中，每几分钟读取新发生的事件
 */
public class EventCollector {
    private Logger log = LogManager.getLogger(EventCollector.class);
    
    //上次事件采集时间点缓存　　key:url , value:time
    private static Map<String, Long> lastDateMap = new HashMap<String, Long>();
    
    private static final long interval = 1200000l;	//20分钟
    
    private static HashMap<String, String> keyMap = new HashMap<String, String>();
    
    //事件类型
    private String[] eventTypes = null;

    public EventCollector() {
        eventTypes = new String[]{"VmRemovedEvent","VmCreatedEvent","VmRenamedEvent",
        		"VmBeingRelocatedEvent","MigrationResourceWarningEvent","HostConnectionLostEvent","HostConnectedEvent",
        		"HostDisconnectedEvent","HostRemovedEvent","DatastoreRemovedOnHostEvent","HostOvercommittedEvent","HostCnxFailedTimeoutEvent",
        		"MigrationErrorEvent","VmCloneFailedEvent","VmConnectedEvent","VmDisconnectedEvent","ClusterCreatedEvent",
        		"ClusterDestroyedEvent","HostOvercommittedEvent","DatastoreDestroyedEvent","DatastoreFileDeletedEvent","DuplicateIpDetectedEvent",
        		"HostIpChangedEvent","ResourcePoolDestroyedEvent","VmFailedToPowerOnEvent","VmFailedToPowerOffEvent","EnteredMaintenanceModeEvent",
        		"VmStateFailedToRevertToSnapshot","VmStateRevertedToSnapshot"};
    }
    

	
	/**
	 * 取采集开始时间
	 * @param key
	 * @return
	 */
	private long getLastTime(String key) {
		long lastTime = 0l;
		if (!lastDateMap.containsKey(key)) {
			Calendar startTime = Calendar.getInstance();
			startTime.setTimeInMillis(System.currentTimeMillis() - interval * 3);	//前60分钟的
			lastTime = startTime.getTimeInMillis();
			
			lastDateMap.put(key, lastTime);
			log.info("First start collect time from: "+ getSimpleDateFormat(lastTime) + ", key:" + key);
		}
		lastTime = lastDateMap.get(key);
		return lastTime;
	}
	
	/**
	 * 查询事件
	 * @param url
	 * @throws CollectorException
	 */
	private void doCollect(String[] url) {
        try {
            String key = "Datacenter@" + url[0];
            long lastEventDate = getLastTime(key);
            
            log.info("Start collect event data by " + url[0] + " from " + getSimpleDateFormat(lastEventDate));
            
            ServiceInstance serviceInstance = VmwareConnectionUtil.getInstance().getConnection(url);
            EventFilterSpec efs = new EventFilterSpec();
            efs.setType(eventTypes);
            
            //设置事件过滤器，根据时间查询事件
            EventFilterSpecByTime tFilter = new EventFilterSpecByTime();
            Calendar startTime = Calendar.getInstance();
            startTime.setTimeInMillis(lastEventDate);
            tFilter.setBeginTime(startTime);
            efs.setTime(tFilter);
            
            EventManager evtMgr = serviceInstance.getEventManager();
            try {
	            Event[] events = evtMgr.queryEvents(efs);
	            if(events != null){
	                for (Event event : events) {
	                    printEvent(event);
	                    String eventKey = key + "_" + event.getKey();
	                    if(!keyMap.containsKey(eventKey)) {	//已有的事件不再处理
	                    	EventProcessor ep = new EventProcessor();
	                    	ep.process(event, url);
	                    } 
	                    keyMap.put(eventKey, "");	
	                }
	            } else
	            	log.warn("Query events from " + url[0] + " empty");
            } catch(Exception e) {
            	log.error("Query events exception", e);
            }
            
            long nextStart = System.currentTimeMillis() - interval;
           	lastDateMap.put(key, nextStart);
    		log.info("Next start query event time: " + getSimpleDateFormat(nextStart) + ", key:" + key);
    		
        } catch (Throwable e) {
            log.error("Collect Event exception by " + url[0], e);
        }
    }

    /**
     * 输出事件信息
     * @param evt
     */
    private void printEvent(Event evt) {
		String type = evt.getClass().getSimpleName();// 事件类型
		int key = evt.getKey();// 事件ID
//		int chainId = evt.getChainId();// 父或组ID
//		String userName = evt.getUserName();// 引发该事件的用户
		long createdTime = evt.getCreatedTime().getTimeInMillis();// 创建时间
		String formattedMessage = evt.getFullFormattedMessage();// 事件内容
        
        String logInfo="type="+type;
        String eventTypeId="";
        if(evt instanceof EventEx){
            EventEx e=(EventEx)evt;
            eventTypeId=e.getEventTypeId();
            logInfo=logInfo+", eventTypeId="+eventTypeId;
        }else if(evt instanceof ExtendedEvent){
            ExtendedEvent e=(ExtendedEvent)evt;
            eventTypeId=e.getEventTypeId();
            logInfo=logInfo+", eventTypeId="+eventTypeId;
        }
        logInfo=logInfo+ ", key=" + key  + ", time=" + getSimpleDateFormat(createdTime)+", message=" + formattedMessage;

        if (evt.getDatacenter() != null) {
            DatacenterEventArgument dc= evt.getDatacenter();
            ManagedObjectReference mor=dc.getDatacenter();
            logInfo=logInfo+"\n datacenter=" +dc.getName() + ", datacenterEntity=" + mor.getVal();
        }
        if (evt.getComputeResource() != null) {
            ComputeResourceEventArgument cr= evt.getComputeResource();
            ManagedObjectReference mor= cr.getComputeResource();
            logInfo=logInfo+"\n cluster=" +cr.getName() + ", clusterEntity=" + mor.getVal();
        }
        if (evt.getHost() != null) {
            HostEventArgument  host= evt.getHost();
            ManagedObjectReference mor= host.getHost();
            logInfo=logInfo+"\n host:" +host.getName() + ", hostEntity=" + mor.getVal();
        }
        if (evt.getVm() != null) {
            VmEventArgument  vm= evt.getVm();
            ManagedObjectReference mor= vm.getVm();
            logInfo=logInfo+"\n vm:" +vm.getName() + ", vmEntity:" + mor.getVal();
        }
        log.info(logInfo);
    }
    
    /**
     * 格式化时间
     * @param time
     * @return
     */
    private String getSimpleDateFormat(long time)   {
        if(time == 0l)
            return "";
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return format.format(new Date(time));
    }


    /**
     * 测试方法
     * @param args
     */
    public static void main(String[] args) {
        try {
            Calendar startTime = Calendar.getInstance();
            startTime.roll(Calendar.DATE, false);//设置查询，一天内的事件
            EventCollector collector = new EventCollector();
            String[] url = new String[4];
            url[1] = "";
            url[0] = "192.168.98.203"; //云中心的IP
            url[2] = "administrator";
            url[3] = "ulabcde!@#";
            collector.doCollect(url);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

VMware事件处理

package com.ultrapower.ultranms.monitor.collector.vm.vmware.event;


import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.vmware.vim25.ComputeResourceEventArgument;
import com.vmware.vim25.DatacenterEventArgument;
import com.vmware.vim25.DatastoreEventArgument;
import com.vmware.vim25.Event;
import com.vmware.vim25.HostEventArgument;
import com.vmware.vim25.VmEventArgument;

/**
 * @Title:VMware事件处理
 */
public class EventProcessor  {
	
	private Logger log = LogManager.getLogger(EventProcessor.class);
	
	

	public void process(Event evt, String[] url) {

		String type = evt.getClass().getSimpleName();// 事件类型
		String text = evt.getFullFormattedMessage();// 事件内容
		String userName = evt.getUserName();// 引发该事件的用户
		if(userName != null && !userName.trim().equals(""))
			text += ", 操作用户:" + userName;
		
		if(type.equals("VmCreatedEvent") || type.equals("VmRemovedEvent")) {	//成功创建虚拟机事件/虚拟机被清除回收事件
			if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
				VmEventArgument vm = evt.getVm();
			}
		} else if(type.equals("VmRenamedEvent") || type.equals("VmBeingRelocatedEvent") ||	//虚拟机虚拟机重命名事件/虚拟机被迁移事件
				  type.equals("MigrationErrorEvent") || type.equals("VmCloneFailedEvent") ||	//迁移错误事件/克隆失败事件
				  type.equals("VmDisconnectedEvent") ||											//虚拟机断开连接事件
				  type.equals("MigrationResourceWarningEvent") || type.equals("VmFailedToPowerOnEvent") || type.equals("VmFailedToPowerOffEvent")){	//资源迁移警告事件/虚拟机启动失败事件/虚拟机关闭失败事件
			if (evt.getVm() != null) {
				VmEventArgument vm = evt.getVm();
				System.out.println("VM: " +  vm.getVm().getVal() + ", " + vm.getName()  + ", type: " + type + ", text: " + text);
			} else if (evt.getHost() != null) {
				HostEventArgument host = evt.getHost();
				System.out.println("Host: " + host.getName()  + ", type: " + type + ", text: " + text);
			} else if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("VmConnectedEvent")){	//虚拟机已连接事件
			if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("ClusterCreatedEvent") || type.equals("ClusterDestroyedEvent") ) {	//集群创建/删除事件
			if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("HostOvercommittedEvent")) {	//集群超出主机容量事件
			if (evt.getComputeResource() != null) {
				ComputeResourceEventArgument cr = evt.getComputeResource();
				System.out.println("ComputeResource: " + cr.getName()  + ", type: " + type + ", text: " + text);
			} else if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("HostConnectionLostEvent") || type.equals("HostRemovedEvent")) {		//主机连接/主机删除事件
			if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("HostConnectedEvent")) {		//主机已连接事件
			if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("HostDisconnectedEvent") || type.equals("HostIpChangedEvent") || 		//主机断开/主机IP改变事件
				  type.equals("DatastoreRemovedOnHostEvent") || type.equals("EnteredMaintenanceModeEvent") ||		//删除在主机的数据存储事件/已经进入维护模式
				  type.equals("HostCnxFailedTimeoutEvent") || type.equals("DuplicateIpDetectedEvent")) {	//主机连接超时事件/检测到IP重复事件
			if (evt.getHost() != null) {
				HostEventArgument host = evt.getHost();
				System.out.println("Host: " + host.getName()  + ", type: " + type + ", text: " + text);
			} else if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("DatastoreDestroyedEvent") ) {	//数据存储被删除
			if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("DatastoreFileDeletedEvent")) {	//删除数据存储文件事件
			if (evt.getDs() != null) {
				DatastoreEventArgument ce = evt.getDs();
				System.out.println("Datastore: " + ce.getName()  + ", type: " + type + ", text: " + text);
			} else if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		} else if(type.equals("VmStateFailedToRevertToSnapshot") || type.equals("VmStateRevertedToSnapshot")) { //创建快照失败, 创建快照
			if (evt.getVm() != null) {
				VmEventArgument vm = evt.getVm();
				System.out.println("VM: " +  vm.getVm().getVal() + ", " + vm.getName()  + ", type: " + type + ", text: " + text);
			} else if (evt.getDatacenter() != null) {
				DatacenterEventArgument dc = evt.getDatacenter();
				System.out.println("DataCenter: " + dc.getDatacenter().getVal()  + ", type: " + type + ", text: " + text);
			}
		}
	}
	
	

}

 

刚毅
关注
专栏目录
vcenter java_Vmware Vsphere WebService之vijava 开发一-vcenter连接、及集群信息获取
weixin_35067976的博客
02-16 460
packagecom.iking.vmware.cluster;importjava.util.ArrayList;importjava.util.Arrays;importjava.util.List;importjavax.xml.ws.soap.SOAPFaultException;importcom.iking.exception.VcenterException;importcom.ik...
VMware vCenter Server 任意文件上传漏洞（CVE-2021-22005）检测
ML_Team的博客
09-26 4036
0x01 前言 很凑巧，今天刚出的VMware vCenter Server 任意文件上传漏洞通告，立马就在工作中用上了。正在内网渗透测试的我，刚发现一目标存在VMware vCenter任意文件读取漏洞，就看到阿里云应急响应中心发出的通告，随后立马去找到POC去检测，借此记录一下。 0x02 漏洞描述 VMware是一家云基础架构和移动商务解决方案厂商，提供基于VMware的虚拟化解决方案。2021年9月22日，VMware 官方发布安全公告，披露了包括 CVE-2021-22005 VMwar
如何获取到服务器信息吗,如何从VMware获取服务器信息
weixin_35955928的博客
08-04 249
为什么不使用视图？他们拥有所有你需要的信息。下面的代码假定您已连接到vCenter。$vmView = Get-View -ViewType VirtualMachine -Property Name,Config,Guest,Runtime$hostView = Get-View -ViewType HostSystem -Property Name$date = Get-DateForeach...
Vcenter数据采集之maven打包可执行jar血历史
weixin_34054866的博客
03-23 154
技术点：spring加载xsd过程：http://blog.csdn.net/bluishglc/article/details/7596118案发背景：1、一个使用maven管理的普通项目（vcenter-collector ：关于Vcenter数据采集）2、项目主要技术： java + mybatis（基于接口形式）+其他3、项目中有一个非maven仓库的jar包：vij...
技术干货|Zabbix运维实战指南：常见问题与解决方案
最新发布
Zabbix_China的博客
09-05 1139
Zabbix通过安装在被监控主机上的agent或通过SNMP、JMX、IPMI等协议来收集数据，并将这些数据存储在数据库中，用户可以通过Web界面来查看和分析这些数据，及时发现问题并采取相应的措施.※ Zabbix Server：根据监控规模和数据量确定服务器配置，建议数据库使用SSD存储，并合理调整相关参数，如MySQL的“innodb buffer pool size”大小，一般为主机内存的75% - 80%。※ 监控项类型：包括简单检查、内部检查、外部检查等。内部检查监控Zabbix内部进程；
vCenter Events
荒野求生的博客
07-25 212
https://www.virten.net/vmware/vcenter-events/
Vmware Vsphere WebService之vijava 开发一-vcenter连接、及集群信息获取
wanzuwodou的博客
11-02 4132
开始是通过java代码调用vsphere提供的原始接口，从而控制vcenter的操作。当第一个版本做完之后发现代码执行的速度特别慢，后来在网上看到有人用vijava（对vsphere原始接口封装）编程，自己就试着换了几个接口发现代码执行速度很快。所以第二版都换了vijava操作。下面就和大家一起学习下如何通过vijava控制vcenter。 首先去github上下载vijava项目，然后将其导入...
vmware vcenter server下创建共享磁盘用于搭建RAC
11-06
在VMware vCenter Server这样的云平台上搭建Oracle RAC集群，可以充分利用虚拟化技术的优势，实现灵活、可扩展的数据库部署。以下将详细介绍如何在VMware vCenter Server上创建共享磁盘并用于搭建Oracle RAC集群。 ...
CVE-2021-21972 Vmware vcenter未授权 获取linux RCE-细节
qq_40015778的博客
02-26 1898
CVE-2021-21972 Vmware vcenter未授权 获取linux RCE-细节 在本文中，我将介绍如何发现VMware vSphere客户端RCE漏洞，泄露技术细节并说明如何在各种平台上利用它。 发现漏洞 在对vSphere Client进行分析的过程中，我一如既往地采用了黑盒和白盒两种方法进行测试，重点关注未经授权即可利用的漏洞。从Web面板，我尝试发送尽可能多的不同请求，所有请求都没有Cookie标头。 向发送未经授权的请求后/ui/vropspluginui/rest/services
Avi Vantage在VMware vCenter的集成指南
Avi Vantage的部署有三种模式：无访问、读取访问和写入访问，每种模式对应不同的功能和自动化水平，同时要求Avi在vCenter中拥有不同级别的权限。用户需要根据实际需求选择合适的部署模式，并参考相关文档以获取详细...
VMware vCenter Converter 安装和管理指南
11-27
### VMware vCenter Converter 安装和管理指南 #### 概述 VMware vCenter Converter 是一款功能强大的工具，主要用于将物理机（Physical Machines, PMs）转换为虚拟机（Virtual Machines, VMs），同时也可以在不同...
如何将物理机系统迁移转换为VMware虚拟机系统(P2V)
09-06
如何将物理机系统迁移转换为VMware虚拟机系统(P2V),VMware Converter P2V 转换工具及安装操作步骤
vCenter任务、事件清除
09-09
vCenter中任务、事件清除 适用于：vCenter 6.x，数据库为内置数据库非第三方数据库； 用法：压缩包文件解压到C盘根目录，运行批处理即可，
通过调用Vcenter-Api获取Vcenter中服务器信息
Q先生
04-11 2075
文档对应url:https://developer.vmware.com/apis/vsphere-automation/latest/cis/api/session/post/我们可以用GET方式取https://192.168.0.200/api/vcenter/vm/vm-12311/guest/local-filesystem。get访问https://192.168.0.200/api/vcenter/vm/vm-12311/guest/identity。但和我们实际想要的内容是有差距的。
Vmware vCenter API： Step2 查询接口
weixin_33785108的博客
01-16 904
为什么80%的码农都做不了架构师？>>> ...
VMware vCenter服务器常用的巡检命令、运维命令和PowerShell脚本
我在Citrix、VMware、Veeam、微软和NVIDIA等领域拥有丰富经验的专业人士，专注于设计和维护虚拟化基础设施、实施备份与灾难恢复策略，致力于优化企业的IT环境。
06-18 3904
VMware vCenter服务器常用的巡检命令、运维命令和PowerShell脚本
vSphere开发指南1——vSphere Automation API
HBohan的博客
07-14 2783
前言 VMware vCenter Server是VMware虚拟化管理平台，广泛的应用于企业私有云内网中。站在渗透测试工具开发的角度，我们需要通过命令行实现vCenter Server同虚拟机的交互。 本系列文章将要比较多种不同的API，介绍实现细节，开源代码，实现以下功能： · 读取虚拟机的配置 · 查看虚拟机文件 · 删除虚拟机文件 · 向虚拟机上传文件 · 从虚拟机下载文件 · 在虚拟机中执行命令 简介 本文将要介绍以下内容： · 基础知识 · vSphere Automation API开发细节.
关于VMware环境中Duplicate IP的问题
企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
10-29 2334
一、问题描述 在vmware环境中，经常会遇到vc或NSX报出Duplicate IP的问题，导致vm和edeg的网络问题，排查定位困难，今天我们就来看下如何处理这种重复IP的网络冲突问题。 二、案例分析处理 案例 1 问题：A duplicate IP address is detected for a vmknic interface configuration. This impacts IPv4 and IPv6. If 192.168.3.1 is the IP address used by t
vcenter:找到虚机是否是虚机模板（template）的字段位置（7）
shunzi2016的博客
06-15 430
通过api和sdk获取的虚机列表中包含了模板虚拟机，但是有些通用性的操作是无法在模板虚机中找到对应属性的。所以我们需要对虚机是否为模板进行对应的区分。对应区分的位置如下： 如图： ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值