Monitorar Processos no Red Hat Enterprise Linux

Introdução

Neste laboratório, você ganhará experiência prática no monitoramento e gerenciamento de processos Linux, uma habilidade fundamental para qualquer administrador de sistema ou desenvolvedor. Você aprenderá a compreender os estados e ciclos de vida dos processos usando ps e top, controlar tarefas em segundo plano e em primeiro plano, e finalizar processos eficazmente com kill, killall e pkill. Além disso, você explorará como monitorar a carga do sistema e o uso da CPU usando uptime e lscpu, e analisará a atividade dos processos em detalhes com top. Este laboratório o equipará com as ferramentas e conhecimentos essenciais para gerenciar processos de forma eficiente e manter a saúde do sistema no RHEL.

Compreender Estados e Ciclo de Vida de Processos com ps e top

Neste passo, você aprenderá sobre os estados dos processos Linux e seus ciclos de vida. Compreender os estados dos processos é crucial para monitorar e gerenciar os recursos do sistema de forma eficaz. Você utilizará os comandos ps e top para observar os processos e seus estados.

Cada processo no Linux possui um estado que descreve sua atividade atual. Esses estados são definidos pelo kernel e indicam se um processo está em execução, em espera, parado ou em outras condições.

Vamos começar examinando os estados dos processos usando o comando ps. O comando ps reporta um instantâneo dos processos atuais.

Primeiro, abra seu terminal. Você pode fazer isso clicando no ícone do terminal na área de trabalho ou pressionando Ctrl+Alt+T. Seu diretório de trabalho padrão é ~/project.

Para ver todos os processos em execução no seu sistema, incluindo aqueles sem um terminal de controle, use o comando ps aux. As opções aux exibem os processos pertencentes a todos os usuários (a), processos sem um terminal de controle (x) e mostram um formato orientado ao usuário (u).

ps aux

Você verá uma longa lista de processos. Preste atenção à coluna STAT, que mostra o estado de cada processo. Estados comuns que você pode observar incluem:

R: Em execução ou pronto (na CPU ou aguardando execução)
S: Sono interrompível (aguardando o término de um evento)
D: Sono ininterrupível (aguardando E/S, não pode ser interrompido)
T: Parado (suspenso por um sinal)
Z: Zumbi (processo terminado, mas o processo pai não recolheu seu status de saída)

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.2 171820 16140 ?        Ss   HH:MM   0:01 /usr/lib/systemd/systemd ...
root           2  0.0  0.0      0     0 ?        S    HH:MM   0:00 [kthreadd]
labex       3448  0.0  0.2 266904  3836 pts/0    R+   HH:MM   0:00 ps aux
...output omitted...

Em seguida, vamos usar o comando ps -ef. Este comando fornece uma lista completa (f) de todos os processos (e), mostrando mais detalhes como o ID do processo pai (PPID), utilização da CPU (C), hora de início (STIME) e o comando (CMD).

ps -ef

Esta saída é frequentemente usada para ver as relações pai-filho entre os processos, embora não mostre explicitamente uma estrutura de árvore.

UID        PID  PPID  C STIME TTY          TIME CMD
root           1       0  0 HH:MM ?        00:00:01 /usr/lib/systemd/systemd ...
root           2       0  0 HH:MM ?        00:00:00 [kthreadd]
root           3       2  0 HH:MM ?        00:00:00 [rcu_gp]
...output omitted...

Para visualizar a hierarquia de processos, você pode usar a opção ps --forest. Isso exibe os processos em um formato de árvore, facilitando a compreensão de quais processos geraram outros.

ps --forest

Este comando é particularmente útil para depuração e compreensão de como diferentes serviços e aplicativos são estruturados no seu sistema.

  PID TTY          TIME CMD
 2768 pts/0    00:00:00 bash
 5947 pts/0    00:00:00  \_ sleep 10000
 6377 pts/0    00:00:00  \_ ps --forest
...output omitted...

Agora, vamos explorar o comando top, que fornece uma visualização dinâmica em tempo real de um sistema em execução. Ele exibe um resumo das informações do sistema e uma lista de processos ou threads atualmente gerenciados pelo kernel Linux.

Execute o comando top:

top

Você verá uma exibição interativa. A seção superior fornece informações resumidas do sistema, incluindo tempo de atividade, média de carga, resumo de tarefas, estatísticas da CPU e uso de memória. A seção inferior lista os processos individuais, ordenados por uso de CPU por padrão.

Na saída do top, observe a coluna S para os estados dos processos, semelhante ao ps. Você também pode ver %CPU (porcentagem de uso da CPU) e %MEM (porcentagem de uso de memória) para cada processo.

top - HH:MM:SS up DD min,  X users,  load average: X.XX, X.XX, X.XX
Tasks: XXX total,   X running, XXX sleeping,   X stopped,   X zombie
%Cpu(s):  X.X us,  X.X sy,  X.X ni, XX.X id,  X.X wa,  X.X hi,  X.X si,  X.X st
MiB Mem :   XXXX.X total,   XXXX.X free,    XXX.X used,    XXX.X buff/cache
MiB Swap:   XXXX.X total,   XXXX.X free,      X.X used.   XXXX.X avail Mem

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
XXXX labex     20   0  XXXXXX   XXXX   XXXX R   X.X   X.X   0:00.0X top
...output omitted...

Enquanto o top estiver em execução, você pode pressionar q para sair e retornar ao prompt do seu terminal.

Compreender esses comandos e as informações que eles fornecem é fundamental para monitorar e solucionar problemas de processos em um sistema Linux.

Controlar Tarefas em Segundo e Primeiro Plano

Neste passo, você aprenderá como gerenciar tarefas em segundo e primeiro plano dentro da sua sessão de shell. Esta é uma habilidade fundamental para um uso eficiente do terminal, permitindo que você execute tarefas demoradas sem bloquear o terminal.

Uma "tarefa" no contexto de um shell refere-se a um comando ou um pipeline de comandos que o shell está gerenciando. Você pode executar tarefas em segundo plano, trazê-las para o primeiro plano ou suspendê-las.

Vamos começar executando um comando simples em segundo plano. Usaremos o comando sleep, que simplesmente espera por um período de tempo especificado.

Para executar sleep 10000 (que espera por 10000 segundos) em segundo plano, adicione um caractere de ampersand (&) ao comando:

sleep 10000 &

Ao pressionar Enter, o shell retornará imediatamente ao prompt, e o comando sleep estará em execução em segundo plano. Você verá uma saída semelhante a esta, indicando o número da tarefa e seu Process ID (PID):

[1] 5947

O [1] indica que esta é a tarefa número 1 na sua sessão de shell atual, e 5947 é o PID do processo sleep.

Para visualizar uma lista de todas as tarefas gerenciadas pelo seu shell, use o comando jobs:

jobs

Você deve ver o comando sleep listado como uma tarefa em segundo plano em execução:

[1]+ Running    sleep 10000 &

O + ao lado de [1] indica que esta é a tarefa atual (a que seria acionada por padrão se você não especificasse um número de tarefa).

Agora, vamos trazer esta tarefa em segundo plano para o primeiro plano. Isso significa que a tarefa assumirá o controle do seu terminal novamente. Use o comando fg seguido do número da tarefa (prefixado com %):

fg %1

O comando sleep 10000 agora estará em primeiro plano. Seu terminal ficará ocupado por este comando, e você não receberá um prompt até que ele termine ou seja suspenso.

sleep 10000

Enquanto um comando está em execução em primeiro plano, você pode enviá-lo para o segundo plano e suspendê-lo pressionando Ctrl+Z. Isso envia um sinal SIGTSTP para o processo.

Pressione Ctrl+Z agora:

^Z

Você verá uma saída indicando que a tarefa foi interrompida e movida para o segundo plano:

[1]+  Stopped                 sleep 10000

Agora, se você executar jobs novamente, verá que o comando sleep está no estado Parado:

jobs

[1]+ Stopped                 sleep 10000

Para retomar uma tarefa em segundo plano parada, você pode usar o comando bg seguido do número da tarefa. Isso reiniciará a tarefa em segundo plano.

bg %1

A tarefa agora estará em execução em segundo plano novamente:

[1]+ sleep 10000 &

Finalmente, vamos limpar a tarefa em segundo plano. Você pode encerrar uma tarefa em segundo plano usando o comando kill com seu PID, ou trazendo-a para o primeiro plano e, em seguida, encerrando-a (por exemplo, com Ctrl+C). Por enquanto, vamos trazê-la para o primeiro plano e encerrá-la.

fg %1

Agora que sleep 10000 está em primeiro plano, pressione Ctrl+C para encerrá-lo. Isso envia um sinal SIGINT para o processo.

^C

Você verá uma mensagem indicando que a tarefa foi encerrada:

[1]+  Terminated              sleep 10000

Se você executar jobs novamente, deverá ver que não há mais tarefas listadas:

jobs

(sem saída)

Isso demonstra o fluxo de trabalho básico de gerenciamento de tarefas em segundo e primeiro plano, essencial para a multitarefa no terminal.

Terminar Processos com kill, killall e pkill

Neste passo, você aprenderá como terminar processos usando os comandos kill, killall e pkill. Esses comandos são essenciais para gerenciar recursos do sistema e interromper aplicativos com comportamento inadequado.

Processos no Linux respondem a sinais. Um sinal é uma interrupção de software entregue a um processo. Diferentes sinais têm significados diferentes, como terminar um processo, suspendê-lo ou fazer com que ele recarregue sua configuração.

Primeiro, vamos entender alguns sinais fundamentais de gerenciamento de processos:

SIGTERM (15): O sinal padrão enviado por kill. É um pedido "educado" para terminar. O processo pode capturar esse sinal, fazer a limpeza e, em seguida, sair.
SIGKILL (9): Um sinal "imbloqueável" que força o término imediato. O processo não pode ignorar ou manipular esse sinal. Use-o como último recurso.
SIGHUP (1): Frequentemente usado para instruir um processo a recarregar seus arquivos de configuração sem reiniciar.
SIGINT (2): Enviado ao pressionar Ctrl+C, normalmente usado para interromper um processo em primeiro plano.
SIGSTOP (19): Suspende um processo. Não pode ser bloqueado ou manipulado.
SIGCONT (18): Retoma um processo parado.

Você pode listar todos os sinais disponíveis e seus números usando kill -l:

kill -l

Você verá uma lista de sinais como esta:

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
...output omitted...

Usando `kill`

O comando kill envia um sinal especificado para um processo identificado por seu Process ID (PID).

Vamos criar alguns processos em segundo plano para praticar o término deles. Usaremos comandos sleep novamente.

sleep 300 &
sleep 301 &
sleep 302 &

Agora, use jobs para ver seus números de tarefa e PIDs:

jobs

[1] 1234
[2] 1235
[3] 1236

(Observação: seus PIDs serão diferentes.)

Vamos encontrar o PID do primeiro processo sleep. Você pode usar ps aux | grep sleep e procurar o PID associado a sleep 300.

ps aux | grep sleep

Você verá uma saída semelhante a esta. Identifique o PID para sleep 300. Por exemplo, se o PID for 1234:

labex       1234  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 300
labex       1235  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 301
labex       1236  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 302
labex       1237  0.0  0.0   6000  1000 pts/0    S+   HH:MM   0:00 grep sleep

Para terminar sleep 300 usando o sinal padrão SIGTERM, use kill seguido de seu PID. Substitua 1234 pelo PID real que você encontrou:

kill 1234

Você pode ver uma mensagem como [1]+ Terminated sleep 300. Verifique se ele desapareceu usando jobs ou ps aux | grep sleep:

jobs

[2]- Running    sleep 301 &
[3]+ Running    sleep 302 &

Agora, vamos terminar sleep 301 com força usando SIGKILL. Encontre seu PID (por exemplo, 1235) e use kill -9 ou kill -SIGKILL:

kill -9 1235

Você provavelmente verá [2]- Killed sleep 301. Verifique novamente:

jobs

[3]+ Running    sleep 302 &

(e assim por diante...)

(O restante da documentação segue...)

Monitorar Carga do Sistema e Uso da CPU com uptime e lscpu

Neste passo, você aprenderá como monitorar a carga média do sistema e o uso da CPU usando os comandos uptime e lscpu. Compreender essas métricas é crucial para avaliar o desempenho do sistema e identificar gargalos potenciais.

Compreendendo a Carga Média com `uptime`

O comando uptime fornece uma visão geral rápida de quanto tempo o seu sistema está em execução, quantos usuários estão conectados e, o mais importante, a carga média do sistema. A carga média indica o número médio de processos que estão em estado executável ou ininterrupto durante um período de tempo.

Execute o comando uptime:

uptime

Você verá uma saída semelhante a esta:

 HH:MM:SS up DD min,  X users,  load average: X.XX, X.XX, X.XX

Vamos analisar a saída:

HH:MM:SS: A hora atual.
up DD min: Quanto tempo o sistema está em execução (tempo de atividade).
X users: O número de usuários conectados atualmente.
load average: X.XX, X.XX, X.XX: Esses três números representam a carga média do sistema nos últimos 1, 5 e 15 minutos, respectivamente.

Uma carga média de 1.00 em uma CPU de um único núcleo significa que a CPU está totalmente utilizada. Em uma CPU multi-núcleo, uma carga média igual ao número de núcleos de CPU significa que o sistema está totalmente utilizado. Por exemplo, em uma CPU de 4 núcleos, uma carga média de 4.00 indica utilização total. Se a carga média exceder consistentemente o número de núcleos de CPU, isso sugere que o seu sistema está sobrecarregado e os processos estão aguardando tempo de CPU.

Determinando os Núcleos da CPU com `lscpu`

Para interpretar corretamente a carga média, você precisa saber quantos núcleos lógicos de CPU o seu sistema possui. O comando lscpu fornece informações detalhadas sobre a arquitetura da CPU.

Execute o comando lscpu:

lscpu

Você verá uma saída extensa. Procure a linha CPU(s):, que indica o número total de CPUs lógicas disponíveis. Além disso, Core(s) per socket: e Socket(s): podem ajudar a entender o layout físico.

Architecture:        x86_64
CPU op-mode(s):      32-bit, 64-bit
Byte Order:          Little Endian
CPU(s):              4
On-line CPU(s) list: 0-3
Thread(s) per core:  2
Core(s) per socket:  2
Socket(s):           1
NUMA node(s):        1
...output omitted...

No exemplo acima, CPU(s): 4 indica que este sistema possui 4 núcleos de CPU lógicos.

Interpretando a Carga Média e os Núcleos da CPU

Vamos combinar as informações de uptime e lscpu. Suponha que sua saída uptime mostre uma carga média de 2.92, 4.48, 5.20 e lscpu mostre CPU(s): 4.

Para obter a carga média por CPU, divida cada número de carga média pelo número total de CPUs lógicas:

Últimos 1 minuto: 2.92 / 4 = 0.73
Últimos 5 minutos: 4.48 / 4 = 1.12
Últimos 15 minutos: 5.20 / 4 = 1.30

Com base nesses cálculos:

Nos últimos 1 minuto, as CPUs foram utilizadas em cerca de 73% de sua capacidade.
Nos últimos 5 minutos, o sistema estava sobrecarregado em cerca de 12% (1.12 - 1.00 = 0.12). Isso significa que os processos estavam aguardando tempo de CPU.
Nos últimos 15 minutos, o sistema estava sobrecarregado em cerca de 30% (1.30 - 1.00 = 0.30).

Esta análise sugere que o sistema estava sob carga significativa nos últimos 5 e 15 minutos, mas a carga diminuiu no último minuto. Este tipo de análise de tendência é crucial para entender a saúde do sistema.

Esses dois comandos, uptime e lscpu, são ferramentas simples, mas poderosas, para avaliar rapidamente a saúde geral e o desempenho do seu sistema Linux.

Analisar a Atividade de Processos com top

Neste passo, você aprofundará o uso do comando top para analisar a atividade dos processos. Embora o top forneça uma visão em tempo real, também oferece recursos interativos poderosos para ordenar, filtrar e gerenciar processos.

Lembre-se de que, em um passo anterior, o top fornece uma visão dinâmica do seu sistema. Vamos iniciar o top novamente:

top

Você verá a interface familiar do top. A seção superior fornece estatísticas do sistema como um todo, e a seção inferior lista os processos.

Compreendendo as Colunas do `top`

Vamos revisar as colunas padrão na lista de processos:

PID: ID do processo.
USER: O proprietário do processo.
PR: Prioridade do processo.
NI: Valor Nice do processo (valor Nice menor significa prioridade maior).
VIRT: Memória virtual usada pelo processo.
RES: Memória residente (RAM física) usada pelo processo.
SHR: Memória compartilhada usada pelo processo.
S: Estado do processo (R=Executando, S=Dormindo, D=Dormindo Ininterrupto, T=Parado, Z=Zombie).
%CPU: Porcentagem de uso da CPU desde a última atualização.
%MEM: Porcentagem de uso de memória (RES / memória física total).
TIME+: Tempo total de CPU usado pelo processo desde seu início.
COMMAND: O nome do comando que iniciou o processo.

Teclas Interativas no `top`

O top é altamente interativo. Você pode pressionar várias teclas para alterar sua exibição e interagir com os processos.

Ordenando Processos:
- Pressione Shift+P (P maiúsculo) para ordenar os processos por uso de CPU (%CPU), que geralmente é o padrão.
- Pressione Shift+M (M maiúsculo) para ordenar os processos por uso de memória (%MEM).
- Pressione Shift+T (T maiúsculo) para ordenar os processos por TIME+.
Experimente pressionar Shift+M agora para ordenar por uso de memória. Observe como a lista de processos é reorganizada. Em seguida, pressione Shift+P para retornar à ordenação por CPU.
Filtrando por Usuário:
- Pressione u (u minúsculo). O top solicitará um nome de usuário. Digite labex e pressione Enter.
- Agora, o top exibirá apenas os processos pertencentes ao usuário labex. Isso é muito útil para se concentrar em seus próprios processos.
- Para limpar o filtro e mostrar todos os usuários novamente, pressione u e, em seguida, pressione Enter sem digitar um nome de usuário.
Alterando o Intervalo de Atualização:
- Por padrão, o top se atualiza a cada 3 segundos. Você pode alterar esse intervalo.
- Pressione s (s minúsculo). O top solicitará um tempo de atraso. Digite 1 (para 1 segundo) e pressione Enter.
- Observe como a exibição se atualiza com mais frequência.
- Você pode alterá-lo de volta para 3 segundos pressionando s novamente e digitando 3.
Matando um Processo:
- Você pode terminar um processo diretamente do top.
- Primeiro, vamos criar um processo sleep em segundo plano em um novo terminal ou janela, ou pressionando Ctrl+Z no terminal atual, depois bg para colocar o top em segundo plano, depois execute sleep 600 &, depois fg para trazer o top de volta ao primeiro plano.
- Alternativamente, você pode abrir um novo terminal (por exemplo, Ctrl+Shift+T em muitos terminais) e executar sleep 600 & lá.
- Depois de ter um processo sleep em execução, volte ao seu terminal top.
- Pressione k (k minúsculo). O top solicitará o PID do processo a ser morto.
- Encontre o PID do seu processo sleep 600 na lista do top. Digite esse PID e pressione Enter.
- O top solicitará o sinal a ser enviado. O padrão é 15 (SIGTERM). Pressione Enter para enviar SIGTERM.
- O processo sleep deve desaparecer da lista. Se não, você pode tentar k novamente e enviar o sinal 9 (SIGKILL).
Alterando a Prioridade de um Processo (Renicing):
- Alterar a prioridade de um processo. Um valor Nice menor significa prioridade maior.
- Pressione r (r minúsculo). O top solicitará um PID e, em seguida, um valor Nice (por exemplo, -10 para prioridade maior, 10 para prioridade menor).
- Este é um recurso avançado para gerenciar recursos do sistema. Para este laboratório, simplesmente pressione r, depois Enter duas vezes para cancelar a operação sem alterar nada.
Saindo do top:
- Quando terminar, pressione q (q minúsculo) para sair do top e retornar ao prompt do seu terminal.

O top é uma ferramenta indispensável para administradores e usuários de sistema. Dominar seus recursos interativos permite um diagnóstico rápido e eficaz de problemas de desempenho do sistema e gerenciamento de processos.

Resumo

Neste laboratório, você aprendeu conceitos fundamentais de gerenciamento de processos Linux. Iniciou compreendendo os estados dos processos e seu ciclo de vida usando os comandos ps e top, observando como os processos transitam entre estados como Executando (R), Dormindo Interrompível (S) e Parado (T). Você praticou identificar estados comuns de processos e interpretar a saída de ps aux e ps -ef para obter insights sobre os processos do sistema.

Além disso, explorou métodos para controlar tarefas em segundo plano e em primeiro plano, o que é crucial para o uso eficiente do terminal. Você também dominou a terminação de processos usando vários comandos, como kill, killall e pkill, compreendendo suas diferentes aplicações para terminação suave ou forçada. Finalmente, aprendeu a monitorar a carga do sistema e o uso da CPU com uptime e lscpu, e a analisar a atividade detalhada dos processos usando top, fornecendo uma visão abrangente do desempenho do sistema e da utilização de recursos.