Ricerca Online Offline
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.
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:
- 1. creare una immagine disco fisso per VirtualBox
- 2. avviare la iso con VirtualBox
- 3. installare l'immagine
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
- 1. creare una immagine di disco fisso per QEMU
- 2. avviare la iso con QEMU
- 3. installare l'immagine
È 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.