1. Introdução
Neste codelab, você vai implantar um agente único / várias ferramentas de forma segura usando o Kit de Desenvolvimento de Agente (ADK), o Agent Engine e o Google Kubernetes Engine. Você vai aprender como um agente de IA iniciado por um usuário no Gemini Enterprise navega com segurança pelo Google Cloud, usando o gateway do GKE com as extensões de serviço para remover dados sensíveis em trânsito das respostas da ferramenta MCP.
Conteúdo do laboratório
- Implantar um agente assistente de hipoteca do ADK no Agent Engine com instrumentação do OpenTelemetry
- Implantar servidores MCP de back-end no Google Kubernetes Engine (GKE) atrás de um gateway interno
- Conectar o Agent Engine a uma VPC de projeto usando uma interface do PSC e o peering de DNS
- Expor APIs REST como ferramentas do MCP usando o proxy de descoberta do MCP da Apigee
- Configurar o gateway do GKE para saída de agente controlada com extensões de serviço para encobrimento de DLP e autorização de MCP
- Aplicar proteções de IA com o Model Armor para análise de comandos e respostas
O que é necessário
- Um navegador da web, como o Chrome
- Tenha um projeto do Google Cloud com o faturamento ativado.
- Conhecimento básico de Terraform, Kubernetes e Python
Este codelab é destinado a desenvolvedores e profissionais de segurança que querem implantar e proteger Agentic Workflows em ambientes corporativos.
2. Antes de começar
Criar um projeto do Google Cloud e ativar as APIs necessárias.
- No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto na nuvem.
- Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto.
Papéis do IAM obrigatórios
Neste codelab, pressupomos que você tenha o papel de Proprietário do projeto do seu projeto na nuvem do Google Cloud.
Ativar APIs
- No console do Google Cloud, clique em Ativar o Cloud Shell. Se você nunca usou o Cloud Shell, um painel vai aparecer com a opção de iniciar o Cloud Shell em um ambiente confiável com ou sem um boost. Se for solicitado que você autorize o Cloud Shell, clique em Autorizar.
- No Cloud Shell, ative todas as APIs necessárias:
gcloud services enable \ compute.googleapis.com \ container.googleapis.com \ dns.googleapis.com \ certificatemanager.googleapis.com \ dlp.googleapis.com \ aiplatform.googleapis.com \ discoveryengine.googleapis.com \ apigee.googleapis.com
Instalar dependências
No Cloud Shell, verifique se as ferramentas necessárias estão instaladas. O Terraform, o kubectl e o Go geralmente são pré-instalados. É preciso instalar o uv (o gerenciador de pacotes do Python) e o Skaffold:
# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh
# Install Skaffold
curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 && \
sudo install skaffold /usr/local/bin/
Defina as variáveis de ambiente
Defina as seguintes variáveis de ambiente que são usadas neste codelab:
export PROJECT_ID=$(gcloud config get project)
export REGION=us-central1
export LOCATION=${REGION}
Criar uma zona de DNS pública
Este codelab requer que uma zona de DNS pública já exista no projeto antes de aplicar a configuração do Terraform. Essa zona é necessária para a delegação do servidor de nomes, de modo que a configuração possa automatizar a criação dos registros necessários para o Certificate Manager.
Execute o seguinte comando no Cloud Shell para criar a zona:
gcloud dns managed-zones create "inference-gateway-zone" \
--dns-name="gateway.example.com." \
--description="Public zone for Inference Gateway" \
--visibility="public" \
--project="${PROJECT_ID}"
3. Clonar um repositório do GitHub
- Em um terminal na máquina local, clone o repositório
cloud-networking-solutions:git clone https://github.com/googleCloudPlatform/cloud-networking-solutions.git - Acesse o diretório do repositório que você baixou:
cd cloud-networking-solutions/demos/service-extensions-gke-gateway
4. Implantar a infraestrutura com o Terraform
Você vai usar o Terraform para provisionar a rede básica, o cluster do GKE e as configurações de identidade necessárias.
- Acesse o diretório
terraformno repositório clonado:cd terraform - Configure o back-end do Terraform. Crie um arquivo
backend.confpara a configuração parcial do back-end. Substituapor um nome de bucket globalmente exclusivo.cat <<EOF > backend.conf bucket = "<YOUR_TERRAFORM_STATE_BUCKET>" prefix = "terraform" EOF
- Copie o arquivo de variáveis de exemplo e atualize-o com os valores do seu projeto:
cp example.tfvars terraform.tfvars - Edite
terraform.tfvarse substitua os valores do marcador de posição.Substitua o seguinte:- project_id: o ID do seu projeto do Google Cloud.
- organization_id: o ID da organização numérico do GCP.
- dns_zone_domain: um domínio que você controla (por exemplo,
demo.example.com.). Precisa terminar com um ponto.
enable_certificate_manager = trueenable_model_armor = trueenable_agent_engine = trueenable_psc_interface = true
- Inicialize e aplique a configuração do Terraform:
terraform init -backend-config=backend.conf terraform plan -out=tfplan terraform apply "tfplan"
5. Implantar cargas de trabalho de amostra com o Skaffold
Em seguida, implante os servidores MCP e os serviços de processamento externo no cluster do GKE.
- Conecte-se ao cluster do GKE criado pelo Terraform:
gcloud container clusters get-credentials gateway-cluster \ --region=${REGION} \ --project=${PROJECT_ID} - Volte para a raiz do projeto e configure os modelos de manifesto do Kubernetes. Copie o exemplo de configuração e defina o ID do projeto e o domínio base:defina
BASE_DOMAINpara corresponder ao seu ambiente. OBASE_DOMAINprecisa corresponder à variável do Terraformdns_zone_domain(sem o ponto final).export BASE_DOMAIN=example.com - Gere os manifestos do Kubernetes e
skaffold.yamlusando modelos:bash k8s/generate.sh envsubst '${PROJECT_ID}' < skaffold.yaml.tmpl > skaffold.yaml - Implante todos os serviços de back-end:
skaffold run -m legacy-dms,income-verification-api,corporate-email,dlp-ext-proc - Implante a configuração do gateway e do HTTPRoute:
kubectl apply -k k8s/gateway-internal/
6. Aplicar proteções de IA com o Model Armor
É possível delegar decisões de segurança de conteúdo, como remover comandos nocivos ou evitar vazamentos de dados, ao Model Armor.
Pré-requisitos: conceder papéis do IAM
É preciso conceder os papéis necessários à conta de serviço do gateway do GKE. A conta de serviço segue o formato: service-GATEWAY_PROJECT_NUMBER@gcp-sa-dep.iam.gserviceaccount.com.
Execute os comandos a seguir para conceder as permissões necessárias:
export GATEWAY_PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
# Grant roles in the Gateway project
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
--role=roles/modelarmor.calloutUser
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
--role=roles/serviceusage.serviceUsageConsumer
# Grant role in the project containing Model Armor templates
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
--role=roles/modelarmor.user
Criar a extensão de autorização do Model Armor
Defina uma extensão que aponte para o serviço do Model Armor na sua região. Salve essa configuração como ma-content-authz-extension.yaml.
Exporte o ID do modelo do Model Armor criado pelo Terraform.
export MA_TEMPLATE_ID=$(cd terraform && terraform output -raw model_armor_template_id)
cat >ma-content-authz-extension.yaml <<EOF
name: ma-ext
service: modelarmor.$LOCATION.rep.googleapis.com
metadata:
model_armor_settings: '[
{
"response_template_id": "projects/${PROJECT_ID}/locations/$LOCATION/templates/${MA_TEMPLATE_ID}",
"request_template_id": "projects/${PROJECT_ID}/locations/$LOCATION/templates/${MA_TEMPLATE_ID}"
}
]'
failOpen: true
EOF
gcloud beta service-extensions authz-extensions import ma-ext \
--source=ma-content-authz-extension.yaml \
--location=$LOCATION
Criar a política de autorização do Model Armor
Crie uma política que associe a extensão do Model Armor ao seu Gateway de Agente. Salve essa configuração como ma-content-authz-policy.yaml.
cat >ma-content-authz-policy.yaml <<EOF
name: ma-content-authz-policy
target:
resources:
- "projects/$PROJECT_ID/locations/$LOCATION/gateways/mortgage-gateway"
policyProfile: CONTENT_AUTHZ
action: CUSTOM
customProvider:
authzExtension:
resources:
- "projects/$PROJECT_ID/locations/$LOCATION/authzExtensions/ma-ext"
EOF
gcloud network-security authz-policies import ma-content-authz-policy \
--source=ma-content-authz-policy.yaml \
--location=$LOCATION
7. Configurar o Gemini Enterprise
Ativar observabilidade
O agente de hipoteca é implantado com a instrumentação do OpenTelemetry e as seguintes variáveis de ambiente de telemetria ativadas por padrão:
GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY=trueOTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=trueOTEL_TRACES_SAMPLER=parentbased_traceidratio
Para saber como configurar traces e períodos no Gemini Enterprise, consulte Gerenciar configurações de observabilidade.
Ativar o Model Armor no Gemini Enterprise
Aplicar a filtragem do Model Armor ao assistente do Gemini Enterprise para analisar os comandos do usuário e as respostas do modelo. Os apps globais do Gemini Enterprise exigem um modelo do Model Armor na multirregião us. Por isso, o Terraform implanta um modelo separado para essa finalidade.
Recupere o nome do modelo na saída do Terraform:
cd terraform
export GE_MA_TEMPLATE_NAME=$(terraform output -raw model_armor_gemini_enterprise_template_name)
Busque o ID do app da sua instância do Gemini Enterprise:
- No console do Google Cloud, acesse a página do Gemini Enterprise.
- No menu de navegação, clique em "Apps".
- Copie o ID da instância do Gemini Enterprise
Exporte o ID como uma variável de ambiente.
export APP_ID=<PASTE_APP_ID>
Atualize o assistente para ativar o Model Armor:
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-H "X-Goog-User-Project: ${PROJECT_ID}" \
"https://global-discoveryengine.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/collections/default_collection/engines/${APP_ID}/assistants/default_assistant?update_mask=customerPolicy" \
-d '{
"customerPolicy": {
"modelArmorConfig": {
"userPromptTemplate": "'"$GE_MA_TEMPLATE_NAME"'",
"responseTemplate": "'"$GE_MA_TEMPLATE_NAME"'",
"failureMode": "FAIL_OPEN"
}
}
}'
Defina failureMode como FAIL_OPEN para permitir solicitações quando o Model Armor estiver indisponível ou FAIL_CLOSED para bloqueá-las.
8. Implantar e adicionar um agente no Gemini Enterprise
Receber detalhes da autorização
Siga estas etapas para receber os detalhes da autorização.
- No console do Google Cloud, na página "APIs e serviços", acesse a página "Credenciais".
- Acesse Credenciais.
- Clique em Criar credenciais e selecione ID do cliente OAuth.
- Em "Tipo de aplicativo", selecione "Aplicativo da Web".
- Na seção "URIs de redirecionamento autorizados", adicione os seguintes URIs:
- https://vertexaisearch.cloud.google.com/oauth-redirect
- https://vertexaisearch.cloud.google.com/static/oauth/oauth.html
- Clique em "Criar".
- Exporte o ID do cliente e a chave secreta do cliente para implantação.
export OAUTH_CLIENT_ID=<Client ID>
export OAUTH_CLIENT_SECRET=<Client Secret>
Implantar o agente de hipotecas
O script src/mortgage-agent/deploy_agent.py implanta o agente do ADK no Agent Engine e, opcionalmente, o registra no Gemini Enterprise. Consulte Registrar e gerenciar um agente A2A para saber mais sobre o fluxo de registro do Gemini Enterprise.
Exportar variáveis da implantação do Terraform.
export VPC_NAME=$(cd terraform && terraform output -raw vpc_name)
export PSC_ATTACHMENT=$(cd terraform && terraform output -raw psc_interface_network_attachment_id)
export DNS_PEERING_DOMAIN=$(cd terraform && terraform output -raw psc_interface_dns_peering_domain)
Instale as dependências e implante:
cd src/mortgage-agent
uv sync
Implante o agente no Vertex Agent Engine e registre-o no Gemini Enterprise:
uv run python deploy_agent.py \
--project=${PROJECT_ID} \
--dms-mcp-url=https://dms.${DNS_PEERING_DOMAIN%%.}/mcp \
--income-verification-url=https://income-verification.${DNS_PEERING_DOMAIN%%.} \
--email-mcp-url=https://email.${DNS_PEERING_DOMAIN%%.}/mcp \
--network-attachment=projects/${PROJECT_ID}/regions/${REGION}/networkAttachments/${PSC_ATTACHMENT} \
--dns-peering-domain=${DNS_PEERING_DOMAIN} \
--dns-peering-target-project=${PROJECT_ID} \
--dns-peering-target-network=${VPC_NAME} \
--enable-agent-identity \
--ge-deploy \
--app-id=${APP_ID} \
--oauth-client-id=${OAUTH_CLIENT_ID} \
--agent-name=mortgage-agent
Referência da flag
Flag | padrão | Descrição |
|
| ID do projeto do GCP |
| (obrigatório) | URL do servidor MCP do DMS |
| (obrigatório) | URL de base da API Income Verification. |
| (obrigatório) | URL do servidor MCP de e-mail |
|
| Região do GCP |
|
| Bucket do GCS para preparo |
|
| Nome de exibição do agente implantado |
| (opcional) | Atualizar um agente atual no local (transmitir o nome completo do recurso) |
| (opcional) | Anexo de rede para interface do PSC (caminho completo ou nome) |
| (opcional) | Domínio DNS para peering de DNS do PSC-I (precisa terminar com um ponto) |
| (opcional) | Projeto que hospeda a rede VPC de destino para peering de DNS |
| (opcional) | Nome da rede VPC para peering de DNS |
|
| Ativar credenciais de privilégio mínimo por agente |
|
| Registrar o agente no Gemini Enterprise após a implantação |
| (opcional) | ID do mecanismo do Gemini Enterprise (obrigatório com |
|
| ID do cliente OAuth 2.0 (obrigatório com |
|
| Chave secreta do cliente OAuth2 (obrigatória com |
|
| Nome do modelo do Gemini para o agente |
|
| Autorização do Gemini Enterprise e nome do agente |
| (opcional) | Registrar um mecanismo de raciocínio no Gemini Enterprise sem reimplantar (transmitir o nome completo do recurso) |
Adicionar usuários com permissão
Para adicionar usuários com permissão a um agente do ADK usando o console do Google Cloud, consulte Adicionar ou modificar usuários e as permissões deles.
9. Teste seu agente
Agora que você implantou e configurou o agente, o gateway do GKE e todos os serviços de back-end, teste o fluxo de ponta a ponta para verificar se as políticas de segurança estão funcionando conforme o esperado. Você vai interagir com o "mortgage-agent" na interface do Gemini Enterprise.
Acessar o agente
- Acesse a página do Gemini Enterprise no console do Google Cloud.
- Selecione o app do Gemini Enterprise que você configurou anteriormente, em que o "mortgage-agent" está registrado.
- Na guia "Visão geral", acesse o URL mostrado na seção "Seu app da Web do Gemini Enterprise está pronto".
- Selecione a guia "Agente" no menu à esquerda, chamada Galeria de agentes.
- Agora você pode conversar com o "Agente assistente de hipotecas".
Caso de teste 1: o cenário ideal: resumir dados com encobrimento de PII
Esse teste verifica se o agente pode acessar sistemas de back-end pelo Gateway de Agente e se as políticas de prevenção contra perda de dados (DLP) são aplicadas para ocultar informações sensíveis.
- Envie o seguinte comando para o agente de assistente de hipoteca:
I'm reviewing the Sterling family's current application. Can you summarize their 2024 and 2025 tax returns and verify if their total household income meets our 2026 debt-to-income requirements? - O que acontece nos bastidores:
- O agente no Gemini Enterprise formula solicitações para as ferramentas necessárias (por exemplo, o sistema de gerenciamento de documentos (DMS) para declarações de impostos, API Income Verification).
- O Model Armor inspeciona os payloads de solicitação e resposta em busca de ameaças.
- A "Política de autorização baseada em conteúdo" que você configurou aciona a extensão de DLP personalizada (
dlp-content-authz-ext). Essa extensão inspeciona os dados buscados nos sistemas de back-end. - O serviço de DLP encobre todas as informações de identificação pessoal (PII), como números de CPF, dos dados da declaração de imposto de renda antes que eles cheguem ao agente.
- Resultado esperado: o agente vai retornar um resumo das declarações de imposto de renda e um status de verificação de renda. Analise criticamente o resumo fornecido pelo agente. Observe que as informações sensíveis, como os SSNs, foram substituídas por marcadores de posição (por exemplo,
[REDACTED]). Isso confirma a execução da política de DLP pelo gateway.
Observabilidade e auditoria
Durante esses testes, a Agent Platform e os serviços associados estão coletando telemetria:
- Cloud Logging: registros detalhados do gateway do GKE, das cargas de trabalho do GKE e de outros serviços fornecem uma trilha de auditoria de solicitações, avaliações de políticas e resultados.
- Cloud Trace: a instrumentação do OpenTelemetry configurada no agente e nos serviços de back-end permite visualizar todo o fluxo de chamadas, do Gemini Enterprise até as ferramentas de back-end, passando pelo gateway do GKE. Isso é muito útil para depurar e entender o ciclo de vida da solicitação.
Ver os traces das suas sessões:
- No console do Google Cloud, acesse a página do Vertex AI Agent Engine.
- Acesse o Agent Engine. As instâncias do Agent Engine que fazem parte do projeto selecionado aparecem na lista. Use o campo "Filtro" para filtrar a lista pela coluna especificada.
- Clique no nome da instância do Agent Engine.
- Clique na guia "Traces".
- É possível selecionar a visualização de sessão ou de período.
- Clique em uma sessão ou período para inspecionar os detalhes do trace, incluindo um gráfico acíclico dirigido (DAG) dos períodos, entradas e saídas e atributos de metadados.
10. Opcional: transcodificar APIs REST para MCP com a Apigee
Embora nosso serviço de verificação de renda seja compatível nativamente com o Protocolo de Contexto de Modelo, muitos sistemas legados corporativos oferecem apenas APIs RESTful. Nesta etapa opcional, você vai usar o proxy de descoberta do MCP da Apigee para transcodificar o endpoint REST do serviço de verificação de renda em uma ferramenta do MCP. Isso permite aplicar as políticas avançadas de governança, limitação de taxa e segurança da Apigee às suas ferramentas legadas.
Para mais informações, consulte a visão geral do MCP da Apigee.
Pré-requisitos
Antes de continuar, verifique se você provisionou e configurou o hub de APIs da Apigee. Siga as etapas na documentação Provisionar o hub de APIs para configurá-lo e anexar sua instância da Apigee.
Etapa 1: criar um anexo de serviço para a Apigee
Para permitir que a Apigee alcance os serviços internos em execução no GKE, é preciso criar um anexo de serviço.
- Procure a regra de encaminhamento do gateway interno do GKE:
export RULE_URI=$(gcloud compute forwarding-rules list \ --filter="loadBalancingScheme=INTERNAL_MANAGED AND target~targetHttpsProxies" \ --format="value(selfLink.segment(6), region.basename(), name)" | \ awk '{print "projects/" $1 "/regions/" $2 "/forwardingRules/" $3}') - Crie o anexo do serviço:
gcloud compute service-attachments create internal-gke-gateway-apigee \ --region=${REGION} \ --target-service=$RULE_URI \ --connection-preference=ACCEPT_AUTOMATIC \ --nat-subnets=gateway-psc-subnet
Etapa 2: ativar a Apigee com o Terraform
Agora, atualize a configuração da infraestrutura para provisionar a organização e a instância da Apigee.
- Navegue até o diretório
terraform:cd terraform - Edite
terraform.tfvarse definaenable_apigee = true. - Aplique as alterações:
terraform apply
Etapa 3: definir a especificação OpenAPI
A Apigee usa definições padrão da OpenAPI (OAS) para descobrir e transcodificar ferramentas. Crie um arquivo chamado income-verification-oas.yaml com o conteúdo a seguir:
openapi: 3.0.0
info:
title: Income Verification API
description: Verify applicant income through third-party employer records.
version: 1.0.0
servers:
- url: https://income-verification.internal.${DNS_PEERING_DOMAIN%%.}/api
paths:
/income-verification/verify:
post:
summary: Verify applicant income
operationId: verifyApplicant
requestBody:
required: true
content:
application/json:
schema:
type: object
properties:
first_name:
type: string
last_name:
type: string
responses:
'200':
description: Successful verification
content:
application/json:
schema:
type: object
Etapa 4: implantar o proxy de descoberta do MCP da Apigee
O proxy de descoberta do MCP é um proxy especializado da Apigee que atua como um servidor MCP.
- Na IU da Apigee, acesse Desenvolver > Proxies de API.
- Clique em Criar novo e selecione Proxy de descoberta do MCP.
- Nomeie o proxy como
income-verification-discovery. - Na seção Especificação da OpenAPI, faça upload do arquivo
income-verification-oas.yamlque você criou. - Defina o Grupo de ambientes como aquele em que o gateway interno está acessível.
- Clique em Implantar.
(Opcional) Adicionar uma política de segurança
Antes de implantar ou compartilhar o proxy, proteja-o. É possível adicionar políticas para aplicar requisitos de segurança, como tokens OAuth ou chaves de API. Para instruções sobre como adicionar uma política de segurança, consulte a documentação da Apigee sobre como proteger APIs.
Etapa 5: verificar o acesso à ferramenta transcodificada
Depois de implantado, a Apigee transcodifica automaticamente o endpoint POST /verify em uma ferramenta MCP verifyApplicant.
- Liste as ferramentas disponíveis pelo endpoint do MCP da Apigee:
curl -X POST https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp \ -H "Content-Type: application/json" \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {} }' - A ferramenta
verifyApplicantvai aparecer na resposta, transcodificada da sua especificação REST. Agora, é possível chamar essa ferramenta pela Apigee, que vai processar a tradução para o serviço REST subjacente e aplicar as políticas de segurança que você configurou.
Etapa 6: atualizar o agente de hipotecas para usar a Apigee
Agora que a Apigee está transcodificando sua API REST em uma ferramenta compatível com o MCP, você precisa atualizar a configuração de implantação do agente. Ao apontar o agente para o endpoint da Apigee, todas as solicitações de verificação de renda agora vão se beneficiar da segurança, do registro e do gerenciamento de tráfego de nível empresarial da Apigee.
- Identifique o URL do MCP da Apigee: seu endpoint precisa seguir o padrão:
https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp. - Execute novamente o script de implantação: use a flag
--updatecom o novo--income-verification-url. Isso atualiza o agente atual no Agent Engine sem exigir um Full Delete.cd src/mortgage-agent # Update the agent to route income verification through Apigee uv run python deploy_agent.py \ --project=${PROJECT_ID} \ --update \ --agent-name=mortgage-agent \ --dms-mcp-url=https://dms.${DNS_PEERING_DOMAIN%%.}/mcp \ --income-verification-url=https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp \ --email-mcp-url=https://email.${DNS_PEERING_DOMAIN%%.}/mcp \ --network-attachment=projects/${PROJECT_ID}/regions/${REGION}/networkAttachments/${PSC_ATTACHMENT} \ --dns-peering-domain=${DNS_PEERING_DOMAIN} \ --dns-peering-target-project=${PROJECT_ID} \ --dns-peering-target-network=${VPC_NAME} \ --ge-deploy \ --app-id=${APP_ID} \ --oauth-client-id=${OAUTH_CLIENT_ID}
- Verifique a mudança: volte à interface do Gemini Enterprise e peça ao agente para verificar a renda de um candidato.
Na guia Depuração da Apigee, você vai ver a solicitação JSON-RPC recebida do gateway do GKE sendo transformada em uma solicitação REST"Can you verify the joint income for the Sterlings using the verification service?"POSTpadrão para o serviço de back-end do GKE.
11. Limpar
Para evitar cobranças na sua conta do Google Cloud pelos recursos criados neste codelab, exclua-os quando terminar.
- Exclua o anexo de serviço se ele tiver sido criado manualmente:
gcloud compute service-attachments delete internal-gke-gateway \ --region=${REGION} --quiet - Navegue até o diretório
terraforme destrua todos os recursos:cd terraform terraform destroy - Se quiser, exclua todo o projeto na nuvem do Google Cloud:
gcloud projects delete ${PROJECT_ID}
12. Parabéns
Você concluiu este codelab e aprendeu a proteger implantações empresariais com agentes entre nuvens.
Conteúdo abordado
- Implantou um agente assistente de hipoteca do ADK no Agent Engine com instrumentação do OpenTelemetry
- Servidores MCP de back-end implantados no GKE atrás de um gateway interno
- Conexão do Agent Engine a uma VPC de projeto usando uma interface do PSC e peering de DNS
- Configuração do gateway do GKE para saída de agente controlada com edição de DLP e autorização de MCP
- Aplicação de proteções de IA com o Model Armor para análise de comandos e respostas
- APIs REST transcodificadas opcionalmente para MCP usando o proxy de descoberta do MCP da Apigee
Próximas etapas
- Conheça o Model Armor
- Leia sobre o Agent Engine
- Conheça o Gemini Enterprise