Workflow incentrati sull'agente: dal prompt alla produzione

1. Panoramica

Benvenuto nel "secondo giorno". Creare un'app e fare clic su "Pubblica" è magico, ma il traffico reale porta a errori reali. Invece di passare le giornate a lottare con YAML o a cercare nei log, puoi creare uno sciame di agenti specializzati per gestire la parte operativa per te. Questo codelab mostra come lo stack unificato di Google Cloud (Eventarc, Cloud Run, Firestore, Cloud Build, BigQuery) consente agli agenti di recuperare in modo sicuro i secret, trasmettere in streaming i log e risolvere i problemi in modo semplice.

In questo codelab creerai DinoQuest, un gioco di avventura con dinosauri basato su Gemini, da zero e lo collegherai a una pipeline CI/CD completamente agentica. Al termine del corso avrai:

• Un'app web DinoQuest funzionante in esecuzione su Cloud Run (nome servizio: dinoquest)
• Una pipeline di analisi dei log che trasmette in streaming i log di Cloud Run in BigQuery e genera una dashboard interattiva con informazioni sul gioco
• Agente di correzione (remediation-agent): un agente di correzione ADK che monitora gli errori di Cloud Run e li corregge automaticamente, di cui viene eseguito il deployment come servizio Cloud Run autonomo attivato da Eventarc
• Un agente CI (ci-agent) che legge la differenza della richiesta di pull, definisce l'ambito dei test in modo intelligente, crea un'immagine Docker tramite Cloud Build e pubblica uno stato di commit su GitHub
• Un agente CD che valuta il rischio di deployment, suddivide il traffico, monitora le metriche e promuove o esegue il rollback automaticamente

Obiettivi didattici

• Come eseguire il deployment di un'app full-stack Vite + FastAPI su Cloud Run come singolo container
• Come configurare Firebase Auth e Firestore per un'app React
• Come creare ed eseguire il deployment di un agente ADK che reagisce agli eventi Pub/Sub tramite Eventarc
• Come indirizzare i log di Cloud Run a BigQuery ed eseguire query sull'analisi del gioco
• Come scrivere competenze di agent per l'integrazione continua e il deployment canary

Che cosa ti serve

• Un progetto cloud Google Cloud con la fatturazione abilitata
• Un progetto Firebase (può essere lo stesso progetto Google Cloud)
• Un account GitHub e un fork del repository DinoQuest
• Accesso ad Antigravity con Gemini (il runner di agenti di Google)
• gcloud CLI installata e autenticata. Consulta le istruzioni di installazione riportate di seguito.
• node ≥ 18 e npm
• python3 ≥ 3.11
• git e gh (interfaccia a riga di comando di GitHub)

Installa gcloud CLI

macOS

brew install --cask google-cloud-sdk

In alternativa, scarica il programma di installazione da cloud.google.com/sdk/docs/install.

Windows

winget install Google.CloudSDK

In alternativa, scarica il programma di installazione di Windows (.exe) da cloud.google.com/sdk/docs/install ed eseguilo.

Dopo l'installazione, inizializza ed esegui l'autenticazione:

gcloud init
gcloud auth login
gcloud auth application-default login

2. Configurare Firebase

Ogni agente ha bisogno di dati su cui ragionare. DinoQuest utilizza Firestore e Firebase Auth per fornire un livello di dati pronto per la produzione che i nostri agenti scopriranno, esploreranno e aggiorneranno in un secondo momento utilizzando il linguaggio naturale.

Poiché questa app è stata generata tramite AI Studio, è fortemente integrata con Firebase. L'utilizzo di Firebase offre diversi vantaggi, tra cui un'architettura pre-protetta e l'accesso ai dati gestito predefinito, che garantiscono la protezione dello stato del gioco fin dal primo giorno.

A. Crea un progetto Firebase

1. Vai alla pagina console.firebase.google.com.
2. Fai clic su Aggiungi progetto (è nascosto nell'opzione per creare un nuovo progetto) → seleziona il progetto GCP esistente (o creane uno nuovo).
3. Disattiva Google Analytics se richiesto → Crea progetto (o scegli l'impostazione predefinita).

B. Abilitazione l'autenticazione Google

1. Nella console Firebase, vai a Sicurezza → Autenticazione (Inizia) → Metodo di accesso.
2. Fai clic su Google → attiva/disattiva Attiva → salva l'email di assistenza → Salva.

C. Aggiungere localhost come dominio autorizzato

1. Sempre in Autenticazione, fai clic sulla scheda Impostazioni.
2. Nella sezione Domini autorizzati, verifica che localhost sia elencato (dovrebbe esserlo per impostazione predefinita).

D. Crea un database Firestore

1. Vai a Database e spazio di archiviazione → Database Firestore → Crea database
2. Scegli Versione Standard → Avanti
3. Seleziona la regione us-central1 (o abbina la regione Cloud Run)
4. Scegli Avvia in modalità di produzione → Crea.

Una volta creato, prendi nota dell'ID database, che avrà l'aspetto di (default), a meno che tu non gli abbia assegnato un nome.

E. Imposta le regole di sicurezza Firebase

In Firestore Database → Rules, sostituisci le regole predefinite con:

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

Fai clic su Pubblica.

F. Aggiungere un'app web e ottenere la configurazione

1. Vai a Impostazioni progetto (icona a forma di ingranaggio) → scheda Generali.
2. Scorri fino a Le tue app → fai clic su Aggiungi app → scegli l'icona Web ().
3. Assegna un nome dinoquest → Registra app
4. Copia l'oggetto firebaseConfig mostrato: ti servirà tra poco.

3. Eseguire il gioco

Ruolo dell'agente: l'ambiente. Prima di poter mettere al lavoro i nostri agenti, abbiamo bisogno di un mondo da gestire. In questo passaggio, eseguiremo il deployment della versione "Day One" di DinoQuest. In questo modo vengono creati il servizio live, i log e lo stato che lo swarm scoprirà e gestirà in un secondo momento.

Scegli una delle due opzioni seguenti. Produce un GEMINI_API_KEY che utilizzi in modo identico in ogni passaggio successivo, senza bisogno di altre modifiche.

A. Configurare la chiave API Gemini

Opzione A: chiave API Vertex AI Gemini (consigliata se hai un progetto Google Cloud)

Vertex AI ti consente di creare una chiave API Gemini collegata direttamente al tuo progetto GCP e fatturata, utilizzando il service account predefinito del progetto. Non è necessario un account AI Studio separato.

1. Esporta l'ID progetto Google Cloud:

   export PROJECT_ID=<YOUR_PROJECT_ID>
   

2. Abilita le API richieste e concedi le autorizzazioni necessarie al service account Compute Engine predefinito:

   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. Apri la pagina delle chiavi API Vertex AI nella console Cloud.
4. Fai clic su Crea credenziali → seleziona Chiave API.
5. Nella finestra di dialogo di creazione:
   • Assegna alla chiave il nome Dino_Key
   • Seleziona la casella Autentica le chiamate API tramite un service account.
   • In Service account, seleziona il service account Compute predefinito ([e-mail]).
   • Nella sezione Seleziona limitazioni dell'API, seleziona API GEMINI.
   • Fai clic su Crea
6. Copia la chiave generata.

Opzione B: AI Studio (la più rapida per lo sviluppo locale)

1. Apri aistudio.google.com.
2. Fai clic su Ottieni chiave API nella barra laterale sinistra.
3. Fai clic su Crea chiave API → scegli il tuo progetto Google Cloud → copia la chiave

Entrambi i tasti sono impostati come GEMINI_API_KEY nei passaggi successivi. Il backend li tratta in modo identico.

Clona il repository

Il repository del corso si trova in https://github.com/gca-americas/dinoquest. Crea un fork nel tuo account GitHub. L'agente lavorerà invece sul tuo repository.

Dopo aver creato un fork, clona il ramo main del repository DinoQuest di cui hai creato un fork e inserisci la directory del progetto:

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

B. Configura le variabili di ambiente

In ogni nuovo terminale bash che apri durante questo codelab, assicurati di impostare queste variabili di ambiente essenziali. Sostituisci i valori dei segnaposto con i dettagli effettivi del progetto:

Innanzitutto, esporta l'URL del repository GitHub:

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

Poi esporta le variabili di ambiente rimanenti:

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

Verifica che la struttura sia corretta:

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 il file dell'ambiente di backend

Innanzitutto, esporta la chiave API Gemini:

export GEMINI_API_KEY=YOUR_GEMINI_API_KEY_FROM_STEP_2

Poi crea il file .env:

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

C. Abilita Firebase App Check / service account (per Cloud Run)

Quando viene eseguito su Cloud Run, il backend utilizza le credenziali predefinite dell'applicazione per comunicare con Firebase, senza necessità di un file di chiave del service account. La chiamata al numero firebase_admin.initialize_app() in backend/main.py rileva automaticamente questa impostazione.

Per lo sviluppo locale, esegui l'autenticazione una sola volta:

gcloud auth application-default login

D. Crea il file di configurazione dell'app Firebase

Nella directory frontend/, crea firebase-applet-config.json con la configurazione del passaggio precedente:

{
  "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 deve corrispondere all'ID database creato nel passaggio precedente. Se hai utilizzato il valore predefinito, lascialo impostato su "(default)".

Esegui il commit delle modifiche nel repository:

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

C. Esegui DinoQuest localmente

1. Abilita le API richieste

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

Lo script start.sh crea il frontend React e passa il terminale al backend FastAPI, che pubblica i file statici compilati:

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

Apri http://localhost:8000 nel browser. Dovresti visualizzare la schermata del titolo di DinoQuest. Accedi con Google, genera il tuo primo dinosauro e verifica che venga salvato in Firestore.

Risoluzione dei problemi:se visualizzi una pagina vuota o errori di autenticazione Firebase, controlla che frontend/firebase-applet-config.json abbia i valori corretti e che localhost sia nell'elenco dei domini autorizzati.

E. Esegui il deployment di DinoQuest in Cloud Run

1. Configurare il progetto

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

3. Crea un repository Artifact Registry

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

4. Archivia la chiave API Gemini in 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 l'immagine container con Cloud Build

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

Viene eseguito il Dockerfile multifase: prima viene creata l'app React, poi l'output viene pacchettizzato nell'immagine FastAPI. Richiede circa 3-5 minuti.

6. Esegui il deployment in Cloud Run

Innanzitutto, esporta l'email dell'amministratore:

export ADMIN_EMAIL=<YOUR_TEST_ACCOUNT_EMAIL>

Quindi esegui il deployment del servizio:

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"

Al termine del comando, Cloud Run stampa un URL del servizio. Copia questo URL: ti servirà per autorizzare il dominio in Firebase.

7. Autorizza il dominio Cloud Run in Firebase

Per consentire agli utenti di accedere dalla tua app di cui è stato eseguito il deployment, devi aggiungere l'URL di Cloud Run ai domini autorizzati di Firebase:

1. Torna alla Console Firebase → Authentication → Settings (Impostazioni) → Authorized domains (Domini autorizzati)
2. Fai clic su Aggiungi dominio.
3. Incolla l'URL del servizio Cloud Run (ad es. dinoquest-xxxxx.us-central1.run.app) rimuovi il prefisso https://
4. Fai clic su Salva.

8. Inserisci i dati della classifica

Per dare un po' di "vita" iniziale al tuo gioco e assicurarti che gli agenti abbiano dati, puoi inserire alcuni punteggi iniziali nella classifica.

1. Assicurati di trovarti nella directory principale dinoquest:

   cd ~/dinoquest
   

2. Crea e attiva un ambiente virtuale:

   python3 -m venv venv
   source venv/bin/activate
   

3. Installa la dipendenza Firestore richiesta:

   pip install google-cloud-firestore
   

4. Esegui lo script di seeding:

   python3 prep/seed_scores.py
   

5. Disattiva l'ambiente virtuale:

   deactivate
   

Ora puoi aprire l'URL del servizio nel browser: DinoQuest è completamente attivo.

4. Configurare Dino Theater

Ruolo agente: Visualizzatore. Come si monitora un team di agenti autonomi? Dino Theater offre una finestra in tempo reale sulla mente del tuo sciame di agenti. Anziché fissare i log del terminale, puoi osservare gli agenti mentre ragionano, si chiamano a vicenda ed eseguono attività nel cloud in una dashboard visiva in tempo reale.

A. Esegui il deployment di Dino Theater in Cloud Run

Innanzitutto, torna alla home directory e clona il codice di Dino Theater:

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

1. Crea ed esegui il push del container:

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

2. Configura il service account e le autorizzazioni:

   # 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. Esegui il deployment dell'applicazione:

   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: --min-instances=1 è consigliato per mantenere attiva la connessione SSE tra gli eventi.
4. Verifica che funzioni:apri l'URL del servizio di cui hai eseguito il deployment nel browser (ad es. https://dino-theater-xxx-uc.a.run.app/demo).

5. DevOps agentico nell'IDE

Ruolo dell'agente: Native Antigravity. Per colmare il divario tra l'IDE e il cloud, colleghiamo Antigravity ai server MCP gestiti di Google Cloud. In questo modo, l'agente nativo ha "occhi" sul tuo progetto, il che gli consente di analizzare i log, controllare le metriche e ragionare sull'infrastruttura senza che tu debba gestire le chiavi API o passare alla console.

Prima di eseguire qualsiasi skill, devi configurare l'accesso di Antigravity a Google Cloud e caricare i playbook delle skill di DinoQuest.

A. Installare il servizio MCP gestito di Google

Il servizio Managed MCP di Google fornisce l'accesso a tutte le API Cloud di Google tramite un unico endpoint ospitato.

Autenticati utilizzando le Credenziali predefinite dell'applicazione:

gcloud auth application-default login

B. Configura mcp_config.json

Crea o aggiorna mcp_config.json nella directory di configurazione di Antigravity (di solito ~/.gemini/antigravity/mcp_config.json) o dalla console. In questo modo, Antigravity ha accesso agli strumenti Google Cloud e GitHub di cui le competenze hanno bisogno:

{
  "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. (Facoltativo) Caricare le competenze in Antigravity

Antigravity rileva le competenze in directory standard specifiche. Copia le competenze di DinoQuest dal repository clonato alla cartella globale delle competenze di 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. (Facoltativo) Riavvia Antigravity

Per applicare le modifiche a mcp_config.json e caricare le skill appena copiate, riavvia l'applicazione Antigravity.

Una volta riavviato:

1. Verifica che i server MCP google e github mostrino lo stato "Connesso" in verde nelle Impostazioni.
2. Verifica che le competenze di DinoQuest vengano visualizzate nell'elenco delle competenze.

Nota:ogni competenza ha una tabella ## Configuration nella parte superiore della SKILL.md. Dopo la copia, devi aggiornare i valori in ~/.gemini/antigravity/skills//SKILL.md in modo che corrispondano al tuo progetto.

E. Correggere il servizio cloud nell'IDE locale

1. Attiva l'errore: apri l'URL di DinoQuest di cui hai eseguito il deployment (dall'ultimo passaggio) nel browser.
2. Vai alla classifica: fai clic sul pulsante Classifica. L'attuale implementazione della classifica è intenzionalmente inefficiente: tenterà di caricare una quantità enorme di dati in memoria, attivando un errore di esaurimento della memoria (OOM).
3. In Antigravity Agent Manager (Agent HUB), chiedi di aiutarti a recuperare l'errore e possibilmente a risolvere la causa principale.

• prompt 1: Scopri cosa non va in dinoquest.
• Prompt 2: Puoi esaminare il codice del gioco Dinoquest e correggere la causa dell'errore di memoria insufficiente?

6. Trasmettere i log a BigQuery e generare analisi

Ruolo dell'agente: agente per i dati. La trasformazione dei log non elaborati in una strategia di prodotto attuabile non dovrebbe richiedere ore di gestione manuale dei dati. Utilizzando Data Agent Kit e BigQuery MCP, creiamo una pipeline "Zero ETL" che trasmette i log direttamente in BigQuery, consentendo all'agente di generare una dashboard di analisi premium in meno di due minuti.

La skill log-router-bq-report configura un sink Cloud Logging che trasmette continuamente i log di Cloud Run di DinoQuest in BigQuery, quindi esegue query sui dati per generare report sul traffico e approfondimenti sull'analisi del gioco.

A. Configurare le variabili dell'abilità

Apri skills/log-router-bq-report/SKILL.md nel repository DinoQuest e aggiorna la sezione Configuration (Configurazione) nella parte superiore:

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

B. Esegui la skill in Antigravity

Apri Antigravity con il repository DinoQuest come contesto e di' a Gemini:

Run the log-router-bq-report skill

La skill:

1. Risolvi il tuo progetto Google Cloud automaticamente
2. Controlla se il sink BigQuery esiste già. In caso contrario, verrà creato il set di dati e il sink.
3. Concedi autorizzazioni IAM: concede al writerIdentity del sink il ruolo Editor dati BigQuery nel set di dati.

Nota:proprio come il sink Eventarc, potresti visualizzare un avviso da gcloud durante questo processo: "Ricordati di concedere all'account di servizio:service-... il ruolo Editor dati BigQuery nel set di dati". La skill gestisce questa operazione automaticamente.

C. Utilizzo di Antigravity per generare il report

Basta chiedere ad Antigravity di "configurare il sink dei log BigQuery e generare il report di analisi". L'agente:

1. Configura l'infrastruttura: crea il set di dati BigQuery e il sink Cloud Logging.
2. Gestisci autorizzazioni: concede automaticamente i ruoli IAM necessari all'identità writer del sink.
3. Genera approfondimenti: analizza i log e genera una dashboard HTML interattiva premium con telemetria di gioco e analisi del tasso di vittorie.

7. Agente di correzione autoriparante

Ruolo agente: agente SRE. Se un servizio di produzione ha esito negativo alle 2 del mattino, non devi svegliarti. Questo agente funge da primo soccorritore. Attivato dai log degli errori di Cloud Run tramite Eventarc, analizza automaticamente l'arresto anomalo, propone una correzione e avvia una pipeline di correzione, il tutto prima ancora che tu abbia eseguito l'accesso alla console.

DinoAgent è un agente ADK che ascolta i log degli errori di Cloud Run tramite Eventarc, diagnostica la causa principale e risolve automaticamente il problema aumentando la memoria, eseguendo il rollback del traffico o inviando una richiesta di pull di correzione del codice su GitHub.

A. Clona il repository dell'agente di correzione

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

La struttura del progetto:

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. Configurare l'accesso a GitHub (traccia di correzione del codice)

La traccia di correzione del codice clona il repository DinoQuest, legge i file di origine, applica le patch e apre le richieste di pull. È necessario un token di accesso personale GitHub con ambito repo.

1. Vai a github.com/settings/tokens → Generate new token (classic)
2. Assegna un nome, seleziona l'ambito repo → Genera token → copialo

Archivialo in Secret Manager:

Innanzitutto, esporta il token GitHub:

export GH_TOKEN=ghp_YOUR_TOKEN_HERE

Poi crea il secret:

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

C. Configurare le notifiche Slack (facoltativo)

Al termine di una correzione, DinoAgent pubblica un riepilogo in un canale Slack.

1. Vai su api.slack.com/apps → Crea nuova app → Da zero
2. Assegna il nome DinoAgent, seleziona il tuo spazio di lavoro → Crea app
3. In Funzionalità → Webhook in entrata → attiva
4. Fai clic su Aggiungi nuovo webhook allo spazio di lavoro → scegli un canale → Consenti.
5. Copia l'URL webhook (https://hooks.slack.com/services/...).

Archivialo in 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 il service account 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

Concedi l'accesso ai secret:

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

E. Crea ed esegui il deployment di DinoAgent su 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. Collega il trigger Eventarc

Crea un argomento Pub/Sub per ricevere i log degli errori di Cloud Run:

gcloud pubsub topics create cloud-run-errors

Crea un sink Cloud Logging che filtri i log degli errori dal tuo servizio dinoquest e li indirizzi all'argomento:

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:quando esegui il comando riportato sopra, gcloud stampa un messaggio Info che recita: "Ricordati di concedere il ruolo Pub/Sub Publisher all'account di servizio:service-... nell'argomento". Il passaggio successivo si occupa proprio di questo.

Concedi all'identità writer del sink (l'account di servizio menzionato nell'avviso) l'autorizzazione di pubblicazione:

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 che sia attivo:

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

Concedi a Eventarc l'autorizzazione per richiamare l'agente di correzione:

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

Crea il trigger 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 correzione è ora completamente automatizzata. Oltre a scalare l'infrastruttura, DinoAgent esegue un'analisi approfondita della causa principale del codice dell'applicazione, applica una patch semantica e utilizza la comunicazione Agent-to-Agent (A2A) per trasferire la correzione all'agente CI per la verifica e il deployment. Puoi esplorare i dettagli dell'implementazione nel codice base di reme-agent.

8. Configura l'agente CI

Ruolo dell'agente: pipeline CI. Smetti di lottare con file YAML complessi e script di compilazione manuali. Questo agente gestisce l'infrastruttura operativa delle tue PR. Legge le modifiche al codice, comprende il contesto, definisce l'ambito dei test necessari e crea le immagini Docker tramite Cloud Build, assicurandosi che ogni commit sia "approvato dall'agente" prima di raggiungere il ramo principale.

ci-agent è un agente della pipeline CI autonomo di cui è stato eseguito il deployment come servizio Cloud Run. Invia le build Docker a Cloud Build, esegue il polling per il completamento, verifica l'immagine in Artifact Registry e genera report per GitHub.

Perché utilizzare un agente per la pipeline CI? A differenza degli script statici tradizionali, una pipeline CI agentica fornisce:

1. Classificazione dell'ambito cognitivo: determina in modo intelligente la profondità del test richiesta, passando da controlli del tipo, test delle unità o suite di integrazione complete, in base all'impatto semantico delle modifiche al codice.
2. Gestione autonoma delle richieste pull: l'agente può creare automaticamente richieste pull, pubblicare riepiloghi dettagliati delle modifiche e persino gestire la scansione dei segreti e i controlli di sicurezza senza intervento umano.
3. Diagnosi degli errori in tempo reale: quando una build non va a buon fine, l'agente non mostra solo i log, ma analizza l'analisi dello stack, identifica la causa probabile e pubblica una diagnosi leggibile direttamente nella richiesta di pull.

A. Clona il repository CIAgent

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

B. Crea il service account 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. Connetti il repository GitHub a Cloud Build

CIAgent invia le build tramite repoSource, che richiede che il repository GitHub sia connesso a Cloud Build Developer Connect.

1. Vai a console GCP → Cloud Build → Repository.
2. Fai clic su Connetti repository.
3. Seleziona GitHub (app GitHub di Cloud Build).
4. Autorizza e seleziona il repository YOUR_GITHUB_USERNAME/dinoquest
5. Fai clic su Connetti e Salta quando ti viene chiesto di creare un trigger.
6. Prendi nota del nome della connessione (il valore predefinito è in genere il tuo nome utente GitHub o un nome simile).

D. Concedere l'accesso ai secret all'agente CI

Riutilizzeremo i secret creati in precedenza per 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. Crea ed esegui il deployment di CIAgent su 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. Configurazione del comando slash di Slack

1. Vai a api.slack.com/apps → Crea nuova app → Da zero
2. Assegna il nome CIAgent, scegli il tuo spazio di lavoro → Crea app
3. In Funzionalità → Comandi slash → Crea nuovo comando
4. Comando: /runci
5. URL richiesta: l'URL Cloud Run di CIAgent riportato sopra con l'aggiunta di /slack (ad es. https://ci-agent-xxx-.us-central1.run.app/slack)
6. Descrizione breve: Trigger CI
7. Salva
8. In Impostazioni → Installa app, fai clic su Installa in Workspace e Consenti.

L'agente CI funge da "cervello" che si basa su solidi servizi Google Cloud come Cloud Build e Artifact Registry. Una volta verificata la build, viene attivata la fase di deployment finale chiamando l'agente CD tramite A2A, garantendo un trasferimento senza problemi tra i cicli di build e di rilascio.

9. Configurare il deployment

Ruolo agente: CD Agent. Il deployment non deve essere un salto nel buio. Questo agente gestisce il rischio per te. Valuta la sicurezza del deployment, gestisce le suddivisioni del traffico canary e monitora le metriche in tempo reale per decidere se promuovere una release o eseguirne il rollback. È l'ultimo gatekeeper dello sciame di agenti autonomi.

cd-agent è un agente di deployment canary autonomo di cui è stato eseguito il deployment come servizio Cloud Run. Riceve richieste di deployment A2A da ci-agent, calcola un punteggio di rischio, imposta una percentuale canary calibrata in base al rischio, monitora le metriche e promuove o esegue il rollback automaticamente. Inoltre, impara dai deployment precedenti utilizzando Firestore.

Il collegamento diretto degli agenti crea una "pipeline cognitiva" in cui ogni trasferimento è un trasferimento ricco di intent e contesto. A differenza dei webhook tradizionali, la comunicazione A2A consente di:

1. Condivisione intelligente del contesto: gli agenti trasmettono le memorie dell'intera sessione, le differenze delle PR e i punteggi di rischio, assicurando che l'agente successivo abbia il "perché" completo prima di iniziare a lavorare.
2. Cognitive Handshakes: gli agenti possono negoziare i cancelli. Ad esempio, l'agente CD può richiedere test di fumo specifici all'agente CI durante l'implementazione canary per verificare una correzione in tempo reale.
3. Correzione collaborativa: se un deployment non va a buon fine, l'agente CD può notificare in modo proattivo all'agente di correzione le metriche non riuscite, avviando un'analisi autonoma della causa principale prima ancora che venga contattato un operatore umano.
4. Negoziazione delle risorse: gli agenti possono negoziare le esigenze dell'infrastruttura. Ad esempio, l'agente CI può chiedere all'agente di correzione di eseguire il provisioning di una maggiore capacità di build se rileva un refactoring su larga scala, oppure l'agente CD può suggerire di scalare il cluster di produzione prima di una release importante.
5. Consenso multi-agente: per le modifiche ad alto rischio, più agenti (ad es. l'agente di sicurezza e l'agente CD) possono eseguire una "approvazione congiunta" tramite A2A, garantendo che il codice non solo venga compilato e implementato, ma rispetti anche le norme di sicurezza prima di essere messo in produzione.

A. Clona il repository CDAgent

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

B. Crea il database Firestore

CDAgent archivia i pattern di memoria di deployment in Firestore:

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

(Se hai già creato un database in questo progetto, puoi saltare questo passaggio.)

C. Crea il service account 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. Concedere l'accesso ai secret a CDAgent

Riutilizzeremo il token GitHub e il webhook Slack precedenti e concederemo all'account di servizio di calcolo Cloud Run l'accesso alla chiave API Gemini in modo che l'app di cui è stato eseguito il deployment possa utilizzarla:

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. Crea ed esegui il deployment di CDAgent su 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 l'istanza attiva in modo che possa rispondere rapidamente ai comandi di Slack e A2A.

L'agente CD è l'ultimo gatekeeper dell'ambiente di produzione. Valuta il rischio di ogni deployment, esegue un canary calibrato in base al rischio e monitora le metriche in tempo reale. Se vengono rilevate anomalie, viene avviato un rollback automatico.

10. Scalare: sbloccare il livello 2 con l'Agent Swarm

A. Testa lo sciame completo

1. Attiva l'errore: apri l'URL di DinoQuest di cui hai eseguito il deployment (dall'ultimo passaggio) nel browser.
2. Vai alla classifica: fai clic sul pulsante Classifica. L'attuale implementazione della classifica è intenzionalmente inefficiente: tenterà di caricare una quantità enorme di dati in memoria, attivando un errore di esaurimento della memoria (OOM).
3. Attendi l'agente: entro circa 60 secondi, remediation-agent riceverà l'evento di errore tramite Eventarc e inizierà la diagnosi.
4. Controlla Slack: dovresti visualizzare una notifica nel tuo canale Slack simile a questa:Riepilogo della correzione di DinoAgent
   • Service: dinoquest
   • Revisione non riuscita: dinoquest-xxxx-xxxx
   • Prova: "È stato superato il limite di memoria di 128 MiB con 13x MiB utilizzati."
   • Perché questa revisione non è andata a buon fine: l'endpoint /api/leaderboard è stato xxxxx in modo inefficiente, causando un errore di memoria insufficiente.
   • Azione intrapresa: aumento della memoria da x Mi a y Gi per il servizio dinoquest. È stata creata una nuova revisione.
   • PR della causa principale: https://github.com/YOUR_USERNAME/DinoQuest/pull/x
5. Verifica le correzioni:
   • GitHub: controlla il repository per un nuovo branch e una richiesta di pull. L'agente ha applicato una patch al codice dell'applicazione per correggere la perdita di memoria sottostante.
   • Cloud Run: nella console Google Cloud, vedrai una nuova revisione del servizio dinoquest con l'allocazione della memoria aggiornata.
   • Classifica: prova di nuovo la classifica. Ora dovrebbe caricarsi correttamente grazie all'aumento della memoria e alla correzione del codice.

B. Evoluzione: implementazione della logica di gioco di livello 2

Aggiungerai una nuova funzionalità sostanziale: il livello 2 (Distruttore di asteroidi). In questo modo, i dinosauri con il punteggio più alto possono passare a una nuova modalità di gioco.

1. Torna al repository dinoquest:

   cd ~/dinoquest
   

2. Crea e passa a un nuovo branch:

   git checkout -b level_2
   

3. Applica la patch di livello 2: esegui lo script fornito per applicare la patch alla tua base di codice locale con asset, componenti e logica di gioco di livello 2:

   bash level_2_backup/levelup.sh
   

4. Esegui il commit e il push delle modifiche:

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

Anziché utilizzare curl per attivare manualmente l'agente, utilizzeremo il comando slash di Slack che hai configurato in precedenza. Ecco come interagisci con la pipeline CI autonoma in uno scenario reale.

1. Apri Slack e vai a un canale in cui è installata l'app CIAgent.
2. Attiva la build CI digitando il seguente comando:

   /runci run ci on branch level_2
   

3. Monitorare l'avanzamento:
   • Slack: l'agente riconoscerà il tuo comando e pubblicherà gli aggiornamenti man mano che la build procede.
   • Dino Theater: guarda le "bolle di pensiero" mentre l'agente classifica la modifica, invia il job Cloud Build e comunica con l'agente CD.
   • GitHub: controlla la richiesta di pull level_2. Vedrai l'agente pubblicare gli stati dei commit e un commento completo sul report CI.
4. Guarda la procedura:
   • Controlla Dino Theater per vedere l'agente CI che pensa, classifica la modifica ed esegue la pipeline.
   • Controlla la richiesta di pull di GitHub per visualizzare lo stato del commit e il report finale pubblicati da CI Agent.

11. Conclusione

Hai creato uno stack DevOps agentico completo su Google Cloud:

Componente	Descrizione
DinoQuest (Cloud Run dinoquest)	Gioco basato su Gemini: frontend React + backend FastAPI
Firebase Auth + Firestore	Autenticazione degli utenti e archiviazione dei profili dei dinosauri
Agente di correzione (Cloud Run + Eventarc)	Agente SRE che corregge automaticamente gli errori OOM e i bug del codice
log-router-bq-report	Agente di dati che trasmette i log a BigQuery e genera insight
CIAgent (Cloud Run)	Agente CI che definisce l'ambito dei test, crea immagini e chiama CD tramite A2A
CDAgent (Cloud Run)	Agente CD che esegue deployment canary con punteggio di rischio e rollback automatico

Tutto il comportamento dell'agente si trova nella directory skills/ come playbook Markdown. Modifica il comportamento modificando la skill, non il codice. Le skill vengono eseguite su Antigravity con Gemini e vengono richiamate comunicando all'agente quale skill eseguire.