19.1. Где containers усложняют систему

mkdir -p /tmp/limits && cd /tmp/limits

cat > cost.py <<'PY'
"""Учёт цены контейнеризации для конкретной задачи.

Инструмент не отвечает «нужен Docker или нет» одним словом.
Он раскладывает решение на статьи: что добавится к отладке,
что даст systemd теми же средствами ядра, где будут расходы,
и какой признак в итоге разводит два варианта.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

# ── Путь от симптома к причине ────────────────────────────────────────
PLAIN_LEVELS = ["лог приложения", "процесс", "система"]
CONTAINER_LEVELS = [
    "лог приложения", "процесс в PID namespace", "cgroup",
    "OverlayFS", "veth и bridge", "NAT", "сеть хоста",
]

# (причина, добавлена ли контейнеризацией)
REFUSED_CAUSES = [
    ("процесс не запустился", False),
    ("слушает 127.0.0.1 вместо 0.0.0.0", False),
    ("сервис ещё не готов", False),
    ("container'ы в разных сетях", True),
    ("опечатка в имени сервиса", True),
    ("опубликован не тот порт", True),
]

# (свойство, Docker, systemd, механизм ядра)
PROPS = [
    ("Ограничение памяти", "mem_limit", "MemoryMax=", "cgroups v2"),
    ("Торможение до OOM", "НЕТ", "MemoryHigh=", "cgroups v2"),
    ("Ограничение CPU", "cpus", "CPUQuota=", "cgroups v2"),
    ("Ограничение числа задач", "pids_limit", "TasksMax=", "cgroups v2"),
    ("Запуск не от root", "USER", "DynamicUser=yes", "—"),
    ("Корень только для чтения", "read_only", "ProtectSystem=strict", "mount ns"),
    ("Свой /tmp", "tmpfs", "PrivateTmp=yes", "mount ns"),
    ("Скрытие устройств", "--device", "PrivateDevices=yes", "mount ns"),
    ("Запрет повышения привилегий", "no-new-privileges", "NoNewPrivileges=yes",
     "prctl"),
    ("Снятие capabilities", "--cap-drop ALL", "CapabilityBoundingSet=",
     "capabilities"),
    ("Ограничение системных вызовов", "seccomp", "SystemCallFilter=", "seccomp"),
    ("Автозапуск и перезапуск", "restart:", "Restart=", "—"),
    ("Мягкая остановка", "stop_grace_period", "TimeoutStopSec=", "—"),
    ("Логи", "драйвер логирования", "journald", "—"),
]

ONLY_DOCKER = [
    "Упаковка зависимостей вместе с приложением",
    "Одинаковость окружения на разных машинах",
    "Единообразие доставки для всех приложений",
]

# (место, механизм, где заметно, чем снимается, что теряется)
OVERHEAD = [
    ("Вычисления", "обычный процесс ядра", "нигде", "", ""),
    ("Память", "те же страницы", "нигде", "", ""),
    ("Системные вызовы", "фильтр seccomp на каждый вызов",
     "интенсивные syscall", "seccomp=unconfined", "существенную часть защиты"),
    ("Чтение файлов", "поиск по стеку слоёв OverlayFS",
     "много мелких файлов", "bind mount", "независимость от каталогов хоста"),
    ("Запись в файлы образа", "copy-up копирует файл целиком",
     "запись в большие файлы", "том", "эфемерность"),
    ("Сеть", "veth, bridge, NAT на каждый пакет",
     "высокий pps", "--network host", "сетевую изоляцию целиком"),
]


def unit_for(task: dict[str, object]) -> str:
    """Unit-файл с ограничениями, равными указанным в задаче."""
    name = str(task["имя"])
    mem = task.get("память", "256M")
    cpu = task.get("cpu", "50%")
    return f"""[Unit]
Description={task['описание']}
After=network-online.target
Wants=network-online.target

[Service]
Type=exec
ExecStart={task['команда']}

DynamicUser=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
PrivateDevices=yes
NoNewPrivileges=yes
RestrictSUIDSGID=yes
CapabilityBoundingSet=
SystemCallFilter=@system-service
SystemCallErrorNumber=EPERM
StateDirectory={name}

MemoryMax={mem}
MemoryHigh={task.get('память_мягкая', mem)}
CPUQuota={cpu}
TasksMax=64

Restart=on-failure
RestartSec=5
TimeoutStopSec=30
KillSignal=SIGTERM

[Install]
WantedBy=multi-user.target
"""


def analyze(task: dict[str, object]) -> dict[str, object]:
    """Признак, разводящий варианты: нужна ли упаковка зависимостей."""
    needs_packaging = bool(task.get("нужна_упаковка"))
    many_machines = int(task.get("машин", 1)) > 1
    io_bound = bool(task.get("интенсивный_ввод_вывод"))
    hardware = bool(task.get("оборудование"))

    reasons_for: list[str] = []
    reasons_against: list[str] = []

    if needs_packaging:
        reasons_for.append("зависимости не ставятся из репозитория дистрибутива")
    else:
        reasons_against.append("зависимости есть в дистрибутиве: упаковка не нужна")

    if many_machines:
        reasons_for.append(f"машин: {task['машин']} — одинаковость окружения важна")
    else:
        reasons_against.append("одна машина: одинаковость нечему обеспечивать")

    if int(task.get("сервисов", 1)) > 3:
        reasons_for.append(f"сервисов: {task['сервисов']} — единообразие доставки")

    if io_bound:
        reasons_against.append("интенсивный ввод-вывод: расходы на OverlayFS и сети")
    if hardware:
        reasons_against.append("работа с оборудованием: образ привяжется к хосту")
    if not task.get("есть_кому_поддерживать", True):
        reasons_against.append("некому поддерживать инфраструктуру сборки")

    verdict = ("Docker оправдан" if len(reasons_for) > len(reasons_against)
               else "systemd-сервис проще")
    return {
        "задача": task["описание"],
        "за": reasons_for,
        "против": reasons_against,
        "вердикт": verdict,
        "признак": ("упаковка нужна" if needs_packaging else "упаковка не нужна"),
    }


def main(path: str) -> int:
    tasks = json.loads(Path(path).read_text())
    out: list[dict[str, object]] = []
    for task in tasks:
        unit_path = Path(f"{task['имя']}.service")
        unit_path.write_text(unit_for(task), encoding="utf-8")
        r = analyze(task)
        r["unit"] = unit_path.name
        out.append(r)

    print(json.dumps({
        "уровней_до": len(PLAIN_LEVELS),
        "уровней_после": len(CONTAINER_LEVELS),
        "причин_всего": len(REFUSED_CAUSES),
        "причин_добавлено": sum(1 for _, added in REFUSED_CAUSES if added),
        "свойств": len(PROPS),
        "совпадает": sum(1 for _, d, _, _ in PROPS if d != "НЕТ"),
        "только_docker": len(ONLY_DOCKER),
        "мест_расходов": len(OVERHEAD),
        "без_расходов": sum(1 for _, _, w, _, _ in OVERHEAD if w == "нигде"),
        "задачи": out,
    }, 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'
[
  {
    "имя": "logrotate-helper",
    "описание": "Скрипт ротации логов на одной машине",
    "команда": "/usr/bin/python3 /opt/rotate/main.py",
    "нужна_упаковка": false,
    "машин": 1,
    "сервисов": 1,
    "интенсивный_ввод_вывод": true,
    "оборудование": false,
    "есть_кому_поддерживать": false,
    "память": "64M",
    "cpu": "20%"
  },
  {
    "имя": "video-encoder",
    "описание": "Кодировщик видео с аппаратным ускорением",
    "команда": "/opt/encoder/bin/encoder --device /dev/dri/renderD128",
    "нужна_упаковка": true,
    "машин": 1,
    "сервисов": 1,
    "интенсивный_ввод_вывод": true,
    "оборудование": true,
    "есть_кому_поддерживать": true,
    "память": "2G",
    "cpu": "400%"
  },
  {
    "имя": "api-service",
    "описание": "API на Python с зависимостями из PyPI, шесть сервисов, четыре машины",
    "команда": "/opt/api/venv/bin/python -m api.main",
    "нужна_упаковка": true,
    "машин": 4,
    "сервисов": 6,
    "интенсивный_ввод_вывод": false,
    "оборудование": false,
    "есть_кому_поддерживать": true,
    "память": "512M",
    "память_мягкая": "400M",
    "cpu": "100%"
  }
]
EOF

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

python3 cost.py tasks.json > result.json 2>&1
get() { python3 -c "import json;print(json.load(open('result.json'))['$1'])"; }

printf '\n═══ Требование 1: удлинение пути отладки ═══\n'
python3 - <<'PY'
from cost import PLAIN_LEVELS, CONTAINER_LEVELS, REFUSED_CAUSES

print(f"    {'без container':<28} {'с container'}")
print("    " + "─" * 60)
for i in range(max(len(PLAIN_LEVELS), len(CONTAINER_LEVELS))):
    a = PLAIN_LEVELS[i] if i < len(PLAIN_LEVELS) else ""
    b = CONTAINER_LEVELS[i] if i < len(CONTAINER_LEVELS) else ""
    print(f"    {a:<28} {b}")
print()
print(f"    уровней: {len(PLAIN_LEVELS)} → {len(CONTAINER_LEVELS)} "
      f"(+{len(CONTAINER_LEVELS) - len(PLAIN_LEVELS)})")
print()
print("    Одно сообщение «Connection refused»:")
print(f"    {'причина':<40} происхождение")
print("    " + "─" * 72)
for cause, added in REFUSED_CAUSES:
    origin = "ДОБАВЛЕНО контейнеризацией" if added else "есть и без container'а"
    print(f"    {cause:<40} {origin}")
added = sum(1 for _, a in REFUSED_CAUSES if a)
print()
print(f"    причин: {len(REFUSED_CAUSES)}, добавлено: {added} "
      f"({added / len(REFUSED_CAUSES) * 100:.0f} %)")
print()
print("    Цена абстракции измерима: то же сообщение означает вдвое больше вещей.")
PY
before="$(get уровней_до)"; after="$(get уровней_после)"
added="$(get причин_добавлено)"; total="$(get причин_всего)"
printf '\n  уровней: %s → %s; причин добавлено: %s из %s\n' \
    "$before" "$after" "$added" "$total"
[ "$after" -gt "$before" ] && [ "$added" -gt 0 ] \
    && ok "удлинение показано числами, а не рассуждением" \
    || bad "уровней $before→$after, добавлено $added"

printf '\n═══ Требование 2: сопоставление с systemd ═══\n'
python3 - <<'PY'
from cost import PROPS, ONLY_DOCKER

print(f"    {'свойство':<32} {'Docker':<20} {'systemd':<24} механизм ядра")
print("    " + "─" * 96)
for prop, docker, systemd, mech in PROPS:
    print(f"    {prop:<32} {docker:<20} {systemd:<24} {mech}")
same = sum(1 for _, d, _, _ in PROPS if d != "НЕТ")
shared = sum(1 for _, _, _, m in PROPS if m != "—")
print()
print(f"    совпадает по смыслу: {same} из {len(PROPS)}")
print(f"    на ОБЩЕМ механизме ядра: {shared}")
print(f"    где systemd даёт больше: {len(PROPS) - same} (MemoryHigh)")
print()
print("    Только у Docker:")
for item in ONLY_DOCKER:
    print(f"      · {item}")
print()
print("    Граница проходит по УПАКОВКЕ, а не по изоляции.")
PY
props="$(get свойств)"; same="$(get совпадает)"; only="$(get только_docker)"
printf '\n  свойств: %s, совпадает: %s, только у Docker: %s\n' "$props" "$same" "$only"
[ "$same" -ge 10 ] && [ "$only" -eq 3 ] \
    && ok "большинство свойств совпадает; различие сведено к упаковке" \
    || bad "совпадает $same, только Docker $only"

printf '\n═══ Требование 3: unit-файлы и настоящая проверка ═══\n'
systemctl --version | head -1 | sed 's/^/  /'
printf '  контроллеры cgroup v2: %s\n' "$(cat /sys/fs/cgroup/cgroup.controllers)"
echo
verify_unit() {
    # Код возврата systemd-analyze verify равен нулю и на испорченном файле,
    # поэтому признаком служит наличие строк с именем проверяемого файла.
    systemd-analyze verify "./$1" 2>&1 | grep -F "$1" || true
}
units_total=0; syntax_bad=0; missing_exec=0
for u in *.service; do
    units_total=$((units_total + 1))
    out="$(verify_unit "$u")"
    if [ -z "$out" ]; then
        printf '  %-26s замечаний нет\n' "$u"
    elif printf '%s' "$out" | grep -q "is not executable"; then
        # Отдельный класс: путь из ExecStart не существует НА ЭТОЙ машине.
        # Это не ошибка unit-файла, а проверка, которой у Docker нет вовсе.
        missing_exec=$((missing_exec + 1))
        printf '  %-26s нет исполняемого файла (директивы приняты)\n' "$u"
    else
        syntax_bad=$((syntax_bad + 1))
        printf '  %-26s %s\n' "$u" "$out"
    fi
done
printf '\n  unit-файлов: %s; ошибок синтаксиса: %s; путь ExecStart отсутствует: %s\n' \
    "$units_total" "$syntax_bad" "$missing_exec"
echo
echo "  Находка: systemd-analyze проверяет СУЩЕСТВОВАНИЕ исполняемого файла,"
echo "  а не только синтаксис. У Docker аналога нет: опечатка в command:"
echo "  внутри compose.yaml выявляется при запуске, а не при разборе конфигурации."
[ "$units_total" -eq 3 ] && [ "$syntax_bad" -eq 0 ] \
    && ok "все директивы приняты systemd; ошибок синтаксиса нет" \
    || bad "ошибок синтаксиса: $syntax_bad из $units_total"

printf '\n═══ Требование 4: проверка проверяющего ═══\n'
cat > broken.service <<'EOF'
[Service]
ExecStart=/bin/true
ProtectSystem=nonsense
EOF
broken_out="$(verify_unit broken.service)"
if [ -n "$broken_out" ]; then
    printf '  испорченный unit: %s\n' "$broken_out"
    ok "проверяющий находит заведомую ошибку — значит, «замечаний нет» что-то значит"
else
    bad "испорченный unit прошёл проверку: инструмент бесполезен"
fi
printf '  код возврата на испорченном файле: '
systemd-analyze verify ./broken.service >/dev/null 2>&1; printf '%s ' "$?"
printf '(поэтому признаком служит вывод, а не код)\n'
rm -f broken.service

printf '\n═══ Требование 5: расходы производительности ═══\n'
python3 - <<'PY'
from cost import OVERHEAD

print(f"    {'место':<26} {'механизм':<38} где заметно")
print("    " + "─" * 96)
for place, mech, where, _, _ in OVERHEAD:
    print(f"    {place:<26} {mech:<38} {where}")
free = sum(1 for _, _, w, _, _ in OVERHEAD if w == "нигде")
print()
print(f"    мест без расходов: {free} из {len(OVERHEAD)}")
print()
print(f"    {'способ снять':<26} {'что снимает':<26} что теряется")
print("    " + "─" * 92)
seen = set()
for place, _, _, fix, loses in OVERHEAD:
    if not fix or fix in seen:
        continue
    seen.add(fix)
    print(f"    {fix:<26} {place:<26} {loses}")
print()
print("    Закономерность: каждый способ ускорить container отключает")
print("    то, ради чего container взят. Если нужны все четыре —")
print("    вопрос стоит поставить иначе.")
PY
places="$(get мест_расходов)"; free="$(get без_расходов)"
printf '\n  мест: %s, из них без расходов: %s\n' "$places" "$free"
[ "$free" -ge 2 ] \
    && ok "названы и места расходов, и места, где их нет" \
    || bad "мест без расходов: $free"

printf '\n═══ Требование 6: три задачи ═══\n'
python3 - <<'PY'
import json

data = json.load(open("result.json"))
for t in data["задачи"]:
    print(f"    ── {t['задача']}")
    print(f"       признак: {t['признак']}")
    for r in t["за"]:
        print(f"       + {r}")
    for r in t["против"]:
        print(f"       − {r}")
    print(f"       ВЫВОД: {t['вердикт']}  (unit: {t['unit']})")
    print()
verdicts = {t["вердикт"] for t in data["задачи"]}
print(f"    различных выводов: {len(verdicts)}")
print()
print("    Вторая задача показательна: упаковка нужна, но образ с")
print("    аппаратным ускорением привязывается к версии драйвера на хосте.")
print("    Обещание «работает везде одинаково» здесь не выполняется,")
print("    и главный довод за Docker исчезает.")
PY
n_verdicts="$(python3 -c "
import json
d = json.load(open('result.json'))
print(len({t['вердикт'] for t in d['задачи']}))")"
[ "$n_verdicts" -ge 2 ] \
    && ok "задачи дали разные выводы, каждый с обоснованием" \
    || bad "различных выводов: $n_verdicts"

printf '\n═══ Требование 7: что НЕ проверялось ═══\n'
python3 - <<'PY'
NOT_RUN = [
    ("любые измерения расходов", "Docker на машине курса не установлен"),
    ("фактический запуск unit-файлов", "нет сессионной шины и прав на установку"),
    ("действие ProtectSystem и seccomp", "требует запуска сервиса"),
    ("поведение при passthrough устройства", "требует оборудования и драйвера"),
]
print(f"    {'проверка':<40} причина")
print("    " + "─" * 84)
for name, why in NOT_RUN:
    print(f"    {name:<40} {why}")
print(f"\n    не выполнялось: {len(NOT_RUN)}")
print()
print("    ВЫПОЛНЕНО по-настоящему: версия systemd, состав контроллеров")
print("    cgroup v2, синтаксическая проверка трёх unit-файлов и проверка")
print("    самого проверяющего на заведомо испорченном файле.")
print()
print("    Числовые значения расходов не приводятся намеренно: они зависят")
print("    от ядра, драйвера хранилища и нагрузки. Механизмы от стенда не зависят.")
PY
ok "разделено выполненное и невыполненное; числа не выдуманы"

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

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

═══ Требование 1: удлинение пути отладки ═══
    без container                с container
    ────────────────────────────────────────────────────────────
    лог приложения               лог приложения
    процесс                      процесс в PID namespace
    система                      cgroup
                                 OverlayFS
                                 veth и bridge
                                 NAT
                                 сеть хоста

    уровней: 3 → 7 (+4)

    Одно сообщение «Connection refused»:
    причина                                  происхождение
    ────────────────────────────────────────────────────────────────────────
    процесс не запустился                    есть и без container'а
    слушает 127.0.0.1 вместо 0.0.0.0         есть и без container'а
    сервис ещё не готов                      есть и без container'а
    container'ы в разных сетях               ДОБАВЛЕНО контейнеризацией
    опечатка в имени сервиса                 ДОБАВЛЕНО контейнеризацией
    опубликован не тот порт                  ДОБАВЛЕНО контейнеризацией

    причин: 6, добавлено: 3 (50 %)

  уровней: 3 → 7; причин добавлено: 3 из 6
  ✓ удлинение показано числами, а не рассуждением

═══ Требование 2: сопоставление с systemd ═══
    свойство                         Docker               systemd                  механизм ядра
    ────────────────────────────────────────────────────────────────────────────────────────────────
    Ограничение памяти               mem_limit            MemoryMax=               cgroups v2
    Торможение до OOM                НЕТ                  MemoryHigh=              cgroups v2
    Ограничение CPU                  cpus                 CPUQuota=                cgroups v2
    ...
    Ограничение системных вызовов    seccomp              SystemCallFilter=        seccomp

    совпадает по смыслу: 13 из 14
    на ОБЩЕМ механизме ядра: 10
    где systemd даёт больше: 1 (MemoryHigh)

    Только у Docker:
      · Упаковка зависимостей вместе с приложением
      · Одинаковость окружения на разных машинах
      · Единообразие доставки для всех приложений

    Граница проходит по УПАКОВКЕ, а не по изоляции.

  свойств: 14, совпадает: 13, только у Docker: 3
  ✓ большинство свойств совпадает; различие сведено к упаковке

    Десять свойств из четырнадцати опираются на буквально один и тот же
    механизм ядра — cgroups v2, mount namespace, seccomp, capabilities.
    Это не сходство подходов, а общая реализация.

═══ Требование 3: unit-файлы и настоящая проверка ═══
  systemd 255 (255.4-1ubuntu8.11)
  контроллеры cgroup v2: cpuset cpu io memory hugetlb pids rdma misc

  api-service.service        нет исполняемого файла (директивы приняты)
  logrotate-helper.service   замечаний нет
  video-encoder.service      нет исполняемого файла (директивы приняты)

  unit-файлов: 3; ошибок синтаксиса: 0; путь ExecStart отсутствует: 2

  Находка: systemd-analyze проверяет СУЩЕСТВОВАНИЕ исполняемого файла,
  а не только синтаксис. У Docker аналога нет: опечатка в command:
  внутри compose.yaml выявляется при запуске, а не при разборе конфигурации.
  ✓ все директивы приняты systemd; ошибок синтаксиса нет

═══ Требование 4: проверка проверяющего ═══
  испорченный unit: /tmp/limits/broken.service:3: Failed to parse protect system value, ignoring: nonsense
  ✓ проверяющий находит заведомую ошибку — значит, «замечаний нет» что-то значит
  код возврата на испорченном файле: 0 (поэтому признаком служит вывод, а не код)

═══ Требование 5: расходы производительности ═══
    место                      механизм                               где заметно
    ────────────────────────────────────────────────────────────────────────────────────────────────
    Вычисления                 обычный процесс ядра                   нигде
    Память                     те же страницы                         нигде
    Системные вызовы           фильтр seccomp на каждый вызов         интенсивные syscall
    Чтение файлов              поиск по стеку слоёв OverlayFS         много мелких файлов
    Запись в файлы образа      copy-up копирует файл целиком          запись в большие файлы
    Сеть                       veth, bridge, NAT на каждый пакет      высокий pps

    мест без расходов: 2 из 6

    способ снять               что снимает                что теряется
    ────────────────────────────────────────────────────────────────────────────────────────────
    seccomp=unconfined         Системные вызовы           существенную часть защиты
    bind mount                 Чтение файлов              независимость от каталогов хоста
    том                        Запись в файлы образа      эфемерность
    --network host             Сеть                       сетевую изоляцию целиком

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

  мест: 6, из них без расходов: 2
  ✓ названы и места расходов, и места, где их нет

═══ Требование 6: три задачи ═══
    ── Скрипт ротации логов на одной машине
       признак: упаковка не нужна
       − зависимости есть в дистрибутиве: упаковка не нужна
       − одна машина: одинаковость нечему обеспечивать
       − интенсивный ввод-вывод: расходы на OverlayFS и сети
       − некому поддерживать инфраструктуру сборки
       ВЫВОД: systemd-сервис проще  (unit: logrotate-helper.service)

    ── Кодировщик видео с аппаратным ускорением
       признак: упаковка нужна
       + зависимости не ставятся из репозитория дистрибутива
       − одна машина: одинаковость нечему обеспечивать
       − интенсивный ввод-вывод: расходы на OverlayFS и сети
       − работа с оборудованием: образ привяжется к хосту
       ВЫВОД: systemd-сервис проще  (unit: video-encoder.service)

    ── API на Python с зависимостями из PyPI, шесть сервисов, четыре машины
       признак: упаковка нужна
       + зависимости не ставятся из репозитория дистрибутива
       + машин: 4 — одинаковость окружения важна
       + сервисов: 6 — единообразие доставки
       ВЫВОД: Docker оправдан  (unit: api-service.service)

    различных выводов: 2

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

═══ Требование 7: что НЕ проверялось ═══
    проверка                                 причина
    ────────────────────────────────────────────────────────────────────────────────────
    любые измерения расходов                 Docker на машине курса не установлен
    фактический запуск unit-файлов           нет сессионной шины и прав на установку
    действие ProtectSystem и seccomp         требует запуска сервиса
    поведение при passthrough устройства     требует оборудования и драйвера

    не выполнялось: 4

    ВЫПОЛНЕНО по-настоящему: версия systemd, состав контроллеров
    cgroup v2, синтаксическая проверка трёх unit-файлов и проверка
    самого проверяющего на заведомо испорченном файле.
  ✓ разделено выполненное и невыполненное; числа не выдуманы

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