DEV Community: Tossapol Ritcharoenwattu

Git : ความสำคัญของ tag

Tossapol Ritcharoenwattu — Tue, 15 Jul 2025 10:10:48 +0000

Tag ใน Git คืออะไร?
Tag ใน Git คือ ป้ายชื่อ (label) ที่เราติดไว้กับ commit เพื่อบอกว่า commit นี้สำคัญ เช่น release เวอร์ชัน

ทำไมต้องใช้ tag?

บอกเวอร์ชันที่ deploy ไปแล้ว เช่น v1.0.0
ช่วยให้ทีมรู้ว่าต้อง checkout commit ไหน
ใช้ใน CI/CD → เช่น pipeline ที่จะ deploy เฉพาะ tag
เวลากลับไปแก้ bug → รู้ว่าต้องแก้บนเวอร์ชันไหน

Git มี 2 ประเภทหลักๆ

Lightweight Tag คล้าย bookmark → แค่บอกว่า tag ชี้ไปที่ commit ไหน ไม่มีข้อมูล extra เช่น ชื่อคนสร้างหรือข้อความ

git tag v1.0.0

Annotated Tag เป็น tag แบบจริงจัง ที่เก็บ:
ชื่อคนสร้าง
อีเมล
วันเวลา
message อธิบาย release
ใช้ทำ release บ่อยที่สุด

git tag -a v1.0.0 -m "Release version 1.0.0"

หรือระบุ commit ที่จะ tag:

git tag -a v1.0.0 a1b2c3d4 -m "Release version 1.0.0"

แสดง tag ที่มีทั้งหมด

git tag

ดูรายละเอียด tag

git show v1.0.0

Push tag ขึ้น Remote
สำคัญมาก! → tag ไม่ถูก push ขึ้น remote อัตโนมัติ ถ้าไม่สั่งเอง

Push tag เดี่ยว

git push origin v1.0.0

Push tag ทั้งหมด

git push origin --tags

ลบ tag
ลบใน local

git tag -d v1.0.0

ลบบน remote

git push origin --delete v1.0.0

Git : เริ่มต้นใช้ Git ตั้งค่า และสร้าง repository

Tossapol Ritcharoenwattu — Tue, 15 Jul 2025 03:38:17 +0000

ตั้งค่าเริ่มต้น

เริ่มต้นใช้งาน git ที่ต้องทำในครั้งแรกเลย คือ การบอก git ว่าเราคือใคร ขั้นตอนนี้ทำครั้งเดียว
setup name and email

git config --global user.name "Tossapol"
git config --global user.email = "youremail@domain.com"

หลังจากตั้งค่าเสร็จ ลอง เช็คดูว่า git รู้จักเราหรือยัง

git config --global user.name
git config --global user.email

เราสามารถเช็คดูค่า config ของ git ที่ตั้งค่าไว้ได้

git config --list

กรณีสร้าง Project ใหม่ Create project on GitLab

1. Create gitlab project
ให้เราสร้าง blank project ใน gitlab โดยไม่ต้อง add readme

Clone project จาก Gitlab ลงมายังเครื่องเราเอง

https://gitlab.com/tossapol.rit/demogitlab1.git

หลังจาก clone เสร็จแล้ว ให้เรา cd เข้าไปยัง foler project และ run command เพื่อบอกว่า เราต้องการทำงานอยู่ที่ branch ไหน

cd demogitlab1
git switch --create main

ทดลองสร้างไฟล์ readme และ push ขึ้นไปยัง gitlab

touch README.md
git add README.md
git commit -m "add README"
git push --set-upstream origin main

ลอง reload project บน gitlab ดูจะพบว่ามี file README.md

ข้อควรระวังมากๆ ของการ สั่ง git push

อาจจะเคยเห็นมีการส่ง argument -uf ไปด้วย สิ่งนี้ เอามาอธิบายเพิ่มเติมคือ
u = set-upstream เอาไว้สำหรับ run ครั้งแรกครั้งเดียว
f = force ส่วนนี้ปกติไม่ควรใช้เป็นอย่างยิ่ง เพราะจะทำให้ ประวัติการแก้ไขหาย

Docker Lesson 2 : มาลองสร้าง image กัน

Tossapol Ritcharoenwattu — Mon, 14 Jul 2025 09:38:18 +0000

เราจะมาลองสร้าง image ของ web บน ubuntu ด้วย python flask กัน
สิ่งที่เราจะทำ

OS Ubuntu
Update apt repo
Install dependencies using apt
Install python dependencies using pip
Copy source code to /opt/ folder
Run the web server using flask command

สร้าง app.py ก่อน

import os
from flask import Flask
app = Flask(__name__)

@app.route("/")
def main():
    return "Welcome!"

@app.route('/how are you')
def hello():
    return 'I am good, how about you?'

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

ทดลองสร้าง image แบบ manual กันดูก่อน

run docker จาก image ubuntu และเปิด bash ใน container

docker run -it -p 5001:5000 ubuntu bash

ติดตั้ง python และ virtual envieroment

apt-get update
apt-get install -y python3 python3-pip python3-venv

สร้าง virtualenv

python3 -m venv /opt/venv

Activate virtualenv สำคัญมาก → ทุกครั้งที่จะใช้ venv → ต้อง activate ก่อน:

source /opt/venv/bin/activate

อัปเกรด pip ใน venv

pip install --upgrade pip

ติดตั้ง Flask ใน venv

pip install flask

ตรวจสอบว่า Flask ติดตั้งแล้วหรือยัง

flask --version

Copy app.py เข้าไป เปิด terminal ใหม่

docker cp app.py <container_id>:/opt/source-code/app.py

cd เข้า directory ที่มี app.py

cd /opt/source-code

export FLASK_APP อย่าใช้ path ตรง ๆ เพราะ import จะ error → ใช้ชื่อ module เช่น ถ้าไฟล์คือ app.py → ต้อง export FLASK_APP=app

export FLASK_APP=app

รัน flask

flask run --host=0.0.0.0 --port=5000

12 : ลองเข้า web url : http://localhost:5001

เข้าได้ปกติ ทีนี้เราจะมาสร้าง dockerfile ตาม step ที่ทำมากัน

สร้าง Dockerfile

FROM ubuntu:latest

# ติดตั้ง python + pip + venv
RUN apt-get update && \
    apt-get install -y python3 python3-pip python3-venv

# สร้าง virtualenv
RUN python3 -m venv /opt/venv

# ติดตั้ง flask ใน venv
RUN /opt/venv/bin/pip install --upgrade pip && \
    /opt/venv/bin/pip install flask

# Copy app.py เข้า container
COPY app.py /opt/source-code/app.py

# set PATH → ใช้ venv
ENV PATH="/opt/venv/bin:$PATH"
ENV FLASK_APP=/opt/source-code/app.py
EXPOSE 5000
CMD ["flask", "run", "--host=0.0.0.0", "--port=5000"]

เสร็จแล้ว build image ด้วย command

docker build Dockerfile -t tossapol/my-custom-app

จะพบว่ามี image ที่เราสร้างขึ้น

ลองสร้าง container จาก image my-custom-app

เราจะสามารถใช้งาน app ที่เราทำไว้ได้ทันที

Docker Lesson 1 : Basic Docker command

Tossapol Ritcharoenwattu — Mon, 14 Jul 2025 03:00:10 +0000

1. docker run

docker run -d -p 8080:80 --name my-nginx nginx

ดึง image ชื่อ nginx (ถ้าไม่มีใน local)
สร้าง container
-d → detached mode → ให้ container รันอยู่เบื้องหลัง
-p → publish port 8080:80 → เอา port 80 ใน container (nginx) → map ออกมาให้เข้าจาก port 8080 บนเครื่อง host เข้าเว็บได้ที่ http://localhost:8080
--name my-nginx → ตั้งชื่อ container เป็น my-nginx

เราสามารถ mount volume ให้ container ใช้ไฟล์บน host ได้ด้วยการส่ง argument -v เข้าไป

docker run -d -p 8080:80 \
    -v /Users/tossapol/Documents/k8s_beginner/nginx_html:/usr/share/nginx/html \
    nginx

-v → mount volume
/Users/tossapol/Documents/k8s_beginner/nginx_html → path บนเครื่องเรา (host)
/usr/share/nginx/html → path ใน container
ใช้แก้ไฟล์ HTML บน host แล้ว container จะเห็นการเปลี่ยนแปลงทันที

2. docker ps
ใช้สำหรับ แสดงรายการ container ที่กำลังรันอยู่ ในระบบ จะแสดงข้อมูลเช่น:
Container ID
ชื่อ container
image ที่ใช้งาน
status
ports
command ที่ container กำลังรัน
ถ้าไม่ใส่ option อะไรเลย → จะแสดงเฉพาะ container ที่ กำลังทำงานอยู่ (running)

docker ps

docker ps -a

จะแสดง container สถานะอื่นๆ นอกจาก running ด้วย

docker ps -n 5

กรณีที่เรามี container หลายตัว เราสามารถกำหนดจำนวนแถวที่จะแสดงผลได้

docker ps -f "status=exited"

เราสามารถใส่ filter เพื่อกรองเฉพาะ container ที่ต้องการได้

กรณีที่ต้องการกำหนดเงื่อนไขมากกว่า 1 เงื่อนไข สามารถใส่ argument -f
เพิ่มได้เช่น

docker ps -a  -f "status=exited"  -f "ancestor=nginx"

3. docker start & stop
ใช้ start และ stop container ที่ถูกสร้างไว้แล้ว

docker start 
docker stop

4. docker rm
ใช้ลบ container ที่ไม่ต้องการ แต่การจะลบได้ container นั้นต้องอยู่ในสถานะ stop เท่านั้น

docker rm 7b8e8e8633bf

5. docker images
ใช้สำหรับดูว่าใน host มี image อะไรอยุ่บ้าง

docker images

docmer rmi ใช้สำหรับลบ image ที่ต้องการ โดย image ที่จะสามารถลบได้ จะต้องไม่มี container ใดที่เกี่ยวข้อง run อยู่

docker rmi nginx

docker pull ใช้สำหรับ download image จาก docker hub

docker pull nginx

docker inspect เอาไว้ดูรายละเอียดของ container

docker inspect d923e4fda97f

docker log เอาไว้ดู log ของ container

docker logs d923e4fda97f

Kubernetes Workshop1 : Step10 : Service Loadbalancer

Tossapol Ritcharoenwattu — Sun, 13 Jul 2025 07:10:49 +0000

เราจะมาลองทำ service loadbalancer ด้วย minikube กัน
เราจะสร้าง pod nginx ขึ้นมาก่อน

ถ้าเรายังไม่ได้สร้าง loadbalancer เราจะไม่สามารถ curl ไปยัง nginx จากภายนอก container ได้

ip : 192.168.49.2 เป็น ip ของ minikube node ยังไม่มีการสร้าง service จึงไม่สามารถ curl ได้
ip : 10.244.0.108 เป็น ip ของ pod ที่อยู่ภายใน node ไม่สามาถเรียก curl จากภายนอกได้
ถ้าอยากเรียก curl http://10.244.0.108 ต้อง ssh เข้าไปใน node ก่อน

สร้าง service loadbalancer เพื่อให้สามารถเข้าถึง nginx จากภายนอกได้
1. สร้างไฟล์ service-definition.yaml

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30008
  selector:
    app: nginx
    tier: frontend

ในส่วนของ selector ต้องกำหนดให้ตรงกับ label ของ pod ที่สร้างไว้ และสั่ง apply

kubectl apply -f service-definition.yaml

จะพบว่ามี service ประเภท loadbalancer ถูกสร้างขึ้นมา

2. เปิด minikube tunnel จำลอง load balance ในเครื่อง
ให้เปิด terminal ใหม่ขึ้นมา run คำสั่ง และห้ามปิด

minikube tunnel

_3. ทดสอบการทำงาน _
สำหรับการใช้ minikube tunnel นี้ เป็นการจำลอง loadbalance จึงไม่สามารถเรียก curl ไปยัง port 30008 ที่กำหนดได้ จะต้อง run command เพื่อดู port ที่สามารถเรียกจาก tunnel ได้ก่อน

minikube service myapp-service

จะเปิดหน้า web ขึ้นมาตาม url http://127.0.0.1:64208

Kubernetes Workshop1 : Step9 : Service

Tossapol Ritcharoenwattu — Sun, 13 Jul 2025 06:36:53 +0000

Service คือ Virtual IP ช่วยให้เข้าถึง Pod ได้โดยไม่ต้องรู้ Pod IP ตรง ๆ มีหลายประเภท:

ClusterIP → ภายใน Cluster
NodePort → เปิด Port ภายนอก
LoadBalancer → สร้าง Load Balancer ภายนอก

ClusterIP

ใช้งานภายใน Cluster เท่านั้น
ใช้ IP ภายใน (เช่น 10.96.5.42)
Pod อื่นใน Cluster เรียกผ่าน ClusterIP ได้
เหมาะสำหรับใช้งานภายใน เช่น Backend, Database

+-----------------------------+
|       Kubernetes Cluster    |
|                             |
|  +-----------------------+  |
|  |     Service (ClusterIP)| |
|  |  10.96.5.42:80         | |
|  +----------+------------+  |
|             |               |
|     +-------+--------+      |
|     |       |        |      |
| +---v--+ +--v---+ +--v---+  |
| | Pod1 | | Pod2 | | Pod3 |  |
| |:8080 | |:8080 | |:8080 |  |
| +------+ +------+ +------+  |
|                             |
+-----------------------------+
Client Pod --> ClusterIP --> Pod1/2/3

NodePort
เปิด Port บน Node ทุกตัว
kube-proxy จะ redirect traffic ไปที่ Pod
เหมาะกับ Cluster on-prem หรือทดสอบระบบ

+---------------------------------------------+
|              Outside World                  |
|                                             |
|         http://NodeIP:30080                 |
|                    |                        |
+--------------------|------------------------+
                     |
          +----------v-----------+
          |   Node (Worker)      |
          |                      |
          |  kube-proxy          |
          +----------+-----------+
                     |
      +--------------+----------------+
      |                               |
+-----v------+                  +-----v------+
| Service    |                  | Service    |
| NodePort   |                  | NodePort   |
| 30080:80   |                  | 30080:80   |
+-----+------+                  +-----+------+
      |                               |
  +---v---+   +---v---+          +----v----+
  | Pod1  |   | Pod2  |          | Pod3    |
  | :8080 |   | :8080 |          | :8080   |
  +-------+   +-------+          +---------+

LoadBalancer

สร้าง Load Balancer ภายนอก (Cloud Provider)
Cloud Provider สร้าง Load Balancer ให้ เช่น AWS ELB
User เรียกผ่าน External DNS หรือ IP
Load Balancer ส่ง traffic ไป NodePort ของ Node
Load Balancer → NodePort → Service → Pod
เหมาะสำหรับ Production

+-------------------------------------+
|         External LoadBalancer       |
|       (Cloud Provider ELB/ALB)      |
|         aabbcc.elb.amazonaws.com     |
+----------------+--------------------+
                 |
        +--------v--------+
        |   NodePort      |
        | (ทุก Node)      |
        | :30080          |
        +--------+--------+
                 |
         +-------+--------+
         |                |
     +---v---+        +---v---+
     | Pod1  |        | Pod2  |
     | :8080 |        | :8080 |
     +-------+        +-------+

สรุปภาพรวม

Kubernetes Workshop1 : Step8 : Update and Rollback Deployment

Tossapol Ritcharoenwattu — Sat, 12 Jul 2025 16:11:58 +0000

ในเรื่องของการ Update and Rollback เรามารู้จักหัวข้อหลักๆ ที่ต้องใช้ในเรื่องนี้กันก่อนประกอบด้วย

1. Rollout

การปรับเปลี่ยนเวอร์ชันแอปใน Kubernetes แบบไม่ทำให้ระบบล่ม
คือกระบวนการที่ Deployment อัปเดตแอป จากเวอร์ชันเดิม → ไปยังเวอร์ชันใหม่ ทำแบบ ค่อย ๆ แทนที่ Pod เก่า ด้วย Pod ใหม่ (Rolling Update) ช่วยให้ แอปยังใช้งานได้ตลอด → ไม่มี downtime
Rollout สำคัญอย่างไร

อัปเดตแอปโดย ไม่หยุดให้บริการ
ลดความเสี่ยง → ถ้าเวอร์ชันใหม่พัง → Rollback กลับได้ทันที
ช่วยให้ Deploy เวอร์ชันใหม่ได้ปลอดภัยกว่า Rollout ทำงานยังไง ตัวอย่างเช่น: คุณมี Deployment ที่รัน nginx:1.18 ต้องการเปลี่ยนเป็น nginx:1.19

เราจะลองทำ lab กันดู โดยการ สร้าง deployment nginx:1.18 ก่อน
'''
kubectl create deployment my-nginx --image=nginx:1.18 --replicas=3
'''

จะเห็นว่าตอนนี้เรามี deployment my-nginx:1.18

เราจะทำการ rollout nginx version ใหม่เป็น 1.19

kubectl set image deployment/my-nginx nginx=nginx:1.19

เช็คสถานะการ rollout

kubectl rollout status deployment

เช็ค history การ rollout

kubectl rollout history deployment/my-nginx

สรุปขั้นตอนการทำงานของ rollout
Kubernetes จะสร้าง ReplicaSet ใหม่ สำหรับเวอร์ชันใหม่และค่อย ๆ ปิด Pod เก่า แล้วสร้าง Pod ใหม่แทนจนครบจำนวน replicas ที่กำหนด

ก่อน Rollout:
[Pod v1] [Pod v1] [Pod v1]
ระหว่าง Rollout:
[Pod v1] [Pod v1] [Pod v2]
[Pod v1] [Pod v2] [Pod v2]
[Pod v2] [Pod v2] [Pod v2]
หลัง Rollout เสร็จ:
[Pod v2] [Pod v2] [Pod v2]

ถ้าแก้ไข image ใน deployment.yaml แล้วสั่ง apply kubernetes จะทำการ rollout ให้เช่นกัน

2. Versioning

คือการจัดการเวอร์ชันของแอปหรือ Deployment เพื่อให้รู้ว่าเรากำลังรันแอปเวอร์ชันไหน และสามารถย้อนกลับได้ถ้าพัง
Versioning ใช้ทำอะไร?

รู้ว่า ตอนนี้รันแอปเวอร์ชันไหน (image, config)
ช่วยให้ Kubernetes ทำ Rollback ได้ง่าย
ช่วยเก็บ ประวัติการเปลี่ยนแปลง (Revision History) ของ Deployment
ลดความเสี่ยงเวลาปล่อยแอปเวอร์ชันใหม่

เวลาสร้างหรือแก้ไข Deployment → Kubernetes จะสร้าง ReplicaSet ใหม่ ทุกครั้งที่มีการเปลี่ยนแปลง โดยแต่ละ ReplicaSet = แต่ละเวอร์ชันของ Deployment
ตัวอย่างหลังจาก rollout แล้ว ถ้าเรา เช็คดูว่าใน cluster มี replicaset อะไรอยู่บ้าง

kubectl get replicaset -o wide

จะเห็นว่า มี replicaset อยู่ 2 โดย replicaset nginx:1.19 มี pod ที่พร้อมทำงานอยู่ 3 แต่ใน nginx:1.18 ไม่มี pod ที่พร้อมทำงาน เนื่องจาก kubernetes จะเก็บ version เดิมไว้เผื่อระบบเกิดปัญหา ต้องทำการ rollback

3. Rollback

คือการย้อนกลับไปใช้ version ก่อนหน้า ถ้าเวอร์ชันใหม่พัง → Rollback กลับเวอร์ชันเดิมได้ทันที
เราสามารถสั่งด้วย command

kubectl rollout undo deployment/my-nginx

Kubernetes จะสลับกลับไปใช้ ReplicaSet ของเวอร์ชันเก่า
ลองเช็ค replicaset ดู จะเห็นว่า pod ready จะกลับมาอยู่ที่ nginx:1.18 แล้ว

4. Deployment Strategy

คือรูปแบบการ rollout version ใหม่ มี 2 แบบคือ Rolling-Update เป็นค่า default ที่ kubernetes ใช้ ตามที่อธิบายแล้วด้านบน และ Recreate เป็นการ ลบ pod เก่าออกจากระบบทั้งหมดก่อน แล้วจึงสร้าง pod ใหม่มาแทนที่ ซึ่งวิธีนี้อาจมี downtime
เหตุผลที่ควรใช้ Recreate
1. แอปทำงานพร้อมกันหลายเวอร์ชันไม่ได้

Database Migration
Stateful App ที่ต้องการ Lock Resource
Service ที่ใช้ Port เดียวกัน ตัวอย่าง: ถ้าคุณมี Database Migration → ต้องหยุด Service ก่อน deploy schema ใหม่ → ใช้ Recreate เหมาะสุด 2. ป้องกัน Conflicts
แอปบางตัวอาจชนกันถ้ารันหลายเวอร์ชันพร้อมกัน 3. ต้องการ Clean Slate อยาก ล้างของเก่าให้หมดก่อน deploy ใหม่ ไม่ควรใช้ Recreate ตอนไหน?
แอปที่ต้อง ให้บริการตลอดเวลา (Zero Downtime)
แอปที่ต้องการ High Availability

การกำหนดให้ kubernetes ใช้ Deployment Strategy แบบ Recreate สามารถทำได้ด้วย yaml เท่านั้น โดยการกำหนด Strategy type

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
  labels:
    app: myapp
    type: front-end
spec:
  strategy:
    type: Recreate
  replicas: 3
  selector:
    matchLabels:
      type: front-end
  template:
    metadata:
      name: myapp-pod
      labels:
        app: myapp
        type: front-end
    spec:
      containers:
        - name: nginx-container
          image: nginx:1.1

Kubernetes Workshop1 : Step7 : การจัดการ Deployment

Tossapol Ritcharoenwattu — Sat, 12 Jul 2025 15:06:33 +0000

สร้าง Deployment ด้วย command

เราสามารถสร้าง deployment ด้วย command

kubectl create deployment httpd-frontend --image=httpd:2.4-alpine --replicas=3

kubernetes จะทำการสร้าง deployment, replicaset และ pod ที่เกี่ยวข้อง

สร้าง Deployment ด้วยไฟล์ yaml

เรามาลองสร้างไฟล์ deployment.yaml กัน โดยไฟล์ที่สร้างนี้เป็นแบบ basic มีหน้าตาเหมือกับ replicaset ในบทความก่อน โดย แตกต่างกันเพียงแค่ kind = Deployment เท่านั้น

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
  labels:
    app: myapp
    type: front-end
spec:
  replicas: 3
  selector:
    matchLabels:
      type: front-end
  template:
    metadata:
      name: myapp-pod
      labels:
        app: myapp
        type: front-end
    spec:
      containers:
        - name: nginx-container
          image: nginx

ก่อนจะสร้าง deployment เรามาเช็คดูก่อนว่าใน cluster มีอะไรบ้าง (ใน lab นี้ ได้ทำการลบทุกอย่างออกหมดแล้ว จึงพบว่าไม่มีอะไร)

สร้าง deployment จาก yaml

kubectl apply -f deployment.yaml

หลังจากสร้าง deployment เรามาเช็คดูว่าใน cluster มีอะไรถูกสร้างขึ้นมาบ้าง

kubetcl get all

จะเห็นได้ว่า deployment จะทำการสร้าง replicaset และ pods ให้เอง

ดูว่าใน cluster มี deployment อะไรบ้าง

kubectl get deployment

ดูรายละเอียดของ deployment ที่ต้องการ
kubectl describe deploymeny myapp-deployment

ลบ deployment
kubectl delete deployment myapp-deployment

ลองเช็คดูว่าใน cluster มีอะไรบ้างหลังจากลบ deployment

เมื่อสั่งลบ deployment แล้ว จะเห็นว่า kubernetes จะทำการลบ repicaset และ pod ที่เกี่ยวข้องกับ deployment ออกไปพร้อมกัน

Kubernetes Workshop1 : Step6 : Deployment

Tossapol Ritcharoenwattu — Sat, 12 Jul 2025 14:47:38 +0000

Deployment คืออะไร?
Deployment คือผู้จัดการเวอร์ชันของแอปใน Kubernetes
ใช้ควบคุมการสร้าง, อัปเดต, และจัดการจำนวน Pod ให้อยู่ในสภาพพร้อมใช้งาน
ดูเผินๆ อาจจะรู้สึกว่ามันคล้ายกับ replicaset จริงๆ แล้วมันควบคุม replicaset อีกที เพื่อเพิ่มความสามารถที่ replicaset ทำไม่ได้

Deployment ทำอะไร?

สร้าง ReplicaSet ให้อัตโนมัติ → เพื่อควบคุมจำนวน Pod
รองรับ Rolling Update → อัปเดตเวอร์ชันแอปแบบไม่ล่ม
ทำ Rollback กลับไปใช้เวอร์ชันเก่าได้ ถ้าเจอปัญหา
ช่วยให้ Scaling ขึ้น-ลง Pod ได้ง่าย
บริหาร หลาย ReplicaSet เบื้องหลังเพื่อจัดการเวอร์ชันต่าง ๆ

ความแตกต่างระหว่าง Deployment กับ ReplicaSet

Deployment
│
├── ReplicaSet v1
│ └── Pods (old version)
│
└── ReplicaSet v2
└── Pods (new version)

ตัวอย่าง YAML ของ Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: nginx
        image: nginx:1.18

Kubernetes Workshop1 : Step5 : การจัดการ replicaset

Tossapol Ritcharoenwattu — Sat, 12 Jul 2025 14:39:19 +0000

ตัวอย่างไฟล์ yaml ของ replicaset

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myapp-replicaset
  labels:
    app: myapp
    type: front-end
spec:
  replicas: 3
  selector:
    matchLabels:
      type: front-end
  template:
    metadata:
      name: myapp-pod
      labels:
        app: myapp
        type: front-end 
    spec:
      containers:
      - name: nginx-container
        image: nginx

จะมีโครงสร้างอยู่ 4 ส่วนหลักเหมือน pod คือ apiVersion, kind, metadata, spec แต่จะมีส่วนที่แตกต่างกันดังนี้

appVersion ตรงนี้ ค่าที่ใส่จะต้องมี apps/ นำหน้าเสมอ เช่น apps/v1
tag ที่อยู่ภายใต้ template เขียนเหมือนเวลาเราเขียน metadata ของ pod ที่ต้องการได้เลย
replicas ตรงนี้เป็นการกำหนดค่า default จำนวน pod ว่าต้องการให้มีเท่าไหร่
selector ตรงนี้ต้องมี เพราะ replicaset สามารถเลือกกลุ่มที่ต้องการจั้ดการได้ เช่นในตัวอย่าง matchLabels = "type: front-end" replicaset จะเลือกเฉพาะที่มีการกำหนด label เป็นค่านี้เท่านั้น

สร้าง Replicaset เราสามารถสร้าง replicaset ด้วย command

kubectl apply -f replicaset-definition.yaml

ลองเช็คดูว่ามี pod ถูกสร้างขึ้นมา 3 pods จริงหรือไม่

ทดลองลบ pod ออก 1 ตัว แล้วเช็คดูใหม่ว่า ยังมี 3 pods เท่ากับที่กำหนดไว้ใน replacaset หรือไม่

จะเห็นได้ว่าถึงจะลบ pod ออกไป แต่พอ เช็คดูใหม่ ก็ยังมี 3 pods เท่าเดิม
ทดลองเพิ่มจำนวน pods ขึ้นเป็น 5
โดยแก้ yaml file

สั่ง kubectl apply -f replicaset-definition.yaml

จะเห็นว่า เราสามารถเพิ่มจำนวน pod เป็น 5 pods ได้
ไม่แก้ yaml เราสามารถสั่งผ่าน command line โดยอ้างอิง ชื่อไฟล์ หรือ ชื่อ replicaset ได้เลย

kubectl scale --replicas=4 -f replicaset-definition.yaml

kubectl scale --replicas=3 replicaset  myapp-replicaset

เรียกดูว่าใน cluster มี replicaset ใด ทำงานอยู่บ้าง

kubectl get replicaset

ดูรายละเอียดของ replicaset

kubectl describe replicaset myapp-replicaset

ลบ replicaset

kubectl delete replicaset myapp-replicaset

จะเห็นว่า เมื่อลบ replicaset แล้ว pod ที่ถูกสร้างจาก replicaset นั้นจะถูกลบออกไปด้วย

Kubernetes Workshop1 : Step4 : replicaset คืออะไร

Tossapol Ritcharoenwattu — Sat, 12 Jul 2025 14:39:09 +0000

ReplicaSet คือผู้คุมจำนวน Pod ใน Kubernetes ทำหน้าที่ให้แน่ใจว่าในระบบมี Pod เท่าที่เราต้องการอยู่เสมอ

ReplicaSet ทำงานยังไง?
กำหนดจำนวน replicas ที่ต้องการ เช่น 3 Pods
ถ้า Pod ใดล้ม → ReplicaSet จะสร้างใหม่ให้ทันที
ถ้ามี Pod เกิน → ReplicaSet จะลบออก
ใช้กับ Deployment เป็นหลัก → Deployment จะสร้างและจัดการ ReplicaSet ให้เราโดยอัตโนมัติ

ทำไมต้องมี ReplicaSet?
ทำให้ระบบ ทนทาน (High Availability)
ช่วยให้ Scaling จำนวน Pod ขึ้นหรือลงง่าย
ทำให้ Kubernetes จัดการโหลดได้ดีขึ้น

ตัวอย่างไฟล์ replicaset yaml แบบง่ายๆ โดยจะเป็นการ สร้าง replicaset มาควบคุมจำนวน pod ให้มี 3 pods ตลอดเวลา

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-replicaset
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: nginx
        image: nginx

+--------------------------+
| ReplicaSet |
| (3 Pods) |
+--------------------------+
| +-----+ +-----+ +-----+
| | Pod | | Pod | | Pod |
| +-----+ +-----+ +-----+
+--------------------------+

Kubernetes Workshop1 : Step3 : จัดการ Pod ด้วย Kube control command

Tossapol Ritcharoenwattu — Fri, 11 Jul 2025 04:29:12 +0000

การจัดการ POD เราจะเริ่มต้นทำ lab ใน minikube กัน
1. การสร้าง Pod
สามารถทำได้ 2 วิธีคือการสั่งให้ kubernetes สร้าง pod ขึ้นมาเลย หรือจะสร้างจาก ไฟล์ yaml ก็ได้ เรามาดูการสร้าง pod ง่ายๆ โดยสั่งให้ kubernetes สร้างขึ้นมาโดยไม่ใช้ yaml
- สั่งสร้าง pod ตรงๆ โดยไม่ได้ใช้ yml file

kubectl run my-nginx --image=nginx

คำส้่งนี้จะดึง image nginx มาใช้จาก dockerhub มาสร้าง pod ชื่อ my-nginx
เราสามารถตรวจสอบได้ว่า มี pod ถูกสร้างขึ้นมาจริงๆหรือไม่ด้วยคำสั่ง

kubectl get pods

- สั่งสร้าง pod ตรงๆ โดยใช้ yml file
เราจะต้องสร้าง yml ขึ้นมาก่อน ด้วย vi หรือ vscode ก็ได้
ตัวอย่างไฟล์ pods.yaml เพื่อสร้าง pod ที่มี 1 container เพื่อทำ web server ด้วย nginx

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
    tier: frontend 
spec:
  containers:
  - name: nginx
    image: nginx

เมื่อได้ไฟล์นี้แล้ว เราสามารถสั่งให้ kubernetes ทำงานได้ 2 คำสั่งคือ

kubectl create -f pod.yaml
หรือ 
kubectl apply -f pod.yaml

ความแตกต่างคือ create คือการสร้างใหม่เท่านั้น ถ้ามีการสั่งซ้ำ จะ error แต่ apply จะเป็นการเช็คว่า ถ้าไม่มีให้สร้าง แต่ถ้ามีแล้วให้ update

2. การดูรายละเอียดของ pod

คำสั่งสำหรับดูว่ามี pod อะไรบ้าง

kubectl get pods

คำสั่งสำหรับดูรายละเอียดของ pod ที่ระบุ

kubectl describe pod nginx

คำสั่งสำหรับ list pod ทั้งหมด โดยแสดง ip ของ pod และ ดูว่า pod อยู่ที่ node ไหน

kubectl get pods -o wide

3. การลบ pod ที่ไม่ต้องการ
คำสั่งสำหรับลบ pod

kubectl delete pod nginx

4. การสร้างไฟล์ yaml โดยการ generate script
การสร้างไฟล์ yaml นั้น เราสามารถสั่งให้ kubernetes generate ค่าเริ่มต้นให้ได้ เพื่อจะได้ไม่ต้องเริ่มทุกอย่างจาก 0 ทำให้เราสามารถเอาไป แก้ไขเพิ่มเติมได้ง่ายขึ้น

คำสั่งสำหรับจำลองการสร้าง yaml ไฟล์ โดยแสดงผลทางหน้าจอ

kubectl run my-redis --image=redis --dry-run=client -o yaml

—dry-run=client หมายถึงไม่ต้องสร้างจริงๆ แค่จำลอง
-o yaml หมายถึงแสดงคำสั่งสร้างในรูปแบบ yaml

ถ้าต้องการ save file ไว้ด้วย เพียงแค่เพิ่ม > filename.yaml ต่อท้าย

kubectl run my-redis --image=redis --dry-run=client -o yaml > redis.yml