К содержимому
Войти

DevOps Road Map

🐍 Python для DevOps

Python у DevOps-инженера закрывает задачи, на которых bash начинает трещать: сходить в API с пагинацией и ретраями, разобрать JSON и YAML, собрать отчёт по логам, почистить registry. От тебя не ждут уровня бэкенд-разработчика, но ждут скрипт, который можно спокойно поставить в cron или CI: с таймаутами, логами, понятными флагами и без shell=True. На собеседовании это проверяют вопросом про твои скрипты и коротким лайвкодингом, чаще всего парсером логов

🧠 Как это устроено

Когда берут Python, а не bash

Короткое правило: пока скрипт склеивает команды и файлы, хватает bash. Как только появляется HTTP API, JSON глубже одного уровня, словари, подсчёты или больше сотни строк логики, удобнее Python. Подробные критерии, strict mode и конвейеры grep/awk разобраны на странице «Bash для автоматизации»

Окружение и зависимости

Системный Python на сервере принадлежит дистрибутиву, на нём работают его утилиты. Поэтому Debian и Ubuntu помечают системный Python как внешне управляемый (PEP 668), и pip отказывается ставить пакеты с ошибкой externally-managed-environment. Правильный путь — виртуальное окружение: отдельный каталог со своим интерпретатором и своими пакетами

Классика — python3 -m venv .venv и pip install. Сейчас всё чаще берут uv: он ставит пакеты быстрее pip, сам скачивает нужную версию Python и умеет запускать одиночные скрипты с зависимостями

ЗадачаКоманда uv
Создать окружение в .venvuv venv или uv venv --python 3.12
Поставить пакет в окружениеuv pip install requests
Создать скрипт с блоком метаданныхuv init --script cleanup.py --python 3.12
Добавить зависимость в скриптuv add --script cleanup.py 'requests<3'
Запустить скриптuv run cleanup.py
Зафиксировать версииuv lock --script cleanup.py, рядом появится cleanup.py.lock

Для DevOps самое полезное здесь — скрипты с inline-метаданными по PEP 723. Зависимости и версия Python пишутся комментарием прямо в начале файла:

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.12"
# dependencies = ["requests>=2.32,<3", "pyyaml>=6"]
# ///

uv run cleanup.py читает этот блок, собирает окружение в кэше и запускает скрипт в нём. Поле dependencies обязательно, даже пустое: dependencies = []. Со строкой shebang и chmod +x скрипт запускается как ./cleanup.py. Один файл без requirements.txt удобно держать в репозитории инфраструктуры и запускать из CI

Скелет скрипта

Почти любой рабочий скрипт держится на четырёх модулях стандартной библиотеки

  • argparse разбирает флаги и сам печатает --help. Опасное действие включается флагом вроде --apply, а по умолчанию скрипт только показывает, что сделал бы
  • logging пишет события с уровнем и временем. По умолчанию сообщения уходят в stderr, а корневой логгер пропускает только WARNING и выше, поэтому logging.basicConfig(level=logging.INFO) нужен явно. print оставь для результата, который читает следующая команда в конвейере
  • pathlib работает с путями: Path("/var/log") / "app.log", .exists(), .glob("*.gz"), без склейки строк через слэш
  • sys.exit(код) или исключение задают код выхода. Cron и CI понимают только его: скрипт, который поймал ошибку, записал её в лог и вышел с нулём, для пайплайна успешен

subprocess без shell

Команды из Python запускают через subprocess.run. Главное правило: аргументы передаются списком, без shell=True. Тогда Python запускает программу напрямую, и каждый элемент списка доходит до неё одним аргументом, какие бы символы в нём ни были. С shell=True строку разбирает /bin/sh, и ;, $(), | внутри переменной превращаются в команды

import subprocess

name = "app.log; echo УДАЛИЛ ВСЁ"
subprocess.run(f"ls -l {name}", shell=True)
r = subprocess.run(["ls", "-l", name], capture_output=True, text=True)
print(r.returncode, r.stderr.strip())
ls: cannot access 'app.log': No such file or directory
УДАЛИЛ ВСЁ
2 ls: cannot access 'app.log; echo УДАЛИЛ ВСЁ': No such file or directory

Первый вызов выполнил вторую команду из имени файла. Второй искал файл с таким именем целиком и не нашёл. Остальные параметры, которые стоит знать наизусть:

ПараметрЧто делает
check=Trueненулевой код выхода превращается в CalledProcessError с полями returncode, stdout, stderr
capture_output=Trueзабирает stdout и stderr в объект результата. Вместе с явными stdout= и stderr= его передавать нельзя
text=Trueвывод приходит строкой, а не байтами
timeout=30по истечении времени процесс убивается, и поднимается TimeoutExpired

Без check=True упавшая команда молча вернёт объект с returncode 2, и скрипт пойдёт дальше. Это тот же провал, что bash без set -e

JSON и YAML

JSON разбирает стандартный модуль: json.load(f) для файла, json.loads(s) для строки, а r.json() у ответа HTTP-клиента. С YAML работает PyYAML, и здесь есть ловушка. Полноценный загрузчик YAML умеет создавать произвольные Python-объекты по тегам вроде !!python/object/apply, то есть вызывать функции прямо при чтении файла. Поэтому конфиги читают через yaml.safe_load: он понимает только строки, числа, списки и словари. Вызов yaml.load(doc) без загрузчика с PyYAML 6.0 падает с TypeError: load() missing 1 required positional argument: 'Loader', а safe_load на опасном теге поднимает ConstructorError

Вторая ловушка в самом формате: PyYAML реализует YAML 1.1, где часть «строк» превращается в другие типы

yaml.safe_load("port: 08\nversion: 1.10\ncountry: NO\n")
# {'port': '08', 'version': 1.1, 'country': False}

Версия 1.10 стала числом 1.1, а код страны NO стал False. Значения, которые должны остаться строками, бери в кавычки

HTTP API: таймауты, ретраи, пагинация

Для запросов к API берут requests или httpx. Три вещи отличают рабочий клиент от учебного

Таймаут. У requests его нет по умолчанию: без параметра timeout запрос к зависшему серверу висит сколько угодно. Скрипт в cron зависает, следующий запуск стартует поверх, и через час их двадцать. Пиши timeout=(3.05, 30): три секунды на соединение и тридцать на ожидание данных. У httpx таймаут по умолчанию есть, 5 секунд тишины в сети

Ретраи. Сеть и балансировщики иногда отвечают 502, 503 и 429. В requests повторы включаются через urllib3.util.Retry в HTTPAdapter: число попыток, экспоненциальная пауза backoff_factor, коды из status_forcelist. По умолчанию Retry повторяет только идемпотентные методы: GET, HEAD, PUT, DELETE, OPTIONS, TRACE. POST не повторяется, потому что второй такой запрос может создать второй заказ или второй деплой

Пагинация. API почти никогда не отдаёт всё за раз. У GitLab по умолчанию 20 записей на страницу, максимум per_page=100, а ссылка на следующую страницу приходит в заголовке Link с rel="next" и в x-next-page. Скрипт, который забыл про пагинацию, видит 20 образов из 3000 и уверенно отчитывается, что всё чисто

🛠️ На практике

Чистка старых образов в registry

Ситуация с прода: диск под GitLab Container Registry заполнен на 95%, потому что CI на каждый коммит пушит образ с тегом из SHA, и за год их накопились тысячи. Нужен скрипт, который пройдёт по всем репозиториям образов проекта и удалит теги старше N дней, оставив несколько свежих. Эндпоинты взяты из документации GitLab API: список репозиториев GET /projects/:id/registry/repositories, теги GET .../repositories/:repository_id/tags, карточка тега GET .../tags/:tag_name, удаление DELETE .../tags/:tag_name

Python · cleanup_registry.py, dry-run по умолчанию

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.12"
# dependencies = ["requests>=2.32,<3"]
# ///
"""Удаляет теги образов старше N дней из GitLab Container Registry. По умолчанию только показывает"""
import argparse
import logging
import os
from datetime import datetime, timedelta, timezone

import requests
from requests.adapters import HTTPAdapter
from urllib3.util import Retry

log = logging.getLogger("cleanup")
TIMEOUT = (3.05, 30)


def session(token: str) -> requests.Session:
    s = requests.Session()
    s.headers["PRIVATE-TOKEN"] = token
    retry = Retry(total=5, backoff_factor=1, status_forcelist=[429, 500, 502, 503, 504])
    s.mount("https://", HTTPAdapter(max_retries=retry))
    return s


def get_json(s: requests.Session, url: str, params: dict | None = None) -> requests.Response:
    r = s.get(url, params=params, timeout=TIMEOUT)
    r.raise_for_status()
    return r


def paginate(s: requests.Session, url: str):
    params = {"per_page": 100}
    while url:
        r = get_json(s, url, params)
        yield from r.json()
        url = r.links.get("next", {}).get("url")  # готовая ссылка на следующую страницу
        params = None  # параметры уже внутри ссылки


def main() -> None:
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument("--project", required=True, help="ID проекта или group%%2Fproject")
    p.add_argument("--older-than-days", type=int, default=30)
    p.add_argument("--keep", type=int, default=10, help="сколько свежих тегов не трогать")
    p.add_argument("--apply", action="store_true", help="удалить по-настоящему")
    args = p.parse_args()
    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")

    api = os.environ.get("GITLAB_API", "https://gitlab.com/api/v4")
    s = session(os.environ["GITLAB_TOKEN"])
    cutoff = datetime.now(timezone.utc) - timedelta(days=args.older_than_days)
    base = f"{api}/projects/{args.project}/registry/repositories"

    for repo in paginate(s, base):
        tags_url = f"{base}/{repo['id']}/tags"
        tags = []
        for t in paginate(s, tags_url):
            # в списке тегов нет даты, она есть только в карточке тега
            info = get_json(s, f"{tags_url}/{t['name']}").json()
            tags.append((datetime.fromisoformat(info["created_at"]), t["name"]))
        tags.sort(reverse=True)
        for created, name in tags[args.keep:]:
            if name == "latest" or created > cutoff:
                continue
            if not args.apply:
                log.info("dry-run: удалил бы %s:%s от %s", repo["path"], name, created.date())
                continue
            r = s.delete(f"{tags_url}/{name}", timeout=TIMEOUT)
            if r.status_code == 403:
                log.warning("тег %s:%s защищён, пропускаю", repo["path"], name)
                continue
            r.raise_for_status()
            log.info("удалил %s:%s", repo["path"], name)


if __name__ == "__main__":
    main()

Запуск без флага ничего не удаляет, только печатает план: GITLAB_TOKEN=... ./cleanup_registry.py --project 42 --keep 5. Посмотрел список, согласился, добавил --apply. В cron его можно неделю гонять в режиме отчёта и включить удаление, когда план выглядит правильно

Что в скрипте сделано намеренно

  • Генератор paginate скрывает пагинацию: остальной код просто перебирает теги и не знает про страницы. Следующую страницу берём из готовой ссылки r.links["next"], как и советует документация GitLab, а не собираем адрес сами
  • Список тегов не содержит created_at, поэтому на каждый тег идёт отдельный запрос карточки. На тысяче тегов это тысяча запросов, и ретраи на 429 здесь нужны всерьёз
  • Ответ 403 на удаление означает, что тег попал под правило защиты. Скрипт пропускает его и идёт дальше, а не падает посреди работы
  • Токен читается из переменной окружения, а не из аргумента: аргументы видны в списке процессов любому пользователю машины

Две особенности GitLab, о которых стоит сказать на собеседовании. Удаление тега не освобождает диск сразу: слои удаляет сборщик мусора registry. И у GitLab есть готовые средства: политика очистки (cleanup policy) в настройках проекта и массовое удаление DELETE .../tags с параметрами name_regex_delete, keep_n и older_than, которое можно вызывать не чаще раза в час на репозиторий. Свой скрипт оправдан, когда правило сложнее регулярки: не трогать теги, которые сейчас запущены в кластере, или чистить сразу несколько registry

Лайвкодинг: парсер логов

Самая частая задача на собеседовании DevOps: «вот access-лог nginx, посчитай ответы по статусам и покажи, какие эндпоинты чаще всего отдают 5xx». Смотрят, читаешь ли файл построчно и знаешь ли collections.Counter

import re
import sys
from collections import Counter
from pathlib import Path

LINE = re.compile(r'(?P<ip>\S+) \S+ \S+ \[[^]]+\] "(?P<method>\S+) (?P<path>\S+) [^"]*" (?P<status>\d{3})')


def parse(path: Path):
    # генератор: в памяти одна строка, а не весь файл
    with path.open(encoding="utf-8", errors="replace") as f:
        for line in f:
            m = LINE.match(line)
            if m:
                yield m.groupdict()


def main() -> None:
    statuses, errors = Counter(), Counter()
    for rec in parse(Path(sys.argv[1])):
        statuses[rec["status"]] += 1
        if rec["status"].startswith("5"):
            errors[(rec["method"], rec["path"])] += 1
    print("статусы:", dict(statuses.most_common()))
    for (method, path), n in errors.most_common(3):
        print(f"{n:>3} {method} {path}")


if __name__ == "__main__":
    main()

На логе из шести строк и одной битой строки:

статусы: {'200': 3, '502': 2, '504': 1}
  3 POST /api/pay

Детали, за которые ставят плюсы. Битая строка не роняет скрипт: регулярка не совпала, строка пропущена. errors="replace" спасает от UnicodeDecodeError, если в лог попал мусорный байт. Counter.most_common(3) сразу даёт топ без ручной сортировки словаря. Типичное продолжение задачи: «а теперь лог 50 ГБ и он в .gz». Ответ: gzip.open(path, "rt") вместо open, остальной код не меняется, потому что генератор уже читает построчно

⚠️ Где ошибаются

  • Запросы без таймаута. requests.get(url) к зависшему API висит часами, запуски cron копятся друг на друге. Таймаут ставится на каждый вызов или через обёртку вроде get_json выше
  • shell=True с f-строкой. Работает, пока в имени ветки, файла или пода нет ; или пробела. Список аргументов решает и инъекцию, и проблему с пробелами. Нужен конвейер — собери его из двух subprocess.run или сделай фильтрацию в Python
  • subprocess.run без check=True. Упала команда kubectl apply, а скрипт отчитался об успехе. Либо check=True, либо явная проверка returncode
  • f.read() или readlines() на большом логе. Файл на 20 ГБ целиком уходит в память, и скрипт убивает OOM killer вместе с соседями по узлу. Итерируйся по файлу: for line in f
  • pip install в системный Python под root. Пакеты перетирают то, на чём работает apt, а на свежих Debian и Ubuntu pip просто откажется. Окружение uv venv или скрипт с метаданными PEP 723
  • print вместо logging. В выводе cron нет ни времени, ни уровня, а данные для следующей команды перемешаны с диагностикой. Логи в stderr через logging, результат в stdout

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

На каких языках автоматизируешь, какие скрипты писал на Python?

Назови Python и bash и объясни границу: bash для обвязки команд и коротких хуков, Python там, где API, JSON или логика с ветвлениями. Дальше два-три конкретных скрипта с цифрами, например: чистка registry с dry-run, которая освободила 400 ГБ, отчёт по сертификатам с истекающим сроком из API балансировщика, проверка дрейфа конфигов между стендами. Про каждый скажи, что он делал при ошибке: таймауты, ретраи, ненулевой код выхода для CI. Интервьюер ищет не список библиотек, а признаки, что твои скрипты работали в проде без присмотра

Почему shell=True опасен и что использовать вместо него?

С shell=True строку команды разбирает /bin/sh, поэтому ;, |, $() и обратные кавычки внутри подставленной переменной становятся командами. Имя файла app.log; rm -rf /data превращается в удаление. Без shell аргументы передаются списком, и программа получает каждый элемент как один аргумент, без разбора. Если без shell никак, значения экранируют через shlex.quote, но обычно проще собрать конвейер из нескольких вызовов или сделать фильтрацию в Python

Как обработать лог на 50 ГБ, и чем здесь помогает генератор?

Файловый объект в Python уже итератор: for line in f читает файл кусками с буфером и отдаёт по строке, в памяти держится одна строка. Генератор с yield поверх него разбирает строку и отдаёт запись, не создавая список из миллионов элементов. Память постоянная, и обработку можно склеивать цепочкой генераторов: чтение, разбор, фильтр, подсчёт в Counter. readlines() вернёт список всех строк, и на 50 ГБ процесс умрёт от OOM. Сжатый лог читается так же через gzip.open(path, "rt")

Чем yaml.safe_load отличается от yaml.load?

safe_load строит только базовые типы: строки, числа, списки, словари. Полный загрузчик по тегам вроде !!python/object/apply создаёт Python-объекты и вызывает функции, и YAML из чужого репозитория или пользовательского ввода выполнит код при чтении. Поэтому с PyYAML 6.0 yaml.load без явного Loader падает с TypeError, а для конфигов берут safe_load. Отдельно стоит помнить про YAML 1.1: NO читается как False, 1.10 как число 1.1

Как сделать ретраи HTTP-запросов, и все ли запросы можно повторять?

В requests повторы подключаются через urllib3.util.Retry в HTTPAdapter: число попыток, экспоненциальная пауза и список кодов вроде 429, 502, 503, 504. Повторять безопасно только идемпотентные запросы, у которых повторный вызов ничего не добавляет, например GET, PUT и DELETE. Поэтому Retry по умолчанию не повторяет POST: второй запрос может создать второй ресурс. Для POST нужен ключ идемпотентности на стороне API или проверка, не создан ли ресурс. И ретраи без таймаута бесполезны: зависший запрос до повтора не доходит

📚 Что почитать