Membangun dan Men-deploy Agen AI dengan server MCP BigQuery dan Gemma 4 di Cloud Run

1. Pengantar

Ringkasan

Yang akan Anda pelajari

Gemma 4 adalah serangkaian model open source berlisensi Apache 2 dari Google DeepMind. Model ini bersifat multimodal, multibahasa, menawarkan penalaran, dan arsitektur yang efisien.

Cloud Run adalah lingkungan serverless untuk container dengan dukungan GPU.

Agent Development Kit (ADK) adalah framework pengembangan agen open source yang memungkinkan Anda membangun, men-debug, dan men-deploy agen AI yang andal dalam skala perusahaan.

BigQuery adalah data warehouse perusahaan serverless yang terkelola sepenuhnya yang memungkinkan Anda menyimpan, membuat kueri, dan menganalisis set data besar.

Model Context Protocol (MCP) menstandardisasi cara model bahasa besar (LLM) dan aplikasi atau agen AI terhubung ke sumber data eksternal. Server MCP memungkinkan Anda menggunakan alat, resource, dan perintahnya untuk melakukan tindakan dan mendapatkan data terbaru dari layanan backend-nya. Server MCP BigQuery memberi agen AI Anda cara yang langsung dan aman untuk menganalisis data di BigQuery. Server MCP yang terkelola sepenuhnya ini menghilangkan overhead pengelolaan, sehingga Anda dapat berfokus pada pengembangan agen cerdas.

2. Penyiapan dan Persyaratan

Mulai dari menetapkan project default dan region Cloud Run:

# set the project
gcloud config set project YOUR_PROJECT_ID

Ganti YOUR_PROJECT_ID dengan Project ID Google Cloud Anda.

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

Ganti CLOUD-RUN-REGION dengan salah satu region Cloud berikut:

  • us-central1
  • asia-southeast1

Berikut adalah variabel lingkungan yang akan digunakan di seluruh codelab ini. Anda dapat menyimpannya dalam file lingkungan dan "membuat sumber" file tersebut. Pastikan untuk menetapkan nilai project ID Anda dengan benar dan secara opsional region.

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

Aktifkan API yang diperlukan untuk Codelab ini. Perubahan API mungkin memerlukan waktu 2-3 menit agar dapat diterapkan.

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. Buat Akun Layanan

Jika Anda tidak menentukan akun layanan saat layanan atau tugas Cloud Run dibuat, Cloud Run akan menggunakan akun layanan default Compute Engine. Sebaiknya gunakan Akun Layanan terpisah untuk layanan Cloud Run agar layanan tidak berjalan dengan izin yang berlebihan.

Buat Akun Layanan untuk layanan Cloud Run

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

4. Menyiapkan Cloud Storage

Buat bucket Cloud Storage untuk menyimpan bobot model. Hal ini akan memungkinkan penggunaan Direct VPC egress untuk mendownload bobot model lebih cepat setiap kali Cloud Run memulai instance layanan.

Jika dikombinasikan dengan fitur Run:ai Model Streamer di vLLM, waktu pemuatan model akan berkurang secara signifikan.

Membuat bucket

Pastikan bucket tersebut adalah bucket satu region yang ditempatkan bersama dengan layanan 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. Mengambil dan Menyimpan Bobot Model ke Cache

Selanjutnya, download model Gemma 4 ke bucket Cloud Storage Anda. Bobot model berukuran puluhan gigabyte, dan mendownloadnya ke komputer lokal atau Cloud Shell terlebih dahulu mungkin tidak memungkinkan. Sebagai gantinya, gunakan Cloud Build dengan penyimpanan yang cukup untuk menyimpan bobot model.

Menyalin Bobot Model dari Bucket Cloud Storage bersama

Google Cloud menghosting Bucket Cloud Storage yang dapat diakses secara publik dengan bobot model Gemma 4.

Untuk menyalinnya ke bucket penyimpanan, jalankan perintah:

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. Mengonfigurasi Jaringan untuk Direct VPC Egress

Konfigurasi Direct VPC Egress memerlukan pembuatan jaringan dan subnet dengan Akses Google Pribadi yang diaktifkan.

Hal ini memungkinkan layanan Cloud Run terhubung ke kumpulan alamat IP eksternal yang digunakan oleh API dan layanan Google, termasuk Cloud Storage.

Membuat Jaringan

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

Membuat Subnet

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. Mengonfigurasi Kebijakan Akses Akun Layanan

Akun Layanan Cloud Run memerlukan izin untuk mengakses bobot model di Bucket Storage yang Anda buat.

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. Lakukan Inisialisasi Variabel Konfigurasi

Tentukan variabel untuk mesin inferensi vLLM dan layanan 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. Men-deploy ke Cloud Run

Menyiapkan Command Line Container vLLM

vLLM memerlukan banyak parameter untuk menjalankan model besar dengan cepat dan efisien. Parameter ini akan diteruskan sebagai argumen ke penampung yang di-deploy ke 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[*]}"

Men-deploy Layanan Cloud Run

Jalankan perintah berikut untuk men-deploy layanan Cloud Run. Perhatikan jenis GPU (RTX 6000 Pro), image dasar (pytorch-vllm-serve:gemma4), dan kebutuhan untuk diautentikasi guna memanggil layanan (--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}"

Proses ini akan memerlukan waktu beberapa menit untuk di-deploy. Setelah selesai, Anda akan memiliki lingkungan yang didukung GPU yang menyajikan Gemma 4 menggunakan infrastruktur serverless dengan penskalaan otomatis, termasuk penskalaan ke nol (tidak ada traffic, tidak ada biaya).

10. Menguji Layanan

Setelah di-deploy, Anda dapat berinteraksi dengan model Gemma 4 menggunakan API yang kompatibel dengan vLLM OpenAI.

Mendapatkan URL Layanan

Ambil URL layanan Cloud Run yang di-deploy.

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"

Menjalankan Inferensi

Kirim perintah ke model menggunakan 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. Membuat Agen Data menggunakan Agent Development Kit

Menulis kode agen

Dari Terminal Cloud Shell atau terminal lokal Anda, buat direktori root untuk aplikasi agentik Anda:

mkdir data_agent

Buka Cloud Shell Editor atau editor teks lain, lalu buat agent.py di direktori 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 juga memerlukan __init__.py dan requirements.txt untuk deployment:

  • __init__.py harus memiliki impor untuk agen.
  • requirements.txt mencantumkan dependensi Python: google-adk untuk Agent Development Kit, litellm untuk library LiteLLM yang dimanfaatkan ADK untuk menggunakan model non-Gemini, dan mcp untuk klien Model Context Protocol.

Perintah ini membantu Anda membuat __init__.py dan requirements.txt:

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

Struktur folder akhir akan terlihat seperti ini:

data_agent/
    __init__.py
    agent.py
    requirements.txt

Mencoba agen secara lokal

Agent Development Kit dilengkapi dengan alat CLI adk - antarmuka terminal interaktif untuk menguji agen Anda. Hal ini berguna untuk pengujian cepat, interaksi yang di-script, dan pipeline CI/CD. Salah satu fitur yang disediakan adalah adk web - Antarmuka Web ADK - cara sederhana untuk mengembangkan dan men-debug agen Anda secara interaktif. ADK Web tidak ditujukan untuk digunakan dalam deployment produksi, tetapi mempermudah Anda mencoba agen.

Perintah ini meluncurkan adk web yang memulai server web lokal di 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 .

Setelah layanan dimulai, buka halaman Web ADK lokal: http://localhost:8080/.

Jika Anda menggunakan Google Cloud Shell, klik tombol Web Preview .

Di UI Web ADK, tanyakan kepada agen tentang data yang dapat diaksesnya:

What data do you have?

Kode agen akan menggunakan model Gemma 4 yang di-deploy ke Cloud Run. Model akan menggunakan alat BigQuery MCP untuk menjelajahi set data citibike. Tindakan ini akan memberi Anda ringkasan tabel dan kolom yang tersedia dalam set data Citibike.

12. Men-deploy agen ke Cloud Run

Perintah ini akan men-deploy agen ke Cloud Run menggunakan 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}"

Mencoba agen

Kami menggunakan opsi --with_ui untuk deployment agen kami. Agen di-deploy dengan Antarmuka Web ADK.

  1. Buka URL agen di browser web. perintah adk deploy menampilkannya, dan Anda juga dapat mengambil URL dengan menjalankan perintah gcloud run services:
gcloud run services describe gemma4-data-agent \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)'
  1. Minta agen untuk mengolah data Citibike yang tersedia:
We have budget for 3 coffee trucks.
We want to find the best city bike stations to place our coffee trucks.

Agen harus menjelajahi set data Citibike menggunakan server MCP BigQuery, menjalankan beberapa Kueri SQL, dan menampilkan daftar 3 stasiun citibike.

13. Selamat!

Selamat, Anda telah menyelesaikan codelab.

Sebaiknya tinjau dokumentasi Cloud Run.

Yang telah kita bahas

  • Cara men-deploy model Gemma 4 di GPU RTX 6000 Pro Cloud Run
  • Cara mengonfigurasi Direct VPC Egress dan streaming model vLLM dengan Cloud Storage untuk memulai layanan yang lebih cepat.
  • Cara membuat dan men-deploy Agen AI dengan Agent Development Kit yang menggunakan LLM Gemma 4 dan server MCP BigQuery.

14. Pembersihan

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, Anda dapat menghapus project atau menghapus setiap resource.

Opsi 1: Menghapus Resource

Menghapus Layanan 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

Menghapus Akun Layanan

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

Hapus Bucket Cloud Storage

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

Menghapus Jaringan dan Subnet 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

Opsi 2: Menghapus Project

Untuk menghapus seluruh project, buka Manage Resources, pilih project yang Anda buat di Langkah 2, lalu pilih Delete. Jika menghapus project, Anda harus mengubah project di Cloud SDK. Anda dapat melihat daftar semua project yang tersedia dengan menjalankan gcloud projects list. Jika ingin tetap menggunakan command line, Anda juga dapat menggunakan perintah ini:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}