Premiers pas avec les serveurs MCP Google

1. Introduction

Bienvenue ! Dans cet atelier de programmation, vous allez apprendre à booster vos agents d'IA à l'aide des serveurs MCP (Model Context Protocol) gérés par Google.

Le Model Context Protocol (MCP) est une norme Open Source qui permet aux modèles d'IA de se connecter de manière sécurisée et efficace à des sources de données et des outils externes. Alors que la plupart des implémentations MCP s'exécutent localement sur votre machine, Google fournit des serveurs MCP distants gérés. Il s'agit de points de terminaison entièrement hébergés et adaptés aux entreprises qui permettent à vos agents d'interagir directement avec l'infrastructure Google Cloud sans que vous ayez à gérer de code ni de conteneurs côté serveur.

L'avantage des comptes gérés

Contrairement aux serveurs MCP locaux qui utilisent des entrées/sorties standards (stdio), les serveurs gérés de Google utilisent Streamable HTTP. Cette architecture offre les avantages suivants :

Aucune infrastructure : aucun serveur à provisionner ni à mettre à l'échelle.
Sécurité dès la conception : intégration native à Google Cloud IAM et aux journaux d'audit.
Scalabilité sans état : interaction fluide grâce aux équilibreurs de charge et aux proxys standards.

Points abordés

Activer et authentifier les serveurs MCP gérés
Utiliser le serveur MCP Cloud Logging comme base de référence.
Orchestrer plusieurs serveurs MCP (Developer Knowledge, Firestore, etc.) pour créer des workflows autonomes.

Prérequis

Un projet Google Cloud avec facturation activée.
savoir utiliser la console Google Cloud et la CLI gcloud ;
Google Cloud Shell (Gemini CLI est préinstallé).

Cet atelier de programmation s'adresse aux utilisateurs et aux développeurs de tous niveaux (y compris aux débutants).

Problèmes concernant les rapports

À mesure que vous progressez dans l'atelier de programmation et avec Antigravity, vous pouvez rencontrer des problèmes.

Pour les problèmes liés à l'atelier de programmation (fautes de frappe, instructions incorrectes), veuillez signaler un bug à l'aide du bouton Report a mistake en bas à gauche de cet atelier de programmation :

2. Avant de commencer

Dans cette étape, vous allez préparer votre environnement Google Cloud. Nous allons effectuer toutes les tâches dans Google Cloud Shell, qui fournit un terminal persistant et préconfiguré.

Activer Cloud Shell

Accédez à Google Cloud Console.
Cliquez sur l'icône Activer Cloud Shell dans l'en-tête en haut à droite.
Une fois la session de terminal lancée, autorisez l'invite si vous y êtes invité.

Définir votre ID de projet

Assurez-vous que Cloud Shell pointe vers le bon projet :

# Set your active project
gcloud config set project YOUR_PROJECT_ID

# Verify the setting
gcloud config list project

Activer les API Foundation

Les serveurs MCP gérés nécessitent que l'API du produit sous-jacent et l'interface MCP soient activées. Exécutez la commande suivante pour activer le backend Cloud Logging (notre référence pour cet atelier) :

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

Remarque : Les services MCP gérés sont actuellement en bêta. Vous devez utiliser le composant gcloud beta pour les activer.

Configurer les identifiants par défaut de l'application (ADC)

Gemini CLI utilise votre identité d'utilisateur pour communiquer avec les serveurs MCP. Accordez à l'agent l'autorisation d'agir en votre nom :

gcloud auth application-default login

Suivez l'URL dans le terminal, connectez-vous, puis collez le code d'autorisation dans Cloud Shell.

Attribuer des rôles IAM de base

Les serveurs MCP gérés utilisent un modèle de sécurité à double niveau. Deux "portails" spécifiques doivent être ouverts :

Portail 1 (accès MCP) : rôle qui vous permet d'appeler le protocole.
Étape 2 (Accès au service) : rôle qui vous permet de consulter les données (par exemple, les journaux).

Exécutez la commande suivante pour vous accorder l'accès requis :

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. Bases : connecter votre premier serveur MCP

Au cours de cette étape, vous allez associer votre agent d'IA (Gemini CLI) au serveur MCP Google Cloud Logging. Il s'agit de notre "base", car il permet à l'agent de voir ce qui se passe dans votre projet en temps réel.

Tâche 1 : Configurer le serveur MCP de journalisation

Gemini CLI utilise un fichier settings.json pour gérer ses connexions. Vous devrez modifier ce fichier (présent dans le dossier ~/.gemini) pour ajouter l'extrait suivant dans le bloc mcpServers. Remplacez YOUR_PROJECT_ID par l'ID de votre projet :

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

Remarque : L'en-tête x-goog-user-project est obligatoire pour les serveurs MCP gérés. Il permet de s'assurer que l'utilisation de l'API et la facturation sont correctement attribuées à votre projet.

Tâche 2 : Simuler l'activité du projet (créer des journaux)

Si votre projet est nouveau ou inactif, il est possible qu'il ne contienne aucun journal "intéressant" récent. Utilisons la CLI gcloud pour injecter quelques entrées personnalisées afin que l'agent ait quelque chose à trouver.

Exécutez ces commandes une par une pour simuler une séquence d'événements :

# 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

Tâche 3 : Vérifier les outils dans Gemini CLI

Avant de commencer à discuter, vérifions que l'agent peut "voir" les outils exposés par le serveur de journalisation. Lancez la Gemini CLI :

gemini

Une fois dans l'invite Gemini CLI (>), exécutez la commande list :

/mcp list

Point de contrôle de la validation : logging-mcp doit être indiqué comme Prêt avec environ six outils disponibles, y compris list_log_entries.

Tâche 4 : Votre première requête d'infrastructure en direct

Demandons maintenant à l'agent de trouver les journaux que nous venons de créer. Comme vous avez attribué le rôle roles/logging.viewer précédemment, l'agent peut désormais "contacter" et lire l'état de votre projet.

Saisissez le prompt suivant dans 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?

Observer l'agent :

L'agent peut vous demander l'ID du projet Google Cloud. Veuillez nous le fournir.
Il identifiera qu'il a besoin de l'outil list_log_entries.
Vous serez invité à autoriser l'exécution de l'outil. Sélectionnez 1. Oui, autoriser une seule fois.
Il analysera la réponse JSON et vous informera de l'erreur Cloud SQL Permission Denied que nous avons simulée.

4. Parcours A : Le cerveau (MCP sur les connaissances des développeurs)

Dans ce parcours, vous allez donner un "cerveau" à votre agent en le connectant au serveur MCP Google Developer Knowledge.

L'un des plus grands risques avec les agents IA est l'hallucination, qui consiste à fournir des commandes CLI obsolètes ou des paramètres d'API abandonnés avec assurance. Ce serveur MCP résout ce problème en ancrant l'agent dans le corpus de documentation pour les développeurs officiel et en direct de Google (qui couvre Google Cloud, Firebase, Android et plus encore).

Tâche 1 : Activer les services de connaissances

Comme pour l'étape de base, nous devons activer à la fois l'API de backend et le point de terminaison du service 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

Tâche 2 : Provisionner une clé API restreinte

Le MCP Developer Knowledge utilise des clés API pour l'authentification. Pour des raisons de sécurité, nous allons créer une clé et la restreindre afin qu'elle ne puisse être utilisée qu'avec cette API spécifique.

Exécutez le script suivant pour créer et récupérer votre clé :

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

Copiez la longue chaîne de caractères renvoyée par la deuxième commande. C'est votre YOUR_API_KEY.

Tâche 3 : Configurer Gemini CLI

Enregistrez maintenant le serveur MCP Knowledge auprès de votre agent. Cela permet à l'agent de rechercher dans la documentation officielle chaque fois qu'il rencontre une question technique à laquelle il ne peut pas répondre avec certitude.

Ajoutez l'extrait suivant dans la section "mcpServers" de votre fichier ~/.gemini/settings.json, en remplaçant YOUR_API_KEY par la chaîne que vous venez de copier :

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

Tâche 4 : Test anti-hallucination

Vérifions que l'agent "effectue des recherches" au lieu de "deviner".

Lancez Gemini CLI :

gemini

Vérifiez que le serveur est prêt : saisissez /mcp list. Vous devriez voir google-developer-knowledge avec deux outils (search_documents et get_document).

Requête : Demandez à l'agent de trouver une commande moderne spécifique.

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.

Éléments à prendre en compte :

Gemini vous demandera l'autorisation d'utiliser search_documents.
Il appellera ensuite probablement get_document pour lire la page spécifique qu'il a trouvée.
La réponse finale doit inclure une commande gcloud storage buckets create ..., citée directement à partir de la documentation.

5. Parcours B : le triage (dépannage autonome)

Prérequis : vous devez avoir terminé le Parcours A : Le cerveau pour que l'agent puisse rechercher des solutions.

Dans ce parcours, vous allez combiner les yeux (MCP Cloud Logging) et le cerveau (MCP Developer Knowledge) de votre agent pour créer une boucle de dépannage autonome.

Au lieu de copier manuellement les codes d'erreur dans un moteur de recherche, vous pouvez simplement demander à l'agent d'analyser votre projet pour détecter les erreurs, de rechercher la solution officielle et de générer un rapport de correction exploitable.

Tâche 1 : Simuler une "mauvaise journée" dans GCP

Pour illustrer la puissance du dépannage autonome, nous avons besoin d'un ensemble réaliste de défaillances. Nous allons utiliser un script Python pour injecter directement dans vos journaux divers obstacles liés à l'infrastructure, allant des erreurs d'autorisation refusée aux problèmes de quota.

Dans Cloud Shell, créez un dossier de votre choix et accédez-y.
Créez un fichier nommé simulate_errors.py :

nano simulate_errors.py

Collez le code suivant dans l'éditeur :

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)

Appuyez sur Ctrl+O, Entrée, puis Ctrl+X pour enregistrer et quitter.
Installez la bibliothèque Google Cloud Logging et exécutez le script :

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)

Tâche 2 : Exécuter la boucle autonome

Nous allons maintenant envoyer un prompt complexe qui demande à Gemini d'orchestrer les deux serveurs MCP simultanément.

Lancez Gemini CLI :

gemini

Saisissez cette "requête principale" dans l'agent :

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

Que se passe-t-il ensuite ?

Vous regardez actuellement un workflow agentique en temps réel. L'agent :

Appelez list_log_entries pour voir le "mauvais jour" que nous venons de simuler.
Analysez le texte pour identifier les échecs de GCS, Cloud Run et Secret Manager.
Appelez search_documents et get_document pour chacun de ces services afin de trouver les rôles IAM ou les corrections de configuration appropriés.
Vous verrez un tableau structuré semblable à celui-ci (les recommandations peuvent varier) :

Service	Récapitulatif des erreurs	Correction recommandée
Cloud Storage	Erreur 403 Accès interdit lors de l'importation	Accordez `roles/storage.objectCreator` au compte de service.
Cloud Run	Échec de l'écoute sur le port 8080	Assurez-vous que l'application se lie à 0.0.0.0 sur le port défini par `$PORT`.
Secret Manager	Rôle d'accès à la version manquant	Attribuez `roles/secretmanager.secretAccessor` à l'identité.

6. Parcours C : Les données (MCP Firestore)

Dans ce parcours, vous allez utiliser le serveur MCP Firestore pour gérer une base de données de documents NoSQL en langage naturel.

Firestore est une base de données flexible et évolutive, mais sa gestion nécessite souvent d'écrire du code SDK complexe ou de parcourir la console. Avec MCP, votre agent devient un administrateur de base de données, capable d'amorcer des données, d'interroger des enregistrements et même d'effectuer des migrations de schéma complexes via le chat.

Tâche 1 : Activer les services Firestore

Tout d'abord, activez l'API Firestore et son point de terminaison MCP correspondant.

# 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

Tâche 2 : Attribuer des rôles IAM Firestore

Pour exécuter des requêtes, votre identité doit disposer d'autorisations spécifiques en plus de l'accès MCP de base.

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

Tâche 3 : Créer une base de données de test dédiée

Pour que nos expériences soient sécurisées, nous allons créer une base de données Firestore dédiée nommée mcp-lab-db.

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

Tâche 4 : Configurer Gemini CLI

Ajoutez le serveur MCP Firestore à votre agent. Ajoutez la configuration suivante à la section "mcpServers" du fichier ~/.gemini/settings.json. Remplacez YOUR_PROJECT_ID par l'ID de votre projet :

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

Tâche 5 : Opérations de base de données en langage naturel

Lancez Gemini CLI et effectuez quelques opérations de base pour vérifier la connexion.

Lancez Gemini CLI :

gemini

Vérifiez que le serveur est prêt : saisissez /mcp list. Vous devriez voir firestore-mcp avec plusieurs outils (add_document, create_database, list_documents, etc).

Essayez ces requêtes dans l'ordre :

Données de départ :

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

Valider :

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

Essayez d'autres requêtes qui vous aident à gérer les bases de données et les collections Firestore en langage naturel.

7. Parcours D : Intelligence (BigQuery et Maps)

Dans ce parcours, vous allez permettre à votre agent d'analyser des pétaoctets de données et de comprendre le monde physique à l'aide des serveurs MCP BigQuery et Maps Grounding Lite.

À la fin de cette section, votre agent sera en mesure de traduire le langage naturel en requêtes SQL complexes et de fournir des conseils géospatiaux contextualisés (comme les temps de trajet et la météo) pour ancrer ses réponses dans la réalité.

Tâche 1 : Activer les services d'intelligence

Activez les API et les interfaces MCP pour BigQuery et 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

Tâche 2 : Attribuer des rôles IAM BigQuery

Pour exécuter des requêtes, votre identité doit disposer d'autorisations spécifiques en plus de l'accès MCP de base.

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

Tâche 3 : Provisionner une clé API Maps

Contrairement aux autres services qui s'appuient uniquement sur IAM, le serveur Maps Grounding Lite nécessite une clé API pour le quota et la facturation.

Créez la clé :

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

Récupérez la chaîne de clé :

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

Copiez la chaîne de clé pour l'étape suivante.

Tâche 4 : Configurer Gemini CLI

Enregistrez maintenant les deux serveurs. Ajoutez les extraits ci-dessous à la section mcpServers du fichier ~/.gemini/settings.json. Remplacez YOUR_PROJECT_ID et YOUR_MAPS_API_KEY par les valeurs correspondantes.

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

Tâche 5 : L'intelligence en action

Lancez Gemini CLI et testez les nouvelles fonctionnalités d'intelligence.

gemini

Vérifiez que le serveur est prêt : saisissez /mcp list. Vous devriez voir bigquery-mcp et maps-grounding-lite-mcp avec plusieurs outils listés. .

Scénario 1 : Le moteur analytique (BigQuery) Demandez à l'agent d'interroger un ensemble de données public sans que vous connaissiez le langage SQL :

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

Scénario 2 : Contexte géospatial (Maps) Demandez à l'agent de planifier un voyage dans le monde réel :

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?

Éléments à prendre en compte :

Pour BigQuery, l'agent appellera execute_sql pour découvrir le schéma et exécuter la requête.
Pour Maps, il orchestrera lookup_weather et compute_routes pour vous proposer un plan de voyage ancré et utile.

8. Renforcement : sécurité et IAM en production

Dans cette dernière étape, vous passerez d'autorisations "Propriétaire" générales à un modèle de défense en profondeur de niveau production.

Les agents IA sont "utiles" par nature. Si vous limitez un outil au niveau de l'UI, un agent intelligent peut tenter de contourner cette restriction en exécutant une commande shell à la place. Pour sécuriser réellement votre infrastructure, vous devez créer des limites strictes à l'aide de Google Cloud IAM.

Modèle de sécurité à double couche

Pour exécuter une action, un agent doit passer par deux étapes :

Étape 1 (la passerelle MCP) : l'identité dispose-t-elle de roles/mcp.toolUser ? (Autorisation d'utiliser le protocole)
Portail 2 (portail de service) : l'identité dispose-t-elle du rôle de produit spécifique (par exemple, roles/datastore.viewer) ? (Autorisation d'afficher les données)

Tâche 1 : Filtrage côté client de niveau 1 (`excludeTools`)

La première ligne de défense consiste à masquer les outils à l'agent pour qu'il ne pense même pas à les utiliser.

Ouvrez vos paramètres Gemini CLI dans l'éditeur Cloud Shell :

cloudshell edit ~/.gemini/settings.json

Recherchez le bloc firestore-mcp et ajoutez la directive excludeTools pour masquer les actions destructrices :

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

Enregistrez le fichier et redémarrez Gemini CLI. Exécutez /mcp list et remarquez que ces outils ont disparu.

Tâche 2 : Niveau 2 – Suprématie de l'infrastructure (le videur IAM)

Le filtrage côté client est une mesure de protection "souple". Si vous demandez à l'agent de "Supprimer ma base de données Firestore" et que l'outil est masqué, il peut essayer d'exécuter gcloud firestore databases delete. Pour éviter cela, nous utilisons un compte de service basé sur le principe du moindre privilège.

Créez un compte de service "Lecteur uniquement" :

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

Générez et activez la clé :

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

Tâche 3 : Test Bouncer de l'"agent utile"

Testons maintenant si l'agent peut contourner notre sécurité.

La première étape consiste à activer le compte de service afin que, même si l'agent revient à l'utilisation de la commande gcloud, il fonctionne sous l'identité du compte de service que nous venons de créer.

Activez le compte de service :

Exécutez la commande suivante en remplaçant [PATH_TO_KEY_FILE] par le chemin d'accès réel à votre fichier de clé JSON (par exemple, reader-key.json).

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

Vérifiez la modification :

Après avoir exécuté la commande, vous pouvez vérifier que le compte de service est actif en exécutant la commande suivante :

gcloud auth list

Le résultat affichera le compte de service comme identifiant actif.

Lancez Gemini CLI :

gemini

Saisissez cette requête :

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

Que se passe-t-il ?

L'agent tentera d'abord d'utiliser l'outil delete_database dans le serveur MCP Firestore. Il échouera en raison du manque d'autorisation.
Il tente ensuite d'être "utile" en revenant à l'outil run_shell_command pour utiliser la commande gcloud firestore.

Résultat :

La commande échoue et renvoie une erreur "Interdit". Comme l'agent s'exécute sous l'identité mcp-reader-sa, il ne dispose pas de l'autorisation datastore.databases.delete. IAM est la solution de dernier recours. Quelle que soit la manière dont l'agent tente d'accéder à la ressource, le "bouncer" au niveau de l'API Google Cloud bloquera la requête.

Repassez à votre compte utilisateur :

Pour revenir à votre compte utilisateur, exécutez la commande suivante :

gcloud config set account YOUR_EMAIL_ADDRESS

9. Nettoyage

Pour éviter des frais inutiles, supprimez vos ressources de test :

# 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. Conclusion

Félicitations ! Vous avez parcouru l'intégralité de la pile des serveurs MCP gérés par Google.

Vous avez commencé par le "tronc" de l'atelier, en établissant une connexion de base à Cloud Logging. Vous avez ensuite créé des "Aventures" modulaires pour ancrer les connaissances de votre agent, automatiser des boucles de dépannage complexes, migrer des données dans Firestore et extraire des renseignements de BigQuery et Maps.

Et surtout, vous avez terminé en ancrant votre agent dans les racines de la sécurité de production. Vous avez prouvé qu'un agent peut être "utile" à l'excès, mais que Google Cloud IAM est le videur ultime, garantissant que vos workflows autonomes respectent toujours le principe du moindre privilège.

Points clés à retenir

Géré = évolutif : vous vous êtes connecté à des outils au niveau de l'infrastructure via Streamable HTTP sans déployer un seul serveur.
L'ancrage est obligatoire : vous avez remplacé les "suppositions" du LLM par le MCP des connaissances du développeur, ce qui garantit que votre agent utilise des commandes actuelles et valides.
L'orchestration est une force : vous avez vu que la véritable magie opère lorsqu'un agent combine plusieurs serveurs MCP pour résoudre un seul problème commercial.

Premiers pas avec les serveurs MCP Google

1. Introduction

L'avantage des comptes gérés

Points abordés

Prérequis

Problèmes concernant les rapports

2. Avant de commencer

Activer Cloud Shell

Définir votre ID de projet

Activer les API Foundation

Configurer les identifiants par défaut de l'application (ADC)

Attribuer des rôles IAM de base

3. Bases : connecter votre premier serveur MCP

Tâche 1 : Configurer le serveur MCP de journalisation

Tâche 2 : Simuler l'activité du projet (créer des journaux)

Tâche 3 : Vérifier les outils dans Gemini CLI

Tâche 4 : Votre première requête d'infrastructure en direct

4. Parcours A : Le cerveau (MCP sur les connaissances des développeurs)

Tâche 1 : Activer les services de connaissances

Tâche 2 : Provisionner une clé API restreinte

Tâche 3 : Configurer Gemini CLI

Tâche 4 : Test anti-hallucination

5. Parcours B : le triage (dépannage autonome)

Tâche 1 : Simuler une "mauvaise journée" dans GCP

Tâche 2 : Exécuter la boucle autonome

6. Parcours C : Les données (MCP Firestore)

Tâche 1 : Activer les services Firestore

Tâche 2 : Attribuer des rôles IAM Firestore

Tâche 3 : Créer une base de données de test dédiée

Tâche 4 : Configurer Gemini CLI

Tâche 5 : Opérations de base de données en langage naturel

7. Parcours D : Intelligence (BigQuery et Maps)

Tâche 1 : Activer les services d'intelligence

Tâche 2 : Attribuer des rôles IAM BigQuery

Tâche 3 : Provisionner une clé API Maps

Tâche 4 : Configurer Gemini CLI

Tâche 5 : L'intelligence en action

8. Renforcement : sécurité et IAM en production

Modèle de sécurité à double couche

Tâche 1 : Filtrage côté client de niveau 1 (excludeTools)

Tâche 2 : Niveau 2 – Suprématie de l'infrastructure (le videur IAM)

Tâche 3 : Test Bouncer de l'"agent utile"

9. Nettoyage

10. Conclusion

Points clés à retenir

Tâche 1 : Filtrage côté client de niveau 1 (`excludeTools`)