Le nœud JS redémarre automatiquement tous les processus JS pour toujours lorsque le serveur tombe en panne
J'utilise forever js pour que mon serveur de noeud continue à fonctionner 24h/24 sur AWS EC2.
J'utilise cette commande
forever start index.js
Cependant, je remarque qu’un certain temps, le processus s’arrête de manière aléatoire et mon site est en panne. Je dois manuellement ssh sur mon serveur pour l'exécuter à nouveau en faisant:
forever restartall
Et puis ça va sauvegarde. Existe-t-il un moyen par lequel je puisse définir un délai d'attente, disons si le serveur/le site Web ne répond pas pendant 200 à 5 secondes, puis redémarre automatiquement tous les processus permanents?
Je suis nouveau dans ce domaine. Si quelqu'un peut me donner un exemple pas à pas pour mon cas, ce serait génial.
Deviner. Le problème était dû à moins de RAM disponible dans mon instance EC2. J'ai mis à niveau RAM à 2 Go et je n'ai pas encore rencontré le crash.
Le nœud peut également commettre des erreurs d'exception non récupérées, mais mon problème majeur était dû à une mémoire insuffisante.
J'espère que cela aide les autres.
Un serveur NodeJS ne devrait pas s’arrêter sans raison. La plupart du temps, c'est à cause d'une erreur 500 qui va arrêter le serveur, vous devrez alors le redémarrer .forever utilise node par défaut pour démarrer votre serveur.
nodemon est un paquet npm qui redémarre votre serveur lorsque le code change ou que votre serveur s'arrête.
Vous pouvez utiliser forever et nodemon ensemble en faisant:
forever start nodemon --exitcrash app.js
ou
forever start -c nodemon app.js
Je suggère d'utiliser le PM2
Quelle est la meilleure option pour exécuter le serveur de production serveur
Quels sont les avantages d'exécuter votre application de cette façon?
- Facile à installer et à exécuter.
PM2 redémarrera automatiquement votre application si elle se bloque.
PM2 conservera un journal de vos exceptions non gérées - dans ce cas, dans un fichier situé dans /home/safeuser/.pm2/logs/app-err.log.
Avec une seule commande, PM2 peut s’assurer que toutes les applications qu’il gère gèrent au redémarrage au redémarrage du serveur. Fondamentalement, votre application de noeud démarrera en tant que service.
Voici donc un exemple d'utilisation de cronpour exécuter des scripts permettant de redémarrer le service/d'effectuer une tâche automatisée. Fondamentalement, j'ai créé des scripts que je dois exécuter à certains intervalles de temps sur mon serveur. Dans votre cas, vous voulez créer un script qui vérifie automatiquement l’état de votre forever.js et, s’il renvoie une mauvaise réponse, exécutez la commande forever restartall mentionnée ci-dessus . 
Vous pouvez configurer ceci en créant une nouvelle entrée de crontab sur le serveur. En ce qui concerne le script, je ne suis en aucun cas un gourou du script bash; J'ai fait un script simple qui fonctionne pour moi. Voici un exemple de vérification d'un service sur ma machine, redémarrez-le s'il n'est pas en cours d'exécution.
#!/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" [email protected]
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" [email protected]
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
Cette vidéo fait partie d'une série impressionnante de déploiement de nœuds utilisant un service sur un serveur UNIX ... Peut-être que cela vous aidera. À propos, il vaut la peine de regarder les quatre vidéos ... Youtube-Link
Avez-vous déjà envisagé pm2 comme alternative? pm2 a quelques fonctionnalités intéressantes comme:
- Exécuter un cluster
- Redémarrage des instances de la grappe une par une (zéro déploiement)
- Surveillance des ressources (montre l'utilisation du processeur et de la mémoire en temps réel)
- Gérer tous les processus pm2 à l'aide de la cli
Vous pouvez également contrôler les redémarrages en ajoutant une option --restart-delay <delay>.
Voici une sortie complète de l'aide de cet outil.
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