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

Menggunakan volume agen Filestore dengan Substrat Agen GKE

Substrat Agen Google Kubernetes Engine (GKE) adalah platform infrastruktur yang mengelola siklus proses sandbox agen AI stateful. Substrat Agen memungkinkan platform menangguhkan workload agen yang tidak aktif untuk menghemat biaya komputasi dan melanjutkannya dalam waktu kurang dari satu detik saat perintah atau tugas baru tiba.

Volume agen Filestore menyediakan lapisan penyimpanan persisten untuk Substrat Agen, yang mempertahankan file ruang kerja, repositori kode, dan artefak scratchpad di seluruh siklus penangguhan dan pelanjutan sandbox.

Cara Agent Substrate menggunakan volume agen

Langkah-langkah berikut menjelaskan cara volume agen Agent Substrate dan Filestore mendukung agen coding interaktif yang membantu developer membuat fitur, menjalankan pengujian, dan men-debug kode:

Inisialisasi sesi: Saat developer mengirimkan tugas, Agent Substrate membuat lingkungan sandbox di GKE dan memasang volume Filestore khusus. Agen meng-clone repositori project, menginstal dependensi, dan menyiapkan ruang kerja.
Penangguhan saat tidak ada aktivitas yang hemat biaya: Saat developer meninjau perbedaan kode atau membuat perintah berikutnya, Agent Substrate akan melepas volume dan menghentikan lingkungan komputasi. Penggunaan resource komputasi turun menjadi nol, sementara semua file ruang kerja, histori Git, dan cache build tetap dipertahankan dalam volume.
Lanjutan instan: Saat developer mengirim perintah baru, Substrat Agen mengklaim sandbox yang telah dipanaskan sebelumnya dan melampirkan kembali volume yang ada dalam waktu kurang dari 100 md. Agen segera melanjutkan beban kerja dengan konteks sistem file lengkap yang tetap utuh, sehingga menghindari pengkloningan ulang repositori yang memakan waktu atau penginstalan ulang dependensi.

Untuk mengetahui informasi selengkapnya, lihat dokumentasi Agent Substrate.

Untuk menjalankan workload agen stateful di GKE Agent Substrate dengan volume agen Filestore, Anda menginstal Agent Substrate, mengonfigurasi integrasi driver CSI Filestore, dan menentukan workload agen untuk menggunakan volume CSI dinamis.

Menginstal Agent Substrate

Untuk menyiapkan project Google Cloud dan menginstal Agent Substrate di cluster GKE Standard, ikuti petunjuk di bagian Menginstal Agent Substrate di GKE.

Menginstal dan mengonfigurasi driver CSI Filestore

Untuk menggunakan volume agen Filestore dengan Agent Substrate, Anda harus memilih langkah driver CSI Filestore opsional saat menjalankan penginstal Agent Substrate interaktif.

Bidang kontrol Agent Substrate (ateapi) berkomunikasi langsung dengan pengontrol driver CSI Filestore melalui gRPC jaringan. Driver CSI menyediakan, melampirkan, dan melepaskan volume per aktor secara dinamis dari kumpulan volume Filestore Anda secara sinkron dengan siklus proses setiap aktor.

Membuat workload yang menggunakan volume Filestore

Di Agent Substrate, Anda menentukan volume Filestore eksternal secara deklaratif dalam resource ActorTemplate, bukan membuat objek PersistentVolumeClaim Kubernetes terpisah. Langkah-langkah berikut akan memandu Anda mengonfigurasi StorageClass dan CSIDriverConfig Filestore, men-deploy WorkerPool dan ActorTemplate yang memasang volume Filestore eksternal, serta mengelola siklus proses aktor.

Buat `StorageClass`

Buat file bernama storageclass.yaml untuk menyediakan volume dinamis dari kumpulan volume Filestore Anda:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: substrate-volumepool-sc
provisioner: filestore.csi.storage.gke.io
parameters:
  volume-pool: "projects/PROJECT_ID/locations/LOCATION/volumePools/VOLUME_POOL_NAME"
allowVolumeExpansion: false
reclaimPolicy: Delete
volumeBindingMode: Immediate

Ganti kode berikut:

PROJECT_ID: Google Cloud Project ID Anda.
LOCATION: region tempat volume pool Anda berada, seperti us-central1.
VOLUME_POOL_NAME: nama pool volume Filestore Anda.

Terapkan StorageClass:

kubectl apply -f storageclass.yaml

Mendaftarkan `CSIDriverConfig`

Resource CSIDriverConfig menjembatani penyedia StorageClass Kubernetes (filestore.csi.storage.gke.io) ke endpoint gRPC jaringan layanan pengontrol CSI Filestore dan jalur soket domain Unix lokal plugin node CSI.

Buat file bernama csi-driver-config.yaml:

apiVersion: ate.dev/v1alpha1
kind: CSIDriverConfig
metadata:
  name: filestore.csi.storage.gke.io
spec:
  driverName: filestore.csi.storage.gke.io
  controllerEndpoint: tcp://csi-filestore-controller.gcp-filestore-csi-driver.svc:10000
  nodeSocketOverride: unix:///var/lib/kubelet/plugins/filestore.csi.storage.gke.io/csi.sock
  tls:
    enabled: true
    usePodIdentity: true
    serverName: csi-filestore-controller.gcp-filestore-csi-driver.svc

Terapkan CSIDriverConfig:

kubectl apply -f csi-driver-config.yaml

Tentukan `WorkerPool` dan `ActorTemplate`

Buat ate-demo atespace dan namespace Kubernetes yang akan berfungsi sebagai batas isolasi untuk kumpulan worker, template aktor, dan aktor Anda:
```
kubectl ate create atespace ate-demo
kubectl create namespace ate-demo
```

Buat resource WorkerPool untuk menjaga agar beban kerja standby fisik siap untuk menghosting sandbox aktor. Simpan manifes berikut sebagai worker-pool.yaml:

apiVersion: ate.dev/v1alpha1
kind: WorkerPool
metadata:
  name: agent-pool
  namespace: ate-demo
  labels:
    workload: stateful-agent
spec:
  replicas: 5
  workerImage: ko://github.com/agent-substrate/substrate/cmd/ateom-gvisor

Terapkan manifes WorkerPool:
```
kubectl apply -f worker-pool.yaml
```
Buat file bernama actor-template.yaml yang menentukan ActorTemplate yang me-mount volume 5 GiB dari substrate-volumepool-sc:
```
metadata:
  atespace: ate-demo
  name: stateful-agent-template
workerSelector:
  matchLabels:
    workload: stateful-agent
containers:
- name: agent
  image: CONTAINER_IMAGE
  volumeMounts:
  - name: shared-storage
    mountPath: /mnt/shared
  readyz:
    httpGet:
      path: /readyz
      port: 8080
sandboxConfig:
  sandboxClass: SANDBOX_CLASS_GVISOR
  configName: gvisor-default
snapshotsConfig:
  storageLocation: gs://SNAPSHOT_BUCKET/stateful-agent
volumes:
- name: shared-storage
  externalVolumeTemplate:
    capacity: 5Gi
    storageClassName: substrate-volumepool-sc
```
Ganti kode berikut:
- CONTAINER_IMAGE: image container untuk workload agen Anda, seperti gcr.io/my-project/agent-app@sha256:7f28ab0....
- SNAPSHOT_BUCKET: bucket Cloud Storage yang digunakan oleh Agent Substrate untuk menyimpan snapshot aktor.
Dalam manifes ini, volumes[].externalVolumeTemplate menentukan kapasitas volume yang diminta (5Gi) dan StorageClass (substrate-volumepool-sc) yang penyedianya cocok dengan CSIDriverConfig, sementara containers[].volumeMounts memasang volume tersebut di /mnt/shared. Setiap volume yang dideklarasikan di volumes harus di-mount oleh setidaknya satu penampung.
Buat ActorTemplate melalui Agent Substrate API menggunakan CLI kubectl ate:
```
kubectl ate create actor-template -f actor-template.yaml
```

Membuat, menangguhkan, dan melanjutkan aktor

Setelah ActorTemplate dibuat dan snapshot golden-nya siap, Anda dapat membuat instance aktor dan mengelola status eksekusinya:

Buat aktor baru dari stateful-agent-template:
```
kubectl ate create actor ACTOR_NAME \
    --template=stateful-agent-template \
    -a ate-demo
```
Ganti ACTOR_NAME dengan nama label DNS-1123 untuk aktor Anda, seperti my-agent-1.

Saat Anda membuat aktor, Agent Substrate akan secara dinamis menyediakan volume Filestore khusus dari substrate-volumepool-sc dan memasangnya di /mnt/shared.
Menangguhkan aktor saat tidak ada aktivitas:
```
kubectl ate suspend actor ACTOR_NAME \
    -a ate-demo
```
Menangguhkan aktor akan membuat checkpoint status memorinya ke Cloud Storage, melepas dan memisahkan volume Filestore sambil mempertahankan semua file ruang kerja di volume, dan merilis workload.
Lanjutkan aktor saat ada permintaan atau tugas baru:
```
kubectl ate resume actor ACTOR_NAME \
    -a ate-demo
```
Melanjutkan aktor akan menetapkannya ke workload yang tersedia, memulihkan snapshot memorinya, dan melampirkan kembali volume Filestore yang ada di /mnt/shared dengan semua file tetap utuh.

Langkah berikutnya

Siapkan lingkungan untuk GKE.
Konfigurasi sandbox yang sudah disiapkan sebelumnya dengan Agent Sandbox.
Jelajahi penyimpanan dinamis dengan Pengikatan terlambat Sandbox Agen.