פיתוח ופריסה ב-Google Cloud באמצעות Antigravity

1. מבוא

fca14bb9f4bb74f4.png

ב-Codelab הזה נלמד איך להשתמש ב-Google Antigravity כדי לתכנן, לבנות ולפרוס אפליקציה בלי שרת (serverless) ב-Google Cloud. ניצור צינור להעברת מסמכים ללא שרתים שמבוסס על אירועים, שקולט קבצים מ-Google Cloud Storage ‏ (GCS), מעבד אותם באמצעות Cloud Run ו-Gemini ומזרים את המטא-נתונים שלהם ל-BigQuery.

מה תלמדו

  • איך משתמשים ב-Antigravity לתכנון ולעיצוב של ארכיטקטורה.
  • יצירת תשתית כקוד (סקריפטים של מעטפת) באמצעות סוכן AI.
  • פיתוח ופריסה של שירות Cloud Run מבוסס Python.
  • שילוב של Gemini ב-Vertex AI לניתוח מולטי-מודאלי של מסמכים.
  • מאמתים את צינור הנתונים מקצה לקצה באמצעות ארטיפקט ההדרכה של Antigravity.

מה תצטרכו

2. סקירה כללית של האפליקציה

לפני שנתחיל לתכנן וליישם את האפליקציה באמצעות Antigravity, נגדיר קודם את האפליקציה שאנחנו רוצים ליצור.

אנחנו רוצים ליצור פייפליין לעיבוד מסמכים בלי שרתים שמבוסס על אירועים. הצינור הזה יקבל קבצים מ-Google Cloud Storage ‏ (GCS), יעבד אותם באמצעות Cloud Run ו-Gemini ויזרים את המטא-נתונים שלהם ל-BigQuery.

דיאגרמת ארכיטקטורה כללית של האפליקציה יכולה להיראות כך:

3bd519cfab38258d.png

לא צריך להיות מדויקים. ‫Antigravity יכול לעזור לנו להבין את פרטי הארכיטקטורה תוך כדי התהליך. עם זאת, כדאי שיהיה לכם רעיון לגבי מה שאתם רוצים ליצור. ככל שתספקו יותר פרטים, כך התוצאות שתקבלו מ-Antigravity יהיו טובות יותר מבחינת ארכיטקטורה וקוד.

3. תכנון הארכיטקטורה

אנחנו מוכנים להתחיל לתכנן את פרטי הארכיטקטורה באמצעות Antigravity!

‫Antigravity מצטיין בתכנון מערכות מורכבות. במקום לכתוב קוד באופן מיידי, אנחנו יכולים להתחיל בהגדרת הארכיטקטורה ברמה גבוהה ולהשתמש באחת מהתכונות כדי לעזור ל-Antigravity להעריך את הבקשה שלנו, לשאול אותנו שאלות המשך ואז להמשיך בתכנון וביישום.

נניח שהפעלתם את Antigravity, עכשיו ניצור פרויקט חדש בשביל ה-codelab הזה.

לוחצים על סמל הפרויקט החדש לצד תכונת ה-Labs‏ Projects ואז על New Project כמו שמוצג בהמשך:

949cd615a1ce8dc3.png

תופיע האפשרות Add Folder כמו שמוצג בהמשך:

ee8ff88b71c10e9f.png

לוחצים על הלחצן הוספת תיקייה כדי להוסיף תיקייה לפרויקט. במחשב שלי יצרתי תיקייה בשם 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:

  • סקריפט פשוט ב-CLI של gcloud להקצאת משאבים
  • התראות Pub/Sub מקוריות של Cloud Storage + מינוי דחיפה של Pub/Sub ל-Cloud Run
  • שימוש ב-Flask (עם Gunicorn) למסגרת
  • פשוט משתמשים בסימולציה מקומית עם קובץ טקסט לנתונים במקום בנתוני OCR בזמן אמת
  • שימוש ב-BigQuery table.insert_rows() כדי להוסיף שורות ל-BigQuery
  • פריסת Cloud Run לא מאומתת

ואפשרויות מומלצות אחרות.

תוכנית הטמעה ורשימת משימות

‫Antigravity יתחיל לעבוד וייצור תוכנית הטמעה. הוא מעביר את התמונה לבדיקה שלכם ומציג הודעה דומה לזו שבהמשך:

3cc503e352eee935.png

אפשר ללחוץ על המתג של חלונית העזר בפינה השמאלית העליונה של החלון כדי לראות את הארטיפקטים שנוצרו. בשלב הזה, זה רק תוכנית ההטמעה.

883adedf0157a073.png

בתוכנית הזו מפורטים:

  • תשתית: מאגר GCS, נושא Pub/Sub, מערך נתונים ב-BigQuery.
  • מעבד: אפליקציית Python/Flask, ‏ Dockerfile, ‏ Requirements.
  • שילוב: התראות GCS ‏→ Pub/Sub ‏→ Cloud Run.

אמורה להופיע כותרת שדומה לכותרת הבאה: למטה מוצגת רשימה חלקית של תוכנית ההטמעה במכונה שלנו:

5fb0baef49bdb8b1.png

חשוב לקרוא אותו בעיון. זו ההזדמנות שלכם לספק משוב על ההטמעה. אפשר ללחוץ על כל חלק בתוכנית ההטמעה ולהוסיף הערות. אחרי שמוסיפים הערות, חשוב לשלוח לבדיקה את כל השינויים שרוצים לבצע, במיוחד שינויים שקשורים לשמות, למזהה הפרויקט ב-Google Cloud, לאזור וכו'.

אם הכול נראה בסדר, לוחצים על הלחצן Proceed כדי לתת לנציג הרשאה להמשיך עם תוכנית ההטמעה.

4. יצירת הבקשה

אחרי שהתוכנית מאושרת, Antigravity מתחיל ליצור את הקבצים שנדרשים לאפליקציה, מסקריפטים להקצאת משאבים ועד קוד האפליקציה.

‫Antigravity ייצור תיקייה ויתחיל ליצור את הקבצים שנדרשים לפרויקט. אם תבדקו את הארטיפקטים, תראו שנוצרו כמה קבצים (קוד מקור, קובצי סקריפט וכו').

f6f4e4473fb2a8b3.png

אחרי שהיא תסיים את העבודה, היא תציין זאת ותיצור מסמך הדרכה שתוכלו לעיין בו. למטה מוצג פלט לדוגמה:

752ebdb9767a82c9.png

במסמך ההסבר מפורט מה הוטמע, אילו סקריפטים נוצרו וחשוב מזה, מהם האימותים שבוצעו. למטה מוצג פלט חלקי של מסמך ההסבר, שכולל את האימות והוולידציה:

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. אחרי שמסיימים את הפעולה הזו,

שלב 1: הפעלת ממשקי ה-API הנדרשים של GCP

מריצים את setup_gcp.sh כדי להפעיל את ממשקי Cloud Run,‏ Pub/Sub,‏ Cloud Storage,‏ BigQuery ו-Cloud Build API: ./scripts/setup_gcp.sh

שלב 2: פריסת כל הצינור

מריצים את deploy.sh:

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

מה הסקריפט הזה עושה מאחורי הקלעים:

  1. מבצעים build של קובץ האימג' של הקונטיינר באמצעות Google Cloud Build ומעבירים אותו בדחיפה ל-Container Registry או ל-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. יוצר מינוי Pub/Sub Push שמכוון לכתובת ה-URL של שירות Cloud Run עם נסיגה אוטומטית של ניסיונות חוזרים.

הוא גם מציע דרכים לבדיקת צינור עיבוד הנתונים.

מריצים את test_pipeline.sh: ./scripts/test_pipeline.sh

הפקודה הזו מעלה את הקבצים samples/sample_contract.txt ו-samples/sample_invoice.pdf לקטגוריה שלכם, ממתינה לעיבוד ומריצה שאילתת BigQuery SQL שמציגה את המטא-נתונים, את מספר המילים ואת התגים שחולצו.

5. פריסת האפליקציה

בוא נבצע פריסה של האפליקציה כמו שצוין. אנחנו יכולים לבקש מ-Antigravity להריץ את הפקודה הזו בשבילנו, אבל לפני כן, צריך לוודא שה-CLI של 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.

בנוסף, הוא עדכן את ארטיפקט ההסבר המפורט כדי להציג את התוצאות (רשימה חלקית מוצגת בהמשך):

סיכום הפריסה

  • פרויקט GCP: ‏ 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

אימות צינור עיבוד נתונים פעיל

הפעלנו את scripts/test_pipeline.sh בסביבת Google Cloud פעילה:

  1. העלאה של הקבצים sample_contract.txt ו-sample_invoice.pdf לקטגוריה של Cloud Storage.
  2. אירועים מסוג OBJECT_FINALIZE שנוצרו ב-GCS נשלחים אל Pub/Sub.
  3. שירות Pub/Sub דחף את המעטפות למיקרו-שירות (microservice) של Cloud Run.
  4. Cloud Run חילץ מטא-נתונים, עיבד סימולציה של OCR והזרים רשומות ל-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 שכל המשאבים נוצרו. כדי לעשות זאת, פועלים לפי השלבים הבאים.

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. גוללים למטה לכרטיסייה מינויים.
  5. בודקים שמופיע doc-uploads-events-push-sub.

Cloud Run

המטרה: בדיקת הסטטוס והיומנים של השירות.

  1. עוברים אל Cloud Run.
  2. לוחצים על השירות document-processor.
  3. אימות:
  4. ‫Health: סימן וי ירוק שמציין שהשירות פעיל.
  5. יומנים: לוחצים על הכרטיסייה Logs (יומנים). מחפשים רשומות כמו Processing document: gs://...‎ ו-Successfully streamed metadata...‎.

BigQuery

המטרה: לוודא שהנתונים מאוחסנים בפועל.

  1. עוברים אל BigQuery >‏ SQL Workspace (סביבת עבודה של SQL).
  2. בחלונית Explorer, מרחיבים את מערך הנתונים project > document_processing.
  3. לוחצים על הטבלה document_metadata.
  4. לוחצים על הכרטיסייה Query (שאילתה) ומאחזרים את כל השורות מהטבלה באמצעות הפקודה SELECT * ‎.
  5. אימות: אמורות להופיע שורות עם הערכים file_name,‏ process_at,‏ tags ו-word_count.

7. סקירת האפליקציה

בשלב הזה, האפליקציה הבסיסית מוקצית ופועלת. לפני שמרחיבים את האפליקציה הזו, כדאי להקדיש רגע לבדיקת הקוד. אפשר לראות את הארטיפקטים, ויוצגו קובצי הקוד שנוצרו.

הנה סיכום קצר של כמה קבצים שאולי יופיעו:

  1. ‫deploy.sh: סקריפט האב שמקצה את כל המשאבים ב-Google Cloud ומפעיל את ממשקי ה-API הנדרשים.
  2. ‫main.py: נקודת הכניסה הראשית של צינור עיבוד הנתונים. אפליקציית Python הזו יוצרת שרת אינטרנט שמקבל הודעות push של Pub/Sub, מוריד את הקובץ מ-GCS, מבצע בו 'עיבוד' (סימולציה של OCR) ומזרים את המטא-נתונים ל-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

שילוב עם AI/ML אמיתי

במקום להשתמש בעיבוד OCR מדומה, אפשר להשתמש במודלים של Gemini כדי לחלץ, לסווג ולתרגם.

  1. מחליפים את לוגיקת ה-OCR הפיקטיבית. שולחים את התמונה או קובץ ה-PDF ל-Gemini כדי לחלץ את הטקסט והנתונים בפועל. לנתח את הטקסט שחולץ כדי לסווג את סוג המסמך (חשבונית, חוזה, קורות חיים) או לחלץ ישויות (תאריכים, שמות, מיקומים).
  2. המערכת תזהה אוטומטית את השפה של המסמך ותתרגם אותו לאנגלית לפני האחסון. אפשר להשתמש גם בכל שפה אחרת.

שיפור האחסון והניתוח

אפשר להגדיר כללים לניהול מחזור החיים בקטגוריה כדי להעביר קבצים ישנים לאחסון מסוג Coldline או Archive כדי לחסוך בעלויות.

חוסן ואבטחה

אתם יכולים לשפר את האמינות והאבטחה של האפליקציה, למשל:

  1. תורי הודעות מתות (DLQ): צריך לעדכן את המינוי ל-Pub/Sub כדי לטפל בכשלים. אם שירות Cloud Run נכשל בעיבוד קובץ 5 פעמים, המערכת שולחת את ההודעה לנושא או למאגר נפרדים של 'הודעות שלא נמסרו' לבדיקה על ידי אדם.
  2. ‫Secret Manager: אם האפליקציה שלכם צריכה מפתחות API או הגדרות רגישות, אחסנו אותם ב-Secret Manager וגשו אליהם בצורה מאובטחת מ-Cloud Run במקום להצפין מחרוזות.
  3. ‫Eventarc: שדרוג מ-Pub/Sub ישיר ל-Eventarc כדי ליהנות מניתוב אירועים גמיש יותר, שמאפשר הפעלה על סמך יומני ביקורת מורכבים או אירועים אחרים של שירותי GCP.

כמובן, אתם יכולים להעלות רעיונות משלכם ולהשתמש ב-Antigravity כדי ליישם אותם.

9. סיכום

הצלחתם לבנות צינור עיבוד נתונים למסמכים מבוסס-AI, ללא שרת וניתן להרחבה, תוך דקות באמצעות Google Antigravity. למדתם איך:

  • תכנון ארכיטקטורות באמצעות AI.
  • נותנים הוראות ל-Antigravity ומנהלים אותו בזמן שהוא יוצר את האפליקציה, החל מיצירת הקוד ועד לפריסה ולאימות.
  • אימות הפריסות והוולידציה באמצעות מדריכים.

מסמכי עזר