#การตั้งค่า vLLM บน DigitalOcean GPU Droplet

การนำ Large Language Model (LLM) มาให้บริการภายในระบบของตนเองเป็นทางเลือกที่น่าสนใจสำหรับงาน เช่น AI Chatbot, RAG, AI Agent, Coding Assistant และ Private LLM โดยเฉพาะเมื่อเราต้องการควบคุมโมเดล ข้อมูล และโครงสร้างพื้นฐานเอง

หนึ่งในเครื่องมือที่ได้รับความนิยมสำหรับงาน LLM Inference คือ vLLM ซึ่งออกแบบมาเพื่อให้บริการโมเดลได้อย่างมีประสิทธิภาพ และมี OpenAI-Compatible API ทำให้แอปพลิเคชันที่ใช้ OpenAI SDK สามารถเปลี่ยนปลายทาง API มายังเซิร์ฟเวอร์ของเราได้ค่อนข้างง่าย

บทความนี้แสดงขั้นตอนการติดตั้ง vLLM บน DigitalOcean GPU Droplet ด้วย Docker Compose ตั้งแต่การเลือก GPU จนถึงการเตรียมระบบสำหรับใช้งานจริง

เอกสารนี้อ้างอิงสถานะของ DigitalOcean และ vLLM ณ เดือนกันยายน 2026 ควรตรวจสอบราคา รุ่น GPU และเวอร์ชันซอฟต์แวร์ล่าสุดจากเอกสารทางการก่อนใช้งานจริง

#สถาปัตยกรรมที่เราจะสร้าง

โครงสร้างพื้นฐานโดยรวมมีลักษณะดังนี้

Application / AI Agent / RAG
            |
          HTTPS
            |
            v
   DigitalOcean Firewall
            |
            v
      Caddy / Nginx
            |
            v
     127.0.0.1:8000
            |
            v
          vLLM
            |
            v
       NVIDIA GPU

จุดสำคัญคือ ไม่ควรเปิด vLLM port 8000 สู่ Internet โดยตรง แต่ควรวาง Reverse Proxy และ HTTPS ไว้ด้านหน้า

info-vllm-digitalocean-gpu-droplet

#vLLM คืออะไร

vLLM คือ LLM inference and serving engine ที่ออกแบบมาเพื่อให้บริการโมเดลภาษาได้อย่างมีประสิทธิภาพ

จุดเด่นที่สำคัญ ได้แก่

  • รองรับการให้บริการ LLM ผ่าน HTTP API
  • มี OpenAI-Compatible API
  • รองรับ Chat Completions, Completions, Responses API และ Embeddings ตามชนิดของโมเดล
  • รองรับ NVIDIA GPU และแพลตฟอร์มเร่งความเร็วอื่น
  • รองรับ Tensor Parallelism สำหรับ Multi-GPU
  • สามารถรันผ่าน Docker ได้
  • เชื่อมต่อกับ Hugging Face models ได้สะดวก
  • เหมาะกับระบบ RAG, AI Agent และ Private LLM

#1. เลือก DigitalOcean GPU Droplet

DigitalOcean มี GPU Droplet หลายระดับ เช่น

GPU VRAM ตัวอย่างงาน
NVIDIA RTX 4000 Ada 20 GB Development, โมเดลขนาดเล็ก-กลาง
NVIDIA RTX 6000 Ada 48 GB LLM Inference, Quantized Models
NVIDIA L40S 48 GB Production Inference
NVIDIA H100 80 GB โมเดลขนาดใหญ่, High Throughput
NVIDIA H200 ขึ้นอยู่กับแผนบริการ โมเดลขนาดใหญ่และงาน Context สูง

ณ ช่วงเวลาที่จัดทำบทความ ราคาหน้า GPU Droplets ของ DigitalOcean ระบุ RTX 4000 Ada ที่ประมาณ $0.76/GPU/hour และ RTX 6000 Ada/L40S ที่ประมาณ $1.57/GPU/hour โดยราคาอาจเปลี่ยนแปลงได้

ตรวจสอบราคาล่าสุดที่:

https://www.digitalocean.com/pricing/gpu-droplets

ตรวจสอบ Region ที่รองรับ GPU แต่ละรุ่นที่:

https://docs.digitalocean.com/products/droplets/details/gpu-availability/

#แนวทางเลือก GPU

สำหรับการทดลองหรือ Workshop:

RTX 4000 Ada
VRAM 20 GB

เหมาะกับโมเดลขนาดเล็กและกลาง เช่น 3B–8B ขึ้นอยู่กับ precision, quantization และ context length

สำหรับ Production ขนาดกลาง:

RTX 6000 Ada
หรือ
L40S

VRAM 48 GB

สำหรับโมเดลขนาดใหญ่หรือมี Concurrent Requests จำนวนมาก:

H100 / H200

ขนาด parameter เพียงอย่างเดียวไม่สามารถบอก VRAM ที่ต้องใช้ได้ทั้งหมด เพราะยังขึ้นอยู่กับ dtype, quantization, KV cache, context length และจำนวน request ที่ประมวลผลพร้อมกัน

#2. สร้าง GPU Droplet

เข้าสู่ DigitalOcean Control Panel

Create
  ↓
GPU Droplet

เลือก NVIDIA GPU ที่ต้องการ

DigitalOcean แนะนำให้ใช้ AI/ML-Ready Image สำหรับ GPU Droplet เพราะมี NVIDIA driver และเครื่องมือที่จำเป็นติดตั้งไว้แล้ว

ณ สิงหาคม 2026 AI/ML-Ready Image สำหรับ NVIDIA ใช้ Ubuntu 24.04 และมีส่วนประกอบสำคัญ เช่น

  • NVIDIA Driver
  • CUDA Toolkit
  • NVIDIA Container Toolkit
  • DCGM Exporter

DigitalOcean ยังมี Inference-Optimized Image ที่มาพร้อม Docker และ vLLM container แต่หากต้องการควบคุมเวอร์ชัน vLLM เอง การใช้ AI/ML-Ready Image ร่วมกับ official vLLM Docker image เป็นแนวทางที่ยืดหยุ่นกว่า

เอกสาร:

https://docs.digitalocean.com/products/droplets/getting-started/recommended-gpu-setup/

#3. เชื่อมต่อ GPU Droplet

หลังจากสร้าง Droplet แล้ว เชื่อมต่อผ่าน SSH

ssh root@DROPLET_IP

ตรวจสอบ GPU

nvidia-smi

หากระบบพร้อมใช้งาน จะเห็นข้อมูล เช่น

NVIDIA Driver
CUDA Version
GPU Model
GPU Memory
GPU Utilization

ตรวจสอบ Docker

docker --version

และ

docker compose version

#4. ทดสอบ Docker ว่าเข้าถึง GPU ได้

ใช้คำสั่ง

docker run --rm \
  --runtime=nvidia \
  --gpus all \
  ubuntu \
  nvidia-smi

หาก Container มองเห็น GPU แสดงว่า NVIDIA Container Runtime พร้อมใช้งาน

#5. เตรียม Project Directory

สร้าง directory สำหรับ vLLM

mkdir -p /opt/vllm/hf-cache
cd /opt/vllm

โครงสร้างจะเป็น

/opt/vllm
├── compose.yaml
├── .env
└── hf-cache/

โฟลเดอร์ hf-cache ใช้เก็บโมเดลจาก Hugging Face เพื่อไม่ต้องดาวน์โหลดใหม่ทุกครั้งที่ restart container

#6. สร้าง API Key

สร้าง key ด้วย OpenSSL

openssl rand -hex 32

อย่านำ API Key ไปเขียนตรง ๆ ใน Source Code หรือ Git Repository

#7. สร้างไฟล์ .env

nano .env

กำหนดค่า

HF_TOKEN=YOUR_HUGGING_FACE_TOKEN
VLLM_API_KEY=YOUR_VLLM_API_KEY

จากนั้นจำกัดสิทธิ์ไฟล์

chmod 600 .env

#HF_TOKEN จำเป็นหรือไม่

หากใช้ Public Model บางรุ่น อาจไม่จำเป็นต้องกำหนด Token

แต่หากใช้

  • Gated Model
  • Private Model
  • โมเดลที่ต้อง Accept License

ควรกำหนด Hugging Face Token

#8. สร้าง compose.yaml

ตัวอย่างต่อไปนี้ใช้ Qwen3-4B เป็นโมเดลสาธิต

services:
  vllm:
    image: vllm/vllm-openai:latest
    container_name: vllm
    restart: unless-stopped

    ipc: host

    ports:
      - "127.0.0.1:8000:8000"

    environment:
      HF_TOKEN: ${HF_TOKEN}

    volumes:
      - ./hf-cache:/root/.cache/huggingface

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities:
                - gpu

    command:
      - --model
      - Qwen/Qwen3-4B
      - --served-model-name
      - qwen3-4b
      - --api-key
      - ${VLLM_API_KEY}
      - --dtype
      - auto
      - --max-model-len
      - "8192"
      - --gpu-memory-utilization
      - "0.90"

vLLM มี official Docker image:

vllm/vllm-openai

เอกสาร:

https://docs.vllm.ai/en/latest/deployment/docker/

ใน Production ควรเปลี่ยนจาก latest เป็น version tag ที่ผ่านการทดสอบแล้ว เพื่อป้องกันพฤติกรรมของระบบเปลี่ยนโดยไม่ตั้งใจเมื่อมีการอัปเดต image

#9. ทำความเข้าใจค่าที่สำคัญ

#--model

กำหนด Hugging Face Model

--model Qwen/Qwen3-4B

#--served-model-name

ชื่อโมเดลที่ Client ใช้เรียก API

--served-model-name qwen3-4b

Client จะเรียกด้วย

{
  "model": "qwen3-4b"
}

#--api-key

กำหนด API Key

--api-key ${VLLM_API_KEY}

อย่างไรก็ตาม vLLM ระบุว่า API key authentication ไม่ได้ป้องกันทุก endpoint ดังนั้น Production ควรมี Reverse Proxy, Network Firewall และ access control เพิ่มเติม

#--max-model-len

กำหนด Context Length สูงสุด

--max-model-len 8192

Context ที่สูงขึ้นใช้ VRAM สำหรับ KV Cache มากขึ้น

หากเกิด CUDA Out of Memory สามารถลดเป็น

4096

#--gpu-memory-utilization

ตัวอย่าง

--gpu-memory-utilization 0.90

สำหรับการเริ่มต้น ค่า 0.90 มักเป็นจุดเริ่มต้นที่สะดวก แต่ควร benchmark ตาม workload จริง

#10. ดาวน์โหลด Image และเริ่มระบบ

docker compose pull
docker compose up -d

ตรวจสอบ Container

docker compose ps

ดู Log

docker compose logs -f vllm

ครั้งแรกอาจใช้เวลานาน เนื่องจากต้องดาวน์โหลด Model Weight จาก Hugging Face

#11. ตรวจสอบ GPU ขณะโหลดโมเดล

เปิด Terminal อีกหน้าหนึ่ง

watch -n 1 nvidia-smi

สามารถดู GPU Utilization, VRAM Usage, Processes, Temperature และ Power Usage ได้

#12. ทดสอบ OpenAI-Compatible API

โหลด Environment Variable

set -a
source .env
set +a

ตรวจสอบรายการโมเดล

curl http://127.0.0.1:8000/v1/models \
  -H "Authorization: Bearer ${VLLM_API_KEY}"

#13. ทดสอบ Chat Completions

curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Authorization: Bearer ${VLLM_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-4b",
    "messages": [
      {
        "role": "system",
        "content": "คุณเป็นผู้ช่วยด้าน Software Engineering"
      },
      {
        "role": "user",
        "content": "อธิบาย Retrieval-Augmented Generation"
      }
    ],
    "temperature": 0.3,
    "max_tokens": 500
  }'

#14. เชื่อมต่อจากเครื่อง Client ด้วย SSH Tunnel

ในตัวอย่าง Compose เรา bind port ไว้ที่

127.0.0.1:8000

จึงไม่สามารถเข้าจาก Internet โดยตรง

ใช้ SSH Tunnel ได้

ssh -L 8000:127.0.0.1:8000 root@DROPLET_IP

จากเครื่อง Client ทดสอบ

curl http://localhost:8000/v1/models \
  -H "Authorization: Bearer YOUR_VLLM_API_KEY"

วิธีนี้เหมาะกับ Development และ Administration

#15. เรียก vLLM ด้วย Python OpenAI SDK

ติดตั้ง OpenAI SDK

pip install openai

สร้างไฟล์ app.py

import os

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key=os.environ["VLLM_API_KEY"],
)

response = client.chat.completions.create(
    model="qwen3-4b",
    messages=[
        {
            "role": "system",
            "content": "You are a software engineering assistant.",
        },
        {
            "role": "user",
            "content": "อธิบายความแตกต่างระหว่าง RAG และ Fine-tuning",
        },
    ],
    temperature=0.2,
    max_tokens=500,
)

print(response.choices[0].message.content)

รัน

export VLLM_API_KEY="YOUR_KEY"
python app.py

#16. ใช้ร่วมกับ RAG

vLLM สามารถทำหน้าที่เป็น Generation Server ในระบบ RAG ได้

User
 |
 v
Backend
 |
 +--------> Embedding Model
 |                |
 |                v
 |          Vector Database
 |                |
 |                v
 +-------- Retrieved Context
 |
 v
vLLM
 |
 v
LLM Response

ตัวอย่างเทคโนโลยีที่สามารถนำมาเชื่อมต่อ ได้แก่ FastAPI, LangChain, LangGraph, LlamaIndex, Spring AI, OpenAI SDK, Qdrant, pgvector, Redis และ Milvus

#17. ใช้ร่วมกับ AI Agent

เนื่องจาก vLLM รองรับ OpenAI-Compatible API จึงสามารถนำไปเป็น Model Backend สำหรับ Agent Framework หลายประเภทได้

AI Agent
   |
   v
OpenAI-Compatible Client
   |
   v
https://llm.example.com/v1
   |
   v
vLLM
   |
   v
Local / Open Model

ความสามารถด้าน Tool Calling ขึ้นอยู่กับโมเดลและ configuration ที่เลือกใช้

#18. เปิดใช้งาน Production ด้วย Reverse Proxy

ไม่แนะนำให้เปิด 0.0.0.0:8000 ตรงสู่ Internet

ควรใช้

Internet
   |
   | HTTPS :443
   v
DigitalOcean Firewall
   |
   v
Caddy / Nginx
   |
   v
127.0.0.1:8000
   |
   v
vLLM

#19. ตัวอย่าง Caddy

llm.example.com {
    reverse_proxy 127.0.0.1:8000 {
        flush_interval -1
    }
}

จาก Client

client = OpenAI(
    base_url="https://llm.example.com/v1",
    api_key=os.environ["VLLM_API_KEY"],
)

#20. Firewall ที่แนะนำ

Port Protocol ใช้งาน
22 TCP SSH
80 TCP HTTP / Certificate
443 TCP HTTPS
8000 TCP ไม่ควรเปิด Public

สำหรับ SSH ควรจำกัด Source IP หากทำได้

#21. ข้อควรระวังเกี่ยวกับ vLLM API Key

เอกสาร vLLM ระบุว่า --api-key หรือ VLLM_API_KEY ใช้ป้องกัน endpoint ภายใต้ path บางกลุ่ม เช่น /v1 แต่ไม่ได้ป้องกัน HTTP endpoint ทุกตัว

ดังนั้น Production ไม่ควรอาศัย API Key ของ vLLM เพียงชั้นเดียว

ควรใช้หลายชั้น เช่น

Cloud Firewall
+
Reverse Proxy
+
HTTPS
+
Authentication / API Gateway
+
Network Restriction
+
vLLM API Key

#22. Multi-GPU ด้วย Tensor Parallelism

ถ้า Droplet มีหลาย GPU สามารถกระจายโมเดลด้วย Tensor Parallelism

ตัวอย่าง 8 GPU

command:
  - --model
  - meta-llama/Llama-3.3-70B-Instruct
  - --served-model-name
  - llama-70b
  - --tensor-parallel-size
  - "8"
  - --api-key
  - ${VLLM_API_KEY}
  - --dtype
  - auto
  - --max-model-len
  - "16384"
  - --gpu-memory-utilization
  - "0.90"

เอกสาร:

https://docs.vllm.ai/en/latest/serving/parallelism_scaling/

#23. ปัญหา CUDA Out of Memory

อาการ

CUDA out of memory

แนวทางแรกคือลด Context Length

- --max-model-len
- "4096"

ลดจำนวน sequence ที่ประมวลผลพร้อมกัน

- --max-num-seqs
- "8"

หรือเลือกโมเดลขนาดเล็กลง, Quantized Model, GPU ที่มี VRAM มากขึ้น หรือ Multi-GPU

#24. ตรวจสอบ Hugging Face Token

หากโหลดโมเดลไม่ได้

docker compose exec vllm env | grep HF_TOKEN

หากเป็น Gated Model ให้ตรวจสอบว่า Accept License แล้ว, Token มีสิทธิ์อ่าน Model และ .env ถูกโหลด

Restart

docker compose restart vllm

#25. Docker ไม่พบ GPU

ตรวจสอบบน Host

nvidia-smi

ตรวจสอบ Docker

docker info | grep -i runtime

ทดสอบ

docker run --rm \
  --runtime=nvidia \
  --gpus all \
  ubuntu \
  nvidia-smi

Restart Docker

sudo systemctl restart docker

#26. Monitoring สำหรับ Production

DigitalOcean AI/ML-Ready Image รองรับ NVIDIA DCGM tooling และ DigitalOcean มีแนวทางสำหรับ GPU Metrics

ค่าที่ควรติดตาม ได้แก่

GPU Utilization
GPU Memory
GPU Temperature
Power Usage
Request Rate
Latency
Time to First Token
Tokens / Second
Error Rate
Queue Depth
CPU
RAM
Disk
Network

สำหรับระบบขนาดใหญ่สามารถเชื่อมต่อ

DCGM Exporter
      |
      v
Prometheus
      |
      v
Grafana

เอกสาร:

https://docs.digitalocean.com/products/droplets/how-to/gpu/enable-metrics/

#27. Update vLLM อย่างปลอดภัย

ใน Production ไม่ควร upgrade โดยไม่ทดสอบ

แนวทางที่เหมาะสมคือ

Development
    ↓
Test New vLLM Version
    ↓
Benchmark
    ↓
Regression Test
    ↓
Pin Image Version
    ↓
Production

#28. Backup Configuration

ควร Backup

compose.yaml
Caddyfile
Environment template
Monitoring configuration
Deployment scripts

แต่ไม่ควร Commit

.env
API Keys
HF Tokens
Private Keys

ตัวอย่าง .gitignore

.env
*.key
*.pem
hf-cache/

#29. การควบคุมค่าใช้จ่าย

GPU Cloud มีค่าใช้จ่ายสูงกว่า CPU Droplet อย่างมาก จึงควรเลือก GPU ให้สัมพันธ์กับขนาด Model, benchmark ก่อน Scale Up, ลด Context Length หากไม่จำเป็น และใช้ Quantization เมื่อเหมาะสม

สิ่งสำคัญคือ Power Off ไม่ได้หยุดการคิดค่าบริการ GPU Droplet เพราะ resource ยังคงถูกจองอยู่ ตามเอกสารของ DigitalOcean ต้อง Destroy Droplet จึงจะยุติ billing ของ instance นั้น

รายละเอียด:

https://docs.digitalocean.com/products/droplets/details/pricing/

#30. Production Checklist

[ ] GPU VRAM เพียงพอ
[ ] Model license ถูกต้อง
[ ] HF Token ไม่อยู่ใน Git
[ ] API Key มีความแข็งแรง
[ ] Port 8000 ไม่เปิด Public
[ ] ใช้ HTTPS
[ ] มี Reverse Proxy / API Gateway
[ ] จำกัด SSH Source IP
[ ] มี Firewall
[ ] Pin Docker Image Version
[ ] มี Persistent Model Cache
[ ] มี Monitoring
[ ] มี Log Management
[ ] มี Rate Limiting
[ ] มี Backup Configuration
[ ] มี Benchmark
[ ] มี Load Test
[ ] มีแผน Rollback

#31. Workflow ตั้งแต่ต้นจนจบ

1. Create GPU Droplet
        ↓
2. เลือก AI/ML-Ready Image
        ↓
3. SSH เข้า Server
        ↓
4. ตรวจสอบ nvidia-smi
        ↓
5. ตรวจสอบ Docker + GPU
        ↓
6. สร้าง /opt/vllm
        ↓
7. สร้าง .env
        ↓
8. สร้าง compose.yaml
        ↓
9. docker compose pull
        ↓
10. docker compose up -d
        ↓
11. ทดสอบ /v1/models
        ↓
12. ทดสอบ /v1/chat/completions
        ↓
13. ตั้ง Firewall
        ↓
14. ติดตั้ง Caddy/Nginx
        ↓
15. เปิด HTTPS
        ↓
16. เชื่อม Application / RAG / Agent
        ↓
17. Monitoring + Benchmark

#สรุป

การใช้งาน vLLM บน DigitalOcean GPU Droplet เป็นแนวทางที่เหมาะกับผู้ที่ต้องการสร้าง LLM API ของตนเอง โดยไม่ต้องพึ่ง Hosted LLM API เพียงอย่างเดียว

องค์ประกอบหลักของระบบคือ

DigitalOcean GPU Droplet
        +
NVIDIA GPU
        +
Docker
        +
vLLM
        +
OpenAI-Compatible API
        +
Caddy / Nginx
        +
HTTPS

เมื่อสร้างระบบเสร็จ สามารถนำ API ไปเชื่อมต่อกับ Web Application, Mobile Application, RAG, AI Chatbot, AI Agent, Multi-Agent System, LangChain, LangGraph, LlamaIndex, Spring AI, FastAPI, Node.js หรือ Laravel ได้

หลักสำคัญไม่ใช่เพียงแค่ “รันโมเดลได้” แต่ต้องคำนึงถึง Security, VRAM, Throughput, Latency, Monitoring และ Cost ไปพร้อมกัน

#References

  1. DigitalOcean GPU Droplets
    https://docs.digitalocean.com/products/gpu-droplets/

  2. DigitalOcean GPU Droplet Pricing
    https://www.digitalocean.com/pricing/gpu-droplets

  3. DigitalOcean GPU Availability by Region
    https://docs.digitalocean.com/products/droplets/details/gpu-availability/

  4. DigitalOcean Recommended Drivers and Software for GPU Droplets
    https://docs.digitalocean.com/products/droplets/getting-started/recommended-gpu-setup/

  5. DigitalOcean GPU Monitoring with DCGM
    https://docs.digitalocean.com/products/droplets/how-to/gpu/enable-metrics/

  6. vLLM Docker Deployment
    https://docs.vllm.ai/en/latest/deployment/docker/

  7. vLLM OpenAI-Compatible Server
    https://docs.vllm.ai/en/latest/serving/online_serving/openai_compatible_server/

  8. vLLM Parallelism and Scaling
    https://docs.vllm.ai/en/latest/serving/parallelism_scaling/