Finalización de procesos en Linux basada en patrones

LinuxLinuxBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En los sistemas Linux, la gestión efectiva de procesos es crucial para mantener la estabilidad y el rendimiento del sistema. Si bien el comando kill permite terminar un proceso utilizando un ID de proceso (PID) específico, hay situaciones en las que es necesario terminar múltiples procesos basados en patrones. Aquí es donde el comando pkill se vuelve invaluable.

Este laboratorio (LabEx) se centra en el uso del comando pkill para terminar procesos basados en sus nombres, argumentos u otros criterios. Aprenderá cómo identificar los procesos en ejecución, terminarlos de forma selectiva utilizando coincidencia de patrones y verificar los resultados de sus operaciones. Estas habilidades son esenciales para la administración del sistema y la resolución de problemas en entornos Linux.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL linux(("Linux")) -.-> linux/ProcessManagementandControlGroup(["Process Management and Control"]) linux(("Linux")) -.-> linux/SystemInformationandMonitoringGroup(["System Information and Monitoring"]) linux(("Linux")) -.-> linux/BasicFileOperationsGroup(["Basic File Operations"]) linux(("Linux")) -.-> linux/TextProcessingGroup(["Text Processing"]) linux/BasicFileOperationsGroup -.-> linux/chmod("Permission Modifying") linux/TextProcessingGroup -.-> linux/grep("Pattern Searching") linux/ProcessManagementandControlGroup -.-> linux/pkill("Pattern-Based Killing") linux/SystemInformationandMonitoringGroup -.-> linux/ps("Process Displaying") subgraph Lab Skills linux/chmod -.-> lab-271359{{"Finalización de procesos en Linux basada en patrones"}} linux/grep -.-> lab-271359{{"Finalización de procesos en Linux basada en patrones"}} linux/pkill -.-> lab-271359{{"Finalización de procesos en Linux basada en patrones"}} linux/ps -.-> lab-271359{{"Finalización de procesos en Linux basada en patrones"}} end

Comprender la gestión de procesos y la terminación básica de procesos

En este primer paso, exploraremos cómo identificar los procesos en ejecución y terminarlos utilizando coincidencia de patrones básica. Linux proporciona varios comandos para la gestión de procesos, incluyendo ps, pgrep y pkill.

Creación de procesos de prueba

Comencemos creando un script sencillo que podamos ejecutar como un proceso en segundo plano. Crearemos múltiples instancias de este script para simular un escenario en el que necesites terminar varios procesos similares.

Primero, navega hasta el directorio del proyecto y crea un script llamado rogue_app.sh:

cd ~/project
nano rogue_app.sh

Agrega el siguiente contenido al script:

#!/bin/bash
while true; do
  echo "Process running with PID $$"
  sleep 5
done

Este script ejecuta un bucle infinito, imprimiendo su ID de proceso (PID) cada 5 segundos.

Ahora, haz que el script sea ejecutable:

chmod +x ~/project/rogue_app.sh

Ejecutemos múltiples instancias de este script en segundo plano:

for i in {1..5}; do
  ~/project/rogue_app.sh &
done

El & al final del comando ejecuta cada instancia del script en segundo plano, lo que te permite seguir utilizando la terminal.

Visualización de procesos en ejecución

Para ver los procesos que acabas de iniciar, utiliza el comando ps con las opciones adecuadas:

ps aux | grep rogue_app.sh

La salida se parecerá a esto:

labex     12345  0.0  0.0   2308   580 pts/0    S    10:00   0:00 /bin/bash /home/labex/project/rogue_app.sh
labex     12346  0.0  0.0   2308   580 pts/0    S    10:00   0:00 /bin/bash /home/labex/project/rogue_app.sh
labex     12347  0.0  0.0   2308   580 pts/0    S    10:00   0:00 /bin/bash /home/labex/project/rogue_app.sh
labex     12348  0.0  0.0   2308   580 pts/0    S    10:00   0:00 /bin/bash /home/labex/project/rogue_app.sh
labex     12349  0.0  0.0   2308   580 pts/0    S    10:00   0:00 /bin/bash /home/labex/project/rogue_app.sh
labex     12350  0.0  0.0   2432   584 pts/0    S+   10:00   0:00 grep --color=auto rogue_app.sh

Ten en cuenta que los PID reales (los números en la segunda columna) serán diferentes en tu sistema.

Terminación de procesos con pkill

Ahora, usemos el comando pkill para terminar todas las instancias de nuestro script:

pkill -f rogue_app.sh

La opción -f le dice a pkill que coincida con la línea de comando completa, no solo con el nombre del proceso. Esto es importante porque cuando se ejecuta un script, el nombre del proceso suele ser el intérprete (como /bin/bash) en lugar del nombre del script.

Verifica que todas las instancias del script se hayan terminado:

ps aux | grep rogue_app.sh

Ahora solo deberías ver el propio comando grep en la salida:

labex     12351  0.0  0.0   2432   584 pts/0    S+   10:01   0:00 grep --color=auto rogue_app.sh

Esto confirma que todas las instancias de rogue_app.sh se han terminado correctamente.

Terminación selectiva de procesos con coincidencia de patrones

En escenarios del mundo real, a menudo es necesario ser más selectivo sobre qué procesos se deben terminar. El comando pkill permite utilizar la coincidencia de patrones para apuntar a procesos específicos basados en varios criterios.

Creación de procesos con diferentes argumentos

Creemos un nuevo script que ejecutaremos con diferentes argumentos de línea de comandos:

cd ~/project
nano service_worker.sh

Agregue el siguiente contenido al script:

#!/bin/bash
while true; do
  echo "Running service worker with argument: $1"
  sleep 5
done

Haga que el script sea ejecutable:

chmod +x ~/project/service_worker.sh

Ahora, ejecutemos múltiples instancias de este script con diferentes argumentos:

~/project/service_worker.sh normal &
~/project/service_worker.sh normal &
~/project/service_worker.sh --malfunctioning &
~/project/service_worker.sh --malfunctioning &
~/project/service_worker.sh emergency &

Esto crea cinco procesos en segundo plano: dos trabajadores "normales", dos trabajadores "con mal funcionamiento" y un trabajador "de emergencia".

Visualización de procesos con diferentes argumentos

Verifique los procesos en ejecución:

ps aux | grep service_worker.sh

Debería ver una salida similar a:

labex     12360  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex     12361  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex     12362  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh --malfunctioning
labex     12363  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh --malfunctioning
labex     12364  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh emergency
labex     12365  0.0  0.0   2432   584 pts/0    S+   10:05   0:00 grep --color=auto service_worker.sh

Terminación selectiva con coincidencia de patrones

Ahora, terminemos selectivamente solo los procesos con el argumento --malfunctioning:

pkill -f "service_worker.sh --malfunctioning"

La opción -f asegura que pkill coincida con la línea de comando completa, incluyendo los argumentos.

Verifique que solo se hayan terminado los procesos objetivo:

ps aux | grep service_worker.sh

Ahora debería ver solo los procesos "normales" y "de emergencia":

labex     12360  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex     12361  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex     12364  0.0  0.0   2308   580 pts/0    S    10:05   0:00 /bin/bash /home/labex/project/service_worker.sh emergency
labex     12366  0.0  0.0   2432   584 pts/0    S+   10:06   0:00 grep --color=auto service_worker.sh

Esto demuestra cómo se pueden terminar selectivamente procesos basados en patrones específicos en sus líneas de comando.

Ahora, terminemos todos los procesos restantes de los trabajadores de servicio:

pkill -f service_worker.sh

Verifique que se hayan terminado todos los procesos de los trabajadores de servicio:

ps aux | grep service_worker.sh

Ahora solo debería ver el propio comando grep:

labex     12367  0.0  0.0   2432   584 pts/0    S+   10:07   0:00 grep --color=auto service_worker.sh

Opciones avanzadas de terminación de procesos

En este paso, exploraremos algunas opciones avanzadas del comando pkill que permiten una gestión de procesos más sofisticada.

Uso de diferentes tipos de señales

Por defecto, pkill envía la señal SIGTERM (señal 15) a los procesos. Esta señal permite que los procesos se terminen de forma elegante, cerrando archivos y realizando operaciones de limpieza. Sin embargo, hay casos en los que es posible que desees utilizar una señal diferente.

Creemos un script que maneje señales:

cd ~/project
nano signal_handler.sh

Agregue el siguiente contenido al script:

#!/bin/bash
trap 'echo "Received SIGHUP (1)"; exit 0' SIGHUP
trap 'echo "Received SIGINT (2)"; exit 0' SIGINT
trap 'echo "Received SIGTERM (15)"; exit 0' SIGTERM

echo "Process started with PID $$"
echo "Use: pkill -[signal] -f signal_handler.sh to send signals"
while true; do
  sleep 1
done

Haga que el script sea ejecutable:

chmod +x ~/project/signal_handler.sh

Ejecute el script en segundo plano:

~/project/signal_handler.sh &

Ahora, intentemos enviar diferentes señales al proceso:

  1. Envíe una señal SIGHUP (señal 1):
pkill -HUP -f signal_handler.sh
  1. Inicie el script nuevamente y envíe SIGINT (señal 2):
~/project/signal_handler.sh &
pkill -INT -f signal_handler.sh
  1. Inicie el script nuevamente y envíe la señal SIGTERM predeterminada (señal 15):
~/project/signal_handler.sh &
pkill -f signal_handler.sh ## Default is SIGTERM

Para cada señal, debería ver el mensaje correspondiente en la salida del terminal antes de que el proceso salga.

Terminación de procesos por edad

pkill permite apuntar a procesos según su edad utilizando las opciones --newer y --older.

Creemos algunos procesos con diferentes tiempos de inicio:

cd ~/project
nano age_test.sh

Agregue el siguiente contenido al script:

#!/bin/bash
while true; do
  echo "Process running with PID $$"
  sleep 5
done

Haga que el script sea ejecutable:

chmod +x ~/project/age_test.sh

Inicie el primer proceso y registre el archivo de referencia:

~/project/age_test.sh &
touch ~/project/reference_time

Espere unos segundos y luego inicie dos procesos más:

sleep 5
~/project/age_test.sh &
~/project/age_test.sh &

Ahora, terminemos solo los procesos que se iniciaron después de que se creó el archivo de referencia:

pkill -f --newer ~/project/reference_time age_test.sh

Verifique qué procesos todavía están en ejecución:

ps aux | grep age_test.sh

Debería ver que solo el primer proceso todavía está en ejecución, ya que se inició antes de que se creara el archivo de referencia.

Termine el proceso restante:

pkill -f age_test.sh

Limitación de pkill por propietario del proceso

También puede limitar las acciones de pkill a los procesos propiedad de un usuario específico. En un sistema multiusuario, esto es especialmente útil.

Con fines demostrativos, ejecutemos algunos procesos como el usuario actual:

~/project/rogue_app.sh &
~/project/rogue_app.sh &

Ahora, terminemos estos procesos, pero solo aquellos propiedad de su usuario actual:

pkill -f -u $(whoami) rogue_app.sh

La opción -u especifica el nombre de usuario del propietario del proceso. La sustitución de comandos $(whoami) obtiene su nombre de usuario actual.

Verifique que se hayan terminado todos los procesos:

ps aux | grep rogue_app.sh

Solo debería ver el propio comando grep en la salida.

Esta capacidad de apuntar a procesos por propietario es especialmente útil en entornos multiusuario donde se desea evitar afectar a los procesos de otros usuarios.

Resumen

En este laboratorio, has aprendido cómo usar el comando pkill para gestionar procesos en un entorno Linux. Este poderoso comando te permite terminar procesos basados en varios criterios, lo que lo convierte en una herramienta esencial para la administración de sistemas.

Conceptos clave cubiertos:

  1. Terminación básica de procesos: Aprendiste cómo identificar procesos en ejecución utilizando el comando ps y terminarlos utilizando pkill con coincidencia de patrones básica.

  2. Terminación selectiva de procesos: Exploraste cómo usar la coincidencia de patrones para apuntar selectivamente a procesos basados en sus argumentos de línea de comandos, lo que permite un control preciso sobre qué procesos se deben terminar.

  3. Opciones avanzadas de terminación de procesos: Descubriste opciones avanzadas de pkill, incluyendo cómo:

    • Enviar diferentes tipos de señales a los procesos
    • Terminar procesos basados en su edad
    • Limitar el alcance de pkill a procesos propiedad de un usuario específico

Estas habilidades son valiosas para mantener la estabilidad del sistema, gestionar recursos y solucionar problemas en entornos Linux. Al dominar el comando pkill, has agregado una herramienta importante a tu conjunto de herramientas de administración de sistemas Linux.