שיעור Lab 3: אב טיפוס לייצור – פריסת סוכן ADK ב-Cloud Run עם GPU

1. מבוא

סקירה כללית

בשיעור ה-Lab הזה תפרסו סוכן של ערכת פיתוח סוכנים (ADK) שמוכן לייצור, עם קצה עורפי של Gemma שמואץ באמצעות GPU. הדגש הוא על דפוסי פריסה קריטיים: הגדרת שירותי Cloud Run עם תמיכה ב-GPU, שילוב של עורפי מודלים עם סוכני ADK וצפייה בהתנהגות של התאמה אוטומטית לעומס (autoscaling) בעומס.

הפעולות שתבצעו:

בשיעור ה-Lab הזה נתמקד בהיבטים הקריטיים של פריסת סביבת ייצור:

  1. פריסת Gemma ב-Cloud Run עם GPU – הגדרת קצה עורפי של מודל Gemma עם ביצועים גבוהים
  2. שילוב הפריסה של Gemma עם סוכן ADK – חיבור הסוכן למודל עם האצת GPU
  3. בדיקה באמצעות ממשק האינטרנט של ADK – אימות של סוכן שיחות
  4. ביצוע בדיקות עומס – מעקב אחרי ההתאמה האוטומטית לעומס של שתי מכונות Cloud Run

הדגש הוא על דפוסי פריסה בסביבת ייצור ולא על פיתוח נרחב של נציגים.

מה תלמדו

  • פריסת מודלים של Gemma עם האצת GPU ב-Cloud Run לשימוש בסביבת ייצור
  • שילוב פריסות של מודלים חיצוניים עם סוכני ADK
  • הגדרה ובדיקה של פריסות של סוכני AI שמוכנים להפעלה
  • הסבר על התנהגות של התאמה אוטומטית לעומס ב-Cloud Run
  • איך מתבצעת תיאום בין כמה מופעים של Cloud Run בזמן עלייה חדה בתעבורה
  • החלת בדיקות עומס כדי לאמת את הביצועים והתאמה לעומס (autoscaling)

2. הגדרת הפרויקט

  1. אם אין לכם חשבון Google, אתם צריכים ליצור חשבון Google.
    • משתמשים בחשבון לשימוש אישי במקום בחשבון לצורכי עבודה או בחשבון בית ספרי. יכול להיות שבחשבונות לצורכי עבודה או בחשבונות בית ספריים יש הגבלות שלא מאפשרות להפעיל את ממשקי ה-API שנדרשים למעבדה הזו.
  2. נכנסים למסוף Google Cloud.
  3. מפעילים את החיוב במסוף Cloud.
    • העלות של השלמת שיעור ה-Lab הזה צריכה להיות פחות מ-1 $‎ על משאבי Cloud.
    • כדי למחוק משאבים ולמנוע חיובים נוספים, אפשר לפעול לפי השלבים בסוף שיעור ה-Lab הזה.
    • משתמשים חדשים זכאים לתקופת ניסיון בחינם בשווי 300$.
  4. יוצרים פרויקט חדש או בוחרים להשתמש בפרויקט קיים.

3. פתיחת Cloud Shell Editor

  1. כדי לעבור ישירות אל Cloud Shell Editor, לוחצים על הקישור הזה.
  2. אם תתבקשו לאשר את הפעולה בשלב כלשהו היום, תצטרכו ללחוץ על אישור כדי להמשיך. לוחצים כדי לתת הרשאה ל-Cloud Shell
  3. אם הטרמינל לא מופיע בתחתית המסך, פותחים אותו:
    • לוחצים על תצוגה.
    • לוחצים על Terminal (מסוף)פתיחת טרמינל חדש ב-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. הפעלת ממשקי API והגדרת אזור ברירת מחדל

כדי שנוכל לפרוס שירותי Cloud Run עם תמיכה ב-GPU, אנחנו צריכים להפעיל את ממשקי Google Cloud API הנדרשים ולהגדיר את הגדרות הפרויקט.

  1. בטרמינל, מפעילים את ממשקי ה-API:
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

נתחיל בהגדרת קוד ההתחלה שמכיל את המבנה הבסיסי של שירותי ה-backend של 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. סקירה כללית של הארכיטקטורה

לפני שמיישמים, כדאי להבין את הארכיטקטורה של שני השירותים:

שיעור Lab 3: ארכיטקטורה של שני שירותים

תובנה מרכזית: במהלך בדיקת העומס, תראו ששני השירותים משנים את הגודל שלהם באופן עצמאי – קצה העורפי של ה-GPU (השירות שיוצר צוואר בקבוק) משנה את הגודל שלו ל-1 עד 3 מופעים לעומס ההסקה, בעוד שהסוכן של ADK נשאר במופע אחד לטיפול בבקשות.

7. פריסת Gemma Backend ב-Cloud Run עם GPU

שיעור Lab 3 Gemma Service

השלב הראשון והחשוב הוא פריסת מודל Gemma עם האצת GPU, שישמש כמוח של סוכן ה-ADK. יכול להיות שיהיה עדיף להשתמש ב-LLM מנותק ומוטמע בארכיטקטורות שבהן נדרש מודל נפרד שעבר כוונון עדין, או שנדרש שינוי קנה מידה מבודד.

  1. עוברים לספריית ה-backend של 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 כך שיקבל חיבורים מכל כתובת IP
    • חשיפת יציאה 8080
  3. פריסת קצה העורפי של Gemma עם תמיכה ב-GPU:
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

אם מופיעה ההודעה 'פריסה ממקור דורשת מאגר Docker ב-Artifact Registry לאחסון קונטיינרים שנבנו. ההודעה 'ייווצר מאגר בשם [cloud-run-source-deploy] באזור [europe-west1]', ממשיכים.

⚙️ הסבר על הגדרות מרכזיות:

  • ‫GPU: נבחר NVIDIA L4 בגלל יחס המחיר-ביצועים המצוין שלו לעומסי עבודה של הסקת מסקנות. ה-L4 מספק זיכרון GPU של 24GB ופעולות טנסור מותאמות, ולכן הוא אידיאלי למודלים עם 270 מיליון פרמטרים כמו Gemma
  • זיכרון: זיכרון מערכת בנפח 16GB לטיפול בטעינת המודל, בפעולות CUDA ובניהול הזיכרון של Ollama
  • מעבד (CPU): 8 ליבות לטיפול אופטימלי בקלט/פלט ובמשימות עיבוד מקדים
  • מקביליות: 4 בקשות לכל מכונה מאזנות את קצב העברת הנתונים עם השימוש בזיכרון ה-GPU
  • זמן קצוב לתפוגה: 600 שניות מאפשרות טעינה ראשונית של המודל והפעלה של הקונטיינר

💰 שיקולי עלות: מכונות עם GPU יקרות משמעותית ממכונות עם CPU בלבד (כ-2-4$לשעה לעומת כ-0.10$לשעה). ההגדרה --max-instances 1 עוזרת לשלוט בעלויות על ידי מניעת שינוי גודל מיותר של מכונות עם GPU.

  1. ממתינים לסיום הפריסה ורושמים את כתובת ה-URL של השירות:
    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
    Replace all TODO comment with this minimal implementation:
    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
    🔧 מה זה עושה:
    • מתחבר ל-backend של Gemma שפרסתם באמצעות LiteLlm
    • תבנית ליצירת צ'אט בוט פשוט
    • הגדרה של שילוב עם Google Cloud
  3. פותחים ומיישמים את שרת FastAPI:
    cloudshell edit server.py
    Replace all TODO comment with:
    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")
    🔧 מה זה עושה:
    • יצירת שרת FastAPI עם שילוב ADK
    • הפעלת ממשק האינטרנט לבדיקה
    • מספק נקודות קצה לבדיקות תקינות
  4. פותחים את קובץ ה-Dockerfile ומטמיעים אותו:
    cloudshell edit Dockerfile
    Replace all TODO comment with:
    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, שמהירה פי 10 עד פי 100 מ-pip. הוא משתמש במטמון גלובלי ובהורדות מקבילות, וכך מקצר משמעותית את הזמן שנדרש ליצירת קונטיינרים
    • ‫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

משתני סביבה הם צמדי מפתח/ערך שמגדירים את האפליקציה בזמן הריצה. הם שימושיים במיוחד במקרים הבאים:

  • נקודות קצה של API וכתובות URL של שירותים (כמו ה-backend של 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 בקשות לכל מופע
  • זיכרון: 4GB לסוכן ADK
  • סביבה: מתחבר לחלק האחורי של Gemma

🔒 הערת אבטחה: כדי לפשט את התרגול הזה, אנחנו משתמשים ב---allow-unauthenticated. בסביבת ייצור, צריך להטמיע אימות מתאים באמצעות:

  • אימות משירות לשירות ב-Cloud Run באמצעות חשבונות שירות
  • כללי מדיניות של ניהול זהויות והרשאות גישה (IAM)
  • מפתחות API או OAuth לגישה חיצונית
  • כדאי להשתמש ב-gcloud run services add-iam-policy-binding כדי לשלוט בגישה

כדי לקבל את כתובת ה-URL של שירות הנציגים:

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. שימוש בשמות תיאוריים: כדי למנוע התנגשויות, כדאי להוסיף קידומת למשתנים (למשל, ‫GEMMA_MODEL_NAME במקום MODEL)
  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 כדי לתקשר עם הקצה העורפי של Gemma שמואץ על ידי GPU, ולקבל ממנו תשובות לשאילתות של משתמשים.

  1. בודקים את נקודת הסיום של בדיקת התקינות:
    curl $AGENT_URL/health
    אלה הפרטים שיוצגו:
    { "status": "healthy", "service": "production-adk-agent" }
  2. כדי ליצור אינטראקציה עם הסוכן, מזינים את כתובת ה-URL של production-adk-agent בכרטיסייה חדשה בדפדפן. אמור להופיע ממשק האינטרנט של ADK.
  3. כדאי לבדוק את הנציג באמצעות שיחות לדוגמה:
    • "What do red pandas typically eat in the wild?"
    • "Can you tell me an interesting fact about snow leopards?"
    • "למה צפרדעים רעילות כל כך צבעוניות?"
    • "איפה אפשר לראות את גור הקנגורו החדש בגן החיות?"
    👀 מה כדאי לבדוק:
    • הנציג מגיב באמצעות מודל Gemma שפרסתם. כדי לוודא זאת, אפשר לעיין ביומנים של שירות Gemma שפרסתם. בקטע הבא נסביר איך עושים את זה
    • התשובות נוצרות על ידי קצה עורפי עם האצת GPU
    • ממשק האינטרנט מספק חוויית צ'אט נקייה

בדיקות Lab 3 ADK

11. הטמעה והרצה של בדיקות עומס

שיעור Lab שלישי: בדיקת עומס

כדי להבין איך פריסת הייצור שלכם מטפלת בתנועה בעולם האמיתי, נטמיע בדיקות עומס מקיפות שיפעילו שינוי גודל אוטומטי גם בסוכן ADK וגם בשירותי ה-Backend של ה-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")
    🔧 מה זה עושה:
    • יצירת סשן: נעשה שימוש בפורמט הנכון של ADK API עם POST ל-/apps/production_agent/users/{user_id}/sessions/{session_id}. אחרי שיוצרים session_id וuser_id, אפשר לשלוח בקשה לסוכן.
    • פורמט ההודעה: בהתאם למפרט של ADK עם app_name, user_id, session_id ואובייקט מובנה new_message
    • נקודת קצה של שיחה: משתמשת בנקודת הקצה /run לאיסוף של כל האירועים בבת אחת (מומלץ לבדיקות עומס)
    • עומס ריאליסטי: יוצר עומס שיחות עם זמני המתנה קצרים יותר כדי להפעיל התאמה אוטומטית לעומס
    📚 לפרטים נוספים על נקודות קצה (endpoints) של 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 שניות
    • משתמשים: 3 משתמשים בו-זמנית
    • קצב יצירת המופעים: משתמש אחד לשנייה
    • יעד: הפעלת שינוי גודל אוטומטי בשני השירותים

12. התבוננות בהתנהגות של התאמה לעומס (autoscaling)

במהלך הפעלת בדיקת העומס, תוכלו לראות את ההתאמה האוטומטית של Cloud Run בפעולה. כאן אפשר לראות את היתרונות הארכיטקטוניים העיקריים של הפרדת סוכן ה-ADK מקצה העורפי של ה-GPU.

במהלך בדיקת העומס, עוקבים במסוף אחרי ההתאמה של שני שירותי Cloud Run.

  1. במסוף Cloud, עוברים אל:
    • Cloud Run → production-adk-agent → Metrics
    • ‫Cloud Run ‏→ ollama-gemma3-270m-gpu ‏→ מדדים

👀 מה כדאי לבדוק:

🤖 ADK Agent Service:

  • צריך להישאר יציב על מכונה אחת בזמן שהתנועה גדלה
  • שימוש גבוה ב-CPU ובזיכרון בזמן תנועה גבוהה
  • מטפל ביעילות בניהול סשנים ובניתוב בקשות

🎮 שירות Gemma לקצה העורפי (צוואר בקבוק):

  • ההיקף משתנה ממופע אחד ל-3 מופעים בהתאם לביקוש להסקת מסקנות
  • ניצול ה-GPU עולה משמעותית בעומס
  • השירות הזה הופך לצוואר בקבוק בגלל הסקת מודלים שדורשת הרבה משאבי GPU
  • זמני ההסקה של המודל נשארים עקביים בזכות ההאצה באמצעות GPU

💡 תובנות מרכזיות:

  • ה-Backend של ה-GPU הוא צוואר הבקבוק ומתרחב בצורה אגרסיבית יותר (1-3 מופעים)
  • הסוכן של ADK נשאר עקבי
  • שני השירותים ניתנים להרחבה באופן עצמאי על סמך מאפייני העומס האישיים שלהם
  • שינוי גודל אוטומטי עוזר לשמור על רמת הביצועים בתנאי עומס משתנים

13. סיכום

מעולה! הצלחתם לפרוס סוכן ADK מוכן לייצור עם קצה עורפי של Gemma עם האצת GPU, ולצפות בהתנהגות של שינוי גודל אוטומטי.

‫✅ מה השגתם

  • ‫✅ פריסת קצה עורפי של מודל Gemma עם האצת GPU ב-Cloud Run
  • ‫✅ יצירה ופריסה של סוכן ADK שמשתלב עם קצה העורפי של Gemma
  • ‫✅ בדיקת הסוכן באמצעות ממשק האינטרנט של ADK
  • ‫✅ התנהגות של התאמה אוטומטית לעומס שנצפתה בשני שירותי Cloud Run מתואמים

💡 תובנות חשובות משיעור ה-Lab הזה

  1. ‫🎮 האצת GPU: מעבד ה-GPU‏ NVIDIA L4 משפר באופן משמעותי את ביצועי הסקת המסקנות של המודל
  2. 🔗 תיאום בין שירותים: שני שירותים של Cloud Run יכולים לפעול יחד בצורה חלקה
  3. 📈 התאמה לעומס (scaling) באופן עצמאי: כל שירות מותאם לעומס על סמך מאפייני העומס הייחודיים שלו
  4. 🚀 מוכנות לסביבת הייצור: הארכיטקטורה מטפלת ביעילות בדפוסי תנועה בעולם האמיתי

‫🔄 השלבים הבאים

  • עורכים ניסויים בדפוסי טעינה שונים ומתבוננים בהתנהגות של שינוי הגודל
  • לנסות גדלים שונים של מודל Gemma (לשנות את הזיכרון ואת ה-GPU בהתאם)
  • הטמעה של מעקב והתראות לגבי פריסות בסביבת ייצור
  • הכרת פריסות בכמה אזורים לזמינות גלובלית

🧹 ניקוי

כדי להימנע מחיובים, מוחקים את המשאבים בסיום השימוש:

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

📖 מקורות מידע