19.3. Когда Docker применять не следует

mkdir -p /tmp/nodocker && cd /tmp/nodocker

cat > cases.py <<'PY'
"""Выбор между контейнеризацией и альтернативой.

Инструмент отвечает не «да/нет», а «какой случай это, какой механизм
за ним стоит, какая альтернатива и чем за неё платят». Вывод «Docker
оправдан» — полноправный результат, а не отсутствие результата.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path


class Case:
    """Случай, где контейнеризация не оправдана."""

    def __init__(self, key: str, name: str, mechanism: str,
                 alternative: str, price: str, certain: bool,
                 depends_on: str = "") -> None:
        self.key = key
        self.name = name
        self.mechanism = mechanism
        self.alternative = alternative
        self.price = price
        self.certain = certain
        self.depends_on = depends_on

    def as_dict(self) -> dict[str, object]:
        return {
            "ключ": self.key, "случай": self.name, "механизм": self.mechanism,
            "альтернатива": self.alternative, "чем_платят": self.price,
            "однозначен": self.certain, "зависит_от": self.depends_on,
        }


CASES = [
    Case("latency", "Жёсткие требования к задержкам",
         "расходы на вводе-выводе и сети; настройки ядра делаются на хосте",
         "bare metal с настройкой хоста, пакет дистрибутива",
         "нет одинаковости окружения между машинами", True),
    Case("gui", "Приложение с графическим интерфейсом",
         "проброс сокетов рабочего стола снимает изоляцию",
         "Flatpak или Snap: те же namespaces плюс порталы",
         "упаковка под несколько форматов", True),
    Case("hardware", "Прямой доступ к оборудованию",
         "passthrough привязывает образ к версии драйвера хоста",
         "пакет дистрибутива с модулем и пользовательской частью",
         "возвращаются различия между машинами", False,
         "одинаков ли парк машин"),
    Case("oneshot", "Однократный или кратковременный скрипт",
         "стоимость сборки и передачи образа превышает саму работу",
         "uv run --with, venv, pipx",
         "зависимости берутся из системы", True),
    Case("static", "Простой статический сайт",
         "задача — отдать файлы; ни одна из задач статики не решается",
         "статический хостинг или веб-сервер из пакета",
         "практически ничем", False,
         "есть ли нетривиальная сборка артефакта"),
    Case("nocapacity", "Команда не поддерживает инфраструктуру",
         "стоимость постоянная: базовые образы, кэш, сканирование, очистка",
         "пакеты дистрибутива и systemd",
         "нет одинаковости и единообразия доставки", True),
    Case("audit", "Жёсткая прослеживаемость состава",
         "появляется второй путь обновления, требующий утверждения",
         "фиксированный образ системы и проверенный репозиторий",
         "теряются воспроизводимость сборки и SBOM", False,
         "описана ли процедура под фиксированный образ системы"),
]

BY_KEY = {c.key: c for c in CASES}

# Доводы, звучащие похоже, но в список не попадающие
NOT_CASES = [
    ("У нас всего один сервис", "одинаковость окружения нужна и одному"),
    ("У нас нет DevOps-инженера", "вопрос времени команды, а не должности"),
    ("Приложение с состоянием", "тома решают задачу; вопрос в эксплуатации"),
    ("Нужна максимальная производительность",
     "расходов на вычислениях практически нет"),
    ("Мы на Windows", "механизм иной, но задача решается"),
]

# Признаки, при которых контейнеризация ОПРАВДАНА
FOR_DOCKER = [
    ("много_машин", "несколько машин: одинаковость окружения важна"),
    ("много_сервисов", "несколько сервисов: единообразие доставки"),
    ("сложные_зависимости", "зависимости не ставятся из репозитория дистрибутива"),
    ("нужна_воспроизводимость", "требуется воспроизводимая сборка и SBOM"),
    ("есть_поддержка", "есть кому поддерживать инфраструктуру сборки"),
]


def classify(task: dict[str, object]) -> dict[str, object]:
    matched = [BY_KEY[k] for k in task.get("признаки", []) if k in BY_KEY]
    pro = [text for key, text in FOR_DOCKER if task.get(key)]

    # Неоднозначные случаи снимаются, если условие выполнено
    resolved: list[str] = []
    effective: list[Case] = []
    for c in matched:
        if not c.certain and task.get(f"снято_{c.key}"):
            resolved.append(f"{c.name}: снят — {c.depends_on}")
        else:
            effective.append(c)

    if effective and len(effective) >= len(pro):
        verdict = "контейнеризация не оправдана"
        recommend = effective[0].alternative
    elif pro:
        verdict = "Docker оправдан"
        recommend = "образ по правилам разделов 05 и 11"
    else:
        verdict = "недостаточно данных"
        recommend = "уточнить: сколько машин, сколько сервисов, какие зависимости"

    return {
        "задача": task["описание"],
        "случаи": [c.as_dict() for c in effective],
        "снятые": resolved,
        "за_docker": pro,
        "вердикт": verdict,
        "рекомендация": recommend,
    }


def main(path: str) -> int:
    tasks = json.loads(Path(path).read_text())
    result = {
        "справочник": [c.as_dict() for c in CASES],
        "не_случаи": NOT_CASES,
        "неоднозначных": sum(1 for c in CASES if not c.certain),
        "задачи": [classify(t) for t in tasks],
    }
    print(json.dumps(result, ensure_ascii=False))
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "tasks.json"))
PY

cat > tasks.json <<'EOF'
[
  {
    "описание": "Скрипт выгрузки отчёта, запускается раз в сутки, работает 3 секунды",
    "признаки": ["oneshot"],
    "много_машин": false,
    "сложные_зависимости": false
  },
  {
    "описание": "Настольная утилита с интерфейсом для внутренних пользователей",
    "признаки": ["gui"],
    "много_машин": false
  },
  {
    "описание": "Обработка видео на ускорителе, парк из 40 одинаковых машин",
    "признаки": ["hardware"],
    "снято_hardware": true,
    "много_машин": true,
    "много_сервисов": false,
    "сложные_зависимости": true,
    "есть_поддержка": true
  },
  {
    "описание": "Лендинг из готовых HTML и CSS без сборки",
    "признаки": ["static"],
    "много_машин": false
  },
  {
    "описание": "API на Python, шесть сервисов, четыре машины, есть дежурство",
    "признаки": [],
    "много_машин": true,
    "много_сервисов": true,
    "сложные_зависимости": true,
    "нужна_воспроизводимость": true,
    "есть_поддержка": true
  }
]
EOF

cat > script.py <<'PY'
"""Кратковременная задача для измерения стоимости запуска."""
from __future__ import annotations

import sys
from pathlib import Path


def main(root: str = ".") -> int:
    total = sum(len(p.read_text(encoding="utf-8").splitlines())
                for p in sorted(Path(root).rglob("*.py")))
    print(f"  строк Python: {total}")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "."))
PY

fail=0
ok()  { printf '  ✓ %s\n' "$1"; }
bad() { printf '  ✗ %s\n' "$1"; fail=1; }

python3 cases.py tasks.json > result.json

printf '\n═══ Требование 1: механизм, а не вывод ═══\n'
python3 - <<'PY'
import json

d = json.load(open("result.json"))
print(f"    {'случай':<40} механизм")
print("    " + "─" * 108)
for c in d["справочник"]:
    print(f"    {c['случай']:<40} {c['механизм']}")
print()
print(f"    случаев: {len(d['справочник'])}")
print()
print("    В каждой строке названа ПРИЧИНА, по которой контейнеризация")
print("    не даёт выигрыша, а не утверждение, что не даёт.")
PY
n_cases="$(python3 -c "import json;print(len(json.load(open('result.json'))['справочник']))")"
[ "$n_cases" -eq 7 ] \
    && ok "семь случаев, каждый описан механизмом" \
    || bad "случаев: $n_cases"

printf '\n═══ Требование 2: альтернатива и её цена ═══\n'
python3 - <<'PY'
import json

d = json.load(open("result.json"))
print(f"    {'случай':<38} {'альтернатива':<46} чем платят")
print("    " + "─" * 128)
for c in d["справочник"]:
    print(f"    {c['случай']:<38} {c['альтернатива']:<46} {c['чем_платят']}")
print()
free = [c for c in d["справочник"] if "практически ничем" in c["чем_платят"]]
print(f"    случаев, где отказ почти ничего не стоит: {len(free)}")
for c in free:
    print(f"      · {c['случай']}")
print()
print("    Столбец «чем платят» обязателен: без него список превращается")
print("    в агитацию против инструмента, а не в разбор задач.")
PY
with_price="$(python3 -c "
import json
d = json.load(open('result.json'))
print(sum(1 for c in d['справочник'] if c['чем_платят']))")"
[ "$with_price" -eq 7 ] \
    && ok "для каждого случая названа цена отказа" \
    || bad "с ценой: $with_price из 7"

printf '\n═══ Требование 3: неоднозначные случаи ═══\n'
python3 - <<'PY'
import json

d = json.load(open("result.json"))
unclear = [c for c in d["справочник"] if not c["однозначен"]]
print(f"    {'случай':<38} вывод зависит от")
print("    " + "─" * 96)
for c in unclear:
    print(f"    {c['случай']:<38} {c['зависит_от']}")
print()
print(f"    неоднозначных: {len(unclear)} из {len(d['справочник'])}")
print()
print("    Это существеннее самого списка: прямой доступ к оборудованию")
print("    перестаёт быть доводом при одинаковом парке машин; статический")
print("    сайт стоит СОБИРАТЬ в container'е, но не РАЗДАВАТЬ из него;")
print("    прослеживаемость и усложняется контейнеризацией, и получает")
print("    от неё средства — SBOM, digest, подписи.")
PY
unclear="$(python3 -c "
import json
d = json.load(open('result.json'))
print(sum(1 for c in d['справочник'] if not c['однозначен']))")"
[ "$unclear" -ge 3 ] \
    && ok "неоднозначные случаи выделены с указанием условия" \
    || bad "неоднозначных: $unclear"

printf '\n═══ Требование 4: пять задач, включая обратный случай ═══\n'
python3 - <<'PY'
import json

d = json.load(open("result.json"))
for t in d["задачи"]:
    print(f"    ── {t['задача']}")
    for c in t["случаи"]:
        print(f"       случай: {c['случай']}")
        print(f"               механизм: {c['механизм']}")
    for s in t["снятые"]:
        print(f"       СНЯТ: {s}")
    for p in t["за_docker"]:
        print(f"       + {p}")
    print(f"       ВЫВОД: {t['вердикт']}")
    print(f"       → {t['рекомендация']}")
    print()
verdicts = [t["вердикт"] for t in d["задачи"]]
pro = sum(1 for v in verdicts if v == "Docker оправдан")
print(f"    задач: {len(verdicts)}, «Docker оправдан»: {pro}, "
      f"различных выводов: {len(set(verdicts))}")
PY
pro="$(python3 -c "
import json
d = json.load(open('result.json'))
print(sum(1 for t in d['задачи'] if t['вердикт'] == 'Docker оправдан'))")"
printf '\n  задач с выводом «Docker оправдан»: %s\n' "$pro"
[ "$pro" -ge 1 ] \
    && ok "инструмент способен рекомендовать Docker — значит, отказ что-то значит" \
    || bad "«Docker оправдан»: $pro — инструмент отвечает односторонне"

printf '\n═══ Требование 5: измерение стоимости альтернативы ═══\n'
command -v uv >/dev/null && uv --version | sed 's/^/  /'
python3 --version | sed 's/^/  /'
echo
rm -rf venv-std venv-uv
printf '  стандартное средство: '
/usr/bin/time -f "%e с" python3 -m venv venv-std 2>&1 | tail -1
printf '  uv:                   '
/usr/bin/time -f "%e с" uv venv venv-uv 2>&1 | tail -1
printf '  сама задача:          '
python3 script.py . >/dev/null 2>&1
/usr/bin/time -f "%e с" python3 script.py . 2>&1 | tail -1
rm -rf venv-std venv-uv
echo
echo "  Сравнение с docker build здесь НЕ приводится: Docker не установлен,"
echo "  а придумывать время сборки было бы подлогом. Достроить сравнение"
echo "  можно у себя:"
echo "    time docker build -t oneshot .          # НЕ ВЫПОЛНЯЛОСЬ"
echo "    time docker run --rm oneshot script.py  # НЕ ВЫПОЛНЯЛОСЬ"
ok "стоимость альтернативы измерена; сравнение честно оставлено читателю"

printf '\n═══ Требование 6: похожие доводы, не попадающие в список ═══\n'
python3 - <<'PY'
import json

d = json.load(open("result.json"))
print(f"    {'довод':<42} почему НЕ попадает")
print("    " + "─" * 100)
for case, why in d["не_случаи"]:
    print(f"    {case:<42} {why}")
print()
print(f"    доводов: {len(d['не_случаи'])}")
print()
print("    Первый и четвёртый встречаются чаще прочих, и оба основаны")
print("    на неточном представлении о том, где Docker берёт своё:")
print("    одинаковость окружения нужна и одной машине, а расходов")
print("    на вычислениях у container'а практически нет.")
PY
n_not="$(python3 -c "import json;print(len(json.load(open('result.json'))['не_случаи']))")"
[ "$n_not" -ge 4 ] \
    && ok "названы доводы, которые звучат похоже, но неверны" \
    || bad "доводов: $n_not"

printf '\n═══ Требование 7: измеренное и предполагаемое ═══\n'
python3 - <<'PY'
MEASURED = [
    ("время создания venv стандартным средством", "/usr/bin/time"),
    ("время создания venv через uv", "/usr/bin/time"),
    ("время выполнения самой задачи", "/usr/bin/time"),
    ("наличие и версии инструментов", "команды --version"),
]
NOT_MEASURED = [
    ("время сборки образа", "Docker на машине курса не установлен"),
    ("расходы на вводе-выводе в container'е", "то же"),
    ("поведение проброса сокета рабочего стола", "требует сессии и Docker"),
    ("привязка образа к версии драйвера", "требует оборудования"),
    ("стоимость поддержки инфраструктуры", "зависит от команды и проекта"),
]
print(f"    {'ИЗМЕРЕНО':<44} чем")
print("    " + "─" * 74)
for name, how in MEASURED:
    print(f"    {name:<44} {how}")
print()
print(f"    {'НЕ ИЗМЕРЯЛОСЬ':<44} причина")
print("    " + "─" * 84)
for name, why in NOT_MEASURED:
    print(f"    {name:<44} {why}")
print()
print(f"    измерено: {len(MEASURED)}, не измерялось: {len(NOT_MEASURED)}")
print()
print("    Механизмы в справочнике — утверждения о том, как устроены")
print("    OverlayFS, сеть, passthrough и порталы. Они опираются")
print("    на разделы 08, 17 и документацию, а не на замеры здесь.")
PY
ok "измеренное отделено от утверждаемого"

printf '\n═══ ИТОГ ═══\n'
[ "$fail" -eq 0 ] && echo "  все требования выполнены" || echo "  ЕСТЬ ПРОВАЛЫ"
echo "  примечание: Docker не использовался; измерена только альтернатива"

cd /tmp && rm -rf /tmp/nodocker
exit "$fail"

═══ Требование 1: механизм, а не вывод ═══
    случай                                   механизм
    ────────────────────────────────────────────────────────────────────────────────────────────────────────────
    Жёсткие требования к задержкам           расходы на вводе-выводе и сети; настройки ядра делаются на хосте
    Приложение с графическим интерфейсом     проброс сокетов рабочего стола снимает изоляцию
    Прямой доступ к оборудованию             passthrough привязывает образ к версии драйвера хоста
    Однократный или кратковременный скрипт   стоимость сборки и передачи образа превышает саму работу
    Простой статический сайт                 задача — отдать файлы; ни одна из задач статики не решается
    Команда не поддерживает инфраструктуру   стоимость постоянная: базовые образы, кэш, сканирование, очистка
    Жёсткая прослеживаемость состава         появляется второй путь обновления, требующий утверждения

    случаев: 7

    В каждой строке названа ПРИЧИНА, по которой контейнеризация
    не даёт выигрыша, а не утверждение, что не даёт.
  ✓ семь случаев, каждый описан механизмом

═══ Требование 3: неоднозначные случаи ═══
    случай                                 вывод зависит от
    ────────────────────────────────────────────────────────────────────────────────────────────────
    Прямой доступ к оборудованию           одинаков ли парк машин
    Простой статический сайт               есть ли нетривиальная сборка артефакта
    Жёсткая прослеживаемость состава       описана ли процедура под фиксированный образ системы

    неоднозначных: 3 из 7
  ✓ неоднозначные случаи выделены с указанием условия

═══ Требование 4: пять задач, включая обратный случай ═══
    ── Скрипт выгрузки отчёта, запускается раз в сутки, работает 3 секунды
       случай: Однократный или кратковременный скрипт
               механизм: стоимость сборки и передачи образа превышает саму работу
       ВЫВОД: контейнеризация не оправдана
       → uv run --with, venv, pipx

    ── Настольная утилита с интерфейсом для внутренних пользователей
       случай: Приложение с графическим интерфейсом
               механизм: проброс сокетов рабочего стола снимает изоляцию
       ВЫВОД: контейнеризация не оправдана
       → Flatpak или Snap: те же namespaces плюс порталы

    ── Обработка видео на ускорителе, парк из 40 одинаковых машин
       СНЯТ: Прямой доступ к оборудованию: снят — одинаков ли парк машин
       + несколько машин: одинаковость окружения важна
       + зависимости не ставятся из репозитория дистрибутива
       + есть кому поддерживать инфраструктуру сборки
       ВЫВОД: Docker оправдан
       → образ по правилам разделов 05 и 11

    ── Лендинг из готовых HTML и CSS без сборки
       случай: Простой статический сайт
               механизм: задача — отдать файлы; ни одна из задач статики не решается
       ВЫВОД: контейнеризация не оправдана
       → статический хостинг или веб-сервер из пакета

    ── API на Python, шесть сервисов, четыре машины, есть дежурство
       + несколько машин: одинаковость окружения важна
       + несколько сервисов: единообразие доставки
       + зависимости не ставятся из репозитория дистрибутива
       + требуется воспроизводимая сборка и SBOM
       + есть кому поддерживать инфраструктуру сборки
       ВЫВОД: Docker оправдан
       → образ по правилам разделов 05 и 11

    задач: 5, «Docker оправдан»: 2, различных выводов: 2

  задач с выводом «Docker оправдан»: 2
  ✓ инструмент способен рекомендовать Docker — значит, отказ что-то значит

═══ Требование 5: измерение стоимости альтернативы ═══
  uv 0.11.6 (x86_64-unknown-linux-gnu)
  Python 3.12.3

  стандартное средство: 5.28 с
  uv:                   0.13 с
  сама задача:          0.02 с

  Сравнение с docker build здесь НЕ приводится: Docker не установлен,
  а придумывать время сборки было бы подлогом.
  ✓ стоимость альтернативы измерена; сравнение честно оставлено читателю

═══ ИТОГ ═══
  все требования выполнены
  примечание: Docker не использовался; измерена только альтернатива