Neste documento, explicamos como instalar o controlador de código aberto do Agent Sandbox em um cluster do Google Kubernetes Engine (GKE) para executar cargas de trabalho de agentes isolados em pods dedicados do Kubernetes. Você também vai aprender a criar um recurso de sandbox que executa código não confiável no ambiente de execução do gVisor. Para a maioria das cargas de trabalho de agentes, use o Agent Substrate no GKE, porque ele pode executar mais agentes nos mesmos nós. Use o Agent Sandbox no GKE quando cada agente precisar de um pod dedicado, GPUs ou TPUs, um PodSpec completo do Kubernetes ou um cluster do GKE Autopilot. Para comparar o Agent Sandbox no GKE com o Agent Substrate no GKE e escolher uma arquitetura para suas cargas de trabalho de agentes de IA, consulte Planejar uma arquitetura para cargas de trabalho de agentes de IA no GKE.
Para uma visão geral de como o Agent Sandbox no GKE isola códigos gerados com IA não confiáveis, consulte Sobre o Agent Sandbox no GKE.
Custos
O Agent Sandbox no GKE é um software de código aberto que você pode usar sem custo financeiro adicional. Os preços do GKE se aplicam aos recursos que você cria, incluindo os recursos de computação que o controlador do Agent Sandbox usa.
Para evitar cobranças desnecessárias, desative o GKE ou exclua o projeto depois de concluir este documento.
Antes de começar
-
No console do Google Cloud , na página do seletor de projetos, selecione ou crie um projeto do Google Cloud .
Papéis necessários para selecionar ou criar um projeto
- Selecionar um projeto: para selecionar um projeto, não é necessário ter um papel do IAM específico. É possível selecionar qualquer projeto em que você tenha um papel.
-
Criar um projeto: para criar um projeto, é preciso ter o papel de Criador de projetos
(
roles/resourcemanager.projectCreator), que contém a permissãoresourcemanager.projects.create. Saiba como conceder papéis.
-
Verifique se o faturamento está ativado para o projeto do Google Cloud .
Ative a API Google Kubernetes Engine, se ainda não estiver ativada.
Funções necessárias para ativar APIs
Para ativar APIs, você precisa da permissão
serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de proprietário (roles/owner). Caso contrário, é possível conseguir essa permissão pelo papel de administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.-
No console do Google Cloud , ative o Cloud Shell.
Definir variáveis de ambiente
Para simplificar os comandos executados neste documento, defina variáveis de ambiente no Cloud Shell. No Cloud Shell, defina as seguintes variáveis de ambiente úteis executando estes 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"
Confira uma explicação dessas variáveis de ambiente:
CLUSTER_NAME: o nome do cluster do GKE, por exemplo,agent-sandbox-cluster.LOCATION: a região ou zona do Google Cloud em que o cluster do GKE foi criado. Se você criar um cluster do Autopilot, defina-o como a região (por exemplo,us-central1). Os clusters do Autopilot são sempre regionais. Se você criar um cluster Standard, defina-o como a zona (por exemplo,us-central1-a). Para reduzir custos, este documento cria um cluster zonal, que usa menos nós do que um cluster regional.AGENT_SANDBOX_VERSION: a versão do controlador de código aberto do Agent Sandbox a ser instalada. Este documento usa a versão 1.0.6. Para ver outras versões, acesse a página de versões do Agent Sandbox.NODE_POOL_NAME: o nome do pool de nós que vai executar os pods do agente, por exemplo,agent-sandbox-pool. Essa variável só é necessária se você estiver criando um cluster do GKE Standard.MACHINE_TYPE: o tipo de máquina dos nós no pool de nós padrão do cluster e no pool de nós do gVisor, por exemplo,e2-standard-2. Para detalhes sobre as diferentes séries de máquinas e como escolher entre as opções, consulte o Guia de comparação e recursos de famílias de máquinas. Essa variável só é necessária se você estiver criando um cluster do GKE Standard.
Criar um cluster do GKE
O Agent Sandbox no GKE isola as cargas de trabalho do agente usando o GKE Sandbox com gVisor ou microVMs. Se você não especificar um ambiente de execução do GKE Sandbox (gVisor ou microVMs), os pods serão executados sem isolamento de kernel. Portanto, não os use para executar código não confiável. Este documento usa o gVisor. Os clusters do Autopilot ativam o gVisor automaticamente. Em clusters Standard, você cria um pool de nós que tem o gVisor ativado. Para usar microVMs, consulte Ativar o tipo de sandbox de microVM. A política de segurança recomendada permite apenas o gVisor, portanto, rejeita recursos do Sandbox que usam microVMs.
Piloto automático
Para criar um cluster do Autopilot, verifique se a variável de ambiente LOCATION
está definida como uma região, como us-central1, e execute
o seguinte comando:
gcloud container clusters create-auto ${CLUSTER_NAME} \
--location=${LOCATION}
Padrão
Para criar um cluster Standard, crie o cluster e adicione um pool de nós com o gVisor ativado. Para reduzir custos, este documento cria um cluster zonal com um único nó por pool.
Defina a variável de ambiente
LOCATIONcomo uma zona, comous-central1-a:export LOCATION="us-central1-a"Crie o cluster:
gcloud container clusters create ${CLUSTER_NAME} \ --location=${LOCATION} \ --machine-type=${MACHINE_TYPE} \ --num-nodes=1Crie um pool de nós separado com o gVisor ativado:
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 em vez do gVisor, crie o pool de nós conforme descrito em Ativar o tipo de sandbox de microVM. O restante deste documento usa o gVisor.
Para usar um cluster Standard, verifique se ele
inclui um pool de nós com o gVisor ativado. Se o cluster não tiver esse pool de nós, crie um executando o comando gcloud container node-pools create anterior.
Para permitir que a ferramenta de linha de comando kubectl se conecte ao cluster, receba
as credenciais do cluster:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${LOCATION}
Instalar o Agent Sandbox
Para instalar o Agent Sandbox, aplique um manifesto de lançamento do
repositório do Agent Sandbox no GitHub. O manifesto sandbox-with-extensions.yaml instala o controlador do Agent Sandbox e as CustomResourceDefinitions para o recurso Sandbox e para os recursos de extensão SandboxTemplate, SandboxClaim e SandboxWarmPool.
Aplique o manifesto da versão:
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yamlO manifesto cria o namespace
agent-sandbox-systeme implanta o controlador nesse namespace.Aguarde até que o controlador esteja pronto:
kubectl rollout status deployment/agent-sandbox-controller \ --namespace=agent-sandbox-system \ --timeout=120s
Também é possível instalar o Agent Sandbox usando o Helm. Para instruções, consulte o README do gráfico do Helm do Agent Sandbox.
Verifique a instalação
Verifique se as CustomResourceDefinitions do Agent Sandbox estão 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.ioA saída lista as quatro CustomResourceDefinitions.
Verifique se o controlador está em execução:
kubectl get deployment agent-sandbox-controller \ --namespace=agent-sandbox-systemQuando o controlador está em execução, a coluna
READYmostra1/1.
Aplicar a política de segurança recomendada
Por padrão, o Agent Sandbox no GKE não restringe a
configuração dos pods que executam seus agentes. Para ajudar a aplicar as configurações de isolamento
aos pods do agente, aplique a ValidatingAdmissionPolicy
secure-sandbox-policy recomendada
do repositório do GitHub do Agent Sandbox. Essa política rejeita qualquer
recurso do Sandbox que não atenda aos requisitos de implantação do Agent Sandbox no
GKE.
Aplique a política:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yamlAplique a vinculação de política. A vinculação aplica a política em todos os namespaces, exceto nos namespaces do 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
A política valida os recursos do Sandbox. Quando você cria um recurso SandboxWarmPool ou SandboxClaim, o controlador cria recursos Sandbox com base em um recurso SandboxTemplate. Se o modelo não atender aos requisitos, a política rejeitará o recurso do Sandbox, e o erro vai aparecer nos registros do controlador. Para ver os registros, execute o seguinte comando:
kubectl logs deployment/agent-sandbox-controller \
--namespace=agent-sandbox-system
Você é o proprietário dessa política e pode modificá-la para se adequar às suas cargas de trabalho. Para mais informações, consulte Políticas de segurança do sandbox.
Requisitos de implantação do Agent Sandbox no GKE
Se você aplicar a política de segurança recomendada, os manifestos de carga de trabalho, como um recurso Sandbox ou SandboxTemplate, precisarão incluir configurações específicas de segurança e configuração. Se um recurso do Sandbox não atender a esses requisitos, o controlador de admissão o rejeitará. Os requisitos de contêiner se aplicam a todos os contêineres no pod, incluindo contêineres de inicialização e contêineres temporários.
Configuração necessária
O manifesto de implantação precisa incluir as seguintes configurações:
runtimeClassName: gvisor: executa o pod no ambiente de execução do gVisor do GKE Sandbox. A política rejeita recursos do Sandbox que usam qualquer outro ambiente de execução, incluindo microVMs.automountServiceAccountToken: false: impede que o pod monte automaticamente o token da conta de serviço padrão.securityContext.runAsNonRoot: true: garante que o contêiner não seja executado como usuário raiz.securityContext.capabilities.drop: ["ALL"]: descarta todos os recursos do Linux do contêiner.resources.limits: é preciso especificar limites de CPU e memória para evitar possíveis cenários de negação de serviço (DoS).nodeSelector: precisa segmentarsandbox.gke.io/runtime: gvisor.tolerations: precisa incluir uma tolerância para o taintsandbox.gke.io/runtime=gvisor:NoSchedule.
Configuração proibida
O manifesto de implantação não pode incluir nenhum dos seguintes itens:
hostNetwork: true,hostPID: trueouhostIPC: true.privileged: trueem contextos de segurança de contêiner.procMount: Unmaskedem contextos de segurança de contêiner.HostPathvolumes.- Recursos adicionados (
capabilities.add). - Configurações de
hostPort. - sysctls personalizados.
- Volumes projetados para tokens ou certificados de conta de serviço.
Implantar o roteador do sandbox (opcional)
O roteador do sandbox é um proxy HTTP que encaminha solicitações de clientes, como o cliente Python do Agent Sandbox, para os pods que executam seus agentes. Se você planeja usar o cliente Python, por exemplo, conforme descrito em Isolar a execução de código de IA com o Agent Sandbox no GKE, implante o roteador.
Implante o roteador no namespace agent-sandbox-system. Por padrão, a
política de rede que o Agent Sandbox no GKE cria para
cada recurso SandboxTemplate permite o tráfego de entrada para pods de agente apenas dos
pods de roteador nesse namespace.
Crie a conta de serviço do roteador e as permissões de RBAC que permitem que o roteador procure pods de agente:
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.yamlImplante o roteador. O comando a seguir define a imagem do roteador para a mesma versão do 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 -Crie o serviço do roteador:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yamlAguarde até que o roteador esteja pronto:
kubectl rollout status deployment/sandbox-router \ --namespace=agent-sandbox-system \ --timeout=120s
Essa configuração de roteador é para desenvolvimento e testes. Para configurações de produção, como TLS, contagens de réplicas e políticas de rede para o roteador, consulte o README de implantação do roteador do Sandbox.
Exportar métricas do controlador (opcional)
O controlador do Agent Sandbox exporta métricas do Prometheus no caminho /metrics na porta metrics (porta 8080). Para coletar essas métricas
usando o Google Cloud Managed Service para Prometheus e consultá-las no Cloud Monitoring,
aplique um recurso personalizado do PodMonitoring.
O GKE ativa a coleta gerenciada por padrão em clusters do Autopilot que executam a versão 1.25 ou mais recente do GKE e em clusters Standard que executam a versão 1.27 ou mais recente do GKE. Se o cluster não tiver a coleta gerenciada ativada, consulte Ativar a coleta gerenciada manualmente.
Como os contadores e histogramas do Prometheus não registram atividades que ocorreram antes do início da coleta, aplique o recurso PodMonitoring depois de instalar o controlador para que o Cloud Monitoring capture os primeiros eventos de recursos do cluster e do Sandbox.
No Cloud Shell, crie um arquivo chamado
agent-sandbox-monitoring.yamlcom o seguinte conteúdo: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: 30sAplique o manifesto:
kubectl apply -f agent-sandbox-monitoring.yaml
Depois de aplicar o recurso PodMonitoring, o Google Cloud Managed Service para Prometheus coleta as métricas do controlador a cada 30 segundos. É possível consultar essas métricas com o PromQL no Cloud Monitoring usando o Metrics Explorer.
No Cloud Monitoring, o Google Cloud Managed Service para Prometheus reserva o rótulo namespace para o namespace do pod do controlador extraído (agent-sandbox-system). Para métricas que definem o próprio rótulo namespace, o Google Cloud Managed Service para Prometheus renomeia o rótulo da métrica como exported_namespace. Para filtrar ou agrupar métricas pelo namespace do recurso do Sandbox, use o rótulo exported_namespace. Para mais informações, consulte
Rótulos reservados.
Por exemplo, é possível consultar as seguintes métricas:
agent_sandbox_build_info: informações de build sobre o controlador, como o commit e a versão do Git.agent_sandboxes: o número de recursos do Sandbox no cluster em um determinado momento. Essa métrica tem rótulos para prontidão, validade, tipo de inicialização, proprietário, criador, modelo e namespace do recurso do Sandbox (exported_namespace). Por exemplo, a consulta PromQL a seguir agrupa recursos do Sandbox por namespace e prontidão:sum by (exported_namespace, ready_condition) (agent_sandboxes)agent_sandbox_claim_controller_startup_latency_ms: um histograma que mede a latência em milissegundos desde o momento em que o controlador observa pela primeira vez um recurso SandboxClaim até que a declaração alcance o statusReady. Como essa métrica é um histograma do Prometheus, consultar o nome da métrica base não retorna dados diretamente. É preciso consultar as séries_bucket,_sumou_count. Por exemplo, a consulta PromQL a seguir calcula a latência de inicialização do 95º percentil em uma janela de taxa de cinco minutos:histogram_quantile( 0.95, sum by (le) ( rate(agent_sandbox_claim_controller_startup_latency_ms_bucket[5m]) ) )
Para mais informações sobre as métricas exportadas e os componentes opcionais de que elas dependem, consulte a Referência de métricas do controlador.
Implantar um ambiente de sandbox
Para implantar um ambiente de sandbox, defina um recurso SandboxTemplate e mantenha recursos de sandbox pré-aquecidos prontos usando um recurso SandboxWarmPool. Em seguida, é possível solicitar um recurso de sandbox desse pool de espera usando um recurso SandboxClaim. Como alternativa, é possível criar um recurso de sandbox diretamente, mas essa abordagem não é compatível com pools de aquecimento.
SandboxTemplate, SandboxWarmPool, SandboxClaim e Sandbox são recursos personalizados do Kubernetes.
Recomendado: criar recursos SandboxTemplate e SandboxWarmPool
O recurso SandboxTemplate funciona como um blueprint reutilizável. O recurso SandboxWarmPool mantém um número especificado de recursos de sandbox pré-aquecidos com pods em execução que estão prontos para serem reivindicados. Esse pool reduz a latência de inicialização.
Para implantar um ambiente de sandbox criando recursos SandboxTemplate e SandboxWarmPool, siga estas etapas:
No Cloud Shell, crie um arquivo chamado
sandbox-template.yamlcom o seguinte conteúdo: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: OnFailureAplique o manifesto SandboxTemplate:
kubectl apply -f sandbox-template.yamlCrie um arquivo chamado
sandbox-warmpool.yamlcom o conteúdo a seguir: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-templateAplique o manifesto SandboxWarmPool:
kubectl apply -f sandbox-warmpool.yamlAguarde até que os recursos do Sandbox do pool de aquecimento e os pods deles estejam prontos:
kubectl wait sandboxwarmpool python-runtime-warmpool \ --for=jsonpath='{.status.readyReplicas}'=2 \ --timeout=600sSe você criar um recurso SandboxClaim antes que os recursos Sandbox do pool e os pods deles estejam prontos, o controlador vai criar um novo recurso Sandbox para a declaração em vez de atribuir um do pool. Em um cluster do Autopilot, os pods podem levar vários minutos para ficarem prontos, porque o GKE pode precisar criar nós para eles.
Criar um recurso SandboxClaim
O recurso SandboxClaim solicita um recurso Sandbox do pool de espera. Como você criou um pool de espera, o controlador atribui um recurso de sandbox pronto (e o pod em execução) do pool à declaração, em vez de criar um novo.
Para solicitar um recurso de sandbox do pool de espera criando um recurso SandboxClaim, siga estas etapas:
Crie um arquivo chamado
sandbox-claim.yamlcom o conteúdo a seguir: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-warmpoolAplique o manifesto SandboxClaim:
kubectl apply -f sandbox-claim.yamlVerifique se o recurso, a declaração e o pool de aquecimento do Sandbox estão prontos:
kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
Alternativa: criar um recurso de sandbox diretamente
Se você não precisar dos tempos de inicialização rápidos fornecidos pelos pools de aquecimento, poderá implantar um recurso do Sandbox diretamente sem usar modelos.
Para implantar um ambiente de sandbox criando um recurso de sandbox diretamente, siga estas etapas:
Crie um arquivo chamado
sandbox.yamlcom o conteúdo a seguir: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" # RequiredAplique o manifesto do Sandbox:
kubectl apply -f sandbox.yamlVerifique se o recurso Sandbox está em execução:
kubectl get sandbox
Fazer upgrade do Agent Sandbox
Para fazer upgrade do Agent Sandbox, aplique o manifesto de lançamento da nova versão:
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
Substitua NEW_VERSION pela versão que você quer instalar, como uma
versão listada na
página de versões do Agent Sandbox.
Antes de fazer upgrade, consulte as notas da versão para a nova versão. Se o
cluster executar uma versão do Agent Sandbox anterior à 1.0.0, você
precisará migrar os recursos para a API v1beta1 antes de fazer upgrade, porque
a versão 1.0.0 removeu a API v1alpha1. Para instruções, consulte o
guia de migração da API.
Se você implantou o roteador do Sandbox ou aplicou a política de segurança recomendada, repita essas etapas para a nova versão.
Desinstalar o Agent Sandbox
Verifique se há recursos do Agent Sandbox que ainda estão em uso:
kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \ --all-namespacesSe você aplicou a política de segurança recomendada, exclua a vinculação e a política:
kubectl delete validatingadmissionpolicybinding secure-sandbox-binding kubectl delete validatingadmissionpolicy secure-sandbox-policySe você implantou o roteador do Sandbox, exclua os recursos de RBAC em todo o cluster:
kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yamlOs outros recursos do roteador estão no namespace
agent-sandbox-system, que será excluído na próxima etapa.Para excluir o controlador do Agent Sandbox, o namespace e as CustomResourceDefinitions, exclua o manifesto de lançamento da versão instalada:
kubectl delete -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
Limpar recursos
Para evitar cobranças na sua conta do Google Cloud , exclua o cluster do GKE que você criou.
gcloud container clusters delete ${CLUSTER_NAME} \
--location=${LOCATION} \
--quiet
Se você criou um cluster do Autopilot, o local é a região (por exemplo, us-central1). Se você criou um cluster padrão, o local é a zona (por exemplo, us-central1-a).
A seguir
- Saiba como salvar e restaurar o Agent Sandbox em ambientes do GKE com snapshots de pod.
- Saiba como o GKE Sandbox isola cargas de trabalho usando o gVisor ou microVMs.
- Saiba mais sobre a segurança do GKE.
- Confira o projeto de código aberto do Agent Sandbox no GitHub.
- Saiba como usar os Kata Containers de código aberto com o Agent Sandbox no GKE. O Kata Containers não é um produto do Google Cloud . Se você instalar e usar esse software, será responsável pelo gerenciamento e pela solução de problemas. O suporte e os SLAs do Google não se aplicam aos Kata Containers.