CDN+OSS边缘加速实践：动态压缩+智能路由降低30%视频流量成本（含带宽峰值监控与告警配置）

C_{total} = \sum_{i=1}^{n} (P_{peak_i} × T_i × R_{region}) + C_{req} × N_{req}

# 请求分布分析代码示例
import pandas as pd
log_df = pd.read_csv("cdn_access_log.csv")
hotspot_ratio = log_df[log_df['file_size'] > 10*1024].groupby('region')['bandwidth'].sum() / log_df['bandwidth'].sum()
print(f"大文件带宽热点区域: \n{hotspot_ratio.sort_values(ascending=False).head(3)}")

华东1: 42.7%  
华北2: 28.1%  
华南1: 15.3%  

# oss_replication.conf
ReplicationRule:
- RuleID: video-hot
  Prefix: videos/4k/
  Status: Enabled
  Destination:
    Bucket: oss-cn-shanghai
    StorageClass: IA
  HistoricalObjectReplication: Disabled
- RuleID: video-cold
  Prefix: videos/1080p/
  Status: Enabled
  SyncRole: OSSRole
  ReplicationTime:
    Status: Enabled
    Time:
      Minutes: 30

def adaptive_compress(file_path, device_type):
    # 设备能力矩阵
    device_profiles = {
        'ios': {'max_bitrate': 8, 'resolution': '1080p'},
        'android_low': {'max_bitrate': 2, 'resolution': '720p'},
        'android_high': {'max_bitrate': 6, 'resolution': '1080p'}
    }
    
    # 获取设备配置
    profile = device_profiles.get(device_type, device_profiles['android_low'])
    
    # FFmpeg动态参数
    cmd = (
        f"ffmpeg -i {file_path} -b:v {profile['max_bitrate']}M "
        f"-s {profile['resolution']} -c:v libx265 -preset fast "
        "-movflags +faststart output.mp4"
    )
    os.system(cmd)
    return calc_bandwidth_saving(file_path, "output.mp4")

Savings = \frac{\sum (Size_{orig} - Size_{comp}) × P_{bandwidth}}{\sum Size_{orig} × P_{bandwidth}} × 100\%

type RouteDecision struct {
    CostWeight     float64 // 成本因子
    LatencyWeight  float64 // 延迟因子
    CacheHitWeight float64 // 缓存命中因子
}

func (rd *RouteDecision) Calculate(metrics NodeMetrics) float64 {
    return rd.CostWeight*metrics.CostIndex +
        rd.LatencyWeight*(1/metrics.Latency) +
        rd.CacheHitWeight*metrics.CacheHitRate
}

// 实时节点选择
func selectEdgeNode(request Request) *CDNNode {
    candidates := getAvailableNodes(request.Region)
    var bestNode *CDNNode
    maxScore := -1.0
    
    for _, node := range candidates {
        score := decisionModel.Calculate(node.GetMetrics())
        if score > maxScore {
            maxScore = score
            bestNode = node
        }
    }
    return bestNode
}

# 基于时间序列异常检测
from statsmodels.tsa.seasonal import STL

def detect_bandwidth_anomaly(data, threshold=3):
    # STL分解时序数据
    res = STL(data, period=24*7).fit()
    resid = res.resid
    
    # 计算Z-score
    mean = np.mean(resid)
    std = np.std(resid)
    z_scores = [(x - mean) / std for x in resid]
    
    # 标记异常点
    anomalies = np.where(np.abs(z_scores) > threshold)
    return anomalies

# prometheus_rules.yml
groups:
- name: cdn-bandwidth-alert
  rules:
  - alert: BandwidthSpike
    expr: |
      rate(cdn_bandwidth_bytes[5m]) > ( 
        avg_over_time(cdn_bandwidth_bytes[1d]) * 1.5
      )
    for: 10m
    labels:
      severity: critical
    annotations:
      summary: "带宽突增告警 {{ $labels.region }}"
      description: "区域 {{ $labels.region }} 带宽5分钟内增长超过基线150%"

  - alert: CostOverThreshold
    expr: |
      predict_linear(cdn_cost_usd[1h], 3600) > 1000
    labels:
      severity: warning

S_{node} = \alpha \frac{1}{C_{traffic}} + \beta \frac{1}{Latency} + \gamma Cache_{hit} + \delta \frac{Ava_{cpu}}{100}

# 根据UA路由到不同后端
map $http_user_agent $upstream_pool {
    ~*iphone|android  mobile_backend;
    default           standard_backend;
}

server {
    listen 80;
    location /video/ {
        proxy_pass http://$upstream_pool;
        
        # 开启带宽限制
        proxy_limit_rate_after 10m;
        proxy_limit_rate 1m;
    }
}

{
  "Rules": [
    {
      "ID": "video-archive",
      "Prefix": "videos/",
      "Status": "Enabled",
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "Archive"
        }
      ],
      "AbortIncompleteMultipartUpload": {
        "DaysAfterInitiation": 7
      }
    }
  ]
}