Opzioni per la Macchina Virtuale

I seguenti esempi utilizzano aptosid, sostituirla con la distribuzione di vostra scelta.

Installare altre distribuzioni in una immagine VM

Nota: se e quando si vuole installare in una immagine di una macchina virtuale, la maggior parte delle distribuzioni linux probabilmente richiederanno uno spazio di 12Gb. Tuttavia, se è necessario avere MS Windows in una macchina virtuale, sarà necessario prevedere circa 30Gb o più per l'immagine. In definitiva la dimensione delle immagini dipende dalla vostra necessità.

Generalmente, allocare la dimensione di un'immagine non richiederà spazio nell'hard disk fino a quando verranno installati i dati. Fino ad allora occuperà solo dinamicamente spazio nell'hard disk, relativo alla quantità attuale di dati che aumenta nell'immagine. Questo è dato dal rapporto di compressione di qcow2.

Abilitare una macchina virtuale KVM

KVM è la soluzione di virtualizzazione completa per Linux su hardware x86 che comprende le estensioni per la virtualizzazione (Intel VT o AMD-V).

Prerequisiti

Per accertarsi se l'hardware supporta KVM, assicurarsi che KVM sia abilitato nel BIOS (in alcuni casi su di un sistema Intel VT o AMD-V potrebbe non essere evidente dove è l'opzione, perciò si assume che sia alla voce stato KVM). Per controllare in una console eseguire:

cat /proc/cpuinfo | egrep --color=always 'vmx|svm'

Se si vede svm o vmx alla voce cpu flag, il sistema supporta KVM. (Altrimenti tornare indietro al BIOS se si crede che sia supportato e controllare di nuovo, oppure cercare su internet dove abilitare KVM nei menù del BIOS).

Se il BIOS non supporta KVM fare riferimento a Virtualbox o QEMU

Per installare ed avviare KVM per prima cosa assicurarsi che i moduli di Virtualbox non siano caricati, (la migliore opzione è utilizzare --purge):

apt-get install qemu-system-x86 qemu-utils

Quando si avvia il sistema gli script iniziali di qemu-system-x86 penseranno al caricamento dei moduli.

Se si utilizza KVM per avviare una aptosid-*.iso

For 64 bit as user:

$ QEMU_AUDIO_DRV=alsa qemu-system-x86_64 -machine accel=kvm:tcg -net nic,model=virtio -net user -soundhw hda -m 1024 -monitor stdio -cdrom <aptosid.iso>

For 32 bit replace qemu-system-x86_64 with qemu-system-i386.

Installare una aptosid-*.iso in una immagine KVM

Per prima cosa creare una immagine hard disk, (questa immagine sarà minima ed aumenterà solo se richiesto a causa del rapporto di compressione qcow2):

$ qemu-img create -f qcow2 aptosid-2010-*-.img 12G

Avviare aptosid-*.iso con i seguenti parametri per abilitare KVM a riconoscere la presenza di una immagine hard disk QEMU disponibile:

$ QEMU_AUDIO_DRV=alsa qemu-system-x86_64 -machine accel=kvm:tcg -net nic,model=virtio -net user -soundhw hda -m 1024 -monitor stdio -cdrom </path/to/aptosid-*.iso> -boot d </path/to/aptosid-VM.img>

For 32 bit replace qemu-system-x86_64 with qemu-system-i386.

Una volta che il cdrom si è avviato cliccare sull'icona aptosid installer per avviare il programma di installazione, (oppure utilizzare il menu), cliccare sul tab Partizionamento ed avviare l'applicazione che si preferisce. Per il partizionamento si possono seguire le istruzioni in Partizionare il disco fisso - tradizionale, GPT e LVM (non dimenticarsi di aggiungere una partizione di swap se si possiede poca RAM). Siate consapevoli che la formattazione richiederà tempo quindi siate pazienti.

gparted kvm hard disk naming

Adesso si ha una VM pronta all'uso:

$ QEMU_AUDIO_DRV=alsa qemu-system-x86_64 -machine accel=kvm:tcg -net nic,model=virtio -net user -soundhw hda -m 1024 -monitor stdio -drive if=virtio,boot=on,file=<path/to/aptosid-VM.img> 

Alcuni guest non supportano virtio, perciò si devono utilizzare altre opzioni all'avvio di KVM, per esempio:

$ QEMU_AUDIO_DRV=alsa qemu-system-x86_64 -machine accel=kvm:tcg -net nic, -net user -soundhw hda -m 1024 -monitor stdio -hda </path/to/your_guest.img > -cdrom your_other.iso -boot d 

or

$ QEMU_AUDIO_DRV=alsa qemu-system-x86_64 -machine accel=kvm:tcg -net nic, -net user -soundhw hda -m 1024 -monitor stdio -hda </path/to/your_guest.img> 

Vedere anche: KVM documentation.

Gestire le installazioni della macchina virtuale KVM
apt-get install aqemu

Quando si utilizza AQEMU assicurarsi di aver scelto la modalità KVM dal menu a tendina di "Emulator Type" nella scheda "General". (Documentazione per AQEMU praticamente non esiste perciò alcuni "tentativi ed errori" sono necessari per scoprire come utilizzare la GUI, tuttavia un buon inizio è quello di utilizzare il menu "VM" seguito dalla scheda "General".

Avviare ed installare in una macchina virtuale VirtualBox

Passi da fare:

Requisiti

RAM raccomandata: 1 GB: Idealmente 512 MB per il guest e 512 MB per l'host. (può essere avviato o no, ma non ci si deve aspettare grandi prestazioni).

Spazio sul disco fisso: mentre VirtualBox in sé è piuttosto "magro" (una tipica installazione necessiterà soltanto di ~30 MB), le macchine virtuali richiedono invece dei file grandi sul disco per emulare i propri dischi emulati. Così per installare MS Windows XP (TM), ad esempio, servirà un file che può crescere facilmente fino a parecchi GB. Per aptosid sarà necessario allocare in VirtualBox una immagine di 5 giga oltre ad una partizione di swap.

Installazione:

apt-get update
apt-get install virtualbox-ose-qt virtualbox-source dmakms module-assistant

Quindi preparare il modulo:

m-a prepare
m-a a-i virtualbox-source

Poi attivare il Dynamic Module-Assistant Kernel Module Support per virtualbox, così la prossima volta che il kernel Linux viene aggiornato verrà preparato anche un modulo virtualbox per esso, senza intervento manuale. Per fare ciò, aggiungere virtualbox-source al file di configurazione /etc/default/dmakms.

mcedit /etc/default/dmakms
virtualbox-source

Infine riavviare il computer.

Questa è una lettura essenziale sul funzionamento di dmakms

Installare aptosid nella macchina virtuale

Usare il wizard di virtualbox per creare una nuova macchina virtuale per aptosid. Poi seguire le istruzioni per una normale installazione di aptosid.

VirtualBox ha un aiuto esaustivo in formato PDF che si può scaricare

Avviare ed installare in una macchina virtuale QEMU

È disponibile uno strumento con interfaccia grafica QT come aiuto per configurare QEMU:

apt-get install qtemu

Creare l'immagine del disco fisso

Per avviare qemu probabilmente servirà una immagine di disco fisso. Questo è un file che immagazzina il contenuto del disco fisso emulato.

Usare il comando seguente:

qemu-img create -f qcow aptosid.qcow 3G

Crea il file immagine denominato "aptosid.qcow". Il parametro "3G" specifica la dimensione del disco, in questo caso 3 GB. Si può usare il suffisso M per megabyte (per esempio "256M"). Non ci si deve preoccupare troppo riguardo alla dimensione del disco - il formato qcow comprime l'immagine cosicché lo spazio vuoto non si aggiunge alla dimensione di questo file.

Installare il sistema operativo

Questa è la prima volta che serve l'avvio dell'emulatore. Tenere presente che quando si clicca dentro la finestra di qemu, il puntatore del mouse viene catturato. Per rilasciarlo premere:

Ctrl+Alt

Se serve un floppy avviabile, avviare Qemu con:

qemu -floppy aptosid.iso -net nic -net user -m 512 -boot d aptosid-VM.img

Se il CD-ROM è avviabile, avviare Qemu con:

qemu -cdrom aptosid.iso -net nic -net user -m 512 -boot d aptosid-VM.img

Ora si può installare aptosid come su un disco fisso reale.

Avviare il sistema

Per avviare il sistema, digitare:

qemu [hd_image]

Una buona idea è utilizzare immagini overlay. In questo modo si possono creare le immagini del disco fisso una volta e poi dire a Qemu di salvare i cambiamenti in un file esterno. Ci si può sbarazzare del tutto dell'instabilità dato che è facile ritornare ad uno stato precedente del sistema.

Per creare una immagine overlay, digitare:

qemu-img create -b [[base''image]] -f qcow [[overlay''image]]

Sostituire l'immagine del disco fisso a base_image (nel nostro caso aptosid-VM.img), dopodiché si può avviare qemu con:

qemu [overlay_image]

L'immagine originale non verrà toccata. NOTA: l'immagine di base non può essere rinominata o spostata in quanto l'overlay si ricorda il percorso completo dell'immagine di base.

Usare qualsiasi partizione reale come partizione primaria singola di una immagine del disco

Talvolta si potrebbe voler usare una delle partizioni del sistema dall'interno di qemu (per esempio se si vuole avviare sia la macchina reale che qemu usando una certa partizione come root). È possibile farlo usando il software RAID in modalità lineare (serve il driver del kernel "linear.ko") e un dispositivo loopback: il trucco è mettere dinamicamente un master boot record (MBR) all'inizio della partizione reale che si vuole inglobare in una immagine del disco grezza di qemu.

Supponiamo di avere una partizione pulita e non montata /dev/sdaN con qualche filesystem su di essa che si vuole sia parte di una immagine disco di qemu. Prima salvare in un piccolo file l'MBR:

dd if=/dev/zero of=/percorso/verso/mbr count=32

Verrà creato un file di 16 KB (32 * 512 byte). È importante non crearlo troppo piccolo (anche se a MBR serve solo un singolo blocco di 512 byte), poiché più piccolo sarà e più piccola dovrà essere la parte più grossa del dispositivo del software RAID, e ciò potrebbe influire sulle prestazioni. Poi impostare un dispositivo di loopback al file MBR:

losetup -f /percorso/verso/mbr

Supponiamo che il dispositivo risultante sia /dev/loop0, in quanto potremmo non avere ancora usato altri loopback. Il prossimo passo sarà quello di creare l'immagine disco "combinata" MBR e /dev/sdaN utilizzando il software RAID:

 modprobe linear
 mdadm --build --verbose /dev/md0 --chunk=16 --level=linear --raid-devices=2 /dev/loop0 /dev/sdaN

Il risultante /dev/md0 sarà quello che useremo come immagine del disco grezza qemu (non dimenticare di impostare i permessi in modo che l'emulatore vi possa accedere). L'ultimo (e un po' scaltro) passo è impostare la configurazione del disco (geometria del disco e tabella della partizioni) in modo che il punto di inizio della partizione primaria nell'MBR si abbini a quello di /dev/sdaN dentro /dev/md0 (un offset di esattamente 16 * 512 = 16384 byte in questo esempio). Si può fare usando fdisk sulla macchina host, non nell'emulatore: la routine predefinita di rilevamento di dischi grezzi produce un "non kilobyte-roundable offsets" (es. 31.5 KB, come nella sezione precedente) che non può essere gestita dal codice del software RAID. Quindi, dall'host:

 fdisk /dev/md0

Creare una partizione primaria singola corrispondente a /dev/sdaN, e giocare con il comando "s"ector dal menu "x"pert finché il primo cilindro (dove inizia la prima partizione) si abbina con la dimensione dell'MBR. Alla fine scrivere ("w"rite) il risultato nel file. Finito. Ora si ha una partizione che si può montare direttamente dall'host, come se fosse una parte di una immagine disco qemu:

 qemu -hdc /dev/md0 [...]

Si può naturalmente impostare in sicurezza qualsiasi bootloader in questa immagine disco che usa qemu, purché la partizione originale /boot/sdaN contenga gli strumenti necessari.

Qui si trova la documentazione ufficiale del progetto QEMU.

Alcuni contenuti riguardo a QEMU sono stati tratti dal wiki di arklinux sotto la Licenza 1.2 della documentazione libera GNU e modificati per il manuale aptosid.

Page last revised 04/10/2013 1320 UTC