Triton Inference Server

NVIDIA Triton Inference Server es una plataforma de servicio de inferencia de código abierto y nivel de producción que admite prácticamente todos los principales marcos de ML. Diseñada para servir con alto rendimiento y baja latencia, Triton maneja PyTorch, TensorFlow, ONNX, TensorRT, OpenVINO y más — todo desde un único proceso de servidor. Desplégalo en la nube con GPU de Clore.ai para obtener una infraestructura de inferencia escalable y rentable.

---

¿Qué es Triton Inference Server?

Triton es la respuesta de NVIDIA al desafío de servir modelos de ML a escala:

• Multi-framework: PyTorch, TensorFlow, TensorRT, ONNX, OpenVINO, backends personalizados en Python

• Ejecución concurrente: Múltiples modelos, múltiples instancias por GPU

• Batching dinámico: Agrupa automáticamente las solicitudes para un mayor rendimiento

• gRPC + HTTP: Protocolos estándar de la industria listos para usar

• Métricas: Punto de métricas compatible con Prometheus

• Repositorio de modelos: Gestión de modelos basada en el sistema de archivos

Puertos usados:

Puerto	Protocolo	Propósito
8000	HTTP	API de inferencia REST
8001	gRPC	API de inferencia gRPC
8002	HTTP	Métricas de Prometheus

---

Prerrequisitos

Requisito	Mínimo	Recomendado
VRAM GPU	8 GB	16–24 GB
GPU	Cualquier NVIDIA con CUDA 11+	RTX 4090 / A100
RAM	16 GB	32 GB
Almacenamiento	20 GB	50 GB

Triton también admite inferencia solo en CPU para cargas de trabajo que no usan CUDA. Usa la variant variante de la imagen Docker para ahorrar costos en trabajos por lotes que no requieren GPU.

---

Paso 1 — Alquila una GPU en Clore.ai

1. Inicia sesión en clore.ai.

2. Haz clic Marketplace y filtra por VRAM ≥ 16 GB.

3. Selecciona un servidor y haz clic en Configurar.

4. Establecer imagen Docker: nvcr.io/nvidia/tritonserver:24.01-py3

   • (Reemplaza 24.01 con la versión más reciente — consulta catálogo NGC)

5. Establecer puertos abiertos: 22 (SSH), 8000 (HTTP), 8001 (gRPC), 8002 (métricas).

6. Haz clic Alquilar.

Las imágenes Docker de Triton son grandes (~15–20 GB). Permite 3–5 minutos para la primera descarga en el primer inicio. Los inicios posteriores son rápidos.

---

Paso 2 — Dockerfile personalizado (con SSH)

La imagen oficial de Triton no incluye un servidor SSH. Usa este 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/*

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

# Instalar la biblioteca cliente de 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

---

Paso 3 — Entender el Repositorio de Modelos

Triton carga modelos desde un repositorio de modelos — un directorio con una estructura específica:

/models/
├── model_name_1/
│   ├── config.pbtxt          # Configuración del modelo
│   ├── 1/                    # Versión 1
│   │   └── model.pt          # Archivo del modelo
│   └── 2/                    # Versión 2 (opcional)
│       └── model.pt
├── model_name_2/
│   ├── config.pbtxt
│   └── 1/
│       └── model.onnx

Cada modelo necesita:

1. Un directorio con el nombre del modelo

2. Un config.pbtxt archivo de configuración

3. Al menos un subdirectorio de versión (p. ej., 1/) con el archivo del modelo

---

Paso 4 — Desplegar un Modelo PyTorch

Exportar el modelo a TorchScript

import torch
import torchvision

# Cargar un ResNet50 preentrenado
model = torchvision.models.resnet50(pretrained=True)
model.eval()

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

# Guardar
traced_model.save("/tmp/resnet50.pt")
print("Modelo exportado con éxito")

Configurar el Repositorio de Modelos

# SSH en tu instancia de Clore.ai
ssh root@<clore-host> -p <port>

# Crear la estructura de directorios
mkdir -p /models/resnet50/1

# Subir el modelo
# (desde tu máquina local)
scp -P <port> /tmp/resnet50.pt root@<clore-host>:/models/resnet50/1/model.pt

Crear 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

---

Paso 5 — Desplegar un Modelo ONNX

Exportar a 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"}
    }
)

Configuración 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

---

Paso 6 — Desplegar un Backend Personalizado en Python

Para modelos que no encajan en backends estándar (preprocesamiento personalizado, lógica de ensamble):

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

---

Paso 7 — Iniciar Triton y Probar

Iniciar Triton Server

# Iniciar (si usas el CMD del Dockerfile, se inicia automáticamente)
tritonserver \
    --model-repository=/models \
    --http-port=8000 \
    --grpc-port=8001 \
    --metrics-port=8002 \
    --log-verbose=0 &

# Esperar a que el servidor esté listo
sleep 5
curl -s http://localhost:8000/v2/health/ready
# Esperado: {"live": true}

Comprobar modelos disponibles

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

Ejecutar inferencia vía HTTP

import tritonclient.http as httpclient
import numpy as np

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

# Comprobar la salud del servidor
print("Servidor listo:", client.is_server_ready())
print("Modelo listo:", client.is_model_ready("resnet50_onnx"))

# Crear entrada
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)

# Ejecutar inferencia
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"Clase predicha: {predicted_class}")

Ejecutar inferencia vía 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"Forma de la salida: {logits.shape}")

---

Monitorización con Prometheus

Triton expone métricas en el puerto 8002:

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

Métricas clave:

# Rendimiento de inferencia
nv_inference_request_success{model="resnet50_onnx", version="1"}
# Tiempo promedio de inferencia
nv_inference_compute_infer_duration_us{model="resnet50_onnx", version="1"}
# Utilización de la GPU
nv_gpu_utilization{gpu_uuid="..."}
# Memoria de la GPU
nv_gpu_memory_used_bytes{gpu_uuid="..."}

---

Configuración de Batching Dinámico

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
  }
}

---

Solución de problemas

Fallo al Cargar el Modelo

Error al cargar el modelo: no se pudo encontrar el archivo del modelo

Solución: Comprueba la estructura de directorios y los permisos:

ls -la /models/resnet50/1/
# Debe contener model.pt (PyTorch) o model.onnx (ONNX)
chmod -R 755 /models/

Incompatibilidad de CUDA

Solución: Haz coincidir la versión de la imagen Triton con tu controlador CUDA:

nvidia-smi  # Anota la versión de CUDA
# Usa la etiqueta de tritonserver correspondiente, p. ej., 23.10 para CUDA 12.2

Puerto No Alcanzable

Solución: Verifica que los tres puertos (8000, 8001, 8002) estén reenviados en Clore.ai. Prueba cada uno:

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

OOM Durante la Carga del Modelo

Solución: Reduce el conteo de instancias o usa instancias CPU para algunos modelos:

instance_group [
  {
    count: 1       # Reducir desde el valor por defecto
    kind: KIND_GPU
  }
]

---

Estimación de Costos

GPU	VRAM	Precio estimado	Rendimiento (ResNet50)
RTX 3080	10 GB	~$0.10/hr	~500 req/sec
RTX 4090	24 GB	~$0.35/hr	~1500 req/sec
A100 40GB	40 GB	~$0.80/hr	~3000 req/sec
H100	80 GB	~$2.50/hr	~8000 req/sec

---

Recursos Útiles

• Triton GitHub

• Registro de Contenedores NGC

• Bibliotecas Cliente de Triton

• Referencia de Configuración de Modelos de Triton

• Backend Python de Triton

• Analizador de Rendimiento de Triton

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Inferencia en Producción	RTX 4090 (24GB)	~$0.70/gpu/hr
Modelos grandes (70B+)	A100 80GB	~$1.20/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.