Estoy usando forever js para mantener mi servidor de nodo funcionando 24/7 en AWS EC2.

Yo uso este comando

forever start index.js

Sin embargo, noto que en algún momento se detiene el proceso al azar y mi sitio se cae. Tengo que ssh manualmente en mi servidor para ejecutarlo nuevamente haciendo:

forever restartall

Y luego se hace una copia de seguridad. ¿Hay alguna forma de definir un tiempo de espera, digamos si el servidor / sitio web no responde durante 200 en 5 segundos, y luego reiniciar todo el proceso para siempre automáticamente?

Soy nuevo en esto, si alguien me puede dar un ejemplo paso a paso para mi caso, sería increíble.

18
Faizan 12 may. 2016 a las 23:45

6 respuestas

La mejor respuesta

Lo averigué. El problema se debió a menos RAM disponible en mi instancia EC2. Actualicé la RAM a 2 GB y hasta ahora no he experimentado el bloqueo.

Nodo también puede cometer errores de excepción no detectados, pero mi principal problema se debió a menos memoria.

Espero que esto ayude a otros.

0
Faizan 6 jun. 2016 a las 16:20

Este video es parte de una increíble serie de despliegue de nodos que termina con el uso de un servicio en un servidor UNIX ... Quizás lo ayude. Por cierto, vale la pena ver los cuatro videos ... Youtube-Link

2
Argee 5 jun. 2016 a las 06:28

Así que este es un ejemplo del uso de cron para ejecutar scripts que pueden reiniciar el servicio / realizar alguna tarea automatizada. Básicamente, creé algunos scripts que necesito ejecutar en ciertos intervalos de tiempo en mi servidor. Para su caso, desea crear un script que verifique automáticamente el estado de su forever.js y, si devuelve una respuesta incorrecta, ejecute el comando forever restartall que mencionó anteriormente. crontab

Puede configurar esto creando una nueva entrada crontab en el servidor. En lo que respecta al guión, de ninguna manera soy un gurú del script bash; Hice un script simple que funciona para mí. Aquí hay un ejemplo de comprobación de un servicio en mi máquina, reiniciando si no se está ejecutando.

#!/bin/bash
zabbix_server="service zabbix-server"
zabbix_agent="service zabbix-agent"
logfile=zabbix_auto_restart.log
logfilePath=/etc/scripts/zabbix/$logfile
zabbix_server_running=0
zabbix_agent_running=0

grep_agent (){
        local retval=$(ps -ef | grep -v grep | grep zabbix_agentd | wc -l)
        echo $retval
}

grep_server (){
        local retval=$(ps -ef | grep -v grep | grep zabbix_server | wc -l)
        echo $retval
}

check_zabbix_agentd (){
        if (( $(grep_agent) <= 0 ))
        then
           sudo /etc/init.d/zabbix-agent start
           echo `date` "$zabbix_agent was stopped... Restarting" >> $logfilePath
           echo "************************************************" >> $logfilePath

           #Send email to notify that the script ran
           echo "$(date) $zabbix_agent was restarted from zabbix_restart.sh" | mutt -s "Zabbix Auto-restart Script Just Ran" <my-email>

        else
           let zabbix_agent_running=1
        fi
}

check_zabbix_server (){
        if (( $(grep_server) <= 0 ))
        then
           sudo /etc/init.d/zabbix-server start
           echo `date` "$zabbix_server was stopped... Restarting" >> $logfilePath
           echo "************************************************" >> $logfilePath

           #Send email to notify that the script ran
           echo "$(date) $zabbix_server was restarted from zabbix_restart.sh" | mutt -s "Zabbix Auto-restart Script Just Ran" evan.bechtol@ericsson.com

        else
           let zabbix_server_running=1
        fi
}

main_loop (){
        until ((zabbix_server_running == 1 && zabbix_agent_running == 1));
        do
                check_zabbix_agentd
                check_zabbix_server
                sleep 1.5
        done
}

main_loop
3
Evan Bechtol 3 jul. 2019 a las 12:58

Sugeriría el uso de PM2

Esta es la mejor opción para ejecutar en un servidor de producción.

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

  • Es fácil de configurar y ejecutar.
  • PM2 reiniciará automáticamente su aplicación si se bloquea.
  • 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 significa que su aplicación de nodo comenzará 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

15
B3none 14 feb. 2020 a las 11:01

Un servidor (NodeJS) no debe detenerse sin ningún motivo. La mayoría de las veces, se debe a un error 500 que no se ha editado catch y detiene el servidor, entonces deberá reiniciarlo. forever está utilizando node de forma predeterminada para iniciar su servidor.

nodemon es un paquete npm que reinicia su servidor cuando el código cambia o cuando su servidor se detiene.

Puede usar forever y nodemon juntos haciendo lo siguiente:

forever start nodemon --exitcrash app.js

O

forever start -c nodemon app.js

O, como se sugiere en otras respuestas, puede usar PM2, ¡lo cual sería mejor para la producción!

19
boehm_s 6 feb. 2020 a las 14:41

¿Alguna vez has considerado pm2 como una alternativa? pm2 tiene algunas características bastante buenas como:

  • Ejecutando un clúster
  • Reiniciar instancias en el clúster una por una (implementaciones de tiempo de inactividad cero)
  • Monitoreo de recursos (muestra el uso de CPU y memoria en tiempo real)
  • Administre todos los procesos pm2 usando el cli

Puede controlar los reinicios también agregando una opción --restart-delay <delay>.

Por la presente una salida completa de la ayuda de esta herramienta.

pm2 --help

                    -------------
Looking for a complete monitoring and management tool for PM2?
 _                             _        _            _
| | _____ _   _ _ __ ___   ___| |_ _ __(_) ___ ___  (_) ___
| |/ / _ \ | | | '_ ` _ \ / _ \ __| '__| |/ __/ __| | |/ _ \
|   <  __/ |_| | | | | | |  __/ |_| |  | | (__\__ \_| | (_) |
|_|\_\___|\__, |_| |_| |_|\___|\__|_|  |_|\___|___(_)_|\___/
     |___/

                      Features

               - Real Time Dashboard
               - CPU/Memory monitoring
               - HTTP monitoring
               - Event notification
               - Custom value monitoring
               - Real Time log display

                      Checkout

               https://keymetrics.io/

                    -------------

[PM2] Spawning PM2 daemon
[PM2] PM2 Successfully daemonized

Usage: pm2 [cmd] app

Commands:

start [options] <file|json|stdin|app_name|pm_id...>                  start and daemonize an app
deploy <file|environment>                                            deploy your json
startOrRestart <json>                                                start or restart JSON file
startOrReload <json>                                                 start or gracefully reload JSON file
startOrGracefulReload <json>                                         start or gracefully reload JSON file
stop [options] <id|name|all|json|stdin...>                           stop a process (to start it again, do pm2 restart <app>)
restart [options] <id|name|all|json|stdin...>                        restart a process
scale <app_name> <number>                                            scale up/down a process in cluster mode depending on total_number param
reload <name|all>                                                    reload processes (note that its for app using HTTP/HTTPS)
gracefulReload <name|all>                                            gracefully reload a process. Send a "shutdown" message to close all connections.
id <name>                                                            get process id by name
delete <name|id|script|all|json|stdin...>                            stop and delete a process from pm2 process list
sendSignal <signal> <pm2_id|name>                                    send a system signal to the target process
ping                                                                 ping pm2 daemon - if not up it will launch it
updatePM2                                                            update in-memory PM2 with local PM2
update                                                               (alias) update in-memory PM2 with local PM2
install|module:install <module|git:/>                                install or update a module and run it forever
module:update <module|git:/>                                         update a module and run it forever
module:generate [app_name]                                           Generate a sample module in current folder
uninstall|module:uninstall <module>                                  stop and uninstall a module
publish|module:publish                                               Publish the module you are currently on
set <key> <value>                                                    sets the specified config <key> <value>
multiset <value>                                                     multiset eg "key1 val1 key2 val2
get [key]                                                            get value for <key>
conf [key] [value]                                                   get / set module config values
config <key> [value]                                                 get / set module config values
unset <key>                                                          clears the specified config <key>
interact [options] [secret_key|command] [public_key] [machine_name]  linking action to keymetrics.io - command can be stop|info|delete|restart
link [options] [secret_key|command] [public_key] [machine_name]      linking action to keymetrics.io - command can be stop|info|delete|restart
web                                                                  launch a health API on port 9615
dump                                                                 dump all processes for resurrecting them later
save                                                                 (alias) dump all processes for resurrecting them later
resurrect                                                            resurrect previously dumped processes
startup [platform]                                                   auto resurrect process at startup. [platform] = ubuntu, centos, redhat, gentoo, systemd, darwin, amazon
logrotate                                                            copy default logrotate configuration
generate                                                             generate an ecosystem.json configuration file
ecosystem                                                            generate an ecosystem.json configuration file
reset <name|id|all>                                                  reset counters for process
describe <id>                                                        describe all parameters of a process id
desc <id>                                                            (alias) describe all parameters of a process id
info <id>                                                            (alias) describe all parameters of a process id
show <id>                                                            (alias) describe all parameters of a process id
list                                                                 list all processes
ls                                                                   (alias) list all processes
l                                                                    (alias) list all processes
status                                                               (alias) list all processes
jlist                                                                list all processes in JSON format
prettylist                                                           print json in a prettified JSON
monit                                                                launch termcaps monitoring
m                                                                    (alias) launch termcaps monitoring
flush                                                                flush logs
reloadLogs                                                           reload all logs
logs [options] [id|name]                                             stream logs file. Default stream all logs
kill                                                                 kill daemon
pull <name> [commit_id]                                              updates repository for a given app
forward <name>                                                       updates repository to the next commit for a given app
backward <name>                                                      downgrades repository to the previous commit for a given app
gc                                                                   force PM2 to trigger garbage collection
deepUpdate                                                           performs a deep update of PM2
*

Options:

-h, --help                           output usage information
-V, --version                        output the version number
-v --version                         get version
-s --silent                          hide all messages
-m --mini-list                       display a compacted list without formatting
-f --force                           force actions
-n --name <name>                     set a <name> for script
-i --instances <number>              launch [number] instances (for networked app)(load balanced)
-l --log [path]                      specify entire log file (error and out are both included)
-o --output <path>                   specify out log file
-e --error <path>                    specify error log file
-p --pid <pid>                       specify pid file
-k --kill-timeout <delay>            delay before sending final SIGKILL signal to process
--max-memory-restart <memory>        specify max memory amount used to autorestart (in megaoctets)
--restart-delay <delay>              specify a delay between restarts (in milliseconds)
--env <environment_name>             specify environment to get specific env variables (for JSON declaration)
-x --execute-command                 execute a program using fork system
-u --user <username>                 define user when generating startup script
--hp <home path>                     define home path when generating startup script
-c --cron <cron_pattern>             restart a running process based on a cron pattern
-w --write                           write configuration in local folder
--interpreter <interpreter>          the interpreter pm2 should use for executing app (bash, python...)
--interpreter-args <arguments>       interpret options (alias of --node-args)
--log-date-format <momentjs format>  add custom prefix timestamp to logs
--no-daemon                          run pm2 daemon in the foreground if it doesn't exist already
--skip-env                           do not refresh environmnent on restart/reload
--source-map-support                 force source map support
--only <application-name>            with json declaration, allow to only act on one application
--disable-source-map-support         force source map support
--merge-logs                         merge logs from different instances but keep error and out separated
--watch [paths]                      watch application folder for changes
--ignore-watch <folders|files>       folder/files to be ignored watching, chould be a specific name or regex - e.g. --ignore-watch="test node_modules "some scripts""
--node-args <node_args>              space delimited arguments to pass to node in cluster mode - e.g. --node-args="--debug=7001 --trace-deprecation"
--no-color                           skip colors
--no-vizion                          start an app without vizion feature (versioning control)
--no-autorestart                     start an app without automatic restart
--no-treekill                        Only kill the main process, not detached children
--no-pmx                             start an app without pmx
--no-automation                      start an app without pmx

Basic Examples:

Start an app using all CPUs available + set a name :
$ pm2 start app.js -i 0 --name "api"

Restart the previous app launched, by name :
$ pm2 restart api

Stop the app :
$ pm2 stop api

Restart the app that is stopped :
$ pm2 restart api

Remove the app from the process list :
$ pm2 delete api

Kill daemon pm2 :
$ pm2 kill

Update pm2 :
$ npm install pm2@latest -g ; pm2 update

More examples in https://github.com/Unitech/pm2#usagefeatures

Deployment help:

$ pm2 deploy help
2
Marco 8 jun. 2016 a las 11:06