Finalización de procesos en Linux

Introducción

En este laboratorio, aprenderá las habilidades esenciales de gestión de procesos en Linux, centrándose en cómo identificar y terminar procesos. La gestión de procesos es una habilidad fundamental para cualquier usuario o administrador de Linux, ya que le permite administrar los recursos del sistema de manera efectiva.

Aprenderá cómo usar el comando ps para identificar los procesos en ejecución y el comando kill para terminar los procesos cuando sea necesario. Estas herramientas son esenciales para mantener el rendimiento del sistema y tratar con aplicaciones no respondientes.

Al final de este laboratorio, podrá identificar procesos, entender sus atributos y terminar los procesos utilizando varios métodos. Estas habilidades son valiosas para solucionar problemas y administrar sistemas Linux de manera eficiente.

Identificación de Procesos

En Linux, cada programa o aplicación en ejecución se considera un proceso. Cada proceso tiene un identificador único llamado Identificador de Proceso (Process ID, PID). Antes de poder terminar un proceso, debes identificarlo utilizando su PID.

Comencemos aprendiendo cómo ver los procesos en ejecución utilizando el comando ps. Este comando muestra información sobre los procesos activos en tu sistema.

Primero, abre una terminal en el entorno de la máquina virtual (VM) de LabEx y ejecuta el siguiente comando:

ps

Verás una lista básica de los procesos que se están ejecutando en tu sesión de terminal actual. La salida debería ser similar a esta:

  PID TTY          TIME CMD
 2104 pts/0    00:00:00 zsh
 2116 pts/0    00:00:00 ps

Esta salida muestra:

PID: El número de Identificador de Proceso
TTY: El tipo de terminal en la que se está ejecutando el proceso
TIME: La cantidad de tiempo de CPU que ha utilizado el proceso
CMD: El comando que inició el proceso

Para ver una lista más completa de todos los procesos en ejecución en el sistema, utiliza el siguiente comando con opciones adicionales:

ps -aux

Las opciones significan:

-a: Muestra los procesos de todos los usuarios
-u: Muestra un formato detallado orientado al usuario
-x: Incluye los procesos sin un terminal de control

La salida será mucho más larga y detallada, mostrando todos los procesos en ejecución en el sistema:

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.1 167936 11876 ?        Ss   10:30   0:01 /sbin/init
root           2  0.0  0.0      0     0 ?        S    10:30   0:00 [kthreadd]
...
labex       2104  0.0  0.1  11108  5456 pts/0    Ss   10:35   0:00 zsh
labex       2130  0.0  0.0   9828  3384 pts/0    R+   10:36   0:00 ps -aux

Ahora, creemos un simple proceso en segundo plano que podamos utilizar para practicar:

sleep 300 &
sleep_pid=$!

Este comando inicia un proceso que "dormirá" (no hará nada) durante 300 segundos (5 minutos). El símbolo & lo ejecuta en segundo plano, y $! captura el PID del último proceso en segundo plano iniciado.

Verifiquemos que el proceso está en ejecución:

echo "The sleep process ID is: $sleep_pid"
ps | grep sleep

Deberías ver una salida similar a:

The sleep process ID is: 2135
 2135 pts/0    00:00:00 sleep

Ahora sabes cómo identificar procesos y encontrar sus PIDs. En el siguiente paso, aprenderemos cómo terminar este proceso.

Finalización de Procesos con 'kill'

Ahora que has identificado un proceso y su PID, puedes aprender cómo terminarlo utilizando el comando kill. El comando kill envía una señal a un proceso, instruyéndolo a terminar.

La sintaxis básica del comando kill es:

kill [options] <PID>

Vamos a terminar el proceso sleep que creamos en el paso anterior. Almacenamos su PID en la variable $sleep_pid. Utiliza el siguiente comando para terminarlo:

kill $sleep_pid

Si has olvidado el PID, puedes encontrarlo de nuevo utilizando:

ps | grep sleep

Después de ejecutar el comando kill, verifica que el proceso se haya terminado:

ps | grep sleep

Si el proceso se terminó correctamente, no deberías ver ninguna salida o solo el propio proceso grep en la salida. Esto significa que el proceso sleep ya no está en ejecución.

Si quieres ser exhaustivo, puedes utilizar el comando ps de nuevo para listar todos los procesos:

ps -aux | grep sleep

Esto podría mostrar algo como:

labex       2156  0.0  0.0   7236   720 pts/0    S+   10:40   0:00 grep --color=auto sleep

El único proceso mostrado es el propio comando grep, lo que indica que el proceso sleep se ha terminado.

Por defecto, el comando kill envía una señal TERM (terminar) al proceso, lo que permite que el proceso salga de forma elegante después de realizar cualquier operación de limpieza. En la mayoría de los casos, esto es suficiente para terminar un proceso.

Ahora has identificado y terminado un proceso con éxito utilizando el comando kill, que es una habilidad fundamental para la gestión de procesos en Linux.

Comprender las Señales de Kill

En Linux, el comando kill puede enviar varios tipos de señales a los procesos, no solo señales de terminación. Comprender estas señales te da más control sobre cómo se terminan los procesos.

Primero, veamos todas las señales disponibles ejecutando:

kill -l

Esto listará todas las señales que el comando kill puede enviar. La salida se ve así:

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
...

Las señales más comúnmente utilizadas son:

SIGTERM (15): Señal predeterminada enviada por el comando kill. Pide al proceso que se termine de forma elegante.
SIGKILL (9): Fuerza al proceso a terminar inmediatamente. Úsala cuando un proceso no responde a SIGTERM.
SIGHUP (1): Tradicionalmente se utiliza para restablecer o recargar archivos de configuración.
SIGINT (2): Se envía cuando presionas Ctrl+C en la terminal.

Vamos a crear otro proceso sleep para practicar:

sleep 300 &
sleep_pid=$!
echo "The new sleep process ID is: $sleep_pid"

Ahora, vamos a enviar una señal específica al proceso utilizando el número de la señal:

kill -15 $sleep_pid

Esto es equivalente al comando kill predeterminado, ya que envía SIGTERM (señal 15).

Verifica que el proceso se haya terminado:

ps | grep sleep

Vamos a crear un proceso sleep más para demostrar la señal SIGKILL:

sleep 300 &
sleep_pid=$!
echo "The third sleep process ID is: $sleep_pid"

Ahora, vamos a utilizar la señal SIGKILL para terminar el proceso de forma forzada:

kill -9 $sleep_pid

Verifica que el proceso se haya terminado:

ps | grep sleep

La señal SIGKILL (9) es una opción de "último recurso" porque:

No permite que el proceso se limpie a sí mismo.
Puede dejar los recursos en un estado inconsistente.
Puede causar pérdida de datos si el proceso estaba escribiendo datos.

Siempre intenta SIGTERM primero y solo utiliza SIGKILL si el proceso no responde a SIGTERM.

Gestión Avanzada de Procesos

Linux ofrece comandos adicionales para la gestión de procesos más allá de los comandos básicos ps y kill. Estas herramientas brindan más flexibilidad y comodidad para identificar y terminar procesos.

El Comando `pgrep`

El comando pgrep te permite encontrar procesos por nombre en lugar de tener que examinar visualmente la salida de ps:

pgrep sleep

Este comando encontrará todos los procesos que tengan "sleep" en su nombre y mostrará sus PIDs.

El Comando `pkill`

El comando pkill combina la funcionalidad de pgrep y kill; encuentra procesos por nombre y les envía una señal:

## Start two sleep processes
sleep 300 &
sleep 300 &

## Kill all sleep processes
pkill sleep

Verifica que todos los procesos sleep se hayan terminado:

ps | grep sleep

El Comando `killall`

Similar a pkill, el comando killall termina procesos por nombre:

## Start two more sleep processes
sleep 300 &
sleep 300 &

## Kill all sleep processes
killall sleep

Verifica una vez más:

ps | grep sleep

Prioridad de Procesos con `nice` y `renice`

Linux también te permite controlar la prioridad de los procesos utilizando los comandos nice y renice.

Comencemos un proceso con una prioridad más baja:

nice -n 10 sleep 300 &

El valor de nice oscila entre -20 (prioridad más alta) y 19 (prioridad más baja). El valor predeterminado es 0. Solo el usuario root puede establecer valores de nice negativos.

Puedes cambiar la prioridad de un proceso en ejecución utilizando renice:

sleep_pid=$!
echo "Sleep process ID with lower priority: $sleep_pid"
renice -n 15 -p $sleep_pid

Veamos la nueva prioridad:

ps -o pid,nice,cmd -p $sleep_pid

Finalmente, terminemos este proceso:

kill $sleep_pid

Estos comandos de gestión avanzada de procesos ofrecen formas más eficientes de gestionar múltiples procesos y controlar los recursos del sistema, lo cual es especialmente útil en sistemas ocupados o cuando se solucionan problemas de rendimiento.

Resumen

En este laboratorio, has aprendido habilidades esenciales de gestión de procesos en Linux que son valiosas para la administración de sistemas y la resolución de problemas:

Identificación de Procesos: Aprendiste cómo usar el comando ps para listar los procesos en ejecución y encontrar sus Identificadores de Proceso (PIDs).
Terminación de Procesos: Practicaste el uso del comando kill para enviar señales de terminación a los procesos utilizando sus PIDs.
Comprensión de las Señales de 'kill': Exploraste diferentes tipos de señales que se pueden enviar a los procesos, incluyendo SIGTERM (15) para una terminación elegante y SIGKILL (9) para una terminación forzada.
Gestión Avanzada de Procesos: Descubriste herramientas más poderosas como pgrep, pkill y killall para encontrar y terminar procesos por nombre, así como cómo controlar la prioridad de los procesos con nice y renice.

Estas habilidades te permiten:

Monitorear eficazmente los procesos del sistema.
Terminar aplicaciones no respondientes.
Gestionar los recursos del sistema.
Solucionar problemas de rendimiento.

La gestión de procesos es un aspecto fundamental de la administración de sistemas Linux, y los comandos que aprendiste en este laboratorio son utilizados diariamente por administradores y usuarios de Linux para mantener el rendimiento y la estabilidad del sistema.