> 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/deployment/hi/roboflow-cloud/dedicated-deployments.md).

# समर्पित डिप्लॉयमेंट्स

## के बारे में

समर्पित डिप्लॉयमेंट निजी क्लाउड सर्वर हैं, जिन्हें Roboflow द्वारा प्रबंधित किया जाता है, जो आपके कंप्यूटर विज़न मॉडल और वर्कफ़्लोज़ को विशेष रूप से आपके लिए आवंटित संसाधनों पर चलाते हैं। ये आपको अपना स्वयं का इन्फ्रास्ट्रक्चर प्रोविजन या मेंटेन किए बिना इन्फरेंस सर्व करने देते हैं, pay-per-hour बिलिंग और आपके workspace API key के माध्यम से सुरक्षित पहुँच के साथ। जब आपको विकास, परीक्षण, या production traffic के लिए सुसंगत, समर्पित प्रदर्शन चाहिए, तब इनका उपयोग करें.

### **समर्पित डिप्लॉयमेंट क्या हैं?**

Roboflow द्वारा प्रबंधित समर्पित डिप्लॉयमेंट निजी क्लाउड सर्वर हैं, जिन्हें विशेष रूप से आपके कंप्यूटर विज़न मॉडल चलाने के लिए डिज़ाइन किया गया है। इनमें शामिल हो सकते हैं:

* ऑब्जेक्ट डिटेक्शन
* इमेज सेगमेंटेशन
* वर्गीकरण
* कीपॉइंट डिटेक्शन
* CLIP जैसे फाउंडेशन मॉडल (यदि Roboflow पर प्रशिक्षित हों)
* Roboflow Workflows (लो-कोड विज़न एप्लिकेशन)
* ...और भी बहुत कुछ!

### **समर्पित डिप्लॉयमेंट के लाभ**

* **अपने मशीन विज़न व्यवसायिक समस्या पर ध्यान दें, इन्फ्रास्ट्रक्चर हमें छोड़ दें:** कुछ ही क्लिक में इन्फरेंस सर्विंग इन्फ्रास्ट्रक्चर शुरू करें, बिना क्लाउड प्रदाताओं के साथ साइन अप किए, सर्वर इंस्टॉल और सुरक्षित किए, TLS certificates प्रबंधित किए, या server management, patching, updates आदि की चिंता किए।
* **समर्पित संसाधन:** अपने उपयोग के लिए विशेष रूप से आवंटित क्लाउड सर्वर प्राप्त करें, जिससे आपके मॉडलों के लिए सुसंगत प्रदर्शन सुनिश्चित हो।
* **सुरक्षित पहुँच:** समर्पित डिप्लॉयमेंट आपके workspace की अद्वितीय API key से उपलब्ध होते हैं और सुरक्षित संचार के लिए HTTPS का उपयोग करते हैं।
* **आसान एकीकरण:** प्रत्येक डिप्लॉयमेंट को के भीतर एक सबडोमेन मिलता है `roboflow.cloud`, जिससे आपके अनुप्रयोगों के साथ एकीकरण सरल हो जाता है।
* **प्रति घंटे भुगतान:** आपसे केवल सर्वर के अस्तित्व की अवधि के लिए शुल्क लिया जाता है (1 मिनट के अंतराल में बिल किया जाता है)।
* **स्वचालित विराम और पुनः आरंभ**: आपके समर्पित डिप्लॉयमेंट निष्क्रियता की एक कॉन्फ़िगर की जा सकने वाली अवधि के बाद स्वचालित रूप से विराम ले लेंगे। For `dev-cpu` या `dev-gpu` deployment types, यह अवधि 1 घंटे पर स्थिर है। इन्हें आपके API key के साथ एक अनुरोध भेजकर जल्दी पुनः आरंभ किया जा सकता है। यह सुविधा आपको लागत बचाने में मदद करने के लिए बनाई गई है।

### **वर्तमान सीमाएँ**

* सभी समर्पित डिप्लॉयमेंट वर्तमान में US-आधारित डेटा केंद्रों में होस्ट किए जाते हैं; अन्य भौगोलिक क्षेत्रों के उपयोगकर्ताओं को अधिक latency दिखाई दे सकती है। यदि आप US के बाहर हैं, तो कृपया एक कस्टम समाधान के लिए हमसे संपर्क करें; हम नेटवर्क latency कम करने में आपकी मदद कर सकते हैं।
* समर्पित डिप्लॉयमेंट Core और Enterprise योजना वाले workspaces के लिए उपलब्ध हैं। देखें [Roboflow योजनाएँ](https://roboflow.com/pricing).

### समर्पित डिप्लॉयमेंट के प्रकार

Roboflow समर्पित डिप्लॉयमेंट के 4 अलग-अलग प्रकार प्रदान करता है, अर्थात् dev-cpu, dev-gpu, prod-cpu, और prod-gpu। जबकि dev-cpu और dev-gpu विकास और परीक्षण उद्देश्यों के लिए डिज़ाइन किए गए हैं, ये कुछ घंटों बाद स्वतः हटा दिए जाएंगे; prod-cpu और prod-gpu स्थायी होते हैं, और बड़े पैमाने के production traffic को सर्व करने के लिए आदर्श हैं।

<table data-search="false"><thead><tr><th width="184">प्रकार</th><th>विशेषताएँ</th></tr></thead><tbody><tr><td>dev-cpu</td><td><p><strong>अस्थायी</strong>: 3 घंटे बाद स्वचालित रूप से हटा दिया जाएगा</p><p><strong>CPU</strong>: मॉडल inference CPU पर किया जा सकता है</p><p>इसके लिए आदर्श <strong>इंटीग्रेशन का परीक्षण</strong> और <strong>प्रोटोटाइपिंग</strong> अनुप्रयोग</p></td></tr><tr><td>dev-gpu</td><td><p><strong>अस्थायी</strong>: 3 घंटे बाद स्वचालित रूप से हटा दिया जाएगा</p><p><strong>इंटीग्रेशन का परीक्षण करने के लिए आदर्श</strong> और <strong>प्रोटोटाइपिंग</strong> अनुप्रयोग</p><p><strong>GPU</strong>: मॉडलों को GPU एक्सेलेरेशन की आवश्यकता होती है (जैसे Florence 2)</p><p>इसके लिए आदर्श <strong>इंटीग्रेशन का परीक्षण</strong> और <strong>प्रोटोटाइपिंग</strong> अनुप्रयोग</p></td></tr><tr><td>prod-cpu</td><td><p><strong>स्थायी</strong>: समर्पित सबडोमेन <code>&#x3C;some-name>.roboflow.cloud</code></p><p><strong>CPU</strong>: मॉडल inference CPU पर किया जा सकता है</p><p>इसके लिए आदर्श <strong>production traffic को सर्व करना</strong></p></td></tr><tr><td>prod-gpu</td><td><p><strong>स्थायी</strong>: समर्पित सबडोमेन <code>&#x3C;some-name>.roboflow.cloud</code></p><p><strong>GPU</strong>: मॉडलों को GPU एक्सेलेरेशन की आवश्यकता होती है (जैसे Florence 2)</p><p>इसके लिए आदर्श <strong>production traffic को सर्व करना</strong></p></td></tr></tbody></table>

### **बिलिंग जानकारी**

GPU डिप्लॉयमेंट (dev-gpu, prod-gpu) के लिए दर है **1 credit/hour**, जबकि CPU डिप्लॉयमेंट (dev-cpu, prod-cpu) के लिए दर है **0.25 credit/hour**.

यदि आप अपने समर्पित डिप्लॉयमेंट सर्वर पर भेजे गए अनुरोधों की संख्या के आधार पर बिलिंग चाहते हैं, तो कृपया [हमारी बिक्री टीम से संपर्क करने के लिए यहाँ क्लिक करें](https://roboflow.com/sales).

सभी समर्पित डिप्लॉयमेंट सर्वर चलाएँगे [Roboflow Inference](/deployment/hi/self-hosted/self-hosted.md), हमारा ओपन-सोर्स inference server। समीक्षा करें [Roboflow Inference दस्तावेज़ीकरण](/deployment/hi/self-hosted/self-hosted.md) उपलब्ध सभी सुविधाओं के बारे में अधिक जानने के लिए।

### उपयोगी लिंक <a href="#provision-and-manage-dedicated-deployments-web-application" id="provision-and-manage-dedicated-deployments-web-application"></a>

* [समर्पित डिप्लॉयमेंट कैसे बनाएं (Roboflow App)](/deployment/hi/roboflow-cloud/dedicated-deployments/create-a-dedicated-deployment.md)
* [समर्पित डिप्लॉयमेंट कैसे बनाएं (Roboflow CLI)](/deployment/hi/roboflow-cloud/dedicated-deployments/create-a-dedicated-deployment.md#create-a-dedicated-deployment-with-the-cli)
* [समर्पित डिप्लॉयमेंट का उपयोग कैसे करें](/deployment/hi/roboflow-cloud/dedicated-deployments/make-requests-to-a-dedicated-deployment.md)
* [HTTP APIs](#http-api)

## HTTP API

[समर्पित परिनियोजन](/deployment/hi/roboflow-cloud/dedicated-deployments.md) ये प्रबंधित GPU मशीनें हैं जो आपके Roboflow मॉडल को अनुमानित latency और उच्च throughput के साथ चलाती हैं। इन्हें एक समर्पित सेवा द्वारा प्रबंधित किया जाता है, जो यहाँ होस्ट की गई है `https://roboflow.cloud`, मुख्य `https://api.roboflow.com` REST API.

यह अनुभाग प्रबंधन endpoints (create, get, list, pause, resume, delete, logs, usage) का दस्तावेज़ीकरण करता है। जब कोई deployment लाइव हो जाए, उस पर inference के लिए देखें [किसी छवि पर मॉडल चलाएँ](/deployment/hi/roboflow-cloud/serverless-api.md#http-api).

{% hint style="info" %}
"edge devices" दस्तावेज़ीकरण के अंतर्गत [परिनियोजन प्रबंधक](/deployment/hi/self-hosted/enterprise/deployment-manager.md#http-api) एक अलग उत्पाद है। समर्पित डिप्लॉयमेंट Roboflow के cloud में प्रबंधित GPU मशीनें हैं; Deployment Manager डिवाइस on-prem हार्डवेयर हैं जो चलाते हैं [Roboflow Inference](/deployment/hi/self-hosted/self-hosted.md).
{% endhint %}

**Base URL:** `https://roboflow.cloud`

`api_key` को एक query parameter के रूप में भेजा जाता है (या request body में, के लिए `POST` endpoints) हर अनुरोध पर। response code जाँचें: यदि यह `200`है, तो response body को JSON object के रूप में decode करें; अन्यथा, response body में एक error message string के रूप में होती है।

### मशीन प्रकारों की सूची

<mark style="color:हरा;">`GET`</mark> `/machine_types`

```bash
curl "https://roboflow.cloud/machine_types?api_key=$ROBOFLOW_API_KEY"
```

**प्रतिक्रिया**

```json
{
  "machine_types": [
    { "name": "gpu-small",  "description": "1× T4, 4 vCPU, 16 GB RAM" },
    { "name": "gpu-medium", "description": "1× L4, 8 vCPU, 32 GB RAM" }
  ]
}
```

### डिप्लॉयमेंट बनाएं

<mark style="color:हरा;">`POST`</mark> `/add`

**बॉडी** (JSON)

<table data-search="false"><thead><tr><th width="200">नाम</th><th width="120">प्रकार</th><th>विवरण</th><th data-type="checkbox">आवश्यक</th></tr></thead><tbody><tr><td><code>api_key</code></td><td>स्ट्रिंग</td><td>Workspace API key.</td><td>true</td></tr><tr><td><code>creator_email</code></td><td>स्ट्रिंग</td><td>workspace सदस्य का ईमेल।</td><td>true</td></tr><tr><td><code>deployment_name</code></td><td>स्ट्रिंग</td><td>workspace के भीतर अद्वितीय नाम।</td><td>true</td></tr><tr><td><code>machine_type</code></td><td>स्ट्रिंग</td><td>से <code>/machine_types</code>.</td><td>true</td></tr><tr><td><code>duration</code></td><td>float</td><td>स्वतः सफाई से पहले घंटे। डिफ़ॉल्ट <code>3</code>.</td><td>false</td></tr><tr><td><code>delete_on_expiration</code></td><td>बूलियन</td><td><code>सत्य</code> समाप्ति पर हटाने के लिए; <code>असत्य</code> रोकने के लिए।</td><td>false</td></tr><tr><td><code>inference_version</code></td><td>स्ट्रिंग</td><td>Inference server version. डिफ़ॉल्ट <code>latest</code>.</td><td>false</td></tr><tr><td><code>min_replicas</code></td><td>integer</td><td>न्यूनतम replicas. डिफ़ॉल्ट <code>1</code>.</td><td>false</td></tr><tr><td><code>max_replicas</code></td><td>integer</td><td>अधिकतम replicas. डिफ़ॉल्ट <code>1</code>.</td><td>false</td></tr></tbody></table>

```bash
curl -X POST "https://roboflow.cloud/add" \\
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "'$ROBOFLOW_API_KEY'",
    "creator_email": "me@company.com",
    "deployment_name": "my-deployment",
    "machine_type": "gpu-small",
    "duration": 8,
    "delete_on_expiration": true
  }'
```

डिप्लॉयमेंट असिंक्रोनस रूप से प्रोविजन होता है। पोल करें `GET /get` जब तक `status == "ready"`.

**प्रतिक्रिया उदाहरण**

```json
{
	"deployment_id": "IwzJ5YLQ0iDhwzqoh3Ae",
	"deployment_name": "dev-testing",
	"machine_type": "dev-gpu",
	"creator_email": YOUR_EMAIL_ADDRESS,
	"creator_id": YOUR_USER_ID,
	"subdomain": "dev-testing",
	"domain": "dev-testing.roboflow.cloud",
	"duration": 3.0,
	"inference_version": "0.45.0",
	"max_replicas": 1,
	"min_replicas": 1,
	"num_replicas": 0,
	"status": "pending",
	"workspace_id": YOUR_WORKSPACE_ID,
	"workspace_url": YOUR_WORKSPACE_URL
}
```

**प्रतिक्रिया स्कीमा**

| फ़ील्ड              | प्रकार   | विवरण                                                                                                |
| ------------------- | -------- | ---------------------------------------------------------------------------------------------------- |
| `deployment_id`     | स्ट्रिंग | डिप्लॉयमेंट के लिए अद्वितीय पहचानकर्ता।                                                              |
| `deployment_name`   | स्ट्रिंग | डिप्लॉयमेंट को दिया गया नाम।                                                                         |
| `machine_type`      | स्ट्रिंग | इनमें से एक `dev-cpu`, `dev-gpu`, `prod-cpu`, `prod-gpu`.                                            |
| `creator_email`     | स्ट्रिंग | डिप्लॉयमेंट बनाने वाले उपयोगकर्ता का ईमेल।                                                           |
| `creator_id`        | स्ट्रिंग | के अनुरूप उपयोगकर्ता ID `creator_email`.                                                             |
| `subdomain`         | स्ट्रिंग | हमेशा समान नहीं होता `deployment_name` - यदि subdomain लिया जा चुका है, तो एक प्रत्यय जोड़ा जाता है। |
| `domain`            | स्ट्रिंग | डिप्लॉयमेंट endpoint का पूरा डोमेन।                                                                  |
| `duration`          | float    | डिप्लॉयमेंट कितने घंटे से चल रहा है।                                                                 |
| `inference_version` | स्ट्रिंग | डिप्लॉयमेंट पर चल रहा inference server version.                                                      |
| `min_replicas`      | integer  | न्यूनतम replica संख्या।                                                                              |
| `max_replicas`      | integer  | अधिकतम replica संख्या।                                                                               |
| `num_replicas`      | integer  | वर्तमान में उपलब्ध replicas.                                                                         |
| `स्थिति`            | स्ट्रिंग | वर्तमान डिप्लॉयमेंट स्थिति।                                                                          |
| `workspace_id`      | स्ट्रिंग | मालिक workspace की ID।                                                                               |
| `workspace_url`     | स्ट्रिंग | मालिक workspace का URL slug।                                                                         |

### डिप्लॉयमेंट प्राप्त करें

<mark style="color:हरा;">`GET`</mark> `/get?api_key=...&deployment_name=...`

**क्वेरी पैरामीटर**

| नाम               | प्रकार   | आवश्यक | विवरण                                 |
| ----------------- | -------- | ------ | ------------------------------------- |
| `api_key`         | स्ट्रिंग | हाँ    | Workspace API key.                    |
| `deployment_name` | स्ट्रिंग | हाँ    | प्राप्त करने हेतु डिप्लॉयमेंट का नाम। |

```bash
curl "https://roboflow.cloud/get?api_key=$ROBOFLOW_API_KEY&deployment_name=my-deployment"
```

**प्रतिक्रिया** (उसी स्कीमा जैसा [डिप्लॉयमेंट बनाएं](#create-a-deployment) प्रतिक्रिया)

```json
{
  "deployment_name": "my-deployment",
  "status": "ready",
  "machine_type": "gpu-small",
  "public_url": "https://my-deployment.roboflow.cloud",
  "created_at": "2026-05-01T17:05:33.000Z",
  "expires_at": "2026-05-02T01:05:33.000Z"
}
```

### डिप्लॉयमेंट्स की सूची

<mark style="color:हरा;">`GET`</mark> `/list?api_key=...`

**क्वेरी पैरामीटर**

| नाम            | प्रकार   | आवश्यक | विवरण                                                    |
| -------------- | -------- | ------ | -------------------------------------------------------- |
| `api_key`      | स्ट्रिंग | हाँ    | Workspace API key.                                       |
| `show_expired` | स्ट्रिंग | नहीं   | समाप्त हो चुके डिप्लॉयमेंट शामिल करें। डिफ़ॉल्ट `असत्य`. |
| `show_deleted` | स्ट्रिंग | नहीं   | हटाए गए डिप्लॉयमेंट शामिल करें। डिफ़ॉल्ट `असत्य`.        |

```bash
curl "https://roboflow.cloud/list?api_key=$ROBOFLOW_API_KEY"
```

**प्रतिक्रिया**

समर्पित डिप्लॉयमेंट प्रविष्टियों की एक सूची, जहाँ प्रत्येक प्रविष्टि का स्कीमा उसी जैसा है जैसा [डिप्लॉयमेंट बनाएं](#create-a-deployment) प्रतिक्रिया।

```json
[
{
	"deployment_id": "IwzJ5YLQ0iDhwzqoh3Ae",
	"deployment_name": "dev-testing",
	"machine_type": "dev-gpu",
	"creator_email": YOUR_EMAIL_ADDRESS,
	"creator_id": YOUR_USER_ID,
	"subdomain": "dev-testing",
	"domain": "dev-testing.roboflow.cloud",
	"duration": 3.0,
	"inference_version": "0.45.0",
	"max_replicas": 1,
	"min_replicas": 1,
	"num_replicas": 0,
	"status": "pending",
	"workspace_id": YOUR_WORKSPACE_ID,
	"workspace_url": YOUR_WORKSPACE_URL
}
]
```

### Logs

<mark style="color:हरा;">`GET`</mark> `/get_log?api_key=...&deployment_name=...&from_timestamp=...&to_timestamp=...&max_entries=...`

**क्वेरी पैरामीटर**

| नाम               | प्रकार   | आवश्यक | विवरण                                                                                 |
| ----------------- | -------- | ------ | ------------------------------------------------------------------------------------- |
| `api_key`         | स्ट्रिंग | हाँ    | Workspace API key.                                                                    |
| `deployment_name` | स्ट्रिंग | हाँ    | वह डिप्लॉयमेंट जिससे लॉग पढ़ने हैं।                                                   |
| `max_entries`     | integer  | नहीं   | लौटाई जाने वाली लॉग प्रविष्टियों की संख्या। डिफ़ॉल्ट `50`.                            |
| `from_timestamp`  | स्ट्रिंग | नहीं   | [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) प्रारंभ समय। डिफ़ॉल्ट 1 घंटा पहले. |
| `to_timestamp`    | स्ट्रिंग | नहीं   | [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) समाप्ति समय। डिफ़ॉल्ट: अभी.        |

```bash
curl "https://roboflow.cloud/get_log?api_key=$ROBOFLOW_API_KEY&deployment_name=my-deployment&max_entries=200"
```

`from_timestamp` और `to_timestamp` ISO-8601 strings हैं। सबसे हालिया लॉग प्राप्त करने के लिए इन्हें छोड़ दें, up to `max_entries`.

**प्रतिक्रिया उदाहरण**

```json
[
	{
		"insert_id": "gpwrgrw55p7b9jdq",
		"payload": "INFO:     10.18.0.38:46296 - \"GET /info HTTP/1.1\" 200 OK",
		"severity": "INFO",
		"timestamp": "2025-01-22T13:23:14.209436+00:00"
	},
	{
		"insert_id": "mbieh16zdjvqp81j",
		"payload": "INFO:     10.18.0.38:46294 - \"GET /info HTTP/1.1\" 200 OK",
		"severity": "INFO",
		"timestamp": "2025-01-22T13:23:14.208738+00:00"
	}
]
```

**प्रतिक्रिया स्कीमा**

लॉग प्रविष्टियों की एक सूची, जहाँ प्रत्येक प्रविष्टि में निम्नलिखित गुण होते हैं:

| फ़ील्ड      | प्रकार   | विवरण                                     |
| ----------- | -------- | ----------------------------------------- |
| `insert_id` | स्ट्रिंग | लॉग प्रविष्टि के लिए अद्वितीय पहचानकर्ता। |
| `payload`   | स्ट्रिंग | लॉग सामग्री।                              |
| `severity`  | स्ट्रिंग | लॉग स्तर।                                 |
| `timestamp` | स्ट्रिंग | जब प्रविष्टि लिखी गई थी।                  |

### उपयोग

पूरे workspace में:

<mark style="color:हरा;">`GET`</mark> `/usage_workspace?api_key=...&from_timestamp=...&to_timestamp=...`

प्रति-डिप्लॉयमेंट:

<mark style="color:हरा;">`GET`</mark> `/usage_deployment?api_key=...&deployment_name=...&from_timestamp=...&to_timestamp=...`

```bash
curl "https://roboflow.cloud/usage_workspace?api_key=$ROBOFLOW_API_KEY&from_timestamp=2026-04-01T00:00:00Z&to_timestamp=2026-05-01T00:00:00Z"
```

### विराम / पुनः आरंभ / हटाएँ

<mark style="color:हरा;">`POST`</mark> `/pause`   <mark style="color:हरा;">`POST`</mark> `/resume`   <mark style="color:लाल;">`POST`</mark> `/delete`

**बॉडी** (JSON)

| नाम               | प्रकार   | आवश्यक | विवरण                                |
| ----------------- | -------- | ------ | ------------------------------------ |
| `api_key`         | स्ट्रिंग | हाँ    | Workspace API key.                   |
| `deployment_name` | स्ट्रिंग | हाँ    | जिस डिप्लॉयमेंट पर कार्रवाई करनी है। |

```bash
curl -X POST "https://roboflow.cloud/pause" \\
  -H "Content-Type: application/json" \
  -d '{"api_key": "'$ROBOFLOW_API_KEY'", "deployment_name": "my-deployment"}'
```

इसी प्रकार का body स्वरूप लागू होता है `/resume` और `/delete`.

**प्रतिक्रिया उदाहरण**

```json
{
	"message": "OK"
}
```

## Python SDK

[समर्पित परिनियोजन](/deployment/hi/roboflow-cloud/dedicated-deployments.md) ये प्रबंधित GPU मशीनें हैं जो आपके Roboflow मॉडल को अनुमानित latency और उच्च throughput के साथ चलाती हैं। SDK इन्हें के माध्यम से प्रबंधित करता है `roboflow.adapters.deploymentapi` adapter - उच्च-स्तरीय `Workspace` क्लास वर्तमान में डिप्लॉयमेंट विधियाँ उपलब्ध नहीं कराती।

प्रत्येक फ़ंक्शन एक `(status_code, body)` टपल लौटाता है, ताकि आप HTTP परिणाम के आधार पर शाखा बना सकें:

```python
from roboflow.adapters import deploymentapi

status, body = deploymentapi.list_deployment("YOUR_API_KEY")
if status == 200:
    for d in body.get("deployments", []):
        print(d["deployment_name"], d["status"])

अन्यथा:
    print("विफल:", body)
```

### उपलब्ध मशीन प्रकारों की सूची

```python
from roboflow.adapters import deploymentapi

status, body = deploymentapi.list_machine_types("YOUR_API_KEY")
for m in body.get("machine_types", []):
    print(m["name"], m.get("description"))
```

### डिप्लॉयमेंट बनाएं

```python
status, body = deploymentapi.add_deployment(
    api_key="YOUR_API_KEY",
    creator_email="me@company.com",          # ज़रूर workspace सदस्य होना चाहिए
    machine_type="gpu-small",
    duration=8,                                # घंटे
    delete_on_expiration=True,
    deployment_name="my-deployment",
    inference_version=None,                    # None → नवीनतम
)
```

डिप्लॉयमेंट असिंक्रोनस रूप से प्रोविजन होता है। पोल करें `get_deployment` जब तक `status == "ready"`.

### डिप्लॉयमेंट विवरण प्राप्त करें

```python
status, body = deploymentapi.get_deployment("YOUR_API_KEY", "my-deployment")
print(body["status"], body.get("public_url"))
```

### विराम / पुनः आरंभ / हटाएँ

```python
deploymentapi.pause_deployment("YOUR_API_KEY", "my-deployment")
deploymentapi.resume_deployment("YOUR_API_KEY", "my-deployment")
deploymentapi.delete_deployment("YOUR_API_KEY", "my-deployment")
```

### Logs

```python
import datetime as dt

status, body = deploymentapi.get_deployment_log(
    api_key="YOUR_API_KEY",
    deployment_name="my-deployment",
    from_timestamp=dt.datetime.utcnow() - dt.timedelta(hours=1),
    to_timestamp=dt.datetime.utcnow(),
    max_entries=200,
)
for entry in body.get("logs", []):
    print(entry["timestamp"], entry["message"])

```

### उपयोग

```python
status, ws_usage = deploymentapi.get_workspace_usage(
    api_key="YOUR_API_KEY",
    from_timestamp=dt.datetime(2026, 4, 1),
    to_timestamp=dt.datetime(2026, 5, 1),
)

status, dep_usage = deploymentapi.get_deployment_usage(
    api_key="YOUR_API_KEY",
    deployment_name="my-deployment",
    from_timestamp=dt.datetime(2026, 4, 1),
    to_timestamp=dt.datetime(2026, 5, 1),
)
```

### समर्पित डिप्लॉयमेंट पर inference चलाना

एक बार डिप्लॉयमेंट तैयार हो जाए, तो inference SDK कॉल्स को इसके `public_url` (द्वारा लौटाया गया `get_deployment`):

```python
from inference_sdk import InferenceHTTPClient

client = InferenceHTTPClient(api_url=body["public_url"], api_key="YOUR_API_KEY")
result = client.infer("photo.jpg", model_id="my-detector/3")
```

## CLI

आप बना, मॉनिटर और प्रबंधित कर सकते हैं [समर्पित परिनियोजन](/deployment/hi/roboflow-cloud/dedicated-deployments.md) कमांड लाइन से।

### डिप्लॉयमेंट्स की सूची

```bash
roboflow deployment list
```

### मशीन प्रकारों की सूची

```bash
roboflow deployment machine-type
```

### डिप्लॉयमेंट बनाएं

```bash
roboflow deployment create <name> -m <machine-type> -e <email>
```

#### विकल्प

| फ़्लैग                      | विवरण                                                                     |
| --------------------------- | ------------------------------------------------------------------------- |
| `-m`, `--machine-type`      | मशीन प्रकार (आवश्यक)। चलाएँ `deployment machine-type` विकल्प देखने के लिए |
| `-e`, `--email`             | आपका ईमेल, workspace सदस्य होना चाहिए (आवश्यक)                            |
| `--duration`                | अवधि घंटों में (डिफ़ॉल्ट: 3)                                              |
| `--inference-version`       | Inference server version (डिफ़ॉल्ट: नवीनतम)                               |
| `--no-delete-on-expiration` | समाप्त होने पर डिप्लॉयमेंट रखें                                           |
| `--wait`                    | डिप्लॉयमेंट तैयार होने तक प्रतीक्षा करें                                  |

उदाहरण:

```bash
roboflow deployment create my-deployment -m gpu-small -e me@company.com --duration 8
```

### डिप्लॉयमेंट विवरण प्राप्त करें

```bash
roboflow deployment get <name>
```

लंबित डिप्लॉयमेंट के तैयार होने तक प्रतीक्षा करें:

```bash
roboflow deployment get my-deployment --wait
```

### लॉग देखें

```bash
roboflow deployment log <name>
```

लॉग्स को रियल-टाइम में देखें:

```bash
roboflow deployment log my-deployment -f
```

#### विकल्प

| फ़्लैग             | विवरण                                                  |
| ------------------ | ------------------------------------------------------ |
| `-d`, `--duration` | लॉग विंडो सेकंड में (डिफ़ॉल्ट: 3600)                   |
| `-n`, `--tail`     | अंत से दिखाने वाली पंक्तियाँ (अधिकतम 50, डिफ़ॉल्ट: 10) |
| `-f`, `--follow`   | लॉग आउटपुट को फॉलो करें                                |

### उपयोग आँकड़े

पूरे workspace का उपयोग प्राप्त करें:

```bash
roboflow deployment usage
```

किसी विशिष्ट deployment के लिए usage प्राप्त करें:

```bash
roboflow deployment usage my-deployment
```

#### विकल्प

| फ़्लैग   | विवरण                  |
| -------- | ---------------------- |
| `--from` | प्रारंभ समय (ISO 8601) |
| `--to`   | समाप्ति समय (ISO 8601) |

### रोकें, पुनः शुरू करें, और हटाएँ

```bash
roboflow deployment pause my-deployment
roboflow deployment resume my-deployment
roboflow deployment delete my-deployment
```

### JSON आउटपुट

सभी deployment कमांड समर्थन करते हैं `--json`:

```bash
roboflow deployment list --json
roboflow deployment get my-deployment --json
```