Jak wdrożyć bezpieczny serwer MCP w Cloud Run

1. Wprowadzenie

Przegląd

W tym ćwiczeniu utworzysz i wdrożysz serwer Model Context Protocol (MCP). Serwery MCP są przydatne do zapewniania LLM dostępu do narzędzi i usług zewnętrznych. Skonfigurujesz go jako bezpieczną usługę gotową do wdrożenia w Cloud Run, do której można uzyskać dostęp z wielu klientów. Następnie połączysz się ze zdalnym serwerem MCP z interfejsu wiersza poleceń Gemini.

Jakie zadania wykonasz

Użyjemy FastMCP, aby utworzyć serwer MCP zoo z 2 narzędziami: get_animals_by_species i get_animal_details. FastMCP to szybki sposób na tworzenie serwerów i klientów MCP w Pythonie.

Grafika serwera MCP w Zoo

Czego się nauczysz

  • Wdrażanie serwera MCP w Cloud Run.
  • Zabezpieczanie punktu końcowego serwera przez wymaganie uwierzytelniania wszystkich żądań, aby tylko autoryzowani klienci i agenci mogli się z nim komunikować.
  • Łączenie się z bezpiecznym punktem końcowym serwera MCP z interfejsu wiersza poleceń Gemini.

2. Konfiguracja projektu

  1. Jeśli nie masz jeszcze konta Google, musisz je utworzyć.
    • Użyj konta osobistego zamiast konta służbowego lub szkolnego. Konta służbowe i szkolne mogą mieć ograniczenia, które uniemożliwiają włączenie interfejsów API potrzebnych do tego ćwiczenia.
  2. Zaloguj się w konsoli Google Cloud.
  3. Utwórz nowy projekt lub ponownie użyj istniejącego.
    • Jeśli zobaczysz błąd dotyczący limitu projektu, ponownie użyj istniejącego projektu lub usuń go, aby utworzyć nowy.

3. Otwórz edytor Cloud Shell

  1. Kliknij ten link, aby przejść bezpośrednio do edytora Cloud Shell.
  2. Jeśli w dowolnym momencie pojawi się prośba o autoryzację, kliknij Autoryzuj , aby kontynuować. Kliknij, aby uwierzytelnić się w Cloud Shell
  3. Jeśli terminal nie pojawia się u dołu ekranu, otwórz go:
    • Kliknij Widok.
    • Kliknij TerminalOtwieranie nowego terminala w edytorze Cloud Shell
  4. W terminalu ustaw projekt za pomocą tego polecenia:
    • Format:
      gcloud config set project [PROJECT_ID]
      
    • Przykład:
      gcloud config set project lab-project-id-example
      
    • Jeśli nie pamiętasz identyfikatora projektu:
      • Możesz wyświetlić wszystkie identyfikatory projektów za pomocą tego polecenia:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
        
      Ustawianie identyfikatora projektu w terminalu edytora Cloud Shell
  5. Powinien pojawić się ten komunikat:
    Updated property [core/project].
    
    Jeśli zobaczysz WARNING i pytanie Do you want to continue (Y/n)?, prawdopodobnie wpisano nieprawidłowy identyfikator projektu. Naciśnij n, a potem Enter i spróbuj ponownie uruchomić polecenie gcloud config set project.

4. Włącz interfejsy API

W terminalu włącz interfejsy API:

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

Jeśli pojawi się prośba o autoryzację, kliknij Autoryzuj , aby kontynuować. Kliknij, aby uwierzytelnić się w Cloud Shell

Wykonanie tego polecenia może potrwać kilka minut, ale ostatecznie powinien się pojawić komunikat o powodzeniu podobny do tego:

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

5. Przygotuj projekt w Pythonie

  1. Utwórz folder o nazwie mcp-on-cloudrun, aby przechowywać kod źródłowy do wdrożenia:
    mkdir mcp-on-cloudrun && cd mcp-on-cloudrun
    
  2. Utwórz projekt w Pythonie za pomocą narzędzia uv, aby wygenerować plik pyproject.toml:
    uv init --description "Example of deploying an MCP server on Cloud Run" --bare --python 3.13
    
    Polecenie uv init tworzy plik pyproject.toml dla Twojego projektu.Aby wyświetlić zawartość pliku, uruchom to polecenie:
    cat pyproject.toml
    
    Dane wyjściowe powinny wyglądać tak:
    [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. Utwórz serwer MCP zoo

Aby zapewnić przydatny kontekst do ulepszenia korzystania z LLM z MCP, skonfiguruj serwer MCP zoo za pomocą FastMCP – standardowej platformy do pracy z protokołem Model Context Protocol. FastMCP umożliwia szybkie tworzenie serwerów i klientów MCP w Pythonie. Ten serwer MCP zawiera dane o zwierzętach w fikcyjnym zoo. Dla uproszczenia dane przechowujemy w pamięci. W przypadku serwera MCP w środowisku produkcyjnym prawdopodobnie będziesz chcieć udostępniać dane ze źródeł takich jak bazy danych lub interfejsy API.

  1. Uruchom to polecenie, aby dodać FastMCP jako zależność w pliku pyproject.toml:
    uv add fastmcp==2.12.4 --no-sync
    
    Spowoduje to dodanie do projektu pliku uv.lock.
  2. Utwórz i otwórz nowy plik server.py z kodem źródłowym serwera MCP:
    cloudshell edit ~/mcp-on-cloudrun/server.py
    
    Polecenie cloudshell edit otworzy plik server.py w edytorze nad terminalem.
  3. Dodaj do pliku server.py ten kod źródłowy serwera MCP zoo:
    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,
            )
        )
    

Kod jest gotowy. Możesz teraz wdrożyć serwer MCP w Cloud Run.

7. Wdrażanie w Cloud Run

Teraz wdróż serwer MCP w Cloud Run bezpośrednio z kodu źródłowego.

  1. Utwórz i otwórz nowy plik Dockerfile do wdrożenia w Cloud Run:
    cloudshell edit ~/mcp-on-cloudrun/Dockerfile
    
  2. Dodaj do pliku Dockerfile ten kod, aby użyć narzędzia uv do uruchomienia pliku 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. Utwórz konto usługi o nazwie mcp-server-sa:
    gcloud iam service-accounts create mcp-server-sa --display-name="MCP Server Service Account"
    
  4. Uruchom polecenie gcloud, aby wdrożyć aplikację w 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
    
    Użyj flagi --no-allow-unauthenticated, aby wymagać uwierzytelniania. Jest to ważne ze względów bezpieczeństwa. Jeśli nie będziesz wymagać uwierzytelniania, każdy będzie mógł wywołać Twój serwer MCP i potencjalnie spowodować uszkodzenie systemu.
  5. Potwierdź utworzenie nowego repozytorium Artifact Registry. Ponieważ po raz pierwszy wdrażasz w Cloud Run z kodu źródłowego, zobaczysz:
    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)?
    
    Wpisz Y i naciśnij Enter. Spowoduje to utworzenie repozytorium Artifact Registry na potrzeby wdrożenia. Jest to wymagane do przechowywania kontenera Dockera serwera MCP na potrzeby usługi Cloud Run.
  6. Po kilku minutach zobaczysz komunikat podobny do tego:
    Service [zoo-mcp-server] revision [zoo-mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.
    

Serwer MCP został wdrożony. Możesz teraz z niego korzystać.

8. Dodaj zdalny serwer MCP do interfejsu wiersza poleceń Gemini

Po pomyślnym wdrożeniu zdalnego serwera MCP możesz się z nim połączyć za pomocą różnych aplikacji, takich jak Google Code Assist czy interfejs wiersza poleceń Gemini. W tej sekcji nawiążemy połączenie z nowym zdalnym serwerem MCP za pomocą interfejsu wiersza poleceń Gemini.

  1. Przyznaj kontu użytkownika uprawnienia do wywoływania zdalnego serwera MCP.
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
        --member=user:$(gcloud config get-value account) \
        --role='roles/run.invoker'
    
  2. Zapisz dane logowania do Google Cloud i numer projektu w zmiennych środowiskowych, aby używać ich w pliku ustawień Gemini:
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
    export ID_TOKEN=$(gcloud auth print-identity-token)
    
  3. Utwórz folder .gemini, jeśli nie został jeszcze utworzony.
    mkdir -p ~/.gemini
    
  4. Otwórz plik ustawień interfejsu wiersza poleceń Gemini.
    cloudshell edit ~/.gemini/settings.json
    
  5. Zastąp plik ustawień interfejsu wiersza poleceń Gemini, aby dodać serwer MCP Cloud Run.
    {
        "ide": {
            "hasSeenNudge": true
        },
        "mcpServers": {
            "zoo-remote": {
                "httpUrl": "https://zoo-mcp-server-$PROJECT_NUMBER.us-west1.run.app/mcp",
                "headers": {
                    "Authorization": "Bearer $ID_TOKEN"
                }
            }
        },
        "security": {
            "auth": {
                "selectedType": "cloud-shell"
            }
        }
    }
    
  6. Uruchom interfejs wiersza poleceń Gemini w Cloud Shell.
    gemini
    
    Aby zaakceptować niektóre ustawienia domyślne, może być konieczne naciśnięcie Enter.Widok początkowy interfejsu wiersza poleceń Gemini
  7. Poproś Gemini o wyświetlenie narzędzi MCP dostępnych w jego kontekście.
    /mcp
    
  8. Poproś Gemini o znalezienie czegoś w zoo.
    Where can I find penguins?
    
    Interfejs wiersza poleceń Gemini powinien wiedzieć, że ma użyć serwera MCP zoo-remote, i zapyta, czy chcesz zezwolić na wykonanie MCP.
  9. Użyj strzałki w dół, a potem naciśnij Enter, aby wybrać.
    Yes, always allow all tools from server "zoo-remote"
    
    Zezwalanie interfejsowi wiersza poleceń Gemini na korzystanie z narzędzi zdalnych w Zoo

Dane wyjściowe powinny zawierać prawidłową odpowiedź i pole wskazujące, że użyto serwera MCP.

Wyświetlanie wyników serwera MCP w interfejsie wiersza poleceń Gemini

Udało się! Zdalny serwer MCP został wdrożony w Cloud Run i przetestowany za pomocą interfejsu wiersza poleceń Gemini.

Gdy zechcesz zakończyć sesję, wpisz /quit i naciśnij Enter, aby zamknąć interfejs wiersza poleceń Gemini.

Debugowanie

Jeśli zobaczysz taki błąd:

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

Prawdopodobnie token identyfikatora wygasł i trzeba ponownie ustawić ID_TOKEN.

  1. Wpisz /quit i naciśnij Enter, aby zamknąć interfejs wiersza poleceń Gemini.
  2. Ustaw projekt w terminalu.
    gcloud config set project [PROJECT_ID]
    
  3. Ponownie uruchom polecenie danych logowania do Google Cloud, aby uzyskać nowy ID_TOKEN, ponieważ Twój mógł wygasnąć.
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
    export ID_TOKEN=$(gcloud auth print-identity-token)
    

9. (Opcjonalnie) Sprawdź wywołania narzędzi w logach serwera

Aby sprawdzić, czy wywołano serwer MCP Cloud Run, sprawdź logi usługi.

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

Powinien się pojawić log potwierdzający, że wykonano wywołanie narzędzia. 🛠️

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. (Opcjonalnie) Dodaj prompt MCP do serwera

Prompt MCP może przyspieszyć pracę w przypadku często używanych promptów, tworząc skrót do dłuższego prompta.

Interfejs wiersza poleceń Gemini automatycznie konwertuje prompty MCP na niestandardowe polecenia ukośnikowe, dzięki czemu możesz wywołać prompt MCP, wpisując /prompt_name, gdzie prompt_name to nazwa prompta MCP.

Utwórz prompt MCP, aby szybko znaleźć zwierzę w zoo, wpisując /find animal w interfejsie wiersza poleceń Gemini.

  1. Dodaj ten kod do pliku server.py nad głównym zabezpieczeniem (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. Ponownie wdróż aplikację w Cloud Run.
    gcloud run deploy zoo-mcp-server \
        --region=us-west1 \
        --source=. \
        --labels=dev-tutorial=codelab-mcp
    
  3. Odśwież ID_TOKEN zdalnego serwera MCP.
    export ID_TOKEN=$(gcloud auth print-identity-token)
    
  4. Po wdrożeniu nowej wersji aplikacji uruchom interfejs wiersza poleceń Gemini.
    gemini
    
  5. W prompcie użyj utworzonego niestandardowego polecenia:
    /find lions
    

Powinno się pojawić, że interfejs wiersza poleceń Gemini wywołuje narzędzie get_animals_by_species i formatuje odpowiedź zgodnie z instrukcjami prompta 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. (Opcjonalnie) Użyj Gemini Flash Lite, aby uzyskać szybsze odpowiedzi

Interfejs wiersza poleceń Gemini umożliwia wybór używanego modelu.

  • Gemini 2.5 Pro to najnowocześniejszy model myślący Google, który potrafi rozwiązywać złożone problemy w kodzie, matematyce i STEM, a także analizować duże zbiory danych, bazy kodu i dokumenty za pomocą długiego kontekstu.
  • Gemini 2.5 Flash to najlepszy model Google pod względem stosunku ceny do wydajności, który oferuje wszechstronne możliwości. 2.5 Flash najlepiej sprawdza się w przypadku przetwarzania na dużą skalę, zadań o niskim opóźnieniu i dużej liczbie, które wymagają myślenia, oraz w agentowych przypadkach użycia.
  • Gemini 2.5 Flash Lite to najszybszy model flash firmy Google, zoptymalizowany pod kątem oszczędności i wysokiej przepustowości.

Ponieważ żądania związane ze znajdowaniem zwierząt w zoo nie wymagają myślenia ani rozumowania, spróbuj przyspieszyć działanie, używając szybszego modelu.

W poprzedniej sekcji utworzyliśmy prompt MCP, aby szybko znaleźć zwierzę w zoo, wpisując /find animal w interfejsie wiersza poleceń Gemini.

  1. Po wdrożeniu nowej wersji aplikacji uruchom interfejs wiersza poleceń Gemini.
    gemini --model=gemini-2.5-flash-lite
    
  2. W prompcie użyj utworzonego niestandardowego polecenia:
    /find lions
    

Powinno się nadal pojawiać, że interfejs wiersza poleceń Gemini wywołuje narzędzie get_animals_by_species i formatuje odpowiedź zgodnie z instrukcjami prompta MCP, ale odpowiedź powinna się pojawić znacznie szybciej.

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

Debugowanie

Jeśli zobaczysz taki błąd:

✕ Unknown command: /find lions

Spróbuj uruchomić /mcp. Jeśli pojawi się zoo-remote - Disconnected, może być konieczne ponowne wdrożenie lub ponowne uruchomienie tych poleceń:

 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)

12. Podsumowanie

Gratulacje! Udało Ci się wdrożyć bezpieczny zdalny serwer MCP i połączyć się z nim.

Przejdź do następnego ćwiczenia

To ćwiczenie jest pierwszym z 3 części. W drugim ćwiczeniu użyjesz utworzonego serwera MCP z agentem ADK.

Używanie serwera MCP w Cloud Run z agentem ADK

(Opcjonalnie) Zwalnianie miejsca

Jeśli nie chcesz kontynuować ćwiczenia i chcesz zwalniać miejsce, możesz usunąć projekt w chmurze, aby uniknąć dodatkowych opłat.

Cloud Run nie nalicza opłat, gdy usługa nie jest używana, ale może zostać pobrana należność za przechowywanie obrazu kontenera w Artifact Registry. Usunięcie projektu w chmurze powoduje zaprzestanie naliczania opłat za wszystkie zasoby wykorzystywane w ramach tego projektu.

Jeśli chcesz, usuń projekt:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Możesz też usunąć niepotrzebne zasoby z dysku Cloud Shell. Możesz:

  1. Usuń katalog projektu codelab:
    rm -rf ~/mcp-on-cloudrun
    
  2. Ostrzeżenie! Tej czynności nie można cofnąć. Jeśli chcesz usunąć wszystko w Cloud Shell, aby zwolnić miejsce, możesz usunąć cały katalog domowy. Upewnij się, że wszystkie elementy, które chcesz zachować, są zapisane w innym miejscu.
    sudo rm -rf $HOME