🐳 Docker 完全ガイド — 図解付きで詳しく学ぶ

出典: Medium, DEV Community, Spacelift, ITcross, Qiita, Zenn, CircleCI などの複数の技術記事を総合
作成日: 2026年4月25日

目次
1. Docker とは何か
1. コンテナとは？
2. なぜ Docker が注目されるのか
1. Docker が解決する課題 — “It works on my machine”
3. コンテナ VS 仮想マシン（VM）
1. アーキテクチャ図で比較
2. 比較表
4. Docker のアーキテクチャ
1. Docker の全体構成図（High-Level Architecture）
2. もう一つの視点 — コンポーネント相互作用図
5. Docker コンポーネントの詳細解説
1. 主要6コンポーネントの役割
2. Airport（空港）アナロジー — 記憶するためのたとえ
6. イメージ vs コンテナ — 根本的な違い
1. イメージ（Image）とコンテナ（Container）の関係を図解
2. イメージとコンテナの比較表
7. Docker の内部動作 — docker run の裏側
1. docker run nginx を実行した時の全体フロー図
2. もう一つのフロー図（ステップバイステップ）
8. Layered Filesystem（階層ファイルシステム）
9. 基礎知識: Namespaces と cgroups
10. Docker の基本的な使い方の流れ
1. 全体のライフサイクル図
2. 基本的な使い方の例
11. Dockerfile の書き方
12. Docker Compose 入門
13. Docker ネットワークとボリューム
1. 13-1. Docker ネットワーク
2. 13-2. Docker ボリューム
14. よく使う Docker コマンド一覧
1. オススメのコマンドリファレンス集
15. Docker の活用法・活用シーン
1. Dockerがよく使われる主要5つのシナリオ
16. つまずきポイントと解決策
1. よくあるエラーと対処法
17. まとめ
1. Docker 全体を振り返る

Docker とは何か
なぜ Docker が注目されるのか
コンテナ VS 仮想マシン (VM)
Docker のアーキテクチャ（構造図）
Docker コンポーネントの詳細解説
イメージ vs コンテナ — 根本的な違い
Docker の内部動作 — docker run の裏側
Layered Filesystem（階層ファイルシステム）
基礎知識: Namespaces と cgroups
Docker の基本的な使い方の流れ
Dockerfile の書き方
Docker Compose 入門
Docker ネットワークとボリューム
よく使う Docker コマンド一覧
Docker の活用法・活用シーン
つまずきポイントと解決策
まとめ

1. Docker とは何か

Docker は、アプリケーションを「コンテナ」という軽量で独立した実行環境にまとめて、どこでも同じように動かせるプラットフォームです。

2013年にDocker社（旧dotCloud社）によってオープンソースとして公開されて以来、世界中のエンジニアに支持されています。

コンテナとは？

コンテナとは、アプリケーションとその実行に必要なライブラリや依存関係、設定ファイルをひとまとめにした軽量な仮想環境です。

従来の仮想マシン（VM）とは異なり、OSカーネルをホストマシンと共有するため、起動が非常に高速で、リソース消費も最小限に抑えられます。

2. なぜ Docker が注目されるのか

メリット	説明
環境の再現性	「自分のPCでは動くのに本番では動かない」問題を解消
軽量・高速	VMに比べてリソース消費が少なく、起動も数秒
ポータビリティ	どの環境（開発/テスト/本番）でも同じコンテナが動作する
チーム開発の効率化	チーム全員が同一の開発環境を瞬時に構築できる
CI/CDとの親和性	自動テストやデプロイのパイプラインに組み込みやすい

Docker が解決する課題 — “It works on my machine”

┌─────────────────────────────────────────────────────┐
│          伝統的な開発環境の課題                        │
├─────────────────────────────────────────────────────┤
│                                                     │
│   開発者AのPC           開発者BのPC     本番サーバー │
│   Python 3.9            Python 3.11    Python 3.8    │
│   Ubuntu 20.04          macOS 12       CentOS 7      │
│   MySQL 5.7             PostgreSQL     MySQL 8.0     │
│                                                     │
│           ↑ ↑ ↑                                     │
│   「環境がバラバラ → 不具合の温床」                │
│                                                     │
└─────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│              Docker 導入後                          │
├─────────────────────────────────────────────────────┤
│                                                     │
│   誰のPCでも → 同じコンテナ画像 = 同じ環境 🎉       │
│                                                     │
│   開発者A ◀── Docker Image ───▶ 開発者B            │
│         ───▶ 本番サーバー                            │
│   全員が「同じ」環境で動作                             │
│                                                     │
└─────────────────────────────────────────────────────┘

3. コンテナ VS 仮想マシン（VM）

アーキテクチャ図で比較

┌──────────────────────────────────────────────────────────┐
│                    【ホスト OS（OSカーネル共有型）】        │
│                  ┌─────────────────────┐                  │
│                  │    ホスト カーネル   │                  │
│                  └──────────┬──────────┘                  │
│                             │                             │
│              ┌──────────────┼──────────────┐            │
│              │             ▼              │            │
│     ┌────────┴────────┐  ┌─┴────────┐   │            │
│     │  コンテナ A     │  │コンテナ B │   │            │
│     │  (Linux)        │  │(Node.js) │   │            │
│     │  ├Python runtime│  │├NPM      │   │            │
│     │  └Libraries     │  │└Libraries│   │            │
│     └─────────────────┘  └──────────┘   │            │
│                                           │            │
│    【Docker】                            │            │
│    軽量 / 高速 / アプリケーション単位     │            │
│         │                                │            │
│         ▼                                │            │
│  ┌──────────────────────────────────────┴──────────┐  │
│  │               【VM アーキテクチャ】               │  │
│  │                                                 │  │
│  │  ┌─────────────┐  ┌──────────────────────┐    │  │
│  │  │ ゲスト OS-A  │  │     ゲスト OS-B      │    │  │
│  │  │ (Ubuntu)    │  │   (Windows Server)   │    │  │
│  │  │ ├カーネル   │  │   ├カーネル          │    │  │
│  │  │ └Libraries  │  │   └Libraries        │    │  │
│  │  └──────┬──────┘  └─────────┬──────────┘    │  │
│  │         │                    │               │  │
│  │    ┌────┴────┐          ┌────┴────┐        │  │
│  │    │ VM-A    │          │ VM-B    │        │  │
│  │    └─────────┘          └─────────┘        │  │
│  │                                                 │  │
│  │  【Hypervisor】 ← ハードウェアの仮想化層      │  │
│  └───────────────────────────────────────────────┘  │
│                                                      │
│  重い / 起動に時間 / OS単位                          │
│                                                      │
└──────────────────────────────────────────────────────┘

比較表

項目	Docker コンテナ	仮想マシン（VM）
カーネル	ホストOSを共有	各VMが独立したカーネルを持つ
起動時間	数秒〜ミリ秒	数分
リソース消費	最小限（MB単位）	大きい（GB単位）
изоляцияレベル	アプリケーション単位	ハードウェア/OS単位
ファイルサイズ	数十MB	数GB〜
性能オーバーヘッド	ほぼなし	Hypervisor分のオーバーヘッド

4. Docker のアーキテクチャ

Docker の全体構成図（High-Level Architecture）

┌───────────────────────────────────────────────────────────────────┐
│                        DOCKER ARCHITECTURE                         │
│                                                                     │
│  ┌────────────┐                                                   │
│  │ Docker CLI  │  ← ユーザーが操作するコマンドライン               │
│  │ (docker)   │     "docker run nginx" など                       │
│  └──────┬─────┘                                                   │
│         │ REST API (Unix Socket / TLS)                             │
│         ▼                                                         │
│  ┌────────────┐             ┌─────────────┐                      │
│  │  dockerd    │◀───────────▶│ Docker API  │   ← バックエンド    │
│  │  (Daemon)   │             │ Server      │                      │
│  │              │             └──────┬──────┘                      │
│  │ • コンテナ管理 │                    │                            │
│  │ • イメージ管理 │     ┌──────────────┴──────────────┐           │
│  │ • ネットワーク │     │          containerd         │           │
│  │ • ボリューム   │     │    (Container Runtime Mgr)  │           │
│  │ • 画像レジスト │     └──────────────┬──────────────┘           │
│  └──────────────┘                     │                            │
│                                       ▼                            │
│                              ┌──────────────────┐                  │
│                              │   containerd-shim  │  ← プロセス監視 │
│                              └──────────┬─────────┘                  │
│                                         │                           │
│                                         ▼                           │
│                              ┌──────────────────┐                  │
│                              │       runc         │  ← OCIランタイム │
│                              │ (コンテナ作成実行)  │                  │
│                              └──────────┬─────────┘                  │
│                                         │                           │
│                                         ▼                           │
│                              ┌──────────────────┐                  │
│                              │   Linux Kernel    │  ← カーネル機能  │
│                              │ • Namespaces      │   (隔離・制御)   │
│                              │ • cgroups         │   リソース管理   │
│                              │ • OverlayFS       │   ファイルシステム│
│                              │ • Network(veth)   │   ネットワーク   │
│                              └──────────────────┘                  │
│                                                                     │
└───────────────────────────────────────────────────────────────────┘

もう一つの視点 — コンポーネント相互作用図

                    ┌──────────────┐
       ユーザー ──▶│ Docker CLI   │
    (ターミナル操作)│  docker xxx  │
                    └──────┬───────┘
                           │ REST API
                           ▼
    ┌──────────────────────────────────────────┐
    │              dockerd (Daemon)            │
    │                                          │
    │  Docker API   ←→  Containerd             │
    │  (gRPC通信で連携)                          │
    │     │                                    │
    │     ├── Image Store                      │
    │     ├── Network Manager                  │
    │     └── Volume Manager                   │
    └──────────────────────────────────────────┘
                           │
                           ▼
              ┌─────────────────────┐
              │    containerd       │
              │  (ランタイム管理)    │
              │                     │
              │  containerd-shim → runc
              │          │         │
              │          ▼         ▼
              │      Kernel     Namespace
              │    cgroups     OverlayFS
              └─────────────────────┘

5. Docker コンポーネントの詳細解説

主要6コンポーネントの役割

① Docker CLI（コマンドラインインターフェース）

役割: ユーザーがDockerを操作するためのターミナルツール
動作: コマンドをREST APIリクエストに変換し、dockerdに送信
例: docker run, docker build, docker images などのコマンド群

# ユーザーがCLIを通じてコマンドを入力
$ docker run -d --name myapp nginx:latest
# ↑ このCLIは docker にリクエストを送る

② dockerd（Docker Daemon / バックエンドサーバー）

役割: Dockerの中心プロセス。すべてのAPIリクエストを処理
詳細機能:
コンテナライフサイクル管理
イメージのビルドと管理
ネットワーク設定
ボリューム管理
他のコンポーネント（containerdなど）への指示
重要なポイント: dockerデーモンは常にバックグラウンドで稼働している必要がある

# デーモンの状態確認
$ systemctl status docker

# Dockerデーモンの設定ファイル
/etc/docker/daemon.json

③ containerd（コンテナランタイムマネージャー）

役割: コンテナの実際のライフサイクルを管理
詳細機能:
イメージのプル・プッシュ・保存
ファイルシステムスナップショット
コンテナの起動/停止
OCI Runtime Spec を containerd-shim に渡す
技術: gRPC で Docker デーモンと通信

# containerd の状態確認
$ sudo systemctl status containerd

④ containerd-shim（プロセススーパーバイザー）

役割: runc の前後でコンテナのプロセス監視を担当
重要な特徴:
runc がプロセスを起動したらexitするため、代わりにshimが監視
dockerd/containerd が再起動しても、shimが存在すればコンテナは維持される
イオーストリーム（ログ出力など）の管理

⑤ runc（OCI標準ランタイム）

役割: 実際に対応カーネル機能を使ってコンテナを生成する低レベルツール
詳細機能:
Namespaces の作成
cgroups の制限適用
rootfs のマウント
エントリポイントの実行
重要ポイント: runcは一度コンテナを作るとすぐにexitする（監視はshimが担当）

# ruc自体が使われていることを確認（containerd内部で）
$ journalctl -u containerd

⑥ Linux Kernel（Linuxカーネル — コアの隔離機能）

機能	説明
Namespaces	プロセスの隔離。各コンテナは独立したPID、ネットワーク、ファイルシステムなどを見る
cgroups	リソース制限。CPU/メモリ/I/Oの使用量を制限・監視
OverlayFS	階層ファイルシステム。イメージのレイヤを積層して管理
Network (veth)	バーチャルイーサーネットペアにより、コンテナ間の通信を可能に

Airport（空港）アナロジー — 記憶するためのたとえ

┌───────────────────────────────────────────────────┐
│         🛫 Docker コンポーネント vs 空港            │
├──────────┬────────────┬───────────────────────────┤
│ コンポー- │ 空港での   │ 実際の意味               │
│ ねント   │ 役割       │                          │
├──────────┼────────────┼───────────────────────────┤
│ Docker CLI │ 旅客ターミ │ パッセンジャが「docker run」│
│          │ 널（ターミ）│ を入力する                │
│ dockerd   │ 空港管理   │ 全てのフライト/ゲートを管  │
│          │ センター    │ 理                         │
│ containerd│ グラウンド  │ ラグ(イメージ)の読み込   │
│          │ コントロール│ み、滑走路のアサイン       │
│ container- │ ギャtoff  │ プレインを準備。再始動   │
│ d-shim    │ 係員      │ しても機体を維持           │
│ runc     │ パイロット  │ 実際に飛行(コンテナ実行)   │
│ Linux Kernel │ 航空管  │ 空中交通制御(リソース限  │
│          │ 制 (ATC)   │ 制、衝突防止)             │
│ Container │ 実際のフ   │ 旅客が搭乗して飛ぶアプリ  │
│          │ ライト     │ ケーション                 │
└──────────┴────────────┴───────────────────────────┘

6. イメージ vs コンテナ — 根本的な違い

イメージ（Image）とコンテナ（Container）の関係を図解

┌───────────────────────────────────────────────────────────┐
│              イメージとコンテナの関係                        │
├───────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────────┐                                          │
│   │  Dockerfile  │     "設計図を書く"                      │
│   │ (レシピ)     │                                          │
│   └──────┬──────┘                                          │
│          │ docker build                                     │
│          ▼                                                 │
│   ┌─────────────┐           イメージ（Image）             │
│   │  読取り専用   │    = 料理の「レシピ」                  │
│   │  ファイル   │                                            │
│   │  システム    │    ・ベースイメージ（食材）            │
│   └─────────────┘    ・RUN命令でレイヤ追加                │
│          │             （調理手順）                        │
│          │ docker run                                    │
│          ▼                                                 │
│   ┌─────────────┐           コンテナ（Container）         │
│   │  読み書き可能 │    = レシピで作った「料理」            │
│   │  実行環境    │                                            │
│   │  （Writable  │    ・実実行体                         │
│   │   Layer）    │    ・起動/停止/再開が可能              │
│   └─────────────┘    ・複数作成可能                        │
│          │                                                 │
│          ▼                                                 │
│   ══════════════════════════════════════════════════       │
│   イメージ（設計図） 1つ → コンテナ（実行体） 複数作成      │
│                                                     ║     │
│                                                   ┌┴┐    │
│                                                 ① │2│    │
│                                                    └┬┘   │
│       イメージ ◀─────────▶ [複数のコンテナ]              │
└───────────────────────────────────────────────────────┘

イメージとコンテナの比較表

項目	Docker イメージ（Image）	Docker コンテナ（Container）
性質	読み取り専用テンプレート	実行環境（インスタンス）
役割	コンテナを作る設計図	実際に動く実体
たとえ	レシピ（レシピ）	レシピから作った料理
作成コマンド	`docker build`, `docker pull`	`docker run`, `docker create`
管理コマンド	`docker images`, `docker rmi`	`docker ps`, `docker stop`
変更	不可（イミュータブル）	可能（書き込み層がある）
ライフサイクル	静的・保存される	起動/停止/再起動/破棄

7. Docker の内部動作 — docker run の裏側

docker run nginx を実行した時の全体フロー図

┌───────────────────────────────────────────────────────────────────┐
│              docker run -d -p 8080:80 nginx を実行！               │
│                                                                      │
│  [Step 1] CLI → dockerd                                             │
│  ┌──────────────────────┐                                          │
│  │ Docker CLI           │                                          │
│  │ "docker run ..."     │─ REST API ─▶ dockerd                    │
│  │ (Unix Socket経由)    │   JSONペイロード                           │
│  └──────────────────────┘                                          │
│                                                                      │
│  [Step 2] dockerd の検証                                           │
│  - コマンドの妥当性チェック                                        │
│  - ローカルイメージ有無の確認                                      │
│  - コンテナ作成の調整                                              │
│                                                                      │
│  [Step 3] イメージ Pull（必要な場合）                                │
│  ┌──────────────────────┐                                          │
│  │ containerd           │                                          │
│  │ • レジストリ認証      │──▶ Docker Hub                           │
│  │ • マニフェスト解決    │   "nginx" イメージを取得                 │
│  │ • Layer ダウンロード & │   → ローカルImage Storeに保存          │
│  │   検証               │                                          │
│  └──────────┬───────────┘                                          │
│             │                                                      │
│  [Step 4] ファイルシステム組み立て                                  │
│  containerd が準備:                                                │
│  • Snapshot (ファイルシステムスナップショット)                      │
│  • OverlayFS Upper/LowerDir 配置                                  │
│  • OCI Bundle（メタデータ/ランタイム設定）                          │
│                                                                      │
│  [Step 5] ネットワーク設定                                         │
│  dockerd が:                                                       │
│  • veth ペア作成                                                   │
│  • Host側を docker0 ブリッジに追加                                │
│  • コンテナにIP付与 (例: 172.17.0.2)                              │
│  • iptables DNAT (ポートフォワーディング: 8080→80)                │
│  • MASQUERADE ルール設定                                           │
│                                                                      │
│  [Step 6] containerd → containerd-shim                             │
│  containerd が:                                                    │
│  • shim を起動                                                     │
│  • OCI Spec を引き渡す                                             │
│  • ライフサイクル管理を委譲                                        │
│                                                                      │
│  [Step 7] shim → runc → Linux Kernel                               │
│  runc が:                                                          │
│  • Namespaces 作成 (PID, NET, MNT, USR, IPC, USER)                │
│  • rootfs マウント                                                  │
│  • cgroups 制限適用                                                 │
│  • コンテナエントリポイント実行                                    │
│  • **runc はexit（監視はshimが担当）**                               │
│                                                                      │
│  [Step 8] コンテナ実行完了                                         │
│  • shim がプロセスを監視                                           │
│  • dockerd がログストリーミング                                     │
│  • カーネルが隔離・リソース制限を適用                              │
│                                                                      │
│  ══════════════════════════════════════════════════                │
│  nginx コンテナがホストの8080番ポートで動作開始！                   │
└───────────────────────────────────────────────────────────────────┘

もう一つのフロー図（ステップバイステップ）

docker run -d -p 8080:80 nginx
         │
         ▼
┌──────────────────┐
│ Step 1: CLI       │
│ "docker run ..."  │
└───────┬──────────┘
        │ REST API (JSON)
        ▼
┌──────────────────┐
│ Step 2: dockerd   │
│ バリデーション    │
└───────┬──────────┘
        │
        ▼
┌──────────────────┐
│ Step 3: Pull      │  ← ローカルにイメージがなければ
│ イメージ取得     │
│ (containerd)     │
└───────┬──────────┘
        │
        ▼
┌──────────────────┐
│ Step 4: FS Assembly│
│ ファイルシステム   │
│ 組み立て         │
└───────┬──────────┘
        │
        ▼
┌──────────────────┐
│ Step 5: Network   │
│ ポートマッピング  │
│ (8080:80)       │
└───────┬──────────┘
        │
        ▼
┌──────────────────┐
│ Step 6: containerd│
│ → containerd-shim │
└───────┬──────────┘
        │
        ▼
┌──────────────────┐
│ Step 7: runc      │
│ Namespaces,cgroups│
│ + カーネル実行    │
└───────┬──────────┘
        │
        ▼
┌──────────────────┐
│ Step 8: 実行完了！ │
│ コンテナ動作開始   │
└──────────────────┘

8. Layered Filesystem（階層ファイルシステム）

Docker イメージのレイヤ構造図

┌─────────────────────────────────────────────────────┐
│              Layered Filesystem（OverlayFS）          │
│                                                       │
│  ┌───────────────────┐                                │
│  │  Container Layer   │ ◀─ 各コンテナに「書き込み」層 │
│  │  （読み書き可能）   │    が自動で追加される         │
│  └────────┬──────────┘                                │
│  ┌────────▼──────────┐                                │
│  │      Layer N       │ ◀─ RUN apt-get update          │
│  └────────┬──────────┘                                │
│  ┌────────▼──────────┐                                │
│  │      Layer N-1     │ ◀─ COPY ./app /app             │
│  └────────┬──────────┘                                │
│  ┌────────▼──────────┐                                │
│  │      ...           │                                │
│  └────────┬──────────┘                                │
│  ┌────────▼──────────┐                                │
│  │      Layer 2       │ ◀─ RUN pip install             │
│  └────────┬──────────┘                                │
│  ┌────────▼──────────┐                                │
│  │      Layer 1       │ ◀─ FROM python:3.12           │
│  └────────┬──────────┘                                │
│             ▼                                           │
│  ┌───────────────────┐                                │
│  │   共有されるレイヤ │ ◀─ 他のイメージとLayerを共有  │
│  └───────────────────┘    → ディスク節約              │
│                                                       │
│  OverlayFS の仕組み:                                   │
│  ┌──────────────┐                                     │
│  │  MergedDir   │ ◀─ コンテナから見える единое 文件系统 │
│  │ (統合表示)    │                                       │
│  └──────┬───────┘                                       │
│         ├─ UpperDir（変更/新規ファイル）                  │
│         └─ LowerDir（読み取り専用レイヤ群）              │
│                                                         │
└───────────────────────────────────────────────────────┘

レイヤの具体的なイメージ

Dockerfile:
  FROM python:3.12-slim      ← Layer 0 (ベース)
  WORKDIR /app               ← Layer 1
  COPY requirements.txt .    ← Layer 2
  RUN pip install -r ...     ← Layer 3
  COPY . .                   ← Layer 4

Dockerfile:
  FROM python:3.12-slim      ← Layer 0 (同じ！共有される)
  WORKDIR /app               ← Layer 1 (同じ！共有される)
  RUN apt-get update         ← NEW Layer (5番目)
  COPY . .                   ← NEW Layer

→ Layer 0,1 は両方のイメージで再利用される！！！

UnionFS の仕組み（CoW = Copy-on-Write）

┌─────────────────────────────────────────────┐
│        OverlayFS: Copy-on-Write 概要         │
│                                              │
│   LowerDir (read-only image layers)          │
│   ┌─────┐ ┌─────┐ ┌─────┐                  │
│   │Lay0 │ │Lay1 │ │Lay2 │                  │
│   └──┬──┘ └──┬──┘ └──┬──┘                  │
│      ╲       ╲       ╱                      │
│       ╲       ╲     ╱    ← 読み取りはLowerDirから  │
│        ╲       ╲   ╱                       │
│         ╲       ╲ ╱                        │
│          ╲_______╱                         │
│             ▲                               │
│             │ (ファイル変更時はコピー)      │
│             │                               │
│   UpperDir (writable layer for container)  │
│   ┌─────┐ ┌─────┐                          │
│   │NewFile│ │Modfied│                        │
│   └─────┘ └─────┘                          │
│                                              │
│  MergedDir (コンテナに見える единое filesystem) │
│  All files from Lower + Upper combined        │
│                                              │
└───────────────────────────────────────────────┘

9. 基礎知識: Namespaces と cgroups

9-1. Namespaces（名前空間）— 隔離の仕組み

┌──────────────────────────────────────────────────────────┐
│              Linux Namespaces — 仮想化された「視点」       │
│                                                            │
│  プロセスはclone(CLONE_NEWNS | CLONE_NEWPID | ...) を    │
│  呼び出すことで、独立したビューを取得する                   │
│                                                            │
│  ┌──────────────────┐      ┌──────────────────┐         │
│  │ ホスト OS での視点 │      │ コンテナAの視点   │         │
│  │                  │      │ (PID Namespace)  │         │
│  │ PID 1: dockerd   │      │ PID 1: myapp     │         │
│  │ PID 2: sshd      │      │ PID 2: worker    │         │
│  │ PID 3: nginx     │      │                  │         │
│  │ PID 4: app       │      │  "PID 1"以外を   │         │
│  │ ...              │      │  見えない！       │         │
│  └──────────────────┘      └──────────────────┘         │
│                                                            │
│  ┌──────────────────┐      ┌──────────────────┐         │
│  │ ネットの世界 (Host)│      │ ネットの世界 (C1) │         │
│  │ docker0: 172.17.0.1│     │ eth0: 172.17.0.2 │         │
│  │ lo: 127.0.0.1     │     │ lo: 127.0.0.1    │         │
│  └──────────────────┘      └──────────────────┘         │
│                                                            │
│  6種類のNamespace                                            │
│  ┌────────────────────────────────────────────────────┐  │
│  │  PID    │ プロセスID空間を隔離                       │  │
│  │  NET    │ ネットワークスタック・IPを独立             │  │
│  │  MNT    │ マウントポイント（ファイルシステム）        │  │
│  │  USR    │ ユーザー/グループ ID を分離               │  │
│  │  IPC    │ Inter-Process Communication を隔離        │  │
│  │  UTS    │ ホスト名・ドメイン名を独立                 │  │
│  └────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────┘

9-2. cgroups（コントロールグループ）— リソース制限の仕組み

┌──────────────────────────────────────────────────────────┐
│              cgroups — CPU/メモリ/I/O 制御               │
│                                                            │
│  /sys/fs/cgroup/                                           │
│  └── docker/                                               │
│       ├── container1/                                      │
│       │   ├── cpu.cfs_quota_us     → CPU制限              │
│       │   ├── memory.limit_in_bytes → メモリ制限           │
│       │   ├── blkio.weight          → I/O優先度           │
│       │   └── ...                                             │
│       └── container2/                                      │
│           ├── cpu.cfs_quota_us      → CPU 50%             │
│           ├── memory.limit_in_bytes → 256MB               │
│           └── ...                                             │
│                                                            │
│  ┌───────────────────────────────────────────────┐       │
│  │  cgroup の役割                                   │       │
│  ├───────────────────────────────────────────────┤       │
│  │ ① リソース制限    → CPU/メモリ/I/Oの上限設定   │       │
│  │ ② 使用量追跡      → どのコンテナがどれだけ使用 │       │
│  │ ③ オーバーコミット防止 → 1つのコンテナがHostを  │       │
│  │                        圧迫しないよう保護        │       │
│  └───────────────────────────────────────────────┘       │
│                                                            │
│  例: docker run --memory=512m --cpus=0.5 myapp            │
│      ↑ これによって cgroup に制限が記録される              │
└──────────────────────────────────────────────────────────┘

Namespaces と cgroups を合わせた全体図

┌─────────────────────────────────────────────────────────────┐
│                 Linux カーネルレベルの隔離                    │
│                                                               │
│  ┌───────────┐    ┌───────────┐    ┌───────────┐          │
│  │ Namespace  │    │ Namespace  │    │ Namespace  │          │
│  │ (PID)     │    │ (NET)      │    │ (MNT)     │          │
│  │ "PID1=app" │    │ "eth0"    │    │ "/app"    │          │
│  └─────┬─────┘    └─────┬─────┘    └─────┬─────┘          │
│        │                │                 │                  │
│   ┌────▼────────────────▼─────────────────▼──────┐         │
│   │              cgroups (リソース制御)            │         │
│   │                                              │         │
│   │  cpu:     CPUS.limit = 0.5                  │         │
│   │  memory:  limit = 512MB                     │         │
│   │  blkio:   weight = 500                      │         │
│   └──────────────────┬─────────────────────────┘          │
│                      │                                      │
│            ┌─────────▼──────────┐                           │
│            │    コンテナ実行     │                           │
│            │ (プロセス動作)     │                           │
│            └────────────────────┘                           │
│                                                               │
│  ※ ホスト上でも同じPID/Net/MNTを見られる！                    │
│     = 他のコンテナからは完全に隔離！                            │
└─────────────────────────────────────────────────────────────┘

10. Docker の基本的な使い方の流れ

全体のライフサイクル図

┌───────────────────────────────────────────────────────────┐
│                    Docker の全体ライフサイクル              │
│                                                             │
│   ┌──────────┐     ┌──────────────┐     ┌──────────────┐  │
│   │ イメージ  │ ──▶ │    コンテナ   │ ──▶ │   コンテナ   │  │
│   │ (Image)   │     │   (Running)   │     │ (Stopped)   │  │
│   └──────────┘     └──────┬───────┘     └──────┬───────┘  │
│      ▲                     │                     │           │
│      │                      │                    ▼           │
│      │                   docker stop              │           │
│      │                                     docker rm       │
│      │                                     (削除)            │
│      │                                                      │
│   ┌──┴─────────────────────────────────────────────────┐  │
│   │                                                  Docker Hub                       │
│   │  pull / push                                      │
│   └─────────────────────────────────────────────────────┘  │
│                                                             │
│  流れ:                                                     │
│  1. Dockerfile でレシピを書く                             │
│  2. docker build でイメージを作成                            │
│  3. docker run でコンテナを起動                              │
│  4. docker stop / rm で停止・削除                         │
└───────────────────────────────────────────────────────────┘

基本的な使い方の例

# Step 1: イメージを取得（Docker Hubから）
$ docker pull nginx

# Step 2: コンテナを起動
$ docker run -d -p 8080:80 --name my-web nginx

# Step 3: 実行中のコンテナを確認
$ docker ps

# Step 4: コンテナのログを見る
$ docker logs my-web

# Step 5: コンテナ内でコマンドを実行
$ docker exec -it my-web /bin/bash

# Step 6: コンテナを停止
$ docker stop my-web

# Step 7: コンテナを削除
$ docker rm my-web

11. Dockerfile の書き方

Dockerfile とは？

Dockerfile は、Docker イメージをビルドするための設計図（レシピ）です。
どのベースイメージを使うか、どのようなパッケージをインストールするか、
どのようなコマンドを実行するかなど、すべての手順を記述します。

Dockerfile の基本構文

# ベースイメージの指定
FROM python:3.12-slim

# コンテナ内の作業ディレクトリを設定
WORKDIR /app

# ホストのファイル（requirements.txt）をコピー
COPY requirements.txt .

# パッケージインストールを実行（レイヤが作成される）
RUN pip install --no-cache-dir -r requirements.txt

# アプリケーション本体をコピー
COPY . .

# コンテナが listen するポートを宣言
EXPOSE 5000

# コンテナ起動時に実行するデフォルトコマンド
CMD ["python", "app.py"]

Dockerfile の主要命令（Instruction）一覧

命令	意味	例
`FROM`	ベースとなるイメージを指定	`FROM python:3.12-slim`
`RUN`	イメージビルド時にコマンドを実行	`RUN apt-get update`
`CMD`	コンテナ起動時のデフォルトコマンド	`CMD ["python", "app.py"]`
`COPY`	ホストのファイルをコンテナにコピー	`COPY . /app`
`ENTRYPOINT`	コンテナ起動時に実行。上書き不可	`ENTRYPOINT ["/run.sh"]`
`WORKDIR`	作業ディレクトリを指定	`WORKDIR /app`
`EXPOSE`	ポートを宣言（実際には開かない）	`EXPOSE 8080`
`ENV`	環境変数を設定	`ENV NODE_ENV=production`
`ADD`	URLダウンロードなど COPY の上位互換	`ADD https://... .`
`ARG`	ビルド時に渡す変数	`ARG VERSION=1.0`
`VOLUME`	ボリュームをマウント	`VOLUME /data`
`USER`	実行ユーザーを指定（セキュリティ向上）	`USER appuser`

Dockerfile を使ったイメージのビルドとコンテナ起動

# イメージをビルド（Dockerfileから）
$ docker build -t my-python-app .

# ビルドしたイメージからコンテナを起動
$ docker run -d -p 5000:5000 --name myapp my-python-app

# ブラウザで確認
# http://localhost:5000

Dockerfile のベストプラクティス

# ❌ ベストプラクティスに反する例
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y python3
COPY app.py /app.py
CMD ["python", "/app.py"]

# ✅ ベストプラクティスに従った例（軽量でセキュア）
FROM python:3.12-slim  # slimバージョンでサイズ削減

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

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt  # キャッシュ削除でサイズ削減

COPY . .               # アプリコードをコピー（RUNと分離してキャッシュ活用）

EXPOSE 5000            # ポート宣言

USER appuser           # rootではなく一般ユーザーで実行（セキュリティ）

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

Dockerfile のベストプラクティスまとめ

✅ やるべきこと	❌ やらないべきこと
`-slim` または `-alpine` を使う	巨大なベースイメージ
`RUN` は `&&` でつなぐ	1行=1 `RUN` 命令（レイヤ増）
キャッシュを意識（変更頻度の低いものを先に）	全部を最後にCOPY
`.dockerignore` を使う	`.git` や `node_modules` を含める
`USER` で一般ユーザーに切り替え	Rootで実行

12. Docker Compose 入門

Docker Compose とは？

Docker Compose は、複数のコンテナで構成されるアプリケーションを定義・管理するためのツールです。
YAML形式の設定ファイル（docker-compose.yml）に構成を記述し、1つのコマンドで全コンテナを操作できます。

なぜ Docker Compose が必要なのか？

┌─────────────────────────────────────────────────────┐
│  単一コンテナ vs 複数コンテナ（Docker Compose）       │
├─────────────────────────────────────────────────────┤
│                                                     │
│   単一コンテナ:                                     │
│   $ docker run -d -p 8080:80 nginx                 │
│   $ docker run -d -e MYSQL_ROOT_PASS=root mysql    │
│   $ docker run -d --link ... myapp                │
│             ↑ コンテナごとにコマンド！               │
│                                                     │
│   Docker Compose:                                   │
│   $ docker compose up -d                            │
│             ↑ 1つのコマンドで全サービス一斉起動！    │
│                                                     │
│   🎉  Web + DB + Cache の複合環境が一瞬で完成       │
└─────────────────────────────────────────────────────┘

docker-compose.yml の基本構造

# docker-compose.yml
version: '3.8'

services:                          # 各サービス（コンテナ）の定義
  web:                             # Webサーバー（Nginx）
    image: nginx:latest            # イメージを指定
    ports:                         # ポートマッピング
      - "8080:80"                # ホスト:8080 → コンテナ:80
    volumes:                       # ボリューム（ファイル共有）
      - ./html:/usr/share/nginx/html
    depends_on:                    # 起動順序の制御
      - app

  app:                             # アプリケーション
    build: .                       # カレントディレクトリのDockerfileからビルド
    ports:                         # ポート公開
      - "5000:5000"
    depends_on:                    # DBが起動してから開始
      - db
    environment:                   # 環境変数
      - FLASK_ENV=development

  db:                              # データベース
    image: mysql:8.0             # MySQL 8.0 イメージ
    environment:                   # 環境変数で初期設定
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: myapp
    volumes:                       # ボリュームでデータを永続化
      - db-data:/var/lib/mysql

volumes:                             # 永続ストレージの定義
  db-data:                           # dbサービスのデータを保存

Docker Compose の基本コマンド

コマンド	用途	例
`docker compose up -d`	全サービスをバックグラウンドで起動	最も基本的な使い方
`docker compose down`	全サービスを停止・削除
`docker compose logs`	全サービスのログを確認
`docker compose ps`	サービスの稼働状況を確認
`docker compose exec web bash`	特定のサービスにシェルでアクセス
`docker compose build`	イメージを再ビルド
`docker compose restart`	全サービスを再起動

Docker Compose の主要設定項目

フィールド	用途	例
`image`	既存イメージを使用	`redis:7-alpine`
`build`	Dockerfileからビルド	`build: ./backend`
`ports`	ポートマッピング	`- "3000:3000"`
`volumes`	データの永続化/共有	`- ./data:/data`
`environment`	環境変数	`- DEBUG=true`
`depends_on`	起動順序制御	`depends_on: [db]`

13. Docker ネットワークとボリューム

13-1. Docker ネットワーク

┌───────────────────────────────────────────────────────────┐
│                Docker ネットワークの構造                   │
│                                                             │
│  ホスト (Docker Host)                                      │
│  ┌─────────────────────────────────────┐                  │
│  │  docker0 (ブリッジネットワーク)      │                  │
│  │  IP: 172.17.0.1/16                 │                  │
│  │                                     │                  │
│  │  ┌───┐    ┌──────┐   ┌──────────┐ │                  │
│  │  │C1 │    │ C2   │   │  C3      │ │                  │
│  │  │eth0│    │eth0  │   │ eth0     │ │                  │
│  │  │172.│    │172.  │   │ 172.     │ │                  │
│  │  │ .0. │    │ .0.  │   │  .0.     │ │                  │
│  │  └───┘    └──────┘   └──────────┘ │                  │
│  └──────────────┬────────────────────┘                  │
│                  │ veth pairs (仮想イーサーネット)        │
│                  ▼                                        │
│             ホストOSの物理 NIC                            │
│                                                             │
│  ネットワークタイプ:                                      │
│  • bridge   → 個々コンテナ間のブリッジ                    │
│  • host     → ホストのネットワークを直接使用               │
│  • overlay  → マルチホム環境（Docker Swarm, K8s)        │
│  • none     → ネットワークなし                            │
└───────────────────────────────────────────────────────┘

13-2. Docker ボリューム

┌──────────────────────────────────────────────────────────────┐
│                    Docker ボリューム（永続ストレージ）          │
│                                                                │
│  ┌───────────────────────┐                                   │
│  │     コンテナA         │    ← コンテナを停止/削除しても...   │
│  │  ┌─────────────────┐  │      データは保たれる！           │
│  │  │ /app/data (tmp)  │  │                                   │
│  │  └─────────────────┘  │    ↔ 一方、通常ファイルは削除される │
│  │                         │                                 │
│  │  ⚠ 通常ファイル = コンテナ削除時消去                       │
│  │  ✅ ボリューム     = 永続化する                            │
│  └───────────┬───────────┘                                   │
│              │                                                │
│              ▼                                                │
│  ┌───────────────────────┐                                   │
│  │   ホスト上のボリューム   │    ← 実際にデータが保存される場所  │
│  │   /var/lib/docker/v/  │                                        │
│  │   my-data/_data/      │                                          │
│  └───────────────────────┘                                        │
│                                                                       │
│  ボリュームのメリット:                                               │
│  • コンテナを再起動してもデータが保持                                │
│  • データベースなどに適した永続ストレージ                              │
│  • ホストとの共有（docker run -v /host:/container）                   │
└─────────────────────────────────────────────────────┘

14. よく使う Docker コマンド一覧

オススメのコマンドリファレンス集

イメージ操作

コマンド	用途
`docker images`	ローカルにあるイメージの一覧を表示
`docker pull nginx`	イメージをDocker Hubから取得
`docker build -t myapp .`	Dockerfileからイメージをビルド
`docker rmi nginx`	イメージを削除
`docker tag myapp:latest user/myapp:v1.0`	イメージにタグ（名前）をつける
`docker push user/myapp:v1.0`	イメージをDocker Hubに公開

コンテナ操作

コマンド	用途
`docker run -d -p 8080:80 nginx`	イメージからコンテナを作成して起動
`docker ps`	実行中のコンテナ一覧を表示
`docker ps -a`	全コンテナ（停止含む）一覧
`docker stop mycontainer`	コンテナを停止
`docker start mycontainer`	停止したコンテナを開始
`docker restart mycontainer`	コンテナを再起動
`docker rm mycontainer`	コンテナを削除
`docker exec -it mycontainer bash`	コンテナ内でコマンドを実行

ログ・情報

コマンド	用途
`docker logs mycontainer`	コンテナのログを表示
`docker logs -f mycontainer`	リアルタイムでログをフォロー
`docker inspect mycontainer`	詳細情報をJSON形式で表示
`docker top mycontainer`	コンテナのプロセス一覧

Docker Compose

コマンド	用途
`docker compose up -d`	全サービス起動（バックグラウンド）
`docker compose down`	全サービスを停止・削除
`docker compose logs`	全サービスのログ
`docker compose ps`	サービスの稼働状況
`docker compose exec web bash`	特定のサービスにアクセス
`docker compose build`	イメージを再ビルド

15. Docker の活用法・活用シーン

Dockerがよく使われる主要5つのシナリオ

┌───────────────────────────────────────────────────────┐
│              Dockerの代表的な活用法                       │
├───────────────────────────────────────────────────────┤
│                                                       │
│  シーン ①: ローカル開発環境の統一                     │
│  ─────────────────────────                          │
│  • チーム全員が同じ開発環境を共有                      │
│  • OS・言語バージョン・ミドルウェアの違いによるバグを80%削減 |
│                                                       │
│  シーン②: CI/CDパイプライン                           │
│  ─────────────────────────                          │
│  • GitHub Actions / Jenkins と組み合わせ              │
│  • コードのプッシュ→自動テスト→ビルド→デプロイ       │
│  • テスト環境もコンテナで再現                         │
│                                                       │
│  シーン③: マイクログサービスアーキテクチャ            │
│  ─────────────────────────                          │
│  • 大きなアプリを小さな独立サービスに分割             │
│  • 各サービスを個別のコンテナとして運用               │
│  • 独立デプロイ・スケーリングが可能                   │
│                                                       │
│  シーン④: データベーステスト環境構築                   │
│  ─────────────────────────                          │
│  • MySQL / PostgreSQL / MongoDB を瞬時に起動         │
│  • テスト終了後すぐに破棄                             │
│  • 本番データを汚す心配なし                           │
│                                                       │
│  シーン⑤: レガシーシステムのモダナイゼーション          │
│  ─────────────────────────                          │
│  • 古い環境をコンテナ内に再現                         │
│  • ホストOSに依存しないため保守が楽                   │
└───────────────────────────────────────────────────────┘

16. つまずきポイントと解決策

よくあるエラーと対処法

エラー ①: Permission Denied（権限エラー）

# 症状: "permission denied" が出る
# 原因: ユーザーが docker グループに入っていない

# 解決策:
$ sudo usermod -aG docker $USER
# → 再ログイン

エラー ②: ポート競合（Port Already in Use）

# 症状: "port is already allocated"
# 原因: 指定したポートが既に使用中

# 解決策:
# 別のポートを割り当てる
$ docker run -p 8081:80 nginx

# または競合しているプロセスを停止

エラー ③: コンテナ即終了

# 症状: コンテナが立ち上がるとすぐにExit
# 原因: フォアグラウンドで実行するプロセスが存在しない

# 解決策:
$ docker logs mycontainer    # エラーログを確認
$ docker exec -it mycontainer bash   # 中身を確認

エラー ④: ディスク容量の不足

# 症状: "no space left on device"

# 解決策: 不要なリソースを一括削除
$ docker system prune -a

# 参考: Docker関連サイズの確認
$ docker system df

17. まとめ

Docker 全体を振り返る

┌─────────────────────────────────────────────────────────────┐
│                   Docker の全体まとめ                          │
│                                                               │
│  ┌───────────────────────────────────────────────────────┐  │
│  │             Docker コンテナエコシステム                  │  │
│  │                                                       │  │
│  │  Docker Hub / Registry                                │  │
│  │     │  ◀ イメージのやり取り                            │  │
│  │  ▼                                                   │  │
│  │  Dockerfile → イメージ（設計図/ビルド済み）              │  │
│  │     │                                                │  │
│  │  docker run                                          │  │
│  │     │                                                │  │
│  │  コンテナ（実際の動作環境: アプリ+ランタイム+ライブラリ） │  │
│  │                                                       │  │
│  └───────────────────────────────────────────────────────┘  │
│                                                               │
│  ✅ Docker のポイント:                                       │
│   • イメージは「設計図」、コンテナは「実行体」                │
│   • ホストOSカーネルを共有 → 軽量・高速                       │
│   • Namespaces と cgroups が隔離とリソース制御を実現         │
│   • Dockerfile でイメージを作成、Compose で複数管理          │
│   • CI/CD・マイクロサービス・テスト環境など多様な活用        │
│                                                               │
│  🚀 次のステップ:                                            │
│   1. Dockerの基本操作をハンズオンで練習                         │
│   2. Dockerfile の自作                                        │
│   3. Docker Compose で複数コンテナ                            │
│   4. Kubernetes / AWS ECS へ                                  │
└───────────────────────────────────────────────────────────────┘

参考URL:
– Docker Fundamentals (Medium)
– Docker internals deep dive (DEV Community)
– Docker Architecture Overview (Spacelift)
– Docker チュートリアル完全ガイド (ITcross)
– Dockerの基本用語解説 (docker.lock-life.com)
– Docker Tutorial 2025 (QuashBugs)
– How Docker Containers Actually Work (Atmosly)
– Docker Image vs Container (CircleCI)
– 初学者向け docker 基礎 (Qiita)
– Dockerの基本用語解説 (Qiita)