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

1. מבוא

סקירה כללית

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

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

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

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

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

מה תלמדו

  • Deploy GPU-accelerated Gemma models to Cloud Run for production use
  • שילוב פריסות של מודלים חיצוניים עם סוכני ADK
  • הגדרה ובדיקה של פריסות של סוכני AI שמוכנים להפקה
  • הסבר על ההתנהגות של Cloud Run בעומס
  • איך אפשר לראות את התיאום בין כמה מכונות של Cloud Run בזמן שיש עליות חדות בתעבורה
  • איך משתמשים בבדיקת גמישות כדי לאמת את הביצועים

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

  1. אם אין לכם חשבון Google, אתם צריכים ליצור חשבון Google.
    • משתמשים בחשבון לשימוש אישי במקום בחשבון לצורכי עבודה או בחשבון בית ספרי. יכול להיות שבחשבונות לצורכי עבודה או בחשבונות בית ספריים יש הגבלות שלא מאפשרות להפעיל את ממשקי ה-API שנדרשים למעבדה הזו.
  2. נכנסים למסוף Google Cloud.
  3. מפעילים את החיוב במסוף Cloud.
    • העלות של השלמת ה-Lab הזה במשאבי Cloud צריכה להיות פחות מ-1$.
    • כדי למחוק משאבים ולמנוע חיובים נוספים, אפשר לבצע את השלבים בסוף ה-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)
    ├── elasticity_test.py       # Elasticity testing (🚧 to implement)
    └── production_agent/        # Agent implementation
        ├── __init__.py          # Package init (✅ completed)
        └── agent.py             # Agent logic (🚧 to implement)

6. סקירה כללית של הארכיטקטורה

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

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

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

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

שיעור Lab שלישי: שירות Gemma

השלב הראשון והחשוב הוא פריסת מודל 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 7 \
  --cpu 8 \
  --set-env-vars OLLAMA_NUM_PARALLEL=4 \
  --gpu 1 \
  --gpu-type nvidia-l4 \
  --max-instances 1 \
  --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 ליבות לטיפול אופטימלי בקלט/פלט ובמשימות עיבוד מקדים
  • מקביליות: 7 בקשות לכל מופע מאזנות את קצב העברת הנתונים עם השימוש בזיכרון ה-GPU
  • ‫Timeout: ‏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")
api_base = os.getenv("OLLAMA_API_BASE", "localhost:10010")  # Location of Ollama server

# Production Gemma Agent - GPU-accelerated conversational assistant
production_agent = Agent(
   model=LiteLlm(model=f"ollama_chat/{gemma_model_name}", api_base=api_base),
   name="production_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 = production_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 של שירותים (כמו ה-Ollama backend שלנו)
  • הגדרות שמשתנות בין סביבות (פיתוח, הכנה לייצור, ייצור)
  • מידע אישי רגיש שאסור להטמיע בקוד

פריסת סוכן 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 50 \
   --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

⚙️ הגדרות עיקריות:

  • שינוי גודל אוטומטי: קבוע על מופע אחד (טיפול קל בבקשות)
  • מקביליות: 50 בקשות לכל מופע
  • זיכרון: 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 (אם אתם צריכים לשנות את משתנה הסביבה, השתמשו במקום זאת בדגל ‎–port) או במשתנים שמתחילים ב-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

אחרי שפורסים את שני השירותים, צריך לוודא שאפשר לתקשר עם הקצה העורפי של 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 Testing

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

שיעור Lab 3: בדיקת גמישות

כדי להבין איך הפריסה בסביבת הייצור מתמודדת עם תנועה בעולם האמיתי, נטמיע בדיקת גמישות שתבדוק את היכולת של המערכת להסתגל לעומס עבודה גבוה יותר בסביבת הייצור 'המדומה'.

  1. פותחים את הסקריפט לבדיקת הגמישות ומטמיעים אותו:
    cloudshell edit elasticity_test.py
    מחליפים את הערת ה-TODO ב:
    import random
import uuid
from locust import HttpUser, task, between

class ProductionAgentUser(HttpUser):
    """Elasticity 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": "elasticity_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."""
        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
  3. ‫Locust הוא כלי לבדיקת עומסים בקוד פתוח שמבוסס על Python. הוא מיועד לבדיקת ביצועים ועומסים של אפליקציות אינטרנט ומערכות אחרות. המאפיין העיקרי שלו הוא שתסריטי בדיקה והתנהגות משתמש מוגדרים באמצעות קוד Python רגיל, מה שמאפשר גמישות רבה וביטוי מדויק בהשוואה לכלים שמסתמכים על ממשקי משתמש גרפיים או על שפות ספציפיות לתחום. נשתמש ב-Locust כדי לדמות תעבורת משתמשים לשירותים שלנו.מריצים את הבדיקה.
    ‫
    uv run locust -f elasticity_test.py \
   -H $AGENT_URL \
   --headless \
   -t 60s \
   -u 20 \
   -r 5
    נסו לשנות את הפרמטרים בבדיקה ולבחון את הפלט.📊 הפרמטרים של בדיקת הגמישות:
    • משך: 60 שניות
    • משתמשים: 20 משתמשים בו-זמנית
    • קצב יצירת המופעים: 5 משתמשים לשנייה
    • טירגוט: הפעלת שינוי גודל אוטומטי בשני השירותים

12. בדיקת התנהגות של התאמה לעומס (auto-scaling)

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

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

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

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

🤖 שירות סוכן ADK:

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

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

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

💡 תובנות חשובות:

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

13. סיכום

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

‫✅ מה השגתם

  • ‫✅ פריסה של קצה עורפי של מודל Gemma עם האצת GPU ב-Cloud Run
  • ‫✅ יצירה ופריסה של סוכן ADK שמשולב עם קצה העורף של Gemma
  • ‫✅ בדיקת הסוכן באמצעות ממשק האינטרנט של ADK
  • ‫✅ התנהגות של התאמה לעומס (autoscaling) שנצפתה בשני שירותי 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

📖 מקורות מידע