Configura políticas de administración semántica

Configura las políticas de administración semántica y el Policy Engine

En esta sección, se aborda la transición de la preparación de la infraestructura a la creación de políticas.

Requisitos previos

Antes de configurar las políticas de gobernanza semánticas, completa los siguientes pasos.

Habilita las APIs obligatorias

Antes de comenzar, habilita las APIs necesarias para la política de administración semántica y sus componentes de red:

gcloud services enable \
    aiplatform.googleapis.com \
    agentregistry.googleapis.com \
    networkservices.googleapis.com \
    networksecurity.googleapis.com \
    compute.googleapis.com \
    dns.googleapis.com \
    --project=PROJECT_ID

Otorga permisos de IAM a la cuenta de servicio de Vertex AI (solo vinculación administrada por Google)

Si usas la opción de vinculación administrada por Google durante el aprovisionamiento, otorga a la cuenta de servicio de Vertex AI (P4SA) los roles que necesita para crear el extremo de Private Service Connect (PSC) (roles/compute.networkAdmin) y el conjunto de registros DNS (roles/dns.admin) en tu proyecto. Si usas la opción Vinculación autoadministrada, puedes omitir este paso, ya que tú mismo creas esos recursos de red.

Crea la identidad de servicio (idempotente) y otorga los roles:

export PROJECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")

gcloud beta services identity create \
    --service=aiplatform.googleapis.com \
    --project=PROJECT_ID

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:service-${PROJECT_NUM}@gcp-sa-aiplatform.s3ns-system.iam.gserviceaccount.com" \
    --role="roles/compute.networkAdmin"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:service-${PROJECT_NUM}@gcp-sa-aiplatform.s3ns-system.iam.gserviceaccount.com" \
    --role="roles/dns.admin"

Los comandos de eliminación correspondientes se encuentran en Quita las vinculaciones de IAM en la sección de limpieza.

Requisitos de elegibilidad de los agentes

Para que aparezca en el selector de agentes de una política de administración semántica en la consola deCloud de Confiance , el motor de razonamiento de un agente debe haberse implementado con ambos identity_type=AGENT_IDENTITY y agent_gateway_config configurados. Si falta alguno de ellos, la consola de Cloud de Confiance filtra el agente fuera del selector. En su lugar, la API y gcloud devuelven un error explícito.

Para implementar un agente que cumpla con estos requisitos, sigue las instrucciones que se indican en Enruta el tráfico de Agent Runtime a través de Agent Gateway. Ambos campos son inmutables en un motor de razonamiento existente, por lo que un agente implementado sin ellos debe volver a implementarse; la aplicación de parches no funcionará.

Para verificar que un agente existente sea apto, confirma que el spec.effectiveIdentity de su motor de razonamiento comience con agents.global.:

gcloud ai reasoning-engines describe REASONING_ENGINE_ID \
    --region=LOCATION \
    --project=PROJECT_ID \
    --format='value(spec.effectiveIdentity)' \
    | grep -q '^agents.global.' \
    && echo "Eligible" || echo "Not eligible"

Ubicaciones admitidas

El motor de políticas de administración semántica y las políticas de administración semántica son compatibles con las siguientes ubicaciones regionales:

Aprovisionamiento y habilitación

Habilitar el motor de políticas de administración semántica. Esto aprovisiona el entorno de ejecución necesario. Por lo general, el aprovisionamiento tarda entre 2 y 3 minutos en completarse. Sin embargo, cuando la demanda es alta o el grupo de preparación se está reabasteciendo, el aprovisionamiento puede tardar hasta 20 minutos. Elige una de las siguientes opciones para el aprovisionamiento:

• Vinculación administrada por Google: Google crea los recursos de red subyacentes en tu proyecto de Cloud de Confiance by S3NS y administra su ciclo de vida automáticamente.
• Vinculación autoadministrada: Creas y administras los recursos de red necesarios (network, subnetwork y dnsZoneName) directamente en tu proyecto de Cloud de Confiance by S3NS .

Después de completar el aprovisionamiento, debes conectar el motor de políticas a Agent Gateway.

Vinculación administrada por Google

curl -X PATCH \
    "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/semanticGovernancePolicyEngine?updateMask=gatewayConfigs" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{ "gatewayConfigs": {
        "GATEWAY_NAME": {
          "network": "NETWORK_NAME",
            "subnetwork": "SUBNETWORK_NAME",
            "dnsZoneName": "DNS_NAME" }
        }
      }'

gcloud beta ai semantic-governance-policy-engine update \
--location=LOCATION \
--project=PROJECT_ID \
--gateway-config="name='GATEWAY_NAME',network=NETWORK_NAME,subnetwork=SUBNETWORK_NAME,dns-zone-name=DNS_NAME"

Reemplaza lo siguiente:

• GATEWAY_NAME por un nombre de puerta de enlace único.
• DNS_NAME por el nombre de la zona del DNS privada que se usará.
• PROJECT_ID por el ID del proyecto de Cloud de Confiance by S3NS (projects/PROJECT_ID/global/networks/default). Si usas una red y una subred personalizadas, reemplaza las rutas de recursos completas de network y subnetwork según corresponda.

Recupera el nombre de host de DNS generado automáticamente

Cuando aprovisionas el motor con la vinculación administrada por Google, Google crea automáticamente un extremo de Private Service Connect (PSC) y registra un registro A de DNS en tu zona del DNS privada. El FQDN de este registro funciona como el SGP_DNS_HOSTNAME y se propaga en el campo de solo salida dnsRecord de la configuración de tu puerta de enlace.

Para recuperar el nombre de host de DNS generado automáticamente, sigue estos pasos:

gcloud beta ai semantic-governance-policy-engine describe \
    --location=LOCATION \
    --project=PROJECT_ID

curl "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/semanticGovernancePolicyEngine" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)"

En la respuesta, busca el campo dnsRecord en gatewayConfigs.GATEWAY_NAME.dnsRecord. Guarda este FQDN, ya que lo necesitarás como SGP_DNS_HOSTNAME cuando conectes el motor de políticas a Agent Gateway.

Vinculación autoadministrada

curl  -X PATCH "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/semanticGovernancePolicyEngine" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "projects/PROJECT_ID/locations/LOCATION/semanticGovernancePolicyEngine"
    }'

gcloud beta ai semantic-governance-policy-engine update \
    --location=LOCATION \
    --project=PROJECT_ID

Este comando devuelve una operación de larga duración. Puedes consultar el estado de la operación reemplazando OPERATION por el valor name de la respuesta:

curl "https://LOCATION-aiplatform.googleapis.com/v1beta1/OPERATION" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json"

Como alternativa, verifica el estado general del motor hasta que el campo state devuelva ACTIVE:

curl "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/semanticGovernancePolicyEngine" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json"

Configura la red (solo para la opción autoadministrada)

Después de aprovisionar el motor de políticas, configura los componentes de red necesarios para que Agent Gateway se comunique con el motor de políticas.

Mientras que Google crea automáticamente el extremo de PSC en un proyecto de usuario administrado por Google para la ruta administrada por Google, para la ruta autoadministrada, debes crear y administrar manualmente el extremo de PSC en tu propio proyecto de Cloud de Confiance by S3NS .

1. Aprovisiona la red y la subred de VPC

En este paso, crearás una red de VPC, una subred y una subred de solo proxy para el tráfico de agentes. Los rangos de IP que se muestran (10.11.12.0/24 y 10.11.13.0/24) son ejemplos. Puedes usar cualquier rango privado RFC 1918 que se ajuste al diseño de tu red.

1. Crea la red de VPC:

   gcloud compute networks create NETWORK_NAME \
       --subnet-mode=auto \
       --project=PROJECT_ID
   

   Reemplaza NETWORK_NAME por el nombre de tu red de VPC (por ejemplo, agent-network).

2. Crea la subred:

   gcloud compute networks subnets create SUBNET_NAME \
       --network=NETWORK_NAME \
       --region=LOCATION \
       --range=10.11.12.0/24 \
       --project=PROJECT_ID
   

   Reemplaza SUBNET_NAME por el nombre de la subred (por ejemplo, agent-subnet).

3. Crea la subred de solo proxy (obligatoria para los balanceadores de cargas administrados):

   gcloud compute networks subnets create PROXY_SUBNET_NAME \
       --network=NETWORK_NAME \
       --region=LOCATION \
       --range=10.11.13.0/24 \
       --purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE \
       --project=PROJECT_ID
   

   Reemplaza PROXY_SUBNET_NAME por el nombre de tu subred de solo proxy (por ejemplo, agent-proxy-subnet).

2. Aprovisiona una zona del DNS privada

Crea una zona del DNS privada para permitir que Agent Gateway resuelva el nombre de host del motor de políticas:

gcloud dns managed-zones create DNS_ZONE_NAME \
    --description="Private zone for my internal agentic VPC services" \
    --dns-name="internal.example.com." \
    --visibility=private \
    --networks=NETWORK_NAME \
    --project=PROJECT_ID

Replace the following:

• DNS_ZONE_NAME: Es el nombre de tu zona del DNS (por ejemplo, my-private-zone).
• internal.example.com.: Es el nombre de DNS de tu zona, incluido el punto final.

3. Crea un adjunto de red

Crea un adjunto de red para permitir que Agent Gateway se conecte a los recursos de tu VPC. La preferencia de conexión debe establecerse en ACCEPT_AUTOMATIC.

gcloud compute network-attachments create NETWORK_ATTACHMENT_NAME \
    --region=LOCATION \
    --subnets=SUBNET_NAME \
    --connection-preference=ACCEPT_AUTOMATIC \
    --project=PROJECT_ID

Replace the following:

• NETWORK_ATTACHMENT_NAME: Es el nombre del adjunto de red (por ejemplo, sgp-nw-attachment).
• SUBNET_NAME: Es la subred que creaste en el paso 1.

4. Crea una IP estática, un extremo de PSC y un registro DNS

Reserva una dirección IP estática, crea un extremo de Private Service Connect (PSC) que apunte al adjunto de servicio del motor de políticas y crea un registro DNS para que se pueda acceder a él.

# Reserve a static IP address
gcloud compute addresses create STATIC_IP_NAME \
    --region=LOCATION \
    --subnet=SUBNET_NAME \
    --purpose=GCE_ENDPOINT \
    --project=PROJECT_ID

# Capture the reserved IP address
IP=$(gcloud compute addresses describe STATIC_IP_NAME \
    --region=LOCATION \
    --project=PROJECT_ID \
    --format=value(address))

# Create the PSC endpoint
gcloud compute forwarding-rules create PSC_ENDPOINT_NAME \
    --region=LOCATION \
    --network=NETWORK_NAME \
    --address=STATIC_IP_NAME \
    --target-service-attachment=PSC_SERVICE_ATTACHMENT \
    --project=PROJECT_ID

# Create a DNS A record for the policy engine
gcloud dns record-sets create SGP_DNS_HOSTNAME \
    --zone=DNS_ZONE_NAME \
    --type=A \
    --ttl=300 \
    --rrdatas=$IP \
    --project=PROJECT_ID

Reemplaza lo siguiente:

• STATIC_IP_NAME: el nombre de tu dirección IP reservada (por ejemplo, sgp-psc-ip).
• PSC_ENDPOINT_NAME: Es el nombre de tu extremo de PSC (por ejemplo, sgp-psc-endpoint).
• PSC_SERVICE_ATTACHMENT: Es el valor pscServiceAttachment guardado de la respuesta de aprovisionamiento.
• SGP_DNS_HOSTNAME: un nombre de host en tu zona del DNS privada, con el formato LOCATION.DNS_ZONE_SUFFIX, en el que DNS_ZONE_SUFFIX es el nombre de DNS que especificaste cuando creaste tu zona del DNS privada. Por ejemplo, si tu ubicación es us-west1 y el sufijo de tu zona del DNS es internal.example.com, usa us-west1.internal.example.com.

5. Configura la conectividad de VPC en Agent Gateway

Después de crear los recursos de red, debes registrar el adjunto de red y el intercambio de tráfico de DNS en tu Agent Gateway para que pueda comunicarse con el Policy Engine a través de la red privada.

Para obtener instrucciones detalladas, consulta Configura la conectividad de VPC en la guía de configuración de Agent Gateway. Como mínimo, debes hacer lo siguiente:

• Registra el adjunto de red creado en el paso 3 con la configuración de salida de Agent Gateway.
• Registra el intercambio de tráfico de DNS para que la puerta de enlace pueda resolver el nombre de host de DNS privado creado en el paso 4.

Conecta el motor de políticas a Agent Gateway

Después de configurar la red, debes crear una extensión de autorización y una política de autorización para que Agent Gateway pueda reenviar el tráfico al Policy Engine para su evaluación.

1. Crea la extensión de autorización: Crea una extensión de autorización que apunte al nombre de host de DNS del Policy Engine. Usa el mismo SGP_DNS_HOSTNAME para el que creaste un registro DNS en Configura la red (paso 4). Este es el mecanismo por el que Agent Gateway envía tráfico al Policy Engine para su evaluación.

   gcloud

   Define la configuración de la extensión en un archivo YAML (authz-ext.yaml) y, luego, impórtala:

   name: AUTHZ_EXTENSION_NAME
   service: SGP_DNS_HOSTNAME
   authority: SGP_DNS_HOSTNAME
   failOpen: false
   loadBalancingScheme: LOAD_BALANCING_SCHEME_UNSPECIFIED
   

   gcloud service-extensions authz-extensions import AUTHZ_EXTENSION_NAME \
       --source=authz-ext.yaml \
       --location=LOCATION \
       --project=PROJECT_ID
   

   REST

   curl -X POST \
       "https://networkservices.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/authzExtensions?authzExtensionId=AUTHZ_EXTENSION_NAME" \
       -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
       -H "Content-Type: application/json" \
       -d '{
         "service": "SGP_DNS_HOSTNAME",
         "authority": "SGP_DNS_HOSTNAME",
         "failOpen": false,
         "loadBalancingScheme": "LOAD_BALANCING_SCHEME_UNSPECIFIED"
       }'
   

   Reemplaza SGP_DNS_HOSTNAME por el nombre de host de DNS para el que creaste un registro A en Configura la red (paso 4).

   Este comando devuelve una operación de larga duración. Espera a que se complete la operación antes de continuar.

2. Crea la política de autorización: Crea una política de autorización que vincule la extensión a tu Agent Gateway. Esto le indica a Agent Gateway que envíe tráfico a través del Policy Engine para su evaluación.

   gcloud

   Define la configuración de la política de autorización en un archivo YAML (authz-policy.yaml) y, luego, impórtala:

   name: AUTHZ_POLICY_NAME
   target:
     loadBalancingScheme: LOAD_BALANCING_SCHEME_UNSPECIFIED
     resources:
     - projects/PROJECT_ID/locations/LOCATION/agentGateways/AGENT_GATEWAY_NAME
   httpRules:
   - to:
       operations:
       - paths:
         - prefix: /
     when: "!request.headers['content-type'].startsWith('application/grpc') && (request.path.endsWith(':generateContent') || request.path.endsWith(':streamGenerateContent'))"
   action: CUSTOM
   policyProfile: CONTENT_AUTHZ
   customProvider:
     authzExtension:
       resources:
       - projects/PROJECT_ID/locations/LOCATION/authzExtensions/AUTHZ_EXTENSION_NAME
   

   gcloud network-security authz-policies import AUTHZ_POLICY_NAME \
       --source=authz-policy.yaml \
       --location=LOCATION \
       --project=PROJECT_ID
   

   REST

   curl -X POST \
       "https://networksecurity.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/authzPolicies?authzPolicyId=AUTHZ_POLICY_NAME" \
       -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
       -H "Content-Type: application/json" \
       -d '{
         "target": {
           "loadBalancingScheme": "LOAD_BALANCING_SCHEME_UNSPECIFIED",
           "resources": ["projects/PROJECT_ID/locations/LOCATION/agentGateways/AGENT_GATEWAY_NAME"]
         },
         "httpRules": [{
           "to": {
             "operations": [{"paths": [{"prefix": "/"}]}]
           },
           "when": "!request.headers['"'"'content-type'"'"'].startsWith('"'"'application/grpc'"'"') && (request.path.endsWith('"'"':generateContent'"'"') || request.path.endsWith('"'"':streamGenerateContent'"'"'))"
         }],
         "action": "CUSTOM",
         "policyProfile": "CONTENT_AUTHZ",
         "customProvider": {
           "authzExtension": {
             "resources": ["projects/PROJECT_ID/locations/LOCATION/authzExtensions/AUTHZ_EXTENSION_NAME"]
           }
         }
       }'
   

   Este comando devuelve una operación de larga duración. Espera a que se complete la operación antes de continuar.

Crear una política

Una vez que el motor de políticas esté activo, podrás definir las protecciones técnicas y de comportamiento para tus agentes.

1. Define el alcance: Determina si la política se aplica a todas las acciones que realiza un agente o si se orienta a una herramienta específica.
2. Crea las restricciones: Proporciona tus reglas de negocio en lenguaje natural.

gcloud alpha agent-registry agents list \
    --project=PROJECT_ID \
    --location=LOCATION

gcloud config set api_endpoint_overrides/aiplatform \
    https://LOCATION-aiplatform.googleapis.com/

gcloud beta ai semantic-governance-policies create POLICY_ID \
    --location=LOCATION \
    --display-name="Semantic governance policy for ShippingAgent-1" \
    --description="Applies to all tool calls from the Cymbal shipping assistant agent" \
    --agent=projects/PROJECT_ID/locations/LOCATION/agents/AGENT_ID \
    --natural-language-constraint="Always use UPS as the shipping provider for shipments within the USA. Always use DHL as the shipping provider for shipments within the EU." \
    --project=PROJECT_ID

gcloud beta ai semantic-governance-policies create POLICY_ID \
    --location=LOCATION \
    --display-name="Semantic governance policy for ShippingAgent-1" \
    --agent=projects/PROJECT_ID/locations/LOCATION/agents/AGENT_ID \
    --natural-language-constraint="Always use UPS as the shipping provider for shipments within the USA. Always use DHL as the shipping provider for shipments within the EU." \
    --agent-response-denial-message="Sorry, I can only book shipments through the approved carriers for your region." \
    --project=PROJECT_ID

gcloud alpha agent-registry mcp-servers list \
    --project=PROJECT_ID \
    --location=LOCATION

gcloud beta ai semantic-governance-policies create POLICY_ID \
    --location=LOCATION \
    --display-name="DISPLAY_NAME" \
    --description="DESCRIPTION" \
    --agent=projects/PROJECT_ID/locations/LOCATION/agents/AGENT_ID \
    --mcp-tools="mcp-server=MCP_SERVER,tools=TOOL_NAME" \
    --natural-language-constraint="NLC_TEXT" \
    --project=PROJECT_ID

Mensajes de denegación con varias políticas

Cuando una sola solicitud activa rechazos de varias políticas, el motor de políticas combina los mensajes de rechazo configurados en esas políticas antes de devolver la respuesta al usuario. Se aplica un siguiente comportamiento:

• Los mensajes de rechazo de cada política con un veredicto de denegación se muestran juntos, separados por líneas en blanco.
• Los mensajes duplicados se muestran una vez.
• Si algunas políticas activadas tienen configurado un mensaje de rechazo y otras no, se agrega una línea genérica "Esta solicitud se rechazó debido a otra política empresarial" para cubrir las políticas que no tienen uno.
• Se muestran como máximo 5 mensajes de denegación por solicitud; se omiten los adicionales.

Habilitar el modo de ejecución de prueba

Puedes habilitar el modo de ejecución de prueba (DRY_RUN), que es un modo de solo auditoría o simulación que te permite evaluar las políticas sin aplicarlas. En este modo, el motor de políticas evalúa todas las llamadas a herramientas en función de tus restricciones y registra los veredictos, pero nunca bloquea las acciones. Esto te permite probar y validar tus restricciones antes de habilitar la aplicación de políticas.

Para habilitar el modo de ejecución de prueba, agrega sgpEnforcementMode: DRY_RUN a los metadatos de tu extensión de autorización:

curl -X PATCH \
    "https://networkservices.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/authzExtensions/AUTHZ_EXTENSION_NAME?updateMask=metadata" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "metadata": {
        "sgpEnforcementMode": "DRY_RUN"
      }
    }'

En el modo de ejecución de prueba, ocurre lo siguiente:

• Todas las llamadas a herramientas están permitidas, independientemente del veredicto.
• Los veredictos y las justificaciones se registran para su revisión.
• Puedes revisar los registros para identificar qué acciones se habrían bloqueado y definir mejor tus restricciones antes de cambiar al modo de aplicación forzosa.

Para volver al modo de aplicación forzosa normal, quita sgpEnforcementMode de los metadatos:

curl -X PATCH \
    "https://networkservices.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/authzExtensions/AUTHZ_EXTENSION_NAME?updateMask=metadata" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "metadata": {}
    }'

Visualiza los registros de evaluación de políticas

El motor de políticas escribe una entrada de registro estructurada para cada evaluación en Cloud Logging en tu proyecto. La entrada registra un verdict general y un array evaluations con un verdict y un rationale para cada herramienta o acción.

1. Desde la consola: En la página Políticas, selecciona una política.
2. En el panel Detalles, en la sección Observabilidad, haz clic en Cloud Logging > Ver detalles.

3. En el Explorador de registros: escribe semantic-governance-policy en el cuadro de consulta o usa el siguiente filtro explícito:

   logName="projects/PROJECT_ID/logs/semantic-governance-policy"

El siguiente ejemplo es una entrada de registro de muestra:

{
  "jsonPayload": {
    "token_usage": 1859,
    "verdict": "ALLOW",
    "token_usage_breakdown": {"output": 43, "thinking": 0, "input": 1816, "total": 1859},
    "evaluations": [
      {
        "toolName": "process_refund",
        "verdict": "ALLOW",
        "actionName": "process_refund",
        "rationale": "The action is aligned with the user's request to process a refund and complies with the constraints regarding order ID length."
      }
    ]
  },
  "resource": {"type": "global", "labels": {"project_id": "PROJECT_NUMBER"}},
  "logName": "projects/PROJECT_ID/logs/semantic-governance-policy"
}

Campos clave:

• verdict: Es la decisión general, que puede ser ALLOW o DENY.
• evaluations[].rationale: Es la justificación de por qué el motor de políticas llegó a un veredicto en particular para cada herramienta o acción.
• token_usage: Es la cantidad de tokens del modelo que consumió la evaluación.

Habilita el seguimiento de solicitudes

El motor de políticas exporta un seguimiento para cada solicitud que evalúa a Cloud Trace en tu proyecto, de modo que puedas inspeccionar la latencia por solicitud y la aplicación de políticas. Para recibir estos seguimientos, habilita la API de Cloud Trace y otorga a la cuenta de servicio de Vertex AI (P4SA) permiso para escribir seguimientos.

1. Habilita la API de Cloud Trace:

   gcloud services enable cloudtrace.googleapis.com \
       --project=PROJECT_ID
   

2. Otorga el rol de agente de Cloud Trace (roles/cloudtrace.agent) a la cuenta de servicio de Vertex AI. Este rol solo otorga el permiso de escritura de seguimiento (cloudtrace.traces.patch):

   export PROJECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
   
   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member="serviceAccount:service-${PROJECT_NUM}@gcp-sa-aiplatform.s3ns-system.iam.gserviceaccount.com" \
       --role="roles/cloudtrace.agent"
   

Después de configurar ambos, envía una solicitud a través de tu agente y consulta los seguimientos en el Explorador de seguimientos de tu proyecto.

Administra la configuración de la política

Después de que se ejecute la política de administración semántica, puedes borrar políticas individuales o desconectar el motor de tu Agent Gateway.

Borra una política

Para quitar una política individual sin afectar la integración general de la política de administración semántica, sigue estos pasos:

gcloud beta ai semantic-governance-policies delete POLICY_ID \
    --location=LOCATION \
    --project=PROJECT_ID

Como alternativa, usa el siguiente comando de curl:

curl -X DELETE \
    "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/semanticGovernancePolicies/POLICY_ID" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)"

Desaprovisiona un motor de políticas

curl  -X POST "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/semanticGovernancePolicyEngine:deprovision" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{}'

gcloud beta ai semantic-governance-policy-engine deprovision \
    --location=LOCATION \
    --project=PROJECT_ID

Desconecta el motor de políticas de Agent Gateway

Puedes desconectar el Policy Engine de tu Agent Gateway para detener la evaluación de las llamadas a herramientas en función de tus restricciones.

Borra la política de autorización que vincula la aplicación de la política de administración semántica a tu puerta de enlace de agente:

gcloud network-security authz-policies delete AUTHZ_POLICY_NAME \
    --location=LOCATION \
    --project=PROJECT_ID

Para volver a conectar el motor de políticas más adelante, vuelve a crear la política de autorización como se describe en Conecta el motor de políticas a Agent Gateway.

Borra la extensión de autorización (opcional)

Borra la extensión de autorización que se creó durante la configuración.

gcloud network-services authz-extensions delete AUTHZ_EXTENSION_NAME \
    --location=LOCATION \
    --project=PROJECT_ID

Limpia los recursos administrados por el cliente (opcional)

La desaprovisionamiento del motor solo destruye los recursos de respaldo administrados por Google. Si ya no los necesitas, debes borrar de forma manual los recursos que creaste en tu propio proyecto durante la configuración.

Quita la zona del DNS privada

gcloud dns managed-zones delete DNS_ZONE_NAME \
    --project=PROJECT_ID

Quita la subred y la VPC

gcloud compute networks subnets delete SUBNET_NAME \
    --region=LOCATION \
    --project=PROJECT_ID

gcloud compute networks delete NETWORK_NAME \
    --project=PROJECT_ID

Quita las vinculaciones de IAM (opcional)

Si otorgaste permisos a la cuenta de servicio de Vertex AI (P4SA), puedes quitarlos:

export PROJECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")

gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:service-${PROJECT_NUM}@gcp-sa-aiplatform.s3ns-system.iam.gserviceaccount.com" \
    --role="roles/compute.networkAdmin"

gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:service-${PROJECT_NUM}@gcp-sa-aiplatform.s3ns-system.iam.gserviceaccount.com" \
    --role="roles/dns.admin"

gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:service-${PROJECT_NUM}@gcp-sa-aiplatform.s3ns-system.iam.gserviceaccount.com" \
    --role="roles/cloudtrace.agent"

Inhabilita la API de Cloud Trace (opcional)

gcloud services disable cloudtrace.googleapis.com --project=PROJECT_ID

Inhabilita la API de Agent Platform (opcional)

gcloud services disable aiplatform.googleapis.com --project=PROJECT_ID

Depura la aplicación de políticas

Para depurar un veredicto inesperado, haz lo siguiente:

1. Verifica el veredicto y la justificación en los registros de evaluación de políticas.
2. Realiza un seguimiento de la solicitud: consulta Habilita el seguimiento de solicitudes.
3. Valida los cambios de forma segura con el modo de ejecución de prueba.
4. Confirmar la implementación: El estado del motor es ACTIVE y se estableció la vinculación de la puerta de enlace.

Catálogo de errores

En la siguiente tabla, se enumeran los errores que puedes encontrar cuando administras políticas de gobernanza semánticas, junto con los pasos para resolverlos:

¿Qué sigue?

• Obtén más información sobre los comandos de gcloud CLI de Vertex AI.
• Supervisa los veredictos de las políticas en el Explorador de registros.