103.5 Lección 1

Certificación:

LPIC-1

Versión:

5.0

Tema:

103 Comandos GNU y Unix

Objetivo:

103.5 Crear, monitorear y matar procesos

Lección:

1 de 2

Introducción

Cada vez que invocamos un comando, se inician uno o más procesos. Un administrador de sistemas bien entrenado no solo necesita crear procesos, sino también poder realizar un seguimiento de ellos y enviarles diferentes tipos de señales si es necesario. En esta lección veremos el control del trabajo y cómo monitorear los procesos.

Control de trabajos

Los trabajos (Jobs) son procesos que se han iniciado de forma interactiva a través de un terminal, enviados a un segundo plano y aún no han finalizado la ejecución. Puede conocer los trabajos activos (y su estado) en su sistema Linux ejecutando jobs:

$ jobs

El comando jobs anterior no produjo ningún resultado, lo que significa que no hay trabajos activos en este momento. Creemos nuestro primer trabajo ejecutando un comando que tarde un poco en finalizar la ejecución (el comando sleep con un parámetro de 60) y, mientras se ejecuta, presione Ctrl+Z:

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

La ejecución del comando se ha detenido (o, mejor dicho, suspendido) y el símbolo del sistema vuelve a estar disponible. Puede buscar trabajos por segunda vez y encontrará el suspendido:

$ jobs
[1]+  Stopped                 sleep 60

Permítanos explicar el resultado:

[1]: Este número es el ID del trabajo y se puede utilizar, precedido por un símbolo de porcentaje (%), para cambiar el estado del trabajo mediante las utilidades fg, bg y kill (como se mostrará más adelante).
+: El signo más indica el trabajo actual predeterminado (es decir, el último suspendido o enviado al segundo plano). El trabajo anterior está marcado con un signo menos (-). Cualquier otro trabajo anterior no está marcado.
Stopped: Descripción del estado del trabajo.
sleep 60: El comando o trabajo en ejecución.

Con la opción -l, los trabajos también mostrarán la ID del proceso (PID) justo antes del estado:

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

Las opciones posibles restantes de trabajos son:

-n: Lista solo los procesos que han cambiado de estado desde la última notificación. El estado posible incluye, Running, Stopped, Terminated o Done.
-p: Lista los IDs de procesos.
-r: Lista solo los procesos en ejecución.
-s: Lista solamente los trabajos detenidos (o suspendidos).

Note	Recuerde, un trabajo tiene un ID de trabajo y un ID de proceso (PID).

Especificaciones de trabajos

El comando jobs, así como otras utilidades como fg, bg y kill (que verá en la siguiente sección) necesitan una especificación de trabajo (o jobspec) para actuar sobre un trabajo en particular. Como acabamos de ver, esto puede ser, y normalmente es, el ID del trabajo precedido por %. Sin embargo, otras especificaciones de trabajo también son posibles. Echemos un vistazo a ellos:

%n

Trabajo cuyo número de identificación es n:

$ jobs %1
[1]+  Stopped                 sleep 60

%str

Trabajo cuya línea de comando comienza con str:

$ jobs %sl
[1]+  Stopped                 sleep 60

%?str

Trabajo cuya línea de comando contiene str:

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

%+ o %%

Trabajo actual (el último que se inició en segundo plano o suspendido del primer plano):

$ jobs %+
[1]+  Stopped                 sleep 60

%-

Trabajo anterior (el que era % + antes del predeterminado, el actual):

$ jobs %-
[1]+  Stopped                 sleep 60

En nuestro caso, dado que solo hay un trabajo, es actual y anterior.

Estado del trabajo: suspensión, primer plano y segundo plano

Una vez que un trabajo está en segundo plano o ha sido suspendido, podemos hacer cualquiera de estas tres cosas:

Llevarlo al primer plano con fg:
```
$ fg %1
sleep 60
```
fg mueve el trabajo especificado al primer plano y lo convierte en el trabajo actual. Ahora podemos esperar hasta que termine, detenerlo nuevamente con Ctrl+Z o terminarlo con Ctrl+C.
Llevarlo a un segundo plano con bg:
```
$ bg %1
[1]+ sleep 60 &
```
Una vez en segundo plano, el trabajo se puede volver a poner en primer plano con fg o matar (ver más abajo). Tenga en cuenta el signo (&) que significa que el trabajo se ha enviado a segundo plano. De hecho, también puede usar el signo y comenzar un proceso directamente en segundo plano:
```
$ sleep 100 &
[2] 970
```
Junto con el ID de trabajo del nuevo trabajo ([2]), ahora también obtenemos su ID de proceso (970). Ahora ambos trabajos se ejecutan en segundo plano:
```
$ jobs
[1]-  Running                 sleep 60 &
[2]+  Running                 sleep 100 &
```
Un poco más tarde, el primer trabajo finaliza la ejecución:
```
$ jobs
[1]-  Done                    sleep 60
[2]+  Running                 sleep 100 &
```
Termine con una señal SIGTERM con kill:
```
$ kill %2
```
Para asegurarse de que el trabajo ha finalizado, ejecute jobs nuevamente:
```
$ jobs
[2]+  Terminated                 sleep 100
```

Note	Si no se especifica ningún trabajo, `fg` y `bg` actuarán sobre el actual, predeterminado. `kill`, sin embargo, siempre necesita una especificación de trabajo.

Trabajos separados: `nohup`

Los trabajos que hemos visto en las secciones anteriores se adjuntaron a la sesión del usuario que los invocó. Eso significa que si la sesión se termina, los trabajos desaparecen. Sin embargo, es posible separar los trabajos de las sesiones y hacer que se ejecuten incluso después de cerrar la sesión. Esto se logra con el comando nohup (“no hangup”). La sintaxis es la siguiente:

nohup COMMAND &

Recuerde, el & envía el proceso a un segundo plano y libera el terminal en el que está trabajando.

Separemos el trabajo en segundo plano ping localhost de la sesión actual:

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

La salida nos muestra la ID del trabajo ([1]) y el PID (1251), seguido de un mensaje que nos informa sobre el archivo nohup.out. Este es el archivo predeterminado donde se guardarán stdout y stderr. Ahora podemos presionar Ctrl+C para liberar el símbolo del sistema, cerrar la sesión, iniciar otro como root y usar tail -f para verificar si el comando se está ejecutando y la salida se está escribiendo en el archivo predeterminado:

$ 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	En lugar de utilizar el `nohup.out` predeterminado, podría haber especificado el archivo de salida de su elección con `nohup ping localhost > /path/to/your/file &`.

Si queremos matar el proceso, debemos especificar su PID:

# kill 1251

Monitoreo de procesos

Un proceso o tarea es una instancia de un programa en ejecución. Por lo tanto, se crean nuevos procesos cada vez que escribe comandos en el terminal.

El comando watch ejecuta un programa periódicamente (2 segundos por defecto) y nos permite mirar el cambio de salida del programa con el tiempo. Por ejemplo, podemos monitorear cómo cambia el promedio de carga a medida que se ejecutan más procesos escribiendo 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

El comando se ejecuta hasta que se interrumpe, por lo que deberíamos detenerlo con Ctrl+C. Obtenemos dos líneas como salida: la primera corresponde a watch y nos dice con qué frecuencia se ejecutará el comando (Every 2.0s: uptime), qué comando/programa mirar (uptime) así como el comando nombre de host y fecha (debian: mar 20 de agosto 23:31:27 2019). La segunda línea de salida es el tiempo de actividad e incluye la hora (23:31:27), cuánto tiempo ha estado activo el sistema (up 21 min), el número de usuarios activos (1 usuario) y carga promedio del sistema o número de procesos en ejecución o en estado de espera durante los últimos 1, 5 y 15 minutos (promedio de carga: 0.00, 0.00, 0.00).

Del mismo modo, puede verificar el uso de la memoria a medida que se crean nuevos procesos con 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 cambiar el intervalo de actualización para watch use las opciones -n o --interval más el número de segundos como en:

$ watch -n 5 free

Ahora el comando free se ejecutará cada 5 segundos.

Para obtener más información sobre las opciones de uptime, free y watch, consulte sus páginas de manual.

Note	La información proporcionada por `uptime` y `free` también está integrada en las herramientas más completas `top` y `ps` (ver más abajo).

Envío de señales a procesos: `kill`

Cada proceso tiene un identificador de proceso único o PID. Una forma de averiguar el PID de un proceso es mediante el comando pgrep seguido del nombre del proceso:

$ pgrep sleep
1201

Note	El identificador de un proceso también se puede descubrir a través del comando `pidof` (por ejemplo, `pidof sleep`).

Similar a pgrep, el comando pkill mata un proceso basado en su nombre:

$ pkill sleep
[1]+  Terminated              sleep 60

Para matar varias instancias del mismo proceso, se puede usar el comando killall:

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

Tanto pkill como killall funcionan de la misma manera que kill en que envían una señal de terminación a los procesos especificados. Si no se proporciona ninguna señal, se envía el valor predeterminado de SIGTERM. Sin embargo, kill solo toma un trabajo o una ID de proceso como argumento.

Las señales se pueden especificar por:

Nombre:
```
$ kill -SIGHUP 1247
```
Número:
```
$ kill -1 1247
```
Opciones:
```
$ kill -s SIGHUP 1247
```

Para que kill funcione de manera similar a pkill o killall (y nos ahorremos los comandos para descubrir los PID primero) podemos usar la sustitución de comandos:

$ kill -1 $(pgrep sleep)

Como ya debería saber, una sintaxis alternativa es kill -1 `pgrep sleep`.

Tip	Para obtener una lista exhaustiva de todas las señales `kill` y sus códigos, escriba `kill -l` en el terminal. Use `-KILL` (`-9` o `-s KILL`) para matar los procesos rebeldes cuando falla cualquier otra señal.

`top` y `ps`

Cuando se trata de monitoreo de procesos, dos herramientas invaluables son top y ps. Mientras que el primero produce resultados dinámicamente, el segundo lo hace estáticamente. En cualquier caso, ambos son excelentes utilidades para tener una visión integral de todos los procesos en el sistema.

Interactuando con `top`

Para invocar top, simplemente teclee 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
    (...)

top le permite al usuario cierta interacción. Por defecto, la salida se ordena por el porcentaje de tiempo de CPU utilizado por cada proceso en orden descendente. Este comportamiento puede modificarse presionando las siguientes teclas desde top:

M: Odena por uso de memoria.
N: Ordena por número de ID.
T: Ordena por tiempo de ejecución.
P: Ordena por porcentaje de uso en CPU.

Tip	Para cambiar entre orden descendente/ascendente, simplemente presione `R`.

Otras teclas interesantes para interactuar con top son:

? o h: Ayuda.
k: Mata un proceso. top solicitará que se elimine el PID del proceso y que se envíe la señal (por defecto, SIGTERM o 15).
r: Cambiar la prioridad de un proceso (renice). top le pedirá el valor nice. Los valores posibles oscilan entre -20 y 19, pero solo el superusuario (root) puede establecerlo en un valor negativo o inferior al actual.
u: Lista de procesos de un usuario en particular (de forma predeterminada se muestran los procesos de todos los usuarios).
c: Muestra las rutas absolutas de los programas y diferencia entre procesos de espacio de usuario y procesos de espacio de kernel (entre corchetes).
V: Vista de bosque/jerarquía de procesos.
t y m: Cambia el aspecto de las lecturas de CPU y memoria respectivamente en un ciclo de cuatro etapas: las dos primeras pulsaciones muestran barras de progreso, la tercera oculta la barra y la cuarta la recupera.
W: Guardar ajustes de configuración en ~/.toprc.

Tip	Una versión más elegante y fácil de usar de `top` es `htop`. Otra alternativa, quizás más exhaustiva, es `atop`. Si aún no está instalado en su sistema, use su administrador de paquetes para instalarlos y probarlos.

Una explicación de la salida de `top`

La salida top se divide en dos áreas: el área resumen y el área de tareas.

El área de resumen en `top`

El área de resumen se compone de las cinco filas superiores y nos proporciona la siguiente información:

top - 11:10:29 up 2:21, 1 user, load average: 0,11, 0,20, 0,14
- Hora actual (formato 24 horas): 11:20:29
- Tiempo de actividad (cantidad de tiempo que el equipo ha estado activo y funcionando): up 2:21
- Número de usuarios conectados y promedio de carga de la CPU durante los últimos 1, 5 y 15 minutos, respectivamente: load average: 0,11, 0,20, 0,14
Tasks: 73 total, 1 running, 72 sleeping, 0 stopped, 0 zombie (información sobre procesos)
- Número total de procesos en modo activo: 73 total
- Ejecutándose (los ejecutados en el momento): 1 running
- Durmiendo (aquellos que esperan reanudar la ejecución): 72 sleeping
- Detenido (por una señal de control de trabajo): 0 stopped
- Zombie (aquellos que han completado la ejecución pero todavía están esperando que su proceso padre los elimine de la tabla de procesos): 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 (porcentaje de tiempo de CPU empleado)
- Procesos de usuario: 0,0 us
- Procesos de sistema/kernel: 0,4 sy
- Procesos establecidos en un valor nice — cuanto mejor sea el valor, menor será la prioridad: 0,0 ni
- Nada — tiempo de inactividad de la CPU: 99,7 id
- Procesos en espera de operaciones de E/S: 0,0 wa
- Procesos que sirven interrupciones de hardware — periféricos que envían las señales del procesador que requieren atención: 0,0 hi
- Procesos que sirven interrupciones de software: 0,0 si
- Los procesos que sirven las tareas de otras máquinas virtuales en un entorno virtual, por lo tanto, roban tiempo: 0,0 st
KiB Mem : 1020332 total, 909492 free, 38796 used, 72044 buff/cache (Información de memoria en kilobytes)
- Monto total de memoria: 1020332 total
- Memoria sin utilizar: 909492 free
- Memoria en uso: 38796 used
- La memoria intermedia (buffer) y almacenada en caché para evitar el acceso excesivo al disco: 72044 buff/cache
  
  Observe cómo el total es la suma de los otros tres valores — free, used y buff/cache — (aproximadamente 1 GB en nuestro caso).
KiB Swap: 1046524 total, 1046524 free, 0 used. 873264 avail Mem (Información memoria swap en kilobytes)
- La cantidad total de espacio de swap: 1046524 total
- Espacio de swap no utilizado: 1046524 free
- Espacio en uso de swap: 0 used
- La cantidad de memoria de intercambio que se puede asignar a los procesos sin causar más intercambio: 873264 avail Mem

El área de tareas en `top`: campos y columnas

Debajo del área de resumen, aparece el área de tareas, que incluye una serie de campos y columnas de información sobre los procesos en ejecución:

PID: Identificador de proceso.
USER: Usuario que emitió el comando que generó el proceso.
PR: Prioridad de proceso en el kernel.
NI: Valor nice del proceso. Los valores más bajos tienen mayor prioridad que los más altos.
VIRT: Cantidad total de memoria utilizada por el proceso (incluido la swap).
RES: Memoria RAM utilizada por el proceso.
SHR: Memoria compartida del proceso con otros procesos.
S: Estado del proceso. Los valores incluyen: S (suspensión interrumpible — esperando que termine un evento), R (ejecutable — ya sea en ejecución o en la cola que se ejecutará) o Z (procesos secundarios terminados en zombies cuyas estructuras de datos aún no se han eliminado de la tabla de procesos).
%CPU: Porcentaje de CPU utilizado por el proceso.
%MEM: Porcentaje de RAM utilizada por el proceso, es decir, el valor RES expresado como porcentaje.
TIME+: Tiempo total de actividad del proceso.
COMMAND: Nombre del comando/programa que generó el proceso..

Visualización de procesos estáticos: `ps`

Como se dijo anteriormente, ps muestra una instantánea de los procesos. Para ver todos los procesos con un terminal (tty), escriba 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
 (...)

Una explicación de la sintaxis y salida de la opción `ps`

Con respecto a las opciones, ps puede aceptar tres estilos diferentes: BSD, UNIX y GNU. Veamos cómo funcionaría cada uno de estos estilos al informar información sobre un ID de proceso en particular:

BSD

Las opciones no siguen ningún guión inicial:

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

UNIX

Las opciones siguen un guión inicial:

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

GNU

Las opciones van seguidas de guiones dobles iniciales:

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

En los tres casos, ps informa sobre el proceso cuyo PID es 811 — en este caso, bash.

Del mismo modo, puede usar ps para buscar los procesos iniciados por un usuario en particular:

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

Veamos los procesos 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

Comenzó dos procesos: bash (-su) y ps (ps U carol). La columna STAT nos dice el estado del proceso (ver más abajo).

Podemos obtener lo mejor de ps combinando algunas de sus opciones. Un comando muy útil (que produce una salida similar a la de top) es ps aux (estilo BSD). En este caso, se muestran los procesos de todos los shells (no solo el actual). El significado de los interruptores es el siguiente:

a: Mostrar procesos que están conectados a un tty o terminal.
u: Mostrar formato orientado al usuario.
x: Mostrar procesos que no están conectados a un tty o 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]
(...)

Permítanos explicar las columnas:

USER: Dueño del proceso.
PID: Identificador de proceso.
%CPU: Porcentaje de CPU utilizado.
%MEM: Porcentaje de memoria física utilizado.
VSZ: Memoria virtual de procesos en KiB.
RSS: Memoria física no intercambiada utilizada por el proceso en KiB.
TT: Terminal (tty) que controla el proceso.
STAT: Código que representa el estado del proceso. Además de S, R y Z (que vimos al describir la salida de top), otros valores posibles incluyen: D (suspensión ininterrumpida — generalmente esperando E/S), T (detenido — normalmente por una señal de control). Algunos modificadores adicionales incluyen: < (alta prioridad — no agradable para otros procesos), N (baja prioridad — agradable para otros procesos) o + (en el grupo de procesos en primer plano).
STARTED: Hora a la que comenzó el proceso.
TIME: Tiempo de CPU acumulado.
COMMAND: Comando que inició el proceso.

Ejercicios Guiados

oneko es un programa divertido y agradable que muestra un gato persiguiendo el cursor del mouse. Si aún no está instalado en su sistema de escritorio, instálelo utilizando el administrador de paquetes de su distribución. Lo usaremos para estudiar el control del trabajo.
- Inicia el programa. ¿Cómo lo hace?
- Mueva el cursor del mouse para ver cómo lo persigue el gato. Ahora suspenda el proceso. ¿Cómo hace eso? ¿Cuál es el resultado?
- Compruebe cuántos trabajos tiene actualmente. ¿Qué escribe? ¿Cuál es el resultado?
- Ahora envíelo al segundo plano especificando su ID de trabajo. ¿Cuál es el resultado? ¿Cómo puede saber que el trabajo se está ejecutando en segundo plano?
- Finalmente, finalice el trabajo especificando su ID de trabajo. ¿Qué escribes?
Descubra los PID de todos los procesos generados por Apache HTTPD web server (apache2) con dos comandos diferentes:
Termine todos los procesos apache2 sin usar sus PID y con dos comandos diferentes:
Suponga que tiene que terminar todas las instancias de apache2 y no tiene tiempo para averiguar cuáles son sus PID. ¿Cómo lograría eso usando kill con la señal predeterminada SIGTERM en una línea:
Inicie top e interactúe con él realizando lo siguiente:
- Mostrar una vista del bosque de procesos:
- Muestra rutas completas de procesos que diferencian entre espacio de usuario y espacio de kernel:
Escriba el comando ps para mostrar todos los procesos iniciados por Apache HTTPD web server usuario (www-data):
- Usando la sintaxis BSD:
- Usando la sintaxis UNIX:
- Usando la sintaxis de GNU:

Ejercicios Exploratorios

La señal SIGHUP puede usarse como una forma de reiniciar ciertos demonios. Con Apache HTTPD web server, por ejemplo, enviar SIGHUP al proceso padre (el que comenzó con init) mata a sus hijos. Sin embargo, el padre vuelve a leer sus archivos de configuración, vuelve a abrir los archivos de registro y genera un nuevo conjunto de hijos. Realice las siguientes tareas:
- Inicie el servidor web:
- Asegúrese de conocer el PID del proceso principal:
- Haga que el servidor web Apache HTTPD se reinicie enviándole la señal SIGHUP al proceso principal:
- Verifique que el padre no haya sido terminado y que se hayan generado nuevos hijos:
Aunque inicialmente estático, la salida de ps puede volverse dinámica combinando ps y watch. Supervisaremos Apache HTTPD web server para detectar nuevas conexiones. Antes de realizar las tareas descritas a continuación, se recomienda que lea la descripción de la directiva MaxConnectionsPerChild en Apache MPM Common Directives.
- Agregue la directiva MaxConnectionsPerChild con un valor de 1 en el archivo de configuración de apache2 — en Debian y derivados se encuentran en /etc/apache2/apache2.conf; en la familia CentOS, en /etc/httpd/conf/httpd.conf. No olvide reiniciar apache2 para que los cambios surtan efecto.
- Escriba un comando que use watch, ps y grep para las conexiones apache2.
- Ahora abra un navegador web o use un navegador de línea de comandos como lynx para establecer una conexión con el servidor web a través de su dirección IP. ¿Qué observa en la salida de watch?
Como has aprendido, por defecto, top clasifica las tareas por porcentaje de uso de CPU en orden descendente (los valores más altos en la parte superior). Este comportamiento se puede modificar con las teclas interactivas M (uso de memoria), N (identificador único del proceso), T (tiempo de ejecución) y P (porcentaje del tiempo de CPU). Sin embargo, también puede ordenar la lista de tareas a su gusto iniciando top con la opción -o (para obtener más información, consulte la página man de top). Ahora, realice las siguientes tareas:
- Inicie top para que las tareas se ordenen por uso de memoria:
- Verifique que envió el comando correcto resaltando la columna de memoria:
ps también tiene una opción o para especificar las columnas que desea que se muestren. Investigue esta opción y realice las siguientes tareas:
- Inicie ps para que solo se muestre información sobre usuario, porcentaje de memoria utilizada, porcentaje de tiempo de CPU utilizado y comando completo:
- Ahora, ejecute ps para que la única información que se muestre sea la del usuario y el nombre de los programas que están utilizando:

Resumen

En esta lección has aprendido sobre jobs y control de jobs. Los hechos y conceptos importantes a tener en cuenta son:

Los trabajos son procesos que se envían en segundo plano.
Además de un ID de proceso, a los trabajos también se les asigna un ID de trabajo cuando se crean.
Para controlar trabajos, se requiere una especificación de trabajo (jobspec).
Los trabajos se pueden poner en primer plano, enviar a un segundo plano, suspender y finalizar (o matar).
Se puede separar un trabajo del terminal y la sesión en la que se creó.

Asimismo, también hemos discutido el concepto de procesado y monitoreo de procesos. Las ideas más relevantes son:

Los procesos ejecutan programas.
Los procesos pueden ser monitoreados.
Las diferentes utilidades nos permiten encontrar el ID de proceso de los procesos y enviarles señales para finalizarlos.
Las señales se pueden especificar por nombre (por ejemplo, -SIGTERM), número (por ejemplo, -15) u opción (por ejemplo, -s SIGTERM).
top y ps son muy potentes cuando se trata de monitorear procesos. La salida del primero es dinámica y se actualiza constantemente; por otro lado, ps revela la salida estáticamente.

Comandos utilizados en esta lección:

jobs: Mostrar trabajos activos y su estado.
sleep: Retraso por una cantidad de tiempo específica.
fg: Mover trabajos a primer plano.
bg: Mover trabajos a un segundo plano.
kill: Terminar trabajos.
nohup: Separar trabajos de la sesión/terminal.
exit: Salir del shell actual.
tail: Mostrar las líneas más recientes en un archivo.
watch: Ejecuta un comando repetidamente (ciclo de 2 segundos por defecto).
uptime: Mostrar cuánto tiempo ha estado funcionando el sistema, la cantidad de usuarios actuales y el promedio de carga del sistema.
free: Mostrar uso de memoria.
pgrep: Buscar la identificación del proceso basada en el nombre.
pidof: Buscar la identificación del proceso basada en el nombre.
pkill: Enviar señal para procesar por nombre.
killall: Eliminar procesos por nombre.
top: Mostrar procesos de Linux.
ps: Informar en un momento dado de los procesos actuales.

Respuestas a los ejercicios guiados

oneko es un programa divertido y agradable que muestra un gato persiguiendo el cursor del mouse. Si aún no está instalado en su sistema de escritorio, instálelo utilizando el administrador de paquetes de su distribución. Lo usaremos para estudiar el control del trabajo.
- Inicie el programa. ¿Cómo lo hace?
  
  Teclee oneko en la terminal.
- Mueva el cursor del mouse para ver cómo lo persigue el gato. Ahora suspenda el proceso. ¿Cómo hace eso? ¿Cuál es el resultado?
  
  Presione Ctrl+z:
  [1]+ Stopped oneko
- Compruebe cuántos trabajos tiene actualmente. ¿Qué escribe? ¿Cuál es el resultado?
  $ jobs [1]+ Stopped oneko
- Ahora envíelo al fondo especificando su ID de trabajo. ¿Cuál es el resultado? ¿Cómo puede saber que el trabajo se está ejecutando en segundo plano?
  $ bg %1 [1]+ oneko &
  El gato se mueve de nuevo.
- Finalmente, finalice el trabajo especificando su ID de trabajo. ¿Qué escribe?
  $ kill %1
Descubra los PID de todos los procesos generados por Apache HTTPD web server (apache2) con dos comandos diferentes:
```
$ pgrep apache2
```
o
```
$ pidof apache2
```
Termine todos los procesos apache2 sin usar sus PID y con dos comandos diferentes:
```
$ pkill apache2
```
o
```
$ killall apache2
```
Suponga que tiene que terminar todas las instancias de apache2 y no tiene tiempo para averiguar cuáles son sus PID. ¿Cómo lograría eso usando kill con la señal predeterminada SIGTERM en una línea:
```
$ kill $(pgrep apache2)
$ kill `pgrep apache2`
```
o
```
$ kill $(pidof apache2)
$ kill `pidof apache2`
```
Note

Dado que SIGTERM (15) es la señal predeterminada, no es necesario pasar ninguna opción para kill.
Inicie top e interactúe con él realizando lo siguiente:
- Mostrar una vista del bosque de procesos:
  
  Presione V.
- Muestra rutas completas de procesos que diferencian entre espacio de usuario y espacio de kernel:
  
  Presione c.
Escriba el comando ps para mostrar todos los procesos iniciados por Apache HTTPD web server usuario (www-data):
- Usando la sintaxis BSD:
  $ ps U www-data
- Usando la sintaxis UNIX:
  $ ps -u www-data
- Usando la sintaxis de GNU:
  $ ps --user www-data

Respuestas a ejercicios exploratorios

La señal SIGHUP puede usarse como una forma de reiniciar ciertos demonios. Con el Apache HTTPD web server, por ejemplo, enviar SIGHUP al proceso padre (el que comenzó con init) mata a sus hijos. Sin embargo, el padre vuelve a leer sus archivos de configuración, vuelve a abrir los archivos de registro y genera un nuevo conjunto de hijos. Realice las siguientes tareas:
- Inicie el servidor web:
  $ sudo systemctl start apache2
- Asegúrese de conocer el PID del proceso principal:
  $ ps aux | grep apache2
  El proceso padre es el iniciado por el usuario root. En nuestro caso el que tiene PID 1653.
- Haga que el servidor web Apache HTTPD se reinicie enviándole la señal SIGHUP al proceso principal:
  $ kill -SIGHUP 1653
- Verifique que el padre no haya sido terminado y que se hayan generado nuevos hijos:
  $ ps aux | grep apache2
  Ahora debería ver el proceso padre apache2 junto con dos hijos nuevos.
Aunque inicialmente estático, la salida de ps puede volverse dinámica combinando ps y watch. Supervisaremos Apache HTTPD web server para detectar nuevas conexiones. Antes de realizar las tareas descritas a continuación, se recomienda que lea la descripción de la directiva MaxConnectionsPerChild en Apache MPM Common Directives.
- Agregue la directiva MaxConnectionsPerChild con un valor de 1 en el archivo de configuración de apache2 — en Debian y derivados se encuentran en /etc/apache2/apache2.conf; en la familia CentOS, en /etc/httpd/conf/httpd.conf. No olvide reiniciar apache2 para que los cambios surtan efecto.
  
  La línea a incluir en el archivo de configuración es MaxConnectionsPerChild 1. Una forma de reiniciar el servidor web es a través de sudo systemctl restart apache2.
- Escriba un comando que use watch, ps y grep para las conexiones apache2.
  $ watch 'ps aux | grep apache2'
  o
  $ watch "ps aux | grep apache2"
- Ahora abra un navegador web o use un navegador de línea de comandos como lynx para establecer una conexión con el servidor web a través de su dirección IP. ¿Qué observas en la salida de watch?
  
  Uno de los procesos secundarios propiedad de www-data desaparece.
Como has aprendido, por defecto, top clasifica las tareas por porcentaje de uso de CPU en orden descendente (los valores más altos en la parte superior). Este comportamiento se puede modificar con las teclas interactivas M (uso de memoria), N (identificador único del proceso), T (tiempo de ejecución) y P (porcentaje del tiempo de CPU). Sin embargo, también puede ordenar la lista de tareas a su gusto iniciando top con la opción -o (para obtener más información, consulte la página man de top). Ahora, realice las siguientes tareas:
- Inicie top para que las tareas se ordenen por uso de memoria:
  $ top -o %MEM
- Verifique que escribió el comando correcto resaltando la columna de memoria:
  
  Presione x.
ps también tiene una opción o para especificar las columnas que desea que se muestren. Investigue esta opción y realice las siguientes tareas:
- Inicie ps para que solo se muestre información sobre usuario, porcentaje de memoria utilizada, porcentaje de tiempo de CPU utilizado y comando completo:
  $ ps o user,%mem,%cpu,cmd
- Ahora, ejecute ps para que la única información que se muestre sea la del usuario y el nombre de los programas que están utilizando:
  $ ps o user,comm