Build, Secure, and Deploy an MCP Server on Google Cloud

1. Before you begin

The Model Context Protocol (MCP) is an open standard that enables AI models and agents to securely access tools, databases, and enterprise context. Since its introduction in 2024, the protocol has seen wide adoption from Cloud and LLM providers. The newest specification MCP Spec 2026-07-28 (MCP 2.0) defines a stateless architecture, simplified transports, and strict result typing, while remaining backward compatible with earlier versions.

The official MCP Python SDK (mcp>=2.0.0) provides MCPServer (mcp.server.mcpserver.MCPServer), which replaces FastMCP in MCP 2.0 as the high-performance, developer-friendly framework for crafting production-ready MCP servers conforming to the modern MCP Spec (2026-07-28) with Streamable HTTP and Server-Sent Events (SSE) transports over SSL/TLS.

In this codelab, you will build a production-grade MCP server using MCPServer from the MCP 2.0 Python SDK and uv dependency management. You will equip your MCP server with four Google Cloud tools (Vertex AI Gemini invocation, Google Cloud Storage inspection, Cloud Logging audit writing, and Google Cloud resource health checking). Then, you will containerize the server and deploy it to two Google Cloud runtime targets: Cloud Run and Google Kubernetes Engine (GKE) Autopilot, and register and use the MCP Server in Gemini Enterprise Agent Platform.

MCP Spec 2026-07-28 & SDK v2.0 Highlights:

• MCPServer Replaces FastMCP: In the official mcp>=2.0.0 Python SDK, MCPServer (from mcp.server.mcpserver import MCPServer) replaces FastMCP while preserving the familiar decorator-driven API (@mcp.tool, @mcp.custom_route).
• Stateless Architecture: Eliminates stateful connection initialization handshakes (initialize/initialized). Every request carries protocol version and client capabilities in headers and _meta.
• Discovery Endpoint: Implements server/discover for capability and version negotiation.
• Streamable Transport: Simplified HTTP/SSE transport eliminating per-connection Mcp-Session-Id headers.
• Result Typing: All tool execution results include a mandatory resultType ("complete" or "input_required").

What you'll do

• Build an MCPServer with 4 Google Cloud tools using Python 3.12+ and uv conforming to MCP Spec 2026-07-28.
• Containerize the MCP server using a multi-stage Docker build.
• Secure and deploy the MCP server to Cloud Run with enforced IAM authentication and SSL/TLS.
• Secure and deploy the MCP server to GKE Autopilot using Workload Identity and Kubernetes Gateway API with TLS.
• Register the secure MCP server endpoint with Gemini Enterprise Agent Platform using OIDC bearer token headers.

What you'll need

• A Google Cloud project with billing enabled.
• Google Cloud SDK (gcloud CLI) installed and configured.
• Python 3.12+ and uv package manager installed.
• docker installed.
• kubectl command-line tool installed.

Tip: You can run this entire codelab inside Google Cloud Shell, which comes pre-installed with gcloud, docker, kubectl, Python, and uv.

2. Set up Google Cloud environment

Before creating resources, authenticate your environment and enable the necessary Google Cloud APIs.

Authenticate gcloud CLI

Log into your Google Cloud account:

gcloud auth login

Set your active Google Cloud project ID:

export PROJECT_ID=$(gcloud config get-value project)
gcloud config set project ${PROJECT_ID}

Enable Google Cloud Services

Enable all required APIs for Cloud Run, GKE, Vertex AI, Artifact Registry, Cloud Build, Cloud Logging, Storage, and Compute Engine:

gcloud services enable \
    agentregistry.googleapis.com \
    run.googleapis.com \
    container.googleapis.com \
    artifactregistry.googleapis.com \
    aiplatform.googleapis.com \
    logging.googleapis.com \
    storage.googleapis.com \
    compute.googleapis.com \
    iam.googleapis.com \
    cloudbuild.googleapis.com \
    --project="${PROJECT_ID}"

Verify that the APIs were enabled successfully:

Operation "operations/..." finished successfully.

Authenticate Application Default Credentials

Authenticate your environment so Python client libraries can access Vertex AI and Cloud Storage locally during development:

gcloud auth application-default login

3. Build the MCP Server with MCPServer and uv

In this step, you will initialize a Python project using uv and build an MCPServer supporting four Google Cloud capabilities.

Initialize Project with uv

Create the server directory and initialize uv:

mkdir -p mcp-server/src/mcp_server
cd mcp-server
uv init --lib

Copy the code into the pyproject.toml file:

[project]
name = "secure-mcp-gcp-server"
version = "0.1.0"
description = "MCP server with Google Cloud tools supporting MCP Spec 2026-07-28 over Streamable HTTP"
readme = "README.md"
requires-python = ">=3.12"
dependencies = [
    "mcp>=2.0.0",
    "google-genai>=1.0.0",
    "google-cloud-storage>=2.14.0",
    "google-cloud-logging>=3.11.0",
    "google-cloud-resource-manager>=1.12.0",
    "uvicorn>=0.30.0",
    "httpx2>=0.1.0",
    "pydantic>=2.7.0",
]

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.hatch.build.targets.wheel]
packages = ["src/mcp_server"]

Sync dependencies using uv:

uv sync

Write the MCPServer Code

Note on MCPServer vs FastMCP: Starting in MCP Python SDK v2.0 (mcp>=2.0.0), MCPServer (from mcp.server.mcpserver import MCPServer) replaces FastMCP as the standard server class for MCP 2.0, removing the need for a separate fastmcp dependency.

Create the server implementation file at src/mcp_server/server.py:

import logging
import os
from typing import Any

from google import genai
from google.cloud import logging as cloud_logging
from google.cloud import storage
from mcp.server.mcpserver import MCPServer
from starlette.requests import Request
from starlette.responses import PlainTextResponse

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("mcp-gcp-server")

# Initialize MCPServer conforming to MCP Spec 2026-07-28
mcp = MCPServer(
    "Google Cloud Production Tools",
    instructions="MCP Server conforming to MCP Spec 2026-07-28 for Vertex AI, Cloud Storage, Audit Logging, and Health Inspection.",
)


@mcp.custom_route("/healthz", methods=["GET"])
async def health_check(request: Request) -> PlainTextResponse:
    """Kubernetes readiness and liveness probe health check endpoint."""
    return PlainTextResponse("OK")


@mcp.tool(description="Generate content or answer questions using Vertex AI Gemini model.")
def vertex_ai_generate_content(
    prompt: str,
    model_name: str = "gemini-2.5-flash",
    project_id: str | None = None,
    location: str = "us-central1",
) -> str:
    """Invokes Vertex AI Gemini API using official google-genai SDK."""
    target_project = project_id or os.getenv("GCP_PROJECT") or os.getenv("GOOGLE_CLOUD_PROJECT")
    if not target_project:
        return "Error: GCP project ID not configured."

    try:
        client = genai.Client(vertexai=True, project=target_project, location=location)
        response = client.models.generate_content(
            model=model_name,
            contents=prompt,
        )
        return response.text or "No text returned from Gemini."
    except Exception as e:
        logger.error("Vertex AI Tool Error: %s", e)
        return f"Error executing Vertex AI tool: {e!s}"


@mcp.tool(description="List objects and inspect metadata for a specified Google Cloud Storage bucket.")
def gcs_bucket_inspector(
    bucket_name: str,
    max_results: int = 10,
    prefix: str | None = None,
) -> dict[str, Any]:
    """Inspects GCS bucket content and metadata conforming to MCP Spec 2026-07-28 resultType schema."""
    try:
        client = storage.Client()
        bucket = client.bucket(bucket_name)
        blobs = list(client.list_blobs(bucket, max_results=max_results, prefix=prefix))
        items = [{"name": b.name, "size_bytes": b.size, "updated": str(b.updated)} for b in blobs]
        return {
            "resultType": "complete",
            "bucket_name": bucket_name,
            "object_count_sample": len(items),
            "objects": items,
        }
    except Exception as e:
        logger.error("GCS Inspector Error: %s", e)
        return {"resultType": "complete", "error": f"Failed to inspect GCS bucket: {e!s}"}


@mcp.tool(description="Write structured operational or security audit log records to Google Cloud Logging.")
def cloud_logging_audit_writer(
    log_name: str,
    message: str,
    severity: str = "INFO",
    metadata: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """Sends structured audit entry to Cloud Logging."""
    try:
        client = cloud_logging.Client()
        logger_instance = client.logger(log_name)
        payload = {"message": message, "metadata": metadata or {}, "source": "mcp-server-gcp"}
        logger_instance.log_struct(payload, severity=severity.upper())
        return {
            "resultType": "complete",
            "status": "success",
            "log_name": log_name,
            "recorded_message": message,
        }
    except Exception as e:
        logger.error("Cloud Logging Error: %s", e)
        return {"resultType": "complete", "error": f"Failed to record audit log: {e!s}"}


@mcp.tool(description="Check health and operational state of Google Cloud project resources.")
def gcp_resource_health_checker(project_id: str | None = None) -> dict[str, Any]:
    """Returns project resource summary and status."""
    target_project = project_id or os.getenv("GOOGLE_CLOUD_PROJECT") or "unknown-project"
    return {
        "resultType": "complete",
        "status": "HEALTHY",
        "project_id": target_project,
        "mcp_spec_version": "2026-07-28",
        "_meta": {
            "io.modelcontextprotocol/protocolVersion": "2026-07-28",
            "io.modelcontextprotocol/serverInfo": {"name": "mcp-gcp-server", "version": "0.1.0"},
        },
        "transports_enabled": ["Streamable HTTP"],
        "ssl_tls_enabled": True,
    }


if __name__ == "__main__":
    port = int(os.getenv("PORT", "8080"))
    logger.info("Starting MCPServer on port %d (Streamable HTTP Transport, Spec 2026-07-28)...", port)
    mcp.run(
        transport="streamable-http",
        host="0.0.0.0",
        port=port,
        stateless_http=True,
        json_response=True,
    )

MCPServer Streamable HTTP Transport: MCPServer serves a stateless Streamable HTTP endpoint on /mcp conforming to MCP Spec 2026-07-28 (stateless_http=True, json_response=True). This allows remote agent platforms and LLMs to connect securely using HTTP POST operations over standard HTTPS without managing session state.

Tool Implementations in this Codelab:

• Live GCP SDK Tools: vertex_ai_generate_content, gcs_bucket_inspector, and cloud_logging_audit_writer make live API calls using their respective Google Cloud client libraries (google-genai, google-cloud-storage, and google-cloud-logging).
• Static Mock Tool: gcp_resource_health_checker is deliberately written as a lightweight static response. It provides an immediate zero-dependency healthcheck for test clients without requiring extra Cloud Monitoring or Resource Manager API quotas. In production, this can be extended with google-cloud-resource-manager or Cloud Monitoring Uptime Checks.

Test the MCP Server Locally

Step 1: Start the MCP Server

In your primary terminal, start the server using uv:

uv run python -m src.mcp_server.server

You should see startup logs confirming the Streamable HTTP server is listening on port 8080:

INFO:mcp-gcp-server:Starting MCPServer on port 8080 (Streamable HTTP Transport, Spec 2026-07-28)...
INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:mcp.server.streamable_http_manager:StreamableHTTP session manager started
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)

Keep this terminal open and running.

Step 2: Verify Streamable HTTP Endpoint using curl

In MCP 2.0 (MCP Spec 2026-07-28), the stateful initialize handshake and Mcp-Session-Id header are replaced by stateless requests. You can invoke tools/list directly by passing MCP-Protocol-Version and Mcp-Method headers along with client metadata in params._meta.

Open a second terminal window and send a Streamable HTTP POST request:

cd mcp-server
curl -i -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2026-07-28" \
  -H "Mcp-Method: tools/list" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {
      "_meta": {
        "io.modelcontextprotocol/protocolVersion": "2026-07-28",
        "io.modelcontextprotocol/clientInfo": {
          "name": "curl-test",
          "version": "1.0.0"
        },
        "io.modelcontextprotocol/clientCapabilities": {}
      }
    }
  }'

MCPServer will respond with HTTP/1.1 200 OK and return the JSON-RPC tools/list result directly:

HTTP/1.1 200 OK
date: Wed, 12 Aug 2026 14:55:00 GMT
server: uvicorn

content-type: application/json

{"jsonrpc":"2.0","id":1,"result":{"tools":[{"name":"vertex_ai_generate_content",...},{"name":"gcs_bucket_inspector",...},{"name":"cloud_logging_audit_writer",...},{"name":"gcp_resource_health_checker",...}]}}

Step 3: Run the MCP Test Client

To test discovering and executing tools on your local server over Streamable HTTP, create a test client script src/mcp_server/test_client.py:

import asyncio
from mcp import Client
from mcp.types import TextContent


async def test_mcp_server() -> None:
    """Connects to the local MCP v2.0 server, lists tools, and invokes health check."""
    server_url = "http://localhost:8080/mcp"
    print(f"[*] Connecting to local MCPServer at {server_url} (Streamable HTTP)...")

    async with Client(server_url) as client:
        print(
            f"[+] Connected (protocol: {client.protocol_version}, "
            f"server: {client.server_info.name if client.server_info else 'unknown'})."
        )

        # List available tools
        tools_response = await client.list_tools()
        print("\n[*] Discovered MCP Tools:")
        for tool in tools_response.tools:
            print(f"  - {tool.name}: {tool.description}")

        # Invoke gcp_resource_health_checker tool
        print("\n[*] Invoking tool: gcp_resource_health_checker...")
        health_result = await client.call_tool("gcp_resource_health_checker", {})
        print("[+] Result:")
        for content in health_result.content:
            if isinstance(content, TextContent):
                print(content.text)


if __name__ == "__main__":
    asyncio.run(test_mcp_server())

Run the test client script using uv:

uv run python src/mcp_server/test_client.py

You should see output demonstrating successful connection, tool discovery, and tool execution:

[*] Connecting to local MCPServer at http://localhost:8080/mcp (Streamable HTTP)...
[+] Connected (protocol: 2026-07-28, server: Google Cloud Production Tools).

[*] Discovered MCP Tools:
  - vertex_ai_generate_content: Generate content or answer questions using Vertex AI Gemini model.
  - gcs_bucket_inspector: List objects and inspect metadata for a specified Google Cloud Storage bucket.
  - cloud_logging_audit_writer: Write structured operational or security audit log records to Google Cloud Logging.
  - gcp_resource_health_checker: Check health and operational state of Google Cloud project resources.

[*] Invoking tool: gcp_resource_health_checker...
[+] Result:
{"resultType": "complete", "status": "HEALTHY", "project_id": "my-gcp-project", "mcp_spec_version": "2026-07-28", "_meta": {"io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/serverInfo": {"name": "mcp-gcp-server", "version": "0.1.0"}}, "transports_enabled": ["Streamable HTTP"], "ssl_tls_enabled": true}

MCP Inspector: You can also use the official interactive MCP Inspector UI to test your tools in a web browser by running npx @modelcontextprotocol/inspector --tui --server-url http://localhost:8080/mcp in your terminal. This will start a TUI web UI where you can interact with your MCP server in your terminal. Type c to connect to the MCP server and navigate the UI.

Once verified, press CTRL+C in your primary terminal to stop the local server.

4. Containerize the MCP Server

To deploy the MCP server to Cloud Run and GKE Autopilot, package the server into a minimal container image using a multi-stage Dockerfile powered by uv.

Create Dockerfile

In mcp-server/Dockerfile:

FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim AS builder

WORKDIR /app
ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy

COPY pyproject.toml uv.lock* /app/
RUN uv sync --no-install-project --no-dev

COPY README.md /app/
COPY src /app/src
RUN uv sync --no-dev

FROM python:3.12-slim-bookworm

WORKDIR /app
COPY --from=builder /app /app

ENV PATH="/app/.venv/bin:$PATH"
ENV PORT=8080
ENV PYTHONUNBUFFERED=1

EXPOSE 8080
CMD ["python", "-m", "src.mcp_server.server"]

Build and Push Image to Artifact Registry

Create an Artifact Registry repository:

gcloud artifacts repositories create mcp-servers \
    --repository-format=docker \
    --location=us-central1 \
    --description="Docker repository for MCP Servers" \
    --project="${PROJECT_ID}"

Grant the required IAM permissions to your user account and the default Compute Engine service account so Cloud Build can stage sources, write logs, and push images to Artifact Registry:

export USER_EMAIL=$(gcloud config get-value account)

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="user:${USER_EMAIL}" \
    --role="roles/cloudbuild.builds.editor"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="user:${USER_EMAIL}" \
    --role="roles/storage.admin"

export DEFAULT_SA=$(gcloud iam service-accounts list \
    --filter="email:[e-mail]" \
    --format="value(email)" \
    --project="${PROJECT_ID}")

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${DEFAULT_SA}" \
    --role="roles/storage.objectViewer"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${DEFAULT_SA}" \
    --role="roles/artifactregistry.writer"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${DEFAULT_SA}" \
    --role="roles/logging.logWriter"

Submit the image build using Cloud Build:

export IMAGE_URI="us-central1-docker.pkg.dev/${PROJECT_ID}/mcp-servers/secure-mcp-server:latest"

gcloud builds submit . --tag="${IMAGE_URI}" --project="${PROJECT_ID}"

Upon completion, your container image is stored securely in Artifact Registry:

SUCCESS: Image published to us-central1-docker.pkg.dev/.../secure-mcp-server:latest

5. Deploy to Cloud Run with IAM & HTTPS

Cloud Run provides a fully managed serverless environment with automatic HTTPS / SSL certificate termination and fine-grained Cloud IAM access control.

Create Dedicated Service Account

Create a least-privilege Google Service Account for Cloud Run:

gcloud iam service-accounts create mcp-server-cr-sa \
    --display-name="MCP Server Cloud Run SA" \
    --project="${PROJECT_ID}"

export SA_EMAIL="mcp-server-cr-sa@${PROJECT_ID}.iam.gserviceaccount.com"

# Grant Vertex AI, Logging, and GCS permissions
gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${SA_EMAIL}" \
    --role="roles/aiplatform.user"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${SA_EMAIL}" \
    --role="roles/logging.logWriter"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${SA_EMAIL}" \
    --role="roles/storage.objectViewer"

Deploy Service to Cloud Run

Deploy the container to Cloud Run with enforced IAM authentication (--no-allow-unauthenticated) and default managed SSL:

gcloud run deploy secure-mcp-server \
    --image="${IMAGE_URI}" \
    --platform=managed \
    --region=us-central1 \
    --service-account="${SA_EMAIL}" \
    --set-env-vars="GOOGLE_CLOUD_PROJECT=${PROJECT_ID}" \
    --no-allow-unauthenticated \
    --ingress=all \
    --project="${PROJECT_ID}"

Automatic Agent Registry Registration on Cloud Run: Cloud Run also offers a beta flag (gcloud beta run deploy ... --functional-type=mcp-server) to automatically register Cloud Run MCP servers in Agent Registry. Note that tool specification exposure and automatic tool discovery are not yet supported for Cloud Run automatic registration; in this codelab, you will manually register the Cloud Run service with toolspec.json so its full tool definitions are cataloged.

Retrieve the HTTPS URL:

export CLOUD_RUN_URL=$(gcloud run services describe secure-mcp-server --platform=managed --region=us-central1 --format='value(status.url)' --project="${PROJECT_ID}")
echo "Cloud Run HTTPS Endpoint: ${CLOUD_RUN_URL}"

Caution: By specifying --no-allow-unauthenticated, unauthorized public HTTP requests are rejected by Google Front End (GFE). Callers must present a valid Google OIDC ID token matching the Cloud Run service URL audience.

Verify Endpoint Security

Attempting an unauthorized request to the Streamable HTTP endpoint will return 403 Forbidden:

Why 403 Forbidden instead of 401 Unauthorized?: When no Authorization header is provided, Cloud IAM evaluates the caller identity as allUsers (anonymous), which lacks the Cloud Run Invoker permission—resulting in an authorization failure (403 Forbidden). Providing a Google OIDC identity token satisfies both authentication and authorization.

curl -i -X POST "${CLOUD_RUN_URL}/mcp" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2026-07-28" \
  -H "Mcp-Method: tools/list" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {
      "_meta": {
        "io.modelcontextprotocol/protocolVersion": "2026-07-28",
        "io.modelcontextprotocol/clientInfo": {
          "name": "curl-test",
          "version": "1.0.0"
        },
        "io.modelcontextprotocol/clientCapabilities": {}
      }
    }
  }'

HTTP/2 403
content-type: text/html; charset=UTF-8
date: Mon, 11 Aug 2026 14:00:00 GMT

Generate an OIDC ID token using gcloud to verify authorized communication:

export ID_TOKEN=$(gcloud auth print-identity-token --audiences="${CLOUD_RUN_URL}")

curl -i -X POST "${CLOUD_RUN_URL}/mcp" \
  -H "Authorization: Bearer ${ID_TOKEN}" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2026-07-28" \
  -H "Mcp-Method: tools/list" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {
      "_meta": {
        "io.modelcontextprotocol/protocolVersion": "2026-07-28",
        "io.modelcontextprotocol/clientInfo": {
          "name": "curl-test",
          "version": "1.0.0"
        },
        "io.modelcontextprotocol/clientCapabilities": {}
      }
    }
  }'

HTTP/2 200
content-type: application/json

{"jsonrpc":"2.0","id":1,"result":{"tools":[{"name":"vertex_ai_generate_content",...},{"name":"gcs_bucket_inspector",...},{"name":"cloud_logging_audit_writer",...},{"name":"gcp_resource_health_checker",...}]}}

Test Live Tool Execution: Cloud Storage Inspector

Now that the remote MCP server is authenticated and responding, test executing the gcs_bucket_inspector tool against Google Cloud infrastructure.

Step 1: Create a Test Cloud Storage Bucket

Create a test bucket and upload a sample file:

export BUCKET_NAME="${PROJECT_ID}-mcp-demo"

# Create Cloud Storage bucket
gcloud storage buckets create "gs://${BUCKET_NAME}" \
    --location=us-central1 \
    --project="${PROJECT_ID}"

# Upload sample file
echo "Hello from Secure MCP on Google Cloud!" > sample.txt
gcloud storage cp sample.txt "gs://${BUCKET_NAME}/sample.txt"

Step 2: Create the Remote GCS Tool Test Client

Create a test client script named src/mcp_server/test_gcs_tool.py to authenticate against Cloud Run and invoke the gcs_bucket_inspector tool:

import asyncio
import os
import subprocess
import httpx2
from mcp import Client
from mcp.client.streamable_http import streamable_http_client
from mcp.types import TextContent


async def test_gcs_tool() -> None:
    """Authenticates to Cloud Run via OIDC and invokes the gcs_bucket_inspector tool."""
    cloud_run_url = os.getenv("CLOUD_RUN_URL")
    bucket_name = os.getenv("BUCKET_NAME")

    if not cloud_run_url or not bucket_name:
        print("[!] Please set both CLOUD_RUN_URL and BUCKET_NAME environment variables.")
        return

    # Generate Google OIDC ID token for Cloud Run authentication
    id_token = subprocess.check_output(
        ["gcloud", "auth", "print-identity-token", f"--audiences={cloud_run_url.rstrip('/')}"],
        text=True,
    ).strip()

    headers = {"Authorization": f"Bearer {id_token}"}
    server_url = f"{cloud_run_url.rstrip('/')}/mcp"

    print(f"[*] Connecting to remote Cloud Run MCP server at {server_url} (Streamable HTTP)...")
    async with httpx2.AsyncClient(
        headers=headers,
        timeout=httpx2.Timeout(30.0, read=300.0),
    ) as http_client:
        transport = streamable_http_client(server_url, http_client=http_client)
        async with Client(transport) as client:
            print(
                f"[+] Authenticated and connected (protocol: {client.protocol_version})."
            )

            # List tools
            tools_response = await client.list_tools()
            print(f"[*] Verified {len(tools_response.tools)} available tools on Cloud Run.")

            # Invoke gcs_bucket_inspector tool
            print(f"\n[*] Invoking tool: gcs_bucket_inspector on '{bucket_name}'...")
            result = await client.call_tool(
                "gcs_bucket_inspector", {"bucket_name": bucket_name}
            )

            print("[+] Response from Cloud Run MCP Server:")
            for content in result.content:
                if isinstance(content, TextContent):
                    print(content.text)


if __name__ == "__main__":
    asyncio.run(test_gcs_tool())

Step 3: Run the Remote GCS Test Client

Run the test script using uv:

uv run python src/mcp_server/test_gcs_tool.py

You should see live object metadata returned from the Cloud Run MCP server:

[*] Connecting to remote Cloud Run MCP server at https://secure-mcp-server-...-uc.a.run.app/mcp (Streamable HTTP)...
[+] Authenticated and connected (protocol: 2026-07-28).
[*] Verified 4 available tools on Cloud Run.

[*] Invoking tool: gcs_bucket_inspector on 'my-project-mcp-demo'...
[+] Response from Cloud Run MCP Server:
{"resultType":"complete","bucket_name":"my-project-mcp-demo","object_count_sample":1,"objects":[{"name":"sample.txt","size_bytes":39,"updated":"..."}]}

6. Deploy to GKE Autopilot with Workload Identity & TLS

For Kubernetes workloads, GKE Autopilot manages node provisioning while Workload Identity eliminates static service account keys.

Provision GKE Autopilot Cluster

Provision a GKE Autopilot cluster:

gcloud container clusters create-auto mcp-gke-cluster \
    --location=us-central1 \
    --project="${PROJECT_ID}"

gcloud container clusters get-credentials mcp-gke-cluster \
    --location=us-central1 \
    --project="${PROJECT_ID}"

Set up Workload Identity

Create a Google Service Account (GSA) and a Kubernetes Service Account (KSA), then link them using Workload Identity:

# 1. Create GSA
gcloud iam service-accounts create mcp-gke-sa \
    --display-name="GKE MCP Service Account" \
    --project="${PROJECT_ID}"

export GSA_EMAIL="mcp-gke-sa@${PROJECT_ID}.iam.gserviceaccount.com"

# 2. Grant IAM Roles to GSA
gcloud projects add-iam-policy-binding "${PROJECT_ID}" --member="serviceAccount:${GSA_EMAIL}" --role="roles/aiplatform.user"
gcloud projects add-iam-policy-binding "${PROJECT_ID}" --member="serviceAccount:${GSA_EMAIL}" --role="roles/logging.logWriter"
gcloud projects add-iam-policy-binding "${PROJECT_ID}" --member="serviceAccount:${GSA_EMAIL}" --role="roles/storage.objectViewer"

# 3. Create KSA
kubectl create serviceaccount mcp-server-ksa --namespace default

# 4. Annotate KSA
kubectl annotate serviceaccount mcp-server-ksa \
    --namespace default \
    iam.gke.io/gcp-service-account="${GSA_EMAIL}"

# 5. Bind KSA to GSA
gcloud iam service-accounts add-iam-policy-binding "${GSA_EMAIL}" \
    --role="roles/iam.workloadIdentityUser" \
    --member="serviceAccount:${PROJECT_ID}.svc.id.goog[default/mcp-server-ksa]" \
    --project="${PROJECT_ID}"

Apply Kubernetes Deployment & Gateway API with TLS

Step 1: Reserve Static IP & Provision Google-Managed SSL Certificate with nip.io

Reserve a global external IP address and leverage wildcard DNS service nip.io (..nip.io) to establish a valid public domain name (MCP_DOMAIN) before applying the Kubernetes manifests:

# Reserve global static IP address for GKE Gateway Load Balancer
gcloud compute addresses create mcp-server-ip \
    --global \
    --project="${PROJECT_ID}"

export MCP_IP=$(gcloud compute addresses describe mcp-server-ip --global --format="value(address)" --project="${PROJECT_ID}")
export MCP_DOMAIN="mcp.${MCP_IP}.nip.io"

echo "Reserved Static IP: ${MCP_IP}"
echo "Configured nip.io Domain: ${MCP_DOMAIN}"

# Provision Google-managed SSL certificate
gcloud compute ssl-certificates create mcp-server-cert \
    --domains="${MCP_DOMAIN}" \
    --global \
    --project="${PROJECT_ID}"

You don't need to wait for the SSL certificate to finish provisioning before continuing—in fact, Google-managed certificates remain in PROVISIONING state until they are attached to the Gateway Load Balancer in Step 3. Proceed immediately to the next steps.

Step 2: Create the Deployment and Service Manifest

Create deployment.yaml containing the Deployment and internal Service definitions. Because MCP 2.0 (MCP Spec 2026-07-28) is stateless, the Kubernetes Service does not require client IP session affinity:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-server-deployment
  namespace: default
  labels:
    app: mcp-server
    # GKE takes this label and registers the deployment as an MCP server to Agent Registry
    registry.gke.io/functional-type: "MCP_SERVER"
  annotations:
    # Endpoint URL where the GKE controller can access this MCP server
    modelcontextprotocol.info/urls: |
      - https://MCP_DOMAIN/mcp
    # Defines structural capabilities for the MCP server card
    modelcontextprotocol.info/capabilities: |
      card:
        endpoint: "/mcp"
        protocol: "HTTP"
spec:
  replicas: 2
  selector:
    matchLabels:
      app: mcp-server
  template:
    metadata:
      labels:
        app: mcp-server
      annotations:
        # Workload Identity annotation for identity and access management
        iam.gke.io/spiffe-identity-type: agent-identity
    spec:
      serviceAccountName: mcp-server-ksa
      containers:
      - name: mcp-server
        image: us-central1-docker.pkg.dev/PROJECT_ID/mcp-servers/secure-mcp-server:latest
        ports:
        - containerPort: 8080
          name: http
        env:
        - name: PORT
          value: "8080"
        - name: GOOGLE_CLOUD_PROJECT
          value: "PROJECT_ID"
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 15
---
apiVersion: v1
kind: Service
metadata:
  name: mcp-server-service
  namespace: default
  labels:
    app: mcp-server
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 8080
    name: http
  selector:
    app: mcp-server

Substitute MCP_DOMAIN and PROJECT_ID and apply the deployment:

sed -e "s|MCP_DOMAIN|${MCP_DOMAIN}|g" \
    -e "s|PROJECT_ID|${PROJECT_ID}|g" \
    deployment.yaml | kubectl apply -f -

Step 3: Create the Gateway API, HealthCheckPolicy, and GCPBackendPolicy Manifest

Create gateway.yaml containing the Gateway, HTTPRoute, a HealthCheckPolicy, and a GCPBackendPolicy:

• HealthCheckPolicy: Configures the Google Cloud Load Balancer to probe /healthz on port 8080.
• GCPBackendPolicy (Backend Timeout): Sets timeoutSec: 300 to align with MCP SDK v2's 300-second read timeout for Streamable HTTP / SSE streams (GKE Gateway defaults to 30 seconds if omitted).

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: mcp-gateway
  namespace: default
spec:
  gatewayClassName: gke-l7-global-external-managed
  listeners:
  - name: https
    protocol: HTTPS
    port: 443
    tls:
      mode: Terminate
      options:
        networking.gke.io/pre-shared-certs: mcp-server-cert
  addresses:
  - type: NamedAddress
    value: mcp-server-ip
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: mcp-http-route
  namespace: default
spec:
  parentRefs:
  - name: mcp-gateway
  hostnames:
  - "MCP_DOMAIN"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /
    backendRefs:
    - name: mcp-server-service
      port: 80
---
apiVersion: networking.gke.io/v1
kind: HealthCheckPolicy
metadata:
  name: mcp-health-check-policy
  namespace: default
spec:
  default:
    checkIntervalSec: 15
    timeoutSec: 5
    healthyThreshold: 1
    unhealthyThreshold: 2
    config:
      type: HTTP
      httpHealthCheck:
        port: 8080
        requestPath: /healthz
  targetRef:
    group: ""
    kind: Service
    name: mcp-server-service
---
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
  name: mcp-backend-policy
  namespace: default
spec:
  default:
    # Aligns with MCP SDK v2's 300s read timeout for Streamable HTTP / SSE streams
    # (GKE Gateway defaults to 30s if omitted)
    timeoutSec: 300
  targetRef:
    group: ""
    kind: Service
    name: mcp-server-service

Apply the Gateway, HTTPRoute, HealthCheckPolicy, and GCPBackendPolicy:

sed "s/MCP_DOMAIN/${MCP_DOMAIN}/g" gateway.yaml | kubectl apply -f -

Step 4: Verify Deployment and Test MCP Server using Port-Forward

Because Google-managed SSL certificates and external Google Cloud Application Load Balancers take 5 to 15 minutes to provision and establish DNS routing, you can immediately test the running GKE pods using kubectl port-forward.

First, check that your pods and Gateway are running:

kubectl get pods -l app=mcp-server
kubectl get gateway mcp-gateway

NAME                                     READY   STATUS    RESTARTS   AGE
mcp-server-deployment-7b8f9495c5-x2n8q   1/1     Running   0          45s
mcp-server-deployment-7b8f9495c5-z4k9p   1/1     Running   0          45s

NAME          CLASS                             ADDRESS          PROGRAMMED   AGE
mcp-gateway   gke-l7-global-external-managed   34.120.x.x       True         2m

Next, test the live GKE service locally using port forwarding:

1. In your terminal, forward local port 8080 to the GKE ClusterIP service:

kubectl port-forward svc/mcp-server-service 8080:80

Keep the kubectl port-forward process running in this terminal session, or open a second terminal for the next commands.

2. In a second terminal, create a test client script named src/mcp_server/test_vertex_tool.py to invoke the vertex_ai_generate_content tool on GKE using Workload Identity:

import argparse
import asyncio
import os
from mcp import Client
from mcp.types import TextContent


async def test_vertex_tool(server_url: str) -> None:
    """Connects to the MCP v2.0 server and invokes the vertex_ai_generate_content tool."""
    print(f"[*] Connecting to MCPServer at {server_url} (Streamable HTTP)...")

    async with Client(server_url) as client:
        print(
            f"[+] Connected (protocol: {client.protocol_version}, "
            f"server: {client.server_info.name if client.server_info else 'unknown'})."
        )

        # List available tools
        tools_response = await client.list_tools()
        print(f"[*] Discovered {len(tools_response.tools)} MCP Tools:")
        for tool in tools_response.tools:
            print(f"  - {tool.name}")

        # Invoke vertex_ai_generate_content tool
        prompt = "Explain in 2 sentences why Model Context Protocol (MCP) Streamable HTTP is great for cloud deployments."
        print(f"\n[*] Invoking tool: vertex_ai_generate_content with prompt: '{prompt}'...")

        result = await client.call_tool(
            "vertex_ai_generate_content",
            {
                "prompt": prompt,
                "model_name": "gemini-2.5-flash",
            },
        )

        print("\n[+] Response from Vertex AI Gemini:")
        for content in result.content:
            if isinstance(content, TextContent):
                print(content.text)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Test Vertex AI MCP Tool on MCPServer.")
    parser.add_argument(
        "--host",
        default=os.getenv("MCP_URL", "http://localhost:8080/mcp"),
        help="MCP Server host or URL (default: http://localhost:8080/mcp or $MCP_URL)",
    )
    args = parser.parse_args()

    # Normalize URL format
    url = args.host
    if not url.startswith("http://") and not url.startswith("https://"):
        url = f"https://{url}"
    if not url.endswith("/mcp"):
        url = f"{url.rstrip('/')}/mcp"

    asyncio.run(test_vertex_tool(url))

3. Run the test script against the local port-forwarded instance:

uv run python src/mcp_server/test_vertex_tool.py --host="http://localhost:8080/mcp"

[*] Connecting to MCPServer at http://localhost:8080/mcp (Streamable HTTP)...
[+] Connected (protocol: 2026-07-28, server: Google Cloud Production Tools).
[*] Discovered 4 MCP Tools:
  - vertex_ai_generate_content
  - gcs_bucket_inspector
  - cloud_logging_audit_writer
  - gcp_resource_health_checker

[*] Invoking tool: vertex_ai_generate_content with prompt: 'Explain in 2 sentences why Model Context Protocol (MCP) Streamable HTTP is great for cloud deployments.'...

[+] Response from Vertex AI Gemini:
MCP Streamable HTTP enables lightweight, stateless HTTP interactions that scale effortlessly across cloud-native platforms like GKE and Cloud Run. It simplifies infrastructure management by using standard HTTP/HTTPS protocols while preserving rich bidirectional streaming for AI agents.

This confirms that the GKE pods are healthy, Workload Identity is successfully authenticating against Vertex AI without static credentials, and the Streamable HTTP transport is operating as expected!

Step 5: Verify Public HTTPS Gateway Endpoint

Load Balancer and Certificate Provisioning Time: Provisioning the external Google Cloud Load Balancer and Google-managed SSL certificate takes approximately 5 to 15 minutes. While the certificate status is PROVISIONING, you can proceed to the next sections and return to this step once the status transitions to ACTIVE to test the public HTTPS domain.

Check the certificate provisioning status with:

gcloud compute ssl-certificates describe mcp-server-cert --global --format="value(managed.status)"

Public Endpoint Security & Identity-Aware Proxy (IAP): In this tutorial, the GKE Gateway exposes the MCP server endpoint publicly without authentication so that testing and remote connectivity are straightforward. For production environments, configure Google Cloud Identity-Aware Proxy (IAP) on your GKE Gateway / Ingress, or integrate an OAuth 2.0 reverse proxy. With IAP enabled, only authenticated users and authorized service accounts with the roles/iap.httpsResourceAccessor IAM role can connect to your MCP server.

Once the certificate is ACTIVE, test the public HTTPS endpoint using the Python test client with the --host flag:

uv run python src/mcp_server/test_vertex_tool.py --host="https://${MCP_DOMAIN}/mcp"

[*] Connecting to MCPServer at https://mcp.34.120.x.x.nip.io/mcp (Streamable HTTP)...
[+] Connected (protocol: 2026-07-28, server: Google Cloud Production Tools).
[*] Discovered 4 MCP Tools:
  - vertex_ai_generate_content
  - gcs_bucket_inspector
  - cloud_logging_audit_writer
  - gcp_resource_health_checker

[*] Invoking tool: vertex_ai_generate_content with prompt: 'Explain in 2 sentences why Model Context Protocol (MCP) Streamable HTTP is great for cloud deployments.'...

[+] Response from Vertex AI Gemini:
MCP Streamable HTTP enables lightweight, stateless HTTP interactions that scale effortlessly across cloud-native platforms like GKE and Cloud Run. It simplifies infrastructure management by using standard HTTP/HTTPS protocols while preserving rich bidirectional streaming for AI agents.

7. Integrate MCP Server with Google Cloud Agent Platform

Now that your MCPServer is securely deployed to HTTPS endpoints on Cloud Run and GKE Autopilot, register and discover your MCP tools with Google Cloud Agent Platform (Agent Registry) so enterprise agents and AI models can dynamically discover and invoke them.

Agent Registry Resource Architecture (/services vs /mcpServers): Agent Registry separates writable registration resources (/services) from read-only catalog projections (/mcpServers). Manual registrations are created using gcloud agent-registry services and projected into /mcpServers, whereas automatic registrations (such as GKE workloads) appear directly in the read-only catalog (gcloud agent-registry mcp-servers list) and not under gcloud agent-registry services list.

1. Register Custom Cloud Run MCP Server to Agent Platform & Test using Service Discovery

Step 1: Extract Tool Specifications (toolspec.json)

To register an external or custom MCP server in Agent Registry, query tools/list on your live stateless MCP 2.0 server, strip tool-level _meta fields, and save the result to toolspec.json in a single pipeline:

# 1. Generate identity token
export ID_TOKEN=$(gcloud auth print-identity-token --audiences="${CLOUD_RUN_URL}")

# 2. Query, parse, sanitize and save in one single pipeline
curl -s -X POST "${CLOUD_RUN_URL}/mcp" \
  -H "Authorization: Bearer ${ID_TOKEN}" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2026-07-28" \
  -H "Mcp-Method: tools/list" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {
      "_meta": {
        "io.modelcontextprotocol/protocolVersion": "2026-07-28",
        "io.modelcontextprotocol/clientInfo": {
          "name": "cli",
          "version": "1.0.0"
        },
        "io.modelcontextprotocol/clientCapabilities": {}
      }
    }
  }' \
  | sed -n 's/^data: //p; /^{/p' \
  | jq '.result | del(.tools[]._meta)' > toolspec.json

Step 2: Register the Service in Agent Registry

Use gcloud agent-registry services create to catalog your MCP server:

export SERVER_NAME="secure-mcp-server"
export DISPLAY_NAME="Google Cloud MCPServer"
export REGION="global"

gcloud agent-registry services create "${SERVER_NAME}" \
  --project="${PROJECT_ID}" \
  --location="${REGION}" \
  --display-name="${DISPLAY_NAME}" \
  --mcp-server-spec-type="tool-spec" \
  --mcp-server-spec-content=toolspec.json \
  --interfaces="url=${CLOUD_RUN_URL}/mcp,protocolBinding=jsonrpc"

Verify that the service was registered successfully:

gcloud agent-registry services describe "${SERVER_NAME}" --location="${REGION}"

name: projects/PROJECT_ID/locations/global/services/secure-mcp-server
displayName: Google Cloud MCPServer
interfaces:
- protocolBinding: JSONRPC
  url: https://secure-mcp-server-xxxx.a.run.app/mcp
mcpServerSpec:
  type: TOOL_SPEC

Step 3: Create and Run Service Discovery Test Client

Create a Python script named src/mcp_server/test_agent_platform.py that dynamically resolves the endpoint from the Agent Registry mcp-servers catalog, authenticates with Google Cloud IAM, and invokes a tool using httpx2 and the MCP 2.0 Client:

import asyncio
import os
import subprocess
import httpx2  # MCP SDK 2.x utilizes httpx2 instead of httpx
from mcp import Client
from mcp.client.streamable_http import streamable_http_client


async def main() -> None:
    server_name = os.getenv("SERVER_NAME", "secure-mcp-server")
    location = os.getenv("REGION", "global")

    # 1. Discover endpoint URL from Google Cloud Agent Registry (mcp-servers catalog)
    print(f"[*] Discovering '{server_name}' in '{location}' from Agent Registry...")
    url = subprocess.check_output(
        [
            "gcloud",
            "agent-registry",
            "mcp-servers",
            "list",
            f"--location={location}",
            f"--filter=displayName='{server_name}' OR mcpServerId ~ ':{server_name}$'",
            "--format=value(interfaces[0].url)",
            "--limit=1",
        ],
        text=True,
    ).strip()

    if not url:
        raise RuntimeError(
            f"No endpoint URL found for '{server_name}' in location '{location}'. "
            "Verify the server is registered and has an interface URL configured."
        )
    print(f"[+] Discovered Endpoint: {url}")

    # 2. Generate IAM identity token if connecting to Cloud Run
    headers: dict[str, str] = {}
    if "run.app" in url:
        audience = url.split("/mcp")[0]
        token = subprocess.check_output(
            ["gcloud", "auth", "print-identity-token", f"--audiences={audience}"],
            text=True,
        ).strip()
        headers["Authorization"] = f"Bearer {token}"

    # 3. Configure a custom httpx2 Client with MCP-safe timeouts
    # We set read to 300s to ensure the long-lived SSE/GET stream stays open
    async with httpx2.AsyncClient(
        headers=headers,
        timeout=httpx2.Timeout(30.0, read=300.0),
    ) as http_client:

        # 4. Initialize Streamable HTTP Transport (yielding a 2-tuple in MCP v2.x)
        transport = streamable_http_client(url, http_client=http_client)

        # 5. Connect using the clean high-level Client interface
        async with Client(transport) as client:
            print("[+] Session active. Connected successfully.")

            # Verify tools registered in the catalog (Attributes are snake_case in MCP v2)
            tools_response = await client.list_tools()
            print(f"[+] Discovered {len(tools_response.tools)} tools:")
            for tool in tools_response.tools:
                print(f"    - {tool.name}")

            # Test executing the health check tool
            print("\n[*] Invoking tool: gcp_resource_health_checker...")
            result = await client.call_tool("gcp_resource_health_checker", {})
            print(f"[+] Tool Output from Agent Platform:\n{result.content[0].text}")


if __name__ == "__main__":
    asyncio.run(main())

Execute the test script:

uv run python src/mcp_server/test_agent_platform.py

[*] Discovering 'secure-mcp-server' in 'global' from Agent Registry...
[+] Discovered Endpoint: https://secure-mcp-server-xxxx.a.run.app/mcp
[+] Session active. Connected successfully.
[+] Discovered 4 tools:
    - vertex_ai_generate_content
    - gcs_bucket_inspector
    - cloud_logging_audit_writer
    - gcp_resource_health_checker

[*] Invoking tool: gcp_resource_health_checker...
[+] Tool Output from Agent Platform:
{"resultType": "complete", "status": "HEALTHY", "mcp_spec_version": "2026-07-28"}

2. Automatic MCP Server Discovery and Registration with GKE

Google Kubernetes Engine (GKE) provides automatic integration with Agent Registry. By labeling and annotating your GKE Deployment manifest, GKE automatically performs an introspection scan against the MCP server, registers the tools into the catalog, and projects the service onto the consumer side without needing to manually generate or upload a toolspec.json.

Step 1: How GKE Automatic Discovery Works

When your deployment.yaml was applied in the previous section, the following configurations enabled automatic discovery:

• registry.gke.io/functional-type: "MCP_SERVER": Informs the GKE cluster controller to register the deployment into Google Cloud Agent Registry.
• modelcontextprotocol.info/urls: Provides the external HTTPS Gateway endpoint (https://${MCP_DOMAIN}/mcp) for controller introspection and consumer routing.
• modelcontextprotocol.info/capabilities: Declares the HTTP transport endpoint (/mcp).
• iam.gke.io/spiffe-identity-type: agent-identity: Configures Workload Identity for agentic communication.

Step 2: Verify GKE Auto-Registration in Agent Registry

Verify that GKE automatically discovered and registered your MCP server into the regional mcp-servers catalog:

# List the automatically registered GKE MCP server in us-central1
gcloud agent-registry mcp-servers list \
  --location=us-central1 \
  --format="table(displayName, tools.len():label=TOOLS)"

DISPLAY_NAME           TOOLS
mcp-server-deployment  4

Step 3: Test GKE MCP Server using Service Discovery

Test your GKE MCP deployment using the service discovery script against the auto-registered server name in us-central1:

SERVER_NAME="mcp-server-deployment" \
REGION=us-central1 \
uv run python src/mcp_server/test_agent_platform.py

[*] Discovering 'mcp-server-deployment' in 'us-central1' from Agent Registry...
[+] Discovered Endpoint: https://mcp.34.120.x.x.nip.io/mcp
[+] Session active. Connected successfully.
[+] Discovered 4 tools:
    - vertex_ai_generate_content
    - gcs_bucket_inspector
    - cloud_logging_audit_writer
    - gcp_resource_health_checker

[*] Invoking tool: gcp_resource_health_checker...
[+] Tool Output from Agent Platform:
{"resultType": "complete", "status": "HEALTHY", "mcp_spec_version": "2026-07-28"}

8. Clean up resources

To avoid incurring charges to your Google Cloud account for the resources used in this codelab, delete the Cloud Run service, GKE cluster, service accounts, and container repository.

Delete Cloud Run Service

gcloud run services delete secure-mcp-server \
    --platform=managed \
    --region=us-central1 \
    --quiet \
    --project="${PROJECT_ID}"

Delete GKE Autopilot Cluster

gcloud container clusters delete mcp-gke-cluster \
    --location=us-central1 \
    --quiet \
    --project="${PROJECT_ID}"

Delete Service Accounts & IAM Bindings

gcloud iam service-accounts delete "mcp-server-cr-sa@${PROJECT_ID}.iam.gserviceaccount.com" --quiet --project="${PROJECT_ID}"
gcloud iam service-accounts delete "mcp-gke-sa@${PROJECT_ID}.iam.gserviceaccount.com" --quiet --project="${PROJECT_ID}"

Delete Artifact Registry Repository

gcloud artifacts repositories delete mcp-servers \
    --location=us-central1 \
    --quiet \
    --project="${PROJECT_ID}"

Delete Agent Registry Custom Service

gcloud agent-registry services delete secure-mcp-server \
    --location=global \
    --quiet \
    --project="${PROJECT_ID}"

Delete Cloud Storage Bucket

gcloud storage rm --recursive "gs://${BUCKET_NAME}" --quiet

Delete Static IP & SSL Certificate

gcloud compute ssl-certificates delete mcp-server-cert --global --quiet --project="${PROJECT_ID}"
gcloud compute addresses delete mcp-server-ip --global --quiet --project="${PROJECT_ID}"

Verify deletion cleanup complete:

Deleted service [secure-mcp-server].
Deleted cluster [mcp-gke-cluster].
Deleted repository [mcp-servers].

9. Congratulations

Congratulations! You have successfully built, secured, and deployed an MCP 2.0 Server using MCPServer from the MCP Python SDK and uv on Google Cloud!

What you covered

• Constructed an MCPServer supporting MCP Spec (2026-07-28) over stateless Streamable HTTP.
• Built 4 production Google Cloud tools integrating Vertex AI Gemini, Cloud Storage, Cloud Logging, and Resource Health.
• Secured container deployments on Cloud Run with enforced IAM authentication and SSL/TLS.
• Configured secretless authentication on GKE Autopilot with Workload Identity and Kubernetes Gateway API with TLS.
• Registered and discovered MCP server endpoints with Gemini Enterprise Agent Platform (Agent Registry) using OIDC authorization headers.

Next steps

• Explore Model Context Protocol Specification for advanced resources and prompt definitions.
• Learn more about the MCP Python SDK.
• Deep dive into Google Cloud Run Security and GKE Workload Identity.