# マネージャーノードでSwarmを初期化
docker swarm init --advertise-addr 192.168.1.10
 
# 出力されたトークンでワーカーノードを参加させる
# Worker Node 1:
docker swarm join --token SWMTKN-1-xxx 192.168.1.10:2377
 
# Worker Node 2:
docker swarm join --token SWMTKN-1-xxx 192.168.1.10:2377
 
# クラスタの状態確認
docker node ls
# ID          HOSTNAME   STATUS    AVAILABILITY   MANAGER STATUS
# abc123 *    manager1   Ready     Active         Leader
# def456      worker1    Ready     Active
# ghi789      worker2    Ready     Active

# HA構成では奇数のマネージャーノードが推奨
# マネージャー数と耐障害性の関係:
 
# マネージャー: 1 → 障害耐性: 0 (非推奨)
# マネージャー: 3 → 障害耐性: 1 (最小HA構成)
# マネージャー: 5 → 障害耐性: 2 (推奨HA構成)
# マネージャー: 7 → 障害耐性: 3 (大規模)
 
# マネージャーの追加
docker swarm join-token manager
# 表示されたコマンドを新ノードで実行
 
# ノードの役割変更
docker node promote worker1     # ワーカー → マネージャー
docker node demote manager3     # マネージャー → ワーカー
 
# ノードのメンテナンスモード
docker node update --availability drain worker1
# → worker1 上のタスクが他のノードに移動
 
# メンテナンス完了後
docker node update --availability active worker1

# サービスの作成
docker service create \
  --name web \
  --replicas 3 \
  --publish published=80,target=80 \
  --update-delay 10s \
  --update-parallelism 1 \
  --rollback-parallelism 1 \
  --rollback-monitor 30s \
  --restart-condition on-failure \
  --limit-memory 256M \
  --limit-cpu 0.5 \
  nginx:alpine
 
# サービスの状態確認
docker service ls
docker service ps web
 
# スケーリング
docker service scale web=5
 
# ローリングアップデート
docker service update --image nginx:1.25-alpine web
 
# ロールバック
docker service rollback web
 
# サービスのログ確認
docker service logs web
docker service logs -f --tail 100 web
 
# サービスの詳細情報
docker service inspect --pretty web

# docker-stack.yml
version: "3.9"
 
services:
  web:
    image: nginx:alpine
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
        failure_action: rollback
        monitor: 30s
        order: start-first  # 新しいタスクを起動してから古いタスクを停止
      rollback_config:
        parallelism: 1
        order: stop-first
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
        window: 120s
      placement:
        constraints:
          - node.role == worker
        preferences:
          - spread: node.id  # ノード間に均等分散
      resources:
        limits:
          cpus: "0.5"
          memory: 256M
        reservations:
          cpus: "0.1"
          memory: 64M
    ports:
      - "80:80"
    networks:
      - frontend
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:80/"]
      interval: 10s
      timeout: 3s
      retries: 3
 
  api:
    image: my-api:latest
    deploy:
      replicas: 2
      placement:
        constraints:
          - node.labels.tier == app
      labels:
        com.example.service: "api"
        com.example.environment: "production"
    environment:
      DATABASE_URL: "postgres://postgres-service:5432/myapp"
    networks:
      - frontend
      - backend
    secrets:
      - db_password
      - api_key
 
  db:
    image: postgres:16-alpine
    deploy:
      replicas: 1
      placement:
        constraints:
          - node.labels.tier == data
        max_replicas_per_node: 1  # 1ノードに1レプリカのみ
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
      POSTGRES_DB: myapp
    networks:
      - backend
    secrets:
      - db_password
 
  redis:
    image: redis:7-alpine
    deploy:
      replicas: 1
      placement:
        constraints:
          - node.labels.tier == data
    networks:
      - backend
 
  # ビジュアライザー（管理用）
  visualizer:
    image: dockersamples/visualizer:latest
    deploy:
      placement:
        constraints:
          - node.role == manager
    ports:
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
 
networks:
  frontend:
    driver: overlay
  backend:
    driver: overlay
    internal: true  # 外部アクセス不可
 
volumes:
  pgdata:
    driver: local
 
secrets:
  db_password:
    external: true
  api_key:
    external: true

# シークレットの作成
echo "MySecretPassword123" | docker secret create db_password -
echo "sk-1234567890" | docker secret create api_key -
 
# ノードラベルの設定
docker node update --label-add tier=app worker1
docker node update --label-add tier=app worker2
docker node update --label-add tier=data worker3
 
# Stack のデプロイ
docker stack deploy -c docker-stack.yml myapp
 
# Stack の状態確認
docker stack ls
docker stack services myapp
docker stack ps myapp
 
# 特定サービスのスケーリング
docker service scale myapp_api=4
 
# Stack の更新（YAMLファイル変更後）
docker stack deploy -c docker-stack.yml myapp  # 再デプロイで差分適用
 
# Stack の削除
docker stack rm myapp

# Overlay ネットワークの作成
docker network create --driver overlay --attachable my-overlay
 
# 暗号化されたOverlayネットワーク
docker network create --driver overlay --opt encrypted my-secure-overlay
 
# ネットワーク一覧
docker network ls --filter driver=overlay

# 「あるべき状態」を宣言すると、オーケストレーターが自動的に現実を合わせる
 
# Docker Swarm: docker-stack.yml
services:
  web:
    image: nginx:alpine
    deploy:
      replicas: 3    # ← 常に3つのレプリカを維持
 
# Kubernetes: deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3        # ← 常に3つのPodを維持
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: web
          image: nginx:alpine

# Docker Swarm のローリングアップデート
docker service update \
  --image my-app:v2.0.0 \
  --update-parallelism 1 \
  --update-delay 10s \
  --update-failure-action rollback \
  --update-monitor 30s \
  --update-max-failure-ratio 0.25 \
  --update-order start-first \
  my-service

# Kubernetes のローリングアップデート
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # 同時に追加できるPod数
      maxUnavailable: 0  # 停止を許容するPod数
  template:
    spec:
      containers:
        - name: app
          image: my-app:v2.0.0

# === minikube（推奨: 初学者向け） ===
# インストール
brew install minikube
 
# クラスタ起動
minikube start --driver=docker --memory=4096 --cpus=2
 
# ダッシュボード
minikube dashboard
 
# === kind（Kubernetes in Docker） ===
# インストール
brew install kind
 
# クラスタ作成（マルチノード）
cat <<EOF | kind create cluster --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
  - role: worker
EOF
 
# === k3d（k3s on Docker、最軽量） ===
# インストール
brew install k3d
 
# クラスタ作成
k3d cluster create mycluster --agents 2
 
# === Docker Desktop ===
# Settings > Kubernetes > Enable Kubernetes

# Step 1: 既存の docker-compose.yml を確認
docker compose config
 
# Step 2: Swarm 非対応の設定を修正
# - build: は使えない → 事前にイメージをビルド＆プッシュ
# - depends_on: の condition は使えない → healthcheck で代替
# - volumes のバインドマウント → Named Volume に変更
 
# Step 3: deploy セクションを追加
# - replicas, resources, placement 等
 
# Step 4: Swarm 初期化
docker swarm init
 
# Step 5: シークレットの作成
cat .env | while IFS='=' read -r key value; do
  echo "$value" | docker secret create "$key" -
done
 
# Step 6: Stack デプロイ
docker stack deploy -c docker-compose.yml myapp
 
# Step 7: 動作確認
docker stack services myapp
docker stack ps myapp

# Before: docker-compose.yml
version: "3.9"
services:
  api:
    build: ./api           # ← Swarmでは不可
    ports:
      - "8080:8080"
    depends_on:
      db:
        condition: service_healthy  # ← Swarmでは不可
    environment:
      DB_PASSWORD: secret123       # ← シークレットに移行
 
# After: docker-stack.yml
version: "3.9"
services:
  api:
    image: registry.example.com/api:1.0.0  # ← ビルド済みイメージ
    ports:
      - "8080:8080"
    deploy:
      replicas: 2
      update_config:
        parallelism: 1
        delay: 10s
      resources:
        limits:
          memory: 512M
          cpus: "1.0"
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:8080/health"]
      interval: 10s
      timeout: 3s
      retries: 5
    secrets:
      - db_password
    environment:
      DB_PASSWORD_FILE: /run/secrets/db_password  # ← ファイルから読み取り
 
secrets:
  db_password:
    external: true

# NG: データベースをオーケストレーション配下で管理（知識不足の状態で）
services:
  postgres:
    deploy:
      replicas: 3  # データベースは単純にレプリカを増やせない
 
# OK: まずはマネージドDBサービスを使用
# AWS RDS, Cloud SQL, Azure Database 等
# → コンテナDB運用は十分な知識を得てから

# NG: マネージャー1台で本番運用
# → マネージャー障害でクラスタ全体が制御不能
 
# OK: 最低3台のマネージャーで HA 構成
docker swarm init --advertise-addr 192.168.1.10
# + 2台のマネージャーを追加
 
# Kubernetes の場合:
# → マネージドサービス（EKS/GKE/AKS）で Control Plane の HA は自動

# 演習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]

# チーム間の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
    )
]

# セキュアコーディング例
import hashlib
import secrets
import hmac
from typing import Optional
 
class SecurityUtils:
    """セキュリティユーティリティ"""
 
    @staticmethod
    def generate_token(length: int = 32) -> str:
        """暗号学的に安全なトークン生成"""
        return secrets.token_urlsafe(length)
 
    @staticmethod
    def hash_password(password: str, salt: Optional[str] = None) -> tuple:
        """パスワードのハッシュ化"""
        if salt is None:
            salt = secrets.token_hex(16)
        hashed = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt.encode('utf-8'),
            iterations=100000
        )
        return hashed.hex(), salt
 
    @staticmethod
    def verify_password(password: str, hashed: str, salt: str) -> bool:
        """パスワードの検証"""
        new_hash, _ = SecurityUtils.hash_password(password, salt)
        return hmac.compare_digest(new_hash, hashed)
 
    @staticmethod
    def sanitize_input(value: str) -> str:
        """入力値のサニタイズ"""
        dangerous_chars = ['<', '>', '"', "'", '&', '\\']
        result = value
        for char in dangerous_chars:
            result = result.replace(char, '')
        return result.strip()
 
# 使用例
token = SecurityUtils.generate_token()
hashed, salt = SecurityUtils.hash_password("my_password")
is_valid = SecurityUtils.verify_password("my_password", hashed, salt)

# テストの ROI（投資対効果）を示す例
class TestROICalculator:
    """テスト投資対効果の計算"""
 
    def __init__(self):
        self.test_writing_hours = 0
        self.bugs_prevented = 0
        self.debug_hours_saved = 0
 
    def add_test_investment(self, hours: float):
        """テスト作成にかかった時間"""
        self.test_writing_hours += hours
 
    def add_bug_prevention(self, count: int, avg_debug_hours: float = 2.0):
        """テストにより防いだバグ"""
        self.bugs_prevented += count
        self.debug_hours_saved += count * avg_debug_hours
 
    def calculate_roi(self) -> dict:
        """ROIの計算"""
        net_benefit = self.debug_hours_saved - self.test_writing_hours
        roi_percent = (net_benefit / self.test_writing_hours * 100
                      if self.test_writing_hours > 0 else 0)
        return {
            'test_hours': self.test_writing_hours,
            'bugs_prevented': self.bugs_prevented,
            'hours_saved': self.debug_hours_saved,
            'net_benefit_hours': net_benefit,
            'roi_percent': f'{roi_percent:.1f}%'
        }

# minikube で開始
minikube start --driver=docker --memory=4096 --cpus=2
kubectl get nodes

# Kompose でdocker-compose.yml をK8sマニフェストに変換
kompose convert -f docker-compose.yml