Come eseguire il deployment di un server MCP sicuro su Cloud Run

1. Introduzione

Panoramica

In questo lab creerai e implementerai un server Model Context Protocol (MCP). I server MCP sono utili per fornire agli LLM l'accesso a strumenti e servizi esterni. Lo configurerai come servizio sicuro e pronto per la produzione su Cloud Run, a cui è possibile accedere da più client. Dopodiché, ti connetterai al server MCP remoto dalla CLI Antigravity.

In questo lab proverai a:

Utilizzeremo FastMCP per creare un server MCP dello zoo con due strumenti: get_animals_by_species e get_animal_details. FastMCP offre un modo rapido e Pythonico per creare server e client MCP.

Grafico del server MCP dello zoo

Obiettivi didattici

  • Esegui il deployment del server MCP su Cloud Run.
  • Proteggi l'endpoint del server richiedendo l'autenticazione per tutte le richieste, assicurandoti che solo i client e gli agenti autorizzati possano comunicare con esso.
  • Connettiti all'endpoint del server MCP sicuro da Antigravity CLI

Prerequisiti

  • Familiarità con Python e le interfacce a riga di comando.
  • Accesso a un progetto Google Cloud con la fatturazione abilitata.
  • Strumenti CLI installati: gcloud, uv, agy.

2. Configurazione del progetto

  1. Se non hai ancora un Account Google, devi crearne uno.
    • Utilizza un account personale anziché un account di lavoro o della scuola. Gli account di lavoro e della scuola potrebbero avere limitazioni che impediscono l'attivazione delle API necessarie per questo lab.
  2. Accedi alla console Google Cloud.
  3. Crea un nuovo progetto o scegli di riutilizzarne uno esistente.
    • Se visualizzi un errore relativo alla quota del progetto, riutilizza un progetto esistente o eliminalo per crearne uno nuovo.

3. Apri editor di Cloud Shell

  1. Fai clic su questo link per andare direttamente all'editor di Cloud Shell.
  2. Se ti viene richiesto di concedere l'autorizzazione in qualsiasi momento della giornata, fai clic su Autorizza per continuare. Fai clic per autorizzare Cloud Shell
  3. Se il terminale non viene visualizzato nella parte inferiore dello schermo, aprilo:
    • Fai clic su Visualizza.
    • Fai clic su TerminaleApri un nuovo terminale nell'editor di Cloud Shell.
  4. Nel terminale, imposta il tuo progetto con questo comando:
    • Formato:
      gcloud config set project [PROJECT_ID]
    • Esempio:
      gcloud config set project lab-project-id-example
    • Se non ricordi l'ID progetto:
      • Puoi elencare tutti gli ID progetto con:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
      Imposta l'ID progetto nel terminale dell'editor di Cloud Shell
  5. Dovresti visualizzare questo messaggio:
    Updated property [core/project].
    Se visualizzi un WARNING e ti viene chiesto Do you want to continue (Y/n)?, probabilmente hai inserito l'ID progetto in modo errato. Premi n, premi Enter e prova a eseguire di nuovo il comando gcloud config set project.

4. Abilita API

Nel terminale, imposta la variabile del progetto e abilita le API:

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

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

Se ti viene richiesto di concedere l'autorizzazione, fai clic su Autorizza per continuare. Fai clic per autorizzare Cloud Shell

Il completamento di questo comando potrebbe richiedere alcuni minuti, ma alla fine dovrebbe essere visualizzato un messaggio di operazione riuscita simile a questo:

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

5. Prepara il progetto Python

  1. Crea una cartella denominata mcp-on-cloudrun per archiviare il codice sorgente per il deployment:
    mkdir mcp-on-cloudrun && cd mcp-on-cloudrun
  2. Crea un progetto Python con lo strumento uv per generare un file pyproject.toml:
    uv init --description "Example of deploying an MCP server on Cloud Run" --bare --python 3.13
    Il comando uv init crea un file pyproject.toml per il tuo progetto.Per visualizzare i contenuti del file, esegui questo comando:
    cat pyproject.toml
    L'output dovrebbe essere simile al seguente:
    [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. Crea il server MCP dello zoo

Per fornire un contesto prezioso per migliorare l'utilizzo degli LLM con MCP, configura un server MCP dello zoo con FastMCP, un framework standard per lavorare con il Model Context Protocol. FastMCP offre un modo rapido per creare server e client MCP con Python. Questo server MCP fornisce dati sugli animali di uno zoo fittizio. Per semplicità, archiviamo i dati in memoria. Per un server MCP di produzione, probabilmente vorrai fornire dati da origini come database o API.

  1. Esegui questo comando per aggiungere FastMCP come dipendenza nel file pyproject.toml:
    uv add fastmcp==2.12.4 --no-sync
    In questo modo, al progetto verrà aggiunto un file uv.lock.
  2. Crea e apri un nuovo file server.py per il codice sorgente del server MCP:
    cloudshell edit ~/mcp-on-cloudrun/server.py
    Il comando cloudshell edit aprirà il file server.py nell'editor sopra il terminale.
  3. Aggiungi il seguente codice sorgente del server MCP dello zoo al file 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,
        )
    )

Il tuo codice è stato completato. È il momento di eseguire il deployment del server MCP su Cloud Run.

7. Deployment in Cloud Run

Ora esegui il deployment di un server MCP su Cloud Run direttamente dal codice sorgente.

  1. Crea e apri un nuovo Dockerfile per il deployment in Cloud Run:
    cloudshell edit ~/mcp-on-cloudrun/Dockerfile
  2. Includi il seguente codice nel Dockerfile per utilizzare lo strumento uv per eseguire il file 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"]
  3. Crea un account di servizio denominato mcp-server-sa:
    gcloud iam service-accounts create mcp-server-sa --display-name="MCP Server Service Account"
  4. Esegui il comando gcloud per eseguire il deployment dell'applicazione in 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
    Utilizza il flag --no-allow-unauthenticated per richiedere l'autenticazione. Questo è importante per motivi di sicurezza. Se non richiedi l'autenticazione, chiunque può chiamare il tuo server MCP e potenzialmente causare danni al tuo sistema.
  5. Conferma la creazione di un nuovo repository Artifact Registry. Poiché è la prima volta che esegui il deployment in Cloud Run dal codice sorgente, vedrai:
    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)?
    Digita Y e premi Enter per creare un repository Artifact Registry per il deployment. Questo è necessario per archiviare il container Docker del server MCP per il servizio Cloud Run.
  6. Dopo alcuni minuti, vedrai un messaggio simile a questo:
    Service [zoo-mcp-server] revision [zoo-mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.

Hai eseguito il deployment del server MCP. Ora puoi usarlo.

8. Aggiungi il server MCP remoto alla CLI Antigravity

Ora che hai eseguito il deployment di un server MCP remoto, puoi connetterti utilizzando varie applicazioni come Google Code Assist o Antigravity CLI. In questa sezione, stabiliremo una connessione al nuovo server MCP remoto utilizzando Antigravity CLI.

  1. Concedere al tuo account utente l'autorizzazione a chiamare il server MCP remoto
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member=user:$(gcloud config get-value account) \
    --role='roles/run.invoker'
  2. Salva le credenziali Google Cloud e il numero di progetto nelle variabili di ambiente da utilizzare nel file delle impostazioni di Antigravity:
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)
  3. Crea una cartella .gemini/antigravity-cli se non è già stata creata.
    mkdir -p ~/.gemini/antigravity-cli
  4. Scrivi il server MCP remoto nel file di configurazione MCP della CLI 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
  5. Avvia Antigravity CLI:
    agy
  1. Esegui l'autenticazione con Antigravity CLI: durante l'avvio iniziale, è richiesta l'autenticazione. Seleziona OAuth (premendo Enter).Schermata di autenticazione Antigravity
  2. Fai clic sul link (se non è selezionabile, evidenzia l'URL in Cloud Shell per copiarlo, poi incollalo nel browser).
  3. Accedi al tuo Account Google
  4. Copiare il codice
  5. Incolla il codice nel terminale dell'editor di Cloud Shell
  6. Premi Enter.Prompt del codice di sicurezza di Antigravity
  7. Premi Enter per accettare alcune impostazioni predefinite.
  8. Chiedere ad Antigravity CLI di elencare gli strumenti MCP disponibili nel suo contesto
    /mcp
    Premi ESC per tornare al campo del prompt.
  9. Chiedi ad Antigravity CLI di trovare qualcosa nello zoo
    Where can I find penguins?
    La CLI Antigravity dovrebbe sapere di utilizzare il server MCP zoo-remote e ti chiederà se vuoi consentire l'esecuzione di MCP.
  10. Utilizza la Freccia giù, quindi premi Enter per selezionare.
    Yes, always allow all tools from server "zoo-remote"
    Antigravity CLI allow zoo remote tools

L'output deve mostrare la risposta corretta e una casella di visualizzazione che indica che è stato utilizzato il server MCP.

Antigravity CLI show zoo mcp server result

Ce l'hai fatta. Hai eseguito correttamente il deployment di un server MCP remoto in Cloud Run e lo hai testato utilizzando l'interfaccia a riga di comando Antigravity.

Quando è tutto pronto per terminare la sessione, digita /exit e poi premi Enter per uscire da Antigravity CLI.

Debug

Se visualizzi un errore come questo:

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

È probabile che il token ID sia scaduto e richieda di impostare nuovamente ID_TOKEN.

  1. Digita /exit e poi premi Enter per uscire da Antigravity CLI.
  2. Imposta il progetto nel terminale 
    gcloud config set project [PROJECT_ID]
  3. Esegui di nuovo il comando delle credenziali Google Cloud per ottenere un nuovo ID_TOKEN, poiché il tuo potrebbe essere scaduto, e riscrivi il file di configurazione: 
    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. (Facoltativo) Verifica le chiamate agli strumenti nei log del server

Per verificare che il server MCP Cloud Run sia stato chiamato, controlla i log del servizio.

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

Dovresti visualizzare un log di output che conferma che è stata effettuata una chiamata allo strumento. 🛠️

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. (Facoltativo) Aggiungi il prompt MCP al server

Un prompt MCP può velocizzare il flusso di lavoro per i prompt che esegui spesso creando un'abbreviazione per un prompt più lungo.

Antigravity CLI converte automaticamente i prompt MCP in comandi slash personalizzati, in modo da poter richiamare un prompt MCP digitando /prompt_name, dove prompt_name è il nome del prompt MCP.

Crea un prompt MCP per trovare rapidamente un animale nello zoo digitando /find animal nella CLI Antigravity.

  1. Aggiungi questo codice al file server.py sopra la guardia 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."
    )
  2. Esegui di nuovo il deployment dell'applicazione in Cloud Run 
    gcloud run deploy zoo-mcp-server \
    --region=us-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
  3. Aggiorna ID_TOKEN e ricrea il file di configurazione: 
    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
  4. Dopo aver eseguito il deployment della nuova versione dell'applicazione, avvia Antigravity CLI. 
    agy
  5. Nel prompt, utilizza il nuovo comando personalizzato che hai creato: 
    /find lions

Dovresti vedere che Antigravity CLI chiama lo strumento get_animals_by_species e formatta la risposta come indicato dal 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. (Facoltativo) Utilizza Gemini Flash Lite per risposte più rapide

La CLI Antigravity ti consente di scegliere il modello e lo sforzo che stai utilizzando.

Poiché le richieste relative alla ricerca degli animali dello zoo non richiedono pensiero o ragionamento, prova ad accelerare le cose utilizzando un modello più veloce.

Nella sezione precedente hai creato un prompt MCP per trovare rapidamente un animale nello zoo digitando /find animal nell'interfaccia a riga di comando di Antigravity.

  1. Dopo aver eseguito il deployment della nuova versione dell'applicazione, avvia Antigravity CLI. 
    agy --model=gemini-3.5-flash --effort=low
  2. Nel prompt, utilizza il nuovo comando personalizzato che hai creato: 
    /find lions

Dovresti comunque vedere che Antigravity CLI chiama lo strumento get_animals_by_species e formatta la risposta come indicato dal prompt MCP, ma la risposta dovrebbe apparire molto più velocemente.

╭───────────────────────────╮
│  > /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.

Debug

Se visualizzi un errore come questo:

✕ Unknown command: /find lions

Prova a eseguire /mcp e, se restituisce zoo-remote - Disconnected, potresti dover eseguire di nuovo il deployment o eseguire di nuovo i seguenti comandi:

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

Complimenti! Hai eseguito il deployment e la connessione a un server MCP remoto sicuro.

Continua con il lab successivo

Questo lab è il primo di una serie in tre parti. Nel secondo lab utilizzerai il server MCP che hai creato con un agente ADK.

Utilizzare un server MCP su Cloud Run con un agente ADK

(Facoltativo) Liberare spazio

Se non continui con il lab successivo e vuoi liberare spazio da ciò che hai creato, puoi eliminare il tuo progetto Cloud per evitare addebiti aggiuntivi.

Sebbene non siano previsti addebiti per Cloud Run quando il servizio non è in uso, ti potrebbero comunque essere addebitati i costi di archiviazione dell'immagine container in Artifact Registry. L'eliminazione del progetto Cloud interrompe la fatturazione per tutte le risorse utilizzate al suo interno.

Se vuoi, elimina il progetto:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Potresti anche voler eliminare le risorse non necessarie dal disco Cloud Shell. Puoi:

  1. Elimina la directory del progetto del codelab: 
    rm -rf ~/mcp-on-cloudrun
  2. Attenzione. La prossima azione non può essere annullata. Se vuoi eliminare tutto ciò che è presente in Cloud Shell per liberare spazio, puoi eliminare l'intera home directory. Fai attenzione che tutto ciò che vuoi conservare sia salvato altrove. 
    sudo rm -rf $HOME