Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Menginstal Agent Sandbox di GKE

Autopilot Standard

Dokumen ini menjelaskan cara menginstal pengontrol Agent Sandbox open source di cluster Google Kubernetes Engine (GKE) untuk menjalankan workload yang di-sandbox di Pod Kubernetes khusus. Anda juga akan mempelajari cara membuat lingkungan sandbox di cluster untuk mengeksekusi kode yang tidak tepercaya dengan aman.

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

Memilih antara arsitektur berbasis Pod dan berbasis aktor

Sebelum menginstal Agent Sandbox di GKE, pastikan arsitektur GKE mana yang sesuai dengan workload agen AI Anda:

Agent Substrate di GKE (berbasis aktor): gunakan arsitektur ini untuk sebagian besar workload agentic, terutama agen stateful yang sering ditangguhkan dan dilanjutkan. Agen aktif berbagi kumpulan Pod hangat, bukan mempertahankan Pod khusus per agen, sehingga Anda dapat menjalankan lebih banyak agen di lebih sedikit node. Agent Substrate di GKE menyediakan penangguhan dan dimulainya kembali otomatis untuk workload yang tidak ada aktivitas, serta memulihkan agen dari penyimpanan dalam waktu kurang dari satu detik. Sebaliknya, Agent Sandbox di GKE memerlukan snapshot Pod manual, dan Anda perlu membangun kode aplikasi untuk mendeteksi ketidakaktifan dan menyimpan progres agen. Agent Substrate di GKE memerlukan cluster GKE Standard. Untuk mengetahui informasi selengkapnya, lihat Tentang Agent Substrate di GKE. Untuk menginstal opsi ini, lihat Menginstal Agent Substrate di GKE.
Agent Sandbox di GKE (berbasis Pod): gunakan arsitektur ini, yang Anda instal dalam dokumen ini, saat setiap agen memerlukan Pod Kubernetes khusus di cluster GKE Autopilot atau Standard. Pilih opsi ini untuk agen yang terus aktif atau workload yang memerlukan salah satu hal berikut:
- Kubernetes API deklaratif, seperti resource kustom Sandbox dan SandboxClaim
- Skema PodSpec Kubernetes lengkap, termasuk sidecar kustom dan container init
- Akses langsung ke akselerator hardware, seperti GPU atau TPU
- Cluster GKE Autopilot

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

Di konsol Google Cloud , pada halaman pemilih project, pilih atau buat project Google Cloud .
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.
Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang akan menghapus semua resource yang terkait dengan project ini.

Buka pemilih project
Pastikan penagihan diaktifkan untuk project Google Cloud Anda.
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

Di konsol Google Cloud , 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 Google Cloud 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 workload dalam sandbox—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 yang di-sandbox menggunakan gVisor atau microVMs. Jika Anda tidak menentukan runtime sandbox, sandbox akan berjalan tanpa isolasi kernel, yang tidak kami rekomendasikan untuk 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 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, buat cluster, lalu tambahkan node pool dengan gVisor yang diaktifkan. Untuk mengurangi biaya, dokumen ini membuat cluster zona dengan satu node per pool.

Tetapkan variabel lingkungan LOCATION ke zona, seperti us-central1-a:
```
export LOCATION="us-central1-a"
```

Membuat cluster:

gcloud container clusters create ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --machine-type=${MACHINE_TYPE} \
    --num-nodes=1

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 CustomResourceDefinition untuk resource Sandbox serta untuk resource ekstensi SandboxTemplate, SandboxClaim, dan SandboxWarmPool.

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.

Tunggu hingga pengontrol siap:
```
kubectl rollout status deployment/agent-sandbox-controller \
    --namespace=agent-sandbox-system \
    --timeout=120s
```
Catatan: Di cluster Autopilot, pengontrol mungkin memerlukan waktu beberapa menit untuk siap karena GKE mungkin perlu membuat node untuknya. Jika waktu perintah habis sebelum pengontrol siap, jalankan perintah lagi.

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

Memverifikasi penginstalan

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.

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 sandbox Anda. Untuk membantu menerapkan setelan isolasi untuk sandbox Anda, terapkan secure-sandbox-policy ValidatingAdmissionPolicy yang direkomendasikan dari repositori GitHub Agent Sandbox. Kebijakan ini menolak resource Sandbox yang tidak memenuhi persyaratan deployment Agent Sandbox di GKE.

Terapkan kebijakan:

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

Terapkan binding kebijakan. Binding 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 sementara.

Konfigurasi yang diperlukan

Manifes deployment Anda harus menyertakan setelan berikut:

runtimeClassName: gvisor: memastikan Pod berjalan di sandbox gVisor. Kebijakan ini menolak 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 sandbox 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 sandbox dari Pod router di namespace ini.

Buat akun layanan router dan izin RBAC yang memungkinkan router mencari Pod sandbox:

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

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 -

Buat Service router:

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

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 Sandbox Router.

Men-deploy lingkungan dengan sandbox

Sebaiknya deploy lingkungan dengan sandbox dengan menentukan resource SandboxTemplate dan menjaga instance yang telah dihangatkan tetap siap menggunakan resource SandboxWarmPool. Kemudian, Anda dapat meminta instance dari warm pool 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.

Direkomendasikan: Buat resource `SandboxTemplate` dan `SandboxWarmPool`

Resource SandboxTemplate berfungsi sebagai blueprint yang dapat digunakan kembali. Resource SandboxWarmPool membantu memastikan bahwa jumlah sandbox yang telah dihangatkan yang ditentukan selalu berjalan dan siap diklaim. Penggunaan resource kustom ini meminimalkan latensi startup.

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

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

Terapkan manifes SandboxTemplate:
```
kubectl apply -f sandbox-template.yaml
```

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

Terapkan manifes SandboxWarmPool:
```
kubectl apply -f sandbox-warmpool.yaml
```
Tunggu hingga sandbox warm pool siap:
```
kubectl wait sandboxwarmpool python-runtime-warmpool \
    --for=jsonpath='{.status.readyReplicas}'=2 \
    --timeout=600s
```
Jika Anda membuat resource SandboxClaim sebelum sandbox pool siap, pengontrol mungkin akan membuat sandbox baru untuk klaim, bukan menetapkan sandbox dari pool. Dalam cluster Autopilot, sandbox dapat memerlukan waktu beberapa menit untuk siap karena GKE mungkin perlu membuat node untuk sandbox tersebut.

Membuat resource `SandboxClaim`

Resource SandboxClaim meminta sandbox dari warm pool. Karena Anda membuat warm pool, pengontrol akan menetapkan sandbox yang berjalan dari pool ke klaim, bukan membuat yang baru.

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

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

Terapkan manifes SandboxClaim:
```
kubectl apply -f sandbox-claim.yaml
```

Pastikan sandbox, klaim, dan warm pool 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:

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

Terapkan manifes Sandbox:
```
kubectl apply -f sandbox.yaml
```
Pastikan 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

Periksa resource Agent Sandbox yang masih digunakan:

kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \
    --all-namespaces

Jika Anda menerapkan kebijakan keamanan yang direkomendasikan, hapus binding kebijakan dan kebijakannya:

kubectl delete validatingadmissionpolicybinding secure-sandbox-binding
kubectl delete validatingadmissionpolicy secure-sandbox-policy

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.

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 Google Cloud 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

Pelajari cara menyimpan dan memulihkan Agent Sandbox di lingkungan GKE dengan snapshot Pod.
Pelajari teknologi dasar yang digunakan oleh Agent Sandbox di GKE.
Pelajari keamanan GKE lebih lanjut.
Pelajari project open source Agent Sandbox di GitHub.
Pelajari cara menggunakan Kata Containers open source dengan Agent Sandbox di GKE. Kata Containers bukan produk Google Cloud . Jika Anda menginstal dan menggunakan software ini, Anda bertanggung jawab atas pengelolaan dan pemecahan masalah. Dukungan dan SLA Google tidak berlaku untuk Kata Containers.