คู่มือฉบับสมบูรณ์: Kubernetes บน Ubuntu 24.04 สำหรับมือใหม่

by

ในโลกของการพัฒนาและจัดการแอปพลิเคชันยุคใหม่ การทำความเข้าใจและใช้งาน Kubernetes (K8s) ถือเป็นทักษะสำคัญที่ไม่อาจมองข้ามได้ Kubernetes เป็นแพลตฟอร์ม Open-source สำหรับการจัดการคอนเทนเนอร์แบบอัตโนมัติ ซึ่งช่วยให้คุณสามารถ Deploy, Scale และจัดการแอปพลิเคชันที่รันในคอนเทนเนอร์ได้อย่างมีประสิทธิภาพ บทความนี้จะพาคุณไปติดตั้ง Kubernetes บน Ubuntu 24.04 LTS ซึ่งเป็นเวอร์ชันล่าสุดที่มีความเสถียรและรองรับระยะยาว ตั้งแต่เริ่มต้นจนสามารถ Deploy แอปพลิเคชันและมอนิเตอร์ได้จริง

บทนำ: ทำไมต้อง Kubernetes และ Ubuntu 24.04?

Kubernetes ได้กลายเป็นมาตรฐานอุตสาหกรรมสำหรับการ Orchestration คอนเทนเนอร์ ด้วยความสามารถในการจัดการ Workload ที่ซับซ้อน, การทำ Self-healing, Load Balancing และการทำ Rolling Update ได้อย่างราบรื่น ทำให้การพัฒนาและดูแลรักษาแอปพลิเคชันในสภาพแวดล้อม Production เป็นเรื่องง่ายขึ้น

ส่วน Ubuntu 24.04 LTS (Noble Numbat) เป็นระบบปฏิบัติการ Linux ยอดนิยมที่ได้รับความไว้วางใจจากนักพัฒนาและองค์กรต่างๆ ทั่วโลก ด้วยการรองรับระยะยาวถึง 5 ปี (หรือ 10 ปีสำหรับ ESM) และการอัปเดตซอฟต์แวร์ที่ทันสมัย ทำให้เป็นแพลตฟอร์มที่ยอดเยี่ยมและมั่นคงสำหรับการติดตั้ง Kubernetes

สิ่งที่ต้องเตรียม (Prerequisites)

ก่อนที่เราจะเริ่มติดตั้ง Kubernetes คุณจำเป็นต้องมีเครื่องเซิร์ฟเวอร์หรือ Virtual Machine (VM) ที่ใช้ Ubuntu 24.04 อย่างน้อย 2 เครื่อง (สำหรับ Control Plane และ Worker Node) โดยมีข้อกำหนดขั้นต่ำดังนี้:

  • Control Plane Node (Master):
    • CPU: 2 Cores หรือมากกว่า
    • RAM: 2GB หรือมากกว่า
    • พื้นที่ดิสก์: 20GB หรือมากกว่า
  • Worker Node(s):
    • CPU: 1 Core หรือมากกว่า
    • RAM: 1GB หรือมากกว่า
    • พื้นที่ดิสก์: 20GB หรือมากกว่า
  • เครือข่าย:
    • ทุก Node ต้องสามารถสื่อสารกันได้ผ่านเครือข่ายส่วนตัว
    • IP Address แบบ Static สำหรับทุก Node
    • ปิด Firewall หรือเปิดพอร์ตที่จำเป็น (สำหรับมือใหม่ แนะนำให้ปิด Firewall ชั่วคราวเพื่อความง่าย)
  • สิทธิ์: ผู้ใช้งานที่มีสิทธิ์ sudo

Tip: เพื่อความง่ายในการทดลองในสภาพแวดล้อม Development คุณสามารถใช้เครื่องเดียวเป็นทั้ง Control Plane และ Worker Node ได้ แต่สำหรับ Production ควรแยก Node ออกจากกัน

ขั้นตอนที่ 1: เตรียมระบบปฏิบัติการ Ubuntu 24.04 (ทุก Node)

ดำเนินการตามขั้นตอนเหล่านี้บนทุก Node (Control Plane และ Worker Node):

1.1 อัปเดตระบบและติดตั้งแพ็คเกจที่จำเป็น

sudo apt update && sudo apt upgrade -y
sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release

1.2 ปิด Swap

Kubernetes ต้องการให้ Swap ถูกปิดใช้งานเพื่อประสิทธิภาพที่ดีที่สุด

sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

1.3 กำหนดค่า Kernel Modules และ Sysctl

เปิดใช้งาน Kernel modules ที่จำเป็นและปรับแต่ง Sysctl เพื่อให้ Kubernetes ทำงานได้อย่างถูกต้อง

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# กำหนดค่า sysctl
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system

ขั้นตอนที่ 2: ติดตั้ง Container Runtime (Containerd) (ทุก Node)

Kubernetes ใช้ Container Runtime เพื่อรันคอนเทนเนอร์ เราจะใช้ Containerd ซึ่งเป็นตัวเลือกที่ได้รับความนิยมและมีประสิทธิภาพ

2.1 ติดตั้ง Containerd

# เพิ่ม Docker GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# เพิ่ม Docker repository
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y containerd.io

2.2 กำหนดค่า Containerd

สร้างไฟล์คอนฟิกเริ่มต้นสำหรับ Containerd และตั้งค่าให้ใช้ systemd เป็น cgroup driver ซึ่งเข้ากันได้กับ kubelet

sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml

2.3 รีสตาร์ทและเปิดใช้งาน Containerd

sudo systemctl restart containerd
sudo systemctl enable containerd

ขั้นตอนที่ 3: ติดตั้ง Kubeadm, Kubelet และ Kubectl (ทุก Node)

kubeadm ใช้สำหรับบูตสแตรปคลัสเตอร์, kubelet เป็น Agent ที่รันบนทุก Node และ kubectl เป็น Command-line tool สำหรับสื่อสารกับคลัสเตอร์

3.1 เพิ่ม Kubernetes APT Repository

# เพิ่ม GPG key ของ Kubernetes
sudo curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
sudo chmod a+r /etc/apt/keyrings/kubernetes-apt-keyring.gpg

# เพิ่ม Kubernetes repository
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt update

3.2 ติดตั้ง Kubeadm, Kubelet และ Kubectl

แนะนำให้ติดตั้งเวอร์ชันที่ระบุเพื่อหลีกเลี่ยงปัญหาความเข้ากันได้ สำหรับบทความนี้ เราจะใช้เวอร์ชัน 1.29.x

sudo apt install -y kubelet=1.29.3-1.1 kubeadm=1.29.3-1.1 kubectl=1.29.3-1.1
sudo apt-mark hold kubelet kubeadm kubectl

apt-mark hold จะป้องกันไม่ให้แพ็คเกจเหล่านี้ถูกอัปเดตโดยไม่ตั้งใจ

ขั้นตอนที่ 4: เริ่มต้น Kubernetes Control Plane (เฉพาะ Control Plane Node)

ดำเนินการขั้นตอนเหล่านี้บน Control Plane Node เท่านั้น

4.1 เริ่มต้น Control Plane

ใช้ kubeadm init เพื่อเริ่มต้น Control Plane คุณจะต้องระบุ Pod Network CIDR สำหรับ Calico

sudo kubeadm init --pod-network-cidr=192.168.0.0/16

เมื่อคำสั่งนี้รันสำเร็จ คุณจะเห็นข้อความแนะนำให้รันคำสั่งต่อไปนี้เพื่อตั้งค่า kubectl สำหรับผู้ใช้งานปัจจุบัน และคำสั่ง kubeadm join สำหรับ Worker Node

4.2 กำหนดค่า Kubectl

รันคำสั่งที่ได้รับจาก kubeadm init เพื่อให้ผู้ใช้ธรรมดาสามารถใช้งาน kubectl ได้

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

4.3 ติดตั้ง Pod Network Add-on (Calico)

เครือข่าย Pod เป็นสิ่งจำเป็นเพื่อให้ Pods สามารถสื่อสารกันได้ เราจะใช้ Calico

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.27.2/manifests/calico.yaml

รอสักครู่เพื่อให้ Pods ของ Calico เริ่มทำงาน คุณสามารถตรวจสอบสถานะได้ด้วย kubectl get pods -n kube-system

4.4 ตรวจสอบสถานะคลัสเตอร์

ตรวจสอบว่า Node พร้อมใช้งานหรือไม่

kubectl get nodes

คุณควรเห็น Control Plane Node อยู่ในสถานะ Ready

ขั้นตอนที่ 5: เข้าร่วม Worker Node (เฉพาะ Worker Node)

บน Worker Node ให้รันคำสั่ง kubeadm join ที่คุณได้รับจาก kubeadm init บน Control Plane Node

# ตัวอย่าง:
sudo kubeadm join 192.168.1.100:6443 --token abcdef.0123456789abcdef \
    --discovery-token-ca-cert-hash sha256:731b94d13b41d06e838b99180f68153c...

แทนที่ IP Address, token และ hash ด้วยค่าจริงที่คุณได้รับ

กลับไปที่ Control Plane Node และรัน kubectl get nodes อีกครั้ง คุณควรเห็น Worker Node อยู่ในสถานะ Ready เช่นกัน

ขั้นตอนที่ 6: การใช้งาน Kubectl และ Pod Deployment เบื้องต้น

เมื่อคลัสเตอร์พร้อมใช้งาน เรามาลอง Deploy แอปพลิเคชันแรกของเรากัน

6.1 ตรวจสอบคลัสเตอร์

kubectl get pods --all-namespaces
kubectl get deployments --all-namespaces
kubectl get services --all-namespaces

6.2 Deploy Nginx Pod

สร้างไฟล์ nginx-pod.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80

Deploy Pod:

kubectl apply -f nginx-pod.yaml

ตรวจสอบสถานะ Pod:

kubectl get pods -l app=nginx
kubectl describe pod nginx-pod

ขั้นตอนที่ 7: การตั้งค่า Ingress เพื่อเข้าถึงแอปพลิเคชัน

Ingress ช่วยให้เราสามารถเข้าถึง Services ภายในคลัสเตอร์จากภายนอกได้โดยใช้ HTTP/HTTPS เราจะต้องติดตั้ง Ingress Controller ก่อน

7.1 ติดตั้ง Nginx Ingress Controller

เราจะใช้ Nginx Ingress Controller ซึ่งเป็นที่นิยม

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.9.4/deploy/static/provider/cloud/deploy.yaml

รอจนกว่า Pods ของ Ingress Controller จะพร้อมใช้งาน:

kubectl get pods -n ingress-nginx

7.2 สร้าง Service และ Ingress Resource สำหรับ Nginx

สร้างไฟล์ nginx-service-ingress.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: myapp.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80

Deploy Service และ Ingress:

kubectl apply -f nginx-service-ingress.yaml

7.3 ทดสอบ Ingress

แก้ไขไฟล์ /etc/hosts บนเครื่องที่คุณใช้เข้าถึง เพื่อให้ myapp.local ชี้ไปยัง IP ของ Node ที่ Ingress Controller รันอยู่ (หรือ IP ของ Control Plane หากใช้ Node เดียว) คุณสามารถหา IP ได้จาก kubectl get nodes -o wide

# บนเครื่อง Client ของคุณ (ไม่ใช่บน Node K8s)
sudo nano /etc/hosts
# เพิ่มบรรทัดนี้ โดยแทนที่ YOUR_NODE_IP ด้วย IP ของ K8s Node
# ตัวอย่าง: 192.168.1.100 myapp.local

จากนั้นเปิดเว็บเบราว์เซอร์ไปที่ http://myapp.local คุณควรเห็นหน้า Nginx default page

ขั้นตอนที่ 8: การมอนิเตอร์ด้วย Prometheus

Prometheus เป็นเครื่องมือมอนิเตอร์ยอดนิยมในระบบ Cloud-native เราจะติดตั้งผ่าน Helm ซึ่งเป็น Package Manager สำหรับ Kubernetes

8.1 ติดตั้ง Helm

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

ตรวจสอบการติดตั้ง:

helm version

8.2 ติดตั้ง Prometheus Stack ด้วย Helm

เราจะใช้ Prometheus-kube-stack ซึ่งรวม Prometheus, Grafana และ Exporters ต่างๆ

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

helm install prometheus prometheus-community/kube-prometheus-stack --namespace monitoring --create-namespace

รอสักครู่เพื่อให้ Pods ทั้งหมดใน Namespace monitoring เริ่มทำงาน

8.3 เข้าถึง Prometheus และ Grafana UI

โดยปกติแล้ว Prometheus และ Grafana จะถูกติดตั้งเป็น ClusterIP Service คุณสามารถเข้าถึงได้โดยการทำ Port-forwarding

# สำหรับ Prometheus UI
kubectl port-forward -n monitoring service/prometheus-kube-prometheus-prometheus 9090:9090 &

# สำหรับ Grafana UI
kubectl port-forward -n monitoring service/prometheus-grafana 3000:80 &

จากนั้นเปิดเว็บเบราว์เซอร์ไปที่ http://localhost:9090 สำหรับ Prometheus และ http://localhost:3000 สำหรับ Grafana (Username/Password เริ่มต้นของ Grafana คือ admin/prom-operator)

การแก้ไขปัญหาที่พบบ่อย (Troubleshooting Common Issues)

  • Pods ค้างที่สถานะ Pending:
    • ตรวจสอบว่า Pod Network Add-on (เช่น Calico) ติดตั้งและทำงานอย่างถูกต้องหรือไม่
    • ตรวจสอบ Resource availability บน Node (CPU, Memory)
    • ดู Event ของ Pod: kubectl describe pod <pod-name>
  • kubectl ไม่เชื่อมต่อ (The connection to the server was refused):
    • ตรวจสอบว่า admin.conf ถูกคัดลอกไปยัง $HOME/.kube/config และมีการตั้งค่าสิทธิ์ที่ถูกต้อง
    • ตรวจสอบสถานะของ kube-apiserver Pod ใน Namespace kube-system
    • ตรวจสอบ Firewall บน Control Plane Node
  • kubeadm init ล้มเหลว:
    • ตรวจสอบว่า Swap ถูกปิดใช้งานแล้ว
    • ตรวจสอบว่า Kernel modules (overlay, br_netfilter) ถูกโหลดและ Sysctl ถูกตั้งค่าอย่างถูกต้อง
    • ตรวจสอบว่า Containerd ใช้ systemd เป็น cgroup driver
  • Ingress ไม่ทำงาน:
    • ตรวจสอบสถานะของ Ingress Controller Pods ใน Namespace ingress-nginx
    • ตรวจสอบว่า Service ที่ Ingress ชี้ไปนั้นทำงานอยู่
    • ตรวจสอบการตั้งค่า DNS (/etc/hosts) บนเครื่อง Client
    • ดู Event ของ Ingress: kubectl describe ingress <ingress-name>

Tip: การใช้ journalctl -xeu kubelet หรือ journalctl -xeu containerd สามารถช่วยในการ Debug ปัญหาที่เกี่ยวข้องกับ Kubelet หรือ Containerd ได้

Tips & Tricks จากประสบการณ์จริง

  • ใช้ Namespaces: จัดระเบียบทรัพยากรของคุณด้วย Namespaces เพื่อแยกแอปพลิเคชันหรือทีมออกจากกัน เช่น kubectl create namespace dev
  • กำหนด Resource Limits: กำหนด requests และ limits สำหรับ CPU และ Memory ใน Pods ของคุณ เพื่อป้องกันไม่ให้ Pod ใด Pod หนึ่งใช้ทรัพยากรมากเกินไปและส่งผลกระทบต่อ Pod อื่นๆ
  • ใช้ Helm Charts: สำหรับการ Deploy แอปพลิเคชันที่ซับซ้อนหรือ Third-party tools (เช่น Prometheus, Grafana) การใช้ Helm Charts จะช่วยให้การติดตั้งและจัดการเป็นเรื่องง่ายขึ้นมาก
  • ศึกษา kubectl explain: หากคุณไม่แน่ใจเกี่ยวกับฟิลด์ใดๆ ในไฟล์ YAML คุณสามารถใช้ kubectl explain <resource.field> เพื่อดูคำอธิบายได้ เช่น kubectl explain pod.spec.containers.ports
  • สำรองข้อมูล ETCD: สำหรับ Production Environment การสำรองข้อมูล ETCD (ฐานข้อมูลหลักของ Kubernetes) เป็นสิ่งสำคัญอย่างยิ่ง

สรุป

คุณได้เรียนรู้วิธีการติดตั้ง Kubernetes บน Ubuntu 24.04 ตั้งแต่การเตรียมระบบ, ติดตั้ง Container Runtime และส่วนประกอบหลักของ Kubernetes, การเริ่มต้น Control Plane, การเพิ่ม Worker Node, การ Deploy Pod, การตั้งค่า Ingress เพื่อเข้าถึงแอปพลิเคชัน และการมอนิเตอร์ด้วย Prometheus นี่เป็นรากฐานที่แข็งแกร่งสำหรับการเริ่มต้นเส้นทางของคุณในโลกของ Kubernetes ขอให้สนุกกับการสำรวจและสร้างสรรค์สิ่งใหม่ๆ บนคลัสเตอร์ของคุณ!

Leave a Comment