11.5. Конфигурация и secrets

ARG PIP_INDEX_TOKEN                       # НЕ ДЕЛАЙТЕ ТАК
RUN pip install --index-url https://user:${PIP_INDEX_TOKEN}@pypi.example.com/simple mypackage

# syntax=docker/dockerfile:1
RUN --mount=type=secret,id=pip_token \
    PIP_TOKEN="$(cat /run/secrets/pip_token)" \
    pip install --index-url "https://user:${PIP_TOKEN}@pypi.example.com/simple" mypackage

docker build --secret id=pip_token,src=./token.txt -t app .

environment:
  POSTGRES_PASSWORD_FILE: /run/secrets/db_password

приложение ──запрос──► хранилище (Vault, Secrets Manager)
     │                      │
     │◄──── секрет ─────────┘
     │      TTL 1 час
     ▼
  использует, перезапрашивает до истечения

mkdir -p /tmp/secrets && cd /tmp/secrets

cat > Dockerfile.arg <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
ARG BUILD_TOKEN
# Секрет подставляется в команду — она сохранится в истории целиком
RUN echo "используем токен: ${BUILD_TOKEN}" > /tmp/build.log \
    && rm -f /tmp/build.log
CMD ["python", "-c", "print('готово')"]
EOF

TOKEN="glpat-SECRET-abcdef1234567890"
docker build -q -f Dockerfile.arg --build-arg BUILD_TOKEN="$TOKEN" -t leak:arg . > /dev/null

echo "═══ ищем токен в готовом образе ═══"
printf '  в docker history:  %s\n' \
    "$(docker history --no-trunc leak:arg 2>/dev/null | grep -c "$TOKEN" || echo 0)"
printf '  в image inspect:   %s\n' \
    "$(docker image inspect leak:arg 2>/dev/null | grep -c "$TOKEN" || echo 0)"

echo "═══ где именно ═══"
docker history --no-trunc leak:arg 2>/dev/null | grep -o "используем токен: [^ ]*" | head -1 | sed 's/^/  /'

echo "═══ файл при этом удалён ═══"
docker run --rm leak:arg sh -c 'ls /tmp/build.log 2>&1 | tail -1' | sed 's/^/  /'

═══ ищем токен в готовом образе ═══
  в docker history:  1
  в image inspect:   0
═══ где именно ═══
  используем токен: glpat-SECRET-abcdef1234567890
═══ файл при этом удалён ═══
  ls: cannot access '/tmp/build.log': No such file or directory

cd /tmp/secrets
cat > Dockerfile.env <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
ENV API_TOKEN=sk-live-SECRET-9876543210
CMD ["python", "-c", "import os; print('токен есть:', bool(os.environ.get('API_TOKEN')))"]
EOF

docker build -q -f Dockerfile.env -t leak:env . > /dev/null

echo "═══ где виден ═══"
printf '  docker image inspect (Config.Env): %s\n' \
    "$(docker image inspect leak:env --format '{{json .Config.Env}}' | grep -c 'sk-live-SECRET' || echo 0)"
printf '  docker history:                    %s\n' \
    "$(docker history --no-trunc leak:env | grep -c 'sk-live-SECRET' || echo 0)"
printf '  в любом запущенном container:      %s\n' \
    "$(docker run --rm leak:env sh -c 'env | grep -c API_TOKEN')"

echo "═══ значение целиком ═══"
docker image inspect leak:env --format '{{range .Config.Env}}{{println "  " .}}{{end}}' | grep API_TOKEN

═══ где виден ═══
  docker image inspect (Config.Env): 1
  docker history:                    1
  в любом запущенном container:      1
  ═══ значение целиком ═══
   API_TOKEN=sk-live-SECRET-9876543210

cd /tmp/secrets
echo -n "glpat-SECRET-abcdef1234567890" > token.txt
chmod 600 token.txt

cat > Dockerfile.secret <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim

# Секрет доступен только внутри этой инструкции и не попадает в слой.
# Значение читается ВНУТРИ RUN: если подставить его в команду, оно
# окажется в истории через переменную.
RUN --mount=type=secret,id=build_token \
    TOKEN="$(cat /run/secrets/build_token)" \
    && test -n "$TOKEN" \
    && echo "длина токена: ${#TOKEN}" \
    && echo "пакет установлен" > /opt/result.txt

CMD ["cat", "/opt/result.txt"]
EOF

docker build -q -f Dockerfile.secret --secret id=build_token,src=./token.txt \
    -t safe:secret . > /dev/null

echo "═══ ищем токен в образе ═══"
TOKEN="$(cat token.txt)"
printf '  в docker history:  %s\n' \
    "$(docker history --no-trunc safe:secret 2>/dev/null | grep -c "$TOKEN" || echo 0)"
printf '  в image inspect:   %s\n' \
    "$(docker image inspect safe:secret 2>/dev/null | grep -c "$TOKEN" || echo 0)"
printf '  в файловой системе: %s\n' \
    "$(docker run --rm safe:secret sh -c "grep -rl '$TOKEN' / 2>/dev/null | wc -l" 2>/dev/null || echo 0)"

echo "═══ что сохранилось в истории ═══"
docker history --no-trunc safe:secret 2>/dev/null | grep -o 'RUN.*build_token.*' | head -1 | cut -c1-100 | sed 's/^/  /'

echo "═══ результат сборки на месте ═══"
docker run --rm safe:secret | sed 's/^/  /'

echo "═══ секрет доступен ли внутри готового образа ═══"
docker run --rm safe:secret sh -c 'cat /run/secrets/build_token 2>&1 | tail -1' | sed 's/^/  /'

═══ ищем токен в образе ═══
  в docker history:  0
  в image inspect:   0
  в файловой системе: 0
═══ что сохранилось в истории ═══
  RUN /bin/sh -c TOKEN="$(cat /run/secrets/build_token)"     && test -n "$TOKEN"     && echo
═══ результат сборки на месте ═══
  пакет установлен
═══ секрет доступен ли внутри готового образа ═══
  cat: can't open '/run/secrets/build_token': No such file or directory

cd /tmp/secrets
cat > Dockerfile.wrong <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
# ОШИБКА: значение подставляется в ARG, который сохраняется в истории
ARG TOKEN_ARG
RUN --mount=type=secret,id=build_token \
    echo "секрет из mount: $(cat /run/secrets/build_token)" > /dev/null \
    && echo "а этот из ARG: ${TOKEN_ARG}" > /dev/null
CMD ["true"]
EOF

docker build -q -f Dockerfile.wrong \
    --secret id=build_token,src=./token.txt \
    --build-arg TOKEN_ARG="$(cat token.txt)" \
    -t leak:mixed . > /dev/null

TOKEN="$(cat token.txt)"
echo "═══ смешанный вариант ═══"
printf '  вхождений токена в history: %s\n' \
    "$(docker history --no-trunc leak:mixed | grep -c "$TOKEN" || echo 0)"
docker history --no-trunc leak:mixed | grep -o "а этот из ARG: [^\"]*" | head -1 | sed 's/^/  /'

═══ смешанный вариант ═══
  вхождений токена в history: 1
  а этот из ARG: glpat-SECRET-abcdef1234567890

cd /tmp/secrets
cat > Dockerfile.envsecret <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
RUN --mount=type=secret,id=api_key,env=API_KEY \
    test -n "$API_KEY" && echo "ключ получен, длина ${#API_KEY}" > /opt/result.txt
CMD ["cat", "/opt/result.txt"]
EOF

API_KEY="ak-SECRET-from-env-0987654321" \
    docker build -q -f Dockerfile.envsecret --secret id=api_key,env=API_KEY \
    -t safe:envsecret . > /dev/null

echo "═══ результат ═══"
docker run --rm safe:envsecret | sed 's/^/  /'
printf '  вхождений в history: %s\n' \
    "$(docker history --no-trunc safe:envsecret | grep -c 'ak-SECRET-from-env' || echo 0)"

═══ результат ═══
  ключ получен, длина 29
  вхождений в history: 0

cd /tmp/secrets
echo "═══ сводка по образам ═══"
printf '  %-18s %-10s %-10s %-10s\n' "образ" "history" "inspect" "в FS"
for img in leak:arg leak:env leak:mixed safe:secret safe:envsecret; do
    case "$img" in
        *envsecret) needle="ak-SECRET-from-env" ;;
        leak:env)   needle="sk-live-SECRET" ;;
        *)          needle="glpat-SECRET" ;;
    esac
    h="$(docker history --no-trunc "$img" 2>/dev/null | grep -c "$needle" || echo 0)"
    i="$(docker image inspect "$img" 2>/dev/null | grep -c "$needle" || echo 0)"
    f="$(docker run --rm --entrypoint sh "$img" -c "grep -rl '$needle' /etc /opt /tmp 2>/dev/null | wc -l" 2>/dev/null || echo 0)"
    printf '  %-18s %-10s %-10s %-10s\n' "$img" "$h" "$i" "$f"
done

═══ сводка по образам ═══
  образ              history    inspect    в FS      
  leak:arg           1          0          0         
  leak:env           1          1          0         
  leak:mixed         1          0          0         
  safe:secret        0          0          0         
  safe:envsecret     0          0          0         

docker rmi -f leak:arg leak:env leak:mixed safe:secret safe:envsecret > /dev/null 2>&1

cd /tmp/secrets
cat > config.py <<'PY'
"""Конфигурация: файл имеет приоритет над переменной."""
from __future__ import annotations

import os
import sys
from pathlib import Path


def get_secret(name: str, default: str | None = None) -> str | None:
    """<name>_FILE → <name> → default.

    Файл побеждает: если заданы оба, используется более безопасный источник.
    """
    path = os.environ.get(f"{name}_FILE")
    if path:
        try:
            return Path(path).read_text(encoding="utf-8").strip()
        except OSError as exc:
            raise RuntimeError(f"{name}_FILE={path}: {exc}") from exc
    return os.environ.get(name, default)


def source_of(name: str) -> str:
    if os.environ.get(f"{name}_FILE"):
        return "файл"
    if os.environ.get(name):
        return "переменная"
    return "умолчание"


def validate() -> int:
    """Все ошибки сразу: иначе исправление требует нескольких перезапусков."""
    errors: list[str] = []

    password = get_secret("DB_PASSWORD")
    if not password:
        errors.append("DB_PASSWORD или DB_PASSWORD_FILE обязателен")

    raw_port = os.environ.get("DB_PORT", "5432")
    try:
        port = int(raw_port)
        if not 1 <= port <= 65535:
            errors.append(f"DB_PORT вне диапазона: {port}")
    except ValueError:
        errors.append(f"DB_PORT должен быть числом: {raw_port!r}")

    level = os.environ.get("LOG_LEVEL", "INFO").upper()
    if level not in {"DEBUG", "INFO", "WARNING", "ERROR"}:
        errors.append(f"LOG_LEVEL недопустим: {level}")

    if errors:
        print("ОШИБКА КОНФИГУРАЦИИ:", file=sys.stderr)
        for e in errors:
            print(f"  - {e}", file=sys.stderr)
        return 1

    masked = f"{password[:3]}…({len(password)} симв.)" if password else "(нет)"
    print(f"  DB_PASSWORD  источник={source_of('DB_PASSWORD'):<11} {masked}")
    print(f"  DB_PORT      {port}")
    print(f"  LOG_LEVEL    {level}")
    return 0


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

mkdir -p secret-files
echo -n "пароль-из-файла-длинный" > secret-files/db_password
chmod 600 secret-files/db_password

echo "═══ только переменная ═══"
docker run --rm -v "$PWD/config.py:/c.py:ro" \
    -e DB_PASSWORD="пароль-из-переменной" python:3.13-slim python /c.py

echo "═══ только файл ═══"
docker run --rm -v "$PWD/config.py:/c.py:ro" \
    -v "$PWD/secret-files/db_password:/run/secrets/db_password:ro" \
    -e DB_PASSWORD_FILE=/run/secrets/db_password python:3.13-slim python /c.py

echo "═══ заданы оба — побеждает файл ═══"
docker run --rm -v "$PWD/config.py:/c.py:ro" \
    -v "$PWD/secret-files/db_password:/run/secrets/db_password:ro" \
    -e DB_PASSWORD="пароль-из-переменной" \
    -e DB_PASSWORD_FILE=/run/secrets/db_password python:3.13-slim python /c.py

echo "═══ валидация: несколько ошибок сразу ═══"
docker run --rm -v "$PWD/config.py:/c.py:ro" \
    -e DB_PORT=не-число -e LOG_LEVEL=ПОДРОБНО python:3.13-slim python /c.py 2>&1 | sed 's/^/  /'

═══ только переменная ═══
  DB_PASSWORD  источник=переменная  пар…(20 симв.)
  DB_PORT      5432
  LOG_LEVEL    INFO
═══ только файл ═══
  DB_PASSWORD  источник=файл        пар…(23 симв.)
  DB_PORT      5432
  LOG_LEVEL    INFO
═══ заданы оба — побеждает файл ═══
  DB_PASSWORD  источник=файл        пар…(23 симв.)
  DB_PORT      5432
  LOG_LEVEL    INFO
═══ валидация: несколько ошибок сразу ═══
  ОШИБКА КОНФИГУРАЦИИ:
    - DB_PASSWORD или DB_PASSWORD_FILE обязателен
    - DB_PORT должен быть числом: 'не-число'
    - LOG_LEVEL недопустим: ПОДРОБНО

cd /tmp/secrets
cat > watcher.py <<'PY'
"""Приложение, читающее секрет один раз и по сигналу."""
import os
import signal
import sys
import time
from pathlib import Path

PATH = Path(os.environ.get("SECRET_PATH", "/run/secrets/token"))
_value = PATH.read_text().strip() if PATH.exists() else "(нет)"


def reload_secret(signum, _frame):
    """SIGHUP: перечитать секрет без перезапуска процесса."""
    global _value
    try:
        _value = PATH.read_text().strip()
        print(f"[SIGHUP] секрет перечитан: {_value}", flush=True)
    except OSError as exc:
        print(f"[SIGHUP] ошибка: {exc}", flush=True)


signal.signal(signal.SIGHUP, reload_secret)
print(f"старт, секрет: {_value}", flush=True)
while True:
    time.sleep(1)
PY

mkdir -p rot
echo -n "версия-1" > rot/token

docker run -d --name rotate \
    -v "$PWD/watcher.py:/w.py:ro" \
    -v "$PWD/rot/token:/run/secrets/token:ro" \
    python:3.13-slim python -u /w.py > /dev/null
sleep 2

echo "═══ исходное значение ═══"
docker logs rotate 2>&1 | tail -1 | sed 's/^/  /'

echo "═══ меняем файл на host ═══"
echo -n "версия-2-НОВАЯ" > rot/token
printf '  на host: %s\n' "$(cat rot/token)"
printf '  в container: %s\n' "$(docker exec rotate cat /run/secrets/token)"

echo "═══ отправляем SIGHUP ═══"
docker exec rotate kill -HUP 1
sleep 1
docker logs rotate 2>&1 | tail -1 | sed 's/^/  /'

docker rm -f rotate > /dev/null

═══ исходное значение ═══
  старт, секрет: версия-1
═══ меняем файл на host ═══
  на host: версия-2-НОВАЯ
  в container: версия-2-НОВАЯ
═══ отправляем SIGHUP ═══
  [SIGHUP] секрет перечитан: версия-2-НОВАЯ

cd /tmp/secrets
cat > compose.rot.yaml <<'EOF'
name: rot
services:
  app:
    image: python:3.13-slim
    volumes:
      - ./watcher.py:/w.py:ro
    command: ["python", "-u", "/w.py"]
    secrets:
      - token
secrets:
  token:
    file: ./rot/token
EOF

echo -n "compose-версия-1" > rot/token
docker compose -f compose.rot.yaml up -d > /dev/null 2>&1
sleep 2
printf '  при старте:  %s\n' "$(docker compose -f compose.rot.yaml exec -T app cat /run/secrets/token)"

echo -n "compose-версия-2" > rot/token
sleep 1
printf '  после правки на host: %s\n' "$(docker compose -f compose.rot.yaml exec -T app cat /run/secrets/token)"

docker compose -f compose.rot.yaml up -d --force-recreate > /dev/null 2>&1
sleep 2
printf '  после пересоздания:   %s\n' "$(docker compose -f compose.rot.yaml exec -T app cat /run/secrets/token)"
docker compose -f compose.rot.yaml down > /dev/null 2>&1

  при старте:  compose-версия-1
  после правки на host: compose-версия-1
  после пересоздания:   compose-версия-2

cd /tmp/secrets
cat > vault-stub.py <<'PY'
"""Имитация внешнего хранилища секретов с TTL."""
import json
import time
from http.server import BaseHTTPRequestHandler, HTTPServer

TTL = 5
_version = 1
_issued_at = time.monotonic()
VALID_TOKEN = "role-token-abc"


class H(BaseHTTPRequestHandler):
    def do_GET(self):
        global _version, _issued_at
        # Начальная аутентификация: без токена доступа нет
        auth = self.headers.get("X-Auth-Token", "")
        if auth != VALID_TOKEN:
            self._json(403, {"error": "не аутентифицирован"})
            return
        # Секрет протухает: хранилище выдаёт новую версию
        if time.monotonic() - _issued_at > TTL:
            _version += 1
            _issued_at = time.monotonic()
        self._json(200, {
            "value": f"db-password-v{_version}",
            "ttl_seconds": TTL,
            "version": _version,
        })

    def _json(self, code, payload):
        body = json.dumps(payload).encode()
        self.send_response(code)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, *a):
        pass


print("хранилище запущено", flush=True)
HTTPServer(("0.0.0.0", 8000), H).serve_forever()
PY

cat > client.py <<'PY'
"""Клиент: получает секрет при старте и обновляет до истечения TTL."""
from __future__ import annotations

import json
import os
import threading
import time
import urllib.error
import urllib.request

VAULT = os.environ.get("VAULT_URL", "http://vault:8000/secret")
# Начальная аутентификация: единственный секрет, который приходит извне
AUTH = os.environ.get("VAULT_TOKEN", "")

_secret = {"value": None, "version": 0}
_lock = threading.Lock()


def fetch() -> dict[str, object] | None:
    req = urllib.request.Request(VAULT, headers={"X-Auth-Token": AUTH})
    try:
        with urllib.request.urlopen(req, timeout=3) as r:
            return json.load(r)
    except urllib.error.HTTPError as exc:
        print(f"  хранилище отказало: HTTP {exc.code}", flush=True)
    except OSError as exc:
        print(f"  хранилище недоступно: {type(exc).__name__}", flush=True)
    return None


def refresher() -> None:
    """Обновление до истечения TTL — ротация без перезапуска."""
    while True:
        data = fetch()
        if data:
            with _lock:
                if data["version"] != _secret["version"]:
                    print(f"  получена версия {data['version']}: {data['value']}", flush=True)
                _secret.update(data)
            time.sleep(max(1, float(data["ttl_seconds"]) * 0.6))
        else:
            time.sleep(2)


if __name__ == "__main__":
    print(f"клиент запущен, токен доступа задан: {bool(AUTH)}", flush=True)
    threading.Thread(target=refresher, daemon=True).start()
    for _ in range(14):
        time.sleep(1)
    print("завершение", flush=True)
PY

cat > compose.vault.yaml <<'EOF'
name: vaultdemo

services:
  vault:
    image: python:3.13-slim
    volumes:
      - ./vault-stub.py:/v.py:ro
    command: ["python", "-u", "/v.py"]

  app:
    image: python:3.13-slim
    volumes:
      - ./client.py:/c.py:ro
    environment:
      VAULT_URL: "http://vault:8000/secret"
      VAULT_TOKEN: "role-token-abc"
    command: ["python", "-u", "/c.py"]
    depends_on: [vault]

  app-no-auth:
    image: python:3.13-slim
    volumes:
      - ./client.py:/c.py:ro
    environment:
      VAULT_URL: "http://vault:8000/secret"
      VAULT_TOKEN: ""
    command: ["python", "-u", "/c.py"]
    depends_on: [vault]
EOF

echo "═══ клиент с токеном доступа ═══"
docker compose -f compose.vault.yaml up --abort-on-container-exit --exit-code-from app app vault \
    > /tmp/secrets/vault.log 2>&1 || true
grep -E 'клиент|версия' /tmp/secrets/vault.log | sed 's/^/  /' | head -6
docker compose -f compose.vault.yaml down > /dev/null 2>&1

echo "═══ клиент без токена ═══"
docker compose -f compose.vault.yaml up --abort-on-container-exit --exit-code-from app-no-auth \
    app-no-auth vault > /tmp/secrets/vault2.log 2>&1 || true
grep -E 'клиент|отказало' /tmp/secrets/vault2.log | head -3 | sed 's/^/  /'
docker compose -f compose.vault.yaml down > /dev/null 2>&1

═══ клиент с токеном доступа ═══
  app-1  | клиент запущен, токен доступа задан: True
  app-1  |   получена версия 1: db-password-v1
  app-1  |   получена версия 2: db-password-v2
  app-1  |   получена версия 3: db-password-v3
═══ клиент без токена ═══
  app-no-auth-1  | клиент запущен, токен доступа задан: False
  app-no-auth-1  |   хранилище отказало: HTTP 403

cd /tmp && rm -rf /tmp/secrets

mkdir -p /tmp/sc && cd /tmp/sc
echo -n "секрет-12345" > s.txt
cat > Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM alpine:3.21
RUN --mount=type=secret,id=s \
    test -n "$(cat /run/secrets/s)" && echo ok > /r.txt
CMD ["cat", "/r.txt"]
EOF
docker build -q --secret id=s,src=./s.txt -t sc:test . > /dev/null
docker run --rm sc:test
docker history --no-trunc sc:test | grep -c "секрет-12345" || echo "0 — секрет не в истории"
docker rmi -f sc:test > /dev/null; cd /tmp && rm -rf /tmp/sc