Gérer Agent Sandbox sur le stockage GKE

Ce document fournit des implémentations de référence pour gérer le stockage d'Agent Sandbox sur GKE, adaptées aux besoins du cycle de vie des données de vos agents.

En fonction des besoins de vos agents en termes de cycle de vie des données, choisissez l'une des configurations suivantes :

Pour en savoir plus sur le choix d'une solution de stockage, consultez Choisir un stockage pour les charges de travail d'agents IA.

Le document suivant utilise la StorageClass dynamic-rwo pour la sélection automatique du type de disque afin de provisionner des disques compatibles avec les types de machines des nœuds sur lesquels les pods Agent Sandbox sur GKE sont planifiés. Pour vous assurer que GKE provisionne des volumes Hyperdisk Balanced pour le stockage de vos agents, vous devez planifier votre Agent Sandbox sur des pods GKE sur les nœuds de familles de machines compatibles, telles que N4. Sinon, GKE utilise pd-balanced.

Ce document implémente le mode d'accès aux données Espace de travail isolé privé à l'aide de l'accès ReadWriteOnce (RWO). Dans ce mode, un agent démarre avec un répertoire de stockage isolé privé auquel il dispose d'un accès exclusif en lecture et en écriture.

Sauf indication contraire, les implémentations de référence de ce document utilisent la création directe de bac à sable, qui s'applique aux agents qui tolèrent une latence de démarrage de plusieurs secondes. Pour obtenir une latence de démarrage inférieure à la seconde pour les espaces de travail avec état ou de restauration à un moment précis, vous devez utiliser Agent Sandbox sur les pools de préchauffage GKE. La liaison du stockage à un pod de pool de préchauffage revendiqué nécessite un script personnalisé et un DaemonSet privilégié. Pour obtenir un exemple d'implémentation, consultez cet exemple GitHub.

Autres modes d'accès

Pour prendre en charge d'autres modes d'accès, vous pouvez modifier les définitions de volume et d'instantané dans les configurations :

  • Espace de travail collaboratif : remplacez accessModes par ReadWriteMany et utilisez une StorageClass compatible avec RWX, telle que Filestore Multishares (Enterprise) (enterprise-multishare-rwx).
  • Espace de travail de branchement d'exploration : installez le dossier de modèle en lecture seule et fournissez un bloc-notes distinct accessible en écriture. Pour le modèle de base, vous devez utiliser un stockage compatible avec plusieurs rattachements en lecture seule, comme Hyperdisk ML avec le mode d'accès ReadOnlyMany (ROX) ou Filestore Multishares avec le mode d'accès RWX.

Avant de commencer

Assurez-vous de disposer d'un cluster GKE sur lequel le contrôleur Agent Sandbox est installé. Si ce n'est pas le cas, ne suivez que les sections suivantes de Installer Agent Sandbox sur GKE, puis revenez à ce document :

  1. Définir des variables d'environnement
  2. Créer un cluster GKE
  3. Installer Agent Sandbox
  4. Appliquer la stratégie de sécurité recommandée

Si vous avez suivi la section Déployer un environnement en bac à sable de ce document, supprimez les exemples de ressources qu'elle a créés afin que vos nœuds disposent d'une capacité suffisante pour les bacs à sable de ce document :

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

Configurer un espace de travail avec état

Utilisez ce modèle pour conserver l'état le plus récent des fichiers d'un agent. Il est utile lorsque votre agent doit conserver l'état lorsque la session de l'agent est suspendue ou arrêtée (Agent Sandbox est supprimé) et restaurer les données à partir du dernier état lorsque la session de l'agent est activée (Agent Sandbox est recréé).

L'implémentation de référence de cette section utilise la création directe de bac à sable et s'applique aux agents qui tolèrent une latence de démarrage de plusieurs secondes.

Cette approche utilise des ressources PersistentVolumeClaim (PVC) GKE standards pour associer un bac à sable à un PVC préexistant contenant les données d'un utilisateur.

Le modèle d'espace de travail avec état suit la séquence d'événements suivante :

  1. Provisionnement : l'administrateur ou l'orchestrateur provisionne manuellement un PVC privé pour chaque session d'agent à l'aide d'un identifiant déterministe (par exemple, pvc-agent-1).
  2. Référencement : dans la ressource Sandbox, vous utilisez le champ persistentVolumeClaim du bloc volumes pour spécifier le claimName exact du volume existant.
  3. Latence : lorsque le bac à sable est créé, GKE doit associer de manière dynamique le disque Compute Engine à la VM du nœud, ce qui entraîne un délai standard de plusieurs secondes.
  4. Persistance : à la fin de la session (suppression de la ressource Sandbox), GKE dissocie le disque, mais ne détruit pas la PVC, ce qui permet de s'assurer que le dernier état est conservé pour la session suivante.

Pour configurer un espace de travail avec état qui conserve les données entre les sessions, suivez les étapes décrites dans les sous-sections suivantes.

Provisionner un espace de travail persistant (PVC)

Créez un PersistentVolumeClaim (PVC) privé qui utilise un identifiant déterministe, tel que pvc-agent-1.

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste :

    kubectl apply -f pvc-agent-1.yaml
    

Comme la classe de stockage utilise la liaison de volume dynamique, le disque n'est encore associé à aucun nœud. Il reste à l'état Pending jusqu'à ce qu'un pod le demandant soit planifié.

Déployer Agent Sandbox

Déployez la ressource personnalisée Sandbox, en référençant la PVC déterministe.

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste :

    kubectl apply -f sandbox-agent-1.yaml
    
  3. Attendez que le bac à sable soit prêt :

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

    GKE vérifie la capacité du nœud et associe le disque, ce qui prend quelques secondes. Le conteneur s'initialise dans un noyau gVisor de l'espace utilisateur. Dans un cluster Autopilot, le bac à sable peut mettre plusieurs minutes à être prêt, car GKE peut avoir besoin de créer un nœud pour celui-ci.

Écrire des données à partir de l'agent

Simulez un agent IA actif qui modifie des fichiers dans son espace de travail en écrivant un fichier texte sur le disque installé.

# 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

Mettre fin à la session de l'agent

Pour simuler un scaling à la baisse ou l'arrêt de la session lorsque l'agent devient inactif, supprimez la ressource Sandbox, mais conservez l'espace de stockage sous-jacent.

kubectl delete sandbox sandbox-agent-1

GKE démonte et dissocie le disque. Le PVC pvc-agent-1 est conservé, ce qui préserve les données.

Réactiver la session de l'agent

Pour réactiver la session, redéployez une nouvelle ressource Sandbox qui référence le même PVC, puis attendez que le bac à sable soit prêt :

kubectl apply -f sandbox-agent-1.yaml

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

Le disque est réassocié (ce qui entraîne un délai d'association) et le conteneur démarre.

Vérifier la conservation des données

Inspectez le conteneur de bac à sable que vous venez de créer pour vérifier que les données de la session précédente ont été conservées.

# 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

Le résultat doit afficher Workspace State Saved - Agent 1.

Effectuer un nettoyage des ressources

Supprimez l'Agent Sandbox et la revendication de volume persistant associée :

kubectl delete sandbox sandbox-agent-1
kubectl delete pvc pvc-agent-1

Configurer une restauration à un moment précis et un transfert de propriété

Utilisez ce modèle pour cloner des ensembles de données afin d'exécuter des tests parallèles, de déboguer ou de travailler de manière indépendante. L'espace de travail d'un agent est initialisé à partir d'un ensemble de données historiques (ou d'un état partagé), ce qui permet d'enregistrer les modifications ultérieures dans une couche accessible en écriture distincte et privée, sans modifier le modèle de base.

L'implémentation de référence de cette section utilise la création directe de bac à sable et s'applique aux agents qui tolèrent une latence de démarrage de plusieurs secondes. Cette approche s'appuie sur l'orchestrateur pour provisionner de manière dynamique de nouvelles PersistentVolumeClaims (PVC) à partir d'anciens VolumeSnapshots avant de lancer une nouvelle session de bac à sable.

Créer la classe VolumeSnapshotClass

Créez un objet VolumeSnapshotClass qui spécifie le pilote CSI et la règle de suppression. Pour Hyperdisk, utilisez le pilote pd.csi.storage.gke.io.

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste :

    kubectl apply -f 1-snapshot-class.yaml
    

Provisionner l'espace de travail initial

Créez un volume dans lequel l'agent effectuera son travail initial.

  1. Enregistrez le manifeste suivant sous le nom 2-source-pvc.yaml :

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: agent-source-pvc
    spec:
      accessModes: ["ReadWriteOnce"]
      storageClassName: dynamic-rwo
      resources:
        requests:
          storage: 10Gi
    
  2. Appliquez le fichier manifeste :

    kubectl apply -f 2-source-pvc.yaml
    

Générer des données d'état

Déployez un pod de bac à sable pour écrire des données sur le volume.

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste :

    kubectl apply -f 3-source-sandbox.yaml
    
  3. Attendez que le bac à sable soit prêt, puis écrivez un fichier d'état. La commande sync vide l'écriture sur le disque afin que l'instantané de la section suivante inclue le contenu du fichier :

    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"
    

Archiver l'état historique (VolumeSnapshot CSI)

Déclenchez un VolumeSnapshot CSI pour figer l'état actuel. Lorsque vous prenez un instantané, suivez les bonnes pratiques pour les instantanés de disque.

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste :

    kubectl apply -f 4-volume-snapshot.yaml
    
  3. Attendez que l'instantané soit prêt à l'emploi :

    kubectl wait volumesnapshot agent-session-v1-snapshot \
        --for=jsonpath='{.status.readyToUse}'=true \
        --timeout=600s
    

Restaurer le volume à partir de l'instantané

Déployez une nouvelle PVC avec son dataSource pointant vers le VolumeSnapshot CSI.

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste :

    kubectl apply -f 5-restored-pvc.yaml
    

Lancer la session Agent Sandbox restaurée

Provisionnez une nouvelle ressource Sandbox qui référence le PVC que vous venez de restaurer.

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste :

    kubectl apply -f 6-restored-sandbox.yaml
    
  3. Attendez que le bac à sable soit prêt :

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

    La préparation de ce bac à sable peut prendre plus de temps que celle du bac à sable source, car GKE crée son disque à partir de l'instantané une fois que celui-ci est prêt.

Vérifier la persistance et la restauration

Vérifiez que l'agent peut lire les données historiques.

NEW_POD_NAME=agent-session-v2-restored
kubectl exec ${NEW_POD_NAME} -- cat /workspace/state.txt

Résultat attendu : Point-in-Time Snapshot - v1

Effectuer un nettoyage des ressources

Supprimez les Agent Sandboxes, les PVC et le 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

Configurer un espace de travail éphémère

Utilisez le modèle d'espace de travail éphémère lorsqu'un agent a besoin d'un volume de stockage pour stocker des fichiers temporaires pendant qu'il est actif. Aucune donnée ne doit être conservée lors de la suppression d'Agent Sandbox.

Configurer avec un démarrage en moins d'une seconde

Utilisez Agent Sandbox sur les pools de préchauffage GKE pour préprovisionner des volumes vides en arrière-plan.

Définir la ressource SandboxTemplate

Définissez le stockage éphémère dans le bloc volumeClaimTemplate.

  1. Enregistrez le manifeste suivant sous le nom 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
    

Lancer la ressource SandboxWarmPool

  1. Enregistrez le manifeste suivant sous le nom 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. Appliquez les deux fichiers manifestes :

    kubectl apply -f stateless-template.yaml
    kubectl apply -f stateless-warmpool.yaml
    
  3. Attendez que les bacs à sable du pool préprovisionné soient prêts :

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

    Si vous créez une ressource SandboxClaim avant que les bacs à sable du pool ne soient prêts, le contrôleur peut créer un bac à sable pour la revendication au lieu d'en attribuer un à partir du pool. Dans un cluster Autopilot, les bacs à sable peuvent mettre plusieurs minutes à être prêts, car GKE peut avoir besoin de créer des nœuds pour eux.

Créer une ressource SandboxClaim

Définissez une ressource SandboxClaim qui se déclenche lorsqu'un utilisateur démarre une session.

  1. Enregistrez le manifeste suivant sous le nom stateless-sandbox-claim.yaml :

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxClaim
    metadata:
      name: agent-1-claim
    spec:
      warmPoolRef:
        name: stateless-warmpool
    
  2. Appliquez le fichier manifeste :

    kubectl apply -f stateless-sandbox-claim.yaml
    

Vérifier l'exécution en moins d'une seconde

Attendez que la revendication soit prête, capturez le nom du pod Agent Sandbox, puis vérifiez que le répertoire /workspace est installé et prêt à être utilisé immédiatement :

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

Arrêter la session de l'agent

Pour mettre fin à la session de l'agent, supprimez la ressource SandboxClaim. La suppression de la revendication entraîne également la suppression du bac à sable revendiqué et de son volume :

kubectl delete sandboxclaim agent-1-claim

Effectuer un nettoyage des ressources

Supprimez les ressources SandboxWarmPool et SandboxTemplate :

kubectl delete sandboxwarmpool stateless-warmpool
kubectl delete sandboxtemplate stateless-sandbox-template

Configurer avec un démarrage de plusieurs secondes

Pour implémenter un espace de travail éphémère qui tolère une latence de plusieurs secondes, utilisez la création directe d'Agent Sandbox sans pool de préchauffage.

Définir un Agent Sandbox sans état

  1. Enregistrez le manifeste suivant sous le nom 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
    

Déployer Agent Sandbox

Pour provisionner le disque de manière dynamique et l'associer au nœud planifié, appliquez le fichier manifeste :

kubectl apply -f sandbox-direct-stateless.yaml

Vérifier la latence et l'exécution au démarrage

Surveillez l'état du pod pour observer le délai d'association avant que le pod ne passe à l'état Running :

kubectl get pods -w

Lorsque le pod est en cours d'exécution, appuyez sur Ctrl+C pour arrêter la vérification.

Capturez le nom du pod et vérifiez que le répertoire /workspace est disponible :

POD_NAME=sandbox-direct-stateless
kubectl exec ${POD_NAME} -- ls -la /workspace

Arrêter la session de l'agent

Supprimez la ressource Sandbox pour arrêter automatiquement le pod et détruire son stockage éphémère :

kubectl delete sandbox sandbox-direct-stateless

Étapes suivantes