Comment faire un node.js l'exécution de l'application en permanence?

Sur un serveur Debian, j'ai installé Node.js. Je comprends comment lancer une application de mastic avec cette ligne de commande:

node /srv/www/MyUserAccount/server/server.js

et l'obtenir à l'adresse 50.51.52.53:8080 (IP et port).

Mais dès que je ferme le mastic, alors je ne peux pas atteindre l'adresse 50.51.52.53:8080 plus.

Comment faire un Node.js l'exécution de l'application en permanence?

Comme vous pouvez le deviner, je suis un débutant avec Linux et Node.js.

Notez que h2 c'est une bonne alternative. Jamais, si vous ne voulez pas l'utiliser pour Toujours pour quelque raison que ce soit.
pouvez-vous vérifier cela, stackoverflow.com/questions/12701259/... je sais que c'est une très vieille question et de la réponse de la marque comme de Véritables dos long mais il suffit de penser de cela, il fonctionne vraiment bien.
désolé pour la réponse tardive. C'est quelque chose que j'ai l'intention d'essayer. Merci pour le lien.
merci @KevinB github.com/Unitech/pm2 est vraiment bonne alternative.
Double Possible de Comment puis-je exécuter un node.js application comme un service de base?

InformationsquelleAutor Sam | 2012-10-03

node.js server

190

Bien que les autres réponses résoudre les OP de problème, ils sont tous les excès et de ne pas expliquer pourquoi il ou elle est confronté à ce problème.

La clé est de cette ligne, "j'ai près de mastic, puis je ne peux pas atteindre l'adresse"

Lorsque vous êtes connecté à votre hôte distant sur le Mastic que vous avez commencé un SSH linux et toutes les commandes tapées à partir de cette session SSH sera exécutée comme les enfants du dit processus.

Votre problème, c'est que lorsque vous fermez le Mastic que vous quittez la session SSH qui tue que des processus et des actifs de processus enfant. Lorsque vous fermez le mastic de vous, par inadvertance tuer votre serveur parce que vous avez exécuté dans le premier plan. Pour éviter ce comportement, de l'exécution du serveur dans le fond en ajoutant & à votre commande:
```
node /srv/www/MyUserAccount/server/server.js &
```
Ici, le problème est un manque de connaissances linux et pas une question à propos de nœud. Pour plus d'infos consultez: http://linuxconfig.org/understanding-foreground-and-background-linux-processes

Mise à JOUR:

Comme d'autres l'ont mentionné, le nœud serveur peut encore mourir lors de la sortie du terminal. Une commune de la chasse aux sorcières que j'ai rencontré est que, même si le nœud processus est en cours d'exécution dans le bg, c'est la sortie standard stdout et stderr est encore souligné dans le terminal. Cela signifie que si le nœud serveur écrit à la console.journal ou de la console.erreur, il recevra un bris de tuyau d'erreur et de crash. Ceci peut être évité par la tuyauterie de sortie de votre processus:
```
node /srv/www/MyUserAccount/server/server.js > stdout.txt 2> stderr.txt &
```
Si le problème persiste, alors vous devriez regarder dans les choses comme tmux ou nohup, qui sont encore plus robuste que le nœud de solutions spécifiques, car ils peuvent être utilisés pour exécuter tous les types de processus (bases de données, l'exploitation forestière services, autres langues).

Une erreur commune que pourrait causer le serveur pour quitter c'est qu'après l'exécution de la nohup node your_path/server.js & il vous suffit de fermer le terminal Putty par un simple clic. Vous devez utiliser exit de commande au lieu de cela, votre nœud serveur sera en place et en cours d'exécution.
- Si vous fermez la Session Putty tout en faisant & le service toujours se ferme bien. (Juste testé sur Debian Jesse)
- J'ai connu cela avec certaines des commandes complexes qui confondent les coquilles de commande analyseur de qui il néglige la commande bg. Pour ces situations, utilisez quelque chose comme tmux, qui est toujours supérieurs à un nœud spécifique de la solution parce que c'est au niveau de l'OS (utile si le démarrage des processus à l'extérieur du nœud comme un db ou service distinct): askubuntu.com/questions/8653/...
- Comme @NiCkNewman dit, cette réponse est incomplète! Voir Rick Roy réponse pour la solution correcte.
- Le "&" rend le processus d'exécution en arrière-plan, mais vous avez réellement besoin d'ajouter "nohup" au début de cette commande pour le détacher de la fenêtre de la console de sorte que l'application ne serait pas arrêter lorsque la fenêtre de mise en veille après quelques heures, la modification de l'été mentionné précédemment commande: nohup node /srv/www/MyUserAccount/server/server.js &
- Grâce à la dernière mise à jour (avec > stdout.txt 2> stderr.txt) - ça marche!!!
- Vous pouvez également utiliser Upstart ou Systemd je crois
- AIX powersystem, nohup node myApp.js & exécuté l'application dans le bg, mais il meurt quand le terme a été fermé. Pas sûr, mais pourquoi.
- Salut, j'ai utilisé cette méthode pour démarrer mon nœud du module. Maintenant, j'ai besoin de le redémarrer. Comment puis-je tuer le processus précédent?
- vous devez utiliser exit commande pour quitter le terminal.
- Alors, comment arrêter le serveur en cours d'exécution dans le cadre normal d'une manière raisonnable et après l'utilisation de " node /srv/www/MyUserAccount/server/server.js &"?
- Voir ici pour ce faire: stackoverflow.com/a/26987229/4493512
InformationsquelleAutor DogNibbler
307

Vous pouvez en installer pour toujours à l'aide de npm comme ceci:
```
sudo npm install -g forever
```
Et de démarrer votre application avec:
```
forever server.js
```
Ou en tant que service:
```
forever start server.js
```
Jamais redémarrage de votre application quand il se bloque ou s'arrête pour une raison quelconque. Pour limiter redémarre à 5, vous pouvez utiliser:
```
forever -m5 server.js
```
À la liste de tous les processus en cours d'exécution:
```
forever list
```
Note le nombre entier dans les crochets et l'utiliser comme suit pour arrêter un processus:
```
forever stop 0
```
Redémarrage d'un processus en cours d'exécution va:
```
forever restart 0
```
Si vous travaillez sur votre dossier de candidature, vous pouvez utiliser le -w paramètre pour redémarrer automatiquement à chaque fois que votre server.js modifications du fichier:
```
forever -w server.js
```
- Mais lorsque je ferme le mastic, il cesse de fonctionner
- si sa fermeture lors de votre session ssh / fenêtre se ferme, alors vous avez probablement oublié d'inclure "démarrer", dans le forever start <file>
- mmmmmmmmuah.... :* le début est manquant
- Quelle est la différence entre l'utilisation de forever server.js et forever start server.js? Je sais qu'il dit qu'il est "comme un service" mais qu'est-ce que cela signifie?
- Quand je tape dans forever server.js, il démarre le serveur. Si je presse Ctrl + C, il arrête le service. Si je tape dans forever start server.js puis il commence le service et même si je presse Ctrl + C elle reste ouverte. Vous pouvez ensuite faire les autres référencé commandes ci-dessus pour arrêter / regarder la liste. C'est ce que j'ai vécu au moins.
- Si vous utilisez express, vous avez à exécuter à l'aide de forever start ./bin/www à la place.
- Est-ce à lancer le script après un redémarrage du serveur?
- Peut-être que cela va aider quelqu'un... j'ai également eu à s'assurer que j'avais "normal" shell à la place des emprisonnés shell, ou que le processus serait tué quand j'ai fermé ma session SSH.
- Le forever module (v0.15.3) est vulnérable à l'Expression Régulière attaques par Déni de Service et ne doit pas être utilisé: github.com/foreverjs/forever/issues/960
- oh oh, c'est pas bon
- J'ai essayé forever index.js et l'application a cessé quand j'ai fait Ctrl+c. J'ai ensuite essayé forever index.js & et cela a fonctionné, même après la sortie de la ssh.
- Aucune de ces commandes gardé le serveur en cours d'exécution après que j'ai tué la session SSH.
InformationsquelleAutor N20
70

Vous pouvez utiliser PM2, c'est un processus de production, le gestionnaire de Node.js applications avec un équilibreur de charge.

Installer PM2
```
$ npm install pm2 -g
```
Démarrer une application
```
$ pm2 start app.js
```
Si vous utilisez express, vous pouvez démarrer votre application, tels que la
```
pm2 start ./bin/www --name="app"
```
Liste de tous les processus en cours d'exécution:
```
$ pm2 list
```
Il fournira la liste de tous les processus. Vous pouvez ensuite arrêter /redémarrer votre service à l'aide de l'ID ou le Nom de l'application avec la commande suivante.
```
$ pm2 stop all                  
$ pm2 stop 0                    
$ pm2 restart all               
```
Pour afficher les journaux de
```
$ pm2 logs ['all'|app_name|app_id]
```
- J'ai choisi cette solution comme la meilleure pour moi . voter
- Merci @zhilevan. Nous sommes également à l'aide de ce et de travail avec beaucoup de douceur.
- Que dieu vous bénisse! ça marche!!!! Pour toujours et à Nohup ne fonctionne pas sur amazon web service bitnami nodejs serveur (docs.bitnami.com/aws/infrastructure/nodejs ). PM2 fonctionne très bien!
- Merci @polras
- c'est vraiment super!
InformationsquelleAutor Vikash Rajpurohit
40

Je vous recommande la recherche de quelque chose comme Pour toujours pour redémarrer le Nœud dans le cas d'un accident, et la poignée daemonizing pour vous.
- Il me semble que Jamais c'est exactement ce que je recherche. Je vous remercie.
- Je tiens à souligner que, sans nohup, nœud de sortie lorsque vous quittez la session ssh si vous exécutez cette façon (sauf si vous utilisez quelque chose comme écran de tmux).
- Intéressant, mais ce n'est pas la façon dont il a travaillé pour moi sur mes machines. Quand j'ai ssh et de commencer quelque chose à l'aide de cette commande, il fonctionne toujours en arrière-plan, même après la fermeture de la session SSH.
- Veuillez voir la 2ème réponse sur stackoverflow.com/questions/4018154/... . Il semble tout à fait que certaines personnes sont d'accord avec le 1er commentaire de cette question, ce qui explique nohup. Ce serait formidable si nous pouvons résoudre cette confusion. Mais je ne sais pas par où commencer.
- Les réponses changer l'ordre au hasard. Pouvez-vous accéder directement à la réponse? Je ne vois pas de confusion. Vous devriez poster une nouvelle question, si vous avez des questions.
- Pour la plupart des unixen (y compris la plupart des distributions de Linux), les choses en cours d'exécution en arrière-plan va encore tuer le processus, si vous fermez la fenêtre du terminal. Pour éviter cette course avec nohup. Exemple: nohup node app.js &
- J'utilise Toujours avec une production Linux env. J'utilise généralement la commande à jamais démarrer --minUptime 10000 -o /logs/myapp.journal nodeApp.js
InformationsquelleAutor Brad
32

Si vous voulez juste pour exécuter votre nœud de l'application dans le terminal toujours, il suffit d'utiliser l'écran.

Installer sur ubuntu/debian:
```
sudo apt-get install screen
```
Utilisation:
```
$ screen
$ node /path/to/app.js
```
ctrl + a et puis ctrl + d de rejeter

À obtenir est de retour:

Un écran: screen -r

Si il n'y a plus d'un, vous pouvez lister tous les écrans, avec: screen -ls

Et puis: screen -r pid_number
- C'est une bonne option, car il me permet également de basculer le processus d'avant-plan à tout moment
InformationsquelleAutor film42
22

Vous pouvez simplement utiliser ce
```
nohup node /srv/www/MyUserAccount/server/server.js &
```
Cela permet de garder l'application en cours d'exécution et pour l'arrêter, vous devrez le tuer.

Pour que vous pourriez installer htop et ensuite, la recherche de nœud et puis la tuer
- Il est important de noter que, dans ce cas, l'utilisateur a besoin pour sortir de la session PuTTY correctement (c'est à dire via le exit de commande). Si l'utilisateur ferme la fenêtre, il peut utiliser un signal autre que SIGHUP à la fin du processus, et donc nœud d'arrêt, de toute façon.
- +1 pour être un simple objet Linux solution au problème. C'est mieux que DogNibbler réponse.
- après la lecture de votre commentaire, j'ai essayé avec brusquement fermer le mastic, mais le serveur fonctionnait encore, peut-être qu'il avait à faire avec la façon dont l'env a été configuré. Mais j'ai pensé que pour ce que l'OP a demandé ce serait plus simple pour y parvenir
- de loin la solution la plus propre
- J'aime cette approche simple, c'est celui que j'utilise, comme pour le tuer, le plus simple est juste un killall node , qui va tuer tous les nœud de processus, dans mon cas, un seul.
- Ce serait tuer nœud tous les processus de ce que si vous disposez de plusieurs scripts en cours d'exécution et que vous souhaitez uniquement mettre fin à un particulier, je vous suggère de trouver le processus, puis de l'extinction de particulier, juste au cas où vous avez eu plusieurs nœud de processus en cours d'exécution dans un serveur de production et ne veulent pas se sentir comme dans un cauchemar 😀
- Merci @thejonwithnoh, très important, peu d'info, il y
- Ne peut pas upvote ce premier commentaire assez...
- La sortie de commande est nécessaire dans mon cas.
InformationsquelleAutor Rick Roy
10

Pour toujours est un très bon module NodeJs pour faire exactement cela.

Installer forever en tapant dans la ligne de commande
```
$ npm install forever -g
```
Puis utilisez la commande suivante pour exécuter un node.js script
```
$ forever start /path/to/script.js
```
Vous êtes bon pour aller. En outre, vous pouvez exécuter
```
$ forever list
```
pour voir tous les scripts. Vous pouvez mettre fin à tout script spécifique en tapant
```
$ forever stop [pid]
```
où [pid] est l'ID de processus du script, vous allez obtenir de la list de commande. Pour arrêter tous les scripts, vous pouvez taper
```
$ forever stopall
```
InformationsquelleAutor
9

nohup de travail j'ai vérifié dans AWS Ubunto vm de suivre la bonne syntax
```
ubuntu@ip-172-00-00-00:~/ms$ nohup node server.js &
```
puis appuyez sur entrée, vous verrez cette ligne
```
ubuntu@ip-172-00-00-00:~/ms$ nohup: ignoring input and appending output to ‘nohup.out’
```
puis tapez ce
```
rm nohup.out
```
- J'aime la façon dont vous avez effacé le nom d'hôte dans la petite invite bash, mais l'a laissé dans le grand titre de la fenêtre
InformationsquelleAutor Adiii
8

Voici un upstart solution que j'ai utilisé pour mes projets personnels:

Placer dans /etc/init/node_app_daemon.conf:
```
description "Node.js Daemon"
author      "Adam Eberlin"

stop on shutdown

respawn
respawn limit 3 15

script
  export APP_HOME="/srv/www/MyUserAccount/server"
  cd $APP_HOME
  exec sudo -u user /usr/bin/node server.js
end script
```
Cela permettra également de gérer les réapparitions de votre application dans le cas où il se bloque. Il va abandonner les tentatives de respawn votre demande si il plante 3 fois ou plus en moins de 15 secondes.
- Je vous remercie pour votre réponse.
InformationsquelleAutor Adam Eberlin
8

Cours de développement, je vous recommande d'utiliser nodemon. Il va redémarrer votre serveur à chaque fois qu'un fichier est modifié. Comme d'autres l'ont souligné, Pour toujours est une option, mais dans la production, tout dépend de la plate-forme que vous utilisez.
Vous souhaitez utiliser le système d'exploitation est recommandé de maintenir les services (par exemple,http://www.freedesktop.org/wiki/Software/systemd/).
- Merci beaucoup, j'ai été à la recherche de quelque chose comme cela.
- Cela a fonctionné pour moi sur un MEAN.JS application -- nodemon exécute la commande grunt, sauf si vous spécifiez un serveur de fichier JS, donc je suis en utilisant cette option pour exécuter mongo et nœud à jamais/simultanément
InformationsquelleAutor Olivier Lalonde
8

Installation
```
$ [sudo] npm install forever -g
```
Vous pouvez utiliser une éternité pour exécuter des scripts en permanence
```
forever start server.js

forever list
```
pour arrêter le service
```
forever stop server.js
```
InformationsquelleAutor Sudhir singh
6

J'ai trouvé une éternité pour faire le travail parfaitement bien.

En supposant que vous avez déjà mnp installé, si non, il suffit de faire
```
sudo apt-get install npm
```
Puis installez jamais
```
npm install forever --global
```
Maintenant, vous pouvez l'exécuter comme ce
```
forever start app.js
```
https://codingweb.io/run-nodejs-application-background/

InformationsquelleAutor erax
4

De la première installation de pm2 globalement
```
npm install -g pm2
```
puis commencer à
```
pm2 start bin/www 
```
InformationsquelleAutor Vinayak Shedgeri
4

Une autre façon est de créer une unité de système pour votre application. créer un "XXX.service" fichier "/etc/systemd/system" dossier, similaire à ceci:
```
[Unit]
Description=swagger
After=network.target

[Service]
ExecStart=/usr/bin/http-server /home/swagger/swagger-editor &
WorkingDirectory=/home/swagger
Restart=always
RestartSec=30

[Install]
WantedBy=multi-user.target
```
Un avantage est que l'application va s'exécuter en tant que service, il redémarre automatiquement si il s'est planté.

Vous pouvez également utiliser sytemctl à gérer: les

systemctl start XXX pour démarrer le service, systemctl stop XXX pour l'arrêter et systemctl enable XXX le démarrage automatique de l'application lors de l'initialisation du système.

InformationsquelleAutor Alex
2

J'espère que cela va vous aider.

À la ligne de commande, installez jamais:
```
npm install forever -g
```
Créer un fichier de l'exemple:
```
sudo nano server.js 
```
Vous pouvez modifier le fichier et d'obtenir des résultats directement dans votre navigateur.

Vous pouvez utiliser filezilla ou tout éditeur pour modifier le fichier.
Exécutez cette commande pour exécuter le fichier:
```
forever start --minUptime 1 --spinSleepTime 1000 -w server.js
```
InformationsquelleAutor Ghanshyam Nakiya
1

Je vous recommandons d'utiliser les PM2, qui est un gestionnaire de processus pour Node.js des applications. PM2 fournit un moyen facile de gérer et de daemonize applications (exécuter en tant que service).

consulter ce lien - https://www.digitalocean.com/community/tutorials/how-to-set-up-a-node-js-application-for-production-on-centos-7
- Il y a déjà une réponse recommander PM2. stackoverflow.com/a/40254977/390718
InformationsquelleAutor vishwa
0

Pas besoin d'installer n'importe quel autre paquet.

Exécuter cette commande
```
node server.js > stdout.txt 2> stderr.txt &
```
server.js est votre serveur de fichier ou il peut être api.js

Après ce coup "sortie" pour fermer la borne
```
exit
```
InformationsquelleAutor Gajender Singh

Vous devez vous connecter pour publier un commentaire.