Lab 3: Prototipo alla produzione - Esegui il deployment dell'agente ADK su Cloud Run con GPU

1. Introduzione

Panoramica

In questo lab, eseguirai il deployment di un agente Agent Development Kit (ADK) pronto per la produzione con un backend Gemma con accelerazione GPU. L'attenzione è rivolta ai pattern di deployment critici: configurazione dei servizi Cloud Run abilitati alla GPU, integrazione dei backend dei modelli con gli agenti ADK e osservazione del comportamento di scalabilità automatica sotto carico.

In questo lab proverai a:

In questo lab ci concentreremo sugli aspetti critici del deployment di produzione:

  1. Esegui il deployment di Gemma su Cloud Run con GPU: configura un backend del modello Gemma ad alte prestazioni
  2. Integra il deployment di Gemma con un agente ADK: collega l'agente al modello con accelerazione GPU
  3. Test con l'interfaccia web ADK: verifica che l'agente conversazionale funzioni correttamente
  4. Esegui test di carico: osserva come le istanze Cloud Run vengono scalate automaticamente in base al carico

L'accento è posto sui pattern di deployment di produzione anziché sullo sviluppo esteso di agent.

Obiettivi didattici

  • Esegui il deployment di modelli Gemma con accelerazione GPU in Cloud Run per l'utilizzo in produzione
  • Integra i deployment di modelli esterni con gli agenti ADK
  • Configurare e testare i deployment di agenti AI pronti per la produzione
  • Comprendere il comportamento della scalabilità automatica di Cloud Run sotto carico
  • Osserva come più istanze Cloud Run si coordinano durante i picchi di traffico
  • Applica test di carico per convalidare le prestazioni e la scalabilità automatica

2. Configurazione del progetto

  1. Se non hai ancora un Account Google, devi crearne uno.
    • Utilizza un account personale anziché un account di lavoro o della scuola. Gli account di lavoro e della scuola potrebbero avere limitazioni che impediscono l'attivazione delle API necessarie per questo lab.
  2. Accedi a Google Cloud Console.
  3. Abilita la fatturazione in Cloud Console.
    • Il completamento di questo lab dovrebbe costare meno di 1 $in risorse cloud.
    • Per evitare ulteriori addebiti, puoi seguire i passaggi alla fine di questo lab per eliminare le risorse.
    • I nuovi utenti hanno diritto alla prova senza costi di 300$.
  4. Crea un nuovo progetto o scegli di riutilizzarne uno esistente.

3. Apri editor di Cloud Shell

  1. Fai clic su questo link per andare direttamente all'editor di Cloud Shell.
  2. Se ti viene richiesto di autorizzare in qualsiasi momento della giornata, fai clic su Autorizza per continuare. Fai clic per autorizzare Cloud Shell
  3. Se il terminale non viene visualizzato nella parte inferiore dello schermo, aprilo:
    • Fai clic su Visualizza.
    • Fai clic su TerminaleApri un nuovo terminale nell'editor di Cloud Shell.
  4. Nel terminale, imposta il progetto con questo comando:
    • Formato:
      gcloud config set project [PROJECT_ID]
    • Esempio:
      gcloud config set project lab-project-id-example
    • Se non ricordi l'ID progetto:
      • Puoi elencare tutti gli ID progetto con:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
      Imposta l'ID progetto nel terminale dell'editor di Cloud Shell
  5. Dovresti vedere questo messaggio:
    Updated property [core/project].
    Se visualizzi un WARNING e ti viene chiesto Do you want to continue (Y/n)?, probabilmente hai inserito l'ID progetto in modo errato. Premi n, premi Enter e prova a eseguire di nuovo il comando gcloud config set project.

4. Abilita le API e imposta la regione predefinita

Prima di poter eseguire il deployment dei servizi Cloud Run con supporto GPU, dobbiamo abilitare le API Google Cloud richieste e configurare le impostazioni del progetto.

  1. Nel terminale, abilita le API:
gcloud services enable \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  aiplatform.googleapis.com

Se ti viene richiesto di concedere l'autorizzazione, fai clic su Autorizza per continuare. Fai clic per autorizzare Cloud Shell

Il completamento di questo comando potrebbe richiedere alcuni minuti, ma alla fine dovrebbe essere visualizzato un messaggio di operazione riuscita simile a questo:

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.
  1. Imposta la regione Cloud Run predefinita.
gcloud config set run/region europe-west1

5. Prepara il progetto Python

Configuriamo il codice iniziale che contiene la struttura di base sia per il backend Gemma sia per i servizi dell'agente ADK.

  1. Clona il repository iniziale:
    cd ~
git clone https://github.com/amitkmaraj/accelerate-ai-lab3-starter.git
cd accelerate-ai-lab3-starter
  2. Esamina la struttura del progetto:
    ls -R
    Dovresti vedere la seguente struttura iniziale:
    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. Panoramica dell'architettura

Prima dell'implementazione, vediamo l'architettura a due servizi:

Lab 3 - Architettura a due servizi

Informazioni chiave: durante il test di carico, noterai che entrambi i servizi vengono scalati in modo indipendente: il backend GPU (servizio collo di bottiglia) viene scalato a 1-3 istanze per il carico di inferenza, mentre l'agente ADK rimane a 1 istanza per la gestione delle richieste.

7. Esegui il deployment del backend Gemma su Cloud Run con GPU

Lab 3 Gemma Service

Il primo passaggio fondamentale è il deployment di un modello Gemma con accelerazione GPU, che fungerà da cervello per l'agente ADK. Avere un LLM disaccoppiato e di cui è stato eseguito il deployment può essere vantaggioso nelle architetture in cui è necessario un modello ottimizzato separato o è necessario uno scaling isolato.

  1. Vai alla directory di backend di Ollama:
    cd ollama-backend
  2. Apri e implementa il Dockerfile di Ollama:
    cloudshell edit Dockerfile
    Sostituisci il commento TODO con:
    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"]
    🔧 Cosa fa:
    • Utilizza l'immagine ufficiale di Ollama come base
    • Imposta OLLAMA_HOST in modo che accetti connessioni da qualsiasi indirizzo IP
    • Espone la porta 8080
  3. Esegui il deployment del backend Gemma con il supporto 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

Se ricevi il messaggio "Il deployment dall'origine richiede un repository Docker Artifact Registry per archiviare i container creati. Verrà creato un repository denominato [cloud-run-source-deploy] nella regione [europe-west1].", continua.

⚙️ Spiegazione della configurazione dei tasti:

  • GPU: NVIDIA L4 scelta per l'eccellente rapporto prezzo/prestazioni per i carichi di lavoro di inferenza. L4 fornisce 24 GB di memoria GPU e operazioni tensoriali ottimizzate, il che lo rende ideale per modelli con 270 milioni di parametri come Gemma
  • Memoria: 16 GB di memoria di sistema per gestire il caricamento dei modelli, le operazioni CUDA e la gestione della memoria di Ollama
  • CPU: 8 core per la gestione ottimale di I/O e attività di pre-elaborazione
  • Concurrency: 4 richieste per istanza bilanciano la velocità effettiva con l'utilizzo della memoria GPU
  • Timeout: 600 secondi per il caricamento iniziale del modello e l'avvio del container

💰 Considerazione sui costi: le istanze GPU sono molto più costose delle istanze solo CPU (circa 2-4 $/ora contro circa 0,10 $/ora). L'impostazione --max-instances 1 consente di controllare i costi impedendo lo scaling non necessario delle istanze GPU.

  1. Attendi il completamento del deployment e prendi nota dell'URL del servizio:
    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. Implementare l'integrazione dell'agente ADK

Ora creiamo un agente ADK minimale che si connette al backend Gemma di cui hai eseguito il deployment.

  1. Vai alla directory dell'agente ADK:
    cd ../adk-agent
  2. Apri e implementa la configurazione dell'agente:
    cloudshell edit production_agent/agent.py
    Sostituisci tutti i commenti TODO con questa implementazione minima:
    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
    🔧 Cosa fa:
    • Si connette al backend Gemma di cui è stato eseguito il deployment tramite LiteLlm
    • Crea un agente conversazionale semplice
    • Configura l'integrazione con Google Cloud
  3. Apri e implementa il server FastAPI:
    cloudshell edit server.py
    Sostituisci tutti i commenti TODO con:
    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")
    🔧 Cosa fa:
    • Crea un server FastAPI con l'integrazione dell'ADK
    • Attiva l'interfaccia web per i test
    • Fornisce endpoint di controllo di integrità
  4. Apri e implementa il Dockerfile:
    cloudshell edit Dockerfile
    Sostituisci tutti i commenti TODO con:
    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"]
    Spiegazione delle scelte tecnologiche:
    • uv: gestore dei pacchetti Python moderno 10-100 volte più veloce di pip. Utilizza una cache globale e download paralleli, riducendo significativamente i tempi di creazione dei container
    • Python 3.13-slim: l'ultima versione di Python con dipendenze di sistema minime, che riduce le dimensioni del container e la superficie di attacco
    • Build in più fasi: la copia di uv dall'immagine ufficiale garantisce di ottenere l'ultimo binario ottimizzato

9. Configura l'ambiente e implementa l'agente

Ora configureremo l'agente ADK per connetterlo al backend Gemma di cui è stato eseguito il deployment ed eseguirne il deployment come servizio Cloud Run. Ciò comporta l'impostazione delle variabili di ambiente e il deployment dell'agente con la configurazione corretta.

  1. Configura la configurazione dell'ambiente:
    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

Informazioni sulle variabili di ambiente in Cloud Run

Le variabili di ambiente sono coppie chiave-valore che configurano l'applicazione in fase di runtime. Sono particolarmente utili per:

  • Endpoint API e URL di servizio (come il nostro backend Ollama)
  • Configurazione che cambia tra gli ambienti (dev, staging, prod)
  • Dati sensibili che non devono essere hardcoded

Esegui il deployment dell'agente 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

⚙️ Configurazione chiave:

  • Scalabilità automatica: fissa a 1 istanza (gestione leggera delle richieste)
  • Contemporaneità: 10 richieste per istanza
  • Memoria: 4 GB per l'agente ADK
  • Environment: si connette al backend di Gemma

🔒 Nota sulla sicurezza: questo lab utilizza --allow-unauthenticated per semplicità. In produzione, implementa l'autenticazione corretta utilizzando:

  • Autenticazione da servizio a servizio di Cloud Run con service account
  • Criteri IAM (Identity and Access Management)
  • Chiavi API o OAuth per l'accesso esterno
  • Valuta la possibilità di utilizzare gcloud run services add-iam-policy-binding per controllare l'accesso

Ottieni l'URL del servizio agente:

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

echo "🎉 ADK Agent deployed at: $AGENT_URL"

✅ Best practice per le variabili di ambiente basate sulla documentazione sulle variabili di ambiente di Cloud Run:

  1. Evita le variabili riservate: non impostare PORT (Cloud Run lo imposta automaticamente) o variabili che iniziano con X_GOOGLE_
  2. Utilizza nomi descrittivi: aggiungi un prefisso alle variabili per evitare conflitti (ad es. GEMMA_MODEL_NAME anziché MODEL)
  3. Virgole di escape: se i valori contengono virgole, utilizza un delimitatore diverso: --set-env-vars "^@^KEY1=value1,value2@KEY2=..."
  4. Aggiornamento e sostituzione: utilizza --update-env-vars per aggiungere/modificare variabili specifiche senza influire sulle altre

Come impostare le variabili in Cloud Run:

  • Da file: gcloud run deploy SERVICE_NAME --env-vars-file .env --labels dev-tutorial codelab-adk (carica più variabili da un file)
  • Più flag: ripeti --set-env-vars per valori complessi che non possono essere separati da virgole

10. Testare con l'interfaccia web ADK

Con entrambi i servizi di cui è stato eseguito il deployment, è il momento di verificare che l'agente ADK possa comunicare correttamente con il backend Gemma con accelerazione GPU e rispondere alle query degli utenti.

  1. Testa l'endpoint di integrità:
    curl $AGENT_URL/health
    Dovresti visualizzare:
    { "status": "healthy", "service": "production-adk-agent" }
  2. Interagisci con il tuo agente inserendo l'URL di production-adk-agent in una nuova scheda del browser. Dovresti visualizzare l'interfaccia web dell'ADK.
  3. Prova il tuo agente con queste conversazioni di esempio:
    • "Cosa mangiano in genere i panda rossi in natura?"
    • "Puoi dirmi un fatto interessante sui leopardi delle nevi?"
    • "Perché le rane freccia sono così colorate?"
    • "Dove posso trovare il nuovo cucciolo di canguro allo zoo?"
    👀 Cosa osservare:
    • L'agente risponde utilizzando il modello Gemma che hai implementato. Puoi verificarlo osservando i log del servizio Gemma di cui hai eseguito il deployment. Lo faremo nella prossima sezione.
    • Le risposte vengono generate dal backend accelerato dalla GPU
    • L'interfaccia web offre un'esperienza di chat pulita

Lab 3 ADK Testing

11. Implementare ed eseguire test di carico

Lab 3 Load Testing

Per capire come la tua implementazione di produzione gestisce il traffico reale, implementeremo test di carico completi che attiveranno la scalabilità automatica sia per l'agente ADK sia per i servizi di backend GPU.

  1. Apri e implementa lo script di test di carico:
    cloudshell edit load_test.py
    Sostituisci il commento TODO con:
    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")
    🔧 Cosa fa:
    • Creazione della sessione: utilizza il formato API ADK corretto con POST a /apps/production_agent/users/{user_id}/sessions/{session_id}. Dopo aver creato un session_id e un user_id, è possibile inviare una richiesta all'agente.
    • Formato messaggio: segue le specifiche dell'ADK con app_name, user_id, session_id e l'oggetto strutturato new_message
    • Endpoint conversazione: utilizza l'endpoint /run per raccogliere tutti gli eventi contemporaneamente (opzione consigliata per il test di carico)
    • Carico realistico: crea un carico conversazionale con tempi di attesa più brevi per attivare la scalabilità automatica
    📚 Per maggiori dettagli sugli endpoint API ADK e sui pattern di test, consulta la guida ai test ADK.
  2. Installa le dipendenze:
    uv sync
pip install locust
  3. Locust è uno strumento open source per il test del carico basato su Python, progettato per testare le prestazioni e il carico di applicazioni web e altri sistemi. La sua caratteristica principale è che gli scenari di test e il comportamento degli utenti sono definiti utilizzando il codice Python standard, offrendo un'elevata flessibilità ed espressività rispetto agli strumenti che si basano su interfacce utente grafiche o linguaggi specifici del dominio. Utilizzeremo Locust per simulare il traffico utente verso i nostri servizi.Esegui il test di carico.
    # Run a load test to trigger autoscaling
locust -f load_test.py \
   -H $AGENT_URL \
   --headless \
   -t 50s \
   -u 3 \
   -r 1
    Prova a modificare i parametri nel test e osserva l'output. Noterai un picco di ollama-gemma3-270m-gpu a 2-3 istanze. I📊 parametri del test di carico:
    • Durata: 50 secondi
    • Utenti: 3 utenti simultanei
    • Tasso di generazione: 1 utente al secondo
    • Target: attiva la scalabilità automatica su entrambi i servizi

12. Osserva il comportamento di scalabilità automatica

Man mano che il test di carico viene eseguito, potrai osservare la scalabilità automatica di Cloud Run in azione. Qui vedrai i principali vantaggi architetturali della separazione dell'agente ADK dal backend della GPU.

Durante il test di carico, monitora la scalabilità di entrambi i servizi Cloud Run nella console.

  1. Nella console Cloud, vai a:
    • Cloud Run → production-adk-agent → Metrics
    • Cloud Run → ollama-gemma3-270m-gpu → Metriche

👀 Cosa devi osservare:

🤖 Servizio agente ADK:

  • Deve rimanere stabile a 1 istanza mentre il traffico aumenta
  • Picco di utilizzo di CPU e memoria durante il traffico elevato
  • Gestisce in modo efficiente la gestione delle sessioni e il routing delle richieste

🎮 Servizio di backend di Gemma (collo di bottiglia):

  • Scalabilità da 1 a 3 istanze in base alla domanda di inferenza
  • L'utilizzo della GPU aumenta in modo significativo sotto carico
  • Questo servizio diventa il collo di bottiglia a causa dell'inferenza del modello che richiede un uso intensivo della GPU
  • I tempi di inferenza del modello rimangono coerenti grazie all'accelerazione GPU

💡 Approfondimenti chiave:

  • Il backend GPU è il collo di bottiglia e viene scalato in modo più aggressivo (1-3 istanze)
  • L'agente ADK rimane coerente
  • Entrambi i servizi scalano in modo indipendente in base alle caratteristiche di carico individuali
  • La scalabilità automatica contribuisce a mantenere le prestazioni in condizioni di carico variabili

13. Conclusione

Complimenti! Hai eseguito il deployment di un agente ADK pronto per la produzione con il backend Gemma con accelerazione GPU e hai osservato il comportamento di scalabilità automatica.

✅ Cosa hai realizzato

  • ✅ È stato eseguito il deployment di un backend del modello Gemma con accelerazione GPU su Cloud Run
  • ✅ Hai creato e implementato un agente ADK che si integra con il backend Gemma
  • ✅ L'agente è stato testato utilizzando l'interfaccia web ADK
  • ✅ Comportamento della scalabilità automatica osservato in due servizi Cloud Run coordinati

💡 Approfondimenti chiave di questo lab

  1. 🎮 Accelerazione GPU: la GPU NVIDIA L4 migliora significativamente le prestazioni di inferenza del modello
  2. 🔗 Coordinamento dei servizi: due servizi Cloud Run possono funzionare insieme senza problemi
  3. 📈 Scalabilità indipendente: ogni servizio viene scalato in base alle sue caratteristiche di carico individuali
  4. 🚀 Idoneità alla produzione: l'architettura gestisce in modo efficace i pattern di traffico reali

🔄 Passaggi successivi

  • Sperimenta diversi pattern di carico e osserva il comportamento di scalabilità
  • Prova diverse dimensioni del modello Gemma (regola di conseguenza la memoria e la GPU)
  • Implementa il monitoraggio e gli avvisi per i deployment di produzione
  • Esplora i deployment multiregionali per la disponibilità globale

🧹 Esegui la pulizia

Per evitare addebiti, elimina le risorse al termine:

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

📖 Risorse