Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Déployer un serveur MCP sécurisé sur Cloud Run

1. Introduction

Présentation

Dans cet atelier, vous allez créer et déployer un serveur Model Context Protocol (MCP). Les serveurs MCP sont utiles pour permettre aux LLM d'accéder à des outils et services externes. Vous allez le configurer en tant que service sécurisé et prêt pour la production sur Cloud Run, accessible depuis plusieurs clients. Vous vous connecterez ensuite au serveur MCP distant depuis l'interface de ligne de commande Antigravity.

Objectifs de l'atelier

Nous allons utiliser FastMCP pour créer un serveur MCP de zoo qui comporte deux outils : get_animals_by_species et get_animal_details. FastMCP fournit un moyen rapide et Pythonique de créer des serveurs et des clients MCP.

Illustration du serveur MCP de zoo

Points abordés

Déployez le serveur MCP sur Cloud Run.
Sécurisez le point de terminaison de votre serveur en exigeant l'authentification pour toutes les requêtes. Ainsi, seuls les clients et agents autorisés pourront communiquer avec lui.
Se connecter au point de terminaison de votre serveur MCP sécurisé depuis la CLI Antigravity

Prérequis

Connaissance de Python et des interfaces de ligne de commande
Un accès à un projet Google Cloud pour lequel la facturation est activée.
Outils CLI installés : gcloud, uv, agy.

2. Configuration du projet

Si vous n'avez pas encore de compte Google, vous devez en créer un.
- Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire. Il est possible que des restrictions s'appliquent aux comptes professionnels et scolaires, ce qui vous empêche d'activer les API nécessaires pour cet atelier.
Connectez-vous à la console Google Cloud.
Créez un projet ou choisissez d'en réutiliser un existant.
- Si une erreur concernant le quota de projet s'affiche, réutilisez un projet existant ou supprimez-en un pour en créer un.

3. Ouvrir l'éditeur Cloud Shell

Cliquez sur ce lien pour accéder directement à l'éditeur Cloud Shell.
Si vous êtes invité à autoriser l'accès à un moment donné aujourd'hui, cliquez sur Autoriser pour continuer.
Si le terminal ne s'affiche pas en bas de l'écran, ouvrez-le :
- Cliquez sur Afficher.
- Cliquez sur Terminal.
Dans le terminal, définissez votre projet avec cette commande :
- Format :
```
gcloud config set project [PROJECT_ID]
```
- Exemple :
```
gcloud config set project lab-project-id-example
```
- Si vous ne vous souvenez pas de l'ID de votre projet :
  - Vous pouvez lister tous vos ID de projet avec la commande suivante :
```
gcloud projects list | awk '/PROJECT_ID/{print $2}'
```
Le message suivant doit s'afficher :
```
Updated property [core/project].
```
Si le message WARNING s'affiche et que vous êtes invité à Do you want to continue (Y/n)?, cela signifie probablement que vous avez saisi l'ID du projet de manière incorrecte. Appuyez sur n, puis sur Enter, et essayez d'exécuter à nouveau la commande gcloud config set project.

4. Activer les API

Dans le terminal, définissez la variable de votre projet et activez les API :

export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)

gcloud services enable \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com

Si vous êtes invité à donner votre autorisation, cliquez sur Autoriser pour continuer. Cliquez pour autoriser Cloud Shell.

L'exécution de cette commande peut prendre quelques minutes, mais un message semblable à celui-ci devrait s'afficher pour vous indiquer que l'opération s'est correctement déroulée :

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.

5. Préparer votre projet Python

Créez un dossier nommé mcp-on-cloudrun pour stocker le code source à déployer :
```
mkdir mcp-on-cloudrun && cd mcp-on-cloudrun
```

Créez un projet Python avec l'outil uv pour générer un fichier pyproject.toml :

uv init --description "Example of deploying an MCP server on Cloud Run" --bare --python 3.13

La commande uv init crée un fichier pyproject.toml pour votre projet.Pour afficher le contenu du fichier, exécutez la commande suivante :

cat pyproject.toml

Le résultat doit se présenter sous la forme suivante :

[project]
name = "mcp-on-cloudrun"
version = "0.1.0"
description = "Example of deploying an MCP server on Cloud Run"
requires-python = ">=3.13"
dependencies = []

6. Créer le serveur MCP du zoo

Pour fournir un contexte utile afin d'améliorer l'utilisation des LLM avec MCP, configurez un serveur MCP de zoo avec FastMCP, un framework standard pour travailler avec le protocole Model Context Protocol. FastMCP permet de créer rapidement des serveurs et des clients MCP avec Python. Ce serveur MCP fournit des données sur les animaux d'un zoo fictif. Par souci de simplicité, nous stockons les données en mémoire. Pour un serveur MCP de production, vous souhaiterez probablement fournir des données provenant de sources telles que des bases de données ou des API.

Exécutez la commande suivante pour ajouter FastMCP en tant que dépendance dans le fichier pyproject.toml :
```
uv add fastmcp==2.12.4 --no-sync
```
Un fichier uv.lock sera ajouté à votre projet.
Créez et ouvrez un fichier server.py pour le code source du serveur MCP :
```
cloudshell edit ~/mcp-on-cloudrun/server.py
```
La commande cloudshell edit ouvre le fichier server.py dans l'éditeur au-dessus du terminal.

Ajoutez le code source du serveur MCP Zoo suivant dans le fichier server.py :

import asyncio
import logging
import os
from typing import List, Dict, Any

from fastmcp import FastMCP

logger = logging.getLogger(__name__)
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)

mcp = FastMCP("Zoo Animal MCP Server 🦁🐧🐻")

# Dictionary of animals at the zoo
ZOO_ANIMALS = [
    {
        "species": "lion",
        "name": "Leo",
        "age": 7,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "lion",
        "name": "Nala",
        "age": 6,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "lion",
        "name": "Simba",
        "age": 3,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "lion",
        "name": "King",
        "age": 8,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "penguin",
        "name": "Waddles",
        "age": 2,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Pip",
        "age": 4,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Skipper",
        "age": 5,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Chilly",
        "age": 3,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Pingu",
        "age": 6,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Noot",
        "age": 1,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "elephant",
        "name": "Ellie",
        "age": 15,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "elephant",
        "name": "Peanut",
        "age": 12,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "elephant",
        "name": "Dumbo",
        "age": 5,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "elephant",
        "name": "Trunkers",
        "age": 10,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "bear",
        "name": "Smokey",
        "age": 10,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "bear",
        "name": "Grizzly",
        "age": 8,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "bear",
        "name": "Barnaby",
        "age": 6,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "bear",
        "name": "Bruin",
        "age": 12,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "giraffe",
        "name": "Gerald",
        "age": 4,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "giraffe",
        "name": "Longneck",
        "age": 5,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "giraffe",
        "name": "Patches",
        "age": 3,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "giraffe",
        "name": "Stretch",
        "age": 6,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Speedy",
        "age": 2,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Dash",
        "age": 3,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Gazelle",
        "age": 4,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Swift",
        "age": 5,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "polar bear",
        "name": "Snowflake",
        "age": 7,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "polar bear",
        "name": "Blizzard",
        "age": 5,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "polar bear",
        "name": "Iceberg",
        "age": 9,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Wally",
        "age": 10,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Tusker",
        "age": 12,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Moby",
        "age": 8,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Flippers",
        "age": 9,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    }
]

@mcp.tool()
def get_animals_by_species(species: str) -> List[Dict[str, Any]]:
    """
    Retrieves all animals of a specific species from the zoo.
    Can also be used to collect the base data for aggregate queries
    of animals of a specific species - like counting the number of penguins
    or finding the oldest lion.

    Args:
        species: The species of the animal (e.g., 'lion', 'penguin').

    Returns:
        A list of dictionaries, where each dictionary represents an animal
        and contains details like name, age, enclosure, and trail.
    """
    logger.info(f">>> 🛠️ Tool: 'get_animals_by_species' called for '{species}'")
    return [animal for animal in ZOO_ANIMALS if animal["species"].lower() == species.lower()]

@mcp.tool()
def get_animal_details(name: str) -> Dict[str, Any]:
    """
    Retrieves the details of a specific animal by its name.

    Args:
        name: The name of the animal.

    Returns:
        A dictionary with the animal's details (species, name, age, enclosure, trail)
        or an empty dictionary if the animal is not found.
    """
    logger.info(f">>> 🛠️ Tool: 'get_animal_details' called for '{name}'")
    for animal in ZOO_ANIMALS:
        if animal["name"].lower() == name.lower():
            return animal
    return {}

if __name__ == "__main__":
    port = int(os.getenv("PORT", 8080))
    logger.info(f"🚀 MCP server started on port {port}")
    asyncio.run(
        mcp.run_async(
            transport="http",
            host="0.0.0.0",
            port=port,
        )
    )

Votre code est terminé ! Il est temps de déployer le serveur MCP sur Cloud Run.

7. Déployer sur Cloud Run

Déployez maintenant un serveur MCP sur Cloud Run directement à partir du code source.

Créez et ouvrez un Dockerfile pour le déploiement sur Cloud Run :
```
cloudshell edit ~/mcp-on-cloudrun/Dockerfile
```

Incluez le code suivant dans le fichier Dockerfile pour utiliser l'outil uv afin d'exécuter le fichier server.py :

# Use the official Python image
FROM python:3.13-slim

# Install uv
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/

# Install the project into /app
COPY . /app
WORKDIR /app

# Allow statements and log messages to immediately appear in the logs
ENV PYTHONUNBUFFERED=1

# Install dependencies
RUN uv sync

EXPOSE $PORT

# Run the FastMCP server
CMD ["uv", "run", "server.py"]

Créez un compte de service nommé mcp-server-sa :

gcloud iam service-accounts create mcp-server-sa --display-name="MCP Server Service Account"

Exécutez la commande gcloud pour déployer l'application sur Cloud Run.
```
cd ~/mcp-on-cloudrun
gcloud run deploy zoo-mcp-server \
    --service-account=mcp-server-sa@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
    --no-allow-unauthenticated \
    --region=us-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
```
Utilisez l'option --no-allow-unauthenticated pour exiger une authentification. C'est important pour des raisons de sécurité. Si vous n'exigez pas d'authentification, n'importe qui peut appeler votre serveur MCP et potentiellement endommager votre système.
Confirmez la création d'un dépôt Artifact Registry. Comme il s'agit de votre premier déploiement sur Cloud Run à partir du code source, vous verrez le message suivant :
```
Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named
[cloud-run-source-deploy] in region [us-west1] will be created.

Do you want to continue (Y/n)?
```
Saisissez Y et appuyez sur Enter. Un dépôt Artifact Registry sera créé pour votre déploiement. Cela est nécessaire pour stocker le conteneur Docker du serveur MCP pour le service Cloud Run.

Au bout de quelques minutes, un message semblable à celui-ci s'affichera :

Service [zoo-mcp-server] revision [zoo-mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.

Vous avez déployé votre serveur MCP. Vous pouvez maintenant l'utiliser.

8. Ajouter le serveur MCP distant à la CLI Antigravity

Maintenant que vous avez déployé un serveur MCP distant, vous pouvez vous y connecter à l'aide de différentes applications, comme Google Code Assist ou Antigravity CLI. Dans cette section, nous allons établir une connexion à votre nouveau serveur MCP distant à l'aide de la CLI Antigravity.

Autorisez votre compte utilisateur à appeler le serveur MCP distant.

gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member=user:$(gcloud config get-value account) \
    --role='roles/run.invoker'

Enregistrez vos identifiants Google Cloud et le numéro de votre projet dans des variables d'environnement à utiliser dans le fichier de paramètres Antigravity :

export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

Créez un dossier .gemini/antigravity-cli s'il n'a pas encore été créé.
```
mkdir -p ~/.gemini/antigravity-cli
```

Écrivez le serveur MCP distant dans votre fichier de configuration MCP de l'interface de ligne de commande Antigravity :

cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF
{
    "mcpServers": {
        "zoo-remote": {
            "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp",
            "headers": {
                "Authorization": "Bearer ${ID_TOKEN}"
            }
        }
    }
}
EOF

Démarrez la CLI Antigravity :
```
agy
```

Authentifiez-vous avec Antigravity CLI : l'authentification est requise lors du démarrage initial. Sélectionnez OAuth (appuyez sur Enter).
Cliquez sur le lien (s'il n'est pas cliquable, mettez en surbrillance l'URL dans Cloud Shell pour la copier, puis collez-la dans votre navigateur).
Connectez-vous à votre compte Google
Copier le code
Collez le code dans le terminal de l'éditeur Cloud Shell.
Appuyez sur Enter.
Appuyez sur Enter pour accepter certains paramètres par défaut.
Demander à la CLI Antigravity de lister les outils MCP disponibles dans son contexte
```
/mcp
```
Appuyez sur ESC pour revenir au champ du prompt.
Demandez à la CLI Antigravity de rechercher un animal dans le zoo
```
Where can I find penguins?
```
La CLI Antigravity devrait reconnaître la nécessité d'utiliser le serveur MCP zoo-remote et vous demander si vous autorisez l'exécution de MCP.
Utilisez la flèche vers le bas, puis appuyez sur Enter pour sélectionner.
```
Yes, always allow all tools from server "zoo-remote"
```

La réponse affichée doit être correcte et être accompagnée d'un encadré indiquant que le serveur MCP a été utilisé.

Résultat de la commande Antigravity CLI show zoo mcp server

Vous avez réussi ! Vous avez déployé un serveur MCP distant sur Cloud Run et l'avez testé à l'aide de l'interface de ligne de commande Antigravity.

Lorsque vous êtes prêt à mettre fin à votre session, saisissez /exit, puis appuyez sur Enter pour quitter la CLI Antigravity.

Débogage

Si une erreur semblable à celle-ci s'affiche :

🔍 Attempting OAuth discovery for 'zoo-remote'...
❌ 'zoo-remote' requires authentication but no OAuth configuration found
Error connecting to MCP server 'zoo-remote': MCP server 'zoo-remote' requires authentication. Please configure OAuth or check server settings.

Il est probable que le jeton d'identité ait expiré et qu'il faille à nouveau définir ID_TOKEN.

Saisissez /exit, puis appuyez sur Enter pour quitter l'interface de ligne de commande Antigravity.
Définir votre projet dans votre terminal
```
gcloud config set project [PROJECT_ID]
```

Exécutez à nouveau la commande d'identifiants Google Cloud pour obtenir un nouveau ID_TOKEN, car le vôtre a peut-être expiré, puis réécrivez votre fichier de configuration :

export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF
{
    "mcpServers": {
        "zoo-remote": {
            "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp",
            "headers": {
                "Authorization": "Bearer ${ID_TOKEN}"
            }
        }
    }
}
EOF

9. (Facultatif) Vérifier les appels d'outils dans les journaux du serveur

Pour vérifier que votre serveur MCP Cloud Run a été appelé, consultez les journaux de service.

gcloud run services logs read zoo-mcp-server --region us-west1 --limit=5

Vous devriez voir un journal de sortie confirmant qu'un appel d'outil a été effectué. 🛠️

2025-08-05 19:50:31 INFO:     169.254.169.126:39444 - "POST /mcp HTTP/1.1" 200 OK
2025-08-05 19:50:31 [INFO]: Processing request of type CallToolRequest
2025-08-05 19:50:31 [INFO]: >>> 🛠️ Tool: 'get_animals_by_species' called for 'penguin'

10. (Facultatif) Ajouter une invite MCP au serveur

Un prompt MCP peut accélérer votre workflow pour les requêtes que vous exécutez souvent en créant un raccourci pour un prompt plus long.

La CLI Antigravity convertit automatiquement les requêtes MCP en commandes slash personnalisées. Vous pouvez ainsi appeler une requête MCP en saisissant /prompt_name, où prompt_name correspond au nom de votre requête MCP.

Créez un prompt MCP pour trouver rapidement un animal dans le zoo en saisissant /find animal dans la CLI Antigravity.

Ajoutez ce code à votre fichier server.py au-dessus de la protection principale (if __name__ == "__main__":).

@mcp.prompt()
def find(animal: str) -> str:
    """
    Find which exhibit and trail a specific animal might be located.
    """

    return (
        f"Please find the exhibit and trail information for {animal} in the zoo. "
        f"Respond with '[animal] can be found in the [exhibit] on the [trail].'"
        f"Example: Penguins can be found in The Arctic Exhibit on the Polar Path."
    )

Redéployer votre application sur Cloud Run

gcloud run deploy zoo-mcp-server \
    --region=us-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp

Actualisez votre ID_TOKEN et recréez le fichier de configuration :

export ID_TOKEN=$(gcloud auth print-identity-token)
export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")

cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF
{
    "mcpServers": {
        "zoo-remote": {
            "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp",
            "headers": {
                "Authorization": "Bearer ${ID_TOKEN}"
            }
        }
    }
}
EOF

Une fois la nouvelle version de votre application déployée, démarrez l'interface de ligne de commande Antigravity.
```
agy
```
Dans le prompt, utilisez la nouvelle commande personnalisée que vous avez créée :
```
/find lions
```

Vous constaterez que la CLI Antigravity appelle l'outil get_animals_by_species et met en forme la réponse conformément aux instructions du prompt MCP.

╭───────────────────────────╮
│  > /find lions            │
╰───────────────────────────╯

 ╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
 │ ✔  get_animals_by_species (zoo-remote MCP Server) get_animals_by_species (zoo-remote MCP Server)  │
 │                                                                                                   │
 │    [{"species":"lion","name":"Leo","age":7,"enclosure":"The Big Cat                               │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Nala","age":6,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Simba","age":3,"enclosure":"The Big Cat                    │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"King","age":8,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah Heights"}]                                                           │
 ╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Lions can be found in The Big Cat Plains on the Savannah Heights.

11. (Facultatif) Utiliser Gemini Flash Lite pour obtenir des réponses plus rapides

L'interface de ligne de commande Antigravity vous permet de choisir le modèle et l'effort que vous utilisez.

Étant donné que les requêtes liées à la recherche des animaux du zoo ne nécessitent pas de réflexion ni de raisonnement, essayez d'accélérer les choses en utilisant un modèle plus rapide.

Dans la section précédente, vous avez créé une invite MCP pour pouvoir trouver rapidement un animal dans le zoo en saisissant /find animal dans l'interface de ligne de commande Antigravity.

Une fois la nouvelle version de votre application déployée, démarrez l'interface de ligne de commande Antigravity.
```
agy --model=gemini-3.5-flash --effort=low
```
Dans le prompt, utilisez la nouvelle commande personnalisée que vous avez créée :
```
/find lions
```

Vous devriez toujours constater que la CLI Antigravity appelle l'outil get_animals_by_species et met en forme la réponse conformément aux instructions du prompt MCP, mais la réponse devrait s'afficher beaucoup plus rapidement.

╭───────────────────────────╮
│  > /find lions            │
╰───────────────────────────╯

 ╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
 │ ✔  get_animals_by_species (zoo-remote MCP Server) get_animals_by_species (zoo-remote MCP Server)  │
 │                                                                                                   │
 │    [{"species":"lion","name":"Leo","age":7,"enclosure":"The Big Cat                               │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Nala","age":6,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Simba","age":3,"enclosure":"The Big Cat                    │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"King","age":8,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah Heights"}]                                                           │
 ╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Lions can be found in The Big Cat Plains on the Savannah Heights.

Débogage

Si une erreur semblable à celle-ci s'affiche :

✕ Unknown command: /find lions

Essayez d'exécuter /mcp. Si la réponse est zoo-remote - Disconnected, vous devrez peut-être redéployer ou exécuter à nouveau les commandes suivantes :

 gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
   --member=user:$(gcloud config get-value account) \
   --role='roles/run.invoker'

export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF
{
   "mcpServers": {
       "zoo-remote": {
           "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp",
           "headers": {
               "Authorization": "Bearer ${ID_TOKEN}"
           }
       }
   }
}
EOF

12. Conclusion

Félicitations ! Vous avez bien déployé un serveur MCP distant sécurisé et vous y êtes connecté.

Passer à l'atelier suivant

Cet atelier est le premier d'une série en trois parties. Dans le deuxième atelier, vous utiliserez le serveur MCP que vous avez créé avec un agent ADK.

Utiliser un serveur MCP sur Cloud Run avec un agent ADK

(Facultatif) Effectuer un nettoyage

Si vous ne passez pas à l'atelier suivant et que vous souhaitez nettoyer ce que vous avez créé, vous pouvez supprimer votre projet Cloud pour éviter que des frais supplémentaires ne soient facturés.

Bien que Cloud Run ne facture pas un service inutilisé, il se peut que des frais vous soient toujours facturés pour le stockage de l'image de conteneur dans Artifact Registry. La suppression de votre projet Cloud arrête la facturation de toutes les ressources utilisées dans ce projet.

Si vous le souhaitez, supprimez le projet :

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Vous pouvez également supprimer les ressources inutiles de votre disque Cloud Shell. Vous pouvez :

Supprimez le répertoire du projet de l'atelier de programmation :
```
rm -rf ~/mcp-on-cloudrun
```
Avertissement ! Cette action est irréversible. Si vous souhaitez supprimer tous les éléments de votre Cloud Shell pour libérer de l'espace, vous pouvez supprimer l'intégralité de votre répertoire d'accueil. Assurez-vous que tout ce que vous souhaitez conserver est enregistré ailleurs.
```
sudo rm -rf $HOME
```