Antigravity की मदद से, Google Cloud पर ऐप्लिकेशन बनाना और उसे डिप्लॉय करना

1. परिचय

fca14bb9f4bb74f4.png

इस कोडलैब में, Google Antigravity का इस्तेमाल करके, Google Cloud पर सर्वरलेस ऐप्लिकेशन डिज़ाइन करने, बनाने, और डिप्लॉय करने का तरीका बताया गया है. हम सर्वरलेस और इवेंट-ड्रिवन दस्तावेज़ पाइपलाइन बनाएंगे. यह पाइपलाइन, Google Cloud Storage (GCS) से फ़ाइलें लेती है, Cloud Run और Gemini का इस्तेमाल करके उन्हें प्रोसेस करती है, और उनके मेटाडेटा को BigQuery में स्ट्रीम करती है.

आपको क्या सीखने को मिलेगा

  • आर्किटेक्चरल प्लानिंग और डिज़ाइन के लिए, Antigravity का इस्तेमाल करने का तरीका.
  • एआई एजेंट की मदद से, कोड के तौर पर इन्फ़्रास्ट्रक्चर (शेल स्क्रिप्ट) जनरेट करने का तरीका.
  • Python पर आधारित Cloud Run सेवा बनाने और डिप्लॉय करने का तरीका.
  • मल्टीमॉडल दस्तावेज़ के विश्लेषण के लिए, Vertex AI पर Gemini को इंटिग्रेट करने का तरीका.
  • Antigravity के Walkthrough आर्टफ़ैक्ट का इस्तेमाल करके, एंड-टू-एंड पाइपलाइन की पुष्टि करने का तरीका.

आपको इनकी ज़रूरत होगी

  • Google Antigravity इंस्टॉल होना चाहिए.
  • आपके पास बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट होना चाहिए.
  • gcloud सीएलआई इंस्टॉल और पुष्टि किया गया होना चाहिए.

2. ऐप्लिकेशन की खास जानकारी

Antigravity का इस्तेमाल करके, ऐप्लिकेशन का आर्किटेक्चर तैयार करने और उसे लागू करने से पहले, आइए हम उस ऐप्लिकेशन की खास जानकारी देखते हैं जिसे हमें बनाना है.

हमें सर्वरलेस और इवेंट-ड्रिवन दस्तावेज़ पाइपलाइन बनानी है. यह पाइपलाइन, Google Cloud Storage (GCS) से फ़ाइलें लेती है, Cloud Run और Gemini का इस्तेमाल करके उन्हें प्रोसेस करती है, और उनके मेटाडेटा को BigQuery में स्ट्रीम करती है.

इस ऐप्लिकेशन के लिए, हाई लेवल आर्किटेक्चर डायग्राम कुछ ऐसा दिख सकता है:

3bd519cfab38258d.png

यह सटीक नहीं होना चाहिए. Antigravity, आर्किटेक्चर की जानकारी समझने में हमारी मदद कर सकता है. हालांकि, यह जानना ज़रूरी है कि आपको क्या बनाना है. जितनी ज़्यादा जानकारी दी जाएगी, आर्किटेक्चर और कोड के मामले में Antigravity से उतने ही बेहतर नतीजे मिलेंगे.

3. आर्किटेक्चर की योजना बनाना

हम Antigravity की मदद से, आर्किटेक्चर की जानकारी की योजना बनाने के लिए तैयार हैं!

Antigravity, जटिल सिस्टम की योजना बनाने में माहिर है. हम तुरंत कोड लिखने के बजाय, हाई-लेवल आर्किटेक्चर तय करके शुरुआत कर सकते हैं. साथ ही, Antigravity को हमारे अनुरोध का आकलन करने, हमसे फ़ॉलो अप सवाल पूछने, और फिर अपनी प्लानिंग और लागू करने की प्रोसेस को आगे बढ़ाने में मदद करने के लिए, किसी एक सुविधा का इस्तेमाल कर सकते हैं.

मान लेते हैं कि आपने Antigravity लॉन्च कर दिया है. अब हम इस कोडलैब के लिए एक नया प्रोजेक्ट बनाएंगे.

Projects लैब के बगल में मौजूद, नए प्रोजेक्ट के आइकॉन पर क्लिक करें. इसके बाद, नीचे दिखाए गए तरीके से New Project पर क्लिक करें:

949cd615a1ce8dc3.png

इससे Add Folder विकल्प दिखेगा, जैसा कि नीचे दिखाया गया है:

ee8ff88b71c10e9f.png

अपने प्रोजेक्ट में फ़ोल्डर जोड़ने के लिए, Add Folder बटन पर क्लिक करें. मैंने अपने कंप्यूटर पर google-cloud-serverless-app फ़ोल्डर बनाया और उसे इस प्रोजेक्ट में जोड़ा.

इससे google-cloud-serverless-app प्रोजेक्ट में बातचीत शुरू हो जाती है.

स्क्रीन के सबसे नीचे बाईं ओर मौजूद, मुख्य सेटिंग आइकॉन ⚙️ पर क्लिक करें. इसके बाद, प्रोजेक्ट की सेटिंग पर जाएं. अगर आपको google-cloud-serverless-app प्रोजेक्ट की सूची नहीं दिखती है, तो सिर्फ़ एक बातचीत करें. इसके बाद, प्रोजेक्ट की सेटिंग पर वापस जाएं.

Agent Settings / Security Preset को Default और Agent Behaviour / Artifact Review Policy को Always Ask पर सेट करें. जैसा कि नीचे दिखाया गया है:

b28e175be64f4390.png

इससे यह पक्का होगा कि हर चरण में, एजेंट के प्लान को लागू करने से पहले, आपको उसकी समीक्षा करने और उसे मंज़ूरी देने का मौका मिलेगा.

प्रॉम्प्ट

अब हम Antigravity को अपना पहला प्रॉम्प्ट देने के लिए तैयार हैं. हम अपने अनुरोध का आकलन करने के लिए, स्लैश कमांड /grill-me का इस्तेमाल करेंगे.

/grill-me टाइप करें. इसके बाद, यह प्रॉम्प्ट डालें और सबमिट करें बटन पर क्लिक करें:

/grill-me 

I want to build a serverless event-driven document processing pipeline on Google Cloud.
Architecture:
- Ingestion: Users upload files to a Cloud Storage bucket.
- Trigger: File uploads trigger a Pub/Sub message.
- Processor: A Python-based Cloud Run service receives the message, processes the file (simulated OCR), and extracts metadata.
- Storage: Stream the metadata (filename, date, tags, word_count) into a BigQuery dataset.

/grill-me कमांड, कई फ़ॉलो अप सवाल पूछता है. अपनी जानकारी के हिसाब से, इन सवालों के जवाब दिए जा सकते हैं. यह सुझाए गए जवाब भी दिखाता है. अगर चाहें, तो इनका इस्तेमाल किया जा सकता है.

मेरे /grill-me कमांड का सैंपल रन नीचे दिखाया गया है:

How would you like the Cloud Run service to receive events from Cloud Storage and Pub/Sub?
(Recommended) Cloud Storage Pub/Sub Notification with a Pub/Sub Push Subscription (HTTP POST to Cloud Run)

How should access to the Cloud Run service endpoint be secured for Pub/Sub push requests?
Publicly accessible Cloud Run service without authentication (for prototyping/quick testing only)

How should the Python processor handle file inspection and the simulated OCR logic?
(Recommended) Download file from GCS: if plain text/utf-8, extract actual words and tags; if binary/image/PDF, simulate OCR processing (mock latency, generate synthetic text & tags, count words)

How should the processor write metadata to BigQuery and handle table/schema provisioning?
(Recommended) Use BigQuery Streaming Inserts (`insert_rows_json`) with auto-creation of the dataset and table if they do not exist

How should the Cloud Run service handle processing failures and retries from Pub/Sub?
(Recommended) Return HTTP 500 on transient errors for Pub/Sub automatic retry; return HTTP 200/204 on non-retryable errors (e.g., file not found, bad event format) to avoid poison pill loops

Which web framework would you prefer for the Python Cloud Run service?
Flask with Gunicorn: minimal, classic lightweight standard for GCP microservices

How would you like the cloud infrastructure (Bucket, Pub/Sub, Cloud Run, BigQuery) to be provisioned and deployed?
(Recommended) Provide both: automated `gcloud` CLI setup/deploy scripts for quick manual rollout AND Terraform manifests for reproducible IaC

How would you like to handle local testing and development before deploying to Google Cloud?
(Recommended) Include a local mock test suite and script (`test_local.py`) that can simulate Pub/Sub push envelopes and test processing with both mocked GCP clients and actual files

ध्यान दें कि मैंने Antigravity से ये काम करने के लिए कहा है:

  • संसाधन उपलब्ध कराने के लिए, gcloud सीएलआई की आसान स्क्रिप्ट
  • नेटिव Cloud Storage Pub/Sub सूचनाएं + Cloud Run के लिए Pub/Sub पुश सदस्यता
  • फ़्रेमवर्क के लिए Flask (Gunicorn के साथ) का इस्तेमाल करना
  • लाइव ओसीआर डेटा के बजाय, डेटा के लिए सिर्फ़ टेक्स्ट फ़ाइल के साथ लोकल सिम्युलेशन का इस्तेमाल करना
  • BigQuery में लाइनें जोड़ने के लिए, BigQuery table.insert_rows() का इस्तेमाल करना
  • बिना पुष्टि के Cloud Run डिप्लॉयमेंट

और अन्य सुझाए गए विकल्प.

लागू करने की योजना और टास्क की सूची

Antigravity अब काम करना शुरू करेगा और लागू करने की योजना जनरेट करेगा. यह आपको नीचे दिए गए मैसेज जैसा कोई मैसेज देकर, समीक्षा के लिए योजना दिखाता है:

3cc503e352eee935.png

सबसे ऊपर दाईं ओर मौजूद, ऑक्ज़िलरी पैन टॉगल पर क्लिक करके, जनरेट किए गए आर्टफ़ैक्ट देखे जा सकते हैं. फ़िलहाल, यह सिर्फ़ लागू करने की योजना है.

883adedf0157a073.png

इस प्लान में ये बातें शामिल हैं:

  • इन्फ़्रास्ट्रक्चर: GCS बकेट, Pub/Sub विषय, BigQuery डेटासेट.
  • प्रोसेसर: Python/Flask ऐप्लिकेशन, Dockerfile, ज़रूरी शर्तें.
  • इंटिग्रेशन: GCS सूचनाएं → Pub/Sub → Cloud Run.

आपको कुछ ऐसा दिखेगा: हमारे कंप्यूटर पर, लागू करने की योजना की आंशिक सूची यहां दिखाई गई है:

5fb0baef49bdb8b1.png

इसे ध्यान से पढ़ें. आपके पास लागू करने के बारे में सुझाव या राय देने का मौका है. लागू करने की योजना के किसी भी हिस्से पर क्लिक करके, टिप्पणियां जोड़ी जा सकती हैं. कुछ टिप्पणियां जोड़ने के बाद, पक्का करें कि आपने उन बदलावों को समीक्षा के लिए सबमिट किया हो जो आपको देखने हैं. खास तौर पर, नामकरण, Google Cloud प्रोजेक्ट आईडी, रीजन वगैरह से जुड़े बदलाव.

अगर सब कुछ ठीक लगता है, तो Proceed बटन पर क्लिक करके, एजेंट को लागू करने की योजना के साथ आगे बढ़ने की अनुमति दें.

4. ऐप्लिकेशन जनरेट करना

प्लान को मंज़ूरी मिलने के बाद, Antigravity, ऐप्लिकेशन के लिए ज़रूरी फ़ाइलें जनरेट करना शुरू करता है. इसमें, स्क्रिप्ट उपलब्ध कराने से लेकर ऐप्लिकेशन कोड तक शामिल है.

Antigravity एक फ़ोल्डर बनाएगा और प्रोजेक्ट के लिए ज़रूरी फ़ाइलें बनाना शुरू करेगा. अगर आर्टफ़ैक्ट देखे जाएं, तो आपको कई फ़ाइलें (सोर्स कोड, स्क्रिप्ट फ़ाइलें वगैरह) जनरेट होती दिखेंगी.

f6f4e4473fb2a8b3.png

अपना काम पूरा करने के बाद, यह इस बारे में बताएगा. साथ ही, Walkthrough दस्तावेज़ बनाएगा, जिसे देखा जा सकता है. यहां सैंपल आउटपुट दिखाया गया है:

752ebdb9767a82c9.png

Walkthrough दस्तावेज़ में, लागू की गई चीज़ों, जनरेट की गई स्क्रिप्ट, और सबसे अहम बात यह है कि पुष्टि और मान्य करने की प्रोसेस के बारे में बताया गया है. Walkthrough दस्तावेज़ का आंशिक आउटपुट यहां दिखाया गया है. इसमें पुष्टि और मान्य करने की प्रोसेस शामिल है:

3. Verification & Validation
Test Suite Execution
We ran the automated test suite using pytest:
bash
.venv/bin/pytest tests/ -v
tests/test_local.py::test_health_check PASSED                            [  9%]
tests/test_local.py::test_invalid_pubsub_envelope PASSED                 [ 18%]
tests/test_local.py::test_ignore_delete_events PASSED                    [ 27%]
tests/test_local.py::test_gcs_file_not_found PASSED                      [ 36%]
tests/test_local.py::test_successful_contract_processing PASSED          [ 45%]
tests/test_local.py::test_successful_pdf_ocr_processing PASSED           [ 54%]
tests/test_local.py::test_transient_bq_error_triggers_500_retry PASSED   [ 63%]
tests/test_processor.py::test_tag_extraction_filters_stopwords PASSED    [ 72%]
tests/test_processor.py::test_process_plain_text_document PASSED         [ 81%]
tests/test_processor.py::test_process_binary_pdf_simulated_ocr PASSED    [ 90%]
tests/test_processor.py::test_process_empty_text_document PASSED         [100%]
============================== 11 passed in 2.37s ==============================
Standalone End-to-End Simulation
We executed the standalone simulation script:
bash
.venv/bin/python tests/test_local.py
Sample Output:
=================================================================
Running Serverless Document Processing Local Simulation
=================================================================
[1] Health Check: Status=200, Payload={'service': 'document-processor', 'status': 'healthy'}
[2] Simulating GCS Event: Object Finalized 'sample_contract.txt' in 'finance-bucket'
   Response: Status=200, Body={'file_name': 'sample_contract.txt', 'ocr_status': 'EXTRACTED_TEXT', 'status': 'success', 'tags': ['provider', 'cloud', 'client', 'agreement', 'shall'], 'word_count': 181}
[3] Simulating GCS Event: Object Finalized 'sample_invoice.pdf' in 'invoices-bucket'
   Response: Status=200, Body={'file_name': 'sample_invoice.pdf', 'ocr_status': 'SIMULATED_OCR', 'status': 'success', 'tags': ['invoice', 'finance', 'billing', 'acme', 'pdf'], 'word_count': 62}
=================================================================
BigQuery Streamed Table Inspection (Mock Table)
=================================================================
Row #1:
 File:       sample_contract.txt (gs://finance-bucket)
 Status:     EXTRACTED_TEXT
 Words:      181
 Tags:       ['provider', 'cloud', 'client', 'agreement', 'shall']
 Processed:  2026-09-08T02:50:37.436225+00:00
Row #2:
 File:       sample_invoice.pdf (gs://invoices-bucket)
 Status:     SIMULATED_OCR
 Words:      62
 Tags:       ['invoice', 'finance', 'billing', 'acme', 'pdf']
 Processed:  2026-09-08T02:50:37.641931+00:00

हम Antigravity से पूछ सकते हैं कि इस ऐप्लिकेशन को Google Cloud पर कैसे डिप्लॉय किया जाए? यह इस बारे में पूरी जानकारी देता है, जैसा कि नीचे बताया गया है. संक्षेप में, यह हमसे यह पक्का करने के लिए कहता है कि Google Cloud SDK इंस्टॉल हो और Google Cloud प्रोजेक्ट सेटअप हो. इसके बाद,

पहला चरण: ज़रूरी जीसीपी एपीआई चालू करना

Cloud Run, Pub/Sub, Cloud Storage, BigQuery, और Cloud Build API चालू करने के लिए, setup_gcp.sh चलाएं: ./scripts/setup_gcp.sh

दूसरा चरण: पूरी पाइपलाइन डिप्लॉय करना

deploy.sh चलाएं:

export GCP_PROJECT="<YOUR_PROJECT_ID>"
export GCP_REGION="us-central1"               # or your region
./scripts/deploy.sh

यह स्क्रिप्ट पर्दे के पीछे क्या करती है:

  1. Google Cloud Build का इस्तेमाल करके, कंटेनर इमेज बनाता है और उसे Container/Artifact Registry में पुश करता है.
  2. सेवा को Cloud Run पर, सही एनवायरमेंट वैरिएबल (GCP_PROJECT, BQ_DATASET_ID, BQ_TABLE_ID) के साथ डिप्लॉय करता है.
  3. Cloud Storage में, डेटा लेने के लिए बकेट (gs://<PROJECT_ID>-document-ingest) बनाता है.
  4. Pub/Sub विषय (document-upload-events) बनाता है और GCS को इस पर पब्लिश करने की अनुमति देता है.
  5. बकेट पर GCS सूचना (OBJECT_FINALIZE) कॉन्फ़िगर करता है.
  6. Cloud Run सेवा के यूआरएल को टारगेट करने वाली, Pub/Sub पुश सदस्यता बनाता है. इसमें, गड़बड़ी होने पर अपने-आप फिर से कोशिश करने की सुविधा होती है.

यह पाइपलाइन को टेस्ट करने का तरीका भी बताता है.

test_pipeline.sh चलाएं: ./scripts/test_pipeline.sh

इससे samples/sample_contract.txt और samples/sample_invoice.pdf आपकी बकेट में अपलोड हो जाती हैं. इसके बाद, प्रोसेसिंग का इंतज़ार किया जाता है. साथ ही, BigQuery SQL क्वेरी चलाई जाती है. इसमें, निकाला गया मेटाडेटा, शब्दों की संख्या, और टैग दिखते हैं.

5. ऐप्लिकेशन डिप्लॉय करना

आइए, बताए गए तरीके से ऐप्लिकेशन डिप्लॉय करें. हम Antigravity से इसे हमारे लिए चलाने के लिए कह सकते हैं. हालांकि, इससे पहले पक्का करें कि gcloud सीएलआई मौजूद हो और Google Cloud प्रोजेक्ट के लिए कॉन्फ़िगर किया गया हो.

हम Antigravity को "Deploy the application for me" प्रॉम्प्ट दे सकते हैं. इससे, आपसे अलग-अलग अनुमतियों के बारे में पूछा जाएगा. इसके बाद, स्क्रिप्ट फ़ाइलें चलाई जाएंगी.

यह प्रोसेस, बैकग्राउंड में चलने वाले टास्क के तौर पर शुरू होती है. इसके बारे में, नीचे दिए गए मैसेज में बताया गया है:

I have initiated the deployment of the document processing pipeline to Google Cloud project PROJECT_ID in REGION.The deployment process is currently executing in the background:

Building and publishing the container image via Cloud Build.

Configuring service account IAM permissions and deploying the Cloud Run service.

Provisioning the Cloud Storage bucket (gs://PROJECT_ID-document-ingest).

Setting up the Pub/Sub topic, GCS notification, and push subscription.

I will notify you as soon as the deployment finishes!

6. ऐप्लिकेशन की पुष्टि करना

पाइपलाइन डिप्लॉय होने के बाद, Antigravity यह पुष्टि करता है कि ऐप्लिकेशन काम कर रहा है या नहीं. यह हमसे पूछता है कि क्या वह test_pipeline.sh फ़ाइल चला सकता है. हम उसे अनुमति दे सकते हैं.

आखिर में, यह हमें यह जानकारी देता है:

🚀 Deployment Successful & Verified on Google Cloud!

The application has been deployed to Google Cloud project PROJECT_ID in REGION and end-to-end event-driven processing has been verified.

इसने नतीजों को देखने के लिए, Walkthrough आर्टफ़ैक्ट को भी अपडेट कर दिया है. इसकी आंशिक सूची यहां दी गई है:

डिप्लॉयमेंट की खास जानकारी

  • जीसीपी प्रोजेक्ट: PROJECT_ID
  • रीजन: REGION
  • Cloud Run सेवा: document-processor
  • Cloud Run एंडपॉइंट: SERVICE_URL
  • Cloud Storage बकेट: gs://PROJECT_ID-document-ingest
  • Pub/Sub विषय: document-upload-events
  • Pub/Sub पुश सदस्यता: document-upload-events-push-sub
  • BigQuery टारगेट: PROJECT_ID.document_processing.document_metadata

लाइव पाइपलाइन की पुष्टि

हमने लाइव Google Cloud एनवायरमेंट के ख़िलाफ़, scripts/test_pipeline.sh चलाया:

  1. sample_contract.txt और sample_invoice.pdf को Cloud Storage बकेट में अपलोड किया.
  2. GCS ने Pub/Sub को OBJECT_FINALIZE इवेंट जनरेट किए.
  3. Pub/Sub ने एनवलप को Cloud Run माइक्रोसेवा में पुश किया.
  4. Cloud Run ने मेटाडेटा निकाला, सिम्युलेट किए गए ओसीआर को प्रोसेस किया, और रिकॉर्ड को BigQuery में स्ट्रीम किया.

लाइव BigQuery क्वेरी का आउटपुट

+------------------------------+------------+----------------+---------------------------------------------------+---------------------+
|          file_name           | word_count |   ocr_status   |                       tags                        |    processed_at     |
+------------------------------+------------+----------------+---------------------------------------------------+---------------------+
| test_invoice_1788840194.pdf  |         62 | SIMULATED_OCR  | ["invoice","finance","billing","acme","pdf"]      | 2026-09-08 04:03:27 |
| test_contract_1788840194.txt |        181 | EXTRACTED_TEXT | ["provider","cloud","client","agreement","shall"] | 2026-09-08 04:03:22 |
+------------------------------+------------+----------------+---------------------------------------------------+---------------------+

पाइपलाइन के सभी कॉम्पोनेंट, प्रोडक्शन में चालू, सही तरीके से काम कर रहे हैं, और उनकी पुष्टि हो चुकी है.

वैकल्पिक: मैन्युअल तरीके से पुष्टि करना

भले ही, Antigravity ने ऐप्लिकेशन की पुष्टि कर दी हो, लेकिन अगर चाहें, तो Google Cloud console में जाकर, मैन्युअल तरीके से भी यह देखा जा सकता है कि सभी संसाधन बनाए गए हैं या नहीं. इसके लिए, यह तरीका अपनाएं.

Cloud Storage

लक्ष्य: पुष्टि करना कि बकेट मौजूद है और अपलोड की गई फ़ाइलें मौजूद हैं.

  1. Cloud Storage > Buckets पर जाएं.
  2. PROJECT_ID-document-processing नाम की बकेट ढूंढें.
  3. फ़ाइलें ब्राउज़ करने के लिए, बकेट के नाम पर क्लिक करें.
  4. पुष्टि करें: आपको अपलोड की गई फ़ाइलें दिखनी चाहिए. जैसे, sample_contract.txt.

Pub/Sub

लक्ष्य: पुष्टि करना कि विषय मौजूद है और उसकी पुश सदस्यता है.

  1. Pub/Sub > Topics पर जाएं.
  2. document-uploads-events ढूंढें.
  3. विषय के आईडी पर क्लिक करें.
  4. नीचे की ओर स्क्रोल करके, Subscriptions टैब पर जाएं.
  5. पुष्टि करें: पक्का करें कि doc-uploads-events-push-sub सूची में शामिल हो.

Cloud Run

लक्ष्य: सेवा की स्थिति और लॉग देखना.

  1. Cloud Run पर जाएं.
  2. सेवा document-processor पर क्लिक करें.
  3. पुष्टि करें:
  4. स्थिति: हरे रंग का चेकमार्क, यह दिखाता है कि सेवा चालू है.
  5. लॉग: लॉग टैब पर क्लिक करें. "Processing document: gs://..." और "Successfully streamed metadata..." जैसी एंट्री ढूंढें.

BigQuery

लक्ष्य: पुष्टि करना कि डेटा वाकई में स्टोर है.

  1. BigQuery > SQL Workspace पर जाएं.
  2. एक्सप्लोरर पैन में, अपना प्रोजेक्ट > document_processing डेटासेट बड़ा करें.
  3. document_metadata टेबल पर क्लिक करें.
  4. Query टैब पर क्लिक करें और SELECT * स्टेटमेंट के ज़रिए, टेबल की सभी लाइनें वापस पाएं.
  5. पुष्टि करें: आपको file_name, process_at, tags, और word_count वाली लाइनें दिखनी चाहिए.

7. ऐप्लिकेशन के बारे में ज़्यादा जानना

इस समय, आपके पास बेसिक ऐप्लिकेशन उपलब्ध है और वह चल रहा है. इस ऐप्लिकेशन को आगे बढ़ाने से पहले, कोड के बारे में ज़्यादा जानें. आर्टफ़ैक्ट देखे जा सकते हैं. इससे, जनरेट की गई कोड फ़ाइलें दिखनी चाहिए.

यहां कुछ फ़ाइलों की खास जानकारी दी गई है:

  1. deploy.sh: यह मास्टर स्क्रिप्ट है. इससे Google Cloud के सभी संसाधन उपलब्ध कराए जाते हैं और ज़रूरी एपीआई चालू किए जाते हैं.
  2. main.py: यह पाइपलाइन का मुख्य एंट्री पॉइंट है. यह Python ऐप्लिकेशन, एक वेब सर्वर बनाता है. यह सर्वर, Pub/Sub पुश मैसेज पाता है, GCS से फ़ाइल डाउनलोड करता है, उसे "प्रोसेस" (ओसीआर सिम्युलेट करता है) करता है, और मेटाडेटा को BigQuery में स्ट्रीम करता है.
  3. Dockerfile: इससे यह तय होता है कि ऐप्लिकेशन को कंटेनर इमेज में कैसे पैकेज किया जाए.
  4. requirements.txt: इसमें Python की डिपेंडेंसी की सूची होती है.

आपको टेस्ट करने और पुष्टि करने के लिए ज़रूरी अन्य स्क्रिप्ट और टेक्स्ट फ़ाइलें भी दिख सकती हैं.

8. ऐप्लिकेशन को बढ़ाना

अब आपके पास काम करने वाला बेसिक ऐप्लिकेशन है. अब इसे बेहतर बनाया जा सकता है और इसकी सुविधाओं को बढ़ाया जा सकता है. यहां कुछ आइडिया दिए गए हैं.

फ़्रंटएंड जोड़ना

प्रोसेस किए गए दस्तावेज़ देखने के लिए, एक आसान वेब इंटरफ़ेस बनाएं.

यह प्रॉम्प्ट आज़माएं: Create a simple Streamlit or Flask web application that connects to BigQuery. It should display a table of the processed documents (filename, upload_date, tags, word_count) and allow me to filter the results by tag

असली एआई/एमएल के साथ इंटिग्रेट करना

सिम्युलेट किए गए ओसीआर प्रोसेसिंग के बजाय, Gemini मॉडल का इस्तेमाल करके, डेटा निकालें, उसे कैटगरी में बांटें, और उसका अनुवाद करें.

  1. डमी ओसीआर लॉजिक बदलें. असल टेक्स्ट और डेटा निकालने के लिए, इमेज/पीडीएफ़ को Gemini पर भेजें. दस्तावेज़ के टाइप (इनवॉइस, कॉन्ट्रैक्ट, रेज़्यूमे) को कैटगरी में बांटने या इकाइयां (तारीखें, नाम, जगहें) निकालने के लिए, निकाले गए टेक्स्ट का विश्लेषण करें.
  2. दस्तावेज़ की भाषा का अपने-आप पता लगाएं और उसे स्टोर करने से पहले, अंग्रेज़ी में अनुवाद करें. कोई दूसरी भाषा भी इस्तेमाल की जा सकती है.

स्टोरेज और Analytics को बेहतर बनाना

लागत बचाने के लिए, बकेट पर लाइफ़साइकल के नियम कॉन्फ़िगर किए जा सकते हैं, ताकि पुरानी फ़ाइलों को "Coldline" या "Archive" स्टोरेज में ले जाया जा सके.

मज़बूती और सुरक्षा

ऐप्लिकेशन को ज़्यादा मज़बूत और सुरक्षित बनाया जा सकता है. जैसे:

  1. डेड लेटर क्यू (डीएलक्यू): गड़बड़ियों को मैनेज करने के लिए, Pub/Sub सदस्यता अपडेट करें. अगर Cloud Run सेवा, किसी फ़ाइल को पांच बार प्रोसेस नहीं कर पाती है, तो मैसेज को "डेड लेटर" विषय/बकेट में भेजें, ताकि उसकी मैन्युअल तरीके से जांच की जा सके.
  2. Secret Manager: अगर आपके ऐप्लिकेशन को एपीआई पासकोड या संवेदनशील कॉन्फ़िगरेशन की ज़रूरत है, तो उन्हें Secret Manager में स्टोर करें और Cloud Run से सुरक्षित तरीके से ऐक्सेस करें. इसके बजाय, स्ट्रिंग को हार्डकोड न करें.
  3. Eventarc: सीधे Pub/Sub के बजाय, Eventarc पर अपग्रेड करें. इससे इवेंट को ज़्यादा फ़्लेक्सिबल तरीके से रूट किया जा सकता है. साथ ही, जटिल ऑडिट लॉग या जीसीपी सेवा के अन्य इवेंट के आधार पर ट्रिगर किया जा सकता है.

ज़ाहिर है कि आपके पास अपने आइडिया हो सकते हैं. साथ ही, उन्हें लागू करने में मदद पाने के लिए, Antigravity का इस्तेमाल किया जा सकता है!

9. नतीजा

आपने Google Antigravity का इस्तेमाल करके, कुछ ही मिनटों में ज़्यादा डेटा हैंडल करने वाली, सर्वरलेस, एआई की सुविधा वाली दस्तावेज़ पाइपलाइन बना ली है. आपने इनके बारे में सीखा:

  • एआई की मदद से आर्किटेक्चर की योजना बनाना.
  • Antigravity को निर्देश देना और उसे मैनेज करना, ताकि वह कोड जनरेट करने से लेकर डिप्लॉयमेंट और पुष्टि करने तक, ऐप्लिकेशन जनरेट कर सके.
  • Walkthrough की मदद से, डिप्लॉयमेंट और पुष्टि की प्रोसेस की पुष्टि करना.

रेफ़रंस के लिए दस्तावेज़