je recommande d'utiliser GNU Screen . Il vous permet de vous déconnecter du serveur pendant que tous vos processus continuent de fonctionner. Je ne sais pas comment j'ai vécu sans elle avant de savoir qu'elle existait.

lorsque la session est fermée, le processus reçoit le signal SIGHUP qu'il ne capte apparemment pas. Vous pouvez utiliser la commande nohup lors du lancement du processus ou la commande intégrée disown -h après le démarrage du processus pour empêcher 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.

nohup blah &

substituez votre nom de processus à blah!

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

faites juste ce que toutes les autres applications ont fait 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é cette innombrables fois sur tous les types d'applications et de nombreux vieux appareils. Vous pouvez combiner avec redirections et autres pour ouvrir un canal privé entre vous et le processus.

créer comme coproc.sh:

#!/bin/bash

IFS=

run_in_coproc () {
    echo "coproc[] -> 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 puis

# ./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à, fraie ce que tu veux. le < (:) ouvre un tuyau anonyme via la substitution de processus, qui meurt, mais le tuyau reste autour parce que vous avez une poignée à lui. Je fais habituellement un sleep 1 au lieu de : parce que c'est légèrement osé, et j'aurais une erreur" file busy " -- n'arrive jamais si une vraie commande est lancée (par exemple, command true )

"heredoc sourcing":

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

cela fonctionne sur chaque shell simple que j'ai essayé, y compris busybox/etc (initramfs). Je ne l'ai jamais vu faire avant, je l'ai indépendamment découvert en poussant, qui savait source pourrait accepter args? Mais il sert souvent de beaucoup plus gérable forme d'eval, si une telle chose existe.

personnellement, j'aime la commande "batch".

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

cela l'affiche à l'arrière-plan, puis vous envoie les résultats. Ça fait partie de cron.

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

vous pouvez trouver des informations sur les processus de démonisation dans des livres tels que" Advanced Network Program, Vol 1, 3rd Edn "de Stevens ou"Advanced Unix Programming" de Rochkind.

I récemment (au cours des deux dernières années) a dû faire face à un programme récalcitrant qui ne s'est pas démystifié correctement. J'ai fini par gérer cela 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 optionnel sur les systèmes qui n'utilisent pas la fonction GNU getopt (); il est nécessaire (ou vous devez spécifier POSIXLY_CORRECT dans l'environnement) sur Linux, etc. Comme double-dash fonctionne partout, il est l'utiliser au mieux.

vous pouvez toujours me contacter (prénom point lastname à gmail point com) si vous voulez la source pour daemonize .

cependant, le code est maintenant (enfin) disponible sur GitHub dans mon SOQ (Stack daemonize-1.10.tgz dans le colis sous-répertoire.

Nohup permet à un processus client de ne pas être tué si un processus parent est tué, pour argument lorsque vous vous déconnectez. Encore mieux utiliser:

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

Nohup rend le processus que vous démarrez immunisé contre la terminaison qui votre session SSH et ses processus enfants sont tués lors de votre déconnexion. La commande que j'ai donnée vous fournit un moyen de stocker le pid de l'application dans un fichier pid de sorte que vous pouvez le tuer correctement plus tard et permet au processus d'exécuter après vous être connecté.

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

si vous utilisez l'écran pour exécuter un processus en tant que root, méfiez-vous de la possibilité d'attaques par élévation de privilèges. Si votre propre compte est compromis d'une manière ou d'une autre, il y aura un moyen direct de prendre en charge l'ensemble du serveur.

Si ce processus doit être exécuté régulièrement et que vous avez suffisamment d'accès sur le serveur, une meilleure option serait d'utiliser cron 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, et il peut terminer dès que c'est fait.

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 voulez

pour renommer session:

Ctrl+B puis $

ensemble Nom

Pour quitter la session:

Ctrl+B puis D

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

quand vous avez besoin de revenir/vérifier à nouveau, démarrer SSH, et entrer

tmux joindre session_name

il faudra vous retournez à votre session tmux.

nohup est très bon si vous voulez vous connecter vos données dans un fichier. Mais quand il va à fond, vous êtes incapable de donner un mot de passe si vos scripts demander. Je pense que vous devez essayer screen . c'est un utilitaire que vous pouvez installer sur votre distribution linux en utilisant yum par exemple sur CentOS yum install screen puis accéder à votre serveur via putty ou un autre logiciel, dans votre shell type screen . Il ouvrira l'écran[0] en mastic. Faire votre travail. Vous pouvez créer plus d'écran[1], d'écran[2], etc. dans la même séance de mastic.

commandes de base que vous devez savoir:

pour démarrer l'écran

écran

À c réer écran suivant

ctrl+A+C

pour passer À n ext écran que vous avez créé

ctrl+A+n

à d etach

ctrl+a+d

pendant le travail fermez votre mastic. Et la prochaine fois que vous vous connectez via putty tapez

screen-r

pour se reconnecter à votre écran, et vous pouvez voir votre processus toujours en cours d'exécution à l'écran. Et pour sortir de l'écran tapez #exit.

pour plus de détails, voir man screen .

j'irais aussi pour le programme d'écran (je sais que quelqu'un d'autre réponse était l'écran mais c'est un achèvement)

non seulement le fait que &, ctrl+z BG désavoue, nohup, etc. peut vous donner une mauvaise surprise que lorsque vous déconnexion travail sera toujours tué (Je ne sais pas pourquoi, mais il m'est arrivé, et il ne s'est pas embêté avec elle parce que je suis passé à utiliser l'écran, mais je suppose solution anthonyrisinger double fourche serait résoudre que), Également écran ont un majeure avantage sur juste retour-mise à la terre:

screen will background your process without losing interactive control to it

et btw, c'est une question Que Je ne poserais jamais en premier lieu :) ... j'utilise screen depuis le début de tout ce que je fais dans n'importe quel unix ... Je (presque) ne travaille jamais dans un interpréteur de commandes unix/linux sans démarrer 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 ce qui peut faire pour vous ... cherchez par vous-même, cela en vaut la peine;)

il y a aussi la commande daemon du paquet libslack open-source.

daemon est tout à fait configurable et se soucie de tous les trucs de démon fastidieux tels que le redémarrage automatique, la journalisation ou la manipulation de fichier pid.

Ajoutez cette chaîne à votre commande: >&- 2>&- <&- &. > & - signifie stdout fermé. 2 > & - signifie proche sderr. <&- signifie près de l'entrée standard. et les moyens d'exécuter en arrière-plan. Cela fonctionne aussi pour démarrer un travail par SSH:

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

pour la plupart des processus, vous pouvez pseudo-daemoniser en utilisant ce vieux tour de ligne de commande Linux:

# ((mycommand &)&)

par exemple:

# ((sleep 30 &)&)
# exit

puis démarrer une nouvelle fenêtre de terminal et:

# ps aux | grep sleep

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

ce que vous avez fait est de commencer le processus en tant qu'enfant d'un enfant, et quand vous sortez, la commande nohup qui déclencherait normalement le le processus de sortie ne descend pas en cascade jusqu'au petit-enfant, le laissant comme un processus orphelin, toujours en cours.

je préfère cette "régler et oublier", pas besoin de traiter avec des nohup , screen , tmux, redirection d'e/s, ou ce genre de trucs.

si vous êtes prêt à exécuter des applications X aussi - utilisez xpra avec"écran".

j'ai utilisé la commande d'écran. Ce lien a des détails sur la façon de faire ceci ""

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

réponse acceptée suggérer utiliser nohup . Je suggère plutôt d'utiliser pm2 . L'utilisation de pm2 sur nohup a de nombreux avantages, comme garder l'application vivante, maintenir des fichiers journaux pour l'application et beaucoup plus d'autres caractéristiques. Pour plus de détails , consultez .

pour installer pm2 vous devez télécharger mnp . Pour le système basé sur Debian

sudo apt-get install npm

et Pour Redhat

sudo yum install npm

ou vous pouvez suivre ces instructions . Après l'installation npm utilisez-le pour installer pm2

npm install pm2@latest -g

une fois fait, vous pouvez démarrer votre application par

$ 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 procédés 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érer les processus en utilisant soit le nom de l'application soit le numéro d'identification du processus ou gérer 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 en utilisant pm2. Tu dois faire un changement dans le dossier jason. Remplacer "exec_interpreter" : "node" par "exec_interpreter" : "none". (voir la section" attributs 1519510920")." ).

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

compilation du code ci-dessus

gcc -o hello hello.c  

et l'exécuter avec np2 en arrière-plan

pm2 start ./hello

On systemd/Linux, systemd-run est un bel outil pour lancer des processus indépendants des sessions. Haters gonna hate