Monter un cluster avec kerrighed sur son réseau

Plopinou … encore un article de type « retour d’expérience geek »
Temps : 2h (en compilant le tout avec un AMD 3000+)
Niveau : Noob (faut quand même savoir jouer à WoW le temps de la compil’ qui peut prendre 1 heures)

Le but de cette technique était de recycler quelques PC sur mon réseau et gagner en puissance de calcul avec de vieux AMD 3000+ avec 1Go de ram.

Kerrighed est un cluster de type « Grappe de serveur » qui permet un truc assez sympa, il suffit que l’ensemble des machines du réseau utilisent le kernel modifié (un 2.6.20 obligatoire …) pour que l’ensemble de ces machines puissent être emulées comme une seul machine SMP partageant donc le CPU et la RAM des machines, assez sympa pour des logiciels qui bouffent de la ram et du cpu (genre firefox ?? xD).

Le gros intéret de ce type de réseaux face à des solutions comme les systèmes MPI est qu’il n’y a pas besoin d’avoir des logiciels spécifique qui utilisent l’interface en question, ici la plupart des softs qui peuvent tourner sur du kernel SMP (qui devient assez commun sur les dernières machine multi-core pour partager les calculs entre les cores d’une même machine) peuvent être susceptible d’utiliser le CPU/RAM des autres ordi.

Alors bon … d’un côté ça parait super intéressant de pouvoir ajouter la puissance de nos anciens PC, d’un autre ont se dit … c’est naze, faut installer le kernel à la main sur chacune de ces machines, de quoi repousser n’importe qu’elle geek en puissance devant le travail à fournir …

C’est là qu’intervient un truc super sympa que l’iut de stras utilisait pour faire booter les terminaux X (et que d’autre utilisent surement). Utiliser une machine comme serveur dhcp,nfs,tftpd-hpa pour faire booter d’autres machines sur un réseau (en clair, on installe le système sur une machine, et toute les autres boot dessus, permettant même de d’utiliser des machines sans disque dur, comme ça on peut ce faire une machine qui prend tt les dd et les partager sur le réseau et pouvoir rajouter une nouvelle machine en la connectant simplement au réseau et en la bootant dessus).

Pour ça, j’ai suivi un superbe tuto (en anglais, et pas trop vieux en plus) que je vais traduire et commenter avec mes superbes retour d’expériences ^^.

L’architecture :

J’ai ma machine HOST (serveur nfs,dhcp,tftpd, …) sur laquelle je fait toute mes manipulations, avec deux interfaces, la première connectée au net (histoire de pouvoir mettre à jour la machine), et la seconde connectée à mon réseau de cluster, qui a besoin d’un réseau à part, puisque j’utilise un serveur DHCP dédié à l’adressage de ces machines.

Donc voilà, pour les IPs : 192.168.0.1 est mon serveur principal, 192.168.0.10 et 192.168.0.11 sont mes deux nodes qui vont booter sur le réseaux.

L’ensemble des manipulations à suivre ce faisant depuis 192.168.0.1 (nommé HOST).

La première commande :

apt-get install dhcp3-server tftpd-hpa portmap syslinux nfs-kernel-server nfs-common debootstrap

qui permettra d’installer l’ensemble des softs nécessaire à notre cluster.

Puis on modifie le fichier /etc/default/dhcp3-server et on spécifie l’interface sur laquelle est connecté notre cluster (eth0 étant ma connexion au net) :

INTERFACES="eth1"

Puis le fichier /etc/dhcp3/dhcpd.conf

# General options
option dhcp-max-message-size 2048;
use-host-decl-names on;
deny unknown-clients;
deny bootp;

option domain-name "cluster.lan";
option domain-name-servers 192.168.0.1;

subnet 192.168.0.0 netmask 255.255.255.0 {
option routers 192.168.0.1;
option broadcast-address 192.168.0.255;
}

group {
filename "pxelinux.0";
option root-path "192.168.0.11:/nfsroot/kerrighed";

host node1 {
fixed-address 192.168.0.10;
hardware ethernet 11:33:22:55:44:66;#à remplacer par l'adresse mac de votre machine 1
}
host node2 {
fixed-address 192.168.0.11;
hardware ethernet 11:22:33:44:55:66;#à remplacer par l'adresse mac de votre machine 2
}

server-name "host";
next-server 192.168.0.1; # Server IP
}

On permet le lancement en daemon de tftp au démarrage de la machine en modifiant /etc/default/tftp-hpa

RUN_DAEMON="yes"
OPTIONS="-l -s /var/lib/tftpboot"

On copie notre loader pxe

cp /usr/lib/syslinux/pxelinux.0 /var/lib/tftpboot

On créer notre dossier de conf :

mkdir -p /var/lib/tftpboot/pxelinux.cfg

Et on edit notre fichier de boot réseau dans /var/lib/tftpboot/pxelinux.cfg/default :

LABEL linux
KERNEL vmlinuz-2.6.20-krg
APPEND console=tty1 root=/dev/nfs nfsroot=192.168.0.1:/nfsroot/kerrighed ip=dhcp rw session_id=1

Maintenant que notre boot est prêt, il faut créer le système sur lequel les autres machines vont booter :

mkdir -p /nfsroot/kerrighed

On prépare l’import en éditant le fichier /etc/exports :

/nfsroot/kerrighed 192.168.0.1/255.255.255.0(rw,no_subtree_check,async,no_root_squash)

Puis un coup de

exportfs -avr && debootstrap - -arch i386 lenny /nfsroot/kerrighed http://ftp.fr.debian.org/debian

Qui peut prendre un bon bout de temps (z’avez le temps de faire un warsong voir même une instance de 30 minutes sur WoW ^^) … puis on fait un coup de

chroot /nfsroot/kerrighed

Pour changer les fichiers de config de notre « nouvelle machine » :

mount -t proc none /proc && mkdir /config && mount -t configfs none /config && apt-get update && export LC_ALL=C && apt-get install dhcp3-common nfs-common nfsbooted openssh-server && ln -sf /etc/network/if-up.d/mountnfs /etc/rcS.d/S34mountnfs &&  apt-get install automake autoconf libtool pkg-config gawk rsync bzip2 libncurses5 libncurses5-dev wget lsb-release xmlto patchutils xutils-dev build-essential subversion && svn checkout svn://scm.gforge.inria.fr/svn/kerrighed/trunk /usr/src/kerrighed -r 5426

Puis modification du /etc/fstab

proc /proc proc defaults 0 0
/dev/nfs / nfs defaults 0 0
configfs /config configfs defaults 0 0

On passe par /etc/network/interfaces pour configurer notre réseau … pour moi :

auto lo
iface lo inet loopback
iface eth0 inet dhcp

Une fois que la plupart des configs sont faites, on peut passer par la compilation du kernel kerrighed.

wget -O /usr/src/linux-2.6.20.tar.bz2 http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.20.tar.bz2 && cd /usr/src/kerrighed && ./autogen.sh && ./configure && cd kernel && make defconfig && make menuconfig

Dans le menu ‘super ecran bleu’ :
Allez dans « Device Drivers » puis « Network device support » et choisir sa carte réseau (sinon vous n’arriverez pas à monter le root une fois le kernel booté).
Revenir au premier menu et choisir « File systems » puis « Network File Systems » et permettre le nfsV3.
On quitte et on sauvegarde la configuration (en cliquant sur « exit »).

On reprend nos commandes (on peut faire un match sur HoN là, y’en a pour une heure) :

cd .. && make kernel && make && make kernel-install && make install && ldconfig

On continue la configuration de notre systèmes en modifiant le fichier /etc/kerrighed_nodes

session=1 #entre 1 et 254
nbmin=1 #nombre de node minimal pour kerrighed.
192.168.0.10;1:eth0
192.168.0.11:2:eth0

et on termine ici en modifiant /etc/default/kerrighed

ENABLE=true

on quitte notre chroot par un superbe :

exit

On copie notre « booter » dans le boot et on redémarre tout nos soft :

cp /nfsroot/kerrighed/boot/vmlinuz-2.6.20-krg /var/lib/tftpboot/ && /etc/init.d/tftpd-hpa start && /etc/init.d/dhcp3-server start && /etc/init.d/portmap start && /etc/init.d/nfs-kernel-server restart

A partir de maintenant, toute machine bootant en réseau sera capable d’utiliser le kernel compilé. (assez sympa en cyber café, ou … 😉 ).

Par contre une fois lancer, il ne faut pas oublier d’autoriser la migration des processus en se connectant sur l’une des nodes :

krgadm nodes && krgadm cluster start && /usr/local/bin/krg_legacy_scheduler && krgcapset -d +CAN_MIGRATE && krgcapset -k $$ -d +CAN_MIGRATE && krgcapset -d +USE_REMOTE_MEMORY && krgcapset -k $$ –inheritable-effective +CAN_MIGRATE

Et voilà … les geeks en puissance vont pouvoir faire revivre leurs premières machines ^^ (et les terminer dignement xD)