18.4. Когда нужна orchestration

mkdir -p /tmp/orch && cd /tmp/orch

cat > decide.py <<'PY'
"""Инструмент принятия решения об orchestration.

Устройство весов: отрицательные признаки по модулю сравнимы
с самыми большими положительными. Это сделано намеренно —
иначе проект, где эксплуатировать кластер некому, набрал бы
проходной балл на одних лишь ожиданиях роста.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

# (ключ, формулировка, вес, чем подтверждается)
QUESTIONS: list[tuple[str, str, int, str]] = [
    ("load", "Одна машина не справляется СЕГОДНЯ", 3,
     "метрики загрузки за последний месяц"),
    ("downtime", "Простой более 5 минут стоит существенных денег", 3,
     "оценка потерь, а не ощущение"),
    ("deploys", "Развёртывания чаще раза в день", 2,
     "история выкаток"),
    ("spikes", "Нагрузка меняется в разы в течение суток", 2,
     "график запросов"),
    ("teams", "Больше трёх команд на общей инфраструктуре", 2,
     "список команд"),
    ("machines", "Более трёх машин под ручным управлением", 2,
     "инвентарь"),
    ("regions", "Нужны несколько географических регионов", 2,
     "требование, а не желание"),
    ("expertise", "Есть человек с опытом эксплуатации кластера", 1,
     "конкретное имя"),
    ("managed_state", "Состояние вынесено в управляемые сервисы", 1,
     "список хранилищ"),
    ("restartable", "Приложения переживают перезапуск в любой момент", 1,
     "проверено, а не предполагается"),
    ("someday", "Главный довод: «понадобится масштабирование»", -2,
     "данных о росте нет"),
    ("everyone", "Единственный довод: так делают все", -3,
     "довод не о системе"),
    ("no_oncall", "Некому дежурить со знанием кластера", -3,
     "кластер станет одной точкой отказа"),
    ("tolerant", "Простой в час допустим", -2,
     "автоматическое восстановление не окупится"),
]

INTERMEDIATE = [
    ("Вторая машина с Compose вручную",
     "переживание отказа одной машины", "автоматики нет"),
    ("Балансировщик перед двумя машинами",
     "доступность при отказе", "состояние, выкатка"),
    ("Управляемая база вне кластера",
     "копии, обновления, отказоустойчивость хранилища", "стоимость сервиса"),
    ("Nomad",
     "оркестрация с меньшей сложностью", "меньше экосистема"),
    ("Управляемый Kubernetes",
     "control plane обслуживает провайдер", "знания всё равно нужны"),
]

VERDICTS = [
    (8, 2, "Kubernetes обоснован",
     "требования подтверждаются фактами, есть кому эксплуатировать"),
    (4, 1, "Промежуточный вариант; пересмотреть через полгода",
     "часть требований настоящая, полный кластер преждевременен"),
    (None, 0, "Compose достаточно",
     "перенос обойдётся дороже пользы"),
]


def evaluate(answers: dict[str, object]) -> dict[str, object]:
    plus: list[tuple[str, int, str]] = []
    minus: list[tuple[str, int, str]] = []
    total = 0
    for key, text, weight, evidence in QUESTIONS:
        if answers.get(key):
            total += weight
            (plus if weight > 0 else minus).append((text, weight, evidence))

    for threshold, code, verdict, why in VERDICTS:
        if threshold is None or total >= threshold:
            break

    raw_plus = sum(w for _, w, _ in plus)
    raw_minus = sum(w for _, w, _ in minus)

    return {
        "проект": answers.get("_name", "без имени"),
        "сумма": total,
        "плюсов": raw_plus,
        "минусов": raw_minus,
        "за": plus,
        "против": minus,
        "вердикт": verdict,
        "почему": why,
        "код": code,
        "перевес": bool(minus) and total < 4 <= raw_plus,
    }


def report(r: dict[str, object]) -> None:
    print(f"  проект: {r['проект']}")
    print()
    print(f"  {'признак':<50} {'вес':>5}  чем подтверждается")
    print("  " + "─" * 100)
    for text, weight, evidence in r["за"]:
        print(f"  {text:<50} {weight:>+5}  {evidence}")
    for text, weight, evidence in r["против"]:
        print(f"  {text:<50} {weight:>+5}  {evidence}")
    print("  " + "─" * 100)
    print(f"  {'плюсы':<50} {r['плюсов']:>+5}")
    print(f"  {'минусы':<50} {r['минусов']:>+5}")
    print(f"  {'СУММА':<50} {r['сумма']:>5}")
    print()
    print(f"  Вывод: {r['вердикт']}")
    print(f"  Почему: {r['почему']}")

    if r["перевес"]:
        print()
        print("  ВНИМАНИЕ: положительных признаков хватило бы на переход,")
        print("  но отрицательные их перевесили. Это и есть смысл чек-листа:")
        print("  требование может быть настоящим, а условий для перехода нет.")

    if r["код"] == 1:
        print()
        print(f"  {'промежуточный вариант':<38} {'решает':<46} не решает")
        print("  " + "─" * 106)
        for name, solves, misses in INTERMEDIATE:
            print(f"  {name:<38} {solves:<46} {misses}")


def main(paths: list[str]) -> int:
    results = []
    for i, path in enumerate(paths):
        if i:
            print()
        answers = json.loads(Path(path).read_text())
        r = evaluate(answers)
        report(r)
        results.append({"проект": r["проект"], "сумма": r["сумма"],
                        "вердикт": r["вердикт"], "код": r["код"],
                        "перевес": r["перевес"]})
    print()
    print(json.dumps(results, ensure_ascii=False))
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:] or ["project.json"]))
PY

cat > cost.py <<'PY'
"""Модель стоимости перехода на Kubernetes.

Числа — порядки величин, а не измерения. Ценность модели
в соотношении разовой и постоянной частей, а не в точности.
"""
from __future__ import annotations

import json

# (статья, разово ч, в месяц ч, доля, снимаемая управляемым кластером)
COSTS = [
    ("Обучение команды", 120, 8, 0.20),
    ("Перенос приложений", 60, 0, 0.00),
    ("Манифесты и шаблоны", 40, 4, 0.00),
    ("Ingress и сертификаты", 16, 2, 0.50),
    ("Мониторинг и логи", 40, 6, 0.30),
    ("Обновления кластера", 8, 6, 0.70),
    ("Резервное копирование etcd", 8, 3, 1.00),
    ("Отладка сверх обычной", 0, 12, 0.00),
    ("Дежурство со знанием кластера", 0, 10, 0.00),
]

HOURS_PER_MONTH = 160


def main() -> None:
    print(f"  {'статья':<32} {'разово':>8} {'в месяц':>9} {'снимает управляемый':>21}")
    print("  " + "─" * 74)
    once_total = monthly_total = managed_monthly = 0.0
    for name, once, per_month, saving in COSTS:
        once_total += once
        monthly_total += per_month
        managed_monthly += per_month * (1 - saving)
        share = f"{saving * 100:.0f} %" if saving else "—"
        print(f"  {name:<32} {once:>8} {per_month:>9} {share:>21}")
    print("  " + "─" * 74)
    print(f"  {'ИТОГО':<32} {once_total:>8.0f} {monthly_total:>9.0f}")
    print()

    year_own = once_total + monthly_total * 12
    year_managed = once_total + managed_monthly * 12
    saved = (1 - managed_monthly / monthly_total) * 100

    print(f"  {'вариант':<24} {'разово':>8} {'в месяц':>9} {'первый год':>12} "
          f"{'человеко-мес.':>15}")
    print("  " + "─" * 72)
    print(f"  {'свой кластер':<24} {once_total:>8.0f} {monthly_total:>9.0f} "
          f"{year_own:>12.0f} {year_own / HOURS_PER_MONTH:>15.1f}")
    print(f"  {'управляемый кластер':<24} {once_total:>8.0f} {managed_monthly:>9.0f} "
          f"{year_managed:>12.0f} {year_managed / HOURS_PER_MONTH:>15.1f}")
    print()
    print(f"  управляемый снимает {saved:.0f} % ежемесячной нагрузки")
    print()
    print("  Что он НЕ снимает: перенос приложений, манифесты, отладку,")
    print("  дежурство. Это большая часть постоянной стоимости.")
    print()

    print(f"  {'доля постоянной стоимости за год':<44} {'свой':>8} {'управляемый':>14}")
    print("  " + "─" * 68)
    print(f"  {'разовая часть':<44} "
          f"{once_total / year_own * 100:>7.0f} % {once_total / year_managed * 100:>13.0f} %")
    print(f"  {'постоянная часть':<44} "
          f"{monthly_total * 12 / year_own * 100:>7.0f} % "
          f"{managed_monthly * 12 / year_managed * 100:>13.0f} %")
    print()
    print("  Постоянная часть больше разовой уже в первый год.")
    print("  Довод «поставим заранее, чтобы не переносить потом» неверен:")
    print("  ежемесячная стоимость начисляется с первого дня, а разовая")
    print("  часть — приведение приложений в порядок — полезна и без кластера.")
    print()
    print(json.dumps({
        "разово_ч": once_total,
        "в_месяц_свой": monthly_total,
        "в_месяц_управляемый": round(managed_monthly, 1),
        "экономия_проц": round(saved),
        "год_свой": year_own,
        "год_управляемый": round(year_managed),
    }, ensure_ascii=False))


if __name__ == "__main__":
    main()
PY

# ── три проекта с разными исходами ───────────────────────────────────
cat > small.json <<'EOF'
{
  "_name": "Внутренний сервис, три разработчика",
  "deploys": true, "managed_state": true, "restartable": true,
  "someday": true, "everyone": true, "no_oncall": true, "tolerant": true
}
EOF

cat > growing.json <<'EOF'
{
  "_name": "Растущий продукт, четыре машины, есть дежурство",
  "downtime": true, "deploys": true, "machines": true,
  "expertise": true, "managed_state": true, "restartable": true
}
EOF

cat > platform.json <<'EOF'
{
  "_name": "Платформа, шесть команд, два региона",
  "load": true, "downtime": true, "deploys": true, "spikes": true,
  "teams": true, "machines": true, "regions": true,
  "expertise": true, "managed_state": true, "restartable": true
}
EOF

# ── подделка: «всё да», но эксплуатировать некому ────────────────────
cat > fake.json <<'EOF'
{
  "_name": "«Нам точно нужен Kubernetes» (проверка на подделке)",
  "spikes": true, "deploys": true, "regions": true,
  "restartable": true,
  "someday": true, "everyone": true, "no_oncall": true, "tolerant": true
}
EOF

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

printf '\n═══ Требование 1: веса чек-листа ═══\n'
python3 - <<'PY'
from decide import QUESTIONS

plus = [w for _, _, w, _ in QUESTIONS if w > 0]
minus = [w for _, _, w, _ in QUESTIONS if w < 0]
print(f"    вопросов: {len(QUESTIONS)} (положительных {len(plus)}, "
      f"отрицательных {len(minus)})")
print(f"    максимум положительных: {sum(plus):+}")
print(f"    максимум отрицательных: {sum(minus):+}")
print(f"    сильнейший положительный: {max(plus):+}")
print(f"    сильнейший отрицательный: {min(minus):+}")
print()
if abs(min(minus)) >= max(plus):
    print("    ✓ сильнейший отрицательный признак по модулю не слабее")
    print("      сильнейшего положительного — значит, способен перевесить")
else:
    print("    ✗ отрицательные признаки слишком слабы")
PY
python3 -c "
from decide import QUESTIONS
plus = [w for _, _, w, _ in QUESTIONS if w > 0]
minus = [w for _, _, w, _ in QUESTIONS if w < 0]
raise SystemExit(0 if abs(min(minus)) >= max(plus) else 1)" \
    && ok "отрицательные веса способны перевесить положительные" \
    || bad "отрицательные веса слишком слабы"

printf '\n═══ Требование 2: три вердикта ═══\n'
python3 - <<'PY'
from decide import VERDICTS
print(f"    {'порог':>7} {'код':>5}  вердикт")
print("    " + "─" * 62)
for threshold, code, verdict, _ in VERDICTS:
    t = "любая" if threshold is None else f"≥ {threshold}"
    print(f"    {t:>7} {code:>5}  {verdict}")
print()
print("    Разные коды возврата позволяют использовать инструмент")
print("    в сценарии: 0 — ничего не менять, 1 — рассмотреть промежуточное,")
print("    2 — планировать переход.")
PY
n_verdicts="$(python3 -c 'from decide import VERDICTS; print(len(VERDICTS))')"
codes="$(python3 -c 'from decide import VERDICTS; print(len({c for _, c, _, _ in VERDICTS}))')"
[ "$n_verdicts" = "3" ] && [ "$codes" = "3" ] \
    && ok "три вердикта с тремя различными кодами возврата" \
    || bad "вердиктов: $n_verdicts, кодов: $codes"

printf '\n═══ Требование 3: три проекта ═══\n'
python3 decide.py small.json growing.json platform.json > verdicts.log 2>&1
sed -n '1,/Почему/p' verdicts.log | sed 's/^/  /'
summary="$(tail -1 verdicts.log)"
python3 - <<'PY' < verdicts.log
import json, sys
lines = sys.stdin.read().splitlines()
results = json.loads(lines[-1])
print()
print(f"    {'проект':<48} {'сумма':>6} {'код':>5}  вердикт")
print("    " + "─" * 108)
for r in results:
    print(f"    {r['проект']:<48} {r['сумма']:>6} {r['код']:>5}  {r['вердикт']}")
codes = {r["код"] for r in results}
print()
print(f"    различных исходов: {len(codes)} из 3")
PY
n_codes="$(echo "$summary" | python3 -c "
import json, sys
print(len({r['код'] for r in json.load(sys.stdin)}))")"
[ "$n_codes" = "3" ] \
    && ok "три проекта дали три разных исхода" \
    || bad "различных исходов: $n_codes"

printf '\n═══ Требование 4: промежуточные варианты ═══\n'
sed -n '/промежуточный вариант/,/Управляемый Kubernetes/p' verdicts.log | sed 's/^/  /'
grep -q "Управляемый Kubernetes" verdicts.log \
    && ok "для промежуточного исхода выведены варианты между Compose и кластером" \
    || bad "варианты не выведены"

printf '\n═══ Требования 5 и 6: стоимость ═══\n'
python3 cost.py > cost.log 2>&1
cat cost.log | sed 's/^/  /'
c_summary="$(tail -1 cost.log)"
get() { echo "$c_summary" | python3 -c "import json,sys; print(json.load(sys.stdin)['$1'])"; }
once="$(get разово_ч)"; per_month="$(get в_месяц_свой)"
saving="$(get экономия_проц)"; year="$(get год_свой)"
printf '\n  разово: %s ч, в месяц: %s ч, за год: %s ч\n' "$once" "$per_month" "$year"
python3 -c "raise SystemExit(0 if ${per_month} * 12 > ${once} else 1)" \
    && ok "постоянная часть превышает разовую уже в первый год" \
    || bad "постоянная часть меньше разовой"
printf '  управляемый кластер снимает: %s %%\n' "$saving"
python3 -c "raise SystemExit(0 if 0 < ${saving} < 50 else 1)" \
    && ok "экономия существенна, но далека от половины — отладка и дежурство остаются" \
    || bad "оценка экономии: $saving %"

printf '\n═══ Требование 7: проверка на подделке ═══\n'
python3 decide.py fake.json > fake.log 2>&1
sed -n '1,/чек-листа/p' fake.log | sed 's/^/  /'
f_summary="$(tail -1 fake.log)"
f_code="$(echo "$f_summary" | python3 -c "import json,sys; print(json.load(sys.stdin)[0]['код'])")"
f_over="$(echo "$f_summary" | python3 -c "import json,sys; print(json.load(sys.stdin)[0]['перевес'])")"
printf '\n  код исхода: %s, сработал перевес: %s\n' "$f_code" "$f_over"
[ "$f_code" = "0" ] && [ "$f_over" = "True" ] \
    && ok "подделка отсеяна: положительных хватало, отрицательные перевесили" \
    || bad "код=$f_code перевес=$f_over"

printf '\n═══ Что НЕ проверялось ═══\n'
python3 - <<'PY'
NOT_RUN = [
    ("фактическая стоимость перехода", "зависит от проекта, команды, провайдера"),
    ("работа кластера", "kubectl и кластер недоступны"),
    ("веса чек-листа", "подобраны по опыту, а не измерены"),
    ("экономия управляемого кластера", "оценка долей, не замер"),
]
print(f"    {'проверка':<40} причина")
print("    " + "─" * 80)
for name, why in NOT_RUN:
    print(f"    {name:<40} {why}")
print(f"\n    не выполнялось: {len(NOT_RUN)}")
print()
print("    Проверено то, что проверяется на модели: устройство весов,")
print("    различимость исходов, поведение на подделке, соотношение")
print("    разовой и постоянной частей. Сами числа — порядки величин.")
print()
print("    Это существенная оговорка: инструмент помогает вести разговор")
print("    о фактах, но не заменяет измерений на конкретном проекте.")
PY
ok "невыполненное перечислено; числа названы моделью"

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

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

═══ Требование 1: веса чек-листа ═══
    вопросов: 14 (положительных 10, отрицательных 4)
    максимум положительных: +19
    максимум отрицательных: -10
    сильнейший положительный: +3
    сильнейший отрицательный: -3

    ✓ сильнейший отрицательный признак по модулю не слабее
      сильнейшего положительного — значит, способен перевесить
  ✓ отрицательные веса способны перевесить положительные

═══ Требование 2: три вердикта ═══
      порог   код  вердикт
    ──────────────────────────────────────────────────────────────
        ≥ 8     2  Kubernetes обоснован
        ≥ 4     1  Промежуточный вариант; пересмотреть через полгода
      любая     0  Compose достаточно

    Разные коды возврата позволяют использовать инструмент
    в сценарии: 0 — ничего не менять, 1 — рассмотреть промежуточное,
    2 — планировать переход.
  ✓ три вердикта с тремя различными кодами возврата

═══ Требование 3: три проекта ═══
  проект: Внутренний сервис, три разработчика

  признак                                              вес  чем подтверждается
  ────────────────────────────────────────────────────────────────────────────────────────────────────
  Развёртывания чаще раза в день                        +2  история выкаток
  Состояние вынесено в управляемые сервисы              +1  список хранилищ
  Приложения переживают перезапуск в любой момент       +1  проверено, а не предполагается
  Главный довод: «понадобится масштабирование»          -2  данных о росте нет
  Единственный довод: так делают все                    -3  довод не о системе
  Некому дежурить со знанием кластера                   -3  кластер станет одной точкой отказа
  Простой в час допустим                                -2  автоматическое восстановление не окупится
  ────────────────────────────────────────────────────────────────────────────────────────────────────
  плюсы                                                 +4
  минусы                                               -10
  СУММА                                                 -6

  Вывод: Compose достаточно
  Почему: перенос обойдётся дороже пользы

    проект                                            сумма   код  вердикт
    ────────────────────────────────────────────────────────────────────────────────────────────────────────────
    Внутренний сервис, три разработчика                  -6     0  Compose достаточно
    Растущий продукт, четыре машины, есть дежурство       7     1  Промежуточный вариант; пересмотреть через полгода
    Платформа, шесть команд, два региона                 19     2  Kubernetes обоснован

    различных исходов: 3 из 3
  ✓ три проекта дали три разных исхода

═══ Требование 4: промежуточные варианты ═══
  промежуточный вариант                  решает                                         не решает
  ──────────────────────────────────────────────────────────────────────────────────────────────────────────
  Вторая машина с Compose вручную        переживание отказа одной машины                автоматики нет
  Балансировщик перед двумя машинами     доступность при отказе                         состояние, выкатка
  Управляемая база вне кластера          копии, обновления, отказоустойчивость хранилища стоимость сервиса
  Nomad                                  оркестрация с меньшей сложностью               меньше экосистема
  Управляемый Kubernetes                 control plane обслуживает провайдер            знания всё равно нужны
  ✓ для промежуточного исхода выведены варианты между Compose и кластером

═══ Требования 5 и 6: стоимость ═══
  статья                             разово   в месяц   снимает управляемый
  ──────────────────────────────────────────────────────────────────────────
  Обучение команды                      120         8                  20 %
  Перенос приложений                     60         0                     —
  Манифесты и шаблоны                    40         4                     —
  Ingress и сертификаты                  16         2                  50 %
  Мониторинг и логи                      40         6                  30 %
  Обновления кластера                     8         6                  70 %
  Резервное копирование etcd              8         3                 100 %
  Отладка сверх обычной                   0        12                     —
  Дежурство со знанием кластера           0        10                     —
  ──────────────────────────────────────────────────────────────────────────
  ИТОГО                                 292        51

  вариант                    разово   в месяц   первый год   человеко-мес.
  ────────────────────────────────────────────────────────────────────────
  свой кластер                  292        51          904             5.7
  управляемый кластер           292        43          805             5.0

  управляемый снимает 16 % ежемесячной нагрузки

  Что он НЕ снимает: перенос приложений, манифесты, отладку,
  дежурство. Это большая часть постоянной стоимости.

  доля постоянной стоимости за год                        свой    управляемый
  ────────────────────────────────────────────────────────────────────
  разовая часть                                             32 %            36 %
  постоянная часть                                          68 %            64 %

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

  разово: 292.0 ч, в месяц: 51.0 ч, за год: 904.0 ч
  ✓ постоянная часть превышает разовую уже в первый год
  управляемый кластер снимает: 16 %
  ✓ экономия существенна, но далека от половины — отладка и дежурство остаются

═══ Требование 7: проверка на подделке ═══
  проект: «Нам точно нужен Kubernetes» (проверка на подделке)

  признак                                              вес  чем подтверждается
  ────────────────────────────────────────────────────────────────────────────────────────────────────
  Развёртывания чаще раза в день                        +2  история выкаток
  Нагрузка меняется в разы в течение суток              +2  график запросов
  Нужны несколько географических регионов               +2  требование, а не желание
  Приложения переживают перезапуск в любой момент       +1  проверено, а не предполагается
  Главный довод: «понадобится масштабирование»          -2  данных о росте нет
  Единственный довод: так делают все                    -3  довод не о системе
  Некому дежурить со знанием кластера                   -3  кластер станет одной точкой отказа
  Простой в час допустим                                -2  автоматическое восстановление не окупится
  ────────────────────────────────────────────────────────────────────────────────────────────────────
  плюсы                                                 +7
  минусы                                               -10
  СУММА                                                 -3

  Вывод: Compose достаточно
  Почему: перенос обойдётся дороже пользы

  ВНИМАНИЕ: положительных признаков хватило бы на переход,
  но отрицательные их перевесили. Это и есть смысл чек-листа:
  требование может быть настоящим, а условий для перехода нет.

  код исхода: 0, сработал перевес: True
  ✓ подделка отсеяна: положительных хватало, отрицательные перевесили

═══ Что НЕ проверялось ═══
    проверка                                 причина
    ────────────────────────────────────────────────────────────────────────────────
    фактическая стоимость перехода           зависит от проекта, команды, провайдера
    работа кластера                          kubectl и кластер недоступны
    веса чек-листа                           подобраны по опыту, а не измерены
    экономия управляемого кластера           оценка долей, не замер
  ✓ невыполненное перечислено; числа названы моделью

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