16.5. GitLab CI

mkdir -p /tmp/glcilab && cd /tmp/glcilab
mkdir -p ci

cat > .gitlab-ci.yml <<'EOF'
stages: [check, test, build, publish]

variables:
  BUILD_CACHE: $CI_REGISTRY_IMAGE/cache:buildcache
  IMAGE_TAG: $CI_REGISTRY_IMAGE:git-$CI_COMMIT_SHORT_SHA

default:
  interruptible: true

.python-base:
  image: python:3.13-slim
  cache:
    key:
      files: [requirements-dev.txt]
    paths: [.pip-cache]
    policy: pull-push
  before_script:
    - pip install --quiet --cache-dir .pip-cache -r requirements-dev.txt

.docker-base:
  image: docker:28-cli
  services:
    - name: docker:28-dind
      alias: docker
  variables:
    DOCKER_HOST: tcp://docker:2376
    DOCKER_TLS_CERTDIR: "/certs"
    DOCKER_CERT_PATH: "/certs/client"
    DOCKER_TLS_VERIFY: 1

format:
  extends: .python-base
  stage: check
  script: [ruff format --check .]

lint:
  extends: .python-base
  stage: check
  script: [ruff check .]

types:
  extends: .python-base
  stage: check
  script: [mypy src/]

unit-tests:
  stage: test
  needs: [format, lint, types]
  image: python:$PY_VERSION-slim
  parallel:
    matrix:
      - PY_VERSION: ["3.12", "3.13"]
  cache:
    key:
      files: [requirements.txt, requirements-dev.txt]
    paths: [.pip-cache]
  script:
    - pip install --quiet --cache-dir .pip-cache -r requirements.txt -r requirements-dev.txt
    - pytest tests/unit -q --junitxml=junit-$PY_VERSION.xml
  artifacts:
    when: always
    reports:
      junit: junit-$PY_VERSION.xml
    paths: [junit-$PY_VERSION.xml]
    expire_in: 1 week

build:
  extends: .docker-base
  stage: build
  needs: [unit-tests]
  before_script:
    - echo "$CI_REGISTRY_PASSWORD" | docker login "$CI_REGISTRY" -u "$CI_REGISTRY_USER" --password-stdin
  script:
    - docker buildx create --use --driver docker-container
    - |
      docker buildx build --target production \
        --cache-from "type=registry,ref=$BUILD_CACHE" \
        --cache-to "type=registry,ref=$BUILD_CACHE,mode=max" \
        --tag candidate:local --load .
    - ./ci/validate-image.sh candidate:local
    - ./ci/integration-tests.sh candidate:local
    - docker save candidate:local -o image.tar
  artifacts:
    paths: [image.tar]
    expire_in: 1 day
  after_script:
    - docker logout "$CI_REGISTRY" || true

scan:
  stage: build
  needs: [build]
  image: aquasec/trivy:latest
  script:
    - ./ci/scan.sh candidate:local
  artifacts:
    paths: [scan-reports/]
    expire_in: 1 month
  allow_failure: true

publish:
  extends: .docker-base
  stage: publish
  needs: [build]
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
      when: on_success
    - if: $CI_COMMIT_TAG
      when: on_success
    - when: never
  before_script:
    - ./ci/require-vars.sh CI_REGISTRY CI_REGISTRY_USER CI_REGISTRY_PASSWORD
    - echo "$CI_REGISTRY_PASSWORD" | docker login "$CI_REGISTRY" -u "$CI_REGISTRY_USER" --password-stdin
  script:
    - docker buildx create --use --driver docker-container
    - |
      docker buildx build --target production \
        --cache-from "type=registry,ref=$BUILD_CACHE" \
        --tag "$IMAGE_TAG" \
        --tag "$CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG" \
        --provenance=true --sbom=true \
        --push .
  after_script:
    - docker logout "$CI_REGISTRY" || true
EOF

# ─── Проверка обязательных переменных ─────────────────────────────────
cat > ci/require-vars.sh <<'SH'
#!/usr/bin/env bash
# Проверяет наличие переменных ДО первой команды, которая их использует.
#
# Без этой проверки отказ приходит из глубины docker login сообщением
# вида "unauthorized", по которому причина неочевидна.
set -uo pipefail

missing=0
for name in "$@"; do
    value="$(eval "printf '%s' \"\${$name:-}\"")"
    if [ -z "$value" ]; then
        printf '  ✗ %s пуста\n' "$name"
        missing=$((missing + 1))
    else
        printf '  ✓ %s задана (%s символов)\n' "$name" "${#value}"
    fi
done

if [ "$missing" -gt 0 ]; then
    cat <<'MSG'

  Переменных не хватает. Вероятные причины, по убыванию частоты:

    1. Переменная protected, а ветка не защищена.
       Признак: pipeline работает на main и падает на ветке.
       Это НЕ ошибка настройки — так и задумано: секрет публикации
       не должен быть доступен задаче из произвольной ветки.

    2. Переменная задана на уровне окружения, а в задаче нет environment:.

    3. Опечатка в имени переменной.

  Правильный ответ на причину 1 — не запускать эту задачу
  на незащищённых ветках (rules: if $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH).

MSG
    exit 1
fi
printf '  все переменные на месте\n'
exit 0
SH
chmod +x ci/require-vars.sh

# ─── Разбор и проверка pipeline ───────────────────────────────────────
cat > ci/lint-gitlab-ci.py <<'PY'
"""Статические проверки .gitlab-ci.yml."""
from __future__ import annotations

import json
import sys
from pathlib import Path

import yaml

RESERVED = {"stages", "variables", "default", "include", "workflow"}


def jobs_of(data: dict) -> dict[str, dict]:
    return {k: v for k, v in data.items()
            if isinstance(v, dict) and not k.startswith(".") and k not in RESERVED}


def check(path: Path) -> list[tuple[str, str, str]]:
    data = yaml.safe_load(path.read_text())
    jobs = jobs_of(data)
    out: list[tuple[str, str, str]] = []

    stages = data.get("stages", [])
    out.append(("ок", "стадии", f"{len(stages)}: {', '.join(stages)}"))

    # 1. needs объявлены явно
    first_stage = stages[0] if stages else None
    without_needs = [n for n, j in jobs.items()
                     if "needs" not in j and j.get("stage") != first_stage]
    if without_needs:
        out.append(("ВАЖНО", "needs",
                    f"без needs: {', '.join(without_needs)} — ждут всю стадию"))
    else:
        out.append(("ок", "needs", "объявлены везде, кроме первой стадии"))

    # 2. cache не используется для передачи результата
    suspicious = []
    for name, job in jobs.items():
        cache = job.get("cache") or {}
        paths = cache.get("paths", []) if isinstance(cache, dict) else []
        for p in paths:
            if any(p.rstrip("/").endswith(x) for x in ("dist", "build", "out", "target")):
                suspicious.append(f"{name}: {p}")
    if suspicious:
        out.append(("КРИТ", "cache для результата",
                    f"{'; '.join(suspicious)} — нужен artifacts"))
    else:
        out.append(("ок", "cache", "используется только для ускорения"))

    # 3. Секреты не в аргументах команд
    raw = path.read_text()
    if "--password " in raw or "-p $" in raw or "-p ${" in raw:
        out.append(("КРИТ", "передача секрета",
                    "секрет в аргументе команды; нужен --password-stdin"))
    else:
        out.append(("ок", "передача секрета", "через stdin"))

    # 4. Публикация ограничена правилами
    for name, job in jobs.items():
        script = " ".join(str(s) for s in (job.get("script") or []))
        if "--push" in script or "docker push" in script:
            rules = job.get("rules")
            if not rules:
                out.append(("КРИТ", f"правила задачи {name}",
                            "публикует без rules — сработает на любой ветке"))
            elif not any("CI_DEFAULT_BRANCH" in str(r) or "CI_COMMIT_TAG" in str(r)
                         for r in rules):
                out.append(("ВАЖНО", f"правила задачи {name}",
                            "публикует, но условие не привязано к ветке или тегу"))
            else:
                out.append(("ок", f"правила задачи {name}",
                            "публикация только с ветки по умолчанию или тега"))

    # 5. rules завершаются when: never
    for name, job in jobs.items():
        rules = job.get("rules")
        if rules and not any(str(r.get("when")) == "never" for r in rules
                             if isinstance(r, dict)):
            out.append(("ЗАМЕЧ", f"rules задачи {name}",
                        "нет завершающего when: never"))

    # 6. Проверка переменных до их использования
    for name, job in jobs.items():
        before = " ".join(str(s) for s in (job.get("before_script") or []))
        script = " ".join(str(s) for s in (job.get("script") or []))
        uses_registry = "CI_REGISTRY_PASSWORD" in before + script
        if uses_registry:
            if "require-vars" in before:
                out.append(("ок", f"проверка переменных в {name}",
                            "выполняется до использования"))
            else:
                out.append(("ВАЖНО", f"проверка переменных в {name}",
                            "нет проверки; отказ придёт из глубины docker login"))

    # 7. Внешний кэш при dind
    for name, job in jobs.items():
        services = job.get("services") or []
        uses_dind = any("dind" in str(s) for s in services)
        extends = job.get("extends")
        if not uses_dind and extends:
            base = data.get(extends if isinstance(extends, str) else extends[0], {})
            uses_dind = any("dind" in str(s) for s in (base.get("services") or []))
        if uses_dind:
            script = " ".join(str(s) for s in (job.get("script") or []))
            if "cache-from" in script:
                out.append(("ок", f"кэш в {name}", "внешний кэш настроен"))
            else:
                out.append(("ВАЖНО", f"кэш в {name}",
                            "dind без внешнего кэша — сборка всегда холодная"))

    return out


def main(paths: list[str]) -> int:
    worst = 0
    summary: dict[str, dict[str, int]] = {}
    for p in paths:
        results = check(Path(p))
        print(f"\n  ── {p} ──")
        print(f"  {'уровень':<8} {'проверка':<30} сообщение")
        print("  " + "─" * 96)
        crit = warn = 0
        for level, name, message in results:
            if level == "КРИТ":
                crit += 1
            elif level == "ВАЖНО":
                warn += 1
            print(f"  {level:<8} {name:<30} {message}")
        print(f"\n  критично: {crit}, важно: {warn}")
        summary[p] = {"крит": crit, "важно": warn}
        worst = max(worst, 2 if crit else (1 if warn else 0))
    print()
    print(json.dumps(summary, ensure_ascii=False))
    return worst


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:] or [".gitlab-ci.yml"]))
PY

# ─── Заведомо плохой файл ─────────────────────────────────────────────
cat > bad-gitlab-ci.yml <<'EOF'
stages: [build, publish]

build:
  stage: build
  image: docker:28-cli
  services:
    - name: docker:28-dind
      alias: docker
  cache:
    paths: [dist/]
  script:
    - docker build -t app:latest .
    - python -m build

publish:
  stage: publish
  image: docker:28-cli
  services:
    - name: docker:28-dind
      alias: docker
  script:
    - docker login -u user -p $REGISTRY_TOKEN
    - docker push app:latest
EOF

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

printf '\n═══ Требования 1-2: структура и needs ═══\n'
python3 - <<'PY'
import yaml
from pathlib import Path

data = yaml.safe_load(Path(".gitlab-ci.yml").read_text())
stages = data["stages"]
reserved = {"stages", "variables", "default"}
jobs = {k: v for k, v in data.items()
        if isinstance(v, dict) and not k.startswith(".") and k not in reserved}

print(f"    стадий: {len(stages)} — {', '.join(stages)}")
print(f"    задач:  {len(jobs)}\n")
print(f"    {'задача':<14} {'стадия':<10} {'needs':<26} {'artifacts':<11} rules")
print("    " + "─" * 76)
for name, job in jobs.items():
    needs = job.get("needs")
    needs_s = ",".join(needs) if isinstance(needs, list) else (needs or "—")
    print(f"    {name:<14} {job.get('stage','—'):<10} {needs_s:<26} "
          f"{'да' if 'artifacts' in job else 'нет':<11} "
          f"{'да' if 'rules' in job else 'нет'}")

first = stages[0]
no_needs = [n for n, j in jobs.items() if "needs" not in j and j.get("stage") != first]
print(f"\n    задач без needs (кроме первой стадии): {len(no_needs)}")
print("    Без needs задача ждёт завершения ВСЕЙ предыдущей стадии,")
print("    а не только тех задач, от которых зависит.")
PY
no_needs_count="$(python3 -c "
import yaml
from pathlib import Path
d = yaml.safe_load(Path('.gitlab-ci.yml').read_text())
stages = d['stages']
reserved = {'stages','variables','default'}
jobs = {k:v for k,v in d.items() if isinstance(v,dict) and not k.startswith('.') and k not in reserved}
print(len([n for n,j in jobs.items() if 'needs' not in j and j.get('stage') != stages[0]]))
")"
[ "${no_needs_count:-9}" -eq 0 ] \
    && ok "needs объявлены везде, кроме первой стадии" \
    || bad "задач без needs: $no_needs_count"

printf '\n═══ Требование 3: cache и artifacts ═══\n'
python3 - <<'PY'
import yaml
from pathlib import Path

d = yaml.safe_load(Path(".gitlab-ci.yml").read_text())
reserved = {"stages", "variables", "default"}
jobs = {k: v for k, v in d.items()
        if isinstance(v, dict) and not k.startswith(".") and k not in reserved}

print(f"    {'задача':<14} {'cache':<24} {'artifacts':<24} назначение")
print("    " + "─" * 84)
for name, job in jobs.items():
    cache = job.get("cache") or {}
    cpaths = ",".join(cache.get("paths", [])) if isinstance(cache, dict) else "—"
    art = job.get("artifacts") or {}
    apaths = ",".join(art.get("paths", [])) if art else "—"
    purpose = []
    if cpaths and cpaths != "—":
        purpose.append("cache ускоряет")
    if apaths and apaths != "—":
        purpose.append("artifacts передаёт")
    print(f"    {name:<14} {cpaths or '—':<24} {apaths or '—':<24} "
          f"{'; '.join(purpose) or '—'}")

print()
print("    НЕВЕРНОЕ использование и его симптом:")
print("      cache: paths: [dist/]  →  публикация иногда работает, иногда падает")
print("      причина: гарантии наличия кэша нет")
print("      исправление: artifacts: paths: [dist/]")
print()
print("    Правило: если без файлов задача НЕ РАБОТАЕТ — это artifacts.")
PY
ok "cache используется для ускорения, artifacts — для передачи результата"

printf '\n═══ Требование 4: способ сборки ═══\n'
python3 - <<'PY'
ROWS = [
    ("Docker-in-Docker", "требует privileged", "полная", "НЕТ",
     "общий runner, важна изоляция"),
    ("Сокет runner'а", "не требует", "НЕТ", "есть",
     "выделенный runner, доверенные задачи"),
    ("kaniko / buildah", "не требует", "полная", "через внешний",
     "нельзя дать привилегии"),
]
print(f"    {'способ':<20} {'привилегии':<20} {'изоляция':<10} "
      f"{'кэш слоёв':<14} когда")
print("    " + "─" * 92)
for row in ROWS:
    print(f"    {row[0]:<20} {row[1]:<20} {row[2]:<10} {row[3]:<14} {row[4]}")
print()
print("    ВЫБРАН: Docker-in-Docker")
print("    Обоснование: изоляция задач важнее кэша слоёв.")
print("    Сокет runner'а равносилен root на host: задача может смонтировать")
print("    корень host и прочитать секреты чужих задач ([урок 12.2]).")
print()
print("    Цена выбора: локального кэша не бывает никогда,")
print("    поэтому внешний кэш type=registry ОБЯЗАТЕЛЕН.")
PY
has_cache="$(grep -c 'cache-from' .gitlab-ci.yml || echo 0)"
printf '    строк с cache-from в файле: %s\n' "$has_cache"
[ "${has_cache:-0}" -ge 2 ] \
    && ok "выбран dind; внешний кэш настроен, как того требует выбор" \
    || bad "cache-from встречается $has_cache раз"

printf '\n═══ Требование 5: проверка защищённых переменных ═══\n'
printf '  случай «переменные заданы»:\n'
CI_REGISTRY="registry.example.com" \
CI_REGISTRY_USER="gitlab-ci-token" \
CI_REGISTRY_PASSWORD="токен-длиной-больше-восьми" \
    ./ci/require-vars.sh CI_REGISTRY CI_REGISTRY_USER CI_REGISTRY_PASSWORD
ok_rc=$?

printf '\n  случай «переменная protected, ветка не защищена»:\n'
CI_REGISTRY="registry.example.com" \
CI_REGISTRY_USER="gitlab-ci-token" \
CI_REGISTRY_PASSWORD="" \
    ./ci/require-vars.sh CI_REGISTRY CI_REGISTRY_USER CI_REGISTRY_PASSWORD
missing_rc=$?

printf '  коды возврата: заданы=%s пусто=%s\n' "$ok_rc" "$missing_rc"
[ "$ok_rc" -eq 0 ] && [ "$missing_rc" -eq 1 ] \
    && ok "проверка даёт понятное сообщение вместо отказа в глубине docker login" \
    || bad "коды: $ok_rc и $missing_rc"

printf '\n═══ Проверка pipeline на двух файлах ═══\n'
python3 ci/lint-gitlab-ci.py .gitlab-ci.yml bad-gitlab-ci.yml > lint.log 2>&1
sed -n '/── .gitlab-ci.yml/,/критично/p' lint.log | sed 's/^/  /'
sed -n '/── bad-gitlab-ci.yml/,/критично/p' lint.log | sed 's/^/  /'
lint_json="$(tail -1 lint.log)"
good_crit="$(echo "$lint_json" | python3 -c "
import json,sys; print(json.load(sys.stdin)['.gitlab-ci.yml']['крит'])")"
bad_crit="$(echo "$lint_json" | python3 -c "
import json,sys; print(json.load(sys.stdin)['bad-gitlab-ci.yml']['крит'])")"
printf '  критичных: правильный=%s плохой=%s\n' "$good_crit" "$bad_crit"
[ "${good_crit:-9}" -eq 0 ] && [ "${bad_crit:-0}" -ge 2 ] \
    && ok "проверка чиста на правильном файле и находит нарушения на плохом" \
    || bad "крит: правильный=$good_crit плохой=$bad_crit"

printf '\n═══ Требование 6: что перенеслось, что изменилось ═══\n'
python3 - <<'PY'
import json

ITEMS = [
    ("Порядок и зависимости", "как есть", "needs: → needs: + stages"),
    ("Логика проверок", "как есть", "run: ./ci/x.sh → script: [./ci/x.sh]"),
    ("Матрица версий", "как есть", "strategy.matrix → parallel.matrix"),
    ("Условия запуска", "как есть", "if: → rules:"),
    ("Артефакты", "как есть", "upload-artifact → artifacts:"),
    ("Кэш зависимостей", "как есть", "actions/cache → cache:"),
    ("Кэш сборки образа", "МЕНЯЕТСЯ", "type=gha → type=registry"),
    ("Сборка образа", "МЕНЯЕТСЯ", "build-push-action → dind/сокет/kaniko"),
    ("Права токена", "МЕНЯЕТСЯ", "permissions: → настройки проекта"),
    ("Переиспользуемые модули", "МЕНЯЕТСЯ", "uses: → include:/extends:"),
    ("Секреты", "МЕНЯЕТСЯ", "secrets. → переменные protected/masked"),
]
same = [i for i in ITEMS if i[1] == "как есть"]
changed = [i for i in ITEMS if i[1] != "как есть"]

print(f"    {'элемент':<28} {'перенос':<12} что именно")
print("    " + "─" * 84)
for name, kind, note in ITEMS:
    print(f"    {name:<28} {kind:<12} {note}")
print()
print(f"    механически: {len(same)} из {len(ITEMS)}")
print(f"    с изменениями: {len(changed)} из {len(ITEMS)}")
print()
print("    Шесть механических переносов — прямое следствие того,")
print("    что логика проверок вынесена в скрипты ci/*.sh.")
print("    Будь она в шагах YAML, механически не перенеслось бы ничего.")
print()
print(json.dumps({"как_есть": len(same), "меняется": len(changed)},
                 ensure_ascii=False))
PY
ok "перечень составлен; названо, что именно меняется в каждом случае"

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

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

═══ Требования 1-2: структура и needs ═══
    стадий: 4 — check, test, build, publish
    задач:  7

    задача         стадия     needs                      artifacts   rules
    ────────────────────────────────────────────────────────────────────────────
    format         check      —                          нет         нет
    lint           check      —                          нет         нет
    types          check      —                          нет         нет
    unit-tests     test       format,lint,types          да          нет
    build          build      unit-tests                 да          нет
    scan           build      build                      да          нет
    publish        publish    build                      нет         да

    задач без needs (кроме первой стадии): 0
    Без needs задача ждёт завершения ВСЕЙ предыдущей стадии,
    а не только тех задач, от которых зависит.
  ✓ needs объявлены везде, кроме первой стадии

═══ Требование 3: cache и artifacts ═══
    задача         cache                    artifacts                назначение
    ────────────────────────────────────────────────────────────────────────────────────
    format         .pip-cache               —                        cache ускоряет
    lint           .pip-cache               —                        cache ускоряет
    types          .pip-cache               —                        cache ускоряет
    unit-tests     .pip-cache               junit-$PY_VERSION.xml    cache ускоряет; artifacts передаёт
    build          —                        image.tar                artifacts передаёт
    scan           —                        scan-reports/            artifacts передаёт
    publish        —                        —                        —

    НЕВЕРНОЕ использование и его симптом:
      cache: paths: [dist/]  →  публикация иногда работает, иногда падает
      причина: гарантии наличия кэша нет
      исправление: artifacts: paths: [dist/]

    Правило: если без файлов задача НЕ РАБОТАЕТ — это artifacts.
  ✓ cache используется для ускорения, artifacts — для передачи результата

═══ Требование 4: способ сборки ═══
    способ               привилегии           изоляция   кэш слоёв      когда
    ────────────────────────────────────────────────────────────────────────────────────────────
    Docker-in-Docker     требует privileged   полная     НЕТ            общий runner, важна изоляция
    Сокет runner'а       не требует           НЕТ        есть           выделенный runner, доверенные задачи
    kaniko / buildah     не требует           полная     через внешний  нельзя дать привилегии

    ВЫБРАН: Docker-in-Docker
    Обоснование: изоляция задач важнее кэша слоёв.
    Сокет runner'а равносилен root на host: задача может смонтировать
    корень host и прочитать секреты чужих задач ([урок 12.2]).

    Цена выбора: локального кэша не бывает никогда,
    поэтому внешний кэш type=registry ОБЯЗАТЕЛЕН.
    строк с cache-from в файле: 2
  ✓ выбран dind; внешний кэш настроен, как того требует выбор

═══ Требование 5: проверка защищённых переменных ═══
  случай «переменные заданы»:
  ✓ CI_REGISTRY задана (22 символов)
  ✓ CI_REGISTRY_USER задана (15 символов)
  ✓ CI_REGISTRY_PASSWORD задана (26 символов)
  все переменные на месте

  случай «переменная protected, ветка не защищена»:
  ✓ CI_REGISTRY задана (22 символов)
  ✓ CI_REGISTRY_USER задана (15 символов)
  ✗ CI_REGISTRY_PASSWORD пуста

  Переменных не хватает. Вероятные причины, по убыванию частоты:

    1. Переменная protected, а ветка не защищена.
       Признак: pipeline работает на main и падает на ветке.
       Это НЕ ошибка настройки — так и задумано: секрет публикации
       не должен быть доступен задаче из произвольной ветки.
    ...
  коды возврата: заданы=0 пусто=1
  ✓ проверка даёт понятное сообщение вместо отказа в глубине docker login

═══ Проверка pipeline на двух файлах ═══
  ── .gitlab-ci.yml ──
  уровень  проверка                       сообщение
  ────────────────────────────────────────────────────────────────────────────────────────────────
  ок       стадии                         4: check, test, build, publish
  ок       needs                          объявлены везде, кроме первой стадии
  ок       cache                          используется только для ускорения
  ок       передача секрета               через stdin
  ок       правила задачи publish         публикация только с ветки по умолчанию или тега
  ок       проверка переменных в publish  выполняется до использования
  ок       кэш в build                    внешний кэш настроен
  ок       кэш в publish                  внешний кэш настроен

  критично: 0, важно: 0
  ── bad-gitlab-ci.yml ──
  ок       стадии                         2: build, publish
  ВАЖНО    needs                          без needs: publish — ждут всю стадию
  КРИТ     cache для результата           build: dist/ — нужен artifacts
  КРИТ     передача секрета               секрет в аргументе команды; нужен --password-stdin
  КРИТ     правила задачи publish         публикует без rules — сработает на любой ветке
  ВАЖНО    кэш в build                    dind без внешнего кэша — сборка всегда холодная

  критично: 3, важно: 2
  критичных: правильный=0 плохой=3
  ✓ проверка чиста на правильном файле и находит нарушения на плохом

═══ Требование 6: что перенеслось, что изменилось ═══
    элемент                      перенос      что именно
    ────────────────────────────────────────────────────────────────────────────────────
    Порядок и зависимости        как есть     needs: → needs: + stages
    Логика проверок              как есть     run: ./ci/x.sh → script: [./ci/x.sh]
    Матрица версий               как есть     strategy.matrix → parallel.matrix
    Условия запуска              как есть     if: → rules:
    Артефакты                    как есть     upload-artifact → artifacts:
    Кэш зависимостей             как есть     actions/cache → cache:
    Кэш сборки образа            МЕНЯЕТСЯ     type=gha → type=registry
    Сборка образа                МЕНЯЕТСЯ     build-push-action → dind/сокет/kaniko
    Права токена                 МЕНЯЕТСЯ     permissions: → настройки проекта
    Переиспользуемые модули      МЕНЯЕТСЯ     uses: → include:/extends:
    Секреты                      МЕНЯЕТСЯ     secrets. → переменные protected/masked

    механически: 6 из 11
    с изменениями: 5 из 11

    Шесть механических переносов — прямое следствие того,
    что логика проверок вынесена в скрипты ci/*.sh.
    Будь она в шагах YAML, механически не перенеслось бы ничего.
  ✓ перечень составлен; названо, что именно меняется в каждом случае

═══ ИТОГ ═══
  все требования выполнены
  примечание: pipeline в GitLab CI не запускался — платформа недоступна