Découpage temporel du GPU pour les agents LLM simultanés sur Kubernetes

Découpage Temporel GPU pour Agents LLM Concurrents sur Kubernetes

Les agents basés sur de grands modèles de langage (LLM) transforment la façon dont les organisations automatisent le raisonnement, la recherche et la prise de décision. Cependant, exécuter plusieurs agents LLM simultanément sur Kubernetes pose un défi fondamental : les GPU sont coûteux, rares et traditionnellement alloués à raison d'un pod par GPU. Le découpage temporel GPU résout ce goulot d'étranglement en permettant à plusieurs charges de travail de partager un seul GPU, améliorant considérablement l'utilisation et réduisant les coûts. Cet article fournit un guide pratique, étape par étape, pour configurer le découpage temporel GPU sur Kubernetes pour des déploiements d'agents LLM concurrents.

Qu'est-ce que le découpage temporel GPU ?

Le découpage temporel GPU est un mécanisme natif de Kubernetes qui divise un seul GPU physique en plusieurs périphériques virtuels. Chaque périphérique virtuel est présenté à un pod comme s'il s'agissait d'un GPU dédié, mais le matériel sous-jacent traite les charges de travail en tranches de temps rapides et circulaires. Cette approche est distincte du partitionnement GPU (MIG), qui isole physiquement la mémoire et le calcul. Le découpage temporel partage les ressources mémoire et de calcul mais introduit une surcharge minimale pour les charges de travail d'inférence, ce qui le rend idéal pour les agents LLM qui passent la plupart de leur temps à attendre des appels réseau ou la génération de tokens.

Le compromis clé est la performance prévisible : si deux pods agents tentent de saturer le GPU simultanément, chacun subira un débit réduit. Pour les agents LLM interactifs avec des modèles d'inférence par à-coups, cependant, le découpage temporel offre souvent une latence quasi-native tout en quadruplant ou plus le nombre d'agents concurrents par GPU.

Prérequis

Avant de mettre en œuvre le découpage temporel GPU, assurez-vous que votre environnement répond à ces prérequis :

• **Cluster Kubernetes** version 1.24 ou ultérieure (testé avec 1.27+)
• **Opérateur GPU NVIDIA** installé (version 23.6.0 ou plus récente recommandée)
• **Pilotes NVIDIA** version 525 ou ultérieure (prenant en charge le découpage temporel)
• **Matériel GPU** : Tout GPU NVIDIA avec capacité de calcul 7.0+ (Volta, Turing, Ampere, Hopper)
• **Framework d'agent LLM** : Tout agent conteneurisé (par exemple, LangChain, LlamaIndex, service Python personnalisé) qui appelle un LLM via API ou modèle local
• **Helm** (pour installer l'opérateur GPU)
• **kubectl** configuré avec les droits d'administration du cluster

> **Remarque** : Le découpage temporel fonctionne mieux pour les charges de travail d'inférence. Pour l'entraînement, utilisez MIG ou des GPU dédiés.

Installation étape par étape

1. Installer l'opérateur GPU NVIDIA

L'opérateur GPU gère les pilotes GPU, les plugins de périphériques et la surveillance. Installez-le via Helm :

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update
helm install gpu-operator nvidia/gpu-operator --namespace nvidia-gpu-operator --create-namespace

Cette commande ajoute le dépôt Helm NVIDIA, met à jour le cache local et installe l'opérateur dans un espace de noms dédié. Attendez que tous les pods soient prêts :

kubectl wait --for=condition=ready pod --all -n nvidia-gpu-operator --timeout=300s

2. Vérifier la détection GPU

Confirmez que le cluster voit vos nœuds GPU :

kubectl get nodes -o json | jq '.items[].status.allocatable | with_entries(select(.key | startswith("nvidia.com/gpu")))'

Vous devriez voir une sortie comme `"nvidia.com/gpu": "1"` pour chaque nœud GPU.

3. Créer une ConfigMap de découpage temporel

Le plugin de périphérique NVIDIA utilise une `ConfigMap` pour définir les profils de découpage temporel. Créez un fichier nommé `time-slicing-config.yaml` :

apiVersion: v1
kind: ConfigMap
metadata:
  name: time-slicing-config
  namespace: nvidia-gpu-operator
data:
  default: |-
    version: v1
    sharing:
      timeSlicing:
        resources:
        - name: nvidia.com/gpu
          replicas: 4

Cette configuration déclare que chaque GPU physique doit apparaître comme 4 GPU virtuels. Ajustez `replicas` en fonction de votre charge de travail (4 à 8 est courant pour les agents LLM).

Appliquez la ConfigMap :

kubectl apply -f time-slicing-config.yaml

4. Configurer la ClusterPolicy pour le découpage temporel

La ressource `ClusterPolicy` de l'opérateur GPU contrôle les paramètres du plugin de périphérique. Patchez-la pour activer le découpage temporel :

kubectl patch clusterpolicy gpu-cluster-policy -n nvidia-gpu-operator --type='json' -p='[{"op": "replace", "path": "/spec/devicePlugin/config", "value": {"name": "time-slicing-config", "default": "default"}}]'

Cela indique au plugin de périphérique d'utiliser la ConfigMap que nous avons créée. Si votre ClusterPolicy a un nom différent (vérifiez avec `kubectl get clusterpolicy -n nvidia-gpu-operator`), ajustez en conséquence.

5. Redémarrer le DaemonSet du plugin de périphérique

Forcez le plugin de périphérique à recharger sa configuration :

kubectl rollout restart daemonset nvidia-device-plugin-daemonset -n nvidia-gpu-operator

Attendez la fin du redémarrage :

kubectl rollout status daemonset nvidia-device-plugin-daemonset -n nvidia-gpu-operator

6. Vérifier les GPU virtuels

Maintenant, chaque nœud GPU devrait signaler plusieurs ressources `nvidia.com/gpu` :

kubectl get nodes -o json | jq '.items[].status.allocatable | with_entries(select(.key | startswith("nvidia.com/gpu")))'

Sortie attendue : `"nvidia.com/gpu": "4"` (ou le nombre de réplicas que vous avez défini).

Exemples d'utilisation

Exemple 1 : Déployer deux pods d'agents LLM concurrents

Créez un déploiement qui demande 1 GPU virtuel par pod :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm-agent
spec:
  replicas: 2
  selector:
    matchLabels:
      app: llm-agent
  template:
    metadata:
      labels:
        app: llm-agent
    spec:
      containers:
      - name: agent
        image: votre-agent-llm:latest
        resources:
          limits:
            nvidia.com/gpu: 1
        env:
        - name: NVIDIA_VISIBLE_DEVICES
          value: "all"

Appliquez le déploiement :

kubectl apply -f llm-agent-deployment.yaml

Les deux pods s'exécuteront sur le même nœud GPU, chacun recevant un GPU virtuel. Vérifiez qu'ils partagent le GPU :

kubectl get pods -o wide | grep llm-agent
kubectl exec <nom-du-pod> -- nvidia-smi

Chaque pod voit un GPU complet dans `nvidia-smi`, mais le pilote assure un découpage temporel équitable.

Exemple 2 : Surveiller l'utilisation GPU avec Prometheus

Installez l'exportateur NVIDIA DCGM pour des métriques en temps réel :

helm install dcgm-exporter nvidia/dcgm-exporter --namespace nvidia-gpu-operator

Transférez le port des métriques :

kubectl port-forward -n nvidia-gpu-operator service/dcgm-exporter 9400:9400 &

Interrogez l'utilisation GPU :

curl http://localhost:9400/metrics | grep -E "DCGM_FI_DEV_GPU_UTIL|DCGM_FI_DEV_MEM_COPY_UTIL"

Vous verrez les valeurs d'utilisation pour le GPU physique, partagées entre tous les pods à découpage temporel.

Exemple 3 : Agent LLM Python utilisant le GPU

Un agent LangChain minimal qui appelle un LLM local (par exemple, Llama 2 via Ollama) pourrait ressembler à ceci :

import os
from langchain.llms import Ollama
from langchain.agents import initialize_agent, Tool
from langchain.tools import tool

@tool
def get_current_time() -> str:
    """Retourne l'heure actuelle."""
    from datetime import datetime
    return datetime.now().isoformat()

llm = Ollama(model="llama2", temperature=0.1)
tools = [get_current_time]
agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)

result = agent.run("Quelle heure est-il ?")
print(result)

Conteneurisez ce script et déployez-le sur Kubernetes avec `nvidia.com/gpu: 1` dans les limites de ressources. La configuration de découpage temporel garantit que plusieurs agents de ce type peuvent coexister sur un seul GPU.

Réglage et bonnes pratiques

Ajuster le nombre de réplicas en fonction de la charge de travail

Pour les agents LLM avec de faibles taux de requêtes (par exemple, 1 à 5 requêtes par minute par agent), 8 réplicas par GPU sont sûrs. Pour les agents à haute fréquence, commencez avec 4 et surveillez l'utilisation GPU :

kubectl exec -n nvidia-gpu-operator daemonset/nvidia-device-plugin-daemonset -- nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv

Si l'utilisation dépasse 90 %, réduisez les réplicas.

Combiner avec l'autoscaler horizontal de pods

Le découpage temporel GPU fonctionne bien avec HPA basé sur des métriques personnalisées. Par exemple, faites évoluer les agents en fonction de l'utilisation moyenne du GPU :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: llm-agent-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: llm-agent
  minReplicas: 1
  maxReplicas: 8
  metrics:
  - type: Pods
    pods:
      metric:
        name: gpu_utilization
      target:
        type: AverageValue
        averageValue: 50

Gérer la contention mémoire

Le découpage temporel partage la mémoire GPU. Si votre modèle LLM nécessite 8 Go, assurez-vous que la mémoire totale de tous les agents concurrents ne dépasse pas la mémoire disponible. Utilisez `nvidia-smi` pour vérifier l'utilisation mémoire et limitez les `replicas` en conséquence.

Conclusion

Le découpage temporel GPU permet aux clusters Kubernetes d'exécuter plusieurs agents LLM simultanément sur un seul GPU, maximisant l'utilisation du matériel et réduisant les coûts d'infrastructure. En suivant les étapes de ce guide—installation de l'opérateur GPU NVIDIA, création d'une ConfigMap de découpage temporel et configuration du plugin de périphérique—vous pouvez transformer un seul GPU en une ressource partagée pour 4 à 8 charges de travail d'inférence concurrentes. Cette approche est particulièrement précieuse pour les systèmes de production servant de nombreux agents LLM interactifs, où les modèles de trafic par à-coups font du découpage temporel une solution efficace et pratique. Comme le soulignent les discussions récentes dans l'industrie provenant de sources comme OpenAI et Microsoft, le partage efficace des GPU est un facteur clé pour des déploiements d'IA évolutifs. Commencez avec 4 réplicas par GPU, surveillez l'utilisation et ajustez en fonction des besoins de concurrence de votre agent. Vos agents LLM—et votre budget—vous remercieront.