Posted inAI

Triển khai AI model trên server riêng: Self-host để bảo vệ dữ liệu nhạy cảm

Artificial Intelligence tutorial - IT technology blog
Artificial Intelligence tutorial - IT technology blog

Vấn đề: Khi AI cloud trở thành rủi ro bảo mật

Mình làm việc ở team DevOps từ hồi API của OpenAI còn chưa phổ biến. Khi các anh em trong team bắt đầu dùng ChatGPT để hỗ trợ code review, debug lỗi production, thậm chí paste cả log server lên để hỏi AI — mình bắt đầu lo.

Dữ liệu đó đi đâu? Có bị dùng để train model không? Với hợp đồng khách hàng yêu cầu dữ liệu phải nằm trong nội bộ, việc dùng cloud AI thực sự là rủi ro pháp lý, không chỉ là rủi ro kỹ thuật. Một số dự án còn yêu cầu tuân thủ GDPR hoặc ISO 27001 — paste thông tin vào ChatGPT là vi phạm thẳng điều khoản.

Giải pháp mình chọn: self-host AI model trên server riêng.

Khái niệm cốt lõi: Self-host AI là gì và cần gì?

Nói đơn giản: thay vì gọi lên server của OpenAI hay Anthropic, bạn chạy model ngay trên máy chủ của mình — VPS, dedicated server, hoặc on-premise. Dữ liệu xử lý tại chỗ, không rời khỏi hạ tầng nội bộ.

Ưu điểm thực tế:

  • Dữ liệu không rời khỏi server của bạn
  • Chi phí cố định, không phụ thuộc token pricing
  • Có thể fine-tune model theo domain riêng
  • Không bị rate limit hay downtime từ provider

Nhược điểm cần biết trước:

  • Cần GPU tốt để chạy model lớn (CPU chạy được nhưng chậm hơn 3-5x)
  • Phải tự quản lý updates, security patches
  • Model 7B-8B thường thua kém GPT-4o về reasoning phức tạp — muốn ngang ngửa thì cần model 70B trở lên

Bài này mình tập trung vào llama.cpp (cho server CPU hoặc GPU nhỏ) và vLLM (cho production GPU server) — hai tool mình đã dùng thực tế trên môi trường production.

Thực hành chi tiết

Phần 1: Self-host với llama.cpp (phù hợp VPS CPU hoặc GPU nhỏ)

llama.cpp cho phép chạy model dạng GGUF — đã quantize để giảm RAM và tăng tốc độ. Mình đang chạy Mistral 7B Q4_K_M trên VPS 32GB RAM. Tốc độ generate khoảng 8–12 token/giây trên CPU 16 core — đủ cho chat nội bộ, không phù hợp batch processing lớn.

Bước 1: Cài đặt llama.cpp với Docker

# Pull image chính thức (có sẵn CUDA support)
docker pull ghcr.io/ggerganov/llama.cpp:server

# Hoặc build từ source nếu cần tùy chỉnh
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make -j$(nproc)          # CPU build
# make LLAMA_CUDA=1 -j$(nproc)  # CUDA build

Bước 2: Tải model GGUF từ Hugging Face

# Tạo thư mục chứa model
mkdir -p /opt/ai-models

# Tải model Mistral 7B quantize Q4_K_M
pip install huggingface-hub
huggingface-cli download \
  bartowski/Mistral-7B-Instruct-v0.3-GGUF \
  Mistral-7B-Instruct-v0.3-Q4_K_M.gguf \
  --local-dir /opt/ai-models

Bước 3: Chạy server

docker run -d \
  --name llama-server \
  -v /opt/ai-models:/models \
  -p 127.0.0.1:8080:8080 \
  ghcr.io/ggerganov/llama.cpp:server \
  -m /models/Mistral-7B-Instruct-v0.3-Q4_K_M.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  --ctx-size 4096 \
  --n-predict 2048 \
  --threads $(nproc)

Lưu ý: mình bind port lên 127.0.0.1 thay vì 0.0.0.0 — chỉ nghe local, không expose trực tiếp ra internet.

Kiểm tra server hoạt động:

curl http://localhost:8080/v1/models

# Test inference
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral",
    "messages": [{"role": "user", "content": "Giải thích Docker volume là gì?"}]
  }'

Phần 2: Self-host với vLLM (cho GPU server production)

Có GPU server? vLLM xứng đáng được xem xét nghiêm túc. Throughput cao hơn llama.cpp khoảng 5–10x nhờ continuous batching và PagedAttention — NVIDIA A10, A100, hoặc RTX 3090+ đều chạy tốt.

# Cài vLLM
pip install vllm

# Chạy server với Llama 3 8B
python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Meta-Llama-3-8B-Instruct \
  --host 127.0.0.1 \
  --port 8000 \
  --max-model-len 4096 \
  --dtype auto

vLLM dùng API format tương thích OpenAI. Đổi base_url là xong — không cần đụng vào logic xử lý response.

Phần 3: Bảo mật — phần quan trọng nhất

Self-host mà không có security thì còn nguy hiểm hơn dùng cloud. Đây là setup mình áp dụng trên production: Nginx reverse proxy với API key authentication.

# /etc/nginx/sites-available/ai-api
server {
    listen 443 ssl;
    server_name ai-api.internal.yourdomain.com;

    ssl_certificate /etc/ssl/certs/internal.crt;
    ssl_certificate_key /etc/ssl/private/internal.key;

    location / {
        # Kiểm tra API key
        if ($http_authorization != "Bearer YOUR_INTERNAL_API_KEY") {
            return 401 '{"error": "Unauthorized"}';
        }

        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_read_timeout 300s;  # LLM cần timeout dài hơn
    }
}

Firewall rules:

# Block port llama.cpp trực tiếp từ bên ngoài
ufw deny 8080
# Chỉ cho phép internal network kết nối qua HTTPS
ufw allow from 10.0.0.0/8 to any port 443
ufw allow from 192.168.0.0/16 to any port 443
ufw logging on

Docker Compose hoàn chỉnh cho production:

# docker-compose.yml
version: '3.8'

services:
  llama-server:
    image: ghcr.io/ggerganov/llama.cpp:server
    restart: unless-stopped
    volumes:
      - /opt/ai-models:/models:ro  # Read-only
    ports:
      - "127.0.0.1:8080:8080"  # Chỉ bind localhost
    command: >
      -m /models/Mistral-7B-Instruct-v0.3-Q4_K_M.gguf
      --host 0.0.0.0
      --port 8080
      --ctx-size 4096
      --threads 8
    deploy:
      resources:
        limits:
          memory: 16G
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"

Monitoring đơn giản với cron:

#!/bin/bash
# /opt/scripts/check-ai-server.sh
RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/v1/models)
if [ "$RESPONSE" != "200" ]; then
    echo "AI Server DOWN at $(date)" >> /var/log/ai-monitor.log
    docker restart llama-server
fi
# Thêm vào crontab
*/5 * * * * /opt/scripts/check-ai-server.sh

Phần 4: Kết nối từ code Python

Điểm hay của cả hai tool là chúng đều dùng OpenAI API format. Bạn chỉ cần đổi base_url — không phải rewrite logic gì cả:

from openai import OpenAI

# Trỏ đến server nội bộ thay vì OpenAI
client = OpenAI(
    api_key="YOUR_INTERNAL_API_KEY",
    base_url="https://ai-api.internal.yourdomain.com/v1"
)

response = client.chat.completions.create(
    model="mistral",  # Tên model trên llama.cpp
    messages=[
        {"role": "system", "content": "Bạn là AI assistant cho team DevOps."},
        {"role": "user", "content": "Review đoạn Dockerfile này cho mình..."}
    ]
)

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

Kết luận: Self-host có đáng không?

Mình chạy setup này trên production được 8 tháng. Uptime 99.7%, chưa có sự cố nào ảnh hưởng đến team. Chi phí server GPU thêm khoảng $200/tháng nhưng tiết kiệm được hơn $500 API cost — và quan trọng hơn là team thoải mái paste log, config, database schema vào AI mà không lo dữ liệu rò rỉ.

Nên self-host khi:

  • Team xử lý dữ liệu nhạy cảm (y tế, tài chính, hợp đồng pháp lý)
  • Cần compliance với GDPR, ISO 27001, hoặc yêu cầu nội địa hóa dữ liệu
  • Volume request đủ lớn để amortize chi phí server
  • Team có DevOps/SRE chăm sóc infrastructure

Nên dùng cloud API khi:

  • Team nhỏ, request ít, không có người quản lý server
  • Cần model mạnh nhất (GPT-4o, Claude Opus) cho task phức tạp
  • Đang ở giai đoạn prototype, chưa cần lo compliance

Self-host AI không phải lựa chọn phù hợp cho mọi team — nhưng với dự án enterprise có yêu cầu bảo mật cao, đây là bài toán hoàn toàn khả thi, kể cả khi team DevOps của bạn chỉ 2-3 người.

Share:
Tags: