Убийство процессов в Linux на основе шаблонов

LinuxBeginner
Практиковаться сейчас

Введение

В системах Linux эффективное управление процессами является ключевым фактором для поддержания стабильности и производительности системы. В то время как команда kill позволяет завершать процессы, используя определенный идентификатор процесса (PID), бывают ситуации, когда вам нужно завершить несколько процессов на основе шаблонов. Именно здесь команда pkill становится неоценимой.

В этом лабораторном занятии (LabEx) основное внимание уделено использованию команды pkill для завершения процессов на основе их имен, аргументов или других критериев. Вы научитесь определять запущенные процессы, завершать их выборочно с использованием сопоставления шаблонов и проверять результаты своих операций. Эти навыки являются обязательными для системного администрирования и устранения неполадок в Linux-окружениях.

Понимание управления процессами и базового завершения процессов

На этом первом этапе мы рассмотрим, как определить запущенные процессы и завершить их с использованием базового сопоставления шаблонов. Linux предоставляет несколько команд для управления процессами, включая ps, pgrep и pkill.

Создание тестовых процессов

Начнем с создания простого скрипта, который мы сможем запустить как фоновый процесс. Мы создадим несколько экземпляров этого скрипта, чтобы смоделировать ситуацию, когда вам нужно завершить несколько похожих процессов.

Сначала перейдите в проектную директорию и создайте скрипт с именем rogue_app.sh:

cd ~/project
nano rogue_app.sh

Добавьте следующее содержимое в скрипт:

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

Этот скрипт запускает бесконечный цикл, выводя свой идентификатор процесса (PID) каждые 5 секунд.

Теперь сделайте скрипт исполняемым:

chmod +x ~/project/rogue_app.sh

Запустим несколько экземпляров этого скрипта в фоновом режиме:

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

Знак & в конце команды запускает каждый экземпляр скрипта в фоновом режиме, позволяя вам продолжать использовать терминал.

Просмотр запущенных процессов

Чтобы увидеть процессы, которые вы только что запустили, используйте команду ps с соответствующими флагами:

ps aux | grep rogue_app.sh

Вывод будет похож на следующий:

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

Обратите внимание, что фактические PID (числа во второй колонке) будут различными на вашей системе.

Завершение процессов с помощью pkill

Теперь используем команду pkill для завершения всех экземпляров нашего скрипта:

pkill -f rogue_app.sh

Опция -f сообщает pkill искать совпадения по всей командной строке, а не только по имени процесса. Это важно, потому что при запуске скрипта имя процесса часто является интерпретатором (например, /bin/bash), а не именем скрипта.

Проверьте, что все экземпляры скрипта были завершены:

ps aux | grep rogue_app.sh

Теперь в выводе вы должны увидеть только саму команду grep:

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

Это подтверждает, что все экземпляры rogue_app.sh были успешно завершены.

Выборочное завершение процессов с использованием сопоставления шаблонов

В реальных сценариях вам часто нужно быть более селективными в выборе процессов для завершения. Команда pkill позволяет использовать сопоставление шаблонов для нацеливания на определенные процессы на основе различных критериев.

Создание процессов с разными аргументами

Создадим новый скрипт, который мы запустим с разными аргументами командной строки:

cd ~/project
nano service_worker.sh

Добавьте следующее содержимое в скрипт:

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

Сделайте скрипт исполняемым:

chmod +x ~/project/service_worker.sh

Теперь запустим несколько экземпляров этого скрипта с разными аргументами:

~/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 &

Это создаст пять фоновых процессов: два "нормальных" работника, два "неисправных" работника и один "экстренный" работник.

Просмотр процессов с разными аргументами

Проверьте запущенные процессы:

ps aux | grep service_worker.sh

Вы должны увидеть вывод, похожий на следующий:

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

Выборочное завершение с использованием сопоставления шаблонов

Теперь давайте выборочно завершим только процессы с аргументом --malfunctioning:

pkill -f "service_worker.sh --malfunctioning"

Опция -f гарантирует, что pkill будет искать совпадения по всей командной строке, включая аргументы.

Проверьте, что были завершены только целевые процессы:

ps aux | grep service_worker.sh

Теперь вы должны увидеть только "нормальные" и "экстренные" процессы:

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

Это демонстрирует, как можно выборочно завершать процессы на основе определенных шаблонов в их командных строках.

Теперь завершим все оставшиеся процессы сервисного работника:

pkill -f service_worker.sh

Проверьте, что все процессы сервисного работника были завершены:

ps aux | grep service_worker.sh

Теперь вы должны увидеть только саму команду grep:

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

Расширенные параметры завершения процессов

На этом шаге мы рассмотрим некоторые расширенные опции команды pkill, которые позволяют более тонко управлять процессами.

Использование различных типов сигналов

По умолчанию pkill отправляет процессам сигнал SIGTERM (сигнал 15). Этот сигнал позволяет процессам корректно завершиться, закрыть файлы и выполнить операции очистки. Однако бывают случаи, когда вам может потребоваться использовать другой сигнал.

Давайте создадим скрипт, который обрабатывает сигналы:

cd ~/project
nano signal_handler.sh

Добавьте следующее содержимое в скрипт:

#!/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

Сделайте скрипт исполняемым:

chmod +x ~/project/signal_handler.sh

Запустите скрипт в фоновом режиме:

~/project/signal_handler.sh &

Теперь попробуем отправить различные сигналы процессу:

  1. Отправьте сигнал SIGHUP (сигнал 1):
pkill -HUP -f signal_handler.sh
  1. Снова запустите скрипт и отправьте SIGINT (сигнал 2):
~/project/signal_handler.sh &
pkill -INT -f signal_handler.sh
  1. Снова запустите скрипт и отправьте сигнал SIGTERM по умолчанию (сигнал 15):
~/project/signal_handler.sh &
pkill -f signal_handler.sh ## Default is SIGTERM

Для каждого сигнала вы должны увидеть соответствующее сообщение в выводе терминала перед завершением процесса.

Завершение процессов по возрасту

pkill позволяет выбирать процессы на основе времени их запуска с помощью опции --newest, которая выбирает самые недавно запущенные процессы.

Давайте создадим несколько процессов с разным временем запуска:

cd ~/project
nano age_test.sh

Добавьте следующее содержимое в скрипт:

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

Сделайте скрипт исполняемым:

chmod +x ~/project/age_test.sh

Запустите первый процесс:

~/project/age_test.sh &

Подождите несколько секунд, затем запустите еще два процесса:

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

Теперь давайте завершим только два самых последних запущенных процесса, используя опцию --newest:

pkill -f --newest 2 age_test.sh

Проверьте, какие процессы все еще запущены:

ps aux | grep age_test.sh

Вы должны увидеть, что запущен только первый процесс, так как он был запущен раньше двух других.

Завершите оставшийся процесс:

pkill -f age_test.sh

Ограничение pkill по владельцу процесса

Вы также можете ограничить действия pkill процессами, принадлежащими определенному пользователю. В многопользовательской системе это особенно полезно.

Для демонстрации запустим несколько процессов от имени текущего пользователя:

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

Теперь давайте завершим эти процессы, но только те, которые принадлежат вашему текущему пользователю:

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

Опция -u указывает имя пользователя, которому принадлежит процесс. Команда $(whoami) подставляет ваше текущее имя пользователя.

Проверьте, что все процессы были завершены:

ps aux | grep rogue_app.sh

В выводе вы должны увидеть только саму команду grep.

Эта возможность выбирать процессы по владельцу особенно полезна в многопользовательских средах, где вы хотите избежать воздействия на процессы, принадлежащие другим пользователям.

Резюме

В этом практическом занятии вы узнали, как использовать команду pkill для управления процессами в среде Linux. Эта мощная команда позволяет завершать процессы на основе различных критериев, что делает ее важным инструментом для системного администрирования.

Покрытые ключевые концепции:

  1. Базовое завершение процессов: Вы научились определять запущенные процессы с помощью команды ps и завершать их с использованием pkill с базовым сопоставлением шаблонов.

  2. Выборочное завершение процессов: Вы изучили, как использовать сопоставление шаблонов для выборочного нацеливания на процессы на основе их аргументов командной строки, что позволяет точно контролировать, какие процессы нужно завершить.

  3. Продвинутые параметры завершения процессов: Вы обнаружили продвинутые параметры pkill, включая:

    • Отправку разных типов сигналов процессам
    • Завершение процессов на основе их времени жизни
    • Ограничение действия pkill только процессами, принадлежащими определенному пользователю

Эти навыки ценны для поддержания стабильности системы, управления ресурсами и устранения неполадок в среде Linux. Освоив команду pkill, вы добавили важный инструмент в свой набор инструментов для системного администрирования Linux.