# ボリュームの作成
docker volume create my-data
 
# ボリューム一覧
docker volume ls
 
# ボリュームのフィルタリング
docker volume ls --filter "driver=local"
docker volume ls --filter "dangling=true"   # 未使用ボリューム
 
# ボリュームの詳細情報
docker volume inspect my-data
# 出力例:
# [
#     {
#         "CreatedAt": "2025-01-15T10:30:00Z",
#         "Driver": "local",
#         "Labels": {},
#         "Mountpoint": "/var/lib/docker/volumes/my-data/_data",
#         "Name": "my-data",
#         "Options": {},
#         "Scope": "local"
#     }
# ]
 
# ボリュームをマウントしてコンテナ起動
docker run -d \
  --name postgres-db \
  -v my-data:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  postgres:16-alpine
 
# --mount 構文（推奨: より明示的）
docker run -d \
  --name postgres-db \
  --mount type=volume,source=my-data,target=/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  postgres:16-alpine
 
# コンテナを削除してもボリュームは残る
docker rm -f postgres-db
docker volume ls  # my-data は健在
 
# 未使用ボリュームの一括削除（注意して使用）
docker volume prune
 
# 全ての未使用ボリュームを強制削除
docker volume prune -a -f

# docker-compose.yml
services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: myapp
    volumes:
      - pgdata:/var/lib/postgresql/data       # Named Volume
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro  # Bind Mount (読取専用)
    ports:
      - "5432:5432"
 
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
 
  backup:
    image: alpine:3.19
    volumes:
      - pgdata:/source:ro          # 同一ボリュームを読取専用でマウント
      - ./backups:/backup
    command: >
      sh -c "tar czf /backup/pgdata-$$(date +%Y%m%d).tar.gz -C /source ."
 
volumes:
  pgdata:
    driver: local
    labels:
      com.example.description: "PostgreSQLデータ"
      com.example.environment: "production"
  redis-data:
    driver: local

# ラベル付きボリュームの作成
docker volume create \
  --label environment=production \
  --label service=postgres \
  prod-pgdata
 
# ラベルでフィルタリング
docker volume ls --filter "label=environment=production"
docker volume ls --filter "label=service=postgres"

# 基本的なBind Mount（-v 構文）
docker run -d \
  --name dev-server \
  -v /home/user/project/src:/app/src \
  -v /home/user/project/config.yaml:/app/config.yaml:ro \
  my-app:dev
 
# --mount 構文（より明示的で推奨）
docker run -d \
  --name dev-server \
  --mount type=bind,source=/home/user/project/src,target=/app/src \
  --mount type=bind,source=/home/user/project/config.yaml,target=/app/config.yaml,readonly \
  my-app:dev
 
# 読み書き権限の制御
# :ro  → 読み取り専用
# :rw  → 読み書き可（デフォルト）
 
# 存在しないホストパスを指定した場合の挙動
# -v 構文    : 自動でディレクトリが作成される（意図せぬ空ディレクトリ生成の危険）
# --mount 構文: エラーになる（安全）

services:
  app:
    build: .
    volumes:
      # ソースコード（読み書き）
      - ./src:/app/src
 
      # 設定ファイル（読み取り専用）
      - ./config:/app/config:ro
 
      # 単一ファイルのマウント
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
 
      # node_modules は Named Volume で分離
      - node_modules:/app/node_modules
 
      # 長文構文
      - type: bind
        source: ./data
        target: /app/data
        read_only: false
 
volumes:
  node_modules:

# SELinux が有効な環境でのBind Mount
# :z  → 共有ラベルを設定（複数コンテナで共有可能）
# :Z  → プライベートラベルを設定（単一コンテナ専用）
docker run -d \
  -v /data/app:/app:z \
  my-app:latest
 
# Docker Compose での指定
# volumes:
#   - ./data:/app/data:z

# tmpfsマウント
docker run -d \
  --name secure-app \
  --tmpfs /tmp:rw,noexec,nosuid,size=100m \
  --mount type=tmpfs,destination=/run/secrets,tmpfs-size=10m,tmpfs-mode=0700 \
  my-app
 
# Docker Composeでの指定

# docker-compose.yml
services:
  app:
    image: my-app
    tmpfs:
      - /tmp:size=100m,mode=1777
    volumes:
      - type: tmpfs
        target: /run/secrets
        tmpfs:
          size: 10485760  # 10MB
          mode: 0700
 
  # テスト用DB（永続化不要 → tmpfsで高速化）
  db-test:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: test
    tmpfs:
      - /var/lib/postgresql/data:size=512m
    # → ディスクI/Oなしでテスト用DBが動作

# === バックアップ ===
# 別コンテナからボリュームをtarで圧縮バックアップ
docker run --rm \
  -v my-data:/source:ro \
  -v $(pwd)/backups:/backup \
  alpine:3.19 \
  tar czf /backup/my-data-backup.tar.gz -C /source .
 
# === リストア ===
# バックアップからボリュームを復元
docker volume create my-data-restored
 
docker run --rm \
  -v my-data-restored:/target \
  -v $(pwd)/backups:/backup:ro \
  alpine:3.19 \
  tar xzf /backup/my-data-backup.tar.gz -C /target
 
# === ボリュームの移行（ホスト間） ===
# 1. 送信元でバックアップ
docker run --rm \
  -v my-data:/source:ro \
  alpine:3.19 \
  tar czf - -C /source . | ssh user@remote-host \
  "docker run --rm -i -v my-data:/target alpine:3.19 tar xzf - -C /target"
 
# === ボリュームのコピー ===
docker volume create my-data-copy
 
docker run --rm \
  -v my-data:/from:ro \
  -v my-data-copy:/to \
  alpine:3.19 \
  sh -c "cp -av /from/. /to/"

# docker-compose.yml - 定期バックアップ設定
services:
  postgres:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
 
  # 定期バックアップコンテナ
  backup:
    image: postgres:16-alpine
    volumes:
      - ./backups:/backups
    environment:
      PGPASSWORD: ${DB_PASSWORD}
    # 毎日3時にバックアップ（cron代替として entrypoint スクリプト）
    entrypoint: >
      sh -c "
        while true; do
          echo \"[$(date)] Starting backup...\"
          pg_dump -h postgres -U postgres myapp | \
            gzip > /backups/myapp-$(date +%Y%m%d-%H%M%S).sql.gz
          echo \"[$(date)] Backup completed.\"
          # 7日以上前のバックアップを削除
          find /backups -name '*.sql.gz' -mtime +7 -delete
          sleep 86400
        done
      "
    depends_on:
      postgres:
        condition: service_healthy
 
volumes:
  pgdata:

#!/bin/bash
# scripts/backup.sh - 手動バックアップスクリプト
 
set -euo pipefail
 
BACKUP_DIR="./backups"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
 
mkdir -p "$BACKUP_DIR"
 
echo "=== PostgreSQL Backup ==="
docker compose exec -T postgres \
  pg_dump -U postgres myapp | gzip > "${BACKUP_DIR}/postgres-${TIMESTAMP}.sql.gz"
echo "  → ${BACKUP_DIR}/postgres-${TIMESTAMP}.sql.gz"
 
echo "=== Volume Backup ==="
docker run --rm \
  -v myapp_pgdata:/source:ro \
  -v "$(pwd)/backups":/backup \
  alpine:3.19 \
  tar czf "/backup/pgdata-${TIMESTAMP}.tar.gz" -C /source .
echo "  → ${BACKUP_DIR}/pgdata-${TIMESTAMP}.tar.gz"
 
echo "=== Redis Backup ==="
docker compose exec redis redis-cli BGSAVE
sleep 2
docker compose cp redis:/data/dump.rdb "${BACKUP_DIR}/redis-${TIMESTAMP}.rdb"
echo "  → ${BACKUP_DIR}/redis-${TIMESTAMP}.rdb"
 
echo "=== Backup Complete ==="
ls -lh "${BACKUP_DIR}/"*"${TIMESTAMP}"*

# NFSバックエンドのボリュームを作成
docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=192.168.1.100,rw,nfsvers=4 \
  --opt device=:/exports/data \
  nfs-data

# docker-compose.yml - NFS ボリューム
volumes:
  shared-data:
    driver: local
    driver_opts:
      type: nfs
      o: "addr=192.168.1.100,rw,nfsvers=4"
      device: ":/exports/data"
 
  # CIFS/SMB ボリューム（Windows ファイルサーバー）
  smb-data:
    driver: local
    driver_opts:
      type: cifs
      o: "addr=192.168.1.200,username=user,password=pass,file_mode=0777,dir_mode=0777"
      device: "//192.168.1.200/shared"

# 現在のストレージドライバーを確認
docker info | grep "Storage Driver"
# 出力例: Storage Driver: overlay2
 
# ストレージ使用状況を確認
docker system df
# 出力例:
# TYPE            TOTAL   ACTIVE  SIZE      RECLAIMABLE
# Images          15      5       3.2GB     1.8GB (56%)
# Containers      8       3       256MB     128MB (50%)
# Local Volumes   12      4       5.1GB     3.2GB (62%)
# Build Cache     45      0       890MB     890MB (100%)
 
# 詳細表示
docker system df -v
 
# 不要データの一括クリーンアップ
docker system prune -a --volumes
# WARNING: ボリュームも含めて全削除される

// /etc/docker/daemon.json
{
  "storage-driver": "overlay2",
  "storage-opts": [
    "overlay2.override_kernel_check=true",
    "overlay2.size=20G"
  ]
}

# 設定変更後にDockerデーモンを再起動
sudo systemctl restart docker
 
# 変更の確認
docker info | grep "Storage Driver"

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: myapp
      # パフォーマンスチューニング
      POSTGRES_INITDB_ARGS: "--data-checksums"
    volumes:
      - pgdata:/var/lib/postgresql/data
      # 初期化スクリプト
      - ./initdb:/docker-entrypoint-initdb.d:ro
      # カスタム設定
      - ./postgresql.conf:/etc/postgresql/postgresql.conf:ro
    command: postgres -c config_file=/etc/postgresql/postgresql.conf
    shm_size: '256m'    # PostgreSQL は共有メモリを多用
    deploy:
      resources:
        limits:
          memory: 1G
 
volumes:
  pgdata:

services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: myapp
      MYSQL_USER: app_user
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - mysql-data:/var/lib/mysql
      - ./my.cnf:/etc/mysql/conf.d/my.cnf:ro
      - ./initdb:/docker-entrypoint-initdb.d:ro
    deploy:
      resources:
        limits:
          memory: 1G
 
volumes:
  mysql-data:

services:
  mongodb:
    image: mongo:7
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD}
    volumes:
      - mongo-data:/data/db
      - mongo-config:/data/configdb
      # 初期化スクリプト
      - ./mongo-init:/docker-entrypoint-initdb.d:ro
    command: mongod --wiredTigerCacheSizeGB 0.5
 
volumes:
  mongo-data:
  mongo-config:

services:
  elasticsearch:
    image: elasticsearch:8.12.0
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms512m -Xmx512m
      - xpack.security.enabled=false
    volumes:
      - es-data:/usr/share/elasticsearch/data
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
 
volumes:
  es-data:

# docker-compose.yml
# macOSではBind Mountが遅い問題の対策
services:
  app:
    build: .
    volumes:
      # ソースコードはバインドマウント
      - ./src:/app/src
 
      # node_modules はNamed Volumeで管理（Bind Mountより高速）
      - node_modules:/app/node_modules
 
      # ビルド成果物も Volume で分離
      - build_cache:/app/.next
      - dist_cache:/app/dist
 
volumes:
  node_modules:
  build_cache:
  dist_cache:

# docker-compose.yml
services:
  db:
    image: postgres:16-alpine
    volumes:
      # WALログ用の高速ストレージ
      - pgdata:/var/lib/postgresql/data
      - pg-wal:/var/lib/postgresql/data/pg_wal
    # PostgreSQL のI/Oチューニング
    command: >
      postgres
        -c shared_buffers=256MB
        -c effective_cache_size=768MB
        -c wal_buffers=8MB
        -c checkpoint_completion_target=0.9
        -c random_page_cost=1.1
 
volumes:
  pgdata:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: /ssd/postgres/data    # SSD上のディレクトリ
  pg-wal:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: /nvme/postgres/wal    # NVMe上のディレクトリ

# ボリュームごとのディスク使用量を確認
docker system df -v
 
# 特定ボリュームのサイズを確認
docker run --rm -v myapp_pgdata:/data alpine du -sh /data
 
# 全ボリュームのサイズを一覧表示
for vol in $(docker volume ls -q); do
  size=$(docker run --rm -v "${vol}":/data alpine du -sh /data 2>/dev/null | cut -f1)
  echo "${vol}: ${size}"
done

#!/bin/bash
# scripts/volume-maintenance.sh
 
echo "=== Docker Volume Maintenance ==="
echo "Date: $(date)"
 
# 1. ディスク使用状況
echo ""
echo "--- Disk Usage ---"
docker system df
 
# 2. 未使用ボリューム
echo ""
echo "--- Dangling Volumes ---"
docker volume ls --filter "dangling=true"
 
# 3. 各ボリュームのサイズ
echo ""
echo "--- Volume Sizes ---"
for vol in $(docker volume ls -q); do
  size=$(docker run --rm -v "${vol}":/data alpine du -sh /data 2>/dev/null | cut -f1)
  echo "  ${vol}: ${size}"
done
 
# 4. 未使用ボリュームのクリーンアップ（確認付き）
echo ""
read -p "Remove dangling volumes? (y/N): " confirm
if [ "$confirm" = "y" ]; then
  docker volume prune -f
  echo "Dangling volumes removed."
fi

# NG: ボリュームなしでDBを運用
docker run -d postgres:16
# → コンテナ削除でデータ全喪失
# → 書き込みレイヤーはCoWオーバーヘッドで低速
 
# OK: Named Volumeにデータを保存
docker run -d \
  -v pgdata:/var/lib/postgresql/data \
  postgres:16

# NG: 本番でホストパスに依存
services:
  app:
    volumes:
      - /opt/myapp/data:/data         # ホストパスへの強い依存
      - /opt/myapp/config:/config     # 別ホストへの移行が困難
 
# OK: Named Volumeでポータビリティを確保
services:
  app:
    volumes:
      - app-data:/data
      - app-config:/config
volumes:
  app-data:
  app-config:

# NG: バックアップ未設定のDB
services:
  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    # バックアップの仕組みがない → ディスク障害でデータ全喪失
 
# OK: バックアップコンテナを併設
services:
  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
 
  backup:
    image: postgres:16-alpine
    volumes:
      - ./backups:/backups
    entrypoint: >
      sh -c "while true; do
        pg_dump -h db -U postgres myapp | gzip > /backups/daily-$$(date +%Y%m%d).sql.gz;
        find /backups -mtime +30 -delete;
        sleep 86400;
      done"

# NG: 確認なしで全未使用ボリュームを削除
docker volume prune -f
# → 停止中のコンテナのデータも含まれる可能性がある
 
# OK: まず確認してから削除
docker volume ls --filter "dangling=true"
# 出力を確認してから:
docker volume rm <特定のボリューム名>

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

# セキュアコーディング例
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)

# -v 構文（暗黙的な挙動あり）
docker run -v mydata:/data app
 
# --mount 構文（明示的で安全）
docker run --mount type=volume,source=mydata,target=/data app

# Dockerfileでユーザーを明示的に設定
FROM node:20-alpine
RUN mkdir -p /app/data && chown -R node:node /app/data
USER node
VOLUME /app/data

# 既存ボリュームの権限を修正
docker run --rm -v mydata:/data alpine chown -R 1000:1000 /data

# S3 volume driver プラグインのインストール
docker plugin install rexray/s3fs \
  S3FS_ACCESSKEY=xxx \
  S3FS_SECRETKEY=xxx
 
# S3バックエンドのボリュームを作成
docker volume create -d rexray/s3fs my-s3-data

# docker-compose.yml
services:
  writer:
    image: my-writer-app:latest
    volumes:
      - shared-data:/data   # 書き込みあり
 
  reader:
    image: my-reader-app:latest
    volumes:
      - shared-data:/data:ro   # 読み取り専用
 
  processor:
    image: my-processor:latest
    volumes:
      - shared-data:/data:ro   # 読み取り専用
 
volumes:
  shared-data:

# 未使用ボリュームの確認（削除はしない）
docker volume ls -f dangling=true
 
# 未使用ボリュームの削除
docker volume prune
 
# 全未使用リソース（イメージ、コンテナ、ネットワーク、ボリューム）の削除
docker system prune --volumes
 
# ラベルベースのクリーンアップ（安全性向上）
docker volume ls --filter "label=environment=development" -q | xargs docker volume rm

#!/bin/bash
# cleanup-volumes.sh - 安全なボリュームクリーンアップスクリプト
 
set -euo pipefail
 
echo "=== 現在のボリューム使用状況 ==="
docker system df -v | head -20
 
echo ""
echo "=== 未使用ボリューム一覧 ==="
DANGLING=$(docker volume ls -f dangling=true -q)
 
if [ -z "$DANGLING" ]; then
    echo "未使用ボリュームはありません。"
    exit 0
fi
 
echo "$DANGLING"
echo ""
echo "合計: $(echo "$DANGLING" | wc -l) 個"
echo ""
 
# 保護対象ボリュームの確認（名前にprod/productionが含まれるものは除外）
SAFE_TO_DELETE=$(echo "$DANGLING" | grep -v -E "(prod|production|backup)" || true)
 
if [ -z "$SAFE_TO_DELETE" ]; then
    echo "安全に削除可能なボリュームはありません。"
    exit 0
fi
 
echo "以下のボリュームを削除します:"
echo "$SAFE_TO_DELETE"
echo ""
read -p "実行しますか？ (y/N): " confirm
 
if [ "$confirm" = "y" ] || [ "$confirm" = "Y" ]; then
    echo "$SAFE_TO_DELETE" | xargs docker volume rm
    echo "削除完了。"
else
    echo "キャンセルしました。"
fi

volumes:
  pgdata:
    name: my-app-pgdata   # 明示的な名前（プロジェクト名プレフィックスなし）
    driver: local
    labels:
      com.example.project: "my-app"
      com.example.type: "database"

#!/bin/bash
# migrate-volume.sh - ボリュームデータの移行
 
SOURCE_VOLUME=$1
TARGET_HOST=$2
TARGET_VOLUME=$3
 
# 1. ソースボリュームをtarにエクスポート
echo "[1/3] ボリュームをエクスポート中..."
docker run --rm \
  -v ${SOURCE_VOLUME}:/source:ro \
  -v $(pwd):/backup \
  alpine tar czf /backup/volume-backup.tar.gz -C /source .
 
# 2. tarファイルをリモートホストに転送
echo "[2/3] リモートホストに転送中..."
scp volume-backup.tar.gz ${TARGET_HOST}:/tmp/
 
# 3. リモートホストでボリュームにインポート
echo "[3/3] リモートホストでインポート中..."
ssh ${TARGET_HOST} << 'EOF'
docker volume create ${TARGET_VOLUME}
docker run --rm \
  -v ${TARGET_VOLUME}:/target \
  -v /tmp:/backup:ro \
  alpine sh -c "cd /target && tar xzf /backup/volume-backup.tar.gz"
rm /tmp/volume-backup.tar.gz
echo "移行完了。"
EOF
 
# ローカルのバックアップファイルを削除
rm volume-backup.tar.gz
echo "すべての処理が完了しました。"

services:
  app:
    tmpfs:
      - /tmp:size=100m

# xfsでプロジェクトクォータを有効化
docker daemon --storage-opt dm.basesize=20G

# ボリュームサイズの定期チェックスクリプト
docker system df -v | grep "VOLUME" -A 100 | \
  awk '$NF ~ /GB/ && $NF+0 > 10 {print "WARNING: " $1 " is " $NF}'