Przepływy pracy oparte na agentach – od prompta do produkcji

1. Przegląd

Witamy w „Dniu drugim”. Opublikowanie aplikacji to magiczna chwila, ale prawdziwy ruch generuje prawdziwe problemy. Zamiast spędzać czas na zmaganiach z YAML-em lub przeszukiwaniu logów, możesz stworzyć rój wyspecjalizowanych agentów, którzy będą zarządzać za Ciebie infrastrukturą operacyjną. To ćwiczenie pokazuje, jak ujednolicony stos Google Cloud (Eventarc, Cloud Run, Firestore, Cloud Build, BigQuery) ułatwia agentom bezpieczne pobieranie obiektów tajnych, przesyłanie strumieniowe logów i rozwiązywanie problemów od razu po wyjęciu z pudełka.

W tym ćwiczeniu od podstaw stworzysz DinoQuest – grę przygodową o dinozaurach opartą na Gemini – i połączysz ją z w pełni agentowym potokiem CI/CD. Po zakończeniu tego szkolenia:

• Działająca aplikacja internetowa DinoQuest uruchomiona w Cloud Run (nazwa usługi: dinoquest)
• Potok analizy logów, który przesyła strumieniowo logi Cloud Run do BigQuery i generuje interaktywny panel statystyk dotyczących gier.
• Agent naprawczy (remediation-agent) – agent naprawczy pakietu ADK, który monitoruje błędy Cloud Run i automatycznie je naprawia. Jest wdrażany jako własna usługa Cloud Run wywoływana przez Eventarc.
• Agent CI (ci-agent), który odczytuje różnice w żądaniu pull, inteligentnie określa zakres testów, tworzy obraz Dockera za pomocą Cloud Build i publikuje stan zatwierdzenia w GitHubie.
• Agent CD, który ocenia ryzyko wdrożenia, dzieli ruch, monitoruje dane i automatycznie promuje lub wycofuje zmiany.

Czego się nauczysz

• Jak wdrożyć w Cloud Run aplikację full-stack Vite + FastAPI jako pojedynczy kontener
• Konfigurowanie uwierzytelniania Firebase i Firestore w aplikacji React
• Jak utworzyć i wdrożyć agenta ADK, który reaguje na zdarzenia Pub/Sub za pomocą Eventarc
• Jak kierować dzienniki Cloud Run do BigQuery i tworzyć zapytania dotyczące statystyk gier
• Jak pisać umiejętności agentowe na potrzeby CI i wdrożenia do wczesnych testów

Czego potrzebujesz

• projekt Google Cloud z włączonymi płatnościami;
• projekt w Firebase (może to być ten sam projekt GCP);
• konto GitHub i rozwidlenie repozytorium DinoQuest;
• Dostęp do Antigravity z Gemini (narzędziem do uruchamiania agentów od Google)
• gcloud Zainstalowany i uwierzytelniony interfejs CLI – instrukcje instalacji znajdziesz poniżej.
• node ≥ 18 i npm
• python3 ≥ 3.11
• git i gh (GitHub CLI)

Instalowanie gcloud CLI

macOS

brew install --cask google-cloud-sdk

Możesz też pobrać instalator ze strony cloud.google.com/sdk/docs/install.

Windows

winget install Google.CloudSDK

Możesz też pobrać instalator Windowsa (.exe) ze strony cloud.google.com/sdk/docs/install i go uruchomić.

Po zainstalowaniu zainicjuj i uwierzytelnij:

gcloud init
gcloud auth login
gcloud auth application-default login

2. Konfigurowanie Firebase

Każdy agent potrzebuje danych, na podstawie których może wnioskować. DinoQuest korzysta z Firestore i Firebase Auth, aby zapewnić warstwę danych gotową do wdrożenia, którą nasze agenty będą później wykrywać, eksplorować i aktualizować za pomocą języka naturalnego.

Ta aplikacja została wygenerowana w AI Studio, więc jest ściśle zintegrowana z Firebase. Korzystanie z Firebase ma wiele zalet, z których najważniejsze to wstępnie zabezpieczona architektura i zarządzany dostęp do danych od samego początku, co zapewnia ochronę stanu gry od pierwszego dnia.

A. Tworzenie projektu Firebase

1. Otwórz console.firebase.google.com.
2. Kliknij Dodaj projekt (jest ukryty w opcji tworzenia nowego projektu) → wybierz istniejący projekt GCP (lub utwórz nowy).
3. Wyłącz Google Analytics, jeśli pojawi się odpowiedni komunikat → Utwórz projekt (możesz też pozostawić ustawienie domyślne).

B. Włącz uwierzytelnianie Google

1. W konsoli Firebase kliknij Bezpieczeństwo → Uwierzytelnianie (Pierwsze kroki) → Metoda logowania.
2. Kliknij Google → włącz Włącz → zapisz adres e-mail pomocy → Zapisz.

C. Dodawanie localhosta jako autoryzowanej domeny

1. Na karcie Uwierzytelnianie kliknij kartę Ustawienia.
2. W sekcji Autoryzowane domeny sprawdź, czy na liście znajduje się localhost (powinno być tam domyślnie).

D. Utwórz bazę danych Firestore

1. Kliknij Baza danych i miejsce na dane → Baza danych Firestore → Utwórz bazę danych.
2. Wybierz Standard Edition → Dalej.
3. Wybierz region us-central1 (lub dopasuj go do regionu Cloud Run).
4. Wybierz Uruchom w trybie produkcyjnym → Utwórz.

Po utworzeniu bazy danych zanotuj jej identyfikator bazy danych – będzie on wyglądać jak (default), chyba że nadasz mu nazwę.

E. Ustawianie reguł zabezpieczeń Firebase

W sekcji Baza danych Firestore → Reguły zastąp domyślne reguły tymi:

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

Kliknij Opublikuj.

F. Dodawanie aplikacji internetowej i pobieranie konfiguracji

1. Kliknij Ustawienia projektu (ikona koła zębatego) → karta Ogólne.
2. Przewiń do sekcji Twoje aplikacje → kliknij Dodaj aplikację → wybierz ikonę Sieć .
3. Nadaj mu nazwę dinoquest → Zarejestruj aplikację
4. Skopiuj firebaseConfig obiekt, który się wyświetla – za chwilę będzie Ci potrzebny.

3. Prowadzenie gry

Rola pracownika obsługi klienta: środowisko Zanim będziemy mogli uruchomić agentów, musimy stworzyć świat, którym będą zarządzać. W tym kroku wdrożymy wersję „Day One” gry DinoQuest. Spowoduje to utworzenie usługi na żywo, dzienników i stanu, które nasz rój później wykryje i którymi będzie zarządzać.

Wybierz jedną z poniższych opcji. W każdym kolejnym kroku używaj tego samego GEMINI_API_KEY – nie musisz wprowadzać żadnych innych zmian.

A. Konfigurowanie klucza interfejsu Gemini API

Opcja A – klucz interfejsu Vertex AI Gemini API (zalecana, jeśli masz projekt GCP)

Vertex AI umożliwia utworzenie klucza interfejsu Gemini API powiązanego bezpośrednio z projektem GCP i rozliczanego w ramach tego projektu przy użyciu domyślnego konta usługi projektu. Nie jest potrzebne oddzielne konto AI Studio.

1. Wyeksportuj identyfikator projektu GCP:

   export PROJECT_ID=<YOUR_PROJECT_ID>
   

2. Włącz wymagane interfejsy API i przyznaj niezbędne uprawnienia domyślnemu kontu usługi Compute Engine:

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

3. Otwórz stronę kluczy interfejsu Vertex AI API w konsoli Cloud.
4. Kliknij Utwórz dane logowania → wybierz Klucz interfejsu API.
5. W oknie tworzenia:
   • Nadaj kluczowi nazwę Dino_Key
   • Zaznacz pole Uwierzytelniaj wywołania interfejsu API za pomocą konta usługi.
   • W sekcji Konto usługi wybierz domyślne konto usługi Compute ([e-mail]).
   • Wróć do sekcji Wybierz ograniczenia interfejsu API i zaznacz GEMINI API.
   • Kliknij Utwórz.
6. Skopiuj wygenerowany klucz.

Opcja B – AI Studio (najszybsza w przypadku lokalnego programowania)

1. Otwórz aistudio.google.com.
2. Na pasku bocznym po lewej stronie kliknij Get API key (Pobierz klucz interfejsu API).
3. Kliknij Utwórz klucz interfejsu API → wybierz projekt GCP → skopiuj klucz.

W dalszych krokach klawisz jest oznaczony jako GEMINI_API_KEY – backend traktuje je identycznie.

Klonowanie repozytorium

Repozytorium kursu znajduje się w regionie https://github.com/gca-americas/dinoquest. Najpierw utwórz rozwidlenie tego repozytorium na swoim koncie GitHub. Zamiast tego poprosimy agenta o pracę nad Twoim repozytorium.

Po utworzeniu rozwidlenia sklonuj gałąź main rozwidlonego repozytorium DinoQuest i przejdź do katalogu projektu:

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

B. Konfigurowanie zmiennych środowiskowych

W każdym nowym terminalu bash otwartym podczas tego kursu upewnij się, że ustawiasz te podstawowe zmienne środowiskowe. Zastąp wartości zastępcze rzeczywistymi szczegółami projektu:

Najpierw wyeksportuj adres URL repozytorium GitHub:

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

Następnie wyeksportuj pozostałe zmienne środowiskowe:

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

Sprawdź, czy struktura wygląda prawidłowo:

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. Tworzenie pliku środowiska backendu

Najpierw wyeksportuj klucz interfejsu Gemini API:

export GEMINI_API_KEY=YOUR_GEMINI_API_KEY_FROM_STEP_2

Następnie utwórz plik .env:

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

C. Włączanie Sprawdzania aplikacji Firebase / konta usługi (w przypadku Cloud Run)

Gdy backend jest uruchomiony w Cloud Run, do komunikacji z Firebase używa domyślnego uwierzytelniania aplikacji – nie jest potrzebny plik klucza konta usługi. firebase_admin.initialize_app() w backend/main.py automatycznie odbierze to połączenie.

W przypadku programowania lokalnego uwierzytelnij się tylko raz:

gcloud auth application-default login

D. Tworzenie pliku konfiguracyjnego aplikacji w Firebase

W katalogu frontend/ utwórz plik firebase-applet-config.json z konfiguracją z poprzedniego kroku:

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

Uwaga: firestoreDatabaseId powinien być zgodny z identyfikatorem bazy danych utworzonym w poprzednim kroku. Jeśli używasz domyślnego ustawienia, pozostaw wartość "(default)".

Zatwierdź zmiany w repozytorium:

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

C. Lokalne uruchamianie DinoQuest

1. Włącz wymagane interfejsy API

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

Skrypt start.sh tworzy frontend React i przekazuje terminal do backendu FastAPI, który wyświetla skompilowane pliki statyczne:

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

Otwórz adres http://localhost:8000 w przeglądarce. Powinien pojawić się ekran tytułowy DinoQuest. Zaloguj się przez Google, wygeneruj pierwszego dinozaura i potwierdź, że został zapisany w Firestore.

Rozwiązywanie problemów: jeśli widzisz pustą stronę lub błędy uwierzytelniania Firebase, sprawdź, czy frontend/firebase-applet-config.json ma prawidłowe wartości i czy localhost znajduje się na liście autoryzowanych domen.

E. Wdrażanie DinoQuest w Cloud Run

1. Ustawianie projektu

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

3. Tworzenie repozytorium Artifact Registry

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

4. Przechowywanie klucza interfejsu Gemini API w usłudze 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. Kompilowanie obrazu kontenera za pomocą Cloud Build

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

Spowoduje to uruchomienie wieloetapowego pliku Dockerfile: najpierw skompiluje aplikację React, a potem spakuje wynik do obrazu FastAPI. Zajmie to około 3–5 minut.

6. Wdrożenie w Cloud Run

Najpierw wyeksportuj adres e-mail administratora:

export ADMIN_EMAIL=<YOUR_TEST_ACCOUNT_EMAIL>

Następnie wdróż usługę:

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"

Po zakończeniu wykonywania polecenia Cloud Run wyświetli adres URL usługi. Skopiuj ten adres URL – będzie on potrzebny do autoryzacji domeny w Firebase.

7. Autoryzowanie domeny Cloud Run w Firebase

Aby umożliwić użytkownikom logowanie się z wdrożonej aplikacji, musisz dodać adres URL Cloud Run do autoryzowanych domen Firebase:

1. Wróć do konsoli Firebase → Uwierzytelnianie → Ustawienia → Autoryzowane domeny.
2. Kliknij Dodaj domenę.
3. Wklej adres URL usługi Cloud Run (np.dinoquest-xxxxx.us-central1.run.app) – usuń prefiks https://.
4. Kliknij Zapisz.

8. Wypełnianie tabeli wyników danymi

Aby nadać grze początkową „żywotność” i zapewnić agentom dane, możesz wypełnić tabelę wyników początkowymi wynikami.

1. Upewnij się, że jesteś w katalogu głównym dinoquest:

   cd ~/dinoquest
   

2. Utwórz i aktywuj środowisko wirtualne:

   python3 -m venv venv
   source venv/bin/activate
   

3. Zainstaluj wymagane zależności Firestore:

   pip install google-cloud-firestore
   

4. Uruchom skrypt początkowy:

   python3 prep/seed_scores.py
   

5. Dezaktywuj środowisko wirtualne:

   deactivate
   

Teraz możesz otworzyć URL usługi w przeglądarce – DinoQuest jest już w pełni aktywna.

4. Konfigurowanie Dino Theater

Rola agenta: wizualizator. Jak monitorować zespół autonomicznych agentów? Dino Theater zapewnia wgląd w czasie rzeczywistym w umysł roju agentów. Zamiast wpatrywać się w logi terminala, możesz obserwować, jak agenci rozumują, komunikują się ze sobą i wykonują zadania w chmurze w panelu wizualnym na żywo.

A. Wdrażanie Dino Theater w Cloud Run

Najpierw wróć do katalogu głównego i skopiuj kod Dino Theater:

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

1. Utwórz i wypchnij kontener:

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

2. Skonfiguruj konto usługi i uprawnienia:

   # 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. Wdróż aplikację:

   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
   

   Uwaga: --min-instances=1 zalecamy utrzymywanie połączenia SSE między zdarzeniami.
4. Sprawdź, czy działa: otwórz w przeglądarce wdrożony adres URL usługi (np. https://dino-theater-xxx-uc.a.run.app/demo).

5. Agentic DevOps w IDE

Rola pracownika obsługi klienta: Native Antigravity. Aby wypełnić lukę między IDE a chmurą, łączymy Antigravity z zarządzanymi serwerami MCP Google Cloud. Dzięki temu agent natywny „widzi” Twój projekt, co pozwala mu analizować logi, sprawdzać dane i wyciągać wnioski na temat infrastruktury bez konieczności przełączania się między kluczami interfejsu API a konsolą.

Zanim uruchomisz jakiekolwiek umiejętności, musisz skonfigurować dostęp Antigravity do Google Cloud i wczytać podręczniki umiejętności DinoQuest.

A. Instalowanie usługi MCP zarządzanej przez Google

Zarządzana usługa MCP od Google zapewnia dostęp do wszystkich interfejsów Google Cloud API za pomocą jednego hostowanego punktu końcowego.

Uwierzytelnianie za pomocą domyślnego uwierzytelniania aplikacji:

gcloud auth application-default login

B. Konfigurowanie pliku mcp_config.json

Utwórz lub zaktualizuj mcp_config.json w katalogu konfiguracji Antigravity (zwykle ~/.gemini/antigravity/mcp_config.json) lub w konsoli. Dzięki temu Antigravity uzyska dostęp do narzędzi Google Cloud i GitHub, których potrzebują umiejętności:

{
  "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. Wczytywanie umiejętności do Antigravity (opcjonalnie)

Antigravity wykrywa umiejętności w określonych standardowych katalogach. Skopiuj umiejętności DinoQuest ze sklonowanego repozytorium do globalnego folderu umiejętności 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. Ponowne uruchomienie Antigravity(opcjonalnie)

Aby zastosować mcp_config.json zmiany i wczytać nowo skopiowane umiejętności, ponownie uruchom aplikację Antigravity.

Po ponownym uruchomieniu:

1. Sprawdź, czy serwery MCP google i github mają w Ustawieniach zielony stan „Połączono”.
2. Sprawdź, czy umiejętności DinoQuest pojawiają się na liście umiejętności.

Uwaga: każda umiejętność ma u góry SKILL.md tabelę ## Configuration. Po skopiowaniu zaktualizuj wartości w sekcji ~/.gemini/antigravity/skills//SKILL.md, aby pasowały do Twojego projektu.

E. Naprawianie usługi w chmurze w lokalnym środowisku IDE

1. Wywołaj błąd: otwórz w przeglądarce wdrożony adres URL DinoQuest (z ostatniego kroku).
2. Otwórz tabelę wyników: kliknij przycisk Tabela wyników. Obecna implementacja tablicy wyników jest celowo nieefektywna – próbuje wczytać do pamięci ogromną ilość danych, co powoduje błąd braku pamięci (OOM).
3. W Antigravity Agent Manager (Agent HUB) poproś o pomoc w rozwiązaniu problemu i usunięciu jego przyczyny.

• prompt 1: Find out what's wrong with dinoquest.
• prompt 2: Can you look at the code for the Dinoquest game and fix what caused the out of memory error?

6. Przesyłanie strumieniowe logów do BigQuery i generowanie analiz

Rola agenta: Agent danych. Przekształcanie surowych logów w przydatną strategię dotyczącą produktu nie powinno zajmować godzin ręcznego przetwarzania danych. Korzystając z pakietu Data Agent Kit i BigQuery MCP, tworzymy potok „Zero ETL”, który przesyła logi bezpośrednio do BigQuery, co pozwala agentowi wygenerować panel analityczny premium w mniej niż 2 minuty.

log-router-bq-report Umiejętność konfiguruje ujście Cloud Logging, które stale przesyła strumieniowo logi Cloud Run DinoQuest do BigQuery, a następnie wysyła zapytania do danych, aby generować raporty o ruchu i statystyki dotyczące gry.

A. Konfigurowanie zmiennych umiejętności

Otwórz plik skills/log-router-bq-report/SKILL.md w repozytorium DinoQuest i zaktualizuj sekcję Configuration (Konfiguracja) u góry:

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

B. Uruchom umiejętność w Antigravity

Otwórz Antigravity z repozytorium DinoQuest jako kontekstem i poproś Gemini:

Run the log-router-bq-report skill

Umiejętność:

1. Automatyczne rozwiązywanie problemów z projektem GCP
2. Sprawdź, czy odbiornik BigQuery już istnieje – jeśli nie, utworzy zbiór danych i odbiornik.
3. Przyznaj uprawnienia IAM: przyzna to rolę Edytujący dane BigQuery w zbiorze danych kontu usługi writerIdentity.

Uwaga: podobnie jak w przypadku ujścia Eventarc, w trakcie tego procesu może pojawić się ostrzeżenie z gcloud: „Pamiętaj, aby przyznać kontu usługi service-... rolę edytującego dane BigQuery w zbiorze danych”. Umiejętność obsługuje to automatycznie.

C. Generowanie raportu za pomocą Antigravity

Wystarczy poprosić Antigravity o „skonfigurowanie ujścia logów BigQuery i wygenerowanie raportu analitycznego”. Pracownik obsługi klienta:

1. Skonfiguruj infrastrukturę: utwórz zbiór danych BigQuery i miejsce docelowe Cloud Logging.
2. Zarządzaj uprawnieniami: automatycznie przyznawaj niezbędne role IAM tożsamości zapisującego ujścia.
3. Generowanie statystyk: analizuj dzienniki i twórz interaktywny panel HTML klasy premium z telemetrią gry i analizą współczynnika wygranych.

7. Agent samonaprawczy

Rola agenta: agent SRE. Jeśli usługa produkcyjna ulegnie awarii o 2:00 w nocy, nie musisz się budzić. Ten agent jest Twoim pierwszym kontaktem. Wywoływana przez logi błędów Cloud Run za pomocą Eventarc, automatycznie analizuje awarię, proponuje rozwiązanie i uruchamia potok naprawczy – wszystko to, zanim zalogujesz się w konsoli.

DinoAgent to agent ADK, który nasłuchuje dzienników błędów Cloud Run za pomocą Eventarc, diagnozuje przyczynę główną i automatycznie rozwiązuje problem – zwiększając pamięć, wycofując ruch lub przesyłając żądanie pull z poprawką kodu w GitHubie.

A. Klonowanie repozytorium agenta do usuwania problemów

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

Struktura projektu:

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. Konfigurowanie dostępu do GitHub (ścieżka poprawek kodu)

Ścieżka poprawek kodu klonuje repozytorium DinoQuest, odczytuje pliki źródłowe, stosuje poprawki i otwiera żądania scalenia. Wymaga to osobistego tokena dostępu do GitHuba z zakresem repo.

1. Otwórz stronę github.com/settings/tokens → Generate new token (classic) (Wygeneruj nowy token (klasyczny)).
2. Nadaj mu nazwę, wybierz repo zakres → Wygeneruj token → skopiuj go.

Przechowuj go w usłudze Secret Manager:

Najpierw wyeksportuj token GitHub:

export GH_TOKEN=ghp_YOUR_TOKEN_HERE

Następnie utwórz obiekt tajny:

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

C. Konfigurowanie powiadomień Slacka (opcjonalnie)

Po zakończeniu procesu naprawy DinoAgent publikuje podsumowanie w kanale Slacka.

1. Otwórz api.slack.com/apps → Create New App (Utwórz nową aplikację) → From scratch (Od podstaw).
2. Nadaj mu nazwę DinoAgent, wybierz obszar roboczy → Utwórz aplikację
3. W sekcji Funkcje → Przychodzące webhooki włącz
4. Kliknij Add New Webhook to Workspace (Dodaj nowy webhook do obszaru roboczego) → wybierz kanał → Allow (Zezwól).
5. Skopiuj adres URL webhooka (https://hooks.slack.com/services/...).

Przechowuj go w usłudze 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. Utwórz konto usługi 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

Przyznaj mu dostęp do obiektów tajnych:

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

E. Kompilowanie i wdrażanie DinoAgent w 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. Połącz aktywator Eventarc

Utwórz temat Pub/Sub, aby otrzymywać dzienniki błędów Cloud Run:

gcloud pubsub topics create cloud-run-errors

Utwórz miejsce docelowe Cloud Logging, które filtruje logi błędów z usługi dinoquest i kieruje je do tematu:

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"

Uwaga: po uruchomieniu powyższego polecenia gcloud wyświetli komunikat Info: „Pamiętaj, aby przyznać konto usługi:service-... rolę publikującego w Pub/Sub w temacie”. Właśnie tym zajmiemy się w następnym kroku.

Przyznaj tożsamości zapisującej ujścia (kontu usługi wymienionemu w ostrzeżeniu) uprawnienia do publikowania:

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"

Sprawdź, czy jest aktywny:

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

Przyznaj Eventarc uprawnienia do wywoływania agenta naprawczego:

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

Utwórz aktywator 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}

Proces naprawy jest teraz w pełni zautomatyzowany. DinoAgent nie tylko skaluje infrastrukturę, ale też przeprowadza szczegółową analizę przyczyn źródłowych w kodzie aplikacji, stosuje poprawkę semantyczną i wykorzystuje komunikację Agent-to-Agent (A2A), aby przekazać poprawkę do agenta CI w celu weryfikacji i wdrożenia. Szczegóły implementacji znajdziesz w bazie kodu reme-agent.

8. Konfigurowanie agenta CI

Rola agenta: potok CI. Nie musisz już zmagać się ze złożonymi plikami YAML ani ręcznymi skryptami kompilacji. Ten agent zarządza operacyjnymi aspektami Twoich żądań. Odczytuje zmiany w kodzie, rozumie kontekst, określa zakres niezbędnych testów i kompiluje obrazy Dockera za pomocą Cloud Build, dzięki czemu każdy commit jest „zatwierdzony przez agenta” przed dotarciem do głównej gałęzi.

ci-agent to autonomiczny agent potoku CI wdrożony jako usługa Cloud Run. Przesyła kompilacje Dockera do Cloud Build, sprawdza, czy zostały ukończone, weryfikuje obraz w Artifact Registry i wysyła raport do GitHuba.

Dlaczego warto używać agenta w potoku CI? W przeciwieństwie do tradycyjnych statycznych skryptów, agentowy potok CI zapewnia:

1. Klasyfikacja zakresu poznawczego: inteligentnie określa wymaganą głębokość testu – przełącza się między sprawdzaniem typów, testami jednostkowymi lub pełnymi pakietami integracyjnymi – na podstawie semantycznego wpływu zmian w kodzie.
2. Autonomiczne zarządzanie żądaniami scalenia: agent może automatycznie tworzyć żądania scalenia, publikować szczegółowe podsumowania zmian, a nawet zarządzać skanowaniem poufnych danych i audytami bezpieczeństwa bez interwencji człowieka.
3. Diagnostyka błędów w czasie rzeczywistym: gdy kompilacja się nie powiedzie, agent nie tylko wyświetla dzienniki, ale też analizuje zrzut stosu, identyfikuje prawdopodobną przyczynę i publikuje czytelną dla człowieka diagnozę bezpośrednio w żądaniu pull request.

A. Klonowanie repozytorium CIAgent

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

B. Tworzenie konta usługi 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. Łączenie repozytorium GitHub z Cloud Build

CIAgent przesyła kompilacje za pomocą repoSource, co wymaga połączenia repozytorium GitHub z Cloud Build Developer Connect.

1. Otwórz konsolę GCP → Cloud Build → Repozytoria.
2. Kliknij Połącz repozytorium.
3. Wybierz GitHub (aplikacja Cloud Build na GitHubie).
4. Autoryzuj i wybierz repozytorium YOUR_GITHUB_USERNAME/dinoquest
5. Gdy pojawi się prośba o utworzenie wyzwalacza, kliknij Połącz i Pomiń.
6. Zanotuj nazwę połączenia (domyślnie jest to zwykle nazwa użytkownika GitHub lub podobna).

D. Przyznawanie agentowi CI dostępu do obiektów tajnych

Użyjemy utworzonych wcześniej obiektów tajnych dla 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. Kompilowanie i wdrażanie CIAgent w 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. Konfigurowanie polecenia po ukośniku w Slacku

1. Otwórz stronę api.slack.com/apps → Utwórz nową aplikację → Od zera.
2. Nadaj mu nazwę CIAgent i wybierz obszar roboczy → Utwórz aplikację
3. W sekcji Funkcje kliknij Polecenia rozpoczynające się ukośnikiem → Utwórz nowe polecenie.
4. Polecenie: /runci
5. Adres URL żądania: adres URL usługi CIAgent Cloud Run z powyższego przykładu z dodanym ciągiem /slack (np.https://ci-agent-xxx-.us-central1.run.app/slack).
6. Krótki opis: Trigger CI
7. Zapisz
8. W sekcji Ustawienia → Zainstaluj aplikację kliknij Zainstaluj w Workspace i Zezwól.

Agent CI działa jako „mózg” oparty na niezawodnych usługach Google Cloud, takich jak Cloud Build i Artifact Registry. Po zweryfikowaniu kompilacji wywołuje ona agenta CD za pomocą A2A, co rozpoczyna ostatnią fazę wdrażania i zapewnia płynne przejście między cyklami kompilacji i wypuszczania.

9. Konfigurowanie wdrożenia

Rola agenta: CD Agent. Wdrożenie nie powinno być skokiem na głęboką wodę. Ten agent zarządza ryzykiem za Ciebie. Ocenia bezpieczeństwo wdrożenia, zarządza podziałem ruchu w przypadku wdrożenia kanaryjnego i monitoruje dane w czasie rzeczywistym, aby zdecydować, czy promować wersję, czy ją wycofać. Jest to ostatni element w roju autonomicznych agentów.

cd-agent to autonomiczny agent wdrożenia do wczesnych testów wdrożony jako usługa Cloud Run. Otrzymuje żądania wdrożenia A2A z ci-agent, oblicza wynik ryzyka, ustawia procent kanarkowy skalibrowany pod kątem ryzyka, monitoruje dane i automatycznie promuje lub wycofuje zmiany. Uczy się też na podstawie poprzednich wdrożeń z użyciem Firestore.

Bezpośrednie połączenie agentów tworzy „potok kognitywny”, w którym każde przekazanie to bogate przeniesienie intencji i kontekstu. W przeciwieństwie do tradycyjnych webhooków komunikacja A2A umożliwia:

1. Inteligentne udostępnianie kontekstu: agenci przekazują całą historię sesji, różnice w ocenach PR i wyniki oceny ryzyka, dzięki czemu kolejny agent przed rozpoczęciem pracy ma pełny kontekst.
2. Cognitive Handshakes: agenci mogą negocjować bramki. Na przykład agent CD może poprosić agenta CI o przeprowadzenie konkretnych testów sprawdzających podczas wdrożenia do wczesnych testów, aby zweryfikować poprawkę w czasie rzeczywistym.
3. Współpraca w zakresie naprawy: jeśli wdrożenie się nie powiedzie, agent CD może proaktywnie powiadomić agenta naprawy o nieprawidłowych wskaźnikach, inicjując autonomiczną analizę pierwotnej przyczyny problemu, zanim jeszcze zostanie powiadomiony człowiek.
4. Negocjacje dotyczące zasobów: agenci mogą negocjować potrzeby w zakresie infrastruktury. Na przykład agent CI może poprosić agenta naprawczego o udostępnienie większej mocy obliczeniowej na potrzeby kompilacji, jeśli wykryje refaktoryzację na dużą skalę, a agent CD może zaproponować skalowanie klastra produkcyjnego przed ważną wersją.
5. Konsensus wielu agentów: w przypadku zmian o wysokim ryzyku wielu agentów (np.agent ds. bezpieczeństwa i agent CD) może przeprowadzić „wspólne zatwierdzenie” za pomocą A2A, co zapewnia, że kod nie tylko jest kompilowany i wdrażany, ale także przed wprowadzeniem do środowiska produkcyjnego jest zgodny z zasadami bezpieczeństwa.

A. Klonowanie repozytorium CDAgent

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

B. Tworzenie bazy danych Firestore

CDAgent przechowuje wzorce pamięci wdrożenia w Firestore:

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

(Jeśli masz już utworzoną bazę danych w tym projekcie, możesz pominąć ten krok).

C. Tworzenie konta usługi 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. Przyznawanie agentowi CDAgent dostępu do obiektów tajnych

Ponownie użyjemy tokena GitHub i elementu webhook Slack z wcześniejszego etapu oraz przyznamy dostęp do klucza interfejsu Gemini API kontu usługi obliczeniowej Cloud Run, aby wdrożona aplikacja mogła go używać:

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. Kompilowanie i wdrażanie CDAgent w 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

Uwaga: --min-instances=1 --no-cpu-throttling utrzymuje instancję w stanie gotowości, aby mogła szybko odpowiadać na polecenia Slacka i A2A.

Agent CD jest ostatnim strażnikiem środowiska produkcyjnego. Ocenia ryzyko każdego wdrożenia, przeprowadza test kanarkowy z uwzględnieniem ryzyka i monitoruje dane w czasie rzeczywistym. Jeśli wykryje jakiekolwiek anomalie, automatycznie przywróci poprzednią wersję.

10. Skalowanie: odblokowywanie poziomu 2 za pomocą roju agentów

A. Testowanie pełnego roju

1. Wywołaj błąd: otwórz w przeglądarce wdrożony adres URL DinoQuest (z ostatniego kroku).
2. Otwórz tabelę wyników: kliknij przycisk Tabela wyników. Obecna implementacja tablicy wyników jest celowo nieefektywna – próbuje wczytać do pamięci ogromną ilość danych, co powoduje błąd braku pamięci (OOM).
3. Poczekaj na agenta: w ciągu około 60 sekund remediation-agent otrzyma zdarzenie błędu za pomocą Eventarc i rozpocznie diagnozę.
4. Sprawdź Slacka: na kanale Slacka powinno pojawić się powiadomienie podobne do tego:Podsumowanie działań naprawczych DinoAgent
   • Usługa: dinoquest
   • Wersja, która nie przeszła weryfikacji: dinoquest-xxxx-xxxx
   • Dowód: „Przekroczono limit pamięci 128 MiB, wykorzystano 13x MiB”.
   • Dlaczego ta zmiana była niekorzystna: punkt końcowy /api/leaderboard był nieefektywnie xxxxx, co spowodowało błąd braku pamięci.
   • Podjęte działanie: zwiększono pamięć z xMi do yGi w przypadku usługi dinoquest. Utworzono nową wersję.
   • Root-cause PR: https://github.com/YOUR_USERNAME/DinoQuest/pull/x
5. Weryfikowanie poprawek:
   • GitHub sprawdź, czy w repozytorium jest nowa gałąź i żądanie pull. Agent poprawił kod aplikacji, aby usunąć wyciek pamięci.
   • Cloud Run: w konsoli GCP zobaczysz nową wersję usługi dinoquest z zaktualizowaną alokacją pamięci.
   • Tablica wyników: spróbuj ponownie wyświetlić tablicę wyników. Teraz powinna się załadować prawidłowo dzięki zwiększonej pamięci i poprawionemu kodowi.

B. Ewolucja: wdrażanie logiki gry na poziomie 2

Dodasz nową, ważną funkcję: poziom 2 (niszczyciel asteroid). Dzięki temu dinozaury z wysokimi wynikami mogą przejść do nowego trybu gry.

1. Wróć do repozytorium dinoquest:

   cd ~/dinoquest
   

2. Tworzenie i przełączanie się na nową gałąź:

   git checkout -b level_2
   

3. Zastosuj poprawkę poziomu 2: uruchom podany skrypt, aby zastosować w lokalnej bazie kodu zasoby, komponenty i logikę gry na poziomie 2:

   bash level_2_backup/levelup.sh
   

4. Zatwierdź i prześlij zmiany:

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

Zamiast używać curl do ręcznego wywoływania agenta, użyjemy skonfigurowanego wcześniej polecenia Slack. W ten sposób wchodzisz w interakcje z autonomicznym potokiem CI w rzeczywistym scenariuszu.

1. Otwórz Slacka i przejdź do dowolnego kanału, na którym jest zainstalowana aplikacja CIAgent.
2. Uruchom kompilację CI, wpisując to polecenie:

   /runci run ci on branch level_2
   

3. Monitoruj postępy:
   • Slack: agent potwierdzi Twoje polecenie i będzie publikować aktualizacje w miarę postępów w kompilacji.
   • Dino Theater: obserwuj „dymki” podczas klasyfikowania zmiany przez agenta, przesyłania zadania Cloud Build i komunikowania się z agentem CD.
   • GitHub sprawdź level_2 żądanie pull. Zobaczysz agenta publikującego stany zatwierdzenia i pełny komentarz do raportu CI.
4. Obserwuj proces:
   • Sprawdź Dino Theater, aby zobaczyć, jak agent CI analizuje zmianę, klasyfikuje ją i uruchamia potok.
   • Sprawdź żądanie pull w GitHubie, aby zobaczyć, jak agent CI publikuje stan zatwierdzenia i raport końcowy.

11. Podsumowanie

Masz już pełny stos DevOps oparty na agentach w Google Cloud:

Komponent	Działanie
DinoQuest (Cloud Run dinoquest)	Gra oparta na Gemini – frontend w React i backend w FastAPI
Uwierzytelnianie Firebase + Firestore	Uwierzytelnianie użytkowników i przechowywanie profili dinozaurów
Agent naprawczy (Cloud Run + Eventarc)	Agent SRE, który automatycznie usuwa błędy OOM i błędy w kodzie
log-router-bq-report	Agent danych, który przesyła strumieniowo logi do BigQuery i generuje statystyki
CIAgent (Cloud Run)	Agent CI, który określa zakres testów, tworzy obrazy i wywołuje CD za pomocą A2A
CDAgent (Cloud Run)	Agent CD, który przeprowadza wdrożenia wczesnych testów z oceną ryzyka i automatycznym wycofywaniem

Całe zachowanie agenta znajduje się w skills/ w postaci przewodników w formacie Markdown – zmień zachowanie, edytując umiejętność, a nie kod. Umiejętności działają na platformie Antigravity z Gemini i są wywoływane przez podanie agentowi, którą umiejętność ma uruchomić.