node.js - node - Se inicia automáticamente por siempre(nodo) al reiniciar el sistema

node js tutorial

Question

Estoy usando el módulo para siempre del nodo para mantener mi servidor de nodo en ejecución. Sin embargo, para siempre termina cuando hay un reinicio del sistema. ¿Hay alguna manera de que pueda iniciar automáticamente el servidor de nodos (para siempre) cuando el sistema se reinicia?

Answer 1

1. Instalar PM2 globalmente usando NPM

   npm install pm2 -g

2. Comience su script con pm2

   pm2 start app.js

3. generar un script de inicio activo

   pm2 startup

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

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

Si desea que la secuencia de comandos de inicio se ejecute con otro usuario, simplemente use la opción -u <username> y la opción --hp <user_home>:

Answer 2

El problema con rc.local es que se accede a los comandos como root que es diferente de 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 especificado necesita iniciar sesión para que las cosas comiencen, lo que en mi situación siempre fue el caso.

Answer 3

Escribí un guión que hace exactamente esto:

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

No lo he intentado por siempre, pero puedes personalizar el comando que ejecuta, por lo que debe ser sencillo:

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

Answer 4

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}}

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

Answer 5

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

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

Answer 6

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

Luego encontré estas instrucciones por Digital Ocean:

digitalocean.com/community/tutorials/…

Usar PM2 como se explicó fue muy simple y funciona perfectamente: mis servidores virtuales tuvieron dos fallas físicas, ya que el tiempo de inactividad fue de solo un minuto.

Answer 7

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

Aquí hay un ejemplo de una secuencia de comandos que he creado 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 las PATH estuvieran configuradas explícitamente o disponibles para el usuario raíz, ya que las secuencias de comandos init.d se ejecutan como raíz.

Answer 8

Puede usar el servicio para siempre para hacer esto.

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

Esto aprovisionará app.js en el directorio actual como un servicio por siempre. El servicio se reiniciará automáticamente cada vez que se reinicie el sistema. También cuando se detiene, intentará una parada elegante. Este script también incluye el script logrotate.

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

NOTA: soy el autor del servicio para siempre.

Answer 9

Puede usar el siguiente comando en su caparazón para iniciar su nodo para siempre
siempre app.js // mi script de nodo
debe tener en cuenta que el servidor en el que se ejecuta su aplicación siempre debe mantenerse activo.

Answer 10

Respuesta copiada de la question 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

Comience una aplicación

$ pm2 start app.js

Si usa Express, entonces puede iniciar su aplicación como

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

Listado de todos los procesos en ejecución:

$ pm2 list

Enumerará 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 registros

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

Answer 11

Sugeriría usar crontab. Es fácil de usar

Cómo

1. Para comenzar la edición, ejecute lo siguiente reemplazando el "usuario de prueba" con el usuario de tiempo de ejecución deseado para el proceso de nodo. Si eliges un usuario diferente a ti mismo, deberás 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 para facilitar su 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 sobre la instalación del cron.

5. Para una mayor confirmación de la instalación del cron, ejecute lo siguiente (nuevamente reemplazando "testuser" con su nombre de usuario de destino) para listar los crones instalados 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 a su script para siempre no es correcta, ejecute which forever para obtener la ruta completa.

Dado que forever llama al 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

• Página de manual de crontab
• Ubuntu Cron HowTo

Answer 12

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

1. Cree un archivo de script 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 según tu configuración!

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

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. Copie y pegue (cambie bob al usuario deseado).

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

Guarde el crontab.

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

Answer 13

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

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

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

ref: digitalocean.com/community/tutorials/…

Answer 14

complete 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;

Answer 15

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

Finalmente obtuve 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 al tuyo. 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 configure NODE_ENV en una línea separada, su aplicación todavía se ejecutará en modo de desarrollo, porque forever no obtiene NODE_ENV.

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

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

Será mejor que configure el entorno NODE_ENV en su 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 stop / start /PATH_TO_PROJECT/app.js para siempre a través de ssh sin volver a establecer NODE_ENV.