Ta strona została przetłumaczona przez Cloud Translation API.

Wdrażanie, zarządzanie i monitorowanie usługi ADK Agent w Cloud Run

1. Wprowadzenie

Z tego samouczka dowiesz się, jak wdrażać, zarządzać i monitorować zaawansowanego agenta utworzonego za pomocą zestawu Agent Development Kit (ADK) w Google Cloud Run. ADK umożliwia tworzenie agentów zdolnych do wykonywania złożonych przepływów pracy z udziałem wielu agentów. Korzystając z Cloud Run, w pełni zarządzanej platformy bezserwerowej, możesz wdrożyć agenta jako skalowalną aplikację skonteneryzowaną bez konieczności przejmowania się infrastrukturą bazową. To połączenie umożliwia skupienie się na podstawowej logice agenta przy jednoczesnym korzystaniu z solidnego i skalowalnego środowiska Google Cloud.

W tym samouczku omówimy bezproblemową integrację ADK z Cloud Run. Dowiesz się, jak wdrożyć agenta, a potem poznasz praktyczne aspekty zarządzania aplikacją w środowisku produkcyjnym. Wyjaśnimy, jak bezpiecznie wdrażać nowe wersje agenta, zarządzając ruchem i umożliwiając testowanie nowych funkcji na podzbiorze użytkowników przed pełnym wdrożeniem.

Dodatkowo zdobędziesz praktyczne doświadczenie w monitorowaniu skuteczności agenta. Przeprowadzimy test obciążenia, aby zasymulować rzeczywistą sytuację i zaobserwować działanie funkcji automatycznego skalowania Cloud Run. Aby uzyskać bardziej szczegółowe informacje o zachowaniu i skuteczności agenta, włączymy śledzenie za pomocą Cloud Trace. Dzięki temu uzyskasz szczegółowy, kompleksowy wgląd w żądania przesyłane przez agenta, co pozwoli Ci identyfikować i usuwać wszelkie wąskie gardła wydajności. Po ukończeniu tego samouczka będziesz mieć pełną wiedzę o tym, jak skutecznie wdrażać agentów opartych na ADK w Cloud Run, zarządzać nimi i je monitorować.

W ramach ćwiczeń z programowania będziesz wykonywać kolejne czynności:

Utwórz bazę danych PostgreSQL w Cloud SQL, która będzie używana w usłudze sesji bazy danych agenta ADK.
Konfigurowanie podstawowego agenta ADK
Konfigurowanie usługi sesji bazy danych do używania przez narzędzie ADK Runner
Początkowe wdrożenie agenta w Cloud Run
Testowanie obciążenia i sprawdzanie autoskalowania Cloud Run
Wdrażanie nowej wersji agenta i stopniowe zwiększanie ruchu kierowanego do nowych wersji
Konfigurowanie śledzenia w chmurze i sprawdzanie śledzenia działania agenta

Omówienie architektury

Wymagania wstępne

Komfortowa praca z Pythonem
Znajomość podstawowej architektury pełnego stosu z użyciem usługi HTTP

Czego się nauczysz

Struktura ADK i lokalne narzędzia
Konfigurowanie agenta ADK za pomocą usługi sesji bazy danych
Konfigurowanie PostgreSQL w Cloud SQL do użycia przez usługę sesji bazy danych
Wdrażanie aplikacji w Cloud Run za pomocą pliku Dockerfile i konfigurowanie początkowych zmiennych środowiskowych
Konfigurowanie i testowanie autoskalowania Cloud Run za pomocą testów obciążeniowych
Strategia stopniowego wdrażania w Cloud Run
Konfigurowanie śledzenia agenta ADK w Cloud Trace

Czego potrzebujesz

przeglądarki Chrome,
konto Gmail,
Projekt w chmurze z włączonymi płatnościami

Ten przewodnik, przeznaczony dla deweloperów na wszystkich poziomach zaawansowania (w tym dla początkujących), wykorzystuje w przykładowej aplikacji język Python. Znajomość Pythona nie jest jednak wymagana do zrozumienia przedstawionych koncepcji.

2. Zanim zaczniesz

Wybieranie aktywnego projektu w Cloud Console

W tym samouczku zakładamy, że masz już projekt Google Cloud z włączonymi płatnościami. Jeśli jeszcze go nie masz, możesz zacząć, wykonując czynności opisane poniżej.

W konsoli Google Cloud na stronie selektora projektów wybierz lub utwórz projekt Google Cloud.
Sprawdź, czy w projekcie Cloud włączone są płatności. Dowiedz się, jak sprawdzić, czy w projekcie są włączone płatności.

Przygotowanie bazy danych Cloud SQL

Później agent ADK będzie korzystać z bazy danych. Utwórzmy bazę danych PostgreSQL w Cloud SQL. Najpierw przejdź do paska wyszukiwania w górnej części konsoli Cloud i wpisz „cloud sql”. Następnie kliknij usługę Cloud SQL.

Następnie musimy utworzyć nową instancję bazy danych. Kliknij Utwórz instancję i wybierz PostgreSQL.

Jeśli zaczynasz od nowego projektu, może być też konieczne włączenie interfejsu Compute Engine API. W tym celu kliknij Włącz interfejs API, gdy pojawi się odpowiedni komunikat.

Następnie wybierzemy specyfikacje bazy danych, wybierzemy wersję Enterprise z gotowym ustawieniem Sandbox.

Następnie ustaw nazwę instancji i hasło domyślne użytkownika postgres. Możesz skonfigurować dowolne dane logowania, ale w tym samouczku użyjemy nazwy instancji i hasła „adk-deployment”.

W tym samouczku użyjemy regionu us-central1 z jedną strefą. Możemy wtedy dokończyć tworzenie bazy danych i pozwolić jej na ukończenie wszystkich wymaganych ustawień, klikając przycisk Utwórz instancję.

Podczas oczekiwania na zakończenie tego procesu możemy przejść do następnej sekcji.

Konfigurowanie projektu w Cloud Shell Terminal

Będziesz używać Cloud Shell, czyli środowiska wiersza poleceń działającego w Google Cloud. U góry konsoli Google Cloud kliknij Aktywuj Cloud Shell.

Po połączeniu z Cloud Shell sprawdź, czy jesteś już uwierzytelniony i czy projekt jest ustawiony na Twój identyfikator projektu, używając tego polecenia:

gcloud auth list

Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:

gcloud config list project

Jeśli projekt nie jest ustawiony, użyj tego polecenia, aby go ustawić:

gcloud config set project <YOUR_PROJECT_ID>

Możesz też zobaczyć identyfikator PROJECT_ID w konsoli.

Kliknij go, a po prawej stronie zobaczysz wszystkie swoje projekty i identyfikator projektu.

Włącz wymagane interfejsy API za pomocą polecenia pokazanego poniżej. Może to potrwać kilka minut, więc zachowaj cierpliwość.

gcloud services enable aiplatform.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       sqladmin.googleapis.com

Po pomyślnym wykonaniu polecenia powinien wyświetlić się komunikat podobny do tego poniżej:

Operation "operations/..." finished successfully.

Alternatywą dla polecenia gcloud jest wyszukanie poszczególnych usług w konsoli lub skorzystanie z tego linku.

Jeśli pominiesz jakiś interfejs API, zawsze możesz go włączyć w trakcie wdrażania.

Informacje o poleceniach gcloud i ich użyciu znajdziesz w dokumentacji.

Otwórz edytor Cloud Shell i skonfiguruj katalog roboczy aplikacji

Teraz możemy skonfigurować edytor kodu, aby wykonywać różne czynności związane z kodowaniem. W tym celu użyjemy edytora Cloud Shell.

Kliknij przycisk Otwórz edytor. Spowoduje to otwarcie edytora Cloud Shell, w którym możesz pisać kod.
Sprawdź, czy projekt Cloud Code jest ustawiony w lewym dolnym rogu (na pasku stanu) edytora Cloud Shell, jak pokazano na ilustracji poniżej, i czy jest ustawiony jako aktywny projekt Google Cloud, w którym masz włączone płatności. W razie potrzeby kliknij Zezwól. Jeśli wykonasz poprzednie polecenie, przycisk może też prowadzić bezpośrednio do aktywowanego projektu zamiast do przycisku logowania.

Następnie sklonujmy z GitHuba katalog roboczy szablonu na potrzeby tego szkolenia. Wpisz to polecenie: W katalogu deploy_and_manage_adk zostanie utworzony katalog roboczy.

git clone https://github.com/alphinside/deploy-and-manage-adk-service.git deploy_and_manage_adk

Następnie przejdź do górnej sekcji edytora Cloud Shell i kliknij File->Open Folder (Plik –>Otwórz folder), znajdź katalog username (nazwa użytkownika) i katalog deploy_and_manage_adk,a potem kliknij OK. Spowoduje to ustawienie wybranego katalogu jako głównego katalogu roboczego. W tym przykładzie nazwa użytkownika to alvinprayuda, więc ścieżka do katalogu jest widoczna poniżej.

Edytor Cloud Shell powinien teraz wyglądać tak:

Następnie możemy skonfigurować środowisko Pythona.

Konfiguracja środowiska

Przygotowywanie wirtualnego środowiska Pythona

Następnym krokiem jest przygotowanie środowiska programistycznego. Bieżący aktywny katalog roboczy terminala powinien znajdować się w katalogu roboczym deploy_and_manage_adk. W tym samouczku użyjemy Pythona 3.12 i menedżera projektów Pythona uv, aby uprościć tworzenie i zarządzanie wersją Pythona oraz środowiskiem wirtualnym.

Jeśli terminal nie jest jeszcze otwarty, otwórz go, klikając Terminal –> Nowy terminal lub użyj skrótu Ctrl + Shift + C. W dolnej części przeglądarki otworzy się okno terminala.

Pobierz uv i zainstaluj Pythona 3.12 za pomocą tego polecenia:

curl -LsSf https://astral.sh/uv/0.6.16/install.sh | sh && \
source $HOME/.local/bin/env && \
uv python install 3.12

Teraz zainicjuj środowisko wirtualne za pomocą polecenia uv. Uruchom to polecenie:

uv sync --frozen

Spowoduje to utworzenie katalogu .venv i zainstalowanie zależności. Szybki podgląd pliku pyproject.toml pozwoli Ci uzyskać informacje o zależnościach, które będą wyświetlane w ten sposób:

dependencies = [
    "google-adk==1.3.0",
    "locust==2.37.10",
    "pg8000==1.31.2",
    "python-dotenv==1.1.0",
]

Aby przetestować środowisko wirtualne, utwórz nowy plik main.py i skopiuj ten kod:

def main():
   print("Hello from deploy_and_manage_adk!")

if __name__ == "__main__":
   main()

Następnie uruchom to polecenie:

uv run main.py

Otrzymasz dane wyjściowe podobne do tych poniżej.

Using CPython 3.12
Creating virtual environment at: .venv
Hello from deploy_and_manage_adk!

Oznacza to, że projekt w Pythonie jest prawidłowo konfigurowany.

Konfigurowanie plików konfiguracji

Teraz musimy skonfigurować pliki konfiguracji dla tego projektu.

Zmień nazwę pliku .env.example na .env. Wyświetli się wartość poniżej. Zaktualizuj wartość GOOGLE_CLOUD_PROJECT, podając identyfikator projektu.

# Google Cloud and Vertex AI configuration
GOOGLE_CLOUD_PROJECT=your-project-id
GOOGLE_CLOUD_LOCATION=global
GOOGLE_GENAI_USE_VERTEXAI=True

# Database connection for session service
# SESSION_SERVICE_URI=postgresql+pg8000://<username>:<password>@/<database>?unix_sock=/cloudsql/<instance_connection_name>/.s.PGSQL.5432

Na potrzeby tego laboratorium wybierzemy wstępnie skonfigurowane wartości dla GOOGLE_CLOUD_LOCATION i GOOGLE_GENAI_USE_VERTEXAI.. Na razie pozostawimy SESSION_SERVICE_URI jako komentarz.

Teraz możemy przejść do następnego kroku, czyli sprawdzić logikę agenta i wdrożyć go.

3. Tworzenie agenta pogodowego za pomocą ADK i Gemini 2.5

Wprowadzenie do struktury katalogów pakietu ADK

Zacznijmy od poznania możliwości ADK i sposobu tworzenia agenta. Pełną dokumentację pakietu ADK znajdziesz pod tym adresem URL . ADK oferuje wiele narzędzi w ramach wykonywania poleceń CLI. Oto niektóre z nich :

Konfigurowanie struktury katalogów agenta
Szybkie wypróbowanie interakcji za pomocą interfejsu wiersza poleceń
Szybkie konfigurowanie lokalnego interfejsu internetowego

Sprawdźmy teraz strukturę agenta w katalogu weather_agent.

weather_agent/
├── __init__.py
├── agent.py

Jeśli sprawdzisz pliki init.py i agent.py, zobaczysz ten kod:

# __init__.py

from weather_agent.agent import root_agent

__all__ = ["root_agent"]

# agent.py

import os
from pathlib import Path

import google.auth
from dotenv import load_dotenv
from google.adk.agents import Agent
from google.cloud import logging as google_cloud_logging

# Load environment variables from .env file in root directory
root_dir = Path(__file__).parent.parent
dotenv_path = root_dir / ".env"
load_dotenv(dotenv_path=dotenv_path)

# Use default project from credentials if not in .env
_, project_id = google.auth.default()
os.environ.setdefault("GOOGLE_CLOUD_PROJECT", project_id)
os.environ.setdefault("GOOGLE_CLOUD_LOCATION", "global")
os.environ.setdefault("GOOGLE_GENAI_USE_VERTEXAI", "True")

logging_client = google_cloud_logging.Client()
logger = logging_client.logger("weather-agent")


def get_weather(city: str) -> dict:
    """Retrieves the current weather report for a specified city.

    Args:
        city (str): The name of the city (e.g., "New York", "London", "Tokyo").

    Returns:
        dict: A dictionary containing the weather information.
              Includes a 'status' key ('success' or 'error').
              If 'success', includes a 'report' key with weather details.
              If 'error', includes an 'error_message' key.
    """
    logger.log_text(
        f"--- Tool: get_weather called for city: {city} ---", severity="INFO"
    )  # Log tool execution
    city_normalized = city.lower().replace(" ", "")  # Basic normalization

    # Mock weather data
    mock_weather_db = {
        "newyork": {
            "status": "success",
            "report": "The weather in New York is sunny with a temperature of 25°C.",
        },
        "london": {
            "status": "success",
            "report": "It's cloudy in London with a temperature of 15°C.",
        },
        "tokyo": {
            "status": "success",
            "report": "Tokyo is experiencing light rain and a temperature of 18°C.",
        },
    }

    if city_normalized in mock_weather_db:
        return mock_weather_db[city_normalized]
    else:
        return {
            "status": "error",
            "error_message": f"Sorry, I don't have weather information for '{city}'.",
        }


root_agent = Agent(
    name="weather_agent",
    model="gemini-2.5-flash",
    instruction="You are a helpful AI assistant designed to provide accurate and useful information.",
    tools=[get_weather],
)

ADK Wyjaśnienie kodu

Ten skrypt zawiera inicjację agenta, w której inicjujemy te elementy:

Ustaw model, który ma być używany, na gemini-2.5-flash
Udostępnij narzędzie get_weather, aby obsługiwać funkcje agenta, np. agenta pogodowego.

Uruchamianie interfejsu internetowego

Teraz możemy wchodzić w interakcje z agentem i sprawdzać jego działanie lokalnie. ADK umożliwia nam korzystanie z interfejsu internetowego do programowania, który pozwala wchodzić w interakcje i sprawdzać, co się dzieje podczas interakcji. Aby uruchomić lokalny serwer interfejsu programistycznego, wykonaj to polecenie:

uv run adk web --port 8080

Pojawią się dane wyjściowe podobne do tych poniżej. Oznacza to, że możemy już uzyskać dostęp do interfejsu internetowego.

INFO:     Started server process [xxxx]
INFO:     Waiting for application startup.

+-----------------------------------------------------------------------------+
| ADK Web Server started                                                      |
|                                                                             |
| For local testing, access at http://localhost:8080.                         |
+-----------------------------------------------------------------------------+

INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)

Aby to sprawdzić, kliknij przycisk Podgląd w przeglądarce w górnej części edytora Cloud Shell i wybierz Podejrzyj na porcie 8080.

Wyświetli się strona internetowa, na której w lewym górnym rogu możesz wybrać dostępnych agentów ( w naszym przypadku powinien to być weather_agent) i interagować z botem. W oknie po lewej stronie zobaczysz wiele informacji o szczegółach logu podczas działania agenta.

Teraz spróbuj wejść z nim w interakcję. Na pasku po lewej stronie możemy sprawdzić ślad każdego wejścia, aby dowiedzieć się, ile czasu zajmuje każda czynność wykonywana przez agenta przed sformułowaniem ostatecznej odpowiedzi.

Jest to jedna z funkcji obserwacji wbudowanych w ADK. Obecnie sprawdzamy ją lokalnie. Później zobaczymy, jak jest to zintegrowane z Cloud Tracing, abyśmy mieli scentralizowane śledzenie wszystkich żądań.

4. Skrypt serwera backendu

Aby udostępnić agenta jako usługę, umieścimy go w aplikacji FastAPI. Możemy tu skonfigurować niezbędne usługi, które będą obsługiwać agenta, np. przygotować usługi Session, Memory lub Artifact do celów produkcyjnych. Oto kod pliku server.py, który będzie używany:

import os

from dotenv import load_dotenv
from fastapi import FastAPI
from google.adk.cli.fast_api import get_fast_api_app
from pydantic import BaseModel
from typing import Literal
from google.cloud import logging as google_cloud_logging
from tracing import CloudTraceLoggingSpanExporter
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider, export


# Load environment variables from .env file
load_dotenv()

logging_client = google_cloud_logging.Client()
logger = logging_client.logger(__name__)

AGENT_DIR = os.path.dirname(os.path.abspath(__file__))

# Get session service URI from environment variables
session_uri = os.getenv("SESSION_SERVICE_URI", None)

# Prepare arguments for get_fast_api_app
app_args = {"agents_dir": AGENT_DIR, "web": True}

# Only include session_service_uri if it's provided
if session_uri:
    app_args["session_service_uri"] = session_uri
else:
    logger.log_text(
        "SESSION_SERVICE_URI not provided. Using in-memory session service instead. "
        "All sessions will be lost when the server restarts.",
        severity="WARNING",
    )

provider = TracerProvider()
processor = export.BatchSpanProcessor(CloudTraceLoggingSpanExporter())
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

# Create FastAPI app with appropriate arguments
app: FastAPI = get_fast_api_app(**app_args)

app.title = "weather-agent"
app.description = "API for interacting with the Agent weather-agent"


class Feedback(BaseModel):
    """Represents feedback for a conversation."""

    score: int | float
    text: str | None = ""
    invocation_id: str
    log_type: Literal["feedback"] = "feedback"
    service_name: Literal["weather-agent"] = "weather-agent"
    user_id: str = ""


@app.post("/feedback")
def collect_feedback(feedback: Feedback) -> dict[str, str]:
    """Collect and log feedback.

    Args:
        feedback: The feedback data to log

    Returns:
        Success message
    """
    logger.log_struct(feedback.model_dump(), severity="INFO")
    return {"status": "success"}


# Main execution
if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=8080)

Wyjaśnienie kodu serwera

Oto elementy zdefiniowane w skrypcie server.py:

Przekształć agenta w aplikację FastAPI za pomocą metody get_fast_api_app. W ten sposób odziedziczymy tę samą definicję trasy, która jest używana w interfejsie programowania aplikacji internetowych.
Skonfiguruj niezbędną usługę sesji, pamięci lub artefaktów, dodając argumenty słów kluczowych do metody get_fast_api_app. Jeśli w tym samouczku skonfigurujemy zmienną środowiskową SESSION_SERVICE_URI, usługa sesji będzie jej używać. W przeciwnym razie będzie używać sesji w pamięci.
Możemy dodać niestandardową ścieżkę, aby obsługiwać inną logikę biznesową backendu. W skrypcie dodajemy przykładową ścieżkę funkcji opinii.
Włącz śledzenie w chmurze, aby wysyłać ślady do Cloud Trace.

5. Wdrażanie w Cloud Run

Teraz wdróżmy tę usługę agenta w Cloud Run. Na potrzeby tej wersji demonstracyjnej usługa będzie udostępniana jako usługa publiczna, do której dostęp będą miały inne osoby. Pamiętaj jednak, że nie jest to sprawdzona metoda, ponieważ nie zapewnia bezpieczeństwa.

W tym samouczku użyjemy pliku Dockerfile, aby wdrożyć agenta w Cloud Run. Poniżej znajduje się zawartość pliku Dockerfile, która będzie używana.

FROM python:3.12-slim

RUN pip install --no-cache-dir uv==0.7.13

WORKDIR /app

COPY . .

RUN uv sync --frozen

EXPOSE 8080

CMD ["uv", "run", "uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8080"]

Mamy już wszystkie pliki potrzebne do wdrożenia aplikacji w Cloud Run. Możemy więc to zrobić. Otwórz terminal Cloud Shell i sprawdź, czy bieżący projekt jest skonfigurowany jako aktywny. Jeśli nie, użyj polecenia gcloud configure, aby ustawić identyfikator projektu:

gcloud config set project [PROJECT_ID]

Następnie uruchom to polecenie, aby wdrożyć go w Cloud Run.

gcloud run deploy weather-agent \
                  --source . \
                  --port 8080 \
                  --project {YOUR_PROJECT_ID} \
                  --allow-unauthenticated \
                  --add-cloudsql-instances {YOUR_DB_CONNECTION_NAME} \
                  --update-env-vars SESSION_SERVICE_URI="postgresql+pg8000://postgres:{YOUR_DEFAULT_USER_PASS}@postgres/?unix_sock=/cloudsql/{YOUR_DB_CONNECTION_NAME}/.s.PGSQL.5432",GOOGLE_CLOUD_PROJECT={YOUR_PROJECT_ID} \
                  --region us-central1

Aby uzyskać wartość {YOUR_DB_CONNECTION_NAME}, możesz ponownie otworzyć Cloud SQL i kliknąć utworzoną instancję. Na stronie instancji przewiń w dół do sekcji „Połącz się z tą instancją” i skopiuj nazwę połączenia, aby zastąpić wartość {YOUR_DB_CONNECTION_NAME}. Na przykład spójrz na obraz pokazany poniżej.

Jeśli pojawi się prośba o potwierdzenie utworzenia repozytorium Artifact Registry dla Dockera, wpisz Y. Pamiętaj, że w tym przypadku zezwalamy na nieuwierzytelniony dostęp, ponieważ jest to aplikacja demonstracyjna. Zalecamy stosowanie odpowiedniego uwierzytelniania w przypadku aplikacji firmowych i produkcyjnych.

Po zakończeniu wdrażania powinien pojawić się link podobny do tego poniżej:

https://weather-agent-*******.us-central1.run.app

Możesz teraz korzystać z aplikacji w oknie incognito lub na urządzeniu mobilnym. Powinien być już dostępny.

6. Sprawdzanie automatycznego skalowania Cloud Run za pomocą testów obciążeniowych

Teraz sprawdzimy możliwości automatycznego skalowania Cloud Run. W tym scenariuszu wdróżmy nową wersję, włączając maksymalną liczbę równoczesnych żądań na instancję. Uruchom to polecenie:

gcloud run deploy weather-agent \
                  --source . \
                  --port 8080 \
                  --project {YOUR_PROJECT_ID} \
                  --allow-unauthenticated \
                  --region us-central1 \
                  --concurrency 10

Następnie sprawdźmy plik load_test.py. Będzie to skrypt, którego użyjemy do testowania obciążenia za pomocą platformy locust. Ten skrypt wykona te czynności :

Losowe wartości user_id i session_id
Utwórz identyfikator sesji dla identyfikatora użytkownika.
Wyślij żądanie do punktu końcowego „/run_sse” z utworzonymi identyfikatorami user_id i session_id.

Jeśli nie podasz adresu URL wdrożonej usługi, będziemy musieli go poznać. Otwórz konsolę Cloud Run i kliknij usługę weather-agent.

Następnie znajdź usługę weather-agent i kliknij ją.

Adres URL usługi będzie wyświetlany obok informacji o regionie. np.

Następnie uruchom to polecenie, aby przeprowadzić test obciążenia:

uv run locust -f load_test.py \
              -H {YOUR_SERVICE_URL} \
              -u 60 \
              -r 5 \
              -t 120 \
              --headless

Po uruchomieniu tego polecenia zobaczysz wyświetlone dane, takie jak te poniżej. ( W tym przykładzie wszystkie żądania zakończyły się powodzeniem)

Type     Name                                  # reqs      # fails |    Avg     Min     Max    Med |   req/s  failures/s
--------|------------------------------------|-------|-------------|-------|-------|-------|-------|--------|-----------
POST     /run_sse end                             813     0(0.00%) |   5817    2217   26421   5000 |    6.79        0.00
POST     /run_sse message                         813     0(0.00%) |   2678    1107   17195   2200 |    6.79        0.00
--------|------------------------------------|-------|-------------|-------|-------|-------|-------|--------|-----------
         Aggregated                              1626     0(0.00%) |   4247    1107   26421   3500 |   13.59        0.00

Sprawdźmy teraz, co się stało w Cloud Run. Wróć do wdrożonej usługi i wyświetl panel. Pokazuje to, jak Cloud Run automatycznie skaluje instancję w celu obsługi żądań przychodzących. Ograniczamy maksymalną liczbę współbieżnych żądań do 10 na instancję, więc instancja Cloud Run automatycznie dostosuje liczbę kontenerów, aby spełnić ten warunek.

7. Stopniowe wdrażanie nowych wersji

Przyjrzyjmy się teraz następującemu scenariuszowi. Chcemy zaktualizować prompt agenta w ten sposób :

# agent.py

...

root_agent = Agent(
    name="weather_agent",
    model="gemini-2.5-flash-preview-05-20",
    instruction="You are a helpful AI assistant designed to provide accurate and useful information. You only answer inquiries about the weather. Refuse all other user query",
    tools=[get_weather],
)

Chcesz wdrożyć nowe wersje, ale nie chcesz, aby cały ruch z żądaniami był kierowany bezpośrednio do nowej wersji. W Cloud Run możemy przeprowadzić stopniowe wdrażanie. Najpierw musimy wdrożyć nową wersję, ale z flagą –no-traffic. Zapisz poprzedni skrypt agenta i uruchom to polecenie:

gcloud run deploy weather-agent \
                  --source . \
                  --port 8080 \
                  --project {YOUR_PROJECT_ID} \
                  --allow-unauthenticated \
                  --region us-central1 \
                  --no-traffic

Po zakończeniu otrzymasz podobny dziennik jak w przypadku poprzedniego procesu wdrażania, z tą różnicą, że będzie on zawierał liczbę obsłużonych żądań. Wyświetli się informacja o 0% obsłużonego ruchu.

Następnie przejdź na stronę usługi Cloud Run i znajdź wdrożoną instancję. Na pasku wyszukiwania wpisz „Cloud Run” i kliknij usługę Cloud Run.

Następnie znajdź usługę weather-agent i kliknij ją.

Otwórz kartę Wersje, na której zobaczysz listę wdrożonych wersji.

Nowa wdrożona wersja będzie obsługiwać 0% ruchu. Kliknij przycisk z 3 kropkami (⋮) i wybierz Zarządzaj ruchem.

W nowo otwartym okienku możesz edytować odsetek ruchu kierowanego do poszczególnych wersji.

Po pewnym czasie ruch będzie kierowany proporcjonalnie na podstawie konfiguracji procentowych. Dzięki temu w razie problemów z nową wersją możemy łatwo przywrócić poprzednie wersje.

8. Śledzenie ADK

Agenty utworzone za pomocą platformy ADK obsługują już śledzenie za pomocą otwartej telemetrii. Mamy Cloud Trace, aby rejestrować ślady i je wizualizować. Sprawdźmy, jak w server.py włączyliśmy tę funkcję w usłudze, którą wcześniej wdrożyliśmy.

# server.py

from tracing import CloudTraceLoggingSpanExporter
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider, export

...

provider = TracerProvider()
processor = export.BatchSpanProcessor(CloudTraceLoggingSpanExporter())
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

...

Inicjujemy tu moduł śledzący i eksporter. Szczegóły eksportera można sprawdzić w pliku tracing.py . Tworzymy tu niestandardowy eksporter, ponieważ istnieje limit danych śledzenia, które można wyeksportować do Cloud Trace. Do śledzenia używamy implementacji z https://googlecloudplatform.github.io/agent-starter-pack/guide/observability.html.

Spróbuj uzyskać dostęp do interfejsu internetowego usługi i porozmawiać z agentem. Następnie na pasku wyszukiwania w konsoli Google Cloud wpisz „Eksplorator logów czasu” i wybierz usługę Eksplorator logów czasu.

Na stronie eksploratora śladów zobaczysz, że ślad naszej rozmowy z agentem został przesłany. W sekcji Nazwa zakresu możesz zobaczyć zakresy i odfiltrować ten, który jest specyficzny dla naszego agenta ( ma nazwę agent_run [weather_agent]).

Gdy zakresy są już przefiltrowane, możesz też bezpośrednio sprawdzić każdy ślad. Wyświetla szczegółowy czas trwania każdego działania podjętego przez agenta. Na przykład spójrz na obrazy poniżej.

W każdej sekcji możesz sprawdzić szczegóły atrybutów, jak pokazano poniżej.

Gotowe. Mamy teraz dobrą widoczność i informacje o każdej interakcji agenta z użytkownikiem, które pomogą nam rozwiązywać problemy. Możesz wypróbować różne narzędzia i procesy.

9. Wyzwanie

Wypróbuj przepływy pracy z wieloma agentami lub oparte na agentach, aby sprawdzić, jak działają pod obciążeniem i jak wygląda ślad.

10. Czyszczenie danych

Aby uniknąć obciążenia konta Google Cloud opłatami za zasoby użyte w tym laboratorium, wykonaj te czynności:

W konsoli Google Cloud otwórz stronę Zarządzanie zasobami.
Z listy projektów wybierz projekt do usunięcia, a potem kliknij Usuń.
W oknie wpisz identyfikator projektu i kliknij Wyłącz, aby usunąć projekt.
Możesz też otworzyć Cloud Run w konsoli, wybrać wdrożoną usługę i ją usunąć.