Fluxos de trabalho com prioridade para agentes: do comando à produção

1. Visão geral

Bem-vindo ao "Dia 2". Embora criar um app e clicar em "Publicar" seja mágico, o tráfego do mundo real traz falhas do mundo real. Em vez de passar os dias lutando com YAML ou procurando em registros, você pode criar um enxame de agentes especializados para gerenciar o encanamento operacional. Este codelab mostra como a pilha unificada do Google Cloud (Eventarc, Cloud Run, Firestore, Cloud Build, BigQuery) facilita a busca segura de secrets, o streaming de registros e a correção de problemas de maneira imediata.

Neste codelab, você vai criar o DinoQuest, um jogo de aventura de dinossauros com tecnologia do Gemini, do zero e conectá-lo a um pipeline de CI/CD totalmente autônomo. Ao final, você terá:

• Um app da Web DinoQuest em funcionamento no Cloud Run (nome do serviço: dinoquest)
• Um pipeline de análise de registros que transmite registros do Cloud Run para o BigQuery e gera um painel interativo de insights de jogos.
• Agente de correção (remediation-agent): um agente de correção do ADK que monitora erros do Cloud Run e os corrige automaticamente. Ele é implantado como um serviço do Cloud Run acionado pelo Eventarc.
• Um agente de CI (ci-agent) que lê o diff do PR, escopo de testes de maneira inteligente, cria uma imagem Docker usando o Cloud Build e envia um status de commit de volta para o GitHub
• Um agente de CD que avalia o risco de implantação, divide o tráfego, monitora métricas e promove ou faz o rollback automaticamente.

O que você vai aprender

• Como implantar um app Vite + FastAPI de pilha completa no Cloud Run como um único contêiner
• Como configurar o Firebase Auth e o Firestore para um app React
• Como criar e implantar um agente do ADK que reage a eventos do Pub/Sub via Eventarc
• Como rotear registros do Cloud Run para o BigQuery e consultar análises de jogos
• Como escrever habilidades de agente para CI e implantação canário

O que é necessário

• Tenha um projeto do Google Cloud com o faturamento ativado.
• Um projeto do Firebase (pode ser o mesmo projeto do GCP)
• Uma conta do GitHub e um fork do repositório DinoQuest
• Acesso ao Antigravity com o Gemini (executor de agentes do Google)
• CLI gcloud instalada e autenticada. Consulte as instruções de instalação abaixo.
• node ≥ 18 e npm
• python3 ≥ 3.11
• git e gh (CLI do GitHub)

Instalar a CLI gcloud

macOS

brew install --cask google-cloud-sdk

Ou baixe o instalador em cloud.google.com/sdk/docs/install.

Windows

winget install Google.CloudSDK

Ou baixe o instalador do Windows (.exe) em cloud.google.com/sdk/docs/install e execute-o.

Depois de instalar, inicialize e autentique:

gcloud init
gcloud auth login
gcloud auth application-default login

2. Configurar o Firebase

Todo agente precisa de dados para raciocinar. O DinoQuest usa o Firestore e o Firebase Auth para fornecer uma camada de dados pronta para produção que nossos agentes vão descobrir, explorar e atualizar usando linguagem natural.

Como esse app foi gerado pelo AI Studio, ele está altamente integrado ao Firebase. Usar o Firebase oferece várias vantagens, principalmente uma arquitetura pré-protegida e acesso aos dados gerenciado prontos para uso, garantindo que o estado do jogo esteja protegido desde o primeiro dia.

A. Criar um projeto do Firebase

1. Acesse console.firebase.google.com.
2. Clique em Adicionar projeto (fica oculto na opção de criar um projeto) → selecione seu projeto do GCP (ou crie um novo).
3. Desative o Google Analytics se solicitado → Criar projeto (ou use a configuração padrão).

B. Ativação da autenticação do Google

1. No console do Firebase, acesse Segurança → Autenticação (Começar) → Método de login.
2. Clique em Google → ative Ativar → salve seu e-mail de suporte → Salvar

C. Adicionar localhost como um domínio autorizado

1. Ainda em Autenticação, clique na guia Configurações.
2. Em Domínios autorizados, confirme se localhost está listado (deve estar por padrão).

D. Crie um banco de dados Firestore

1. Acesse Banco de dados e armazenamento → Banco de dados do Firestore → Criar banco de dados
2. Escolha Standard Edition → Próxima
3. Selecione a região us-central1 (ou a mesma do Cloud Run).
4. Escolha Iniciar no modo de produção → Criar

Depois de criado, anote o ID do banco de dados. Ele vai aparecer como (default), a menos que você tenha dado um nome a ele.

E. Definir regras de segurança do Firebase

Em Banco de dados do Firestore → Regras, substitua as regras padrão por:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // ===============================================================
    // Helper Functions
    // ===============================================================
    function isAuthenticated() {
      return request.auth != null;
    }
    
    function isOwner(userId) {
      return isAuthenticated() && request.auth.uid == userId;
    }

    function isValidUser(data) {
      return data.keys().hasAll(['uid', 'email']) &&
             data.uid is string && data.uid.size() > 0 &&
             (data.email == null || (data.email is string && data.email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")));
    }

    function isValidDinosaur(data) {
      return data.keys().hasAll(['userId', 'name', 'type']) &&
             data.userId == request.auth.uid &&
             data.name is string && data.name.size() > 0 && data.name.size() < 50 &&
             data.type in ['Speedy', 'Tank', 'Balanced', 'Agile'];
    }

    function isValidGame(data) {
      return data.keys().hasAll(['userId', 'score']) &&
             data.userId == request.auth.uid &&
             data.score is number && data.score >= 0;
    }


    match /users/{userId} {
      allow read: if isOwner(userId);
      allow create: if isOwner(userId) && isValidUser(request.resource.data);
      allow update: if isOwner(userId) && isValidUser(request.resource.data);

      match /dinosaurs/{dinoId} {
        allow read: if isOwner(userId);
        allow create: if isOwner(userId) && isValidDinosaur(request.resource.data);
        allow update: if isOwner(userId) && isValidDinosaur(request.resource.data);
      }

      match /games/{gameId} {
        allow read: if isOwner(userId);
        allow create: if isOwner(userId) && isValidGame(request.resource.data);
      }

      match /seenAnnouncements/{announcementId} {
        allow read, create: if isOwner(userId);
      }
    }

    match /announcements/{announcementId} {
      allow read: if isAuthenticated();
    }

    // Default deny
    match /{document=**} {
      allow read, write: if false;
    }

    match /scores/{scoreId} {
      allow read: if true;
      allow create: if isAuthenticated();
      allow update: if false;
    }
  }
}

Clique em Publicar.

F. Adicionar um app da Web e receber a configuração

1. Acesse Configurações do projeto (ícone de engrenagem) → guia Geral.
2. Role a tela até Seus apps → clique em Adicionar app → escolha o ícone Web ().
3. Nomeie o arquivo como dinoquest → Registrar app.
4. Copie o objeto firebaseConfig mostrado. Você vai precisar dele em breve.

3. Executar o jogo

Função do agente: o ambiente. Antes de colocar nossos agentes para trabalhar, precisamos de um mundo para eles gerenciarem. Nesta etapa, vamos implantar a versão "Day One" do DinoQuest. Isso cria o serviço ativo, os registros e o estado que nosso enxame vai descobrir e gerenciar mais tarde.

Escolha uma das duas opções abaixo. Qualquer uma delas produz um GEMINI_API_KEY que você usa de forma idêntica em todas as etapas posteriores. Não é necessário fazer outras mudanças.

A. Configurar a chave da API Gemini

Opção A: chave de API Gemini da Vertex AI (recomendada se você tiver um projeto do GCP)

Com a Vertex AI, você pode criar uma chave de API Gemini vinculada diretamente ao seu projeto do GCP e faturada a ele, usando a conta de serviço padrão do projeto. Não é necessário ter uma conta separada do AI Studio.

1. Exporte o ID do projeto do GCP:

   export PROJECT_ID=<YOUR_PROJECT_ID>
   

2. Ative as APIs necessárias e conceda as permissões necessárias à conta de serviço padrão do Compute Engine:

   gcloud auth application-default set-quota-project $PROJECT_ID
   gcloud config set project $PROJECT_ID
   
   # Enable Vertex AI, Compute Engine, and Generative Language APIs
   gcloud services enable aiplatform.googleapis.com \
                          compute.googleapis.com \
                          generativelanguage.googleapis.com
   
   # Grant Vertex AI User role to the default compute service account
   PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:${PROJECT_NUMBER}[e-mail]" \
     --role="roles/aiplatform.user" \
     --condition=None
   

3. Abra a página de chaves de API da Vertex AI no console do Cloud.
4. Clique em Criar credenciais → selecione Chave de API
5. Na caixa de diálogo de criação:
   • Nomeie a chave como Dino_Key.
   • Marque a caixa Autenticar chamadas de API por uma conta de serviço.
   • Em "Conta de serviço", selecione a conta de serviço padrão do Compute ([e-mail]).
   • De volta à página Selecionar restrições de API, marque API GEMINI.
   • Clique em Criar.
6. Copie a chave gerada.

Opção B: AI Studio (mais rápido para desenvolvimento local)

1. Acesse aistudio.google.com
2. Clique em Receber chave de API na barra lateral esquerda.
3. Clique em Criar chave de API → escolha seu projeto do GCP → copie a chave.

Qualquer uma das chaves é definida como GEMINI_API_KEY nas etapas a seguir. O back-end as trata de maneira idêntica.

Clonar o repositório

O repositório do curso está em https://github.com/gca-americas/dinoquest. Primeiro, ramifique para sua própria conta do GitHub. Em vez disso, o agente vai trabalhar no seu repositório.

Depois de fazer o fork, clone a ramificação main do repositório DinoQuest bifurcado e insira o diretório do projeto:

git clone https://github.com/YOUR_GITHUB_USERNAME/dinoquest.git
cd dinoquest

B. Configurar variáveis de ambiente

Em todos os novos terminais bash que você abrir durante este codelab, defina essas variáveis de ambiente essenciais. Substitua os valores de marcador pelos detalhes reais do projeto:

Primeiro, exporte o URL do repositório do GitHub:

export GITHUB_REPO_URL=https://github.com/YOUR_GITHUB_USERNAME/dinoquest

Em seguida, exporte as variáveis de ambiente restantes:

export PROJECT_ID=your-project-id
export GOOGLE_CLOUD_PROJECT=$PROJECT_ID
export CLOUD_RUN_REGION=us-central1
export GOOGLE_GENAI_USE_VERTEXAI=True
export HARNESS_EVENTS_TOPIC=projects/$PROJECT_ID/topics/harness-events
export CLOUD_BUILD_REPO=<YOUR_GITHUB_USERNAME>-dinoquest

Confirme se a estrutura está correta:

dinoquest/
├── backend/          # FastAPI backend (serves frontend + Gemini API calls)
├── frontend/         # React/Vite frontend
├── skills/           # Agentic CI/CD skill files
├── Dockerfile        # Multi-stage build (React → Python)
├── start.sh          # Local dev launcher
└── README.md

B. Criar o arquivo de ambiente de back-end

Primeiro, exporte sua chave da API Gemini:

export GEMINI_API_KEY=YOUR_GEMINI_API_KEY_FROM_STEP_2

Em seguida, crie o arquivo .env:

cat > backend/.env <<EOF
GEMINI_API_KEY=$GEMINI_API_KEY
GOOGLE_GENAI_USE_VERTEXAI=False
GOOGLE_CLOUD_PROJECT=$PROJECT_ID
EOF

C. Ativar o Firebase App Check / conta de serviço (para o Cloud Run)

Ao ser executado no Cloud Run, o back-end usa as Application Default Credentials para se comunicar com o Firebase. Não é necessário um arquivo de chave de conta de serviço. A chamada firebase_admin.initialize_app() em backend/main.py faz isso automaticamente.

Para desenvolvimento local, autentique uma vez:

gcloud auth application-default login

D. Criar o arquivo de configuração do App do Firebase

No diretório frontend/, crie firebase-applet-config.json com sua configuração da etapa anterior:

{
  "apiKey": "YOUR_API_KEY",
  "authDomain": "YOUR_PROJECT_ID.firebaseapp.com",
  "projectId": "YOUR_PROJECT_ID",
  "storageBucket": "YOUR_PROJECT_ID.appspot.com",
  "messagingSenderId": "YOUR_SENDER_ID",
  "appId": "YOUR_APP_ID",
  "firestoreDatabaseId": "(default)"
}

Observação : firestoreDatabaseId precisa corresponder ao ID do banco de dados criado na etapa anterior. Se você usou o padrão, deixe como "(default)".

Confirme as mudanças no repositório:

git add frontend/firebase-applet-config.json
git commit -m "chore: add firebase config"
git push origin main

C. Executar o DinoQuest localmente

1. Ativar APIs obrigatórias

gcloud services enable \
  run.googleapis.com \
  cloudbuild.googleapis.com \
  artifactregistry.googleapis.com \
  secretmanager.googleapis.com \
  firestore.googleapis.com \
  logging.googleapis.com \
  pubsub.googleapis.com \
  eventarc.googleapis.com \
  aiplatform.googleapis.com \
  bigquery.googleapis.com \
  aiplatform.googleapis.com

2. Iniciar DinoQuest

O script start.sh cria o front-end do React e entrega o terminal ao back-end do FastAPI, que veicula os arquivos estáticos compilados:

cd backend
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt -q

cd ..
# Force-remove the Vertex AI flag from the current terminal session to avoid conflicts
unset GOOGLE_GENAI_USE_VERTEXAI
./start.sh

Abra http://localhost:8000 no navegador. A tela de título do DinoQuest vai aparecer. Faça login com o Google, gere seu primeiro dinossauro e confirme se ele foi salvo no Firestore.

Solução de problemas:se você encontrar uma página em branco ou erros de autenticação do Firebase, verifique se frontend/firebase-applet-config.json tem os valores corretos e se localhost está na lista de domínios autorizados.

E. Implantar o DinoQuest no Cloud Run

1. Definir o projeto

export PROJECT_ID=$(gcloud config get-value project)

3. Crie um repositório do Artifact Registry

gcloud artifacts repositories create dinoquest \
  --repository-format=docker \
  --location=$CLOUD_RUN_REGION \
  --description="DinoQuest container images"

4. Armazenar a chave de API Gemini no Secret Manager

echo -n $GEMINI_API_KEY | \
  gcloud secrets create gemini-api-key --data-file=-

# Grant the default compute service account access to the secret
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud secrets add-iam-policy-binding gemini-api-key \
  --member="serviceAccount:${PROJECT_NUMBER}[e-mail]" \
  --role="roles/secretmanager.secretAccessor"

5. Criar a imagem do contêiner com o Cloud Build

gcloud builds submit \
  --tag $CLOUD_RUN_REGION-docker.pkg.dev/$PROJECT_ID/dinoquest/app:latest .

Isso executa o Dockerfile de vários estágios: primeiro cria o app React e depois empacota a saída na imagem do FastAPI. Leva de 3 a 5 minutos.

6. Implantar no Cloud Run

Primeiro, exporte seu e-mail de administrador:

export ADMIN_EMAIL=<YOUR_TEST_ACCOUNT_EMAIL>

Em seguida, implante o serviço:

gcloud run deploy dinoquest \
  --image=$CLOUD_RUN_REGION-docker.pkg.dev/$PROJECT_ID/dinoquest/app:latest \
  --region=$CLOUD_RUN_REGION \
  --platform=managed \
  --allow-unauthenticated \
  --memory=128Mi \
  --set-secrets="GEMINI_API_KEY=gemini-api-key:latest" \
  --set-env-vars="ADMIN_EMAILS=$ADMIN_EMAIL" \
  --set-env-vars="GOOGLE_GENAI_USE_VERTEXAI=False" \
  --set-env-vars="GOOGLE_CLOUD_PROJECT=$PROJECT_ID"

Quando o comando for concluído, o Cloud Run vai imprimir um URL do serviço. Copie este URL: você vai precisar dele para autorizar o domínio no Firebase.

7. Autorizar o domínio do Cloud Run no Firebase

Para permitir que os usuários façam login no app implantado, adicione o URL do Cloud Run aos domínios autorizados do Firebase:

1. Volte para o console do Firebase → Autenticação → Configurações → Domínios autorizados
2. Clique em Adicionar domínio.
3. Cole o URL do serviço do Cloud Run (por exemplo, dinoquest-xxxxx.us-central1.run.app) — remova o prefixo https://
4. Clique em Salvar.

8. Inserir dados no ranking

Para dar um pouco de "vida" ao jogo e garantir que os agentes tenham dados, você pode inserir algumas pontuações iniciais na tabela de classificação.

1. Verifique se você está no diretório raiz dinoquest:

   cd ~/dinoquest
   

2. Crie e ative um ambiente virtual:

   python3 -m venv venv
   source venv/bin/activate
   

3. Instale a dependência do Firestore necessária:

   pip install google-cloud-firestore
   

4. Execute o script de propagação:

   python3 prep/seed_scores.py
   

5. Desative o ambiente virtual:

   deactivate
   

Agora você pode abrir o URL do serviço no navegador. O DinoQuest está totalmente ativo.

4. Configurar o Dino Theater

Função do agente: visualizador. Como monitorar uma equipe de agentes autônomos? O Dino Theater oferece uma janela em tempo real para a mente do seu enxame de agentes. Em vez de ficar olhando para os registros do terminal, você pode acompanhar o raciocínio dos seus agentes, a comunicação entre eles e a execução de tarefas na nuvem em um painel visual ao vivo.

A. Implantar o Dino Theater no Cloud Run

Primeiro, volte ao diretório principal e clone o código do Dino Theater:

cd ~
git clone https://github.com/gca-americas/dinoquest-theater.git
cd dinoquest-theater

1. Crie e envie o contêiner:

   gcloud builds submit --tag $CLOUD_RUN_REGION-docker.pkg.dev/$PROJECT_ID/dinoquest/dino-theater:latest .
   

2. Configurar conta de serviço e permissões:

   # Create the service account
   gcloud iam service-accounts create dino-theater
   
   # Create the Pub/Sub topic (if you haven't yet)
   gcloud pubsub topics create harness-events
   
   # Create the subscription
   gcloud pubsub subscriptions create harness-events-theater \
     --topic=harness-events
   
   # Grant subscriber role
   gcloud pubsub subscriptions add-iam-policy-binding harness-events-theater \
     --member="serviceAccount:dino-theater@${PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/pubsub.subscriber"
   

3. Implante o aplicativo:

   gcloud run deploy dino-theater \
     --image $CLOUD_RUN_REGION-docker.pkg.dev/$PROJECT_ID/dinoquest/dino-theater:latest \
     --region=$CLOUD_RUN_REGION \
     --service-account=dino-theater@${PROJECT_ID}.iam.gserviceaccount.com \
     --set-env-vars="GOOGLE_CLOUD_PROJECT=$PROJECT_ID" \
     --allow-unauthenticated \
     --min-instances=1
   

   Observação: --min-instances=1 é recomendado para manter a conexão SSE ativa entre eventos.
4. Verifique se ele funciona:abra o URL do serviço implantado no navegador (por exemplo, https://dino-theater-xxx-uc.a.run.app/demo).

5. DevOps agêntico no ambiente de desenvolvimento integrado

Função do agente: antigravidade nativa. Para diminuir a distância entre o IDE e a nuvem, conectamos o Antigravity aos servidores MCP gerenciados do Google Cloud. Isso dá ao seu agente nativo "olhos" no projeto, permitindo que ele analise registros, verifique métricas e raciocine sobre a infraestrutura sem que você precise manipular chaves de API ou mudar de contexto para o console.

Antes de executar qualquer habilidade, configure o acesso do Antigravity ao Google Cloud e carregue os playbooks de habilidades do DinoQuest.

A. Instalar o serviço MCP gerenciado do Google

O serviço Managed MCP do Google oferece acesso a todas as APIs do Cloud por um único endpoint hospedado.

Autentique usando o Application Default Credentials:

gcloud auth application-default login

B. Configurar mcp_config.json

Crie ou atualize mcp_config.json no diretório de configuração do Antigravity (geralmente ~/.gemini/antigravity/mcp_config.json) ou no console. Isso dá ao Antigravity acesso às ferramentas do Google Cloud e do GitHub de que as habilidades precisam:

{
  "mcpServers": {
    "google-developer-knowledge": {
      "serverUrl": "https://developerknowledge.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    },
    "google-bigquery": {
      "serverUrl": "https://bigquery.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    },
    "google-cloud-logging": {
      "serverUrl": "https://logging.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    },
    "google-cloud-monitoring": {
      "serverUrl": "https://monitoring.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "disabledTools": [
        "get_dashboard",
        "list_dashboards"
      ]
    },
    "google-cloud-run": {
      "serverUrl": "https://run.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "disabledTools": [
        "deploy_service_from_image",
        "deploy_service_from_archive",
        "deploy_service_from_file_contents"
      ]
    },
    "google-cloud-sql": {
      "serverUrl": "https://sqladmin.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "disabled": true
    },
    "google-cloud-trace": {
      "serverUrl": "https://cloudtrace.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    },
    "google-error-reporting": {
      "serverUrl": "https://clouderrorreporting.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    },
    "google-firestore": {
      "serverUrl": "https://firestore.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    },
    "google-resource-manager": {
      "serverUrl": "https://cloudresourcemanager.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    },
    "gemini-cloud-assist": {
      "serverUrl": "https://geminicloudassist.googleapis.com/mcp",
      "authProviderType": "google_credentials"
    }
  }
}

C. Carregar habilidades no Antigravity (opcional)

O Antigravity descobre habilidades em diretórios padrão específicos. Copie as habilidades do DinoQuest do repositório clonado para a pasta global de habilidades do Antigravity:

# Create the standard skills directory if it doesn't exist
mkdir -p ~/.gemini/antigravity/skills

# Copy all DinoQuest skills into the global skills folder
cp -r skills/* ~/.gemini/antigravity/skills/

D. Reinicie o Antigravity(opcional).

Para aplicar as mudanças de mcp_config.json e carregar as habilidades recém-copiadas, reinicie o aplicativo Antigravity.

Depois de reiniciar:

1. Verifique se os servidores MCP google e github mostram o status verde "Conectado" em Configurações.
2. Verifique se as habilidades do DinoQuest aparecem na sua lista de habilidades.

Observação:cada habilidade tem uma tabela ## Configuration na parte de cima da SKILL.md. Depois de copiar, atualize os valores em ~/.gemini/antigravity/skills//SKILL.md para corresponder ao seu projeto.

E. Corrigir o serviço de nuvem no ambiente de desenvolvimento integrado local

1. Acione o erro: abra o URL implantado do DinoQuest (da última etapa) no navegador.
2. Acessar o ranking: clique no botão Ranking. A implementação atual do ranking é propositalmente ineficiente. Ela tenta carregar uma quantidade enorme de dados na memória, o que causa um erro de falta de memória (OOM, na sigla em inglês).
3. No Antigravity Agent Manager (Agent HUB), peça ajuda para recuperar o erro e possivelmente corrigir a causa raiz.

• comando 1: Descubra o que há de errado com o dinoquest.
• comando 2: Você pode analisar o código do jogo Dinoquest e corrigir o que causou o erro de falta de memória?

6. Transmitir registros para o BigQuery e gerar análises

Função do agente: agente de dados. Transformar registros brutos em uma estratégia de produto útil não deve levar horas de tratamento manual de dados. Usando o Data Agent Kit e o BigQuery MCP, criamos um pipeline "Zero ETL" que transmite registros diretamente para o BigQuery, permitindo que o agente gere um painel de análise premium em menos de dois minutos.

A habilidade log-router-bq-report configura um coletor do Cloud Logging que transmite continuamente os registros do Cloud Run do DinoQuest para o BigQuery e consulta os dados para gerar relatórios de tráfego e insights de análise de jogos.

A. Configurar as variáveis de habilidade

Abra skills/log-router-bq-report/SKILL.md no repositório DinoQuest e atualize a seção Configuration na parte de cima:

| Variable      | Your Value         |
|---------------|--------------------|
| SERVICE_NAME  | dinoquest          |
| BQ_DATASET    | dinoquest_logs     |
| LOG_SINK_NAME | dinoquest-bq-sink  |

B. Executar a habilidade no Antigravity

Abra o Antigravity com o repositório DinoQuest como contexto e diga ao Gemini:

Run the log-router-bq-report skill

A habilidade vai:

1. Resolver seu projeto do GCP automaticamente
2. Verifique se o gravador do BigQuery já existe. Caso contrário, ele vai criar o conjunto de dados e o gravador.
3. Conceder permissões do IAM: concede ao writerIdentity do coletor a função de Editor de dados do BigQuery no conjunto de dados.

Observação:assim como o coletor do Eventarc, talvez você veja um alerta do gcloud durante esse processo: "Não se esqueça de conceder à serviceAccount:service-... o papel de editor de dados do BigQuery no conjunto de dados". A skill faz isso automaticamente.

C. Usar o Antigravity para gerar o relatório

Basta pedir para o Antigravity "configurar o coletor de registros do BigQuery e gerar o relatório de análise". O agente vai:

1. Configurar a infraestrutura: crie o conjunto de dados do BigQuery e o gravador do Cloud Logging.
2. Gerenciar permissões: concede automaticamente os papéis do IAM necessários à identidade de gravador do coletor.
3. Gerar insights: analise os registros e produza um painel HTML premium e interativo com telemetria de jogos e análise de taxa de vitórias.

7. Agente de correção automática

Função do agente: agente de SRE. Quando um serviço de produção falha às 2h, você não precisa acordar. Esse agente age como seu primeiro atendimento. Acionado por registros de erros do Cloud Run via Eventarc, ele analisa automaticamente a falha, propõe uma correção e inicia um pipeline de correção, tudo isso antes mesmo de você fazer login no console do Google Cloud.

O DinoAgent é um agente do ADK que detecta registros de erros do Cloud Run via Eventarc, diagnostica a causa raiz e corrige automaticamente, seja aumentando a memória, revertendo o tráfego ou enviando uma solicitação de pull de correção de código no GitHub.

A. Clonar o repositório do agente de correção

cd ~
git clone https://github.com/gca-americas/dinoquest-reme-agent.git
cd dinoquest-reme-agent

Estrutura do projeto:

dinoquest-reme-agent/
├── main.py              # Service entrypoint — receives Eventarc HTTP POST, runs agent
├── runner.py            # ADK Runner + session service
├── agent.py             # LlmAgent definition, loads skill from file
├── tools.py             # Cloud Run v2 API tools (list/get/rollback/update)
├── skills/
│   └── remediation/
│       ├── SKILL.md     # Agent playbook — edit this to change behavior
│       └── scripts/     # Shell scripts for the code-fix track
│           ├── clone_repo.sh
│           ├── read_file.sh
│           ├── apply_fix.sh
│           ├── commit_branch.sh
│           ├── open_pr.sh
│           └── rollback_fix.sh
├── requirements.txt
└── Dockerfile

B. Configurar o acesso ao GitHub (faixa de correção de código)

A faixa de correção de código clona seu repositório DinoQuest, lê arquivos de origem, aplica patches e abre PRs. Ele precisa de um token de acesso pessoal do GitHub com o escopo repo.

1. Acesse github.com/settings/tokens → Gerar novo token (clássico).
2. Dê um nome a ele, selecione o escopo repo → Gerar token → copie o token.

Armazene no Secret Manager:

Primeiro, exporte seu token do GitHub:

export GH_TOKEN=ghp_YOUR_TOKEN_HERE

Em seguida, crie o secret:

echo -n $GH_TOKEN | \
  gcloud secrets create github-token --data-file=-

C. Configurar notificações do Slack (opcional)

Quando uma correção é concluída, o DinoAgent posta um resumo em um canal do Slack.

1. Acesse api.slack.com/apps → Criar novo app → Do zero
2. Nomeie como DinoAgent, selecione seu espaço de trabalho → Criar app
3. Em Recursos → Webhooks de entrada → ative
4. Clique em Adicionar novo webhook ao espaço de trabalho → escolha um canal → Permitir.
5. Copie o URL do webhook (https://hooks.slack.com/services/...).

Armazene no Secret Manager:

export SLACK_TOKEN=YOUR_SLACK_WEBHOOK
echo -n "https://hooks.slack.com/services/$SLACK_TOKEN" | \
  gcloud secrets create slack-webhook --data-file=-

D. Criar a conta de serviço DinoAgent

gcloud iam service-accounts create remediation-agent \
  --display-name="Cloud Run Remediation Agent"

export SA="remediation-agent@${PROJECT_ID}.iam.gserviceaccount.com"

for ROLE in \
  roles/run.admin \
  roles/iam.serviceAccountUser \
  roles/eventarc.eventReceiver \
  roles/aiplatform.user \
  roles/artifactregistry.reader \
  roles/secretmanager.secretAccessor \
  roles/pubsub.publisher \
  roles/logging.viewer; do
  gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${SA}" --role="$ROLE" \
    --condition=None
done

Conceda acesso aos secrets:

for SECRET in github-token slack-webhook; do
  gcloud secrets add-iam-policy-binding $SECRET \
    --member="serviceAccount:${SA}" \
    --role="roles/secretmanager.secretAccessor"
done

E. Criar e implantar o DinoAgent no Cloud Run

# Get Project Number for the CIAgent URL
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
export CIAGENT_URL=https://ci-agent-${PROJECT_NUMBER}.${CLOUD_RUN_REGION}.run.app
export SA="remediation-agent@${PROJECT_ID}.iam.gserviceaccount.com"
export GITHUB_REPO_URL=https://github.com/YOUR_REPO
HARNESS_EVENTS_TOPIC=projects/$PROJECT_ID/topics/harness-events


AGENT_IMAGE="$CLOUD_RUN_REGION-docker.pkg.dev/${PROJECT_ID}/dinoquest/remediation-agent:latest"
gcloud builds submit --tag $AGENT_IMAGE .


gcloud run deploy remediation-agent \
  --image=$AGENT_IMAGE \
  --region=$CLOUD_RUN_REGION \
  --service-account=$SA \
  --memory=2Gi \
  --set-env-vars="GOOGLE_CLOUD_PROJECT=${PROJECT_ID},GOOGLE_GENAI_USE_VERTEXAI=True" \
  --set-env-vars="GITHUB_REPO_URL=${GITHUB_REPO_URL}" \
  --set-secrets="SLACK_WEBHOOK_URL=slack-webhook:latest" \
  --set-env-vars="HARNESS_EVENTS_TOPIC=${HARNESS_EVENTS_TOPIC}" \
  --set-env-vars="CIAGENT_URL=${CIAGENT_URL}" \
  --set-secrets="GITHUB_TOKEN=github-token:latest" \
  --no-allow-unauthenticated \
  --min-instances=1 \
  --no-cpu-throttling \
  --timeout=300

F. Conectar o gatilho do Eventarc

Crie um tópico do Pub/Sub para receber registros de erros do Cloud Run:

gcloud pubsub topics create cloud-run-errors

Crie um coletor do Cloud Logging que filtre os registros de erros do serviço dinoquest e os encaminhe para o tópico:

export SERVICE_NAME=dinoquest
FILTER="resource.type=\"cloud_run_revision\" resource.labels.service_name=\"$SERVICE_NAME\" severity=ERROR NOT logName=~\"cloudaudit\" NOT httpRequest.requestUrl=~\"/_ah/health\""

gcloud logging sinks create cloud-run-errors-sink \
  pubsub.googleapis.com/projects/${PROJECT_ID}/topics/cloud-run-errors \
  --log-filter="$FILTER"

Observação:ao executar o comando acima, gcloud vai imprimir uma mensagem de Informação dizendo: "Não se esqueça de conceder à serviceAccount:service-... o papel de Publicador do Pub/Sub no tópico". A próxima etapa faz exatamente isso.

Conceda à identidade do gravador do coletor (a conta de serviço mencionada no aviso) permissão para publicar:

SINK_SA=$(gcloud logging sinks describe cloud-run-errors-sink \
  --format='value(writerIdentity)')

gcloud pubsub topics add-iam-policy-binding cloud-run-errors \
  --member="${SINK_SA}" --role="roles/pubsub.publisher"

Verifique se ele está ativo:

gcloud eventarc triggers describe remediation-trigger --location=$CLOUD_RUN_REGION

Conceda permissão ao Eventarc para invocar o agente de correção:

gcloud run services add-iam-policy-binding remediation-agent \
  --region=$CLOUD_RUN_REGION \
  --member="serviceAccount:${SA}" \
  --role="roles/run.invoker"

Crie o gatilho do Eventarc:

gcloud eventarc triggers create remediation-trigger \
  --location=$CLOUD_RUN_REGION \
  --destination-run-service=remediation-agent \
  --destination-run-region=$CLOUD_RUN_REGION \
  --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished" \
  --transport-topic=projects/${PROJECT_ID}/topics/cloud-run-errors \
  --service-account=${SA}

A correção agora é totalmente automatizada. Além de apenas escalonar a infraestrutura, o DinoAgent realiza uma análise detalhada da causa raiz no código do aplicativo, aplica um patch semântico e usa a comunicação agente-para-agente (A2A) para transferir a correção ao agente de CI para verificação e implantação. Confira os detalhes da implementação na base de código do agente reme.

8. Configurar o agente de CI

Função do agente: pipeline de CI. Pare de lutar com arquivos YAML complexos e scripts de build manuais. Esse agente gerencia a parte operacional dos seus PRs. Ele lê as mudanças no código, entende o contexto, define o escopo dos testes necessários e cria as imagens do Docker usando o Cloud Build, garantindo que cada commit seja "aprovado pelo agente" antes de chegar à ramificação principal.

O ci-agent é um agente de pipeline de CI autônomo implantado como um serviço do Cloud Run. Ele envia builds do Docker para o Cloud Build, faz pesquisas de conclusão, verifica a imagem no Artifact Registry e gera relatórios para o GitHub.

Por que usar um agente no pipeline de CI? Ao contrário dos scripts estáticos tradicionais, um pipeline de CI agêntico oferece:

1. Classificação de escopo cognitivo: determina de maneira inteligente a profundidade de teste necessária, alternando entre verificações de tipo, testes de unidade ou conjuntos de integração completos, com base no impacto semântico das mudanças no código.
2. Gerenciamento autônomo de PRs: o agente pode criar PRs automaticamente, postar resumos detalhados de mudanças e até mesmo gerenciar a verificação de segredos e auditorias de segurança sem intervenção humana.
3. Diagnóstico de falhas em tempo real: quando um build falha, o agente não apenas mostra os registros. Ele analisa o rastreamento de pilha, identifica a causa provável e publica um diagnóstico legível diretamente na solicitação de pull.

A. Clonar o repositório CIAgent

cd ~
git clone https://github.com/gca-americas/dinoquest-ci-agent.git
cd dinoquest-ci-agent

B. Criar a conta de serviço do CIAgent

gcloud iam service-accounts create ci-agent \
  --display-name="CIAgent CI Pipeline"

export SA="ci-agent@${PROJECT_ID}.iam.gserviceaccount.com"

# Grant necessary roles to the service account
for ROLE in \
  roles/cloudbuild.builds.editor \
  roles/cloudbuild.builds.builder \
  roles/artifactregistry.reader \
  roles/artifactregistry.writer \
  roles/aiplatform.user \
  roles/secretmanager.secretAccessor \
  roles/pubsub.publisher \
  roles/developerconnect.admin; do
  gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${SA}" --role="$ROLE" \
    --condition=None
done



# ci-agent needs to act as itself when running build steps
gcloud iam service-accounts add-iam-policy-binding $SA \
  --member="serviceAccount:${SA}" \
  --role="roles/iam.serviceAccountUser"

C. Conectar o repositório do GitHub ao Cloud Build

O CIAgent envia builds via repoSource, o que exige que o repositório do GitHub esteja conectado ao Cloud Build Developer Connect.

1. Acesse Console do GCP → Cloud Build → Repositórios.
2. Clique em Conectar repositório.
3. Selecione GitHub (app GitHub do Cloud Build).
4. Autorizar e selecionar seu repositório YOUR_GITHUB_USERNAME/dinoquest
5. Clique em Conectar e Pular quando for solicitado a criar um gatilho.
6. Anote o nome da conexão. O padrão geralmente é o nome de usuário do GitHub ou algo parecido.

D. Conceder acesso do CIAgent a secrets

Vamos reutilizar os secrets criados anteriormente para o DinoAgent:

gcloud secrets add-iam-policy-binding github-token \
  --member="serviceAccount:${SA}" \
  --role="roles/secretmanager.secretAccessor"

gcloud secrets add-iam-policy-binding slack-webhook-ci \
  --member="serviceAccount:${SA}" \
  --role="roles/secretmanager.secretAccessor"

E. Criar e implantar o CIAgent no Cloud Run

# Set up required variables for orchestration
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
export CDAGENT_URL=https://cd-agent-${PROJECT_NUMBER}.${CLOUD_RUN_REGION}.run.app
export CI_AGENT_URL=ci-agent-${PROJECT_NUMBER}.${CLOUD_RUN_REGION}.run.app
export GITHUB_OWNER="YOUR_GITHUB_USERNAME"
export CLOUD_BUILD_CONNECTION="YOUR_CONNECTION_NAME"  # Update this if your connection name is different
export CLOUD_BUILD_REPO="YOUR_GITHUB_USERNAME-dinoquest" # Update this if your connection name is different

export SLACK_TOKEN=YOUR_SLACK_WEBHOOK
echo -n "https://hooks.slack.com/services/$SLACK_TOKEN" | \
  gcloud secrets create slack-webhook-ci --data-file=-

export SA="ci-agent@${PROJECT_ID}.iam.gserviceaccount.com"
AGENT_IMAGE="$CLOUD_RUN_REGION-docker.pkg.dev/${PROJECT_ID}/dinoquest/ci-agent:latest"
gcloud builds submit --tag $AGENT_IMAGE .

gcloud run deploy ci-agent \
  --image=$AGENT_IMAGE \
  --region=$CLOUD_RUN_REGION \
  --service-account=$SA \
  --memory=1Gi \
  --timeout=600 \
  --allow-unauthenticated \
  --min-instances=1 \
  --set-env-vars="GOOGLE_CLOUD_PROJECT=${PROJECT_ID},GOOGLE_GENAI_USE_VERTEXAI=True" \
  --set-env-vars="HARNESS_EVENTS_TOPIC=${HARNESS_EVENTS_TOPIC}" \
  --set-env-vars="HOST=${CI_AGENT_URL},PROTOCOL=https" \
  --set-secrets="SLACK_WEBHOOK_URL=slack-webhook-ci:latest" \
  --set-env-vars="GITHUB_OWNER=${GITHUB_OWNER},GITHUB_REPO=dinoquest" \
  --set-env-vars="CLOUD_BUILD_CONNECTION=${CLOUD_BUILD_CONNECTION},CLOUD_BUILD_REPO=${CLOUD_BUILD_REPO},CLOUD_BUILD_REGION=${CLOUD_RUN_REGION}" \
  --set-env-vars="CDAGENT_URL=${CDAGENT_URL}" \
  --set-secrets="GITHUB_TOKEN=github-token:latest" \
  --min-instances=1

F. Configuração do comando de barra do Slack

1. Acesse api.slack.com/apps → Create New App → From scratch.
2. Nomeie como CIAgent, escolha seu espaço de trabalho → Criar app
3. Em Recursos → Comandos de barra → Criar novo comando
4. Comando: /runci
5. URL da solicitação: o URL do Cloud Run do CIAgent acima com /slack anexado (por exemplo, https://ci-agent-xxx-.us-central1.run.app/slack)
6. Descrição curta: Trigger CI
7. Salvar
8. Em Configurações → Instalar app, clique em Instalar no Workspace e em Permitir.

O agente de CI atua como um "cérebro" que fica acima de serviços robustos do Google Cloud, como o Cloud Build e o Artifact Registry. Depois que o build é verificado, ele aciona a fase final de implantação chamando o agente de CD via A2A, garantindo uma transferência perfeita entre os ciclos de build e lançamento.

9. Configurar a implantação

Função do agente: agente de CD. A implantação não deve ser um salto de fé. Esse agente gerencia o risco para você. Ele avalia a segurança da implantação, gerencia divisões de tráfego canário e monitora métricas em tempo real para decidir se uma versão deve ser promovida ou revertida. É o último gatekeeper no seu enxame de agentes autônomos.

O cd-agent é um agente de implantação canário autônomo implantado como um serviço do Cloud Run. Ele recebe solicitações de implantação de A2A de ci-agent, calcula uma pontuação de risco, define uma porcentagem canário calibrada por risco, monitora métricas e promove ou faz o rollback automaticamente. Ele também aprende com implantações anteriores usando o Firestore.

A conexão direta de agentes cria um "pipeline cognitivo" em que cada transferência é uma transferência rica de intenção e contexto. Ao contrário dos webhooks tradicionais, a comunicação A2A permite:

1. Compartilhamento inteligente de contexto: os agentes transmitem memórias de sessão inteiras, diferenças de solicitação de pull e pontuações de risco, garantindo que o próximo agente tenha o "porquê" completo antes de começar a trabalhar.
2. Cognitive Handshakes: os agentes podem negociar portões. Por exemplo, o agente de CD pode solicitar testes de fumaça específicos do agente de CI durante um lançamento canário para verificar uma correção em tempo real.
3. Correção colaborativa: se uma implantação falhar, o agente de CD poderá notificar proativamente o agente de correção com métricas com falha, iniciando uma análise autônoma de causa raiz antes mesmo de um humano ser notificado.
4. Negociação de recursos: os agentes podem negociar necessidades de infraestrutura. Por exemplo, o agente de CI pode pedir ao agente de correção para provisionar mais capacidade de build se detectar uma refatoração em grande escala, ou o agente de CD pode sugerir o escalonamento do cluster de produção antes de um lançamento importante.
5. Consenso multiagente: para mudanças de alto risco, vários agentes (por exemplo, agente de segurança e agente de CD) podem realizar uma "aprovação conjunta" via A2A, garantindo que o código não apenas crie e implante, mas também siga as políticas de segurança antes de entrar em produção.

A. Clonar o repositório CDAgent

cd ~
git clone https://github.com/gca-americas/dinoquest-cd-agent.git
cd dinoquest-cd-agent

B. Criar o banco de dados do Firestore

O CDAgent armazena os padrões de memória de implantação no Firestore:

gcloud firestore databases create \
  --region=$CLOUD_RUN_REGION \
  --project=$PROJECT_ID

Se você já tiver criado um banco de dados neste projeto, pule esta etapa.

C. Criar a conta de serviço do CDAgent

gcloud iam service-accounts create cd-agent \
  --display-name="CDAgent Canary Deployer"

export SA="cd-agent@${PROJECT_ID}.iam.gserviceaccount.com"

# Grant necessary roles
for ROLE in \
  roles/run.developer \
  roles/iam.serviceAccountUser \
  roles/artifactregistry.reader \
  roles/artifactregistry.writer \
  roles/monitoring.viewer \
  roles/datastore.user \
  roles/aiplatform.user \
  roles/run.admin \
  roles/pubsub.publisher; do
  gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${SA}" --role="$ROLE" \
    --condition=None
done

D. Conceder acesso do CDAgent a secrets

Vamos reutilizar o token do GitHub e o webhook do Slack de antes e conceder à conta de serviço de computação do Cloud Run acesso à chave de API do Gemini para que o app implantado possa usá-la:

gcloud secrets add-iam-policy-binding github-token \
  --member="serviceAccount:${SA}" \
  --role="roles/secretmanager.secretAccessor"

gcloud secrets add-iam-policy-binding slack-webhook-cd \
  --member="serviceAccount:${SA}" \
  --role="roles/secretmanager.secretAccessor"

# Grant the compute service account access to Gemini API key
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud secrets add-iam-policy-binding gemini-api-key \
  --project=$PROJECT_ID \
  --member="serviceAccount:${PROJECT_NUMBER}[e-mail]" \
  --role="roles/secretmanager.secretAccessor"

E. Criar e implantar o CDAgent no Cloud Run

export GITHUB_OWNER="YOUR_GITHUB_USERNAME"

export CD_AGENT_URL=cd-agent-${PROJECT_NUMBER}.${CLOUD_RUN_REGION}.run.app

export SLACK_TOKEN=YOUR_SLACK_WEBHOOK
echo -n "https://hooks.slack.com/services/$SLACK_TOKEN" | \
  gcloud secrets create slack-webhook-cd --data-file=-

AGENT_IMAGE="$CLOUD_RUN_REGION-docker.pkg.dev/${PROJECT_ID}/dinoquest/cd-agent:latest"
gcloud builds submit --tag $AGENT_IMAGE .


export SA="cd-agent@${PROJECT_ID}.iam.gserviceaccount.com"


gcloud run deploy cd-agent \
  --image=$AGENT_IMAGE \
  --region=$CLOUD_RUN_REGION \
  --service-account=$SA \
  --memory=1Gi \
  --set-env-vars="GOOGLE_CLOUD_PROJECT=${PROJECT_ID}" \
  --set-env-vars="GOOGLE_GENAI_USE_VERTEXAI=True" \
  --set-env-vars="HOST=${CD_AGENT_URL},PROTOCOL=https" \
  --set-env-vars="CD_TARGET_SERVICE=dinoquest" \
  --set-env-vars="HARNESS_EVENTS_TOPIC=${HARNESS_EVENTS_TOPIC}" \
  --set-env-vars="GITHUB_OWNER=${GITHUB_OWNER}" \
  --set-env-vars="GITHUB_REPO=dinoquest" \
  --set-env-vars="DEMO_MODE=true" \
  --set-env-vars="LEADERBOARD_ENABLED=true" \
  --set-secrets="SLACK_WEBHOOK_URL=slack-webhook-cd:latest" \
  --set-secrets="GITHUB_TOKEN=github-token:latest" \
  --allow-unauthenticated \
  --min-instances=1 \
  --no-cpu-throttling \
  --timeout=300

Observação : o --min-instances=1 --no-cpu-throttling mantém a instância ativa para que ela possa responder rapidamente aos comandos do Slack e do A2A.

O agente de CD é o guardião final do seu ambiente de produção. Ele avalia o risco de cada implantação, executa um canário calibrado por risco e monitora métricas em tempo real. Se forem detectadas anomalias, uma reversão automática será iniciada.

10. Aumentando a escala: desbloqueando o nível 2 com o Agent Swarm

A. Testar o Full Swarm

1. Acione o erro: abra o URL implantado do DinoQuest (da última etapa) no navegador.
2. Acessar o ranking: clique no botão Ranking. A implementação atual do ranking é propositalmente ineficiente. Ela tenta carregar uma quantidade enorme de dados na memória, o que causa um erro de falta de memória (OOM, na sigla em inglês).
3. Aguarde o agente: em cerca de 60 segundos, o remediation-agent vai receber o evento de erro pelo Eventarc e iniciar o diagnóstico.
4. Verifique o Slack: você vai encontrar uma notificação no seu canal do Slack parecida com esta:Resumo da correção do DinoAgent
   • Serviço: dinoquest
   • Revisão com falha: dinoquest-xxxx-xxxx
   • Evidência: "O limite de memória de 128 MiB foi excedido com 13x MiB usados".
   • Por que essa revisão foi ruim: o endpoint /api/leaderboard foi xxxxx de maneira ineficiente, causando um erro de falta de memória.
   • Ação realizada: aumentamos a memória de xMi para yGi no serviço dinoquest. Uma nova revisão foi criada.
   • PR da causa raiz: https://github.com/YOUR_USERNAME/DinoQuest/pull/x
5. Verifique as correções:
   • GitHub: verifique se há um novo branch e uma solicitação de pull no seu repositório. O agente corrigiu o código do aplicativo para resolver o vazamento de memória.
   • Cloud Run: no Console do GCP, você vai encontrar uma nova revisão do serviço dinoquest com a alocação de memória atualizada.
   • Ranking: tente acessar o ranking de novo. Ele deve carregar corretamente agora graças ao aumento da memória e à correção do código.

B. Evolução: implementação da lógica de jogo de nível 2

Você vai adicionar um novo recurso importante: Nível 2 (Destruidor de asteroides). Isso permite que os dinossauros com pontuação alta avancem para um novo modo de jogo.

1. Volte ao repositório dinoquest:

   cd ~/dinoquest
   

2. Criar e mudar para uma nova ramificação:

   git checkout -b level_2
   

3. Aplique o patch do nível 2: execute o script fornecido para corrigir sua base de código local com recursos, componentes e lógica de jogo do nível 2:

   bash level_2_backup/levelup.sh
   

4. Confirme e envie as mudanças:

   git add .
   git commit -m "feat: add Level 2"
   git push origin level_2
   

Em vez de usar curl para acionar o agente manualmente, vamos usar o comando de barra do Slack que você configurou antes. É assim que você interage com seu pipeline de CI autônomo em um cenário real.

1. Abra o Slack e navegue até qualquer canal em que o app CIAgent esteja instalado.
2. Acione o build de CI digitando o seguinte comando:

   /runci run ci on branch level_2
   

3. Monitore o progresso:
   • Slack: o agente vai reconhecer seu comando e postar atualizações conforme o build avança.
   • Dino Theater: assista às "bolhas de pensamento" enquanto o agente classifica a mudança, envia o job do Cloud Build e se comunica com o agente de CD.
   • GitHub: verifique sua solicitação de pull level_2. O agente vai postar status de commit e um comentário completo do relatório de CI.
4. Assista o processo:
   • Marque Dino Theater para ver o agente de CI pensando, classificando a mudança e executando o pipeline.
   • Confira sua solicitação de pull do GitHub para ver o agente de CI postar o status do commit e o relatório final.

11. Conclusão

Você criou uma pilha completa de DevOps com agentes no Google Cloud:

Componente	O que faz?
DinoQuest (Cloud Run dinoquest)	Jogo com tecnologia do Gemini: front-end React + back-end FastAPI
Firebase Auth + Firestore	Autenticação de usuário e armazenamento de perfil de dinossauro
Agente de correção (Cloud Run + Eventarc)	Agente de SRE que corrige automaticamente erros de falta de memória e bugs de código.
log-router-bq-report	Agente de dados que transmite registros para o BigQuery e gera insights
CIAgent (Cloud Run)	Agente de CI que escopo testes, cria imagens e chama CD via A2A
CDAgent (Cloud Run)	Agente de CD que executa implantações canário com pontuação de risco e reversão automática.

Todo o comportamento do agente fica no diretório skills/ como playbooks do Markdown. Para mudar o comportamento, edite a habilidade, não o código. As habilidades são executadas no Antigravity com o Gemini e são invocadas quando você diz ao agente qual habilidade executar.