> 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 Management API

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

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

{% hint style="warning" %}
**एंटरप्राइज़ सुविधा।** इस पृष्ठ पर मौजूद स्वतंत्र सेवा को उत्पादन में उपयोग करने के लिए Roboflow Enterprise लाइसेंस की आवश्यकता है। देखें [Roboflow लाइसेंसिंग](https://roboflow.com/licensing) विवरण के लिए। यह ऊपर वर्णित एकीकृत वीडियो प्रबंधन API पर लागू नहीं होता।
{% endhint %}

वर्तमान एकीकृत सर्वर के अलग [वीडियो कॉन्फ़िगरेशन मार्गदर्शन](/deployment/hi/self-hosted/inference-server/configuration/video-configuration.md), जिसमें इसकी प्रबंधित प्रक्रिया सीमा भी शामिल है। लंबित मीडिया-रेफ़रेंस सत्यापन इस एंटरप्राइज़ सेवा की अनुरोध स्कीमा को भी कवर करता है; देखें [उस build में False](/deployment/hi/self-hosted/inference-server/configuration/security-migration.md#video-source-validation).

## के बारे में

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

यह निम्नलिखित सहित, लेकिन इन्हीं तक सीमित नहीं, परिदृश्यों के लिए उपयोगी है:

* एक साथ कई ऑनलाइन वीडियो स्ट्रीम्स पर इन्फ़रेंस करना।
* समन्वय की आवश्यकता वाले कई उपकरणों पर इन्फ़रेंस निष्पादित करना।
* वीडियो प्रोसेसिंग की निगरानी के लिए एक मॉनिटरिंग परत स्थापित करना।

![स्ट्रीम प्रबंधन डिज़ाइन](https://storage.googleapis.com/com-roboflow-marketing/inference/stream_management_api_design.jpg)

### उदाहरण उपयोग-मामला

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

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

## कैसे चलाएँ

### Docker में `docker compose`

सबसे सामान्य उपयोग-मामले Docker Compose कॉन्फ़िगरेशन के रूप में पैकेज किए गए हैं। जहाँ कंटेनरों के भीतर कस्टम कॉन्फ़िगरेशन की आवश्यकता होती है, जैसे कैमरा डिवाइसों को पास करना, वहाँ नीचे दिए गए अलग-कंटेनर विकल्प अधिक उपयुक्त हो सकते हैं।

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

```bash
docker compose -f ./docker/dockerfiles/stream-management-api.compose-cpu.yaml up
```

{% endtab %}

{% tab title="GPU" %}

```bash
docker compose -f ./docker/dockerfiles/stream-management-api.compose-gpu.yaml up
```

{% endtab %}

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

```bash
docker compose -f ./docker/dockerfiles/stream-management-api.compose-jetson.5.1.1.yaml up
```

Jetson उपकरणों पर, कुछ ऑपरेशंस (जैसे कंटेनर बूटस्ट्रैप या मॉडल आरंभिकरण) अन्य प्लेटफ़ॉर्म्स की तुलना में अधिक समय लेते हैं। Docker Compose परिभाषा वर्तमान में Stream Manager TCP सॉकेट पोर्ट के खुलने की प्रतीक्षा नहीं करती, इसलिए HTTP API के प्रारंभिक अनुरोधों का उत्तर HTTP 503 के साथ दिया जा सकता है।
{% endtab %}
{% endtabs %}

### Docker में, API और stream manager को अलग-अलग चलाना

{% 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 %}

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

**स्ट्रीम प्रबंधन API**

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

**स्ट्रीम प्रबंधक**

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

#### इमेज बनाना (वैकल्पिक)

```bash
# स्ट्रीम प्रबंधन API
docker build -t roboflow/roboflow-inference-stream-management-api:dev -f docker/dockerfiles/Dockerfile.stream_management_api .

# स्ट्रीम प्रबंधक
docker build -t roboflow/roboflow-inference-stream-manager-{device}:dev -f docker/dockerfiles/Dockerfile.onnx.{device}.stream_manager .
```

### बारे-मेटल परिनियोजन

कुछ मामलों में आपको एप्लिकेशन को होस्ट स्तर पर परिनियोजित करना पड़ता है। यह संभव है, लेकिन आपको अपने प्लेटफ़ॉर्म के लिए उसी तरह पर्यावरण को सेट करना होगा जैसा Stream Manager और Stream Management API Dockerfile करते हैं। एक बार यह हो जाए, तो चलाएँ:

```bash
python -m inference.enterprise.stream_management.manager.app  # प्रबंधक चलाता है
python -m inference.enterprise.stream_management.api.app      # प्रबंधन API चलाता है
```

## कैसे एकीकृत करें

को चलाने के बाद `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 value with message size][MESSAGE: utf-8 serialised json of size dictated by header]
```

डिकोड करने के बाद संदेश मान्य 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>`. देखें [मॉडल IDs](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 value with result size][RESULT: utf-8 serialised json of size dictated by header]
```

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

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

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

## भविष्य का कार्य

* सुरक्षित दूरस्थ नियंत्रण सक्षम करने के लिए API कनेक्शन परत को सुरक्षित करना।
* Stream Manager के TCP सॉकेट को सुरक्षित करना।