┌─────────────────────────────────────────────────────────────┐
│                      Control Plane (Istio/CP)               │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │  Pilot      │  │  Citadel    │  │  Galley     │  ...     │
│  └─────────────┘  └─────────────┘  └─────────────┘          │
└─────────────────────────────────────────────────────────────┘
                              │ xDS (LDS/RDS/CDS/EDS)
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────┐
│  Signaling Pod      │ │  Media Pod (SFU)    │ │  Media Pod (SFU)    │
│  ┌───────────────┐  │ │  ┌───────────────┐  │ │  ┌───────────────┐  │
│  │ App Container │  │ │  │ App Container │  │ │  │ App Container │  │
│  │ (gRPC/HTTP)   │  │ │  │ (RTP/RTCP)    │  │ │  │ (RTP/RTCP)    │  │
│  └───────┬───────┘  │ │  └───────┬───────┘  │ │  └───────┬───────┘  │
│          │          │ │          │          │ │          │          │
│  ┌───────▼───────┐  │ │  ┌───────▼───────┐  │ │  ┌───────▼───────┐  │
│  │ Sidecar       │  │ │  │ Media Sidecar │  │ │  │ Media Sidecar │  │
│  │ (Envoy)       │  │ │  │ (eBPF/XDP)    │  │ │  │ (eBPF/XDP)    │  │
│  └───────────────┘  │ │  └───────────────┘  │ │  └───────────────┘  │
└─────────────────────┘ └─────────────────────┘ └─────────────────────┘
        │                       │                       │
        │ Signaling Plane       │ Media Plane (Bypass)  │
        │ (L7 Governance)       │ (L4 Zero-Copy)        │
        ▼                       ▼                       ▼

用户态                    内核态                    硬件
┌─────────────────────────────────────────────────────────────┐
│  Media Sidecar (Go/Rust)                                    │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │ AF_XDP UMEM │◄─│ XSK Ring    │◄─│ XDP Program │          │
│  │ (HugePages) │  │ (Rx/Tx/Fill │  │ (eBPF)      │          │
│  └─────────────┘  │  /Comp)     │  └──────┬──────┘          │
└───────────────────┼──────────────┼─────────┼─────────────────┘
                    │              │         │
                    ▼              ▼         ▼
            ┌─────────────────────────────────────┐
            │       Kernel Network Stack          │
            │  (Bypassed for Media Flow)          │
            └─────────────────────────────────────┘
                    │              │         │
                    ▼              ▼         ▼
            ┌─────────────────────────────────────┐
            │         NIC Driver (XDP Native)     │
            └─────────────────────────────────────┘

# MediaTrafficPolicy CRD 示例
apiVersion: media.mesh.io/v1alpha1
kind: MediaTrafficPolicy
metadata:
  name: enterprise-qos-policy
  namespace: meeting-prod
spec:
  # 租户级隔离
  tenantIsolation:
    enabled: true
    priorityClasses:
      - name: "platinum"
        bandwidthGuarantee: "500Mbps"
        latencyBudget: "50ms"
        jitterBudget: "10ms"
      - name: "gold"
        bandwidthGuarantee: "200Mbps"
        latencyBudget: "100ms"
  
  # 会议级 QoS 策略
  meetingQoS:
    adaptiveBitrate:
      enabled: true
      minBitrate: "500kbps"
      maxBitrate: "4Mbps"
    fecPolicy:
      enabled: true
      redundancyRatio: 0.15  # 15% FEC 冗余
    nackOptimization:
      enabled: true
      rttThreshold: "80ms"
  
  # 网络拓扑感知路由
  topologyAwareRouting:
    enabled: true
    preferSameAZ: true
    crossRegionPenalty: 50
    fallbackToRelay: true
  
  # 安全合规
  security:
    dtlsEnforcement: "strict"
    srtpProfile: "AES_CM_128_HMAC_SHA1_80"
    auditLogging: true

┌────────────────────────────────────────────────────────────────┐
│                    Observability Stack                         │
├──────────────────┬──────────────────┬──────────────────────────┤
│   Metrics        │   Logs           │   Traces                 │
│  (Prometheus)    │  (Loki)          │  (Tempo/Jaeger)          │
├──────────────────┼──────────────────┼──────────────────────────┤
│ • pps/bps/loss   │ • RTCP XR 结构化 │ • 端到端调用链           │
│ • jitter/rtt     │   日志           │   (信令+媒体关联)        │
│ • fec/nack ratio │ • 关键事件审计   │ • 跨集群拓扑追踪         │
│ • queue depth    │ • 安全合规日志   │ • 根因定位热力图         │
└──────────────────┴──────────────────┴──────────────────────────┘

# 1. 节点级资源预留 (DaemonSet 部署前置条件)
# /etc/sysctl.d/99-media-sidecar.conf
net.core.netdev_max_backlog = 250000
net.core.rmem_max = 67108864
net.core.wmem_max = 67108864
vm.nr_hugepages = 8192  # 2MB * 8192 = 16GB UMEM 池

# 2. CPU 独占绑核配置 (Kubelet + CRI-O)
# kubelet --cpu-manager-policy=static --topology-manager-policy=single-numa-node
# Pod Annotation: cpu-load-balancing.crio.io: "disable"

# 3. NIC 多队列映射 (ethtool -L eth0 combined 16)
# Media Sidecar 启动参数: --rx-queues=0-7 --tx-queues=8-15

graph LR
    A[Canary v1.n+1] -->|1% 流量<br>影子镜像模式| B(指标对比<br>延迟/丢包/CPU)
    B -->|通过阈值| C[扩大至 10%<br>真实流量]
    C -->|稳定 30min| D[全量发布]
    B -->|异常| E[自动回滚<br>告警研发]
    
    style A fill:#e1f5fe
    style D fill:#c8e6c9
    style E fill:#ffcdd2

// media_mesh/api/v1alpha1/media_listener.proto
// 扩展 Listener 描述媒体入口特征
message MediaListener {
  string name = 1;                    // e.g., "media-ingress-rtp"
  uint32 port = 2;                    // 监听端口
  string bind_address = 3;            // 0.0.0.0 或特定 NIC IP
  TransportProtocol protocol = 4;     // UDP_ONLY / UDP_TCP_MUX
  
  // 核心扩展：媒体会话匹配规则
  repeated MediaMatchRule match_rules = 5;
  
  // 零拷贝参数下发
  XdpConfig xdp_config = 6;
  
  // 流量治理策略引用
  string traffic_policy_ref = 7;      // 引用 MediaTrafficPolicy CRD
}

message MediaMatchRule {
  // 基于 5 元组 + RTP Header 语义匹配
  PortRange dst_port_range = 1;
  repeated uint32 ssrc_whitelist = 2;      // SSRC 白名单
  repeated string mid_values = 3;          // SDP mid 标识 (audio/video/data)
  RtpPayloadTypeRange payload_types = 4;   // 负载类型范围 (如 96-127 动态 PT)
  
  // 动作：REDIRECT_TO_XDP / PASS_KERNEL / DROP / MIRROR
  MatchAction action = 5; 
}

message XdpConfig {
  bool enabled = 1;
  repeated uint32 rx_queue_ids = 2;        // 绑定 RSS 队列
  uint32 umem_frame_size = 3;              // 2048 / 4096
  uint32 umem_frame_count = 4;             // 总 Frame 数
  bool need_wakeup = 5;                    // 是否需要显式唤醒
  XdpFlags flags = 6;                      // XDP_FLAGS_DRV_MODE / SKB_MODE / HW_MODE
}

sequenceDiagram
    participant Admin as 运维/Controller
    participant Pilot as Istio Pilot (扩展版)
    participant XDS as xDS Server (Media Agent)
    participant Sidecar as Media Sidecar (Agent)
    
    Admin->>Pilot: Apply MediaTrafficPolicy / MediaListener CRD
    Pilot->>Pilot: 合并 ServiceEntry + MediaListener 生成内部模型
    Pilot->>XDS: Push LDS (MediaListener) + RDS (Route) + EDS (Endpoint)
    Note right of XDS: 协议转换: Istio Model -> Media Sidecar Config
    XDS->>Sidecar: gRPC Stream (Delta xDS) 下发配置
    Sidecar->>Sidecar: 热加载 eBPF Map / 更新 Ring Buffer 参数
    Sidecar-->>XDS: ACK / NACK (配置校验结果)
    XDS-->>Pilot: 聚合上报配置同步状态

// xdp_main.c
struct bpf_map_def SEC("maps") prog_array = {
    .type = BPF_MAP_TYPE_PROG_ARRAY,
    .key_size = sizeof(__u32),
    .value_size = sizeof(__u32),
    .max_entries = 2, // 0: current, 1: next (staging)
};

// 入口程序：仅做分发
SEC("xdp/entry")
int xdp_entry(struct xdp_md *ctx) {
    // 关键：读取当前生效版本索引 (原子读取)
    __u32 *ver = bpf_map_lookup_elem(&version_map, &key_zero);
    if (!ver) return XDP_PASS;
    
    // 尾调用跳转至具体逻辑程序，不可返回
    return bpf_tail_call(ctx, &prog_array, *ver);
}

// 升级流程 (Control Plane Agent 执行):
// 1. bpf_prog_load 新逻辑 -> fd_new
// 2. bpf_map_update_elem(prog_array, index=1, &fd_new) // 预热槽位
// 3. 验证预热槽位程序可运行 (测试包)
// 4. bpf_map_update_elem(version_map, &key_zero, &new_ver=1) // 原子切换
// 5. 旧程序 fd 引用计数归零后自动卸载

┌────────────────────────────────────────────────────────────────────┐
│                     Key Management Plane (KMP)                     │
│  ┌──────────────┐    ┌──────────────┐    ┌────────────────────┐   │
│  │  Cert Manager│    │  Key Vault   │    │  Policy Engine     │   │
│  │  (Root CA)   │    │  (HSM/KMS)   │    │  (Rotation/Revoke) │   │
│  └──────┬───────┘    └──────┬───────┘    └─────────┬──────────┘   │
└─────────┼───────────────────┼──────────────────────┼──────────────┘
          │ xDS (SDS - Secret Discovery Service)  │
          ▼                                       ▼
┌────────────────────────────────────────────────────────────────────┐
│                      Media Sidecar (Data Plane)                    │
│  ┌─────────────────────┐  ┌────────────────────────────────────┐  │
│  │  DTLS Handshake     │  │  SRTP Crypto Offload (eBPF Map)    │  │
│  │  Offload (Optional) │  │  ┌──────────────────────────────┐  │  │
│  │  - 仅在建联阶段介入 │  │  │ SSRC -> {Key, Salt, ROC, MKI}│  │  │
│  │  - 密钥导出至 Map   │  │  │ 存储于 BPF_MAP_TYPE_LRU_HASH │  │  │
│  └──────────┬──────────┘  │  │ 生命周期随会话自动过期驱逐    │  │  │
│             │             │  └──────────────────────────────┘  │  │
│             ▼             └────────────────────────────────────┘  │
│  ┌────────────────────────────────────────────────────────────┐  │
│  │  Inline Crypto Engine (AES-GCM / AES-CM)                   │  │
│  │  - 利用 NIC IPsec Offload / CPU AES-NI / ARMv8 Crypto Ext  │  │
│  │  - 零拷贝路径上直接加解密，明文**不落用户态内存**             │  │
│  └────────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────────┘

// Media Sidecar Agent (Go) - 处理 DTLS 握手完成回调
func (a *Agent) OnDtlsHandshakeComplete(session *DtlsSession, srtpKeys *SrtpKeyMaterial) {
    // 1. 构造 eBPF Map Key: 由 (Dst IP, Dst Port, SSRC) 组成
    key := MakeSrtpMapKey(session.RemoteAddr, session.Ssrc)
    
    // 2. 值结构体 (对齐 C 结构体)
    val := SrtpMapValue{
        CipherSuite:   srtpKeys.Profile,      // SRTP_AES128_CM_HMAC_SHA1_80
        MasterKey:     srtpKeys.MasterKey,    // 16/32 bytes
        MasterSalt:    srtpKeys.MasterSalt,   // 14 bytes
        ROC:           0,                     // Roll-over Counter 初始化
        KeyDerivationRate: srtpKeys.KDR,      // 通常为 0
        MKI:           srtpKeys.MKI,          // Master Key Identifier
        MKILen:        uint8(len(srtpKeys.MKI)),
        ExpireAt:      uint64(time.Now().Add(session.Timeout).UnixNano()),
    }
    
    // 3. 原子更新 BPF Map (用户态 -> 内核态，无锁)
    // 使用 BPF_F_NO_PREALLOC 标志避免锁竞争
    if err := a.bpfMap.Update(&key, &val, ebpf.UpdateAny); err != nil {
        log.Errorf("SRTP Key Map update failed: %v", err)
        // 触发熔断：拒绝新建流，老流自然老化
    }
    
    // 4. 审计日志 (仅记录元数据)
    audit.Log("SRTP_KEY_INSTALLED", map[string]interface{}{
        "tenant_id": session.TenantID,
        "session_id": session.ID,
        "cipher": srtpKeys.Profile.String(),
        "key_id": HashKeyID(srtpKeys.MasterKey), // 仅记录密钥指纹
    })
}

┌──────────────────┐     ┌──────────────────┐     ┌──────────────────┐
│   Cloud A (VPC)  │     │   Cloud B (VPC)  │     │   On-Prem IDC    │
│  ┌────────────┐  │     │  ┌────────────┐  │     │  ┌────────────┐  │
│  │ Media GW   │◄─┼─────┼─►│ Media GW   │◄─┼─────┼─►│ Media GW   │  │
│  │ (Sidecar)  │  │     │  │ (Sidecar)  │  │     │  │ (Sidecar)  │  │
│  └─────┬──────┘  │     │  └─────┬──────┘  │     │  └─────┬──────┘  │
│        │         │     │        │         │     │        │         │
│  ┌─────▼──────┐  │     │  ┌─────▼──────┐  │     │  ┌─────▼──────┐  │
│  │ SFU Cluster│  │     │  │ SFU Cluster│  │     │  │ SFU Cluster│  │
│  └────────────┘  │     │  └────────────┘  │     │  └────────────┘  │
└────────┬─────────┘     └────────┬─────────┘     └────────┬─────────┘
         │                        │                        │
         └────────────────────────┼────────────────────────┘
                                  ▼
                    ┌─────────────────────────┐
                    │  Global Media Control   │
                    │  Plane (Multi-Cluster)  │
                    │  - Federated xDS        │
                    │  - Global Topology DB   │
                    │  - Cross-Cloud Routing  │
                    └─────────────────────────┘

# 多集群 MediaGateway 资源定义 (Kubernetes Fleet/ClusterSet)
apiVersion: media.mesh.io/v1alpha1
kind: MediaGateway
metadata:
  name: gw-shanghai-aliyun
  namespace: media-system
  labels:
    topology.istio.io/region: cn-shanghai
    topology.istio.io/provider: aliyun
spec:
  # 网关能力声明
  capabilities:
    maxSessions: 50000
    maxBandwidthGbps: 100
    supportedCodecs: [H264, H265, VP8, VP9, OPUS]
    hardwareOffload: ["AES-NI", "QAT", "MLX5_RXP"]
  
  # 对外暴露端点 (自动注册至全局拓扑库)
  endpoints:
    - name: public-vip
      address: 203.0.113.10
      port: 4789
      protocol: VXLAN_UDP
      network: "aliyun-vpc-prod"
    - name: private-peering
      address: 10.0.0.5
      port: 4789
      protocol: VXLAN_UDP
      network: "direct-connect"
  
  # 跨云路由策略
  routingPolicy:
    preferSameProvider: true
    maxLatencyMs: 80
    fallbackRelay: "gw-beijing-backup"

┌─────────────────────────────────────────────────────────────────┐
│                    压测金字塔 (自下而上)                         │
├─────────────────────────────────────────────────────────────────┤
│  L4: 全链路业务压测 (Chaos + Real Traffic Replay)               │
│  - 场景：万人会议 + 网络抖动 + 节点故障 + 配置变更               │
│  - 目标：验证 SLA/SLO、熔断降级、灾备切换有效性                 │
├─────────────────────────────────────────────────────────────────┤
│  L3: 集群水位压测 (Soak Test / Stability Test)                  │
│  - 场景：7x24h 满载运行 + 慢慢注入内存泄漏/CPU 抖动             │
│  - 目标：验证内存/CPU/句柄/连接数无泄漏，指标收敛稳定           │
├─────────────────────────────────────────────────────────────────┤
│  L2: 单节点极限性能压测 (Micro-benchmark)                       │
│  - 场景：单 Sidecar 最大 PPS/Gbps、延迟分布、零拷贝效率         │
│  - 目标：摸清硬件天花板，产出「容量模型参数」                   │
├─────────────────────────────────────────────────────────────────┤
│  L1: 组件单元压测 (Unit Perf Test)                              │
│  - 场景：eBPF Map 查找延迟、Ring Buffer 入队出队延迟、加解密吞吐│
│  - 目标：定位热点函数，指导代码优化                             │
└─────────────────────────────────────────────────────────────────┘

# capacity_planner.py
class MediaNodeCapacity:
    def __init__(self, cpu_cores=32, nic_speed_gbps=25, mem_gb=64):
        self.cpu_cores = cpu_cores
        self.nic_speed_bps = nic_speed_gbps * 1e9
        self.mem_bytes = mem_gb * 1024**3
        
        # 单流基线画像 (1080p30 + Opus Audio)
        self.per_stream = {
            'bitrate_bps': 3.5e6,      # 3.5 Mbps (含 FEC 20%)
            'pps': 2500,               # 视频 1500 + 音频 500 + RTCP 500
            'cpu_cycles_per_pkt': 320, # AF_XDP 零拷贝路径实测值
            'state_mem_bytes': 2.5e3,  # SRTP Key + ROC + QoS Context + Ring Buffer Share
        }
    
    def max_streams_by_cpu(self) -> int:
        # 预留 20% CPU 给 OS/Monitoring/Control Plane
        available_cycles = self.cpu_cores * 2.6e9 * 0.8  # 2.6 GHz
        cycles_per_stream_per_sec = self.per_stream['pps'] * self.per_stream['cpu_cycles_per_pkt']
        return int(available_cycles / cycles_per_stream_per_sec)
    
    def max_streams_by_nic(self) -> int:
        # 预留 15% 带宽给信令/控制/重传
        return int(self.nic_speed_bps * 0.85 / self.per_stream['bitrate_bps'])
    
    def max_streams_by_mem(self) -> int:
        # 预留 10GB 给系统/HugePages 元数据
        return int((self.mem_bytes - 10*1024**3) / self.per_stream['state_mem_bytes'])
    
    def bottleneck(self) -> dict:
        limits = {
            'cpu': self.max_streams_by_cpu(),
            'nic': self.max_streams_by_nic(),
            'mem': self.max_streams_by_mem(),
        }
        bottleneck = min(limits, key=limits.get)
        return {'limits': limits, 'bottleneck': bottleneck, 'max_safe': int(limits[bottleneck] * 0.8)}

# 运行结果示例 (32C/25G/64G 节点):
# {'limits': {'cpu': 9200, 'nic': 6071, 'mem': 21500}, 'bottleneck': 'nic', 'max_safe': 4856}
# 结论：网卡带宽是瓶颈，安全水位 4800 并发流/节点，建议扩容 25G->100G NIC 或横向扩展

{
  "dashboard": {
    "title": "Media Mesh - Golden Signals (RED + USE)",
    "panels": [
      {
        "title": "Rate: Media Streams Ingress (streams/s)",
        "targets": [{"expr": "rate(media_streams_created_total[1m])", "legendFormat": "{{tenant}}/{{cluster}}"}],
        "alert": {"conditions": [{"evaluator": {"params": [1000], "type": "gt"}, "query": {"params": ["A", "5m", "now"]}}]}
      },
      {
        "title": "Errors: Packet Loss Rate (Post-FEC)",
        "targets": [{"expr": "sum(rate(media_packets_lost_total[1m])) by (tenant) / sum(rate(media_packets_received_total[1m])) by (tenant)", "legendFormat": "{{tenant}}"}],
        "thresholds": [{"colorMode": "critical", "fill": true, "line": true, "op": "gt", "value": 0.005}]
      },
      {
        "title": "Duration: E2E Latency P50/P95/P99 (ms)",
        "targets": [
          {"expr": "histogram_quantile(0.50, sum(rate(media_e2e_latency_bucket[5m])) by (le, tenant))", "legendFormat": "P50"},
          {"expr": "histogram_quantile(0.99, sum(rate(media_e2e_latency_bucket[5m])) by (le, tenant))", "legendFormat": "P99"}
        ]
      },
      {
        "title": "Saturation: Sidecar CPU Utilization (USE)",
        "targets": [{"expr": "avg by (pod) (rate(container_cpu_usage_seconds_total{container='media-sidecar'}[1m])) * 100", "legendFormat": "{{pod}}"}],
        "thresholds": [{"value": 70, "op": "gt", "colorMode": "warning"}, {"value": 85, "op": "gt", "colorMode": "critical"}]
      },
      {
        "title": "Saturation: XDP Queue Depth (Backpressure Signal)",
        "targets": [{"expr": "max by (pod, queue_id) (media_xdp_ring_depth)", "legendFormat": "{{pod}}-Q{{queue_id}}"}],
        "alert": {"conditions": [{"evaluator": {"params": [8192], "type": "gt"}, "query": {"params": ["A", "2m", "now"]}}]}
      }
    ]
  }
}