Kubernetes — จัดการ Container ให้เป็นระบบด้วย K8s

จากโพสต์ที่แล้วเราเรียนรู้ Docker ว่ามันช่วยให้เรา pack app + dependencies ไว้ใน Container เดียว ทำให้ deploy ได้ทุกที่

แต่ถ้าเรามี Container เป็น สิบ... ร้อย... พัน ตัวล่ะ? ใครจะมานั่งสั่ง docker run ทีละตัว? 😵

นี่คือปัญหาที่ Kubernetes (K8s) มาแก้ — มันเป็น Container Orchestrator ที่ช่วยจัดการ container ให้ทำงานร่วมกันอย่างเป็นระบบ เหมือนกัปตันเรือที่คุมตู้สินค้า (container) ทั้งลำ ⚓🐕

Kubernetes คืออะไร?

Kubernetes (อ่านว่า คู-เบอร์-เน-ทิส, ย่อว่า K8s) คือ open-source container orchestration platform ที่พัฒนาโดย Google ปัจจุบันดูแลโดย CNCF

หน้าที่หลักคือ:

จัดวาง Container — เลือกว่า container ไหนรันบนเครื่องไหน (Scheduling)
Scaling — เพิ่ม/ลด container ตาม traffic อัตโนมัติ
Self-healing — container ตาย? K8s สร้างตัวใหม่ทันที
Load Balancing — กระจาย traffic ให้เท่าๆ กัน
Rolling Updates — อัปเดตแอปโดยไม่ downtime

💡 จำง่ายๆ: Docker = สร้าง Container | Kubernetes = จัดการ Container

ทำไมต้อง Kubernetes?

Docker Compose ก็จัดการหลาย containers ได้ แล้วทำไมต้อง K8s? คำตอบคือ Compose ทำงานบน เครื่องเดียว แต่ K8s ทำงานบน หลายเครื่อง (cluster) — auto-scaling, self-healing, rolling updates, service discovery ทั้งหมดอัตโนมัติ ลองนึกภาพว่าเรามี web app ที่ใช้ 3 services:

🌐 Frontend

React App × 3

→

⚙️ Backend

Node.js API × 5

→

🗄️ Database

PostgreSQL × 2

รวม 10 containers — ถ้าจัดการด้วยมือจะต้อง:

สั่ง docker run ทีละตัว
ถ้า container ตาย ต้อง restart เอง
Traffic เพิ่ม? ต้อง scale เอง
Deploy version ใหม่? ต้องหยุดทีละตัว

Kubernetes ทำทั้งหมดนี้ให้อัตโนมัติ! 🚀

K8s Architecture — มีอะไรอยู่ข้างใน?

Kubernetes cluster แบ่งเป็น 2 ส่วนหลัก — Control Plane (สมอง — ตัดสินใจว่า Pod ไหนรันที่ไหน, ดูแล desired state) กับ Worker Nodes (แรงงาน — รัน containers จริง) Control Plane มักมี 3 เครื่องเพื่อ HA ส่วน Worker Nodes มีได้ไม่จำกัด เพิ่ม nodes = เพิ่ม capacity:

Kubernetes Cluster

Control Plane (Master)

API Server

Scheduler

Controller Manager

etcd (Database)

Worker Node 1

kubelet

kube-proxy

Pod (App A)

Pod (App B)

Worker Node 2

kubelet

kube-proxy

Pod (App A)

Pod (App C)

Control Plane (สมอง)

Control Plane มี 4 components หลัก: API Server (ประตูหน้าเดียว — kubectl, dashboard ทุกอย่างผ่านตัวนี้), etcd (key-value store เก็บ state ทั้งหมดของ cluster), Scheduler (ตัดสินใจว่า Pod ใหม่ไปรันที่ Node ไหน), Controller Manager (ดูแลว่า actual state = desired state):

API Server — ประตูหน้าบ้าน ทุกคำสั่งต้องผ่านตรงนี้
Scheduler — เลือกว่า Pod ไหนจะรันบน Node ไหน
Controller Manager — ดูแลให้ state ตรงกับที่เรากำหนด
etcd — ฐานข้อมูลที่เก็บ config ทั้งหมดของ cluster

Worker Node (แรงงาน)

แต่ละ Worker Node มี 3 components: kubelet (agent ที่รับคำสั่งจาก Control Plane แล้วจัดการ Pods), kube-proxy (จัดการ networking ภายใน cluster), Container Runtime (containerd/CRI-O — ตัวรัน containers จริง):

kubelet — agent ที่รันบนทุก Node คอยดูแล Pod
kube-proxy — จัดการ networking ให้ Pod คุยกันได้
Pod — หน่วยที่เล็กที่สุดใน K8s (ข้างในมี container)

K8s Core Concepts — คำศัพท์ที่ต้องรู้

K8s มีศัพท์เฉพาะเยอะ แต่ core concepts ที่ต้องเข้าใจมีไม่กี่ตัว — Pod (หน่วยเล็กที่สุดใน K8s ห่อ 1+ containers), Deployment (จัดการ Pods — scaling, rolling updates), Service (ทำให้ Pods มี stable endpoint), Ingress (route traffic จาก internet เข้า Services) เข้าใจ 4 ตัวนี้ก็เริ่มใช้ K8s ได้แล้ว:

Concept	คืออะไร	เปรียบเทียบ
Pod	หน่วยเล็กสุด (1+ containers)	ห้องพัก 1 ห้อง
Deployment	จัดการ Pod ให้มีจำนวนตามที่กำหนด	ผู้จัดการโรงแรม
Service	เปิดทางให้เข้าถึง Pod ได้	ประตูทางเข้า
Node	เครื่อง (physical/VM) ที่รัน Pod	ตึกอาคาร
Namespace	แบ่งกลุ่ม resources	ชั้นของตึก
ConfigMap	เก็บ config (key-value)	ป้ายติดห้อง
Secret	เก็บข้อมูลลับ (encoded)	ตู้เซฟ
Ingress	จัดการ HTTP routing จากภายนอก	ล็อบบี้โรงแรม

Hands-on — Deploy แอปแรกด้วย K8s

มาลองใช้จริง! ขั้นตอนหลักคือ: สร้าง Deployment (บอกว่ารัน image อะไร กี่ replicas) → สร้าง Service (expose ให้เข้าถึงได้) → Scale (เพิ่ม/ลด replicas) → Update (เปลี่ยน version โดยไม่ downtime)

1. สร้าง Deployment

Deployment YAML กำหนด: replicas (กี่ Pods), image (Docker image ไหน), resources (CPU/Memory limits), readinessProbe (ตรวจว่า Pod พร้อมรับ traffic ก่อน route เข้ามา) สังเกตว่าเป็น declarative — บอก "ต้องการอะไร" ไม่ใช่ "ทำอะไร":

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-web-app
  labels:
    app: web
spec:
  replicas: 3          # รัน 3 pods
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:alpine
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "100m"
          limits:
            memory: "128Mi"
            cpu: "250m"

# สร้าง deployment
kubectl apply -f deployment.yaml

# ดูสถานะ
kubectl get pods
# NAME                          READY   STATUS    RESTARTS   AGE
# my-web-app-6d8f7b4c5-abc12   1/1     Running   0          10s
# my-web-app-6d8f7b4c5-def34   1/1     Running   0          10s
# my-web-app-6d8f7b4c5-ghi56   1/1     Running   0          10s

2. สร้าง Service

Service ทำให้ Pods มี stable IP/DNS name — เพราะ Pods มาและไป (scale, crash, update) แต่ Service address คงที่เสมอ มี 3 types: ClusterIP (ภายใน cluster), NodePort (expose port บน Node), LoadBalancer (สร้าง cloud LB อัตโนมัติ):

apiVersion: v1
kind: Service
metadata:
  name: web-service
spec:
  type: LoadBalancer
  selector:
    app: web         # เชื่อมกับ Pod ที่มี label app=web
  ports:
  - port: 80         # port ที่เปิดให้ภายนอก
    targetPort: 80   # port ของ container

# สร้าง service
kubectl apply -f service.yaml

# ดู service
kubectl get svc
# NAME          TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)
# web-service   LoadBalancer   10.96.45.123   203.0.113.50    80:31234/TCP

3. Scaling — เพิ่ม/ลด Pod

Scale ได้ง่ายมาก — แค่แก้ replicas แล้ว K8s สร้าง/ลบ Pods ให้อัตโนมัติ หรือใช้ HPA (Horizontal Pod Autoscaler) ให้ scale ตาม CPU/Memory usage อัตโนมัติ:

# Scale เป็น 5 pods
kubectl scale deployment my-web-app --replicas=5

# ดูผล
kubectl get pods
# จะเห็น 5 pods running!

4. Rolling Update — อัปเดตโดยไม่ downtime

Rolling Update คือฟีเจอร์ที่ทำให้ K8s โดดเด่น — เมื่อ update image version K8s จะค่อยๆ สร้าง Pod ใหม่ (version ใหม่) แล้วลบ Pod เก่าทีละตัว ถ้า Pod ใหม่ fail จะ rollback อัตโนมัติ — zero downtime deployment:

# เปลี่ยน image เป็น version ใหม่
kubectl set image deployment/my-web-app web=nginx:1.25

# ดูสถานะ update
kubectl rollout status deployment/my-web-app
# Waiting for deployment "my-web-app" rollout to finish...
# deployment "my-web-app" successfully rolled out

# ผิดพลาด? Rollback!
kubectl rollout undo deployment/my-web-app

Self-healing — K8s ซ่อมตัวเอง

Self-healing คือฟีเจอร์ที่ทำให้ K8s แตกต่างจาก Docker Compose — ถ้า Pod crash, Node ล่ม, หรือ health check fail K8s จะ detect และสร้าง Pod ใหม่อัตโนมัติ ไม่ต้องมีคนมานั่ง monitor แล้ว restart เอง ทำงาน 24/7 ไม่มีวันหยุด:

# ลอง kill pod ทิ้ง
kubectl delete pod my-web-app-6d8f7b4c5-abc12

# ดูอีกที — K8s สร้างตัวใหม่มาแทนแล้ว!
kubectl get pods
# my-web-app-6d8f7b4c5-xyz99   1/1     Running   0          3s  ← ตัวใหม่!
# my-web-app-6d8f7b4c5-def34   1/1     Running   0          5m
# my-web-app-6d8f7b4c5-ghi56   1/1     Running   0          5m

🐕 K8s จำ "desired state" ไว้เสมอ: เราบอกว่าต้องการ 3 pods → ถ้าเหลือ 2 มันจะสร้างเพิ่มจนครบ 3 เอง!

Docker Compose vs Kubernetes

คำถามที่พบบ่อย — "ควรใช้ Compose หรือ K8s?" ไม่ใช่เรื่องของ "ตัวไหนดีกว่า" แต่เป็น "ต้องการอะไร" — Compose เหมาะกับ single server, dev environment, small apps ส่วน K8s เหมาะกับ production ที่ต้อง scale, HA, multi-team:

Feature	Docker Compose	Kubernetes
เหมาะกับ	Development, เครื่องเดียว	Production, หลายเครื่อง
Scaling	Manual	Auto-scaling ได้
Self-healing	❌ ไม่มี	✅ อัตโนมัติ
Load Balancing	ต้องตั้งเอง	Built-in
Rolling Update	❌ ต้อง down	✅ Zero-downtime
ความซับซ้อน	ง่าย	ซับซ้อนกว่า
Config ไฟล์	`docker-compose.yml`	YAML manifests

💡 กฎง่ายๆ: Dev ใช้ Docker Compose, Production ใช้ Kubernetes

เริ่มต้นลองเล่น K8s

ไม่ต้องมี cluster จริงก็ลองได้! มี tools สำหรับรัน K8s บนเครื่องตัวเอง — เหมาะกับการเรียนรู้และ development แนะนำเริ่มจาก minikube (ง่ายที่สุด) หรือ kind (K8s ใน Docker — เร็วมาก):

Minikube — K8s บนเครื่องตัวเอง (แนะนำสำหรับมือใหม่)
Kind — K8s ใน Docker container
K3s — K8s เวอร์ชันเบาๆ สำหรับ Raspberry Pi / Edge
Docker Desktop — เปิด K8s ได้ในตัว (Settings → Kubernetes → Enable)

# ติดตั้ง minikube แล้วเริ่ม cluster
minikube start

# ลอง deploy
kubectl create deployment hello --image=nginx
kubectl expose deployment hello --port=80 --type=NodePort

# เปิดดูในเบราว์เซอร์
minikube service hello

สรุป

Kubernetes คือ industry standard สำหรับ container orchestration — ทุก cloud provider รองรับ (EKS, AKS, GKE) และเป็นทักษะที่ DevOps engineers ต้องมี เรียนรู้ curve สูง แต่เมื่อเข้าใจแล้วจะเห็นว่ามันแก้ปัญหาจริงๆ ที่ Docker เดี่ยวๆ ทำไม่ได้:

Kubernetes = Container Orchestrator ที่จัดการ deploy, scale, heal อัตโนมัติ
Pod = หน่วยเล็กสุด | Deployment = จัดการ Pod | Service = เปิดทางเข้า
Control Plane = สมอง (API Server, Scheduler, etcd) | Worker Node = แรงงาน (kubelet, pods)
Self-healing + Auto-scaling + Rolling Updates = ฟีเจอร์หลักที่ทำให้ K8s จำเป็นใน Production
Docker Compose สำหรับ dev, Kubernetes สำหรับ production
เริ่มเล่นง่ายๆ ด้วย Minikube หรือ Docker Desktop ⚓🐕

บทความจากซีรีส์ DevOps & Vibe Coding 2026