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 3 e 74 (in 71 versioni)
⇤ ← Versione 3 del 22/03/2010 21.41.24 →
Dimensione: 11871
Autore: FabioMarconi
Commento:
← Versione 74 del 24/10/2025 14.14.56 → ⇥
Dimensione: 11486
Autore: jeremie2
Commento: revisione
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")>>
Linea 3: Linea 7:
[[BR]]
[[Indice(depth=2 align=right)]]		 = Introduzione =
Linea 6: Linea 9:
= Creazione di macchine virtuali = Questa pagina spiega come creare e gestire macchine virtuali (ospiti) dopo aver installato '''[[Virtualizzazione/Kvm/Installazione|KVM]]'''. 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 8: Linea 14:
Una volta installato KVM, è possibile preocedere alla creazione della VM. Ciò può essere fatto usando:
 * [http://virt-manager.et.redhat.com virt-manager]: uno strumento GUI.
 * [http://www.howtoforge.com/installing-kvm-guests-with-virt-install-on-ubuntu-8.10-server virt-install], uno script python sviluppato da Red Hat
 * [https://help.ubuntu.com/8.04/serverguide/C/ubuntu-vm-builder.html ubuntu-vm-builder], sviluppato da Canonical.		 = Creare VM da interfaccia grafica =
Linea 13: Linea 16:
== Ubuntu-vm-builder: un modo veloce e potente per creare Ubuntu JEOS VMs == '''virt-manager''' è lo strumento più semplice e raccomandato per la maggior parte degli utenti per creare e gestire le macchine virtuali '''KVM'''.
Linea 15: Linea 18:
[http://doc.ubuntu.com/ubuntu/serverguide/C/ubuntu-vm-builder.html Ubuntu-vm-builder] è probabilmente il miglior strumento per la creazione di VMs che eseguono Ubuntu JEOS 8.04, dato che l'installazione avviene interamente tramite script (molto veloce).  0. [[AmministrazioneSistema/InstallareProgrammi|Installare]] il pacchetto [[apt://virt-manager|virt-manager]].
 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 [[Virtualizzazione/Kvm/Installazione#root|guida]]).
 }}}
 0. Creare una nuova macchina virtuale. Fare clic sull'icona '''Crea una nuova macchina virtuale''' (monitor con stella verde).
 0. Verranno visualizzati i seguenti metodi di installazione:
   * '''Local install media (ISO image or CDROM)''': installare un sistema operativo da un file ISO o da un CD/DVD fisico. (Metodo più comune).
   * '''Network Install (HTTP, FTP, NFS)''': installare un sistema operativo tramite un server di installazione di rete.
   * '''Import existing disk image''': configurare una VM che utilizzi un disco virtuale preesistente.
   * '''Network Boot (PXE)''': avvio della VM tramite PXE da una rete.
 0. Selezionare '''Local install media''' e fare clic su '''Avanti'''.
 0. Specificare il percorso del media di installazione facendo clic su '''Sfoglia...''' per selezionare il file ISO del sistema operativo che si desidera installare.
 0. Spuntare '''Automatically detect from the install media / source''' in modo che '''virt-manager''' tenti di rilevare il tipo di sistema operativo 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''': è 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 utilizzare 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 come aggiungere più CPU, modificare il tipo di scheda di rete in '''virtio''', aggiungere dispositivi USB, ecc..
  * Fare clic su '''Fine'''. La VM si avvierà e sarà possibile procedere con l'installazione del sistema operativo come su un computer fisico.
Linea 17: Linea 46:
= Creare VM da terminale =
Linea 18: Linea 48:
Questo strumento è pacchettizato, e si trova nel repository universe: '''virt-install''' è uno script Python che permette la creazione di macchine virtuali KVM in modo automatizzato da terminale.
Linea 20: Linea 50:
{{{
sudo apt-get install ubuntu-vm-builder		 [[AmministrazioneSistema/InstallareProgrammi|Installare]] il pacchetto [[apt://virtinst|virtinst]].

== Esempio installazione Ubuntu Server ==

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

 0. È buona pratica creare il file immagine del disco prima di avviare `virt-install` per avere un maggiore controllo. Preparare 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
 }}}dove:
  * `name ubuntu-server-vm`: è il nome della macchina virtuale.
  * `memory 2048`: 2GB di RAM.
  * `vcpus 2`: 2 core virtuali per la CPU.
  * `disk ...`: configurazione del disco in cui:
   * `path`: percorso dell'immagine.
   * `bus=virtio`: per prestazioni ottimali.
   * `size`: dimensione (se non specificato prima).
  * `os-variant ubuntufocal`: aiuta '''libvirt''' a ottimizzare le impostazioni. Per '''Ubuntu 22.04''' si può utilizzare '''ubuntujammy''' o '''ubuntufocal'''.
  * `network bridge=br0,model=virtio`: connette la VM al bridge '''br0''' sull'host usando l'interfaccia di rete '''virtio''' para-virtualizzata. Se '''br0''' non esiste si può utilizzare 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 installazione Windows ==

Per ottenere buone prestazioni l'installazione di Windows richiede l'utilizzo di driver '''Virtio'''. Questi driver non sono inclusi nella ISO di Windows e devono essere forniti separatamente.

 0. Scaricare l'immagine ISO `virtio-win.iso` (ad esempio dal sito Fedora Koji) e posizionarla in una directory accessibile all'host KVM (es. `/var/lib/libvirt/images/`).
 0. Preparare il disco immagine digitando:{{{
 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`), mentre il secondo 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
}}}E 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`: nome della VM da clonare.
  * `--name new-vm`: nome della nuova VM.
  * `--file /path/to/new-vm-disk.qcow2`: percorso e 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 MV da immagine preesistente - Overlay =

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

 0. In base alle esigenze:
  * '''creare''' un'immagine `qcow2` di base. Ad esempio per un'installazione pulita di Ubuntu:{{{
 qemu-img create -f qcow2 base_ubuntu.qcow2 20G
}}}
  * '''convertire''' un'immagine `qcow2` esistente:{{{
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 166:
'''Nota: a partire dalla 8.10 (intrepid)''': il pacchetto viene chiamato '''python-vm-builder''', il comando '''vmbuilder''' ed è possibile trovare un [https://help.ubuntu.com/community/JeOSVMBuilder dettagliato tutorial sul wiki].*******Tradurre 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 unoa nuova dalla base.
Linea 26: Linea 168:
=== Basic use ===

Here is a very basic example of how to use it:

{{{
sudo ubuntu-vm-builder kvm hardy		 {{{#!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.
Linea 34: Linea 172:
This will create an Ubuntu Hardy, with all options set to default. = Ulteriori risorse =
Linea 36: Linea 174:
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 sul wiki Ubuntu internazionale]]
 * [[https://qemu.org/|Sito ufficiale di QEMU]]
 * [[https://virt-manager.org/|Sito ufficiale di virt-manager]]
Linea 262: Linea 180:
----
CategoryHomepage CategoryInTraduzione		 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. 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.

Creare VM da interfaccia grafica

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

  1. Installare il pacchetto virt-manager.

  2. Avviare Virtual Machine Manager.

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

  3. Creare una nuova macchina virtuale. Fare clic sull'icona Crea una nuova macchina virtuale (monitor con stella verde).

  4. Verranno visualizzati i seguenti metodi di installazione:

    • Local install media (ISO image or CDROM): installare un sistema operativo da un file ISO o da un CD/DVD fisico. (Metodo più comune).

    • Network Install (HTTP, FTP, NFS): installare un sistema operativo tramite un server di installazione di rete.

    • Import existing disk image: configurare una VM che utilizzi un disco virtuale preesistente.

    • Network Boot (PXE): avvio della VM tramite PXE da una rete.

  5. Selezionare Local install media e fare clic su Avanti.

  6. Specificare il percorso del media di installazione facendo clic su Sfoglia... per selezionare il file ISO del sistema operativo che si desidera installare.

  7. Spuntare Automatically detect from the install media / source in modo che virt-manager tenti di rilevare il tipo di sistema operativo per ottimizzare le impostazioni.

  8. 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.
  9. Creare o specificare il disco virtuale:

    • Crea una nuova immagine del disco gestita: è 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 utilizzare un'immagine disco esistente o di crearne una in un percorso specifico o su un dispositivo a blocchi.

  10. 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.

  11. Finalizzare la creazione:
    • Assegnare un nome alla macchina virtuale.

    • Spuntare Personalizza la configurazione prima di installare per accedere a opzioni avanzate come aggiungere più CPU, modificare il tipo di scheda di rete in virtio, aggiungere dispositivi USB, ecc..

    • Fare clic su Fine. La VM si avvierà e sarà possibile procedere con l'installazione del sistema operativo come su un computer fisico.

Creare VM da terminale

virt-install è uno script Python che permette la creazione di macchine virtuali KVM in modo automatizzato da terminale.

Installare il pacchetto virtinst.

Esempio installazione Ubuntu Server

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

  1. È buona pratica creare il file immagine del disco prima di avviare virt-install per avere un maggiore controllo. Preparare 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
    dove:

    • name ubuntu-server-vm: è il nome della macchina virtuale.

    • memory 2048: 2GB di RAM.

    • vcpus 2: 2 core virtuali per la CPU.

    • disk ...: configurazione del disco in cui:

      • path: percorso dell'immagine.

      • bus=virtio: per prestazioni ottimali.

      • size: dimensione (se non specificato prima).

    • os-variant ubuntufocal: aiuta libvirt a ottimizzare le impostazioni. Per Ubuntu 22.04 si può utilizzare ubuntujammy o ubuntufocal.

    • network bridge=br0,model=virtio: connette la VM al bridge br0 sull'host usando l'interfaccia di rete virtio para-virtualizzata. Se br0 non esiste si può utilizzare 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 installazione Windows

Per ottenere buone prestazioni l'installazione di Windows richiede l'utilizzo di driver Virtio. Questi driver non sono inclusi nella ISO di Windows e devono essere forniti separatamente.

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

  2. Preparare il disco immagine digitando:

     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), mentre il secondo 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

    E 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: nome della VM da clonare.

    • --name new-vm: nome della nuova VM.

    • --file /path/to/new-vm-disk.qcow2: percorso e 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 MV da immagine preesistente - Overlay

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

  1. In base alle esigenze:

    • creare un'immagine qcow2 di base. Ad esempio per un'installazione pulita di Ubuntu:

       qemu-img create -f qcow2 base_ubuntu.qcow2 20G

    • convertire un'immagine qcow2 esistente:

      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 unoa nuova dalla base.

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.

Ulteriori risorse

CategoryVirtualizzazione