Le RAID logiciel Linux (mdadm) offre redondance et performance sans contrôleur matériel coûteux. Guide complet de déploiement production : configuration, monitoring, alertes et procédures de remplacement disque.
Plan
- Choisir le bon niveau RAID
- Installation et création RAID
- Optimisation performance
- Monitoring et alertes automatiques
- Procédure remplacement disque à chaud
- Recovery et reconstruction
- Benchmarks et bonnes pratiques
- Conclusion
Choisir le bon niveau RAID
Comparaison niveaux RAID
| Niveau | Disques min | Espace utile | Tolérance panne | Performance lecture | Performance écriture | Cas d'usage |
| RAID 0 | 2 | 100% | 0 disque | Excellente (x2) | Excellente (x2) | Performance pure (cache, scratch) |
| RAID 1 | 2 | 50% | 1 disque | Bonne (x2) | Standard | Système, boot, haute disponibilité |
| RAID 5 | 3 | (n-1)/n | 1 disque | Très bonne | Moyenne (parité) | Données, balance coût/perf |
| RAID 6 | 4 | (n-2)/n | 2 disques | Très bonne | Faible (double parité) | Gros volumes, sécurité max |
| RAID 10 | 4 | 50% | 1 disque/miroir | Excellente (xN/2) | Très bonne | Bases de données, I/O intensif |
Recommandations par cas d'usage
Système / Boot :
RAID 1 sur 2 SSD
- Simplicité
- Boot possible même si 1 disque mort
- Performance lecture doublée
Bases de données (MySQL/PostgreSQL) :
RAID 10 sur 4+ disques
- Performance I/O maximale
- Tolérance panne
- Pas de pénalité écriture (vs RAID 5/6)
Stockage fichiers (NAS) :
RAID 6 sur 6-12 disques
- Bon compromis espace/sécurité
- Tolère 2 pannes simultanées
- Idéal gros volumes (>10 TB)
Cache / Scratch :
RAID 0 sur SSD NVMe
- Performance pure
- Données non critiques
- Accélération builds/compilation
Installation et création RAID
Prérequis
# Installer mdadm
apt install mdadm # Debian/Ubuntu
dnf install mdadm # RHEL/Rocky
# Identifier les disques
lsblk
fdisk -l
# Vérifier SMART status
apt install smartmontools
smartctl -a /dev/sda
smartctl -a /dev/sdb
Créer un RAID 1 (2 disques)
# Partitionner les disques (même taille)
# /dev/sda et /dev/sdb
# Créer partitions GPT
parted /dev/sda mklabel gpt
parted /dev/sda mkpart primary 0% 100%
parted /dev/sda set 1 raid on
parted /dev/sdb mklabel gpt
parted /dev/sdb mkpart primary 0% 100%
parted /dev/sdb set 1 raid on
# Créer RAID 1
mdadm --create /dev/md0 \
--level=1 \
--raid-devices=2 \
/dev/sda1 /dev/sdb1
# Vérifier
cat /proc/mdstat
# md0 : active raid1 sdb1[1] sda1[0]
# 1000000000 blocks super 1.2 [2/2] [UU]
# Attendre fin de synchronisation initiale
watch cat /proc/mdstat
Créer un RAID 5 (3+ disques)
# 4 disques : /dev/sd{a,b,c,d}
# Partitionner tous les disques
for disk in a b c d; do
parted /dev/sd${disk} mklabel gpt
parted /dev/sd${disk} mkpart primary 0% 100%
parted /dev/sd${disk} set 1 raid on
done
# Créer RAID 5
mdadm --create /dev/md0 \
--level=5 \
--raid-devices=4 \
--chunk=256 \
/dev/sd{a,b,c,d}1
# Vérifier
mdadm --detail /dev/md0
Créer un RAID 10 (4+ disques)
# 4 disques minimum (2 miroirs de 2)
mdadm --create /dev/md0 \
--level=10 \
--raid-devices=4 \
--layout=n2 \
/dev/sd{a,b,c,d}1
# Layout options :
# n2 = near 2 (défaut, meilleure performance)
# f2 = far 2 (meilleure lecture, pire écriture)
# o2 = offset 2
Formater et monter
# Créer filesystem (ext4 ou xfs)
mkfs.ext4 -L data /dev/md0
# Ou XFS (recommandé >16TB)
mkfs.xfs -L data /dev/md0
# Monter
mkdir -p /mnt/raid
mount /dev/md0 /mnt/raid
# Vérifier
df -h /mnt/raid
Configuration persistante
# Sauvegarder config RAID
mdadm --detail --scan >> /etc/mdadm/mdadm.conf
# Ou RHEL/Rocky
mdadm --detail --scan >> /etc/mdadm.conf
# Mettre à jour initramfs
update-initramfs -u # Debian/Ubuntu
dracut -f # RHEL/Rocky
# Ajouter au fstab
UUID=$(blkid /dev/md0 -s UUID -o value)
echo "UUID=$UUID /mnt/raid ext4 defaults,noatime 0 2" >> /etc/fstab
# Tester fstab
mount -a
Optimisation performance
Chunk size optimal
# Chunk size = taille bloc données avant écriture suivante
# RAID 5/6 :
# - 64K : petits fichiers, base de données
# - 256K : usage général (défaut recommandé)
# - 512K-1M : gros fichiers, streaming
# Recréer avec chunk custom
mdadm --create /dev/md0 \
--level=5 \
--chunk=512 \
--raid-devices=4 \
/dev/sd{a,b,c,d}1
Stripe cache size
# Augmenter cache pour meilleure performance (RAID 5/6)
# Voir valeur actuelle
cat /sys/block/md0/md/stripe_cache_size
# 256 (défaut)
# Augmenter (RAM disponible)
echo 8192 > /sys/block/md0/md/stripe_cache_size
# Permanent
echo 'DEVICE /dev/sd*' > /etc/mdadm/mdadm.conf
echo 'ARRAY /dev/md0 metadata=1.2 name=hostname:0 UUID=xxx stripe_cache_size=8192' >> /etc/mdadm/mdadm.conf
Read-ahead buffer
# Augmenter read-ahead (séquentiel)
# Défaut
blockdev --getra /dev/md0
# 256
# Augmenter (meilleur pour streaming)
blockdev --setra 8192 /dev/md0
# Permanent (systemd)
cat > /etc/systemd/system/raid-readahead.service << 'EOF'
[Unit]
Description=Set RAID read-ahead
After=mdadm.service
[Service]
Type=oneshot
ExecStart=/sbin/blockdev --setra 8192 /dev/md0
[Install]
WantedBy=multi-user.target
EOF
systemctl enable --now raid-readahead
Bitmap pour resync rapide
# Activer bitmap interne (journaling)
# Accélère resync après crash
mdadm --grow /dev/md0 --bitmap=internal
# Vérifier
mdadm --detail /dev/md0 | grep Bitmap
# Intent Bitmap : Internal
Monitoring et alertes automatiques
Configuration mdadm monitoring
# /etc/mdadm/mdadm.conf (Debian/Ubuntu)
# /etc/mdadm.conf (RHEL/Rocky)
# Email alertes
MAILADDR root@localhost
# Scan automatique
DEVICE /dev/sd*
# Arrays
ARRAY /dev/md0 metadata=1.2 name=hostname:0 UUID=xxx
Service mdmonitor
# Activer monitoring daemon
systemctl enable --now mdmonitor
# Vérifier status
systemctl status mdmonitor
# Logs
journalctl -u mdmonitor -f
Script de monitoring custom
#!/bin/bash
# /usr/local/bin/mdadm-check.sh
RAID_DEVICE="/dev/md0"
EMAIL="admin@example.com"
# Vérifier status
STATUS=$(mdadm --detail $RAID_DEVICE | grep "State :" | awk '{print $3}')
if [ "$STATUS" != "clean" ] && [ "$STATUS" != "active" ]; then
# État anormal
DETAIL=$(mdadm --detail $RAID_DEVICE)
mail -s "⚠️ RAID Alert: $RAID_DEVICE status $STATUS" $EMAIL << EOF
RAID Array $RAID_DEVICE has abnormal status: $STATUS
Full details:
$DETAIL
Action required: Check failed disks and replace if necessary.
EOF
fi
# Vérifier disques failed
FAILED=$(mdadm --detail $RAID_DEVICE | grep "failed" | wc -l)
if [ $FAILED -gt 0 ]; then
DETAIL=$(mdadm --detail $RAID_DEVICE)
mail -s "🚨 CRITICAL: RAID $RAID_DEVICE has $FAILED failed disk(s)" $EMAIL << EOF
CRITICAL: $FAILED disk(s) have failed in $RAID_DEVICE
$DETAIL
IMMEDIATE ACTION REQUIRED: Replace failed disk(s)
EOF
fi
# Vérifier SMART
for disk in $(mdadm --detail $RAID_DEVICE | grep "active sync" | awk '{print $7}' | sed 's/[0-9]*$//'); do
SMART_ERRORS=$(smartctl -a $disk | grep "Error" | wc -l)
if [ $SMART_ERRORS -gt 0 ]; then
mail -s "⚠️ SMART errors detected on $disk" $EMAIL << EOF
SMART errors detected on $disk (member of $RAID_DEVICE)
$(smartctl -a $disk | grep -A 20 "Error")
Recommend replacement before failure.
EOF
fi
done
# Installer
chmod +x /usr/local/bin/mdadm-check.sh
# Cron toutes les heures
echo "0 * * * * /usr/local/bin/mdadm-check.sh" | crontab -
Monitoring Prometheus
# prometheus.yml
scrape_configs:
- job_name: 'node'
static_configs:
- targets: ['localhost:9100']
# Installer node_exporter avec mdstat collector
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xzf node_exporter-1.7.0.linux-amd64.tar.gz
./node_exporter --collector.mdadm
# Métriques disponibles
curl localhost:9100/metrics | grep mdadm
# node_mdadm_disks_active{device="md0"} 4
# node_mdadm_disks_failed{device="md0"} 0
Procédure remplacement disque à chaud
Scénario : 1 disque failed dans RAID 5
# 1. Vérifier status
mdadm --detail /dev/md0
# /dev/sdb1 - faulty
cat /proc/mdstat
# md0 : active raid5 sdd1[3] sdc1[2] sdb1[1](F) sda1[0]
# 2. Marquer disque comme failed (si pas auto)
mdadm --manage /dev/md0 --fail /dev/sdb1
# 3. Retirer du RAID
mdadm --manage /dev/md0 --remove /dev/sdb1
# 4. Éteindre serveur et remplacer disque physique
# OU si hot-swap :
echo 1 > /sys/block/sdb/device/delete
# 5. Après remplacement, rescanner
echo "- - -" > /sys/class/scsi_host/host0/scan
# 6. Partitionner nouveau disque (copier table du disque sain)
sgdisk --replicate=/dev/sdb /dev/sda
sgdisk --randomize-guids /dev/sdb
# 7. Ajouter au RAID
mdadm --manage /dev/md0 --add /dev/sdb1
# 8. Suivre reconstruction
watch cat /proc/mdstat
# [=>...................] recovery = 12.5% (125000000/1000000000)
# finish=45.2min speed=322000K/sec
# 9. Vérifier fin reconstruction
mdadm --detail /dev/md0
# State : clean
# /dev/sdb1 - active sync
Remplacement sans downtime (RAID 1/10)
# RAID 1 avec 2 disques : peut tourner avec 1 seul
# 1. Fail + remove
mdadm /dev/md0 --fail /dev/sdb1 --remove /dev/sdb1
# 2. Remplacer disque à chaud
# 3. Ajouter nouveau
mdadm /dev/md0 --add /dev/sdb1
# Système reste disponible pendant reconstruction
Recovery et reconstruction
Forcer un check complet
# Vérifier intégrité (scrub)
echo check > /sys/block/md0/md/sync_action
# Suivre progression
cat /proc/mdstat
# Voir résultat
cat /sys/block/md0/md/mismatch_cnt
# 0 = OK, >0 = problèmes détectés
Récupération après crash
# Assembler RAID automatiquement
mdadm --assemble --scan
# Ou manuellement
mdadm --assemble /dev/md0 /dev/sd{a,b,c,d}1
# Forcer démarrage même si dégradé
mdadm --assemble --force /dev/md0 /dev/sda1 /dev/sdc1 /dev/sdd1
# (sdb manquant)
# Voir status
mdadm --detail /dev/md0
Reconstruire array dégradé
# Scénario : RAID 5 avec 2 disques morts (data loss)
# Créer nouveau RAID avec disques restants + nouveaux
# 1. Sauvegarder données survivantes (si possible)
# 2. Détruire array corrompu
mdadm --stop /dev/md0
mdadm --zero-superblock /dev/sd{a,b,c,d}1
# 3. Recréer RAID avec TOUS nouveaux disques
mdadm --create /dev/md0 \
--level=5 \
--raid-devices=4 \
/dev/sd{a,b,c,d}1
# 4. Restaurer backup
Benchmarks et bonnes pratiques
Tests performance
# Installer fio
apt install fio
# Test lecture séquentielle
fio --name=seqread --rw=read --bs=1M --size=10G \
--numjobs=1 --filename=/mnt/raid/test --direct=1
# Test écriture séquentielle
fio --name=seqwrite --rw=write --bs=1M --size=10G \
--numjobs=1 --filename=/mnt/raid/test --direct=1
# Test lecture aléatoire (IOPS)
fio --name=randread --rw=randread --bs=4K --size=1G \
--numjobs=4 --filename=/mnt/raid/test --direct=1
# Test écriture aléatoire
fio --name=randwrite --rw=randwrite --bs=4K --size=1G \
--numjobs=4 --filename=/mnt/raid/test --direct=1
Résultats typiques (4x SSD SATA) :
| RAID | Lecture seq | Écriture seq | Lecture 4K | Écriture 4K |
| RAID 0 | 2000 MB/s | 2000 MB/s | 160k IOPS | 160k IOPS |
| RAID 1 | 1000 MB/s | 500 MB/s | 80k IOPS | 40k IOPS |
| RAID 5 | 1500 MB/s | 700 MB/s | 120k IOPS | 50k IOPS |
| RAID 10 | 2000 MB/s | 1000 MB/s | 160k IOPS | 80k IOPS |
Bonnes pratiques
✅ Configuration :
- Utiliser disques identiques (même taille/modèle)
- Activer bitmap pour resync rapide
- Configurer chunk size adapté au workload
- Partitions alignées (2048 sectors)
✅ Monitoring :
- mdmonitor activé
- Alertes email configurées
- Check SMART hebdomadaire
- Scrub mensuel (
echo check)
✅ Maintenance :
- Remplacer disques proactivement (SMART warnings)
- Tester procédure recovery régulièrement
- Backup régulier (RAID ≠ backup !)
- Documenter procédures
✅ Performance :
- RAID 10 pour DB (I/O random)
- RAID 5/6 pour fichiers (séquentiel)
- stripe_cache_size >= 8192 (RAID 5/6)
- read-ahead adapté au workload
Checklist déploiement RAID
✅ Installation :
- mdadm installé
- Disques testés (SMART)
- Partitions créées et alignées
- RAID créé et synchronisé
- Filesystem formaté
✅ Configuration :
- mdadm.conf sauvegardé
- initramfs mis à jour
- fstab configuré avec UUID
- Bitmap activé
- Performance tunée
✅ Monitoring :
- mdmonitor activé
- Email alertes configuré
- Script monitoring custom
- Prometheus node_exporter
- SMART monitoring actif
✅ Procédures :
- Procédure remplacement disque documentée
- Test remplacement à chaud effectué
- Backup régulier configuré
- Recovery testé
Conclusion
Le RAID logiciel Linux avec mdadm offre une solution fiable et performante pour la redondance des données. Le monitoring proactif et des procédures de remplacement bien rodées sont essentiels pour éviter la perte de données.
Points clés :
- RAID 1 : système/boot, simplicité
- RAID 10 : bases de données, performance I/O
- RAID 5/6 : stockage fichiers, bon compromis
- Monitoring automatique obligatoire
- Remplacer disques proactivement (SMART)
Gains typiques :
- Disponibilité : 99.9%+ (tolérance panne)
- Performance : +50-200% vs disque seul
- Coût : -60% vs RAID matériel
- Flexibilité : migration/extension facile
Actions prioritaires :
- Choisir niveau RAID adapté
- Configurer monitoring + alertes
- Tester procédure remplacement
- Documenter pour l'équipe
- Backup régulier (RAID ≠ backup)
