Avvia automaticamente per sempre (nodo) al riavvio del sistema

Sto usando il modulo per sempre del nodo per far funzionare il mio nodo server. Forever tuttavia termina in caso di riavvio del sistema. Esiste un modo per avviare automaticamente il server nodo (con per sempre) al riavvio del sistema?

Suggerirei di usare crontab. È facile da usare.

Come

1. Per iniziare la modifica eseguire quanto segue sostituendo "testuser" con l'utente di runtime desiderato per il processo del nodo. Se scegli un utente diverso da te, dovrai eseguirlo con sudo.

   $ crontab -u testuser -e

2. Se non l'hai mai fatto prima, ti verrà chiesto con quale editor desideri modificare. Mi piace vim, ma consiglierò nano per facilità d'uso.

3. Una volta nell'editor aggiungi la seguente riga:

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

4. Salva il file. Dovresti ricevere un feedback sul fatto che cron è stato installato.

5. Per un'ulteriore conferma dell'installazione del cron, eseguire quanto segue (sostituendo nuovamente "testuser" con il nome utente di destinazione) per elencare i cron attualmente installati:

   $ crontab -u testuser -l 

Nota che a mio avviso, dovresti sempre usare percorsi completi quando esegui binari in cron. Inoltre, se il percorso dello script forever non è corretto, esegui which foreverper ottenere il percorso completo.

Dato che le foreverchiamate node, potresti anche voler fornire il percorso completo per node:

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

Ulteriori letture

• Pagina man di crontab
• Ubuntu Cron HowTo

Per questo puoi usare il servizio per sempre.

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

Ciò fornirà app.js nella directory corrente come servizio tramite per sempre. Il servizio si riavvierà automaticamente ogni volta che si riavvia il sistema. Anche quando fermato tenterà un arresto grazioso. Questo script fornisce anche lo script logrotate.

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

NOTA: sono l'autore del servizio per sempre.

1. Installa PM2 a livello globale usando NPM

   npm install pm2 -g

2. Inizia la tua sceneggiatura con pm2

   pm2 start app.js

3. genera uno script di avvio attivo

   pm2 startup

   NOTA: l'avvio di pm2 serve per avviare PM2 al riavvio del sistema. PM2 una volta avviato, riavvia tutti i processi che aveva gestito prima che il sistema si arrestasse.

Nel caso in cui si desideri disabilitare l'avvio automatico, utilizzare semplicemente pm2 unstartup

Se si desidera che lo script di avvio venga eseguito con un altro utente, utilizzare l' -u <username>opzione e il--hp <user_home>:

Questo caso è valido per Debian.

Aggiungi quanto segue a /etc/rc.local

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

• {{user}} sostituisce il tuo nome utente.
• {{app path}}sostituisce il percorso dell'app. Per esempio,/var/www/test/app.js

Un metodo crontab alternativo ispirato a questa risposta e a questo post sul blog.

1. Crea un file di script bash (cambia bob all'utente desiderato).

vi /home/bob/node_server_init.sh

2. Copialo e incollalo all'interno del file che hai appena creato.

#!/bin/sh

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

Assicurati di modificare i percorsi sopra in base alla tua configurazione!

3. Assicurarsi che lo script bash possa essere eseguito.

chmod 700 /home/bob/node_server_init.sh

4. Prova lo script bash.

sh /home/bob/node_server_init.sh

5. Sostituire "bob" con l'utente runtime per il nodo.

crontab -u bob -e

6. Copia e incolla (cambia bob all'utente desiderato).

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

Salva il crontab.

Sei arrivato alla fine, il tuo premio è un riavvio (da testare) :)

Risposta copiata dalla domanda allegata .

È possibile utilizzare PM2 , è un gestore dei processi di produzione per le applicazioni Node.js con un bilanciamento del carico integrato.

Installa PM2

$ npm install pm2 -g

Avvia un'applicazione

$ pm2 start app.js

Se si utilizza express, è possibile avviare l'app come

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

Elenco di tutti i processi in esecuzione:

$ pm2 list

Elencherà tutto il processo. È quindi possibile interrompere / riavviare il servizio utilizzando ID o Nome dell'app con il seguente comando.

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

Per visualizzare i registri

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

Per questo è necessario creare uno script shell nella cartella /etc/init.d. È un po 'complicato se non l'hai mai fatto, ma ci sono molte informazioni sul web sugli script init.d.

Ecco un esempio di uno script che ho creato per eseguire un sito CoffeeScript per sempre:

#!/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

Ho dovuto assicurarmi che la cartella e i PERCORSI fossero esplicitamente impostati o disponibili all'utente root poiché gli script init.d venivano eseguiti come root.

Usa il PM2

Qual è l'opzione migliore per eseguire il server di produzione del server

Quali sono i vantaggi di eseguire l'applicazione in questo modo?

• PM2 riavvierà automaticamente l'applicazione in caso di arresto anomalo.

• PM2 manterrà un registro delle eccezioni non gestite, in questo caso, in un file in /home/safeuser/.pm2/logs/app-err.log.

• Con un solo comando, PM2 può garantire il riavvio di tutte le applicazioni che gestisce al riavvio del server. Fondamentalmente, l'applicazione del nodo verrà avviata come servizio.

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

Per sempre non è stato creato per far funzionare le applicazioni del nodo come servizi. L'approccio giusto è quello di creare una voce / etc / inittab (vecchi sistemi linux) o un upstart (nuovi sistemi linux).

Ecco un po 'di documentazione su come configurarlo come upstart: https://github.com/cvee/node-upstart

crontabnon funziona per me su CentOS x86 6.5. @reboot sembra non funzionare.

Finalmente ho ottenuto questa soluzione:

Modificare: /etc/rc.local

sudo vi /etc/rc.local

Aggiungi questa riga alla fine del file. Cambia USER_NAMEe PATH_TO_PROJECTal tuo. NODE_ENV=productionsignifica che l'app viene eseguita in modalità di produzione. Puoi aggiungere più righe se devi eseguire più di un'app node.js.

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

Non impostare NODE_ENVsu una riga separata, l'app funzionerà comunque in modalità di sviluppo, perché per sempre non si ottiene NODE_ENV.

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

Salvare ed uscire da vi (premere ESC : w q return). Puoi provare a riavviare il server. Dopo il riavvio del server, l'app node.js dovrebbe essere eseguita automaticamente, anche se non si accede a nessun account in remoto tramite ssh.

Faresti meglio a impostare l' NODE_ENVambiente nella tua shell. NODE_ENVverrà impostato automaticamente quando il tuo account accederà USER_NAME.

echo export NODE_ENV=production >> ~/.bash_profile

Quindi puoi eseguire comandi come per sempre stop / start /PATH_TO_PROJECT/app.jsvia ssh senza impostare di NODE_ENVnuovo.

Ho scritto una sceneggiatura che fa esattamente questo:

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

Non ho provato per sempre, ma puoi personalizzare il comando che esegue, quindi dovrebbe essere semplice:

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

Il problema con rc.local è che i comandi sono accessibili come root, che è diverso dal loggarsi come utente e usare sudo.

Ho risolto questo problema aggiungendo uno script .sh con i comandi di avvio che voglio etc / profile.d. Qualsiasi file .sh in profile.d verrà caricato automaticamente e qualsiasi comando verrà trattato come se si usasse il normale sudo.

L'unico aspetto negativo di questo è che l'utente specificato deve effettuare il login per iniziare le cose che nella mia situazione era sempre il caso.

Ho provato molte delle risposte sopra. Nessuno di loro ha funzionato per me. La mia app è installata in /homee come utente, non come root. Questo probabilmente significa che quando vengono eseguiti gli script di avvio sopra menzionati,/home non è ancora montato, quindi l'app non viene avviata.

Poi ho trovato queste istruzioni di Digital Ocean:

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

L'uso di PM2 come spiegato è stato molto semplice e funziona perfettamente: i miei server virtuali hanno avuto due arresti anomali fisici poiché i tempi di inattività sono stati solo di circa un minuto.

esempio completo crontab (situato in / 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;

È possibile utilizzare il seguente comando nella shell per avviare il nodo per sempre:

forever app.js //my node script

È necessario tenere presente che il server su cui è in esecuzione l'app deve essere sempre attivo.