Kaito

Kaito (Kubernetes AI Toolchain Operator) est un opérateur Kubernetes open source développé par Microsoft et intégré à la CNCF Sandbox en 2024. Il simplifie le déploiement de grands modèles de langage (LLM) et de modèles d'inférence AI sur des clusters Kubernetes avec GPU, via une abstraction déclarative : la ressource Workspace.

Idéal pour : déploiement d'inférence LLM sur Kubernetes, clusters AKS ou on-prem avec GPU, fine-tuning LoRA/QLoRA, équipes ML sans expertise infrastructure Kubernetes.

Informations essentielles

Origine : Microsoft (Azure) → CNCF Sandbox (2024)  ·  Licence : MIT  ·  Architectures : x86_64, ARM64

Liens : GitHub  ·  Documentation  ·  Presets (modèles)  ·  Releases

Support : Projet CNCF Sandbox en développement actif. Consulter les release notes avant toute mise à jour.

Stack par défaut

Concepts clés

Workspace

La ressource Workspace est l'abstraction centrale de Kaito. Elle décrit :

• quel modèle déployer (inference.preset.name)
• sur quels nœuds GPU (resource.instanceType pour le provisioning auto, ou resource.labelSelector pour des nœuds existants)
• en inférence ou en fine-tuning (spec.inference vs spec.tuning)

Kaito crée automatiquement un Deployment et un Service pour le modèle. Si le GPU provisioner est actif, il crée également un NodeClaim pour provisionner les nœuds manquants.

Modèles pré-intégrés (presets)

Kaito embarque des images Docker pré-construites avec les poids des modèles. Aucun téléchargement manuel ni script d'initialisation requis.

Liste complète et exigences GPU par modèle (VRAM minimale) : github.com/kaito-project/kaito/tree/main/presets

GPU provisioner

Le kaito-gpu-provisioner s'intègre avec Karpenter pour provisionner automatiquement des nœuds GPU dans le cloud (AKS en natif, autres clouds via configuration Karpenter). Sans provisioner, Kaito utilise les nœuds GPU existants dans le cluster en ciblant leurs labels via labelSelector.

Prérequis

• Kubernetes ≥ 1.24
• Helm ≥ 3.0
• Nœuds GPU avec NVIDIA GPU Operator ou device plugin installé
• Accès au registry Microsoft Container Registry (mcr.microsoft.com) pour les images de modèles
• Pour le provisioning automatique : Karpenter + credentials cloud

Installation

Workspace controller

helm repo add kaito https://azure.github.io/kaito
helm repo update

helm install kaito-workspace kaito/kaito-workspace \
  -n kaito-workspace --create-namespace

Vérifier l'installation

# Pods du controller
kubectl get pods -n kaito-workspace

# CRDs installés
kubectl get crd | grep kaito

GPU Provisioner (optionnel - Azure AKS)

helm install kaito-gpu-provisioner kaito/kaito-gpu-provisioner \
  -n kaito-workspace \
  --set settings.azure.subscriptionId=<subscription-id> \
  --set settings.azure.resourceGroup=<resource-group> \
  --set settings.azure.location=<region>

Sans GPU provisioner, s'assurer que les nœuds GPU portent les labels ciblés dans resource.labelSelector.

Déployer un modèle

Avec des nœuds GPU existants

# workspace-phi3.yaml
apiVersion: kaito.sh/v1alpha1
kind: Workspace
metadata:
  name: workspace-phi3
spec:
  resource:
    labelSelector:
      matchLabels:
        accelerator: nvidia-gpu   # label des nœuds GPU existants
  inference:
    preset:
      name: phi-3-mini-128k-instruct

kubectl apply -f workspace-phi3.yaml

# Suivre le déploiement (Pending → Provisioning → Running)
kubectl get workspace workspace-phi3 -w

La colonne INFERENCEREADY passe à True quand le modèle est prêt à recevoir des requêtes.

Avec provisioning automatique (AKS + GPU provisioner)

apiVersion: kaito.sh/v1alpha1
kind: Workspace
metadata:
  name: workspace-llama3
spec:
  resource:
    instanceType: "Standard_NC6s_v3"   # SKU Azure VM avec GPU
    labelSelector:
      matchLabels:
        app: llama3
  inference:
    preset:
      name: llama-3.1-8b-instruct

Kaito provisionne automatiquement un nœud Standard_NC6s_v3 si aucun nœud GPU disponible ne correspond au labelSelector.

Accéder au modèle

Kaito crée un Service ClusterIP pour chaque Workspace.

# Vérifier le service
kubectl get svc workspace-phi3-service

# Port-forward pour test local
kubectl port-forward svc/workspace-phi3-service 8080:80

API d'inférence

# Chat (modèles instruct)
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "phi-3-mini-128k-instruct",
    "messages": [{"role": "user", "content": "Explique Kubernetes en 3 phrases."}],
    "max_tokens": 200
  }'

# Completion (modèles de base)
curl http://localhost:8080/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "phi-3-mini-128k-instruct",
    "prompt": "Kubernetes est",
    "max_tokens": 100
  }'

L'API est compatible OpenAI pour la plupart des modèles instruct. Vérifier le endpoint exact dans la documentation du preset concerné.

Fine-tuning (LoRA / QLoRA)

# workspace-finetune.yaml
apiVersion: kaito.sh/v1alpha1
kind: Workspace
metadata:
  name: finetune-phi3
spec:
  resource:
    instanceType: "Standard_NC6s_v3"
    labelSelector:
      matchLabels:
        app: finetune-phi3
  tuning:
    preset:
      name: phi-3-mini-128k-instruct
    method: qlora
    input:
      volume:
      - name: training-data
        persistentVolumeClaim:
          claimName: training-data-pvc
    output:
      volume:
      - name: model-output
        persistentVolumeClaim:
          claimName: model-output-pvc

kubectl apply -f workspace-finetune.yaml
kubectl get workspace finetune-phi3 -w

Les données d'entraînement doivent être au format JSONL dans le PVC training-data-pvc. Le modèle fine-tuné est écrit dans model-output-pvc.

Mise à jour

helm repo update

# Vérifier la version installée
helm list -n kaito-workspace

# Mettre à jour
helm upgrade kaito-workspace kaito/kaito-workspace -n kaito-workspace

Comme pour tout opérateur Kubernetes, vérifier les release notes avant de mettre à jour : les CRDs peuvent évoluer entre versions.

Troubleshooting

Workspace bloqué en Pending

# Statut détaillé et conditions
kubectl describe workspace <nom>

# Événements récents
kubectl get events --sort-by='.lastTimestamp'

# Nœuds GPU disponibles et leur capacité VRAM
kubectl get nodes -o custom-columns="NAME:.metadata.name,GPU:.status.allocatable.nvidia\.com/gpu"

Pod du modèle en erreur

# Trouver le pod créé par le Workspace
kubectl get pods -l kaito.sh/workspace=<nom-workspace>

# Logs du pod (chargement du modèle en cours ou erreur)
kubectl logs -l kaito.sh/workspace=<nom-workspace> --tail=100

# OOM GPU (VRAM insuffisante) - choisir un preset plus petit ou un nœud avec plus de VRAM
kubectl describe pod <nom-pod> | grep -A5 "OOMKilled\|Reason"

GPU Operator non détecté

# Vérifier le GPU Operator
kubectl get pods -n gpu-operator

# Vérifier que les nœuds exposent les ressources GPU
kubectl describe node <nom-nœud-gpu> | grep -A5 "Allocatable"

Commandes utiles

# Lister tous les Workspaces
kubectl get workspace -A

# Statut détaillé (RESOURCEREADY, INFERENCEREADY, WORKSPACEREADY)
kubectl get workspace -o wide

# Pod du modèle en cours d'exécution
kubectl get pods -l kaito.sh/workspace=<nom>

# Logs du controller Kaito
kubectl logs -n kaito-workspace -l app=kaito-workspace --tail=100

# Supprimer un Workspace (arrête le modèle et libère les ressources)
kubectl delete workspace <nom>

Ressources

• GitHub : https://github.com/kaito-project/kaito
• Documentation : https://github.com/kaito-project/kaito/tree/main/docs
• Presets (modèles supportés) : https://github.com/kaito-project/kaito/tree/main/presets
• Releases : https://github.com/kaito-project/kaito/releases
• CNCF : https://www.cncf.io/projects/kaito/