🎯 멀티테넌트 아키텍처란 뭔데?

멀티테넌트(Multi-tenant) 아키텍처는 하나의 애플리케이션 인스턴스로 여러 고객(테넌트)을 동시에 서비스하는 구조를 말해요. 쉽게 말하면 아파트 한 동에 여러 세대가 사는 것처럼, 하나의 시스템에서 여러 회사나 조직이 각자의 데이터를 독립적으로 관리하는 거죠! 🏢

전통적인 방식은 고객마다 별도의 서버와 애플리케이션을 설치했는데, 이건 비용도 많이 들고 유지보수도 헬이었어요 ㅠㅠ 멀티테넌트는 이런 문제를 완전 해결해주는 솔루션이에요.

🏗️ 멀티테넌트 데이터 격리 전략

멀티테넌트 시스템에서 가장 중요한 건 바로 데이터 격리예요. 각 테넌트의 데이터가 섞이면 안 되니까요! PHP에서 구현할 수 있는 세 가지 주요 전략을 알아볼게요. 🔐

💻 PHP로 멀티테넌트 구현하기

자, 이제 실전이에요! PHP로 멀티테넌트 시스템을 어떻게 구현하는지 코드 레벨에서 살펴볼게요. 여기서는 가장 많이 사용되는 공유 스키마 방식을 기준으로 설명할게요. 🚀

📝 테넌트 식별 클래스 구현

<?php
// TenantResolver.php
class TenantResolver
{
    private static $currentTenant = null;
    
    /**
     * 서브도메인에서 테넌트 식별
     */
    public static function resolveFromSubdomain()
    {
        $host = $_SERVER['HTTP_HOST'] ?? '';
        $parts = explode('.', $host);
        
        if (count($parts) >= 3) {
            $subdomain = $parts[0];
            self::$currentTenant = self::getTenantBySubdomain($subdomain);
        }
        
        return self::$currentTenant;
    }
    
    /**
     * 경로에서 테넌트 식별
     */
    public static function resolveFromPath()
    {
        $uri = $_SERVER['REQUEST_URI'] ?? '';
        $segments = explode('/', trim($uri, '/'));
        
        if (!empty($segments[0])) {
            self::$currentTenant = self::getTenantBySlug($segments[0]);
        }
        
        return self::$currentTenant;
    }
    
    /**
     * 헤더에서 테넌트 식별
     */
    public static function resolveFromHeader()
    {
        $tenantId = $_SERVER['HTTP_X_TENANT_ID'] ?? null;
        
        if ($tenantId) {
            self::$currentTenant = self::getTenantById($tenantId);
        }
        
        return self::$currentTenant;
    }
    
    /**
     * DB에서 테넌트 정보 조회
     */
    private static function getTenantBySubdomain($subdomain)
    {
        // 실제로는 DB 조회 또는 캐시에서 가져옴
        $pdo = Database::getConnection();
        $stmt = $pdo->prepare("SELECT * FROM tenants WHERE subdomain = ?");
        $stmt->execute([$subdomain]);
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }
    
    private static function getTenantBySlug($slug)
    {
        $pdo = Database::getConnection();
        $stmt = $pdo->prepare("SELECT * FROM tenants WHERE slug = ?");
        $stmt->execute([$slug]);
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }
    
    private static function getTenantById($id)
    {
        $pdo = Database::getConnection();
        $stmt = $pdo->prepare("SELECT * FROM tenants WHERE id = ?");
        $stmt->execute([$id]);
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }
    
    /**
     * 현재 테넌트 정보 반환
     */
    public static function getCurrentTenant()
    {
        return self::$currentTenant;
    }
    
    /**
     * 현재 테넌트 ID 반환
     */
    public static function getCurrentTenantId()
    {
        return self::$currentTenant['id'] ?? null;
    }
}

🔒 테넌트 컨텍스트 관리

테넌트를 식별했으면 이제 애플리케이션 전체에서 이 정보를 사용할 수 있어야 해요. 컨텍스트 관리 클래스를 만들어볼게요! 🎯

<?php
// TenantContext.php
class TenantContext
{
    private static $instance = null;
    private $tenant = null;
    private $config = [];
    
    private function __construct() {}
    
    public static function getInstance()
    {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    
    /**
     * 테넌트 설정
     */
    public function setTenant($tenant)
    {
        $this->tenant = $tenant;
        $this->loadTenantConfig();
    }
    
    /**
     * 현재 테넌트 반환
     */
    public function getTenant()
    {
        return $this->tenant;
    }
    
    /**
     * 테넌트 ID 반환
     */
    public function getTenantId()
    {
        return $this->tenant['id'] ?? null;
    }
    
    /**
     * 테넌트별 설정 로드
     */
    private function loadTenantConfig()
    {
        if (!$this->tenant) {
            return;
        }
        
        // 테넌트별 설정을 DB나 파일에서 로드
        $pdo = Database::getConnection();
        $stmt = $pdo->prepare("SELECT * FROM tenant_configs WHERE tenant_id = ?");
        $stmt->execute([$this->tenant['id']]);
        $configs = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        foreach ($configs as $config) {
            $this->config[$config['key']] = $config['value'];
        }
    }
    
    /**
     * 테넌트 설정값 가져오기
     */
    public function getConfig($key, $default = null)
    {
        return $this->config[$key] ?? $default;
    }
    
    /**
     * 테넌트 설정값 저장
     */
    public function setConfig($key, $value)
    {
        $this->config[$key] = $value;
        
        // DB에도 저장
        $pdo = Database::getConnection();
        $stmt = $pdo->prepare("
            INSERT INTO tenant_configs (tenant_id, `key`, value) 
            VALUES (?, ?, ?)
            ON DUPLICATE KEY UPDATE value = ?
        ");
        $stmt->execute([
            $this->tenant['id'],
            $key,
            $value,
            $value
        ]);
    }
    
    /**
     * 테넌트가 특정 기능을 사용할 수 있는지 확인
     */
    public function hasFeature($feature)
    {
        $plan = $this->tenant['plan'] ?? 'free';
        $features = $this->getFeaturesByPlan($plan);
        return in_array($feature, $features);
    }
    
    private function getFeaturesByPlan($plan)
    {
        $planFeatures = [
            'free' => ['basic_features'],
            'starter' => ['basic_features', 'advanced_reports'],
            'professional' => ['basic_features', 'advanced_reports', 'api_access'],
            'enterprise' => ['basic_features', 'advanced_reports', 'api_access', 'custom_branding', 'priority_support']
        ];
        
        return $planFeatures[$plan] ?? [];
    }
}

🗃️ 데이터베이스 쿼리 자동화

공유 스키마 방식에서 가장 중요한 건 모든 쿼리에 tenant_id 조건을 자동으로 추가하는 거예요. 실수로 빼먹으면 다른 테넌트 데이터가 노출될 수 있거든요! 😱

이걸 자동화하는 방법을 알아볼게요.

<?php
// TenantAwareModel.php
abstract class TenantAwareModel
{
    protected $table;
    protected $pdo;
    
    public function __construct()
    {
        $this->pdo = Database::getConnection();
    }
    
    /**
     * 테넌트 ID를 자동으로 포함한 SELECT 쿼리
     */
    public function find($id)
    {
        $tenantId = TenantContext::getInstance()->getTenantId();
        
        $stmt = $this->pdo->prepare("
            SELECT * FROM {$this->table} 
            WHERE id = ? AND tenant_id = ?
        ");
        $stmt->execute([$id, $tenantId]);
        
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }
    
    /**
     * 테넌트의 모든 레코드 조회
     */
    public function all($conditions = [])
    {
        $tenantId = TenantContext::getInstance()->getTenantId();
        
        $where = ["tenant_id = ?"];
        $params = [$tenantId];
        
        foreach ($conditions as $key => $value) {
            $where[] = "{$key} = ?";
            $params[] = $value;
        }
        
        $whereClause = implode(' AND ', $where);
        
        $stmt = $this->pdo->prepare("
            SELECT * FROM {$this->table} 
            WHERE {$whereClause}
        ");
        $stmt->execute($params);
        
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }
    
    /**
     * 데이터 생성 (tenant_id 자동 추가)
     */
    public function create($data)
    {
        $tenantId = TenantContext::getInstance()->getTenantId();
        $data['tenant_id'] = $tenantId;
        $data['created_at'] = date('Y-m-d H:i:s');
        
        $columns = array_keys($data);
        $placeholders = array_fill(0, count($data), '?');
        
        $sql = sprintf(
            "INSERT INTO {$this->table} (%s) VALUES (%s)",
            implode(', ', $columns),
            implode(', ', $placeholders)
        );
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(array_values($data));
        
        return $this->pdo->lastInsertId();
    }
    
    /**
     * 데이터 업데이트 (tenant_id 검증)
     */
    public function update($id, $data)
    {
        $tenantId = TenantContext::getInstance()->getTenantId();
        $data['updated_at'] = date('Y-m-d H:i:s');
        
        $setParts = [];
        $params = [];
        
        foreach ($data as $key => $value) {
            $setParts[] = "{$key} = ?";
            $params[] = $value;
        }
        
        $params[] = $id;
        $params[] = $tenantId;
        
        $sql = sprintf(
            "UPDATE {$this->table} SET %s WHERE id = ? AND tenant_id = ?",
            implode(', ', $setParts)
        );
        
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute($params);
    }
    
    /**
     * 데이터 삭제 (tenant_id 검증)
     */
    public function delete($id)
    {
        $tenantId = TenantContext::getInstance()->getTenantId();
        
        $stmt = $this->pdo->prepare("
            DELETE FROM {$this->table} 
            WHERE id = ? AND tenant_id = ?
        ");
        
        return $stmt->execute([$id, $tenantId]);
    }
    
    /**
     * 소프트 삭제
     */
    public function softDelete($id)
    {
        return $this->update($id, ['deleted_at' => date('Y-m-d H:i:s')]);
    }
}

// 사용 예시
class User extends TenantAwareModel
{
    protected $table = 'users';
    
    public function findByEmail($email)
    {
        $tenantId = TenantContext::getInstance()->getTenantId();
        
        $stmt = $this->pdo->prepare("
            SELECT * FROM {$this->table} 
            WHERE email = ? AND tenant_id = ?
        ");
        $stmt->execute([$email, $tenantId]);
        
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }
}

🎨 Laravel을 활용한 멀티테넌트 구현

순수 PHP도 좋지만, 라라벨(Laravel) 프레임워크를 사용하면 멀티테넌트 구현이 훨씬 쉬워져요! ㅋㅋㅋ 라라벨의 강력한 기능들을 활용한 방법을 알아볼게요. 🚀

🔧 Global Scope 활용

라라벨의 Global Scope를 사용하면 모든 쿼리에 자동으로 tenant_id 조건을 추가할 수 있어요!

<?php
// app/Scopes/TenantScope.php
namespace App\Scopes;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;

class TenantScope implements Scope
{
    public function apply(Builder $builder, Model $model)
    {
        if ($tenantId = tenant_id()) {
            $builder->where('tenant_id', $tenantId);
        }
    }
}

// app/Models/TenantAwareModel.php
namespace App\Models;

use App\Scopes\TenantScope;
use Illuminate\Database\Eloquent\Model;

abstract class TenantAwareModel extends Model
{
    protected static function booted()
    {
        static::addGlobalScope(new TenantScope());
        
        // 생성 시 자동으로 tenant_id 추가
        static::creating(function ($model) {
            if (!$model->tenant_id) {
                $model->tenant_id = tenant_id();
            }
        });
    }
}

// app/Models/User.php
namespace App\Models;

class User extends TenantAwareModel
{
    protected $fillable = ['name', 'email', 'password'];
    
    // 이제 User::all()을 하면 자동으로 현재 테넌트의 사용자만 조회됨!
}

// helpers.php
function tenant_id()
{
    return app('tenant')->id ?? null;
}

function tenant()
{
    return app('tenant');
}

🎯 미들웨어로 테넌트 식별

<?php
// app/Http/Middleware/IdentifyTenant.php
namespace App\Http\Middleware;

use Closure;
use App\Models\Tenant;
use Illuminate\Http\Request;

class IdentifyTenant
{
    public function handle(Request $request, Closure $next)
    {
        $tenant = $this->resolveTenant($request);
        
        if (!$tenant) {
            abort(404, 'Tenant not found');
        }
        
        // 테넌트를 서비스 컨테이너에 바인딩
        app()->instance('tenant', $tenant);
        
        // 뷰에서도 사용할 수 있도록
        view()->share('tenant', $tenant);
        
        return $next($request);
    }
    
    private function resolveTenant(Request $request)
    {
        // 서브도메인에서 식별
        $host = $request->getHost();
        $subdomain = explode('.', $host)[0];
        
        return Tenant::where('subdomain', $subdomain)
            ->where('status', 'active')
            ->first();
    }
}

// app/Http/Kernel.php에 등록
protected $middlewareGroups = [
    'web' => [
        // ... 다른 미들웨어들
        \App\Http\Middleware\IdentifyTenant::class,
    ],
];

💾 데이터베이스 마이그레이션 전략

멀티테넌트 환경에서 DB 스키마 변경은 조심스러운 작업이에요. 모든 테넌트에 영향을 주니까요! 안전한 마이그레이션 전략을 알아볼게요. 🛡️

<?php
// 라라벨 마이그레이션 예시
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateUsersTable extends Migration
{
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('tenant_id');
            $table->string('name');
            $table->string('email');
            $table->string('password');
            $table->string('phone')->nullable();
            $table->enum('status', ['active', 'inactive', 'suspended'])->default('active');
            $table->timestamps();
            $table->softDeletes();
            
            // 인덱스
            $table->index(['tenant_id', 'id']);
            $table->index(['tenant_id', 'email']);
            $table->unique(['tenant_id', 'email']); // 테넌트 내에서 이메일 중복 방지
            
            // 외래키
            $table->foreign('tenant_id')
                  ->references('id')
                  ->on('tenants')
                  ->onDelete('cascade');
        });
    }
    
    public function down()
    {
        Schema::dropIfExists('users');
    }
}

🔐 보안 고려사항

멀티테넌트 시스템에서 보안은 정말정말 중요해요! 한 테넌트의 데이터가 다른 테넌트에게 노출되면 완전 대형사고죠 ㅠㅠ 반드시 체크해야 할 보안 포인트들을 정리해볼게요. 🛡️

<?php
// 보안 검증 미들웨어
class ValidateTenantAccess
{
    public function handle($request, Closure $next)
    {
        $currentTenantId = tenant_id();
        
        // URL에서 리소스 ID 추출
        $resourceId = $request->route('id');
        
        if ($resourceId) {
            // 해당 리소스가 현재 테넌트 소유인지 확인
            $resource = $this->getResource($request, $resourceId);
            
            if (!$resource || $resource->tenant_id !== $currentTenantId) {
                // 보안 로그 기록
                Log::warning('Cross-tenant access attempt', [
                    'tenant_id' => $currentTenantId,
                    'resource_id' => $resourceId,
                    'ip' => $request->ip(),
                    'user_id' => auth()->id()
                ]);
                
                abort(403, 'Access denied');
            }
        }
        
        return $next($request);
    }
    
    private function getResource($request, $id)
    {
        $routeName = $request->route()->getName();
        
        // 라우트 이름에 따라 적절한 모델 조회
        if (str_contains($routeName, 'users')) {
            return User::find($id);
        } elseif (str_contains($routeName, 'posts')) {
            return Post::find($id);
        }
        
        return null;
    }
}

⚡ 성능 최적화 전략

멀티테넌트 시스템은 많은 사용자가 동시에 사용하기 때문에 성능 최적화가 필수예요! 실전에서 바로 써먹을 수 있는 최적화 팁들을 공유할게요. 🚀

<?php
class TenantCache
{
    private $redis;
    
    public function __construct()
    {
        $this->redis = new Redis();
        $this->redis->connect('127.0.0.1', 6379);
    }
    
    /**
     * 테넌트별 캐시 키 생성
     */
    private function makeKey($key)
    {
        $tenantId = tenant_id();
        return "tenant:{$tenantId}:{$key}";
    }
    
    /**
     * 캐시 저장
     */
    public function set($key, $value, $ttl = 3600)
    {
        $cacheKey = $this->makeKey($key);
        return $this->redis->setex($cacheKey, $ttl, serialize($value));
    }
    
    /**
     * 캐시 조회
     */
    public function get($key, $default = null)
    {
        $cacheKey = $this->makeKey($key);
        $value = $this->redis->get($cacheKey);
        
        return $value !== false ? unserialize($value) : $default;
    }
    
    /**
     * 캐시 삭제
     */
    public function delete($key)
    {
        $cacheKey = $this->makeKey($key);
        return $this->redis->del($cacheKey);
    }
    
    /**
     * 테넌트의 모든 캐시 삭제
     */
    public function flushTenant()
    {
        $tenantId = tenant_id();
        $pattern = "tenant:{$tenantId}:*";
        
        $keys = $this->redis->keys($pattern);
        if (!empty($keys)) {
            $this->redis->del($keys);
        }
    }
    
    /**
     * 캐시 또는 DB에서 조회 (캐시 미스 시 DB 조회 후 캐싱)
     */
    public function remember($key, $ttl, $callback)
    {
        $value = $this->get($key);
        
        if ($value !== null) {
            return $value;
        }
        
        $value = $callback();
        $this->set($key, $value, $ttl);
        
        return $value;
    }
}

// 사용 예시
$cache = new TenantCache();

// 사용자 정보 캐싱
$user = $cache->remember("user:{$userId}", 3600, function() use ($userId) {
    return User::find($userId);
});

// 대시보드 통계 캐싱
$stats = $cache->remember('dashboard:stats', 300, function() {
    return [
        'total_users' => User::count(),
        'active_users' => User::where('status', 'active')->count(),
        'total_revenue' => Order::sum('amount')
    ];
});

📦 파일 저장소 관리

멀티테넌트 환경에서 파일 관리도 중요한 이슈예요! 각 테넌트의 파일을 안전하게 분리하고 효율적으로 관리하는 방법을 알아볼게요. 📁

<?php
class TenantFileStorage
{
    private $basePath;
    private $s3Client; // AWS S3 사용 시
    
    public function __construct()
    {
        $this->basePath = storage_path('tenants');
    }
    
    /**
     * 테넌트별 저장 경로 생성
     */
    private function getTenantPath($path = '')
    {
        $tenantId = tenant_id();
        $tenantPath = "{$this->basePath}/{$tenantId}";
        
        if (!is_dir($tenantPath)) {
            mkdir($tenantPath, 0755, true);
        }
        
        return $path ? "{$tenantPath}/{$path}" : $tenantPath;
    }
    
    /**
     * 파일 업로드
     */
    public function upload($file, $directory = 'uploads')
    {
        $filename = $this->generateUniqueFilename($file);
        $path = "{$directory}/{$filename}";
        $fullPath = $this->getTenantPath($path);
        
        // 디렉토리 생성
        $dir = dirname($fullPath);
        if (!is_dir($dir)) {
            mkdir($dir, 0755, true);
        }
        
        // 파일 이동
        if (move_uploaded_file($file['tmp_name'], $fullPath)) {
            return [
                'success' => true,
                'path' => $path,
                'url' => $this->getUrl($path),
                'size' => filesize($fullPath),
                'mime_type' => mime_content_type($fullPath)
            ];
        }
        
        return ['success' => false, 'error' => 'Upload failed'];
    }
    
    /**
     * 고유한 파일명 생성
     */
    private function generateUniqueFilename($file)
    {
        $extension = pathinfo($file['name'], PATHINFO_EXTENSION);
        return uniqid() . '_' . time() . '.' . $extension;
    }
    
    /**
     * 파일 다운로드
     */
    public function download($path)
    {
        $fullPath = $this->getTenantPath($path);
        
        if (!file_exists($fullPath)) {
            return false;
        }
        
        header('Content-Type: ' . mime_content_type($fullPath));
        header('Content-Disposition: attachment; filename="' . basename($path) . '"');
        header('Content-Length: ' . filesize($fullPath));
        
        readfile($fullPath);
        exit;
    }
    
    /**
     * 파일 삭제
     */
    public function delete($path)
    {
        $fullPath = $this->getTenantPath($path);
        
        if (file_exists($fullPath)) {
            return unlink($fullPath);
        }
        
        return false;
    }
    
    /**
     * 파일 URL 생성
     */
    public function getUrl($path)
    {
        $tenantId = tenant_id();
        return url("/storage/tenants/{$tenantId}/{$path}");
    }
    
    /**
     * S3에 업로드 (클라우드 스토리지 사용 시)
     */
    public function uploadToS3($file, $directory = 'uploads')
    {
        $tenantId = tenant_id();
        $filename = $this->generateUniqueFilename($file);
        $key = "tenants/{$tenantId}/{$directory}/{$filename}";
        
        try {
            $result = $this->s3Client->putObject([
                'Bucket' => env('AWS_BUCKET'),
                'Key' => $key,
                'SourceFile' => $file['tmp_name'],
                'ACL' => 'private'
            ]);
            
            return [
                'success' => true,
                'url' => $result['ObjectURL'],
                'key' => $key
            ];
        } catch (Exception $e) {
            return ['success' => false, 'error' => $e->getMessage()];
        }
    }
    
    /**
     * 테넌트 스토리지 사용량 계산
     */
    public function getStorageUsage()
    {
        $path = $this->getTenantPath();
        return $this->getDirectorySize($path);
    }
    
    private function getDirectorySize($path)
    {
        $size = 0;
        
        foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path)) as $file) {
            $size += $file->getSize();
        }
        
        return $size;
    }
}

🎨 테넌트별 커스터마이징

SaaS의 큰 장점 중 하나가 각 테넌트가 자기만의 브랜딩을 할 수 있다는 거예요! 로고, 색상, 도메인 등을 커스터마이징하는 방법을 알아볼게요. 🎨

<?php
class TenantCustomization
{
    /**
     * 테넌트 테마 설정 가져오기
     */
    public function getTheme()
    {
        $tenant = tenant();
        
        return [
            'primary_color' => $tenant->primary_color ?? '#667eea',
            'secondary_color' => $tenant->secondary_color ?? '#764ba2',
            'logo_url' => $tenant->logo_url ?? '/default-logo.png',
            'favicon_url' => $tenant->favicon_url ?? '/default-favicon.ico',
            'font_family' => $tenant->font_family ?? 'Inter, sans-serif'
        ];
    }
    
    /**
     * 동적 CSS 생성
     */
    public function generateCSS()
    {
        $theme = $this->getTheme();
        
        $css = "
        :root {
            --primary-color: {$theme['primary_color']};
            --secondary-color: {$theme['secondary_color']};
            --font-family: {$theme['font_family']};
        }
        
        .btn-primary {
            background-color: var(--primary-color);
            border-color: var(--primary-color);
        }
        
        .btn-primary:hover {
            background-color: color-mix(in srgb, var(--primary-color) 80%, black);
        }
        
        .navbar {
            background-color: var(--primary-color);
        }
        
        a {
            color: var(--primary-color);
        }
        
        body {
            font-family: var(--font-family);
        }
        ";
        
        return $css;
    }
    
    /**
     * 테마 설정 업데이트
     */
    public function updateTheme($data)
    {
        $tenant = tenant();
        
        $allowedFields = [
            'primary_color',
            'secondary_color',
            'font_family'
        ];
        
        foreach ($allowedFields as $field) {
            if (isset($data[$field])) {
                $tenant->$field = $data[$field];
            }
        }
        
        $tenant->save();
        
        // 캐시 초기화
        $cache = new TenantCache();
        $cache->delete('theme');
        
        return true;
    }
    
    /**
     * 로고 업로드
     */
    public function uploadLogo($file)
    {
        $storage = new TenantFileStorage();
        $result = $storage->upload($file, 'branding');
        
        if ($result['success']) {
            $tenant = tenant();
            $tenant->logo_url = $result['url'];
            $tenant->save();
            
            return $result;
        }
        
        return false;
    }
    
    /**
     * 이메일 템플릿 커스터마이징
     */
    public function getEmailTemplate($type)
    {
        $tenant = tenant();
        $theme = $this->getTheme();
        
        $templates = [
            'welcome' => [
                'subject' => "Welcome to {$tenant->name}!",
                'header_color' => $theme['primary_color'],
                'logo' => $theme['logo_url'],
                'content' => $tenant->welcome_email_content ?? $this->getDefaultWelcomeContent()
            ],
            'invoice' => [
                'subject' => "Invoice from {$tenant->name}",
                'header_color' => $theme['primary_color'],
                'logo' => $theme['logo_url'],
                'footer' => $tenant->invoice_footer ?? $this->getDefaultInvoiceFooter()
            ]
        ];
        
        return $templates[$type] ?? null;
    }
    
    private function getDefaultWelcomeContent()
    {
        return "Thank you for joining us! We're excited to have you on board.";
    }
    
    private function getDefaultInvoiceFooter()
    {
        $tenant = tenant();
        return "© " . date('Y') . " {$tenant->name}. All rights reserved.";
    }
}

// 뷰에서 사용
// layout.blade.php
<!DOCTYPE html>
<html>
<head>
    <style>
        {{ app(TenantCustomization::class)->generateCSS() }}
    </style>
</head>
<body>
    <nav class="navbar">
        <img src="{{ tenant()->logo_url }}" alt="Logo">
    </nav>
    
    @yield('content')
</body>
</html>

💰 과금 및 플랜 관리

SaaS 비즈니스의 핵심은 바로 과금이죠! ㅋㅋㅋ 테넌트별로 다른 플랜을 제공하고 사용량을 추적하는 시스템을 구축해볼게요. 💳

<?php
class SubscriptionManager
{
    /**
     * 플랜 정의
     */
    private function getPlans()
    {
        return [
            'free' => [
                'name' => 'Free',
                'price' => 0,
                'limits' => [
                    'users' => 3,
                    'storage' => 1024 * 1024 * 1024, // 1GB in bytes
                    'api_calls' => 1000,
                    'projects' => 5
                ],
                'features' => ['basic_features']
            ],
            'starter' => [
                'name' => 'Starter',
                'price' => 29,
                'limits' => [
                    'users' => 10,
                    'storage' => 10 * 1024 * 1024 * 1024, // 10GB
                    'api_calls' => 10000,
                    'projects' => 20
                ],
                'features' => ['basic_features', 'advanced_reports']
            ],
            'professional' => [
                'name' => 'Professional',
                'price' => 99,
                'limits' => [
                    'users' => 50,
                    'storage' => 100 * 1024 * 1024 * 1024, // 100GB
                    'api_calls' => 100000,
                    'projects' => 100
                ],
                'features' => ['basic_features', 'advanced_reports', 'api_access', 'custom_branding']
            ],
            'enterprise' => [
                'name' => 'Enterprise',
                'price' => null, // 맞춤형
                'limits' => [
                    'users' => -1, // 무제한
                    'storage' => -1,
                    'api_calls' => -1,
                    'projects' => -1
                ],
                'features' => ['all_features', 'priority_support', 'dedicated_manager']
            ]
        ];
    }
    
    /**
     * 현재 플랜 정보 가져오기
     */
    public function getCurrentPlan()
    {
        $tenant = tenant();
        $plans = $this->getPlans();
        
        return $plans[$tenant->plan] ?? $plans['free'];
    }
    
    /**
     * 사용량 체크
     */
    public function checkLimit($resource)
    {
        $tenant = tenant();
        $plan = $this->getCurrentPlan();
        $limit = $plan['limits'][$resource] ?? 0;
        
        // 무제한인 경우
        if ($limit === -1) {
            return ['allowed' => true, 'unlimited' => true];
        }
        
        $usage = $this->getUsage($resource);
        
        return [
            'allowed' => $usage < $limit,
            'usage' => $usage,
            'limit' => $limit,
            'percentage' => ($usage / $limit) * 100
        ];
    }
    
    /**
     * 현재 사용량 조회
     */
    private function getUsage($resource)
    {
        $tenantId = tenant_id();
        
        switch ($resource) {
            case 'users':
                return User::where('tenant_id', $tenantId)->count();
                
            case 'storage':
                $storage = new TenantFileStorage();
                return $storage->getStorageUsage();
                
            case 'api_calls':
                // API 호출 로그에서 이번 달 사용량 조회
                return ApiLog::where('tenant_id', $tenantId)
                    ->whereMonth('created_at', date('m'))
                    ->count();
                
            case 'projects':
                return Project::where('tenant_id', $tenantId)->count();
                
            default:
                return 0;
        }
    }
    
    /**
     * 기능 사용 가능 여부 확인
     */
    public function hasFeature($feature)
    {
        $plan = $this->getCurrentPlan();
        
        if (in_array('all_features', $plan['features'])) {
            return true;
        }
        
        return in_array($feature, $plan['features']);
    }
    
    /**
     * 플랜 업그레이드
     */
    public function upgradePlan($newPlan)
    {
        $tenant = tenant();
        $plans = $this->getPlans();
        
        if (!isset($plans[$newPlan])) {
            return ['success' => false, 'error' => 'Invalid plan'];
        }
        
        $oldPlan = $tenant->plan;
        $tenant->plan = $newPlan;
        $tenant->plan_changed_at = now();
        $tenant->save();
        
        // 결제 처리 (Stripe, PayPal 등)
        $this->processPayment($tenant, $plans[$newPlan]['price']);
        
        // 이벤트 로깅
        $this->logPlanChange($tenant, $oldPlan, $newPlan);
        
        return ['success' => true, 'plan' => $newPlan];
    }
    
    /**
     * 결제 처리
     */
    private function processPayment($tenant, $amount)
    {
        // Stripe 결제 예시
        // 실제로는 Stripe SDK를 사용해야 해요
        
        if ($amount > 0) {
            // 결제 로직
            // ...
        }
    }
    
    /**
     * 사용량 경고 알림
     */
    public function checkUsageAlerts()
    {
        $resources = ['users', 'storage', 'api_calls', 'projects'];
        $alerts = [];
        
        foreach ($resources as $resource) {
            $check = $this->checkLimit($resource);
            
            if (!$check['unlimited'] && $check['percentage'] >= 80) {
                $alerts[] = [
                    'resource' => $resource,
                    'usage' => $check['usage'],
                    'limit' => $check['limit'],
                    'percentage' => $check['percentage']
                ];
            }
        }
        
        if (!empty($alerts)) {
            $this->sendUsageAlert($alerts);
        }
        
        return $alerts;
    }
    
    private function sendUsageAlert($alerts)
    {
        // 이메일 또는 알림 발송
        // ...
    }
}

// 미들웨어에서 사용량 체크
class CheckSubscriptionLimits
{
    public function handle($request, Closure $next, $resource)
    {
        $subscription = new SubscriptionManager();
        $check = $subscription->checkLimit($resource);
        
        if (!$check['allowed']) {
            return response()->json([
                'error' => 'Limit exceeded',
                'message' => "You've reached your {$resource} limit. Please upgrade your plan.",
                'usage' => $check['usage'],
                'limit' => $check['limit']
            ], 403);
        }
        
        return $next($request);
    }
}

🔄 테넌트 온보딩 프로세스

새로운 테넌트가 가입할 때 필요한 모든 설정을 자동으로 처리하는 온보딩 시스템을 만들어볼게요! 이게 있으면 고객 경험이 완전 달라져요 ㅋㅋㅋ 🎉

<?php
class TenantOnboarding
{
    /**
     * 새 테넌트 생성 및 초기화
     */
    public function createTenant($data)
    {
        DB::beginTransaction();
        
        try {
            // 1. 테넌트 레코드 생성
            $tenant = $this->createTenantRecord($data);
            
            // 2. 관리자 계정 생성
            $admin = $this->createAdminUser($tenant, $data);
            
            // 3. 기본 설정 초기화
            $this->initializeSettings($tenant);
            
            // 4. 샘플 데이터 생성 (옵션)
            if ($data['create_sample_data'] ?? false) {
                $this->createSampleData($tenant);
            }
            
            // 5. 환영 이메일 발송
            $this->sendWelcomeEmail($tenant, $admin);
            
            // 6. 온보딩 체크리스트 생성
            $this->createOnboardingChecklist($tenant);
            
            DB::commit();
            
            return [
                'success' => true,
                'tenant' => $tenant,
                'admin' => $admin
            ];
            
        } catch (Exception $e) {
            DB::rollBack();
            
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 테넌트 레코드 생성
     */
    private function createTenantRecord($data)
    {
        $subdomain = $this->generateSubdomain($data['company_name']);
        
        return Tenant::create([
            'name' => $data['company_name'],
            'subdomain' => $subdomain,
            'plan' => $data['plan'] ?? 'free',
            'status' => 'active',
            'trial_ends_at' => now()->addDays(14), // 14일 무료 체험
            'settings' => json_encode([
                'timezone' => $data['timezone'] ?? 'UTC',
                'currency' => $data['currency'] ?? 'USD',
                'language' => $data['language'] ?? 'en'
            ])
        ]);
    }
    
    /**
     * 서브도메인 생성
     */
    private function generateSubdomain($companyName)
    {
        $subdomain = strtolower(preg_replace('/[^a-zA-Z0-9]/', '', $companyName));
        
        // 중복 체크
        $counter = 1;
        $originalSubdomain = $subdomain;
        
        while (Tenant::where('subdomain', $subdomain)->exists()) {
            $subdomain = $originalSubdomain . $counter;
            $counter++;
        }
        
        return $subdomain;
    }
    
    /**
     * 관리자 계정 생성
     */
    private function createAdminUser($tenant, $data)
    {
        return User::create([
            'tenant_id' => $tenant->id,
            'name' => $data['admin_name'],
            'email' => $data['admin_email'],
            'password' => password_hash($data['password'], PASSWORD_DEFAULT),
            'role' => 'admin',
            'status' => 'active'
        ]);
    }
    
    /**
     * 기본 설정 초기화
     */
    private function initializeSettings($tenant)
    {
        $defaultSettings = [
            'email_notifications' => true,
            'two_factor_auth' => false,
            'api_enabled' => false,
            'theme' => 'light',
            'date_format' => 'Y-m-d',
            'time_format' => 'H:i:s'
        ];
        
        foreach ($defaultSettings as $key => $value) {
            TenantConfig::create([
                'tenant_id' => $tenant->id,
                'key' => $key,
                'value' => $value
            ]);
        }
    }
    
    /**
     * 샘플 데이터 생성
     */
    private function createSampleData($tenant)
    {
        // 샘플 프로젝트
        $project = Project::create([
            'tenant_id' => $tenant->id,
            'name' => 'Sample Project',
            'description' => 'This is a sample project to help you get started',
            'status' => 'active'
        ]);
        
        // 샘플 태스크
        Task::create([
            'tenant_id' => $tenant->id,
            'project_id' => $project->id,
            'title' => 'Complete your profile',
            'description' => 'Add your company logo and customize your branding',
            'status' => 'pending'
        ]);
        
        Task::create([
            'tenant_id' => $tenant->id,
            'project_id' => $project->id,
            'title' => 'Invite team members',
            'description' => 'Add your team members to collaborate',
            'status' => 'pending'
        ]);
    }
    
    /**
     * 환영 이메일 발송
     */
    private function sendWelcomeEmail($tenant, $admin)
    {
        $customization = new TenantCustomization();
        $template = $customization->getEmailTemplate('welcome');
        
        // 이메일 발송 로직
        // Mail::to($admin->email)->send(new WelcomeEmail($tenant, $admin, $template));
    }
    
    /**
     * 온보딩 체크리스트 생성
     */
    private function createOnboardingChecklist($tenant)
    {
        $checklist = [
            ['task' => 'Complete company profile', 'completed' => false],
            ['task' => 'Upload company logo', 'completed' => false],
            ['task' => 'Customize branding colors', 'completed' => false],
            ['task' => 'Invite team members', 'completed' => false],
            ['task' => 'Create first project', 'completed' => false],
            ['task' => 'Explore features', 'completed' => false]
        ];
        
        OnboardingChecklist::create([
            'tenant_id' => $tenant->id,
            'items' => json_encode($checklist),
            'completed_at' => null
        ]);
    }
    
    /**
     * 온보딩 진행률 계산
     */
    public function getOnboardingProgress()
    {
        $tenant = tenant();
        $checklist = OnboardingChecklist::where('tenant_id', $tenant->id)->first();
        
        if (!$checklist) {
            return 0;
        }
        
        $items = json_decode($checklist->items, true);
        $completed = array_filter($items, fn($item) => $item['completed']);
        
        return (count($completed) / count($items)) * 100;
    }
}

📊 모니터링 및 분석

멀티테넌트 시스템을 운영하면서 각 테넌트의 사용 패턴과 시스템 상태를 모니터링하는 건 필수예요! 실시간으로 문제를 감지하고 대응할 수 있어야 하거든요. 📈

<?php
class TenantAnalytics
{
    private $redis;
    
    public function __construct()
    {
        $this->redis = new Redis();
        $this->redis->connect('127.0.0.1', 6379);
    }
    
    /**
     * 활동 로깅
     */
    public function logActivity($action, $data = [])
    {
        $tenantId = tenant_id();
        $userId = auth()->id();
        
        ActivityLog::create([
            'tenant_id' => $tenantId,
            'user_id' => $userId,
            'action' => $action,
            'data' => json_encode($data),
            'ip_address' => request()->ip(),
            'user_agent' => request()->userAgent(),
            'created_at' => now()
        ]);
        
        // Redis에 실시간 카운터 증가
        $key = "tenant:{$tenantId}:activity:" . date('Y-m-d');
        $this->redis->incr($key);
        $this->redis->expire($key, 86400 * 30); // 30일 보관
    }
    
    /**
     * 대시보드 통계
     */
    public function getDashboardStats()
    {
        $tenantId = tenant_id();
        $cache = new TenantCache();
        
        return $cache->remember('dashboard:stats', 300, function() use ($tenantId) {
            return [
                'total_users' => User::where('tenant_id', $tenantId)->count(),
                'active_users' => User::where('tenant_id', $tenantId)
                    ->where('last_login_at', '>=', now()->subDays(30))
                    ->count(),
                'total_projects' => Project::where('tenant_id', $tenantId)->count(),
                'active_projects' => Project::where('tenant_id', $tenantId)
                    ->where('status', 'active')
                    ->count(),
                'storage_used' => $this->getStorageUsed(),
                'api_calls_today' => $this->getApiCallsToday(),
                'activity_trend' => $this->getActivityTrend(7)
            ];
        });
    }
    
    /**
     * 사용 중인 스토리지 용량
     */
    private function getStorageUsed()
    {
        $storage = new TenantFileStorage();
        $bytes = $storage->getStorageUsage();
        
        return $this->formatBytes($bytes);
    }
    
    /**
     * 오늘 API 호출 수
     */
    private function getApiCallsToday()
    {
        $tenantId = tenant_id();
        $key = "tenant:{$tenantId}:api_calls:" . date('Y-m-d');
        
        return (int) $this->redis->get($key) ?: 0;
    }
    
    /**
     * 활동 추세 (최근 N일)
     */
    private function getActivityTrend($days)
    {
        $tenantId = tenant_id();
        $trend = [];
        
        for ($i = $days - 1; $i >= 0; $i--) {
            $date = date('Y-m-d', strtotime("-{$i} days"));
            $key = "tenant:{$tenantId}:activity:{$date}";
            
            $trend[] = [
                'date' => $date,
                'count' => (int) $this->redis->get($key) ?: 0
            ];
        }
        
        return $trend;
    }
    
    /**
     * 사용자 참여도 분석
     */
    public function getUserEngagement()
    {
        $tenantId = tenant_id();
        
        return [
            'daily_active_users' => User::where('tenant_id', $tenantId)
                ->where('last_login_at', '>=', now()->subDay())
                ->count(),
            'weekly_active_users' => User::where('tenant_id', $tenantId)
                ->where('last_login_at', '>=', now()->subWeek())
                ->count(),
            'monthly_active_users' => User::where('tenant_id', $tenantId)
                ->where('last_login_at', '>=', now()->subMonth())
                ->count(),
            'average_session_duration' => $this->getAverageSessionDuration(),
            'most_active_users' => $this->getMostActiveUsers(5)
        ];
    }
    
    /**
     * 평균 세션 시간
     */
    private function getAverageSessionDuration()
    {
        $tenantId = tenant_id();
        
        $sessions = DB::table('sessions')
            ->where('tenant_id', $tenantId)
            ->where('created_at', '>=', now()->subWeek())
            ->get();
        
        if ($sessions->isEmpty()) {
            return 0;
        }
        
        $totalDuration = 0;
        foreach ($sessions as $session) {
            $duration = strtotime($session->last_activity) - strtotime($session->created_at);
            $totalDuration += $duration;
        }
        
        return round($totalDuration / $sessions->count() / 60); // 분 단위
    }
    
    /**
     * 가장 활발한 사용자
     */
    private function getMostActiveUsers($limit)
    {
        $tenantId = tenant_id();
        
        return ActivityLog::select('user_id', DB::raw('COUNT(*) as activity_count'))
            ->where('tenant_id', $tenantId)
            ->where('created_at', '>=', now()->subWeek())
            ->groupBy('user_id')
            ->orderBy('activity_count', 'desc')
            ->limit($limit)
            ->with('user:id,name,email')
            ->get();
    }
    
    /**
     * 바이트를 읽기 쉬운 형식으로 변환
     */
    private function formatBytes($bytes)
    {
        $units = ['B', 'KB', 'MB', 'GB', 'TB'];
        $i = 0;
        
        while ($bytes >= 1024 && $i < count($units) - 1) {
            $bytes /= 1024;
            $i++;
        }
        
        return round($bytes, 2) . ' ' . $units[$i];
    }
    
    /**
     * 시스템 헬스 체크
     */
    public function healthCheck()
    {
        $tenantId = tenant_id();
        
        return [
            'database' => $this->checkDatabase(),
            'cache' => $this->checkCache(),
            'storage' => $this->checkStorage(),
            'api_rate_limit' => $this->checkApiRateLimit(),
            'overall_status' => 'healthy' // or 'warning', 'critical'
        ];
    }
    
    private function checkDatabase()
    {
        try {
            DB::connection()->getPdo();
            return ['status' => 'ok', 'message' => 'Database connection is healthy'];
        } catch (Exception $e) {
            return ['status' => 'error', 'message' => $e->getMessage()];
        }
    }
    
    private function checkCache()
    {
        try {
            $this->redis->ping();
            return ['status' => 'ok', 'message' => 'Cache is working'];
        } catch (Exception $e) {
            return ['status' => 'error', 'message' => $e->getMessage()];
        }
    }
    
    private function checkStorage()
    {
        $subscription = new SubscriptionManager();
        $check = $subscription->checkLimit('storage');
        
        if ($check['percentage'] >= 90) {
            return ['status' => 'warning', 'message' => 'Storage usage is high'];
        }
        
        return ['status' => 'ok', 'message' => 'Storage is healthy'];
    }
    
    private function checkApiRateLimit()
    {
        $subscription = new SubscriptionManager();
        $check = $subscription->checkLimit('api_calls');
        
        if ($check['percentage'] >= 80) {
            return ['status' => 'warning', 'message' => 'API rate limit approaching'];
        }
        
        return ['status' => 'ok', 'message' => 'API usage is normal'];
    }
}

🚀 확장성 및 성능 고려사항

멀티테넌트 시스템이 성장하면서 마주하게 될 확장성 이슈들과 해결 방법을 알아볼게요! 미리 준비하면 나중에 고생 안 해요 ㅋㅋㅋ 💪

🎓 실전 팁과 베스트 프랙티스

지금까지 배운 내용을 실제 프로젝트에 적용할 때 꼭 알아야 할 팁들을 정리해볼게요! 이건 진짜 현업에서 얻은 노하우예요 😎

🔮 미래 트렌드와 발전 방향

멀티테넌트 아키텍처는 계속 진화하고 있어요! 앞으로 주목해야 할 트렌드들을 살펴볼게요. 🌟

🎬 마무리하며

와... 여기까지 읽으셨다면 정말 대단하세요! ㅋㅋㅋ 멀티테넌트 아키텍처는 처음엔 복잡해 보이지만, 한 번 제대로 구축해놓으면 정말 강력한 무기가 돼요. 💪

핵심을 다시 정리하면:

1. 데이터 격리가 최우선 - 보안은 타협할 수 없어요!
2. 확장성을 고려한 설계 - 나중에 리팩토링하면 정말 힘들어요
3. 성능 최적화는 필수 - 캐싱과 인덱싱을 잘 활용하세요
4. 모니터링 체계 구축 - 문제를 빨리 발견하고 대응해야 해요
5. 사용자 경험 중심 - 기술은 수단일 뿐, 고객 만족이 목표예요

PHP로 멀티테넌트 SaaS를 만드는 건 충분히 가능하고, 실제로 많은 성공 사례들이 있어요. Laravel 같은 프레임워크를 활용하면 더욱 쉽게 구현할 수 있고요! 🚀

혹시 막히는 부분이 있거나 더 깊이 있는 도움이 필요하다면 재능넷에서 전문가들과 상담해보세요. 실전 경험이 풍부한 개발자들이 여러분의 프로젝트를 성공으로 이끌어줄 거예요! 😊

여러분의 SaaS 프로젝트가 대박나길 응원합니다! 화이팅! 🎉✨