O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Criar, proteger e implantar um servidor MCP no Google Cloud

1. Antes de começar

O Protocolo de Contexto de Modelo (MCP) é um padrão aberto que permite que modelos e agentes de IA acessem ferramentas, bancos de dados e contexto empresarial com segurança. Desde a introdução em 2024, o protocolo tem sido amplamente adotado por provedores de nuvem e LLMs. A especificação mais recente, MCP Spec 2026-07-28 (MCP 2.0), define uma arquitetura sem estado, transportes simplificados e tipagem de resultados estrita, mantendo a compatibilidade com versões anteriores.

O SDK oficial do MCP para Python (mcp>=2.0.0) oferece MCPServer (mcp.server.mcpserver.MCPServer), que substitui FastMCP no MCP 2.0 como a estrutura de alto desempenho e fácil de usar para desenvolvedores na criação de servidores MCP prontos para produção de acordo com a especificação do MCP (28/07/2026) moderna com HTTP transmitível e eventos enviados pelo servidor (SSE, na sigla em inglês) em SSL/TLS.

Neste codelab, você vai criar um servidor MCP de nível de produção usando MCPServer do SDK do MCP 2.0 para Python e o gerenciamento de dependências uv. Você vai equipar seu servidor MCP com quatro ferramentas do Google Cloud: invocação do Gemini na Vertex AI, inspeção do Google Cloud Storage, gravação de auditoria do Cloud Logging e verificação da integridade de recursos do Google Cloud. Em seguida, você vai conteinerizar o servidor e implantá-lo em dois destinos de ambiente de execução do Google Cloud: o Cloud Run e o Autopilot do Google Kubernetes Engine (GKE). Depois, vai registrar e usar o servidor MCP na Gemini Enterprise Agent Platform.

Destaques da especificação do MCP 2026-07-28 e do SDK v2.0:

MCPServer Substitui FastMCP: no SDK oficial do Python mcp>=2.0.0, MCPServer (from mcp.server.mcpserver import MCPServer) substitui FastMCP, preservando a API familiar orientada por decorador (@mcp.tool, @mcp.custom_route).
Arquitetura sem estado: elimina os handshakes de inicialização de conexão com estado (initialize/initialized). Cada solicitação carrega a versão do protocolo e os recursos do cliente em cabeçalhos e _meta.
Endpoint de descoberta: implementa server/discover para negociação de recursos e versões.
Transporte transmissível: transporte HTTP/SSE simplificado que elimina cabeçalhos Mcp-Session-Id por conexão.
Tipagem de resultados: todos os resultados da execução da ferramenta incluem um resultType obrigatório ("complete" ou "input_required").

Atividades deste laboratório

Crie um MCPServer com quatro ferramentas do Google Cloud usando Python 3.12+ e uv de acordo com a especificação do MCP 2026-07-28.
Coloque o servidor MCP em um contêiner usando uma build do Docker de vários estágios.
Proteja e implante o servidor MCP no Cloud Run com autenticação do IAM e SSL/TLS aplicados.
Proteja e implante o servidor MCP no GKE Autopilot usando a Identidade da carga de trabalho e a API Gateway do Kubernetes com TLS.
Registre o endpoint do servidor MCP seguro com a Gemini Enterprise Agent Platform usando cabeçalhos de token de portador OIDC.

O que é necessário

Ter um projeto do Google Cloud com o faturamento ativado.
O SDK Google Cloud (CLI gcloud) instalado e configurado.
Python 3.12 ou mais recente e gerenciador de pacotes uv instalados.
O app docker foi instalado.
A ferramenta de linha de comando kubectl instalada.

2. Configurar o ambiente do Google Cloud

Antes de criar recursos, autentique seu ambiente e ative as APIs do Cloud necessárias do Google Cloud.

Autenticar a CLI gcloud

Faça login na sua conta do Google Cloud:

gcloud auth login

Defina o ID do projeto ativo do Google Cloud:

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

Ativar os serviços do Google Cloud

Ative todas as APIs necessárias para Cloud Run, GKE, Vertex AI, Artifact Registry, Cloud Build, Cloud Logging, Storage e 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}"

Verifique se as APIs foram ativadas:

Operation "operations/..." finished successfully.

Autenticar o Application Default Credentials

Autentique seu ambiente para que as bibliotecas de cliente Python possam acessar a Vertex AI e o Cloud Storage localmente durante o desenvolvimento:

gcloud auth application-default login

3. Criar o servidor MCP com MCPServer e uv

Nesta etapa, você vai inicializar um projeto Python usando uv e criar um MCPServer compatível com quatro recursos do Google Cloud.

Inicializar o projeto com uv

Crie o diretório do servidor e inicialize o uv:

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

Copie o código no arquivo 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"]

Sincronize as dependências usando uv:

uv sync

Escrever o código do MCPServer

Crie o arquivo de implementação do servidor em 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,
    )

Testar o servidor MCP localmente

Etapa 1: iniciar o servidor do MCP

No terminal principal, inicie o servidor usando uv:

uv run python -m src.mcp_server.server

Você vai ver registros de inicialização confirmando que o servidor HTTP transmissível está usando a porta 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)

Mantenha esse terminal aberto e em execução.

Etapa 2: verificar o endpoint HTTP transmissível usando curl

No MCP 2.0 (Especificação do MCP 2026-07-28), o handshake initialize com estado e o cabeçalho Mcp-Session-Id são substituídos por solicitações sem estado. Você pode invocar o tools/list diretamente transmitindo os cabeçalhos MCP-Protocol-Version e Mcp-Method junto com os metadados do cliente em params._meta.

Abra uma segunda janela de terminal e envie uma solicitação POST HTTP transmitível:

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": {}
      }
    }
  }'

O MCPServer vai responder com HTTP/1.1 200 OK e retornar o resultado tools/list do JSON-RPC diretamente:

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

Etapa 3: executar o cliente de teste do MCP

Para testar a descoberta e a execução de ferramentas no seu servidor local por HTTP transmissível, crie um script de cliente de teste 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())

Execute o script do cliente de teste usando uv:

uv run python src/mcp_server/test_client.py

Você vai ver uma saída demonstrando a conexão, a descoberta e a execução da ferramenta:

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

Depois da verificação, pressione CTRL+C no terminal principal para interromper o servidor local.

4. Conteinerizar o servidor MCP

Para implantar o servidor MCP no Cloud Run e no Autopilot do GKE, empacote o servidor em uma imagem de contêiner mínima usando um Dockerfile de vários estágios com tecnologia uv.

Criar Dockerfile

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

Criar e enviar imagem para o Artifact Registry

Crie um repositório do Artifact Registry:

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

Conceda as permissões necessárias do IAM à sua conta de usuário e à conta de serviço padrão do Compute Engine para que o Cloud Build possa preparar origens, gravar registros e enviar imagens ao 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"

Envie o build da imagem usando o 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}"

Após a conclusão, a imagem do contêiner é armazenada com segurança no Artifact Registry:

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

5. Implantar no Cloud Run com IAM e HTTPS

O Cloud Run oferece um ambiente sem servidor totalmente gerenciado com encerramento automático de certificado HTTPS / SSL e controle de acesso detalhado do Cloud IAM.

Criar conta de serviço dedicada

Crie uma conta de serviço do Google com privilégios mínimos para o 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"

Implantar serviço no Cloud Run

Implante o contêiner no Cloud Run com autenticação do IAM forçada (--no-allow-unauthenticated) e SSL gerenciado padrão:

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

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

Verificar a segurança de endpoints

Tentar fazer uma solicitação não autorizada ao endpoint HTTP do Streamable vai retornar 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

Gere um token de ID do OIDC usando gcloud para verificar a comunicação autorizada:

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

Teste da execução da ferramenta ativa: inspetor do Cloud Storage

Agora que o servidor MCP remoto está autenticado e respondendo, teste a execução da ferramenta gcs_bucket_inspector na infraestrutura do Google Cloud.

Etapa 1: criar um bucket de teste do Cloud Storage

Crie um bucket de teste e faça upload de um arquivo de amostra:

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"

Etapa 2: criar o cliente de teste da ferramenta GCS remota

Crie um script de cliente de teste chamado src/mcp_server/test_gcs_tool.py para autenticar no Cloud Run e invocar a ferramenta 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())

Etapa 3: executar o cliente de teste remoto do GCS

Execute o script de teste usando uv:

uv run python src/mcp_server/test_gcs_tool.py

Os metadados do objeto ativo vão ser retornados do servidor MCP do 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. Implantar no Autopilot do GKE com a Identidade da carga de trabalho e TLS

Para cargas de trabalho do Kubernetes, o GKE Autopilot gerencia o provisionamento de nós, enquanto a Identidade da carga de trabalho elimina as chaves estáticas da conta de serviço.

Provisionar um cluster do Autopilot do GKE

Provisione um cluster do GKE Autopilot:

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

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

Configurar a Identidade da carga de trabalho

Crie uma conta de serviço do Google (GSA) e uma conta de serviço do Kubernetes (KSA) e vincule-as usando a Identidade da carga de trabalho:

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

Aplicar a API Kubernetes Deployment e Gateway com TLS

Etapa 1: reservar um IP estático e provisionar um certificado SSL gerenciado pelo Google com nip.io

Reserve um endereço IP externo global e use o serviço DNS curinga nip.io (..nip.io) para estabelecer um nome de domínio público válido (MCP_DOMAIN) antes de aplicar os manifestos do 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}"

Não é necessário esperar que o provisionamento do certificado SSL seja concluído antes de continuar. Na verdade, os certificados gerenciados pelo Google permanecem no estado PROVISIONING até serem anexados ao balanceador de carga de gateway na etapa 3. Siga imediatamente para as próximas etapas.

Etapa 2: criar o manifesto de implantação e serviço

Crie deployment.yaml com as definições de implantação e serviço interno. Como o MCP 2.0 (Especificação do MCP 2026-07-28) não tem estado, o Service do Kubernetes não exige afinidade da sessão de IP do cliente:

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

Substitua MCP_DOMAIN e PROJECT_ID e aplique a implantação:

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

Etapa 3: criar o manifesto da API Gateway, HealthCheckPolicy e GCPBackendPolicy

Crie gateway.yaml contendo o gateway, o HTTPRoute, um HealthCheckPolicy e um GCPBackendPolicy:

HealthCheckPolicy: configura o balanceador de carga do Google Cloud para sondar /healthz na porta 8080.
GCPBackendPolicy (tempo limite do back-end): define timeoutSec: 300 para se alinhar ao tempo limite de leitura de 300 segundos do SDK do MCP v2 para fluxos HTTP / SSE transmitíveis. O gateway do GKE usa 30 segundos como padrão se for omitido.

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

Aplique o gateway, o HTTPRoute, a HealthCheckPolicy e a GCPBackendPolicy:

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

Etapa 4: verificar a implantação e testar o servidor MCP usando o encaminhamento de porta

Como os certificados SSL gerenciados pelo Google e os balanceadores de carga de aplicativo externos do Google Cloud levam de 5 a 15 minutos para provisionar e estabelecer o roteamento DNS, você pode testar imediatamente os pods do GKE em execução usando kubectl port-forward.

Primeiro, verifique se os pods e o gateway estão em execução:

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

Em seguida, teste o serviço GKE ativo localmente usando o encaminhamento de porta:

No terminal, encaminhe a porta local 8080 para o serviço ClusterIP do GKE:

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

Em um segundo terminal, crie um script de cliente de teste chamado src/mcp_server/test_vertex_tool.py para invocar a ferramenta vertex_ai_generate_content no GKE usando a Identidade da carga de trabalho:

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

Execute o script de teste na instância local com encaminhamento de porta:

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.

Isso confirma que os pods do GKE estão íntegros, que a Identidade da carga de trabalho está autenticando com sucesso na Vertex AI sem credenciais estáticas e que o transporte HTTP transmitível está funcionando como esperado.

Etapa 5: verificar o endpoint do gateway HTTPS público

Verifique o status de provisionamento do certificado com:

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

Quando o certificado estiver ACTIVE, teste o endpoint HTTPS público usando o cliente de teste Python com a 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. Integrar o servidor MCP à Agent Platform do Google Cloud

Agora que seu MCPServer está implantado com segurança em endpoints HTTPS no Cloud Run e no GKE Autopilot, registre e descubra suas ferramentas do MCP com a Plataforma de agentes do Google Cloud (Registro de agente) para que agentes empresariais e modelos de IA possam descobrir e invocar essas ferramentas de forma dinâmica.

1. Registrar o servidor MCP personalizado do Cloud Run na Agent Platform e testar usando a descoberta de serviços

Etapa 1: extrair especificações da ferramenta (`toolspec.json`)

Para registrar um servidor MCP externo ou personalizado no Agent Registry, consulte tools/list no seu servidor MCP 2.0 ativo e sem estado, remova os campos _meta no nível da ferramenta e salve o resultado em toolspec.json em um único pipeline:

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

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

Etapa 2: registrar o serviço no Agent Registry

Use gcloud agent-registry services create para catalogar seu servidor 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"

Verifique se o serviço foi registrado com sucesso:

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

Etapa 3: criar e executar o cliente de teste do Service Discovery

Crie um script Python chamado src/mcp_server/test_agent_platform.py que resolva dinamicamente o endpoint do catálogo mcp-servers do Agent Registry, faça a autenticação com o Cloud IAM do Google Cloud e invoque uma ferramenta usando httpx2 e o MCP 2.0 Client:

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


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

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

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

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

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

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

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

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

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


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

Execute o script de teste:

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. Descoberta e registro automáticos de servidores MCP com o GKE

O Google Kubernetes Engine (GKE) oferece integração automática com o Agent Registry. Ao rotular e anotar o manifesto de implantação do GKE, o GKE realiza automaticamente uma verificação de introspecção no servidor MCP, registra as ferramentas no catálogo e projeta o serviço no lado do consumidor sem precisar gerar ou fazer upload manual de um toolspec.json.

Etapa 1: como a descoberta automática do GKE funciona

Quando o deployment.yaml foi aplicado na seção anterior, as seguintes configurações ativaram a descoberta automática:

registry.gke.io/functional-type: "MCP_SERVER": informa ao controlador do cluster do GKE para registrar a implantação no Google Cloud Agent Registry.
modelcontextprotocol.info/urls: fornece o endpoint do gateway HTTPS externo (https://${MCP_DOMAIN}/mcp) para introspecção do controlador e roteamento do consumidor.
modelcontextprotocol.info/capabilities: declara o endpoint de transporte HTTP (/mcp).
iam.gke.io/spiffe-identity-type: agent-identity: configura a Identidade da carga de trabalho para comunicação com agentes.

Etapa 2: verificar o registro automático do GKE no Agent Registry

Verifique se o GKE descobriu e registrou automaticamente seu servidor MCP no catálogo regional 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

Etapa 3: testar o servidor do MCP do GKE usando a descoberta de serviços

Teste a implantação do MCP do GKE usando o script de descoberta de serviços com o nome do servidor registrado automaticamente em 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. Limpar recursos

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste codelab, exclua o serviço do Cloud Run, o cluster do GKE, as contas de serviço e o repositório de contêineres.

Excluir serviço do Cloud Run

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

Excluir cluster do GKE Autopilot

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

Excluir contas de serviço e vinculações do IAM

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

Excluir repositório do Artifact Registry

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

Excluir serviço personalizado do Agent Registry

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

Excluir bucket do Cloud Storage

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

Excluir IP estático e certificado 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}"

Verifique se a limpeza da exclusão foi concluída:

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

9. Parabéns

Parabéns! Você criou, protegeu e implantou um servidor MCP 2.0 usando MCPServer do SDK do MCP para Python e uv no Google Cloud.

Conteúdo abordado

Criamos um MCPServer compatível com a especificação do MCP (28/07/2026) em HTTP streamable sem estado.
Criou quatro ferramentas de produção do Google Cloud que integram o Gemini da Vertex AI, o Cloud Storage, o Cloud Logging e o Resource Health.
Implantações de contêineres protegidas no Cloud Run com autenticação do IAM e SSL/TLS aplicados.
Configurou a autenticação sem secrets no GKE Autopilot com a Identidade da carga de trabalho e a API Gateway do Kubernetes com TLS.
Endpoints de servidores MCP registrados e descobertos com a Gemini Enterprise Agent Platform (Agent Registry) usando cabeçalhos de autorização OIDC.

Próximas etapas

Confira a Especificação do Protocolo de Contexto de Modelo para recursos avançados e definições de comandos.
Saiba mais sobre o SDK do Python para MCP.
Saiba mais sobre a segurança do Google Cloud Run e a Identidade da carga de trabalho do GKE.