# Kubernetes Recreate デプロイ
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  strategy:
    type: Recreate  # 全 Pod を停止後に新 Pod を起動
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: myapp:v2.0.0
          ports:
            - containerPort: 3000

# docker-compose.blue-green.yml
version: "3.8"
 
services:
  app-blue:
    image: myapp:v1.0.0
    ports:
      - "8081:3000"
    environment:
      - ENV=production
      - SLOT=blue
 
  app-green:
    image: myapp:v1.1.0
    ports:
      - "8082:3000"
    environment:
      - ENV=production
      - SLOT=green
 
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app-blue
      - app-green

# nginx.conf — Blue-Green切替
upstream active_backend {
    # 現在のアクティブスロットを指定
    # Blue → Green に切り替えるときはここを変更
    server app-green:3000;
}
 
upstream standby_backend {
    server app-blue:3000;
}
 
server {
    listen 80;
 
    location / {
        proxy_pass http://active_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
 
    # ヘルスチェック用
    location /health {
        proxy_pass http://active_backend/health;
    }
}

# GitHub Actions での Blue-Green デプロイ
name: Blue-Green Deploy
on:
  push:
    branches: [main]
 
jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
    steps:
      - uses: actions/checkout@v4
 
      - uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
          aws-region: ap-northeast-1
 
      - name: Determine target group
        id: target
        run: |
          # 現在のアクティブターゲットグループを取得
          ACTIVE_TG=$(aws elbv2 describe-rules \
            --listener-arn ${{ secrets.ALB_LISTENER_ARN }} \
            --query 'Rules[0].Actions[0].TargetGroupArn' --output text)
 
          if echo "$ACTIVE_TG" | grep -q "blue"; then
            echo "deploy_tg=green" >> "$GITHUB_OUTPUT"
            echo "active_tg=blue" >> "$GITHUB_OUTPUT"
          else
            echo "deploy_tg=blue" >> "$GITHUB_OUTPUT"
            echo "active_tg=green" >> "$GITHUB_OUTPUT"
          fi
 
      - name: Deploy to standby environment
        run: |
          # スタンバイ環境にデプロイ
          aws ecs update-service \
            --cluster production \
            --service myapp-${{ steps.target.outputs.deploy_tg }} \
            --task-definition myapp:latest \
            --force-new-deployment
 
          # サービスが安定するまで待機
          aws ecs wait services-stable \
            --cluster production \
            --services myapp-${{ steps.target.outputs.deploy_tg }}
 
      - name: Health check on standby
        run: |
          HEALTH_URL="https://${{ steps.target.outputs.deploy_tg }}.internal.example.com/health"
          for i in $(seq 1 10); do
            STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$HEALTH_URL")
            if [ "$STATUS" = "200" ]; then
              echo "Health check passed"
              exit 0
            fi
            echo "Attempt $i/10: Status $STATUS"
            sleep 5
          done
          echo "Health check failed"
          exit 1
 
      - name: Switch traffic
        run: |
          # ALB のリスナールールを更新してトラフィックを切り替え
          aws elbv2 modify-rule \
            --rule-arn ${{ secrets.ALB_RULE_ARN }} \
            --actions Type=forward,TargetGroupArn=${{ secrets[format('TG_{0}_ARN', steps.target.outputs.deploy_tg)] }}
 
          echo "Traffic switched to ${{ steps.target.outputs.deploy_tg }}"
 
      - name: Verify deployment
        run: |
          sleep 30  # DNS 伝播待ち
          STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://api.example.com/health)
          if [ "$STATUS" != "200" ]; then
            echo "::error::Deployment verification failed! Rolling back..."
            # ロールバック: 元のターゲットグループに戻す
            aws elbv2 modify-rule \
              --rule-arn ${{ secrets.ALB_RULE_ARN }} \
              --actions Type=forward,TargetGroupArn=${{ secrets[format('TG_{0}_ARN', steps.target.outputs.active_tg)] }}
            exit 1
          fi
          echo "Deployment verified successfully"

# Kubernetes - Canary デプロイ (Ingress ベース)
# stable deployment (v1)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-stable
  labels:
    app: myapp
    version: stable
spec:
  replicas: 9
  selector:
    matchLabels:
      app: myapp
      version: stable
  template:
    metadata:
      labels:
        app: myapp
        version: stable
    spec:
      containers:
        - name: myapp
          image: myapp:v1.0.0
          ports:
            - containerPort: 3000
---
# canary deployment (v2)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-canary
  labels:
    app: myapp
    version: canary
spec:
  replicas: 1  # 全10台中1台 = 10%
  selector:
    matchLabels:
      app: myapp
      version: canary
  template:
    metadata:
      labels:
        app: myapp
        version: canary
    spec:
      containers:
        - name: myapp
          image: myapp:v2.0.0
          ports:
            - containerPort: 3000
---
# 共通 Service (両方にルーティング)
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp  # version ラベルは指定しない
  ports:
    - port: 80
      targetPort: 3000

# Istio VirtualService でトラフィック比率を制御
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: myapp
spec:
  hosts:
    - myapp.example.com
  http:
    - route:
        - destination:
            host: myapp-stable
            port:
              number: 3000
          weight: 90
        - destination:
            host: myapp-canary
            port:
              number: 3000
          weight: 10

# AWS App Mesh Route で Canary トラフィック分割
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualRouter
metadata:
  name: myapp-router
spec:
  listeners:
    - portMapping:
        port: 3000
        protocol: http
  routes:
    - name: canary-route
      httpRoute:
        match:
          prefix: /
        action:
          weightedTargets:
            - virtualNodeRef:
                name: myapp-stable
              weight: 90
            - virtualNodeRef:
                name: myapp-canary
              weight: 10

#!/bin/bash
# canary-rollout.sh — Canary の段階的ロールアウト
set -euo pipefail
 
STAGES=(5 10 25 50 75 100)  # トラフィック比率(%)
OBSERVATION_TIME=300          # 各段階の観測時間(秒)
ERROR_THRESHOLD=5             # エラー率の閾値(%)
 
for WEIGHT in "${STAGES[@]}"; do
  echo "=== Stage: ${WEIGHT}% canary traffic ==="
 
  # トラフィック比率を更新
  kubectl patch virtualservice myapp --type=json \
    -p="[{\"op\":\"replace\",\"path\":\"/spec/http/0/route/1/weight\",\"value\":${WEIGHT}},
         {\"op\":\"replace\",\"path\":\"/spec/http/0/route/0/weight\",\"value\":$((100-WEIGHT))}]"
 
  echo "Observing for ${OBSERVATION_TIME}s..."
  sleep "${OBSERVATION_TIME}"
 
  # メトリクスを取得してエラー率を確認
  ERROR_RATE=$(curl -s "http://prometheus:9090/api/v1/query?query=rate(http_requests_total{version=\"canary\",code=~\"5..\"}[5m])/rate(http_requests_total{version=\"canary\"}[5m])*100" \
    | jq -r '.data.result[0].value[1] // "0"')
 
  echo "Current error rate: ${ERROR_RATE}%"
 
  if (( $(echo "${ERROR_RATE} > ${ERROR_THRESHOLD}" | bc -l) )); then
    echo "::error::Error rate ${ERROR_RATE}% exceeds threshold ${ERROR_THRESHOLD}%. Rolling back!"
    kubectl patch virtualservice myapp --type=json \
      -p='[{"op":"replace","path":"/spec/http/0/route/1/weight","value":0},
           {"op":"replace","path":"/spec/http/0/route/0/weight","value":100}]'
    exit 1
  fi
 
  if [ "${WEIGHT}" -eq 100 ]; then
    echo "Canary rollout complete! Scaling down stable version."
    kubectl scale deployment myapp-stable --replicas=0
    kubectl scale deployment myapp-canary --replicas=10
  fi
done

# Kubernetes Rolling Update 設定
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 6
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 2        # 一度に追加できる Pod 数
      maxUnavailable: 1  # 同時に停止できる Pod 数
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: myapp:v2.0.0
          ports:
            - containerPort: 3000
          readinessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 10
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 15
            periodSeconds: 20

// feature-flag.ts — シンプルな Feature Flag 実装
interface FeatureFlag {
  name: string;
  enabled: boolean;
  rolloutPercentage: number;  // 0-100
  allowedUsers?: string[];
  metadata?: Record<string, unknown>;
}
 
class FeatureFlagService {
  private flags: Map<string, FeatureFlag> = new Map();
 
  constructor(private readonly configSource: FlagConfigSource) {}
 
  async initialize(): Promise<void> {
    const config = await this.configSource.fetch();
    for (const flag of config.flags) {
      this.flags.set(flag.name, flag);
    }
  }
 
  isEnabled(flagName: string, userId?: string): boolean {
    const flag = this.flags.get(flagName);
    if (!flag) return false;
    if (!flag.enabled) return false;
 
    // 特定ユーザーに許可されている場合
    if (userId && flag.allowedUsers?.includes(userId)) {
      return true;
    }
 
    // パーセンテージロールアウト
    if (flag.rolloutPercentage < 100) {
      const hash = this.hashUserId(userId ?? 'anonymous');
      return (hash % 100) < flag.rolloutPercentage;
    }
 
    return true;
  }
 
  private hashUserId(userId: string): number {
    let hash = 0;
    for (let i = 0; i < userId.length; i++) {
      const char = userId.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash |= 0; // 32bit整数に変換
    }
    return Math.abs(hash);
  }
}
 
// 使用例
const featureFlags = new FeatureFlagService(remoteConfigSource);
await featureFlags.initialize();
 
if (featureFlags.isEnabled('new-checkout-flow', currentUser.id)) {
  renderNewCheckout();
} else {
  renderLegacyCheckout();
}

// feature-flag-lifecycle.ts — Flag のライフサイクル管理
interface FlagLifecycle {
  name: string;
  createdAt: Date;
  createdBy: string;
  status: 'development' | 'testing' | 'rollout' | 'fully-rolled-out' | 'cleanup';
  expiresAt?: Date;  // 期限（これを過ぎたら削除対象）
  jiraTicket?: string;  // 関連チケット
}
 
class FlagLifecycleManager {
  // 期限切れの Flag を検出
  findExpiredFlags(flags: FlagLifecycle[]): FlagLifecycle[] {
    const now = new Date();
    return flags.filter(flag =>
      flag.expiresAt && flag.expiresAt < now &&
      flag.status === 'fully-rolled-out'
    );
  }
 
  // Flag の棚卸しレポート生成
  generateAuditReport(flags: FlagLifecycle[]): string {
    const lines = [
      '# Feature Flag 棚卸しレポート',
      `生成日: ${new Date().toISOString()}`,
      '',
      '| Flag | ステータス | 作成日 | 期限 | 担当者 |',
      '|------|----------|-------|------|--------|',
    ];
 
    for (const flag of flags) {
      const isExpired = flag.expiresAt && flag.expiresAt < new Date();
      lines.push(
        `| ${flag.name} | ${flag.status} ${isExpired ? '(期限切れ!)' : ''} | ${flag.createdAt.toISOString().slice(0, 10)} | ${flag.expiresAt?.toISOString().slice(0, 10) ?? '-'} | ${flag.createdBy} |`
      );
    }
 
    return lines.join('\n');
  }
}

# Feature Flag の状態を CI で検証
name: Feature Flag Audit
on:
  schedule:
    - cron: '0 9 * * 1'  # 毎週月曜
  workflow_dispatch:
 
jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Check for stale feature flags
        run: |
          # コード内の Feature Flag 参照を検索
          echo "## Feature Flag 使用状況" > flag-report.md
 
          # isEnabled('flag-name') パターンを検索
          grep -rn "isEnabled\|featureFlag\|FEATURE_" src/ --include="*.ts" --include="*.tsx" | \
            grep -oP "(?:isEnabled|featureFlag)\('\"" | \
            sort -u > found-flags.txt
 
          echo "検出された Flag:" >> flag-report.md
          cat found-flags.txt >> flag-report.md
 
      - name: Create issue if stale flags found
        if: steps.check.outputs.stale_count > 0
        uses: peter-evans/create-issue-from-file@v5
        with:
          title: "Feature Flag 棚卸し: 古い Flag が検出されました"
          content-filepath: flag-report.md
          labels: tech-debt,feature-flags

# マイグレーションの自動実行ワークフロー
name: DB Migration
on:
  push:
    branches: [main]
    paths:
      - 'migrations/**'
 
jobs:
  migrate:
    runs-on: ubuntu-latest
    environment: production
    permissions:
      id-token: write
      contents: read
    steps:
      - uses: actions/checkout@v4
 
      - uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
          aws-region: ap-northeast-1
 
      - name: Run migration (dry-run)
        run: |
          # まずドライランで確認
          npx prisma migrate diff \
            --from-schema-datasource prisma/schema.prisma \
            --to-migrations migrations/ \
            --shadow-database-url "$SHADOW_DB_URL"
        env:
          SHADOW_DB_URL: ${{ secrets.SHADOW_DATABASE_URL }}
 
      - name: Apply migration
        run: npx prisma migrate deploy
        env:
          DATABASE_URL: ${{ secrets.DATABASE_URL }}
 
      - name: Verify migration
        run: |
          # マイグレーション後のスキーマ検証
          npx prisma validate

# AWS Lambda + SAM の自動ロールバック
Resources:
  ApiFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: dist/lambda.handler
      Runtime: nodejs20.x
      AutoPublishAlias: live
      DeploymentPreference:
        Type: Canary10Percent5Minutes
        Alarms:
          - !Ref ApiErrorAlarm
          - !Ref ApiLatencyAlarm
 
  # エラー率のアラーム
  ApiErrorAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      MetricName: 5XXError
      Namespace: AWS/ApiGateway
      Statistic: Sum
      Period: 60
      EvaluationPeriods: 2
      Threshold: 10
      ComparisonOperator: GreaterThanThreshold
      TreatMissingData: notBreaching
 
  # レイテンシのアラーム
  ApiLatencyAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      MetricName: Latency
      Namespace: AWS/ApiGateway
      ExtendedStatistic: p99
      Period: 60
      EvaluationPeriods: 2
      Threshold: 3000  # 3秒
      ComparisonOperator: GreaterThanThreshold

# Argo Rollouts を使った自動ロールバック
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: myapp
spec:
  replicas: 10
  strategy:
    canary:
      steps:
        - setWeight: 10
        - pause: { duration: 5m }
        - analysis:
            templates:
              - templateName: success-rate
        - setWeight: 50
        - pause: { duration: 5m }
        - analysis:
            templates:
              - templateName: success-rate
        - setWeight: 100
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: myapp:v2.0.0
---
# 分析テンプレート
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: success-rate
spec:
  metrics:
    - name: success-rate
      interval: 30s
      count: 5
      successCondition: result[0] >= 0.95
      failureLimit: 3
      provider:
        prometheus:
          address: http://prometheus:9090
          query: |
            sum(rate(http_requests_total{app="myapp",version="canary",code!~"5.."}[5m]))
            /
            sum(rate(http_requests_total{app="myapp",version="canary"}[5m]))

// health-check.ts — 適切なヘルスチェック実装
app.get('/health', (req, res) => {
  // 浅いヘルスチェック: アプリケーションが起動しているか
  res.json({ status: 'ok', uptime: process.uptime() });
});
 
app.get('/health/deep', async (req, res) => {
  // 深いヘルスチェック: 依存関係が正常か
  const checks = {
    database: await checkDatabase(),
    redis: await checkRedis(),
    externalApi: await checkExternalApi(),
  };
 
  const allHealthy = Object.values(checks).every(c => c.status === 'ok');
 
  res.status(allHealthy ? 200 : 503).json({
    status: allHealthy ? 'ok' : 'degraded',
    checks,
    timestamp: new Date().toISOString(),
  });
});

# 演習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()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
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
    )
]

# .github/workflows/deploy-notification.yml
name: Deploy Notification
 
on:
  workflow_call:
    inputs:
      environment:
        required: true
        type: string
      version:
        required: true
        type: string
      status:
        required: true
        type: string
 
jobs:
  notify:
    runs-on: ubuntu-latest
    steps:
      - name: Post Slack Notification
        uses: slackapi/slack-github-action@v2.0.0
        with:
          webhook: ${{ secrets.SLACK_DEPLOY_WEBHOOK }}
          webhook-type: incoming-webhook
          payload: |
            {
              "blocks": [
                {
                  "type": "header",
                  "text": {
                    "type": "plain_text",
                    "text": "Deploy ${{ inputs.status == 'success' && 'Completed' || 'Failed' }}"
                  }
                },
                {
                  "type": "section",
                  "fields": [
                    { "type": "mrkdwn", "text": "*Environment:*\n`${{ inputs.environment }}`" },
                    { "type": "mrkdwn", "text": "*Version:*\n`${{ inputs.version }}`" },
                    { "type": "mrkdwn", "text": "*Actor:*\n${{ github.actor }}" },
                    { "type": "mrkdwn", "text": "*Status:*\n${{ inputs.status == 'success' && ':white_check_mark: Success' || ':x: Failed' }}" }
                  ]
                },
                {
                  "type": "actions",
                  "elements": [
                    {
                      "type": "button",
                      "text": { "type": "plain_text", "text": "View Run" },
                      "url": "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
                    }
                  ]
                }
              ]
            }