Wie führe ich eine node.js-App als Hintergrunddienst aus?

Da dieser Beitrag im Laufe der Jahre viel Aufmerksamkeit auf sich gezogen hat, habe ich die Top-Lösungen pro Plattform am Ende dieses Beitrags aufgelistet.

Ursprünglicher Beitrag :

Ich möchte, dass mein node.js-Server im Hintergrund ausgeführt wird, dh wenn ich mein Terminal schließe, soll mein Server weiter ausgeführt werden. Ich habe dies gegoogelt und mir dieses Tutorial ausgedacht , aber es funktioniert nicht wie beabsichtigt. Anstatt dieses Daemon-Skript zu verwenden, dachte ich, ich hätte nur die Ausgabeumleitung (den 2>&1 >> fileTeil) verwendet, aber auch diese wird nicht beendet - ich erhalte eine leere Zeile in meinem Terminal, als würde sie auf Ausgabe / Fehler warten.

Ich habe auch versucht, den Prozess in den Hintergrund zu stellen, aber sobald ich mein Terminal schließe, wird der Prozess ebenfalls beendet.

Wie kann ich es laufen lassen, wenn ich meinen lokalen Computer herunterfahre?

Top-Lösungen :

• Systemd (Linux)
• Launchd (Mac)
• Knotenfenster (Windows)
• PM2 (Node.js)

Kopieren meiner eigenen Antwort von Wie führe ich eine Node.js-Anwendung als eigenen Prozess aus?

Antwort 2015 : Fast jede Linux-Distribution wird mit systemd geliefert , was bedeutet , dass Monit, PM2 usw. für immer nicht mehr erforderlich sind - Ihr Betriebssystem erledigt diese Aufgaben bereits .

myapp.serviceErstellen Sie eine Datei (ersetzen Sie 'myapp' natürlich durch den Namen Ihrer App):

[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

Beachten Sie, wenn Sie neu in Unix sind: /var/www/myapp/app.js sollte #!/usr/bin/env nodein der ersten Zeile stehen.

Kopieren Sie Ihre Servicedatei in die /etc/systemd/system.

Beginnen Sie mit systemctl start myapp.

Aktivieren Sie es, um beim Booten mit ausgeführt zu werden systemctl enable myapp.

Siehe Protokolle mit journalctl -u myapp

Dies stammt aus der Bereitstellung von Knoten-Apps unter Linux, Ausgabe 2018 , die auch Befehle zum Generieren einer AWS / DigitalOcean / Azure CloudConfig zum Erstellen von Linux / Knotenservern (einschließlich der .serviceDatei) enthält.

Sie können Forever, ein einfaches CLI-Tool, verwenden, um sicherzustellen, dass ein bestimmtes Knotenskript kontinuierlich (dh für immer) ausgeführt wird: https://www.npmjs.org/package/forever

UPDATE - Wie in einer der folgenden Antworten erwähnt, hat PM2 einige wirklich nette Funktionen, die für immer fehlen. Erwägen Sie, es zu verwenden.

Ursprüngliche Antwort

Verwenden Sie nohup :

nohup node server.js &

BEARBEITEN Ich wollte hinzufügen, dass die akzeptierte Antwort wirklich der richtige Weg ist. Ich verwende für immer Instanzen, die aufbleiben müssen. Ich mache das gerne npm install -g foreverim Knotenpfad und mache es dann einfachforever start server.js

Dies ist möglicherweise nicht der akzeptierte Weg, aber ich mache es mit dem Bildschirm, insbesondere während der Entwicklung, weil ich ihn wieder aufrufen und bei Bedarf damit herumalbern kann.

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

Der Bildschirm löst sich und überlebt das Abmelden. Dann können Sie es wieder zurückholen, indem Sie Bildschirm -r ausführen. Weitere Informationen finden Sie im Bildschirmhandbuch. Sie können die Bildschirme benennen und so weiter, wenn Sie möchten.

Update 2016: Die Node-Windows / Mac / Linux-Serie verwendet eine gemeinsame API für alle Betriebssysteme, daher ist sie eine absolut relevante Lösung. Jedoch; node-linux generiert systemv init-Dateien. Da systemd immer beliebter wird, ist es unter Linux realistisch gesehen eine bessere Option. PR ist willkommen, wenn jemand Systemd-Unterstützung zu Node-Linux hinzufügen möchte :-)

Original-Thread:

Dies ist jetzt ein ziemlich alter Thread, aber Node-Windows bietet eine andere Möglichkeit, Hintergrunddienste unter Windows zu erstellen. Es basiert lose auf dem nssmKonzept der Verwendung eines exeWrappers um Ihr Knotenskript. Jedoch; es nutzt winsw.exestatt und stellt einen konfigurierbaren Knoten Wrapper für weitere granulare Kontrolle darüber , wie der Prozess startet / stoppt auf Ausfälle. Diese Prozesse sind wie jeder andere Dienst verfügbar:

Das Modul backt auch einige Ereignisprotokolle:

Die Dämonisierung Ihres Skripts erfolgt über Code. Zum Beispiel:

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();

Das Modul unterstützt Dinge wie das Begrenzen von Neustarts (damit schlechte Skripte Ihren Server nicht beschädigen) und das Erhöhen der Zeitintervalle zwischen Neustarts.

Da Node-Windows-Dienste wie alle anderen ausgeführt werden, ist es möglich, den Dienst mit der bereits verwendeten Software zu verwalten / überwachen.

Schließlich gibt es keine makeAbhängigkeiten. Mit anderen Worten, eine einfache npm install -g node-windowswird funktionieren. Sie benötigen keine Visual Studio-, .NET- oder Node-Gyp-Magie, um dies zu installieren. Außerdem ist es MIT- und BSD-lizenziert.

Bei vollständiger Offenlegung bin ich der Autor dieses Moduls. Es wurde entwickelt, um die genauen Schmerzen des OP zu lindern, aber mit einer engeren Integration in die Funktionalität, die das Betriebssystem bereits bietet. Ich hoffe, zukünftige Zuschauer mit derselben Frage finden es nützlich.

UPDATE : Ich habe aktualisiert, um das Neueste von pm2 aufzunehmen:

Für viele Anwendungsfälle ist die Verwendung eines systemd-Dienstes die einfachste und am besten geeignete Methode zum Verwalten eines Knotenprozesses. Für diejenigen, die zahlreiche Knotenprozesse oder unabhängig voneinander ausgeführte Knoten-Mikrodienste in einer einzigen Umgebung ausführen, ist pm2 ein umfassenderes Tool.

https://github.com/unitech/pm2

http://pm2.io

• Es hat eine wirklich nützliche Überwachungsfunktion -> hübsche 'GUI' für die Befehlszeilenüberwachung mehrerer Prozesse mit pm2 monitoder Prozessliste mitpm2 list
• organisierte Protokollverwaltung -> pm2 logs
• andere Sachen:

  • Verhaltenskonfiguration
  • Unterstützung der Quellkarte
  • PaaS-kompatibel
  • Anschauen & Nachladen
  • Modulsystem
  • Maximales Neuladen des Speichers
  • Cluster-Modus
  • Hot Reload
  • Entwicklungsworkflow
  • Startskripte
  • Automatische Vervollständigung
  • Bereitstellungsworkflow
  • Keymetrics-Überwachung
  • API

Wenn Sie das Skript einfach bis zum Abschluss ununterbrochen ausführen möchten, können Sie es nohupwie bereits in den Antworten hier erwähnt verwenden. Keine der Antworten enthält jedoch einen vollständigen Befehl, der auch stdinund protokolliert stdout.

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

• Die >>Mittel hängen an app.log.
• 2>&1stellt sicher, dass Fehler auch an die gesendet stdoutund hinzugefügt werden app.log.
• Das Ende &stellt sicher, dass Ihr aktuelles Terminal vom Befehl getrennt ist, damit Sie weiterarbeiten können.

Wenn Sie einen Knotenserver ausführen möchten (oder etwas, das beim Neustart des Servers wieder gestartet werden soll), sollten Sie systemd / systemctl verwenden .

Wenn Sie OSX ausführen, können Sie einen echten Systemprozess am einfachsten erstellen launchd, indem Sie ihn starten.

Erstellen Sie eine solche Liste und fügen Sie sie mit dem Namen in die / Library / LaunchDaemons ein top-level-domain.your-domain.application.plist(Sie müssen beim Platzieren root sein):

<?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>

Wenn Sie fertig sind, geben Sie Folgendes aus (als root):

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

und du rennst.

Und Sie werden nach einem Neustart immer noch ausgeführt.

Weitere Optionen in der Liste finden Sie auf der Manpage hier: https://developer.apple.com/library/mac/documentation/Darwin/Reference/Manpages/man5/launchd.plist.5.html

Versuchen Sie, diesen Befehl auszuführen, wenn Sie nohup verwenden -

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

Sie können den Server auch für immer starten

forever start -c "npm start" ./ 

PM2 unterstützt auch npm start

pm2 start npm -- start

Ich benutze einfach das Daemon npm Modul:

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
});

In letzter Zeit verwende ich auch mon (1) von TJ Holowaychuk , um einfache Knoten-Apps zu starten und zu verwalten.

Ich benutze Supervisor für die Entwicklung. Es funktioniert einfach. Wann immer Sie Änderungen an einer .js-Datei vornehmen, startet Supervisor Ihre App automatisch mit diesen geladenen Änderungen neu.

Hier ist ein Link zu seiner Github-Seite

Installieren :

sudo npm Install Supervisor -g

Mit -e können Sie ganz einfach andere Erweiterungen anzeigen lassen. Ein anderer Befehl, den ich oft benutze, ist -i, um bestimmte Ordner zu ignorieren.

Sie können nohup und Supervisor verwenden, um Ihre Knoten-App auch nach dem Abmelden im Hintergrund auszuführen.

sudo nohup Supervisor myapp.js &

Node.js als Hintergrunddienst in WINDOWS XP

• Kudos geht an Hacksparrow unter: http://www.hacksparrow.com/install-node-js-and-npm-on-windows.html für ein Tutorial zur Installation von Node.js + npm für Windows.
• Ein großes Lob geht an Tatham Oddie unter: http://blog.tatham.oddie.com.au/2011/03/16/node-js-on-windows/ für die Implementierung von nnsm.exe.

Installation:

1. Installieren Sie WGET http://gnuwin32.sourceforge.net/packages/wget.htm über die ausführbare Datei des Installationsprogramms
2. Installieren Sie GIT http://code.google.com/p/msysgit/downloads/list über die ausführbare Datei des Installationsprogramms
3. Installieren Sie NSSM http://nssm.cc/download/?page=download , indem Sie nnsm.exe in den Ordner% windir% / system32 kopieren

4. Erstellen Sie 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. Öffnen Sie die Befehlskonsole und geben Sie Folgendes ein (setx nur, wenn Resource Kit installiert ist)

   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. Ein nützlicher Batch-Goodie ist das Erstellen von c: \ node \ ServiceMe.cmd

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

Service-Management:

• Auf die Dienste selbst kann jetzt über Start-> Ausführen-> services.msc oder über Start-> Ausführen-> MSCONFIG-> Dienste zugegriffen werden (und aktivieren Sie "Alle Microsoft-Dienste ausblenden").
• Das Skript stellt jedem Knoten, der über das Batch-Skript erstellt wurde, 'node-' voran.
• Ebenso finden Sie sie in der Registrierung: " HKLM \ SYSTEM \ CurrentControlSet \ Services \ node-xxxx "

Die akzeptierte Antwort ist wahrscheinlich die beste Produktionsantwort, aber für einen schnellen Hack, der Entwicklungsarbeit leistet, habe ich Folgendes gefunden:

nodejs scriptname.js & hat nicht funktioniert, weil nodejs das & zu verschlingen schien, und so ließ mich das Ding das Terminal nicht weiter benutzen, ohne dass scriptname.js starb.

Aber ich habe nodejs scriptname.jseine .sh-Datei eingefügt und nohup sh startscriptname.sh &gearbeitet.

Auf jeden Fall keine Produktionssache, aber es löst das Problem "Ich muss mein Terminal weiter verwenden und möchte nicht 5 verschiedene Terminals starten".

Wenn Sie NodeJS auf einem Linux-Server ausführen, ist dies meiner Meinung nach der beste Weg.

Erstellen Sie ein Service-Skript und kopieren Sie es in /etc/init/nodejs.conf

Dienst starten: sudo service nodejs start

Dienst beenden: sudo service nodejs stop

Service-Skript

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

Juni 2017 Update:
Lösung für Linux: (Red Hat). Vorherige Kommentare funktionieren bei mir nicht. Dies funktioniert für mich bei Amazon Web Service - Red Hat 7. Ich hoffe, dies funktioniert für jemanden da draußen.

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

Verwenden Sie nssm, die beste Lösung für Windows. Laden Sie einfach nssm herunter , öffnen Sie cmd im Verzeichnis nssm und geben Sie ein

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

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

Dadurch wird ein neuer Windows-Dienst installiert, der unter services.msc aufgeführt wird. Von dort aus können Sie den Dienst starten oder stoppen. Dieser Dienst wird automatisch gestartet und Sie können den Neustart konfigurieren, wenn er fehlschlägt.

Um die verschiedenen vorgeschlagenen Optionen abzurunden, gibt es noch einen: den daemonBefehl in GNU / Linux, über den Sie hier lesen können: http://libslack.org/daemon/manpages/daemon.1.html . (Entschuldigung, wenn dies bereits in einem der obigen Kommentare erwähnt wurde).

Schauen Sie sich die Fuge an! Abgesehen davon, dass Sie viele Worker starten, können Sie auch Ihren Knotenprozess dämonisieren!

http://github.com/pgte/fugue

Hat jemand einen trivialen Fehler in der Position von "2> & 1" bemerkt?

2>&1 >> file

sollte sein

>> file 2>&1

Ich verwende tmux für eine Entwicklungsumgebung mit mehreren Fenstern / Fenstern auf Remote-Hosts. Es ist wirklich einfach, den Prozess zu trennen und im Hintergrund laufen zu lassen. Schauen Sie sich tmux an

Für Benutzer neuerer Versionen des Daemon npm-Moduls müssen Sie Dateideskriptoren anstelle von Zeichenfolgen übergeben:

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 ist ein Produktionsprozessmanager für Node.js-Anwendungen mit integriertem Load Balancer. Sie können Anwendungen für immer am Leben erhalten, sie ohne Ausfallzeiten neu laden und allgemeine Systemadministrationsaufgaben vereinfachen. https://github.com/Unitech/pm2

Ich bin überrascht, dass niemand Guvnor erwähnt hat

Ich habe es für immer versucht, pm2 usw. Aber wenn es um solide Kontrolle und webbasierte Leistungsmetriken geht, habe ich festgestellt, dass Guvnor bei weitem das Beste ist. Außerdem ist es vollständig OpenSource.

Bearbeiten: Ich bin mir jedoch nicht sicher, ob es unter Windows funktioniert. Ich habe es nur unter Linux verwendet.

Da mir diese Option in der Liste der bereitgestellten Antworten fehlt, möchte ich ab 2020 eine geeignete Option hinzufügen: Docker oder eine gleichwertige Containerplattform . Neben der Sicherstellung, dass Ihre Anwendung in einer stabilen Umgebung funktioniert, bieten sich zusätzliche Sicherheitsvorteile sowie eine verbesserte Portabilität.

Es gibt Docker-Unterstützung für Windows, MacOS und die meisten / großen Linux-Distributionen. Die Installation von Docker auf einer unterstützten Plattform ist recht einfach und gut dokumentiert. Das Einrichten einer Node.js-Anwendung ist so einfach wie das Einfügen in einen Container und das Ausführen dieses Containers, während sichergestellt wird, dass er nach dem Herunterfahren neu gestartet wird.

Container-Image erstellen

Angenommen, Ihre Anwendung ist in / home / me / my-app auf diesem Server verfügbar , erstellen Sie eine Textdatei Dockerfile im Ordner / home / me / my-app mit ähnlichen Inhalten:

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

Erstellen Sie das Bild mit dem folgenden Befehl:

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

Hinweis: Der letzte Parameter wählt den Ordner aus, der diese Docker-Datei anstelle der Docker-Datei selbst enthält. Sie können mit der Option -f eine andere auswählen .

Container starten

Verwenden Sie diesen Befehl zum Starten des Containers:

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

Dieser Befehl setzt voraus, dass Ihre App Port 3000 überwacht und Sie möchten, dass sie auf Port 80 Ihres Hosts verfügbar gemacht wird.

Dies ist sicherlich ein sehr begrenztes Beispiel, aber es ist ein guter Ausgangspunkt.

Wenn Sie pm2 verwenden, können Sie es mit autorestartset to verwenden false:

$ pm2 Ökosystem

Dadurch wird ein Beispiel generiert 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 start ecosystem.config.js

Diese Antwort ist für die Partei ziemlich spät, aber ich fand, dass die beste Lösung darin bestand, ein Shell-Skript zu schreiben, das sowohl die Befehle als auch die Befehle screen -dmSund verwendet nohup.

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

Ich füge auch das >> logfileBit am Ende hinzu, damit ich die Knotenanweisungen einfach speichern kann console.log().

Warum habe ich ein Shell-Skript verwendet? Nun, ich habe auch eine if-Anweisung hinzugefügt, die überprüft, ob der node myserver.jsProzess bereits ausgeführt wurde.

Auf diese Weise konnte ich eine einzelne Befehlszeilenoption erstellen, mit der ich den Server am Laufen halten und neu starten kann, wenn ich Änderungen vorgenommen habe, was für die Entwicklung sehr hilfreich ist.