# macOS (Homebrew)
brew install --cask docker
 
# macOS (OrbStack -- 推奨代替)
brew install --cask orbstack
 
# Windows (WSL2 バックエンド推奨)
winget install Docker.DockerDesktop
 
# Linux (Docker Engine -- 公式スクリプト)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
# 再ログイン後に有効化
 
# Linux (Ubuntu -- apt)
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# バージョン確認
docker version
docker compose version
 
# システム情報
docker system info
 
# ディスク使用量
docker system df
docker system df -v     # 詳細表示
 
# ヘルスチェック
docker run --rm hello-world

# ─── ステージ 1: 依存インストール ───
FROM node:20-slim AS deps
WORKDIR /app
 
# パッケージマネージャーの有効化
RUN corepack enable
 
# 依存定義ファイルのみコピー (キャッシュ活用)
COPY package.json pnpm-lock.yaml .npmrc ./
RUN pnpm install --frozen-lockfile
 
# ─── ステージ 2: 開発環境 ───
FROM node:20-slim AS dev
WORKDIR /app
 
RUN corepack enable
 
# 開発に必要なツール
RUN apt-get update && apt-get install -y \
    git \
    curl \
    jq \
    postgresql-client \
    && rm -rf /var/lib/apt/lists/*
 
COPY --from=deps /app/node_modules ./node_modules
COPY . .
 
EXPOSE 3000
CMD ["pnpm", "dev"]
 
# ─── ステージ 3: ビルド ───
FROM node:20-slim AS build
WORKDIR /app
 
RUN corepack enable
 
COPY --from=deps /app/node_modules ./node_modules
COPY . .
 
# ビルド時環境変数
ARG NODE_ENV=production
ENV NODE_ENV=${NODE_ENV}
 
RUN pnpm build
 
# 本番用の依存のみ再インストール
RUN pnpm install --prod --frozen-lockfile
 
# ─── ステージ 4: 本番 ───
FROM node:20-slim AS production
WORKDIR /app
 
# セキュリティ: 非 root ユーザー
RUN addgroup --system --gid 1001 nodejs && \
    adduser --system --uid 1001 appuser
 
# 本番に必要なファイルのみコピー
COPY --from=build --chown=appuser:nodejs /app/dist ./dist
COPY --from=build --chown=appuser:nodejs /app/node_modules ./node_modules
COPY --from=build --chown=appuser:nodejs /app/package.json ./package.json
 
# セキュリティ: 読み取り専用ファイルシステム対応
USER appuser
 
EXPOSE 3000
 
# ヘルスチェック
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:3000/api/health || exit 1
 
CMD ["node", "dist/index.js"]

# ─── ステージ 1: ビルダー ───
FROM python:3.12-slim AS builder
WORKDIR /app
 
# uv を使った高速インストール
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 
# 依存定義のみコピー
COPY pyproject.toml uv.lock ./
 
# 仮想環境を作成して依存インストール
RUN uv sync --frozen --no-dev
 
# ─── ステージ 2: 開発環境 ───
FROM python:3.12-slim AS dev
WORKDIR /app
 
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 
# 開発ツール
RUN apt-get update && apt-get install -y \
    git \
    curl \
    && rm -rf /var/lib/apt/lists/*
 
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen
 
COPY . .
 
EXPOSE 8000
CMD ["uv", "run", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]
 
# ─── ステージ 3: 本番 ───
FROM python:3.12-slim AS production
WORKDIR /app
 
RUN adduser --system --uid 1001 appuser
 
COPY --from=builder /app/.venv /app/.venv
COPY . .
 
ENV PATH="/app/.venv/bin:$PATH"
 
USER appuser
 
EXPOSE 8000
 
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:8000/health || exit 1
 
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# .dockerignore
node_modules
.next
dist
build
coverage
.turbo
.env.local
.env.*.local
*.log
.git
.vscode
.idea
*.md
!README.md
Dockerfile*
docker-compose*.yml
compose*.yaml
.dockerignore

# compose.yaml (docker compose v2 形式)
name: my-project
 
services:
  # ─── アプリケーション ───
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: dev
      args:
        NODE_VERSION: "20"
    ports:
      - "3000:3000"
    volumes:
      - .:/app                           # ソースコードマウント
      - /app/node_modules                # node_modules はコンテナ内を使用
    environment:
      - NODE_ENV=development
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/mydb
      - REDIS_URL=redis://redis:6379
      - LOG_LEVEL=debug
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    develop:
      watch:                             # docker compose watch 用
        - action: sync
          path: ./src
          target: /app/src
        - action: rebuild
          path: package.json
        - action: rebuild
          path: pnpm-lock.yaml
    restart: unless-stopped
 
  # ─── データベース ───
  db:
    image: postgres:16-alpine
    container_name: ${COMPOSE_PROJECT_NAME:-myproject}-db
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: mydb
      POSTGRES_INITDB_ARGS: "--encoding=UTF-8 --lc-collate=C --lc-ctype=C"
      TZ: Asia/Tokyo
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./scripts/init.sql:/docker-entrypoint-initdb.d/init.sql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
      start_period: 10s
    restart: unless-stopped
 
  # ─── キャッシュ ───
  redis:
    image: redis:7-alpine
    container_name: ${COMPOSE_PROJECT_NAME:-myproject}-redis
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --maxmemory 128mb --maxmemory-policy allkeys-lru
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
    restart: unless-stopped
 
  # ─── メールテスト ───
  mailpit:
    image: axllent/mailpit:latest
    container_name: ${COMPOSE_PROJECT_NAME:-myproject}-mail
    ports:
      - "1025:1025"    # SMTP
      - "8025:8025"    # Web UI
    environment:
      MP_SMTP_AUTH_ACCEPT_ANY: 1
      MP_SMTP_AUTH_ALLOW_INSECURE: 1
    restart: unless-stopped
 
volumes:
  postgres_data:
  redis_data:

# compose.yaml (ベース -- CI/本番共通)
services:
  app:
    build:
      context: .
      target: production
    environment:
      - NODE_ENV=production

# compose.override.yaml (ローカル開発用 -- 自動読み込み)
services:
  app:
    build:
      target: dev
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - LOG_LEVEL=debug
    depends_on:
      db:
        condition: service_healthy
 
  db:
    image: postgres:16-alpine
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
 
volumes:
  postgres_data:

# compose.ci.yaml (CI 用)
services:
  app:
    build:
      target: build
    environment:
      - NODE_ENV=test
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/testdb
 
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: testdb
    tmpfs:
      - /var/lib/postgresql/data  # CI ではメモリ上で高速化

# 使い方
docker compose up                                    # base + override (自動)
docker compose -f compose.yaml -f compose.ci.yaml up # base + CI
docker compose -f compose.yaml up                    # base のみ

# ─── 起動 ───
docker compose up -d                    # バックグラウンド起動
docker compose up --build               # リビルドして起動
docker compose up --build --force-recreate  # 強制再作成
docker compose watch                    # ファイル変更を監視 (v2.22+)
docker compose up -d --wait             # ヘルスチェック完了まで待機
 
# ─── ログ ───
docker compose logs -f app              # app のログを追跡
docker compose logs --tail 100 db       # db の最新100行
docker compose logs --since 5m          # 直近5分のログ
docker compose logs -f --no-log-prefix  # プレフィックスなし
 
# ─── 操作 ───
docker compose exec app sh              # コンテナ内でシェル
docker compose exec app bash            # bash が使える場合
docker compose exec db psql -U postgres # DB に接続
docker compose exec redis redis-cli     # Redis CLI
docker compose run --rm app pnpm test   # 一時コンテナでテスト
docker compose run --rm app pnpm prisma migrate dev  # マイグレーション
 
# ─── スケーリング ───
docker compose up -d --scale worker=3   # worker を3インスタンスに
 
# ─── 状態確認 ───
docker compose ps                       # サービス一覧
docker compose ps -a                    # 停止中も含む
docker compose top                      # プロセス一覧
docker compose stats                    # リソース使用状況
 
# ─── 停止・削除 ───
docker compose down                     # 停止
docker compose down -v                  # ボリュームも削除
docker compose down --rmi all           # イメージも削除
docker compose down --remove-orphans    # 孤立コンテナも削除
 
# ─── クリーンアップ ───
docker system prune -af                 # 不要な全リソース削除
docker volume prune                     # 未使用ボリューム削除
docker builder prune -af                # ビルドキャッシュ削除
docker image prune -af                  # 不要イメージ削除

# Makefile
.PHONY: up down restart build logs shell db-cli redis-cli seed clean
 
# ─── 起動・停止 ───
up:
	docker compose up -d --wait
 
down:
	docker compose down
 
restart:
	docker compose restart
 
build:
	docker compose up -d --build --wait
 
# ─── ログ ───
logs:
	docker compose logs -f
 
logs-app:
	docker compose logs -f app
 
# ─── シェル ───
shell:
	docker compose exec app sh
 
db-cli:
	docker compose exec db psql -U postgres -d mydb
 
redis-cli:
	docker compose exec redis redis-cli
 
# ─── データベース ───
migrate:
	docker compose exec app pnpm prisma migrate dev
 
seed:
	docker compose exec app pnpm prisma db seed
 
db-reset:
	docker compose exec app pnpm prisma migrate reset --force
 
# ─── テスト ───
test:
	docker compose run --rm app pnpm test
 
test-watch:
	docker compose run --rm app pnpm test:watch
 
# ─── クリーンアップ ───
clean:
	docker compose down -v --rmi all --remove-orphans
	docker system prune -af
 
# ─── CI ───
ci:
	docker compose -f compose.yaml -f compose.ci.yaml up -d --wait
	docker compose exec app pnpm test
	docker compose -f compose.yaml -f compose.ci.yaml down -v

# compose.yaml のベストプラクティス
services:
  app:
    volumes:
      # ソースコードはバインドマウント (ホットリロード用)
      - .:/app
 
      # node_modules は名前付きボリューム (高速)
      - node_modules:/app/node_modules
 
      # ビルドキャッシュも名前付きボリューム
      - next_cache:/app/.next
      - turbo_cache:/app/.turbo
 
      # 一時ファイルは tmpfs (メモリ上)
      - type: tmpfs
        target: /app/tmp
 
volumes:
  node_modules:
  next_cache:
  turbo_cache:

# compose.yaml (docker compose watch 設定)
services:
  app:
    build:
      context: .
      target: dev
    develop:
      watch:
        # ソースコード変更 → コンテナにコピー (高速)
        - action: sync
          path: ./src
          target: /app/src
          ignore:
            - "**/*.test.ts"
 
        # 設定ファイル変更 → コンテナにコピー
        - action: sync
          path: ./public
          target: /app/public
 
        # 依存変更 → コンテナ再ビルド
        - action: rebuild
          path: package.json
 
        - action: rebuild
          path: pnpm-lock.yaml
 
        # Dockerfile 変更 → コンテナ再ビルド
        - action: rebuild
          path: Dockerfile

# docker compose watch の実行
docker compose watch
 
# バックグラウンドで実行
docker compose watch &
 
# ログも表示
docker compose watch --no-up  # 既に起動済みの場合

# .env (docker compose が自動読込 -- チーム共有)
COMPOSE_PROJECT_NAME=my-project
NODE_ENV=development
 
# データベース
POSTGRES_USER=postgres
POSTGRES_PASSWORD=postgres
POSTGRES_DB=mydb
DATABASE_URL=postgresql://postgres:postgres@db:5432/mydb
 
# Redis
REDIS_URL=redis://redis:6379
 
# .env.local (個人設定 -- .gitignore に追加)
GITHUB_TOKEN=ghp_xxxxx
AWS_ACCESS_KEY_ID=AKIA...
AWS_SECRET_ACCESS_KEY=...
 
# .env.example (テンプレート -- リポジトリにコミット)
# コピーして .env.local を作成: cp .env.example .env.local
GITHUB_TOKEN=
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=

# compose.yaml
services:
  app:
    env_file:
      - path: .env
        required: true
      - path: .env.local
        required: false   # 存在しなくてもエラーにしない
    environment:
      # env_file の値を上書き
      - LOG_LEVEL=debug
      - ENABLE_FEATURE_X=true

# compose.yaml (Docker Secrets を使った管理)
services:
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
 
secrets:
  db_password:
    file: ./secrets/db_password.txt   # ローカルファイル
    # または
    # environment: DB_PASSWORD        # 環境変数から

# compose.yaml (複数ネットワーク)
services:
  app:
    networks:
      - frontend
      - backend
 
  web:
    image: nginx:alpine
    networks:
      - frontend
    ports:
      - "80:80"
 
  db:
    networks:
      - backend
    # ↑ frontend からはアクセス不可 (セキュリティ)
 
  redis:
    networks:
      - backend
 
networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # 外部からのアクセスを遮断

# project-a/compose.yaml
services:
  api:
    networks:
      - shared
 
networks:
  shared:
    name: shared-network
    external: true
 
# project-b/compose.yaml
services:
  web:
    networks:
      - shared
    environment:
      - API_URL=http://api:3000
 
networks:
  shared:
    name: shared-network
    external: true

# 共有ネットワークの作成
docker network create shared-network
 
# 両プロジェクトを起動
cd project-a && docker compose up -d
cd project-b && docker compose up -d
 
# project-b の web から project-a の api にアクセス可能

# syntax=docker/dockerfile:1
 
# BuildKit のキャッシュマウント
FROM node:20-slim AS deps
WORKDIR /app
RUN corepack enable
 
COPY package.json pnpm-lock.yaml ./
 
# パッケージマネージャーのキャッシュをマウント
RUN --mount=type=cache,id=pnpm,target=/root/.local/share/pnpm/store \
    pnpm install --frozen-lockfile
 
# シークレットのマウント (イメージに残らない)
RUN --mount=type=secret,id=npm_token \
    NPM_TOKEN=$(cat /run/secrets/npm_token) pnpm install

# BuildKit を有効にしてビルド
DOCKER_BUILDKIT=1 docker build .
 
# シークレットを渡してビルド
docker build --secret id=npm_token,src=./.npmrc .
 
# マルチプラットフォームビルド
docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest .

# ─── ベストプラクティス ───
 
# 1. 特定バージョンを指定 (latest は使わない)
FROM node:20.12.0-slim   # ✅ 固定バージョン
# FROM node:latest       # ❌ バージョン不定
 
# 2. 非 root ユーザーで実行
RUN addgroup --system --gid 1001 nodejs && \
    adduser --system --uid 1001 appuser
USER appuser
 
# 3. 読み取り専用ファイルシステム
# compose.yaml で: read_only: true
 
# 4. セキュリティスキャン
# docker scout quickview myapp:latest
# docker scout cves myapp:latest
 
# 5. 不要なパッケージを含めない
# slim / distroless イメージを使用

services:
  app:
    # セキュリティオプション
    security_opt:
      - no-new-privileges:true    # 権限昇格を防止
    read_only: true               # ファイルシステムを読み取り専用
    tmpfs:
      - /tmp                      # 書き込み可能な一時領域
      - /app/tmp
    cap_drop:
      - ALL                       # 全ケーパビリティを除去
    cap_add:
      - NET_BIND_SERVICE          # 必要なものだけ追加

# ─── コンテナの状態確認 ───
docker compose ps -a
docker compose logs --tail 50 app
docker inspect <container_id>
 
# ─── ネットワーク確認 ───
docker network ls
docker network inspect my-project_default
docker compose exec app ping db    # サービス間の疎通確認
 
# ─── リソース確認 ───
docker stats                        # リアルタイムリソース使用量
docker compose top                  # コンテナ内プロセス
docker system df -v                 # ディスク使用量詳細
 
# ─── イメージの中身を確認 ───
docker run --rm -it myapp:latest sh
docker history myapp:latest         # レイヤー履歴
docker inspect myapp:latest | jq '.[0].Config'  # 設定確認
 
# ─── ビルドのデバッグ ───
docker build --progress=plain .     # ビルドログの詳細表示
docker build --no-cache .           # キャッシュ無しでビルド

# .github/workflows/docker.yml
name: Docker Build
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
 
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      # Docker Buildx のセットアップ
      - uses: docker/setup-buildx-action@v3
 
      # Docker レイヤーキャッシュ
      - uses: actions/cache@v4
        with:
          path: /tmp/.buildx-cache
          key: ${{ runner.os }}-buildx-${{ github.sha }}
          restore-keys: |
            ${{ runner.os }}-buildx-
 
      # ビルド
      - uses: docker/build-push-action@v5
        with:
          context: .
          target: production
          push: false
          cache-from: type=local,src=/tmp/.buildx-cache
          cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
 
      # キャッシュの更新
      - run: |
          rm -rf /tmp/.buildx-cache
          mv /tmp/.buildx-cache-new /tmp/.buildx-cache

# .github/workflows/test.yml
name: Test with Docker Compose
on: [push, pull_request]
 
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Start services
        run: docker compose -f compose.yaml -f compose.ci.yaml up -d --wait
 
      - name: Run tests
        run: docker compose exec -T app pnpm test
 
      - name: Run lint
        run: docker compose exec -T app pnpm lint
 
      - name: Cleanup
        if: always()
        run: docker compose -f compose.yaml -f compose.ci.yaml down -v

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]