> 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).

# एक वर्कफ़्लो परिनियोजित करें

आप एक वर्कफ़्लो को चार तरीकों से परिनियोजित कर सकते हैं:

1. छवियाँ भेजें [Roboflow API](#process-images) को अपने वर्कफ़्लो का उपयोग करके प्रोसेसिंग के लिए।
2. एक बनाएँ [Roboflow समर्पित परिनियोजन](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) अपने उपयोग के लिए विशेष रूप से प्रावधानित अवसंरचना पर।
3. अपने स्वयं के हार्डवेयर पर अपने वर्कफ़्लो को चलाएँ, [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted).
4. उपयोग करें [बैच प्रोसेसिंग](https://docs.roboflow.com/deployment/roboflow-cloud/batch-processing) बिना कोडिंग के लागत-प्रभावी ढंग से बड़ी मात्रा में डेटा प्रोसेस करने के लिए।

### मुझे कौन-सा विकल्प उपयोग करना चाहिए?

| विकल्प                                                                                       | इसके लिए सर्वोत्तम                                                                                                                                                                                                                         |
| -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **HTTP API** (Roboflow द्वारा होस्ट किया गया, या स्वयं-होस्टेड `इन्फरेंस` सर्वर)             | वर्कफ़्लोज़ को एक स्वतंत्र सेवा के रूप में उपयोग करने, अपने एप्लिकेशन को Python के अलावा किसी अन्य भाषा में रखने, या भारी गणना वाले कामों को समर्पित सर्वरों पर ऑफ़लोड करने के लिए।                                                        |
| [**WebRTC स्ट्रीमिंग**](/workflows/hi/deploy/video-processing.md)                            | Serverless या स्वयं-होस्टेड Inference Server पर वर्कफ़्लो के माध्यम से वीडियो फ़ाइलें, वेबकैम और कैमरा स्ट्रीम प्रोसेस करना।                                                                                                               |
| [**`inference-cli`**](https://docs.roboflow.com/reference/inference/inference-cli/workflows) | बिना कोड के कमांड लाइन से छवियों, डायरेक्टरीज़, या वीडियो फ़ाइलों को प्रोसेस करना।                                                                                                                                                         |
| [**बैच प्रोसेसिंग**](https://docs.roboflow.com/deployment/roboflow-cloud/batch-processing)   | संग्रहीत छवियों और वीडियो पर बड़े असिंक्रोनस जॉब, आपके लिए प्रावधानित अवसंरचना के साथ।                                                                                                                                                     |
| **`इन्फरेंस` Python पैकेज**                                                                  | Execution Engine को सीधे अपने Python एप्लिकेशन के भीतर चलाना, पूर्ण नियंत्रण और बिना किसी HTTP होप के। देखें [Execution Engine](/workflows/hi/developer-guide/developer-guide/execution-engine.md#running-the-execution-engine-in-python). |

{% hint style="warning" %}
Roboflow होस्टेड API पर वर्कफ़्लो चलाने में दो सीमाएँ हैं जिनका ध्यान रखना होगा:

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

स्वयं-होस्टेड और समर्पित परिनियोजन पर ये सीमाएँ नहीं होतीं।
{% endhint %}

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

ऑन-प्रिमाइसेस परिनियोजन चुनकर, आप किसी भी सिस्टम पर वर्कफ़्लोज़ चला सकते हैं जहाँ आप 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 %}

### एक वर्कफ़्लो परिनियोजित करें

वर्कफ़्लो परिनियोजित करने के लिए, Workflows एडिटर के ऊपरी बाएँ कोने में "Deploy" बटन पर क्लिक करें। इस पृष्ठ पर सभी परिनियोजन विकल्पों का दस्तावेज़ दिया गया है।

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

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

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

#### छवियों को प्रोसेस करें

आप Roboflow API या स्थानीय Inference सर्वर का उपयोग करके एकल छवियों पर अपने वर्कफ़्लो को चला सकते हैं।

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

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

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

```
inference server start
```

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

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",  # या स्थानीय परिनियोजन के लिए "http://127.0.0.1:9001"
    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 key से। बदलें `workspace-name` और `workflow-id` को अपने Roboflow workspace name और Workflow IDs से।

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

स्थानीय निष्पादन CPU और NVIDIA CUDA GPU डिवाइसों पर काम करता है। सर्वोत्तम प्रदर्शन के लिए, NVIDIA Jetson या NVIDIA GPU वाले क्लाउड सर्वर जैसे 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` हेडर आपकी कुंजी को URLs और लॉग्स से बाहर रखता है। देखें [REST API से प्रमाणीकरण करें](https://docs.roboflow.com/reference/platform/rest-api/authenticate-with-the-rest-api).
{% endhint %}

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

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

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

किसी वर्कफ़्लो को वेबकैम, RTSP स्ट्रीम, या वीडियो फ़ाइल पर चलाने के लिए Inference SDK WebRTC क्लाइंट का उपयोग करें। वही कोड Serverless और स्वयं-होस्टेड Inference Server दोनों के साथ काम करता है।

SDK को उसके WebRTC डिपेंडेंसीज़ के साथ इंस्टॉल करें:

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

एक स्वयं-होस्टेड Inference Server शुरू करें, या उपयोग करें `https://serverless.roboflow.com` बिना सर्वर चलाए। फिर एक Python फ़ाइल बनाएँ:

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

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",  # या "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()
```

ऊपर, बदलें `API_KEY` को अपने Roboflow API key से। बदलें `workspace-name` और `workflow-id` को अपने Roboflow workspace name और Workflow IDs से।

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

बदलें `WebcamSource()` को किसी अन्य स्रोत से, जब वीडियो किसी स्थानीय वेबकैम से नहीं आता। देखें [Workflows के साथ वीडियो प्रोसेसिंग](/workflows/hi/deploy/video-processing.md) RTSP स्ट्रीम, वीडियो फ़ाइलों, और आउटपुट वीडियो के लिए।

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

आप 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
```

फिर आप अपना डेटा ingest कर सकते हैं:

```
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 जॉब बनाते समय प्रदर्शित होगा
```

और जब जॉब पूरा हो जाए, परिणाम एक्सपोर्ट करें:

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

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

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

```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` फ़ाइल होगी जिसमें उस फ़ाइल के Workflow परिणामों के साथ-साथ निष्पादन के दौरान उत्पन्न कोई भी छवियाँ होंगी, और एक `aggregated_results.csv` फ़ाइल होगी जिसमें हर इनपुट के परिणाम एक साथ संयोजित होंगे।

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

## अगले चरण

* Execution Engine को सीधे अपने Python एप्लिकेशन के भीतर चलाएँ: देखें [डेवलपर गाइड](/workflows/hi/developer-guide/developer-guide.md).
* Workflow द्वारा लौटाए गए परिणामों की संरचना समझें: देखें [Workflow निष्पादन](/workflows/hi/developer-guide/developer-guide/workflow-execution.md#output-construction).