devops-курс Все курсы

✻ Урок 1.5 · Тема 1: Linux, Bash и systemd

Диск, память и процессор: где кончаются ресурсы

⏱ 4 ч

Как работать с кодом и когда идти дальше

Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:

  • Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
  • Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
  • Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.

Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.

Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.

Зачем это нужно

Типичная ночная история: сервис перезапускают «на удачу», а причиной оказывается переполненный диск. Этот урок про то, как не гадать.

Вот как выглядит одна из типичных ночных историй: диск, который заполняется за ночь.

Диск заполняется в среднем на 8 процентных пунктов в час, а в 03:00 доходит до 100%. С этой минуты сервис не может записать ни строки, и дежурному звонят. Такой график за вечер показал бы проблему заранее: по нему видно не только «сколько занято», но и «когда кончится».

Одна из типичных причин ночных сбоев: у сервера кончился диск, память или процессор. Такой сбой называют инцидентом (incident): сервис у пользователей не работает или работает плохо, и дежурному инженеру нужно быстро понять причину (подробно про инциденты в теме 10). Ресурс (resource) это то, чего у сервера ограниченное количество и что делят все программы. Их три:

  • диск: место для файлов, не пропадает при выключении питания; смотрят df и du;
  • оперативная память (RAM): быстрая временная память, где программа держит данные, пока работает; смотрят free;
  • процессор: сколько работы сервер успевает сделать в секунду; смотрят uptime и top.

Каждый ресурс кончается по-своему. Кто не отличает «диск заполнен» от «кончились inodes» (inode это «карточка» файла в журнале учёта файловой системы, разберём ниже), а «памяти мало» от «памяти хватает, это кэш», тратит на разбор часы. Все эти вопросы задают и на собеседованиях.

В этом уроке ты научишься по короткому чек-листу понимать, какой ресурс подводит. Чек-лист называется метод USE: для каждого ресурса проверяют занятость (Utilization), очередь (Saturation) и ошибки (Errors). Очередь здесь значит, что работа уже ждёт, потому что ресурса не хватает, как очередь в кассу.

Каждую поломку ты воспроизведёшь сам, безопасно: на тестовом «диске» размером 64 МБ и на своём процессе с лимитом памяти. Лимит это потолок: больше этого объёма процессу брать не разрешено. В контейнерах он встретится в уроке 4.1.

Шаг проекта: в app.py появляются демонстрационные эндпоинты /leak и /burn (версия v2.2). Эндпоинт (endpoint) это адрес, по которому сервис отвечает на запрос: /healthz уже есть, теперь добавятся ещё два. Ими мы будем «съедать» память и процессор «Заметок» без сторонних нагрузчиков.

Что нужно знать

Сервис «Заметки» у тебя на этом этапе запускается руками: cd ~/notes && python3 app.py. Под управлением systemd (программа, которая запускает сервисы при старте сервера и перезапускает их после сбоя) он окажется только в уроке 1.8.

Картина целиком

Представь кухню ресторана.

  • Кладовая это диск. Она большая, но полки в ней делятся на места (сколько влезет) и на карточки в журнале учёта (каждой коробке нужна своя карточка). Можно исчерпать полки, а можно исчерпать пустые карточки, хотя полки полупустые.
  • Рабочий стол повара это оперативная память (RAM, random access memory). Работать можно только с тем, что лежит на столе. Стол быстрый, но маленький. Пока на столе есть место, повар оставляет там продукты «на всякий случай»: вдруг понадобятся снова. Это кэш.
  • Повара это процессор. Каждый повар (ядро процессора) готовит одно блюдо за раз. Если заказов больше, чем поваров, заказы стоят в очереди.
  • Шеф-администратор это ядро Linux. Он раздаёт места на столе, распределяет заказы между поварами и, если стол переполнился окончательно, выбрасывает одно блюдо, чтобы кухня не встала.

Слово «ядро» в этом уроке встретится в двух значениях, не путай. Ядро Linux (kernel) это главная часть операционной системы, «шеф-администратор». Ядро процессора (CPU core) это один «повар», физический или виртуальный исполнитель. Когда речь о процессоре, мы будем писать «ядро процессора» или «ядро CPU».

flowchart TD
    K["Ядро Linux (шеф)"] --> DSK["Диск (кладовая)"]
    K --> MEM["Память (стол)"]
    K --> CPU["Процессор (повара)"]
    DSK --> D1["df, du, lsof"]
    MEM --> M1["free, dmesg"]
    CPU --> C1["uptime, top"]

Под каждым ресурсом написаны команды, которыми ты его смотришь. Нехватка диска даёт No space left on device, нехватка памяти даёт OOM-killer, нехватка процессора даёт очередь (load average).

За урок ты разберёшь каждый из трёх ресурсов: из чего он состоит, чем измеряется, как выглядит его нехватка и какими командами это увидеть. Потом соединишь всё в один порядок проверки (метод USE) и потренируешься на поломках «Заметок».

Теория

Диск: блоки, inodes и почему их два лимита

Диск сам по себе это просто длинный ряд одинаковых ячеек, в которые можно записывать байты. Без «оглавления» невозможно понять, где начинается и заканчивается твой файл, как он называется и кому принадлежит. Поэтому поверх диска (или его раздела, то есть выделенного куска) создают файловую систему (file system): набор правил и служебных таблиц, по которым ядро Linux записывает и находит файлы. На серверах Linux чаще всего используют файловую систему ext4.

Книги (содержимое файлов) стоят на полках. Полки разбиты на одинаковые места по одной книге, это блоки (block). В ext4 блок обычно 4 КБ: даже файл в один байт занимает целый блок. Но найти книгу по полкам невозможно, поэтому есть каталожные карточки: на карточке написано, чья книга, когда поступила, какой толщины и на каких местах лежат её страницы. Такая карточка называется inode (index node, «индексный узел»). Названия книги на карточке нет: название написано в отдельном алфавитном указателе, это каталог (directory). Указатель хранит пары «имя, номер карточки». Где аналогия перестаёт работать: в библиотеке карточек обычно больше, чем нужно, а в ext4 их число задано при создании файловой системы и потом не растёт (в XFS inode динамические и создаются по мере надобности, но принцип «у файлов есть отдельный лимит» остаётся).

Вот что происходит с файлом по шагам:

  1. Когда ты создаёшь файловую систему командой mkfs (make filesystem), она делит раздел на блоки и заводит таблицу inodes заданного размера. Число inodes считается заранее: по умолчанию одна карточка на каждые несколько килобайтов раздела (для маленьких разделов около 4 КБ, для больших около 16 КБ). Так устроена ext4: её число inodes задаётся при создании и дальше не растёт. В XFS (файловая система по умолчанию в RHEL, Rocky, Alma) inodes выделяются динамически, и нехватка inodes там редка.
  2. Ты создаёшь файл note.txt. Ядро берёт свободный inode, записывает в него владельца, права, размер, время и список блоков, потом берёт свободные блоки под данные и, наконец, дописывает в каталог строку «note.txt = inode 12».
  3. Ты читаешь файл: ядро смотрит в каталог, находит номер 12, открывает карточку и идёт по списку блоков.
  4. Ты удаляешь файл командой rm: ядро стирает строку из каталога и уменьшает в карточке счётчик ссылок (number of links): сколько имён в каталогах указывают на эту карточку. Когда ссылок ноль (и файл никто не открыл, об этом дальше), карточка и блоки освобождаются.

Разобранный пример с настоящими числами. Мы создадим образ размером 64 МБ и попросим mkfs.ext4 -N 2000, то есть всего 2000 inodes. Сразу после создания df покажет (это настоящий вывод):

Filesystem      Size  Used Avail Use% Mounted on
/dev/loop0       60M   24K   55M   1% /mnt/small
Filesystem     Inodes IUsed IFree IUse% Mounted on
/dev/loop0       2000    11  1989    1% /mnt/small

Читаем: образ 64 МБ, но Size только 60M: часть места ушла на служебные структуры (журнал и сами таблицы). Avail 55M, а не 60M: ext4 оставляет около 5% блоков в резерве только для суперпользователя root, чтобы администратор мог зайти и прибраться, даже когда обычные пользователи заполнили всё. Из 2000 inodes уже занято 11: ими файловая система пользуется сама (каталог lost+found и служебные записи). Значит, можно создать не более 1989 файлов, вне зависимости от их размера.

Отсюда видно два независимых способа исчерпать диск:

  • кончились блоки: df -h показывает Use% 100%, файл записать нельзя;
  • кончились inodes: df -h показывает свободное место, а df -i показывает IUse% 100%. Создать новый файл нельзя, хотя места полно. Пустой файл занимает 0 блоков, но всё равно одну карточку. Типичная причина: миллионы крошечных файлов (сессии пользователей, кэш, письма в очереди).

В обоих случаях ошибка одинаковая: No space left on device («на устройстве не осталось места»). По тексту ошибки не отличить, поэтому первое, что делают, это df -h и df -i.

Прикинь сам: раздел с 100000 inodes, из них занято все 100000, а блоков занято 10%. Можно ли создать новый пустой файл?

Нельзя: для файла нужна карточка (inode), а они кончились. Будет No space left on device, хотя df -h показывает 90% свободно.

Частая ошибка: думать, что «диск свободен на 40%» гарантирует возможность записи. Нет: нужны и свободные блоки, и свободные inodes (и ещё права на запись в каталог, урок 1.3). Второе заблуждение: «пустые файлы ничего не занимают». Они занимают inode, а inodes конечны.

Что такое «смонтировать» и loop-устройство. В уроке 1.1 ты видел, что в Linux одно дерево каталогов и диски «подключаются» к его веткам. Подключение раздела к каталогу называется монтированием (mount), а каталог, куда он подключён, точкой монтирования (mount point). В практике мы сделаем это без настоящего второго диска: обычный файл small.img объявим «диском» через loop-устройство (loop device). Это возможность ядра притвориться, что файл это блочное устройство (диск): mount -o loop создаёт такое устройство, /dev/loop0, и подключает его. Так мы можем безопасно забить «диск» до отказа: системный раздел не пострадает.

Посмотреть, какие диски и разделы есть и куда они подключены, можно тремя командами:

  • lsblk (list block devices) рисует дерево дисков и разделов с размерами;
  • findmnt /var показывает, какой раздел подключён к каталогу /var и какая у него файловая система;
  • df -h показывает заполненность подключённых разделов.

Если раздел на LVM (менеджер томов, который позволяет менять размер разделов на лету) почти полон и в группе есть свободное место, его увеличивают одной командой: sudo lvextend -r -L +5G /dev/vg0/var. Ключ -r сразу растягивает и файловую систему. Имя тома у тебя будет своё: сначала посмотри lsblk.

Журнал ext4. Файловой системе нужна защита от сбоя питания посреди записи. Поэтому ext4 ведёт журнал (journal): сначала коротко записывает намерение («сейчас изменю эти блоки»), потом делает изменение. После аварии система по журналу доделывает или отменяет начатое, и сама файловая система остаётся целой. Но журнал защищает служебные таблицы (метаданные), а не содержимое: недописанный файл программы может оказаться обрезанным. Журнал занимает место внутри файловой системы, поэтому Size у df чуть меньше размера раздела.

Главное: у диска два лимита: блоки (сколько данных) и inodes (сколько файлов), и кончиться может любой; смотрят их df -h и df -i.

Проверь понимание: df -h показывает на /var 40% занято, а touch /var/x отвечает No space left on device. Что проверишь первым и что найдёшь?

Ответ

df -i /var. Скорее всего, IUse% равен 100%: блоков хватает, а карточек для новых файлов нет. Дальше ищешь каталог с огромным числом мелких файлов и убираешь лишнее.

df и du: два способа посмотреть на диск, которые расходятся

Есть два разных вопроса. «Сколько места занято на разделе в целом?» и «какие файлы и каталоги его занимают?». На них отвечают две разные команды, потому что отвечают они с разных сторон.

Ты стоишь у входа в кладовую. df это взгляд на счётчик на двери: «занято 41 полка из 60», не заходя внутрь. du это ревизор, который идёт вдоль полок и складывает размеры коробок. Обычно числа совпадают. Расходятся они, когда на счётчике полки занимает то, чего ревизор не видит.

  • df (disk free) спрашивает у самой файловой системы: «сколько блоков и inodes занято?». Это быстрый вызов ядра, файлы не перебираются.
  • du (disk usage) обходит каталоги, для каждого файла читает размер и суммирует. На большом разделе он медленный.

Поэтому они расходятся, когда происходит одно из двух:

  1. Файл удалён, но открыт процессом. Вспомни шаг 4 из предыдущего раздела: карточка и блоки освобождаются, когда ссылок ноль и файл никто не открыл. Процесс, который открыл файл (у него есть файловый дескриптор, урок 1.4), продолжает им пользоваться. Ты удалил имя, du файл больше не находит, потому что его нет ни в одном каталоге. А df продолжает считать блоки занятыми, пока процесс не закроет файл или не завершится. Классический случай: огромный лог, который удалили, а программа продолжает в него писать.
  2. Поверх каталога смонтирован другой раздел. Файлы, которые лежали в каталоге до монтирования, никуда не делись, но «закрыты» подключённым разделом: du их не видит, df их считает.

Есть и третья причина расхождения в цифрах, безобидная: du считает занятые блоки файлов, а не только размер данных, поэтому крошечный файл в 3 байта он покажет как 4K.

Как искать, что съело место. Идут сверху вниз: сначала df -h (какой раздел заполнен), потом sudo du -xh --max-depth=1 /var | sort -h | tail (какой каталог самый большой), потом то же самое внутри найденного каталога, и так до файла. Ключ -x не даёт du выходить за границы одного раздела: иначе в подсчёт попадёт всё, что подключено внутри (например, чужие тестовые разделы). sudo нужен, потому что часть каталогов закрыта для обычного пользователя (в прошлом уроке ты закрыл /var/lib/notes режимом 750).

flowchart TD
    A["df -h: какой раздел?"] --> B["du: какой каталог?"]
    B --> C{"du сходится с df?"}
    C -->|"да"| D["Убрать найденное"]
    C -->|"нет"| E["lsof +L1: кто держит"]
    E --> F["Перезапустить процесс"]

Разобранный пример: почему в практике du покажет 52K, а df 41M. Мы создадим файл 40 МБ, запустим tail -f (он открывает файл и держит его), а потом удалим файл. Настоящие цифры такого опыта: до удаления df показывает 41M занято. После rm df показывает всё те же 41M, а du -sh показывает 52K: это несколько служебных файлов ext4. Через lsof +L1 (список открытых файлов, у которых ссылок меньше одной, то есть удалённых) видим строку с NLINK 0 и пометкой (deleted): файл без имени, но живой. Освободить место можно тремя способами: закрыть файл (завершить процесс), перезапустить процесс или обнулить файл через /proc: truncate -s 0 /proc/<PID>/fd/<номер>. Последний способ не требует остановки процесса. Ты делал похожий шаг в уроке 1.4, когда смотрел /proc/<PID>/fd.

Предупреждение про truncate: так обнуляют только логи. Для базы данных, журнала WAL или файла, который программа читает как данные, обнуление выглядит как порча: программа продолжит писать со старой позиции и оставит дыру из нулей. Перед обнулением проверь, что это за файл: ls -l /proc/<PID>/fd и sudo lsof -p <PID>. Правильный путь для логов: настроить logrotate с режимом copytruncate или заставить программу переоткрыть файл сигналом SIGHUP (если она так умеет).

Прикинь сам: ты удалил лог на 5 ГБ, а df не изменился. Что это может быть и чем проверишь?

Файл удалён из каталога, но его держит открытым процесс, поэтому блоки не освобождены. Проверка: sudo lsof +L1 покажет такие файлы.

Осторожно: «Я удалил файл, значит место освободилось». Не всегда: если файл держит процесс, место вернётся только после закрытия. Второе: «du и df должны показывать одно и то же». Не должны, и расхождение само по себе является диагностикой.

Главное: df считает занятое разделом, du сумму файлов в каталогах; расходятся из-за удалённых, но открытых файлов и из-за монтирования поверх каталога.

Проверь понимание: Ты удалил лог на 5 ГБ, df не изменился. Какая команда покажет виновника и что она выведет?

Ответ

sudo lsof +L1. Она печатает открытые файлы со счётчиком ссылок меньше одной, то есть уже удалённые из каталога. В строке будут имя процесса, его PID и размер файла. Место вернётся, когда процесс закроет файл (перезапуск или переоткрытие лога).

Логи, tmpfs и выгрузки: три частые причины «диск кончился»

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

Пока вывозят мусор по расписанию, всё в порядке. Расписание сломалось, и бак переполнен. Три типичных виновника:

  1. Логи. Программа дописывает строки в файл лога (/var/log/...). Файл только растёт. Чтобы он не разрастался бесконечно, есть ротация логов (log rotation): по расписанию старый файл переименовывают, сжимают и удаляют самые старые копии. В Linux это делает logrotate. Если ротация сломана или лог пишется слишком бурно (например, включён режим отладки), диск заполняется за часы.
  2. tmpfs. Каталоги вроде /run и /dev/shm лежат в tmpfs: это файловая система, целиком живущая в оперативной памяти. Запись туда занимает не диск, а RAM, и исчезает после перезагрузки. В df -h такие разделы видны отдельными строками (tmpfs), и заполнить их можно, тогда No space left on device появится при свободном диске.
  3. Выгрузки и бэкапы. Файл вроде export/dump-2026-09.bin, который кто-то положил «на минуточку» и забыл. В сценарии 3 «Сломай и почини» именно так.

Сервис пишет 200 байт на каждый запрос и получает 100 запросов в секунду. В сутки это 200 × 100 × 86400 = 1 728 000 000 байт, то есть около 1,6 ГиБ. Без ротации диск на 50 ГиБ заполнится за 31 день, а с включённым отладочным логом, который пишет в десять раз больше, за три дня.

Прикинь сам: df -h показывает 100% на /run, а основной диск свободен на 70%. Что это значит?

/run это tmpfs, он живёт в оперативной памяти. Заполнен именно этот раздел, значит, надо искать, что пишет туда данные, и смотреть память.

Частая ошибка: считать, что каждый No space left on device связан с диском. На tmpfs это память, а на маленьком /boot это забытые старые ядра.

Как это видно у «Заметок». Запрос записи POST /notes возвращает 500 {"error": "storage"}, если код при записи получил ошибку операционной системы OSError. Чтение и /healthz продолжают работать, поэтому в одном мониторинге по коду 200 такую поломку не увидеть.

Главное: диск заполняют обычно логи без ротации, tmpfs и забытые выгрузки; ошибка No space left бывает и про память (tmpfs), и про inodes.

Память: free, available, кэш и swap

Диск в тысячи раз медленнее оперативной памяти. Поэтому программы работают с данными в памяти, а диск нужен для долгого хранения. Оперативная память (RAM) быстрая и небольшая, и её нужно делить между десятками процессов.

Ты работаешь за столом (память) и достаёшь бумаги из шкафа (диск). Пока стол не забит, ты не убираешь бумаги обратно: вдруг они понадобятся ещё раз. Так же ведёт себя ядро: прочитанные с диска файлы оно оставляет в свободной памяти. Это кэш файлов (page cache): в следующий раз файл прочитается из памяти, а не с диска. Как только программе нужно место, ядро мгновенно освобождает часть кэша. Где аналогия перестаёт работать: бумагу со стола можно только выбросить или унести в шкаф, а страницу кэша, которую не меняли, можно просто забыть, потому что копия уже есть на диске.

Как устроено: что показывает free -h. Ключ -h (human) печатает размеры в удобных единицах: Ki, Mi, Gi (кибибайты, мебибайты, гибибайты; 1 Mi = 1024 Ki, а не 1000, этим они отличаются от КБ, МБ, ГБ). Вот настоящий вывод:

               total        used        free      shared  buff/cache   available
Mem:           7.7Gi       972Mi       5.2Gi       1.6Mi       1.8Gi       6.8Gi
Swap:          1.0Gi          0B       1.0Gi
  • total: сколько всего памяти видит система (7,7 Gi).
  • used: занято программами (972 Mi). Сюда не входит кэш.
  • free: совсем никем не занято (5,2 Gi). У нагруженного сервера эта колонка почти всегда маленькая, и это нормально: свободная память простаивает зря, поэтому ядро заполняет её кэшем.
  • shared: память, которую делят между собой процессы, для нас не важна.
  • buff/cache: кэш файлов (1,8 Gi). Его можно отдать программам при необходимости.
  • available: главная колонка. Оценка того, сколько памяти можно выделить программам без выгрузки на диск: примерно free плюс та часть кэша, которую можно сбросить. Здесь 5,2 + 1,8 = 7,0, а показано 6,8, потому что часть кэша сбросить нельзя. Тревожиться надо, когда available мала, а не когда мала free.

Строка Swap это область подкачки. Swap это место на диске (раздел или файл), куда ядро выгружает редко нужные страницы памяти, чтобы освободить RAM. Программа, страницу которой выгрузили, при обращении вынуждена ждать чтения с диска. Если swap активно используется, а available мала, сервер тормозит: это насыщение (saturation) памяти. Небольшой объём swap «в простое» не проблема.

Сколько памяти занял процесс. У процесса есть два размера, VSZ и RSS; подробно их разберём в разделе про виртуальную память ниже. Пока запомни: настоящее потребление показывает RSS (RES в top). Пример из практики: свежий python3 app.py показывает RSS 19412 (килобайт), после /leak?mb=80 показывает RSS 101336. Разница: 101336 - 19412 = 81924 КБ, то есть 80 МБ (80 × 1024 = 81920 КБ) плюс несколько КБ служебных. Это подтверждает, что /leak занимает реальную память.

Прикинь сам: free -h показывает free 200Mi, available 6.1Gi при 8 ГБ. Паниковать?

Нет. Кэш занял «свободное» место, но ядро вернёт его по первому требованию, а это число и показывает available.

Частая ошибка: считать «free 150 МБ из 8 ГБ» аварией. Нет, смотри available. И думать, что «swap увеличивает память»: он подменяет быструю память медленной и только оттягивает беду.

Главное: о нехватке памяти говорит available, а не free; swap это медленное продолжение памяти, а не её увеличение.

Проверь понимание: На сервере free 150 МБ, available 5 ГБ, swap почти не тронут. Нужно ли что-то делать срочно?

Ответ

Нет. Память занята кэшем файлов, ядро вернёт её по первому требованию, и это число показывает available. Тревога начинается, когда available мала, а swap активно растёт.

Виртуальная память: почему «выделить» не значит «занять»

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

Из этого два размера процесса:

  • VSZ (VIRT в top, virtual size): сколько памяти процесс запросил, то есть сумма обещаний;
  • RSS (RES в top, resident set size): сколько реально лежит в оперативной памяти сейчас. Страницы (куски по 4 КБ) выдаются при первой записи, тогда RSS и растёт.

bytearray(80 * 1048576) в Python сразу заполняет массив нулями, то есть пишет в каждую страницу. Поэтому RSS вырос на все 80 МБ (задание 5). Если бы память только запросили и не писали, вырос бы VSZ, а RSS нет. Что будет, когда обещаний накопилось больше, чем есть памяти, читай дальше.

Прикинь сам: ты шлёшь сервису /leak?mb=80, и он выделяет 80 МБ и сразу заполняет их нулями. Какая колонка в ps вырастет: VSZ, RSS или обе?

Обе: VSZ вырастает, потому что память запрошена, а RSS потому, что bytearray записал нули в каждую страницу. Если бы память только запросили и не трогали, вырос бы один VSZ. Поэтому на утечку смотрят по RSS: у Java или Go VSZ и так в разы больше реальной памяти, и паниковать от него не надо.

Главное: выделить не значит занять: ядро записывает обещание (VSZ), а реальные страницы (RSS) выдаёт при первой записи.

OOM-killer и cgroup: что происходит, когда память кончилась

Представь: память кончилась, а процессы продолжают в неё писать. Кого выкинуть? Система либо зависнет, либо ядро выберет жертву. Второй вариант называется OOM-killer (Out Of Memory killer, «убийца при нехватке памяти»). Отказать программе в запросе памяти ядро почти не умеет: оно уже пообещало (см. выше), и проблема всплывает позже, когда программа начинает писать.

У лифта есть предел по весу. Когда зашли лишние, кто-то должен выйти, иначе лифт не поедет. Ядро выбирает того, кто «весит больше всех» и менее важен, и выводит из лифта принудительно. Где аналогия слабая: выведенный процесс не может возразить или собрать вещи, он просто исчезает.

Вот как это происходит по шагам:

  1. Процесс просит память и получает её, пока хватает.
  2. Когда свободной памяти нет и кэш сбросить уже нечем, ядро включает OOM-killer.
  3. Ядро для каждого процесса считает «счёт» (oom_score, его видно в /proc/<PID>/oom_score): чем больше памяти занял процесс, тем счёт выше.
  4. Процесс с наибольшим счётом получает SIGKILL (сигнал 9, урок 1.4): его нельзя перехватить, он не успевает ничего сохранить и не может корректно завершиться.
  5. Ядро пишет в свой журнал строку про убийство. Код выхода убитого процесса 137 (128 + 9, урок 1.4).
flowchart TD
    A["Процесс просит память"] --> B{"Свободная есть?"}
    B -->|"да"| C["Выдать страницы"]
    B -->|"нет"| D["Сбросить кэш и swap"]
    D -->|"помогло"| C
    D -->|"нет"| E["OOM-killer: oom_score"]
    E --> F["SIGKILL худшему"]
    F --> G["Журнал ядра, код 137"]

Журнал ядра читают командой dmesg (-T печатает понятное время). Ubuntu запрещает обычному пользователю читать его, поэтому нужен sudo.

Ограничение внутри группы: cgroup. Бывает, что ядру не нужно ждать, пока кончится память всего сервера: для группы процессов задан свой лимит. Такая группа называется cgroup (control group, «контрольная группа»): механизм ядра Linux, который ограничивает и учитывает ресурсы группы процессов. Именно так работают лимиты памяти у контейнеров Docker и у подов Kubernetes (темы 4 и 5). Если процессы группы вышли за лимит, OOM-killer убивает процесс внутри неё, остальной сервер не страдает. Проще всего создать такую группу командой systemd-run (её подробнее разберём в уроке 1.8): она запускает команду в новой группе с заданными ограничениями. Для нас важны два свойства: MemoryMax=200M (лимит 200 МБ) и MemorySwapMax=0 (запрет swap для группы, иначе ядро начнёт выгружать память на диск, а не убивать процесс).

Разобранный пример: строка из журнала ядра. Настоящая строка, которую ты получишь в практике:

[Wed Sep 30 12:01:13 2026] Memory cgroup out of memory: Killed process 105959 (python3) total-vm:346976kB, anon-rss:203564kB, file-rss:9408kB, shmem-rss:0kB, UID:1000 pgtables:476kB oom_score_adj:0
  • Memory cgroup out of memory: OOM внутри группы с лимитом. Если бы кончилась память всей машины, было бы Out of memory: Killed process ... без слова cgroup.
  • Killed process 105959 (python3): кого убили, номер и имя. (На обычной ВМ этот PID совпадает с PID в ps. В примере выше журнал снят на стенде-контейнере, поэтому номер в нём другой.)
  • total-vm:346976kB: виртуальный размер (VSZ), около 339 МБ.
  • anon-rss:203564kB: «анонимная» память, которую программа выделила сама (куча, наш bytearray), около 199 МБ. Это почти весь лимит 200 МБ, то есть причина убийства видна.
  • file-rss:9408kB: память под файлы (библиотеки Python).
  • UID:1000: чей процесс.

OOM в Kubernetes. Под (pod, группа контейнеров, тема 5) с лимитом памяти это та же cgroup, поэтому всё выше работает один в один.

  • Лимит пода resources.limits.memory превращается в файл memory.max его cgroup (в cgroup v1 он называется memory.limit_in_bytes). MemoryMax из нашего systemd-run это то же самое ограничение, только под именем systemd. Вышел за лимит: SIGKILL, код выхода 137.
  • Первое, что смотрят: kubectl describe pod ИМЯ. В разделе Last State будет Terminated, Reason: OOMKilled, Exit Code: 137.
  • Внутри контейнера счётчик убийств лежит в /sys/fs/cgroup/memory.events (строка oom_kill 1), а текущее потребление в memory.current.
  • Если памяти не хватает на всём узле, работают два разных механизма. Ядро Linux убивает процессы по числу oom_score_adj: kubelet ставит его по классу QoS (Quality of Service), и первыми гибнут поды BestEffort (без запросов и лимитов), потом Burstable, последними Guaranteed (запрос равен лимиту). А сам kubelet заранее выселяет (evicts) поды, которые вышли за свои запросы памяти, начиная с менее важных по приоритету.
  • С процессором иначе: упёрся в лимит CPU, процесс не убивают, а притормаживают (throttling). В Prometheus это метрика container_cpu_cfs_throttled_periods_total: растёт, значит под тормозит из-за лимита, хотя узел свободен.

Прикинь сам: процесс в контейнере с лимитом 512 МБ исчез, а на сервере свободно 20 ГБ. Как так?

Лимит cgroup сработал раньше, чем кончилась память сервера: OOM-killer убил процесс внутри группы. Подтверждение: строка в dmesg или journalctl -k.

Осторожно: «Код 137 значит OOM, и точка». Нет: 137 значит только «убит SIGKILL». Так мог убить и человек командой kill -9, и менеджер сервисов по таймауту. Что это именно OOM, доказывает строка в dmesg. Второе заблуждение: «в логах приложения тишина, значит не OOM». Убитый процесс не успевает написать в лог: следы надо искать в журнале ядра.

Главное: OOM-killer шлёт SIGKILL процессу с наибольшим счётом, а код 137 говорит только об убийстве сигналом, а не о причине.

Проверь понимание: Под перезапустился с кодом 137. Как доказать, что это был именно OOM, а не kill -9?

Ответ

Смотреть kubectl describe pod: Reason: OOMKilled в Last State, и строку Out of memory: Killed process в dmesg или journalctl -k. Сам код 137 доказывает только SIGKILL.

Утечка памяти: как процесс занимает память и не отдаёт её

Программа получает память у ядра порциями и обязана вернуть ненужное. Возвращает её либо сама (явно), либо специальный «уборщик» языка (в Python это сборщик мусора, garbage collector: он находит объекты, на которые больше никто не ссылается, и освобождает их). Если программа продолжает держать ссылку на данные, которые ей давно не нужны, уборщик не имеет права их забрать. Память занята, польза нулевая. Это утечка памяти (memory leak). Понимать её нужно, потому что в нашем уроке мы вызовем утечку специально, а на работе будем отличать её от честного роста потребления.

Повар достаёт со склада коробки и ставит на стол. Готовое блюдо ушло, а пустые коробки он не выносит: «вдруг пригодятся». За смену стол забит коробками, и класть новые продукты некуда. Где аналогия слабее: коробки повар может вынести в любой момент, а программа без своего решения освободить память не может, если сама держит на неё ссылку.

Вот как это происходит по шагам:

  1. Программа создаёт объект (список, строку, массив байтов), и интерпретатор просит у ядра страницы памяти под него.
  2. Пока на объект есть хотя бы одна ссылка (переменная, элемент списка, запись в глобальном хранилище), он «живой».
  3. Когда ссылок не остаётся, объект освобождается, и память возвращается интерпретатору. Интерпретатор не всегда отдаёт её обратно ядру сразу, поэтому RSS процесса после освобождения падает не всегда.
  4. Утечка это когда ссылки копятся: например, список, в который каждый запрос добавляет данные и который никто не чистит.

Разобранный пример из нашего кода. В app.py (задание 4) есть глобальный список LEAK = []. Запрос /leak?mb=80 делает LEAK.append(bytearray(80 * 1048576)). Считаем: 1048576 это 1024 × 1024 байт, то есть один мегабайт. 80 × 1048576 = 83 886 080 байт, это и есть 80 МБ. Массив лежит в LEAK, ссылка на него хранится до конца жизни процесса, поэтому память не освобождается никогда. Два запроса дают 160 МБ, три 240 МБ, и так до отказа. Именно так выглядит утечка на графике: память растёт ступеньками и не спадает даже ночью, когда запросов нет.

Как отличить утечку от нормы. Нормальное потребление растёт с нагрузкой и падает вместе с ней. Утечка растёт независимо от нагрузки и падает только после перезапуска процесса. Поэтому смотрят тренд за сутки, а не один снимок.

Прикинь сам: RSS сервиса растёт на 30 МБ в час и не спадает, хотя ночью запросов нет. Это норма?

Нет, это похоже на утечку: нормальная память растёт с нагрузкой и падает вместе с ней. Надо снять рост по времени и найти, что копится.

Осторожно: «Память процесса выросла, значит утечка». Нет: кэш в самом приложении, пул соединений и буферы тоже растут и потом стабилизируются. Утечка это рост без остановки.

Главное: утечка это память, которая растёт независимо от нагрузки, потому что ссылки на ненужные данные копятся и объекты не освобождаются.

Процессор: ядра, очередь и load average

Программ запущено больше, чем в процессоре ядер, но каждое ядро процессора в каждый момент выполняет одну программу. Чтобы всем хватало, ядро Linux нарезает время на очень короткие кусочки (миллисекунды) и по очереди выдаёт их процессам. Пользователю кажется, что всё работает одновременно.

Ядра процессора это кассы, процессы это покупатели. Каждая касса обслуживает одного человека за раз. Если покупателей меньше, чем касс, очередей нет. Если больше, образуется очередь, и каждый ждёт дольше. Число касс узнают командой nproc. Где аналогия слабее: покупатель стоит в очереди целиком, а процесс ядро постоянно «отзывает от кассы» на другой кусочек.

Load average и nice уже были в уроке 1.4 (раздел «Приоритет и load average»): load это длина очереди за 1, 5 и 15 минут, а nice решает, кто уступает ядро при нехватке ядер. Здесь только то, что нужно для диагностики.

Реальный вывод uptime:

 11:52:13 up 23 min,  0 user,  load average: 0.81, 0.19, 0.06

Само число ничего не значит без числа ядер. Правило: load, делённый на nproc. Load 4,0 на 4 ядрах: все заняты, очереди нет. Load 4,0 на 2 ядрах: ядра перегружены вдвое. Процессы в состоянии D (ждут диск) тоже входят в load, поэтому высокий load бывает при свободном процессоре.

Новый пример. uptime показывает load average: 6.0, 5.8, 1.1 на сервере с 4 ядрами. Как читать: 6,0 на 4 ядра это очередь примерно из двух процессов; 1 и 5 минут почти равны, а 15 минут мал, значит, перегрузка началась минут пять-десять назад и держится. Дальше открывают top: если us и sy высокие и наверху python3 с большим %CPU, виноват процесс; если us низкий, а wa высокий, процессы стоят за диском, и процессор ни при чём.

Прикинь сам: load 8 на 4 ядрах, но us + sy вместе всего 10%, а wa 85%. Что искать?

Не процесс, который «жрёт CPU», а медленный или забитый диск: процессы стоят в очереди за диском (состояние D), а не за процессором. Смотреть iostat -x 1 (колонка %util) и top, кто в состоянии D.

Частая ошибка: считать, что «load 12 значит процессор перегружен». Не обязательно: если процессы висят в состоянии D, процессор свободен, а виноват диск.

Главное: load average делят на число ядер; высокий load при низком us и высоком wa значит диск, а не процессор.

Проверь понимание: uptime показывает load average: 1.1, 5.8, 6.0 на 4 ядрах. Что это значит?

Ответ

Перегрузка была недавно и уже спадает: 15 минут назад load был 6,0 (очередь около двух процессов на 4 ядра), сейчас 1,1. Читай тройку справа налево, от старого к новому.

top: на что тратится время процессора

Load говорит «очередь есть», но не говорит, кто и на что тратит время. Для этого есть top: список процессов, отсортированный по нагрузке, с шапкой про общее состояние. Ключи -b -n 2 -d 1 включают пакетный режим (вывод в терминал без интерактива) и два замера с паузой 1 секунду: первый замер в top всегда усреднён за всё время работы системы и потому не годится для диагностики.

Управляющий магазином смотрит на экран: сколько касс работает (us, sy), сколько простаивает (id), сколько стоит и ждёт поставщика (wa).

Как устроено: шапка. Строка процессора в top:

%Cpu(s): 14.0 us,  0.2 sy,  0.0 ni, 85.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st

Все значения это проценты времени за последний интервал, от суммарной мощности всех ядер CPU:

  • us (user): время в коде самих программ, то есть вычисления;
  • sy (system): время в ядре Linux по просьбе программ (чтение файлов, сеть);
  • ni (nice): то же, что us, но для процессов с пониженным приоритетом (nice, урок 1.4);
  • id (idle): простой, процессор свободен;
  • wa (iowait): процессор простаивает, потому что все, кому он нужен, ждут диск или сеть. Высокое wa при высоком load указывает на диск;
  • hi, si: обработка прерываний (сигналов от железа), на серверах в норме около нуля;
  • st (steal): у виртуальных машин: гипервизор (программа, на которой работает ВМ) отдал ядра CPU другой машине. Это чужая нагрузка на том же железе, помочь изнутри ВМ нельзя.

Ниже идёт таблица процессов. Главные колонки: PID, USER, S (состояние, урок 1.4), RES (RSS, память), %CPU, COMMAND. Важный нюанс: %CPU процесса считается от одного ядра, поэтому может быть больше 100% (у процесса с несколькими потоками на нескольких ядрах). А us в шапке считается от всех ядер сразу.

Пример на двух ядрах. Один процесс крутит цикл без остановки. В таблице у него %CPU 100: это одно ядро целиком. В шапке us около 50%: одно ядро из двух, 100 / 2. На четырёх ядрах было бы около 25%, на восьми около 12%. Поэтому по шапке нельзя сказать «процессор свободен», если один процесс упёрся в своё ядро.

Почему три одновременных /burn не займут три ядра. У Python есть GIL (Global Interpreter Lock, «глобальная блокировка интерпретатора»): в каждый момент Python-код исполняет только один поток, остальные ждут. Наш сервер создаёт по потоку на запрос, но все потоки делят одну «кассу». Поэтому сколько бы запросов /burn ни шло параллельно, python3 не превысит примерно 100% одного ядра. Мы это увидим в сценарии «Сломай и почини». Вывод для диагностики: сервис может быть «перегружен» при том, что load небольшой, если он упёрся в своё одно ядро. Поэтому смотри не только uptime, но и %CPU процесса в top.

Прикинь сам: в top процесс показывает %CPU 350, а на сервере 8 ядер. Согласуется ли это с us 44% в шапке?

Да: %CPU процесса считают от одного ядра, 350% это 3,5 ядра, а 44% от 8 ядер это тоже около 3,5 ядра.

Частая ошибка: читать %Cpu(s) и %CPU процесса как одно и то же. Первое считается от суммы всех ядер, второе от одного. Вторая ошибка: смотреть только на us и не замечать wa или st.

Главное: в шапке top процент от всех ядер, у процесса от одного ядра; смотри us, sy, wa, st и сравнивай с load.

Откуда команды берут числа: /proc

free, top, uptime и ps сами ничего не измеряют: они читают «виртуальное» дерево файлов /proc (в уроке 1.4 ты уже заглядывал в /proc/<PID>). Файлов на диске там нет: когда ты читаешь такой файл, ядро на лету собирает текст из своих счётчиков. Поэтому free и cat /proc/meminfo показывают одни и те же числа.

Что полезно помнить: /proc/meminfo (память), /proc/loadavg (load average; строка 0.81 0.19 0.06 1/93 4218 это три load, затем «готовых к работе из существующих» и последний PID), /proc/<PID>/status и /proc/<PID>/fd/ (данные процесса и его открытые файлы), /proc/<PID>/oom_score (счёт для OOM-killer). Размер файлов в /proc показывается нулевым, и места на диске они не занимают.

Главное: /proc это окно в память ядра, а не файлы на диске; команды читают из него и ничего не измеряют сами.

USE: один чек-лист на любой ресурс

Когда сервер тормозит, есть соблазн «попробовать что-нибудь»: перезапустить, добавить памяти. Есть готовый приём, метод USE: для каждого ресурса по очереди задать три одинаковых вопроса и не пропускать ни один ресурс. Так диагностика не зависит от вдохновения.

На приёме не начинают с операции, а меряют пульс, давление, температуру. Три вопроса USE это «стандартные замеры» для сервера.

Для каждого ресурса:

  • U (Utilization, занятость): насколько ресурс занят, в процентах;
  • S (Saturation, насыщение): есть ли очередь или ожидание, то есть что-то хочет ресурс и не может получить;
  • E (Errors, ошибки): есть ли отказы и сбои.

Для наших ресурсов:

Ресурс Занятость (U) Насыщение (S) Ошибки (E)
Процессор top: us + sy load выше nproc; vmstat, колонка r редко
Память free -h: available swap in/out (vmstat: si, so) OOM-killer в dmesg
Диск (место) df -h: Use% нет No space left on device
Диск (inodes) df -i: IUse% нет тот же No space left on device
Справка: диск (ввод-вывод), сеть и контейнеры по USE
Ресурс Занятость (U) Насыщение (S) Ошибки (E)
Диск (ввод-вывод) iostat -x 1: %util iostat: aqu-sz, await; top: wa dmesg: ошибки ввода-вывода
Сеть sar -n DEV 1: rxkB/s, txkB/s ss -s, очереди в ss -tn ip -s link: errors, dropped
Контейнеры (K8s) kubectl top pod /proc/pressure/* (PSI) OOMKilled в kubectl describe pod

iostat и sar входят в пакет sysstat, по умолчанию его на сервере нет (sudo apt install sysstat). kubectl top показывает расход пода, если в кластере стоит metrics-server.

Про насыщение есть готовый показатель без догадок: PSI (Pressure Stall Information). Это файлы /proc/pressure/cpu, memory и io: ядро само пишет, какую долю времени процессы стояли в ожидании ресурса. Строка some avg10=0.00 значит «за 10 секунд хотя бы один процесс ждал 0% времени». Строка full значит «ждали все процессы сразу», то есть работа остановилась полностью. Эти файлы в задании 5 мы прочитаем сами.

vmstat (virtual memory statistics) печатает сводку раз в секунду. Настоящий вывод vmstat 1 3 (три замера с шагом 1 секунда, первая строка это среднее с момента запуска, смотри следующие):

procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st gu
 1  0      0 3629156 322648 3167832    0    0   227  3974 2279    2  1  0 99  0  0  0
 1  0      0 3632352 322648 3167828    0    0     0     8 3682 4238  7  0 92  0  0  0
 1  0      0 3646800 322648 3167828    0    0     0    12 3271 3340  8  0 92  0  0  0

r это число процессов, которые готовы выполняться или выполняются (очередь на CPU), b число процессов в состоянии D (ждут диск). swpd сколько swap занято, si и so сколько KiB в секунду читается из swap и записывается в него (ненулевые постоянно значит, что идёт обмен с диском: память кончается). Колонки us sy id wa st те же, что в top. Колонка gu (время гостя, если на машине запущены виртуальные машины) нам не нужна.

Как «Заметки» показывают нехватку ресурса. Для нашего сервиса из app.py:

Что случилось Что увидит клиент
Кончилось место или inodes POST /notes возвращает 500 {"error": "storage"} (код add_note ловит OSError), а GET /healthz по-прежнему 200
OOM-killer убил процесс обрыв соединения, потом Failed to connect ... Couldn't connect to server: слушателя больше нет
Процесс упёрся в CPU ответы медленные, top показывает python3 около 100%

Обрати внимание на первую строку: «сервис жив, но не может записывать». Проба /healthz такое не ловит. Поэтому /readyz в app.py проверяет право записи в каталог данных, а мониторинг проверяет и место на диске.

Прикинь сам: сервер тормозит. С чего начнёшь по методу USE?

С полного прохода по ресурсам (процессор, память, диск, сеть): для каждого проверить занятость, очередь и ошибки. Только так можно ответить на вопрос «не диск ли виноват».

Частая ошибка: диагностировать «по ощущению» одним ресурсом. Метод USE заставляет пройти все и отвечает на вопрос «а не диск ли?» до того, как ты полез искать утечку в коде.

flowchart LR
    S["Сервер тормозит"] --> CPU["Процессор: top"]
    S --> MEM["Память: free"]
    S --> DSK["Диск: df, iostat"]
    CPU --> R["U, S, E по каждому"]
    MEM --> R
    DSK --> R
    R --> V["Виноватый найден"]

Главное: USE: для каждого ресурса проверяем Utilization (занятость), Saturation (очередь), Errors (ошибки) и не лечим «по ощущению».

Проверь понимание: Процессор занят на 30%, но сервис тормозит. Закрывает ли это вопрос про процессор по методу USE?

Ответ

Нет. Занятость это только U. Надо ещё посмотреть очередь (load на ядро, r в vmstat) и ошибки. И не останавливаться на процессоре: пройти память и диск, потому что причина может быть там.

Что будет в алерте и что делать

Ночью ты увидишь не лекцию, а короткое сообщение мониторинга. Для трёх ресурсов этого урока оно выглядит так (пороги ориентировочные, у каждой команды свои):

Алерт Порог Первая команда Эскалация
Диск заполняется df выше 80-85%; лучше прогноз: Prometheus predict_linear(node_filesystem_avail_bytes[6h], 4*3600) < 0 («кончится за 4 часа») df -h, потом sudo du -xh --max-depth=1 / \| sort -h \| tail корневой раздел, база данных или очередь: звать старшего сразу; остальное, если место не освобождено за 15 минут
Память available ниже 10% от total, или в dmesg есть Killed process free -h, ps aux --sort=-rss \| head, sudo dmesg -T \| grep -i killed процесс снова убит или available падает: звать старшего
Inodes df -i: IUse% выше 85% df -i, поиск каталога с кучей файлов (find из сценария 4) корневой раздел, база данных или очередь: звать старшего сразу; остальное, если за 15 минут не освободили

Прогноз важнее порога: диск на 70%, который растёт на 8 пунктов в час, опаснее диска на 90%, который не двигается неделями. В графике из начала урока именно прогноз разбудил бы тебя в 23:00, а не в 03:00.

Теория закончена. В практике ты сам увидишь df, free и top, а потом сломаешь «Заметки» утечкой и нагрузкой.

Практика

Все задания выполняются на твоей ВМ с Ubuntu из урока 1.1. Нужны пакеты lsof и e2fsprogs (утилита mkfs.ext4): в Ubuntu Server они обычно уже есть, если нет, поставь:

sudo apt install -y lsof e2fsprogs   # -y: сразу отвечать «да» на вопрос об установке

Выводы в уроке настоящие, снятые на стенде с Ubuntu 24.04: это контейнер на 15 ядрах, поэтому df / показывает overlay, а nproc даёт 15. У тебя ВМ с 2-8 ядрами. Имена разделов, PID, время и размеры у тебя будут другие: важна структура.

Задание 1. Осмотр: df, du, free, uptime, vmstat

Цель: за минуту собрать картину USE по трём ресурсам.

Предскажи: сколько процентов занимает / на твоём сервере, и что будет больше: free или available? Запиши до запуска.

Ответ

available всегда не меньше free, потому что включает кэш, который можно освободить. Процент / у каждого свой; для чистой ВМ обычно 10-30%.

Разбор команд перед запуском:

  • df -h /: df (disk free) печатает занятость разделов, -h (human) выводит размеры в МБ и ГБ, / ограничивает вывод разделом, на котором лежит корень. df -i / то же для inodes.
  • free -h: память и swap, разобрана в теории.
  • nproc: число ядер процессора.
  • uptime: время работы и load average.
  • sudo du -xh --max-depth=1 /var 2>/dev/null | sort -h | tail -4: du считает размеры, -x не выходит за границы раздела, -h в удобных единицах, --max-depth=1 печатает только сам /var и его каталоги первого уровня, а не все вложенные. Дальше конвейер (урок 1.2): sort -h сортирует по размеру с учётом суффиксов K, M, G (без -h «10M» встанет перед «9M»), tail -4 оставляет четыре последние строки, то есть самые большие. 2>/dev/null выбрасывает сообщения об ошибках: ты помнишь, что ошибки идут в поток stderr, и здесь мы прячем шум про закрытые каталоги.
  • vmstat 1 3: три замера памяти и процессора с шагом секунда.

Шаги:

  1. Посмотри диск, inodes, память, число ядер и load:
df -h /             # место на корневом разделе
df -i /             # inodes на корневом разделе
free -h             # память и swap
nproc               # число ядер
uptime              # load average за 1, 5, 15 минут
  1. Найди самые большие каталоги в /var и посмотри сводку vmstat:
sudo du -xh --max-depth=1 /var 2>/dev/null | sort -h | tail -4
vmstat 1 3

Что должно получиться (у тебя числа другие):

Filesystem      Size  Used Avail Use% Mounted on
overlay         911G  8.5G  856G   1% /
Filesystem       Inodes  IUsed    IFree IUse% Mounted on
overlay        60710912 125038 60585874    1% /
               total        used        free      shared  buff/cache   available
Mem:           7.7Gi       972Mi       5.2Gi       1.6Mi       1.8Gi       6.8Gi
Swap:          1.0Gi          0B       1.0Gi
15
 11:52:13 up 23 min,  0 user,  load average: 0.81, 0.19, 0.06
2.4M	/var/cache
8.2M	/var/lib
17M	/var/log
27M	/var
procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st gu
 1  0      0 3629156 322648 3167832    0    0   227  3974 2279    2  1  0 99  0  0  0
 1  0      0 3632352 322648 3167828    0    0     0     8 3682 4238  7  0 92  0  0  0
 1  0      0 3646800 322648 3167828    0    0     0    12 3271 3340  8  0 92  0  0  0

Как читать вывод:

  • Первая пара строк это df: Filesystem (имя раздела; у тебя, скорее всего, /dev/vda1 или /dev/sda1, в примере overlay, потому что стенд это контейнер), Size размер, Used занято, Avail доступно, Use% процент, Mounted on куда подключён. Вторая пара это те же колонки, но для inodes: IUsed занято карточек, IFree свободно.
  • free: колонки разобраны в теории. Главное: available 6,8 Gi много, Swap использован на 0.
  • 15 это nproc: на стенде, где снят пример, 15 ядер CPU. У твоей ВМ, скорее всего, от 2 до 8.
  • uptime: время 11:52:13, работает 23 минуты, 0 user (сеансов пользователей), три числа load average: 0,81 за минуту, 0,19 за 5, 0,06 за 15. Они меньше nproc, значит, очереди нет. Первое число больше остальных: недавно что-то нагружало сервер, сейчас затихает.
  • Четыре строки du это /var/cache, /var/lib, /var/log и итог по /var: в этом порядке, самый большой внизу.
  • vmstat: r 1 (один процесс в очереди), b 0, si и so нули (swap не работает), id 92 (процессор простаивает), wa 0. Первая строка vmstat это среднее с момента запуска, её игнорируют.

Типичные ошибки:

  • du: cannot read directory '/var/lib/notes': Permission denied: du запущен без sudo и не видит чужие каталоги, итог занижен. Запускай с sudo (права, урок 1.3): каталог /var/lib/notes принадлежит пользователю notes с режимом 750.

Задание 2. Диск: место и inodes на тестовом разделе

Цель: воспроизвести оба вида «диск закончился» на изолированном образе, не рискуя системным диском.

Предскажи: в образе 64 МБ мы создадим файл 100 МБ, потом отдельно много пустых файлов. Какая ошибка будет в каждом случае, и что покажет df -h во втором случае?

Ответ

Обе ошибки No space left on device. В первом df -h покажет 100% места, во втором места почти не занято (пустые файлы весят 0 блоков), зато df -i покажет IUse% 100%.

Разбор команд перед запуском:

  • truncate -s 64M small.img: создаёт файл размером ровно 64 МБ (-s size). Файл «разреженный»: сначала он почти не занимает места на диске, потому что состоит из нулей, которых физически нет.
  • mkfs.ext4 -q -N 2000 small.img: создаёт в файле файловую систему ext4. -q (quiet) убирает болтливый вывод, -N 2000 задаёт число inodes: нам нужно маленькое число, чтобы исчерпать его быстро.
  • sudo mount -o loop small.img /mnt/small: подключает образ к каталогу /mnt/small. -o loop (option) включает loop-устройство из теории. sudo нужен, потому что монтировать может только root.
  • sudo chown "$USER": /mnt/small: делает тебя владельцем точки монтирования, иначе писать в неё сможет только root. Переменная $USER это твоё имя, а двоеточие после неё значит «и группу поставить твою же». Кавычки защищают от пробелов в имени.
  • dd if=/dev/zero of=/mnt/small/big.bin bs=1M count=100 status=none: dd копирует данные. if (input file) это источник, /dev/zero специальный «файл», который выдаёт бесконечные нули; of (output file) куда писать; bs=1M блоками по 1 МБ; count=100 сто блоков, то есть 100 МБ; status=none убирает итоговую статистику.
  • for i in $(seq 1 2100); do : > /mnt/small/f$i; done 2>&1 | tail -2: цикл (подробнее в уроке 1.6). seq 1 2100 печатает числа от 1 до 2100, $(...) подставляет результат на место. Для каждого числа i команда : > /mnt/small/f$i создаёт пустой файл: : встроенная команда «ничего не делать», а > перенаправляет её (пустой) вывод в файл, создавая его. 2>&1 направляет сообщения об ошибках (stderr) в тот же поток, что и вывод, а | tail -2 показывает последние две строки, то есть последние ошибки.
  • ls /mnt/small | wc -l: wc -l (word count, lines) считает строки, то есть файлы в каталоге.

Шаги:

  1. Создай образ 64 МБ и файловую систему с малым числом inodes, смонтируй:
mkdir -p ~/lab && cd ~/lab
truncate -s 64M small.img                     # файл-«диск» размером 64 МБ
mkfs.ext4 -q -N 2000 small.img                # ext4, всего 2000 inodes
sudo mkdir -p /mnt/small
sudo mount -o loop small.img /mnt/small       # подключаем образ как раздел
sudo chown "$USER": /mnt/small
df -h /mnt/small && df -i /mnt/small
  1. Заполни место:
dd if=/dev/zero of=/mnt/small/big.bin bs=1M count=100 status=none
df -h /mnt/small
  1. Освободи и исчерпай inodes:
rm /mnt/small/big.bin
for i in $(seq 1 2100); do : > /mnt/small/f$i; done 2>&1 | tail -2
df -h /mnt/small && df -i /mnt/small
  1. Найди, где лежит куча файлов, попробуй создать ещё один и убери всё:
ls /mnt/small | wc -l
touch /mnt/small/new
rm -f /mnt/small/f*
df -i /mnt/small

Что должно получиться (по шагам 1-4):

Filesystem      Size  Used Avail Use% Mounted on
/dev/loop0       60M   24K   55M   1% /mnt/small
Filesystem     Inodes IUsed IFree IUse% Mounted on
/dev/loop0       2000    11  1989    1% /mnt/small
dd: error writing '/mnt/small/big.bin': No space left on device
Filesystem      Size  Used Avail Use% Mounted on
/dev/loop0       60M   55M     0 100% /mnt/small
bash: /mnt/small/f2099: No space left on device
bash: /mnt/small/f2100: No space left on device
Filesystem      Size  Used Avail Use% Mounted on
/dev/loop0       60M   56K   55M   1% /mnt/small
Filesystem     Inodes IUsed IFree IUse% Mounted on
/dev/loop0       2000  2000     0  100% /mnt/small
1990
touch: cannot touch '/mnt/small/new': No space left on device
Filesystem     Inodes IUsed IFree IUse% Mounted on
/dev/loop0       2000    11  1989    1% /mnt/small

Как читать вывод:

  • Начало: пустой «диск». Size 60M (не 64: служебные структуры), Avail 55M (минус резерв root), inodes: 2000 всего, 11 занято самой файловой системой.
  • dd: error writing ... No space left on device: dd записал всё, что смог, и упёрся в предел. Ты обычный пользователь, поэтому резерв root тебе недоступен: Used 55M, Avail 0, Use% 100%.
  • После удаления big.bin место вернулось. Дальше цикл создаёт файлы, пока не кончатся inodes. Сообщения показывают только последние две ошибки (f2099, f2100).
  • Главная пара: df -h показывает Use% 1%, места 55M, а df -i показывает IUse% 100%. Ошибка одна и та же, а причина другая. Это самая важная строка задания.
  • ls | wc -l дал 1990: 1989 файлов плюс каталог lost+found. Совпадает с расчётом: 1989 свободных inodes на старте.
  • После rm -f /mnt/small/f* inodes вернулись: IUsed снова 11.

Типичные ошибки:

  • umount: /mnt/small: target is busy: твой терминал стоит внутри /mnt/small, выйди командой cd ~ и повтори.

Не знаешь, что значит строка из lsof, df или free? Дай нейросети вывод вместе с командой и спроси, что означает каждая колонка. Потом проверь: колонки в man, числа через /proc.

Задание 3. Удалённый файл, который держит процесс

Цель: увидеть случай, когда df и du расходятся, и вернуть место без перезапуска процесса.

Предскажи: ты удаляешь файл, который читает запущенная программа. Освободится ли место на df? Что покажет du?

Ответ

Место не освободится: пока есть открытый дескриптор (file descriptor), inode и блоки живут. du файла не найдёт (имени нет), df продолжит показывать занятое место.

Разбор команд перед запуском:

  • tail -f /mnt/small/log.big > /dev/null &: tail -f (follow) открывает файл и «следит» за ним, ожидая новых строк. Вывод мы выбрасываем в /dev/null, & отправляет процесс в фон (урок 1.4). Пока он жив, файл открыт.
  • TAILPID=$!: $! это PID последнего фонового процесса (урок 1.4). Мы кладём его в переменную TAILPID, чтобы позже обратиться к нему.
  • sudo lsof +L1 /mnt/small: lsof (list open files) показывает открытые файлы. +L1 оставляет только те, у которых число ссылок меньше 1, то есть удалённые, но ещё открытые. /mnt/small ограничивает поиск нашим разделом.
  • sudo du -sh /mnt/small: -s (summary) выводит одну итоговую строку.
  • truncate -s 0 /proc/<PID>/fd/<FD>: сделать файл нулевой длины. Путь /proc/<PID>/fd/<номер> это ссылка на открытый дескриптор процесса, через неё можно добраться до файла, у которого нет имени. Так обнуляют только логи: перед этим всегда смотри ls -l /proc/<PID>/fd и sudo lsof -p <PID>, а для чужой базы данных или WAL так делать нельзя (см. предупреждение в теории).

Шаги:

  1. Создай файл 40 МБ на тестовом разделе и держи его открытым:
cd ~/lab
dd if=/dev/zero of=/mnt/small/log.big bs=1M count=40 status=none
tail -f /mnt/small/log.big > /dev/null &      # процесс держит файл открытым
TAILPID=$!                                    # запоминаем PID
echo "$TAILPID"
df -h /mnt/small | tail -1
  1. Удали файл и сравни df с du:
rm /mnt/small/log.big
df -h /mnt/small | tail -1
sudo du -sh /mnt/small
  1. Найди виновника и освободи место без остановки процесса:
sudo lsof +L1 /mnt/small                       # открытые файлы с числом ссылок 0
sudo truncate -s 0 /proc/$TAILPID/fd/3         # обнуляем файл через дескриптор 3
df -h /mnt/small | tail -1
  1. Теперь заверши процесс и убери тестовый раздел:
kill "$TAILPID"                                # SIGTERM процессу tail
sleep 1
cd ~
sudo umount /mnt/small
rm -f ~/lab/small.img
sudo rmdir /mnt/small

Что должно получиться:

238
/dev/loop0       60M   41M   15M  73% /mnt/small
/dev/loop0       60M   41M   15M  73% /mnt/small
52K	/mnt/small
tail: cannot watch '/mnt/small/log.big': No such file or directory
tail: inotify cannot be used, reverting to polling
COMMAND PID    USER   FD   TYPE DEVICE SIZE/OFF NLINK NODE NAME
tail    238 ubuntu     3r   REG    7,0 41943040     0   12 /mnt/small/log.big (deleted)
/dev/loop0       60M   56K   55M   1% /mnt/small

PID 238 у тебя будет другой, подставь свой.

Как читать вывод:

  • Первая строка: PID фонового tail.
  • Две одинаковые строки df: 41M занято до удаления файла и после удаления. Место не освободилось.
  • 52K /mnt/small: du не видит файл, потому что его имени нет ни в одном каталоге. 52K это служебные данные файловой системы.
  • Две строки tail: cannot watch ... inotify cannot be used, reverting to polling: tail заметил, что файл исчез, и пишет об этом в терминал. Они могут появиться в другом месте вывода: процесс работает параллельно.
  • Таблица lsof: COMMAND команда, PID процесс, FD номер дескриптора (3r: дескриптор 3, открыт на чтение), SIZE/OFF размер в байтах, 41943040 (это 40 × 1048576, то есть 40 МБ), NLINK 0: имён у файла не осталось, NODE номер inode, NAME путь и пометка (deleted).
  • После truncate df показывает 56K занято и 55M доступно: место вернулось, а tail продолжает работать.

Типичные ошибки:

  • truncate: cannot open '/proc/238/fd/3' for writing: No such file or directory: PID или номер дескриптора не тот. Посмотри FD в выводе lsof (цифра без буквы) и PID в его втором столбце.

Задание 4. Шаг проекта: /leak и /burn в app.py

Цель: добавить в «Заметки» два демонстрационных эндпоинта (в реальном сервисе их бы не было) и проверить, что они отвечают.

Код этих двух маршрутов возьми из примера: он создаёт управляемую нагрузку для следующих опытов. Сейчас нужно понимать, какой параметр запроса задаёт объём памяти или длительность работы, и сопоставлять запрос с показаниями free и top. Разбирать устройство Python-сервера и самостоятельно реализовывать выделение памяти сейчас не нужно.

Справка: адрес запроса. Адрес http://localhost:8080/leak?mb=80 состоит из пути (path) /leak («что нужно») и строки запроса (query string) mb=80 после знака ? (параметры имя=значение, несколько через &). В Python urlparse(self.path) разбирает адрес на части, а parse_qs(...) превращает строку запроса в словарь {"mb": ["80"]} (значение это список, потому что один параметр можно передать несколько раз). qs.get("mb", ["0"])[0] берёт первое значение или "0", если параметра нет. Значение всегда приходит строкой, поэтому его превращают в число сами: int("80") даёт 80, а для mb=abc int выдаст ValueError, и сервис ответит 400 (плохой запрос).

Что делают новые эндпоинты:

  • /leak?mb=N выделяет N мегабайт и не отпускает их: складывает в список LEAK. Так имитируется утечка памяти (memory leak): программа занимает память и не возвращает. bytearray(N * 1048576) создаёт массив из N × 1 048 576 нулевых байтов (1 048 576 это 1024 × 1024, число байтов в мегабайте). Лимит на один запрос 256 МБ, и общий потолок LEAK_MAX_MB (по умолчанию 1024 МБ), чтобы случайно не положить весь сервер.
  • /burn?sec=N в течение N секунд крутит пустой цикл while ... pass: процессор занят, и полезной работы нет. Так имитируется зависшая или «жадная» программа.

Предскажи: /burn?sec=20 жжёт один поток. Какой процент CPU покажет top для процесса, пока идёт запрос?

Ответ

Около 100%: один поток занимает одно ядро процессора целиком (для процесса %CPU считается от одного ядра, см. теорию). Общий us в шапке зависит от числа ядер: на двух ядрах около 50%.

Шаги:

  1. Открой ~/notes/app.py (nano app.py, урок 1.1). Добавь import time к остальным импортам (после import threading), а в строке from urllib.parse import urlparse добавь parse_qs, чтобы получилось from urllib.parse import parse_qs, urlparse:
import time                                  # для busy-цикла в /burn
  1. Перед строкой class Handler(BaseHTTPRequestHandler): (после функции add_note, с двумя пустыми строками до и после) вставь хранилище «утечки»:
LEAK = []                                    # сюда складываем занятую память
LEAK_MAX_MB = int(os.environ.get("LEAK_MAX_MB", "1024"))   # потолок суммарной утечки
  1. Внутри класса Handler, после метода json и перед do_GET, добавь два вспомогательных метода (они нужны новым веткам: _json отвечает JSON, _text отвечает простым текстом):
    def _json(self, code, obj):
        self.json(code, obj)

    def _text(self, code, body):
        self.send(code, body, "text/plain; charset=utf-8")
  1. Начало метода do_GET заменяется. Строку path = urlparse(self.path).path замени на блок ниже, а дальше цепочка if path == "/": ... остаётся как была:
    def do_GET(self):
        parsed = urlparse(self.path)
        qs = parse_qs(parsed.query)
        # демонстрационные эндпоинты: в реальном сервисе их бы не было
        if parsed.path == "/leak":
            try:
                mb = int(qs.get("mb", ["0"])[0])
            except ValueError:                        # mb=abc: не число
                return self._json(400, {"error": "limit"})
            # допустимо от 1 до 256 МБ за раз и не больше LEAK_MAX_MB суммарно
            if not 1 <= mb <= 256 or sum(len(b) for b in LEAK) // 1048576 + mb > LEAK_MAX_MB:
                return self._json(400, {"error": "limit"})
            LEAK.append(bytearray(mb * 1048576))     # bytearray занимает реальную память
            total = sum(len(b) for b in LEAK) // 1048576
            return self._text(200, "leaked total %d MB\n" % total)
        if parsed.path == "/burn":
            try:
                sec = int(qs.get("sec", ["0"])[0])
            except ValueError:
                return self._json(400, {"error": "sec 0-60"})
            if not 0 <= sec <= 60:
                return self._json(400, {"error": "sec 0-60"})
            end = time.monotonic() + sec
            while time.monotonic() < end:            # активное ожидание грузит одно ядро
                pass
            return self._text(200, "burned %d\n" % sec)
        path = parsed.path
        # ... дальше без изменений: if path == "/": ... elif path == "/healthz": ...
  1. Последняя правка: сервису в этой версии уже понадобится отвечать на чужие методы. Это нужно тестам из урока 1.6: они проверяют, что PUT возвращает 405 Method Not Allowed («метод не разрешён»). Добавь в конец класса Handler (перед log_message) четыре строки:
    def do_PUT(self):
        # неподдерживаемый метод даёт 405 (нужно тестам из 1.6)
        self.json(405, {"error": "method not allowed"})

    do_DELETE = do_PATCH = do_OPTIONS = do_PUT

Последняя строка присваивает тот же обработчик ещё трём методам. Полный файл версии v2.2 можно сверить с эталоном: project/notes/versions/v2.2.py. Скачай эталон в /tmp и сравни командой diff (она печатает только различия; пустой вывод значит, что файлы совпали):

curl -fsSL -o /tmp/v2.2.py https://raw.githubusercontent.com/distinguished-sre/learning/main/devops/project/notes/versions/v2.2.py
diff ~/notes/app.py /tmp/v2.2.py

Отличия только в пустых строках или в тексте комментариев безвредны. Если diff показывает другие строки, поправь свой файл.

  1. Проверь синтаксис, запусти сервис и проверь ветки:
cd ~/notes
python3 -m py_compile app.py && echo "синтаксис ok"
python3 app.py 2>> app.log &
sleep 1
curl -s "localhost:8080/leak?mb=10"
curl -s "localhost:8080/leak?mb=999"
curl -s "localhost:8080/burn?sec=1"
curl -s "localhost:8080/burn?sec=abc"
curl -s -i -X PUT localhost:8080/notes | head -1
  1. Останови сервис:
pkill -f "python3 app.py"

Что должно получиться:

синтаксис ok
leaked total 10 MB
{"error": "limit"}
burned 1
{"error": "sec 0-60"}
HTTP/1.0 405 Method Not Allowed

Как читать вывод:

  • синтаксис ok: py_compile проверяет файл, не запуская сервис. Если есть ошибка, будет SyntaxError со строкой.
  • leaked total 10 MB: /leak выделил 10 МБ. Тело ответа заканчивается переводом строки, поэтому следующая строка начинается с новой.
  • {"error": "limit"}: mb=999 больше 256, запрос отклонён с кодом 400 (плохой запрос). Обрати внимание на пробел после двоеточия: так json.dumps в Python печатает JSON по умолчанию.
  • burned 1: цикл отработал секунду и вернул ответ.
  • {"error": "sec 0-60"}: параметр abc не число, ответ 400.
  • HTTP/1.0 405 Method Not Allowed: -X PUT отправил запрос методом PUT, -i включил вывод заголовков, head -1 оставил первую строку (статус).

Типичные ошибки:

  • NameError: name 'time' is not defined: не добавлен import time (шаг 1).
  • AttributeError: 'Handler' object has no attribute '_json': не добавлены методы _json и _text (шаг 3) или они оказались вне класса (нет отступа в четыре пробела).

Задание 5. Память и OOM-killer на своём процессе

Цель: увидеть, как растёт потребление памяти процессом и как выглядит OOM-убийство, без риска для всей ВМ.

Предскажи: сервис запущен с лимитом памяти 200 МБ. Ты просишь /leak?mb=80 три раза подряд. Что ответит каждый запрос и что покажет curl на третьем?

Ответ

Первые два вернут leaked total 80 MB и leaked total 160 MB. Третий запрос требует ещё 80 МБ, вместе с самим интерпретатором Python (около 19 МБ) выходит больше 200 МБ. Ядро убьёт процесс на середине запроса, ответа не будет, curl напечатает curl: (52) Empty reply from server («пустой ответ»).

Перед началом проверь, что у тебя systemd. Лимит памяти ниже задаётся через systemd-run, а он работает только там, где PID 1 это systemd:

ps -p 1 -o comm=

Должно быть systemd. Если выведено другое (например, bash или docker-init: контейнер или WSL без systemd), systemd-run не заработает. Тогда выполни задание на ВМ из урока 1.1, а здесь только прочитай разбор вывода.

Задание делается в двух терминалах: в первом работает сервис (на переднем плане, без &), из второго ты шлёшь запросы и смотришь память. Так не нужен фон: если sudo спросит пароль, ты увидишь запрос и просто введёшь его.

Разбор команды запуска:

sudo systemd-run --scope --unit=notes-leak -p MemoryMax=200M -p MemorySwapMax=0 \
    runuser -u "$USER" -- env NOTES_DATA=/tmp/notes.txt python3 app.py
  • sudo: создавать cgroup с лимитами может только root.
  • systemd-run --scope: запускает команду в новой cgroup (в теории). --scope значит, что процесс остаётся твоим дочерним на переднем плане, а не уходит под управление systemd (это будет в уроке 1.8). --unit=notes-leak даёт группе понятное имя вместо случайного.
  • -p MemoryMax=200M -p MemorySwapMax=0: свойства (-p property) группы: лимит памяти 200 МБ, swap запрещён.
  • runuser -u "$USER" --: запустить дальнейшую команду от имени тебя, а не root. Мы уже в root из-за sudo, а запускать сервис от root незачем. -- отделяет ключи runuser от команды.
  • env NOTES_DATA=/tmp/notes.txt python3 app.py: env задаёт переменную окружения для этого запуска (файл данных кладём во временный каталог, чтобы не трогать настоящие данные), и запускает сервис.
  • systemctl show notes-leak.scope -p MemoryMax -p MemoryCurrent: systemctl show печатает свойства группы. MemoryMax лимит в байтах, MemoryCurrent сколько группа занимает сейчас.
  • PID=$(pgrep -f '^python3 app.py' | head -1): pgrep -f ищет по полной командной строке, ^ значит «строка начинается с», поэтому не попадут sudo и runuser, у которых python3 app.py лишь в конце; head -1 оставляет первый PID. ps -p "$PID" -o pid,rss,comm (урок 1.4) печатает PID, RSS (в килобайтах) и имя команды именно этого процесса.
  • sudo dmesg -T | grep -i 'killed process' | tail -1: dmesg -T читает журнал ядра с понятным временем, grep -i ищет строку без учёта регистра.

Шаги:

  1. В первом терминале запусти сервис в группе с лимитом 200 МБ. Он остаётся на переднем плане и печатает access-лог; терминал занят до конца задания:
cd ~/notes
sudo systemd-run --scope --unit=notes-leak -p MemoryMax=200M -p MemorySwapMax=0 \
    runuser -u "$USER" -- env NOTES_DATA=/tmp/notes.txt python3 app.py
  1. Во втором терминале проверь, что сервис живой, и посмотри лимит:
curl -s localhost:8080/healthz; echo
systemctl show notes-leak.scope -p MemoryMax -p MemoryCurrent
  1. Там же наблюдай память процесса и «утекай»:
PID=$(pgrep -f '^python3 app.py' | head -1)
ps -p "$PID" -o pid,rss,comm           # rss в килобайтах
curl -s "localhost:8080/leak?mb=80"
ps -p "$PID" -o pid,rss,comm
systemctl show notes-leak.scope -p MemoryCurrent
curl -s "localhost:8080/leak?mb=80"
cat /proc/pressure/memory              # PSI: сколько времени процессы ждали память
curl -sS "localhost:8080/leak?mb=80"

Команда cat /proc/pressure/memory посередине показывает насыщение памяти (PSI, о нём в теории). Вывод состоит из двух строк, some и full, в каждой доли ожидания за 10, 60 и 300 секунд (avg10, avg60, avg300) и общий счётчик total. some значит «хотя бы один процесс ждал память», full значит «ждали все процессы сразу, полезной работы не было». У тебя, скорее всего, нули или доли процента: давление считается на всей машине, а лимит 200 МБ мы поставили только на одну группу. Это тоже урок: узел спокоен, а процесс внутри группы уже убит. Если файла нет, ядро собрано без PSI, пропусти команду. Две строки PSI в блоке «Что должно получиться» ниже не показаны: пример снят без этой команды, и ты увидишь их после строки leaked total 160 MB.

  1. Найди след убийства и код выхода. В первом терминале вернулось приглашение оболочки (возможно, с надписью Killed): напечатай там echo $?. Во втором:
sudo dmesg -T | grep -i 'killed process' | tail -1
curl -sS localhost:8080/healthz
  1. Убери за собой. После OOM группа остаётся в состоянии «упала», и следующий запуск с тем же именем не пройдёт, пока её не сбросить:
sudo systemctl reset-failed notes-leak.scope

Что должно получиться (второй терминал; в первом после убийства echo $? печатает 137):

Running as unit: notes-leak.scope; invocation ID: 09b6ef5dde5d4bba9d3655d22c968948
ok
MemoryCurrent=10977280
MemoryMax=209715200
    PID   RSS COMMAND
   1625 19412 python3
leaked total 80 MB
    PID   RSS COMMAND
   1625 101336 python3
MemoryCurrent=95027200
leaked total 160 MB
curl: (52) Empty reply from server
[Wed Sep 30 12:01:13 2026] Memory cgroup out of memory: Killed process 105959 (python3) total-vm:346976kB, anon-rss:203564kB, file-rss:9408kB, shmem-rss:0kB, UID:1000 pgtables:476kB oom_score_adj:0
curl: (7) Failed to connect to localhost port 8080 after 0 ms: Couldn't connect to server

Строка Running as unit печатается в первом терминале при запуске (в примере сервис был в фоне, и она шла в общий вывод). Числа в примере сняты на стенде с запуском в фоне; запуск на переднем плане с двумя терминалами даёт те же значения памяти, но формат строк Killed и Exit 137 у тебя будет определять твоя оболочка.

Как читать вывод:

  • Running as unit: notes-leak.scope: группа создана. invocation ID уникален у каждого запуска, у тебя другой.
  • ok: /healthz отвечает. MemoryMax=209715200 это 200 × 1048576 байт: лимит из -p MemoryMax=200M. MemoryCurrent=10977280 (около 10,5 МБ): группа только что стартовала и занимает мало.
  • RSS 19412 (килобайт, около 19 МБ) это чистый интерпретатор Python. После /leak?mb=80 RSS стал 101336, разница 81924 КБ, то есть те самые 80 МБ. MemoryCurrent вырос до 95027200 (около 90 МБ): группа считает то же самое.
  • leaked total 160 MB после второго запроса: процесс занимает около 180 МБ, под лимит 200 МБ ещё влезает.
  • curl: (52) Empty reply from server: третий запрос попросил ещё 80 МБ, 19 + 160 + 80 больше 200, ядро убило процесс во время обработки. curl отправил запрос, а ответа не дождался: соединение оборвано без единого байта.
  • Строка dmesg: Memory cgroup out of memory (OOM в группе, не на всей машине), Killed process ... (python3), anon-rss:203564kB это почти весь лимит 200 МБ. Строку разбирали в теории. На обычной ВМ PID в журнале совпадёт с PID из ps.
  • echo $? в первом терминале: 137. 137 = 128 + 9 (урок 1.4): SIGKILL. Нужен именно dmesg, чтобы отличить OOM от ручного kill -9.
  • Последний curl: Failed to connect ... Couldn't connect to server: порт больше никто не слушает, процесса нет. Это то, что увидит клиент.

Типичные ошибки:

  • Failed to start transient scope unit: Unit notes-leak.scope was already loaded or has a fragment file: остатки прошлого запуска. sudo systemctl reset-failed notes-leak.scope (шаг 5) и повтори.
  • dmesg: read kernel buffer failed: Operation not permitted: забыл sudo (Ubuntu запрещает обычным пользователям читать журнал ядра).
  • OSError: [Errno 98] Address already in use: предыдущий запуск ещё жив: pkill -f "python3 app.py" (урок 1.4).
  • PID= пустой и ps ругается: сервис в первом терминале уже умер или не запустился; посмотри там вывод.

Прочитай строку про OOM из dmesg вместе с нейросетью: попроси разобрать каждое поле (total-vm, rss, oom_score_adj). Потом сверь с тем, что показывает ps для того же процесса.

Задание 6. Нагрузка на CPU: /burn и top

Цель: нагрузить процессор «Заметок» и увидеть это в top, uptime и vmstat.

Предскажи: пока идёт /burn?sec=30, как изменится load average и что покажет top в колонке %CPU у python3?

Ответ

%CPU у python3 около 100 (одно ядро). Load average за 1 минуту начнёт расти плавно к значению около 1, потому что считается скользящее среднее. Числа за 5 и 15 минут вырастут меньше.

Разбор команд перед запуском:

  • curl -s "localhost:8080/burn?sec=30" &: запрос висит 30 секунд, & отправляет его в фон, чтобы терминал остался свободным. (В прошлом задании сервис шёл на переднем плане, здесь в фон уходит клиент.)
  • SERVER=$! и CLIENT=$!: $! это PID последнего фонового процесса (урок 1.4). Мы запоминаем PID сервера и клиента, чтобы обращаться к ним по имени переменной.
  • top -b -n 2 -d 1 | awk '/^top/{n++} n==2' | head -12: top в пакетном режиме (-b) делает 2 замера (-n 2) с паузой 1 секунда (-d 1); awk '/^top/{n++} n==2' пропускает всё до второго блока (строка, начинающаяся с top, увеличивает счётчик, и печатаются строки, пока счётчик равен 2); head -12 оставляет первые 12 строк.
  • wait "$CLIENT": ждёт завершения фонового клиента по его PID. Номер задания (wait %2) здесь ненадёжен: он зависит от того, сколько заданий уже было в этом терминале.

Шаги:

  1. Запусти сервис и нагрузи процессор:
cd ~/notes
python3 app.py 2>> app.log &
SERVER=$!
sleep 1
uptime
curl -s "localhost:8080/burn?sec=30" &
CLIENT=$!
sleep 15
  1. Пока идёт /burn (у тебя остаётся примерно 15 секунд), сними показания:
top -b -n 2 -d 1 | awk '/^top/{n++} n==2' | head -12
uptime
  1. Дождись конца запроса и останови сервис:
wait "$CLIENT"
kill "$SERVER"

Что должно получиться:

 11:56:40 up 28 min,  0 user,  load average: 1.33, 0.62, 0.24
top - 11:56:55 up 28 min,  0 user,  load average: 1.85, 1.06, 0.46
Tasks:   9 total,   1 running,   8 sleeping,   0 stopped,   0 zombie
%Cpu(s): 14.0 us,  0.2 sy,  0.0 ni, 85.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   7935.3 total,   3500.7 free,   1212.5 used,   3422.9 buff/cache
MiB Swap:   1024.0 total,   1024.0 free,      0.0 used.   6722.8 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
    456 ubuntu    20   0  101200  19412   9468 S 100.0   0.2   0:16.22 python3
      1 root      20   0   20880  11548   8880 S   0.0   0.1   0:00.05 systemd
 11:56:55 up 28 min,  0 user,  load average: 1.85, 1.06, 0.46
burned 30

Как читать вывод:

  • Первая строка uptime до нагрузки: load 1,33 за минуту (на стенде, где снят пример, остались следы прошлых заданий; у тебя на свежей ВМ будет меньше).
  • Шапка top: Tasks 9 total, 1 running (один процесс реально выполняется), %Cpu(s): 14.0 us ... 85.7 id: процессор занят на 14% от всех ядер. MiB Mem и MiB Swap это free -m в другой раскладке, avail Mem то же, что available.
  • Строка python3: %CPU 100.0: одно ядро процессора занято этим процессом целиком. RES 19412 (КБ): памяти он почти не занимает, это чистый процессор, а не память. S показывает S (sleeping), потому что состояние процесса top берёт у главного потока, а он спокойно ждёт новых запросов; счёт идёт в отдельном потоке, созданном под запрос /burn (урок 1.4), и его вклад виден только в %CPU. Чтобы увидеть R у рабочего потока, запусти top -H -p PID.
  • load average: 1.85, 1.06, 0.46: 1 минута выросла сильнее всего (с 1,33 до 1,85), 5 минут и 15 минут отстают. Так и выглядит «свежая» нагрузка.
  • burned 30: клиент дождался ответа. Числа у тебя будут другие. В примере 15 ядер: us 14%, потому что одно ядро это около 6,7% общей мощности, а остальное принесла чужая нагрузка контейнера. Формула из теории: us примерно равно 100 / nproc для одного занятого ядра. На 4 ядрах ты увидишь около 25%, на 8 около 12%, на двух около 50%.

Типичные ошибки:

  • curl: (7) Failed to connect to localhost port 8080 after 0 ms: Couldn't connect to server: сервис не запущен или ещё не успел открыть порт. Проверь, что шаг 1 выполнен, и увеличь sleep.
  • bash: wait: %2: no such job: так выглядела бы запись wait %2, когда задания с таким номером нет. Поэтому в уроке wait "$CLIENT" по PID.
  • OSError: [Errno 98] Address already in use: предыдущий сервис ещё жив. Останови его pkill -f "python3 app.py" и запусти заново.
  • us в шапке не 50% и не 100%: он считается от всех ядер. Раздели ожидаемое число на nproc: на 4 ядрах один занятый процесс даст около 25%.
  • На вершине top другой процесс, а не python3: на машине есть чужая нагрузка. В интерактивном top нажми P (сортировка по %CPU) или смотри только свой процесс: top -b -n 2 -d 1 -p "$SERVER".

Сломай и почини

Проверим себя как дежурный: без подсказки, по USE.

Скрипт сам запускает свою копию «Заметок» на порту 8080 и ломает её или тестовый диск. Выбирает поломку случайно, номер тебе не говорит: так ты тренируешь диагностику, а не угадывание.

Что делает скрипт. Сценарий 1 запускает сервис в cgroup с лимитом памяти и вызывает /leak до OOM-killer. Сценарий 2 запускает три параллельных /burn. Сценарии 3 и 4 создают файл-образ диска в /var/lib/break-1.5, монтируют его в /mnt/break-1.5 и заполняют по месту или по inodes. Системный диск, твои данные и SSH-доступ скрипт не трогает, но он монтирует файловую систему и запускает процессы от root через sudo. Поэтому запускай его только на учебной виртуальной машине, не на рабочей. Исходник можно пролистать до запуска: less /tmp/break-1.5.sh после скачивания или на GitHub; разбор поломок ниже спрятан, пока не попробуешь сам.

Подготовка:

  • пройдено задание 4: в ~/notes/app.py есть /leak. Если его нет, скачай эталон v2.2: curl -fsSL -o ~/notes/app.py https://raw.githubusercontent.com/distinguished-sre/learning/main/devops/project/notes/versions/v2.2.py (свою версию сначала сохрани: cp ~/notes/app.py ~/notes/app.py.bak);
  • твой собственный сервис на 8080 остановлен: pkill -f "python3 app.py".

Запуск:

curl -fsSL -o /tmp/break-1.5.sh https://raw.githubusercontent.com/distinguished-sre/learning/main/devops/project/notes/break/1.5/break.sh
sudo bash /tmp/break-1.5.sh random    # выберет один из четырёх сценариев; номер не смотри

Скрипт печатает только «сломано, сервис Заметок не в порядке». Сценарии: 1 /leak до OOM-killer, 2 /burn грузит CPU, 3 заполненный диск (loop-файл), 4 исчерпание inodes (loop-файл).

Симптом

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

Проверь, как ведёт себя сервис:

curl -sS -m 3 http://127.0.0.1:8080/healthz
curl -sS -m 3 -X POST -d '{"text":"проверка"}' http://127.0.0.1:8080/notes

Гипотезы

Составь список из трёх гипотез до запуска любой команды. Например: «кончился диск», «кончились inodes», «убит процесс за память», «процессор занят одним процессом», «диск тормозит (iowait)». Для каждой запиши, какая команда её проверит.

Проверки

Пройди USE по порядку, по одной команде на ресурс:

uptime; nproc                       # CPU: load против числа ядер
top -b -n 2 -d 1 | awk '/^top/{n++} n==2' | head -12   # кто занимает CPU и сколько wa
free -h                             # память: available, swap
sudo dmesg -T | tail -20            # следы OOM
df -h; df -i                        # место и inodes на всех разделах
Исправление
  • Сценарий 1 (память): в dmesg строка Memory cgroup out of memory: Killed process ... (python3), а на порту 8080 никого нет: curl пишет Couldn't connect to server. Причина: /leak занял память до лимита группы, и ядро убило процесс. Исправление: запустить сервис заново (cd ~/notes && python3 app.py). Память при этом не освобождается сама, только рестартом. В реальной жизни ограничивают процесс MemoryMax (урок 1.8), ищут утечку в коде и настраивают автоперезапуск.
  • Сценарий 2 (CPU): сервис жив, но отвечает медленно. В top один python3 около 100% и в нём почти всё время us, wa около нуля. Load при этом может быть небольшим (меньше nproc): три одновременных /burn упираются в GIL и занимают лишь одно ядро (теория про top). Ориентироваться нужно на %CPU процесса, а не только на load. Исправление: найти PID (top или ps aux --sort=-%cpu | head), kill <PID> (SIGTERM, урок 1.4). Процесс завершится не сразу, а через несколько секунд (до 10 секунд STOP_TIMEOUT на обработку запросов), при необходимости SIGKILL: kill -9 <PID>.
  • Сценарий 3 (место): df -h показывает 100% на /mnt/break-1.5, sudo du -xh --max-depth=1 /mnt/break-1.5 | sort -h | tail находит каталог export, в нём большой файл. POST /notes возвращает 500 {"error": "storage"}, а /healthz отвечает ok. Исправление: удалить или сжать файл (rm /mnt/break-1.5/export/dump-2026-09.bin) и убедиться через lsof +L1, что его не держит процесс. После этого запись заработает.
  • Сценарий 4 (inodes): df -h показывает свободное место, df -i показывает IUse% 100% на /mnt/break-1.5. Ищем каталог с огромным числом файлов: sudo find /mnt/break-1.5 -xdev | cut -d/ -f1-4 | sort | uniq -c | sort -rn | head -3 покажет около 1989 записей в /mnt/break-1.5/spool. Исправление: удалить лишнее (rm -f /mnt/break-1.5/spool/m*) и разобраться, что их плодит.

Разбор команды из сценария 4: find ... -xdev печатает все пути на этом разделе, cut -d/ -f1-4 оставляет первые четыре части пути, разделённого / (то есть /mnt/break-1.5/spool), sort | uniq -c считает одинаковые строки, sort -rn | head -3 показывает три самых частых.

Отработай каждый сценарий отдельно: sudo bash /tmp/break-1.5.sh 1 … sudo bash /tmp/break-1.5.sh 4, и после каждого sudo bash /tmp/break-1.5.sh fix (он останавливает сервис скрипта, размонтирует и удаляет тестовый диск; безопасно запускать повторно). Потом запусти свой сервис как раньше.

ИИ в помощь

Нейросеть хорошо объясняет колонки free, top и df, но не видит твой сервер: что у тебя занимает диск и кто съел память, она узнает только из того, что ты покажешь. Общие правила работы с ней: ИИ-помощник.

Задача: разобрать «диск кончился».

Ubuntu 24.04. df -h: <вывод>; df -i: <вывод>; du -xh --max-depth=1 /var | sort -h | tail: <вывод>.
Скажи, что именно кончилось (блоки или inodes), что занимает место и какие проверки сделать,
прежде чем что-то удалять.

Проверь ответ: убедись, что вывод совпадает с твоим df, и проверь lsof +L1 на удалённые открытые файлы. Типичная ошибка: совет rm -rf по каталогу, который держит работающий сервис.

Задача: понять, убил ли процесс OOM-killer.

Сервис <имя> исчез, код выхода 137. Вот journalctl -k | grep -i -E 'out of memory|killed process': <вывод>; free -h: <вывод>.
Объясни, что произошло, сработал лимит cgroup или кончилась память сервера, и что исправить
сначала: лимит, утечку или объём памяти.

Проверь ответ: сверь строки журнала с /proc/<PID>/status и лимитом контейнера. Типичная ошибка: вывод «код 137 значит OOM» без проверки журнала ядра.

Задача: разобрать load average.

uptime: <вывод>; nproc: <число>; top -bn1 | head -15: <вывод>.
Это нехватка процессора или процессы ждут диск? Объясни по us, sy, wa, st и по состояниям D.
Какие команды запустить дальше?

Проверь ответ: сравни load с числом ядер и посмотри колонку wa сам. Типичная ошибка: «добавь ядер», хотя причина в диске.

Словарик урока

Термин Простыми словами
Ресурс (resource) то, чего у сервера ограниченное количество: место на диске, память, время процессора
Файловая система (file system) правила и служебные таблицы, по которым ядро записывает и находит файлы на диске (например, ext4)
Блок (block) минимальный кусок диска под данные файла, обычно 4 КБ
inode «карточка» файла: владелец, права, размер, где лежат блоки; имени в ней нет
Каталог (directory) таблица «имя файла, номер inode»
Ссылка (link) одно имя файла в каталоге; когда ссылок 0 и файл никто не держит, он удаляется
Монтирование (mount) подключение раздела диска к каталогу дерева файлов
Loop-устройство (loop device) возможность ядра показать обычный файл как диск
df / du сколько занято на разделе в целом / сколько занимают файлы, найденные обходом
Файловый дескриптор (fd) номер, под которым процесс держит открытый файл
Оперативная память (RAM) быстрая память, с которой работают программы
Кэш файлов (page cache) свободная память, в которой ядро хранит недавно прочитанные файлы; отдаётся по требованию
available сколько памяти можно выдать программам без выгрузки на диск: главная колонка free
Swap (подкачка) место на диске для выгрузки редко нужной памяти; медленнее RAM
VSZ / RSS сколько памяти процесс запросил (виртуально) / сколько реально занимает в RAM сейчас
OOM-killer механизм ядра, который при нехватке памяти убивает процесс сигналом SIGKILL
cgroup группа процессов в ядре с общими лимитами и учётом ресурсов; так работают лимиты в контейнерах
dmesg журнал сообщений ядра, там пишут про OOM
Ядро Linux (kernel) главная часть ОС, распределяет ресурсы; не путать с ядром процессора
Ядро процессора (CPU core) один исполнитель, выполняет одну программу за раз
nproc число ядер процессора
Load average среднее число процессов, которые работают или ждут очереди (и диска), за 1, 5 и 15 минут
us, sy, id, wa, st доли времени процессора: программа, ядро, простой, ожидание диска, отнято гипервизором
GIL блокировка в Python: код исполняется одним потоком за раз, поэтому процесс занимает не больше одного ядра
USE метод диагностики: занятость (Utilization), насыщение (Saturation), ошибки (Errors) для каждого ресурса
Эндпоинт (endpoint) адрес, по которому сервис отвечает на запрос, например /leak
Строка запроса (query string) часть адреса после ?: параметры имя=значение

Вопросы с собеседований

Раздел для повторения: ответь вслух, потом открой ответ. Короткие вопросы с пометкой [на скорость] тренируй на время: ответ за 30 секунд.

1. [junior] [часто] Диск заполнен на 100%. Как быстро найти, что занимает место?

Ответ

df -h, чтобы понять раздел; затем sudo du -xh --max-depth=1 <точка> | sort -h | tail и спуск вглубь; -x, чтобы не выйти в другие разделы. Смотрю логи, кэш пакетов, старые бэкапы, каталоги Docker (эта тема встретится в уроке 4.9).

Что хотят услышать: du -x, сортировку, спуск по каталогам, ncdu (интерактивный просмотр размеров) как удобство, проверку удалённых-открытых файлов, что /var/log не удаляют вслепую.

Красный флаг: rm -rf /var/log/* без проверки, что нужно сервисам.

2. [junior] [часто] free -h показывает free 150 МБ из 8 ГБ. Это авария?

Ответ

Нет, если available большая: ядро держит свободную память под кэш файлов и отдаёт по требованию. Тревожат маленькая available, растущий swap, ненулевые si и so в vmstat, строки OOM в dmesg.

Что хотят услышать: page cache, available, разницу между «занято программами» и «занято кэшем», swap как признак насыщения.

Красный флаг: «надо срочно освобождать память, сбросим кэш командой» без понимания, что кэш и так отдаётся.

3. [junior] [часто] Сервер тормозит. Каков твой порядок проверок за первые 2 минуты?

Ответ

По USE: uptime и nproc (CPU и load), top (кто занимает и сколько wa), free -h и vmstat 1 5 (память, swap), df -h и df -i (диск), dmesg -T | tail (OOM, ошибки диска). Затем сужаю до процесса.

Что хотят услышать: порядок, разделение занятости и насыщения, ссылку на числа, а не на ощущения, dmesg.

Красный флаг: сразу перезапустить сервис, не глядя на метрики.

4. [junior] df -h показывает 100% на /var, а du -sh /var считает всего 20 ГБ из 50. Что делаешь?

Ответ

Первым делом думаю про удалённый, но открытый файл: sudo lsof +L1 /var, смотрю строки со (deleted). Такой файл держит процесс: du его не видит, а df считает. Освобождаю перезапуском процесса или truncate -s 0 /proc/<PID>/fd/<FD>. Вторая версия: под точкой монтирования лежат файлы, скрытые смонтированным сверху разделом.

Что хотят услышать: lsof +L1, разницу между df и du, очистку через /proc/<PID>/fd, ротацию логов (logrotate) как причину: программа, которая по расписанию сжимает и удаляет старые логи, а процесс продолжает писать в старый файл.

Красный флаг: «просто перезагружу сервер» без понимания, почему место не возвращается.

5. [junior] [на скорость] Прод пишет No space left on device, но df -h показывает 40% свободно. Что это?

Ответ

Проверяю df -i: скорее всего закончились inodes («карточки» файлов), число которых фиксируется при создании файловой системы. Ищу каталог с миллионами мелких файлов (find -xdev, cut, uniq -c), чищу и настраиваю очистку или ротацию того, что их плодит.

Что хотят услышать: inodes и df -i, типичные виновники (сессии, кэш, почтовая очередь, маленькие логи), что число inodes задаётся при создании файловой системы.

Красный флаг: «диск не заполнен, значит ошибка в приложении».

6. [middle] Сервис пропал, в логах нет ошибок. Как проверишь, что его убил OOM-killer?

Ответ

sudo dmesg -T | grep -i -E 'killed process|out of memory' (или journalctl -k, то же самое через журнал systemd). Смотрю код выхода: 137 это SIGKILL, но он не доказывает OOM, ведь так мог убить и человек. Для процессов в контейнерах и cgroup ищу Memory cgroup out of memory. Затем free -h, top по RSS, смотрю, утечка это или занижен лимит.

Что хотят услышать: dmesg или journalctl -k, код 137 и почему он не доказывает OOM, различие OOM всей системы и cgroup, что убитый процесс не успевает записать лог.

Красный флаг: «искал в логах приложения, не нашёл, значит не OOM».

7. [middle] Load average 12 на четырёхъядерном сервере, но top показывает CPU почти свободным. Причина?

Ответ

Высокий wa (iowait): процессы в состоянии D ждут диск или сетевую файловую систему, а в load Linux входят и они. Смотрю top (wa), vmstat 1 (колонка b), iostat -x (утилита, показывающая загрузку каждого диска), ps -eo state,pid,cmd | grep '^D'. Нахожу медленный диск, забитую очередь или зависший сетевой том.

Что хотят услышать: load включает процессы в D, сравнение с nproc, wa, поиск процессов в D.

Красный флаг: «load 12 значит CPU перегружен, добавим ядер».

8. [middle] Сервис падает раз в сутки около 03:00 и сам поднимается. Что делаешь?

Ответ

Смотрю dmesg -T и журнал сервиса на время падения: код 137 и OOM или падение по другой причине. Строю тренд памяти (ps -o rss по времени или метрики), сверяю с расписанием задач на 03:00: cron (планировщик, запускающий команды по расписанию), ротация логов, бэкап. Временно ставлю лимит и автоперезапуск, затем ищу утечку в коде.

Что хотят услышать: корреляцию по времени, OOM против падения по коду, cron и бэкапы как «соседи» по памяти, тренд, а не разовый снимок.

Красный флаг: «увеличим память серверу» без выяснения причины.

9. [junior] [на скорость] Чем отличаются swap и обычная память, и когда swap это плохо?

Ответ

Swap это область на диске для выгрузки страниц памяти. Немного swap в простое нормально: выгружено то, что давно не нужно. Плохо, если идёт постоянный обмен (si и so в vmstat ненулевые): сервис тормозит, потому что диск в тысячи раз медленнее памяти.

Что хотят услышать: отличие «использован» и «активно обменивается», vmstat, swap как отсрочка перед OOM, а не решение нехватки памяти.

Красный флаг: «swap всегда надо отключать» или «swap решает нехватку памяти».

10. [middle] Диск заполняют логи приложения. Что сделаешь сейчас и что навсегда?

Ответ

Сейчас: du -x находит файл, место освобождаю сжатием или truncate -s 0 (не rm, если файл открыт процессом), проверяю lsof +L1. Навсегда: ротация логов (logrotate: сжимает и удаляет старые файлы по правилам размера и возраста), лимиты на число и размер файлов, разумный уровень логирования, алерт на Use% и на прогноз заполнения, отдельный раздел под логи, чтобы переполнение не положило систему.

Что хотят услышать: truncate против rm, logrotate, алерт по прогнозу, а не только по порогу, отдельный раздел для изоляции.

Красный флаг: ручная чистка раз в месяц, без ротации и алертов.

11. [middle] Как понять, что сервер упёрся в диск, а не в CPU? Какие команды и признаки?

Ответ

В top смотрю строку CPU: большое значение wa (iowait) значит, что процессы ждут ввода-вывода. Дальше iostat -x 1 из пакета sysstat: у устройства смотрю %util, время ожидания (await, в новых версиях раздельно r_await и w_await) и длину очереди. Кто именно нагружает диск, показывают iotop или pidstat -d 1. Признак: load average высокий, а CPU в основном свободен. Высокий iowait не всегда про локальный диск: так же выглядит зависший сетевой диск (NFS). Строка CPU в top помогает различить причины: us и sy это код программ и ядра, wa ожидание диска, st время, которое забрал гипервизор (шумный сосед).

Что хотят услышать: wa в top, iostat -x, %util и await, iotop/pidstat -d, высокий load при свободном CPU, NFS как исключение.

Красный флаг: «Load высокий, значит не хватает CPU».

12. [middle] Под в Kubernetes перезапускается, а на узле свободна память. Как проверить, что это OOMKilled, и чем он отличается от тормозов из-за лимита CPU?

Ответ

Смотрю kubectl describe pod ИМЯ: в Last State будет Terminated, Reason: OOMKilled, Exit Code: 137. Свободная память узла ничего не значит: убивает не узел, а cgroup контейнера, когда процесс упёрся в limits.memory. Подтверждаю счётчиком memory.events (поле oom_kill) в cgroup контейнера и dmesg на узле. Лечение: найти, растёт ли RSS (утечка) или лимит просто мал, и поднять limits, а не гадать. С процессором иначе: упёрся в лимит CPU, процесс не убивают, а притормаживают (throttling). Признак: метрика container_cpu_cfs_throttled_periods_total растёт, а load на узле небольшой.

Что хотят услышать: OOMKilled и код 137, лимит контейнера против памяти узла, QoS-классы (BestEffort убивают первыми), разница между убийством по памяти и throttling по CPU.

Красный флаг: «добавлю узлу памяти» без проверки лимита контейнера.

Проверено на версиях

Прогонялось на учебном стенде 2026-09-30, Docker-контейнер с systemd (devops-lab:24.04) на ядре Linux 6.12.76:

  • Ubuntu 24.04.5 LTS; Python 3.12.3; curl 8.5.0; systemd 255.4
  • procps-ng 4.0.4 (free, top, ps, vmstat), util-linux 2.39.3 (mount, runuser, setpriv), e2fsprogs 1.47.0 (mke2fs), coreutils 9.4 (df, du, dd, truncate), lsof 4.95.0
  • задания 1-6 и все четыре сценария скрипта break/1.5/break.sh выполнены на этом стенде, выводы в уроке настоящие; app.py v2.2 совпадает с эталоном project/notes/versions/v2.2.py; shellcheck на скрипте без замечаний
  • Ubuntu 26.04.1 LTS (образ без systemd): проверены только df, free, top, ps, mount, mkfs.ext4, заполнение loop-образа по месту и inodes; формат вывода тот же, отличие одно: dd на 26.04 это uutils coreutils 0.8.0 с другим текстом ошибки. Задания 4-6 и скрипт поломок на 26.04 не прогонялись: нет systemd и Python в образе
  • Особенности стенда: контейнер делит ядро Linux с другими контейнерами, поэтому load average и us включают чужую нагрузку, а df / показывает overlay
  • Что не прогонялось после правок урока: задание 5 в варианте с запуском на переднем плане и двумя терминалами (выводы в уроке сняты с запуском в фоне, значения памяти те же, форматы Killed и Exit 137 зависят от оболочки); ps -p 1 -o comm=; wait "$CLIENT" и kill "$SERVER" в задании 6 (шаблон pgrep -f '^python3 app.py' проверен на пробном процессе); lsblk, findmnt, lvextend, iostat, sar, /proc/pressure/*, kubectl describe pod и запрос predict_linear взяты из документации, на стенде не запускались

Итог урока: ты умеешь

  • отличить нехватку места от нехватки inodes по df -h и df -i
  • найти самый большой каталог сверху вниз через du -x --max-depth=1 | sort -h
  • объяснить, почему df и du расходятся, и найти удалённый файл через lsof +L1
  • читать free -h: available, кэш, swap
  • найти следы OOM-killer в dmesg и связать их с кодом выхода 137
  • читать load average относительно nproc и отличать CPU от iowait
  • прочитать шапку и строки top и vmstat
  • пройти USE по CPU, памяти и диску за две минуты
  • воспроизвести нехватку памяти и процессора у «Заметок» через /leak и /burn

Мини-инструкция на ночь (три строки).

  1. Сначала df -h, df -i, free -h, uptime и top: какой ресурс подводит, пока ничего не перезапускаешь.
  2. Потом ищешь виновника: du -xh --max-depth=1 | sort -h, lsof +L1, dmesg -T | grep -i killed, ps aux --sort=-rss | head.
  3. До очистки сохрани вывод du и lsof +L1 в тикет: после удаления файлов причину уже не восстановить. Если упёрлись корневой раздел, база данных или очередь, зови старшего сразу, остальное зови, если не освободил за 15 минут. В тикет пиши: что показывали df, free, top (числа), что сделал, что осталось неясным.

Дальше: Урок 1.6: Основы bash и Make: переменные, условия, циклы

Проверь себя

Короткий тест по уроку: 5 вопросов из банка в 30. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.

Тест работает с включённым JavaScript.

тема 1 урок 1.5 4 ч курс 0/0 ← → уроки

Помоги улучшить курс

Что нужно изменить?