Redundância de discos (RAID1) com Debian Squeeze (para sistemas em produção)
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.
|
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.
|
|
É 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.
|
|
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
|
|
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
|
|
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>
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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:
|
|
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
Redes sociais
- Twitter: Para novidades sobre artigos, livros e palestras, siga-me em eribertomota.