Docker Swarm คืออะไร? Container Orchestration ที่ง่ายกว่า Kubernetes สำหรับทีมเล็ก 2026

Docker Swarm คืออะไร? ทำไมถึงยังน่าสนใจในปี 2026

ในโลกของ Container Orchestration หลายคนรู้จักแค่ Kubernetes (K8s) แต่จริงๆ แล้วยังมีเครื่องมืออีกตัวหนึ่งที่ทรงพลังแต่ง่ายกว่ามาก นั่นคือ Docker Swarm ซึ่งเป็นฟีเจอร์ที่ถูกสร้างมาให้เป็นส่วนหนึ่งของ Docker Engine โดยตรง ไม่ต้องติดตั้งเพิ่มเติมใดๆ ทั้งสิ้น

Docker Swarm ถูกออกแบบมาเพื่อให้การจัดการ container หลายตัวบนหลายเครื่องเซิร์ฟเวอร์เป็นเรื่องง่ายที่สุดเท่าที่จะเป็นไปได้ โดยเฉพาะสำหรับทีมพัฒนาขนาดเล็กที่ไม่ต้องการความซับซ้อนของ Kubernetes แต่ยังต้องการความสามารถในการ scale แอปพลิเคชัน ทำ load balancing และบริหาร container จำนวนมากได้อย่างอัตโนมัติ

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

Docker Swarm ต่างจาก Docker ปกติอย่างไร

Docker ปกติ (standalone mode) ทำงานบนเครื่องเดียว คุณสร้าง container, จัดการ network, จัดเก็บ volume ทุกอย่างอยู่บนเครื่องเดียว แต่เมื่อแอปพลิเคชันโตขึ้น คุณต้องการหลายเครื่องเซิร์ฟเวอร์ทำงานร่วมกัน นั่นคือจุดที่ Docker Swarm เข้ามาแก้ปัญหา

Docker Swarm เปลี่ยน Docker Engine หลายตัวให้กลายเป็น cluster เดียว ทำให้คุณสามารถ deploy แอปพลิเคชันไปยังหลายเครื่องพร้อมกันด้วยคำสั่งเดียว โดย Swarm จะจัดการเรื่องการกระจายโหลด การดูแลให้ container ทำงานตลอดเวลา และอื่นๆ ให้โดยอัตโนมัติ

สิ่งที่ทำให้ Docker Swarm แตกต่างคือ มันถูกรวมเข้ากับ Docker Engine โดยตรง ไม่ต้องติดตั้งซอฟต์แวร์เพิ่มเติม ไม่ต้องเรียนรู้เครื่องมือใหม่ หากคุณเขียน docker-compose.yml ได้ คุณก็พร้อมใช้ Docker Swarm แล้ว

Docker Swarm vs Kubernetes: เปรียบเทียบความซับซ้อน

Kubernetes เป็นระบบ Container Orchestration ที่ทรงพลังที่สุดในปัจจุบัน แต่ความทรงพลังนั้นมาพร้อมกับความซับซ้อนมหาศาล มาดูการเปรียบเทียบกัน

ด้านการติดตั้ง

Docker Swarm: เปิดใช้งานด้วยคำสั่งเดียว docker swarm init ไม่ต้องติดตั้งอะไรเพิ่ม ใช้เวลาไม่ถึง 5 นาทีก็พร้อมใช้งาน

Kubernetes: ต้องติดตั้ง kubeadm, kubectl, kubelet, Container Runtime, CNI plugin, etcd และอีกหลายส่วนประกอบ กว่าจะ setup เสร็จอาจใช้เวลาหลายชั่วโมงถึงหลายวัน

ด้าน Learning Curve

Docker Swarm: หากคุณรู้ Docker อยู่แล้ว คุณสามารถเรียนรู้ Swarm ได้ภายใน 1-2 วัน Concept ทุกอย่างคล้ายคลึงกับ Docker Compose ที่คุณคุ้นเคย

Kubernetes: ต้องเรียนรู้ Concept ใหม่มากมาย ทั้ง Pod, Deployment, Service, Ingress, ConfigMap, Secret, RBAC, Namespace, PersistentVolume, StorageClass และอีกนับสิบ ใช้เวลาเรียนรู้หลายสัปดาห์ถึงเดือน

ด้านไฟล์ Configuration

Docker Swarm: ใช้ docker-compose.yml ที่คุณคุ้นเคยอยู่แล้ว เพิ่ม section deploy เข้าไปเล็กน้อย ไฟล์มักมีไม่กี่สิบบรรทัด

Kubernetes: ต้องเขียน YAML หลายไฟล์ ทั้ง Deployment, Service, Ingress, ConfigMap ฯลฯ ไฟล์ configuration อาจมีรวมกันหลายร้อยบรรทัด

ด้านทรัพยากร

Docker Swarm: ใช้ RAM น้อยกว่ามาก สามารถรันบน VPS ราคาถูก (2GB RAM ก็ใช้ได้) เหมาะกับงบจำกัด

Kubernetes: Control plane ต้องการ RAM อย่างน้อย 2GB per node และ worker node ก็ต้องการเพิ่มเติม ค่าใช้จ่ายโดยรวมสูงกว่ามาก

เมื่อไหร่ที่ Docker Swarm เพียงพอ

Docker Swarm เหมาะกับสถานการณ์ต่อไปนี้อย่างยิ่ง และคุณไม่จำเป็นต้องใช้ Kubernetes เลย

ทีมขนาดเล็ก (1-10 คน): เมื่อทีมมีคนไม่มาก ทุกคนต้องทำหลายอย่าง ไม่มีเวลาไปเรียนรู้ Kubernetes อย่างลึกซึ้ง Swarm ให้ความสามารถ 80% ที่ต้องการด้วยความซับซ้อน 20% ของ K8s

แอปพลิเคชันที่ไม่ซับซ้อน: Web API, เว็บไซต์ทั่วไป, Microservice จำนวนไม่มาก ที่ไม่ต้องการ auto-scaling ที่ซับซ้อนหรือ custom resource definitions

จำนวน Container น้อยกว่า 50 ตัว: หากทั้งระบบของคุณมี container ไม่เกิน 50 ตัว Docker Swarm จัดการได้สบายๆ โดยไม่มีปัญหาด้านประสิทธิภาพ

งบประมาณจำกัด: ไม่ต้องจ้าง Kubernetes specialist ไม่ต้องซื้อ managed K8s service ราคาแพง ทำเองได้ด้วยทีมที่มี

ต้องการ deploy เร็ว: จากศูนย์ถึง production ได้ภายในชั่วโมง ไม่ใช่สัปดาห์

สถาปัตยกรรมของ Docker Swarm (Swarm Architecture)

Docker Swarm มีสถาปัตยกรรมที่เรียบง่ายแต่แข็งแกร่ง ประกอบด้วยองค์ประกอบหลักดังนี้

Manager Node

Manager Node คือหัวใจของ Swarm cluster ทำหน้าที่บริหารจัดการ state ของ cluster ทั้งหมด ตัดสินใจว่า container ควรรันอยู่ที่ไหน และรับคำสั่งจากผู้ดูแลระบบ ในสภาพแวดล้อมจริง ควรมี Manager อย่างน้อย 3 ตัวเพื่อความ high availability โดยจำนวนที่แนะนำคือเลขคี่ (3, 5, 7) เพื่อให้ระบบ Raft consensus ทำงานได้ถูกต้อง

Worker Node

Worker Node คือเครื่องที่ทำหน้าที่รัน container จริงๆ ไม่ได้มีส่วนในการตัดสินใจหรือบริหารจัดการ cluster เพียงแค่รับคำสั่งจาก Manager แล้วรัน container ตามที่ได้รับมอบหมาย คุณสามารถเพิ่ม Worker ได้ไม่จำกัดตามความต้องการของระบบ

Raft Consensus Algorithm

Swarm ใช้ Raft consensus algorithm ในการรักษาความสอดคล้องของข้อมูลระหว่าง Manager Node ทั้งหมด ระบบนี้ทำให้ Swarm สามารถทนต่อการล้มเหลวของ Manager ได้ ตราบเท่าที่เสียงข้างมาก (quorum) ยังทำงานอยู่ เช่น หากมี Manager 3 ตัว ระบบสามารถทนต่อการเสียของ 1 ตัวได้ หากมี 5 ตัว ทนได้ 2 ตัว

เบื้องหลังการทำงาน Raft จะเลือก Leader node หนึ่งตัวจาก Manager ทั้งหมด โดย Leader จะรับผิดชอบการตัดสินใจและกระจายข้อมูลไปยัง Manager ตัวอื่นๆ (Follower) หาก Leader ล้มเหลว Follower จะเลือก Leader ใหม่โดยอัตโนมัติ กระบวนการนี้เกิดขึ้นภายในไม่กี่วินาที

การตั้งค่า Docker Swarm Cluster

การเริ่มต้นใช้งาน Docker Swarm นั้นง่ายมากจริงๆ เพียงไม่กี่ขั้นตอนก็พร้อมใช้งาน

ขั้นตอนที่ 1: Initialize Swarm

บนเครื่องที่ต้องการเป็น Manager ตัวแรก ให้รันคำสั่งนี้

docker swarm init --advertise-addr 192.168.1.100

คำสั่งนี้จะทำสิ่งต่อไปนี้โดยอัตโนมัติ เปิดใช้งาน Swarm mode บน Docker Engine, สร้าง TLS certificates สำหรับการสื่อสารที่เข้ารหัส, กำหนดให้เครื่องนี้เป็น Manager ตัวแรก, สร้าง token สำหรับให้เครื่องอื่นเข้าร่วม cluster และสร้าง default overlay network

ขั้นตอนที่ 2: เพิ่ม Worker Node

หลังจาก init เสร็จ ระบบจะแสดง token สำหรับเข้าร่วม cluster นำ token นี้ไปรันบนเครื่องอื่นที่ต้องการเป็น Worker

docker swarm join --token SWMTKN-1-xxxx 192.168.1.100:2377

ขั้นตอนที่ 3: เพิ่ม Manager Node เพิ่มเติม

สำหรับ high availability ควรเพิ่ม Manager อีก 2 ตัว ขอ token สำหรับ manager ด้วยคำสั่ง

docker swarm join-token manager

จากนั้นนำ token ที่ได้ไปรันบนเครื่องที่ต้องการเป็น Manager เพิ่มเติม เพียงเท่านี้คุณก็มี Swarm cluster ที่พร้อมใช้งานแล้ว ง่ายมากใช่ไหม

ตรวจสอบ Node ทั้งหมด

docker node ls

คำสั่งนี้จะแสดง node ทั้งหมดในระบบ พร้อมบอกสถานะ (Active/Drain) และ role (Manager/Worker)

การ Deploy Services บน Docker Swarm

Docker Swarm มี service 2 ประเภทหลัก แต่ละประเภทมีจุดประสงค์ที่แตกต่างกัน

Replicated Service

Replicated service คือรูปแบบที่ใช้บ่อยที่สุด คุณกำหนดจำนวน replica ที่ต้องการ แล้ว Swarm จะกระจาย container ไปยัง node ต่างๆ อย่างสมดุล

docker service create --name web --replicas 3 -p 80:80 nginx:alpine

คำสั่งนี้สร้าง service ชื่อ “web” ที่มี nginx container ทำงานอยู่ 3 ตัว กระจายอยู่บน node ต่างๆ ใน cluster โดย Swarm จะดูแลให้มี container ทำงานอยู่ 3 ตัวเสมอ หากตัวใดตัวหนึ่งล้ม Swarm จะสร้างตัวใหม่ขึ้นมาทดแทนโดยอัตโนมัติ

Global Service

Global service คือรูปแบบที่รัน container หนึ่งตัวบนทุก node ใน cluster เหมาะสำหรับ monitoring agents, log collectors, หรือ security agents

docker service create --name monitor --mode global prom/node-exporter

ไม่ว่าจะมี node กี่ตัว ทุกตัวจะมี node-exporter container ทำงานอยู่เสมอ เมื่อเพิ่ม node ใหม่เข้า cluster ก็จะมี container ถูกสร้างบน node ใหม่โดยอัตโนมัติ

Docker Stack Deploy ด้วย Compose Files

วิธีที่แนะนำสำหรับการ deploy แอปพลิเคชันจริงบน Swarm คือการใช้ docker stack deploy ร่วมกับ docker-compose.yml ที่คุณคุ้นเคยอยู่แล้ว

ตัวอย่าง docker-compose.yml สำหรับ Swarm

version: '3.8'
services:
  web:
    image: myapp:latest
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
        failure_action: rollback
      restart_policy:
        condition: on-failure
        max_attempts: 3
      resources:
        limits:
          cpus: '0.5'
          memory: 256M
    ports:
      - "8080:80"
    networks:
      - frontend

  api:
    image: myapi:latest
    deploy:
      replicas: 2
      placement:
        constraints:
          - node.role == worker
    networks:
      - frontend
      - backend

  db:
    image: postgres:15
    deploy:
      replicas: 1
      placement:
        constraints:
          - node.labels.db == true
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - backend

networks:
  frontend:
    driver: overlay
  backend:
    driver: overlay
    internal: true

volumes:
  db-data:

Deploy ด้วยคำสั่งเดียว

docker stack deploy -c docker-compose.yml myapp

สังเกตว่าเราใช้ section deploy ในแต่ละ service เพื่อกำหนดค่าเฉพาะ Swarm เช่น จำนวน replica, ลำดับการ update, resource limits และ placement constraints ทั้งหมดนี้อยู่ในไฟล์เดียว เข้าใจง่าย

Networking ใน Docker Swarm

Docker Swarm มีระบบ networking ที่ทรงพลังในตัว รองรับการสื่อสารข้ามเครื่องเซิร์ฟเวอร์โดยไม่ต้องตั้งค่าอะไรซับซ้อน

Overlay Network

Overlay network เป็นหัวใจของ networking ใน Swarm ทำให้ container บนคนละเครื่องสามารถสื่อสารกันได้เสมือนอยู่บน network เดียวกัน Swarm จะจัดการ encryption, routing, และ DNS ให้โดยอัตโนมัติ ทุก service ในเครือข่ายเดียวกันสามารถเรียกหากันด้วยชื่อ service ได้เลย เช่น http://api:3000 ไม่ต้อง hardcode IP address

Ingress Network

Ingress network เป็น overlay network พิเศษที่ Swarm สร้างขึ้นมาเพื่อจัดการ routing mesh ทำให้ client สามารถเข้าถึง service ผ่าน port ที่เปิดไว้ได้จาก node ใดก็ได้ใน cluster แม้ว่า container จะไม่ได้รันอยู่บน node นั้น

ตัวอย่างเช่น หากคุณมี web service ที่ expose port 80 และมี node 3 ตัว แม้ว่า web container จะรันอยู่แค่บน node 1 และ node 2 แต่ผู้ใช้สามารถเข้าถึงได้ผ่าน IP ของ node ใดก็ได้ทั้ง 3 ตัว Swarm จะ route traffic ไปยัง container ที่เหมาะสมให้โดยอัตโนมัติ

คุณยังสามารถสร้าง internal overlay network ที่ไม่เชื่อมต่อกับโลกภายนอก เหมาะสำหรับ backend services ที่ไม่ต้องการให้เข้าถึงจากภายนอก เช่น database หรือ internal API

Secrets Management

Docker Swarm มีระบบจัดการ secrets ในตัว ทำให้คุณสามารถจัดเก็บและส่งข้อมูลลับ เช่น password, API keys, TLS certificates ไปยัง container ได้อย่างปลอดภัย

สร้าง Secret

echo "mydbpassword123" | docker secret create db_password -
docker secret create tls_cert ./server.crt

ใช้ Secret ใน Service

docker service create --name db   --secret db_password   --secret tls_cert   postgres:15

Secret จะถูกส่งไปยัง container ในรูปแบบไฟล์ที่ /run/secrets/<secret_name> โดย secret จะถูกเก็บไว้ใน Raft log ของ Manager node แบบเข้ารหัส ไม่มีการเก็บลงดิสก์แบบ plaintext และจะถูกส่งไปยัง container ที่ต้องการเท่านั้น ไม่ได้กระจายไปทุกที่

ข้อดีของการใช้ Swarm secrets คือไม่ต้องเก็บรหัสผ่านใน docker-compose.yml หรือ environment variable ที่อาจถูกเปิดเผยได้ง่าย ทำให้ระบบปลอดภัยมากขึ้นอย่างมีนัยสำคัญ

Docker Configs

นอกจาก Secrets แล้ว Docker Swarm ยังมี Configs ซึ่งคล้ายกันแต่ออกแบบมาสำหรับข้อมูลที่ไม่ลับ เช่น configuration files, nginx.conf, application settings

docker config create nginx_conf ./nginx.conf
docker service create --name web --config source=nginx_conf,target=/etc/nginx/nginx.conf nginx:alpine

ข้อดีของ Configs คือคุณสามารถอัปเดตได้โดยไม่ต้อง rebuild image และสามารถแชร์ config เดียวกันให้หลาย service ใช้ได้ ทำให้การจัดการ configuration เป็นระบบมากขึ้น

Rolling Updates และ Rollbacks

หนึ่งในฟีเจอร์ที่สำคัญที่สุดของ Docker Swarm คือความสามารถในการ update service โดยไม่ต้อง downtime ระบบ rolling update จะค่อยๆ เปลี่ยน container ทีละตัว ทำให้ผู้ใช้ไม่รู้สึกว่ามีการ update เกิดขึ้น

กำหนดค่า Rolling Update

docker service update   --image myapp:v2.0   --update-parallelism 1   --update-delay 10s   --update-failure-action rollback   --update-max-failure-ratio 0.25   web

ค่า configuration ที่สำคัญมีดังนี้ parallelism กำหนดจำนวน container ที่อัปเดตพร้อมกัน ค่า 1 หมายถึง update ทีละตัว delay คือเวลารอระหว่างการ update แต่ละ batch failure-action กำหนดว่าจะทำอะไรเมื่อ update ล้มเหลว rollback หมายถึงย้อนกลับไปเวอร์ชันก่อนหน้าอัตโนมัติ max-failure-ratio กำหนดสัดส่วนความล้มเหลวสูงสุดที่ยอมรับได้ ถ้าเกินจะ trigger failure action

Manual Rollback

หากต้องการย้อนกลับด้วยตนเอง

docker service rollback web

คำสั่งเดียว ทุกอย่างกลับสู่สถานะก่อนหน้า ง่ายมาก

Health Checks

Health check เป็นกลไกสำคัญที่ช่วยให้ Swarm รู้ว่า container ยังทำงานปกติหรือไม่ หาก health check ล้มเหลว Swarm จะหยุด container ที่มีปัญหาและสร้างตัวใหม่ขึ้นมาทดแทน

docker service create --name web   --health-cmd "curl -f http://localhost:80/health || exit 1"   --health-interval 30s   --health-timeout 10s   --health-retries 3   --health-start-period 60s   myapp:latest

health-cmd คือคำสั่งที่ใช้ตรวจสอบสุขภาพของ container health-interval คือความถี่ในการตรวจสอบ health-timeout คือเวลารอสูงสุดก่อนถือว่า check ล้มเหลว health-retries คือจำนวนครั้งที่ check ล้มเหลวก่อนถือว่า container unhealthy health-start-period คือเวลารอหลังจาก container เริ่มทำงานก่อนเริ่ม check เพื่อให้ application มีเวลา initialize

Health checks ทำให้ระบบ self-healing ได้อย่างแท้จริง container ที่มีปัญหาจะถูกแทนที่โดยอัตโนมัติ โดยไม่ต้องมีคนมาคอยดูแล

Scaling Services

การ scale service ใน Docker Swarm ง่ายมาก เพียงคำสั่งเดียว

docker service scale web=5

หรือ scale หลาย service พร้อมกัน

docker service scale web=5 api=3 worker=10

Swarm จะสร้าง container เพิ่มหรือลดตามที่ต้องการ กระจายไปยัง node ต่างๆ อย่างสมดุล โดยพิจารณาจากทรัพยากรที่มีอยู่ของแต่ละ node

แม้ว่า Swarm จะไม่มี auto-scaling ในตัวเหมือน Kubernetes HPA แต่คุณสามารถสร้าง auto-scaling ได้ง่ายๆ ด้วย script ที่ตรวจสอบ metrics (CPU, memory, request rate) แล้วรัน docker service scale ตาม threshold ที่กำหนด หรือใช้เครื่องมืออย่าง Orbiter ที่เป็น auto-scaler สำหรับ Swarm โดยเฉพาะ

Docker Swarm + Traefik สำหรับ Reverse Proxy และ TLS

Traefik เป็น reverse proxy ที่ออกแบบมาเพื่อทำงานร่วมกับ container orchestration โดยเฉพาะ เมื่อใช้ร่วมกับ Docker Swarm จะได้ระบบที่ทรงพลังมาก Traefik สามารถค้นพบ service ใหม่ใน Swarm โดยอัตโนมัติ สร้าง routing rules จาก labels ของ service และขอ TLS certificate จาก Let’s Encrypt แบบอัตโนมัติ

ตัวอย่าง Traefik บน Swarm

version: '3.8'
services:
  traefik:
    image: traefik:v3.0
    command:
      - "--providers.swarm=true"
      - "--providers.swarm.exposedByDefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.le.acme.tlschallenge=true"
      - "[email protected]"
      - "--certificatesresolvers.le.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - letsencrypt:/letsencrypt
    deploy:
      placement:
        constraints:
          - node.role == manager
    networks:
      - traefik-public

  myapp:
    image: myapp:latest
    deploy:
      labels:
        - "traefik.enable=true"
        - "traefik.http.routers.myapp.rule=Host(`myapp.example.com`)"
        - "traefik.http.routers.myapp.entrypoints=websecure"
        - "traefik.http.routers.myapp.tls.certresolver=le"
        - "traefik.http.services.myapp.loadbalancer.server.port=80"
      replicas: 3
    networks:
      - traefik-public

networks:
  traefik-public:
    driver: overlay

volumes:
  letsencrypt:

ด้วย configuration นี้ Traefik จะ auto-discover service ที่มี label traefik.enable=true สร้าง routing rule ตามโดเมนที่กำหนด ขอ TLS certificate จาก Let’s Encrypt อัตโนมัติ และ load balance traffic ไปยัง replica ทั้ง 3 ตัว ทั้งหมดนี้ไม่ต้องตั้งค่า nginx, ไม่ต้อง manual cert renewal ดีมากสำหรับทีมเล็ก

Monitoring Docker Swarm

การ monitor Swarm cluster มีเครื่องมือหลายตัวให้เลือกใช้ แต่ที่แนะนำสำหรับทีมเล็กมีดังนี้

Portainer

Portainer เป็น GUI management tool สำหรับ Docker และ Docker Swarm ติดตั้งง่ายมากบน Swarm

docker stack deploy -c portainer-agent-stack.yml portainer

Portainer ให้คุณดู service ทั้งหมด, ดู logs, scale service, update image และอีกมากมาย ผ่าน web UI ที่สวยงาม เหมาะสำหรับทีมที่ไม่อยากพิมพ์คำสั่ง CLI ตลอดเวลา หรือต้องการให้คนที่ไม่ถนัด command line สามารถดูแลระบบได้

Prometheus + Grafana

สำหรับ monitoring ที่จริงจังกว่า Prometheus ร่วมกับ Grafana เป็นคู่ที่ลงตัวที่สุด Prometheus เก็บ metrics จาก node-exporter (ข้อมูลเครื่อง), cAdvisor (ข้อมูล container) และ application metrics จากนั้น Grafana สร้าง dashboard ที่สวยงามจาก metrics เหล่านั้น

คุณสามารถ deploy Prometheus stack ทั้งชุดบน Swarm ได้ด้วย docker stack deploy เช่นกัน ทำให้ monitoring system รันอยู่บน Swarm เดียวกันกับแอปพลิเคชัน ไม่ต้องมีเครื่องแยก

สิ่งสำคัญที่ควร monitor สำหรับ Swarm cluster ได้แก่ CPU และ memory usage ของแต่ละ node, จำนวน container ที่ทำงานอยู่ต่อ node, network I/O, disk usage, service replica count เทียบกับ desired count, response time ของ application และ error rate

ข้อจำกัดของ Docker Swarm

แม้ Docker Swarm จะมีข้อดีมากมาย แต่ก็มีข้อจำกัดที่ต้องรู้ก่อนเลือกใช้

ไม่มี Auto-scaling ในตัว: ต้องใช้เครื่องมือภายนอกหรือเขียน script เอง ในขณะที่ Kubernetes มี HPA (Horizontal Pod Autoscaler) ในตัว

Ecosystem เล็กกว่า: Kubernetes มี Helm charts, Operators, CRD และเครื่องมือนับพันให้ใช้ Docker Swarm มี ecosystem ที่เล็กกว่ามาก

ไม่เหมาะกับ Scale ใหญ่มาก: สำหรับ cluster ที่มี node มากกว่า 100 ตัวหรือ container นับพัน Kubernetes จะจัดการได้ดีกว่า

การพัฒนาช้าลง: Docker Inc. ให้ความสำคัญกับ Docker Desktop และ Docker Hub มากกว่า Swarm ฟีเจอร์ใหม่ๆ ออกมาช้ากว่า Kubernetes มาก

ไม่มี Custom Resource Definitions: Kubernetes สามารถขยายได้ด้วย CRD ทำให้เป็นแพลตฟอร์มที่ยืดหยุ่นมาก Swarm ไม่มีความสามารถนี้

Community เล็กกว่า: เมื่อเจอปัญหา อาจหาคำตอบได้ยากกว่า Kubernetes ที่มี community ใหญ่มาก

Migration Path จาก Docker Swarm ไปยัง Kubernetes

หากวันหนึ่งทีมโตขึ้นหรือแอปพลิเคชันซับซ้อนมากขึ้นจนต้องย้ายไป Kubernetes การเตรียมตัวจะช่วยให้การ migrate ง่ายขึ้น

แนวทางการ Migrate

1. Containerize Everything First: หากคุณใช้ Swarm อยู่แล้ว แปลว่าแอปทุกตัวอยู่ใน container แล้ว ซึ่งเป็นข้อได้เปรียบใหญ่ เพราะ container เดียวกันสามารถรันบน K8s ได้เลย ไม่ต้องแก้ code

2. แปลง docker-compose.yml เป็น K8s manifests: ใช้เครื่องมือ Kompose ที่สามารถแปลง docker-compose.yml เป็น Kubernetes Deployment, Service และไฟล์อื่นๆ ได้โดยอัตโนมัติ แม้จะไม่สมบูรณ์แบบ 100% แต่ช่วยประหยัดเวลาได้มาก

3. ย้ายทีละ Service: ไม่จำเป็นต้องย้ายทุกอย่างพร้อมกัน สามารถย้ายทีละ service โดยใช้ external load balancer ชี้ traffic ไปยังทั้ง Swarm และ K8s cluster ระหว่างช่วงเปลี่ยนผ่าน

4. เรียนรู้ K8s Concepts ทีละหัวข้อ: เริ่มจาก Pod, Deployment, Service แล้วค่อยเรียนรู้เพิ่มเติม ไม่ต้องรู้ทุกอย่างก่อนเริ่มใช้

5. ใช้ Managed K8s: แทนที่จะ setup K8s เอง ใช้ managed service เช่น EKS, GKE, AKS จะช่วยลดภาระในการดูแล control plane ได้มาก

Docker Swarm ในปี 2026: ยังเกี่ยวข้องอยู่ไหม?

คำถามที่หลายคนถามคือ Docker Swarm ยังน่าใช้อยู่ไหมในปี 2026 คำตอบคือ ขึ้นอยู่กับ use case ของคุณ

Swarm ยังเหมาะสมสำหรับทีมเล็กที่ต้องการ Container Orchestration ที่ง่ายและรวดเร็ว สำหรับ startups ที่ต้องการ ship เร็ว ไม่อยาก spend เวลากับ infrastructure มาก สำหรับโปรเจกต์ภายในองค์กรที่ไม่ต้อง scale มหาศาล สำหรับ dev/staging environment ที่ต้องการจำลอง production cluster และสำหรับ edge computing หรือ IoT scenarios ที่ทรัพยากรจำกัด

ควรพิจารณา Kubernetes หากทีมมีมากกว่า 10 คน หากต้องการ auto-scaling ที่ซับซ้อน หากต้องใช้ advanced networking policies หากต้องการ service mesh (Istio, Linkerd) หากต้อง comply กับ regulatory requirements ที่ต้องการ RBAC ละเอียด หรือหากต้องการใช้ ecosystem ของ K8s อย่าง Helm, Operators, ArgoCD

Docker Swarm ไม่ได้ตายหรือถูกยกเลิก มันยังเป็นส่วนหนึ่งของ Docker Engine และได้รับ maintenance อย่างต่อเนื่อง แม้ว่าจะไม่มีฟีเจอร์ใหม่มากนัก แต่ก็ยังเป็นเครื่องมือที่เสถียรและเชื่อถือได้สำหรับการใช้งานที่เหมาะสม

Best Practices สำหรับการใช้ Docker Swarm ในปี 2026

ปิดท้ายด้วย best practices ที่ช่วยให้คุณใช้ Docker Swarm ได้อย่างมีประสิทธิภาพสูงสุด

1. ใช้ Manager อย่างน้อย 3 ตัว: เพื่อ high availability อย่าใช้ Manager ตัวเดียวใน production เพราะหากล้มจะเสีย cluster ทั้งหมด

2. แยก Manager กับ Worker: ตั้งค่า Manager node เป็น drain mode เพื่อไม่ให้รัน application container บน Manager ทำให้ Manager โฟกัสกับการบริหาร cluster อย่างเดียว

3. ใช้ Secrets และ Configs: อย่าใส่ข้อมูลลับใน environment variable หรือ image ใช้ Swarm Secrets เสมอ

4. ตั้งค่า Health Checks: ทุก service ควรมี health check เพื่อให้ Swarm สามารถ self-heal ได้

5. ใช้ Resource Limits: กำหนด CPU และ memory limits ให้ทุก service เพื่อป้องกันไม่ให้ container ตัวเดียวกิน resources จนกระทบ container อื่น

6. ใช้ Rolling Updates เสมอ: อย่า update ทุก container พร้อมกัน ใช้ rolling update ที่มี failure action เป็น rollback

7. Backup Swarm State: ทำ backup ของ /var/lib/docker/swarm directory บน Manager node เป็นประจำ เพื่อกู้คืนได้หากเกิดปัญหา

8. ใช้ Private Registry: อย่า pull image จาก Docker Hub โดยตรงใน production ใช้ private registry เช่น Harbor หรือ GitLab Container Registry

9. Log Aggregation: ตั้งค่า centralized logging ด้วย ELK stack หรือ Loki เพราะ log ของ container จะหายไปเมื่อ container ถูกลบ

10. ทดสอบ Disaster Recovery: ซ้อมการกู้คืนระบบเป็นประจำ ลอง shutdown Manager node แล้วดูว่าระบบยัง failover ได้อย่างถูกต้องหรือไม่

สรุป

Docker Swarm เป็น Container Orchestration ที่เรียบง่ายแต่ทรงพลัง เหมาะอย่างยิ่งสำหรับทีมเล็กที่ต้องการจัดการ container หลายตัวบนหลายเครื่องเซิร์ฟเวอร์ โดยไม่ต้องเผชิญกับความซับซ้อนของ Kubernetes จุดแข็งคือความง่ายในการเรียนรู้ การติดตั้งที่รวดเร็ว และการใช้ docker-compose.yml ที่คุ้นเคย

สำหรับทีมที่มีคน 1-10 คน มี container ไม่เกิน 50 ตัว และต้องการ deploy แอปพลิเคชันอย่างรวดเร็วและเชื่อถือได้ Docker Swarm ยังคงเป็นตัวเลือกที่ยอดเยี่ยมในปี 2026 และเมื่อถึงเวลาที่ต้องย้ายไป Kubernetes ก็มี migration path ที่ชัดเจน เพราะทุกอย่างอยู่ใน container อยู่แล้ว

เริ่มต้นด้วย Swarm วันนี้ แล้วค่อยย้ายไป Kubernetes เมื่อจำเป็น ดีกว่าเสียเวลาหลายสัปดาห์ไปกับ Kubernetes ทั้งที่ Swarm ตอบโจทย์ได้เพียงพอ