Menginstal Agent Sandbox di GKE

Dokumen ini menjelaskan cara menginstal pengontrol Agent Sandbox open source di cluster Google Kubernetes Engine (GKE) untuk menjalankan workload agen yang terisolasi di Pod Kubernetes khusus. Anda juga akan mempelajari cara membuat resource Sandbox yang menjalankan kode yang tidak tepercaya di runtime gVisor. Untuk sebagian besar workload agen, gunakan Agent Substrate di GKE, karena dapat menjalankan lebih banyak agen di node yang sama. Gunakan Agent Sandbox di GKE saat setiap agen memerlukan Pod, GPU, atau TPU khusus, PodSpec Kubernetes lengkap, atau cluster GKE Autopilot. Untuk membandingkan Agent Sandbox di GKE dengan Agent Substrate di GKE dan memilih arsitektur untuk workload agen AI Anda, lihat Merencanakan arsitektur untuk workload agen AI di GKE.

Untuk ringkasan tentang cara Agent Sandbox di GKE mengisolasi kode buatan AI yang tidak tepercaya, lihat Tentang Agent Sandbox di GKE.

Biaya

Agent Sandbox di GKE adalah software open source yang dapat Anda gunakan tanpa biaya tambahan. Harga GKE berlaku untuk resource yang Anda buat, termasuk resource komputasi yang digunakan pengontrol Agent Sandbox.

Untuk menghindari tagihan yang tidak perlu, pastikan Anda menonaktifkan GKE atau menghapus project setelah menyelesaikan dokumen ini.

Sebelum memulai

  1. Di konsol Cloud de Confiance , pada halaman pemilih project, pilih atau buat project Cloud de Confiance .

    Peran yang diperlukan untuk memilih atau membuat project

    • Memilih project: Memilih project tidak memerlukan peran IAM tertentu—Anda dapat memilih project apa pun yang perannya telah diberikan kepada Anda.
    • Membuat project: Untuk membuat project, Anda memerlukan peran Project Creator (roles/resourcemanager.projectCreator), yang berisi izin resourcemanager.projects.create. Pelajari cara memberikan peran.

    Buka pemilih project

  2. Pastikan penagihan diaktifkan untuk project Cloud de Confiance Anda.

  3. Aktifkan Google Kubernetes Engine API, jika belum diaktifkan.

    Peran yang diperlukan untuk mengaktifkan API

    Untuk mengaktifkan API, Anda memerlukan izin serviceusage.services.enable. Jika Anda membuat project, kemungkinan Anda sudah memiliki izin ini melalui peran Pemilik (roles/owner). Jika tidak, Anda bisa mendapatkan izin ini melalui peran Service Usage Admin (roles/serviceusage.serviceUsageAdmin). Pelajari cara memberikan peran.

    Mengaktifkan API

  4. Di konsol Cloud de Confiance , aktifkan Cloud Shell.

    Aktifkan Cloud Shell

Menentukan variabel lingkungan

Untuk menyederhanakan perintah yang Anda jalankan dalam dokumen ini, Anda dapat menetapkan variabel lingkungan di Cloud Shell. Di Cloud Shell, tentukan variabel lingkungan yang berguna berikut dengan menjalankan perintah berikut:

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"

Berikut penjelasan tentang variabel lingkungan ini:

  • CLUSTER_NAME: nama cluster GKE Anda—misalnya, agent-sandbox-cluster.
  • LOCATION: region atau zona Cloud de Confiance by S3NS tempat cluster GKE Anda dibuat. Jika Anda membuat cluster Autopilot, tetapkan ini ke region (misalnya, us-central1). Cluster Autopilot selalu bersifat regional. Jika Anda membuat cluster Standard, tetapkan ini ke zona (misalnya, us-central1-a). Untuk mengurangi biaya, dokumen ini membuat cluster zona, yang menggunakan lebih sedikit node daripada cluster regional.
  • AGENT_SANDBOX_VERSION: versi pengontrol Agent Sandbox open source yang akan diinstal. Dokumen ini menggunakan versi 1.0.6. Untuk melihat versi lainnya, buka halaman rilis Agent Sandbox.
  • NODE_POOL_NAME: nama node pool yang akan menjalankan Pod agen Anda—misalnya, agent-sandbox-pool. Variabel ini hanya diperlukan jika Anda membuat cluster GKE Standard.
  • MACHINE_TYPE: jenis mesin node di node pool default cluster Anda dan di node pool gVisor—misalnya, e2-standard-2. Untuk mengetahui detail tentang berbagai seri mesin dan memilih di antara berbagai opsi, lihat Panduan perbandingan dan resource kelompok mesin. Variabel ini hanya diperlukan jika Anda membuat cluster GKE Standard.

Membuat cluster GKE

Agent Sandbox di GKE mengisolasi workload agen menggunakan GKE Sandbox dengan gVisor atau microVMs. Jika Anda tidak menentukan runtime GKE Sandbox (gVisor atau microVM), Pod Anda akan berjalan tanpa isolasi kernel, jadi jangan gunakan Pod tersebut untuk menjalankan kode yang tidak tepercaya. Dokumen ini menggunakan gVisor. Cluster Autopilot mengaktifkan gVisor secara otomatis. Di cluster Standard, Anda membuat node pool yang mengaktifkan gVisor. Untuk menggunakan microVM, lihat Mengaktifkan jenis sandbox microVM. Kebijakan keamanan yang direkomendasikan hanya mengizinkan gVisor, sehingga menolak resource Sandbox yang menggunakan microVM.

Autopilot

Untuk membuat cluster Autopilot, pastikan variabel lingkungan LOCATION ditetapkan ke region, seperti us-central1, lalu jalankan perintah berikut:

gcloud container clusters create-auto ${CLUSTER_NAME} \
    --location=${LOCATION}

Standar

Untuk membuat cluster Standard, Anda membuat cluster, lalu menambahkan node pool dengan gVisor yang diaktifkan. Untuk mengurangi biaya, dokumen ini membuat cluster zona dengan satu node per pool.

  1. Tetapkan variabel lingkungan LOCATION ke zona, seperti us-central1-a:

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

    gcloud container clusters create ${CLUSTER_NAME} \
        --location=${LOCATION} \
        --machine-type=${MACHINE_TYPE} \
        --num-nodes=1
    
  3. Buat node pool terpisah dengan gVisor yang diaktifkan:

    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
    

    Untuk menggunakan microVM, bukan gVisor, buat node pool seperti yang dijelaskan dalam Mengaktifkan jenis sandbox microVM. Bagian lain dari dokumen ini menggunakan gVisor.

Untuk menggunakan cluster Standard yang ada, pastikan cluster tersebut menyertakan node pool yang mengaktifkan gVisor. Jika cluster tidak memiliki node pool tersebut, buat node pool dengan menjalankan perintah gcloud container node-pools create sebelumnya.

Agar alat command line kubectl dapat terhubung ke cluster, dapatkan kredensial cluster:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${LOCATION}

Menginstal Agent Sandbox

Untuk menginstal Agent Sandbox, terapkan manifes rilis dari repositori GitHub Agent Sandbox. Manifes sandbox-with-extensions.yaml menginstal pengontrol Agent Sandbox dan CustomResourceDefinitions untuk resource Sandbox serta untuk resource ekstensi SandboxTemplate, SandboxClaim, dan SandboxWarmPool.

  1. Terapkan manifes rilis:

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

    Manifes membuat namespace agent-sandbox-system dan men-deploy pengontrol di namespace tersebut.

  2. Tunggu hingga pengontrol siap:

    kubectl rollout status deployment/agent-sandbox-controller \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

Anda juga dapat menginstal Agent Sandbox menggunakan Helm. Untuk mengetahui petunjuknya, lihat README chart Helm Agent Sandbox.

Memverifikasi penginstalan

  1. Pastikan CustomResourceDefinitions Agent Sandbox telah diinstal:

    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
    

    Output akan mencantumkan empat CustomResourceDefinition.

  2. Pastikan pengontrol sedang berjalan:

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

    Saat pengontrol berjalan, kolom READY akan menampilkan 1/1.

Menerapkan kebijakan keamanan yang direkomendasikan

Secara default, Agent Sandbox di GKE tidak membatasi konfigurasi Pod yang menjalankan agen Anda. Untuk membantu menerapkan setelan isolasi bagi Pod agen Anda, terapkan secure-sandbox-policy ValidatingAdmissionPolicy yang direkomendasikan dari repositori GitHub Agent Sandbox. Kebijakan ini menolak resource Sandbox apa pun yang tidak memenuhi persyaratan deployment Agent Sandbox di GKE.

  1. Terapkan kebijakan:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yaml
    
  2. Terapkan binding kebijakan. Binding ini menerapkan kebijakan di semua namespace, kecuali namespace sistem, seperti kube-system:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-binding.yaml
    

Kebijakan ini memvalidasi resource Sandbox. Saat Anda membuat resource SandboxWarmPool atau resource SandboxClaim, pengontrol akan membuat resource Sandbox dari resource SandboxTemplate. Jika template tidak memenuhi persyaratan, kebijakan akan menolak resource Sandbox, dan error akan muncul di log pengontrol. Untuk melihat log, jalankan perintah berikut:

kubectl logs deployment/agent-sandbox-controller \
    --namespace=agent-sandbox-system

Anda memiliki kebijakan ini, dan Anda dapat mengubahnya agar sesuai dengan workload Anda. Untuk mengetahui informasi selengkapnya, lihat Kebijakan keamanan sandbox.

Persyaratan deployment Agent Sandbox di GKE

Jika Anda menerapkan kebijakan keamanan yang direkomendasikan, manifes workload Anda, seperti resource Sandbox atau SandboxTemplate, harus menyertakan setelan keamanan dan konfigurasi tertentu. Jika resource Sandbox tidak memenuhi persyaratan ini, pengontrol penerimaan akan menolaknya. Persyaratan container berlaku untuk semua container di Pod, termasuk container init dan container efemeral.

Konfigurasi yang diperlukan

Manifes deployment Anda harus menyertakan setelan berikut:

  • runtimeClassName: gvisor: menjalankan Pod di runtime gVisor GKE Sandbox. Kebijakan ini menolak resource Sandbox yang menggunakan runtime lain, termasuk microVM.
  • automountServiceAccountToken: false: mencegah Pod memasang token akun layanan default secara otomatis.
  • securityContext.runAsNonRoot: true: memastikan container tidak berjalan sebagai pengguna root.
  • securityContext.capabilities.drop: ["ALL"]: menghapus semua kemampuan Linux dari container.
  • resources.limits: Anda harus menentukan batas CPU dan memori untuk mencegah potensi skenario denial of service (DoS).
  • nodeSelector: harus menargetkan sandbox.gke.io/runtime: gvisor.
  • tolerations: harus menyertakan toleransi untuk taint sandbox.gke.io/runtime=gvisor:NoSchedule.

Konfigurasi yang dilarang

Manifes deployment Anda tidak boleh menyertakan salah satu hal berikut:

  • hostNetwork: true, hostPID: true, atau hostIPC: true.
  • privileged: true dalam konteks keamanan container.
  • procMount: Unmasked dalam konteks keamanan container.
  • HostPath volume.
  • Kemampuan tambahan (capabilities.add).
  • Setelan hostPort.
  • Sysctl kustom.
  • Volume yang diproyeksikan untuk token atau sertifikat akun layanan.

Men-deploy Router Sandbox (opsional)

Sandbox Router adalah proxy HTTP yang merutekan permintaan dari klien, seperti klien Python Agent Sandbox, ke Pod yang menjalankan agen Anda. Jika Anda berencana menggunakan klien Python, misalnya seperti yang dijelaskan dalam Mengisolasi eksekusi kode AI dengan Agent Sandbox di GKE, deploy router.

Anda men-deploy router di namespace agent-sandbox-system. Secara default, kebijakan jaringan yang dibuat Agent Sandbox di GKE untuk setiap resource SandboxTemplate hanya mengizinkan traffic masuk ke Pod agen dari Pod router di namespace ini.

  1. Buat akun layanan router dan izin RBAC yang memungkinkan router mencari Pod agen:

    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. Men-deploy router. Perintah berikut menetapkan image router ke versi yang sama dengan pengontrol:

    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. Buat Service router:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yaml
    
  4. Tunggu hingga router siap:

    kubectl rollout status deployment/sandbox-router \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

Konfigurasi router ini ditujukan untuk pengembangan dan pengujian. Untuk setelan produksi, seperti TLS, jumlah replika, dan kebijakan jaringan untuk router, lihat README deployment Router Sandbox.

Mengekspor metrik pengontrol (opsional)

Pengontrol Agent Sandbox mengekspor metrik Prometheus di jalur /metrics pada port metrics (port 8080). Untuk mengumpulkan metrik ini menggunakan Google Cloud Managed Service for Prometheus dan membuat kueri di Cloud Monitoring, terapkan resource kustom PodMonitoring.

GKE mengaktifkan pengumpulan terkelola secara default di cluster Autopilot yang menjalankan GKE versi 1.25 atau yang lebih baru dan di cluster Standard yang menjalankan GKE versi 1.27 atau yang lebih baru. Jika cluster Anda tidak mengaktifkan pengumpulan terkelola, lihat Mengaktifkan pengumpulan terkelola secara manual.

Karena penghitung dan histogram Prometheus tidak mencatat aktivitas yang terjadi sebelum pengumpulan dimulai, terapkan resource PodMonitoring setelah Anda menginstal pengontrol agar Cloud Monitoring menangkap peristiwa resource cluster dan Sandbox awal.

  1. Di Cloud Shell, buat file bernama agent-sandbox-monitoring.yaml dengan konten berikut:

    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. Terapkan manifes:

    kubectl apply -f agent-sandbox-monitoring.yaml
    

Setelah Anda menerapkan resource PodMonitoring, Google Cloud Managed Service for Prometheus akan mengumpulkan metrik pengontrol setiap 30 detik. Anda dapat mengkueri metrik ini dengan PromQL di Cloud Monitoring menggunakan Metrics Explorer.

Di Cloud Monitoring, Google Cloud Managed Service for Prometheus mencadangkan label namespace untuk namespace Pod pengontrol yang di-scrape (agent-sandbox-system). Untuk metrik yang menentukan label namespace-nya sendiri, Google Cloud Managed Service for Prometheus mengganti nama label metrik menjadi exported_namespace. Untuk memfilter atau mengelompokkan metrik menurut namespace resource Sandbox, gunakan label exported_namespace. Untuk mengetahui informasi selengkapnya, lihat Label yang dicadangkan.

Misalnya, Anda dapat mengkueri metrik berikut:

  • agent_sandbox_build_info: informasi build tentang pengontrol, seperti commit dan versi Git.

  • agent_sandboxes: jumlah resource Sandbox pada waktu tertentu dalam cluster. Metrik ini memiliki label untuk kesiapan, masa berlaku, jenis peluncuran, pemilik, pembuat, template, dan namespace resource Sandbox (exported_namespace). Misalnya, kueri PromQL berikut mengelompokkan resource Sandbox berdasarkan namespace dan kesiapan:

    sum by (exported_namespace, ready_condition) (agent_sandboxes)
    
  • agent_sandbox_claim_controller_startup_latency_ms: histogram yang mengukur latensi dalam milidetik sejak pengontrol pertama kali mengamati resource SandboxClaim hingga klaim mencapai status Ready. Karena metrik ini adalah histogram Prometheus, membuat kueri nama metrik dasar tidak akan menampilkan data secara langsung. Anda harus mengkueri deret _bucket, _sum, atau _count-nya. Misalnya, kueri PromQL berikut menghitung latensi startup persentil ke-95 dalam periode rasio lima menit:

    histogram_quantile(
      0.95,
      sum by (le) (
        rate(agent_sandbox_claim_controller_startup_latency_ms_bucket[5m])
      )
    )
    

Untuk mengetahui informasi selengkapnya tentang metrik yang diekspor dan komponen opsional yang menjadi dependensinya, lihat Referensi Metrik Pengontrol.

Men-deploy lingkungan dengan sandbox

Untuk men-deploy lingkungan dengan sandbox, tentukan resource SandboxTemplate dan siapkan resource Sandbox yang telah dihangatkan sebelumnya menggunakan resource SandboxWarmPool. Kemudian, Anda dapat meminta resource Sandbox dari kumpulan siap pakai ini menggunakan resource SandboxClaim. Atau, Anda dapat membuat resource Sandbox secara langsung, tetapi pendekatan ini tidak mendukung warm pool.

SandboxTemplate, SandboxWarmPool, SandboxClaim, dan Sandbox adalah resource kustom Kubernetes.

Resource SandboxTemplate berfungsi sebagai blueprint yang dapat digunakan kembali. Resource SandboxWarmPool mempertahankan jumlah resource Sandbox yang telah dihangatkan sebelumnya dengan Pod yang berjalan dan siap diklaim. Warm pool ini mengurangi latensi startup.

Untuk men-deploy lingkungan dengan sandbox dengan membuat resource SandboxTemplate dan SandboxWarmPool, selesaikan langkah-langkah berikut:

  1. Di Cloud Shell, buat file bernama sandbox-template.yaml dengan konten berikut:

    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. Terapkan manifes SandboxTemplate:

    kubectl apply -f sandbox-template.yaml
    
  3. Buat file bernama sandbox-warmpool.yaml dengan konten berikut:

    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. Terapkan manifes SandboxWarmPool:

    kubectl apply -f sandbox-warmpool.yaml
    
  5. Tunggu hingga resource Sandbox warm pool dan Pod-nya siap:

    kubectl wait sandboxwarmpool python-runtime-warmpool \
        --for=jsonpath='{.status.readyReplicas}'=2 \
        --timeout=600s
    

    Jika Anda membuat resource SandboxClaim sebelum resource Sandbox pool dan Pod-nya siap, pengontrol akan membuat resource Sandbox baru untuk klaim, bukan menetapkan resource dari pool. Dalam cluster Autopilot, Pod dapat memerlukan waktu beberapa menit untuk siap karena GKE mungkin perlu membuat node untuk Pod tersebut.

Membuat resource SandboxClaim

Resource SandboxClaim meminta resource Sandbox dari warm pool. Karena Anda membuat warm pool, pengontrol akan menetapkan resource Sandbox yang siap (dan Pod yang berjalan) dari pool ke klaim, bukan membuat yang baru.

Untuk meminta resource Sandbox dari warm pool dengan membuat resource SandboxClaim, selesaikan langkah-langkah berikut:

  1. Buat file bernama sandbox-claim.yaml dengan konten berikut:

    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. Terapkan manifes SandboxClaim:

    kubectl apply -f sandbox-claim.yaml
    
  3. Pastikan resource, klaim, dan warm pool Sandbox sudah siap:

    kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
    

Alternatif: Membuat resource Sandbox secara langsung

Jika tidak memerlukan waktu startup cepat yang disediakan oleh warm pool, Anda dapat men-deploy resource Sandbox secara langsung tanpa menggunakan template.

Untuk men-deploy lingkungan dengan sandbox dengan membuat resource Sandbox secara langsung, selesaikan langkah-langkah berikut:

  1. Buat file bernama sandbox.yaml dengan konten berikut:

    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. Terapkan manifes Sandbox:

    kubectl apply -f sandbox.yaml
    
  3. Pastikan resource Sandbox sedang berjalan:

    kubectl get sandbox
    

Mengupgrade Agent Sandbox

Untuk mengupgrade Agent Sandbox, terapkan manifes rilis untuk versi baru:

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

Ganti NEW_VERSION dengan versi yang ingin Anda instal, seperti versi yang tercantum di halaman rilis Agent Sandbox.

Sebelum melakukan upgrade, tinjau catatan rilis untuk versi baru. Jika cluster Anda menjalankan Agent Sandbox versi sebelum 1.0.0, Anda harus memigrasikan resource ke API v1beta1 sebelum melakukan upgrade, karena versi 1.0.0 menghapus API v1alpha1. Untuk mendapatkan petunjuk, lihat panduan migrasi API.

Jika Anda men-deploy Sandbox Router atau menerapkan kebijakan keamanan yang direkomendasikan, ulangi langkah-langkah tersebut untuk versi baru.

Meng-uninstal Agent Sandbox

  1. Periksa resource Agent Sandbox yang masih digunakan:

    kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \
        --all-namespaces
    
  2. Jika Anda menerapkan kebijakan keamanan yang direkomendasikan, hapus binding kebijakan dan kebijakannya:

    kubectl delete validatingadmissionpolicybinding secure-sandbox-binding
    kubectl delete validatingadmissionpolicy secure-sandbox-policy
    
  3. Jika Anda men-deploy Sandbox Router, hapus resource RBAC-nya di seluruh cluster:

    kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yaml
    

    Resource router lainnya berada di namespace agent-sandbox-system, yang akan dihapus pada langkah berikutnya.

  4. Untuk menghapus pengontrol Agent Sandbox, namespace-nya, dan CustomResourceDefinition-nya, hapus manifes rilis untuk versi yang Anda instal:

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

Membersihkan resource

Agar akun Cloud de Confiance by S3NS Anda tidak dikenai biaya, hapus cluster GKE yang Anda buat.

gcloud container clusters delete ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --quiet

Jika Anda membuat cluster Autopilot, lokasinya adalah region (misalnya, us-central1). Jika Anda membuat cluster Standard, lokasinya adalah zona (misalnya, us-central1-a).

Langkah berikutnya