Iniciar automáticamente para siempre (nodo) al reiniciar el sistema

Estoy usando el módulo de nodo de forever para mantener mi servidor de nodo en funcionamiento. Sin embargo, Forever termina cuando hay un reinicio del sistema. ¿Hay alguna forma en que pueda iniciar automáticamente el servidor de nodo (con para siempre) cuando el sistema se reinicie?

Yo sugeriría usar crontab. Es fácil de usar.

Cómo

  1. Para comenzar a editar, ejecute lo siguiente al reemplazar el “testuser” con su usuario de tiempo de ejecución deseado para el proceso del nodo. Si elige un usuario diferente a usted, tendrá que ejecutar esto con sudo.

    $ crontab -u testuser -e 
  2. Si nunca ha hecho esto antes, le preguntará con qué editor desea editar. Me gusta vim, pero recomendaré nano por su facilidad de uso.

  3. Una vez en el editor agregue la siguiente línea:

     @reboot /usr/local/bin/forever start /your/path/to/your/app.js 
  4. Guarda el archivo. Debería obtener algunos comentarios de que el cron ha sido instalado.

  5. Para una confirmación adicional de la instalación del cron, ejecute lo siguiente (nuevamente, reemplace “testuser” con su nombre de usuario de destino) para enumerar las crons instaladas actualmente:

     $ crontab -u testuser -l 

Tenga en cuenta que, en mi opinión, siempre debe usar rutas completas al ejecutar binarios en cron. Además, si la ruta de acceso a su secuencia de comandos para siempre no es correcta, ejecútela which forever obtener la ruta completa.

Dado que forever llama node , es posible que también desee proporcionar la ruta completa al node :

 @reboot /usr/local/bin/forever start -c /usr/local/bin/node /your/path/to/your/app.js 

Otras lecturas

  • Crontab Man Page
  • Ubuntu Cron HowTo

Puedes usar el servicio de siempre para hacer esto.

 npm install -g forever-service forever-service install test 

Esto aprovisionará app.js en el directorio actual como un servicio a través de siempre. El servicio se reiniciará automáticamente cada vez que se reinicie el sistema. También cuando se detiene, intentará una parada elegante. Esta secuencia de comandos también proporciona la secuencia de comandos logrotate.

URL de Github: https://github.com/zapty/forever-service

NOTA: Soy el autor del servicio para siempre.

Este caso es válido para Debian.
Agregue lo siguiente a /etc/rc.local

/usr/bin/sudo -u {{user}} /usr/local/bin/forever start {{app path}}

{{usuario}} reemplaza a tu nombre de usuario
{{ruta de la aplicación}} reemplaza a la ruta de la aplicación. Por ejemplo, /var/www/test/app.js

  1. Instale PM2 globalmente utilizando NPM

    npm install pm2 -g

  2. Comience su guión con pm2

    pm2 start app.js

  3. generar un script de inicio activo

    pm2 startup

    NOTA: el inicio de pm2 es para iniciar PM2 cuando el sistema se reinicia. PM2 una vez iniciado, reinicia todos los procesos que había estado administrando antes de que el sistema se apagara.

En caso de que desee deshabilitar el inicio automático, simplemente use pm2 unstartup

Si desea que la secuencia de comandos de inicio se ejecute con otro usuario, solo use la opción -u y el --hp :

Un método crontab alternativo inspirado en esta respuesta y esta publicación de blog.

1. Cree un archivo de script de bash (cambie bob al usuario deseado).

 vi /home/bob/node_server_init.sh 

2. Copie y pegue esto dentro del archivo que acaba de crear.

 #!/bin/sh export NODE_ENV=production export PATH=/usr/local/bin:$PATH forever start /node/server/path/server.js > /dev/null 

¡Asegúrate de editar las rutas anteriores de acuerdo con tu configuración!

3. Asegúrese de que se pueda ejecutar el script bash.

 chmod 700 /home/bob/node_server_init.sh 

4. Reemplace “bob” con el usuario de tiempo de ejecución para el nodo.

 crontab -u bob -e 

5. Copiar y pegar (cambiar bob al usuario deseado).

 @reboot /bin/sh /home/bob/node_server_init.sh 

Guarda el crontab.

Has llegado al final, tu premio es un reinicio (para probar) 🙂

Copiado la respuesta de la pregunta adjunta.

Puede usar PM2 , es un administrador de procesos de producción para aplicaciones Node.js con un equilibrador de carga incorporado.

Instalar PM2

 $ npm install pm2 -g 

Iniciar una aplicación

 $ pm2 start app.js 

Si usas Express entonces puedes iniciar tu aplicación como

 pm2 start ./bin/www --name="app" 

Listado de todos los procesos en ejecución:

 $ pm2 list 

Enumera todo el proceso. Luego puede detener / reiniciar su servicio usando ID o Nombre de la aplicación con el siguiente comando.

 $ pm2 stop all $ pm2 stop 0 $ pm2 restart all 

Para visualizar los registros

 $ pm2 logs ['all'|app_name|app_id] 

Necesitas crear un script de shell en la carpeta /etc/init.d para eso. Es un poco complicado si nunca lo has hecho, pero hay mucha información en la web en los scripts init.d.

Aquí hay una muestra de una secuencia de comandos que creé para ejecutar un sitio de CoffeeScript para siempre:

 #!/bin/bash # # initd-example Node init.d # # chkconfig: 345 # description: Script to start a coffee script application through forever # processname: forever/coffeescript/node # pidfile: /var/run/forever-initd-hectorcorrea.pid # logfile: /var/run/forever-initd-hectorcorrea.log # # Based on a script posted by https://gist.github.com/jinze at https://gist.github.com/3748766 # # Source function library. . /lib/lsb/init-functions pidFile=/var/run/forever-initd-hectorcorrea.pid logFile=/var/run/forever-initd-hectorcorrea.log sourceDir=/home/hectorlinux/website coffeeFile=app.coffee scriptId=$sourceDir/$coffeeFile start() { echo "Starting $scriptId" # This is found in the library referenced at the top of the script start_daemon # Start our CoffeeScript app through forever # Notice that we change the PATH because on reboot # the PATH does not include the path to node. # Launching forever or coffee with a full path # does not work unless we set the PATH. cd $sourceDir PATH=/usr/local/bin:$PATH NODE_ENV=production PORT=80 forever start --pidFile $pidFile -l $logFile -a -d --sourceDir $sourceDir/ -c coffee $coffeeFile RETVAL=$? } restart() { echo -n "Restarting $scriptId" /usr/local/bin/forever restart $scriptId RETVAL=$? } stop() { echo -n "Shutting down $scriptId" /usr/local/bin/forever stop $scriptId RETVAL=$? } status() { echo -n "Status $scriptId" /usr/local/bin/forever list RETVAL=$? } case "$1" in start) start ;; stop) stop ;; status) status ;; restart) restart ;; *) echo "Usage: {start|stop|status|restart}" exit 1 ;; esac exit $RETVAL 

Tenía que asegurarme de que la carpeta y los PATH se establecieran explícitamente o estuvieran disponibles para el usuario root, ya que los scripts init.d se ejecutan como root.

Usa el PM2

¿Cuál es la mejor opción para ejecutar el servidor de producción del servidor?

¿Cuáles son las ventajas de ejecutar su aplicación de esta manera?

  • PM2 reiniciará automáticamente su aplicación si se bloquea.

  • PM2 mantendrá un registro de sus excepciones no manejadas, en este caso, en un archivo en /home/safeuser/.pm2/logs/app-err.log.

  • Con un comando, PM2 puede asegurar que cualquier aplicación que administre se reinicie cuando el servidor se reinicie. Básicamente, su aplicación de nodo se iniciará como un servicio.

ref: https://www.digitalocean.com/community/tutorials/how-to-use-pm2-to-setup-a-node-js-production-environment-on-an-ubuntu-vps

Forever no se hizo para que las aplicaciones de nodo se ejecuten como servicios. El enfoque correcto es crear una entrada / etc / inittab (sistemas linux antiguos) o un arranque (sistemas linux más nuevos).

Aquí hay algo de documentación sobre cómo configurar esto como un inicio: https://github.com/cvee/node-upstart

crontab no funciona para mí en CentOS x86 6.5. @reboot parece no funcionar.

Finalmente conseguí esta solución.

Editar /etc/rc.local

 sudo vi /etc/rc.local 

Agregue esta línea al final del archivo. Cambia USER_NAME y PATH_TO_PROJECT a tu propio. NODE_ENV = producción significa que la aplicación se ejecuta en modo de producción. Puede agregar más líneas si necesita ejecutar más de una aplicación node.js.

 su - USER_NAME -c "NODE_ENV=production /usr/local/bin/forever start /PATH_TO_PROJECT/app.js" 

No establezca NODE_ENV en una línea separada, su aplicación aún se ejecutará en modo de desarrollo, porque para siempre no se obtiene NODE_ENV.

 # WRONG! su - USER_NAME -c "export NODE_ENV=production" 

Guarde y salga de vi (presione ESC: wq volver). Puedes intentar reiniciar tu servidor. Después de que su servidor se reinicie, su aplicación node.js debería ejecutarse automáticamente, incluso si no inicia sesión en ninguna cuenta de forma remota a través de ssh.

Mejor establece el entorno NODE_ENV en tu shell. NODE_ENV se configurará automáticamente cuando su cuenta USER_NAME inicie sesión.

 echo export NODE_ENV=production >> ~/.bash_profile 

Por lo tanto, puede ejecutar comandos como siempre stop / start /PATH_TO_PROJECT/app.js a través de ssh sin tener que configurar NODE_ENV nuevamente.

Escribí un guión que hace exactamente esto:

https://github.com/chovy/node-startup

No lo he intentado desde siempre, pero puedes personalizar el comando que ejecuta, por lo que debería ser sencillo:

 /etc/init.d/node-app start /etc/init.d/node-app restart /etc/init.d/node-app stop 

Probé muchas de las respuestas anteriores. Ninguno de ellos trabajó para mí. Mi aplicación está instalada en /home y como usuario, no como root. Esto probablemente significa que cuando se ejecutan los scripts de inicio mencionados anteriormente, /home aún no está montado, por lo que la aplicación no se inicia.

Luego encontré estas instrucciones por Digital Ocean:

https://www.digitalocean.com/community/tutorials/how-to-use-pm2-to-setup-a-node-js-production-environment-on-an-ubuntu-vps

El uso de PM2 como se explicó fue muy simple y funciona perfectamente: desde entonces, mis servidores virtuales tuvieron dos lockings físicos: el tiempo de inactividad fue de solo un minuto.

El problema con rc.local es que se accede a los comandos como raíz, que es diferente a iniciar sesión como usuario y usar sudo.

Resolví este problema agregando un script .sh con los comandos de inicio que quiero, etc / profile.d. Cualquier archivo .sh en profile.d se cargará automáticamente y cualquier comando se tratará como si usara el sudo normal.

El único inconveniente de esto es que el usuario específico debe iniciar sesión para que empiecen las cosas, lo que en mi situación siempre fue así.

Puede usar el siguiente comando en su shell para iniciar su nodo para siempre
forever app.js // mi script de nodo
debe tener en cuenta que el servidor en el que se está ejecutando la aplicación siempre debe mantenerse.

complete el ejemplo crontab (ubicado en / etc / crontab) ..

 #!/bin/bash # edit this file with .. crontab -u root -e # view this file with .. crontab -u root -l # put your path here if it differs PATH=/root/bin:/root/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin # * * * * * echo "executes once every minute" > /root/deleteme @reboot cd /root/bible-api-dbt-server; npm run forever; @reboot cd /root/database-api-server; npm run forever; @reboot cd /root/mailer-api-server; npm run forever;