# ユーザー定義bridgeネットワークを作成
docker network create \
  --driver bridge \
  --subnet 192.168.100.0/24 \
  --gateway 192.168.100.1 \
  --ip-range 192.168.100.128/25 \
  my-app-network
 
# ネットワークの詳細を確認
docker network inspect my-app-network
 
# コンテナをネットワークに接続して起動
docker run -d \
  --name web-server \
  --network my-app-network \
  nginx:alpine
 
docker run -d \
  --name api-server \
  --network my-app-network \
  node:20-alpine sleep infinity
 
# web-server から api-server へ名前解決で通信できる
docker exec web-server ping -c 3 api-server
 
# 既存のコンテナをネットワークに動的に接続
docker network connect my-app-network existing-container
 
# ネットワークから切断
docker network disconnect my-app-network existing-container

# docker-compose.yml
services:
  frontend:
    image: nginx:alpine
    networks:
      - frontend-net
    ports:
      - "80:80"
 
  api:
    build: ./api
    networks:
      - frontend-net
      - backend-net
    environment:
      DB_HOST: database  # DNS名で参照
 
  database:
    image: postgres:16-alpine
    networks:
      - backend-net
    environment:
      POSTGRES_PASSWORD: secret
 
networks:
  frontend-net:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/24
  backend-net:
    driver: bridge
    internal: true  # 外部アクセス不可
    ipam:
      config:
        - subnet: 172.21.0.0/24

# docker-compose.yml - 高度なネットワーク設定
networks:
  # カスタムサブネットとゲートウェイ
  custom-net:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.30.0.0/24
          gateway: 172.30.0.1
          ip_range: 172.30.0.128/25    # IPアドレスの割り当て範囲
 
  # 外部ネットワーク（既に存在するネットワークを参照）
  existing-net:
    external: true
    name: my-existing-network
 
  # MTUとドライバーオプション
  optimized-net:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.enable_icc: "true"           # コンテナ間通信
      com.docker.network.bridge.enable_ip_masquerade: "true"  # IPマスカレード
      com.docker.network.bridge.host_binding_ipv4: "0.0.0.0"  # バインドIP
      com.docker.network.driver.mtu: "1500"                   # MTU
    labels:
      environment: production
      team: platform

services:
  app:
    image: my-app:latest
    networks:
      app-net:
        ipv4_address: 172.25.0.10
        aliases:
          - application
          - webapp
 
  db:
    image: postgres:16-alpine
    networks:
      app-net:
        ipv4_address: 172.25.0.20
        aliases:
          - database
          - postgres
 
  cache:
    image: redis:7-alpine
    networks:
      app-net:
        ipv4_address: 172.25.0.30
        aliases:
          - redis
          - cache
 
networks:
  app-net:
    driver: bridge
    ipam:
      config:
        - subnet: 172.25.0.0/24
          gateway: 172.25.0.1

# 基本: ホストの8080番をコンテナの80番にマッピング
docker run -d -p 8080:80 nginx:alpine
 
# 特定IPにバインド（localhostのみ公開）
docker run -d -p 127.0.0.1:8080:80 nginx:alpine
 
# UDPポートの公開
docker run -d -p 5353:53/udp dns-server
 
# ランダムポート割当（ホスト側ポートを自動決定）
docker run -d -p 80 nginx:alpine
# → docker port <container> で確認
 
# 複数ポートの公開
docker run -d \
  -p 80:80 \
  -p 443:443 \
  -p 8443:8443 \
  nginx:alpine
 
# ポート範囲の公開
docker run -d -p 7000-7010:7000-7010 my-app
 
# TCP と UDP の両方を公開
docker run -d -p 53:53/tcp -p 53:53/udp dns-server
 
# 全ポートを公開 (-P: Dockerfile の EXPOSE で定義されたポート)
docker run -d -P nginx:alpine

services:
  web:
    image: nginx:alpine
    ports:
      # 短縮構文
      - "80:80"                    # ホスト:コンテナ
      - "443:443"
      - "127.0.0.1:8080:80"       # 特定IPにバインド
 
      # 長文構文（推奨: 意図が明確）
      - target: 80                 # コンテナ側ポート
        published: 8080            # ホスト側ポート
        protocol: tcp
        mode: host                 # host or ingress
 
  db:
    image: postgres:16-alpine
    ports:
      # 開発時のみ外部公開（本番では expose のみ）
      - "127.0.0.1:5432:5432"
 
    # expose: コンテナ間通信のみ（ホストには非公開）
    expose:
      - "5432"

# .env ファイルでポートを変数化
APP_PORT=3000
DB_PORT=5432
REDIS_PORT=6379
 
# docker-compose.yml
services:
  app:
    ports:
      - "${APP_PORT:-3000}:3000"
  db:
    ports:
      - "127.0.0.1:${DB_PORT:-5432}:5432"
  redis:
    ports:
      - "127.0.0.1:${REDIS_PORT:-6379}:6379"

# hostネットワークでNginxを起動
# コンテナのポート80がそのままホストのポート80になる
docker run -d \
  --network host \
  --name web \
  nginx:alpine
 
# ポートマッピング不要（-p フラグは無視される）
curl http://localhost:80
 
# host ネットワークの確認
docker inspect web --format '{{.NetworkSettings.Networks}}'

services:
  # パフォーマンスが重要なサービス
  high-perf-app:
    image: my-app:latest
    network_mode: host
    # ports: は使用不可（hostネットワークでは無視される）
    environment:
      PORT: 8080
 
  # 監視ツール（ホストのネットワークを監視）
  prometheus:
    image: prom/prometheus:latest
    network_mode: host
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

# Swarmを初期化（マネージャーノード）
docker swarm init --advertise-addr 192.168.1.10
 
# ワーカーノードをSwarmに参加
docker swarm join --token SWMTKN-xxx 192.168.1.10:2377
 
# 暗号化付きオーバーレイネットワークを作成
docker network create \
  --driver overlay \
  --subnet 10.10.0.0/16 \
  --opt encrypted \
  --attachable \
  my-overlay
 
# サービスをオーバーレイネットワーク上にデプロイ
docker service create \
  --name web \
  --network my-overlay \
  --replicas 3 \
  --publish published=80,target=80 \
  nginx:alpine
 
# ネットワーク状態の確認
docker network inspect my-overlay
 
# オーバーレイネットワークの暗号化状態を確認
docker network inspect my-overlay --format '{{.Options}}'

# docker-compose.yml (Swarm mode)
services:
  web:
    image: nginx:alpine
    deploy:
      replicas: 3
      placement:
        constraints:
          - node.role == worker
    networks:
      - frontend
 
  api:
    image: my-api:latest
    deploy:
      replicas: 2
    networks:
      - frontend
      - backend
 
  db:
    image: postgres:16-alpine
    deploy:
      replicas: 1
      placement:
        constraints:
          - node.labels.type == db
    networks:
      - backend
    volumes:
      - pgdata:/var/lib/postgresql/data
 
networks:
  frontend:
    driver: overlay
  backend:
    driver: overlay
    internal: true     # 外部アクセス不可
    driver_opts:
      encrypted: "true"  # IPsec暗号化
 
volumes:
  pgdata:

# macvlan ネットワークの作成
docker network create \
  --driver macvlan \
  --subnet 192.168.1.0/24 \
  --gateway 192.168.1.1 \
  --opt parent=eth0 \
  macvlan-net
 
# コンテナを macvlan ネットワークに接続
docker run -d \
  --name legacy-app \
  --network macvlan-net \
  --ip 192.168.1.100 \
  legacy-app:latest
 
# 802.1Q VLAN タグ付き macvlan
docker network create \
  --driver macvlan \
  --subnet 192.168.10.0/24 \
  --gateway 192.168.10.1 \
  --opt parent=eth0.10 \
  macvlan-vlan10

# docker-compose.yml
services:
  app:
    image: my-app:latest
    networks:
      app-net:
        aliases:
          - application
          - webapp
 
  cache-primary:
    image: redis:7-alpine
    networks:
      app-net:
        aliases:
          - redis
          - cache
 
  cache-replica:
    image: redis:7-alpine
    command: redis-server --replicaof redis 6379
    networks:
      app-net:
        aliases:
          - redis    # 同一エイリアスでラウンドロビンDNS
          - cache
 
networks:
  app-net:
    driver: bridge

# DNS解決の確認
docker run --rm --network app-net busybox nslookup redis
# → cache-primary と cache-replica の両方のIPが返る
 
# 特定コンテナのDNS設定を確認
docker exec app cat /etc/resolv.conf
 
# DNS解決のテスト（dig コマンド）
docker run --rm --network app-net tutum/dnsutils dig redis
 
# 逆引きDNS
docker run --rm --network app-net busybox nslookup 172.20.0.3

services:
  app:
    image: my-app:latest
    dns:
      - 8.8.8.8
      - 8.8.4.4
    dns_search:
      - example.com
      - internal.example.com
    dns_opt:
      - "ndots:2"
      - "timeout:3"
    extra_hosts:
      - "host.docker.internal:host-gateway"   # ホストマシンへのアクセス
      - "legacy-server:192.168.1.100"         # 手動DNS設定

# docker-compose.yml - マイクロサービス構成
services:
  # --- フロントエンド層 ---
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    networks:
      - public
      - app-tier
    depends_on:
      - frontend
 
  frontend:
    build: ./frontend
    networks:
      - app-tier
 
  # --- アプリケーション層 ---
  user-service:
    build: ./services/user
    networks:
      - app-tier
      - data-tier
 
  order-service:
    build: ./services/order
    networks:
      - app-tier
      - data-tier
      - message-tier
 
  notification-service:
    build: ./services/notification
    networks:
      - app-tier
      - message-tier
 
  # --- メッセージング層 ---
  rabbitmq:
    image: rabbitmq:3-management-alpine
    networks:
      - message-tier
 
  # --- データ層 ---
  postgres:
    image: postgres:16-alpine
    networks:
      - data-tier
 
  redis:
    image: redis:7-alpine
    networks:
      - data-tier
 
networks:
  public:
    driver: bridge
  app-tier:
    driver: bridge
    internal: false
  data-tier:
    driver: bridge
    internal: true   # 外部アクセスを完全遮断
  message-tier:
    driver: bridge
    internal: true

# docker-compose.yml - マルチテナント構成
services:
  # 共有リバースプロキシ
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    networks:
      - proxy-net
 
  # テナントA
  tenant-a-app:
    image: my-app:latest
    environment:
      TENANT_ID: tenant-a
    networks:
      - proxy-net
      - tenant-a-net
 
  tenant-a-db:
    image: postgres:16-alpine
    networks:
      - tenant-a-net    # テナントA専用ネットワークのみ
 
  # テナントB
  tenant-b-app:
    image: my-app:latest
    environment:
      TENANT_ID: tenant-b
    networks:
      - proxy-net
      - tenant-b-net
 
  tenant-b-db:
    image: postgres:16-alpine
    networks:
      - tenant-b-net    # テナントB専用ネットワークのみ
 
networks:
  proxy-net:
    driver: bridge
  tenant-a-net:
    driver: bridge
    internal: true     # テナントAのDBは外部アクセス不可
  tenant-b-net:
    driver: bridge
    internal: true     # テナントBのDBも外部アクセス不可

# ネットワーク一覧を確認
docker network ls
 
# 特定ネットワークの詳細（接続コンテナ、IPAM設定）
docker network inspect my-app-network
 
# コンテナのネットワーク設定を確認
docker inspect --format='{{json .NetworkSettings.Networks}}' my-container | jq .
 
# コンテナのIPアドレスを取得
docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' my-container
 
# コンテナのポートマッピングを確認
docker port my-container
 
# コンテナ内からネットワーク診断
docker run --rm --network my-app-network nicolaka/netshoot \
  bash -c "
    # DNS解決テスト
    nslookup api-server
    # TCP接続テスト
    nc -zv api-server 8080
    # ルーティング確認
    ip route
    # ネットワークインターフェース確認
    ip addr
    # TCPダンプ（パケットキャプチャ）
    tcpdump -i eth0 -c 20 port 80
  "
 
# ホスト側からiptablesルールを確認
sudo iptables -t nat -L -n | grep DOCKER
 
# Docker ネットワーク関連のイベントを監視
docker events --filter type=network
 
# 使用されていないネットワークの一括削除
docker network prune

# netshoot コンテナで対象ネットワークに接続して診断
docker run -it --rm --network my-app-network nicolaka/netshoot
 
# 内部で使えるコマンド:
# ping, traceroute, nslookup, dig
# curl, wget, nc (netcat)
# tcpdump, iperf, mtr
# ip, ss, netstat
# nmap, iftop
 
# 例: コンテナ間の帯域幅テスト
# サーバー側
docker run -d --name iperf-server --network my-app-network nicolaka/netshoot iperf3 -s
# クライアント側
docker run --rm --network my-app-network nicolaka/netshoot iperf3 -c iperf-server

# docker-compose.yml - IPv6 有効化
services:
  app:
    image: my-app:latest
    networks:
      - dual-stack
 
networks:
  dual-stack:
    driver: bridge
    enable_ipv6: true
    ipam:
      config:
        - subnet: 172.28.0.0/24    # IPv4
        - subnet: fd00::/64         # IPv6 ULA

# Docker デーモンでIPv6を有効化
# /etc/docker/daemon.json
{
  "ipv6": true,
  "fixed-cidr-v6": "fd00::/80"
}

# NG: デフォルトbridgeではDNS解決が機能しない
docker run -d --name app1 my-app
docker run -d --name app2 my-app
docker exec app1 ping app2  # 失敗: 名前解決できない
 
# OK: ユーザー定義ネットワークを使う
docker network create my-net
docker run -d --name app1 --network my-net my-app
docker run -d --name app2 --network my-net my-app
docker exec app1 ping app2  # 成功

# NG: 全サービスがフラットに通信可能
services:
  nginx:
    networks: [shared]
  app:
    networks: [shared]
  database:
    networks: [shared]  # フロントエンドからDBに直接到達可能
 
# OK: 層ごとにネットワークを分離
services:
  nginx:
    networks: [frontend]
  app:
    networks: [frontend, backend]
  database:
    networks: [backend]  # backendからのみアクセス可能

# NG: 0.0.0.0 にバインド（全インターフェースに公開）
docker run -d -p 5432:5432 postgres:16
 
# OK: localhostのみにバインド
docker run -d -p 127.0.0.1:5432:5432 postgres:16

# NG: IPアドレスをハードコード
services:
  app:
    environment:
      DB_HOST: 172.18.0.5  # IPアドレスは変わる可能性がある
 
# OK: DNS名（サービス名）を使用
services:
  app:
    environment:
      DB_HOST: database    # Composeのサービス名はDNSで解決される

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

networks:
  backend:
    name: my-custom-backend  # 明示的な名前指定

services:
  app:
    extra_hosts:
      - "host.docker.internal:host-gateway"
    environment:
      HOST_API: http://host.docker.internal:4000

# プロジェクトA (共有ネットワークを作成)
networks:
  shared:
    name: shared-network
    driver: bridge
 
# プロジェクトB (既存ネットワークに参加)
networks:
  shared:
    external: true
    name: shared-network

# 手動で共有ネットワークを作成
docker network create shared-network
 
# プロジェクトBからも利用可能
docker compose up -d

services:
  app:
    networks:
      frontend:
        priority: 1000   # 高い値が優先
      backend:
        priority: 500
      monitoring:
        priority: 100
 
networks:
  frontend:
  backend:
    internal: true
  monitoring:
    internal: true

# tc（Traffic Control）によるコンテナの帯域幅制限
# コンテナのvethインターフェースを特定
CONTAINER_PID=$(docker inspect -f '{{.State.Pid}}' mycontainer)
VETH=$(ip link | grep -A1 "if${CONTAINER_PID}" | head -1 | awk '{print $2}' | tr -d ':')
 
# 帯域幅を100Mbpsに制限
tc qdisc add dev ${VETH} root tbf rate 100mbit burst 32kbit latency 100ms

# Docker Swarmモードでのリソース制限
services:
  app:
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
        reservations:
          cpus: "0.5"
          memory: 256M

{
  "ipv6": true,
  "fixed-cidr-v6": "2001:db8:1::/64"
}

# docker-compose.yml
networks:
  dual-stack:
    enable_ipv6: true
    ipam:
      config:
        - subnet: 172.28.0.0/16
        - subnet: "2001:db8:2::/64"
 
services:
  app:
    networks:
      dual-stack:
        ipv4_address: 172.28.0.10
        ipv6_address: "2001:db8:2::10"