Comienza a usar los servidores de MCP de Google

1. Introducción

¡Te damos la bienvenida! En este codelab, aprenderás a potenciar tus agentes de IA con los servidores del Protocolo de contexto del modelo (MCP) administrados por Google.

El Protocolo de contexto del modelo (MCP) es un estándar de código abierto que permite que los modelos de IA se conecten de forma segura y eficiente a herramientas y fuentes de datos externas. Si bien la mayoría de las implementaciones de MCP se ejecutan de forma local en tu máquina, Google proporciona servidores de MCP remotos administrados. Estos son extremos completamente alojados y listos para la empresa que permiten que tus agentes interactúen directamente con la infraestructura de Google Cloud sin que tengas que administrar ningún código o contenedor del servidor.

La ventaja de "Administrado"

A diferencia de los servidores de MCP locales que usan entrada y salida estándar (stdio), los servidores administrados de Google utilizan HTTP transmitible. Esta arquitectura ofrece lo siguiente:

Infraestructura cero: No hay servidores para aprovisionar ni escalar.
Seguridad por diseño: Integración nativa con Google Cloud IAM y Registros de auditoría.
Escalabilidad sin estado: Interacción fluida a través de balanceadores de cargas y proxies estándares

Qué aprenderás

Cómo habilitar y autenticar los servidores de MCP administrados
Cómo usar el servidor de MCP de Cloud Logging como referencia básica.
Cómo organizar varios servidores de MCP (Developer Knowledge, Firestore, etc.) para crear flujos de trabajo autónomos

Requisitos

Un proyecto de Google Cloud con la facturación habilitada
Conocimientos sobre la consola de Google Cloud y la CLI de gcloud
Google Cloud Shell (Gemini CLI está preinstalada aquí).

Este codelab está diseñado para usuarios y desarrolladores de todos los niveles (incluidos los principiantes).

Informar problemas

A medida que trabajes en el codelab y con Antigravity, es posible que encuentres problemas.

Si tienes problemas relacionados con el codelab (errores de escritura, instrucciones incorrectas), abre un error con el botón Report a mistake que se encuentra en la esquina inferior izquierda de este codelab:

2. Antes de comenzar

En este paso, prepararás tu entorno de Google Cloud. Realizaremos todas las tareas en Google Cloud Shell, que proporciona una terminal persistente y preconfigurada.

Activar Cloud Shell

Navega a la consola de Google Cloud.
Haz clic en el ícono de Activar Cloud Shell en el encabezado de la parte superior derecha.
Una vez que comience la sesión de la terminal, autoriza la instrucción si se te solicita.

Establece tu ID del proyecto

Asegúrate de que Cloud Shell apunte al proyecto correcto:

# Set your active project
gcloud config set project YOUR_PROJECT_ID

# Verify the setting
gcloud config list project

Habilita las APIs de Foundation

Los servidores de MCP administrados requieren que se habiliten tanto la API del producto subyacente como la interfaz de MCP. Ejecuta el siguiente comando para habilitar el backend de Cloud Logging (nuestra referencia para este lab):

# Enable the Cloud Logging API and its MCP interface
gcloud services enable logging.googleapis.com
gcloud beta services mcp enable logging.googleapis.com

Nota: Actualmente, los servicios de MCP administrados se encuentran en beta. Debes usar el componente beta de gcloud para habilitarlas.

Configura las credenciales predeterminadas de la aplicación (ADC)

La CLI de Gemini usa tu identidad de usuario para comunicarse con los servidores de MCP. Otorga permiso al agente para que actúe en tu nombre:

gcloud auth application-default login

Sigue la URL en la terminal, accede y vuelve a pegar el código de autorización en Cloud Shell.

Asigna roles de IAM básicos

Los servidores de MCP administrados usan un modelo de seguridad de doble capa. Debes tener abiertas dos “puertas” específicas:

Puerta 1 (acceso a MCP): Es el rol que te permite llamar al protocolo.
Puerta 2 (acceso al servicio): Es el rol que te permite ver los datos (p.ej., ver registros).

Ejecuta el siguiente comando para otorgarte el acceso requerido:

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

# Gate 1: Permission to use the MCP protocol
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/mcp.toolUser"

# Gate 2: Permission to view the actual logs
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/logging.viewer"

3. Conceptos básicos: Conecta tu primer servidor de MCP

En este paso, vincularás tu agente de IA (Gemini CLI) al servidor de MCP de Google Cloud Logging. Esta es nuestra "base" porque permite que el agente vea lo que sucede dentro de tu proyecto en tiempo real.

Tarea 1: Configura el servidor de MCP de Logging

Gemini CLI usa un archivo settings.json para administrar sus conexiones. Deberás editar este archivo (presente en la carpeta ~/.gemini) para agregar el siguiente fragmento dentro del bloque mcpServers. Reemplaza YOUR_PROJECT_ID por el ID de tu proyecto:

"logging-mcp": {
      "httpUrl": "https://logging.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "oauth": {
        "scopes": [
          "https://www.googleapis.com/auth/logging.read"
        ]
      },
      "timeout": 30000,
      "headers": {
        "x-goog-user-project": "YOUR_PROJECT_ID"
      }
}

Nota: El encabezado x-goog-user-project es obligatorio para los servidores de MCP administrados, ya que garantiza que el uso de la API y la facturación se atribuyan correctamente a tu proyecto.

Tarea 2: Simula la actividad del proyecto (crea registros)

Si tu proyecto es nuevo o está inactivo, es posible que no tenga registros "interesantes" recientes. Usemos la CLI de gcloud para insertar algunas entradas personalizadas de modo que el agente tenga algo que encontrar.

Ejecuta estos comandos uno por uno para simular una secuencia de eventos:

# 1. Simulate a standard system start
gcloud logging write mcp-test-log "System boot sequence initiated" --severity=INFO
# 2. Simulate a warning about resource limits
gcloud logging write mcp-test-log "High memory pressure detected in zone us-central1-a" --severity=WARNING
# 3. Simulate a critical authentication failure
gcloud logging write mcp-test-log "ERROR: Failed to connect to Cloud SQL. Permission Denied." --severity=ERROR

Tarea 3: Verifica las herramientas en Gemini CLI

Antes de comenzar a chatear, verifiquemos que el agente pueda "ver" las herramientas expuestas por el servidor de Logging. Inicia Gemini CLI:

gemini

Una vez que estés en el símbolo del sistema de Gemini CLI (>), ejecuta el comando list:

/mcp list

Punto de control de verificación: Deberías ver logging-mcp como Listo con aproximadamente 6 herramientas disponibles, incluida list_log_entries.

Tarea 4: Tu primera instrucción de infraestructura en vivo

Ahora, pidámosle al agente que encuentre los registros que acabamos de crear. Como otorgaste el rol roles/logging.viewer anteriormente, el agente ahora puede "comunicarse" y leer el estado de tu proyecto.

Escribe la siguiente instrucción en Gemini CLI:

Show me the 3 most recent log entries from the log named 'mcp-test-log'. What is the highest severity issue you see?

Observa al agente:

Es posible que el agente te solicite el ID del proyecto de Google Cloud. Proporciona esa información.
Identificará que necesita la herramienta list_log_entries.
Se te pedirá permiso para ejecutar la herramienta. Selecciona 1. Sí, permitir una vez.
Analizará la respuesta JSON y te informará sobre el error Cloud SQL Permission Denied que simulamos.

4. Recorrido A: El cerebro (MCP de conocimiento del desarrollador)

En este recorrido, le darás un "cerebro" a tu agente conectándolo al servidor de MCP de Google Developer Knowledge.

Uno de los mayores riesgos de los agentes de IA es la alucinación, es decir, proporcionar con confianza comandos de la CLI desactualizados o parámetros de la API obsoletos. Este servidor de MCP resuelve ese problema al fundamentar el agente en el corpus oficial y activo de documentación para desarrolladores de Google (que abarca Google Cloud, Firebase, Android y mucho más).

Tarea 1: Habilita los servicios de conocimiento

Al igual que en nuestro paso fundamental, debemos habilitar la API de backend y el extremo de servicio de MCP.

# 1. Enable the Developer Knowledge API
gcloud services enable developerknowledge.googleapis.com

# 2. Enable the MCP Server interface
gcloud beta services mcp enable developerknowledge.googleapis.com

Tarea 2: Proporciona una clave de API restringida

El MCP de Developer Knowledge usa claves de API para la autenticación. Por motivos de seguridad, crearemos una clave y la restringiremos para que solo se pueda usar con esta API específica.

Ejecuta la siguiente secuencia de comandos para crear y recuperar tu clave:

# Create the restricted API key
gcloud alpha services api-keys create \
    --display-name="MCP-Knowledge-Key" \
    --api-target service=developerknowledge.googleapis.com

# Wait a few seconds for the key to propagate, then fetch the string
gcloud alpha services api-keys get-key-string \
    $(gcloud alpha services api-keys list \
    --filter="displayName='MCP-Knowledge-Key'" \
    --format="value(name)") \
    --format="value(keyString)"

Copia la cadena larga de caracteres que devolvió el segundo comando. Este es tu YOUR_API_KEY.

Tarea 3: Configura Gemini CLI

Ahora, registra el servidor de MCP de Knowledge con tu agente. Esto permite que el agente busque en la documentación oficial cada vez que encuentre una pregunta técnica que no pueda responder con un 100% de certeza.

Agrega el siguiente fragmento dentro de la sección mcpServers en el archivo ~/.gemini/settings.json y reemplaza YOUR_API_KEY por la cadena que acabas de copiar:

"developer-knowledge-mcp": {
      "httpUrl": "https://developerknowledge.googleapis.com/mcp",
      "headers": {
        "X-Goog-Api-Key": "YOUR_API_KEY"
      }
}

Tarea 4: La prueba de anti-alucinación

Verifiquemos que el agente ahora esté "investigando" en lugar de "adivinando".

Inicia Gemini CLI:

gemini

Verifica que el servidor esté listo: escribe /mcp list. Deberías ver google-developer-knowledge con 2 herramientas (search_documents y get_document).

La instrucción: Pídele al agente que encuentre un comando específico y moderno.

I want to create a Google Cloud Storage bucket using the modern gcloud storage command. Search the official documentation for the exact syntax and show me an example for a bucket in the 'us-central1' region.

Qué debes buscar:

Gemini te pedirá permiso para usar search_documents.
Luego, es probable que llame a get_document para leer la página específica que encontró.
La respuesta final debe incluir un comando gcloud storage buckets create ..., citado directamente de la documentación.

5. Recorrido B: La evaluación (solución de problemas autónoma)

Requisito previo: Para completar este recorrido, debes haber completado el Recorrido A: El cerebro para que el agente pueda investigar las correcciones.

En este recorrido, combinarás los Ojos (MCP de Cloud Logging) y el Cerebro (MCP de conocimiento del desarrollador) de tu agente para crear un Bucle de solución de problemas autónomo.

En lugar de copiar manualmente los códigos de error en un motor de búsqueda, le darás al agente una sola instrucción para que analice tu proyecto en busca de errores, investigue la resolución oficial y genere un informe de correcciones prácticas.

Tarea 1: Simula un "mal día" en GCP

Para ver el poder de la solución de problemas autónoma, necesitamos un conjunto realista de fallas. Usaremos una secuencia de comandos de Python para insertar una variedad de obstáculos de infraestructura (desde errores de permiso denegado hasta problemas de cuota) directamente en tus registros.

En Cloud Shell, crea una carpeta de tu elección y navega hasta ella.
Crea un archivo llamado simulate_errors.py:

nano simulate_errors.py

Pega el siguiente código en el editor:

import argparse
from google.cloud import logging

def simulate_errors(project_id):
    client = logging.Client(project=project_id)
    logger = client.logger("mcp-scenario-logger")

    print(f"Simulating realistic errors for project: {project_id}...")

    # 1. GCS Permission Error
    logger.log_text("ERROR: GCS Upload failed for 'gs://my-app-bucket/data.json'. Status: 403 Forbidden. Missing 'storage.objects.create' for service account.", severity="ERROR")

    # 2. Cloud Run Startup Error
    logger.log_text("ERROR: Cloud Run service 'api-gateway' failed to start. Container failed to listen on port 8080. Check 'Cloud Run container startup requirements'.", severity="ERROR")

    # 3. Secret Manager Access Error
    logger.log_text("ERROR: Access denied to secret 'API_KEY'. The identity lacks 'secretmanager.versions.access'.", severity="ERROR")

    print("Log entries written to 'mcp-scenario-logger'.")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--project", required=True)
    args = parser.parse_args()
    simulate_errors(args.project)

Presiona Ctrl + O, Intro y Ctrl+X para guardar y salir.
Instala la biblioteca de Google Cloud Logging y ejecuta la secuencia de comandos:

python -m venv mcp_env
source mcp_env/bin/activate
pip install google-cloud-logging
python simulate_errors.py --project $(gcloud config get-value project)

Tarea 2: Ejecuta el bucle autónomo

Ahora, activaremos una instrucción compleja que le indica a Gemini que coordine ambos servidores de MCP de forma simultánea.

Inicia Gemini CLI:

gemini

Escribe esta "instrucción principal" en el agente:

I need to troubleshoot recent issues in my project. Perform the following autonomous loop:

Step 1 : Retrieval: Use the Logging MCP to fetch the 5 most recent ERROR entries from the log 'mcp-scenario-logger'.
Step 2 : Iteration: For every unique error found, extract the service and specific error message.
Step 3 : Research: Use the Developer Knowledge MCP to find the official resolution or gcloud command to fix each issue.
Step 4 : Resolution: Consolidate everything into a markdown table with columns: | Service | Error Summary | Recommended Fix |.

Qué esperar

Ahora estás viendo un flujo de trabajo agentic en tiempo real. El agente hará lo siguiente:

Llama a list_log_entries para ver el "Día malo" que acabamos de simular.
Analiza el texto para identificar que GCS, Cloud Run y Secret Manager están fallando.
Llama a search_documents y get_document para cada uno de esos servicios y encuentra los roles de IAM correctos o las correcciones de configuración.
Presentarte una tabla estructurada similar a esta (las recomendaciones podrían diferir):

Servicio	Resumen del error	Corrección recomendada
Cloud Storage	Error 403 (Prohibido) al subir contenido	Otorga `roles/storage.objectCreator` a la cuenta de servicio.
Cloud Run	No se pudo escuchar en el puerto 8080	Asegúrate de que la app se vincule a 0.0.0.0 en el puerto definido por `$PORT`.
Secret Manager	Falta el rol de acceso a la versión	Asigna `roles/secretmanager.secretAccessor` a la identidad.

6. Recorrido C: Los datos (MCP de Firestore)

En este recorrido, usarás el servidor de MCP de Firestore para administrar una base de datos de documentos NoSQL solo con lenguaje natural.

Firestore es una base de datos flexible y escalable, pero su administración a menudo requiere escribir código complejo del SDK o navegar por la consola. Con MCP, tu agente se convierte en un administrador de bases de datos capaz de propagar datos, consultar registros y hasta realizar migraciones de esquemas complejos a través del chat.

Tarea 1: Habilita los servicios de Firestore

Primero, habilita la API de Firestore y su extremo de MCP correspondiente.

# 1. Enable the Firestore API
gcloud services enable firestore.googleapis.com

# 2. Enable the MCP Server interface
gcloud beta services mcp enable firestore.googleapis.com

Tarea 2: Asigna roles de IAM de Firestore

Para ejecutar consultas, tu identidad necesita permisos específicos más allá del acceso básico al MCP.

# Grant Firestore User role
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/datastore.user"

Tarea 3: Crea una base de datos de prueba dedicada

Para mantener la seguridad de nuestros experimentos, crearemos una base de datos de Firestore dedicada llamada mcp-lab-db.

gcloud firestore databases create --database=mcp-lab-db --location=nam5 --type=firestore-native

Tarea 4: Configura Gemini CLI

Agrega el servidor de MCP de Firestore a tu agente. Agrega la siguiente configuración a la sección mcpServers en el archivo ~/.gemini/settings.json. Reemplaza YOUR_PROJECT_ID por el ID de tu proyecto:

"firestore-mcp": {
      "httpUrl": "https://firestore.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "oauth": {
        "scopes": [
          "https://www.googleapis.com/auth/cloud-platform"
        ]
      },
      "timeout": 30000,
      "headers": {
        "x-goog-user-project": "YOUR_PROJECT_ID"
      }
}

Tarea 5: Operaciones de la base de datos de lenguaje natural

Inicia Gemini CLI y realiza algunas operaciones básicas para verificar la conexión.

Inicia Gemini CLI:

gemini

Verifica que el servidor esté listo: escribe /mcp list. Deberías ver firestore-mcp con varias herramientas (add_document, create_database, list_documents, etc).

Prueba estas instrucciones en orden:

Datos de inicialización:

In the 'mcp-lab-db' database, add three documents to a 'products' collection. Include a laptop (stock 5), a mouse (stock 25), and a keyboard (stock 8).

Verificar:

List all documents in the 'products' collection from the 'mcp-lab-db' database.

Prueba otras instrucciones que te ayuden a administrar bases de datos y colecciones de Firestore a través del lenguaje natural.

7. Recorrido D: Inteligencia (BigQuery y Maps)

En este recorrido, equiparás a tu agente con la capacidad de analizar petabytes de datos y comprender el mundo físico con los servidores de MCP de BigQuery y Maps Grounding Lite.

Al final de esta sección, tu agente podrá traducir el lenguaje natural en consultas en SQL complejas y proporcionar asesoramiento geoespacial sensible al contexto (como tiempos de viaje y clima) para fundamentar sus respuestas en la realidad.

Tarea 1: Habilita los servicios de inteligencia

Habilita las APIs y las interfaces de MCP para BigQuery y Google Maps.

# 1. Enable product APIs
gcloud services enable bigquery.googleapis.com mapstools.googleapis.com

# 2. Enable MCP Server interfaces
gcloud beta services mcp enable bigquery.googleapis.com
gcloud beta services mcp enable mapstools.googleapis.com

Tarea 2: Asigna roles de IAM de BigQuery

Para ejecutar consultas, tu identidad necesita permisos específicos más allá del acceso básico al MCP.

# Grant BigQuery Job User and Data Viewer roles
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/bigquery.jobUser"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/bigquery.dataViewer"

Tarea 3: Proporciona una clave de la API de Maps

A diferencia de otros servicios que dependen únicamente de IAM, el servidor de Maps Grounding Lite requiere una clave de API para la cuota y la facturación.

Crea la clave:

gcloud alpha services api-keys create --display-name="MCP-Maps-Key"

Recupera la cadena de claves:

# Wait a few seconds for the key to propagate, then fetch the string
gcloud alpha services api-keys get-key-string \
    $(gcloud alpha services api-keys list \
    --filter="displayName='MCP-Maps-Key'" \
    --format="value(name)") \
    --format="value(keyString)"

Copia la cadena de claves para el siguiente paso.

Tarea 4: Configura Gemini CLI

Ahora, registra ambos servidores. Agrega los siguientes fragmentos a la sección mcpServers del archivo ~/.gemini/settings.json. Reemplaza YOUR_PROJECT_ID y YOUR_MAPS_API_KEY según corresponda.

"bigquery-mcp": {
      "httpUrl": "https://bigquery.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "oauth": {
        "scopes": [
          "https://www.googleapis.com/auth/cloud-platform"
        ]
      },
      "timeout": 30000,
      "headers": {
        "x-goog-user-project": "YOUR_PROJECT_ID"
      }
},
"maps-grounding-lite-mcp": {
      "httpUrl": "https://mapstools.googleapis.com/mcp",
      "headers": {
        "X-Goog-Api-Key": "YOUR_MAPS_API_KEY"
      }
}

Tarea 5: Inteligencia en acción

Inicia Gemini CLI y prueba las nuevas capacidades de "Inteligencia".

gemini

Verifica que el servidor esté listo: escribe /mcp list. Deberías ver bigquery-mcp y maps-grounding-lite-mcp con varias herramientas enumeradas. .

Situación 1: El motor analítico (BigQuery) Pídele al agente que consulte un conjunto de datos públicos sin que sepas nada de SQL:

Run a query to count the number of penguins on each island in the BigQuery public dataset ml_datasets.penguins.

Situación 2: Contexto geoespacial (Maps) Pídele al agente que planifique un viaje al mundo real:

I am planning a drive from Mumbai to Pune tomorrow morning. Based on current weather and routing, what should I expect in terms of travel time and what should I carry?

Qué debes buscar:

En el caso de BigQuery, el agente llamará a execute_sql para descubrir el esquema y ejecutar la consulta.
En el caso de Maps, coordinará lookup_weather y compute_routes para brindarte un plan de viaje fundamentado y útil.

8. Protección: IAM y seguridad de producción

En este paso final, dejarás de usar permisos amplios de "Propietario" para usar un modelo de defensa en profundidad de nivel de producción.

Los agentes de IA son "útiles" por naturaleza. Si restringes una herramienta a nivel de la IU, es posible que un agente inteligente intente eludir esa restricción ejecutando un comando de shell. Para proteger realmente tu infraestructura, debes crear límites estrictos con Google Cloud IAM.

El modelo de seguridad de doble capa

Para ejecutar cualquier acción, un agente debe pasar por dos puertas:

Puerta 1 (la puerta de MCP): ¿La identidad tiene roles/mcp.toolUser? (Permiso para usar el protocolo)
Puerta 2 (la puerta de servicio): ¿La identidad tiene el rol de producto específico (p.ej., roles/datastore.viewer)? (Permiso para ver los datos).

Tarea 1: Capa 1: Filtrado del cliente (`excludeTools`)

La primera capa de defensa consiste en ocultar las herramientas al agente para que ni siquiera "piense" en usarlas.

Abre la configuración de Gemini CLI en el editor de Cloud Shell:

cloudshell edit ~/.gemini/settings.json

Busca el bloque firestore-mcp y agrega la directiva excludeTools para ocultar las acciones destructivas:

"firestore-mcp": {
  "httpUrl": "https://firestore.googleapis.com/mcp",
  "excludeTools": ["delete_database", "update_database", "delete_document"],
  ...
}

Guarda el archivo y reinicia Gemini CLI. Ejecuta /mcp list y observa que esas herramientas ya no están.

Tarea 2: Capa 2: Supremacía de la infraestructura (el guardia de IAM)

El filtrado del cliente es un parámetro de referencia "suave". Si le pides al agente que "borre mi base de datos de Firestore" y la herramienta está oculta, es posible que intente ejecutar gcloud firestore databases delete. Para evitar esto, usamos una cuenta de servicio con privilegios mínimos.

Crea una cuenta de servicio de "solo lectura":

# Create the service account
gcloud iam service-accounts create mcp-reader-sa --display-name="MCP Reader Only"

# Grant ONLY the necessary roles (Gate 1 + Gate 2)
export PROJECT_ID=$(gcloud config get-value project)
SA_EMAIL="mcp-reader-sa@$PROJECT_ID.iam.gserviceaccount.com"

gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/mcp.toolUser"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/datastore.viewer"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/aiplatform.user"

Genera y activa la clave:

gcloud iam service-accounts keys create reader-key.json --iam-account=$SA_EMAIL
export GOOGLE_APPLICATION_CREDENTIALS=$(pwd)/reader-key.json

Tarea 3: Prueba de rebote del "Agente útil"

Ahora, probemos si el agente puede eludir nuestra seguridad.

Nuestro primer paso será activar la cuenta de servicio para que, incluso si el agente recurre al uso del comando gcloud, opere bajo la identidad de la cuenta de servicio que acabamos de crear.

Activa la cuenta de servicio:

Ejecuta el siguiente comando y reemplaza [PATH_TO_KEY_FILE] por la ruta de acceso real a tu archivo de clave JSON (p.ej., reader-key.json).

gcloud auth activate-service-account --key-file=[PATH_TO_KEY_FILE]

Verifica el cambio:

Después de ejecutar el comando, puedes verificar que la cuenta de servicio esté activa ejecutando el siguiente comando:

gcloud auth list

El resultado mostrará la cuenta de servicio como la credencial activa.

Inicia Gemini CLI:

gemini

Escribe esta instrucción:

I want to delete the 'mcp-lab-db' firestore database. If the tool is missing, try using the gcloud firestore command in the terminal.

¿Qué sucede?

Primero, el agente intentará usar la herramienta delete_database en el servidor de MCP de Firestore. Fallará debido a la falta de permisos.
Luego, intenta ser "útil" recurriendo a la herramienta run_shell_command para usar el comando gcloud firestore.

El resultado:

El comando falla con un error de prohibido. Dado que el agente se ejecuta con la identidad mcp-reader-sa, no tiene el permiso datastore.databases.delete. IAM es la última medida de seguridad. Independientemente de cómo el agente intente acceder al recurso, el "Bouncer" a nivel de la API de Google Cloud bloqueará la solicitud.

Vuelve a tu cuenta de usuario:

Para volver a tu cuenta de usuario, ejecuta el siguiente comando:

gcloud config set account YOUR_EMAIL_ADDRESS

9. Limpieza

Para evitar cargos no deseados, borra los recursos de prueba:

# Delete the Firestore database
gcloud firestore databases delete --database=mcp-lab-db

# Remove the service account
gcloud iam service-accounts delete mcp-reader-sa@$PROJECT_ID.iam.gserviceaccount.com

10. Conclusión

¡Felicitaciones! Navegaste correctamente por la pila completa de servidores de MCP administrados por Google.

Comenzaste con el "tronco" del lab, estableciendo una conexión fundamental con Cloud Logging. Desde allí, te expandiste a "Aventuras" modulares, que fundamentan el conocimiento de tu agente, automatizan bucles complejos de solución de problemas, migran datos en Firestore y extraen inteligencia de BigQuery y Maps.

Lo más importante es que terminaste por anclar tu agente en las raíces de la seguridad de producción. Demostraste que, si bien un agente puede ser "útil" hasta el extremo, Google Cloud IAM es el portero definitivo, ya que garantiza que tus flujos de trabajo autónomos siempre respeten el principio de privilegio mínimo.

Conclusiones clave

Administrado = Escalable: Te conectaste a herramientas a nivel de la infraestructura a través de HTTP transmitible sin implementar un solo servidor.
La fundamentación es obligatoria: Reemplazaste las "conjeturas" del LLM por el MCP de conocimiento del desarrollador, lo que garantiza que tu agente use comandos válidos y actuales.
La organización es poder: Viste que la verdadera magia ocurre cuando un agente combina varios servidores de MCP para resolver un solo problema comercial.

Comienza a usar los servidores de MCP de Google Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

1. Introducción

La ventaja de "Administrado"

Qué aprenderás

Requisitos

Informar problemas

2. Antes de comenzar

Activar Cloud Shell

Establece tu ID del proyecto

Habilita las APIs de Foundation

Configura las credenciales predeterminadas de la aplicación (ADC)

Asigna roles de IAM básicos

3. Conceptos básicos: Conecta tu primer servidor de MCP

Tarea 1: Configura el servidor de MCP de Logging

Tarea 2: Simula la actividad del proyecto (crea registros)

Tarea 3: Verifica las herramientas en Gemini CLI

Tarea 4: Tu primera instrucción de infraestructura en vivo

4. Recorrido A: El cerebro (MCP de conocimiento del desarrollador)

Tarea 1: Habilita los servicios de conocimiento

Tarea 2: Proporciona una clave de API restringida

Tarea 3: Configura Gemini CLI

Tarea 4: La prueba de anti-alucinación

5. Recorrido B: La evaluación (solución de problemas autónoma)

Tarea 1: Simula un "mal día" en GCP

Tarea 2: Ejecuta el bucle autónomo

6. Recorrido C: Los datos (MCP de Firestore)

Tarea 1: Habilita los servicios de Firestore

Tarea 2: Asigna roles de IAM de Firestore

Tarea 3: Crea una base de datos de prueba dedicada

Tarea 4: Configura Gemini CLI

Tarea 5: Operaciones de la base de datos de lenguaje natural

7. Recorrido D: Inteligencia (BigQuery y Maps)

Tarea 1: Habilita los servicios de inteligencia

Tarea 2: Asigna roles de IAM de BigQuery

Tarea 3: Proporciona una clave de la API de Maps

Tarea 4: Configura Gemini CLI

Tarea 5: Inteligencia en acción

8. Protección: IAM y seguridad de producción

El modelo de seguridad de doble capa

Tarea 1: Capa 1: Filtrado del cliente (excludeTools)

Tarea 2: Capa 2: Supremacía de la infraestructura (el guardia de IAM)

Tarea 3: Prueba de rebote del "Agente útil"

9. Limpieza

10. Conclusión

Conclusiones clave

Comienza a usar los servidores de MCP de Google

Tarea 1: Capa 1: Filtrado del cliente (`excludeTools`)