¿Cómo ejecuto una aplicación node.js como servicio en segundo plano?

Dado que esta publicación ha recibido mucha atención a lo largo de los años, he enumerado las mejores soluciones por plataforma al final de esta publicación.

Publicación original :

Quiero que mi servidor node.js se ejecute en segundo plano, es decir: cuando cierro mi terminal quiero que mi servidor siga ejecutándose. He buscado en Google esto y se me ocurrió este tutorial , sin embargo, no funciona según lo previsto. Entonces, en lugar de usar esa secuencia de comandos de daemon, pensé que solo usé la redirección de salida (la 2>&1 >> fileparte), pero esto tampoco sale: obtengo una línea en blanco en mi terminal, como si estuviera esperando salida / errores.

También he tratado de poner el proceso en segundo plano, pero tan pronto como cierro mi terminal, el proceso también se cierra.

Entonces, ¿cómo puedo dejarlo funcionando cuando apago mi computadora local?

Las mejores soluciones :

• Systemd (Linux)
• Lanzado (Mac)
• ventanas de nodo (Windows)
• PM2 (Node.js)

Copiando mi propia respuesta de ¿Cómo ejecuto una aplicación Node.js como su propio proceso?

Respuesta de 2015 : casi todas las distribuciones de Linux vienen con systemd, lo que significa que para siempre, monit, PM2, etc., ya no son necesarias: su sistema operativo ya maneja estas tareas .

Cree un myapp.servicearchivo (reemplazando 'myapp' con el nombre de su aplicación, obviamente):

[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

Tenga en cuenta si es nuevo en Unix: /var/www/myapp/app.js debería tenerlo #!/usr/bin/env nodeen la primera línea.

Copie su archivo de servicio en el /etc/systemd/system.

Comenzar con systemctl start myapp.

Permitir que se ejecute en el arranque con systemctl enable myapp.

Ver registros con journalctl -u myapp

Esto se ha tomado de Cómo implementamos aplicaciones de nodo en Linux, edición 2018 , que también incluye comandos para generar un AWS / DigitalOcean / Azure CloudConfig para construir servidores Linux / nodo (incluido el .servicearchivo).

Puede usar Forever, una herramienta CLI simple para garantizar que un script de nodo dado se ejecute continuamente (es decir, para siempre): https://www.npmjs.org/package/forever

ACTUALIZACIÓN : como se menciona en una de las respuestas a continuación, PM2 tiene una funcionalidad realmente agradable que falta para siempre. Considera usarlo.

Respuesta original

Use nohup :

nohup node server.js &

EDITAR Quería agregar que la respuesta aceptada es realmente el camino a seguir. Estoy usando para siempre en instancias que necesitan mantenerse en pie. Me gusta hacerlo npm install -g forever, está en la ruta del nodo y luego simplemente hagoforever start server.js

Puede que esta no sea la forma aceptada, pero lo hago con la pantalla, especialmente durante el desarrollo, porque puedo recuperarlo y engañarlo si es necesario.

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

La pantalla se separará y sobrevivirá cuando cierre la sesión. Luego puede recuperarlo haciendo screen -r. Pulse el manual de la pantalla para más detalles. Puede nombrar las pantallas y otras cosas si lo desea.

Actualización de 2016: la serie node-windows / mac / linux utiliza una API común en todos los sistemas operativos, por lo que es una solución absolutamente relevante. Sin embargo; node-linux genera archivos systemv init. A medida que systemd continúa creciendo en popularidad, en realidad es una mejor opción en Linux. Los RP son bienvenidos si alguien quiere agregar soporte systemd a node-linux :-)

Hilo original:

Este es un hilo bastante antiguo ahora, pero node-windows proporciona otra forma de crear servicios en segundo plano en Windows. Se basa libremente en el nssmconcepto de usar un execontenedor alrededor de su script de nodo. Sin embargo; en su winsw.exelugar, utiliza y proporciona un contenedor de nodo configurable para un control más granular sobre cómo se inicia / detiene el proceso en caso de fallas. Estos procesos están disponibles como cualquier otro servicio:

El módulo también se hornea en algunos registros de eventos:

Daemonizar su script se logra a través del código. Por ejemplo:

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

El módulo admite cosas como reinicios de límite (para que los scripts incorrectos no mangueen su servidor) e intervalos de tiempo crecientes entre reinicios.

Dado que los servicios de nodo-Windows se ejecutan como cualquier otro, es posible administrar / monitorear el servicio con cualquier software que ya use.

Finalmente, no hay makedependencias. En otras palabras, un sencillonpm install -g node-windows funcionará. No necesita Visual Studio, .NET o node-gyp magic para instalar esto. Además, tiene licencia MIT y BSD.

En total divulgación, soy el autor de este módulo. Fue diseñado para aliviar el dolor exacto que experimentó el OP, pero con una integración más estrecha en la funcionalidad que el sistema operativo ya proporciona. Espero que los futuros espectadores con esta misma pregunta lo encuentren útil.

ACTUALIZACIÓN : actualicé para incluir lo último de pm2:

Para muchos casos de uso, el uso de un servicio systemd es la forma más sencilla y adecuada de administrar un proceso de nodo. Para aquellos que ejecutan numerosos procesos de nodo o microservicios de nodo de ejecución independiente en un solo entorno, pm2 es una herramienta más completa.

https://github.com/unitech/pm2

http://pm2.io

• tiene una función de monitoreo realmente útil -> bonita 'gui' para monitoreo de línea de comando de múltiples procesos con pm2 monito lista de procesos conpm2 list
• Gestión organizada de registros -> pm2 logs
• otras cosas:

  • Configuración de comportamiento
  • Soporte de mapa fuente
  • Compatible con PaaS
  • Mira y recarga
  • Sistema de módulos
  • Max recarga de memoria
  • Modo de clúster
  • Recarga en caliente
  • Flujo de trabajo de desarrollo
  • Guiones de inicio
  • Autocompletar
  • Flujo de trabajo de implementación
  • Monitoreo de Keymetrics
  • API

Si simplemente desea ejecutar el script sin interrupciones hasta que se complete, puede usarlo nohupcomo ya se mencionó en las respuestas aquí. Sin embargo, ninguna de las respuestas proporciona un comando completo que también registre stdiny stdout.

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

• Los >>medios anexan app.log.
• 2>&1se asegura de que los errores también se envíen stdouty se agreguen a app.log.
• El final &asegura que su terminal actual esté desconectada del comando para que pueda continuar trabajando.

Si desea ejecutar un servidor de nodo (o algo que debería iniciarse una vez que se reinicie el servidor) debe usar systemd / systemctl .

Si está ejecutando OSX, entonces la forma más fácil de producir un verdadero proceso del sistema es usarlo launchdpara iniciarlo.

Cree un plist como este y colóquelo en / Library / LaunchDaemons con el nombre top-level-domain.your-domain.application.plist(debe ser root al colocarlo):

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

Cuando termine, emita esto (como root):

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

y tu estas corriendo

Y seguirá ejecutándose después de reiniciar.

Para otras opciones en la lista, vea la página de manual aquí: https://developer.apple.com/library/mac/documentation/Darwin/Reference/Manpages/man5/launchd.plist.5.html

Intente ejecutar este comando si está utilizando nohup -

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

También puedes usar forever para iniciar el servidor

forever start -c "npm start" ./ 

PM2 también es compatible npm start

pm2 start npm -- start

Simplemente estoy usando el módulo 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
});

Últimamente también estoy usando mon (1) de TJ Holowaychuk para iniciar y administrar aplicaciones de nodo simples.

Yo uso Supervisor para el desarrollo. Simplemente funciona Cada vez que realiza cambios en un archivo .js, Supervisor reinicia automáticamente su aplicación con esos cambios cargados.

Aquí hay un enlace a su página de Github

Instalar en pc :

supervisor de instalación de sudo npm -g

Puede hacer que vea otras extensiones fácilmente con -e. Otro comando que uso a menudo es -i para ignorar ciertas carpetas.

Puede usar nohup y supervisor para hacer que su aplicación de nodo se ejecute en segundo plano incluso después de cerrar sesión.

sudo nohup supervisor myapp.js &

Node.js como un servicio en segundo plano en WINDOWS XP

• Kudos va a Hacksparrow en: http://www.hacksparrow.com/install-node-js-and-npm-on-windows.html para obtener un tutorial de instalación de Node.js + npm para Windows.
• Kudos va a Tatham Oddie en: http://blog.tatham.oddie.com.au/2011/03/16/node-js-on-windows/ para la implementación de nnsm.exe.

Instalación:

1. Instale WGET http://gnuwin32.sourceforge.net/packages/wget.htm a través del ejecutable del instalador
2. Instale GIT http://code.google.com/p/msysgit/downloads/list a través del ejecutable del instalador
3. Instale NSSM http://nssm.cc/download/?page=download copiando nnsm.exe en la carpeta% windir% / system32

4. Crear 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. Abra la consola de comandos y escriba lo siguiente (setx solo si está instalado el Kit de recursos)

   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 ingenioso lote es crear c: \ node \ ServiceMe.cmd

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

Gestión De Servicios:

• Ahora se puede acceder a los servicios en sí a través de Inicio-> Ejecutar-> services.msc o en Inicio-> Ejecutar-> MSCONFIG-> Servicios (y marque 'Ocultar todos los servicios de Microsoft').
• El script prefijará cada nodo realizado a través del script por lotes con 'node-'.
• Del mismo modo, se pueden encontrar en el registro: " HKLM \ SYSTEM \ CurrentControlSet \ Services \ node-xxxx "

La respuesta aceptada es probablemente la mejor respuesta de producción, pero para un truco rápido haciendo trabajo de desarrollo, encontré esto:

nodejs scriptname.js & no funcionó, porque nodejs parecía engullir el &, por lo que la cosa no me permitió seguir usando el terminal sin que scriptname.js muriera.

Pero puse nodejs scriptname.jsun archivo .sh y nohup sh startscriptname.sh &trabajé.

Definitivamente no es una cosa de producción, pero resuelve el problema "Necesito seguir usando mi terminal y no quiero iniciar 5 terminales diferentes".

Si está ejecutando nodejs en el servidor Linux, creo que esta es la mejor manera.

Cree un script de servicio y cópielo en /etc/init/nodejs.conf

servicio de inicio: inicio de sudo service nodejs

detener el servicio: sudo service nodejs stop

Secuencia de comandos de servicio

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

Actualización de junio de 2017:
Solución para Linux: (Red hat). Los comentarios anteriores no me funcionan. Esto funciona para mí en Amazon Web Service - Red Hat 7. Espero que esto funcione para alguien por ahí.

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

use nssm la mejor solución para Windows, simplemente descargue nssm , abra cmd en el directorio nssm y escriba

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

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

esto instalará un nuevo servicio de Windows que se enumerará en services.msc desde allí, puede iniciar o detener el servicio, este servicio se iniciará automáticamente y puede configurarlo para reiniciar si falla.

Para completar las diversas opciones sugeridas, aquí hay una más: el daemoncomando en GNU / Linux, sobre el que puede leer aquí: http://libslack.org/daemon/manpages/daemon.1.html . (disculpas si esto ya se menciona en uno de los comentarios anteriores).

¡Mira la fuga! Además de lanzar muchos trabajadores, ¡también puedes demonizar tu proceso de nodo!

http://github.com/pgte/fugue

¿Alguien ha notado un error trivial de la posición de "2> y 1"?

2>&1 >> file

debiera ser

>> file 2>&1

Uso tmux para un entorno de desarrollo de múltiples ventanas / paneles en hosts remotos. Es realmente sencillo separar y mantener el proceso ejecutándose en segundo plano. Echa un vistazo a tmux

Para las personas que usan versiones más recientes del módulo daemon npm, debe pasar descriptores de archivo en lugar de cadenas:

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 es un administrador de procesos de producción para aplicaciones Node.js con un equilibrador de carga incorporado. Le permite mantener las aplicaciones vivas para siempre, volver a cargarlas sin tiempo de inactividad y facilitar las tareas comunes de administración del sistema. https://github.com/Unitech/pm2

Me sorprende que nadie haya mencionado a Guvnor

Lo he intentado para siempre, pm2, etc. Pero, cuando se trata de control sólido y métricas de rendimiento basadas en la web, he encontrado que Guvnor es, con mucho, el mejor. Además, también es completamente de código abierto.

Editar: Sin embargo, no estoy seguro de si funciona en Windows. Solo lo he usado en Linux.

Como me falta esta opción en la lista de respuestas proporcionadas, me gustaría agregar una opción elegible a partir de 2020: docker o cualquier contenedor equivalente plataforma de . Además de garantizar que su aplicación funcione en un entorno estable, existen beneficios de seguridad adicionales, así como una portabilidad mejorada.

Hay compatibilidad con Docker para Windows, macOS y la mayoría / las principales distribuciones de Linux. Instalar docker en una plataforma compatible es bastante sencillo y está bien documentado. Configurar una aplicación Node.js es tan simple como ponerlo en un contenedor y ejecutar ese contenedor mientras se asegura de que se reinicie después del apagado.

Crear imagen de contenedor

Suponiendo que su aplicación esté disponible en / home / me / my-app en ese servidor, cree un archivo Dockerfile en la carpeta / home / me / my-app con contenido similar a este:

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

Cree la imagen usando un comando como este:

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

Nota: El último parámetro es seleccionar la carpeta que contiene ese Dockerfile en lugar del Dockerfile en sí. Puede elegir uno diferente usando la opción -f .

Iniciar contenedor

Use este comando para iniciar el contenedor:

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

Este comando asume que su aplicación está escuchando en el puerto 3000 y desea que quede expuesta en el puerto 80 de su host.

Este es un ejemplo muy limitado, pero es un buen punto de partida.

Si está usando pm2, puede usarlo con autorestartset to false:

ecosistema $ pm2

Esto generará una muestra 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 inicio ecosistema.config.js

Esta respuesta llega bastante tarde a la fiesta, pero descubrí que la mejor solución era escribir un script de shell que utilizara los comandos screen -dmSy nohup.

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

También agrego el >> logfilebit al final para poder guardar fácilmente las console.log()declaraciones de nodo .

¿Por qué utilicé un script de shell? Bueno, también agregué una declaración if que verificó si el node myserver.jsproceso ya se estaba ejecutando.

De esa manera pude crear una opción de línea de comando única que me permite mantener el servidor en funcionamiento y también reiniciarlo cuando he realizado cambios, lo cual es muy útil para el desarrollo.