Criando e ajustando arrays RAID1 no Linux

Intenção primaria e variações relacionadas

• Intenção primária: Criar arrays RAID1 e migrar o sistema para eles.
• Variações: configurar RAID1 com mdadm, atualizar GRUB para RAID, migrar / e /boot para RAID, regenerar initrd para RAID, validar arrays degradados.

Pré-requisitos

• Acesso root ou sudo em um sistema Linux com mdadm e GRUB instalados.
• Dois discos/partições por array (ex.: /dev/hda1 + /dev/hdb1).
• Cópia de segurança recente antes de operações em disco.

1. Criando nossos arrays RAID

Agora vamos criar os arrays RAID /dev/md0, /dev/md1 e /dev/md2. Adicionaremos /dev/hdb1 ao /dev/md0, /dev/hdb5 ao /dev/md1 e /dev/hdb6 ao /dev/md2. Como /dev/hda1, /dev/hda5 e /dev/hda6 estão em uso pelo sistema, usamos o placeholder missing nos comandos abaixo:

mdadm --create /dev/md0 --level=1 --raid-disks=2 missing /dev/hdb1  
mdadm --create /dev/md1 --level=1 --raid-disks=2 missing /dev/hdb5  
mdadm --create /dev/md2 --level=1 --raid-disks=2 missing /dev/hdb6

Execute:

cat /proc/mdstat

A saída deve mostrar três arrays RAID degradados ( [U] ou [U] indica array degradado; [UU] indica array OK):

[root@server1 ~]# cat /proc/mdstat  
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]  
md2 : active raid1 hdb6[1]  
      4642688 blocks [2/1] [_U]  
  
md1 : active raid1 hdb5[1]  
      417536 blocks [2/1] [_U]  
  
md0 : active raid1 hdb1[1]  
      176576 blocks [2/1] [_U]  
  
unused devices:   
[root@server1 ~]#

2. Criando sistemas de arquivos e atualizando /etc/mdadm.conf

Crie sistemas de arquivos e swap nos arrays:

mkfs.ext3 /dev/md0  
mkswap /dev/md1  
mkfs.ext3 /dev/md2

Em seguida, atualize /etc/mdadm.conf para incluir os arrays recém-criados. Primeiro faça um backup do arquivo atual e depois escaneie os arrays:

cp /etc/mdadm.conf /etc/mdadm.conf_orig  
mdadm --examine --scan >> /etc/mdadm.conf

Exiba o conteúdo atualizado:

cat /etc/mdadm.conf

No arquivo você verá linhas ARRAY com UUIDs e detalhes dos arrays (exemplo abaixo mantido como referência):

# mdadm configuration file
#
# mdadm will function properly without the use of a configuration file,
# but this file is useful for keeping track of arrays and member disks.
[...]
ARRAY /dev/md0 level=raid1 num-devices=2 UUID=6b4f013f:6fe18719:5904a9bd:70e9cee6
ARRAY /dev/md1 level=raid1 num-devices=2 UUID=63194e2e:c656857a:3237a906:0616f49e
ARRAY /dev/md2 level=raid1 num-devices=2 UUID=edec7105:62700dc0:643e9917:176563a7

Important: Manter o /etc/mdadm.conf atualizado facilita a montagem automática dos arrays durante boot.

3. Montando arrays e atualizando fstab/mtab

Crie pontos de montagem e monte /dev/md0 e /dev/md2 (não é necessário montar o swap /dev/md1):

mkdir /mnt/md0  
mkdir /mnt/md2

mount /dev/md0 /mnt/md0  
mount /dev/md2 /mnt/md2

Verifique com:

mount

Exemplo de saída esperada:

[root@server1 ~]# mount  
/dev/hda6 on / type ext3 (rw,relatime)  
none on /proc type proc (rw)  
/dev/hda1 on /boot type ext3 (rw,relatime)  
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)  
/dev/md0 on /mnt/md0 type ext3 (rw)  
/dev/md2 on /mnt/md2 type ext3 (rw)  
[root@server1 ~]#

Edite /etc/fstab: substitua /dev/hda1 por /dev/md0, /dev/hda5 por /dev/md1 e /dev/hda6 por /dev/md2. O /etc/fstab deve ficar similar a:

/dev/md2 / ext3 relatime 1 1
/dev/md0 /boot ext3 relatime 1 2
/dev/cdrom /media/cdrom auto umask=0022,users,iocharset=utf8,noauto,ro,exec 0 0
/dev/fd0 /media/floppy auto umask=0022,users,iocharset=utf8,noauto,exec,flush 0 0
none /proc proc defaults 0 0
/dev/md1 swap swap defaults 0 0

Atualize também /etc/mtab para refletir o novo mapeamento (substitua /dev/hda1 por /dev/md0 e /dev/hda6 por /dev/md2). Exemplo:

/dev/md2 / ext3 rw,relatime 0 0
none /proc proc rw 0 0
/dev/md0 /boot ext3 rw,relatime 0 0
none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0
/dev/md0 /mnt/md0 ext3 rw 0 0
/dev/md2 /mnt/md2 ext3 rw 0 0

4. Ajustando o GRUB e o initrd

No arquivo do GRUB (/boot/grub/menu.lst), adicione fallback 1 logo após default 0 para que haja uma opção de fallback se o primeiro kernel falhar:

vi /boot/grub/menu.lst

Edite para incluir:

default 0
fallback 1

Copie a stanza do kernel existente e coloque a cópia antes da stanza original. Modifique root=/dev/hda6 para root=/dev/md2 e (hd0,0) para (hd1,0). Se houver resume=/dev/hda5, troque por resume=/dev/md1. Exemplo de bloco no menu.lst:

title linux
kernel (hd1,0)/vmlinuz BOOT_IMAGE=linux root=/dev/md2  resume=/dev/md1
initrd (hd1,0)/initrd.img

title linux
kernel (hd0,0)/vmlinuz BOOT_IMAGE=linux root=/dev/hda6  resume=/dev/hda5
initrd (hd0,0)/initrd.img

Observação: (hd1,0) corresponde a /dev/hdb; esse disco já faz parte dos arrays RAID.

Regenerar o ramdisk para incluir suporte a RAID durante boot:

mv /boot/initrd-`uname -r`.img /boot/initrd-`uname -r`.img_orig  
mkinitrd /boot/initrd-`uname -r`.img `uname -r`

Copie o conteúdo de / (montado em /mnt/md2) e de /boot (montado em /mnt/md0):

cp -dpRx / /mnt/md2

cd /boot  
cp -dpRx . /mnt/md0

Esses passos garantem que os dados necessários estejam presentes nas partições RAID antes do reboot.

5. Preparando o GRUB em ambos os discos

Instale o GRUB no disco secundário /dev/hdb (e no primário também) para permitir boot redundante.

Execute o shell do grub:

grub

No prompt do GRUB, instale em cada disco. Exemplo para o primeiro disco (hd0):

root (hd0,0)
setup (hd0)

Exemplo de saída (mantida como referência):

grub> root (hd0,0)  
 Filesystem type is ext2fs, partition type 0x83  
  
grub> 

E então para o segundo disco (hd1):

root (hd1,0)
setup (hd1)

Saída de sucesso esperada indica que stage1/stage2 foram instalados e setores embutidos foram escritos. Finalmente, saia do prompt do GRUB:

quit

Agora reinicie o sistema e valide que o sistema inicia a partir dos arrays RAID. O sistema tentará primeiro iniciar via RAID (opção padrão) e, em caso de falha, usará o fallback definido.

reboot

Checagens pós-reboot

• Verifique /proc/mdstat para confirmar que os arrays estão montados e sincronizando: cat /proc/mdstat
• Confirme que / e /boot estão montados sobre /dev/md2 e /dev/md0.
• Confira dmesg ou /var/log/messages para erros relacionados a md, disco ou initrd.

Quando isso pode falhar (cenários comuns)

• GRUB antigo vs GRUB2: este procedimento usa a sintaxe do GRUB legacy. Em sistemas com GRUB2, o comando e a configuração mudam.
• Partições com números diferentes: certifique-se das partições corretas (hd0/hda vs hd1/hdb). Erros de mapa de disco impedem o boot.
• initrd sem suporte a md: se o initrd não incluir módulos md/raid, o kernel não encontra os arrays e o boot falha.
• UUIDs ausentes: usar dispositivos de bloco diretos em fstab pode ser frágil; preferir UUIDs quando possível.

Alternativas e boas práticas

• Usar mdadm –assemble em vez de –create quando dispositivos já têm metadata.
• Preferir GRUB2 e atualizar o grub.cfg via update-grub (quando disponível) para reduzir manipulação manual de menu.lst.
• Usar UUIDs em /etc/fstab para evitar dependência de nomes de dispositivo que podem mudar.
• Testar todo o processo em ambiente de staging antes de rodar em produção.

Checklists de papel (funções)

• Administrador (preparação): backup completo; checar espaço em /boot; identificar partições corretas; atualizar /etc/mdadm.conf.
• Engenheiro de implantação (execução): criar arrays, criar FS, montar, copiar dados, regenerar initrd, instalar GRUB nos dois discos.
• Operações (pós-reboot): validar /proc/mdstat, logs de boot, agendar verificação periódica do SMART dos discos.

Mini metodologia de rollout

1. Backup completo. 2. Criar arrays em modo degradado com placeholder missing. 3. Criar FS e swap. 4. Atualizar mdadm.conf. 5. Montar e copiar dados. 6. Atualizar fstab/mtab e menu do GRUB. 7. Regenerar initrd. 8. Instalar GRUB em ambos os discos. 9. Reboot e validação.

Glossário (uma linha)

• RAID1: espelhamento de disco para redundância; dois ou mais discos com cópias idênticas.
• mdadm: utilitário para controlar arrays Linux MD (Multiple Device).
• initrd/initramfs: imagem inicial usada pelo kernel para montar sistemas antes do root final.
• GRUB: carregador de boot usado para carregar o kernel.

Fluxo de decisão rápido (Mermaid)

flowchart TD
  A[Preparado? Backup completo] -->|não| B[ Fazer backup ]
  A -->|sim| C[Criar arrays com missing]
  C --> D{Arrays criados com sucesso?}
  D -->|sim| E[Criar FS, montar e copiar dados]
  D -->|não| F[Rever partições e mdadm --examine]
  E --> G[Atualizar mdadm.conf, fstab e mtab]
  G --> H[Regenerar initrd]
  H --> I[Instalar GRUB em ambos discos]
  I --> J[Reboot e validação]

Resumo

• Criar arrays RAID1 com mdadm em modo degradado permite migrar o sistema sem tirá-lo do ar imediatamente.
• Atualize /etc/mdadm.conf, fstab/mtab, regenere initrd e instale GRUB em ambos os discos para boot redundante.
• Teste em staging e mantenha backups; prefira UUIDs em fstab e considere GRUB2 em distribuições modernas.

Importante: sempre tenha backups e, se possível, teste cada etapa num ambiente que não seja o servidor de produção.