Nesta aula, vamos explorar os fundamentos do gerenciamento de processos e serviços em sistemas Linux, com foco em ferramentas e conceitos essenciais para profissionais de DevOps. Compreender como processos são criados, gerenciados e monitorados é crucial para manter a estabilidade e o desempenho de ambientes de produção.

Abordaremos desde comandos clássicos como ps e kill até o moderno sistema de init systemd, que gerencia serviços, logs e dependências. Também veremos como consultar logs com journalctl e monitorar recursos com top e htop. Ao final, você terá uma base sólida para administrar processos e serviços no dia a dia.

Gerenciamento de processos

Processos são instâncias de programas em execução. Cada processo possui um identificador único (PID) e pode estar em diferentes estados (executando, dormindo, parado, zumbi). O Linux oferece comandos poderosos para listar, inspecionar e controlar processos.

O comando ps é a ferramenta mais comum para listar processos. Com opções como aux (todos os processos do sistema) ou ef (formato padrão), você obtém detalhes como PID, usuário, uso de CPU e memória. O comando top fornece uma visão dinâmica e interativa dos processos em tempo real. Para finalizar um processo, use kill com o PID ou pkill com o nome.

# Listar todos os processos do sistema
ps aux

# Listar processos de um usuário específico
ps -u joao

# Visualizar processos em tempo real
top

# Finalizar um processo pelo PID
kill 1234

# Finalizar todos os processos com um nome
pkill firefox

É importante entender a hierarquia de processos: cada processo (exceto o init) tem um processo pai (PPID). O comando pstree exibe essa árvore de forma visual. Além disso, processos podem ser executados em background com & ou gerenciados com jobs, bg e fg.

# Exibir árvore de processos
pstree

# Executar um comando em background
sleep 100 &

# Listar jobs do shell atual
jobs

# Trazer um job para foreground
fg %1

systemd (visão geral)

systemd é o sistema de init e gerenciador de serviços padrão na maioria das distribuições Linux modernas. Ele substitui o antigo SysV init e oferece inicialização paralela, dependências entre serviços, gerenciamento de logs e muito mais. Os serviços são definidos por units, arquivos de configuração que descrevem como iniciar, parar e reiniciar um serviço.

Com systemd, você usa o comando systemctl para gerenciar serviços: start, stop, restart, enable (iniciar na boot) e disable. O comando status mostra informações detalhadas sobre um serviço. Exemplo com o serviço nginx:

# Iniciar o serviço nginx
sudo systemctl start nginx

# Habilitar para iniciar automaticamente
sudo systemctl enable nginx

# Verificar status
sudo systemctl status nginx

# Parar e desabilitar
sudo systemctl stop nginx
sudo systemctl disable nginx

As units ficam em /etc/systemd/system/ (criadas pelo admin) e /lib/systemd/system/ (do pacote). Um arquivo de unit típico contém seções como [Unit] (descrição, dependências), [Service] (tipo, comando de execução) e [Install] (target de instalação). Você pode criar suas próprias units para serviços customizados.

# Exemplo de unit /etc/systemd/system/meu-servico.service
[Unit]
Description=Meu Serviço Personalizado
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/meu-script.sh
Restart=on-failure

[Install]
WantedBy=multi-user.target

Após criar ou modificar uma unit, execute sudo systemctl daemon-reload para recarregar as configurações.

Logs do sistema

Logs são registros de eventos do sistema e aplicações. No systemd, o journald coleta logs binários e os disponibiliza via journalctl. Você pode filtrar por serviço, prioridade, data e muito mais. Logs tradicionais em texto plano ainda são escritos em /var/log/ (ex.: syslog, auth.log).

Com journalctl, você pode visualizar logs em tempo real (-f), consultar logs de um serviço específico (-u nginx), desde o último boot (-b) ou com prioridade (-p err). Exemplos:

# Ver todos os logs (requer sudo para alguns)
sudo journalctl

# Logs do serviço sshd
sudo journalctl -u sshd

# Logs desde o último boot
sudo journalctl -b

# Acompanhar logs em tempo real
sudo journalctl -f

# Logs de erro (prioridade 3)
sudo journalctl -p err

Para logs tradicionais, use tail, less ou grep nos arquivos em /var/log/. Exemplo: tail -f /var/log/syslog para monitorar em tempo real. Ferramentas como logrotate gerenciam a rotação e compressão automática dos logs.

Monitoramento básico

Monitorar processos e recursos do sistema é essencial para detectar problemas de desempenho. Comandos como top e htop mostram uso de CPU, memória, processos em execução. htop é uma versão melhorada com interface colorida e interativa.

Para monitorar uso de disco, use df -h (sistemas de arquivos) e du -sh * (tamanho de diretórios). O comando free -h exibe uso de memória RAM e swap. iostat (do pacote sysstat) mostra estatísticas de I/O de discos. Exemplos:

# Monitorar processos com top
top

# Versão melhorada (instalar com sudo apt install htop)
htop

# Uso de disco
df -h

# Uso de memória
free -h

# Estatísticas de I/O
iostat -x 1 5

Ferramentas como netstat ou ss mostram conexões de rede e portas em uso. Para monitoramento mais avançado, considere soluções como Prometheus, Grafana, Nagios ou Zabbix, que integram coleta de métricas e alertas.

# Mostrar conexões de rede ativas
ss -tulpn

# Alternativa com netstat (instalar net-tools)
netstat -tulpn

Boas práticas

  • Sempre verifique logs ao diagnosticar problemas: journalctl -xe mostra o erro do último serviço falho.
  • Use systemctl list-units --type=service --state=running para listar serviços ativos.
  • Evite matar processos à força (kill -9) sem antes tentar SIGTERM (padrão) ou SIGINT.
  • Documente serviços customizados com units systemd e mantenha scripts em diretórios padronizados.
  • Configure logrotate para evitar que logs cresçam indefinidamente.

Observações finais

Dominar processos e serviços é um passo fundamental para qualquer profissional DevOps. O systemd unificou a administração de serviços e logs, tornando o gerenciamento mais consistente. Pratique os comandos em um ambiente de teste para ganhar confiança. Lembre-se de que a segurança também é importante: evite rodar serviços como root e use permissões adequadas.

Exercícios

  1. Liste todos os processos do sistema ordenados por uso de memória (descendente) e salve a saída em um arquivo.

    2. ✓ Resposta: 
    ps aux --sort=-%mem > processos_por_memoria.txt
  2. Crie um serviço systemd simples que execute um script que escreve a data atual em um arquivo a cada 30 segundos (dica: use um loop com sleep).

    3. ✓ Resposta:

    Script /usr/local/bin/log-date.sh:

    #!/bin/bash
while true; do
  date >> /var/log/date.log
  sleep 30
done

    Unit /etc/systemd/system/date-log.service:

    [Unit]
Description=Log date every 30 seconds

[Service]
ExecStart=/usr/local/bin/log-date.sh
Restart=always

[Install]
WantedBy=multi-user.target

    Comandos:

    sudo systemctl daemon-reload
sudo systemctl start date-log
sudo systemctl enable date-log
  3. Use journalctl para exibir apenas as mensagens de erro (prioridade err) do serviço sshd desde o último boot.

    4. ✓ Resposta: 
    sudo journalctl -u sshd -b -p err
  4. Monitore o uso de CPU em tempo real e identifique o processo que mais consome CPU, depois finalize-o.

    5. ✓ Resposta: 
    # Execute top e pressione Shift+P para ordenar por CPU
# Identifique o PID do processo que mais consome
# Depois finalize com:
kill -9 PID
  5. Liste todos os serviços systemd que estão ativos atualmente.

    6. ✓ Resposta: 
    systemctl list-units --type=service --state=running

Referências