main 分支是开发版,稳定使用需切到 r26.10 等发布分支;示例需先跑 fetch_models.sh 下载模型到 model_repository;并非所有后端在所有平台都支持,需查 Backend-Platform 支持矩阵。
server
triton-inference-serverBSD-3-Clause活跃维护面向云端和数据中心的高性能推理服务端,支持多种深度学习框架模型部署,并可在边缘设备上运行。
The Triton Inference Server provides an optimized cloud and edge inferencing solution.
git clone -b r26.10 https://github.com/triton-inference-server/server.git
cd server/docs/examples
./fetch_models.sh
docker run --gpus=1 --rm --net=host -v ${PWD}/model_repository:/models nvcr.io/nvidia/tritonserver:26.10-py3 tritonserver --model-repository=/models --model-control-mode explicit --load-model densenet_onnxREADME 说明可在 NVIDIA GPU、x86 与 ARM CPU、AWS Inferentia 上推理;示例用 docker run --gpus=1 启动,并给出纯 CPU 系统的启动示例,具体显存要求未说明。
NVIDIA 开源的多框架推理服务端,把 TensorRT、PyTorch、ONNX 等模型统一部署成 HTTP/gRPC 服务
面向云端和数据中心的高性能推理服务端,支持多种深度学习框架模型部署,并可在边缘设备上运行。
核心能力
- 支持 TensorRT、PyTorch、ONNX、OpenVINO、Python 等多种后端
- 提供动态批处理与序列批处理,提升吞吐
- 用 Ensemble 和 BLS 编排多模型流水线
- 基于 KServe 的 HTTP/REST 与 gRPC 推理协议
- 暴露 GPU 利用率、吞吐与延迟等监控指标
容易踩的坑
- v2.74.0Release 2.74.0 corresponding to NGC container 26.10最新正式版2026-11-02 · 2026-11-02 17:26 UTC
Triton Inference Server
The Triton Inference Server provides a cloud inferencing solution optimized for both CPUs and GPUs. The server provides an inference service via an HTTP or GRPC endpoint, allowing remote clients to request inferencing for any model being managed by the server. For edge deployments, Triton Server is also available as a shared library with an API that allows the full functionality of the server to be included directly in an application.
- The S3 addressing style is now configurable.
- Request cancellation is now checked before a request is dispatched to the backend, and before batch assembly in the TensorRT backend.
- Tutorials: The Llava1.5 guide is deprecated in favor of the new Qwen2.5-VL guide for the TensorRT-LLM PyTorch backend. Note: this is a breaking change.
- HTTP request buffers are now released after a request is rejected for exceeding the chunk limit.
--http-max-input-sizeis now enforced across nested parameters of generate requests.- SageMaker model URLs are now validated before path normalization.
- Fixed copying of the cuBLAS libraries to the CUDA targets lib directory.
- Relaxed the
openaiandpydanticpins to match vLLM requirements. - Tritonserver is now built on, and shipped on, the cuda-dl-base devel image.
- Python backend: Restrictive permissions are now applied to shared memory, and GPU tensor allocation now falls back to host memory.
- ONNX Runtime, OpenVINO, Python and TensorRT-LLM backends: Backend builds now require
TRITON_BUILD_CONTAINERinstead of synthesizing apy3-minimage. - vLLM backend: Added support for vLLM >= 0.30, and prompts are now rendered before generation and encoding.
- Triton CLI: The image fetch in the TRT-LLM preprocessing template is now bounded.
- The Triton TensorRT-LLM Backend container image is not included in this release.
- vLLM's v0 API and Ray are affected by vulnerabilities. Users should consider their own architecture and mitigation steps which may include but should not be limited to:
- Do not expose Ray executors and vLLM hosts to a network where any untrusted connections might reach the host.
- Ensure that only the other vLLM hosts are able to connect to
- v2.73.0Release 2.73.0 corresponding to NGC container 26.092026-09-30 · 2026-09-30 22:26 UTC
查看更新说明
Triton Inference Server
The Triton Inference Server provides a cloud inferencing solution optimized for both CPUs and GPUs. The server provides an inference service via an HTTP or GRPC endpoint, allowing remote clients to request inferencing for any model being managed by the server. For edge deployments, Triton Server is also available as a shared library with an API that allows the full functionality of the server to be included directly in an application.
- The 26.09 DLFW containers introduce initial support for the NVIDIA Rubin GPU architecture.
- Core: Flagged the
developer_toolsC API wrapper as deprecated in the documentation. - Client: Fixed reading of
cudaIpcMemHandle_tbytes viagetPtr()for compatibility withcuda-bindings13.x. - Restored
preserve_orderingbehavior by reserving the completion-queue slot at enqueue time. - Fixed
default_model_filenameautofill incorrectly applying to Python-runtime PyTorch models. - OpenVINO backend: Fixed the OpenVINO GPU plugin build to ship
libOpenCL.so.1. - Python backend: Fixed a segfault during shutdown when using Triton metrics, and fixed shared-memory cleanup on forced shutdown.
- PyTorch backend: Fixed swapped
ReportStatisticstimestamp arguments and added a guard to the AOTI package loader in the PT2/AOTI backend. - Excluded
libtritonserverfromauditwheelprocessing in thetritonfrontendwheel build. - Fixed a crash: shared-memory inference requests now return a graceful
UNAVAILABLEerror instead of a NULL-dereference crash. - SageMaker integration: Fixed cross-model invoke/unload handling for multi-model endpoints.
- OpenAI-compatible frontend: Improved cancellation handling for response streams.
- Fixed an unhandled exception when parsing inference header length in the HTTP frontends.
- Build: Updated the C++ standard from C++17 to C++20.
- Build: Migrated the
tritonfrontendwheel tohatchlingwith PEP 639 metadata.
- The Triton TensorRT-LLM Backend container image is not included in this release.
- vLLM's v0 API and Ray are affected by vulnerabilities. Users should consider their own architecture and mitigation steps which may include but should not be limited to: *
- v2.72.0Release 2.72.0 corresponding to NGC container 26.082026-08-31 · 2026-08-31 19:07 UTC
查看更新说明
Triton Inference Server
The Triton Inference Server provides a cloud inferencing solution optimized for both CPUs and GPUs. The server provides an inference service via an HTTP or GRPC endpoint, allowing remote clients to request inferencing for any model being managed by the server. For edge deployments, Triton Server is also available as a shared library with an API that allows the full functionality of the server to be included directly in an application.
- Added a log callback option to the
tritonserverC and Python APIs and to the commonLogger, allowing an embedding application to route Triton log records into its own logging stack instead of a file or stream. - Fixed dynamic-batcher starvation caused by
waiting_consumer_countdrift, where the scheduler could stop dispatching work despite queued requests. - Restored
preserve_orderingsemantics by reserving the completion-queue slot at enqueue time rather than at completion. - Core: Improved model-readiness reporting in
TRITONSERVER_ServerModelIsReady— non-availability errors are now returned and unresolved models correctly reportready=false. - Model loading now catches exceptions rather than propagating them out of the load path, and uses
logic_errorso bothinvalid_argumentandout_of_rangeare handled uniformly. - TensorRT backend: Fixed CUDA graph execution for non-batching models.
- vLLM backend: Corrected JSON input parsing.
- OpenVINO backend: Enabled OpenVINO model generation on SBSA (aarch64).
- Python client: Removed the upper bound on the
grpciopackage requirement, so client installations are no longer pinned to an outdated gRPC. - Build: Added experimental build presets, allowing a build to be driven from a file via
--build-presets-fileinstead of a long command line. - Build: Default build parallelism is now capped by available memory, with matching caps for the ONNX Runtime and OpenVINO backend builds, preventing out-of-memory failures during container builds.
- Aligned protobuf and related dependencies with the gRPC 1.81.1 bump across the server, core, client, third-party and Model Analyzer components.
- Documentation: Added a RHEL / manylinux build tutorial.
- The
- Added a log callback option to the
- v2.71.0Release 2.71.0 corresponding to NGC container 26.072026-07-29 · 2026-07-29 16:09 UTC
查看更新说明
Triton Inference Server
The Triton Inference Server provides a cloud inferencing solution optimized for both CPUs and GPUs. The server provides an inference service via an HTTP or GRPC endpoint, allowing remote clients to request inferencing for any model being managed by the server. For edge deployments, Triton Server is also available as a shared library with an API that allows the full functionality of the server to be included directly in an application.
- Added a streaming tool-call parse buffer limit to the OpenAI-compatible frontend to prevent excessive memory usage during streaming tool calls.
- PyTorch backend: Enabled PyTorch 2 batching and added support for loading NV embedding layers.
- HSTU generative-recommender is supported using the PyTorch AOTI serving path.
- TensorRT backend: Added multi-device (multi-GPU) inference support.
- Python client: Preserved the output datatype for empty (zero-element) tensors.
- Core: Improved model-readiness reporting in
TRITONSERVER_ServerModelIsReady— non-availability errors are now returned, unresolved models correctly reportready=false, and the readiness lookup is * resolved byModelIdentifier. - Python backend: Fixed a deadlock in decoupled BLS and a use-after-free in the
async_execpybind callback. - Security: Restriction header values are now redacted from the OpenAI frontend startup log, and the inference restriction is enforced in the SageMaker MME invoke handler.
- Avoid the specific APIs/flows (low-level OCB, BIO_f_linebuffer with short writes, CMS password-based decryption, low-level
GF(2^m)with untrusted params) for many linux binaries, in order to avoid exposure to known issues in OpenSSL 1.1.1. - vLLM's v0 API and Ray are affected by vulnerabilities. Users should consider their own architecture and mitigation steps which may include but should not be limited to:
- Do not expose Ray executors and vLLM hosts to a network where any untrusted connections might reach the host.
- Ensure that only the other vLLM hosts are able to connect to the TCP port used for the XPUB socket. Note that the port used is random.
- When using Valgrind or other leak detection tools on AGX-
- v2.70.0Release 2.70.0 corresponding to NGC container 26.062026-06-26 · 2026-06-26 18:41 UTC
查看更新说明
Triton Inference Server
The Triton Inference Server provides a cloud inferencing solution optimized for both CPUs and GPUs. The server provides an inference service via an HTTP or GRPC endpoint, allowing remote clients to request inferencing for any model being managed by the server. For edge deployments, Triton Server is also available as a shared library with an API that allows the full functionality of the server to be included directly in an application.
- (Breaking) Removed deprecated Windows support: Dropped the Windows server build and removed Windows from the core build and documentation.
- (Breaking) Python client BF16 handling: The client now requires
ml_dtypes.bfloat16arrays for BF16 input/output tensors and no longer casts to/fromnp.float32. Scripts that passed BF16 data asnp.float32arrays must switch toml_dtypes.bfloat16. - TensorRT backend: Added multi-device (multi-GPU) inference support.
- PyTorch backend: Enabled PyTorch 2 dynamic batching.
- OpenAI-compatible frontend: Added an HTTP request body size limit.
- Fixed a server crash when loading models from
S3after an idle-connection timeout. - Security: Hardened model environment unpacking and file-path handling against path traversal.
- Improved request validation in the
SageMakerendpoint. - Changed the container install tree under
/opt/tritonserver/to stay root-owned, with thetriton-serveruser accessing it via group/other permissions. - Fixed a server crash caused by improper error handling.
- Avoid the specific APIs/flows (low-level OCB, BIO_f_linebuffer with short writes, CMS password-based decryption, low-level
GF(2^m)with untrusted params) for many linux binaries, in order to avoid exposure to known issues in OpenSSL 1.1.1. - vLLM's v0 API and Ray are affected by vulnerabilities. Users should consider their own architecture and mitigation steps which may include but should not be limited to:
- Do not expose Ray executors and vLLM hosts to a network where any untrusted connections might reach the host.
- Ensure that only the other vLLM hosts are able to connect to the TCP port used for the XPUB socket. Note that the por
用户点评
登录用户的真实使用记录,可按版本和硬件筛选还没有人点评。第一个说出真实体验的人最有价值。
[!WARNING] You are currently on the
mainbranch which tracks under-development progress towards the next release. The current release is version 2.74.0 and corresponds to the 26.10 container release on NVIDIA GPU Cloud (NGC).
Triton Inference Server
Triton Inference Server is an open source inference serving software that streamlines AI inferencing. Triton enables teams to deploy any AI model from multiple deep learning and machine learning frameworks, including TensorRT, PyTorch, ONNX, OpenVINO, Python, RAPIDS FIL, and more. Triton Inference Server supports inference across cloud, data center, edge and embedded devices on NVIDIA GPUs, x86 and ARM CPU, or AWS Inferentia. Triton Inference Server delivers optimized performance for many query types, including real time, batched, ensembles and audio/video streaming. Triton inference Server is part of NVIDIA AI Enterprise, a software platform that accelerates the data science pipeline and streamlines the development and deployment of production AI.
Major features include:
- Supports multiple deep learning frameworks
- Supports multiple machine learning frameworks
- Concurrent model execution
- Dynamic batching
- Sequence batching and implicit state management for stateful models
- Provides Backend API that allows adding custom backends and pre/post processing operations
- Supports writing custom backends in python, a.k.a. Python-based backends.
- Model pipelines using Ensembling or Business Logic Scripting (BLS)
- HTTP/REST and GRPC inference protocols based on the community developed KServe protocol
- A C API and Java API allow Triton to link directly into your application for edge and other in-process use cases
- Metrics indicating GPU utilization, server throughput, server latency, and more
New to Triton Inference Server? Make use of these tutorials to begin your Triton journey!
Join the Triton and TensorRT community and stay current on the latest product updates, bug fixes, content, best practices, and more. Need enterprise support? NVIDIA global support is available for Triton Inference Server with the NVIDIA AI Enterprise software suite.
Serve a Model in 3 Easy Steps
# Step 1: Create the example model repository
git clone -b r26.10 https://github.com/triton-inference-server/server.git
cd server/docs/examples
./fetch_models.sh
# Step 2: Launch triton from the NGC Triton container
docker run --gpus=1 --rm --net=host -v ${PWD}/model_repository:/models nvcr.io/nvidia/tritonserver:26.10-py3 tritonserver --model-repository=/models --model-control-mode explicit --load-model densenet_onnx
# Step 3: Sending an Inference Request
# In a separate console, launch the image_client example from the NGC Triton SDK container
docker run -it --rm --net=host nvcr.io/nvidia/tritonserver:26.10-py3-sdk /workspace/install/bin/image_client -m densenet_onnx -c 3 -s INCEPTION /workspace/images/mug.jpg
# Inference should return the following
Image '/workspace/images/mug.jpg':
15.346230 (504) = COFFEE MUG
13.224326 (968) = CUP
10.422965 (505) = COFFEEPOT
Please read the QuickStart guide for additional information regarding this example. The quickstart guide also contains an example of how to launch Triton on CPU-only systems. New to Triton and wondering where to get started? Watch the Getting Started video.
Examples and Tutorials
Check out NVIDIA LaunchPad for free access to a set of hands-on labs with Triton Inference Server hosted on NVIDIA infrastructure.
Specific end-to-end examples for popular models, such as ResNet, BERT, and DLRM are located in the NVIDIA Deep Learning Examples page on GitHub. The NVIDIA Developer Zone contains additional documentation, presentations, and examples.
Documentation
Build and Deploy
The recommended way to build and use Triton Inference Server is with Docker images.
- Install Triton Inference Server with Docker containers (Recommended)
- Install Triton Inference Server without Docker containers
- Build a custom Triton Inference Server Docker container
- Build Triton Inference Server from source
- Examples for deploying Triton Inference Server with Kubernetes and Helm on GCP, AWS, and NVIDIA FleetCommand
- Secure Deployment Considerations
Using Triton
Preparing Models for Triton Inference Server
The first step in using Triton to serve your models is to place one or more models into a model repository. Depending on the type of the model and on what Triton capabilities you want to enable for the model, you may need to create a model configuration for the model.
- Add custom operations to Triton if needed by your model
- Enable model pipelining with Model Ensemble and Business Logic Scripting (BLS)
- Optimize your models setting scheduling and batching parameters and model instances.
- Use the Model Analyzer tool to help optimize your model configuration with profiling
- Learn how to explicitly manage what models are available by loading and unloading models
Configure and Use Triton Inference Server
- Read the Quick Start Guide to run Triton Inference Server on both GPU and CPU
- Triton supports multiple execution engines, called backends, including TensorRT, PyTorch, ONNX, OpenVINO, Python, and more
- Not all the above backends are supported on every platform supported by Triton. Look at the Backend-Platform Support Matrix to learn which backends are supported on your target platform.
- Learn how to optimize performance using the Performance Analyzer and Model Analyzer
- Learn how to manage loading and unloading models in Triton
- Send requests directly to Triton with the HTTP/REST JSON-based or gRPC protocols
Client Support and Examples
A Triton client application sends inference and other requests to Triton. The Python and C++ client libraries provide APIs to simplify this communication.
- Review client examples for C++, Python, and Java
- Configure HTTP and gRPC client options
- Send input data (e.g. a jpeg image) directly to Triton in the body of an HTTP request without any additional metadata
Extend Triton
Triton Inference Server's architecture is specifically designed for modularity and flexibility
- Customize Triton Inference Server container for your use case
- Create custom backends in either C/C++ or Python
- Create decoupled backends and models that can send multiple responses for a request or not send any responses for a request
- Use a Triton repository agent to add functionality that operates when a model is loaded and unloaded, such as authentication, decryption, or conversion
- Deploy Triton on Jetson and JetPack
- Use Triton on AWS Inferentia
Additional Documentation
Contributing
Contributions to Triton Inference Server are more than welcome. To contribute please review the contribution guidelines. If you have a backend, client, example or similar contribution that is not modifying the core of Triton, then you should file a PR in the contrib repo.
Reporting problems, asking questions
We appreciate any feedback, questions or bug reporting regarding this project. When posting issues in GitHub, follow the process outlined in the Stack Overflow document. Ensure posted examples are:
- minimal – use as little code as possible that still produces the same problem
- complete – provide all parts needed to reproduce the problem. Check if you can strip external dependencies and still show the problem. The less time we spend on reproducing problems the more time we have to fix it
- verifiable – test the code you're about to provide to make sure it reproduces the problem. Remove all other problems that are not related to your request/question.
For issues, please use the provided bug report and feature request templates.
For questions, we recommend posting in our community GitHub Discussions.
For more information
Please refer to the NVIDIA Developer Triton page for more information.