1. Introdução
Neste tutorial, você vai aprender a implantar, gerenciar e monitorar um agente eficiente criado com o Kit de Desenvolvimento de Agente (ADK) no Google Cloud Run. Com o ADK, é possível criar agentes capazes de fluxos de trabalho complexos e multiagentes. Ao usar o Cloud Run, uma plataforma sem servidor totalmente gerenciada, é possível implantar seu agente como um aplicativo conteinerizado e escalonável sem se preocupar com a infraestrutura. Essa combinação poderosa permite que você se concentre na lógica principal do seu agente enquanto se beneficia do ambiente robusto e escalonável do Google Cloud.
Neste tutorial, vamos explorar a integração perfeita do ADK com o Cloud Run. Você vai aprender a implantar seu agente e depois vai conhecer os aspectos práticos do gerenciamento do aplicativo em um ambiente semelhante ao de produção. Vamos mostrar como lançar novas versões do seu agente com segurança gerenciando o tráfego. Assim, você pode testar novos recursos com um subconjunto de usuários antes de um lançamento completo.
Além disso, você vai ganhar experiência prática com o monitoramento da performance do seu agente. Vamos simular um cenário real realizando um teste de carga para observar os recursos de escalonamento automático do Cloud Run em ação. Para ter insights mais detalhados sobre o comportamento e a performance do seu agente, vamos ativar o rastreamento com o Cloud Trace. Isso vai fornecer uma visão detalhada e completa das solicitações à medida que elas passam pelo seu agente, permitindo que você identifique e resolva gargalos de desempenho. Ao final deste tutorial, você terá uma compreensão abrangente de como implantar, gerenciar e monitorar com eficiência seus agentes com tecnologia ADK no Cloud Run.
Durante o codelab, você vai usar uma abordagem gradual da seguinte forma:
- Crie um banco de dados PostgreSQL no CloudSQL para ser usado no serviço de sessão do banco de dados do agente do ADK.
- Configurar um agente básico do ADK
- Configurar o serviço de sessão do banco de dados para ser usado pelo executor do ADK
- Implantação inicial do agente no Cloud Run
- Teste de carga e inspeção do escalonamento automático do Cloud Run
- Implante uma nova revisão do agente e aumente gradualmente o tráfego para novas revisões
- Configurar o rastreamento na nuvem e inspecionar o rastreamento da execução do agente
Visão geral da arquitetura
Pré-requisitos
- Conhecimento de Python
- Conhecimento básico da arquitetura full-stack usando o serviço HTTP
O que você vai aprender
- Estrutura do ADK e utilitários locais
- Configurar o agente do ADK com o serviço de sessão do banco de dados
- Configurar o PostgreSQL no CloudSQL para ser usado pelo serviço de sessão do banco de dados
- Implantar o aplicativo no Cloud Run usando o Dockerfile e configurar as variáveis de ambiente iniciais
- Configurar e testar o escalonamento automático do Cloud Run com teste de carga
- Estratégia de lançamento gradual com o Cloud Run
- Configurar o rastreamento do agente do ADK para o Cloud Trace
O que é necessário
- Navegador da Web Google Chrome
- Uma conta do Gmail
- Um projeto do Cloud com faturamento ativado
Este codelab, criado para desenvolvedores de todos os níveis (incluindo iniciantes), usa Python no aplicativo de exemplo. No entanto, não é necessário ter conhecimento de Python para entender os conceitos apresentados.
2. Antes de começar
Selecionar projeto ativo no console do Cloud
Este codelab pressupõe que você já tenha um projeto do Google Cloud com o faturamento ativado. Se você ainda não tem uma, siga as instruções abaixo para começar.
- No console do Google Cloud, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
- Confira se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto.
Preparar o banco de dados do Cloud SQL
Vamos precisar de um banco de dados para ser usado pelo agente do ADK mais tarde. Vamos criar um banco de dados PostgreSQL no Cloud SQL. Primeiro, navegue até a barra de pesquisa na parte superior do console do Cloud e digite "cloud sql". Em seguida, clique no produto Cloud SQL.
Depois disso, vamos precisar criar uma nova instância de banco de dados. Clique em Criar instância e escolha PostgreSQL.
Talvez seja necessário ativar a API Compute Engine se você começar com um novo projeto. Basta clicar em Ativar API se essa solicitação aparecer.
Em seguida, vamos escolher as especificações do banco de dados, a edição Enterprise com a predefinição da edição Sandbox.
Depois disso, defina o nome da instância e a senha padrão do usuário postgres aqui. Você pode configurar isso com as credenciais que quiser. No entanto, para este tutorial, vamos usar "adk-deployment" como nome da instância e senha.
Vamos usar us-central1 com uma única zona neste tutorial. Depois, podemos finalizar a criação do banco de dados e deixar que ele conclua toda a configuração necessária clicando no botão Criar instância.
Enquanto aguardamos a conclusão, podemos continuar para a próxima seção.
Configurar o projeto do Cloud no terminal do Cloud Shell
- Você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud. Clique em "Ativar o Cloud Shell" na parte de cima do console do Google Cloud.
- Depois de se conectar ao Cloud Shell, verifique se sua conta já está autenticada e se o projeto está configurado com seu ID do projeto usando o seguinte comando:
gcloud auth list
- Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.
gcloud config list project
- Se o projeto não estiver definido, use este comando:
gcloud config set project <YOUR_PROJECT_ID>
Também é possível conferir o ID do PROJECT_ID no console.
Clique nele para ver todos os seus projetos e o ID do projeto no lado direito.
- Ative as APIs necessárias com o comando mostrado abaixo. Isso pode levar alguns minutos.
gcloud services enable aiplatform.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudresourcemanager.googleapis.com \
sqladmin.googleapis.com
Após a execução do comando, você vai ver uma mensagem semelhante a esta:
Operation "operations/..." finished successfully.
A alternativa ao comando gcloud é pesquisar cada produto no console ou usar este link.
Se alguma API for esquecida, você sempre poderá ativá-la durante a implementação.
Consulte a documentação para ver o uso e os comandos gcloud.
Acessar o editor do Cloud Shell e configurar o diretório de trabalho do aplicativo
Agora, podemos configurar nosso editor de código para fazer algumas coisas de programação. Vamos usar o editor do Cloud Shell para isso.
- Clique no botão "Abrir editor" para abrir um editor do Cloud Shell. Podemos escrever nosso código aqui
- Verifique se o projeto do Cloud Code está definido no canto inferior esquerdo (barra de status) do editor do Cloud Shell, conforme destacado na imagem abaixo, e se ele está definido como o projeto ativo do Google Cloud em que o faturamento está ativado. Autorize se for solicitado. Se você já segue o comando anterior, o botão também pode apontar diretamente para o projeto ativado em vez do botão de login.
- Em seguida, vamos clonar o diretório de trabalho do modelo para este codelab do GitHub. Execute o seguinte comando: Ele vai criar o diretório de trabalho no diretório deploy_and_manage_adk.
git clone https://github.com/alphinside/deploy-and-manage-adk-service.git deploy_and_manage_adk
- Depois disso, acesse a seção superior do editor do Cloud Shell e clique em Arquivo->Abrir pasta, encontre o diretório nome de usuário e o diretório deploy_and_manage_adk. Em seguida, clique no botão "OK". Isso vai definir o diretório escolhido como o principal de trabalho. Neste exemplo, o nome de usuário é alvinprayuda. Portanto, o caminho do diretório é mostrado abaixo.
Agora, o editor do Cloud Shell vai ficar assim:
Em seguida, podemos configurar o ambiente Python.
Configuração do ambiente
Preparar o ambiente virtual do Python
A próxima etapa é preparar o ambiente de desenvolvimento. O diretório de trabalho do terminal ativo atual precisa estar dentro do diretório de trabalho deploy_and_manage_adk. Vamos usar o Python 3.12 neste codelab e o gerenciador de projetos Python uv para simplificar a necessidade de criar e gerenciar a versão do Python e o ambiente virtual.
- Se você ainda não abriu o terminal, clique em Terminal -> Novo terminal ou use Ctrl + Shift + C. Isso vai abrir uma janela do terminal na parte de baixo do navegador.
- Faça o download do
uve instale o Python 3.12 com o seguinte comando:
curl -LsSf https://astral.sh/uv/0.6.16/install.sh | sh && \
source $HOME/.local/bin/env && \
uv python install 3.12
- Agora vamos inicializar o ambiente virtual usando
uv. Execute este comando:
uv sync --frozen
Isso vai criar o diretório .venv e instalar as dependências. Uma rápida olhada no pyproject.toml vai mostrar informações sobre as dependências, assim:
dependencies = [
"google-adk==1.3.0",
"locust==2.37.10",
"pg8000==1.31.2",
"python-dotenv==1.1.0",
]
- Para testar o ambiente virtual, crie um novo arquivo main.py e copie o seguinte código:
def main():
print("Hello from deploy_and_manage_adk!")
if __name__ == "__main__":
main()
- Em seguida, execute o comando abaixo.
uv run main.py
Você vai receber uma saída como a mostrada abaixo
Using CPython 3.12 Creating virtual environment at: .venv Hello from deploy_and_manage_adk!
Isso mostra que o projeto Python está sendo configurado corretamente.
Configurar arquivos de configuração
Agora precisamos configurar os arquivos de configuração para esse projeto.
Renomeie o arquivo .env.example para .env. O valor abaixo vai aparecer. Atualize o valor de GOOGLE_CLOUD_PROJECT para o ID do seu projeto.
# 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
Neste codelab, vamos usar os valores pré-configurados para GOOGLE_CLOUD_LOCATION e GOOGLE_GENAI_USE_VERTEXAI.. Por enquanto, vamos manter SESSION_SERVICE_URI comentado.
Agora podemos passar para a próxima etapa: inspecionar e implantar a lógica do agente.
3. Criar o agente de clima com o ADK e o Gemini 2.5
Introdução à estrutura de diretórios do ADK
Vamos começar analisando o que o ADK tem a oferecer e como criar o agente. A documentação completa do ADK pode ser acessada neste URL . O ADK oferece muitas utilidades na execução de comandos da CLI. Alguns deles são :
- Configurar a estrutura de diretórios do agente
- Teste rapidamente a interação por entrada e saída da CLI
- Configurar rapidamente a interface da Web da IU de desenvolvimento local
Agora, vamos verificar a estrutura do agente no diretório weather_agent.
weather_agent/ ├── __init__.py ├── agent.py
Se você inspecionar init.py e agent.py, verá 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],
)
Explicação de código do ADK
Esse script contém nossa iniciação do agente, em que inicializamos o seguinte:
- Defina o modelo a ser usado como
gemini-2.5-flash - Forneça a ferramenta
get_weatherpara oferecer suporte à funcionalidade do agente como um agente de clima.
Executar a IU da Web
Agora, podemos interagir com o agente e inspecionar o comportamento dele localmente. O ADK permite ter uma interface da Web de desenvolvimento para interagir e inspecionar o que está acontecendo durante a interação. Execute o comando a seguir para iniciar o servidor da interface de desenvolvimento local:
uv run adk web --port 8080
Ele vai gerar uma saída como o exemplo a seguir, o que significa que já podemos acessar a interface da 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)
Para verificar, clique no botão Visualização da Web na parte superior do Editor do Cloud Shell e selecione Visualizar na porta 8080.
Você vai ver a seguinte página da Web, em que é possível selecionar os agentes disponíveis no botão suspenso no canto superior esquerdo ( no nosso caso, weather_agent) e interagir com o bot. Você vai ver muitas informações sobre os detalhes do registro durante o tempo de execução do agente na janela à esquerda.
Agora tente interagir com ele. Na barra à esquerda, podemos inspecionar o rastreamento de cada entrada para entender quanto tempo leva para cada ação realizada pelo agente antes de formar a resposta final.
Esse é um dos recursos de observabilidade integrados ao ADK. No momento, ele é inspecionado localmente. Mais tarde, vamos ver como isso é integrado ao Cloud Tracing para que tenhamos um rastreamento centralizado de todas as solicitações.
4. O script do servidor de back-end
Para tornar o agente acessível como um serviço, vamos encapsulá-lo em um app FastAPI. Aqui, podemos configurar os serviços necessários para oferecer suporte ao agente, como preparar o serviço Session, Memory ou Artifact para fins de produção. Este é o código do server.py que será usado.
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)
Explicação do código do servidor
Estas são as coisas definidas no script server.py:
- Converta nosso agente em um app FastAPI usando o método
get_fast_api_app. Assim, vamos herdar a mesma definição de rota usada na interface de desenvolvimento da Web. - Configure o serviço de sessão, memória ou artefato necessário adicionando os argumentos de palavra-chave ao método
get_fast_api_app. Neste tutorial, se configurarmos a variável de ambienteSESSION_SERVICE_URI, o serviço de sessão vai usá-la. Caso contrário, ele usará a sessão na memória. - Podemos adicionar uma rota personalizada para oferecer suporte a outras lógicas de negócios de back-end. No script, adicionamos um exemplo de rota de funcionalidade de feedback.
- Ative o rastreamento na nuvem para enviar rastreamentos ao Google Cloud Trace.
5. Como implantar no Cloud Run
Agora, vamos implantar esse serviço de agente no Cloud Run. Para fins desta demonstração, esse serviço será exposto como um serviço público que pode ser acessado por outras pessoas. No entanto, lembre-se de que essa não é a prática recomendada, já que não é segura.
Neste codelab, vamos usar o Dockerfile para implantar nosso agente no Cloud Run. Confira abaixo o conteúdo do Dockerfile que será usado.
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"]
Neste ponto, já temos todos os arquivos necessários para implantar nossos aplicativos no Cloud Run. Vamos fazer isso. Navegue até o terminal do Cloud Shell e verifique se o projeto atual está configurado para seu projeto ativo. Caso contrário, use o comando gcloud configure para definir o ID do projeto:
gcloud config set project [PROJECT_ID]
Em seguida, execute o comando abaixo para implantar no 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 acessar o valor {YOUR_DB_CONNECTION_NAME}, volte ao Cloud SQL e clique na instância que você criou. Na página da instância, role para baixo até a seção Conectar-se a esta instância e copie o nome da conexão para substituir o valor {YOUR_DB_CONNECTION_NAME}. Por exemplo, veja a imagem abaixo
Se você precisar confirmar a criação de um registro de artefato para o repositório do Docker, responda Y. Estamos permitindo o acesso não autenticado porque este é um aplicativo de demonstração. Recomendamos usar a autenticação adequada para seus aplicativos empresariais e de produção.
Quando a implantação for concluída, você vai receber um link semelhante a este:
https://weather-agent-*******.us-central1.run.app
Use o aplicativo na janela anônima ou no dispositivo móvel. Ele já deve estar ativo.
6. Como inspecionar o escalonamento automático do Cloud Run com o teste de carga
Agora vamos inspecionar os recursos de escalonamento automático do Cloud Run. Para este cenário, vamos implantar uma nova revisão e ativar a simultaneidade máxima por instância. Execute este comando
gcloud run deploy weather-agent \
--source . \
--port 8080 \
--project {YOUR_PROJECT_ID} \
--allow-unauthenticated \
--region us-central1 \
--concurrency 10
Depois disso, vamos inspecionar o arquivo load_test.py. Esse será o script usado para fazer o teste de carga com o framework locust. Esse script vai fazer o seguinte :
- user_id e session_id aleatórios
- Crie session_id para o user_id
- Acesse o endpoint "/run_sse" com o user_id e o session_id criados.
Vamos precisar saber o URL do serviço implantado, caso você não tenha anotado. Acesse o console do Cloud Run e clique no serviço weather-agent.
Em seguida, encontre e clique no serviço weather-agent.
O URL do serviço vai aparecer ao lado das informações da região. Exemplo:
Em seguida, execute o comando abaixo para fazer o teste de carga.
uv run locust -f load_test.py \
-H {YOUR_SERVICE_URL} \
-u 60 \
-r 5 \
-t 120 \
--headless
Ao executar esse comando, você vai ver métricas como esta. ( Neste exemplo, todas as solicitações foram bem-sucedidas)
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
Agora vamos ver o que aconteceu no Cloud Run. Acesse novamente o serviço implantado e confira o painel. Isso vai mostrar como o Cloud Run escalona automaticamente a instância para processar as solicitações recebidas. Como estamos limitando a simultaneidade máxima a 10 por instância, a instância do Cloud Run tentará ajustar automaticamente o número de contêineres para atender a essa condição.
7. Lançamento gradual de novas revisões
Agora, considere o seguinte cenário. Queremos atualizar o comando do agente para o seguinte :
# 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],
)
Em seguida, você quer lançar novas revisões, mas não quer que todo o tráfego de solicitações vá diretamente para a nova versão. Podemos fazer um lançamento gradual com o Cloud Run. Primeiro, precisamos implantar uma nova revisão, mas com a flag –no-traffic. Salve o script do agente anterior e execute o seguinte comando:
gcloud run deploy weather-agent \
--source . \
--port 8080 \
--project {YOUR_PROJECT_ID} \
--allow-unauthenticated \
--region us-central1 \
--no-traffic
Depois de terminar, você vai receber um registro semelhante ao processo de implantação anterior, mas com a diferença do número de tráfego atendido. Ela vai mostrar 0% do tráfego veiculado.
Em seguida, acesse a página do produto Cloud Run e encontre sua instância implantada. Digite "cloud run" na barra de pesquisa e clique no produto Cloud Run.
Em seguida, encontre e clique no serviço weather-agent.
Acesse a guia Revisões para ver a lista de revisões implantadas.
Você vai notar que as novas revisões implantadas estão atendendo a 0%. Clique no botão de três pontos (⋮) e escolha Gerenciar tráfego.
Na janela pop-up, edite a porcentagem do tráfego que vai para cada revisão.
Depois de esperar um pouco, o tráfego será direcionado proporcionalmente com base nas configurações de porcentagem. Assim, podemos reverter facilmente para as revisões anteriores se algo acontecer com a nova versão.
8. Rastreamento do ADK
Os agentes criados com o ADK já oferecem suporte ao rastreamento usando a incorporação do OpenTelemetry. Temos o Cloud Trace para capturar e visualizar esses rastreamentos. Vamos inspecionar o server.py para saber como ativar isso no serviço implantado 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)
...
Aqui, inicializamos o rastreador e o exportador. Os detalhes do exportador podem ser inspecionados em tracing.py . Aqui, criamos um exportador personalizado porque há um limite para os dados de rastreamento que podem ser exportados para o Cloud Trace. Estamos usando uma implementação de https://googlecloudplatform.github.io/agent-starter-pack/guide/observability.html (link em inglês) para esse recurso de rastreamento.
Tente acessar a interface de desenvolvimento da Web do serviço e converse com o agente. Depois disso, acesse a barra de pesquisa do console do Cloud, digite "Explorador de traces" e escolha o produto Explorador de traces.
Na página do explorador de rastreamentos, você vai ver que o rastreamento da nossa conversa com o agente foi enviado. Na seção Nome do intervalo, filtre o intervalo específico do nosso agente ( chamado agent_run [weather_agent]).
Quando os intervalos já estão filtrados, também é possível inspecionar cada rastreamento diretamente. Ele vai mostrar a duração detalhada de cada ação realizada pelo agente. Por exemplo, veja as imagens abaixo
Em cada seção, você pode inspecionar os detalhes nos atributos, como mostrado abaixo
Pronto! Agora temos boa capacidade de observação e informações sobre cada interação do nosso agente com o usuário para ajudar a depurar problemas. Teste várias ferramentas ou fluxos de trabalho.
9. Desafio
Teste fluxos de trabalho multiagentes ou com agentes para ver como eles funcionam sob cargas e como é o rastreamento.
10. Limpar
Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste codelab, siga estas etapas:
- No console do Google Cloud, acesse a página Gerenciar recursos.
- Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
- Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.
- Ou acesse Cloud Run no console, selecione o serviço que você acabou de implantar e exclua.