# Workflow Deploy करें

आप एक Workflow को चार तरीकों से deploy कर सकते हैं:

1. चित्रों को भेजें [Roboflow API](https://inference.roboflow.com/workflows/modes_of_running/#http-api-request) को अपने Workflow का उपयोग करके processing के लिए।
2. एक बनाएँ [Roboflow Dedicated Deployment](/roboflow/roboflow-hi/deploy/dedicated-deployments.md) ऐसी infrastructure पर जो विशेष रूप से आपके उपयोग के लिए provision की गई हो।
3. अपने खुद के hardware पर अपने Workflow को चलाएँ, उपयोग करके [Roboflow Inference](https://inference.roboflow.com/install/).
4. उपयोग करें [Batch Processing](/roboflow/roboflow-hi/deploy/batch-processing.md) बिना coding के, बड़ी मात्रा में data को cost-efficient तरीके से process करने के लिए।

यदि आप अपना Workflow अपने खुद के hardware पर चलाते हैं, तो आप इसे images और video files दोनों पर चला सकते हैं (regular से streams सहित **webcams** और professional **CCTV cameras**).

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

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

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

### एक Workflow deploy करें

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

आपके Workflows editor में code snippets आपके Workflows URL और API key के साथ पहले से भर दिए जाएँगे।

{% hint style="info" %}
Workflows के usage limits के बारे में अधिक जानने के लिए, देखें [Roboflow pricing page](https://roboflow.com/workflows).
{% endhint %}

#### Images process करें

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

सबसे पहले, Roboflow Inference SDK install करें:

```python
pip install inference-sdk inference-cli 
```

यदि आप local पर चलाते हैं, तो [official Docker installation instructions](https://docs.docker.com/get-docker/) का पालन करें ताकि Docker को अपनी machine पर install करके Inference server शुरू किया जा सके:

```
inference server start
```

फिर, एक नया Python file बनाएँ और निम्न code जोड़ें:

```python
from inference_sdk import InferenceHTTPClient

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",  # या local deployment के लिए "http://127.0.0.1:9001"
    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 name और Workflow IDs से।

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

Local execution CPU और NVIDIA CUDA GPU devices पर काम करती है। सर्वोत्तम performance के लिए, NVIDIA Jetson या NVIDIA GPU वाले cloud server जैसे GPU-enabled device पर deploy करें।

#### Video Stream प्रोसेस करें (RTSP, Webcam)

आप video stream के frames पर अपना Workflow deploy कर सकते हैं। यह webcam या RTSP stream हो सकती है। आप अपने Workflow को video files पर भी चला सकते हैं।

सबसे पहले, Inference install करें:

```
pip install inference  # या GPU machines के लिए inference-gpu
```

Inference को install होने में कुछ मिनट लग सकते हैं।

फिर, एक नया Python file बनाएँ और निम्न code जोड़ें:

```python
# InferencePipeline object import करें
from inference import InferencePipeline

def my_sink(result, video_frame):
    print(result) # प्रत्येक frame की predictions के साथ कुछ करें
    

# pipeline object initialize करें
pipeline = InferencePipeline.init_with_workflow(
    api_key="API_KEY",
    workspace_name="workspace-name",
    workflow_id="workflow-id",
    video_reference=0, # video का path, RSTP stream, device id (int, आमतौर पर built in webcams के लिए 0), या RTSP stream url
    on_prediction=my_sink
)
pipeline.start() #pipeline शुरू करें
pipeline.join() #pipeline thread के समाप्त होने का इंतज़ार करें

```

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

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

जब आप ऊपर दिया गया code चलाते हैं, तो आपका Workflow आपके video या video stream पर चलेगा।

#### Data के Batches प्रोसेस करें

आप Roboflow Batch Processing service का उपयोग करके data के पूरे batches—images और video files की directories—को efficiently process कर सकते हैं। यह fully managed solution किसी coding या local computation की आवश्यकता नहीं रखती। बस अपना data और Workflow चुनें, और बाकी Roboflow पर छोड़ दें।

हम Batch Processing के साथ UI, CLI और REST API interactions दोनों को support करते हैं। नीचे, हम CLI commands प्रस्तुत करते हैं। खोजें [सभी विकल्प](https://inference.roboflow.com/workflows/batch_processing/about/#cli).

processing चलाने के लिए, Inference CLI install करें:

```
pip install inference-cli
```

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

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

जब data लोड हो जाएँ, processing job शुरू करें:

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

job की प्रगति इस तरह प्रदर्शित की जा सकती है:

```
inference rf-cloud batch-processing show-job-details \\
    --job-id <your-job-id>  # job-id job बनाते समय प्रदर्शित होगा
```

और जब job पूरा हो जाए, परिणाम export करें:

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.roboflow.com/roboflow/roboflow-hi/workflows/deploy-a-workflow.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.