Skip to content
Learni
Voir tous les tutoriels
IA et Machine Learning

Comment installer et utiliser Triton Inference Server en 2026

12 minBEGINNER
DockerMLOpsMachine LearningTriton Inference ServerNVIDIAONNX
Read in English

Introduction

Triton Inference Server, développé par NVIDIA, est une solution open-source puissante pour déployer et servir des modèles de machine learning en production. Contrairement à des serveurs custom, Triton supporte nativement de multiples frameworks (TensorFlow, PyTorch, ONNX, etc.), optimise l'inférence sur GPU/CPU, et gère le scaling dynamique via Kubernetes ou Docker.

Pourquoi l'utiliser en 2026 ? Avec l'essor de l'IA générative et des pipelines MLOps, Triton excelle dans les environnements hétérogènes : batching automatique, model ensemble, et métriques intégrées. Ce tutoriel beginner vous guide pour un setup complet : générer un modèle ONNX simple (régression linéaire), configurer le repository de modèles, lancer via Docker, et interroger via client Python.

À la fin, vous aurez un serveur d'inférence fonctionnel, prêt pour des apps réelles. Temps estimé : 20 minutes. Pas besoin de GPU – ça marche sur CPU ! (128 mots)

Prérequis

  • Docker installé (version 20+ ; téléchargez ici)
  • Python 3.10+ avec pip
  • Accès internet pour pull images Docker et pip installs
  • 2 Go RAM libre
  • Connaissances basiques en terminal et Python (pas de ML avancé requis)
Exécutez docker --version et python --version pour vérifier.

Créer la structure du projet

setup.sh
#!/bin/bash
mkdir -p triton-tutorial/models/simple_regression/1
cd triton-tutorial

# Installer les dépendances Python
pip install scikit-learn==1.5.1 skl2onnx==1.17.0 onnxruntime==1.19.2 numpy==2.1.1

# Créer un fichier vide pour le modèle (sera généré ensuite)
touch models/simple_regression/1/model.onnx

echo "Structure créée : models/simple_regression/1/ prêt pour config et modèle."

Ce script initialise le dossier projet avec la hiérarchie Triton requise : models///. Il installe les libs pour générer un modèle ONNX via scikit-learn. Évitez les espaces dans les noms de dossiers pour prévenir les erreurs de montage Docker.

Générer le modèle ONNX simple

generate_model.py
import numpy as np
import sklearn
from sklearn.linear_model import LinearRegression
import skl2onnx

# Données d'exemple : y = 2*x + 1
X = np.array([[1.0], [2.0], [3.0], [4.0], [5.0]])
y = np.array([3.0, 5.0, 7.0, 9.0, 11.0])

# Entraîner le modèle
model = LinearRegression()
model.fit(X, y)

# Exporter en ONNX
initial_type = [('input', np.float32, [1])]
onnx_model = skl2onnx.convert_sklearn(model, initial_types=initial_type, target_opset=15)

# Sauvegarder
import os
os.makedirs('models/simple_regression/1', exist_ok=True)
with open('models/simple_regression/1/model.onnx', 'wb') as f:
    skl2onnx.save_model(onnx_model, f)

print('Modèle ONNX généré : y ≈ 2*x + 1')
print('Test local :', model.predict([[6.0]]))  # Devrait ≈13

Ce code crée un modèle de régression linéaire simple (fonction y=2x+1), l'entraîne sur 5 points, et l'exporte en ONNX pour compatibilité Triton. Utilisez target_opset=15 pour la stabilité. Piège : vérifiez les shapes d'input/output car Triton est strict sur les dims.

Configurer le modèle (config.pbtxt)

models/simple_regression/config.pbtxt
name: "simple_regression"
platform: "onnxruntime_onnx"

max_batch_size: 128

input {
  name: "input"
  data_type: TYPE_FP32
  dims: [ 1 ]
}

output {
  name: "variable"
  data_type: TYPE_FP32
  dims: [ 1 ]
}

instance_group [
  {
    count: 1
    kind: KIND_CPU
  }
]

optimization {
  cpu {
    separate: true  # Optimise pour CPU
  }
}

Ce fichier config.pbtxt définit le nom, la plateforme ONNX, les inputs/outputs (shape [1] pour x scalaire), et active le backend CPU. max_batch_size:128 permet le batching. Évitez les mismatches dims : input 'input' FP32 vecteur 1D, output 'variable'.

Lancer le serveur Triton

run_server.sh
#!/bin/bash
cd triton-tutorial

# Pull image Triton (version 2026-compatible, CPU/GPU)
docker pull nvcr.io/nvidia/tritonserver:24.08-py3

# Lancer serveur : expose HTTP gRPC metrics
# Monte le repo modèles

docker run --rm -p 8000:8000 -p 8001:8001 -p 8002:8002 \
  -v $(pwd)/models:/models \
  nvcr.io/nvidia/tritonserver:24.08-py3 \
  tritonserver --model-repository=/models --log-verbose=1

# Ctrl+C pour arrêter. Vérifiez logs : 'Started HTTPService' et 'simple_regression INFERENCE READY'

Ce script pull l'image officielle Triton et lance le serveur avec montage volume pour les modèles. Ports : 8000(HTTP), 8001(gRPC), 8002(métriques). --log-verbose=1 aide debug. Piège : assurez models/ accessible ; sur GPU ajoutez --gpus all et NVIDIA Container Toolkit.

Client Python pour tester l'inférence

test_client.py
import tritonclient.http as httpclient
import numpy as np

# Connexion HTTP au serveur local
triton_client = httpclient.InferenceServerClient(url="localhost:8000")

# Préparer input : x=6.0 → attendu ~13
input_data = np.array([6.0], dtype=np.float32)
input_tensor = httpclient.InferInput("input", [1], "FP32")
input_tensor.set_data_from_numpy(input_data)

output_tensor = httpclient.InferRequestedOutput("variable")

# Inférence
results = triton_client.infer(model_name="simple_regression", inputs=[input_tensor], outputs=[output_tensor])

prediction = results.as_numpy("variable")
print(f"Prédiction pour x=6 : {prediction[0]:.2f} (attendu ~13)")

# Test batch
batch_inputs = np.array([[6.0], [7.0]], dtype=np.float32)
batch_input = httpclient.InferInput("input", [2, 1], "FP32")
batch_input.set_data_from_numpy(batch_inputs)
batch_results = triton_client.infer(model_name="simple_regression", inputs=[batch_input], outputs=[output_tensor])
print(f"Batch : {batch_results.as_numpy('variable')} (attendu ~13,15)")

Ce client utilise tritonclient[http] (pip install tritonclient[all]) pour query HTTP. Input/output match config.pbtxt. Teste single et batch. Piège : installez pip install tritonclient[all]==2.48.0 avant ; vérifiez serveur up avec curl localhost:8000/v2/health/ready.

Vérification et monitoring

Une fois lancé, accédez à http://localhost:8002/metrics pour Prometheus. Testez health : curl http://localhost:8000/v2/health/ready (retourne 200 OK). Logs Docker montrent 'READY'. Échelle avec docker stats ou Kubernetes pour prod.

Bonnes pratiques

  • Versionnez modèles : Utilisez models/mon_modele/v2/ pour updates sans downtime.
  • Sécurisez : Ajoutez --api-timeout 60 --model-control-mode explicit et auth TLS en prod.
  • Optimisez : Activez dynamic_batching dans config.pbtxt pour throughput x10.
  • Multi-modèles : Ajoutez plusieurs dossiers sous models/ pour ensemble IA.
  • CI/CD : Intégrez avec GitHub Actions pour rebuild repo auto.

Erreurs courantes à éviter

  • Dims mismatch : Input shape dans config.pbtxt != client → 'INVALID_ARGUMENT'.
  • Modèle non trouvé : Vérifiez montage volume et nom exact (case-sensitive).
  • Port occupé : Tuez processus sur 8000/8001 ou changez -p 8001:8001.
  • Pas de backend : Pour ONNX, image-py3 suffit ; GPU nécessite CUDA toolkit.

Pour aller plus loin

Maîtrisez Triton avancé : Docs officielles NVIDIA.

Découvrez nos formations Learni sur MLOps et IA pour scaler en Kubernetes avec Triton.

Ressources : GitHub Triton, Exemples NGC.