AV Chaos Monkey

वीडियो कॉन्फ्रेंसिंग सिस्टम्स के लोड टेस्टिंग के लिए वितरित कैओस इंजीनियरिंग प्लेटफ़ॉर्म। H.264/Opus स्ट्रीम के साथ 1500+ WebRTC प्रतिभागियों का अनुकरण करता है और गिरावट वाली स्थितियों के तहत सिस्टम की लचीलापन को मान्य करने के लिए नेटवर्क कैओस स्पाइक्स इंजेक्ट करता है।

आर्किटेक्चर

1. मीडिया प्रोसेसिंग पाइपलाइन:

   • FFmpeg इनपुट वीडियो को स्टार्टअप पर H.264 Annex-B और Ogg/Opus में बदलता है
   • NAL Reader H.264 स्ट्रीम (SPS/PPS/IDR/Slices) को पार्स करता है
   • Opus Reader Ogg कंटेनर से 20ms ऑडियो फ्रेम्स निकालता है
   • फ्रेम्स मेमोरी में कैश किए जाते हैं, सभी प्रतिभागियों के बीच साझा (शून्य-कॉपी)
   • प्रति-प्रतिभागी एन्कोडिंग की तुलना में CPU ~90% कम करता है

2. कंट्रोल प्लेन:

   • HTTP सर्वर (:8080) REST API के माध्यम से परीक्षण जीवनचक्र प्रबंधित करता है
   • Spike Scheduler कैओस इवेंट वितरित करता है (even/random/front/back/legacy)
   • Network Degrader कैओस लागू करता है: पैकेट लॉस (1-25%), जिटर (10-50ms), बिटरेट कमी (30-80%), फ्रेम ड्रॉप (10-60%)
   • लोडेड कैओस कॉन्फ़िगरेशन प्रतिभागी पूल पर लागू होता है

3. प्रतिभागी पूल:

   • स्वचालित रूप से पॉड्स में विभाजित: participant_id % total_partitions = partition_id
   • प्रत्येक प्रतिभागी RTP स्ट्रीम उत्पन्न करता है (PT=96 वीडियो, PT=111 ऑडियो)
   • प्रतिभागी ID RTP एक्सटेंशन हेडर (ID=1) में एम्बेडेड
   • पूल आकार: 1-100 (लोकल), 100-500 (Docker), 500-1500 (Kubernetes)

4. Kubernetes ऑटो-कॉन्फ़िगरेशन:

   • पॉड्स पॉड नाम से विभाजन ID स्वतः पहचानते हैं: orchestrator-3 → PARTITION_ID=3
   • पोर्ट आवंटन: base_port + (partition_id × 10000) + participant_index
   • उदाहरण: विभाजन 0 5000-14999 का उपयोग करता है, विभाजन 1 15000-24999 का उपयोग करता है
   • 10 रेप्लिका वाला StatefulSet, प्रत्येक ~150 प्रतिभागियों को संभालता है
   • संसाधन: प्रति पॉड 1-4 CPU, 2-4Gi मेमोरी
   • होस्ट मशीन स्पेक्स के आधार पर स्वचालित रूप से कॉन्फ़िगर होता है

5. UDP रिले चेन (केवल Kubernetes):

   ऑर्केस्ट्रेटर पॉड्स (10×) → UDP :5000 → udp-relay पॉड (Python)
   → लेंथ-प्रीफिक्स्ड TCP :5001 → kubectl port-forward 15001:5001
   → tools/udp-relay (Go) → UDP :5002 → आपका रिसीवर
   

   • क्यों: kubectl port-forward केवल TCP समर्थन करता है, UDP नहीं
   • क्लस्टर में रिले: Python स्क्रिप्ट सभी पॉड्स से UDP एकत्र करती है, 2-बाइट लेंथ प्रीफ़िक्स के साथ TCP के रूप में स्ट्रीम करती है
   • लोकल रिले: Go टूल TCP स्ट्रीम को वापस UDP पैकेट में बदलता है
   • 1500 प्रतिभागी स्ट्रीम को एकल कनेक्शन में एकत्रित करता है

6. WebRTC इन्फ्रास्ट्रक्चर:

   • Coturn StatefulSet: 3 प्रारंभिक रेप्लिका, HPA लोड के आधार पर 1-10 स्केल करता है (~500 प्रतिभागी/रेप्लिका)
   • coturn-lb Service: TURN ट्रैफ़िक को रेप्लिका में लोड बैलेंस करता है
   • webrtc-connector: वैकल्पिक प्रॉक्सी लेयर (Deployment + HPA 2-10 रेप्लिका), SDP सिग्नलिंग संभालता है
   • Docker Mode: स्थानीय परीक्षण के लिए एकल Coturn कंटेनर
   • पोर्ट्स: 3478 (TURN), 49152-65535 (रिले रेंज)
   • क्रेडेंशियल्स: webrtc/webrtc123

7. क्लाइंट इंटीग्रेशन:

   • UDP रिसीवर: रिले चेन के माध्यम से सभी प्रतिभागियों से एकत्रित RTP स्ट्रीम प्राप्त करता है
   • WebRTC रिसीवर: TURN सर्वर के माध्यम से SDP आदान-प्रदान के माध्यम से 1:1 WebRTC कनेक्शन स्थापित करता है
   • दोनों आपके वीडियो कॉल सिस्टम (SFU/MCU/Mesh) के परीक्षण के लिए अग्रेषित करते हैं

8. ऑब्ज़र्वेबिलिटी स्टैक (वैकल्पिक):

   • Prometheus: हर 5 सेकंड में सभी ऑर्केस्ट्रेटर पॉड्स से /metrics एंडपॉइंट स्क्रैप करता है
   • Grafana: पूर्व-कॉन्फ़िगर्ड डैशबोर्ड (admin/admin) के माध्यम से मेट्रिक्स विज़ुअलाइज़ करता है
   • एक्सपोज़्ड मेट्रिक्स: प्रतिभागी संख्या, भेजे गए पैकेट, भेजे गए बाइट्स, सक्रिय स्पाइक्स, पैकेट लॉस %, जिटर, MOS स्कोर
   • एक्सेस: Prometheus :30090 पर, Grafana :30030 पर (NodePort)
   • स्वतः-खोज के लिए ऑर्केस्ट्रेटर पॉड्स एनोटेट: prometheus.io/scrape: "true"

मुख्य अवधारणाएँ

प्रतिभागी अनुकरण

प्रत्येक आभासी प्रतिभागी वास्तविक मीडिया स्ट्रीम उत्पन्न करता है:

• वीडियो: वास्तविक वीडियो फ़ाइलों से H.264 NAL इकाइयाँ, RFC 6184 के अनुसार पैकेटीकृत
• ऑडियो: Ogg कंटेनरों से Opus फ्रेम्स, RFC 7587 के अनुसार पैकेटीकृत
• RTP: मानक-अनुरूप हेडर प्रतिभागी ID एक्सटेंशन के साथ
• टाइमिंग: फ्रेम-सटीक टाइमिंग (30fps वीडियो, 20ms ऑडियो पैकेट)

कैओस इंजेक्शन

पाँच स्पाइक प्रकार वास्तविक दुनिया की नेटवर्क स्थितियों का अनुकरण करते हैं:

• पैकेट लॉस: एप्लिकेशन लेयर पर RTP पैकेट छोड़ता है (1-100%)
• नेटवर्क जिटर: विलंबता भिन्नता जोड़ता है (बेस + गाऊसी जिटर)
• बिटरेट कमी: वीडियो एन्कोडिंग को थ्रॉटल करता है (30-80% कमी)
• फ्रेम ड्रॉप: वीडियो फ्रेम्स छोड़ता है (10-60% ड्रॉप दर)
• बैंडविड्थ लिमिटिंग: कुल थ्रूपुट को सीमित करता है

वितरण रणनीतियाँ

स्पाइक्स परीक्षण अवधि में कॉन्फ़िगरेबल रणनीतियों का उपयोग करके वितरित किए जाते हैं:

• Even: जिटर के साथ एकसमान अंतराल (पूर्वानुमेय लोड)
• Random: अप्रत्याशित समय (यथार्थवादी कैओस)
• Front-loaded: शुरुआत में घने स्पाइक्स (रिकवरी परीक्षण)
• Back-loaded: बेसलाइन फिर कैओस (तुलनात्मक परीक्षण)
• Legacy: निश्चित अंतराल टिकर (रनटाइम इंजेक्शन)

विभाजन (Partitioning)

Kubernetes डिप्लॉयमेंट क्षैतिज स्केलिंग के लिए प्रतिभागी विभाजन का उपयोग करते हैं:

• प्रत्येक पॉड हैंडल करता है participant_id % total_partitions == partition_id
• पोर्ट आवंटन: base_port + (partition_id * 10000) + participant_index
• 1-10 पॉड्स में स्वचालित लोड वितरण
• 1500+ प्रतिभागियों तक स्केल (प्रति पॉड 150)

सिस्टम चलाना

1. स्थानीय विकास (नेटिव Go)

सर्वोत्तम: विकास, डिबगिंग, छोटे पैमाने के परीक्षण (1-100 प्रतिभागी)

# ऑर्केस्ट्रेटर शुरू करें
go run cmd/main.go

# दूसरे टर्मिनल में: UDP रिसीवर शुरू करें
go run examples/go/udp_receiver.go 5002

# config/config.json संपादित करके num_participants: 10 सेट करें
# कैओस परीक्षण चलाएँ
go run tools/chaos-test/main.go -config config/config.json

क्या होता है:

• एकल ऑर्केस्ट्रेटर प्रक्रिया :8080 पर
• प्रतिभागी UDP 127.0.0.1:5002 पर भेजते हैं
• कैओस स्पाइक्स HTTP API के माध्यम से इंजेक्ट किए जाते हैं
• रीयल-टाइम मेट्रिक्स हर 2 सेकंड में प्रदर्शित होते हैं

कॉन्फ़िगरेशन (config/config.json):

{
  "base_url": "http://localhost:8080",
  "media_path": "public/rick-roll.mp4",
  "num_participants": 10,
  "duration_seconds": 300,
  "spikes": {
    "count": 20,
    "interval_seconds": 5,
    "types": { "rtp_packet_loss": {...}, "network_jitter": {...} }
  },
  "spike_distribution": {
    "strategy": "random",
    "min_spacing_seconds": 5,
    "jitter_percent": 15
  }
}

---

2. Docker Compose (कंटेनरीकृत)

सर्वोत्तम: पृथक परीक्षण, CI/CD, मध्यम पैमाने के परीक्षण (100-500 प्रतिभागी)

पूर्वापेक्षाएँ:

• Docker Desktop 8-16GB मेमोरी आवंटन के साथ
• docker-compose स्थापित

# ऑर्केस्ट्रेटर कंटेनर बनाएँ और शुरू करें
./scripts/start_everything.sh build

# दूसरे टर्मिनल में: UDP रिसीवर शुरू करें
go run examples/go/udp_receiver.go 5002

# config/config.json संपादित करके num_participants: 100 सेट करें
# कैओस परीक्षण चलाएँ (कंटेनर को लक्ष्य करता है)
go run tools/chaos-test/main.go -config config/config.json

संसाधन सीमाएँ (docker-compose.yaml संपादित करें):

services:
  orchestrator:
    deploy:
      resources:
        limits:
          cpus: "14.0"
          memory: 6G  # अधिक प्रतिभागियों के लिए बढ़ाएँ

स्केलिंग गाइड:

Docker मेमोरी	अधिकतम प्रतिभागी	CPU कोर
8 GB	~100	4
16 GB	~250	8
24 GB	~400	12
32 GB	~500	14

---

3. Nix के साथ Kubernetes (उत्पादन पैमाना)

सर्वोत्तम: बड़े पैमाने के परीक्षण (500-1500 प्रतिभागी), क्षैतिज स्केलिंग, उत्पादन सत्यापन

पूर्वापेक्षाएँ:

• Nix फ्लेक्स सक्षम के साथ
• Docker Desktop या kind क्लस्टर
• kubectl कॉन्फ़िगर किया गया

चरण 1: Nix वातावरण में प्रवेश करें

# Nix प्रदान करता है: Go, Docker, kubectl, kind, ffmpeg
nix develop

# या स्वतः-सक्रियण के लिए direnv का उपयोग करें
echo "use flake" > .envrc
direnv allow