Docker × AI開発 最強環境構築 GPU対応！再現性重視の爆速セットアップ

はじめに：なぜ今、AI開発にDockerが必要なのか？

AI技術の進化は目覚ましく、ビジネスにおけるその活用範囲は拡大の一途を辿っています。しかし、AIモデルの開発を実際に進める上で、多くの企業や開発者が直面するのが「環境構築」という大きな壁です。開発チーム内での環境差異、ライブラリのバージョン衝突、そして複雑なGPU設定など、これらは開発効率を著しく低下させる要因となりかねません。

このような課題を解決し、AI開発をより迅速かつ円滑に進めるために、コンテナ技術であるDockerが強力なツールとして注目を集めています。Dockerを導入することで、開発環境の再現性を高め、チーム全体の生産性を向上させることが可能です。

AI開発の「環境構築」における課題とDockerのメリット

AI開発環境の構築には、特有の難しさがあります。主な課題として、以下の点が挙げられます。

これらの課題に対し、Dockerは以下のような強力なメリットを提供します。

Dockerは、これらのメリットを通じて、AI開発における環境構築の課題を根本から解決し、開発のスピードと品質を飛躍的に向上させるための基盤を築きます。

この記事で実現できること：再現性の高いAI開発環境の構築

本記事では、Dockerの基本からGPU対応のディープラーニング環境構築、そして実務で役立つ応用テクニックまで、一貫したハンズオン形式で解説していきます。具体的には、以下の内容を目標とします。

• Dockerの主要な概念を理解し、AI開発に必要な基盤環境をDockerfileで定義できるようになります。
• Pythonと主要なAIライブラリ（TensorFlow/PyTorch）を内包したJupyter Lab環境をDockerコンテナで構築し、実際に動作させます。
• GPUを活用したディープラーニング環境をDocker上に構築する方法を学び、モデルの学習を高速化する道を拓きます。
• Docker Composeを用いた複数コンテナ連携や、チームでの環境共有といった実務的な活用方法を習得し、開発プロセス全体の効率化を図ります。

この記事を通じて、AI開発の環境構築における悩みを解消し、より本質的なモデル開発に集中できる状態を目指しましょう。

事前準備と必要なツール

AI開発環境をDockerで構築する前に、いくつかのツールと概念の理解が必要です。ここでは、Dockerの基礎知識から、開発に必要なソフトウェアのインストールまでを解説します。

Dockerの基本概念を理解する（コンテナ、イメージ、Dockerfile）

Dockerを効果的に利用するには、その核となる「コンテナ」「イメージ」「Dockerfile」の3つの概念を理解することが不可欠です。

これらの概念を理解することで、Dockerを使った環境構築がなぜ再現性が高く、効率的であるのかを深く把握できます。

Docker Desktopのインストールと初期設定

Dockerを利用するには、まずご自身の開発環境にDockerエンジンをインストールする必要があります。WindowsやmacOSをお使いの場合は、「Docker Desktop」をインストールするのが最も手軽で推奨される方法です。

1. Docker Desktopのダウンロード:

Docker公式サイト（`https://www.docker.com/products/docker-desktop/`）にアクセスし、ご自身のOS（WindowsまたはmacOS）に合ったインストーラーをダウンロードします。

1. インストール:

ダウンロードしたインストーラーを実行し、画面の指示に従ってインストールを進めます。Windowsの場合、WSL 2（Windows Subsystem for Linux 2）の有効化が求められる場合がありますので、指示に従ってください。

1. Docker Desktopの起動と初期設定:

インストール完了後、Docker Desktopを起動します。通常、メニューバー（macOS）またはタスクバー（Windows）にDockerアイコンが表示されます。初回起動時には、利用規約への同意や、簡単なチュートリアルが表示されることがあります。

1. 動作確認:

ターミナル（コマンドプロンプトやPowerShell、macOSのターミナル）を開き、以下のコマンドを実行してDockerが正しくインストールされ、動作しているかを確認します。

    docker --version
    docker run hello-world

`docker –version` でバージョン情報が表示され、`docker run hello-world` で "Hello from Docker!" のメッセージが表示されれば、Dockerのインストールは成功です。

その他の準備：VS Codeなどの開発ツールの導入

Docker環境での開発をよりスムーズに進めるために、統合開発環境（IDE）やコードエディタを用意しておくと便利です。ここでは、多くの開発者に利用されているVisual Studio Code（VS Code）の導入を推奨します。

1. VS Codeのインストール:

VS Code公式サイト（`https://code.visualstudio.com/`）から、ご自身のOSに合ったインストーラーをダウンロードし、インストールします。

1. 推奨拡張機能のインストール:

VS Codeをインストールしたら、以下の拡張機能を導入しておくと、Docker関連の作業やPython開発が非常に快適になります。

これらの準備が整えば、いよいよAI開発環境の基盤をDockerfileで構築するステップへ進むことができます。

AI開発環境の基盤をDockerfileで構築する

ここからが本記事の核心です。AI開発に特化した環境をDockerfileで定義し、それを元にDockerイメージを構築していきます。Dockerfileは、環境構築の「レシピ」であり、一度記述すれば、誰でも同じ環境を再現できるようになります。

Dockerfileの基本構造と記述方法

Dockerfileは、一連の命令を上から順に実行することでDockerイメージを構築するテキストファイルです。基本的な構造は以下のようになります。

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

# 開発者の情報（任意）
LABEL maintainer="your_name@example.com"

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

# 必要なパッケージのインストールとクリーンアップ
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        build-essential \
        # その他の必要なシステムパッケージ \
    && rm -rf /var/lib/apt/lists/*

# Pythonの依存関係ファイルのコピーとインストール
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# アプリケーションコードのコピー（今回はJupyter Lab関連のみ）
# COPY . .

# ポートの公開（Jupyter Labが使用するポート）
EXPOSE 8888

# コンテナ起動時に実行するコマンド
CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--allow-root", "--no-browser", "--ServerApp.token=''", "--ServerApp.password=''"]

主要な命令について解説します。

これらの命令を組み合わせて、必要なAI開発環境を構築していきます。

Python環境と主要AIライブラリ（TensorFlow/PyTorch, scikit-learn, NumPyなど）の選定・インストール

AI開発環境の核となるのは、Pythonとそのエコシステムです。Dockerfile内でPython環境をセットアップし、必要なライブラリをインストールします。

まず、プロジェクトのルートディレクトリに `requirements.txt` ファイルを作成し、インストールしたいPythonライブラリを記述します。

`requirements.txt` の例:

numpy==1.26.4
pandas==2.2.2
scikit-learn==1.4.2
matplotlib==3.8.4
jupyterlab==4.1.6
tensorflow==2.16.1 # または torch==2.2.2 torchvision==0.17.2 torchaudio==2.2.2 --index-url https://download.pytorch.org/whl/cu121 (GPU対応PyTorchの場合)

Dockerfileの記述（AIライブラリとJupyter Labの導入）:

# ベースイメージの指定 (Python 3.9とDebian Buster Slim版)
# より新しいPythonバージョンや別のOSベースを選ぶことも可能です
FROM python:3.9-slim-buster

LABEL maintainer="ai-dev-team@example.com"

# aptパッケージリストの更新と必要なシステムツール（ビルドツールなど）のインストール
# --no-install-recommends は不要な依存パッケージのインストールを抑制し、イメージサイズを小さくします
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        build-essential \
        git \
    && rm -rf /var/lib/apt/lists/*

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

# ホストからrequirements.txtをコンテナの/appディレクトリにコピー
COPY requirements.txt .

# requirements.txtに記載されたPythonライブラリをインストール
# --no-cache-dir はpipのキャッシュを使わないことで、イメージサイズをさらに最適化します
RUN pip install --no-cache-dir -r requirements.txt

# Jupyter Labが利用するポートを宣言
EXPOSE 8888

# コンテナ起動時にJupyter Labを起動するコマンド
# --ip=0.0.0.0 は全てのネットワークインターフェースからのアクセスを許可
# --allow-root はrootユーザーでの実行を許可 (開発環境向け)
# --no-browser は起動時にブラウザを自動で開かない
# --ServerApp.token='' --ServerApp.password='' で認証を無効化 (開発環境向け、セキュリティに注意)
CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--allow-root", "--no-browser", "--ServerApp.token=''", "--ServerApp.password=''"]

このDockerfileでは、Pythonベースイメージを土台に、`apt-get` で基本的なシステムツールをインストールし、`pip` を使って `requirements.txt` に記述されたAIライブラリ群を導入しています。特に `build-essential` は、一部のPythonライブラリがC/C++コンポーネントを含んでおり、ビルド時に必要となるためインストールしておくと安心です。

開発効率を上げるJupyter Labの導入と設定

AI開発において、インタラクティブなデータ分析やモデルの試行錯誤にはJupyter Labが非常に有効です。上記のDockerfileでは、既にJupyter Labのインストールと起動設定を含めています。

`CMD` 命令でJupyter Labを起動する際に `–ip=0.0.0.0` と `–port=8888` を指定することで、コンテナ外部（ホストOSのブラウザ）からアクセスできるようにします。また、`–ServerApp.token=”` と `–ServerApp.password=”` を設定することで、開発環境での利便性を高めるために、認証なしでJupyter Labにアクセスできるようにしています。実運用やセキュリティが求められる環境では、これらの認証設定を適切に行う必要があります。

このDockerfileをプロジェクトのルートディレクトリに `Dockerfile` という名前で保存すれば、環境構築の基盤が完成です。

Dockerイメージのビルドとコンテナの実行

Dockerfileが完成したら、いよいよDockerイメージをビルドし、そのイメージからコンテナを起動してJupyter Labにアクセスしてみましょう。このセクションでは、具体的なコマンドと手順を解説します。

コマンド一つでイメージをビルドする手順

Dockerfileを元にDockerイメージをビルドするには、`docker build` コマンドを使用します。

1. Dockerfileとrequirements.txtの準備:

前述の `Dockerfile` と `requirements.txt` を同じディレクトリ（例えば `ai_dev_env` という名前のフォルダ）に配置します。

    ai_dev_env/
    ├── Dockerfile
    └── requirements.txt

1. イメージのビルド:

ターミナルを開き、`Dockerfile` が存在するディレクトリに移動します。そして、以下のコマンドを実行してイメージをビルドします。

    cd ai_dev_env
    docker build -t ai-jupyter-env:latest .

• `docker build`: イメージをビルドするコマンドです。
• `-t ai-jupyter-env:latest`: ビルドするイメージに `ai-jupyter-env` という名前と `latest` というタグ（バージョン）を付けます。タグは任意の文字列で指定でき、例えば `ai-jupyter-env:v1.0` のようにバージョン番号を付けることも可能です。
• `.`: Dockerfileが存在するパスを示します。`.` は現在のディレクトリを意味します。

このコマンドを実行すると、Dockerは `Dockerfile` の各命令を順番に実行し、ベースイメージのダウンロード、パッケージのインストール、ライブラリのセットアップなどを行います。初回ビルド時は時間がかかることがありますが、一度ビルドしてしまえば、次回からはキャッシュが利用されるため、変更がない限り高速に完了します。

ビルドが成功すると、最後に「Successfully built [イメージID]」のようなメッセージが表示されます。

1. ビルドされたイメージの確認:

以下のコマンドで、ビルドされたイメージがリストに表示されることを確認できます。

    docker images

`ai-jupyter-env` という名前のイメージが `latest` タグとともに表示されていれば成功です。

コンテナを起動し、Jupyter Labへアクセスする方法

イメージのビルドが完了したら、そのイメージを使ってコンテナを起動します。

1. コンテナの起動:

以下の `docker run` コマンドを実行して、コンテナを起動します。

    docker run -it -p 8888:8888 -v "$(pwd):/app/work" --name ai_dev_container ai-jupyter-env:latest

• `docker run`: コンテナを起動するコマンドです。
• `-it`:
  • `-i`: インタラクティブモードでコンテナを実行し、標準入力を開いたままにします。
  • `-t`: 疑似ターミナルを割り当てます。これにより、コンテナ内でコマンドを実行したり、Jupyter Labのログを確認したりできるようになります。
• `-p 8888:8888`: ポートフォワーディングの設定です。`ホストOSのポート:コンテナのポート` の形式で指定します。これにより、ホストOSのブラウザから `localhost:8888` でコンテナ内のJupyter Labにアクセスできるようになります。
• `-v "$(pwd):/app/work"`: ボリュームマウントの設定です。`ホストOSのパス:コンテナ内のパス` の形式で指定します。
  • `"$(pwd)"` (Windowsの場合は `%cd%`) は、現在のホストOSのディレクトリを指します。
  • `/app/work` は、コンテナ内のJupyter Labが作業ディレクトリとするパスです。
  • この設定により、ホストOSのファイルとコンテナ内のファイルを共有でき、例えばホスト側でPythonスクリプトを編集し、コンテナ内のJupyter Labでそのスクリプトを実行するといった作業が可能になります。
• `–name ai_dev_container`: 起動するコンテナに `ai_dev_container` という名前を付けます。これにより、コンテナIDではなく分かりやすい名前でコンテナを管理できます。
• `ai-jupyter-env:latest`: 起動するコンテナの元となるイメージを指定します。

コマンド実行後、コンテナが起動し、Jupyter Labのログが出力され始めます。最後に `http://0.0.0.0:8888/lab?token=…` のようなURLが表示されますが、今回は認証を無効にしているため、トークンは不要です。

1. Jupyter Labへのアクセス:

Webブラウザを開き、以下のURLにアクセスします。

    http://localhost:8888/lab

Jupyter Labのインターフェースが表示されれば成功です。ブラウザ上で新しいノートブックを作成したり、ターミナルを開いたりして、コンテナ内の環境を操作できます。

コンテナの停止:

コンテナを停止するには、ターミナルで `Ctrl+C` を押すか、別のターミナルを開いて以下のコマンドを実行します。

    docker stop ai_dev_container

停止したコンテナを削除するには、以下のコマンドを実行します。

    docker rm ai_dev_container

ポートフォワーディングとファイル共有（Volume Mount）の設定

`docker run` コマンドで使用した `-p` オプションと `-v` オプションは、Dockerを使った開発で非常に重要な役割を果たします。

これらの設定を適切に行うことで、ホストOSの豊富な開発ツールを活用しつつ、Dockerの持つ再現性と分離性のメリットを享受できる開発環境が構築できます。

ハンズオン！コンテナ上でAIモデルを動かしてみよう

構築したDockerコンテナのJupyter Lab環境で、実際にPythonスクリプトを実行し、簡単なAIモデルを動かしてみましょう。これにより、環境が正しくセットアップされていることを確認できます。

Jupyter Labでの環境動作確認（Python, ライブラリのインポート）

Jupyter Labにアクセスしたら、まずは基本的な環境動作を確認します。

1. 新しいノートブックの作成:

Jupyter Labの左側のファイルブラウザペインで、「+」アイコンをクリックし、「Python 3 (ipykernel)」を選択して新しいノートブックを作成します。

1. Pythonバージョンの確認:

ノートブックのセルに以下のコードを入力し、実行します（`Shift + Enter`）。

    import sys
    print(sys.version)

`Dockerfile` で指定したPythonのバージョン（例：3.9.x）が表示されれば、正しくPythonが動作しています。

1. 主要ライブラリのインポート確認:

次に、`requirements.txt` でインストールした主要なAIライブラリが正しくインポートできるかを確認します。

    import numpy as np
    import pandas as pd
    import sklearn
    import tensorflow as tf # または import torch

    print(f"NumPy version: {np.__version__}")
    print(f"Pandas version: {pd.__version__}")
    print(f"Scikit-learn version: {sklearn.__version__}")
    print(f"TensorFlow version: {tf.__version__}") # または print(f"PyTorch version: {torch.__version__}")

    # GPUが利用可能かどうかの確認 (TensorFlowの場合)
    print("GPU is available for TensorFlow:", tf.config.list_physical_devices('GPU'))
    # GPUが利用可能かどうかの確認 (PyTorchの場合)
    # print("GPU is available for PyTorch:", torch.cuda.is_available())

エラーなく各ライブラリのバージョンが表示され、特にGPU対応のイメージをビルドしている場合はGPUの利用可能性が `True` またはデバイスリストとして表示されれば、環境構築は成功です。

MNISTデータセットを用いた簡単な画像分類モデルの実装

環境が動作していることを確認できたので、実際にMNISTデータセット（手書き数字画像データセット）を使って、簡単な画像分類モデルを構築・学習させてみましょう。これは、AI開発環境がエンドツーエンドで機能していることを示す良いテストになります。

新しいJupyterノートブックセルに以下のコードを入力し、順番に実行してください。

import tensorflow as tf
from tensorflow.keras import layers, models
import matplotlib.pyplot as plt
import numpy as np

# 1. MNISTデータセットの読み込み
print("Loading MNIST dataset...")
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()
print("MNIST dataset loaded.")

# 2. データの前処理
# 画像データを0-1の範囲に正規化し、チャンネル次元を追加
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255

# ラベルをOne-Hotエンコーディング
train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)

print("Data preprocessed.")

# 3. モデルの構築 (シンプルなCNN)
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# モデルのコンパイル
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

model.summary()
print("Model compiled.")

# 4. モデルの学習
print("Starting model training...")
history = model.fit(train_images, train_labels, epochs=5, batch_size=64,
                    validation_data=(test_images, test_labels))
print("Model training finished.")

# 5. モデルの評価
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f"\nTest accuracy: {test_acc:.4f}")

# 6. 学習履歴の可視化
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label='val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0, 1])
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='loss')
plt.plot(history.history['val_loss'], label='val_loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

# 7. 予測の実行と結果の表示
predictions = model.predict(test_images)

# テストデータからランダムに画像を選び、予測結果と真のラベルを表示
num_samples = 5
random_indices = np.random.choice(range(len(test_images)), num_samples)

plt.figure(figsize=(10, 5))
for i, idx in enumerate(random_indices):
    plt.subplot(1, num_samples, i + 1)
    plt.imshow(test_images[idx].reshape(28, 28), cmap='gray')
    plt.title(f"Pred: {np.argmax(predictions[idx])}\nTrue: {np.argmax(test_labels[idx])}")
    plt.axis('off')
plt.suptitle('Sample Predictions', y=0.98)
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()

このコードを実行すると、コンテナ内のTensorFlow環境でMNISTデータセットのダウンロード、前処理、CNNモデルの構築、学習、評価、そして結果の可視化までが実行されます。

特に、モデル学習の部分でエラーが出ずに進み、最後に精度が表示され、グラフが描画されれば、AI開発環境が完全に機能している証拠です。

構築した環境の動作検証とデバッグ

もし、上記の手順でエラーが発生した場合、以下の点を確認してみてください。

これらの手順でトラブルシューティングを行うことで、ほとんどの問題は解決できるはずです。

実務で差がつくDocker活用テクニック

ここまでのハンズオンで基本的なAI開発環境は構築できましたが、実際のBtoBの現場では、より高度な要件が求められます。ここでは、GPUの活用、複数コンテナの連携、そして環境のバージョン管理といった、実務で役立つDockerの応用テクニックを紹介します。

GPUサポートの導入：NVIDIA Dockerでディープラーニングを高速化

ディープラーニングのモデル学習には、CPUよりもGPUを利用する方が圧倒的に高速です。Dockerコンテナ内でGPUを利用するには、NVIDIAが提供する「NVIDIA Container Toolkit」（旧NVIDIA Docker）をホストOSに導入する必要があります。

1. 前提条件:
   • NVIDIA製GPUが搭載されたPC（ホストOS）。
   • ホストOSにNVIDIAの最新GPUドライバーがインストール済みであること。
   • Docker Desktopがインストール済みであること。

1. NVIDIA Container Toolkitのインストール:

NVIDIA Container Toolkitのインストール方法はOSによって異なります。公式ドキュメント（`https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html`）を参照し、ご自身の環境に合わせてインストールしてください。

多くのLinuxディストリビューションでは、以下の手順に沿って行います。

    # リポジトリの追加
    distribution=$(. /etc/os-release;echo $ID$VERSION_ID) \
        && curl -s -L https://nvidia.github.io/libnvidia-container/gpgkey | sudo apt-key add - \
        && curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

    # パッケージリストの更新とNVIDIA Container Toolkitのインストール
    sudo apt-get update
    sudo apt-get install -y nvidia-container-toolkit

    # Dockerデーモンの再起動
    sudo systemctl restart docker

Windows Subsystem for Linux (WSL 2) を利用しているWindowsユーザーの場合、通常、Docker Desktopが自動的にGPUパススルーを処理してくれるため、追加のNVIDIA Container Toolkitのインストールは不要なことが多いです。しかし、問題が発生する場合は公式ドキュメントを確認してください。

1. GPU対応Dockerfileの準備:

PythonのGPU対応ライブラリ（TensorFlow-GPU, PyTorch CUDA版など）をインストールするように `requirements.txt` を更新し、`Dockerfile` のベースイメージを、NVIDIAが提供する公式のCUDAベースイメージに変更します。

`requirements.txt` の例（TensorFlowの場合）:

    numpy==1.26.4
    ...
    tensorflow[and-cuda]==2.16.1 # GPU対応TensorFlow

`requirements.txt` の例（PyTorchの場合）:

    numpy==1.26.4
    ...
    torch==2.2.2+cu121 torchvision==0.17.2+cu121 torchaudio==2.2.2+cu121 --index-url https://download.pytorch.org/whl/cu121

(注: `+cu121` はCUDA 12.1対応を意味します。ご自身の環境のCUDAバージョンに合わせて調整してください。)

GPU対応Dockerfileの例:

    # NVIDIA CUDAベースイメージを使用
    # cuda:12.1.1-devel-ubuntu22.04 は CUDA 12.1.1、開発ツールを含むUbuntu 22.04ベース
    # cuda:12.1.1-runtime-ubuntu22.04 は CUDA 12.1.1、ランタイムのみを含む軽量版
    FROM nvidia/cuda:12.1.1-cudnn8-devel-ubuntu22.04
    # または FROM nvidia/cuda:12.1.1-devel-ubuntu22.04 など

    # Pythonのインストール
    RUN apt-get update && \
        apt-get install -y --no-install-recommends python3.9 python3.9-venv python3-pip git build-essential && \
        update-alternatives --install /usr/bin/python python /usr/bin/python3.9 1 && \
        update-alternatives --install /usr/bin/pip pip /usr/bin/pip3 1 && \
        rm -rf /var/lib/apt/lists/*

    WORKDIR /app

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

    EXPOSE 8888
    CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--allow-root", "--no-browser", "--ServerApp.token=''", "--ServerApp.token=''"]

`nvidia/cuda` で始まるイメージは、Pythonがプリインストールされていない場合があるため、明示的にPythonをインストールする必要があります。

1. GPU対応イメージのビルドとコンテナの起動:

ビルドコマンドはこれまでと同じですが、コンテナ起動時にGPUリソースを割り当てるオプションを追加します。

    # イメージのビルド
    docker build -t ai-jupyter-gpu-env:latest .

    # GPUを有効にしてコンテナを起動
    # --gpus all オプションを追加
    docker run -it --rm -p 8888:8888 -v "$(pwd):/app/work" --name ai_dev_gpu_container --gpus all ai-jupyter-gpu-env:latest

`-gpus all` オプションにより、ホストOSの全てのGPUがコンテナから利用可能になります。特定のGPUのみを指定することも可能です（例: `–gpus device=0,1`）。

コンテナ内でGPUが認識されているかは、Jupyter Labで`tf.config.list_physical_devices(‘GPU’)`や`torch.cuda.is_available()`を実行して確認してください。

Docker Composeによる複数コンテナ連携（例：MLflowとの連携）

実際のAIプロジェクトでは、Jupyter Labだけでなく、データストア（データベース）、モデル管理ツール（MLflow）、APIサーバーなど、複数のサービスを連携させて動かすことがよくあります。このような場合、「Docker Compose」が非常に強力なツールとなります。

Docker Composeは、複数のDockerコンテナで構成されるアプリケーションを、YAMLファイル一つで定義し、一括で管理できるツールです。

例えば、MLflow（機械学習ライフサイクル管理ツール）とJupyter Labを連携させるケースを考えてみましょう。MLflowはトラッキングサーバーと、そのメタデータを保存するためのバックエンドストア（例：PostgreSQLやSQLite）が必要です。

`docker-compose.yml` の例:

version: '3.8'

services:
  # MLflow トラッキングサーバー
  mlflow-server:
    image: ghcr.io/mlflow/mlflow:v2.12.2 # MLflow公式イメージ
    ports:
      - "5000:5000" # MLflow UIのポート
    environment:
      # バックエンドストアとしてPostgreSQLを使用
      - MLFLOW_TRACKING_URI=postgresql://user:password@mlflow-db:5432/mlflow_db
      - MLFLOW_TRACKING_USERNAME=user
      - MLFLOW_TRACKING_PASSWORD=password
    depends_on:
      - mlflow-db # DBコンテナが起動してから起動
    command: mlflow server \
      --host 0.0.0.0 \
      --port 5000 \
      --backend-store-uri $MLFLOW_TRACKING_URI \
      --default-artifact-root /mlflow-artifacts # アーティファクトの保存先

  # PostgreSQLデータベース (MLflowのバックエンドストア用)
  mlflow-db:
    image: postgres:15
    environment:
      - POSTGRES_DB=mlflow_db
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - mlflow_db_data:/var/lib/postgresql/data # データ永続化
    ports:
      - "5432:5432" # DBポート (開発用、本番では直接公開しない)

  # AI開発環境 (Jupyter Lab)
  jupyter-lab:
    build:
      context: . # Dockerfileが現在のディレクトリにあることを示す
      dockerfile: Dockerfile # 使用するDockerfileの指定
    ports:
      - "8888:8888" # Jupyter Labのポート
    volumes:
      - ./notebooks:/app/work # ホストの./notebooksをコンテナの/app/workにマウント
      - ./mlruns:/mlflow-artifacts # MLflowアーティファクトをホストと共有
    environment:
      # Jupyter LabからMLflowサーバーへアクセスするための環境変数
      - MLFLOW_TRACKING_URI=http://mlflow-server:5000
      - MLFLOW_TRACKING_USERNAME=user
      - MLFLOW_TRACKING_PASSWORD=password
    depends_on:
      - mlflow-server # MLflowサーバーが起動してから起動
    # GPUを使用する場合はここに --gpus all を追記
    # runtime: nvidia # Docker Desktop for Windows/macOSでは不要な場合が多い
    # devices:
    #   - /dev/nvidia0:/dev/nvidia0 # Linux環境で特定のGPUをマウントする場合
    #   - /dev/nvidiactl:/dev/nvidiactl
    #   - /dev/nvidia-uvm:/dev/nvidia-uvm
    #   - /dev/nvidia-uvm-tools:/dev/nvidia-uvm-tools

volumes:
  mlflow_db_data: # データの永続化のための名前付きボリューム

この `docker-compose.yml` ファイルをプロジェクトのルートに配置し、Jupyter Lab用の `Dockerfile` と `requirements.txt` を同じ階層に置きます。

実行方法:

docker compose up -d

このコマンド一つで、PostgreSQL、MLflowトラッキングサーバー、Jupyter Labの3つのコンテナが連携して起動します。

• `mlflow-server` は `mlflow-db` に接続し、MLflowのUIは `http://localhost:5000` でアクセス可能になります。
• `jupyter-lab` は `mlflow-server` に接続し、ノートブック内からMLflowのAPIを利用して実験の追跡やモデルのロギングを行えます。
• `-d` オプションはバックグラウンドでコンテナを実行します。

複数のサービスからなる複雑なAI/MLシステムを開発する際に、Docker Composeは環境構築と管理を劇的に簡素化し、チーム開発の効率を大きく向上させます。

環境のバージョン管理とチームでの共有方法

Dockerの大きなメリットの一つは、環境そのものをバージョン管理し、チーム間で容易に共有できる点です。

これらの戦略を組み合わせることで、環境構築に関する属人性を排除し、オンボーディングの迅速化、開発環境間の差異によるトラブルの低減、そして継続的なインテグレーション/デリバリー (CI/CD) パイプラインへの組み込みが可能になります。

まとめ：DockerがもたらすAI開発の効率化と品質向上

本記事では、Dockerの基本概念から、GPU対応のAI開発環境構築、そしてDocker Composeを用いた複数コンテナ連携まで、実践的なハンズオン形式で解説しました。DockerをAI開発に導入することで、環境構築の課題を解決し、開発プロセス全体の効率性と品質を飛躍的に向上させられることをご理解いただけたかと思います。

環境構築の属人化を防ぎ、チーム開発を加速するDocker

AI開発における「環境構築」は、往々にして属人化しがちな作業です。特定の開発者に依存したり、環境間の微妙な差異が原因でバグが発生したりといった問題は、チーム全体の生産性を大きく阻害します。

Dockerは、Dockerfileという形で環境の「設計図」をコード化し、それを元に誰でも同じ「コンテナ」を生成できるメカニズムを提供します。これにより、環境構築の属人性が排除され、新しいメンバーのオンボーディングが迅速化し、開発者全員が同一かつ一貫性のある環境で作業できるようになります。結果として、コミュニケーションコストの削減、デバッグの効率化、そして何よりもAIモデル開発という本質的なタスクへの集中を促し、チーム開発のスピードと品質を両立させることが可能です。

CI/CDへの応用と開発ライフサイクルの最適化

Dockerは開発環境の構築に留まらず、AIモデルの開発ライフサイクル全体、特に継続的インテグレーション（CI）と継続的デリバリー（CD）のパイプラインにおいて極めて重要な役割を果たします。

• CI (継続的インテグレーション): モデルのコードが変更されるたびに、Dockerfileで定義された環境を用いて自動的にテストを実行できます。これにより、環境依存のバグを早期に発見し、開発の初期段階で品質を保証することが可能になります。
• CD (継続的デリバリー/デプロイ): Dockerイメージは、開発環境からテスト環境、そして本番環境へとシームレスにデプロイできる「運びやすいパッケージ」となります。モデルとその実行環境をコンテナにすることで、デプロイ時の「環境差異」による問題を最小限に抑え、信頼性の高いデプロイを実現します。

このように、Dockerは単なる環境構築ツールではなく、AI開発の品質を向上させ、開発から運用までのサイクル全体を最適化するための不可欠な技術と言えるでしょう。

次なるステップ：コンテナオーケストレーションへの挑戦

本記事でご紹介したDockerの活用は、AI開発における効率化の第一歩に過ぎません。さらに大規模なシステムや高可用性を求める環境では、複数のコンテナを効率的に管理・連携させる「コンテナオーケストレーション」の技術が重要になります。

• Kubernetes (K8s): コンテナオーケストレーションのデファクトスタンダードであり、数十、数百といったコンテナ群を自動でデプロイ、スケーリング、管理する機能を提供します。AIモデルのトレーニングジョブの実行、推論APIサービスの管理、GPUリソースの効率的な利用などに活用されます。
• クラウドサービス: AWS EKS、Azure AKS、Google Kubernetes Engine (GKE) など、主要なクラウドベンダーはマネージドKubernetesサービスを提供しており、運用負荷を軽減しながら高度なコンテナオーケストレーション環境を構築できます。

これらの技術を習得することで、さらにスケーラブルで堅牢なAIシステムを構築し、ビジネスにおけるAI活用を次のレベルへと引き上げることが可能になります。まずは本記事で学んだDockerの基礎とハンズオンを確実にマスターし、ぜひ次のステップへと挑戦してください。