Créer et déployer des agents IA avec Gemma 4 et le serveur MCP BigQuery dans Cloud Run

1. Introduction

Remarque : Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement

Présentation

Points abordés

• Déployer un modèle Gemma 4 sur un Cloud Run GPU RTX 6000 Pro avec vLLM
• Créer un agent IA à l'aide d'Agent Development Kit (ADK) et utiliser Gemma 4 avec celui-ci
• Accorder aux agents IA l'accès à des données structurées dans BigQuery à l'aide du serveur BigQuery MCP

Gemma 4 est une famille de modèles à poids ouverts sous licence Apache 2 de Google DeepMind. Les modèles sont multimodaux, multilingues, offrent un raisonnement et une architecture efficace.

Cloud Run est un environnement sans serveur pour les conteneurs compatible avec les GPU.

Agent Development Kit (ADK) est un framework de développement d'agents Open Source qui vous permet de créer, de déboguer et de déployer des agents IA fiables à l'échelle de l'entreprise.

BigQuery est un entrepôt de données d'entreprise sans serveur, entièrement géré, qui vous permet de stocker, d'interroger et d'analyser des ensembles de données volumineux.

Le Model Context Protocol (MCP) standardise la façon dont les grands modèles de langage (LLM) et les applications ou agents IA se connectent à des sources de données externes. Les serveurs MCP vous permettent d'utiliser leurs outils, ressources et requêtes pour effectuer des actions et obtenir des données mises à jour à partir de leur service de backend. Le serveur BigQuery MCP offre à vos agents IA un moyen direct et sécurisé d'analyser les données dans BigQuery. Ce serveur MCP entièrement géré élimine les frais généraux de gestion, ce qui vous permet de vous concentrer sur le développement d'agents intelligents.

Remarque : Cet atelier de programmation utilise le modèle Gemma 4 31B Instruction-Tuned. Il explique comment utiliser Run:ai Model Streamer et la sortie VPC directe pour réduire le temps nécessaire au chargement du modèle à partir de Cloud Storage lors du démarrage du conteneur. Pour en savoir plus, consultez le guide des bonnes pratiques concernant les GPU.

2. Préparation

L'ensemble de cet atelier peut être exécuté sur la ligne de commande. Vous pouvez utiliser Cloud Shell (cliquez sur l'icône d'invite en haut à droite de la console) pour démarrer l'environnement.

Commencez par définir le projet par défaut et la région Cloud Run :

# set the project
gcloud config set project YOUR_PROJECT_ID

Remplacez YOUR_PROJECT_ID par l'ID de votre projet Google Cloud.

# set Cloud Run region
REGION="CLOUD-RUN-REGION"; gcloud config set run/region $REGION && echo $REGION > lab2rgn.txt

Remplacez CLOUD-RUN-REGION par l'une des régions Cloud suivantes :

• us-central1
• asia-southeast1

Voici les variables d'environnement qui seront utilisées tout au long de cet atelier de programmation. Vous pouvez les enregistrer dans un fichier d'environnement et les "sourcer". Veillez à définir correctement la valeur de l'ID de votre projet et, éventuellement, de la région.

# Model name on HuggingFace Hub
export MODEL_NAME="google/gemma-4-31B-it"

# Cloud Run Service name
export SERVICE_NAME="gemma4-rtx-vllm-codelab"

# Cloud Project and Region for Cloud Run
export GOOGLE_CLOUD_PROJECT=$(gcloud config get project -q)
export GOOGLE_CLOUD_REGION=$(cat lab2rgn.txt 2> /dev/null || gcloud config get run/region -q)

# Service account for Cloud Run service
export SERVICE_ACCOUNT="vllm-service-sa"
export SERVICE_ACCOUNT_EMAIL="${SERVICE_ACCOUNT}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com"

# GCS Bucket for the model cache.
export MODEL_CACHE_BUCKET="${GOOGLE_CLOUD_PROJECT}-${GOOGLE_CLOUD_REGION}-hf-model-cache"
# Model cache location in GSC bucket
export GCS_MODEL_LOCATION="gs://${MODEL_CACHE_BUCKET}/model-cache/${MODEL_NAME}"
# Uncomment next line if loading gemma-4-31B-it directly from the public cache bucket
# export GCS_MODEL_LOCATION="gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it"

# VPC Network for Direct VPC Egress
export VPC_NETWORK="vllm-${GOOGLE_CLOUD_REGION}-net"
export VPC_SUBNET="vllm-${GOOGLE_CLOUD_REGION}-subnet"
export SUBNET_RANGE="10.8.0.0/26"

Remarque : Il est utile d'enregistrer cet extrait en tant que fichier de script et de le réutiliser à l'avenir, lorsque la session Cloud Shell est réinitialisée. Enregistrez-le sous le nom env.sh et exécutez source env.sh pour définir les variables d'environnement lors des étapes suivantes. N'effectuez pas de commit env.sh dans les systèmes de contrôle des versions.

Activez les API nécessaires pour cet atelier de programmation. La prise en compte des modifications apportées aux API peut prendre deux à trois minutes.

gcloud services enable --project "${GOOGLE_CLOUD_PROJECT}" \
    run.googleapis.com \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    iam.googleapis.com \
    compute.googleapis.com \
    vpcaccess.googleapis.com \
    storage.googleapis.com \
    bigquery.googleapis.com \
    aiplatform.googleapis.com

3. Créer un compte de service

Si vous ne spécifiez pas de compte de service lors de la création du service ou du job Cloud Run, Cloud Run utilise le compte de service Compute Engine par défaut. Il est recommandé d'utiliser un compte de service distinct pour le service Cloud Run afin d'éviter d'exécuter le service avec des autorisations excessives.

Créer un compte de service pour le service Cloud Run

gcloud iam service-accounts create ${SERVICE_ACCOUNT} \
  --project "${GOOGLE_CLOUD_PROJECT}" \
  --display-name "vLLM Service Account"

4. Configurer Cloud Storage

Créez un bucket Cloud Storage pour stocker les pondérations du modèle. Cela vous permettra d'utiliser la sortie VPC directe pour télécharger plus rapidement les pondérations du modèle chaque fois que Cloud Run démarre une instance de service.

Combinée à la fonctionnalité Run:ai Model Streamer de vLLM, elle réduit considérablement le temps de chargement du modèle.

Créer un bucket

Assurez-vous qu'il s'agit d'un bucket à région unique colocalisé avec le service Cloud Run.

gcloud storage buckets create "gs://${MODEL_CACHE_BUCKET}" \
    --uniform-bucket-level-access --public-access-prevention \
    --project "${GOOGLE_CLOUD_PROJECT}" --location "${GOOGLE_CLOUD_REGION}"

5. Récupérer et mettre en cache les pondérations du modèle

Ensuite, téléchargez le modèle Gemma 4 dans votre bucket Cloud Storage. Les pondérations des modèles représentent des dizaines de gigaoctets, et il peut être impossible de les télécharger d'abord sur votre machine locale ou dans Cloud Shell. Utilisez plutôt Cloud Build avec suffisamment de stockage pour contenir les pondérations du modèle.

Copier les pondérations du modèle à partir d'un bucket Cloud Storage partagé

Google Cloud héberge un bucket Cloud Storage accessible au public avec les pondérations du modèle Gemma 4.

Si vous utilisez l'une des régions us-, au lieu de copier les pondérations du modèle, vous pouvez simplement modifier GCS_MODEL_LOCATION pour qu'il pointe vers l'emplacement du cache public. Par exemple, pour le modèle gemma-4-31B-it, définissez export GCS_MODEL_LOCATION="gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it" (si vous utilisez un fichier d'environnement, tel que .env ou env.sh, n'oubliez pas de le modifier).

Pour les copier dans votre bucket de stockage, exécutez la commande suivante :

gcloud builds submit --project="${GOOGLE_CLOUD_PROJECT}" --region="${GOOGLE_CLOUD_REGION}" --no-source \
    --substitutions="_MODEL_NAME=${MODEL_NAME},_GCS_MODEL_LOCATION=${GCS_MODEL_LOCATION}" \
    --config=/dev/stdin <<'EOF'
steps:
- name: 'gcr.io/google.com/cloudsdktool/google-cloud-cli:slim'
  entrypoint: 'bash'
  args:
  - '-c'
  - |
    if [[ "$_GCS_MODEL_LOCATION" == *"vertex-model-garden-public-us"* ]]; then
      echo "Using the public cache bucket."
      exit 0
    fi
    gcloud config set storage/parallel_composite_upload_enabled True
    gcloud config set storage/parallel_composite_upload_threshold 150M
    gcloud config set storage/sliced_object_download_threshold 150M
    MODEL_NAME="$_MODEL_NAME"
    SHORT_NAME="$${MODEL_NAME#*/}"
    gcloud storage cp -r -D "gs://vertex-model-garden-public-us/gemma4/$${SHORT_NAME}" "$_GCS_MODEL_LOCATION"
EOF

Remarque : Cette opération prend beaucoup de temps, entre 10 et 30 minutes.

6. Configurer la mise en réseau pour la sortie VPC directe

La configuration de la sortie VPC directe nécessite la création d'un réseau et d'un sous-réseau avec l'accès privé à Google activé.

Cela permet aux services Cloud Run de se connecter à l'ensemble d'adresses IP externes utilisées par les API et services Google, y compris Cloud Storage.

Créer un réseau

gcloud compute networks create "$VPC_NETWORK" \
        --subnet-mode=custom \
        --bgp-routing-mode=regional \
        --project "$GOOGLE_CLOUD_PROJECT"

Créer un sous-réseau

gcloud compute networks subnets create "$VPC_SUBNET" \
        --network="$VPC_NETWORK" \
        --region="$GOOGLE_CLOUD_REGION" \
        --range="$SUBNET_RANGE" \
        --enable-private-ip-google-access \
        --project "$GOOGLE_CLOUD_PROJECT"

7. Configurer la stratégie d'accès au compte de service

Le compte de service Cloud Run a besoin d'autorisations pour accéder aux pondérations du modèle dans le bucket de stockage que vous avez créé.

gcloud storage buckets add-iam-policy-binding "gs://${MODEL_CACHE_BUCKET}" \
    --member "serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --role "roles/storage.admin" \
    --project "${GOOGLE_CLOUD_PROJECT}"

8. Initialiser les variables de configuration

Définissez les variables pour le moteur d'inférence vLLM et le service Cloud Run.

# vLLM variables
export MAX_MODEL_LEN="32767"    # 32767 to improve concurrency. Keep it empty to use model's maximim context length (256K)
export QUANTIZATION_TYPE="fp8"  # Model quantization for faster performance and lower memory usage.
export KV_CACHE_DTYPE="fp8"     # KV-cache quantization to save GPU memory.
export GPU_MEM_UTIL="0.95"      # Fraction of GPU memory to be used by the vLLM engine.
export TENSOR_PARALLEL_SIZE="1" # Partitioning model across GPUs (1 here as we have only 1 GPU).
export MAX_NUM_SEQS="16"         # Max concurrent requests vLLM processes in one batch.

# Cloud Run variables
export CLOUD_RUN_CPU_NUM=20
export CLOUD_RUN_MEMORY_GB=80
export CLOUD_RUN_MAX_INSTANCES=1
export CLOUD_RUN_CONCURRENCY=16

Remarque sur l'optimisation des performances : L'optimisation de ces variables est un équilibre entre le débit et la latence :

• MAX_NUM_SEQS vs CLOUD_RUN_CONCURRENCY: CLOUD_RUN_CONCURRENCY doit être au moins aussi grand que MAX_NUM_SEQS. Pour une utilisation optimale en cas de pics de trafic, définissez-le légèrement plus haut (par exemple, 2x).
• Pression sur la mémoire : MAX_MODEL_LEN et MAX_NUM_SEQS consomment tous deux de la mémoire GPU pour le cache KV. Si vous rencontrez des erreurs de mémoire insuffisante (OOM) avec des longueurs de contexte importantes, envisagez de réduire MAX_NUM_SEQS.
• Latence : une simultanéité plus élevée (MAX_NUM_SEQS) augmente le débit total, mais peut augmenter la latence des requêtes individuelles.
• Scaling: CLOUD_RUN_MAX_INSTANCES vous permet d'effectuer un scaling horizontal. Si la latence de votre instance unique est acceptable, mais que vous avez besoin d'une capacité totale plus importante, augmentez cette valeur.

9. Déployer dans Cloud Run

Préparer la ligne de commande du conteneur vLLM

vLLM nécessite de nombreux paramètres pour exécuter des modèles volumineux rapidement et efficacement. Ces paramètres seront transmis en tant qu'arguments au conteneur déployé sur Cloud Run.

CONTAINER_ARGS=(
    "vllm"
    "serve"
    "${GCS_MODEL_LOCATION}"
    "--served-model-name" "${MODEL_NAME}"
    "--enable-log-requests"
    "--enable-chunked-prefill"
    "--enable-prefix-caching"
    "--generation-config" "auto"
    "--enable-auto-tool-choice"
    "--tool-call-parser" "gemma4"
    "--reasoning-parser" "gemma4"
    "--dtype" "bfloat16"
    "--quantization" "${QUANTIZATION_TYPE}"
    "--kv-cache-dtype" "${KV_CACHE_DTYPE}"
    "--max-num-seqs" "${MAX_NUM_SEQS}"
    "--gpu-memory-utilization" "${GPU_MEM_UTIL}"
    "--tensor-parallel-size" "${TENSOR_PARALLEL_SIZE}"
    "--load-format" "runai_streamer"
    "--port" "8080"
    "--host" "0.0.0.0"
)

if [[ "${MAX_MODEL_LEN}" != "" ]]; then
    CONTAINER_ARGS+=("--max-model-len" "${MAX_MODEL_LEN}")
fi

export CONTAINER_ARGS_STR="${CONTAINER_ARGS[*]}"

Déployer le service Cloud Run

Exécutez la commande suivante pour déployer le service Cloud Run. Notez le type de GPU (RTX 6000 Pro), l'image de base (pytorch-vllm-serve:gemma4) et la nécessité de s'authentifier pour appeler le service (--no-allow-unauthenticated).

gcloud beta run deploy "${SERVICE_NAME}" \
    --image="us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4" \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --region "${GOOGLE_CLOUD_REGION}" \
    --service-account "${SERVICE_ACCOUNT_EMAIL}" \
    --execution-environment gen2 \
    --no-allow-unauthenticated \
    --cpu="${CLOUD_RUN_CPU_NUM}" \
    --memory="${CLOUD_RUN_MEMORY_GB}Gi" \
    --gpu=1 \
    --gpu-type=nvidia-rtx-pro-6000 \
    --no-gpu-zonal-redundancy \
    --no-cpu-throttling \
    --max-instances ${CLOUD_RUN_MAX_INSTANCES} \
    --concurrency ${CLOUD_RUN_CONCURRENCY} \
    --network ${VPC_NETWORK} \
    --subnet ${VPC_SUBNET} \
    --vpc-egress all-traffic \
    --set-env-vars "MODEL_NAME=${MODEL_NAME}" \
    --set-env-vars "GOOGLE_CLOUD_PROJECT=${GOOGLE_CLOUD_PROJECT}" \
    --set-env-vars "GOOGLE_CLOUD_REGION=${GOOGLE_CLOUD_REGION}" \
    --port=8080 \
    --timeout=3600 \
    --cpu-boost \
    --startup-probe tcpSocket.port=8080,initialDelaySeconds=240,failureThreshold=40,timeoutSeconds=10,periodSeconds=15 \
    --command "bash" \
    --args="^;^-c;${CONTAINER_ARGS_STR}"

Le déploiement prendra quelques minutes. Une fois terminé, vous disposerez d'un environnement basé sur GPU qui diffuse Gemma 4 à l'aide d'une infrastructure sans serveur avec autoscaling, y compris le scaling à zéro (pas de trafic, pas de coût).

Remarque : Si le déploiement du service échoue en raison de la disponibilité ou du quota de GPU, ignorez le test du service et passez à la section Créer un agent de données à l'aide d'Agent Development Kit. L'agent peut utiliser Gemini 3.5 Flash Lite dans Gemini Enterprise Agent Platform s'il n'y a pas de service Gemma 4 à utiliser.

10. Tester le service

Une fois déployé, vous pouvez interagir avec votre modèle Gemma 4 à l'aide de l'API compatible avec vLLM OpenAI.

Obtenir l'URL du service

Récupérez l'URL de votre service Cloud Run déployé.

SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --project "${GOOGLE_CLOUD_PROJECT}" --region "${GOOGLE_CLOUD_REGION}" --format 'value(status.url)')
echo "Service URL: $SERVICE_URL"

Exécuter une inférence

Envoyez une requête au modèle à l'aide de curl.

curl -s "$SERVICE_URL/v1/chat/completions" \
  -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "'"${MODEL_NAME}"'",
  "messages": [
    {"role": "user", "content": "Why is the sky blue?"}
  ],
  "chat_template_kwargs": {
    "enable_thinking": true
  },
  "skip_special_tokens": false
}' | jq -r '.choices[0].message.content'

11. Créer un agent de données à l'aide d'Agent Development Kit

Écrire le code de l'agent

À partir du terminal Cloud Shell ou de votre terminal local, créez un répertoire racine pour votre application d'agent :

mkdir data_agent

Ouvrez l'éditeur Cloud Shell ou un autre éditeur de texte, puis créez agent.py dans le répertoire data_agent :

data_agent/
    agent.py

agent.py

import os
import subprocess

from google.adk.agents import LlmAgent
from google.adk.models.lite_llm import LiteLlm
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

import google.auth
from google.auth.transport.requests import Request
from google.oauth2 import id_token

# Fetch Application Default Credentials (ADC)
application_default_credentials, project_id = google.auth.default()
application_default_credentials.refresh(Request())

# Retrieve Google Cloud project to use.
project_id = os.getenv("GOOGLE_CLOUD_PROJECT", project_id)
if not project_id:
    raise ValueError("GOOGLE_CLOUD_PROJECT environment variable is not set.")

if os.getenv("GOOGLE_GENAI_USE_ENTERPRISE", "").lower() not in ["true", "1"]:
    # Using Cloud Run for hosting LLM with LiteLLM wrapper
    api_base = os.getenv(
        "API_BASE",
        os.environ.get("OPENAI_API_BASE", "")
    ).rstrip("/")
    if not api_base:
        raise ValueError("API_BASE environment variable is not set")
    if not api_base.endswith("/v1"):
        api_base += "/v1"

    model_name = os.getenv("MODEL_NAME")
    if not model_name:
        raise ValueError("MODEL_NAME environment variable is not set")
    # Format required by LiteLLM for OpenAI-compatible APIs
    model_name=f"openai/{model_name}"

    # To access the model's Cloud Run service,
    # we need an identity token.
    try:
        model_service_token_string = id_token.fetch_id_token(Request(), api_base)
    except Exception as e:
        # Fallback with using gcloud CLI to get the identity token
        model_service_token_string = subprocess.check_output(
            f"gcloud auth print-identity-token -q",
            shell=True
        ).decode().strip()

    # Gemma 4 in vLLM requires additional parameters in the request body.
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True
        },
        "skip_special_tokens": False
    }
    # Configure the model with LiteLLM and an OpenAI-compatible endpoint
    custom_model = LiteLlm(
      model=model_name,
      base_url=api_base,
      api_key=model_service_token_string,
      extra_body=extra_body
    )
    model = custom_model
else:
    # Gemini API in Agent Platform fallback
    model = "gemini-3.5-flash-lite"

# Initialize the MCP Toolset with the connection parameters
bigquery_toolset = MCPToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://bigquery.googleapis.com/mcp",
        headers={
            "Authorization": f"Bearer {application_default_credentials.token}",
            "x-goog-user-project": project_id, # This is used for billing
        },
        tool_filter=[
            'get_dataset_info',
            'list_table_ids',
            'get_table_info',
            # Using readonly is a security measure to prevent accidental data modification.
            'execute_sql_readonly',
        ]
    )
)

# Configure the agent

system_instruction = f"""
You are a helpful assistant that can answer questions about data in BigQuery.
To answer the user's question, use data you have access to by using tools `list_table_ids` and `get_table_info`.
Your data is in `bigquery-public-data.new_york_citibike` dataset
   (Citi Bike trips and stations in the NYC area.
    It includes trip records starting from September 2013 and is updated daily.)

Plan of action:
0. ALWAYS start by analyzing dataset.
1. Analyze your data, investigate schema and dimensions by querying distrinct values of columns using `execute_sql_readonly`.
   Output information about tables, columns, their data types and sets of values (for dimensions).
   Note which columns can be joined or used in aggregations/filters, and what type conversion may be needed for joining or aggregating.
   DO NOT MAKE ASSUMPTIONS ABOUT DATA (structure, type, values, relationships) BASED ON YOUR PRIOR KNOWLEDGE. ALWAYS VERIFY YOUR ASSUMPTIONS.
2. Understand and interpret the user's question.
3. Formulate a plan to answer the user's question.
4. Write a SQL query to retrieve relevant data in necessary form.
   This is where you must pay extra attention to column types and dimensions' sets of values.
5. Retrieve data by generating BigQuery SQL and using `execute_sql_readonly`.
   Always use Dry Run to verify SQL correctness.
   Use `{project_id}` to run BigQuery queries (`project_id` parameter of `execute_sql_readonly`).

Do not use LaTeX in your responses. When giving a final answer, use Markdown.
"""

root_agent = LlmAgent(
    model=model,
    name="data_agent",
    instruction=system_instruction,
    description="A helpful assistant that can answer questions using NYC Citibike data.",
    tools=[bigquery_toolset]
)

ADK nécessite également __init__.py et requirements.txt pour le déploiement :

• __init__.py doit comporter une importation pour l'agent.
• requirements.txt liste les dépendances Python : google-adk pour Agent Development Kit, litellm pour la bibliothèque LiteLLM qu'ADK exploite pour utiliser des modèles non-Gemini, et mcp pour le client Model Context Protocol.

Ces commandes vous aident à créer __init__.py et requirements.txt :

echo "from . import agent" > data_agent/__init__.py
echo -e "google-adk==2.4.*\nlitellm\nmcp==1.29.*" > data_agent/requirements.txt

La structure finale des dossiers doit ressembler à ceci :

data_agent/
    __init__.py
    agent.py
    requirements.txt

Essayer l'agent en local

Agent Development Kit est fourni avec l'outil CLI adk, une interface de terminal interactive permettant de tester vos agents. Cela est utile pour les tests rapides, les interactions scriptées et les pipelines CI/CD. L'une des fonctionnalités qu'il fournit est adk web (interface Web ADK), un moyen simple de développer et de déboguer vos agents de manière interactive. ADK Web n'est pas destiné à être utilisé dans les déploiements en production, mais il permet d'essayer l'agent très facilement.

Remarque : Avant d'exécuter cette commande, assurez-vous que votre répertoire actuel contient le répertoire data_agent (avec la commande ls).

Cette commande lance adk web, qui démarre un serveur Web local sur le port 8080.

export API_BASE=$(gcloud run services describe $SERVICE_NAME \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)')

# If Gemma 4 deployment failed, use Gemini fallback
if [[ "${API_BASE}" == "" ]]; then
  export GOOGLE_GENAI_USE_ENTERPRISE=true
else
  export GOOGLE_GENAI_USE_ENTERPRISE=false
fi

uv tool run --with litellm,"mcp==1.29.*" --from "google-adk[mcp]==2.4.*" adk web --allow_origins="*" --port 8080 .

Une fois le service démarré, ouvrez la page Web ADK locale : http://localhost:8080/.

Si vous utilisez Google Cloud Shell, cliquez sur le bouton Aperçu sur le Web .

Dans l'UI Web ADK, demandez à l'agent les données auxquelles il a accès :

What data do you have?

Remarque : La première requête adressée à l'agent peut prendre quelques minutes si le service Gemma 4 précédemment déployé est réduit à zéro par Cloud Run. Le démarrage et le chargement du modèle prennent environ trois à quatre minutes.

Le code de l'agent utilisera le modèle Gemma 4 déployé sur Cloud Run. Le modèle utilisera les outils BigQuery MCP pour explorer l'ensemble de données citibike. Il vous donnera un aperçu des tables et des champs disponibles dans l'ensemble de données Citibike.

12. Déployer l'agent sur Cloud Run

Si votre commande précédente exécute toujours le serveur Web ADK, arrêtez-le en appuyant sur Ctrl + C.

Cette commande déploiera l'agent sur Cloud Run à l'aide de la CLI ADK.

export API_BASE=$(gcloud run services describe $SERVICE_NAME \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)')

# If Gemma 4 deployment failed, use Gemini fallback
if [[ "${API_BASE}" == "" ]]; then
  export GOOGLE_GENAI_USE_ENTERPRISE=true
else
  export GOOGLE_GENAI_USE_ENTERPRISE=false
fi

uv tool run --from google-adk==2.4.0 \
  adk deploy cloud_run \
      --with_ui \
      --project $GOOGLE_CLOUD_PROJECT \
      --region $GOOGLE_CLOUD_REGION \
      --service_name gemma4-data-agent \
      --app_name data_agent \
      data_agent \
      -- \
      --allow-unauthenticated \
      --max-instances 1 \
      --set-env-vars GOOGLE_GENAI_USE_ENTERPRISE=${GOOGLE_GENAI_USE_ENTERPRISE},MODEL_NAME="${MODEL_NAME}",API_BASE="${API_BASE}",GOOGLE_CLOUD_PROJECT="${GOOGLE_CLOUD_PROJECT}"

Essayer l'agent

Nous avons utilisé l'option --with_ui pour le déploiement de notre agent. Il a déployé l'agent avec l'interface Web ADK.

1. Ouvrez l'URL de l'agent dans le navigateur Web. La commande adk deploy l'a renvoyée, et vous pouvez également la récupérer en exécutant la commande gcloud run services :

gcloud run services describe gemma4-data-agent \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)'

2. Demandez à l'agent de raisonner sur les données Citibike disponibles :

We have budget for 3 coffee trucks.
We want to find the best city bike stations to place our coffee trucks.

L'agent doit explorer l'ensemble de données Citibike à l'aide du serveur BigQuery MCP, exécuter quelques requêtes SQL et renvoyer une liste de trois stations citibike.

13. Félicitations !

Bravo ! Vous avez terminé cet atelier de programmation.

Nous vous recommandons de consulter la documentation Cloud Run.

Points abordés

• Déployer un modèle Gemma 4 sur un GPU Cloud Run RTX 6000 Pro
• Configurer la sortie VPC directe et le streaming de modèle vLLM avec Cloud Storage pour un démarrage plus rapide du service
• Créer et déployer un agent IA avec Agent Development Kit qui utilise le LLM Gemma 4 et le serveur BigQuery MCP

14. Libérer de l'espace

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet ou les ressources individuelles.

Option 1 : Supprimer les ressources

Supprimer les services Cloud Run

gcloud run services delete gemma4-data-agent \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --region "${GOOGLE_CLOUD_REGION}" \
      --quiet
gcloud run services delete $SERVICE_NAME \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --region "${GOOGLE_CLOUD_REGION}" \
      --quiet

Supprimer le compte de service

gcloud iam service-accounts delete \
      ${SERVICE_ACCOUNT_EMAIL} \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --quiet

Supprimer le bucket Cloud Storage

gcloud storage rm --recursive gs://$MODEL_CACHE_BUCKET

Supprimer le réseau et le sous-réseau VPC

gcloud compute networks subnets delete $VPC_SUBNET \
    --region "${GOOGLE_CLOUD_REGION}" \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --quiet

gcloud compute networks delete $VPC_NETWORK \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --quiet

Option 2 : Supprimer le projet

Pour supprimer l'ensemble du projet, accédez à Gérer les ressources, sélectionnez le projet que vous avez créé à l'étape 2, puis choisissez Supprimer. Si vous supprimez le projet, vous devrez modifier les projets dans votre Cloud SDK. Vous pouvez afficher la liste de tous les projets disponibles en exécutant gcloud projects list. Si vous souhaitez rester sur la ligne de commande, vous pouvez également utiliser cette commande :

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}