Como posso executar um aplicativo node.js como um serviço de segundo plano?

Como esse post recebeu muita atenção ao longo dos anos, listei as principais soluções por plataforma no final deste post.


Postagem 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 em execução. Eu pesquisei isso e criei este tutorial , mas ele não funciona como planejado. Então, em vez de usar esse script daemon, pensei em usar o redirecionamento de saída (a parte do 2>&1 >> file ), mas isso também não sai – recebo uma linha em branco no terminal, como se estivesse esperando por resultados / erros .

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

Então, como posso deixá-lo funcionando quando eu desligar meu computador local?


Principais soluções :

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

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

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

    Faça um arquivo myapp.service (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 

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

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

    Comece com systemctl start myapp .

    Permitir que ele seja executado na boot com o systemctl enable myapp .

    Veja os logs com journalctl -u myapp

    Isso é tirado de Como implementamos 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 arquivo .service ).

    Você pode usar 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 – Como mencionado em uma das respostas abaixo, o PM2 tem algumas funcionalidades realmente legais que faltam para sempre. Considere usá-lo.

    Resposta Original

    Use nohup :

     nohup node server.js & 

    EDIT eu queria acrescentar que a resposta aceita é realmente o caminho a percorrer. Eu estou usando para sempre em instâncias que precisam ficar acordadas. Eu gosto de fazer o npm install -g forever então ele está no caminho do nó e então, forever start server.js

    Isso pode não ser o caminho aceito, mas eu faço isso com a canvas, especialmente enquanto estou em desenvolvimento, porque posso trazê-lo de volta e enganá-lo, se necessário.

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

    A canvas será desconectada e sobreviverá ao seu logoff. Então você pode voltar a fazer a canvas -r. Acesse o manual da canvas para mais detalhes. Você pode nomear as canvass 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; node-linux gera arquivos init systemv. Como o systemd continua a crescer em popularidade, é realisticamente uma opção melhor no Linux. PR é bem-vindo se alguém quiser adicionar suporte ao systemd para node-linux 🙂

    Tópico original:

    Esse é um thread bem antigo agora, mas o node-windows fornece outra maneira de criar serviços em segundo plano no Windows. É vagamente baseado no conceito nssm de usar um wrapper exe em torno do seu script de nó. Contudo; Ele usa o winsw.exe e fornece um wrapper de nó configurável para um controle mais granular sobre como o processo é iniciado / interrompido em falhas. Esses processos estão disponíveis como qualquer outro serviço:

    insira a descrição da imagem aqui

    O módulo também coze em algum log de events:

    insira a descrição da imagem aqui

    A demonização do seu script é realizada por meio de 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 reboot de limites (assim, scripts ruins não geram o seu servidor) e intervalos de tempo crescentes entre reinicializações.

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

    Finalmente, não há dependencies de make . Em outras palavras, um simples npm install -g node-windows funcionará. Você não precisa do Visual Studio, .NET ou magic-node-gyp para instalar isso. Além disso, é licenciado pelo 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 maior integração com a funcionalidade que o Sistema Operacional já fornece. Espero que futuros espectadores com essa mesma pergunta achem útil.

    UPDATE : atualizei para include o mais recente a partir de pm2:

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

    https://github.com/unitech/pm2

    http://pm2.io

    • ele tem um recurso de monitoramento realmente útil -> pretty ‘gui’ para monitoramento de linha de comando de múltiplos processos com pm2 monit ou lista de processos com pm2 list
    • Gerenciamento organizado de logs -> pm2 logs
    • outras coisas:
      • Configuração de comportamento
      • Suporte ao mapa de origem
      • PaaS Compatible
      • Assista e recarregue
      • Sistema de Módulos
      • Memória máxima recarregável
      • Modo de Cluster
      • Recarga quente
      • Fluxo de trabalho de desenvolvimento
      • Scripts de boot
      • Conclusão automática
      • Fluxo de Trabalho de Implantação
      • Monitorização de Keymetrics
      • API

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

    Construa um plist como este e coloque-o em / Library / LaunchDaemons com o nome top-level-domain.your-domain.application.plist (você precisa ser root ao colocá-lo):

     < ?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">   Label top-level-domain.your-domain.application WorkingDirectory /your/preferred/workingdirectory ProgramArguments  /usr/local/bin/node your-script-file  RunAtLoad  KeepAlive    

    Quando terminar, emita isso (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á correndo após o reinício.

    Para outras opções, consulte a man page aqui: https://developer.apple.com/library/mac/documentation/Darwin/Reference/Manpages/man5/launchd.plist.5.html

    Eu 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 eu também estou usando o mon (1) do TJ Holowaychuk para iniciar e gerenciar aplicativos de nós simples.

    Eu uso o Supervisor para desenvolvimento. Apenas funciona. Sempre que você fizer alterações em um arquivo .js, o Supervisor reinicia automaticamente seu aplicativo com as alterações carregadas.

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

    Instalar:

    sudo npm install supervisor -g

    Você pode facilmente ver outras extensões com -e. Outro comando que eu uso frequentemente é -i para ignorar certas pastas.

    Você pode usar nohup e supervisor para fazer com que seu aplicativo de nó seja executado em segundo plano mesmo depois de efetuar logout.

    sudo nohup supervisor myapp.js &

    Se você simplesmente deseja executar o script ininterruptamente até que ele seja concluído, você pode usar nohop como já mencionado nas respostas aqui. No entanto, nenhuma das respostas fornece um comando completo que também registra stdin e stdout .

     nohup node index.js >> app.log 2>&1 & 
    • O >> significa acrescentar ao app.log .
    • 2>&1 garante que os erros também sejam enviados para stdout e adicionados ao app.log .
    • O final & garante que 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 iniciar o backup quando o servidor for reiniciado), use systemd / systemctl .

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

    Instalação:

    1. Instale o WGET http://gnuwin32.sourceforge.net/packages/wget.htm via executável do instalador
    2. Instale o GIT http://code.google.com/p/msysgit/downloads/list via 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 (somente setx 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. Um goodie de lote bacana é 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 estão agora acessíveis através de Iniciar-> Executar-> services.msc ou via Iniciar-> Executar-> MSCONFIG-> Serviços (e selecione ‘Ocultar Todos os Serviços da Microsoft’).
    • O script prefixará todos os nós feitos através 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 rápido trabalho de desenvolvimento, achei isto:

    nodejs scriptname.js & não funcionou, porque o nodejs parecia engolir o &, e assim a coisa não me deixou continuar usando o terminal sem o scriptname.js morrer.

    Mas eu coloquei nodejs scriptname.js em um arquivo .sh, e nohup sh startscriptname.sh & funcionou.

    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ê está executando o nodejs no servidor linux, acho que esta é a melhor maneira.

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

    iniciar serviço: serviço sudo nodejs start

    serviço de parada: serviço sudo nodejs stop

    Roteiro 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/" #set your project home folder here env COMMAND="/usr/bin/node " #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="" #set your project home folder here export 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 

    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" ./ 

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

    use nssm a melhor solução para windows, apenas baixe nssm , abra cmd para nssm directory e digite

     nssm install    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 a reboot se falhar.

    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 isso funcione para alguém lá fora.

     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 

    Confira a fuga! Além de lançar muitos trabalhadores, você pode demonizar seu processo de nó também!

    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 múltiplas janelas / painéis em hosts remotos. É muito simples separar e manter o processo em execução em segundo plano. Dê uma olhada no tmux

    Essa resposta é bem tarde para a festa, mas descobri que a melhor solução era escrever um script de shell que usasse os comandos screen -dmS e nohup .

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

    Eu também adiciono o bit >> logfile no final para que eu possa salvar facilmente as instruções do nó console.log() .

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

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

    O PM2 é um gerenciador de processos de produção para aplicativos Node.js com um balanceador de carga integrado. Ele permite que você mantenha os aplicativos ativos para sempre, para recarregá-los sem tempo de inatividade e para facilitar as 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, eu acho que Guvnor é de longe o melhor. Além disso, também é totalmente opensource.

    insira a descrição da imagem aqui

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

    É muito simples.

    1. Adicione package.json em seu projeto
    2. Adicione o nome do arquivo de script ou o caminho no seu Package.JSON Start
    3. Então simples vá para o seu console abrir o diretório do seu projeto por cd path / to / directory /
    4. Escreva nohup npm start

    A seguir está uma amostra Package.JSON que qualquer um pode usar. {“name”: “Project”,

      "version": "1.0.0", "main": "httpsserver.js", "scripts": { "start": "node httpsserver.js" }, "keywords": [], "author": "", "license": "ISC", "dependencies": {}, "devDependencies": {}, "description": "" }