तीसरी लैब: प्रोटोटाइप से प्रोडक्शन तक - जीपीयू के साथ Cloud Run पर अपना ADK एजेंट डिप्लॉय करना

1. परिचय

खास जानकारी

इस लैब में, आपको प्रोडक्शन के लिए तैयार एजेंट डेवलपमेंट किट (एडीके) एजेंट को डिप्लॉय करना होगा. इसमें जीपीयू की मदद से काम करने वाले Gemma बैकएंड का इस्तेमाल किया जाएगा. इसमें, डिप्लॉयमेंट के अहम पैटर्न पर फ़ोकस किया जाता है: जीपीयू की सुविधा वाली Cloud Run सेवाएं सेट अप करना, मॉडल बैकएंड को ADK एजेंट के साथ इंटिग्रेट करना, और लोड के दौरान अपने-आप स्केलिंग होने की सुविधा को मॉनिटर करना.

आपको क्या करना होगा

इस लैब में, प्रोडक्शन डिप्लॉयमेंट के इन मुख्य पहलुओं पर फ़ोकस किया जाएगा:

  1. जीपीयू की मदद से, Cloud Run पर Gemma को डिप्लॉय करना - बेहतर परफ़ॉर्मेंस वाला Gemma मॉडल बैकएंड सेट अप करना
  2. Gemma को ADK एजेंट के साथ इंटिग्रेट करना - अपने एजेंट को जीपीयू की मदद से काम करने वाले मॉडल से कनेक्ट करना
  3. ADK वेब इंटरफ़ेस की मदद से टेस्ट करना - पुष्टि करें कि आपका बातचीत वाला एजेंट सही तरीके से काम कर रहा है
  4. लोड टेस्टिंग करें - देखें कि लोड बढ़ने पर, Cloud Run के दोनों इंस्टेंस अपने-आप कैसे स्केल होते हैं

इसमें एजेंट को ज़्यादा से ज़्यादा डेवलप करने के बजाय, प्रोडक्शन डिप्लॉयमेंट पैटर्न पर ज़ोर दिया जाता है.

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

  • प्रोडक्शन के लिए, Cloud Run पर जीपीयू की मदद से काम करने वाले Gemma मॉडल डिप्लॉय करना
  • बाहरी मॉडल डिप्लॉयमेंट को एडीके एजेंट के साथ इंटिग्रेट करना
  • एआई एजेंट के प्रोडक्शन-रेडी डिप्लॉयमेंट को कॉन्फ़िगर करना और उसकी जांच करना
  • लोड बढ़ने पर, Cloud Run की अपने-आप स्केल होने की सुविधा के काम करने के तरीके को समझना
  • देखें कि ट्रैफ़िक बढ़ने पर, Cloud Run के कई इंस्टेंस कैसे काम करते हैं
  • परफ़ॉर्मेंस और ऑटोस्केलिंग की पुष्टि करने के लिए, लोड टेस्टिंग लागू करें

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

  1. अगर आपके पास पहले से कोई Google खाता नहीं है, तो आपको Google खाता बनाना होगा.
    • ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें. ऑफ़िस और स्कूल वाले खातों पर कुछ पाबंदियां हो सकती हैं. इनकी वजह से, इस लैब के लिए ज़रूरी एपीआई चालू नहीं किए जा सकते.
  2. Google Cloud Console में साइन इन करें.
  3. Cloud Console में बिलिंग चालू करें.
    • इस लैब को पूरा करने में, Cloud संसाधनों पर 1 डॉलर से कम का खर्च आना चाहिए.
    • ज़्यादा शुल्क से बचने के लिए, इस लैब के आखिर में दिए गए निर्देशों का पालन करके संसाधनों को मिटाया जा सकता है.
    • नए उपयोगकर्ता, 300 डॉलर के मुफ़्त क्रेडिट पा सकते हैं.
  4. नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें.

3. Cloud Shell Editor खोलें

  1. सीधे Cloud Shell Editor पर जाने के लिए, इस लिंक पर क्लिक करें
  2. अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें. Cloud Shell को अनुमति देने के लिए क्लिक करें
  3. अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
    • देखें पर क्लिक करें
    • टर्मिनलCloud Shell Editor में नया टर्मिनल खोलें पर क्लिक करें
  4. टर्मिनल में, इस निर्देश का इस्तेमाल करके अपना प्रोजेक्ट सेट करें:
    • फ़ॉर्मैट:
      gcloud config set project [PROJECT_ID]
    • उदाहरण:
      gcloud config set project lab-project-id-example
    • अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो:
      • अपने सभी प्रोजेक्ट आईडी की सूची देखने के लिए, यह तरीका अपनाएं:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
      Cloud Shell Editor के टर्मिनल में प्रोजेक्ट आईडी सेट करना
  5. आपको यह मैसेज दिखेगा:
    Updated property [core/project].
    अगर आपको WARNING दिखता है और आपसे Do you want to continue (Y/n)? पूछा जाता है, तो इसका मतलब है कि आपने प्रोजेक्ट आईडी गलत डाला है. n दबाएं, Enter दबाएं, और gcloud config set project कमांड को फिर से चलाने की कोशिश करें.

4. एपीआई चालू करना और डिफ़ॉल्ट क्षेत्र सेट करना

GPU की सुविधा के साथ Cloud Run सेवाओं को डिप्लॉय करने से पहले, हमें ज़रूरी Google Cloud API चालू करने होंगे. साथ ही, आपके प्रोजेक्ट की सेटिंग कॉन्फ़िगर करनी होंगी.

  1. टर्मिनल में, इन एपीआई को चालू करें:
gcloud services enable \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  aiplatform.googleapis.com

अगर अनुमति देने के लिए कहा जाए, तो जारी रखने के लिए अनुमति दें पर क्लिक करें. Cloud Shell को अनुमति देने के लिए क्लिक करें

इस कमांड को पूरा होने में कुछ मिनट लग सकते हैं. हालांकि, आखिर में आपको इस तरह का मैसेज दिखेगा:

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.
  1. Cloud Run के लिए डिफ़ॉल्ट क्षेत्र सेट करें.
gcloud config set run/region europe-west1

5. अपना Python प्रोजेक्ट तैयार करना

आइए, स्टार्टर कोड सेट अप करें. इसमें हमारे Gemma बैकएंड और ADK एजेंट सेवाओं, दोनों के लिए बुनियादी स्ट्रक्चर शामिल है.

  1. स्टार्टर रिपॉज़िटरी को क्लोन करें:
    cd ~
git clone https://github.com/amitkmaraj/accelerate-ai-lab3-starter.git
cd accelerate-ai-lab3-starter
  2. प्रोजेक्ट के स्ट्रक्चर की जांच करें:
    ls -R
    आपको यह स्टार्टर स्ट्रक्चर दिखेगा:
    accelerate-ai-lab3-starter/
├── README.md                    # Project overview
├── ollama-backend/              # Ollama backend (separate deployment)
│   └── Dockerfile               # Backend container (🚧 to implement)
└── adk-agent/                   # ADK agent (separate deployment)
    ├── pyproject.toml           # Python dependencies (✅ completed)
    ├── server.py                # FastAPI server (🚧 to implement)
    ├── Dockerfile               # Container config (🚧 to implement)
    ├── load_test.py             # Load testing (🚧 to implement)
    └── production_agent/        # Agent implementation
        ├── __init__.py         # Package init (✅ completed)
        └── agent.py            # Agent logic (🚧 to implement)

6. आर्किटेक्चर के बारे में खास जानकारी

इसे लागू करने से पहले, आइए दो-सेवाओं वाले आर्किटेक्चर के बारे में जानते हैं:

लैब 3: दो सर्विस वाला आर्किटेक्चर

अहम जानकारी: लोड टेस्टिंग के दौरान, आपको दिखेगा कि दोनों सेवाएं अलग-अलग तरीके से स्केल हो रही हैं. जीपीयू बैकएंड (बॉटलनेक सेवा) अनुमान लगाने के लोड के लिए 1 से 3 इंस्टेंस तक स्केल होता है, जबकि एडीके एजेंट अनुरोध को हैंडल करने के लिए 1 इंस्टेंस पर रहता है.

7. Gemma बैकएंड को जीपीयू के साथ Cloud Run पर डिप्लॉय करें

Lab 3 Gemma Service

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

  1. Ollama बैकएंड डायरेक्ट्री पर जाएं:
    cd ollama-backend
  2. Ollama Dockerfile खोलें और लागू करें:
    cloudshell edit Dockerfile
    TODO टिप्पणी को इससे बदलें:
    FROM ollama/ollama:latest

# Listen on all interfaces, port 8080
ENV OLLAMA_HOST 0.0.0.0:8080

# Store model weight files in /models
ENV OLLAMA_MODELS /models

# Reduce logging verbosity
ENV OLLAMA_DEBUG false

# Never unload model weights from the GPU
ENV OLLAMA_KEEP_ALIVE -1

# Store the model weights in the container image
ENV MODEL gemma3:270m
RUN ollama serve & sleep 5 && ollama pull $MODEL

# Start Ollama
ENTRYPOINT ["ollama", "serve"]
    🔧 इस सेटिंग से क्या होता है:
    • यह Ollama की आधिकारिक इमेज का इस्तेमाल करता है
    • इस कुकी का इस्तेमाल, OLLAMA_HOST को किसी भी आईपी पते से कनेक्शन स्वीकार करने के लिए सेट करने के लिए किया जाता है
    • पोर्ट 8080 को ऐक्सेस करने की अनुमति देता है
  3. जीपीयू की सुविधा के साथ Gemma बैकएंड डिप्लॉय करें:
gcloud run deploy ollama-gemma3-270m-gpu \
  --source . \
  --region europe-west1 \
  --concurrency 4 \
  --cpu 8 \
  --set-env-vars OLLAMA_NUM_PARALLEL=4 \
  --gpu 1 \
  --gpu-type nvidia-l4 \
  --max-instances 3 \
  --memory 16Gi \
  --allow-unauthenticated \
  --no-cpu-throttling \
  --no-gpu-zonal-redundancy \
  --timeout 600 \
  --labels dev-tutorial=codelab-agent-gpu

अगर आपको यह मैसेज मिलता है, "सोर्स से डिप्लॉय करने के लिए, Artifact Registry Docker रिपॉज़िटरी की ज़रूरत होती है, ताकि बनाए गए कंटेनर को सेव किया जा सके. [europe-west1] क्षेत्र में [cloud-run-source-deploy] नाम की एक रिपॉज़िटरी बनाई जाएगी." मैसेज दिखता है, तो जारी रखें.

⚙️ मुख्य कॉन्फ़िगरेशन के बारे में जानकारी:

  • जीपीयू: NVIDIA L4 को इसलिए चुना गया है, क्योंकि अनुमान लगाने से जुड़े वर्कलोड के लिए, यह कीमत और परफ़ॉर्मेंस के हिसाब से सबसे अच्छा जीपीयू है. L4 में 24 जीबी जीपीयू मेमोरी और ऑप्टिमाइज़ किए गए टेंसर ऑपरेशन मिलते हैं. इसलिए, यह 27 करोड़ पैरामीटर वाले मॉडल के लिए सबसे सही है. जैसे, Gemma
  • मेमोरी: मॉडल को लोड करने, CUDA ऑपरेशनों को मैनेज करने, और Ollama की मेमोरी को मैनेज करने के लिए 16 जीबी सिस्टम मेमोरी
  • सीपीयू: बेहतर I/O हैंडलिंग और प्रीप्रोसेसिंग टास्क के लिए 8 कोर
  • एक साथ कई अनुरोध: हर इंस्टेंस के लिए चार अनुरोध, जीपीयू मेमोरी के इस्तेमाल के साथ थ्रूपुट को बैलेंस करते हैं
  • टाइम आउट: 600 सेकंड, शुरुआती मॉडल लोडिंग और कंटेनर स्टार्टअप के लिए तय किया गया है

💰 लागत: जीपीयू इंस्टेंस, सिर्फ़ सीपीयू वाले इंस्टेंस की तुलना में काफ़ी महंगे होते हैं (~2 से 4 डॉलर/घंटा बनाम ~0.10 डॉलर/घंटा). --max-instances 1 सेटिंग की मदद से, बिना वजह जीपीयू इंस्टेंस को स्केल करने से रोककर लागत को कंट्रोल किया जा सकता है.

  1. डिप्लॉयमेंट पूरा होने का इंतज़ार करें और सेवा का यूआरएल नोट करें:
    export OLLAMA_URL=$(gcloud run services describe ollama-gemma3-270m-gpu \
    --region=europe-west1 \
    --format='value(status.url)')

echo "🎉 Gemma backend deployed at: $OLLAMA_URL"

8. ADK एजेंट इंटिग्रेशन लागू करना

अब हम एक ऐसा ADK एजेंट बनाएंगे जो डिप्लॉय किए गए Gemma बैकएंड से कनेक्ट हो.

  1. ADK एजेंट डायरेक्ट्री पर जाएं:
    cd ../adk-agent
  2. एजेंट कॉन्फ़िगरेशन खोलें और लागू करें:
    cloudshell edit production_agent/agent.py
    सभी TODO टिप्पणियों को इस कम से कम लागू करने वाले कोड से बदलें:
    import os
from pathlib import Path

from dotenv import load_dotenv
from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
import google.auth

# Load environment variables
root_dir = Path(__file__).parent.parent
dotenv_path = root_dir / ".env"
load_dotenv(dotenv_path=dotenv_path)

# Configure Google Cloud
try:
    _, project_id = google.auth.default()
    os.environ.setdefault("GOOGLE_CLOUD_PROJECT", project_id)
except Exception:
    pass

os.environ.setdefault("GOOGLE_CLOUD_LOCATION", "europe-west1")

# Configure model connection
gemma_model_name = os.getenv("GEMMA_MODEL_NAME", "gemma3:270m")

# Production Gemma Agent - GPU-accelerated conversational assistant
gemma_agent = Agent(
   model=LiteLlm(model=f"ollama_chat/{gemma_model_name}"),
   name="gemma_agent",
   description="A production-ready conversational assistant powered by GPU-accelerated Gemma.",
   instruction="""You are 'Gem', a friendly, knowledgeable, and enthusiastic zoo tour guide.
   Your main goal is to make a zoo visit more fun and educational for guests by answering their questions.

   You can provide general information and interesting facts about different animal species, such as:
   - Their natural habitats and diet. 🌲🍓
   - Typical lifespan and behaviors.
   - Conservation status and unique characteristics.

   IMPORTANT: You do NOT have access to any tools. This means you cannot look up real-time, specific information about THIS zoo. You cannot provide:
   - The names or ages of specific animals currently at the zoo.
   - The exact location or enclosure for an animal.
   - The daily schedule for feedings or shows.

   Always answer based on your general knowledge about the animal kingdom. Keep your tone cheerful, engaging, and welcoming for visitors of all ages. 🦁✨""",
   tools=[],  # Gemma focuses on conversational capabilities
)

# Set as root agent
root_agent = gemma_agent
    🔧 इस सेटिंग से क्या होता है:
    • यह LiteLlm के ज़रिए, डिप्लॉय किए गए Gemma बैकएंड से कनेक्ट होता है
    • यह बातचीत करने वाला एक आसान एजेंट बनाता है
    • यह कुकी, Google Cloud इंटिग्रेशन को कॉन्फ़िगर करती है
  3. FastAPI सर्वर खोलें और उसे लागू करें:
    cloudshell edit server.py
    सभी TODO टिप्पणियों को इससे बदलें:
    import os
from dotenv import load_dotenv
from fastapi import FastAPI
from google.adk.cli.fast_api import get_fast_api_app

# Load environment variables
load_dotenv()

AGENT_DIR = os.path.dirname(os.path.abspath(__file__))
app_args = {"agents_dir": AGENT_DIR, "web": True}

# Create FastAPI app with ADK integration
app: FastAPI = get_fast_api_app(**app_args)

# Update app metadata
app.title = "Production ADK Agent - Lab 3"
app.description = "Gemma agent with GPU-accelerated backend"
app.version = "1.0.0"

@app.get("/health")
def health_check():
    return {"status": "healthy", "service": "production-adk-agent"}

@app.get("/")
def root():
    return {
        "service": "Production ADK Agent - Lab 3",
        "description": "GPU-accelerated Gemma agent",
        "docs": "/docs",
        "health": "/health"
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080, log_level="info")
    🔧 इस सेटिंग से क्या होता है:
    • यह ADK इंटिग्रेशन के साथ एक FastAPI सर्वर बनाता है
    • यह कुकी, टेस्टिंग के लिए वेब इंटरफ़ेस चालू करती है
    • हेल्थ चेक एंडपॉइंट उपलब्ध कराता है
  4. Dockerfile खोलें और उसे लागू करें:
    cloudshell edit Dockerfile
    सभी TODO टिप्पणियों को इससे बदलें:
    FROM python:3.13-slim

# Copy uv from the official image
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv

# Install system dependencies
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

# Set working directory
WORKDIR /app

# Copy all files
COPY . .

# Install Python dependencies
RUN uv sync

# Expose port
EXPOSE 8080

# Run the application
CMD ["uv", "run", "uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8080"]
    टेक्नोलॉजी के विकल्पों के बारे में जानकारी:
    • uv: यह Python पैकेज मैनेजर का नया वर्शन है. यह pip से 10 से 100 गुना ज़्यादा तेज़ी से काम करता है. यह ग्लोबल कैश और पैरलल डाउनलोड का इस्तेमाल करता है. इससे कंटेनर बनाने में लगने वाला समय काफ़ी कम हो जाता है
    • Python 3.13-slim: यह Python का नया वर्शन है. इसमें सिस्टम से जुड़ी कम से कम डिपेंडेंसी होती हैं. इससे कंटेनर का साइज़ और अटैक सरफेस कम हो जाता है
    • मल्टी-स्टेज बिल्ड: इसकी आधिकारिक इमेज से uv को कॉपी करने से, हमें ऑप्टिमाइज़ किया गया नया बाइनरी मिलता है

9. एनवायरमेंट कॉन्फ़िगर करना और एजेंट डिप्लॉय करना

अब हम ADK एजेंट को कॉन्फ़िगर करेंगे, ताकि वह आपके डिप्लॉय किए गए Gemma बैकएंड से कनेक्ट हो सके. साथ ही, इसे Cloud Run सेवा के तौर पर डिप्लॉय करेंगे. इसमें एनवायरमेंट वैरिएबल सेट अप करना और सही कॉन्फ़िगरेशन के साथ एजेंट को डिप्लॉय करना शामिल है.

  1. अपना एनवायरमेंट कॉन्फ़िगरेशन सेट अप करें:
    cat << EOF > .env
GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
GOOGLE_CLOUD_LOCATION=europe-west1
GEMMA_MODEL_NAME=gemma3:270m
OLLAMA_API_BASE=$OLLAMA_URL
EOF

Cloud Run में एनवायरमेंट वैरिएबल को समझना

एनवायरमेंट वैरिएबल, की-वैल्यू पेयर होते हैं. ये रनटाइम पर आपके ऐप्लिकेशन को कॉन्फ़िगर करते हैं. ये खास तौर पर इन कामों के लिए मददगार होते हैं:

  • एपीआई एंडपॉइंट और सेवा के यूआरएल (जैसे, हमारा Ollama बैकएंड)
  • ऐसा कॉन्फ़िगरेशन जो अलग-अलग एनवायरमेंट (डेवलपमेंट, स्टेजिंग, प्रोडक्शन) के हिसाब से बदलता है
  • संवेदनशील डेटा जिसे हार्डकोड नहीं किया जाना चाहिए

ADK एजेंट को डिप्लॉय करें:

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

gcloud run deploy production-adk-agent \
   --source . \
   --region europe-west1 \
   --allow-unauthenticated \
   --memory 4Gi \
   --cpu 2 \
   --max-instances 1 \
   --concurrency 10 \
   --timeout 300 \
   --set-env-vars GOOGLE_CLOUD_PROJECT=$PROJECT_ID \
   --set-env-vars GOOGLE_CLOUD_LOCATION=europe-west1 \
   --set-env-vars GEMMA_MODEL_NAME=gemma3:270m \
   --set-env-vars OLLAMA_API_BASE=$OLLAMA_URL \
   --labels dev-tutorial=codelab-agent-gpu

⚙️ मुख्य कॉन्फ़िगरेशन:

  • ऑटोसकेलिंग: एक इंस्टेंस पर सेट है (कम संसाधनों का इस्तेमाल करके अनुरोधों को मैनेज करना)
  • एक साथ किए जाने वाले अनुरोध: हर इंस्टेंस के लिए 10 अनुरोध
  • मेमोरी: ADK एजेंट के लिए 4 जीबी
  • Environment: यह आपके Gemma बैकएंड से कनेक्ट होता है

🔒 सुरक्षा से जुड़ी जानकारी: इस लैब में, आसानी से समझने के लिए --allow-unauthenticated का इस्तेमाल किया गया है. प्रोडक्शन में, पुष्टि करने की सही सुविधा लागू करें. इसके लिए, इनका इस्तेमाल करें:

  • सेवा खातों की मदद से, Cloud Run की सेवा से सेवा की पुष्टि करना
  • आइडेंटिटी और ऐक्सेस मैनेजमेंट (आईएएम) नीतियां
  • बाहरी ऐक्सेस के लिए एपीआई कुंजियां या OAuth
  • ऐक्सेस कंट्रोल करने के लिए gcloud run services add-iam-policy-binding का इस्तेमाल करना

अपने एजेंट के लिए सर्विस यूआरएल पाएं:

export AGENT_URL=$(gcloud run services describe production-adk-agent \
    --region=europe-west1 \
    --format='value(status.url)')

echo "🎉 ADK Agent deployed at: $AGENT_URL"

✅ एनवायरमेंट वैरिएबल इस्तेमाल करने के सबसे सही तरीके, Cloud Run के एनवायरमेंट वैरिएबल के दस्तावेज़ के आधार पर:

  1. आरक्षित वैरिएबल का इस्तेमाल न करें: PORT (Cloud Run इसे अपने-आप सेट करता है) या X_GOOGLE_ से शुरू होने वाले वैरिएबल सेट न करें
  2. जानकारी देने वाले नामों का इस्तेमाल करें: वैरिएबल के नाम के आगे प्रीफ़िक्स जोड़ें, ताकि नाम एक-दूसरे से मैच न हों. उदाहरण के लिए, MODEL के बजाय GEMMA_MODEL_NAME)
  3. कॉमा से बचें: अगर आपकी वैल्यू में कॉमा शामिल हैं, तो किसी दूसरे डेलिमिटर का इस्तेमाल करें: --set-env-vars "^@^KEY1=value1,value2@KEY2=..."
  4. अपडेट बनाम बदलें: अन्य वैरिएबल पर असर डाले बिना, किसी वैरिएबल को जोड़ने/बदलने के लिए --update-env-vars का इस्तेमाल करें

Cloud Run में वैरिएबल कैसे सेट करें:

  • फ़ाइल से: gcloud run deploy SERVICE_NAME --env-vars-file .env --labels dev-tutorial codelab-adk (किसी फ़ाइल से कई वैरिएबल लोड करता है)
  • एक से ज़्यादा फ़्लैग: ऐसी जटिल वैल्यू के लिए --set-env-vars को दोहराएं जिन्हें कॉमा लगाकर अलग नहीं किया जा सकता

10. ADK के वेब इंटरफ़ेस का इस्तेमाल करके जांच करना

दोनों सेवाओं को डिप्लॉय करने के बाद, अब यह पुष्टि करने का समय है कि आपका ADK एजेंट, GPU की मदद से काम करने वाले Gemma के बैकएंड से कम्यूनिकेट कर सकता है या नहीं. साथ ही, यह भी पुष्टि करें कि वह उपयोगकर्ता की क्वेरी के जवाब दे सकता है या नहीं.

  1. सेहत की जानकारी देने वाले एंडपॉइंट की जांच करें:
    curl $AGENT_URL/health
    आपको यह दिखना चाहिए:
    { "status": "healthy", "service": "production-adk-agent" }
  2. अपने एजेंट से इंटरैक्ट करने के लिए, नए ब्राउज़र टैब में अपने production-adk-agent का यूआरएल डालें. आपको ADK का वेब इंटरफ़ेस दिखेगा.
  3. इन सैंपल बातचीत की मदद से, अपने एजेंट को टेस्ट करें:
    • "लाल पांडा आम तौर पर, जंगल में क्या खाते हैं?"
    • "क्या तुम मुझे हिम तेंदुओं के बारे में कोई दिलचस्प जानकारी दे सकते हो?"
    • "ज़हरीले डार्ट फ़्रॉग इतने चटख रंग के क्यों होते हैं?"
    • "मुझे चिड़ियाघर में नया बेबी कंगारू कहां मिलेगा?"
    👀 क्या देखें:
    • यह एजेंट, डिप्लॉय किए गए Gemma मॉडल का इस्तेमाल करके जवाब देता है. तैनात की गई Gemma सेवा के लॉग देखकर, इसकी पुष्टि की जा सकती है. हम अगले सेक्शन में ऐसा करेंगे
    • जवाब, जीपीयू की मदद से तेज़ी से काम करने वाले बैकएंड से जनरेट किए जाते हैं
    • वेब इंटरफ़ेस पर चैट करने का बेहतर अनुभव मिलता है

Lab 3 ADK Testing

11. लोड टेस्टिंग लागू करना और उसे चलाना

Lab 3 Load Testing

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

  1. लोड टेस्टिंग स्क्रिप्ट खोलें और लागू करें:
    cloudshell edit load_test.py
    TODO टिप्पणी को इससे बदलें:
    import random
import uuid
from locust import HttpUser, task, between

class ProductionAgentUser(HttpUser):
    """Load test user for the Production ADK Agent."""

    wait_time = between(1, 3)  # Faster requests to trigger scaling

    def on_start(self):
        """Set up user session when starting."""
        self.user_id = f"user_{uuid.uuid4()}"
        self.session_id = f"session_{uuid.uuid4()}"

        # Create session for the Gemma agent using proper ADK API format
        session_data = {"state": {"user_type": "load_test_user"}}

        self.client.post(
            f"/apps/production_agent/users/{self.user_id}/sessions/{self.session_id}",
            headers={"Content-Type": "application/json"},
            json=session_data,
        )

    @task(4)
    def test_conversations(self):
        """Test conversational capabilities - high frequency to trigger scaling."""
        topics = [
            "What do red pandas typically eat in the wild?",
            "Can you tell me an interesting fact about snow leopards?",
            "Why are poison dart frogs so brightly colored?",
            "Where can I find the new baby kangaroo in the zoo?",
            "What is the name of your oldest gorilla?",
            "What time is the penguin feeding today?"
        ]

        # Use proper ADK API format for sending messages
        message_data = {
            "app_name": "production_agent",
            "user_id": self.user_id,
            "session_id": self.session_id,
            "new_message": {
                "role": "user",
                "parts": [{
                    "text": random.choice(topics)
                }]
            }
        }

        self.client.post(
            "/run",
            headers={"Content-Type": "application/json"},
            json=message_data,
        )

    @task(1)
    def health_check(self):
        """Test the health endpoint."""
        self.client.get("/health")
    🔧 इस सेटिंग से क्या होता है:
    • सेशन बनाना: इसमें /apps/production_agent/users/{user_id}/sessions/{session_id} को पोस्ट करने के लिए, ADK API के सही फ़ॉर्मैट का इस्तेमाल किया जाता है. session_id और user_id बनाने के बाद, एजेंट से अनुरोध किया जा सकता है.
    • मैसेज फ़ॉर्मैट: यह एडीके के स्पेसिफ़िकेशन के मुताबिक होता है. इसमें app_name, user_id, session_id, और स्ट्रक्चर्ड new_message ऑब्जेक्ट शामिल होते हैं
    • Conversation Endpoint: यह एक साथ सभी इवेंट इकट्ठा करने के लिए, /run एंडपॉइंट का इस्तेमाल करता है. लोड टेस्टिंग के लिए इसका इस्तेमाल करने का सुझाव दिया जाता है
    • रियलिस्टिक लोड: यह सुविधा, बातचीत वाला लोड बनाती है. इससे इंतज़ार का समय कम हो जाता है और ऑटोस्केलिंग ट्रिगर हो जाती है
    📚 ADK API एंडपॉइंट और टेस्टिंग पैटर्न के बारे में ज़्यादा जानने के लिए, ADK टेस्टिंग गाइड देखें.
  2. डिपेंडेंसी इंस्टॉल करें:
    uv sync
pip install locust
  3. Locust एक ओपन-सोर्स टूल है. इसे Python की मदद से बनाया गया है. इसका इस्तेमाल वेब ऐप्लिकेशन और अन्य सिस्टम की परफ़ॉर्मेंस और लोड टेस्टिंग के लिए किया जाता है. इसकी मुख्य विशेषता यह है कि टेस्ट के अलग-अलग चरणों और उपयोगकर्ता के व्यवहार को स्टैंडर्ड Python कोड का इस्तेमाल करके तय किया जाता है. इससे, ग्राफ़िकल यूज़र इंटरफ़ेस या डोमेन के हिसाब से तय की गई भाषाओं पर निर्भर रहने वाले टूल की तुलना में, ज़्यादा फ़्लेक्सिबिलिटी और एक्सप्रेसिवनेस मिलती है. हम अपनी सेवाओं पर उपयोगकर्ता ट्रैफ़िक का सिम्युलेट करने के लिए, Locust का इस्तेमाल करेंगे.लोड टेस्ट चलाएं.
    # Run a load test to trigger autoscaling
locust -f load_test.py \
   -H $AGENT_URL \
   --headless \
   -t 50s \
   -u 3 \
   -r 1
    टेस्ट में पैरामीटर बदलकर देखें और आउटपुट पर नज़र रखें. आपको ollama-gemma3-270m-gpu में 2 से 3 इंस्टेंस की बढ़ोतरी दिखेगी. 📊 लोड टेस्ट के पैरामीटर:
    • अवधि: 50 सेकंड
    • उपयोगकर्ता: एक साथ तीन उपयोगकर्ता
    • स्पॉन रेट: हर सेकंड एक उपयोगकर्ता
    • टारगेट: दोनों सेवाओं पर ऑटोस्केलिंग ट्रिगर करें

12. ऑटोस्केलिंग की सुविधा के काम करने के तरीके को समझना

लोड टेस्ट के दौरान, Cloud Run की ऑटोस्केलिंग की सुविधा काम करती हुई दिखेगी. यहां आपको ADK एजेंट को GPU बैकएंड से अलग करने के मुख्य फ़ायदों के बारे में पता चलेगा.

लोड टेस्ट के दौरान, अपनी कंसोल में देखें कि Cloud Run की दोनों सेवाएं कैसे स्केल होती हैं.

  1. Cloud Console में, यहां जाएं:
    • Cloud Run → production-adk-agent → मेट्रिक
    • Cloud Run → ollama-gemma3-270m-gpu → मेट्रिक

👀 आपको इन बातों का ध्यान रखना चाहिए:

🤖 ADK Agent Service:

  • ट्रैफ़िक बढ़ने पर भी, एक ही इंस्टेंस पर स्थिर रहना चाहिए
  • ज़्यादा ट्रैफ़िक के दौरान सीपीयू और मेमोरी के इस्तेमाल में अचानक बढ़ोतरी होना
  • यह कुकी, सेशन मैनेजमेंट और अनुरोधों को सही तरीके से रूट करने का काम करती है

🎮 Gemma की बैकएंड सेवा (बॉटलनैक):

  • अनुमान लगाने की मांग के आधार पर, 1 से 3 इंस्टेंस तक स्केल करता है
  • लोड बढ़ने पर, जीपीयू का इस्तेमाल काफ़ी बढ़ जाता है
  • जीपीयू का ज़्यादा इस्तेमाल करने वाले मॉडल इन्फ़रेंस की वजह से, यह सेवा बॉटलनेक बन जाती है
  • जीपीयू ऐक्सेलरेटेड होने की वजह से, मॉडल इन्फ़रेंस के समय में कोई बदलाव नहीं होता

💡 अहम जानकारी:

  • जीपीयू बैकएंड, परफ़ॉर्मेंस में रुकावट डालने वाला कॉम्पोनेंट है. यह ज़्यादा तेज़ी से स्केल होता है (1 से 3 इंस्टेंस)
  • ADK एजेंट एक जैसा रहता है
  • दोनों सेवाएं, अपने-अपने लोड की विशेषताओं के आधार पर अलग-अलग स्केल होती हैं
  • ऑटोस्केलिंग की मदद से, अलग-अलग लोड की स्थितियों में परफ़ॉर्मेंस को बनाए रखने में मदद मिलती है

13. नतीजा

बधाई हो! आपने प्रोडक्शन के लिए तैयार ADK एजेंट को डिप्लॉय कर दिया है. इसमें जीपीयू की मदद से काम करने वाला Gemma बैकएंड है. साथ ही, आपने ऑटोस्केलिंग की सुविधा को भी देखा है.

✅ आपने क्या-क्या हासिल किया

  • ✅ Cloud Run पर, जीपीयू की मदद से काम करने वाले Gemma मॉडल के बैकएंड को डिप्लॉय किया गया हो
  • ✅ ADK एजेंट बनाया और उसे डिप्लॉय किया गया है. यह एजेंट, Gemma के बैकएंड के साथ इंटिग्रेट होता है
  • ✅ ADK के वेब इंटरफ़ेस का इस्तेमाल करके एजेंट की जांच की गई हो
  • ✅ दो कोऑर्डिनेटेड Cloud Run सेवाओं में, अपने-आप स्केलिंग होने की सुविधा काम करती है

💡 इस लैब से मिली अहम जानकारी

  1. 🎮 जीपीयू ऐक्सेलरेटेड: NVIDIA L4 जीपीयू, मॉडल इन्फ़रेंस की परफ़ॉर्मेंस को बेहतर बनाता है
  2. 🔗 सेवा समन्वय: दो Cloud Run सेवाएं एक साथ आसानी से काम कर सकती हैं
  3. 📈 इंडिपेंडेंट स्केलिंग: हर सेवा को उसके लोड की विशेषताओं के आधार पर स्केल किया जाता है
  4. 🚀 प्रोडक्शन का ऐक्सेस पाने के लिए ज़रूरी चीज़ें: आर्किटेक्चर, असल दुनिया के ट्रैफ़िक पैटर्न को असरदार तरीके से मैनेज करता है

🔄 अगले चरण

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

🧹 स्टोरेज खाली करें

शुल्क से बचने के लिए, काम पूरा होने के बाद संसाधनों को मिटा दें:

gcloud run services delete production-adk-agent --region=europe-west1
gcloud run services delete ollama-gemma3-270m-gpu --region=europe-west1

📖 संसाधन