Installa Agent Sandbox su GKE

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

  1. 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'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

    Vai al selettore di progetti

  2. Verifica che la fatturazione sia attivata per il tuo progetto Cloud de Confiance .

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

    Abilitare l'API

  4. Nella console Cloud de Confiance , attiva Cloud Shell.

    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 esempio agent-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 esempio us-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 esempio agent-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 esempio e2-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.

  1. Imposta la variabile di ambiente LOCATION su una zona, ad esempio us-central1-a:

    export LOCATION="us-central1-a"
    
  2. Crea il cluster:

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

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

  1. Applica il manifest della release:

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

    Il manifest crea lo spazio dei nomi agent-sandbox-system ed esegue il deployment del controller in questo spazio dei nomi.

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

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

    L'output elenca le quattro CustomResourceDefinition.

  2. Verifica che il controller sia in esecuzione:

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

    Quando il controller è in esecuzione, la colonna READY mostra 1/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.

  1. Applica la policy:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yaml
    
  2. Applica 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 target sandbox.gke.io/runtime: gvisor.
  • tolerations: deve includere una tolleranza per la contaminazione sandbox.gke.io/runtime=gvisor:NoSchedule.

Configurazione non consentita

Il manifest di deployment non deve includere nessuno dei seguenti elementi:

  • hostNetwork: true, hostPID: true o hostIPC: true.
  • privileged: true nei contesti di sicurezza dei container.
  • procMount: Unmasked nei contesti di sicurezza dei container.
  • HostPath volume.
  • 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.

  1. 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.yaml
    
  2. Esegui 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 -
    
  3. Crea il servizio del router:

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

  1. In Cloud Shell, crea un file denominato agent-sandbox-monitoring.yaml con 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: 30s
    
  2. Applica 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 stato Ready. 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, _sum o _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.

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:

  1. In Cloud Shell, crea un file denominato sandbox-template.yaml con 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: OnFailure
    
  2. Applica il manifest SandboxTemplate:

    kubectl apply -f sandbox-template.yaml
    
  3. Crea un file denominato sandbox-warmpool.yaml con 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-template
    
  4. Applica il manifest SandboxWarmPool:

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

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

  1. Crea un file denominato sandbox-claim.yaml con 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-warmpool
    
  2. Applica il manifest SandboxClaim:

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

  1. Crea un file denominato sandbox.yaml con 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" # Required
    
  2. Applica il manifest di Sandbox:

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

  1. Controlla se sono ancora in uso risorse di Agent Sandbox:

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

    Le altre risorse del router si trovano nello spazio dei nomi agent-sandbox-system, che verrà eliminato nel passaggio successivo.

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