103.5 Lição 1

Certificação:

LPIC-1

Versão:

5.0

Tópico:

103 Comandos GNU e Unix

Objetivo:

103.5 Criar, monitorar e eliminar processos

Lição:

1 de 2

Introdução

A cada vez que invocamos um comando, um ou mais processos são iniciados. Um administrador de sistema experiente não só precisa criar processos, mas também ser capaz de controlá-los e enviar diferentes tipos de sinais a eles se e quando necessário. Nesta lição, discorreremos sobre o controle de trabalhos e o monitoramento de processos.

Controle de jobs

Jobs (trabalhos) são processos iniciados de forma interativa através de um terminal, enviados para o segundo plano e ainda não finalizados. Para descobrir mais sobre os jobs ativos (e seus status) em seu sistema Linux, execute jobs:

$ jobs

O comando jobs acima não produziu nenhuma saída, o que significa que não há jobs ativos no momento. Vamos criar nosso primeiro job executando um comando que leva algum tempo para terminar de ser executado (o comando sleep com um parâmetro de 60) e — durante a execução — pressionamos Ctrl+Z:

$ sleep 60
^Z
[1]+  Stopped                 sleep 60

A execução do comando foi interrompida (ou, mais exatamente, suspensa) e o prompt de comando está disponível novamente. Se você procurar por jobs uma segunda vez, encontrará aquele que foi suspenso:

$ jobs
[1]+  Stopped                 sleep 60

Vamos entender melhor essa saída:

[1]: Este número é o identificador do trabalho e pode ser usado --precedido por um símbolo de porcentagem (%) — para alterar o status do job com os utilitários fg, bg e kill (como ensinaremos mais tarde).
+: O sinal de mais indica o job atual por padrão (ou seja, o último a ser suspenso ou mandado ao segundo plano). O job anterior é sinalizado com um sinal de menos (-). Quaisquer outros jobs anteriores não são sinalizados.
Stopped: Descrição do status do job.
sleep 60: O comando ou job em si.

Com a opção -l, o comando jobs exibe adicionalmente o identificador do processo (PID) logo antes do status:

$ jobs -l
[1]+  1114 Stopped                 sleep 60

As demais opções possíveis para jobs são:

-n: Lista apenas os processos que mudaram de status desde a última notificação. Os possíveis status incluem Running, Stopped, Terminated ou Done.
-p: Lista os IDs do processo.
-r: Lista apenas os jobs em execução.
-s: Lista apenas os jobs interrompidos (ou suspensos).

Note	Lembre-se, um job tem um ID de trabalho e um ID de processo (PID).

Especificação do trabalho

O comando jobs, a exemplo de outros utilitários como fg, bg e kill (que você verá na próxima seção), precisa de uma especificação de trabalho (ou jobspec) para agir sobre um job particular. Como acabamos de ver, este pode ser — e normalmente é — o ID do trabalho precedido por %. No entanto, outras especificações de trabalho também são possíveis. Vamos dar uma olhada nelas:

%n

Job cujo número de ID é n:

$ jobs %1
[1]+  Stopped                 sleep 60

%str

Job cuja linha de comando começa com str:

$ jobs %sl
[1]+  Stopped                 sleep 60

%?str

Job cuja linha de comando contém str:

$ jobs %?le
[1]+  Stopped                 sleep 60

%+ ou %%

Job atual (o que foi iniciado por último em segundo plano ou suspenso do primeiro plano):

$ jobs %+
[1]+  Stopped                 sleep 60

%-

Job anterior (aquele que era %+ antes do padrão, que é o atual):

$ jobs %-
[1]+  Stopped                 sleep 60

No nosso caso, como há apenas um job, ele é o atual e o anterior.

Status do trabalho: suspensão, primeiro plano e segundo plano

Uma vez que um job está em segundo plano ou foi suspenso, podemos fazer três coisas com ele:

Levá-lo ao primeiro plano com fg:
```
$ fg %1
sleep 60
```
fg move o job especificado para o primeiro plano e o torna o job atual. A seguir podemos esperar que ele seja concluído, interrompê-lo novamente com Ctrl+Z ou encerrá-lo com Ctrl+C.
Colocá-lo em segundo plano com bg:
```
$ bg %1
[1]+ sleep 60 &
```
Uma vez no segundo plano, o trabalho pode ser trazido de volta ao primeiro plano com fg ou eliminado (veja abaixo). Observe o e comercial (&) indicando que o trabalho foi enviado para o segundo plano. Na verdade, também podemos usar o e comercial para iniciar um processo diretamente em segundo plano:
```
$ sleep 100 &
[2] 970
```
Junto com o ID do novo trabalho ([2]), também obtemos o ID do processo (970). Agora, ambos os trabalhos estão rodando em segundo plano:
```
$ jobs
[1]-  Running                 sleep 60 &
[2]+  Running                 sleep 100 &
```
Um pouco mais tarde, o primeiro trabalho termina de ser executado:
```
$ jobs
[1]-  Done                    sleep 60
[2]+  Running                 sleep 100 &
```
Encerrá-lo através de um sinal SIGTERM com kill:
```
$ kill %2
```
Para ter certeza de que o job foi encerrado, rode jobs novamente:
```
$ jobs
[2]+  Terminated                 sleep 100
```

Note	Se nenhum trabalho for especificado, `fg` e `bg` agirão sobre o job padrão atual. `kill`, no entanto, sempre precisa de uma especificação de trabalho.

Trabalhos desvinculados: `nohup`

Os jobs que vimos nas seções anteriores estavam todos vinculados à sessão do usuário que os invocou. Isso significa que, se a sessão for encerrada, os jobs serão perdidos. No entanto, é possível desvincular jobs de sessões e executá-los mesmo após o encerramento da sessão. Isso é feito com o comando nohup (“no hangup”). A sintaxe é a seguinte:

nohup COMMAND &

Lembre-se, o & envia o processo para o segundo plano e libera o terminal em que estamos trabalhando.

Vamos desvincular o job em segundo plano ping localhost da sessão atual:

$ nohup ping localhost &
[1] 1251
$ nohup: ignoring input and appending output to 'nohup.out'
^C

A saída mostra o ID do trabalho ([1]) e o PID (1251), seguido por uma mensagem nos informando sobre o arquivo nohup.out. Este é o arquivo padrão no qual stdout e stderr serão salvos. Agora podemos pressionar Ctrl+C para liberar o prompt de comando, fechar a sessão, iniciar outra como root e usar tail -f para verificar se o comando está rodando e a saída está sendo escrita no arquivo padrão:

$ exit
logout
$ tail -f /home/carol/nohup.out
64 bytes from localhost (::1): icmp_seq=3 ttl=64 time=0.070 ms
64 bytes from localhost (::1): icmp_seq=4 ttl=64 time=0.068 ms
64 bytes from localhost (::1): icmp_seq=5 ttl=64 time=0.070 ms
^C

Tip	Em vez de usar o `nohup.out` padrão, poderíamos ter especificado um arquivo de saída à escolha com `nohup ping localhost > /path/to/your/file &`.

Se quisermos encerrar o processo, devemos especificar seu PID:

# kill 1251

Monitoramento de processos

Um processo ou tarefa é uma instância de um programa em execução. Assim, criamos novos processos toda vez que digitamos comandos no terminal.

O comando watch executa um programa periodicamente (por padrão, a cada 2 segundos) e nos permite observar a mudança da saída do programa ao longo do tempo. Por exemplo, podemos monitorar como a média de trabalho muda conforme mais processos são executados digitando watch uptime:

Every  2.0s: uptime          debian: Tue Aug 20 23:31:27 2019

 23:31:27 up 21 min,  1 user,  load average: 0.00, 0.00, 0.00

O comando roda até ser interrompido, então teríamos de pará-lo com Ctrl+C. Obtemos duas linhas na saída: a primeira corresponde ao watch e nos informa a frequência com que o comando será executado (Every 2.0s: uptime), qual o comando/programa a observar (uptime) além do nome do host e a data (debian: Tue Aug 20 23:31:27 2019). A segunda linha da saída é o tempo de atividade e inclui a hora (23:31:27), o tempo em que o sistema está ativo (up 21 min), o número de usuários ativos (1 user) e a carga média do sistema ou o número de processos em execução ou em estado de espera nos últimos 1, 5 e 15 minutos (load average: 0.00, 0.00, 0.00).

Da mesma forma, você pode verificar o uso de memória à medida que novos processos são criados com watch free:

Every  2.0s: free            debian: Tue Aug 20 23:43:37 2019

 23:43:37 up 24 min,  1 user,  load average: 0.00, 0.00, 0.00
              total        used        free      shared  buff/cache   available
Mem:       16274868      493984    14729396       35064     1051488    15462040
Swap:      16777212           0    16777212

Para alterar o intervalo de atualização de watch, use as opções -n ou --interval, mais o número de segundos, como em:

$ watch -n 5 free

Agora o comando free será executado a cada 5 segundos.

Para saber mais sobre as opções de uptime, free e watch, consulte as páginas de manual correspondentes.

Note	As informações fornecidas por `uptime` e `free` também são integradas nas ferramentas mais abrangentes `top` e `ps` (veja abaixo).

Enviando sinais para processos: `kill`

Cada processo possui um identificador de processo ou PID exclusivo. Uma maneira de descobrir o PID de um processo é usar o comando pgrep seguido pelo nome do processo:

$ pgrep sleep
1201

Note	O identificador de um processo também pode ser descoberto com o comando `pidof` (p.ex. `pidof sleep`).

Como no caso do pgrep, o comando pkill elimina um processo com base em seu nome:

$ pkill sleep
[1]+  Terminated              sleep 60

Para eliminar várias instâncias do mesmo processo, o comando killall pode ser usado:

$ sleep 60 &
[1] 1246
$ sleep 70 &
[2] 1247
$ killall sleep
[1]-  Terminated              sleep 60
[2]+  Terminated              sleep 70

Tanto pkill quanto killall funcionam da mesma maneira que kill, ou seja, enviam um sinal de encerramento para o(s) processo(s) especificado(s). Se nenhum sinal for fornecido, o padrão SIGTERM é enviado. No entanto, kill só aceita um ID de trabalho ou de processo como argumento.

Os sinais podem ser especificados por:

Nome:
```
$ kill -SIGHUP 1247
```
Número:
```
$ kill -1 1247
```
Opção:
```
$ kill -s SIGHUP 1247
```

Para fazer com que kill funcione de forma semelhante a pkill ou killall (evitando os comandos para descobrir os PIDs correspondentes), podemos usar a substituição de comandos:

$ kill -1 $(pgrep sleep)

Como você já deve saber, uma sintaxe alternativa é kill -1 `pgrep sleep`.

Tip	Para uma lista exaustiva de todos os sinais de `kill` e seus códigos, digite `kill -l` no terminal. Use `-KILL` (`-9` ou `-s KILL`) para eliminar processos rebeldes quando todos os outros sinais falharem.

`top` e `ps`

Quando se trata de monitoramento de processos, duas ferramentas inestimáveis são top e ps. Enquanto o primeiro produz resultados de maneira dinâmica, o último o faz de maneira estática. Em todos os casos, ambos são excelentes utilitários para se ter uma visão abrangente de todos os processos do sistema.

Interação com `top`

Para chamar o top, basta digitar top:

$ top

top - 11:10:29 up  2:21,  1 user,  load average: 0,11, 0,20, 0,14
Tasks:  73 total,   1 running,  72 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0,0 us,  0,3 sy,  0,0 ni, 99,7 id,  0,0 wa,  0,0 hi,  0,0 si,  0,0 st
KiB Mem :  1020332 total,   909492 free,    38796 used,    72044 buff/cache
KiB Swap:  1046524 total,  1046524 free,        0 used.   873264 avail Mem

   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
   436 carol     20   0   42696   3624   3060 R  0,7  0,4   0:00.30 top
     4 root      20   0       0      0      0 S  0,3  0,0   0:00.12 kworker/0:0
   399 root      20   0   95204   6748   5780 S  0,3  0,7   0:00.22 sshd
     1 root      20   0   56872   6596   5208 S  0,0  0,6   0:01.29 systemd
     2 root      20   0       0      0      0 S  0,0  0,0   0:00.00 kthreadd
     3 root      20   0       0      0      0 S  0,0  0,0   0:00.02 ksoftirqd/0
     5 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 kworker/0:0H
     6 root      20   0       0      0      0 S  0,0  0,0   0:00.00 kworker/u2:0
     7 root      20   0       0      0      0 S  0,0  0,0   0:00.08 rcu_sched
     8 root      20   0       0      0      0 S  0,0  0,0   0:00.00 rcu_bh
     9 root      rt   0       0      0      0 S  0,0  0,0   0:00.00 migration/0
    10 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 lru-add-drain
    (...)

O top permite uma certa interação do usuário. Por padrão, a saída é classificada pela porcentagem de tempo da CPU usada por cada processo em ordem decrescente. Esse comportamento pode ser modificado pressionando as seguintes teclas de dentro do top:

M: Classificar por uso da memória.
N: Classificar pelo número ID do processo.
T: Classificar por tempo de execução.
P: Classificar por porcentagem de uso da CPU.

Tip	Para alternar entre a ordem crescente/decrescente, basta pressionar `R`.

Outras teclas interessantes para interagir com top são:

? ou h: Ajuda.
k: Elimina um processo. O top pedirá o PID do processo a encerrar, assim como o sinal a ser enviado (por padrão, SIGTERM ou 15).
r: Altera a prioridade de um processo (renice). top pede o valor de nice. Os valores possíveis variam de -20 a 19, mas apenas o superusuário (root) pode definir um valor negativo ou inferior ao atual.
u: Lista os processos de um determinado usuário (por padrão, são mostrados os processos de todos os usuários).
c: Mostra os caminhos absolutos dos programas e diferencia os processos do espaço do usuário dos processos do espaço do kernel (entre colchetes).
V: Visão de floresta/hierárquica dos processos.
t e m: Mudam a aparência das leituras da CPU e da memória, respectivamente, em um ciclo de quatro estágios: os dois primeiros pressionamentos mostram barras de progresso, o terceiro oculta a barra e o quarto a traz de volta.
W: Salva as definições de configuração em ~/.toprc.

Tip	Uma versão mais sofisticada e amigável de `top` é `htop`. Outra alternativa, talvez mais exaustiva, é `atop`. Se ainda não estiverem instalados em seu sistema, use seu gerenciador de pacotes para instalá-los e experimentá-los.

Explicação da saída de `top`

A saída de top é dividida em duas áreas: a área de resumo e a área de tarefas.

A área de resumo em `top`

A área de resumo é composta pelas cinco linhas superiores e nos fornece as seguintes informações:

top - 11:10:29 up 2:21, 1 user, load average: 0,11, 0,20, 0,14
- hora atual (em formato de 24 horas): 11:20:29
- tempo de atividade (há quanto tempo o sistema está ativo e funcionando): up 2:21
- número de usuários logados e carga média da CPU nos últimos 1, 5 e 15 minutos, respectivamente: load average: 0,11, 0,20, 0,14
Tasks: 73 total, 1 running, 72 sleeping, 0 stopped, 0 zombie (informações sobre os processos)
- número total de processos em modo ativo: 73 total
- em execução (os que estão sendo executados): 1 running
- em espera (os que estão esperando para retomar a execução): 72 sleeping
- interrompidos (por um sinal de controle do trabalho): 0 stopped
- zumbi (os que concluíram a execução mas ainda estão esperando que o processo pai os remova da tabela de processos): 0 zombie
%Cpu(s): 0,0 us, 0,3 sy, 0,0 ni, 99,7 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st (porcentagem de tempo da CPU gasto em:)
- processos de usuário: 0,0 us
- processos do sistema/kernel: 0,4 sy
- processos com um valor nice configurado — quanto mais alto o valor nice, menor a prioridade: 0,0 ni
- nada — tempo ocioso da CPU: 99,7 id
- processos aguardando operações de I/O: 0,0 wa
- processos atendendo interrupções de hardware — periféricos enviando ao processador sinais que precisam de atenção: 0,0 hi
- processos atendendo interrupções de software: 0,0 si
- processos atendendo tarefas de outras máquinas virtuais em um ambiente virtual, e que portanto roubam tempo: 0,0 st
KiB Mem : 1020332 total, 909492 free, 38796 used, 72044 buff/cache (informações da memória em kilobytes)
- quantidade total de memória: 1020332 total
- memória não utilizada: 909492 free
- memória em uso: 38796 used
- memória armazenada em buffer e em cache para evitar acesso excessivo ao disco: 72044 buff/cache
  
  Note como o total é a soma dos outros três valores — free, used e buff/cache — (aproximadamente 1 GB em nosso caso).
KiB Swap: 1046524 total, 1046524 free, 0 used. 873264 avail Mem (informações de troca em kilobytes)
- quantidade total de espaço de troca: 1046524 total
- espaço de troca não utilizado: 1046524 free
- espaço de troca em uso: 0 used
- quantidade de memória de troca que pode ser alocada a processos sem causar mais trocas: 873264 avail Mem

A área de tarefas em `top`: Campos e colunas

Abaixo da área de resumo fica a área de tarefas, que inclui uma série de campos e colunas que informam sobre os processos em execução:

PID: Identificador do processo.
USER: Usuário emissor do comando que originou o processo
PR: Prioridade de processo para o kernel.
NI: Valor nice do processo. Os valores mais baixos têm mais prioridade que os valores altos.
VIRT: Quantidade total de memória usada por processo (incluindo Troca).
RES: Memória RAM usada por processo.
SHR: Memória compartilhada do processo com outros processos.
S: Status do processo. Os valores incluem: S (suspensão interrompível — esperando que um evento termine), R (executável — em execução ou na fila para ser executado) ou Z (zumbi — processos filhos encerrados cujas estruturas de dados ainda não foram removidas da tabela de processos).
%CPU: Porcentagem de CPU usada pelo processo.
%MEM: Porcentagem de RAM utilizada pelo processo, ou seja, o valor de RES expresso em porcentagem.
TIME+: Tempo total de atividade do processo.
COMMAND: Nome do comando/programa que gerou o processo.

Visualizando processos estaticamente: `ps`

Como dito acima, o ps exibe um instantâneo dos processos. Para ver todos os processos com um terminal (tty), digite ps a:

$ ps a
  PID TTY      STAT   TIME COMMAND
  386 tty1     Ss+    0:00 /sbin/agetty --noclear tty1 linux
  424 tty7     Ssl+   0:00 /usr/lib/xorg/Xorg :0 -seat seat0 (...)
  655 pts/0    Ss     0:00 -bash
 1186 pts/0    R+     0:00 ps a
 (...)

Explicação da sintaxe e da saída das opções de `ps`

Com relação às opções, o ps aceita três estilos diferentes: BSD, UNIX e GNU. Vamos ver como cada um desses estilos se comportaria ao relatar informações sobre a ID de um processo específico:

BSD

As opções não requerem um traço inicial:

$ ps p 811
  PID TTY      STAT   TIME COMMAND
  811 pts/0    S      0:00 -su

UNIX

As opções requerem um traço inicial:

$ ps -p 811
  PID TTY          TIME CMD
  811 pts/0    00:00:00 bash

GNU

As opções recebem um duplo traço inicial:

$ ps --pid 811
  PID TTY          TIME CMD
  811 pts/0    00:00:00 bash

Nos três casos, o ps relata informações sobre o processo cujo PID é 811 — neste caso, o bash.

Da mesma forma, podemos usar o ps para pesquisar os processos iniciados por um usuário determinado:

ps U carol (BSD)
ps -u carol (UNIX)
ps --user carol (GNU)

Vamos verificar os processos iniciados por carol:

$ ps U carol
  PID TTY      STAT   TIME COMMAND
  811 pts/0    S      0:00 -su
  898 pts/0    R+     0:00 ps U carol

Ela iniciou dois processos: bash (-su) e ps (ps U carol). A coluna STAT informa o estado do processo (veja abaixo).

Podemos obter o melhor do ps combinando algumas de suas opções. Um comando muito útil (produzindo uma saída semelhante à de top) é ps aux (estilo BSD). Nesse caso, os processos de todos os shells (não apenas o atual) são mostrados. O significado das opções é o seguinte:

a: Mostra processos que estão vinculados a um tty ou terminal.
u: Exibe formato orientado ao usuário.
x: Mostra processos que não estão vinculados a um tty ou terminal.

$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 204504  6780 ?        Ss   14:04   0:00 /sbin/init
root         2  0.0  0.0      0     0 ?        S    14:04   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S    14:04   0:00 [ksoftirqd/0]
root         5  0.0  0.0      0     0 ?        S<   14:04   0:00 [kworker/0:0H]
root         7  0.0  0.0      0     0 ?        S    14:04   0:00 [rcu_sched]
root         8  0.0  0.0      0     0 ?        S    14:04   0:00 [rcu_bh]
root         9  0.0  0.0      0     0 ?        S    14:04   0:00 [migration/0]
(...)

Entenda melhor as colunas:

USER: Proprietário do processo.
PID: Identificador do processo.
%CPU: Porcentagem de CPU usada.
%MEM: Porcentagem de memória física usada.
VSZ: Memória virtual do processo em KiB.
RSS: Memória física não trocada usada pelo processo em KiB.
TT: Terminal (tty) que controla o processo.
STAT: Código que representa o estado do processo. Além de S, R e Z (que vimos ao descrever a saída de top), outros valores possíveis seriam: D (dormente sem interrupção — geralmente esperando por I/O), T (interrompido — normalmente por um sinal de controle). Alguns modificadores extras incluem: < (prioridade maior que o convencional), N (prioridade menor que o convencional), ou + (no grupo de processos em primeiro plano).
STARTED: Horário de início do processo.
TIME: Tempo de CPU acumulado.
COMMAND: Comando que iniciou o processo.

Exercícios Guiados

oneko é um programa divertido que mostra um gato perseguindo o cursor do mouse. Se ele ainda não estiver instalado em seu sistema desktop, instale-o usando o gerenciador de pacotes de sua distribuição. Vamos usá-lo para estudar o controle de jobs.
- Inicie o programa. Qual o procedimento?
- Mova o cursor do mouse para ver como o gato o persegue. Agora suspenda o processo. Qual o procedimento? Qual é a saída?
- Verifique quantos jobs estão presentes atualmente. O que você digita? Qual é a saída?
- Agora envie-o para o segundo plano especificando seu ID de trabalho. Qual é a saída? Como você pode saber se o job está sendo executado em segundo plano?
- Finalmente, encerre o job especificando seu ID de trabalho. O que você digita?
Descubra o PID de todos os processos gerados pelo servidor web Apache HTTPD (apache2) com dois comandos diferentes:
Encerre todos os processos apache2 sem usar seus PIDs e com dois comandos diferentes:
Suponha que você tem de encerrar todas as instâncias do apache2 e não tem tempo para descobrir quais são os PIDs correspondentes. Como fazer isso usando kill com o sinal padrão SIGTERM em uma só linha?
Inicie o top e interaja com ele executando o seguinte:
- Exibir uma visão em floresta dos processos:
- Exibir caminhos completos de processos, diferenciando entre espaço de usuário e espaço de kernel:
Digite o comando ps para exibir todos os processos iniciados pelo usuário do servidor web Apache HTTPD (www-data):
- Usando a sintaxe do BSD:
- Usando a sintaxe do UNIX:
- Usando a sintaxe do GNU:

Exercícios Exploratórios

O sinal SIGHUP pode ser usado como forma de reiniciar certos daemons. Com o servidor web Apache HTTPD — por exemplo — enviar SIGHUP para o processo pai (iniciado por init) elimina seus filhos. O pai, no entanto, relê seus arquivos de configuração, reabre os arquivos de log e gera um novo conjunto de filhos. Execute as seguintes tarefas:
- Inicie o servidor web:
- Certifique-se de conhecer o PID do processo pai:
- Faça o servidor web Apache HTTPD reiniciar enviando o sinal SIGHUP para o processo pai:
- Verifique se o pai não foi eliminado e se novos filhos foram gerados:
Embora inicialmente estática, a saída de ps pode ser tornada dinâmica combinando ps e watch. Vamos monitorar as novas conexões do servidor web Apache HTTPD. Antes de realizar as tarefas descritas abaixo, recomendamos ler a descrição da diretiva MaxConnectionsPerChild em Apache MPM Common Directives.
- Adicione a diretiva MaxConnectionsPerChild com um valor de 1 no arquivo de configuração de apache2 — no Debian e seus derivativos ele fica em /etc/apache2/apache2.conf; na família CentOS, em /etc/httpd/conf/httpd.conf. Não esqueça de reiniciar apache2 para que as mudanças sejam aplicadas.
- Digite um comando que use watch, ps e grep para as conexões do apache2.
- Agora abra um navegador web ou use um navegador de linha de comando como o lynx para estabelecer uma conexão com o servidor web através de seu endereço IP. O que você observa na saída de watch?
Como vimos, por padrão, top classifica as tarefas por porcentagem de uso da CPU em ordem decrescente (com os valores mais altos no topo). Esse comportamento pode ser modificado com as teclas interativas M (uso de memória), N (identificador único do processo), T (tempo de execução) e P (porcentagem de tempo de CPU). No entanto, também podemos classificar a lista de tarefas a gosto, iniciando top com a opção -o (para saber mais, verifique a página man de top). Agora, execute as seguintes tarefas:
- Inicie o top para que as tarefas sejam classificadas por uso da memória:
- Verifique se digitou o comando correto destacando a coluna da memória:
O ps também tem uma opção o para especificar as colunas que você deseja mostrar. Estude esta opção e execute as seguintes tarefas:
- Inicie o ps para exibir somente informações sobre o usuário, porcentagem de memória usada, porcentagem de tempo da CPU usado e comando completo:
- Agora, inicie o ps para que as únicas informações exibida sejam o usuário e o nome dos programas que ele está usando:

Resumo

Nesta lição, você aprendeu sobre jobs (trabalhos) e controle de jobs. Os fatos e conceitos principais a ser lembrados são:

Jobs são processos enviados ao segundo plano.
Além de um ID de processo, os jobs também recebem um ID de trabalho quando criados.
Para controlar os jobs, é necessária uma especificação de trabalho (jobspec).
Os jobs podem ser trazidos ao primeiro plano, enviados ao segundo plano, encerrados e eliminados (ou mortos).
Um job pode ser desvinculado do terminal e da sessão na qual foi criado.

Discutimos também o conceito de processos e monitoramento de processos. As ideias mais relevantes são:

Os processos são programas em execução.
Os processos podem ser monitorados.
Diferentes utilitários nos permitem descobrir o ID do processo dos processos, bem como enviar sinais para encerrá-los.
Os sinais podem ser especificados por nome (p. ex. -SIGTERM), número (p. ex. -15) ou opção (p. ex. -s SIGTERM).
top e ps são muito poderosos quando se trata de monitorar processos. A saída do primeiro é dinâmica e se atualiza constantemente; já o ps exibe a saída de forma estática.

Comandos usados nesta lição:

jobs: Mostra os jobs ativos e seus status.
sleep: Espera por um período específico de tempo.
fg: Traz o job para o primeiro plano.
bg: Move o job para o segundo plano.
kill: Elimina o job.
nohup: Desvincula o job da sessão/terminal.
exit: Sai do shell atual.
tail: Exibe as linhas mais recentes em um arquivo.
watch: Executa um comando repetidamente (ciclo de 2 segundos por padrão).
uptime: Mostra há quanto tempo o sistema está rodando, o número de usuários atuais e a carga média do sistema.
free: Mostra o uso da memória.
pgrep: Procura o ID do processo com base no nome.
pidof: Procura o ID do processo com base no nome.
pkill: Envia sinal ao processo por nome.
killall: Elimina processo(s) por nome.
top: Exibe os processos do Linux.
ps: Relata um instantâneo dos processos atuais.

Respostas aos Exercícios Guiados

oneko é um programa divertido que mostra um gato perseguindo o cursor do mouse. Se ele ainda não estiver instalado em seu sistema desktop, instale-o usando o gerenciador de pacotes de sua distribuição. Vamos usá-lo para estudar o controle de jobs.
- Inicie o programa. Qual o procedimento?
  
  Digitar oneko no terminal.
- Mova o cursor do mouse para ver como o gato o persegue. Agora suspenda o processo. Qual o procedimento? Qual é a saída?
  
  Pressionar a combinação de teclas Ctrl+z:
  [1]+ Stopped oneko
- Verifique quantos jobs estão presentes atualmente. O que você digita? Qual é a saída?
  $ jobs [1]+ Stopped oneko
- Agora envie-o para o segundo plano especificando seu ID de trabalho. Qual é a saída? Como você pode saber se o job está sendo executado em segundo plano?
  $ bg %1 [1]+ oneko &
  O gato está se movendo outra vez.
- Finalmente, encerre o job especificando seu ID de trabalho. O que você digita?
  $ kill %1
Descubra o PID de todos os processos gerados pelo servidor web Apache HTTPD (apache2) com dois comandos diferentes:
```
$ pgrep apache2
```
ou
```
$ pidof apache2
```
Encerre todos os processos apache2 sem usar seus PIDs e com dois comandos diferentes:
```
$ pkill apache2
```
ou
```
$ killall apache2
```
Suponha que você tem de encerrar todas as instâncias do apache2 e não tem tempo para descobrir quais são os PIDs correspondentes. Como fazer isso usando kill com o sinal padrão SIGTERM em uma só linha?
```
$ kill $(pgrep apache2)
$ kill `pgrep apache2`
```
ou
```
$ kill $(pidof apache2)
$ kill `pidof apache2`
```
Note

Como SIGTERM (15) é o sinal padrão, não é necessário passar nenhuma opção para kill.
Inicie o top e interaja com ele executando o seguinte:
- Exibir uma visão em floresta dos processos:
  
  Pressione V.
- Exibir caminhos completos de processos, diferenciando entre espaço de usuário e espaço de kernel:
  
  Pressione c.
Digite o comando ps para exibir todos os processos iniciados pelo usuário do servidor web Apache HTTPD (www-data):
- Usando a sintaxe do BSD:
  $ ps U www-data
- Usando a sintaxe do UNIX:
  $ ps -u www-data
- Usando a sintaxe do GNU:
  $ ps --user www-data

Respostas aos Exercícios Exploratórios

O sinal SIGHUP pode ser usado como forma de reiniciar certos daemons. Com o servidor web Apache HTTPD — por exemplo — enviar SIGHUP para o processo pai (iniciado por init) elimina seus filhos. O pai, no entanto, relê seus arquivos de configuração, reabre os arquivos de log e gera um novo conjunto de filhos. Execute as seguintes tarefas:
- Inicie o servidor web:
  $ sudo systemctl start apache2
- Certifique-se de conhecer o PID do processo pai:
  $ ps aux | grep apache2
  O processo pai é aquele iniciado pelo usuário root. Em nosso caso, o PID é 1653.
- Faça o servidor web Apache HTTPD reiniciar enviando o sinal SIGHUP para o processo pai:
  $ kill -SIGHUP 1653
- Verifique se o pai não foi eliminado e se novos filhos foram gerados:
  $ ps aux | grep apache2
  Agora você deve ver o processo pai apache2 junto com dois novos filhos.
Embora inicialmente estática, a saída de ps pode ser tornada dinâmica combinando ps e watch. Vamos monitorar as novas conexões do servidor web Apache HTTPD. Antes de realizar as tarefas descritas abaixo, recomendamos ler a descrição da diretiva MaxConnectionsPerChild em Apache MPM Common Directives.
- Adicione a diretiva MaxConnectionsPerChild com um valor de 1 no arquivo de configuração de apache2 — no Debian e seus derivativos ele fica em /etc/apache2/apache2.conf; na família CentOS, em /etc/httpd/conf/httpd.conf. Não esqueça de reiniciar apache2 para que as mudanças sejam aplicadas.
  
  A linha a incluir no arquivo de configuração é MaxConnectionsPerChild 1. Uma maneira de reiniciar o servidor web é através de sudo systemctl restart apache2.
- Digite um comando que use watch, ps e grep para as conexões do apache2.
  $ watch 'ps aux | grep apache2'
  ou
  $ watch "ps aux | grep apache2"
- Agora abra um navegador web ou use um navegador de linha de comando como o lynx para estabelecer uma conexão com o servidor web através de seu endereço IP. O que você observa na saída de watch?
  
  Um dos processos filho de propriedade de www-data desaparece.
Como vimos, por padrão, top classifica as tarefas por porcentagem de uso da CPU em ordem decrescente (com os valores mais altos no topo). Esse comportamento pode ser modificado com as teclas interativas M (uso de memória), N (identificador único do processo), T (tempo de execução) e P (porcentagem de tempo de CPU). No entanto, também podemos classificar a lista de tarefas a gosto, iniciando top com a opção -o (para saber mais, verifique a página man de top). Agora, execute as seguintes tarefas:
- Inicie o top para que as tarefas sejam classificadas por uso da memória:
  $ top -o %MEM
- Verifique se digitou o comando correto destacando a coluna da memória:
  
  Pressione x.
O ps também tem uma opção o para especificar as colunas que você deseja mostrar. Estude esta opção e execute as seguintes tarefas:
- Inicie o ps para exibir somente informações sobre o usuário, porcentagem de memória usada, porcentagem de tempo da CPU usado e comando completo:
  $ ps o user,%mem,%cpu,cmd
- Agora, inicie o ps para que as únicas informações exibida sejam o usuário e o nome dos programas que ele está usando:
  $ ps o user,comm