124：API网关与流量管理：高可用API设计

class Router:
    def __init__(self):
        self.routes = {}
    
    def add_route(self, path, handler):
        self.routes[path] = handler
    
    def route(self, request):
        path = request.path
        if path in self.routes:
            return self.routes[path](request)
        else:
            return self.handle_404(request)
    
    def handle_404(self, request):
        return {"status": 404, "message": "Not Found"}

class Authenticator:
    def __init__(self):
        self.token_store = {}
    
    def generate_token(self, user_id):
        token = self._generate_random_token()
        self.token_store[token] = user_id
        return token
    
    def validate_token(self, token):
        return token in self.token_store
    
    def get_user_id(self, token):
        return self.token_store.get(token)
    
    def _generate_random_token(self):
        import secrets
        return secrets.token_hex(32)

class RateLimiter:
    def __init__(self, max_requests, time_window):
        self.max_requests = max_requests
        self.time_window = time_window  # 秒
        self.requests = {}
    
    def is_allowed(self, client_id):
        import time
        current_time = time.time()
        
        if client_id not in self.requests:
            self.requests[client_id] = []
        
        # 清理过期的请求记录
        self.requests[client_id] = [t for t in self.requests[client_id] if current_time - t < self.time_window]
        
        # 检查是否超过限制
        if len(self.requests[client_id]) < self.max_requests:
            self.requests[client_id].append(current_time)
            return True
        else:
            return False

class CircuitBreaker:
    def __init__(self, failure_threshold, recovery_time):
        self.failure_threshold = failure_threshold
        self.recovery_time = recovery_time  # 秒
        self.failures = 0
        self.state = "CLOSED"
        self.last_failure_time = 0
    
    def allow_request(self):
        import time
        current_time = time.time()
        
        if self.state == "OPEN":
            # 检查是否可以尝试恢复
            if current_time - self.last_failure_time > self.recovery_time:
                self.state = "HALF_OPEN"
                return True
            else:
                return False
        elif self.state == "HALF_OPEN":
            # 尝试一个请求
            return True
        else:  # CLOSED
            return True
    
    def record_success(self):
        if self.state == "HALF_OPEN":
            self.state = "CLOSED"
            self.failures = 0
    
    def record_failure(self):
        import time
        self.failures += 1
        self.last_failure_time = time.time()
        
        if self.state == "CLOSED" and self.failures >= self.failure_threshold:
            self.state = "OPEN"
        elif self.state == "HALF_OPEN":
            self.state = "OPEN"
            self.failures = 0

class HealthChecker:
    def __init__(self, services, check_interval):
        self.services = services
        self.check_interval = check_interval  # 秒
        self.healthy_services = set(services)
        self.last_check_time = 0
    
    def check_health(self):
        import time
        current_time = time.time()
        
        if current_time - self.last_check_time > self.check_interval:
            self.last_check_time = current_time
            
            for service in self.services:
                if self._is_service_healthy(service):
                    self.healthy_services.add(service)
                else:
                    self.healthy_services.remove(service)
    
    def get_healthy_services(self):
        self.check_health()
        return list(self.healthy_services)
    
    def _is_service_healthy(self, service):
        # 实现健康检查逻辑
        import requests
        try:
            response = requests.get(f"http://{service}/health", timeout=2)
            return response.status_code == 200
        except:
            return False

class WeightedRouter:
    def __init__(self):
        self.routes = {}
    
    def add_route(self, path, services):
        """
        services: [(service_url, weight), ...]
        """
        self.routes[path] = services
    
    def route(self, request):
        path = request.path
        if path in self.routes:
            services = self.routes[path]
            return self._select_service(services)
        else:
            return None
    
    def _select_service(self, services):
        import random
        total_weight = sum(weight for _, weight in services)
        rand = random.uniform(0, total_weight)
        current_weight = 0
        
        for service, weight in services:
            current_weight += weight
            if rand <= current_weight:
                return service
        
        return services[0][0]

import jwt
import datetime

def generate_jwt(user_id, secret_key):
    payload = {
        "user_id": user_id,
        "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=24)
    }
    return jwt.encode(payload, secret_key, algorithm="HS256")

def validate_jwt(token, secret_key):
    try:
        payload = jwt.decode(token, secret_key, algorithms=["HS256"])
        return payload
    except:
        return None

def mask_sensitive_data(data, sensitive_fields):
    for field in sensitive_fields:
        if field in data:
            data[field] = "***"
    return data

class ResponseCache:
    def __init__(self, max_size, ttl):
        self.cache = {}
        self.max_size = max_size
        self.ttl = ttl  # 秒
    
    def get(self, key):
        import time
        current_time = time.time()
        
        if key in self.cache:
            value, timestamp = self.cache[key]
            if current_time - timestamp < self.ttl:
                return value
            else:
                del self.cache[key]
        
        return None
    
    def set(self, key, value):
        import time
        current_time = time.time()
        
        if len(self.cache) >= self.max_size:
            # 移除最旧的缓存
            oldest_key = min(self.cache, key=lambda k: self.cache[k][1])
            del self.cache[oldest_key]
        
        self.cache[key] = (value, current_time)

import requests
from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter

session = requests.Session()
retries = Retry(total=3, backoff_factor=1)
session.mount('http://', HTTPAdapter(max_retries=retries, pool_connections=100, pool_maxsize=100))
session.mount('https://', HTTPAdapter(max_retries=retries, pool_connections=100, pool_maxsize=100))

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, f"http://example.com/{i}") for i in range(100)]
        results = await asyncio.gather(*tasks)
        return results

asyncio.run(main())

# prometheus.yml
scrape_configs:
  - job_name: 'api_gateway'
    static_configs:
      - targets: ['localhost:8000']
    metrics_path: '/metrics'
    scrape_interval: 15s