<> = Kurzbeschreibung der Einrichtung eines Software Raids = == Allgemeines == * die Verwendung der raidtools (/etc/raidtab) wurde durch mdadm erweitert/abgelöst * mdadm verwendet folgende Files: /etc/mdadm/mdadm.conf /proc/mdstat == Testumgebung == * Debian 3.1 (sarge) (4.0 etch) * 1 x SCSI Festplatte * 1 x IDE FEstplatte in externem USB Gehäuse * raid1 als Kernelmodul (Bootvorgang via initrd) == Raid 1 anlegen == * notwendige Software besorgen{{{ apt-get install mdadm }}} * debconf mitteilen, dass du Module nutzen moechtest und dass es automatisch beim booten starten soll * im Kernel: "Device Drivers" -> "Multi-Device" -> "Raid support" + "Raid-1" als Modul aktivieren, compilieren und laden * die Module heissen: "md" und "raid1" * diese in "/etc/mkinitrd/modules" eintragen, damit sie automatisch geladen werden * Die Festplatten muessen wahrscheinlich noch konfiguriert werden. Die komplette Partitionstabelle einer bestehenden Platte kopierst du mit folgendem befehl auf eine andere:{{{ $ sfdisk -d /dev/hdx | sfdisk /dev/sdy }}} * das klappt nur einwandfrei bei zwei gleichen Platten * hier von hdx auf sdy (die Namen lauten bei dir auf jeden Fall anders ;) * Mit "hdparm" solltest du noch überprüfen ob udma aktiviert ist. * "mdadm --zero-superblock /dev/hdy1" löscht den Superblock einer Partition (falls diese vorher schon für ein software raid benutzt wurde) * jetzt das Array anlegen:{{{ mdadm --create --verbose /dev/md0 --level=raid1 --raid-devices=2 /dev/hdx1 /dev/sdy1 }}} * falls das Kommando fehlschlägt, weil /dev/md0 nicht existiert, überprüf ob das Modul geladen ist und das Blockdevice existiert:{{{ lsmod | egrep raid ls -l /dev/md0 sudo mknod /dev/md0 b 9 0 ## nur anlegen wenn nicht existent }}} * in /proc/mdstat sollte jetzt ein aktives Diskarray stehen * Wenn du per initrd bootest musst du noch die "/etc/mkinitrd/mkinitrd.conf" verändern. Dazu setzt du "ROOT=/dev/md0" rein (vorher stand dort wahrscheinlich "ROOT=probe"). * mdadm fuer den taeglichen Gebrauch konfigurieren{{{ vi /etc/mdadm/mdadm.conf }}} * z.B. folgende Zeilen reinschreiben: * DEVICE /dev/hdx* * DEVICE /dev/sdy* * ARRAY /dev/md0 devices=/dev/hdx1,/dev/sdy1 * oder aktuelle config auslesen und in datei schreiben: ''mdadm --examine --scan >> /etc/mdadm/mdadm.conf'' * jetzt kannst du mit /dev/md0 wie mit der vorherigen Partition (z.B.: /dev/hdx1) arbeiten, nur das nebenbei alles gespiegelt wird (z.B. auf /dev/sdy1) juchuu = Anwendungsfälle = == hotadd von Platten == * für den Fall, dass das RAID Array nur mit halber Kraft läuft z.B.: [_U] * nachschauen, welche Platte/Partition ausgefallen ist (hier beim RAID "md0") {{{ mdadm --detail /dev/md0 }}} * diese aus dem RAID entfernen (hier ist es hdx1):{{{ mdadm /dev/md0 -r /dev/hdx1 }}} * es können keine aktiven Platten aus dem RAID entfernt werden, willst du eine Platte einfach so aus dem Verbund entfernen, muss diese vorher als "faulty" markiert werden:{{{ mdadm /dev/md0 -f /dev/hdx1 }}} * jetzt die Platte wechseln * anschließend wieder integrieren, ''cat'' zeigt den Fortschritt{{{ mdadm /dev/md0 -a /dev/hdx1 cat /proc/mdstat }}} * nutzen verschiedene RAID Arrays dieselbe Platte so werden sie von mdadm nacheinander synchronisiert, nicht parallel == nichtsynchronisierbares System wieder herstellen == * stell sicher, dass kein prozess auf die raid Partitionen zugreift * stop das RAID Array: {{{ mdadm --stop /dev/md0 }}} * starte die Synchronisation: {{{ mdadm -A -U resync /dev/md0 }}} * nachschauen ob's geklappt hat{{{ cat /proc/mdstat }}} * dort sollte jetzt der Synchronisierungsvorgang angezeigt werden * zum Schluß stehen in eckigen Klammern zwei Us (d.h. die zwei Partitionen sind up&running) [UU] == pending resync == * bei ''resync=PENDING'' den resync sofort erzwingen mit: {{{ mdadm --readwrite /dev/mdX }}} == Platte nach Ausfall wechseln (klonen) == ''Szenario: in einem Software-RAID hängen zwei gleichartige Platten. Eine davon fällt aus und soll durch eine baugleiche ersetzt werden. (sdX & sdY sind die alten Platten, sdZ die neue, sdy fällt aus, sdX wird auf sdZ geklont)'' * Als erstes Backup vom laufenden System machen, falls was schief geht. * alle Partitionen der defekten Platte aus dem Software-RAID entfernen: {{{ mdadm /dev/md0 -f /dev/sdY[1..n] mdadm /dev/md0 -r /dev/sdY[1..n] }}} * Hoch lebe hotplugging - ist eine Platte am SATA2 Controller ausgefallen, dann lässt sich diese leicht im laufenden Betrieb wechseln - einfach die alte abstöpseln und die neue anschließen. * MBR und Partitionstabelle der noch funktionierende Platte auf externen Datenträger sichern: {{{ dd if=/dev/sdX of=/mnt/extern/mbr_sdX bs=512 count=1 sfdisk -d /dev/sdX > /mnt/extern/partitionstabelle_sdX }}} * Beides auf neue Platte übertragen: {{{ dd if=/mnt/extern/mbr_sdX of=/dev/sdZ bs=512 count=63 sfdisk /dev/sdZ < /mnt/extern/partitionstabelle_sdX }}} * Achtung: beim dd sind es meist 63 Sektoren, die auf der neuen Platte überschrieben werden, bis die erste Partition anfängt. Das könnte bei dir anders sein. * falls ''sfdisk -l /dev/sdX; sfdisk -l /dev/sdZ'' zur Not mit ''sfdisk -R /dev/sdd'' den Kernel veranlassen, die neue Partitionstabelle nochmal einzulesen * abschliessend alle Partitionen der neuen Platte jeweils ins RAID einbinden: {{{ mdadm /dev/md0 -a /dev/sdZ[1..n] }}} * das kann dauern ''cat /proc/mdstat'' zeigt den Fortschritt * ggf. /etc/hdparm.conf , /etc/smartd.conf und /etc/munin/plugin-conf.d/munin-node anpassen = Hinweise = * die verwendung der raidtools (und /etc/raidtab) wurde durch mdadm erweitert/abgelöst * das root Dateisystem kann auch gespiegelt werden, dazu muss der kernel beim booten angeblich nur wissen, wie das raid Gerät heisst. * grub: "kernel /boot/vmlinuz... root=/dev/md0 md=0,/dev/hdx1,/dev/sdy1" * für den fall, das ein platte ausgestiegen ist, in der grubconfig noch einen "recovery" eintrag einrichten: "kernel /boot/vmlinuz... root=/dev/md0 md=0,/dev/sdy1" * hat a noch nicht getestet * Die swap Partition kann zwecks besserer Performance im raid0-Modus benutzt werden, allerdings kommt es dann beim Ausfall einer Platte zu Datenverlusten und das System erhängt sich höchst wahrscheinlich. Wer damit leben kann hat schnelleres swapping, ansonsten ist raid1 die sicherere Variante und auch noch etwas performanter als eine normale swap Partition. * https://we.riseup.net/debian/software-raid == Kurzanleitung RAID1 (launoc) == * nicht für root-fs geeignet * wurde auch mit einem existierenden FS getestet * Variablen im 1. Abschnitt anpassen. Den Rest Zeile für Zeile mit C&P abarbeiten. {{{ ## var md=/dev/md0 pd1=/dev/hdc1 ## phys-Disk (Partition) pd2=/dev/hda3 ## phys-Disk mnt=/mnt/tmp ## mount-dir test mdconf=/etc/mdadm/mdadm.conf fstab=/etc/fstab backupdir=/mnt/space ## f. backup $pd1 ## check variables ls -l $md $pd1 $pd2 ## pd sollten annaehernd gleiche Groesse haben. ## wichtig: pd1 <= pd2 fdisk -l | egrep "$pd1|$pd2" df -k $backupdir ## backup dd if=$pd1 | gzip -c > $backupdir/$pd1.dd.gz-`date +%y%m%d` ## create RAID1 mdadm --create $md --level=1 --raid-devices=2 $pd1 missing cat /proc/mdstat ## add 2. pd mdadm $md -a $pd2 ## create/restore fs (optional) # gunzip -c $backupdir/$pd1.dd.gz-`date +%y%m%d` | dd of=$md # mkfs.ext3 $md ## check cat /proc/mdstat mdadm --detail --scan mount -r $md $mnt ls -l $mnt/ umount $mnt dd if=$pd1 bs=1k count=2 | hexdump -C dd if=$pd2 bs=1k count=2 | hexdump -C ## change konfig ls -la $mdconf cp -p $mdconf $mdconf.old [ `grep DEVICE $mdconf | wc -l` -eq 0 ] && echo 'DEVICE /dev/hd*[0-9] /dev/sd*[0-9]' > $mdconf #mdadm --detail --scan >> $mdconf echo "ARRAY $md level=raid1 num-devices=2 devices=$pd1,$pd2" >> $mdconf more $mdconf ## test stop/start mdadm -S $md cat /proc/mdstat mdadm -A -s -a ## /etc/init.d/mdadm-raid start cat /proc/mdstat ## change konfig (final) cp -p $fstab $fstab.old cat $fstab.old | sed "s:$pd1:$md:" > $fstab diff $fstab.old $fstab }}}