Comment exécuter Node.js en arrière-plan et ne jamais mourir?

Je me connecte au serveur Linux via putty SSH. J'ai essayé de l'exécuter en arrière-plan comme ceci:

$ node server.js &

Cependant, après 2,5 heures, le terminal devient inactif et le processus meurt. Existe-t-il de toute façon que je peux maintenir le processus en vie même avec le terminal déconnecté?

Modifier 1

En fait, j'ai essayé nohup, mais dès que je ferme le terminal Putty SSH ou que je débranche mon Internet, le processus du serveur s'arrête immédiatement.

Y a-t-il quelque chose à faire dans Putty?

Edit 2 (le février 2012)

Il y a un node.jsmodule, pour toujours . Il exécutera le serveur node.js en tant que service démon.

Solution simple (si vous n'êtes pas intéressé à revenir au processus, vous voulez juste qu'il continue à fonctionner):

nohup node server.js &

Il y a aussi la jobscommande pour voir une liste indexée de ces processus en arrière-plan. Et vous pouvez tuer un processus en arrière-plan en exécutant kill %1ou kill %2avec le nombre étant l'index du processus.

Solution puissante (vous permet de vous reconnecter au processus s'il est interactif):

screen

Vous pouvez ensuite vous détacher en appuyant sur Ctrl + a + d, puis rattacher en exécutant screen -r

Considérez également la nouvelle alternative à screen, tmux.

nohup node server.js > /dev/null 2>&1 &

1. nohupsignifie: N'interrompez pas ce processus même lorsque le stty est coupé.
2. > /dev/nullsignifie: stdout va à / dev / null (qui est un périphérique factice qui n'enregistre aucune sortie).
3. 2>&1signifie: stderr va également à la sortie standard (qui est déjà redirigée vers /dev/null). Vous pouvez remplacer & 1 par un chemin de fichier pour conserver un journal des erreurs, par exemple:2>/tmp/myLog
4. &à la fin signifie: exécutez cette commande en tâche de fond.

Vous devriez vraiment essayer d'utiliser screen. C'est un peu plus compliqué que de le faire nohup long_running &, mais comprendre l'écran une fois qu'on ne revient plus.

Commencez votre session d'écran au début:

user@host:~$ screen

Exécutez tout ce que vous voulez:

wget http://mirror.yandex.ru/centos/4.6/isos/i386/CentOS-4.6-i386-binDVD.iso

Appuyez sur ctrl + A, puis sur d. Terminé. Votre session se poursuit en arrière-plan.

Vous pouvez répertorier toutes les sessions par screen -lset en attacher à certaines par screen -r 20673.pts-0.srv, où 0673.pts-0.srv est une liste d'entrées.

C'est une vieille question, mais elle est bien classée sur Google. Je ne peux presque pas croire aux réponses les plus votées, car l'exécution d'un processus node.js dans une session d'écran, avec &ou même avec le nohupdrapeau - tous - sont juste des solutions de contournement.

Surtout la solution screen / tmux, qui devrait vraiment être considérée comme une solution amateur . Screen et Tmux ne sont pas destinés à maintenir le fonctionnement des processus, mais à multiplexer des sessions de terminal. C'est très bien, lorsque vous exécutez un script sur votre serveur et que vous souhaitez vous déconnecter. Mais pour un serveur node.js, vous ne voulez pas que votre processus soit attaché à une session de terminal. C'est trop fragile. Pour continuer à fonctionner, vous devez démonifier le processus!

Il existe de nombreux bons outils pour le faire.

PM2 : http://pm2.keymetrics.io/

# basic usage
$ npm install pm2 -g
$ pm2 start server.js

# you can even define how many processes you want in cluster mode:
$ pm2 start server.js -i 4

# you can start various processes, with complex startup settings
# using an ecosystem.json file (with env variables, custom args, etc):
$ pm2 start ecosystem.json

Un gros avantage que je vois en faveur de PM2 est qu'il peut générer le script de démarrage du système pour rendre le processus persistant entre les redémarrages:

$ pm2 startup [platform]

Où platformpeut être ubuntu|centos|redhat|gentoo|systemd|darwin|amazon.

forever.js : https://github.com/foreverjs/forever

# basic usage
$ npm install forever -g
$ forever start app.js

# you can run from a json configuration as well, for
# more complex environments or multi-apps
$ forever start development.json

Scripts d'initialisation :

Je ne vais pas entrer dans les détails sur la façon d'écrire un script d'initialisation, car je ne suis pas un expert dans ce sujet et ce serait trop long pour cette réponse, mais en gros, ce sont de simples scripts shell, déclenchés par des événements du système d'exploitation. Vous pouvez en savoir plus à ce sujet ici

Docker :

Exécutez simplement votre serveur dans un conteneur Docker avec -doption et, voilá , vous avez un serveur node.js démonisé!

Voici un exemple de Dockerfile (du guide officiel de node.js ):

FROM node:argon

# Create app directory
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app

# Install app dependencies
COPY package.json /usr/src/app/
RUN npm install

# Bundle app source
COPY . /usr/src/app

EXPOSE 8080
CMD [ "npm", "start" ]

Créez ensuite votre image et exécutez votre conteneur:

$ docker build -t <your username>/node-web-app .
$ docker run -p 49160:8080 -d <your username>/node-web-app

J'espère que cela aidera quelqu'un à atterrir sur cette page. Utilisez toujours l'outil approprié pour le travail. Cela vous évitera beaucoup de maux de tête et au fil des heures!

une autre solution renie le travail

$ nohup node server.js &
[1] 1711
$ disown -h %1

nohuppermettra au programme de continuer même après la mort du terminal. J'ai en fait eu des situations où nohupempêche la session SSH de se terminer correctement, vous devez donc également rediriger l'entrée:

$ nohup node server.js </dev/null &

Selon la nohupconfiguration, vous devrez peut-être également rediriger la sortie standard et l'erreur standard vers des fichiers.

J'ai cette fonction dans mon fichier shell rc, basée sur la réponse de @ Yoichi:

nohup-template () {
    [[ "$1" = "" ]] && echo "Example usage:\nnohup-template urxvtd" && return 0
    nohup "$1" > /dev/null 2>&1 &
}

Vous pouvez l'utiliser de cette façon:

nohup-template "command you would execute here"

Nohup et screen offrent d'excellentes solutions d'éclairage pour exécuter Node.js en arrière-plan. Le gestionnaire de processus Node.js ( PM2 ) est un outil pratique pour le déploiement. Installez-le avec npm globalement sur votre système:

npm install pm2 -g

pour exécuter une application Node.js en tant que démon:

pm2 start app.js

Vous pouvez éventuellement le lier à Keymetrics.io un SAAS de surveillance réalisé par Unitech.

$ disown node server.js &

Il supprimera la commande de la liste des tâches actives et enverra la commande en arrière-plan

Avez-vous lu sur la commande nohup ?

Pour exécuter la commande en tant que service système sur debian avec sysv init:

Copiez le script squelette et adaptez-le à vos besoins, probablement tout ce que vous avez à faire est de définir certaines variables. Votre script héritera de valeurs par défaut fines /lib/init/init-d-script, si quelque chose ne correspond pas à vos besoins - remplacez-le dans votre script. Si quelque chose ne va pas, vous pouvez voir les détails dans la source /lib/init/init-d-script. Les variables obligatoires sont DAEMONet NAME. Le script utilisera start-stop-daemonpour exécuter votre commande, START_ARGSvous pouvez définir des paramètres supplémentaires start-stop-daemonà utiliser.

cp /etc/init.d/skeleton /etc/init.d/myservice
chmod +x /etc/init.d/myservice
nano /etc/init.d/myservice

/etc/init.d/myservice start
/etc/init.d/myservice stop

Voilà comment j'exécute des trucs en python pour mon wiki wikimedia:

...
DESC="mediawiki articles converter"
DAEMON='/home/mss/pp/bin/nslave'
DAEMON_ARGS='--cachedir /home/mss/cache/'
NAME='nslave'
PIDFILE='/var/run/nslave.pid'
START_ARGS='--background --make-pidfile --remove-pidfile --chuid mss --chdir /home/mss/pp/bin'

export PATH="/home/mss/pp/bin:$PATH"

do_stop_cmd() {
    start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 \
        $STOP_ARGS \
        ${PIDFILE:+--pidfile ${PIDFILE}} --name $NAME
    RETVAL="$?"
    [ "$RETVAL" = 2 ] && return 2
    rm -f $PIDFILE
    return $RETVAL
}

Outre la définition de vars, j'ai dû remplacer à do_stop_cmdcause de python substitue l'exécutable, donc le service ne s'est pas arrêté correctement.

Outre les solutions intéressantes ci-dessus, je mentionnerais également les outils de supervision et de surveillance qui permettent de démarrer le processus, de surveiller sa présence et de le démarrer en cas de mort. Avec 'monit', vous pouvez également exécuter des vérifications actives comme vérifier si le processus répond à la demande http

Pour Ubuntu, j'utilise ceci:

(exécutez PROG_SH &> / dev / null &)

Cordialement

Essayez ceci pour une solution simple

cmd et sortie