Migrando um sistema para RAID1 — guia prático

Objetivo e público

Este documento descreve como migrar um sistema Linux que está atualmente usando /dev/sda* para um sistema RAID1 usando /dev/sdb como primeiro membro ativo e deixando /dev/sda como fallback até a conclusão. Público: administradores de sistemas com acesso root e familiaridade básica com a linha de comando e com conceitos de partições e bootloader.

Pré-requisitos

• Backup completo dos dados críticos antes de começar. Nunca confie apenas no procedimento sem backup.
• Acesso root no servidor físico ou via console remoto.
• mdadm, mkinitrd/mkinitramfs, e grub instalados no sistema.
• /dev/sda e /dev/sdb com partições paralelas: sda1/sdb1 (boot), sda2/sdb2 (swap), sda3/sdb3 (/).
• Tempo de manutenção planejado; reinicialização é necessária no final.

Important: Execute cada comando com atenção — especialmente os que escrevem em discos (mkfs, setup grub, cp). Um engano pode tornar o sistema inoperante.

1. Criação dos arrays RAID

Vamos criar três arrays RAID /dev/md0, /dev/md1 e /dev/md2. O fluxo usado aqui adiciona a partição do segundo disco (/dev/sdb) e usa o placeholder missing para indicar que o par ainda não está presente em /dev/sda (o sistema ainda está rodando nelas).

Comandos a executar exatamente:

mdadm –create /dev/md0 –level=1 –raid-disks=2 missing /dev/sdb1 mdadm –create /dev/md1 –level=1 –raid-disks=2 missing /dev/sdb2 mdadm –create /dev/md2 –level=1 –raid-disks=2 missing /dev/sdb3

Ao criar os arrays, eles aparecerão como degradados. Verifique com:

cat /proc/mdstat

Você deve ver algo semelhante a:

[root@server1 ~]# cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md2 : active raid1 sdb3[1]
9759360 blocks [2/1] [_U]

md1 : active raid1 sdb2[1]
522048 blocks [2/1] [_U]

md0 : active raid1 sdb1[1]
200704 blocks [2/1] [_U]

unused devices: 
[root@server1 ~]#

Explicação rápida: [U] ou [U] indica que um dos membros está ausente e o array está degradado. [UU] significa que ambos os membros estão presentes e o array está saudável.

2. Criar sistemas de arquivos e swap nos arrays

Formate os arrays e ative swap conforme a intenção original:

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

Dica: Se preferir ext4 substitua mkfs.ext3 por mkfs.ext4, mas confirme compatibilidade do initramfs/instalador do GRUB.

3. Gerar /etc/mdadm.conf

Registre a configuração dos arrays para que o mdadm possa montá-los automaticamente no boot:

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

Verifique o conteúdo:

cat /etc/mdadm.conf

Você deverá ver entradas ARRAY semelhantes a estas (UUIDs variam):

ARRAY /dev/md0 level=raid1 num-devices=2 UUID=78d582f0:940fabb5:f1c1092a:04a55452
ARRAY /dev/md1 level=raid1 num-devices=2 UUID=8db8f7e1:f2a64674:d22afece:4a539aa7
ARRAY /dev/md2 level=raid1 num-devices=2 UUID=1baf282d:17c58efd:a8de6947:b0af9792

Guarde esse arquivo; ele é essencial para reassemblar os arrays automaticamente.

4. Montar e copiar dados

Crie pontos de montagem temporários e monte os arrays para copiar os dados atuais:

mkdir /mnt/md0
mkdir /mnt/md2

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

Confirme com:

mount

Exemplo de saída esperada:

[root@server1 ~]# mount
/dev/sda3 on / type ext3 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
/dev/sda1 on /boot type ext3 (rw)
tmpfs on /dev/shm type tmpfs (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
/dev/md0 on /mnt/md0 type ext3 (rw)
/dev/md2 on /mnt/md2 type ext3 (rw)
[root@server1 ~]#

Copie a raiz e o /boot para os novos arrays. Use flags que preservem atributos, links e permissões:

cp -dpRx / /mnt/md2

cd /boot
cp -dpRx . /mnt/md0

Nota: Se houver arquivos abertos em / (por exemplo /proc ou /sys), o cp ignorará os pseudo-sistemas de arquivos; manter a ordem acima evita copiar pseudo-sistemas.

5. Ajustar fstab e mtab

Edite /etc/fstab no sistema de destino (o / montado do md2 copiado) para usar os dispositivos RAID:

Abra o editor:

vi /etc/fstab

Substitua LABEL=/boot por /dev/md0, LABEL=SWAP-sda2 por /dev/md1 e LABEL=/ por /dev/md2. O arquivo deverá ficar parecido com:

/dev/md2                 /                       ext3    defaults        1 1
/dev/md0             /boot                   ext3    defaults        1 2
tmpfs                   /dev/shm                tmpfs   defaults        0 0
devpts                  /dev/pts                devpts  gid=5,mode=620  0 0
sysfs                   /sys                    sysfs   defaults        0 0
proc                    /proc                   proc    defaults        0 0
/dev/md1         swap                    swap    defaults        0 0

Em seguida, atualize /etc/mtab (ou o arquivo mtab que está em uso no ambiente ativo) para refletir a montagem atual:

vi /etc/mtab

Conteúdo esperado:

/dev/md2 / ext3 rw 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
devpts /dev/pts devpts rw,gid=5,mode=620 0 0
/dev/md0 /boot ext3 rw 0 0
tmpfs /dev/shm tmpfs rw 0 0
none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0
sunrpc /var/lib/nfs/rpc_pipefs rpc_pipefs rw 0 0

6. Ajustar GRUB para fallback e novo root

Edite o arquivo do GRUB para permitir fallback caso o boot dos arrays falhe. Abra:

vi /boot/grub/menu.lst

Adicione ou garanta que exista a linha fallback=1 logo após default=0:

default=0
fallback=1

Isso faz com que, se o primeiro kernel falhar, o GRUB tente a entrada de fallback.

No mesmo arquivo, copie a primeira stanza de kernel para cima e ajuste para usar root=/dev/md2 e root (hd1,0). Exemplo resultante:

[...]
title CentOS (2.6.18-128.el5)
        root (hd1,0)
        kernel /vmlinuz-2.6.18-128.el5 ro root=/dev/md2
        initrd /initrd-2.6.18-128.el5.img

title CentOS (2.6.18-128.el5)
        root (hd0,0)
        kernel /vmlinuz-2.6.18-128.el5 ro root=LABEL=/
        initrd /initrd-2.6.18-128.el5.img

Explicação: root (hd1,0) referencia o segundo disco (geralmente /dev/sdb). Mantemos a stanza original como fallback que usa /dev/sda.

7. Atualizar initramfs

Renomeie o initrd atual como backup e gere um novo compatível com o novo root:

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

Verifique se o novo initrd foi criado em /boot.

8. Preparando o GRUB no segundo disco (/dev/sdb)

Você agora deve instalar o GRUB no disco secundário para permitir boot independente dele.

Inicie o shell do grub:

grub

No prompt do GRUB, execute os passos abaixo (exemplos):

root (hd0,0)

Exemplo de retorno:

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

grub>

Em seguida instale o GRUB nesse disco:

setup (hd0)

Exemplo de saída (resumo):

grub> setup (hd0)
Checking if "/boot/grub/stage1" exists... no
Checking if "/grub/stage1" exists... yes
Checking if "/grub/stage2" exists... yes
Checking if "/grub/e2fs_stage1_5" exists... yes
Running "embed /grub/e2fs_stage1_5 (hd0)"...  15 sectors are embedded.
succeeded
Running "install /grub/stage1 (hd0) (hd0)1+15 p (hd0,0)/grub/stage2 /grub/grub.conf"... succeeded
Done.

grub>

Repita o processo agora para o segundo disco (hd1) que corresponde a /dev/sdb:

root (hd1,0)
setup (hd1)
quit

Saia do GRUB e faça um reboot para testar:

reboot

O sistema deverá tentar bootar do /dev/sdb (arrays RAID); se houver falha será usado o fallback em /dev/sda.

Checagens pós-reboot

• Verifique /proc/mdstat para confirmar que os arrays estão ativos e, se possível, reconstrua adicionando /dev/sda1 etc. com mdadm –add.
• Confirme que o sistema montou /dev/md2 como / e /dev/md0 como /boot.
• Cheque dmesg/journalctl para mensagens de erro relativas a md, initramfs ou GRUB.

Recuperação e sincronização dos membros

Depois do reboot bem-sucedido, adicione as partições /dev/sda* aos arrays para reconstruir a redundância:

mdadm --add /dev/md0 /dev/sda1
mdadm --add /dev/md1 /dev/sda2
mdadm --add /dev/md2 /dev/sda3

Monitore reconstrução em /proc/mdstat até que o estado passe para [UU].

Riscos comuns e mitigação

• Erro ao identificar partição alvo — sempre verifique com lsblk, fdisk -l ou parted -l.
• Sobrescrever disco errado com mkfs — se possível, confirme UUIDs e rótulos antes de formatar.
• GRUB instalado no disco errado — teste no console do servidor ou numa janela KVM antes de remover o disco original.
• Falta de backup — sempre realize e verifique backups antes de operações em disco.

Mini-SOP rápido (para automação/manual)

1. Fazer backup completo. 2. Criar arrays com mdadm (missing + /dev/sdb). 3. mkfs/mkswap. 4. mdadm –examine –scan > /etc/mdadm.conf. 5. Montar arrays e copiar / e /boot. 6. Atualizar fstab/mtab. 7. Gerar novo initrd. 8. Instalar GRUB em /dev/sdb. 9. Reboot. 10. Adicionar /dev/sda aos arrays e monitorar reconstrução.

Checklist por função

• Operador/Runbook:
  • Backup completo verificado
  • Janela de manutenção definida
  • Console físico ou IPMI pronto
• Administrador de disco:
  • Partições confirmadas (lsblk/fdisk)
  • Arrays criados e verificados em /proc/mdstat
• Engenheiro de boot:
  • menu.lst atualizado com fallback
  • initrd regenerado
  • GRUB instalado em ambos discos

Fluxo de decisão (Mermaid)

flowchart TD
  A[Iniciar migração para RAID1?] --> B{Backup disponível?}
  B -- Não --> Z[Parar: fazer backup]
  B -- Sim --> C{Partições em ambos discos OK?}
  C -- Não --> Y[Corrigir partições ou abortar]
  C -- Sim --> D[Criar arrays com missing]
  D --> E[Formatar e montar]
  E --> F[Copiar dados e ajustar fstab]
  F --> G[Instalar GRUB em /dev/sdb]
  G --> H[Reboot]
  H --> I{Boot bem-sucedido?}
  I -- Sim --> J[Adicionar /dev/sda* aos arrays]
  I -- Não --> K[Usar fallback / recuperar do backup]

Glossário rápido

• RAID1: Espelhamento de discos, redundância 1:1.
• mdadm: Ferramenta Linux para gerenciar arrays MD (software RAID).
• initrd/initramfs: Ramdisk inicial usado pelo kernel para montar root antes do sistema real.
• GRUB: Bootloader que carrega o kernel.

Critérios de aceitação

• Após reboot, o sistema subiu com root em /dev/md2 e /boot em /dev/md0.
• /proc/mdstat mostra arrays com ambos os membros presentes após adicionar /dev/sda* e completar resync ([UU]).
• GRUB instalado em /dev/sda e /dev/sdb, ou ao menos em /dev/sdb com fallback funcional.

Resumo

• Criamos arrays RAID1 degradados usando mdadm com placeholder missing.
• Formatamos, copiamos / e /boot, ajustamos fstab/mtab e regeneramos initrd.
• Instalamos GRUB no disco secundário e testamos o boot. Finalmente, adicionamos as partições do disco original para sincronizar os arrays.

Notas: Este guia descreve passos manuais, úteis para documentação e automação. Ajuste nomes de dispositivos, caminhos do kernel e versões para o seu ambiente.