> 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 प्रबंधित करता है, और जो आपके कंप्यूटर विज़न मॉडल तथा Workflows को विशेष रूप से आपके लिए आवंटित संसाधनों पर चलाते हैं। ये आपको अपना खुद का इन्फ्रास्ट्रक्चर प्रावधान या बनाए बिना inference सेवा देने देते हैं, जिसमें प्रति-घंटा बिलिंग और आपके workspace API key के माध्यम से सुरक्षित पहुँच होती है। जब आपको विकास, परीक्षण, या प्रोडक्शन ट्रैफ़िक के लिए सुसंगत, समर्पित प्रदर्शन चाहिए, तब इनका उपयोग करें।

### **समर्पित परिनियोजन क्या हैं?**

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

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

### **समर्पित परिनियोजनों के लाभ**

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

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

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

### समर्पित परिनियोजनों के प्रकार

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

<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>प्रोडक्शन ट्रैफ़िक की सेवा</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>प्रोडक्शन ट्रैफ़िक की सेवा</strong></p></td></tr></tbody></table>

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

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

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

सभी समर्पित परिनियोजन सर्वर चलाएँगे [Roboflow Inference](/deployment/hi/self-hosted/self-hosted.md), हमारा ओपन-सोर्स inference सर्वर। [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 API](#http-api)

## HTTP API

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

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

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

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

`api_key` को क्वेरी पैरामीटर के रूप में (या `POST` endpoints के लिए अनुरोध बॉडी में) प्रत्येक अनुरोध पर भेजा जाता है। प्रतिक्रिया कोड जाँचें: यदि यह `200`है, तो प्रतिक्रिया बॉडी को JSON ऑब्जेक्ट के रूप में डिकोड करें; अन्यथा, प्रतिक्रिया बॉडी में एक त्रुटि संदेश स्ट्रिंग के रूप में होता है।

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

<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>string</td><td>वर्कस्पेस API key।</td><td>true</td></tr><tr><td><code>creator_email</code></td><td>string</td><td>वर्कस्पेस सदस्य का ईमेल।</td><td>true</td></tr><tr><td><code>deployment_name</code></td><td>string</td><td>वर्कस्पेस के भीतर अद्वितीय नाम।</td><td>true</td></tr><tr><td><code>machine_type</code></td><td>string</td><td>से <code>/machine_types</code>.</td><td>true</td></tr><tr><td><code>duration</code></td><td>फ़्लोट</td><td>स्वचालित सफ़ाई से पहले के घंटे। डिफ़ॉल्ट <code>3</code>.</td><td>false</td></tr><tr><td><code>delete_on_expiration</code></td><td>boolean</td><td><code>true</code> समाप्ति पर हटाने के लिए; <code>false</code> रोकने के लिए।</td><td>false</td></tr><tr><td><code>inference_version</code></td><td>string</td><td>Inference सर्वर संस्करण। डिफ़ॉल्ट <code>नवीनतम</code>.</td><td>false</td></tr><tr><td><code>min_replicas</code></td><td>पूर्णांक</td><td>न्यूनतम प्रतिकृतियाँ। डिफ़ॉल्ट <code>1</code>.</td><td>false</td></tr><tr><td><code>max_replicas</code></td><td>पूर्णांक</td><td>अधिकतम प्रतिकृतियाँ। डिफ़ॉल्ट <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`     | string   | परिनियोजन के लिए अद्वितीय पहचानकर्ता।                                                                 |
| `deployment_name`   | string   | परिनियोजन को दिया गया नाम।                                                                            |
| `machine_type`      | string   | इनमें से एक `dev-cpu`, `dev-gpu`, `prod-cpu`, `prod-gpu`.                                             |
| `creator_email`     | string   | परिनियोजन बनाने वाले उपयोगकर्ता का ईमेल।                                                              |
| `creator_id`        | string   | से संबंधित उपयोगकर्ता ID `creator_email`.                                                             |
| `subdomain`         | string   | हमेशा वही नहीं होता जैसा `deployment_name` - यदि उपडोमेन लिया जा चुका है तो एक प्रत्यय जोड़ा जाता है। |
| `domain`            | string   | परिनियोजन endpoint का पूर्ण डोमेन।                                                                    |
| `duration`          | फ़्लोट   | परिनियोजन कितने घंटे से चल रहा है।                                                                    |
| `inference_version` | string   | परिनियोजन पर चल रहा inference सर्वर संस्करण।                                                          |
| `min_replicas`      | पूर्णांक | न्यूनतम प्रतिकृति संख्या।                                                                             |
| `max_replicas`      | पूर्णांक | अधिकतम प्रतिकृति संख्या।                                                                              |
| `num_replicas`      | पूर्णांक | वर्तमान में उपलब्ध प्रतिकृतियाँ।                                                                      |
| `status`            | string   | वर्तमान परिनियोजन स्थिति।                                                                             |
| `workspace_id`      | string   | स्वामी वर्कस्पेस की ID।                                                                               |
| `workspace_url`     | string   | स्वामी वर्कस्पेस का URL स्लग।                                                                         |

### एक परिनियोजन प्राप्त करें

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

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

| नाम               | प्रकार | आवश्यक | विवरण                                 |
| ----------------- | ------ | ------ | ------------------------------------- |
| `api_key`         | string | हाँ    | वर्कस्पेस API key।                    |
| `deployment_name` | string | हाँ    | प्राप्त करने के लिए परिनियोजन का नाम। |

```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`      | string | हाँ    | वर्कस्पेस API key।                                     |
| `show_expired` | string | नहीं   | समाप्त हो चुके परिनियोजन शामिल करें। डिफ़ॉल्ट `false`. |
| `show_deleted` | string | नहीं   | हटाए गए परिनियोजन शामिल करें। डिफ़ॉल्ट `false`.        |

```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
}
]
```

### लॉग्स

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

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

| नाम               | प्रकार   | आवश्यक | विवरण                                                                              |
| ----------------- | -------- | ------ | ---------------------------------------------------------------------------------- |
| `api_key`         | string   | हाँ    | वर्कस्पेस API key।                                                                 |
| `deployment_name` | string   | हाँ    | लॉग पढ़ने के लिए परिनियोजन।                                                        |
| `max_entries`     | पूर्णांक | नहीं   | लौटाई जाने वाली लॉग प्रविष्टियों की संख्या। डिफ़ॉल्ट `50`.                         |
| `from_timestamp`  | string   | नहीं   | [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) आरंभ समय। डिफ़ॉल्ट 1 घंटे पहले। |
| `to_timestamp`    | string   | नहीं   | [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 स्ट्रिंग्स हैं। सबसे हाल के लॉग प्राप्त करने के लिए इन्हें छोड़ दें, तक `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` | string | लॉग प्रविष्टि के लिए अद्वितीय पहचानकर्ता। |
| `payload`   | string | लॉग सामग्री।                              |
| `severity`  | string | लॉग स्तर।                                 |
| `timestamp` | string | जब प्रविष्टि लिखी गई थी।                  |

### उपयोग

वर्कस्पेस-व्यापी:

<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`         | string | हाँ    | वर्कस्पेस API key।                    |
| `deployment_name` | string | हाँ    | जिस पर कार्रवाई करनी है वह परिनियोजन। |

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

वही बॉडी संरचना `/resume` और `/delete`.

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

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

## Python SDK

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

प्रत्येक फ़ंक्शन एक `(स्थिति_कोड, बॉडी)` tuple लौटाता है ताकि आप 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"])
else:
    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",          # वर्कस्पेस सदस्य होना चाहिए
    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")
```

### लॉग्स

```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, InferenceConfiguration

client = InferenceHTTPClient(
    api_url=body["public_url"], api_key="YOUR_API_KEY"
).configure(InferenceConfiguration(api_key_transport="header"))
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`             | आपका ईमेल, वर्कस्पेस सदस्य होना चाहिए (आवश्यक)                            |
| `--duration`                | घंटों में अवधि (डिफ़ॉल्ट: 3)                                              |
| `--inference-version`       | Inference server version (डिफ़ॉल्ट: latest)                               |
| `--no-delete-on-expiration` | समाप्त होने पर deployment को रखें                                         |
| `--wait`                    | जब तक deployment तैयार न हो जाए, प्रतीक्षा करें                           |

उदाहरण:

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

### Deployment विवरण प्राप्त करें

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

लंबित deployment के तैयार होने की प्रतीक्षा करें:

```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`   | लॉग आउटपुट फ़ॉलो करें                                  |

### उपयोग सांख्यिकी

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

```bash
roboflow deployment usage
```

किसी विशिष्ट deployment का उपयोग प्राप्त करें:

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