Docker vs Kubernetes: Khi nào cần Kubernetes thực sự?

Năm 2022, tôi join một startup. CTO nói: “Chúng ta dùng Kubernetes.”

Tôi hỏi: “Traffic bao nhiêu?”

“Khoảng 100 requests/phút.”

“Bao nhiêu servers?”

“2 servers.”

Đó là overkill.

Sau 6 tháng maintain K8s cluster cho 2 servers, chúng tôi migrate về Docker Compose. Deployment time giảm từ 30 phút xuống 2 phút.

Đây là bài học tôi học được.

Docker vs Kubernetes: Không phải so sánh táo với cam

Docker:

• Container runtime
• Chạy containers trên 1 server
• Đơn giản, dễ học

Kubernetes:

• Container orchestration platform
• Quản lý containers trên nhiều servers
• Phức tạp, learning curve dốc

Analogy:

• Docker = Xe ô tô
• Kubernetes = Hệ thống quản lý đội xe taxi (routing, scaling, monitoring)

Khi nào Docker Compose là đủ?

Scenario 1: Small to Medium Apps

Specs:

• 1-3 servers
• < 1000 requests/phút
• Downtime 5-10 phút/tháng là acceptable

Example: Blog/CMS

# docker-compose.yml
version: '3.8'
services:
  app:
    image: myapp:latest
    ports:
      - "80:80"
    environment:
      - DB_HOST=db
    depends_on:
      - db
      - redis
  
  db:
    image: postgres:15
    volumes:
      - db_data:/var/lib/postgresql/data
  
  redis:
    image: redis:7
    
volumes:
  db_data:

Deployment:

docker-compose pull
docker-compose up -d

Pros:

• Đơn giản
• Deploy nhanh (< 1 phút)
• Dễ debug

Cons:

• Không auto-scale
• Downtime khi deploy
• Single point of failure

Verdict: Đủ cho 80% projects.

Scenario 2: Multi-server (nhưng không cần auto-scale)

Specs:

• 3-5 servers
• Traffic ổn định
• Cần load balancing

Solution: Docker Compose + Traefik

# docker-compose.yml
version: '3.8'
services:
  traefik:
    image: traefik:v2.10
    command:
      - "--providers.docker=true"
      - "--entrypoints.web.address=:80"
    ports:
      - "80:80"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
  
  app:
    image: myapp:latest
    deploy:
      replicas: 3  # 3 instances
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.app.rule=Host(`example.com`)"

Pros:

• Load balancing tự động
• Vẫn đơn giản hơn K8s
• Zero-downtime deployment (rolling update)

Cons:

• Không auto-scale theo traffic
• Phải manage servers manually

Verdict: Tốt cho medium apps (< 10 servers).

Khi nào thực sự CẦN Kubernetes?

Use Case 1: Auto-scaling theo traffic

Scenario: E-commerce site với traffic spike (Black Friday, flash sale)

Requirement:

• Normal: 100 requests/s → 5 pods
• Peak: 10,000 requests/s → 50 pods
• Auto-scale up/down

K8s Solution:

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 5
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: app
        image: myapp:latest
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 512Mi
---
# hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 5
  maxReplicas: 50
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Kết quả: K8s tự động scale từ 5 → 50 pods khi CPU > 70%.

Docker Compose: Không làm được. Phải scale manually.

Use Case 2: Multi-region Deployment

Scenario: Global app cần deploy ở US, EU, Asia

Requirement:

• Mỗi region có cluster riêng
• Failover tự động nếu 1 region down
• Centralized management

K8s Solution:

# Multi-cluster setup với Istio/Linkerd
apiVersion: v1
kind: Service
metadata:
  name: myapp
spec:
  type: LoadBalancer
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080

Docker Compose: Phải setup manually cho mỗi region.

Use Case 3: Complex Microservices

Scenario: 20+ microservices với dependencies phức tạp

Requirement:

• Service discovery
• Health checks
• Circuit breakers
• Distributed tracing

K8s Solution:

# Service mesh với Istio
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: myapp
spec:
  hosts:
  - myapp
  http:
  - match:
    - headers:
        version:
          exact: v2
    route:
    - destination:
        host: myapp
        subset: v2
  - route:
    - destination:
        host: myapp
        subset: v1
      weight: 90
    - destination:
        host: myapp
        subset: v2
      weight: 10  # Canary deployment

Docker Compose: Có thể làm, nhưng phức tạp và thiếu features.

Cost Comparison

Docker Compose Setup

Infrastructure:

• 3 servers (4GB RAM, 2 CPU): $30/tháng
• Load balancer: $10/tháng
• Total: $40/tháng

Time:

• Setup: 2 giờ
• Maintenance: 2 giờ/tháng

Kubernetes Setup

Infrastructure:

• Control plane (managed): $70/tháng
• 3 worker nodes (4GB RAM, 2 CPU): $30/tháng
• Load balancer: $10/tháng
• Total: $110/tháng

Time:

• Setup: 20 giờ (learning + config)
• Maintenance: 10 giờ/tháng (updates, troubleshooting)

Verdict: K8s đắt gấp 3 lần về cost và time.

Alternatives: Middle Ground

1. Docker Swarm

Pros:

• Đơn giản hơn K8s
• Built-in Docker
• Auto-scaling (basic)

Cons:

• Ecosystem nhỏ hơn K8s
• Ít features hơn

Use case: Team nhỏ, cần orchestration đơn giản.

# Init swarm
docker swarm init

# Deploy stack
docker stack deploy -c docker-compose.yml myapp

# Scale
docker service scale myapp_app=10

2. Nomad (HashiCorp)

Pros:

• Đơn giản hơn K8s
• Flexible (chạy containers, VMs, binaries)
• Tích hợp tốt với Consul, Vault

Cons:

• Ecosystem nhỏ hơn K8s

Use case: Multi-cloud, hybrid workloads.

3. Managed Services

AWS ECS/Fargate:

• Đơn giản hơn K8s
• Serverless containers
• Tích hợp tốt với AWS services

Google Cloud Run:

• Serverless containers
• Auto-scale to zero
• Pay per request

Use case: Muốn orchestration nhưng không muốn manage infrastructure.

Decision Tree

Bạn cần deploy containers?
├─ Yes
│  ├─ Bao nhiêu servers?
│  │  ├─ 1-2 servers
│  │  │  └─ Docker Compose
│  │  ├─ 3-10 servers
│  │  │  ├─ Traffic ổn định?
│  │  │  │  ├─ Yes → Docker Compose + Traefik
│  │  │  │  └─ No (có spikes) → Kubernetes hoặc ECS
│  │  └─ > 10 servers
│  │     └─ Kubernetes
│  ├─ Cần auto-scaling?
│  │  ├─ Yes → Kubernetes hoặc Cloud Run
│  │  └─ No → Docker Compose
│  └─ Multi-region?
│     ├─ Yes → Kubernetes
│     └─ No → Docker Compose hoặc Swarm
└─ No → Traditional deployment

Migration Path

Đừng nhảy thẳng vào K8s. Follow path:

1. Start: Docker Compose

   • Deploy lên 1-2 servers
   • Learn containers

2. Scale: Docker Compose + Load Balancer

   • Deploy lên 3-5 servers
   • Add Traefik/Nginx

3. Evaluate: Có thực sự cần K8s?

   • Traffic có spike không?
   • Cần auto-scale không?
   • Team có bandwidth maintain K8s không?

4. If Yes: Migrate to K8s

   • Start với managed K8s (GKE, EKS, AKS)
   • Migrate từng service một
   • Monitor và optimize

5. If No: Stick với Docker Compose

   • Đơn giản hơn
   • Rẻ hơn
   • Đủ cho majority of use cases

Kết luận

Docker Compose đủ khi:

• < 10 servers
• Traffic ổn định
• Team nhỏ
• Downtime 5-10 phút/tháng OK

Kubernetes cần khi:

• 10 servers hoặc multi-region

• Auto-scaling critical
• Zero-downtime deployment bắt buộc
• Complex microservices

Lời khuyên:

• Đừng dùng K8s vì “cool” hoặc “CV đẹp”
• Start simple, scale khi cần
• K8s là tool, không phải goal

Rule of thumb: Nếu bạn đang hỏi “Có cần K8s không?”, câu trả lời thường là “Chưa cần”.

Dùng Docker Compose cho đến khi nó không đủ nữa. Lúc đó, bạn sẽ biết chính xác tại sao cần K8s.