RAID1 : créer arrays, préparer GRUB

Contexte et objectifs

Ce guide explique comment migrer un système existant vers des arrays RAID1 en créant les devices /dev/md0, /dev/md1 et /dev/md2, en copiant les données et en préparant le chargeur d’amorçage (GRUB) sur le deuxième disque. RAID1 fournit une tolérance de panne par miroir : chaque disque contient une copie identique des données.

Important : effectuez une sauvegarde complète avant toute opération risquée. Définition en une ligne : RAID1 = miroir des blocs entre deux disques, lecture équilibrée, reconstruit automatiquement sur remplacement d’un disque.

Variantes de l’intention (SEO)

Installer RAID1
Migrer disque vers RAID1
Configurer mdadm et GRUB pour RAID
Création d’arrays RAID dégradés
Préparer /etc/fstab et initrd pour RAID

4 Création de nos arrays RAID

Nous allons créer les arrays RAID /dev/md0, /dev/md1 et /dev/md2. Les partitions /dev/sdb1, /dev/sdb2 et /dev/sdb3 seront ajoutées aux arrays correspondants. Les partitions /dev/sda1, /dev/sda2 et /dev/sda3 ne peuvent pas être ajoutées maintenant (le système tourne dessus), nous utilisons donc le placeholder missing dans les commandes ci‑dessous :

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

Exécution utile pour vérifier l’état des arrays :

cat /proc/mdstat

La sortie devrait indiquer trois arrays RAID dégradés. [U] ou [U] signifie qu’un disque est manquant (array dégradé), [UU] signifie array OK :

[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 ~]#

Conseil rapide : une fois le second disque ajouté, mdadm commencera la reconstruction pour atteindre [UU]. Surveillez /proc/mdstat pendant la reconstruction.

5 Création des systèmes de fichiers et réglages initiaux

Nous formaterons les arrays et activerons la swap :

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

Ensuite, générez /etc/mdadm.conf pour avoir l’UUID et la configuration persistante :

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

Affichez le contenu :

cat /etc/mdadm.conf

Vous devriez voir les définitions des arrays (UUIDs sont spécifiques à votre machine) :

| 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 |

Important : conservez ce fichier pour que mdadm puisse assembler automatiquement les arrays au démarrage.

Monter temporairement les arrays

Nous montons /dev/md0 et /dev/md2 (pas la swap) pour copier les données :

mkdir /mnt/md0
mkdir /mnt/md2

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

Vérifiez avec :

mount

Sortie attendue (extrait) :

/dev/md0 on /mnt/md0 type ext3 (rw)
/dev/md2 on /mnt/md2 type ext3 (rw)

Modifier /etc/fstab pour le démarrage

Remplacez LABEL=/boot par /dev/md0, LABEL=SWAP-sda2 par /dev/md1 et LABEL=/ par /dev/md2 afin que votre fstab monte les arrays RAID au démarrage :

vi /etc/fstab

| /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 |

Ensuite, remplacez les références dans /etc/mtab (fichier runtime) si vous souhaitez que les vues actuelles reflètent les nouveaux devices :

vi /etc/mtab

| /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 |

Note : /etc/mtab est souvent un lien vers /proc/self/mounts sur les distributions modernes ; modifiez-le uniquement si nécessaire.

Ajout de fallback dans GRUB

Ouvrez /boot/grub/menu.lst (ou /boot/grub/grub.conf selon la distribution) et ajoutez fallback=1 après default=0 :

vi /boot/grub/menu.lst

| [...] default=0 fallback=1 [...] |

Cela force l’utilisation d’une entrée de secours si la première entrée échoue. Ensuite, dupliquez la strophe du kernel pour ajouter une entrée qui boot sur /dev/md2 (au lieu de LABEL=/) et changez root(hd0,0) en root(hd1,0) pour la nouvelle entrée :

| [...] 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 |

Explication : root (hd1,0) fait référence au second disque (/dev/sdb) qui contient déjà la partition /boot copiée plus tard.

Regénération du ramdisk

Renommez l’initrd existant et régénérez‑le pour inclure le support RAID et les modules nécessaires :

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

Vérifiez que le nouvel initrd est présent dans /boot.

Copier le contenu des partitions existantes vers les arrays

Copiez tout le système racine sur /dev/md2 monté sur /mnt/md2 :

cp -dpRx / /mnt/md2

Puis copiez le contenu de /boot vers /mnt/md0 :

cd /boot
cp -dpRx . /mnt/md0

Options cp : -d conserve les liens, -p préserve les permissions, -R copie récursivement, -x reste sur le même système de fichiers.

6 Préparer GRUB (Part 1)

Il faut ensuite installer GRUB sur le second disque (/dev/sdb) afin que la machine puisse démarrer depuis l’un ou l’autre disque :

grub

Dans l’invite GRUB, exécutez :

root (hd0,0)

Exemple d’échange avec grub :

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

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.

Puis configurez aussi le second disque :

root (hd1,0)
setup (hd1)
quit

Cette séquence installe le chargeur sur les deux MBRs, permettant au système de démarrer si l’un des disques meurt.

Vérification finale et redémarrage

Avant de redémarrer :

Vérifiez /proc/mdstat et attendez la fin de la reconstruction si vous avez ajouté un disque.
Confirmez que /etc/mdadm.conf contient les ARRAY correspondants.
Assurez‑vous que /etc/fstab utilise /dev/md* et que /boot contient kernel + initrd corrects.

Lancez :

reboot

Le système doit tenter de booter sur les arrays RAID (entrée principale). Si le boot échoue, GRUB utilisera l’entrée de fallback et booter sur l’ancien disque.

Vérifications post‑démarrage

Après redémarrage, contrôlez :

cat /proc/mdstat
mount
mdadm --detail /dev/md0
mdadm --detail /dev/md2

Confirmez que les arrays sont actifs et que /boot et / sont montés depuis /dev/md0 et /dev/md2. Vérifiez aussi la présence du swap via /dev/md1 :

swapon -s

Checklist rôle‑par rôle

Administrateur système (avant redémarrage) :
- Sauvegarde complète existante hors machine
- /etc/mdadm.conf généré
- /etc/fstab modifié pour /dev/md*
- initrd regénéré
- /boot copié sur /dev/md0
- GRUB installé sur les deux disques
Ingénieur support (après redémarrage) :
- /proc/mdstat shows [UU] for chaque RAID
- /dev/md0 monté sur /boot
- /dev/md2 monté sur /
- swap activée sur /dev/md1
- Logs kernel/syslog sans erreurs d’initrd

Critères d’acceptation

Le serveur redémarre correctement et présente /dev/md2 comme root (mount montre / sur /dev/md2).
/boot est lu depuis /dev/md0.
Tous les arrays RAID1 affichent [UU] dans /proc/mdstat ou sont en cours de reconstruction avec progression.
GRUB installé sur les deux disques et le fallback fonctionne (testable en retirant temporairement le premier disque dans un environnement de test).

Scénarios d’échec et résolution rapide

Reconstruction qui ne démarre pas : vérifier les journaux (dmesg, /var/log/messages) et lancer mdadm –assemble –scan.
Kernel ne trouve pas /dev/md2 au boot : le ramdisk n’inclut pas md_mod ou le module raid1 ; regénérez initrd en incluant les modules nécessaires.
GRUB n’est pas trouvé sur le second disque : relancer setup (hd1) dans le shell grub.

Mini‑méthodologie et heuristiques

Travailler toujours sur copies montées (/mnt/md*) jusqu’à validation complète.
Ne remplacez pas ou ne démontez pas les partitions actives avant d’avoir une entrée GRUB fonctionnelle et un initrd testé.
Prioriser la redondance du chargeur (installer GRUB sur chaque disque) plutôt que de dépendre d’un seul MBR.

Risques principaux et mitigations

Perte de données pendant copie : mitigation = sauvegarde externe et test de restauration.
Erreur de configuration fstab -> système non bootable : mitigation = garder l’accès console/ISO live pour réparation.
Modules manquants dans initrd : mitigation = vérifier la présence de md_mod, raid1, ext3 dans le initrd.

Petit arbre de décision (Mermaid)

flowchart TD
  A[Début] --> B{Arrays créés ?}
  B -- Non --> C[Créer arrays avec missing]
  B -- Oui --> D{Systèmes de fichiers créés ?}
  D -- Non --> E[mkfs.ext3/mkswap]
  E --> F[Monter /mnt/md* et copier données]
  D -- Oui --> F
  F --> G{GRUB installé sur sdb ?}
  G -- Non --> H[Entrer dans grub -> setup 'hd1']
  G -- Oui --> I[Regénérer initrd -> reboot]
  I --> J{Boot OK ?}
  J -- Non --> K[Utiliser fallback / récupération console]
  J -- Oui --> L[Terminé]

Récapitulatif

Créez les arrays RAID (utilisez missing pour le disque encore en service).
Formatez et montez les arrays, copiez les données.
Mettez à jour /etc/mdadm.conf, /etc/fstab et /etc/mtab.
Regénérez l’initrd et installez GRUB sur les deux disques.
Redémarrez, vérifiez /proc/mdstat et le montage des points racine.

Points d’attention : toujours tester en environnement non‑prod si possible ; valider la reconstruction RAID et le fallback GRUB avant d’abandonner l’accès aux disques originaux.

Passer un système en RAID1 : créer les arrays, préparer GRUB et basculer