Triton Inference Server

NVIDIA Triton Inference Server ist eine produktionsreife, Open-Source-Inferenzbereitstellungsplattform, die praktisch jedes große ML-Framework unterstützt. Triton wurde für Bereitstellung mit hohem Durchsatz und geringer Latenz entwickelt und unterstützt PyTorch, TensorFlow, ONNX, TensorRT, OpenVINO und mehr — alles aus einem einzigen Serverprozess. Setzen Sie es in der GPU-Cloud von Clore.ai für eine skalierbare, kosteneffiziente Inferenzinfrastruktur ein.

---

Was ist der Triton Inference Server?

Triton ist NVIDIAs Antwort auf die Herausforderung, ML-Modelle in großem Maßstab bereitzustellen:

• Mehrere Frameworks: PyTorch, TensorFlow, TensorRT, ONNX, OpenVINO, benutzerdefinierte Python-Backends

• Parallele Ausführung: Mehrere Modelle, mehrere Instanzen pro GPU

• Dynamisches Batching: Anfragen automatisch zu Batches zusammenfassen für höheren Durchsatz

• gRPC + HTTP: Industrie-Standardprotokolle von Haus aus

• Metriken: Prometheus-kompatibler Metrik-Endpunkt

• Modell-Repository: Dateisystembasiertes Modellmanagement

Verwendete Ports:

Port	Protokoll	Zweck
8000	HTTP	REST-Inferenz-API
8001	gRPC	gRPC-Inferenz-API
8002	HTTP	Prometheus-Metriken

---

Voraussetzungen

Anforderung	Minimum	Empfohlen
GPU-VRAM	8 GB	16–24 GB
GPU	Jede NVIDIA-GPU mit CUDA 11+	RTX 4090 / A100
RAM	16 GB	32 GB
Speicher	20 GB	50 GB

Triton unterstützt auch CPU-only-Inferenz für Workloads ohne CUDA. Verwenden Sie die nur-CPU Variante des Docker-Images, um bei Batch-Jobs ohne GPU-Bedarf Kosten zu sparen.

---

Schritt 1 — Mieten Sie eine GPU auf Clore.ai

1. Melde dich an bei clore.ai.

2. Klicken Sie auf Marktplatz und filtern Sie nach VRAM ≥ 16 GB.

3. Wählen Sie einen Server aus und klicken Sie auf Konfigurieren.

4. Docker-Image festlegen: nvcr.io/nvidia/tritonserver:24.01-py3

   • (Ersetzen Sie 24.01 durch die neueste Version — prüfen Sie den NGC-Katalog)

5. Offene Ports festlegen: 22 (SSH), 8000 (HTTP), 8001 (gRPC), 8002 (Metriken).

6. Klicken Sie auf Mieten.

Triton-Docker-Images sind groß (~15–20 GB). Planen Sie beim ersten Start 3–5 Minuten für das anfängliche Herunterladen ein. Nachfolgende Starts sind schnell.

---

Schritt 2 — Benutzerdefinierte Dockerfile (mit SSH)

Das offizielle Triton-Image enthält keinen SSH-Server. Verwenden Sie dieses 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/*

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

# Python-Clientbibliothek installieren
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

---

Schritt 3 — Das Modell-Repository verstehen

Triton lädt Modelle aus einem Modell-Repository — einem Verzeichnis mit einer bestimmten Struktur:

/models/
├── model_name_1/
│   ├── config.pbtxt          # Modellkonfiguration
│   ├── 1/                    # Version 1
│   │   └── model.pt          # Modelldatei
│   └── 2/                    # Version 2 (optional)
│       └── model.pt
├── model_name_2/
│   ├── config.pbtxt
│   └── 1/
│       └── model.onnx

Jedes Modell benötigt:

1. Ein Verzeichnis mit dem Modellnamen

2. Eine config.pbtxt Konfigurationsdatei

3. Mindestens ein Versions-Unterverzeichnis (z. B. 1/) mit der Modelldatei

---

Schritt 4 — Ein PyTorch-Modell bereitstellen

Modell in TorchScript exportieren

import torch
import torchvision

# Vortrainiertes ResNet50 laden
model = torchvision.models.resnet50(pretrained=True)
model.eval()

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

# Speichern
traced_model.save("/tmp/resnet50.pt")
print("Modell erfolgreich exportiert")

Modell-Repository einrichten

# Per SSH auf Ihre Clore.ai-Instanz zugreifen
ssh root@<clore-host> -p <port>

# Verzeichnisstruktur erstellen
mkdir -p /models/resnet50/1

# Modell hochladen
# (von Ihrem lokalen Rechner)
scp -P <port> /tmp/resnet50.pt root@<clore-host>:/models/resnet50/1/model.pt

config.pbtxt erstellen

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

---

Schritt 5 — Ein ONNX-Modell bereitstellen

In ONNX exportieren

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

ONNX-Konfiguration

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

---

Schritt 6 — Ein benutzerdefiniertes Python-Backend bereitstellen

Für Modelle, die nicht zu standardmäßigen Backends passen (benutzerdefinierte Vorverarbeitung, Ensemble-Logik):

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

---

Schritt 7 — Triton starten und testen

Triton-Server starten

# Start (wenn Sie das Dockerfile-CMD verwenden, startet es automatisch)
tritonserver \
    --model-repository=/models \
    --http-port=8000 \
    --grpc-port=8001 \
    --metrics-port=8002 \
    --log-verbose=0 &

# Warten, bis der Server bereit ist
sleep 5
curl -s http://localhost:8000/v2/health/ready
# Erwartet: {"live": true}

Verfügbare Modelle prüfen

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

Inferenz über HTTP ausführen

import tritonclient.http as httpclient
import numpy as np

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

# Serverzustand prüfen
print("Server bereit:", client.is_server_ready())
print("Modell bereit:", client.is_model_ready("resnet50_onnx"))

# Eingabe erstellen
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)

# Führe Inferenz aus
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"Vorhergesagte Klasse: {predicted_class}")

Inferenz über gRPC ausführen

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"Ausgabeform: {logits.shape}")

---

Monitoring mit Prometheus

Triton stellt Metriken an Port 8002 bereit:

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

Wichtige Metriken:

# Inferenzdurchsatz
nv_inference_request_success{model="resnet50_onnx", version="1"}
# Durchschnittliche Inferenzzeit
nv_inference_compute_infer_duration_us{model="resnet50_onnx", version="1"}
# GPU-Auslastung
nv_gpu_utilization{gpu_uuid="..."}
# GPU-Speicher
nv_gpu_memory_used_bytes{gpu_uuid="..."}

---

Konfiguration für dynamisches Batching

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

---

Fehlerbehebung

Fehler beim Laden des Modells

Modell konnte nicht geladen werden: Modelldatei nicht gefunden

Lösung: Verzeichnisstruktur und Berechtigungen prüfen:

ls -la /models/resnet50/1/
# Muss model.pt (PyTorch) oder model.onnx (ONNX) enthalten
chmod -R 755 /models/

CUDA-Inkompatibilität

Lösung: Passen Sie die Triton-Image-Version an Ihren CUDA-Treiber an:

nvidia-smi  # CUDA-Version notieren
# Verwenden Sie ein passendes tritonserver-Tag, z. B. 23.10 für CUDA 12.2

Port nicht erreichbar

Lösung: Überprüfen Sie, ob alle drei Ports (8000, 8001, 8002) in Clore.ai weitergeleitet sind. Testen Sie jeden:

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

OOM während des Modellladens

Lösung: Reduzieren Sie die Anzahl der Instanzen oder verwenden Sie für einige Modelle CPU-Instanzen:

instance_group [
  {
    count: 1       # Von der Standardeinstellung reduzieren
    kind: KIND_GPU
  }
]

---

Kostenschätzung

GPU	VRAM	Geschätzter Preis	Durchsatz (ResNet50)
RTX 3080	10 GB	$0,05–0,19/Std.	~500 Anfragen/Sek.
RTX 4090	24 GB	ca. 0,14–0,42 $/h	~1500 Anfragen/Sek.
A100 40GB	40 GB	Bare Metal	~3000 Anfragen/Sek.
H100	80 GB	~1,04 $/Std.	~8000 Anfragen/Sek.

---

Nützliche Ressourcen

• Triton GitHub

• NGC-Container-Registry

• Triton-Client-Bibliotheken

• Triton-Referenz zur Modellkonfiguration

• Triton Python Backend

• Triton-Leistungsanalysator

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Produktionsinferenz	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
Große Modelle (70B+)	A100 80GB	Bare Metal

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.