Wiki Ubuntu-it

Indice
Partecipa
FAQ
Wiki Blog
------------------
Ubuntu-it.org
Forum
Chiedi
Chat
Cerca
Planet
  • Pagina non alterabile
  • Informazioni
  • Allegati
  • Differenze per "Virtualizzazione/Kvm/CreazioneOspiti"
Differenze tra le versioni 1 e 73 (in 72 versioni)
Versione 1 del 22/03/2010 18.36.52
Dimensione: 11731
Autore: FabioMarconi
Commento:
Versione 73 del 24/10/2025 14.13.35
Dimensione: 11768
Autore: jeremie2
Commento: importato da ivantu/Virtualizzazione/Kvm/CreazioneOspiti
Le cancellazioni sono segnalate in questo modo. Le aggiunte sono segnalate in questo modo.
Linea 1: Linea 1:
##title KVM Create Guests #format wiki
#LANGUAGE it
<<BR>>
<<Indice(depth=2)>>
<<Informazioni(forum="http://forum.ubuntu-it.org/viewtopic.php?t=371617"; rilasci="25.10 25.04 24.04 22.04 10.04")>>
Linea 3: Linea 7:
[[BR]]
[[Indice(depth=2 align=right)]]
= Introduzione =
Linea 6: Linea 9:
= Creating virtual machines = Questa pagina spiega come creare e gestire macchine virtuali (ospiti) dopo aver installato '''[[Virtualizzazione/Kvm/Installazione|KVM]]''' su Ubuntu 22.04 e versioni successive.
Linea 8: Linea 11:
Now that KVM is installed, let's see how we create our first VM. This can be done using:
 * [[http://virt-manager.et.redhat.com|virt-manager]]: a GUI tool
 * [[http://www.howtoforge.com/installing-kvm-guests-with-virt-install-on-ubuntu-8.10-server|virt-install]], a python script developed by Red Hat
 * [[https://help.ubuntu.com/8.04/serverguide/C/ubuntu-vm-builder.html|ubuntu-vm-builder]], developed by Canonical.
La creazione di macchine virtuali può essere effettuata utilizzando principalmente:
 * '''virt-manager''': un'interfaccia grafica (GUI) completa e intuitiva.
 * '''virt-install''': uno strumento a riga di comando per la creazione automatizzata di VM.
 * '''virsh''': l'interfaccia a riga di comando per `libvirt`, utilizzata per la gestione delle VM esistenti.
Linea 13: Linea 16:
== Ubuntu-vm-builder: the fast & powerful way to create Ubuntu JEOS VMs == = Virt-manager: Creazione di una VM tramite interfaccia grafica =
Linea 15: Linea 18:
[[http://doc.ubuntu.com/ubuntu/serverguide/C/ubuntu-vm-builder.html|Ubuntu-vm-builder]] is probably the best tool to use if you want to create VMs running Ubuntu JEOS 8.04, as the install is entirely scripted (very fast). '''virt-manager''' è lo strumento più semplice e raccomandato per la maggior parte degli utenti per creare e gestire le macchine virtuali KVM.
Linea 17: Linea 20:
[[AmministrazioneSistema/InstallareProgrammi|Installare]] il pacchetto [[apt://virt-manager|virt-manager]].
Linea 18: Linea 22:
This tool is packaged, and in universe:  0. [[AmbienteGrafico/AvviareProgrammi|Avviare]] "Virtual Machine Manager".
 {{{#!wiki note
 Potrebbe essere richiesta la password di amministratore se l'utente non fa parte del gruppo `libvirt` (vedere la guida di installazione).
 }}}
 0. Creare una nuova macchina virtuale. Cliccare sull'icona "Crea una nuova macchina virtuale" (un monitor con una stella verde).
  * Metodo di installazione:
   * "Local install media (ISO image or CDROM)": Utilizzato per installare un sistema operativo da un file ISO o da un CD/DVD fisico. Questo è il metodo più comune.
   * "Network Install (HTTP, FTP, NFS)": Utilizzato per installare un sistema operativo tramite un server di installazione di rete.
   * "Import existing disk image": Utilizzato per configurare una VM che utilizzi un disco virtuale preesistente.
   * "Network Boot (PXE)": Utilizzato per l'avvio della VM tramite PXE da una rete.
  * Selezionare "Local install media" e cliccare "Avanti".
 0. Specificare il percorso del media di installazione:
  * Cliccare "Sfoglia..." per selezionare il file ISO del sistema operativo che si desidera installare.
  * Spuntare "Automatically detect from the install media / source". virt-manager tenterà di rilevare il tipo di sistema operativo e la variante per ottimizzare le impostazioni.
 0. Configurare RAM e CPU:
  * Assegnare la quantità di RAM desiderata alla VM. Si consiglia di lasciare almeno 1GB (1024 MB) per l'host.
  * Assegnare il numero di core CPU.
 0. Creare o specificare il disco virtuale:
  * "Crea una nuova immagine del disco gestita": Questo è il metodo predefinito e raccomandato. Specificare la dimensione desiderata per il disco. virt-manager creerà un'immagine qcow2 nella directory predefinita di libvirt (/var/lib/libvirt/images/).
  * "Seleziona o crea un volume di archiviazione personalizzato": Permette di usare un'immagine disco esistente o di crearne una in un percorso specifico o su un dispositivo a blocchi.
 0. Configurare la rete:
  * Selezionare la configurazione di rete desiderata:
   * "Virtual network 'default' (NAT)": La VM sarà isolata nella rete virtuale predefinita di libvirt, con accesso a Internet tramite NAT sull'host.
   * "Bridge device": Selezionare il bridge configurato sull'host (es. br0). La VM sarà direttamente visibile sulla rete fisica.
 0. Finalizzare la creazione:
  * Assegnare un nome alla macchina virtuale.
  * Spuntare "Personalizza la configurazione prima di installare" per accedere a opzioni avanzate (es. aggiungere più CPU, modificare il tipo di scheda di rete in virtio, aggiungere dispositivi USB, ecc.).
  * Cliccare "Fine". La VM si avvierà e sarà possibile procedere con l'installazione del sistema operativo come su un computer fisico.
Linea 20: Linea 51:
{{{
sudo apt-get install ubuntu-vm-builder
= Virt-install: Creazione di una VM tramite riga di comando =

'''virt-install''' è uno script Python che permette la creazione di macchine virtuali KVM in modo automatizzato da terminale. È utile per scripting o per utenti esperti.

[[AmministrazioneSistema/InstallareProgrammi|Installare]] il pacchetto [[apt://virtinst|virtinst]].

== Esempio di installazione di Ubuntu Server ==

Questo esempio mostra come installare Ubuntu Server da un file ISO, utilizzando driver Virtio per disco e rete.

 0. Preparare il disco immagine. È buona pratica creare il file immagine del disco prima di avviare `virt-install` per avere un maggiore controllo. Un'immagine `qcow2` di 20GB:{{{
qemu-img create -f qcow2 /var/lib/libvirt/images/ubuntu-server.qcow2 20G
}}}
 0. Eseguire virt-install:{{{
sudo virt-install \
    --name ubuntu-server-vm \
    --memory 2048 \
    --vcpus 2 \
    --disk path=/var/lib/libvirt/images/ubuntu-server.qcow2,bus=virtio,size=20 \
    --os-variant ubuntufocal \
    --network bridge=br0,model=virtio \
    --cdrom /path/to/ubuntu-22.04-live-server-amd64.iso \
    --graphics vnc,listen=0.0.0.0 \
    --noautoconsole \
    --virt-type kvm \
    --hvm
 }}} Spiegazione degli argomenti:{{{
--name ubuntu-server-vm: Nome della macchina virtuale.
--memory 2048: 2 GB di RAM.
--vcpus 2: 2 core virtuali per la CPU.
--disk ...: Configurazione del disco. path è il percorso dell'immagine, bus=virtio per prestazioni ottimali, size è la dimensione (se non specificato prima).
--os-variant ubuntufocal: Aiuta libvirt a ottimizzare le impostazioni. Per Ubuntu 22.04, si può usare ubuntujammy o ubuntufocal.
--network bridge=br0,model=virtio: Connette la VM al bridge br0 sull'host, usando l'interfaccia di rete virtio paravirtualizzata. Se br0 non esiste, si può usare network=default per la rete NAT.
--cdrom /path/to/ubuntu-22.04-live-server-amd64.iso: Percorso del file ISO per l'installazione.
--graphics vnc,listen=0.0.0.0: Abilita l'accesso VNC da qualsiasi indirizzo. Per maggiore sicurezza, si può limitare listen=127.0.0.1.
--noautoconsole: Non connette automaticamente il terminale alla console della VM.
--virt-type kvm --hvm: Specifica l'uso di KVM per la virtualizzazione hardware completa.
 }}}
 0. Connettersi alla VM per l'installazione. Dopo aver avviato `virt-install`, la VM sarà in esecuzione. Per accedere alla console grafica (VNC):{{{
 virt-viewer --connect qemu:///system ubuntu-server-vm
 }}} Si aprirà una finestra con la console della VM, dove è possibile procedere con l'installazione.

== Esempio di installazione di Windows ==

L'installazione di Windows richiede l'uso di driver virtio per ottenere buone prestazioni. Questi driver non sono inclusi nell'ISO di Windows e devono essere forniti separatamente.

 0. Scaricare i driver Virtio per Windows. Scaricare l'immagine ISO `virtio-win.iso` (ad esempio da Fedora Koji) e posizionarla in una directory accessibile all'host KVM (es. `/var/lib/libvirt/images/`).
 0. Preparare il disco immagine:{{{
 qemu-img create -f qcow2 /var/lib/libvirt/images/windows10.qcow2 60G
 }}}
 0. Eseguire virt-install per Windows:{{{
 sudo virt-install \
    --name windows10-vm \
    --memory 4096 \
    --vcpus 4 \
    --disk path=/var/lib/libvirt/images/windows10.qcow2,bus=virtio,size=60 \
    --disk path=/var/lib/libvirt/images/virtio-win.iso,device=cdrom \
    --os-variant win10 \
    --network bridge=br0,model=virtio \
    --cdrom /path/to/Win10_22H2_Italian_x64.iso \
    --graphics vnc,listen=0.0.0.0 \
    --noautoconsole \
    --virt-type kvm \
    --hvm
 }}}
 {{{#!wiki note
 Il primo --disk è per il disco di sistema (bus=virtio).<<BR>>Il secondo --disk carica l'ISO dei driver Virtio come un CD-ROM virtuale. Durante l'installazione di Windows (quando viene richiesto "Carica driver"), puntare a questo CD-ROM per installare i driver del disco e della rete.
 }}}
 0. Connettersi alla VM e installare i driver. Usare `virt-viewer` per accedere alla VM e seguire la procedura di installazione di Windows. Quando richiesto per i driver, caricarli dall'ISO `virtio-win.iso` montata.

= Clonazione di una macchina virtuale =

È possibile clonare una macchina virtuale esistente usando lo strumento '''virt-clone'''. Questo strumento duplicherà l'immagine del disco e creerà una nuova definizione di dominio `libvirt` con un nuovo MAC address e UUID per evitare conflitti.

Per clonare una macchina virtuale chiamata `source-vm` in una nuova macchina `new-vm`:
 0. Assicurarsi che la VM sorgente non sia in esecuzione:{{{
virsh shutdown source-vm
}}} (Attendere che lo stato diventi `shut off`).
 0. Eseguire virt-clone:{{{
sudo virt-clone \
    --original source-vm \
    --name new-vm \
    --file /var/lib/libvirt/images/new-vm.qcow2
 }}}

Descrizione:
  * --original source-vm: Specifica il nome della VM da clonare.
  * --name new-vm: Specifica il nome della nuova VM.
  * --file /path/to/new-vm-disk.qcow2: Specifica il percorso e il nome del file della nuova immagine disco per la VM clonata. Questo creerà una copia completa del disco.

Dopo la clonazione, la `new-vm` sarà disponibile e potrà essere avviata tramite `virt-manager` o `virsh start new-vm`.

= Creazione di una macchina virtuale da un'immagine preesistente / Overlay (snapshot) =

L'uso di '''qcow2''' con overlay (snapshot basati su copy-on-write) permette di creare VM leggere e usa meno spazio su disco rispetto alla clonazione completa. È ideale per sperimentare senza alterare un'immagine di base.

 0. Creare un'immagine di base (se non già presente). Assicurarsi di avere un'immagine 'qcow2' di base. Per esempio, un'installazione pulita di Ubuntu:{{{
 qemu-img create -f qcow2 base_ubuntu.qcow2 20G
 }}}
 {{{#!wiki note
 Oppure convertire un'immagine esistente in qcow2: `qemu-img convert existing.raw -O qcow2 base_ubuntu.qcow2`
 }}}
 0. Creare un'immagine overlay (snapshot differenziale). Questa immagine registrerà solo le modifiche rispetto all'immagine di base, conservando l'originale intatta.
 {{{
 qemu-img create -f qcow2 -b /path/to/base_ubuntu.qcow2 /path/to/overlay_vm.qcow2
 }}} `overlay_vm.qcow2` sarà il disco della nuova VM.
 0. Creare una nuova macchina virtuale usando l'immagine overlay. Utilizzare '''virt-install''' o '''virt-manager''' per creare una nuova VM, puntando il disco virtuale al file overlay_vm.qcow2 appena creato. Con '''virt-install''':{{{
sudo virt-install \
    --name overlay-test-vm \
    --memory 1024 \
    --vcpus 1 \
    --disk path=/path/to/overlay_vm.qcow2,bus=virtio \
    --os-variant ubuntufocal \
    --network network=default,model=virtio \
    --graphics vnc,listen=0.0.0.0 \
    --noautoconsole \
    --virt-type kvm \
    --hvm
Linea 24: Linea 171:
'''Note for 8.10 (intrepid)''': the package is now named '''python-vm-builder''', the command is now named '''vmbuilder''' and you can find a [[https://help.ubuntu.com/community/JeOSVMBuilder|detailed tutorial on the wiki]]. In questo modo, la `overlay-test-vm` si avvierà usando `overlay_vm.qcow2` e tutte le modifiche verranno scritte solo in questo file, lasciando `base_ubuntu.qcow2` inalterato. Se la VM `overlay-test-vm` viene distrutta, basta cancellare `overlay_vm.qcow2` e crearne uno nuovo dalla base.
Linea 26: Linea 173:
=== Basic use === {{{#!wiki note
Il manuale `virt-image(5)` e lo strumento '''virt-image''' stesso sono parte di '''libguestfs-tools''' e sono utilizzati principalmente per la creazione automatizzata di VM da file XML descrittori, spesso in contesti di cloud o automazione. La procedura descritta originariamente era più complessa del necessario per la creazione di overlay con qemu-img e virt-install/virt-manager.
Linea 28: Linea 176:
Here is a very basic example of how to use it: = Ulteriori risorse =
Linea 30: Linea 178:
{{{
sudo ubuntu-vm-builder kvm hardy
}}}

This will create an Ubuntu Hardy, with all options set to default.

Or you can use this URL to a Javascript tool that generates the lengthy set of parameters available for ubuntu-vm-builder:
 * http://people.ubuntu.com/~kirkland/ubuntu-vm-builder.html

Note: if you want to use Virsh to manage your virtual machines as detailed below, you must add this parameter:

{{{
--libvirt qemu:///system
}}}

The javascript does not have an option for this itself, unfortunately.

'''Note''': when using --libvirt, the xml file is injected into libvirt and not stored locally. Use {{{virsh -c qemu:///system}}} or {{{virt-manager -c qemu:///system}}} to start your machine or modify its configuration.

=== More complex example ===

Now here is a somewhat more complex example:

{{{
ubuntu-vm-builder kvm hardy \
                  --domain newvm \
                  --dest newvm \
                  --arch i386 \
                  --hostname hostnameformyvm \
                  --mem 256 \
                  --user john \
                  --pass doe \
                  --ip 192.168.0.12 \
                  --mask 255.255.255.0 \
                  --net 192.168.0.0 \
                  --bcast 192.168.0.255 \
                  --gw 192.168.0.1 \
                  --dns 192.168.0.1 \
                  --mirror http://archive.localubuntumirror.net/ubuntu \
                  --components main,universe \
                  --addpkg vim openssh-server \
                  --libvirt qemu:///system ;
}}}

This will create a new Ubuntu Hardy VM called "newvm", the hostname will be set to "hostnameformyvm", the network will be configured with a static IP address and a gateway at address 192.168.0.1. The --mirror will tell the script to download the packages from a local Ubuntu mirror instead of the default server (this may speed up by a lot the time necessary to create the VM). The components argument will enable main and universe by default on the VM, --addpkg vim will install vim, and finally the last argument will automatically add the newly created VM to KVM.

By adding 'openssh-server' with --addpkg, we will be able to ssh into our new machine once its started (provided the networking works correctly).

Note: The manual isn't specific about the --exec option, used to execute a script file during the vm build process. If you specify the --exec option then you must provide the full path to the script you are executing. Not doing so will cause the installer to tell you that it can't find the script file.

'''Bug notice: ''' it seems that the package 'linux-package' is not found during the machine building process unless 'restricted' is also specified as a component option to ubuntu-vm-builder. If not specified, you'll get a non-functioning system that boots into grub only. This line makes it work for me:

{{{
--components 'main,universe,restricted'
}}}

I'm assuming this is a bug in ubuntu-vm-builder.

=== Install on a raw block device ===

Ubuntu-vm-builder doesn't allow you to create the VM on a raw block device yet (like a standalone partition, or a iSCSI share). You can use ubuntu-vm-builder to create the qcow2 image and then move the VM to the block device with qemu-img though; if /dev/sdb is the disk device on which you want to move the virtual machine:

{{{
sudo qemu-img convert root.qcow2 -O raw /dev/sdb
}}}

Edit the XML definition file for the VM in /etc/libvirt/qemu/, and set the source file to be:
{{{
<source file='/dev/sdb'/>
}}}

Redefine the VM and start it; it is now running from /dev/sdb.

Ubuntu-vm-builder is a very powerful tool - to get a more detailed list of its capabilities, use ubuntu-vm-builder --help.


== Create VMs running other operating systems: virt-install ==

Virt-install is radically different in the way it works. Instead of creating automagically a new VM, it will allow you to boot on an iso, and therefore to install almost any operating system. For a list of supported operating system, consult [[http://www.linux-kvm.org/page/Guest_Support_Status|kvm's official webpage]].

As you need virt-install to setup Windows guests, we will here describe how to install windows XP. There are a couple of small issues during the install, so I will also describe the workarounds.

=== Example Windows install ===
{{http://waste.mandragor.org/windows-kvm.png}}

NB: The following install is for Windows XP under KVM-62 (default in Hardy as time of writing). I have been unable to run windows 2000 server in accelerated mode on it. To run windows 2000 server, I use the KVM-72 backport for Hardy provided by Soren in his PPA: https://launchpad.net/~soren/+archive.

Copy the ISO of the system you want to install to your working directory:
{{{
yhamon@paris:~$ ls *.iso
ubuntu-8.04-server-i386.iso windowsxpsp2.iso
}}}
or create an ISO from a cd/dvd:
{{{
dd if=/dev/dvd of=dvd.iso
}}}

Install virt-install:
{{{
sudo apt-get install python-virtinst
}}}

Then, you need to run virt-install. On Ubuntu Hardy, with KVM-62, the install of windows XP doesn't work when accelerated (ie, using --accelerate), so run the install without that argument, and replace qemu by kvm in the XML defintiion file (in /etc/libvirt/qemu) after the first reboot.

{{{
sudo virt-install --connect qemu:///system -n xpsp2 -r 512 -f windows.qcow2 -s 12 -c windowsxpsp2.iso --vnc --noautoconsole --os-type windows --os-variant winxp
}}}

'''Note for 8.10 (intrepid)''': to make above command work add --hvm option to enable fully virtualized guest.

This will boot a new VM from the ISO. Connect to the new VM using virt-viewer:

{{{
virt-viewer -c qemu:///system xpsp2
}}}

Or if KVM is running on a different server:

{{{
virt-viewer -c qemu+ssh://ip/system xpsp2
}}}

You can now start the install. Another problem is that after the first reboot, in the process of the installation, the windows installer will complain that it can not see the disk anymore. In the XML definition of the VM again, add this to the list of devices:

{{{
<domain type='kvm'>
  [...]
  <devices>
    [...]
    <disk type='file' device='cdrom'>
      <source file='//home/yhamon/windowsxpsp2.iso'/>
      <target dev='hdc' bus='ide'/>
      <readonly/>
    </disk>
  </devices>
</domain>
}}}

Redefine the VM in virsh (sudo virsh define /etc/libvirt/qemu/xpsp2.xml) and restart the VM - it should work fine.

Another problem with virt-install in combination with Windows is that the created disk image is corrupted. At first the installation seems to work, but then after a reboot it stops with the message 'A read error occured'. This can be easily fixed by creating a new disk image (prior to installation):
{{{
qemu-img create -f qcow2 disk0.qcow2 12G
}}}
Overwrite the qcow2 file created by virt-install by this new file, reboot your VM and you are ready to go.

=== Example Ubuntu install ===
You can perform the following to install Ubuntu Hardy:{{{
sudo virt-install --connect qemu:///system -n hardy -r 512 -f hardy.qcow2 -s 12 -c hardy-server-amd64.iso --vnc --noautoconsole --os-type linux --os-variant ubuntuHardy --accelerate --network=network:default
}}}

The '--network' option sets up the machine to use the default libvirt network. You can see available libvirt networks with:{{{
virsh net-list --all
}}}

=== Other Operating Systems ===
Other Operating Systems can be installed using the same method as above. See 'man virt-install' for more information on different options for your virtual machine and supported OS types and OS variants.

'''Warning:''' this method fails with Fedora LiveCD installations and possibly others; see the bug here: https://bugs.launchpad.net/ubuntu/+source/kvm/+bug/220463

== Cloning a virtual machine ==
You can clone an existing virtual machine using the virt-clone tool. This duplicates the disk image and sets up the virtual machine domain configuration.

If you wish to clone a virtual machine named ''srchost'' to a new machine ''newhost'', ensure that the virtual machine ''srchost'' is not running and execute the following command.
{{{
$ virt-clone --connect=qemu:///system -o srchost -n newhost -f /path/to/newhost.qcow2
}}}

== Create a virtual machine from pre-existing image ==
Assuming:

 * Virt-manager is being used to manage virtual machines.
 * You wish to add a pre-existing image to virt-manager.

Use case:

Using qcow2 with overlays, you can experiment heavily with your virtual machines without having to perform complete reinstalls if you manage to corrupt them. A side effect of this method in comparison to cloning, is that less disk space is used.

Procedure:

1. Create the hard drive image with qcow2 format:
{{{
$ qemu-img create -f qcow2 <image name>.qcow2
}}}
2. Install the virtual machine using virt-manager:

Instead of allowing virt-manager to create a new drive image, simply
direct it to use the image you created in the previous step.

3. Create the overlay:
{{{
$ qemu-img create -f qcow2 -b <image name>.qcow2 <image name>.ovl
}}}
4. Create virtual image XML descriptor.

Read first:
{{{
$ man virt-image
$ man 5 virt-image
}}}
Copy the XML file created in step 2 above:
{{{
$ cp ~/.libvirt/qemu/<vm name>.xml overlay.xml
}}}
Then using your favorite editor, open and edit the copied XML file:
{{{
$ <editor> overlay.xml
}}}
Create the virtual image XML descriptor based on the virt-image(5)
manpage. I simply commented out the original text, and used it as
a guide when creating the new descriptor.

5. Create the new virtual machine from the image descriptor:
{{{
$ virt-image --vnc overlay.xml
}}}
6. Run and test the new virtual machine based on the overlay.

Open the new virtual machine in virt-manager and test to your hearts
content. If you 'break' the virtual machine, simply destroy and
delete it. Then recreate the overlay image and recreate the overlay
virtual machine as described above. You can commit the overlay changes
to the base image if desired, see the qemu-img manpage for details.

== See also ==

The [[../FAQ#systemadjustments|system specific adjustment recommended in the FAQ]].

[[http://packages.ubuntu.com/search?keywords=apt-cacher-ng|apt-cacher-ng]] for mirroring. You can reduce setup time to 3-4 minutes using ubuntu-vm-builder on a reasonable machine.
 * [[http://packages.ubuntu.com/search?keywords=apt-cacher-ng|apt-cacher-ng per il mirroring]]
 * [[https://help.ubuntu.com/community/KVM/CreateGuests|Documento originale (Community Ubuntu)]]
 * [[https://qemu.org/|Sito ufficiale di QEMU]]
 * [[https://virt-manager.org/|Sito ufficiale di virt-manager]]
 * [[https://help.ubuntu.com/community/KVM/CreateGuests|Documento originale]]
Linea 262: Linea 185:
----
CategoryHomepage
CategoryVirtualizzazione


Guida verificata con Ubuntu: 22.04 24.04 25.10

Problemi in questa pagina? Segnalali in questa discussione

Introduzione

Questa pagina spiega come creare e gestire macchine virtuali (ospiti) dopo aver installato KVM su Ubuntu 22.04 e versioni successive.

La creazione di macchine virtuali può essere effettuata utilizzando principalmente:

  • virt-manager: un'interfaccia grafica (GUI) completa e intuitiva.

  • virt-install: uno strumento a riga di comando per la creazione automatizzata di VM.

  • virsh: l'interfaccia a riga di comando per libvirt, utilizzata per la gestione delle VM esistenti.

Virt-manager: Creazione di una VM tramite interfaccia grafica

virt-manager è lo strumento più semplice e raccomandato per la maggior parte degli utenti per creare e gestire le macchine virtuali KVM.

Installare il pacchetto virt-manager.

  1. Avviare "Virtual Machine Manager".

    • Potrebbe essere richiesta la password di amministratore se l'utente non fa parte del gruppo libvirt (vedere la guida di installazione).

  2. Creare una nuova macchina virtuale. Cliccare sull'icona "Crea una nuova macchina virtuale" (un monitor con una stella verde).
    • Metodo di installazione:
      • "Local install media (ISO image or CDROM)": Utilizzato per installare un sistema operativo da un file ISO o da un CD/DVD fisico. Questo è il metodo più comune.
      • "Network Install (HTTP, FTP, NFS)": Utilizzato per installare un sistema operativo tramite un server di installazione di rete.
      • "Import existing disk image": Utilizzato per configurare una VM che utilizzi un disco virtuale preesistente.
      • "Network Boot (PXE)": Utilizzato per l'avvio della VM tramite PXE da una rete.
    • Selezionare "Local install media" e cliccare "Avanti".
  3. Specificare il percorso del media di installazione:
    • Cliccare "Sfoglia..." per selezionare il file ISO del sistema operativo che si desidera installare.
    • Spuntare "Automatically detect from the install media / source". virt-manager tenterà di rilevare il tipo di sistema operativo e la variante per ottimizzare le impostazioni.
  4. Configurare RAM e CPU:
    • Assegnare la quantità di RAM desiderata alla VM. Si consiglia di lasciare almeno 1GB (1024 MB) per l'host.
    • Assegnare il numero di core CPU.
  5. Creare o specificare il disco virtuale:
    • "Crea una nuova immagine del disco gestita": Questo è il metodo predefinito e raccomandato. Specificare la dimensione desiderata per il disco. virt-manager creerà un'immagine qcow2 nella directory predefinita di libvirt (/var/lib/libvirt/images/).
    • "Seleziona o crea un volume di archiviazione personalizzato": Permette di usare un'immagine disco esistente o di crearne una in un percorso specifico o su un dispositivo a blocchi.
  6. Configurare la rete:
    • Selezionare la configurazione di rete desiderata:
      • "Virtual network 'default' (NAT)": La VM sarà isolata nella rete virtuale predefinita di libvirt, con accesso a Internet tramite NAT sull'host.
      • "Bridge device": Selezionare il bridge configurato sull'host (es. br0). La VM sarà direttamente visibile sulla rete fisica.
  7. Finalizzare la creazione:
    • Assegnare un nome alla macchina virtuale.
    • Spuntare "Personalizza la configurazione prima di installare" per accedere a opzioni avanzate (es. aggiungere più CPU, modificare il tipo di scheda di rete in virtio, aggiungere dispositivi USB, ecc.).
    • Cliccare "Fine". La VM si avvierà e sarà possibile procedere con l'installazione del sistema operativo come su un computer fisico.

Virt-install: Creazione di una VM tramite riga di comando

virt-install è uno script Python che permette la creazione di macchine virtuali KVM in modo automatizzato da terminale. È utile per scripting o per utenti esperti.

Installare il pacchetto virtinst.

Esempio di installazione di Ubuntu Server

Questo esempio mostra come installare Ubuntu Server da un file ISO, utilizzando driver Virtio per disco e rete.

  1. Preparare il disco immagine. È buona pratica creare il file immagine del disco prima di avviare virt-install per avere un maggiore controllo. Un'immagine qcow2 di 20GB:

    qemu-img create -f qcow2 /var/lib/libvirt/images/ubuntu-server.qcow2 20G
  2. Eseguire virt-install:

    sudo virt-install \
        --name ubuntu-server-vm \
        --memory 2048 \
        --vcpus 2 \
        --disk path=/var/lib/libvirt/images/ubuntu-server.qcow2,bus=virtio,size=20 \
        --os-variant ubuntufocal \
        --network bridge=br0,model=virtio \
        --cdrom /path/to/ubuntu-22.04-live-server-amd64.iso \
        --graphics vnc,listen=0.0.0.0 \
        --noautoconsole \
        --virt-type kvm \
        --hvm

    Spiegazione degli argomenti:

    --name ubuntu-server-vm: Nome della macchina virtuale.
    --memory 2048: 2 GB di RAM.
    --vcpus 2: 2 core virtuali per la CPU.
    --disk ...: Configurazione del disco. path è il percorso dell'immagine, bus=virtio per prestazioni ottimali, size è la dimensione (se non specificato prima).
    --os-variant ubuntufocal: Aiuta libvirt a ottimizzare le impostazioni. Per Ubuntu 22.04, si può usare ubuntujammy o ubuntufocal.
    --network bridge=br0,model=virtio: Connette la VM al bridge br0 sull'host, usando l'interfaccia di rete virtio paravirtualizzata. Se br0 non esiste, si può usare network=default per la rete NAT.
    --cdrom /path/to/ubuntu-22.04-live-server-amd64.iso: Percorso del file ISO per l'installazione.
    --graphics vnc,listen=0.0.0.0: Abilita l'accesso VNC da qualsiasi indirizzo. Per maggiore sicurezza, si può limitare listen=127.0.0.1.
    --noautoconsole: Non connette automaticamente il terminale alla console della VM.
    --virt-type kvm --hvm: Specifica l'uso di KVM per la virtualizzazione hardware completa.
  3. Connettersi alla VM per l'installazione. Dopo aver avviato virt-install, la VM sarà in esecuzione. Per accedere alla console grafica (VNC):

     virt-viewer --connect qemu:///system ubuntu-server-vm
    Si aprirà una finestra con la console della VM, dove è possibile procedere con l'installazione.

Esempio di installazione di Windows

L'installazione di Windows richiede l'uso di driver virtio per ottenere buone prestazioni. Questi driver non sono inclusi nell'ISO di Windows e devono essere forniti separatamente.

  1. Scaricare i driver Virtio per Windows. Scaricare l'immagine ISO virtio-win.iso (ad esempio da Fedora Koji) e posizionarla in una directory accessibile all'host KVM (es. /var/lib/libvirt/images/).

  2. Preparare il disco immagine:

     qemu-img create -f qcow2 /var/lib/libvirt/images/windows10.qcow2 60G
  3. Eseguire virt-install per Windows:

     sudo virt-install \
        --name windows10-vm \
        --memory 4096 \
        --vcpus 4 \
        --disk path=/var/lib/libvirt/images/windows10.qcow2,bus=virtio,size=60 \
        --disk path=/var/lib/libvirt/images/virtio-win.iso,device=cdrom \
        --os-variant win10 \
        --network bridge=br0,model=virtio \
        --cdrom /path/to/Win10_22H2_Italian_x64.iso \
        --graphics vnc,listen=0.0.0.0 \
        --noautoconsole \
        --virt-type kvm \
        --hvm
    • Il primo --disk è per il disco di sistema (bus=virtio).
      Il secondo --disk carica l'ISO dei driver Virtio come un CD-ROM virtuale. Durante l'installazione di Windows (quando viene richiesto "Carica driver"), puntare a questo CD-ROM per installare i driver del disco e della rete.

  4. Connettersi alla VM e installare i driver. Usare virt-viewer per accedere alla VM e seguire la procedura di installazione di Windows. Quando richiesto per i driver, caricarli dall'ISO virtio-win.iso montata.

Clonazione di una macchina virtuale

È possibile clonare una macchina virtuale esistente usando lo strumento virt-clone. Questo strumento duplicherà l'immagine del disco e creerà una nuova definizione di dominio libvirt con un nuovo MAC address e UUID per evitare conflitti.

Per clonare una macchina virtuale chiamata source-vm in una nuova macchina new-vm:

  1. Assicurarsi che la VM sorgente non sia in esecuzione:

    virsh shutdown source-vm

    (Attendere che lo stato diventi shut off).

  2. Eseguire virt-clone:

    sudo virt-clone \
        --original source-vm \
        --name new-vm \
        --file /var/lib/libvirt/images/new-vm.qcow2

Descrizione:

  • --original source-vm: Specifica il nome della VM da clonare.
  • --name new-vm: Specifica il nome della nuova VM.
  • --file /path/to/new-vm-disk.qcow2: Specifica il percorso e il nome del file della nuova immagine disco per la VM clonata. Questo creerà una copia completa del disco.

Dopo la clonazione, la new-vm sarà disponibile e potrà essere avviata tramite virt-manager o virsh start new-vm.

Creazione di una macchina virtuale da un'immagine preesistente / Overlay (snapshot)

L'uso di qcow2 con overlay (snapshot basati su copy-on-write) permette di creare VM leggere e usa meno spazio su disco rispetto alla clonazione completa. È ideale per sperimentare senza alterare un'immagine di base.

  1. Creare un'immagine di base (se non già presente). Assicurarsi di avere un'immagine 'qcow2' di base. Per esempio, un'installazione pulita di Ubuntu:

     qemu-img create -f qcow2 base_ubuntu.qcow2 20G
    • Oppure convertire un'immagine esistente in qcow2: qemu-img convert existing.raw -O qcow2 base_ubuntu.qcow2

  2. Creare un'immagine overlay (snapshot differenziale). Questa immagine registrerà solo le modifiche rispetto all'immagine di base, conservando l'originale intatta.
     qemu-img create -f qcow2 -b /path/to/base_ubuntu.qcow2 /path/to/overlay_vm.qcow2

    overlay_vm.qcow2 sarà il disco della nuova VM.

  3. Creare una nuova macchina virtuale usando l'immagine overlay. Utilizzare virt-install o virt-manager per creare una nuova VM, puntando il disco virtuale al file overlay_vm.qcow2 appena creato. Con virt-install:

    sudo virt-install \
        --name overlay-test-vm \
        --memory 1024 \
        --vcpus 1 \
        --disk path=/path/to/overlay_vm.qcow2,bus=virtio \
        --os-variant ubuntufocal \
        --network network=default,model=virtio \
        --graphics vnc,listen=0.0.0.0 \
        --noautoconsole \
        --virt-type kvm \
        --hvm

In questo modo, la overlay-test-vm si avvierà usando overlay_vm.qcow2 e tutte le modifiche verranno scritte solo in questo file, lasciando base_ubuntu.qcow2 inalterato. Se la VM overlay-test-vm viene distrutta, basta cancellare overlay_vm.qcow2 e crearne uno nuovo dalla base.