lindev.fr

Nous allons voir dans ce billet comment rendre votre application Node.js persistante dans le temps, c'est à dire

• Démarrer l'app automatiquement au démarrage du système
• Restart en cas de crash du process
• ...

Les dépendances

Pour mener à bien cette fonction, nous allons utiliser le module forever

Installation en tant que module global ( disponible depuis n'importe quelle app )

sudo npm -g install forever

Je travail actuellement sur la version 0.8.11 de Node.js et la version 0.10.0 de forever

init.d

Nous allons créer un script de démarrage ( définition de service ) pour notre application

cd /etc/init.d
vim MonAppNode

Voici le contenu :

#!/bin/bash

# Source function library.
. /lib/lsb/init-functions

#############PARAMETRES A CONFIGURER################

NAME=app.js                 # Nom de votre application
PORT=1234                   # Port (dans le cas ou votre app utilise process.env.PORT pour définir le port)
INSTANCE_DIR=/var/nodelab/monappnode/$NAME         # emplacement de votre application
SOURCE_NAME=MonAppNode       # Nom donné au process

user=www-data
pidfile=/var/run/$SOURCE_NAME.pid
logfile=/var/log/$SOURCE_NAME.log
forever_dir=/var/run/forever # chemin d'execution de forever.

###################FIN#########################

export PATH=$PATH:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/game

node=node
forever=forever
awk=awk

start() {
    echo "Starting $NAME node instance: "

    if [ "$id" = "" ]; then
        # Create the log and pid files, making sure that the target use has access to them
        touch $logfile
        chown $user $logfile

        touch $pidfile
        chown $user $pidfile

        # Launch the application
        start_daemon
            $forever start -p $forever_dir --pidFile $pidfile -l $logfile -a -d $INSTANCE_DIR $SOURCE_NAME
        RETVAL=$?
    else
        echo "Instance already running at pid $id"
        RETVAL=0
    fi
}

restart() {
    echo -n "Restarting $NAME node instance : "
    if [ "$id" != "" ]; then
        $forever restart -p $forever_dir $id
        RETVAL=$?
    else
        start
    fi
}

stop() {
    echo -n "Shutting down $NAME node instance PID : `cat $pidfile` "
    if [ "$id" != "" ]; then
        $forever stop -p $forever_dir $id
    else
        echo "Instance is not running";
    fi
    RETVAL=$?
}

status(){
    pid=`cat $pidfile`
    $forever list -p $forever_dir | $awk "\$8 && \$8 == \"$pid\" { print \$0; };"
    #forever list -p /var/run/forever | awk '$8 && $8 == "27567" { print $0; };'
}

getForeverId() {
    pid=`cat $pidfile` 
    $forever list -p $forever_dir | $awk "\$8 && \$8 == \"$pid\" { gsub(/[\[\]]/, \"\", \$2); print \$2; };"
    #forever list -p /var/run/forever | awk '$7 == "27270" { gsub(/[\[\]]/, "", $2); print $2; };'
}
id=$(getForeverId);


case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    status)
        status 
        ;;
    restart)
        restart
        ;;
    *)
        echo "Usage:  {start|stop|status|restart}"
        exit 1
        ;;
esac
exit $RETVAL

On le rends exécutable

chmod +x MonAppNode

Enfin on déclare le service dans init.d

update-rc.d MonAppNode defaults

Utilisation

Comme chaque script de démarrage, il répond aux commandes

service MonAppNode start
service MonAppNode stop
service MonAppNode status
service MonAppNode restart

Pour ce qui est de la surveillance du process node, tout est gérer par forever .

Conclusion

Voilà une méthode parmi d'autres, le script ci-dessus a été fait depuis une version plus ancienne trouvé sur le net ( je ne sais plus ou désolé ) que j'ai adapté .

Ch.

LTSP ( Linux Terminal Server Project )

J'ai pour mission d'informatiser une zone de production de prés de 7000m2, après le câblage de la zone ( RJ45 10/100/1000 ), il m'a fallu trouver un moyen économique / facile à maintenir et surtout résistant à un environnement de production.

Installer des machines autonomes ( PC standard ) n'est donc pas la meilleure solution.

J'ai donc opté pour un système client-serveur, ou les clients dit (léger) n'ont besoin que d'une interface réseau compatible PXE, et d'une carte/chip. graphique pour l'affichage sur l’écran. ( et évidemment , le trio Ecran/clavier/souris ).

Pour ce qui est de la puissance nécessaire, la station gérant uniquement l'affichage ( dans mon cas ) un cpu type atom peut suffire ( C'est l'occasion de recycler les vielles machines qui trainent), n'importe quel client léger peut faire l'affaire .

Je parle, je parle , mais c'est quoi exactement LTSP ....

le principe est simple, d'un coté il y a un serveur ( relativement puissant, cette variante va dépendre du nombre de clients à gérer ), sur lequel vous devrez créer les comptes utilisateurs. De l'autre les clients léger, qui ne sont là que pour déporter l'affichage de la session utilisateur, enfin entre les deux parties un réseau 100/1000.

Plusieurs avantages à ce principe:

• installation ou mise à jour à un seul endroit, pour l'enssemble des clients
• Maintenant aisé ( juste un remplacement de matériel, pas de restauration necessaire )
• Backup simplifié ( une seule origine )

Le Fonctionnement

Avant de vous expliquer comment monter un tel serveur, je vais vous présenter rapidement comment cela se passe entre le client et le serveur.

Commençons par un petit schéma de notre infra .. j'adore les schémas

Nous avons donc un réseau avec un parc de clients légers, un serveur DHCP déjà existant, et enfin notre serveur LTSP, le tout, évidemment relié à l'aide d'un concentrateur de qualité 10/1000/1000.

Bon très bien, quand j'appuie sur le bouton "power" de mon client léger ... il se passe quoi

Bon , détaillons tout ça ..

1. La carte mère est alimentée, elle détecte ses périphériques, le bios indique que le boot commence via le LAN , ok je balance donc sur le réseau une requête afin que quelqu'un me réponde avec une IP à me donner et les instructions nécessaires à mon Boot système.
2. Notre serveur DHCP reçoit évidemment cette requête ( comme toute les autres machines présentes sur le réseau ) lui attribut une adresse IP libre ainsi que les paramètres supplémentaires ( Adresse sur Serveur LTSP, Fichier image à charger ... ) que nous détaillerons plus tard
3. Super nous voilà connecté et identifié sur le réseau, nous pouvons maintenant contacter le serveur LTSP et charger le fichier image via le protocole tftp ( ftp en mode udp )
4. Le fichier image reçu ( avec les fichiers de conf qui vont avec ), il est chargé en mémoire ( en RAM ) et on continue notre chemin en lançant le système fraichement chargé .
5. Le système chargé ( distribution debian minimaliste ) nous avons droit à un superbe écran de connexion ( graphisme customisable au passage ). Bien! identifions nous .. login ... mot de passe, notre système minimaliste tente donc à distance de se connecter avec le couple login mot de passe ( tout se fait en SSH, donc rien ne passe en clair à ce moment sur le réseau )
6. L’authentification réussi on peut voir sur notre client léger, la session (Gnome par exemple) s'afficher. Il nous est alors possible de lancer n'importe quelle application avec la puissance du serveur, tout en étant sur une machine de plus de 10 ans.

Voilà grosso modo comment cela fonctionne avec LTSP . Bien! nous allons maintenant pouvoir aborder la mise en place du serveur, avec plus de facilité.

Environnement Graphique

Et oui .. fatalement il nous faut un environnement graphique sur notre serveur .. n'en n'ayant jamais installé sur aucun de mes serveurs, il m'a fallu commencer par là ...

apt-get install gnome gdm

Continuons ...

LTSP Server

Deux solutions s'offrent à nous à ce stade, soit nous installons le paquet ltsp-server-standalone, soit le paquet ltsp-server ...

Quelle est la différence vous aller me dire ...

C'est très simple, le paquet ltsp-server-standalone est un paquet "tout en un" c'est à dire qu'en plus de vous installer le serveur ltsp, il va aussi installer un serveur DHCP, et TFTP . Ayant dans mon cas un serveur DHCP en place, je vais installer le second paquet ltsp-server.. ( si vous n'en n'avez pas, installer le premier, la seule différence va être que votre DHCP sera sur la même machine que le serveur LTSP ).

Donc ( avec les paquets suggérés ):

apt-get install ltsp-server dnsmasq libasound2-plugins ltspfs ldm-server sdm pulseaudio-esound-compat esound-clients nas-bin ltsp-docs qemu-user-static syslinux-common

Système de fichier NFS

Le système de fichier de notre distribution minimaliste étant situé sur le serveur LTSP ( il n'est pas chargé en RAM ), ce dernier est monté nia NFS, il nous faut donc l'installer et configurer le fichier /etc/exports afin d'y ajouter le répertoire contenant notre système de fichiers.

apt-get install nfs-kernel-server
vim /etc/exports

Nous allons y ajouter la ligne suivante

/opt/ltsp *(ro,no_root_squash,async,no_subtree_check)

Nous pouvons ensuite relancer le service NFS

invoke-rc.d nfs-kernel-server restart

Tftp

Tout à l'heure j'ai parlé du serveur TFTP, utiliser par le client PXE pour charger le noyau minimaliste, et les quelques fichiers de conf ..

Installons le :

apt-get install atftpd

La configuration par défaut n'est pas valide, nous allons donc le reconfigurer.

Commençons par supprimer la ligne suivante du fichier /etc/inetd.conf

tftp            dgram   udp4    wait    nobody /usr/sbin/tcpd /usr/sbin/in.tftpd --tftpd-timeout 300 --retry-timeout 5 --mcast-port 1758 --mcast-addr 239.239.239.0-255 --mcast-ttl 1 --maxthread 100 --verbose=5 /srv/tftp

Puis reconfigurons le

dpkg-reconfigure atftpd

Gardez toutes les valeurs par défaut, sauf au moment ou il vous demande de spécifier la plage réseau ( indiquer la votre )

Enfin, nous pouvons le relancer ...

invoke-rc.d openbsd-inetd restart

Ip Forwarding

Notre serveur va relayer les paquets de nos clients léger, nous devons donc activer l'ip forwarding

Pour le faire en "one shoot", sans redémarrer

echo "1" > /proc/sys/net/ipv4/ip_forward

Et pour que ce soit ... durable

mettez à 1 le paramètre net.ipv4.ip_forward du fichier /etc/sysctl.conf

L'image minimale

Bien maintenant que tout nos services sont Ok, on va pouvoir créer notre image minimale ainsi que le système de fichier, qui sera utiliser par notre client léger.

Pour accomplir cette tâche nous allons utiliser la commande

ltsp-build-client --arch i386 --chroot classique

• --arch permet de spécifier une architecture pour notre client ( attention à ne pas l'oublier si votre serveur tourne avec une debian 64Bits et votre client en 32, par défaut l'architecture du serveur sera utilisé, tout comme la version du noyau linux à charger )

• --chroot permet de nommer notre environnement minimaliste, par défaut le nom de l'architecture est utilisé "i386" ( vous noterez qu'il est possible d'utiliser plusieurs images différentes, avec des noms différents pour tel ou tel client léger )

Je vous laisse le loisir de parcourir la page de man de la commande pour le reste des paramètres, qui permettent par exemple de charger un noyau linux de la branche unstable, ou testing ou autre ... bref mettre la version de vôtre choix ( par défaut elle est identique à celle du serveur , squeeze dans mon cas ).

Une fois terminé, nous allons mettre à jour les clefs SSH entre notre serveur et l'environnement fraichement créé ( utilisé pour la liaison réseau client - serveur )

ltsp-update-sshkeys

DHCP

Et oui je ne vous ai pas encore parlé de cette partie essentiel au bon fonctionnement .

Comme nous l'avons vu, un client léger commence par chercher un serveur DHCP sur le réseau pour passer à la suite.

Dans mon exemple, le serveur LTSP possède l'adresse 10.0.0.221, et le serveur DHCP 10.0.0.8

Afin de structurer la configuration au niveau du DHCP, nous allons créer un fichier spécifique pour les clients léger , puis le déclarer dans le fichier de configuration principale du serveur DHCP

Commençons par créer ce fameux fichier

touch /etc/ltsp/dhcpd.conf

Puis on le déclare dans notre configuration principale du DHCP

vim /etc/dhcp3/dhcpd.conf

Et on y ajoute à la fin :

include "/etc/ltsp/dhcpd.conf";

Bien, revenons au contenu du fichier /etc/ltsp/dhcpd.conf

Nous allons créer un groupe afin de pouvoir déclarer des paramètres pour l'enssemble des clients, voici un exemple que vous pouvez utiliser en adaptant les ip et adresses MAC:

group {
#Système de fichier à monter
option root-path "/opt/ltsp/classique";
#Adresse du serveur LTSP
next-server     10.0.0.221;
#Fichier image à charger
if substring( option vendor-class-identifier, 0, 9 ) = "PXEClient" {
filename "/ltsp/classique/pxelinux.0";
} else {
filename "/ltsp/classique/nbi.img";
}
#Client leger Dell
host pxeDell {
hardware ethernet 00:14:0b:80:e5:1a;
fixed-address   10.0.0.101;
}
#Client leger HP
host pxeHP {
hardware ethernet 00:16:17:5e:57:ec;
fixed-address   10.0.0.102;
}
#Client de test
host pxeTest {
hardware ethernet 00:14:67:e5:57:ab;
fixed-address   10.0.0.103;
filename "/ltsp/unstable/pxelinux.0";
option root-path "/opt/ltsp/unstable";
}
}

Dans ce groupe nous commençons par spécifier le système de fichier par défaut à monter, l'image à charger et l'adresse du serveur LTSP , vient ensuite la déclaration des clients PXE, identifié par un nom , une ip et une adresse MAC.

Il est possible de spécifier une autre image ou un autre système de fichier à monter pour un poste particulier, ex : host unstable qui chargera l'image nommée unstable ( souvenez-vous , l'option --chroot de la commande ltsp-build-client )

Nous n'avons plus qu'à redémarrer notre serveur DHCP, et tester avec un des client léger paramétré ci-dessus.

invoke-rc.d dhcp3-server restart

Premier Test

Il suffit d'appuyer sur le bouton "power" et normalement .... vous devriez découvrir ceci

N'hésitez à poster vos commentaires sur le sujet, nous verrons dans le prochain article, comment monter une clef usb ou un CD à partir du client léger, ou encore y faire passer le son, nous verrons aussi comment configurer les client PXE de façon globale ou pour un client unique.

Bref ... vous n'avez pas fini avec ce sujet restez à l'écoute .

Ch.