Triển khai TensorRT-LLM trên Docker: Tối ưu Throughput và Giảm Latency khi Phục vụ LLM trên GPU NVIDIA

AI tutorial - IT technology blog
AI tutorial - IT technology blog

Tại Sao Inference LLM của Bạn Chậm Hơn Mức Cần Thiết

Bạn có một GPU NVIDIA mạnh mẽ, một mô hình ngôn ngữ đã được huấn luyện tốt, và một deployment production cần phục vụ — thế nhưng latency inference vẫn ở mức 2–3 giây mỗi request, và throughput sụp đổ khi vượt quá 10 người dùng đồng thời. Nút cổ chai không phải ở phần cứng của bạn. Vấn đề nằm ở cách mô hình đang được thực thi.

Hầu hết các team bắt đầu với Hugging Face Transformers và PyTorch. Điều đó hoàn toàn hợp lý cho giai đoạn prototype. Nhưng chế độ eager execution của PyTorch không được xây dựng cho việc phục vụ high-throughput — nó để lãng phí một lượng đáng kể GPU compute, đặc biệt khi bạn chạy inference lặp đi lặp lại trên một kiến trúc mô hình cố định.

Nguyên nhân gốc rễ là thiếu graph optimization. Mỗi forward pass phải tính toán lại operator fusion, memory layout và kernel selection từ đầu. TensorRT-LLM giải quyết vấn đề này bằng cách compile mô hình thành một TensorRT engine tối ưu một lần duy nhất, sau đó tái sử dụng cho mọi request. Trên cùng phần cứng, điều này thường dẫn đến throughput cao hơn 3–5x và latency first-token giảm 50–70%.

Nếu bạn đang chạy LLM như một dịch vụ production — không chỉ là demo — thì tối ưu hóa này quan trọng hơn hầu hết các nâng cấp phần cứng. Làm đúng có nghĩa là A100 của bạn phục vụ được nhiều người dùng hơn nhiều với cùng ngân sách GPU.

Cài đặt: Thiết lập TensorRT-LLM trên Docker

Các Docker image chính thức của NVIDIA loại bỏ nỗi đau trong việc thiết lập môi trường. CUDA, cuDNN, TensorRT và Python bindings đều được cài đặt sẵn và khớp phiên bản — điều này một mình đã tiết kiệm vài giờ vật lộn với dependency.

Yêu cầu trước khi bắt đầu

  • GPU NVIDIA với kiến trúc Ampere trở lên (A100, A10, RTX 3090/4090, H100)
  • Driver NVIDIA ≥ 525.85
  • Docker Engine đã cài NVIDIA Container Toolkit
  • Ít nhất 20GB dung lượng đĩa cho image và model weights

Đầu tiên, kiểm tra xem NVIDIA Container Toolkit có hoạt động không:

docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

GPU của bạn sẽ hiện trong output. Nếu không, hãy cài toolkit trước:

# Cài đặt NVIDIA Container Toolkit
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-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Tải Docker Image TensorRT-LLM

NVIDIA xuất bản TensorRT-LLM images trên container registry của họ. Chọn phiên bản phù hợp với driver CUDA của bạn:

# Tải TensorRT-LLM image (điều chỉnh phiên bản nếu cần)
docker pull nvcr.io/nvidia/tritonserver:24.05-trtllm-python-py3

# Hoặc dùng TensorRT-LLM development image nhẹ hơn
docker pull nvcr.io/nvidia/tensorrt-llm:0.11.0

Khởi động container với quyền truy cập GPU và mount thư mục local để chứa model weights:

docker run --gpus all \
  --ipc=host \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  -v /path/to/models:/models \
  -p 8000:8000 \
  -it nvcr.io/nvidia/tensorrt-llm:0.11.0 bash

Flag --ipc=host quan trọng ở đây — nó cho phép shared memory giữa các tiến trình container, thứ mà TensorRT-LLM cần cho multi-GPU tensor parallelism.

Cấu hình: Build và Phục vụ TensorRT Engine Đầu Tiên

TensorRT-LLM hoạt động theo hai giai đoạn: compile mô hình thành TensorRT engine, sau đó phục vụ nó. Quá trình compilation là nơi công việc thực sự diễn ra — CUDA kernels được fused, memory layouts được tối ưu, và engine được khóa với phần cứng GPU cụ thể của bạn.

Bước 1: Chuyển đổi Model Weights

Lấy Llama-3-8B làm ví dụ, bắt đầu bằng cách tải mô hình vào trong container:

# Cài đặt Hugging Face hub để tải mô hình
pip install huggingface_hub

# Tải model weights (yêu cầu HF token cho các mô hình có kiểm soát truy cập)
huggingface-cli download meta-llama/Meta-Llama-3-8B \
  --local-dir /models/llama3-8b \
  --token YOUR_HF_TOKEN

Sau đó chuyển đổi weights sang định dạng TensorRT-LLM checkpoint:

cd /app/tensorrt_llm/examples/llama

python convert_checkpoint.py \
  --model_dir /models/llama3-8b \
  --output_dir /models/llama3-8b-trtllm-ckpt \
  --dtype float16 \
  --tp_size 1

Trên A100 hoặc H100, chuyển sang --dtype bfloat16 để có độ ổn định số học tốt hơn. Với cấu hình đa GPU, đặt --tp_size 2 (hoặc 4, 8) để phân tán mô hình qua các GPU bằng tensor parallelism.

Bước 2: Build TensorRT Engine

Bước này compile model graph thành một binary được tối ưu. Dự tính 5–15 phút tùy thuộc vào GPU và kích thước mô hình:

trtllm-build \
  --checkpoint_dir /models/llama3-8b-trtllm-ckpt \
  --output_dir /models/llama3-8b-engine \
  --gemm_plugin float16 \
  --max_batch_size 32 \
  --max_input_len 2048 \
  --max_seq_len 4096 \
  --use_paged_context_fmha enable

Các tham số quan trọng cần điều chỉnh cho workload của bạn:

  • --max_batch_size: Số request đồng thời tối đa. Giá trị cao hơn cải thiện throughput nhưng tăng bộ nhớ sử dụng.
  • --max_input_len + --max_seq_len: Đặt dựa trên use case thực tế của bạn. Giá trị lớn hơn sẽ tiêu thụ nhiều KV cache memory hơn.
  • --use_paged_context_fmha enable: Kích hoạt paged KV cache attention — thiết yếu để xử lý các chuỗi có độ dài biến đổi mà không lãng phí bộ nhớ cho padding.

Bước 3: Khởi động với Triton Inference Server

Kết hợp TensorRT-LLM với NVIDIA Triton để phục vụ production. Tạo cấu trúc model repository trước:

mkdir -p /triton_model_repo/tensorrt_llm/1

# Sao chép các file engine
cp /models/llama3-8b-engine/* /triton_model_repo/tensorrt_llm/1/

# Tạo cấu hình Triton
cat > /triton_model_repo/tensorrt_llm/config.pbtxt << 'EOF'
name: "tensorrt_llm"
backend: "tensorrtllm"
max_batch_size: 32

parameters {
  key: "executor_worker_path"
  value: { string_value: "/opt/tritonserver/backends/tensorrtllm/trtllmExecutorWorker" }
}
parameters {
  key: "max_tokens_in_paged_kv_cache"
  value: { string_value: "2560" }
}
parameters {
  key: "batch_scheduler_policy"
  value: { string_value: "inflight_fused_batching" }
}
EOF

Scheduler inflight_fused_batching là thứ phân biệt việc phục vụ cấp production với xử lý batch thông thường. Thay vì chờ batch hiện tại hoàn thành, nó liên tục merge các request đến vào các batch đang hoạt động. GPU utilization vẫn cao ngay cả khi traffic patterns không đồng đều.

Khởi động Triton server:

tritonserver \
  --model-repository /triton_model_repo \
  --http-port 8000 \
  --grpc-port 8001 \
  --metrics-port 8002

Kiểm tra và Giám sát: Xác nhận Thực sự Nhanh Hơn

Hãy đo đạc thực tế. Đừng tin tưởng mù quáng rằng deployment đang hoạt động tốt — TensorRT-LLM và Triton cung cấp đủ telemetry để xác nhận chính xác bạn đã cải thiện được bao nhiêu latency và throughput.

Kiểm tra Chức năng Nhanh

import tritonclient.http as httpclient
import numpy as np
import json

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

# Kiểm tra trạng thái server
print("Server sẵn sàng:", client.is_server_ready())
print("Model sẵn sàng:", client.is_model_ready("tensorrt_llm"))

# Gửi request inference thử nghiệm
inputs = [
    httpclient.InferInput("text_input", [1, 1], "BYTES"),
    httpclient.InferInput("max_tokens", [1, 1], "INT32"),
]

prompt = "Giải thích Docker networking theo cách đơn giản."
inputs[0].set_data_from_numpy(np.array([[prompt.encode()]], dtype=object))
inputs[1].set_data_from_numpy(np.array([[256]], dtype=np.int32))

outputs = [httpclient.InferRequestedOutput("text_output")]
result = client.infer("tensorrt_llm", inputs, outputs=outputs)
print(result.as_numpy("text_output")[0][0].decode())

Đo lường Throughput

TensorRT-LLM đi kèm với công cụ benchmark tích hợp. Chạy nó để lấy con số baseline:

python /app/tensorrt_llm/benchmarks/python/benchmark.py \
  -m llama \
  --engine_dir /models/llama3-8b-engine \
  --batch_size 1 8 16 32 \
  --input_output_len 512,128 \
  --dtype float16

Chạy cùng benchmark đó với baseline PyTorch vanilla để đặt các con số vào bối cảnh. Trên A100 80GB, Llama-3-8B thường đi từ khoảng 15 tokens/giây với PyTorch lên 80–120 tokens/giây với TensorRT-LLM ở batch size 1. Khoảng cách này càng nới rộng hơn ở batch size cao hơn.

Giám sát GPU Utilization và KV Cache

Triton cung cấp metrics tương thích Prometheus tại cổng 8002:

# Kiểm tra các metrics quan trọng
curl -s http://localhost:8002/metrics | grep -E \
  'nv_inference_request_success|nv_inference_queue_duration|kv_cache_utilization'

Chú ý kỹ đến kv_cache_utilization. Nếu nó duy trì trên 90% dưới tải, hãy tăng max_tokens_in_paged_kv_cache trong config Triton hoặc giảm max_batch_size. Áp lực KV cache — không phải compute — là nguồn gây ra latency spike phổ biến nhất trong các deployment TensorRT-LLM production.

Kết nối các metrics này vào Prometheus và Grafana để theo dõi liên tục. Các panel đáng theo dõi: tokens per second, time-to-first-token (p50/p99), queue depth và KV cache utilization theo thời gian.

Khi Nào Cần Build Lại Engine

TensorRT engine được compile gắn với GPU model cụ thể, phiên bản CUDA và compile-time parameters của bạn. Cần build lại khi:

  • Nâng cấp lên thế hệ GPU khác
  • Thay đổi phiên bản CUDA hoặc TensorRT
  • Điều chỉnh max batch size hoặc max sequence length
  • Chuyển đổi giữa độ chính xác FP16 và BF16

Lưu build script có thể tái tạo trong version control. Việc rebuild nên là một lệnh duy nhất, không phải một buổi debug. Thời gian compile — thường 10–15 phút với mô hình 8B — là chi phí bỏ ra một lần duy nhất. Sau đó, mọi inference call đều chạy trên engine đã tối ưu.

Share: