No Linux, como evitar um processo de fundo de ser interrompido após cliente fechamento SSH
-
08-07-2019 - |
Pergunta
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 ??
Solução
Confira o programa " nohup ".
Outras dicas
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.
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.
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.
nohup blah &
Substitua o nome do processo para blah!
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.
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.
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.
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.
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
.
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.
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.
Use a tela. É muito simples de usar e funciona como vnc para terminais. http://www.bangmoney.org/presentations/screen.html
Se você está disposto a executar aplicativos X, bem como -. Uso XPRA juntamente com "tela"
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;)
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.
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
$
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
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
Em systemd / Linux, systemd-run é uma boa ferramenta para lançar processos independente de sessão. Aborrecedores que vão odiar