Utiliser des volumes d'agent Filestore avec GKE Agent Substrate

Google Kubernetes Engine (GKE) Agent Substrate est une plate-forme d'infrastructure qui gère le cycle de vie des bacs à sable d'agents d'IA avec état. Le sous-système d'agent permet aux plates-formes de suspendre les charges de travail des agents inactifs pour réduire les coûts de calcul et de les reprendre en moins d'une seconde lorsque de nouvelles requêtes ou tâches arrivent.

Les volumes de l'agent Filestore fournissent la couche de stockage persistant pour Agent Substrate, en conservant les fichiers de l'espace de travail, les dépôts de code et les artefacts du bloc-notes lors des cycles de suspension et de reprise du bac à sable.

Comment Agent Substrate utilise les volumes d'agents

Les étapes suivantes décrivent comment les volumes d'agent Agent Substrate et Filestore prennent en charge un agent de codage interactif qui aide les développeurs à créer des fonctionnalités, à exécuter des tests et à déboguer du code :

  1. Initialisation de la session : lorsqu'un développeur envoie une tâche, Agent Substrate crée un environnement de bac à sable sur GKE et monte un volume Filestore dédié. L'agent clone le dépôt du projet, installe les dépendances et prépare l'espace de travail.
  2. Suspension inactive économique : pendant que le développeur examine les différences de code ou élabore la prochaine invite, Agent Substrate démonte le volume et met fin à l'environnement de calcul. L'utilisation des ressources de calcul tombe à zéro, tandis que tous les fichiers de l'espace de travail, l'historique Git et les caches de compilation restent persistants dans le volume.
  3. Reprise instantanée : lorsque le développeur envoie une nouvelle invite, Agent Substrate revendique un bac à sable préchauffé et rattache le volume existant en moins de 100 ms. L'agent reprend immédiatement la charge de travail avec le contexte complet du système de fichiers intact, ce qui évite les re-clones de dépôt ou les réinstallations de dépendances qui prennent du temps.

Pour en savoir plus, consultez la documentation sur le substrat de l'agent.

Pour exécuter des charges de travail d'agent avec état sur GKE Agent Substrate avec des volumes d'agent Filestore, vous devez installer Agent Substrate, configurer l'intégration du pilote CSI Filestore et définir vos charges de travail d'agent pour qu'elles utilisent des volumes CSI dynamiques.

Installer Agent Substrate

Pour préparer votre projet Google Cloud et installer Agent Substrate sur un cluster GKE Standard, suivez les instructions de la section Installer Agent Substrate sur GKE.

Installer et configurer le pilote CSI Filestore

Pour utiliser les volumes d'agent Filestore avec Agent Substrate, vous devez sélectionner l'étape facultative Pilote CSI Filestore lorsque vous exécutez le programme d'installation interactif Agent Substrate.

Le plan de contrôle du sous-ensemble d'agents (ateapi) communique directement avec le contrôleur du pilote CSI Filestore via le réseau gRPC. Le pilote CSI provisionne, attache et détache dynamiquement les volumes par acteur de votre pool de volumes Filestore en synchronisation avec le cycle de vie de chaque acteur.

Créer des charges de travail qui utilisent des volumes Filestore

Dans Agent Substrate, vous définissez les volumes Filestore externes de manière déclarative dans une ressource ActorTemplate au lieu de créer des objets PersistentVolumeClaim Kubernetes distincts. Les étapes suivantes vous guident dans la configuration d'un StorageClass et d'un CSIDriverConfig Filestore, le déploiement d'un WorkerPool et d'un ActorTemplate qui installent un volume Filestore externe, et la gestion du cycle de vie de l'acteur.

Créer le StorageClass

Créez un fichier nommé storageclass.yaml pour provisionner des volumes dynamiques à partir de votre pool de volumes Filestore :

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

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet Google Cloud .
  • LOCATION : région où réside votre pool de volumes, par exemple us-central1.
  • VOLUME_POOL_NAME : nom de votre pool de volumes Filestore.

Appliquez la fonctionStorageClass :

kubectl apply -f storageclass.yaml

Enregistrer le CSIDriverConfig

La ressource CSIDriverConfig relie le provisionneur StorageClass Kubernetes (filestore.csi.storage.gke.io) au point de terminaison gRPC réseau du service de contrôleur CSI Filestore et au chemin d'accès au socket de domaine Unix local du plug-in de nœud CSI.

Créez un fichier nommé 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

Appliquez la fonctionCSIDriverConfig :

kubectl apply -f csi-driver-config.yaml

Définir WorkerPool et ActorTemplate

  1. Créez l'espace de noms ate-demo et Kubernetes qui servira de limite d'isolation pour votre pool de nœuds de calcul, votre modèle d'acteur et vos acteurs :

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

  2. Créez une ressource WorkerPool pour que les charges de travail de secours physique soient prêtes à héberger des bacs à sable d'acteurs. Enregistrez le manifeste suivant sous le nom 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. Appliquez le fichier manifeste WorkerPool :

    kubectl apply -f worker-pool.yaml

  4. Créez un fichier nommé actor-template.yaml définissant le ActorTemplate qui monte un volume de 5 Gio à partir de 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

    Remplacez les éléments suivants :

    • CONTAINER_IMAGE : image de conteneur pour la charge de travail de votre agent, par exemple gcr.io/my-project/agent-app@sha256:7f28ab0....
    • SNAPSHOT_BUCKET : bucket Cloud Storage utilisé par Agent Substrate pour stocker les instantanés d'acteur.

    Dans ce fichier manifeste, volumes[].externalVolumeTemplate spécifie la capacité de volume demandée (5Gi) et le StorageClass (substrate-volumepool-sc) dont l'approvisionneur correspond à votre CSIDriverConfig, tandis que containers[].volumeMounts installe ce volume sur /mnt/shared. Chaque volume déclaré dans volumes doit être monté par au moins un conteneur.

  5. Créez ActorTemplate via l'API Agent Substrate à l'aide de la CLI kubectl ate :

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

Créer, suspendre et reprendre un acteur

Une fois le ActorTemplate créé et son instantané de référence prêt, vous pouvez créer une instance d'acteur et gérer son état d'exécution :

  1. Créez un acteur à partir de stateful-agent-template :

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

    Remplacez ACTOR_NAME par un nom de libellé DNS-1123 pour votre acteur, tel que my-agent-1.

    Lorsque vous créez l'acteur, Agent Substrate provisionne dynamiquement un volume Filestore dédié à partir de substrate-volumepool-sc et le monte sur /mnt/shared.

  2. Suspendre l'acteur lorsqu'il devient inactif :

    kubectl ate suspend actor ACTOR_NAME \
    -a ate-demo

    La suspension de l'acteur vérifie l'état de sa mémoire dans Cloud Storage, démonte et détache le volume Filestore tout en conservant tous les fichiers de l'espace de travail sur le volume, et libère la charge de travail.

  3. Reprenez l'acteur lorsqu'une nouvelle requête ou tâche arrive :

    kubectl ate resume actor ACTOR_NAME \
    -a ate-demo

    La reprise de l'acteur l'attribue à une charge de travail disponible, restaure son instantané mémoire et rattache le volume Filestore existant à /mnt/shared avec tous les fichiers intacts.

Étapes suivantes