Les noyaux linux récents permettent de démarrer une machine sous linux entièrement depuis le réseau, en chargeant le noyau et le système de fichiers racine depuis un serveur. Pour ce faire, le poste client peut utiliser diverses méthodes de démarrage : eeproms spécialement configurées, cartes réseaux implantant les protocoles RARP, BOOTP ou DHCP, CD-ROM, lanceurs chargés depuis une disquette ou un disque dur local.

Logilab a soutenu la rédaction de ce guide. Reportez-vous à son site pour les nouvelles versions de ce document. Je remercie également les administrateurs et les développeurs de etherboot, netboot, plume et linux terminal server project, qui ont réellement rendu possible le démarrage sur réseau d'une station linux.

J'adresse des remerciements particuliers à Ken Yap, membre du projet etherboot, dont les commentaires ont beaucoup aidé à la qualité de ce guide

Je remercie également Jerome Warnier, développeur principal du projet plume, Pierre Mondié, Kyle Bateman, Peter T. Breuer, Charles Howes et Thomas Marteau pour leurs commentaires et leurs contributions.

Cette documentation a été écrite à l'intention d'administrateurs systèmes expérimentés, rompus à la pratique de linux, comme l'utilisation de grep, sed et awk, la programmation shell, les processus et les scripts de démarrage, la compilation du noyau et la configuration d'un serveur NFS. Avoir l'expérience du passage d'arguments au noyau aidera. Des informations sur ces sujets peuvent être trouvées dans les pages de manuel de grep, sed, awk, dans les pages de manuel et d'info du shell bash, dans les guides pratiques "Disquettes d'amorçage", "De la mise sous tension à la ligne de commande bash", "Noyau linux", "BootParam-HOWTO" , dans les pages de manuel de bootparam et de rdev, dans le guide pratique de NFS et sur la page de manuel d'exports.

Il existe de multiples sources d'information concernant le démarrage sur réseau mais, et c'est pourquoi j'ai écrit ce guide, aucune ne décrit toutes les possibilités existantes, et la plupart sont spécifiques à une méthode. Celle qui m'a été la plus utile est la documentation fournie par linux terminal server project, bien que je n'ai pas utilisé le paquetage qu'elle recommande et que j'ai choisi de décrire ici comment procéder sans ces paquetages, car ils font le choix d'exécuter toutes les applications à distance sur le serveur. Des informations utiles sont également disponible sur la page du projet etherboot.

Enfin, vous pouvez trouver des informations utiles mais succintes dans l'arborescence des sources du noyau, dans le répertoire /usr/src/linux/Documentation, /usr/src/linux étant le répertoire où résident les sources du noyau.

J'apprécierai particulièrement les retours d'expérience concernant ce document. N'hésitez pas à m'écrire à <bbp@via.ecp.fr> pour me faire part de vos comentaires, corrections ou suggestions. Vous pouvez également utiliser l'adresse <contact@logilab.fr>.

Ce document est protégé et distribué sous les termes de la licence de documentation libre GNU. Une copie de cette licence devrait être fournie avec le document. Dans le cas contraire, celle-ci est disponible à http://www.fsf.org/licenses/fdl.html.

On peut se demander comment une station peut démarrer sur un réseau IP sans connaître son adresse IP. En pratique, trois protocoles permettent au client d'obtenir cette information, ainsi que certains paramètres supplémentaires de configuration :

Une fois que le client à récupéré son paramétrage IP, si le noyau n'est pas disponible sur un support local quelconque (disquette, CD-ROM, disque dur), le client le chargera par le protocole TFTP. Son emplacement est fourni par le server BOOTP/DHCP. Un serveur (pas nécessairement le serveur BOOTP/DHCP) devra exécuter le démon TFTP pour les noyaux non locaux. Le noyau obtenu après compilation ne peut pas être utilisé en l'état avec BOOTP/DHCP ; l'image du noyau doit être modifiée grâce à l'utilitaire mknbi (et modifiée de nouveau avec l'utilitaire imggen si vous utilisez une EPROM LanWorks). L'utilitaire mknbi devra également être utilisé pour modifier les noyaux qui seront inscrits sur une ROM.

Une fois le noyau lancé, il va tenter de monter son système de fichiers racine. Sa localisation est obtenue par BOOTP/DHCP et il est monté grâce à NFS. Cela signifie qu'un client utilisera deux fois BOOTP pour démarrer : la première fois pour charger son noyau, la seconde pour connaître l'emplacement de la racine (qui peut se trouver sur un troisième serveur).

Une autre solution consiste à utiliser un disque virtuel comme racine. Dans ce cas, l'image du disque virtuel est chargée par TFTP.

Une fois le système de fichiers racine monté, vous pouvez commencer à respirer : vous pouvez au moins utiliser les lames sh, sed et awk de votre couteau suisse. Vous allez devoir modifier les scripts d'initialisation du système de fichier de vos clients : par exemple, vous devrez retirer tous les disques durs, disquettes ou CD-ROM qui apparaissent dans le fichier /etc/fstab (pour vos stations qui en sont dépourvues), il vous faudra inhiber l'activation des partitions de swap (notez qu'il existe une méthode permettant de monter une partition swap par NFS ou sur un périphérique réseau). Si plusieurs clients utilisent la même racine distante, vous devrez aussi générer automagiquement tous les fichiers de configuration réseau au démarrage.

Il est possible d'utiliser un disque virtuel pour le système de fichiers racine. Dans ce cas, la commande permettant de modifier l'image binaire du noyau quelque peu différente. Si vous choisissez cette option, il vous faudra permettre le support du disque virtuel initial (initrd), et vous pourrez peut-être vous passer du support de NFS, ou le compiler en tant que module.

Il est temps de s'intéresser à ce qui se passe quand vous utilisez initrd. La documentation complète est disponible dans les sources du noyau dans le fichier Documentation/initrd.txt. Je dois vous prévenir que je n'ai jamais essayé :).

Quand initrd est activé, le gestionnaire de démarrage charge en premier le noyau et le disque virtuel initial en mémoire. Le disque virtuel est monté en lecture-écriture comme système de fichiers racine. Le noyau recherche un fichier nommé /linuxrc (un exécutable binaire ou un script commençant par #!). Quand /linuxrc se termine, la racine traditionnelle est montée sous /, et la séquence de démarrage normale est exécutée. Donc, pour permettre à la station de travailler entièrement sur le disque virtuel, il vous suffit de créer un lien de /linuxrc vers /sbin/init, ou d'écrire là un script exécutant toutes les actions que vous désirez, et d'arrêter l'ordinateur.

Une fois le noyau compilé, vous devez construire un système de fichiers racine pour votre installation. La méthode est expliquée dans la section "Configuration des clients, construction du système de fichiers racine". Je supposerai que cela est déjà fait et que la racine des clients est, temporairement, dans le répertoire /tmp/rootfs. Il faut maintenant créer l'image du disque virtuel. Une méthode simple est :

Maintenant, vous devez modifier l'image du noyau, comme expliqué plus haut, avec l'utilitaire mknbi-linux. La suite de commandes diffère peu (je suppose que l'image du noyau est /tftpboot/zImage et que l'image du disque virtuel est /tmp/initrd) :

# cd /tftpboot
# chmod 0555 zImage
# chown root:root zImage
# rdev zImage /dev/ram0

# mknbi-linux zImage --output=kernel
--rootdir=/dev/ram0 /tmp/initrd

Contentez-vous d'exporter le répertoire dans lequel réside le système de fichiers racine du client (réferrez-vous à la page de manuel d'export pour plus d'information sur cet aspect). Le plus simple est d'exporter avec les attributs no_root_squash et rw, mais une configuration idéale exporterait la plus grande part de la racine avec les attributs root_squash et ro, et listerait, dans le fichier /etc/exports, tous les répertoires qui nécessitent réellement les attributs no_root_squash et/ou rw. Commencez avec les attributs rw et no_root_squash pour tout, le réglage fin sera fait plus tard.

Bien sûr, le serveur NFS est inutile si vous envisagez d'utiliser un disque virtuel sur vos clients.

Je supposerai que le paquetage bootpd est installé. Le fichier de configuration par défaut est /etc/bootptab, et sa syntaxe est décrite dans la page de manuel de bootptab. Créons ce fichier.

Lancez, en tant que root, votre éditeur favori. Vim. Si, si, c'est celui-là. Si ce n'est pas le cas, il doit le devenir. Maintenant, tapez les lignes suivantes (ce sont les attributs par défaut). Tous les attributs que vous définissez ici, et qui ne sont redéfinis dans aucune liste d'attributs spécifique à une machine, seront valables pour tous les clients :

       .default\
                :sm=votre masque de sous-réseau\
                :ds=adresse IP du serveur de noms \
                :ht=ethernet\
                :dn=nom de domaine\
                :gw=adresse IP de la passerelle\
                :sa=adresse IP du serveur TFTP\
                :bf=chemin d'accès à l'image du noyau\
                :rp=chemin d'accès à la racine\
                :hn
      

Maintenant, ajoutez une entrée pour chacun des clients de votre réseau. Une entrée se présente sous la forme :

        nom du client\
                :ha=adresse MAC du client\
                :ip=adresse IP du client
      

Voici un exemple de fichier /etc/bootptab :

              .default\
                      :sm=255.255.0.0\
                      :ds=192.168.0.2\
                      :ht=ethernet\
                      :dn=frtest.org\
                      :gw=192.168.0.1\
                      :sa=192.168.0.2\
                      :bf=/tftpboot/kernel\
                      :rp=/nfsroot\
                      :hn

              foo\
                      :ha=001122334455\
                      :ip=192.168.2.12

              bar\
                      :ha=00FFEEDDCCBB\
                      :ip=192.168.12.42\
                      :ds=192.168.2.42
      

Enfin, lancez le démon bootpd avec la commande bootpd -s (il est judicieux d'ajouter cette commande dans vos scripts de démarrage), ou ajoutez la ligne suivante à votre fichier /etc/inetd.conf :

        bootps dgram udp wait root /usr/sbin/tcpd bootpd -i -t 120
      

Si vous désirez tester le serveur BOOTP, ajoutez une entrée dans le fichier /etc/bootptab et utilisez le programme bootptest.

Configurer le serveur TFTP n'est pas la partie difficile : installez le paquetage tftpd si vous l'avez, et ajoutez la ligne suivante à votre fichier /etc/inetd.conf (de nouveau, je suppose que /tftpboot est le répertoire contenant l'image du noyau) :

        tftp dgram udp wait root /usr/sbin/tcpd in.tftpd /tftpboot
      

Vous devez être conscient des limitations imposées par l'utilisation du démon TFTP à partir d'inetd. La plupart des implémentations arrêterons un service s'il est appelé trop souvent . Aussi, si vos clients sont nombreux, cherchez plutôt du côté d'xinetd, ou lancez le démon TFTP isolément.

Maintenant que tous les démons sont correctement configurés, vous pouvez relancer inetd et boire un café. N'oubliez pas de dire à tout le monde que la configuration du serveur est finie, pour pouvoir passer pour un héros avant d'entamer la construction du système de fichiers racine de vos clients.

Tout d'abord, déplacez vous dans le futur répertoire racine de vos stations. Vous pouvez facilement créer le répertoire /home par la commande mkdir, ou en le copiant à partir d'où vous voulez (utilisez la commande cp -a pour effectuer une copie récursive préservant les propriétaires, groupes, liens symboliques et permissions). Même chose pour les répertoires /mnt, /root, /tmp (n'oubliez pas chmod 0 sur ce dernier, puisqu'il n'est qu'un point de montage du /tmp réel que nous utiliserons, car chaque station a besoin de son propre répertoire /tmp). Copiez les répertoires /bin, /sbin, /boot et /usr existant dans le futur répertoire racine (commande cp -a). Vous pouvez créer le répertoire /proc avec mkdir, et utiliser chmod 0 dessus. Notez que certaines applications ont besoin d'un accès en écriture sur le répertoire de leur utilisateur.

Le répertoire /lib peut être copié sans danger de n'importe où, mais vous devrez y installer les modules qui conviennent. Pour ce faire, utilisez les commandes suivantes (considérant que le noyau compilé pour les clients réside sur le serveur dans /usr/src/linux, et que la racine est dans /nfsroot) :

# cd /usr/src/linux
# make modules_install INSTALL_MOD_PATH=/nfsroot

N'oubliez pas de placer le fichier System.map dans le répertoire /nfsroot/boot. Un premier problème que nous aurons à résoudre est que, en fonction de votre configuration, le système peut essayer de lancer fsck sur la racine au démarrage. Impossible sans disque dur. La plupart des distributions omettrons fsck si un fichier fastboot est présent dans le répertoire racine. Aussi, tapez les commandes suivantes si vous ne comptez pas monter de disque dur :

# cd /nfsroot
# touch fastboot
# chmod 0 fastboot

# cd /nfsroot/sbin
# ln -s ../bin/true fsck.nfs

Le répertoire /dev peut être copié d'un autre emplacement vers /nfsroot. Les permissions et les liens symboliques devant être préservés, utilisez la commande cp -a. Une autre solution est d'utiliser la fonctionnalité devfs des noyaux 2.2.x, qui réduit la consommation mémoire tout en augmentant les performances, mais le défaut de cette méthode est que tous les liens symboliques existant dans /dev seront perdus. Le point à garder à l'esprit est que chaque station a besoin de son propre répertoire /dev, aussi vous devrez le copier sur un disque virtuel si vous voulez avoir plusieurs clients et ne pas utiliser devfs.

Nous utiliserons des disques virtuels pour ces répertoires, chaque client devant avoir les siens propres. Mais nous en avons encore besoin au début pour créer leur structure standard. Notez que cela n'est pas nécessaire si vous n'avez qu'un seul client. Copiez donc ces répertoires (cp -a) dans /nfsroot. Vous pouvez alors faire un peu de ménage dans /var : vous pouvez effacer tout le contenu de /nfsroot/var/log et de /nfsroot/var/run. Vous pouvez probablement effacer également le contenu de /nfsroot/var/spool/mail si vous comptez exporter ce répertoire via NFS. Vous devrez enfin supprimer les fichiers contenant des informations spécifiques à la machine présents dans /nfsroot/etc pour les construire à la volée durant le processus de démarrage.

Les scripts de démarrage doivent être modifiés afin de pouvoir monter certaines parties de l'arborescence : le répertoire /dev si vous n'utilisez pas devfs, les répertoires /tmp, /var et /etc. Le code suivant effectue ces modifications :

        # cette partie uniquement si vous n'utilisez pas devfs
        mke2fs -q -i 1024 /dev/ram0 16384
        mount -n -t ext2 -o rw,suid,dev,exec, \
            async,nocheck /dev/ram0 /dev
        # cette partie dans tous les cas
        mke2fs -q -i 1024 /dev/ram1 16384
        mount -n -t ext2 -o rw,suid,dev,exec, \
            async,nocheck /dev/ram1 /tmp
        chmod 1777 /tmp
        cp -a /etc /tmp
        mke2fs -q -i 1024 /dev/ram2 16384
        mount -n -t ext2 -o rw,suid,dev,exec, \
            async,nocheck /dev/ram2 /etc
        find /tmp/etc -maxdepth 1 -exec cp -a '{}' /etc ';'
        mount -f -t ext2 -o rw,suid,dev,exec, \
            async,nocheck,remount /dev/ram2 /etc
        mount -f -o remount /
        cp -a /var /tmp
        mke2fs -q -i 1024 /dev/ram3 16384
        mount -t ext2 -o rw,suid,dev,exec, \
            async,nocheck /dev/ram3 /var
        find /tmp/var -maxdepth 1 -exec cp -a '{}' /var ';'
      

Dans le cas où vous aurez plus d'un seul client, vous devrez changer dynamiquement au démarrage certains fichiers contenus dans /etc : ceux contenant l'adresse IP et le nom d'hôte du client. Ces fichiers dépendent des distributions mais vous les retrouverez aisément avec grep. Contentez-vous de retirer de ces fichiers toutes les informations spécifiques à un client, et ajouter le code permettant la génération de ces informations lors du démarrage, mais uniquement une fois que le nouveau /etc a été monté sur le disque virtuel ! Ci-dessous une méthode permettant d'obtenir l'adresse IP et le nom d'hôte lors du démarrage (si bootpc est installé dans l'arborescence des stations) :

        IPADDR="$(bootpc | awk '/IPADDR/ \
                                {
                                  match($0,"[A-Za-z]+")
                                  s=substr($0,RSTART+RLENGTH)
                                  match(s,"[0-9.]+")
                                  print substr(s,RSTART,RLENGTH)
                                }
                               ')"

        HOST="$(bootpc | awk '/HOSTNAME/ \
                              {
                                match($0,"[A-Za-z]+")
                                s=substr($0,RSTART+RLENGTH)
                                match(s,"[A-Za-z0-9-]+")
                                print substr(s,RSTART,RLENGTH)
                              }')"

        DOMAIN="$(bootpc | awk '/DOMAIN/ \
                                {
                                  match($0,"[A-Za-z]+")
                                  s=substr($0,RSTART+RLENGTH)
                                  match(s,"[A-Za-z0-9-.]+")
                                  print substr(s,RSTART,RLENGTH)
                                }')"
      

Là, le nom d'hôte pourra être déterminé avec la commande hostname $HOSTNAME. Une fois ceci fait, il est temps de générer à la volée les fichiers de configuration contenant l'adresse IP ou le nom d'hôte du client.

On peut maintenant passer aux réglages fins. Comme /var sera monté sur un disque virtuel (suaf si vous n'avez qu'un seul client), vous devrez sauvegarder les logs sur un serveur, si vous voulez les conserver. Une méthode pour ce faire consiste à supprimer le fichier /nfsroot/etc/syslog.conf et à le remplacer par le fichier suivant (man syslog.conf pour plus de détails) :

        *.*     /dev/tty12
        *.*     nom ou adresse IP du serveur contenant les logs
      

Si vous utilisez logrotate et avez effectué les opérations précédentes, vous devrez remplacer le fichier de configuration de logrotate (/etc/logrotate.conf sur la plupart des machines) par un fichier vide :

        # rm -f /etc/logrotate.conf
        # touch /etc/logrotate.conf
      

Retirez du fichier /nfsroot/etc/fstab toutes les références à des disques durs, lecteurs de disquettes ou CD-ROM qui sont absents de vos stations clientes. Ajoutez une entrée pour le répertoire /var/spool/mail, qui pourrait être exporté par le serveur par NFS ou par tout autre système de fichiers réseau. Vous pourrez vouloir également ajouter une entrée pour /home dans ce fichier.

Vous pouvez également mettre en commentaire les lignes exécutant newaliases, activant le swap, et exécutant depmod -a et également supprimer le fichier /nfsroot/etc/mtab. Retirez les commentaires des lignes de vos fichiers de démarrage concernant /fastboot, /fsckoptions, et /forecfsck. Retirez également ou mettez en commentaires toutes les lignes des scripts de démarrage qui tenteraient d'écrire sur le système de fichiers racine, à l'exception des accès en écriture réellement nécessaires, qui devraient tous être redirigés vers l'emplacement d'un ramdisk si vous utilisez plusieurs clients.

Le temps est venu d'un petit essai. SAUVEGARDEZ TOUS LES /nfsroot NOUVELLEMENT CREES. tar -cvvIf devrait faire cela à merveille. Prenez également le temps de vérifier que vous n'avez rien oublié. Et tentez de démarrer un client.

Regardez attentivement l'écran de la station cliente pendant la phase de démarrage. Excusez-moi ! j'ai omis de vous dire de connecter un écran... Cours, Forest ! Cours et rapportes-en un. Des messages d'erreur vont probablement s'afficher. Résolvez les problèmes et effectuez de fréquentes sauvegardes du répertoire /nfsroot. Un jour, le client démarrera proprement. Pour l'heure, vous allez devoir résoudre les problèmes apparaissant pendant la séquence d'arrêt ;=P.

C'est le cas le plus simple : certaines cartes réseau fournissent une extension du BIOS contenant un client bootp ou DHCP, aussi il suffit de configurer les opérations bootp ou DHCP dans le BIOS, et tout est dit.

Ces deux cas de figure sont assez simples : le noyau est chargé depuis le support local, et tout ce qu'il doit faire est de récupérer ses paramètres réseau par bootp et de monter le système de fichiers racine par NFS ; cela ne devrait poser aucun problème. D'autre part, un disque dur local est un excellent endroit pour loger les répertoire /var, /tmp, et /dev...

Si vous disposez d'un disque dur local, tout ce que vous avez à faire est d'utiliser lilo ou votre chargeur de démarrage préféré, comme d'habitude. Si vous utilisez une disquette, vous pouvez utilisez le chargeur, ou simplement y écrire le noyau : un noyau est directement chargeable. Vous pouvez utiliser une commande comme :

# dd if=zImage of=/dev/fd0 bs=8192

Cependant, Alan Cox a écrit dans une discussion au sujet du noyau linux que cette fonctionnalité sera retirée tôt ou tard, aussi devrait vous un jour utiliser un chargeur de démarrage également sur les disquettes. Je sais que cela fonctionne toujours avec un noyau 2.4.11, mais le support semble en avoir été retiré dans la version 2.4.13. Voyez le chapitre six du boot-disk-HOWTO à ce sujet.

Certains chargeurs de démarrage ont des capacités réseau, aussi devriez vous utilisez ceux là pour chargeur l'image du noyau par le réseau. Quelques-un sont listés ci-dessous :

De nombreuses cartes réseau comportent un slot permettant l'insertion d'une EPROM contenant du code BIOS additionnel. Cela permet d'ajouter, par exemple, des fonctionnalités bootp au BIOS. Pour ce faire, il convient tout d'abord de trouver comment activer la prise supportant l'EPROM. Il peut être nécessaire d'agir sur un cavalier ou d'utiliser un logiciel spécifique. Quelques cartes, telles la 905B de 3Com, disposent de branchements pour EEPROM, ce qui permet de modifier le logiciel embarqué dans l'EEPROM. En annexe, vous trouverez des informations sur les EPROM et sur les différents types de composant de mémoire.

Pour obtenir la liste des fabricants de brûleurs d'EPROM, reportez-vous au site Yahoo, dans le répertoire Economie->Entreprises->Matériel->Périphériques->Programmateurs ou reportez-vous au guide pratique Diskless-HOWTO, section Liste des fabricants de brûleurs d'EPROM.

Si vous choisissez de créer vos propres ROM, vous devrez y charger un logiciel bootp ou DHCP et alors, vous vous retrouverez dans la configuration d'une carte réseau possédant ces caractéristiques, tel que décrit plus haut.

Vous devrez également trouver la taille et la vitesse d'EPROM appropriés à votre adaptateur réseau. Des méthodes pour ce faire sont fournies en annexe, car les fabricants de cartes fournissent rarement ces informations.

Cette section a originellement été écrite par Hans de Goede (<j.w.r.degoede@et.tudelft.nl>) pour le guide pratique "Système de fichiers racine sur NFS". Je l'ai juste modifié dans la mesure nécessaire pour rendre compte des différences entre le présent document et le guide pratique "Système de fichiers racine sur NFS".

La majeure partie de ce qui est écrit ci-dessus est également valable pour le démarrage par CD-ROM. Pourquoi vouloir démarrer une machine depuis le lecteur de CD-ROM ? Le démarrage sur un CD-ROM est surtout intéressant pour des applications très spécifiques, comme un kiosque, une base de données de bibliothèque, un net-café, ou pour celui qui n'a pas de réseau ou de serveur pour permettre l'usage d'un système de fichiers racine sur réseau.

            # cdrecord -v speed=<vitesse de
            gravure> dev=<chemin au périphérique générique scsi
            de votre graveur> boot.iso
          

Les sections précédentes ont exposé une manière simple de traiter les fichiers et les répertoires comme /var, spécifiques aux différentes stations. La plupart sont simplement construits à la volée et stockés sur ramdisk, mais vous pouvez préférer traiter ce problème sur le serveur NFS. Le projet clusternfs fournit un serveur de fichiers réseau capable de délivrer des fichiers différents en fonctions de critères comme l'adresse IP ou le nom d'hôte. L'idée de base est que, si un client d'adresse IP 10.2.12.42 requiert le fichier, disons, monfichier, le serveur cherche un fichier nommé monfichier$$IP=10.2.12.42$$ et le renvoi à la place du fichier monfichier s'il est disponible.

Une manière simple de diminuer la consommation de mémoire est de disposer plusieurs répertoires créés de manière dynamique sur le même disque virtuel. Par exemple, supposons que le premier disque virtuel contient le répertoire /tmp. Alors, on peut déplacer le répertoire /var/tmp sur ce disque virtuel avec la commande suivante, exécutée depuis le serveur :

        # mkdir /nfsroot/tmp/var
        # chmod 0 /nfsroot/tmp/var
        # ln -s /tmp/var /nfsroot/var/tmp
      

Une autre bonne méthode pour réduire la consommation mémoire si vous ne disposez pas de disque dur local et n'utilisez pas de partition d'échange par réseau est de désactiver l'option Echange sur périphériques en mode bloc pendant la compilation du noyau.

Si vos stations ne dispose pas de suffisament de mémoire et n'ont pas de disques locaux, vous pouvez utiliser une partition d'échange sur NFS. Cependant, gardez à l'esprit que le code de cette fonctionnalité est encore en phase de développement et que son fonctionnement est généralement assez lent. La documentation complète de cette fonctionnalité est disponible à http://www.instmath.rwth-aachen.de/~heine/nfs-swap/.

La première chose à faire pour mettre en œuvre cette fonctionnalité est de modifier votre noyau (vous devez disposer de la version 2.2 ou supérieure). Téléchargez le modificatif à l'adresse fournie ci-dessus et déplacez vous dans le répertoire /usr/src/linux. On considère que le modificatif est dans /usr/src/patch. Utilisez la commande suivante :

        # cat ../patch | patch -p1 -l -s
      

Exportez alors un répertoire en lecture-écriture et avec l'option no_root_squash depuis le serveur NFS. Configurez les clients pour qu'ils montent ce répertoire quelque part (disons dans /mnt/swap). Il devra être monté avec des paramètres rsize et wsize inférieurs à la taille de page utilisée par le noyau (soit 4ko sur architecure Intel), sans quoi la machine risque de se trouver à cours de mémoire, pour cause de fragmentation ; reportez vous à la page de manuel de nfs pour les détails concernant les paramètres rsize et wsize. Pour créer une partition d'échange de 20Mo, utilisez les lignes de commande suivantes (à placer dans les scripts d'initialisation des stations clientes) :

        # dd if=/dev/zero of=/mnt/swap/swapfile bs=1k count=20480
	# mkswap /mnt/swap/swapfile
	# swapon /mnt/swap/swapfile
      

Un mot encore sur les caractéristiques des partitions d'échange par NFS : en premier lieu le mécanisme est généralement lent, sauf à disposer d'interfaces réseau spécialement rapides. Cette possibilité n'a pas encore été beaucoup testée. Enfin, ce n'est pas sécurisé : n'importe qui sur le réseau est à même de lire les données transférées.

Bien que je n'ai jamais testé personnellement, j'ai eu des retours selon lesquels cette astuce fonctionne, du moins avec des noyaux récents.

Le principe général est le même qu'avec NFS. Le point positif est qu'il n'est pas nécessaire de modifier le code du noyau. Mais la plupart de ses caractéristiques s'appliquent également à cette méthode.

Pour créer un espace de swap de 20 Mo, vous devrez d'abord le créer sur le serveur, puis l'exporter vers le client, enfin, exécuter mkswap sur le fichier. Notez que la commande mkswap doit être exécutée sur le serveur, car mkswap fait usage d'appels système non supportés par NBD. De plus, cette commande doit être exécutée après que le serveur ait exporté le fichier, car les données contenues dans celui-ci risqueraient d'être détruite au moment où le serveur commence l'exportation. En considérant un serveur nommé NBDserveur, un client nommé NBDclient et que le port TCP utilisé pour l'exportation est le port 1024, la commande à exécuter sur le serveur est :

        # dd if=/dev/zero of=/swap/swapfile bs=1k count=20480
	# nbd-server NBDclient 1024 /swap/swapfile
	# mkswap /swap/swapfile
      

        # swapon /dev/nd0
      

De nouveau, ce ne sont là que les principes généraux. Les noms de fichiers peuvent également être dépendants des noms ou adresses IP des stations.

Une autre solution de fichier d'échange est de créer un système de fichiers ext2 sur le NBD, d'y créer un simple fichier et, enfin, d'utiliser les commandes mkswap et swapon pour utiliser le fichier comme fichier d'échange. La seconde méthode est plus proche de celle du fichier d'échange sur NFS que la première.

Les commandes suivantes, exécutées sur le serveur, devraient résoudre le problème :

        # ln -s /proc/mounts /nfsroot/etc/mtab
        # touch /nfsroot/proc/mounts
      

Une méthode simple est d'utiliser, du côté serveur, un chroot et d'exécuter alors votre utilitaire d'installation favori. Pour changer la racine vers l'endroit approprié, utiliser la commande suivante :

        # chroot /nfsroot
      

Les utilisateurs de distributions Debian seront particulièrement intéressés par l'option --root de dpkg, qui indique à dpkg où est la racine du système cible.