Sous Linux, comment empêcher un processus en arrière-plan d'être arrêté après la fermeture du client SSH

Question

Je travaille sur une machine Linux sous SSH (Putty). Je dois laisser un processus en cours d'exécution pendant la nuit. Je pensais donc pouvoir le faire en démarrant le processus en arrière-plan (avec une esperluette à la fin de la commande) et en redirigeant stdout vers un fichier. À ma grande surprise, ça ne marche pas. Dès que je ferme la fenêtre Putty, le processus est arrêté.

Comment puis-je empêcher cela?

Answer 1

Découvrez le " nohup " programme.

Answer 2

Je vous recommanderais d'utiliser Écran GNU . Il vous permet de vous déconnecter du serveur pendant que tous vos processus continuent de s'exécuter. Je ne sais pas comment je vivais sans elle avant de savoir qu'elle existait.

Answer 3

Lorsque la session est fermée, le processus reçoit le signal SIGHUP qu’il ne semble apparemment pas capter. Vous pouvez utiliser la commande nohup lors du lancement du processus ou la commande intégrée bash disown -h après le démarrage du processus pour éviter que cela ne se produise:

> help disown
disown: disown [-h] [-ar] [jobspec ...]
     By default, removes each JOBSPEC argument from the table of active jobs.
    If the -h option is given, the job is not removed from the table, but is
    marked so that SIGHUP is not sent to the job if the shell receives a
    SIGHUP.  The -a option, when JOBSPEC is not supplied, means to remove all
    jobs from the job table; the -r option means to remove only running jobs.

Answer 4

démoniser? nohup? ÉCRAN? (tmux ftw, l’écran est indésirable; -)

Faites comme toutes les autres applications depuis le début - double fork.

# ((exec sleep 30)&)
# grep PPid /proc/`pgrep sleep`/status
PPid:   1
# jobs
# disown
bash: disown: current: no such job

Bang! Fait :-) J'ai utilisé ces innombrables fois sur tous les types d'applications et sur de nombreuses vieilles machines. Vous pouvez combiner avec des redirections et d’autres choses pour ouvrir un canal privé entre vous et le processus.

Créer en tant que coproc.sh:

#!/bin/bash

IFS=

run_in_coproc () {
    echo "coproc[$1] -> main"
    read -r; echo $REPLY
}

# dynamic-coprocess-generator. nice.
_coproc () {
    local i o e n=${1//[^A-Za-z0-9_]}; shift
    exec {i}<> <(:) {o}<> >(:) {e}<> >(:)
. /dev/stdin <<COPROC "${@}"
    (("\$@")&) <&$i >&$o 2>&$e
    $n=( $o $i $e )
COPROC
}

# pi-rads-of-awesome?
for x in {0..5}; do
    _coproc COPROC$x run_in_coproc $x
    declare -p COPROC$x
done

for x in COPROC{0..5}; do
. /dev/stdin <<RUN
    read -r -u \${$x[0]}; echo \$REPLY
    echo "$x <- main" >&\${$x[1]}
    read -r -u \${$x[0]}; echo \$REPLY
RUN
done

et ensuite

# ./coproc.sh 
declare -a COPROC0='([0]="21" [1]="16" [2]="23")'
declare -a COPROC1='([0]="24" [1]="19" [2]="26")'
declare -a COPROC2='([0]="27" [1]="22" [2]="29")'
declare -a COPROC3='([0]="30" [1]="25" [2]="32")'
declare -a COPROC4='([0]="33" [1]="28" [2]="35")'
declare -a COPROC5='([0]="36" [1]="31" [2]="38")'
coproc[0] -> main
COPROC0 <- main
coproc[1] -> main
COPROC1 <- main
coproc[2] -> main
COPROC2 <- main
coproc[3] -> main
COPROC3 <- main
coproc[4] -> main
COPROC4 <- main
coproc[5] -> main
COPROC5 <- main

Et voilà, engendre quoi que ce soit. le < (:) ouvre un canal anonyme via une substitution de processus, qui meurt, mais le canal reste collé car vous en avez le contrôle. Je fais habituellement un sleep 1 au lieu de : parce que c'est un peu racé, et j'aurais un fichier & "Occupé" & ";" erreur - ne se produit jamais si une commande réelle est exécutée (par exemple, command true)

& "Hérédoc sourcing &";

. /dev/stdin <<EOF
[...]
EOF

Cela fonctionne sur tous les shell que j'ai jamais essayés, y compris busybox / etc (initramfs). Je ne l'ai jamais vu faire auparavant, je l'ai découvert de manière indépendante en poussant, qui savait que la source pouvait accepter les arguments? Mais il s’agit souvent d’une forme d’évaluation beaucoup plus gérable, s’il en existe une.

Answer 5

nohup blah &

Remplacez le nom de votre processus par blah!

Answer 6

Personnellement, j'aime bien la commande "batch".

$ batch
> mycommand -x arg1 -y arg2 -z arg3
> ^D

Cela le place en arrière-plan, puis vous envoie les résultats par courrier. C'est une partie de cron.

Answer 7

Comme d'autres l'ont noté, pour exécuter un processus en arrière-plan afin de pouvoir vous déconnecter de votre session SSH, vous devez vous assurer que le processus en arrière-plan se dissocie correctement de son terminal de contrôle, qui est le pseudo-tty de la session SSH. utilise.

Vous pouvez trouver des informations sur la démonisation de processus dans des ouvrages tels que Stevens & "Advanced Network Program, Vol 1, 3rd Edn &"; ou & "Programmation Unix avancée" de Rochkind & ";

J'ai eu récemment (au cours des deux dernières années) un programme récalcitrant qui ne s'est pas démonisé correctement. J'ai fini par régler ce problème en créant un programme de démonisation générique - similaire à nohup mais avec plus de contrôles disponibles.

Usage: daemonize [-abchptxV][-d dir][-e err][-i in][-o out][-s sigs][-k fds][-m umask] -- command [args...]
  -V          print version and exit
  -a          output files in append mode (O_APPEND)
  -b          both output and error go to output file
  -c          create output files (O_CREAT)
  -d dir      change to given directory
  -e file     error file (standard error - /dev/null)
  -h          print help and exit
  -i file     input file (standard input - /dev/null)
  -k fd-list  keep file descriptors listed open
  -m umask    set umask (octal)
  -o file     output file (standard output - /dev/null)
  -s sig-list ignore signal numbers
  -t          truncate output files (O_TRUNC)
  -p          print daemon PID on original stdout
  -x          output files must be new (O_EXCL)

Le double tiret est facultatif sur les systèmes n'utilisant pas la fonction GNU getopt (); cela est nécessaire (ou vous devez spécifier POSIXLY_CORRECT dans l'environnement) sous Linux, etc. Comme le double tiret fonctionne partout, il est préférable de l'utiliser.

Vous pouvez toujours me contacter (prénom point dernier nom sur gmail point com) si vous souhaitez que le code source soit daemonize.

Cependant, le code est maintenant (enfin) disponible sur GitHub dans mon SOQ (pile). Questions de débordement) dans le référentiel sous forme de fichier daemonize-1.10.tgz dans packages sous-répertoire.

Answer 8

Si vous utilisez screen pour exécuter un processus en tant que root, prenez garde à la possibilité d'attaques par élévation de privilèges. Si votre compte est compromis d'une manière ou d'une autre, il existe un moyen direct de prendre le contrôle de l'intégralité du serveur.

Si ce processus doit être exécuté régulièrement et que vous disposez d'un accès suffisant sur le serveur, une meilleure option serait d'utiliser cron lors de l'exécution du travail. Vous pouvez également utiliser init.d (le super démon) pour démarrer votre processus en arrière-plan. Ce processus peut se terminer dès que c'est fait.

Answer 9

Sur un système basé sur Debian (sur la machine distante) Installer:

  

sudo apt-get install tmux

Utilisation:

  

tmux

     

exécutez les commandes que vous souhaitez

Pour renommer la session:

  

Ctrl + B , puis $

     

Nom défini

Pour quitter la session:

  

Ctrl + B , puis D

(cela quitte la session tmux). Ensuite, vous pouvez vous déconnecter de SSH.

Lorsque vous devez revenir / vérifier à nouveau, démarrez SSH et entrez

  

tmux attach nom_session

Cela vous ramènera à votre session tmux.

Answer 10

nohup est très utile si vous souhaitez enregistrer vos informations dans un fichier. Mais quand il passe en arrière-plan, vous ne pouvez pas lui donner un mot de passe si vos scripts le demandent. Je pense que vous devez essayer screen. c’est un utilitaire que vous pouvez installer sur votre distribution linux en utilisant yum, par exemple sous CentOS yum install screen, puis accédez à votre serveur via putty ou un autre logiciel, dans votre type de shell man screen. Cela ouvrira l'écran [0] dans le mastic. Fais ton travail. Vous pouvez créer plus d'écran [1], d'écran [2], etc. au cours de la même session de mastic.

Commandes de base à connaître:

Pour démarrer l'écran

écran

Pour c créer l'écran suivant

ctrl + a + c

Pour passer à n écran externe que vous avez créé

ctrl + a + n

À d correspondance

ctrl + a + d

Pendant le travail, fermez votre mastic. Et la prochaine fois que vous vous connecterez via un type de mastic

écran -r

Pour vous reconnecter à votre écran, vous pouvez voir que votre processus est toujours en cours d'exécution à l'écran. Et pour quitter le type d’écran #exit.

Pour plus de détails, voir <=>.

Answer 11

Pour la plupart des processus, vous pouvez effectuer une pseudo-démonisation à l'aide de cette vieille astuce de ligne de commande Linux:

# ((mycommand &)&)

Par exemple:

# ((sleep 30 &)&)
# exit

Ouvrez ensuite une nouvelle fenêtre de terminal et:

# ps aux | grep sleep

Indique que sleep 30 est toujours en cours d'exécution.

Vous avez démarré le processus en tant qu'enfant d'un enfant. Lorsque vous quittez, la commande nohup qui déclencherait normalement la fermeture du processus ne se répercute pas en cascade sur le petit-enfant. un processus orphelin, toujours en cours d'exécution.

Je préfère ceci & "Définissez-le et oubliez-le &"; approche, pas besoin de traiter avec screen, <=>, tmux, redirection d’E / S, ni aucun de ces éléments.

Answer 12

Nohup permet à un processus client de ne pas être tué si un processus parent est tué, comme argument lorsque vous vous déconnectez. Mieux encore, utilisez:

nohup /bin/sh -c "echo \$\$ > $pidfile; exec $FOO_BIN $FOO_CONFIG  " > /dev/null

Nohup rend le processus que vous commencez immunisé contre la terminaison de votre session SSH et de ses processus enfants lorsque vous vous déconnectez. La commande que j’ai donnée vous permet de stocker le pid de l’application dans un fichier pid afin que vous puissiez le tuer correctement plus tard et permettre au processus de s’exécuter une fois que vous vous êtes déconnecté.

Answer 13

Utiliser l'écran. Il est très simple à utiliser et fonctionne comme vnc pour les terminaux. http://www.bangmoney.org/presentations/screen.html

Answer 14

Si vous souhaitez également exécuter des applications X, utilisez xpra avec & "screen < !> quot;.

Answer 15

Je voudrais aussi aller pour le programme d'écran (je sais que quelque autre réponse était écran mais c'est une fin)

non seulement le fait que & amp ;, ctrl + z bg soit désavoué, nohup, etc. peut vous donner une vilaine surprise que lorsque vous vous déconnectez, le travail sera toujours tué (je ne sais pas pourquoi, mais ce , et cela ne l’a pas dérangé parce que j’ai choisi d’utiliser Screen, mais j’imagine que la solution anthonyrisinger résoudrait ce problème. / p>

screen will background your process without losing interactive control to it

et d'ailleurs, c'est une question que je ne poserais jamais en premier lieu :) ... j'utilise l'écran depuis mon début de rien faire dans n'importe quel unix ... je (presque) ne travaille JAMAIS dans un shell Unix / Linux sans commencer l'écran en premier ... et je devrais arrêter maintenant, ou je vais commencer une présentation sans fin de ce qu'est un bon écran et de ce que vous pouvez faire pour vous ... Regardez-le par vous-même, ça vaut le coup;)

Answer 16

Il existe également la commande daemon du paquetage open-source libslack.

daemon est tout à fait configurable et prend en charge tous les trucs fastidieux du démon tels que le redémarrage automatique, la journalisation ou la gestion du fichier pid.

Answer 17

Ajoutez cette chaîne à votre commande: > & amp; - 2 > & amp; - < & amp; - & amp ;. > & amp; - signifie fermer stdout. 2 & Gt; & Amp; - signifie stderr proche. < & amp; - signifie stdin proche. & amp; signifie courir en arrière-plan. Cela fonctionne également pour démarrer un travail via ssh:

$ ssh myhost 'sleep 30 >&- 2>&- <&- &'
# ssh returns right away, and your sleep job is running remotely
$

Answer 18

J'ai utilisé la commande d'écran. Ce lien contient des informations détaillées sur la procédure à suivre

.

https://www.rackaid.com / blog / linux-screen-tutorial-and-how-to / # démarrage

Answer 19

La réponse acceptée suggère d'utiliser nohup . Je suggérerais plutôt d'utiliser pm2 . L'utilisation de pm2 sur nohup présente de nombreux avantages, tels que le maintien de l'application en vie, la maintenance des fichiers journaux pour l'application et bien d'autres fonctionnalités. Pour plus de détails, consultez cette page .

Pour installer pm2 , vous devez télécharger npm . Pour les systèmes basés sur Debian

sudo apt-get install npm

et pour Redhat

sudo yum install npm

Vous pouvez également suivre ces instructions . Après avoir installé npm , utilisez-le pour installer pm2

.

npm install pm2@latest -g

Une fois que vous avez terminé, vous pouvez démarrer votre application en

.

$ pm2 start app.js              # Start, Daemonize and auto-restart application (Node)
$ pm2 start app.py              # Start, Daemonize and auto-restart application (Python)

Pour la surveillance des processus, utilisez les commandes suivantes:

$ pm2 list                      # List all processes started with PM2
$ pm2 monit                     # Display memory and cpu usage of each app
$ pm2 show [app-name]           # Show all informations about application

Gérez les processus à l'aide du nom de l'application ou de l'ID de processus ou gérez tous les processus ensemble:

$ pm2 stop     <app_name|id|'all'|json_conf>
$ pm2 restart  <app_name|id|'all'|json_conf>
$ pm2 delete   <app_name|id|'all'|json_conf>

Les fichiers journaux peuvent être trouvés dans

$HOME/.pm2/logs #contain all applications logs

Les fichiers exécutables binaires peuvent également être exécutés à l’aide de pm2. Vous devez modifier le fichier jason. Remplacez "exec_interpreter" : "node" par "exec_interpreter" : "none". (voir le section attributs ).

#include <stdio.h>
#include <unistd.h>  //No standard C library
int main(void)
{
    printf("Hello World\n");
    sleep (100);
    printf("Hello World\n");

    return 0;
}

Compiler le code ci-dessus

gcc -o hello hello.c  

et exécutez-le avec np2 en arrière-plan

pm2 start ./hello

Answer 20

Sous systemd / Linux, systemd-run est un bel outil pour lancer des processus indépendants de la session. Les haineux vont détester