KI-Agenten mit Gemma 4 und BigQuery-MCP-Server in Cloud Run erstellen und bereitstellen

1. Einführung

Übersicht

Lerninhalte

Gemma 4 ist eine Familie von Apache 2-lizenzierten Open-Weight-Modellen von Google DeepMind. Die Modelle sind multimodal, mehrsprachig, bieten Argumentationsfähigkeit und eine effiziente Architektur.

Cloud Run ist eine serverlose Umgebung für Container mit Unterstützung für GPUs.

Das Agent Development Kit (ADK) ist ein Open-Source-Framework für die Entwicklung von Agenten, mit dem Sie zuverlässige KI-Agenten im Unternehmen erstellen, debuggen und bereitstellen können.

BigQuery ist ein vollständig verwaltetes, serverloses Data Warehouse für Unternehmen, in dem Sie große Datasets speichern, abfragen und analysieren können.

Das Model Context Protocol (MCP) standardisiert die Verbindung von Large Language Models (LLMs) und KI-Anwendungen oder -Agenten mit externen Datenquellen. Mit MCP-Servern können Sie ihre Tools, Ressourcen und Prompts verwenden, um Aktionen auszuführen und aktualisierte Daten von ihrem Backend-Dienst abzurufen. Der BigQuery MCP-Server bietet Ihren KI-Agenten eine direkte und sichere Möglichkeit, Daten in BigQuery zu analysieren. Dieser vollständig verwaltete MCP-Server reduziert den Verwaltungsaufwand, sodass Sie sich auf die Entwicklung intelligenter Agenten konzentrieren können.

2. Einrichtung und Anforderungen

Legen Sie zuerst das Standardprojekt und die Cloud Run-Region fest:

# set the project
gcloud config set project YOUR_PROJECT_ID

Ersetzen Sie YOUR_PROJECT_ID durch Ihre Google Cloud-Projekt-ID.

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

Ersetzen Sie CLOUD-RUN-REGION durch eine der folgenden Cloud-Regionen:

  • us-central1
  • asia-southeast1

Hier sind Umgebungsvariablen, die in diesem Codelab verwendet werden. Sie können diese in einer Umgebungsdatei speichern und „sourcen“. Achten Sie darauf, dass Sie den Wert Ihrer Projekt-ID und optional die Region richtig festlegen.

# 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"

Aktivieren Sie die für dieses Codelab erforderlichen APIs. Es kann 2 bis 3 Minuten dauern, bis die API-Änderungen wirksam werden.

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. Dienstkonto erstellen

Wenn Sie beim Erstellen des Cloud Run-Dienstes oder -Jobs kein Dienstkonto angeben, verwendet Cloud Run das Compute Engine-Standarddienstkonto. Es wird empfohlen, ein separates Dienstkonto für den Cloud Run-Dienst zu verwenden, um zu vermeiden, dass der Dienst mit zu vielen Berechtigungen ausgeführt wird.

Dienstkonto für den Cloud Run-Dienst erstellen

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

4. Cloud Storage einrichten

Erstellen Sie einen Cloud Storage-Bucket zum Speichern der Modellgewichtungen. So können Sie Direct VPC Egress verwenden, um Modellgewichtungen schneller herunterzuladen, wenn Cloud Run eine Dienstinstanz startet.

In Kombination mit der Run:ai Model Streamer-Funktion in vLLM wird die Ladezeit des Modells erheblich reduziert.

Bucket erstellen

Achten Sie darauf, dass es sich um einen Bucket mit einer einzelnen Region handelt, der sich am selben Standort wie der Cloud Run-Dienst befindet.

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

5. Modellgewichtungen abrufen und im Cache speichern

Laden Sie als Nächstes das Gemma 4-Modell in Ihren Cloud Storage-Bucket herunter. Modellgewichtungen sind Dutzende von Gigabyte groß und es ist möglicherweise nicht möglich, sie zuerst auf Ihren lokalen Computer oder in Cloud Shell herunterzuladen. Verwenden Sie stattdessen Cloud Build mit genügend Speicherplatz für die Modellgewichtungen.

Modellgewichtungen aus einem freigegebenen Cloud Storage-Bucket kopieren

Google Cloud hostet einen öffentlich zugänglichen Cloud Storage-Bucket mit Modellgewichtungen für Gemma 4.

Führen Sie den folgenden Befehl aus, um sie in Ihren Speicher-Bucket zu kopieren:

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

6. Netzwerk für Direct VPC Egress konfigurieren

Direct VPC Egress-Konfiguration erfordert die Erstellung eines Netzwerks und Subnetzes mit aktiviertem privaten Google-Zugriff.

So können Cloud Run-Dienste eine Verbindung zu den externen IP-Adressen herstellen, die von Google APIs und -Diensten verwendet werden, einschließlich Cloud Storage.

Netzwerk erstellen

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

Subnetz erstellen

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. Zugriffsrichtlinie für Dienstkonto konfigurieren

Das Cloud Run-Dienstkonto benötigt Berechtigungen für den Zugriff auf Modellgewichtungen im von Ihnen erstellten Speicher-Bucket.

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. Konfigurationsvariablen initialisieren

Definieren Sie die Variablen für die vLLM-Inferenz-Engine und den Cloud Run-Dienst.

# 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

9. In Cloud Run bereitstellen

Befehlszeile für vLLM-Container vorbereiten

Für vLLM sind viele Parameter erforderlich, um große Modelle schnell und effizient auszuführen. Diese Parameter werden als Argumente an den in Cloud Run bereitgestellten Container übergeben.

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[*]}"

Cloud Run-Dienst bereitstellen

Führen Sie den folgenden Befehl aus, um den Cloud Run-Dienst bereitzustellen. Beachten Sie den GPU-Typ (RTX 6000 Pro), das Basis-Image (pytorch-vllm-serve:gemma4) und die Notwendigkeit, sich zu authentifizieren, um den Dienst aufzurufen (--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}"

Die Bereitstellung dauert einige Minuten. Danach haben Sie eine GPU-basierte Umgebung, in der Gemma 4 mit einer serverlosen Infrastruktur mit automatischer Skalierung bereitgestellt wird, einschließlich der Skalierung auf null (kein Traffic, keine Kosten).

10. Dienst testen

Nach der Bereitstellung können Sie mit der vLLM OpenAI-kompatiblen API mit Ihrem Gemma 4-Modell interagieren.

Dienst-URL abrufen

Rufen Sie die URL Ihres bereitgestellten Cloud Run-Dienstes ab.

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"

Inferenz ausführen

Senden Sie mit curl einen Prompt an das Modell.

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. Daten-Agent mit dem Agent Development Kit erstellen

Code des Agenten schreiben

Erstellen Sie im Cloud Shell-Terminal oder in Ihrem lokalen Terminal ein Stammverzeichnis für Ihre Agenten-App:

mkdir data_agent

Öffnen Sie den Cloud Shell-Editor oder einen anderen Texteditor und erstellen Sie agent.py im Verzeichnis 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]
)

Für die Bereitstellung sind außerdem __init__.py und requirements.txt erforderlich:

  • __init__.py muss einen Import für den Agenten enthalten.
  • requirements.txt enthält eine Liste der Python-Abhängigkeiten: google-adk für das Agent Development Kit, litellm für die LiteLLM-Bibliothek, die ADK für die Verwendung von Nicht-Gemini-Modellen nutzt, und mcp für den Model Context Protocol-Client.

Mit diesen Befehlen können Sie __init__.py und requirements.txt erstellen:

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

Die endgültige Ordnerstruktur sollte so aussehen:

data_agent/
    __init__.py
    agent.py
    requirements.txt

Agent lokal testen

Das Agent Development Kit enthält das CLI-Tool adk, eine interaktive Terminaloberfläche zum Testen Ihrer Agenten. Dies ist nützlich für schnelle Tests, Skriptinteraktionen und CI/CD-Pipelines. Eine der Funktionen ist adk web – die ADK-Weboberfläche, mit der Sie Ihre Agenten auf einfache Weise interaktiv entwickeln und debuggen können. ADK Web ist nicht für die Verwendung in Produktionsbereitstellungen vorgesehen, macht es aber sehr einfach, den Agenten zu testen.

Mit diesem Befehl wird adk web gestartet, das einen lokalen Webserver auf Port 8080 startet.

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 .

Öffnen Sie nach dem Start des Dienstes die lokale ADK-Webseite: http://localhost:8080/.

Wenn Sie Google Cloud Shell verwenden, klicken Sie auf die Schaltfläche „Webvorschau“ .

Fragen Sie den Agenten in der ADK-Weboberfläche nach den Daten, auf die er Zugriff hat:

What data do you have?

Der Agentencode verwendet das in Cloud Run bereitgestellte Gemma 4-Modell. Das Modell verwendet BigQuery MCP-Tools, um das Citibike-Dataset zu untersuchen. Sie erhalten eine Übersicht über die verfügbaren Tabellen und Felder im Citibike-Dataset.

12. Agent in Cloud Run bereitstellen

Mit diesem Befehl wird der Agent mit der ADK-CLI in Cloud Run bereitgestellt.

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}"

Agent testen

Wir haben die Option --with_ui für die Bereitstellung unseres Agenten verwendet. Dadurch wurde der Agent mit der ADK-Weboberfläche bereitgestellt.

  1. Öffnen Sie die Agent-URL im Webbrowser. Der Befehl adk deploy hat sie zurückgegeben. Sie können die URL auch mit dem Befehl gcloud run services abrufen:
gcloud run services describe gemma4-data-agent \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)'
  1. Bitten Sie den Agenten, die verfügbaren Citibike-Daten zu analysieren:
We have budget for 3 coffee trucks.
We want to find the best city bike stations to place our coffee trucks.

Der Agent sollte das Citibike-Dataset mit dem BigQuery MCP-Server untersuchen, einige SQL-Abfragen ausführen und eine Liste mit drei Citibike-Stationen zurückgeben.

13. Glückwunsch!

Sie haben das Codelab abgeschlossen.

Wir empfehlen, die Cloud Run-Dokumentation zu lesen.

Behandelte Themen

  • Bereitstellung des Gemma 4-Modells auf einer Cloud Run RTX 6000 Pro-GPU
  • Konfiguration von Direct VPC Egress und vLLM-Modellstreaming mit Cloud Storage für einen schnelleren Dienststart
  • Erstellung und Bereitstellung eines KI-Agenten mit dem Agent Development Kit, der das Gemma 4-LLM und den BigQuery MCP-Server verwendet

14. Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder das Projekt löschen oder die einzelnen Ressourcen entfernen.

Option 1: Ressourcen löschen

Cloud Run-Dienste löschen

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

Dienstkonto löschen

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

Cloud Storage-Bucket löschen

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

VPC-Netzwerk und Subnetz löschen

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: Projekt löschen

Wenn Sie das gesamte Projekt löschen möchten, rufen Sie „Ressourcen verwalten“ auf, wählen Sie das in Schritt 2 erstellte Projekt aus und klicken Sie auf „Löschen“. Wenn Sie das Projekt löschen, müssen Sie die Projekte in Ihrem Cloud SDK ändern. Sie können die Liste aller verfügbaren Projekte mit dem Befehl gcloud projects list aufrufen. Wenn Sie die Befehlszeile verwenden möchten, können Sie auch diesen Befehl verwenden:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}