No meu caso, eu tinha uma VM montada sobre um volume de 10GB, e eu desejava expandir este espaço para 30GB, sem ter que anexar outro volume. Segui rigorosamente estes passos: parar a VM, expandir o volume lógico, dar boot com um CD ou pendrive de boot da distribuição, recriar a tabela de partições com o fdisk com os novos valores, estender a partição ext4 com resize2fs. Acompanhe mais detalhadamente abaixo.

Volume lógico

Antes de mais nada, a máquina virtual deverá estar desligada. No servidor hypervisior, execute o seguinte comando:

lvextend -L +20G /dev/logical/plutus

Isto faz com que meu volume lógico ‘plutus’ seja aumentado em 20GiB (veja diferença entre GiB e GB)

Partição física do disco virtual

Depois de o volume esticado, basta dar o boot na máquina virtual usando um disco de boot externo. Isto é importante porque vamos mexer na estrutura básica das partições. No meu caso eu uso Slackware64 13.1 e fdisk, mas nada impede de usar outra distro e ferramenta. O importante é que não haja formatação na finalização do processo. Aqui, assume-se que você saiba usar a ferramenta escolhida.

Na minha VM, eu tenho duas partições: / (root ou barra) como sda1 de 9,5GiB e swap como sda2 0,5GiB. Neste passo, preciso entrar no fdisk no dispositivo sda e excluir as duas partições. Mas calma! Isto não fará com que você perca seus dados, pois estamos apenas mexendo no mapeamento das partições, onde começa e termina o que. Depois de excluir, criei a partição número 1, que corresponde ao / com o tamanho de 29,5GiB e o restante para swap. Aqui é importantíssimo que se observe o início da partição 1, que deverá estar no mesmo bloco da anterior. Caso contrário, os dados ficarão inacessíveis. Feito isto, basta salvar a nova tabela de partições.

Estendendo a partição ext4

Aproveitando que não estamos rodando em cima do disco em questão, vamos efetivar o tamanho da partição útil do sistema. Para isto usarei o comando resize2fs do pacote e2fsprogs. Este passo é muito simples, basta usar o comando:

resize2fs /dev/sda1

Isto fará com que ele aumente a partição ext4 para o máximo possível, no caso 29,5GiB. É provável que ele solicite uma checagem com o fsck antes de fazer isto. Basta usar o comando:

fsck /dev/sda1

Finalização

Agora, basta testar. Antes mesmo de um boot no disco principal, tente montara nova partição:

mount /dev/sda1 /mnt

Se tudo correu bem, você poderá navegar na nova partição pelo ponto de montagem /mnt. Agora basta dar um reboot usando o disco principal.

diff -Naur libvirt-0.8.4/docs/schemas/domain.rng libvirt-0.8.4.edu/docs/schemas/domain.rng
--- libvirt-0.8.4/docs/schemas/domain.rng       2010-08-31 10:44:13.000000000 -0300
+++ libvirt-0.8.4.edu/docs/schemas/domain.rng   2010-09-28 14:34:40.626234752 -0300
@@ -1619,6 +1619,11 @@
               <empty/>
             </element>
           </optional>
+          <optional>
+           <element name="nesting">
+             <empty/>
+           </element>
+         </optional>
         </interleave>
       </element>
     </optional>
diff -Naur libvirt-0.8.4/src/conf/domain_conf.c libvirt-0.8.4.edu/src/conf/domain_conf.c
--- libvirt-0.8.4/src/conf/domain_conf.c        2010-08-31 10:44:13.000000000 -0300
+++ libvirt-0.8.4.edu/src/conf/domain_conf.c    2010-09-28 14:35:36.069149447 -0300
@@ -75,7 +75,8 @@
 VIR_ENUM_IMPL(virDomainFeature, VIR_DOMAIN_FEATURE_LAST,
               "acpi",
               "apic",
-              "pae")
+              "pae",
+             "nesting")

 VIR_ENUM_IMPL(virDomainLifecycle, VIR_DOMAIN_LIFECYCLE_LAST,
               "destroy",
diff -Naur libvirt-0.8.4/src/conf/domain_conf.h libvirt-0.8.4.edu/src/conf/domain_conf.h
--- libvirt-0.8.4/src/conf/domain_conf.h        2010-08-31 10:44:13.000000000 -0300
+++ libvirt-0.8.4.edu/src/conf/domain_conf.h    2010-09-28 14:36:11.931054102 -0300
@@ -650,6 +650,7 @@
     VIR_DOMAIN_FEATURE_ACPI,
     VIR_DOMAIN_FEATURE_APIC,
     VIR_DOMAIN_FEATURE_PAE,
+    VIR_DOMAIN_FEATURE_NESTING,

     VIR_DOMAIN_FEATURE_LAST
 };
diff -Naur libvirt-0.8.4/src/qemu/qemu_conf.c libvirt-0.8.4.edu/src/qemu/qemu_conf.c
--- libvirt-0.8.4/src/qemu/qemu_conf.c  2010-09-10 09:38:13.000000000 -0300
+++ libvirt-0.8.4.edu/src/qemu/qemu_conf.c      2010-09-28 14:38:36.218612249 -0300
@@ -1192,6 +1192,8 @@
         flags |= QEMUD_CMD_FLAG_MEM_PATH;
     if (strstr(help, "-chardev"))
         flags |= QEMUD_CMD_FLAG_CHARDEV;
+    if (strstr(help, "-enable-nesting"))
+        flags |= QEMUD_CMD_FLAG_NESTING;
     if (strstr(help, "-balloon"))
         flags |= QEMUD_CMD_FLAG_BALLOON;
     if (strstr(help, "-device"))
@@ -3944,6 +3946,9 @@
             goto error;
         }
     }
+    if ((qemuCmdFlags & QEMUD_CMD_FLAG_NESTING) &&
+        (def->features & (1 << VIR_DOMAIN_FEATURE_NESTING)))
+        ADD_ARG_LIT("-enable-nesting");

     /*
      * NB, -nographic *MUST* come before any serial, or monitor
@@ -6303,6 +6308,8 @@
             fullscreen = 1;
         } else if (STREQ(arg, "-localtime")) {
             def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
+        } else if (STREQ(arg, "-enable-nesting")) {
+            def->features |= (1 << VIR_DOMAIN_FEATURE_NESTING);
         } else if (STREQ(arg, "-kernel")) {
             WANT_VALUE();
             if (!(def->os.kernel = strdup(val)))
diff -Naur libvirt-0.8.4/src/qemu/qemu_conf.h libvirt-0.8.4.edu/src/qemu/qemu_conf.h
--- libvirt-0.8.4/src/qemu/qemu_conf.h  2010-08-31 10:44:13.000000000 -0300
+++ libvirt-0.8.4.edu/src/qemu/qemu_conf.h      2010-09-28 14:38:58.739788135 -0300
@@ -93,6 +93,8 @@
     QEMUD_CMD_FLAG_NODEFCONFIG   = (1LL << 37), /* -nodefconfig */
     QEMUD_CMD_FLAG_BOOT_MENU     = (1LL << 38), /* -boot menu=on support */
     QEMUD_CMD_FLAG_ENABLE_KQEMU  = (1LL << 39), /* -enable-kqemu flag */
+    QEMUD_CMD_FLAG_NESTING       = (1LL << 40), /* Is the -enable-nesting flag available */
+
 };

 /* Main driver state */

Apenas para esclarecer, Nested Paging é um recurso disponível apenas para processadores AMD da linha Phenom ou superior. Maiores detalhes, consulte este documento.

Pesquisei por referências de como habilitar a opção ‘-enable-nesting’ do qemu-kvm no libvirt, mas não encontrei. Depois de pelo menos 2 dezenas de cliques, eis que encontro na lista de e-mails dos desenvolvedores do libvirt referências já antigas (novembro de 2009), de como usar o nesting. Pois bem, meu trabalho se resumiu em ler certinho as mensagens e montar um patch. Mesmo que a versão que estou usando (0.8.3) seja muito mais nova que esse post, testei as alterações, e que maravilha, funcionou!!!

Depois de compilado e instalado, só precisei acrescentar na definição do domínio dentro da tag <features> uma tag <nesting/>. Depois disso é só iniciar a VM e ver que na linha de comando da sua máquina virtual tem o -enable-nesting.

Agradeço demais a equipe de desenvolvimento de qemu-kvm e libvirt!

Abaixo segue o meu patch para libvirt-0.8.3:

diff -Naur ../libvirt-0.8.3//docs/schemas/domain.rng ./docs/schemas/domain.rng
--- ../libvirt-0.8.3//docs/schemas/domain.rng   2010-07-29 06:48:30.000000000 -0300
+++ ./docs/schemas/domain.rng   2010-09-01 16:51:57.710851479 -0300
@@ -1595,6 +1595,11 @@
               <empty/>
             </element>
           </optional>
+          <optional>
+           <element name="nesting">
+             <empty/>
+           </element>
+         </optional>
         </interleave>
       </element>
     </optional>
diff -Naur ../libvirt-0.8.3//src/conf/domain_conf.c ./src/conf/domain_conf.c
--- ../libvirt-0.8.3//src/conf/domain_conf.c    2010-08-02 16:16:42.000000000 -0300
+++ ./src/conf/domain_conf.c    2010-09-01 16:51:57.710851479 -0300
@@ -75,7 +75,8 @@
 VIR_ENUM_IMPL(virDomainFeature, VIR_DOMAIN_FEATURE_LAST,
               "acpi",
               "apic",
-              "pae")
+              "pae",
+             "nesting")

 VIR_ENUM_IMPL(virDomainLifecycle, VIR_DOMAIN_LIFECYCLE_LAST,
               "destroy",
diff -Naur ../libvirt-0.8.3//src/conf/domain_conf.h ./src/conf/domain_conf.h
--- ../libvirt-0.8.3//src/conf/domain_conf.h    2010-07-29 06:48:30.000000000 -0300
+++ ./src/conf/domain_conf.h    2010-09-01 16:51:57.710851479 -0300
@@ -649,6 +649,7 @@
     VIR_DOMAIN_FEATURE_ACPI,
     VIR_DOMAIN_FEATURE_APIC,
     VIR_DOMAIN_FEATURE_PAE,
+    VIR_DOMAIN_FEATURE_NESTING,

     VIR_DOMAIN_FEATURE_LAST
 };
diff -Naur ../libvirt-0.8.3//src/qemu/qemu_conf.c ./src/qemu/qemu_conf.c
--- ../libvirt-0.8.3//src/qemu/qemu_conf.c      2010-08-04 09:21:27.000000000 -0300
+++ ./src/qemu/qemu_conf.c      2010-09-01 16:57:47.485469640 -0300
@@ -1190,6 +1190,8 @@
         flags |= QEMUD_CMD_FLAG_MEM_PATH;
     if (strstr(help, "-chardev"))
         flags |= QEMUD_CMD_FLAG_CHARDEV;
+    if (strstr(help, "-enable-nesting"))
+        flags |= QEMUD_CMD_FLAG_NESTING;
     if (strstr(help, "-balloon"))
         flags |= QEMUD_CMD_FLAG_BALLOON;
     if (strstr(help, "-device"))
@@ -3907,6 +3909,9 @@
             goto error;
         }
     }
+    if ((qemuCmdFlags & QEMUD_CMD_FLAG_NESTING) &&
+        (def->features & (1 << VIR_DOMAIN_FEATURE_NESTING)))
+        ADD_ARG_LIT("-enable-nesting");

     /*
      * NB, -nographic *MUST* come before any serial, or monitor
@@ -6265,6 +6270,8 @@
             fullscreen = 1;
         } else if (STREQ(arg, "-localtime")) {
             def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
+        } else if (STREQ(arg, "-enable-nesting")) {
+            def->features |= (1 << VIR_DOMAIN_FEATURE_NESTING);
         } else if (STREQ(arg, "-kernel")) {
             WANT_VALUE();
             if (!(def->os.kernel = strdup(val)))
diff -Naur ../libvirt-0.8.3//src/qemu/qemu_conf.h ./src/qemu/qemu_conf.h
--- ../libvirt-0.8.3//src/qemu/qemu_conf.h      2010-07-28 11:18:15.000000000 -0300
+++ ./src/qemu/qemu_conf.h      2010-09-01 16:58:29.900876561 -0300
@@ -92,6 +92,7 @@
     QEMUD_CMD_FLAG_PCI_CONFIGFD  = (1LL << 36), /* pci-assign.configfd */
     QEMUD_CMD_FLAG_NODEFCONFIG   = (1LL << 37), /* -nodefconfig */
     QEMUD_CMD_FLAG_BOOT_MENU     = (1LL << 38), /* -boot menu=on support */
+    QEMUD_CMD_FLAG_NESTING       = (1LL << 39), /* Is the -enable-nesting flag available */
 };

 /* Main driver state */

Outro método de autenticação seria por meio de um par de chaves pública e privada. Nesse método, cada cliente possui uma chave privada que o identifica e deve ser protegida. O servidor recebe a chave pública correspondente de cada cliente para autenticar. Desta forma, não há, à princípio, necessidade de senha. Porém, o próprio certificado pode exigir uma senha para ser acessado, mas assim, ele será único para todos os servidores e não haverá tráfego de senha entre servidor e cliente. Vejamos como fazer isto:

No cliente, é preciso gerar as chaves com o seguinte comando:

ssh-keygen

Ele perguntará por uma senha. Caso queira fornecer, digite-a. Caso queira que o acesso seja direto, deixe em branco. Por padrão, ele gerará dois arquivos: ~/.ssh/id_rsa e ~/.ssh/id_rsa.pub. Respectivamente eles são a chave privada e pública em algorítmo RSA. Copie a chave pública para o servidor (assumindo que o IP dele é 10.0.0.8):

scp ~/.ssh/id_rsa.pub 10.0.0.8:~

No servidor, insira a chave pública recém recebida na lista de chaves autorizadas:

cat ~/id_rsa.pub >> ~/.ssh/authorized_keys

Feito isto, basta alterar o modo de autenticação do servidor. Acesse o arquivo de configuração /etc/ssh/sshd_config e altere, acrescente ou descomente as seguintes opções para que confira com o modelo:

# Define autenticação por chave pública RSA.
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile     .ssh/authorized_keys

# Desabilita autenticação por senha
PasswordAuthentication no
PermitEmptyPasswords no

Reinicialize o serviço do ssh. No Slackware execute /etc/rc.d/rc.sshd restart. Agora está pronto, basta testar. No cliente, pode-ser conectar usando duas sintaxes:

ssh 10.0.0.8

Use o exemplo acima caso o nome do arquivo e caminho da chave seja o padrão, ~/.ssh/id_rsa. Se for diferente, a seguinte sintaxe será necessária:

ssh -i <caminho completo para chave privada> 10.0.0.8

Para mais informações, o bom e velho man sempre ajuda.

Antes de tudo, é necessário que já tenha sido criado um grupo virtual. Como isso não está no escopo do post, recomendo navegar por esse howto. Com o grupo criado e ativado, vamos criar a definição do pool para o libvirt. Abra um editor de texto, como o vim, e coloque nele o seguinte texto:

<pool type='logical'>
<name>logical</name>
<source>
<device path='/dev/sdb1'/>
<name>logical</name>
<format type='lvm2'/>
</source>
<target>
<path>/dev/logical</path>
</target></pool>

Nesse exemplo, vamos assumir que a partição que compõe o grupo logico é o /dev/sdb1. Após, salve com um nome sugestivo, como por exemplo logical.xml. Agora só resta registrar no libvirt.

virsh pool-define logical.xml

Mesmo registrado, o sistema ainda não ativou o pool. É recomendado que ele seja marcado como autostart, para que caso o libvirt pare, ele ative automaticamente o pool. Para isto, basta os seguintes comandos:

virsh pool-autostart logical
virsh pool-start logical

Com o pool inicializado, agora só resta criar um volume lógico dentro dele:

virsh vol-create-as logical disco_teste 10GB

Este comando criará um volume lógico de nome disco_teste no grupo logical tendo como capacidade 10GiB

Convertendo arquivos de imagens em volumes lógicos

Caso já tenha uma máquina virtual configurada em um arquivo de imagem nos formatos suportados pelo qemu, basta convertê-lo usando o próprio qemu-img para o formato desejado. Na versão 0.12.4 os formatos suportados são: cow, qcow, vdi, vmdk, cloop, dmg, bochs, qcow2, host_device, raw entre outros.

Antes de começar, é preciso criar um volume lógico com o mesmo tamanho da imagem existente. Para ter o valor correto, use a ferramenta qemu-img para saber o tamanho total da imagem:

qemu-img info disco.img

Ele retornará algo como:

image: disco.img
file format: qcow2
virtual size: 10G (10737418240 bytes)
disk size: 4.0G
cluster_size: 65536

Veja que, embora o arquivo tenha tamanho de 4GB, ele pode crescer até o tamanho virtual, que é de 10GB para esta imagem. Agora, crie um volume lógico com este tamanho seguindo o modelo logo acima.

Eu conheço duas formas de levar o arquivo de imagem para um volume lógico. A primeira é usando o qemu-img para já gravar a imagem no volume:

qemu-img convert -f qcow2 -O host_device disco.img /dev/logical/disco_teste

Ou então, com uma etapa a mais, e portanto mais demorada, transformando a imagem do formato nativo para raw e depois transferindo os dados de forma bruta para o volume com o dd:

qemu-img convert -f qcow2 -O raw disco.img disco.raw
dd if=disco.raw of=/dev/logical/disco_teste

O resultado de ambos é o mesmo. Desde que tenha um domínio registrado com esse disco, agora é só usar o volume lógico recém criado. A definição de um disco em volume lógico segue o modelo:

<devices>
...
<disk type='block' device='disk'>
<source dev='/dev/logical/disco_teste'/>
<target dev='sdc' bus='scsi'/>
</disk>
...
</devices>

Como estou usando a distribuição Slackware, é interessante compilar o libvirt e gerar um pacote txz, no padrão da distribuição. Como o pessoal da slackbuilds.org já disponibilizou o script SlackBuild para ele, vamos aproveitar. Acesse esse link que mostrará o resultado da busca por libvirt no repositório. Como resultado, aparecerá o link para a página de download da versão mais atual que estiver no repositório. Clique no link.

Quando escrevi este post, a versão que estava lá era a 0.7.6, mas eu abordarei aqui a versão 0.8.1 por causa de novos recursos. Portanto, o único pacote necessário será o libvirt.tar.gz. Baixe-o clicando no link da página. O código fonte da versão 0.8.1 você encontrará neste endereço.

Dentre vários recursos desta versão, uma em especial eu gostaria de colocar em evidência: o suporte ao módulo macvtap. A grosso modo, isto possibilita anexar uma interface virtual tap em uma interface real. Assim é possível que o sistema operacional hóspede se integre à LAN real da máquina hospedeira. Este recurso está disponível a partir da versão 2.6.34 do kernel do Linux. Desta maneira, será necessário atualizar o kernel para esta versão. Como compilar o kernel não está no escopo do artigo, deixo apenas a informação de habilitar o recurso de macvtap na seção Device Drivers->Network device support->MAC-VLAN support e MAC-VLAN based tap device.

Supondo que os pacotes do libvirt foram salvos no diretório ~/libvirt, execute os seguintes passos:

cd ~/libvirt
tar xvf libvirt.tar.gz
mv libvirt/* .

Edite o arquivo libvirt.SlackBuild para alterar a versão de 0.7.6 para 0.8.1. Salve e vamos compilar:

ARCH=`uname -m` ./libvirt.SlackBuild

Aguarde terminar e após instale o pacote:

installpkg /tmp/libvirt-0.8.1-x86_64-1.tar.gz

Configuração básica

Verifique neste post um exemplo de script de inicialização para o serviço do libvirt. Copie o script para um arquivo chamado rc.libvirtd na pasta /etc/rc.d/. Devo lembrar de acrescentar sua chamada dentro do script rc.local, caso queira que ele suba automaticamente com o sistema, quando iniciado.

Por default, o servidor do libvirt abrirá um socket tls para acesso tcp, e para isto, é necessário gerar um certificado. Com a finalidade apenas de teste, não creio ser necessário isto, já que o acesso normalmente será feito pelo socket unix mesmo. Altere a opção listen_tls=1 para listen_tls=0 no arquivo /etc/libvirt/libvirtd.conf. Não adianta só comentar esta linha, já que o default é habilitado.

#!/bin/bash

MODULES="tun vhost_net"
PIDFILE="/var/run/libvirtd.pid"
TIMEOUT=${TIMEOUT:-40}
OPTS=${OPTS:-""}

check_running_machines() {

  i=0

  for j in `virsh list | grep running | awk '{print $2;}'` ; do
    virsh shutdown $j
  done

  echo -n "Waiting machines"

  while [ $(virsh list | grep running | wc -l) -gt "0" ]; do
    if [ "$i" -ge "$TIMEOUT" ];then
      break
    fi
    echo -n "."
    i=`expr $i + 1`
    sleep 1
  done

  echo ""

  if [ $(virsh list | grep running | wc -l) -gt "0" ];then

    echo -n "The following machines are still running, forcing shutdown: "
    for j in `virsh list | grep running | awk '{print $2;}'` ; do
      virsh destroy $j
      echo -n "$j "
    done

    echo ""
    sleep 2
  fi

}

check_processor() {

  egrep 'vmx' /proc/cpuinfo > /dev/null

  if [ "$?" -eq "0" ];then
    MODULES="$MODULES kvm_intel kvm"
  fi

  check=$?

  egrep 'svm' /proc/cpuinfo > /dev/null

  if [ "$?" -eq "0" ];then
    MODULES="$MODULES kvm_amd kvm"
  fi

  check=`expr $check + $?`

  if [ $check -eq "2" ];then
    echo "Your systems does not support KVM!"
  fi

}

start() {
  if [ -f $PIDFILE ];then
    echo "libvirt is already running..."
    exit 1
  fi
  echo "Starting libvirtd..."
  check_processor
  modprobe -a $MODULES
  libvirtd -d -l $OPTS
}

stop() {
  if [ ! -f $PIDFILE ];then
    echo "libvirt is not running..."
    exit 2
  fi
  check_running_machines
  check_processor
  echo "Stopping libvirtd..."
  kill -TERM `cat $PIDFILE`
  modprobe -ra $MODULES
}

case $1 in
start)
  start
  ;;
stop)
  stop
  ;;
restart)
  stop
  sleep 1
  start
  ;;
*)
  echo "Usage: $0 (start|stop|restart)"
  ;;
esac

Para quem ainda não leu, o livro fala do conceito de virtualização de uma forma bastante didática e direta apresentando softwares desta área, porém sua ênfase está na solução OpenSource Xen. Ao ler o livro, me lembrei de um recurso que já tinha visto, mas não estudado antes, as instruções Intel-VT e AMD-V, que podem ser referenciadas como vmx e svm respectivamente no Linux. Lembrei também, que há opções disponíveis na tela de configuração do Kernel para habilitar esses recursos, o KVM. Falando rapidamente, o KVM (Kernel-based Virtual Machine) é uma implementação no kernel-space que permite melhor uso do recurso de virtualização do processador usando máquinas virtuais compatíveis com ele.

Mas o KVM não poderia trabalhar sozinho numa solução de virtualização. Pesquisando um pouco mais, vi que o emulador Qemu tem uma versão modificada para trabalhar com o KVM. Como usuário de Slackware que sou, encontrei o script SlackBuild no repostório não-oficial SlackBuilds.org do qemu-kvm. Baixei o pacote do qemu-kvm que estava no mesmo repositório juntamente com seu script e já mandei bala. Alterei o script para dizer qual arquiteturas quero emular. Para isto, basta definir a variável BUILD_ARCH que contém as arquiteturas separadas por um espaço. A lista de arquiteturas suportadas é: i386; x86_64; alpha; arm; armeb; cris; m68k; microblaze; mips; mipsel; ppc; ppc64; ppc64abi32; sh4; sh4eb; sparc; sparc64 e sparc32plus. No meu caso, ficou assim:

BUILD_ARCH="i386 x86_64"

ARCH=`uname -m` ./qemu-kvm.SlackBuild

Depois disto, aguardei o fim da compilação e instalei:

installpkg /tmp/qemu-kvm-0.12.3-x86_64-1_SBo.tgz

Para seu uso, é importante que seu processador suporte a instrução vmx ou svm. Para saber se seu processador suporta, use o seguinte comando:

egrep '(vmx|svm)' /proc/cpuinfo

Se retornar alguma linha, quer dizer que seu processador está preparado. O KVM deve estar compilado com o kernel. Pode ser tanto incorporado no kernel como em módulo. No kernel huge do Slackware, ele já vem compilado como módulo. Para usá-lo, basta carregar o módulo.

Para AMD:

modprobe -a kvm kvm_amd

ou para Intel:

modprobe -a kvm kvm_intel

Agora só é preciso criar a máquina virtual.

O qemu vem com algumas ferramentas, mas aqui falarei apenas de duas: qemu e qemu-img. Antes de tudo, precisamos criar o disco virtual. Para isso, usei o qemu-img:

qemu-img create -f qcow2 ~/teste.img 10G

Traduzindo, mandei ele criar o arquivo de imagem ~/teste.img no formato qcow2 de tamanho 10G. Caso verifique o tamanho do arquivo de imagem e ele esteja muito pequeno, não se assuste. Ele cresce conforme demanda até o limite de 10G. Ainda não descobri como criar o imagem com todo seu espaço já alocado.

Agora basta rodar a máquina na linha de comando:

qemu -hda ~/teste.img -cdrom ~/slackdvd.iso -boot d -m 256 -k pt-br -name Teste -net nic,model=pcnet -net user

Traduzindo, eu pedi para o qemu inicializar a máquina de nome Teste atribuindo o disco ide primério como sendo teste.img, uma unidade de cdrom montada com a imagem slackdvd.iso. Pedi para que busque o boot na unidade d, ou seja, no dvd. Ele terá também 256MB de memória, um teclado com layout pt-br. Para conectividade use uma placa de rede do modelo pcnet e crie uma nat da minha interface de rede real para ela. Assim terei acesso à Internet. Caso não queira ter o terminal preso, acrescente a opção -daemonize.

Essa configuração é básica, apenas para se ter um primeiro contato. Vale observar também, que o comando qemu cria um ambiente 32bit. Para uso de sistemas 64bit, use o comando qemu-system-x86_64 em seu lugar. Para configurações mais completas, confira o manual do comando qemu:

man qemu

domain dominio_nis server endereço_do_servidor

Agora é preciso indicar ao sistema que procure as informações de login no NIS. Para isto, alteraremos o arquivo /etc/nsswitch.conf. Localize as linhas que contenham as configurações para os arquivos passwd, group e shadow. Altere para o seguinte:

passwd:		files nis
shadow:		files nis
group:		files nis

Isto fará com que o sistema procure primeiramente nos arquivos locais, caso não encontre, procurará via NIS. Mais outro detalhe, é importante para que isto aconteça. No final do arquivo /etc/passwd, acrescente uma linha igual à esta:

+::::::

No arquivo /etc/group, por sua vez, acrescente:

+:::

Está quase pronto. Agora para usarmos a autenticação remota, precisamos definir nosso domínio NIS com o comando:

nisdomainname [dominio]

Observe que o domínio do servidor e cliente deverão ser o mesmo. Após, apenas inicializaremos o NIS cliente com o comando:

/usr/sbin/ypbind

Depois de tudo isto, os usuários terão que ser cadastrados apenas no servidor, podendo ser logados de qualquer máquina cliente do servidor NIS.