Gerenciar e Monitorar Processos no Linux

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 em execução tanto em primeiro plano (foreground) quanto em segundo plano (background), garantindo maior controle sobre seu ambiente de linha de comando e recursos do sistema. Esta experiência prática é fundamental para qualquer pessoa que trabalhe com Linux, desde administradores de sistemas até desenvolvedores.

Você começará iniciando uma tarefa em segundo plano usando o operador & e visualizando seu status com jobs. Em seguida, inspecionará os processos em execução com ps, monitorará a atividade do sistema em tempo real com top e praticará o controle de tarefas usando fg, bg e Ctrl-Z. Para concluir o laboratório, você aprenderá como ajustar a prioridade de um processo com renice e como encerrá-lo usando o comando kill, cobrindo todo o ciclo de vida do gerenciamento de processos.

Iniciar e Visualizar um Processo em Segundo Plano com `&` e `jobs`

Nesta etapa, você aprenderá como executar um comando em segundo plano e como visualizar o status das tarefas em segundo plano. Em um shell Linux, você normalmente executa um comando e espera que ele termine antes que o prompt retorne. Isso é chamado de executar um processo em primeiro plano. No entanto, para tarefas de longa duração, você pode querer executá-las em segundo plano para continuar usando seu terminal para outros comandos.

Para executar um comando em segundo plano, basta adicionar um e comercial (&) ao final da linha de comando. Vamos tentar isso com o comando sleep, que é um utilitário simples que faz uma pausa por um período de tempo especificado.

Execute o seguinte comando para rodar o sleep por 300 segundos em segundo plano. Isso nos permitirá trabalhar com ele nas próximas etapas.

sleep 300 &

Depois de pressionar Enter, você verá algo semelhante à seguinte saída, e o prompt de comando retornará imediatamente, permitindo que você digite novos comandos.

[1] 12345

O shell iniciou o comando sleep 300 como uma tarefa de segundo plano. A saída fornece duas informações principais:

[1]: Este é o ID da tarefa (job ID). O shell atribui um ID de tarefa exclusivo para 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 todas as tarefas 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, junto com seu ID de tarefa e status atual.

[1]+  Running                 sleep 300 &

Você iniciou com sucesso um processo em segundo plano e sabe como verificar seu status. Esta é uma habilidade fundamental para gerenciar tarefas longas em um sistema Linux. Nas etapas seguintes, exploraremos como interagir com essa tarefa de segundo plano.

Inspecionar Processos em Execução com `ps`

Na etapa 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. Para obter uma visão mais ampla de todos os processos em execução no sistema, você precisa de uma ferramenta mais poderosa: ps (process status). O comando ps fornece um instantâneo dos processos atuais no momento em que você o executa.

Vamos começar executando o ps sem nenhuma opção. Este comando fornece um resumo dos processos pertencentes ao usuário atual e vinculados ao terminal atual.

ps

A saída será mínima, provavelmente mostrando 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, 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 processos de todos os usuários.
u: exibe em um formato orientado ao usuário (mostrando usuário, % de CPU, % de memória, etc.).
x: inclui processos não vinculados a um terminal.

Uma lista longa 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 na etapa anterior.

ps aux | grep sleep

Este comando filtra a saída do 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 rodando no momento em que o ps capturou a lista de processos. Observe que o PID do sleep 300 (neste exemplo, 23885) corresponde ao que você viu quando executou o comando pela primeira vez em segundo plano.

Outro formato popular para visualizar processos é o ps -ef.

-e: seleciona todos os processos no sistema.
-f: exibe uma listagem em formato "completo", que inclui informações úteis como o ID do Processo Pai (PPID).

Vamos tentar, usando novamente o grep para encontrar nosso processo sleep.

ps -ef | grep sleep

O formato de saída é diferente, mas fornece informações semelhantes. Esta visualização é particularmente útil para ver a hierarquia de processos através 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

Você viu agora como usar o ps para obter um instantâneo dos processos do sistema. Ao combiná-lo com ferramentas como o grep, você pode encontrar e inspecionar processos específicos rapidamente.

Monitorar Recursos do Sistema com `top`

Nesta etapa, você aprenderá a usar o top, uma ferramenta poderosa para monitoramento do sistema em tempo real. Enquanto o ps fornece um instantâneo estático, o top oferece uma visão dinâmica e continuamente atualizada da atividade do sistema, sendo inestimável para identificar processos que consomem muitos recursos no momento em que isso ocorre.

Para começar, basta digitar top no seu terminal e pressionar Enter.

top

Toda a janela do seu terminal será ocupada pela interface do top. Ela será parecida com isto, 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 no topo mostra estatísticas de todo o 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 mostra processos individuais, ordenados por padrão pelo uso da CPU (%CPU).

O comando top é interativo. Você pode usar várias teclas para alterar seu comportamento. Vamos tentar algumas:

Ordenar por Uso de Memória: Pressione M (maiúsculo). A lista será reordenada com base na coluna %MEM, mostrando os processos que mais consomem memória no topo.
Ordenar por Uso de CPU: Pressione P (maiúsculo). Isso fará com que a lista volte à ordenação padrão, pela coluna %CPU.
Encontrar seu processo sleep: Você pode tentar localizar o processo sleep que iniciou anteriormente. Ele provavelmente estará no final da lista, pois não está usando CPU. Você pode usar as teclas 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.

Sair do top: Pressione q para fechar a interface do top e retornar ao prompt de comando.

Você usou o top para obter uma visão em tempo real dos processos e do uso de recursos do seu sistema. Este é o comando essencial para qualquer administrador de sistemas que esteja diagnosticando problemas de desempenho.

Gerenciar o Controle de Tarefas com `fg`, `bg` e Ctrl-Z

Nesta etapa, você aprenderá como gerenciar o estado das suas tarefas em execução. Você já sabe como iniciar uma tarefa em segundo plano, mas e se você iniciar um comando demorado em primeiro plano e perceber que precisa do terminal de volta? O controle de tarefas permite mover processos entre o primeiro e o segundo plano, além de pausá-los (parar) 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á rodando.

jobs

Você deve ver sua tarefa sleep rodando em segundo plano.

[1]  + running    sleep 300

Agora, vamos trazer essa tarefa para o primeiro plano. Para fazer isso, use o comando fg (foreground) seguido pelo ID da tarefa precedido por um %. Como o nosso ID de tarefa é 1, o comando é:

fg %1

O shell exibirá o nome do comando com informações adicionais da tarefa, e seu prompt de comando desaparecerá. O terminal agora está "ocupado" pelo comando sleep 300, esperando que ele termine.

[1]  + 394 running    sleep 300

Para recuperar seu terminal sem encerrar o processo, você pode pará-lo. Pressione a combinação de teclas Ctrl-Z (mantenha pressionada a tecla Ctrl e pressione Z).

Esta ação envia um sinal especial (SIGTSTP) ao processo, que pausa sua execução. O processo não é encerrado; ele é apenas suspenso. Você verá uma mensagem confirmando isso e seu prompt retornará.

[1]  + 394 suspended  sleep 300

Agora, verifique o status das suas tarefas novamente:

jobs

A saída agora mostra o status da tarefa como "suspended" (suspensa).

[1]  + suspended  sleep 300

Uma tarefa parada pode ser retomada. Você pode retomá-la em primeiro plano com fg ou em segundo plano com bg. Vamos retomá-la em segundo plano usando o comando bg.

bg %1

O shell confirmará que a tarefa está rodando em segundo plano novamente.

[1]  + 394 continued  sleep 300

Você pode verificar o status uma última vez com jobs para ver que ela voltou para "Running". Você moveu com sucesso um processo do segundo plano para o primeiro plano, parou-o e o retomou no segundo plano.

Ajustar a Prioridade do Processo com `renice`

Nesta etapa, você aprenderá como influenciar a prioridade de agendamento de um processo em execução. No Linux, a "gentileza" (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 0. Um valor de nice mais alto significa que o processo é mais "gentil" com os outros, cedendo tempo de CPU mais facilmente.

Ajustaremos a prioridade do processo sleep com o qual você tem trabalhado. Para fazer isso, primeiro você precisa do ID do Processo (PID). Você pode encontrá-lo novamente usando ps e grep.

ps aux | grep sleep

Procure a linha correspondente ao sleep 300 (não o comando grep em si) e anote o 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 atual de nice (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   5 sleep 300

Como esperado, o valor padrão de nice (NI) é 5.

Agora, vamos alterar esse valor usando o comando renice. Aumentaremos 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 5, new priority 10

Por fim, verifique se a alteração entrou em vigor executando o comando ps novamente:

ps -o pid,ni,cmd -p <YOUR_PID>

A saída deve mostrar agora o novo valor de nice.

    PID  NI CMD
  23885  10 sleep 300

Você alterou com sucesso a prioridade de um processo em execução. Esta é uma técnica útil para garantir que tarefas de segundo plano longas e não críticas não interfiram em trabalhos de primeiro plano mais importantes.

Encerrar um Processo com `kill`

Nesta etapa final, você aprenderá como encerrar um processo. Embora alguns processos terminem sozinhos, 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 principal ferramenta para isso é o comando kill.

O comando kill envia um sinal a um processo específico. Por padrão, ele envia o sinal SIGTERM (terminar), que solicita educadamente que o processo seja encerrado, permitindo que ele realize operações de limpeza antes de sair.

Você pode atingir um processo usando o seu ID de Processo (PID) ou, para tarefas em segundo plano no seu shell atual, o seu ID de tarefa. Usar o ID da tarefa costuma ser mais conveniente.

Primeiro, vamos confirmar que nossa tarefa sleep ainda está rodando.

jobs

Você deve ver o processo sleep listado.

[1]+  Running                 sleep 300 &

Agora, use o comando kill com o ID da tarefa (%1) para encerrá-lo.

kill %1

Depois de executar o comando, o shell provavelmente imprimirá uma mensagem no terminal indicando que a tarefa foi encerrada. Esta 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 tarefas ativas nesta sessão do shell. Você também pode usar o ps para conferir.

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.

Em casos onde um processo não responde e não reage ao sinal padrão SIGTERM, você pode enviar um sinal mais forte, o SIGKILL (sinal número 9), que encerra o processo imediatamente sem dar a ele a chance de limpeza. O comando seria kill -9 %1. Isso deve ser usado apenas como último recurso.

Parabéns! Você praticou o ciclo de vida completo do gerenciamento básico de processos no Linux: iniciar um processo em segundo plano, inspecioná-lo com ps e top, gerenciá-lo com controle de tarefas, 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 seu status com o comando jobs. Em seguida, explorou como inspecionar todos os processos em execução com ps para encontrar detalhes como o ID do Processo (PID), e como usar o top para monitoramento em tempo real do uso de recursos do sistema e processos ativos.

Além disso, você praticou o controle de tarefas suspendendo um processo de 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 agendamento de um processo usando renice e como encerrar um processo de forma adequada usando o comando kill com seu PID.