Serveur d'inférence Triton

NVIDIA Triton Inference Server est une plateforme de déploiement d'inférence open source de qualité production qui prend en charge pratiquement tous les principaux frameworks de ML. Conçu pour un service à haut débit et à faible latence, Triton gère PyTorch, TensorFlow, ONNX, TensorRT, OpenVINO, et plus encore — le tout à partir d'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 du déploiement de modèles de ML à grande échelle :

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

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

• Batching dynamique : Regroupe automatiquement les requêtes pour un débit plus élevé

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

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

• Dépôt de modèles : Gestion des modèles basée sur le système de fichiers

Ports utilisés :

Port	Protocole	Objectif
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	Toute carte NVIDIA avec CUDA 11+	RTX 4090 / A100
RAM	16 Go	32 Go
Stockage	20 Go	50 Go

Triton prend également en charge l'inférence uniquement CPU pour les charges de travail non CUDA. Utilisez la cpu-only variante de l'image Docker pour réduire les coûts sur les tâches par lots qui ne nécessitent pas de GPU.

---

Étape 1 — Louez un GPU sur Clore.ai

1. Connectez-vous à clore.ai.

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

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

4. Définissez 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éfinissez les ports ouverts : 22 (SSH), 8000 (HTTP), 8001 (gRPC), 8002 (métriques).

6. Cliquez sur Louer.

Les images Docker Triton sont volumineuses (~15–20 Go). Prévoyez 3 à 5 minutes pour le premier téléchargement au lancement initial. 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 dépôt de modèles

Triton charge les modèles depuis un dépôt 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 (facultatif)
│       └── model.pt
├── model_name_2/
│   ├── config.pbtxt
│   └── 1/
│       └── model.onnx

Chaque modèle a besoin de :

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 vers TorchScript

import torch
import torchvision

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

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

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

Configurer le dépôt de modèles

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

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

# Importer 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 vers 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 rentrent pas dans les backends standard (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 la commande CMD du Dockerfile, il se lance 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 l'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 l'état 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 l'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}")

---

Surveillance avec Prometheus

Triton expose les 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 du GPU
nv_gpu_utilization{gpu_uuid="..."}
# Mémoire GPU
nv_gpu_memory_used_bytes{gpu_uuid="..."}

---

Configuration du batching 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 du 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 la balise tritonserver correspondante, par ex. 23.10 pour CUDA 12.2

Port inaccessible

Solution : Vérifiez que les trois ports (8000, 8001, 8002) sont transférés dans 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,05–0,19 $/h	~500 req/sec
RTX 4090	24 Go	0,14–0,42 $/h	~1500 req/sec
A100 40 Go	40 Go	bare metal	~3000 req/sec
H100	80 Go	~1,04 $/h	~8000 req/sec

---

Ressources utiles

• GitHub de Triton

• Registre de conteneurs NGC

• Bibliothèques clientes Triton

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

• Backend Python Triton

• Analyseur de performances Triton

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Inférence en production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grands modèles (70B+)	A100 80 Go	bare metal

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