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

Введение

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

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

Skills Graph

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

На этом первом этапе мы рассмотрим, как определить запущенные процессы и завершить их с использованием базового сопоставления шаблонов. 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

2. Запустите скрипт снова и отправьте SIGINT (сигнал 2):

~/project/signal_handler.sh &
pkill -INT -f signal_handler.sh

3. Запустите скрипт снова и отправьте сигнал SIGTERM по умолчанию (сигнал 15):

~/project/signal_handler.sh &
pkill -f signal_handler.sh ## Default is SIGTERM

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

Завершение процессов по времени жизни

pkill позволяет нацеливаться на процессы на основе их времени жизни с использованием параметров --newer и --older.

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

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 &
touch ~/project/reference_time

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

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

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

pkill -f --newer ~/project/reference_time 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.