K8s อิหยัง *ะ

เริ่มแรก หลายๆ ท่านคงยังสงสัย ว่า K8s มันคืออะไรนะครับ สั้นๆ ก็คือมันมาจาก Kubernetes นั่นเอง ถ้าเราเอา K กับ s ท้ายออก มันคือ u-b-e-r-n-e-t-e ซึ่งรวมแล้วก็คือ 8 อักขระนั่นเอง ดังนั้น ชื่อย่อของ Kubernetes ก็คือ K8s โดยใช้เลข 8 มาทำให้มันสั้นขึ้นนะครับ

นอกเหนือจากนั้นก็ยังมี K3s นะครับ ลองเข้าไปอ่านเพิ่มเติมได้ แต่ K3s จะเน้นแบบ lightweight ซึ่งอาจจะเหมาะสมกับ Edge Computing มากกว่า

Kubernetes

จาก นิยามอย่างเป็นทางการ ของมัน สั้นๆ ได้ความว่า Kubernetes คือสิ่งที่เราเอาไว้ใช้จัดการ containerized workloads (ตัวอย่าง containers ที่นิยมคือ Docker, Rancher) ซึ่งตรงนี้แหละ ที่ Kubernetes สามารถเข้ามาช่วยเราเรื่อง Scalability ได้อย่างชัดเจนเลย ตามที่นิยามของมันเขียนไว้ว่า มันคือ Orchestration Tool นั่นเองนะครับ (ลองนึกถึงวง Orchestra ที่ทาง Conductor จะเป็นคนกำหนด ว่าเครื่องไม้่ เครื่องมือไหน ควรจะเล่น ให้ดังขึ้น มากขึ้น หรือ แผ่วลง นะครับ)

Containers

Docker , Rancher หรือ Rocket เป็นตัวอย่าง Containers นะครับ ซึ่งการที่เราทำ Containerization กับ Application ของเราแล้ว ดังนั้น ด้วย Concept ของ Container คือ เราสามารถหยิบนำ Containerized Application นั้นๆ ไปรันที่ไหนก็ได้ นั่นเอง (Dependencies ต่างๆ เราระบุใน Container นะครับ) ซึ่งจะต่างกับ VM ตรงที่ว่ามันจะผูกกับ library ของ OS ที่เราใช้ แต่การใช้ Containers เนี่ย ส่วนของ OS ที่เราระบุ มันจะ Share Kernel กัน อะไรใช้ได้ก็ใช้ อะไรใช้ไม่ได้ก็โหลดมาเพิ่มใหม่ ดังนั้น ถ้ามองในมุมของ Hardware Resource แล้ว Containers จะกิน CPU, Memory, Harddisk น้อยกว่าการสร้าง Virtual Machine บน Hypervisor นะครับ (แต่ทั้งนี้ทั้งนั้น แล้วแต่งานนะครับ บางงาน ต้องการ Access เข้าถึง Root ดังน้ัน การใช้ VM หรือ K8s + Container ต้องดูที่ตัวงานด้วยนะครับ ตามความเหมาะสม)

แล้ว Kubernetes อิหยัง *ะ

ในมื่อ Containers อย่าง Docker, Rancher, Rocket เข้ามาข่วยให้เราสามารถ Deploy Containerized App ของเราไปที่ไหนก็ได้ สามารถ Deploy ได้หลายๆ ที่ แล้วทำไม เรายังจะต้องใช้ Kubernetes อีก

คำถามสั้นๆ เรื่องเกี่ยวกับ Application นะครับ

1. แล้วเราจัดการ Deployments ของ Containers ของเราอย่างไร (ตัวอย่าง ถ้ามีการ Updates / Releases เกิดขึ้น แล้วจะจัดการอย่างไร)
2. เมื่อเรา Deploy Containerized App ไปแล้ว เราจัดการอย่างไร ให้ระบบรู้ว่า Application นั้นๆ มันไม่ทำงาน หรือ Down ลงไป แล้วจะ Restart อย่างไร แล้วไหนจะต้องทำการสร้างตัวทดแทนขึ้นมา ให้ระบบรองรับผู้ใช้งานต่อไปได้
3. ถ้า Containerized App ของเรา รันๆปกติ แต่จู่ๆ เกิดปัญหาว่า Hardware Resource ไม่พอ เราจะแก้ไขอย่างไร
4. แล้วการ Scale ให้ระบบของเรามันรองรับผุ้ใช้งานได้มากขึ้นละ แล้วถ้าผู้ใช้งานน้อยลง ก็ Scale down ลงมา จะได้ประหยัดค่าใช้จ่าย

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

Overview สำหรับ Kubernetes Cluster

https://kubernetes.io/docs/concepts/overview/components/

จาก Diagram ด้านบน เราจะเห็นว่า Components ที่สำคัญๆ และอยากจะยกมาในบทความนี้คือ

Kubernetes control plane ตามชื่อเลยนะครับ เป็น Component ที่จัดการเรื่อง Node ถ้า Node ไหนไม่ทำงาน จะทำอย่าง แม้กระทั่งเรื่องการจัดการ Pod นะครับ

etcd is the cluster database, is a consistent and highly-available key-value store. (metadata)

kube-scheduler ตัวจัดตาราง ว่าให้ pod ไหน ไปทำงานที่ไหน ใน Nodes ที่มีอยู่ใน Cluster

kubelet เป็น Agent ที่คอยบอกว่า Container นั่นยังทำงานอยู่ใน Pod

kube-proxy จัดการเรื่อง Networking และ เป็นตัวกำหนด Network Rules ระหว่าง Nodes

Nodes

ใน Cluster ก็จะประกอบด้วย Nodes นะครับ ซึ่งอาจจะเป็น one-node-cluster ก็ได้ ไม่ว่ากัน แต่ถ้าจะให้มองเห็นภาพ ลองนึกถึง Data Center ที่เราจะเห็นว่า Servers มันถูกสร้างขึ้นมาเป็น Clusters นั่นเอง ซึ่ง Data Center น้้นอาจจะมีเพียง 1 cluster แต่ประกอบไปด้วย หลายๆ Racks และ แต่ละ Racks ก็มี หลายๆ Compute Nodes และ อาจจะเพียง 1 Management Nodes อย่างตัวอย่างด้านล่างนะครับ IBM Summit โดย IBM Power ซึ่งเป็น Supercomputer ที่เร็วที่สุดในโลกในขณะนี้

https://www.ibm.com/thought-leadership/summit-supercomputer/

ในเมื่อเรามี Nodes ดังนั้น เราสามารถกระจายงาน โดย Deploy ไปหลายๆ Nodes ได้โดย Management Node ซึ่งจะคอย monitor ว่า Nodes ทำงานได้ไม่ดี ก็จะทำการโอนงานไปให้ Nodes อื่นๆ และ Reboot Nodes ที่ทำงานไม่ได้ ขึ้นมาใหม่ ซึ่ง Concept ของ Hardware — Cluster แบบนี้แหละครับที่ทาง Kubernetes จะยึดเป็นพื้นฐาน ดังนั้น สั้นๆ อีกครั้งนะครับ

Nodes = Compute Node ไม่ว่าจะเป็น VM หรือ Dedicated Server นั่นเองนะครับ

แล้ว Pod อิหยัง *ะ

อ่านมาตรงนี้ แล้ว Pod มันคืออะไร Pod เนี่ยเป็น Compute Unit เล็กๆ ที่รัน Containerized Application ของเรา นะครับ ดังนั้น ถ้าเราระบุ Kubernetes ให้ทำการ Deploy โดยมี 5 Replicas ดังนั้น เราคาดหวังว่าจะมี 5 Pods ที่รัน Containerized Application ของเรานั่นเอง โดย Replica ตรงนี้ เราสามารถ Set ได้ และให้ทาง Kubernetes กระจายมอบงาน 5 Pods นี้ไปยัง Nodes ที่เรามีอยู่

พูดไปเมื่อยมือ (เพราะว่าเป็น Blog นี้แหนะ) ถ้างั้นมาลองลงมือทำกันดีกว่า

ก่อนอื่น สร้าง Cloud Account กันก่อน (ครับ ลองบน Cloud เลย)

จะว่าไปแล้วการทดลองใช้ Kubernetes ก็สามารถทำได้บน Local นะครับ แต่เรามาทดลองใช้ของฟรีกันบน Cloud ดีกว่า ซึ่งมาดูกันว่า อะไร Free บน IBM Cloud

อันดับแรก สมัคร IBM Cloud Account นะครับ ซึ่งเน้นนะครับว่าเราจะใช้ของฟรี

อันดับที่สอง ทำการ Upgrade Acount เพื่อที่เราจะสร้าง Free Cluster ได้นะครับ โดยกดที่นี่ https://cloud.ibm.com/billing/payments

หลังจากนั้น ให้รอ Approval นะครับ

หน้าถัดไป เราก็จะเห็นว่า หลังจากเราสมัคร IBM Cloud + กับ Upgrade Account แล้ว เราก็ยังได้ Cloud Credit มาฟรีๆ อีก 200 USD นะครับ แต่ว่า จากตัวอย่างนี้ Free Kubernetes Cluster เราจะไม่ถูกหักไปจาก 200 USD Credit นะครับ

มาสร้าง Kubernetes Cluster แรก แบบ ฟรีๆ กัน

หลังจากนั้น เราก็ทำการสร้าง Free Cluster ได้เลยนะครับ ซึ่ง Free ตัวนี้จะทำงานได้ 30 วัน และจะถูกทำลายไปเองนะครับ โดยที่เราไม่ต้องกังวลถึงค่าใช้จ่าย ที่อาจจะตามมาภายหลังนะครับ สร้าง Free Cluster ได้จาก link นี้นะครับ https://cloud.ibm.com/kubernetes/catalog/create

ตามรูปนะครับ ให้แน่ใจว่าเราเลือก Free Cluster จริงๆ นะครับ ส่วนที่เหลือให้เป็นค่า Default และทำการกดปุ่ม Create ได้เลยนะครับ

ให้เวลา IBM Cloud Provision K8s Cluster ซะก่อนนะครับ

หลังจากกดปุ่ม Create แล้ว ให้เวลา IBM Cloud Provision Kubernetes Cluster ซักระยะนะครับ

เอาละ จากหน้านี้ Free K8s Cluster พร้อมใข้งานแล้วนะครับ ดังนั้น ด้วยการที่ว่าเราใช้ ทุกอย่างบน Cloud ดังนั้น Step ถัดไปคือ ใช้งาน IBM Cloud Shell นะครับ กดได้ที่ Icon ด้านขวาบนตามลูกศรนะครับ

หน้าตาของ IBM Cloud Shell ก็จะเป็นแบบนี้นะครับ นั่นก็คือ Remote Cloud Terminal นั่นเอง ซึ่งตัวอย่างนี้ เราจะใช้ IBM Cloud Shell เป็นหลักนะครับ เพราะว่าการใช้งาน K8s นั้น เราต้องติดตั้งอะไรค่อนข้างเยอะ เราเลี่ยงตรงนั้นไปก่อนนะครับ สำหรับ ณ ตอนนี้

เมื่อเรามี Cloud Terminal พร้อมใช้งานแล้ว ดังนั้น ขี้นตอนต่อไป เราต้องการทำการเชื่อมต่อไปที่ Kubernetes Cluster ของเรานะครับ เรากลับไปที่หน้าหลักของ K8s Cluster จะเห็นว่า Access > Step ที่ 2 คือการเชื่อมต่อนะครับ ให้เรากด Icon Copy แล้วไปวางที่ IBM Cloud Shell ได้เลยนะครับ

เชื่อมต่อ Connect ไปที่ K8s Cluster

dev_ibm_cloud@cloudshell:~$ ibmcloud ks cluster config --cluster mycluster

OK
The configuration for bqt6sktd0holu2n3ng90 was downloaded successfully.

Added context for bqt6sktd0holu2n3ng90 to the current kubeconfig file.
You can now execute 'kubectl' commands against your cluster. For example, run 'kubectl get nodes'.

หลังจากนั้นแล้ว เราลองคำสั่งด้านล่างดูนะครับ ว่า nodes และ pods มีอะไรบ้าง

$ kubectl get nodes

$ kubectl get pods --all-namespaces

เราก็ได้รูปร่าง output ออกมาเป็นแบบนี้

เราจะเห็นว่า pods มีเยอะแยะมากมาย นั่นเป็นเพราะว่า Kubernetes cluster ตัวนี้ ถูกรันอยู่บน IBM Cloud ดังนั้น ด้วยศัพท์เทคนิคแล้ว เราจะเรียกว่า Managed Kubernetes Service นั่นเองนะครับ โดยที่ทาง IBM Cloud จะดูแลเรื่องทุกเรื่อง แม้กระทั่งความปลอดภัย โดยที่เรา Focus การใช้งาน และดึงประโยชน์ของ K8s และ IBM Cloud มาควบคู่ด้วยกันนะครับ

Deployment + Service

ขั้นตอนต่อไป เราทำการ Deploy Containerized App นะครับ ในที่นี้ เราจะใช้ Image จาก Public Docker hub และ ชื่อ ibmcom/guestbook:v1 นั่นคือ guestbook ซึ่งเขึยนด้วย Go Lang นะครับ สามารถ Copy Command ยาว ด้านล่างไปแปะใน IBM Cloud Shell ได้เลยนะครับ

$ cat <<EOF | kubectl create -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: guestbook
  labels:
    app: guestbook
spec:
  replicas: 2
  selector:
    matchLabels:
      app: guestbook
  template:
    metadata:
      labels:
        app: guestbook
    spec:
      containers:
      - name: guestbook
        image: ibmcom/guestbook:v1
        imagePullPolicy: Always
        ports:
        - name: http
          containerPort: 3000
          protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: guestbook
  labels:
    app: guestbook
spec:
  type: NodePort
  ports:
  - port: 3000
    targetPort: 3000
    name: guestbook
    protocol: TCP
  selector:
    app: guestbook
EOF

จาก YAML File ด้านบน เราทำการ Deployment Containerized App ไปเรียบร้อยแล้ว ซึ่งเรา Set Replica= 2 นะครับ ดังนั้น เราคาดหวังว่า App ของเรา จะใช้ 2 Pods นั่นเอง ซึ่งทาง Kubernetes ก็ทำงานตามที่เราต้องการนะครับ ต่อไป เรามาดูกันว่ามีอะไรทำงานอยู่บ้าง และ Pods, Deployment, Service มีอะไรรันอยู่บน K8s Cluster ของเรากัน

$ kubectl get all -o wide

แสดงออกมาทั้งหมดนะครับ ทั้ง Deployment, Service, Pod และ ReplicaSet

เท่านี้เองครับ ขั้นตอนการ Deploy และ App ของเราก็ ทำงานได้แล้ว ขั้นตอนต่อไป คือ เราต้องหาทางเข้าไปที่ App ของเรานะครับ ไม่ว่า Port Number และ IP Address ซึ่งจาก รูปด้านบน สังเกตุที่ service/guestbook นะครับ เราจะเห็นว่า NodePort จะมีการระบุไว้ว่า 3000:32719 นะครับ ซึ่งแทนที่เราจะใช้ port 3000 ในการเข้าถึง App ของเรา แต่ด้วย Kubernestes จัดการ Port Number มาให้นะ ดังนั้นเจ้า K8s แนะให้เราใช้ Port Number 32719 แทน (Port number ค่าทุกอย่าง ให้ทุกท่านดูจาก output ของตัวเองนะครับ ค่าอาจะจะไม่เหมือนกับที่ผมแสดงเอาไว้ในที่นี้)

ต่อไป ค้นหา IP Adress นะครับ ด้วยคำสั่งด้านล่างนี้ และดึงค่า External IP มาใช้นะครับ

$ kubectl get nodes -o wide

ดังนั้น ในที่นี้ ผมจะได้ URL ของ App ที่เพิ่ง Deploy ไปก็คือ

http://184.172.214.148:32719

App — Guestbook

ทิ้งท้ายไว้เป็นการบ้าน ทดลอง Scale กันดู

# ทดลอง Delete Pods ทั้งหมด แล้วลองเข้า Web App ของเราใหม่ด้วย IP:port เดิม
$ kubectl delete pods --all

--------------------------------------------------------------------

# ทดลอง Scale App ขึ้นไปที่ 10 Pods โดยทดสอบดูก่อนว่า มีกี่ Pods ที่รัน guestbook
$ kubectl get pods
$ kubectl scale --replicas=10 deployment guestbook
$ kubectl get pods

# ทดลองดู Replicaset 
$ kubectl get replicasets -l app=guestbook

ถ้าใครได้ทำการบ้าน ก็จะพอทราบนะครับ ถ้าอะไรเกิดขึ้นกับ pods อย่าง ใช้งานไม่ได้ หรือ เผลอถูกลบ K8s ก็จะสร้าง pods ใหม่ขึ้นมาแทนที่ และ ระบบก็ยังเดินหน้าทำงานต่อไปได้นะครับ

แม้กระทั้งการ Scale เราก็เห็นว่า เรา Scale ขึ้นไป 10 Pods แล้ว เวลาที่ User เข้ามาที่ Web Guestbook นี้ ทาง K8s ก็จัดการกระจายงานไปยัง Nodes / Pods ให้เราอีกด้วย ก็คือ Concept ของ Load Balance นั่งเอง ครับ

อีกนิดนึงสำหรับ Free Cluster 30 วัน Cluster นี้ จะถูกทำลายอัตโนมัติ นะครับ ไม่ต้องห่วงว่าจะมีอะไรมาทำให้เราเสียค่าใช้จ่ายนะครับ

เป็นไงบ้างครับ หว่งว่าบทความนี้คงจะทำให้หลายๆ ท่านกระจ่ายเรื่อง K8s นะครับ ว่าทำไมถึงการเป็นที่ฮิต และ ทำไมหลายๆ องค์กรให้ความสนใจเรื่อง Cloud Native Development กันมากนะครับ ท้ายที่สุดแล้ว แนะนำกลุ่ม IBM Cloud Thailand นะครับ สามารถเข้ามาพูดคุย แลกเปลี่ยนประสบการณ์กันได้ครับ

*ibm.biz/IBMCloudThailandFacebookGroup*