> 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/workflows/hi/deploy/deploy-a-workflow.md).

# Workflow तैनात करें

प्रबंधित लाइव कैमरों के लिए Cloud Streaming, अनुरोधों के लिए Cloud API, संग्रहीत डेटा के लिए Batch Processing, या अपना स्वयं का रनटाइम चुनें।

इनपुट और प्रोसेसिंग कितनी देर तक चलनी चाहिए, इसके आधार पर चुनें कि अपना Workflow कैसे चलाना है।

<table data-search="false"><thead><tr><th>विकल्प</th><th>इसके लिए सबसे उपयुक्त</th></tr></thead><tbody><tr><td><a href="https://docs.roboflow.com/deployment/roboflow-cloud/cloud-streaming">क्लाउड स्ट्रीमिंग</a></td><td>प्रबंधित क्लाउड कंप्यूट पर लाइव कैमरे, जिसमें स्रोत सेटअप, प्रीव्यू, निरंतर डिप्लॉयमेंट और स्पष्ट रूप से रोकने के नियंत्रण शामिल हैं।</td></tr><tr><td>HTTP API</td><td>होस्ट किए गए या खुद होस्ट किए गए एंडपॉइंट पर अलग-अलग इमेज अनुरोध।</td></tr><tr><td><a href="https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments">समर्पित डिप्लॉयमेंट</a></td><td>आपके उपयोग के लिए प्रावधान किया गया निजी क्लाउड रनटाइम।</td></tr><tr><td><a href="https://docs.roboflow.com/workflows/hi/deploy/video-processing.md">खुद होस्ट की गई वीडियो प्रोसेसिंग</a></td><td>वेबकैम, नेटवर्क कैमरे या फ़ाइलें, जिन्हें आपके अपने Inference Server पर प्रोसेस किया जाता है।</td></tr><tr><td><a href="https://docs.roboflow.com/deployment/roboflow-cloud/batch-processing">बैच प्रोसेसिंग</a></td><td>संग्रहीत इमेज और वीडियो पर सीमित अवधि के एसिंक्रोनस जॉब।</td></tr><tr><td><a href="https://docs.roboflow.com/reference/inference/inference-cli/workflows">Inference CLI</a></td><td>कमांड लाइन से इमेज, डायरेक्टरी या वीडियो फ़ाइलें।</td></tr><tr><td>Inference Python पैकेज</td><td>आपके एप्लिकेशन के भीतर <a href="https://docs.roboflow.com/workflows/hi/developer-guide/developer-guide/execution-engine.md#running-the-execution-engine-in-python">Execution Engine</a> का उपयोग, बिना HTTP अनुरोध के।</td></tr></tbody></table>

{% hint style="warning" %}
Serverless Cloud API पर प्रति-अनुरोध Workflow निष्पादन की दो सीमाएँ हैं, जिन्हें ध्यान में रखना चाहिए:

* Workflow का रनटाइम अधिकतम 20 सेकंड तक सीमित है।
* रिस्पॉन्स पेलोड अधिकतम 6 MB तक सीमित है, इसलिए कई विज़ुअलाइज़ेशन ब्लॉक वाले या बड़ी इनपुट इमेज वाले Workflows विफल हो सकते हैं।

ये अनुरोध सीमाएँ Cloud Streaming जॉब पर लागू नहीं होतीं। खुद होस्ट किए गए और समर्पित डिप्लॉयमेंट की अपनी रनटाइम कॉन्फ़िगरेशन होती है।
{% endhint %}

अगर आप अपना Workflow अपने हार्डवेयर पर चलाते हैं, तो इसे इमेज और वीडियो फ़ाइलों—जिनमें सामान्य **वेबकैम** और पेशेवर **CCTV कैमरों**).

की स्ट्रीम भी शामिल हैं—पर चला सकते हैं। ऑन-प्रिमाइसेस डिप्लॉयमेंट चुनकर, आप Workflow को किसी भी ऐसे सिस्टम पर चला सकते हैं जहाँ Inference डिप्लॉय किया जा सकता है। इसमें शामिल हैं:

* NVIDIA Jetson
* AWS EC2, GCP Cloud Engine और Azure Virtual Machines
* Raspberry Pi

{% hint style="info" %}
Roboflow Enterprise ग्राहकों को वीडियो स्ट्रीम के अतिरिक्त विकल्प उपलब्ध हैं, जैसे Basler कैमरों पर इन्फ़रेंस चलाना। हमारी पेशकशों के बारे में अधिक जानने के लिए, [Roboflow की सेल्स टीम से संपर्क करें](https://roboflow.com/sales).
{% endhint %}

### Workflow डिप्लॉय करें

डिप्लॉयमेंट का तरीका चुनने के लिए Workflow एडिटर में "डिप्लॉय करें" पर क्लिक करें। किसी कनेक्टेड लाइव स्रोत के लिए "Cloud Streaming" चुनें, या नीचे दिए गए संबंधित API या खुद होस्ट करने के निर्देशों का उपयोग करें।

आपके Workflows एडिटर के कोड स्निपेट में आपका Workflows URL और API key पहले से भरे होंगे।

स्निपेट उस रनटाइम के अनुसार होते हैं, जिस पर आपका एडिटर चल रहा है। अगर आप एडिटर को स्थानीय Inference सर्वर या [समर्पित डिप्लॉयमेंट](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments)पर स्विच करते हैं, तो हर स्निपेट में मौजूद `api_url` उस सर्वर की ओर इंगित करेगा और उससे मेल खाने वाले टैब को अनुशंसित के रूप में चिह्नित किया जाएगा। अगर आपके सेव किए गए Workflow प्रीव्यू में कोई उदाहरण इमेज है, तो वह भी स्निपेट में अपने आप भर दी जाएगी।

{% hint style="info" %}
Workflows की उपयोग सीमाओं के बारे में अधिक जानने के लिए, [Roboflow की मूल्य निर्धारण वाली पेज](https://roboflow.com/workflows).
{% endhint %}

#### इमेज प्रोसेस करें

आप Roboflow API या स्थानीय Inference सर्वर का उपयोग करके अपने Workflow को एकल इमेज पर चला सकते हैं।

पहले, Roboflow Inference SDK इंस्टॉल करें:

```bash
pip install inference-sdk inference-cli
```

अगर आप इसे स्थानीय रूप से चलाते हैं, तो अपनी मशीन पर Docker इंस्टॉल करने और Inference सर्वर शुरू करने के लिए [Docker इंस्टॉलेशन के आधिकारिक निर्देशों](https://docs.docker.com/get-docker/) का पालन करें:

```
inference server start
```

इसके बाद, एक नई Python फ़ाइल बनाएँ और उसमें निम्नलिखित कोड जोड़ें:

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",  # or "http://127.0.0.1:9001" for local deployment
    api_key="API_KEY"
).configure(InferenceConfiguration(api_key_transport="header"))

result = client.run_workflow(
    workspace_name="workspace-name",
    workflow_id="workflow-id",
    images={
        "image": "YOUR_IMAGE.jpg"
    }
)

```

ऊपर, `API_KEY` को अपनी Roboflow API कुंजी से बदलें। `workspace-name` और `workflow-id` को अपने Roboflow वर्कस्पेस नाम और Workflow ID से बदलें।

ये मान खोजने के लिए, अपना Roboflow Workflow खोलें और "Deploy Workflow" पर क्लिक करें। फिर, पेज पर दिखाई देने वाले कोड स्निपेट से अपना वर्कस्पेस नाम और Workflow ID कॉपी करें।

स्थानीय निष्पादन CPU और NVIDIA CUDA GPU डिवाइसों पर काम करता है। बेहतरीन प्रदर्शन के लिए, GPU-सक्षम डिवाइस, जैसे NVIDIA Jetson, या NVIDIA GPU वाले क्लाउड सर्वर पर डिप्लॉय करें।

यदि आप किसी भी भाषा से सीधे एंडपॉइंट को कॉल करना चाहते हैं, तो HTTP अनुरोध भेजें:

```bash
curl --location 'https://serverless.roboflow.com/infer/workflows/<your-workspace-name>/<your-workflow-id>' \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <YOUR-API-KEY>' \
    --data '{
    "inputs": {
        "image": {"type": "url", "value": "https://your-image-url"},
        "parameter": "some-value"
    }
}'
```

{% hint style="info" %}
कुंजी को `?api_key=` क्वेरी पैरामीटर के रूप में या `api_key` बॉडी फ़ील्ड के रूप में भेजना पुराना तरीका है। यह अब भी काम करता है, लेकिन `Authorization: Bearer` हेडर आपकी कुंजी को URL और लॉग में आने से बचाता है। देखें [REST API से प्रमाणित करें](https://docs.roboflow.com/reference/platform/rest-api/authenticate-with-the-rest-api).
{% endhint %}

inputs `ऑब्जेक्ट की कुंजियाँ` आपके Workflow से निर्धारित होती हैं, इसलिए इनके नाम आपके द्वारा तय किए गए इनपुट के अनुसार अलग-अलग होते हैं। WorkflowImage के रूप में घोषित इनपुट `WorkflowImage` ऐसा ऑब्जेक्ट लेते हैं जिसमें `type` और `value` कुंजियाँ होती हैं; HTTP पर समर्थित `type` मान हैं `url` और `base64`.

ऊपर दिए गए उदाहरण Roboflow प्लेटफ़ॉर्म पर सहेजे गए Workflow को चलाते हैं। आप अनुरोध के साथ Workflow की पूरी परिभाषा भी भेज सकते हैं। यह शुरुआत से बनाए गए उन Workflows के लिए उपयोगी है जिनमें API-कुंजी से सुरक्षित ब्लॉक नहीं होते। देखें [Inference SDK](https://docs.roboflow.com/reference/inference/inference-sdk/workflows) के लिए `specification` तर्क।

#### वीडियो स्ट्रीम प्रोसेस करें

प्रबंधित लाइव कैमरों के लिए, इसका उपयोग करें [Cloud Streaming](https://docs.roboflow.com/deployment/roboflow-cloud/cloud-streaming)। "Deploy" पर क्लिक करें, फिर "Cloud Streaming" चुनें, कोई स्रोत चुनें, उसके Workflow इनपुट और प्रोसेसिंग अनुमान की समीक्षा करें, फिर प्रोसेसिंग शुरू करें। कैमरा कनेक्ट करने, नतीजे देखने और रन को स्पष्ट रूप से रोकने के लिए [त्वरित शुरुआत](https://docs.roboflow.com/deployment/roboflow-cloud/cloud-streaming/quickstart) का पालन करें।

एडिटर की "Run" कार्रवाई, डिप्लॉयमेंट के साथ ड्राफ़्ट का पूर्वावलोकन कर सकती है। किसी पात्र पूर्वावलोकन को प्रमोट करने पर उसका सटीक रनिंग स्नैपशॉट और बंद किए गए सिंक बरकरार रहते हैं—बिना प्रकाशित किए या फिर से शुरू किए। देखें [Workflow जीवनचक्र](https://docs.roboflow.com/deployment/roboflow-cloud/cloud-streaming/run-a-workflow) निरंतर रन में बदलाव लागू करने से पहले।

अपने Inference Server पर वीडियो के लिए, Inference SDK WebRTC क्लाइंट अब भी उपलब्ध है:

```bash
pip install "inference-sdk[webrtc]"
```

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration
from inference_sdk.webrtc import StreamConfig, WebcamSource

client = InferenceHTTPClient(
    api_url="http://localhost:9001",
    api_key="API_KEY",
).configure(InferenceConfiguration(api_key_transport="header"))

session = client.webrtc.stream(
    source=WebcamSource(),
    workflow="workflow-id",
    workspace="workspace-name",
    config=StreamConfig(data_output=["predictions"]),
)

@session.on_data("predictions")
def handle_predictions(predictions, metadata):
    print(predictions)

session.run()
```

पहले [स्व-होस्ट किया गया Inference Server](https://docs.roboflow.com/deployment/self-hosted/inference-server) शुरू करें और workspace, Workflow तथा API key के मान बदलें। देखें [Workflows के साथ वीडियो प्रोसेसिंग](https://docs.roboflow.com/workflows/hi/deploy/video-processing.md) अन्य स्रोत प्रकारों और आउटपुट प्रबंधन के लिए। यह WebRTC क्लाइंट, Cloud Streaming स्रोत और जॉब API नहीं है।

#### डेटा के बैच प्रोसेस करें

Roboflow Batch Processing सेवा का उपयोग करके आप डेटा के पूरे बैच—छवियों और वीडियो फ़ाइलों की डायरेक्टरी—को कुशलता से प्रोसेस कर सकते हैं। इस पूरी तरह प्रबंधित समाधान के लिए न तो कोडिंग की ज़रूरत है, न ही स्थानीय कंप्यूटेशन की। बस अपना डेटा और Workflow चुनें, और बाकी काम Roboflow पर छोड़ दें।

हम Batch Processing के साथ UI, CLI और REST API—तीनों के माध्यम से काम करने की सुविधा देते हैं। नीचे CLI कमांड दिए गए हैं। जानें [सभी विकल्प](https://docs.roboflow.com/deployment/roboflow-cloud/batch-processing#cli).

प्रोसेसिंग चलाने के लिए, Inference CLI इंस्टॉल करें:

```
pip install inference-cli
```

इसके बाद, आप अपना डेटा जोड़ सकते हैं:

```
inference rf-cloud data-staging create-batch-of-images \
    --images-dir <your-images-dir-path> \
    --batch-id <your-batch-id>
```

डेटा लोड हो जाने पर, प्रोसेसिंग जॉब शुरू करें:

```
inference rf-cloud batch-processing process-images-with-workflow \
    --workflow-id <workflow-id> \
    --batch-id <batch-id>
```

जॉब की प्रगति इस कमांड से देखी जा सकती है:

```
inference rf-cloud batch-processing show-job-details \
    --job-id <your-job-id>  # job-id will be displayed when you create a job
```

और जॉब पूरा हो जाने पर, नतीजे एक्सपोर्ट करें:

```
inference rf-cloud data-staging export-batch \
    --target-dir <dir-to-export-result> \
    --batch-id <output-batch-of-a-job>
```

#### CLI से स्थानीय डायरेक्टरी प्रोसेस करें

जिस मशीन से आप काम कर रहे हैं, उस पर पहले से मौजूद डेटा के लिए, `inference-cli` बिना कोई कोड लिखे, अलग-अलग इमेज, इमेज की डायरेक्टरी या वीडियो फ़ाइल पर वर्कफ़्लो चला सकता है:

```bash
pip install inference-cli
```

```bash
inference workflows process-images-directory \
    -i {your_input_directory} \
    -o {your_output_directory} \
    --workspace_name {your-roboflow-workspace-url} \
    --workflow_id {your-workflow-id} \
    --api-key {your_roboflow_api_key}
```

आउटपुट डायरेक्टरी में हर इनपुट फ़ाइल के लिए एक सबडायरेक्टरी मिलेगी। हर सबडायरेक्टरी में उस फ़ाइल के वर्कफ़्लो परिणामों वाली `results.json` फ़ाइल और निष्पादन के दौरान बनाई गई कोई भी इमेज होगी। साथ ही, एक `aggregated_results.csv` फ़ाइल में हर इनपुट के परिणाम एक साथ जोड़े गए होंगे।

सभी विकल्पों के लिए [Inference CLI संदर्भ](https://docs.roboflow.com/reference/inference/inference-cli/workflows) देखें।

## अगले चरण

* एक्ज़ीक्यूशन इंजन को सीधे अपने Python एप्लिकेशन में चलाएँ: [डेवलपर गाइड](https://docs.roboflow.com/workflows/hi/developer-guide/developer-guide.md).
* वर्कफ़्लो से मिलने वाले परिणामों का स्वरूप समझें: देखें [वर्कफ़्लो निष्पादन](https://docs.roboflow.com/workflows/hi/developer-guide/developer-guide/workflow-execution.md#output-construction).
