Usa volúmenes del agente de Filestore con el sustrato del agente de GKE

Google Kubernetes Engine (GKE) Agent Substrate es una plataforma de infraestructura que administra el ciclo de vida de las zonas de pruebas de agentes de IA con estado. Agent Substrate permite que las plataformas suspendan las cargas de trabajo de los agentes inactivos para ahorrar costos de procesamiento y reanudarlas en menos de un segundo cuando llegan nuevas instrucciones o tareas.

Los volúmenes de agentes de Filestore proporcionan la capa de almacenamiento persistente para Agent Substrate, lo que preserva los archivos del espacio de trabajo, los repositorios de código y los artefactos del bloc de notas en los ciclos de suspensión y reanudación del entorno de pruebas.

Cómo Agent Substrate usa los volúmenes de agentes

En los siguientes pasos, se describe cómo los volúmenes de Agent Substrate y del agente de Filestore admiten un agente de programación interactivo que ayuda a los desarrolladores a compilar funciones, ejecutar pruebas y depurar código:

  1. Inicialización de la sesión: Cuando un desarrollador envía una tarea, Agent Substrate crea un entorno de zona de pruebas en GKE y activa un volumen de Filestore dedicado. El agente clona el repositorio del proyecto, instala las dependencias y prepara el espacio de trabajo.
  2. Suspensión inactiva rentable: Mientras el desarrollador revisa las diferencias de código o crea la siguiente instrucción, Agent Substrate desmonta el volumen y finaliza el entorno de procesamiento. La utilización de recursos de procesamiento se reduce a cero, mientras que todos los archivos del espacio de trabajo, el historial de Git y las memorias caché de compilación permanecen persistentes en el volumen.
  3. Reanudación instantánea: Cuando el desarrollador envía una nueva instrucción, Agent Substrate reclama un entorno de pruebas precalentado y vuelve a adjuntar el volumen existente en menos de 100 ms. El agente reanuda inmediatamente la carga de trabajo con el contexto completo del sistema de archivos intacto, lo que evita la clonación de repositorios o la reinstalación de dependencias que consumen mucho tiempo.

Para obtener más información, consulta la documentación de Agent Substrate.

Para ejecutar cargas de trabajo de agentes con estado en el sustrato de agentes de GKE con volúmenes de agentes de Filestore, debes instalar el sustrato de agentes, configurar la integración del controlador de CSI de Filestore y definir tus cargas de trabajo de agentes para que usen volúmenes de CSI dinámicos.

Instala Agent Substrate

Para preparar tu proyecto de Google Cloud y, luego, instalar Agent Substrate en un clúster de GKE Standard, sigue las instrucciones que se indican en Cómo instalar Agent Substrate en GKE.

Instala y configura el controlador de CSI de Filestore

Para usar volúmenes de agentes de Filestore con Agent Substrate, debes seleccionar el paso opcional Controlador de CSI de Filestore cuando ejecutes el instalador interactivo de Agent Substrate.

El plano de control de Agent Substrate (ateapi) se comunica directamente con el controlador del controlador de CSI de Filestore a través de gRPC de red. El controlador de CSI aprovisiona, adjunta y separa de forma dinámica los volúmenes por actor de tu grupo de volúmenes de Filestore en sincronización con el ciclo de vida de cada actor.

Crea cargas de trabajo que usen volúmenes de Filestore

En Agent Substrate, defines volúmenes externos de Filestore de forma declarativa en un recurso ActorTemplate en lugar de crear objetos PersistentVolumeClaim de Kubernetes separados. En los siguientes pasos, se explica cómo configurar un StorageClass y un CSIDriverConfig de Filestore, implementar un WorkerPool y un ActorTemplate que activen un volumen externo de Filestore y administrar el ciclo de vida del actor.

Crea el StorageClass

Crea un archivo llamado storageclass.yaml para aprovisionar volúmenes dinámicos desde tu grupo de volúmenes de 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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto de Google Cloud .
  • LOCATION: Es la región en la que reside tu grupo de volúmenes, como us-central1.
  • VOLUME_POOL_NAME: Es el nombre de tu grupo de volúmenes de Filestore.

Aplica StorageClass:

kubectl apply -f storageclass.yaml

Registra el CSIDriverConfig

El recurso CSIDriverConfig conecta el aprovisionador de StorageClass de Kubernetes (filestore.csi.storage.gke.io) al extremo de gRPC de red del servicio del controlador de CSI de Filestore y a la ruta de acceso del socket de dominio de Unix local del complemento del nodo de CSI.

Crea un archivo llamado 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

Aplica CSIDriverConfig:

kubectl apply -f csi-driver-config.yaml

Define WorkerPool y ActorTemplate

  1. Crea el espacio de nombres de ate-demo y el espacio de nombres de Kubernetes para que sirvan como límite de aislamiento para tu grupo de trabajadores, plantilla de actor y actores:

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

  2. Crea un recurso WorkerPool para mantener las cargas de trabajo de reserva física listas para alojar zonas de pruebas de actores. Guarda el siguiente manifiesto como 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. Aplica el manifiesto WorkerPool:

    kubectl apply -f worker-pool.yaml

  4. Crea un archivo llamado actor-template.yaml que defina el ActorTemplate que une un volumen de 5 GiB desde 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

    Reemplaza lo siguiente:

    • CONTAINER_IMAGE: Es la imagen del contenedor para la carga de trabajo del agente, como gcr.io/my-project/agent-app@sha256:7f28ab0....
    • SNAPSHOT_BUCKET: Es el bucket de Cloud Storage que usa Agent Substrate para almacenar instantáneas de actores.

    En este manifiesto, volumes[].externalVolumeTemplate especifica la capacidad del volumen solicitada (5Gi) y el StorageClass (substrate-volumepool-sc) cuyo aprovisionador coincide con tu CSIDriverConfig, mientras que containers[].volumeMounts activa ese volumen en /mnt/shared. Cada volumen declarado en volumes debe activarse en al menos un contenedor.

  5. Crea el ActorTemplate a través de la API de Agent Substrate con la CLI de kubectl ate:

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

Cómo crear, suspender y reanudar un actor

Una vez que se crea el ActorTemplate y su instantánea de referencia está lista, puedes crear una instancia de actor y administrar su estado de ejecución:

  1. Crea un actor nuevo a partir de stateful-agent-template:

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

    Reemplaza ACTOR_NAME por un nombre de etiqueta DNS-1123 para tu actor, como my-agent-1.

    Cuando creas el actor, Agent Substrate aprovisiona de forma dinámica un volumen de Filestore dedicado desde substrate-volumepool-sc y lo activa en /mnt/shared.

  2. Suspende el actor cuando esté inactivo:

    kubectl ate suspend actor ACTOR_NAME \
    -a ate-demo

    Cuando se suspende el actor, se guarda el estado de la memoria en Cloud Storage, se desmonta y se desconecta el volumen de Filestore, a la vez que se conservan todos los archivos del espacio de trabajo en el volumen y se libera la carga de trabajo.

  3. Reanuda el actor cuando llega una nueva solicitud o tarea:

    kubectl ate resume actor ACTOR_NAME \
    -a ate-demo

    Cuando se reanuda el actor, se le asigna una carga de trabajo disponible, se restablece su instantánea de memoria y se vuelve a conectar el volumen existente de Filestore en /mnt/shared con todos los archivos intactos.

¿Qué sigue?