Processos zombie no Linux: como encontrá-los e removê-los

Um processo zombie é um processo filho que terminou a sua execução, mas ainda ocupa um espaço na tabela de processos do kernel. Existe porque o processo pai não chamou wait() para recolher o seu estado de saída. Os processos zombie não consomem CPU nem memória, mas cada um ocupa um PID. Se se acumularem em número suficiente, o sistema não consegue criar novos processos. Este artigo explica como identificá-los, removê-los e impedir que surjam desde o início.

Por que razão os processos zombie são importantes nos servidores

Um único processo zombie é inofensivo. O problema começa quando se acumulam. O Linux tem um espaço de PID finito: 32 768 em sistemas de 32 bits, até 4 194 304 em sistemas de 64 bits. Se os processos zombie encherem a tabela de processos, o kernel não consegue criar novos processos. Isso significa que não há novas ligações, nem novos threads de trabalho, nem nada de novo.

Servidores web como o Apache e o Nginx estão particularmente expostos porque criam processos filhos para lidar com o tráfego. Testes de desempenho demonstraram uma queda de 48% na taxa de transferência quando os processos zombie se acumulam num servidor web ocupado. Em 2019, uma fuga de canal Golang num pod DNS do Kubernetes criou mais de 26 000 processos zombie num único nó, enchendo a tabela de processos e causando a falha da resolução DNS em todo o cluster.

A tabela abaixo mostra as principais diferenças entre um processo normal e um zombie:

A conclusão fundamental: não se pode kill -9 um zombie. Ele já está morto. A única maneira de o eliminar é fazer com que o processo pai o recolha, ou matar o pai para que init (PID 1) o herde e o elimine automaticamente.

Como encontrar processos zombie

Os processos zombie aparecem com um Z na coluna STAT e <defunct> ao lado do nome do comando. Liste-os com:

ps aux | grep -w Z

Para ver o ID do processo pai (PPID), de que irá precisar para a remoção:

ps -eo pid,ppid,stat,comm | grep -w Z

O top comando também indica a contagem total de processos zombie na sua linha de cabeçalho. Para uma verificação rápida e não interativa:

top -bn1 | grep zombie

Rastrear o processo pai com o pstree

Assim que tiver o PID de um zombie, rastreie-o até ao pai responsável:

pstree -p -s <zombie_pid>

Isto mostra a árvore genealógica completa desde init até ao zombie. Se pstree não estiver instalado, ps auxf fornece uma visualização em árvore ASCII semelhante.

Contagem de zombies para monitorização

Uma contagem limpa que exclui o próprio processo grep:

ps aux | awk '$8 ~ /Z/ {count++} END {print count+0}'

Para monitorização contínua durante a resolução de problemas:

watch -n 1 'ps aux | grep -w Z | wc -l'

Como remover processos zombie

Os processos zombie só podem ser removidos através da recolha do seu estado de saída. Isso significa trabalhar através do processo pai.

1. Encontre o processo pai.

ps -o ppid= -p <zombie_pid>

2. Sinalize ao processo pai para eliminar os seus filhos.

kill -SIGCHLD <parent_pid>

Isto diz ao pai para chamar wait() em quaisquer filhos encerrados. É um processo não disruptivo e funciona com aplicações que se comportam corretamente.

3. Se o SIGCHLD não funcionar, reinicie o serviço.

systemctl restart <service_name>

4. Se o pai não responder, encerre-o.

kill <parent_pid>

Ou se ignorar o SIGTERM:

kill -9 <parent_pid>

Quando o pai morre, init (PID 1) ou systemd adota os zombies órfãos e os elimina imediatamente. Tenha cuidado em sistemas de produção. Encerrar o processo pai também encerra todos os seus filhos ativos.

5. Verifique a limpeza.

ps aux | awk '$8 ~ /Z/ {count++} END {print count+0}'

Se a contagem for 0, está tudo bem.

Prevenção de processos zombie

Lide com processos filhos no seu código

A causa principal da maioria das acumulações de processos zombie é um processo pai que nunca chama wait(). Corrija na origem:

• C: Defina signal(SIGCHLD, SIG_IGN); para descartar automaticamente as informações de saída dos processos filhos ou use um manipulador de sinais com waitpid(-1, NULL, WNOHANG) para recolher de forma assíncrona.
• Python: Use subprocess.run(), que aguarda automaticamente. Se estiver a utilizar Popen, chame proc.wait() explicitamente.
• Bash: Adicione wait no final dos scripts que iniciam tarefas em segundo plano.

Configure o systemd corretamente

Para serviços geridos pelo systemd, estas configurações evitam a acumulação de processos zombie:

• KillMode=control-group garante que todos os processos filhos sejam encerrados em conjunto quando o serviço parar.
• TimeoutStopSec dá tempo ao processo pai para recolher os filhos antes de o systemd enviar SIGKILL.
• WatchdogSec reinicia automaticamente os serviços que não respondem, detetando casos em que o processo pai fica bloqueado e deixa de eliminar os filhos.

Monitorize a sua tabela de processos

Configure uma tarefa cron que seja executada a cada 15 minutos para contar os processos «zombie» e alertar se a contagem exceder um limite:

ps aux | awk '$8 ~ /Z/' | wc -l

Monitorize também a utilização da sua tabela de processos, comparando a contagem atual com /proc/sys/kernel/pid_max. Se exceder 80%, investigue antes que se torne um problema. Alguns zombies transitórios durante o funcionamento normal não são motivo de preocupação. Uma contagem crescente que não volta a zero aponta para um bug na aplicação que precisa de ser corrigido.

Conclusão

Os processos zombie são processos mortos que não foram eliminados. Não utilizam CPU nem memória, mas ocupam PIDs, e uma tabela de processos cheia impede o servidor de realizar qualquer tarefa útil.

• Encontre-os com ps aux | grep -w Z e rastreie o processo pai com pstree.
• Remova-os enviando SIGCHLD ao processo pai, reiniciando o serviço ou terminando o processo pai como último recurso.
• Prevê-os escrevendo código que chame wait(), configurando o systemd corretamente e monitorizando a sua tabela de processos.

Se estiver a executar cargas de trabalho de alto tráfego e precisar de uma infraestrutura fiável com acesso root total, os servidores dedicados da FDC oferecem-lhe controlo total sobre a gestão de processos e a configuração do sistema.