Kubernetes คืออะไร และมันแก้ปัญหาอะไรบ้าง?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (มักเรียกย่อว่า **K8s**) เป็นแพลตฟอร์ม **container orchestration** แบบโอเพนซอร์ส มันทำให้การ deploy, การ scale, การเชื่อมต่อเครือข่าย และการซ่อมแซมตัวเองของแอปพลิเคชันที่รันแบบ container เป็นอัตโนมัติทั่วทั้ง cluster ของเครื่องหลายเครื่อง คุณจึงเพียงอธิบาย *สถานะที่ต้องการ (desired state)* แล้ว Kubernetes จะทำงานอย่างต่อเนื่องเพื่อทำให้ความเป็นจริงตรงกับสถานะนั้น

## ปัญหา: การรัน container ในระดับใหญ่นั้นยาก

```text
You have containers (from Docker), but in production you must also answer:
  → แต่ละ container รันบนเครื่อง (machine) ไหน? (scheduling)
  → ถ้า container crash ล่ะ? (self-healing / restart)
  → ถ้าทั้ง node ตายล่ะ? (reschedule ไปที่อื่น)
  → 50 replica จะค้นหาและคุยกันได้อย่างไร? (service discovery)
  → จะ roll out เวอร์ชันใหม่โดยไม่มี downtime ได้อย่างไร? (rolling update)
  → จะ scale จาก 3 เป็น 30 replica ตอนทราฟฟิกพุ่งได้อย่างไร? (autoscaling)
การทำทั้งหมดนี้ด้วยมือบนเซิร์ฟเวอร์หลายเครื่องนั้นขยายขนาดไม่ไหว
```

## ทางออก: orchestration แบบ declarative

คุณส่ง **manifest** ที่อธิบายสิ่งที่คุณต้องการ แล้ว **control loop** ของ cluster จะขับเคลื่อนระบบให้ไปสู่สถานะนั้น:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "ฉันต้องการให้มี 3 ก็อปปี้รันอยู่เสมอ"
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: nginx:1.27
          ports:
            - containerPort: 80
```

```bash
kubectl apply -f web.yaml     # ประกาศสถานะที่ต้องการ
kubectl get pods              # Kubernetes ได้สร้าง & จัดตาราง 3 Pod แล้ว
```

ถ้า Pod ตาย Kubernetes จะสังเกตเห็นช่องว่าง (รันอยู่ 2 เทียบกับที่ต้องการ 3) และสร้างตัวแทนขึ้นมาโดยอัตโนมัติ

## Kubernetes มอบอะไรให้คุณบ้าง

```text
✓ SCHEDULING       — วาง Pod ลงบน node ตามทรัพยากร & ข้อจำกัด
✓ SELF-HEALING     — restart container ที่ล้มเหลว, แทนที่ Pod/node ที่ตาย
✓ SERVICE DISCOVERY— IP เสมือน & ชื่อ DNS ที่เสถียรสำหรับกลุ่มของ Pod
✓ LOAD BALANCING   — กระจายทราฟฟิกไปยัง replica ที่แข็งแรง
✓ ROLLING UPDATES  — ปล่อยเวอร์ชันใหม่โดยไม่มี downtime, rollback เมื่อล้มเหลว
✓ SCALING          — ด้วยมือหรืออัตโนมัติ (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — inject การตั้งค่าโดยไม่ต้อง build image ใหม่
✓ STORAGE ORCHESTRATION — แนบ persistent volume เข้ากับ workload
```

## Declarative เทียบกับ imperative

```text
IMPERATIVE  → "รันคำสั่งนี้ แล้วคำสั่งนั้น" (คุณจัดการแต่ละขั้นตอนเอง)
DECLARATIVE → "นี่คือสถานะสุดท้ายที่ฉันต้องการ" (Kubernetes ปรับให้ตรงเอง)
โมเดล declarative แบบ reconciliation-loop คือแนวคิดแกนกลางของ Kubernetes
```

## ทำไมจึงสำคัญ

Kubernetes ได้กลายเป็นมาตรฐานโดยพฤตินัยสำหรับการรัน workload แบบ container ใน production ดังนั้นการเข้าใจว่ามันคืออะไรและแก้ปัญหาอะไรจึงเป็นความรู้พื้นฐานที่นำไปใช้ได้กว้างขวาง Container (จากเครื่องมืออย่าง Docker) แก้ปัญหาการแพ็กเกจ แต่มันไม่ตอบคำถามด้านการปฏิบัติงานที่เกิดขึ้นเมื่อขยายขนาด: แต่ละ container รันบนเครื่องไหน, จะเกิดอะไรขึ้นเมื่อ container หรือทั้ง node ล้มเหลว, replica หลายสิบตัวจะค้นหาและคุยกันอย่างไร, จะ roll out เวอร์ชันใหม่โดยไม่มี downtime ได้อย่างไร และจะขยาย/ลดขนาดตามความต้องการได้อย่างไร Kubernetes จัดการทั้งหมดนี้ผ่านโมเดล **declarative ที่อิงการ reconciliation**: คุณอธิบายสถานะที่ต้องการใน manifest แล้ว control loop ของ cluster จะขับเคลื่อนสถานะจริงให้ไปสู่สถานะนั้นอย่างต่อเนื่อง — สร้าง, จัดตาราง, restart และแทนที่ Pod ตามความจำเป็น สิ่งนี้มอบ **self-healing** (container ที่ crash และ node ที่ตายจะถูกกู้คืนโดยอัตโนมัติ), **service discovery และ load balancing** (IP เสมือนและ DNS ที่เสถียรอยู่หน้ากลุ่มของ Pod), **rolling update และ rollback** (deploy โดยไม่มี downtime), **scaling** (ด้วยมือหรืออัตโนมัติ) และ **orchestration ของ config, secret และ storage** เพราะ Kubernetes เป็นรากฐานของวิธีที่อุตสาหกรรมส่วนใหญ่ deploy และดำเนินการซอฟต์แวร์ — บนทุก cloud ใหญ่และแบบ on-premises — การเข้าใจจุดมุ่งหมายของมันและโมเดล declarative ที่เป็นแกนกลางจึงเป็นบริบทที่จำเป็นสำหรับงานโครงสร้างพื้นฐานยุคใหม่ และเป็นรากฐานทางความคิดที่ทุกแนวคิด Kubernetes อื่น ๆ ต่อยอดขึ้นไป

ปัญหา: การรัน container ในระดับใหญ่นั้นยาก

ทางออก: orchestration แบบ declarative

Kubernetes มอบอะไรให้คุณบ้าง

Declarative เทียบกับ imperative

ทำไมจึงสำคัญ

คำถามที่เกี่ยวข้อง