Docker Compose AIフルスタックデプロイ：LLMからベクトルデータベースまでのワンクリックオーケストレーション

DevOps

AI開発環境の構築、まだ3日もかかってる？

2026年になっても、AI開発環境の構築は開発者の悪夢のままです。OllamaをインストールしてLLMを動かし、Qdrantでベクトルを保存し、エンベディングサービスを構築し、APIゲートウェイで認証を設定し、GPUドライバ、CUDAバージョン、モデルダウンロードを処理する必要があります…3日経ってもコードを1行も書いていません。

Docker Compose AIフルスタックデプロイは、これらすべてを1つのファイルにオーケストレーションできます。docker compose up -d でAIスタック全体を数分で起動。本記事は、7つのコアパターン、5つのよくある落とし穴、10のエラートラブルシューティング、プロダクション強化戦略を網羅した完全実践ガイドです。

主要ポイント

  • Docker Compose AIフルスタックデプロイ = LLM + ベクトルDB + エンベディング + APIゲートウェイ + モニタリング、1ファイルで完結
  • Ollama + OpenWebUI は最も成熟したローカルLLMサービングソリューション
  • Qdrant/Milvus はベクトルデータベースの最適解、Dockerデプロイは極めてシンプル
  • GPUパススルーがAIデプロイの鍵 — deploy.resources.reservations.devices で設定
  • プロダクションでは認証、レート制限、モニタリング、バックアップの完全な強化が必要

目次

  • AIフルスタックアーキテクチャ全景
  • Pattern 1: Ollama + OpenWebUI LLMサービング
  • Pattern 2: Qdrant/Milvusベクトルデータベース
  • Pattern 3: エンベディングサービスとモデル管理
  • Pattern 4: APIゲートウェイと認証
  • Pattern 5: GPUパススルーとリソース制限
  • Pattern 6: モニタリングとオブザーバビリティ
  • Pattern 7: プロダクション強化とセキュリティ
  • 5つのよくある落とし穴と解決策
  • 10のよくあるエラートラブルシューティング
  • 高度な最適化テクニック
  • 比較分析：Docker Compose vs K8s vs Docker Swarm
  • オンラインツール推奨
  • まとめ

AIフルスタックアーキテクチャ全景

Docker Compose AIフルスタックデプロイの中核は7層アーキテクチャです。下層のGPUから上層のゲートウェイまで、各層に対応するコンテナサービスがあります：

┌─────────────────────────────────────────────────────┐
│                   API Gateway                        │
│              (Traefik / Nginx)                       │
│         認証 · レート制限 · ルーティング · TLS          │
├──────────┬──────────┬──────────┬────────────────────┤
│ OpenWebUI│  RAG App │  Agent   │  Admin Panel       │
│  (Chat)  │  (検索)   │  (代理)  │  (管理)             │
├──────────┴──────────┴──────────┴────────────────────┤
│              Embedding Service                       │
│       (TEI / Infinity / FastEmbed)                  │
├──────────────────┬──────────────────────────────────┤
│   Ollama LLM     │    vLLM / TGI                    │
│  (モデルサービス) │   (高性能推論)                     │
├──────────────────┴──────────────────────────────────┤
│           Vector Database                            │
│     (Qdrant / Milvus / Weaviate)                    │
├─────────────────────────────────────────────────────┤
│              Infrastructure                          │
│   Redis · PostgreSQL · MinIO · Prometheus            │
├─────────────────────────────────────────────────────┤
│              GPU / CPU Runtime                       │
│     NVIDIA CUDA · ROCm · CPU Fallback               │
└─────────────────────────────────────────────────────┘

Docker Compose AIフルスタックデプロイの完全なディレクトリ構造：

ai-stack/
├── docker-compose.yml
├── docker-compose.gpu.yml
├── docker-compose.prod.yml
├── .env
├── ollama/
│   └── Modelfile
├── qdrant/
│   └── config.yaml
├── traefik/
│   ├── traefik.yml
│   └── acme.json
├── monitoring/
│   ├── prometheus.yml
│   └── grafana/
│       └── dashboards/
└── scripts/
    ├── init-models.sh
    └── backup-vectors.sh

Pattern 1: Ollama + OpenWebUI LLMサービング

Ollamaは2026年最も成熟したローカルLLMサービングソリューションで、Llama 4、Qwen 3、DeepSeek V3などの主要モデルをサポートしています。OpenWebUIはChatGPTスタイルのWebインターフェースを提供します。

基本設定

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    environment:
      OLLAMA_KEEP_ALIVE: "24h"
      OLLAMA_NUM_PARALLEL: "4"
      OLLAMA_MAX_LOADED_MODELS: "3"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    volumes:
      - open_webui_data:/app/backend/data
    environment:
      OLLAMA_BASE_URL: "http://ollama:11434"
      WEBUI_SECRET_KEY: "${WEBUI_SECRET_KEY}"
      ENABLE_SIGNUP: "false"
      DEFAULT_USER_ROLE: "user"
    depends_on:
      ollama:
        condition: service_healthy
    restart: unless-stopped

volumes:
  ollama_data:
  open_webui_data:

モデル自動プル

Ollama起動後、モデルを手動でプルする必要がありますが、初期化スクリプトで自動化できます：

#!/bin/bash
# scripts/init-models.sh

MODELS=(
  "qwen3:8b"
  "llama4:8b"
  "deepseek-v3:8b"
  "nomic-embed-text"
)

for model in "${MODELS[@]}"; do
  echo "Pulling model: $model"
  until curl -s http://localhost:11434/api/pull -d "{\"name\":\"$model\"}" | grep -q "success"; do
    echo "  Retrying $model..."
    sleep 5
  done
  echo "  ✓ $model ready"
done

echo "All models pulled successfully!"

Docker Composeに初期化サービスを追加：

  model-init:
    image: curlimages/curl:latest
    container_name: model-init
    depends_on:
      ollama:
        condition: service_healthy
    volumes:
      - ./scripts/init-models.sh:/init-models.sh:ro
    entrypoint: ["/bin/sh", "/init-models.sh"]
    restart: "no"

カスタムModelfile

# ollama/Modelfile
FROM qwen3:8b

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 8192
PARAMETER stop "<|im_end|>"

SYSTEM """
あなたはプロフェッショナルなAIアシスタントです。質問に答える際：
1. まず簡潔な結論を述べる
2. 次に詳細な説明を提供する
3. 不確かな場合は明確に伝える
"""

カスタムモデルのビルド：

docker exec ollama ollama create my-assistant -f /root/.ollama/Modelfile

Pattern 2: Qdrant/Milvusベクトルデータベース

ベクトルデータベースはRAGアーキテクチャの中核です。Docker Compose AIフルスタックデプロイでは通常、Qdrant（軽量）またはMilvus（大規模）を選択します。

Qdrant設定（小中規模プロジェクト推奨）

  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - qdrant_data:/qdrant/storage
      - ./qdrant/config.yaml:/qdrant/config/production.yaml:ro
    environment:
      QDRANT__SERVICE__GRPC_PORT: "6334"
      QDRANT__LOG_LEVEL: "INFO"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:6333/healthz"]
      interval: 10s
      timeout: 5s
      retries: 3
    restart: unless-stopped

Qdrant設定ファイル：

# qdrant/config.yaml
storage:
  performance:
    max_search_threads: 4
  wal:
    wal_capacity_mb: 32
    wal_segments_ahead: 0
  optimizers:
    indexing_threshold: 20000
    memmap_threshold: 50000
service:
  max_request_size_mb: 64
  enable_cors: true
telemetry_disabled: true

Milvus設定（大規模プロジェクト推奨）

  etcd:
    image: quay.io/coreos/etcd:v3.5.16
    container_name: milvus-etcd
    environment:
      ETCD_AUTO_COMPACTION_MODE: "revision"
      ETCD_AUTO_COMPACTION_RETENTION: "1000"
      ETCD_QUOTA_BACKEND_BYTES: "4294967296"
    volumes:
      - etcd_data:/etcd
    command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379
    restart: unless-stopped

  minio:
    image: minio/minio:latest
    container_name: milvus-minio
    environment:
      MINIO_ACCESS_KEY: "${MINIO_ACCESS_KEY}"
      MINIO_SECRET_KEY: "${MINIO_SECRET_KEY}"
    ports:
      - "9001:9001"
      - "9000:9000"
    volumes:
      - minio_data:/minio_data
    command: minio server /minio_data --console-address ":9001"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3
    restart: unless-stopped

  milvus:
    image: milvusdb/milvus:v2.5-latest
    container_name: milvus
    ports:
      - "19530:19530"
      - "9091:9091"
    volumes:
      - milvus_data:/var/lib/milvus
    environment:
      ETCD_ENDPOINTS: "etcd:2379"
      MINIO_ADDRESS: "minio:9000"
    depends_on:
      - etcd
      - minio
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]
      interval: 30s
      timeout: 20s
      retries: 3
      start_period: 90s
    restart: unless-stopped

ベクトルデータベース比較

機能 Qdrant Milvus Weaviate ChromaDB
デプロイ複雑度 極低（1コンテナ） 高（3+コンテナ） 低（1コンテナ） 極低（1コンテナ）
パフォーマンス（百万級） 優秀 優秀 良好 普通
パフォーマンス（億級） 良好 優秀 普通 非対象
フィルタ検索 ✅ 強力 ✅ 強力 ✅ 良好 ⚠️ 基本
永続化 ✅ ✅ ✅ ⚠️ デフォルトメモリ
マルチレプリカ ✅ ✅ ✅ ❌
gRPCサポート ✅ ✅ ❌ ❌
Docker Compose適合性 ✅ 最適 ⚠️ 重い ✅ 良好 ✅ 開発用
プロダクション対応 ✅ ✅ ✅ ❌ 開発のみ

選定推奨：Docker Compose AIフルスタックデプロイではQdrantが最適。デプロイがシンプルでパフォーマンスも優秀。ベクトル数が1億を超える場合はMilvusを検討。ChromaDBはプロトタイピングのみに適しています。

Pattern 3: エンベディングサービスとモデル管理

エンベディングサービスはテキストをベクトルに変換し、RAGパイプラインの重要なステップです。Docker Compose AIコンテナオーケストレーションには3つの主流ソリューションがあります。

Hugging Face TEI（推奨）

  tei:
    image: ghcr.io/huggingface/text-embeddings-inference:latest
    container_name: tei
    ports:
      - "8080:80"
    volumes:
      - tei_cache:/data
    environment:
      MODEL_ID: "BAAI/bge-m3"
      REVISION: "main"
      MAX_BATCH_TOKENS: "16384"
      MAX_CLIENT_BATCH_SIZE: "32"
      HF_TOKEN: "${HF_TOKEN}"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:80/health"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 120s
    restart: unless-stopped

Infinityエンベディングサービス

  infinity:
    image: michaelf34/infinity:latest
    container_name: infinity
    ports:
      - "7997:7997"
    volumes:
      - infinity_cache:/app/.cache
    environment:
      MODEL_ID: "BAAI/bge-m3"
      ENGINE: "optimum"
      BATCH_SIZE: "32"
    command: >
      --model-id BAAI/bge-m3
      --engine optimum
      --port 7997
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7997/health"]
      interval: 10s
      timeout: 5s
      retries: 3
    restart: unless-stopped

エンベディングサービス呼び出し例

import httpx
import numpy as np

async def get_embeddings(texts: list[str]) -> list[list[float]]:
    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.post(
            "http://tei:80/embed",
            json={"inputs": texts}
        )
        response.raise_for_status()
        return response.json()

async def search_similar(query: str, top_k: int = 5) -> list[dict]:
    query_embedding = await get_embeddings([query])
    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.post(
            "http://qdrant:6333/collections/documents/points/search",
            json={
                "vector": query_embedding[0],
                "limit": top_k,
                "with_payload": True
            }
        )
        response.raise_for_status()
        return response.json()["result"]

エンベディングサービス比較

機能 TEI Infinity FastEmbed
GPUアクセラレーション ✅ ネイティブ ✅ ネイティブ ❌ CPUのみ
バッチ推論 ✅ 高効率 ✅ 高効率 ⚠️ 普通
マルチモデル ✅ ✅ ✅
Dockerイメージサイズ ~2GB ~4GB ~500MB
プロダクション対応 ✅ ✅ ⚠️ 開発用
OpenAI互換API ✅ ✅ ❌

Pattern 4: APIゲートウェイと認証

プロダクション環境のDocker Compose AIフルスタックデプロイには、統一認証、レート制限、ルーティングのためのAPIゲートウェイが必須です。

Traefik設定

  traefik:
    image: traefik:v3.2
    container_name: traefik
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik/traefik.yml:/etc/traefik/traefik.yml:ro
      - traefik_certs:/etc/traefik/certs
      - ./traefik/dynamic:/etc/traefik/dynamic:ro
    command:
      - "--api.dashboard=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--providers.file.directory=/etc/traefik/dynamic"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
    labels:
      traefik.enable: "true"
      traefik.http.routers.traefik.rule: "Host(`traefik.ai-stack.local`)"
      traefik.http.routers.traefik.entrypoints: "websecure"
      traefik.http.routers.traefik.tls: "true"
      traefik.http.services.traefik.loadbalancer.server.port: "8080"
    restart: unless-stopped

OpenWebUIとTraefikの連携

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    volumes:
      - open_webui_data:/app/backend/data
    environment:
      OLLAMA_BASE_URL: "http://ollama:11434"
    labels:
      traefik.enable: "true"
      traefik.http.routers.webui.rule: "Host(`chat.ai-stack.local`)"
      traefik.http.routers.webui.entrypoints: "websecure"
      traefik.http.routers.webui.tls: "true"
      traefik.http.services.webui.loadbalancer.server.port: "8080"
    depends_on:
      ollama:
        condition: service_healthy
    restart: unless-stopped

認証ミドルウェア

# traefik/dynamic/auth.yml
http:
  middlewares:
    auth-middleware:
      forwardAuth:
        address: "http://auth-service:8000/verify"
        trustForwardHeader: true
        authResponseHeaders:
          - "X-User-Id"
          - "X-User-Role"

    rate-limit:
      rateLimit:
        average: 30
        burst: 60
        period: 1m

  routers:
    api-router:
      rule: "Host(`api.ai-stack.local`)"
      entrypoints:
        - "websecure"
      tls: true
      middlewares:
        - "auth-middleware"
        - "rate-limit"
      service: "ollama-api"

Pattern 5: GPUパススルーとリソース制限

AIデプロイの中核はGPUです。Docker Compose AIフルスタックデプロイは deploy.resources.reservations.devices でGPUパススルーを実現します。

NVIDIA GPUパススルー

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
        limits:
          memory: 16G
          cpus: "8.0"
    environment:
      NVIDIA_VISIBLE_DEVICES: "all"
      NVIDIA_DRIVER_CAPABILITIES: "compute,utility"
      OLLAMA_KEEP_ALIVE: "24h"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped

マルチGPU割り当て

  ollama:
    image: ollama/ollama:latest
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["0"]
              capabilities: [gpu]
    environment:
      CUDA_VISIBLE_DEVICES: "0"

  tei:
    image: ghcr.io/huggingface/text-embeddings-inference:latest
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["1"]
              capabilities: [gpu]
    environment:
      CUDA_VISIBLE_DEVICES: "1"

CPUフォールバック設定

  ollama-cpu:
    image: ollama/ollama:latest
    profiles: ["cpu-only"]
    container_name: ollama
    volumes:
      - ollama_data:/root/.ollama
    environment:
      OLLAMA_NUM_PARALLEL: "2"
      OLLAMA_MAX_LOADED_MODELS: "1"
    deploy:
      resources:
        limits:
          memory: 8G
          cpus: "4.0"

  ollama-gpu:
    image: ollama/ollama:latest
    profiles: ["gpu"]
    container_name: ollama
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
        limits:
          memory: 16G

起動方法：

# GPUモード
docker compose --profile gpu up -d

# CPUモード
docker compose --profile cpu-only up -d

GPUリソースモニタリングスクリプト

import subprocess
import json
import time

def monitor_gpu_usage(interval: int = 60):
    while True:
        result = subprocess.run(
            ["nvidia-smi", "--query-gpu=index,name,memory.used,memory.total,utilization.gpu",
             "--format=csv,noheader,nounits"],
            capture_output=True, text=True
        )
        for line in result.stdout.strip().split("\n"):
            idx, name, mem_used, mem_total, util = line.split(", ")
            print(f"GPU {idx} ({name}): {mem_used}/{mem_total}MB, Util: {util}%")
        time.sleep(interval)

if __name__ == "__main__":
    monitor_gpu_usage()

Pattern 6: モニタリングとオブザーバビリティ

Docker Compose AIフルスタックデプロイのモニタリングは、GPU使用率、推論レイテンシ、ベクトルデータベースパフォーマンスなど、AI固有のメトリクスをカバーする必要があります。

Prometheus + Grafana

  prometheus:
    image: prom/prometheus:v3.2.0
    container_name: prometheus
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.retention.time=30d"
      - "--storage.tsdb.retention.size=10GB"
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:11.5.0
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
      - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards:ro
      - ./monitoring/grafana/datasources:/etc/grafana/provisioning/datasources:ro
    environment:
      GF_SECURITY_ADMIN_USER: "${GRAFANA_USER}"
      GF_SECURITY_ADMIN_PASSWORD: "${GRAFANA_PASSWORD}"
      GF_USERS_ALLOW_SIGN_UP: "false"
    ports:
      - "3001:3000"
    depends_on:
      - prometheus
    restart: unless-stopped

  dcgm-exporter:
    image: nvidia/dcgm-exporter:latest
    container_name: dcgm-exporter
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    ports:
      - "9400:9400"
    restart: unless-stopped

Prometheus設定

# monitoring/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: "ollama"
    static_configs:
      - targets: ["ollama:11434"]
    metrics_path: "/metrics"
    scrape_interval: 30s

  - job_name: "qdrant"
    static_configs:
      - targets: ["qdrant:6333"]
    metrics_path: "/metrics"
    scrape_interval: 30s

  - job_name: "dcgm"
    static_configs:
      - targets: ["dcgm-exporter:9400"]
    scrape_interval: 10s

  - job_name: "node-exporter"
    static_configs:
      - targets: ["node-exporter:9100"]

  - job_name: "traefik"
    static_configs:
      - targets: ["traefik:8080"]

主要アラートルール

# monitoring/alerts.yml
groups:
  - name: ai-stack
    rules:
      - alert: OllamaHighLatency
        expr: histogram_quantile(0.95, rate(ollama_request_duration_seconds_bucket[5m])) > 30
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Ollama推論レイテンシが高すぎます"

      - alert: GPUMemoryHigh
        expr: DCGM_FI_DEV_FB_USED / DCGM_FI_DEV_FB_TOTAL > 0.9
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "GPUメモリ使用率が90%を超えています"

      - alert: QdrantHighLatency
        expr: histogram_quantile(0.95, rate(qdrant_request_duration_seconds_bucket[5m])) > 5
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Qdrantクエリレイテンシが高すぎます"

      - alert: OllamaContainerDown
        expr: up{job="ollama"} == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Ollamaサービスが利用不可です"

Pattern 7: プロダクション強化とセキュリティ

Docker Compose AIフルスタックデプロイをプロダクションに導入する際、セキュリティは最低条件です。

Secrets管理

services:
  ollama:
    image: ollama/ollama:latest
    secrets:
      - hf_token
    environment:
      HF_TOKEN_FILE: /run/secrets/hf_token

  qdrant:
    image: qdrant/qdrant:latest
    secrets:
      - qdrant_api_key
    environment:
      QDRANT__SERVICE__API_KEY_FILE: /run/secrets/qdrant_api_key

secrets:
  hf_token:
    file: ./secrets/hf_token.txt
  qdrant_api_key:
    file: ./secrets/qdrant_api_key.txt
  db_password:
    file: ./secrets/db_password.txt

ネットワーク分離

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true
  monitoring:
    driver: bridge
    internal: true

services:
  traefik:
    networks:
      - frontend
      - backend

  open-webui:
    networks:
      - frontend
      - backend

  ollama:
    networks:
      - backend

  qdrant:
    networks:
      - backend

  tei:
    networks:
      - backend

  prometheus:
    networks:
      - monitoring
      - backend

  grafana:
    networks:
      - frontend
      - monitoring

バックアップ戦略

#!/bin/bash
# scripts/backup-vectors.sh

BACKUP_DIR="/backups/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"

echo "Backing up Qdrant..."
curl -s -X POST "http://localhost:6333/snapshots" | jq .

echo "Backing up Ollama models list..."
curl -s "http://localhost:11434/api/tags" | jq . > "$BACKUP_DIR/ollama_models.json"

echo "Backing up environment config..."
cp .env "$BACKUP_DIR/.env.backup"
cp docker-compose.yml "$BACKUP_DIR/docker-compose.yml.backup"

echo "Backup completed: $BACKUP_DIR"

完全プロダクション設定

# docker-compose.prod.yml
services:
  ollama:
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
        limits:
          memory: 16G
          cpus: "8.0"
      restart_policy:
        condition: on-failure
        delay: 10s
        max_attempts: 5
        window: 120s
    logging:
      driver: json-file
      options:
        max-size: "100m"
        max-file: "5"
    read_only: true
    tmpfs:
      - /tmp

  qdrant:
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: "2.0"
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
    logging:
      driver: json-file
      options:
        max-size: "50m"
        max-file: "3"

5つのよくある落とし穴と解決策

落とし穴1：Ollamaモデルプルタイムアウト

現象：docker compose up 後、Ollamaがモデルのプルで止まる。大規模モデル（Llama 4 70Bなど）のダウンロードは1時間以上かかる場合がある。

解決策：model-init サービスで非同期プルを行う。Ollamaサービス自体はモデルの準備を待つ必要がない。

  model-init:
    image: curlimages/curl:latest
    depends_on:
      ollama:
        condition: service_healthy
    volumes:
      - ./scripts/init-models.sh:/init-models.sh:ro
    entrypoint: ["/bin/sh", "/init-models.sh"]
    restart: "no"
    deploy:
      resources:
        limits:
          memory: 256M

落とし穴2：QdrantコンテナOOM

現象：ベクトルデータ量が増加すると、QdrantコンテナがOOM Killedされる。

解決策：メモリ制限を設定し、メモリマッピングを有効にする。

  qdrant:
    image: qdrant/qdrant:latest
    deploy:
      resources:
        limits:
          memory: 8G
    environment:
      QDRANT__STORAGE__PERFORMANCE__MAX_SEARCH_THREADS: "4"
      QDRANT__STORAGE__WAL__WAL_CAPACITY_MB: "64"

落とし穴3：GPUドライババージョンの不一致

現象：docker compose up で CUDA driver version is insufficient エラー。

解決策：ホストのNVIDIAドライバが535以上であることを確認し、nvidia-container-toolkit をインストールする。

# ドライババージョンの確認
nvidia-smi | head -3

# nvidia-container-toolkitのインストール (Ubuntu)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

落とし穴4：エンベディングサービスとLLMのGPU競合

現象：TEIとOllamaが同時に実行されるとGPUメモリ不足になり、モデルのロードに失敗する。

解決策：device_ids でGPUを正確に割り当てるか、エンベディングサービスをCPUで実行する。

  ollama:
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["0"]
              capabilities: [gpu]

  tei:
    # CPUモードでエンベディングサービスを実行
    environment:
      MODEL_ID: "BAAI/bge-m3"
      # GPUを割り当てず、CPUを使用

落とし穴5：コンテナ間DNS解決の失敗

現象：OpenWebUIが ollama: Name or service not known を報告する。

解決策：すべてのサービスが同じネットワーク上にあることを確認し、container_name またはサービス名をホスト名として使用する。

networks:
  ai-network:
    driver: bridge

services:
  ollama:
    container_name: ollama
    networks:
      - ai-network

  open-webui:
    container_name: open-webui
    networks:
      - ai-network
    environment:
      OLLAMA_BASE_URL: "http://ollama:11434"

10のよくあるエラートラブルシューティング

1. could not select device driver — NVIDIAランタイム未インストール

# nvidia-container-toolkitをインストール後Dockerを再起動
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
docker info | grep -i runtime
# nvidia runtimeが表示されるはず

2. OOM Killed — GPUメモリ不足

# GPUメモリの確認
nvidia-smi
# より小さいモデルまたは量子化版を使用
docker exec ollama ollama run qwen3:4b

3. Connection refused to Ollama — サービス未準備

# Ollamaヘルスステータスの確認
docker compose ps
docker compose logs ollama
# ヘルスチェック通過後に接続

4. permission denied on Docker socket

sudo usermod -aG docker $USER
newgrp docker

5. Qdrant collection not found — コレクション未作成

curl -X PUT "http://localhost:6333/collections/documents" \
  -H "Content-Type: application/json" \
  -d '{"vectors": {"size": 1024, "distance": "Cosine"}}'

6. model not found — Ollamaモデル未プル

docker exec ollama ollama pull qwen3:8b

7. CUDA out of memory — 推論時のGPUメモリオーバーフロー

# 並行リクエスト数を減らす
# docker-compose.ymlで設定
environment:
  OLLAMA_NUM_PARALLEL: "1"
  OLLAMA_MAX_LOADED_MODELS: "1"

8. TLS handshake error — Traefik証明書の問題

# 証明書ファイルの権限確認
chmod 600 traefik/acme.json
# Traefikログの確認
docker compose logs traefik

9. too many open files — ファイルディスクリプタ制限

# 一時的に制限を引き上げ
ulimit -n 65536
# 永続設定（/etc/security/limits.conf）
# * soft nofile 65536
# * hard nofile 65536

10. vector dimension mismatch — エンベディング次元の不一致

# Qdrantコレクションの次元がエンベディングモデルの出力次元と一致することを確認
# bge-m3: 1024次元
# nomic-embed-text: 768次元
curl -X PUT "http://localhost:6333/collections/documents" \
  -d '{"vectors": {"size": 1024, "distance": "Cosine"}}'

高度な最適化テクニック

マルチステージモデルウォームアップ

  model-warmer:
    image: curlimages/curl:latest
    container_name: model-warmer
    depends_on:
      ollama:
        condition: service_healthy
    entrypoint: >
      /bin/sh -c "
        echo 'Warming up models...' &&
        curl -s http://ollama:11434/api/generate -d '{\"model\":\"qwen3:8b\",\"prompt\":\"hi\",\"stream\":false}' > /dev/null &&
        curl -s http://ollama:11434/api/generate -d '{\"model\":\"nomic-embed-text\",\"prompt\":\"test\",\"stream\":false}' > /dev/null &&
        echo 'Models warmed up!'
      "
    restart: "no"

スマートモデルアンロード

  ollama:
    environment:
      OLLAMA_KEEP_ALIVE: "5m"
      OLLAMA_NUM_PARALLEL: "4"
      OLLAMA_MAX_LOADED_MODELS: "2"

OLLAMA_KEEP_ALIVE: "5m" は5分間リクエストのないモデルを自動的にアンロードし、GPUメモリを解放します。

ヘルスチェックのチェーン依存

  tei:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:80/health"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 120s

  qdrant:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:6333/healthz"]
      interval: 10s
      timeout: 5s
      retries: 3

  rag-app:
    depends_on:
      ollama:
        condition: service_healthy
      tei:
        condition: service_healthy
      qdrant:
        condition: service_healthy

Docker Compose Watchによる自動開発

# docker-compose.yml
services:
  rag-app:
    build: .
    develop:
      watch:
        - action: rebuild
          path: ./app
          target: /app
        - action: sync
          path: ./app/static
          target: /app/static

比較分析：Docker Compose vs K8s vs Docker Swarm

項目 Docker Compose Kubernetes Docker Swarm
AIフルスタックデプロイ複雑度 ⭐ 極低 ⭐⭐⭐⭐⭐ 極高 ⭐⭐ 低
GPUスケジューリング ✅ ネイティブ ✅ Device Plugin ⚠️ 設定必要
オートスケーリング ❌ ✅ HPA ⚠️ 手動
サービスディスカバリ ✅ DNS ✅ CoreDNS ✅ DNS
ローリングアップデート ⚠️ スクリプト必要 ✅ ネイティブ ✅ ネイティブ
設定管理 ✅ .env ✅ ConfigMap ⚠️ Config
Secret管理 ✅ Docker Secret ✅ K8s Secret ⚠️ 基本
モニタリングエコシステム ✅ Prometheus ✅ 完全 ⚠️ 限定的
マルチノードオーケストレーション ❌ 単一ノード ✅ コア機能 ✅ ネイティブ
学習曲線 低 高 低
コミュニティ活動 ✅ 活発 ✅ 非常に活発 ❌ 衰退中
対象AIプロジェクト規模 1-5 GPU 10+ GPU 2-5 GPU

選定推奨：Docker Compose AIフルスタックデプロイは単一マシン1-5 GPUのシナリオに最適。AI開発と小規模プロダクションの最適な選択肢です。5 GPU以上またはマルチノードが必要な場合は、Kubernetes + KServe/vLLMを検討してください。Docker SwarmはAIデプロイには推奨されません。

オンラインツール推奨

まとめ

Docker Compose AIフルスタックデプロイは、AI開発環境を「3日かけても構築できない」から「1コマンドで起動」へと変えます。Ollama + OpenWebUIでLLMサービング、Qdrantでベクトルストレージ、TEIでエンベディング、Traefikでゲートウェイ、Prometheus + Grafanaでモニタリング、GPUパススルーで推論を高速化。7つのパターンが開発からプロダクションまでの全チェーンをカバーし、5つの落とし穴と10のエラートラブルシューティングで遠回りを回避します。1-5 GPUのAIプロジェクトにおいて、Docker Composeは2026年最も実用的なAIコンテナオーケストレーションソリューションです。

関連記事

外部リファレンス

ブラウザローカルツールを無料で試す →

#Docker#Docker Compose#AI部署#LLM#向量数据库#Ollama#2026#DevOps