Como executar o Node.js como um processo em segundo plano e nunca morrer?

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

$ node server.js &

No entanto, após 2,5 horas, o terminal fica inativo e o processo morre. Existe alguma maneira de manter o processo vivo, mesmo com o terminal desconectado?

Editar 1

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

Existe algo que eu tenho que fazer em Putty?

Edit 2 (em fevereiro de 2012)

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

Solução simples (se você não estiver interessado em voltar ao processo, apenas queira que ele continue em execução):

nohup node server.js &

Há também o jobscomando para ver uma lista indexada desses processos em segundo plano. E você pode eliminar um processo em segundo plano executando kill %1ou kill %2com o número sendo o índice do processo.

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

screen

Você pode desanexar pressionando Ctrl + a + de reconectar executando screen -r

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

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

1. nohupsignifica: Não encerre esse processo mesmo quando o stty estiver cortado.
2. > /dev/nullsignifica: stdout vai para / dev / null (que é um dispositivo fictício que não registra nenhuma saída).
3. 2>&1significa: stderr também vai para o stdout (que já está redirecionado /dev/null). Você pode substituir & 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 screen. É um pouco mais complicado do que apenas fazer nohup long_running &, mas entender a tela quando você nunca mais voltar.

Inicie sua sessão na tela primeiro:

user@host:~$ screen

Execute o que quiser:

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

Pressione ctrl + A e depois d. Feito. Sua sessão continua em segundo plano.

Você pode listar todas as sessões por screen -lse anexar a algumas por screen -r 20673.pts-0.srvcomando, em que 0673.pts-0.srv é uma lista de entradas.

Esta é uma pergunta antiga, mas tem uma classificação alta no Google. Quase não consigo acreditar nas respostas mais votadas, porque executar um processo node.js dentro de uma sessão de tela, com &ou mesmo com o nohupsinalizador - todos eles - são apenas soluções alternativas.

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

Existem muitas boas ferramentas 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 a favor do PM2 é que ele pode gerar o script de inicialização do sistema para fazer com que o processo persista entre as reinicializações:

$ pm2 startup [platform]

Onde platformpode estar 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 inicialização :

Não vou entrar em detalhes sobre como escrever um script init, porque não sou especialista neste assunto e seria muito longo para essa resposta, mas basicamente são simples scripts de shell, acionados por eventos do SO. Você pode ler mais sobre isso aqui

Docker :

Basta executar o servidor em um contêiner do Docker com a -dopção e, voilá , você tem um servidor node.j daemonizado!

Aqui está uma amostra do Dockerfile (no 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 <your username>/node-web-app .
$ docker run -p 49160:8080 -d <your username>/node-web-app

Espero que isso ajude alguém a chegar nesta página. Sempre use a ferramenta adequada para o trabalho. Isso vai lhe poupar muitas dores de cabeça e durante horas!

outra solução negou o trabalho

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

nohuppermitirá que o programa continue mesmo após a morte do terminal. Na verdade, tive situações em que nohupimpede que a sessão SSH seja encerrada corretamente, portanto, você deve redirecionar a entrada também:

$ nohup node server.js </dev/null &

Dependendo de como nohupestá configurado, também pode ser necessário redirecionar a saída padrão e o erro padrão para os arquivos.

Eu tenho essa função no meu arquivo shell rc, com base na resposta de @ 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"

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

npm install pm2 -g

para executar um aplicativo Node.js como um daemon:

pm2 start app.js

Opcionalmente, você pode vinculá-lo ao Keymetrics.io, um SAAS de monitoramento feito pela Unitech.

$ disown node server.js &

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

Você leu sobre o comando nohup ?

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

Copie o script do esqueleto e adapte-o às suas necessidades, provavelmente tudo o que você precisa fazer é definir algumas variáveis. 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 na fonte /lib/init/init-d-script. Vars obrigatórios são DAEMONe NAME. O script será usado start-stop-daemonpara executar seu comando, pois START_ARGSvocê pode definir parâmetros adicionais start-stop-daemonpara 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 no meu wiki da 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, eu tive que substituir do_stop_cmdpor causa de python substitui o executável, para que o serviço não parasse 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 o 'monit', você também pode executar algumas verificações ativas, como verificar se o processo responde à solicitação http

Para o Ubuntu, eu uso este:

(exec PROG_SH &> / dev / null &)

Saudações

Tente isso para uma solução simples

cmd & exit