Configuration & Environment Variables

go version go1.26.5 darwin/arm64
github.com/lib/pq v1.10.9   # ใช้เฉพาะหัวข้อ 6 ตอนพิสูจน์เรื่อง DSN

1 · โค้ดนี้ผิดตรงไหน

นี่คือ cmd/api/main.go แบบที่เขียนกันตอนเริ่มโปรเจกต์ — เปิดฐานข้อมูล แล้วเปิดเซิร์ฟเวอร์ จบ (โครง cmd/ มาจาก บทเรียน 27):

db, _ := gorm.Open(postgres.Open(
    "host=localhost user=postgres password=P@ssw0rd123 dbname=wongnok"))

recipeRepo := repository.NewRecipeRepo(db)   // db ถูกใช้ต่อตรงนี้

r := gin.Default()
r.Run(":8080")

โค้ดนี้ compile ผ่าน รันได้ ทำงานถูกต้อง บนเครื่องคุณ
และมันมีปัญหาสามข้อที่จะโผล่คนละเวลากัน:

ปัญหา 1 — รหัสผ่านอยู่ในโค้ด

P@ssw0rd123 ไม่ได้อยู่แค่ในไฟล์ พอคุณ git commit แล้ว git push มันจะกลายเป็นส่วนหนึ่งของประวัติ repo ถาวร
จุดที่คนพลาดกันมากที่สุด: ลบทิ้งทีหลังไม่ช่วย — commit เก่ายังอยู่ ใครก็ตามที่ clone repo ไปแล้วสั่ง git log -p ก็ยังอ่านเจอ ถ้า repo เคยเป็น public แม้แค่ชั่วโมงเดียว ต้องถือว่ารหัสผ่านนั้นหลุดแล้ว และวิธีแก้ที่ถูกต้องคือไปเปลี่ยนรหัสผ่านที่ฐานข้อมูล ไม่ใช่แก้ไฟล์

ปัญหา 2 — เปลี่ยนค่า = แก้โค้ด

แอปตัวเดียวกันต้องรันอย่างน้อยสามที่: เครื่องคุณ (dev) · เครื่องทดสอบ (staging) · ของจริง (production) ทั้งสามที่ต่อคนละฐานข้อมูล
โค้ดข้างบนมี host เดียวฝังไว้ แปลว่าจะขึ้น staging ต้องแก้ไฟล์ → commit → build ใหม่
ผลคือ binary ที่คุณเทสบน staging กับที่ปล่อยขึ้น production ไม่ใช่ก้อนเดียวกัน — เทสผ่านบนก้อนหนึ่ง แล้วปล่อยอีกก้อนหนึ่ง

ปัญหา 3 — ทีมใช้ค่าเดียวกันไม่ได้

เพื่อนในทีมสามคน คนหนึ่งลง Postgres ไว้ที่ localhost อีกคนรันใน Docker อีกคนใช้พอร์ตอื่นเพราะพอร์ต 5432 ชนกับของเดิม
โค้ดมี host เดียว ใครแก้ให้ตรงเครื่องตัวเองก็ต้องระวังไม่ให้ commit ติดไป — และสุดท้ายก็มีคน commit ติดไปจนได้ แล้วเครื่องคนอื่นพังหมด

2 · Environment Variables คืออะไรกันแน่

Environment variable คือ ตัวแปรที่อยู่นอกโปรแกรม — ระบบปฏิบัติการเก็บไว้ให้ทุก process แล้วส่งต่อให้โปรแกรมของเราตอนรัน ไม่ใช่ตอน build
(process = โปรแกรมหนึ่งตัวที่กำลังทำงานอยู่ · เปิดสอง terminal แล้วสั่ง ./api ทั้งสองอัน = สอง process คนละตัว คนละ PID)
คุณสมบัติที่ต้องจำมีสี่ข้อ:

ข้อ "ส่งต่อจาก parent ไป child" ฟังดูนามธรรม ผมพิสูจน์ให้ดูด้วย PID จริง — โปรแกรมทดสอบพิมพ์ os.Getpid() กับ os.Getppid() ออกมา แล้วผมพิมพ์ PID ของ shell ($$) เทียบ:

$ echo "this shell PID = $$"; APP_PORT=6262 go run .
this shell PID = 34148
APP_PORT = 6262
my PID = 34157  parent PID = 34151

สาม PID ต่างกันหมด: shell (34148) → go run (34151) → binary จริงที่ถูก compile แล้วรัน (34157)
ค่า APP_PORT=6262 วิ่งข้ามไปครบสองทอด โดยเราไม่ได้ทำอะไรเพิ่มเลย

# ก้อนที่ 1 — ไม่มี export
$ APP_PORT=5555; echo "shell sees: $APP_PORT"; ./api
shell sees: 5555          # shell เห็นค่า
APP_PORT  =               # แต่โปรแกรมได้ค่าว่าง
LOG_LEVEL =
PID       = 39661

# ก้อนที่ 2 — มี export
$ export APP_PORT=5555; echo "shell sees: $APP_PORT"; ./api
shell sees: 5555
APP_PORT  = 5555          # คราวนี้โปรแกรมเห็น
LOG_LEVEL =
PID       = 39663

มีอีกท่าหนึ่งที่ใช้บ่อยกว่า export เวลาทดสอบ คือเขียนนำหน้าคำสั่ง ซึ่งมีผลเฉพาะคำสั่งนั้น ไม่ค้างใน shell:

$ export APP_PORT=8080; APP_PORT=9090 ./api; echo "shell still: $APP_PORT"
APP_PORT  = 9090             # โปรแกรมเห็น 9090
LOG_LEVEL =
PID       = 39699
shell still: 8080            # shell ยังเป็น 8080 เหมือนเดิม

จำสองเรื่องจากผลนี้: เขียนนำหน้าคำสั่งชนะ export สำหรับ process นั้น · และค่าไม่ค้าง พอคำสั่งจบ shell กลับไปเป็นค่าเดิม

3 · ไม่ใช่เรื่องเฉพาะ Go

ตรงนี้สำคัญกว่าที่คิด: env ไม่ใช่ feature ของ Go แต่เป็นกติกาของระบบปฏิบัติการ ที่ทุกภาษาและทุกเครื่องมือ deploy เห็นตรงกัน
แปลว่าเมื่อคุณเรียนวิธีนี้ครั้งเดียว คุณใช้ได้กับทุกที่ที่โค้ดของคุณจะไปอยู่:

และฝั่งภาษาโปรแกรม ทุกภาษาก็มีวิธีอ่านของตัวเอง หน้าตาต่างกันแต่เป็นของสิ่งเดียวกัน:

แนวคิดนี้มีชื่อเรียกและมีที่มา — มาจากเอกสารชื่อ 12-Factor App ซึ่งเป็นชุดหลักการ 12 ข้อสำหรับเขียนแอปที่ deploy ง่าย
ข้อที่เกี่ยวกับเราคือ Factor III: Config ที่บอกว่า config ต้องแยกออกจาก code และเก็บใน environment
เกณฑ์ทดสอบง่าย ๆ ที่เอกสารนั้นให้ไว้คือ: ถ้าตอนนี้เปิด repo ให้เป็น public ทันที มีอะไรหลุดไหม — ถ้ามี แปลว่า config ยังไม่แยก

$ export LOG_LEVEL=FROM_HOST; docker run --rm alpine printenv LOG_LEVEL
host LOG_LEVEL = FROM_HOST
exit=1                          # container ไม่เห็นเลย ไม่พิมพ์อะไรออกมา

$ docker run --rm -e LOG_LEVEL alpine printenv LOG_LEVEL
FROM_HOST                      # เขียน -e ชื่อเปล่า ๆ = หยิบค่าจาก shell ส่งเข้าไป

4 · เรียกใช้ env ใน Go แบบพื้นฐาน

Go มีสองฟังก์ชันสำหรับอ่าน env และความต่างของมันคือหัวใจของหัวข้อนี้:

// แบบที่ 1 — ได้ค่ามาอย่างเดียว ไม่มี error
level := os.Getenv("LOG_LEVEL")

// แบบที่ 2 — ได้ค่า + บอกด้วยว่า "ตัวแปรนี้มีอยู่จริงไหม"
level, ok := os.LookupEnv("LOG_LEVEL")

os.Getenv ถ้าไม่เจอจะคืน "" เฉย ๆ · ไม่มี error ไม่มี panic
ส่วน os.LookupEnv คืนค่าที่สองเป็น bool ซึ่งตอบคำถามคนละข้อ: ไม่ใช่ "ค่าว่างไหม" แต่คือ "ตัวแปรนี้ถูกตั้งไว้หรือเปล่า"

fmt.Printf("Getenv    = %q\n", os.Getenv("LOG_LEVEL"))
v, ok := os.LookupEnv("LOG_LEVEL")
fmt.Printf("LookupEnv = %q, ok=%v\n", v, ok)

$ env LOG_LEVEL=DEBUG ./envtest
Getenv    = "DEBUG"
LookupEnv = "DEBUG", ok=true

$ env LOG_LEVEL= ./envtest
Getenv    = ""
LookupEnv = "", ok=true

$ env -u LOG_LEVEL ./envtest
Getenv    = ""
LookupEnv = "", ok=false

$ export LOG_LEVEL=""; ./envtest; printenv | grep -c '^LOG_LEVEL'
LookupEnv = "", ok=true
--- printenv | grep -c LOG_LEVEL ---
1        # ตัวแปรมีอยู่จริง แค่ค่าว่าง

$ unset LOG_LEVEL; ./envtest; printenv | grep -c '^LOG_LEVEL'
LookupEnv = "", ok=false
--- printenv | grep -c LOG_LEVEL ---
0        # ไม่มีตัวแปรนี้แล้วจริง ๆ

สรุปเป็นตารางสามกรณี ทุกช่องมาจากผลรันในกล่องเฉลยข้างบน:

5 · กับดักแรก — ทุกอย่างเป็น string

PORT=8080 ที่โปรแกรมได้รับคือสตริง "8080" ไม่ใช่เลข 8080
อยากได้ int ต้องแปลงเอง และทุกฟังก์ชันแปลงคืน error มาด้วยเสมอ:

strconv.Atoi("")                  // PORT ไม่ได้ตั้งค่า → Getenv คืน ""
time.ParseDuration("30")        // คนเขียน TIMEOUT=30 แล้วคิดว่า "30 วินาที"
strconv.ParseBool("yes")          // คนที่มาจาก YAML เคยชินกับ yes/no

strconv.Atoi("") -> v=0, err=strconv.Atoi: parsing "": invalid syntax
    err type: *strconv.NumError
    NumError{Func:"Atoi", Num:"", Err:invalid syntax}

time.ParseDuration("30") -> v=0s, err=time: missing unit in duration "30"
    err type: *time.parseDurationError

strconv.ParseBool("yes") -> v=false, err=strconv.ParseBool: parsing "yes": invalid syntax
    err type: *strconv.NumError

เคสข้างบนยังพอเดาได้ ทีนี้ผมรันเคสที่เดาไม่ได้ ให้ดู เริ่มจาก Atoi:

strconv.Atoi("8080 ")   -> n=0, err=strconv.Atoi: parsing "8080 ": invalid syntax   # ช่องว่างท้ายตัวเดียว
strconv.Atoi(" 8080")   -> n=0, err=strconv.Atoi: parsing " 8080": invalid syntax
strconv.Atoi("8080\n")  -> n=0, err=strconv.Atoi: parsing "8080\n": invalid syntax
strconv.Atoi("8080.0")  -> n=0, err=strconv.Atoi: parsing "8080.0": invalid syntax
strconv.Atoi("+8080")   -> n=8080, err=<nil>                                        # ผ่าน
strconv.Atoi("08080")   -> n=8080, err=<nil>                                        # ผ่าน
strconv.Atoi("8_080")   -> n=0, err=strconv.Atoi: parsing "8_080": invalid syntax
strconv.Atoi("99999999999999999999")
    -> n=9223372036854775807, err=strconv.Atoi: parsing "99999999999999999999": value out of range

time.ParseDuration แปลกกว่านั้นอีก เพราะมันมีข้อความ error ถึงสามแบบ:

time.ParseDuration("1h30m") -> d=1h30m0s, err=<nil>      # ต่อหน่วยกันได้
time.ParseDuration("-5s")   -> d=-5s, err=<nil>
time.ParseDuration("30ms")  -> d=30ms, err=<nil>
time.ParseDuration("0")     -> d=0s, err=<nil>            # ข้อยกเว้นเดียวที่ไม่ต้องมีหน่วย

time.ParseDuration("")      -> d=0s, err=time: invalid duration ""
time.ParseDuration("abc")   -> d=0s, err=time: invalid duration "abc"
time.ParseDuration("30")    -> d=0s, err=time: missing unit in duration "30"
time.ParseDuration(" 30s")  -> d=0s, err=time: invalid duration " 30s"
time.ParseDuration("30s ")  -> d=0s, err=time: unknown unit "s " in duration "30s "
time.ParseDuration("30S")   -> d=0s, err=time: unknown unit "S" in duration "30S"

สองบรรทัดล่างสุดคือของแปลก: "30s " ที่มีช่องว่างท้ายไม่ได้ขึ้นว่า invalid แต่ขึ้นว่า unknown unit "s " — ซึ่งอ่านแล้วงงมากว่าหน่วย s ไม่รู้จักได้ยังไง (คำตอบ: หน่วยที่มันเห็นคือ "s " พร้อมช่องว่าง ไม่ใช่ "s")
และ "30S" ตัว S ใหญ่ก็ไม่ผ่าน เพราะหน่วยเป็น case-sensitive

strconv.ParseBool เป็นตัวที่คนเดาผิดบ่อยที่สุด เพราะมันรับเฉพาะ 12 ค่านี้ ไม่มีอย่างอื่นเลย ผมยืนยันสองทาง — brute force ทดสอบ 24 ค่า (ทุกค่าที่โชว์ข้างล่างนี้) และเปิดซอร์สจริงของ Go 1.26.5 อ่าน:

// จาก src/internal/strconv/atob.go ของ Go 1.26.5 — เป็น switch ตรง ๆ ไม่มี trim ไม่มี lowercase
func ParseBool(str string) (bool, error) {
	switch str {
	case "1", "t", "T", "true", "TRUE", "True":
		return true, nil
	case "0", "f", "F", "false", "FALSE", "False":
		return false, nil
	}
	return false, ErrSyntax
}

  "1" "t" "T" "TRUE" "true" "True"      OK  -> true
  "0" "f" "F" "FALSE" "false" "False"   OK  -> false

  "tRue"   ERROR  strconv.ParseBool: parsing "tRue": invalid syntax   # พิมพ์ผสมไม่ได้
  "yes"    ERROR  strconv.ParseBool: parsing "yes": invalid syntax
  "no"     ERROR  strconv.ParseBool: parsing "no": invalid syntax
  "on"     ERROR  strconv.ParseBool: parsing "on": invalid syntax
  "off"    ERROR  strconv.ParseBool: parsing "off": invalid syntax
  "y" "n" "Y" "N" "2" "-1"              ERROR  ... invalid syntax
  " true"  ERROR  strconv.ParseBool: parsing " true": invalid syntax   # ช่องว่างก็ไม่ได้

6 · ปัญหาของการใช้ os.Getenv() เยอะ ๆ

มาถึงตรงนี้เรามีเครื่องมือครบแล้ว — อ่าน env ได้ แปลง type ได้ เช็ค error ได้
แล้วปัญหาอยู่ตรงไหน? ปัญหาคือพอโปรเจกต์โต แล้วเรียก os.Getenv กระจายไปทั่วโค้ด มันจะพังห้าแบบที่ไม่มีอะไรจับได้เลย

1 · พิมพ์ผิดไม่มีใครเตือน

ชื่อ env เป็นสตริงธรรมดา — compiler ไม่รู้จักมัน ไม่มีรายชื่อให้เทียบ
ผมทดสอบด้วยการเขียน os.Getenv("POSTGRES_DNS") (สลับ SN เป็น NS) ทั้งที่ตอนรันตั้ง POSTGRES_DSN ไว้จริง:

$ go build ./... ; echo "exit=$?"
exit=0
(ไม่มี output ใด ๆ เลย)

$ go vet ./... ; echo "exit=$?"
exit=0
(ไม่มี output ใด ๆ เลย)

เครื่องมือทั้งสองตัวเงียบสนิท แล้วตอนรันได้แบบนี้:

$ POSTGRES_DSN="postgres://user:pass@localhost:5432/mydb?sslmode=disable" go run .
dsn = ""
len(dsn) = 0
LookupEnv(POSTGRES_DSN) = "postgres://user:pass@localhost:5432/mydb?sslmode=disable", ok=true
LookupEnv(POSTGRES_DNS) = "", ok=false
-> โปรแกรมเดินต่อได้ ไม่ panic ไม่ error
exit=0

ค่าจริงอยู่ครบในตัวแปรที่สะกดถูก แต่โค้ดหยิบตัวที่สะกดผิดแล้วได้ "" แล้วเดินต่อเหมือนไม่มีอะไรเกิดขึ้น
สังเกตว่า LookupEnv ตอบ ok=false ให้แล้ว — ข้อมูลมีอยู่ แต่ถ้าโค้ดใช้ Getenv ก็ไม่มีใครเอาไปใช้

2 · แปลง type เองทุกที่

ทุกจุดที่ต้องการตัวเลขต้องเขียนสามบรรทัดเดิมซ้ำ: อ่าน → แปลง → จัดการ error
สิบ config = สามสิบบรรทัดที่หน้าตาเหมือนกันหมด และบรรทัดจัดการ error คือบรรทัดที่คนขี้เกียจเขียนที่สุด พอมี _ โผล่มาสักตัวเดียว คุณก็ได้ผลตามหัวข้อ 5 ทันที

3 · default กระจัดกระจาย

port := os.Getenv("PORT")
if port == "" { port = "8080" }        // ← อยู่ใน main.go

// อีกไฟล์หนึ่ง คนละคนเขียน
p := os.Getenv("PORT")
if p == "" { p = "3000" }             // ← default ไม่ตรงกัน แต่ไม่มีใครเห็น

ก้อน if x == "" { x = ... } กระจายอยู่ทั่วโปรเจกต์ · เวลาจะเปลี่ยน default ต้องไล่หาให้ครบทุกจุด และพลาดหนึ่งจุดก็ไม่มีอะไรฟ้อง

4 · ไม่มีที่ไหนบอกว่าแอปต้องการ config อะไรบ้าง

คำถามที่คนใหม่เข้าทีมถามวันแรกเสมอ: "ต้องตั้ง env อะไรบ้างถึงจะรันได้"
คำตอบที่ตรงที่สุดในโค้ดแบบนี้คือ grep -r "os.Getenv" . — ซึ่งบอกได้แค่ชื่อ ไม่บอกว่าตัวไหนบังคับ ตัวไหนมี default ตัวไหนต้องเป็นตัวเลข
เอกสารก็เชื่อไม่ได้ เพราะมันไม่ได้ผูกกับโค้ด — คนเพิ่ม env ใหม่แล้วลืมอัปเดต README เป็นเรื่องปกติ

5 · ระเบิดกลางทาง ไม่ใช่ตอน start

ข้อนี้แสบที่สุด ผมรันพิสูจน์กับ database/sql จริง — ลืมตั้ง DSN (DSN = ข้อความบรรทัดเดียวที่บอกว่าจะต่อฐานข้อมูลเครื่องไหน ด้วยชื่อผู้ใช้และรหัสอะไร) แล้วส่งค่าว่างเข้าไป:

=== A. DSN ว่าง (ลืมตั้ง env) | driver="postgres" dsn=""
  sql.Open err  = <nil>                    # เปิดผ่าน ไม่มี error
  Ping err      = dial tcp [::1]:5432: connect: connection refused
  Query err     = dial tcp [::1]:5432: connect: connection refused

sql.Open คืน <nil> — แอป start ผ่าน log ขึ้นสวยงามว่าเซิร์ฟเวอร์พร้อมแล้ว
สาเหตุคือ database/sql เป็นแบบ lazy: sql.Open แค่เช็คว่า รู้จักชื่อ driver ตัวนี้ไหม แล้วสร้าง connection pool เปล่า ๆ ไว้ (connection pool = แอ่งของสายที่ต่อค้างไว้ ให้หลาย request หยิบใช้สลับกัน แทนที่จะต่อใหม่ทุกครั้ง) ยังไม่ต่อจริง
ผมทดสอบเคสอื่นเทียบด้วย ยืนยันว่ามันไม่ตรวจ DSN เลยแม้แต่รูปแบบ:

=== B. DSN ขยะ | dsn="this-is-not-a-dsn"
  sql.Open err  = <nil>                    # ขยะชัด ๆ ก็ยังผ่าน
  Ping err      = missing "=" after "this-is-not-a-dsn" in connection info string"

=== D. driver ที่ไม่ได้ register | driver="mysqlx"
  sql.Open err  = sql: unknown driver "mysqlx" (forgotten import?)   # เคสเดียวที่ error

A. dsn=""                     -> Ping err = dial tcp [::1]:5432: connect: connection refused
C. dsn="postgres://u:p@127.0.0.1:59999/db?..."
                              -> Ping err = dial tcp 127.0.0.1:59999: connect: connection refused

7 · สิ่งที่อยากได้ — และจุดที่สไลด์หยุด

ห้าปัญหาข้างบนมีต้นเหตุร่วมข้อเดียว: เรากระจายความรู้เรื่อง config ไว้ทั่วโปรเจกต์ ทั้งชื่อ ทั้ง type ทั้ง default ทั้งกฎว่าอันไหนบังคับ
สิ่งที่อยากได้จริง ๆ คือประกาศครั้งเดียวว่าแอปนี้ต้องการอะไรบ้าง แล้วให้เครื่องมือจัดการที่เหลือ — อ่านให้ · แปลง type ให้ · เติม default ให้ · และถ้าขาดตัวไหนก็หยุดตั้งแต่ตอน start ไม่ใช่ไปพังตอนผู้ใช้ยิงเข้ามา

ทดสอบความเข้าใจ

ไม่ตั้ง PORT      -> Atoi("")      = 0,    err=strconv.Atoi: parsing "": invalid syntax
PORT=8080         -> Atoi("8080")  = 8080, err=<nil>
PORT="8080 "      -> Atoi("8080 ") = 0,    err=strconv.Atoi: parsing "8080 ": invalid syntax
PORT=999...999    -> Atoi(...)     = 9223372036854775807, err=...: value out of range

อ้างอิง

• pkg.go.dev — os.Getenv · os.LookupEnv — อ่านย่อหน้าเดียวของ LookupEnv: มันอธิบายตรง ๆ ว่าทำไมถึงต้องมีตัวที่คืน bool เพิ่ม
• pkg.go.dev — strconv.Atoi · ParseBool · NumError — ที่มาของ ErrSyntax / ErrRange และรายชื่อ 12 ค่าที่ ParseBool รับ
• pkg.go.dev — time.ParseDuration — อ่านรายการหน่วยที่รองรับ (ns, us — เขียน µs หรือ μs ก็ได้ · ms, s, m, h) และสังเกตว่าไม่มี d สำหรับวัน — อยากได้ 1 วันต้องเขียน 24h
• The Twelve-Factor App — III. Config — ต้นทางของแนวคิดทั้งบท พร้อมเกณฑ์ทดสอบ "เปิด repo เป็น public ตอนนี้ได้ไหม"
• pkg.go.dev — sql.Open — อ่านประโยคที่บอกว่ามันไม่เปิด connection จริง ซึ่งอธิบายผลรันในหัวข้อ 6 ทั้งหมด
• Docker — -e / --env-file — ท่า -e NAME แบบไม่ใส่ค่า และลำดับความแรงเมื่อชื่อชนกัน
• joho/godotenv · caarlos0/env · go-playground/validator — สามตัวที่หน้าปกสไลด์ระบุเป็นปลายทาง (บทนี้ยังไม่ได้ใช้)
• Cheat sheet Day 8 — ตารางกับดักรวมทั้งวัน