Introdução
Neste laboratório, você aprenderá as habilidades essenciais para gerenciar e monitorar processos em um sistema Linux. Você explorará como interagir com processos executados tanto em primeiro plano (foreground) quanto em segundo plano (background), obtendo maior controle sobre o seu ambiente de linha de comando e os recursos do sistema. Essa experiência prática é fundamental para qualquer pessoa que trabalhe com Linux, desde administradores de sistemas até desenvolvedores.
Você começará iniciando um job em segundo plano usando o operador & e visualizando seu status com o comando jobs. Em seguida, inspecionará os processos em execução com o ps, monitorará a atividade do sistema em tempo real com o top e praticará o controle de jobs usando fg, bg e Ctrl-Z. Para concluir o laboratório, você aprenderá como ajustar a prioridade de um processo com o renice e como encerrá-lo usando o comando kill, cobrindo assim todo o ciclo de vida do gerenciamento de processos.
Iniciar e Visualizar um Processo em Segundo Plano com & e jobs
Neste passo, você aprenderá a executar um comando em segundo plano e a verificar o status dos jobs em execução. Em um shell Linux, você normalmente executa um comando e aguarda até que ele seja concluído para que o prompt retorne. Isso é chamado de executar um processo em primeiro plano (foreground). No entanto, para tarefas de longa duração, você pode preferir executá-las em segundo plano (background) para poder continuar usando o terminal para outros comandos.
Para executar um comando em segundo plano, basta adicionar um E comercial (&) no final da linha de comando. Vamos testar isso com o comando sleep, que é um utilitário simples que pausa a execução por um período de tempo especificado.
Execute o comando a seguir para rodar o sleep por 300 segundos em segundo plano. Isso nos permitirá interagir com ele nos próximos passos.
sleep 300 &
Após pressionar Enter, você verá algo semelhante à saída abaixo, e o prompt de comando retornará imediatamente, permitindo que você digite novos comandos.
[1] 12345
O shell iniciou o comando sleep 300 como um job em segundo plano. A saída fornece duas informações principais:
[1]: Este é o ID do job (job ID). O shell atribui um ID de job exclusivo a cada processo em segundo plano.12345: Este é o ID do processo (PID). O sistema operacional atribui um PID exclusivo a cada processo em execução. O seu PID será diferente do exemplo.
Agora que o processo está rodando em segundo plano, como você pode verificar o status dele? Você pode usar o comando jobs, que lista todos os jobs em execução no segundo plano da sessão atual do shell.
Execute o comando jobs no seu terminal:
jobs
A saída mostrará o comando sleep que acabamos de iniciar, juntamente com o seu ID de job e o status atual.
[1]+ Running sleep 300 &
Você iniciou com sucesso um processo em segundo plano e aprendeu a verificar o seu status. Esta é uma habilidade fundamental para gerenciar tarefas de longa duração em um sistema Linux. Nos próximos passos, exploraremos como interagir com esse job em segundo plano.
Inspecionar Processos em Execução com ps
Neste passo, você usará o comando ps para inspecionar os processos em execução. No passo anterior, você usou o comando jobs para ver o processo em segundo plano no seu shell atual. No entanto, o jobs é limitado à sua sessão. O comando ps fornece um panorama mais amplo dos processos no momento exato em que é executado.
Vamos começar executando o ps sem nenhuma opção. Esse comando fornece um panorama dos processos pertencentes ao usuário atual e associados ao terminal atual.
ps
A saída será mínima, mostrando provavelmente apenas o seu shell (zsh) e o comando ps que você acabou de executar. Os PIDs serão diferentes no seu sistema.
PID TTY TIME CMD
23882 pts/0 00:00:00 zsh
23953 pts/0 00:00:00 ps
Para ver todos os processos em execução no sistema, e não apenas os do seu terminal, você pode usar o ps com opções. Uma combinação muito comum e útil é ps aux.
a: mostra os processos de todos os usuários.u: exibe em um formato voltado para o usuário (mostrando usuário, %CPU, %MEM, etc.).x: inclui processos que não estão associados a um terminal.
Uma longa lista de processos não é muito útil se você estiver procurando por algo específico. Podemos combinar o ps com o comando grep para filtrar a saída. Vamos encontrar o processo sleep que você iniciou no passo anterior.
ps aux | grep sleep
Este comando filtra a saída de ps aux e mostra apenas as linhas que contêm a palavra "sleep".
labex 23885 0.0 0.0 7264 868 pts/0 S 11:50 0:00 sleep 300
labex 23962 0.0 0.0 10788 2240 pts/0 S+ 11:52 0:00 grep --color=auto sleep
Você provavelmente verá duas linhas na saída. Uma é o seu processo sleep 300. A outra é o próprio comando grep sleep, que estava em execução no momento em que o ps capturou a lista de processos. Note que o PID do sleep 300 (neste exemplo, 23885) corresponde ao que você viu quando executou o comando em segundo plano pela primeira vez.
Outro formato popular para visualizar processos é ps -ef.
-e: seleciona todos os processos do sistema.-f: exibe uma listagem em formato "completo" (full), que inclui informações úteis como o ID do Processo Pai (PPID).
Vamos testar, usando novamente o grep para encontrar o nosso processo sleep.
ps -ef | grep sleep
O formato de saída é diferente, mas fornece informações semelhantes. Essa visualização é particularmente útil para observar a hierarquia de processos por meio das colunas PID e PPID.
UID PID PPID C STIME TTY TIME CMD
labex 23885 23882 0 11:50 pts/0 00:00:00 sleep 300
labex 23964 23882 0 11:53 pts/0 00:00:00 grep --color=auto sleep
Agora você já sabe como usar o ps para obter um panorama dos processos do sistema. Combinando-o com ferramentas como o grep, você pode encontrar e inspecionar rapidamente processos específicos.
Monitorar Recursos do Sistema com top
Neste passo, você aprenderá a usar o top, uma ferramenta poderosa para o monitoramento do sistema em tempo real. Enquanto o ps fornece um panorama estático dos processos, o top oferece uma visão dinâmica e atualizada continuamente da atividade do sistema, tornando-se inestimável para identificar processos que consomem muitos recursos no momento em que isso acontece.
Para começar, basta digitar top no seu terminal e pressionar Enter.
top
A interface do top ocupará toda a janela do seu terminal. Ela será parecida com a imagem abaixo, com os dados sendo atualizados a cada poucos segundos.
top - 12:05:15 up 15 min, 1 user, load average: 0.00, 0.01, 0.00
Tasks: 115 total, 1 running, 114 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.1 us, 0.1 sy, 0.0 ni, 99.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 1987.2 total, 985.4 free, 501.8 used, 500.0 buff/cache
MiB Swap: 2048.0 total, 2048.0 free, 0.0 used. 1325.4 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 167900 12936 8488 S 0.0 0.6 0:01.15 systemd
2 root 20 0 0 0 0 S 0.0 0.0 0:00.00 kthreadd
...
A interface do top é dividida em duas partes principais:
- A área de resumo na parte superior mostra estatísticas gerais do sistema, como tempo de atividade (uptime), número de tarefas, carga da CPU (
%Cpu(s)) e uso de memória (MiB Mem). - A lista de processos abaixo exibe os processos individuais, ordenados por uso de CPU (
%CPU) por padrão.
O comando top é interativo. Você pode usar várias teclas para alterar o seu comportamento. Vamos testar algumas:
Pressione M (maiúsculo) para ordenar por uso de memória. A lista será reorganizada com base na coluna %MEM, colocando os processos que mais consomem memória no topo.
Pressione P (maiúsculo) para ordenar por uso de CPU. Isso retornará a ordenação da lista para o padrão, baseado na coluna %CPU.
Tente localizar o processo sleep que você iniciou anteriormente. Ele provavelmente estará mais abaixo na lista porque não está usando CPU. Você pode usar as teclas de Seta para Baixo e Seta para Cima para rolar pela lista de processos.
Quando terminar de observar, você pode sair do top a qualquer momento.
Pressione q para sair da interface do top e retornar ao prompt de comando.
Agora você já utilizou o top para obter uma visão em tempo real dos processos e do uso de recursos do seu sistema. Este é um comando essencial para qualquer administrador de sistemas que esteja solucionando problemas de desempenho.
Gerenciar o Controle de Jobs com fg, bg e Ctrl-Z
Neste passo, você aprenderá a gerenciar o estado dos seus jobs em execução. Você já sabe como iniciar um job em segundo plano, mas e se você iniciar um comando de longa duração em primeiro plano e perceber que precisa do terminal de volta? O controle de jobs (job control) permite mover processos entre o primeiro e o segundo plano, além de pausá-los (pará-los) e retomá-los.
Vamos trabalhar com o processo sleep 300 que você iniciou anteriormente. Primeiro, verifique o status dele com o comando jobs para garantir que ainda está em execução.
jobs
Você deve ver o seu job sleep rodando em segundo plano.
[1] + running sleep 300
Agora, vamos trazer este job para o primeiro plano. Para fazer isso, use o comando fg (foreground) seguido pelo ID do job precedido por %. Como o nosso ID de job é 1, o comando é:
fg %1
O shell exibirá o nome do comando com informações adicionais do job, e o seu prompt de comando desaparecerá. O terminal agora está "ocupado" pelo comando sleep 300, aguardando a sua conclusão.
[1] + 394 running sleep 300
Para recuperar o seu terminal sem matar o processo, você pode suspendê-lo. Pressione a combinação de teclas Ctrl-Z (mantenha a tecla Ctrl pressionada e pressione Z).
Essa ação envia um sinal especial (SIGTSTP) para o processo, o que pausa a sua execução. O processo não é encerrado; ele é simplesmente suspenso. Você verá uma mensagem confirmando isso, e o prompt retornará.
[1] + 394 suspended sleep 300
Agora, verifique o status dos seus jobs novamente:
jobs
A saída agora mostra o status do job como "suspended" (suspenso).
[1] + suspended sleep 300
Um job parado pode ser retomado. Você pode retomá-lo em primeiro plano com o fg ou em segundo plano com o bg. Vamos retomá-lo em segundo plano usando o comando bg.
bg %1
O shell confirmará que o job está rodando novamente em segundo plano.
[1] + 394 continued sleep 300
Você pode verificar o status dele uma última vez com o comando jobs para ver que ele voltou a ser "Running" (em execução). Agora você moveu com sucesso um processo do segundo plano para o primeiro plano, o suspendeu e o retomou em segundo plano.
Ajustar a Prioridade do Processo com renice
Neste passo, você aprenderá a influenciar a prioridade de escalonamento de um processo em execução. No Linux, a "educação" (niceness) de um processo determina quanto tempo de CPU ele recebe em relação a outros processos. O valor de nice varia de -20 (maior prioridade) a +19 (menor prioridade). Por padrão, a maioria dos processos começa com um valor de nice igual a 0. Um valor de nice mais alto significa que o processo é mais "educado" com os outros processos, cedendo tempo de CPU com mais facilidade.
Vamos ajustar a prioridade do processo sleep com o qual você tem trabalhado. Para fazer isso, você primeiro precisa do ID do Processo (PID). Você pode encontrá-lo novamente usando o ps e o grep.
ps aux | grep sleep
Procure a linha correspondente ao sleep 300 (e não ao comando grep em si) e anote o seu PID na segunda coluna.
labex 23885 0.0 0.0 7264 868 pts/0 S 11:50 0:00 sleep 300
labex 24101 0.0 0.0 10788 2240 pts/0 S+ 12:15 0:00 grep --color=auto sleep
Neste exemplo, o PID é 23885. Você deve usar o PID da sua própria saída nos comandos a seguir.
Agora, vamos verificar o valor de nice atual (NI) do processo. O comando ps com a opção -o permite especificar colunas de saída personalizadas.
ps -o pid,ni,cmd -p <YOUR_PID>
Substitua <YOUR_PID> pelo PID real do seu processo sleep. Por exemplo: ps -o pid,ni,cmd -p 23885.
PID NI CMD
23885 0 sleep 300
Como esperado, o valor de nice padrão (NI) é 0.
Agora, vamos alterar esse valor usando o comando renice. Vamos aumentar o valor de nice para 10, o que diminuirá a prioridade do processo. Usuários comuns só podem aumentar o valor de nice de seus próprios processos (tornando-os de menor prioridade).
renice -n 10 -p <YOUR_PID>
Novamente, substitua <YOUR_PID> pelo PID do seu processo. O comando informará a prioridade antiga e a nova.
23885 (process ID) old priority 0, new priority 10
Finalmente, verifique se a alteração surtiu efeito executando o comando ps novamente:
ps -o pid,ni,cmd -p <YOUR_PID>
A saída agora deve mostrar o novo valor de nice.
PID NI CMD
23885 10 sleep 300
Você alterou com sucesso a prioridade de um processo em execução. Essa é uma técnica útil para garantir que tarefas de segundo plano de longa duração e não críticas não interfiram em trabalhos mais importantes em primeiro plano.
Encerrar um Processo com kill
Neste passo, você aprenderá a encerrar um processo. Embora alguns processos sejam concluídos por conta própria, muitas vezes você precisará parar manualmente um processo que não é mais necessário, que está se comportando mal ou que foi iniciado para fins temporários, como o nosso comando sleep. A ferramenta principal para isso é o comando kill.
O comando kill envia um sinal para um processo especificado. Por padrão, ele envia o sinal SIGTERM (terminate), que pede educadamente para o processo ser encerrado, permitindo que ele execute quaisquer operações de limpeza antes de sair.
Você pode direcionar um processo usando o seu ID de Processo (PID) ou, no caso de jobs em segundo plano no seu shell atual, o ID do job. Usar o ID do job costuma ser mais conveniente.
Primeiro, vamos confirmar se o nosso job sleep ainda está em execução.
jobs
Você deve ver o processo sleep listado.
[1]+ Running sleep 300 &
Agora, use o comando kill com o ID do job (%1) para encerrá-lo.
kill %1
Após executar o comando, o shell provavelmente imprimirá uma mensagem no terminal indicando que o job foi encerrado. Essa mensagem pode aparecer imediatamente ou após você pressionar Enter novamente.
[1]+ Terminated sleep 300
Vamos verificar se o processo realmente desapareceu. Execute o comando jobs novamente.
jobs
O comando agora não deve produzir nenhuma saída, pois não há mais jobs ativos nesta sessão do shell. Você também pode usar o ps para confirmar.
ps aux | grep sleep
A única linha que você poderá ver é o próprio comando grep sleep. O processo original sleep 300 não está mais em execução.
Nos casos em que um processo não responde e não reage ao sinal padrão SIGTERM, você pode enviar um sinal mais enérgico, o SIGKILL (sinal número 9), que encerra o processo imediatamente sem dar a ele a chance de realizar a limpeza. O comando seria kill -9 %1. Isso deve ser usado apenas como último recurso.
Parabéns! Agora você praticou todo o ciclo de vida do gerenciamento básico de processos no Linux: iniciar um processo em segundo plano, inspecioná-lo com ps e top, gerenciá-lo com o controle de jobs, ajustar sua prioridade e, finalmente, encerrá-lo.
Resumo
Neste laboratório, você aprendeu as habilidades fundamentais para gerenciar e monitorar processos em um ambiente Linux. Você começou executando um processo em segundo plano usando o operador & e visualizou o seu status com o comando jobs. Em seguida, explorou como inspecionar todos os processos em execução com o ps para encontrar detalhes como o ID do Processo (PID) e como usar o top para o monitoramento em tempo real do uso de recursos do sistema e dos processos ativos.
Além disso, você praticou o controle de jobs suspendendo um processo em primeiro plano com Ctrl-Z, movendo-o para o segundo plano com bg e trazendo-o de volta para o primeiro plano com fg. Você também aprendeu como ajustar a prioridade de escalonamento de um processo usando o renice e como encerrar um processo de forma limpa usando o comando kill junto com o seu PID.
