19.4. Каталог антипаттернов

mkdir -p /tmp/antilab && cd /tmp/antilab

cat > catalog.py <<'PY'
"""Каталог антипаттернов: группы и правила.

Каталог отделён от линтера намеренно. Список групп используется
и правилами, и отчётом о покрытии, и перечнем необнаружимого —
иначе три места разъезжаются при первом же изменении.
"""
from __future__ import annotations

GROUPS = {
    "build": "Сборка образов",
    "run": "Запуск и жизненный цикл",
    "data": "Данные",
    "net": "Сеть",
    "secret": "Конфигурация и секреты",
    "compose": "Compose",
    "ops": "Эксплуатация",
    "org": "Организационные",
}

# Антипаттерны, не обнаруживаемые статически — с указанием группы
NOT_DETECTABLE = [
    ("org", "Один человек знает, как собирается образ", "знание вне репозитория"),
    ("org", "Базовые образы не обновляются", "видно по датам, а не по файлам"),
    ("org", "Сканирование настроено, отчёты не читают", "процесс, а не конфигурация"),
    ("org", "Dockerfile скопирован из статьи без разбора", "не отличим от написанного"),
    ("org", "«Завернём всё в Docker»", "решение принято до конфигурации"),
    ("org", "Kubernetes «потому что так делают»", "то же"),
    ("run", "Нет обработки SIGTERM", "находится в коде приложения"),
    ("data", "Нет процедуры восстановления", "существует вне репозитория"),
    ("net", "Порт не нужен снаружи", "зависит от назначения сервиса"),
    ("ops", "Исправления через docker exec", "происходят в работающей системе"),
    ("compose", "Окружения не разделены по смыслу", "требует понимания задачи"),
]
PY

cat > lint.py <<'PY'
"""Линтер по каталогу антипаттернов.

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

import json
import re
import sys
from pathlib import Path

import yaml

from catalog import GROUPS, NOT_DETECTABLE

SEVERITY_ORDER = {"высокая": 0, "средняя": 1, "низкая": 2}


class Finding:
    def __init__(self, code: str, where: str, severity: str,
                 what: str, fix: str) -> None:
        self.code = code
        self.where = where
        self.severity = severity
        self.what = what
        self.fix = fix

    @property
    def group(self) -> str:
        return self.code.split(".", 1)[0]

    def as_dict(self) -> dict[str, str]:
        return {"код": self.code, "где": self.where,
                "серьёзность": self.severity, "что": self.what,
                "как_правильно": self.fix, "группа": GROUPS[self.group]}


def lint_dockerfile(text: str, name: str) -> list[Finding]:
    out: list[Finding] = []
    lines = text.splitlines()
    joined = "\n".join(lines)
    has_user = numeric_user = False
    copy_all = deps_copy = 0

    def add(code: str, line: int | None, sev: str, what: str, fix: str) -> None:
        where = f"{name}:{line}" if line else name
        out.append(Finding(code, where, sev, what, fix))

    for i, raw in enumerate(lines, 1):
        line = raw.strip()
        if not line or line.startswith("#"):
            continue
        upper = line.upper()
        parts = line.split()

        if upper.startswith("FROM"):
            ref = parts[1] if len(parts) > 1 else ""
            if ref.endswith(":latest"):
                add("build.latest", i, "высокая",
                    "базовый образ по тегу latest",
                    "конкретный тег, лучше digest")
            elif ":" not in ref and "@" not in ref:
                add("build.notag", i, "высокая",
                    "базовый образ без тега — это latest",
                    "конкретный тег, лучше digest")
        if re.fullmatch(r"RUN\s+apt-get\s+update", line, re.I):
            add("build.split_update", i, "средняя",
                "apt-get update отдельной инструкцией",
                "объединить с install в одной RUN")
        if upper.startswith("ADD ") and "http" not in line and ".tar" not in line:
            add("build.add", i, "низкая", "ADD для локальных файлов", "COPY")
        if re.match(r"COPY\s+\.\s+\.?\s*$", line, re.I):
            copy_all = i
        if upper.startswith("COPY") and re.search(
                r"(requirements|pyproject|uv\.lock|poetry\.lock|package\.json)",
                line, re.I):
            deps_copy = i
        if re.search(r"pip\s+install", line, re.I) and not re.search(
                r"(==|-r\s|--no-deps|\.lock)", line):
            add("build.unpinned", i, "средняя",
                "установка пакетов без фиксации версий",
                "файл блокировки или явные версии")
        if upper.startswith("USER"):
            has_user = True
            value = parts[1] if len(parts) > 1 else ""
            numeric_user = bool(re.fullmatch(r"\d+(:\d+)?", value))
        if upper.startswith("CMD") and not line.endswith("]"):
            add("run.shellform", i, "высокая",
                "CMD в shell-форме: PID 1 будет оболочкой",
                "exec-форма со списком аргументов")
        if upper.startswith("ENTRYPOINT") and not line.endswith("]"):
            add("run.shellform", i, "высокая",
                "ENTRYPOINT в shell-форме",
                "exec-форма со списком аргументов")
        if "sleep infinity" in line or "tail -f /dev/null" in line:
            add("run.fake_alive", i, "высокая",
                "container держится живым искусственно",
                "устранить причину выхода процесса")
        if upper.startswith(("ENV", "ARG")) and re.search(
                r"(PASSWORD|SECRET|TOKEN|API_KEY)", line, re.I):
            add("secret.in_image", i, "высокая",
                "секрет в ENV или ARG: остаётся в истории образа",
                "RUN --mount=type=secret или секрет при запуске")
        if re.search(r"chmod\s+(-R\s+)?777", line):
            add("data.chmod777", i, "высокая", "chmod 777",
                "совпадающие UID и GID")
        if re.search(r"\brm\b.*\b(secret|\.env|credential)", line, re.I):
            add("secret.rm_after_copy", i, "высокая",
                "удаление секрета не убирает его из предыдущего слоя",
                "RUN --mount=type=secret")

    if copy_all and deps_copy and copy_all < deps_copy:
        add("build.copy_order", copy_all, "средняя",
            "COPY . . раньше установки зависимостей",
            "сначала файл зависимостей, потом код")
    if not has_user:
        add("run.root", None, "высокая", "USER не задан: запуск от root",
            "USER с числовым идентификатором")
    elif not numeric_user:
        add("run.named_user", None, "средняя",
            "USER задан именем, а не числом",
            "числовой UID: Kubernetes проверяет runAsNonRoot")
    if "apt-get install" in joined and "/var/lib/apt/lists" not in joined:
        add("build.apt_cache", None, "средняя", "кэш apt не удалён",
            "rm -rf /var/lib/apt/lists/* в той же RUN")
    return out


def lint_compose(doc: dict, name: str) -> list[Finding]:
    out: list[Finding] = []

    def add(code: str, where: str, sev: str, what: str, fix: str) -> None:
        out.append(Finding(code, where, sev, what, fix))

    if "version" in doc:
        add("compose.version", f"{name}:version", "низкая",
            "поле version устарело и игнорируется", "убрать")

    declared = set((doc.get("volumes") or {}).keys())

    for svc_name, svc in (doc.get("services") or {}).items():
        svc = svc or {}
        where = f"{name}:{svc_name}"
        image = str(svc.get("image", ""))

        if image and ("@" not in image):
            tag = image.rsplit(":", 1)[-1] if ":" in image else ""
            if tag == "latest" or not tag:
                add("compose.latest", where, "высокая",
                    "образ по тегу latest или без тега",
                    "конкретный тег или digest")
        if "container_name" in svc:
            add("compose.container_name", where, "средняя",
                "container_name делает --scale невозможным",
                "обращаться по имени сервиса")
        if isinstance(svc.get("depends_on"), list):
            add("compose.depends_no_condition", where, "средняя",
                "depends_on без condition: ждёт запуска, а не готовности",
                "condition: service_healthy и повторы в приложении")
        if svc.get("network_mode") == "host":
            add("net.host", where, "высокая",
                "network_mode: host снимает сетевую изоляцию",
                "проверить, действительно ли сеть узкое место")
        if "links" in svc:
            add("net.links", where, "средняя", "links — устаревший механизм",
                "пользовательские сети")
        for p in svc.get("ports") or []:
            spec = p if isinstance(p, str) else str(p.get("published", ""))
            if spec and not spec.startswith("127.0.0.1"):
                add("net.public_port", where, "низкая",
                    f"порт {spec} публикуется на все адреса",
                    "явный адрес привязки, если наружу не нужно")
        if str(svc.get("user", "")) in ("0", "root", "0:0"):
            add("run.root", where, "высокая", "запуск от root",
                "числовой непривилегированный UID")
        if image and not svc.get("healthcheck"):
            add("ops.no_healthcheck", where, "средняя",
                "нет healthcheck: «запущен» не значит «работает»",
                "healthcheck с проверкой готовности")
        limits = ((svc.get("deploy") or {}).get("resources") or {}).get("limits")
        if not limits and not svc.get("mem_limit"):
            add("ops.no_limits", where, "средняя", "нет ограничений ресурсов",
                "mem_limit и cpus или deploy.resources.limits")

        env = svc.get("environment") or {}
        pairs = list(env.items()) if isinstance(env, dict) else [
            (e.split("=", 1)[0], e.split("=", 1)[-1]) for e in env if "=" in e]
        for key, value in pairs:
            if re.search(r"(PASSWORD|SECRET|TOKEN|API_KEY)", str(key), re.I) \
                    and not str(key).endswith("_FILE") \
                    and value and not str(value).startswith("$"):
                add("secret.in_compose", where, "высокая",
                    f"секрет в открытом виде: {key}",
                    "файл секрета вне репозитория")

        for v in svc.get("volumes") or []:
            spec = v if isinstance(v, str) else \
                f"{v.get('source', '')}:{v.get('target', '')}"
            source = spec.split(":")[0]
            if "docker.sock" in spec:
                add("ops.docker_sock", where, "высокая",
                    "монтирование сокета равно правам root на хосте",
                    "агент с ограниченными правами")
            elif source.startswith("/"):
                add("data.bind_mount", where, "низкая",
                    f"bind mount каталога хоста: {source}",
                    "именованный том")
            elif source and not source.startswith(".") \
                    and source not in declared:
                add("data.undeclared_volume", where, "средняя",
                    f"том {source} не объявлен в volumes:",
                    "объявить именованный том")
    return out


def main(argv: list[str]) -> int:
    findings: list[Finding] = []
    for path in argv:
        p = Path(path)
        if not p.exists():
            continue
        if p.name.lower().startswith("dockerfile"):
            findings += lint_dockerfile(p.read_text(encoding="utf-8"), p.name)
        elif p.suffix in (".yaml", ".yml"):
            doc = yaml.safe_load(p.read_text(encoding="utf-8")) or {}
            findings += lint_compose(doc, p.name)

    findings.sort(key=lambda f: (SEVERITY_ORDER[f.severity], f.code, f.where))

    by_sev: dict[str, int] = {}
    by_group: dict[str, int] = {}
    for f in findings:
        by_sev[f.severity] = by_sev.get(f.severity, 0) + 1
        by_group[f.group] = by_group.get(f.group, 0) + 1

    # Правила, реализованные линтером — для отчёта о покрытии
    implemented = {
        "build": ["latest", "notag", "split_update", "add", "unpinned",
                  "copy_order", "apt_cache"],
        "run": ["shellform", "fake_alive", "root", "named_user"],
        "data": ["chmod777", "bind_mount", "undeclared_volume"],
        "net": ["host", "links", "public_port"],
        "secret": ["in_image", "rm_after_copy", "in_compose"],
        "compose": ["version", "latest", "container_name",
                    "depends_no_condition"],
        "ops": ["no_healthcheck", "no_limits", "docker_sock"],
        "org": [],
    }

    print(json.dumps({
        "находок": len(findings),
        "по_серьёзности": by_sev,
        "по_группам": {GROUPS[g]: n for g, n in by_group.items()},
        "правил": sum(len(v) for v in implemented.values()),
        "покрытие": {GROUPS[g]: len(v) for g, v in implemented.items()},
        "список": [f.as_dict() for f in findings],
        "не_обнаруживается": [
            {"группа": GROUPS[g], "что": what, "почему": why}
            for g, what, why in NOT_DETECTABLE
        ],
    }, ensure_ascii=False))
    return 1 if by_sev.get("высокая") else 0


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

# ── заведомо плохая конфигурация ────────────────────────────────────
cat > Dockerfile.bad <<'DOCKERFILE'
FROM python:latest

ENV DB_PASSWORD=hunter2

COPY . .
COPY requirements.txt .

RUN apt-get update
RUN apt-get install -y curl gcc
RUN pip install flask requests
RUN chmod -R 777 /app
RUN rm /app/secret.key

CMD python app.py
DOCKERFILE

cat > compose.bad.yaml <<'EOF'
version: "3.8"

services:
  web:
    image: myapp:latest
    container_name: web
    network_mode: host
    user: "0:0"
    ports:
      - "8080:8000"
    environment:
      DB_PASSWORD: hunter2
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /opt/data:/data
      - cachedata:/cache
    depends_on:
      - db

  db:
    image: postgres
    links:
      - web
EOF

# ── чистая конфигурация ─────────────────────────────────────────────
cat > Dockerfile.good <<'DOCKERFILE'
# syntax=docker/dockerfile:1
FROM python:3.13-slim@sha256:6771159cd4fa5d9bba1258caf0b82e6b73458c694d178ad97c5e925c2d0e1a91

WORKDIR /app

COPY requirements.lock .
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install --no-deps -r requirements.lock

COPY src/ ./src/

USER 10001:10001

ENTRYPOINT ["python", "-m", "app.main"]
DOCKERFILE

cat > compose.good.yaml <<'EOF'
services:
  web:
    image: ghcr.io/org/app:1.4.2
    user: "10001:10001"
    read_only: true
    ports:
      - "127.0.0.1:8080:8000"
    environment:
      DB_PASSWORD_FILE: /run/secrets/db_password
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health')"]
      interval: 10s
    deploy:
      resources:
        limits: {cpus: "0.5", memory: 256M}
    depends_on:
      db:
        condition: service_healthy
    networks: [backend]

  db:
    image: postgres:17-alpine
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app"]
      interval: 5s
    deploy:
      resources:
        limits: {cpus: "1.0", memory: 1G}
    volumes:
      - pgdata:/var/lib/postgresql/data
    networks: [backend]

volumes:
  pgdata:

networks:
  backend:
EOF

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

python3 lint.py Dockerfile.bad compose.bad.yaml > bad.json; bad_code=$?
python3 lint.py Dockerfile.good compose.good.yaml > good.json; good_code=$?

printf '\n═══ Требования 1 и 7: правила и покрытие групп ═══\n'
python3 - <<'PY'
import json

d = json.load(open("bad.json"))
print(f"    {'группа каталога':<32} правил в линтере")
print("    " + "─" * 52)
for group, n in d["покрытие"].items():
    mark = "" if n else "  ← не проверяется в принципе"
    print(f"    {group:<32} {n:>4}{mark}")
print()
print(f"    правил всего: {d['правил']}")
print()
print("    Группа «Организационные» пуста намеренно: её антипаттерны")
print("    не обнаруживаются ни одним инструментом.")
PY
rules="$(python3 -c "import json;print(json.load(open('bad.json'))['правил'])")"
printf '\n  правил: %s\n' "$rules"
[ "$rules" -ge 15 ] \
    && ok "правил не меньше пятнадцати, разложены по группам каталога" \
    || bad "правил: $rules"

printf '\n═══ Требования 2, 3 и 4: находки на плохой конфигурации ═══\n'
python3 - <<'PY'
import json

d = json.load(open("bad.json"))
print(f"    {'серьёзность':<12} {'код':<30} {'где':<26} что")
print("    " + "─" * 118)
for f in d["список"]:
    print(f"    {f['серьёзность']:<12} {f['код']:<30} {f['где']:<26} {f['что']}")
print()
print(f"    находок: {d['находок']}   по серьёзности: {d['по_серьёзности']}")
print(f"    по группам: {d['по_группам']}")
print()
print("    Каждая находка содержит пять полей, включая способ исправления:")
example = d["список"][0]
for key, value in example.items():
    print(f"      {key}: {value}")
PY
n_bad="$(python3 -c "import json;print(json.load(open('bad.json'))['находок'])")"
high="$(python3 -c "
import json
print(json.load(open('bad.json'))['по_серьёзности'].get('высокая', 0))")"
printf '\n  находок: %s (высокой серьёзности: %s), код возврата: %s\n' \
    "$n_bad" "$high" "$bad_code"
[ "$n_bad" -ge 10 ] && [ "$bad_code" -eq 1 ] \
    && ok "не менее десяти находок; код возврата отражает серьёзность" \
    || bad "находок $n_bad, код $bad_code"

printf '\n═══ Требование 5: чистая конфигурация ═══\n'
python3 - <<'PY'
import json

d = json.load(open("good.json"))
print(f"    находок: {d['находок']}")
print(f"    по серьёзности: {d['по_серьёзности'] or 'нет'}")
if d["список"]:
    print()
    for f in d["список"]:
        print(f"    {f['серьёзность']:<12} {f['код']:<30} {f['что']}")
print()
high = d["по_серьёзности"].get("высокая", 0)
if high == 0:
    print("    Ни одной находки высокой серьёзности.")
    print()
    print("    Это проверка ЛИНТЕРА, а не конфигурации: инструмент,")
    print("    отмечающий всё подряд, ничем не лучше не отмечающего ничего.")
    print("    Без чистого примера находки в плохой конфигурации")
    print("    не значили бы ничего.")
else:
    print(f"    ПРОБЛЕМА: {high} находок высокой серьёзности на чистом примере")
PY
good_high="$(python3 -c "
import json
print(json.load(open('good.json'))['по_серьёзности'].get('высокая', 0))")"
printf '\n  высокой серьёзности на чистой конфигурации: %s, код возврата: %s\n' \
    "$good_high" "$good_code"
[ "$good_high" -eq 0 ] && [ "$good_code" -eq 0 ] \
    && ok "чистая конфигурация проходит — находки различимы" \
    || bad "высоких: $good_high, код: $good_code"

printf '\n═══ Требование 6: что не обнаруживается в принципе ═══\n'
python3 - <<'PY'
import json

d = json.load(open("good.json"))
print(f"    {'группа':<28} {'антипаттерн':<48} почему не находится")
print("    " + "─" * 122)
for item in d["не_обнаруживается"]:
    print(f"    {item['группа']:<28} {item['что']:<48} {item['почему']}")
print()
org = [i for i in d["не_обнаруживается"] if i["группа"] == "Организационные"]
print(f"    всего: {len(d['не_обнаруживается'])}, из них организационных: {len(org)}")
print()
print("    Организационные антипаттерны наносят наибольший ущерб")
print("    и не находятся ни одним инструментом. «Ноль находок»")
print("    не говорит, знает ли кто-нибудь ещё, как собрать этот образ,")
print("    и обновлялся ли базовый образ за последний год.")
PY
n_nd="$(python3 -c "
import json
print(len(json.load(open('good.json'))['не_обнаруживается']))")"
[ "$n_nd" -ge 8 ] \
    && ok "перечислено необнаружимое, с указанием причины" \
    || bad "не обнаруживается: $n_nd"

printf '\n═══ Что НЕ проверялось ═══\n'
python3 - <<'PY'
NOT_RUN = [
    ("сборка образов", "Docker на машине курса не установлен"),
    ("запуск конфигураций", "то же"),
    ("последствия антипаттернов", "описаны по механизмам, а не воспроизведены"),
    ("полнота каталога", "62 записи — не исчерпывающий список"),
]
print(f"    {'проверка':<34} причина")
print("    " + "─" * 82)
for name, why in NOT_RUN:
    print(f"    {name:<34} {why}")
print()
print("    ВЫПОЛНЕНО: разбор двух Dockerfile и двух compose.yaml,")
print("    сопоставление правил с группами каталога, проверка линтера")
print("    на чистой конфигурации.")
PY
ok "разделено выполненное и невыполненное"

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

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

═══ Требования 1 и 7: правила и покрытие групп ═══
    группа каталога                  правил в линтере
    ────────────────────────────────────────────────────
    Сборка образов                      7
    Запуск и жизненный цикл             4
    Данные                              3
    Сеть                                3
    Конфигурация и секреты              3
    Compose                             4
    Эксплуатация                        3
    Организационные                     0  ← не проверяется в принципе

    правил всего: 27

    Группа «Организационные» пуста намеренно: её антипаттерны
    не обнаруживаются ни одним инструментом.

  правил: 27
  ✓ правил не меньше пятнадцати, разложены по группам каталога

═══ Требования 2, 3 и 4: находки на плохой конфигурации ═══
    серьёзность  код                            где                        что
    ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────
    высокая      build.latest                   Dockerfile.bad:1           базовый образ по тегу latest
    высокая      compose.latest                 compose.bad.yaml:db        образ по тегу latest или без тега
    высокая      compose.latest                 compose.bad.yaml:web       образ по тегу latest или без тега
    высокая      data.chmod777                  Dockerfile.bad:11          chmod 777
    высокая      net.host                       compose.bad.yaml:web       network_mode: host снимает сетевую изоляцию
    высокая      ops.docker_sock                compose.bad.yaml:web       монтирование сокета равно правам root на хосте
    высокая      run.root                       Dockerfile.bad             USER не задан: запуск от root
    высокая      run.root                       compose.bad.yaml:web       запуск от root
    высокая      run.shellform                  Dockerfile.bad:14          CMD в shell-форме: PID 1 будет оболочкой
    высокая      secret.in_compose              compose.bad.yaml:web       секрет в открытом виде: DB_PASSWORD
    высокая      secret.in_image                Dockerfile.bad:3           секрет в ENV или ARG: остаётся в истории образа
    высокая      secret.rm_after_copy           Dockerfile.bad:12          удаление секрета не убирает его из предыдущего слоя
    средняя      build.apt_cache                Dockerfile.bad             кэш apt не удалён
    ...

    находок: 27   по серьёзности: {'высокая': 12, 'средняя': 12, 'низкая': 3}
    по группам: {'Сборка образов': 5, 'Compose': 5, 'Данные': 3, 'Сеть': 3, 'Эксплуатация': 5, 'Запуск и жизненный цикл': 3, 'Конфигурация и секреты': 3}

  находок: 27 (высокой серьёзности: 12), код возврата: 1
  ✓ не менее десяти находок; код возврата отражает серьёзность

═══ Требование 5: чистая конфигурация ═══
    находок: 0
    по серьёзности: нет

    Ни одной находки высокой серьёзности.

    Это проверка ЛИНТЕРА, а не конфигурации: инструмент,
    отмечающий всё подряд, ничем не лучше не отмечающего ничего.
    Без чистого примера находки в плохой конфигурации
    не значили бы ничего.

  высокой серьёзности на чистой конфигурации: 0, код возврата: 0
  ✓ чистая конфигурация проходит — находки различимы

═══ Требование 6: что не обнаруживается в принципе ═══
    группа                       антипаттерн                                      почему не находится
    ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
    Организационные              Один человек знает, как собирается образ         знание вне репозитория
    Организационные              Базовые образы не обновляются                    видно по датам, а не по файлам
    ...
    Запуск и жизненный цикл      Нет обработки SIGTERM                            находится в коде приложения
    Данные                       Нет процедуры восстановления                     существует вне репозитория

    всего: 11, из них организационных: 6
  ✓ перечислено необнаружимое, с указанием причины

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