TensorRT Optimization Docker Container Deploy — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

แนะนำ TensorRT Optimization Docker Container Deploy

ในยุคที่โมเดล AI และ Deep Learning กำลังก้าวเข้าสู่ Production อย่างเต็มรูปแบบ ปัญหาสำคัญที่นักพัฒนาและวิศวกร Machine Learning ต้องเผชิญคือประสิทธิภาพในการ Inference โดยเฉพาะอย่างยิ่งเมื่อต้อง Deploy บนระบบที่มีทรัพยากรจำกัด หรือต้องการ Latency ต่ำมาก TensorRT (TensorRT) จาก NVIDIA ได้กลายเป็นมาตรฐานในการ Optimize โมเดล Neural Network ให้ทำงานได้เร็วขึ้น บน GPU ของ NVIDIA โดยเฉพาะ

บทความนี้จะพาคุณไปรู้จักกับ TensorRT Optimization Docker Container Deploy อย่างละเอียด ตั้งแต่พื้นฐาน จนถึงการปรับใช้ใน Production จริง โดยเน้นที่การใช้งานร่วมกับ Docker Container เพื่อให้การ Deploy สะดวก ทำซ้ำได้ และพกพาได้ง่าย

1. ทำความเข้าใจ TensorRT และ Docker Container

1.1 TensorRT คืออะไร?

TensorRT คือ SDK สำหรับ High-Performance Deep Learning Inference ที่พัฒนาโดย NVIDIA โดยมีเป้าหมายเพื่อเพิ่มความเร็วในการ Inference และลด Latency บน GPU ของ NVIDIA TensorRT ทำงานโดยการ Optimize โมเดลที่เทรนเสร็จแล้ว (Trained Model) ผ่านเทคนิคต่างๆ เช่น:

• Layer Fusion – รวมหลาย Layer เข้าด้วยกันเพื่อลด Kernel Launch Overhead
• Weight Quantization – ลด Precision ของ Weight เช่น จาก FP32 เป็น FP16 หรือ INT8 เพื่อเพิ่มความเร็ว
• Kernel Auto-Tuning – เลือก Kernel ที่เหมาะสมที่สุดสำหรับ GPU แต่ละรุ่น
• Memory Optimization – จัดการ Memory อย่างมีประสิทธิภาพ

TensorRT รองรับโมเดลจาก Framework ต่างๆ เช่น TensorFlow, PyTorch, ONNX และอื่นๆ โดยสามารถแปลงโมเดลเป็นรูปแบบที่เรียกว่า TensorRT Engine (.trt หรือ .plan) ซึ่งเป็นรูปแบบที่ Optimize แล้วสำหรับ GPU เฉพาะรุ่น

1.2 Docker Container คืออะไรและทำไมต้องใช้?

Docker Container เป็นเทคโนโลยี Virtualization ระดับ OS ที่ช่วยให้คุณ Pack Application และ Dependencies ทั้งหมดลงใน Container Image ทำให้ Application ทำงานได้อย่างสม่ำเสมอในทุกสภาพแวดล้อม

ข้อดีของการใช้ Docker Container สำหรับ TensorRT Deployment:

• Reproducibility – สร้างสภาพแวดล้อมที่เหมือนกันทุกครั้ง ไม่ว่าจะ Deploy บนเครื่อง Develop, Staging หรือ Production
• Isolation – แยก Dependencies ของแต่ละ Application ไม่ให้รบกวนกัน
• Portability – ย้าย Application ระหว่างเครื่องหรือ Cloud Provider ได้ง่าย
• Version Control – จัดการ Version ของ TensorRT, CUDA, cuDNN และ Library อื่นๆ ได้อย่างแม่นยำ
• Scalability – รองรับการ Scale ด้วย Orchestration Tools เช่น Kubernetes

2. การเตรียมสภาพแวดล้อมสำหรับ TensorRT Docker Container

2.1 สิ่งที่ต้องเตรียมก่อนเริ่ม

ก่อนที่เราจะเริ่ม Optimize และ Deploy โมเดลด้วย TensorRT และ Docker เราจำเป็นต้องมีสิ่งต่อไปนี้:

• NVIDIA GPU – รองรับ CUDA (Compute Capability 6.0 ขึ้นไป แนะนำ 7.0+ สำหรับ FP16, 7.2+ สำหรับ INT8)
• NVIDIA Driver – Version ล่าสุดที่รองรับ CUDA 12.x
• Docker Engine – Version 24.0 ขึ้นไป
• NVIDIA Container Toolkit (nvidia-docker2) – สำหรับให้ Docker Container เข้าถึง GPU
• TensorRT Docker Image – จาก NVIDIA NGC Registry

2.2 การติดตั้ง NVIDIA Container Toolkit

ขั้นตอนการติดตั้ง NVIDIA Container Toolkit บน Ubuntu 22.04 LTS:

# เพิ่ม Repository ของ NVIDIA
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

# อัปเดตและติดตั้ง
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# รีสตาร์ท Docker
sudo systemctl restart docker

# ทดสอบว่า GPU ถูกตรวจพบ
sudo docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi

2.3 การเลือก TensorRT Docker Image ที่เหมาะสม

NVIDIA NGC (NVIDIA GPU Cloud) มี Docker Image ที่มี TensorRT ติดตั้งพร้อมแล้วหลาย Version โดยสามารถเลือกได้ตามความต้องการ:

คำแนะนำ: เลือก Version ล่าสุดเสมอ (ณ ปี 2026 คือ 25.03-py3) เพื่อรับฟีเจอร์ใหม่และการ Optimize ที่ดีที่สุด แต่ควรทดสอบใน Staging ก่อนเสมอ

3. ขั้นตอนการ Optimize โมเดลด้วย TensorRT

3.1 การแปลงโมเดลเป็น ONNX

ONNX (Open Neural Network Exchange) เป็นรูปแบบโมเดลมาตรฐานที่ TensorRT รองรับโดยตรง ขั้นตอนแรกคือการแปลงโมเดลจาก Framework ดั้งเดิมเป็น ONNX

ตัวอย่างการแปลงโมเดล PyTorch เป็น ONNX:

import torch
import torchvision.models as models

# โหลดโมเดลที่เทรนเสร็จแล้ว
model = models.resnet50(pretrained=True)
model.eval()

# สร้าง Input ตัวอย่าง
dummy_input = torch.randn(1, 3, 224, 224)

# แปลงเป็น ONNX
torch.onnx.export(
    model,
    dummy_input,
    "resnet50.onnx",
    export_params=True,
    opset_version=17,
    do_constant_folding=True,
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={
        'input': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    }
)

print("โมเดลถูกแปลงเป็น ONNX สำเร็จ")

3.2 การสร้าง TensorRT Engine จาก ONNX

เมื่อได้โมเดลในรูปแบบ ONNX แล้ว ขั้นตอนต่อไปคือการสร้าง TensorRT Engine ซึ่งเป็นรูปแบบที่ Optimize แล้วสำหรับ GPU เฉพาะรุ่น

import tensorrt as trt
import numpy as np

# สร้าง Logger และ Builder
TRT_LOGGER = trt.Logger(trt.Logger.WARNING)
builder = trt.Builder(TRT_LOGGER)
network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
parser = trt.OnnxParser(network, TRT_LOGGER)

# อ่านโมเดล ONNX
with open("resnet50.onnx", "rb") as f:
    if not parser.parse(f.read()):
        for error in range(parser.num_errors):
            print(parser.get_error(error))
        raise RuntimeError("ไม่สามารถ Parse ONNX ได้")

# กำหนด Config
config = builder.create_builder_config()
config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 1 << 30)  # 1GB

# เปิดใช้งาน FP16 Precision (ถ้า GPU รองรับ)
if builder.platform_has_fast_fp16:
    config.set_flag(trt.BuilderFlag.FP16)
    print("เปิดใช้งาน FP16 Precision")

# เปิดใช้งาน INT8 Precision (ต้องใช้ Calibration Dataset)
# if builder.platform_has_fast_int8:
#     config.set_flag(trt.BuilderFlag.INT8)
#     config.set_calibrator(MyCalibrator())

# สร้าง Engine
serialized_engine = builder.build_serialized_network(network, config)

# บันทึก Engine ลงไฟล์
with open("resnet50.trt", "wb") as f:
    f.write(serialized_engine)

print("TensorRT Engine ถูกสร้างสำเร็จ")

3.3 การทำ Inference ด้วย TensorRT Engine

เมื่อมี TensorRT Engine แล้ว เราสามารถใช้มันทำ Inference ได้ดังนี้:

import tensorrt as trt
import numpy as np
import cv2

# โหลด Engine
TRT_LOGGER = trt.Logger(trt.Logger.WARNING)
with open("resnet50.trt", "rb") as f:
    runtime = trt.Runtime(TRT_LOGGER)
    engine = runtime.deserialize_cuda_engine(f.read())

# สร้าง Context
context = engine.create_execution_context()

# เตรียม Input
input_image = cv2.imread("test_image.jpg")
input_image = cv2.resize(input_image, (224, 224))
input_image = input_image.transpose(2, 0, 1)  # HWC -> CHW
input_image = input_image.astype(np.float32) / 255.0
input_image = np.expand_dims(input_image, axis=0)  # เพิ่ม Batch Dimension

# จัดสรร Memory บน GPU
input_binding = engine.get_binding_index("input")
output_binding = engine.get_binding_index("output")

input_memory = np.ascontiguousarray(input_image)
output_memory = np.empty((1, 1000), dtype=np.float32)

# ทำ Inference
context.execute_v2([input_memory, output_memory])

# ตรวจสอบผลลัพธ์
predicted_class = np.argmax(output_memory[0])
print(f"Predicted class: {predicted_class}")

4. การสร้าง Docker Container สำหรับ TensorRT Deployment

4.1 การเขียน Dockerfile ที่เหมาะสม

การสร้าง Docker Image ที่มี TensorRT และ Application ของคุณเป็นสิ่งสำคัญ การออกแบบ Dockerfile ที่ดีจะช่วยให้ Image มีขนาดเล็ก ปลอดภัย และ Build ได้เร็ว

ตัวอย่าง Dockerfile สำหรับ TensorRT Inference Server:

# Stage 1: Build Stage
FROM nvcr.io/nvidia/tensorrt:25.03-py3 AS builder

WORKDIR /app

# คัดลอกไฟล์ที่จำเป็นสำหรับการ Build
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# คัดลอก Source Code และโมเดล
COPY src/ ./src/
COPY models/ ./models/

# Build TensorRT Engine (ถ้าต้องการทำตอน Build)
# RUN python src/build_engine.py --onnx models/model.onnx --output models/model.trt

# Stage 2: Production Stage
FROM nvcr.io/nvidia/tensorrt:25.03-py3

WORKDIR /app

# ติดตั้ง Dependencies ที่จำเป็นสำหรับ Production
RUN apt-get update && apt-get install -y --no-install-recommends \
    libgl1-mesa-glx \
    libglib2.0-0 \
    && rm -rf /var/lib/apt/lists/*

# คัดลอกเฉพาะไฟล์ที่จำเป็นจาก Build Stage
COPY --from=builder /app/src ./src
COPY --from=builder /app/models ./models

# สร้าง User ที่ไม่ใช่ Root เพื่อความปลอดภัย
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

# กำหนด Port
EXPOSE 8000

# Command สำหรับรัน Inference Server
CMD ["python", "src/inference_server.py"]

4.2 Multi-Stage Build เพื่อลดขนาด Image

การใช้ Multi-Stage Build ช่วยลดขนาดของ Docker Image ได้อย่างมาก โดยเฉพาะเมื่อเราต้องการเครื่องมือสำหรับ Build TensorRT Engine แต่ไม่จำเป็นต้องมีใน Production

4.3 การจัดการ GPU Access ใน Docker Container

เพื่อให้ Container สามารถเข้าถึง GPU ได้ เราต้องใช้ --gpus flag หรือตั้งค่าใน Docker Compose:

วิธีที่ 1: ใช้ Command Line

# ใช้ GPU ทั้งหมด
docker run --gpus all -p 8000:8000 my-tensorrt-app:latest

# ใช้ GPU เฉพาะ Device (GPU 0 และ GPU 1)
docker run --gpus '"device=0,1"' -p 8000:8000 my-tensorrt-app:latest

# ใช้ GPU ตาม CUDA_VISIBLE_DEVICES
docker run -e CUDA_VISIBLE_DEVICES=0,1 --gpus all -p 8000:8000 my-tensorrt-app:latest

วิธีที่ 2: ใช้ Docker Compose

version: '3.8'

services:
  tensorrt-server:
    image: my-tensorrt-app:latest
    ports:
      - "8000:8000"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - CUDA_VISIBLE_DEVICES=0
      - TENSORRT_ENGINE_PATH=/app/models/resnet50.trt
    volumes:
      - ./models:/app/models
    restart: unless-stopped

5. Best Practices สำหรับ TensorRT Docker Deployment

5.1 การ Optimize ขนาดและ Performance

• ใช้ Multi-Stage Build - แยก Build และ Production Stage เพื่อลดขนาด Image
• เลือก Base Image ที่เหมาะสม - ใช้ TensorRT Image แทน CUDA Image เต็ม เพื่อลดขนาด
• Pre-build TensorRT Engine - ควร Build Engine ล่วงหน้าใน Build Stage ไม่ใช่ตอน Runtime
• ใช้ Model Optimization - ลด Precision (FP16/INT8) และ Pruning เพื่อเพิ่มความเร็ว
• Batch Inference - รองรับ Dynamic Batching เพื่อเพิ่ม Throughput

5.2 การจัดการ Security

• ใช้ Non-Root User - สร้าง User สำหรับรัน Application แทนการใช้ Root
• จำกัด Resource - กำหนด Memory และ CPU Limits ใน Docker
• Scan Image - ใช้ Tools เช่น Trivy หรือ Snyk เพื่อ Scan Vulnerability
• ใช้ Secrets Management - ไม่ Hardcode API Keys หรือ Credentials ใน Image
• Network Isolation - เปิดเฉพาะ Port ที่จำเป็น (เช่น 8000 สำหรับ HTTP)

5.3 การ Monitoring และ Logging

• ใช้ Structured Logging - ส่ง Log ในรูปแบบ JSON เพื่อให้ Log Aggregator (ELK, Grafana Loki) จัดการได้ง่าย
• Monitor GPU Utilization - ใช้ NVIDIA DCGM (Data Center GPU Manager) หรือ Prometheus Exporter
• Health Check Endpoint - เพิ่ม Endpoint สำหรับ Kubernetes Liveness/Readiness Probe
• Metrics Export - ส่ง Metrics เช่น Latency, Throughput, Error Rate ไปยัง Prometheus

6. Real-World Use Cases

6.1 Real-Time Object Detection สำหรับ Smart Camera

บริษัทผลิตกล้องวงจรปิดแห่งหนึ่งต้องการเพิ่มความสามารถในการตรวจจับวัตถุแบบ Real-Time บนกล้อง Edge Device โดยใช้ NVIDIA Jetson (ซึ่งใช้ TensorRT) และ Docker Container

Solution:

• ใช้ YOLOv8 โมเดลที่ Optimize ด้วย TensorRT INT8
• Deploy ผ่าน Docker Container บน Jetson Orin NX
• ใช้ NVIDIA DeepStream SDK สำหรับ Pipeline Video Analytics
• ผลลัพธ์: Latency ลดลงจาก 50ms เหลือ 8ms, FPS เพิ่มจาก 20 เป็น 120

6.2 AI Chatbot สำหรับ Customer Service

ธนาคารชั้นนำต้องการ Deploy Large Language Model (LLM) สำหรับ Chatbot ให้บริการลูกค้า โดยต้องตอบสนองภายใน 2 วินาที

Solution:

• ใช้ Llama 3 8B โมเดลที่ Quantize ด้วย TensorRT-LLM (FP8 Precision)
• Deploy บน Kubernetes Cluster ที่มี GPU A100
• ใช้ Docker Container พร้อม Auto-scaling ตาม Load
• ผลลัพธ์: Latency เฉลี่ย 1.2 วินาที, รองรับ 500 Concurrent Users

6.3 Medical Image Analysis

โรงพยาบาลต้องการระบบวิเคราะห์ภาพเอ็กซ์เรย์เพื่อช่วยแพทย์วินิจฉัยโรคปอด โดยต้องมีความแม่นยำสูงและทำงานบนเครื่องที่มีทรัพยากรจำกัด

Solution:

• ใช้ EfficientNet-B4 ที่ Optimize ด้วย TensorRT FP16
• Deploy ผ่าน Docker Container บน Workstation ที่มี RTX 4090
• ใช้ DICOM Protocol สำหรับรับภาพจากเครื่องเอ็กซ์เรย์
• ผลลัพธ์: วิเคราะห์ภาพ 1000 ภาพใน 15 วินาที (จากเดิม 2 นาที)

7. การ Troubleshooting ปัญหาที่พบบ่อย

7.1 ปัญหา GPU ไม่ถูกตรวจจับใน Container

สาเหตุ: NVIDIA Container Toolkit ไม่ได้ติดตั้ง หรือ Docker Daemon ไม่ได้รีสตาร์ท

วิธีแก้:

• ตรวจสอบว่า nvidia-container-toolkit ติดตั้งแล้ว
• รัน sudo systemctl restart docker
• ทดสอบด้วย docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi
• ถ้ายังไม่สำเร็จ ตรวจสอบ /etc/docker/daemon.json ว่ามี "default-runtime": "nvidia" หรือไม่

7.2 TensorRT Engine Build ล้มเหลว

สาเหตุ: OOM (Out of Memory) หรือ Unsupported Layer

วิธีแก้:

• ลด Workspace Size ใน Config: config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 512 << 20)
• ใช้ Precision ต่ำลง (FP16 แทน FP32)
• ตรวจสอบว่า Layer ที่ใช้รองรับโดย TensorRT หรือไม่ (ใช้ TRT Network Validator)
• ลองใช้ Dynamic Shape แทน Fixed Shape

7.3 Performance ไม่ดีเท่าที่คาดหวัง

สาเหตุ: GPU ไม่ได้ถูกใช้เต็มประสิทธิภาพ หรือ Bottleneck ที่ CPU/IO

วิธีแก้:

• ใช้ nvidia-smi หรือ nvtop ตรวจสอบ GPU Utilization
• เพิ่ม Batch Size ให้เหมาะสมกับ GPU Memory
• ใช้ CUDA Graphs สำหรับ Latency-critical Applications
• ตรวจสอบ Data Pipeline (I/O, Preprocessing) ว่ามี Bottleneck หรือไม่

8. การ Monitor และ Optimize อย่างต่อเนื่อง

8.1 การตั้งค่า Monitoring Stack

การ Monitor TensorRT Inference ใน Production เป็นสิ่งสำคัญเพื่อให้แน่ใจว่าระบบทำงานได้ตามที่คาดหวัง:

# ตัวอย่างการเพิ่ม Prometheus Metrics ใน FastAPI Inference Server
from fastapi import FastAPI, Request
from prometheus_client import Counter, Histogram, generate_latest, REGISTRY
import time

app = FastAPI()

# Define Metrics
INFERENCE_COUNTER = Counter('inference_requests_total', 'Total Inference Requests')
INFERENCE_LATENCY = Histogram('inference_latency_seconds', 'Inference Latency in Seconds', buckets=[0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0])
GPU_UTILIZATION = Gauge('gpu_utilization_percent', 'GPU Utilization Percentage')

@app.post("/predict")
async def predict(request: Request):
    INFERENCE_COUNTER.inc()
    start_time = time.time()
    
    # ทำ Inference...
    result = run_inference(await request.json())
    
    INFERENCE_LATENCY.observe(time.time() - start_time)
    return {"result": result}

@app.get("/metrics")
async def metrics():
    return generate_latest(REGISTRY)

8.2 การทำ A/B Testing สำหรับ Model Version

เมื่อมีโมเดลหลาย Version (เช่น FP32, FP16, INT8) ควรทำ A/B Testing เพื่อเปรียบเทียบ Performance และ Accuracy:

• ใช้ Feature Flag หรือ Traffic Splitting (เช่น 90% FP16, 10% INT8)
• วัด Metrics เช่น Accuracy, Latency, Throughput
• ใช้ Shadow Deployment เพื่อทดสอบโมเดลใหม่โดยไม่กระทบ User จริง
• Rollback ทันทีถ้า Metrics ต่ำกว่า Threshold

9. อนาคตของ TensorRT และ Docker Deployment

ในปี 2026 เทคโนโลยี TensorRT และ Docker Container ยังคงพัฒนาอย่างต่อเนื่อง โดยมีแนวโน้มสำคัญดังนี้:

• TensorRT-LLM - การ Optimize สำหรับ Large Language Models โดยเฉพาะ รองรับ FP8 และ INT4 Quantization
• Dynamic Shape Support - รองรับ Input Shape ที่แปรผันได้ดีขึ้น โดยไม่ต้อง Rebuild Engine
• Kubernetes Native - การ Integrate กับ Kubernetes ผ่าน NVIDIA GPU Operator ทำให้จัดการ GPU Resource ได้ง่ายขึ้น
• Edge AI - การ Deploy TensorRT บน Jetson และ Embedded Devices ผ่าน Docker Container ที่ Optimize สำหรับ ARM
• Automated Optimization Pipeline - Tools ที่ช่วย Automate การ Build, Test, และ Deploy TensorRT Engine โดยอัตโนมัติ

Summary

TensorRT Optimization ร่วมกับ Docker Container Deployment เป็นโซลูชันที่ทรงพลังสำหรับการนำโมเดล AI ไปใช้ใน Production อย่างมีประสิทธิภาพ บทความนี้ได้ครอบคลุมตั้งแต่การทำความเข้าใจพื้นฐานของ TensorRT และ Docker, การเตรียมสภาพแวดล้อม, การ Optimize โมเดล, การสร้าง Docker Container, ไปจนถึง Best Practices และ Real-World Use Cases

ประเด็นสำคัญที่ควรจดจำ:

• TensorRT สามารถเพิ่มความเร็ว Inference ได้ถึง 10-40 เท่าเมื่อเทียบกับ Framework ดั้งเดิม ขึ้นอยู่กับ Precision และ Model Architecture
• การใช้ Docker Container ช่วยให้ Deployment ทำซ้ำได้ จัดการ Version ได้ และ Scale ได้ง่าย
• ควรใช้ Multi-Stage Build เพื่อลดขนาด Image และเพิ่มความปลอดภัย
• การ Monitor และ Optimize อย่างต่อเนื่องเป็นสิ่งจำเป็นสำหรับ Production

สำหรับนักพัฒนาที่ต้องการเริ่มต้นใช้งาน TensorRT และ Docker Container ควรเริ่มจากการทำ PoC (Proof of Concept) ในสภาพแวดล้อมที่ควบคุมได้ก่อน แล้วจึงค่อยๆ ขยายไปสู่ Production โดยใช้ Best Practices ที่กล่าวถึงในบทความนี้ หากมีข้อสงสัยหรือต้องการคำแนะนำเพิ่มเติม สามารถติดต่อทีมงาน SiamCafe Blog ได้ที่ช่องทางปกติ

บทความโดย SiamCafe Blog — อัปเดตล่าสุด: 2026