Dieses Dokument enthält Referenzimplementierungen für die Speicherverwaltung für Agent Sandbox in GKE, die auf die Anforderungen des Datenlebenszyklus Ihrer Agenten zugeschnitten sind.
Wählen Sie je nach den Anforderungen an den Datenlebenszyklus Ihrer Agenten eine der folgenden Konfigurationen aus:
- Zustandsorientierten Arbeitsbereich konfigurieren
- Wiederherstellung zu einem bestimmten Zeitpunkt und Übertragung der Eigentumsrechte konfigurieren
- Temporären Arbeitsbereich konfigurieren
Weitere Informationen zur Auswahl einer Speicherlösung finden Sie unter Speicher für KI-Agenten-Arbeitslasten auswählen.
Im folgenden Dokument wird die StorageClass dynamic-rwo für die automatische Auswahl des Laufwerkstyps verwendet, um Laufwerke bereitzustellen, die mit den Maschinentypen von Knoten kompatibel sind, auf denen Agent Sandbox auf GKE-Pods geplant ist. Damit die GKE Hyperdisk Balanced-Volumes für den Speicher Ihrer Agenten bereitstellt, müssen Sie Ihre Agent Sandbox in GKE-Pods auf den Knoten kompatibler Maschinenfamilien wie N4 planen. Andernfalls greift die GKE auf pd-balanced zurück.
In diesem Dokument wird der Datenzugriffsmodus Private Isolated Workspace mit ReadWriteOnce-Zugriff (RWO) implementiert. In diesem Modus wird ein Agent mit einem privaten, isolierten Speicherverzeichnis gestartet, auf das er alleinigen Lese- und Schreibzugriff hat.
Sofern nicht anders angegeben, verwenden die Referenzimplementierungen in diesem Dokument die direkte Sandbox-Erstellung, die für Agenten geeignet ist, die eine Startlatenz von mehreren Sekunden tolerieren. Wenn Sie eine Startlatenz von weniger als einer Sekunde für zustandsorientierte oder Point-in-Time-Wiederherstellungsarbeitsbereiche erreichen möchten, müssen Sie die Agent Sandbox in GKE-Warm-Pools verwenden. Das Binden von Speicher an einen beanspruchten Warm-Pool-Pod erfordert benutzerdefiniertes Scripting und ein privilegiertes DaemonSet. Eine Referenzimplementierung finden Sie in diesem GitHub-Beispiel.
Alternative Zugriffsmodi
Wenn Sie alternative Zugriffsmodi unterstützen möchten, können Sie die Volume- und Snapshot-Definitionen in den Konfigurationen ändern:
- Arbeitsbereich für die Zusammenarbeit: Ändern Sie den
accessModesinReadWriteManyund verwenden Sie eine RWX-fähige StorageClass, z. B. Filestore Multishares (Enterprise) (enterprise-multishare-rwx). - Explorationsverzweigungs-Arbeitsbereich: Der Vorlagenordner wird mit Lesezugriff bereitgestellt und es wird ein separater beschreibbarer Arbeitsbereich bereitgestellt. Für die Basisvorlage müssen Sie Speicher verwenden, der mehrere schreibgeschützte Anhänge unterstützt, z. B. Hyperdisk ML mit dem Zugriffsmodus
ReadOnlyMany(ROX) oder Filestore Multishares mit dem Zugriffsmodus RWX.
Hinweis
Prüfen Sie, ob Sie einen GKE-Cluster haben, auf dem der Agent Sandbox-Controller installiert ist. Wenn nicht, führen Sie nur die folgenden Abschnitte von Agent Sandbox in GKE installieren aus und kehren Sie dann zu diesem Dokument zurück:
- Umgebungsvariablen definieren
- GKE-Cluster erstellen
- Agent Sandbox installieren
- Empfohlene Sicherheitsrichtlinie anwenden
Wenn Sie den Abschnitt Sandbox-Umgebung bereitstellen dieses Dokuments abgeschlossen haben, löschen Sie die darin erstellten Beispielressourcen, damit Ihre Knoten genügend Kapazität für die Sandboxen in diesem Dokument haben:
kubectl delete sandboxclaim sandbox-claim --ignore-not-found
kubectl delete sandboxwarmpool python-runtime-warmpool --ignore-not-found
kubectl delete sandbox sandbox-example-2 --ignore-not-found
Zustandsorientierten Arbeitsbereich konfigurieren
Verwenden Sie dieses Muster, um den neuesten Status der Dateien eines KI-Agenten beizubehalten. Das ist nützlich, wenn Ihr Agent den Status beibehalten muss, wenn die Agent-Sitzung pausiert oder beendet wird (Agent Sandbox wird gelöscht), und die Daten aus dem neuesten Status wiederherstellen muss, wenn die Agent-Sitzung aktiviert wird (Agent Sandbox wird neu erstellt).
Die Referenzimplementierung in diesem Abschnitt verwendet die direkte Sandbox-Erstellung und ist für KI-Agenten geeignet, die eine Startlatenz von mehreren Sekunden tolerieren.
Bei diesem Ansatz werden standardmäßige GKE-PersistentVolumeClaim-Ressourcen (PVC) verwendet, um eine Sandbox mit einem bereits vorhandenen PVC zu verknüpfen, der die Daten eines Nutzers enthält.
Das zustandsorientierte Arbeitsbereichsmuster folgt dieser Abfolge von Ereignissen:
- Bereitstellung: Der Administrator oder Orchestrator stellt manuell einen privaten PVC für jede Agentensitzung mit einer deterministischen Kennung (z. B.
pvc-agent-1) bereit. - Referenzierung: In der Ressource
Sandboxverwenden Sie das FeldpersistentVolumeClaimim Blockvolumes, um die genaueclaimNamedes vorhandenen Volumes anzugeben. - Latenz: Wenn die Sandbox erstellt wird, muss die GKE das Compute Engine-Laufwerk dynamisch an die Knoten-VM anhängen. Dies führt zu einer Standardverzögerung von mehreren Sekunden.
- Persistenz: Bei Beendigung der Sitzung (Löschen der
Sandbox-Ressource) trennt GKE das Laufwerk, zerstört aber nicht das PVC. Dadurch wird sichergestellt, dass der aktuelle Status für die nächste Sitzung erhalten bleibt.
Führen Sie die Schritte in den folgenden Abschnitten aus, um einen zustandsorientierten Arbeitsbereich zu konfigurieren, in dem Daten zwischen Sitzungen beibehalten werden.
Nichtflüchtigen Arbeitsbereich (PVC) bereitstellen
Erstellen Sie einen privaten PersistentVolumeClaim (PVC), der eine deterministische Kennung wie pvc-agent-1 verwendet.
Speichern Sie das folgende Manifest als
pvc-agent-1.yaml:apiVersion: v1 kind: PersistentVolumeClaim metadata: name: pvc-agent-1 # Derived directly from the deterministic assignment ID namespace: default spec: accessModes: - ReadWriteOnce storageClassName: dynamic-rwo # Selects disk type compatible with the node machine family resources: requests: storage: 10GiWenden Sie das Manifest an:
kubectl apply -f pvc-agent-1.yaml
Da die Speicherklasse die dynamische Volume-Bindung verwendet, ist das Laufwerk noch an keinen Knoten angehängt. Er bleibt im Status Pending, bis ein Pod, der ihn anfordert, geplant wird.
Agent Sandbox bereitstellen
Stellen Sie die benutzerdefinierte Sandbox-Ressource bereit und verweisen Sie dabei auf den deterministischen PVC.
Speichern Sie das folgende Manifest als
sandbox-agent-1.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: sandbox-agent-1 # Traceable sandbox name namespace: default spec: podTemplate: spec: runtimeClassName: gvisor # Required automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor # Required tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: workspace-disk mountPath: /workspace # Mounts the private disk into the container resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumes: - name: workspace-disk persistentVolumeClaim: claimName: pvc-agent-1 # Binds this specific Sandbox to Agent 1's PVC restartPolicy: OnFailureWenden Sie das Manifest an:
kubectl apply -f sandbox-agent-1.yamlWarten Sie, bis die Sandbox bereit ist:
kubectl wait sandbox sandbox-agent-1 \ --for=condition=Ready \ --timeout=300sGKE prüft die Knotenkapazität und hängt das Laufwerk an. Das dauert einige Sekunden. Der Container wird in einem gVisor-Kernel im Userspace initialisiert. In einem Autopilot-Cluster kann es einige Minuten dauern, bis die Sandbox bereit ist, da GKE möglicherweise einen Knoten dafür erstellen muss.
Daten vom KI-Agenten schreiben
Simulieren Sie einen aktiven KI-Agenten, der Dateiänderungen in seinem Arbeitsbereich vornimmt, indem Sie eine Textdatei auf das bereitgestellte Laufwerk schreiben.
# Set the active Pod name
POD_NAME=sandbox-agent-1
# Write a state file to the persistent directory
kubectl exec ${POD_NAME} -- sh -c "echo 'Workspace State Saved - Agent 1' > /workspace/modified_data.txt"
# Confirm the file exists on the disk
kubectl exec ${POD_NAME} -- cat /workspace/modified_data.txt
Agentensitzung beenden
Wenn Sie das Herunterskalieren oder Beenden der Sitzung simulieren möchten, wenn der Agent inaktiv wird, löschen Sie die Ressource Sandbox, behalten Sie aber den zugrunde liegenden Speicher bei.
kubectl delete sandbox sandbox-agent-1
GKE hebt die Bereitstellung des Laufwerks auf und trennt es. Der PVC pvc-agent-1 bleibt erhalten und die Daten werden beibehalten.
Agent-Sitzung wieder aktivieren
Wenn Sie die Sitzung wieder aktivieren möchten, stellen Sie eine neue Sandbox-Ressource bereit, die auf denselben PVC verweist, und warten Sie, bis die Sandbox bereit ist:
kubectl apply -f sandbox-agent-1.yaml
kubectl wait sandbox sandbox-agent-1 \
--for=condition=Ready \
--timeout=300s
Das Laufwerk wird wieder angehängt (was zu einer Verzögerung führt) und der Container wird gestartet.
Datenaufbewahrung prüfen
Prüfen Sie den neu erstellten Sandbox-Container, um sicherzustellen, dass die Daten der vorherigen Sitzung beibehalten wurden.
# Set the active Pod name of the new session
NEW_POD_NAME=sandbox-agent-1
# Read the file from the newly booted sandbox
kubectl exec ${NEW_POD_NAME} -- cat /workspace/modified_data.txt
Die Ausgabe sollte Workspace State Saved - Agent 1 enthalten.
Ressourcen bereinigen
Löschen Sie die Agent Sandbox und die zugehörige Anforderung eines nichtflüchtigen Volumes:
kubectl delete sandbox sandbox-agent-1
kubectl delete pvc pvc-agent-1
Wiederherstellung zu einem bestimmten Zeitpunkt und Übertragung der Eigentumsrechte konfigurieren
Verwenden Sie dieses Muster, um Datasets für parallele Tests, Fehlerbehebung oder unabhängige Arbeit zu klonen. Der Arbeitsbereich eines KI-Agenten wird aus einem historischen Datensatz (oder einem freigegebenen Status) initialisiert. Nachfolgende Änderungen werden in einer separaten, privaten, beschreibbaren Ebene gespeichert, ohne die Basisvorlage zu ändern.
Die Referenzimplementierung in diesem Abschnitt verwendet die direkte Sandbox-Erstellung und ist für KI-Agenten geeignet, die eine Startlatenz von mehreren Sekunden tolerieren. Bei diesem Ansatz stellt der Orchestrator dynamisch neue PersistentVolumeClaims (PVCs) aus historischen VolumeSnapshots bereit, bevor eine neue Sandbox-Sitzung gestartet wird.
VolumeSnapshotClass erstellen
Erstellen Sie eine VolumeSnapshotClass, die den CSI-Treiber und die Löschrichtlinie angibt.
Verwenden Sie für Hyperdisk den Treiber pd.csi.storage.gke.io.
Speichern Sie das folgende Manifest als
1-snapshot-class.yaml:apiVersion: snapshot.storage.k8s.io/v1 kind: VolumeSnapshotClass metadata: name: standard-rwo-snapshot driver: pd.csi.storage.gke.io deletionPolicy: DeleteWenden Sie das Manifest an:
kubectl apply -f 1-snapshot-class.yaml
Ersten Arbeitsbereich bereitstellen
Erstellen Sie ein Volume, auf dem der Agent seine erste Arbeit ausführt.
Speichern Sie das folgende Manifest als
2-source-pvc.yaml:apiVersion: v1 kind: PersistentVolumeClaim metadata: name: agent-source-pvc spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo resources: requests: storage: 10GiWenden Sie das Manifest an:
kubectl apply -f 2-source-pvc.yaml
Zustandsdaten generieren
Stellen Sie einen Sandbox-Pod bereit, um Daten in das Volume zu schreiben.
Speichern Sie das folgende Manifest als
3-source-sandbox.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: agent-session-v1 namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor # Required tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: workspace mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumes: - name: workspace persistentVolumeClaim: claimName: agent-source-pvc restartPolicy: OnFailureWenden Sie das Manifest an:
kubectl apply -f 3-source-sandbox.yamlWarten Sie, bis die Sandbox bereit ist, und schreiben Sie dann eine Statusdatei. Mit dem Befehl
syncwird der Schreibvorgang auf das Laufwerk geleert, sodass der Snapshot im nächsten Abschnitt den Inhalt der Datei enthält:kubectl wait sandbox agent-session-v1 \ --for=condition=Ready \ --timeout=300s POD_NAME=agent-session-v1 kubectl exec ${POD_NAME} -- sh -c "echo 'Point-in-Time Snapshot - v1' > /workspace/state.txt && sync"
Historischen Zustand archivieren (CSI-VolumeSnapshot)
Lösen Sie einen CSI-VolumeSnapshot aus, um den aktuellen Status einzufrieren. Beachten Sie beim Erstellen eines Snapshots die Best Practices für Laufwerk-Snapshots.
Speichern Sie das folgende Manifest als
4-volume-snapshot.yaml:apiVersion: snapshot.storage.k8s.io/v1 kind: VolumeSnapshot metadata: name: agent-session-v1-snapshot spec: volumeSnapshotClassName: standard-rwo-snapshot source: persistentVolumeClaimName: agent-source-pvcWenden Sie das Manifest an:
kubectl apply -f 4-volume-snapshot.yamlWarten Sie, bis der Snapshot einsatzbereit ist:
kubectl wait volumesnapshot agent-session-v1-snapshot \ --for=jsonpath='{.status.readyToUse}'=true \ --timeout=600s
Volume aus dem Snapshot wiederherstellen
Stellen Sie einen neuen PVC bereit, dessen dataSource auf den CSI-VolumeSnapshot verweist.
Speichern Sie das folgende Manifest als
5-restored-pvc.yaml:apiVersion: v1 kind: PersistentVolumeClaim metadata: name: agent-restored-pvc spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo dataSource: name: agent-session-v1-snapshot kind: VolumeSnapshot apiGroup: snapshot.storage.k8s.io resources: requests: storage: 10GiWenden Sie das Manifest an:
kubectl apply -f 5-restored-pvc.yaml
Wiederhergestellte Agent Sandbox-Sitzung starten
Stellen Sie eine neue Sandbox-Ressource bereit, die auf den neu wiederhergestellten PVC verweist.
Speichern Sie das folgende Manifest als
6-restored-sandbox.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: agent-session-v2-restored namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor # Required tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: workspace mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumes: - name: workspace persistentVolumeClaim: claimName: agent-restored-pvc restartPolicy: OnFailureWenden Sie das Manifest an:
kubectl apply -f 6-restored-sandbox.yamlWarten Sie, bis die Sandbox bereit ist:
kubectl wait sandbox agent-session-v2-restored \ --for=condition=Ready \ --timeout=600sEs kann länger dauern, bis diese Sandbox bereit ist, als die Quell-Sandbox, da GKE das Laufwerk aus dem Snapshot erstellt, nachdem der Snapshot bereit ist.
Persistenz und Wiederherstellung prüfen
Prüfen Sie, ob der Agent die Verlaufsdaten lesen kann.
NEW_POD_NAME=agent-session-v2-restored
kubectl exec ${NEW_POD_NAME} -- cat /workspace/state.txt
Erwartete Ausgabe: Point-in-Time Snapshot - v1
Ressourcen bereinigen
Löschen Sie die Agent Sandboxes, PVCs und den VolumeSnapshot:
kubectl delete sandbox agent-session-v1
kubectl delete sandbox agent-session-v2-restored
kubectl delete pvc agent-source-pvc
kubectl delete pvc agent-restored-pvc
kubectl delete volumesnapshot agent-session-v1-snapshot
kubectl delete volumesnapshotclass standard-rwo-snapshot
Temporären Arbeitsbereich konfigurieren
Verwenden Sie das Muster für sitzungsspezifische Arbeitsbereiche, wenn ein Agent ein Speichervolumen zum Speichern temporärer Dateien benötigt, während der Agent aktiv ist. Beim Löschen der Agent Sandbox müssen keine Daten beibehalten werden.
Mit Start in weniger als einer Sekunde konfigurieren
Verwenden Sie Agent Sandbox in GKE-Warm-Pools, um leere Volumes im Hintergrund vorab bereitzustellen.
SandboxTemplate-Ressource definieren
Definieren Sie die Sicherung des sitzungsspezifischen Speichers im Block volumeClaimTemplate.
Speichern Sie das folgende Manifest als
stateless-template.yaml:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxTemplate metadata: name: stateless-sandbox-template namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false securityContext: runAsNonRoot: true runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: ephemeral-disk mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumeClaimTemplates: - metadata: name: ephemeral-disk spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo # Selects disk type compatible with node machine family resources: requests: storage: 10Gi
SandboxWarmPool-Ressource starten
Speichern Sie das folgende Manifest als
stateless-warmpool.yaml:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxWarmPool metadata: name: stateless-warmpool namespace: default spec: replicas: 2 # Keep two standby Pods with pre-attached empty disks sandboxTemplateRef: name: stateless-sandbox-templateWenden Sie beide Manifeste an:
kubectl apply -f stateless-template.yaml kubectl apply -f stateless-warmpool.yamlWarten Sie, bis die Sandboxen des warmen Pools bereit sind:
kubectl wait sandboxwarmpool stateless-warmpool \ --for=jsonpath='{.status.readyReplicas}'=2 \ --timeout=600sWenn Sie eine
SandboxClaim-Ressource erstellen, bevor die Sandboxen des Pools bereit sind, erstellt der Controller möglicherweise eine neue Sandbox für die Anforderung, anstatt eine aus dem Pool zuzuweisen. In einem Autopilot-Cluster kann es einige Minuten dauern, bis die Sandboxen bereit sind, da GKE möglicherweise Knoten für sie erstellen muss.
Ressource SandboxClaim erstellen
Definieren Sie eine SandboxClaim-Ressource, die ausgelöst wird, wenn ein Nutzer eine Sitzung startet.
Speichern Sie das folgende Manifest als
stateless-sandbox-claim.yaml:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxClaim metadata: name: agent-1-claim spec: warmPoolRef: name: stateless-warmpoolWenden Sie das Manifest an:
kubectl apply -f stateless-sandbox-claim.yaml
Ausführung in weniger als einer Sekunde prüfen
Warten Sie, bis der Claim bereit ist, rufen Sie den Namen des Agent Sandbox-Pods ab und prüfen Sie dann, ob das Verzeichnis /workspace bereitgestellt und sofort einsatzbereit ist:
kubectl wait sandboxclaim agent-1-claim --for=condition=Ready --timeout=300s
export POD_NAME=$(kubectl get sandboxclaim agent-1-claim -o jsonpath='{.status.sandbox.name}')
kubectl exec ${POD_NAME} -- ls -la /workspace
Agentensitzung beenden
Löschen Sie die Ressource SandboxClaim, um die KI-Agentensitzung zu beenden. Durch das Löschen des Claims werden auch die beanspruchte Sandbox und ihr Volume gelöscht:
kubectl delete sandboxclaim agent-1-claim
Ressourcen bereinigen
Löschen Sie die Ressourcen SandboxWarmPool und SandboxTemplate:
kubectl delete sandboxwarmpool stateless-warmpool
kubectl delete sandboxtemplate stateless-sandbox-template
Mit Startzeit von mehreren Sekunden konfigurieren
Wenn Sie einen sitzungsspezifischen Arbeitsbereich implementieren möchten, der eine Latenz von mehreren Sekunden toleriert, erstellen Sie die Agent Sandbox direkt ohne Warm Pool.
Zustandslose Agent Sandbox definieren
Speichern Sie das folgende Manifest als
sandbox-direct-stateless.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: sandbox-direct-stateless namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false securityContext: runAsNonRoot: true runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: ephemeral-disk mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required restartPolicy: OnFailure volumeClaimTemplates: - metadata: name: ephemeral-disk spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo resources: requests: storage: 10Gi
Agent Sandbox bereitstellen
Wenden Sie das Manifest an, um das Laufwerk dynamisch bereitzustellen und an den geplanten Knoten anzuhängen:
kubectl apply -f sandbox-direct-stateless.yaml
Startlatenz und Ausführung prüfen
Überwachen Sie den Pod-Status, um die Verzögerung beim Anhängen zu beobachten, bevor der Pod in den Status Running wechselt:
kubectl get pods -w
Wenn der Pod ausgeführt wird, drücken Sie Strg + C, um die Wiedergabe zu beenden.
Rufen Sie den Pod-Namen ab und prüfen Sie, ob das Verzeichnis /workspace verfügbar ist:
POD_NAME=sandbox-direct-stateless
kubectl exec ${POD_NAME} -- ls -la /workspace
Agentensitzung beenden
Löschen Sie die Ressource Sandbox, um den Pod automatisch zu beenden und seinen sitzungsspezifischen Speicher zu löschen:
kubectl delete sandbox sandbox-direct-stateless
Nächste Schritte
- Weitere Informationen zu Agent Sandbox in GKE
- Weitere Informationen zum Isolieren der KI-Code-Ausführung mit Agent Sandbox in GKE
- Agent Sandbox in GKE-Umgebungen mit Pod-Snapshots speichern und wiederherstellen