DevOps

Kubernetes Basics for Beginners

📅 2026-02-09 | โดย อ.บอม กิตติทัศน์ เจริญพนาสิทธิ์ — SiamCafe.net Since 1997

Kubernetes Basics for Beginners คืออะไร / ทำไมถึงสำคัญ

น้องๆ เคยเจอปัญหาไหม เวลาเขียนโปรแกรมเสร็จแล้ว เอาไปรันจริงบนเครื่องคนอื่น ทำไมมันไม่ทำงานเหมือนเครื่องเราเป๊ะๆ? หรือตอนที่เว็บเราดัง คนเข้าเยอะๆ เซิร์ฟเวอร์รับไม่ไหว ล่มจ้อย... Kubernetes (K8s) เนี่ยแหละครับพระเอกของเรา

K8s มันคือระบบจัดการ Container แบบอัตโนมัติ (Container Orchestration) พูดง่ายๆ คือมันช่วยเราจัดการโปรแกรมที่ถูกห่ออยู่ใน Container ให้ทำงานได้อย่างราบรื่น ไม่ว่าจะเป็นเรื่องของการ Scale (เพิ่มจำนวน), Load Balancing (กระจายโหลด), Healing (ถ้าตัวไหนเสียก็สร้างใหม่เอง) และอื่นๆ อีกมากมาย

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

พื้นฐานที่ต้องรู้

Containers คืออะไร?

Container เนี่ย ให้คิดซะว่ามันคือกล่องที่บรรจุโปรแกรมของเรา พร้อมกับทุกสิ่งที่โปรแกรมนั้นต้องการ (Library, Dependencies, etc.) ทำให้โปรแกรมของเราสามารถทำงานได้ทุกที่ที่มี Container Runtime (เช่น Docker)

สมัยก่อนเวลาลงโปรแกรมทีนึง มันจะไปยุ่งกับ OS ของเครื่องโดยตรง ทำให้เวลาลงหลายๆ โปรแกรม มันตีกันมั่วไปหมด แต่ Container มันแยกส่วนกัน ทำให้โปรแกรมแต่ละตัวไม่รบกวนกันครับ

Pods, Deployments, Services

K8s จะมีศัพท์เฉพาะที่ต้องทำความเข้าใจกันหน่อย เริ่มจาก:

• Pod: หน่วยที่เล็กที่สุดใน K8s คือกลุ่มของ Container ที่ทำงานร่วมกัน
• Deployment: คือตัวที่บอก K8s ว่าเราต้องการรัน Pod กี่ตัว และจะอัพเดท Pod เหล่านั้นยังไง
• Service: คือตัวที่ expose Pod ของเราให้คนอื่นเข้าถึงได้ ไม่ว่า Pod จะอยู่ตรงไหนก็ตาม

ลองนึกภาพตามนะ เรามี Deployment บอก K8s ว่าอยากได้ 3 Pod ของเว็บ SiamCafe.net แล้ว Service ก็จะทำหน้าที่เป็นเหมือนเบอร์โทรศัพท์ที่ใครๆ ก็โทรเข้ามาได้ ไม่ว่า Pod จะอยู่ที่ไหนก็ตาม

SiamCafe Blog

YAML Files

K8s ส่วนใหญ่จะ config ทุกอย่างผ่านไฟล์ YAML ซึ่งเป็นไฟล์ที่อ่านง่าย (มั้ง) เราจะใช้ YAML ในการ define Deployment, Service และ Object อื่นๆ ใน K8s

ตัวอย่าง YAML file สำหรับ Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: my-app-image:latest
        ports:
        - containerPort: 8080

ไม่ต้องตกใจนะ ถ้าเห็นแล้วงงๆ เดี๋ยวเราจะค่อยๆ เรียนรู้กันไป

วิธีใช้งาน / เริ่มต้นยังไง

การเริ่มต้นใช้งาน K8s อาจจะดูยุ่งยาก แต่จริงๆ แล้วมันไม่ได้ยากอย่างที่คิดครับ เรามีหลายทางเลือกให้เลือกใช้ ขึ้นอยู่กับความต้องการของเรา

ถ้าอยากลองเล่น K8s แบบง่ายๆ ผมแนะนำให้ลองใช้ Minikube หรือ Kind ครับ มันคือ K8s cluster ขนาดเล็กที่รันบนเครื่องเราได้เลย เหมาะสำหรับการทดลองและเรียนรู้

ขั้นตอนปฏิบัติจริง

ติดตั้ง Minikube

Minikube คือ K8s cluster ขนาดเล็กที่รันบนเครื่องเราได้ เหมาะสำหรับการทดลองและเรียนรู้ วิธีติดตั้งก็ง่ายมากครับ

สำหรับ macOS:

brew install minikube

สำหรับ Linux:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

หลังจากติดตั้งเสร็จแล้ว ก็สั่ง start ได้เลย:

minikube start

Deploy Application

หลังจากที่เรามี K8s cluster แล้ว เราก็สามารถ Deploy Application ของเราได้เลย สมมติว่าเรามี Docker image ชื่อ `my-app-image:latest` เราสามารถ Deploy ได้ดังนี้:

kubectl create deployment my-app --image=my-app-image:latest
kubectl expose deployment my-app --port=8080 --type=NodePort

คำสั่งแรกจะสร้าง Deployment ชื่อ `my-app` โดยใช้ Docker image ที่เรากำหนด คำสั่งที่สองจะ expose Deployment ของเราผ่าน NodePort ซึ่งจะทำให้เราสามารถเข้าถึง Application ของเราได้ผ่าน Browser

SiamCafe Blog

ตรวจสอบ Status

เราสามารถตรวจสอบ Status ของ Deployment และ Service ของเราได้โดยใช้คำสั่ง:

kubectl get deployments
kubectl get services

คำสั่งเหล่านี้จะแสดงข้อมูลเกี่ยวกับ Deployment และ Service ของเรา เช่น จำนวน Pod ที่รันอยู่, Port ที่ expose และอื่นๆ

เปรียบเทียบกับทางเลือกอื่น

K8s ไม่ใช่เครื่องมือเดียวในการจัดการ Container นะครับ ยังมีทางเลือกอื่นๆ อีกมากมาย เช่น Docker Swarm, Apache Mesos และอื่นๆ แต่ละตัวก็มีข้อดีข้อเสียแตกต่างกันไป

Docker Swarm จะใช้งานง่ายกว่า K8s เหมาะสำหรับโปรเจคขนาดเล็กที่ไม่ต้องการความซับซ้อนมากนัก แต่ K8s จะมี Feature ที่หลากหลายกว่า และ Scale ได้ดีกว่า เหมาะสำหรับโปรเจคขนาดใหญ่ที่มีความต้องการสูง

Feature	Kubernetes	Docker Swarm
Complexity	Complex	Simple
Scalability	High	Medium
Features	Rich	Basic
Community	Large	Medium

Best Practices / เคล็ดลับจากประสบการณ์

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

จำไว้เลยว่า Kubernetes ไม่ใช่ยาวิเศษที่จะแก้ปัญหาทุกอย่างได้ มันเป็นแค่เครื่องมือหนึ่งที่เราเอามาใช้ให้เหมาะสมกับงานของเราเท่านั้นเอง เลือกใช้ให้ถูกที่ ถูกเวลา แล้วชีวิตจะง่ายขึ้นเยอะ

3 เทคนิคที่ใช้ได้จริง

เอาล่ะ มาดูเทคนิคที่ผมใช้จริงในสมัยที่ต้องดูแลระบบกันบ้าง บอกเลยว่าพวกนี้ช่วยชีวิตผมมาหลายครั้งแล้ว

1. Resource Limits และ Requests สำคัญมาก

อันนี้สำคัญสุดๆ! หลายคนมองข้ามเรื่องนี้ไป แต่จริงๆ แล้วมันเป็นตัวป้องกันไม่ให้ Pod กิน Resource เกินจำเป็น สมัยก่อนเคยเจอเคส Pod ตัวนึง Memory Leak กิน RAM ไปหมด Server แฮงค์ทั้ง Cluster! พอใส่ Resource Limits และ Requests เข้าไป ชีวิตดีขึ้นเยอะ

apiVersion: v1
kind: Pod
metadata:
  name: memory-demo
spec:
  containers:
  - name: memory-demo-ctr
    image: polinux/stress
    resources:
      limits:
        memory: "200Mi"
      requests:
        memory: "100Mi"
    command: ["stress"]
    args: ["--vm", "1", "--vm-bytes", "150Mi", "--vm-hang", "1"]

ง่ายๆ คือ Limits คือ Maximum ที่ Pod ใช้ได้ ส่วน Requests คือ Minimum ที่ Pod ต้องการ ถ้า Pod ต้องการมากกว่า Requests แต่ไม่เกิน Limits ก็ยังพอได้ แต่ถ้าเกิน Limits ระบบจะ Kill Pod ทันที

2. Liveness และ Readiness Probes ห้ามลืม

Liveness Probe เอาไว้เช็คว่า Pod ยังมีชีวิตอยู่ไหม Readiness Probe เอาไว้เช็คว่า Pod พร้อมให้บริการหรือยัง สมัยก่อนผมเคยเจอ Pod มันค้าง แต่ Kubernetes ไม่รู้เรื่อง ก็เลยไม่ Restart ให้ พอใส่ Probes เข้าไป ปัญหานี้ก็หมดไปเลย

apiVersion: v1
kind: Pod
metadata:
  name: liveness-readiness-example
spec:
  containers:
  - name: liveness-readiness-ctr
    image: k8s.gcr.io/busybox
    args:
    - /bin/sh
    - -c
    - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5
      periodSeconds: 5
    readinessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5
      periodSeconds: 5

Liveness Probe เหมือนคนคอยเคาะประตูถามว่า "เฮ้ ยังอยู่ไหม?" ถ้าไม่อยู่ Kubernetes จะ Restart Pod ให้ ส่วน Readiness Probe เหมือนถามว่า "เฮ้ พร้อมให้บริการหรือยัง?" ถ้ายังไม่พร้อม Kubernetes จะไม่ส่ง Traffic เข้ามา

3. Logging และ Monitoring คือเพื่อนแท้

Logging และ Monitoring เป็นสิ่งสำคัญมากในการ Debug ปัญหา สมัยก่อนผมต้อง Log ทุกอย่างที่เกิดขึ้นในระบบ แล้วเอามาวิเคราะห์ว่าเกิดอะไรขึ้น ทำไมระบบถึงมีปัญหา เดี๋ยวนี้มีเครื่องมือดีๆ เยอะแยะ ลองเลือกใช้ดู

ลองนึกภาพว่าคุณกำลังขับรถ ถ้าไม่มีมาตรวัดความเร็ว ไม่มีไฟเตือนน้ำมันหมด คุณจะขับรถได้ยังไง Logging และ Monitoring ก็เหมือนกัน ช่วยให้เราเห็นสิ่งที่เกิดขึ้นในระบบของเรา

FAQ คำถามที่พบบ่อย

Kubernetes เหมาะกับงานแบบไหน?

Kubernetes เหมาะกับงานที่ต้องการ Scalability, High Availability และ Automated Deployment ถ้างานของคุณมีลักษณะแบบนี้ Kubernetes จะช่วยให้ชีวิตคุณง่ายขึ้นเยอะ แต่ถ้างานของคุณเล็กๆ ไม่ซับซ้อน อาจจะไม่คุ้มที่จะใช้ Kubernetes

Kubernetes ยากจริงไหม?

ในช่วงแรกๆ อาจจะยากหน่อย แต่ถ้าคุณเข้าใจหลักการมันจริงๆ มันก็ไม่ได้ยากอย่างที่คิด เริ่มจาก Basics ก่อน แล้วค่อยๆ เรียนรู้ไปเรื่อยๆ เดี๋ยวก็เก่งเอง

Kubernetes กับ Docker ต่างกันยังไง?

Docker คือ Container Runtime ที่ใช้สร้างและรัน Container ส่วน Kubernetes คือ Orchestration Tool ที่ใช้จัดการ Container หลายๆ ตัว Docker เหมือนเครื่องยนต์ ส่วน Kubernetes เหมือนคนขับรถ

มี Tool อะไรที่ช่วยให้ใช้ Kubernetes ง่ายขึ้นบ้าง?

มีเยอะแยะเลย! Minikube เอาไว้รัน Kubernetes บนเครื่องตัวเอง, Helm เอาไว้จัดการ Package ของ Kubernetes, Kubectl เป็น Command-Line Tool ที่ใช้ Interact กับ Kubernetes Cluster ลองศึกษาดูครับ

สรุป

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

อย่าลืมติดตาม SiamCafe Blog นะครับ ผมจะเอาประสบการณ์ IT 28+ ปี มาเล่าให้ฟังเรื่อยๆ