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 tu estava conectado, e não no terminal em que tu 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 tu estava executando. Os programas cessaram a execução quando receberam o sinal.
esta funcionalidade continua viva no Linux hoje. No seu PC, uma janela de terminal é uma emulação de um terminal físico. Se tu tiver processos em execução que foram iniciados a partir dessa janela do terminal e fechar esta 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. isto pode parecer um problema, mas na verdade é uma função útil.
O comando nohup
Se tu deseja que um processo continue mesmo que a janela do terminal a partir da qual ele foi iniciado esteja fechada, tu 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 este problema é colocar outro processo entre a sessão do shell e o programa, e ter isto programa de camada intermediária nunca passa adiante
SIGHUP sinal.
É isto que nohupacontece. Ele inicia programas para tu, 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.
isto é útil quando, por exemplo, tu tem um processo de longa execução que precisa ser executado até a conclusão. Se tu 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 tu estiver trabalhando remotamente em um computador via SSH e não quiser que um processo confidencial seja encerrado se a conexão remota falhar, tu 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, tu não retornará ao prompt de comando. Tudo o que isto nohupfaz é tornar o processo impermeável ao fechamento do terminal. isto não transforma o processo em uma tarefa em segundo plano .
Agora tu precisa reiniciar apenas para encerrar o processo? Não. Para interromper um nohupprocesso que tu 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 ficheiro chamado “nohup.out”. Podemos revisá-lo com menos.
menos nohup.out
Qualquer coisa que normalmente seria enviada para a janela do terminal é capturada no ficheiro. As execuções subsequentes nohupserão anexadas ao ficheiro “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 isto, adicionamos um E comercial ” &” ao final da linha de comando.
nohup ./long-proc &
tu 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 tu 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 tu 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 tu clicar em “Enter”, tu 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, tu 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 tu examinarless o ficheiro “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 ficheiro “nohup.out”. Não está interligado, a saída do segundo processo só começa quando o primeiro processo termina.
Se quiser usar um ficheiro próprio em vez de “nohup.out”, tu pode redirecionar o comando para o ficheiro 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 ficheiro “myfile.txt”.
Podemos olhar dentro do ficheiro “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 utilizadores Linux de hoje em máquinas incrivelmente poderosas.
