एजेंट फ़र्स्ट वर्कफ़्लो - प्रॉम्प्ट से लेकर प्रोडक्शन तक

1. खास जानकारी

‘दूसरा दिन' में आपका स्वागत है. ऐप्लिकेशन बनाने और उसे ‘पब्लिश करें' पर क्लिक करने से, ऐप्लिकेशन लॉन्च हो जाता है. हालांकि, असल दुनिया में ऐप्लिकेशन का इस्तेमाल करने वाले लोगों की वजह से, ऐप्लिकेशन में समस्याएं आ सकती हैं. YAML से जूझने या लॉग ढूंढने के बजाय, अब खास एजेंटों का एक ग्रुप बनाया जा सकता है. ये एजेंट, आपके लिए ऑपरेशनल प्लंबिंग को मैनेज करेंगे. इस कोडलैब में बताया गया है कि Google Cloud का यूनिफ़ाइड स्टैक (Eventarc, Cloud Run, Firestore, Cloud Build, BigQuery) एजेंट के लिए, सीक्रेट को सुरक्षित तरीके से फ़ेच करना, लॉग स्ट्रीम करना, और समस्याओं को तुरंत ठीक करना कितना आसान बनाता है.

खास जानकारी

इस कोडलैब में, आपको DinoQuest बनाने का तरीका बताया जाएगा. यह Gemini की मदद से काम करने वाला डायनासोर एडवेंचर गेम है. इसे शुरू से बनाया जाएगा और पूरी तरह से एजेंटिक सीआई/सीडी पाइपलाइन से जोड़ा जाएगा. इस कोर्स को पूरा करने के बाद, आपको ये सारे काम करने में मदद मिलेगी:

  • Cloud Run पर चल रहा DinoQuest वेब ऐप्लिकेशन (सेवा का नाम: dinoquest)
  • लॉग ऐनलिटिक्स पाइपलाइन, जो Cloud Run लॉग को BigQuery में स्ट्रीम करती है और गेम से जुड़ी अहम जानकारी वाला इंटरैक्टिव डैशबोर्ड जनरेट करती है
  • समस्या ठीक करने वाला एजेंट (remediation-agent) — यह एडीके का समस्या ठीक करने वाला एजेंट है. यह Cloud Run से जुड़ी गड़बड़ियों पर नज़र रखता है और उन्हें अपने-आप ठीक कर देता है. इसे Cloud Run की अपनी सेवा के तौर पर डिप्लॉय किया जाता है. इसे Eventarc ट्रिगर करता है
  • एक सीआई एजेंट (ci-agent), जो आपके पीआर के अंतर को पढ़ता है, टेस्ट को स्मार्ट तरीके से स्कोप करता है, Cloud Build के ज़रिए Docker इमेज बनाता है, और GitHub पर कमिट की स्थिति वापस पोस्ट करता है
  • सीडी एजेंट, डिप्लॉयमेंट के जोखिम का आकलन करता है, ट्रैफ़िक को बांटता है, मेट्रिक की निगरानी करता है, और अपने-आप प्रमोशन करता है या रोल बैक करता है

आपको क्या सीखने को मिलेगा

  • Cloud Run पर, फ़ुल-स्टैक Vite + FastAPI ऐप्लिकेशन को एक कंटेनर के तौर पर डिप्लॉय करने का तरीका
  • React ऐप्लिकेशन के लिए, Firebase Auth और Firestore को कॉन्फ़िगर करने का तरीका
  • Eventarc की मदद से, Pub/Sub इवेंट पर प्रतिक्रिया देने वाला ADK एजेंट कैसे बनाया और डिप्लॉय किया जाता है
  • Cloud Run के लॉग को BigQuery पर कैसे रूट करें और गेम के आंकड़ों से जुड़ी क्वेरी कैसे करें
  • सीआई और कैनरी डिप्लॉयमेंट के लिए, एजेंट की भूमिका निभाने वाले कौशल कैसे लिखें

आपको किन चीज़ों की ज़रूरत होगी

  • बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट
  • एक Firebase प्रोजेक्ट (यह GCP प्रोजेक्ट भी हो सकता है)
  • GitHub खाता और DinoQuest रिपॉज़िटरी का फ़ोर्क
  • Gemini (Google का एजेंट रनर) के साथ Antigravity का ऐक्सेस
  • gcloud सीएलआई इंस्टॉल और पुष्टि हो गई हो — इंस्टॉल करने के निर्देश नीचे दिए गए हैं
  • node ≥ 18 and npm
  • python3 ≥ 3.11
  • git और gh (GitHub CLI)

gcloud सीएलआई इंस्टॉल करना

macOS

brew install --cask google-cloud-sdk

इसके अलावा, cloud.google.com/sdk/docs/install से इंस्टॉलर डाउनलोड करें.

Windows

winget install Google.CloudSDK

इसके अलावा, Windows इंस्टॉलर (.exe) को cloud.google.com/sdk/docs/install से डाउनलोड करके चलाएं.

इंस्टॉल करने के बाद, इसे शुरू करें और पुष्टि करें:

gcloud init
gcloud auth login
gcloud auth application-default login

2. Firebase सेट अप करना

हर एजेंट को जवाब देने के लिए डेटा की ज़रूरत होती है. DinoQuest, Firestore और Firebase Auth का इस्तेमाल करता है. इससे प्रोडक्शन के लिए तैयार डेटा लेयर मिलती है. हमारे एजेंट बाद में इस डेटा लेयर को खोजेंगे, एक्सप्लोर करेंगे, और नैचुरल लैंग्वेज का इस्तेमाल करके अपडेट करेंगे.

इस ऐप्लिकेशन को AI Studio की मदद से जनरेट किया गया है. इसलिए, इसे Firebase के साथ इंटिग्रेट किया गया है. Firebase का इस्तेमाल करने के कई फ़ायदे हैं. इनमें सबसे अहम फ़ायदा यह है कि इसमें पहले से सुरक्षित आर्किटेक्चर होता है. साथ ही, इसमें डेटा ऐक्सेस को मैनेज करने की सुविधा भी होती है. इससे यह पक्का होता है कि आपके गेम की स्थिति पहले दिन से ही सुरक्षित रहे.

A. Firebase प्रोजेक्ट बनाना

  1. console.firebase.google.com पर जाएं
  2. प्रोजेक्ट जोड़ें पर क्लिक करें (यह 'नया प्रोजेक्ट बनाएं' विकल्प में छिपा होता है) → अपना मौजूदा GCP प्रोजेक्ट चुनें या नया प्रोजेक्ट बनाएं
  3. अगर Google Analytics को बंद करने का विकल्प दिखता है, तो उसे बंद करें → प्रोजेक्ट बनाएं (इसके अलावा, डिफ़ॉल्ट सेटिंग का इस्तेमाल भी किया जा सकता है)

B. Google Authentication की सुविधा चालू करना

  1. Firebase कंसोल में, Security → Authentication (Get started) → Sign-in method पर जाएं
  2. Google पर क्लिक करें → चालू करें टॉगल करें → सहायता के लिए इस्तेमाल किया जाने वाला ईमेल पता सेव करें → सेव करें

C. स्थानीय होस्ट को अनुमति वाले डोमेन के तौर पर जोड़ना

  1. Authentication में रहते हुए, Settings टैब पर क्लिक करें
  2. अनुमति वाले डोमेन में जाकर पुष्टि करें कि localhost की सूची में शामिल है. यह डिफ़ॉल्ट रूप से शामिल होना चाहिए

डी॰ Firestore डेटाबेस बनाना

  1. डेटाबेस और स्टोरेज → Firestore डेटाबेस → डेटाबेस बनाएं पर जाएं
  2. Standard Edition → आगे बढ़ें को चुनें
  3. इलाका चुनें us-central1 या Cloud Run का इलाका चुनें
  4. प्रोडक्शन मोड में शुरू करें → बनाएं को चुनें

डेटाबेस बनाने के बाद, अपने डेटाबेस का आईडी नोट कर लें. अगर आपने इसका नाम नहीं रखा है, तो यह (default) जैसा दिखेगा.

ई॰ Firebase के सुरक्षा नियम सेट करना

Firestore डेटाबेस → नियम में जाकर, डिफ़ॉल्ट नियमों को इससे बदलें:

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

पब्लिश करें पर क्लिक करें.

F. वेब ऐप्लिकेशन जोड़ना और कॉन्फ़िगरेशन पाना

  1. प्रोजेक्ट सेटिंग (गियर आइकॉन) → सामान्य टैब पर जाएं
  2. स्क्रोल करके आपके ऐप्लिकेशन पर जाएं → ऐप्लिकेशन जोड़ें पर क्लिक करें → वेब आइकॉन () चुनें
  3. इसे dinoquest नाम दें → ऐप्लिकेशन रजिस्टर करें
  4. दिखाया गया firebaseConfig ऑब्जेक्ट कॉपी करें. आपको इसकी ज़रूरत पड़ेगी

3. गेम चलाना

एजेंट की भूमिका: एनवायरमेंट. इससे पहले कि हम अपने एजेंट को काम पर लगाएं, हमें उनके लिए एक दुनिया बनानी होगी. इस चरण में, हम DinoQuest का "Day One" वर्शन डिप्लॉय करेंगे. इससे लाइव सेवा, लॉग, और स्थिति बनती है. इन्हें बाद में हमारा स्वार्म ढूंढकर मैनेज करेगा.

खास जानकारी

नीचे दिए गए दो विकल्पों में से एक विकल्प चुनें. या GEMINI_API_KEY बनाता है, जिसका इस्तेमाल आपको बाद के हर चरण में एक जैसा करना होता है. इसमें कोई और बदलाव करने की ज़रूरत नहीं होती.

A. Gemini API पासकोड सेट अप करना

Vertex AI की मदद से, Gemini API का पासकोड बनाया जा सकता है. यह पासकोड सीधे तौर पर आपके GCP प्रोजेक्ट से जुड़ा होता है और इसके लिए बिलिंग भी इसी प्रोजेक्ट से की जाती है. इसके लिए, प्रोजेक्ट के डिफ़ॉल्ट सेवा खाते का इस्तेमाल किया जाता है. इसके लिए, अलग से AI Studio खाते की ज़रूरत नहीं होती.

  1. अपना GCP प्रोजेक्ट आईडी एक्सपोर्ट करें:
    export PROJECT_ID=<YOUR_PROJECT_ID>
  2. ज़रूरी एपीआई चालू करें और 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}-compute@developer.gserviceaccount.com" \
  --role="roles/aiplatform.user" \
  --condition=None
  3. Cloud Console में Vertex AI API पासकोड पेज खोलें
  4. क्रेडेंशियल बनाएं पर क्लिक करें → एपीआई पासकोड चुनें
  5. बनाने के डायलॉग बॉक्स में:
    • कुंजी को Dino_Key नाम दें
    • सेवा खाते के ज़रिए एपीआई कॉल की पुष्टि करें बॉक्स पर सही का निशान लगाएं
    • 'सेवा खाता' में जाकर, डिफ़ॉल्ट कंप्यूट सेवा खाता (PROJECT_NUMBER-compute@developer.gserviceaccount.com) चुनें
    • एपीआई के इस्तेमाल से जुड़ी पाबंदियां चुनें में वापस जाकर, GEMINI API पर सही का निशान लगाएं
    • बनाएं पर क्लिक करें
  6. जनरेट की गई कुंजी को कॉपी करें.

दूसरा विकल्प — AI Studio (स्थानीय डेवलपर के लिए सबसे तेज़)

  1. aistudio.google.com खोलें
  2. बाईं ओर मौजूद साइडबार में, Get API key पर क्लिक करें
  3. एपीआई पासकोड बनाएं पर क्लिक करें → अपना GCP प्रोजेक्ट चुनें → पासकोड कॉपी करें

यहां दिए गए चरणों में, किसी भी कुंजी को GEMINI_API_KEY के तौर पर सेट किया जाता है. बैकएंड, दोनों को एक जैसा मानता है.

रिपॉज़िटरी को क्लोन करना

कोर्स की रिपॉज़िटरी https://github.com/gca-americas/dinoquest में मौजूद है. कृपया इसे पहले अपने GitHub खाते में fork करें. हम एजेंट को आपकी रिपॉज़िटरी पर काम करने के लिए कहेंगे.

फ़ोर्क करने के बाद, फ़ोर्क किए गए DinoQuest रेपो की main ब्रांच को क्लोन करें और प्रोजेक्ट डायरेक्ट्री डालें:

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

B. एनवायरमेंट वैरिएबल सेट अप करना

इस कोडलैब के दौरान, हर नए बैश टर्मिनल में इन ज़रूरी एनवायरमेंट वैरिएबल को सेट करना न भूलें. प्लेसहोल्डर वैल्यू की जगह, अपने प्रोजेक्ट की असल जानकारी डालें:

सबसे पहले, GitHub रिपॉज़िटरी का यूआरएल एक्सपोर्ट करें:

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

इसके बाद, बाकी एनवायरमेंट वैरिएबल एक्सपोर्ट करें:

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

पुष्टि करें कि स्ट्रक्चर सही हो:

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. बैकएंड एनवायरमेंट फ़ाइल बनाना

सबसे पहले, Gemini API पासकोड एक्सपोर्ट करें:

export GEMINI_API_KEY=YOUR_GEMINI_API_KEY_FROM_STEP_2

इसके बाद, .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 / सेवा खाता (Cloud Run के लिए) चालू करें

Cloud Run पर चलने वाला बैकएंड, Firebase से कम्यूनिकेट करने के लिए ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल का इस्तेमाल करता है. इसके लिए, सेवा खाते की कुंजी वाली फ़ाइल की ज़रूरत नहीं होती. firebase_admin.initialize_app() में backend/main.py पर होने वाली कॉल अपने-आप इस सुविधा का इस्तेमाल करेगी.

लोकल डेवलपमेंट के लिए, एक बार पुष्टि करें:

gcloud auth application-default login

डी॰ Firebase ऐप्लिकेशन कॉन्फ़िगरेशन फ़ाइल बनाना

frontend/ डायरेक्ट्री में, पिछले चरण के कॉन्फ़िगरेशन के साथ firebase-applet-config.json बनाएं:

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

ध्यान दें: firestoreDatabaseId, पिछले चरण में बनाए गए डेटाबेस आईडी से मेल खाना चाहिए. अगर आपने डिफ़ॉल्ट वैल्यू का इस्तेमाल किया है, तो इसे "(default)" के तौर पर छोड़ दें.

बदलावों को वापस अपनी रिपॉज़िटरी में कमिट करें:

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

C. DinoQuest को लोकल तौर पर चलाना

1. ज़रूरी एपीआई चालू करना

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 शुरू करें

start.sh स्क्रिप्ट, React फ़्रंटएंड बनाती है और टर्मिनल को FastAPI बैकएंड को सौंप देती है. यह बैकएंड, कंपाइल की गई स्टैटिक फ़ाइलें उपलब्ध कराता है:

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

अपने ब्राउज़र में http://localhost:8000 खोलें. आपको DinoQuest की टाइटल स्क्रीन दिखेगी. Google खाते से साइन इन करें, अपना पहला डायनासोर जनरेट करें, और पुष्टि करें कि यह Firestore में सेव हो गया है.

समस्या हल करना: अगर आपको कोई खाली पेज दिखता है या Firebase auth से जुड़ी गड़बड़ियां दिखती हैं, तो दोबारा जांच करें कि frontend/firebase-applet-config.json में सही वैल्यू मौजूद हैं और localhost, अनुमति वाले डोमेन की सूची में शामिल है.

ई॰ DinoQuest को Cloud Run पर डिप्लॉय करना

1. अपना प्रोजेक्ट सेट करना

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

3. Artifact Registry में डेटा स्टोर करने की जगह बनाना

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

4. Gemini API पासकोड को 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}-compute@developer.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

5. Cloud Build की मदद से कंटेनर इमेज बनाना

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

इससे मल्टी-स्टेज Dockerfile चलता है: यह पहले React ऐप्लिकेशन बनाता है. इसके बाद, आउटपुट को FastAPI इमेज में पैकेज करता है. इसमें करीब 3 से 5 मिनट लगते हैं.

6. Cloud Run पर डिप्लॉय करना

सबसे पहले, एडमिन का ईमेल पता एक्सपोर्ट करें:

export ADMIN_EMAIL=<YOUR_TEST_ACCOUNT_EMAIL>

इसके बाद, सेवा को डिप्लॉय करें:

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"

कमांड पूरी होने पर, Cloud Run सेवा का यूआरएल प्रिंट करता है. इस यूआरएल को कॉपी करें. आपको Firebase में डोमेन को अनुमति देने के लिए इसकी ज़रूरत होगी.

7. Firebase में Cloud Run डोमेन को अनुमति देना

उपयोगकर्ताओं को डिप्लॉय किए गए ऐप्लिकेशन से साइन इन करने की अनुमति देने के लिए, आपको Cloud Run यूआरएल को Firebase के अनुमति वाले डोमेन में जोड़ना होगा:

  1. Firebase कंसोल → Authentication → Settings → Authorized domains पर वापस जाएं
  2. डोमेन जोड़ें पर क्लिक करें
  3. अपनी Cloud Run सर्विस का यूआरएल चिपकाएं (जैसे, dinoquest-xxxxx.us-central1.run.app) — https:// प्रीफ़िक्स हटाएं
  4. सेव करें पर क्लिक करें

8. लीडरबोर्ड का डेटा सीड करना

अपने गेम को कुछ शुरुआती "लाइफ़" देने और यह पक्का करने के लिए कि आपके एजेंटों के पास डेटा हो, लीडरबोर्ड में कुछ शुरुआती स्कोर जोड़े जा सकते हैं.

  1. पक्का करें कि आप dinoquest की रूट डायरेक्ट्री में हों:
    cd ~/dinoquest
  2. वर्चुअल एनवायरमेंट बनाएं और उसे चालू करें:
    python3 -m venv venv
source venv/bin/activate
  3. Firestore की ज़रूरी डिपेंडेंसी इंस्टॉल करें:
    pip install google-cloud-firestore
  4. सीडिंग स्क्रिप्ट चलाएं:
    python3 prep/seed_scores.py
  5. वर्चुअल एनवायरमेंट बंद करें:
    deactivate

अब अपने ब्राउज़र में सेवा का यूआरएल खोला जा सकता है. DinoQuest पूरी तरह से लाइव हो चुका है!

4. Dino Theater को सेट अप करना

एजेंट की भूमिका: विज़ुअलाइज़र. ऑटोनॉमस एजेंट टीम की परफ़ॉर्मेंस को कैसे मॉनिटर किया जाता है? डाइनो थिएटर की मदद से, एजेंट स्वार्म के काम करने के तरीके को रीयल-टाइम में देखा जा सकता है. टर्मिनल लॉग को देखने के बजाय, लाइव विज़ुअल डैशबोर्ड में यह देखा जा सकता है कि आपके एजेंट कैसे तर्क देते हैं, एक-दूसरे को कॉल करते हैं, और क्लाउड पर टास्क पूरे करते हैं.

खास जानकारी

A. Dino Theater को Cloud Run पर डिप्लॉय करना

सबसे पहले, अपनी होम डायरेक्ट्री पर वापस जाएं और Dino Theater कोड को क्लोन करें:

cd ~
git clone https://github.com/gca-americas/dinoquest-theater.git
cd dinoquest-theater
  1. कंटेनर बनाना और उसे पुश करना:
    gcloud builds submit --tag $CLOUD_RUN_REGION-docker.pkg.dev/$PROJECT_ID/dinoquest/dino-theater:latest .
  2. सेवा खाता और अनुमतियां सेट अप करना:
    # 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. ऐप्लिकेशन डिप्लॉय करें:
    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
    ध्यान दें: --min-instances=1 का सुझाव दिया जाता है, ताकि इवेंट के बीच एसएसई कनेक्शन चालू रहे.
  4. पुष्टि करें कि यह काम करता है: अपने ब्राउज़र में, डिप्लॉय किए गए सेवा के यूआरएल को खोलें. उदाहरण के लिए, https://dino-theater-xxx-uc.a.run.app/demo.

5. आईडीई में एजेंटिक DevOps

एजेंट की भूमिका: नेटिव एंटीग्रैविटी. आपके आईडीई और क्लाउड के बीच के अंतर को कम करने के लिए, हम Antigravity को Google Cloud के मैनेज किए जा रहे एमसीपी सर्वर से कनेक्ट करते हैं. इससे आपके नेटिव एजेंट को आपके प्रोजेक्ट की जानकारी मिलती है. इससे वह लॉग पार्स कर सकता है, मेट्रिक की जांच कर सकता है, और इंफ़्रास्ट्रक्चर के बारे में जानकारी दे सकता है. इसके लिए, आपको एपीआई कुंजियों को मैनेज करने या कंसोल पर स्विच करने की ज़रूरत नहीं होती.

किसी भी स्किल को चलाने से पहले, आपको Google Cloud को ऐक्सेस करने के लिए Antigravity को कॉन्फ़िगर करना होगा. साथ ही, DinoQuest की स्किल प्लेबुक लोड करनी होंगी.

A. Google की मैनेज की गई एमसीपी सेवा इंस्टॉल करना

Google की मैनेज की गई एमसीपी सेवा, एक ही होस्ट किए गए एंडपॉइंट के ज़रिए Google Cloud के सभी एपीआई का ऐक्सेस देती है.

ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल का इस्तेमाल करके पुष्टि करना:

gcloud auth application-default login

B. mcp_config.json कॉन्फ़िगर करना

अपनी Antigravity कॉन्फ़िगरेशन डायरेक्ट्री (आम तौर पर ~/.gemini/antigravity/mcp_config.json) में mcp_config.json बनाएं या अपडेट करें. इसके अलावा, इसे कंसोल से भी किया जा सकता है. इससे Antigravity को Google Cloud और GitHub के उन टूल का ऐक्सेस मिलता है जिनकी ज़रूरत इन स्किल को होती है:

{
  "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. Antigravity में स्किल लोड करना (ज़रूरी नहीं)

Antigravity, कुछ स्टैंडर्ड डायरेक्ट्री में मौजूद कौशल का पता लगाता है. क्लोन की गई अपनी रिपॉज़िटरी से DinoQuest की स्किल को, 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/

डी॰ Antigravity को रीस्टार्ट करें(ज़रूरी नहीं)

mcp_config.json बदलावों को लागू करने और नई कॉपी की गई स्किल लोड करने के लिए, Antigravity ऐप्लिकेशन को रीस्टार्ट करें.

रीस्टार्ट होने के बाद:

  1. पुष्टि करें कि सेटिंग में, google और github एमसीपी सर्वर के लिए, "कनेक्ट किया गया" स्टेटस हरे रंग में दिख रहा हो.
  2. पुष्टि करें कि DinoQuest की सुविधाएं, आपकी सुविधाओं की सूची में दिख रही हैं.

ध्यान दें: हर स्किल के SKILL.md में सबसे ऊपर एक ## Configuration टेबल होती है. कॉपी करने के बाद, आपको ~/.gemini/antigravity/skills//SKILL.md में मौजूद वैल्यू को अपडेट करना होगा, ताकि वे आपके प्रोजेक्ट से मेल खाएं.

ई॰ लोकल आईडीई में क्लाउड सेवा की समस्या ठीक करना

  1. गड़बड़ी ट्रिगर करना: अपने ब्राउज़र में, डिप्लॉय किया गया DinoQuest यूआरएल (पिछले चरण से) खोलें.
  2. लीडरबोर्ड पर जाएं: लीडरबोर्ड बटन पर क्लिक करें. लीडरबोर्ड को जान-बूझकर इस तरह से लागू किया गया है कि यह ठीक से काम न करे. यह मेमोरी में बहुत ज़्यादा डेटा लोड करने की कोशिश करेगा. इससे, मेमोरी से बाहर होने (ओओएम) की गड़बड़ी ट्रिगर होगी.
  3. Antigravity Agent Manager (Agent HUB) में, गड़बड़ी को ठीक करने और समस्या की वजह का पता लगाने के लिए मदद मांगें.
  • पहला प्रॉम्प्ट: पता लगाएं कि dinoquest में क्या गड़बड़ी है.
  • दूसरा प्रॉम्प्ट: क्या Dinoquest गेम के कोड को देखकर, मेमोरी से जुड़ी गड़बड़ी को ठीक किया जा सकता है?

6. BigQuery में लॉग स्ट्रीम करना और आंकड़ों की जानकारी जनरेट करना

एजेंट की भूमिका: डेटा एजेंट. कच्चे लॉग को काम की प्रॉडक्ट रणनीति में बदलने के लिए, मैन्युअल तरीके से डेटा को प्रोसेस करने में घंटों नहीं लगने चाहिए. Data Agent Kit और BigQuery MCP का इस्तेमाल करके, हम एक ‘Zero ETL' पाइपलाइन बनाते हैं. यह पाइपलाइन, लॉग को सीधे तौर पर BigQuery में स्ट्रीम करती है. इससे एजेंट को दो मिनट से भी कम समय में, प्रीमियम Analytics डैशबोर्ड जनरेट करने की अनुमति मिलती है.

log-router-bq-report स्किल, Cloud Logging सिंक सेट अप करती है. यह DinoQuest के Cloud Run लॉग को BigQuery में लगातार स्ट्रीम करता है. इसके बाद, डेटा से क्वेरी करके ट्रैफ़िक रिपोर्ट और गेम-ऐनलिटिक्स की अहम जानकारी जनरेट करता है.

खास जानकारी

A. स्किल के वैरिएबल कॉन्फ़िगर करना

अपनी DinoQuest repo में skills/log-router-bq-report/SKILL.md खोलें और सबसे ऊपर मौजूद Configuration सेक्शन को अपडेट करें:

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

B. Antigravity में स्किल को चलाना

DinoQuest रेपो को कॉन्टेक्स्ट के तौर पर इस्तेमाल करके Antigravity खोलें और Gemini से यह सवाल पूछें:

Run the log-router-bq-report skill

इस स्किल से:

  1. अपने GCP प्रोजेक्ट की समस्या को अपने-आप ठीक होने दें
  2. देखें कि BigQuery सिंक पहले से मौजूद है या नहीं. अगर यह मौजूद नहीं है, तो यह डेटासेट और सिंक बना देगा.
  3. IAM अनुमतियां दें: इससे सिंक के writerIdentity को डेटासेट पर BigQuery डेटा एडिटर की भूमिका मिल जाएगी.

ध्यान दें: Eventarc सिंक की तरह, इस प्रोसेस के दौरान आपको gcloud से यह चेतावनी दिख सकती है: "कृपया serviceAccount:service-... को डेटासेट पर BigQuery डेटा एडिटर की भूमिका दें." यह स्किल, इस काम को अपने-आप मैनेज करती है.

C. रिपोर्ट जनरेट करने के लिए Antigravity का इस्तेमाल करना

Antigravity से "BigQuery लॉग सिंक सेट अप करने और आंकड़ों की रिपोर्ट जनरेट करने" के लिए कहें. एजेंट ये काम करेगा:

  1. इंफ़्रास्ट्रक्चर कॉन्फ़िगर करना: BigQuery डेटासेट और Cloud Logging सिंक बनाएं.
  2. अनुमतियां मैनेज करें: सिंक की राइटर आइडेंटिटी को ज़रूरी आईएएम भूमिकाएं अपने-आप असाइन करें.
  3. अहम जानकारी जनरेट करना: लॉग का विश्लेषण करें और गेम टेलीमेट्री और जीत की दर के विश्लेषण के साथ एक प्रीमियम, इंटरैक्टिव एचटीएमएल डैशबोर्ड जनरेट करें.

7. सेल्फ़-हीलिंग रेमेडिएशन एजेंट

एजेंट की भूमिका: एसआरई एजेंट. अगर प्रोडक्शन सेवा रात 2 बजे काम नहीं करती है, तो आपको उठने की ज़रूरत नहीं होनी चाहिए. यह एजेंट, आपातकालीन स्थिति में मदद के लिए सबसे पहले आने वाले व्यक्ति के तौर पर काम करता है. यह सुविधा, Eventarc के ज़रिए Cloud Run के गड़बड़ी वाले लॉग से ट्रिगर होती है. यह क्रैश का अपने-आप विश्लेषण करती है, उसे ठीक करने का सुझाव देती है, और समस्या ठीक करने की प्रोसेस शुरू करती है. यह सब तब होता है, जब आपने कंसोल में लॉग इन भी नहीं किया होता.

DinoAgent, ADK एजेंट है. यह Eventarc के ज़रिए Cloud Run के गड़बड़ी वाले लॉग को सुनता है, गड़बड़ी की मुख्य वजह का पता लगाता है, और उसे अपने-आप ठीक करता है. इसके लिए, वह मेमोरी को बढ़ाता है, ट्रैफ़िक को वापस लाता है या GitHub पर कोड ठीक करने का पीआर फ़ाइल करता है.

खास जानकारी

A. बचे हुए टोकन को ठीक करने वाले एजेंट के डेटा स्टोर करने की जगह को क्लोन करना

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

प्रोजेक्ट का स्ट्रक्चर:

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 का ऐक्सेस सेट अप करना (कोड ठीक करने वाला ट्रैक)

कोड ठीक करने वाला ट्रैक, आपकी DinoQuest repo को क्लोन करता है, सोर्स फ़ाइलें पढ़ता है, पैच लागू करता है, और पीआर खोलता है. इसके लिए, repo स्कोप वाला GitHub का निजी ऐक्सेस टोकन ज़रूरी है.

  1. github.com/settings/tokens → Generate new token (classic) पर जाएं
  2. इसे कोई नाम दें, repo स्कोप → टोकन जनरेट करें को चुनें → इसे कॉपी करें

इसे Secret Manager में सेव करें:

सबसे पहले, अपना GitHub टोकन एक्सपोर्ट करें:

export GH_TOKEN=ghp_YOUR_TOKEN_HERE

इसके बाद, सीक्रेट बनाएं:

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

C. Slack पर सूचनाएं पाने की सुविधा सेट अप करना (ज़रूरी नहीं)

समस्या ठीक हो जाने पर, DinoAgent इसकी खास जानकारी को Slack चैनल पर पोस्ट करता है.

  1. api.slack.com/apps → Create New App → From scratch पर जाएं
  2. इसे DinoAgent नाम दें. इसके बाद, अपना Workspace चुनें → ऐप्लिकेशन बनाएं
  3. सुविधाएं → आने वाले वेबहुक में जाकर, टॉगल चालू करें
  4. Add New Webhook to Workspace पर क्लिक करें → कोई चैनल चुनें → Allow
  5. वेबहुक यूआरएल (https://hooks.slack.com/services/...) कॉपी करें

इसे Secret Manager में सेव करें:

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

डी॰ 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

इसे सीक्रेट का ऐक्सेस दें:

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

ई॰ DinoAgent को 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. Eventarc ट्रिगर को कॉन्फ़िगर करना

Cloud Run से जुड़ी गड़बड़ी के लॉग पाने के लिए, Pub/Sub विषय बनाएं:

gcloud pubsub topics create cloud-run-errors

एक Cloud Logging सिंक बनाएं, जो आपकी dinoquest सेवा से गड़बड़ी के लॉग को फ़िल्टर करता है और उन्हें इस विषय पर भेजता है:

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"

ध्यान दें: ऊपर दिया गया निर्देश चलाने पर, gcloud एक जानकारी वाला मैसेज प्रिंट करेगा. इसमें लिखा होगा: "कृपया याद रखें कि serviceAccount:service-... को विषय पर Pub/Sub पब्लिशर की भूमिका दें." अगले चरण में, इसी के बारे में बताया गया है.

सिंक के राइटर की पहचान (चेतावनी में बताया गया सेवा खाता) को पब्लिश करने की अनुमति दें:

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"

पुष्टि करें कि यह चालू है:

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

समस्या हल करने वाले एजेंट को शुरू करने के लिए, Eventarc को अनुमति दें:

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

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}

अब उल्लंघन ठीक करने की प्रोसेस पूरी तरह से ऑटोमैटिक हो गई है. DinoAgent, सिर्फ़ इन्फ़्रास्ट्रक्चर को स्केल करने के अलावा, ऐप्लिकेशन कोड की समस्या की जड़ का पता लगाता है. साथ ही, सिमैंटिक पैच लागू करता है. इसके अलावा, यह एजेंट-टू-एजेंट (A2A) कम्यूनिकेशन का इस्तेमाल करके, समस्या को ठीक करने के लिए सीआई एजेंट को सौंपता है, ताकि वह इसकी पुष्टि कर सके और इसे डिप्लॉय कर सके. reme-agent codebase में जाकर, लागू करने से जुड़ी जानकारी देखी जा सकती है.

8. सीआई एजेंट सेट अप करना

एजेंट की भूमिका: सीआई पाइपलाइन. जटिल YAML फ़ाइलों और मैन्युअल बिल्ड स्क्रिप्ट से छुटकारा पाएं. यह एजेंट, पीआर की प्लंबिंग को मैनेज करता है. यह आपके कोड में हुए बदलावों को पढ़ता है, कॉन्टेक्स्ट को समझता है, ज़रूरी टेस्ट को स्कोप करता है, और Cloud Build की मदद से आपकी Docker इमेज बनाता है. इससे यह पक्का होता है कि हर कमिट, मुख्य ब्रांच तक पहुंचने से पहले "एजेंट से मंज़ूरी" पा ले.

ci-agent एक ऑटोनॉमस सीआई पाइपलाइन एजेंट है, जिसे Cloud Run सेवा के तौर पर डिप्लॉय किया जाता है. यह Docker बिल्ड को Cloud Build पर सबमिट करता है, पूरा होने के लिए पोल करता है, Artifact Registry में इमेज की पुष्टि करता है, और GitHub को रिपोर्ट करता है.

खास जानकारी

अपनी सीआई पाइपलाइन के लिए एजेंट का इस्तेमाल क्यों करें? पारंपरिक स्टैटिक स्क्रिप्ट के बजाय, एजेंटिक सीआई पाइपलाइन से ये फ़ायदे मिलते हैं:

  1. कॉग्निटिव स्कोप क्लासिफ़िकेशन: यह आपके कोड में किए गए बदलावों के सिमैंटिक असर के आधार पर, ज़रूरी टेस्ट डेप्थ का पता लगाता है. साथ ही, टाइप-चेक, यूनिट टेस्ट या फ़ुल इंटिग्रेशन सुइट के बीच स्विच करता है.
  2. पीआर को अपने-आप मैनेज करना: यह एजेंट, पीआर अपने-आप बना सकता है. साथ ही, बदलावों की खास जानकारी पोस्ट कर सकता है. इसके अलावा, यह एजेंट, इंसानों की मदद के बिना सीक्रेट स्कैनिंग और सुरक्षा ऑडिट को भी मैनेज कर सकता है.
  3. असली समय में गड़बड़ी का पता लगाना: जब कोई बिल्ड फ़ेल हो जाता है, तो एजेंट सिर्फ़ लॉग नहीं दिखाता. वह स्टैक ट्रेस का विश्लेषण करता है, गड़बड़ी की संभावित वजह का पता लगाता है, और गड़बड़ी की जानकारी को सीधे पीआर में पोस्ट करता है. यह जानकारी, किसी व्यक्ति के लिए आसानी से पढ़ी जा सकती है.

A. CIAgent के डेटा स्टोर करने की जगह का क्लोन बनाना

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

B. 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. GitHub रिपो को Cloud Build से कनेक्ट करना

CIAgent, repoSource के ज़रिए बिल्ड सबमिट करता है. इसके लिए, GitHub रिपो का Cloud Build Developer Connect से कनेक्ट होना ज़रूरी है.

  1. GCP Console → Cloud Build → Repositories पर जाएं
  2. कनेक्ट रिपॉज़िटरी पर क्लिक करें
  3. GitHub (Cloud Build GitHub ऐप्लिकेशन) चुनें
  4. YOUR_GITHUB_USERNAME/dinoquest रिपॉज़िटरी को अनुमति दें और उसे चुनें
  5. ट्रिगर बनाने के लिए कहा जाने पर, कनेक्ट करें और अभी नहीं पर क्लिक करें.
  6. अपने कनेक्शन का नाम नोट करें. डिफ़ॉल्ट रूप से, यह आम तौर पर आपका GitHub उपयोगकर्ता नाम या उससे मिलता-जुलता नाम होता है.

डी॰ CIAgent को सीक्रेट ऐक्सेस करने की अनुमति देना

हम 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"

ई॰ Cloud Run पर CIAgent बनाना और डिप्लॉय करना

# 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. Slack में स्लैश कमांड सेट अप करना

  1. api.slack.com/apps → Create New App → From scratch पर जाएं
  2. इसे CIAgent नाम दें, अपना Workspace चुनें → ऐप्लिकेशन बनाएं
  3. सुविधाएं → स्लैश कमांड → नई कमांड बनाएं में जाकर
  4. निर्देश: /runci
  5. अनुरोध यूआरएल: ऊपर दिया गया CIAgent Cloud Run यूआरएल, जिसमें /slack जोड़ा गया हो (जैसे, https://ci-agent-xxx-.us-central1.run.app/slack)
  6. कम शब्दों में जानकारी: Trigger CI
  7. सेव करें
  8. सेटिंग → ऐप्लिकेशन इंस्टॉल करें में जाकर, Workspace में इंस्टॉल करें पर क्लिक करें और अनुमति दें.

सीआई एजेंट, Cloud Build और Artifact Registry जैसी Google Cloud की मज़बूत सेवाओं के ऊपर काम करता है. बिल्ड की पुष्टि हो जाने के बाद, यह डिप्लॉयमेंट के आखिरी चरण को ट्रिगर करता है. इसके लिए, यह A2A के ज़रिए सीडी एजेंट को कॉल करता है. इससे यह पक्का होता है कि बिल्ड और रिलीज़ साइकल के बीच आसानी से हैंडऑफ़ हो सके.

9. डिप्लॉयमेंट सेट अप करना

एजेंट की भूमिका: सीडी एजेंट. डिप्लॉयमेंट को बिना सोचे-समझे नहीं किया जाना चाहिए. यह एजेंट, आपके लिए जोखिम को मैनेज करता है. यह डिप्लॉयमेंट की सुरक्षा का आकलन करता है, कैनरी ट्रैफ़िक को मैनेज करता है, और रीयल-टाइम मेट्रिक को मॉनिटर करता है. इससे यह तय किया जाता है कि किसी रिलीज़ को प्रमोट करना है या उसे वापस रोल बैक करना है. यह आपके ऑटोनॉमस एजेंट स्वार्म का फ़ाइनल गेटकीपर है.

cd-agent एक ऑटोनॉमस कैनरी डिप्लॉयमेंट एजेंट है. इसे Cloud Run सेवा के तौर पर डिप्लॉय किया जाता है. इसे ci-agent से A2A डिप्लॉय करने के अनुरोध मिलते हैं. यह जोखिम का स्कोर कैलकुलेट करता है, जोखिम के हिसाब से कैनरी का प्रतिशत सेट करता है, मेट्रिक की निगरानी करता है, और अपने-आप प्रमोट या रोल बैक करता है. यह Firestore का इस्तेमाल करके, पिछले डिप्लॉयमेंट से भी सीखता है.

खास जानकारी

एजेंट को सीधे तौर पर कनेक्ट करने से, "कॉग्निटिव पाइपलाइन" बनती है. इसमें हर हैंडऑफ़, इरादे और कॉन्टेक्स्ट का बेहतर ट्रांसफ़र होता है. सामान्य वेबहुक के मुकाबले, A2A कम्यूनिकेशन की मदद से ये काम किए जा सकते हैं:

  1. इंटेलिजेंट कॉन्टेक्स्ट शेयरिंग: एजेंट, पूरे सेशन की मेमोरी, पीआर में अंतर, और जोखिम के स्कोर पास करते हैं. इससे यह पक्का होता है कि अगले एजेंट को काम शुरू करने से पहले, पूरी जानकारी मिल जाए.
  2. कॉग्निटिव हैंडशेक: एजेंट, गेट के बारे में बातचीत कर सकते हैं. उदाहरण के लिए, कैनरी रोलआउट के दौरान सीडी एजेंट, सीआई एजेंट से कुछ स्मोक टेस्ट का अनुरोध कर सकता है. इससे वह रीयल-टाइम में किसी समस्या को ठीक करने की पुष्टि कर पाएगा.
  3. मिलकर समस्या हल करना: अगर कोई डिप्लॉयमेंट पूरा नहीं होता है, तो सीडी एजेंट, समस्या हल करने वाले एजेंट को उन मेट्रिक के बारे में सूचना दे सकता है जो काम नहीं कर रही हैं. इससे, किसी व्यक्ति को सूचना मिलने से पहले ही, समस्या की वजह का अपने-आप विश्लेषण शुरू हो जाता है.
  4. संसाधन के लिए बातचीत करना: एजेंट, बुनियादी ढांचे की ज़रूरतों के बारे में बातचीत कर सकते हैं. उदाहरण के लिए, अगर सीआई एजेंट को बड़े पैमाने पर रीफ़ैक्टरिंग का पता चलता है, तो वह रेमेडिएशन एजेंट से ज़्यादा बिल्ड कैपेसिटी उपलब्ध कराने के लिए कह सकता है. इसके अलावा, सीडी एजेंट किसी बड़ी रिलीज़ से पहले, प्रोडक्शन क्लस्टर को स्केल करने का सुझाव दे सकता है.
  5. एक से ज़्यादा एजेंट की सहमति: ज़्यादा जोखिम वाले बदलावों के लिए, एक से ज़्यादा एजेंट (जैसे, सुरक्षा एजेंट और सीडी एजेंट) A2A के ज़रिए "जॉइंट साइन-ऑफ़" कर सकते हैं. इससे यह पक्का किया जा सकता है कि कोड न सिर्फ़ बनाया और डिप्लॉय किया गया है, बल्कि प्रोडक्शन में जाने से पहले सुरक्षा नीतियों का पालन भी किया गया है.

A. CDAgent के डेटा स्टोर करने की जगह का क्लोन बनाना

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

B. Firestore डेटाबेस बनाना

CDAgent, डिप्लॉयमेंट मेमोरी पैटर्न को Firestore में सेव करता है:

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

(अगर आपने इस प्रोजेक्ट में पहले से ही कोई डेटाबेस बना लिया है, तो इस चरण को छोड़ दें.)

C. 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

डी॰ सीडीएजेंट को सीक्रेट ऐक्सेस करने की अनुमति देना

हम पहले से मौजूद GitHub टोकन और Slack वेबहुक का फिर से इस्तेमाल करेंगे. साथ ही, Cloud Run कंप्यूट सेवा खाते को Gemini API कुंजी का ऐक्सेस देंगे, ताकि डिप्लॉय किया गया ऐप्लिकेशन इसका इस्तेमाल कर सके:

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}-compute@developer.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

ई॰ Cloud Run पर CDAgent बनाना और डिप्लॉय करना

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

ध्यान दें: --min-instances=1 --no-cpu-throttling इंस्टेंस को चालू रखता है, ताकि वह Slack और A2A के निर्देशों का तुरंत जवाब दे सके.

सीडी एजेंट, आपके प्रोडक्शन एनवायरमेंट का आखिरी गेटकीपर होता है. यह हर डिप्लॉयमेंट के जोखिम का आकलन करता है, जोखिम के हिसाब से कैनरी डिप्लॉयमेंट करता है, और रीयल-टाइम मेट्रिक की निगरानी करता है. अगर कोई गड़बड़ी मिलती है, तो यह अपने-आप रोलबैक शुरू कर देता है.

10. स्केल अप करना: एजेंट स्वार्म की मदद से लेवल 2 को अनलॉक करना

A. फ़ुल स्वार्म की जांच करना

  1. गड़बड़ी ट्रिगर करना: अपने ब्राउज़र में, डिप्लॉय किया गया DinoQuest यूआरएल (पिछले चरण से) खोलें.
  2. लीडरबोर्ड पर जाएं: लीडरबोर्ड बटन पर क्लिक करें. लीडरबोर्ड को जान-बूझकर इस तरह से लागू किया गया है कि यह ठीक से काम न करे. यह मेमोरी में बहुत ज़्यादा डेटा लोड करने की कोशिश करेगा. इससे, मेमोरी से बाहर होने (ओओएम) की गड़बड़ी ट्रिगर होगी.
  3. एजेंट के लिए इंतज़ार करें: करीब 60 सेकंड के अंदर, remediation-agent को Eventarc के ज़रिए गड़बड़ी वाला इवेंट मिलेगा. इसके बाद, वह गड़बड़ी का पता लगाना शुरू कर देगा.
  4. Slack देखें: आपको अपने Slack चैनल में एक सूचना दिखेगी. यह सूचना इस तरह की होगी:DinoAgent Remediation Summary
    • सेवा: dinoquest
    • बदलाव लागू नहीं हुआ: dinoquest-xxxx-xxxx
    • सबूत: "मेमोरी की सीमा 128 MiB से ज़्यादा हो गई है. 13x MiB का इस्तेमाल किया गया है."
    • इस वर्शन में क्या गड़बड़ी थी: /api/leaderboard एंडपॉइंट को सही तरीके से xxxxx नहीं किया गया था. इस वजह से, OOM गड़बड़ी हुई.
    • की गई कार्रवाई: सेवा dinoquest के लिए, मेमोरी को xMi से बढ़ाकर yGi कर दिया गया है. नया वर्शन बनाया गया.
    • समस्या की मुख्य वजह बताने वाला पीआर: https://github.com/YOUR_USERNAME/DinoQuest/pull/x
  5. समस्या ठीक होने की पुष्टि करना:
    • GitHub: अपनी रिपॉज़िटरी में नई ब्रांच और पुल अनुरोध देखें. एजेंट ने ऐप्लिकेशन कोड को पैच कर दिया है, ताकि मेमोरी लीक की समस्या को ठीक किया जा सके.
    • Cloud Run: GCP Console में, आपको dinoquest सेवा का नया वर्शन दिखेगा. इसमें मेमोरी का अपडेट किया गया असाइनमेंट होगा.
    • लीडरबोर्ड: लीडरबोर्ड को फिर से आज़माएं. अब यह लोड हो जाना चाहिए, क्योंकि मेमोरी बढ़ा दी गई है और कोड में हुई गड़बड़ी को ठीक कर दिया गया है.

B. एवल्यूशन: गेम के लेवल 2 का लॉजिक लागू करना

आपको एक नई सुविधा जोड़नी होगी: लेवल 2 (ऐस्टरॉइड डिस्ट्रॉयर). इससे ज़्यादा स्कोर वाले डायनासोर, गेम के नए मोड में आगे बढ़ पाते हैं.

  1. अपनी dinoquest रिपॉज़िटरी पर वापस जाएं: 
    cd ~/dinoquest
  2. नई ब्रांच बनाना और उस पर स्विच करना: 
    git checkout -b level_2
  3. लेवल 2 का पैच लागू करें: लेवल 2 की ऐसेट, कॉम्पोनेंट, और गेम लॉजिक के साथ अपने लोकल कोडबेस को पैच करने के लिए, दी गई स्क्रिप्ट चलाएं: 
    bash level_2_backup/levelup.sh
  4. बदलावों को कमिट और पुश करें: 
    git add .
git commit -m "feat: add Level 2"
git push origin level_2

एजेंट को मैन्युअल तरीके से ट्रिगर करने के लिए curl का इस्तेमाल करने के बजाय, हम Slack Slash Command का इस्तेमाल करेंगे, जिसे आपने पहले कॉन्फ़िगर किया था. असल दुनिया में, ऑटोनॉमस सीआई पाइपलाइन के साथ इंटरैक्ट करने का तरीका यही है.

  1. Slack खोलें और उस चैनल पर जाएं जहां CIAgent ऐप्लिकेशन इंस्टॉल किया गया है.
  2. नीचे दी गई कमांड टाइप करके, सीआई बिल्ड ट्रिगर करें:
    /runci run ci on branch level_2
  3. प्रोग्रेस को मॉनिटर करना:
    • Slack: एजेंट आपकी कमांड को स्वीकार करेगा और बिल्ड की प्रोसेस पूरी होने पर अपडेट पोस्ट करेगा.
    • डिनो थिएटर: एजेंट के बदलाव को कैटगरी में बांटने, Cloud Build जॉब सबमिट करने, और सीडी एजेंट से कम्यूनिकेट करने के दौरान "थॉट बबल" देखें.
    • GitHub: अपनी level_2 पीआर देखें. आपको एजेंट के पोस्ट किए गए कमिट स्टेटस और सीआई की पूरी रिपोर्ट वाली टिप्पणी दिखेगी.
  4. प्रोसेस देखें:
    • डाइनो थिएटर में जाकर देखें कि सीआई एजेंट कैसे सोच रहा है, बदलाव को कैसे कैटगरी में बांट रहा है, और पाइपलाइन को कैसे चला रहा है.
    • GitHub PR देखें. इसमें CI एजेंट, कमिट की स्थिति और फ़ाइनल रिपोर्ट पोस्ट करता है.

11. नतीजा

आपने Google Cloud पर एक पूरा एजेंटिक DevOps स्टैक बनाया है:

कॉम्पोनेंट

यह क्या करता है

DinoQuest (Cloud Run dinoquest)

Gemini की मदद से बनाया गया गेम — React फ़्रंटएंड + FastAPI बैकएंड

Firebase Auth + Firestore

उपयोगकर्ता की पुष्टि करना और डायनासोर की प्रोफ़ाइल सेव करना

Remediation Agent (Cloud Run + Eventarc)

एसआरई एजेंट, जो ओओएम गड़बड़ियों और कोड की गड़बड़ियों को अपने-आप ठीक करता है

log-router-bq-report

डेटा एजेंट, BigQuery में लॉग स्ट्रीम करता है और अहम जानकारी जनरेट करता है

CIAgent (Cloud Run)

सीआई एजेंट, जो टेस्ट को स्कोप करता है, इमेज बनाता है, और A2A के ज़रिए सीडी को कॉल करता है

CDAgent (Cloud Run)

सीडी एजेंट, जोखिम के हिसाब से स्कोर किए गए कैनरी डिप्लॉयमेंट को अपने-आप रोलबैक करने की सुविधा के साथ चलाता है

एजेंट के सभी व्यवहार, skills/ डायरेक्ट्री में Markdown प्लेबुक के तौर पर मौजूद होते हैं. एजेंट के व्यवहार में बदलाव करने के लिए, कोड में नहीं, बल्कि स्किल में बदलाव करें. स्किल, Gemini के साथ Antigravity पर काम करती हैं. इन्हें चालू करने के लिए, एजेंट को यह बताना होता है कि कौनसी स्किल चालू करनी है.