# एक Workflow deploy करें

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

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

यदि आप अपना Workflow अपने ही hardware पर चलाते हैं, तो आप इसे images और video files दोनों पर चला सकते हैं (जिसमें नियमित से 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 customers के पास अतिरिक्त video stream options तक पहुँच होती है, जैसे Basler cameras पर inference चलाना। हमारी offerings के बारे में अधिक जानने के लिए, [Roboflow sales team से संपर्क करें](https://roboflow.com/sales).
{% endhint %}

### एक Workflow deploy करें

किसी workflow को deploy करने के लिए, Workflows editor के ऊपर बाएँ कोने में मौजूद "Deploy" button पर click करें। इस page पर सभी deployment options documented हैं।

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

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

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

```
inference server start
```

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

```python
from inference_sdk import InferenceHTTPClient

client = InferenceHTTPClient(
    api_url="https://detect.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 से।

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

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

#### Video Stream (RTSP, Webcam) process करें

आप अपने Workflow को video stream के frames पर 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, # वीडियो का 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 से।

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

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

#### Data के Batches process करें

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

हम Batch Processing के साथ UI, CLI और REST API interactions दोनों का समर्थन करते हैं। नीचे, हम CLI commands प्रस्तुत कर रहे हैं। खोजें [सभी options](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 load हो जाए, processing job शुरू करें:

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

job की progress इस प्रकार दिखाई जा सकती है:

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

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

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