Docker完全ガイド：仕組みから基本コマンドまで図解で学ぶ
CHATGPT / AIChatGPTなどの生成AIを活用して運営・記事制作・更新を行っています。制作方針
Dockerの仕組み、仮想マシンとの違い、イメージとコンテナ、Dockerfile、Compose、基本コマンド、トラブル対応まで図解ベースで解説します。
この記事でわかること
Dockerの概念から実用までを一通り押さえるための総合ガイドです。導入済みの人が仕組みを理解する用途にも向いています。
- コンテナと仮想マシンの違い
- Docker Engine、イメージ、コンテナの関係
- 日常的に使う基本コマンドの位置づけ
おすすめ読者: Dockerをなんとなく使っている人、仕組みから整理して理解したい人。
読む前の注意: コンテナの動作はOS、CPUアーキテクチャ、Dockerの実行環境、bind mountや環境変数などにも左右されます。実行前に手元の条件と公式情報を確認してください。
🐳 Docker 完全ガイド — 図解付きで詳しく学ぶ
出典: Medium, DEV Community, Spacelift, ITcross, Qiita, Zenn, CircleCI などの複数の技術記事を総合
作成日: 2026年4月25日
目次
- 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社）によってオープンソースとして公開されて以来、世界中のエンジニアに支持されています。
コンテナとは？
コンテナとは、アプリケーションとその実行に必要なライブラリや依存関係、設定をひとまとめにした隔離された実行環境です。
Linux上のLinuxコンテナはホストのLinuxカーネルを共有します。macOSのDocker Desktopと、WindowsのLinuxコンテナモードはLinux仮想マシン内で実行します。WindowsコンテナモードはWindows用のコンテナです。起動時間やメモリ使用量は、イメージ、設定、ホスト、ワークロードによって変わります。
2. なぜ Docker が注目されるのか
| メリット | 説明 |
|---|---|
| 環境の再現性 | アプリと依存関係をまとめ、環境差による問題を減らしやすくする |
| 軽量・高速 | VMとは実行方式が異なる。実際の起動時間や資源使用量は条件によって変わる |
| ポータビリティ | OS・CPUアーキテクチャ・カーネルなどが互換で、必要な設定もそろえば、同じイメージを利用できる |
| チーム開発の効率化 | 共通のイメージと設定を使い、チームで環境をそろえやすくする |
| 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 導入後 │
├─────────────────────────────────────────────────────┤
│ │
│ 同じイメージ + 互換OS/CPU/設定 = 再現しやすい環境 │
│ │
│ 開発者A ◀── Docker Image ───▶ 開発者B │
│ ───▶ 本番サーバー │
│ kernel・CPU・mount・環境変数の差は別途確認 │
│ │
└─────────────────────────────────────────────────────┘同じイメージを使っても、ホストのOSカーネル、CPUアーキテクチャ、bind mount、環境変数、実行時設定などが違えば挙動も変わることがあります。複数CPU向けのイメージや互換性の確認についてはDocker公式のmulti-platform build解説も参照してください。
3. コンテナ VS 仮想マシン（VM）
アーキテクチャ図で比較
┌──────────────────────────────────────────────────────────┐
│ Linux host + Docker Engine │ Docker Desktop (Linux containers)│
│ │ │
│ ┌───────────────────────────┐ │ ┌─────────────────────────────┐ │
│ │ Linux host kernel │ │ │ macOS/Windows host │ │
│ │ └ Docker Engine │ │ │ └ Linux VM │ │
│ │ ├ Container A │ │ │ └ Linux kernel │ │
│ │ └ Container B │ │ │ └ Docker Engine │ │
│ └───────────────────────────┘ │ ├ Container A │ │
│ │ └ Container B │ │
│ Linux containers share the │ Linux containers use the VM's │
│ Linux host kernel │ kernel, not the Mac/Windows one │
└────────────────────────────────┴─────────────────────────────────┘
┌──────────────────────────────────────────────────────────────────┐
│ 仮想マシンは仮想化されたハードウェア上でゲストOSとカーネルを実行 │
│ コンテナは対応するホストカーネル機能を使ってプロセスを隔離 │
└──────────────────────────────────────────────────────────────────┘比較表
| 項目 | Docker コンテナ | 仮想マシン（VM） |
|---|---|---|
| カーネル | LinuxコンテナはLinuxカーネルを共有。Docker DesktopではLinux VMのカーネルを使う（Windows containersは別） | 各VMが独立したカーネルを持つ |
| 起動時間 | 起動時間はアプリ、イメージ、ホスト、実行方式による | ゲストOSと設定による |
| リソース消費 | イメージ、プロセス、実行環境による | ゲストOS、割当資源、ディスクイメージによる |
| 隔離の境界 | カーネル機能を使ったプロセス・リソースの隔離。VMと同じ境界ではない | ゲストOSを含む仮想マシン単位 |
| ファイルサイズ | 含まれるソフトウェアやデータによる | ゲストOSや保存データによる |
| 性能オーバーヘッド | 実行環境やI/Oなどに左右される | 仮想化方式やワークロードに左右される |
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が担当）
# runc自体が使われていることを確認（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-web11. 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:5000Dockerfile のベストプラクティス
# ❌ ベストプラクティスに反する例
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_PASSWORD="$MYSQL_ROOT_PASSWORD" mysql:8.0 │
│ $ 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: ${MYSQL_ROOT_PASSWORD:?Set MYSQL_ROOT_PASSWORD in your local environment}
MYSQL_DATABASE: myapp
volumes: # ボリュームでデータを永続化
- db-data:/var/lib/mysql
volumes: # 永続ストレージの定義
db-data: # dbサービスのデータを保存Composeはシェルの環境変数またはプロジェクトの.envから値を読み込みます。パスワードを含む.envはリポジトリへ登録しないでください。
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・言語・ミドルウェアなどの環境差を小さくしやすい │
│ │
│ シーン②: CI/CDパイプライン │
│ ───────────────────────── │
│ • GitHub Actions / Jenkins と組み合わせ │
│ • コードのプッシュ→自動テスト→ビルド→デプロイ │
│ • テスト環境もコンテナで再現 │
│ │
│ シーン③: マイクログサービスアーキテクチャ │
│ ───────────────────────── │
│ • 大きなアプリを小さな独立サービスに分割 │
│ • 各サービスを個別のコンテナとして運用 │
│ • 独立デプロイ・スケーリングが可能 │
│ │
│ シーン④: データベーステスト環境構築 │
│ ───────────────────────── │
│ • MySQL / PostgreSQL / MongoDB の検証環境を用意 │
│ • テスト後に不要なコンテナを削除できる │
│ • 接続先・volumeを分け、本番データとの誤接続を防ぐ │
│ │
│ シーン⑤: レガシーシステムのモダナイゼーション │
│ ───────────────────────── │
│ • 互換性を確認した古い環境をコンテナ内に再現 │
│ • kernel・CPU・volumeなどホスト側の条件も確認 │
└───────────────────────────────────────────────────────┘16. つまずきポイントと解決策
よくあるエラーと対処法
エラー ①: Permission Denied（権限エラー）
# 症状: "permission denied" が出る
# 原因: ユーザーが docker グループに入っていない
# 解決策:
$ sudo usermod -aG docker $USER
# → 再ログイン権限の注意: Docker Engineのrootful構成では、dockerグループのメンバーはroot相当の権限を得ます。信頼できるユーザーだけを追加してください。root権限を避けたい場合はDocker rootless modeを検討します。
エラー ②: ポート競合（Port Already in Use）
# 症状: "port is already allocated"
# 原因: 指定したポートが既に使用中
# 解決策:
# 別のポートを割り当てる
$ docker run -p 8081:80 nginx
# または競合しているプロセスを停止エラー ③: コンテナ即終了
# 症状: コンテナが起動後すぐに終了
# 状態・終了コード・エラーとログを確認
$ docker inspect --format='{{.State.Status}} {{.State.ExitCode}} {{.State.Error}}' mycontainer
$ docker logs mycontainerエラー ④: ディスク容量の不足
# 症状: "no space left on device"
# まず使用量を確認
$ docker system df使用量を確認してから、不要な対象を選んで個別に削除します。docker system pruneは停止中コンテナ、未使用ネットワーク、dangling image、build cacheを削除対象にし、-aを付けると未使用イメージも対象になります。実行前に公式の削除対象を確認し、再取得・再buildできるものだけを選んでください。
17. まとめ
Docker 全体を振り返る
┌─────────────────────────────────────────────────────────────┐
│ Docker の全体まとめ │
│ │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ Docker コンテナエコシステム │ │
│ │ │ │
│ │ Docker Hub / Registry │ │
│ │ │ ◀ イメージのやり取り │ │
│ │ ▼ │ │
│ │ Dockerfile → イメージ（設計図/ビルド済み） │ │
│ │ │ │ │
│ │ docker run │ │
│ │ │ │ │
│ │ コンテナ（実際の動作環境: アプリ+ランタイム+ライブラリ） │ │
│ │ │ │
│ └───────────────────────────────────────────────────────┘ │
│ │
│ ✅ Docker のポイント: │
│ • イメージは「設計図」、コンテナは「実行体」 │
│ • LinuxコンテナはLinux kernelを共有 │
│ • Docker DesktopはLinux VM内で実行 │
│ • 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)
Docker公式資料の確認日: 2026年10月2日。Multi-platform builds、Networking on Docker Desktop、Install Docker Desktop on Windows、Linux post-installation、Docker Engine security、docker system prune。
よくある質問
Dockerは仮想マシンの代わりですか？
近い用途で使われますが、仕組みは異なります。LinuxコンテナはLinuxカーネルの機能でプロセスなどを隔離します。Docker DesktopでLinuxコンテナを使う場合はLinux VMが間に入ります。
まず覚えるべきコマンドは？
docker run、docker ps、docker images、docker logs、docker exec、docker stopから始めると実務で困りにくいです。
学習時につまずきやすい点は？
イメージとコンテナの違い、ボリューム、ポート公開、権限周りでつまずきやすいです。この記事内の該当部分を行き来しながら確認してください。
