Como executo um aplicativo Node.js. como seu próprio processo?

Qual é a melhor maneira de implantar o Node.js?

Eu tenho um VPS Dreamhost (é o que eles chamam de VM ) e pude instalar o Node.js e configurar um proxy. Isso funciona muito bem, desde que eu mantenha aberta a conexão SSH que iniciei o nó.

Resposta de 2016 : quase toda distribuição Linux vem com systemd, o que significa que eternamente, monit, PM2 etc. não são mais necessários - o 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=nobody
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 a /etc/systemd/systempasta

Informe o systemd sobre o novo serviço com systemctl daemon-reload.

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).

Use para sempre . Ele executa os programas Node.js em processos separados e os reinicia, se houver algum.

Uso:

• forever start example.js para iniciar um processo.
• forever list para ver a lista de todos os processos iniciados por sempre
• forever stop example.jspara interromper o processo ou forever stop 0para o processo com o índice 0 (como mostrado por forever list).

Eu escrevi sobre o meu método de implantação aqui: Implantando aplicativos node.js.

Em resumo:

• Use o gancho pós-recebimento git
• Jake para a ferramenta de construção
• Iniciante como um wrapper de serviço para o nó
• Monit para monitorar e reiniciar aplicativos que eles vão para baixo
• nginx para rotear solicitações para aplicativos diferentes no mesmo servidor

pm2 faz os truques.

Os recursos são: Monitoramento, recarga de código ativo, balanceador de carga interno, script de inicialização automática e processos de ressurreição / despejo.

Você pode usar monit, forever, upstartou systemdpara iniciar o seu servidor.

Você pode usar o verniz ou o HAProxy em vez do Nginx (sabe-se que o Nginx não funciona com websockets).

Como uma solução rápida e suja que você pode usar nohup node your_app.js &para impedir que seu aplicativo terminar com o seu servidor, mas forever, monite outras soluções propostas são melhores.

Criei um script Upstart usado atualmente para meus aplicativos:

description "YOUR APP NAME"
author "Capy - http://ecapy.com"

env LOG_FILE=/var/log/node/miapp.log
env APP_DIR=/var/node/miapp
env APP=app.js
env PID_NAME=miapp.pid
env USER=www-data
env GROUP=www-data
env POST_START_MESSAGE_TO_LOG="miapp HAS BEEN STARTED."
env NODE_BIN=/usr/local/bin/node
env PID_PATH=/var/opt/node/run
env SERVER_ENV="production"

######################################################

start on runlevel [2345]
stop on runlevel [016]

respawn
respawn limit 99 5

pre-start script
    mkdir -p $PID_PATH
    mkdir -p /var/log/node
end script

script
    export NODE_ENV=$SERVER_ENV
    exec start-stop-daemon --start --chuid $USER:$GROUP --make-pidfile --pidfile $PID_PATH/$PID_NAME --chdir $APP_DIR --exec $NODE_BIN -- $APP >> $LOG_FILE 2>&1
end script

post-start script
    echo $POST_START_MESSAGE_TO_LOG >> $LOG_FILE
end script

Personalize tudo antes de #########, crie um arquivo em /etc/init/your-service.conf e cole-o lá.

Então você pode:

start your-service
stop your-service
restart your-service
status your-service

Eu escrevi um guia bastante abrangente para implantar o Node.js, com arquivos de exemplo:

Tutorial: Como implantar aplicativos Node.js, com exemplos

Abrange coisas como http-proxy, SSL e Socket.IO .

Aqui está um artigo mais longo sobre como resolver esse problema com o systemd: http://savanne.be/articles/deploying-node-js-with-systemd/

Algumas coisas a ter em mente:

• Quem iniciará seu monitoramento de processos? O Forever é uma ótima ferramenta, mas precisa de uma ferramenta de monitoramento para se manter em funcionamento. Isso é um pouco bobo, por que não usar seu sistema init?
• Você pode monitorar adequadamente seus processos?
• Você está executando vários back-ends? Em caso afirmativo, você possui disposições em vigor para impedir que algum deles derrube os outros em termos de uso de recursos?
• O serviço será necessário o tempo todo? Caso contrário, considere a ativação do soquete (consulte o artigo).

Todas essas coisas são feitas facilmente com o systemd.

Se você tiver acesso root, é melhor configurar um daemon para que ele seja salvo e salvo em segundo plano. Você pode ler como fazer exatamente isso no Debian e Ubuntu na postagem do blog Run Node.js como um serviço no Ubuntu .

Para sempre fará o truque.

@ Kevin: Você deve ser capaz de matar processos bem. Eu verificaria a documentação um pouco. Se você puder reproduzir o erro, seria ótimo publicá-lo como um problema no GitHub.

Tente o seguinte: http://www.technology-ebay.de/the-teams/mobile-de/blog/deploying-node-applications-with-capistrano-github-nginx-and-upstart.html

Um guia excelente e detalhado para implantar aplicativos Node.js. com Capistrano, Upstart e Nginx

Como Box9 disse, Forever é uma boa escolha para código de produção. Mas também é possível manter um processo em andamento, mesmo que a conexão SSH seja fechada a partir do cliente.

Embora não seja necessariamente uma boa ideia para a produção, isso é muito útil quando no meio de longas sessões de depuração, ou após a saída do console de processos demorados, ou sempre que é útil desconectar sua conexão SSH, mas mantenha o terminal ativo no servidor para se reconectar mais tarde (como iniciar o aplicativo Node.js. em casa e reconectar-se ao console mais tarde no trabalho para verificar como estão as coisas).

Supondo que seu servidor seja uma caixa * nix, você pode usar o comando screen do shell para manter o processo em execução, mesmo se o SSH do cliente estiver fechado. Você pode fazer o download / instalar a tela da Web, se ainda não estiver instalada (procure um pacote para sua distribuição, se Linux, ou use MacPorts, se OS X).

Funciona da seguinte forma:

1. Quando você abrir a conexão SSH pela primeira vez, digite 'screen' - isso iniciará sua sessão de tela.
2. Comece a trabalhar normalmente (ou seja, inicie o aplicativo Node.js.)
3. Quando terminar, feche o seu terminal. O (s) processo (s) do servidor continuarão em execução.
4. Para reconectar-se ao seu console, ssh de volta ao servidor, efetue login e digite 'screen -r' para reconectar. Seu antigo contexto de console voltará pronto para você continuar a usá-lo.
5. Para sair da tela, enquanto estiver conectado ao servidor, digite 'exit' no prompt do console - isso o levará ao shell comum.

Você pode ter várias sessões de tela em execução simultaneamente, se necessário, e pode se conectar a qualquer uma delas a partir de qualquer cliente. Leia a documentação online para todas as opções.

Forever é uma boa opção para manter os aplicativos em execução (e é o npm instalável como um módulo, o que é bom).

Mas, para uma "implantação" mais séria - como gerenciamento remoto de implantação, reinicialização, execução de comandos etc. - eu usaria o capistrano com a extensão do nó.

https://github.com/loopj/capistrano-node-deploy

https://paastor.com é um serviço relativamente novo que faz a implantação para você, em um VPS ou outro servidor. Há uma CLI para enviar código. O Paastor possui um nível gratuito, pelo menos no momento da publicação.

No seu caso, você pode usar o daemon inicial . Para uma solução completa de implantação, posso sugerir capistrano . Dois guias úteis são: Como configurar o Node.js. env e Como implantar via capistrano + upstart .

Tente node-deploy-server . É um conjunto de ferramentas complexo para implantar um aplicativo em seus servidores privados. Está escrito em Node.js e usa o npm para instalação.