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
-
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 permisoresourcemanager.projects.create. Obtén más información para otorgar roles.
-
Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .
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.-
En la consola de Google Cloud , 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.
Establece la variable de entorno
LOCATIONen una zona, comous-central1-a:export LOCATION="us-central1-a"Crea el clúster:
gcloud container clusters create ${CLUSTER_NAME} \ --location=${LOCATION} \ --machine-type=${MACHINE_TYPE} \ --num-nodes=1Crea 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=gvisorPara 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.
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.yamlEl manifiesto crea el espacio de nombres
agent-sandbox-systemy, luego, implementa el controlador en ese espacio de nombres.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
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.ioEn el resultado, se enumeran las cuatro CustomResourceDefinitions.
Verifica que el controlador se esté ejecutando:
kubectl get deployment agent-sandbox-controller \ --namespace=agent-sandbox-systemCuando el controlador se está ejecutando, la columna
READYmuestra1/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.
Aplica la política:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yamlAplica 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 parasandbox.gke.io/runtime: gvisor.tolerations: Debe incluir una tolerancia para el reproche desandbox.gke.io/runtime=gvisor:NoSchedule.
Configuración prohibida
El manifiesto de implementación no debe incluir ninguno de los siguientes elementos:
hostNetwork: true,hostPID: trueohostIPC: true.privileged: trueen los contextos de seguridad de los contenedores.procMount: Unmaskeden los contextos de seguridad de los contenedores.HostPathde 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.
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.yamlImplementa 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 -Crea el Service del router:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yamlEspera 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.
En Cloud Shell, crea un archivo llamado
agent-sandbox-monitoring.yamlcon 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: 30sAplica 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 estadoReady. 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,_sumo_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.
Recomendado: Crea recursos SandboxTemplate y SandboxWarmPool
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:
En Cloud Shell, crea un archivo llamado
sandbox-template.yamlcon 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: OnFailureAplica el manifiesto de SandboxTemplate:
kubectl apply -f sandbox-template.yamlCrea un archivo llamado
sandbox-warmpool.yamlcon 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-templateAplica el manifiesto de SandboxWarmPool:
kubectl apply -f sandbox-warmpool.yamlEspera 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=600sSi 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:
Crea un archivo llamado
sandbox-claim.yamlcon 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-warmpoolAplica el manifiesto de SandboxClaim:
kubectl apply -f sandbox-claim.yamlVerifica 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:
Crea un archivo llamado
sandbox.yamlcon 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" # RequiredAplica el manifiesto de la zona de pruebas:
kubectl apply -f sandbox.yamlVerifica 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
Verifica si hay recursos de Agent Sandbox que aún estén en uso:
kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \ --all-namespacesSi 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-policySi 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.yamlLos otros recursos del router se encuentran en el espacio de nombres
agent-sandbox-system, que se borra en el siguiente paso.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?
- Obtén información para guardar y restablecer Agent Sandbox en entornos de GKE con instantáneas de Pods.
- Obtén información sobre cómo GKE Sandbox aísla las cargas de trabajo con gVisor o microVMs.
- Obtén más información sobre la seguridad de GKE.
- Explora el proyecto de código abierto de Agent Sandbox en GitHub.
- Obtén información para usar Kata Containers de código abierto con Agent Sandbox en GKE. Kata Containers no es un producto de Google Cloud . Si instalas y usas este software, eres responsable de la administración y la solución de problemas. La asistencia y los ANS de Google no se aplican a Kata Containers.