สารบัญ
Series: CyberSecurity Foundation — รากฐาน Security สำหรับยุค AI (ภาษาคน)
Part 0 — WHY: เมืองนี้ทำไมต้องมียาม
- EP.01 — Cybersecurity คือเรื่องของคุณ
- EP.02 — 4 เคสที่เปลี่ยนวงการ
- EP.03 — CIA Triad
- EP.04 — Defense in Depth + Diversity
- EP.05 — Assume Breach + Risk
Part 1 — HOW: ระบบนิเวศของเมือง 6. EP.06 — ระบบนิเวศของโจร 7. EP.07 — ระบบนิเวศของผู้ป้องกัน 8. EP.08 — Framework: ISO/NIST/COBIT/CIS 9. EP.09 — Compliance Theater
Part 2 — Identity: บัตรประชาชน + กุญแจห้อง 10. EP.10 — IAM Lifecycle 11. EP.11 — Authentication 3 Factors 12. EP.12 — Password 101 13. EP.13 — MFA + Biometric 14. EP.14 — Kerberos 15. EP.15 — Federation + SSO 16. EP.16 — Authorization 17. EP.17 — PAM + Zero Trust
Part 3 — Data: ของในเซฟ 18. EP.18 — Data Classification + Lifecycle 19. EP.19 — Cryptography 101 20. EP.20 — Symmetric Crypto AES 21. EP.21 — Asymmetric Crypto RSA + DH 22. EP.22 — Hashing 23. EP.23 — PKI + Certificates 24. EP.24 — TLS / HTTPS 25. EP.25 — Email Security 26. EP.26 — Privacy Engineering
Part 4 — Infrastructure: ถนน กำแพง ท่อน้ำ 27. EP.27 — Network + Firewall Generations 28. EP.28 — Segmentation + DMZ + Microsegmentation 29. EP.29 — IDS / IPS / WAF / RASP 30. EP.30 — VPN + Proxy + DNS Security 31. EP.31 — DDoS + DLP 32. EP.32 — Cloud + Shared Responsibility 33. EP.33 — Container + Kubernetes: ตู้คอนเทนเนอร์ใน warehouse ← คุณอยู่ตรงนี้
Part 4 EP.34-38 + Part 5-6 — กำลังเขียนต่อ
ครับ — EP.32 จบไปด้วยภาพ เช่าคอนโด vs ซื้อตึก — คุณเห็นแล้วว่าเมื่อบริษัทย้ายขึ้น cloud — shared responsibility model บอกว่าใครรับผิดชอบส่วนไหนของตึก. AWS / Azure / GCP ดูแลตึก + ลิฟต์ + กำแพงนอก. แต่ห้องของคุณ — กุญแจ / ของในห้อง / ใครเข้าได้ — คุณดูแลเอง
แต่ EP.33 ผมต้องบอกคุณก่อนเลยครับ — โลก cloud-native ปี 2026 มัน ไม่ได้หยุดแค่ “เช่าห้องใน cloud”. มันมีอีกชั้นที่ลึกกว่านั้น
ลองนึกภาพต่อ — สมัยก่อนเราย้ายของในออฟฟิศ — ใช้รถกระบะขนทีละชิ้น. กล่องปะกล่อง — ของแตก. ของหายระหว่างทาง. ขนยาก. ไปถึงก็จัดเรียงใหม่หมด
แต่อยู่ๆ มีคนคิด ตู้คอนเทนเนอร์มาตรฐาน — ตู้เหล็กขนาดเดียวกันทั่วโลก. ใส่ของอะไรลงไปก็ได้. ปิดตู้ครั้งเดียว. เคลื่อนย้ายด้วยเครนเดียว. ขึ้นเรือ / รถไฟ / รถบรรทุก — ใช้ตู้เดิม. ไปถึงท่าเรือไหนของโลก — ระบบรองรับเหมือนกัน
โลก IT เกิดเหตุการณ์เดียวกันครับ — container (ตู้คอนเทนเนอร์ของ software) เปลี่ยนวิธี deploy application ทั้งหมดในรอบ 10 ปี. และเมื่อ container เยอะขึ้นเป็นพันเป็นหมื่นตู้ — เราต้องมี Kubernetes — ผู้จัดการ warehouse ที่ดูแลว่าตู้ไหนตั้งตรงไหน / ตู้ไหนพังแล้วเปลี่ยน / ตู้ไหนคุยกับตู้ไหน
เริ่มที่คำถามแรกครับ — ตู้คอนเทนเนอร์ทำไมถึงต่างจาก VM — เพราะถ้าไม่เคลียร์ตรงนี้ก่อน เรื่อง Docker / Kubernetes / container risk ที่ตามมาทั้งหมดจะอ่านผิดทิศ
Container vs VM — ทำไมตู้คอนเทนเนอร์เบากว่าตึก
ก่อนเข้า container — ต้องเข้าใจของเก่าก่อนครับ. ของเก่าคือ Virtual Machine (VM) — เครื่องเสมือน ที่เราคุ้นเคยจากยุค VMware / Hyper-V
ลองนึกภาพในเมืองของเรา. ก่อนยุค container — บริษัทอยากรัน application — ต้องสร้าง ตึกเสมือนหลังหนึ่ง บนเครื่อง server ใหญ่. ตึกเสมือนหลังนี้คือ VM — ข้างในมี ระบบไฟ + ระบบประปา + ระบบแอร์ + พื้น + ผนัง + ห้อง ของตัวเอง ครบทุกอย่าง. ภาษา IT — VM แต่ละตัวมี OS kernel (แก่นระบบปฏิบัติการ) แยกของตัวเอง
ข้อดีของตึกเสมือน — แยกขาดกันสนิท. ตึกหนึ่งไฟไหม้ — ตึกอื่นไม่กระทบ. ข้อเสีย — หนัก. ตึกเสมือนหนึ่งหลัง = หลายกิกะไบต์. boot ทีใช้เวลานาที. ใน server เครื่องเดียว — รันได้แค่ 10-20 ตึกเสมือน ก็เต็มแล้ว
แล้ว container มาเปลี่ยนภาพยังไง?
Container = ตู้คอนเทนเนอร์ของ application — ไม่ใช่ตึกใหม่ — แต่เป็น ห้องในตึกเดียวกัน ที่แยกผนังให้ดีจน application ในห้องคิดว่าตัวเองอยู่ในตึกของตัวเอง. OS kernel แชร์กับห้องอื่น (กับตู้คอนเทนเนอร์ตัวอื่นบน server เดียวกัน) — แต่ process / network / filesystem ของห้องตัวเอง แยกเรียบร้อย
ลองเทียบเป็นตาราง:
| ประเด็น | VM (ตึกเสมือน) | Container (ตู้คอนเทนเนอร์) |
|---|---|---|
| OS kernel | แยกของตัวเอง | แชร์กับ host + container อื่น |
| ขนาด | หลาย GB | หลาย MB ถึงร้อย MB |
| boot time | นาที | วินาทีถึงเสี้ยววินาที |
| ความหนาแน่น (per server) | สิบๆ ตัว | ร้อยๆ ถึงพันๆ ตัว |
| portability | ปานกลาง (image VM ใหญ่) | สูงมาก (image เล็ก ขนไปไหนก็ run ได้) |
| isolation | แข็งแรงกว่า | อ่อนกว่า (เพราะแชร์ kernel) |
ประเด็นความปลอดภัยที่สำคัญที่สุด — เพราะ container แชร์ kernel กับ host — ถ้ามีช่องโหว่ใน kernel หรือใน container runtime — โจรอาจ escape ออกจากห้องตัวเอง ไปคุม ตึกทั้งหลัง (host) ได้. นี่คือ container escape ที่เราจะลงลึกตอนกลาง EP
อีกประเด็นที่ผู้บริหารต้องเข้าใจ — container ไม่ใช่ทดแทน VM แบบหายขาด. ในโลกจริงปี 2026 — บริษัทใหญ่ส่วนมาก ใช้ทั้งคู่ — VM เป็นชั้นนอก (แยก workload ที่ความเสี่ยงต่างกัน) + container อยู่ในนั้น (เพื่อความเร็ว + ความหนาแน่น). บริษัทไทยที่บอกว่า “ย้ายไป container 100% ทุกอย่าง” — ลองสำรวจให้ดีๆ ครับ — บ่อยครั้งเป็นภาพในใจของ team dev มากกว่าความจริงที่ ops จัดการได้
มุมผู้บริหาร: เวลา CTO บอก “เราใช้ container แล้วครับ” — ถามต่อทันที — “workload ไหนยังอยู่ VM และทำไม?” เพราะใน enterprise ที่ทำ security ดี — database + ระบบการเงินมักยังอยู่ VM เพราะ isolation แข็งแรงกว่า. คำตอบ “container ทุกอย่าง” คือ red flag — มันคือการย้ายของมีค่าจากเซฟไปไว้ในตู้ล็อกเกอร์ที่กุญแจร่วมกับเพื่อนบ้าน
Docker fundamentals — Image คือกล่องบรรจุของ, Container คือกล่องที่ถูกเปิดใช้
มาที่ของจริง — Docker ครับ. Docker คือเครื่องมือที่ทำให้ container popular ทั้งวงการตั้งแต่ปี 2013. ปัจจุบันคำว่า “container” ในที่ทำงานทั่วไป = Docker เป็นหลัก (มี runtime อื่นเช่น containerd / CRI-O / Podman แต่หลักคิดเหมือนกัน)
มี 3 คำที่ต้องแยกให้ออก — Image / Container / Registry
1. Image (อิมเมจ — แม่แบบของตู้คอนเทนเนอร์)
ลองนึกในโลกขนส่งครับ — image = แม่แบบของตู้คอนเทนเนอร์ที่บรรจุของเสร็จเรียบร้อยพร้อมส่ง. ในนั้นมี:
- OS layer พื้นฐาน เช่น Ubuntu / Alpine / Debian (เลือกเอง)
- runtime ของภาษา เช่น Node.js / Python / Java
- dependency ทั้งหมดของ application
- โค้ดของ application เอง
- คำสั่งเริ่มต้น ตอนเปิดตู้
Image read-only + versioned. ถ้าคุณสร้าง image v1.2.3 — มันจะเหมือนเดิมตลอดไป. ของ image ทำขึ้นจาก Dockerfile — ไฟล์ recipe ที่บอกว่า “เริ่มจาก base image อะไร → ติดตั้งอะไรเพิ่ม → ใส่โค้ดอะไร → รันคำสั่งอะไร”
2. Container (คอนเทนเนอร์ — ตู้ที่ถูกเปิดใช้)
Container = image ที่ถูก run ขึ้นมาเป็นกระบวนการจริงๆ บน server. ถ้า image คือ แม่แบบตู้ — container คือ ตู้ตัวจริงที่ถูกขนลงเรือกำลังวิ่ง. จาก image เดียว — สั่งให้รัน 100 container พร้อมกันก็ได้. ทุก container เริ่มจากสถานะเดียวกัน (เพราะ image เดียวกัน)
3. Registry (รีจิสทรี — คลังเก็บแม่แบบ)
Registry = ที่เก็บ image กลาง — แชร์ทั่ววงการ. ที่ใหญ่ที่สุดคือ Docker Hub (ของ Docker Inc.) — มี image สาธารณะหลายล้านตัว — ตั้งแต่ image อย่างเป็นทางการ (ubuntu, node, postgres) → image ของ developer ทั่วโลก. นอกจาก Docker Hub มี GitHub Container Registry, AWS ECR, Google Artifact Registry, Azure Container Registry — บริษัทใหญ่ใช้ private registry ของตัวเองเสมอ
มีอีกศัพท์ที่จะเจอ — image layer. ลองนึก Photoshop ครับ — แต่ละขั้นใน Dockerfile = layer ใหม่ที่ซ้อนทับ layer เก่า. ข้อดี — layer ที่เหมือนกันใช้ร่วมกันได้ (ประหยัด storage + transfer). ข้อเสีย — ถ้า layer ล่างมี secret หรือมีช่องโหว่ — ทุก image ที่ใช้ layer นั้นมีปัญหาตามไปด้วย
ตัวอย่างให้เห็นภาพ — บริษัทคุณเขียน application เป็น Node.js. Dockerfile เขียนว่า “เริ่มจาก node:18 (image ทางการของ Node.js v18) → copy โค้ด → run npm install → start”. จบ — คุณได้ image ของ application
แต่คำถาม — node:18 มาจากไหน? Docker Hub. ใครเป็นคนทำ? Node.js team อย่างเป็นทางการ. แต่ layer ที่อยู่ใต้ node:18 คือ Debian เวอร์ชันหนึ่ง. layer ใต้นั้น คือ glibc + OpenSSL + library อีกหลายสิบตัว. ถ้า OpenSSL ใน Debian layer มี vulnerability — application ของคุณติด vulnerability ตั้งแต่วินาทีแรกที่ build — ทั้งที่โค้ดของคุณไม่ได้แตะอะไรเลย
ในข่าวเคยมีรายงานจาก vendor หลายเจ้า (Snyk, Aqua, Sysdig) ว่า — public image บน Docker Hub มากกว่า 50% มี high/critical vulnerability. บาง image popular ที่ pull เป็นล้านครั้งต่อเดือน — มี CVE เก่าหลายปี
มุมผู้บริหาร: เอาตรงๆ ครับ — เวลาทีมบอก “เรา deploy ผ่าน Docker” — ถ้าคุณเชื่อแค่นั้นแล้วผ่าน — คุณอาจกำลัง import vulnerability จากคนแปลกหน้าทั่วโลก เข้าระบบคุณ. คำถามที่ต้องถามทีมคือ “เรา pull image จาก public Docker Hub โดยตรงไหม?” + “มี image scan ไหม ใช้เครื่องมืออะไร” + “Base image เรา pin version หรือใช้
:latest?” คำตอบที่ดี = “เรา mirror image ทั้งหมดมา private registry — สแกนด้วย Trivy ก่อน promote ไป production — pin version แบบ digest hash ไม่ใช่ tag”. คำตอบ “เราใช้latestจาก Docker Hub ตรงๆ” = ตู้คอนเทนเนอร์ที่ซื้อจากท่าเรือมือสองโดยไม่เปิดดูข้างใน
Container security risks — 4 แบบที่เจอบ่อยที่สุด
ความเข้าใจผิดที่อันตรายที่สุดของผู้บริหารหลายคนคือ — “container = secure by default”. เพราะมัน “ใหม่” + “tech” + “บริษัทใหญ่ใช้กัน”. เอาตรงๆ — ความปลอดภัยของ container ขึ้นกับว่าใครสร้าง + ใครจัดการ + ใครรัน. ตู้คอนเทนเนอร์ทั่วไปใน warehouse — ของในตู้อาจเป็นอะไรก็ได้
ผมจะแบ่งความเสี่ยงเป็น 4 แบบที่เจอในข่าวบ่อยที่สุด
1. Image vulnerabilities — ตู้ที่บรรจุของพร้อมโรค
เหตุเกิดจาก base image หรือ dependency ที่ติดมีช่องโหว่ — เหมือนตู้คอนเทนเนอร์ที่ซื้อมาแล้วข้างในมีของพร้อมจุดอ่อน
เคสที่คลาสสิคที่สุด — Log4Shell ในปี 2021. Log4j เป็น logging library ของ Java ที่อยู่ในแอปนับล้าน. เดือนธันวาคม 2021 — มีคนค้นพบช่องโหว่ระดับ CVSS 10.0 (สูงสุดของ scale) — โจรส่ง string พิเศษไปใน log → log4j ไป fetch โค้ดอันตรายมารัน → โจรครองเครื่องเสร็จ
ในโลก container ผลกระทบ ยิ่งร้ายแรง เพราะ:
- ทุก image ที่ใช้ Java + Log4j โดน — ไม่ว่าจะรู้หรือไม่
- image แบบ multi-stage ที่ฝัง Log4j ใน build stage — บางครั้งหลุดมา production
- บริษัทต้องไล่ scan + rebuild + redeploy ทุก image ทั่วทั้ง fleet — นับพันนับหมื่นตู้
- บาง image ที่ pull จาก Docker Hub โดยไม่ rebuild — ติดต่อมานานหลายเดือนหลัง patch ออก
ใน scenario ของบริษัทไทยที่ใช้ container — Log4Shell เป็น stress test แรกของวงการ. บริษัทที่ทำ image inventory ดี + ใช้ image scanner — patch จบใน 1-2 สัปดาห์. บริษัทที่ไม่มี inventory — บางที่ใช้เวลา 6 เดือนกว่าจะมั่นใจว่า patch หมดทุกที่. นี่คือเหตุผลที่ Software Bill of Materials (SBOM) กลายเป็น keyword สำคัญในปี 2022-2026 (EP.34 ลึกต่อ)
2. Privileged containers — ตู้ที่เปิดได้ทั้ง warehouse
ปกติ container ควรรันด้วย สิทธิ์จำกัด — เห็นแค่ของในตู้ตัวเอง. แต่บางครั้ง developer ใส่ flag --privileged หรือ runAsUser: 0 (root) เพื่อให้ container ทำสิ่งที่ “ทำง่ายกว่า” — แล้วลืมถอดออกตอน production
Privileged container = ตู้คอนเทนเนอร์ที่มี กุญแจ master ของทั้ง warehouse. ถ้าโจรเข้ามาในตู้นี้ได้ — โจรเปิดได้ทุกตู้ + เปิด warehouse ออกไปข้างนอกได้ด้วย
ในข่าว pattern คลาสสิคที่เห็นบ่อย — บริษัทเริ่มต้น POC (proof of concept) ที่ dev ตั้ง container เป็น privileged: true เพื่อให้ทดสอบเร็ว → POC ผ่าน → ย้ายไป production — ลืมแก้ flag → 6 เดือนต่อมาโจรเจอ — เข้าผ่าน application bug ธรรมดา — แต่ escape ขึ้นเป็น root ของ host ได้เพราะ privileged
3. Container escape — เปิดจากในตู้ไปครอง warehouse
Container escape = โจรอยู่ใน container ตัวหนึ่ง — แล้ว กระโดดออกจากตู้ ไปคุม host (ตึก / server) ทั้งหลัง. เป็น scenario ที่ rare แต่ devastating — เพราะถ้าโจรครอง host ได้ → คุมทุก container บนนั้น → ขยายต่อไปทั้ง cluster
วิธีที่เกิด escape ในข่าว:
- kernel vulnerability เช่น Dirty Pipe (CVE-2022-0847) — โจรในตู้แก้ไฟล์บน host kernel ได้
- container runtime vulnerability เช่น runC CVE-2019-5736 — โจรเขียนทับ binary ของ runC จากใน container
- mount ของ host เข้า container ผิดวิธี เช่น mount
/var/run/docker.sockเข้า container ทั่วไป → container นั้นสั่ง Docker daemon ของ host ได้ → ครอง host - privileged + capability ที่ใส่เกิน
container escape ไม่ค่อยเกิด — แต่ทุกครั้งที่เกิด → ข่าวใหญ่. เพราะมันบ่อนทำลายข้อสันนิษฐานหลักของ container ทั้งหมด
4. Secret leakage in Dockerfile — เปิด Dockerfile แล้วเจอรหัสผ่าน
อันนี้เกิดบ่อยที่สุดในชีวิตจริง — และน่าเศร้าที่สุด. developer ใส่ secret ตรงๆ ใน Dockerfile หรือ commit Dockerfile ที่มี secret ขึ้น GitHub public — แล้วทั่วโลกเห็นใน 5 นาที
ตัวอย่างปัญหาที่เห็นได้ทั่วไป:
FROM node:18COPY . /appENV DATABASE_PASSWORD=SuperSecret123ENV AWS_SECRET_ACCESS_KEY=AKIA...หรือแย่กว่านั้น — ใส่ secret ใน layer ที่ลบไปแล้วแต่ยังอยู่ใน image history:
COPY secret.json /tmp/secret.jsonRUN ./install-with-secret /tmp/secret.jsonRUN rm /tmp/secret.json # ลบแล้ว แต่ยังอยู่ใน layer ก่อนหน้า!ใน image — ทุก layer ถูกเก็บไว้แม้ลบไฟล์ใน layer ถัดไป. ใครก็ตามที่ pull image ของคุณ — docker history ได้ทุก layer — เห็น secret ที่คิดว่าลบแล้ว
มีข่าว popular ในวงการ — บริษัทใหญ่ลืม commit Dockerfile ขึ้น public repo — มี AWS key ข้างใน — โจร bot scan GitHub ตลอด 24 ชม. — ภายในชั่วโมงเดียวเริ่ม spin EC2 instances สำหรับ crypto mining — บิลของบริษัทเดือนนั้น 6 หลัก USD
มุมผู้บริหาร: 4 ข้อนี้ — ถ้าคุณจำได้ขั้นเดียวคือจำว่า ความเสี่ยงของ container ไม่ใช่ “container ปลอดภัยหรือไม่ปลอดภัย” — แต่คือ “ทีมเราเข้าใจ container ดีพอไหม”. มันเหมือนรถยนต์ — รถปลอดภัยหรือไม่ปลอดภัย ขึ้นกับคนขับ. คำถามที่ถามทีมได้ — “เรา scan image ก่อน deploy ไหม?” / “มี privileged container เหลือใน production ไหม — รายชื่อ?” / “Secret เก็บใน Dockerfile หรือใน secret manager?” / “ใครได้ดูว่า image ของบริษัทเรามี vulnerability ตัวไหน — มี dashboard ไหม?”. ถ้าได้คำตอบที่ชัดเจน 4 ข้อ — ทีมคุณ mature พอ. ถ้ายังงงๆ — ลงทุนใน image scanning + secret management ก่อนทำอย่างอื่น
Kubernetes basics — ผู้จัดการ warehouse ที่ดูแลตู้คอนเทนเนอร์ทุกตู้
ลองนึกภาพ warehouse ของเมืองเราอีกครั้ง — ถ้าบริษัทคุณมีตู้คอนเทนเนอร์ 5 ตู้ — ใช้ Docker บน server เดียวก็พอ. แต่ถ้ามี 500 ตู้ กระจายในหลาย server / หลาย region / มีตู้ที่ต้องคุยกัน + ตู้ที่ scale ตามจำนวนลูกค้า + ตู้ที่ต้องเปลี่ยนเป็นเวอร์ชันใหม่โดยไม่ดาวน์ — คุณต้องการ ผู้จัดการ warehouse
นั่นคือ Kubernetes (K8s) — ระบบจัดการ container ขนาดใหญ่ — open-source ที่ Google ปล่อยออกมาในปี 2014 — ปัจจุบันเป็น de-facto standard ของวงการ. คำเรียกย่อ “K8s” — K + 8 ตัวอักษร + s
ถ้า container = ตู้คอนเทนเนอร์ → Kubernetes = ระบบ warehouse + เครน + รถ AGV + ระบบติดตามทุกตู้ ที่ดูแลให้ทุกตู้อยู่ที่ถูกต้อง + ทำงานถูกต้อง + ตู้ไหนพังเปลี่ยนทันที
คำศัพท์ที่ผู้บริหารต้องรู้ — ผมจะแยกให้ฟังเป็นบทบาท
Pod — กลุ่มตู้ที่ทำงานเป็นทีม
Pod = กลุ่มตู้คอนเทนเนอร์ 1-N ตู้ ที่ K8s ปฏิบัติเป็น หน่วยเดียว — รันด้วยกัน + แชร์ network + แชร์ storage. Pod เป็น หน่วยเล็กที่สุด ที่ K8s จัดการ — ไม่ใช่ container เดี่ยวๆ
ส่วนใหญ่ Pod = container 1 ตัว. แต่บางกรณีต้องมี container เสริม (เรียก sidecar) เช่น container หลักรัน app + sidecar ทำหน้าที่ logging / proxy / mesh
Deployment — แม่แบบบอกว่าต้องการกี่ Pod
Deployment = คำสั่งกับ K8s ว่า “ผมต้องการ Pod แบบนี้ (ใช้ image นี้) จำนวน 5 ตัว — ตลอดเวลา”. ถ้า Pod พังไป 1 ตัว — K8s สร้างใหม่ทันที เพื่อให้ครบ 5. ถ้าเวอร์ชันใหม่ของ image ออกมา — Deployment สั่งให้ K8s ทยอย rolling update ทีละ Pod โดยไม่ดาวน์
นี่คือ super power ของ K8s — self-healing + declarative. คุณบอกว่า “ต้องการอะไร” (5 ตู้ที่บรรจุแบบนี้) — ไม่ใช่ “ทำขั้นตอนอะไร”. K8s จัดการให้เอง
Service — ที่อยู่ของกลุ่ม Pod
Pod แต่ละตัว IP ของมันเปลี่ยนได้ตลอด (Pod ตาย-เกิดใหม่ตลอดเวลา). ถ้าคุณบอกผู้ใช้ว่า “เข้า http://192.168.x.x” — มันใช้ไม่ได้
Service = ที่อยู่คงที่ ของกลุ่ม Pod. K8s ให้ IP + DNS name คงที่ — Service เป็น load balancer ภายใน ที่ส่งคำขอไปยัง Pod ที่พร้อมรับ
Ingress — ประตูจาก internet เข้ามายัง Service
Ingress = ประตูหน้า warehouse ที่ผู้ใช้จากภายนอก (internet) วิ่งเข้ามา. ทำหน้าที่ routing — “URL /api/orders ไป Service A, URL /api/users ไป Service B” — และมัก terminate TLS ที่นี่ด้วย
ConfigMap + Secret — กล่องเก็บค่า config + รหัสลับ
ConfigMap = กล่องเก็บค่า config ที่ Pod ดึงไปใช้ได้ (เช่น URL, feature flag, parameter). Secret = กล่องเก็บข้อมูลละเอียดอ่อน (password, API key, TLS cert) — ที่ K8s เก็บแยก + ควร encrypt at rest
จุดที่ต้องระวัง — K8s Secret ไม่ใช่ encrypted by default ใน etcd (database ของ K8s). ค่ามันเก็บเป็น base64 encoded ซึ่ง = ไม่ใช่ encryption. ต้องเปิด encryption at rest เอง หรือใช้ external secret manager (AWS Secrets Manager / HashiCorp Vault / Sealed Secrets)
RBAC + NetworkPolicy — กฎเข้าออก + กฎคุยกัน
RBAC (Role-Based Access Control) ของ K8s = กฎว่าใครทำอะไรใน cluster ได้. คล้ายกับ Authorization ใน EP.16 — แต่ scope ของ K8s. กำหนดว่า user A เข้า namespace ไหน / สั่งอะไรได้ / ดูอะไรได้
NetworkPolicy = กฎว่า Pod ไหนคุยกับ Pod ไหนได้. by default — Pod ทุกตัวใน cluster คุยกันได้หมด (flat network). NetworkPolicy ทำให้คุณจำกัด — “Pod ของ frontend คุยกับ Pod ของ backend ได้ แต่ห้ามคุยกับ database โดยตรง”
นี่คือ microsegmentation ใน K8s (เชื่อมกับ EP.28). บริษัทที่ไม่ตั้ง NetworkPolicy = warehouse ที่ตู้ทุกตู้คุยกันได้หมด — เป็น playground สำหรับ lateral movement ของโจร
มุมผู้บริหาร: K8s ไม่ได้ secure by default ครับ. มันคือ engine ทรงพลัง ที่ถ้าตั้งดีคือเกราะป้องกัน — ถ้าตั้งไม่ดีคือประตูเปิดให้โจรเดินเข้า. default ของ K8s = ปลอดภัยน้อย เพื่อให้ใช้งานง่าย. คำถามที่ถามทีมได้ — “ทุก namespace มี NetworkPolicy ไหม?” / “Secret ใน etcd encrypt at rest ไหม?” / “ใครมี cluster-admin — รายชื่อ?” / “RBAC ตามหลัก least privilege ไหม หรือทุกคน admin?”. ถ้าตอบว่า “ทุกคน admin เพราะมันใช้ง่าย” — สีแดงครับ. K8s ที่ตั้งค่าผิดเป็นช่องโหว่ใหญ่ที่สุดที่บริษัทไทยเริ่มเจอ — เพราะ team dev โหลด K8s มาใช้เร็วกว่า team security เรียนทันท่วงที
K8s security in practice — 5 ชั้นป้องกันที่ใช้จริงในวงการ
มาที่ของจริง — ในวงการ K8s security ปี 2026 มี 5 ชั้นป้องกัน ที่บริษัท mature ใช้กัน. ผมเรียงตามลำดับว่าเริ่มจากชั้นไหนก่อน
ชั้น 1 — Image Scanning (ตรวจตู้ก่อนเข้า warehouse)
ก่อน image จะถูก deploy เป็น Pod — ต้อง scan หาช่องโหว่ ก่อน. เครื่องมือยอดนิยม:
- Trivy (Aqua Security, open-source) — เร็ว + ใช้ง่าย + popular ที่สุดในวงการปัจจุบัน
- Snyk (commercial) — ครอบคลุม + UI ดี + integrate IDE
- Anchore — focus ที่ enterprise + policy engine แข็ง
Scanner ดู image ทุก layer — เทียบกับ CVE database — รายงานว่ามี vulnerability ตัวไหน level อะไร + แนะนำ version ที่ patch แล้ว. บริษัทที่ทำดี — scan ทุก image ใน CI pipeline + block image ที่มี critical CVE ออกจาก production
ชั้น 2 — Runtime Protection (ยามที่เดินตรวจ warehouse ตลอดเวลา)
ตู้ที่ผ่านการตรวจตอน scan — ไม่ได้แปลว่ายังปลอดภัยอยู่ตลอด. Runtime protection = ยามที่ดู พฤติกรรมของ container ขณะรัน — จับ anomaly
- Falco (CNCF, open-source) — มาตรฐานของวงการ. ตรวจ system call ของ container — เห็น process ที่แปลกประหลาด เช่น container web server จู่ๆ รัน
ncหรือbashinteractive - Sysdig Secure (commercial) — Falco + dashboard + policy + cloud integration
- Aqua Runtime + Wiz Runtime — alternatives ในวงการ enterprise
ภาพในใจ — image scan คือ ตรวจตู้ตอนเข้าประตู warehouse / runtime protection คือ กล้องวงจรปิด + ยามเดินตรวจ ขณะตู้อยู่ในนั้น. ทั้งคู่ต้องมี — ขาดอันใดอันหนึ่งคือเสียมือไปข้างหนึ่ง
ชั้น 3 — Pod Security Standards (กฎความปลอดภัยของตู้)
สมัยก่อน K8s มี Pod Security Policy (PSP) — แต่ deprecated ตั้งแต่ K8s 1.21 และถูกถอดใน 1.25. แทนที่ด้วย Pod Security Standards (PSS) — มาตรฐาน 3 ระดับ:
- Privileged — อะไรก็ได้ (สำหรับ system workload เท่านั้น)
- Baseline — กันสิ่งที่อันตรายเห็นชัด (เช่น privileged container, hostPath mount)
- Restricted — เข้มที่สุด (drop ทุก capability, รันด้วย non-root, read-only root filesystem)
บริษัทที่ทำดี — บังคับ Restricted ใน namespace ที่รัน workload ของลูกค้า. enforcement ทำผ่าน Pod Security Admission ของ K8s — block Pod ที่ไม่ตามมาตรฐาน
ชั้น 4 — Service Mesh + mTLS (ทุกการคุยกันมีลายเซ็น)
ในเมืองของเรา — warehouse ใหญ่ที่ตู้ A คุยกับตู้ B ต้องผ่าน โทรศัพท์ภายในของ warehouse. ใครก็โทรหากันได้ — แต่ไม่รู้ว่าใครพูด
Service Mesh = ชั้นเสริมที่บังคับให้ทุกการสื่อสารระหว่าง Pod มี identity + เข้ารหัส + record. Istio + Linkerd เป็น 2 ตัวที่ popular ที่สุด
จุดเด่น — mTLS (mutual TLS) ใน mesh — ไม่ใช่แค่ Pod A เห็น Pod B (ฝั่งเดียวเหมือน HTTPS เว็บ) แต่ ทั้งคู่ยืนยันตัวกันด้วย certificate. ของในตู้ + ใครส่ง + ใครรับ — เซ็นชื่อทั้งสองฝั่ง
ผลพลอยได้ — observability ดีขึ้น + กำหนด policy ละเอียดได้ (allow X→Y, deny X→Z) + traffic shifting สำหรับ canary deployment. แลกกับ complexity ของ mesh ที่ต้องเรียนรู้ + overhead ทาง resource
ชั้น 5 — Admission Controllers (ยามที่อ่าน manifest ก่อนรับเข้า)
ทุกครั้งที่มีคนสั่ง deploy อะไรขึ้น K8s — manifest (ไฟล์ YAML บอกว่าจะสร้างอะไร) วิ่งผ่าน Admission Controller ก่อนถึง cluster. คุณตั้ง policy ได้ — “ห้าม Pod ที่ใช้ image จาก registry ที่ไม่ใช่ของเรา” / “ห้าม privileged: true” / “ทุก Pod ต้องมี resource limit” / “ทุก Service ต้องมี NetworkPolicy คู่กัน”
เครื่องมือ:
- OPA Gatekeeper (Open Policy Agent) — ใช้ภาษา Rego เขียน policy
- Kyverno — ใช้ YAML เขียน policy (เรียนรู้ง่ายกว่า OPA สำหรับ team ที่ไม่ใช่ programmer)
Admission Controller คือ policy as code ที่บังคับใช้กับทุก deployment — ไม่ต้องพึ่ง human review
มุมผู้บริหาร: ครับ — 5 ชั้นนี้ — ไม่ต้องทำพร้อมกันหมด. ลำดับที่แนะนำในข่าวและคำแนะนำของวงการ = ชั้น 1 (Image scan) → ชั้น 3 (Pod Security Standards) → ชั้น 5 (Admission Controller) → ชั้น 2 (Runtime) → ชั้น 4 (Mesh). เพราะ Image scan + PSS + Admission Controller เริ่มลงทุนต่ำ + ผลกระทบสูง. Runtime + Mesh ต้องมี security ops พร้อม + ต้องมี culture ที่จัดการ alert ได้. คำถามที่ผู้บริหารถามทีม K8s ได้ — “เราอยู่ชั้นไหน?” + “ต่อไปจะเพิ่มชั้นไหน เหตุผลอะไร?” — คำตอบที่ดี = ทีมรู้ตัวว่าอยู่ตรงไหนของ maturity curve + มีแผนชัด. คำตอบ “เราใช้ K8s — ก็ปลอดภัยอยู่แล้ว” = ตอบไม่ตรงคำถาม
เคสจริง 3 เคสที่ทุกผู้บริหารต้องรู้
ทฤษฎีพอแล้วครับ — มาดู ตัวอย่างของจริง ที่เกิดขึ้นในวงการ — ทั้ง 3 เคสมี บทเรียน ตรงกับ 5 ชั้นที่เพิ่งคุย
เคส 1 — Tesla Kubernetes cryptojacking (2018)
กุมภาพันธ์ 2018 — บริษัท RedLock (ตอนนี้คือ Palo Alto Prisma Cloud) ตรวจพบว่า Tesla มี K8s dashboard เปิดอยู่บน internet โดยไม่มีรหัสผ่าน. โจรเจอ — เข้าผ่าน dashboard — สั่งให้ K8s ของ Tesla รัน Pod สำหรับ crypto mining (ขุด Monero)
ที่แสบกว่านั้น — โจรมีฝีมือ:
- ใช้ pool ของตัวเอง (ไม่ใช่ public pool) — ตรวจจับยากกว่า
- CPU usage จำกัด ไม่ให้สูงเด่นชัด — กล้องไม่ตรวจจับ
- เก็บความถี่ของการสื่อสารต่ำ — กลบ traffic anomaly
- ใช้ SSL + non-standard port — หลบ network monitoring
จุดสำคัญที่ผู้บริหารต้องเรียน — dashboard ของ K8s ที่ไม่ใส่รหัส ≠ น่ารักน่าเอ็นดู มันคือ ประตู warehouse เปิดทิ้งไว้ + ในนั้นมี server ของ Tesla. ใน scenario นี้ — ป้องกันได้ที่ ชั้น 5 (Admission Controller) + RBAC ที่ดีจาก K8s + dashboard ไม่ expose ไปนอก cluster
เคส 2 — Capital One (2019) — มุม K8s ที่ลืมพูด
EP.32 เราเล่า Capital One ในมุม SSRF + IMDSv1 ของ AWS. แต่มีมุมที่น่าสนใจกว่านั้น — ถ้า Capital One มี proper K8s RBAC + NetworkPolicy — โจรอาจไปต่อไม่ได้ไกลขนาดนั้น
ในเคสนั้น — โจรเจาะผ่าน WAF misconfiguration → ได้สิทธิ์ของ container ของ web app → ใช้สิทธิ์นั้นเรียก AWS metadata service → ได้ AWS credential → ดูดข้อมูลจาก S3 ของ 100M+ customer
ถ้ามี NetworkPolicy ที่ deny outbound ของ container web app ไปยัง metadata endpoint (169.254.169.254) — โจรเจาะเข้าได้ แต่ดึง credential ไม่ได้. ถ้ามี RBAC ดี — service account ของ Pod web app ไม่มีสิทธิ์ดู S3 bucket ใด — แม้ได้ credential ก็ใช้ไม่ได้
นี่คือพลังของ defense in depth (EP.04) ในโลก K8s — เจาะชั้นนอกได้ แต่ติดชั้นใน. Capital One ไม่ได้มีชั้นในที่แน่นพอ. บทเรียนของวงการตั้งแต่นั้น — ทุก K8s production ต้องมี NetworkPolicy บังคับ outbound + RBAC แบบ least privilege
เคส 3 — Log4Shell ใน container (2021)
ธันวาคม 2021 — Log4Shell ระเบิด — ทุก image ที่มี Log4j โดน. ในโลก container ผลกระทบขยายเร็วเป็นพิเศษเพราะ:
- base image ทางการของ Java เช่น
openjdkมีหลายเวอร์ชันที่บัน Log4j - บริษัทที่ใช้ image ของ third-party (Elastic, Splunk, monitoring tools) — บางตัวฝัง Log4j ภายใน — บริษัทไม่รู้ตัว
- ใน public image บน Docker Hub — มี image นับล้านที่ติด Log4Shell ตั้งแต่วันที่ CVE ออก
- บริษัทไม่มี SBOM — ไม่รู้ว่า image ของตัวเองมีอะไรอยู่ในนั้น — ใช้เวลาเดือนๆ กว่าจะ inventory เสร็จ
บริษัทที่ทำ image scanning + SBOM ดี — patch เสร็จใน 1-2 สัปดาห์. บริษัทที่ไม่มี — บางที่ใช้เวลา 6 เดือน — และในระหว่างนั้น โจรบอตสแกนหา Log4Shell ทั่ว internet 24/7
บทเรียนของ Log4Shell ไม่ใช่แค่ “patch ให้เร็ว” — บทเรียนใหญ่กว่าคือ “คุณต้องรู้ว่า image ของคุณมีอะไรอยู่ในนั้น” — SBOM + image scanning + dependency tracking — เป็น must-have ของวงการตั้งแต่ปี 2022. นี่นำเข้าสู่ EP.34 เลยครับ
มุมผู้บริหาร: 3 เคสนี้ — ถ้าจำได้แค่จุดเดียว — จำว่า โจรในยุค container ไม่ต้องเก่งกว่าทีมคุณมาก — แค่เจอ default config ที่ทีมคุณไม่ได้ไปเปลี่ยน. Tesla = dashboard ไม่ใส่รหัส. Capital One = NetworkPolicy ไม่ตั้ง. Log4Shell = ไม่มี SBOM. ทั้ง 3 เรื่องนี้ — ทำไม่ยาก + ไม่แพง — แค่ต้องรู้ว่าต้องทำ. คำถามที่ผู้บริหารต้องถามทุก quarter — “ตอนนี้ K8s ของเรา default ไหนที่เรายังไม่ได้แก้?” — ถ้าทีมตอบไม่ได้ทันที = ทีมไม่ได้คุมเอกสาร security baseline ของ cluster
สรุป — warehouse ที่จัดการดี กับ warehouse ที่ปล่อยตามยถากรรม
ครับ — มาถึงจุดสรุปของ EP.33 แล้ว. ในเมืองที่ของมีค่าของเรา — ตอนนี้คุณเห็นแล้วว่า ถนน (Part 4 EP.27-31), เช่าตึกใน cloud (EP.32), และ ตู้คอนเทนเนอร์ใน warehouse (EP.33) ทำงานยังไง
Container เปลี่ยนวิธี deploy software ทั้งวงการ — เร็วกว่า, เบากว่า, portable กว่า VM. Docker ทำให้ทุกคนใช้ได้ง่าย — image / container / registry. แต่พลังที่มากับ container = ความเสี่ยงรูปแบบใหม่ ที่ VM ไม่มี — image vulnerability, privileged container, container escape, secret leakage
Kubernetes = ผู้จัดการ warehouse — Pod, Deployment, Service, Ingress, ConfigMap, Secret, RBAC, NetworkPolicy. เป็น engine ทรงพลัง — ตั้งดี = เกราะ / ตั้งไม่ดี = ประตูเปิด
5 ชั้นป้องกันของ K8s — Image scan → PSS → Admission Controller → Runtime → Mesh + mTLS. ไม่ต้องทำพร้อมกันหมด — เริ่มจากชั้นที่ ROI สูง
3 เคสจริง — Tesla cryptojacking 2018 (dashboard ไม่มีรหัส), Capital One 2019 มุม K8s (NetworkPolicy + RBAC ที่ขาด), Log4Shell 2021 (SBOM + image scanning ที่ไม่มี)
สิ่งที่ผู้นำต้องจำ
ข้อแรก — Container ไม่ใช่ secure by default — มันคือ powerful by default
นี่คือ mindset shift ที่สำคัญที่สุดของ EP นี้ครับ — เวลาทีมบอก “เรา deploy ใน container แล้ว — ปลอดภัยกว่าเดิม” — คุณต้องตั้งคำถามต่อ. container เร็วขึ้น + portable ขึ้น + scalable ขึ้น — แต่ ความปลอดภัยขึ้นกับวินัยของทีม + เครื่องมือที่ใช้ + วิธีตั้งค่า
ลองนึกเปรียบเทียบครับ — รถ Tesla ขับเองได้ ≠ ปลอดภัยอัตโนมัติ. ขึ้นกับคนที่นั่งหลังพวงมาลัย + การตั้งค่า + การบำรุงรักษา. container ก็เหมือนกัน — เป็น tool ที่ทรงพลัง แต่ปลอดภัยหรือไม่ ขึ้นกับวินัยของคนใช้
checklist 6 ข้อสำหรับผู้บริหารถามทีม K8s:
- เรา pull image จาก registry ของเราเอง หรือจาก Docker Hub ตรงๆ? (คำตอบที่ดี = private registry + mirror จาก public)
- เรา scan image ก่อน production ไหม — ใช้เครื่องมืออะไร — block ที่ระดับไหน? (Trivy / Snyk / Anchore + block critical CVE)
- มี privileged container เหลือใน production ไหม — รายชื่อ? (คำตอบที่ดี = ศูนย์ หรือ <5 ตัวที่มี exception ชัดเจน)
- NetworkPolicy ครบทุก namespace ไหม — ใช้ default deny? (ถ้าไม่มี — เริ่มเลย)
- RBAC ของ K8s least privilege ไหม — ใครเป็น cluster-admin? (รายชื่อต้องสั้น + audit ได้)
- Secret เก็บใน K8s Secret (base64) หรือ external secret manager? (Vault / AWS Secrets Manager / Sealed Secrets ดีกว่า raw K8s Secret)
ทำได้ 4-5 ข้อ — บริษัทคุณอยู่ในกลุ่ม mature ของวงการแล้ว. ทำได้ 1-2 ข้อ — ลงทุนใน 3 ข้อแรกก่อน — ROI สูงสุด
ข้อสอง — Default ของ K8s ทุกตัวคือเปิดเพื่อง่าย — security คือสิ่งที่ทีมต้อง opt-in
นี่คือเรื่องที่ผู้บริหารหลายคนยังไม่เห็นภาพ — K8s ออกแบบมาให้ใช้งานง่ายก่อน เพื่อให้ adoption เร็ว. ผลคือ default ของแทบทุก setting เปิดให้ผ่าน + อนุญาตทุกอย่าง — เพื่อให้ “งานเดิน”. Pod คุยกันได้หมด. Service account มีสิทธิ์เยอะ. dashboard เปิดได้ง่าย. Secret ไม่ encrypt at rest. NetworkPolicy ไม่มี.
ทีมที่ไม่รู้เรื่องนี้ — ติดตั้ง K8s — ใช้งานได้ → คิดว่า done. แต่จริงๆ แล้ว default = ปลอดภัยน้อยสุด ในทุกมิติ. ทีมที่ mature — รู้ว่าหลังติดตั้ง K8s — ต้อง harden ทุก default ก่อน production
เคส Tesla (dashboard) + Capital One (RBAC + NetworkPolicy) ทั้งคู่เป็นเคสคลาสสิคของ “default config risk” — ไม่ใช่ช่องโหว่ใน K8s — แต่เป็น default ที่ทีมไม่ได้ไปเปลี่ยน
วัฒนธรรมที่บริษัทคุณควรสร้าง — “K8s production-ready != K8s ทำงานได้”. ก่อนขึ้น production — ต้องมี K8s security baseline checklist ที่ทำตามทุกข้อ. มาตรฐานที่ใช้อ้างได้ในวงการ — CIS Kubernetes Benchmark + NSA/CISA Kubernetes Hardening Guide + OWASP Kubernetes Top 10. ทั้งสามฟรี + อ่านได้ทุก operator. ถ้าทีม K8s ไม่เคยได้ยินอย่างใดอย่างหนึ่ง = สีเหลือง
Tease EP.34 — ยามตรวจของตั้งแต่โรงงาน ไม่ใช่ตอนถึง warehouse
ครับ — EP.33 จบ. คุณเห็นแล้วว่า ตู้คอนเทนเนอร์ ใน warehouse + ผู้จัดการ warehouse (K8s) ทำงานยังไง + ความเสี่ยงตรงไหน + ป้องกันยังไง
แต่ลองคิดต่อ — ที่ผ่านมาเราคุยเรื่องการตรวจ ตอน image scan ก่อนเข้า cluster + ตอน Pod รัน. ทั้งคู่คือ “ตรวจตอนของถึง warehouse แล้ว”
คำถามใหญ่ของ EP.34 — แล้วก่อนหน้านั้นล่ะ?
- ก่อนของจะถูกบรรจุลงตู้ — โค้ดเขียนที่ไหน? บน laptop ของ developer
- โค้ดผ่านอะไรก่อนกลายเป็น image? CI/CD pipeline (โรงงานประกอบ)
- ใครส่งโค้ดอันตรายเข้า pipeline ได้บ้าง? ใครก็ตามที่ commit code ได้ + dependency จากนอก + infrastructure as code script
- ของในตู้บางส่วนมาจากไหน? library นับร้อย ของบริษัทอื่นทั่วโลก
EP.34 จะพาคุณดูแนวคิดที่เปลี่ยนวงการในรอบ 5 ปี — DevSecOps + Shift-Left:
- ยามตรวจของตั้งแต่ในโรงงาน ไม่ใช่ตอนของถึง warehouse — เพราะถ้าถึง warehouse แล้วเจอปัญหา = แพง + ช้า + ลูกค้าได้รับผลกระทบ
- SAST (ตรวจโค้ดขณะเขียน) / DAST (ตรวจ application ขณะรัน) / SCA (ตรวจ library ภายนอก) / IAST (ตรวจแบบไฮบริด)
- IaC scanning (ตรวจสคริปต์สร้าง infrastructure เช่น Terraform)
- Secret scanning ตั้งแต่ commit
- SBOM (Software Bill of Materials) — รายการของในตู้ทุกตู้
- Supply chain attack — เคส SolarWinds 2020 + Log4Shell 2021 จะ revisit ในมุม build pipeline
หลัก shift-left = ขยับการตรวจสอบไปต้นน้ำที่สุดเท่าที่ทำได้ — เพราะของพังตอน production แก้แพงกว่าตอน design นาทีแรก 100 เท่าขึ้นไป
ครับ — EP.34 — DevSecOps + Shift-Left — เปลี่ยนทั้งความสัมพันธ์ระหว่าง developer กับ security จากเดิม “security เป็นยามขัดขวาง” → “security เป็นเครื่องมือของ developer ตั้งแต่บรรทัดแรก”
→ EP.34 — DevSecOps + Shift-Left: ยามตรวจของตั้งแต่โรงงาน (กำลังเขียน)