pteuz Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
=======Le RAID logiciel sous Linux=======

Le RAID est un mécanisme de gestion de unités de stockage, qui peut être matériel (via une carte dédiée) ou logiciel (géré par le système d'exploitation ou un driver). Il existe différents type de RAID (0, 1, 5, etc) qui déterminent chacun un mode de gestion. Je ne m'attarde pas là dessus, pour plus d'info, aller voir [[http://fr.wikipedia.org/wiki/RAID_(informatique)|wikipédia : le RAID]].

Avant de le mettre en place, se renseigner sur quel type de RAID est adapté à notre besoin (en terme de performance, redondance, consommation, etc...). On pourra s'inspirer de [[https://fr.wikipedia.org/wiki/RAID_%28informatique%29|Wikipédia]] et de [[http://wintelguy.com/raidmttdl.pl|RAID Reliability Calculator]] qui permet de calculer les probabilités de perte de donnée en fonction du type de RAID et des caractéristiques des disques choisis.
======Installation de Debian avec RAID0======

Le but de cet article est de décrire la procédure que j'ai utilisée pour installer une Debian Lenny sur 2 disques dur en RAID0 logiciel avec Linux Software RAID. Mes motivations sont :
  * pas de perte d'espace disque
  * tirer parti des performances maximale avec mon matériel (disques et CPU/carte mère)
  * un RAID logiciel car je n'ai pas de contrôleur RAID matériel

Le RAID0 ne permet pas de redondance ni de récupération des données en cas de crash disque ; qu'à cela ne tienne je fais de la synchronisation régulièrement.

J'ai suivi la doc disponible sur ubuntu-fr : [[http://doc.ubuntu-fr.org/tutoriel/comment_installer_ubuntu_sur_raid0_logiciel|Comment installer ubuntu sur RAID 0]]

Situation actuelle :
  * 2 disques durs SATA de 1 To chacun

Voici ce que je veux faire :
  * une partition de swap de 1Go
  * un /boot de 1Go aussi
  * un / de 6Go
  * le reste dans /data

Voici le résultat du partitionnement de mes disques (GB = Go) :
  /dev/sda
    /dev/sda1 de 1GB   (swap)
    /dev/sda2 de 3GB   (RAID) -> la moitié du futur /
    /dev/sda3 de 996GB (RAID) -> la moitié du futur /data
  /dev/sdb
    /dev/sdb1 de 1GB   (ext3) -> /boot (penser à sélectionner "indicateur d'amorçage : présent")
    /dev/sdb2 de 3GB   (RAID) -> l'autre moitié du futur /
    /dev/sdb3 de 996GB (RAID) -> l'autre moitié du futur /data

Je vais ensuite créer 2 volumes RAID0 avec l'installateur Debian :
  * /dev/sda2 et /dev/sdb2 qui formeront le volume /dev/md0
  * /dev/sda3 et /dev/sdb3 qui formeront le volume /dev/md1

NB : La partition /boot ne peut pas être créée sur du raid logiciel pour pouvoir booter dessus ; mais cela ne pose pas de problème de performance car elle n'est plus utilisée une fois la machine bootée.


======Création d'un RAID1======
//à la main//

Lister les disques et partitions sur la machine (on doit être root sinon ça n'affiche rien, même pas un message d'erreur) :
<code>
sudo fdisk -l | grep Disque
 Disque /dev/sda: 6442 Mo, 6442450944 octets
 Disque /dev/sdc: 1073 Mo, 1073741824 octets
 Disque /dev/sdb: 1073 Mo, 1073741824 octets
</code>

On va faire un RAID1 avec les disques /dev/sd{c,d} = on doit créer 2 partitions primaires de type "fd" (Linux raid auto) sur tout l'espace de chaque disque.

=> Cela nous donne donc /dev/sdb1 et /dev/sdc1 2 partitions d'environs 1 gigaoctet chacune.


Créer un volume RAID1 ; y rattacher les 2 partitions de 1 Go
<code>
mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sd{b,c}1

cat /proc/mdstat 
Personalities : [raid1] 
md0 : active raid1 sdb1[0] sdc1[1]
      1044096 blocks [2/2] [UU]
      
unused devices: <none>
</code>

On déclare un disque en erreur ("faulty")
<code>
mdadm /dev/md0 --fail /dev/sdb1

cat /proc/mdstat 
Personalities : [raid1] 
md0 : active raid1 sdc1[1] sdb1[2](F)
      1044096 blocks [2/1] [_U]
      
unused devices: <none>
</code>

On retire les disques défectueux du volume RAID
<code>
mdadm /dev/md0 --remove failed

cat /proc/mdstat 
Personalities : [raid1] 
md0 : active raid1 sdc1[1]
      1044096 blocks [2/1] [_U]
      
unused devices: <none>
</code>

On ajoute un nouveau disque dans le RAID = le nouveau disque se resynchronise
<code>
mdadm /dev/md0 --add /dev/sdb1

cat /proc/mdstat 
Personalities : [raid1] 
md0 : active raid1 sdb1[2] sdc1[1]
      1044096 blocks [2/1] [_U]
      [=>...................]  recovery =  8.7% (91776/1044096) finish=0.3min speed=45888K/sec
      
unused devices: <none>
</code>

Puis on formate la nouvelle partition RAID (/dev/md0 en ext3 :
<code>
mke2fs -T ext3 /dev/md0
</code>

Automatisation du montage :
<code>
vi /etc/fstab
 /dev/md0       /mnt/RAID1      ext3    defaults        1 0
</code>

======Divers======

=====Créer un volume RAID1 avec un seul disque=====
Il s'agit ici de créer un RAID 1 avec un seul disque, donc un RAID en défaut (pas de réplication de données mais la machine fonctionne toujours). Cela permet par exemple de préparer une machine avec un seul disque en attendant la livraison du second.

<code>
mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sda1 missing
</code>

-> On créer /dev/md0 en RAID1 en utilisant 2 partitions : /dev/sda1 et une qui manque en temps normal c'est plus utile d'utiliser une 2nde partition


======Création d'un raid5 + LVM======

=====Volume RAID 5=====

Un raid0 avec de la redondance pour la sécurité des données ? C'est un **raid5** et c'est ce que je vais réaliser sur mon NAS (malgré qu'il ne soit doté que d'un processeur [[http://fr.wikipedia.org/wiki/Intel_Atom#Pineview|atom n550]], un processeur un peu léger pour du calcul de parité).

Première chose : repérer les noms des disques :
<code bash>
sudo fdisk -l | grep Disk
Disk /dev/sda: 64.0 GB, 64023257088 bytes
Disk /dev/sdb: 2000.4 GB, 2000398934016 bytes
Disk /dev/sdc: 2000.4 GB, 2000398934016 bytes
Disk /dev/sdd: 2000.4 GB, 2000398934016 bytes
</code>
Dans mon cas je vais utiliser /dev/sdb, /dev/sdc et /dev/sdd pour mon RAID 5.

Puis, créer des partitions de type "Raid auto detect" (**code : fd**) et de même taille sur tous les disques avec **fdisk** : (NB : l'exemple ci-dessous est réalisé avec un disque de 3 To mais le principe est le même)

<code bash>
sudo fdisk /dev/sdd
Le périphérique ne contient pas une table de partitions DOS ou Sun, SGI, OSF valable
Création d'une nouvelle étiquette DOS avec id de disque 0x7b3be7ec.
Les modifications restent en mémoire jusqu'à ce que vous les écriviez.
Après quoi, bien sûr, le contenu précédent sera irrécupérable.

Avertissement : drapeau 0x0000 non valable dans la table de partitions 4, sera corrigé par w(écriture)

Attention : la taille du disque est 3.0 To (3000592982016 octets).
Ce format de table de partitions DOS ne peut pas être utilisé
sur des disques pour des volumes plus grand (2199023255040 octets) et
secteurs de 512 octets. Utiliser parted(1) et le format de table
de partitions à GUID (GPT).


Le périphérique dispose d'une taille de secteur logique plus
petite que la taille de secteur physique. Ajuster la limite de
taille à celle de secteur physique (ou optimale en terme d'E/S)
est conseillé, sinon les performances risquent d'être affectées.

Commande (m pour l'aide): n
Partition type:
   p   primary (0 primary, 0 extended, 4 free)
   e   extended
Select (default p): p
Numéro de partition (1-4, par défaut 1):
Utilisation de la valeur par défaut 1
Premier secteur (2048-4294967295, par défaut 2048):
Utilisation de la valeur par défaut 2048
Dernier secteur, +secteurs or +taille{K,M,G} (2048-4294967294, par défaut 4294967294):
Utilisation de la valeur par défaut 4294967294

Commande (m pour l'aide): t
Partition sélectionnée 1
Code Hexa (taper L pour lister les codes): fd
Type système de partition modifié de 1 à fd (RAID Linux autodétecté)

Commande (m pour l'aide): w
La table de partitions a été altérée !

Appel de ioctl() pour relire la table de partitions.
Synchronisation des disques.
</code>

Créez le RAID :
<code bash>
mdadm --create --verbose /dev/md0 --level=5 --raid-devices=3 --assume-clean /dev/sd[bcd]1
</code>

Si vous obtenez l'erreur suivante :
<code bash>
mdadm: layout defaults to left-symmetric
mdadm: layout defaults to left-symmetric
mdadm: chunk size defaults to 512K
mdadm: cannot open /dev/sdc1: No such file or directory
</code>
... recréez les partition avec **cfdisk** plutôt que fdisk !

Après avoir créés les partitions j'obtiens une erreur !
<code bash>
mdadm --create --verbose /dev/md0 --level 5 --assume-clean --raid-devices=3 /dev/sdb1 /dev/sdc1 /dev/sdd1
mdadm: layout defaults to left-symmetric
mdadm: layout defaults to left-symmetric
mdadm: chunk size defaults to 512K
mdadm: super1.x cannot open /dev/sdc1: Device or resource busy
mdadm: /dev/sdc1 is not suitable for this array.
mdadm: super1.x cannot open /dev/sdd1: Device or resource busy
mdadm: /dev/sdd1 is not suitable for this array.
mdadm: create aborted
</code>

D'après http://www.righteoushack.net/?p=197 il pourrait s'agir d'un reliquat de bug lié aux drivers d'un fake-raid (configuré dans le BIOS) ; je teste :
<code bash>
sudo aptitude remove dmraid
</code>

... mais toujours le même problème :(

N'ayant rien à perdre je décide de passer la prise en charge des disques SATA dans le BIOS en "AHCI" plutôt que "IDE enhanced" comme auparavant. Normalement les disques SATA doivent toujours être configurés en AHCI car cela permet la prise en charge du NCQ et autres, mais il me semble que lorsqu'on créer un RAID software cela est générateur de problème. Mais au point où j'en suis..

Au reboot, les disques ont été renumérotés :
<code bash>
sudo fdisk -l | grep Disk
Disk /dev/sda: 2000.4 GB, 2000398934016 bytes
Disk /dev/sdb: 2000.4 GB, 2000398934016 bytes
Disk /dev/sdc: 64.0 GB, 64023257088 bytes
Disk /dev/sdd: 2000.4 GB, 2000398934016 bytes
</code>

<code bash>
# Création du raid 5 avec 3 partitions : /dev/sda1 /dev/sdb1 /dev/sdd1
# --assume-clean permet d'éviter le calcul de parité à la création
mdadm --create --verbose /dev/md0 --level 5 --assume-clean --raid-devices=3 /dev/sd[abd]1
mdadm: layout defaults to left-symmetric
mdadm: layout defaults to left-symmetric
mdadm: chunk size defaults to 512K
mdadm: /dev/sdb1 appears to be part of a raid array:
    level=raid5 devices=3 ctime=Thu Sep  6 23:40:51 2012
mdadm: size set to 1953381888K
Continue creating array? y
mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md0 started.
</code>

Rofl ! It works !

Il faut attendre un peu le temps de la construction du raid, puis on vérifie :
<code bash>
 sudo mdadm --detail /dev/md0
/dev/md0:
        Version : 1.2
  Creation Time : Wed Sep 12 21:35:52 2012
     Raid Level : raid5
     Array Size : 3906763776 (3725.78 GiB 4000.53 GB)
  Used Dev Size : 1953381888 (1862.89 GiB 2000.26 GB)
   Raid Devices : 3
  Total Devices : 3
    Persistence : Superblock is persistent

    Update Time : Thu Sep 13 18:00:13 2012
          State : clean
 Active Devices : 3
Working Devices : 3
 Failed Devices : 0
  Spare Devices : 0

         Layout : left-symmetric
     Chunk Size : 512K

           Name : ymir2:0  (local to host ymir2)
           UUID : 5766333b:7721932e:a40ebe2e:0c6fe1d0
         Events : 2

    Number   Major   Minor   RaidDevice State
       0       8        1        0      active sync   /dev/sda1
       1       8       17        1      active sync   /dev/sdb1
       2       8       49        2      active sync   /dev/sdd1


# ou :
cat /proc/mdstat
Personalities : [raid6] [raid5] [raid4] [linear] [multipath] [raid0] [raid1] [raid10]
md0 : active raid5 sdd1[2] sdb1[1] sda1[0]
      3906763776 blocks super 1.2 level 5, 512k chunk, algorithm 2 [3/3] [UUU]

unused devices: <none>
</code>

----

Dans le première commande on pourrait tilter sur la ligne :
<code bash>
     Array Size : 3907020800 (3726.03 GiB 4000.79 GB)
</code>

3726.03 GiB alors que je devrait avoir 4 To ? WTF !!

====Rappel sur les unités====

  * 8 bits = 1 octet (byte en anglais : un octet et one byte c'est pareil !). Les abréviations respectives sont b (bit), o (octet) et B (byte).
  * 1 kB = 1 ko = 1000 octets (bytes). Dans la même logique, 1 MB vaut 1000 kB, 1 GB vaut 1000 MB, etc... : **ce sont des puissances de 10** : 1000 c'est 10^3.
  * 1 KiB vaut, lui, 1024 octets (bytes). Dans la même logique, 1 KiB = 1024 B, 1 MiB vaut 1024 KiB, 1 GiB vaut 1024 MiB, etc... **ce sont des puissances de 2** (normal pour de l'informatique) : 1024 c'est 2^10.

<WRAP center round info 80%>
Les //X//i se prononcent kibi (Ki), mébi (Mi), etc...
</WRAP>

<WRAP center round info 80%>
Les abréviations des kilos sont "k" pour les puissances de 10 et "Ki" pour les puissances de 2. C'est exprès, pour qu'on confonde.
</WRAP>

Autant la première notation (B, kB, MB...) est assez classique et facile à calculer :
<code>
1 GB = 10^3 MB = 10^6 kB = 10^9 B = 1 000 000 000 bytes
</code>
... autant la seconde n'est pas naturelle (pour les hommes en tout cas) :
<code>
1 GiB = 2^10 MiB = 2^20 KiB = 2^30 B soit 1 073 741 824 bytes
</code>
Ce qui nous amène à la conclusion : 1 GiB "vaut plus" que 1GB. (c'est pour ça que les vendeurs de disques dur comptent en GB, ça gonfle les capacités :) ). Mais les ordinateurs, eux, comptent en puissance de 2, en //X//iB (kilo, méga, giga, etc...). Donc un disque dur de 1 To (1 TB) acheté dans le commerce ne fait que : ''10^12 / 2^40 = 0.909 TiB''

Voici la table de conversion entre //X//B et //X//iB :
<code>
1 TB = 10^12 o => 0.909 TiB
1 GB = 10^9  o => 0.931 GiB
1 MB = 10^6  o => 0.954 MiB
1 KB = 10^3  o => 0.977 KiB

1 TiB = 2^40 o => 1.100 TB
1 GiB = 2^30 o => 1.074 GB
1 MiB = 2^20 o => 1.049 MB
1 KiB = 2^10 o => 1.024 kB
</code>

Pour finir la parenthèse, dans mon cas j'ai mon raid5 de 3 x 2 To ; ça donne 4 To de capacité utile, donc 4 x 0.909 = 3.6380 TiB (arrondi) = 3725 GiB : le compte est bon (mais pas à mon avantage).

source : entre autres [[http://fr.wikipedia.org/wiki/Pr%C3%A9fixe_binaire|préfixe binaire]] sur Wikipédia.


----


Une fois le raid construit, si tout va bien, il faudra le monter automatiquement au démarrage la prochaine fois ; commenter la ligne "ARRAY xxx" dans le fichier ''/etc/mdadm/mdadm.conf'' et ajouter le résultat de la commande :
<code bash>
mdadm --detail --scan >> /etc/mdadm/mdadm.conf

# PI le résultat de la commande :
ARRAY /dev/md0 metadata=1.2 name=ymir2:0 UUID=5766333b:7721932e:a40ebe2e:0c6fe1d0
</code>

=====Raid en vrac au reboot=====

Sous Ubuntu 10.10 cette fois j'ai rencontré un problème lors du reboot car il me montait /dev/md avec 2 disques et /dev/md_d0 avec le dernier. Hideux. Même en retouchant le mdadm.conf celà n'a rien changé. Je suis alors tombé sur [[http://ubuntuforums.org/showpost.php?p=7424082&postcount=11|ce post sur ubuntuforums]] qui décrit cette procédure qui a résolu mon problème : 
<code bash>
# arrêt du raid triso
mdadm --stop /dev/md_d0
 mdadm: metadata format 00.90 unknown, ignored.
 mdadm: stopped /dev/md_d0

mdadm --auto-detect

/usr/share/mdadm/mkconf force-generate /etc/mdadm/mdadm.conf

update-initramfs -u
 update-initramfs: Generating /boot/initrd.img-2.6.35-25-generic

# puis on reboot
init 6
</code>

Au redémarrage le volume RAID est monté correctement \o/.

====D'autres pistes====

<code bash>
cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md126 : inactive sdc[1]
      1953514496 blocks

md127 : active (auto-read-only) raid5 sdd[2] sdb[0]
      3907028992 blocks level 5, 64k chunk, algorithm 2 [3/2] [U_U]

unused devices: <none>
</code>

<code bash>
mdadm --examine /dev/sdb1
/dev/sdb1:
          Magic : a92b4efc
        Version : 0.90.00
           UUID : cc5892bf:a52da5c0:2ddc0efe:cce42a60 (local to host ymir2)
  Creation Time : Fri Aug 19 18:22:07 2011
     Raid Level : raid5
  Used Dev Size : 1953511936 (1863.01 GiB 2000.40 GB)
     Array Size : 3907023872 (3726.03 GiB 4000.79 GB)
   Raid Devices : 3
  Total Devices : 3
Preferred Minor : 0

    Update Time : Thu Nov 17 19:32:24 2011
          State : clean
 Active Devices : 3
Working Devices : 3
 Failed Devices : 0
  Spare Devices : 0
       Checksum : 26f6dd32 - correct
         Events : 39

         Layout : left-symmetric
     Chunk Size : 64K

      Number   Major   Minor   RaidDevice State
this     0       8       17        0      active sync   /dev/sdb1

   0     0       8       17        0      active sync   /dev/sdb1
   1     1       8       33        1      active sync   /dev/sdc1
   2     2       8       49        2      active sync   /dev/sdd1

mdadm --examine /dev/sdc1
/dev/sdc1:
          Magic : a92b4efc
        Version : 0.90.00
           UUID : cc5892bf:a52da5c0:2ddc0efe:cce42a60 (local to host ymir2)
  Creation Time : Fri Aug 19 18:22:07 2011
     Raid Level : raid5
  Used Dev Size : 1953511936 (1863.01 GiB 2000.40 GB)
     Array Size : 3907023872 (3726.03 GiB 4000.79 GB)
   Raid Devices : 3
  Total Devices : 3
Preferred Minor : 0

    Update Time : Thu Nov 17 19:32:24 2011
          State : clean
 Active Devices : 3
Working Devices : 3
 Failed Devices : 0
  Spare Devices : 0
       Checksum : 26f6dd44 - correct
         Events : 39

         Layout : left-symmetric
     Chunk Size : 64K

      Number   Major   Minor   RaidDevice State
this     1       8       33        1      active sync   /dev/sdc1

   0     0       8       17        0      active sync   /dev/sdb1
   1     1       8       33        1      active sync   /dev/sdc1
   2     2       8       49        2      active sync   /dev/sdd1

mdadm --examine /dev/sdd1
/dev/sdd1:
          Magic : a92b4efc
        Version : 0.90.00
           UUID : cc5892bf:a52da5c0:2ddc0efe:cce42a60 (local to host ymir2)
  Creation Time : Fri Aug 19 18:22:07 2011
     Raid Level : raid5
  Used Dev Size : 1953511936 (1863.01 GiB 2000.40 GB)
     Array Size : 3907023872 (3726.03 GiB 4000.79 GB)
   Raid Devices : 3
  Total Devices : 3
Preferred Minor : 0

    Update Time : Thu Nov 17 19:32:24 2011
          State : clean
 Active Devices : 3
Working Devices : 3
 Failed Devices : 0
  Spare Devices : 0
       Checksum : 26f6dd56 - correct
         Events : 39

         Layout : left-symmetric
     Chunk Size : 64K

      Number   Major   Minor   RaidDevice State
this     2       8       49        2      active sync   /dev/sdd1

   0     0       8       17        0      active sync   /dev/sdb1
   1     1       8       33        1      active sync   /dev/sdc1
   2     2       8       49        2      active sync   /dev/sdd1
</code>

<code bash>
egrep -v "^$|^#" /etc/mdadm/mdadm.conf
DEVICE partitions
CREATE owner=root group=disk mode=0660 auto=yes
HOMEHOST <system>
MAILADDR root
ARRAY /dev/md0 level=raid5 num-devices=3 metadata=0.90 UUID=cc5892bf:a52da5c0:2ddc0efe:cce42a60
   devices=/dev/sdb1,/dev/sdc1,/dev/sdd1
</code>

<code bash>
mdadm --detail --scan
ARRAY /dev/md/0_0 metadata=0.90 UUID=c50da923:2bb088ef:2ddc0efe:cce42a60
ARRAY /dev/md/0_1 metadata=0.90 UUID=cb278753:2d171315:2ddc0efe:cce42a60
</code>

<code bash>
mdadm --stop /dev/md126
 mdadm: stopped /dev/md126
mdadm --stop /dev/md127
 mdadm: stopped /dev/md127
mdadm --assemble /dev/md0
 mdadm: /dev/md0 has been started with 3 drives.
</code>

<code bash>
mdadm --detail --scan
ARRAY /dev/md0 metadata=0.90 UUID=cc5892bf:a52da5c0:2ddc0efe:cce42a60
</code>

<code bash>
cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md0 : active raid5 sdb1[0] sdd1[2] sdc1[1]
      3907023872 blocks level 5, 64k chunk, algorithm 2 [3/3] [UUU]

unused devices: <none>
</code>


=====LVM=====

Création du bousin LVM : déclaration dans l'ordre :
  * d'un volume physique (pv) de 4 To (le raid5)
  * d'un groupe de volume (vg) : on ajoute le pv de 4 To qui sera seul dans son groupe
  * d'un volume logique (lv) : on déclare une partition de 2 To dans le vg de 4 To (on pourra le redimensionner plus tard).
<code bash>
pvcreate /dev/md0
vgcreate md0_vg /dev/md0
lvcreate -L 2T -n data_lv md0_vg
</code>

Puis on traite ''/dev/md0_vg/data_lv'' comme avec une partition classique :
<code bash>
# formatage en ext4 avec des paramètres optimisés pour le raid..
#(source : http://planet.ubuntu-fr.org/post/2007/10/13/mdadm-raid5)
mkfs.ext4 -m 0 -b 4096 -R stride=8 /dev/md0_vg/data_lv

# montage automatique au démarrage :
echo "/dev/md0_vg/data_lv /mnt/data ext4 defaults 0 1" >> /etc/fstab

# montage
mkdir /mnt/data
mount /mnt/data
</code>

Vérifications : afficher les résumés des volumes physiques, des groupes de volumes et des volumes logiques :
<code bash>
pvs
  PV         VG     Fmt  Attr PSize  PFree
  /dev/md0   md0_vg lvm2 a-    3,64t    0
  /dev/sda5  ymir2  lvm2 a-   59,38g    0

vgs
  VG     #PV #LV #SN Attr   VSize  VFree
  md0_vg   1   1   0 wz--n-  3,64t    0
  ymir2    1   2   0 wz--n- 59,38g    0

lvs
  LV      VG     Attr   LSize  Origin Snap%  Move Log Copy%  Convert
  data_lv md0_vg -wi-ao  3,64t
  root    ymir2  -wi-ao 56,91g
  swap_1  ymir2  -wi-ao  2,47g
</code>

======Management du raid======

=====Monitorer son RAID=====

<WRAP center round important 60%>
Attention les commandes qui vont suivre ne proviennent pas toutes du même RAID !
</WRAP>

<code>
cat /proc/mdstat 
 Personalities : [raid0] 
 md1 : active raid0 sda3[0] sdb3[1]
       1945696256 blocks 64k chunks
       
 md0 : active raid0 sda2[0] sdb2[1]
       5863552 blocks 64k chunks
       
 unused devices: <none>
</code>

On peut avoir plus de détails avec :
<code>
mdadm --detail /dev/md1
    /dev/md1:
         Version : 00.90
   Creation Time : Sat Feb  7 12:49:57 2009
      Raid Level : raid0
      Array Size : 1945696256 (1855.56 GiB 1992.39 GB)
    Raid Devices : 2
   Total Devices : 2
 Preferred Minor : 1
     Persistence : Superblock is persistent
 
     Update Time : Tue Feb 10 20:31:42 2009
           State : clean
  Active Devices : 2
 Working Devices : 2
  Failed Devices : 0
   Spare Devices : 0
 
      Chunk Size : 64K
  
            UUID : 9695e8d2:87d83bd5:e070d1d4:842cdf7e
          Events : 0.5
  
     Number   Major   Minor   RaidDevice State
        0       8        3        0      active sync   /dev/sda3
        1       8       19        1      active sync   /dev/sdb3
</code>

Arrêter/Supprimer le raid :
<code bash>
mdadm --stop /dev/md0
 mdadm: stopped /dev/md0
</code>

Supprimer et ajouter un disque dans une grappe raid :
<code bash>
mdadm --manage --remove /dev/md0 /dev/sdd1
 mdadm: hot removed /dev/sdd1 from /dev/md0

mdadm --manage --add /dev/md0 /dev/sdd1
 mdadm: re-added /dev/sdd1
</code>

Vérifications :
<code>
mdadm --detail /dev/md0

mdadm --detail --scan --verbose
</code>


======Augmenter un RAID + LVM======

Récemment j'ai ajouté un disque de 2 To à mon RAID 5 de 3x 2 To déjà en place. Voici la procédure que j'ai employée, elle se découpe en 2 étapes :
  * augmenter le RAID
  * augmenter le LV

=====Augmenter le RAID=====

Bien sur ce nouveau disque disque a la même taille que les disques déjà inclus dans le RAID. Je créé une partition de type "fd" (Linux RAID auto) de taille max avec fdisk (en somme, exactement pareil que les autres disques) :

<code bash>
Disk /dev/sdc: 2000.4 GB, 2000398934016 bytes
81 têtes, 63 secteurs/piste, 765633 cylindres, total 3907029168 secteurs
Unités = secteurs de 1 * 512 = 512 octets
Taille de secteur (logique / physique) : 512 octets / 512 octets
taille d'E/S (minimale / optimale) : 512 octets / 512 octets
Identifiant de disque : 0x720b8114

Périphérique Amorce  Début        Fin      Blocs     Id  Système
/dev/sdc1            2048  3907029167  1953513560   fd  RAID Linux autodétecté
</code>

Puis on ajoute le disque à la grappe :
<code bash>
mdadm /dev/md0 -a /dev/sdc1
</code>

Et enfin on augmente le nombre de disque à notre RAID. **Attention** cette étape va automatiquement lancer la resynchronisation du RAID, qui prend beaucoup de temps et ne supporte pas d'arrêt ou de redémarrage électrique (sous peine de perdre vos données).
<code bash>
mdadm --grow /dev/md0 --raid-device=4
mdadm: Need to backup 3072K of critical section..
</code>

<WRAP center round important 80%>
Ne faites pas comme moi qui ai lancé cette commande à peine 3h avant une coupure électrique programmée... D'ailleurs à ce propos (et pour info), en fait on peut arrêter la machine (et donc la synchro) passé un certain temps, le mdadm doit juste passer la section critique (!). Moi les 3h ont suffit, et en rallumant le bousin le lendemain le gentil RAID a poursuivi sa synchronisation comme si de rien n'était !
</WRAP>

Vérification de l'état d'avancement :
<code bash>
cat /proc/mdstat
Personalities : [raid6] [raid5] [raid4] [linear] [multipath] [raid0] [raid1] [raid10]
md0 : active raid5 sdc1[3] sdd1[2] sdb1[1] sda1[0]
      3906763776 blocks super 1.2 level 5, 512k chunk, algorithm 2 [4/4] [UUUU]
      [>....................]  reshape =  0.1% (3267072/1953381888) finish=1624.4min speed=20007K/sec
</code>

Une fois la synchro terminée (soit environ <del>28</del> 2 jours plus tard...) mdadm affiche enfin une taille digne de son rang : 6 To !
<code bash>
mdadm --detail /dev/md0

/dev/md0:
        Version : 1.2
  Creation Time : Wed Sep 12 21:35:52 2012
     Raid Level : raid5
     Array Size : 5860145664 (5588.67 GiB 6000.79 GB)
  Used Dev Size : 1953381888 (1862.89 GiB 2000.26 GB)
   Raid Devices : 4
  Total Devices : 4
    Persistence : Superblock is persistent

    Update Time : Tue Feb 19 06:03:31 2013
          State : clean
 Active Devices : 4
Working Devices : 4
 Failed Devices : 0
  Spare Devices : 0

         Layout : left-symmetric
     Chunk Size : 512K

           Name : ymir2:0  (local to host ymir2)
           UUID : 5766333b:7721932e:a40ebe2e:0c6fe1d0
         Events : 14151

    Number   Major   Minor   RaidDevice State
       0       8        1        0      active sync   /dev/sda1
       1       8       17        1      active sync   /dev/sdb1
       2       8       49        2      active sync   /dev/sdd1
       3       8       33        3      active sync   /dev/sdc1
</code>

C'est déjà bien mais c'est pô fini ; il faut maintenant le dire à LVM !

=====Prise en compte par LVM=====

1) Première chose : Démonter le volume logique (NB : cette étape n'est pas obligatoire avec le système de fichier que j'utilise (ext4), mais vu que mon serveur n'est pas en prod ça ne me coûte pas plus cher) :
<code bash>
umount /dev/md0_vg/data_lv
</code>

2) Augmenter la taille du pv :
<code bash>
pvresize /dev/md0
  Physical volume "/dev/md0" changed
  1 physical volume(s) resized / 0 physical volume(s) not resized

# vérif : c'est mieux !
pvdisplay
  --- Physical volume ---
  PV Name               /dev/md0
  VG Name               md0_vg
  PV Size               5,46 TiB / not usable 1,50 MiB
  Allocatable           yes (but full)
  PE Size               4,00 MiB
  Total PE              1430699
  Free PE               0
  Allocated PE          1430699
  PV UUID               Cy7Zxe-Src9-5hQi-QQ0W-waMI-yv3V-mECzi8
  
# le vg en tient compte immédiatement :
vgdisplay
  --- Volume group ---
  VG Name               md0_vg
  System ID
  Format                lvm2
  Metadata Areas        1
  Metadata Sequence No  5
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                1
  Open LV               0
  Max PV                0
  Cur PV                1
  Act PV                1
  VG Size               5,46 TiB
  PE Size               4,00 MiB
  Total PE              1430699
  Alloc PE / Size       1430699 / 5,46 TiB
  Free  PE / Size       0 / 0
  VG UUID               AEKER3-SOwc-zwSQ-rR4J-iJw0-IxlI-qP2hd6
</code>

3) Augmenter la taille du lv ; attention sa taille ne doit pas dépasser la taille de son volume group (vg), ni être inférieur sa taille actuelle (sinon on perd des données).

On pourrait déclarer une nouvelle taille de 5,46 TiB (''-L 3.64T''), ou même ajouter 1.64 To (''-L +1.64T''), mais on veut la taille totale du vg donc on va être précis et utiliser l'option ''-l +100%FREE'' qui indique qu'on ajoute toute la place libre restante du vg :
<code bash>
lvresize -l +100%FREE /dev/md0_vg/data_lv
  Extending logical volume data_lv to 5,46 TiB
  Logical volume data_lv successfully resized
</code>

4) On doit ensuite vérifier l'intégrité du volume logique :
<code bash>e2fsck -f /dev/md0_vg/data_lv
 e2fsck 1.42 (29-Nov-2011)
 Passe 1 : vérification des i-noeuds, des blocs et des tailles
 Passe 2 : vérification de la structure des répertoires
 Passe 3 : vérification de la connectivité des répertoires
 Passe 4 : vérification des compteurs de référence
 Passe 5 : vérification de l'information du sommaire de groupe
 /dev/md0_vg/data_lv : 287397/244178944 fichiers (1.0% non contigüs), 950095488/976689152 blocs
</code>

Puis on étend le système de fichier :
<code bash>
resize2fs /dev/md0_vg/data_lv
 resize2fs 1.42 (29-Nov-2011)
 En train de redimensionner le système de fichiers sur /dev/md0_vg/data_lv à 1465035776 (4k) blocs.
 Le système de fichiers /dev/md0_vg/data_lv a maintenant une taille de 1465035776 blocs.
</code>

... et on remonte le lv :
<code bash>
mount /dev/md0_vg/data_lv

df -hT /mnt/data
Sys. de fichiers           Type Taille Utilisé Dispo Uti% Monté sur
/dev/mapper/md0_vg-data_lv ext4   5,4T    3,5T  1,9T  65% /mnt/data
</code>

Okaaaay !

======Tests et benchmarks======

Je vais comparer ici mon ex raid0 avec mon précédent raid5 (sic). Attention il y a beaucoup de paramètres qui changent donc ces tests ne sont pas très "scientifiques", mais ils donnent un ordre d'idée.

Le raid0 est sur le serveur ymir :
  * raid0 de 2x HDD Samsung Spinpoint F1 1 To (7200 rpm, 32 Mo de cache)
  * le système est installé sur ces disques donc ils ne sont pas idle pendant les tests
  * la partition est formatée en ext3 avec les réglages par défaut

Le raid5 est sur le serveur ymir2 :
  * raid5 de 3x HDD Samsung EcoGreen F4 2 To (5400 rpm, 32 Mo de cache)
  * le raid est monté sur des disques complètement idle, le système étant installé sur un autre disque (un SSD OCZ Vertex 60 Go)
  * la partition est formatée en ext2 avec les réglages indiqués plus haut


=====Test en écriture=====

====A l'ancienne avec dd====

J'utilise ici la commande ''dd'' pour créer un ficher de 1 Go et le remplir de 0.

sur ymir2 :
<code bash>
# raid5
dd if=/dev/zero of=/mnt/data/test.data bs=8k count=128k
131072+0 enregistrements lus
131072+0 enregistrements écrits
1073741824 octets (1,1 GB) copiés, 12,3638 s, 86,8 MB/s

# à titre comparatif, sur le SSD
dd if=/dev/zero of=/tmp/test.data bs=8k count=128k
131072+0 enregistrements lus
131072+0 enregistrements écrits
1073741824 octets (1,1 GB) copiés, 6,25596 s, 172 MB/s
</code>

sur ymir :
<code bash>
# raid0
dd if=/dev/zero of=/mnt/data/tmp/test.data bs=8k count=128k
131072+0 enregistrements lus
131072+0 enregistrements écrits
1073741824 bytes (1,1 GB) copied, 8,66769 s, 124 MB/s
</code>

De ces valeurs on peut retenir une chose : l'écriture sur un raid5 nécessite un lourd calcul de parité qui surcharge clairement le processeur (atom n550 pour ceux qui ne suivent pas :)). Mais ça reste jouable vu qu'il a 2 cores + l'[[http://fr.wikipedia.org/wiki/Hyper_threading|hyper threading]] (ça laisse de la place pour les autres processus).

=====Test en lecture=====

====Avec hdparm====
sur ymir2 :
<code bash>
# raid5
hdparm -t -T /dev/md0
/dev/md0:
 Timing cached reads:   1426 MB in  2.00 seconds = 712.86 MB/sec
 Timing buffered disk reads: 600 MB in  3.01 seconds = 199.55 MB/sec

# SSD
hdparm -t -T /dev/sda
/dev/sda:
 Timing cached reads:   1436 MB in  2.00 seconds = 718.36 MB/sec
 Timing buffered disk reads: 506 MB in  3.01 seconds = 168.26 MB/sec
</code>

sur ymir :
<code bash>
hdparm -t -T /dev/md1
/dev/md1:
 Timing cached reads:   1152 MB in  2.00 seconds = 575.74 MB/sec
 Timing buffered disk reads:  398 MB in  3.01 seconds = 132.34 MB/sec
</code>

====Avec dd====

On réutilise le fichier précédemment créé et on le lis dans le vent (/dev/null) :

sur ymir2 :
<code bash>
# raid5
dd if=/mnt/data/test.data of=/dev/null bs=8k
131072+0 enregistrements lus
131072+0 enregistrements écrits
1073741824 octets (1,1 GB) copiés, 5,23449 s, 205 MB/s

# SSD
dd if=/tmp/test.data of=/dev/null bs=8k
131072+0 enregistrements lus
131072+0 enregistrements écrits
1073741824 octets (1,1 GB) copiés, 4,3989 s, 244 MB/s
</code>

Les valeurs du raid5 sont cohérentes env. 200 MB/s ; ce n'est pas le cas pour le SSD.

Attention : si on refait le "dd" plusieurs fois de suite on risque de calculer la vitesse du cache disque :

<code bash>
# raid5
dd if=/mnt/data/test.data of=/dev/null bs=8k
131072+0 enregistrements lus
131072+0 enregistrements écrits
1073741824 octets (1,1 GB) copiés, 1,00804 s, 1,1 GB/s
</code>

sur ymir :
<code bash>
# raid0
dd if=/mnt/data/tmp/test.data of=/dev/null bs=8k
131072+0 enregistrements lus
131072+0 enregistrements écrits
1073741824 bytes (1,1 GB) copied, 9,06151 s, 118 MB/s
</code>

Étonnant : on a un meilleur débit en écriture qu'en lecture sur ce raid0...


======Test avec bonnie++======

bonnie++ est un logiciel tierce qui mesure les performances d'un disque.


======Suppression totale d'un volume RAID======

Parce que mdadm est coriace, et que la procédure de suppression d'un RAID pour récupérer les disques n'est pas si anodine que cela, voici une petite check-list :

Supprimer les metadata avec dmraid
<code bash>
sudo dmraid -r -E /dev/sdb
no raid disks and with names: "/dev/sdb"

sudo dmraid -r -E /dev/sdc
Do you really want to erase "ddf1" ondisk metadata on /dev/sdc ? [y/n] :y
ERROR: ddf1: seeking device "/dev/sdc" to 1024204253954048
ERROR: writing metadata to /dev/sdc, offset 2000398933504 sectors, size 0 bytes returned 0
ERROR: erasing ondisk metadata on /dev/sdc

sudo dmraid -r -E /dev/sdd
Do you really want to erase "ddf1" ondisk metadata on /dev/sdd ? [y/n] :y
ERROR: ddf1: seeking device "/dev/sdd" to 1024204253954048
ERROR: writing metadata to /dev/sdd, offset 2000398933504 sectors, size 0 bytes returned 0
ERROR: erasing ondisk metadata on /dev/sdd
</code>

Si ça ne marche pas on observe encore :
<code bash>
cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md0 : inactive sdd[0](S) sdb[2](S)
      3907028992 blocks
unused devices: <none>
</code>

<code bash>
umount /dev/md0
mdadm --manage /dev/md0 --stop
mdadm --manage /dev/md0 --remove
rm /etc/mdadm/mdadm.conf
</code>

Suppression de la partition "raid" de chaque disque
<code bash>
sudo fdisk /dev/sdb
d
p
w
</code>

On efface les superblocks :
<code bash>
sudo mdadm --zero-superblock /dev/sdb
sudo mdadm --zero-superblock /dev/sdb1
mdadm: Couldn't open /dev/sdb1 for write - not zeroing
</code>

Cela évite de se retrouver bloquer au boot par le prompt busybox !

Dans mon cas au reboot un nouveau volume raid est apparu tout seul : "md127". Il y a une procédure avec Ubuntu pour l'éradiquer (source : http://ubuntuforums.org/showthread.php?t=1764861%29: ) :
<code bash>
sudo update-initramfs -u
sudo reboot
</code>


======Liens======

  * [[http://doc.ubuntu-fr.org/tutoriel/comment_installer_ubuntu_sur_raid0_logiciel|Comment installer ubuntu sur RAID 0]]
  * [[http://doc.ubuntu-fr.org/raid_logiciel|RAID logiciel]]

  * https://help.ubuntu.com/community/FakeRaidHowto
  * http://doc.ubuntu-fr.org/tutoriel/installation_raid_lvm
  * http://doc.ubuntu-fr.org/lvm
  * http://linux.developpez.com/lvm/
  * http://www.howtoforge.com/software-raid1-grub-boot-debian-etch
  * [[http://www.unixgarden.com/index.php/administration-systeme/la-souplesse-du-raid-logiciel-de-linux#more-1410|La souplesse du RAID logiciel de Linux]] (chez unixgarden.com)