> 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/batch-processing.md).

# बैच प्रोसेसिंग

आपके लिए provisioned cloud infrastructure के साथ बड़ी छवि batches और संग्रहीत videos पर Workflows चलाएँ।

## परिचय

बैच प्रोसेसिंग, चलाने का एक किफ़ायती तरीका है [वर्कफ़्लो](https://docs.roboflow.com/workflows) इमेज के बैच और संग्रहीत वीडियो पर। बड़ी मात्रा में डेटा को एसिंक्रोनस रूप से प्रोसेस करने के लिए यह आदर्श है।

बैच प्रोसेसिंग बड़े बैच को चलाने के लिए आवश्यक इन्फ़्रास्ट्रक्चर अपने-आप उपलब्ध कराती है।

{% hint style="info" %}
बैच प्रोसेसिंग, Roboflow के क्रेडिट सिस्टम या Enterprise प्लान वाले हर वर्कस्पेस के लिए उपलब्ध है। आप "Batch Processing" टैब से कोई जॉब शुरू कर सकते हैं या इसमें चुने गए आइटम पर वर्कफ़्लो चला सकते हैं: [एसेट लाइब्रेरी](https://docs.roboflow.com/platform/workspaces/asset-library).
{% endhint %}

आप Roboflow वेब इंटरफ़ेस या हमारे API (CLI के ज़रिए) से बैच प्रोसेसिंग जॉब कॉन्फ़िगर कर सकते हैं।

जॉब शुरू करने पर, आपके डेटा को प्रोसेस करने के लिए क्लाउड में मशीनें उपलब्ध कराई जाएँगी। इसके बाद आपको आपके डेटा पर चलाने के लिए चुने गए वर्कफ़्लो के आउटपुट वाली JSON फ़ाइल मिलेगी।

जॉब CPU या GPU मशीनों पर चलते हैं। GPU जॉब तेज़ होते हैं, लेकिन उनकी लागत अधिक होती है। CPU और GPU की दरों के लिए देखें [क्रेडिट पेज](https://roboflow.com/credits) जॉब पूरा होने में कितना समय लगेगा, यह इस पर निर्भर करता है कि वह कितनी इमेज या वीडियो प्रोसेस करता है, वर्कफ़्लो कितना जटिल है और मशीन का प्रकार क्या है। आम समस्याओं के लिए देखें [समस्या निवारण](https://docs.roboflow.com/deployment/hi/roboflow-cloud/batch-processing/troubleshooting.md).

निम्न वीडियो में बैच प्रोसेसिंग को विस्तार से समझाया गया है:

{% embed url="<https://www.youtube.com/watch?v=S7K2j2IeQrM>" %}

## वेब ऐप

बाएँ साइडबार में "Deployments" खोलें और "Batch Processing" टैब चुनें।

<figure><img src="https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-1193fa943b014f1b279c123ad5ccc88fac10f551%2FScreenshot%202025-05-19%20at%2012.14.51.png?alt=media" alt=""><figcaption></figcaption></figure>

"New Batch Job" पर क्लिक करें और ये चरण पूरे करें:

1. एक चुनें [वर्कफ़्लो](https://docs.roboflow.com/workflows).
2. प्रोसेस करने के लिए इमेज या वीडियो अपलोड करें।
3. CPU या GPU हार्डवेयर चुनें। जब तक आपको इन्हें बदलने की ज़रूरत न हो, "Advanced Options" की डिफ़ॉल्ट सेटिंग रहने दें।
4. "Create Batch Job" पर क्लिक करें।

<figure><img src="https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-10667231b1e727c9344565e52171e0d1cb26b90c%2FScreenshot%202025-05-19%20at%2012.16.27.png?alt=media" alt=""><figcaption></figcaption></figure>

जॉब सूची में हर जॉब की प्रगति रियल टाइम में दिखाई देती है। इस टैब से शुरू किए गए जॉब आपके Activity Center में भी दिखते हैं, जहाँ उन्हें सिर्फ़ आप देख सकते हैं। किसी जॉब के विवरण खोलने के लिए उस पर क्लिक करें। "Source and type" से पता चलता है कि यह किन इमेज पर चला: उन्हें चुनने वाली [एसेट लाइब्रेरी](https://docs.roboflow.com/platform/workspaces/asset-library) की खोज क्वेरी—साथ में "Open in Asset Library" लिंक—या मैन्युअल रूप से चुनी गई इमेज की संख्या।

### एसेट लाइब्रेरी से

में [एसेट लाइब्रेरी](https://docs.roboflow.com/platform/workspaces/asset-library), इमेज चुनें या अपनी खोज से मेल खाने वाली सभी इमेज चुनें, फिर "Run Workflow" पर क्लिक करें। पूरी प्रक्रिया के लिए देखें [वर्कफ़्लो चलाना](https://docs.roboflow.com/platform/workspaces/asset-library#running-a-workflow) इसमें यह भी शामिल है कि नतीजे आपकी इमेज पर वापस कैसे लिखें।

### Agent से

से कहें [Roboflow Agent](https://docs.roboflow.com/agents/roboflow-agent) कि वह एसेट लाइब्रेरी की इमेज पर प्रकाशित वर्कफ़्लो चलाए: वे इमेज जिन्हें आप चुनते हैं, खोज से मेल खाने वाली इमेज या पूरी लाइब्रेरी। यह आपके जॉब की स्थिति भी बता सकता है और जॉब पूरा होने पर चैट में आपको सूचित करता है। इसके शुरू किए गए जॉब Background Tasks में भी दिखाई देते हैं।

Agent चैट टैब के रूप में Batch Processing भी खोल सकता है। नए जॉब फ़ॉर्म में Agent, आपके सहमत वर्कफ़्लो और सेटिंग भर देता है, लेकिन आपको अपने कंप्यूटर से फ़ाइलें खुद चुननी होंगी।

### डेटासोर्स के मिरर होने पर अपने-आप

हर बार जब कोई [डेटासोर्स](https://docs.roboflow.com/datasets/create-and-upload/adding-data/datasources) मिरर होता है, तो बैच प्रोसेसिंग जॉब आयात की गई नई इमेज पर वर्कफ़्लो चला सकता है (उदाहरण के लिए, टैग या पहले से लगाए गए लेबल को अपडेट रखने के लिए)। [डेटासोर्स](https://app.roboflow.com/settings/datasources) पेज के "Workflow runs" सेक्शन में, "Add workflow run" पर क्लिक करें। "Run when" के अंतर्गत "On Sync" चुनें और इसे ट्रिगर करने वाले डेटासोर्स चुनें। वर्कफ़्लो में ठीक एक `image` इनपुट होना चाहिए।

{% hint style="info" %}
अगर आपको "Workflow runs" सेक्शन दिखाई नहीं देता है, तो बैच ऑटोमेशन प्रबंधित करने की अनुमति वाली भूमिका के लिए Workspace एडमिन से संपर्क करें।
{% endhint %}

नतीजों को खोजने योग्य बनाने के लिए देखें [नतीजों को एसेट लाइब्रेरी में वापस लिखना](https://docs.roboflow.com/platform/workspaces/asset-library#writing-results-back-to-the-asset-library).

## HTTP API

**त्वरित लिंक:**

* [डेटा इनजेस्ट करें](#ingest-data) (वीडियो, एकल इमेज, इमेज)
* [बैच की स्थिति देखें](#check-batch-status) (आइटम की संख्या, शार्ड का विवरण)
* [जॉब शुरू करें](#start-a-job)
* [जॉब की प्रगति पर नज़र रखें](#monitor-job-progress) (जॉब की स्थिति, चरण, टास्क)
* [नतीजे एक्सपोर्ट करें](#export-results) (आउटपुट के हिस्से, डाउनलोड URL)
* [वेबहुक सूचनाएँ](#webhook-notifications)

### डेटा इनजेस्ट करें

#### वीडियो अपलोड करें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/data-staging/v1/external/{workspace}/batches/{batch\_id}/upload/video" method="post" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

#### इमेज अपलोड करें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/data-staging/v1/external/{workspace}/batches/{batch\_id}/upload/image" method="post" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

#### कई इमेज अपलोड करें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/data-staging/v1/external/{workspace}/batches/{batch\_id}/bulk-upload/image-files" method="post" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

### बैच की स्थिति जाँचें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/data-staging/v1/external/{workspace}/batches/{batch\_id}/count" method="get" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

#### शार्ड अपलोड का विवरण जाँचें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/data-staging/v1/external/{workspace}/batches/{batch\_id}/shards" method="get" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

### जॉब शुरू करें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/batch-processing/v1/external/{workspace}/jobs/{job\_id}" method="post" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

### जॉब की प्रगति पर नज़र रखें

#### जॉब की स्थिति प्राप्त करें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/batch-processing/v1/external/{workspace}/jobs/{job\_id}" method="get" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

#### जॉब के चरणों की सूची देखें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/batch-processing/v1/external/{workspace}/jobs/{job\_id}/stages" method="get" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

#### चरण के टास्क की सूची देखें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/batch-processing/v1/external/{workspace}/jobs/{job\_id}/stages/{stage\_id}/tasks" method="get" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

### नतीजे एक्सपोर्ट करें

#### आउटपुट के हिस्सों की सूची देखें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/data-staging/v1/external/{workspace}/batches/{batch\_id}/parts" method="get" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

#### डाउनलोड URL की सूची देखें

{% openapi src="/files/3e8d761a853ad1914ff83d0adb1afb2628525d4f" path="/data-staging/v1/external/{workspace}/batches/{batch\_id}/list" method="get" %}
[batch-processing.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-c01faa8d2b7705ff92e611d69a086a8d11d1c26a%2Fbatch-processing.yaml?alt=media)
{% endopenapi %}

### वेबहुक सूचनाएँ

स्थिति जानने के लिए बार-बार अनुरोध करने के बजाय, इनजेशन या प्रोसेसिंग पूरी होने पर सूचना पाने के लिए वेबहुक का उपयोग कर सकते हैं। देखें [CLI का उपयोग](#webhook-automation) वेबहुक कॉन्फ़िगरेशन और पेलोड फ़ॉर्मैट के लिए।

## CLI

स्थानीय या क्लाउड इमेज और वीडियो को स्टेज और प्रोसेस करने के लिए `inference rf-cloud` का उपयोग करें। आपके [एसेट लाइब्रेरी](https://docs.roboflow.com/platform/workspaces/asset-library)में पहले से मौजूद इमेज के लिए, `roboflow batch`.

### स्थानीय और क्लाउड फ़ाइलें

#### सेटअप

स्थानीय या क्लाउड फ़ाइलों के लिए, Inference CLI इंस्टॉल करें:

```bash
pip install inference-cli
export ROBOFLOW_API_KEY="YOUR-API-KEY-GOES-HERE"
```

क्लाउड स्टोरेज के समर्थन के लिए:

```bash
pip install 'inference-cli[cloud-storage]'
```

अगर आपको अपनी API कुंजी ढूँढ़ने में मदद चाहिए, तो हमारी [प्रमाणीकरण गाइड](https://docs.roboflow.com/reference/authentication/authentication/find-your-roboflow-api-key).

#### डेटा इनजेस्ट करें

**इमेज**

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

**वीडियो**

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

{% hint style="info" %}
बैच ID में केवल छोटे अक्षरों, अंकों, हाइफ़न (`-`) और अंडरस्कोर (`_`).
{% endhint %}

**क्लाउड स्टोरेज**

अगर आपका डेटा पहले से ही क्लाउड स्टोरेज (S3, Google Cloud Storage या Azure) में है, तो आप फ़ाइलों को स्थानीय रूप से डाउनलोड किए बिना सीधे प्रोसेस कर सकते हैं।

इमेज के लिए:

```bash
inference rf-cloud data-staging create-batch-of-images \
  --data-source cloud-storage \
  --bucket-path <cloud-path> \
  --batch-id <your-batch-id>
```

वीडियो के लिए:

```bash
inference rf-cloud data-staging create-batch-of-videos \
  --data-source cloud-storage \
  --bucket-path <cloud-path> \
  --batch-id <your-batch-id>
```

यह `--bucket-path` पैरामीटर इन प्रोवाइडर को सपोर्ट करता है। ग्लोब पैटर्न से तय होता है कि कौन-सी फ़ाइलें इनजेस्ट की जाएँगी:

<table data-search="false"><thead><tr><th>प्रोवाइडर</th><th>पाथ फ़ॉर्मैट</th><th>ग्लोब का उदाहरण</th></tr></thead><tbody><tr><td>S3</td><td><code>s3://bucket-name/path/</code></td><td><code>s3://my-bucket/training-data/**/*.jpg</code>: सभी JPG फ़ाइलें, सभी सबफ़ोल्डरों में</td></tr><tr><td>Google Cloud Storage</td><td><code>gs://bucket-name/path/</code></td><td><code>gs://my-bucket/videos/2024-*/*.mp4</code>: इन फ़ोल्डरों में मौजूद MP4 फ़ाइलें <code>2024-*</code> फ़ोल्डरों</td></tr><tr><td>Azure Blob Storage</td><td><code>az://container-name/path/</code></td><td><code>az://container/images/*.png</code>: images फ़ोल्डर में मौजूद PNG फ़ाइलें</td></tr></tbody></table>

{% hint style="info" %}
आपके क्लाउड स्टोरेज क्रेडेंशियल का उपयोग CLI केवल स्थानीय रूप से प्री-साइन्ड URL बनाने के लिए करता है। इन्हें कभी भी Roboflow सर्वर पर अपलोड नहीं किया जाता।
{% endhint %}

{% hint style="warning" %}
बनाए गए प्री-साइन्ड URL 24 घंटे तक मान्य रहते हैं। सुनिश्चित करें कि आपका बैच प्रोसेसिंग जॉब इस अवधि के भीतर पूरा हो जाए।
{% endhint %}

बड़े डेटासेट के लिए, सिस्टम इमेज को अपने-आप 20,000 फ़ाइलों के हिस्सों में बाँट देता है। वीडियो के लिए 1,000 से कम के बैच बेहतर रहते हैं।

**साइन्ड URL से इनजेशन**

उन्नत ऑटोमेशन के लिए, आप स्थानीय फ़ाइलों के बजाय साइन्ड URL के ज़रिए डेटा इनजेस्ट कर सकते हैं:

<table data-search="false"><thead><tr><th>फ़्लैग</th><th>विवरण</th></tr></thead><tbody><tr><td><code>--data-source references-file</code></td><td>साइन्ड URL के ज़रिए संदर्भित फ़ाइलों को प्रोसेस करें।</td></tr><tr><td><code>--references &#x3C;path_or_url></code></td><td>फ़ाइल URL वाली JSONL फ़ाइल का पाथ, या उस फ़ाइल की ओर संकेत करने वाला साइन्ड URL।</td></tr></tbody></table>

रेफ़रेंस फ़ाइलें इस फ़ॉर्मैट का उपयोग करती हैं: `JSONL`:

```
{"name": "<unique-file-name-1>", "url": "https://<signed-url>"}
{"name": "<unique-file-name-2>", "url": "https://<signed-url>"}
```

{% hint style="info" %}
साइन्ड URL से इनजेशन, Enterprise और पहले वाले Growth प्लान में उपलब्ध है।
{% endhint %}

#### स्टेज किए गए डेटा की जाँच करें

```bash
inference rf-cloud data-staging show-batch-details --batch-id <your-batch-id>
```

#### जॉब शुरू करें

**इमेज प्रोसेस करें**

```bash
inference rf-cloud batch-processing process-images-with-workflow \
  --workflow-id <workflow-id> \
  --batch-id <batch-id> \
  --machine-type gpu
```

**वीडियो प्रोसेस करें**

```bash
inference rf-cloud batch-processing process-videos-with-workflow \
  --workflow-id <workflow-id> \
  --batch-id <batch-id> \
  --machine-type gpu \
  --max-video-fps <your-desired-fps>
```

{% hint style="info" %}
अपनी Workflow ID जानने के लिए, Roboflow App में Workflow Editor खोलें, "Deploy" पर क्लिक करें और कोड स्निपेट में पहचानकर्ता खोजें।
{% endhint %}

{% hint style="info" %}
डिफ़ॉल्ट रूप से, प्रोसेसिंग CPU पर चलती है। `--machine-type gpu` का उपयोग ऐसे Workflows के लिए करें जिनमें कई या बड़े मॉडल हों।
{% endhint %}

#### जॉब की प्रगति पर नज़र रखें

स्टार्ट कमांड एक जॉब ID देता है। स्थिति जाँचने के लिए इसका उपयोग करें:

```bash
inference rf-cloud batch-processing show-job-details --job-id <your-job-id>
```

#### नतीजे एक्सपोर्ट करें

जॉब के विवरण में आउटपुट बैच ID शामिल होगा। परिणाम एक्सपोर्ट करने के लिए इसका उपयोग करें:

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

#### वेबहुक ऑटोमेशन

स्थिति जानने के लिए बार-बार अनुरोध करने के बजाय, अंतर्ग्रहण या प्रोसेसिंग पूरी होने पर सूचना पाने के लिए वेबहुक का उपयोग कर सकते हैं।

**डेटा अंतर्ग्रहण वेबहुक**

CLI कमांड `create-batch-of-images` और `create-batch-of-videos` इनका समर्थन करते हैं:

<table data-search="false"><thead><tr><th>फ़्लैग</th><th>विवरण</th></tr></thead><tbody><tr><td><code>--notifications-url &#x3C;webhook_url></code></td><td>सूचनाओं के लिए वेबहुक एंडपॉइंट।</td></tr><tr><td><code>--notification-category ingest-status</code></td><td>अंतर्ग्रहण प्रक्रिया की समग्र स्थिति। डिफ़ॉल्ट।</td></tr><tr><td><code>--notification-category files-status</code></td><td>अलग-अलग फ़ाइलों की प्रोसेसिंग स्थिति।</td></tr></tbody></table>

सूचनाएँ HTTP POST के ज़रिए भेजी जाती हैं, जिसमें `Authorization` हेडर में आपकी Roboflow Publishable Key होती है।

**अंतर्ग्रहण स्थिति की सूचना**

```json
{
    "type": "roboflow-data-staging-notification-v1",
    "event_id": "8c20f970-fe10-41e1-9ef2-e057c63c07ff",
    "ingest_id": "8cd48813430f2be70b492db67e07cc86",
    "batch_id": "test-batch-117",
    "shard_id": null,
    "notification": {
        "type": "ingest-status-notification-v1",
        "success": false,
        "error_details": {
            "type": "unsafe-url-detected",
            "reason": "Untrusted domain found: https://example.com/image.png"
        }
    },
    "delivery_attempt": 1
}
```

**फ़ाइल स्थिति की सूचना**

```json
{
    "type": "roboflow-data-staging-notification-v1",
    "event_id": "8f42708b-aeb7-4b73-9d83-cf18518b6d81",
    "ingest_id": "d5cb69aa-b2d1-4202-a1c1-0231f180bda9",
    "batch_id": "prod-batch-1",
    "shard_id": "0d40fa12-349e-439f-83f8-42b9b7987b33",
    "notification": {
        "type": "ingest-files-status-notification-v1",
        "success": true,
        "ingested_files": [
            "000000494869.jpg",
            "000000186042.jpg"
        ],
        "failed_files": [
            {
                "type": "file-size-limit-exceeded",
                "file_name": "big_image.png",
                "reason": "Max size of single image is 20971520B."
            }
        ],
        "content_truncated": false
    },
    "delivery_attempt": 1
}
```

**जॉब पूरा होने के वेबहुक**

जोड़ें `--notifications-url` जॉब शुरू करते समय:

```bash
inference rf-cloud batch-processing process-images-with-workflow \
  --workflow-id <workflow-id> \
  --batch-id <batch-id> \
  --notifications-url <webhook_url>
```

**जॉब पूरा होने की सूचना**

```json
{
  "type": "roboflow-batch-job-notification-v1",
  "event_id": "8f42708b-aeb7-4b73-9d83-cf18518b6d81",
  "job_id": "<your-batch-job-id>",
  "job_state": "success | fail",
  "delivery_attempt": 1
}
```

#### क्लाउड स्टोरेज प्रमाणीकरण

**AWS S3 और S3-संगत स्टोरेज**

क्रेडेंशियल अपने-आप इन स्रोतों से पहचाने जाते हैं:

1. पर्यावरण वेरिएबल:

```bash
export AWS_ACCESS_KEY_ID=your-access-key-id
export AWS_SECRET_ACCESS_KEY=your-secret-access-key
export AWS_SESSION_TOKEN=your-session-token  # Optional
```

2. AWS क्रेडेंशियल फ़ाइलें (`~/.aws/credentials`, `~/.aws/config`)
3. IAM भूमिकाएँ (EC2, ECS, Lambda)

नामित प्रोफ़ाइल:

```bash
export AWS_PROFILE=production
```

S3-संगत सेवाओं के लिए (उदा.: Cloudflare R2, MinIO):

```bash
export AWS_ENDPOINT_URL=https://account-id.r2.cloudflarestorage.com
export AWS_REGION=auto  # R2 requires region='auto'
export AWS_ACCESS_KEY_ID=your-r2-access-key
export AWS_SECRET_ACCESS_KEY=your-r2-secret-key
```

**Google Cloud Storage**

क्रेडेंशियल यहाँ से पहचाने जाते हैं:

1. सेवा खाता कुंजी फ़ाइल (ऑटोमेशन के लिए अनुशंसित):

```bash
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json
```

2. gcloud CLI से उपयोगकर्ता क्रेडेंशियल (`gcloud auth login`)
3. GCP मेटाडेटा सेवा (Google Cloud Platform पर चलने पर)

**Azure Blob Storage**

SAS टोकन (अनुशंसित):

```bash
export AZURE_STORAGE_ACCOUNT_NAME=mystorageaccount
export AZURE_STORAGE_SAS_TOKEN="YOUR_SAS_TOKEN"
```

खाता कुंजी:

```bash
export AZURE_STORAGE_ACCOUNT_NAME=mystorageaccount
export AZURE_STORAGE_ACCOUNT_KEY=your-account-key
```

Azure CLI से SAS टोकन जनरेट करें। `<expiry-utc>` को भविष्य के UTC समय से बदलें, इस `YYYY-MM-DDTHH:MMZ` फ़ॉर्मैट में:

```bash
az storage container generate-sas \
  --account-name mystorageaccount \
  --name my-container \
  --permissions rl \
  --expiry <expiry-utc>
```

**कस्टम स्क्रिप्ट**

उन्नत उपयोग के मामलों के लिए, हस्ताक्षरित URL फ़ाइलें जनरेट करने वाली स्क्रिप्ट देखें:

* AWS S3: [generateS3SignedUrls.sh](https://raw.githubusercontent.com/roboflow/roboflow-python/main/scripts/generateS3SignedUrls.sh)
* Google Cloud Storage: [generateGCSSignedUrls.sh](https://raw.githubusercontent.com/roboflow/roboflow-python/main/scripts/generateGCSSignedUrls.sh)
* Azure Blob Storage: [generateAzureSasUrls.sh](https://raw.githubusercontent.com/roboflow/roboflow-python/main/scripts/generateAzureSasUrls.sh)

#### सभी विकल्प देखें

```bash
inference rf-cloud --help
inference rf-cloud data-staging --help
inference rf-cloud batch-processing --help
```

### एसेट लाइब्रेरी की इमेजें

को बदलें `<workspace-url>` अपने Workspace स्लग से (उदाहरण: `my-workspace`)। एक प्रकाशित Workflow चुनें, जिसमें एक `image` इनपुट हो। अन्य आवश्यक इनपुट के लिए डिफ़ॉल्ट मान दें, सिवाय `source_id`के, जिसे Batch Processing हर इमेज के लिए भरता है।

इंस्टॉल करें या अपडेट करें [Roboflow CLI](https://docs.roboflow.com/reference/platform/cli), साइन इन करें और अपने Workflows की सूची देखें:

```bash
pip install --upgrade roboflow
roboflow auth login
roboflow --workspace <workspace-url> --json workflow list
```

JSON आउटपुट से किसी प्रकाशित Workflow का `id` इस्तेमाल करें। प्रोसेस करने के लिए इमेजें खोजने हेतु [RoboQL](https://docs.roboflow.com/platform/workspaces/asset-library) खोज करें:

```bash
roboflow --workspace <workspace-url> --json image search "tag:night-shift" \
  --fields id,filename
```

खोज के नतीजों से इमेज ID को `--image-ids`:

```bash
roboflow --workspace <workspace-url> batch create \
  --workflow <workflow-id> \
  --image-ids <image-id-1>,<image-id-2>
```

किसी संरचित फ़िल्टर से मेल खाने वाली सभी इमेजें प्रोसेस करने के लिए, `--image-ids` की जगह `--query "tag:night-shift"`का इस्तेमाल करें। `--all` का इस्तेमाल पूरी Asset Library को प्रोसेस करने के लिए करें। चयन का ठीक एक विकल्प चुनें।

create के जवाब में शामिल हैं `taskId`, `jobId`, और `requestId`। काम पूरा होने तक प्रतीक्षा करने के लिए टास्क ID और जॉब की जाँच करने के लिए जॉब ID का इस्तेमाल करें:

```bash
roboflow --workspace <workspace-url> asynctasks wait <task-id>
roboflow --workspace <workspace-url> batch status <job-id>
roboflow --workspace <workspace-url> batch list
```

{% hint style="info" %}
अगर आप टर्मिनल बंद कर दें या प्रतीक्षा कमांड का समय समाप्त हो जाए, तब भी जॉब चलता रहता है। नेटवर्क त्रुटि के बाद, उन्हीं विकल्पों के साथ फिर से प्रयास करें। डुप्लिकेट जॉब बनाने से बचने के लिए, `requestId` रिस्पॉन्स या त्रुटि संकेत से लेकर इसे इस रूप में पास करें: `--request-id <request-id>` ।
{% endhint %}

किसी जॉब को रोकने के लिए `batch abort <job-id>` का उपयोग करें, या उसे `batch restart <job-id>` से उसकी मौजूदा कॉन्फ़िगरेशन के साथ फिर से चलाएँ। दोनों कमांड पुष्टि माँगते हैं; स्क्रिप्ट के लिए `--yes` जोड़ें। रीस्टार्ट करने पर क्रेडिट खर्च हो सकते हैं।
