Posts tagged ‘virtualização’
-
Montar partição de VM em host
Há momentos em que é necessário trabalhar com um disco ou partição de um servidor Linux sem que ele seja usado no boot. Normalmente em PCs usamos um disco de boot que nos entrega um shell para darmos comandos. Geralmente isto é feito para depuração de problemas na partição.
Em máquinas virtuais baseadas no KVM, é possível montar uma partição de uma máquina virtual no servidor hospedeiro. Para isto, basta usar o módulo Network block driver (nbd). Para habilitar, verifique se sua configuração do kernel contém “CONFIG_BLK_DEV_NBD=m” ou “CONFIG_BLK_DEV_NBD=y”. Caso seja um módulo, basta carregá-lo com o modprobe.
modprobe nbd max_part=63
Mais informações, use: modinfo nbd.
No pacote do qemu-kvm, vem uma ferramenta chamada qemu-nbd. Com ela, basta conectar algum dos arquivos de bloco nbd à imagem do disco virtual. No meu caso:
qemu-nbd -c /dev/nbd0 /dev/logical/dns2
.
Ele critou outros arquivos de blocos, representando todas as partições do meu disco virtual: /dev/nbd0p1, /dev/nbd0p2 e /dev/nbd0p3. Com isto, basta eu montar este bloco a alguma pasta do sistema, como no exemplo:
mount /dev/nbd0p1 /mnt/tmp
Vale lembrar que o hospedeiro precisa ter suporte ao sistema de arquivos da partição que será montada.
Para desconectar, é preciso desmontar as partições montadas anteriormente e desconectar o dispositivo.
qemu-nbd -d /dev/nbd0
Mais informações use “qemu-nbd -h” ou “man qemu-nbd”.
-
Estender partição
Como toda invenção, meu aprendizado é orientado à necessidade. Recentemente passei por um sufoco de espaço em disco em uma máquina virtual minha, que opera sobre um servidor Linux com KVM. Para melhor gerência, meus discos virtuais estão alocados como volumes lógicos LVM2, o que facilitou muito meu trabalho neste momento.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.
-
nested paging em libvirt-0.8.4
Segue abaixo uma atualização do patch anterior:
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 */ -
KVM+libvirt em hugepages
O uso de hugepages em domínios KVM no libvirt é muito simples, e pode ser aplicada tanto em VMs já instaladas como em novas. Na definição do domínio, certifique que haja a seguinte estrutura:
... <memoryBacking> <hugepages/> </memoryBacking> ...
Para não haver problemas, certifique também que há páginas suficientes para hospedar a quantidade de memória do domínio. Lembrando que em um sistema x86 32 bit e 64 bit, ocupam 4096KB e 2048KB respectivamente. Sendo assim, um domínio de 256MB deverá ter disponível 64 páginas para um processador 32 bit e 128 páginas para um 64 bit.
Para descobrir quanto há de páginas disponíveis, verifique o arquivo /proc/meminfo:
[ćode lang="bash"]grep -i huge /proc/meminfo[/code]
O libvirt também tem que estar preparado para gerenciar domínios com hugepages. Para ativar este recurso, o arquivo /etc/libvirt/qemu.conf deverá conter a seguinte opção, sendo /dev/hugepages o caminho para acesso à hugepages (como mencionado no post anterior):
hugetlbfs_mount = "/dev/hugepages"
Feito isto, basta reinicializar o libvirtd para que as configurações tomei efeito e inicializar o domínio configurado. Verifique o uso das hugepages para confirmar seu uso.
-
hugepages
Estudando o sistema de gerenciamento de memória do Linux, encontrei um recurso interessante para uso mais eficiente de memória.Para ficar claro, explicarei brevemente como funciona o gerenciamento de memória do Linux.
Paginação
O Linux, na sua inicialização, verifica a quantidade de memória disponível e mapeia o endereçamento. Isto é feito pela MMU (Memory Management Unit) que atribui endereços virtuais para melhor gerenciamento. Assim é possível uso de swaping e transparência para os processos. Mais detalhes serão abordados em outro post.
Quando um processo faz uma requisição de memória ao Linux, este aloca o espaço solicitado em forma de páginas. As páginas, numa rápida analogia, é o mesmo que os blocos nas partições. Eles tem um cabeçalho e a área de dados propriamente dita. As páginas, em arquitetura x86, têm o tamanho de 4KB. Isto indica que quando precisamos de 12KB, o sistema aloca 3 páginas e entrega ao processo.
Hugepages
Este é um método bacana de estender as páginas para um tamanho maior. Como vimos, o Linux entrega páginas de tamanho fixo, e isso pode gerar um certo desperdício. Vejo isso em dois aspectos: overhead e uso real não múltiplo de 4.
Caso eu queira 10KB de memória, o sistema me entregará o maior múltiplo imediato para mim, ou seja, 12KB. Ou então, mesmo que eu use exatamente um múltiplo de 4, ao requisitar 120MB, terei 30720 páginas. Isso significa 30720 cabeçalhos, que mesmo que pequenos, representam uma perda.
Hugepages permite uso de páginas de 4MB em sistemas x86 de 32 bit e 2MB de 64bit. Assim, há um uso mais eficiente da memória quando é necessário um grande volume de memória. Outra característica também é que esse tipo de páginas não pode ser movida para a área swap.
Ativação e uso
Para tirar proveito desse tipo de paginação, é preciso que o kernel esteja preparado antes. Para isso, certifique que seu kernel tenha as seguintes opções ativadas:
CONFIG_HUGETLBFS=y CONFIG_HUGETLB_PAGE=y
Através do ‘make menuconfig’ vá em File Systems -> Pseudo filesystems -> HugeTLB file system support.
Depois de compilado e instalado o kernel, verifique se foi devidamente ativado:
grep -i huge /proc/meminfo HugePages_Total: 0 HugePages_Free: 0 HugePages_Rsvd: 0 HugePages_Surp: 0 Hugepagesize: 2048 kB
Se apareceu algo parecido com isso, agora só falta alocar as páginas. Para isto, é necessário que haja espaço contíguo disponível para a quantidade que será alocada. Desta forma, é mais interessante alocar logo na inicialização do sistema. Para isto, acrescente a seguinte linha no arquivo /etc/sysctl.conf:
vm.nr_hugepages=256
Isto dirá ao kernel na inicialização alocar 256 páginas de tamanho 2048KB (no meu sistema 64 bit), Assim totalizando 512MB (256 * 2048KB = 512MB). Para tomar efeito, será preciso reinicializar o sistema.
Depois de reinicializado, certifique que tudo correu bem:
grep -i huge /proc/meminfo HugePages_Total: 256 HugePages_Free: 256 HugePages_Rsvd: 0 HugePages_Surp: 0 Hugepagesize: 2048 kB
Veja que nenhuma página foi usada. Um processo que queira fazer isto, deverá requisitar explicitamente por hugepages. Para criar uma interface de acesso, é preciso montar uma pseudo partição hugetlb. Acrescente no seu fstab:
hugetlbfs /dev/hugepages hugetlbfs defaults 0 0
Como o diretório /dev/hugepages não existe, é preciso criá-lo também antes de montar.
Uma boa aplicação para isto são máquinas virtuais baseadas em KVM, como descreverá o próximo post.
-
Converter discos virtuais
Há uma diversidade de hypervisiors no mercado, e com isso, há também uma diversidade de formatos de discos virtuais (vdi, vmdk, qcow, raw…) e muitas precisamos portar uma para a outra.
Uma forma prática e fácil de converter imagens é usando o qemu-img. Este utilitário acompanha o pacote qemu-kvm, que pode ser baixado e usado livremente. Veja alguns exemplos para converter discos:
vdi -> qcow
qemu-img convert -f vdi -O qcow origem.img destino.img
vmdk -> qcow
qemu-img convert -f vmdk -O qcow origem.img destino.img
vmdk -> vdi
qemu-img convert -f vmdk -O vdi origem.img destino.img
qcow -> raw
qemu-img convert -f qcow -O raw origem.img destino.img
raw -> qcow2
qemu-img convert -f raw -O qcow2 origem.img destino.img
qcow2 -> volume lógico (já citado em “Convertendo arquivos de imagens em volumes lógicos“)
qemu-img convert -f qcow2 -O host_device origem.img /dev/logical/destino
No final de contas, essa brincadeira pode ser feita entre todos estes formatos: cow qcow vdi vmdk cloop dmg bochs vpc vvfat qcow2 parallels nbd host_cdrom host_floppy host_device raw tftp ftps ftp https http
Mais informações sempre podem ser encontradas no manual.
man qemu-img
-
libvirt e nested paging
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 */ -
VirtualBox e usb
O VirtualBox tem um recurso de acesso à dispositivos USB da máquina host, mas nem sempre é fácil usá-lo. No meu caso, o host é um Slackware 13.1 Linux. O problema é de permissão e simples de se resolver. No início, quando o sistema de arquivos USB (usbfs) é montado, ele normalmente coloca tudo para apenas o root ter controle. A mágica está em alterar isto, usando o grupo plugdev, que no Slackware é usado para dispositivos removíveis.
Primeiramente seu usuário deve estar no grupo. Adicione o usuário que vai usar o VirtualBox no grupo com o seguinte comando, no meu caso, usuário eduardo:usermod -a -G plugdev eduardo
Agora basta uma alteração no fstab. Acrescente a seguinte linha:
usbfs /proc/bus/usb usbfs devgid=83,devmode=660 0 0
Isso fará com que o sistema no início monte o usbfs sendo do grupo do plugdev também, e dando permissão de leitura e escrita para seus membros.
Para resolver isso rapidamente sem reinicializar o sistema, use o seguinte:
mount -o remount,devgid=83,devmode=660 /proc/bus/usb
-
libvirt e LVM2
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>
-
LVM2 Snapshot
Nessas ultimas semanas andei procurando por uma solução eficiente para backups de discos, se possível, usando imagens. Eis que conheço o recurso de snapshot do LVM2. Ele é bastante fácil de usar, mas, é lógico, você precisa de uma partição no seu disco do tipo LVM, tipo 8e.
Tendo isto em mãos, basta criar um grupo de volumes lógicos do tamanho desejado na nova partição LVM. Isso pode ser feito com o seguinte comando:
vgcreate logical /dev/sdb1
No meu caso, eu não especifiquei o tamanho máximo do grupo, portanto ele pega todo o espaço disponível em sdb1. A grosso modo, o grupo de volumes lógicos está para um disco físico assim como os volumes lógicos estão para as partições. A diferença é que a virtualização do disco permite um ambiente mais flexível e simples.
Com o grupo pronto, basta adicionar os volumes. Meu disco tem 80GB, e para teste vou gerar um volume de 10GB chamado teste no grupo logical:
lvcreate -L10G -n teste logical
Pronto! Agora pode verificar que existe um dispositivo de bloco criado em /dev/logical/teste. Ele representa o volume lógico. Ele se comporta como um dispositivo de bloco comum, e portanto, pode ser tratado como um. Para conseguir usar, esse volume precisa ser formatado. Eu costumo usar o raiserfs, mas pode ser usado ext3, ext4, xfs…
mkreiserfs /dev/logical/teste mount -t reiserfs /dev/logical/teste /mnt/tmp
O volume agora pode ser usado normalmente. É só acessar o ponto de montagem /mnt/tmp. Com o ambiente todo pronto, agora vamos ao que interessa, o snapshot. Assumindo que o volume está em plena produção, vamos simular uma situação de backup online, que é a aplicação mais óbvia que vejo neste recurso. Para melhor entendimento, vamos analisando os passos seguintes:
lvcreate -L 500M -s -n backup /dev/logical/teste
Isso fará com que seja criado um volume lógico de 500MB, de nome backup e tipo snapshot do volume já existente /dev/logical/teste. O tamanho do snapshot é claramente menor que o volume original, e isso não está errado. No momento em que o snaphot é criado, o sistema ‘congela’ o volume original para que possamos trabalhar com ele sem que haja alterações, e o tamanho do snapshot representa o volume de alterações que ele permitirá que o sistema em produção faça nesse volume sem que seja prejudicado. A grosso modo, é como se fosse um buffer de alterações, que são armazenadas sem serem efetivadas no volume original. Para aqueles que conhecem o sistema de arquivamento e hotbackup de SGBDs, é a mesma coisa.
Muitos dão exemplos de backups usando snapshots montando o volume snapshot e copiando os arquivos com cp, compactando com tar e gz, mas eu normalmente crio uma imagem completa com o dd. De qualquer forma, apresentarei ambos abaixo:
Tar e gz
mount -t reiserfs /dev/logical/backup /mnt/tmp0 tar cf ~/backup.tar.gz /mnt/tmp0
dd
dd if=/dev/logical/backup of=~/backup.img
Depois do backup, basta remover o snapshot que as alterações serão aplicadas.
lvremove -f /dev/logical/backup
Tags
- There was a problem connecting to Twitter, or no public messages were found.
Recentes
Estou lendo
Wish list
Blog
- Carlos Feichas
- Debugging Consultoria
- Fabiano Xavier
- Fábio Arezi
- Felipe Molina
- Lucas Catón
- Mateus Penha
- Tiago Mathidios
Lista de Links
- Asterisk Asterisk PBX
- Debugging Consultoria Debugging Consultoria
- LPI
- Slackbuilds Repositório Slackbuilds
- Slackware Site oficial Slackware
- Viva o Linux Comunidade Viva o Linux
- Voip-Info Wiki VoIP