Flujos de trabajo centrados en el agente: de la instrucción a la producción

1. Descripción general

Te damos la bienvenida al "Día dos". Si bien compilar una app y presionar "Publicar" es mágico, el tráfico del mundo real genera fallas del mundo real. En lugar de pasar tus días luchando con YAML o buscando en los registros, puedes crear un enjambre de agentes especializados para que administren la infraestructura operativa por ti. En este codelab, se muestra cómo la pila unificada de Google Cloud (Eventarc, Cloud Run, Firestore, Cloud Build y BigQuery) facilita que los agentes recuperen secretos, transmitan registros y solucionen problemas de forma segura de inmediato.

En este codelab, compilarás DinoQuest, un juego de aventuras de dinosaurios potenciado por Gemini, desde cero y lo conectarás a una canalización de CI/CD completamente basada en agentes. Al final, tendrás lo siguiente:

• Una app web de DinoQuest en funcionamiento que se ejecuta en Cloud Run (nombre del servicio: dinoquest)
• Una canalización de análisis de registros que transmite registros de Cloud Run a BigQuery y genera un panel interactivo de estadísticas del juego
• Agente de corrección (remediation-agent): Es un agente de corrección del ADK que supervisa los errores de Cloud Run y los corrige automáticamente. Se implementa como su propio servicio de Cloud Run activado por Eventarc.
• Un agente de CI (ci-agent) que lee la diferencia de tu PR, define el alcance de las pruebas de forma inteligente, compila una imagen de Docker a través de Cloud Build y publica un estado de confirmación en GitHub
• Un agente de CD que califica el riesgo de implementación, divide el tráfico, supervisa las métricas y promueve o revierte automáticamente

Qué aprenderás

• Cómo implementar una app de pila completa de Vite y FastAPI en Cloud Run como un solo contenedor
• Cómo configurar Firebase Auth y Firestore para una app de React
• Cómo compilar e implementar un agente de ADK que reacciona a eventos de Pub/Sub a través de Eventarc
• Cómo enrutar registros de Cloud Run a BigQuery y consultar estadísticas del juego
• Cómo escribir habilidades de agente para la CI y la implementación de versiones canary

Requisitos

• Un proyecto de Google Cloud con la facturación habilitada.
• Un proyecto de Firebase (puede ser el mismo proyecto de GCP)
• Una cuenta de GitHub y una bifurcación del repo de DinoQuest
• Acceso a Antigravity con Gemini (el ejecutor de agentes de Google)
• CLI de gcloud instalada y autenticada (consulta las instrucciones de instalación a continuación)
• node ≥ 18 y npm
• python3 ≥ 3.11
• git y gh (CLI de GitHub)

Instala gcloud CLI

macOS

brew install --cask google-cloud-sdk

También puedes descargar el instalador desde cloud.google.com/sdk/docs/install.

Windows

winget install Google.CloudSDK

También puedes descargar el instalador de Windows (.exe) desde cloud.google.com/sdk/docs/install y ejecutarlo.

Después de la instalación, inicializa y autentica:

gcloud init
gcloud auth login
gcloud auth application-default login

2. Configura Firebase

Todos los agentes necesitan datos para razonar. DinoQuest usa Firestore y Firebase Auth para proporcionar una capa de datos lista para producción que nuestros agentes descubrirán, explorarán y actualizarán más adelante con lenguaje natural.

Dado que esta app se generó a través de AI Studio, está muy integrada con Firebase. Usar Firebase ofrece varias ventajas, entre las que se destacan una arquitectura previamente protegida y un acceso a los datos administrado de inmediato, lo que garantiza que el estado de tu juego esté protegido desde el primer día.

A. Crea un proyecto de Firebase

1. Ve a console.firebase.google.com.
2. Haz clic en Agregar proyecto (está oculto en la opción para crear un proyecto nuevo) → selecciona tu proyecto de GCP existente (o crea uno nuevo).
3. Inhabilita Google Analytics si se te solicita → Crear proyecto (o puedes usar la configuración predeterminada).

B. Habilitar la autenticación de Google

1. En Firebase console, ve a Seguridad → Autenticación (Comenzar) → Método de acceso.
2. Haz clic en Google → activa Habilitar → guarda tu correo electrónico de asistencia → Guardar.

C. Agrega localhost como un dominio autorizado

1. En Authentication, haz clic en la pestaña Settings.
2. En Dominios autorizados, confirma que localhost aparezca en la lista (debería aparecer de forma predeterminada).

D. Crea una base de datos de Firestore

1. Ve a Database & Storage → Firestore Database → Create database.
2. Elige Edición Standard → Siguiente.
3. Selecciona la región us-central1 (o haz que coincida con tu región de Cloud Run).
4. Elige Iniciar en modo de producción → Crear.

Una vez creada, anota tu ID de base de datos, que se verá como (default), a menos que le hayas asignado un nombre.

E. Configura las reglas de seguridad de Firebase

En Firestore Database → Rules, reemplaza las reglas predeterminadas por las siguientes:

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;
    }
  }
}

Haz clic en Publicar.

F. Agrega una app web y obtén la configuración

1. Ve a Configuración del proyecto (ícono de ajustes) → pestaña General.
2. Desplázate hasta Tus apps → haz clic en Agregar app → elige el ícono de Web ().
3. Asigna el nombre dinoquest → Registrar app
4. Copia el objeto firebaseConfig que se muestra. Lo necesitarás en un momento.

3. Cómo ejecutar el juego

Rol del agente: El entorno. Antes de poner a trabajar a nuestros agentes, necesitamos un mundo para que lo administren. En este paso, implementaremos la versión "Día uno" de DinoQuest. Esto crea el servicio en vivo, los registros y el estado que nuestro enjambre descubrirá y administrará más adelante.

Elige una de las dos opciones siguientes. Cualquiera de las dos produce un GEMINI_API_KEY que usas de forma idéntica en cada paso posterior, sin necesidad de realizar otros cambios.

A. Configura la clave de API de Gemini

Opción A: Clave de la API de Gemini de Vertex AI (recomendada si tienes un proyecto de GCP)

Vertex AI te permite crear una clave de la API de Gemini vinculada directamente a tu proyecto de GCP y facturada a este, con la cuenta de servicio predeterminada del proyecto. No se necesita una cuenta separada de AI Studio.

1. Exporta tu ID del proyecto de GCP:

   export PROJECT_ID=<YOUR_PROJECT_ID>
   

2. Habilita las APIs requeridas y otorga los permisos necesarios a la cuenta de servicio predeterminada de 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. Abre la página de claves de la API de Vertex AI en la consola de Cloud.
4. Haz clic en Crear credenciales → selecciona Clave de API.
5. En el diálogo de creación, haz lo siguiente:
   • Asigna el nombre Dino_Key a la llave.
   • Marca la casilla Autenticar las llamadas a la API a través de una cuenta de servicio.
   • En Cuenta de servicio, selecciona la cuenta de servicio de procesamiento predeterminada ([e-mail]).
   • En Select API restrictions, vuelve a marcar GEMINI API.
   • Haz clic en Create.
6. Copia la clave generada.

Opción B: AI Studio (la más rápida para el desarrollo local)

1. Abre aistudio.google.com
2. Haz clic en Obtener clave de API en la barra lateral izquierda.
3. Haz clic en Crear clave de API → elige tu proyecto de GCP → copia la clave.

Cualquiera de las claves se establece como GEMINI_API_KEY en los pasos que siguen. El backend las trata de forma idéntica.

Clona el repositorio

El repositorio del curso se encuentra en https://github.com/gca-americas/dinoquest. Primero, bifúrcalo en tu propia cuenta de GitHub. En su lugar, haremos que el agente trabaje en tu repositorio.

Después de bifurcar el repositorio, clona la rama main del repositorio bifurcado de DinoQuest y, luego, ingresa al directorio del proyecto:

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

B. Configura las variables de entorno

En cada terminal de Bash nueva que abras durante este codelab, asegúrate de configurar estas variables de entorno esenciales. Reemplaza los valores de marcador de posición por los detalles reales de tu proyecto:

Primero, exporta la URL de tu repositorio de GitHub:

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

Luego, exporta las variables de entorno 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

Confirma que la estructura se vea bien:

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. Crea el archivo de entorno de backend

Primero, exporta tu clave de API de Gemini:

export GEMINI_API_KEY=YOUR_GEMINI_API_KEY_FROM_STEP_2

Luego, crea el archivo .env:

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

C. Habilita la Verificación de aplicaciones de Firebase o la cuenta de servicio (para Cloud Run)

Cuando se ejecuta en Cloud Run, el backend usa las credenciales predeterminadas de la aplicación para comunicarse con Firebase. No se necesita ningún archivo de clave de cuenta de servicio. La llamada firebase_admin.initialize_app() en backend/main.py lo detecta automáticamente.

Para el desarrollo local, autentícate una vez:

gcloud auth application-default login

D. Crea el archivo de configuración de la app de Firebase

En el directorio frontend/, crea firebase-applet-config.json con tu configuración del paso 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)"
}

Nota: firestoreDatabaseId debe coincidir con el ID de la base de datos que creaste en el paso anterior. Si usaste el valor predeterminado, déjalo como "(default)".

Confirma los cambios en tu repositorio:

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

C. Ejecuta DinoQuest de forma local

1. Habilita las API obligatorias

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. Comenzar DinoQuest

La secuencia de comandos start.sh compila el frontend de React y entrega la terminal al backend de FastAPI, que entrega los archivos 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

Abre http://localhost:8000 en tu navegador. Deberías ver la pantalla de título de DinoQuest. Accede con Google, genera tu primer dinosaurio y confirma que se guarde en Firestore.

Solución de problemas: Si ves una página en blanco o errores de autenticación de Firebase, verifica que frontend/firebase-applet-config.json tenga los valores correctos y que localhost esté en la lista de dominios autorizados.

E. Implementa DinoQuest en Cloud Run

1. Configura tu proyecto

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

3. Crea un repositorio de Artifact Registry

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

4. Almacena la clave de la API de Gemini en 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. Crea la imagen de contenedor con Cloud Build

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

Esto ejecuta el Dockerfile de varias etapas: primero compila la app de React y, luego, empaqueta el resultado en la imagen de FastAPI. Tarda entre 3 y 5 minutos.

6. Implementa en Cloud Run

Primero, exporta tu correo electrónico de administrador:

export ADMIN_EMAIL=<YOUR_TEST_ACCOUNT_EMAIL>

Luego, implementa el servicio:

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"

Cuando se complete el comando, Cloud Run imprimirá una URL del servicio. Copia esta URL, ya que la necesitarás para autorizar el dominio en Firebase.

7. Autoriza el dominio de Cloud Run en Firebase

Para permitir que los usuarios accedan desde tu app implementada, debes agregar la URL de Cloud Run a los dominios autorizados de Firebase:

1. Regresa a Firebase console → Authentication → Settings → Authorized domains.
2. Haz clic en Agregar dominio.
3. Pega la URL de tu servicio de Cloud Run (p. ej., dinoquest-xxxxx.us-central1.run.app) y quita el prefijo https://.
4. Haga clic en Guardar.

8. Propaga los datos de la tabla de clasificación

Para darle a tu juego algo de "vida" inicial y asegurarte de que tus agentes tengan datos, puedes completar la tabla de clasificación con algunas puntuaciones iniciales.

1. Asegúrate de estar en el directorio raíz dinoquest:

   cd ~/dinoquest
   

2. Crea y activa un entorno virtual:

   python3 -m venv venv
   source venv/bin/activate
   

3. Instala la dependencia de Firestore requerida:

   pip install google-cloud-firestore
   

4. Ejecuta la secuencia de comandos de inicialización:

   python3 prep/seed_scores.py
   

5. Desactiva el entorno virtual:

   deactivate
   

Ahora puedes abrir la URL del servicio en tu navegador. DinoQuest está completamente en funcionamiento.

4. Cómo configurar el Dino Theater

Rol del agente: Visualizador. ¿Cómo supervisas un equipo de agentes autónomos? Dino Theater proporciona una ventana en tiempo real a la mente de tu enjambre de agentes. En lugar de mirar los registros de la terminal, puedes ver cómo tus agentes razonan, se llaman entre sí y ejecutan tareas en la nube en un panel visual en vivo.

A. Implementa Dino Theater en Cloud Run

Primero, regresa a tu directorio principal y clona el código de Dino Theater:

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

1. Compila y envía el contenedor:

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

2. Configura la cuenta de servicio y los permisos:

   # 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. Implementa la aplicación:

   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
   

   Nota: Se recomienda --min-instances=1 para mantener activa la conexión SSE entre eventos.
4. Verifica que funcione: Abre la URL del servicio implementado en tu navegador (p.ej., https://dino-theater-xxx-uc.a.run.app/demo).

5. DevOps con agentes en el IDE

Rol del agente: Antigravedad nativa. Para cerrar la brecha entre tu IDE y la nube, conectamos Antigravity a los servidores MCP administrados de Google Cloud. Esto le da a tu agente nativo "ojos" en tu proyecto, lo que le permite analizar registros, verificar métricas y razonar sobre la infraestructura sin que tengas que hacer malabares con las claves de API ni cambiar de contexto a la consola.

Antes de ejecutar cualquier habilidad, debes configurar el acceso de Antigravity a Google Cloud y cargar los manuales de habilidades de DinoQuest.

A. Instala el servicio de MCP administrado por Google

El servicio de MCP administrado de Google proporciona acceso a todas las APIs de Google Cloud a través de un solo extremo alojado.

Autentica con las credenciales predeterminadas de la aplicación:

gcloud auth application-default login

B. Configura mcp_config.json

Crea o actualiza mcp_config.json en tu directorio de configuración de Antigravity (por lo general, ~/.gemini/antigravity/mcp_config.json) o desde la consola. Esto le da a Antigravity acceso a las herramientas de Google Cloud y GitHub que necesitan las habilidades:

{
  "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. Carga habilidades en Antigravity (opcional)

Antigravity descubre habilidades en directorios estándares específicos. Copia las habilidades de DinoQuest desde el repositorio clonado a la carpeta global de habilidades de 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. Reinicia Antigravity(opcional)

Para aplicar los cambios de mcp_config.json y cargar las habilidades recién copiadas, reinicia la aplicación Antigravity.

Una vez que se reinicie, haz lo siguiente:

1. Verifica que los servidores de MCP de google y github muestren el estado "Conectado" en verde en Configuración.
2. Verifica que las habilidades de DinoQuest aparezcan en tu lista de habilidades.

Nota: Cada habilidad tiene una tabla ## Configuration en la parte superior de su SKILL.md. Después de copiar, debes actualizar los valores en ~/.gemini/antigravity/skills//SKILL.md para que coincidan con tu proyecto.

E. Cómo corregir un servicio en la nube en un IDE local

1. Activa el error: Abre la URL de DinoQuest implementada (del último paso) en tu navegador.
2. Ir al ranking: Haz clic en el botón Ranking. La implementación actual del ranking es intencionalmente ineficiente: intentará cargar una gran cantidad de datos en la memoria, lo que activará un error de memoria insuficiente (OOM).
3. En Antigravity Agent Manager (Agent HUB), pídele que te ayude a recuperar el error y, posiblemente, a corregir la causa raíz.

• Instrucción 1: Descubre qué sucede con DinoQuest.
• Instrucción 2: ¿Puedes revisar el código del juego Dinoquest y corregir lo que causó el error de memoria insuficiente?

6. Transmite registros a BigQuery y genera estadísticas

Rol del agente: Agente de datos. Transformar los registros sin procesar en una estrategia de producto práctica no debería llevar horas de canalización manual de datos. Con el kit de Data Agent y el MCP de BigQuery, creamos una canalización "sin ETL" que transmite registros directamente a BigQuery, lo que permite que el agente genere un panel de análisis premium en menos de dos minutos.

La habilidad log-router-bq-report configura un receptor de Cloud Logging que transmite de forma continua los registros de Cloud Run de DinoQuest a BigQuery y, luego, consulta los datos para generar informes de tráfico y estadísticas de análisis del juego.

A. Configura las variables de habilidad

Abre skills/log-router-bq-report/SKILL.md en tu repo de DinoQuest y actualiza la sección Configuration en la parte superior:

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

B. Ejecuta la habilidad en Antigravity

Abre Antigravity con el repo DinoQuest como contexto y dile a Gemini lo siguiente:

Run the log-router-bq-report skill

La skill hará lo siguiente:

1. Resuelve tu proyecto de GCP automáticamente
2. Verifica si el receptor de BigQuery ya existe. Si no es así, se crearán el conjunto de datos y el receptor.
3. Grant IAM permissions: Se le otorgará al writerIdentity del receptor el rol de editor de datos de BigQuery en el conjunto de datos.

Nota: Al igual que con el receptor de Eventarc, es posible que veas una advertencia de gcloud durante este proceso: "Recuerda otorgar el rol de Editor de datos de BigQuery a serviceAccount:service-... en el conjunto de datos". La skill controla esto automáticamente.

C. Cómo se usa Antigravity para generar el informe

Solo tienes que pedirle a Antigravity que "configure el receptor de registros de BigQuery y genere el informe de estadísticas". El agente hará lo siguiente:

1. Configurar la infraestructura: Crea el conjunto de datos de BigQuery y el receptor de Cloud Logging.
2. Administrar permisos: Otorga automáticamente los roles de IAM necesarios a la identidad de escritura del receptor.
3. Generar estadísticas: Analiza los registros y genera un panel interactivo premium en HTML con telemetría del juego y análisis de la tasa de victorias.

7. Agente de corrección de autorreparación

Rol del agente: Agente de SRE. Cuando un servicio de producción falla a las 2 a.m., no deberías tener que despertarte. Este agente actúa como tu primer respondedor. Activado por los registros de errores de Cloud Run a través de Eventarc, analiza automáticamente la falla, propone una solución y activa una canalización de corrección, todo antes de que te hayas conectado a la consola.

DinoAgent es un agente de ADK que escucha los registros de errores de Cloud Run a través de Eventarc, diagnostica la causa raíz y corrige automáticamente el problema, ya sea aumentando la memoria, revirtiendo el tráfico o presentando una PR de corrección de código en GitHub.

A. Clona el repositorio del agente de corrección

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

Estructura del proyecto:

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. Configura el acceso a GitHub (pista de corrección de código)

El segmento de corrección de código clona tu repo de DinoQuest, lee los archivos fuente, aplica parches y abre PRs. Necesita un token de acceso personal de GitHub con el permiso repo.

1. Ve a github.com/settings/tokens → Generate new token (classic).
2. Asigna un nombre, selecciona el alcance repo → Generar token → cópialo

Almacénalo en Secret Manager:

Primero, exporta tu token de GitHub:

export GH_TOKEN=ghp_YOUR_TOKEN_HERE

Luego, crea el secreto:

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

C. Configura las notificaciones de Slack (opcional)

Cuando se completa una corrección, DinoAgent publica un resumen en un canal de Slack.

1. Ve a api.slack.com/apps → Create New App → From scratch
2. Asigna el nombre DinoAgent, selecciona tu espacio de trabajo → Crear app
3. En Características → Webhooks entrantes → activa el botón de activación
4. Haz clic en Agregar nuevo webhook al espacio de trabajo → elige un canal → Permitir.
5. Copia la URL del webhook (https://hooks.slack.com/services/...).

Almacénalo en 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. Crea la cuenta de servicio de 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

Otorga acceso a los secretos:

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

E. Compila e implementa DinoAgent en 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. Conecta el activador de Eventarc

Crea un tema de Pub/Sub para recibir los registros de errores de Cloud Run:

gcloud pubsub topics create cloud-run-errors

Crea un receptor de Cloud Logging que filtre los registros de errores de tu servicio de dinoquest y los enrute al tema:

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"

Nota: Cuando ejecutes el comando anterior, gcloud imprimirá un mensaje de Info que dice: "Recuerda otorgar a serviceAccount:service-... el rol de publicador de Pub/Sub en el tema". El siguiente paso se encarga de eso.

Otorga permiso de publicación a la identidad del escritor del receptor (la cuenta de servicio que se menciona en la advertencia):

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"

Verifica que esté activa:

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

Otorga permiso a Eventarc para invocar el agente de corrección:

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

Crea el activador de 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}

La corrección ahora está completamente automatizada. Además de escalar la infraestructura, DinoAgent realiza un análisis profundo de la causa raíz en el código de la aplicación, aplica un parche semántico y usa la comunicación Agent-to-Agent (A2A) para entregar la corrección al agente de CI para su verificación y su implementación. Puedes explorar los detalles de la implementación en la base de código de reme-agent.

8. Configura el agente de CI

Agent Role: CI pipeline. Deja de luchar con archivos YAML complejos y secuencias de comandos de compilación manuales. Este agente administra la infraestructura operativa de tus solicitudes de extracción. Lee los cambios de código, comprende el contexto, define el alcance de las pruebas necesarias y compila tus imágenes de Docker a través de Cloud Build, lo que garantiza que cada confirmación esté "aprobada por el agente" antes de llegar a la rama principal.

ci-agent es un agente autónomo de canalización de CI implementado como un servicio de Cloud Run. Envía compilaciones de Docker a Cloud Build, sondea para verificar la finalización, verifica la imagen en Artifact Registry y genera informes en GitHub.

¿Por qué usar un agente para tu canalización de CI? A diferencia de las secuencias de comandos estáticas tradicionales, una canalización de CI agente proporciona lo siguiente:

1. Clasificación del alcance cognitivo: Determina de forma inteligente la profundidad de prueba requerida (cambiando entre verificaciones de tipos, pruebas de unidades o conjuntos de pruebas de integración completos) según el impacto semántico de los cambios en el código.
2. Administración autónoma de RR.PP.: El agente puede crear automáticamente RR.PP., publicar resúmenes detallados de los cambios y hasta administrar el análisis de secretos y las auditorías de seguridad sin intervención humana.
3. Diagnóstico de fallas en tiempo real: Cuando falla una compilación, el agente no solo muestra los registros, sino que analiza el seguimiento de pila, identifica la causa probable y publica un diagnóstico legible directamente en la PR.

A. Clona el repositorio de CIAgent

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

B. Crea la cuenta de servicio de 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. Conecta el repositorio de GitHub a Cloud Build

CIAgent envía compilaciones a través de repoSource, lo que requiere que el repo de GitHub esté conectado a Cloud Build Developer Connect.

1. Ve a GCP Console → Cloud Build → Repositorios.
2. Haz clic en Conectar repositorio.
3. Selecciona GitHub (app de GitHub de Cloud Build).
4. Autoriza y selecciona tu repositorio de YOUR_GITHUB_USERNAME/dinoquest
5. Haz clic en Conectar y Omitir cuando se te solicite crear un activador.
6. Toma nota del nombre de tu conexión (por lo general, el valor predeterminado es tu nombre de usuario de GitHub o uno similar).

D. Otorga acceso de CIAgent a los secretos

Volveremos a usar los secretos creados anteriormente para 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. Compila e implementa CIAgent en 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. Configuración del comando de barra de Slack

1. Ve a api.slack.com/apps → Create New App → From scratch.
2. Asigna el nombre CIAgent, elige tu espacio de trabajo → Crear app
3. En Funciones → Comandos de barra → Crear comando nuevo
4. Comando: /runci
5. URL de la solicitud: Tu URL de Cloud Run de CIAgent anterior con /slack anexado (p.ej., https://ci-agent-xxx-.us-central1.run.app/slack)
6. Descripción breve: Trigger CI
7. Guardar
8. En Configuración → Instalar la app, haz clic en Instalar en Workspace y Permitir.

El agente de CI actúa como un "cerebro" que se encuentra sobre servicios sólidos de Google Cloud, como Cloud Build y Artifact Registry. Una vez que se verifica la compilación, se activa la fase final de implementación llamando al agente de CD a través de A2A, lo que garantiza una transferencia fluida entre los ciclos de compilación y lanzamiento.

9. Configura la implementación

Rol del agente: Agente de CD. La implementación no debería ser un acto de fe. Este agente administra el riesgo por ti. Califica la seguridad de la implementación, administra las divisiones del tráfico de la versión canary y supervisa las métricas en tiempo real para decidir si se debe promover o revertir una versión. Es el último filtro de tu enjambre de agentes autónomos.

El cd-agent es un agente de implementación de versión canary autónomo implementado como un servicio de Cloud Run. Recibe solicitudes de implementación de A2A desde ci-agent, calcula una puntuación de riesgo, establece un porcentaje de versión canary calibrado según el riesgo, supervisa las métricas y promueve o revierte la implementación automáticamente. También aprende de las implementaciones anteriores con Firestore.

La conexión directa de los agentes crea un "canal cognitivo" en el que cada transferencia es una transferencia enriquecida de intención y contexto. A diferencia de los webhooks tradicionales, la comunicación A2A permite lo siguiente:

1. Intelligent Context Sharing: Los agentes pasan recuerdos de sesiones completas, diferencias de solicitudes de extracción y puntuaciones de riesgo, lo que garantiza que el siguiente agente tenga el "por qué" completo antes de comenzar a trabajar.
2. Cognitive Handshakes: Los agentes pueden negociar puertas. Por ejemplo, el agente de CD puede solicitar pruebas de humo específicas al agente de CI durante el lanzamiento de una versión canary para verificar una corrección en tiempo real.
3. Corrección colaborativa: Si falla una implementación, el agente de CD puede notificar de forma proactiva al agente de corrección con métricas de falla, lo que inicia un análisis autónomo de la causa raíz antes de que se llame a un humano.
4. Negociación de recursos: Los agentes pueden negociar las necesidades de infraestructura. Por ejemplo, el agente de CI puede pedirle al agente de corrección que aprovisione más capacidad de compilación si detecta una refactorización a gran escala, o bien el agente de CD puede sugerir que se escale el clúster de producción antes de un lanzamiento importante.
5. Consenso multiagente: Para los cambios de alto riesgo, varios agentes (p.ej., el agente de seguridad y el agente de CD) pueden realizar una "aprobación conjunta" a través de A2A, lo que garantiza que el código no solo se compile y se implemente, sino que también cumpla con las políticas de seguridad antes de llegar a producción.

A. Clona el repositorio de CDAgent

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

B. Crea la base de datos de Firestore

CDAgent almacena sus patrones de memoria de implementación en Firestore:

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

(Si ya creaste una base de datos en este proyecto, puedes omitir este paso).

C. Crea la cuenta de servicio de 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. Otorga acceso de CDAgent a los secretos

Reutilizaremos el token de GitHub y el webhook de Slack que usamos antes, y otorgaremos acceso a la clave de la API de Gemini a la cuenta de servicio de procesamiento de Cloud Run para que la app implementada pueda usarla:

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. Compila e implementa CDAgent en 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

Nota: --min-instances=1 --no-cpu-throttling mantiene la instancia activa para que pueda responder rápidamente a los comandos de Slack y de A2A.

El agente de CD es el guardián final de tu entorno de producción. Evalúa el riesgo de cada implementación, ejecuta una versión canary calibrada según el riesgo y supervisa las métricas en tiempo real. Si se detectan anomalías, se inicia una reversión automática.

10. Aumento de escala: Cómo desbloquear el nivel 2 con el Agent Swarm

A. Prueba Full Swarm

1. Activa el error: Abre la URL de DinoQuest implementada (del último paso) en tu navegador.
2. Ir a la tabla de clasificación: Haz clic en el botón Tabla de clasificación. La implementación actual del ranking es intencionalmente ineficiente: intentará cargar una gran cantidad de datos en la memoria, lo que activará un error de memoria insuficiente (OOM).
3. Wait for the Agent: En un plazo de 60 segundos, aproximadamente, el remediation-agent recibirá el evento de error a través de Eventarc y comenzará su diagnóstico.
4. Verifica Slack: Deberías ver una notificación en tu canal de Slack similar a esta:Resumen de corrección de DinoAgent
   • Servicio: dinoquest
   • Revisión con errores: dinoquest-xxxx-xxxx
   • Evidencia: "Se superó el límite de memoria de 128 MiB con 13 MiB usados".
   • Por qué esta revisión fue mala: El extremo /api/leaderboard se xxxxx de manera ineficiente, lo que provocó un error de OOM.
   • Acción tomada: Se aumentó la memoria de xMi a yGi para el servicio dinoquest. Se creó una revisión nueva.
   • PR de causa raíz: https://github.com/YOUR_USERNAME/DinoQuest/pull/x
5. Verifica las correcciones:
   • GitHub: Verifica si hay una rama nueva y una solicitud de extracción en tu repositorio. El agente corrigió el código de la aplicación para solucionar la fuga de memoria subyacente.
   • Cloud Run: En GCP Console, verás una revisión nueva del servicio dinoquest con la asignación de memoria actualizada.
   • Tabla de clasificación: Vuelve a probar la tabla de clasificación. Ahora debería cargarse correctamente gracias al aumento de memoria y a la corrección del código.

B. Evolution: Implementing Level 2 Game Logic

Agregarás una nueva función importante: Nivel 2 (Destructor de asteroides). Esto permite que los dinosaurios con puntuación alta avancen a un nuevo modo de juego.

1. Vuelve a tu repositorio de dinoquest:

   cd ~/dinoquest
   

2. Crea una rama nueva y cambia a ella:

   git checkout -b level_2
   

3. Aplica el parche de nivel 2: Ejecuta la secuencia de comandos proporcionada para aplicar el parche a tu base de código local con los recursos, los componentes y la lógica del juego del nivel 2:

   bash level_2_backup/levelup.sh
   

4. Confirma y envía los cambios:

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

En lugar de usar curl para activar el agente de forma manual, usaremos el comando de barra de Slack que configuraste antes. Así es como interactúas con tu canalización de CI autónoma en una situación del mundo real.

1. Abre Slack y navega a cualquier canal en el que esté instalada la app de CIAgent.
2. Activa la compilación de CI escribiendo el siguiente comando:

   /runci run ci on branch level_2
   

3. Supervisa el progreso:
   • Slack: El agente reconocerá tu comando y publicará actualizaciones a medida que avance la compilación.
   • Dino Theater: Mira las "burbujas de pensamiento" mientras el agente clasifica el cambio, envía el trabajo de Cloud Build y se comunica con el agente de CD.
   • GitHub: Revisa tu PR de level_2. Verás que el agente publica estados de confirmación y un comentario completo del informe de CI.
4. Mira el proceso:
   • Consulta Dino Theater para ver cómo el agente de CI piensa, clasifica el cambio y ejecuta la canalización.
   • Revisa tu PR de GitHub para ver si el agente de CI publicó el estado de la confirmación y el informe final.

11. Conclusión

Compilaste una pila de DevOps completa basada en agentes en Google Cloud:

Componente	Qué hace
DinoQuest (Cloud Run dinoquest)	Juego potenciado por Gemini: frontend de React y backend de FastAPI
Firebase Auth + Firestore	Almacenamiento de perfiles de dinosaurios y autenticación de usuarios
Agente de corrección (Cloud Run y Eventarc)	Agente de SRE que corrige automáticamente los errores de OOM y los errores de código
log-router-bq-report	Agente de datos que transmite registros a BigQuery y genera estadísticas
CIAgent (Cloud Run)	Agente de CI que define el alcance de las pruebas, compila imágenes y llama a CD a través de A2A
CDAgent (Cloud Run)	Agente de CD que ejecuta implementaciones de versiones canary con puntuación de riesgo y reversión automática

Todo el comportamiento del agente se encuentra en el directorio skills/ como manuales de estrategias de Markdown. Para cambiar el comportamiento, edita la habilidad, no el código. Las habilidades se ejecutan en Antigravity con Gemini y se invocan indicándole al agente qué habilidad ejecutar.