KVM (Italiano) - ArchWiki

# KVM (Italiano)

From ArchWiki
Jump to navigation Jump to search
The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.

The translation of this article or section does not reflect the original text.

Reason: Last updated in 2012 (236047), out of sync with English page (Discuss in Talk:KVM (Italiano)#)

KVM, Kernel Based Virtual Machine, è un hypervisor inserito direttamente all'interno del kernel 2.6 (e 3.x) a partire dalla versione 2.6.20. Il suo utilizzo ha scopi simili a quelli di Xen ma è più immediato. Per cominciare ad utilizzare l'hypervisor è sufficiente caricare i moduli appropriati. Come per la virtualizzazione completa di Xen, anche per utilizzare KVM è necessario disporre di un processore che supporti le estensioni VT di Intel, o AMD-V in caso di sistema AMD.

Utilizzando KVM, è possibile avviare macchine virtuali multiple che eseguano immagini non modificate di Linux, Windows, o di molti altri sistemi. (Consultare Guest Support Status). Ogni macchina virtuale ha il suo hardware virtualizzato privato: scheda di rete, adattatore grafico, etc. Consultare KVM Howto

Le differenze tra KVM, Xen, VMware e QEMU sono elencate su KVM FAQ.

KVM è utilizzato insieme a Libvirt per una migliore gestione attraverso il set di comandi "virsh".

## Installare i pacchetti

I kernel Arch forniscono i moduli del kernel appropriati. Si può verificare se il proprio kernel supporti kvm tramite il seguente comando (ammesso che il proprio kernel sia compilato con la flag `CONFIG_IKCONFIG_PROC)`:

    $ zgrep KVM /proc/config.gz

KVM necessita di un processore sulla macchina host che supporti la virtualizzazione (tecnologia nota come VT-x per i processori Intel e AMD-V per quelli prodotti da AMD). È possibile verificare questo requisito col seguente comando:

     $ lscpu

Se il processore supporta la virtualizzazione, verrà mostrata anche una riga che lo afferma esplicitamente. Altrimenti la compatibilità può essere controllata anche con

     grep -E "(vmx|svm)" --color=always /proc/cpuinfo

Se non viene restituito alcun output, il proprio processore non supporta la virtualizzazione, e non è quindi possibile utilizzare QEMU-KVM.

KVM necessita inoltre di una versione modificata di QEMU per poter lanciare e gestire le macchine virtuali. È possibile sceglierne una tra le seguenti in base alle proprie esigenze:

1. Il pacchetto qemu-kvm[broken link: replaced by qemu] è disponibile nei Repository Ufficiali (scelta raccomandata)

1. Se è necessario anche l'uso di QEMU, si può scegliere di installare una versione di qemu superiore alla 0.9.0, che va in conflitto con il pacchetto qemu-kvm[broken link: replaced by qemu]. Comunque oramai anche il pacchetto qemu fornisce un eseguibile (`qemu -enable-kvm`) che si avvantaggia di tale tecnologia.

## Configurare i moduli del kernel

Innanzitutto è necessario aggiungere il proprio utente al gruppo `kvm` in modo da consentirgli di utilizzare la periferica `/dev/kvm`

    # gpasswd -a <Proprio_Nome_Utente> kvm

Successivamente bisogna scegliere quale modulo caricare in base al processore che si possiede.

1. Successivamente, caricare i moduli `kvm` e `kvm-intel` se si possiede un processore Intel (estensione VT-x)

    # modprobe kvm

    # modprobe kvm-intel

oppure i moduli `kvm` e `kvm-amd` nel caso si possieda un processore AMD con estensione AMD-V (nome in codice Pacifica)

    # modprobe kvm

    # modprobe kvm-amd

Se il caricamento del modulo `kvm` dovesse andare a buon fine, ma si dovessero riscontrare problemi nel caricamento di `kvm-intel` o `kvm-amd` (nonostante /proc/cpuinfo confermi la presenza di estensioni di virtualizzazione), verificare le impostazioni del proprio BIOS, in quanto alcuni produttori (sopratutto di sistemi portatili) disabilitano la VT di default. Per verificare se il problema sia dovuto alla disabilitazione delle estensioni, consultare l'output di `dmesg` subito dopo il fallimento del caricamento dei moduli.

Se si vuole che questi moduli vengano caricati all'avvio, sfruttare `/etc/rc.conf`

## Come utilizzare KVM

1. Creare un'immagine del sistema guest

    $ qemu-img create -f qcow2 <Image_Name> <size>

1. Installare il sistema guest. Per l'installazione può essere utilizzata un'immagine cd/dvd (file ISO)

    $ qemu-kvm -hda <Nome_Immagine> -m 512 -cdrom </Percorso/all/immagine/ISO> -boot d -vga std

1. Eseguire il sistema

    $ qemu-kvm -hda <Nome_Immagine> -m 512 -vga std

Nota: Si potrebbe volere assegnare più di una cpu al sistema guest tramite lo switch `-smp X` (dove X è il numero di cpu). Il numero massimo di cpu assegnabili per un singolo sistema è 16.
Nota: La memoria di default di KVM è di 128MB, per modificarla utilizzare il parametro `-m` e specificare il quantitativo di memoria desiderata in megabytes (es. `-m 1024`). Tenere presente inoltre che i sistemi Microsoft più recenti (testato con Vista e Seven) richiedono il tipo di immagine `qcow2`, restituendo altrimenti un codice di errore 0x80070057 durante l'installazione.

Consultare QEMU per tutte le altre informazioni.

## Sistema guest paravirtualizzato (virtio)

KVM offre ai sistemi guest la possibilità di utilizzare la paravirtualizzazione di periferiche a blocchi e di rete, che consente migliori prestazioni e minor sovraccarico. Linux ha questa capacità con i suoi moduli virtio dalla versione 2.6.25. Per windows un driver di periferica di rete paravirtualizzata è disponibile a questo indirizzo[link interrotto 2020-08-02].

Una periferica a blocchi virtio richiede l'opzione `-drive` anzichè la semplice `-hd*`, più `if=virtio`:

    $ qemu-kvm -boot order=c -drive file=drive.img,if=virtio

Nota: `-boot order=c` è assolutamente necessario se si desidera eseguire il boot da questa periferica. Non c'è alcun tipo di autorilevamento, come invece avviene con `-hd*`

All'incirca lo stesso metodo si utilizza per le periferiche di rete

    $ qemu-kvm -net nic,model=virtio

### Preparare un sistema guest (Arch) linux

Per utilizzare periferiche virtio su di un sistema guest Arch Linux, i seguenti moduli devono essere caricati: `virtio, virtio_pci, virtio_blk, virtio_net e virtio_ring` ( per sistemi guest a 32 bit, il modulo `virtio` non è necessario). Se si vuole eseguire il boot da un disco-vitio, il ramdisk iniziale deve essere rigenerato. Aggiungere i moduli appropriati all'interno di `/etc/mkinitcpio.conf` in questo modo:

    /etc/mkinitcpio.conf

    MODULES="virtio virtio_blk virtio_pci virtio_net virtio_ring"

e rigenerare:

    # mkinitcpio -p linux

I dischi virtio sono rilevati col prefisso v (come ad esempio vda, vdb, etc...). Devono quindi essere effettuate le opportune modifiche all'interno di `/etc/fstab` e `/boot/grub/menu.lst` (se si esegue il boot da uno di questi dischi; ovviamente se si utilizza un sistema che fa riferimento ai dischi tramite uuids, non deve essere modificato nulla.)

Modificare o creare

    /boot/grub/device.map

    (hd0) /dev/vda

Grub ha alcuni problemi nel riconoscimento di dischi virtio. Perciò, se il bootloader non è installato, o se lo si vuole re-installare, è necessario modificare (o creare, nel caso non sia presente, eventualità molto frequente) anche il file `/boot/grub/device.map` in maniera coerente:

    /boot/grub/device.map

    (hd0) /dev/vda

Ulteriori informazioni sulla paravirtualizzazione in KVM: [1] sezione nel qemu-book tedesco: [2]

### Preparare un sistema guest Windows

Preparare un sistema guest Windows che funzioni tramite dispositivi virtio è alquanto macchinoso.

Nel proprio host KVM (che esegue Arch Linux) scaricare il driver virtio da Fedora repository. Ora bisogna creare una nuova immagine del disco, che imponga a Windows la ricerca del driver. Per fare ciò, interrompere l'esecuzione della macchina virtuale e dare il seguente comando:

    qemu-img create -f qcow2 fake.img 1G

Eseguire il guest Windows originale (ancora in modalità IDA). Aggiungere il disco fasullo ed un cdrom con il driver.

    qemu-kvm -drive file=windows.img,if=ide,boot=on -m 512 -drive file=fake.img,if=virtio -cdrom virtio-win-0.1-15.iso -vga std

Windows rileverà il disco fasullo e cercherà un driver per gestirlo.. Se dovesse fallire, andare in Gestione Periferiche, individuare il drive SCSI con un punto esclamativo a fianco, clickare su "Aggiorna Driver" e navigare fino alla directory appropriata sul cdrom.

Quando l'installazione è completata con successo, è possibile spegnere la macchina virtuale e ri-eseguirla, ora con il driver `virtio`

    qemu-kvm -drive file=windows.img,if=virtio,boot=on -m 512 -vga std

Nota: Se si riscontrano problemi di BSOD, assicurarsi di aver settato un quantitativo sufficiente di memoria tramite lo switch `-m`

## Ridimensionare l'immagine

Attenzione: ridimensionare un'immagine contenente un filesystem ntfs d'avvio, potrebbe rendere la VM installata su di esso inavviabile. Una soluzione (estremamente macchinosa ed adatta solo ad utenti esperti), è mostrata a questo indirizzo insieme ad una approfondita spiegazione del problema http://tjworld.net/wiki/Howto/ResizeQemuDiskImages[link interrotto 2020-08-02].

### Metodo attuale

Dalla versione 0.13.0 of qemu, è stata aggiunta una nuova opzione all'eseguibile `qemu-img`, l'opzione `resize`. Tramite questo switch è possibile ridimensionare un'immagine qcow2 direttamente, senza la necessità del passaggio intermedio per il formato raw. Ad es., il seguente comando incrementerà la dimensione dell'immagine my_image.qcow2 di 10 Gigabytes.

    qemu-img resize my_image.qcow2 +10G

### Vecchio metodo

È possibile incrementare la dimensione di un'immagine `qcow2` successivamente, almeno con `ext3`. Convertirla in immagine `raw`, espandere la sua dimensione con `dd`, riconvertirla in `qcow2`, rimpiazzare la partizione con una più grande, effettuare un `fsck` e ridimensionare il filesystem.

    $ qemu-img convert -O raw image.qcow2 image.img
    $ dd if=/dev/zero of=image.img bs=1G count=0 seek=[NUMBER_OF_GB]
    $ qemu-img convert -O qcow2 -o cluster_size=64K image.img imageplus.qcow2
    $ qemu-kvm -hda imageplus.qcow2 -m 512 -cdrom </Path/to/the/ISO/Image> -boot d -vga std
    $ fdisk /dev/sda [Tenere presente che il questo comando cancellerà la partizione, creandone una nuova che andrà ad occupare l'intero disco.]
    $ e2fsck -f /dev/sda1
    $ resize2fs /dev/sda1

## Abilitare KSM

KSM (Kernel Samepage Merging) è una funzione del kernel Linux introdotta con la versione 2.6.32. KSM consente alle applicazioni registrate di condividere alcune delle loro pagine di memoria. Per quanto riguarda KVM, il meccanismo KSM consente alle macchine virtuali create di operare questa condivisione. In uno scenario all'interno del quale siano presenti diversi sistemi operativi guest simili tra loro, questa scelta può comportare un significativo risparmio di memoria impiegata. Per abilitare KSM, assicurarsi per prima cosa di disporre di una versione di qemu-kvm[broken link: replaced by qemu] uguale o superiore alla 0.12.0.

    # pacman -Qi qemu-kvm | grep Version

    Version        : 0.12.1.2-1

e di una versione del kernel uguale o superiore alla 2.6.32.

    $ uname -r

    3.0-ARCH

Se i due requisiti sono soddisfatti, dovrebbe quindi essere presente la directory `/sys/kernel/mm/ksm/`, contenente vari file. È possibile abilitare/disabilitare KSM modificando ad 1 o 0 il file `/sys/kernel/mm/ksm/run`

    # echo 1 > /sys/kernel/mm/ksm/run

Se KSM è in esecuzione, e ci sono pagine da condividere (ad esempio, se sono in esecuzione due o più macchine virtuali simili) allora il file `/sys/kernel/mm/ksm/pages_shared` avrà un valore diverso da 0. Come spiegato nella documentazione del kernel `Documentation/vm/ksm.txt` lo stato effettivo di KSM e di MADV_MERGEABLE è mostrato all'interno di `/sys/kernel/mm/ksm/`:

    pages_shared     - how many shared unswappable kernel pages KSM is using
    pages_sharing    - how many more sites are sharing them i.e. how much saved
    pages_unshared   - how many pages unique but repeatedly checked for merging
    pages_volatile   - how many pages changing too fast to be placed in a tree
    full_scans       - how many times all mergeable areas have been scanned

    Un rapporto alto tra pages_sharing e pages_shared indica una buona condivisione, ma
    un rapporto alto tra pages_unshared e pages_sharing indica tentativi inutili
    pages_volatile è funzione di diversi tipi di attività, ma un valore alto potrebbe indicare un uso limitato di madvise MADV_MERGEABLE.

Una maniera semplice per varificare le effettive performance del KSM, consiste nello stampare il contenuto dei file in questa directory

    # for ii in /sys/kernel/mm/ksm/* ; do echo -n "$ii: " ; cat $ii ; done

    /sys/kernel/mm/ksm/full_scans: 151
     /sys/kernel/mm/ksm/max_kernel_pages: 246793
     /sys/kernel/mm/ksm/pages_shared: 92112
     /sys/kernel/mm/ksm/pages_sharing: 131355
     /sys/kernel/mm/ksm/pages_to_scan: 100
     /sys/kernel/mm/ksm/pages_unshared: 123942
     /sys/kernel/mm/ksm/pages_volatile: 1182
     /sys/kernel/mm/ksm/run: 1
     /sys/kernel/mm/ksm/sleep_millisecs: 20

## Agevolazioni per i nuovi utenti

Se è stato installato il pacchetto qemu, è possibile utilizzare delle interfacce grafiche, come qtemuAUR per un uso semplificato oppure qemu-launcherAUR per un utilizzo più approfondito, per gestire le proprie macchine virtuali. È necessario modificare il valore di `QEMU start command` nel pannello di configurazione da `qemu` a `qemu-kvm`/`qemu-system-x86_64` o aggiungere `-enable-kvm` alle opzioni di avvio addizionali. Con le nuove versioni di qemu, potrebbe non essere più necessario aggiungere l'opzione `-enable-kvm`, in quanto lìeseguibile `qemu` dovrebbe rilevare l'esecuzione di kvm e partire con i corretti parametri. Se si avvia la propria macchina virtuale tramite un'interfaccia grafica, e si riscontra una installazione mlto lenta, sarà il caso di verificare la corretta esecuzione di KVM, in quanto QEMU potrebbe aver fallito il rilevamento, ed essere partito con una emulazione puramente software.

## Integrazione del mouse

Per evitare che il mouse venga catturato quando si clicca all'interno della finestra del sistema guest aggiungere l'opzione `-usbdevice tablet`. Ciò significa che QEMU sarà in grado di rilevare la posizione del mouse senza doverlo catturare. Quando attivata, questa opzione sovrascrive inoltre l'emulazione della porta PS/2.

    $ qemu-kvm -hda <Image_Name> -m 512 -vga std -usbdevice tablet

## Montare immagini qemu

    # modprobe nbd max_part=63

    # qemu-nbd -c /dev/nbd0 [image.img]

    # mount /dev/nbd0p1 [/mnt/qemu]

## Eseguire le macchine virtuali all'avvio

Se si utilizzano virt-manager e `virsh` per la gestione delle proprie VM, l'operazione è molto semplice. Per impostare da riga di comando l'esecuzione di una macchina virtuale all'avvio

    virsh autostart <domain>

per disabilitare l'autostart

    virsh autostart --disable <domain>

Con virt-manager è altrettanto semplice, avendo la possibilità di spuntare la relativa checkbox nelle opzioni di avvio della VM.

Nota: VMs avviate da QEMU e KVM da linea di comando non sono gestibile da virt-manager

Consultare QEMU#Starting QEMU virtual machines on boot

## Trucchi e Consigli

### Configurazione di rete semplificata

Configurare un bridging di rete potrebbe risultare complesso, a volte. Se l'unico scopo della creazione della macchina virtuale è quello di sperimentare, una soluzione più semplice può essere quella di connettersi tramite tunneling SSH.

I passi fondamentali sono i seguenti:

- configurare un server SSH sul sistema host
- (opzionale) creare un utente designato ad effettuare il tunneling
- installare SSH sulla macchina virtuale
- configurare l'autenticazione

Consultare la pagina SSH[archived page] per configurare quest'ultimo, in particolare la sezione OpenSSH#Forwarding other ports Quando si usano le impostazioni di rete di default, l'host è raggiungibile all'indirizzo `10.0.2.2`

Se tutto funziona, e si è in grado di accede in SSH all'host, è sufficiente aggiungere quanto segue

    /etc/rc.local

    # Local SSH Server
    echo "Starting SSH tunnel"
    sudo -u vmuser ssh tunneluser@10.0.2.2 -N -R 2213:127.0.0.1:22 -f
    # Random remote port (e.g. from another VM)
    echo "Starting random tunnel"
    sudo -u vmuser ssh tunneluser@10.0.2.2 -N -L 2345:127.0.0.1:2345 -f

In questo esempio viene creato un tunnel sul server SSH della macchina virtuale ed una porta dell'host scelta arbitrariamente viene collegata nella macchina virtuale.

Questa è una maniera molto essenziale di configurare la rete con le macchina virtuali. È comunque piuttosto sicura, e dovrebbe essere adegauata in gran parte delle circostanze.

Categories:

- Virtualization (Italiano)
- Kernel (Italiano)

Hidden categories:

- Pages or sections flagged with Template:Bad translation
- Pages with broken package links
- Pages with links to archived pages