Table of Contents

Gerenciamento de Processos no Linux

Gerenciamento de Processos no Linux

Nível Básico

1. Visualização de Processos Simples

ps - Lista os processos em execução no terminal atual.
1. Exemplo de uso:
```
ps
```
2. Descrição: Exibe os processos em execução no terminal atual com informações básicas como PID, TTY e comando.

top - Monitora processos em tempo real.
1. Exemplo de uso:
```
top
```
2. Descrição: Mostra os processos em execução, uso de CPU, memória e tempo de execução em uma interface interativa em tempo real.

2. Gerenciamento Básico de Processos

kill - Encerra um processo com base no PID.
1. Exemplo de uso:
```
kill 1234
```
2. Descrição: Encerra o processo com o PID 1234. Utiliza o sinal padrão (SIGTERM) para solicitar o encerramento.

bg - Coloca um processo suspenso em segundo plano.
1. Exemplo de uso:
```
bg %1
```
2. Descrição: Retoma o processo suspenso %1 e o coloca em execução em segundo plano.

3. Comandos de Controle de Processos Simples

jobs - Lista os processos em segundo plano e suspensos no shell atual.
1. Exemplo de uso:
```
jobs
```
2. Descrição: Exibe uma lista dos processos que estão rodando em segundo plano ou suspensos no terminal atual.

fg - Traz um processo de segundo plano para o primeiro plano.
1. Exemplo de uso:
```
fg %1
```
2. Descrição: Move o processo %1 do segundo plano para o primeiro plano para continuar sua execução de forma interativa.

Nível Intermediário

1. Visualização Detalhada de Processos

ps aux - Lista todos os processos em execução no sistema com informações detalhadas.
1. Exemplo de uso:
```
ps aux
```
2. Descrição: Exibe uma lista completa de todos os processos, incluindo aqueles que não estão associados ao terminal atual, com informações como CPU, memória e usuário que iniciou o processo.

htop - Visualização interativa de processos com interface melhorada.
1. Exemplo de uso:
```
htop
```
2. Descrição: Ferramenta interativa para monitorar processos em tempo real, permitindo a navegação fácil com o teclado e suporte a múltiplas opções de filtragem e ordenação.

2. Enviar Sinais para Processos

kill -9 - Envia o sinal SIGKILL para encerrar um processo imediatamente.
1. Exemplo de uso:
```
kill -9 1234
```
2. Descrição: Força o encerramento imediato do processo com PID 1234. Este comando não permite que o processo execute a rotina de limpeza antes de ser finalizado.

killall - Envia sinais para múltiplos processos com o mesmo nome.
1. Exemplo de uso:
```
killall firefox
```
2. Descrição: Encerra todos os processos que correspondem ao nome especificado, no caso firefox.

3. Gerenciamento de Prioridade de Processos

nice - Inicia um processo com uma prioridade específica.
1. Exemplo de uso:
```
nice -n 10 comando
```
2. Descrição: Executa o comando com prioridade reduzida, o que permite que ele consuma menos recursos do sistema.

renice - Altera a prioridade de um processo em execução.
1. Exemplo de uso:
```
renice +5 1234
```
2. Descrição: Altera a prioridade do processo com PID 1234, reduzindo sua prioridade, de forma que ele consuma menos recursos.

4. Parar e Continuar Processos

kill -STOP - Suspende temporariamente um processo.
1. Exemplo de uso:
```
kill -STOP 1234
```
2. Descrição: Suspende o processo com PID 1234, parando sua execução, mas sem encerrá-lo.

kill -CONT - Retoma a execução de um processo suspenso.
1. Exemplo de uso:
```
kill -CONT 1234
```
2. Descrição: Retoma a execução do processo com PID 1234 que estava suspenso.

Nível Avançado

1. Gerenciamento de Processos em Execução

top -u - Filtra processos por um usuário específico.
1. Exemplo de uso:
```
top -u usuario
```
2. Descrição: Exibe os processos em execução pertencentes ao usuário usuario, permitindo monitorar apenas suas atividades.

pgrep - Encontra processos com base em nome ou outros critérios.
1. Exemplo de uso:
```
pgrep apache2
```
2. Descrição: Procura o PID de todos os processos que correspondem ao nome apache2.

2. Gerenciamento Avançado de Processos com `nohup`

nohup - Executa um processo que continuará rodando mesmo após o encerramento do terminal.
1. Exemplo de uso:
```
nohup comando &
```
2. Descrição: Executa o comando em segundo plano, ignorando o sinal de hangup, permitindo que o processo continue rodando após a desconexão do terminal.

disown - Remove um processo de segundo plano da lista de processos associados ao terminal.
1. Exemplo de uso:
```
disown -h %1
```
2. Descrição: Desassocia o processo %1 do terminal atual, para que ele não seja terminado ao fechar a sessão.

3. Gerenciamento de Processos em Múltiplas Máquinas

pssh - Executa comandos de forma paralela em várias máquinas via SSH.
1. Exemplo de uso:
```
pssh -h hosts.txt -l usuario comando
```
2. Descrição: Executa o comando em todas as máquinas listadas no arquivo hosts.txt, utilizando o usuário usuario para acesso SSH.

parallel-ssh - Executa comandos simultaneamente em múltiplos servidores.
1. Exemplo de uso:
```
parallel-ssh -h servidores.txt df -h
```
2. Descrição: Executa o comando df -h em todos os servidores listados no arquivo servidores.txt, exibindo o uso de disco em cada servidor.

4. Debug e Análise de Processos

strace - Rastreia chamadas de sistema feitas por um processo.
1. Exemplo de uso:
```
strace -p 1234
```
2. Descrição: Anexa ao processo com PID 1234 e exibe todas as chamadas de sistema que o processo está fazendo, útil para debug.

lsof - Exibe arquivos abertos e portas de rede usadas por processos.
1. Exemplo de uso:
```
lsof -i :80
```
2. Descrição: Mostra todos os processos que estão usando a porta 80, normalmente para identificar servidores web ativos.

5. Controle de Recursos por Processo

cgroups - Controla e limita o uso de recursos de um grupo de processos.
1. Exemplo de uso:
```
cgcreate -g memory,cpu:/meugrupo
```
2. Descrição: Cria um grupo de controle meugrupo com limites de uso de CPU e memória. Este grupo pode ser usado para limitar recursos de processos específicos.

systemd-run - Executa um processo sob um escopo gerenciado por systemd.
1. Exemplo de uso:
```
systemd-run --scope -p MemoryMax=500M comando
```
2. Descrição: Executa o comando com um limite máximo de uso de memória de 500 MB, gerenciado pelo systemd.

Nível Especializado

1. Controle Avançado de Processos com `cgroups`

cgexec - Executa processos em grupos de controle (cgroups) específicos.
1. Exemplo de uso:
```
cgexec -g cpu,memory:/meugrupo comando
```
2. Descrição: Executa o comando dentro do cgroup meugrupo, que possui restrições de CPU e memória pré-definidas, garantindo controle sobre o uso de recursos.

cgset - Ajusta os parâmetros de cgroups em tempo real.
1. Exemplo de uso:
```
cgset -r memory.limit_in_bytes=512M /meugrupo
```
2. Descrição: Ajusta dinamicamente o limite de memória do cgroup meugrupo para 512 MB, afetando todos os processos executados dentro deste grupo.

2. Manipulação Especializada de Processos com `systemd`

systemctl isolate - Coloca o sistema em um estado ou alvo específico.
1. Exemplo de uso:
```
systemctl isolate rescue.target
```
2. Descrição: Transfere o sistema para o modo de resgate, terminando a maioria dos processos normais e mantendo apenas o essencial para manutenção.

systemctl kill - Envia sinais a processos gerenciados pelo systemd.
1. Exemplo de uso:
```
systemctl kill --kill-who=all apache2.service
```
2. Descrição: Envia sinais de término para todos os processos relacionados ao serviço apache2 gerenciado pelo systemd.

3. Limitação de I/O com `ionice`

ionice - Controla a prioridade de operações de entrada/saída de disco para processos.
1. Exemplo de uso:
```
ionice -c2 -n7 comando
```
2. Descrição: Executa o comando com prioridade baixa para operações de I/O no disco, minimizando seu impacto no sistema.

ionice + renice - Combina controle de I/O e prioridade de CPU.
1. Exemplo de uso:
```
ionice -c2 -n7 renice +10 1234
```
2. Descrição: Ajusta a prioridade de I/O e de CPU para o processo com PID 1234, garantindo que ele consuma poucos recursos de CPU e disco.

4. Gerenciamento de Processos em Containers

docker run - Inicia processos em containers Docker.
1. Exemplo de uso:
```
docker run --rm -d --name app_container app_imagem
```
2. Descrição: Inicia um processo em um container isolado com base na imagem app_imagem, permitindo que o processo seja executado de forma independente do sistema host.

docker stats - Monitora o uso de recursos por processos em containers.
1. Exemplo de uso:
```
docker stats app_container
```
2. Descrição: Exibe o uso de CPU, memória, I/O e rede de todos os processos em execução dentro do container app_container em tempo real.

5. Execução de Processos Distribuídos

Ansible - Orquestra processos em múltiplos servidores.
1. Exemplo de uso:
```
ansible -i hosts all -m shell -a 'comando'
```
2. Descrição: Executa o comando em todos os servidores listados no arquivo hosts, orquestrando processos de forma paralela em uma infraestrutura distribuída.

Kubernetes - Gerencia processos em containers distribuídos.
1. Exemplo de uso:
```
kubectl run app --image=app_imagem --replicas=3
```
2. Descrição: Executa o processo em três réplicas de containers, distribuindo a carga entre múltiplos nós do cluster Kubernetes.

6. Monitoração Avançada de Processos

atop - Ferramenta avançada para monitoramento detalhado de processos e recursos.
1. Exemplo de uso:
```
atop
```
2. Descrição: Exibe estatísticas detalhadas de uso de CPU, memória, disco e rede por processo em tempo real, permitindo a análise de desempenho.

perf - Ferramenta de análise de performance de processos.
1. Exemplo de uso:
```
perf stat -p 1234
```
2. Descrição: Coleta e exibe métricas detalhadas de desempenho do processo com PID 1234, como número de ciclos de CPU, cache miss e outras métricas de hardware.