Se usó la API de Cloud Translation para traducir esta página.

Implementa, administra y observa el agente de ADK en Cloud Run

1. Introducción

En este instructivo, se explica cómo implementar, administrar y supervisar un agente potente creado con el Kit de desarrollo de agentes (ADK) en Google Cloud Run. El ADK te permite crear agentes capaces de realizar flujos de trabajo complejos de varios agentes. Si aprovechas Cloud Run, una plataforma sin servidores completamente administrada, puedes implementar tu agente como una aplicación alojada en contenedores y escalable sin preocuparte por la infraestructura subyacente. Esta potente combinación te permite enfocarte en la lógica principal de tu agente y, al mismo tiempo, beneficiarte del entorno sólido y escalable de Google Cloud.

A lo largo de este instructivo, exploraremos la integración perfecta del ADK con Cloud Run. Aprenderás a implementar tu agente y, luego, te sumergirás en los aspectos prácticos de la administración de tu aplicación en un entorno similar al de producción. Abordaremos cómo lanzar de forma segura nuevas versiones de tu agente administrando el tráfico, lo que te permitirá probar nuevas funciones con un subconjunto de usuarios antes de un lanzamiento completo.

Además, obtendrás experiencia práctica en la supervisión del rendimiento de tu agente. Simularemos una situación real realizando una prueba de carga para observar las capacidades de ajuste de escala automático de Cloud Run en acción. Para obtener estadísticas más detalladas sobre el comportamiento y el rendimiento de tu agente, habilitaremos el registro con Cloud Trace. Esto proporcionará una vista detallada de extremo a extremo de las solicitudes a medida que viajan a través de tu agente, lo que te permitirá identificar y abordar cualquier cuello de botella de rendimiento. Al final de este instructivo, comprenderás cómo implementar, administrar y supervisar de manera eficaz tus agentes potenciados por el ADK en Cloud Run.

En el codelab, seguirás un enfoque paso a paso de la siguiente manera:

Crea una base de datos de PostgreSQL en Cloud SQL para usarla en el servicio de sesión de la base de datos del agente del ADK
Configura un agente básico del ADK
Configura el servicio de sesión de la base de datos para que lo use el ejecutor del ADK
Implementa el agente en Cloud Run por primera vez
Realiza pruebas de carga y examina el ajuste de escala automático de Cloud Run
Implementa una revisión nueva del agente y aumenta gradualmente el tráfico hacia las revisiones nuevas
Configura el registro de seguimiento en la nube y, luego, inspecciona el registro de seguimiento de la ejecución del agente

Descripción general de la arquitectura

Requisitos previos

Comodidad para trabajar con Python
Conocimiento de la arquitectura básica de pila completa con el servicio HTTP

Qué aprenderás

Estructura del ADK y utilidades locales
Configura el agente de ADK con el servicio de sesión de la base de datos
Configura PostgreSQL en Cloud SQL para que lo use el servicio de sesión de la base de datos
Implementa la aplicación en Cloud Run con Dockerfile y configura las variables de entorno iniciales
Configura y prueba el ajuste de escala automático de Cloud Run con pruebas de carga
Estrategia de lanzamiento gradual con Cloud Run
Configura el registro del agente del ADK en Cloud Trace

Requisitos

Navegador web Chrome
Una cuenta de Gmail
Un proyecto de Cloud con la facturación habilitada

Este codelab, diseñado para desarrolladores de todos los niveles (incluidos los principiantes), usa Python en su aplicación de ejemplo. Sin embargo, no es necesario tener conocimientos de Python para comprender los conceptos que se presentan.

2. Antes de comenzar

Selecciona el proyecto activo en la consola de Cloud

En este codelab, se supone que ya tienes un proyecto de Google Cloud con la facturación habilitada. Si aún no lo tienes, puedes seguir las instrucciones que se indican a continuación para comenzar.

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

Prepara la base de datos de Cloud SQL

Más adelante, necesitaremos una base de datos para que la utilice el agente de ADK. Creemos una base de datos de PostgreSQL en Cloud SQL. Primero, navega a la barra de búsqueda en la sección superior de la consola de Cloud y escribe "Cloud SQL". Luego, haz clic en el producto Cloud SQL.

Después, deberemos crear una instancia de base de datos nueva. Para ello, haz clic en Crear instancia y elige PostgreSQL.

También es posible que debas habilitar la API de Compute Engine si comienzas con un proyecto nuevo. Para ello, haz clic en Habilitar API si aparece este mensaje.

A continuación, elegiremos las especificaciones de la base de datos y seleccionaremos la edición Enterprise con el ajuste predeterminado de la edición Sandbox.

Después de eso, establece el nombre de la instancia y la contraseña predeterminada para el usuario postgres aquí. Puedes configurar esto con las credenciales que desees. Sin embargo, para este instructivo, usaremos "adk-deployment" como nombre de instancia y contraseña.

Usemos us-central1 con una sola zona para este instructivo. Podemos finalizar la creación de nuestra base de datos y dejar que complete toda la configuración necesaria haciendo clic en el botón Crear instancia.

Mientras esperamos a que termine, podemos continuar con la siguiente sección.

Configura el proyecto de Cloud en la terminal de Cloud Shell

Usarás Cloud Shell, un entorno de línea de comandos que se ejecuta en Google Cloud. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

Una vez que te conectes a Cloud Shell, verifica que ya te autenticaste y que el proyecto se configuró con el ID de tu proyecto con el siguiente comando:

gcloud auth list

En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto.

gcloud config list project

Si tu proyecto no está configurado, usa el siguiente comando para hacerlo:

gcloud config set project <YOUR_PROJECT_ID>

Como alternativa, también puedes ver el ID de PROJECT_ID en la consola.

Haz clic en él y verás todos tus proyectos y el ID del proyecto en el lado derecho.

Habilita las APIs requeridas con el siguiente comando. Este proceso puede tardar unos minutos, así que ten paciencia.

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

Si el comando se ejecuta correctamente, deberías ver un mensaje similar al que se muestra a continuación:

Operation "operations/..." finished successfully.

La alternativa al comando de gcloud es a través de la consola, buscando cada producto o usando este vínculo.

Si olvidas alguna API, puedes habilitarla durante el transcurso de la implementación.

Consulta la documentación para ver los comandos y el uso de gcloud.

Ve al editor de Cloud Shell y configura el directorio de trabajo de la aplicación

Ahora, podemos configurar nuestro editor de código para hacer algunas cosas de programación. Usaremos el editor de Cloud Shell para esto.

Haz clic en el botón Abrir editor. Se abrirá un editor de Cloud Shell en el que podrás escribir tu código
Asegúrate de que el proyecto de Cloud Code esté configurado en la esquina inferior izquierda (barra de estado) del editor de Cloud Shell, como se destaca en la siguiente imagen, y que esté configurado en el proyecto activo de Google Cloud en el que tienes habilitada la facturación. Haz clic en Autorizar si se te solicita. Si ya seguiste el comando anterior, es posible que el botón también apunte directamente a tu proyecto activado en lugar del botón de acceso.

A continuación, clonemos el directorio de trabajo de la plantilla para este codelab desde GitHub. Para ello, ejecuta el siguiente comando. Se creará el directorio de trabajo en el directorio deploy_and_manage_adk.

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

Luego, ve a la sección superior del editor de Cloud Shell y haz clic en File->Open Folder, busca tu directorio de nombre de usuario y el directorio deploy_and_manage_adk y, luego, haz clic en el botón Aceptar. Esto convertirá el directorio elegido en el directorio de trabajo principal. En este ejemplo, el nombre de usuario es alvinprayuda, por lo que la ruta de acceso del directorio se muestra a continuación.

Ahora, tu editor de Cloud Shell debería verse así:

A continuación, podemos configurar nuestro entorno de Python.

Configuración del entorno

Prepara el entorno virtual de Python

El siguiente paso es preparar el entorno de desarrollo. Tu directorio de trabajo de la terminal activa actual debe estar dentro del directorio de trabajo deploy_and_manage_adk. En este codelab, usaremos Python 3.12 y uv python project manager para simplificar la necesidad de crear y administrar la versión de Python y el entorno virtual.

Si aún no abriste la terminal, haz clic en Terminal -> New Terminal o usa Ctrl + Mayúsculas + C para abrir una ventana de terminal en la parte inferior del navegador.

Descarga uv y, luego, instala Python 3.12 con el siguiente comando:

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

Ahora , inicialicemos el entorno virtual con uv. Ejecuta este comando

uv sync --frozen

Esto creará el directorio .venv y, luego, instalará las dependencias. Un vistazo rápido a pyproject.toml te brindará información sobre las dependencias que se muestran de esta manera:

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

Para probar el entorno virtual, crea un archivo nuevo main.py y copia el siguiente código

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

if __name__ == "__main__":
   main()

Luego, ejecuta el siguiente comando:

uv run main.py

Obtendrás un resultado como el que se muestra a continuación.

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

Esto demuestra que el proyecto de Python se está configurando correctamente.

Configura archivos de configuración

Ahora, deberemos configurar los archivos de configuración para este proyecto.

Cambia el nombre del archivo .env.example a .env y se mostrará el siguiente valor. Actualiza el valor de GOOGLE_CLOUD_PROJECT a tu project-id.

# 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

Para este codelab, usaremos los valores preconfigurados para GOOGLE_CLOUD_LOCATION y GOOGLE_GENAI_USE_VERTEXAI.. Por ahora, mantendremos SESSION_SERVICE_URI como comentario.

Ahora podemos pasar al siguiente paso: inspeccionar la lógica del agente y, luego, implementarlo.

3. Crea el agente meteorológico con el ADK y Gemini 2.5

Introducción a la estructura de directorios del ADK

Comencemos por explorar lo que ofrece el ADK y cómo compilar el agente. Puedes acceder a la documentación completa del ADK en esta URL . El ADK nos ofrece muchas utilidades dentro de la ejecución de su comando de CLI. Algunos de ellos son los siguientes :

Configura la estructura del directorio del agente
Probar rápidamente la interacción a través de la entrada y salida de la CLI
Configura rápidamente la interfaz web de la IU de desarrollo local

Ahora, verifiquemos la estructura del agente en el directorio weather_agent.

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

Si inspeccionas init.py y agent.py, verás este código

# __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],
)

Explicación del código del ADK

Este script contiene la inicialización de nuestro agente, en la que inicializamos los siguientes elementos:

Configura el modelo que se usará en gemini-2.5-flash
Proporciona la herramienta get_weather para admitir la funcionalidad del agente como agente meteorológico.

Ejecuta la IU web

Ahora, podemos interactuar con el agente y analizar su comportamiento de forma local. El ADK nos permite tener una IU web de desarrollo para interactuar y observar lo que sucede durante la interacción. Ejecuta el siguiente comando para iniciar el servidor de la IU de desarrollo local:

uv run adk web --port 8080

Se generará un resultado similar al siguiente ejemplo, lo que significa que ya podemos acceder a la interfaz web.

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)

Ahora, para verificarlo, haz clic en el botón Vista previa en la Web en la parte superior del editor de Cloud Shell y selecciona Vista previa en el puerto 8080.

Verás la siguiente página web en la que podrás seleccionar los agentes disponibles en el botón desplegable de la parte superior izquierda ( en nuestro caso, debería ser weather_agent) y, luego, interactuar con el bot. En la ventana de la izquierda, verás mucha información sobre los detalles del registro durante el tiempo de ejecución del agente.

Ahora, intenta interactuar con él. En la barra izquierda, podemos inspeccionar el registro de cada entrada para comprender cuánto tiempo tarda el agente en realizar cada acción antes de formar la respuesta final.

Esta es una de las funciones de observabilidad integradas en el ADK. Actualmente, la inspeccionamos de forma local. Más adelante, veremos cómo se integra esto en Cloud Trace para que tengamos un registro centralizado de todas las solicitudes.

4. La secuencia de comandos del servidor de backend

Para que el agente sea accesible como servicio, lo encapsularemos en una app de FastAPI. Aquí podemos configurar los servicios necesarios para admitir el agente, como preparar los servicios de Session, Memory o Artifact para fines de producción. Este es el código de server.py que se usará

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)

Explicación del código del servidor

Estos son los elementos que se definen en la secuencia de comandos server.py:

Convierte nuestro agente en una app de FastAPI con el método get_fast_api_app. De esta manera, heredaremos la misma definición de ruta que se utiliza para la IU de desarrollo web.
Configura el servicio de sesión, memoria o artefacto necesario agregando los argumentos de palabras clave al método get_fast_api_app. En este instructivo, si configuramos la variable de entorno SESSION_SERVICE_URI, el servicio de sesión la usará. De lo contrario, usará la sesión en memoria.
Podemos agregar una ruta personalizada para admitir otra lógica comercial de backend. En la secuencia de comandos, agregamos un ejemplo de ruta de funcionalidad de comentarios.
Habilita el seguimiento de nube para enviar el registro a Google Cloud Trace

5. Implementa en Cloud Run

Ahora, implementemos este servicio de agente en Cloud Run. Para los fines de esta demostración, este servicio se expondrá como un servicio público al que pueden acceder otras personas. Sin embargo, ten en cuenta que no son las prácticas recomendadas, ya que no son seguras.

En este codelab, usaremos Dockerfile para implementar nuestro agente en Cloud Run. A continuación, se muestra el contenido del Dockerfile que se usará

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"]

En este punto, ya tenemos todos los archivos necesarios para implementar nuestras aplicaciones en Cloud Run. Implementémosla. Navega a la terminal de Cloud Shell y asegúrate de que el proyecto actual esté configurado en tu proyecto activo. Si no es así, usa el comando gcloud config para establecer el ID del proyecto:

gcloud config set project [PROJECT_ID]

Luego, ejecuta el siguiente comando para implementarlo en 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

Para obtener el valor de {YOUR_DB_CONNECTION_NAME}, puedes volver a Cloud SQL y hacer clic en la instancia que creaste. En la página de la instancia, desplázate hacia abajo hasta la sección "Conéctate a esta instancia" y podrás copiar el nombre de la conexión para sustituir el valor {YOUR_DB_CONNECTION_NAME}. Por ejemplo, la imagen de búsqueda que se muestra a continuación

Si se te solicita que confirmes la creación de un registro de artefactos para el repositorio de Docker, responde Y. Ten en cuenta que permitimos el acceso no autenticado aquí porque se trata de una aplicación de demostración. Se recomienda usar la autenticación adecuada para tus aplicaciones empresariales y de producción.

Una vez que se complete la implementación, deberías obtener un vínculo similar al siguiente:

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

Continúa y usa tu aplicación desde la ventana de incógnito o tu dispositivo móvil. Ya debería estar disponible.

6. Inspecciona el ajuste de escala automático de Cloud Run con pruebas de carga

Ahora, inspeccionaremos las capacidades de escalamiento automático de Cloud Run. Para este caso, implementaremos una revisión nueva y habilitaremos la máxima simultaneidad por instancia. Ejecuta el siguiente comando:

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

Después de eso, inspeccionemos el archivo load_test.py. Esta será la secuencia de comandos que usaremos para realizar la prueba de carga con el framework de locust. Esta secuencia de comandos hará lo siguiente :

user_id y session_id aleatorios
Crea session_id para el user_id
Llama al extremo "/run_sse" con el user_id y el session_id creados.

Si no la recuerdas, necesitaremos saber la URL del servicio implementado. Ve a la consola de Cloud Run y haz clic en tu servicio weather-agent.

Luego, busca tu servicio weather-agent y haz clic en él.

La URL del servicio se mostrará justo al lado de la información de la región. P. ej.,

Luego, ejecuta el siguiente comando para realizar la prueba de carga:

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

Si ejecutas este comando, verás métricas como las que se muestran a continuación. ( En este ejemplo, todas las solicitudes se completaron correctamente).

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

Luego, veamos qué sucedió en Cloud Run. Vuelve a tu servicio implementado y consulta el panel. Esto mostrará cómo Cloud Run ajusta automáticamente la escala de la instancia para controlar las solicitudes entrantes. Dado que limitamos la simultaneidad máxima a 10 por instancia, la instancia de Cloud Run intentará ajustar la cantidad de contenedores para satisfacer esta condición automáticamente.

7. Lanzamiento gradual de revisiones nuevas

Ahora, veamos la siguiente situación. Queremos actualizar la instrucción del agente a la siguiente :

# 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],
)

Luego, quieres lanzar revisiones nuevas, pero no quieres que todo el tráfico de solicitudes vaya directamente a la versión nueva. Podemos hacer lanzamientos graduales con Cloud Run. Primero, debemos implementar una revisión nueva, pero con el parámetro –no-traffic. Guarda la secuencia de comandos del agente anterior y ejecuta el siguiente comando:

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

Cuando termines, recibirás un registro similar al del proceso de implementación anterior, con la diferencia de la cantidad de tráfico que se atendió. Se mostrará el 0% del tráfico publicado.

A continuación, ve a la página del producto de Cloud Run y busca la instancia implementada. Escribe Cloud Run en la barra de búsqueda y haz clic en el producto Cloud Run.

Luego, busca tu servicio weather-agent y haz clic en él.

Ve a la pestaña Revisiones y verás la lista de revisiones implementadas.

Verás que las nuevas revisiones implementadas publican el 0% del tráfico. Desde aquí, puedes hacer clic en el botón de kebab (⋮) y elegir Administrar tráfico.

En la ventana emergente nueva, puedes editar el porcentaje de tráfico que se dirige a cada revisión.

Después de esperar un tiempo, el tráfico se dirigirá de forma proporcional según los porcentajes de configuración. De esta manera, podemos revertir fácilmente a las revisiones anteriores si sucede algo con la nueva versión.

8. Registro de ADK

Los agentes compilados con el ADK ya admiten el seguimiento con la incorporación de OpenTelemetry. Tenemos Cloud Trace para capturar esos seguimientos y visualizarlos. Inspeccionemos server.py para ver cómo lo habilitamos en nuestro servicio implementado anteriormente.

# 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)

...

Aquí, inicializamos el registrador y el exportador. Los detalles del exportador se pueden inspeccionar en tracing.py . Aquí creamos un exportador personalizado porque hay un límite en los datos de seguimiento que se pueden exportar a Cloud Trace. Para esta capacidad de seguimiento, usamos una implementación de https://googlecloudplatform.github.io/agent-starter-pack/guide/observability.html.

Intenta acceder a la IU web de tu servicio y chatea con el agente. Luego, ve a la barra de búsqueda de la consola de Cloud, escribe “explorador de seguimiento” y elige el producto Explorador de seguimiento.

En la página del explorador de registros, verás que se envió el registro de nuestra conversación con el agente. Puedes ver en la sección Nombre del tramo y filtrar el tramo específico de nuestro agente ( se llama agent_run [weather_agent]).

Cuando los intervalos ya están filtrados, también puedes inspeccionar cada registro directamente. Se mostrará la duración detallada de cada acción que realice el agente. Por ejemplo, mira las imágenes a continuación.

En cada sección, puedes inspeccionar los detalles de los atributos, como se muestra a continuación.

Listo. Ahora tenemos buena observabilidad e información sobre cada interacción de nuestro agente con el usuario para ayudar a depurar problemas. No dudes en probar diferentes herramientas o flujos de trabajo.

9. Desafío

Prueba flujos de trabajo multiagente o basados en agentes para ver cómo se desempeñan bajo cargas y cómo se ve el registro.

10. Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este codelab:

En la consola de Google Cloud, ve a la página Administrar recursos.
En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrarlo.
Como alternativa, puedes ir a Cloud Run en la consola, seleccionar el servicio que acabas de implementar y borrarlo.