Tạo, bảo mật và triển khai máy chủ MCP trên Google Cloud

1. Trước khi bắt đầu

Giao thức ngữ cảnh mô hình (MCP) là một tiêu chuẩn mở cho phép các mô hình và tác nhân AI truy cập an toàn vào các công cụ, cơ sở dữ liệu và ngữ cảnh doanh nghiệp. Kể từ khi ra mắt vào năm 2024, giao thức này đã được các nhà cung cấp Đám mây và LLM áp dụng rộng rãi. Quy cách mới nhất MCP Spec 2026-07-28 (MCP 2.0) xác định một cấu trúc không trạng thái, các phương thức truyền tải đơn giản và việc nhập kết quả nghiêm ngặt, đồng thời vẫn tương thích ngược với các phiên bản trước.

MCP Python SDK (mcp>=2.0.0) chính thức cung cấp MCPServer (mcp.server.mcpserver.MCPServer), thay thế FastMCP trong MCP 2.0 làm khung hiệu suất cao, thân thiện với nhà phát triển để tạo các máy chủ MCP sẵn sàng sản xuất tuân thủ MCP Spec (28/7/2026) hiện đại với các phương thức truyền HTTP có thể truyền trực tuyến và Sự kiện do máy chủ gửi (SSE) qua SSL/TLS.

Trong lớp học lập trình này, bạn sẽ xây dựng một máy chủ MCP cấp sản xuất bằng MCPServer từ MCP 2.0 Python SDK và tính năng quản lý phần phụ thuộc uv. Bạn sẽ trang bị cho máy chủ MCP của mình 4 công cụ của Google Cloud (lời gọi Vertex AI Gemini, hoạt động kiểm tra Google Cloud Storage, hoạt động ghi nhật ký kiểm tra Cloud Logging và hoạt động kiểm tra tình trạng tài nguyên của Google Cloud). Sau đó, bạn sẽ tạo vùng chứa cho máy chủ và triển khai máy chủ đó đến 2 mục tiêu thời gian chạy của Google Cloud: Cloud Run và Google Kubernetes Engine (GKE) Autopilot, đồng thời đăng ký và sử dụng Máy chủ MCP trong Nền tảng tác nhân Gemini Enterprise.

Bạn sẽ thực hiện

  • Tạo một MCPServer bằng 4 công cụ của Google Cloud bằng Python 3.12 trở lên và uv tuân thủ MCP Spec 2026-07-28.
  • Chứa máy chủ MCP bằng bản dựng Docker nhiều giai đoạn.
  • Bảo mật và triển khai máy chủ MCP lên Cloud Run bằng xác thực IAM và SSL/TLS bắt buộc.
  • Bảo mật và triển khai máy chủ MCP vào GKE Autopilot bằng Workload Identity và Kubernetes Gateway API có TLS.
  • Đăng ký điểm cuối máy chủ MCP bảo mật với Nền tảng tác nhân Gemini Enterprise bằng cách sử dụng tiêu đề mã thông báo người dùng OIDC.

Bạn cần có

  • Một dự án trên Google Cloud đã bật tính năng thanh toán.
  • Google Cloud SDK (CLI gcloud) đã được cài đặt và định cấu hình.
  • Đã cài đặt Python 3.12 trở lên và trình quản lý gói uv.
  • Đã cài đặt docker.
  • Đã cài đặt công cụ dòng lệnh kubectl.

2. Thiết lập môi trường Google Cloud

Trước khi tạo tài nguyên, hãy xác thực môi trường của bạn và bật các Cloud APIs cần thiết của Google.

Xác thực CLI gcloud

Đăng nhập vào tài khoản Google Cloud của bạn:

gcloud auth login

Đặt mã dự án trên đám mây đang hoạt động của bạn:

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

Bật Dịch vụ Google Cloud

Bật tất cả các API bắt buộc cho Cloud Run, GKE, Vertex AI, Artifact Registry, Cloud Build, Cloud Logging, Storage và 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}"

Xác minh rằng bạn đã bật các API thành công:

Operation "operations/..." finished successfully.

Xác thực Thông tin xác thực mặc định của ứng dụng

Xác thực môi trường của bạn để các thư viện ứng dụng Python có thể truy cập vào Vertex AI và Cloud Storage cục bộ trong quá trình phát triển:

gcloud auth application-default login

3. Tạo máy chủ MCP bằng MCPServer và uv

Trong bước này, bạn sẽ khởi tạo một dự án Python bằng uv và tạo một MCPServer hỗ trợ 4 chức năng của Google Cloud.

Khởi tạo dự án bằng uv

Tạo thư mục máy chủ và khởi động uv:

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

Sao chép mã vào tệp pyproject.toml:

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

Đồng bộ hoá các phần phụ thuộc bằng uv:

uv sync

Viết mã MCPServer

Tạo tệp triển khai máy chủ tại 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,
    )

Kiểm thử máy chủ MCP cục bộ

Bước 1: Khởi động máy chủ MCP

Trong thiết bị đầu cuối chính, hãy khởi động máy chủ bằng uv:

uv run python -m src.mcp_server.server

Bạn sẽ thấy nhật ký khởi động xác nhận rằng máy chủ HTTP Streamable đang theo dõi trên cổng 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)

Giữ cho cửa sổ dòng lệnh này luôn mở và chạy.

Bước 2: Xác minh điểm cuối HTTP có thể truyền phát trực tuyến bằng curl

Trong MCP 2.0 (MCP Spec 2026-07-28), cái bắt tay initialize có trạng thái và tiêu đề Mcp-Session-Id được thay thế bằng các yêu cầu không trạng thái. Bạn có thể gọi tools/list trực tiếp bằng cách truyền các tiêu đề MCP-Protocol-Version và Mcp-Method cùng với siêu dữ liệu ứng dụng trong params._meta.

Mở cửa sổ dòng lệnh thứ hai rồi gửi yêu cầu HTTP POST có thể truyền trực tuyến:

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 sẽ phản hồi bằng HTTP/1.1 200 OK và trả về trực tiếp kết quả JSON-RPC tools/list:

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",...}]}}

Bước 3: Chạy MCP Test Client

Để kiểm thử việc khám phá và thực thi các công cụ trên máy chủ cục bộ qua HTTP có thể truyền trực tuyến, hãy tạo một tập lệnh kiểm thử máy khách 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())

Chạy tập lệnh ứng dụng kiểm thử bằng uv:

uv run python src/mcp_server/test_client.py

Bạn sẽ thấy kết quả minh hoạ việc kết nối, khám phá và thực thi công cụ thành công:

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

Sau khi xác minh, hãy nhấn CTRL+C trong thiết bị đầu cuối chính để dừng máy chủ cục bộ.

4. Chứa máy chủ MCP

Để triển khai máy chủ MCP cho Cloud Run và GKE Autopilot, hãy đóng gói máy chủ vào một hình ảnh vùng chứa tối thiểu bằng cách sử dụng tệp Dockerfile nhiều giai đoạn do uv cung cấp.

Tạo Dockerfile

Trong 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"]

Tạo và chuyển hình ảnh vào Artifact Registry

Tạo một kho lưu trữ Artifact Registry:

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

Cấp các quyền IAM cần thiết cho tài khoản người dùng và tài khoản dịch vụ Compute Engine mặc định để Cloud Build có thể dàn dựng các nguồn, ghi nhật ký và đẩy hình ảnh vào 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:compute@developer.gserviceaccount.com" \
    --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"

Gửi bản dựng hình ảnh bằng 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}"

Sau khi hoàn tất, hình ảnh vùng chứa của bạn sẽ được lưu trữ an toàn trong Artifact Registry:

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

5. Triển khai lên Cloud Run bằng IAM và HTTPS

Cloud Run cung cấp một môi trường không máy chủ được quản lý toàn diện với tính năng tự động chấm dứt chứng chỉ HTTPS / SSL và kiểm soát quyền truy cập Cloud IAM chi tiết.

Tạo tài khoản dịch vụ chuyên dụng

Tạo Tài khoản dịch vụ Google có đặc quyền tối thiểu cho 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"

Triển khai dịch vụ lên Cloud Run

Triển khai vùng chứa vào Cloud Run bằng tính năng xác thực IAM bắt buộc (--no-allow-unauthenticated) và SSL được quản lý mặc định:

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

Truy xuất URL HTTPS:

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

Xác minh tính năng bảo mật điểm cuối

Việc cố gắng gửi một yêu cầu trái phép đến điểm cuối HTTP Streamable sẽ trả về 403 Forbidden:

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

Tạo mã thông báo nhận dạng OIDC bằng gcloud để xác minh thông tin liên lạc được uỷ quyền:

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",...}]}}

Kiểm thử việc thực thi công cụ trực tiếp: Cloud Storage Inspector

Giờ đây, khi máy chủ MCP từ xa đã được xác thực và phản hồi, hãy kiểm thử việc thực thi công cụ gcs_bucket_inspector đối với cơ sở hạ tầng của Google Cloud.

Bước 1: Tạo một Thùng lưu trữ đám mây kiểm thử

Tạo một nhóm kiểm thử và tải một tệp mẫu lên:

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"

Bước 2: Tạo Remote GCS Tool Test Client

Tạo một tập lệnh ứng dụng kiểm thử có tên là src/mcp_server/test_gcs_tool.py để xác thực với Cloud Run và gọi công cụ gcs_bucket_inspector:

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())

Bước 3: Chạy Remote GCS Test Client

Chạy kịch bản kiểm tra bằng uv:

uv run python src/mcp_server/test_gcs_tool.py

Bạn sẽ thấy siêu dữ liệu đối tượng trực tiếp được trả về từ máy chủ MCP Cloud Run:

[*] 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. Triển khai đến GKE Autopilot bằng Workload Identity và TLS

Đối với khối lượng công việc Kubernetes, chế độ Tự vận hành của GKE quản lý việc cấp phát nút trong khi Workload Identity loại bỏ các khoá tài khoản dịch vụ tĩnh.

Cung cấp cụm Autopilot GKE

Cung cấp một cụm GKE Autopilot:

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

Thiết lập Workload Identity

Tạo Tài khoản dịch vụ Google (GSA) và Tài khoản dịch vụ Kubernetes (KSA), sau đó liên kết các tài khoản này bằng 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}"

Áp dụng API Triển khai và Cổng Kubernetes bằng TLS

Bước 1: Đặt trước IP tĩnh và cấp chứng chỉ SSL do Google quản lý bằng nip.io

Dự trữ một địa chỉ IP ngoài toàn cầu và tận dụng dịch vụ DNS ký tự đại diện nip.io (..nip.io) để thiết lập một tên miền công khai hợp lệ (MCP_DOMAIN) trước khi áp dụng các tệp kê khai Kubernetes:

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

Bạn không cần đợi chứng chỉ SSL hoàn tất việc cung cấp trước khi tiếp tục. Trên thực tế, các chứng chỉ do Google quản lý vẫn ở trạng thái PROVISIONING cho đến khi được đính kèm vào Bộ cân bằng tải cổng trong Bước 3. Tiến hành ngay các bước tiếp theo.

Bước 2: Tạo tệp kê khai triển khai và dịch vụ

Tạo deployment.yaml chứa các định nghĩa về việc Triển khai và Dịch vụ nội bộ. Vì MCP 2.0 (MCP Spec 2026-07-28) không trạng thái, nên Service Kubernetes không yêu cầu mối liên kết phiên IP của máy khách:

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

Thay thế MCP_DOMAIN và PROJECT_ID rồi áp dụng quy trình triển khai:

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

Bước 3: Tạo tệp kê khai Gateway API, HealthCheckPolicy và GCPBackendPolicy

Tạo gateway.yaml chứa Cổng, HTTPRoute, HealthCheckPolicy và GCPBackendPolicy:

  • HealthCheckPolicy: Định cấu hình Trình cân bằng tải của Google Cloud để kiểm tra /healthz trên cổng 8080.
  • GCPBackendPolicy (Backend Timeout): Đặt timeoutSec: 300 để phù hợp với thời gian chờ đọc 300 giây của MCP SDK phiên bản 2 cho các luồng HTTP / SSE có thể truyền trực tuyến (Cổng GKE mặc định là 30 giây nếu bị bỏ qua).
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

Áp dụng Gateway, HTTPRoute, HealthCheckPolicy và GCPBackendPolicy:

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

Bước 4: Xác minh việc triển khai và kiểm thử máy chủ MCP bằng tính năng chuyển tiếp cổng

Vì chứng chỉ SSL do Google quản lý và Bộ cân bằng tải ứng dụng Google Cloud bên ngoài mất từ 5 đến 15 phút để cung cấp và thiết lập định tuyến DNS, nên bạn có thể kiểm thử ngay các nhóm GKE đang chạy bằng kubectl port-forward.

Trước tiên, hãy kiểm tra để đảm bảo các pod và Gateway đang hoạt động:

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

Tiếp theo, hãy kiểm thử dịch vụ GKE đang hoạt động cục bộ bằng cách chuyển tiếp cổng:

  1. Trong thiết bị đầu cuối, hãy chuyển tiếp cổng cục bộ 8080 đến dịch vụ ClusterIP của GKE:
kubectl port-forward svc/mcp-server-service 8080:80
  1. Trong một thiết bị đầu cuối thứ hai, hãy tạo một tập lệnh ứng dụng kiểm thử có tên là src/mcp_server/test_vertex_tool.py để gọi công cụ vertex_ai_generate_content trên GKE bằng cách sử dụng 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))
  1. Chạy tập lệnh kiểm thử trên phiên bản được chuyển tiếp cổng cục bộ:
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.

Điều này xác nhận rằng các pod GKE hoạt động bình thường, Workload Identity đang xác thực thành công với Vertex AI mà không cần thông tin đăng nhập tĩnh và hoạt động truyền tải HTTP có thể truyền trực tuyến đang hoạt động như mong đợi!

Bước 5: Xác minh điểm cuối cổng HTTPS công khai

Kiểm tra trạng thái cấp chứng chỉ bằng cách:

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

Sau khi chứng chỉ là ACTIVE, hãy kiểm thử điểm cuối HTTPS công khai bằng ứng dụng kiểm thử Python có cờ --host:

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. Tích hợp máy chủ MCP với Nền tảng tác nhân của Google Cloud

Giờ đây, khi MCPServer được triển khai an toàn đến các điểm cuối HTTPS trên Cloud Run và GKE Autopilot, hãy đăng ký và khám phá các công cụ MCP của bạn bằng Nền tảng tác nhân của Google Cloud (Sổ đăng ký tác nhân) để các tác nhân doanh nghiệp và mô hình AI có thể khám phá và gọi chúng một cách linh hoạt.

1. Đăng ký Máy chủ MCP Cloud Run tuỳ chỉnh vào Nền tảng tác nhân và Kiểm thử bằng tính năng Khám phá dịch vụ

Bước 1: Trích xuất thông số kỹ thuật của công cụ (toolspec.json)

Để đăng ký một máy chủ MCP bên ngoài hoặc tuỳ chỉnh trong Agent Registry (Sổ đăng ký tác nhân), hãy truy vấn tools/list trên máy chủ MCP 2.0 không trạng thái đang hoạt động, xoá các trường _meta ở cấp công cụ và lưu kết quả vào toolspec.json trong một quy trình duy nhất:

# 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

Bước 2: Đăng ký Dịch vụ trong Sổ đăng ký tác nhân

Sử dụng gcloud agent-registry services create để lập danh mục máy chủ MCP:

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"

Xác minh rằng bạn đã đăng ký dịch vụ thành công:

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

Bước 3: Tạo và chạy ứng dụng kiểm thử Khám phá dịch vụ

Tạo một tập lệnh Python có tên là src/mcp_server/test_agent_platform.py để phân giải động điểm cuối từ danh mục mcp-servers của Agent Registry, xác thực bằng Google Cloud IAM và gọi một công cụ bằng httpx2 và 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())

Thực thi kịch bản kiểm tra:

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. Tự động phát hiện và đăng ký máy chủ MCP bằng GKE

Google Kubernetes Engine (GKE) cung cấp tính năng tích hợp tự động với Agent Registry. Bằng cách gắn nhãn và chú thích tệp kê khai Triển khai GKE, GKE sẽ tự động thực hiện một quy trình quét tự kiểm tra đối với máy chủ MCP, đăng ký các công cụ vào danh mục và chiếu dịch vụ lên phía người dùng mà không cần tạo hoặc tải toolspec.json lên theo cách thủ công.

Bước 1: Cách hoạt động của tính năng Tự động phát hiện GKE

Khi deployment.yaml của bạn được áp dụng trong phần trước, các cấu hình sau đây sẽ bật tính năng tự động phát hiện:

  • registry.gke.io/functional-type: "MCP_SERVER": Thông báo cho bộ điều khiển cụm GKE để đăng ký việc triển khai vào Google Cloud Agent Registry.
  • modelcontextprotocol.info/urls: Cung cấp điểm cuối Cổng HTTPS bên ngoài (https://${MCP_DOMAIN}/mcp) để kiểm tra bộ điều khiển và định tuyến người dùng.
  • modelcontextprotocol.info/capabilities: Khai báo điểm cuối truyền tải HTTP (/mcp).
  • iam.gke.io/spiffe-identity-type: agent-identity: Định cấu hình Workload Identity cho giao tiếp dạng tác nhân.

Bước 2: Xác minh tính năng Tự động đăng ký GKE trong Agent Registry

Xác minh rằng GKE đã tự động phát hiện và đăng ký máy chủ MCP của bạn vào danh mục mcp-servers theo khu vực:

# 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

Bước 3: Kiểm thử Máy chủ MCP GKE bằng tính năng Khám phá dịch vụ

Kiểm thử việc triển khai MCP GKE bằng kịch bản khám phá thông tin dịch vụ dựa trên tên máy chủ đã đăng ký tự động trong 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. Dọn dẹp tài nguyên

Để tránh phát sinh phí cho tài khoản Google Cloud của bạn đối với các tài nguyên được dùng trong lớp học lập trình này, hãy xoá dịch vụ Cloud Run, cụm GKE, tài khoản dịch vụ và kho lưu trữ vùng chứa.

Xoá dịch vụ Cloud Run

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

Xoá cụm Autopilot GKE

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

Xoá tài khoản dịch vụ và các liên kết IAM

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

Xoá kho lưu trữ Artifact Registry

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

Xoá dịch vụ tuỳ chỉnh của sổ đăng ký tác nhân

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

Xoá bộ chứa Cloud Storage

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

Xoá IP tĩnh và chứng chỉ SSL

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

Xác minh rằng quá trình dọn dẹp sau khi xoá đã hoàn tất:

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

9. Xin chúc mừng

Xin chúc mừng! Bạn đã tạo, bảo mật và triển khai thành công một Máy chủ MCP 2.0 bằng MCPServer từ MCP Python SDK và uv trên Google Cloud!

Nội dung bạn đã đề cập

  • Đã tạo MCPServer hỗ trợ MCP Spec (28/7/2026) qua HTTP có thể truyền phát trực tuyến không trạng thái.
  • Xây dựng 4 công cụ sản xuất của Google Cloud tích hợp Vertex AI Gemini, Cloud Storage, Cloud Logging và Resource Health.
  • Triển khai vùng chứa bảo mật trên Cloud Run với chế độ xác thực IAM và SSL/TLS bắt buộc.
  • Đã định cấu hình phương thức xác thực không cần khoá bí mật trên GKE Autopilot bằng Workload Identity và Kubernetes Gateway API có TLS.
  • Đã đăng ký và khám phá các điểm cuối của máy chủ MCP bằng Nền tảng tác nhân Gemini Enterprise (Sổ đăng ký tác nhân) bằng cách sử dụng tiêu đề uỷ quyền OIDC.

Các bước tiếp theo