Comment exécuter Node.js comme un processus d'arrière-plan et ne jamais mourir?

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

1. nohup signifie: ne terminez pas ce processus même lorsque le stty est coupé hors.
2. > /dev/null signifie: stdout va vers /dev/null (qui est un mannequin périphérique qui n'enregistre aucune sortie).
3. 2>&1 signifie: stderr va aussi à 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 tant que en tâche de fond.

, Vous devriez vraiment essayer d'utiliser screen. C'est un peu plus compliqué que de simplement faire nohup long_running &, mais comprendre l'écran une fois que vous ne revenez plus jamais.

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 D. terminé. Votre session continue en arrière-plan.

Vous pouvez lister toutes les sessions par screen -ls, et attacher à certaines par la commande 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 sur les réponses les plus votées, parce que l'exécution d'un nœud.le processus js à l'intérieur d'une session d'écran, avec le & ou même avec le drapeau nohup - tous-ne sont que des solutions de contournement.

Spécialement la solution screen / tmux, qui devrait vraiment être considérée comme une solutionamateur . Screen et Tmux ne sont pas destinés à maintenir les processus en cours d'exécution, mais pour le multiplexage des sessions de terminal. C'est très bien, quand vous êtes l'exécution d'un script sur votre serveur et souhaitez déconnecter. Mais pour un nœud.serveur js vous ne voulez pas que votre processus soit attaché à une session de terminal. C'est trop fragile. pour garder les choses en cours d'exécution, vous devez démoniser le processus!

Il y a beaucoup de 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 grand 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 conserver entre les redémarrages:

$ pm2 startup [platform]

Où platform peut ubuntu|centos|redhat|gentoo|systemd|darwin|amazon.

Pour Toujours.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, parce que je ne suis pas un expert dans ce sujet et ce serait trop long pour cette réponse, mais fondamentalement, ce sont de simples scripts shell, déclenchés par des événements OS. Vous pouvez lire plus à ce sujet ici

Docker:

Exécutez simplement votre serveur dans un conteneur Docker avec l'option -d et, voilà , vous avez un nœud démonisé.serveur js!

Voici un exemple de fichier Dockerfile (à partir du nœud.js guide officiel):

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" ]

Ensuite, construisez 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. Toujours utiliser l'outil approprié pour le travail. Cela vous évitera beaucoup de maux de tête et plus des heures!

Une autre solution renie le travail

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

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

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

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

J'ai cette fonction dans mon fichier rc shell, basé 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"

$ disown node server.js &

Il va supprimer la commande de la liste des tâches actives et envoyer la commande à l'arrière-plan

Nohup et screen offrent d'excellentes solutions d'éclairage au nœud en cours d'exécution.js en arrière-plan. Nœud.js le gestionnaire de processus (H2) est un outil pratique pour le déploiement. Installez-le avec npm globalement sur votre système:

npm install pm2 -g

Pour exécuter un nœud.application js en tant que démon:

pm2 start app.js

Vous pouvez éventuellement le lier à Keymetrics.io {[4] } un SaaS de surveillance fait par Unitech.

Avez-vous lu 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 des variables. Votre script héritera des valeurs par défaut de /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 source /lib/init/init-d-script. Les var obligatoires sont DAEMON et NAME. Script utilise start-stop-daemon pour exécuter votre commande, dans START_ARGS, vous pouvez définir des paramètres supplémentaires de 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

C'est ainsi que je lance des trucs 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
}

En plus de définir vars, j'ai dû remplacer do_stop_cmd à cause de Python remplace l'exécutable, donc le service ne s'est pas arrêté correctement.

En dehors des solutions cool ci-dessus, je mentionnerais également les outils supervisord et monit qui permettent de démarrer le processus, de surveiller sa présence et de le démarrer s'il est mort. Avec 'monit', vous pouvez également exécuter des vérifications actives comme vérifier si le processus répond à la requête http

Pour Ubuntu j'utilise ceci:

( exec PROG_SH & > / dev / null&)

Cordialement

Essayez ceci pour une solution simple

cmd & exit