多区域 LLM 部署：全球低延迟 AI 服务

                    ┌───────────────────────┐
                    │   Global DNS (GeoDNS) │
                    │   Anycast / Route53   │
                    └───────────┬───────────┘
            ┌───────────────────┼───────────────────┐
            ▼                   ▼                   ▼
     ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
     │  US-West    │    │  EU-West    │    │  AP-East    │
     │  (Oregon)   │    │  (Ireland)  │    │  (Singapore) │
     │             │    │             │    │             │
     │ ┌─────────┐ │    │ ┌─────────┐ │    │ ┌─────────┐ │
     │ │ LLM GPU │ │    │ │ LLM GPU │ │    │ │ LLM GPU │ │
     │ │ Cluster │ │    │ │ Cluster │ │    │ │ Cluster │ │
     │ └─────────┘ │    │ └─────────┘ │    │ └─────────┘ │
     │ ┌─────────┐ │    │ ┌─────────┐ │    │ ┌─────────┐ │
     │ │ Redis   │ │    │ │ Redis   │ │    │ │ Redis   │ │
     │ │ + Vector│ │    │ │ + Vector│ │    │ │ + Vector│ │
     │ └─────────┘ │    │ └─────────┘ │    │ └─────────┘ │
     └─────────────┘    └─────────────┘    └─────────────┘
            │                   │                   │
            └───────────────────┼───────────────────┘
                    ┌───────────┴───────────┐
                    │  Global Model Registry │
                    │  (Central Storage)     │
                    │  S3 + CDN 分发         │
                    └───────────────────────┘

# AWS Route53 Geo DNS 配置
Type: A
Name: api.llm.example.com
TTL: 60

Records:
  - Region: us-west-2
    Value: 54.x.x.x          # US-West LLM endpoint
    HealthCheck: llm-us-health
  - Region: eu-west-1
    Value: 52.x.x.x          # EU-West LLM endpoint
    HealthCheck: llm-eu-health
  - Region: ap-southeast-1
    Value: 13.x.x.x          # AP-East LLM endpoint
    HealthCheck: llm-ap-health
  - Region: default
    Value: 54.x.x.x          # 默认路由到 US

# 健康检查失败时自动故障转移
Failover:
  primary: us-west-2 → ap-southeast-1
  secondary: eu-west-1 → us-west-2

import geoip2.database
from datetime import datetime

class GeoRouter:
    def __init__(self, regions: list[dict]):
        self.regions = regions
        # {"name": "us-west", "endpoint": "...", "latencies": {}}
        self.health = {r["name"]: {"healthy": True, "p99": 0} for r in regions}
        self.reader = geoip2.database.Reader('GeoLite2-City.mmdb')

    def route(self, request_ip: str, user_region: str = None) -> str:
        # 1. 用户指定区域优先
        if user_region and self._is_healthy(user_region):
            return self._get_endpoint(user_region)

        # 2. GeoIP 自动判断
        try:
            resp = self.reader.city(request_ip)
            user_continent = resp.continent.code
            region = self._match_region(user_continent)
            if region and self._is_healthy(region):
                return self._get_endpoint(region)
        except Exception:
            pass

        # 3. 延迟优先选择
        return self._lowest_latency_region()

    def _match_region(self, continent: str) -> str:
        mapping = {"NA": "us-west", "SA": "us-west", "EU": "eu-west",
                   "AS": "ap-east", "OC": "ap-east", "AF": "eu-west"}
        return mapping.get(continent)

    def _lowest_latency_region(self) -> str:
        healthy = [r for r in self.regions if self._is_healthy(r["name"])]
        if not healthy:
            raise Exception("No healthy regions")
        return min(healthy, key=lambda r: self.health[r["name"]]["p99"])["endpoint"]

class CompliantDataRouter:
    """确保用户数据不跨境"""

    REGION_POLICIES = {
        "eu-west": {"regulation": "GDPR", "data_residency": "EU"},
        "us-west": {"regulation": "CCPA", "data_residency": "US"},
        "ap-east": {"regulation": "PIPL", "data_residency": "CN/SG"},
    }

    def __init__(self, region: str):
        self.region = region
        self.policy = self.REGION_POLICIES[region]

    def validate_request(self, user_data: dict) -> bool:
        """验证请求数据是否符合区域合规要求"""
        # 检查用户是否同意数据在该区域处理
        user_region = user_data.get("region", "")
        if not self._is_compliant(user_region, self.policy["data_residency"]):
            raise ComplianceError(
                f"User from {user_region} cannot be processed in {self.region}"
            )
        return True

    def _is_compliant(self, user_region: str, data_residency: str) -> bool:
        rules = {
            "EU": ["EU", "UK"],            # EU 数据不离开欧洲
            "US": ["US", "CA", "MX"],       # US 数据在北美
            "CN/SG": ["CN", "SG", "JP", "KR"],  # 亚太数据在亚太
        }
        allowed = rules.get(data_residency, [])
        return user_region in allowed

class ModelSyncManager:
    """跨区域模型同步"""

    def __init__(self, regions: list[str], central_storage: str):
        self.regions = regions
        self.central = central_storage  # S3 / MinIO

    async def deploy_model(self, model_path: str, version: str):
        """将新模型分发到所有区域"""
        # 1. 上传到中心存储
        central_key = f"models/{version}/model.safetensors"
        self._upload_to_central(model_path, central_key)

        # 2. 并行分发到各区域
        tasks = []
        for region in self.regions:
            tasks.append(self._sync_to_region(region, central_key, version))
        results = await asyncio.gather(*tasks, return_exceptions=True)

        # 3. 验证所有区域成功
        failed = [r for r, result in zip(self.regions, results)
                  if isinstance(result, Exception)]
        if failed:
            logger.error(f"Model sync failed for regions: {failed}")
            return False
        return True

    async def _sync_to_region(self, region: str, central_key: str, version: str):
        """将模型同步到指定区域"""
        # 使用 CDN 加速分发
        cdn_url = f"https://cdn.llm.example.com/{central_key}"
        region_endpoint = self._get_region_endpoint(region)

        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{region_endpoint}/internal/model/load",
                json={"url": cdn_url, "version": version}
            ) as resp:
                if resp.status != 200:
                    raise Exception(f"Region {region} model load failed")

class DisasterRecovery:
    """多区域灾难恢复"""

    def __init__(self, regions: list[str], primary: str):
        self.regions = regions
        self.primary = primary
        self.failover_order = [r for r in regions if r != primary]

    async def health_check(self) -> dict:
        """全区域健康检查"""
        results = {}
        for region in self.regions:
            results[region] = await self._check_region(region)
        return results

    async def failover(self, failed_region: str) -> str:
        """故障转移到下一个区域"""
        # 1. 将故障区域从 DNS 摘除
        await self._remove_from_dns(failed_region)

        # 2. 选择最佳备选区域
        for candidate in self.failover_order:
            if await self._is_healthy(candidate):
                # 3. 更新 DNS 指向
                await self._update_dns(failed_region, candidate)
                # 4. 通知各区域缓存失效
                await self._invalidate_cache(failed_region)
                logger.info(f"Failed over from {failed_region} to {candidate}")
                return candidate

        raise Exception("No healthy failover target")

    async def _check_region(self, region: str) -> dict:
        """检查区域健康状态"""
        endpoint = self._get_endpoint(region)
        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    f"{endpoint}/health", timeout=3
                ) as resp:
                    return {
                        "region": region,
                        "healthy": resp.status == 200,
                        "latency": resp.headers.get("X-Response-Time", "N/A")
                    }
        except Exception:
            return {"region": region, "healthy": False, "latency": "timeout"}

class ElasticScaling:
    """区域弹性：非高峰期缩容"""

    PEAK_HOURS = {
        "us-west": (14, 22),   # UTC
        "eu-west": (7, 15),
        "ap-east": (0, 8),
    }

    def get_target_replicas(self, region: str, current_hour: int) -> int:
        """根据时段动态调整副本数"""
        start, end = self.PEAK_HOURS.get(region, (0, 24))
        if start <= current_hour < end:
            return 4  # 高峰 4 副本
        return 2  # 低峰 2 副本