tva
← コラム

意図しない共倒れを防ぐマルチテナントDocker

ベンダーの公式文書を、運用上の管理策、移行の判断、検証可能なリリース基準に落とし込む、本番運用に向けた最新の続編です。

2026年に変わったこと

運用上の境界条件が変化したため、このテーマを改めて検討します。長期的に有効な原則は残る一方、現行バージョンでは過去の近道が不十分、あるいは危険になっている場合があります。本稿は2026年7月14日時点で入手できる公式文書を起点に、事実とローカルな判断を分け、設定変更をすべて管理された本番介入として扱います。

最新の一次資料

この更新版の使い方

まず一次資料を確認し、実際に稼働しているバージョンを記録し、設定を変える前に観測可能な成果を定義します。代表性のある環境で、最小かつ元に戻せる変更を試します。コマンドが成功しただけでは受け入れ基準を満たしません。サービスの健全性、データ完全性、レイテンシー、セキュリティ境界、ロールバック時間まで確認します。旧稿の診断手順で現在も有効な部分は運用基盤として残しますが、バージョン依存の例は必ず現行文書と照合します。

運用の基盤

サブドメインベースのルーティングを通じてオフラインでもオンラインでもアクセス可能な、16のコンテナ化されたサービスを持つテンプレートベースのマルチテナント開発環境の構築方法。以下の設定ファイル、スクリプト、コマンド例は元のガイドから引用し、必要な箇所を修正しています。

複数クライアントの開発環境管理は、複雑な手動セットアップか高額なクラウドソリューションのどちらかを選択しなければならないことがよくあります。手動デプロイは時間がかかり、エラーも発生しやすいです。クラウドプラットフォームは便利ですが、ベンダーロックインと使用量に応じて増加する継続的なコストが発生します。

今回は、クライアント環境間の強固な分離と自動デプロイ機能を両立しながら、インフラの完全なコントロールを維持するスケーラブルなマルチテナント開発スタックの構築方法をご紹介します。このアプローチは、セルフホスティングソリューションの理念に基づいています。n8nをセルフホストしてワークフロー自動化を実現する方法や、DockerでWindmillをデプロイする方法で完全な運用コントロールを実現するのと同様のコンセプトです。

使用するツール

まず、16コンテナ構成における各コンポーネントの役割を確認します。

Docker：コンテナ化の基盤

Dockerは、マルチテナント環境に必要な分離性と一貫性を提供します。各クライアントに同一の設定を持つ専用コンテナを用意することで、開発環境で動作するものを本番環境でも動作させやすくなります。同じハードウェア上で複数の独立したサーバーを稼働させるようなものですが、CPU、メモリ、ディスク、カーネルは共有しています。

主なメリットは、クライアント環境を強固に分離できることです。各クライアントのデータ、設定、カスタマイズは別々のコンテナ、ネットワーク、ボリュームに配置されるため、他のクライアントのものに干渉しません。異なる要件やセキュリティニーズを持つ複数のビジネスクライアントを扱う際に、これは非常に重要です。

Traefik：スマートリバースプロキシとロードバランサー

Traefikは、ドメイン名に基づいてリクエストを適切なクライアント環境に自動的にルーティングするインテリジェントなトラフィック管理ツールです。複雑なApacheやNginxのルールを手動で設定する代わりに、TraefikがDockerコンテナのラベルを読み取り、ルーティングを自動的に設定します。

Traefikは、各訪問者（リクエスト）をどのオフィス（コンテナ）に案内すべきかを正確に知っている、いわばスマートな受付のようなものです。毎回指示を出す必要はありません。このセットアップでは、TraefikがSSL終端、自動サービスディスカバリを処理し、詳細なモニタリングダッシュボードを提供します。

Cloudflareトンネル：安全な外部アクセス

Cloudflareトンネルは、複雑なファイアウォール設定やVPNなしで、ローカル開発スタックへの安全なアクセスを提供します。各クライアントドメインに独自のトンネルを用意し、クライアントごとの外部アクセス経路を分離します。

優れた点は、開発環境がローカルかつ安全な状態を維持しながら、適切な認証によりクライアントがどこからでも特定のサービスにアクセスできることです。n8nホスティングガイドで安全な外部アクセスを設定したのと同様のアプローチです。

完全なサービススタック：クライアントが必要とするすべて

マルチテナントスタックには、クライアントごとに16コンテナにわたる4つのコアサービスカテゴリーが含まれます。

ワークフロー自動化とビジネスロジック：

  • n8n：業務プロセスの自動化のための完全なワークフロー自動化プラットフォーム
  • Authentik：エンタープライズグレードのシングルサインオンとID管理（サーバー、ワーカー、Redisキャッシュの3コンテナ）

データベースとバックエンドサービス：

  • PostgreSQL：最適化されたコネクションプーリングですべてのサービスをサポートする堅牢なデータベースバックエンド
  • Supabaseスタック：6つの専用コンテナ（Studio、Meta、Auth、REST API、Realtime、Kong Gateway）による完全なBaaS（Backend-as-a-Service）
  • NocoDB：クライアントデータ管理のためのノーコードデータベースインターフェース

AIとインテリジェンス：

  • Ollama：インテリジェントな自動化のためのGPUアクセラレーション対応ローカルAI言語モデル
  • Qdrant（オプション）：高度なAIワークフローと類似検索のためのベクトルデータベース

インフラとモニタリング：

  • Cloudflareトンネル：安全な外部接続
  • Traefik：自動SSLとモニタリングダッシュボード付きリバースプロキシ

全体の仕組み

クライアントが環境にアクセスする際の完全なフローは以下の通りです。

  • クライアントがカスタムドメイン（例：workflows.client-a.com）にアクセスします
  • CloudflareトンネルがリクエストをローカルのTraefikインスタンスにルーティングします
  • Traefikがドメインを読み取り、ミドルウェア（認証、SSL、レート制限）を適用し、正しいクライアントコンテナに転送します
  • 設定されている場合、AuthentikがすべてのサービスにわたるSSO認証を処理します
  • クライアントは、自分のデータと設定を持つ専用の分離された環境を利用できます
  • このクライアントのルートから他のクライアントの環境にはアクセスできません

すべてが整理・分離された状態を維持し、各クライアントはauth.client-a.com、database.client-a.com、backend.client-a.comなどの独自のサブドメイン構造を持ちます。

セットアップの実践手順

基盤の準備

まず、Docker Desktopのインストールとドメイン管理のセットアップが必要です。簡単なクライアントオンボーディングのために、ワイルドカードDNS構造の設定を推奨します。

# Install Docker Desktop (macOS)
brew install --cask docker

# Verify installation
docker --version
docker compose version

# Ensure sufficient resources for multi-container environments
# Recommended: 16GB RAM, 8+ CPU cores, 500GB+ SSD storage

テンプレートシステムの作成

テンプレートベースのアプローチにより、その真価が発揮されます。各クライアントを手動でセットアップする代わりに、クライアント固有の設定で即座にデプロイできるテンプレートを作成します。

全体のディレクトリ構造を作成します。

mkdir -p development-stack/{template,deployments}
cd development-stack/template

# Create service-specific configuration directories
mkdir -p {traefik,authentik,supabase,init}

完全なマルチサービステンプレート設定

全16サービスを含むdocker-compose.ymlの完全なテンプレートを作成します。

networks:
  tenant:
    name: ${TENANT_NETWORK}
    driver: bridge

services:
  # External Connectivity (public hostnames point to https://traefik:443 in the Cloudflare dashboard)
  cloudflare-tunnel:
    image: cloudflare/cloudflared:2026.7.2
    container_name: ${TENANT_PREFIX}-tunnel
    command: tunnel --no-autoupdate run --token ${CLOUDFLARE_TOKEN}
    networks:
      - tenant
    restart: unless-stopped

  # Reverse Proxy & Load Balancer
  # No host ports 80/443: client traffic arrives through the tunnel, so several
  # clients can share one host. Certificates use the Cloudflare DNS challenge.
  traefik:
    image: traefik:v3.7.9
    container_name: ${TENANT_PREFIX}-traefik
    command:
      - "--api.dashboard=true"
      - "--ping=true"
      - "--providers.docker=true"
      - "--providers.docker.network=${TENANT_NETWORK}"
      - "--providers.docker.exposedbydefault=false"
      - "--providers.docker.constraints=Label(`com.docker.compose.project`,`${TENANT_PREFIX}`)"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.websecure.asdefault=true"
      - "--entrypoints.traefik.address=:8080"
      - "--certificatesresolvers.letsencrypt.acme.email=${ADMIN_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.dnschallenge.provider=cloudflare"
    environment:
      CF_DNS_API_TOKEN: ${CF_DNS_API_TOKEN}
    ports:
      # Dashboard on localhost only (http://localhost:PORT/dashboard/)
      - "127.0.0.1:${TRAEFIK_DASHBOARD_PORT}:8080"
    networks:
      - tenant
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik/acme.json:/acme.json
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.dashboard.rule=PathPrefix(`/`)"
      - "traefik.http.routers.dashboard.entrypoints=traefik"
      - "traefik.http.routers.dashboard.service=api@internal"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "traefik", "healthcheck", "--ping"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Database Backend
  postgres:
    image: postgres:15.18-alpine
    container_name: ${TENANT_PREFIX}-postgres
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init:/docker-entrypoint-initdb.d
    networks:
      - tenant
    ports:
      # Localhost only, for admin tools on the host
      - "127.0.0.1:${POSTGRES_PORT}:5432"
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 30s
      timeout: 10s
      retries: 5
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G

  # Workflow Automation
  n8n:
    image: n8nio/n8n:2.31.7
    container_name: ${TENANT_PREFIX}-n8n
    environment:
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: ${POSTGRES_USER}
      DB_POSTGRESDB_PASSWORD: ${POSTGRES_PASSWORD}
      N8N_PROTOCOL: ${N8N_PROTOCOL}
      N8N_HOST: ${N8N_DOMAIN}
      N8N_PORT: 5678
      N8N_SECURE_COOKIE: ${N8N_SECURE_COOKIE}
      WEBHOOK_URL: https://${N8N_DOMAIN}
      N8N_EDITOR_BASE_URL: https://${N8N_DOMAIN}
      EXECUTIONS_DATA_PRUNE: "true"
      EXECUTIONS_DATA_MAX_AGE: 168
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - tenant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.n8n.rule=Host(`${N8N_DOMAIN}`)"
      - "traefik.http.routers.n8n.tls.certresolver=letsencrypt"
      - "traefik.http.services.n8n.loadbalancer.server.port=5678"
      - "traefik.http.routers.n8n.middlewares=${AUTH_MIDDLEWARE}"
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy

  # No-Code Database Interface
  nocodb:
    image: nocodb/nocodb:2026.07.0
    container_name: ${TENANT_PREFIX}-nocodb
    environment:
      NC_DB: "pg://postgres:5432?u=${POSTGRES_USER}&p=${POSTGRES_PASSWORD}&d=nocodb"
      NC_PUBLIC_URL: https://${NOCODB_DOMAIN}
      NC_DISABLE_TELE: "true"
      NC_ADMIN_EMAIL: ${ADMIN_EMAIL}
      NC_ADMIN_PASSWORD: ${NOCODB_ADMIN_PASSWORD}
    volumes:
      - nocodb_data:/usr/app/data
    networks:
      - tenant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.nocodb.rule=Host(`${NOCODB_DOMAIN}`)"
      - "traefik.http.routers.nocodb.tls.certresolver=letsencrypt"
      - "traefik.http.services.nocodb.loadbalancer.server.port=8080"
      - "traefik.http.routers.nocodb.middlewares=${AUTH_MIDDLEWARE}"
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy

  # Supabase Backend Stack (5 containers)
  supabase-studio:
    image: supabase/studio:2026.07.27-sha-cbb076d
    container_name: ${TENANT_PREFIX}-supabase-studio
    environment:
      STUDIO_PG_META_URL: http://supabase-meta:8080
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      DEFAULT_ORGANIZATION_NAME: ${CLIENT_NAME}
      DEFAULT_PROJECT_NAME: ${CLIENT_NAME} Project
      SUPABASE_PUBLIC_URL: https://${SUPABASE_DOMAIN}
    networks:
      - tenant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.supabase-studio.rule=Host(`${SUPABASE_DOMAIN}`)"
      - "traefik.http.routers.supabase-studio.tls.certresolver=letsencrypt"
      - "traefik.http.services.supabase-studio.loadbalancer.server.port=3000"
      - "traefik.http.routers.supabase-studio.middlewares=${AUTH_MIDDLEWARE}"
    restart: unless-stopped
    healthcheck:
      disable: true
    depends_on:
      postgres:
        condition: service_healthy

  supabase-meta:
    image: supabase/postgres-meta:v0.96.6
    container_name: ${TENANT_PREFIX}-supabase-meta
    environment:
      PG_META_PORT: 8080
      PG_META_DB_HOST: postgres
      PG_META_DB_PORT: 5432
      PG_META_DB_NAME: supabase
      PG_META_DB_USER: ${POSTGRES_USER}
      PG_META_DB_PASSWORD: ${POSTGRES_PASSWORD}
    networks:
      - tenant
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy

  supabase-auth:
    image: supabase/gotrue:v2.193.1
    container_name: ${TENANT_PREFIX}-supabase-auth
    environment:
      GOTRUE_API_HOST: 0.0.0.0
      GOTRUE_API_PORT: 9999
      API_EXTERNAL_URL: https://api.${CLIENT_DOMAIN}
      GOTRUE_DB_DRIVER: postgres
      GOTRUE_DB_DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/supabase
      GOTRUE_SITE_URL: https://${SUPABASE_DOMAIN}
      GOTRUE_JWT_SECRET: ${SUPABASE_JWT_SECRET}
      GOTRUE_JWT_EXP: 3600
      GOTRUE_JWT_DEFAULT_GROUP_NAME: authenticated
    networks:
      - tenant
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy

  supabase-rest:
    image: postgrest/postgrest:v13.0.8
    container_name: ${TENANT_PREFIX}-supabase-rest
    environment:
      PGRST_DB_URI: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/supabase
      PGRST_DB_SCHEMAS: public
      PGRST_DB_ANON_ROLE: anon
      PGRST_JWT_SECRET: ${SUPABASE_JWT_SECRET}
      PGRST_DB_USE_LEGACY_GUCS: "false"
    networks:
      - tenant
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy

  supabase-realtime:
    image: supabase/realtime:v2.120.3
    container_name: ${TENANT_PREFIX}-supabase-realtime
    environment:
      PORT: 4000
      DB_HOST: postgres
      DB_PORT: 5432
      DB_USER: ${POSTGRES_USER}
      DB_PASSWORD: ${POSTGRES_PASSWORD}
      DB_NAME: supabase
      DB_AFTER_CONNECT_QUERY: 'SET search_path TO _realtime'
      DB_ENC_KEY: supabaserealtime
      API_JWT_SECRET: ${SUPABASE_JWT_SECRET}
      SECRET_KEY_BASE: ${SUPABASE_JWT_SECRET}
      METRICS_JWT_SECRET: ${SUPABASE_JWT_SECRET}
      ERL_AFLAGS: -proto_dist inet_tcp
      DNS_NODES: "''"
      APP_NAME: realtime
      SEED_SELF_HOST: "true"
    networks:
      - tenant
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy

  supabase-kong:
    image: kong:3.9.1
    container_name: ${TENANT_PREFIX}-supabase-kong
    environment:
      KONG_DATABASE: "off"
      KONG_DECLARATIVE_CONFIG: /var/lib/kong/kong.yml
      KONG_DNS_ORDER: LAST,A,CNAME
      KONG_PLUGINS: request-size-limiting,cors,key-auth,rate-limiting
      KONG_NGINX_PROXY_PROXY_BUFFER_SIZE: 160k
      KONG_NGINX_PROXY_PROXY_BUFFERS: 64 160k
    volumes:
      - ./supabase/kong.yml:/var/lib/kong/kong.yml:ro
    networks:
      - tenant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.kong.rule=Host(`api.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.kong.tls.certresolver=letsencrypt"
      - "traefik.http.services.kong.loadbalancer.server.port=8000"
      - "traefik.http.routers.kong.middlewares=${AUTH_MIDDLEWARE}"
    restart: unless-stopped

  # Local AI Language Models
  ollama:
    image: ollama/ollama:0.32.3
    container_name: ${TENANT_PREFIX}-ollama
    environment:
      OLLAMA_HOST: 0.0.0.0:11434
      OLLAMA_ORIGINS: "*"
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - tenant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.ollama.rule=Host(`ai.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.ollama.tls.certresolver=letsencrypt"
      - "traefik.http.services.ollama.loadbalancer.server.port=11434"
      - "traefik.http.routers.ollama.middlewares=${AUTH_MIDDLEWARE}"
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 16G
        reservations:
          memory: 8G
    healthcheck:
      test: ["CMD", "ollama", "list"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Enterprise SSO Authentication (3 containers)
  authentik-redis:
    image: redis:7.4.9-alpine
    container_name: ${TENANT_PREFIX}-authentik-redis
    command: --save 60 1 --loglevel warning
    networks:
      - tenant
    volumes:
      - authentik_redis_data:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      interval: 30s
      timeout: 3s
      retries: 3

  authentik-server:
    image: ghcr.io/goauthentik/server:${AUTHENTIK_TAG}
    container_name: ${TENANT_PREFIX}-authentik-server
    command: server
    environment:
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
      AUTHENTIK_ERROR_REPORTING__ENABLED: "false"
      AUTHENTIK_POSTGRESQL__HOST: postgres
      AUTHENTIK_POSTGRESQL__USER: ${POSTGRES_USER}
      AUTHENTIK_POSTGRESQL__NAME: authentik
      AUTHENTIK_POSTGRESQL__PASSWORD: ${POSTGRES_PASSWORD}
      AUTHENTIK_REDIS__HOST: authentik-redis
    volumes:
      - authentik_media:/media
      - authentik_templates:/templates
    networks:
      - tenant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authentik.rule=Host(`auth.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.authentik.tls.certresolver=letsencrypt"
      - "traefik.http.services.authentik.loadbalancer.server.port=9000"
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      authentik-redis:
        condition: service_healthy

  authentik-worker:
    image: ghcr.io/goauthentik/server:${AUTHENTIK_TAG}
    container_name: ${TENANT_PREFIX}-authentik-worker
    command: worker
    environment:
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
      AUTHENTIK_ERROR_REPORTING__ENABLED: "false"
      AUTHENTIK_POSTGRESQL__HOST: postgres
      AUTHENTIK_POSTGRESQL__USER: ${POSTGRES_USER}
      AUTHENTIK_POSTGRESQL__NAME: authentik
      AUTHENTIK_POSTGRESQL__PASSWORD: ${POSTGRES_PASSWORD}
      AUTHENTIK_REDIS__HOST: authentik-redis
    volumes:
      - authentik_media:/media
      - authentik_templates:/templates
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - tenant
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      authentik-redis:
        condition: service_healthy

  # Test Service for Health Monitoring
  whoami:
    image: traefik/whoami:v1.11.0
    container_name: ${TENANT_PREFIX}-whoami
    networks:
      - tenant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.whoami.rule=Host(`test.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.whoami.tls.certresolver=letsencrypt"
      - "traefik.http.services.whoami.loadbalancer.server.port=80"
    restart: unless-stopped

volumes:
  postgres_data:
  n8n_data:
  nocodb_data:
  ollama_data:
  authentik_redis_data:
  authentik_media:
  authentik_templates:

完全な環境テンプレート

クライアント固有の変数一式用に.env.templateを作成します。

# Client Configuration
CLIENT_NAME=CLIENT_NAME_PLACEHOLDER
CLIENT_DOMAIN=CLIENT_DOMAIN_PLACEHOLDER
TENANT_PREFIX=CLIENT_PREFIX_PLACEHOLDER
TENANT_NETWORK=CLIENT_NETWORK_PLACEHOLDER
# Compose project name: keeps volume names and Traefik's container filter per client
COMPOSE_PROJECT_NAME=CLIENT_PREFIX_PLACEHOLDER

# Service Domains (Subdomain-based routing)
N8N_DOMAIN=workflows.CLIENT_DOMAIN_PLACEHOLDER
NOCODB_DOMAIN=database.CLIENT_DOMAIN_PLACEHOLDER
SUPABASE_DOMAIN=backend.CLIENT_DOMAIN_PLACEHOLDER
AUTHENTIK_DOMAIN=auth.CLIENT_DOMAIN_PLACEHOLDER

# Host Ports (localhost only, offset per client by the deployment script)
TRAEFIK_DASHBOARD_PORT=8080
POSTGRES_PORT=5432

# Admin Configuration
ADMIN_EMAIL=admin@CLIENT_DOMAIN_PLACEHOLDER

# Database Configuration
POSTGRES_DB=main_db
POSTGRES_USER=postgres
POSTGRES_PASSWORD=SECURE_PASSWORD_PLACEHOLDER

# Service-Specific Passwords
NOCODB_ADMIN_PASSWORD=NOCODB_PASSWORD_PLACEHOLDER
SUPABASE_JWT_SECRET=SUPABASE_JWT_PLACEHOLDER

# Authentik SSO Configuration
AUTHENTIK_SECRET_KEY=AUTHENTIK_SECRET_PLACEHOLDER
AUTHENTIK_TAG=2025.8.6

# n8n Configuration
N8N_PROTOCOL=https
N8N_SECURE_COOKIE=true

# Cloudflare Integration (tunnel token, and an API token with Zone:DNS:Edit for certificates)
CLOUDFLARE_TOKEN=CLOUDFLARE_TOKEN_PLACEHOLDER
CF_DNS_API_TOKEN=CF_DNS_API_TOKEN_PLACEHOLDER

# Authentication Middleware (set to 'auth-global' for SSO, leave empty for no auth)
AUTH_MIDDLEWARE=

データベース初期化スクリプト

init/01-create-multiple-databases.sqlにデータベースの初期化処理一式を作成します。

-- Create databases for all services
CREATE DATABASE n8n;
CREATE DATABASE nocodb;
CREATE DATABASE supabase;
CREATE DATABASE authentik;

-- Enable required extensions for Supabase
-- (pgjwt is not part of the official postgres image, and a failing statement aborts the init)
\c supabase
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

-- Schemas and role the Supabase services expect
CREATE SCHEMA IF NOT EXISTS auth;
CREATE SCHEMA IF NOT EXISTS _realtime;
CREATE ROLE anon NOLOGIN;
GRANT USAGE ON SCHEMA public TO anon;

-- Enable required extensions for Authentik
\c authentik
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

\echo 'Multiple databases and extensions created successfully'

Supabase Kongゲートウェイ設定

APIゲートウェイルーティング用にsupabase/kong.ymlを作成します。

_format_version: "3.0"

services:
  - name: auth-v1-open
    url: http://supabase-auth:9999/verify
    plugins:
      - name: cors
    routes:
      - name: auth-v1-open
        strip_path: true
        paths:
          - /auth/v1/verify
        methods:
          - POST
          - OPTIONS

  - name: auth-v1-open-callback
    url: http://supabase-auth:9999/callback
    plugins:
      - name: cors
    routes:
      - name: auth-v1-open-callback
        strip_path: true
        paths:
          - /auth/v1/callback
        methods:
          - GET
          - POST
          - OPTIONS

  - name: auth-v1
    _comment: "GoTrue: /auth/v1/* -> http://supabase-auth:9999/*"
    url: http://supabase-auth:9999/
    plugins:
      - name: cors
      - name: key-auth
        config:
          hide_credentials: false
    routes:
      - name: auth-v1-all
        strip_path: true
        paths:
          - /auth/v1/
        methods:
          - GET
          - POST
          - PUT
          - PATCH
          - DELETE
          - OPTIONS

  - name: rest-v1
    _comment: "PostgREST: /rest/v1/* -> http://supabase-rest:3000/*"
    url: http://supabase-rest:3000/
    plugins:
      - name: cors
      - name: key-auth
        config:
          hide_credentials: true
    routes:
      - name: rest-v1-all
        strip_path: true
        paths:
          - /rest/v1/
        methods:
          - GET
          - POST
          - PUT
          - PATCH
          - DELETE
          - OPTIONS

  - name: realtime-v1
    _comment: "Realtime: /realtime/v1/* -> ws://supabase-realtime:4000/socket/*"
    url: http://supabase-realtime:4000/socket/
    plugins:
      - name: cors
      - name: key-auth
        config:
          hide_credentials: false
    routes:
      - name: realtime-v1-all
        strip_path: true
        paths:
          - /realtime/v1/
        methods:
          - GET
          - POST
          - PUT
          - PATCH
          - DELETE
          - OPTIONS

consumers:
  - username: anon
    keyauth_credentials:
      - key: your-anon-key-here
  - username: service_role
    keyauth_credentials:
      - key: your-service-role-key-here

plugins:
  - name: cors
    config:
      origins:
        - "*"
      methods:
        - GET
        - POST
        - PUT
        - PATCH
        - DELETE
        - OPTIONS
      headers:
        - Accept
        - Accept-Version
        - Content-Length
        - Content-MD5
        - Content-Type
        - Date
        - X-Auth-Token
        - Authorization
        - X-Forwarded-For
        - X-Forwarded-Proto
        - X-Forwarded-Port
      exposed_headers:
        - X-Auth-Token
      credentials: true
      max_age: 3600

自動デプロイスクリプト

数分で新しいクライアント環境を作成する一連の処理を行うデプロイスクリプト：

#!/bin/bash
# deploy-client.sh - Complete Multi-Tenant Deployment
set -euo pipefail

CLIENT_DOMAIN=${1:-}
CLIENT_NAME=${2:-}
CLOUDFLARE_TOKEN=${3:-}

if [ -z "$CLIENT_DOMAIN" ] || [ -z "$CLIENT_NAME" ] || [ -z "$CLOUDFLARE_TOKEN" ] || [ -z "${CF_DNS_API_TOKEN:-}" ]; then
    echo "Usage: CF_DNS_API_TOKEN=... ./deploy-client.sh example.com 'Client Name' 'cloudflare-tunnel-token'"
    echo ""
    echo "Example: ./deploy-client.sh client-a.com 'Client A Corporation' 'your-cloudflare-token'"
    echo "CF_DNS_API_TOKEN: Cloudflare API token with Zone:DNS:Edit, used for certificates"
    exit 1
fi

# Run from the template directory, wherever the script is called from
cd "$(dirname "$0")"

CLIENT_PREFIX=$(echo "$CLIENT_DOMAIN" | sed 's/[.-]//g' | tr '[:upper:]' '[:lower:]')
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

echo "🚀 Deploying complete multi-tenant environment..."
echo "📋 Configuration:"
echo "   Domain: $CLIENT_DOMAIN"
echo "   Name: $CLIENT_NAME"
echo "   Prefix: $CLIENT_PREFIX"
echo "   Timestamp: $TIMESTAMP"
echo ""

# Create deployment directory
DEPLOY_DIR="../deployments/$CLIENT_DOMAIN"
mkdir -p "$DEPLOY_DIR"/{traefik,authentik,supabase,init,logs}

echo "📁 Created deployment directory structure"

# Copy template files
cp docker-compose.yml "$DEPLOY_DIR/"
cp -R traefik authentik supabase init "$DEPLOY_DIR/"

echo "📋 Copied configuration templates"

# Generate secure passwords and secrets
POSTGRES_PASSWORD=$(openssl rand -hex 16)
NOCODB_PASSWORD=$(openssl rand -hex 12)
SUPABASE_JWT_SECRET=$(openssl rand -hex 32)
AUTHENTIK_SECRET=$(openssl rand -hex 32)

echo "🔐 Generated secure credentials"

# Offset the localhost-only host ports per client (80/443 are not published at all)
PORT_OFFSET=$(($(echo "$CLIENT_PREFIX" | cksum | cut -f1 -d' ') % 1000))
TRAEFIK_DASHBOARD_PORT=$((8080 + PORT_OFFSET))
POSTGRES_PORT=$((5432 + PORT_OFFSET))

# Create comprehensive environment file (readable by the owner only)
umask 077
sed -e "s/CLIENT_NAME_PLACEHOLDER/$CLIENT_NAME/g" \
    -e "s/CLIENT_DOMAIN_PLACEHOLDER/$CLIENT_DOMAIN/g" \
    -e "s/CLIENT_PREFIX_PLACEHOLDER/$CLIENT_PREFIX/g" \
    -e "s/CLIENT_NETWORK_PLACEHOLDER/${CLIENT_PREFIX}-network/g" \
    -e "s/SECURE_PASSWORD_PLACEHOLDER/$POSTGRES_PASSWORD/g" \
    -e "s/NOCODB_PASSWORD_PLACEHOLDER/$NOCODB_PASSWORD/g" \
    -e "s/SUPABASE_JWT_PLACEHOLDER/$SUPABASE_JWT_SECRET/g" \
    -e "s/AUTHENTIK_SECRET_PLACEHOLDER/$AUTHENTIK_SECRET/g" \
    -e "s/CLOUDFLARE_TOKEN_PLACEHOLDER/$CLOUDFLARE_TOKEN/g" \
    -e "s/CF_DNS_API_TOKEN_PLACEHOLDER/$CF_DNS_API_TOKEN/g" \
    -e "s/^TRAEFIK_DASHBOARD_PORT=.*/TRAEFIK_DASHBOARD_PORT=$TRAEFIK_DASHBOARD_PORT/" \
    -e "s/^POSTGRES_PORT=.*/POSTGRES_PORT=$POSTGRES_PORT/" \
    .env.template > "$DEPLOY_DIR/.env"

echo "⚙️  Generated environment configuration"

# Create ACME file for Traefik SSL
touch "$DEPLOY_DIR/traefik/acme.json"
chmod 600 "$DEPLOY_DIR/traefik/acme.json"

# Initialize deployment
cd "$DEPLOY_DIR"

echo "🐋 Starting Docker containers..."
echo "   This may take several minutes for first-time image downloads"

# Start all services (each waits for the database health check)
docker compose up -d

echo ""
echo "✅ Multi-tenant environment deployed successfully!"
echo ""
echo "🌐 Access URLs:"
echo "   🔧 Traefik Dashboard: http://localhost:$TRAEFIK_DASHBOARD_PORT/dashboard/"
echo "   🔀 Workflows (n8n): https://workflows.$CLIENT_DOMAIN"
echo "   🗄️  Database (NocoDB): https://database.$CLIENT_DOMAIN"
echo "   🔧 Backend (Supabase): https://backend.$CLIENT_DOMAIN"
echo "   🤖 AI (Ollama): https://ai.$CLIENT_DOMAIN"
echo "   🔐 Authentication: https://auth.$CLIENT_DOMAIN"
echo "   🔌 API Gateway: https://api.$CLIENT_DOMAIN"
echo "   🧪 Test Service: https://test.$CLIENT_DOMAIN"
echo ""
echo "📊 Container Status:"
docker compose ps
echo ""
echo "🔑 Generated credentials are stored in $DEPLOY_DIR/.env (mode 600)"
echo ""
echo "📝 Next Steps:"
echo "   1. In the Cloudflare tunnel, route *.${CLIENT_DOMAIN} to https://traefik:443 (No TLS Verify)"
echo "   2. Wait 2-3 minutes for all services to initialize"
echo "   3. Access services via the URLs above"
echo "   4. Configure SSO via auth.$CLIENT_DOMAIN if needed"
echo ""
echo "📚 Documentation: Visit tva.sg for setup guides and troubleshooting"
echo "💬 Support: Contact us via tva.sg/contact for assistance"

マルチテナントスタックの使い方

新規クライアントのデプロイ

一連の処理を行うスクリプトにより、新しいクライアント環境の作成が簡単になります。

# Set once per shell: Cloudflare API token with Zone:DNS:Edit (used for certificates)
export CF_DNS_API_TOKEN="your-cloudflare-dns-token"

# Deploy Client A with full enterprise stack
./deploy-client.sh client-a.com "Client A Corporation" "your-cloudflare-token"

# Deploy Client B with different domain
./deploy-client.sh client-b.org "Client B Industries" "your-cloudflare-token"

# Deploy Startup C
./deploy-client.sh startup-c.io "Startup C" "your-cloudflare-token"

各デプロイにより以下が作成されます。

  • 16コンテナを持つ専用のDockerネットワーク
  • 永続ストレージ用の個別データボリューム
  • ヘルスモニタリング付きの固有サービスコンテナ
  • 個別のCloudflareトンネル設定
  • SSL証明書付きのカスタムドメインルーティング
  • 有効化の準備が整ったエンタープライズグレードのSSOインフラ

複数環境の管理

中央の場所からすべてのクライアント環境を監視します。

# Check all running environments across clients
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" | grep -E "(client|startup)"

# View comprehensive logs for specific client
cd deployments/client-a.com
docker compose logs -f --tail=50 n8n

# Health check all services for a client
docker compose ps
docker compose exec postgres pg_isready

# Restart specific services
docker compose restart nocodb supabase-studio

# Update all services to the image versions now pinned in docker-compose.yml
docker compose pull && docker compose up -d

コンテナアーキテクチャの詳細

クライアントごとの完全な16コンテナアーキテクチャには以下が含まれます。

インフラレイヤー（4コンテナ）：

  • cloudflare-tunnel：安全な外部接続
  • traefik：自動SSLとサービスディスカバリ付きリバースプロキシ
  • postgres：コネクションプーリング付き中央データベース
  • whoami：ヘルスモニタリングとルーティング検証

アプリケーションレイヤー（7コンテナ）：

  • n8n：PostgreSQLバックエンド付きワークフロー自動化
  • nocodb：ノーコードデータベースインターフェース
  • supabase-studio：バックエンド開発ダッシュボード
  • supabase-meta：データベースの構造情報を取得するサービス
  • supabase-auth：認証とユーザー管理
  • supabase-rest：自動生成REST API
  • supabase-realtime：リアルタイムサブスクリプションと更新

AIとゲートウェイレイヤー（2コンテナ）：

  • ollama：GPUアクセラレーション対応ローカルAI
  • supabase-kong：レート制限とCORS付きAPIゲートウェイ

エンタープライズセキュリティレイヤー（3コンテナ）：

  • authentik-server：SSO認証サーバー
  • authentik-worker：バックグラウンドタスクと通知
  • authentik-redis：セッション管理とキャッシング

クライアントごとのリソーススケーリング

クライアントのニーズと使用パターンに基づいてリソースを調整します。

# High-performance client configuration (docker-compose.override.yml)
services:
  n8n:
    deploy:
      resources:
        limits:
          cpus: '4.0'
          memory: 8G
        reservations:
          cpus: '2.0'
          memory: 4G

  postgres:
    command: postgres -c max_connections=200 -c shared_buffers=1GB -c effective_cache_size=3GB
    deploy:
      resources:
        limits:
          cpus: '2.0'
          memory: 4G
        reservations:
          cpus: '1.0'
          memory: 2G

  ollama:
    deploy:
      resources:
        limits:
          memory: 32G
        reservations:
          memory: 16G
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

ビジネスへの実際のメリット

エンタープライズ機能を備えた完全なクライアント分離

各クライアントには、企業向けのSSO、AI機能、バックエンド基盤一式を備えた専用環境を用意します。データ、設定、カスタマイズ、セキュリティポリシーは分離されます。あるクライアントの環境で発生したアプリケーションレベルの問題はその環境内にとどまりますが、すべてのクライアントが1台のホストを共有するため、CPU、メモリ、ディスクのリソース枯渇など、ホストレベルの問題は全体に影響する可能性があります。個別のn8nデプロイで実現する分離と同様のコンセプトです。

フル機能セットによる迅速なクライアントオンボーディング

新規クライアントは、完全な開発・自動化スタックを10分以内で稼働させることができます。デプロイスクリプトは設定、認証情報の生成、サービスの初期化を自動化します。CloudflareのDNSレコードと任意のSSO設定は、短い手動の手順として残ります。

予測可能なエンタープライズコスト

初期セットアップ後は、基本インフラ以外にクライアントごとのホスティングコストは発生しません。シートごと、ワークフローごと、またはAPIコールごとに課金するSaaSソリューションとは異なり、サーバーに定額を支払い、そのリソースが許す数だけ、フルエンタープライズ機能を備えたクライアント環境を運用できます。

プロフェッショナルなブランドの一貫性

各クライアントは、プロフェッショナルなサブドメイン（workflows.client.com、auth.client.comなど）を持つ独自のブランドドメインを取得し、環境を完全にカスタマイズできます。ブランドアイデンティティを希薄化する「Powered by」フッターや共有インターフェースはありません。

n8n統合：大規模なエンタープライズワークフロー自動化

ここからが真に強力な部分です。n8nをセルフホストしてワークフロー自動化を実現する方法をご紹介してきましたが、このマルチテナントセットアップにより、各クライアントが完全なエンタープライズスタックと統合された独自のn8nインスタンスを持つことができます。

各クライアントは以下のような高度なワークフローを構築できます。

  • 独自のデータベース（NocoDB、Supabase PostgreSQL）への接続
  • 独自のAIモデル（Ollama）を使用したインテリジェントな自動化
  • エンタープライズSSO（Authentik）による認証
  • 特定のビジネスツールやAPIとの統合
  • 専用の分離された環境内でのデータ処理

この組み合わせにより、以下を実現する強力なクライアント向けのサービス提供基盤が生まれます。

  • 標準化された自動化機能の迅速なデプロイ
  • 他のクライアントに影響を与えないクライアントごとのワークフローカスタマイズ
  • コストの線形増加なしにサービス提供の規模を拡大
  • 各クライアントの完全なデータ主権の維持
  • セキュリティとコンプライアンスへの取り組みの基盤となるSSOベースのアクセス制御の提供

このアプローチは、WindmillのDockerセットアップガイドで使用したのと同じ原則に基づいていますが、完全なマルチテナントアーキテクチャに拡張しています。

高度な設定オプション

AuthentikによるエンタープライズSSOの実装

Authentikのフォワード認証を設定して、すべてのクライアントサービスにわたるシングルサインオンを有効にします。

# Add to the authentik-server labels in docker-compose.yml
- "traefik.http.middlewares.auth-global.forwardauth.address=http://authentik-server:9000/outpost.goauthentik.io/auth/traefik"
- "traefik.http.middlewares.auth-global.forwardauth.trustForwardHeader=true"
- "traefik.http.middlewares.auth-global.forwardauth.authResponseHeaders=X-authentik-username,X-authentik-groups,X-authentik-email,X-authentik-name,X-authentik-uid"

次に、ミドルウェアを使用するようにサービスのラベルを更新します。

labels:
  - "traefik.http.routers.n8n.middlewares=auth-global"
  - "traefik.http.routers.nocodb.middlewares=auth-global"
  - "traefik.http.routers.supabase-studio.middlewares=auth-global"

高度なAI向けのベクトルデータベースの追加

QdrantベクトルデータベースでAI機能を強化：

qdrant:
  image: qdrant/qdrant:v1.18.3
  container_name: ${TENANT_PREFIX}-qdrant
  environment:
    QDRANT__SERVICE__HTTP_PORT: 6333
    QDRANT__SERVICE__GRPC_PORT: 6334
  volumes:
    - qdrant_data:/qdrant/storage
  networks:
    - tenant
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.qdrant.rule=Host(`vector.${CLIENT_DOMAIN}`)"
    - "traefik.http.routers.qdrant.tls.certresolver=letsencrypt"
    - "traefik.http.services.qdrant.loadbalancer.server.port=6333"
    - "traefik.http.routers.qdrant.middlewares=${AUTH_MIDDLEWARE}"
# Also add qdrant_data: under the top-level volumes:

ハイブリッドAIアーキテクチャの実装

最適なパフォーマンスのために、コンテナ化されたAIとネイティブAIを組み合わせたハイブリッドアプローチを検討してください。

# Install Ollama natively on host for GPU acceleration
brew install ollama

# Configure containers to use native Ollama
# In docker-compose.yml, services can access via host.docker.internal:11434
n8n:
  environment:
    - OLLAMA_HOST=host.docker.internal:11434

macOSでは、Docker Desktopがコンテナ内のGPUをサポートしない一方、ネイティブで動作するOllamaはGPUアクセラレーションを直接利用するため、この違いが重要です。私たちの構成では、他のサービスをコンテナで動かしたまま、約5〜6倍のパフォーマンス向上が得られました。

モニタリングと可観測性スタック

クライアントごとに包括的なモニタリングを追加します。

prometheus:
  image: prom/prometheus:v3.13.1
  container_name: ${TENANT_PREFIX}-prometheus
  volumes:
    - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
    - prometheus_data:/prometheus
  networks:
    - tenant
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.prometheus.rule=Host(`metrics.${CLIENT_DOMAIN}`)"
    - "traefik.http.routers.prometheus.tls.certresolver=letsencrypt"
    - "traefik.http.routers.prometheus.middlewares=${AUTH_MIDDLEWARE}"

grafana:
  image: grafana/grafana:13.1.1
  container_name: ${TENANT_PREFIX}-grafana
  environment:
    GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD}
    GF_USERS_ALLOW_SIGN_UP: "false"
  volumes:
    - grafana_data:/var/lib/grafana
    - ./monitoring/dashboards:/var/lib/grafana/dashboards
  networks:
    - tenant
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.grafana.rule=Host(`monitoring.${CLIENT_DOMAIN}`)"
    - "traefik.http.routers.grafana.tls.certresolver=letsencrypt"
    - "traefik.http.routers.grafana.middlewares=${AUTH_MIDDLEWARE}"
# Also add prometheus_data: and grafana_data: under the top-level volumes:

よくある問題と解決策

「Service Unavailable」またはHTTP 502エラー

通常、Traefikがターゲットコンテナに到達できないことを意味します。以下を確認してください。

# Verify container is running and healthy
docker compose ps
docker compose logs traefik --tail=20

# Check container is on correct network
docker network ls
docker network inspect ${CLIENT_PREFIX}-network

# Verify Traefik labels are correct
docker compose config --services

DNS解決の問題

ワイルドカードDNSの設定は、サブドメインルーティングにとって非常に重要です。

# Correct Cloudflare DNS configuration
*.client-a.com CNAME tunnel-uuid.cfargotunnel.com
*.client-b.org CNAME tunnel-uuid2.cfargotunnel.com

# Test DNS resolution
nslookup workflows.client-a.com
dig workflows.client-a.com

複数クライアント間でのリソース枯渇

すべてのクライアント環境のリソース使用状況を監視します。

# Check overall system resource usage
docker stats --no-stream
htop

# Check disk usage per client
du -sh deployments/*/
df -h

# Monitor container memory usage
docker stats --no-stream --format "table {{.Name}}\t{{.MemUsage}}"

データベースコネクションプールの枯渇

多数のクライアントがいる場合、PostgreSQLのコネクション制限に達する可能性があります。デプロイごとに設定してください。

# Connect to client database
docker compose exec postgres psql -U postgres

-- Increase connection limit
ALTER SYSTEM SET max_connections = 300;
ALTER SYSTEM SET shared_buffers = '256MB';
ALTER SYSTEM SET effective_cache_size = '1GB';

-- Apply: effective_cache_size reloads, max_connections and shared_buffers need a restart
SELECT pg_reload_conf();
\q

# Restart PostgreSQL
docker compose restart postgres

Authentik SSO設定の問題

よくあるSSO設定の問題と解決策：

# Check Authentik containers are running
docker compose ps | grep authentik

# Verify database initialization
docker compose exec postgres psql -U postgres -d authentik -c "\dt"

# Check Authentik logs for startup issues
docker compose logs authentik-server --tail=50

# Get a recovery link to log in as admin if needed
docker compose exec authentik-worker ak create_recovery_key 10 akadmin

Cloudflareトンネル接続の問題

トンネル接続の問題をデバッグします。

# Check tunnel status
docker compose logs cloudflare-tunnel --tail=20

# Verify tunnel configuration in Cloudflare dashboard
# Ensure wildcard routing: *.client-domain.com

# Test tunnel connectivity
curl -I https://test.client-domain.com

インフラの考慮事項

複数クライアント向けインフラのサイジング

フル16コンテナスタックで10〜15クライアントを同時に処理する一般的なセットアップの場合：

最小要件：

  • CPU：16〜24コア（アクティブなクライアント環境あたり2コア）
  • RAM：64〜128GB（AI使用状況に応じてクライアントあたり4〜8GB）
  • ストレージ：2TB以上のNVMe SSD（データベース、AIモデル、ログは時間とともに増大）
  • ネットワーク：応答性の高いクライアントアクセスのためのギガビット接続

本番環境の推奨事項：

  • サーバー：Hetzner CCX62または同等品（48 vCPU、192GB RAM）
  • ストレージ：自動バックアップシステム付き4TB NVMe
  • ネットワーク：複数の冗長接続
  • モニタリング：アラート付き完全な可観測性スタック

マルチクライアント環境のバックアップ戦略

クライアントごとの自動バックアップを実装します。

#!/bin/bash
# backup-all-clients.sh - Comprehensive backup solution
set -euo pipefail
umask 077

BACKUP_DIR="/opt/backups"
BACKUP_DATE=$(date +%Y%m%d_%H%M%S)
# Path to development-stack/deployments
DEPLOYMENTS_DIR="/opt/development-stack/deployments"
mkdir -p "$BACKUP_DIR"

for client_dir in "$DEPLOYMENTS_DIR"/*/; do
    CLIENT_DOMAIN=$(basename "$client_dir")
    # Volume names start with the compose project name (TENANT_PREFIX in .env)
    PROJECT=$(grep '^COMPOSE_PROJECT_NAME=' "$client_dir/.env" | cut -d= -f2)
    echo "📦 Backing up client: $CLIENT_DOMAIN"

    # Subshell: the cd applies to this client only; set -e stops the script on any failure
    (
        cd "$client_dir"

        # Backup databases with compression
        docker compose exec -T postgres pg_dumpall -U postgres | gzip > "${BACKUP_DIR}/${CLIENT_DOMAIN}_db_${BACKUP_DATE}.sql.gz"

        # Backup persistent volumes
        docker run --rm \
            -v "${BACKUP_DIR}":/backup \
            -v "${PROJECT}_n8n_data":/data/n8n:ro \
            -v "${PROJECT}_nocodb_data":/data/nocodb:ro \
            -v "${PROJECT}_ollama_data":/data/ollama:ro \
            alpine:3.22 tar czf "/backup/${CLIENT_DOMAIN}_volumes_${BACKUP_DATE}.tar.gz" -C /data .

        # Backup configuration files
        tar czf "${BACKUP_DIR}/${CLIENT_DOMAIN}_config_${BACKUP_DATE}.tar.gz" \
            docker-compose.yml .env traefik/ supabase/ authentik/ init/
    )

    echo "✅ Backup completed for $CLIENT_DOMAIN"
done

# Cleanup old backups (keep 30 days)
find "$BACKUP_DIR" -name "*.gz" -mtime +30 -delete

# Optional: Upload to cloud storage
# rclone sync "$BACKUP_DIR" s3:backup-bucket/multi-tenant/

本番環境向けセキュリティ強化

包括的なセキュリティベストプラクティスを実装します。

# Enhanced Traefik security configuration
traefik:
  command:
    - "--api.dashboard=true"
    - "--ping=true"
    - "--log.level=WARN"
    - "--accesslog=true"
    - "--providers.docker=true"
    - "--providers.docker.network=${TENANT_NETWORK}"
    - "--providers.docker.exposedbydefault=false"
    - "--providers.docker.constraints=Label(`com.docker.compose.project`,`${TENANT_PREFIX}`)"
    - "--entrypoints.web.address=:80"
    - "--entrypoints.websecure.address=:443"
    - "--entrypoints.websecure.asdefault=true"
    - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
    - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
    - "--entrypoints.traefik.address=:8080"
    - "--certificatesresolvers.letsencrypt.acme.email=${ADMIN_EMAIL}"
    - "--certificatesresolvers.letsencrypt.acme.storage=/acme.json"
    - "--certificatesresolvers.letsencrypt.acme.dnschallenge.provider=cloudflare"
  labels:
    # Security headers middleware
    - "traefik.http.middlewares.security.headers.customRequestHeaders.X-Forwarded-Proto=https"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.X-Frame-Options=DENY"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.X-Content-Type-Options=nosniff"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.Strict-Transport-Security=max-age=31536000"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.Content-Security-Policy=default-src 'self'"

    # Rate limiting middleware
    - "traefik.http.middlewares.ratelimit.ratelimit.burst=100"
    - "traefik.http.middlewares.ratelimit.ratelimit.average=50"

セキュリティミドルウェアをすべてのクライアントサービスに適用します。

labels:
  # Without SSO
  - "traefik.http.routers.n8n.middlewares=security,ratelimit"
  # With SSO enabled (AUTH_MIDDLEWARE=auth-global)
  # - "traefik.http.routers.n8n.middlewares=security,ratelimit,auth-global"

コスト分析：重要な数字

従来のSaaSコスト（フル機能セットの10エンタープライズクライアント）

クライアントあたりの月額コスト：

  • n8n Pro：$50/月/クライアント = $500/月
  • Supabase Pro：$25/月/クライアント = $250/月
  • ノーコードプラットフォーム（Airtable）：$20/月/クライアント = $200/月
  • エンタープライズSSO（Auth0）：$23/月/クライアント = $230/月
  • AI APIコスト（OpenAI）：$50/月/クライアント = $500/月
  • 合計：$1,680/月 = $20,160/年

セルフホストマルチテナントエンタープライズスタックのコスト

年間インフラコスト：

  • 専用vCPUを備えたクラウドサーバー（Hetzner CCX62）：$350/月 = $4,200/年
  • ドメインコスト（10クライアント）：$120/年
  • Cloudflare Pro（オプション）：$240/年
  • 合計：$4,560/年

年間節約額：$15,600（77%のコスト削減）

これらの数値は、2025年8月の元のガイドに基づいています。2026年10月時点で、Auth0のB2C Essentialsプランは月額$35からとなり、HetznerはCCX62を掲載していません。後継のCCX63は48 vCPU、192 GBで、掲載価格はVAT別で、プライマリIPv4アドレス1個を含めて月額€853.99です。判断する前に、最新の価格で両方を再計算してください。

さらに以下が得られます。

  • 完全なデータ主権とプライバシー
  • 無制限のカスタマイズとホワイトラベリング
  • ベンダーロックインやSaaSプランによるレート制限なし
  • 自ら管理するセキュリティとコンプライアンスの制御
  • リセラーサービスの提供能力
  • アップデートと機能の完全なコントロール

このセットアップが通常SaaSサブスクリプションでははるかに高額になるエンタープライズ機能を提供することを考えると、特に強力です。n8nのセルフホスティング分析で実証したコストメリットと同様のコンセプトです。

設定作業から運用判断へ

重要なのは、プラットフォームを設定できるかだけではありません。チームが責任分担を説明し、設定のずれを検出し、場当たり的な対応なしに復旧し、変更が狙った成果を改善したと示せるかです。そのため、各設定に責任者、ベースライン、ロールバック手順、結果の検証期間を結び付けます。これにより、単発の修正が運用能力になります。本番の記録には、変更理由、確認した証拠、正確な対象範囲、停止や取り消しの権限を持つ担当者を含めます。リリース後は合意した指標をベースラインと比較し、結果を変更記録とともに保存します。期待した改善がなければ、ロールバックも失敗ではなく妥当な結果です。この規律は個々の設定値より重要です。同じ記録が次の担当者に信頼できる出発点を与え、その後の最適化を推測ではなく測定に基づく判断に変えます。

関連記事

関連記事

Dockerでマルチテナント開発スタックを構築する：クライアント環境の拡張に対応する完全セットアップガイド

本番Docker向けTraefik v3：HTTPS、プロバイダー保護、可観測性

複数マーケットプレイスのデータパイプライン：地域をまたぐ出品者アカウント管理