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);

// 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))
    })
}

┌─────────────────────────────────────┐
│     단일 데이터베이스                 │
│  ┌──────────┐  ┌──────────┐         │
│  │ 스키마 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 - 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)
}