Microservices Trên 1 VPS Với Docker Compose: 10 Service Không Cần Kubernetes

Năm 2023 tôi nhận maintain một SaaS nho nhỏ từ anh bạn. 3 service (auth, API, worker), chạy bằng PM2 trên 1 VPS. "Có gì khó đâu," tôi nghĩ. 3 tháng sau, user tăng gấp 5, tôi tự tách API thành 6 microservices. Lúc đó PM2 bắt đầu lòi ra vấn đề: port conflict, env variable rối nùi, dependency giữa các service không kiểm soát được, một service leak RAM kéo theo OOM kill giết luôn service bên cạnh.

Giải pháp: Docker Compose. KHÔNG phải Kubernetes. Bài này là toàn bộ hành trình tôi chuyển 1 project từ PM2 monolithic lên Docker Compose 10 microservices — những gì hoạt động, những gì suýt giết production, và tại sao bạn có thể chưa cần Kubernetes.

Tại Sao Docker Compose, Không Phải Kubernetes?

Đây là câu hỏi tôi được hỏi nhiều nhất. Câu trả lời ngắn: Kubernetes cho 1 VPS giống như dùng xe tải chở 1 thùng mì.

Nếu bạn có 1 VPS và dưới 20 service: Docker Compose. Nếu bạn có 3 VPS trở lên và cần auto-scale, zero-downtime deploy: Kubernetes. Đơn giản vậy thôi.

Kiến Trúc Thực Tế: 10 Service Trên 1 VPS 4GB RAM

Đây là stack tôi đang chạy cho một web app bán hàng nho nhỏ:

Docker Network: app_network (bridge, internal DNS)

┌─────────────────────────────────────────────────┐
│                  NGINX (port 80/443)             │
│            Reverse Proxy + SSL Terminate         │
└────┬────┬────┬────┬────┬────┬────┬────┬────┬────┘
     │    │    │    │    │    │    │    │    │
     ▼    ▼    ▼    ▼    ▼    ▼    ▼    ▼    ▼    ▼
  ┌────┐┌────┐┌────┐┌────┐┌────┐┌────┐┌────┐┌────┐┌────┐┌────┐
  │Auth││API ││Wrk││Cron││WS ││Adm││PG ││Rds││Rab││Mel│
  │Svc ││Svc ││Svc││Svc ││Svc││Svc││DB ││Cch││MQ ││Svc│
  └────┘└────┘└────┘└────┘└────┘└────┘└────┘└────┘└────┘└────┘
  Node  Node  Node  Node   Go   Remix  Pstg  Rds  Rbbt Minio
  3001  3002  3003  3004   3005  3006   5432  6379 5672  9000

10 service, chạy trên VPS 4GB RAM, CPU load trung bình 25%. Tổng chi phí: 160K VPS + 0K orchestration = 160K/tháng. Nếu dùng managed Kubernetes (GKE/EKS) thì riêng control plane đã $70/tháng (~1.8 triệu), chưa tính node.

docker-compose.yml Production: Từng Dòng Một

Đây không phải file mẫu "Hello World". Đây là config tôi đang chạy thật. Tôi giải thích từng phần.

version: "3.8"

# ===== NETWORK =====
networks:
  app_network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.28.0.0/16
  # Database network riêng — không expose ra app_network
  db_network:
    driver: bridge
    internal: true  # Không có internet access

# ===== VOLUMES =====
volumes:
  postgres_data:
    driver: local
  redis_data:
    driver: local
  rabbitmq_data:
    driver: local
  minio_data:
    driver: local
  nginx_logs:
    driver: local

# ===== SERVICES =====
services:
  # 1. NGINX Reverse Proxy
  nginx:
    image: nginx:1.25-alpine
    container_name: prod_nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/conf.d:/etc/nginx/conf.d:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
      - nginx_logs:/var/log/nginx
    networks:
      - app_network
    depends_on:
      - auth_service
      - api_service
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 256M
        reservations:
          cpus: "0.25"
          memory: 128M

  # 2. Auth Service (Node.js + JWT)
  auth_service:
    build:
      context: ./services/auth
      dockerfile: Dockerfile
    container_name: prod_auth
    restart: unless-stopped
    expose:
      - "3001"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://${DB_USER}:${DB_PASS}@postgres:5432/${DB_NAME}
      - REDIS_URL=redis://redis:6379
      - JWT_SECRET=${JWT_SECRET}
    networks:
      - app_network
      - db_network
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3001/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 15s
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M
        reservations:
          cpus: "0.25"
          memory: 256M

  # 3. API Service (Node.js + Express)
  api_service:
    build:
      context: ./services/api
      dockerfile: Dockerfile
    container_name: prod_api
    restart: unless-stopped
    expose:
      - "3002"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://${DB_USER}:${DB_PASS}@postgres:5432/${DB_NAME}
      - REDIS_URL=redis://redis:6379
      - RABBITMQ_URL=amqp://${RABBIT_USER}:${RABBIT_PASS}@rabbitmq:5672
      - MINIO_ENDPOINT=minio
      - MINIO_PORT=9000
    networks:
      - app_network
      - db_network
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
      rabbitmq:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3002/health"]
      interval: 30s
      timeout: 5s
      retries: 3
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 1G
        reservations:
          cpus: "0.5"
          memory: 512M

  # 4. PostgreSQL 15
  postgres:
    image: postgres:15-alpine
    container_name: prod_postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASS}
      - POSTGRES_DB=${DB_NAME}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - db_network  # Chỉ nối vào db_network, không expose ra app_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
        reservations:
          cpus: "0.5"
          memory: 256M
    command: 
      - "postgres"
      - "-c"
      - "shared_buffers=128MB"
      - "-c"
      - "effective_cache_size=384MB"

  # 5. Redis 7
  redis:
    image: redis:7-alpine
    container_name: prod_redis
    restart: unless-stopped
    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
    volumes:
      - redis_data:/data
    networks:
      - db_network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 384M
        reservations:
          cpus: "0.25"
          memory: 128M

  # 6. RabbitMQ
  rabbitmq:
    image: rabbitmq:3.12-management-alpine
    container_name: prod_rabbitmq
    restart: unless-stopped
    environment:
      - RABBITMQ_DEFAULT_USER=${RABBIT_USER}
      - RABBITMQ_DEFAULT_PASS=${RABBIT_PASS}
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    networks:
      - db_network
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "check_port_connectivity"]
      interval: 30s
      timeout: 10s
      retries: 5
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M
        reservations:
          cpus: "0.25"
          memory: 256M

  # 7. MinIO (S3-compatible storage)
  minio:
    image: minio/minio:latest
    container_name: prod_minio
    restart: unless-stopped
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=${MINIO_USER}
      - MINIO_ROOT_PASSWORD=${MINIO_PASS}
    volumes:
      - minio_data:/data
    networks:
      - db_network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 5s
      retries: 3
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M

  # 8. Worker Service (xử lý job queue)
  worker_service:
    build:
      context: ./services/worker
      dockerfile: Dockerfile
    container_name: prod_worker
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - RABBITMQ_URL=amqp://${RABBIT_USER}:${RABBIT_PASS}@rabbitmq:5672
      - MINIO_ENDPOINT=minio
    networks:
      - db_network
    depends_on:
      rabbitmq:
        condition: service_healthy
      minio:
        condition: service_healthy
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M

  # 9. Cron Service (scheduled tasks)
  cron_service:
    build:
      context: ./services/cron
      dockerfile: Dockerfile
    container_name: prod_cron
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://${DB_USER}:${DB_PASS}@postgres:5432/${DB_NAME}
    networks:
      - db_network
    depends_on:
      postgres:
        condition: service_healthy
    deploy:
      resources:
        limits:
          cpus: "0.25"
          memory: 256M

  # 10. Melisearch (full-text search)
  meilisearch:
    image: getmeili/meilisearch:v1.5
    container_name: prod_meilisearch
    restart: unless-stopped
    environment:
      - MEILI_MASTER_KEY=${MEILI_KEY}
      - MEILI_ENV=production
      - MEILI_NO_ANALYTICS=true
    volumes:
      - meili_data:/meili_data
    networks:
      - db_network
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M

5 Gotcha Production Khi Dùng Docker Compose

So Sánh Các Phương Án Orchestration Trên VPS

Deploy Flow: Từ Git Push Đến Production

Đây là flow deploy tôi dùng — đơn giản, không cần CI/CD phức tạp:

# Trên máy dev: push code lên Git
git push origin main

# SSH vào VPS, pull + deploy
ssh user@vps-ip
cd /opt/app

# Pull code mới
git pull origin main

# Build image mới (chỉ build service thay đổi)
docker compose build api_service worker_service

# Zero-downtime restart: scale lên 2 instance, đợi healthy, scale cũ xuống
docker compose up -d --scale api_service=2 --no-recreate nginx postgres redis
# Đợi instance mới healthy (10s)
sleep 10
docker compose up -d --scale api_service=1 --no-recreate

# Cleanup image cũ (giữ 2 version gần nhất)
docker image prune -a --filter "until=48h" -f

Monitoring + Logging Cho Docker Compose Stack

Không có Kubernetes dashboard, bạn cần tool riêng. Đây là stack monitoring tôi dùng trên cùng VPS:

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "127.0.0.1:9090:9090"
  
  grafana:
    image: grafana/grafana
    ports:
      - "127.0.0.1:3030:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASS}
  
  # Loki + Promtail cho log aggregation
  loki:
    image: grafana/loki:2.9
  
  promtail:
    image: grafana/promtail:2.9
    volumes:
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - ./promtail-config.yml:/etc/promtail/config.yml

Đọc thêm: Hướng dẫn Monitoring VPS với Prometheus + Grafana và Quản lý Log Docker với Loki + Grafana.

Khi Nào Nên Lên Kubernetes?

Tôi không anti-Kubernetes. Tôi anti-Kubernetes-cho-mọi-thứ. Đây là checklist để bạn biết đã đến lúc migrate chưa:

• Bạn có 3+ server và cần phân phối service giữa các node
• Bạn cần auto-scale theo CPU/memory/requests (HPA)
• Bạn cần deploy zero-downtime với canary/blue-green mặc định
• Team bạn có 1+ người chuyên DevOps (k8s không phải "cài xong để đó")
• Bạn cần secret management tập trung (Vault, Sealed Secrets)
• Bill VPS hàng tháng đã vượt 3-5 triệu và optimize riêng lẻ không đủ

Nếu chưa đạt ít nhất 3/6 tiêu chí trên: Docker Compose vẫn là bạn thân.

Chi Phí Thực Tế: Docker Compose vs Kubernetes

Khác biệt 15x giữa Docker Compose và managed Kubernetes. Với 160K/tháng, bạn có thể chạy 10 services + database + cache + queue + storage + monitoring. Cùng stack đó trên GKE: 2.5 triệu/tháng. Với startup nhỏ, đó là cả một khoản tiết kiệm khổng lồ.