Agent-First-Workflows – vom Prompt zur Produktion

1. Übersicht

Willkommen zum zweiten Tag. Wenn Sie eine App erstellen und auf „Veröffentlichen“ klicken, ist das zwar magisch, aber echter Traffic führt zu echten Fehlern. Statt Ihre Tage mit YAML oder dem Durchsuchen von Logs zu verbringen, können Sie eine Vielzahl von spezialisierten Agenten erstellen, die sich um die operative Infrastruktur kümmern. In diesem Codelab wird gezeigt, wie der einheitliche Stack von Google Cloud (Eventarc, Cloud Run, Firestore, Cloud Build, BigQuery) es Agents erleichtert, Secrets sicher abzurufen, Logs zu streamen und Probleme sofort zu beheben.

In diesem Codelab erstellen Sie DinoQuest – ein von Gemini unterstütztes Dinosaurier-Abenteuerspiel – von Grund auf und verbinden es mit einer vollständig agentenbasierten CI/CD-Pipeline. Am Ende haben Sie:

• Eine funktionierende DinoQuest-Webanwendung, die in Cloud Run ausgeführt wird (Dienstname: dinoquest)
• Eine Pipeline für die Loganalyse, mit der Cloud Run-Logs in BigQuery gestreamt und ein interaktives Dashboard mit Spielstatistiken erstellt wird
• Remediation Agent (remediation-agent): Ein ADK-Remediation Agent, der nach Cloud Run-Fehlern sucht und sie automatisch behebt. Er wird als eigener Cloud Run-Dienst bereitgestellt, der von Eventarc ausgelöst wird.
• Ein CI-Agent (ci-agent), der den PR-Diff liest, Tests intelligent eingrenzt, ein Docker-Image über Cloud Build erstellt und einen Commit-Status an GitHub zurückgibt
• Ein CD-Agent, der das Bereitstellungsrisiko bewertet, Traffic aufteilt, Messwerte überwacht und automatisch hoch- oder zurückstuft

Lerninhalte

• Vollständige Vite- und FastAPI-Anwendung in Cloud Run als einzelnen Container bereitstellen
• Firebase Auth und Firestore für eine React-App konfigurieren
• So erstellen und stellen Sie einen ADK-Agent bereit, der über Eventarc auf Pub/Sub-Ereignisse reagiert
• Cloud Run-Logs an BigQuery weiterleiten und Spielanalysen abfragen
• Agentic Skills für CI und Canary-Bereitstellung schreiben

Voraussetzungen

• Ein Google Cloud-Projekt mit aktivierter Abrechnung
• Ein Firebase-Projekt (kann dasselbe GCP-Projekt sein)
• Ein GitHub-Konto und ein Fork des DinoQuest-Repositorys
• Zugriff auf Antigravity mit Gemini (dem Agent Runner von Google)
• gcloud CLI installiert und authentifiziert – siehe Installationsanleitung unten
• node ≥ 18 und npm
• python3 ≥ 3.11
• git und gh (GitHub CLI)

gcloud-CLI installieren

macOS

brew install --cask google-cloud-sdk

Oder laden Sie das Installationsprogramm unter cloud.google.com/sdk/docs/install herunter.

Windows

winget install Google.CloudSDK

Alternativ können Sie das Windows-Installationsprogramm (.exe) unter cloud.google.com/sdk/docs/install herunterladen und ausführen.

Nach der Installation müssen Sie das SDK initialisieren und sich authentifizieren:

gcloud init
gcloud auth login
gcloud auth application-default login

2. Firebase einrichten

Jeder Agent benötigt Daten, um Schlussfolgerungen zu ziehen. DinoQuest verwendet Firestore und Firebase Authentication, um eine produktionsreife Datenschicht bereitzustellen, die unsere Agents später in natürlicher Sprache erkennen, analysieren und aktualisieren.

Da diese App über AI Studio generiert wurde, ist sie stark in Firebase eingebunden. Die Verwendung von Firebase bietet mehrere Vorteile. Dazu gehören vor allem eine von vornherein gesicherte Architektur und ein verwalteter Datenzugriff, sodass der Status Ihres Spiels vom ersten Tag an geschützt ist.

A. Firebase-Projekt erstellen

1. Rufen Sie console.firebase.google.com auf.
2. Klicken Sie auf Projekt hinzufügen (diese Option ist in der Option zum Erstellen eines neuen Projekts verborgen) → wählen Sie Ihr vorhandenes GCP-Projekt aus (oder erstellen Sie ein neues).
3. Deaktivieren Sie Google Analytics, wenn Sie dazu aufgefordert werden → Projekt erstellen (Sie können auch die Standardeinstellung beibehalten).

B. Google-Authentifizierung aktivieren

1. Rufen Sie in der Firebase Console Sicherheit → Authentifizierung (Jetzt starten) → Anmeldemethode auf.
2. Klicken Sie auf Google → aktivieren Sie Aktivieren → speichern Sie die Support-E‑Mail-Adresse → Speichern.

C. „localhost“ als autorisierte Domain hinzufügen

1. Klicken Sie auf dem Tab Authentifizierung auf den Tab Einstellungen.
2. Prüfen Sie unter Autorisierte Domains, ob localhost aufgeführt ist (sollte standardmäßig der Fall sein).

D. Firestore-Datenbank erstellen

1. Rufen Sie Datenbank & Speicher → Firestore-Datenbank → Datenbank erstellen auf.
2. Wählen Sie Standardversion → Weiter aus.
3. Wählen Sie die Region us-central1 aus (oder passen Sie sie an Ihre Cloud Run-Region an).
4. Wählen Sie Im Produktionsmodus starten → Erstellen aus.

Notieren Sie sich nach dem Erstellen die Datenbank-ID. Sie sieht so aus: (default), sofern Sie sie nicht benannt haben.

E. Firebase-Sicherheitsregeln festlegen

Ersetzen Sie unter Firestore-Datenbank → Regeln die Standardregeln durch Folgendes:

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

Klicken Sie auf Veröffentlichen.

F. Web-App hinzufügen und Konfiguration abrufen

1. Rufen Sie die Projekteinstellungen (Zahnradsymbol) → Tab Allgemein auf.
2. Scrollen Sie zu Meine Apps → klicken Sie auf App hinzufügen → wählen Sie das Symbol Web () aus.
3. Geben Sie einen Namen ein → App registrierendinoquest
4. Kopieren Sie das angezeigte firebaseConfig-Objekt. Sie werden es gleich brauchen.

3. Spiel leiten

Rolle des Agents: Die Umgebung. Bevor wir unsere KI-Agenten einsetzen können, benötigen wir eine Welt, die sie verwalten können. In diesem Schritt stellen wir die „Day One“-Version von DinoQuest bereit. Dadurch werden der Live-Dienst, die Protokolle und der Status erstellt, die unser Schwarm später erkennt und verwaltet.

Wählen Sie eine der beiden folgenden Optionen aus. Es wird entweder ein GEMINI_API_KEY erstellt, das Sie in jedem späteren Schritt identisch verwenden – es sind keine weiteren Änderungen erforderlich.

A. Gemini API-Schlüssel einrichten

Option A: Vertex AI Gemini API-Schlüssel (empfohlen, wenn Sie ein Google Cloud-Projekt haben)

Mit Vertex AI können Sie einen Gemini API-Schlüssel erstellen, der direkt mit Ihrem GCP-Projekt verknüpft ist und über das Standarddienstkonto des Projekts abgerechnet wird. Ein separates AI Studio-Konto ist nicht erforderlich.

1. Exportieren Sie Ihre GCP-Projekt-ID:

   export PROJECT_ID=<YOUR_PROJECT_ID>
   

2. Aktivieren Sie die erforderlichen APIs und gewähren Sie dem Compute Engine-Standarddienstkonto die erforderlichen Berechtigungen:

   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. Öffnen Sie in der Cloud Console die Seite „Vertex AI-API-Schlüssel“.
4. Klicken Sie auf Anmeldedaten erstellen → wählen Sie API-Schlüssel aus.
5. Gehen Sie im Dialogfeld zum Erstellen so vor:
   • Geben Sie dem Schlüssel den Namen Dino_Key.
   • Klicken Sie das Kästchen API-Aufrufe über ein Dienstkonto authentifizieren an.
   • Wählen Sie unter „Dienstkonto“ das Standarddienstkonto für Compute Engine ([e-mail]) aus.
   • Klicken Sie auf der Seite API-Einschränkungen auswählen das Kästchen GEMINI API an.
   • Klicken Sie auf Erstellen.
6. Kopieren Sie den generierten Schlüssel.

Option B: AI Studio (am schnellsten für die lokale Entwicklung)

1. Rufen Sie aistudio.google.com auf.
2. Klicken Sie in der linken Seitenleiste auf API-Schlüssel abrufen.
3. Klicken Sie auf API-Schlüssel erstellen → wählen Sie Ihr GCP-Projekt aus → kopieren Sie den Schlüssel.

Einer der beiden Schlüssel wird in den folgenden Schritten als GEMINI_API_KEY festgelegt. Das Backend behandelt sie identisch.

Repository klonen

Das Kurs-Repository befindet sich in https://github.com/gca-americas/dinoquest. Erstellen Sie zuerst einen Fork des Repositorys in Ihrem eigenen GitHub-Konto. Wir lassen den Agenten stattdessen an Ihrem Repository arbeiten.

Klonen Sie nach dem Forken den main-Branch Ihres geforkten DinoQuest-Repositorys und rufen Sie das Projektverzeichnis auf:

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

B. Umgebungsvariablen einrichten

Legen Sie in jedem neuen Bash-Terminal, das Sie während dieses Codelabs öffnen, diese wichtigen Umgebungsvariablen fest. Ersetzen Sie die Platzhalterwerte durch die tatsächlichen Projektdetails:

Exportieren Sie zuerst die URL Ihres GitHub-Repositorys:

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

Exportieren Sie dann die verbleibenden Umgebungsvariablen:

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

Prüfen Sie, ob die Struktur richtig aussieht:

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. Back-End-Umgebungsdatei erstellen

Exportieren Sie zuerst Ihren Gemini API-Schlüssel:

export GEMINI_API_KEY=YOUR_GEMINI_API_KEY_FROM_STEP_2

Erstellen Sie dann die Datei .env:

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

C. Firebase App Check / Dienstkonto (für Cloud Run) aktivieren

Wenn das Back-End in Cloud Run ausgeführt wird, verwendet es Standardanmeldedaten für Anwendungen für die Kommunikation mit Firebase. Es ist keine Dienstkontoschlüsseldatei erforderlich. Der firebase_admin.initialize_app()-Aufruf in backend/main.py wird automatisch berücksichtigt.

Für die lokale Entwicklung müssen Sie sich nur einmal authentifizieren:

gcloud auth application-default login

D. Firebase-App-Konfigurationsdatei erstellen

Erstellen Sie im Verzeichnis frontend/ die Datei firebase-applet-config.json mit Ihrer Konfiguration aus dem vorherigen Schritt:

{
  "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)"
}

Hinweis : firestoreDatabaseId sollte mit der Datenbank-ID übereinstimmen, die Sie im vorherigen Schritt erstellt haben. Wenn Sie die Standardeinstellung verwendet haben, lassen Sie das Feld auf "(default)".

Übernehmen Sie die Änderungen für Ihr Repository:

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

C. DinoQuest lokal ausführen

1. Erforderliche APIs aktivieren

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

Das start.sh-Skript erstellt das React-Frontend und übergibt das Terminal an das FastAPI-Backend, das die kompilierten statischen Dateien bereitstellt:

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

Öffnen Sie in Ihrem Browser http://localhost:8000. Der Titelbildschirm von DinoQuest sollte angezeigt werden. Melden Sie sich über Google an, generieren Sie Ihren ersten Dinosaurier und bestätigen Sie, dass er in Firestore gespeichert wird.

Fehlerbehebung:Wenn eine leere Seite oder Firebase-Authentifizierungsfehler angezeigt werden, prüfen Sie, ob frontend/firebase-applet-config.json die richtigen Werte enthält und ob localhost in der Liste der autorisierten Domains enthalten ist.

E. DinoQuest in Cloud Run bereitstellen

1. Projekt festlegen

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

3. Artifact Registry-Repository erstellen

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

4. Gemini API-Schlüssel in Secret Manager speichern

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. Container-Image mit Cloud Build erstellen

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

Dadurch wird das mehrstufige Dockerfile ausgeführt: Zuerst wird die React-App erstellt und dann wird die Ausgabe in das FastAPI-Image gepackt. Das dauert etwa 3 bis 5 Minuten.

6. In Cloud Run bereitstellen

Exportieren Sie zuerst die E-Mail-Adresse des Administrators:

export ADMIN_EMAIL=<YOUR_TEST_ACCOUNT_EMAIL>

Stellen Sie dann den Dienst bereit:

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"

Wenn der Befehl abgeschlossen ist, gibt Cloud Run eine Service-URL aus. Kopieren Sie diese URL. Sie benötigen sie, um die Domain in Firebase zu autorisieren.

7. Cloud Run-Domain in Firebase autorisieren

Damit sich Nutzer über Ihre bereitgestellte App anmelden können, müssen Sie die Cloud Run-URL den autorisierten Domains von Firebase hinzufügen:

1. Kehren Sie zur Firebase Console → Authentifizierung → Einstellungen → Autorisierte Domains zurück.
2. Klicken Sie auf Domain hinzufügen.
3. Fügen Sie die URL Ihres Cloud Run-Dienstes ein (z. B. dinoquest-xxxxx.us-central1.run.app) – entfernen Sie das Präfix https://.
4. Klicken Sie auf Speichern.

8. Bestenlistendaten übertragen

Damit Ihr Spiel von Anfang an etwas „Leben“ hat und Ihre Agents Daten zur Verfügung haben, können Sie die Bestenliste mit einigen Startpunkteständen füllen.

1. Achten Sie darauf, dass Sie sich im Stammverzeichnis dinoquest befinden:

   cd ~/dinoquest
   

2. Erstellen und aktivieren Sie eine virtuelle Umgebung:

   python3 -m venv venv
   source venv/bin/activate
   

3. Installieren Sie die erforderliche Firestore-Abhängigkeit:

   pip install google-cloud-firestore
   

4. Führen Sie das Seeding-Skript aus:

   python3 prep/seed_scores.py
   

5. Deaktivieren Sie die virtuelle Umgebung:

   deactivate
   

Sie können die Dienst-URL jetzt in Ihrem Browser öffnen. DinoQuest ist vollständig live.

4. Dino-Theater einrichten

Agent-Rolle: Visualizer. Wie überwachen Sie ein autonomes Agententeam? Dino Theater bietet einen Echtzeit-Einblick in die Denkweise Ihres Agentenschwarms. Anstatt sich Terminal-Logs anzusehen, können Sie in einem visuellen Live-Dashboard beobachten, wie Ihre Agents argumentieren, sich gegenseitig aufrufen und Aufgaben in der Cloud ausführen.

A. Dino Theater in Cloud Run bereitstellen

Wechseln Sie zuerst zurück zu Ihrem Basisverzeichnis und klonen Sie den Dino Theater-Code:

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

1. Container erstellen und per Push übertragen:

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

2. Dienstkonto und Berechtigungen einrichten:

   # 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. Anwendung bereitstellen:

   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
   

   Hinweis: --min-instances=1 wird empfohlen, um die SSE-Verbindung zwischen Ereignissen aufrechtzuerhalten.
4. Funktionsweise prüfen:Öffnen Sie die bereitgestellte Dienst-URL in Ihrem Browser (z.B. https://dino-theater-xxx-uc.a.run.app/demo).

5. Agentic DevOps in der IDE

Rolle des Kundenservicemitarbeiters: Native Antigravity. Um die Lücke zwischen Ihrer IDE und der Cloud zu schließen, verbinden wir Antigravity mit den verwalteten MCP-Servern von Google Cloud. So erhält Ihr nativer Agent Zugriff auf Ihr Projekt und kann Logs parsen, Messwerte prüfen und die Infrastruktur analysieren, ohne dass Sie API-Schlüssel verwalten oder zur Console wechseln müssen.

Bevor Sie Skills ausführen, müssen Sie den Zugriff von Antigravity auf Google Cloud konfigurieren und die DinoQuest-Skill-Playbooks laden.

A. Von Google verwalteten MCP-Dienst installieren

Der verwaltete MCP-Dienst von Google bietet Zugriff auf alle Google Cloud APIs über einen einzelnen gehosteten Endpunkt.

Mit Standardanmeldedaten für Anwendungen authentifizieren:

gcloud auth application-default login

B. mcp_config.json konfigurieren

Erstellen oder aktualisieren Sie mcp_config.json in Ihrem Antigravity-Konfigurationsverzeichnis (normalerweise ~/.gemini/antigravity/mcp_config.json) oder über die Konsole. Dadurch erhält Antigravity Zugriff auf die Google Cloud- und GitHub-Tools, die für die Skills erforderlich sind:

{
  "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. Skills in Antigravity laden (optional)

Antigravity findet Skills in bestimmten Standardverzeichnissen. Kopieren Sie die DinoQuest-Skills aus Ihrem geklonten Repository in den globalen Antigravity-Skills-Ordner:

# 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. Antigravity neu starten(optional)

Wenn Sie die Änderungen an mcp_config.json übernehmen und die neu kopierten Skills laden möchten, starten Sie die Antigravity-App neu.

Nach dem Neustart:

1. Prüfen Sie, ob die MCP-Server google und github in den Einstellungen den grünen Status „Verbunden“ haben.
2. Prüfen Sie, ob die DinoQuest-Skills in Ihrer Skill-Liste angezeigt werden.

Hinweis:Für jede Fähigkeit gibt es oben auf der SKILL.md eine ## Configuration-Tabelle. Nach dem Kopieren sollten Sie die Werte in ~/.gemini/antigravity/skills//SKILL.md an Ihr Projekt anpassen.

E. Cloud-Dienst in lokaler IDE korrigieren

1. Fehler auslösen: Öffnen Sie die bereitgestellte DinoQuest-URL (aus dem letzten Schritt) in Ihrem Browser.
2. Zur Bestenliste: Klicken Sie auf die Schaltfläche Bestenliste. Die aktuelle Leaderboard-Implementierung ist bewusst ineffizient. Es wird versucht, eine große Menge an Daten in den Arbeitsspeicher zu laden, was einen OOM-Fehler (Out-Of-Memory) auslöst.
3. Bitten Sie Antigravity Agent Manager (Agent HUB), Ihnen bei der Behebung des Fehlers und möglicherweise der Ursache zu helfen.

• Prompt 1: Finde heraus, was mit dinoquest nicht stimmt.
• Prompt 2: Kannst du dir den Code für das Dinoquest-Spiel ansehen und den Fehler beheben, der den Fehler „Nicht genügend Arbeitsspeicher“ verursacht hat?

6. Logs zu BigQuery streamen und Analysen erstellen

Rolle des Agenten: Data Agent Die Umwandlung von Rohlogs in eine umsetzbare Produktstrategie sollte nicht Stunden manueller Datenaufbereitung in Anspruch nehmen. Mit dem Data Agent Kit und BigQuery MCP erstellen wir eine „Zero ETL“-Pipeline, mit der Logs direkt in BigQuery gestreamt werden. So kann der Agent in weniger als zwei Minuten ein Premium-Analysedashboard generieren.

Mit dem log-router-bq-report-Skill wird eine Cloud Logging-Senke eingerichtet, die die Cloud Run-Logs von DinoQuest kontinuierlich in BigQuery streamt. Anschließend werden die Daten abgefragt, um Traffic-Berichte und Erkenntnisse zur Spieleanalyse zu erstellen.

A. Skill-Variablen konfigurieren

Öffnen Sie skills/log-router-bq-report/SKILL.md in Ihrem DinoQuest-Repository und aktualisieren Sie den Abschnitt Configuration (Konfiguration) oben:

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

B. Skill in Antigravity ausführen

Öffnen Sie Antigravity mit dem DinoQuest-Repository als Kontext und sagen Sie Gemini:

Run the log-router-bq-report skill

Der Skill wird:

1. GCP-Projekt automatisch reaktivieren
2. Prüfen, ob die BigQuery-Senke bereits vorhanden ist: Wenn nicht, werden das Dataset und die Senke erstellt.
3. IAM-Berechtigungen erteilen: Der writerIdentity der Senke wird die Rolle BigQuery-Datenbearbeiter für das Dataset zugewiesen.

Hinweis:Wie bei der Eventarc-Senke wird möglicherweise auch hier eine Warnung von gcloud angezeigt: „Bitte denken Sie daran, dem Dienstkonto:service-... die Rolle ‚BigQuery Data Editor‘ für das Dataset zuzuweisen.“ Das Skill erledigt das automatisch.

C. Bericht mit Antigravity erstellen

Bitten Sie Antigravity einfach, die BigQuery-Logsenke einzurichten und den Analysebericht zu erstellen. Der KI-Agent wird:

1. Infrastruktur konfigurieren: Erstellen Sie das BigQuery-Dataset und die Cloud Logging-Senke.
2. Berechtigungen verwalten: Der Writer-Identität der Senke werden automatisch die erforderlichen IAM-Rollen zugewiesen.
3. Insights generieren: Analysieren Sie die Protokolle und erstellen Sie ein Premium-, interaktives HTML-Dashboard mit Spieltelemetrie und Gewinnratenanalyse.

7. Agent für automatische Problembehebung

Agent-Rolle: SRE-Agent. Wenn ein Produktionsdienst um 2 Uhr morgens ausfällt, sollten Sie nicht aufwachen müssen. Dieser Agent fungiert als Ihr erster Ansprechpartner. Der Prozess wird durch Cloud Run-Fehlerlogs über Eventarc ausgelöst. Er analysiert den Absturz automatisch, schlägt eine Korrektur vor und startet einen Korrektur-Pipeline – alles, bevor Sie sich überhaupt in der Konsole angemeldet haben.

DinoAgent ist ein ADK-Agent, der über Eventarc auf Cloud Run-Fehlerlogs wartet, die Ursache diagnostiziert und automatisch behebt – entweder durch Erhöhen des Arbeitsspeichers, Zurücksetzen des Traffics oder Einreichen eines PR für die Codekorrektur auf GitHub.

A. Remediation Agent-Repository klonen

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

Die Projektstruktur:

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. GitHub-Zugriff einrichten (Code-Fix-Track)

Beim Code-Fix-Track wird Ihr DinoQuest-Repository geklont, Quellcode gelesen, Patches angewendet und Pull-Requests geöffnet. Dazu ist ein persönliches GitHub-Zugriffstoken mit dem Bereich repo erforderlich.

1. Rufen Sie github.com/settings/tokens auf → Generate new token (classic) (Neues Token (klassisch) generieren).
2. Geben Sie einen Namen ein, wählen Sie den repo-Bereich aus → Token generieren → kopieren Sie ihn.

Speichern Sie es in Secret Manager:

Exportieren Sie zuerst Ihr GitHub-Token:

export GH_TOKEN=ghp_YOUR_TOKEN_HERE

Erstellen Sie dann das Secret:

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

C. Slack-Benachrichtigungen einrichten (optional)

Wenn eine Korrektur abgeschlossen ist, postet DinoAgent eine Zusammenfassung in einem Slack-Kanal.

1. Rufen Sie api.slack.com/apps auf → Create New App (Neue App erstellen) → From scratch (Von Grund auf).
2. Geben Sie einen Namen ein, wählen Sie Ihren Arbeitsbereich aus → App erstellenDinoAgent
3. Unter Features → Eingehende Webhooks → aktivieren
4. Klicken Sie auf Add New Webhook to Workspace (Arbeitsbereich neuen Webhook hinzufügen) → wählen Sie einen Channel aus → Allow (Zulassen).
5. Webhook-URL kopieren (https://hooks.slack.com/services/...)

Speichern Sie es 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. DinoAgent-Dienstkonto erstellen

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

Gewähren Sie Zugriff auf die Secrets:

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

E. DinoAgent erstellen und in Cloud Run bereitstellen

# 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. Eventarc-Trigger einrichten

Erstellen Sie ein Pub/Sub-Thema, um Cloud Run-Fehlerlogs zu empfangen:

gcloud pubsub topics create cloud-run-errors

Erstellen Sie eine Cloud Logging-Senke, die Fehlerlogs aus Ihrem dinoquest-Dienst filtert und an das Thema weiterleitet:

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"

Hinweis:Wenn Sie den oben genannten Befehl ausführen, gibt gcloud eine Info-Meldung aus: „Vergessen Sie nicht, dem Dienstkonto:service-... die Pub/Sub-Publisher-Rolle für das Thema zuzuweisen.“ Genau das wird im nächsten Schritt behandelt.

Gewähren Sie der Writer-Identität der Senke (dem im Warnhinweis erwähnten Dienstkonto) die Berechtigung zum Veröffentlichen:

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"

So prüfen Sie, ob die Funktion aktiviert ist:

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

Gewähren Sie Eventarc die Berechtigung zum Aufrufen des Korrektur-Agents:

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

Eventarc-Trigger erstellen:

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}

Die Korrektur erfolgt jetzt vollständig automatisch. DinoAgent skaliert nicht nur die Infrastruktur, sondern führt auch eine detaillierte Ursachenanalyse des Anwendungscodes durch, wendet einen semantischen Patch an und verwendet die Agent-to-Agent-Kommunikation (A2A), um die Korrektur zur Überprüfung und Bereitstellung an den CI-Agenten zu übergeben. Die Implementierungsdetails finden Sie in der reme-agent-Codebasis.

8. CI-Agent einrichten

Agent Role: CI pipeline (Agent-Rolle: CI-Pipeline) Sie müssen sich nicht mehr mit komplexen YAML-Dateien und manuellen Build-Skripts herumschlagen. Dieser Agent verwaltet die betriebliche Infrastruktur Ihrer PRs. Der Agent liest Ihre Codeänderungen, versteht den Kontext, grenzt die erforderlichen Tests ein und erstellt Ihre Docker-Images über Cloud Build. So wird sichergestellt, dass jeder Commit „agent-genehmigt“ ist, bevor er den Hauptzweig erreicht.

Der ci-agent ist ein autonomer CI-Pipeline-Agent, der als Cloud Run-Dienst bereitgestellt wird. Es sendet Docker-Builds an Cloud Build, fragt nach dem Abschluss, prüft das Image in Artifact Registry und meldet sich bei GitHub.

Warum sollte ich einen Agent für meine CI-Pipeline verwenden? Im Gegensatz zu herkömmlichen statischen Skripts bietet eine agentische CI-Pipeline Folgendes:

1. Kognitive Bereichsklassifizierung: Die erforderliche Testtiefe wird intelligent bestimmt. Je nach semantischer Auswirkung Ihrer Codeänderungen wird zwischen Typüberprüfungen, Einheitentests oder vollständigen Integrationssuiten gewechselt.
2. Autonome PR-Verwaltung: Der Agent kann automatisch PRs erstellen, detaillierte Zusammenfassungen von Änderungen posten und sogar Secret Scanning und Sicherheitsüberprüfungen ohne menschliches Eingreifen verwalten.
3. Fehlerdiagnose in Echtzeit: Wenn ein Build fehlschlägt, zeigt der Agent nicht nur Protokolle an. Er analysiert den Stacktrace, ermittelt die wahrscheinliche Ursache und postet eine für Menschen lesbare Diagnose direkt im Pull-Request.

A. CIAgent-Repository klonen

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

B. CIAgent-Dienstkonto erstellen

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. GitHub-Repository mit Cloud Build verbinden

CIAgent sendet Builds über repoSource. Dazu muss das GitHub-Repository mit Cloud Build Developer Connect verbunden sein.

1. Rufen Sie die GCP Console → Cloud Build → Repositories auf.
2. Klicken Sie auf Repository verbinden.
3. Wählen Sie GitHub (Cloud Build GitHub App) aus.
4. YOUR_GITHUB_USERNAME/dinoquest-Repository autorisieren und auswählen
5. Klicken Sie auf Verbinden und dann auf Überspringen, wenn Sie aufgefordert werden, einen Trigger zu erstellen.
6. Notieren Sie sich den Namen Ihrer Verbindung (standardmäßig ist das in der Regel Ihr GitHub-Nutzername oder ein ähnlicher Name).

D. CIAgent Zugriff auf Secrets gewähren

Wir verwenden die zuvor für DinoAgent erstellten Secrets wieder:

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. CIAgent erstellen und in Cloud Run bereitstellen

# 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. Einrichtung von Slack-Slash-Befehlen

1. Gehen Sie zu api.slack.com/apps → Create New App (Neue App erstellen) → From scratch (Von Grund auf).
2. Geben Sie einen Namen ein (CIAgent), wählen Sie einen Arbeitsbereich aus und klicken Sie auf App erstellen.
3. Unter Funktionen → Slash-Befehle → Neuen Befehl erstellen
4. Befehl: /runci
5. Anfrage-URL: Ihre CIAgent Cloud Run-URL von oben mit angehängtem /slack (z.B. https://ci-agent-xxx-.us-central1.run.app/slack)
6. Kurzbeschreibung: Trigger CI
7. Speichern
8. Klicken Sie unter Einstellungen → App installieren auf Im Workspace installieren und dann auf „Zulassen“.

Der CI-Agent fungiert als „Gehirn“ und basiert auf robusten Google Cloud-Diensten wie Cloud Build und Artifact Registry. Sobald der Build überprüft wurde, wird die letzte Bereitstellungsphase ausgelöst, indem der CD-Agent über A2A aufgerufen wird. So wird ein nahtloser Übergang zwischen den Build- und Releasezyklen gewährleistet.

9. Bereitstellung einrichten

Agent-Rolle: CD Agent Die Bereitstellung sollte kein Blindflug sein. Dieser Agent verwaltet das Risiko für Sie. Es bewertet die Sicherheit der Bereitstellung, verwaltet Canary-Traffic-Splits und überwacht Echtzeitmesswerte, um zu entscheiden, ob eine Version hochgestuft oder zurückgesetzt werden soll. Es ist der letzte Gatekeeper in Ihrem autonomen Agentenschwarm.

Der cd-agent ist ein autonomer Canary-Deployment-Agent, der als Cloud Run-Dienst bereitgestellt wird. Es empfängt A2A-Bereitstellungsanfragen von ci-agent, berechnet einen Risikowert, legt einen risikokalierten Canary-Prozentsatz fest, überwacht Messwerte und stuft automatisch hoch oder führt ein Rollback durch. Außerdem werden Daten aus früheren Bereitstellungen mit Firestore berücksichtigt.

Wenn Sie Agents direkt verbinden, entsteht eine „kognitive Pipeline“, bei der bei jeder Übergabe Intention und Kontext übertragen werden. Im Gegensatz zu herkömmlichen Webhooks ermöglicht die A2A-Kommunikation Folgendes:

1. Intelligente Kontextfreigabe: Agents geben gesamte Sitzungsspeicher, PR-Unterschiede und Risikobewertungen weiter, sodass der nächste Agent vor Arbeitsbeginn das vollständige „Warum“ kennt.
2. Cognitive Handshakes: Agents können Gates aushandeln. Beispiel: Der CD-Agent kann während eines Canary-Rollouts bestimmte Smoke-Tests vom CI-Agent anfordern, um einen Fix in Echtzeit zu überprüfen.
3. Gemeinsame Fehlerbehebung: Wenn eine Bereitstellung fehlschlägt, kann der CD-Agent den Remediation Agent proaktiv über fehlgeschlagene Messwerte benachrichtigen und so eine autonome Ursachenanalyse einleiten, bevor ein Mensch benachrichtigt wird.
4. Ressourcenverhandlung: KI-Agenten können Infrastrukturanforderungen verhandeln. Der CI-Agent kann beispielsweise den Remediation-Agent auffordern, mehr Build-Kapazität bereitzustellen, wenn er ein umfangreiches Refactoring erkennt. Der CD-Agent kann vorschlagen, den Produktionscluster vor einer wichtigen Version zu skalieren.
5. Multi-Agent Consensus: Bei Änderungen mit hohem Risiko können mehrere Agents (z. B. Security Agent und CD Agent) über A2A eine „gemeinsame Genehmigung“ durchführen. So wird sichergestellt, dass Code nicht nur erstellt und bereitgestellt wird, sondern auch den Sicherheitsrichtlinien entspricht, bevor er in die Produktion geht.

A. CDAgent-Repository klonen

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

B. Firestore-Datenbank erstellen

CDAgent speichert seine Bereitstellungsmuster in Firestore:

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

Wenn Sie in diesem Projekt bereits eine Datenbank erstellt haben, können Sie diesen Schritt überspringen.

C. CDAgent-Dienstkonto erstellen

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. CDAgent Zugriff auf Secrets gewähren

Wir verwenden das GitHub-Token und den Slack-Webhook aus dem vorherigen Schritt wieder und gewähren dem Cloud Run-Dienstkonto Zugriff auf den Gemini API-Schlüssel, damit die bereitgestellte App ihn verwenden kann:

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. CDAgent erstellen und in Cloud Run bereitstellen

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

Hinweis : --min-instances=1 --no-cpu-throttling hält die Instanz aktiv, damit sie schnell auf Slack- und A2A-Befehle reagieren kann.

Der CD-Agent ist der letzte Gatekeeper Ihrer Produktionsumgebung. Es bewertet das Risiko jeder Bereitstellung, führt einen risikoangepassten Canary-Test durch und überwacht Echtzeitmesswerte. Wenn Anomalien erkannt werden, wird automatisch ein Rollback eingeleitet.

10. Skalierung: Mit dem Agent Swarm Level 2 freischalten

A. Full Swarm testen

1. Fehler auslösen: Öffnen Sie die bereitgestellte DinoQuest-URL (aus dem letzten Schritt) in Ihrem Browser.
2. Zur Bestenliste: Klicken Sie auf die Schaltfläche Bestenliste. Die aktuelle Leaderboard-Implementierung ist bewusst ineffizient. Es wird versucht, eine große Menge an Daten in den Arbeitsspeicher zu laden, was einen OOM-Fehler (Out-Of-Memory) auslöst.
3. Auf den Agent warten: Innerhalb von etwa 60 Sekunden empfängt remediation-agent das Fehlerereignis über Eventarc und beginnt mit der Diagnose.
4. In Slack nachsehen: In Ihrem Slack-Kanal sollte eine Benachrichtigung wie diese angezeigt werden:DinoAgent Remediation Summary
   • Dienst: dinoquest
   • Fehlerhafte Überarbeitung: dinoquest-xxxx-xxxx
   • Nachweis: „Memory limit of 128 MiB exceeded with 13x MiB used.“ (Arbeitsspeicherlimit von 128 MiB überschritten, 13x MiB verwendet.)
   • Warum war diese Überarbeitung schlecht?: Der /api/leaderboard-Endpunkt wurde ineffizient xxxxx, was zu einem OOM-Fehler führte.
   • Ergriffene Maßnahmen: Der Arbeitsspeicher für den Dienst dinoquest wurde von xMi auf yGi erhöht. Es wurde eine neue Version erstellt.
   • PR für die Ursache: https://github.com/YOUR_USERNAME/DinoQuest/pull/x
5. Korrekturen prüfen:
   • GitHub: Prüfen Sie Ihr Repository auf einen neuen Branch und eine Pull-Anfrage. Der Agent hat den Anwendungscode gepatcht, um das zugrunde liegende Speicherleck zu beheben.
   • Cloud Run: In der GCP Console wird eine neue Version des dinoquest-Dienstes mit der aktualisierten Arbeitsspeicherzuweisung angezeigt.
   • Bestenliste: Versuchen Sie es noch einmal mit der Bestenliste. Sie sollte jetzt dank des erhöhten Arbeitsspeichers und der eventuellen Fehlerbehebung im Code geladen werden.

B. Evolution: Implementierung der Spiellogik für Level 2

Sie fügen eine wichtige neue Funktion hinzu: Level 2 (Asteroid Destroyer). Dinosaurier mit einem hohen Punktestand können in einen neuen Spielmodus wechseln.

1. Zurück zum Repository „dinoquest“:

   cd ~/dinoquest
   

2. Neuen Zweig erstellen und zu ihm wechseln:

   git checkout -b level_2
   

3. Level 2-Patch anwenden: Führen Sie das bereitgestellte Skript aus, um Ihre lokale Codebasis mit Level 2-Assets, -Komponenten und -Spiellogik zu patchen:

   bash level_2_backup/levelup.sh
   

4. Commit durchführen und Änderungen per Push-Befehl übertragen:

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

Anstatt curl zu verwenden, um den Agent manuell auszulösen, verwenden wir den Slack-Slash-Befehl, den Sie zuvor konfiguriert haben. So interagieren Sie in einem realen Szenario mit Ihrer autonomen CI-Pipeline.

1. Öffnen Sie Slack und rufen Sie einen beliebigen Kanal auf, in dem die CIAgent-App installiert ist.
2. Lösen Sie den CI-Build aus, indem Sie den folgenden Befehl eingeben:

   /runci run ci on branch level_2
   

3. Fortschritt beobachten
   :
   • Slack: Der Agent bestätigt Ihren Befehl und postet Updates zum Fortschritt des Builds.
   • Dino Theater: Sehen Sie sich die „Sprechblasen“ an, während der Agent die Änderung klassifiziert, den Cloud Build-Job einreicht und mit dem CD-Agenten kommuniziert.
   • GitHub: Sehen Sie sich Ihren level_2-Pull-Request an. Dort sehen Sie, dass der Agent Commit-Status und einen vollständigen CI-Berichtskommentar postet.
4. Vorgang ansehen:
   • Sehen Sie sich Dino Theater an, um zu sehen, wie der CI-Agent die Änderung klassifiziert und die Pipeline ausführt.
   • Sehen Sie sich Ihren GitHub-Pull-Request an, um zu sehen, wie der CI-Agent den Commit-Status und den Abschlussbericht postet.

11. Fazit

Sie haben einen vollständigen Agenten-DevOps-Stack in Google Cloud erstellt:

Komponente	Funktion
DinoQuest (Cloud Run dinoquest)	Gemini-basiertes Spiel – React-Frontend + FastAPI-Backend
Firebase Auth + Firestore	Nutzerauthentifizierung und Speicherung von Dinosaurierprofilen
Remediation Agent (Cloud Run + Eventarc)	SRE-Agent, der OOM-Fehler und Codefehler automatisch behebt
log-router-bq-report	KI-Datenagent, der Logs in BigQuery streamt und Statistiken generiert
CIAgent (Cloud Run)	CI-Agent, der Tests eingrenzt, Images erstellt und CD über A2A aufruft
CDAgent (Cloud Run)	CD-Agent, der Canary-Bereitstellungen mit Risikobewertung und automatischem Rollback ausführt

Das gesamte Agent-Verhalten ist im Verzeichnis skills/ als Markdown-Playbooks enthalten. Sie können das Verhalten ändern, indem Sie den Skill bearbeiten, nicht den Code. Skills werden auf Antigravity mit Gemini ausgeführt und durch Angabe des auszuführenden Skills aufgerufen.