Como executo um aplicativo node.js. como um serviço em segundo plano?

Como esta postagem recebeu muita atenção ao longo dos anos, listei as principais soluções por plataforma na parte inferior desta postagem.

Post original :

Eu quero que meu servidor node.js. seja executado em segundo plano, ou seja: quando eu fechar meu terminal, quero que meu servidor continue funcionando. Eu pesquisei isso no Google e criei este tutorial , mas ele não funciona conforme o esperado. Então, ao invés de usar esse script daemon, pensei 2>&1 >> fileque havia usado o redirecionamento de saída (a parte), mas isso também não sai - recebo uma linha em branco no meu terminal, como se estivesse esperando por erros / saída.

Eu também tentei colocar o processo em segundo plano, mas assim que fecho meu terminal, o processo também é interrompido.

Então, como posso deixá-lo em execução quando eu desligo o computador local?

Principais soluções :

• Systemd (Linux)
• Launchd (Mac)
• janelas do nó (Windows)
• PM2 (Node.js)

Copiando minha própria resposta de Como executo um aplicativo Node.js. como seu próprio processo?

Resposta de 2015 : quase todas as distribuições Linux vêm com systemd, o que significa que para sempre, monit, PM2, etc não são mais necessários - seu sistema operacional já lida com essas tarefas .

Crie um myapp.servicearquivo (substituindo 'myapp' pelo nome do seu aplicativo, 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

Observe se você é novo no Unix: /var/www/myapp/app.js deve ter #!/usr/bin/env nodena primeira linha.

Copie seu arquivo de serviço para o /etc/systemd/system.

Comece com systemctl start myapp.

Habilite para rodar na inicialização com systemctl enable myapp.

Veja logs com journalctl -u myapp

Isso é retirado de Como implantamos aplicativos de nó no Linux, edição 2018 , que também inclui comandos para gerar um AWS / DigitalOcean / Azure CloudConfig para criar servidores Linux / nó (incluindo o .servicearquivo).

Você pode usar o Forever, uma ferramenta CLI simples para garantir que um determinado script de nó seja executado continuamente (ou seja, para sempre): https://www.npmjs.org/package/forever

ATUALIZAÇÃO - Conforme mencionado em uma das respostas abaixo, o PM2 tem algumas funcionalidades realmente boas que faltam para sempre. Considere usá-lo.

Resposta original

Use nohup :

nohup node server.js &

Edição Gostaria de acrescentar que a resposta aceita é realmente o caminho a percorrer. Estou usando para sempre em instâncias que precisam permanecer acordadas. Eu gosto de fazê- npm install -g foreverlo, é no caminho do nó e, em seguida, basta fazerforever start server.js

Essa pode não ser a maneira aceita, mas eu faço isso com a tela, especialmente durante o desenvolvimento, porque posso recuperá-la e enganá-la, se necessário.

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

A tela será desconectada e você sobreviverá ao fazer logoff. Então você pode recuperá-lo novamente fazendo a tela -r. Acesse o manual da tela para obter mais detalhes. Você pode nomear as telas e outros enfeites, se quiser.

Atualização de 2016: A série node-windows / mac / linux usa uma API comum em todos os sistemas operacionais, portanto é uma solução absolutamente relevante. Contudo; O node-linux gera arquivos init do systemv. À medida que o systemd continua a crescer em popularidade, é realisticamente uma opção melhor no Linux. Os PR são bem-vindos se alguém quiser adicionar suporte systemd ao node-linux :-)

Tópico original:

Este é um encadeamento bastante antigo agora, mas o node-windows fornece outra maneira de criar serviços em segundo plano no Windows. É vagamente baseado no nssmconceito de uso de um exewrapper em torno do script do nó. Contudo; ele usa em winsw.exevez disso e fornece um invólucro de nó configurável para controle mais granular sobre como o processo inicia / para em falhas. Esses processos estão disponíveis como qualquer outro serviço:

O módulo também utiliza alguns logs de eventos:

Daemonizing seu script é realizado através do código. Por exemplo:

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

O módulo suporta coisas como limitar as reinicializações (para que scripts ruins não mantenham o servidor) e intervalos de tempo crescentes entre as reinicializações.

Como os serviços node-windows são executados como qualquer outro, é possível gerenciar / monitorar o serviço com o software que você já usa.

Finalmente, não há makedependências. Em outras palavras, um simplesnpm install -g node-windows funcionará. Você não precisa da mágica do Visual Studio, .NET ou node-gyp para instalar isso. Além disso, é licenciado para MIT e BSD.

Na divulgação completa, sou o autor deste módulo. Ele foi projetado para aliviar a dor exata que o OP experimentou, mas com uma integração mais estreita à funcionalidade que o Sistema Operacional já oferece. Espero que os futuros espectadores com essa mesma pergunta achem útil.

UPDATE : atualizei para incluir as últimas do pm2:

para muitos casos de uso, o uso de um serviço systemd é a maneira mais simples e apropriada de gerenciar um processo do nó. para aqueles que executam vários processos de nó ou microsserviços de nó de execução independente em um único ambiente, o pm2 é uma ferramenta com mais recursos.

https://github.com/unitech/pm2

http://pm2.io

• possui um recurso de monitoramento realmente útil -> bastante 'gui' para o monitoramento por linha de comando de vários processos pm2 monitou lista de processos compm2 list
• Gerenciamento organizado de logs -> pm2 logs
• outras coisas:

  • Configuração de comportamento
  • Suporte ao mapa de origem
  • Compatível com PaaS
  • Assista e recarregue
  • Sistema de módulos
  • Recarga máxima de memória
  • Modo de cluster
  • Recarga a quente
  • Fluxo de trabalho de desenvolvimento
  • Scripts de inicialização
  • Conclusão automática
  • Fluxo de trabalho de implantação
  • Monitoramento de keymetrics
  • API

Se você deseja simplesmente executar o script ininterruptamente até que seja concluído, use-o nohupcomo já mencionado nas respostas aqui. No entanto, nenhuma das respostas fornece um comando completo que também registra stdine stdout.

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

• Os >>meios anexados a app.log.
• 2>&1garante que os erros também sejam enviados stdoute adicionados ao arquivo app.log.
• A finalização &garante que o seu terminal atual esteja desconectado do comando para que você possa continuar trabalhando.

Se você deseja executar um servidor de nó (ou algo que deve ser iniciado quando o servidor reiniciar), use systemd / systemctl .

Se você estiver executando o OSX, a maneira mais fácil de produzir um verdadeiro processo do sistema é usá launchd-lo para iniciá-lo.

Crie uma lista como esta e coloque-a em / Library / LaunchDaemons com o nome top-level-domain.your-domain.application.plist(você precisa ser root ao colocá-la):

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

Quando terminar, emita este (como root):

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

e você está correndo.

E você ainda estará executando após uma reinicialização.

Para outras opções na lista, consulte a página de manual aqui: https://developer.apple.com/library/mac/documentation/Darwin/Reference/Manpages/man5/launchd.plist.5.html

Tente executar este comando se você estiver usando nohup -

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

Você também pode usar para sempre para iniciar o servidor

forever start -c "npm start" ./ 

O PM2 também suporta npm start

pm2 start npm -- start

Estou simplesmente usando o 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
});

Ultimamente, também estou usando o mon (1) do TJ Holowaychuk para iniciar e gerenciar aplicativos de nó simples.

Eu uso o Supervisor para desenvolvimento. Isso simplesmente funciona. Sempre que você faz alterações em um arquivo .js, o Supervisor reinicia automaticamente seu aplicativo com essas alterações carregadas.

Aqui está um link para sua página do Github

Instalar:

sudo npm install supervisor -g

Você pode facilmente assistir outras extensões com -e. Outro comando que uso com freqüência é -i para ignorar determinadas pastas.

Você pode usar nohup e supervisor para fazer com que o aplicativo do nó seja executado em segundo plano, mesmo após o logout.

supervisor sudo nohup myapp.js e

Node.js como um serviço em segundo plano no WINDOWS XP

• O Kudos vai para Hacksparrow em: http://www.hacksparrow.com/install-node-js-and-npm-on-windows.html para obter instruções sobre como instalar o Node.js + npm no Windows.
• O kudos vai para Tatham Oddie em: http://blog.tatham.oddie.com.au/2011/03/16/node-js-on-windows/ para implementação do nnsm.exe.

Instalação:

1. Instale o WGET http://gnuwin32.sourceforge.net/packages/wget.htm através do executável do instalador
2. Instale o GIT http://code.google.com/p/msysgit/downloads/list através do executável do instalador
3. Instale o NSSM http://nssm.cc/download/?page=download através da cópia do nnsm.exe na pasta% windir% / system32

4. Crie 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 o console de comando e digite o seguinte (setx apenas se o Resource Kit estiver instalado)

   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. Uma boa opção de lote é criar c: \ node \ ServiceMe.cmd

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

Gerenciamento de serviços:

• Os serviços em si agora estão acessíveis em Iniciar-> Executar-> services.msc ou em Iniciar-> Executar-> MSCONFIG-> Serviços (e marque 'Ocultar todos os serviços da Microsoft').
• O script prefixará cada nó criado por meio do script em lote com 'node-'.
• Da mesma forma, eles podem ser encontrados no registro: " HKLM \ SYSTEM \ CurrentControlSet \ Services \ node-xxxx "

A resposta aceita é provavelmente a melhor resposta de produção, mas, para um hack rápido no trabalho de desenvolvimento, encontrei o seguinte:

nodejs scriptname.js & não funcionou, porque o nodejs parecia devorar o &, então a coisa não me deixou continuar usando o terminal sem que o scriptname.js morresse.

Mas eu coloquei nodejs scriptname.jsem um arquivo .sh e nohup sh startscriptname.sh &trabalhei.

Definitivamente não é uma coisa de produção, mas resolve o problema "Eu preciso continuar usando meu terminal e não quero iniciar 5 terminais diferentes".

Se você estiver executando o nodejs no servidor linux, acho que essa é a melhor maneira.

Crie um script de serviço e copie para /etc/init/nodejs.conf

start service: serviço sudo nodejs start

stop service: serviço sudo nodejs stop

Script sevice

description "DManager node.js server - Last Update: 2012-08-06"
author      "Pedro Muniz - pedro.muniz@geeklab.com.br"

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

Atualização de junho de 2017:
Solução para Linux: (Red hat). Comentários anteriores não funcionam para mim. Isso funciona para mim no Amazon Web Service - Red Hat 7. Espero que funcione para alguém por aí.

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 o nssm a melhor solução para o windows, faça o download do nssm , abra o diretório cmd to nssm e digite

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

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

isso instalará um novo serviço do Windows que será listado em services.msc. A partir daí, você poderá iniciar ou interromper o serviço, esse serviço será iniciado automaticamente e você poderá configurar para reiniciar se falhar.

Para completar as várias opções sugeridas, aqui está mais uma: o daemoncomando no GNU / Linux, sobre o qual você pode ler aqui: http://libslack.org/daemon/manpages/daemon.1.html . (desculpas se isso já for mencionado em um dos comentários acima).

Confira fuga! Além de iniciar muitos trabalhadores, você também pode demonizar o processo do nó!

http://github.com/pgte/fugue

alguém notou um erro trivial da posição de "2> & 1"?

2>&1 >> file

deveria estar

>> file 2>&1

Eu uso o tmux para um ambiente de desenvolvimento de várias janelas / painéis em hosts remotos. É realmente simples desanexar e manter o processo em execução em segundo plano. Dê uma olhada no tmux

Para pessoas que usam versões mais recentes do módulo daemon npm - você precisa passar descritores de arquivo em vez de strings:

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

O PM2 é um gerenciador de processos de produção para aplicativos Node.js. com um balanceador de carga interno. Permite manter os aplicativos ativos para sempre, recarregá-los sem tempo de inatividade e facilitar tarefas comuns de administração do sistema. https://github.com/Unitech/pm2

Estou surpreso que ninguém tenha mencionado Guvnor

Eu tentei para sempre, pm2, etc. Mas, quando se trata de controle sólido e métricas de desempenho baseadas na Web, achei o Guvnor de longe o melhor. Além disso, também é totalmente de código aberto.

Edit: No entanto, não tenho certeza se ele funciona no Windows. Eu só usei no linux.

Como não tenho essa opção na lista de respostas fornecidas, gostaria de adicionar uma opção qualificada a partir de 2020: janela de encaixe ou qualquer contêiner equivalente plataforma de . Além de garantir que seu aplicativo esteja funcionando em um ambiente estável, existem benefícios adicionais de segurança, além de portabilidade aprimorada.

Há suporte para docker para Windows, macOS e a maioria das principais distribuições Linux. A instalação do docker em uma plataforma suportada é bastante direta e bem documentada. A configuração de um aplicativo Node.js. é tão simples quanto colocá-lo em um contêiner e executá-lo, garantindo que ele seja reiniciado após o desligamento.

Criar imagem de contêiner

Supondo que seu aplicativo esteja disponível em / home / me / my-app nesse servidor, crie um arquivo de texto Dockerfile na pasta / home / me / my-app com conteúdo semelhante a este:

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

Crie a imagem usando o comando como este:

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

Nota: O último parâmetro é selecionar a pasta que contém esse Dockerfile em vez do próprio Dockerfile. Você pode escolher um diferente usando a opção -f .

Iniciar contêiner

Use este comando para iniciar o contêiner:

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

Este comando pressupõe que seu aplicativo esteja escutando na porta 3000 e você deseja que seja exposto na porta 80 do seu host.

Este é um exemplo muito limitado, com certeza, mas é um bom ponto de partida.

Se você estiver usando pm2, poderá usá-lo com autorestartdefinido para false:

ecossistema $ pm2

Isso irá gerar uma amostra 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

Esta resposta é muito tarde para a festa, mas eu achei que a melhor solução era escrever um shell script que usou os ambos os screen -dmSe nohupcomandos.

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

Também adiciono o >> logfilebit no final para poder salvar facilmente as console.log()instruções do nó .

Por que eu usei um script de shell? Bem, eu também adicionei uma instrução if que verificou se o node myserver.jsprocesso já estava em execução.

Dessa forma, consegui criar uma única opção de linha de comando que permite manter o servidor funcionando e também reiniciá-lo quando eu fizer alterações, o que é muito útil para o desenvolvimento.