Questo documento spiega come installare il controller open source Agent Sandbox su un cluster Google Kubernetes Engine (GKE) per eseguire workload degli agenti isolati in pod Kubernetes dedicati. Imparerai anche a creare una risorsa sandbox che esegue codice non attendibile nel runtime gVisor. Per la maggior parte dei workload degli agenti, utilizza invece Agent Substrate su GKE, perché può eseguire più agenti sugli stessi nodi. Utilizza Agent Sandbox su GKE quando ogni agente ha bisogno di un pod, di GPU o TPU dedicati, di un PodSpec Kubernetes completo o di un cluster GKE Autopilot. Per confrontare Agent Sandbox su GKE con Agent Substrate su GKE e scegliere un'architettura per i workload degli agenti AI, consulta Pianifica un'architettura per i workload degli agenti AI su GKE.
Per una panoramica di come Agent Sandbox su GKE isola il codice non attendibile generato dall'AI, consulta Informazioni su Agent Sandbox su GKE.
Costi
Agent Sandbox su GKE è un software open source che puoi utilizzare senza costi aggiuntivi. I prezzi di GKE si applicano alle risorse che crei, incluse le risorse di computing utilizzate dal controller di Agent Sandbox.
Per evitare addebiti non necessari, assicurati di disattivare GKE o di eliminare il progetto dopo aver completato questo documento.
Prima di iniziare
-
Nella console Cloud de Confiance , nella pagina di selezione del progetto, seleziona o crea un progetto Cloud de Confiance .
Ruoli richiesti per selezionare o creare un progetto
- Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per cui ti è stato concesso un ruolo.
-
Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (
roles/resourcemanager.projectCreator), che contiene l'autorizzazioneresourcemanager.projects.create. Scopri come concedere i ruoli.
-
Verifica che la fatturazione sia attivata per il tuo progetto Cloud de Confiance .
Abilita l'API Google Kubernetes Engine, se non è già abilitata.
Ruoli richiesti per abilitare le API
Per abilitare le API, devi disporre dell'autorizzazione
serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.-
Nella console Cloud de Confiance , attiva Cloud Shell.
Definisci le variabili di ambiente
Per semplificare i comandi che esegui in questo documento, puoi impostare le variabili di ambiente in Cloud Shell. In Cloud Shell, definisci le seguenti variabili di ambiente utili eseguendo questi comandi:
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"
Ecco una spiegazione di queste variabili di ambiente:
CLUSTER_NAME: il nome del tuo cluster GKE, ad esempioagent-sandbox-cluster.LOCATION: la regione o la zona Cloud de Confiance by S3NS in cui è stato creato il cluster GKE. Se crei un cluster Autopilot, impostalo sulla regione (ad esempious-central1). I cluster Autopilot sono sempre a livello di regione. Se crei un cluster Standard, impostalo sulla zona (ad esempio,us-central1-a). Per ridurre i costi, questo documento crea un cluster di zona, che utilizza meno nodi rispetto a un cluster regionale.AGENT_SANDBOX_VERSION: la versione del controller Agent Sandbox open source da installare. Questo documento utilizza la versione 1.0.6. Per visualizzare altre versioni, vai alla pagina delle release di Agent Sandbox.NODE_POOL_NAME: il nome del pool di nodi che eseguirà i pod dell'agente, ad esempioagent-sandbox-pool. Questa variabile è obbligatoria solo se stai creando un cluster GKE Standard.MACHINE_TYPE: il tipo di macchina dei nodi nel pool di nodi predefinito del cluster e nel pool di nodi gVisor, ad esempioe2-standard-2. Per informazioni dettagliate sulle diverse serie di macchine e sulla scelta tra le diverse opzioni, consulta la guida alle risorse e al confronto per le famiglie di macchine. Questa variabile è obbligatoria solo se stai creando un cluster GKE Standard.
Crea un cluster GKE
Agent Sandbox su GKE isola i workload degli agenti utilizzando GKE Sandbox con gVisor o microVMs. Se non specifichi un runtime GKE Sandbox (gVisor o microVM), i tuoi pod vengono eseguiti senza isolamento del kernel, quindi non utilizzarli per eseguire codice non attendibile. Questo documento utilizza gVisor. I cluster Autopilot attivano gVisor automaticamente. Nei cluster Standard, crei un pool di nodi con gVisor abilitato. Per utilizzare invece le microVM, consulta Attiva il tipo di sandbox microVM. La policy di sicurezza consigliata consente solo gVisor, quindi rifiuta le risorse Sandbox che utilizzano microVM.
Autopilot
Per creare un cluster Autopilot, assicurati che la variabile di ambiente LOCATION sia impostata su una regione, ad esempio us-central1, quindi esegui questo comando:
gcloud container clusters create-auto ${CLUSTER_NAME} \
--location=${LOCATION}
Standard
Per creare un cluster Standard, devi creare il cluster e poi aggiungere un pool di nodi con gVisor abilitato. Per ridurre i costi, questo documento crea un cluster di zona con un singolo nodo per pool.
Imposta la variabile di ambiente
LOCATIONsu una zona, ad esempious-central1-a:export LOCATION="us-central1-a"Crea il cluster:
gcloud container clusters create ${CLUSTER_NAME} \ --location=${LOCATION} \ --machine-type=${MACHINE_TYPE} \ --num-nodes=1Crea un pool di nodi separato con gVisor abilitato:
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=gvisorPer utilizzare le microVM anziché gVisor, crea il pool di nodi come descritto in Attiva il tipo di sandbox microVM. Il resto di questo documento utilizza gVisor.
Per utilizzare un cluster Standard esistente, assicurati che il cluster includa un pool di nodi con gVisor abilitato. Se il cluster non dispone di un pool di nodi di questo tipo, creane uno eseguendo il comando gcloud container node-pools create precedente.
Per consentire allo strumento a riga di comando kubectl di connettersi al cluster, recupera le credenziali del cluster:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${LOCATION}
Installa Agent Sandbox
Per installare Agent Sandbox, applica un manifest di release dal repository GitHub di Agent Sandbox. Il manifest sandbox-with-extensions.yaml installa il controller Agent Sandbox e le CustomResourceDefinition per la risorsa Sandbox e per le risorse di estensione SandboxTemplate, SandboxClaim e SandboxWarmPool.
Applica il manifest della release:
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yamlIl manifest crea lo spazio dei nomi
agent-sandbox-systemed esegue il deployment del controller in questo spazio dei nomi.Attendi che il controller sia pronto:
kubectl rollout status deployment/agent-sandbox-controller \ --namespace=agent-sandbox-system \ --timeout=120s
Puoi anche installare Agent Sandbox utilizzando Helm. Per istruzioni, consulta il README del grafico Helm di Agent Sandbox.
Verifica l'installazione
Verifica che le CustomResourceDefinition di Agent Sandbox siano installate:
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.ioL'output elenca le quattro CustomResourceDefinition.
Verifica che il controller sia in esecuzione:
kubectl get deployment agent-sandbox-controller \ --namespace=agent-sandbox-systemQuando il controller è in esecuzione, la colonna
READYmostra1/1.
Applica la policy di sicurezza consigliata
Per impostazione predefinita, Agent Sandbox su GKE non limita la configurazione dei pod che eseguono gli agenti. Per applicare le impostazioni di isolamento per i pod dell'agente, applica la ValidatingAdmissionPolicy secure-sandbox-policy consigliata dal repository GitHub di Agent Sandbox. Questa policy rifiuta qualsiasi risorsa Sandbox che non soddisfa i requisiti di deployment di Agent Sandbox su GKE.
Applica la policy:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yamlApplica l'associazione delle policy. L'associazione applica la policy in tutti gli spazi dei nomi, ad eccezione di quelli di sistema, come
kube-system:kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-binding.yaml
La policy convalida le risorse della sandbox. Quando crei una risorsa SandboxWarmPool o una risorsa SandboxClaim, il controller crea risorse Sandbox da una risorsa SandboxTemplate. Se il template non soddisfa i requisiti, la policy rifiuta la risorsa Sandbox e l'errore viene visualizzato nei log del controller. Per visualizzare i log, esegui questo comando:
kubectl logs deployment/agent-sandbox-controller \
--namespace=agent-sandbox-system
Questa policy è di tua proprietà e puoi modificarla in base ai tuoi workload. Per saperne di più, consulta Policy di sicurezza in modalità sandbox.
Requisiti di deployment di Agent Sandbox su GKE
Se applichi la policy di sicurezza consigliata, i manifest del workload, ad esempio una risorsa Sandbox o SandboxTemplate, devono includere impostazioni di sicurezza e configurazione specifiche. Se una risorsa Sandbox non soddisfa questi requisiti, il controller di ammissione la rifiuta. I requisiti dei container si applicano a tutti i container nel pod, inclusi i container init e i container temporanei.
Configurazione richiesta
Il manifest di deployment deve includere le seguenti impostazioni:
runtimeClassName: gvisor: esegue il pod nel runtime gVisor di GKE Sandbox. La policy rifiuta le risorse Sandbox che utilizzano qualsiasi altro runtime, incluse le microVM.automountServiceAccountToken: false: impedisce al pod di montare automaticamente il token del account di servizio predefinito.securityContext.runAsNonRoot: true: garantisce che il container non venga eseguito come utente root.securityContext.capabilities.drop: ["ALL"]: elimina tutte le funzionalità Linux dal container.resources.limits: devi specificare i limiti di CPU e memoria per evitare potenziali scenari di denial of service (DoS).nodeSelector: deve avere come targetsandbox.gke.io/runtime: gvisor.tolerations: deve includere una tolleranza per la contaminazionesandbox.gke.io/runtime=gvisor:NoSchedule.
Configurazione non consentita
Il manifest di deployment non deve includere nessuno dei seguenti elementi:
hostNetwork: true,hostPID: trueohostIPC: true.privileged: truenei contesti di sicurezza dei container.procMount: Unmaskednei contesti di sicurezza dei container.HostPathvolume.- Funzionalità aggiunte (
capabilities.add). - Impostazioni di
hostPort. - Sysctl personalizzati.
- Volumi proiettati per i token o i certificati dei account di servizio.
Esegui il deployment del router sandbox (facoltativo)
Il router della sandbox è un proxy HTTP che instrada le richieste dai client, come il client Python di Agent Sandbox, ai pod che eseguono gli agenti. Se prevedi di utilizzare il client Python, ad esempio come descritto in Isola l'esecuzione di codice AI con Agent Sandbox su GKE, esegui il deployment del router.
Esegui il deployment del router nello spazio dei nomi agent-sandbox-system. Per impostazione predefinita, la policy di rete creata da Agent Sandbox su GKE per ogni risorsa SandboxTemplate consente il traffico in entrata verso i pod dell'agente solo dai pod del router in questo spazio dei nomi.
Crea il account di servizio del router e le autorizzazioni RBAC che consentono al router di cercare i pod dell'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.yamlEsegui il deployment del router. Il seguente comando imposta l'immagine del router sulla stessa versione del controller:
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 il servizio del router:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yamlAttendi che il router sia pronto:
kubectl rollout status deployment/sandbox-router \ --namespace=agent-sandbox-system \ --timeout=120s
Questa configurazione del router è destinata allo sviluppo e ai test. Per le impostazioni di produzione, come TLS, conteggi delle repliche e policy di rete per il router, consulta il README del deployment del router sandbox.
Esporta le metriche del controller (facoltativo)
Il controller Agent Sandbox esporta le metriche di Prometheus nel percorso /metrics sulla porta metrics (porta 8080). Per raccogliere queste metriche utilizzando Google Cloud Managed Service per Prometheus ed eseguire query in Cloud Monitoring, applica una risorsa personalizzata PodMonitoring.
GKE abilita la raccolta gestita per impostazione predefinita sui cluster Autopilot che eseguono GKE versione 1.25 o successive e sui cluster Standard che eseguono GKE versione 1.27 o successive. Se la raccolta gestita non è abilitata per il tuo cluster, consulta Abilita la raccolta gestita manualmente.
Poiché i contatori e gli istogrammi di Prometheus non registrano l'attività che si è verificata prima dell'inizio della raccolta, applica la risorsa PodMonitoring dopo aver installato il controller in modo che Cloud Monitoring acquisisca gli eventi iniziali del cluster e delle risorse della sandbox.
In Cloud Shell, crea un file denominato
agent-sandbox-monitoring.yamlcon i seguenti contenuti: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: 30sApplica il manifest:
kubectl apply -f agent-sandbox-monitoring.yaml
Dopo aver applicato la risorsa PodMonitoring, Google Cloud Managed Service per Prometheus esegue lo scraping delle metriche del controller ogni 30 secondi. Puoi eseguire query su queste metriche con PromQL in Cloud Monitoring utilizzando Esplora metriche.
In Cloud Monitoring, Google Cloud Managed Service per Prometheus riserva l'etichetta namespace per lo spazio dei nomi del pod del controller sottoposto a scraping (agent-sandbox-system). Per le metriche che definiscono la propria etichetta namespace, Google Cloud Managed Service per Prometheus rinomina l'etichetta della metrica in exported_namespace. Per filtrare o raggruppare le metriche in base allo spazio dei nomi della risorsa Sandbox, utilizza l'etichetta exported_namespace. Per saperne di più, consulta Etichette riservate.
Ad esempio, puoi eseguire query sulle seguenti metriche:
agent_sandbox_build_info: informazioni sulla build del controller, come il commit Git e la versione.agent_sandboxes: il numero di risorse Sandbox nel cluster in un determinato momento. Questa metrica ha etichette per idoneità, scadenza, tipo di lancio, proprietario, creator, template e spazio dei nomi della risorsa Sandbox (exported_namespace). Ad esempio, la seguente query PromQL raggruppa le risorse Sandbox per spazio dei nomi e idoneità:sum by (exported_namespace, ready_condition) (agent_sandboxes)agent_sandbox_claim_controller_startup_latency_ms: un istogramma che misura la latenza in millisecondi dal momento in cui il controller osserva per la prima volta una risorsa SandboxClaim fino a quando la richiesta raggiunge lo statoReady. Poiché questa metrica è un istogramma Prometheus, l'esecuzione di query sul nome della metrica di base non restituisce dati direttamente. Devi eseguire query sulle serie_bucket,_sumo_count. Ad esempio, la seguente query PromQL calcola la latenza di avvio del 95° percentile in una finestra di frequenza di cinque minuti:histogram_quantile( 0.95, sum by (le) ( rate(agent_sandbox_claim_controller_startup_latency_ms_bucket[5m]) ) )
Per saperne di più sulle metriche esportate e sui componenti facoltativi da cui dipendono, consulta il riferimento sulle metriche del controller.
Esegui il deployment di un ambiente sandbox
Per eseguire il deployment di un ambiente sandbox, definisci una risorsa SandboxTemplate e tieni pronte le risorse Sandbox preriscaldate utilizzando una risorsa SandboxWarmPool. Puoi quindi richiedere una risorsa Sandbox da questo pool caldo utilizzando una risorsa SandboxClaim. In alternativa, puoi creare direttamente una risorsa Sandbox, ma questo approccio non supporta i pool di warm-up.
SandboxTemplate, SandboxWarmPool, SandboxClaim e Sandbox sono risorse personalizzate di Kubernetes.
Consigliato: crea risorse SandboxTemplate e SandboxWarmPool
La risorsa SandboxTemplate funge da progetto riutilizzabile. La risorsa SandboxWarmPool mantiene un numero specificato di risorse Sandbox preinizializzate con pod in esecuzione pronti per essere rivendicati. Questo pool "warm" riduce la latenza di avvio.
Per eseguire il deployment di un ambiente con sandbox creando le risorse SandboxTemplate e SandboxWarmPool, completa i seguenti passaggi:
In Cloud Shell, crea un file denominato
sandbox-template.yamlcon i seguenti contenuti: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: OnFailureApplica il manifest SandboxTemplate:
kubectl apply -f sandbox-template.yamlCrea un file denominato
sandbox-warmpool.yamlcon i seguenti contenuti: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-templateApplica il manifest SandboxWarmPool:
kubectl apply -f sandbox-warmpool.yamlAttendi che le risorse della sandbox del pool di preriscaldamento e i relativi pod siano pronti:
kubectl wait sandboxwarmpool python-runtime-warmpool \ --for=jsonpath='{.status.readyReplicas}'=2 \ --timeout=600sSe crei una risorsa SandboxClaim prima che le risorse Sandbox del pool e i relativi pod siano pronti, il controller crea una nuova risorsa Sandbox per la richiesta anziché assegnarne una dal pool. In un cluster Autopilot, i pod possono impiegare diversi minuti per essere pronti perché GKE potrebbe dover creare nodi per loro.
Crea una risorsa SandboxClaim
La risorsa SandboxClaim richiede una risorsa Sandbox dal pool caldo. Poiché hai creato un pool caldo, il controller assegna alla richiesta una risorsa Sandbox pronta (e il relativo pod in esecuzione) dal pool anziché crearne una nuova.
Per richiedere una risorsa Sandbox dal pool caldo creando una risorsa SandboxClaim, completa i seguenti passaggi:
Crea un file denominato
sandbox-claim.yamlcon i seguenti contenuti: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-warmpoolApplica il manifest SandboxClaim:
kubectl apply -f sandbox-claim.yamlVerifica che la risorsa, la richiesta e il pool caldo della sandbox siano pronti:
kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
Alternativa: crea direttamente una risorsa sandbox
Se non hai bisogno dei tempi di avvio rapidi forniti dai pool caldi, puoi eseguire il deployment di una risorsa Sandbox direttamente senza utilizzare i template.
Per eseguire il deployment di un ambiente in modalità sandbox creando direttamente una risorsa Sandbox, completa i seguenti passaggi:
Crea un file denominato
sandbox.yamlcon i seguenti contenuti: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" # RequiredApplica il manifest di Sandbox:
kubectl apply -f sandbox.yamlVerifica che la risorsa Sandbox sia in esecuzione:
kubectl get sandbox
Esegui l'upgrade di Agent Sandbox
Per eseguire l'upgrade di Agent Sandbox, applica il manifest di release per la nuova versione:
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
Sostituisci NEW_VERSION con la versione che vuoi installare, ad esempio una versione elencata nella pagina delle release di Agent Sandbox.
Prima di eseguire l'upgrade, consulta le note di rilascio della nuova versione. Se il tuo cluster esegue una versione di Agent Sandbox precedente alla 1.0.0, devi eseguire la migrazione delle risorse all'API v1beta1 prima di eseguire l'upgrade, perché la versione 1.0.0 ha rimosso l'API v1alpha1. Per istruzioni, consulta la guida alla migrazione dell'API.
Se hai eseguito il deployment del router della sandbox o applicato la policy di sicurezza consigliata, ripeti questi passaggi per la nuova versione.
Disinstalla Agent Sandbox
Controlla se sono ancora in uso risorse di Agent Sandbox:
kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \ --all-namespacesSe hai applicato la policy di sicurezza consigliata, elimina l'associazione della policy e la policy:
kubectl delete validatingadmissionpolicybinding secure-sandbox-binding kubectl delete validatingadmissionpolicy secure-sandbox-policySe hai eseguito il deployment del router sandbox, elimina le relative risorse RBAC a livello di cluster:
kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yamlLe altre risorse del router si trovano nello spazio dei nomi
agent-sandbox-system, che verrà eliminato nel passaggio successivo.Per eliminare il controller Agent Sandbox, il relativo spazio dei nomi e le relative CustomResourceDefinition, elimina il manifest della release per la versione che hai installato:
kubectl delete -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
Esegui la pulizia delle risorse
Per evitare che al tuo account Cloud de Confiance by S3NS vengano addebitati costi, elimina il cluster GKE che hai creato.
gcloud container clusters delete ${CLUSTER_NAME} \
--location=${LOCATION} \
--quiet
Se hai creato un cluster Autopilot, la località è la regione (ad esempio us-central1). Se hai creato un cluster Standard, la località è la zona (ad esempio us-central1-a).
Passaggi successivi
- Scopri come salvare e ripristinare Agent Sandbox negli ambienti GKE con gli snapshot dei pod.
- Scopri come GKE Sandbox isola i workload utilizzando gVisor o microVM.
- Scopri di più sulla sicurezza di GKE.
- Esplora il progetto open source Agent Sandbox su GitHub.
- Scopri come utilizzare Kata Containers open source con Agent Sandbox su GKE. Kata Containers non è un prodotto Cloud de Confiance . Se installi e utilizzi questo software, sei responsabile della gestione e della risoluzione dei problemi. L'assistenza e gli SLA di Google non si applicano a Kata Containers.