Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

MCP-Server in Google Cloud erstellen, schützen und bereitstellen

1. Hinweis

Das Model Context Protocol (MCP) ist ein offener Standard, der es KI-Modellen und ‑Agenten ermöglicht, sicher auf Tools, Datenbanken und Unternehmenskontext zuzugreifen. Seit seiner Einführung im Jahr 2024 wurde das Protokoll von Cloud- und LLM-Anbietern weitgehend übernommen. Die neueste Spezifikation MCP Spec 2026-07-28 (MCP 2.0) definiert eine zustandslose Architektur, vereinfachte Transporte und eine strenge Ergebnistypisierung, bleibt aber abwärtskompatibel mit früheren Versionen.

Das offizielle MCP Python SDK (mcp>=2.0.0) bietet MCPServer (mcp.server.mcpserver.MCPServer), das FastMCP in MCP 2.0 als leistungsstarkes, entwicklerfreundliches Framework zum Erstellen von produktionsreifen MCP-Servern ersetzt, die der modernen MCP-Spezifikation (28.07.2026) mit Streamable HTTP- und Server-Sent Events-Transports (SSE) über SSL/TLS entsprechen.

In diesem Codelab erstellen Sie einen MCP-Server für die Produktion mit MCPServer aus dem MCP 2.0 Python SDK und uv-Abhängigkeitsverwaltung. Sie statten Ihren MCP-Server mit vier Google Cloud-Tools aus (Vertex AI Gemini-Aufruf, Google Cloud Storage-Prüfung, Cloud Logging-Audit-Schreiben und Google Cloud-Ressourcenstatusprüfung). Anschließend containerisieren Sie den Server und stellen ihn in zwei Google Cloud-Laufzeitzielen bereit: Cloud Run und Google Kubernetes Engine (GKE) Autopilot. Außerdem registrieren und verwenden Sie den MCP-Server in der Gemini Enterprise Agent Platform.

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

MCPServer Ersetzt FastMCP: Im offiziellen mcp>=2.0.0 Python SDK ersetzt MCPServer (from mcp.server.mcpserver import MCPServer) FastMCP, wobei die vertraute dekoratorgesteuerte API (@mcp.tool, @mcp.custom_route) beibehalten wird.
Zustandslose Architektur: Es sind keine Handshakes zur Initialisierung zustandsbehafteter Verbindungen (initialize/initialized) erforderlich. Jede Anfrage enthält die Protokollversion und die Clientfunktionen in Headern und _meta.
Endpunkt der Erkennung: Implementiert server/discover für die Aushandlung von Funktionen und Versionen.
Streamable Transport: Vereinfachter HTTP-/SSE-Transport, bei dem die Mcp-Session-Id-Header pro Verbindung entfallen.
Ergebnistypisierung: Alle Ergebnisse der Tool-Ausführung enthalten ein obligatorisches resultType ("complete" oder "input_required").

Aufgaben

Erstelle eine MCPServer mit vier Google Cloud-Tools mit Python 3.12+ und uv gemäß MCP Spec 2026-07-28.
Containerisieren Sie den MCP-Server mit einem mehrstufigen Docker-Build.
Sichern Sie den MCP-Server und stellen Sie ihn in Cloud Run mit erzwungener IAM-Authentifizierung und SSL/TLS bereit.
Sichern Sie den MCP-Server und stellen Sie ihn mit Workload Identity und der Kubernetes Gateway API mit TLS in GKE Autopilot bereit.
Registrieren Sie den sicheren MCP-Serverendpunkt mit Gemini Enterprise Agent Platform mithilfe von OIDC-Bearertoken-Headern.

Voraussetzungen

Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.
Das Google Cloud SDK (gcloud CLI) ist installiert und konfiguriert.
Python 3.12 oder höher und der uv-Paketmanager sind installiert.
docker wurde installiert.
kubectl-Befehlszeilentool installiert

2. Google Cloud-Umgebung einrichten

Bevor Sie Ressourcen erstellen, müssen Sie Ihre Umgebung authentifizieren und die erforderlichen Google Cloud APIs aktivieren.

gcloud CLI authentifizieren

Melden Sie sich in Ihrem Google Cloud-Konto an:

gcloud auth login

Legen Sie Ihre aktive Google Cloud-Projekt-ID fest:

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

Google Cloud-Dienste aktivieren

Aktivieren Sie alle erforderlichen APIs für Cloud Run, GKE, Vertex AI, Artifact Registry, Cloud Build, Cloud Logging, Storage und 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}"

Prüfen Sie, ob die APIs erfolgreich aktiviert wurden:

Operation "operations/..." finished successfully.

Standardanmeldedaten für Anwendungen authentifizieren

Authentifizieren Sie Ihre Umgebung, damit Python-Clientbibliotheken während der Entwicklung lokal auf Vertex AI und Cloud Storage zugreifen können:

gcloud auth application-default login

3. MCP-Server mit MCPServer und uv erstellen

In diesem Schritt initialisieren Sie ein Python-Projekt mit uv und erstellen ein MCPServer, das vier Google Cloud-Funktionen unterstützt.

Projekt mit uv initialisieren

Erstellen Sie das Serververzeichnis und initialisieren Sie uv:

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

Kopieren Sie den Code in die Datei 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"]

Abhängigkeiten mit uv synchronisieren:

uv sync

MCPServer-Code schreiben

Erstellen Sie die Serverimplementierungsdatei unter 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,
    )

MCP-Server lokal testen

Schritt 1: MCP-Server starten

Starten Sie den Server in Ihrem primären Terminal mit uv:

uv run python -m src.mcp_server.server

Sie sollten Startprotokolle sehen, die bestätigen, dass der Streamable-HTTP-Server Port 8080 überwacht:

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)

Lassen Sie dieses Terminal geöffnet und aktiv.

Schritt 2: Streamable HTTP-Endpunkt mit curl überprüfen

In MCP 2.0 (MCP Spec 2026-07-28) werden der zustandsorientierte initialize-Handshake und der Mcp-Session-Id-Header durch zustandslose Anfragen ersetzt. Sie können tools/list direkt aufrufen, indem Sie die Header MCP-Protocol-Version und Mcp-Method zusammen mit den Clientmetadaten in params._meta übergeben.

Öffnen Sie ein zweites Terminalfenster und senden Sie eine Streamable-HTTP-POST-Anfrage:

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 antwortet mit HTTP/1.1 200 OK und gibt das JSON-RPC-Ergebnis tools/list direkt zurück:

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

Schritt 3: MCP-Testclient ausführen

Wenn Sie das Erkennen und Ausführen von Tools auf Ihrem lokalen Server über Streamable HTTP testen möchten, erstellen Sie ein Testclientskript 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())

Führen Sie das Testclient-Script mit uv aus:

uv run python src/mcp_server/test_client.py

Sie sollten eine Ausgabe sehen, die eine erfolgreiche Verbindung, die Erkennung von Tools und die Ausführung von Tools zeigt:

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

Drücken Sie nach der Bestätigung im primären Terminal CTRL+C, um den lokalen Server zu beenden.

4. MCP-Server in Container packen

Um den MCP-Server in Cloud Run und GKE Autopilot bereitzustellen, verpacken Sie den Server in einem minimalen Container-Image mit einem mehrstufigen Dockerfile, das von uv unterstützt wird.

Dockerfile erstellen

In mcp-server/Dockerfile:

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

WORKDIR /app
ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy

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

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

FROM python:3.12-slim-bookworm

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

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

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

Image erstellen und per Push in Artifact Registry übertragen

Erstellen Sie ein Artifact Registry-Repository:

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

Weisen Sie Ihrem Nutzerkonto und dem Compute Engine-Standarddienstkonto die erforderlichen IAM-Berechtigungen zu, damit Cloud Build Quellen bereitstellen, Logs schreiben und Images in Artifact Registry übertragen kann:

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"

Senden Sie den Image-Build mit 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}"

Nach Abschluss wird Ihr Container-Image sicher in Artifact Registry gespeichert:

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

5. In Cloud Run mit IAM und HTTPS bereitstellen

Cloud Run bietet eine vollständig verwaltete serverlose Umgebung mit automatischer HTTPS-/SSL-Zertifikatsbeendigung und detaillierter Cloud IAM-Zugriffssteuerung.

Dediziertes Dienstkonto erstellen

Erstellen Sie ein Google-Dienstkonto mit geringsten Berechtigungen für 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"

Dienst in Cloud Run bereitstellen

Stellen Sie den Container in Cloud Run mit erzwungener IAM-Authentifizierung (--no-allow-unauthenticated) und verwaltetem Standard-SSL bereit:

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

Rufen Sie die HTTPS-URL ab:

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

Endpunktsicherheit überprüfen

Bei einem nicht autorisierten Versuch, eine Anfrage an den Streamable-HTTP-Endpunkt zu senden, wird 403 Forbidden zurückgegeben:

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

Generieren Sie ein OIDC-ID-Token mit gcloud, um die autorisierte Kommunikation zu bestätigen:

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

Ausführung von Live-Tools testen: Cloud Storage Inspector

Nachdem der Remote-MCP-Server authentifiziert wurde und reagiert, testen Sie die Ausführung des gcs_bucket_inspector-Tools für die Google Cloud-Infrastruktur.

Schritt 1: Cloud Storage-Test-Bucket erstellen

Erstellen Sie einen Test-Bucket und laden Sie eine Beispieldatei hoch:

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"

Schritt 2: Remote GCS Tool Test Client erstellen

Erstellen Sie ein Testclientskript mit dem Namen src/mcp_server/test_gcs_tool.py, um sich bei Cloud Run zu authentifizieren und das Tool gcs_bucket_inspector aufzurufen:

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

Schritt 3: Remote GCS Test Client ausführen

Führen Sie das Testskript mit uv aus:

uv run python src/mcp_server/test_gcs_tool.py

Sie sollten Metadaten für Live-Objekte sehen, die vom Cloud Run-MCP-Server zurückgegeben werden:

[*] 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. Mit Workload Identity und TLS in GKE Autopilot bereitstellen

Bei Kubernetes-Arbeitslasten wird die Knotenbereitstellung von GKE Autopilot verwaltet, während Workload Identity statische Dienstkontoschlüssel überflüssig macht.

GKE Autopilot-Cluster bereitstellen

GKE Autopilot-Cluster bereitstellen:

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

Workload Identity einrichten

Erstellen Sie ein Google-Dienstkonto (GSA) und ein Kubernetes-Dienstkonto (KSA) und verknüpfen Sie sie dann mit 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}"

Kubernetes-Bereitstellungs- und Gateway API mit TLS anwenden

Schritt 1: Statische IP-Adresse reservieren und von Google verwaltetes SSL-Zertifikat mit nip.io bereitstellen

Reservieren Sie eine globale externe IP-Adresse und nutzen Sie den Wildcard-DNS-Dienst nip.io (..nip.io), um einen gültigen öffentlichen Domainnamen (MCP_DOMAIN) zu erstellen, bevor Sie die Kubernetes-Manifeste anwenden:

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

Sie müssen nicht warten, bis die Bereitstellung des SSL-Zertifikats abgeschlossen ist, bevor Sie fortfahren. Von Google verwaltete Zertifikate bleiben bis zum Anhängen an den Gateway-Load-Balancer in Schritt 3 im Status PROVISIONING. Fahren Sie sofort mit den nächsten Schritten fort.

Schritt 2: Deployment- und Dienstmanifest erstellen

Erstellen Sie deployment.yaml mit den Deployment- und internen Dienstdefinitionen. Da MCP 2.0 (MCP Spec 2026-07-28) zustandslos ist, ist für die Kubernetes-Service keine Client-IP-Sitzungsaffinität erforderlich:

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

Ersetzen Sie MCP_DOMAIN und PROJECT_ID und wenden Sie die Bereitstellung an:

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

Schritt 3: Manifest für Gateway API, HealthCheckPolicy und GCPBackendPolicy erstellen

Erstellen Sie gateway.yaml mit dem Gateway, der HTTPRoute, einem HealthCheckPolicy und einem GCPBackendPolicy:

HealthCheckPolicy: Konfiguriert den Google Cloud-Load Balancer, um /healthz auf Port 8080 zu prüfen.
GCPBackendPolicy (Backend-Zeitlimit): Legt timeoutSec: 300 so fest, dass es mit dem 300-Sekunden-Lesezeitlimit für Streamable HTTP-/SSE-Streams im MCP SDK v2 übereinstimmt. Wenn es ausgelassen wird, wird standardmäßig 30 Sekunden verwendet.

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

Wenden Sie das Gateway, die HTTPRoute, die HealthCheckPolicy und die GCPBackendPolicy an:

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

Schritt 4: Bereitstellung prüfen und MCP-Server mit Portweiterleitung testen

Da die Bereitstellung von von Google verwalteten SSL-Zertifikaten und externen Google Cloud Application Load Balancern sowie die Einrichtung des DNS-Routings 5 bis 15 Minuten dauern kann, können Sie die ausgeführten GKE-Pods sofort mit kubectl port-forward testen.

Prüfe zuerst, ob deine Pods und dein Gateway ausgeführt werden:

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

Testen Sie als Nächstes den aktiven GKE-Dienst lokal mit Portweiterleitung:

Leiten Sie in Ihrem Terminal den lokalen Port 8080 an den GKE ClusterIP-Dienst weiter:

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

Erstellen Sie in einem zweiten Terminal ein Testclientskript mit dem Namen src/mcp_server/test_vertex_tool.py, um das Tool vertex_ai_generate_content in GKE mit Workload Identity aufzurufen:

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

Führen Sie das Testscript für die lokale Instanz mit Portweiterleitung aus:

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.

Das bestätigt, dass die GKE-Pods fehlerfrei sind, die Workload Identity-Authentifizierung bei Vertex AI ohne statische Anmeldedaten erfolgreich ist und der Streamable HTTP-Transport wie erwartet funktioniert.

Schritt 5: Öffentlichen HTTPS-Gateway-Endpunkt prüfen

Prüfen Sie den Status der Zertifikatsbereitstellung mit:

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

Sobald das Zertifikat ACTIVE ist, testen Sie den öffentlichen HTTPS-Endpunkt mit dem Python-Testclient und dem Flag --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. MCP-Server in die Google Cloud Agent Platform einbinden

Nachdem Ihre MCPServer sicher auf HTTPS-Endpunkten in Cloud Run und GKE Autopilot bereitgestellt wurde, registrieren und erkennen Sie Ihre MCP-Tools mit der Google Cloud Agent Platform (Agent Registry), damit Unternehmens-Agents und KI-Modelle sie dynamisch erkennen und aufrufen können.

1. Benutzerdefinierten Cloud Run-MCP-Server in der Agent Platform registrieren und mit Service Discovery testen

Schritt 1: Tool-Spezifikationen extrahieren (`toolspec.json`)

Wenn Sie einen externen oder benutzerdefinierten MCP-Server in Agent Registry registrieren möchten, fragen Sie tools/list auf Ihrem Live-Server für zustandslose MCP 2.0-Server ab, entfernen Sie die Felder _meta auf Tool-Ebene und speichern Sie das Ergebnis in einer einzelnen Pipeline in toolspec.json:

# 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

Schritt 2: Dienst in Agent Registry registrieren

So katalogisieren Sie Ihren MCP-Server mit gcloud agent-registry services create:

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"

Prüfen Sie, ob der Dienst erfolgreich registriert wurde:

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

Schritt 3: Service Discovery-Testclient erstellen und ausführen

Erstellen Sie ein Python-Skript mit dem Namen src/mcp_server/test_agent_platform.py, das den Endpunkt dynamisch aus dem mcp-servers-Katalog der Agent Registry auflöst, sich mit Google Cloud IAM authentifiziert und ein Tool mit httpx2 und dem MCP 2.0 Client aufruft:

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

Führen Sie das Testskript aus:

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. Automatische MCP-Servererkennung und -registrierung mit GKE

Google Kubernetes Engine (GKE) bietet eine automatische Integration mit der Agent Registry. Wenn Sie Ihr GKE-Bereitstellungsmanifest kennzeichnen und annotieren, führt GKE automatisch einen Introspektionsscan für den MCP-Server durch, registriert die Tools im Katalog und stellt den Dienst auf der Consumer-Seite bereit, ohne dass Sie manuell eine toolspec.json generieren oder hochladen müssen.

Schritt 1: Funktionsweise der automatischen GKE-Erkennung

Als Ihre deployment.yaml im vorherigen Abschnitt angewendet wurde, wurden die folgenden Konfigurationen für die automatische Erkennung aktiviert:

registry.gke.io/functional-type: "MCP_SERVER": Informiert den GKE-Cluster-Controller, die Bereitstellung in der Google Cloud Agent Registry zu registrieren.
modelcontextprotocol.info/urls: Stellt den externen HTTPS-Gateway-Endpunkt (https://${MCP_DOMAIN}/mcp) für die Controller-Introspektion und das Consumer-Routing bereit.
modelcontextprotocol.info/capabilities: Deklariert den HTTP-Transportendpunkt (/mcp).
iam.gke.io/spiffe-identity-type: agent-identity: Konfiguriert Workload Identity für die Kommunikation mit Agenten.

Schritt 2: GKE-Autoregistrierung in der Agent Registry überprüfen

Prüfen Sie, ob Ihr MCP-Server automatisch von GKE erkannt und im regionalen mcp-servers-Katalog registriert wurde:

# 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

Schritt 3: GKE MCP-Server mit Service Discovery testen

Testen Sie die Bereitstellung des GKE MCP mit dem Service Discovery-Script anhand des automatisch registrierten Servernamens in us-central1:

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

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

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

8. Ressourcen bereinigen

Damit Ihrem Google Cloud-Konto die in diesem Codelab verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie den Cloud Run-Dienst, den GKE-Cluster, die Dienstkonten und das Container-Repository.

Cloud Run-Dienst löschen

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

GKE Autopilot-Cluster löschen

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

Dienstkonten und IAM-Bindungen löschen

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

Artifact Registry-Repository löschen

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

Benutzerdefinierten Dienst für die Agent Registry löschen

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

Cloud Storage-Bucket löschen

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

Statische IP-Adresse und SSL-Zertifikat löschen

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

Prüfen Sie, ob die Bereinigung nach dem Löschen abgeschlossen ist:

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

9. Glückwunsch

Das wars! Sie haben mit MCPServer aus dem MCP Python SDK und uv in Google Cloud erfolgreich einen MCP 2.0-Server erstellt, gesichert und bereitgestellt.

Behandelte Themen

MCPServer wurde erstellt, das die MCP-Spezifikation (28.07.2026) über zustandslose Streamable HTTP unterstützt.
Vier Google Cloud-Produktionstools entwickelt, in die Vertex AI Gemini, Cloud Storage, Cloud Logging und Resource Health integriert sind.
Sichere Containerbereitstellungen in Cloud Run mit erzwungener IAM-Authentifizierung und SSL/TLS.
Die authentifizierungslose Authentifizierung wurde in GKE Autopilot mit Workload Identity und Kubernetes Gateway API mit TLS konfiguriert.
Registrierte und erkannte MCP-Serverendpunkte mit der Gemini Enterprise Agent Platform (Agent Registry) mit OIDC-Autorisierungsheadern.

Nächste Schritte

In der Model Context Protocol-Spezifikation finden Sie erweiterte Ressourcen und Prompt-Definitionen.
Weitere Informationen zum MCP Python SDK
Google Cloud Run-Sicherheit und GKE Workload Identity