servidores | Freedom Interface

Arquvo de ‘servidores’

libvirt e nested paging

Data:2010.09.01 | Categoriaservidores, virtualização | Resposta:0

Embora o qemu-kvm já tenha suporte à páginas aninhadas (nested pages), a última versão do libvirt-0.8.3 ainda não suporta.

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 */

ssh com chave privada

Data:2010.07.14 | Categorialinux, redes, servidores, utilidades | Resposta:0

No mundo Linux o protocolo ssh é muito utilizado para administração remota e transferência segura de arquivos entre hosts, sendo na maioria servidores. Acredito que sua ampla adoção se deve à simplicidade, velocidade e segurança. Por padrão, na maioria das distribuições Linux ele usa autenticação por senha e um par de chaves públicas.

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.
libvirt e LVM2

Data:2010.07.07 | Categorialinux, servidores, utilidades, virtualização | Resposta:0

Uma ótima forma de criar uma estrutura para suportar máquinas virtuais é a parceria entre libvirt e LVM2. No meu caso em específico, uso o emulador qemu-kvm para rodar minhas máquinas virtuais. A seguir, apresentarei como se cria um pool de volumes lógicos no libvirt e como converter máquinas já criadas em arquivos de imagens.

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>
```
libvirt no Slackware 13.1

Data:2010.07.01 | Categorialinux, servidores, virtualização | Resposta:0

Libvirt é um ótimo utilitário para gerenciamento de máquinas virtuais de algumas plataformas de virtualização, como Xen, KVM, VMWare ESX, VirtualBox, OpenVZ, entre outros. Neste post farei um guia rápido para instação dele.

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.

rc.libvirt

Data:2010.05.26 | Categorialinux, servidores, virtualização | Resposta:1

Segue abaixo um script de start e stop para o serviço libvirtd que fiz para Slackware:

#!/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

qemu-kvm

Data:2010.05.24 | Categorialinux, servidores, virtualização | Resposta:0

Há tempos venho usando a virtualização como meio de testar sistemas e multiplicar o número de máquinas de teste, que sem ela, seria quase impossível. Nesta última semana passei a me preocupar mais com o assunto. Embora eu já venha usando seus milagrosos recursos, nunca havia parado para ver que soluções existem na praça e como esta mágica funciona. Resolvi finalmente ler um livro sobre o tema que um amigo me emprestou há mais de um ano. Não sei o que é pior, não devolver o livro do amigo ou não ler. O livro se chama Virtualização, publicado pela Linux Magazine.

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
```
Instalação NIS – Cliente

Data:2010.04.27 | Categorialinux, redes, servidores | Resposta:0

O cliente é levemente parecido com o cliente, apenas algumas opções a mais. Primeiramente no arquivo /etc/yp.conf definimos qual o domínio que pertenceremos e qual é o servidor NIS deste. Este arquivo ficará com o seguinte conteúdo, apenas:
```
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.
Instalação NIS – Servidor

Data:2010.04.27 | Categorialinux, redes, servidores | Resposta:0

Primeiramente é preciso entender o NIS. Sem maiores pesquisas, baseando apenas no meu conhecimento, ele é um serviço de informações de contas de usuários. Com este serviço, você pode ter centralizado em apenas um servidor todas as contas, senhas e grupos de um sistema. Este é consultado pelas estações, clientes, que buscam nele informações para o login.

Para ele funcionar, é necessário que o serviço de rpc esteja habilitado e rodando, tanto no servidor como no cliente, pois as trocas de informações são feitas pelo portmap.

Vamos à configuração!

O servidor é extremamente simples. Com o serviço rpc rodando, você precisará apenas definir seu domínio NIS com o comando:
```
nisdomainname [dominio]
```
Após, rode o comando ypserv, que normalmente está em /usr/sbin.
```
/usr/sbin/ypserv
```
Para um servidor master, precisará também executar o comando rpc.yppasswdd que está em /usr/sbin.
```
/usr/sbin/rpc.yppasswdd
```
Para servidor slave, em lugar do rpc.yppasswdd, use o comando rpc.ypxfrd, que é um proxy para o master.
```
/usr/sbin/rpc.ypxfrd
```
Para cada usuário criado no sistema, é necessário ir até o diretório /var/yp e rodar o comando:
```
make
```
Sem isto, o usuário criado não será válido no NIS. Pronto, seu servidor está rodando e aguardando requisições de login!

Tags Cloud

"viagens" backup banco de dados catástrofes curiosidade dicas espiritualidade filosofias hardware linux recuperação redes servidores sql utilidades vídeos variedades virtualização

WP Cumulus Flash tag cloud by Roy Tanck and Luke Morton requires Flash Player 9 or better.

Arquivo

setembro 2010
S	T	Q	Q	S	S	D
« ago
	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30

Blog

Lista de Links

Utilitários

Tweets

Por isso optei pelo KVM: http://www.ibm.com/developerworks/br/library/l-linux-kvm/ 15 hrs ago
Broadcasting your screencast http://www.livestream.com/ 17 hrs ago
Centenário do Corinthians - http://tinyurl.com/2c824ag 6 days ago
Para os amantes de virtualização, linux e afins: http://www.freedominterface.org/2010/09/01/libvirt-e-nested-paging/ 1 week ago
More updates...

Posting tweet...

Convertendo arquivos de imagens em volumes lógicos

Configuração básica