Schlagwort-Archive: VMDK

Utilize PowerCLI to resize VMDK files of multiple VMs

This is the translated version of an article written in German originally. I translated it as a non-German speaking person has shown interest in the topic.

Disclaimer: This tutorial comes without warranty and support. Use at your own risk.

In this tutorial, I would like to show a minimal example on how selected VMDK files of specific VMs can be resized with using the PowerCLI.

This is useful, for example, when so many VMs are affected that the time and effort required to manually enlarge them via the vSphere (web) client seems too great.

Only the resizing of the VMDK file is considered here. The subsequent resizing of the partition and file system within the guest operating system, which is also necessary, is not part of this tutorial.

Goal

For a minimal example, from a group of VMs the second and third hard disk of VM-Test-5 and VM-Test-6 are to be enlarged. The respective second hard disk is to be enlarged from 250 GB to 500 GB and the respective third hard disk is to be enlarged from 400 GB to 800 GB.

Requirements

A working installation of the VMware PowerCLI and the ability to access the vCenter Server is a prerequisite to follow this tutorial.

Here we go

The following code block shows how the necessary information about the VMs is read out to be processed.

PowerCLI C:\Scripts> Get-VM | Where-Object {$_ | Select-String -pattern "VM-Test-\d"}

Name                 PowerState Num CPUs MemoryGB
----                 ---------- -------- --------
VM-Test-5        PoweredOn  4        24.000
VM-Test-7        PoweredOn  4        16.000
VM-Test-6        PoweredOn  4        24.000


PowerCLI C:\Scripts> Get-VM | Where-Object {$_ | Select-String -pattern "VM-Test-[5,6]{1}"}

Name                 PowerState Num CPUs MemoryGB
----                 ---------- -------- --------
VM-Test-5        PoweredOn  4        24.000
VM-Test-6        PoweredOn  4        24.000


PowerCLI C:\Scripts> $VM = Get-VM | Where-Object {$_ | Select-String -pattern "VM-Test-[5,6]{1}"}
PowerCLI C:\Scripts> Get-VM $VM | Get-HardDisk | FT Parent, Name, CapacityGB -AutoSize

Parent        Name        CapacityGB
------        ----        ----------
VM-Test-5 Hard disk 1         40
VM-Test-5 Hard disk 2        250
VM-Test-5 Hard disk 3        400
VM-Test-5 Hard disk 4         80
VM-Test-6 Hard disk 1         40
VM-Test-6 Hard disk 2        250
VM-Test-6 Hard disk 3        400
VM-Test-6 Hard disk 4         80

From the above output you can see that we want to enlarge the VMDK files which are called „Hard disk 2“ and „Hard disk 3“ respectively.

In the code block that follows, I first define a few variables, then double check that I am selecting the correct VMDK files for the operation, and then I resize them.

PowerCLI C:\Scripts> $HardDisk = 2
PowerCLI C:\Scripts> $HardDisk = "Hard disk " + $HardDisk
PowerCLI C:\Scripts> $HardDiskSize = 500
PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk}

CapacityGB      Persistence                                              Filename
----------      -----------                                                    --------
250.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_1.vmdk
250.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_1.vmdk


PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk} | Set-HardDisk -CapacityGB $HardDiskSize -Conf
irm:$false

CapacityGB      Persistence                                                    Filename
----------      -----------                                                    --------
500.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_1.vmdk
500.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_1.vmdk


PowerCLI C:\Scripts> Get-VM $VM | Get-HardDisk | FT Parent, Name, CapacityGB -AutoSize

Parent        Name        CapacityGB
------        ----        ----------
VM-Test-5 Hard disk 1         40
VM-Test-5 Hard disk 2        500
VM-Test-5 Hard disk 3        400
VM-Test-5 Hard disk 4         80
VM-Test-6 Hard disk 1         40
VM-Test-6 Hard disk 2        500
VM-Test-6 Hard disk 3        400
VM-Test-6 Hard disk 4         80


PowerCLI C:\Scripts> $HardDisk = 3
PowerCLI C:\Scripts> $HardDisk = "Hard disk " + $HardDisk
PowerCLI C:\Scripts> $HardDiskSize = 800
PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk}

CapacityGB      Persistence                                                    Filename
----------      -----------                                                    --------
400.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_2.vmdk
400.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_2.vmdk


PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk} | Set-HardDisk -CapacityGB $HardDiskSize -Conf
irm:$false

CapacityGB      Persistence                                                    Filename
----------      -----------                                                    --------
800.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_2.vmdk
800.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_2.vmdk


PowerCLI C:\Scripts>

If the above code block is not self-explanatory, feel free to post your questions about it in the comments. I’ll try to complete the tutorial in a timely manner.

VMware ESXi: VMDK-Datei einer Gast-VM mit virt-sysprep bereinigen

Soll eine virtuelle Maschine (VM) als Vorlage (engl. template) für weitere VMs dienen, so ist es in der Regel ausreichend, eine VM mit dem gewünschten Betriebssystem zu installieren und zukünftig als Vorlage zu verwenden. Anschließend kann diese VM über die Werkzeuge im ESXi-Host- bzw. vSphere-Client geklont werden. Die dabei erzeugte VM kann während dieses Vorgangs mithilfe einer Gast-Anpassungsspezifikation angepasst werden, um z.B. einen neuen Hostnamen oder eine abweichende IP-Adresse zu vergeben.

Klont man nach dem beschriebenen Verfahren eine Linux-VM, enthält diese noch die Historie des Originals. So werden z.B. bash-history, crontabs, ssh-hostkeys, ssh-userdirs, etc. vom Original übernommen und bestehen in der neuen VM fort. Um dies zu verhindern, sind diese Informationen zuvor aus der VM, welche als Vorlage dient, zu entfernen. Dazu kann man sich eigener Skripte bedienen oder auf das Programm virt-sysprep zurückgreifen, welches genau für diese Aufgabe geschaffen wurde.

Im Folgenden dokumentiere exemplarisch, wie man mit virt-sysprep eine VMDK-Datei bearbeiten kann, die im Datenspeicher eines ESXi-Hosts abgelegt ist.

Warnung: Folgende Schritte werden von VMware nicht unterstützt. Es besteht die Gefahr des Datenverlusts durch beschädigte VMDK-Dateien. Wer diesem Tutorial folgt, tut dies auf eigene Gefahr. Zuvor sollte geprüft werden, ob ein aktuelles Backup existiert, welches bei Bedarf wiederhergestellt werden kann.

Umgebung

Für dieses Tutorial wird ein Linux-Arbeitsplatz verwendet, auf dem die Pakete libguestfs-tools und sshfs zu installieren sind.

Die zu bearbeitende VMDK-Datei heißt in diesem Beispiel vmname-flat.vmdk und liegt im Datenspeicher eines ESXi-Hosts.

Vom Linux-Arbeitsplatz aus kann via SSH auf den Root-Account des ESXi-Hosts zugegriffen werden.

Ein virt-sysprep-wrapper-Skript

Ich möchte auf meine VMDK-Dateien die Standard-Operationen von virt-sysprep, mit Ausnahme der Operation ssh-userdir anwenden (siehe OPERATIONS in virt-sysprep(1)). Dazu habe ich ein kurzes Wrapper-Skript erstellt, welches eine notwendige Umgebungsvariable setzt, den Pfad zur zu bearbeitenden VMDK-Datei als Argument übergeben bekommt und die gewünschten Operationen darauf ausführt. Das Skript ist im Folgenden dargestellt. Die eigentliche Aktion passiert in den letzten beiden Zeilen.

#!/bin/bash
# Author: Joerg Kastning
# Description:
# Sysprep RHEL vSphere templates using `virt-sysprep` from `libguestfs-tools`.

usage()
{
  cat << EOF
  usage: $0 OPTIONS $1

  This script use virt-sysprep to reset, unconfigure or customize a virtual machine so clones can be made (virt-sysprep(1)).

  The path to the file VMNAME-flat.vmdk has to be provided as $1.

  OPTIONS:
  -h Shows this help message.
EOF
}

export LIBGUESTFS_BACKEND=direct
virt-sysprep --operations defaults,-ssh-userdir -a $1

Das Skript liegt im Verzeichnis bin, im HOME-Verzeichnis meines Benutzers. Damit befindet sich das Skript im PATH und kann ohne den vollqualifizierten Pfad aufgerufen werden.

Der Ablauf

Wichtig: Die VM, deren VMDK-Datei bearbeitet werden soll, MUSS ausgeschaltet sein.

Zuerst müssen die Pakete libguestfs-tools und sshfs auf dem Linux-Arbeitsplatz installiert werden:

sudo [apt|yum|dnf] install libguestfs-tools sshfs

Alle weiteren Schritte werden auf dem Linux-Arbeitsplatz ausgeführt:

$ mkdir vmfs
$ sshfs root@esxi-host.beispiel.de:/vmfs vmfs
$ cd vmfs/pfad/zum/verzeichnis/der/VM/
$ virt-sysprep-wrapper.sh vmname-flat.vmdk
[   0,0] Examining the guest ...
[  15,1] Performing "abrt-data" ...
[  15,3] Performing "backup-files" ...
[  24,4] Performing "bash-history" ...
[  24,5] Performing "blkid-tab" ...
[  24,7] Performing "crash-data" ...
[  24,7] Performing "cron-spool" ...
[  24,8] Performing "dhcp-client-state" ...
[  25,0] Performing "dhcp-server-state" ...
[  25,0] Performing "dovecot-data" ...
[  25,0] Performing "logfiles" ...
[  28,2] Performing "machine-id" ...
[  28,3] Performing "mail-spool" ...
[  28,3] Performing "net-hostname" ...
[  28,6] Performing "net-hwaddr" ...
[  28,8] Performing "pacct-log" ...
[  28,9] Performing "package-manager-cache" ...
[  30,5] Performing "pam-data" ...
[  30,5] Performing "passwd-backups" ...
[  30,6] Performing "puppet-data-log" ...
[  30,7] Performing "rh-subscription-manager" ...
[  30,8] Performing "rhn-systemid" ...
[  30,9] Performing "rpm-db" ...
[  31,0] Performing "samba-db-log" ...
[  31,1] Performing "script" ...
[  31,1] Performing "smolt-uuid" ...
[  31,1] Performing "ssh-hostkeys" ...
[  31,2] Performing "sssd-db-log" ...
[  31,3] Performing "tmp-files" ...
[  31,8] Performing "udev-persistent-net" ...
[  31,9] Performing "utmp" ...
[  31,9] Performing "yum-uuid" ...
[  32,0] Performing "customize" ...
[  32,2] Setting a random seed
[  32,3] Setting the machine ID in /etc/machine-id
[  32,9] Performing "lvm-uuids" ...
$ cd
$ fusermount -u vmfs

Damit ist die VM von ihrer Geschichte befreit und kann nun als bereinigte Vorlage für weitere VMs dienen.

Quellen und weiterführende Links

VMDK-Dateien mit Hilfe der PowerCLI vergrößern

In diesem Tutorial möchte ich an einem Minimal-Beispiel zeigen, wie mit Hilfe der PowerCLI ausgewählte VMDK-Dateien spezifischer VMs vergrößert werden können.

Dies bietet sich z.B. immer dann an, wenn so viele VMs betroffen sind, dass der Aufwand der manuellen Vergrößerung über den vSphere-(Web)-Client zu groß erscheint.

Betrachtet wird hier lediglich die Vergrößerung der VMDK-Datei. Die anschließend ebenfalls notwendige Vergrößerung von Partition und Dateisystem innerhalb des Gast-Betriebssystems ist nicht Bestandteil dieses Tutorials.

Zielstellung

Für das Minimalbeispiel sollen aus einer Gruppe VMs die jeweils zweite und dritte Festplatte von VM-Test-5 und VM-Test-6 vergrößert werden. Die jeweilige zweite Festplatte ist von 250 GB auf 500 GB zu vergrößern und die jeweilige dritte Festplatte soll von 400 GB auf 800 GB vergrößert werden.

Voraussetzungen

Eine funktionsfähige Installation der VMware PowerCLI und die Möglichkeit den vCenter Server über diese ansprechen zu können, ist Voraussetzung, um diesem Tutorial zu folgen.

Ablauf

Im folgenden Code-Block wird dargestellt, wie wir die notwendigen Informationen über die zu bearbeitenden VMs auslesen.

PowerCLI C:\Scripts> Get-VM | Where-Object {$_ | Select-String -pattern "VM-Test-\d"}

Name                 PowerState Num CPUs MemoryGB
----                 ---------- -------- --------
VM-Test-5        PoweredOn  4        24.000
VM-Test-7        PoweredOn  4        16.000
VM-Test-6        PoweredOn  4        24.000


PowerCLI C:\Scripts> Get-VM | Where-Object {$_ | Select-String -pattern "VM-Test-[5,6]{1}"}

Name                 PowerState Num CPUs MemoryGB
----                 ---------- -------- --------
VM-Test-5        PoweredOn  4        24.000
VM-Test-6        PoweredOn  4        24.000


PowerCLI C:\Scripts> $VM = Get-VM | Where-Object {$_ | Select-String -pattern "VM-Test-[5,6]{1}"}
PowerCLI C:\Scripts> Get-VM $VM | Get-HardDisk | FT Parent, Name, CapacityGB -AutoSize

Parent        Name        CapacityGB
------        ----        ----------
VM-Test-5 Hard disk 1         40
VM-Test-5 Hard disk 2        250
VM-Test-5 Hard disk 3        400
VM-Test-5 Hard disk 4         80
VM-Test-6 Hard disk 1         40
VM-Test-6 Hard disk 2        250
VM-Test-6 Hard disk 3        400
VM-Test-6 Hard disk 4         80

Aus der obigen Ausgabe ist zu erkennen, dass wir die VMDK-Dateien, welche als „Hard disk 2“ bzw. „Hard disk 3“ bezeichnet werden, vergrößern möchten.

In dem nun folgenden Code-Block definiere ich zuerst ein paar Variablen, welche ich für den Verarbeitungslauf benötige, anschließend prüfe ich noch einmal, ob ich die richtigen VMDK-Dateien für die Operation auswähle und vergrößere sie anschließend.

PowerCLI C:\Scripts> $HardDisk = 2
PowerCLI C:\Scripts> $HardDisk = "Hard disk " + $HardDisk
PowerCLI C:\Scripts> $HardDiskSize = 500
PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk}

CapacityGB      Persistence                                                    Filename
----------      -----------                                                    --------
250.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_1.vmdk
250.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_1.vmdk


PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk} | Set-HardDisk -CapacityGB $HardDiskSize -Conf
irm:$false

CapacityGB      Persistence                                                    Filename
----------      -----------                                                    --------
500.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_1.vmdk
500.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_1.vmdk


PowerCLI C:\Scripts> Get-VM $VM | Get-HardDisk | FT Parent, Name, CapacityGB -AutoSize

Parent        Name        CapacityGB
------        ----        ----------
VM-Test-5 Hard disk 1         40
VM-Test-5 Hard disk 2        500
VM-Test-5 Hard disk 3        400
VM-Test-5 Hard disk 4         80
VM-Test-6 Hard disk 1         40
VM-Test-6 Hard disk 2        500
VM-Test-6 Hard disk 3        400
VM-Test-6 Hard disk 4         80


PowerCLI C:\Scripts> $HardDisk = 3
PowerCLI C:\Scripts> $HardDisk = "Hard disk " + $HardDisk
PowerCLI C:\Scripts> $HardDiskSize = 800
PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk}

CapacityGB      Persistence                                                    Filename
----------      -----------                                                    --------
400.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_2.vmdk
400.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_2.vmdk


PowerCLI C:\Scripts> Get-HardDisk -vm $VM | where {$_.Name -eq $HardDisk} | Set-HardDisk -CapacityGB $HardDiskSize -Conf
irm:$false

CapacityGB      Persistence                                                    Filename
----------      -----------                                                    --------
800.000         IndependentPersis... ...STD-2.9T-02] VM-Test-5/VM-Test-5_2.vmdk
800.000         IndependentPersis... ...STD-2.9T-01] VM-Test-6/VM-Test-6_2.vmdk


PowerCLI C:\Scripts>

Falls der obige Code-Block nicht selbsterklärend ist, stellt eure Fragen dazu gern in den Kommentaren. Ich versuche das Tutorial dann zeitnah zu ergänzen.

VirtualBox VDI Datei in VMware VMDK Datei konvertieren

Schon 2012 habe ich im Artikel Virtualbox und das Open Virtualization Format darüber berichtet, dass sich ins OVF bzw. OVA Format exportierte VMs nicht in einer VMware vSphere Umgebung importieren lassen. Leider hat sich an diesem Umstand bis heute nichts geändert. Daher habe ich mir einen neuen Weg gesucht, um VMs von Virtualbox nach vSphere zu migrieren.

Auf dem ESXi ist zuerst eine neue virtuelle Maschine ohne Festplatte zu erstellen. Um nun die VDI aus VirtualBox nutzen zu können, muss diese zuerst in eine VMDK Datei konvertiert werden.

Eine Lösung fand ich in diesem englischsprachigen Blogpost. Zur Konvertierung nutzen wir das Tool „vboxmanage“ auf der Komandozeile. Der folgende Codeschnipsel zeigt einen Beispielaufruf:

C:\Program Files\Oracle\VirtualBox>vboxmanage clonehd "Pfad zur VDI Datei\quelldatei.vdi" "Pfad zur VDI Datei"\zieldatei.vmdk --format VMDK --variant Standard

vditovmdk

Beispiel einer Konvertierung von VirtualBox zu VMware.

Mit dem obigen Aufruf wird im selben Verzeichnis, in dem die VDI Datei liegt eine VMDK Datei erzeugt. Diese kann nun in den Datastore eines ESXi Hypervisor hochgeladen und als virtuelle Festplatte einer VM hinzugefügt werden.

Anschließend kann man die VM starten und sie weiter nutzen.

Update 16.3.2014: Hier kommt ein wichtiger Nachtrag aus der Praxis. Er soll ich davor bewahren, die gleichen Erfahrungen wie ich machen zu müssen. Die oben beschriebene Migration von VirtualBox zu vSphere führte zu einem wahren Härtetest von vSphere HA.

Nach dem Start der VM im vSphere Cluster sollten im nächsten Schritt die VBox Guest Additions deinstalliert und die VMware Tools installiert werden. Doch soweit bin ich gar nicht erst bekommen.

Denn die migrierte VM hängte sich auf und lies sich nicht mehr steuern. Auch ein Zurücksetzen der VM zeigte keinerlei Wirkung. Nur kurze Zeit später stürzte der ganze Hypervisor ab und der Cluster führte einen Failover durch. Dadurch wurde leider auch die fehlerhafte VM auf einen anderen Host übertragen und brachte diesen ebenfalls zum Absturz, bevor ich die VM stoppen und löschen konnte.

Zwei Hypervisor-Abstürze innerhalb von 30 Minuten sind eindeutig zwei zu viel. Für den VMware Support war dieses Verhalten ebenfalls neu. Hier bekam ich den Rat zukünftig die VirtualBox Guest Additions zu deinstallieren, bevor ich die VDI Datei konvertiere.

Für unseren Betrieb haben wir hingegen festgelegt keine weiteren VMs auf diesem Weg zu migrieren. Wir werden VMs nach einer Testphase durch Neuinstallation ins Cluster überführen. So können wir durch Konvertierung verursachte Fehler ausschließen und erstellte Dokumentationen überprüfen, indem wir das System nach der Dokumentation erneut bereitstellen.

vSphere: Virtuelle Festplatte klonen

Möchte man mehrere gleichartige Server bereitsellen, lässt sich die Bereitstellung beschleunigen, indem man einen Server installiert und die Festplatte klont.

Man erstellt dazu weitere VMs ohne Festplatte über den vSphere Client. Eine VMDK kann über die SSH-Shell mit folgendem Befehl geklont werden:

vmkfstools -i /path/old/vm/foo.vmdk /path/new/foo.vmdk

Virtualbox und das Open Virtualization Format

Dieser Artikel bietet eine Kurzzusammenfassung meiner bisherigen Erfahrungen mit VirtualBox und dem Open Virtualization Format.

VirtualBox ist eine Virtualisierungslösung welche unter der GNU General Public License (GPL) version 2 steht. Ich benutze diese Software privat schon seit einigen Jahren. Zum Einen um mein Windows 7 Betriebssystem auf meinem Ubuntu Notebook zu betreiben und zum Anderen, um gefahrlos neue Betriebssysteme oder Konfigurationen ausprobieren zu können, ohne nach einem Fehler immer gleich das ganze Notebook bzw. den PC neu installieren zu müssen. Und bis heute leistet VirtualBox gute Arbeit. Was mir besonders gefällt ist das die Software alle gängigen virtuellen Festplattenformate wie

  • VDI (Virtual Disk Image),
  • VMDK (Virtual Machine Disk),
  • VHD (Virtual Hard Disk) und
  • HDD (Parallels)

unterstützt. Somit ist VirtualBox kompatibel zu VMs, die unter VMware, Hyper-V oder Parallels erstellt wurden.

Doch nicht immer starten VMs die man von einem System auf ein anderes portiert hat auch auf Anhieb. Ich wollte die (virtuelle) Windows 7 Installation von meinem Desktop PC auf meine Notebook bringen und habe im ersten Versuch einfach die virtuelle Festplattendatei kopiert. Auf meinem Notebook habe ich nun eine neue VM mit gleicher Anzahl CPUs und RAM wie auf dem Desktop PC erstellt und die kopierte Festplatte verwendet. Mit dem Ergebnis, dass Windows den Bootvorgang mit einem Bluescreen abbrach. Der Grund für dieses Verhalten ist meist, dass in der neuen VM ein anderer Gerätetreiber für die Festplatte verwendet wird oder die ACPI Einstellungen nicht mit denen übereinstimmen, mit denen Windows installiert wurde.

An dieser Stelle kommt nun das Open Virtualisation Format, kurz OVF, ins Spiel. OVF ist ein offener Standard, um virtuelle Maschinen verteilen zu können. Die Anwendung in VirtualBox ist denkbar einfach. Man wählt aus dem Hauptmenü die Option „Appliance exportieren“ und wählt aus der Liste seiner VMs die Maschine(n) aus, die man gerne auf ein anderes System übertragen möchte. Bei Verwendung des OVA Formats werden die Einstellungen der VM und die virtuelle Festplatte in ein Archiv gepackt und sind damit bereit für die Verteilung. Der Import geht, zumindest unter VirtualBox, ebenso spielen von der Hand. Man wählt den Punkt „Appliance Importieren“ aus dem Menü, wählt die OVA Datei aus und importiert die VM mit den Originaleinstellungen.

Ich habe dies mit meiner Windows 7 Installation getestet und kann sagen, dass es hervorragend funktioniert hat. Windows startete sofort und ohne Fehler auch auf meinem Notebook.

Damit ist VirtualBox eigentlich bestens für die Erstellung von Verteilung von VMs gerüstet. Das einzige Problem ist, dass laut Wikipedia noch nicht viele Mitbewerber Open Virtualization unterstützen und man so exportierte VMs z.B. auf einem ESXi bzw. Hyper-V Host nicht einfach importieren kann. Ich wünschte die großen Anbieter würden hier zügig nachrüsten.

Falls jemand bereits Erfahrungen damit gesammelt hat mit VirtualBox erzeugte VMs auf ESXi oder Hyper-V zu portieren, würde ich mich freuen, wenn Er oder Sie diese Erfahrungen mit mir teilt.

Mich hat VirtualBox überzeugt. Für den privaten Gebrauch ist es bestens geeignet.