Comment exécuter une application node.js en tant que service d'arrière-plan?

Étant donné que ce message a attiré beaucoup d'attention au fil des ans, j'ai répertorié les meilleures solutions par plate-forme au bas de ce message.

Message d'origine :

Je veux que mon serveur node.js s'exécute en arrière-plan, c'est-à-dire: lorsque je ferme mon terminal, je veux que mon serveur continue de fonctionner. J'ai googlé cela et j'ai trouvé ce tutoriel , mais cela ne fonctionne pas comme prévu. Donc, au lieu d'utiliser ce script démon, je pensais que j'utilisais juste la redirection de sortie (la 2>&1 >> filepartie), mais cela aussi ne se termine pas - j'obtiens une ligne vierge dans mon terminal, comme s'il attendait des sorties / erreurs.

J'ai également essayé de mettre le processus en arrière-plan, mais dès que je ferme mon terminal, le processus est également tué.

Alors, comment puis-je le laisser fonctionner lorsque j'arrête mon ordinateur local?

Meilleures solutions :

• Systemd (Linux)
• Launchd (Mac)
• noeuds-fenêtres (Windows)
• PM2 (Node.js)

Copie de ma propre réponse à partir de Comment exécuter une application Node.js comme son propre processus?

Réponse 2015 : presque chaque distribution Linux est livrée avec systemd, ce qui signifie que pour toujours, monit, PM2, etc. ne sont plus nécessaires - votre système d'exploitation gère déjà ces tâches .

Créez un myapp.servicefichier (en remplaçant 'myapp' par le nom de votre application, évidemment):

[Unit]
Description=My app

[Service]
ExecStart=/var/www/myapp/app.js
Restart=always
User=nobody
# Note Debian/Ubuntu uses 'nogroup', RHEL/Fedora uses 'nobody'
Group=nogroup
Environment=PATH=/usr/bin:/usr/local/bin
Environment=NODE_ENV=production
WorkingDirectory=/var/www/myapp

[Install]
WantedBy=multi-user.target

Notez que si vous êtes nouveau sur Unix: /var/www/myapp/app.js devrait avoir #!/usr/bin/env nodesur la toute première ligne.

Copiez votre fichier de service dans le /etc/systemd/system.

Commencez avec systemctl start myapp.

Activez-le pour démarrer au démarrage avec systemctl enable myapp.

Voir les journaux avec journalctl -u myapp

Ceci est extrait de Comment nous déployons des applications de nœuds sur Linux, édition 2018 , qui comprend également des commandes pour générer un AWS / DigitalOcean / Azure CloudConfig pour construire des serveurs Linux / nœuds (y compris le .servicefichier).

Vous pouvez utiliser Forever, un simple outil CLI pour vous assurer qu'un script de nœud donné s'exécute en continu (c'est-à-dire pour toujours): https://www.npmjs.org/package/forever

MISE À JOUR - Comme mentionné dans l'une des réponses ci-dessous, PM2 a de très belles fonctionnalités manquantes pour toujours. Pensez à l'utiliser.

Réponse originale

Utilisez nohup :

nohup node server.js &

EDIT Je voulais ajouter que la réponse acceptée est vraiment la voie à suivre. J'utilise pour toujours les instances qui doivent rester actives. J'aime le faire npm install -g forever, c'est dans le chemin du nœud, puis juste faireforever start server.js

Ce n'est peut-être pas la manière acceptée, mais je le fais avec l'écran, surtout pendant le développement car je peux le faire remonter et le tromper si nécessaire.

screen
node myserver.js
>>CTRL-A then hit D

L'écran se détachera et survivra à votre déconnexion. Ensuite, vous pouvez le récupérer en faisant screen -r. Appuyez sur le manuel de l'écran pour plus de détails. Vous pouvez nommer les écrans et ainsi de suite si vous le souhaitez.

Mise à jour 2016: la série node-windows / mac / linux utilise une API commune à tous les systèmes d'exploitation, c'est donc absolument une solution pertinente. Toutefois; node-linux génère des fichiers d'initialisation systemv. Alors que systemd continue de gagner en popularité, c'est en réalité une meilleure option sous Linux. Bienvenue aux RP si quelqu'un veut ajouter le support de systemd à node-linux :-)

Fil d'origine:

C'est un fil assez ancien maintenant, mais les fenêtres de noeud fournissent une autre façon de créer des services d'arrière-plan sur Windows. Il est vaguement basé sur le nssmconcept d'utilisation d'un exewrapper autour de votre script de nœud. Toutefois; il utilise à la winsw.exeplace et fournit un wrapper de nœud configurable pour un contrôle plus granulaire sur la façon dont le processus démarre / s'arrête en cas d'échec. Ces processus sont disponibles comme tout autre service:

Le module cuit également dans certains journaux d'événements:

La démonétisation de votre script se fait via du code. Par exemple:

var Service = require('node-windows').Service;

// Create a new service object
var svc = new Service({
  name:'Hello World',
  description: 'The nodejs.org example web server.',
  script: 'C:\\path\\to\\my\\node\\script.js'
});

// Listen for the "install" event, which indicates the
// process is available as a service.
svc.on('install',function(){
  svc.start();
});

// Listen for the "start" event and let us know when the
// process has actually started working.
svc.on('start',function(){
  console.log(svc.name+' started!\nVisit http://127.0.0.1:3000 to see it in action.');
});

// Install the script as a service.
svc.install();

Le module prend en charge des choses comme le plafonnement des redémarrages (afin que les mauvais scripts ne gâchent pas votre serveur) et l'augmentation des intervalles de temps entre les redémarrages.

Étant donné que les services node-windows fonctionnent comme les autres, il est possible de gérer / surveiller le service avec n'importe quel logiciel que vous utilisez déjà.

Enfin, il n'y a pas de makedépendances. En d'autres termes, une simplenpm install -g node-windows fonctionnera. Vous n'avez pas besoin de la magie de Visual Studio, .NET ou node-gyp pour l'installer. En outre, il est sous licence MIT et BSD.

En toute divulgation, je suis l'auteur de ce module. Il a été conçu pour soulager la douleur exacte éprouvée par l'OP, mais avec une intégration plus étroite dans les fonctionnalités déjà fournies par le système d'exploitation. J'espère que les futurs téléspectateurs avec cette même question le trouveront utile.

MISE À JOUR : j'ai mis à jour pour inclure la dernière de pm2:

pour de nombreux cas d'utilisation, l'utilisation d'un service systemd est la manière la plus simple et la plus appropriée de gérer un processus de nœud. pour ceux qui exécutent de nombreux processus de nœuds ou des microservices de nœuds fonctionnant indépendamment dans un seul environnement, pm2 est un outil plus complet.

https://github.com/unitech/pm2

http://pm2.io

• il a une fonction de surveillance très utile -> joli 'gui' pour la surveillance en ligne de commande de plusieurs processus avec pm2 monitou liste de processus avecpm2 list
• gestion organisée des journaux -> pm2 logs
• d'autres choses:

  • Configuration du comportement
  • Prise en charge de la carte source
  • Compatible PaaS
  • Regarder et recharger
  • Système de modules
  • Recharge de mémoire max
  • Mode cluster
  • Rechargement à chaud
  • Workflow de développement
  • Scripts de démarrage
  • Complétion automatique
  • Workflow de déploiement
  • Surveillance de Keymetrics
  • API

Si vous voulez simplement exécuter le script sans interruption jusqu'à ce qu'il se termine, vous pouvez utiliser nohupcomme déjà mentionné dans les réponses ici. Cependant, aucune des réponses ne fournit une commande complète qui enregistre également stdinet stdout.

nohup node index.js >> app.log 2>&1 &

• Les >>moyens s'ajoutent à app.log.
• 2>&1s'assure que les erreurs sont également envoyées stdoutet ajoutées au fichier app.log.
• La fin &garantit que votre terminal actuel est déconnecté de la commande afin que vous puissiez continuer à travailler.

Si vous souhaitez exécuter un serveur de noeud (ou quelque chose qui devrait redémarrer au redémarrage du serveur), vous devez utiliser systemd / systemctl .

Si vous exécutez OSX, le moyen le plus simple de produire un véritable processus système consiste launchdà le lancer.

Construisez un plist comme celui-ci et placez-le dans / Library / LaunchDaemons avec le nom top-level-domain.your-domain.application.plist(vous devez être root lorsque vous le placez):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>top-level-domain.your-domain.application</string>

    <key>WorkingDirectory</key>
    <string>/your/preferred/workingdirectory</string>

    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/node</string>
        <string>your-script-file</string>
    </array>

    <key>RunAtLoad</key>
    <true/>

    <key>KeepAlive</key>
    <true/>

</dict>
</plist>

Une fois terminé, lancez ceci (en tant que root):

launchctl load /Library/LaunchDaemons/top-level-domain.your-domain.application.plist
launchctl start top-level-domain.your-domain.application

et vous courez.

Et vous serez toujours en cours d'exécution après un redémarrage.

Pour d'autres options dans le plist, regardez la page de manuel ici: https://developer.apple.com/library/mac/documentation/Darwin/Reference/Manpages/man5/launchd.plist.5.html

Essayez d'exécuter cette commande si vous utilisez nohup -

nohup npm start 2>/dev/null 1>/dev/null&

Vous pouvez également utiliser éternellement pour démarrer le serveur

forever start -c "npm start" ./ 

PM2 prend également en charge npm start

pm2 start npm -- start

J'utilise simplement le module daemon npm:

var daemon = require('daemon');

daemon.daemonize({
    stdout: './log.log'
  , stderr: './log.error.log'
  }
, './node.pid'
, function (err, pid) {
  if (err) {
    console.log('Error starting daemon: \n', err);
    return process.exit(-1);
  }
  console.log('Daemonized successfully with pid: ' + pid);

  // Your Application Code goes here
});

Dernièrement, j'utilise également mon (1) de TJ Holowaychuk pour démarrer et gérer des applications de nœud simples.

J'utilise Supervisor pour le développement. Ça marche juste. Chaque fois que vous apportez des modifications à un fichier .js, Supervisor redémarre automatiquement votre application avec ces modifications chargées.

Voici un lien vers sa page Github

Installer:

sudo npm install supervisor -g

Vous pouvez facilement lui faire regarder d'autres extensions avec -e. Une autre commande que j'utilise souvent est -i pour ignorer certains dossiers.

Vous pouvez utiliser nohup et superviseur pour faire fonctionner votre application de nœud en arrière-plan même après votre déconnexion.

sudo nohup superviseur myapp.js &

Node.js en tant que service d'arrière-plan dans WINDOWS XP

• Félicitations à Hacksparrow à: http://www.hacksparrow.com/install-node-js-and-npm-on-windows.html pour un tutoriel d'installation de Node.js + npm pour Windows.
• Félicitations à Tatham Oddie à: http://blog.tatham.oddie.com.au/2011/03/16/node-js-on-windows/ pour la mise en œuvre de nnsm.exe.

Installation:

1. Installez WGET http://gnuwin32.sourceforge.net/packages/wget.htm via l'exécutable du programme d'installation
2. Installez GIT http://code.google.com/p/msysgit/downloads/list via l'exécutable du programme d'installation
3. Installez NSSM http://nssm.cc/download/?page=download via la copie de nnsm.exe dans le dossier% windir% / system32

4. Créez c: \ node \ helloworld.js

   // http://howtonode.org/hello-node
   var http = require('http');
   var server = http.createServer(function (request, response) {
       response.writeHead(200, {"Content-Type": "text/plain"});
       response.end("Hello World\n");
   });
   server.listen(8000);
   console.log("Server running at http://127.0.0.1:8000/");

5. Ouvrez la console de commande et tapez ce qui suit (setx uniquement si le Kit de ressources est installé)

   C:\node> set path=%PATH%;%CD%
   C:\node> setx path "%PATH%"
   C:\node> set NODE_PATH="C:\Program Files\nodejs\node_modules"
   C:\node> git config --system http.sslcainfo /bin/curl-ca-bundle.crt    
   C:\node> git clone --recursive git://github.com/isaacs/npm.git    
   C:\node> cd npm    
   C:\node\npm> node cli.js install npm -gf   
   C:\node> cd ..    
   C:\node> nssm.exe install node-helloworld "C:\Program Files\nodejs\node.exe" c:\node\helloworld.js    
   C:\node> net start node-helloworld

6. Un bon cadeau par lots est de créer c: \ node \ ServiceMe.cmd

   @echo off
   nssm.exe install node-%~n1 "C:\Program Files\nodejs\node.exe" %~s1
   net start node-%~n1
   pause

La gestion des services:

• Les services eux-mêmes sont désormais accessibles via Démarrer-> Exécuter-> services.msc ou via Démarrer-> Exécuter-> MSCONFIG-> Services (et cochez «Masquer tous les services Microsoft»).
• Le script préfixe chaque nœud créé via le script batch avec 'node-'.
• De même, ils peuvent être trouvés dans le registre: " HKLM \ SYSTEM \ CurrentControlSet \ Services \ node-xxxx "

La réponse acceptée est probablement la meilleure réponse de production, mais pour un hack rapide faisant du travail de développement, j'ai trouvé ceci:

nodejs scriptname.js & n'a pas fonctionné, car nodejs semblait engloutir le &, et donc la chose ne m'a pas permis de continuer à utiliser le terminal sans que scriptname.js ne meure.

Mais j'ai mis nodejs scriptname.jsun fichier .sh et j'ai nohup sh startscriptname.sh &travaillé.

Ce n'est certainement pas un problème de production, mais cela résout le problème "J'ai besoin de continuer à utiliser mon terminal et je ne veux pas démarrer 5 terminaux différents".

Si vous exécutez nodejs sur un serveur Linux, je pense que c'est la meilleure façon.

Créez un script de service et copiez-le dans /etc/init/nodejs.conf

démarrer le service: sudo service nodejs start

arrêter le service: sudo service nodejs stop

Script Sevice

description "DManager node.js server - Last Update: 2012-08-06"
author      "Pedro Muniz - [email protected]"

env USER="nodejs" #you have to create this user 
env APPNAME="nodejs" #you can change the service name
env WORKDIR="/home/<project-home-dir>" #set your project home folder here
env COMMAND="/usr/bin/node <server name>" #app.js ?

# used to be: start on startup
# until we found some mounts weren't ready yet while booting:
start on started mountall
stop on shutdown

# Automatically Respawn:
respawn
respawn limit 99 5

pre-start script
    sudo -u $USER echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Starting" >> /var/log/$APPNAME.log
end script

script
    # Not sure why $HOME is needed, but we found that it is:
    export HOME="<project-home-dir>"  #set your project home folder here
    export NODE_PATH="<project node_path>"

    #log file, grant permission to nodejs user
    exec start-stop-daemon --start --make-pidfile --pidfile /var/run/$APPNAME.pid --chuid $USER --chdir $WORKDIR --exec $COMMAND >> /var/log/$APPNAME.log 2>&1
end script

post-start script
   # Optionally put a script here that will notifiy you node has (re)started
   # /root/bin/hoptoad.sh "node.js has started!"
end script

pre-stop script
    sudo -u $USER echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Stopping" >> /var/log/$APPNAME.log
end script

Mise à jour de juin 2017:
Solution pour Linux: (chapeau rouge). Les commentaires précédents ne fonctionnent pas pour moi. Cela fonctionne pour moi sur Amazon Web Service - Red Hat 7. J'espère que cela fonctionne pour quelqu'un là-bas.

A. Create the service file 
sudo vi /etc/systemd/system/myapp.service
[Unit]
Description=Your app
After=network.target

[Service]
ExecStart=/home/ec2-user/meantodos/start.sh
WorkingDirectory=/home/ec2-user/meantodos/

[Install]
WantedBy=multi-user.target

B. Create a shell file
/home/ec2-root/meantodos/start.sh
#!/bin/sh -
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to 8080
npm start

then:
chmod +rx /home/ec2-root/meantodos/start.sh
(to make this file executable)

C. Execute the Following

sudo systemctl daemon-reload
sudo systemctl start myapp
sudo systemctl status myapp

(If there are no errors, execute below.  Autorun after server restarted.)
chkconfig myapp -add

utilisez nssm la meilleure solution pour windows, téléchargez simplement nssm , ouvrez cmd dans le répertoire nssm et tapez

nssm install <service name> <node path> <app.js path> 

eg: nssm install myservice "C:\Program Files\nodejs" "C:\myapp\app.js" 

cela installera un nouveau service Windows qui sera répertorié sur services.msc à partir de là, vous pouvez démarrer ou arrêter le service, ce service démarrera automatiquement et vous pouvez configurer pour redémarrer s'il échoue.

Pour compléter les différentes options suggérées, voici une autre: la daemoncommande dans GNU / Linux, que vous pouvez lire ici: http://libslack.org/daemon/manpages/daemon.1.html . (excuses si cela est déjà mentionné dans l'un des commentaires ci-dessus).

Découvrez fugue! En plus de lancer de nombreux travailleurs, vous pouvez également diaboliser votre processus de nœud!

http://github.com/pgte/fugue

quelqu'un a-t-il remarqué une erreur insignifiante sur la position "2> & 1"?

2>&1 >> file

devrait être

>> file 2>&1

J'utilise tmux pour un environnement de développement à fenêtres / volets multiples sur des hôtes distants. Il est très simple de détacher et de maintenir le processus en arrière-plan. Jetez un œil à tmux

Pour les personnes utilisant des versions plus récentes du module démon npm - vous devez passer des descripteurs de fichiers au lieu de chaînes:

var fs = require('fs');
var stdoutFd = fs.openSync('output.log', 'a');
var stderrFd = fs.openSync('errors.log', 'a');
require('daemon')({
    stdout: stdoutFd, 
    stderr: stderrFd
});

PM2 est un gestionnaire de processus de production pour les applications Node.js avec un équilibreur de charge intégré. Il vous permet de maintenir les applications en vie pour toujours, de les recharger sans interruption et de faciliter les tâches d'administration système courantes. https://github.com/Unitech/pm2

Je suis surpris que personne n'ait mentionné Guvnor

Je l' ai essayé pour toujours, PM2, etc. Mais, en matière de contrôle solide et des mesures de performance basées sur le Web, j'ai trouvé Guvnor de loin le meilleur. De plus, il est également entièrement open source.

Edit: Cependant, je ne sais pas si cela fonctionne sur Windows. Je ne l'ai utilisé que sur Linux.

Comme il me manque cette option dans la liste des réponses fournies, j'aimerais ajouter une option éligible à partir de 2020: docker ou tout conteneur équivalent plate forme de . En plus de garantir que votre application fonctionne dans un environnement stable, il y a des avantages de sécurité supplémentaires ainsi qu'une portabilité améliorée.

Il existe un support Docker pour Windows, macOS et la plupart des distributions Linux majeures. L'installation de Docker sur une plate - forme prise en charge est assez simple et bien documentée. La configuration d'une application Node.js est aussi simple que de la placer dans un conteneur et d'exécuter ce conteneur tout en s'assurant qu'elle est redémarrée après l'arrêt.

Créer une image de conteneur

En supposant que votre application est disponible dans / home / me / my-app sur ce serveur, créez un fichier texte Dockerfile dans le dossier / home / me / my-app avec un contenu similaire à celui-ci:

FROM node:lts-alpine
COPY /my-app /app
CMD ["/app/server.js"]

Créez l'image en utilisant une commande comme celle-ci:

docker build -t myapp-as-a-service /home/me

Remarque: dernier paramètre consiste à sélectionner le dossier contenant ce Dockerfile au lieu du Dockerfile lui-même. Vous pouvez en choisir un autre en utilisant l'option -f .

Démarrer le conteneur

Utilisez cette commande pour démarrer le conteneur:

docker run -d --restart always -p 80:3000 myapp-as-a-service

Cette commande suppose que votre application écoute sur le port 3000 et que vous souhaitez qu'elle soit exposée sur le port 80 de votre hôte.

C'est un exemple très limité à coup sûr, mais c'est un bon point de départ.

Si vous utilisez pm2, vous pouvez l'utiliser avec la valeur autorestartset false:

Écosystème pm2 $

Cela va générer un échantillon ecosystem.config.js:

module.exports = {
  apps: [
    {
      script: './scripts/companies.js',
      autorestart: false,
    },
    {
      script: './scripts/domains.js',
      autorestart: false,
    },
    {
      script: './scripts/technologies.js',
      autorestart: false,
    },
  ],
}

$ pm2 startosystem.config.js

Cette réponse est assez tardive pour le groupe, mais j'ai trouvé que la meilleure solution était d'écrire un script shell qui utilisait à la fois les commandes screen -dmSet nohup.

screen -dmS newScreenName nohup node myserver.js >> logfile.log

J'ajoute également le >> logfilebit à la fin pour pouvoir facilement enregistrer les console.log()instructions de noeud .

Pourquoi ai-je utilisé un script shell? Eh bien, j'ai également ajouté une instruction if qui vérifiait si le node myserver.jsprocessus était déjà en cours d'exécution.

De cette façon, j'ai pu créer une seule option de ligne de commande qui me permet à la fois de maintenir le serveur en marche et de le redémarrer lorsque j'ai apporté des modifications, ce qui est très utile pour le développement.