Мониторинг процессов в Red Hat Enterprise Linux

Введение

В этом лабораторном практикуме вы получите практический опыт мониторинга и управления процессами Linux, что является фундаментальным навыком для любого системного администратора или разработчика. Вы научитесь понимать состояния и жизненные циклы процессов с помощью команд ps и top, управлять фоновыми и передними задачами, а также эффективно завершать процессы с помощью kill, killall и pkill. Кроме того, вы изучите, как контролировать нагрузку системы и использование ЦП с помощью uptime и lscpu, и подробно анализировать активность процессов с помощью top. Этот практикум снабдит вас необходимыми инструментами и знаниями для эффективного управления процессами и поддержания здоровья системы на RHEL.

Понимание состояний и жизненного цикла процессов с помощью ps и top

В этом шаге вы узнаете о состояниях процессов Linux и их жизненном цикле. Понимание состояний процессов имеет решающее значение для эффективного мониторинга и управления системными ресурсами. Вы будете использовать команды ps и top для наблюдения за процессами и их состояниями.

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

Начнём с изучения состояний процессов с помощью команды ps. Команда ps отображает моментальный снимок текущих процессов.

Сначала откройте терминал. Вы можете сделать это, щелкнув по значку терминала на рабочем столе или нажав Ctrl+Alt+T. Ваша текущая рабочая директория — ~/project.

Чтобы увидеть все запущенные процессы на вашей системе, включая те, у которых нет управляющего терминала, используйте команду ps aux. Опции aux отображают процессы, принадлежащие всем пользователям (a), процессы без управляющего терминала (x), и показывают формат, ориентированный на пользователя (u).

ps aux

Вы увидите длинный список процессов. Обратите внимание на столбец STAT, который показывает состояние каждого процесса. Распространённые состояния, которые вы можете наблюдать, включают:

• R: Запущенный или готовый к запуску (в процессоре или ожидает запуска)
• S: Прерывимое ожидание (ожидание завершения события)
• D: Непрерывимое ожидание (ожидание ввода-вывода, не может быть прервано)
• T: Приостановленный (приостановлен сигналом)
• Z: Зомби (процесс завершён, но родительский процесс ещё не получил его код завершения)

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

Далее, давайте воспользуемся командой ps -ef. Эта команда предоставляет полный список (f) всех процессов (e), показывая больше деталей, такие как идентификатор родительского процесса (PPID), использование процессора (C), время запуска (STIME) и команду (CMD).

ps -ef

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

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

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

ps --forest

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

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

Теперь давайте рассмотрим команду top, которая предоставляет динамический, реальный вид работающей системы. Она отображает сводку информации о системе и список процессов или потоков, которые в данный момент управляются ядром Linux.

Запустите команду top:

top

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

В выводе top наблюдайте столбец S для состояний процессов, аналогично ps. Вы также можете увидеть %CPU (процент использования процессора) и %MEM (процент использования памяти) для каждого процесса.

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

Пока top работает, вы можете нажать q, чтобы выйти и вернуться к приглашению терминала.

Понимание этих команд и предоставляемой ими информации является фундаментальным для мониторинга и устранения неполадок процессов в системе Linux.

Управление фоновыми и передними задачами

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

«Задача» в контексте оболочки относится к команде или цепочке команд, которые оболочка управляет. Вы можете запускать задачи в фоновом режиме, переводить их в передний план или приостанавливать их.

Начнём с запуска простой команды в фоновом режиме. Мы будем использовать команду sleep, которая просто ожидает определённое количество времени.

Чтобы запустить sleep 10000 (ожидание 10000 секунд) в фоновом режиме, добавьте амперсанд (&) к команде:

sleep 10000 &

При нажатии Enter оболочка сразу вернётся к приглашению, а команда sleep будет выполняться в фоновом режиме. Вы увидите вывод, похожий на этот, показывающий номер задачи и её идентификатор процесса (PID):

[1] 5947

[1] указывает, что это задача номер 1 в вашей текущей сессии оболочки, а 5947 — PID процесса sleep.

Чтобы просмотреть список всех задач, которые в данный момент управляет ваша оболочка, используйте команду jobs:

jobs

Вы должны увидеть команду sleep в списке как запущенную фоновую задачу:

[1]+ Running    sleep 10000 &

Символ + рядом с [1] указывает, что это текущая задача (над которой будет выполняться действие по умолчанию, если вы не указали номер задачи).

Теперь давайте переведём эту фоновую задачу в передний план. Это означает, что задача снова получит контроль над вашим терминалом. Используйте команду fg и номер задачи (с префиксом %):

fg %1

Команда sleep 10000 теперь находится в переднем плане. Ваш терминал будет занят этой командой, и вы не получите приглашение, пока она не завершится или не будет приостановлена.

sleep 10000

Пока команда выполняется в переднем плане, вы можете перевести её в фоновый режим и приостановить её, нажав Ctrl+Z. Это отправляет сигнал SIGTSTP процессу.

Нажмите Ctrl+Z сейчас:

^Z

Вы увидите вывод, указывающий, что задача была остановлена и переведена в фоновый режим:

[1]+  Stopped                 sleep 10000

Теперь, если вы снова выполните jobs, вы увидите, что команда sleep находится в состоянии Stopped:

jobs

[1]+ Stopped                 sleep 10000

Чтобы возобновить остановленную фоновую задачу, вы можете использовать команду bg и номер задачи. Это запустит задачу снова в фоновом режиме.

bg %1

Задача снова будет выполняться в фоновом режиме:

[1]+ sleep 10000 &

Наконец, давайте завершим фоновую задачу. Вы можете завершить фоновую задачу с помощью команды kill с её PID или переведя её в передний план и завершив (например, с помощью Ctrl+C). Сейчас давайте переведём её в передний план и завершим.

fg %1

Теперь, когда sleep 10000 находится в переднем плане, нажмите Ctrl+C, чтобы завершить её. Это отправляет сигнал SIGINT процессу.

^C

Вы увидите сообщение, указывающее, что задача была завершена:

[1]+  Terminated              sleep 10000

Если вы снова выполните jobs, вы должны увидеть, что задач больше нет:

jobs

(no output)

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

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

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

Процессы в Linux реагируют на сигналы. Сигнал — это программное прерывание, посылаемое процессу. Разные сигналы имеют разное значение, например, завершение процесса, приостановление его или загрузка новой конфигурации.

Сначала давайте разберёмся с некоторыми фундаментальными сигналами управления процессами:

• SIGTERM (15): Сигнал по умолчанию, отправляемый командой kill. Это «вежливый» запрос на завершение. Процесс может перехватить этот сигнал, выполнить необходимые действия по очистке и затем завершиться.
• SIGKILL (9): «Неблокируемый» сигнал, который принудительно завершает процесс немедленно. Процесс не может игнорировать или обрабатывать этот сигнал. Используйте его в крайнем случае.
• SIGHUP (1): Часто используется для указания процессу перезагрузить файлы конфигурации без перезапуска.
• SIGINT (2): Отправляется при нажатии Ctrl+C, обычно используется для прерывания процесса в переднем плане.
• SIGSTOP (19): Приостанавливает процесс. Он не может быть заблокирован или обработан.
• SIGCONT (18): Возобновляет приостановленный процесс.

Вы можете перечислить все доступные сигналы и их номера, используя kill -l:

kill -l

Вы увидите список сигналов, похожий на этот:

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

Использование kill

Команда kill отправляет указанный сигнал процессу, идентифицированному по его идентификатору процесса (PID).

Давайте создадим несколько фоновых процессов для практики завершения. Мы снова будем использовать команды sleep.

sleep 300 &
sleep 301 &
sleep 302 &

Теперь используйте jobs, чтобы увидеть их номера задач и PID:

jobs

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

(Обратите внимание: ваши PID будут отличаться.)

Давайте найдём PID первого процесса sleep. Вы можете использовать ps aux | grep sleep и найти PID, связанный с sleep 300.

ps aux | grep sleep

Вы увидите вывод, похожий на этот. Определите PID для sleep 300. Например, если PID равен 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

Чтобы завершить sleep 300 с помощью сигнала SIGTERM по умолчанию, используйте kill и его PID. Замените 1234 на фактический PID, который вы нашли:

kill 1234

Вы можете увидеть сообщение вроде [1]+ Terminated sleep 300. Проверьте, что он исчез, используя jobs или ps aux | grep sleep:

jobs

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

Теперь давайте принудительно завершим sleep 301 с помощью SIGKILL. Найдите его PID (например, 1235) и используйте kill -9 или kill -SIGKILL:

kill -9 1235

Вы, скорее всего, увидите [2]- Killed sleep 301. Снова проверьте:

jobs

[3]+ Running    sleep 302 &

Использование killall

Команда killall завершает процессы по их имени, а не по PID. Она отправляет сигнал всем процессам, которые соответствуют указанному имени команды.

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

sleep 303 &
sleep 304 &
sleep 305 &

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

jobs

[3] Running    sleep 302 &
[4] Running    sleep 303 &
[5] Running    sleep 304 &
[6] Running    sleep 305 &

Теперь используйте killall, чтобы завершить все процессы sleep. По умолчанию killall отправляет SIGTERM.

killall sleep

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

jobs

(no output)

Использование pkill

Команда pkill похожа на killall, но предоставляет более расширенные критерии выбора, включая сопоставление по шаблону имён команд, идентификаторам пользователей, группам и управляющим терминалам. Она очень мощна для нацеливания на определённые наборы процессов.

Давайте создадим новые процессы sleep для pkill:

sleep 306 &
sleep 307 &
sleep 308 &

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

jobs

[1] Running    sleep 306 &
[2] Running    sleep 307 &
[3] Running    sleep 308 &

Чтобы завершить все процессы sleep, принадлежащие текущему пользователю (labex), вы можете использовать pkill -u labex sleep:

pkill -u labex sleep

Эта команда завершит все процессы sleep, принадлежащие пользователю labex.

Проверьте, что все процессы sleep исчезли:

jobs

(no output)

Вы также можете использовать pkill с шаблоном. Например, если у вас есть процессы с именами my_app_v1 и my_app_v2, вы можете завершить оба с помощью pkill my_app.

Эти команды предоставляют гибкие способы управления и завершения процессов, от нацеливания на один процесс по его PID до завершения нескольких процессов на основе их имени или других атрибутов. Всегда будьте осторожны при использовании kill -9 или SIGKILL, так как это может привести к потере данных, если у процесса нет возможности выполнить очистку.

Мониторинг нагрузки системы и использования процессора с помощью uptime и lscpu

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

Понимание средней нагрузки с помощью uptime

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

Выполните команду uptime:

uptime

Вы увидите вывод, похожий на этот:

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

Давайте разберём вывод:

• HH:MM:SS: Текущее время.
• up DD min: Время работы системы (uptime).
• X users: Количество пользователей, подключённых в данный момент.
• load average: X.XX, X.XX, X.XX: Эти три числа представляют среднюю нагрузку системы за последние 1, 5 и 15 минут соответственно.

Средняя нагрузка 1.00 на одноядерном процессоре означает, что процессор полностью загружен. На многоядерном процессоре средняя нагрузка, равная количеству ядер процессора, означает, что система полностью загружена. Например, на 4-ядерном процессоре средняя нагрузка 4.00 указывает на полную загрузку. Если средняя нагрузка постоянно превышает количество ядер процессора, это говорит о том, что ваша система перегружена, и процессы ожидают времени выполнения на процессоре.

Определение ядер процессора с помощью lscpu

Для правильной интерпретации средней нагрузки вам необходимо знать, сколько логических ядер процессора имеет ваша система. Команда lscpu предоставляет подробную информацию об архитектуре процессора.

Выполните команду lscpu:

lscpu

Вы увидите подробный вывод. Обратите внимание на строку CPU(s):, которая указывает общее количество доступных логических процессоров. Также Core(s) per socket: и Socket(s): помогут вам понять физическую компоновку.

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

В приведённом примере CPU(s): 4 указывает, что в этой системе 4 логических ядра процессора.

Интерпретация средней нагрузки и ядер процессора

Давайте объединим информацию из uptime и lscpu. Предположим, что вывод uptime показывает среднюю нагрузку 2.92, 4.48, 5.20, а lscpu показывает CPU(s): 4.

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

• За последние 1 минуту: 2.92 / 4 = 0.73
• За последние 5 минут: 4.48 / 4 = 1.12
• За последние 15 минут: 5.20 / 4 = 1.30

Основываясь на этих расчётах:

• За последние 1 минуту процессоры использовались примерно на 73% своей мощности.
• За последние 5 минут система была перегружена примерно на 12% (1.12 - 1.00 = 0.12). Это означает, что процессы ожидали времени выполнения на процессоре.
• За последние 15 минут система была перегружена примерно на 30% (1.30 - 1.00 = 0.30).

Этот анализ показывает, что система испытывала значительную нагрузку в течение последних 5 и 15 минут, но нагрузка снизилась за последнюю минуту. Такой анализ тенденций имеет решающее значение для понимания состояния системы.

Эти две команды, uptime и lscpu, являются простыми, но мощными инструментами для быстрого определения общего состояния и производительности вашей системы Linux.

Анализ активности процессов с помощью top

В этом шаге вы углубитесь в использование команды top для анализа активности процессов. Хотя top предоставляет обзор в реальном времени, она также предлагает мощные интерактивные возможности для сортировки, фильтрации и управления процессами.

Вспомните из предыдущего шага, что top предоставляет динамический вид вашей системы. Давайте снова запустим top:

top

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

Понимание столбцов в top

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

• PID: Идентификатор процесса.
• USER: Владелец процесса.
• PR: Приоритет процесса.
• NI: Значение nice (меньшее значение nice означает более высокий приоритет).
• VIRT: Виртуальная память, используемая процессом.
• RES: Резидентная память (физическая оперативная память), используемая процессом.
• SHR: Общая память, используемая процессом.
• S: Состояние процесса (R=Запущен, S=Ожидание, D=Непрерываемое ожидание, T=Остановлен, Z=Зомби).
• %CPU: Процент использования процессора с момента последнего обновления.
• %MEM: Процент использования памяти (RES / общая физическая память).
• TIME+: Общее время использования процессора процессом с момента его запуска.
• COMMAND: Имя команды, которая запустила процесс.

Интерактивные клавиши в top

top — это высокоинтерактивная команда. Вы можете нажимать различные клавиши, чтобы изменить отображение и взаимодействовать с процессами.

1. Сортировка процессов:

   • Нажмите Shift+P (заглавная P), чтобы отсортировать процессы по использованию процессора (%CPU), что часто является значением по умолчанию.
   • Нажмите Shift+M (заглавная M), чтобы отсортировать процессы по использованию памяти (%MEM).
   • Нажмите Shift+T (заглавная T), чтобы отсортировать процессы по TIME+.

   Попробуйте нажать Shift+M сейчас, чтобы отсортировать по использованию памяти. Обратите внимание, как список процессов переупорядочивается. Затем нажмите Shift+P, чтобы вернуться к сортировке по использованию процессора.

2. Фильтрация по пользователю:

   • Нажмите u (строчная u). top запросит имя пользователя. Введите labex и нажмите Enter.
   • Теперь top будет отображать только процессы, принадлежащие пользователю labex. Это очень полезно для фокусировки на собственных процессах.
   • Чтобы очистить фильтр и показать всех пользователей снова, нажмите u, а затем нажмите Enter, не вводя имя пользователя.

3. Изменение интервала обновления:

   • По умолчанию top обновляется каждые 3 секунды. Вы можете изменить этот интервал.
   • Нажмите s (строчная s). top запросит время задержки. Введите 1 (для 1 секунды) и нажмите Enter.
   • Обратите внимание, как отображение обновляется чаще.
   • Вы можете изменить его обратно на 3 секунды, нажав s снова и введя 3.

4. Завершение процесса:

   • Вы можете завершить процесс непосредственно из top.
   • Сначала запустим процесс sleep в фоновом режиме в новой вкладке или окне терминала, или нажав Ctrl+Z в текущем терминале, затем bg, чтобы поместить top в фоновый режим, затем запустите sleep 600 &, затем fg, чтобы вернуть top в фоновый режим.
   • В качестве альтернативы, вы можете открыть новую вкладку терминала (например, Ctrl+Shift+T во многих терминалах) и запустить sleep 600 & там.
   • После запуска процесса sleep вернитесь к терминалу top.
   • Нажмите k (строчная k). top запросит PID процесса для завершения.
   • Найдите PID вашего процесса sleep 600 в списке top. Введите этот PID и нажмите Enter.
   • top запросит сигнал для отправки. По умолчанию это 15 (SIGTERM). Нажмите Enter, чтобы отправить SIGTERM.
   • Процесс sleep должен исчезнуть из списка. Если нет, вы можете попробовать k снова и отправить сигнал 9 (SIGKILL).

5. Изменение приоритета процесса (renicing):

   • Изменение приоритета процесса. Меньшее значение nice означает более высокий приоритет.
   • Нажмите r (строчная r). top запросит PID, а затем значение nice (например, -10 для более высокого приоритета, 10 для более низкого приоритета).
   • Это расширенная функция для управления системными ресурсами. Для этой лабораторной работы просто нажмите r, затем дважды Enter, чтобы отменить операцию без каких-либо изменений.

6. Выход из top:

   • Когда вы закончите, нажмите q (строчная q), чтобы выйти из top и вернуться к приглашению вашего терминала.

top — незаменимый инструмент для системных администраторов и пользователей. Овладение его интерактивными функциями позволяет быстро и эффективно диагностировать проблемы производительности системы и управлять процессами.

Резюме

В этой лабораторной работе вы изучили основные концепции управления процессами в Linux. Вы начали с понимания состояний процессов и их жизненного цикла, используя команды ps и top, наблюдая, как процессы переходят между состояниями, такими как Запущен (R), Прерывимое ожидание (S) и Остановлен (T). Вы практиковались в определении распространённых состояний процессов и интерпретации вывода команд ps aux и ps -ef, чтобы получить представление о системных процессах.

Кроме того, вы изучили методы управления фоновыми и фоновыми задачами, что имеет решающее значение для эффективного использования терминала. Вы также освоили завершение процессов с помощью различных команд, таких как kill, killall и pkill, понимая их различные применения для плавного или принудительного завершения. Наконец, вы научились отслеживать нагрузку системы и использование процессора с помощью uptime и lscpu, а также анализировать подробную активность процессов с помощью top, обеспечивая комплексный обзор производительности системы и использования ресурсов.