Forem: Perajit

AWS vs GCP ตอนที่ 1: Network & Security

Perajit — Tue, 21 Apr 2026 14:31:30 +0000

บทความนี้เขียนเพื่อพยายามสรุปเปรียบเทียบ AWS และ GCP จะเขียนออกแนวโน้ตส่วนตัว แบบสรุปคร่าวๆ ไม่ลงรายละเอียดเยอะ (เพราะก็ไม่ได้เชี่ยวชาญ 555)

ที่คิดไว้ก็อยากเขียนหลายเรื่อง แต่ขอเริ่มจากเรื่อง Network ก่อนแล้วกัน

Network Architecture

ก่อนอื่นต้องพูดถึงคำศัพท์กันก่อน

ในแง่ภูมิศาสตร์: Global, Region, Zone (สำหรับ AWS เรียก Availability Zone หรือ AZ)
- ในระบบ cloud แต่ละเจ้าจะแบ่งโครงสร้างพื้นฐานในเชิงภูมิศาสตร์ตามบริเวณที่มี data center
- Global คือทั้งโลก ประกอบด้วยหลายๆ Region ซึ่งเป็นที่ตั้งที่อยู่ห่างกันมาก
- แต่ละ Region จะประกอบด้วยหลาย Zone (สำหรับ AWS เรียก availability zone หรือ AZ) อีกที
ในแง่เครือข่าย: VPC, Subnet
- VPC ที่เป็นวงเครือข่ายที่ resource ภายในสามารถมองเห็นกันได้แต่ภายนอกไม่สามารถมองเห็นเข้ามาได้ถ้าไม่ได้รับอนุญาต
- Subnet ส่วนย่อยของ VPC

ความแตกต่างที่ชัดเจนคือ

สำหรับ AWS:

VPC span เป็น Regional ไม่สามารถ span ข้าม Region ได้
Subnet อยู่เฉพาะใน AZ เดียวเท่านั้น ไม่สามารถ span ข้าม AZ ได้

ในขณะที่ GCP:

VPC span เป็น Global ครอบคลุมทั่วโลก
Subnet เป็น Regional คือ span ครอบคลุมได้หลาย Zone (เวลาวาง VM ยังต้องเลือก Zone แต่ IP Address มาจาก pool เดียวกันทั้ง Region)

ความแตกต่างนี้ทำให้ GCP สามารถคุยข้าม Region ได้เลยโดยไม่ต้องทำอะไรเพิ่ม ขณะที่ AWS ต้องมีขั้นตอนเพิ่มเติม (เช่น ทำ Peering) เพื่อให้คุยข้าม Region ได้

Network Routing

การคุม traffic ใน Network จะใช้ Route Table (AWS) หรือ Routes (GCP)โดยมีความแตกต่างกันตามนี้

AWS Route Table

อยู่ในเลเวล Subnet คือแต่ละ VPC จะมีได้หลาย Route Table และควบคุม traffic ของแต่ละ Subnet แยกกันด้วยการสร้าง Route Table ที่ต่างกันไปผูกไว้
ถ้าไม่มีการผูก Route Table ที่สร้างแยกไว้ Subnet จะใช้ Main Route Table ซึ่งเป็นตารางกลางสำหรับทุก Subnet ซึ่งกำหนดให้ component ทุกตัวคุยกันผ่าน internal IP ได้ภายใน VPC

GCP Routes

มี Routes ตารางเดียวเป็นระดับ Global แชร์กันทั้งโลก
สามารถสร้าง Route ให้มีผลเฉพาะสำหรับ VM บางตัวได้โดยการใส่ Network Tags
เมื่อมีการสร้าง Subnet ใหม่ ระบบจะสร้าง Route สำหรับการติดต่อภายใน (local) ให้แบบ Global โดยอัตโนมัติ หมายความว่า component จากคนละ Region จะคุยกันผ่าน internal IP ได้เลย

Network Security

Network Security in AWS

AWS แบ่งตัวควบคุม security เป็น 2 เลเยอร์ คือ ในระดับ Subnet และระดับ Instance

Security Group:

ควบคุมระดับ Instance
เป็นการควบคุมแบบ Stateful หมายความว่า มีการจำเส้นทางเข้าออกของ traffic ถ้าขาเข้าผ่านได้ ขาออกก็จะผ่านได้โดยอัตโนมัติ
ควบคุมแค่ Allow เท่านั้น (white-list)
ค่า default คือ Deny ขาเข้าทั้งหมด แต่ Allow ขาออกทั้งหมด ทำให้ instance สามารถเรียกออกไปข้างนอกได้เพื่อ install package ต่างๆ ได้

Network ACL (NACL):

ควบคุมระดับ Subnet
เป็นการควบคุมแบบ Stateless หมายความว่า ไม่มีการจำการเส้นทางเข้าออกของ traffic ต่อให้ขาเข้าผ่านเข้ามาได้แล้วมันก็ไม่ได้ยอมให้ขาออกผ่านได้เอง ต้องกำหนดกฎของ "ขาเข้า" (ingress) และ "ขาออก" (egress) แยกกัน
ควบคุมได้ทั้ง Allow และ Deny (สามารถทำ black-list ได้)
โดย default จะ allow ทั้งหมด ทั้งขาเข้าและขาออก

ใน AWS มักจะใช้ Security Group เป็นหลัก และใช้ NACL แค่เป็นด่านเสริมเพื่อ black-list IP ไม่พึงประสงค์

Network Security in GCP

มีตัวควบคุม security หลักๆ คือ Firewall Rules เป็นการควบคุมแบบ Stateful โดยมีค่า default เหมือนกับ Security Group (stateful เหมือนกัน) คืออนุญาตให้ทุกอย่างวิ่งออกได้ทั้งหมด แต่บล็อกทุกอย่างที่วิ่งเข้า

ควบคุมได้ทั้ง Allow และ Deny ทำให้เราสามารถใช้ทำ black-list กับ white-list ได้โดยอาศัยการตั้งค่า Deny/Allow, Priority

ทำ Deny (black-list):
- สร้างกฎโดยใช้ Action: Deny, Priority: 100 (ตัวเลขน้อยกว่ากฎ Allow หมายถึงสำคัญมากกว่า)
- ระบุ Source IP ที่ต้องการบล็อก
ทำ Allow (white-list):
- สร้างกฎโดยใช้ Action: Allow, Priority: 1000 (ตัวเลขมากกว่ากฎ Deny หมายถึงสำคัญน้อยกว่า)
- ระบุ Source IP ที่ต้องการให้ผ่าน

Firewall Rules ทำงานที่ระดับ VPC แต่สามารถเซ็ตค่าให้ทำงานในระดับ Instance (เหมือน Security Group) หรือ Subnet (เหมือน NACL) ได้

ควบคุมระดับ Instance (เทียบกับ Security Group): อาศัย Target Tags ระบุเป้าหมายกลุ่มของ VM ที่ต้องการบังคับใช้กฎ
ควบคุมระดับ Subnet (เทียบกับ NACL): อาศัยการกำหนด Destination IP เป็น IP range ของ Subnet ที่ต้องการควบคุม

Interface ใน Go ฉบับรวบยอด

Perajit — Tue, 21 Apr 2026 01:27:11 +0000

Interface กับ OOP

จากบทความที่แล้ว เราทำ OOP ด้วยการผูก method ให้ struct ผ่าน receiver ทีนี้ถ้าเราอยากจัดการกับ struct หลายประเภทที่มีพฤติกรรมเหมือนกันในที่เดียวจะทำยังไง?

ปกติในภาษาอื่นเราก็จะสร้าง interface ขึ้นมา แล้วให้แต่ละ class implement interface นั้นใช่มั้ย? ใน Go ก็มี interface เหมือนกัน แต่สิ่งที่ต่างคือ ใน Go เป็น implicit interface ไม่ต้องมีการเขียนคีย์เวิร์ด implement เลย

เช่น เรามี Cat และ Dog ซึ่งทั้งคู่มี method ที่มี method signature เหมือนกันคือ Speaker()

type Cat struct { Name string }
func (c Cat) Speak() { fmt.Println(c.Name, "Meow!") }

type Dog struct { Name string }
func (d Dog) Speak() { fmt.Println(d.Name, "Woof!") }

เราสามารถสร้าง interface ได้แบบนี้

type Speaker interface {
  Speak()
}

โดย Cat และ Dog ของเราจะยังเหมือนเดิม ไม่มีแก้โค้ดใดๆ แต่ Go จะรู้เองว่ามันคือ Speaker เพราะว่า "satisfy interface"

และเราก็สามารถประกาศ slice ของ Speaker แล้วเก็บค่า Cat กับ Dog ไว้ด้วยกัน รวมถึงสามารถเรียก method ของ Speaker จาก slice ได้เลย

cat := Cat{Name: "Kitty"}
dog := Dog{Name: "Bo"}

// slice ของ Speaker เก็บได้ทั้ง cat และ dog ทันที
animals := []Speaker{cat, dog}

for _, a := range animals {
  // เรียก Speak() ของ Speaker ได้เลย
  a.Speak()
}

ไอเดียคือใช้การประกาศ interface จากฝั่ง consumer ตรงข้ามกับใน classic OOP ที่เวลาจะใช้ interface ต้องมีการผูกกันตั้งแต่ต้น ซึ่งการทำ interface แบบ Go มีข้อดีหลายอย่าง

ทำให้เราโฟกัสที่ behavior มากกว่า type
ยืดหยุ่น สามารถเอา library สองตัวจากคนละที่มาทำงานร่วมกันได้ทันทีถ้า method signature ตรงกัน
ไม่ผูกติดกับโค้ดต้นทาง ถ้าสนใจ method ไหนก็ประกาศ interface แค่นั้นพอ ซึ่งข้อนี้ทำให้การ mock (เช่น สำหรับ unit test) ง่ายขึ้นมาก

โครงสร้าง Interface

ภายใต้ตัวแปร interface จะเก็บค่า 2 อย่างเสมอ คือ type (ชนิดของข้อมูล) และ value (ค่าของข้อมูล) เพราะฉะนั้น interface จะเป็น nil ก็ต่อเมื่อทั้ง type และ value เป็น nil

เช่นจากตัวอย่างเดิม เรามี struct Cat และ interface Speaker

var c *Cat = nil
var i Speaker = c

// ตรวจสอบว่า i เป็น nil รึเปล่า
fmt.Println(i == nil)

จะได้ผลลัพธ์เป็น false

Empty Interface

interface ว่าง interface{} คือ interface ที่ไม่มีการกำหนด method อะไรไว้ ซึ่งหมายความว่าสามารถเป็น type อะไรก็ได้ (หรือก็คือ any ในเวอร์ชั่นใหม่ๆ ของ Go)

เรามักจะใช้ในกรณีที่ต้องการ Dynamic Type เช่น ใช้กับฟังก์ชั่นที่รับพารามิเตอร์อะไรก็ได้ หรือใช้กับโครงสร้างข้อมูลที่ dynamic เช่น map[string]interface{}

แต่ข้อควรระวังคือ เราจะไม่สามารถใช้ความสามารถของ type เดิมได้ ต้องแปลงค่ากลับมาก่อน เช่น

var x interface{} = 1

เราไม่สามารถสั่งแบบนี้ได้

sum := x + 5 // จะ error

เนื่องจากตอนนี้ x เป็น interface{} ไม่ใช่ int ต้องแปลงกลับเป็น int ก่อนถึงจะทำ operation ของ int ได้

sum := x.(int) + 5

ปัจจุบัน Go มี Generics ให้ใช้แล้ว แนะนำให้ใช้ Generics แทน interface{}

OOP ใน Go ฉบับเข้าใจง่าย (มั้ง)

Perajit — Tue, 21 Apr 2026 00:17:37 +0000

ออกตัวก่อนว่าไม่ได้เชี่ยวชาญ Go อะไรมากมาย แค่นึกไม่ออกว่าเขียนเรื่องอะไรดี แล้วเรื่องนี้ก็ผุดขึ้นมา

ใน Go สามารถทำ OOP ได้ แต่จะค่อนข้างต่างจากภาษาอื่นที่เคยเจอมา คือไม่มีสิ่งที่เรียกว่า class แต่จะใช้ struct ซึ่งเป็นการ define โครงสร้างข้อมูล เช่น

type Animal struct {
  Name string
  Weight int
}

เป็นการประกาศโครงสร้างของข้อมูลที่ประกอบด้วยฟิลด์ชื่อ Name และ Weight และเนื่องจากใน Go จะใส่ zero value ให้ค่าต่างๆ เสมอ ดังนั้นถ้าประกาศตัวแปรด้วย type ของ struct แต่ละ field ก็จะมีค่าเริ่มต้นเป็น zero value ของแต่ละชนิดข้อมูลโดยอัตโนมัติ ซึ่งก็คือทำหน้าที่เก็บข้อมูลได้เหมือน data class ในภาษาอื่นนั่นเอง

จากตัวอย่าง Animal ถ้าประกาศตัวแปรแบบนี้

cat := Animal{}

เราก็จะได้สิ่งที่เหมือนกับ instance ของ data class ที่มีค่า cat.Name = "" และ cat.Weight = 0

หรือจะกำหนดค่าเริ่มต้นลงไปตั้งแต่ตอนประกาศค่าก็ได้ เช่น

cat := Animal{Name: "Kitty", Weight: 2}

ก็จะได้ค่าตามที่กำหนดคือ cat.Name = "Kitty" และ cat.Weight = 2

Class with methods

ตอนนี้เราสามารถสร้างสิ่งที่เหมือนกับ class ที่มี property แล้ว แต่ว่าในโลกของ OOP เนี่ย class ไม่ได้มีแค่ property แต่ยังมี method ด้วยใช่มั้ย?

ใน Go เราสามารถสร้าง method ให้กับ struct ได้โดยไม่ได้เขียนลงใน struct เลย แต่ใช้การการผูกฟังก์ชั่นเข้าไปโต้งๆ ทีหลัง ซึ่งคำว่า "ผูกโต้งๆ" อาศัยสิ่งที่เรียกว่า receiver

ตัวอย่างเช่น เราจะเติม method Eat() ให้กับ Animal ได้แบบนี้

func(a *Animal) Eat() {
  a.Weight++
}

สังเกตว่ารูปแบบการเขียนฟังก์ชั่นจะมีบางอย่างเพิ่มเข้ามา คือ (a *Animal) สิ่งนี้แหละที่เรียกว่า receiver โดย a คือ receiver variable ส่วน *Animal เป็น receiver type สังเกตว่าจะไม่มีการใช้คีย์เวิร์ด this เหมือนภาษาอื่น แต่จะใช้ receiver อ้างอิงไปเลย

ลองเขียนโค้ดทดสอบดู

cat := Animal{Name: "Kitty", Weight: 2}
cat.Eat()
fmt.Printf("Weight: %v", a.Weight)

จะได้ค่า a.Weight = 3

แล้วทีนี้อยากให้มี method อีกสักกี่อันก็แค่เขียนฟังก์ชั่นโดยผูก receiver เข้าไป

ข้อดีของการเขียนลักษณะนี้คือทำให้สามารถเติม method เข้าไปได้โดย struct ไม่บวม (อยู่คนละไฟล์ได้) และการใช้ชื่อตัวแปร receiver แทน this ทำให้ refactor โค้ดจาก function ธรรมดามาเป็น method ได้ง่ายๆ โดยไม่ต้องแก้ชื่อตัวแปรเป็น this

เสริมอีกนิดว่า receiver มี 2 แบบคือ value receiver กับ pointer receiver สำหรับในตัวอย่างเราใช้ pointer receiver ซึ่งคือแบบนี้ (a *Animal) เพราะต้องการแก้ไขข้อมูล เวลาใช้ value receiver ซึ่งคือแบบนี้ (a Animal) เราจะไม่สามารถแก้ไขข้อมูลได้

เช่น ถ้าแก้โค้ดของ method Eat() เป็นแบบนี้

// การใช้ value receiver จะไม่สามารถแก้ไขข้อมูลได้
func(a Animal) Eat {
  a.Weight++
}

ผลที่ได้คือคือค่าของ a.Weight จะไม่เปลี่ยน

Inheritance (หรือจริงๆ คือ Composition)

การ "สืบทอด" ใน Go ก็แตกต่างจากภาษาอื่นที่ใช้คีย์เวิร์ด extends แต่ Go ออกแบบมาให้ "Composition over Inheritance" จึงใช้การ "ฝัง" (embedding) struct ซ้อนเข้าไปข้างใน เช่น

type Cat struct {
  Animal
  SlaveName string
}
func(c *Cat) Meow() {
  fmt.Println("Meow")
}

เราจะได้ Cat ที่มี property และ method ของ Animal ติดมาด้วยทันที
ทดสอบด้วยการเขียนโค้ดตามด้านล่างนี้

cat := Cat{}
cat.Eat()
fmt.Printf("Name: %v, Weight: %v, SlaveName: %v", cat.Name, cat.Weight, cat.SlaveName)

โค้ดจะไม่พัง และจะได้ผลลัพธ์เป็น Name:, Weight:1, SlaveName:

Name เป็นสตริงว่าง จาก zero value
Weight เป็น 1 เนื่องจากมีการสั่ง cat.Eat() ทำการเพิ่มค่าจาก zero value ครั้งนึง
SlaveName เป็นสตริงว่างจาก zero value

แล้วถ้าเกิดเราต้องการใส่ค่าเริ่มต้นให้กับ cat ล่ะ? ในเมื่อเราสามารถเรียก property ที่มาจาก Animal ได้ตรงๆ งั้นเราลองใส่ Weight เป็น 2 ให้กับ cat ดูหน่อย

cat := Cat{Weight: 2, SlaveName: "Jack"}

ปรากฏว่าเขียนแบบนี้จะเจอ syntax error…

นี่เป็นเรื่องที่เราเจอตอนลองเขียนครั้งแรก แล้วก็งงว่าจะใส่ค่าเริ่มต้นให้มันได้ยังไง แล้วก็ค้นพบว่า วิธีที่ถูกต้องคือ ต้องระบุชื่อ struct ที่ embed มาด้วย!

เนื่องจากตอนประกาศ struct เราใส่ Animal เข้าไป ตอนเซ็ตค่าเริ่มต้นเราก็ต้องระบุ Animal เหมือนกัน แบบนี้

cat := Cat{Animal: Animal{Weight: 2}, SlaveName: "Jack"}

ทีนี้ถ้าลองสั่ง

cat.Eat()
fmt.Printf("Name: %v, Weight: %v, SlaveName: %v", cat.Name, cat.Weight, cat.SlaveName)

เราจะได้ผลลัพธ์ Name:, Weight:3, SlaveName:Jack

Name ยังเป็นสตริงว่างเพราะไม่ได้กำหนดค่า
Weight เป็น 3 เนื่องจากค่าเริ่มต้นถูกเซ็ตเป็น 2
SlaveName ได้ค่า Jack ที่เซ็ตเข้าไป

ตอนที่ดึงค่าออกมาจาก field หรือเรียก method สามารถเรียกได้เลยตรงๆ แต่ตอนประกาศค่าต้องระบุชื่อ struct ที่ embed มาเสมอ

สำหรับ OOP ใน Go คร่าวๆ ก็ประมาณนี้ค่ะ