18.2. Объекты Kubernetes

Pod
├── общий сетевой namespace   ← все container'ы видят один localhost
├── общий IPC namespace
├── общие тома
└── container'ы:
    ├── приложение
    └── вспомогательный (по необходимости)

Deployment          описывает желаемое: образ, реплики, стратегия обновления
    │  создаёт и управляет
    ▼
ReplicaSet          поддерживает N одинаковых pod'ов
    │  создаёт
    ▼
Pod                 запускается на узле

Service                     стабильное имя и адрес
   │  выбирает по меткам
   ▼
pod-a (10.1.2.3)   pod-b (10.1.2.7)   pod-c (10.1.5.1)

База недоступна:
  readiness должна упасть   → трафик перестанет идти, pod останется жив
  liveness должна пройти    → перезапуск не восстановит базу

mkdir -p /tmp/k8sobj && cd /tmp/k8sobj

cat > deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  labels:
    app: api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: api
    spec:
      # Соответствует USER в Dockerfile ([урок 12.3])
      securityContext:
        runAsNonRoot: true
        runAsUser: 10001
        fsGroup: 10001
      # Время на обработку SIGTERM ([урок 11.3])
      terminationGracePeriodSeconds: 45
      containers:
        - name: api
          # Закрепление по digest ([урок 14.4])
          image: ghcr.io/org/api@sha256:8a3f2b1c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a
          ports:
            - name: http
              containerPort: 8000
          # Три пробы, каждая отвечает на свой вопрос
          startupProbe:
            httpGet:
              path: /startupz
              port: http
            periodSeconds: 2
            failureThreshold: 30      # до 60 секунд на инициализацию
          livenessProbe:
            httpGet:
              path: /healthz          # только сам процесс
              port: http
            periodSeconds: 10
            timeoutSeconds: 3
            failureThreshold: 3
          readinessProbe:
            httpGet:
              path: /readyz           # готовность обслуживать
              port: http
            periodSeconds: 3
            timeoutSeconds: 2
            failureThreshold: 2
          resources:
            requests:                 # влияет на ПЛАНИРОВАНИЕ
              cpu: 100m
              memory: 128Mi
            limits:                   # влияет на ПОВЕДЕНИЕ
              cpu: 500m
              memory: 256Mi
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities:
              drop: ["ALL"]
          env:
            - name: LOG_LEVEL
              valueFrom:
                configMapKeyRef:
                  name: api-config
                  key: log_level
          volumeMounts:
            - name: tmp
              mountPath: /tmp
            - name: secrets
              mountPath: /run/secrets
              readOnly: true
      volumes:
        - name: tmp
          emptyDir: {}
        - name: secrets
          secret:
            secretName: api-secrets
EOF

cat > service.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: api
spec:
  type: ClusterIP
  selector:
    app: api          # те же метки, что у pod'ов
  ports:
    - name: http
      port: 80        # адрес Service
      targetPort: http  # порт в container'е
EOF

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

for name in ("deployment.yaml", "service.yaml"):
    doc = yaml.safe_load(Path(name).read_text())
    print(f"  {name}: {doc['kind']} «{doc['metadata']['name']}» — валиден")
PY

echo "═══ структура Deployment ═══"
python3 - <<'PY'
import yaml
from pathlib import Path

d = yaml.safe_load(Path("deployment.yaml").read_text())
spec = d["spec"]
pod = spec["template"]["spec"]
container = pod["containers"][0]

print(f"  реплик: {spec['replicas']}")
print(f"  стратегия: {spec['strategy']['type']}, "
      f"maxSurge={spec['strategy']['rollingUpdate']['maxSurge']}, "
      f"maxUnavailable={spec['strategy']['rollingUpdate']['maxUnavailable']}")
print(f"  terminationGracePeriodSeconds: {pod['terminationGracePeriodSeconds']}")
print(f"  container'ов в pod'е: {len(pod['containers'])}")
print()
probes = [k for k in container if k.endswith("Probe")]
print(f"  проб: {len(probes)} — {', '.join(probes)}")
for p in probes:
    path = container[p]["httpGet"]["path"]
    period = container[p].get("periodSeconds")
    print(f"    {p:<16} {path:<12} каждые {period} с")
print()
res = container["resources"]
print(f"  requests: cpu={res['requests']['cpu']}, memory={res['requests']['memory']}")
print(f"  limits:   cpu={res['limits']['cpu']}, memory={res['limits']['memory']}")
PY

═══ проверка синтаксиса ═══
  deployment.yaml: Deployment «api» — валиден
  service.yaml: Service «api» — валиден
═══ структура Deployment ═══
  реплик: 3
  стратегия: RollingUpdate, maxSurge=1, maxUnavailable=0
  terminationGracePeriodSeconds: 45
  container'ов в pod'е: 1

  проб: 3 — startupProbe, livenessProbe, readinessProbe
    startupProbe     /startupz    каждые 2 с
    livenessProbe    /healthz     каждые 10 с
    readinessProbe   /readyz      каждые 3 с

  requests: cpu=100m, memory=128Mi
  limits:   cpu=500m, memory=256Mi

cd /tmp/k8sobj
cat > probes.py <<'PY'
"""Три пробы Kubernetes и последствия неверного выбора."""
from __future__ import annotations

PROBES = [
    ("startupProbe", "инициализация завершена?",
     "остальные пробы не выполняются, пока не пройдёт",
     "приложение с долгим стартом"),
    ("livenessProbe", "процесс жив?",
     "container ПЕРЕЗАПУСКАЕТСЯ",
     "зависание, взаимоблокировка, утечка дескрипторов"),
    ("readinessProbe", "готов принимать трафик?",
     "pod убирается из Service, но НЕ перезапускается",
     "прогрев, недоступная зависимость, перегрузка"),
]

SCENARIOS = [
    {
        "событие": "База данных временно недоступна",
        "readiness": "должна упасть — трафик уйдёт на другие pod'ы",
        "liveness": "должна пройти — перезапуск базу не вернёт",
        "если одна проба": "ПЕРЕЗАПУСК: бесполезный и вредный",
    },
    {
        "событие": "Приложение зависло, не отвечает",
        "readiness": "упадёт — трафик уйдёт",
        "liveness": "упадёт — перезапуск поможет",
        "если одна проба": "работает верно",
    },
    {
        "событие": "Прогрев кэша при старте, 40 секунд",
        "readiness": "не пройдёт — трафика не будет",
        "liveness": "должна пройти или ещё не выполняться",
        "если одна проба": "ПЕРЕЗАПУСК в цикле: старт не успевает",
    },
    {
        "событие": "Пик нагрузки, очередь переполнена",
        "readiness": "упадёт — нагрузка перераспределится",
        "liveness": "должна пройти",
        "если одна проба": "ПЕРЕЗАПУСК под нагрузкой: станет хуже",
    },
]


def main() -> None:
    print(f"  {'проба':<16} {'вопрос':<32} при отказе")
    print("  " + "─" * 92)
    for name, question, on_fail, when in PROBES:
        print(f"  {name:<16} {question:<32} {on_fail}")
    print()
    for name, _, _, when in PROBES:
        print(f"    {name:<16} нужна для: {when}")

    print()
    print(f"  {'событие':<38} {'readiness':<42} если ОДНА проба")
    print("  " + "─" * 106)
    broken = 0
    for s in SCENARIOS:
        if "ПЕРЕЗАПУСК" in s["если одна проба"]:
            broken += 1
        print(f"  {s['событие']:<38} {s['readiness']:<42} {s['если одна проба']}")

    print()
    print(f"  сценариев, где одна проба даёт неверное поведение: "
          f"{broken} из {len(SCENARIOS)}")
    print()
    print("  Правило: liveness проверяет ТОЛЬКО сам процесс;")
    print("  readiness — готовность обслуживать.")
    print()
    print("  Проверка зависимостей в liveness — самая частая ошибка:")
    print("  отказ базы вызывает перезапуск всех экземпляров приложения,")
    print("  и восстановление становится дольше.")


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

echo "═══ три пробы ═══"
python3 probes.py

═══ три пробы ═══
  проба            вопрос                           при отказе
  ────────────────────────────────────────────────────────────────────────────────────────────
  startupProbe     инициализация завершена?         остальные пробы не выполняются, пока не пройдёт
  livenessProbe    процесс жив?                     container ПЕРЕЗАПУСКАЕТСЯ
  readinessProbe   готов принимать трафик?          pod убирается из Service, но НЕ перезапускается

    startupProbe     нужна для: приложение с долгим стартом
    livenessProbe    нужна для: зависание, взаимоблокировка, утечка дескрипторов
    readinessProbe   нужна для: прогрев, недоступная зависимость, перегрузка

  событие                                readiness                                  если ОДНА проба
  ──────────────────────────────────────────────────────────────────────────────────────────────────────────
  База данных временно недоступна        должна упасть — трафик уйдёт на другие pod'ы  ПЕРЕЗАПУСК: бесполезный и вредный
  Приложение зависло, не отвечает        упадёт — трафик уйдёт                      работает верно
  Прогрев кэша при старте, 40 секунд     не пройдёт — трафика не будет              ПЕРЕЗАПУСК в цикле: старт не успевает
  Пик нагрузки, очередь переполнена      упадёт — нагрузка перераспределится        ПЕРЕЗАПУСК под нагрузкой: станет хуже

  сценариев, где одна проба даёт неверное поведение: 3 из 4

  Правило: liveness проверяет ТОЛЬКО сам процесс;
  readiness — готовность обслуживать.

  Проверка зависимостей в liveness — самая частая ошибка:
  отказ базы вызывает перезапуск всех экземпляров приложения,
  и восстановление становится дольше.

cd /tmp/k8sobj
cat > qos.py <<'PY'
"""Классы качества обслуживания и их последствия."""
from __future__ import annotations

CASES = [
    {"имя": "критичный сервис",
     "requests": {"cpu": "500m", "memory": "512Mi"},
     "limits": {"cpu": "500m", "memory": "512Mi"}},
    {"имя": "обычное приложение",
     "requests": {"cpu": "100m", "memory": "128Mi"},
     "limits": {"cpu": "500m", "memory": "256Mi"}},
    {"имя": "фоновая задача",
     "requests": {"cpu": "50m", "memory": "64Mi"},
     "limits": {}},
    {"имя": "без указания ресурсов",
     "requests": {}, "limits": {}},
]


def qos_class(requests: dict, limits: dict) -> str:
    if not requests and not limits:
        return "BestEffort"
    if requests and limits and requests == limits:
        return "Guaranteed"
    return "Burstable"


EVICTION_ORDER = {"BestEffort": 1, "Burstable": 2, "Guaranteed": 3}


def main() -> None:
    print(f"  {'pod':<26} {'requests':<24} {'limits':<24} класс")
    print("  " + "─" * 90)
    rows = []
    for c in CASES:
        cls = qos_class(c["requests"], c["limits"])
        rows.append((c["имя"], cls))
        req = ", ".join(f"{k}={v}" for k, v in c["requests"].items()) or "—"
        lim = ", ".join(f"{k}={v}" for k, v in c["limits"].items()) or "—"
        print(f"  {c['имя']:<26} {req:<24} {lim:<24} {cls}")

    print()
    print("  Порядок вытеснения при нехватке памяти на узле:")
    for name, cls in sorted(rows, key=lambda r: EVICTION_ORDER[r[1]]):
        print(f"    {EVICTION_ORDER[cls]}. {name:<26} ({cls})")

    print()
    print(f"  {'величина':<12} {'на что влияет':<34} аналог в Docker")
    print("  " + "─" * 76)
    print(f"  {'requests':<12} {'ПЛАНИРОВАНИЕ: выбор узла':<34} нет аналога")
    print(f"  {'limits':<12} {'поведение под нагрузкой':<34} --memory, --cpus")
    print()
    print("  requests не ограничивает — он резервирует. Планировщик")
    print("  размещает pod только на узле, где эта величина свободна.")
    print()
    print("  Практический вывод: pod без requests попадает в BestEffort")
    print("  и будет вытеснен ПЕРВЫМ — даже если он важнее соседей.")
    print()
    print("  Поведение при превышении limits — то же, что в Docker:")
    print("    память → OOM kill")
    print("    CPU    → throttling ([урок 13.3])")
    print("  Механизм тот же: cgroup v2.")


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

echo "═══ классы обслуживания ═══"
python3 qos.py

═══ классы обслуживания ═══
  pod                        requests                 limits                   класс
  ──────────────────────────────────────────────────────────────────────────────────────────
  критичный сервис           cpu=500m, memory=512Mi   cpu=500m, memory=512Mi   Guaranteed
  обычное приложение         cpu=100m, memory=128Mi   cpu=500m, memory=256Mi   Burstable
  фоновая задача             cpu=50m, memory=64Mi     —                        Burstable
  без указания ресурсов      —                        —                        BestEffort

  Порядок вытеснения при нехватке памяти на узле:
    1. без указания ресурсов      (BestEffort)
    2. обычное приложение         (Burstable)
    2. фоновая задача             (Burstable)
    3. критичный сервис           (Guaranteed)

  величина     на что влияет                      аналог в Docker
  ────────────────────────────────────────────────────────────────────────────
  requests     ПЛАНИРОВАНИЕ: выбор узла           нет аналога
  limits       поведение под нагрузкой            --memory, --cpus

  requests не ограничивает — он резервирует. Планировщик
  размещает pod только на узле, где эта величина свободна.

  Практический вывод: pod без requests попадает в BestEffort
  и будет вытеснен ПЕРВЫМ — даже если он важнее соседей.

  Поведение при превышении limits — то же, что в Docker:
    память → OOM kill
    CPU    → throttling ([урок 13.3])
  Механизм тот же: cgroup v2.

cd /tmp/k8sobj
cat > sidecar.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: app-with-sidecar
spec:
  # Init-container: выполняется ДО основных, до успешного завершения
  initContainers:
    - name: migrate
      image: ghcr.io/org/api@sha256:8a3f2b1c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a
      command: ["python", "-m", "src.migrate"]
      envFrom:
        - secretRef:
            name: db-credentials
  containers:
    # Основной container
    - name: api
      image: ghcr.io/org/api@sha256:8a3f2b1c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a
      ports:
        - containerPort: 8000
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/app
    # Sidecar: читает те же файлы, отправляет наружу
    - name: log-shipper
      image: ghcr.io/org/shipper@sha256:7b1e5c3a2d9f4e8b6a0c1d3f5a7b9c2e4d6f8a0b1c3e5d7f9a2b4c6e8d0f1a3b
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/app
          readOnly: true
  volumes:
    - name: shared-logs
      emptyDir: {}
EOF

echo "═══ структура pod'а ═══"
python3 - <<'PY'
import yaml
from pathlib import Path

pod = yaml.safe_load(Path("sidecar.yaml").read_text())
spec = pod["spec"]

inits = spec.get("initContainers", [])
mains = spec.get("containers", [])
print(f"  init-container'ов: {len(inits)}")
for c in inits:
    print(f"    {c['name']}: {' '.join(c.get('command', []))}")
print(f"  основных container'ов: {len(mains)}")
for c in mains:
    mounts = [m["mountPath"] for m in c.get("volumeMounts", [])]
    print(f"    {c['name']:<14} тома: {', '.join(mounts) or '—'}")
print(f"  томов: {len(spec.get('volumes', []))}")
PY

echo "═══ что общее, что своё ═══"
python3 - <<'PY'
SHARED = [
    ("сетевой namespace", "оба видят один localhost и один IP-адрес"),
    ("IPC namespace", "разделяемая память доступна обоим"),
    ("тома", "если смонтированы в оба container'а"),
    ("жизненный цикл", "планируются, запускаются и удаляются вместе"),
]
OWN = [
    ("файловая система", "у каждого своя из своего образа"),
    ("процессы", "по умолчанию свой PID namespace"),
    ("лимиты ресурсов", "задаются на каждый container отдельно"),
    ("пробы", "у каждого свои"),
]
print(f"  {'ОБЩЕЕ в pod е':<24} следствие")
print("  " + "─" * 76)
for name, why in SHARED:
    print(f"  {name:<24} {why}")
print()
print(f"  {'СВОЁ у каждого':<24} следствие")
print("  " + "─" * 76)
for name, why in OWN:
    print(f"  {name:<24} {why}")
print()
print("  Это ровно то, что даёт --network container: и --ipc container:")
print("  в Docker ([урок 17.3]): общая сеть, свои файловые системы.")
print()
print("  Технически namespaces держит pause-container — минимальный")
print("  процесс, к которому присоединяются остальные. Поэтому")
print("  перезапуск container'а не меняет IP-адрес pod'а.")
print()
print("  Правило: несколько container'ов оправданы, только если они")
print("  должны жить и умирать вместе и делить сеть.")
print("  Два независимых сервиса — это ДВА pod'а.")
PY

═══ структура pod'а ═══
  init-container'ов: 1
    migrate: python -m src.migrate
  основных container'ов: 2
    api            тома: /var/log/app
    log-shipper    тома: /var/log/app
  томов: 1
═══ что общее, что своё ═══
  ОБЩЕЕ в pod е            следствие
  ────────────────────────────────────────────────────────────────────────────
  сетевой namespace        оба видят один localhost и один IP-адрес
  IPC namespace            разделяемая память доступна обоим
  тома                     если смонтированы в оба container'а
  жизненный цикл           планируются, запускаются и удаляются вместе

  СВОЁ у каждого           следствие
  ────────────────────────────────────────────────────────────────────────────
  файловая система         у каждого своя из своего образа
  процессы                 по умолчанию свой PID namespace
  лимиты ресурсов          задаются на каждый container отдельно
  пробы                    у каждого свои

  Это ровно то, что даёт --network container: и --ipc container:
  в Docker ([урок 17.3]): общая сеть, свои файловые системы.
  ...

cd /tmp/k8sobj
cat > secret.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: api-secrets
type: Opaque
data:
  # base64, НЕ шифрование
  db_password: cGFzc3dvcmQtaXotcHJpbWVyYQ==
  api_token: dG9rZW4taXotcHJpbWVyYQ==
EOF

echo "═══ что внутри Secret ═══"
python3 - <<'PY'
import base64
import yaml
from pathlib import Path

s = yaml.safe_load(Path("secret.yaml").read_text())
print(f"  type: {s['type']}")
print()
print(f"  {'ключ':<16} {'в манифесте':<32} {'длина после base64 -d':<24}")
print("  " + "─" * 76)
for key, value in s["data"].items():
    decoded = base64.b64decode(value).decode("utf-8", "replace")
    print(f"  {key:<16} {value:<32} {len(decoded)} символов")
print()
print("  Значения НЕ выводятся: они восстанавливаются одной командой,")
print("  и печатать их в отчёте — создавать вторую утечку ([урок 12.6]).")
print()
print("  base64 — ОБРАТИМОЕ кодирование, а не шифрование.")
print("  Это ровно то же, что поле auth в ~/.docker/config.json")
print("  ([урок 14.2]).")
print()
print("  Шифрование хранилища кластера включается ОТДЕЛЬНО.")
print("  По умолчанию Secret лежит в хранилище как есть.")
PY

echo "═══ два способа подключения ═══"
python3 - <<'PY'
WAYS = [
    {"способ": "переменная окружения (envFrom, valueFrom)",
     "обновление без перезапуска": "НЕТ",
     "виден в describe pod": "ДА",
     "наследуется потомками": "ДА",
     "попадёт в отчёт об ошибке": "ДА"},
    {"способ": "файл через том (volumeMounts)",
     "обновление без перезапуска": "да",
     "виден в describe pod": "нет",
     "наследуется потомками": "нет",
     "попадёт в отчёт об ошибке": "нет"},
]
keys = ["обновление без перезапуска", "виден в describe pod",
        "наследуется потомками", "попадёт в отчёт об ошибке"]
print(f"  {'свойство':<32} {'переменная':<14} файл")
print("  " + "─" * 62)
for key in keys:
    print(f"  {key:<32} {WAYS[0][key]:<14} {WAYS[1][key]}")
print()
print("  Файл предпочтительнее по всем четырём признакам.")
print("  Те же доводы, что в уроке 12.6: переменная окружения")
print("  наследуется всеми потомками и попадает в отчёты об ошибках.")
print()
print("  Дополнительно: файл обновляется без перезапуска pod'а —")
print("  ротация секрета не требует перезапуска приложения,")
print("  если оно перечитывает файл.")
PY

═══ что внутри Secret ═══
  type: Opaque

  ключ             в манифесте                      длина после base64 -d   
  ────────────────────────────────────────────────────────────────────────────
  db_password      cGFzc3dvcmQtaXotcHJpbWVyYQ==     19 символов
  api_token        dG9rZW4taXotcHJpbWVyYQ==         16 символов

  Значения НЕ выводятся: они восстанавливаются одной командой,
  и печатать их в отчёте — создавать вторую утечку ([урок 12.6]).

  base64 — ОБРАТИМОЕ кодирование, а не шифрование.
  Это ровно то же, что поле auth в ~/.docker/config.json
  ([урок 14.2]).

  Шифрование хранилища кластера включается ОТДЕЛЬНО.
  По умолчанию Secret лежит в хранилище как есть.
═══ два способа подключения ═══
  свойство                         переменная     файл
  ──────────────────────────────────────────────────────────────
  обновление без перезапуска       НЕТ            да
  виден в describe pod             ДА             нет
  наследуется потомками            ДА             нет
  попадёт в отчёт об ошибке        ДА             нет

  Файл предпочтительнее по всем четырём признакам.
  ...

cd /tmp/k8sobj
cat > mapping.py <<'PY'
"""Соответствие объектов Kubernetes тому, что делалось в Docker."""
from __future__ import annotations

import json

MAPPING = [
    ("Pod", "docker run с --network container:",
     "группа container'ов с общими namespaces", "прямое"),
    ("ReplicaSet", "—", "поддержание N экземпляров", "нет аналога"),
    ("Deployment", "—", "обновление и откат", "нет аналога"),
    ("Service", "встроенный DNS сети Docker",
     "стабильное имя плюс балансировка", "частичное"),
    ("ConfigMap", "environment в Compose", "конфигурация", "прямое"),
    ("Secret", "secrets в Compose", "секреты как файлы", "прямое"),
    ("emptyDir", "анонимный том", "временные данные", "прямое"),
    ("emptyDir + Memory", "--tmpfs", "данные в памяти", "прямое"),
    ("hostPath", "bind mount", "каталог узла", "прямое"),
    ("PersistentVolumeClaim", "именованный том", "постоянное хранилище", "частичное"),
    ("livenessProbe", "HEALTHCHECK", "перезапуск при отказе", "частичное"),
    ("readinessProbe", "—", "управление трафиком", "нет аналога"),
    ("startupProbe", "start_period в healthcheck", "долгая инициализация", "частичное"),
    ("limits", "--memory, --cpus", "потолок ресурсов", "прямое"),
    ("requests", "—", "резервирование при планировании", "нет аналога"),
    ("securityContext", "--user, --cap-drop, --read-only", "ограничения", "прямое"),
    ("terminationGracePeriodSeconds", "stop_grace_period", "время на SIGTERM", "прямое"),
    ("initContainers", "depends_on: service_completed_successfully",
     "подготовка до старта", "частичное"),
    ("Namespace", "имя проекта Compose", "разделение имён", "частичное"),
]


def main() -> None:
    print(f"  {'объект Kubernetes':<32} {'что вы уже делали':<44} соответствие")
    print("  " + "─" * 96)
    counts: dict[str, int] = {}
    for obj, docker, _, degree in MAPPING:
        counts[degree] = counts.get(degree, 0) + 1
        print(f"  {obj:<32} {docker:<44} {degree}")

    total = len(MAPPING)
    known = counts.get("прямое", 0) + counts.get("частичное", 0)
    print()
    for degree, n in counts.items():
        print(f"  {degree:<14} {n:>2} из {total}")
    print()
    print(f"  знакомо полностью или частично: {known} из {total} "
          f"({known / total * 100:.0f} %)")
    print()
    print("  Нового по существу три вещи:")
    for obj, _, what, degree in MAPPING:
        if degree == "нет аналога":
            print(f"    {obj:<16} {what}")
    print()
    print("  Все три — про ПОДДЕРЖАНИЕ состояния: число экземпляров,")
    print("  обновление без перерыва, направление трафика.")
    print("  Это и есть граница между Docker и Kubernetes ([урок 18.1]).")
    print()
    print(json.dumps({"всего": total, "знакомо": known}, ensure_ascii=False))


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

echo "═══ что из этого вы уже знаете ═══"
python3 mapping.py

cd /tmp && rm -rf /tmp/k8sobj

═══ что из этого вы уже знаете ═══
  объект Kubernetes                что вы уже делали                            соответствие
  ────────────────────────────────────────────────────────────────────────────────────────────────
  Pod                              docker run с --network container:            прямое
  ReplicaSet                       —                                            нет аналога
  Deployment                       —                                            нет аналога
  Service                          встроенный DNS сети Docker                   частичное
  ConfigMap                        environment в Compose                        прямое
  Secret                           secrets в Compose                            прямое
  emptyDir                         анонимный том                                прямое
  emptyDir + Memory                --tmpfs                                      прямое
  hostPath                         bind mount                                   прямое
  PersistentVolumeClaim            именованный том                              частичное
  livenessProbe                    HEALTHCHECK                                  частичное
  readinessProbe                   —                                            нет аналога
  startupProbe                     start_period в healthcheck                   частичное
  limits                           --memory, --cpus                             прямое
  requests                         —                                            нет аналога
  securityContext                  --user, --cap-drop, --read-only              прямое
  terminationGracePeriodSeconds    stop_grace_period                            прямое
  initContainers                   depends_on: service_completed_successfully   частичное
  Namespace                        имя проекта Compose                          частичное

  прямое          8 из 19
  нет аналога      4 из 19
  частичное       7 из 19

  знакомо полностью или частично: 15 из 19 (79 %)

  Нового по существу три вещи:
    ReplicaSet       поддержание N экземпляров
    Deployment       обновление и откат
    readinessProbe   управление трафиком
    requests         резервирование при планировании

  Все три — про ПОДДЕРЖАНИЕ состояния: число экземпляров,
  обновление без перерыва, направление трафика.
  Это и есть граница между Docker и Kubernetes ([урок 18.1]).

python3 -c "import yaml; print(yaml.safe_load(open('deployment.yaml'))['kind'])"
python3 -c "
import yaml
d = yaml.safe_load(open('deployment.yaml'))
c = d['spec']['template']['spec']['containers'][0]
print([k for k in c if k.endswith('Probe')])
print(c['resources'])"