15.5. Валидация образа

docker inspect ОБРАЗ --format '{{.Config.User}}'

docker run --rm --entrypoint id ОБРАЗ -u     # фактический UID

ENTRYPOINT python app.py            # shell form
ENTRYPOINT ["python", "app.py"]     # exec form

docker inspect ОБРАЗ --format '{{json .Config.Entrypoint}}'

Entrypoint          Cmd              Что выполнится
["python"]          ["app.py"]       python app.py
["python","app.py"] []               python app.py
null                ["python","app.py"]  python app.py
["docker-entry.sh"] ["serve"]        docker-entry.sh serve

docker inspect ОБРАЗ --format '{{json .Config.Healthcheck}}'

docker run -d --name probe ОБРАЗ
# ждать перехода из starting в healthy
docker inspect probe --format '{{.State.Health.Status}}'

docker run --rm --entrypoint sh ОБРАЗ -c 'echo проверка'   # проверяет НИЧЕГО

docker run -d --name smoke -p 0:8000 ОБРАЗ
# дождаться готовности, обратиться, проверить ответ

schemaVersion: 2.0.0

commandTests:
  - name: "работает не от root"
    command: "id"
    args: ["-u"]
    excludedOutput: ["^0$"]

fileExistenceTests:
  - name: "код приложения на месте"
    path: /app/src/main.py
    shouldExist: true

  - name: "тестов в образе нет"
    path: /app/tests
    shouldExist: false

metadataTest:
  user: "10001"
  workdir: /app
  exposedPorts: ["8000"]

cid=$(docker create ОБРАЗ)
docker cp "$cid:/app/src/main.py" - > /dev/null && echo есть
docker rm "$cid"

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

cat > src/main.py <<'PY'
"""Сервис для проверки валидации образа."""
from __future__ import annotations

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

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


class Handler(http.server.BaseHTTPRequestHandler):
    def do_GET(self) -> None:
        body = json.dumps(
            {"статус": "ок", "uid": os.getuid(), "pid": os.getpid()},
            ensure_ascii=False,
        ).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

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


def on_term(signum: int, _frame: object) -> None:
    print(f"получен сигнал {signum}, завершаюсь", flush=True)
    _shutdown.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()
    print(f"сервис готов на порту {PORT}, uid={os.getuid()}", flush=True)
    _shutdown.wait()
    server.shutdown()
    print("завершение выполнено", flush=True)
    sys.exit(0)
PY

cat > healthcheck.py <<'PY'
"""Проверка здоровья: обращается на тот же порт, что слушает сервис."""
import os
import sys
import urllib.request

port = os.environ.get("PORT", "8000")
try:
    with urllib.request.urlopen(f"http://127.0.0.1:{port}/", timeout=3) as r:
        sys.exit(0 if r.status == 200 else 1)
except Exception as exc:
    print(f"проверка не прошла: {exc}")
    sys.exit(1)
PY

cat > Dockerfile.good <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PORT=8000
WORKDIR /app
COPY src/ ./src/
COPY healthcheck.py ./
RUN useradd --create-home --uid 10001 appuser && chown -R appuser:appuser /app
USER appuser
EXPOSE 8000
HEALTHCHECK --interval=3s --timeout=3s --retries=3 --start-period=3s \
    CMD ["python", "/app/healthcheck.py"]
ENTRYPOINT ["python", "/app/src/main.py"]
EOF

cat > Dockerfile.bad <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1 PORT=8000
# Ошибка 1: секрет в ENV
ENV API_TOKEN=sekret-token-value-12345
WORKDIR /app
COPY src/ ./src/
COPY healthcheck.py ./
# Ошибка 2: USER не задан — работа от root
# Ошибка 3: healthcheck обращается не на тот порт
HEALTHCHECK --interval=3s --timeout=3s --retries=3 \
    CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:9999/')"]
# Ошибка 4: shell form — SIGTERM не дойдёт до приложения
ENTRYPOINT python /app/src/main.py
EOF

echo "═══ сборка обоих образов ═══"
docker build -q -f Dockerfile.good -t val:good . > /dev/null && echo "  val:good собран"
docker build -q -f Dockerfile.bad -t val:bad . > /dev/null && echo "  val:bad собран"

═══ сборка обоих образов ═══
  val:good собран
  val:bad собран

cd /tmp/validate
show_static() {
    local image="$1"
    printf '  %s\n' "$image"
    docker inspect "$image" --format \
'    User:        {{if .Config.User}}{{.Config.User}}{{else}}(не задан → root){{end}}
    WorkingDir:  {{.Config.WorkingDir}}
    Entrypoint:  {{json .Config.Entrypoint}}
    Cmd:         {{json .Config.Cmd}}
    ExposedPorts:{{range $p, $_ := .Config.ExposedPorts}} {{$p}}{{end}}
    Healthcheck: {{if .Config.Healthcheck}}объявлен{{else}}НЕТ{{end}}'
    local env_secrets
    env_secrets="$(docker inspect "$image" \
        --format '{{range .Config.Env}}{{println .}}{{end}}' \
        | grep -cPi '^(.*_)?(token|secret|password|api_key)=.{6,}' || echo 0)"
    printf '    Секретов в ENV: %s\n' "$env_secrets"
}

echo "═══ конфигурация обоих образов ═══"
show_static val:good
echo
show_static val:bad

echo "═══ различение формы ENTRYPOINT ═══"
for img in val:good val:bad; do
    ep="$(docker inspect "$img" --format '{{json .Config.Entrypoint}}')"
    first="$(echo "$ep" | python3 -c "
import json, sys
v = json.load(sys.stdin) or []
print(v[0] if v else '')
")"
    second="$(echo "$ep" | python3 -c "
import json, sys
v = json.load(sys.stdin) or []
print(v[1] if len(v) > 1 else '')
")"
    if [ "$first" = "/bin/sh" ] && [ "$second" = "-c" ]; then
        printf '  %-10s shell form — SIGTERM НЕ дойдёт до приложения\n' "$img"
    else
        printf '  %-10s exec form  — сигналы доходят\n' "$img"
    fi
done

═══ конфигурация обоих образов ═══
  val:good
    User:        appuser
    WorkingDir:  /app
    Entrypoint:  ["python","/app/src/main.py"]
    Cmd:         null
    ExposedPorts: 8000/tcp
    Healthcheck: объявлен
    Секретов в ENV: 0

  val:bad
    User:        (не задан → root)
    WorkingDir:  /app
    Entrypoint:  ["/bin/sh","-c","python /app/src/main.py"]
    Cmd:         null
    ExposedPorts:
    Healthcheck: объявлен
    Секретов в ENV: 1
═══ различение формы ENTRYPOINT ═══
  val:good   exec form  — сигналы доходят
  val:bad    shell form — SIGTERM НЕ дойдёт до приложения

cd /tmp/validate
cat > Dockerfile.nouser <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
WORKDIR /app
COPY src/ ./src/
# USER задан, но пользователь НЕ СОЗДАН
USER appuser
ENTRYPOINT ["python", "/app/src/main.py"]
EOF

docker build -q -f Dockerfile.nouser -t val:nouser . > /dev/null 2>&1

echo "═══ статическая проверка ═══"
docker inspect val:nouser --format '  User в конфигурации: {{.Config.User}}'
echo "  выглядит правильно"

echo "═══ попытка запуска ═══"
docker run --rm val:nouser 2>&1 | head -2 | sed 's/^/  /'

echo "═══ вывод ═══"
cat <<'TXT'
  Статическая проверка «поле User не пусто» этот образ пропустит.
  Проблема обнаруживается только запуском.

  Отсюда правило: статическая проверка проверяет НАМЕРЕНИЕ,
  динамическая — РЕЗУЛЬТАТ. Нужны обе.

  Ещё два случая, которые пропускает статическая проверка:
    USER 0        поле не пусто, но это root
    USER root     то же самое
TXT

echo "═══ надёжная проверка UID ═══"
for img in val:good val:bad; do
    uid="$(docker run --rm --entrypoint id "$img" -u 2>/dev/null || echo "ошибка")"
    printf '  %-10s фактический UID: %s\n' "$img" "$uid"
done
docker rmi -f val:nouser > /dev/null 2>&1

═══ статическая проверка ═══
  User в конфигурации: appuser
  выглядит правильно
═══ попытка запуска ═══
  docker: Error response from daemon: unable to find user appuser:
  no matching entries in passwd file
═══ вывод ═══
  Статическая проверка «поле User не пусто» этот образ пропустит.
  Проблема обнаруживается только запуском.

  Отсюда правило: статическая проверка проверяет НАМЕРЕНИЕ,
  динамическая — РЕЗУЛЬТАТ. Нужны обе.

  Ещё два случая, которые пропускает статическая проверка:
    USER 0        поле не пусто, но это root
    USER root     то же самое
═══ надёжная проверка UID ═══
  val:good   фактический UID: 10001
  val:bad    фактический UID: 0

cd /tmp/validate
echo "═══ через docker create (процесс не запускается) ═══"
check_file() {
    local image="$1" path="$2"
    local cid
    cid="$(docker create "$image" 2>/dev/null)"
    if docker cp "$cid:$path" - > /dev/null 2>&1; then
        printf '  ✓ %-28s есть в %s\n' "$path" "$image"
    else
        printf '  ✗ %-28s отсутствует в %s\n' "$path" "$image"
    fi
    docker rm "$cid" > /dev/null 2>&1
}

check_file val:good /app/src/main.py
check_file val:good /app/healthcheck.py
check_file val:good /app/tests
check_file val:good /app/requirements-dev.txt

echo "═══ почему docker create, а не docker run ═══"
cat <<'TXT'
  docker create создаёт container, но НЕ запускает процесс.
  Копирование выполняет daemon — работает даже в distroless,
  где нет ни shell, ни ls ([урок 13.5]).

  Альтернатива с запуском требует shell в образе:
    docker run --rm --entrypoint sh ОБРАЗ -c 'test -e /app/src/main.py'

  Для distroless она не сработает.
TXT

═══ через docker create (процесс не запускается) ═══
  ✓ /app/src/main.py             есть в val:good
  ✓ /app/healthcheck.py          есть в val:good
  ✗ /app/tests                   отсутствует в val:good
  ✗ /app/requirements-dev.txt    отсутствует в val:good
═══ почему docker create, а не docker run ═══
  docker create создаёт container, но НЕ запускает процесс.
  Копирование выполняет daemon — работает даже в distroless,
  где нет ни shell, ни ls ([урок 13.5]).
  ...

cd /tmp/validate
check_health() {
    local image="$1" name="probe-$$"
    docker rm -f "$name" > /dev/null 2>&1
    docker run -d --name "$name" -p 0:8000 "$image" > /dev/null 2>&1
    local declared
    declared="$(docker inspect "$image" \
        --format '{{if .Config.Healthcheck}}да{{else}}нет{{end}}')"
    local status="—"
    for i in $(seq 1 20); do
        status="$(docker inspect "$name" \
            --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}нет проверки{{end}}' \
            2>/dev/null || echo "container исчез")"
        case "$status" in
            healthy|unhealthy) break ;;
        esac
        sleep 1
    done
    printf '  %-10s объявлен: %-4s фактический статус: %s\n' "$image" "$declared" "$status"
    if [ "$status" = "unhealthy" ]; then
        docker inspect "$name" --format '{{json .State.Health.Log}}' 2>/dev/null \
            | python3 -c "
import json, sys
log = json.load(sys.stdin) or []
if log:
    out = log[-1]['Output'].strip().replace(chr(10), ' ')[:64]
    print(f'    вывод проверки: код={log[-1][\"ExitCode\"]} {out}')
" 2>/dev/null
    fi
    docker rm -f "$name" > /dev/null 2>&1
}

echo "═══ объявленный и фактический статус ═══"
check_health val:good
check_health val:bad

echo "═══ вывод ═══"
cat <<'TXT'
  Оба образа объявляют healthcheck. Один переходит в healthy,
  второй — в unhealthy, потому что обращается на порт 9999,
  которого никто не слушает.

  Статическая проверка «healthcheck объявлен» пропускает
  вторую ошибку целиком.

  Причина отказа видна ТОЛЬКО в .State.Health.Log —
  в docker logs её нет ([урок 13.2]).
TXT

═══ объявленный и фактический статус ═══
  val:good   объявлен: да   фактический статус: healthy
  val:bad    объявлен: да   фактический статус: unhealthy
    вывод проверки: код=1 Traceback (most recent call last): ... ConnectionRefusedError
═══ вывод ═══
  Оба образа объявляют healthcheck. Один переходит в healthy,
  второй — в unhealthy, потому что обращается на порт 9999,
  которого никто не слушает.

  Статическая проверка «healthcheck объявлен» пропускает
  вторую ошибку целиком.

  Причина отказа видна ТОЛЬКО в .State.Health.Log —
  в docker logs её нет ([урок 13.2]).

cd /tmp/validate
cat > smoke.sh <<'SH'
#!/usr/bin/env bash
# Smoke test: запускает образ КАК ЕСТЬ, без подмены точки входа.
set -uo pipefail

IMAGE="${1:?укажите образ}"
NAME="smoke-$$"
failures=0

pass() { printf '  ✓ %s\n' "$1"; }
fail() { printf '  ✗ %s\n' "$1"; failures=$((failures + 1)); }

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

printf '\n  Smoke test: %s\n\n' "$IMAGE"

# ВАЖНО: без --entrypoint. Подмена отменила бы то, что проверяем.
if ! docker run -d --name "$NAME" -p 0:8000 "$IMAGE" > /dev/null 2>&1; then
    fail "container не запустился"
    printf '\n  провалов: %s\n\n' "$failures"
    exit 1
fi

# 1. Не упал сразу
sleep 5
status="$(docker inspect "$NAME" --format '{{.State.Status}}' 2>/dev/null)"
[ "$status" = "running" ] && pass "работает через 5 секунд" \
                          || fail "статус через 5 секунд: $status"

# 2. Отвечает на запрос
port="$(docker port "$NAME" 8000/tcp 2>/dev/null | head -1 | rsplit_port)" 2>/dev/null || \
port="$(docker port "$NAME" 8000/tcp 2>/dev/null | head -1 | sed 's/.*://')"
if [ -n "$port" ]; then
    body="$(curl -sf --max-time 5 "http://127.0.0.1:$port/" 2>/dev/null || echo "")"
    if echo "$body" | grep -q '"статус"'; then
        pass "отвечает на запрос: $(echo "$body" | cut -c1-46)"
    else
        fail "не отвечает на порту $port"
    fi
else
    fail "порт 8000 не опубликован"
fi

# 3. Работает не от root
uid="$(docker exec "$NAME" id -u 2>/dev/null || echo "?")"
[ "$uid" != "0" ] && [ "$uid" != "?" ] && pass "работает от UID $uid" \
                                       || fail "работает от root (UID $uid)"

# 4. Завершается по SIGTERM быстро — ловит shell form ENTRYPOINT
start="$(python3 -c 'import time; print(time.monotonic())')"
docker stop -t 10 "$NAME" > /dev/null 2>&1
end="$(python3 -c 'import time; print(time.monotonic())')"
elapsed="$(python3 -c "print(f'{$end - $start:.1f}')")"
code="$(docker inspect "$NAME" --format '{{.State.ExitCode}}' 2>/dev/null)"
quick="$(python3 -c "print(1 if $elapsed < 3 else 0)")"
if [ "$quick" = "1" ]; then
    pass "завершился по SIGTERM за $elapsed с (код $code)"
else
    fail "не завершился по SIGTERM: $elapsed с, код $code — вероятна shell form ENTRYPOINT"
fi

printf '\n  провалов: %s\n\n' "$failures"
[ "$failures" -gt 0 ] && exit 1
exit 0
SH
chmod +x smoke.sh

echo "═══ smoke test правильного образа ═══"
./smoke.sh val:good || true

echo "═══ smoke test сломанного образа ═══"
./smoke.sh val:bad || true

echo "═══ чего НЕ делать ═══"
cat <<'TXT'
  docker run --rm --entrypoint sh ОБРАЗ -c 'echo проверка'

  Такая «проверка» отменяет точку входа — то есть проверяет
  ровно то, что не нужно проверять. Она пройдёт и на образе
  со сломанным ENTRYPOINT.

  Smoke test запускает образ КАК ЕСТЬ.
TXT

═══ smoke test правильного образа ═══

  Smoke test: val:good

  ✓ работает через 5 секунд
  ✓ отвечает на запрос: {"статус": "ок", "uid": 10001, "pid": 1}
  ✓ работает от UID 10001
  ✓ завершился по SIGTERM за 0.3 с (код 0)

  провалов: 0

═══ smoke test сломанного образа ═══

  Smoke test: val:bad

  ✓ работает через 5 секунд
  ✗ порт 8000 не опубликован
  ✗ работает от root (UID 0)
  ✗ не завершился по SIGTERM: 10.2 с, код 137 — вероятна shell form ENTRYPOINT

  провалов: 3

═══ чего НЕ делать ═══
  docker run --rm --entrypoint sh ОБРАЗ -c 'echo проверка'

  Такая «проверка» отменяет точку входа — то есть проверяет
  ровно то, что не нужно проверять. Она пройдёт и на образе
  со сломанным ENTRYPOINT.

  Smoke test запускает образ КАК ЕСТЬ.

cd /tmp/validate
cat > structure-tests.yaml <<'EOF'
schemaVersion: 2.0.0

commandTests:
  - name: "работает не от root"
    command: "id"
    args: ["-u"]
    excludedOutput: ["^0$"]

  - name: "python доступен"
    command: "python"
    args: ["--version"]
    exitCode: 0

  - name: "тестовых зависимостей нет"
    command: "python"
    args: ["-c", "import pytest"]
    exitCode: 1

fileExistenceTests:
  - name: "код приложения на месте"
    path: /app/src/main.py
    shouldExist: true

  - name: "проверка здоровья на месте"
    path: /app/healthcheck.py
    shouldExist: true

  - name: "тестов в образе нет"
    path: /app/tests
    shouldExist: false

  - name: "файла зависимостей разработки нет"
    path: /app/requirements-dev.txt
    shouldExist: false

metadataTest:
  user: "appuser"
  workdir: "/app"
  exposedPorts: ["8000"]
  envVars:
    - key: PYTHONUNBUFFERED
      value: "1"
EOF

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

spec = yaml.safe_load(Path("structure-tests.yaml").read_text())
counts = {
    "commandTests": len(spec.get("commandTests", [])),
    "fileExistenceTests": len(spec.get("fileExistenceTests", [])),
    "metadataTest": 1 if spec.get("metadataTest") else 0,
}
print(f"  schemaVersion: {spec['schemaVersion']}")
for name, n in counts.items():
    print(f"  {name}: {n}")
print(f"  всего проверок: {sum(counts.values())}")
PY

echo "═══ запуск инструмента ═══"
if command -v container-structure-test > /dev/null 2>&1; then
    container-structure-test test --image val:good --config structure-tests.yaml 2>&1 \
        | tail -8 | sed 's/^/  /'
else
    cat <<'TXT'
  container-structure-test НЕ УСТАНОВЛЕН — проверки НЕ ВЫПОЛНЯЛИСЬ.

  Команда для справки:
    container-structure-test test \
        --image val:good --config structure-tests.yaml

  Инструмент распространяется как отдельный бинарник
  и как образ gcr.io/gcp-runtimes/container-structure-test.
TXT
fi

echo "═══ сравнение с собственным скриптом ═══"
cat <<'TXT'
  Container structure test        Скрипт на shell

  YAML, декларативно              Императивно
  Читается без знания языка       Нужно читать код
  Единый формат в организации     Свой в каждом проекте
  Ещё одна зависимость            Только Docker
  Ограниченная выразительность    Любая логика
  Не измеряет время               Может измерять

  Проверка «завершается по SIGTERM за 2 секунды» в формате
  container structure test не выражается — там нет понятия
  времени и сигналов. Её пишут скриптом в любом случае.

  Выбор — вопрос предпочтений команды, а не возможностей.
TXT

═══ проверка формата ═══
  schemaVersion: 2.0.0
  commandTests: 3
  fileExistenceTests: 4
  metadataTest: 1
  всего проверок: 8
═══ запуск инструмента ═══
  container-structure-test НЕ УСТАНОВЛЕН — проверки НЕ ВЫПОЛНЯЛИСЬ.

  Команда для справки:
    container-structure-test test \
        --image val:good --config structure-tests.yaml

  Инструмент распространяется как отдельный бинарник
  и как образ gcr.io/gcp-runtimes/container-structure-test.
═══ сравнение с собственным скриптом ═══
  Container structure test        Скрипт на shell
  ...
  Проверка «завершается по SIGTERM за 2 секунды» в формате
  container structure test не выражается — там нет понятия
  времени и сигналов. Её пишут скриптом в любом случае.

  Выбор — вопрос предпочтений команды, а не возможностей.

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

IMAGE="${1:?укажите образ}"
PORT="${2:-8000}"
NAME="validate-$$"

static_fail=0
dynamic_fail=0
skipped=0

pass()  { printf '  ✓ %s\n' "$1"; }
sfail() { printf '  ✗ %s\n' "$1"; static_fail=$((static_fail + 1)); }
dfail() { printf '  ✗ %s\n' "$1"; dynamic_fail=$((dynamic_fail + 1)); }
skip()  { printf '  ○ %s (НЕ ПРОВЕРЕНО)\n' "$1"; skipped=$((skipped + 1)); }

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

docker image inspect "$IMAGE" > /dev/null 2>&1 || {
    echo "  образ $IMAGE не найден"; exit 3; }

printf '\n  Валидация образа: %s\n\n  СТАТИЧЕСКИЕ (без запуска)\n' "$IMAGE"

# 1. USER объявлен и не root
user="$(docker inspect "$IMAGE" --format '{{.Config.User}}')"
case "$user" in
    "")      sfail "USER не задан — процесс пойдёт от root" ;;
    0|root)  sfail "USER = $user, то есть root" ;;
    *)       pass "USER объявлен: $user" ;;
esac

# 2. Форма ENTRYPOINT
ep_form="$(docker inspect "$IMAGE" --format '{{json .Config.Entrypoint}}' \
    | python3 -c "
import json, sys
v = json.load(sys.stdin) or []
if len(v) >= 2 and v[0] in ('/bin/sh', '/bin/bash', 'sh', 'bash') and v[1] == '-c':
    print('shell')
elif v:
    print('exec')
else:
    print('none')
")"
case "$ep_form" in
    exec)  pass "ENTRYPOINT в exec form — сигналы дойдут" ;;
    shell) sfail "ENTRYPOINT в shell form — SIGTERM не дойдёт до приложения" ;;
    none)  pass "ENTRYPOINT не задан (команда определяется CMD)" ;;
esac

# 3. Секреты в ENV
secrets="$(docker inspect "$IMAGE" --format '{{range .Config.Env}}{{println .}}{{end}}' \
    | grep -Pci '^([A-Z_]*_)?(TOKEN|SECRET|PASSWORD|API_KEY|CREDENTIAL)[A-Z_]*=.{6,}' \
    || echo 0)"
[ "${secrets:-0}" -eq 0 ] && pass "секретов в ENV нет" \
                          || sfail "переменных, похожих на секреты: $secrets"

# 4. Healthcheck объявлен
if docker inspect "$IMAGE" --format '{{if .Config.Healthcheck}}да{{end}}' | grep -q да; then
    pass "healthcheck объявлен"
else
    sfail "healthcheck не объявлен"
fi

# 5. EXPOSE
ports="$(docker inspect "$IMAGE" \
    --format '{{range $p, $_ := .Config.ExposedPorts}}{{$p}} {{end}}')"
[ -n "$ports" ] && pass "EXPOSE: $ports" || sfail "EXPOSE не задан"

# 6. Файлы: нужные есть, лишних нет (через docker create, без запуска)
cid="$(docker create "$IMAGE" 2>/dev/null)"
if [ -n "$cid" ]; then
    for path in /app/src /app/healthcheck.py; do
        docker cp "$cid:$path" - > /dev/null 2>&1 \
            && pass "есть: $path" || sfail "отсутствует: $path"
    done
    for path in /app/tests /app/requirements-dev.txt /app/.git; do
        docker cp "$cid:$path" - > /dev/null 2>&1 \
            && sfail "лишнее в образе: $path" || pass "нет лишнего: $path"
    done
    docker rm "$cid" > /dev/null 2>&1
else
    skip "проверка файлов: docker create не удался"
fi

printf '\n  провалов статических: %s\n' "$static_fail"

# Если статические провалились грубо — динамические бессмысленны
if [ "$static_fail" -ge 4 ]; then
    printf '\n  ДИНАМИЧЕСКИЕ пропущены: слишком много статических провалов\n'
    printf '  ИТОГ: статических %s, динамических пропущено, не проверено %s\n\n' \
        "$static_fail" "$skipped"
    exit 1
fi

printf '\n  ДИНАМИЧЕСКИЕ (с запуском)\n'

if ! docker run -d --name "$NAME" -p "0:$PORT" "$IMAGE" > /dev/null 2>&1; then
    dfail "container не запускается"
    printf '\n  ИТОГ: статических %s, динамических %s\n\n' "$static_fail" "$dynamic_fail"
    exit 1
fi

sleep 4
status="$(docker inspect "$NAME" --format '{{.State.Status}}' 2>/dev/null)"
[ "$status" = "running" ] && pass "работает через 4 с" \
                          || dfail "статус через 4 с: $status"

# Фактический UID
uid="$(docker exec "$NAME" id -u 2>/dev/null || echo "?")"
case "$uid" in
    0) dfail "фактический UID: 0 (root)" ;;
    "?") skip "фактический UID: нет exec в образе" ;;
    *) pass "фактический UID: $uid" ;;
esac

# Ответ на запрос
hostport="$(docker port "$NAME" "$PORT/tcp" 2>/dev/null | head -1 | sed 's/.*://')"
if [ -n "$hostport" ]; then
    if curl -sf --max-time 5 "http://127.0.0.1:$hostport/" > /dev/null 2>&1; then
        pass "отвечает на HTTP-запрос"
    else
        dfail "не отвечает на порту $hostport"
    fi
else
    skip "проверка ответа: порт не опубликован"
fi

# Healthcheck переходит в healthy
health="—"
for i in $(seq 1 20); do
    health="$(docker inspect "$NAME" \
        --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}нет{{end}}' 2>/dev/null)"
    case "$health" in healthy|unhealthy|нет) break ;; esac
    sleep 1
done
case "$health" in
    healthy)   pass "healthcheck перешёл в healthy" ;;
    unhealthy) dfail "healthcheck провальный (объявлен, но не проходит)" ;;
    нет)       skip "healthcheck: не объявлен" ;;
    *)         skip "healthcheck: не дошёл до итогового статуса ($health)" ;;
esac

# Завершение по 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)"
if python3 -c "import sys; sys.exit(0 if $secs < 3 else 1)"; then
    pass "завершился по SIGTERM за $secs с (код $code)"
else
    dfail "SIGTERM не обработан: $secs с, код $code"
fi

printf '\n  ИТОГ: статических провалов %s, динамических %s, не проверено %s\n\n' \
    "$static_fail" "$dynamic_fail" "$skipped"

total=$((static_fail + dynamic_fail))
[ "$total" -gt 0 ] && exit 1
exit 0
SH
chmod +x validate-image.sh

echo "═══ правильный образ ═══"
./validate-image.sh val:good; good_rc=$?

echo "═══ сломанный образ ═══"
./validate-image.sh val:bad; bad_rc=$?

printf '\n  коды возврата: правильный=%s сломанный=%s\n' "$good_rc" "$bad_rc"

docker rmi -f val:good val:bad > /dev/null 2>&1
cd /tmp && rm -rf /tmp/validate

═══ правильный образ ═══

  Валидация образа: val:good

  СТАТИЧЕСКИЕ (без запуска)
  ✓ USER объявлен: appuser
  ✓ ENTRYPOINT в exec form — сигналы дойдут
  ✓ секретов в ENV нет
  ✓ healthcheck объявлен
  ✓ EXPOSE: 8000/tcp
  ✓ есть: /app/src
  ✓ есть: /app/healthcheck.py
  ✓ нет лишнего: /app/tests
  ✓ нет лишнего: /app/requirements-dev.txt
  ✓ нет лишнего: /app/.git

  провалов статических: 0

  ДИНАМИЧЕСКИЕ (с запуском)
  ✓ работает через 4 с
  ✓ фактический UID: 10001
  ✓ отвечает на HTTP-запрос
  ✓ healthcheck перешёл в healthy
  ✓ завершился по SIGTERM за 0.3 с (код 0)

  ИТОГ: статических провалов 0, динамических 0, не проверено 0

═══ сломанный образ ═══

  Валидация образа: val:bad

  СТАТИЧЕСКИЕ (без запуска)
  ✗ USER не задан — процесс пойдёт от root
  ✗ ENTRYPOINT в shell form — SIGTERM не дойдёт до приложения
  ✗ переменных, похожих на секреты: 1
  ✓ healthcheck объявлен
  ✗ EXPOSE не задан
  ✓ есть: /app/src
  ✓ есть: /app/healthcheck.py
  ✓ нет лишнего: /app/tests
  ✓ нет лишнего: /app/requirements-dev.txt
  ✓ нет лишнего: /app/.git

  провалов статических: 4

  ДИНАМИЧЕСКИЕ пропущены: слишком много статических провалов
  ИТОГ: статических 4, динамических пропущено, не проверено 0

  коды возврата: правильный=0 сломанный=1

docker inspect ОБРАЗ --format '{{.Config.User}} {{json .Config.Entrypoint}}'
docker run --rm --entrypoint id ОБРАЗ -u
docker inspect ОБРАЗ --format '{{json .Config.Healthcheck}}'
cid=$(docker create ОБРАЗ) && docker cp "$cid:/app/tests" - > /dev/null 2>&1; echo $?; docker rm "$cid"
docker run -d --name smoke ОБРАЗ && sleep 5 && time docker stop smoke