> 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 को चार तरीकों से तैनात कर सकते हैं:

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

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

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

{% hint style="warning" %}
Roboflow hosted API पर Workflow चलाने की दो सीमाएँ हैं, जिन्हें ध्यान में रखना चाहिए:

* Workflow runtime 20 सेकंड तक सीमित है।
* response payload 6 MB तक सीमित है, इसलिए कई visualization blocks वाले Workflows, या बड़े input images वाले Workflows विफल हो सकते हैं।

Self-hosted और dedicated deployments पर ये सीमाएँ नहीं होतीं।
{% endhint %}

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

on-premises deployment चुनकर, आप Workflows को किसी भी ऐसे सिस्टम पर चला सकते हैं जहाँ आप Inference तैनात कर सकते हैं। इसमें शामिल हैं:

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

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

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

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

आपके Workflows editor में code snippets पहले से ही आपके Workflows URL और API key से भरे होंगे।

Snippets आपके editor के runtime से मेल खाते हैं। यदि आप editor को local Inference server या एक [Dedicated Deployment](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments)तो `api_url` प्रत्येक snippet उस server की ओर संकेत करता है, और मेल खाता tab recommended के रूप में चिह्नित होता है। यदि उपलब्ध हो, तो Snippets आपके saved Workflow preview से एक उदाहरण छवि भी भरते हैं।

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

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

आप Roboflow API या local Inference server का उपयोग करके अपने Workflow को एकल छवियों पर चला सकते हैं।

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

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

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

```
inference server start
```

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

```python
from inference_sdk import InferenceHTTPClient

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

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 नाम और Workflow IDs से।

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

Local execution CPU और NVIDIA CUDA GPU devices पर काम करता है। सर्वोत्तम प्रदर्शन के लिए, NVIDIA Jetson या NVIDIA GPU वाले cloud server जैसे GPU-enabled डिवाइस पर तैनात करें।

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

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

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

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

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

Inference SDK WebRTC client का उपयोग करके किसी webcam, RTSP stream, या video file पर Workflow चलाएँ। यही कोड Serverless और self-hosted Inference Server दोनों के साथ काम करता है।

SDK को उसकी WebRTC dependencies के साथ इंस्टॉल करें:

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

एक self-hosted Inference Server प्रारंभ करें, या उपयोग करें `https://serverless.roboflow.com` बिना server चलाए। फिर एक Python फ़ाइल बनाएँ:

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

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",  # or "http://localhost:9001"
    api_key="API_KEY",
)

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 नाम और Workflow IDs से।

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

बदलें `WebcamSource()` जब वीडियो स्थानीय webcam से न आए, तो किसी अन्य स्रोत पर। देखें [Workflows के साथ वीडियो प्रोसेसिंग](/workflows/hi/deploy/video-processing.md) RTSP streams, video files, और output video के लिए।

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

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

हम Batch Processing के साथ UI, CLI और REST API इंटरैक्शन दोनों का समर्थन करते हैं। नीचे, हम CLI commands प्रस्तुत कर रहे हैं। खोजें [सभी विकल्प](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}
```

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

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

## अगले चरण

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