使用 Go 语言的多租户数据库模式示例

┌─────────────────────────────────────┐
│     单个数据库                   │
│  ┌───────────────────────────────┐  │
│  │  共享模式                   │  │
│  │  - users (tenant_id, ...)    │  │
│  │  - orders (tenant_id, ...)   │  │
│  │  - products (tenant_id, ...) │  │
│  └───────────────────────────────┘  │
└─────────────────────────────────────┘

-- 包含 tenant_id 的用户表
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);

// Go 中使用 GORM 的示例
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))
    })
}

┌─────────────────────────────────────┐
│     单个数据库                   │
│  ┌──────────┐  ┌──────────┐         │
│  │ 模式 A   │  │ 模式 B   │  ...    │
│  │ (租户1)  │  │ (租户2)  │         │
│  └──────────┘  └──────────┘         │
└─────────────────────────────────────┘

-- 为租户创建模式
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

┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│  数据库 1    │  │  数据库 2    │  │  数据库 3    │
│  (租户 A)    │  │  (租户 B)    │  │  (租户 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 - 缺少租户过滤
db.Where("email = ?", email).First(&user)

// ✅ GOOD - 始终包含租户过滤
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)
}