Tworzenie i wdrażanie agentów AI z Gemma 4 i serwerem MCP BigQuery w Cloud Run

1. Wprowadzenie

Przegląd

Czego się nauczysz

Gemma 4 to rodzina modeli o otwartych wagach na licencji Apache 2 od Google DeepMind. Modele są multimodalne, wielojęzyczne, oferują rozumowanie i wydajną architekturę.

Cloud Run to bezserwerowe środowisko dla kontenerów z obsługą GPU.

Pakiet Agent Development Kit (ADK) to platforma open source do tworzenia agentów, która umożliwia tworzenie, debugowanie i wdrażanie niezawodnych agentów AI na skalę przedsiębiorstwa.

BigQuery to w pełni zarządzana, bezserwerowa hurtownia danych dla firm, która umożliwia przechowywanie, wysyłanie zapytań i analizowanie ogromnych zbiorów danych.

Protokół Model Context Protocol (MCP) standaryzuje sposób, w jaki duże modele językowe (LLM) oraz aplikacje lub agenty AI łączą się z zewnętrznymi źródłami danych. Serwery MCP umożliwiają korzystanie z ich narzędzi, zasobów i promptów do wykonywania działań i uzyskiwania aktualnych danych z usługi backendu. Serwer BigQuery MCP zapewnia agentom AI bezpośredni i bezpieczny sposób analizowania danych w BigQuery. Ten w pełni zarządzany serwer MCP eliminuje obciążenie związane z zarządzaniem, dzięki czemu możesz skupić się na tworzeniu inteligentnych agentów.

2. Konfiguracja i wymagania

Zacznij od ustawienia domyślnego projektu i regionu Cloud Run:

# set the project
gcloud config set project YOUR_PROJECT_ID

Zastąp YOUR_PROJECT_ID identyfikatorem projektu Google Cloud.

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

Zastąp CLOUD-RUN-REGION jednym z tych regionów Cloud:

  • us-central1
  • asia-southeast1

Oto zmienne środowiskowe, których będziemy używać w tym ćwiczeniu. Możesz je zapisać w pliku środowiska i „źródle”. Pamiętaj, aby prawidłowo ustawić wartość identyfikatora projektu i opcjonalnie regionu.

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

Włącz interfejsy API potrzebne do tego ćwiczenia. Zastosowanie zmian w interfejsie API może potrwać 2–3 minuty.

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. Utwórz konto usługi

Jeśli podczas tworzenia usługi lub zadania Cloud Run nie określisz konta usługi, Cloud Run użyje domyślnego konta usługi Compute Engine. Zalecamy używanie osobnego konta usługi dla usługi Cloud Run, aby uniknąć uruchamiania usługi z nadmiernymi uprawnieniami.

Utwórz konto usługi dla usługi Cloud Run

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

4. Konfigurowanie Cloud Storage

Utwórz zasobnik Cloud Storage, w którym będą przechowywane wagi modelu. Umożliwi to korzystanie z bezpośredniego ruchu wychodzącego VPC do szybszego pobierania wag modelu za każdym razem, gdy Cloud Run uruchamia instancję usługi.

W połączeniu z funkcją Run:ai Model Streamer w vLLM znacznie skraca to czas wczytywania modelu.

Tworzenie zasobnika

Upewnij się, że jest to zasobnik w jednym regionie, który znajduje się w tym samym miejscu co usługa 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. Pobieranie i buforowanie wag modelu

Następnie pobierz model Gemma 4 do zasobnika Cloud Storage. Wagi modelu mają dziesiątki gigabajtów, a pobieranie ich najpierw na komputer lokalny lub do Cloud Shell może być niemożliwe. Zamiast tego użyj Cloud Build z wystarczającą ilością miejsca na wagi modelu.

Kopiowanie wag modelu ze współdzielonego zasobnika Cloud Storage

Google Cloud hostuje publicznie dostępny zasobnik Cloud Storage z wagami modelu Gemma 4.

Aby skopiować je do zasobnika, uruchom to polecenie:

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. Konfigurowanie sieci na potrzeby bezpośredniego ruchu wychodzącego VPC

Konfiguracja bezpośredniego połączenia VPC z ruchem wychodzącym wymaga utworzenia sieci i podsieci z włączonym prywatnym dostępem do Google.

Umożliwia to usługom Cloud Run łączenie się z zestawem zewnętrznych adresów IP używanych przez interfejsy API Google i usługi, w tym Cloud Storage.

Utwórz sieć

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

Utwórz podsieć

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. Konfigurowanie zasad dostępu do konta usługi

Konto usługi Cloud Run musi mieć uprawnienia dostępu do wag modelu w utworzonym zasobniku Cloud Storage.

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. Inicjowanie zmiennych konfiguracji

Zdefiniuj zmienne zarówno dla silnika wnioskowania vLLM, jak i usługi 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

9. Wdrożenie w Cloud Run

Przygotowywanie wiersza poleceń kontenera vLLM

vLLM wymaga wielu parametrów, aby szybko i wydajnie uruchamiać duże modele. Te parametry zostaną przekazane jako argumenty do kontenera wdrożonego w 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[*]}"

Wdrażanie usługi Cloud Run

Aby wdrożyć usługę Cloud Run, uruchom to polecenie. Zwróć uwagę na typ GPU (RTX 6000 Pro), obraz bazowy (pytorch-vllm-serve:gemma4) oraz konieczność uwierzytelnienia, aby wywołać usługę (--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}"

Wdrożenie potrwa kilka minut. Po zakończeniu będziesz mieć środowisko oparte na GPU, które obsługuje model Gemma 4 za pomocą bezserwerowej infrastruktury z autoskalowaniem, w tym skalowaniem do zera (brak ruchu, brak kosztów).

10. Testowanie usługi

Po wdrożeniu możesz korzystać z modelu Gemma 4 za pomocą interfejsu API vLLM zgodnego z OpenAI.

Pobieranie adresu URL usługi

Pobierz adres URL wdrożonej usługi Cloud Run.

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"

Uruchamianie wnioskowania

Wyślij prompt do modelu za pomocą 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. Tworzenie agenta danych za pomocą pakietu Agent Development Kit

Pisanie kodu agenta

W terminalu Cloud Shell lub terminalu lokalnym utwórz katalog główny aplikacji opartej na agentach:

mkdir data_agent

Otwórz edytor Cloud Shell lub inny edytor tekstu i utwórz plik agent.py w katalogu 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]
)

Do wdrożenia pakiet ADK wymaga też plików __init__.py i requirements.txt:

  • __init__.py musi zawierać import agenta.
  • requirements.txt zawiera listę zależności Pythona: google-adk na potrzeby pakietu Agent Development Kit, litellm na potrzeby biblioteki LiteLLM, której ADK używa do korzystania z modeli innych niż Gemini, oraz mcp na potrzeby klienta protokołu Model Context Protocol.

Te polecenia pomogą Ci utworzyć pliki __init__.py i requirements.txt:

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

Ostateczna struktura folderów powinna wyglądać tak:

data_agent/
    __init__.py
    agent.py
    requirements.txt

Testowanie agenta lokalnie

Pakiet Agent Development Kit zawiera narzędzie adk CLI – interaktywny interfejs terminala do testowania agentów. Jest to przydatne do szybkiego testowania, interakcji skryptowych i potoków CI/CD. Jedną z jego funkcji jest adk web – interfejs internetowy ADK – prosty sposób na interaktywne tworzenie i debugowanie agentów. Interfejs internetowy ADK nie jest przeznaczony do użytku we wdrożeniach produkcyjnych, ale bardzo ułatwia testowanie agenta.

To polecenie uruchamia adk web, który uruchamia lokalny serwer WWW na porcie 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 .

Po uruchomieniu usługi otwórz lokalną stronę internetową ADK: http://localhost:8080/.

Jeśli używasz Google Cloud Shell, kliknij przycisk Podgląd w przeglądarce .

W interfejsie internetowym ADK zapytaj agenta o dane, do których ma dostęp:

What data do you have?

Kod agenta będzie używać modelu Gemma 4 wdrożonego w Cloud Run. Model będzie używać narzędzi BigQuery MCP do eksplorowania zbioru danych citibike. Przedstawi on przegląd dostępnych tabel i pól w zbiorze danych Citibike.

12. Wdrażanie agenta w Cloud Run

To polecenie wdroży agenta w Cloud Run za pomocą interfejsu wiersza poleceń 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}"

Testowanie agenta

Do wdrożenia agenta użyliśmy opcji --with_ui. Wdrożyła ona agenta z interfejsem internetowym ADK.

  1. Otwórz adres URL agenta w przeglądarce. Zwróciło go polecenie adk deploy. Możesz też pobrać adres URL, uruchamiając polecenie gcloud run services:
gcloud run services describe gemma4-data-agent \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)'
  1. Poproś agenta o przeanalizowanie dostępnych danych Citibike:
We have budget for 3 coffee trucks.
We want to find the best city bike stations to place our coffee trucks.

Agent powinien eksplorować zbiór danych Citibike za pomocą Serwera MCP BigQuery, uruchomić kilka zapytań SQL i zwrócić listę 3 stacji citibike.

13. Gratulacje!

Gratulujemy ukończenia ćwiczenia!

Zalecamy zapoznanie się z dokumentacją Cloud Run.

Omówione zagadnienia

  • Jak wdrożyć model Gemma 4 na GPU Cloud Run RTX 6000 Pro.
  • Jak skonfigurować bezpośredni ruch wychodzący VPC i przesyłanie strumieniowe modelu vLLM za pomocą Cloud Storage, aby przyspieszyć uruchamianie usługi.
  • Jak utworzyć i wdrożyć agenta AI za pomocą pakietu Agent Development Kit, który używa modelu Gemma 4 LLM i serwera BigQuery MCP.

14. Zwalnianie miejsca

Aby uniknąć obciążenia konta Google Cloud opłatami za zasoby zużyte w tym samouczku, możesz usunąć projekt lub poszczególne zasoby.

Opcja 1. Usuwanie zasobów

Usuń usługi 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

Usuń konto usługi

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

Usuń zasobnik Cloud Storage

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

Usuń sieć VPC i podsieć

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

Opcja 2. Usuwanie projektu

Aby usunąć cały projekt, otwórz Zarządzanie zasobami, wybierz projekt utworzony w kroku 2 i kliknij Usuń. Jeśli usuniesz projekt, musisz zmienić projekty w Cloud SDK. Listę wszystkich dostępnych projektów możesz wyświetlić, uruchamiając polecenie gcloud projects list. Jeśli chcesz pozostać w wierszu poleceń, możesz też użyć tego polecenia:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}