Instala Agent Sandbox en GKE

En este documento, se explica cómo instalar el controlador de código abierto de Agent Sandbox en un clúster de Google Kubernetes Engine (GKE) para ejecutar cargas de trabajo de agentes aisladas en Pods de Kubernetes dedicados. También aprenderás a crear un recurso de zona de pruebas que ejecute código que no sea de confianza en el entorno de ejecución de gVisor. Para la mayoría de las cargas de trabajo de agentes, usa Agent Substrate en GKE, ya que puede ejecutar más agentes en los mismos nodos. Usa Agent Sandbox en GKE cuando cada agente necesite un Pod dedicado, GPU o TPU, una PodSpec de Kubernetes completa o un clúster de GKE Autopilot. Para comparar Agent Sandbox en GKE con Agent Substrate en GKE y elegir una arquitectura para tus cargas de trabajo de agentes de IA, consulta Planifica una arquitectura para cargas de trabajo de agentes de IA en GKE.

Para obtener una descripción general de cómo Agent Sandbox en GKE aísla el código generado por IA que no es de confianza, consulta Acerca de Agent Sandbox en GKE.

Costos

Agent Sandbox en GKE es un software de código abierto que puedes usar sin cargo adicional. Los precios de GKE se aplican a los recursos que creas, incluidos los recursos de procesamiento que usa el controlador de Agent Sandbox.

Para evitar cargos innecesarios, asegúrate de inhabilitar GKE o borrar el proyecto después de completar este documento.

Antes de comenzar

  1. En la consola de Google Cloud , en la página del selector de proyectos, selecciona o crea un proyecto de Google Cloud .

    Roles necesarios para seleccionar o crear un proyecto

    • Seleccionar un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
    • Crea un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

    Ir al selector de proyectos

  2. Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

  3. Habilita la API de Google Kubernetes Engine si aún no está habilitada.

    Roles necesarios para habilitar las APIs

    Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

    Habilitar la API

  4. En la consola de Google Cloud , activa Cloud Shell.

    Activa Cloud Shell

Define las variables de entorno

Para simplificar los comandos que ejecutas en este documento, puedes configurar variables de entorno en Cloud Shell. En Cloud Shell, define las siguientes variables de entorno útiles ejecutando los siguientes comandos:

export CLUSTER_NAME="agent-sandbox-cluster"
export LOCATION="us-central1"
export AGENT_SANDBOX_VERSION="v1.0.6"
export NODE_POOL_NAME="agent-sandbox-pool"
export MACHINE_TYPE="e2-standard-2"

A continuación, se explica cada una de estas variables de entorno:

  • CLUSTER_NAME: Es el nombre del clúster de GKE, por ejemplo, agent-sandbox-cluster.
  • LOCATION: Es la región o zona de Google Cloud en la que se crea tu clúster de GKE. Si creas un clúster de Autopilot, configúralo en la región (por ejemplo, us-central1). Los clústeres de Autopilot siempre son regionales. Si creas un clúster de Standard, configúralo en la zona (por ejemplo, us-central1-a). Para reducir los costos, en este documento se crea un clúster zonal, que usa menos nodos que un clúster regional.
  • AGENT_SANDBOX_VERSION: Es la versión del controlador de Agent Sandbox de código abierto que se instalará. En este documento, se usa la versión 1.0.6. Para ver otras versiones, consulta la página de versiones de Agent Sandbox.
  • NODE_POOL_NAME: Es el nombre del grupo de nodos que ejecutará los Pods del agente, por ejemplo, agent-sandbox-pool. Esta variable solo es necesaria si creas un clúster de GKE Standard.
  • MACHINE_TYPE: Es el tipo de máquina de los nodos en el grupo de nodos predeterminado del clúster y en el grupo de nodos de gVisor, por ejemplo, e2-standard-2. Para obtener detalles sobre las diferentes series de máquinas y elegir entre las distintas opciones, consulta la Guía de comparación y recursos de familias de máquinas. Esta variable solo es obligatoria si creas un clúster de GKE Standard.

Crea un clúster de GKE

Agent Sandbox en GKE aísla las cargas de trabajo de los agentes con GKE Sandbox con gVisor o microVMs. Si no especificas un entorno de ejecución de GKE Sandbox (gVisor o microVMs), tus Pods se ejecutarán sin aislamiento del kernel, por lo que no debes usarlos para ejecutar código no confiable. En este documento, se usa gVisor. Los clústeres de Autopilot habilitan gVisor automáticamente. En los clústeres de Standard, creas un grupo de nodos que tiene gVisor habilitado. Para usar microVMs, consulta Habilita el tipo de zona de pruebas de microVM. La política de seguridad recomendada solo permite gVisor, por lo que rechaza los recursos de Sandbox que usan microVMs.

Autopilot

Para crear un clúster de Autopilot, asegúrate de que la variable de entorno LOCATION esté configurada en una región, como us-central1, y, luego, ejecuta el siguiente comando:

gcloud container clusters create-auto ${CLUSTER_NAME} \
    --location=${LOCATION}

Estándar

Para crear un clúster de Standard, debes crear el clúster y, luego, agregar un grupo de nodos con gVisor habilitado. Para reducir los costos, en este documento se crea un clúster zonal con un solo nodo por grupo.

  1. Establece la variable de entorno LOCATION en una zona, como us-central1-a:

    export LOCATION="us-central1-a"
    
  2. Crea el clúster:

    gcloud container clusters create ${CLUSTER_NAME} \
        --location=${LOCATION} \
        --machine-type=${MACHINE_TYPE} \
        --num-nodes=1
    
  3. Crea un grupo de nodos independiente con gVisor habilitado:

    gcloud container node-pools create ${NODE_POOL_NAME} \
        --cluster=${CLUSTER_NAME} \
        --machine-type=${MACHINE_TYPE} \
        --location=${LOCATION} \
        --num-nodes=1 \
        --image-type=cos_containerd \
        --sandbox=type=gvisor
    

    Para usar microVMs en lugar de gVisor, crea el grupo de nodos como se describe en Habilita el tipo de zona de pruebas de microVM. En el resto de este documento, se usa gVisor.

Para usar un clúster de Standard existente, asegúrate de que el clúster incluya un grupo de nodos que tenga gVisor habilitado. Si el clúster no tiene un grupo de nodos de este tipo, crea uno ejecutando el comando gcloud container node-pools create anterior.

Para habilitar la herramienta de línea de comandos de kubectl para que se conecte al clúster, obtén las credenciales del clúster:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${LOCATION}

Instala Agent Sandbox

Para instalar Agent Sandbox, aplica un manifiesto de versión desde el repositorio de GitHub de Agent Sandbox. El manifiesto sandbox-with-extensions.yaml instala el controlador de Agent Sandbox y las CustomResourceDefinitions para el recurso Sandbox y para los recursos de extensión SandboxTemplate, SandboxClaim y SandboxWarmPool.

  1. Aplica el manifiesto de la versión:

    kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
    

    El manifiesto crea el espacio de nombres agent-sandbox-system y, luego, implementa el controlador en ese espacio de nombres.

  2. Espera hasta que el controlador esté listo:

    kubectl rollout status deployment/agent-sandbox-controller \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

También puedes instalar Agent Sandbox con Helm. Para obtener instrucciones, consulta el archivo README del gráfico de Helm de Agent Sandbox.

Verifique la instalación

  1. Verifica que las CustomResourceDefinitions de Agent Sandbox estén instaladas:

    kubectl get crd \
        sandboxes.agents.x-k8s.io \
        sandboxtemplates.extensions.agents.x-k8s.io \
        sandboxclaims.extensions.agents.x-k8s.io \
        sandboxwarmpools.extensions.agents.x-k8s.io
    

    En el resultado, se enumeran las cuatro CustomResourceDefinitions.

  2. Verifica que el controlador se esté ejecutando:

    kubectl get deployment agent-sandbox-controller \
        --namespace=agent-sandbox-system
    

    Cuando el controlador se está ejecutando, la columna READY muestra 1/1.

Aplica la política de seguridad recomendada

De forma predeterminada, Agent Sandbox en GKE no restringe la configuración de los Pods que ejecutan tus agentes. Para ayudar a aplicar la configuración de aislamiento de tus Pods de agentes, aplica la secure-sandbox-policy ValidatingAdmissionPolicy recomendada del repositorio de GitHub de Agent Sandbox. Esta política rechaza cualquier recurso de zona de pruebas que no cumpla con los requisitos de implementación de Agent Sandbox en GKE.

  1. Aplica la política:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yaml
    
  2. Aplica la vinculación de la política. La vinculación aplica la política en todos los espacios de nombres, excepto en los del sistema, como kube-system:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-binding.yaml
    

La política valida los recursos de la zona de pruebas. Cuando creas un recurso SandboxWarmPool o SandboxClaim, el controlador crea recursos Sandbox a partir de un recurso SandboxTemplate. Si la plantilla no cumple con los requisitos, la política rechaza el recurso de Sandbox y el error aparece en los registros del controlador. Para ver los registros, ejecuta el siguiente comando:

kubectl logs deployment/agent-sandbox-controller \
    --namespace=agent-sandbox-system

Esta política es de tu propiedad y puedes modificarla para que se adapte a tus cargas de trabajo. Para obtener más información, consulta Políticas de seguridad de la zona de pruebas.

Requisitos de implementación de Agent Sandbox en GKE

Si aplicas la política de seguridad recomendada, los manifiestos de tu carga de trabajo, como un recurso Sandbox o SandboxTemplate, deben incluir parámetros de configuración y seguridad específicos. Si un recurso de zona de pruebas no cumple con estos requisitos, el controlador de admisión lo rechaza. Los requisitos del contenedor se aplican a todos los contenedores del Pod, incluidos los contenedores de inicio y los contenedores efímeros.

Configuración obligatoria

Tu manifiesto de implementación debe incluir los siguientes parámetros de configuración:

  • runtimeClassName: gvisor: Ejecuta el Pod en el entorno de ejecución de gVisor de GKE Sandbox. La política rechaza los recursos de la zona de pruebas que usan cualquier otro entorno de ejecución, incluidas las microVMs.
  • automountServiceAccountToken: false: Evita que el Pod active de forma automática el token de la cuenta de servicio predeterminada.
  • securityContext.runAsNonRoot: true: Garantiza que el contenedor no se ejecute como el usuario raíz.
  • securityContext.capabilities.drop: ["ALL"]: Descarta todas las capacidades de Linux del contenedor.
  • resources.limits: Debes especificar los límites de CPU y memoria para evitar posibles situaciones de denegación del servicio (DoS).
  • nodeSelector: Debe segmentar para sandbox.gke.io/runtime: gvisor.
  • tolerations: Debe incluir una tolerancia para el reproche de sandbox.gke.io/runtime=gvisor:NoSchedule.

Configuración prohibida

El manifiesto de implementación no debe incluir ninguno de los siguientes elementos:

  • hostNetwork: true, hostPID: true o hostIPC: true.
  • privileged: true en los contextos de seguridad de los contenedores.
  • procMount: Unmasked en los contextos de seguridad de los contenedores.
  • HostPath de volúmenes.
  • Se agregaron capacidades (capabilities.add).
  • Configuración de hostPort.
  • sysctls personalizados
  • Volúmenes proyectados para tokens o certificados de cuentas de servicio.

Implementa el router de la zona de pruebas (opcional)

El Sandbox Router es un proxy HTTP que enruta las solicitudes de los clientes, como el cliente de Python de Agent Sandbox, a los Pods que ejecutan tus agentes. Si planeas usar el cliente de Python, por ejemplo, como se describe en Aísla la ejecución de código de IA con Agent Sandbox en GKE, implementa el router.

Implementas el router en el espacio de nombres agent-sandbox-system. De forma predeterminada, la política de red que Agent Sandbox en GKE crea para cada recurso SandboxTemplate permite el tráfico entrante a los Pods de agentes solo desde los Pods de router en este espacio de nombres.

  1. Crea la cuenta de servicio del router y los permisos de RBAC que permiten que el router busque Pods de agentes:

    kubectl apply \
        -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/serviceaccount.yaml \
        -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yaml
    
  2. Implementa el router. Con el siguiente comando, se establece la imagen del router en la misma versión que el controlador:

    curl -sSL https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/deployment.yaml \
        | sed "s|sandbox-router-go:latest|sandbox-router-go:${AGENT_SANDBOX_VERSION}|" \
        | kubectl apply -f -
    
  3. Crea el Service del router:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yaml
    
  4. Espera hasta que el router esté listo:

    kubectl rollout status deployment/sandbox-router \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

Esta configuración del router es para desarrollo y pruebas. Para obtener información sobre la configuración de producción, como TLS, recuentos de réplicas y políticas de red para el router, consulta el archivo README de implementación de Sandbox Router.

Exporta métricas del controlador (opcional)

El controlador de Agent Sandbox exporta las métricas de Prometheus en la ruta de acceso /metrics en el puerto metrics (puerto 8080). Para recopilar estas métricas con Google Cloud Managed Service para Prometheus y consultarlas en Cloud Monitoring, aplica un recurso personalizado de PodMonitoring.

GKE habilita la recopilación administrada de forma predeterminada en los clústeres de Autopilot que ejecutan la versión 1.25 o posterior de GKE y en los clústeres de Standard que ejecutan la versión 1.27 o posterior de GKE. Si tu clúster no tiene habilitada la recopilación administrada, consulta Habilita la recopilación administrada de forma manual.

Debido a que los contadores y los histogramas de Prometheus no registran la actividad que ocurrió antes de que comenzara la recopilación, aplica el recurso PodMonitoring después de instalar el controlador para que Cloud Monitoring capture los eventos tempranos de los recursos del clúster y de la zona de pruebas.

  1. En Cloud Shell, crea un archivo llamado agent-sandbox-monitoring.yaml con el siguiente contenido:

    apiVersion: monitoring.googleapis.com/v1
    kind: PodMonitoring
    metadata:
      name: agent-sandbox-controller
      namespace: agent-sandbox-system
    spec:
      selector:
        matchLabels:
          app: agent-sandbox-controller
      endpoints:
      - port: metrics
        path: /metrics
        interval: 30s
    
  2. Aplica el manifiesto

    kubectl apply -f agent-sandbox-monitoring.yaml
    

Después de aplicar el recurso PodMonitoring, Google Cloud Managed Service para Prometheus recopila las métricas del controlador cada 30 segundos. Puedes consultar estas métricas con PromQL en Cloud Monitoring con el Explorador de métricas.

En Cloud Monitoring, Google Cloud Managed Service para Prometheus reserva la etiqueta namespace para el espacio de nombres del Pod del controlador extraído (agent-sandbox-system). En el caso de las métricas que definen su propia etiqueta namespace, Google Cloud Managed Service para Prometheus cambia el nombre de la etiqueta de la métrica a exported_namespace. Para filtrar o agrupar métricas por el espacio de nombres del recurso de la zona de pruebas, usa la etiqueta exported_namespace. Para obtener más información, consulta Etiquetas reservadas.

Por ejemplo, puedes consultar las siguientes métricas:

  • agent_sandbox_build_info: Información de compilación sobre el controlador, como la confirmación y la versión de Git.

  • agent_sandboxes: Es la cantidad de recursos de la zona de pruebas en el clúster en un momento determinado. Esta métrica tiene etiquetas para la preparación, el vencimiento, el tipo de inicio, el propietario, el creador, la plantilla y el espacio de nombres del recurso de Sandbox (exported_namespace). Por ejemplo, la siguiente consulta de PromQL agrupa los recursos de Sandbox por espacio de nombres y preparación:

    sum by (exported_namespace, ready_condition) (agent_sandboxes)
    
  • agent_sandbox_claim_controller_startup_latency_ms: Es un histograma que mide la latencia en milisegundos desde que el controlador observa por primera vez un recurso SandboxClaim hasta que la reclamación alcanza el estado Ready. Debido a que esta métrica es un histograma de Prometheus, la consulta del nombre de la métrica base no devuelve datos directamente. Debes consultar sus series _bucket, _sum o _count. Por ejemplo, la siguiente consulta de PromQL calcula la latencia de inicio del percentil 95 en una ventana de frecuencia de cinco minutos:

    histogram_quantile(
      0.95,
      sum by (le) (
        rate(agent_sandbox_claim_controller_startup_latency_ms_bucket[5m])
      )
    )
    

Para obtener más información sobre las métricas exportadas y los componentes opcionales de los que dependen, consulta la referencia de métricas del controlador.

Implementa un entorno de zona de pruebas

Para implementar un entorno de zona de pruebas, define un recurso SandboxTemplate y mantén listos los recursos de Sandbox precalentados con un recurso SandboxWarmPool. Luego, puedes solicitar un recurso de zona de pruebas de este grupo de preparación con un recurso SandboxClaim. Como alternativa, puedes crear un recurso de Sandbox directamente, pero este enfoque no admite grupos de instancias de reserva.

SandboxTemplate, SandboxWarmPool, SandboxClaim y Sandbox son recursos personalizados de Kubernetes.

El recurso SandboxTemplate actúa como un plano reutilizable. El recurso SandboxWarmPool mantiene una cantidad especificada de recursos de zona de pruebas preparados previamente con Pods en ejecución que están listos para reclamarse. Este grupo de preparación reduce la latencia de inicio.

Para implementar un entorno de zona de pruebas creando recursos SandboxTemplate y SandboxWarmPool, completa los siguientes pasos:

  1. En Cloud Shell, crea un archivo llamado sandbox-template.yaml con el siguiente contenido:

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxTemplate
    metadata:
      name: python-runtime-template
      namespace: default
    spec:
      podTemplate:
        metadata:
          labels:
            sandbox-type: python-runtime
        spec:
          runtimeClassName: gvisor # Required
          automountServiceAccountToken: false # Required
          securityContext:
            runAsNonRoot: true # Required
          nodeSelector:
            sandbox.gke.io/runtime: gvisor # Required
          tolerations:
          - key: "sandbox.gke.io/runtime"
            value: "gvisor"
            effect: "NoSchedule" # Required
          containers:
          - name: runtime
            image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0
            ports:
            - containerPort: 8888
            resources:
              requests:
                cpu: "250m"
                memory: "512Mi"
              limits:
                cpu: "500m"
                memory: "1Gi" # Required
            securityContext:
              capabilities:
                drop: ["ALL"] # Required
          restartPolicy: OnFailure
    
  2. Aplica el manifiesto de SandboxTemplate:

    kubectl apply -f sandbox-template.yaml
    
  3. Crea un archivo llamado sandbox-warmpool.yaml con el siguiente contenido:

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxWarmPool
    metadata:
      name: python-runtime-warmpool
      namespace: default
      labels:
        app: python-runtime-warmpool
    spec:
      replicas: 2
      sandboxTemplateRef:
        # This must match the name of the SandboxTemplate.
        name: python-runtime-template
    
  4. Aplica el manifiesto de SandboxWarmPool:

    kubectl apply -f sandbox-warmpool.yaml
    
  5. Espera hasta que los recursos de la zona de pruebas del grupo de preparación y sus Pods estén listos:

    kubectl wait sandboxwarmpool python-runtime-warmpool \
        --for=jsonpath='{.status.readyReplicas}'=2 \
        --timeout=600s
    

    Si creas un recurso SandboxClaim antes de que los recursos Sandbox del grupo y sus Pods estén listos, el controlador creará un recurso Sandbox nuevo para la reclamación en lugar de asignar uno del grupo. En un clúster de Autopilot, los Pods pueden tardar varios minutos en estar listos, ya que es posible que GKE deba crear nodos para ellos.

Crea un recurso SandboxClaim

El recurso SandboxClaim solicita un recurso Sandbox del grupo de preparación. Como creaste un grupo de preparación, el controlador asigna un recurso de zona de pruebas listo (y su Pod en ejecución) del grupo a la reclamación en lugar de crear uno nuevo.

Para solicitar un recurso de zona de pruebas del grupo de preparación creando un recurso SandboxClaim, completa los siguientes pasos:

  1. Crea un archivo llamado sandbox-claim.yaml con el siguiente contenido:

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxClaim
    metadata:
      name: sandbox-claim
      namespace: default
    spec:
      warmPoolRef:
        # This must match the name of the SandboxWarmPool.
        name: python-runtime-warmpool
    
  2. Aplica el manifiesto de SandboxClaim:

    kubectl apply -f sandbox-claim.yaml
    
  3. Verifica que el recurso, la reclamación y el grupo de preparación de la zona de pruebas estén listos:

    kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
    

Alternativa: Crea un recurso de zona de pruebas directamente

Si no necesitas los tiempos de inicio rápidos que proporcionan los grupos de preparación, puedes implementar un recurso de zona de pruebas directamente sin usar plantillas.

Para implementar un entorno de zona de pruebas creando un recurso de zona de pruebas directamente, completa los siguientes pasos:

  1. Crea un archivo llamado sandbox.yaml con el siguiente contenido:

    apiVersion: agents.x-k8s.io/v1beta1
    kind: Sandbox
    metadata:
      name: sandbox-example-2
    spec:
      podTemplate:
        metadata:
          labels:
            sandbox: sandbox-example
        spec:
          runtimeClassName: gvisor
          restartPolicy: OnFailure
          automountServiceAccountToken: false # Required
          securityContext:
            runAsNonRoot: true # Required
            runAsUser: 1000 # Required if image defaults to root (for example, busybox)
          nodeSelector:
            sandbox.gke.io/runtime: gvisor
          tolerations:
          - key: "sandbox.gke.io/runtime"
            value: "gvisor"
            effect: "NoSchedule" # Required
          containers:
          - name: my-container
            image: busybox
            command: ["/bin/sh", "-c"]
            args: ["sleep 3600000; echo 'Container finished successfully'; exit 0"]
            securityContext:
              capabilities:
                drop: ["ALL"] # Required
              allowPrivilegeEscalation: false
            resources:
              limits:
                cpu: "100m"
                memory: "128Mi" # Required
    
  2. Aplica el manifiesto de la zona de pruebas:

    kubectl apply -f sandbox.yaml
    
  3. Verifica que el recurso de Sandbox se esté ejecutando:

    kubectl get sandbox
    

Actualiza Agent Sandbox

Para actualizar Agent Sandbox, aplica el manifiesto de la versión nueva:

export AGENT_SANDBOX_VERSION="NEW_VERSION"
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml

Reemplaza NEW_VERSION por la versión que deseas instalar, como una versión que aparece en la página de versiones de Agent Sandbox.

Antes de actualizar, revisa las notas de la versión nueva. Si tu clúster ejecuta una versión de Agent Sandbox anterior a la 1.0.0, debes migrar tus recursos a la API de v1beta1 antes de actualizar, ya que la versión 1.0.0 quitó la API de v1alpha1. Para obtener instrucciones, consulta la guía de migración de la API.

Si implementaste el Sandbox Router o aplicaste la política de seguridad recomendada, repite esos pasos para la versión nueva.

Desinstala Agent Sandbox

  1. Verifica si hay recursos de Agent Sandbox que aún estén en uso:

    kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \
        --all-namespaces
    
  2. Si aplicaste la política de seguridad recomendada, borra la vinculación de la política y la política:

    kubectl delete validatingadmissionpolicybinding secure-sandbox-binding
    kubectl delete validatingadmissionpolicy secure-sandbox-policy
    
  3. Si implementaste el Sandbox Router, borra sus recursos de RBAC para todo el clúster:

    kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yaml
    

    Los otros recursos del router se encuentran en el espacio de nombres agent-sandbox-system, que se borra en el siguiente paso.

  4. Para borrar el controlador de Agent Sandbox, su espacio de nombres y sus CustomResourceDefinitions, borra el manifiesto de la versión que instalaste:

    kubectl delete -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
    

Limpia los recursos

Para evitar que se apliquen cargos a tu cuenta de Google Cloud , borra el clúster de GKE que creaste.

gcloud container clusters delete ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --quiet

Si creaste un clúster de Autopilot, la ubicación es la región (por ejemplo, us-central1). Si creaste un clúster de Standard, la ubicación es la zona (por ejemplo, us-central1-a).

¿Qué sigue?