Procurar Online Offline
Opções de instalação de Máquina Virtual (VM)
Os exemplos seguintes utilizam aptosid para a instalação. Simplesmente substitua aptosid pela distribuição que você deseja experimentar.
Installing other distributions to a VM image
Nota: a maior parte das distribuições do Linux vão precisar de pouco espaço no seu disco. Como o disco efetivamente usado depende únicamente da instalação que fizer, nós recomendamos reservar 12GB para Linux e 30GB para o MS Windows..
Como ativar uma VM usando KVM (VM basead no kernel do Linux)
KVM é uma solução de virtualização para Linux utilizando hardware x86 que possua extensões de virtualização (Intel VT ou AMD-V).
Pré-requisitos
Para verificar se seu hardware suporta KVM, certifique-se que a virtualização não está desativada na BIOS - o lugar para a ativar/desativar não é evidente e pode estar escondido, por isso consulte o seu Manual da BIOS. A maneira de verificar se está ativada, é executando numa consola os comandos seguintes:
cat /proc/cpuinfo | egrep --color=always 'vmx|svm'
Se você vir svm ou vmx então o seu sistema suporta o KVM. (se isso não acontecer e você está seguro de que deveria suportar, então controle novamente a sua configuração da BIOS, consulte o manual da mesma ou procure na Net aonde essa opção está "escondida").
Se o seu sistema não suporta a virtualização KVM o melhor será utilizar Virtualbox ou QEMU
Para utilizar KVM, assegure-se que os módulos da "Virtualbox" não estão carregados, (o melhor é desinstalá-los com a opção "--purge" ):
apt-get install qemu-system-x86 qemu-utils
Quando reiniciar o sistema os scripts de inicialização do qemu-system-x86 tomarão conta de carregar os módulos necessários.
Utilizar KVM para lançar um iso do aptosid
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.
Como instalar o aptosid numa imagem de KVM
Primeiro é necessário criar uma imagem de disco, (o espaço ocupado por esta imagem é inicialmente minimo e aumentará únicamente quando necessário):
$ qemu-img create -f qcow2 aptosid-VM.img 12G
Utilize os parâmetros seguintes para lançar o iso e para tornar o disco acessível à VM.:
$ 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.
Depois da inicialização do sistema estar completada clique no icon do programa de instalação do aptosid para o lançar ( ou utilize o menu), vá ao Particionamento e á sua esquerda terá uma caixa que deve ter um disco pronto para o particionamento e formatar, muito provávelmente /dev/sda. Escolha gparted ou partitionmanager. Tome atenção que o partionmanager tem um layout um pouco diferente do gparted, que vamos utilzar neste exemplo.
A sua VM está pronta a ser utilizada:
$ 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>
Nota: alguns guest sistemas não têm suporte de virtio (não é o caso do aptosid) então o comando do kvm vai necessitar de outros parâmetros:
$ 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
ou
$ 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>
Leitura altamente recomendada: Documentação do KVM.
Administração das suas máquinas virtuais de KVM
A administração das máquinas virtuais do KVM poderá ser feita por intermédio do "aqemu" que terá que ser instalado.
apt-get install aqemu
Tenha o cuidado de escolher o modo KVM como 'Emulator Typo' na página de preferências 'General' (A documentação do AQEMU é minima, pelo que serão necessárias algumas tentativas para o uso correto. Um bom ponto de partida é começar a pelas páginas menu "VM" e depois "General").
Booting and installing to a VirtualBox Virtual Machine
Passos:
- 1. crie uma imagem do HD para VirtualBox
- 2. dê o boot em ISOs com VirtualBox
- 3. instale a imagem
Requisitos:
RAM recomendada: 1 GB ; idealmente, 512 MB para o guest e 512 MB para o host (pode ser rodado com menos memória, porém não espere bom desempenho).
Espaço no HD: Enquanto o VirtualBox em si é magro (uma instalação típica ocupa apenas 30 MB de espaço), as máquinas virtuais necessitarão de grandes arquivos no disco para representar seus próprios HDs. Assim, para instalar o MS Windows XP (TM), por exemplo, você vai precisar de um arquivo que facilmente crescerá por diversos GB em tamanho. Para não se apertar, vai ser preciso que você aloque uma imagem de 5 GB e mais a swap.
Instalação:
apt-get update apt-get install virtualbox-ose-qt virtualbox-source dmakms module-assistant
Então prepare o módulo:
m-a prepare m-a a-i virtualbox-source
Daí ative o Dynamic Module-Assistant Kernel Module Support (dmakms) para o Virtualbox, de forma que, na próxima vez que o kernel for atualizado, um módulo do Virtualbox também seja preparado para ele, sem intervenção manual. Para fazer isso, adicione virtualbox-source ao arquivo de configuração /etc/default/dmakms .
mcedit /etc/default/dmakms virtualbox-source
Em seguida, reinicie sua máquina.
Leitura essencial sobre o dmakms
Como instalar o aptosid na máquina virtual
Use o assistente do virtualbox para criar uma nova máquina virtual para o aptosid, depois é só seguir as instruções de uma instalação normal.
O VirtualBox tem uma boa Ajuda em PDF, que você pode baixar aqui.
>Booting and installing a QEMU Virtual Machine
- 1. crie uma imagem do HD para o qemu
- 2. dê o boot da iso pelo qemu
- 3. instale a imagem
Existe uma interface gráfica em QT para ajudá-lo a fazer a configuração:
apt-get install qtemu
Como criar a imagem do HD
Para rodar o QEMU, você provavelmente irá precisar de uma imagem do HD. Trata-se de um arquivo que armazena o conteúdo do HD emulado.
Use este comando:
qemu-img create -f qcow aptosid.qcow 3G
Isso cria o arquivo de imagem "aptosid.qcow". O parâmetro "3G" especifica o tamanho do disco - no caso, 3 GB. Você pode usar o sufixo M para megabytes (por exemplo, "256M"). Não se preocupe muito com o tamanho do disco - o formato qcow comprime a imagem, de forma que o espaço vago não é adicionado ao tamanho do arquivo.
Como instalar o sistema operacional
Esta é a primeira vez que você vai precisar de abrir o emulador. Atenção: quando você clica dentro da janela do qemu, o ponteiro do mouse fica preso. Para soltá-lo, pressione:
Ctrl+Alt
Se for preciso dar o boot a partir de um disquete, rode o Qemu com:
qemu -floppy aptosid.iso -net nic -net user -m 512 -boot d aptosid.qcow
...e se for a partir de um CD:
qemu -cdrom aptosid.iso -net nic -net user -m 512 -boot d aptosid.qcow
Agora instale o aptosid como se fosse em um HD de verdade.
Como rodar o sistema
Para rodar o sistema, digite:
qemu [hd_image]
Uma boa ideia é usar imagens sobrepostas. Dessa forma, você pode criar a imagem do HD uma vez e dizer ao qemu para armazenar as mudanças em um arquivo externo. Você se livra de toda possível instabilidade, porque é facílimo reverter o sistema para o estado original.
Para criar uma imagem sobreposta ("overlay"), digite:
qemu-img create -b [[base''image]] -f qcow [[overlay''image]]
Isso substitui a imagem do HD para base_image (no caso, aptosid.qcow). Depois, é só rodar o qemu assim:
qemu [overlay_image]
A imagem original permanece intocada. Um probleminha: a imagem base não poderá ser renomeada ou movida. A sobreposição (overlay) lembra o caminho completo da base.
Como usar qualquer partição real como a partição primária de uma imagem do HD
Pode acontecer de você desejar usar uma de suas partições de dentro do qemu (por exemplo, dar o boot tanto em sua máquina real quanto no qemu, usando uma partição como root). Isso pode ser feito utilizando software RAID no modo linear (é necessário o driver linear.ko) e um dispositivo loopback: o truque é preceder dinamicamente uma MBR à partição real que você deseja embutir em uma imagem de HD bruta (raw) no qemu.
Suponha que você tenha uma partição desmontada /dev/sdaN com alguns arquivos do sistema que você deseja que façam parte de uma imagem de HD do qemu. Primeiro, crie um pequeno arquivo para guardar a MBR:
dd if=/dev/zero of=/caminho/para/mbr count=32
Com isso, um arquivo de 16 KB (32 * 512 bytes) é criado. É importante não fazê-lo muito pequeno (ainda que a MBR precise de apenas um bloco de 512 bytes), pois quanto menor ele for, menor terá de ser o tamanho do software RAID, o que pode impactar no desempenho. Agora, você configura um dispositivo loopback para a MBR:
losetup -f /caminho/para/mbr
Assumamos que o dispositivo resultante seja /dev/loop0, pois até agora não usamos nenhum outro loopback. O próximo passo é criar a imagem do HD resultante da fusão MBR + /dev/sdaN usando software RAID:
modprobe linear mdadm --build --verbose /dev/md0 --chunk=16 --level=linear --raid-devices=2 /dev/loop0 /dev/sdaN
O /dev/md0 resultante é o que você usará como imagem bruta do disco no qemu (não se esqueça de ajustar as permissões para que o emulador possa acessá-la). O último passo é fixar a configuração do disco (geometria do disco e tabela de partições) de forma que o ponto inicial da partição primária na MBR seja igual ao do /dev/sdaN dentro de /dev/md0 (exatamente 16 * 512 = 16384 bytes neste exemplo). Para isso, use o fdisk na máquina hospedeira, não no emulador: a rotina padrão de detecção de imagem bruta (raw) do qemu muitas vezes dá resultados não arredondáveis em kilobytes (como 31.5 KB na seção anterior), impossíveis de serem gerenciados pelo código do RAID. Portanto, no hospedeiro:
fdisk /dev/md0
Lá, crie uma partição primária correspondente a /dev/sdaN e experimente com o comando 's'ector no menu 'x'pert até que o primeiro cilindro (onde está a primeira partição) tenha tamanho igual ao da MBR. Finalmente, use 'w'rite para escrever o resultado no arquivo e... acabou! Agora você tem uma partição que pode ser montada direto da máquina hospedeira e que também é parte da imagem de disco do qemu:
qemu -hdc /dev/md0 [...]
Naturalmente, você pode configurar qualquer carregador de boot na imagem usando o qemu, desde que a partição /boot/sdaN contenha as ferramentas necessárias.