Exibir código-fonte para Redundância de discos (RAID1) com Debian Squeeze (para sistemas em produção)

{{cabeçalho|13 de janeiro de 2011|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'''.
<br><br>

== 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.

{{exclamação1|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.

{{exclamação1|É 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.}} 
<br><br>

== 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''.

{{exclamação1|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

{{exclamação1|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
<br><br>

== 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
<br><br>

== 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

{{exclamação1|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>

{{exclamação1|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

{{exclamação1|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
<br><br>

== 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

{{exclamação1|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
<br><br>

== 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 {
         <big>'''insmod raid'''</big>
         <big>'''insmod mdraid'''</big>
         insmod ext2
         <big>'''set root='(md/0)''''</big>
 <big>'''#        search --no-floppy --fs-uuid --set 8282c143-5b3f-4fed-8df8-4c63b61e8fcc'''</big>
         echo    'Loading Linux 2.6.32-5-amd64 ...'
         <big>'''linux   /boot/vmlinuz-2.6.32-5-amd64 root=/dev/md0 ro  quiet'''</big>
         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
<br><br>

== 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.
<br><br>

== 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

{{exclamação1|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

{{exclamação1|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

{{exclamação1|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.}}
<br><br>

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


[[image:Hd_sata.jpg|center]]


{{exclamação1|'''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.
<br><br>

== 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. 
<br><br>

== 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.
<br><br>

== 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
<br><br>
{{rodapé|http://www2.clustrmaps.com/user/9abcc756|http://www2.clustrmaps.com/stats/maps-no_clusters/bit.ly-raid1_squeeze_producao-thumb.jpg|13 jan. 11}}