Redundância de discos (RAID1) com Debian Squeeze (para sistemas em produção)

De Eriberto Wiki
Ir para: navegação, pesquisa
Twitter.png

by (C) João Eriberto Mota Filho <eriberto (a) eriberto pro br>

Artigo criado em: 13 de janeiro de 2011.

Última atualização: veja o rodapé desta página.

Tiny URL ou bit.ly: http://bit.ly/raid1_squeeze_producao



Este tutorial é destinado a quem possui algum sistema já em produção (com Debian Squeeze) e precisa implementar a redundância de dados entre dois HDs (RAID1).

O RAID1

RAID é a sigla de Redundant Array of Independent Drives ou agrupamento redundante de discos independentes. Há vários níveis de RAID, sendo que neste artigo nos interessa o nível um.

No nível um (RAID1), teremos que trabalhar com dois ou mais discos pois, quando um dado é enviado para gravação, na verdade, ele é escrito, ao mesmo tempo, em todos os discos envolvidos. Consideremos dois discos. Caso um dos dois discos falhe, o outro continuará a operar normalmente. Com isso, não teremos a perda de dados e nem da disponibilidade do sistema. Neste artigo trabalharemos com um par de discos.

Tendo em vista o atual baixo custo dos HDs, é extremamente indicado o uso de RAID1 em todos os ambientes, inclusive em casa.

O cenário deste artigo e as variações possíveis

Neste artigo utilizaremos um cenário onde teremos que espelhar um HD com duas partições: uma que contém a raiz do sistema e outra que contém o /home.

A clonagem das partições será um pouco complicada, pois o sistema já está em produção e cada partição já conterá dados. O problema é que se criaremos arrays RAID e associarmos as partições do sistema a esses arrays, os dados existentes nas referidas partições serão destruídos. Então, procedimentos especiais deverão ser adotados. Basicamente, seguiremos este roteiro:

  • Teremos, num primeiro momento, as partições do primeiro HD em utilização, mantendo o sistema no ar.
  • Serão criados os arrays e os mesmos conterão as partições do segundo HD.
  • Serão copiados todos os dados do primeiro HD para os arrays.
  • O sistema de boot será configurado para utilizar os arrays.
  • Será dado boot no sistema.
  • O primeiro HD, agora sem função, será inserido nos arrays como clone do segundo HD (os dados do primeiro HD serão sobrescritos!).
  • O RAID1 estará implementado com dois HD.
Exclamacao36.png Não haverá partição de swap, pois partimos do princípio que, atualmente, todos preferem trabalhar com swap em arquivo.

Há outras variações que poderão ser implementadas facilmente após o entendimento deste tutorial. Três delas:

  • A existência de uma única partição para todo o sistema, sendo esta espelhada.
  • A existência de muitas partições para todo o sistema, sendo todas espelhadas.
  • O espelhamento de apenas algumas partições do sistema, como a que contém o /home, por exemplo.
Exclamacao36.png É importante dizer que a partição que será espelho de outra deverá ter o exato tamanho da original (situação ideal) ou ser maior. Em consequência, se raciocinarmos com discos inteiros, um HD 250 GB poderá ser espelho de um outro de 200 GB.



Procedimentos iniciais

Para começar, instale o pacote mdadm, que é responsável pela administração do sistema de RAID e o pacote parted, que contém o comando partprobe, que será utilizado ao longo deste artigo. Precisaremos também do rsync para algumas operações.

# apt-get install mdadm parted rsync

Após o download dos arquivos necessários à instalação do mdadm, surgirá a uma janela denominada "Configurando mdadm". Nessa janela você terá que escolher uma opção para o funcionamento do RAID. No caso deste artigo, após ler as explicações existentes na tela, selecione all.

Exclamacao36.png Obs: MD é a sigla de Multiple Devices. Essa sigla será muito utilizada a partir de agora. Um exemplo disso é o dispositivo /dev/md0, que será criado adiante.

Considerando que o HD principal seja o /dev/sda e que o segundo HD já esteja disponível como /dev/sdb e, ainda, que /dev/sdb seja do mesmo tamanho ou maior que /dev/sda, utilizando o comando dd, copie o MBR do primeiro disco para o segundo, de forma que o esquema de particionamento permaneça o mesmo em ambos. Para isso, execute o comando:

# dd if=/dev/sda of=/dev/sdb bs=512 count=1

O resultado desta operação será similar a isto:

root@aquarius:~# dd if=/dev/sda of=/dev/sdb bs=512 count=1
1+0 registros de entrada
1+0 registros de saída
512 bytes (512 B) copiados, 0,00922317 s, 55,5 kB/s
Exclamacao36.png Lembre-se que você poderá adotar outros modelos de implementação, como espelhar apenas uma partição em um disco menor. Neste caso, o particionamento deverá ser feito manualmente, dispensando a cópia com o dd.

Com o comando partprobe, avise ao kernel sobre existência de uma nova tabela de particionamento em /dev/sdb:

# partprobe /dev/sdb

Para verificar se as tabelas de particionamento ficaram idênticas, utilize o comando fdisk:

# fdisk -l

O próximo passo será reiniciar a máquina para que os módulos de kernel RAID sejam carregados já a partir do boot. Para isso, execute:

# reboot

Depois que a máquina inicializar, faça login como root e verifique se os módulos foram carregados:

# lsmod | grep raid

O resultado deverá ser parecido com isto (poderá haver diferenças!):

root@aquarius:~# lsmod | grep raid
raid10                 17809  0 
raid456                44500  0 
async_raid6_recov       5170  1 raid456
async_pq                3479  2 raid456,async_raid6_recov
raid6_pq               77179  2 async_raid6_recov,async_pq
async_xor               2478  3 raid456,async_raid6_recov,async_pq
async_memcpy            1198  2 raid456,async_raid6_recov
async_tx                1734  5 raid456,async_raid6_recov,async_pq,async_xor,async_memcpy
raid1                  18431  0 
raid0                   5517  0 
md_mod                 73824  6 raid10,raid456,raid1,raid0,multipath,linear



Adequação das partições e ajuste da tabela de filesystems (/etc/fstab)

Para que o sistema RAID funcione, as partições dos discos deverão ser do tipo RAID Linux. Inicialmente, vamos alterar as partições de /dev/sda. Para tanto, emita o comando:

# fdisk /dev/sda

Dentro do ambiente do fdisk, pressione "p" e ENTER para ver o esquema de particionamento. Se você instalou o Debian corretamente, notará a presença do "ID System" como sendo "83 Linux". Deveremos mudar isso para "RAID Linux". Para tanto, pressione "t" e ENTER. Como número da partição, pressione "1" e ENTER. Como código da partição, pressione "fd" e ENTER. Para conferir, pressione "p" e ENTER. Você notará a midança do "ID System" para Detecção automática de RAID Linux. Faça o mesmo procedimento para a outra partição (/dev/sda2). No fim, salve e saia, pressionando "w" e ENTER.

Agora, uma vez alterada a identificação das partições de /dev/sda para RAID Linux, deveremos fazer o mesmo com as partições de /dev/sdb. Siga o mesmo procedimento mostrado anteriormente.

Como próximo passo, teremos que ajustar a tabela de filesystems. Edite o arquivo /etc/fstab e altere os discos referentes às partições para /dev/mdX. Se for o caso, altere também os filesystems para Ext4 (que é o filesystem que usaremos no RAID, a não ser que você prefira outro). No meu caso, o arquivo original era o seguinte:

# <file system> <mount point>   <type>  <options>       <dump>  <pass>
proc            /proc           proc    defaults        0       0

# / was on /dev/sda1 during installation
UUID=6bee7c7c-0287-4f11-bcf8-310aca6c1c5c /               ext4    errors=remount-ro 0       1

# /home was on /dev/sda2 during installation
UUID=a234e87e-64b2-4dc0-8771-0072cd824311 /home           ext4    defaults        0       2

/dev/scd0       /media/cdrom0   udf,iso9660 user,noauto     0       0

O arquivo final ficou assim:

# <file system> <mount point>   <type>  <options>       <dump>  <pass>
proc            /proc           proc    defaults        0       0

# / was on /dev/sda1 during installation
/dev/md0        /               ext4    errors=remount-ro 0       1

# /home was on /dev/sda2 during installation
/dev/md1        /home           ext4    defaults        0       2

/dev/scd0       /media/cdrom0   udf,iso9660 user,noauto     0       0



Clonagem da partição raiz

A partir de agora, teremos que criar um array RAID (/dev/md0) e associar a primeira partição do segundo HD (/dev/sdb1) a esse dispositivo RAID (/dev/md0). Depois disso, como só poderemos escrever em /dev/md0 (e não mais em /dev/sdb1), necessitaremos formatar /dev/md0 e, depois, copiar todos os dados de /dev/sda1 para /dev/md0 (que contém /dev/sdb1).

Para criar o array /dev/md0, associando o /dev/sdb1 ao mesmo, execute:

# mdadm -C /dev/md0 -l 1 -n 2 missing /dev/sdb1
Exclamacao36.png No comando anterior, dissemos que queremos criar o /dev/md0, nível 1 (RAID1), com dois dispositivos (que serão o /dev/sda1 e o /dev/sdb1). Como só iremos adicionar o /dev/sdb1 por enquanto, pois o /dev/sda1 possui o sistema e está em uso, teremos que usar a palavra missing, pois dissemos no comando que seriam adicionados dois dispositivos.

Depois de pressionar o ENTER no comando anterior, surgirá na tela:

mdadm: Note: this array has metadata at the start and
    may not be suitable as a boot device.  If you plan to
    store '/boot' on this device please ensure that
    your boot-loader understands md/v1.x metadata, or use
    --metadata=0.90
Continue creating array?

Responda à pergunta, pressionando a tecla "y" e ENTER. Como resultado, surgirá na tela:

mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md0 started.

Para ver o array criado, utilize o comando:

# cat /proc/mdstat

O resultado será:

Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10] 
md0 : active (auto-read-only) raid1 sdb1[1]
      19529656 blocks super 1.2 [2/1] [_U]
      
unused devices: <none>
Exclamacao36.png Observe que foi criado um dispositivo /dev/md0, funcionando como RAID1, e que o mesmo contém o /dev/sdb1.

O próximo passo será formatar o /dev/md0. Usarei o filesystem Ext4 com 0.5% de espaço reservado ao superusuário.

# mkfs.ext4 -m .5 /dev/md0

A seguir, deveremos montar o /dev/md0 em /mnt e copiar o conteúdo da partição raiz (exceto o /home). Para isso, utilizaremos o comando rsync, que permite excluir arquivos e diretórios de uma cópia. Então, inicialmente, monte o /dev/md0 em /mnt:

# mount /dev/md0 /mnt

Copie tudo da raiz para o /mnt, exceto o conteúdo do /home (que será colocado em outro array), o conteúdo do próprio /mnt (para evitar um loop infinito de sistema) e o conteúdo do /proc e do /sys (para evitar uma paralisação do sistema):

# rsync -av --exclude=/home/* --exclude=/mnt/* --exclude=/proc/* --exclude=/sys/* / /mnt
Exclamacao36.png Observe que o conteúdo de /proc e de /sys é virtual e estará disponível quando a máquina for reinicializada. O conteúdo de /home não foi copiado porque, no nosso exemplo, esse diretório está montado em outro filesystem e, no fim, pertencerá a /dev/md1.

Terminada a cópia, verifique se tudo está ok:

# ls /mnt

Desmonte o /dev/md0:

# umount /dev/md0



Clonagem da partição que contém o /home

Deveremos realizar o mesmo procedimento feito com a partição raiz, em relação à partição que contém o /home, gerando o conteúdo de /dev/md1.

Para criar o array /dev/md1, associado a /dev/sdb2, utilize o comando:

# mdadm -C /dev/md1 -l 1 -n 2 missing /dev/sdb2

Ao ser feita a pergunta Continue creating array?, responda "y" e ENTER. Depois, verifique se o /dev/md1 foi criado corretamente:

# cat /proc/mdstat

Formate o /dev/md1:

# mkfs.ext4 -m .5 /dev/md1

O próximo passo será copiar todo o conteúdo de /home para o /dev/md1. Assim sendo, monte o /dev/md1 em /mnt e faça a cópia de conteúdo:

# mount /dev/md1 /mnt
# rsync -av /home/* /mnt
Exclamacao36.png Note que por tratar-se da cópia de um diretório inteiro, sem restrições, poderia ter sido utilizado o comando cp (# cp -av /home/* /mnt). No entanto, é vantajosa a utilização do rsync, uma vez que se o conteúdo de /home for grande e se houver necessidade de parada, o reinício da cópia se dará a partir do mesmo ponto de parada (a não ser que algum arquivo tenha sido modificado e, neste caso, será copiado novamente).

Verifique se a cópia foi realizada corretamente:

# ls /mnt

Desmonte o dispositivo:

# umount /dev/md1

Por tratar-se de um servidor de rede que abre pontos de entrada na máquina, se não for precisar do rsync para qualquer tarefa no seu sistema, desinstale-o:

# apt-get purge rsync



Adequação do GRUB2 (primeira fase)

Agora, vamos ajustar o GRUB2 para que o mesmo passe a inicializar utilizando o RAID. Esta será apenas uma primeira fase pois, por enquanto, teremos que ajustar o GRUB "na mão". Em uma próxima fase, o próprio GRUB fará a sua configuração automaticamente (sem a intervenção do administrador).

O primeiro passo será incluir o esquema RAID no fim do seu arquivo de configuração (/etc/mdadm/mdadm.conf). O GRUB2 precisará das informações desse arquivo para gerar as suas configurações. Assim, para ver o esquema RAID atual, utilize o seguinte comando:

# mdadm -Es

No meu caso, o resultado foi o seguinte:

root@aquarius:~# mdadm -Es
ARRAY /dev/md/0 metadata=1.2 UUID=6175f273:408be534:1e1cc0e6:fa9bc239 name=aquarius:0
ARRAY /dev/md/1 metadata=1.2 UUID=c881bfca:9f246542:88ca694c:2272dbe3 name=aquarius:1

Para incluir o esquema RAID no fim do arquivo de configuração RAID (/etc/mdadm/mdadm.conf), utilize o comando:

# mdadm -Es >> /etc/mdadm/mdadm.conf

Verifique o resultado:

# cat /etc/mdadm/mdadm.conf

Agora, reconstrua o arquivo initrd, existente dentro do diretório /boot, que é necessário para a inicialização do sistema:

# update-initramfs -u

Edite o arquivo /boot/grub/grub.cfg faça algumas alterações necessárias. No meu caso, as linhas originais eram as seguintes:

### BEGIN /etc/grub.d/10_linux ###
menuentry 'Debian GNU/Linux, with Linux 2.6.32-5-amd64' --class debian --class gnu-linux --class gnu --class os {
        insmod part_msdos
        insmod ext2
        set root='(hd0,msdos1)'
        search --no-floppy --fs-uuid --set 8282c143-5b3f-4fed-8df8-4c63b61e8fcc
        echo    'Loading Linux 2.6.32-5-amd64 ...'
        linux   /boot/vmlinuz-2.6.32-5-amd64 root=UUID=8282c143-5b3f-4fed-8df8-4c63b61e8fcc ro  quiet
        echo    'Loading initial ramdisk ...'
        initrd  /boot/initrd.img-2.6.32-5-amd64
}

As linhas, depois de alteradas, ficaram assim (observe o que está em negrito):

### BEGIN /etc/grub.d/10_linux ###
menuentry 'Debian GNU/Linux, with Linux 2.6.32-5-amd64' --class debian --class gnu-linux --class gnu --class os {
        insmod raid
        insmod mdraid
        insmod ext2
        set root='(md/0)'
#        search --no-floppy --fs-uuid --set 8282c143-5b3f-4fed-8df8-4c63b61e8fcc
        echo    'Loading Linux 2.6.32-5-amd64 ...'
        linux   /boot/vmlinuz-2.6.32-5-amd64 root=/dev/md0 ro  quiet
        echo    'Loading initial ramdisk ...'
        initrd  /boot/initrd.img-2.6.32-5-amd64
}

Depois de alterar a configuração do GRUB, reinicie a máquina:

# reboot

Reiniciada a máquina, faça login como root e utilize o comando # df -h para verificar se tudo deu certo. No meu caso, ficou assim:

root@aquarius:~# df -h
Sist. Arq.            Size  Used Avail Use% Montado em
/dev/md0               19G  2,6G   15G  15% /
tmpfs                 980M     0  980M   0% /lib/init/rw
udev                  975M  160K  975M   1% /dev
tmpfs                 980M     0  980M   0% /dev/shm
/dev/md1               46G  180M   46G   1% /home

Uma vez que o sistema passou a utilizar o /dev/md0 no lugar do /dev/sda1 como raiz, necessitamos refazer a operação para incluir o esquema RAID no fim do arquivo de configuração RAID (/etc/mdadm/mdadm.conf), uma vez que esse arquivo ainda não havia sido alterado. Para isso, utilize o comando:

# mdadm -Es >> /etc/mdadm/mdadm.conf

Verifique se o arquivo de configuração recebeu as informações sobre o RAID:

# cat /etc/mdadm/mdadm.conf



Sincronização das partições do primeiro HD

Uma vez reiniciado o sistema, estaremos utilizando o /dev/md0 e o /dev/md1 que, na verdade, correspondem a /dev/sdb1 e a /dev/sdb2 (só esses, por enquato). Assim sendo, o disco /dev/sda não está mais em uso. Com isso, poderemos inserir as suas partições nos arrays (/dev/md0 e /dev/md1). Quando fizermos isso, todo o conteúdo das partições de /dev/sda será apagado, pois tais partições serão espelhos das existentes em /dev/sdb.

Para fazer com que as partições de /dev/sda entrem nos arrays e sejam espelhos das partições existentes em /dev/sdb, utilize os comandos:

# mdadm -a /dev/md0 /dev/sda1
# mdadm -a /dev/md1 /dev/sda2

A seguir, caso deseje acompanhar a sincronização de discos, utilize o comando:

# watch -n 1 cat /proc/mdstat

Com o comando anterior, você verá algo como isto:

Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md0 : active raid1 sda1[2] sdb1[1]
      19529656 blocks super 1.2 [2/1] [_U]
      [===>.................]  recovery = 17.9% (3496128/19529656) finish=4.0min speed=65466K/sec

md1 : active raid1 sda2[2] sdb2[1]
      48827320 blocks super 1.2 [2/1] [_U]
        resync=DELAYED

unused devices: <none>

Observe que o md1 está com a sua sincronização marcada como DELAYED (atrasada). Isso ocorreu porque o sistema irá sincronizar o md0 primeiro. Sincronizações simultâneas gerariam uma notável queda de performance.

Adequação do GRUB2 (segunda fase)

Não há a necessidade de esperar o término da sincronição para executar esta fase. Simplesmente, atualize a configuração do GRUB, reconstruindo o seu arquivo de configuração de forma automática pelo sistema:

# update-grub
Exclamacao36.png Caso você conheça um pouco a estrutura do GRUB, analise o arquivo /boot/grub/grub.cfg e notará as mudanças que englobam o RAID e que foram feitas automaticamente pelo comando # update-grub.

Agora, instale o novo GRUB no MBR dos dois HDs:

# grub-install /dev/sda
# grub-install /dev/sdb
Exclamacao36.png Não entendeu por que foi instalado o GRUB nos dois HDs? A explicação é simples. O RAID está espelhando somente as partições e não os MBRs. Assim sendo, deixamos os dois HDs em condições de realizar boot.

Por fim, reinicie a máquina para que a mesma passe a utilizar definitivamente o RAID:

# reboot

Depois de reiniciada a máquina, faça login como root e utilize o comando # df -h para verificar se o sistema continua usando RAID. Um exemplo:

root@aquarius:~# df -h
Sist. Arq.            Size  Used Avail Use% Montado em
/dev/md0               19G  2,6G   15G  15% /
tmpfs                 980M     0  980M   0% /lib/init/rw
udev                  975M  160K  975M   1% /dev
tmpfs                 980M     0  980M   0% /dev/shm
/dev/md1               46G  180M   46G   1% /home
Exclamacao36.png A partir deste ponto, sempre que for necessário, o sistema terá condições de reescrever a configuração do GRUB por si só, ou seja, não haverá mais a necessidade de intervenção humana.



Teste de funcionamento

Inicialmente, tenha a certeza de que os dois discos foram sincronizados. Para isso, emita o comando:

# cat /proc/mdstat

O resultado deverá ser similar ao seguinte:

root@aquarius:~# cat /proc/mdstat 
Personalities : [raid1] 
md1 : active raid1 sda2[2] sdb2[1]
      48827320 blocks super 1.2 [2/2] [UU]
      
md0 : active raid1 sda1[2] sdb1[1]
      19529656 blocks super 1.2 [2/2] [UU]
      
unused devices: <none>

Observe que não está ocorrendo nenhuma sincronização neste momento. A duplas de "U" mostram que as duas partições de cada array estão sincronizadas. Exemplo:

md1 : active raid1 sda2[2] sdb2[1]
      48827320 blocks super 1.2 [2/2] [UU]

Neste caso, o array md1 está em RAID1 e possui as partições sda2 (o [2] indica que trata-se da partição secundária) e sdb2 (o [1] indica que é primária). Ainda, as duas estão sincronizadas (UU).

Para testar o funcionamento do RAID, primeiro crie algum arquivo em algum diretório (sugiro o /root), com a palavra teste no seu interior. A seguir, abra a máquina e, com cuidado, remova o cabo de energia de um dos dois HDs. Provavelmente, você deve estar utilizando HD SATA. Nesse caso, o cabo de energia será o que tiver o conector maior. Veja:


Hd sata.jpg


Exclamacao36.png ATENÇÃO! A operação de remoção do cabo de energia para teste deverá ser feita com cuidado. Não execute esta operação se não souber o que está fazendo. Remover o cabo de energia não provoca danos ao material. No entanto, nunca remova o cabo de dados se o de energia estiver ligado.

Uma vez removido o cabo de energia de um dos HDs, surgirá na tela algo similar a isto:

[ 3711.022708] ata1: exception Emask 0x10 SAct 0x0 SErr 0x4010000 action 0xe frozen
[ 3711.022803] ata1: SError: { PHYRdyChg DevExch }
[ 3722.384088] sd 0:0:0:0: rejecting I/O to offline device
[ 3722.384145] end_request: I/O error, dev sda, sector 2056
[ 3722.384195] raid1: Disk failure on sda1, disabling device.
[ 3722.384196] raid1: Operation continuing on 1 devices.

Observe, em especial, as duas últimas linhas:

[ 3722.384195] raid1: Disk failure on sda1, disabling device.
[ 3722.384196] raid1: Operation continuing on 1 devices.

Elas dizem que houve uma falha em sda1 e que o RAID1 continuará no ar, usando apenas um disco. Assim sendo, como teste, continue operando o computador normalmente e procure pelo arquivo que você criou. Agora, emita o comando:

# cat /proc/mdstat

No meu caso, o resultado foi o seguinte:

root@aquarius:~# cat /proc/mdstat 
Personalities : [raid1] 
md1 : active raid1 sda2[2] sdb2[1]
      48827320 blocks super 1.2 [2/2] [UU]
      
md0 : active raid1 sda1[2](F) sdb1[1]
      19529656 blocks super 1.2 [2/1] [_U]
      
unused devices: <none>

Note que o md0 está com um disco em falha, fato este simbolizado por (F). O array md1 mostra que não há falhas. Isso nem sempre irá acontecer. No meu caso, ocorreu porque ainda não tinha havido uma tentativa de acesso ao /home. No entanto, provocando uma reação do sistema (após criarmos um arquivo, manualmente, em /home), teremos o seguinte resultado:

root@aquarius:~# cat /proc/mdstat 
Personalities : [raid1] 
md1 : active raid1 sda2[2](F) sdb2[1]
      48827320 blocks super 1.2 [2/1] [_U]
      
md0 : active raid1 sda1[2](F) sdb1[1]
      19529656 blocks super 1.2 [2/1] [_U]
      
unused devices: <none>

Fica claro que houve pane. Ainda, olhe o conteúdo do log /var/log/syslog. Lá também haverá um registro sobre tudo o que ocorreu.

A troca de um disco danificado

Para trocar um disco danificado, deveremos seguir alguns passos simples. Inicialmente, desligue a máquina e coloque um outro HD pois, em um caso real, estaremos colocando um novo HD na máquina, que deverá ter o mesmo tamanho ou ser maior que o HD que estava funcionando antes. Também é necessário desligar a máquina para que o HD não seja reconhecido como um novo dispositivo, recebendo um nome como /dev/sdc, por exemplo.


Caso você pretenda usar o mesmo disco como teste, você deverá excluir o seu MBR para que tal disco não seja mais reconhecido, uma vez que o mesmo já possui um esquema RAID ativo. Utilize o comando dd para "matar" o MBR existente no disco. Exemplo: # dd if=/dev/zero of=/dev/sda bs=512 count=1.


Uma vez reiniciada a máquina, verifique novamente a situação dos arrays:

# cat /proc/mdstat

No meu caso, o resultado foi:

root@aquarius:~# cat /proc/mdstat 
Personalities : [raid1] 
md1 : active raid1 sdb2[1]
      48827320 blocks super 1.2 [2/1] [_U]
      
md0 : active raid1 sdb1[1]
      19529656 blocks super 1.2 [2/1] [_U]
      
unused devices: <none>

Depois, com o comando dd, copie o MBR do HD que está funcionando para o novo HD. No meu caso, a cópia será de /dev/sdb para /dev/sda. Cuidado para não errar essa operação. Exemplo:

# dd if=/dev/sdb of=/dev/sda bs=512 count=1

Com o comando partprobe, avise ao kernel sobre a alteração da tabela de particionamento:

# partprobe /dev/sda

A seguir, inclua os /dev/sdaX nos arrays. Exemplo:

# mdadm -a /dev/md0 /dev/sda1
# mdadm -a /dev/md1 /dev/sda2

Assim como foi feito antes, observe a sincronização de dados com o comando a seguir:

# watch -n 1 cat /proc/mdstat

Pronto! Estão recuperados todos os arrays.

Alertas via e-mail

O sistema de monitoramento do RAID no Debian pode enviar e-mails avisando sobre pane em discos ou outros eventos importantes. A configuração desse recurso é simples.

Inicialmente, instale o sendmail ou outro MTA da sua preferência.

# apt-get install sendmail-bin sendmail

Como próximo passo, edite o arquivo /etc/mdadm/mdadm.conf e, na linha iniciada por MAILADDR, remova a palavra root e insira o seu endereço de e-mail. A seguir, recarregue o monitor RAID, fazendo-o ler as novas configurações:

# /etc/init.d/mdadm reload

Está configurado o alerta via e-mail.

Comandos em situações diversas

A partir deste ponto, veremos alguns comandos úteis para o dia-a-dia de quem mantém um sistema RAID1.

Detalhes sobre um array

Os detalhes sobre um array poderão ser obtidos com a chave "-D". Exemplo:

# mdadm -D /dev/md0

Um exemplo de saída:

root@aquarius:~# mdadm -D /dev/md0
/dev/md0:
        Version : 1.2
  Creation Time : Tue Jan 18 17:22:19 2011
     Raid Level : raid1
     Array Size : 19529656 (18.62 GiB 20.00 GB)
  Used Dev Size : 19529656 (18.62 GiB 20.00 GB)
   Raid Devices : 3
  Total Devices : 3
    Persistence : Superblock is persistent

    Update Time : Wed Jan 19 17:06:21 2011
          State : clean
 Active Devices : 3
Working Devices : 3
 Failed Devices : 0
  Spare Devices : 0

           Name : aquarius:0  (local to host aquarius)
           UUID : 6175f273:408be534:1e1cc0e6:fa9bc239
         Events : 1314

    Number   Major   Minor   RaidDevice State
       2       8        1        0      active sync   /dev/sda1
       1       8       17        1      active sync   /dev/sdb1

Detalhes sobre uma partição de disco pertencente a um array

Os detalhes sobre uma partição poderão ser obtidos com a chave "-E". Exemplo:

# mdadm -E /dev/sda2

Um exemplo de saída:

root@aquarius:~# mdadm -E /dev/sda2
/dev/sda2:
          Magic : a92b4efc
        Version : 1.2
    Feature Map : 0x0
     Array UUID : c881bfca:9f246542:88ca694c:2272dbe3
           Name : aquarius:1  (local to host aquarius)
  Creation Time : Tue Jan 18 17:35:07 2011
     Raid Level : raid1
   Raid Devices : 2

 Avail Dev Size : 97654784 (46.57 GiB 50.00 GB)
     Array Size : 97654640 (46.57 GiB 50.00 GB)
  Used Dev Size : 97654640 (46.57 GiB 50.00 GB)
    Data Offset : 2048 sectors
   Super Offset : 8 sectors
          State : clean
    Device UUID : 3dc67bda:b36bd93a:5c1c873b:35e0821d

    Update Time : Wed Jan 19 15:01:54 2011
       Checksum : cff1ab4e - correct
         Events : 324


   Device Role : Active device 0
   Array State : AA ('A' == active, '.' == missing)

Remoção de uma partição de disco de um array

Para remover um disco de um array, primeiro deveremos decretar uma falha em tal disco para depois retirá-lo. O comando para decretar falha é (exemplo para /dev/sdb):

# mdadm -f /dev/md0 /dev/sdb1

Espere alguns segundos (20 ou 30) para que o sistema trate definitivamente o /dev/sdb1 como falho. Depois, remova-o:

# mdadm -r /dev/md0 /dev/sdb1

Pode ser que o sistema exiba a seguinte mensagem de erro:

mdadm: hot remove failed for /dev/sdb1: Device or resource busy

Neste caso, pode ser que o sistema ainda não tenha "decretado" falha por não ter tido ainda a necessidade de gravar algum dado no disco. Assim, para acelerar o processo, crie um arquivo de teste em um diretório que pertença ao array que contém o disco falho e espere 20 ou 30 segundos. Tente remover a partição novamente e deverá dar certo.

Remoção de um array

Para remover um array, você deverá desmontá-lo (a partir do seu dispositivo ou do ponto de montagem), parar o mesmo e, depois, desfazer a ligação com o RAID em cada partição. Vamos a um exemplo com o array /dev/md1. Primeiro, desmonte o array:

# umount /dev/md1

A seguir, pare-o (stop):

# mdadm -S /dev/md1

Desfaça a ligação de /dev/sda2 e de /dev/sdb2 com o RAID. Para isso, destrua a área de controle existente em cada um deles:

# mdadm --zero-superblock /dev/sda2
# mdadm --zero-superblock /dev/sdb2

Para ver o resultado, utilize o comando a seguir:

# cat /proc/mdstat

Por fim, edite o arquivo /etc/mdadm/mdadm.conf e remova a entrada referente ao array excluído.

Adicionar mais discos ao RAID

Por algum motivo, pode ser que você queira adicionar mais discos ao seu sistema RAID. Isso poderá ser feito para espelhar por completo outro disco ou apenas para uma partição. Neste exemplo, vamos adicionar um disco inteiro (que deverá ter tamanho igual ou maior que os já existentes).

Depois de adicionar fisicamente o HD na máquina (que trataremos como /dev/sdc), copie para este o MBR do /dev/sda ou do /dev/sdb:

# dd if=/dev/sda of=/dev/sdc bs=512 count=1

Com o comando partprobe, avise ao kernel sobre a alteração do particionamento:

# partprobe /dev/sdc

A seguir, aumente, de dois para três, a quantidade de dispositivos em cada array:

# mdadm -G /dev/md0 -n 3
# mdadm -G /dev/md1 -n 3

Por fim, adicione cada partição de /dev/sdc ao respectivo array:

# mdadm -a /dev/md0 /dev/sdc1
# mdadm -a /dev/md1 /dev/sdc2

Se quiser, acompanhe a sincronização com o comando:

# watch -n 1 cat /proc/mdstat



Comentários, sugestões e controle de acessos

Por favor, deixe os seus comentários e sugestões sobre este artigo no meu Blog Técnico. Para isto, clique aqui.


bit.ly-raid1_squeeze_producao-thumb.jpg

Consulte também o contador abaixo, iniciado em 13 jan. 11.
Twitter: Para novidades sobre artigos, livros e palestras, siga-me em eribertomota.