> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/deployment/hi/self-hosted/enterprise/stream-management-api.md).

# Stream प्रबंधन API

Stream Management API के साथ Roboflow Inference वीडियो pipelines को दूरस्थ रूप से प्रबंधित करें - इसे Docker में चलाएँ, HTTP के माध्यम से एकीकृत करें, और Stream Manager protocol का उपयोग करें।

{% hint style="warning" %}
एक स्वतंत्र सेवा के रूप में बंद कर दी गई है। स्वयं होस्ट की गई वीडियो प्रोसेसिंग के लिए, Inference SDK WebRTC क्लाइंट का उपयोग करें, साथ में [Inference Server](https://docs.roboflow.com/deployment/hi/self-hosted/inference-server.md)। नए प्रबंधित लाइव-कैमरा डिप्लॉयमेंट के लिए, उपयोग करें [Cloud Streaming](https://docs.roboflow.com/deployment/hi/roboflow-cloud/cloud-streaming.md)। कोई विकल्प चुनने के लिए देखें [वीडियो प्रोसेसिंग](https://docs.roboflow.com/workflows/deploy/video-processing) ।
{% endhint %}

{% hint style="warning" %}
इस पेज पर दी गई स्वतंत्र सेवा को प्रोडक्शन में उपयोग करने के लिए Roboflow Enterprise लाइसेंस आवश्यक है। विवरण के लिए देखें [Roboflow लाइसेंसिंग](https://roboflow.com/licensing) । Inference के मौजूदा रिलीज़ में अब इसका सोर्स, Docker Compose फ़ाइलें या Dockerfile शामिल नहीं हैं। नीचे प्रकाशित इमेज अब अपडेट नहीं की जातीं। API में प्रमाणीकरण नहीं है और यह सभी इंटरफ़ेस पर सुनता है: इसे केवल किसी विश्वसनीय नेटवर्क पर या फ़ायरवॉल अथवा प्रमाणीकरण वाले प्रॉक्सी के पीछे चलाएँ। मौजूदा Inference Server में वीडियो के लिए देखें [वीडियो कॉन्फ़िगरेशन](https://docs.roboflow.com/deployment/hi/self-hosted/inference-server/configuration/video-configuration.md).
{% endhint %}

## परिचय

Stream Management API, ऑनलाइन वीडियो स्ट्रीम पर Roboflow ऑब्जेक्ट डिटेक्शन मॉडल से अनुमान उत्पन्न करता था। इसमें वीडियो वर्कर्स को दूर से नियंत्रित करने के लिए एक HTTP प्रबंधन परत जोड़ी गई थी।

यह कई परिस्थितियों में उपयोगी है, जिनमें शामिल हैं, लेकिन इन्हीं तक सीमित नहीं:

* एक साथ कई ऑनलाइन वीडियो स्ट्रीम पर अनुमान चलाना।
* ऐसे कई डिवाइसों पर अनुमान चलाना जिनके बीच समन्वय आवश्यक हो।
* वीडियो प्रोसेसिंग की निगरानी के लिए एक मॉनिटरिंग परत स्थापित करना।

![Stream Management का डिज़ाइन](https://storage.googleapis.com/com-roboflow-marketing/inference/stream_management_api_design.jpg)

### उपयोग का उदाहरण

Joe अपने कारखाने में लगाए गए IP कैमरों के समूह से रिकॉर्ड किए गए फ़ुटेज में वस्तुओं की निगरानी करना चाहता है। Roboflow प्लेटफ़ॉर्म पर ऑब्जेक्ट डिटेक्शन मॉडल को प्रशिक्षित करने के बाद, वह उसे डिप्लॉय करने के लिए तैयार है। कारखाने में चार कैमरे होने के कारण, Joe ऐसा कॉम्पैक्ट मॉडल चुनता है जो उसके Jetson डिवाइसों पर प्रति सेकंड 30 से अधिक अनुमान चला सके। प्रत्येक डिवाइस के लिए उपलब्ध कंप्यूटिंग क्षमता को देखते हुए, सभी कैमरों के फ़ुटेज को संसाधित करने के लिए उसे दो Jetson डिवाइस चाहिए, ताकि हर वीडियो स्रोत पर लगभग 15 फ़्रेम प्रति सेकंड संसाधित किए जा सकें।

डिप्लॉयमेंट को आसान बनाने के लिए, Joe अपने स्थानीय नेटवर्क के सभी Jetson डिवाइसों पर Stream Management कंटेनर डिप्लॉय करता है। इससे वह प्रोसेसिंग कार्यों का संचालन करने के लिए HTTP के ज़रिए प्रत्येक डिवाइस से संपर्क कर सकता है। वह डिवाइसों को कमांड भेजने और हर वीडियो स्ट्रीम की स्थिति के बारे में मेट्रिक्स प्राप्त करने के लिए एक वेब ऐप बनाता है। अंत में, वह अनुमान प्राप्त करने के लिए UDP सर्वर लागू करता है और फ़ुटेज में वस्तुओं को ट्रैक करने के लिए `supervision` पैकेज का उपयोग करता है।

## कैसे चलाएँ

### Docker में

{% tabs %}
{% tab title="CPU" %}

```bash
docker run -d --name stream_manager --network host roboflow/roboflow-inference-stream-manager-cpu:latest
docker run -d --name stream_management_api --network host roboflow/roboflow-inference-stream-management-api:latest
```

{% endtab %}

{% tab title="GPU" %}

```bash
docker run -d --name stream_manager --network host --runtime nvidia roboflow/roboflow-inference-stream-manager-gpu:latest
docker run -d --name stream_management_api --network host roboflow/roboflow-inference-stream-management-api:latest
```

{% endtab %}

{% tab title="Jetson (JetPack 5.1.1)" %}

```bash
docker run -d --name stream_manager --network host --runtime nvidia roboflow/roboflow-inference-stream-manager-jetson-5.1.1:latest
docker run -d --name stream_management_api --network host roboflow/roboflow-inference-stream-management-api:latest
```

{% endtab %}
{% endtabs %}

#### कॉन्फ़िगरेशन पैरामीटर

Stream Management API:

* `STREAM_MANAGER_HOST` - स्ट्रीम मैनेजर कंटेनर का होस्टनेम। यदि `--network host` का उपयोग नहीं किया गया है, या आप किसी रिमोट मशीन को लक्ष्य बना रहे हैं, तो इसे कंटेनर के नाम से बदलें।
* `STREAM_MANAGER_PORT` - स्ट्रीम मैनेजर से संपर्क करने के लिए इस्तेमाल किया जाने वाला पोर्ट। इसका मान स्ट्रीम मैनेजर कंटेनर के पोर्ट से मेल खाना चाहिए।

Stream Manager:

* `PORT` - वह पोर्ट जिस पर सर्वर चलता है।
* मॉडल को स्थायी रूप से संग्रहीत करने और इन्फ़रेंस पाइपलाइन के आरंभ को तेज़ करने के लिए, कंटेनर के `/tmp/cache` पर एक वॉल्यूम माउंट करें।
* इस कंटेनर के स्तर पर कैमरा कनेक्टिविटी सक्षम होनी चाहिए। इसलिए, यदि डिवाइसों को Docker में पास करना आवश्यक है, तो ऐसा यहीं करें।

## इंटीग्रेट कैसे करें

चलाने के बाद `roboflow-inference-stream-management-api` कंटेनर, HTTP API यहाँ उपलब्ध है `http://127.0.0.1:8080` डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ।

कॉल करें `wget http://127.0.0.1:8080/openapi.json` API की OpenAPI विशिष्टता प्राप्त करने के लिए, जिसे आप इसमें रेंडर कर सकते हैं [Swagger संपादक](https://editor.swagger.io/).

Python क्लाइंट का एक उदाहरण:

```python
import requests
from typing import Optional

URL = "http://127.0.0.1:8080"

def list_pipelines() -> dict:
    response = requests.get(f"{URL}/list_pipelines")
    return response.json()


def get_pipeline_status(pipeline_id: str) -> dict:
    response = requests.get(f"{URL}/status/{pipeline_id}")
    return response.json()


def pause_pipeline(pipeline_id: str) -> dict:
    response = requests.post(f"{URL}/pause/{pipeline_id}")
    return response.json()


def resume_pipeline(pipeline_id: str) -> dict:
    response = requests.post(f"{URL}/resume/{pipeline_id}")
    return response.json()


def terminate_pipeline(pipeline_id: str) -> dict:
    response = requests.post(f"{URL}/terminate/{pipeline_id}")
    return response.json()


def initialise_pipeline(
    video_reference: str,
    model_id: str,
    api_key: str,
    sink_host: str,
    sink_port: int,
    max_fps: Optional[int] = None,
) -> dict:
    response = requests.post(
        f"{URL}/initialise",
        json={
            "type": "init",
            "sink_configuration": {
                "type": "udp_sink",
                "host": sink_host,
                "port": sink_port,
            },
            "video_reference": video_reference,
            "model_id": model_id,
            "api_key": api_key,
            "max_fps": max_fps,
        },
    )
    return response.json()
```

{% hint style="info" %}
`initialise_pipeline()` को यह देना आवश्यक है: `video_reference` और `sink_configuration` जहाँ हर संसाधन (वीडियो फ़ाइल या कैमरा डिवाइस) और URI (स्ट्रीम संदर्भ, सिंक संदर्भ), Stream Manager परिवेश से पहुँच योग्य हो। उदाहरण के लिए, Docker कंटेनरों के भीतर `localhost` कंटेनर के localhost से जुड़ता है, होस्ट मशीन के localhost से नहीं।
{% endhint %}

## डेवलपर नोट्स

कार्यान्वयन का प्रमुख घटक Stream Manager है, जो एकल-थ्रेड वाले TCP सर्वर के रूप में काम करता है। यह TCP सॉकेट से प्राप्त अनुरोधों को संसाधित करता है और वीडियो वर्कर प्रक्रियाओं की निगरानी करता है। वर्करों और Stream Manager के बीच कमांड और परिणाम पहुँचाने के लिए मल्टीप्रोसेसिंग क्यू का उपयोग होता है।

Stream Manager को भेजे गए अनुरोधों को ब्लॉकिंग मोड में क्रमिक रूप से संभाला जाता है, इसलिए अगले अनुरोध के शुरू होने से पहले हर अनुरोध पूरा होना चाहिए।

### संचार प्रोटोकॉल: अनुरोध

Stream Manager निम्नलिखित बाइनरी प्रोटोकॉल स्वीकार करता है। हर पेलोड में शामिल होता है:

```
[HEADER: 4B, big-endian, unsigned - संदेश के आकार वाला int मान][MESSAGE: हेडर द्वारा निर्धारित आकार का utf-8 क्रमबद्ध json]
```

डिकोड करने के बाद संदेश वैध JSON होना चाहिए और उसमें एक वैध कमांड होना चाहिए।

`list_pipelines`:

```json
{
  "type": "list_pipelines"
}
```

`init`:

```json
{
  "type": "init",
  "model_id": "some/1",
  "video_reference": "rtsp://192.168.0.1:554",
  "sink_configuration": {
    "type": "udp_sink",
    "host": "192.168.0.3",
    "port": 9999
  },
  "api_key": "YOUR_API_KEY",
  "max_fps": 16,
  "model_configuration": {
    "type": "object-detection",
    "class_agnostic_nms": true,
    "confidence": 0.5,
    "iou_threshold": 0.4,
    "max_candidates": 300,
    "max_detections": 3000
  },
  "video_source_properties": {
    "frame_width": 1920,
    "frame_height": 1080,
    "fps": 30
  }
}
```

{% hint style="info" %}
मॉडल ID इस स्ट्रिंग से बनता है `<project_id>/<version_id>`। इन मानों को खोजने के लिए देखें [मॉडल ID](https://docs.roboflow.com/models/model-ids) ।
{% endhint %}

`terminate`:

```json
{
  "type": "terminate",
  "pipeline_id": "my_pipeline"
}
```

`pause`:

```json
{
  "type": "mute",
  "pipeline_id": "my_pipeline"
}
```

`resume`:

```json
{
  "type": "resume",
  "pipeline_id": "my_pipeline"
}
```

`status`:

```json
{
  "type": "status",
  "pipeline_id": "my_pipeline"
}
```

### संचार प्रोटोकॉल: प्रतिक्रियाएँ

हर ऐसे अनुरोध के लिए जिसे संसाधित किया जा सकता है (टाइमआउट या स्रोत से कनेक्शन टूटने के बिना), Stream Manager इस प्रारूप में परिणाम लौटाता है:

```
[HEADER: 4B, big-endian, unsigned - परिणाम के आकार वाला int मान][RESULT: हेडर द्वारा निर्धारित आकार का utf-8 क्रमबद्ध json]
```

परिणाम में शामिल हैं:

* `request_id` - Stream Manager द्वारा दिया गया अनुरोध ID दर्शाने वाली एक यादृच्छिक स्ट्रिंग, जिससे डीबग करना आसान हो जाता है।
* `pipeline_id` - लागू होने पर, वह पाइपलाइन जिससे कमांड संबंधित है।
* `response` - ऑपरेशन की प्रतिक्रिया का पेलोड।

हर `response` में एक `status` कुंजी होती है, जिसका मान इन दो में से एक होता है: `success` या `failure`। हर विफल प्रतिक्रिया में एक `error_type` कुंजी होती है, जो त्रुटि-हैंडलिंग को भेजने के लिए उपयोग की जाती है, साथ ही वैकल्पिक `error_class` और `error_message` फ़ील्ड होते हैं, जिनमें त्रुटि का आंतरिक विवरण होता है। सफल प्रतिक्रियाओं की सामग्री ऑपरेशन के प्रकार पर निर्भर करती है।
