Instalar o Agent Sandbox no GKE

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

  1. 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ão resourcemanager.projects.create. Saiba como conceder papéis.

    Acessar o seletor de projetos

  2. Verifique se o faturamento está ativado para o projeto do Google Cloud .

  3. 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.

    Ativar a API

  4. No console do Google Cloud , ative o Cloud Shell.

    Ativar 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.

  1. Defina a variável de ambiente LOCATION como uma zona, como us-central1-a:

    export LOCATION="us-central1-a"
    
  2. Crie o cluster:

    gcloud container clusters create ${CLUSTER_NAME} \
        --location=${LOCATION} \
        --machine-type=${MACHINE_TYPE} \
        --num-nodes=1
    
  3. Crie 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=gvisor
    

    Para 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.

  1. Aplique o manifesto da versão:

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

    O manifesto cria o namespace agent-sandbox-system e implanta o controlador nesse namespace.

  2. 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

  1. 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.io
    

    A saída lista as quatro CustomResourceDefinitions.

  2. Verifique se o controlador está em execução:

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

    Quando o controlador está em execução, a coluna READY mostra 1/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.

  1. Aplique a política:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yaml
    
  2. Aplique 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 segmentar sandbox.gke.io/runtime: gvisor.
  • tolerations: precisa incluir uma tolerância para o taint sandbox.gke.io/runtime=gvisor:NoSchedule.

Configuração proibida

O manifesto de implantação não pode incluir nenhum dos seguintes itens:

  • hostNetwork: true, hostPID: true ou hostIPC: true.
  • privileged: true em contextos de segurança de contêiner.
  • procMount: Unmasked em contextos de segurança de contêiner.
  • HostPath volumes.
  • 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.

  1. 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.yaml
    
  2. Implante 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 -
    
  3. Crie o serviço do roteador:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yaml
    
  4. Aguarde 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.

  1. No Cloud Shell, crie um arquivo chamado agent-sandbox-monitoring.yaml com 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: 30s
    
  2. Aplique 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 status Ready. 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, _sum ou _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.

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:

  1. No Cloud Shell, crie um arquivo chamado sandbox-template.yaml com 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: OnFailure
    
  2. Aplique o manifesto SandboxTemplate:

    kubectl apply -f sandbox-template.yaml
    
  3. Crie um arquivo chamado sandbox-warmpool.yaml com 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-template
    
  4. Aplique o manifesto SandboxWarmPool:

    kubectl apply -f sandbox-warmpool.yaml
    
  5. Aguarde 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=600s
    

    Se 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:

  1. Crie um arquivo chamado sandbox-claim.yaml com 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-warmpool
    
  2. Aplique o manifesto SandboxClaim:

    kubectl apply -f sandbox-claim.yaml
    
  3. Verifique 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:

  1. Crie um arquivo chamado sandbox.yaml com 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" # Required
    
  2. Aplique o manifesto do Sandbox:

    kubectl apply -f sandbox.yaml
    
  3. Verifique 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

  1. Verifique se há recursos do Agent Sandbox que ainda estão em uso:

    kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \
        --all-namespaces
    
  2. Se 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-policy
    
  3. Se 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.yaml
    

    Os outros recursos do roteador estão no namespace agent-sandbox-system, que será excluído na próxima etapa.

  4. 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