Sicheren MCP-Server in Cloud Run bereitstellen

1. Einführung

Übersicht

In diesem Lab erstellen und stellen Sie einen MCP-Server (Model Context Protocol) bereit. MCP-Server sind nützlich, um LLMs Zugriff auf externe Tools und Dienste zu ermöglichen. Sie konfigurieren ihn als sicheren, produktionsbereiten Dienst in Cloud Run, auf den von mehreren Clients aus zugegriffen werden kann. Anschließend stellen Sie eine Verbindung zum Remote-MCP-Server über die Gemini CLI her.

Aufgaben

Wir verwenden FastMCP, um einen Zoo-MCP-Server mit zwei Tools zu erstellen: get_animals_by_species und get_animal_details. FastMCP bietet eine schnelle, Python-basierte Möglichkeit, MCP-Server und -Clients zu erstellen.

Grafik für MCP-Server für einen Zoo

Lerninhalte

  • MCP-Server in Cloud Run bereitstellen
  • Endpunkt des Servers sichern, indem Sie für alle Anfragen eine Authentifizierung erforderlich machen, damit nur autorisierte Clients und Agenten mit ihm kommunizieren können
  • Verbindung zum sicheren MCP-Serverendpunkt über die Gemini CLI herstellen

2. Projekt einrichten

  1. Wenn Sie noch kein Google-Konto haben, müssen Sie ein Google-Konto erstellen.
    • Verwenden Sie ein privates Konto anstelle eines Arbeits- oder Schulkontos. Bei Arbeits- und Schulkonten können Einschränkungen gelten, die verhindern, dass Sie die für dieses Lab erforderlichen APIs aktivieren.
  2. Melden Sie sich in der Google Cloud Console an.
  3. Abrechnung aktivieren in der Cloud Console.
    • Die Kosten für dieses Lab sollten weniger als 1 $für Cloud-Ressourcen betragen.
    • Am Ende dieses Labs finden Sie eine Anleitung zum Löschen von Ressourcen, um weitere Kosten zu vermeiden.
    • Neue Nutzer können die kostenlose Testversion mit einem Guthaben von 300$ nutzen.
  4. Erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt wieder.
    • Wenn ein Fehler bezüglich des Projektkontingents angezeigt wird, verwenden Sie ein vorhandenes Projekt wieder oder löschen Sie ein vorhandenes Projekt, um ein neues zu erstellen.

3. Cloud Shell-Editor öffnen

  1. Klicken Sie auf diesen Link, um direkt zu Cloud Shell-Editor zu gelangen.
  2. Wenn Sie heute aufgefordert werden, sich zu authentifizieren, klicken Sie auf Autorisieren , um fortzufahren. Klicken Sie, um Cloud Shell zu autorisieren.
  3. Wenn das Terminal unten auf dem Bildschirm nicht angezeigt wird, öffnen Sie es:
    • Klicken Sie auf Anzeigen.
    • Klicken Sie auf TerminalNeues Terminal im Cloud Shell-Editor öffnen
  4. Legen Sie im Terminal Ihr Projekt mit diesem Befehl fest:
    • Format:
      gcloud config set project [PROJECT_ID]
    • Beispiel:
      gcloud config set project lab-project-id-example
    • Wenn Sie sich nicht an Ihre Projekt-ID erinnern können:
      • Sie können alle Ihre Projekt-IDs mit diesem Befehl auflisten:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
      Projekt-ID im Cloud Shell Editor-Terminal festlegen
  5. Es sollte folgende Meldung angezeigt werden:
    Updated property [core/project].
    Wenn Sie eine WARNING sehen und gefragt werden Do you want to continue (Y/n)?, haben Sie die Projekt-ID wahrscheinlich falsch eingegeben. Drücken Sie n, drücken Sie Enter, und versuchen Sie noch einmal, den Befehl gcloud config set project auszuführen.

4. APIs aktivieren

Aktivieren Sie im Terminal die APIs:

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

Wenn Sie aufgefordert werden, sich zu authentifizieren, klicken Sie auf Autorisieren , um fortzufahren. Klicken Sie, um Cloud Shell zu autorisieren.

Die Ausführung dieses Befehls kann einige Minuten dauern. Am Ende sollte jedoch eine Erfolgsmeldung ähnlich dieser angezeigt werden:

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

5. Python-Projekt vorbereiten

  1. Erstellen Sie einen Ordner mit dem Namen mcp-on-cloudrun, um den Quellcode für die Bereitstellung zu speichern:
    mkdir mcp-on-cloudrun && cd mcp-on-cloudrun
  2. Erstellen Sie mit dem Tool uv ein Python-Projekt, um eine pyproject.toml-Datei zu generieren:
    uv init --description "Example of deploying an MCP server on Cloud Run" --bare --python 3.13
    Mit dem Befehl uv init wird eine pyproject.toml-Datei für Ihr Projekt erstellt.Führen Sie Folgendes aus, um den Inhalt der Datei aufzurufen:
    cat pyproject.toml
    Die Ausgabe sollte so aussehen:
    [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. Zoo-MCP-Server erstellen

Um wertvollen Kontext zur Verbesserung der Verwendung von LLMs mit MCP bereitzustellen, richten Sie mit FastMCP einen Zoo-MCP-Server ein. FastMCP ist ein Standard-Framework für die Arbeit mit dem Model Context Protocol. FastMCP bietet eine schnelle Möglichkeit, MCP-Server und -Clients mit Python zu erstellen. Dieser MCP-Server stellt Daten zu Tieren in einem fiktiven Zoo bereit. Zur Vereinfachung speichern wir die Daten im Arbeitsspeicher. Für einen Produktions-MCP-Server sollten Sie Daten aus Quellen wie Datenbanken oder APIs bereitstellen.

  1. Führen Sie den folgenden Befehl aus, um FastMCP als Abhängigkeit in der Datei pyproject.toml hinzuzufügen:
    uv add fastmcp==2.12.4 --no-sync
    Dadurch wird Ihrem Projekt eine uv.lock-Datei hinzugefügt.
  2. Erstellen und öffnen Sie eine neue Datei server.py für den Quellcode des MCP-Servers:
    cloudshell edit ~/mcp-on-cloudrun/server.py
    Mit dem Befehl cloudshell edit wird die Datei server.py im Editor über dem Terminal geöffnet.
  3. Fügen Sie der Datei server.py den folgenden Quellcode des Zoo-MCP-Servers hinzu:
    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,
        )
    )

Ihr Code ist fertig. Jetzt können Sie den MCP-Server in Cloud Run bereitstellen.

7. In Cloud Run bereitstellen

Stellen Sie jetzt einen MCP-Server direkt aus dem Quellcode in Cloud Run bereit.

  1. Erstellen und öffnen Sie eine neue Dockerfile für die Bereitstellung in Cloud Run:
    cloudshell edit ~/mcp-on-cloudrun/Dockerfile
  2. Fügen Sie der Dockerfile den folgenden Code hinzu, um das Tool uv zum Ausführen der Datei server.py zu verwenden:
    # 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. Erstellen Sie ein Dienstkonto mit dem Namen mcp-server-sa:
    gcloud iam service-accounts create mcp-server-sa --display-name="MCP Server Service Account"
  4. Führen Sie den Befehl gcloud aus, um die Anwendung in Cloud Run bereitzustellen.
    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=europe-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
    Verwenden Sie das Flag --no-allow-unauthenticated, um eine Authentifizierung zu erzwingen. Das ist aus Sicherheitsgründen wichtig. Wenn Sie keine Authentifizierung erzwingen, kann jeder Ihren MCP-Server aufrufen und möglicherweise Schäden an Ihrem System verursachen.
  5. Bestätigen Sie die Erstellung eines neuen Artifact Registry-Repositorys. Da Sie zum ersten Mal aus dem Quellcode in Cloud Run bereitstellen, wird Folgendes angezeigt:
    Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named
[cloud-run-source-deploy] in region [europe-west1] will be created.

Do you want to continue (Y/n)?
    Geben Sie Y ein und drücken Sie die Enter. Dadurch wird ein Artifact Registry-Repository für Ihre Bereitstellung erstellt. Dies ist erforderlich, um den Docker-Container des MCP-Servers für den Cloud Run-Dienst zu speichern.
  6. Nach einigen Minuten wird eine Meldung wie diese angezeigt:
    Service [zoo-mcp-server] revision [zoo-mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.

Sie haben Ihren MCP-Server bereitgestellt. Jetzt können Sie ihn verwenden.

8. Remote-MCP-Server zur Gemini CLI hinzufügen

Nachdem Sie einen Remote-MCP-Server erfolgreich bereitgestellt haben, können Sie mit verschiedenen Anwendungen wie Google Code Assist oder der Gemini CLI eine Verbindung zu ihm herstellen. In diesem Abschnitt stellen wir mit der Gemini CLI eine Verbindung zu Ihrem neuen Remote-MCP-Server her.

  1. Geben Sie Ihrem Nutzerkonto die Berechtigung, den Remote-MCP-Server aufzurufen.
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member=user:$(gcloud config get-value account) \
    --role='roles/run.invoker'
  2. Speichern Sie Ihre Google Cloud-Anmeldedaten und die Projektnummer in Umgebungsvariablen, um sie in der Gemini-Einstellungsdatei zu verwenden:
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)
  3. Erstellen Sie einen Ordner .gemini, falls er noch nicht vorhanden ist.
    mkdir -p ~/.gemini
  4. Öffnen Sie die Einstellungsdatei der Gemini CLI.
    cloudshell edit ~/.gemini/settings.json
  5. Ersetzen Sie die Einstellungsdatei der Gemini CLI, um den Cloud Run-MCP-Server hinzuzufügen.
    {
    "ide": {
        "hasSeenNudge": true
    },
    "mcpServers": {
        "zoo-remote": {
            "httpUrl": "https://zoo-mcp-server-$PROJECT_NUMBER.europe-west1.run.app/mcp",
            "headers": {
                "Authorization": "Bearer $ID_TOKEN"
            }
        }
    },
    "security": {
        "auth": {
            "selectedType": "cloud-shell"
        }
    }
}
  6. Starten Sie die Gemini CLI in Cloud Shell.
    gemini
    Möglicherweise müssen Sie Enter drücken, um einige Standardeinstellungen zu akzeptieren.Gemini CLI – erste Ansicht
  7. Lassen Sie sich von Gemini die MCP-Tools auflisten, die im Kontext verfügbar sind.
    /mcp
  8. Bitten Sie Gemini, etwas im Zoo zu suchen.
    Where can I find penguins?
    Die Gemini CLI sollte wissen, dass sie den zoo-remote-MCP-Server verwenden soll, und Sie fragen, ob Sie die Ausführung von MCP zulassen möchten.
  9. Verwenden Sie den Abwärtspfeil und drücken Sie dann Enter, um auszuwählen.
    Yes, always allow all tools from server "zoo-remote"
    Gemini CLI-Tool „zoo-remote“ zulassen

Die Ausgabe sollte die richtige Antwort und ein Feld enthalten, in dem angezeigt wird, dass der MCP-Server verwendet wurde.

Gemini CLI: Ergebnis des Zoo-MCP-Servers anzeigen

Fertig! Sie haben einen Remote-MCP-Server erfolgreich in Cloud Run bereitgestellt und mit der Gemini CLI getestet.

Wenn Sie die Sitzung beenden möchten, geben Sie /quit ein und drücken Sie dann die Enter, um die Gemini CLI zu beenden.

Debugging

Wenn ein Fehler wie dieser angezeigt wird:

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

Wahrscheinlich ist das ID-Token abgelaufen und Sie müssen ID_TOKEN noch einmal festlegen.

  1. Geben Sie /quit ein und drücken Sie dann die Enter, um die Gemini CLI zu beenden.
  2. Legen Sie Ihr Projekt im Terminal fest. 
    gcloud config set project [PROJECT_ID]
  3. Führen Sie den Befehl für die Google Cloud-Anmeldedaten noch einmal aus, um ein neues ID_TOKEN zu erhalten, da Ihr Token möglicherweise abgelaufen ist. 
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

9. (Optional) Toolaufrufe in Serverlogs prüfen

Prüfen Sie die Dienstlogs, um zu bestätigen, dass Ihr Cloud Run-MCP-Server aufgerufen wurde.

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

Sie sollten ein Ausgabeprotokoll sehen, das bestätigt, dass ein Toolaufruf erfolgt ist. 🛠️

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. (Optional) MCP-Prompt zum Server hinzufügen

Ein MCP-Prompt kann Ihren Workflow für häufig ausgeführte Prompts beschleunigen, indem er eine Kurzform für einen längeren Prompt erstellt.

Die Gemini CLI wandelt MCP-Prompts automatisch in benutzerdefinierte Slash-Befehle um, sodass Sie einen MCP-Prompt aufrufen können, indem Sie /prompt_name eingeben, wobei prompt_name der Name Ihres MCP-Prompts ist.

Erstellen Sie einen MCP-Prompt, damit Sie schnell ein Tier im Zoo finden können, indem Sie /find animal in die Gemini CLI eingeben.

  1. Fügen Sie diesen Code in der Datei server.py über der Hauptsperre (if __name__ == "__main__":) ein. 
    @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. Stellen Sie Ihre Anwendung noch einmal in Cloud Run bereit. 
    gcloud run deploy zoo-mcp-server \
    --region=europe-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
  3. Aktualisieren Sie das ID-Token für Ihren Remote-MCP-Server. 
    export ID_TOKEN=$(gcloud auth print-identity-token)
  4. Nachdem die neue Version Ihrer Anwendung bereitgestellt wurde, starten Sie die Gemini CLI. 
    gemini
  5. Verwenden Sie im Prompt den neuen benutzerdefinierten Befehl, den Sie erstellt haben: 
    /find lions

Sie sollten sehen, dass die Gemini CLI das Tool get_animals_by_species aufruft und die Antwort wie im MCP-Prompt angegeben formatiert.

╭───────────────────────────╮
│  > /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. (Optional) Gemini Flash Lite für schnellere Antworten verwenden

Mit der Gemini CLI können Sie das verwendete Modell auswählen.

  • Gemini 2.5 Pro ist das hochmoderne Denkmodell von Google, das komplexe Probleme in Code, Mathematik und MINT lösen sowie große Datensätze, Codebasen und Dokumente mit langem Kontext analysieren kann.
  • Gemini 2.5 Flash ist das beste Modell von Google in Bezug auf das Preis-Leistungs-Verhältnis und bietet umfassende Funktionen. 2.5 Flash eignet sich am besten für die Verarbeitung großer Datenmengen, Aufgaben mit niedriger Latenz und hohem Volumen, die Denkprozesse erfordern, sowie für Anwendungsfälle mit Agenten.
  • Gemini 2.5 Flash Lite ist das schnellste Flash-Modell von Google, das für Kosteneffizienz und hohen Durchsatz optimiert ist.

Da für die Anfragen zum Finden der Zootiere keine Denkprozesse erforderlich sind, können Sie die Geschwindigkeit erhöhen, indem Sie ein schnelleres Modell verwenden.

Im vorherigen Abschnitt haben Sie einen MCP-Prompt erstellt, damit Sie schnell ein Tier im Zoo finden können, indem Sie /find animal in die Gemini CLI eingeben.

  1. Nachdem die neue Version Ihrer Anwendung bereitgestellt wurde, starten Sie die Gemini CLI. 
    gemini --model=gemini-2.5-flash-lite
  2. Verwenden Sie im Prompt den neuen benutzerdefinierten Befehl, den Sie erstellt haben: 
    /find lions

Sie sollten weiterhin sehen, dass die Gemini CLI das Tool get_animals_by_species aufruft und die Antwort wie im MCP-Prompt angegeben formatiert. Die Antwort sollte jedoch viel schneller angezeigt werden.

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

Debugging

Wenn ein Fehler wie dieser angezeigt wird:

✕ Unknown command: /find lions

Führen Sie /mcp aus. Wenn zoo-remote - Disconnected ausgegeben wird, müssen Sie möglicherweise noch einmal bereitstellen oder die folgenden Befehle ausführen:

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

Glückwunsch! Sie haben einen sicheren Remote-MCP-Server erfolgreich bereitgestellt und eine Verbindung zu ihm hergestellt.

Nächstes Lab aufrufen

Dieses Lab ist das erste von drei Labs. Im zweiten Lab verwenden Sie den erstellten MCP-Server mit einem ADK-Agenten.

MCP-Server in Cloud Run mit einem ADK-Agenten verwenden

(Optional) Bereinigen

Wenn Sie nicht mit dem nächsten Lab fortfahren und die erstellten Ressourcen bereinigen möchten, können Sie Ihr Cloud-Projekt löschen, um zusätzliche Kosten zu vermeiden.

Während für Cloud Run keine Kosten anfallen, wenn der Dienst nicht verwendet wird, wird Ihnen dennoch das Speichern des Container-Images in Artifact Registry möglicherweise in Rechnung gestellt. Durch das Löschen des Cloudprojekts wird die Abrechnung für alle in diesem Projekt verwendeten Ressourcen beendet.

Wenn Sie möchten, löschen Sie das Projekt:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Möglicherweise möchten Sie auch unnötige Ressourcen von Ihrem Cloud Shell-Laufwerk löschen. Sie haben folgende Möglichkeiten:

  1. Löschen Sie das Projektverzeichnis des Codelabs: 
    rm -rf ~/mcp-on-cloudrun
  2. Warnung! Diese nächste Aktion kann nicht rückgängig gemacht werden. Wenn Sie alles in Ihrer Cloud Shell löschen möchten, um Speicherplatz freizugeben, können Sie Ihr gesamtesBasisverzeichnis löschen. Achten Sie darauf, dass alles, was Sie behalten möchten, an einem anderen Ort gespeichert ist. 
    sudo rm -rf $HOME