Como executar o processo como fundo e nunca morrer?

Eu me conecto ao servidor linux via SSH putty. Eu tentei executá-lo como um processo em segundo plano como este:

$ node server.js & 

No entanto, após 2,5 horas, o terminal se torna inativo e o processo é interrompido. Existe alguma maneira que eu possa manter o processo ativo mesmo com o terminal desconectado?


Editar 1

Na verdade, eu tentei nohup , mas assim que eu fecho o terminal SSH Putty ou desconecto minha internet, o processo do servidor para imediatamente.

Há algo que eu tenha que fazer em Putty?


Editar 2 (em fev, 2012)

Existe um módulo node.js , para sempre . Ele executará o servidor node.js como serviço de daemon.

   

Solução simples (se você não está interessado em voltar ao processo, apenas quer continuar funcionando):

 nohup node server.js & 

Solução poderosa (permite que você se reconecte ao processo se for interativo):

 screen 

Você pode então desappend pressionando Ctrl + a + d e, em seguida, append novamente executando a screen -r

Considere também a nova alternativa para a canvas, o tmux.

nohup node server.js > /dev/null 2>&1 &

  1. nohup significa: não termine este processo mesmo quando o stty é cortado.
  2. > /dev/null significa: stdout vai para / dev / null (que é um dispositivo fictício que não grava nenhuma saída).
  3. 2>&1 significa: stderr também vai para o stdout (que já é redirecionado para /dev/null ). Você pode replace & 1 por um caminho de arquivo para manter um registro de erros, por exemplo: 2>/tmp/myLog
  4. & no final significa: execute este comando como uma tarefa em segundo plano.

Você realmente deveria tentar usar a screen . É um pouco mais complicado do que apenas fazer nohup long_running & , mas entender a canvas uma vez que você nunca mais volta.

Comece sua session de canvas no começo:

 user@host:~$ screen 

Corra o que quiseres:

 wget http://mirror.yandex.ru/centos/4.6/isos/i386/CentOS-4.6-i386-binDVD.iso 

Pressione ctrl + A e depois d. Feito. Sua session continua em segundo plano.

Você pode listar todas as sessões pela screen -ls , e append a algumas pelo comando screen -r 20673.pts-0.srv , onde 0673.pts-0.srv é uma lista de input.

Essa é uma pergunta antiga, mas é bem classificada no Google. Eu quase não posso acreditar nas respostas mais votadas, porque executar um processo node.js dentro de uma session de canvas, com o & ou mesmo com o sinalizador nohup – todos eles – são apenas soluções alternativas.

Especialmente a solução screen / tmux, que deve realmente ser considerada uma solução amadora . O Screen e o Tmux não servem para manter os processos em execução, mas para sessões de terminal de multiplexação. Tudo bem, quando você está executando um script no seu servidor e deseja desconectar. Mas para um servidor node.js, você não quer que seu processo seja anexado a uma session de terminal. Isso é muito frágil. Para manter as coisas funcionando você precisa daemonizar o processo!

Existem muitas ferramentas boas para fazer isso.

PM2 : http://pm2.keymetrics.io/

 # basic usage $ npm install pm2 -g $ pm2 start server.js # you can even define how many processes you want in cluster mode: $ pm2 start server.js -i 4 # you can start various processes, with complex startup settings # using an ecosystem.json file (with env variables, custom args, etc): $ pm2 start ecosystem.json 

Uma grande vantagem que vejo em favor da PM2 é que ela pode gerar o script de boot do sistema para fazer o processo persistir entre as reinicializações:

 $ pm2 startup [platform] 

Onde platform pode ser ubuntu|centos|redhat|gentoo|systemd|darwin|amazon .

forever.js : https://github.com/foreverjs/forever

 # basic usage $ npm install forever -g $ forever start app.js # you can run from a json configuration as well, for # more complex environments or multi-apps $ forever start development.json 

Scripts de boot :

Eu não vou entrar em detalhes sobre como escrever um script de init, porque eu não sou um especialista neste assunto e seria muito longo para esta resposta, mas basicamente eles são scripts de shell simples, acionados por events do sistema operacional. Você pode ler mais sobre isso aqui

Docker :

Basta executar seu servidor em um contêiner Docker com a opção -d e, voilá , você tem um servidor daemonized node.js!

Aqui está uma amostra do Dockerfile (do guia oficial node.js):

 FROM node:argon # Create app directory RUN mkdir -p /usr/src/app WORKDIR /usr/src/app # Install app dependencies COPY package.json /usr/src/app/ RUN npm install # Bundle app source COPY . /usr/src/app EXPOSE 8080 CMD [ "npm", "start" ] 

Em seguida, crie sua imagem e execute seu contêiner:

 $ docker build -t /node-web-app . $ docker run -p 49160:8080 -d /node-web-app 

Espero que isso ajude alguém a aterrar nesta página. Sempre use a ferramenta adequada para o trabalho. Vai poupar muita dor de cabeça e horas!

outra solução negar o trabalho

 $ nohup node server.js & [1] 1711 $ disown -h %1 

nohup permitirá que o programa continue mesmo depois que o terminal morrer. Eu realmente tive situações em que o nohup impede que a session SSH seja finalizada corretamente, então você deve redirect a input também:

 $ nohup node server.js  

Dependendo de como o nohup está configurado, você também pode precisar redirect a saída padrão e o erro padrão para os arquivos.

Eu tenho essa function no meu arquivo shell rc, com base na resposta do @ Yoichi:

 nohup-template () { [[ "$1" = "" ]] && echo "Example usage:\nnohup-template urxvtd" && return 0 nohup "$1" > /dev/null 2>&1 & } 

Você pode usá-lo desta maneira:

 nohup-template "command you would execute here" 
 $ disown node server.js & 

Ele removerá o comando da lista de tarefas ativas e enviará o comando para o plano de fundo

O Nohup e a canvas oferecem ótimas soluções de iluminação para executar o Node.js em segundo plano. O gerenciador de processos Node.js ( PM2 ) é uma ferramenta útil para implantação. Instale-o com o npm globalmente em seu sistema:

npm install pm2 -g

para executar um aplicativo Node.js como um daemon:

pm2 start app.js

Você pode, opcionalmente, vinculá-lo ao Keymetrics.io um monitoramento SAAS feito pela Unitech.

Você já leu sobre o comando nohup ?

Para executar o comando como um serviço do sistema no debian com o sysv init:

Copie o esqueleto do script e adapte-o às suas necessidades, provavelmente tudo o que você precisa fazer é definir algumas variables. Seu script herdará padrões finos de /lib/init/init-d-script , se algo não atender às suas necessidades – substitua-o em seu script. Se algo der errado, você poderá ver detalhes em source /lib/init/init-d-script . Vars obrigatórias são DAEMON e NAME . O script usará o start-stop-daemon para executar seu comando, em START_ARGS você pode definir parâmetros adicionais de start-stop-daemon para usar.

 cp /etc/init.d/skeleton /etc/init.d/myservice chmod +x /etc/init.d/myservice nano /etc/init.d/myservice /etc/init.d/myservice start /etc/init.d/myservice stop 

É assim que eu executo algumas coisas em python para o meu wiki wikimedia:

 ... DESC="mediawiki articles converter" DAEMON='/home/mss/pp/bin/nslave' DAEMON_ARGS='--cachedir /home/mss/cache/' NAME='nslave' PIDFILE='/var/run/nslave.pid' START_ARGS='--background --make-pidfile --remove-pidfile --chuid mss --chdir /home/mss/pp/bin' export PATH="/home/mss/pp/bin:$PATH" do_stop_cmd() { start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 \ $STOP_ARGS \ ${PIDFILE:+--pidfile ${PIDFILE}} --name $NAME RETVAL="$?" [ "$RETVAL" = 2 ] && return 2 rm -f $PIDFILE return $RETVAL } 

Além de configurar vars, tive que replace do_stop_cmd porque o python substitui o executável, portanto, o serviço não parou corretamente.

Além das soluções legais acima eu mencionaria também as ferramentas supervisord e monit que permitem iniciar o processo, monitorar sua presença e iniciá-lo se ele morrer. Com ‘monit’ você também pode executar algumas verificações ativas, como verificar se o processo responde por solicitação http

Para o Ubuntu eu uso isso:

(exec PROG_SH &> / dev / null &)

Saudações

Tente isso para uma solução simples

cmd e sair