Redundância de discos (RAID1) com Debian Squeeze (para sistemas em produção): mudanças entre as edições
Linha 456: | Linha 456: | ||
Está configurado o alerta via e-mail. | Está configurado o alerta via e-mail. | ||
<br><br> | <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 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 | |||
Por último, 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 | |||
==== 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 | |||
== Controle de acessos == | == Controle de acessos == |
Edição das 12h04min de 19 de janeiro de 2011
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 pares de disco pois, quando um dado é enviado para o disco, na verdade, ele é escrito, ao mesmo tempo, nos 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 apenas 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 criaremos arrays RAID e associaremos as partições do sistema a esses arrays. Mas, aos fazermos isso, os dados existentes nas 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 seu dados serão sobrescritos!).
- O RAID1 estará implementado.
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 várias 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.
Procedimentos iniciais
Inicialmente, instale o pacote mdadm, que é responsável pela administração do sistema de RAID:
# apt-get install mdadm
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 ou se não souber o que escolher, 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 os dois discos sejam exatamente do mesmo tamanho, utilizando o comando dd, clone 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
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 RAID sejam carregados e para que o sistema operacional reconheceça o novo esquema de particionamento do segundo HD. Para isso, execute:
# reboot
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 apenas as partições de /dev/sdb. Para tanto, emita o comando:
# fdisk /dev/sdb
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. Faça o mesmo procedimento para a outra partição (/dev/sdb2). No fim, salve e saia, pressionando "w" e ENTER.
Agora, uma vez alterada a identificação das partições de /dev/sdb para RAID Linux, deveremos fazer o mesmo com as partições de /dev/sda. Siga o mesmo procedimento mostrado anteriormente.
Teremos que ajustas 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. 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 da seguinte forma:
# <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
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?
Para responder à pergunta, pressione 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, instale o rsync:
# apt-get install rsync
Monte o /dev/md0 em /mnt:
# mount /dev/md0 /mnt
Copie tudo, menos 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. |
Terminada a cópia, verifique se tudo está ok:
# ls /mnt
Desmonte o /dev/md0:
# umount /dev/md0
Por tratar-se de um servidor de rede, se não for precisar do rsync para qualquer tarefa no seu sistema, desinstale-o:
# apt-get purge rsync
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 /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 # cp -av /home/* /mnt
Note que por tratar-se da cópia de um diretório inteiro, sem restrições, não foi necessário utilizar o comando rsync. |
Verifique se a cópia foi realizada corretamente:
# ls /mnt
Desmonte o dispositivo:
# umount /dev/md1
Adequação do GRUB2 (primeira fase)
Agora, vamos ajustar o GRUB2 para que o mesmo passe a bootar utilizando o RAID. Esta será apenas uma primeira fase, pois 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 poder ser utilizado. 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 e 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
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.
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:
# update-grub
Instale o novo GRUB no MBR dos dois HDs:
# grub-install /dev/sda # grub-install /dev/sdb
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
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 é a secundaría) 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 no seu interior teste. A seguir, abra a máquina e, com cuidado, remova o cabo de energia de um dos dois HDs. Se estiver utilizando HD SATA, 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. |
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, 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 ocorre porque ainda não houve uma tentativa de acesso ao /home. 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>
Ficará 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. Para simular isso, simplesmente, desligue a máquina e religue o HD anteriormente desligado (energia).
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
A seguir, reinclua 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 a para de 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
Em seguida, 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 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
Por último, 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
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
Controle de acessos
<absHTML>
</absHTML>