Мир искусственного интеллекта в 2026 году напоминает Kubernetes-кластер после пятницы релиза: всё горит, масштабируется, жужжит видеокартами и требует "ещё чуть-чуть VRAM".
Модели становятся больше, запросов больше, GPU дороже, а разработчики всё ещё иногда запускают inference через Flask + torch.load() внутри одного контейнера.

И вот тут на сцену выходит NVIDIA Triton Inference Server.

Это не просто "сервер для моделей". Это полноценная промышленная платформа для запуска inference-нагрузки:

  • TensorRT

  • ONNX

  • PyTorch

  • TensorFlow

  • Python backend

  • ансамбли моделей

  • batching

  • GPU scheduling

  • streaming

  • Kubernetes

  • multi-model serving

  • горячая загрузка моделей

И всё это с ощущением, будто NVIDIA однажды посмотрела на хаос ML production и сказала:

"Ладно. Давайте уже сделаем это нормально. Надоел этот цирк с понями!"

Что вообще такое Triton Inference Server

Если очень грубо:

Triton - это nginx для нейросетей.

Только вместо HTML:

  • тензоры

  • CUDA

  • batching

  • gRPC

  • inference pipeline

  • GPU memory management

Он умеет:

  • загружать модели

  • автоматически их обновлять

  • распределять нагрузку

  • делать batching запросов

  • использовать GPU эффективно

  • отдавать inference через HTTP/gRPC

И самое главное:

Triton превращает зоопарк моделей в нормальный production runtime.

Почему все начинают использовать Triton

До Triton инфраструктура ML выглядела так:

python server.py

А внутри:

  • Flask

  • torch.load()

  • multiprocessing

  • костыли

  • ручной batching

  • CUDA out of memory

  • "почему GPU загружен на 12%?"

  • "кто опять убил контейнер"

С Triton появляется:

  • нормальный inference lifecycle

  • модельный репозиторий

  • health checks

  • metrics

  • Prometheus

  • GPU telemetry

  • Kubernetes scaling

  • model versioning

Архитектура Triton

У Triton простая архитектура.

Client
   |
HTTP/gRPC
   |
Triton Server
   |
Model Repository
   |
Backend
   |
GPU/CPU

Backends:

  • TensorRT

  • ONNX Runtime

  • PyTorch

  • TensorFlow

  • Python

  • OpenVINO

  • FIL

  • vLLM backend

  • TensorRT-LLM

Установка Triton через Docker

Самый нормальный путь.

Проверяем NVIDIA runtime

На сервере должны быть:

  • Docker

  • NVIDIA Driver

  • NVIDIA Container Toolkit

Проверяем GPU:

nvidia-smi

Если всё хорошо:

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 575.xx                                                           |
+-----------------------------------------------------------------------------+

Установка NVIDIA Container Toolkit

Для Ubuntu:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt update
sudo apt install -y nvidia-container-toolkit

Перезапускаем Docker:

sudo systemctl restart docker

Первый запуск Triton

docker run --gpus=all --rm -it \
-p 8000:8000 \
-p 8001:8001 \
-p 8002:8002 \
nvcr.io/nvidia/tritonserver:25.04-py3 \
tritonserver --model-repository=/models

Порты:

  • 8000 - HTTP API

  • 8001 - gRPC

  • 8002 - Prometheus metrics

И вот тут начинается магия production AI.

Структура model repository

Triton живёт вокруг model repository.

Пример:

models/
└── sentiment_model/
    ├── config.pbtxt
    └── 1/
        └── model.onnx

Где:

  • sentiment_model - имя модели

  • 1 - версия модели

  • config.pbtxt - конфигурация

Запускаем ONNX модель

Конвертация модели

Допустим у нас есть PyTorch модель.

torch.onnx.export(
    model,
    dummy_input,
    "model.onnx",
    input_names=["input"],
    output_names=["output"]
)

config.pbtxt

Вот сердце Triton.

name: "sentiment_model"

platform: "onnxruntime_onnx"

max_batch_size: 32

input [
  {
    name: "input"
    data_type: TYPE_FP32
    dims: [768]
  }
]

output [
  {
    name: "output"
    data_type: TYPE_FP32
    dims: [2]
  }
]

instance_group [
  {
    kind: KIND_GPU
    count: 1
  }
]

Запуск сервера

docker run --gpus=all --rm \
-p8000:8000 \
-v $(pwd)/models:/models \
nvcr.io/nvidia/tritonserver:25.04-py3 \
tritonserver --model-repository=/models

Проверяем что сервер жив

curl localhost:8000/v2/health/ready

Ответ:

OK

Иногда это самый приятный "OK" за всю неделю.

Список моделей

curl localhost:8000/v2/models

Делаем inference

Python клиент

Устанавливаем:

pip install tritonclient[http]

Пример запроса

import numpy as np
import tritonclient.http as httpclient

client = httpclient.InferenceServerClient(
    url="localhost:8000"
)

input_data = np.random.rand(1, 768).astype(np.float32)

inputs = []

infer_input = httpclient.InferInput(
    "input",
    input_data.shape,
    "FP32"
)

infer_input.set_data_from_numpy(input_data)

inputs.append(infer_input)

outputs = [
    httpclient.InferRequestedOutput("output")
]

result = client.infer(
    model_name="sentiment_model",
    inputs=inputs,
    outputs=outputs
)

print(result.as_numpy("output"))

Dynamic batching - та самая магия производительности

Вот где Triton начинает окупать GPU.

Обычный inference:

  • 1 запрос

  • 1 GPU execution

  • куча простаивания

Triton умеет:

  • собирать запросы

  • объединять в batch

  • запускать пачкой

GPU начинает работать как GPU, а не как дорогой RGB-обогреватель.

Настройка batching

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

Что это даёт

Без batching:

GPU utilization: 15%

С batching:

GPU utilization: 90%

Финансовый директор внезапно перестаёт смотреть на тебя как на человека, который арендует суперкомпьютер ради калькулятора.

TensorRT backend

Если ONNX - это хорошо, то TensorRT - это "мы хотим squeeze every last FLOP из GPU".

TensorRT:

  • оптимизирует граф

  • делает kernel fusion

  • уменьшает latency

  • ускоряет inference

Иногда:

  • x2

  • x5

  • x10 ускорение

Конвертация в TensorRT

trtexec \
--onnx=model.onnx \
--saveEngine=model.plan

Конфиг TensorRT

platform: "tensorrt_plan"

Всё. Иногда production optimization выглядит подозрительно просто.

Python backend

Вот это уже очень интересно. Triton умеет запускать Python-код как backend.

То есть:

  • preprocessing

  • postprocessing

  • custom logic

  • tokenizer

  • бизнес-логика

Можно делать прямо внутри Triton.

Структура Python backend

models/
└── tokenizer/
    ├── config.pbtxt
    └── 1/
        └── model.py

model.py

import numpy as np
import triton_python_backend_utils as pb_utils

class TritonPythonModel:

    def initialize(self, args):
        print("Model initialized")

    def execute(self, requests):

        responses = []

        for request in requests:

            input_tensor = pb_utils.get_input_tensor_by_name(
                request,
                "text"
            )

            data = input_tensor.as_numpy()

            result = np.array([len(x) for x in data])

            output_tensor = pb_utils.Tensor(
                "length",
                result.astype(np.int32)
            )

            responses.append(
                pb_utils.InferenceResponse(
                    output_tensors=[output_tensor]
                )
            )

        return responses

Ensemble models

Вот тут Triton начинает напоминать mini-Kubeflow.

Можно собирать pipeline:

Tokenizer
   ↓
Embedding
   ↓
LLM
   ↓
Postprocess

И всё это будет одним inference endpoint.

Пример ensemble

ensemble_scheduling {
  step [
    {
      model_name: "tokenizer"
      model_version: -1
    },
    {
      model_name: "llm"
      model_version: -1
    }
  ]
}

Triton + Kubernetes

Ну и конечно самое вкусное. Triton идеально живёт в Kubernetes.

Особенно если:

  • много GPU

  • много моделей

  • autoscaling

  • multi-tenant AI platform

Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: triton
spec:
  replicas: 1

  selector:
    matchLabels:
      app: triton

  template:
    metadata:
      labels:
        app: triton

    spec:
      containers:
      - name: triton

        image: nvcr.io/nvidia/tritonserver:25.04-py3

        args:
          - tritonserver
          - --model-repository=/models

        ports:
        - containerPort: 8000
        - containerPort: 8001
        - containerPort: 8002

        resources:
          limits:
            nvidia.com/gpu: 1

        volumeMounts:
        - name: models
          mountPath: /models

      volumes:
      - name: models
        persistentVolumeClaim:
          claimName: triton-models

Service

apiVersion: v1
kind: Service
metadata:
  name: triton
spec:
  selector:
    app: triton

  ports:
  - name: http
    port: 8000

  - name: grpc
    port: 8001

  - name: metrics
    port: 8002

GPU Operator

В Kubernetes почти всегда используют:

  • NVIDIA GPU Operator

  • Node Feature Discovery

  • DCGM Exporter

Без этого Kubernetes с GPU быстро превращается в шаманизм.

Метрики и мониторинг

Triton умеет:

  • Prometheus metrics

  • GPU telemetry

  • latency

  • queue time

  • batch stats

  • model load time

Метрики:

curl localhost:8002/metrics

Пример метрик

nv_inference_request_success
nv_inference_queue_duration_us
nv_gpu_utilization
nv_inference_execution_count

И вот тут DevOps-инженер начинает чувствовать себя дома.

Horizontal scaling

Обычная схема:

Ingress
   ↓
Service
   ↓
Triton Pods

Можно:

  • масштабировать pod'ы

  • разделять модели

  • делать model sharding

  • использовать MIG

MIG - Multi Instance GPU

Это когда один GPU режется на части.

Например:

H100
 ├── 10GB
 ├── 10GB
 ├── 20GB

И Kubernetes видит это как разные GPU.

В multi-tenant окружениях это буквально спасение бюджета.

Triton и большие языковые модели

В 2026 году большинство ставит Triton ради:

  • Llama

  • DeepSeek

  • Qwen

  • Mistral

  • Gemma

Особенно вместе с:

  • TensorRT-LLM

  • vLLM

  • KV cache

  • paged attention

Triton + vLLM

Сейчас это одна из самых популярных схем.

Почему:

  • Triton даёт production infrastructure

  • vLLM даёт быстрый inference LLM

Получается:

  • batching

  • streaming

  • token scheduling

  • API gateway

  • metrics

  • scaling

Пример docker-compose

version: "3.9"

services:

  triton:
    image: nvcr.io/nvidia/tritonserver:25.04-py3

    command:
      - tritonserver
      - --model-repository=/models

    ports:
      - "8000:8000"
      - "8001:8001"
      - "8002:8002"

    volumes:
      - ./models:/models

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: [gpu]

Частые проблемы

CUDA mismatch

Самая популярная.

CUDA driver version is insufficient

Потому что:

  • драйвер старый

  • контейнер новый

  • NVIDIA как обычно решила "слегка обновить совместимость"

OOM

CUDA out of memory

Лечится:

  • batching tuning

  • fp16

  • quantization

  • TensorRT

  • MIG

  • уменьшением context window

Медленный inference

Почти всегда:

  • batching выключен

  • CPU preprocessing

  • маленькие batch size

  • PCIe bottleneck

  • tokenizer тормозит

Когда Triton не нужен

Иногда люди пытаются запускать Triton:

  • для одной модели

  • с 5 запросами в день

  • на CPU

  • на VPS за 10 евро

Это как ставить Kubernetes ради nginx и котика на главной странице.

Когда Triton действительно раскрывается

Triton великолепен если:

  • много inference

  • дорогие GPU

  • high load

  • LLM

  • Kubernetes

  • multi-model serving

  • latency optimization

Плюсы Triton

Очень высокая производительность

Triton реально умеет загружать GPU эффективно.

Production-ready

Не "pet project ready".

А именно:

  • enterprise

  • observability

  • scaling

  • monitoring

  • HA

Огромное количество backend'ов

Можно запускать почти всё.

Dynamic batching

Это killer feature.

Kubernetes friendly

NVIDIA явно проектировала его под k8s.

Минусы Triton

Сложность

Triton - не игрушка. Иногда config.pbtxt напоминает древний ритуал вызова CUDA-демона.

Документация NVIDIA

Она:

  • огромная

  • местами прекрасная

  • местами как будто написана видеокартой

Отладка

Иногда inference pipeline дебажится через:

  • логи

  • молитвы

  • nvidia-smi

  • "а давайте перезапустим pod"

Итог

NVIDIA Triton Inference Server сегодня - это практически стандарт де-факто для серьёзного AI inference в инфраструктуре.

Особенно если у вас:

  • Kubernetes

  • GPU-кластеры

  • LLM

  • production-нагрузка

  • много моделей

  • дорогие ускорители

И самое приятное - Triton наконец-то приносит в мир ML ту самую инженерную дисциплину, к которой инфраструктурщики привыкли уже много лет.

Потому что когда AI перестаёт быть "магическим Python-скриптом" и становится обычным production-сервисом - жизнь всей команды внезапно становится гораздо спокойнее.