CDN优化：多级缓存与智能调度

多级缓存架构

CDN通过在全球分布的边缘节点缓存内容，减少用户访问延迟和源站压力。

// CDN缓存管理
@Component
public class CDNCacheManager {
    
    private final CacheConfig config;
    private final OriginServer originServer;
    
    // 缓存决策
    public CacheDecision decideCache(String resourceKey, RequestContext context) {
        // 检查缓存策略
        CachePolicy policy = getCachePolicy(resourceKey);
        
        // 检查是否可缓存
        if (!policy.isCacheable()) {
            return CacheDecision.bypass("资源不可缓存");
        }
        
        // 检查边缘节点缓存
        Optional<CachedContent> edgeCache = checkEdgeCache(resourceKey);
        if (edgeCache.isPresent() && !isStale(edgeCache.get(), policy)) {
            return CacheDecision.hit("边缘节点命中");
        }
        
        // 检查区域缓存
        Optional<CachedContent> regionalCache = checkRegionalCache(resourceKey);
        if (regionalCache.isPresent() && !isStale(regionalCache.get(), policy)) {
            return CacheDecision.hit("区域节点命中");
        }
        
        // 检查源站缓存
        Optional<CachedContent> originCache = checkOriginCache(resourceKey);
        if (originCache.isPresent() && !isStale(originCache.get(), policy)) {
            return CacheDecision.hit("源站命中");
        }
        
        // 缓存未命中，需要回源
        return CacheDecision.miss("需要回源获取");
    }
    
    // 多级缓存读取
    public Content getFromMultiLevelCache(String resourceKey) {
        // L1: 边缘节点缓存
        Optional<Content> edge = redisTemplate.opsForValue()
            .get("cdn:edge:" + resourceKey);
        if (edge.isPresent()) {
            metrics.counter("cdn.l1.hit").increment();
            return edge.get();
        }
        
        // L2: 区域节点缓存
        Optional<Content> regional = redisTemplate.opsForValue()
            .get("cdn:regional:" + resourceKey);
        if (regional.isPresent()) {
            metrics.counter("cdn.l2.hit").increment();
            // 回写L1
            writeToEdgeCache(resourceKey, regional.get());
            return regional.get();
        }
        
        // L3: 源站缓存
        Optional<Content> origin = getFromOrigin(resourceKey);
        if (origin.isPresent()) {
            metrics.counter("cdn.l3.hit").increment();
            // 回写L1和L2
            writeToEdgeCache(resourceKey, origin.get());
            writeToRegionalCache(resourceKey, origin.get());
            return origin.get();
        }
        
        metrics.counter("cdn.miss").increment();
        return Content.empty();
    }
}

缓存预热机制

// 缓存预热服务
@Service
public class CacheWarmupService {
    
    private final CDNProvider cdnProvider;
    private final PredictionEngine predictor;
    
    // 定时预热
    @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨2点
    public void scheduledWarmup() {
        // 预测热门资源
        List<HotResource> hotResources = predictor.predictHotResources(
            Duration.ofHours(24));
        
        // 预热这些资源
        warmupResources(hotResources);
    }
    
    // 事件驱动预热
    @EventListener
    public void onContentPublished(ContentPublishedEvent event) {
        // 新内容发布时预热
        String contentKey = event.getContentKey();
        
        // 预热到所有边缘节点
        cdnProvider.purgeAndWarmup(contentKey);
        
        // 记录预热日志
        log.info("内容预热完成: {}", contentKey);
    }
    
    // 智能预热
    public void smartWarmup(String resourceKey) {
        // 分析访问模式
        AccessPattern pattern = analyzeAccessPattern(resourceKey);
        
        // 确定预热策略
        WarmupStrategy strategy = selectStrategy(pattern);
        
        // 执行预热
        switch (strategy) {
            case AGGRESSIVE:
                // 激进预热：立即预热到所有节点
                cdnProvider.warmupAllNodes(resourceKey);
                break;
            case CONSERVATIVE:
                // 保守预热：只预热到区域节点
                cdnProvider.warmupRegionalNodes(resourceKey);
                break;
            case DEMAND_BASED:
                // 按需预热：根据实际访问逐步预热
                cdnProvider.warmupOnDemand(resourceKey);
                break;
        }
    }
    
    private void warmupResources(List<HotResource> resources) {
        resources.parallelStream().forEach(resource -> {
            try {
                cdnProvider.warmup(resource.getKey());
                metrics.counter("cdn.warmup.success").increment();
            } catch (Exception e) {
                metrics.counter("cdn.warmup.failed").increment();
                log.error("预热失败: {}", resource.getKey(), e);
            }
        });
    }
}

智能调度算法

// 智能调度器
@Component
public class IntelligentScheduler {
    
    private final List<EdgeNode> edgeNodes;
    private final HealthChecker healthChecker;
    
    // 基于延迟的调度
    public EdgeNode selectByLatency(ClientInfo client) {
        return edgeNodes.stream()
            .filter(node -> node.isHealthy())
            .min(Comparator.comparingDouble(node -> 
                calculateLatency(client, node)))
            .orElseThrow(() -> new NoAvailableNodeException());
    }
    
    // 基于负载的调度
    public EdgeNode selectByLoad(ClientInfo client) {
        return edgeNodes.stream()
            .filter(node -> node.isHealthy())
            .min(Comparator.comparingDouble(EdgeNode::getLoadScore))
            .orElseThrow(() -> new NoAvailableNodeException());
    }
    
    // 综合调度（考虑延迟、负载、地理位置）
    public EdgeNode selectOptimal(ClientInfo client) {
        return edgeNodes.stream()
            .filter(node -> node.isHealthy())
            .min(Comparator.comparingDouble(node -> {
                // 延迟权重 40%
                double latencyScore = calculateLatencyScore(client, node) * 0.4;
                
                // 负载权重 30%
                double loadScore = node.getLoadScore() * 0.3;
                
                // 地理位置权重 20%
                double geoScore = calculateGeoScore(client, node) * 0.2;
                
                // 带宽权重 10%
                double bandwidthScore = calculateBandwidthScore(node) * 0.1;
                
                return latencyScore + loadScore + geoScore + bandwidthScore;
            }))
            .orElseThrow(() -> new NoAvailableNodeException());
    }
    
    // 故障转移
    public EdgeNode failover(ClientInfo client, EdgeNode failedNode) {
        // 标记节点为不健康
        failedNode.setHealthy(false);
        
        // 选择备用节点
        return selectOptimal(client);
    }
}

// DNS智能解析
@Component
public class SmartDNSResolver {
    
    public String resolve(String domain, ClientInfo client) {
        // 获取所有可用节点
        List<DNSRecord> records = dnsService.getRecords(domain);
        
        // 根据客户端信息选择最佳节点
        DNSRecord selected = selectBestRecord(records, client);
        
        // 返回选中节点的IP
        return selected.getAddress();
    }
    
    private DNSRecord selectBestRecord(List<DNSRecord> records, ClientInfo client) {
        // 基于地理位置
        if (client.getGeoLocation() != null) {
            records = sortByGeoDistance(records, client.getGeoLocation());
        }
        
        // 基于运营商
        if (client.getISP() != null) {
            records = sortByISPMatch(records, client.getISP());
        }
        
        // 基于健康状态
        records = records.stream()
            .filter(r -> r.isHealthy())
            .collect(Collectors.toList());
        
        if (records.isEmpty()) {
            throw new DNSResolutionException("没有可用的DNS记录");
        }
        
        return records.get(0);
    }
}

CDN安全配置

# CDN安全配置
cdn:
  security:
    # HTTPS配置
    https:
      enabled: true
      min_tls_version: "1.2"
      cipher_suites:
        - "TLS_AES_256_GCM_SHA384"
        - "TLS_CHACHA20_POLY1305_SHA256"
        - "TLS_AES_128_GCM_SHA256"
    
    # 访问控制
    access_control:
      ip_whitelist:
        - "10.0.0.0/8"
        - "172.16.0.0/12"
      geo_blocking:
        enabled: false
        blocked_countries: []
    
    # 防盗链
    hotlink_protection:
      enabled: true
      allowed_referrers:
        - "*.example.com"
        - "https://trusted.com"
      token_based: true
      token_secret: "${CDN_TOKEN_SECRET}"
    
    # DDoS防护
    ddos_protection:
      enabled: true
      rate_limiting:
        requests_per_second: 1000
        burst_size: 5000
      challenge_response:
        enabled: true
        captcha_provider: "recaptcha"
    
    # WAF集成
    waf:
      enabled: true
      mode: "block"
      rules:
        - name: "sql_injection"
          enabled: true
        - name: "xss"
          enabled: true
        - name: "path_traversal"
          enabled: true
  
  # 缓存配置
  caching:
    default_ttl: "1h"
    max_ttl: "24h"
    
    rules:
      - pattern: "*.html"
        ttl: "5m"
        no_cache: true
      
      - pattern: "*.css"
        ttl: "7d"
        immutable: true
      
      - pattern: "*.js"
        ttl: "7d"
        immutable: true
      
      - pattern: "*.jpg"
        ttl: "30d"
        immutable: true
      
      - pattern: "/api/*"
        ttl: "0"
        bypass: true

CDN优化通过多级缓存架构、智能预热机制和智能调度算法，为全球用户提供快速、可靠的内容分发服务。