# Dockerfile - Node.jsアプリケーション
FROM node:20-alpine
 
# アプリケーションディレクトリを作成
WORKDIR /app
 
# 依存関係をインストール（rootで実行）
COPY package*.json ./
RUN npm ci --only=production
 
# アプリケーションコードをコピー
COPY --chown=node:node . .
 
# 非rootユーザーに切り替え
USER node
 
EXPOSE 3000
CMD ["node", "server.js"]

# Dockerfile - Pythonアプリケーション（ユーザー作成パターン）
FROM python:3.12-slim
 
RUN groupadd --gid 1001 appgroup && \
    useradd --uid 1001 --gid appgroup --shell /bin/false --create-home appuser
 
WORKDIR /app
 
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY --chown=appuser:appgroup . .
 
USER appuser
 
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:create_app()"]

# Dockerfile - Goアプリケーション（スクラッチベース）
FROM golang:1.22-alpine AS builder
 
WORKDIR /build
COPY go.mod go.sum ./
RUN go mod download
 
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /app/server ./cmd/server
 
# 本番ステージ: scratchベースで最小構成
FROM scratch
 
# 非rootユーザーを設定（/etc/passwdをコピー）
COPY --from=builder /etc/passwd /etc/passwd
COPY --from=builder /etc/group /etc/group
 
# TLS証明書をコピー（外部HTTPSアクセス用）
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
# バイナリをコピー
COPY --from=builder --chown=1001:1001 /app/server /server
 
USER 1001
 
EXPOSE 8080
ENTRYPOINT ["/server"]

# Dockerfile - Javaアプリケーション（Spring Boot）
FROM eclipse-temurin:21-jre-alpine
 
RUN addgroup -g 1001 -S spring && \
    adduser -u 1001 -S spring -G spring -s /bin/false
 
WORKDIR /app
 
COPY --chown=spring:spring target/*.jar app.jar
 
# JVMのセキュリティ設定
ENV JAVA_OPTS="-XX:+UseContainerSupport \
    -XX:MaxRAMPercentage=75.0 \
    -Djava.security.egd=file:/dev/./urandom"
 
USER spring
 
EXPOSE 8080
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

// /etc/docker/daemon.json
{
  "userns-remap": "default"
}

# User Namespace Remapping の確認
# コンテナ内で root として実行されていても
# ホスト上では別のUIDにマッピングされる
docker run --rm alpine id
# uid=0(root) gid=0(root) ← コンテナ内では root
 
# ホスト上での実際のUID確認
ps aux | grep "コンテナプロセス"
# 165536 (非特権UID) で実行されている

# Rootless Docker のインストール
curl -fsSL https://get.docker.com/rootless | sh
 
# 環境変数の設定
export PATH=$HOME/bin:$PATH
export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock
 
# Rootless Docker の動作確認
docker info | grep -i "root"
# rootless: true

# Dockerfile内でのヘルスチェック定義
FROM nginx:alpine
 
# HTTPエンドポイントによるヘルスチェック
HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:80/health || exit 1

# PostgreSQL用のヘルスチェック
FROM postgres:16-alpine
 
HEALTHCHECK --interval=10s --timeout=5s --start-period=30s --retries=5 \
  CMD pg_isready -U postgres -d mydb || exit 1

# Redis用のヘルスチェック
FROM redis:7-alpine
 
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
  CMD redis-cli ping | grep -q PONG || exit 1

# MongoDB用のヘルスチェック
FROM mongo:7
 
HEALTHCHECK --interval=15s --timeout=5s --start-period=30s --retries=3 \
  CMD mongosh --eval "db.adminCommand('ping').ok" --quiet || exit 1

# docker-compose.yml でのヘルスチェック定義
version: "3.9"
 
services:
  api:
    image: my-api:latest
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 15s
      timeout: 5s
      retries: 3
      start_period: 30s
      start_interval: 5s  # 起動期間中のチェック間隔（Compose v2.3+）
 
  postgres:
    image: postgres:16-alpine
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
 
  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 3
 
  # 依存サービスのヘルスチェックを待ってから起動
  app:
    image: my-app:latest
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy

// Node.js/Express - ヘルスチェックエンドポイント
const express = require("express");
const app = express();
 
// Shallow Health Check（Liveness用）
app.get("/health", (req, res) => {
  res.status(200).json({
    status: "ok",
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
  });
});
 
// Deep Health Check（Readiness用）
app.get("/ready", async (req, res) => {
  const checks = {};
  let isReady = true;
 
  // データベース接続チェック
  try {
    await db.query("SELECT 1");
    checks.database = "ok";
  } catch (err) {
    checks.database = "error";
    isReady = false;
  }
 
  // Redis接続チェック
  try {
    await redis.ping();
    checks.redis = "ok";
  } catch (err) {
    checks.redis = "error";
    isReady = false;
  }
 
  // 外部API接続チェック
  try {
    await fetch("https://api.external.com/status", { timeout: 3000 });
    checks.externalApi = "ok";
  } catch (err) {
    checks.externalApi = "error";
    isReady = false;
  }
 
  const statusCode = isReady ? 200 : 503;
  res.status(statusCode).json({
    status: isReady ? "ready" : "not_ready",
    checks,
    timestamp: new Date().toISOString(),
  });
});

# Python/FastAPI - ヘルスチェックエンドポイント
from fastapi import FastAPI, Response
from datetime import datetime
import asyncpg
import aioredis
 
app = FastAPI()
 
@app.get("/health")
async def health_check():
    return {
        "status": "ok",
        "timestamp": datetime.utcnow().isoformat(),
    }
 
@app.get("/ready")
async def readiness_check(response: Response):
    checks = {}
    is_ready = True
 
    # データベースチェック
    try:
        conn = await asyncpg.connect(dsn=DATABASE_URL)
        await conn.fetchval("SELECT 1")
        await conn.close()
        checks["database"] = "ok"
    except Exception:
        checks["database"] = "error"
        is_ready = False
 
    # Redisチェック
    try:
        redis = await aioredis.from_url(REDIS_URL)
        await redis.ping()
        await redis.close()
        checks["redis"] = "ok"
    except Exception:
        checks["redis"] = "error"
        is_ready = False
 
    if not is_ready:
        response.status_code = 503
 
    return {
        "status": "ready" if is_ready else "not_ready",
        "checks": checks,
        "timestamp": datetime.utcnow().isoformat(),
    }

# docker-compose.yml
version: "3.9"
 
services:
  api:
    image: my-api:latest
    deploy:
      resources:
        limits:
          memory: 512M       # ハード上限（超過でOOM Kill）
          cpus: "1.0"        # CPU 1コア分
        reservations:
          memory: 256M       # 最低保証メモリ
          cpus: "0.25"       # 最低保証CPU
 
  worker:
    image: my-worker:latest
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: "2.0"
        reservations:
          memory: 512M
          cpus: "0.5"
      # OOM優先度（OOMスコア調整）
    oom_score_adj: 100  # 正の値 → OOM Kill されやすい
 
  database:
    image: postgres:16-alpine
    deploy:
      resources:
        limits:
          memory: 2G
          cpus: "2.0"
        reservations:
          memory: 1G
          cpus: "1.0"
    oom_score_adj: -500  # 負の値 → OOM Kill されにくい

# docker run でのリソース制限
docker run -d \
  --name api \
  --memory=512m \
  --memory-swap=512m \       # スワップ無効化（メモリと同値）
  --memory-reservation=256m \
  --cpus=1.0 \
  --cpu-shares=512 \         # 相対的なCPU配分（デフォルト1024）
  --pids-limit=100 \         # プロセス数上限（fork爆弾対策）
  --ulimit nofile=65535:65535 \  # ファイルディスクリプタ上限
  my-api:latest
 
# リソース使用状況のリアルタイム監視
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}\t{{.PIDs}}"

# Java - コンテナのメモリ制限を自動認識
# JDK 8u191+ / JDK 11+ では UseContainerSupport がデフォルト有効
docker run -d \
  --memory=512m \
  -e JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0" \
  my-java-app:latest
 
# Node.js - ヒープサイズ制限
docker run -d \
  --memory=512m \
  -e NODE_OPTIONS="--max-old-space-size=384" \
  my-node-app:latest
 
# Python - メモリ制限はOS依存（特別な設定は不要だが監視は必要）
docker run -d \
  --memory=512m \
  -e PYTHONDONTWRITEBYTECODE=1 \
  my-python-app:latest
 
# Go - GOMEMLIMIT で GC を最適化（Go 1.19+）
docker run -d \
  --memory=512m \
  -e GOMEMLIMIT=400MiB \
  my-go-app:latest

# Dockerfile - ログ設計のベストプラクティス
FROM node:20-alpine
 
WORKDIR /app
COPY . .
 
# アプリケーションは stdout/stderr に出力する
# ファイルへの書き込みは行わない
CMD ["node", "server.js"]
 
# server.js 内のログ出力例:
# console.log(JSON.stringify({
#   timestamp: new Date().toISOString(),
#   level: "info",
#   message: "Request handled",
#   method: "GET",
#   path: "/api/users",
#   status: 200,
#   duration_ms: 45,
#   request_id: "abc-123"
# }));

# docker-compose.yml - ログドライバー設定
version: "3.9"
 
services:
  api:
    image: my-api:latest
    logging:
      driver: json-file    # デフォルトドライバー
      options:
        max-size: "10m"    # ログファイルの最大サイズ
        max-file: "5"      # ローテーションファイル数
        compress: "true"   # 圧縮有効化
        tag: "{{.Name}}/{{.ID}}"  # タグ付け
 
  # Fluentdへの転送
  worker:
    image: my-worker:latest
    logging:
      driver: fluentd
      options:
        fluentd-address: "localhost:24224"
        tag: "docker.{{.Name}}"
        fluentd-async: "true"     # 非同期送信（ログ損失のリスクあり）
        fluentd-retry-wait: "1s"
        fluentd-max-retries: "10"

// /etc/docker/daemon.json - 全コンテナ共通のログ設定
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3",
    "compress": "true",
    "labels": "environment,service",
    "tag": "{{.ImageName}}/{{.Name}}/{{.ID}}"
  }
}

# Python - structlog を使った構造化ログ
import structlog
import logging
 
structlog.configure(
    processors=[
        structlog.stdlib.filter_by_level,
        structlog.stdlib.add_logger_name,
        structlog.stdlib.add_log_level,
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.StackInfoRenderer(),
        structlog.processors.format_exc_info,
        structlog.processors.UnicodeDecoder(),
        structlog.processors.JSONRenderer(),
    ],
    wrapper_class=structlog.stdlib.BoundLogger,
    logger_factory=structlog.PrintLoggerFactory(),
)
 
logger = structlog.get_logger()
 
# 使用例
logger.info("request_handled",
    method="GET",
    path="/api/users",
    status=200,
    duration_ms=45,
    request_id="abc-123",
)
# 出力: {"event":"request_handled","method":"GET","path":"/api/users","status":200,"duration_ms":45,"request_id":"abc-123","timestamp":"2024-01-15T10:30:00Z","level":"info"}

// Go - slog を使った構造化ログ（Go 1.21+）
package main
 
import (
    "log/slog"
    "os"
)
 
func main() {
    // JSON形式でstdoutに出力
    logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
        Level: slog.LevelInfo,
    }))
    slog.SetDefault(logger)
 
    // 使用例
    slog.Info("request_handled",
        "method", "GET",
        "path", "/api/users",
        "status", 200,
        "duration_ms", 45,
        "request_id", "abc-123",
    )
}

// server.js - Node.js のGraceful Shutdown
const http = require("http");
 
const server = http.createServer((req, res) => {
  res.writeHead(200);
  res.end("OK");
});
 
server.listen(3000, () => {
  console.log("Server started on port 3000");
});
 
// SIGTERM: docker stop が送信するシグナル
process.on("SIGTERM", () => {
  console.log("SIGTERM received. Shutting down gracefully...");
 
  server.close(() => {
    console.log("HTTP server closed");
    // DB接続のクリーンアップ
    // メッセージキューの切断
    process.exit(0);
  });
 
  // 強制終了のタイムアウト（SIGKILLの前に自主終了）
  setTimeout(() => {
    console.error("Forced shutdown after timeout");
    process.exit(1);
  }, 10000);
});

# Python/FastAPI - Graceful Shutdown
import signal
import asyncio
import uvicorn
from fastapi import FastAPI
 
app = FastAPI()
shutdown_event = asyncio.Event()
 
@app.on_event("shutdown")
async def shutdown():
    print("Shutting down gracefully...")
    # DB接続プールのクローズ
    await database.disconnect()
    # バックグラウンドタスクの完了待ち
    await task_queue.close()
    print("Cleanup completed")
 
# uvicornはSIGTERMを自動的にハンドリング
if __name__ == "__main__":
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=8000,
        timeout_graceful_shutdown=30,
    )

// Go - Graceful Shutdown
package main
 
import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)
 
func main() {
    srv := &http.Server{Addr: ":8080"}
 
    // シグナルハンドリング
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
 
    go func() {
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatalf("Server error: %v", err)
        }
    }()
 
    log.Println("Server started on :8080")
 
    // シグナル待ち
    sig := <-sigChan
    log.Printf("Received signal: %s. Shutting down...", sig)
 
    // Graceful Shutdown（30秒タイムアウト）
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
 
    if err := srv.Shutdown(ctx); err != nil {
        log.Printf("Forced shutdown: %v", err)
    }
 
    log.Println("Server stopped")
}

# Dockerfile - 正しいエントリポイント設定
FROM node:20-alpine
 
WORKDIR /app
COPY . .
 
# NG: shell形式（シグナルが /bin/sh に届き、nodeプロセスに伝わらない）
# CMD node server.js
 
# OK: exec形式（nodeプロセスがPID 1として起動し、シグナルを直接受信）
CMD ["node", "server.js"]
 
# または、tiniを使用してPID 1問題を解決
# RUN apk add --no-cache tini
# ENTRYPOINT ["tini", "--"]
# CMD ["node", "server.js"]

# docker-compose.yml
services:
  api:
    image: my-api:latest
    stop_grace_period: 30s  # SIGTERMからSIGKILLまでの猶予時間
    stop_signal: SIGTERM    # デフォルト

# === ビルドステージ ===
FROM node:20-alpine AS builder
 
WORKDIR /app
 
# 依存関係のインストール（キャッシュ活用）
COPY package.json package-lock.json ./
RUN npm ci
 
# ソースコードのコピーとビルド
COPY . .
RUN npm run build
 
# 不要な開発依存関係を除去
RUN npm prune --production
 
# === 本番ステージ ===
FROM node:20-alpine AS production
 
# セキュリティアップデート
RUN apk update && apk upgrade --no-cache && \
    apk add --no-cache tini dumb-init
 
# 非rootユーザー
RUN addgroup -g 1001 -S appgroup && \
    adduser -u 1001 -S appuser -G appgroup
 
WORKDIR /app
 
# ビルド成果物のみコピー
COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
COPY --from=builder --chown=appuser:appgroup /app/node_modules ./node_modules
COPY --from=builder --chown=appuser:appgroup /app/package.json ./
 
# ヘルスチェック
HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
 
# メタデータ
LABEL maintainer="team@example.com" \
      version="1.0.0" \
      description="Production API server"
 
# 非rootユーザーで実行
USER appuser
 
EXPOSE 3000
 
# tiniでPID 1問題を解決
ENTRYPOINT ["tini", "--"]
CMD ["node", "dist/server.js"]

# === ビルドステージ ===
FROM python:3.12-slim AS builder
 
WORKDIR /app
 
# 仮想環境を使用してシステムPythonを汚染しない
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
 
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
# === 本番ステージ ===
FROM python:3.12-slim AS production
 
# セキュリティアップデート
RUN apt-get update && apt-get upgrade -y --no-install-recommends && \
    apt-get install -y --no-install-recommends tini wget && \
    apt-get clean && rm -rf /var/lib/apt/lists/*
 
# 非rootユーザー
RUN groupadd -g 1001 appgroup && \
    useradd -u 1001 -g appgroup -s /bin/false -m appuser
 
WORKDIR /app
 
# 仮想環境をコピー
COPY --from=builder /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
 
# アプリケーションコードをコピー
COPY --chown=appuser:appgroup . .
 
# ヘルスチェック
HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8000/health || exit 1
 
# 環境変数
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1
 
USER appuser
 
EXPOSE 8000
 
ENTRYPOINT ["tini", "--"]
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "--timeout", "120", "app:create_app()"]

# === ビルドステージ ===
FROM golang:1.22-alpine AS builder
 
RUN apk add --no-cache ca-certificates tzdata
 
WORKDIR /build
 
COPY go.mod go.sum ./
RUN go mod download && go mod verify
 
COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
    go build -ldflags="-s -w -X main.version=$(cat VERSION)" \
    -o /app/server ./cmd/server
 
# === 本番ステージ（distroless） ===
FROM gcr.io/distroless/static-debian12:nonroot
 
COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=builder /app/server /server
 
EXPOSE 8080
 
USER nonroot:nonroot
 
ENTRYPOINT ["/server"]

# docker-compose.prod.yml
version: "3.9"
 
services:
  api:
    image: registry.example.com/api:${VERSION:-latest}
    restart: unless-stopped        # 自動再起動
    read_only: true                # ルートFS読み取り専用
    tmpfs:
      - /tmp:size=100m,noexec     # tmpのみ書き込み可
    security_opt:
      - no-new-privileges:true     # 権限昇格を禁止
    cap_drop:
      - ALL                        # 全Capabilityを削除
    cap_add:
      - NET_BIND_SERVICE           # 必要なもののみ追加
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: "1.0"
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:3000/health"]
      interval: 30s
      timeout: 5s
      retries: 3
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "5"
    environment:
      NODE_ENV: production
      LOG_LEVEL: info
    networks:
      - app-net

# docker-compose.prod.yml - シークレット管理
version: "3.9"
 
services:
  api:
    image: my-api:latest
    environment:
      # 非機密設定は環境変数で直接指定
      NODE_ENV: production
      LOG_LEVEL: info
      PORT: "3000"
    env_file:
      - .env.production  # 環境固有の設定
    secrets:
      - db_password
      - api_key
      - jwt_secret
 
secrets:
  db_password:
    file: ./secrets/db_password.txt    # ファイルベース
  api_key:
    external: true                      # Docker Swarm シークレット
  jwt_secret:
    environment: JWT_SECRET             # 環境変数から（Compose v2.17+）

// Node.js - Docker シークレットの読み取り
const fs = require("fs");
const path = require("path");
 
function readSecret(secretName) {
  const secretPath = path.join("/run/secrets", secretName);
  try {
    return fs.readFileSync(secretPath, "utf8").trim();
  } catch (err) {
    // シークレットファイルがない場合は環境変数にフォールバック
    return process.env[secretName.toUpperCase()];
  }
}
 
const dbPassword = readSecret("db_password");
const jwtSecret = readSecret("jwt_secret");

# docker-compose.prod.yml - ネットワーク分離
version: "3.9"
 
services:
  nginx:
    image: nginx:alpine
    ports:
      - "443:443"
    networks:
      - frontend
    # nginx のみが外部に公開される
 
  api:
    image: my-api:latest
    networks:
      - frontend    # nginx からのリクエストを受信
      - backend     # DB/Redis への接続
    # ポートは公開しない（nginx経由のみ）
 
  postgres:
    image: postgres:16-alpine
    networks:
      - backend     # API からのみアクセス可能
    # ポートは公開しない
 
  redis:
    image: redis:7-alpine
    networks:
      - backend
    # ポートは公開しない
 
networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # 外部アクセス不可（インターネット接続なし）

# NG: USERを指定しない（rootで実行される）
FROM node:20-alpine
WORKDIR /app
COPY . .
CMD ["node", "server.js"]
 
# OK: 専用ユーザーで実行
FROM node:20-alpine
WORKDIR /app
COPY . .
USER node
CMD ["node", "server.js"]

# NG: リソース制限なし
services:
  api:
    image: my-api:latest
    # → メモリリークで他のコンテナを巻き込んでホストがクラッシュ
 
# OK: 適切なリソース制限を設定
services:
  api:
    image: my-api:latest
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: "1.0"

# NG: ログをコンテナ内のファイルに書き込み
# アプリが /var/log/app.log に書き込む → コンテナサイズ肥大化
 
# OK: stdout/stderrに出力し、Dockerログドライバーに委任
# console.log(), print(), fmt.Println() を使用

# NG: docker-compose.yml にパスワードを直書き
services:
  api:
    environment:
      DB_PASSWORD: "MySecretPassword123!"
      API_KEY: "sk-1234567890abcdef"
 
# OK: Docker Secrets または .env ファイル（.gitignore対象）を使用
services:
  api:
    env_file:
      - .env.production  # .gitignore に含める
    secrets:
      - db_password

# NG: shell形式（/bin/sh -c でラップされる）
CMD node server.js
# PID 1 = /bin/sh, PID 2 = node
# → SIGTERMが/bin/shに届き、nodeに伝わらない
 
# OK: exec形式
CMD ["node", "server.js"]
# PID 1 = node
# → SIGTERMがnodeに直接届く

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

services:
  api:
    read_only: true
    tmpfs:
      - /tmp:size=100m
      - /var/run:size=10m

# Trivyでのイメージスキャン
trivy image --severity CRITICAL,HIGH my-app:latest
 
# 既知の脆弱性のみを検知（修正可能なもの）
trivy image --ignore-unfixed --severity CRITICAL my-app:latest
 
# SBOM（ソフトウェア部品表）の生成
trivy image --format spdx-json --output sbom.json my-app:latest

# distroless を使った Go アプリケーション
FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=builder /app/server /server
USER nonroot:nonroot
ENTRYPOINT ["/server"]