Go での例を含むマルチテナントデータベースパターン

┌─────────────────────────────────────┐
│     Single Database                 │
│  ┌───────────────────────────────┐  │
│  │  Shared Schema                │  │
│  │  - users (tenant_id, ...)     │  │
│  │  - orders (tenant_id, ...)    │  │
│  │  - products (tenant_id, ...)  │  │
│  └───────────────────────────────┘  │
└─────────────────────────────────────┘

-- tenant_idを含むusersテーブル
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    tenant_id INTEGER NOT NULL,
    email VARCHAR(255) NOT NULL,
    name VARCHAR(255),
    created_at TIMESTAMP DEFAULT NOW(),
    FOREIGN KEY (tenant_id) REFERENCES tenants(id)
);

-- パフォーマンス向上のためtenant_idにインデックスを設定
CREATE INDEX idx_users_tenant_id ON users(tenant_id);

-- 行レベルセキュリティ（PostgreSQLの例）
ALTER TABLE users ENABLE ROW LEVEL SECURITY;

CREATE POLICY tenant_isolation ON users
    FOR ALL
    USING (tenant_id = current_setting('app.current_tenant')::INTEGER);

// GORMを使用したGoでの例
func GetUserByEmail(db *gorm.DB, tenantID uint, email string) (*User, error) {
    var user User
    err := db.Where("tenant_id = ? AND email = ?", tenantID, email).First(&user).Error
    return &user, err
}

// テナントコンテキストを設定するミドルウェア
func TenantMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tenantID := extractTenantID(r) // サブドメイン、ヘッダー、JWTから取得
        ctx := context.WithValue(r.Context(), "tenant_id", tenantID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

┌─────────────────────────────────────┐
│     Single Database                 │
│  ┌──────────┐  ┌──────────┐         │
│  │ Schema A │  │ Schema B │  ...    │
│  │ (Tenant1)│  │ (Tenant2)│         │
│  └──────────┘  └──────────┘         │
└─────────────────────────────────────┘

-- テナント用のスキーマを作成
CREATE SCHEMA tenant_123;

-- テナント操作用の検索パスを設定
SET search_path TO tenant_123, public;

-- テナントスキーマ内にテーブルを作成
CREATE TABLE tenant_123.users (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255) NOT NULL,
    name VARCHAR(255),
    created_at TIMESTAMP DEFAULT NOW()
);

// スキーマ検索パス付きの接続文字列
func GetTenantDB(tenantID uint) *gorm.DB {
    db := initializeDB()
    db.Exec(fmt.Sprintf("SET search_path TO tenant_%d, public", tenantID))
    return db
}

// またはPostgreSQL接続文字列を使用
// postgresql://user:pass@host/db?search_path=tenant_123

┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│  Database 1  │  │  Database 2  │  │  Database 3  │
│  (Tenant A)  │  │  (Tenant B)  │  │  (Tenant C)  │
└──────────────┘  └──────────────┘  └──────────────┘

-- テナント用のデータベースを作成
CREATE DATABASE tenant_enterprise_corp;

-- テナントデータベースに接続
\c tenant_enterprise_corp

-- テーブルを作成（tenant_idは不要！）
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255) NOT NULL,
    name VARCHAR(255),
    created_at TIMESTAMP DEFAULT NOW()
);

// 接続プールマネージャ
type TenantDBManager struct {
    pools map[uint]*gorm.DB
    mu    sync.RWMutex
}

func (m *TenantDBManager) GetDB(tenantID uint) (*gorm.DB, error) {
    m.mu.RLock()
    if db, exists := m.pools[tenantID]; exists {
        m.mu.RUnlock()
        return db, nil
    }
    m.mu.RUnlock()

    m.mu.Lock()
    defer m.mu.Unlock()

    // ライターロックを取得した後に再度確認
    if db, exists := m.pools[tenantID]; exists {
        return db, nil
    }

    // 新しい接続を作成
    db, err := gorm.Open(postgres.Open(fmt.Sprintf(
        "host=localhost user=dbuser password=dbpass dbname=tenant_%d sslmode=disable",
        tenantID,
    )), &gorm.Config{})
    
    if err != nil {
        return nil, err
    }

    m.pools[tenantID] = db
    return db, nil
}

-- RLSを有効にする
ALTER TABLE orders ENABLE ROW LEVEL SECURITY;

-- テナントごとの分離ポリシーを作成
CREATE POLICY tenant_isolation ON orders
    FOR ALL
    USING (tenant_id = current_setting('app.current_tenant')::INTEGER);

-- アプリケーションでテナントコンテキストを設定
SET app.current_tenant = '123';

// ❌ BAD - tenantフィルタが欠如
db.Where("email = ?", email).First(&user)

// ✅ GOOD - tenantフィルタを常に含める
db.Where("tenant_id = ? AND email = ?", tenantID, email).First(&user)

// ✅ BETTER - スコープやミドルウェアを使用
db.Scopes(TenantScope(tenantID)).Where("email = ?", email).First(&user)

// PgBouncerを使用したトランザクションプール
// またはアプリケーションレベルの接続ルーティングを使用

type AuditLog struct {
    ID        uint
    TenantID  uint
    UserID    uint
    Action    string
    Table     string
    RecordID  uint
    Timestamp time.Time
    IPAddress string
}

-- テナントクエリ用の複合インデックス
CREATE INDEX idx_orders_tenant_created ON orders(tenant_id, created_at DESC);
CREATE INDEX idx_orders_tenant_status ON orders(tenant_id, status);

-- 一般的なテナント固有クエリ用の部分インデックス
CREATE INDEX idx_orders_active_tenant ON orders(tenant_id, created_at)
WHERE status = 'active';

// テナントクエリ用に準備されたステートメントを使用
stmt := db.Prepare("SELECT * FROM users WHERE tenant_id = $1 AND email = $2")

// テナントごとにバッチ操作
db.Where("tenant_id = ?", tenantID).Find(&users)

// 個別データベースパターン用にテナントごとの接続プールを使用

// マイグレーションはすべてのテナントに自動的に適用
func Migrate(db *gorm.DB) error {
    return db.AutoMigrate(&User{}, &Order{}, &Product{})
}

// テナントごとにマイグレーションを実行
func MigrateAllTenants(tenantIDs []uint) error {
    for _, tenantID := range tenantIDs {
        db := GetTenantDB(tenantID)
        if err := db.AutoMigrate(&User{}, &Order{}); err != nil {
            return fmt.Errorf("tenant %d: %w", tenantID, err)
        }
    }
    return nil
}

// 小規模テナント：共有スキーマ
if tenant.Tier == "standard" {
    return GetSharedDB(tenant.ID)
}

// エンタープライズテナント：個別データベース
if tenant.Tier == "enterprise" {
    return GetTenantDB(tenant.ID)
}