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 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.
A sincronização da partição /home
Teste de funcionamento
A troca de um disco danificado
Controle de acessos
<absHTML>
</absHTML>