Archive

Archive for August, 2010

How to Get ESX Version from vCenter?

August 16th, 2010 3 comments

There is a recent question in vSphere(VI) Java API forum about this. On its face, it’s very easy because most people know how to get hold of the version as follows: 

String version = si.getAboutInfo().getVersion();

The si in the above code is the variable of ServiceInstance object. If you have never used the API yet, please try this Getting Started Tutorial which shows how to get your first program running from scratch in 5 minutes

If you are connecting to a vCenter server and try to get the version of a HostSystem the vCenter manages, it’s not so obvious. But it’s definitely doable. Here is the solution assuming you already get hold of the HostSystem object as host variable here: 

String version = host.getConfig().getProduct().getVersion();

Here you know why. First, the aboutInfo is now called product although they are of the same type. Second, it’s hidden within the config property. 

Before taking the code away, I would like to share with you an important tip for better performance. 

Categories: vSphere API Tags: ,

UUID vs. vSphere

August 12th, 2010 No comments

UUID stands for universally unique identifier (UUID). It’s a 128-bit value. vSphere uses it as IDs for many different types of entities like HostSystem, VirtualMachine, Datastore, etc.

The UUID surfaces to the vSphere API as well. You can find many methods use UUID as parameter or return result. The most commonly used one is the SearchIndex.findByUuid() which find you a virtual machine or a host based on its UUID, either instance or BIOS UUID. The format used for UUID is as follows:

52dc2e26-dbc4-7d05-5fed-019d234379d9

Since 4.0, DistributedVirtualSwitchManager managed object is added and it has a method called queryDvsByUuid(). As reported by VI Java API community, the standard format doesn’t work. The accepted format is like this:

Why Hyperic Chose VI Java API for vSphere Integration?

August 11th, 2010 No comments

VMware SpringSource released Hyperic 4.4 last week. According to Charles Lee, co-founder of Hyperic, one key feature is “enhanced management of VMware virtualized environments through integration with VMware vCenter.” I am glad vSphere(VI) Java API (a.k.a. vijava) has contributed to the success of the product.

Here is part of Charles’s blog Hyperic Broadens vSphere Support through vCenter APIs in Version 4.4 explaining the rationale behind the choice:

How to Promote a Virtual Machine’s Disks?

August 10th, 2010 No comments

What does a promotion mean for a virtual machine’s disks? When you get a promotion, you may have more salary, a better title, bigger office space, etc. For sure a virtual disk cannot earn salary and doesn’t care about title, but it can occupy bigger space in datastore.

In my previous blog, I discussed how to create linked virtual machines using vSphere API. These linked virtual machines share a common disk as base, therefore the total disk consumption is significantly reduced. When a virtual disk is promoted, it gets its own “office” other than sharing it with others.

The vSphere API to promote virtual disks is promoteDisks_Task defined with VirtualMachine type. It has a tricky parameter called “unlink” (type: boolean) . According to the API reference:

1. If the unlink parameter is true, any disk backing which is shared shared by multiple virtual machines is copied so that this virtual machine has its own unshared version. Copied files always end up in the virtual machine’s home directory.

2. Any disk backing which is not shared between multiple virtual machines and is not associated with a snapshot is consolidated with its child backing.

Now when should you use true or false? “If the unlink parameter is true, the net effect of this operation is improved read performance, at the cost of disk space. If the unlink parameter is false the net effect is improved read performance at the cost of inhibiting future sharing.”

Here is the sample code that illustrates the usage of the API:

Vertically Complete Systems: Next Big Trend?

August 9th, 2010 2 comments

IBM recently announced its re-organization around its software and hardware business units. The previously separate business units were merged together as one – the Systems and Software Group led by the former software chief Steve Mills.

You may recall that IBM did not have a dedicated software group until Lou Gerstner created one 15 years ago to centralize all the software businesses into one business unit. This unit has been IBM’s most profitable business. Before that, IBM offered all the software as add-ons to the systems like 390 and AS/400.

Now can we expect IBM to offer hardware systems as add-ons to their software solutions?

Although companies constantly re-organize to streamline their business execution, this reorganization did indicate a big trend is happening in the IT industry. Computer vendors are striving to own vertically-complete stacks: from hardware all the way up to business applications.

A Big Cloud Challenge: Cross Stack Portability

August 4th, 2010 No comments

When you think of portability in cloud computing, you think of how to move applications code, data, and workloads. These are mostly horizontal movements within the same level of software stacks – from one IaaS to another, and from one PaaS to another.

There is a more interesting and potentially very important movement that I would describe as “cross stack” portability. Today we don’t see cross stack portability unless we re-write the application, which is not what I cover here (although it could be a good business opportunity for companies to explore). Rather, I am talking about how to move your application built on PaaS to an IaaS vendor or even to a private cloud. The reason I call it cross stack is because the application is moved up or down to a different level in the software stack.

In this blog, I’ll focus on portability without code change. I’ll discuss three conversions: from PaaS to IaaS, SaaS to IaaS, and IaaS to PaaS. Mathematically we can have other forms of conversions – say from IaaS to SaaS – but those examples are either not that interesting or not that practical. So I won’t cover them here.

From PaaS to IaaS

Who Created That VM: Java Version of the Winning Script of VMware Contest

August 3rd, 2010 2 comments

As you recall from my previous blog on the Script-O-Mania contest, Alan Renouf won the first prize with his Who Created That VM script written in PowerCLI. The script leverages implicitly several vSphere APIs, so I think it would be cool to have a Java version. At least we can illustrate how to use these related vSphere APIs.

The following is a sample I rewote using VI Java API for the same purpose except that Alan’s script shows full display name of a user while this Java version shows user name (see the following diagram). Although longer, the Java version can run on any OS, not just Windows.

Categories: vSphere API Tags: ,

How to Create Linked Virtual Machines with vSphere API?

August 2nd, 2010 5 comments

More often than not, you may have several virtual machines based on same software stacks running on the same host. Although they are very much the same, they take as much space as multitude of what one virtual machine takes.

Since vSphere 4.0, things are different. You can significantly reduce the storage usage by a new feature called linked virtual machines. The idea is simple: sharing a common virtual disk among the similar virtual machines. The shared virtual disk serves as a base. On top of that, each virtual machine has its own delta disk. When a guest operating system writes to disk, the data persists to the delta disk. When it reads from disk, the delta disk is checked first before trying the base disk.

As a result, you only need to save one copy of the base disk no matter how many virtual machines you have (up to 8 virtual machines in a linked virtual machine group). One limitation is that you cannot use it with HA cluster.

How to create linked virtual machines? You have two approaches: clone a virtual machine either from a snapshot, or from its current running state.