Monitorizar Procesos en Red Hat Enterprise Linux

Introducción

En este laboratorio, obtendrás experiencia práctica en la monitorización y gestión de procesos Linux, una habilidad fundamental para cualquier administrador de sistemas o desarrollador. Aprenderás a comprender los estados y ciclos de vida de los procesos utilizando ps y top, controlar trabajos en segundo plano y en primer plano, y terminar procesos eficazmente con kill, killall y pkill. Además, explorarás cómo monitorizar la carga del sistema y el uso de la CPU utilizando uptime y lscpu, y analizarás la actividad de los procesos en detalle con top. Este laboratorio te proporcionará las herramientas y conocimientos esenciales para gestionar procesos de forma eficiente y mantener la salud del sistema en RHEL.

Comprender los Estados y el Ciclo de Vida de los Procesos con ps y top

En este paso, aprenderás sobre los estados de los procesos de Linux y su ciclo de vida. Comprender los estados de los procesos es crucial para monitorizar y gestionar los recursos del sistema de forma eficaz. Utilizarás los comandos ps y top para observar los procesos y sus estados.

Cada proceso en Linux tiene un estado que describe su actividad actual. Estos estados están definidos por el kernel e indican si un proceso está en ejecución, durmiendo, detenido o en otras condiciones.

Empecemos examinando los estados de los procesos utilizando el comando ps. El comando ps proporciona una instantánea de los procesos actuales.

Primero, abre tu terminal. Puedes hacerlo haciendo clic en el icono del terminal en el escritorio o pulsando Ctrl+Alt+T. Tu directorio de trabajo predeterminado es ~/project.

Para ver todos los procesos en ejecución en tu sistema, incluyendo aquellos sin terminal de control, utiliza el comando ps aux. Las opciones aux muestran los procesos de todos los usuarios (a), los procesos sin terminal de control (x), y presentan un formato orientado al usuario (u).

ps aux

Verás una larga lista de procesos. Presta atención a la columna STAT, que muestra el estado de cada proceso. Los estados comunes que podrías observar incluyen:

• R: En ejecución o listo (en la CPU o esperando para ejecutarse)
• S: Sueño interrumpible (esperando a que se complete un evento)
• D: Sueño no interrumpible (esperando E/S, no se puede interrumpir)
• T: Detenido (suspendido por una señal)
• Z: Zombie (proceso terminado, pero el padre no ha recogido su estado de salida)

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.2 171820 16140 ?        Ss   HH:MM   0:01 /usr/lib/systemd/systemd ...
root           2  0.0  0.0      0     0 ?        S    HH:MM   0:00 [kthreadd]
labex       3448  0.0  0.2 266904  3836 pts/0    R+   HH:MM   0:00 ps aux
...output omitted...

A continuación, utilicemos el comando ps -ef. Este comando proporciona una lista completa (f) de todos los procesos (e), mostrando más detalles como el ID del proceso padre (PPID), la utilización de la CPU (C), la hora de inicio (STIME) y el comando (CMD).

ps -ef

Esta salida se utiliza a menudo para ver las relaciones padre-hijo entre los procesos, aunque no muestra explícitamente una estructura de árbol.

UID        PID  PPID  C STIME TTY          TIME CMD
root           1       0  0 HH:MM ?        00:00:01 /usr/lib/systemd/systemd ...
root           2       0  0 HH:MM ?        00:00:00 [kthreadd]
root           3       2  0 HH:MM ?        00:00:00 [rcu_gp]
...output omitted...

Para visualizar la jerarquía de procesos, puedes usar la opción ps --forest. Esto muestra los procesos en un formato de árbol, lo que facilita la comprensión de qué procesos generaron otros.

ps --forest

Este comando es particularmente útil para la depuración y la comprensión de cómo se estructuran los diferentes servicios y aplicaciones en tu sistema.

  PID TTY          TIME CMD
 2768 pts/0    00:00:00 bash
 5947 pts/0    00:00:00  \_ sleep 10000
 6377 pts/0    00:00:00  \_ ps --forest
...output omitted...

Ahora, exploremos el comando top, que proporciona una vista dinámica en tiempo real de un sistema en ejecución. Muestra un resumen de la información del sistema y una lista de procesos o hilos que el kernel de Linux gestiona actualmente.

Ejecuta el comando top:

top

Verás una pantalla interactiva. La sección superior proporciona información resumida del sistema, incluyendo tiempo de actividad, promedio de carga, resumen de tareas, estadísticas de la CPU y uso de memoria. La sección inferior lista los procesos individuales, ordenados por uso de CPU de forma predeterminada.

En la salida de top, observa la columna S para los estados de los procesos, similar a ps. También puedes ver %CPU (porcentaje de uso de CPU) y %MEM (porcentaje de uso de memoria) para cada proceso.

top - HH:MM:SS up DD min,  X users,  load average: X.XX, X.XX, X.XX
Tasks: XXX total,   X running, XXX sleeping,   X stopped,   X zombie
%Cpu(s):  X.X us,  X.X sy,  X.X ni, XX.X id,  X.X wa,  X.X hi,  X.X si,  X.X st
MiB Mem :   XXXX.X total,   XXXX.X free,    XXX.X used,    XXX.X buff/cache
MiB Swap:   XXXX.X total,   XXXX.X free,      X.X used.   XXXX.X avail Mem

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
XXXX labex     20   0  XXXXXX   XXXX   XXXX R   X.X   X.X   0:00.0X top
...output omitted...

Mientras top esté en ejecución, puedes pulsar q para salir y volver a la solicitud de tu terminal.

Comprender estos comandos y la información que proporcionan es fundamental para monitorizar y solucionar problemas de procesos en un sistema Linux.

Controlar Tareas en Primer Plano y Fondo

En este paso, aprenderás a gestionar tareas en segundo plano y primer plano dentro de tu sesión de shell. Esta es una habilidad fundamental para un uso eficiente de la línea de comandos, que te permite ejecutar tareas largas sin bloquear tu terminal.

Una "tarea" en el contexto de un shell se refiere a un comando o una secuencia de comandos que el shell está gestionando. Puedes ejecutar tareas en segundo plano, llevarlas al primer plano o suspenderlas.

Empecemos ejecutando un comando simple en segundo plano. Usaremos el comando sleep, que simplemente espera una cantidad de tiempo especificada.

Para ejecutar sleep 10000 (que espera 10000 segundos) en segundo plano, añade un ampersand (&) al comando:

sleep 10000 &

Al pulsar Intro, el shell volverá inmediatamente al indicador, y el comando sleep se ejecutará en segundo plano. Verás una salida similar a esta, que indica el número de tarea y su ID de proceso (PID):

[1] 5947

[1] indica que esta es la tarea número 1 en tu sesión de shell actual, y 5947 es el PID del proceso sleep.

Para ver una lista de todas las tareas gestionadas actualmente por tu shell, utiliza el comando jobs:

jobs

Deberías ver el comando sleep listado como una tarea en segundo plano en ejecución:

[1]+ Running    sleep 10000 &

El + junto a [1] indica que esta es la tarea actual (la que se actuaría por defecto si no especificas un número de tarea).

Ahora, llevemos esta tarea en segundo plano al primer plano. Esto significa que la tarea volverá a controlar tu terminal. Usa el comando fg seguido del número de tarea (prefijado con %):

fg %1

El comando sleep 10000 ahora estará en primer plano. Tu terminal estará ocupado por este comando, y no obtendrás un indicador hasta que termine o se suspenda.

sleep 10000

Mientras un comando se ejecuta en primer plano, puedes enviarlo al segundo plano y suspenderlo pulsando Ctrl+Z. Esto envía una señal SIGTSTP al proceso.

Pulsa Ctrl+Z ahora:

^Z

Verás una salida que indica que la tarea se ha detenido y se ha movido al segundo plano:

[1]+  Stopped                 sleep 10000

Ahora, si vuelves a ejecutar jobs, verás que el comando sleep está en estado Detenido:

jobs

[1]+ Stopped                 sleep 10000

Para reanudar una tarea en segundo plano detenida, puedes usar el comando bg seguido del número de tarea. Esto reiniciará la tarea en segundo plano.

bg %1

La tarea ahora se ejecutará de nuevo en segundo plano:

[1]+ sleep 10000 &

Finalmente, limpiemos la tarea en segundo plano. Puedes terminar una tarea en segundo plano usando el comando kill con su PID, o llevándola al primer plano y terminándola (por ejemplo, con Ctrl+C). Por ahora, vamos a llevarla al primer plano y terminarla.

fg %1

Ahora que sleep 10000 está en primer plano, pulsa Ctrl+C para terminarla. Esto envía una señal SIGINT al proceso.

^C

Verás un mensaje que indica que la tarea se ha terminado:

[1]+  Terminated              sleep 10000

Si vuelves a ejecutar jobs, no debería aparecer ninguna tarea:

jobs

(no output)

Esto demuestra el flujo de trabajo básico para gestionar tareas en segundo plano y primer plano, esencial para la multitarea en la terminal.

Terminar Procesos con kill, killall y pkill

En este paso, aprenderás a terminar procesos utilizando los comandos kill, killall y pkill. Estos comandos son esenciales para gestionar los recursos del sistema y detener aplicaciones que se comportan mal.

Los procesos en Linux responden a señales. Una señal es una interrupción de software enviada a un proceso. Diferentes señales tienen diferentes significados, como terminar un proceso, suspenderlo o hacer que vuelva a cargar su configuración.

Primero, comprendamos algunas señales fundamentales de gestión de procesos:

• SIGTERM (15): La señal predeterminada enviada por kill. Es una solicitud "educada" para terminar. El proceso puede capturar esta señal, realizar la limpieza necesaria y luego salir.
• SIGKILL (9): Una señal "no bloqueable" que fuerza la terminación inmediata. El proceso no puede ignorar ni manejar esta señal. Úsala como último recurso.
• SIGHUP (1): A menudo se utiliza para indicar a un proceso que vuelva a cargar sus archivos de configuración sin reiniciarlo.
• SIGINT (2): Enviada al pulsar Ctrl+C, normalmente utilizada para interrumpir un proceso en primer plano.
• SIGSTOP (19): Suspende un proceso. No se puede bloquear ni manejar.
• SIGCONT (18): Reanuda un proceso detenido.

Puedes listar todas las señales disponibles y sus números usando kill -l:

kill -l

Verás una lista de señales como esta:

 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
...output omitted...

Usando kill

El comando kill envía una señal especificada a un proceso identificado por su ID de proceso (PID).

Creemos algunos procesos en segundo plano para practicar su terminación. Usaremos comandos sleep de nuevo.

sleep 300 &
sleep 301 &
sleep 302 &

Ahora, usa jobs para ver sus números de tarea y PID:

jobs

[1] 1234
[2] 1235
[3] 1236

(Nota: Tus PID serán diferentes.)

Busquemos el PID del primer proceso sleep. Puedes usar ps aux | grep sleep y buscar el PID asociado con sleep 300.

ps aux | grep sleep

Verás una salida similar a esta. Identifica el PID de sleep 300. Por ejemplo, si el PID es 1234:

labex       1234  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 300
labex       1235  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 301
labex       1236  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 302
labex       1237  0.0  0.0   6000  1000 pts/0    S+   HH:MM   0:00 grep sleep

Para terminar sleep 300 usando la señal predeterminada SIGTERM, usa kill seguido de su PID. Reemplaza 1234 con el PID real que encontraste:

kill 1234

Podrías ver un mensaje como [1]+ Terminated sleep 300. Verifica que ha desaparecido usando jobs o ps aux | grep sleep:

jobs

[2]- Running    sleep 301 &
[3]+ Running    sleep 302 &

Ahora, terminemos sleep 301 de forma forzosa usando SIGKILL. Encuentra su PID (por ejemplo, 1235) y usa kill -9 o kill -SIGKILL:

kill -9 1235

Probablemente verás [2]- Killed sleep 301. Verifica de nuevo:

jobs

[3]+ Running    sleep 302 &

(Continúa con las secciones killall y pkill de forma similar)

Monitorizar la Carga del Sistema y el Uso de la CPU con uptime y lscpu

En este paso, aprenderás a monitorizar la carga media del sistema y el uso de la CPU utilizando los comandos uptime y lscpu. Comprender estas métricas es crucial para evaluar el rendimiento del sistema e identificar posibles cuellos de botella.

Entendiendo la Carga Media con uptime

El comando uptime proporciona una visión general rápida de cuánto tiempo ha estado funcionando tu sistema, cuántos usuarios están conectados y, lo más importante, la carga media del sistema. La carga media indica el número medio de procesos que están en estado ejecutable o no interrumpible durante un período de tiempo.

Ejecuta el comando uptime:

uptime

Verás una salida similar a esta:

 HH:MM:SS up DD min,  X users,  load average: X.XX, X.XX, X.XX

Desglosemos la salida:

• HH:MM:SS: La hora actual.
• up DD min: El tiempo que el sistema ha estado funcionando (tiempo de actividad).
• X users: El número de usuarios conectados actualmente.
• load average: X.XX, X.XX, X.XX: Estos tres números representan la carga media del sistema durante los últimos 1, 5 y 15 minutos, respectivamente.

Una carga media de 1.00 en una CPU de un solo núcleo significa que la CPU está completamente utilizada. En una CPU multinúcleo, una carga media igual al número de núcleos de CPU significa que el sistema está completamente utilizado. Por ejemplo, en una CPU de 4 núcleos, una carga media de 4.00 indica una utilización completa. Si la carga media supera constantemente el número de núcleos de CPU, sugiere que tu sistema está sobrecargado y los procesos están esperando tiempo de CPU.

Determinar los Núcleos de la CPU con lscpu

Para interpretar correctamente la carga media, necesitas saber cuántos núcleos lógicos de CPU tiene tu sistema. El comando lscpu proporciona información detallada sobre la arquitectura de la CPU.

Ejecuta el comando lscpu:

lscpu

Verás una salida extensa. Busca la línea CPU(s):, que te indica el número total de CPUs lógicas disponibles. Además, Core(s) per socket: y Socket(s): pueden ayudarte a comprender la disposición física.

Architecture:        x86_64
CPU op-mode(s):      32-bit, 64-bit
Byte Order:          Little Endian
CPU(s):              4
On-line CPU(s) list: 0-3
Thread(s) per core:  2
Core(s) per socket:  2
Socket(s):           1
NUMA node(s):        1
...output omitted...

En el ejemplo anterior, CPU(s): 4 indica que este sistema tiene 4 núcleos de CPU lógicos.

Interpretando la Carga Media y los Núcleos de la CPU

Combinemos la información de uptime y lscpu. Supongamos que tu salida de uptime muestra una carga media de 2.92, 4.48, 5.20 y lscpu muestra CPU(s): 4.

Para obtener la carga media por CPU, divide cada número de carga media por el número total de CPUs lógicas:

• Últimos 1 minuto: 2.92 / 4 = 0.73
• Últimos 5 minutos: 4.48 / 4 = 1.12
• Últimos 15 minutos: 5.20 / 4 = 1.30

Basándonos en estos cálculos:

• En los últimos 1 minuto, las CPUs se utilizaron aproximadamente al 73% de su capacidad.
• En los últimos 5 minutos, el sistema estaba sobrecargado en aproximadamente un 12% (1.12 - 1.00 = 0.12). Esto significa que los procesos estaban esperando tiempo de CPU.
• En los últimos 15 minutos, el sistema estaba sobrecargado en aproximadamente un 30% (1.30 - 1.00 = 0.30).

Este análisis sugiere que el sistema estuvo bajo una carga significativa durante los últimos 5 y 15 minutos, pero la carga ha disminuido en el último minuto. Este tipo de análisis de tendencias es crucial para comprender la salud del sistema.

Estos dos comandos, uptime y lscpu, son herramientas simples pero potentes para evaluar rápidamente la salud y el rendimiento general de tu sistema Linux.

Analizar la Actividad de los Procesos con top

En este paso, profundizarás en el uso del comando top para analizar la actividad de los procesos. Si bien top proporciona una vista en tiempo real, también ofrece potentes funciones interactivas para ordenar, filtrar y gestionar procesos.

Recuerda del paso anterior que top proporciona una vista dinámica de tu sistema. Iniciemos top de nuevo:

top

Verás la familiar interfaz de top. La sección superior proporciona estadísticas del sistema en general, y la sección inferior lista los procesos.

Entendiendo las Columnas de top

Revisemos las columnas predeterminadas en la lista de procesos:

• PID: ID de proceso.
• USER: El propietario del proceso.
• PR: Prioridad del proceso.
• NI: Valor Nice del proceso (un valor Nice más bajo significa una prioridad más alta).
• VIRT: Memoria virtual utilizada por el proceso.
• RES: Memoria residente (RAM física) utilizada por el proceso.
• SHR: Memoria compartida utilizada por el proceso.
• S: Estado del proceso (R=En ejecución, S=Dormido, D=Dormido no interrumpible, T=Detenido, Z=Zombie).
• %CPU: Porcentaje de uso de la CPU desde la última actualización.
• %MEM: Porcentaje de uso de memoria (RES / memoria física total).
• TIME+: Tiempo total de CPU utilizado por el proceso desde su inicio.
• COMMAND: El nombre del comando que inició el proceso.

Teclas Interactivas en top

top es altamente interactivo. Puedes presionar varias teclas para cambiar su visualización e interactuar con los procesos.

1. Ordenar Procesos:

   • Presiona Mayús+P (P mayúscula) para ordenar los procesos por uso de CPU (%CPU), que suele ser el predeterminado.
   • Presiona Mayús+M (M mayúscula) para ordenar los procesos por uso de memoria (%MEM).
   • Presiona Mayús+T (T mayúscula) para ordenar los procesos por TIME+.

   Prueba presionando Mayús+M ahora para ordenar por uso de memoria. Observa cómo la lista de procesos se reordena. Luego presiona Mayús+P para volver a ordenar por CPU.

2. Filtrar por Usuario:

   • Presiona u (u minúscula). top te pedirá un nombre de usuario. Escribe labex y presiona Intro.
   • Ahora, top solo mostrará los procesos propiedad del usuario labex. Esto es muy útil para centrarse en tus propios procesos.
   • Para borrar el filtro y mostrar todos los usuarios de nuevo, presiona u y luego presiona Intro sin escribir un nombre de usuario.

3. Cambiar el Intervalo de Actualización:

   • De forma predeterminada, top se actualiza cada 3 segundos. Puedes cambiar este intervalo.
   • Presiona s (s minúscula). top te pedirá un tiempo de retraso. Introduce 1 (para 1 segundo) y presiona Intro.
   • Observa cómo la visualización se actualiza con más frecuencia.
   • Puedes cambiarlo de nuevo a 3 segundos presionando s de nuevo e introduciendo 3.

4. Matar un Proceso:

   • Puedes terminar un proceso directamente desde top.
   • Primero, creemos un proceso sleep en segundo plano en una nueva pestaña o ventana de terminal, o presionando Ctrl+Z en tu terminal actual, luego bg para poner top en segundo plano, luego ejecuta sleep 600 &, luego fg para traer top de nuevo al primer plano.
   • Alternativamente, puedes abrir una nueva pestaña de terminal (por ejemplo, Ctrl+Shift+T en muchos terminales) y ejecutar sleep 600 & allí.
   • Una vez que tengas un proceso sleep en ejecución, vuelve a tu terminal top.
   • Presiona k (k minúscula). top te pedirá el PID del proceso que quieres matar.
   • Busca el PID de tu proceso sleep 600 en la lista de top. Introduce ese PID y presiona Intro.
   • top te pedirá la señal que quieres enviar. El valor predeterminado es 15 (SIGTERM). Presiona Intro para enviar SIGTERM.
   • El proceso sleep debería desaparecer de la lista. Si no lo hace, puedes intentar k de nuevo y enviar la señal 9 (SIGKILL).

5. Cambiar la Prioridad de un Proceso (Renicing):

   • Cambiar la prioridad de un proceso. Un valor Nice más bajo significa una prioridad más alta.
   • Presiona r (r minúscula). top te pedirá un PID y luego un valor Nice (por ejemplo, -10 para una prioridad más alta, 10 para una prioridad más baja).
   • Esta es una función avanzada para gestionar los recursos del sistema. Para este laboratorio, simplemente presiona r, luego Intro dos veces para cancelar la operación sin cambiar nada.

6. Salir de top:

   • Cuando hayas terminado, presiona q (q minúscula) para salir de top y volver a tu símbolo del sistema.

top es una herramienta indispensable para administradores de sistemas y usuarios por igual. Dominar sus funciones interactivas permite un diagnóstico rápido y eficaz de los problemas de rendimiento del sistema y la gestión de procesos.

Resumen

En este laboratorio, aprendiste conceptos fundamentales de la gestión de procesos en Linux. Empezaste comprendiendo los estados de los procesos y su ciclo de vida utilizando los comandos ps y top, observando cómo los procesos transitan entre estados como En Ejecución (R), Dormido Interruptible (S) y Detenido (T). Practicaste la identificación de estados de procesos comunes e interpretaste la salida de ps aux y ps -ef para obtener información sobre los procesos del sistema.

Además, exploraste métodos para controlar trabajos en segundo plano y en primer plano, lo cual es crucial para un uso eficiente de la terminal. También dominaste la terminación de procesos utilizando varios comandos como kill, killall y pkill, comprendiendo sus diferentes aplicaciones para terminaciones suaves o forzosas. Finalmente, aprendiste a monitorizar la carga del sistema y el uso de la CPU con uptime y lscpu, y a analizar la actividad detallada de los procesos con top, proporcionando una visión general completa del rendimiento del sistema y la utilización de los recursos.