16.2. GitHub Actions

name: CI

on:
  push:
    branches: ["**"]
  pull_request:
  schedule:
    - cron: "0 6 * * 1"

permissions:
  contents: read

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  fast-checks:
    runs-on: ubuntu-latest
    steps: [...]

docker push ghcr.io/org/app:git-a3f2c1b
denied: permission_denied: write_package

permissions:
  contents: read
  packages: write        # ← необходимо для публикации в ghcr.io

# ОПАСНО: не делать так
on: pull_request_target
jobs:
  build:
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha }}   # ← код из PR
      - run: make build                                    # ← с секретами

- name: Собрать для тестов
  run: docker build -t app:test .
- name: Тесты
  run: docker run --rm app:test pytest
- name: Собрать и опубликовать
  uses: docker/build-push-action@v6      # ← ВТОРАЯ сборка
  with:
    push: true

- name: Сборка
  uses: docker/build-push-action@v6
  with:
    load: true                # образ попадает в локальный демон
    tags: app:candidate
    push: false

- name: Проверки образа
  run: ./validate.sh app:candidate

- name: Публикация
  uses: docker/build-push-action@v6
  with:
    push: true
    tags: ${{ steps.meta.outputs.tags }}

- run: echo "$TOKEN" | docker login ghcr.io -u "$USER" --password-stdin
  env:
    TOKEN: ${{ secrets.GITHUB_TOKEN }}

- uses: actions/checkout@v4                              # подвижный тег
- uses: actions/checkout@<полный-sha-коммита>            # закреплено

- uses: actions/setup-python@v5
  with:
    python-version: "3.13"
    cache: pip
    cache-dependency-path: requirements*.txt

strategy:
  fail-fast: false
  matrix:
    python: ["3.12", "3.13"]

mkdir -p /tmp/gha && cd /tmp/gha
mkdir -p .github/workflows src tests

cat > .github/workflows/ci.yaml <<'EOF'
name: CI

on:
  push:
    branches: ["**"]
    tags: ["v*"]
  pull_request:
  schedule:
    # Сканирование опубликованных образов: уязвимость появляется
    # после сборки, когда код уже не меняется
    - cron: "0 6 * * 1"

# Права по умолчанию — минимальные. Задачи расширяют их точечно.
permissions:
  contents: read

# Новый push в ту же ветку отменяет предыдущий запуск
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  # ── Быстрые проверки: идут параллельно, ВСЕ доводятся до конца ──
  fast-checks:
    name: ${{ matrix.check }}
    runs-on: ubuntu-latest
    strategy:
      # Отказ одной проверки не отменяет остальные:
      # разработчик увидит все проблемы разом
      fail-fast: false
      matrix:
        check: [format, lint, types]
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
          cache: pip
          cache-dependency-path: requirements*.txt

      - name: Установка инструментов
        run: pip install --quiet -r requirements-dev.txt

      - name: Проверка форматирования
        if: matrix.check == 'format'
        run: ruff format --check .

      - name: Линтинг
        if: matrix.check == 'lint'
        run: ruff check .

      - name: Проверка типов
        if: matrix.check == 'types'
        run: mypy src/

  # ── Unit-тесты на матрице версий ──
  unit-tests:
    needs: fast-checks
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python: ["3.12", "3.13"]
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python }}
          cache: pip
          cache-dependency-path: requirements*.txt

      - run: pip install --quiet -r requirements.txt -r requirements-dev.txt

      - name: Unit-тесты
        run: pytest tests/unit -q --junit-xml=junit-${{ matrix.python }}.xml

      - name: Сохранить отчёт
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: junit-${{ matrix.python }}
          path: junit-${{ matrix.python }}.xml

  # ── Сборка образа ОДИН раз, проверки на нём же ──
  build:
    needs: unit-tests
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write        # без этого docker push даст permission_denied
    outputs:
      digest: ${{ steps.push.outputs.digest }}
      tags: ${{ steps.meta.outputs.tags }}
    steps:
      - uses: actions/checkout@v4

      - uses: docker/setup-buildx-action@v3

      - name: Определить теги
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=sha,prefix=git-,format=short
            type=ref,event=branch
            type=semver,pattern={{version}}
            type=raw,value=latest,enable={{is_default_branch}}

      # Сборка БЕЗ публикации: образ попадает в локальный демон
      - name: Сборка образа
        uses: docker/build-push-action@v6
        with:
          context: .
          target: production
          load: true
          push: false
          tags: candidate:local
          cache-from: type=gha
          cache-to: type=gha,mode=max

      - name: Валидация образа
        run: ./ci/validate-image.sh candidate:local

      - name: Integration-тесты на СОБРАННОМ образе
        run: ./ci/integration-tests.sh candidate:local

      - name: Вход в registry
        if: github.event_name != 'pull_request'
        run: echo "$TOKEN" | docker login "$REGISTRY" -u "$ACTOR" --password-stdin
        env:
          TOKEN: ${{ secrets.GITHUB_TOKEN }}
          ACTOR: ${{ github.actor }}
          REGISTRY: ${{ env.REGISTRY }}

      # Вторая сборка полностью из кэша: те же слои, тот же digest
      - name: Публикация
        id: push
        if: github.event_name != 'pull_request'
        uses: docker/build-push-action@v6
        with:
          context: .
          target: production
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
          provenance: true
          sbom: true

      - name: Выход из registry
        if: always()
        run: docker logout "$REGISTRY" || true
        env:
          REGISTRY: ${{ env.REGISTRY }}

  # ── Сканирование: не блокирует при отсутствии исправления ──
  scan:
    needs: build
    if: github.event_name != 'push' || github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: read
      security-events: write
    steps:
      - uses: actions/checkout@v4
      - name: Сканирование
        run: ./ci/scan.sh "${{ needs.build.outputs.digest }}"
EOF

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

wf = yaml.safe_load(Path(".github/workflows/ci.yaml").read_text())
jobs = wf["jobs"]
print(f"  задач: {len(jobs)}")
for name, job in jobs.items():
    needs = job.get("needs")
    needs_s = ", ".join(needs) if isinstance(needs, list) else (needs or "—")
    perms = job.get("permissions", "наследует")
    n_steps = len(job.get("steps", []))
    print(f"    {name:<14} шагов {n_steps:<3} зависит от: {needs_s:<14} права: {perms}")
PY

═══ проверка синтаксиса ═══
  задач: 4
    fast-checks    шагов 6   зависит от: —              права: наследует
    unit-tests     шагов 5   зависит от: fast-checks    права: наследует
    build          шагов 8   зависит от: unit-tests     права: {'contents': 'read', 'packages': 'write'}
    scan           шагов 2   зависит от: build          права: {'contents': 'read', 'packages': 'read', 'security-events': 'write'}

cd /tmp/gha
cat > permissions.py <<'PY'
"""Права GITHUB_TOKEN: пересечение трёх ограничений.

Блок permissions в workflow может только СУЗИТЬ права,
но не расширить их сверх настроек репозитория и организации.
"""
from __future__ import annotations

CASES = [
    {
        "случай": "по умолчанию, без блока permissions",
        "организация": "разрешено",
        "репозиторий": "только чтение",
        "workflow": "не объявлен",
        "итог": "чтение",
    },
    {
        "случай": "packages: write объявлен",
        "организация": "разрешено",
        "репозиторий": "только чтение",
        "workflow": "packages: write",
        "итог": "чтение",
    },
    {
        "случай": "репозиторий разрешает запись",
        "организация": "разрешено",
        "репозиторий": "чтение и запись",
        "workflow": "packages: write",
        "итог": "запись пакетов",
    },
    {
        "случай": "организация запретила",
        "организация": "запрещено",
        "репозиторий": "чтение и запись",
        "workflow": "packages: write",
        "итог": "чтение",
    },
    {
        "случай": "workflow сузил намеренно",
        "организация": "разрешено",
        "репозиторий": "чтение и запись",
        "workflow": "contents: read",
        "итог": "только contents: read",
    },
]


def main() -> None:
    print(f"  {'случай':<36} {'орг.':<12} {'репозиторий':<18} "
          f"{'workflow':<18} итог")
    print("  " + "─" * 104)
    for c in CASES:
        print(f"  {c['случай']:<36} {c['организация']:<12} "
              f"{c['репозиторий']:<18} {c['workflow']:<18} {c['итог']}")

    print()
    print("  Строка 2 — источник отказа «denied: permission_denied».")
    print("  Блок permissions объявлен верно, но настройка репозитория")
    print("  ограничивает токен чтением. permissions СУЖАЕТ, а не расширяет.")
    print()
    print("  Порядок диагностики:")
    print("    1. блок permissions в workflow и в задаче")
    print("    2. настройки репозитория: Actions → General → Workflow permissions")
    print("    3. настройки организации")


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

echo "═══ права токена ═══"
python3 permissions.py

═══ права токена ═══
  случай                               орг.         репозиторий        workflow           итог
  ────────────────────────────────────────────────────────────────────────────────────────────────────────
  по умолчанию, без блока permissions  разрешено    только чтение      не объявлен        чтение
  packages: write объявлен             разрешено    только чтение      packages: write    чтение
  репозиторий разрешает запись         разрешено    чтение и запись    packages: write    запись пакетов
  организация запретила                запрещено    чтение и запись    packages: write    чтение
  workflow сузил намеренно             разрешено    чтение и запись    contents: read     только contents: read

  Строка 2 — источник отказа «denied: permission_denied».
  Блок permissions объявлен верно, но настройка репозитория
  ограничивает токен чтением. permissions СУЖАЕТ, а не расширяет.

  Порядок диагностики:
    1. блок permissions в workflow и в задаче
    2. настройки репозитория: Actions → General → Workflow permissions
    3. настройки организации

cd /tmp/gha
mkdir -p src tests/unit ci

cat > requirements.txt <<'EOF'
click==8.3.0
EOF
cat > requirements-dev.txt <<'EOF'
pytest==9.1.1
ruff==0.16.0
mypy==1.19.1
EOF

cat > src/__init__.py <<'PY'
PY
cat > src/app.py <<'PY'
"""Приложение для демонстрации pipeline."""
from __future__ import annotations

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

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


class Handler(http.server.BaseHTTPRequestHandler):
    def do_GET(self) -> None:
        body = json.dumps({"status": "ok", "uid": os.getuid()}).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)
    _stop.set()


def main() -> int:
    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}", flush=True)
    _stop.wait()
    server.shutdown()
    return 0


if __name__ == "__main__":
    sys.exit(main())
PY

cat > Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim AS base
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
WORKDIR /app
COPY requirements.txt .
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install --no-cache-dir -r requirements.txt

FROM base AS production
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/')"]
ENTRYPOINT ["python", "-m", "src.app"]
EOF

echo "═══ сборка дважды: тот же контекст, тот же кэш ═══"
docker build -q --target production -t twice:first . > /dev/null
first="$(docker inspect twice:first --format '{{.Id}}')"
docker build -q --target production -t twice:second . > /dev/null
second="$(docker inspect twice:second --format '{{.Id}}')"

printf '  первая сборка:  %s\n' "${first:0:32}..."
printf '  вторая сборка:  %s\n' "${second:0:32}..."
if [ "$first" = "$second" ]; then
    echo "  ✓ идентичны — вторая сборка полностью из кэша"
else
    echo "  ✗ различаются"
fi

echo "═══ что бывает без кэша между сборками ═══"
cat <<'TXT'
  Две сборки БЕЗ общего кэша могут дать разные образы:

    базовый образ обновился между сборками
    зависимость без закреплённой версии подтянулась другая
    метка времени попала в слой

  Поэтому схема «собрать для тестов, потом собрать для публикации»
  публикует НЕ ТО, что проверяли.

  Правильно: собрать один раз с load: true, проверить,
  затем опубликовать с тем же cache-from — вторая сборка
  экспортирует уже готовый результат.
TXT
docker rmi -f twice:first twice:second > /dev/null 2>&1

═══ сборка дважды: тот же контекст, тот же кэш ═══
  первая сборка:  sha256:8f3a2b1c4d5e6f7a8b9c0d1e2f3a...
  вторая сборка:  sha256:8f3a2b1c4d5e6f7a8b9c0d1e2f3a...
  ✓ идентичны — вторая сборка полностью из кэша
═══ что бывает без кэша между сборками ═══
  Две сборки БЕЗ общего кэша могут дать разные образы:

    базовый образ обновился между сборками
    зависимость без закреплённой версии подтянулась другая
    метка времени попала в слой

  Поэтому схема «собрать для тестов, потом собрать для публикации»
  публикует НЕ ТО, что проверяли.
  ...

cd /tmp/gha
cat > masking.py <<'PY'
"""Что маскируется в логах, а что нет.

Механизм маскирования ищет ТОЧНОЕ совпадение строки секрета.
Любое преобразование обходит его.
"""
from __future__ import annotations

import base64

SECRET = "ghp_ExampleTokenValue1234567890abcd"


def masked(text: str) -> str:
    """Имитация маскирования: замена точных вхождений."""
    return text.replace(SECRET, "***")


CASES = [
    ("echo $SECRET", SECRET),
    ("echo $SECRET | base64", base64.b64encode(SECRET.encode()).decode()),
    ("echo ${SECRET:0:12}", SECRET[:12]),
    ("echo $SECRET | rev", SECRET[::-1]),
    ("echo $SECRET | tr a-z A-Z", SECRET.upper()),
    ("printf '%s\\n%s' ${SECRET:0:16} ${SECRET:16}", f"{SECRET[:16]}\n{SECRET[16:]}"),
    ("curl -H \"Authorization: Bearer $SECRET\" -v", f"Authorization: Bearer {SECRET}"),
]


def main() -> None:
    print(f"  {'что выполняется':<44} {'замаскировано':<15} что видно в логе")
    print("  " + "─" * 100)
    leaked = 0
    for command, output in CASES:
        shown = masked(output)
        hidden = SECRET not in shown and shown != output
        if not hidden and SECRET not in output:
            # Преобразованный секрет: маскирование не сработало
            status = "НЕТ"
            leaked += 1
        elif "***" in shown:
            status = "да"
        else:
            status = "НЕТ"
            leaked += 1
        preview = shown.replace("\n", "\\n")[:40]
        print(f"  {command:<44} {status:<15} {preview}")

    print()
    print(f"  обошли маскирование: {leaked} из {len(CASES)}")
    print()
    print("  Маскирование — ПОСЛЕДНИЙ рубеж, а не защита.")
    print("  Секрет не должен попадать в вывод вовсе:")
    print("    echo \"$TOKEN\" | docker login -u \"$USER\" --password-stdin")
    print("    (ни в командной строке, ни в выводе)")


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

echo "═══ что обходит маскирование ═══"
python3 masking.py

═══ что обходит маскирование ═══
  что выполняется                              замаскировано   что видно в логе
  ────────────────────────────────────────────────────────────────────────────────────────────────────
  echo $SECRET                                 да              ***
  echo $SECRET | base64                        НЕТ             Z2hwX0V4YW1wbGVUb2tlblZhbHVlMTIzNDU2Nz
  echo ${SECRET:0:12}                          НЕТ             ghp_ExampleT
  echo $SECRET | rev                           НЕТ             dcba0987654321eulaVnekoTelpmaxE_phg
  echo $SECRET | tr a-z A-Z                    НЕТ             GHP_EXAMPLETOKENVALUE1234567890ABCD
  printf '%s\n%s' ${SECRET:0:16} ${SECRET:16}  НЕТ             ghp_ExampleToke\nnValue1234567890abcd
  curl -H "Authorization: Bearer $SECRET" -v   да              Authorization: Bearer ***

  обошли маскирование: 5 из 7
  ...

cd /tmp/gha
cat > pin-actions.py <<'PY'
"""Проверка закрепления версий действий в workflow.

Тег вида @v4 — подвижный указатель: его содержимое меняется.
Действие выполняется в вашем окружении с вашими секретами.
"""
from __future__ import annotations

import json
import re
import sys
from pathlib import Path

USES = re.compile(r"^\s*-?\s*uses:\s*([^\s#]+)")
SHA = re.compile(r"^[0-9a-f]{40}$")


def classify(ref: str) -> tuple[str, str]:
    if "@" not in ref:
        return "БЕЗ ВЕРСИИ", "выполнится ветка по умолчанию"
    action, version = ref.rsplit("@", 1)
    if SHA.match(version):
        return "закреплено", "содержимое неизменно"
    if re.fullmatch(r"v\d+\.\d+\.\d+", version):
        return "частично", "тег может быть переставлен"
    if re.fullmatch(r"v\d+", version):
        return "подвижное", "содержимое меняется при каждом выпуске"
    return "подвижное", "ветка или произвольный тег"


def main(path: str) -> int:
    text = Path(path).read_text()
    refs = [m.group(1) for m in (USES.match(line) for line in text.splitlines()) if m]

    print(f"  {'действие':<44} {'статус':<14} следствие")
    print("  " + "─" * 100)
    pinned = 0
    for ref in refs:
        status, note = classify(ref)
        if status == "закреплено":
            pinned += 1
        print(f"  {ref:<44} {status:<14} {note}")

    print()
    print(f"  закреплено по SHA: {pinned} из {len(refs)}")
    print()
    print("  Закрепление:")
    print("    - uses: actions/checkout@<40-символьный-sha>  # v4.2.2")
    print("  Комментарий с версией нужен людям; SHA — машине.")
    print()
    print("  Обновление выполняет бот зависимостей: он создаёт")
    print("  pull request со сменой SHA, и изменение видно в диффе.")
    return 0 if pinned == len(refs) else 1


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else ".github/workflows/ci.yaml"))
PY

echo "═══ проверка закрепления ═══"
python3 pin-actions.py .github/workflows/ci.yaml || true

═══ проверка закрепления ═══
  действие                                     статус         следствие
  ────────────────────────────────────────────────────────────────────────────────────────────────────
  actions/checkout@v4                          подвижное      содержимое меняется при каждом выпуске
  actions/setup-python@v5                      подвижное      содержимое меняется при каждом выпуске
  actions/checkout@v4                          подвижное      содержимое меняется при каждом выпуске
  actions/setup-python@v5                      подвижное      содержимое меняется при каждом выпуске
  actions/upload-artifact@v4                   подвижное      содержимое меняется при каждом выпуске
  actions/checkout@v4                          подвижное      содержимое меняется при каждом выпуске
  docker/setup-buildx-action@v3                подвижное      содержимое меняется при каждом выпуске
  docker/metadata-action@v5                    подвижное      содержимое меняется при каждом выпуске
  docker/build-push-action@v6                  подвижное      содержимое меняется при каждом выпуске
  docker/build-push-action@v6                  подвижное      содержимое меняется при каждом выпуске
  actions/checkout@v4                          подвижное      содержимое меняется при каждом выпуске

  закреплено по SHA: 0 из 11
  ...

cd /tmp/gha
cat > ci/validate-image.sh <<'SH'
#!/usr/bin/env bash
# Валидация собранного образа перед публикацией ([урок 15.5]).
set -uo pipefail

IMAGE="${1:?укажите образ}"
failures=0
pass() { printf '  ✓ %s\n' "$1"; }
fail() { printf '  ✗ %s\n' "$1"; failures=$((failures + 1)); }

printf '\n  Валидация: %s\n\n' "$IMAGE"

user="$(docker inspect "$IMAGE" --format '{{.Config.User}}')"
case "$user" in
    ""|0|root) fail "USER не задан или root" ;;
    *)         pass "USER: $user" ;;
esac

form="$(docker inspect "$IMAGE" --format '{{json .Config.Entrypoint}}' | python3 -c "
import json, sys
v = json.load(sys.stdin) or []
print('shell' if len(v) >= 2 and v[0] in ('/bin/sh','sh','/bin/bash') and v[1] == '-c'
      else ('exec' if v else 'none'))
")"
[ "$form" = "shell" ] && fail "ENTRYPOINT в shell form" || pass "ENTRYPOINT: $form form"

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

docker inspect "$IMAGE" --format '{{if .Config.Healthcheck}}y{{end}}' | grep -q y \
    && pass "healthcheck объявлен" || fail "healthcheck не объявлен"

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

cat > ci/integration-tests.sh <<'SH'
#!/usr/bin/env bash
# Integration-тесты на СОБРАННОМ образе, а не на пересобранном коде.
set -uo pipefail

IMAGE="${1:?укажите образ}"
NAME="ci-integration-$$"
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  Integration-тесты: %s\n\n' "$IMAGE"

docker run -d --name "$NAME" -p 0:8000 "$IMAGE" > /dev/null 2>&1 \
    || { fail "container не запустился"; exit 1; }

port="$(docker port "$NAME" 8000/tcp | head -1 | sed 's/.*://')"
for _ in $(seq 1 20); do
    curl -sf --max-time 2 "http://127.0.0.1:$port/" > /dev/null 2>&1 && break
    sleep 1
done

body="$(curl -sf --max-time 5 "http://127.0.0.1:$port/" 2>/dev/null || echo "")"
echo "$body" | grep -q '"status"' && pass "отвечает: $body" \
                                   || fail "не отвечает на порту $port"

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

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}')")"
python3 -c "import sys; sys.exit(0 if $secs < 3 else 1)" \
    && pass "завершился по SIGTERM за $secs с" \
    || fail "SIGTERM не обработан: $secs с"

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

cat > ci/scan.sh <<'SH'
#!/usr/bin/env bash
# Сканирование образа. Блокирует только при наличии исправления ([урок 16.1]).
set -uo pipefail

TARGET="${1:?укажите образ или digest}"

if ! command -v trivy > /dev/null 2>&1; then
    printf '\n  trivy НЕ УСТАНОВЛЕН — сканирование НЕ ВЫПОЛНЯЛОСЬ\n'
    printf '  команда для справки:\n'
    printf '    trivy image --severity HIGH,CRITICAL --ignore-unfixed %s\n\n' "$TARGET"
    exit 0
fi

printf '\n  Сканирование: %s\n\n' "$TARGET"
# --ignore-unfixed: находки без исправления не блокируют
trivy image --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 "$TARGET"
rc=$?
printf '\n  код возврата сканера: %s\n\n' "$rc"
exit "$rc"
SH
chmod +x ci/*.sh

echo "═══ сборка и проверки, как в pipeline ═══"
docker build -q --target production -t candidate:local . > /dev/null
./ci/validate-image.sh candidate:local || true
./ci/integration-tests.sh candidate:local || true
./ci/scan.sh candidate:local || true
docker rmi -f candidate:local > /dev/null 2>&1

═══ сборка и проверки, как в pipeline ═══

  Валидация: candidate:local

  ✓ USER: app
  ✓ ENTRYPOINT: exec form
  ✓ секретов в ENV нет
  ✓ healthcheck объявлен

  провалов: 0


  Integration-тесты: candidate:local

  ✓ отвечает: {"status": "ok", "uid": 10001}
  ✓ работает от UID 10001
  ✓ завершился по SIGTERM за 0.3 с

  провалов: 0


  trivy НЕ УСТАНОВЛЕН — сканирование НЕ ВЫПОЛНЯЛОСЬ
  команда для справки:
    trivy image --severity HIGH,CRITICAL --ignore-unfixed candidate:local

cd /tmp/gha
cat > lint-workflow.py <<'PY'
"""Статические проверки workflow до отправки в репозиторий."""
from __future__ import annotations

import json
import re
import sys
from pathlib import Path

import yaml


def check(path: Path) -> list[tuple[str, str, str]]:
    """Возвращает список (уровень, проверка, сообщение)."""
    raw = path.read_text()
    wf = yaml.safe_load(raw)
    out: list[tuple[str, str, str]] = []

    # PyYAML читает ключ `on` как True — это особенность YAML 1.1
    triggers = wf.get("on", wf.get(True, {}))

    # 1. pull_request_target с выполнением кода из PR
    if isinstance(triggers, dict) and "pull_request_target" in triggers:
        if re.search(r"pull_request\.head\.sha", raw):
            out.append(("КРИТ", "pull_request_target",
                        "выполняется код из PR в окружении с секретами"))
        else:
            out.append(("ВАЖНО", "pull_request_target",
                        "проверьте, что код из PR не выполняется"))
    else:
        out.append(("ок", "pull_request_target", "не используется"))

    # 2. Права токена объявлены
    if "permissions" not in wf:
        out.append(("ВАЖНО", "permissions",
                    "не объявлены на уровне workflow — действуют настройки репозитория"))
    else:
        out.append(("ок", "permissions", f"объявлены: {wf['permissions']}"))

    # 3. Публикация требует packages: write
    for name, job in wf.get("jobs", {}).items():
        steps = job.get("steps", [])
        pushes = any(
            (s.get("with") or {}).get("push") is True
            or "docker push" in str(s.get("run", ""))
            for s in steps
        )
        if pushes:
            perms = job.get("permissions", {}) or {}
            if perms.get("packages") == "write":
                out.append(("ок", f"права задачи {name}", "packages: write объявлено"))
            else:
                out.append(("КРИТ", f"права задачи {name}",
                            "публикует образ без packages: write"))

    # 4. Секреты не в командной строке
    if re.search(r"(--password|-p)\s+\$\{\{\s*secrets\.", raw):
        out.append(("КРИТ", "передача секрета",
                    "секрет в аргументе команды — попадёт в ps и журналы"))
    else:
        out.append(("ок", "передача секрета", "через stdin или окружение"))

    # 5. fail-fast в матрице
    for name, job in wf.get("jobs", {}).items():
        strategy = job.get("strategy")
        if strategy and "matrix" in strategy:
            if strategy.get("fail-fast") is False:
                out.append(("ок", f"матрица {name}", "fail-fast: false"))
            else:
                out.append(("ВАЖНО", f"матрица {name}",
                            "fail-fast по умолчанию true — отказ отменит остальные варианты"))

    # 6. Закрепление действий
    refs = re.findall(r"uses:\s*([^\s#]+)", raw)
    unpinned = [r for r in refs if not re.search(r"@[0-9a-f]{40}$", r)]
    if unpinned:
        out.append(("ВАЖНО", "закрепление действий",
                    f"не закреплено по SHA: {len(unpinned)} из {len(refs)}"))
    else:
        out.append(("ок", "закрепление действий", f"все {len(refs)} закреплены"))

    # 7. concurrency
    if "concurrency" in wf:
        out.append(("ок", "concurrency", "объявлена — лишние запуски отменяются"))
    else:
        out.append(("ЗАМЕЧ", "concurrency",
                    "не объявлена — параллельные push тратят исполнителей"))

    return out


def main(path: str) -> int:
    results = check(Path(path))
    print(f"  {'уровень':<8} {'проверка':<28} сообщение")
    print("  " + "─" * 96)
    crit = warn = 0
    for level, name, message in results:
        if level == "КРИТ":
            crit += 1
        elif level == "ВАЖНО":
            warn += 1
        print(f"  {level:<8} {name:<28} {message}")

    print()
    print(f"  критично: {crit}, важно: {warn}")
    print()
    print(json.dumps({"крит": crit, "важно": warn}, ensure_ascii=False))
    return 2 if crit else (1 if warn else 0)


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else ".github/workflows/ci.yaml"))
PY

echo "═══ проверка workflow ═══"
python3 lint-workflow.py .github/workflows/ci.yaml | head -20 || true

echo "═══ проверка на заведомо плохом workflow ═══"
cat > bad-workflow.yaml <<'EOF'
name: Bad CI

on: pull_request_target

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python: ["3.12", "3.13"]
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha }}
      - run: docker login -u user -p ${{ secrets.REGISTRY_TOKEN }}
      - run: docker push ghcr.io/org/app:latest
EOF
python3 lint-workflow.py bad-workflow.yaml | head -14 || true

cd /tmp && rm -rf /tmp/gha

═══ проверка workflow ═══
  уровень  проверка                     сообщение
  ────────────────────────────────────────────────────────────────────────────────────────────────
  ок       pull_request_target          не используется
  ок       permissions                  объявлены: {'contents': 'read'}
  ок       права задачи build           packages: write объявлено
  ок       передача секрета             через stdin или окружение
  ок       матрица fast-checks          fail-fast: false
  ок       матрица unit-tests           fail-fast: false
  ВАЖНО    закрепление действий         не закреплено по SHA: 11 из 11
  ок       concurrency                  объявлена — лишние запуски отменяются

  критично: 0, важно: 1

═══ проверка на заведомо плохом workflow ═══
  уровень  проверка                     сообщение
  ────────────────────────────────────────────────────────────────────────────────────────────────
  КРИТ     pull_request_target          выполняется код из PR в окружении с секретами
  ВАЖНО    permissions                  не объявлены на уровне workflow — действуют настройки репозитория
  КРИТ     права задачи build           публикует образ без packages: write
  КРИТ     передача секрета             секрет в аргументе команды — попадёт в ps и журналы
  ВАЖНО    матрица build                fail-fast по умолчанию true — отказ отменит остальные варианты
  ВАЖНО    закрепление действий         не закреплено по SHA: 1 из 1
  ЗАМЕЧ    concurrency                  не объявлена — параллельные push тратят исполнителей

  критично: 3, важно: 4

python3 -c "import yaml,sys; yaml.safe_load(open('.github/workflows/ci.yaml'))" && echo валиден
gh workflow list
gh run list --limit 5
gh run view --log-failed