Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Kompilowanie, zabezpieczanie i wdrażanie serwera MCP w Google Cloud

1. Zanim zaczniesz

Model Context Protocol (MCP) to otwarty standard, który umożliwia modelom i agentom AI bezpieczny dostęp do narzędzi, baz danych i kontekstu przedsiębiorstwa. Od momentu wprowadzenia w 2024 roku protokół ten jest powszechnie stosowany przez dostawców usług w chmurze i modeli LLM. Najnowsza specyfikacja MCP Spec 2026-07-28 (MCP 2.0) definiuje architekturę bezstanową, uproszczone transporty i ścisłe typowanie wyników, zachowując przy tym zgodność wsteczną z wcześniejszymi wersjami.

Oficjalny pakiet MCP Python SDK (mcp>=2.0.0) udostępnia MCPServer (mcp.server.mcpserver.MCPServer), który zastępuje FastMCP w MCP 2.0 jako wydajny i przyjazny dla programistów framework do tworzenia serwerów MCP gotowych do wdrożenia w środowisku produkcyjnym, zgodnych z nowoczesną specyfikacją MCP (28.07.2026) z przesyłaniem strumieniowym HTTP i transportem Server-Sent Events (SSE) przez SSL/TLS.

W tym ćwiczeniu utworzysz serwer MCP klasy produkcyjnej przy użyciu MCPServer z pakietu MCP 2.0 Python SDK i uv zarządzania zależnościami. Wyposażysz serwer MCP w 4 narzędzia Google Cloud (wywoływanie Vertex AI Gemini, sprawdzanie Google Cloud Storage, zapisywanie logów kontrolnych w Cloud Logging i sprawdzanie stanu zasobów Google Cloud). Następnie skonteneryzujesz serwer i wdrożysz go w 2 środowiskach wykonawczych Google Cloud: Cloud Run i Google Kubernetes Engine (GKE) Autopilot. Zarejestrujesz też serwer MCP i będziesz go używać na platformie agentów Gemini Enterprise.

Najważniejsze informacje o specyfikacji MCP z 28 lipca 2026 r. i pakiecie SDK w wersji 2.0:

MCPServer Zastępuje FastMCP: w oficjalnym pakiecie mcp>=2.0.0 Python SDK funkcja MCPServer (from mcp.server.mcpserver import MCPServer) zastępuje funkcję FastMCP, zachowując znaną API opartą na dekoratorach (@mcp.tool, @mcp.custom_route).
Architektura bezstanowa: eliminuje uzgadnianie stanu połączenia (initialize/initialized). Każde żądanie zawiera w nagłówkach i _meta wersję protokołu i możliwości klienta.
Punkt końcowy wykrywania: implementuje server/discover do negocjowania możliwości i wersji.
Streamable Transport: uproszczony transport HTTP/SSE, który eliminuje nagłówki Mcp-Session-Id dla każdego połączenia.
Typowanie wyników: wszystkie wyniki wykonania narzędzia zawierają obowiązkowy typ resultType ("complete" lub "input_required").

Jakie zadania wykonasz

Utwórz MCPServer za pomocą 4 narzędzi Google Cloud, używając Pythona w wersji 3.12 lub nowszej i uv zgodnego ze specyfikacją MCP z 28 lipca 2026 r..
Konteneryzacja serwera MCP za pomocą wieloetapowego procesu tworzenia Dockera.
Zabezpiecz i wdroż serwer MCP w Cloud Run z wymuszonym uwierzytelnianiem IAM i protokołem SSL/TLS.
Zabezpiecz i wdroż serwer MCP w GKE Autopilot za pomocą Workload Identity i interfejsu Kubernetes Gateway API z TLS.
Zarejestruj bezpieczny punkt końcowy serwera MCP w Gemini Enterprise Agent Platform za pomocą nagłówków tokena nośnika OIDC.

Czego potrzebujesz

projekt Google Cloud z włączonymi płatnościami;
Zainstalowany i skonfigurowany pakiet SDK Google Cloud (gcloud CLI).
Zainstalowany Python 3.12 lub nowszy oraz menedżer pakietów uv.
Zainstalowano docker.
zainstalowane narzędzie wiersza poleceń kubectl.

2. Konfigurowanie środowiska Google Cloud

Przed utworzeniem zasobów uwierzytelnij środowisko i włącz niezbędne interfejsy Google Cloud API.

Uwierzytelnianie gcloud CLI

Zaloguj się na konto Google Cloud:

gcloud auth login

Ustaw identyfikator aktywnego projektu Google Cloud:

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

Włączanie usług Google Cloud

Włącz wszystkie wymagane interfejsy API dla Cloud Run, GKE, Vertex AI, Artifact Registry, Cloud Build, Cloud Logging, Storage i 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}"

Sprawdź, czy interfejsy API zostały włączone:

Operation "operations/..." finished successfully.

Uwierzytelnianie domyślnego uwierzytelniania aplikacji

Uwierzytelnij środowisko, aby biblioteki klienta Pythona mogły lokalnie uzyskiwać dostęp do Vertex AI i Cloud Storage podczas programowania:

gcloud auth application-default login

3. Tworzenie serwera MCP za pomocą MCPServer i uv

W tym kroku zainicjujesz projekt w Pythonie za pomocą uv i utworzysz MCPServer obsługujący 4 funkcje Google Cloud.

Inicjowanie projektu za pomocą uv

Utwórz katalog serwera i zainicjuj go: uv

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

Skopiuj kod do pliku 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"]

Synchronizuj zależności za pomocą uv:

uv sync

Pisanie kodu MCPServer

Utwórz plik implementacji serwera w lokalizacji 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,
    )

Testowanie serwera MCP lokalnie

Krok 1. Uruchom serwer MCP

W terminalu głównym uruchom serwer za pomocą polecenia uv:

uv run python -m src.mcp_server.server

Powinny się pojawić logi uruchamiania potwierdzające, że serwer HTTP Streamable nasłuchuje na porcie 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)

Pozostaw ten terminal otwarty i uruchomiony.

Krok 2. Sprawdź punkt końcowy HTTP z możliwością przesyłania strumieniowego za pomocą narzędzia curl

W MCP 2.0 (MCP Spec 2026-07-28) stanowe uzgadnianie initialize i nagłówek Mcp-Session-Id są zastępowane przez żądania bezstanowe. Możesz wywołać tools/list bezpośrednio, przekazując nagłówki MCP-Protocol-Version i Mcp-Method wraz z metadanymi klienta w params._meta.

Otwórz drugie okno terminala i wyślij żądanie HTTP POST z możliwością przesyłania strumieniowego:

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 odpowie HTTP/1.1 200 OK i zwróci bezpośrednio wynik tools/list JSON-RPC:

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

Krok 3. Uruchom klienta testowego MCP

Aby przetestować wykrywanie i wykonywanie narzędzi na serwerze lokalnym za pomocą protokołu Streamable HTTP, utwórz skrypt klienta testowego 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())

Uruchom skrypt klienta testowego za pomocą polecenia uv:

uv run python src/mcp_server/test_client.py

Powinny się wyświetlić dane wyjściowe potwierdzające nawiązanie połączenia, wykrycie narzędzia i jego wykonanie:

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

Po zweryfikowaniu naciśnij CTRL+C w terminalu głównym, aby zatrzymać serwer lokalny.

4. Konteneryzacja serwera MCP

Aby wdrożyć serwer MCP w Cloud Run i GKE Autopilot, spakuj go do minimalnego obrazu kontenera za pomocą wieloetapowego pliku Dockerfile opartego na uv.

Tworzenie pliku Dockerfile

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

Tworzenie obrazu i przesyłanie go do Artifact Registry

Utwórz repozytorium Artifact Registry:

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

Przyznaj wymagane uprawnienia IAM kontu użytkownika i domyślnemu kontu usługi Compute Engine, aby Cloud Build mógł przygotowywać źródła, zapisywać logi i przesyłać obrazy do 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"

Prześlij kompilację obrazu za pomocą 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}"

Po zakończeniu obraz kontenera jest bezpiecznie przechowywany w Artifact Registry:

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

5. Wdrażanie w Cloud Run z IAM i HTTPS

Cloud Run zapewnia w pełni zarządzane środowisko bezserwerowe z automatycznym zakończeniem certyfikatu HTTPS / SSL i szczegółową kontrolą dostępu Cloud IAM.

Utwórz dedykowane konto usługi

Utwórz konto usługi Google o jak najmniejszych uprawnieniach dla 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"

Wdrażanie usługi w Cloud Run

Wdróż kontener w Cloud Run z wymuszonym uwierzytelnianiem uprawnień (--no-allow-unauthenticated) i domyślnym zarządzanym protokołem 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}"

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

Weryfikowanie zabezpieczeń punktów końcowych

Próba wysłania nieautoryzowanego żądania do punktu końcowego HTTP Streamable spowoduje zwrócenie kodu 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

Wygeneruj token identyfikacji OIDC za pomocą gcloud, aby potwierdzić autoryzowaną komunikację:

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

Testowanie wykonania narzędzia na żywo: narzędzie Cloud Storage Inspector

Teraz, gdy zdalny serwer MCP jest uwierzytelniony i odpowiada, przetestuj wykonanie narzędzia gcs_bucket_inspector w infrastrukturze w chmurze Google.

Krok 1. Utwórz testowy zasobnik Cloud Storage

Utwórz zasobnik testowy i prześlij przykładowy plik:

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"

Krok 2. Utwórz klienta testowego narzędzia Remote GCS Tool

Utwórz skrypt klienta testowego o nazwie src/mcp_server/test_gcs_tool.py, aby uwierzytelnić się w Cloud Run i wywołać narzędzie 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())

Krok 3. Uruchom zdalnego klienta testowego GCS

Uruchom scenariusz testowania za pomocą polecenia uv:

uv run python src/mcp_server/test_gcs_tool.py

Powinny pojawić się metadane obiektu na żywo zwrócone przez serwer 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. Wdrażanie w Autopilocie w GKE za pomocą Workload Identity i TLS

W przypadku zadań Kubernetes Autopilot w GKE zarządza udostępnianiem węzłów, a Workload Identity eliminuje statyczne klucze kont usługi.

Aprowizowanie klastra GKE w trybie Autopilota

Udostępnij klaster GKE w trybie Autopilota:

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

Konfigurowanie Workload Identity

Utwórz konto usługi Google (GSA) i konto usługi Kubernetes (KSA), a następnie połącz je za pomocą 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}"

Stosowanie wdrożenia Kubernetes i interfejsu Gateway API z TLS

Krok 1. Zarezerwuj statyczny adres IP i udostępnij certyfikat SSL zarządzany przez Google za pomocą nip.io

Zarezerwuj globalny zewnętrzny adres IP i skorzystaj z usługi DNS z symbolem wieloznacznym nip.io (..nip.io), aby utworzyć prawidłową publiczną nazwę domeny (MCP_DOMAIN) przed zastosowaniem manifestów 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}"

Nie musisz czekać na zakończenie obsługi administracyjnej certyfikatu SSL, aby kontynuować. Certyfikaty zarządzane przez Google pozostają w stanie PROVISIONING, dopóki nie zostaną dołączone do usługi równoważenia obciążenia bramy w kroku 3. Od razu przejdź do następnych kroków.

Krok 2. Utwórz plik manifestu wdrożenia i usługi

Utwórz deployment.yaml zawierający definicje wdrożenia i usługi wewnętrznej. Ponieważ MCP 2.0 (MCP Spec 2026-07-28) jest bezstanowy, Kubernetes Service nie wymaga koligacji sesji z adresem IP klienta:

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

Zastąp MCP_DOMAIN i PROJECT_ID i zastosuj wdrożenie:

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

Krok 3. Utwórz plik manifestu interfejsu Gateway API, HealthCheckPolicy i GCPBackendPolicy

Utwórz gateway.yaml zawierający bramę, trasę HTTP, HealthCheckPolicy i GCPBackendPolicy:

HealthCheckPolicy: konfiguruje system równoważenia obciążenia Google Cloud do sondowania /healthz na porcie 8080.
GCPBackendPolicy (Backend Timeout): ustawia wartość timeoutSec: 300, aby była zgodna z 300-sekundowym czasem oczekiwania na odczyt w przypadku strumieni HTTP / SSE z możliwością przesyłania strumieniowego w pakiecie MCP SDK w wersji 2 (brama GKE domyślnie ma 30 sekund, jeśli ten parametr zostanie pominięty).

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

Zastosuj Gateway, HTTPRoute, HealthCheckPolicy i GCPBackendPolicy:

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

Krok 4. Sprawdź wdrożenie i przetestuj serwer MCP za pomocą przekierowania portów

Ponieważ certyfikaty SSL zarządzane przez Google i zewnętrzne systemy równoważenia obciążenia aplikacji Google Cloud potrzebują 5–15 minut na udostępnienie i ustanowienie routingu DNS, możesz od razu przetestować działające pody GKE za pomocą kubectl port-forward.

Najpierw sprawdź, czy pody i brama są uruchomione:

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

Następnie przetestuj aktywną usługę GKE lokalnie za pomocą przekierowania portów:

W terminalu przekieruj port lokalny 8080 do usługi ClusterIP GKE:

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

W drugim terminalu utwórz skrypt klienta testowego o nazwie src/mcp_server/test_vertex_tool.py, aby wywołać narzędzie vertex_ai_generate_content w GKE za pomocą 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))

Uruchom scenariusz testowania na lokalnej instancji przekierowanej na port:

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.

Potwierdza to, że pody GKE są w dobrym stanie, Workload Identity przeprowadza uwierzytelnianie w Vertex AI bez statycznych danych logowania, a transport HTTP z możliwością przesyłania strumieniowego działa zgodnie z oczekiwaniami.

Krok 5. Sprawdź publiczny punkt końcowy bramy HTTPS

Sprawdź stan udostępniania certyfikatu za pomocą tego polecenia:

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

Gdy certyfikat będzie ACTIVE, przetestuj publiczny punkt końcowy HTTPS za pomocą klienta testowego w Pythonie z użyciem flagi --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. Integrowanie serwera MCP z platformą agentów Google Cloud

Teraz, gdy MCPServer jest bezpiecznie wdrożony w punktach końcowych HTTPS w Cloud Run i GKE Autopilot, zarejestruj i wykryj narzędzia MCP za pomocą Google Cloud Agent Platform (rejestru agentów), aby agenty klasy korporacyjnej i modele AI mogły je dynamicznie wykrywać i wywoływać.

1. Rejestrowanie niestandardowego serwera MCP Cloud Run na platformie Agent Platform i testowanie za pomocą usługi wykrywania usług

Krok 1. Wyodrębnij specyfikacje narzędzia (`toolspec.json`)

Aby zarejestrować zewnętrzny lub niestandardowy serwer MCP w Agent Registry, wyślij zapytanie tools/list na aktywnym serwerze MCP 2.0 bez stanu, usuń pola _meta na poziomie narzędzia i zapisz wynik w toolspec.json w ramach jednego potoku:

# 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

Krok 2. Zarejestruj usługę w Agent Registry

Użyj gcloud agent-registry services create, aby skatalogować serwer 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"

Sprawdź, czy usługa została zarejestrowana:

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

Krok 3. Utwórz i uruchom testowego klienta odkrywania usług

Utwórz skrypt Pythona o nazwie src/mcp_server/test_agent_platform.py, który dynamicznie rozwiązuje punkt końcowy z katalogu mcp-servers Agent Registry, uwierzytelnia się w Google Cloud IAM i wywołuje narzędzie za pomocą httpx2 i 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())

Uruchom scenariusz testowania:

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. Automatyczne wykrywanie i rejestracja serwera MCP w GKE

Google Kubernetes Engine (GKE) zapewnia automatyczną integrację z Agent Registry. Dzięki etykietowaniu i dodawaniu adnotacji do manifestu wdrożenia GKE usługa GKE automatycznie przeprowadza skanowanie introspekcyjne serwera MCP, rejestruje narzędzia w katalogu i projektuje usługę po stronie konsumenta bez konieczności ręcznego generowania ani przesyłania pliku toolspec.json.

Krok 1. Jak działa automatyczne wykrywanie GKE

Gdy w poprzedniej sekcji zastosowano deployment.yaml, automatyczne wykrywanie zostało włączone przez te konfiguracje:

registry.gke.io/functional-type: "MCP_SERVER": informuje kontroler klastra GKE o zarejestrowaniu wdrożenia w rejestrze agentów Google Cloud.
modelcontextprotocol.info/urls: udostępnia zewnętrzny punkt końcowy bramy HTTPS (https://${MCP_DOMAIN}/mcp) na potrzeby introspekcji kontrolera i kierowania konsumentów.
modelcontextprotocol.info/capabilities: deklaruje punkt końcowy transportu HTTP (/mcp).
iam.gke.io/spiffe-identity-type: agent-identity: konfiguruje Workload Identity na potrzeby komunikacji agenta.

Krok 2. Sprawdź automatyczną rejestrację GKE w Agent Registry

Sprawdź, czy GKE automatycznie wykrył i zarejestrował serwer MCP w katalogu regionalnym mcp-servers:

# 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

Krok 3. Testowanie serwera MCP GKE za pomocą funkcji Service Discovery

Przetestuj wdrożenie MCP w GKE za pomocą skryptu wykrywania usług na podstawie automatycznie zarejestrowanej nazwy serwera w 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. Zwalnianie miejsca

Aby uniknąć obciążenia konta Google Cloud opłatami za zasoby zużyte w tym ćwiczeniu, usuń usługę Cloud Run, klaster GKE, konta usługi i repozytorium kontenerów.

Usuwanie usługi Cloud Run

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

Usuwanie klastra GKE w trybie Autopilota

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

Usuwanie kont usługi i powiązań uprawnień

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

Usuwanie repozytorium Artifact Registry

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

Usuwanie usługi niestandardowej rejestru agentów

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

Usuwanie zasobnika Cloud Storage

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

Usuwanie statycznego adresu IP i certyfikatu 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}"

Sprawdź, czy czyszczenie po usunięciu zostało zakończone:

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

9. Gratulacje

Gratulacje! Udało Ci się skompilować, zabezpieczyć i wdrożyć serwer MCP 2.0 za pomocą MCPServer z pakietu MCP Python SDK i uv w Google Cloud.

Omówione zagadnienia

Zbudowano MCPServer obsługujący specyfikację MCP (28.07.2026) za pomocą bezstanowego protokołu HTTP z możliwością przesyłania strumieniowego.
Utworzono 4 narzędzia produkcyjne Google Cloud integrujące Vertex AI Gemini, Cloud Storage, Cloud Logging i Resource Health.
Zabezpieczone wdrożenia kontenerów w Cloud Run z wymuszonym uwierzytelnianiem uprawnień i SSL/TLS.
Skonfigurowano uwierzytelnianie bez użycia kluczy tajnych w GKE Autopilot za pomocą Workload Identity i interfejsu Kubernetes Gateway API z TLS.
Zarejestrowane i wykryte punkty końcowe serwera MCP za pomocą Gemini Enterprise Agent Platform (Agent Registry) z użyciem nagłówków autoryzacji OIDC.

Dalsze kroki

Więcej informacji i definicje promptów znajdziesz w specyfikacji protokołu Model Context Protocol.
Dowiedz się więcej o pakiecie SDK MCP dla Pythona.
Szczegółowe informacje o bezpieczeństwie Google Cloud Run i Workload Identity w GKE.