Mit Antigravity in Google Cloud entwickeln und bereitstellen

1. Einführung

In diesem Codelab erfahren Sie, wie Sie mit Google Antigravity eine serverlose Anwendung entwerfen, erstellen und in Google Cloud bereitstellen. Wir erstellen eine serverlose und ereignisgesteuerte Dokumentpipeline, die Dateien aus Google Cloud Storage (GCS) aufnimmt, sie mit Cloud Run und Gemini verarbeitet und ihre Metadaten in BigQuery streamt.

Lerninhalte

• Antigravity für die Architekturplanung und das Design verwenden
• Infrastruktur als Code (Shell-Skripts) mit einem KI-Agenten generieren
• Einen Cloud Run-Dienst auf Python-Basis erstellen und bereitstellen
• Gemini auf Vertex AI für die multimodale Dokumentanalyse einbinden
• Die End-to-End-Pipeline mit dem Antigravity-Artefakt „Walkthrough“ überprüfen

Voraussetzungen

• Google Antigravity ist installiert.
• Google Cloud-Projekt mit aktivierter Abrechnungsfunktion
• gcloud CLI installiert und authentifiziert

2. Übersicht über die App

Bevor wir mit der Architektur und Implementierung der Anwendung mit Antigravity beginnen, skizzieren wir zuerst die Anwendung, die wir erstellen möchten.

Wir möchten eine serverlose und ereignisgesteuerte Dokumentpipeline erstellen, die Dateien aus Google Cloud Storage (GCS) aufnimmt, sie mit Cloud Run und Gemini verarbeitet und ihre Metadaten in BigQuery streamt.

Ein Architekturdiagramm auf hoher Ebene für diese Anwendung könnte so aussehen:

Das muss nicht genau sein. Antigravity kann uns helfen, die Architekturdetails im Laufe der Zeit zu ermitteln. Es ist jedoch hilfreich, eine Vorstellung davon zu haben, was Sie erstellen möchten. Je detaillierter Sie die Informationen angeben, desto bessere Ergebnisse erhalten Sie von Antigravity in Bezug auf Architektur und Code.

3. Architektur planen

Wir können jetzt mit der Planung der Architekturdetails mit Antigravity beginnen.

Antigravity eignet sich hervorragend für die Planung komplexer Systeme. Anstatt sofort Code zu schreiben, können wir zuerst die Architektur auf hoher Ebene definieren und eine der Funktionen verwenden, damit Antigravity unsere Anfrage auswerten, uns weiterführende Fragen stellen und dann mit der Planung und Implementierung fortfahren kann.

Angenommen, Sie haben Antigravity gestartet, erstellen wir ein neues Projekt für dieses Codelab.

Klicken Sie neben dem Lab Projects auf das Symbol für ein neues Projekt und dann auf New Project (Neues Projekt), wie unten gezeigt:

Dadurch wird die Option Add Folder (Ordner hinzufügen) angezeigt, wie unten gezeigt:

Klicken Sie auf die Schaltfläche Add Folder (Ordner hinzufügen), um Ihrem Projekt einen Ordner hinzuzufügen. Auf meinem Computer habe ich den Ordner google-cloud-serverless-app erstellt und ihn diesem Projekt hinzugefügt.

Dadurch wird eine Unterhaltung im Projekt google-cloud-serverless-app geöffnet.

Klicken Sie links unten auf dem Bildschirm auf das Symbol für die Haupteinstellungen ⚙️ und rufen Sie die projektspezifischen Einstellungen auf. Wenn das Projekt google-cloud-serverless-app nicht aufgeführt ist, führen Sie einfach eine Unterhaltung und kehren Sie dann zu den Projekteinstellungen zurück.

Legen Sie für Agent Settings / Security Preset (Agenteneinstellungen/Sicherheitspreset) die Option Default (Standard) und für Agent Behaviour / Artifact Review Policy (Agentenverhalten/Richtlinie zur Artefaktüberprüfung) die Option Always Ask (Immer fragen) fest, wie unten gezeigt:

So können Sie in jedem Schritt den Plan überprüfen und genehmigen, bevor der Agent ihn ausführt.

Prompt

Jetzt können wir Antigravity unseren ersten Prompt geben. Wir verwenden den Slash-Befehl /grill-me, um unsere Anfrage auszuwerten.

Geben Sie /grill-me ein, geben Sie dann den folgenden Prompt ein und klicken Sie auf die Schaltfläche „Senden“:

/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. 

Der Befehl /grill-me stellt eine Reihe von weiterführenden Fragen, die Sie nach bestem Wissen beantworten können. Außerdem werden Recommended Answers (Empfohlene Antworten) vorgeschlagen, die Sie verwenden können.

Ein Beispiel für die Ausführung meines Befehls /grill-me ist unten dargestellt:

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

Ich habe Antigravity gebeten, Folgendes zu verwenden:

• Ein einfaches gcloud CLI-Skript zum Bereitstellen von Ressourcen
• Native Cloud Storage Pub/Sub-Benachrichtigungen + Pub/Sub-Push-Abo für Cloud Run
• Flask (mit Gunicorn) für das Framework verwenden
• Anstelle von Live-OCR-Daten nur eine lokale Simulation mit einer Textdatei für die Daten verwenden
• Mit BigQuery table.insert_rows() Zeilen in BigQuery einfügen
• Nicht authentifizierte Cloud Run-Bereitstellung

und andere empfohlene Optionen.

Implementierungsplan und Aufgabenliste

Antigravity erstellt jetzt einen Implementierungsplan. Er wird zur Überprüfung bereitgestellt und Sie erhalten eine Nachricht wie die folgende:

Sie können oben rechts im Fenster auf den Umschalter für den Hilfsbereich klicken und die generierten Artefakte ansehen. Derzeit ist das nur der Implementierungsplan.

Dieser Plan enthält Folgendes:

• Infrastruktur: GCS-Bucket, Pub/Sub-Thema, BigQuery-Dataset
• Prozessor: Python/Flask-App, Dockerfile, Anforderungen
• Integration: GCS-Benachrichtigungen → Pub/Sub → Cloud Run

Die Ausgabe sollte in etwa so aussehen: Unten ist eine Teilliste des Implementierungsplans auf unserem Computer zu sehen:

Lesen Sie ihn sorgfältig durch. Hier haben Sie die Möglichkeit, Feedback zur Implementierung zu geben. Sie können auf einen beliebigen Teil des Implementierungsplans klicken und Kommentare hinzufügen. Nachdem Sie Kommentare hinzugefügt haben, senden Sie alle Änderungen zur Überprüfung ein, die Sie vornehmen möchten, insbesondere in Bezug auf die Benennung, die Google Cloud-Projekt-ID, die Region usw.

Wenn alles in Ordnung ist, geben Sie dem Agenten die Berechtigung, mit dem Implementierungsplan fortzufahren, indem Sie auf die Schaltfläche Proceed (Fortfahren) klicken.

Hinweis:Manchmal wird die Schaltfläche Proceed (Fortfahren) nicht angezeigt und Antigravity fährt fort, ohne auf Ihre Eingabe zu warten.

4. Anwendung generieren

Sobald der Plan genehmigt wurde, generiert Antigravity die für die Anwendung erforderlichen Dateien, von Bereitstellungsskripts bis hin zum Anwendungscode.

Hinweis: Sie werden aufgefordert, mehrere Terminalbefehle (gcloud, Shell-Skripts usw.) einzugeben, die der Agent benötigt, um die Umgebung zu verstehen und dann die Skripts entsprechend zu generieren. Klicken Sie auf die Schaltfläche Submit, damit der Agent fortfahren kann. In diesem Lab werden die spezifischen Dateinamen behandelt, die generiert wurden. Antigravity generiert jedoch möglicherweise andere Dateinamen. Die Absicht und der Inhalt der Dateien sollten jedoch ähnlich sein.

Antigravity erstellt einen Ordner und beginnt mit der Erstellung der für das Projekt erforderlichen Dateien. Wenn Sie die Artefakte prüfen, werden mehrere Dateien (Quellcode, Skriptdateien usw.) generiert.

Sobald die Arbeit abgeschlossen ist, wird dies erwähnt und ein Walkthrough -Dokument erstellt, das Sie sich ansehen können. Ein Beispiel für die Ausgabe ist unten dargestellt:

Im Walkthrough-Dokument wird beschrieben, was implementiert wurde, welche Skripts generiert wurden und vor allem, welche Überprüfung und Validierung durchgeführt wurde. Unten ist eine Teilausgabe des Walkthrough-Dokuments mit der Überprüfung und Validierung zu sehen:

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

Wir können Antigravity fragen, wie wir diese Anwendung in Google Cloud bereitstellen können. Sie erhalten alle Details dazu, wie unten aufgeführt. Zusammenfassend werden wir aufgefordert, darauf zu achten, dass das Google Cloud SDK installiert und ein Google Cloud-Projekt eingerichtet ist. Sobald das erledigt ist,

Schritt 1: Erforderliche GCP APIs aktivieren

Führen Sie setup_gcp.sh aus, um die Cloud Run, Pub/Sub, Cloud Storage, BigQuery und Cloud Build APIs zu aktivieren: ./scripts/setup_gcp.sh

Schritt 2: Gesamte Pipeline bereitstellen

Führen Sie deploy.sh aus:

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

Was dieses Skript im Hintergrund tut:

1. Erstellt das Container-Image mit Google Cloud Build und überträgt es in die Container/Artifact Registry.
2. Stellt den Dienst in Cloud Run mit den entsprechenden Umgebungsvariablen (GCP_PROJECT, BQ_DATASET_ID, BQ_TABLE_ID) bereit.
3. Erstellt den Cloud Storage-Aufnahmebucket (gs://<PROJECT_ID>-document-ingest).
4. Erstellt das Pub/Sub-Thema (document-upload-events) und gewährt GCS die Berechtigung, darin zu veröffentlichen.
5. Konfiguriert eine GCS-Benachrichtigung (OBJECT_FINALIZE) für den Bucket.
6. Erstellt ein Pub/Sub-Push-Abo, das auf die Cloud Run-Dienst-URL mit automatischer Wiederholungs-Backoff-Funktion ausgerichtet ist.

Außerdem wird vorgeschlagen, wie Sie die Pipeline testen können.

Führen Sie test_pipeline.sh aus: ./scripts/test_pipeline.sh

Dadurch werden samples/sample_contract.txt und samples/sample_invoice.pdf in Ihren Bucket hochgeladen, auf die Verarbeitung gewartet und eine BigQuery-SQL-Abfrage ausgeführt, die die extrahierten Metadaten, die Anzahl der Wörter und die Tags anzeigt.

5. Anwendung bereitstellen

Stellen wir die Anwendung wie beschrieben bereit. Wir können Antigravity bitten, das für uns auszuführen. Bevor wir das tun, müssen wir jedoch prüfen, ob die gcloud CLI vorhanden und für das Google Cloud-Projekt konfiguriert ist.

Wir können Antigravity den Prompt "Deploy the application for me" (Anwendung für mich bereitstellen) geben. Sie werden nach verschiedenen Berechtigungen gefragt und dann werden die Skriptdateien ausgeführt.

Der Prozess wird als Hintergrundaufgabe gestartet, wie in der folgenden Nachricht erläutert:

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. Anwendung überprüfen

Sobald die Pipeline bereitgestellt wurde, überprüft Antigravity, ob die Anwendung tatsächlich funktioniert. Wir werden gefragt, ob die Datei test_pipeline.sh ausgeführt werden kann. Wir können die Berechtigung erteilen.

Schließlich wird Folgendes angezeigt:

🚀 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.

Außerdem wurde das Walkthrough-Artefakt aktualisiert, um die Ergebnisse anzuzeigen (Teilliste unten):

Zusammenfassung der Bereitstellung

• GCP-Projekt: PROJECT_ID
• Region: REGION
• Cloud Run-Dienst: document-processor
• Cloud Run-Endpunkt: SERVICE_URL
• Cloud Storage-Bucket: gs://PROJECT_ID-document-ingest
• Pub/Sub-Thema: document-upload-events
• Pub/Sub-Push-Abo: document-upload-events-push-sub
• BigQuery-Ziel: PROJECT_ID.document_processing.document_metadata

Live-Überprüfung der Pipeline

Wir haben scripts/test_pipeline.sh in der Live-Google Cloud-Umgebung ausgeführt:

1. sample_contract.txt und sample_invoice.pdf in den Cloud Storage-Bucket hochgeladen.
2. GCS hat OBJECT_FINALIZE-Ereignisse für Pub/Sub generiert.
3. Pub/Sub hat die Umschläge an den Cloud Run-Mikrodienst übertragen.
4. Cloud Run hat Metadaten extrahiert, die simulierte OCR-Verarbeitung durchgeführt und Datensätze in BigQuery gestreamt.

Live-BigQuery-Abfrageausgabe

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

Alle Pipelinekomponenten sind aktiv, fehlerfrei und in der Produktion überprüft.

Optional: Manuelle Überprüfung

Obwohl Antigravity die Anwendung bereits überprüft hat, können Sie in der Google Cloud Console auch manuell prüfen, ob alle Ressourcen erstellt wurden. Folgen Sie dazu dieser Anleitung.

Cloud Storage

Ziel: Prüfen, ob der Bucket vorhanden ist, und nach hochgeladenen Dateien suchen.

1. Rufen Sie Cloud Storage > Buckets auf.
2. Suchen Sie den Bucket mit dem Namen PROJECT_ID-document-processing.
3. Klicken Sie auf den Bucket-Namen, um die Dateien zu durchsuchen.
4. Überprüfen Sie, ob die hochgeladenen Dateien angezeigt werden (z.B. sample_contract.txt).

Pub/Sub

Ziel: Prüfen, ob das Thema vorhanden ist und ein Push-Abo hat.

1. Rufen Sie Pub/Sub > Themen auf.
2. Suchen Sie nach document-uploads-events.
3. Klicken Sie auf die Themen-ID.
4. Scrollen Sie nach unten zum Tab Abos.
5. Prüfen Sie, ob doc-uploads-events-push-sub aufgeführt ist.

Cloud Run

Ziel: Dienststatus und Logs prüfen.

1. Rufen Sie Cloud Run auf.
2. Klicken Sie auf den Dienst document-processor.
3. Prüfen Sie Folgendes:
4. Status: Ein grünes Häkchen zeigt an, dass der Dienst aktiv ist.
5. Logs: Klicken Sie auf den Tab „Logs“. Suchen Sie nach Einträgen wie "Processing document: gs://..." (Dokument wird verarbeitet: gs://...) und "Successfully streamed metadata..." (Metadaten wurden erfolgreich gestreamt...).

BigQuery

Ziel: Prüfen, ob die Daten tatsächlich gespeichert sind.

1. Rufen Sie BigQuery > SQL-Arbeitsbereich auf.
2. Maximieren Sie im Bereich „Explorer“ Ihr Projekt > document_processing -Dataset.
3. Klicken Sie auf die Tabelle document_metadata.
4. Klicken Sie auf den Tab Abfrage und rufen Sie alle Zeilen aus der Tabelle mit der Anweisung SELECT * ab.
5. Prüfen Sie, ob Zeilen mit file_name, process_at, tags und word_count angezeigt werden.

7. Anwendung kennenlernen

An diesem Punkt haben Sie die grundlegende App bereitgestellt und sie wird ausgeführt. Bevor Sie diese Anwendung weiter erweitern, sehen Sie sich den Code an. Sie können die Artefakte ansehen und die generierten Codedateien sollten angezeigt werden.

Hier eine kurze Zusammenfassung einiger Dateien, die Sie möglicherweise sehen:

1. deploy.sh: Das Hauptskript, das alle Google Cloud-Ressourcen bereitstellt und die erforderlichen APIs aktiviert.
2. main.py: Der Haupteinstiegspunkt der Pipeline. Diese Python-App erstellt einen Webserver, der Pub/Sub-Push-Nachrichten empfängt, die Datei aus GCS herunterlädt, sie „verarbeitet“ (simuliert OCR) und die Metadaten in BigQuery streamt.
3. Dockerfile: Definiert, wie die App in ein Container-Image verpackt wird.
4. requirements.txt: Listet die Python-Abhängigkeiten auf.

Möglicherweise werden auch andere Skripts und Textdateien angezeigt, die für Tests und Überprüfung erforderlich sind.

8. Anwendung erweitern

Nachdem Sie nun eine funktionierende grundlegende Anwendung haben, können Sie sie weiter iterieren und erweitern. Hier einige Ideen:

Frontend hinzufügen

Erstellen Sie eine einfache Weboberfläche, um die verarbeiteten Dokumente anzusehen.

Probieren Sie den folgenden Prompt aus: 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

Mit echter KI/ML integrieren

Verwenden Sie anstelle der simulierten OCR-Verarbeitung Gemini-Modelle, um Text zu extrahieren, zu klassifizieren und zu übersetzen.

1. Ersetzen Sie die Dummy-OCR-Logik. Senden Sie das Bild/die PDF-Datei an Gemini, um den tatsächlichen Text und die Daten zu extrahieren. Analysieren Sie den extrahierten Text, um den Dokumenttyp zu klassifizieren (Rechnung, Vertrag, Lebenslauf) oder Entitäten zu extrahieren (Daten, Namen, Orte).
2. Erkennen Sie automatisch die Sprache des Dokuments und übersetzen Sie es ins Englische, bevor Sie es speichern. Sie können auch eine andere Sprache verwenden.

Speicher und Analysen verbessern

Sie können Lebenszyklusregeln für den Bucket konfigurieren, um alte Dateien in den Speicher „Coldline“ oder „Archiv“ zu verschieben und so Kosten zu sparen.

Robustheit und Sicherheit

Sie können die App robuster und sicherer machen, z. B. so:

1. Dead-Letter-Warteschlangen (DLQ): Aktualisieren Sie das Pub/Sub-Abo, um Fehler zu verarbeiten. Wenn der Cloud Run-Dienst eine Datei fünfmal nicht verarbeiten kann, senden Sie die Nachricht zur manuellen Überprüfung an ein separates Thema/einen separaten Bucket für unzustellbare Nachrichten.
2. Secret Manager: Wenn Ihre App API-Schlüssel oder vertrauliche Konfigurationen benötigt, speichern Sie sie im Secret Manager und greifen Sie sicher von Cloud Run aus darauf zu, anstatt Strings fest zu codieren.
3. Eventarc: Führen Sie ein Upgrade von direktem Pub/Sub auf Eventarc durch, um eine flexiblere Ereignisweiterleitung zu ermöglichen. So können Sie Auslöser basierend auf komplexen Audit-Logs oder anderen GCP-Dienstereignissen erstellen.

Natürlich können Sie sich eigene Ideen einfallen lassen und Antigravity verwenden, um sie zu implementieren.

9. Fazit

Sie haben mit Google Antigravity in wenigen Minuten eine skalierbare, serverlose, KI-gestützte Dokumentpipeline erstellt. Sie haben Folgendes gelernt:

• Architekturen mit KI planen
• Antigravity anweisen und verwalten, während es die Anwendung generiert, von der Codeerstellung bis zur Bereitstellung und Validierung
• Bereitstellungen und Validierungen mit Walkthroughs überprüfen

Referenzdokumente

• Offizielle Website : https://antigravity.google/
• Dokumentation: https://antigravity.google/docs
• Anwendungsbeispiele : https://antigravity.google/use-cases
• Download : https://antigravity.google/download