ในบทความที่แล้ว (Docker Swarm คืออะไร) ผมได้อธิบายไปแล้วว่า Docker Swarm คืออะไร และการใช้งานแบบคร่าวๆ สําหรับในบทความนี้ผมจะมาทดลองให้ดูว่าเมื่อนํา Docker Swarm มาใช้งานแล้วจะเป็นอย่างไรบ้าง ก่อนอื่นมาดูกันก่อนว่าคําสั่งพื้นฐานของ Docker Swarm ที่จะต้องใช้มีอะไรบ้าง

คําสั่งพื้นฐาน Docker Swarm

1. สร้าง docker swarm manager เป็นคําสั่งสําหรับกําหนดให้เครื่องของเราเป็น Manager มีรูปแบบคําสั่งดังนี้

docker swarm init

เมื่อเรียกคําสั่งนี้แล้ว Docker Swarm จะ print ข้อมูลสําหรับ join worker node ออกมาประมาณนี้

2. คําสั่ง  join swarm เป็นคําสั่งสําหรับสั่งให้เครื่องเราไป join กับ Manager รูปแบบการใช้คําสั่งคือ

docker swarm join <token สําหรับ join> <ip ของเครื่อง Manager>

3. คําสั่งดูว่ามีเครื่องไหน join อยู่ใน Swarm บ้าง  รูปแบบคําสั่งคือ

docker node ls

ระบบจะแสดงผลออกมาประมาณนี้ โดยจะบอกว่ามีเครื่องไหน join อยู่บ้าง และเครื่องไหนเป็น Manager และเครื่องไหนเป็น Worker

**4. คําสั่งสําหรับลบเครื่องออกจาก Swarm **หมายถึงคําสั่งสําหรับ ลบ node ใด node หนึ่งออกจาก Swarm รูปแบบคําสั่งคือ

docker node rm <ชื่อ node ที่ต้องการจะลบ>

5. คําสั่งดู token เป็นคําสั่งสําหรับดู token ในกรณีที่เราลืม token ไปแล้ว เราสามารถที่จะเรียกดูได้จากคําสั่งนี้

docker swarm join-token <manager or worker>

จากคําสั่งด้านบนจะใช้แยกกันระหว่าง Manager กับ Worker แล้วแต่ว่าเราจะดู token ของอะไร ตัวอย่าง

6. คําสั่ง create service เป็นคําสั่งสําหรับสร้าง service โดยจะรันจาก Docker Image รูแบบคําสั่งคือ

docker service create --replicas <จํานวน task ที่ต้องการ> --name <ชื่อ service> -p <port> <image ที่ต้องการ>

คําสั่งจะคล้ายๆกับการ docker run 7. คําสั่งดู service ที่รันอยู่ รูปแบบคําสั่งคือ

docker service ls

8. คําสั่งดูรายละเอียดของ service คือคําสั่งที่ใช้ดูว่า service นี้มี task ไปอยู่ที่ node ไหนบ้าง รูปแบบคําสั่งคือ

docker service ps <ชื่อ service>

9. คําสั่ง scale เป็นคําสั่งสําหรับ เพิ่ม-ลด จํานวน task รูปแบบคําสั่งคือ

docker service scale <ชื่อ service>=<จํานวน task>

10. คําสั่งลบ service รูปแบบคําสั่งคือ

docker service rm <ชื่อ service>

11. ยกเลิกการ join หมายความว่า สั่งให้เครื่องตัวเองยกเลิกการ join Swarm

docker swarm leave

ลองเล่น Docker Swarm

จําลองเครื่องขึ้นมา 5 เครื่องคือ manager1, manager2, manager3, node1 และ node2 โดยให้ manager1, manager2 และ manager3 เป็น Swarm manager ส่วน node1 และ node2 ให้เป็น Swarm Worker

ผมใช้ vmware ในการจําลองเครื่องขึ้นมาทั้ง 5 เครื่อง

นําเครื่องทั้งหมดมาทํา Swarm โดยมีเป้าหมายในการทดลองดังนี้

• ลอง ระบบ IPVS ที่เป็น Load-balance
• ถ้า Manager node down จะเกิดอะไรขึ้น
• ถ้า Worker node down จะเกิดอะไรขึ้น
• ลอง Scale task

เริ่มด้วยนําเครื่องทั้ง 5 เครื่องมาทํา swarm กันก่อน ตามนี้ครับ

กําหนดให้ manager1 ให้เป็น Swarm Manager ด้วยคําสั่ง

docker swarm init

ได้ผลดังนี้

ซึ่งจะแสดง token สําหรับ Worker เพียงอย่างเดียว ถ้าต้องการ get token ของ Worker และ manager ทําตามด้านล่างได้เลยครับ

นํา Worker Token ที่ได้ไปรันในเครื่อง node1, node2 จะได้ผลประมาณนี้ node1

node2

ต่อมาเรามา join Manager node โดยกําหนดเครื่อง manager2 และ manager3 เพื่อเป็นเครื่อง Manager สํารอง โดยจะต้อง Get Manager token จาก เครื่อง manager1 ก่อน

docker swarm join-token manager

จะได้ Manaer Token

เอา Manager Token นี้ไปรันในเครื่อง manager2

รันที่ manager3

ถึงตอนนี้เราทําการ join เครื่องทั้ง 4 เครื่องใน Swarm เรียบร้อยแล้ว หลังจากนี้เราจะต้องใช้คําสั่ง Control ต่างๆ ผ่าน Swarm manager เท่านั้น ซึ่งก็คือเครื่อง manager1, manager2 และ manager3 ลองตรวจสอบดูว่าทุกอย่าง join กันเรียบร้อยมั้ย ด้วยคําสั่ง

docker node ls

ผมได้ทํา Docker Image ไว้สําหรับมาลองเล่นกับ Docker Swarm โดย Docker Image ตัวนี้ จะเป็นเว็บ server ที่จะ Print host name ออกมาเมื่อเปิดเว็บไปที่ port 3000 สําหรับ host name ใน docker ก็ คือ Container ID นั่นเอง

Docker Image ตัวนี้ผมเอาขึ้น Docker hub เรียบร้อยแล้วครับ ที่ hub.docker.com/r/thiti/swarm-example/

เป้าหมายแรกของเราคือ มาทดลอง Load-balance กัน คือผมสร้าง Service ด้วยคําสั่งนี้

docker service create --replicas 1 --name web -p 3000:3000 thiti/swarm-example

ความหมายของคําสั่งคือ สร้าง service ชื่อ web จํานวน 1 task และใช้ port 3000 โดยสร้างจาก image thiti/swarm-example

Docker Image ที่จะใช้สร้าง service จะต้องมีอยู่ทุกเครื่องที่  join อยู่ใน swarm หรือถ้าไม่มีก็จะต้องอยู่บน docker hub

ลองดูว่า Service ทํางานมั้ย

จะเห็นว่าเราได้ service ขึ้นมา 1 อัน เรามาดูรายละเอียดของ Service ตัวนี้กัน

จากรูป Task ของ Service ตัวนี้ ถูกรันอยู่บนเครื่อง node2 ดังนั้นผมอยากลองว่า ถ้าผมเข้าหน้าเว็บนี้จากเครื่องอื่นที่ไม่ใช่ node2 จะเข้าได้มั้ย เพื่อทดสอบ Load-balance ผมลองเข้าไปที่ ip ของเครื่อง node1 สามารถเข้าได้ตามรูป

ลําดับต่อไปมาลองว่า ถ้า manager1 เกิด down จะเกิดอะไรขึ้น

วิธีการคือ shutdown เครื่อง manager1 เลย ผลที่ได้คือ Leader มาอยู่ที่ manager3

ลองเข้าหน้าเว็บโดยเข้าที่ ip ของเครื่อง node1 ก็ยังเข้าหน้าเว็บได้ตามปกติ

แสดงว่าเมื่อ manager1 ซึ่งเป็น Leader หายไปจากระบบ Docker Swarm ก็ยังทํางานได้ตามปกติ การทดลองต่อไป ถ้า Worker node down ระบบ ยังทํางานต่อได้มั้ย

สั่ง shutdown node1 ผลที่ได้คือ task ย้ายไปอยู่ที่ node2

ยังเข้าเว็บได้ตามปกติ สั่ง shutdown node2 ผลที่ได้คือ task ย้ายไปอยู่ที่ manager2

ต่อไปมาลอง Scale กันบ้างครับ โดยผมจะ Scale เป็น 10 task ผลที่ได้คือ task จะกระจายไปยัง node ต่างๆ

จบการทดลองครับ

ขอบคุณที่ติดตามอ่านมาจนถึงบรรทัดนี้นะครับ ถ้าข้อมูลผิดพลาดตรงไหนก็ขออภัยด้วยนะครับ

ลําดับต่อไป เราจะใช้งาน Docker Compose กับ Docker Swarm อ่านต่อได้ที่นี่ ใช้ Docker Compose กับ Docker Swarm