Docker完全攻略2025：コンテナ基礎からマルチステージビルド、Compose、本番デプロイまで

# cgroupでメモリを256MBに制限する例
sudo cgcreate -g memory:mycontainer
echo 268435456 | sudo tee /sys/fs/cgroup/memory/mycontainer/memory.limit_in_bytes

┌─────────────────────────────────────────────────────────────┐
│              コンテナアーキテクチャ                            │
├──────────┬──────────┬──────────┬──────────┐                 │
│  App A   │  App B   │  App C   │  App D   │                 │
├──────────┼──────────┼──────────┼──────────┤                 │
│  Bins/   │  Bins/   │  Bins/   │  Bins/   │                 │
│  Libs    │  Libs    │  Libs    │  Libs    │                 │
├──────────┴──────────┴──────────┴──────────┤                 │
│           Container Runtime                │                 │
├────────────────────────────────────────────┤                 │
│              Host OS Kernel                │                 │
├────────────────────────────────────────────┤                 │
│              Infrastructure                │                 │
└────────────────────────────────────────────┘                 │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                   VMアーキテクチャ                            │
├──────────┬──────────┬──────────┬──────────┐                 │
│  App A   │  App B   │  App C   │  App D   │                 │
├──────────┼──────────┼──────────┼──────────┤                 │
│  Bins/   │  Bins/   │  Bins/   │  Bins/   │                 │
│  Libs    │  Libs    │  Libs    │  Libs    │                 │
├──────────┼──────────┼──────────┼──────────┤                 │
│ Guest OS │ Guest OS │ Guest OS │ Guest OS │                 │
├──────────┴──────────┴──────────┴──────────┤                 │
│              Hypervisor                    │                 │
├────────────────────────────────────────────┤                 │
│              Host OS                       │                 │
├────────────────────────────────────────────┤                 │
│              Infrastructure                │                 │
└────────────────────────────────────────────┘                 │
└─────────────────────────────────────────────────────────────┘

┌─────────────┐     REST API     ┌─────────────────────┐
│   Docker     │ ──────────────> │   Docker Daemon      │
│   CLI        │                 │   (dockerd)          │
│              │                 │                      │
│  docker run  │                 │  ┌─────────────────┐ │
│  docker build│                 │  │   containerd    │ │
│  docker pull │                 │  │                 │ │
└─────────────┘                 │  │  ┌───────────┐  │ │
                                │  │  │   runc    │  │ │
                                │  │  └───────────┘  │ │
                                │  └─────────────────┘ │
                                └─────────────────────┘

# イメージ管理コマンド
docker images                    # ローカルイメージ一覧
docker pull nginx:1.25-alpine    # イメージダウンロード
docker image inspect nginx       # イメージ詳細情報
docker image prune               # 未使用イメージの整理

# コンテナの実行と管理
docker run -d --name my-nginx -p 8080:80 nginx:1.25-alpine
docker ps                        # 実行中のコンテナ一覧
docker logs my-nginx             # ログ確認
docker exec -it my-nginx /bin/sh # コンテナ内部にアクセス
docker stop my-nginx             # 停止
docker rm my-nginx               # 削除

# ボリュームの作成と使用
docker volume create my-data
docker run -d -v my-data:/app/data my-app
docker run -d -v /host/path:/container/path my-app  # バインドマウント

# ネットワークの作成と管理
docker network create my-network
docker run -d --network my-network --name api my-api
docker run -d --network my-network --name db postgres
# apiコンテナからdb:5432でアクセス可能

# ベースイメージの選択
FROM node:20-alpine

# メタデータの追加
LABEL maintainer="dev@example.com"
LABEL version="1.0"

# ビルド時変数（ビルド時のみ使用可能）
ARG NODE_ENV=production

# 環境変数（ランタイムでも使用可能）
ENV NODE_ENV=$NODE_ENV
ENV PORT=3000

# 作業ディレクトリの設定
WORKDIR /app

# ファイルコピー（COPYを推奨）
COPY package*.json ./

# コマンド実行
RUN npm ci --only=production

# ソースコードのコピー
COPY . .

# ポートのドキュメント化（実際にはポートを開かない）
EXPOSE 3000

# コンテナのヘルスチェック
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1

# 実行ユーザーの変更（セキュリティ）
USER node

# コンテナ起動時に実行するコマンド
ENTRYPOINT ["node"]
CMD ["server.js"]

# CMDのみ使用 - docker run時に完全に上書き可能
CMD ["python", "app.py"]
# docker run my-image python test.py  (CMDがtest.pyに置換)

# ENTRYPOINTのみ使用 - 常に実行される
ENTRYPOINT ["python"]
# docker run my-image app.py  (python app.pyとして実行)

# ENTRYPOINT + CMD の組み合わせ（最も柔軟）
ENTRYPOINT ["python"]
CMD ["app.py"]
# docker run my-image         -> python app.py
# docker run my-image test.py -> python test.py

# ARG: ビルド時にのみ存在（ランタイムには存在しない）
ARG BUILD_VERSION=1.0
RUN echo "Building version: $BUILD_VERSION"

# ENV: ビルド時 + ランタイムの両方で存在
ENV APP_VERSION=1.0
# コンテナ実行時にもAPP_VERSIONが使用可能

# 悪い例: ソース変更時にnpm installが再実行
COPY . .
RUN npm install

# 良い例: package.json変更時にのみnpm installが再実行
COPY package*.json ./
RUN npm ci
COPY . .

# 悪い例: 3つのレイヤーを生成
RUN apt-get update
RUN apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*

# 良い例: 1つのレイヤーを生成 + キャッシュクリア
RUN apt-get update && \
    apt-get install -y --no-install-recommends curl && \
    rm -rf /var/lib/apt/lists/*

# .dockerignore
node_modules
.git
.env
*.md
Dockerfile
docker-compose*.yml
.github
coverage
dist

# Stage 1: ビルド環境
FROM node:20 AS builder
WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

# Stage 2: プロダクション環境
FROM node:20-alpine AS production
WORKDIR /app

# プロダクション依存関係のみインストール
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force

# ビルド成果物のみコピー
COPY --from=builder /app/dist ./dist

# セキュリティ: non-rootユーザー
USER node

EXPOSE 3000
CMD ["node", "dist/server.js"]

# Stage 1: ビルド
FROM golang:1.22-alpine AS builder
WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /app/server .

# Stage 2: 最小イメージ
FROM scratch
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=builder /app/server /server

EXPOSE 8080
ENTRYPOINT ["/server"]

# Stage 1: ビルド
FROM eclipse-temurin:21-jdk AS builder
WORKDIR /app

COPY gradlew build.gradle settings.gradle ./
COPY gradle ./gradle
RUN ./gradlew dependencies --no-daemon

COPY src ./src
RUN ./gradlew bootJar --no-daemon

# Stage 2: ランタイム
FROM eclipse-temurin:21-jre-alpine
WORKDIR /app

COPY --from=builder /app/build/libs/*.jar app.jar

RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring

EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

# Stage 1: 依存関係のビルド
FROM python:3.12-slim AS builder
WORKDIR /app

RUN pip install --no-cache-dir poetry
COPY pyproject.toml poetry.lock ./
RUN poetry export -f requirements.txt -o requirements.txt --without-hashes
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

# Stage 2: ランタイム
FROM python:3.12-slim
WORKDIR /app

COPY --from=builder /install /usr/local
COPY . .

RUN useradd --create-home appuser
USER appuser

EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app.main:app"]

# docker-compose.yml
version: '3.9'

services:
  api:
    build:
      context: ./api
      dockerfile: Dockerfile
    ports:
      - '3000:3000'
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://postgres:secret@db:5432/myapp
      - REDIS_URL=redis://redis:6379
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    healthcheck:
      test: ['CMD', 'wget', '--spider', 'http://localhost:3000/health']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    restart: unless-stopped
    networks:
      - app-network

  db:
    image: postgres:16-alpine
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: secret
    ports:
      - '5432:5432'
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U postgres']
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes --maxmemory 256mb
    volumes:
      - redis-data:/data
    ports:
      - '6379:6379'
    networks:
      - app-network

  nginx:
    image: nginx:1.25-alpine
    ports:
      - '80:80'
      - '443:443'
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      - api
    networks:
      - app-network

volumes:
  postgres-data:
    driver: local
  redis-data:
    driver: local

networks:
  app-network:
    driver: bridge

# .envファイルの使用
services:
  api:
    env_file:
      - .env
      - .env.production

# Docker Secrets（Swarmモード）
services:
  api:
    secrets:
      - db_password
      - api_key

secrets:
  db_password:
    file: ./secrets/db_password.txt
  api_key:
    external: true

# サービスの起動（バックグラウンド）
docker compose up -d

# サービスログの確認
docker compose logs -f api

# サービスのスケーリング
docker compose up -d --scale api=3

# サービスの再ビルド + 再起動
docker compose up -d --build

# サービスの停止とリソースのクリーンアップ
docker compose down

# ボリュームも含めてすべて削除
docker compose down -v

# 特定サービスのみ再起動
docker compose restart api

# 実行中のサービスのステータス確認
docker compose ps

# docker-compose.yml（共通）
services:
  api:
    build: ./api

# docker-compose.override.yml（開発環境 - 自動ロード）
services:
  api:
    volumes:
      - ./api:/app    # ホットリロード用マウント
    environment:
      - DEBUG=true
    command: npm run dev

# docker-compose.prod.yml（本番）
services:
  api:
    environment:
      - NODE_ENV=production
    deploy:
      replicas: 3
      resources:
        limits:
          memory: 512M
          cpus: "0.5"

# 開発環境（overrideファイルが自動ロード）
docker compose up

# 本番環境
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# カスタムネットワークの作成
docker network create my-app

# 同じネットワークでコンテナを実行
docker run -d --name api --network my-app my-api-image
docker run -d --name db --network my-app postgres

# apiコンテナ内部からdbコンテナにアクセス
# ホスト名 "db" が自動的に解決される
curl http://db:5432

# 特定のポートマッピング
docker run -p 8080:80 nginx

# 特定のインターフェースにのみバインド
docker run -p 127.0.0.1:8080:80 nginx

# ランダムなホストポートの割り当て
docker run -p 80 nginx

# 複数のポートマッピング
docker run -p 80:80 -p 443:443 nginx

# Docker Composeでの自動サービスディスカバリ
services:
  api-gateway:
    image: nginx
    depends_on:
      - user-service
      - order-service

  user-service:
    image: my-user-service
    # api-gatewayからhttp://user-service:3000でアクセス可能

  order-service:
    image: my-order-service
    # api-gatewayからhttp://order-service:3000でアクセス可能

# Node.js - 組み込みのnodeユーザーを活用
FROM node:20-alpine
WORKDIR /app
COPY --chown=node:node . .
RUN npm ci --only=production
USER node
CMD ["node", "server.js"]

# カスタムユーザーの作成
FROM python:3.12-slim
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
WORKDIR /app
COPY --chown=appuser:appgroup . .
USER appuser
CMD ["python", "app.py"]

docker run --read-only --tmpfs /tmp --tmpfs /var/run my-app

# Docker Composeで
services:
  api:
    read_only: true
    tmpfs:
      - /tmp
      - /var/run

# Trivyで脆弱性をスキャン
trivy image my-app:latest

# 深刻度でフィルタリング
trivy image --severity HIGH,CRITICAL my-app:latest

# Docker Scout（Docker Desktop内蔵）
docker scout cves my-app:latest
docker scout recommendations my-app:latest

# Snyk
snyk container test my-app:latest

# 絶対にやってはいけません
ENV API_KEY=sk-1234567890
COPY .env /app/.env

# 正しい方法: ビルド時にシークレットをマウント（BuildKit）
RUN --mount=type=secret,id=npmrc,target=/root/.npmrc npm ci

# ビルド時にシークレットを渡す
DOCKER_BUILDKIT=1 docker build --secret id=npmrc,src=.npmrc -t my-app .

# ルートレスモードでDockerをインストール
dockerd-rootless-setuptool.sh install

# 確認
docker info | grep -i rootless
# Security Options: rootless

# Docker Content Trustを有効化
export DOCKER_CONTENT_TRUST=1

# 署名されたイメージのみPull可能
docker pull my-registry/my-app:latest  # 署名がなければ失敗

# Cosignでイメージに署名（Sigstore）
cosign sign my-registry/my-app:latest
cosign verify my-registry/my-app:latest

[セキュリティチェックリスト]
- Non-rootユーザーで実行（USERディレクティブ）
- 最小ベースイメージの使用（Alpine、distroless、scratch）
- イメージ脆弱性の定期スキャン（Trivy、Snyk、Scout）
- Dockerfileにシークレット/認証情報を絶対に含めない
- 読み取り専用ファイルシステムの使用
- ネットワーク露出の最小化
- リソース制限の設定（メモリ、CPU）
- Docker Content Trustの有効化
- ベースイメージの定期的な更新
- 不要なパッケージ/ツールの削除

# .github/workflows/docker-build.yml
name: Docker Build and Push

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: my-org/my-app

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Login to Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: my-username
          password: my-token

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ghcr.io/my-org/my-app
          tags: |
            type=ref,event=branch
            type=sha,prefix=
            type=semver,pattern=v{{version}}

      - name: Build and Push
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: steps.meta.outputs.tags
          labels: steps.meta.outputs.labels
          cache-from: type=gha
          cache-to: type=gha,mode=max
          platforms: linux/amd64,linux/arm64

# Buildxビルダーの作成
docker buildx create --name multiarch --use

# マルチプラットフォームでビルドおよびプッシュ
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --tag my-registry/my-app:latest \
  --push .

# GitHub Actions Cache
- name: Build with cache
  uses: docker/build-push-action@v5
  with:
    cache-from: type=gha
    cache-to: type=gha,mode=max

# レジストリベースのキャッシュ
- name: Build with registry cache
  uses: docker/build-push-action@v5
  with:
    cache-from: type=registry,ref=ghcr.io/my-org/my-app:buildcache
    cache-to: type=registry,ref=ghcr.io/my-org/my-app:buildcache,mode=max

# コンテナのログドライバー設定
docker run -d \
  --log-driver=json-file \
  --log-opt max-size=10m \
  --log-opt max-file=3 \
  my-app

# syslogドライバー
docker run -d \
  --log-driver=syslog \
  --log-opt syslog-address=tcp://logserver:514 \
  my-app

# Docker Composeでのロギング設定
services:
  api:
    logging:
      driver: json-file
      options:
        max-size: '10m'
        max-file: '3'

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - '9090:9090'

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    ports:
      - '8080:8080'

  grafana:
    image: grafana/grafana:latest
    volumes:
      - grafana-data:/var/lib/grafana
    ports:
      - '3000:3000'
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

volumes:
  grafana-data:

# メモリ制限: 512MB（超過時OOM Kill）
docker run -m 512m my-app

# CPU制限: 1.5コア
docker run --cpus="1.5" my-app

# 組み合わせ
docker run -m 512m --cpus="1.5" --memory-swap=1g my-app

# Docker Composeで
services:
  api:
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '1.5'
        reservations:
          memory: 256M
          cpus: '0.5'

// Node.jsの例
process.on('SIGTERM', async () => {
  console.log('SIGTERM received. Graceful shutdown...')

  // 新しいリクエストを拒否
  server.close(async () => {
    // DB接続を閉じる
    await db.close()
    // Redis接続を閉じる
    await redis.quit()

    console.log('All connections closed. Exiting.')
    process.exit(0)
  })

  // 30秒後に強制終了
  setTimeout(() => {
    console.error('Forced shutdown after timeout')
    process.exit(1)
  }, 30000)
})

# Dockerfileでの正しいENTRYPOINT形式
# exec形式を使用（SIGTERMがアプリに直接配信される）
ENTRYPOINT ["node", "server.js"]

# shell形式は使用禁止（SIGTERMがshにのみ配信される）
# ENTRYPOINT node server.js  # これはやめてください

# Dockerfileでのヘルスチェック
HEALTHCHECK --interval=30s --timeout=3s --start-period=30s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

# Docker Composeでのヘルスチェック
services:
  api:
    healthcheck:
      test: ['CMD', 'curl', '-f', 'http://localhost:3000/health']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  db:
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U postgres']
      interval: 10s
      timeout: 5s
      retries: 5

# Dockerとほぼ同じCLI
podman run -d -p 8080:80 nginx
podman ps
podman images

# Docker互換のためのエイリアス
alias docker=podman

# ctr - containerdネイティブCLI（低レベル）
ctr images pull docker.io/library/nginx:latest
ctr run docker.io/library/nginx:latest my-nginx

# Dockerと同じUX
nerdctl run -d -p 8080:80 nginx
nerdctl compose up -d
nerdctl build -t my-app .

# 追加機能: イメージ暗号化
nerdctl image encrypt --recipient jwe:public-key.pem my-app encrypted-app

# NVIDIA Container Toolkitのインストール
distribution=ubuntu22.04
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

# パッケージのインストール
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# Dockerランタイムの設定
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# すべてのGPUを使用
docker run --gpus all nvidia/cuda:12.3-base nvidia-smi

# 特定のGPUのみ使用
docker run --gpus '"device=0,1"' my-ml-app

# Docker Composeで

services:
  ml-training:
    image: my-ml-app
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

# PyTorchモデルサービングDockerfile
FROM pytorch/pytorch:2.2.0-cuda12.1-cudnn8-runtime

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY model/ ./model/
COPY serve.py .

EXPOSE 8000

HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
  CMD curl -f http://localhost:8000/health || exit 1

CMD ["python", "serve.py"]

# TensorFlow Serving
services:
  tf-serving:
    image: tensorflow/serving:latest-gpu
    ports:
      - '8501:8501'
    volumes:
      - ./models:/models
    environment:
      - MODEL_NAME=my_model
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

  triton-server:
    image: nvcr.io/nvidia/tritonserver:24.01-py3
    ports:
      - '8000:8000'
      - '8001:8001'
      - '8002:8002'
    volumes:
      - ./model-repository:/models
    command: tritonserver --model-repository=/models
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]