Triton Inference Server

Servidor de inferencia NVIDIA Triton es una plataforma de inferencia de código abierto y de nivel de producción que admite prácticamente todos los principales frameworks de ML. Diseñado 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. Despliégalo en la nube de GPU de Clore.ai para 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:

• Multiframework: PyTorch, TensorFlow, TensorRT, ONNX, OpenVINO, backends personalizados en Python

• Ejecución concurrente: Varios modelos, varias instancias por GPU

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

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

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

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

Puertos utilizados:

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

---

Requisitos previos

Requisito	Mínimo	Recomendado
VRAM de 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 solo-CPU variante de la imagen de 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 en Marketplace y filtra por VRAM ≥ 16 GB.

3. Selecciona un servidor y haz clic en Configurar.

4. Establece la imagen de Docker: nvcr.io/nvidia/tritonserver:24.01-py3

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

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

6. Haz clic en Alquilar.

Las imágenes Docker de Triton son grandes (~15–20 GB). Permite 3–5 minutos para la descarga inicial 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 — Comprende el repositorio de modelos

Triton carga los 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 (por ejemplo, 1/) con el archivo del modelo

---

Paso 4 — Despliega un modelo PyTorch

Exportar el modelo a TorchScript

import torch
import torchvision

# Carga 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 correctamente")

Configurar el repositorio de modelos

# Conéctate por SSH a 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 — Despliega 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 de 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 — Despliega un backend personalizado en Python

Para modelos que no encajan en los backends estándar (preprocesamiento personalizado, lógica de 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

---

Paso 7 — Inicia Triton y prueba

Iniciar el servidor Triton

# 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 los 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 el estado 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)

# Ejecuta la 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 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 medio 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 con CUDA

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

nvidia-smi  # Nota la versión de CUDA
# Usa una etiqueta de tritonserver que coincida, por ejemplo, 23.10 para CUDA 12.2

Puerto no accesible

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

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

OOM durante la carga del modelo

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

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

---

Estimación de costos

GPU	VRAM	Precio estimado	Rendimiento (ResNet50)
RTX 3080	10 GB	$0,05–0,19/h	~500 solicitudes/seg
RTX 4090	24 GB	$0.14–0.42/h	~1500 solicitudes/seg
A100 40GB	40 GB	bare metal	~3000 solicitudes/seg
H100	80 GB	~$1.04/h	~8000 solicitudes/seg

---

Recursos útiles

• GitHub de Triton

• Registro de contenedores NGC

• Bibliotecas cliente de Triton

• Referencia de configuración de modelos de Triton

• Backend de Python de Triton

• Analizador de rendimiento de Triton

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Inferencia en producción	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Modelos grandes (70B+)	A100 80GB	bare metal

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