18.1. Какие задачи решают Docker и Kubernetes

Императивно (Docker)               Декларативно (Kubernetes)
──────────────────────             ─────────────────────────
docker run -d --name web ...       apiVersion: apps/v1
                                   kind: Deployment
выполняется один раз               spec:
                                     replicas: 3
если упадёт — останется лежать
                                   система непрерывно приводит
                                   фактическое состояние
                                   к описанному

        ┌─────────────────────────────────┐
        │        стандарты OCI            │
        ├─────────────────────────────────┤
        │ Image Specification             │  формат образа
        │ Runtime Specification           │  bundle и config.json
        │ Distribution Specification      │  протокол registry
        └─────────────────────────────────┘
              ▲                    ▲
              │                    │
        docker build          Kubernetes
        docker push           kubelet → CRI → containerd → runc

kubelet ──CRI──► среда выполнения ──► containerd/runc ──► процесс

До 1.24:  kubelet → dockershim → Docker Engine → containerd → runc
После:    kubelet → CRI ────────────────────────► containerd → runc

crictl ps
crictl images
crictl logs <id>

mkdir -p /tmp/k8s && cd /tmp/k8s
mkdir -p src

cat > src/app.py <<'PY'
"""Приложение, пригодное и для Docker, и для Kubernetes."""
from __future__ import annotations

import http.server
import json
import os
import signal
import sys
import threading

PORT = int(os.environ.get("PORT", "8000"))
_ready = threading.Event()
_stop = threading.Event()


class Handler(http.server.BaseHTTPRequestHandler):
    def do_GET(self) -> None:
        if self.path == "/healthz":
            code, body = 200, {"состояние": "жив"}
        elif self.path == "/readyz":
            ok = _ready.is_set()
            code = 200 if ok else 503
            body = {"состояние": "готов" if ok else "не готов"}
        else:
            code, body = 200, {"сервис": "работает", "uid": os.getuid()}
        payload = json.dumps(body, ensure_ascii=False).encode()
        self.send_response(code)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(payload)))
        self.end_headers()
        self.wfile.write(payload)

    def log_message(self, *args: object) -> None:
        pass


def _on_term(signum: int, _frame: object) -> None:
    print(f"получен сигнал {signum}: закрываем готовность, затем завершаемся",
          flush=True)
    _ready.clear()
    _stop.set()


if __name__ == "__main__":
    signal.signal(signal.SIGTERM, _on_term)
    signal.signal(signal.SIGINT, _on_term)
    server = http.server.ThreadingHTTPServer(("0.0.0.0", PORT), Handler)
    threading.Thread(target=server.serve_forever, daemon=True).start()
    _ready.set()
    print(f"готов на порту {PORT}", flush=True)
    _stop.wait()
    server.shutdown()
    sys.exit(0)
PY

cat > Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim AS production
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PORT=8000
WORKDIR /app
COPY src/ ./src/
RUN useradd --create-home --uid 10001 app && chown -R app:app /app
USER app
EXPOSE 8000
HEALTHCHECK --interval=5s --timeout=3s --retries=3 --start-period=3s \
    CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/healthz')"]
ENTRYPOINT ["python", "-m", "src.app"]
EOF

echo "═══ собираем образ ═══"
docker build -q -t k8s-ready:1 . > /dev/null
echo "  собран"

echo "═══ формат образа ═══"
docker inspect k8s-ready:1 --format '{{.Os}}/{{.Architecture}}' | sed 's/^/  платформа: /'
docker save k8s-ready:1 -o img.tar 2>/dev/null
mkdir -p unpacked && tar -xf img.tar -C unpacked 2>/dev/null
python3 - <<'PY'
import json
from pathlib import Path

root = Path("unpacked")
index = root / "index.json"
if index.exists():
    data = json.loads(index.read_text())
    print(f"  index.json: schemaVersion={data.get('schemaVersion')}")
    for m in data.get("manifests", [])[:2]:
        print(f"    mediaType: {m.get('mediaType')}")
    print("  формат OCI Image Layout")
else:
    manifest = root / "manifest.json"
    if manifest.exists():
        print("  формат Docker Image (совместим с OCI)")
    print("  index.json отсутствует — классический формат save")

blobs = list((root / "blobs").rglob("*")) if (root / "blobs").exists() else []
print(f"  blob-файлов: {len([b for b in blobs if b.is_file()])}")
PY
rm -rf unpacked img.tar

echo "═══ что это значит ═══"
cat <<'TXT'
  Образ описан стандартом OCI Image Specification.
  Kubernetes скачивает его по Distribution Specification —
  тому же протоколу, что docker pull.

  Затем разворачивает слои и формирует bundle
  по Runtime Specification, который исполняет runc.

  Ни на одном шаге Docker как программа не участвует.
  Отсюда: образы переносятся БЕЗ ИЗМЕНЕНИЙ.
TXT

═══ собираем образ ═══
  собран
═══ формат образа ═══
  платформа: linux/amd64
  index.json: schemaVersion=2
    mediaType: application/vnd.oci.image.manifest.v1+json
  формат OCI Image Layout
  blob-файлов: 5
═══ что это значит ═══
  Образ описан стандартом OCI Image Specification.
  Kubernetes скачивает его по Distribution Specification —
  тому же протоколу, что docker pull.
  ...

cd /tmp/k8s
cat > dockershim.py <<'PY'
"""Что изменилось при удалении dockershim в Kubernetes 1.24."""
from __future__ import annotations

CHAINS = {
    "До 1.24 (с dockershim)": [
        "kubelet", "dockershim", "Docker Engine", "containerd", "shim", "runc",
    ],
    "После 1.24 (containerd напрямую)": [
        "kubelet", "CRI", "containerd", "shim", "runc",
    ],
    "После 1.24 (CRI-O)": [
        "kubelet", "CRI", "CRI-O", "runc",
    ],
    "У вас на машине (Docker)": [
        "docker CLI", "dockerd", "containerd", "shim", "runc",
    ],
}

CHANGED = [
    ("kubelet общается с Docker Engine", "больше нет"),
    ("Docker нужен на узлах кластера", "не нужен"),
    ("docker ps показывает pod'ы", "не показывает"),
    ("Диагностика на узле", "через crictl вместо docker"),
]

UNCHANGED = [
    ("Формат образов", "OCI Image Specification — не менялся"),
    ("docker build", "работает; образ пригоден для Kubernetes"),
    ("docker push и registry", "Distribution Specification — тот же"),
    ("Dockerfile", "не изменился ни на строку"),
    ("Слои, кэш, multi-stage", "механизм тот же"),
    ("Теги и digest", "те же"),
    ("runc", "тот же исполнитель"),
]


def main() -> None:
    print("  Цепочки выполнения:\n")
    for name, chain in CHAINS.items():
        print(f"    {name}")
        print(f"      {' → '.join(chain)}")
        print(f"      звеньев: {len(chain)}")
        print()

    before = len(CHAINS["До 1.24 (с dockershim)"])
    after = len(CHAINS["После 1.24 (containerd напрямую)"])
    print(f"  Убрано звеньев: {before - after}")
    print()

    print(f"  {'что ИЗМЕНИЛОСЬ':<42} стало")
    print("  " + "─" * 78)
    for what, now in CHANGED:
        print(f"  {what:<42} {now}")

    print()
    print(f"  {'что НЕ изменилось':<42} почему")
    print("  " + "─" * 78)
    for what, why in UNCHANGED:
        print(f"  {what:<42} {why}")

    print()
    print("  Формулировка «Kubernetes отказался от Docker» породила")
    print("  недоразумение: многие решили, что образы docker build")
    print("  перестанут работать. Они работают — убран слой")
    print("  совместимости внутри kubelet, а не поддержка формата.")


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

echo "═══ что убрал dockershim ═══"
python3 dockershim.py

═══ что убрал dockershim ═══
  Цепочки выполнения:

    До 1.24 (с dockershim)
      kubelet → dockershim → Docker Engine → containerd → shim → runc
      звеньев: 6

    После 1.24 (containerd напрямую)
      kubelet → CRI → containerd → shim → runc
      звеньев: 5

    После 1.24 (CRI-O)
      kubelet → CRI → CRI-O → runc
      звеньев: 4

    У вас на машине (Docker)
      docker CLI → dockerd → containerd → shim → runc
      звеньев: 5

  Убрано звеньев: 1

  что ИЗМЕНИЛОСЬ                             стало
  ──────────────────────────────────────────────────────────────────────────────
  kubelet общается с Docker Engine           больше нет
  Docker нужен на узлах кластера             не нужен
  docker ps показывает pod'ы                 не показывает
  Диагностика на узле                        через crictl вместо docker

  что НЕ изменилось                          почему
  ──────────────────────────────────────────────────────────────────────────────
  Формат образов                             OCI Image Specification — не менялся
  docker build                               работает; образ пригоден для Kubernetes
  docker push и registry                     Distribution Specification — тот же
  Dockerfile                                 не изменился ни на строку
  Слои, кэш, multi-stage                     механизм тот же
  Теги и digest                              те же
  runc                                       тот же исполнитель

  Формулировка «Kubernetes отказался от Docker» породила
  недоразумение: многие решили, что образы docker build
  перестанут работать. Они работают — убран слой
  совместимости внутри kubelet, а не поддержка формата.

cd /tmp/k8s
cat > models.py <<'PY'
"""Сравнение императивной и декларативной модели на сценариях отказа."""
from __future__ import annotations

SCENARIOS = [
    {
        "событие": "Процесс завершился с ошибкой",
        "docker": "restart policy перезапустит",
        "k8s": "перезапустит container в pod'е",
        "различие": "нет",
    },
    {
        "событие": "Container удалён командой",
        "docker": "останется удалённым",
        "k8s": "pod будет создан заново",
        "различие": "ЕСТЬ",
    },
    {
        "событие": "Узел выключился",
        "docker": "container не работает",
        "k8s": "pod'ы переедут на другой узел",
        "различие": "ЕСТЬ",
    },
    {
        "событие": "Нужно 3 экземпляра, работает 2",
        "docker": "не отслеживается",
        "k8s": "создаст третий",
        "различие": "ЕСТЬ",
    },
    {
        "событие": "Readiness-проба не проходит",
        "docker": "статус unhealthy, и всё",
        "k8s": "трафик перестаёт идти на этот pod",
        "различие": "ЕСТЬ",
    },
    {
        "событие": "Обновление версии образа",
        "docker": "остановить и запустить заново",
        "k8s": "постепенная замена с контролем готовности",
        "различие": "ЕСТЬ",
    },
    {
        "событие": "Приложение вышло за лимит памяти",
        "docker": "OOM kill, перезапуск по политике",
        "k8s": "OOM kill, перезапуск, учёт в событиях",
        "различие": "нет",
    },
]


def main() -> None:
    print(f"  {'событие':<38} {'Docker':<34} {'Kubernetes':<38}")
    print("  " + "─" * 112)
    differ = 0
    for s in SCENARIOS:
        if s["различие"] == "ЕСТЬ":
            differ += 1
        print(f"  {s['событие']:<38} {s['docker']:<34} {s['k8s']:<38}")

    print()
    print(f"  различаются: {differ} из {len(SCENARIOS)}")
    print()
    print("  Общее у совпадающих строк: они про ОДНУ машину и ОДИН container.")
    print("  Различаются те, где нужно ПОДДЕРЖИВАТЬ состояние:")
    print("  число экземпляров, размещение по узлам, направление трафика.")
    print()
    print("  Это и есть граница: Docker запускает, Kubernetes поддерживает.")
    print("  Второе требует первого и не отменяет его.")


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

echo "═══ где модели различаются ═══"
python3 models.py

═══ где модели различаются ═══
  событие                                Docker                             Kubernetes                            
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Процесс завершился с ошибкой           restart policy перезапустит        перезапустит container в pod'е        
  Container удалён командой              останется удалённым                pod будет создан заново               
  Узел выключился                        container не работает              pod'ы переедут на другой узел         
  Нужно 3 экземпляра, работает 2         не отслеживается                   создаст третий                        
  Readiness-проба не проходит            статус unhealthy, и всё            трафик перестаёт идти на этот pod     
  Обновление версии образа               остановить и запустить заново      постепенная замена с контролем готовности
  Приложение вышло за лимит памяти       OOM kill, перезапуск по политике   OOM kill, перезапуск, учёт в событиях 

  различаются: 5 из 7

  Общее у совпадающих строк: они про ОДНУ машину и ОДИН container.
  Различаются те, где нужно ПОДДЕРЖИВАТЬ состояние:
  число экземпляров, размещение по узлам, направление трафика.

  Это и есть граница: Docker запускает, Kubernetes поддерживает.
  Второе требует первого и не отменяет его.

cd /tmp/k8s
cat > skills.py <<'PY'
"""Какие навыки работы с Docker переносятся в Kubernetes."""
from __future__ import annotations

import json

SKILLS = [
    ("Dockerfile: инструкции, порядок, кэш", "полностью", "формат тот же"),
    ("Multi-stage сборка", "полностью", "механизм сборщика, не среды выполнения"),
    ("Размер образа, выбор базового", "полностью", "те же соображения"),
    ("USER, capabilities, read-only", "полностью", "другой синтаксис: securityContext"),
    ("Теги и digest, стратегия публикации", "полностью", "тот же registry"),
    ("Логи в stdout", "полностью", "kubectl logs читает так же"),
    ("Обработка SIGTERM", "полностью", "Kubernetes шлёт тот же сигнал"),
    ("Сканирование, SBOM, provenance", "полностью", "работа с образом"),
    ("Healthcheck", "понятийно", "в Kubernetes три пробы вместо одной"),
    ("Лимиты ресурсов", "понятийно", "добавляются requests для планирования"),
    ("Compose-файлы", "НЕ переносятся", "другая модель объектов"),
    ("docker run и его флаги", "НЕ переносятся", "заменяются описанием pod'а"),
    ("Сети Docker", "НЕ переносятся", "плоская сеть кластера, другая модель"),
    ("Volumes Docker", "частично", "понятие есть, устройство иное"),
]


def main() -> None:
    print(f"  {'навык':<40} {'переносится':<16} почему")
    print("  " + "─" * 96)
    counts = {"полностью": 0, "понятийно": 0, "частично": 0, "НЕ переносятся": 0}
    for name, degree, why in SKILLS:
        counts[degree] = counts.get(degree, 0) + 1
        print(f"  {name:<40} {degree:<16} {why}")

    total = len(SKILLS)
    carried = counts["полностью"] + counts["понятийно"]
    print()
    for degree, n in counts.items():
        print(f"  {degree:<16} {n:>2} из {total}")
    print()
    print(f"  переносится полностью или понятийно: {carried} из {total} "
          f"({carried / total * 100:.0f} %)")
    print()
    print("  Не переносится то, что описывает ЗАПУСК: compose-файлы,")
    print("  флаги docker run, модель сетей. Переносится то,")
    print("  что описывает АРТЕФАКТ и его поведение.")
    print()
    print(json.dumps({"всего": total, "переносится": carried},
                     ensure_ascii=False))


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

echo "═══ переносимость навыков ═══"
python3 skills.py

═══ переносимость навыков ═══
  навык                                    переносится      почему
  ────────────────────────────────────────────────────────────────────────────────────────────────
  Dockerfile: инструкции, порядок, кэш     полностью        формат тот же
  Multi-stage сборка                       полностью        механизм сборщика, не среды выполнения
  Размер образа, выбор базового            полностью        те же соображения
  USER, capabilities, read-only            полностью        другой синтаксис: securityContext
  Теги и digest, стратегия публикации      полностью        тот же registry
  Логи в stdout                            полностью        kubectl logs читает так же
  Обработка SIGTERM                        полностью        Kubernetes шлёт тот же сигнал
  Сканирование, SBOM, provenance           полностью        работа с образом
  Healthcheck                              понятийно        в Kubernetes три пробы вместо одной
  Лимиты ресурсов                          понятийно        добавляются requests для планирования
  Compose-файлы                            НЕ переносятся   другая модель объектов
  docker run и его флаги                   НЕ переносятся   заменяются описанием pod'а
  Сети Docker                              НЕ переносятся   плоская сеть кластера, другая модель
  Volumes Docker                           частично         понятие есть, устройство иное

  полностью         8 из 14
  понятийно         2 из 14
  частично          1 из 14
  НЕ переносятся    3 из 14

  переносится полностью или понятийно: 10 из 14 (71 %)

  Не переносится то, что описывает ЗАПУСК: compose-файлы,
  флаги docker run, модель сетей. Переносится то,
  что описывает АРТЕФАКТ и его поведение.

cd /tmp/k8s
cat > k8s-readiness.sh <<'SH'
#!/usr/bin/env bash
# Проверка образа на пригодность для Kubernetes.
#
# Все проверки выполняются средствами Docker: кластер не нужен.
set -uo pipefail

IMAGE="${1:?укажите образ}"
NAME="k8sready-$$"
issues=0
pass() { printf '  ✓ %s\n' "$1"; }
warn() { printf '  ⚠ %s\n' "$1"; issues=$((issues + 1)); }

cleanup() { docker rm -f "$NAME" > /dev/null 2>&1; }
trap cleanup EXIT INT TERM

printf '\n  Пригодность для Kubernetes: %s\n\n' "$IMAGE"

# 1. Формат образа
os_arch="$(docker inspect "$IMAGE" --format '{{.Os}}/{{.Architecture}}' 2>/dev/null)"
pass "платформа: $os_arch (OCI Image Specification)"

# 2. Пользователь: в Kubernetes задаётся securityContext, но образ должен позволять
user="$(docker inspect "$IMAGE" --format '{{.Config.User}}')"
case "$user" in
    ""|0|root) warn "USER не задан — потребуется runAsUser в securityContext" ;;
    *)         pass "USER: $user — совместимо с runAsNonRoot" ;;
esac

# 3. ENTRYPOINT в exec form: Kubernetes шлёт SIGTERM напрямую процессу
form="$(docker inspect "$IMAGE" --format '{{json .Config.Entrypoint}}' | python3 -c "
import json, sys
v = json.load(sys.stdin) or []
shells = {'/bin/sh', 'sh', '/bin/bash', 'bash'}
print('shell' if len(v) >= 2 and v[0] in shells and v[1] == '-c'
      else ('exec' if v else 'none'))
")"
[ "$form" = "shell" ] \
    && warn "ENTRYPOINT в shell form — SIGTERM не дойдёт при завершении pod'а" \
    || pass "ENTRYPOINT в $form form"

# 4. Логи в stdout
pass "логи: проверяются запуском ниже"

# 5. Эндпоинты проб
docker run -d --name "$NAME" -p 0:8000 "$IMAGE" > /dev/null 2>&1 || {
    warn "container не запустился"; printf '\n  замечаний: %s\n\n' "$issues"; exit 1; }
sleep 4

port="$(docker port "$NAME" 8000/tcp 2>/dev/null | head -1 | sed 's/.*://')"
if [ -n "$port" ]; then
    for path in /healthz /readyz; do
        code="$(curl -s -o /dev/null -w '%{http_code}' --max-time 3 \
            "http://127.0.0.1:$port$path" 2>/dev/null)"
        case "$code" in
            200) pass "эндпоинт $path отвечает 200 — годится для пробы" ;;
            "")  warn "эндпоинт $path недоступен" ;;
            *)   warn "эндпоинт $path вернул $code" ;;
        esac
    done
else
    warn "порт не опубликован"
fi

# 6. Логи попали в stdout
n_lines="$(docker logs "$NAME" 2>&1 | grep -c . || echo 0)"
[ "${n_lines:-0}" -gt 0 ] \
    && pass "логи идут в stdout: $n_lines строк" \
    || warn "логов в stdout нет — kubectl logs будет пуст"

# 7. Обработка SIGTERM
t0="$(python3 -c 'import time; print(time.monotonic())')"
docker stop -t 10 "$NAME" > /dev/null 2>&1
t1="$(python3 -c 'import time; print(time.monotonic())')"
secs="$(python3 -c "print(f'{$t1 - $t0:.1f}')")"
code="$(docker inspect "$NAME" --format '{{.State.ExitCode}}' 2>/dev/null)"
python3 -c "import sys; sys.exit(0 if $secs < 3 else 1)" \
    && pass "SIGTERM обработан за $secs с (код $code)" \
    || warn "SIGTERM не обработан: $secs с — pod будет убит по таймауту"

printf '\n  замечаний: %s\n' "$issues"
printf '  проверки выполнены средствами Docker; кластер не требовался\n\n'
[ "$issues" -gt 0 ] && exit 1
exit 0
SH
chmod +x k8s-readiness.sh

echo "═══ проверка пригодного образа ═══"
./k8s-readiness.sh k8s-ready:1 || true

echo "═══ проверка непригодного ═══"
cat > Dockerfile.bad <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
ENV PORT=8000
WORKDIR /app
COPY src/ ./src/
ENTRYPOINT python -m src.app
EOF
docker build -q -f Dockerfile.bad -t k8s-bad:1 . > /dev/null 2>&1
./k8s-readiness.sh k8s-bad:1 2>&1 | tail -8 || true

docker rmi -f k8s-ready:1 k8s-bad:1 > /dev/null 2>&1
cd /tmp && rm -rf /tmp/k8s

═══ проверка пригодного образа ═══

  Пригодность для Kubernetes: k8s-ready:1

  ✓ платформа: linux/amd64 (OCI Image Specification)
  ✓ USER: app — совместимо с runAsNonRoot
  ✓ ENTRYPOINT в exec form
  ✓ логи: проверяются запуском ниже
  ✓ эндпоинт /healthz отвечает 200 — годится для пробы
  ✓ эндпоинт /readyz отвечает 200 — годится для пробы
  ✓ логи идут в stdout: 1 строк
  ✓ SIGTERM обработан за 0.3 с (код 0)

  замечаний: 0
  проверки выполнены средствами Docker; кластер не требовался

═══ проверка непригодного ═══
  ⚠ USER не задан — потребуется runAsUser в securityContext
  ⚠ ENTRYPOINT в shell form — SIGTERM не дойдёт при завершении pod'а
  ✓ эндпоинт /healthz отвечает 200 — годится для пробы
  ✓ эндпоинт /readyz отвечает 200 — годится для пробы
  ✓ логи идут в stdout: 1 строк
  ⚠ SIGTERM не обработан: 10.2 с — pod будет убит по таймауту

  замечаний: 3

docker save ОБРАЗ | tar -xO index.json 2>/dev/null | python3 -m json.tool | head
docker inspect ОБРАЗ --format '{{.Os}}/{{.Architecture}} {{.Config.User}}'
docker inspect ОБРАЗ --format '{{json .Config.Entrypoint}}'
docker run -d --name probe -p 0:8000 ОБРАЗ && sleep 4 && time docker stop probe