18.3. От Compose к Kubernetes

depends_on:
  db:
    condition: service_healthy

networks:
  frontend:
  backend:
    internal: true

ports:
  - "8080:8000"

volumes:
  pgdata:

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:8000/health"]

1. Образы          закрепить по digest, проверить пригодность ([урок 18.1])
2. Конфигурация    environment → ConfigMap, secrets → Secret
3. Состояние       решить: StatefulSet, PVC или вынести из кластера
4. Пробы           разделить healthcheck на три эндпоинта
5. Ресурсы         добавить requests, не только limits
6. Сеть            Service для каждого; Ingress — только где нужен
7. Зависимости     убрать depends_on, добавить повторы в приложении
8. Изоляция        NetworkPolicy вместо отдельных сетей

mkdir -p /tmp/migrate && cd /tmp/migrate

cat > compose.yaml <<'EOF'
name: practical-stack

services:
  api:
    build: .
    image: ghcr.io/org/api:1.4.2
    command: ["python", "-m", "app.main"]
    ports:
      - "8080:8000"
    environment:
      LOG_LEVEL: info
      DATABASE_URL: postgresql://app@db:5432/appdb
      REDIS_URL: redis://cache:6379/0
    secrets:
      - db_password
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
    healthcheck:
      test: ["CMD", "python", "-c",
             "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health')"]
      interval: 10s
      timeout: 3s
      retries: 3
      start_period: 15s
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: "0.5"
          memory: 256M
    stop_grace_period: 45s
    user: "10001:10001"
    read_only: true
    tmpfs:
      - /tmp
    cap_drop: [ALL]
    networks: [frontend, backend]
    restart: unless-stopped

  worker:
    image: ghcr.io/org/api:1.4.2
    command: ["python", "-m", "app.worker"]
    environment:
      REDIS_URL: redis://cache:6379/0
    depends_on:
      cache:
        condition: service_started
    deploy:
      replicas: 3
    stop_grace_period: 60s
    networks: [backend]
    restart: unless-stopped

  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_DB: appdb
      POSTGRES_USER: app
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d appdb"]
      interval: 5s
      retries: 10
    networks: [backend]
    restart: unless-stopped

  cache:
    image: redis:8-alpine
    command: ["redis-server", "--appendonly", "yes"]
    volumes:
      - cachedata:/data
    networks: [backend]
    restart: unless-stopped

volumes:
  pgdata:
  cachedata:

secrets:
  db_password:
    file: ./secrets/db_password.txt

networks:
  frontend:
  backend:
    internal: true
EOF

echo "═══ состав стека ═══"
python3 - <<'PY'
import yaml
from pathlib import Path

c = yaml.safe_load(Path("compose.yaml").read_text())
services = c["services"]
print(f"  сервисов: {len(services)}")
print(f"  томов:    {len(c.get('volumes', {}))}")
print(f"  секретов: {len(c.get('secrets', {}))}")
print(f"  сетей:    {len(c.get('networks', {}))}")
print()
print(f"  {'сервис':<10} {'реплик':>7} {'состояние':<12} {'публикует':<12} зависит от")
print("  " + "─" * 70)
for name, svc in services.items():
    replicas = svc.get("deploy", {}).get("replicas", 1)
    stateful = "да" if svc.get("volumes") else "нет"
    ports = ", ".join(svc.get("ports", [])) or "—"
    deps = ", ".join(svc.get("depends_on", {})) if isinstance(svc.get("depends_on"), dict) \
        else ", ".join(svc.get("depends_on", [])) or "—"
    print(f"  {name:<10} {replicas:>7} {stateful:<12} {ports:<12} {deps or '—'}")
PY

═══ состав стека ═══
  сервисов: 4
  томов:    2
  секретов: 1
  сетей:    2

  сервис      реплик состояние    публикует    зависит от
  ──────────────────────────────────────────────────────────────────────
  api              2 нет          8080:8000    db, cache
  worker           3 нет          —            cache
  db               1 да           —            —
  cache            1 да           —            —

cd /tmp/migrate
cat > kompose-sim.py <<'PY'
"""Имитация автоматической конвертации Compose в манифесты.

Воспроизводит типичное поведение конвертеров, чтобы показать,
какие решения принимаются за вас — и почему они плохи.
"""
from __future__ import annotations

import json
from pathlib import Path

import yaml


def convert(compose: dict) -> list[dict[str, object]]:
    """Механическое преобразование: каждый сервис → Deployment + Service."""
    objects: list[dict[str, object]] = []
    for name, svc in compose["services"].items():
        deploy = svc.get("deploy", {})
        resources = deploy.get("resources", {})
        limits = resources.get("limits", {})

        container: dict[str, object] = {
            "name": name,
            "image": svc.get("image", "неизвестен"),
        }
        if "command" in svc:
            container["command"] = svc["command"]
        if "environment" in svc:
            env = svc["environment"]
            container["env"] = [{"name": k, "value": str(v)}
                                for k, v in (env.items() if isinstance(env, dict) else {})]
        if limits:
            container["resources"] = {
                "limits": {
                    k: v for k, v in (
                        ("cpu", limits.get("cpus")),
                        ("memory", limits.get("memory")),
                    ) if v
                }
            }
        if "healthcheck" in svc:
            container["livenessProbe"] = {"exec": {"command": ["см. healthcheck"]}}

        objects.append({
            "kind": "Deployment",
            "name": name,
            "replicas": deploy.get("replicas", 1),
            "containers": [container],
            "volumes": bool(svc.get("volumes")),
        })

        if svc.get("ports"):
            objects.append({
                "kind": "Service",
                "name": name,
                "type": "LoadBalancer",
                "ports": svc["ports"],
            })
    return objects


PROBLEMS = [
    ("healthcheck → одна проба", "потеряно разделение liveness и readiness",
     "отказ зависимости вызовет перезапуск"),
    ("все сервисы → Deployment", "db и cache имеют состояние",
     "при масштабировании два pod'а на один том — повреждение данных"),
    ("ports → LoadBalancer", "публикует наружу",
     "стоимость внешнего адреса; сервис может быть не нужен снаружи"),
    ("depends_on → игнорируется", "проблема не исчезла, а стала невидимой",
     "приложение упадёт при старте раньше базы"),
    ("нет requests", "задан только limits",
     "класс BestEffort: вытесняется первым"),
    ("networks → игнорируются", "internal: true потерян",
     "изоляция backend исчезла молча"),
    ("secrets → не перенесены", "нет объекта Secret",
     "пароль базы взять неоткуда"),
]


def main() -> None:
    compose = yaml.safe_load(Path("compose.yaml").read_text())
    objects = convert(compose)

    kinds: dict[str, int] = {}
    for o in objects:
        kinds[o["kind"]] = kinds.get(o["kind"], 0) + 1

    print("  Результат механической конвертации:")
    for kind, n in kinds.items():
        print(f"    {kind}: {n}")
    print(f"    всего объектов: {len(objects)}")
    print()
    print(f"  {'объект':<12} {'вид':<12} {'реплик':>7}  состояние")
    print("  " + "─" * 52)
    for o in objects:
        if o["kind"] == "Deployment":
            state = "ЕСТЬ" if o["volumes"] else "нет"
            print(f"  {o['name']:<12} {o['kind']:<12} {o['replicas']:>7}  {state}")

    print()
    print(f"  {'что сделал конвертер':<30} {'почему плохо':<44} последствие")
    print("  " + "─" * 116)
    for what, why, effect in PROBLEMS:
        print(f"  {what:<30} {why:<44} {effect}")

    print()
    print(f"  проблем: {len(PROBLEMS)}")
    print()
    print("  Главная беда не в отдельных ошибках, а в том, что результат")
    print("  ВЫГЛЯДИТ работающим. Он запускается, отвечает на запросы —")
    print("  и содержит решения, которые никто не принимал.")
    print()
    print("  Разумное применение конвертера: получить черновик,")
    print("  чтобы увидеть объём работы, и переписать вручную.")
    print()
    print(json.dumps({"объектов": len(objects), "проблем": len(PROBLEMS)},
                     ensure_ascii=False))


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

echo "═══ механическая конвертация ═══"
python3 kompose-sim.py

═══ механическая конвертация ═══
  Результат механической конвертации:
    Deployment: 4
    Service: 1
    всего объектов: 5

  объект       вид           реплик  состояние
  ────────────────────────────────────────────────────
  api          Deployment         2  нет
  worker       Deployment         3  нет
  db           Deployment         1  ЕСТЬ
  cache        Deployment         1  ЕСТЬ

  что сделал конвертер           почему плохо                                 последствие
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  healthcheck → одна проба       потеряно разделение liveness и readiness     отказ зависимости вызовет перезапуск
  все сервисы → Deployment       db и cache имеют состояние                   при масштабировании два pod'а на один том — повреждение данных
  ports → LoadBalancer           публикует наружу                             стоимость внешнего адреса; сервис может быть не нужен снаружи
  depends_on → игнорируется      проблема не исчезла, а стала невидимой       приложение упадёт при старте раньше базы
  нет requests                   задан только limits                          класс BestEffort: вытесняется первым
  networks → игнорируются        internal: true потерян                       изоляция backend исчезла молча
  secrets → не перенесены        нет объекта Secret                           пароль базы взять неоткуда

  проблем: 7

  Главная беда не в отдельных ошибках, а в том, что результат
  ВЫГЛЯДИТ работающим. Он запускается, отвечает на запросы —
  и содержит решения, которые никто не принимал.
  ...

cd /tmp/migrate
cat > decisions.py <<'PY'
"""Решения при ручном переносе каждого сервиса."""
from __future__ import annotations

import json
from pathlib import Path

import yaml

DECISIONS = {
    "api": {
        "объект": "Deployment",
        "почему": "без состояния, масштабируется свободно",
        "service": "ClusterIP + Ingress",
        "почему_service": "внешний доступ нужен, но через Ingress, не LoadBalancer",
        "пробы": "три: startupz, healthz, readyz",
        "требует_кода": "да: добавить /readyz и /startupz",
        "зависимости": "убрать depends_on; добавить повторы подключения",
    },
    "worker": {
        "объект": "Deployment",
        "почему": "без состояния, три реплики",
        "service": "нет",
        "почему_service": "не принимает входящих соединений",
        "пробы": "liveness по процессу; readiness не нужна без Service",
        "требует_кода": "нет",
        "зависимости": "убрать depends_on; BLMOVE переживает недоступность",
    },
    "db": {
        "объект": "StatefulSet или управляемая база вне кластера",
        "почему": "состояние; Deployment повредит данные при масштабировании",
        "service": "Headless (clusterIP: None)",
        "почему_service": "нужны устойчивые DNS-имена pod'ов",
        "пробы": "readiness через pg_isready; liveness осторожно",
        "требует_кода": "нет",
        "зависимости": "нет",
    },
    "cache": {
        "объект": "StatefulSet или Deployment без тома",
        "почему": "решить: нужна ли сохранность кэша",
        "service": "ClusterIP",
        "почему_service": "обращение по имени внутри кластера",
        "пробы": "readiness через redis-cli ping",
        "требует_кода": "нет",
        "зависимости": "нет",
    },
}


def main() -> None:
    compose = yaml.safe_load(Path("compose.yaml").read_text())

    print(f"  {'сервис':<10} {'объект':<44} почему")
    print("  " + "─" * 108)
    for name, d in DECISIONS.items():
        print(f"  {name:<10} {d['объект']:<44} {d['почему']}")

    print()
    print(f"  {'сервис':<10} {'Service':<26} почему")
    print("  " + "─" * 96)
    for name, d in DECISIONS.items():
        print(f"  {name:<10} {d['service']:<26} {d['почему_service']}")

    print()
    print(f"  {'сервис':<10} {'пробы':<38} требует изменений в коде")
    print("  " + "─" * 76)
    needs_code = 0
    for name, d in DECISIONS.items():
        if d["требует_кода"].startswith("да"):
            needs_code += 1
        print(f"  {name:<10} {d['пробы']:<38} {d['требует_кода']}")

    print()
    print(f"  {'сервис':<10} что делать с depends_on")
    print("  " + "─" * 76)
    for name, d in DECISIONS.items():
        print(f"  {name:<10} {d['зависимости']}")

    stateful = [n for n, s in compose["services"].items() if s.get("volumes")]
    print()
    print(f"  сервисов с состоянием: {len(stateful)} ({', '.join(stateful)})")
    print(f"  сервисов, требующих изменений в коде: {needs_code}")
    print()
    print("  Главный вывод: перенос выявляет приложения, не готовые")
    print("  к отказам зависимостей. depends_on скрывал эту неготовность;")
    print("  в Kubernetes её нечем скрыть.")
    print()
    print(json.dumps({"с_состоянием": len(stateful), "требуют_кода": needs_code},
                     ensure_ascii=False))


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

echo "═══ решения по сервисам ═══"
python3 decisions.py

═══ решения по сервисам ═══
  сервис     объект                                       почему
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────
  api        Deployment                                   без состояния, масштабируется свободно
  worker     Deployment                                   без состояния, три реплики
  db         StatefulSet или управляемая база вне кластера состояние; Deployment повредит данные при масштабировании
  cache      StatefulSet или Deployment без тома          решить: нужна ли сохранность кэша

  сервис     Service                    почему
  ────────────────────────────────────────────────────────────────────────────────────────────────
  api        ClusterIP + Ingress        внешний доступ нужен, но через Ingress, не LoadBalancer
  worker     нет                        не принимает входящих соединений
  db         Headless (clusterIP: None) нужны устойчивые DNS-имена pod'ов
  cache      ClusterIP                  обращение по имени внутри кластера

  сервис     пробы                                  требует изменений в коде
  ────────────────────────────────────────────────────────────────────────────
  api        три: startupz, healthz, readyz         да: добавить /readyz и /startupz
  worker     liveness по процессу; readiness не нужна без Service нет
  db         readiness через pg_isready; liveness осторожно нет
  cache      readiness через redis-cli ping         нет

  сервис     что делать с depends_on
  ────────────────────────────────────────────────────────────────────────────
  api        убрать depends_on; добавить повторы подключения
  worker     убрать depends_on; BLMOVE переживает недоступность
  db         нет
  cache      нет

  сервисов с состоянием: 2 (db, cache)
  сервисов, требующих изменений в коде: 1

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

cd /tmp/migrate
mkdir -p manifests

cat > manifests/api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  labels: {app: api}
spec:
  replicas: 2                       # было deploy.replicas
  selector:
    matchLabels: {app: api}
  strategy:
    type: RollingUpdate
    rollingUpdate: {maxSurge: 1, maxUnavailable: 0}
  template:
    metadata:
      labels: {app: api}
    spec:
      securityContext:              # было user: "10001:10001"
        runAsNonRoot: true
        runAsUser: 10001
        runAsGroup: 10001
        fsGroup: 10001
      terminationGracePeriodSeconds: 45   # было stop_grace_period
      containers:
        - name: api
          image: ghcr.io/org/api@sha256:8a3f2b1c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a
          command: ["python", "-m", "app.main"]
          ports:
            - {name: http, containerPort: 8000}   # было ports: "8080:8000"
          envFrom:
            - configMapRef: {name: api-config}    # было environment
          env:
            - name: DB_PASSWORD_FILE
              value: /run/secrets/db_password
          # healthcheck разделён на ТРИ пробы
          startupProbe:
            httpGet: {path: /startupz, port: http}
            periodSeconds: 2
            failureThreshold: 30
          livenessProbe:
            httpGet: {path: /healthz, port: http}
            periodSeconds: 10
            failureThreshold: 3
          readinessProbe:
            httpGet: {path: /readyz, port: http}
            periodSeconds: 3
            failureThreshold: 2
          resources:
            requests: {cpu: 100m, memory: 128Mi}  # ДОБАВЛЕНО: в Compose не было
            limits: {cpu: 500m, memory: 256Mi}    # было deploy.resources.limits
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true          # было read_only: true
            capabilities: {drop: ["ALL"]}         # было cap_drop: [ALL]
          volumeMounts:
            - {name: tmp, mountPath: /tmp}
            - {name: db-password, mountPath: /run/secrets, readOnly: true}
      volumes:
        - name: tmp
          emptyDir: {medium: Memory}              # было tmpfs: /tmp
        - name: db-password
          secret: {secretName: db-credentials}    # было secrets:
---
apiVersion: v1
kind: Service
metadata:
  name: api
spec:
  type: ClusterIP                   # НЕ LoadBalancer: внешний доступ через Ingress
  selector: {app: api}
  ports:
    - {name: http, port: 80, targetPort: http}
EOF

cat > manifests/db.yaml <<'EOF'
apiVersion: apps/v1
kind: StatefulSet                   # НЕ Deployment: у сервиса есть состояние
metadata:
  name: db
spec:
  serviceName: db                   # требуется StatefulSet'ом
  replicas: 1
  selector:
    matchLabels: {app: db}
  template:
    metadata:
      labels: {app: db}
    spec:
      terminationGracePeriodSeconds: 60
      containers:
        - name: postgres
          image: postgres:17-alpine@sha256:1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b
          ports:
            - {name: postgres, containerPort: 5432}
          env:
            - {name: POSTGRES_DB, value: appdb}
            - {name: POSTGRES_USER, value: app}
            - {name: POSTGRES_PASSWORD_FILE, value: /run/secrets/db_password}
            - {name: PGDATA, value: /var/lib/postgresql/data/pgdata}
          readinessProbe:
            exec:
              command: ["pg_isready", "-U", "app", "-d", "appdb"]
            periodSeconds: 5
            failureThreshold: 6
          # liveness ОСТОРОЖНО: перезапуск базы под нагрузкой опасен
          livenessProbe:
            exec:
              command: ["pg_isready", "-U", "app", "-d", "appdb"]
            periodSeconds: 30
            failureThreshold: 10
            timeoutSeconds: 10
          resources:
            requests: {cpu: 250m, memory: 512Mi}
            limits: {cpu: 1000m, memory: 1Gi}
          volumeMounts:
            - {name: pgdata, mountPath: /var/lib/postgresql/data}
            - {name: db-password, mountPath: /run/secrets, readOnly: true}
      volumes:
        - name: db-password
          secret: {secretName: db-credentials}
  volumeClaimTemplates:             # было volumes: pgdata
    - metadata: {name: pgdata}
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests: {storage: 10Gi}
---
apiVersion: v1
kind: Service
metadata:
  name: db
spec:
  clusterIP: None                   # headless: устойчивые имена pod'ов
  selector: {app: db}
  ports:
    - {name: postgres, port: 5432, targetPort: postgres}
EOF

cat > manifests/netpol.yaml <<'EOF'
# Замена networks.backend.internal: true
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-allow-from-app
spec:
  podSelector:
    matchLabels: {app: db}
  policyTypes: [Ingress]
  ingress:
    - from:
        - podSelector:
            matchLabels: {app: api}
        - podSelector:
            matchLabels: {app: worker}
      ports:
        - {protocol: TCP, port: 5432}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
spec:
  podSelector: {}
  policyTypes: [Ingress]
EOF

echo "═══ проверка манифестов ═══"
python3 - <<'PY'
import yaml
from pathlib import Path

total = 0
for path in sorted(Path("manifests").glob("*.yaml")):
    docs = [d for d in yaml.safe_load_all(path.read_text()) if d]
    total += len(docs)
    kinds = ", ".join(f"{d['kind']}/{d['metadata']['name']}" for d in docs)
    print(f"  {path.name:<14} {len(docs)} объектов: {kinds}")
print(f"\n  всего объектов: {total}")
PY

echo "═══ что изменилось по сравнению с Compose ═══"
python3 - <<'PY'
CHANGES = [
    ("ports: 8080:8000", "containerPort + Service ClusterIP",
     "внешний доступ — отдельное решение через Ingress"),
    ("healthcheck (одна)", "три пробы: startup, liveness, readiness",
     "потребовало добавить эндпоинты в приложение"),
    ("depends_on", "УБРАНО",
     "заменено повторами подключения в коде"),
    ("volumes: pgdata", "volumeClaimTemplates в StatefulSet",
     "каждый pod получает свой том"),
    ("db как обычный сервис", "StatefulSet + headless Service",
     "устойчивые имена, свой том у каждого pod'а"),
    ("deploy.resources.limits", "requests + limits",
     "ДОБАВЛЕНЫ requests: без них класс BestEffort"),
    ("networks.backend.internal", "NetworkPolicy",
     "изоляция описывается политикой, а не сетью"),
    ("secrets: db_password", "Secret + volumeMounts",
     "файл, а не переменная окружения"),
    ("tmpfs: /tmp", "emptyDir с medium: Memory", "прямое соответствие"),
    ("user, read_only, cap_drop", "securityContext", "прямое соответствие"),
    ("image по тегу 1.4.2", "image по digest",
     "закрепление для воспроизводимости"),
]
print(f"  {'было в Compose':<28} {'стало в Kubernetes':<38} комментарий")
print("  " + "─" * 112)
for old, new, note in CHANGES:
    print(f"  {old:<28} {new:<38} {note}")
print()
added = [c for c in CHANGES if "ДОБАВЛЕН" in c[1] or "ДОБАВЛЕН" in c[2]]
removed = [c for c in CHANGES if "УБРАНО" in c[1]]
print(f"  изменений: {len(CHANGES)}, из них добавлено нового: {len(added)}, "
      f"убрано: {len(removed)}")
PY

═══ проверка манифестов ═══
  api.yaml       2 объектов: Deployment/api, Service/api
  db.yaml        2 объектов: StatefulSet/db, Service/db
  netpol.yaml    2 объектов: NetworkPolicy/db-allow-from-app, NetworkPolicy/default-deny-ingress

  всего объектов: 6
═══ что изменилось по сравнению с Compose ═══
  было в Compose               стало в Kubernetes                     комментарий
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ports: 8080:8000             containerPort + Service ClusterIP      внешний доступ — отдельное решение через Ingress
  healthcheck (одна)           три пробы: startup, liveness, readiness потребовало добавить эндпоинты в приложение
  depends_on                   УБРАНО                                 заменено повторами подключения в коде
  volumes: pgdata              volumeClaimTemplates в StatefulSet     каждый pod получает свой том
  db как обычный сервис        StatefulSet + headless Service         устойчивые имена, свой том у каждого pod'а
  deploy.resources.limits      requests + limits                      ДОБАВЛЕНЫ requests: без них класс BestEffort
  networks.backend.internal    NetworkPolicy                          изоляция описывается политикой, а не сетью
  secrets: db_password         Secret + volumeMounts                  файл, а не переменная окружения
  tmpfs: /tmp                  emptyDir с medium: Memory              прямое соответствие
  user, read_only, cap_drop    securityContext                        прямое соответствие
  image по тегу 1.4.2          image по digest                        закрепление для воспроизводимости

  изменений: 11, из них добавлено нового: 1, убрано: 1

cd /tmp/migrate
cat > estimate.py <<'PY'
"""Оценка объёма работы по переносу до его начала."""
from __future__ import annotations

import json
from pathlib import Path

import yaml

# Стоимость в условных единицах: 1 ≈ полчаса работы
COSTS = {
    "прямой перенос сервиса": 1,
    "сервис с состоянием": 4,
    "разделение healthcheck на пробы": 2,
    "добавление эндпоинтов в код": 6,
    "замена depends_on повторами": 4,
    "NetworkPolicy вместо сети": 3,
    "Secret и ConfigMap": 1,
    "Ingress": 2,
    "подбор requests": 2,
}


def estimate(compose: dict) -> dict[str, object]:
    services = compose["services"]
    items: list[tuple[str, int, str]] = []

    for name, svc in services.items():
        if svc.get("volumes"):
            items.append((f"{name}: StatefulSet, PVC, headless Service",
                          COSTS["сервис с состоянием"], name))
        else:
            items.append((f"{name}: Deployment + Service",
                          COSTS["прямой перенос сервиса"], name))

        if "healthcheck" in svc:
            items.append((f"{name}: разделить healthcheck на пробы",
                          COSTS["разделение healthcheck на пробы"], name))
            items.append((f"{name}: добавить эндпоинты /readyz, /startupz",
                          COSTS["добавление эндпоинтов в код"], name))

        if svc.get("depends_on"):
            items.append((f"{name}: убрать depends_on, добавить повторы",
                          COSTS["замена depends_on повторами"], name))

        if svc.get("deploy", {}).get("resources"):
            items.append((f"{name}: подобрать requests",
                          COSTS["подбор requests"], name))

        if svc.get("ports"):
            items.append((f"{name}: Ingress для внешнего доступа",
                          COSTS["Ingress"], name))

    if compose.get("networks"):
        internal = [n for n, cfg in compose["networks"].items()
                    if isinstance(cfg, dict) and cfg.get("internal")]
        if internal:
            items.append((f"NetworkPolicy вместо сетей: {', '.join(internal)}",
                          COSTS["NetworkPolicy вместо сети"], "—"))

    if compose.get("secrets"):
        items.append(("Secret из файлов", COSTS["Secret и ConfigMap"], "—"))
    items.append(("ConfigMap из environment", COSTS["Secret и ConfigMap"], "—"))

    total = sum(cost for _, cost, _ in items)
    return {"пункты": items, "итого": total}


def main() -> None:
    compose = yaml.safe_load(Path("compose.yaml").read_text())
    est = estimate(compose)

    print(f"  {'работа':<52} {'стоимость':>10}")
    print("  " + "─" * 66)
    for name, cost, _ in est["пункты"]:
        print(f"  {name:<52} {cost:>10}")

    total = est["итого"]
    print("  " + "─" * 66)
    print(f"  {'ИТОГО':<52} {total:>10}")
    print()
    print(f"  в часах (1 единица ≈ 0.5 часа): около {total * 0.5:.0f}")
    print()

    code_work = sum(c for n, c, _ in est["пункты"] if "код" in n or "эндпоинт" in n
                    or "повторы" in n)
    print(f"  из них работа В КОДЕ, а не в манифестах: {code_work} "
          f"({code_work / total * 100:.0f} %)")
    print()
    print("  Это главный результат оценки: почти половина работы —")
    print("  изменения в приложении, а не написание YAML.")
    print()
    print("  Автоматическая конвертация даёт манифесты за минуту")
    print("  и не делает ничего из этой половины.")
    print()
    print(json.dumps({"итого": total, "в_коде": code_work}, ensure_ascii=False))


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

echo "═══ оценка объёма ═══"
python3 estimate.py

cd /tmp && rm -rf /tmp/migrate

═══ оценка объёма ═══
  работа                                               стоимость
  ──────────────────────────────────────────────────────────────────
  api: Deployment + Service                                     1
  api: разделить healthcheck на пробы                           2
  api: добавить эндпоинты /readyz, /startupz                    6
  api: убрать depends_on, добавить повторы                      4
  api: подобрать requests                                       2
  api: Ingress для внешнего доступа                             2
  worker: Deployment + Service                                  1
  worker: убрать depends_on, добавить повторы                   4
  db: StatefulSet, PVC, headless Service                        4
  db: разделить healthcheck на пробы                            2
  db: добавить эндпоинты /readyz, /startupz                     6
  cache: StatefulSet, PVC, headless Service                     4
  NetworkPolicy вместо сетей: backend                           3
  Secret из файлов                                              1
  ConfigMap из environment                                      1
  ──────────────────────────────────────────────────────────────────
  ИТОГО                                                        43
  в часах (1 единица ≈ 0.5 часа): около 22

  из них работа В КОДЕ, а не в манифестах: 20 (47 %)

  Это главный результат оценки: почти половина работы —
  изменения в приложении, а не написание YAML.

  Автоматическая конвертация даёт манифесты за минуту
  и не делает ничего из этой половины.

python3 -c "
import yaml
c = yaml.safe_load(open('compose.yaml'))
for n, s in c['services'].items():
    print(n, 'состояние:', bool(s.get('volumes')), 'depends_on:', list(s.get('depends_on') or {}))"