Criar e implantar no Google Cloud com o Antigravity

1. Introdução

Neste codelab, você vai aprender a usar o Google Antigravity para criar, desenvolver e implantar um aplicativo sem servidor no Google Cloud. Vamos criar um pipeline de documentos sem servidor e orientado a eventos que ingere arquivos do Google Cloud Storage (GCS), os processa usando o Cloud Run e o Gemini e transmite os metadados para o BigQuery.

O que você vai aprender

• Como usar o Antigravity para planejamento e design arquitetônico.
• Gerar infraestrutura como código (scripts shell) com um agente de IA.
• Criar e implantar um serviço do Cloud Run baseado em Python.
• Integrar o Gemini na Vertex AI para análise multimodal de documentos.
• Verificar o pipeline de ponta a ponta usando o artefato de tutorial do Antigravity.

O que é necessário

• O Google Antigravity instalado.
• um projeto do Google Cloud com faturamento ativado
• CLI gcloud instalada e autenticada.

2. Visão geral do app

Antes de começar a arquitetar e implementar o aplicativo usando o Antigravity, vamos descrever o aplicativo que queremos criar.

Queremos criar um pipeline de documentos sem servidor e orientado a eventos que ingere arquivos do Google Cloud Storage (GCS), os processa usando o Cloud Run e o Gemini e transmite os metadados para o BigQuery.

Um diagrama de arquitetura de alto nível para esse aplicativo pode ser assim:

Isso não precisa ser preciso. O Antigravity pode nos ajudar a descobrir os detalhes da arquitetura à medida que avançamos. No entanto, é útil ter uma ideia do que você quer criar. Quanto mais detalhes você fornecer, melhores serão os resultados do Antigravity em termos de arquitetura e código.

3. Planejar a arquitetura

Estamos prontos para começar a planejar os detalhes da arquitetura com o Antigravity.

O Antigravity é excelente no planejamento de sistemas complexos. Em vez de escrever o código imediatamente, podemos começar definindo a arquitetura de alto nível e usar um dos recursos para ajudar o Antigravity a avaliar nossa solicitação, fazer perguntas complementares e, em seguida, prosseguir com o planejamento e a implementação.

Supondo que você tenha iniciado o Antigravity, vamos criar um novo projeto para este codelab.

Clique no ícone de novo projeto ao lado do laboratório Projects e, em seguida, em New Project , conforme mostrado abaixo:

Isso vai mostrar a opção Add Folder , conforme mostrado abaixo:

Clique no botão Add Folder para adicionar uma pasta ao projeto. Na minha máquina, criei uma pasta google-cloud-serverless-app e a adicionei a esse projeto.

Isso abre uma conversa no projeto google-cloud-serverless-app.

Clique no ícone de configurações principal ⚙️ na parte de baixo à esquerda da tela e acesse as configurações específicas do projeto. Se o projeto google-cloud-serverless-app não estiver listado, faça uma única conversa e volte às configurações do projeto.

Defina Agent Settings / Security Preset como Default e Agent Behaviour / Artifact Review Policy como Always Ask, conforme mostrado abaixo:

Isso garante que, em cada etapa, você possa revisar e aprovar o plano antes que o agente seja executado.

Comando

Agora estamos prontos para fornecer nosso primeiro comando ao Antigravity. Vamos usar um comando de barra /grill-me para avaliar nossa solicitação.

Digite /grill-me, insira o comando a seguir e clique no botão "Enviar":

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

O comando /grill-me faz várias perguntas complementares que você pode tentar responder da melhor forma possível. Ele também sugere Respostas recomendadas , que você pode usar se quiser.

Um exemplo de execução do meu comando /grill-me é mostrado abaixo:

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

Perceba que pedi ao Antigravity para usar:

• Um script simples da CLI gcloud para provisionar recursos
• Notificações nativas do Cloud Storage Pub/Sub + assinatura por push do Pub/Sub para o Cloud Run
• Usar o Flask (com Gunicorn) para o framework
• Basta usar a simulação local com um arquivo de texto para os dados em vez de dados OCR em tempo real
• Usar table.insert_rows() do BigQuery para inserir linhas no BigQuery
• Implantação não autenticada do Cloud Run

e outras opções recomendadas.

Plano de implementação e lista de tarefas

O Antigravity vai começar a trabalhar e gerar um plano de implementação. Ele o coloca para revisão, enviando uma mensagem semelhante à mostrada abaixo:

Você pode clicar na alternância do painel auxiliar na janela no canto superior direito e conferir os artefatos gerados, que neste momento são apenas o plano de implementação.

Esse plano descreve:

• Infraestrutura: bucket do GCS, tópico do Pub/Sub, conjunto de dados do BigQuery.
• Processador: app Python/Flask, Dockerfile, requisitos.
• Integração: notificações do GCS → Pub/Sub → Cloud Run.

Você verá algo semelhante ao seguinte. Uma lista parcial do plano de implementação na nossa máquina é mostrada abaixo:

Leia com atenção. Esta é sua chance de enviar feedback para a implementação. Você pode clicar em qualquer parte do plano de implementação e adicionar comentários. Depois de adicionar alguns comentários, envie para revisão as mudanças que você gostaria de ver, especialmente em relação a nomes, ID do projeto do Google Cloud, região etc.

Quando tudo estiver bem, conceda ao agente a permissão para prosseguir com o plano de implementação clicando no botão Proceed.

Observação:às vezes, um botão Proceed não aparece, e o Antigravity pode prosseguir sem esperar sua entrada.

4. Gerar o aplicativo

Depois que o plano é aprovado, o Antigravity começa a gerar os arquivos necessários para o aplicativo, desde scripts de provisionamento até código do aplicativo.

Observação: você vai receber vários comandos de terminal (gcloud, scripts shell etc.) que o agente precisará usar para entender o ambiente e gerar os scripts de acordo. Clique no botão Submit para que o agente avance. Embora este laboratório cubra os nomes de arquivos específicos que foram gerados, o Antigravity pode gerar nomes de arquivos diferentes, embora a intenção e o conteúdo dos arquivos sejam semelhantes.

O Antigravity vai criar uma pasta e começar a criar os arquivos necessários para o projeto. Se você verificar os artefatos, vai notar vários arquivos (código-fonte, arquivos de script etc.) sendo gerados.

Quando o trabalho for concluído, ele vai mencionar isso e criar um documento de tutorial que você pode consultar. Um exemplo de saída é mostrado abaixo:

O documento de tutorial menciona o que foi implementado, os scripts gerados e, mais importante, a verificação e a validação que foram feitas. Uma saída parcial do documento de tutorial que inclui a verificação e a validação é mostrada abaixo:

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

Podemos perguntar ao Antigravity como implantar esse aplicativo no Google Cloud? Ele retorna com detalhes completos sobre o mesmo, conforme listado abaixo. Para resumir, ele pede que você verifique se o SDK do Google Cloud está instalado junto com uma configuração de projeto do Google Cloud. Depois disso,

Etapa 1: ativar as APIs do GCP necessárias

Execute setup_gcp.sh para ativar as APIs do Cloud Run, Pub/Sub, Cloud Storage, BigQuery e Cloud Build: ./scripts/setup_gcp.sh

Etapa 2: implantar todo o pipeline

Execute deploy.sh:

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

O que esse script faz nos bastidores:

1. Cria a imagem do contêiner usando o Google Cloud Build e a envia para o Container/Artifact Registry.
2. Implanta o serviço no Cloud Run com variáveis de ambiente apropriadas (GCP_PROJECT, BQ_DATASET_ID, BQ_TABLE_ID).
3. Cria o bucket de ingestão do Cloud Storage (gs://<PROJECT_ID>-document-ingest).
4. Cria o tópico do Pub/Sub (document-upload-events) e concede permissão ao GCS para publicar nele.
5. Configura uma notificação do GCS (OBJECT_FINALIZE) no bucket.
6. Cria uma assinatura de envio do Pub/Sub direcionada ao URL do serviço do Cloud Run com backoff de repetição automática.

Ele também sugere como testar o pipeline.

Execute test_pipeline.sh: ./scripts/test_pipeline.sh

Isso faz o upload de samples/sample_contract.txt e samples/sample_invoice.pdf para o bucket, aguarda o processamento e executa uma consulta SQL do BigQuery mostrando os metadados extraídos, a contagem de palavras e as tags.

5. Implantar o aplicativo

Vamos implantar o aplicativo conforme mencionado. Podemos pedir ao Antigravity para executar isso para nós, mas antes de fazer isso, verifique se a CLI gcloud está presente e configurada para o projeto do Google Cloud.

Podemos dar um comando ao Antigravity "Deploy the application for me". Isso vai solicitar várias permissões e, em seguida, executar os arquivos de script.

Ele inicia o processo como uma tarefa em segundo plano, conforme explicado pela mensagem abaixo:

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. Verificar o aplicativo

Depois que o pipeline é implantado, o Antigravity prossegue para verificar se o aplicativo realmente funciona. Ele pergunta se pode executar o arquivo test_pipeline.sh. Podemos conceder permissão.

Por fim, ele nos diz o seguinte:

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

Ele também atualizou o artefato de tutorial para mostrar os resultados (lista parcial abaixo):

Resumo da implantação

• Projeto do GCP: PROJECT_ID
• Região: REGION
• Serviço do Cloud Run: document-processor
• Endpoint do Cloud Run: SERVICE_URL
• Bucket do Cloud Storage: gs://PROJECT_ID-document-ingest
• Tópico do Pub/Sub: document-upload-events
• Assinatura de envio do Pub/Sub: document-upload-events-push-sub
• Destino do BigQuery: PROJECT_ID.document_processing.document_metadata

Verificação de pipeline em tempo real

Executamos scripts/test_pipeline.sh no ambiente do Google Cloud em tempo real:

1. Fizemos o upload de sample_contract.txt e sample_invoice.pdf para o bucket do Cloud Storage.
2. O GCS gerou eventos OBJECT_FINALIZE para o Pub/Sub.
3. O Pub/Sub enviou os envelopes para o microsserviço do Cloud Run.
4. O Cloud Run extraiu metadados, processou OCR simulado e transmitiu registros para o BigQuery.

Saída de consulta do BigQuery em tempo real

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

Todos os componentes do pipeline estão ativos, íntegros e verificados na produção.

Opcional: verificação manual

Embora o Antigravity já tenha verificado o aplicativo, você também pode verificar manualmente no console do Google Cloud se todos os recursos foram criados, seguindo estas etapas.

Cloud Storage

Objetivo: verificar se o bucket existe e conferir os arquivos enviados.

1. Acesse Cloud Storage > Buckets.
2. Localize o bucket chamado PROJECT_ID-document-processing.
3. Clique no nome do bucket para navegar pelos arquivos.
4. Verificar: os arquivos enviados (por exemplo, sample_contract.txt) vão aparecer.

Pub/Sub

Objetivo: confirmar se o tópico existe e tem uma assinatura por push.

1. Acesse Pub/Sub > Tópicos.
2. Encontre document-uploads-events.
3. Clique no ID do tópico.
4. Role a tela para baixo até a guia Assinaturas.
5. Verificar: confira se doc-uploads-events-push-sub está listado.

Cloud Run

Objetivo: verificar o status e os registros do serviço.

1. Acesse Cloud Run.
2. Clique no serviço document-processor.
3. Verificar:
4. Saúde: marca de seleção verde indicando que o serviço está ativo.
5. Registros: clique na guia "Registros". Procure entradas como "Processing document: gs://..." e "Successfully streamed metadata...".

BigQuery

Objetivo: validar se os dados estão realmente armazenados.

1. Acesse BigQuery > Espaço de trabalho SQL.
2. No painel "Explorer", expanda o conjunto de dados projeto > document_processing.
3. Clique na tabela document_metadata.
4. Clique na guia Consulta e recupere todas as linhas da tabela usando a instrução SELECT *.
5. Verificar: você vai encontrar linhas que contêm file_name, process_at, tags e word_count.

7. Conheça o aplicativo

Neste ponto, você tem o app básico provisionado e em execução. Antes de se aprofundar na extensão desse aplicativo, reserve um momento para explorar o código. Você pode conferir os artefatos, e eles vão mostrar os arquivos de código gerados.

Confira um resumo rápido de alguns arquivos que podem aparecer:

1. deploy.sh: o script principal que provisiona todos os recursos do Google Cloud e ativa as APIs necessárias.
2. main.py: o ponto de entrada principal do pipeline. Esse app Python cria um servidor da Web que recebe mensagens de envio do Pub/Sub, faz o download do arquivo do GCS, o "processa" (simula OCR) e transmite os metadados para o BigQuery.
3. Dockerfile: define como empacotar o app em uma imagem do contêiner.
4. requirements.txt: lista as dependências do Python.

Você também pode encontrar outros scripts e arquivos de texto necessários para testes e verificação.

8. Estender o aplicativo

Agora que você tem um aplicativo básico funcional, pode continuar iterando e estendendo o aplicativo. Confira algumas ideias.

Adicionar um front-end

Crie uma interface da Web simples para visualizar os documentos processados.

Tente o seguinte comando: 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

Integrar com IA/ML real

Em vez de processamento de OCR simulado, use modelos do Gemini para extrair, classificar e traduzir.

1. Substitua a lógica de OCR fictícia. Envie a imagem/PDF para o Gemini para extrair texto e dados reais. Analise o texto extraído para classificar o tipo de documento (fatura, contrato, currículo) ou extrair entidades (datas, nomes, locais).
2. Detecte automaticamente o idioma do documento e traduza-o para o inglês antes de armazená-lo. Você também pode usar qualquer outro idioma.

Melhorar o armazenamento e a análise

Você pode configurar regras de ciclo de vida no bucket para mover arquivos antigos para o armazenamento "Coldline" ou "Archive" para economizar custos.

Robustez e segurança

Você pode tornar o app mais robusto e seguro, como:

1. Filas de mensagens mortas (DLQ): atualize a assinatura do Pub/Sub para processar falhas. Se o serviço do Cloud Run não conseguir processar um arquivo cinco vezes, envie a mensagem para um tópico/bucket de "mensagens mortas" separado para inspeção humana.
2. Secret Manager: se o app precisar de chaves de API ou configuração sensível, armazene-as no Secret Manager e acesse-as com segurança no Cloud Run em vez de codificar strings.
3. Eventarc: faça upgrade do Pub/Sub direto para o Eventarc para um roteamento de eventos mais flexível, permitindo que você acione com base em registros de auditoria complexos ou outros eventos de serviço do GCP.

É claro que você pode criar suas próprias ideias e usar o Antigravity para ajudar a implementá-las.

9. Conclusão

Você criou um pipeline de documentos escalonável, sem servidor e com tecnologia de IA em minutos usando o Google Antigravity. Você aprendeu a:

• Planejar arquiteturas com IA.
• Instruir e gerenciar o Antigravity enquanto ele trabalha na geração do aplicativo, desde a geração de código até a implantação e validação.
• Verificar implantações e validação com tutoriais.

Documentos de referência

• Site oficial : https://antigravity.google/
• Documentação: https://antigravity.google/docs
• Casos de uso : https://antigravity.google/use-cases
• Download : https://antigravity.google/download