Eric Sloof

UTM is revolutionizing the way we think about virtual machines on Apple devices. It's a comprehensive system emulator and virtual machine host, specially designed for iOS and macOS. Built on the robust foundation of QEMU, UTM enables users to seamlessly run various operating systems like Windows and Linux on their Mac, iPhone, and iPad.

UTM is a game-changer for Apple Silicon users. It uses Apple's Hypervisor virtualization framework, allowing ARM64 operating systems to run at speeds almost identical to native performance. For those with Intel Macs, there's the ability to virtualize x86/x64 operating systems. And it doesn’t stop there - UTM also offers lower performance emulation for running x86/x64 on Apple Silicon and ARM64 on Intel. This versatility extends to supporting a range of other emulated processors, including ARM32, MIPS, PPC, and RISC-V, making your Mac a truly universal platform.

UTM isn’t just about the new and shiny; it also breathes life into classic operating systems. Whether it's an old PowerPC, SPARC, or x86_64 system, UTM lets you revisit the digital past. Curious users can explore a gallery showcasing various systems that UTM can emulate.

Apple Silicon Mac users can take virtualization a step further with UTM. It allows the running of multiple instances of macOS, which is particularly beneficial for developers and security-focused users. This feature, however, is exclusive to ARM-based Macs running macOS Monterey or higher.

UTM stands out from other virtualization software due to its design, which is exclusively for macOS and Apple platforms. It seamlessly blends with the Big Sur style, offering a user experience that feels genuinely Mac-like, complete with all the expected privacy and security features.

At its core, UTM harnesses the power of QEMU, a well-established, free, and open-source emulation software. QEMU's complexity is well-known, often deterring users with its array of command-line options. UTM eliminates this barrier, offering the robust features of QEMU without the complexity, making it accessible to a wider range of users.

Virtual machines on Apple devices have never been more accessible and versatile, thanks to UTM. Whether you're a developer, an enthusiast, or just someone who needs to run different operating systems on your Apple device, UTM is the tool you've been waiting for. Discover more about UTM and how it can transform your virtual machine experience on Apple devices at https://getutm.app/ and https://mac.getutm.app/.

In this article, we'll explore how ChatGPT can automate the generation of a Python script for managing the power states of virtual machines within VMware vCenter. To initiate, you need to prompt ChatGPT to generate a script by posing the question:

Could you develop a Python script for VMware vCenter to retrieve the virtual machines and allow the user to control their power states? The server details are: host name 'vc.ntpro.local', username 'administrator@ntpro.local', password 'VMware1!' Please ignore certificate errors and use tls.

ChatGPT's response will be affirmative, recommending the use of the pyvmomi library to interface with VMware vCenter. It will advise on installing the pyvmomi library via pip, if not already done so.

You can find the complete Python code through this link. 

For Python project management, I prefer the PyCharm Community Edition. The pyvmomi module is crucial for our tasks and can be conveniently installed via the terminal with 'pip install pyvmomi'. PyCharm also offers a GUI for handling Python packages.

After generating a new Python file, insert the ChatGPT-provided script into PyCharm's editor. Execution may require some adjustments, like updating TLS versions. Should errors arise, ChatGPT is equipped to troubleshoot and provide solutions. Once the refined script is implemented, it successfully retrieves and manages the power states of the virtual machines from vCenter.

In a subsequent step, I prompted ChatGPT to integrate a basic GUI into the script using the pre-installed TKInter module from Python3. The resulting interface displays a virtual machine list with functional power controls. Despite a minor glitch with the "wait task" during the demonstration, the core functionality was unaffected.
Remember, repeated queries won't yield identical results when soliciting code from ChatGPT. Precision in your inquiries enhances ChatGPT's ability to generate effective code. If your code encounters issues, ChatGPT can help debug and even elucidate the script's workings in depth. Enjoy coding!

vSphere comes equipped with a vast array of metrics and properties. A detailed object-by-object and metric-by-metric documentation might seem dry and overly theoretical, potentially leading to disappointment, as it might not directly address real-world problem-solving. Collecting metrics is not the core of your business.

This document is tailored for experienced VMware professionals focused on optimizing and troubleshooting in production environments. It introduces metrics using the Triple See Method, a strategy that aligns metrics with operational management.

This is an advanced-level text, spanning over 300 pages. It's not a quick read, so Iwan 'e1' Rahabok suggested settling down with a coffee or your preferred beverage for a thorough and quiet reading session.

In this article, we explore the innovative implementation of VMware's ESXi ARM on the Raspberry Pi 5. The focus is on setting up ESXi ARM on the Raspberry Pi 5, which was initially challenged by a lack of UEFI support. This obstacle is surmounted by Mario Bălănică's development of a Raspberry Pi 5-specific UEFI bios. The setup process is detailed, emphasizing the necessity of an external USB network adapter, and the steps from microSD card preparation to management network configuration.

In 2018, Pat Gelsinger, then CEO of VMware, made a groundbreaking announcement at the VMworld keynote presentation in Las Vegas, revealing the ability to operate ESXi on a Raspberry Pi. Following the presentation, I connected with Alexander Fainkichen, a pivotal contributor to the initiative, for a sit-down interview. As a presenter for VMworld TV at a time when edge computing was surging in popularity, I had the opportunity to delve into the subject. The full interview remains accessible on VMware’s Explore channel.

‘Back at Vegas, people asked us in jest whether the Pi could ever run ESX. We decided it was worth showing that it is possible. ESX on Pi is a promise that VMware understands that the Edge includes extremely low end devices as well. Scaling with the workload and envo is important!’
 

I recently acquired the cutting-edge Raspberry Pi 5, aiming to set up ESXi ARM. It was tailored for the Raspberry Pi 4, but initial attempts to operate it on the Raspberry Pi 5 were met with a challenge due to the absence of UEFI support.
 

However, this scenario changed about a week back when Mario Bălănică, associated with the Windows on Raspberry (WoR) project, unveiled a UEFI bios specially designed for the Raspberry Pi 5. This critical development has enabled the device to install ESXi ARM.

Before proceeding, it's important to note a few prerequisites. The Raspberry Pi 5's built-in network adapter is marked an unsupported UEFI peripheral, necessitating the use of an external USB network adapter. For my setup, I chose the Maxonar USB C Ethernet Adapter, which offers reliable Gigabit LAN connectivity.

The installation procedure is quite direct. Begin by copying the UEFI files onto a microSD card formatted to FAT32. Next, transfer the ISO contents of the ESXi ARM installer onto a FAT32-compliant USB drive. Once you power up the Raspberry Pi, the installation should initiate on its own.

During my initial setup, the installation paused at 81%, hindered by the lack of a network adapter for the management network. This hiccup is overcome on the first reboot, where the USB network adapter is recognized, allowing the configuration of the management network thereafter.

The storage setup utilizes a USB interface, connecting through a robust "UGREEN M.2 Adapter NVMe SSD Hard Drive Enclosure" which houses a swift "Samsung SSD 256GB PM991 M.2 2242 42mm PCIe 3.0 x4 NVMe" drive. This USB drive plays a triple role: it's the install-boot media, the destination for the ESXi install, and the local storage for VMFS (Virtual Machine File System). You can leave it inserted after the installation completes. In future enhancements, I plan to integrate the Samsung SSD into my setup more seamlessly, using the PineBerry m.2 HATDrive, interfaced via NVMe.

In this video, I've captured the entire installation process from beginning to end, and it takes just 5 minutes to complete. The recording was done using a Video Capture Card, a Guermok USB 3.0 HDMI to USB C Audio Capture Card, and QuickTime on a Mac.

Once the installation is finalized, the next step is to start running virtual workloads. My first action was to set up a Photon virtual machine; VMware conveniently provides an ARM-compatible OVA file. The process is hassle-free, since I'm using Virtual Center to manage the ARM-based ESXi host—just a few clicks and the virtual machine springs to life.

The subsequent hurdle was setting up a Windows environment. Locating an ARM-compatible Windows ISO proved challenging, but after a diligent search, I found one. I uploaded the ISO to the local data store and configured a Windows VM. The installation of Windows was time-consuming, and the initial startup was even more prolonged. Eventually, a blue screen error interrupted the process, which requires further investigation.

Initially, I operated on a Raspberry Pi 5 with 4 GB of RAM, but soon transitioned to a more robust 8 GB model to accommodate additional VM workloads. Monitoring of the vCenter server is conducted through Aria Operations, which allows me to keep an eye on the ESXi ARM host and virtual machines via comprehensive dashboards. I've also set up Aria Operations for log management, simplifying the troubleshooting process. 

In summary, the article showcases the advancements and challenges in setting up and running ESXi ARM on the Raspberry Pi 5. It highlights the technical requirements, the setup process, and the potential for hosting various virtual workloads, along with the importance of continuous monitoring and system optimization. Special thanks to Jimmy van der Mast for providing technical expertise.

In the ever-evolving landscape of virtualization management, efficiency is key. VMware's vCenter Server is the heart of many virtual environments, orchestrating a symphony of VMs with precision. But what if you could take vCenter's capabilities to the next level? Enter Python – the versatile scripting language that speaks directly to vCenter, unlocking a new realm of automation and control.

Python is more than just a programming language; it's a gateway to automation. With the Python SDK for VMware, known as PyVmomi, you can script complex operations that manage your virtual machines, all within the comfort of Python’s syntax. Whether you’re looking to power on a fleet of VMs, take snapshots before a big update, or gracefully shut down systems for maintenance, Python and PyVmomi make it possible with minimal effort.

Imagine a script that not only lists all VMs registered in your vCenter but also offers you the control to power them on, suspend, resume, or even take a snapshot. This is not a mere imagination anymore; it's a reality that I've crafted into a Python script. This script is your remote control to vCenter, putting the power of virtual machine management at your fingertips.

The script starts by connecting to your vCenter server using your credentials. Once authenticated, it fetches a list of all VMs and displays them neatly. Here's where the interactivity comes in – you choose a VM and decide what to do with it. Want to power it on or shut it down? Just a command away. Need to suspend or resume it? A simple input does the job. Looking to create a snapshot? It’s just as easy.

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

# vCenter Server details
vc_server = 'vc.ntpro.local'
username = 'administrator@ntpro.local'
password = 'VMware1!'

# Disable SSL certificate verification (for demo purposes only, not recommended for production)
context = ssl._create_unverified_context()

# Function to connect to vCenter
def connect_to_vcenter(server, user, password):
    si = SmartConnect(host=server, user=user, pwd=password, sslContext=context)
    atexit.register(Disconnect, si)
    return si

# Function to get all VMs
def get_all_vms(si):
    content = si.RetrieveContent()
    container = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True)
    return container.view

# Power operations for the VM
def power_on_vm(vm):
    if vm.runtime.powerState != vim.VirtualMachinePowerState.poweredOn:
        task = vm.PowerOnVM_Task()
        wait_for_task(task)
        print(f"VM '{vm.name}' is powered on.")
    else:
        print(f"VM '{vm.name}' is already powered on.")

def power_off_vm(vm):
    if vm.runtime.powerState != vim.VirtualMachinePowerState.poweredOff:
        task = vm.PowerOffVM_Task()
        wait_for_task(task)
        print(f"VM '{vm.name}' is powered off.")
    else:
        print(f"VM '{vm.name}' is already powered off.")

def suspend_vm(vm):
    if vm.runtime.powerState == vim.VirtualMachinePowerState.poweredOn:
        task = vm.SuspendVM_Task()
        wait_for_task(task)
        print(f"VM '{vm.name}' is suspended.")
    else:
        print(f"VM '{vm.name}' cannot be suspended because it is not powered on.")

def resume_vm(vm):
    if vm.runtime.powerState == vim.VirtualMachinePowerState.suspended:
        task = vm.PowerOnVM_Task()
        wait_for_task(task)
        print(f"VM '{vm.name}' is resumed.")
    else:
        print(f"VM '{vm.name}' is not suspended.")

def create_snapshot(vm):
    task = vm.CreateSnapshot_Task(name='Snapshot', description='Created by script', memory=False, quiesce=False)
    wait_for_task(task)
    print(f"Snapshot for VM '{vm.name}' created.")

# Wait for vCenter task to complete
def wait_for_task(task):
    task_done = False
    while not task_done:
        if task.info.state == vim.TaskInfo.State.success:
            return
        if task.info.state == vim.TaskInfo.State.error:
            print(f"Task failed: {task.info.error}")
            raise Exception("Task failed")

# Main script logic
if __name__ == "__main__":
    si = connect_to_vcenter(vc_server, username, password)
    vms = get_all_vms(si)
    vms_dict = {vm.name: vm for vm in vms}
    
    print("List of VMs:")
    for vm_name in vms_dict.keys():
        print(vm_name)
    
    selected_vm_name = input("Enter the name of the VM you wish to manage: ")
    vm = vms_dict.get(selected_vm_name)
    
    if vm:
        print(f"Selected VM: {selected_vm_name}")
        action = input("Choose an action: (on) Power On, (off) Power Off, (suspend) Suspend, (resume) Resume, (snapshot) Create Snapshot: ").lower().strip()
        if action == 'on':
            power_on_vm(vm)
        elif action == 'off':
            power_off_vm(vm)
        elif action == 'suspend':
            suspend_vm(vm)
        elif action == 'resume':
            resume_vm(vm)
        elif action == 'snapshot':
            create_snapshot(vm)
        else:
            print("Invalid action selected.")
    else:
        print(f"VM '{selected_vm_name}' not found.")

The script is designed with safety and ease of use in mind, leveraging Python’s clear syntax and PyVmomi’s powerful bindings to the vSphere API. It’s a tool that can be expanded, customized, and integrated into larger workflows or dashboards. I'm hosting the source code, along with some screenshots on my GitHub page.

Unlock the power of Python to seamlessly gather and harness data from Aria Operations (vROps). This blog post introduces a Python script that connects to vROps, efficiently authenticating to obtain a secure token. This token is the golden key, allowing the script to pull detailed metrics for a virtual machine named 'Raspberry'.

import requests
import json

# Replace these with your vROps details
vrops_host = 'https://ariaops.ntpro.local'
username = 'admin'
password = 'VMware1!'

# Endpoints
auth_url = f'{vrops_host}/suite-api/api/auth/token/acquire'
vm_search_url = f'{vrops_host}/suite-api/api/resources'
metrics_url_template = f'{vrops_host}/suite-api/api/resources/{{}}/stats'

# Authenticate and Get Token
headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
payload = {'username': username, 'password': password}
response = requests.post(auth_url, headers=headers, data=json.dumps(payload), verify=False)
token = response.json().get('token')

if not token:
    raise Exception("Authentication failed")

# Update headers with the token
headers['Authorization'] = f'vRealizeOpsToken {token}'

# Function to get the ID of a VM by its name
def get_vm_id(vm_name):
    vm_url = f'{vrops_host}/suite-api/api/resources'
    response = requests.get(vm_url, headers=headers, verify=False)
    if response.status_code == 200:
        resources = response.json()['resourceList']
        for resource in resources:
            if resource['resourceKey']['name'] == vm_name:
                return resource['identifier']
    return None

# Function to get metrics for a VM by its ID
def get_vm_metrics(vm_id):
    metrics_url = f'{vrops_host}/suite-api/api/resources/{vm_id}/stats'
    response = requests.get(metrics_url, headers=headers, verify=False)
    if response.status_code == 200:
        return response.json()
    return None

# Main script execution
vm_id = get_vm_id('raspberry')
if vm_id:
    vm_metrics = get_vm_metrics(vm_id)
    if vm_metrics:
        print("Metrics for VM 'raspberry':")
        print(json.dumps(vm_metrics, indent=4))
    else:
        print("Failed to retrieve metrics for VM 'raspberry'")
else:
    print("VM 'raspberry' not found")

Through this script, you can effortlessly access the Aria Ops REST API, which is designed to safeguard and validate your data retrieval missions. Once authenticated, you can harvest a rich dataset, which can then be woven into your custom solutions or operational dashboards. By leveraging this script, raw data can be transformed into actionable insights, enhancing virtual machine monitoring and management.

The source code, complete with an example of the output and some screenshots, is hosted on my GitHub page.