Agent-Sandbox im GKE-Speicher verwalten

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:

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 accessModes in ReadWriteMany und 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:

  1. Umgebungsvariablen definieren
  2. GKE-Cluster erstellen
  3. Agent Sandbox installieren
  4. 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:

  1. Bereitstellung: Der Administrator oder Orchestrator stellt manuell einen privaten PVC für jede Agentensitzung mit einer deterministischen Kennung (z. B. pvc-agent-1) bereit.
  2. Referenzierung: In der Ressource Sandbox verwenden Sie das Feld persistentVolumeClaim im Block volumes, um die genaue claimName des vorhandenen Volumes anzugeben.
  3. 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.
  4. 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.

  1. 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: 10Gi
    
  2. Wenden 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.

  1. 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: OnFailure
    
  2. Wenden Sie das Manifest an:

    kubectl apply -f sandbox-agent-1.yaml
    
  3. Warten Sie, bis die Sandbox bereit ist:

    kubectl wait sandbox sandbox-agent-1 \
        --for=condition=Ready \
        --timeout=300s
    

    GKE 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.

  1. 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: Delete
    
  2. Wenden 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.

  1. 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: 10Gi
    
  2. Wenden 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.

  1. 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: OnFailure
    
  2. Wenden Sie das Manifest an:

    kubectl apply -f 3-source-sandbox.yaml
    
  3. Warten Sie, bis die Sandbox bereit ist, und schreiben Sie dann eine Statusdatei. Mit dem Befehl sync wird 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.

  1. 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-pvc
    
  2. Wenden Sie das Manifest an:

    kubectl apply -f 4-volume-snapshot.yaml
    
  3. Warten 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.

  1. 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: 10Gi
    
  2. Wenden 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.

  1. 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: OnFailure
    
  2. Wenden Sie das Manifest an:

    kubectl apply -f 6-restored-sandbox.yaml
    
  3. Warten Sie, bis die Sandbox bereit ist:

    kubectl wait sandbox agent-session-v2-restored \
        --for=condition=Ready \
        --timeout=600s
    

    Es 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.

  1. 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

  1. 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-template
    
  2. Wenden Sie beide Manifeste an:

    kubectl apply -f stateless-template.yaml
    kubectl apply -f stateless-warmpool.yaml
    
  3. Warten Sie, bis die Sandboxen des warmen Pools bereit sind:

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

    Wenn 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.

  1. 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-warmpool
    
  2. Wenden 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

  1. 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