Voici la représentation visuelle du réseau que vous aurez à construire une fois que votre serveur «rouge» sera fonctionnel. Ce serveur contient 3 cartes réseau (eth0, eth1, eth2) ayant chacune une utilité particulière.

Figure 1.1. Architecture réseau

Voici à quoi ressemble la configuration des cartes réseau de votre réseau. Ces éléments de configuration seront écrites aux emplacement appropriés plus loin dans ce document. Cette section n'est qu'à titre informatif...

Serveur

hostname = rouge
eth0 : 192.168.0.50 // Relié à Internet
eth1 : 192.168.50.1 // Relié au cluster
eth2 : 192.168.51.1 // Relié aux terminaux X
gateway = 192.168.0.1 // Correspond à votre serveur et votre adresse gateway sur votre réseau (changer au besoin)
dns = 192.168.0.14 // Correspond à votre serveur et votre adresse dns sur votre réseau (changer au besoin)

noeud 1

host name = dix
mac = 00:04:75:F4:E6:BC //Mac adresse de votre carte réseau. Adapter selon votre matériel!
ip = 192.168.50.10

noeud 2

hostname = onze
mac = 00:04:75:F4:EC:07
ip = 192.168.50.11

terminal

hostname = ws100
mac = 00:0A:E6:0D:00:93
ip = 192.168.51.110

Commençons par installer GCC, le compilateur C et C++ de Linux (entre autres langages)...

#emerge -k gcc

#emerge -k gcc-config
#gcc-config -l // Pour voir les versions de GCC installées

Cela devrait vous donner quelque chose en sortie comme ceci :

#[1] i686-pc-linux-gnu-3.3.2

[1] représentant la version installée sur votre système.

#emerge -k openmosix-sources
#cd /usr/src/
#rm -rf linux
#ln -s linux-2.4.22-openmosixlinux // Le nom du dossier peut changer. 
                                   // Adapter à la version en cours, soit linux-2.x.xx-openmosixlinux
#cd /usr/src/linux
#cp .config .config_working        // Conserver l'ancienne configuration du kernel
#make menuconfig

Nous allons maintenant passer aux choix de modules à compiler (ajouter) dans le noyau.

OpenMosix -->

    [*] openMosix process migration support
    [ ] Support clusters with a complex network topology
    [*] Stricter security on openMosix ports
    (1) Level of process-identity disclosure (0-3)
    [*] openMosix File-System
    [ ] Poll/Select exceptions on pipes
    [ ] Disable OOM Killer
    [ ] Load Limit

Code maturity level options  --->
    [*] Prompt for development and/or incomplete code/drivers

Networking options --->
    <*> Packet socket
    [ ]   Packet socket: mmapped IO
    < > Netlink device emulation
    [ ] Network packet filtering (replaces ipchains)
    [*] Socket Filtering
    <*> Unix domain sockets
    [*] TCP/IP networking
    [*]   IP: multicasting

File systems --->

    [*] /proc file system support
    [*] /dev file system support (EXPERIMENTAL)
    [*]   Automatically mount at boot 
     

Finalement, il faut compiler le noyau. Ceci implique la création des dépendances, création de l'image pour le répertoire boot/, la création des modules, leur installation et finalement copie du fichier bzImage.

# make dep
# make clean bzImage modules modules_install
# cp /usr/src/linux/arch/i386/boot/bzImage /boot/bzImage

Procédonc maintenant à l'installation en tant que telle...

#emerge -k openmosix-user //Installer les outils OpenMosix
#mkdir mfs //Créer le point de montage /mfs dans le répertoire racine, c'est à dire " / "

Modification du fichier /etc/fstab...

#nano /etc/fstab

Ajoutez la ligne suivante :

none          /mfs          mfs         noauto,dfsa=1        0 0

Quittez nano en enregistrant les changements et ...

Il y a aussi l'application openmosixview qui permet d'afficher un aperçu de votre cluster et des processus migrés d'un noeud à l'autre. Vous pouvez l'installer comme ceci...

#emerge -k openmosixview

#cd /usr/src
#cp .config .config_working   //sauvergarder une copie de la configuration du noyau maître
#make menuconfig              //C'est ici qu'on modifie la configuration du noyau maître

Assurez-vous que votre noyau possède ces options :

Code maturity level options  --->
  [*] Prompt for development and/or incomplete code/drivers


Networking options --->
  <*> Packet socket
  [ ] Packet socket: mmapped IO
  < > Netlink device emulation
  [ ] Network packet filtering (replaces ipchains)
  [*] Socket Filtering
  <*> Unix domain sockets
  [*] TCP/IP networking
  [*]   IP: multicasting

  
File systems --->

  [*] /proc file system support
  [*] /dev file system support (EXPERIMENTAL)
  [*] Automatically mount at boot    
  Network File Systems  --->
    <*> NFS server support
    [*] Provide NFSv3 server support

Finalement, il faut compiler le noyau. Ceci implique la création des dépendances, création de l'image pour le répertoire boot/, la création des modules, leur installation et finalement copie du fichier bzImage pour remplacer l'ancien.

# make dep
# make clean bzImage modules modules_install
# cp /usr/src/linux/arch/i386/boot/bzImage /boot/bzImage
# cp /usr/src/linux/.config /usr/src/linux/.config_master //Sauvegarder d'une copie de la configuration 
du noyau maître)

Nous allons maintenant procéder à la compilation d'un nouveau noyau, noyau qui sera nécessaire à vos terminaux X...

Vous aurez besoin de nouveaux noyaux pour vos terminaux X. En fait, lorsque ceux-ci démarreront, ils utiliseront ce noyau spécialement conçu pour eux.

Code maturity level options  --->

  [*] Prompt for development and/or incomplete code/drivers

Networking options --->
  <*> Packet socket
  [ ] Packet socket: mmapped IO
  < > Netlink device emulation
  [ ] Network packet filtering (replaces ipchains)
  [ ] Socket Filtering
  <*> Unix domain sockets
  [*] TCP/IP networking
  [*] IP: multicasting
  [*] IP: kernel level autoconfiguration
  [*] IP: DHCP support (NEW)

File systems --->
  [*] /proc file system support
  [*] /dev file system support (EXPERIMENTAL)
  [*] Automatically mount at boot
  Network File Systems  --->

  Ajouter toutes les options requises pour les cartes ethernet de vos noeuds esclaves

Procédons maintenant à la compilation :

#cd /usr/linux
#make clean dep bzImage //Compilation du noyau esclave
#mkdir /diskless
#cp /usr/src/linux/arch/i386/boot/bzImage /diskless //Copie du noyau esclave

Les systèmes de fichiers des noeuds maître et esclaves oeuvent subir de nombreuses adaptations. Concentrons-nous d'abord sur les fichiers de configuration et les points de montage. Nous avons besoin d'un répertoire sous /diskless pour le premier noeud esclave . Chaque esclave a besoin de son propre système de fichiers racine (le "root") parce que certains fichiers ne peuvent pas être communs à plusieurs machines sans causer de graves problèmes. Peu importe les noms des sous-répertoires vous pouvez, par exemple, les nommer d'après les adresses IP car elles sont uniques et explicites. Dans cet exemple, l'adresse IP du premier noeud esclave est 192.168.50.10 : vous devez faire cette opération pour chaque noeud esclave. Voir le code ci-bas.

# mkdir /diskless/192.168.50.10
# cp -r /etc /diskless/192.168.50.10/etc
# mkdir /diskless/192.168.50.10/home
# mkdir /diskless/192.168.50.10/dev
# mkdir /diskless/192.168.50.10/proc
# mkdir /diskless/192.168.50.10/tmp
# mkdir /diskless/192.168.50.10/mnt
# mkdir /diskless/192.168.50.10/mnt/.initd
# mkdir /diskless/192.168.50.10/root
# mkdir /diskless/192.168.50.10/var
# mkdir /diskless/192.168.50.10/var/empty
# mkdir /diskless/192.168.50.10/var/lock
# mkdir /diskless/192.168.50.10/var/log
# mkdir /diskless/192.168.50.10/var/run
# mkdir /diskless/192.168.50.10/mfs

Vous devez ensuite modifier le fichier «net» situé dans le répertoire /etc/net pour forcer la carte réseau des postes esclaves à obtenir une adresse ip par dhcp. Encore une fois, cette procédure est nécessaire pour CHAQUE noeud esclave.

#nano /diskless/192.168.50.1/etc/net

Gardez seulement les lignes suivantes :

iface_eth0="dhcp"
gateway="eth0/192.168.50.1" //Changez le ip pour celui de votre passerelle

Quittez le fichier et enregistrez les modifications. Nous allons maintenant procéder à l'installation du serveur DHCP. Le serveur DHCP procure une adresse IP de façon automatique à tous les ordinateurs qui se brancheront sur votre réseau.

#emerge -k dhcp

Modifions maintenant le fichier de configuration du serveur DHCP :

#cp /etc/dhcp/dhcp.conf.sample /etc/dhcp/dhcp.conf
#nano /etc/dhcp/dhcp.conf

Votre fichier dhcp.conf, version finale, devrait ressembler à ceci :

ddns-update-style none;

option space PXE;
option PXE.mtftp-ip             code 1 = ip-address;
option PXE.mtftp-cport          code 2 = unsigned integer 16;
option PXE.mtftp-sport          code 3 = unsigned integer 16;
option PXE.mtftp-tmout          code 4 = unsigned integer 8;
option PXE.mtftp-delay          code 5 = unsigned integer 8;
option PXE.discovery-control    code 6 = unsigned integer 8;
option PXE.discovery-mcast-addr code 7 = ip-address;

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

subnet 192.168.50.0 netmask 255.255.255.0
{
 class "pxeclients"
 {
       match if substring (option vendor-class-identifier, 0, 9) = "PXEClient";
       option vendor-class-identifier "PXEClient";
       vendor-option-space PXE;
       option PXE.mtftp-ip 0.0.0.0;
       filename "pxelinux.0";
       next-server 192.168.50.1;                       //adresse du serveur
 }

 pool
 {
       max-lease-time 86400;
       default-lease-time 86400;
       deny unknown clients;
 }

 host dix
 {
      hardware ethernet            00:04:75:F4:E6:BC;  //adresse mac du client
      fixed-address                192.168.50.10;
      server-name                  "rouge";            //nom du serveur
      option routers               192.168.50.1;       //adresse du serveur
      option domain-name-servers   192.168.0.14;       //adresse du dns
      option host-name             "dix";              //nom du client
 }

 host onze
 {
      hardware ethernet            00:04:75:F4:EC:07;
      fixed-address                192.168.50.11;
      server-name                  "rouge";
      option routers               192.168.50.1;
      option domain-name-servers   192.168.0.14;
      option host-name             "onze";
 }
}

subnet 192.168.51.0 netmask 255.255.255.0
{
      option broadcast-address     192.168.51.255;
}

}

Il faut maintenant spécifier sur quel interface réseau le serveur DHCP devra s'exécuter.

#nano /etc/conf.d/dhcp //Exemple de /etc/conf.d/dhcp

IFACE="eth1 eth2"
DHCPD_OPTS=""

Quittez nano en sauvegardant les changements.

Démarrez le serveur DHCP et ajoutez-le à la procédure de démarrage pour qu'il s'exécute automatiquement.

#/etc/init.d/dhcp start

#rc-update add dhcp default

#/etc/init.d/dhcpd restart

Le serveur tFTP (Trivial FTP) est utilisé pour envoyer le noyau et le initrd au terminal, via le réseau.

Commençons par installer les services nécessaires :

#emerge -k syslinux //Installer syslinux

#emerge tftp-hpa  //Installer le serveur tFTP

#cp /usr/lib/syslinux/pxelinux.0 /diskless //installer le démarreur à distance

#mkdir /diskless/pxelinux.cfg

#nano /diskless/pxelinux.cfg/C0A8320A //C0A8320A en hexadécimal = 192.168.50.10 en décimal)

DEFAULT /diskless/bzImage
APPEND ip=dhcp root=/dev/nfs nfsroot=192.168.1.1:/diskless/192.168.1.10

INTFTPD_PATH="/diskless"
INTFTPD_OPTS="-l -v -s ${INTFTPD_PATH}"

#/etc/init.d/in.tftpd start
# rc-update add in.tftpd default

NFS (Network File System) permet de rendre disponible le système de fichiers aux terminaux. Un "Network File System" (Système de fichiers réseau) est un protocole réseau qui supporte le partage de fichiers, comme par exemple le protocole SMB pour Windows.

Commençons par installer le packetage requis :

#emerge nfs-utils

Configurez maintenant le fichier de démarrage du serveur NFS

#nano /etc/init.d/nfs

Modifiez-le fichier pour qu'il prenne les valeurs suivantes :

# Number of servers to be started up by default
RPCNFSDCOUNT=20

#Options to pass to rpc.mountd
RPCMOUNTDOPTS=""

Sortez de nano et enregistrez les changements. Démarrez le serveur NFS et ajoutez-le au processus de démarrage du noeud maître (votre serveur) :

#/etc/init.d/nfs start

#rc-update add nfs default

Par la suite, il faut modifier le fichier "exports", fichier contenant tous les principes partagés par NFS.

#nano /etc/exports

# /etc/exports: NFS file systems being exported.  See exports(5).
/diskless/192.168.50.10               192.168.50.10(rw,no_root_squash,no_all_squash,sync)
/diskless/192.168.50.11               192.168.50.11(rw,no_root_squash,no_all_squash,sync)
/opt      192.168.50.0/24(ro,no_root_squash,no_all_squash,sync)
/usr      192.168.50.0/24(ro,no_root_squash,no_all_squash,sync)
/home     192.168.50.0/24(rw,no_root_squash,no_all_squash,sync)
/var/log  192.168.50.10(rw,no_root_squash,no_all_squash,sync)
/var/log  192.168.50.11(rw,no_root_squash,no_all_squash,sync)

Par la suite, il faut modifier le fichier "fstab" spécifique à chaque noeud, comme ceci :

#nano /diskless/192.168.50.10/etc/fstab

Le fichier fstab contenu dans /diskless/192.168.50.10/etc/fstab du noeud esclave que vous configurez devrait ressembler à ceci :

192.168.50.1:/diskless/192.168.50.10  /     nfs    hard,intr,rw,nolock,rsize=8192,wsize=8192   0 0
192.168.50.1:/opt                     /opt  nfs    hard,intr,ro,nolock,rsize=8192,wsize=8192   0 0
192.168.50.1:/usr                     /usr  nfs    hard,intr,ro,nolock,rsize=8192,wsize=8192   0 0
192.168.50.1:/home                    /home nfs    hard,intr,rw,nolock,rsize=8192,wsize=8192   0 0
192.168.50.1:/var/log              var/log  nfs    hard,intr,rw                                0 0

# NOTE: The next line is critical for boot!
none       /proc        proc      defaults        0 0
none       /mfs         mfs       noauto,dfsa=1   0 0
none       /dev/shm     tmpfs     defaults        0 0

Passons maintenant à la création de certains dossiers nécessaires nécessaires à chaque noeud esclave. Encore une fois, vous devez créer ces dossiers pour chaque noeud esclave de votre réseau et ce, autant que vous en avez. N'oubliez pas de modifier l'adresse ip du noeud esclave en question à chaque fois que vous créerez ses dossiers...

# cp -r /bin /diskless/192.168.50.10/bin
# cp -r /sbin /diskless/192.168.50.10/sbin 
# cp -r /lib /diskless/192.168.50.10/lib

Ensuite, pour chaque noeud esclave (selon l'adresse ip correspondante) faites :

diskless/192.168.50.10/fastboot
# echo "touch /fastboot" >> /diskless/192.168.50.10/etc/conf.d/local.start

#mkdir /mnt/ltsp

#mount -o loop /root/ltsp-4.iso /mnt/ltsp

#cd /mnt/ltsp

#./ltsp_installer

C'est ici que l'installation de LTSP s'effectue...

Make selection : 2

Make selection : 1

Make selection : A

Are you sure yout want to install ALL components ? Yes

In which directory would you like to place LTSP ? [/opt/ltsp]

Installation de ltsp .................

Et c'est ici que la configuration de LTSP s'effectue...

#./ltspcfg

press enter to continue ...

Make selection : C

Make selection : 1

Select run level : 5

Make selection : 2

choisir eth2


Make selection : 8 

Do you want to add entries to /etc/hosts ? Yes

Make selection : R

À présent, copions le noyau de ltsp dans le dossier diskless

#cp /tftpboot/bzImageltsp /diskless/bzImageltsp

Éditons maintenant le fichier "exports" :

#nano /etc/exports

en ajoutant les lignes suivantes :

opt/ltsp/i386              192.168.0.0/255.255.255.0(ro,no_root_squash,async)
/var/opt/ltsp/swapfiles    192.168.0.0/255.255.255.0(rw,no_root_squash,async)

Voici la version finale du fichier exports, ou du moins, ce à quoi il devrait ressembler :

# /etc/exports: NFS file systems being exported.  See exports(5).

#diskless
/diskless/192.168.50.10   192.168.50.10(rw,no_root_squash,no_all_squash,sync)
/diskless/192.168.50.11   192.168.50.11(rw,no_root_squash,no_all_squash,sync)
/opt                      192.168.50.0/24(ro,no_root_squash,no_all_squash,sync)
/usr                      192.168.50.0/24(ro,no_root_squash,no_all_squash,sync)
/home                     192.168.50.0/24(rw,no_root_squash,no_all_squash,sync)
/var/log                  192.168.50.10(rw,no_root_squash,no_all_squash,sync)
/var/log                  192.168.50.11(rw,no_root_squash,no_all_squash,sync)

#ltsp    
/opt/ltsp/i386            192.168.51.0/255.255.255.0(ro,no_root_squash,async)
/var/opt/ltsp/swapfiles   192.168.51.0/255.255.255.0(rw,no_root_squash,async)

DHCP signifie Dynamic Host Configuration Protocol. Le DHCP (service système) est un outil permettant à un ordinateur de se connecteur sur un réseau et recevoir automatiquement une adresse IP de la part du serveur. Dans notre cas, les adresses sont ordinairement des adresses locales (192.168.x.x ou encore 10.0.x.x) et serviront strictement aux ordinateurs situés sur le réseau pour communiquer entre eux. L'adresse IP servant à la navigation sur Internet ne devrait être connue que par le serveur (interface eth0).

Éditons maintenant le fichier "dhcpd.conf" :

#nano /etc/dhcp/dhcpd.conf

Voici la version finale du fichier exports, ou du moins, ce à quoi il devrait ressembler :

ddns-update-style none;

option space PXE;
option PXE.mtftp-ip              code 1 = ip-address;
option PXE.mtftp-cport           code 2 = unsigned integer 16;
option PXE.mtftp-sport           code 3 = unsigned integer 16;
option PXE.mtftp-tmout           code 4 = unsigned integer 8;
option PXE.mtftp-delay           code 5 = unsigned integer 8;
option PXE.discovery-control     code 6 = unsigned integer 8;
option PXE.discovery-mcast-addr  code 7 = ip-address;

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

subnet 192.168.50.0 netmask 255.255.255.0
{
#diskless
       class "pxeclients"
       {
             match if substring (option vendor-class-identifier, 0, 9) = "PXEClient";
             option vendor-class-identifier "PXEClient";
             vendor-option-space PXE;

             option PXE.mtftp-ip 0.0.0.0;
             filename "pxelinux.0";
             next-server 192.168.50.1;
        }

        pool
        {
             max-lease-time 86400;
             default-lease-time 86400;
             deny unknown clients;
        }

       host dix
       {
             hardware ethernet           00:04:75:F4:E6:BC; //ici vous devez écrire l'adresse MAC de votre propre carte réseau!
             fixed-address               192.168.50.10;
             server-name                 "rouge";
             option routers              192.168.50.1;
             option domain-name-servers  192.168.0.14;
             option host-name            "dix";
       }

       host onze
       {
             hardware ethernet            00:04:75:F4:EC:07; //ici vous devez écrire l'adresse MAC de votre propre carte réseau!
             fixed-address                192.168.50.11;
             server-name                  "rouge";
             option routers               192.168.50.1;
             option domain-name-servers   192.168.0.14;
             option host-name             "onze";
       }
}


#ltsp

subnet 192.168.51.0 netmask 255.255.255.0
{
             option broadcast-address     192.168.51.255;
}

group {
      option domain-name       "nomdedomaine";
      filename                 "bzImageltsp";
      option root-path         "192.168.51.1:/opt/ltsp/i386";
      use-host-decl-names      on;

      host ws110 //Nous n'avons listé qu'un seul terminal pour l'exemple mais vous devriez lister tous les vôtres présents sur le réseau...
      {
           hardware ethernet        00:0A:E6:0D:00:93; //ici vous devez écrire l'adresse MAC de votre propre carte réseau!
           fixed-address            192.168.51.110;
      }
}

Après avoir quitté nano est enregistrant les modifications, démarrez le serveur DHCP :

#/etc/init.d/dhcp restart

#nano /etc/X11/xdm/Xaccess

# *                 #any host can get a login window