No Linux, como evitar um processo de fundo de ser interrompido após cliente fechamento SSH

Question

Eu estou trabalhando em uma máquina linux através de SSH (Putty). Eu preciso deixar um processo em execução durante a noite, então eu pensei que eu poderia fazer isso, iniciando o processo no fundo (com um e comercial no final do comando) e redirecionar stdout para um arquivo. Para minha surpresa, que não funciona. Assim que eu fechar a janela Putty, o processo é interrompido.

Como posso impedir que isso aconteça ??

Answer 1

Confira o programa " nohup ".

Answer 2

Eu recomendaria usar GNU tela . Ele permite que você se desconectar do servidor, enquanto todos os seus processos continuar a executar. Eu não sei como eu vivi sem ele antes de eu sabia que existia.

Answer 3

Quando a sessão é fechada o processo recebe o sinal SIGHUP que, aparentemente, não está pegando. Você pode usar o comando nohup ao iniciar o processo ou a festa built-in disown -h comando após o início do processo para impedir que isto aconteça:

> 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

daemonize? nohup? TELA? (Tmux ftw, a tela é lixo; -)

Basta fazer o que todos os outros aplicativo tem feito desde o início -. Garfo duplo

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

bang! Feito :-) Eu usei isso inúmeras vezes em todos os tipos de aplicativos e muitas máquinas antigas. Você pode combinar com redirecionamentos e outros enfeites para abrir um canal privado entre você eo processo.

Criar como 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

e

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

E lá vai você, spawn o que quer. o <(:) abre um pipe anônimo via substituição processo, que morre, mas as varas de tubos ao redor porque você tem um identificador para ele. Eu costumo fazer uma sleep 1 vez de : porque o seu um pouco atrevido, e eu recebo um erro de "arquivo ocupado" - nunca acontece se um comando real é RAN (por exemplo, command true)

"heredoc fornecimento":

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

Isso funciona em cada shell que eu já tentaram, incluindo busybox / etc (initramfs). Eu nunca vi isso antes, eu descobri-lo de forma independente enquanto cutucando, que sabia fonte pode aceitar argumentos? Mas muitas vezes serve como uma forma muito mais gerenciável de eval, se existe tal coisa a.

Answer 5

nohup blah &

Substitua o nome do processo para blah!

Answer 6

Pessoalmente, como o comando 'lote'.

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

Este stuffs-lo para o fundo e, em seguida mails os resultados para você. É uma parte do cron.

Answer 7

Como outros já mencionado, para executar um processo em segundo plano para que você possa desligar da sua sessão SSH, você precisa ter o processo de fundo adequadamente dissociar-se do seu terminal de controle - que é o pseudo-tty que a sessão SSH usos.

Você pode encontrar informações sobre daemonizing processos em livros como Stevens' 'Programa Avançado de Rede, Vol 1, 3 Edn' ou 'Programação Avançada Unix' do Rochkind.

I recentemente (no último par de anos) teve de lidar com um programa recalcitrante que não daemonize-se corretamente. Acabei lidar com isso através da criação de um programa daemonizing genérica -. Semelhante ao nohup mas com mais controles disponíveis

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)

O duplo-traço é opcional em sistemas que não utilizam a função GNU getopt (); é necessário (ou você tem que especificar POSIXLY_CORRECT no ambiente) no Linux etc. Desde duplo traço funciona em qualquer lugar, é melhor usá-lo.

Você ainda pode entrar em contato comigo (Nome DOT Apelido at gmail dot com) se quiser que a fonte para daemonize.

No entanto, o código é agora (finalmente) disponível no GitHub na minha SOQ (Stack Perguntas overflow) repositório como daemonize-1.10.tgz arquivo no pacotes sub-diretório.

Answer 8

Se você usar a tela para executar um processo como root, cuidado com a possibilidade de ataques de elevação de privilégios. Se sua conta for comprometida de alguma forma, haverá uma maneira direta de assumir todo o servidor.

Se este processo precisa ser executado regularmente e você tem acesso suficiente no servidor, uma opção melhor seria usar cron a correr o trabalho. Você também pode usar init.d (o super daemon) para iniciar o seu processo em segundo plano, e pode terminar assim que ele é feito.

Answer 9

Em um sistema baseado em Debian (na máquina remota) Instalação:

sudo apt-get install tmux

Uso:

tmux

Comandos de corrida você quer

Para mudar o nome da sessão:

Ctrl + B , em seguida, $

set Nome

Para sessão de saída:

Ctrl + B , em seguida, D

(Isto deixa a sessão tmux). Depois, você pode sair do SSH.

Quando você precisa voltar / verificar-lo novamente, iniciar SSH e digite

tmux anexar session_name

Ele irá levá-lo de volta para sua sessão tmux.

Answer 10

nohup é muito bom se você quiser registrar seus dados para um arquivo. Mas quando ele vai para fundo você é incapaz de dar-lhe uma senha, se seus scripts pedir. Eu acho que você deve tentar screen. sua utilidade a você pode instalar em sua distribuição Linux usando yum, por exemplo, no CentOS yum install screen então acessar o servidor via massa ou de outro software, em seu tipo shell screen. Ele vai abrir a tela [0] em massa de vidraceiro. Você trabalha. Você pode criar mais ecrã [1], a tela [2], etc na mesma sessão de massa de vidraceiro.

comandos básicos que você precisa saber:

Para iniciar tela

tela

---

Para c reate próxima tela

ctrl + a + c

---

Para mover para n tela ext você criou

ctrl + a + n

---

Para d etach

ctrl + a + d

---

Durante o trabalho de perto a sua massa de vidraceiro. E da próxima vez quando você entra através do tipo de massa

tela -r

Para voltar a ligar a sua tela, e você pode ver o seu processo ainda está em execução na tela. E para sair do tipo de tela #exit.

Para mais detalhes veja man screen.

Answer 11

Para a maioria dos processos, poderá pseudo-daemonize usando este truque de linha de comando do Linux:

# ((mycommand &)&)

Por exemplo:

# ((sleep 30 &)&)
# exit

Em seguida, iniciar uma nova janela de terminal e:

# ps aux | grep sleep

mostrará que sleep 30 ainda está em execução.

O que você tem feito é iniciado o processo como um filho de uma criança, e quando sair, o comando nohup que normalmente desencadear o processo de saída não em cascata até o grand-filho, deixando-o órfão processo, ainda em curso.

Eu prefiro este "defini-lo e esquecê-lo" abordagem, não há necessidade de lidar com nohup, screen, tmux, I / o redirecionamento, ou qualquer dessas coisas.

Answer 12

nohup permite que um processo cliente para não ser morto se um processo pai for morto, para o argumento quando sair. Mesmo melhor ainda usar:

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

nohup torna o processo de começar imune à rescisão que sua sessão SSH e seus processos filhos são matança em cima de você fazer o logout. O comando i deu fornece uma maneira que você pode armazenar o pid da aplicação em um arquivo pid para que você possa correcly matá-lo mais tarde e permite que o processo seja executado depois de ter desconectado.

Answer 13

Use a tela. É muito simples de usar e funciona como vnc para terminais. http://www.bangmoney.org/presentations/screen.html

Answer 14

Se você está disposto a executar aplicativos X, bem como -. Uso XPRA juntamente com "tela"

Answer 15

Eu também iria para o programa de tela (sei que some1 resposta mais estava tela, mas esta é uma conclusão)

Não é apenas o fato de que &, ctrl + z bg disown, nohup, etc. pode dar-lhe uma surpresa desagradável que quando você logoff trabalho ainda serão mortos (eu não sei por que, mas tinha acontecido comigo, e ele didn 't preocupar com isso ser motivo eu mudei para usar a tela, mas eu acho que anthonyrisinger solução como dupla bifurcação iria resolver isso), também a tela tem um importante vantagem sobre apenas back-terra:

screen will background your process without losing interactive control to it

e btw, esta é uma pergunta que eu nunca pediria em primeiro lugar :) ... i usar a tela do meu início de fazer qualquer coisa em qualquer unix ... i (quase) nunca trabalho em um shell unix / linux sem iniciar a tela em primeiro lugar ... e eu deveria parar agora, ou eu vou começar uma apresentação interminável de que boa tela é eo que pode fazer para ya ... procurá-lo por si mesmo, vale a pena;)

Answer 16

Há também a daemon comando do pacote de código aberto libslack.

daemon é bastante configurável e se preocupa com todas as coisas daemon tedioso, como o reinício automático, logging ou manuseio pidfile.

Answer 17

Anexar esta corda ao seu comando:> & - 2> & - <& - &. > & - significa perto stdout. 2> & - meios perto stderr. <& - meios perto stdin. E meios executado em segundo plano. Isso funciona para programaticamente iniciar um trabalho via ssh, também:

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

Answer 18

Eu costumava comando tela. Este link tem o detalhe de como fazer isso

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

Answer 19

resposta aceita sugiro usar nohup . Eu prefiro sugerir o uso pm2 . Usando pm2 sobre nohup tem muitas vantagens, como manter a aplicação viva, manter arquivos de log para aplicação e muito mais outras características. Para mais detalhes verificar isso .

Para instalar pm2 você precisa baixar npm . Para o sistema baseado em Debian

sudo apt-get install npm

e para Redhat

sudo yum install npm

Ou você pode seguir estes instrução. Após a instalação do npm usá-lo para instalar pm2

npm install pm2@latest -g

Uma vez que o seu feito você pode começar a sua aplicação

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

Para o processo de utilização Monitorização seguintes comandos:

$ 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

Gerenciar processos usando tanto nome do aplicativo ou ID do processo ou gerencia todos os processos juntos:

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

Os arquivos de log podem ser encontrados em

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

---

arquivos executáveis ??binários podem também ser executado usando PM2. Você tem que fez uma alteração no arquivo jason. Alterar o "exec_interpreter" : "node", para "exec_interpreter" : "none". (veja o atributos seção ).

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

A compilação acima código

gcc -o hello hello.c  

e executá-lo com np2 no fundo

pm2 start ./hello

Answer 20

Em systemd / Linux, systemd-run é uma boa ferramenta para lançar processos independente de sessão. Aborrecedores que vão odiar