Crea e implementa agentes de IA con Gemma 4 y el servidor de MCP de BigQuery en Cloud Run

1. Introducción

Descripción general

Qué aprenderás

Gemma 4 es una familia de modelos de código abierto con licencia de Apache 2 de Google DeepMind. Los modelos son multimodales, multilingües, ofrecen razonamiento y una arquitectura eficiente.

Cloud Run es un entorno sin servidores para contenedores con compatibilidad con GPUs.

El Kit de desarrollo de agentes (ADK) es un framework de desarrollo de agentes de código abierto que te permite compilar, depurar y, luego, implementar agentes de IA confiables a escala empresarial.

BigQuery es un almacén de datos empresarial completamente administrado y sin servidores que te permite almacenar, consultar y analizar conjuntos de datos masivos.

El Protocolo de contexto del modelo (MCP) estandariza la forma en que los modelos de lenguaje grandes (LLM) y las aplicaciones o agentes de IA se conectan a fuentes de datos externas. Los servidores de MCP te permiten usar sus herramientas, recursos y mensajes para realizar acciones y obtener datos actualizados de su servicio de backend. El servidor de MCP de BigQuery proporciona a tus agentes de IA una forma directa y segura de analizar datos en BigQuery. Este servidor de MCP completamente administrado elimina la sobrecarga de administración, lo que te permite enfocarte en desarrollar agentes inteligentes.

2. Configuración y requisitos

Comienza por configurar el proyecto predeterminado y la región de Cloud Run:

# set the project
gcloud config set project YOUR_PROJECT_ID

Reemplaza YOUR_PROJECT_ID por el ID de tu proyecto de Google Cloud.

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

Reemplaza CLOUD-RUN-REGION por una de las siguientes regiones de Cloud:

  • us-central1
  • asia-southeast1

Estas son las variables de entorno que se usarán en este codelab. Puedes guardarlas en un archivo de entorno y “obtener su código fuente”. Asegúrate de configurar correctamente el valor del ID de tu proyecto y, de manera opcional, la región.

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

Habilita las APIs necesarias para este codelab. Los cambios en la API pueden tardar entre 2 y 3 minutos en aplicarse.

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. Crear una cuenta de servicio.

Si no especificas una cuenta de servicio cuando se crea un trabajo o servicio de Cloud Run, Cloud Run usa la cuenta de servicio predeterminada de Compute Engine. Se recomienda una cuenta de servicio independiente para el servicio de Cloud Run para evitar ejecutar el servicio con permisos excesivos.

Crea una cuenta de servicio para el servicio de Cloud Run

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

4. Configura Cloud Storage

Crea un bucket de Cloud Storage para almacenar las ponderaciones del modelo. Esto permitirá usar la salida de VPC directa para descargar las ponderaciones del modelo más rápido cada vez que Cloud Run inicie una instancia de servicio.

En combinación con la función Run:ai Model Streamer en vLLM, reduce significativamente el tiempo de carga del modelo.

Crea un bucket

Asegúrate de que sea un bucket de una sola región ubicado junto con el servicio de 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. Recupera y almacena en caché las ponderaciones del modelo

A continuación, descarga el modelo Gemma 4 en tu bucket de Cloud Storage. Las ponderaciones de los modelos son de decenas de gigabytes, y descargarlas primero a tu máquina local o Cloud Shell puede ser inviable. En cambio, usa Cloud Build con suficiente almacenamiento para contener las ponderaciones del modelo.

Copia las ponderaciones del modelo desde un bucket de Cloud Storage compartido

Google Cloud aloja un bucket de Cloud Storage de acceso público con las ponderaciones del modelo Gemma 4.

Para copiarlos en tu bucket de almacenamiento, ejecuta el siguiente comando:

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. Configura la red para la salida de VPC directa

La configuración de la salida de VPC directa requiere la creación de una red y una subred con el Acceso privado a Google habilitado.

Esto permite que los servicios de Cloud Run se conecten al conjunto de direcciones IP externas que usan las APIs y los servicios de Google, incluido Cloud Storage.

Crea una red

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

Crea una subred

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. Configura la política de acceso a la cuenta de servicio

La cuenta de servicio de Cloud Run necesita permisos para acceder a las ponderaciones del modelo en el bucket de almacenamiento que creaste.

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. Inicializa las variables de configuración

Define las variables para el motor de inferencia de vLLM y el servicio de 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. Implementa en Cloud Run

Prepara la línea de comandos del contenedor de vLLM

vLLM requiere muchos parámetros para ejecutar modelos grandes de forma rápida y eficiente. Estos parámetros se pasarán como argumentos al contenedor implementado en 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[*]}"

Implementa el servicio de Cloud Run

Ejecuta el siguiente comando para implementar el servicio de Cloud Run. Ten en cuenta el tipo de GPU (RTX 6000 Pro), la imagen base (pytorch-vllm-serve:gemma4) y la necesidad de autenticarse para invocar el servicio (--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}"

La implementación tardará unos minutos. Una vez que finalice, tendrás un entorno potenciado por GPU que entregará Gemma 4 con una infraestructura sin servidores con ajuste de escala automático, incluido el ajuste a cero (sin tráfico, sin costo).

10. Prueba el servicio

Una vez implementado, puedes interactuar con tu modelo Gemma 4 con la API compatible con OpenAI de vLLM.

Obtén la URL del servicio

Recupera la URL de tu servicio de Cloud Run implementado.

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"

Ejecuta la inferencia

Envía un mensaje al modelo con 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. Crea un agente de datos con el Kit de desarrollo de agentes

Escribe el código del agente

Desde la terminal de Cloud Shell o tu terminal local, crea un directorio raíz para tu app de agente:

mkdir data_agent

Abre el Editor de Cloud Shell o cualquier otro editor de texto y crea agent.py en el directorio 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]
)

El ADK también requiere __init__.py y requirements.txt para la implementación:

  • __init__.py debe tener una importación para el agente.
  • requirements.txt enumera las dependencias de Python: google-adk para el Kit de desarrollo de agentes, litellm para la biblioteca de LiteLLM que aprovecha el ADK para usar modelos que no son de Gemini y mcp para el cliente del Protocolo de contexto del modelo.

Estos comandos te ayudan a crear __init__.py y 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 estructura de carpetas final debería verse así:

data_agent/
    __init__.py
    agent.py
    requirements.txt

Prueba el agente localmente

El Kit de desarrollo de agentes incluye la herramienta de CLI adk, una interfaz de terminal interactiva para probar tus agentes. Esto es útil para pruebas rápidas, interacciones con secuencias de comandos y canalizaciones de CI/CD. Una de las funciones que proporciona es adk web (interfaz web del ADK), una forma sencilla de desarrollar y depurar tus agentes de forma interactiva. La Web del ADK no está diseñada para usarse en implementaciones de producción, pero facilita la prueba del agente.

Este comando inicia adk web, que inicia un servidor web local en el puerto 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 .

Una vez que se inicia el servicio, abre la página web local del ADK: http://localhost:8080/.

Si usas Google Cloud Shell, haz clic en el botón Vista previa en la Web .

En la IU web del ADK, pregúntale al agente sobre los datos a los que tiene acceso:

What data do you have?

El código del agente usará el modelo Gemma 4 implementado en Cloud Run. El modelo usará las herramientas de MCP de BigQuery para explorar el conjunto de datos de citibike. Te dará una descripción general de las tablas y los campos disponibles en el conjunto de datos de Citibike.

12. Implementa el agente en Cloud Run

Este comando implementará el agente en Cloud Run con la CLI del 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}"

Prueba el agente

Usamos la opción --with_ui para la implementación de nuestro agente. Implementó el agente con la interfaz web del ADK.

  1. Abre la URL del agente en el navegador web. El comando adk deploy la mostró, y también puedes recuperarla ejecutando el comando gcloud run services:
gcloud run services describe gemma4-data-agent \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)'
  1. Pídele al agente que razone sobre los datos de Citibike disponibles:
We have budget for 3 coffee trucks.
We want to find the best city bike stations to place our coffee trucks.

El agente debe explorar el conjunto de datos de Citibike con el servidor de MCP de BigQuery, ejecutar algunas consultas de SQL y mostrar una lista de 3 estaciones de citibike.

13. ¡Felicitaciones!

¡Felicitaciones por completar el codelab!

Te recomendamos que revises la documentación de Cloud Run.

Temas abordados

  • Cómo implementar el modelo Gemma 4 en una GPU RTX 6000 Pro de Cloud Run
  • Cómo configurar la salida de VPC directa y la transmisión de modelos de vLLM con Cloud Storage para un inicio de servicio más rápido
  • Cómo crear y, luego, implementar un agente de IA con el Kit de desarrollo de agentes que usa el LLM Gemma 4 y el servidor de MCP de BigQuery

14. Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o borra los recursos individuales.

Opción 1: Borra los recursos

Borra los servicios de 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

Borra la cuenta de servicio

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

Borra el bucket de Cloud Storage

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

Borra la red de VPC y la subred

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

Opción 2: Borra el proyecto

Para borrar todo el proyecto, ve a Administrar recursos, selecciona el proyecto que creaste en el paso 2 y elige Borrar. Si borras el proyecto, deberás cambiar los proyectos en tu SDK de Cloud. Para ver la lista de todos los proyectos disponibles, ejecuta gcloud projects list. Si deseas usar la línea de comandos, también puedes usar este comando:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}