Aviso:

Este artigo foi feito para meu próprio uso. Tentei resolver um problema que estava enfrentando na empresa e encontrei esta solução depois de muito pesquisar, testar e errar, logo, qualquer discordância ou sugestão em relação aos procedimentos aqui descritos podem ser enviados para Este endereço de e-mail está protegido contra spambots. Você deve habilitar o JavaScript para visualizá-lo. .

“A preguiça é a mãe de todas as invenções”

Para a felicidade da equipe de suporte da empresa em que trabalho, todas as máquinas são padronizadas (mesma marca, apenas com algumas variações de modelo), o que nos facilita muito no momento de prepará-las para o uso. Veja as etapas da preparação (provavelmente deve ser muito comum a todos os profissionais que trabalham com suporte):

São tarefas que, depois de algumas execuções, tornam-se extremamente frustrantes para qualquer técnico. Imagine preparar 200 computadores manualmente. Pensando em pular algumas etapas, utilizamos um recurso muito comum entre assistências técnicas: imagens de disco.

As imagens são arquivos que contêm todo o conteúdo dos discos de origem. Elas podem ser armazenadas em CDs, pendrives e nas mais diversas mídias. Com o uso dessas imagens, o trabalho de repetição da instalação passa a ser apenas o trabalho de cópia dos arquivos de imagem para os HDs.

Em nosso caso, utilizamos o software Symantec Norton Ghost, que faz exatamente o que precisamos: cria imagens do disco em arquivos para que possamos copiá-las em outros discos, criando assim uma réplica da máquina de origem.

É nesse ponto que a preguiça entra: para criar a imagem de uma máquina, é necessário retirar o seu disco rígido, colocá-lo na máquina em que está instalado o programa, fazer a imagem, colocar o disco da máquina que queremos restaurar e fazer o procedimento de restauração.

Até certo ponto, o processo não é tão demorado e nem envolve tantas etapas. Analisando detalhadamente, são economizadas muitas horas de trabalho deste modo, mas ainda temos o inconveniente do processo físico envolvido: ter que abrir a máquina, retirar peças e recolocá-las.

A solução que proponho acaba com a necessidade de abertura do computador: temos um pendrive com um sistema operacional que, ao ser iniciado, tenha um menu com as opções para criação e restauração de imagens, gravando e restaurando os discos através da rede.

É bem provável que neste ponto muitos digam: “Mas o Norton Ghost tem um recurso que permite a criação de imagens pela rede”, e é verdade, ele possui mesmo, mas o Norton Ghost é um software pago, que exige uma licença de uso e sua configuração não é das mais fáceis.

Utilizaremos o PartImage para a tarefa de criação e restauração das imagens e NFS para o acesso nas pastas do servidor pela rede. Abaixo, listarei os softwares utilizados neste procedimento:

• Uma máquina com Debian 5 (pode ser qualquer distribuição Linux, desde que o NFS esteja configurado)
• ISO do Slax 6.1.2 (este foi o linux live que eu mais achei interessante, pois todas as alterações feitas podem ser salvas no próprio pendrive)
• LinuxLive USB Creator 2.4

Configuração do servidor

Obs.: É necessário que você tenha uma máquina com linux já instalado para os procedimentos a seguir.

Instalar o NFS e o partimage no servidor (no caso do Debian ou variantes)

#apt-get install portmap nfs-kernel-server nfs-common partimage

Definir um diretório para a cópia dos arquivos de imagem, editando o arquivo /ect/exports

#vim /etc/exports

Adicione a linha ao final do arquivo

/ghost 192.168.0.99(rw)

Onde:

/ghost – endereço da pasta onde serão criadas as imagens

192.168.0.99 – máquina (ou máquinas) da rede que pode(m) acessar o compartilhamento 

(rw) – permissão de gravação

Exporte a pasta ou reinicie o serviço

#exportfs -a

Ou

#/etc/init.d/nfs-kernel-server

Dê permissão de gravação na pasta /ghost

#chmod –R 777 /ghost

A etapa de configuração do servidor está concluída.

Preparação do pendrive

Baixe o Slax no site: http://www.slax.org (200MB)

Baixe o Linux Live USB Creator no endereço: http://www.linuxliveusb.com/ (2,3MB)

Descompacte e abra o programa:

Coloque o pendrive na porta USB e selecione-o em “PASSO 1 – ESCOLHER UMA PENDRIVE”:

Aguarde a leitura do arquivo ISO:

Selecione a opção “Formate o pendrive em FAT32(isto apagará seus dados!!)” e clique no símbolo do “RAIO”:

Confirme a mensagem que aparecer:

Com o pendrive pronto, faça o teste de boot em um computador, colocando-o na porta USB, reiniciando e apertando F12 (na maioria dos computadores) na inicialização para exibir o menu de BOOT da BIOS, selecione o pendrive e entre no Slax:

Após verificar que seu pendrive está funcionando corretamente, vamos para a configuração final do nosso processo. Reinicie a máquina e entre no sistema operacional.

Baixe os módulos que serão necessários para o Slax no site http://www.slax.org

• nfs-utils-4 – O client NFS para o Slax
• partimage-0.6.7-i486-2lu – O programa para criação e restauração das imagens
• libnewt0.52-0.52.10-5-b1 – Biblioteca necessária ao partimage

Copie os arquivos para o pendrive, no caminho:

“Unidade do Pendrive”:\slax\modules

Edite o arquivo slax.cfg no caminho:

“Unidade do Pendrive”:\boot\slax.cfg

Altere a linha

APPEND initrd=/boot/initrd.gz ramdisk_size=6666 root=/dev/ram0 rw autoexec=xconf;telinit~4 changes=/slax/

Para

APPEND initrd=/boot/initrd.gz ramdisk_size=6666 root=/dev/ram0 rw autoexec=xconf;telinit~2 changes=/slax/

Isto fará com que seu Slax não inicie a interface gráfica, iniciando em runlevel 2.

Crie um arquivo na raiz do pendrive com o nome de imagem.sh, edite esse arquivo em seu editor de textos favorito e digite o seguinte conteúdo:

#!/bin/bash

#########################################################################

#Script para criação e restauração de imagens utilizando Partimage e acesso NFS

#########################################################################

#               Criado por Douglas Jean Baiocco Morgan em 28/05/2010            #

#                              www.thepolux.com.br                              #

#########################################################################

#########################################################################

#Carrega o layout de teclado padrão ABNT2

#########################################################################

loadkeys br-abnt2.map

#########################################################################

#Cria a variável rede, que será utilizada para identificar em qual device a placa foi reconhecida.

#########################################################################

rede=`ifconfig | grep -o eth0`

#########################################################################

#Mostra uma primeira mensagem de boas vindas

#########################################################################

dialog --msgbox "Seja bem vindo ao criador de imagens da XXXX\n\nVoce podera criar ou recuperar hds com este software\n\nCertifique-se de que todos os dados foram salvos e aperte enter para continuar" 300 300

#########################################################################

#se a placa de rede encontrada estiver no device eth0, este ponto irá mostrar a mensagem correspondente

#########################################################################

if [ -e $rede ]

then

dialog --msgbox "Placa de rede detectada em eth1" 300 300

rede="eth1"

else

dialog --msgbox "Placa de rede detectada em eth0" 300 300

rede="eth0"

fi

#########################################################################

#configura um ip para a interface de rede

#########################################################################

ifconfig $rede 192.168.0.99 netmask 255.255.255.0 up

#########################################################################

#cria a pasta /ghost

#########################################################################

mkdir /ghost 2>/dev/null

#########################################################################

#monta a pasta remota do servidor na pasta local /ghost

#########################################################################

mount.nfs 192.168.0.1:/ghost /ghost -o nolock

#########################################################################

#Monta o menu para que o usuário escolha o que deseja fazer e atribui o resultado a variável resposta

#########################################################################

resposta=$(dialog --stdout --menu "O que vc deseja fazer?" 300 300 6 1 "Criar uma imagem" 2 "Restaurar uma imagem" 3 "Particionar o Disco")

#########################################################################

#caso a resposta seja a primeira opção

#########################################################################

if [ $resposta -eq 1 ]

then

x=0

valor=0

#########################################################################

#acessa o arquivo /proc/partitions e cria um loop for para todas as entradas deste arquivo que sejam partições de disco

#########################################################################

for linhas in `cat /proc/partitions | grep -v loop | grep -v maj| cut -b23-40 | grep -v ^$`

do

tamanho=`cat /proc/partitions | grep -w $linhas | cut -b11-21`

tamanho=`expr $tamanho / 1024 / 1024`

tamanho_linhas=${#linhas}

if [ $tamanho_linhas -eq 4 ]

then

if [ $tamanho -ne 0 ]

then

checklist=/dev/$linhas" "$tamanho"GB "$checklist

let x++

fi

fi

done

origem=$(dialog --stdout --menu "Escolha a particao que será feito a imagem" 300 300 $x $checklist)

destino=$(dialog --stdout --inputbox "Digite o nome da imagem a ser criada" 300 300)

#########################################################################

#desmonta a partição selecionada (caso esteja montada)

#########################################################################

umount $origem

#########################################################################

#comando para a criação da imagem

#########################################################################

partimage -d -o -z1 -f2 -b save $origem /ghost/$destino

fi

#########################################################################

#caso a resposta seja a segunda opção

#########################################################################

if [ $resposta -eq 2 ]

then

x=0

#########################################################################

#laço for para listar as imagens disponíveis em /ghost

#########################################################################

for linhas in `ls /ghost/ | grep 000`

do

#########################################################################

#criar a variável para alimentar a caixa de mensagem

#########################################################################

checklist=$linhas" "$x" "$checklist

let x++

done

#########################################################################

#mensagem com a lista de arquivos em /ghost

#########################################################################

destino=$(dialog --stdout --menu "Escolha a imagem que vc quer restaurar" 300 300 6 $checklist)

x=0

valor=0

#########################################################################

#laço for para criar a lista de partições disponíveis no computador

#########################################################################

for linhas in `cat /proc/partitions | grep -v loop | grep -v maj| cut -b23-40 | grep -v ^$`

do

tamanho=`cat /proc/partitions | grep -w $linhas | cut -b11-21`

tamanho=`expr $tamanho / 1024 / 1024`

tamanho_linhas=${#linhas}

if [ $tamanho_linhas -eq 4 ]

then

if [ $tamanho -ne 0 ]

then

checklist=/dev/$linhas" "$tamanho"GB "$checklist

let x++

fi

fi

done

origem=$(dialog --stdout --menu "Escolha a particao que será feito a imagem" 300 300 $x $checklist)

umount $origem

#########################################################################

#comando para restaurar a imagem na partição selecionada

#########################################################################

partimage -b restore $origem /ghost/$destino

fi

if [ $resposta -eq 3 ]

then

cfdisk

fi

Volte a inicializar a máquina com o pendrive:

Na tela de login, digite root para o usuário e toor para a senha:

Após o boot, converta o arquivo imagem.sh para dentro do diretório /:

#cat /mnt/sdb1/imagen.sh | tr -d '\r' > /imagen.sh

Onde sdb1 é a unidade montada do pendrive (verifique com um #ls /mnt/sdb1  se é esta mesmo)

Dê permissão de execução

#chmod +x /imagem.sh

Adicione ao rc.local uma chamada para o arquivo. Ele será executado na inicialização do Slax

#echo sh /imagem.sh >> /etc/rc.d/rc.local

Pronto! Agora inicie a máquina com o pendrive e veja a facilidade em criar e restaurar imagens.

Considerações finais

A decisão em usar o NFS para a gravação em rede teve um motivo muito simples: eu não consegui fazer com que o Partimage conectasse ao servidor (e não foi por falta de tentativa) então, utilizei esta opção, que me pareceu interessante. É claro que podemos aprimorar algumas coisas em relação à segurança dos dados, mas a grosso modo, este método é funcional.

O Slax foi o Linux Live que mais facilmente foi configurado e instalado no pendrive, dentre as versões que testei (e não foram poucas).

Fique atento também para um ponto: as máquinas envolvidas devem estar em rede!!!