Imagem de HD pela rede usando um pendrive e o Partimage

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):

• Instalação do sistema operacional;

• Instalação dos drivers de dispositivos;

• Instalação dos programas padrões (Acrobat Reader, Anti-virus, etc) ;

• Instalação dos programas para uso na empresa (ERP, ferramentas de produtividade, etc);

• Configuração das informações dos usuários (Configurar conta de e-mail, atalhos da área de trabalho, etc).

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)

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

Adicione a linha ao final do arquivo

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

Ou

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

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

Preparação do pendrive

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

Baixe o Linux Live USB Creator no endereço: https://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”

Após isso, clique em ISO / IMG / ZIP e escolha o local onde está localizada a imagem do Slax.

Aguarde a leitura do arquivo ISO.

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

Confirme a mensagem:

Aguarde a conclusão do programa.

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 https://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”:slaxmodules

Edite o arquivo slax.cfg no caminho:

Altere a linha

Para

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 XXXXnnVoce 
podera criar ou recuperar hds com este softwarennCertifique-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 de origem" 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 de origem" 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 /:

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

Dê permissão de execução

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

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). E, antes tarde do que nunca: as máquinas envolvidas devem estar em rede! 🙂

Nota: Este artigo foi feito para meu próprio uso, resolvendo um problema que estava enfrentando. Qualquer discordância ou sugestão em relação aos procedimentos aqui descritos podem ser enviados para douglasbaiocco@uol.com.br.

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

Por Douglas Baiocco <douglasbaiocco [at] uol.com.br> – https://www.thepolux.com.br