O nohupcomando do Linux permite que processos importantes continuem em execução mesmo quando a janela do terminal que os iniciou está fechada. Mostramos como usar este venerável comando no Linux de hoje.
Índice
HUP e SIGHUP
Unix , o ancestral do Linux, foi criado antes da invenção do PC. Os computadores eram equipamentos grandes e caros. As pessoas interagiam com eles por meio de linhas seriais, localmente no mesmo prédio ou remotamente por meio de conexões lentas de modem. Originalmente, eles digitavam suas instruções em teleimpressoras que foram gradualmente substituídas por terminais burros .
Eles foram chamados de burros porque o poder de processamento estava no computador ao qual você estava conectado, e não no terminal em que você estava digitando. Os programas estavam sendo executados no computador – onde quer que ele estivesse localizado – e não no dispositivo em sua mesa.
Se aconteceu algo que interrompeu a conexão entre o seu terminal e o computador, o computador detectou a queda de linha e enviou um
HUP ou desligue o sinal dos programas que você estava executando. Os programas cessaram a execução quando receberam o sinal.
Essa funcionalidade continua viva no Linux hoje. No seu PC, uma janela de terminal é uma emulação de um terminal físico. Se você tiver processos em execução que foram iniciados a partir dessa janela do terminal e fechar essa janela, o
SIGHUP sinal é enviado aos programas para que eles sejam informados do
HUP e sei que eles deveriam terminar .
Há um efeito cascata que ocorre. Se os processos iniciaram algum processo filho, o SIGHUP também será passado para eles, para que saibam que devem ser encerrados.
O nohupcomando inicia processos filhos, mas se recusa a passar
SIGHUP sinais para eles. Isso pode parecer um problema, mas na verdade é uma função útil.
O comando nohup
Se você deseja que um processo continue mesmo que a janela do terminal a partir da qual ele foi iniciado esteja fechada, você precisa de uma maneira de interceptar o
SIGHUP para que o programa nunca o receba. (Na verdade, a janela do terminal não inicia processos, eles são iniciados pela sessão do shell dentro da janela do terminal.) A solução simples e elegante para esse problema é colocar outro processo entre a sessão do shell e o programa, e ter isso programa de camada intermediária nunca passa adiante
SIGHUP sinal.
É isso que nohupacontece. Ele inicia programas para você, de modo que eles sejam um processo filho do nohup, e não um processo filho do shell. Como não são processos filhos do shell, não receberão diretamente um
SIGHUP da casca. E se nohupnão passar
SIGHUP para seus filhos, o programa não receberá
SIGHUP de forma alguma.
Isso é útil quando, por exemplo, você tem um processo de longa execução que precisa ser executado até a conclusão. Se você fechar acidentalmente a janela do terminal e seu shell, o processo também será encerrado. Usar nohuppara iniciar o processo isola o processo do nohupsinal. Se você estiver trabalhando remotamente em um computador via SSH e não quiser que um processo confidencial seja encerrado se a conexão remota falhar, você iniciará o processo no computador remoto com nohup.
Usando nohup
Criamos um programa que não faz nada de útil, mas será executado e executado até ser finalizado. Ele imprime a hora na janela do terminal a cada três segundos. É chamado
long-proc para “processo longo”.
./long-proc
Se este fosse um programa que fizesse algo útil e quiséssemos que ele continuasse em execução mesmo que a janela do terminal e o shell estivessem fechados, nós o iniciaríamos com nohup.
nohup ./long-proc
O processo é desacoplado stdine, stdout portanto, não pode receber nenhuma entrada nem gravar na janela do terminal. Além disso, como ele ainda está em execução, você não retornará ao prompt de comando. Tudo o que isso nohupfaz é tornar o processo impermeável ao fechamento do terminal. Isso não transforma o processo em uma tarefa em segundo plano .
Agora você precisa reiniciar apenas para encerrar o processo? Não. Para interromper um nohupprocesso que você não iniciou como processo em segundo plano, pressione a combinação de teclas Ctrl+C.
A saída do programa foi capturada para nós em um arquivo chamado “nohup.out”. Podemos revisá-lo com menos.
menos nohup.out
Qualquer coisa que normalmente seria enviada para a janela do terminal é capturada no arquivo. As execuções subsequentes nohupserão anexadas ao arquivo “nohup.out” existente.
Uma maneira mais útil de executar o processo é iniciá-lo para que ele resista ao fechamento da janela do terminal e, ao mesmo tempo, nohuptorná-lo uma tarefa em segundo plano . Para fazer isso, adicionamos um E comercial ” &” ao final da linha de comando.
nohup ./long-proc &
Você precisará pressionar “Enter” mais uma vez para retornar ao prompt de comando. Fomos informados de que o número do trabalho do processo é 1 — o número entre colchetes ” []” — e que o ID do processo é 13115.
Podemos usar qualquer um deles para encerrar o processo. “Ctrl+C” não funcionará agora porque o programa não tem nenhuma associação com a janela do terminal ou com o shell.
Se você esquecer qual é o número do trabalho, poderá usar o jobscomando para listar as tarefas em segundo plano que foram iniciadas nessa janela do terminal.
empregos
Para encerrar nossa tarefa podemos usar o killcomando e o número do trabalho, precedido por um sinal de porcentagem ” %“, assim:
matar % 1
Se você fechou a janela do terminal, precisará encontrar o ID do processo e usá-lo com o killcomando. O pgrepcomando encontrará o ID do processo que corresponde à pista de pesquisa fornecida. Procuraremos o nome do processo.
pgrep processo longo
Agora podemos usar o ID do processo para encerrá-lo.
matar 13115
Na próxima vez que você clicar em “Enter”, você será informado de que o processo foi encerrado.
Agora vamos ver o que não encerra o processo. Vamos reiniciá-lo e fechar a janela do terminal.
nohup ./long-proc
Se abrirmos uma nova janela de terminal e procurarmos nosso processo com pgrep, veremos que ele ainda está em execução. Fechar a janela do terminal que iniciou o processo não teve efeito.
pgrep processo longo
É possível passar vários comandos para o nohup, mas geralmente é melhor iniciá-los separadamente. Torna mais fácil manipulá-los como trabalhos em segundo plano. Os comandos não serão executados ao mesmo tempo, serão executados um após o outro. A execução não é simultânea, é sequencial. Para que eles sejam executados simultaneamente, você precisa iniciá-los separadamente.
Dito isto, para iniciar vários processos ao mesmo tempo , use nohuppara iniciar um shell Bash e use a -copção (comandos) com a sequência de comandos. Use aspas simples ” '” para agrupar a lista de comandos e “e” comercial duplo ” &&” para separar os comandos.
nohup bash -c 'ls /bin && ls /sbin'
Se você examinarless o arquivo “nohup.out”, verá a saída do primeiro processo e, em seguida, a saída do segundo processo.
menos nohup.out
A saída de ambos os comandos foi capturada no arquivo “nohup.out”. Não está interligado, a saída do segundo processo só começa quando o primeiro processo termina.
Se quiser usar um arquivo próprio em vez de “nohup.out”, você pode redirecionar o comando para o arquivo de sua escolha.
nohup bash -c 'ls /bin && ls /sbin' > meuarquivo.txt
Observe que a mensagem não diz mais “anexando saída a nohupo.out”, mas sim “redirecionando stderr para stdout” e estamos redirecionando stdout para nosso arquivo “myfile.txt”.
Podemos olhar dentro do arquivo “myfile.txt” com menos.
menos meuarquivo.txt
Como antes, contém a saída de ambos os comandos.
É engraçado como a história de uma concessionária às vezes pode fazer parecer que ela não tem relevância para os tempos modernos. O nohup comando é um desses. Algo que foi criado para lidar com desconexões em linhas seriais ainda é útil para os usuários Linux de hoje em máquinas incrivelmente poderosas.
