Filestore-Agent-Volumes mit GKE Agent Substrate verwenden

Google Kubernetes Engine (GKE) Agent Substrate ist eine Infrastrukturplattform, die den Lebenszyklus von zustandsorientierten KI-Agent-Sandboxes verwaltet. Mit Agent Substrate können Plattformen inaktive Agent-Arbeitslasten anhalten, um Rechenkosten zu sparen, und sie in weniger als einer Sekunde fortsetzen, wenn neue Prompts oder Aufgaben eingehen.

Filestore-Agent-Volumes bieten die nichtflüchtige Speicherebene für Agent Substrate. So bleiben Arbeitsbereichdateien, Code-Repositories und Scratchpad-Artefakte über Sandbox-Unterbrechungs- und ‑Fortsetzungszyklen hinweg erhalten.

So werden Agent-Volumen in Agent Substrate verwendet

In den folgenden Schritten wird beschrieben, wie Agent Substrate und Filestore-Agent-Volumes einen interaktiven Coding-Agent unterstützen, der Entwicklern hilft, Funktionen zu erstellen, Tests auszuführen und Code zu debuggen:

  1. Sitzungsinitialisierung:Wenn ein Entwickler eine Aufgabe einreicht, erstellt Agent Substrate eine Sandbox-Umgebung in GKE und hängt ein dediziertes Filestore-Volume ein. Der KI-Agent klont das Projekt-Repository, installiert Abhängigkeiten und bereitet den Arbeitsbereich vor.
  2. Kostengünstige Inaktivitätsunterbrechung:Während der Entwickler Code-Differenzen prüft oder den nächsten Prompt erstellt, wird das Volume von Agent Substrate unmountet und die Rechenumgebung beendet. Die Nutzung von Computeressourcen sinkt auf null, während alle Arbeitsbereichsdateien, der Git-Verlauf und die Build-Caches im Volume erhalten bleiben.
  3. Sofortige Wiederaufnahme: Wenn der Entwickler einen neuen Prompt sendet, beansprucht Agent Substrate eine vorab aufgewärmte Sandbox und hängt das vorhandene Volume in weniger als 100 ms wieder an. Der Agent setzt die Arbeitslast sofort mit dem vollständigen Dateisystemkontext fort. So werden zeitaufwendige Re-Clones von Repositorys oder Neuinstallationen von Abhängigkeiten vermieden.

Weitere Informationen finden Sie in der Dokumentation zu Agent Substrate.

Wenn Sie zustandsorientierte Agent-Arbeitslasten auf GKE Agent Substrate mit Filestore-Agent-Volumes ausführen möchten, installieren Sie Agent Substrate, konfigurieren Sie die Filestore-CSI-Treiberintegration und definieren Sie Ihre Agent-Arbeitslasten für die Verwendung dynamischer CSI-Volumes.

Agent Substrate installieren

Wenn Sie Ihr Google Cloud -Projekt vorbereiten und Agent Substrate in einem GKE-Standardcluster installieren möchten, folgen Sie der Anleitung unter Agent Substrate in GKE installieren.

Filestore-CSI-Treiber installieren und konfigurieren

Wenn Sie Filestore-Agent-Volumes mit Agent Substrate verwenden möchten, müssen Sie bei der Ausführung des interaktiven Agent Substrate-Installationsprogramms den optionalen Schritt Filestore-CSI-Treiber auswählen.

Die Agent Substrate-Steuerungsebene (ateapi) kommuniziert direkt über Netzwerk-gRPC mit dem Filestore-CSI-Treiber-Controller. Der CSI-Treiber stellt dynamisch Volumes pro Akteur aus Ihrem Filestore-Volume-Pool bereit, hängt sie an und trennt sie wieder ab. Dies geschieht synchron mit dem Lebenszyklus der einzelnen Akteure.

Arbeitslasten erstellen, die Filestore-Volumes verwenden

In Agent Substrate definieren Sie externe Filestore-Volumes deklarativ in einer ActorTemplate-Ressource, anstatt separate Kubernetes-PersistentVolumeClaim-Objekte zu erstellen. Die folgenden Schritte führen Sie durch das Konfigurieren einer Filestore-StorageClass und CSIDriverConfig, das Bereitstellen einer WorkerPool und ActorTemplate, die ein externes Filestore-Volume bereitstellen, und das Verwalten des Akteurlebenszyklus.

StorageClass erstellen

Erstellen Sie eine Datei mit dem Namen storageclass.yaml, um dynamische Volumes aus Ihrem Filestore-Volumepool bereitzustellen:

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: Projekt-ID in Google Cloud .
  • LOCATION: Die Region, in der sich Ihr Volume-Pool befindet, z. B. us-central1.
  • VOLUME_POOL_NAME: Der Name Ihres Filestore-Volume-Pools.

Wenden Sie den StorageClass an:

kubectl apply -f storageclass.yaml

CSIDriverConfig registrieren

Die CSIDriverConfig-Ressource verbindet den Kubernetes-StorageClass-Bereitsteller (filestore.csi.storage.gke.io) mit dem Netzwerk-gRPC-Endpunkt des Filestore-CSI-Controllerdienstes und dem lokalen Unix-Domain-Socketpfad des CSI-Knoten-Plug-ins.

Erstellen Sie eine Datei mit dem Namen 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

Wenden Sie den CSIDriverConfig an:

kubectl apply -f csi-driver-config.yaml

WorkerPool und ActorTemplate definieren

  1. Erstellen Sie den ate-demo-Arbeitsbereich und den Kubernetes-Namespace, der als Isolationsgrenze für Ihren Worker-Pool, Ihre Akteurvorlage und Ihre Akteure dienen soll:

    kubectl ate create atespace ate-demo
kubectl create namespace ate-demo

  2. Erstellen Sie eine WorkerPool-Ressource, um physische Standby-Arbeitslasten bereitzuhalten, die Actors-Sandboxes hosten können. Speichern Sie das folgende Manifest als 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

  3. Wenden Sie das WorkerPool-Manifest an:

    kubectl apply -f worker-pool.yaml

  4. Erstellen Sie eine Datei mit dem Namen actor-template.yaml, in der das ActorTemplate definiert wird, das ein 5 GiB-Volume aus substrate-volumepool-sc einbindet:

    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

    Ersetzen Sie Folgendes:

    • CONTAINER_IMAGE: Das Container-Image für die Agent-Arbeitslast, z. B. gcr.io/my-project/agent-app@sha256:7f28ab0....
    • SNAPSHOT_BUCKET: Der Cloud Storage-Bucket, der von Agent Substrate zum Speichern von Akteurs-Snapshots verwendet wird.

    In diesem Manifest gibt volumes[].externalVolumeTemplate die angeforderte Volume-Kapazität (5Gi) und die StorageClass (substrate-volumepool-sc) an, deren Provisioner mit Ihrem CSIDriverConfig übereinstimmt, während containers[].volumeMounts dieses Volume unter /mnt/shared bereitstellt. Jedes in volumes deklarierte Volume muss von mindestens einem Container bereitgestellt werden.

  5. Erstellen Sie ActorTemplate über die Agent Substrate API mit der kubectl ate-CLI:

    kubectl ate create actor-template -f actor-template.yaml

Actor erstellen, sperren und reaktivieren

Sobald ActorTemplate erstellt und der goldene Snapshot bereit ist, können Sie eine Akteurinstanz erstellen und ihren Ausführungsstatus verwalten:

  1. Erstellen Sie einen neuen Akteur aus stateful-agent-template:

    kubectl ate create actor ACTOR_NAME \
    --template=stateful-agent-template \
    -a ate-demo

    Ersetzen Sie ACTOR_NAME durch einen DNS-1123-Labelnamen für Ihren Akteur, z. B. my-agent-1.

    Wenn Sie den Actor erstellen, stellt Agent Substrate dynamisch ein dediziertes Filestore-Volume aus substrate-volumepool-sc bereit und hängt es unter /mnt/shared ein.

  2. Akteur pausieren, wenn er inaktiv wird:

    kubectl ate suspend actor ACTOR_NAME \
    -a ate-demo

    Beim Anhalten des Actors wird der Speicherstatus in Cloud Storage gespeichert, das Filestore-Volume wird unmountet und getrennt, wobei alle Arbeitsbereichsdateien auf dem Volume erhalten bleiben, und die Arbeitslast wird freigegeben.

  3. Aktor fortsetzen, wenn eine neue Anfrage oder Aufgabe eingeht:

    kubectl ate resume actor ACTOR_NAME \
    -a ate-demo

    Wenn Sie den Actor fortsetzen, wird er einer verfügbaren Arbeitslast zugewiesen, sein Memory-Snapshot wird wiederhergestellt und das vorhandene Filestore-Volume wird unter /mnt/shared mit allen Dateien wieder angehängt.

Nächste Schritte