Triton Inference Server

NVIDIA Triton Inference Server est une plateforme d'inférence open-source de qualité production qui prend en charge pratiquement tous les principaux frameworks ML. Conçue pour un service à haut débit et faible latence, Triton gère PyTorch, TensorFlow, ONNX, TensorRT, OpenVINO, et plus encore — le tout depuis un seul processus serveur. Déployez-le sur le cloud GPU de Clore.ai pour une infrastructure d'inférence évolutive et rentable.

---

Qu'est-ce que Triton Inference Server ?

Triton est la réponse de NVIDIA au défi de servir des modèles ML à grande échelle :

• Multi-framework : PyTorch, TensorFlow, TensorRT, ONNX, OpenVINO, backends personnalisés en Python

• Exécution concurrente : Plusieurs modèles, plusieurs instances par GPU

• Regroupement dynamique (dynamic batching) : Regroupe automatiquement les requêtes pour un meilleur débit

• gRPC + HTTP : Protocoles standards du secteur prêts à l'emploi

• Métriques : Point de terminaison de métriques compatible Prometheus

• Répertoire de modèles : Gestion des modèles basée sur le système de fichiers

Ports utilisés :

Port	Protocole	Usage
8000	HTTP	API d'inférence REST
8001	gRPC	API d'inférence gRPC
8002	HTTP	Métriques Prometheus

---

Prérequis

Exigence	Minimum	Recommandé
VRAM GPU	8 Go	16–24 Go
GPU	N'importe quelle NVIDIA avec CUDA 11+	RTX 4090 / A100
RAM	16 Go	32 Go
Stockage	20 Go	50 Go

Triton prend aussi en charge l'inférence CPU uniquement pour les charges non-CUDA. Utilisez la cpu-only variante de l'image Docker pour des économies sur les tâches en lot qui ne nécessitent pas de GPU.

---

Étape 1 — Louez un GPU sur Clore.ai

1. Connectez-vous à clore.ai.

2. Cliquez Place de marché et filtrez par VRAM ≥ 16 Go.

3. Sélectionnez un serveur et cliquez sur Configurer.

4. Définir l'image Docker : nvcr.io/nvidia/tritonserver:24.01-py3

   • (Remplacez 24.01 par la version la plus récente — consultez le catalogue NGC)

5. Définir les ports ouverts : 22 (SSH), 8000 (HTTP), 8001 (gRPC), 8002 (métriques).

6. Cliquez Louez.

Les images Docker Triton sont volumineuses (~15–20 Go). Prévoyez 3–5 minutes pour le premier téléchargement au premier lancement. Les démarrages suivants sont rapides.

---

Étape 2 — Dockerfile personnalisé (avec SSH)

L'image officielle Triton n'inclut pas de serveur SSH. Utilisez ce Dockerfile :

FROM nvcr.io/nvidia/tritonserver:24.01-py3

RUN apt-get update && apt-get install -y \
    openssh-server \
    wget curl \
    && rm -rf /var/lib/apt/lists/*

# Configurer SSH
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Installer la bibliothèque cliente Python
RUN pip install tritonclient[all] numpy Pillow

RUN mkdir -p /models

EXPOSE 22 8000 8001 8002

CMD service ssh start && \
    tritonserver \
        --model-repository=/models \
        --log-verbose=0 \
        --http-port=8000 \
        --grpc-port=8001 \
        --metrics-port=8002

---

Étape 3 — Comprendre le répertoire de modèles

Triton charge les modèles à partir d'un répertoire de modèles — un répertoire avec une structure spécifique :

/models/
├── model_name_1/
│   ├── config.pbtxt          # Configuration du modèle
│   ├── 1/                    # Version 1
│   │   └── model.pt          # Fichier du modèle
│   └── 2/                    # Version 2 (optionnelle)
│       └── model.pt
├── model_name_2/
│   ├── config.pbtxt
│   └── 1/
│       └── model.onnx

Chaque modèle nécessite :

1. Un répertoire portant le nom du modèle

2. Un config.pbtxt fichier de configuration

3. Au moins un sous-répertoire de version (par ex., 1/) contenant le fichier du modèle

---

Étape 4 — Déployer un modèle PyTorch

Exporter le modèle en TorchScript

import torch
import torchvision

# Charger un ResNet50 pré-entraîné
model = torchvision.models.resnet50(pretrained=True)
model.eval()

# Exporter en TorchScript
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Sauvegarder
traced_model.save("/tmp/resnet50.pt")
print("Modèle exporté avec succès")

Configurer le répertoire de modèles

# SSH sur votre instance Clore.ai
ssh root@<clore-host> -p <port>

# Créer la structure de répertoires
mkdir -p /models/resnet50/1

# Télécharger le modèle
# (depuis votre machine locale)
scp -P <port> /tmp/resnet50.pt root@<clore-host>:/models/resnet50/1/model.pt

Créer config.pbtxt

cat > /models/resnet50/config.pbtxt << 'EOF'
name: "resnet50"
platform: "pytorch_libtorch"
max_batch_size: 32

input [
  {
    name: "input__0"
    data_type: TYPE_FP32
    dims: [3, 224, 224]
  }
]

output [
  {
    name: "output__0"
    data_type: TYPE_FP32
    dims: [1000]
  }
]

dynamic_batching {
  preferred_batch_size: [8, 16, 32]
  max_queue_delay_microseconds: 100
}

instance_group [
  {
    count: 2
    kind: KIND_GPU
    gpus: [0]
  }
]
EOF

---

Étape 5 — Déployer un modèle ONNX

Exporter en ONNX

import torch
import torchvision
import torch.onnx

model = torchvision.models.resnet50(pretrained=True)
model.eval()

dummy_input = torch.randn(1, 3, 224, 224)

torch.onnx.export(
    model,
    dummy_input,
    "/tmp/resnet50.onnx",
    opset_version=13,
    input_names=["images"],
    output_names=["logits"],
    dynamic_axes={
        "images": {0: "batch_size"},
        "logits": {0: "batch_size"}
    }
)

Configuration ONNX

mkdir -p /models/resnet50_onnx/1
scp -P <port> /tmp/resnet50.onnx root@<clore-host>:/models/resnet50_onnx/1/model.onnx

cat > /models/resnet50_onnx/config.pbtxt << 'EOF'
name: "resnet50_onnx"
platform: "onnxruntime_onnx"
max_batch_size: 32

input [
  {
    name: "images"
    data_type: TYPE_FP32
    dims: [3, 224, 224]
  }
]

output [
  {
    name: "logits"
    data_type: TYPE_FP32
    dims: [1000]
  }
]

dynamic_batching {
  preferred_batch_size: [8, 16, 32]
  max_queue_delay_microseconds: 100
}
EOF

---

Étape 6 — Déployer un backend Python personnalisé

Pour les modèles qui ne conviennent pas aux backends standards (prétraitement personnalisé, logique d'ensemble) :

mkdir -p /models/custom_model/1

cat > /models/custom_model/1/model.py << 'EOF'
import triton_python_backend_utils as pb_utils
import numpy as np
import torch

class TritonPythonModel:
    def initialize(self, args):
        self.model = torch.nn.Linear(10, 5).cuda()
        self.model.eval()
    
    def execute(self, requests):
        responses = []
        for request in requests:
            input_tensor = pb_utils.get_input_tensor_by_name(request, "INPUT")
            input_np = input_tensor.as_numpy()
            
            with torch.no_grad():
                inp = torch.from_numpy(input_np).float().cuda()
                out = self.model(inp).cpu().numpy()
            
            output_tensor = pb_utils.Tensor("OUTPUT", out.astype(np.float32))
            responses.append(pb_utils.InferenceResponse(output_tensors=[output_tensor]))
        
        return responses
    
    def finalize(self):
        pass
EOF

cat > /models/custom_model/config.pbtxt << 'EOF'
name: "custom_model"
backend: "python"
max_batch_size: 64

input [
  {
    name: "INPUT"
    data_type: TYPE_FP32
    dims: [10]
  }
]

output [
  {
    name: "OUTPUT"
    data_type: TYPE_FP32
    dims: [5]
  }
]
EOF

---

Étape 7 — Démarrer Triton et tester

Démarrer le serveur Triton

# Démarrer (si vous utilisez le CMD du Dockerfile, il démarre automatiquement)
tritonserver \
    --model-repository=/models \
    --http-port=8000 \
    --grpc-port=8001 \
    --metrics-port=8002 \
    --log-verbose=0 &

# Attendre que le serveur soit prêt
sleep 5
curl -s http://localhost:8000/v2/health/ready
# Attendu : {"live": true}

Vérifier les modèles disponibles

curl http://<clore-host>:<public-8000>/v2/models

Exécuter une inférence via HTTP

import tritonclient.http as httpclient
import numpy as np

client = httpclient.InferenceServerClient(
    url="<clore-host>:<public-port-8000>",
    ssl=False
)

# Vérifier la santé du serveur
print("Serveur prêt :", client.is_server_ready())
print("Modèle prêt :", client.is_model_ready("resnet50_onnx"))

# Créer l'entrée
image = np.random.rand(1, 3, 224, 224).astype(np.float32)
input_tensor = httpclient.InferInput("images", image.shape, "FP32")
input_tensor.set_data_from_numpy(image)

# Exécuter l'inférence
outputs = [httpclient.InferRequestedOutput("logits")]
response = client.infer("resnet50_onnx", [input_tensor], outputs=outputs)

logits = response.as_numpy("logits")
predicted_class = np.argmax(logits[0])
print(f"Classe prédite : {predicted_class}")

Exécuter une inférence via gRPC

import tritonclient.grpc as grpcclient
import numpy as np

client = grpcclient.InferenceServerClient(
    url="<clore-host>:<public-port-8001>"
)

image = np.random.rand(1, 3, 224, 224).astype(np.float32)
input_tensor = grpcclient.InferInput("images", image.shape, "FP32")
input_tensor.set_data_from_numpy(image)

outputs = [grpcclient.InferRequestedOutput("logits")]
response = client.infer("resnet50_onnx", [input_tensor], outputs=outputs)

logits = response.as_numpy("logits")
print(f"Forme de la sortie : {logits.shape}")

---

Monitoring avec Prometheus

Triton expose des métriques sur le port 8002 :

curl http://<clore-host>:<public-port-8002>/metrics

Métriques clés :

# Débit d'inférence
nv_inference_request_success{model="resnet50_onnx", version="1"}
# Temps moyen d'inférence
nv_inference_compute_infer_duration_us{model="resnet50_onnx", version="1"}
# Utilisation GPU
nv_gpu_utilization{gpu_uuid="..."}
# Mémoire GPU
nv_gpu_memory_used_bytes{gpu_uuid="..."}

---

Configuration du regroupement dynamique

dynamic_batching {
  preferred_batch_size: [4, 8, 16, 32]
  max_queue_delay_microseconds: 5000
  preserve_ordering: true
  
  priority_levels: 3
  default_priority_level: 2
  default_queue_policy {
    timeout_action: REJECT
    default_timeout_microseconds: 10000
    allow_timeout_override: true
    max_queue_size: 100
  }
}

---

Dépannage

Échec du chargement du modèle

Échec du chargement du modèle : fichier modèle introuvable

Solution : Vérifiez la structure des répertoires et les permissions :

ls -la /models/resnet50/1/
# Doit contenir model.pt (PyTorch) ou model.onnx (ONNX)
chmod -R 755 /models/

Incompatibilité CUDA

Solution : Faites correspondre la version de l'image Triton à votre pilote CUDA :

nvidia-smi  # Notez la version CUDA
# Utilisez le tag tritonserver correspondant, ex. 23.10 pour CUDA 12.2

Port non accessible

Solution : Vérifiez que les trois ports (8000, 8001, 8002) sont bien redirigés sur Clore.ai. Testez chacun :

curl http://<host>:<port>/v2/health/live

OOM lors du chargement du modèle

Solution : Réduisez le nombre d'instances ou utilisez des instances CPU pour certains modèles :

instance_group [
  {
    count: 1       # Réduire par rapport à la valeur par défaut
    kind: KIND_GPU
  }
]

---

Estimation des coûts

GPU	VRAM	Prix estimé	Débit (ResNet50)
RTX 3080	10 Go	~0,10 $/h	~500 req/s
RTX 4090	24 Go	~0,35 $/h	~1500 req/s
A100 40GB	40 Go	~0,80 $/h	~3000 req/s
H100	80 Go	~2,50 $/h	~8000 req/s

---

Ressources utiles

• Triton GitHub

• Registre de conteneurs NGC

• Bibliothèques clientes Triton

• Référence de configuration des modèles Triton

• Backend Python de Triton

• Analyseur de performance Triton

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Inférence en production	RTX 4090 (24GB)	~$0.70/gpu/hr
Grands modèles (70B+)	A100 80GB	~$1.20/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.