internal/config — ประกอบทุกอย่างเข้าด้วยกัน

go version go1.26.5 darwin/arm64

github.com/caarlos0/env/v11        v11.4.1
github.com/joho/godotenv           v1.5.1
github.com/go-playground/validator/v10  v10.30.3
gorm.io/gorm                       v1.31.2
gorm.io/driver/postgres            v1.6.2
postgres:16-alpine                 # ผ่าน colima (Docker 29.6.2)

1 · โครงโปรเจกต์ — โฟลเดอร์ใหม่ที่จะเพิ่ม

สไลด์วางโครงไว้แบบนี้ ส่วนที่เป็นของใหม่ในบทนี้คือ internal/config/ ทั้งโฟลเดอร์:

2 · ทำไมต้องเป็นโฟลเดอร์แยก — เหตุผล 4 ข้อ

คำถามที่ควรถามก่อนคือ "ทำไมไม่ประกาศ struct Config ไว้ใน main.go เลย มันก็ที่เดียวเหมือนกัน"
สไลด์ให้เหตุผลไว้สี่ข้อ และมีข้อหนึ่งที่ไม่ใช่เรื่องของวินัย แต่เป็นเรื่องที่ Go บังคับให้เอง:

ข้อ 2 — internal/ ไม่ใช่คำแนะนำ มันเป็นกฎของ compiler

คำว่า module ในที่นี้คือหน่วยที่มีไฟล์ go.mod หนึ่งไฟล์คุมอยู่ — โปรเจกต์ wongnok/api ของเราคือหนึ่ง module
กฎของ Go คือ: package ที่อยู่ใต้โฟลเดอร์ชื่อ internal จะ import ได้เฉพาะโค้ดที่อยู่ใต้โฟลเดอร์แม่ของ internal นั้น
ผมทดสอบสองทาง — จาก ใน module เดียวกัน กับจาก module อื่น ที่ replace ชี้มาที่โฟลเดอร์เดียวกันเป๊ะ:

===== A. import จากใน module เดียวกัน (cmd/api → internal/config) =====
inside module, import ok: wongnok
exit=0

===== B. import จาก module อื่น =====
package outsider
	main.go:6:2: use of internal package wongnok/api/internal/config not allowed
exit=1

3 · anti-pattern vs pattern — env ต้องอ่านที่ไหน

นี่คือหัวใจของทั้งบท และเป็นจุดที่คนพลาดกันมากที่สุดตอนเริ่มใช้ config struct: มี struct แล้ว แต่ยังแอบเรียก os.Getenv ลึก ๆ ข้างในอยู่ดี

func (h *Handler) Login(c *gin.Context) {
    secret := os.Getenv("JWT_SECRET")
    // ...
}

func NewHandler(svc Service, cfg config.Auth) *Handler {
    return &Handler{svc: svc, cfg: cfg}
}

ฟังดูเป็นเรื่องความสวยงามของโค้ด แต่มันไม่ใช่ ผมเขียนสองแบบให้ยิงจริงด้วย httptest โดยไม่ตั้ง JWT_SECRET เลย (env -u JWT_SECRET) แล้วดูว่าแต่ละแบบตอบอะไร:

JWT_SECRET ตอนนี้ = ""

=== แบบห้าม (os.Getenv ใน handler) ===
status : 200
body   : signed with secret="" (len=0)

=== แบบทำ (validate ตอน start ก่อนถึง handler) ===
แอปตายตั้งแต่ตอน start:
Key: 'Auth.JWTSecret' Error:Field validation for 'JWTSecret' failed on the 'required' tag

4 · config.go — ตัวประกอบ

ไฟล์นี้ไม่ประกาศ env สักตัว หน้าที่มันมีสองอย่างเท่านั้น: รวม section เข้าด้วยกัน กับ เป็นประตูเดียวที่คนนอกเรียกเข้ามา

// internal/config/config.go
package config

import (
	"errors"
	"fmt"

	"github.com/caarlos0/env/v11"
	"github.com/go-playground/validator/v10"
)

// ใช้ตัวเดียวทั้ง package — validator แคชข้อมูล struct ไว้ข้างใน
var validate = validator.New(validator.WithRequiredStructEnabled())

type Config struct {
	App      App
	Logging  Logging
	Database Database
}

func Load() (Config, error) {
	cfg, err := env.ParseAs[Config]()
	if err != nil {
		return Config{}, fmt.Errorf("parse environment: %w", err)
	}

	// ไม่ wrap ด้วย fmt.Errorf — errors.Join จัดบรรทัดไว้แล้ว
	if err := cfg.Validate(); err != nil {
		return Config{}, err
	}

	return cfg, nil
}

// รวม error ของ "ทุก section" มาแสดงทีเดียว
// เพิ่ม Redis? สร้าง redis.go + เติม 1 บรรทัดตรงนี้
func (cfg Config) Validate() error {
	return errors.Join(
		cfg.App.Validate(),
		cfg.Logging.Validate(),
		cfg.Database.Validate(),
	)
}

อ่านลำดับใน Load() ให้ชัด — มันคือสามบรรทัดที่สรุปทั้งสามบทที่แล้ว: ParseAs → Validate → คืนค่า
และมีรายละเอียดสองอย่างที่ดูเหมือนเรื่องสไตล์ แต่จริง ๆ มีเหตุผลที่วัดได้

รายละเอียดที่ 1 — ทำไม wrap อันบน แต่ไม่ wrap อันล่าง

fmt.Errorf("...: %w", err) คือการ ห่อ error เดิมไว้ข้างใน แล้วเติมข้อความนำหน้า เพื่อบอกว่ามันเกิดที่ไหน (%w คือช่องที่เก็บ error ตัวเดิมไว้ให้ errors.Is/errors.As ขุดกลับมาได้)
ส่วน errors.Join(a, b, c) คือการ มัด error หลายตัวเป็นก้อนเดียว โดยที่ตัวไหนเป็น nil มันข้ามให้ และถ้าเป็น nil หมดก็คืน nil
คำถามคือทำไมอันหนึ่ง wrap อีกอันไม่ wrap ทั้งที่มันดูเป็น error เหมือนกัน

joined := errors.Join(errA, errB)

fmt.Println(joined)                                    // A. คืนตรง ๆ
fmt.Println(fmt.Errorf("validate config: %w", joined))  // B. wrap ก่อน

===== A. คืน err ตรง ๆ (ไม่ wrap) =====
Key: 'App.Port' Error:Field validation for 'Port' failed on the 'lte' tag
Key: 'Logging.Level' Error:Field validation for 'Level' failed on the 'oneofci' tag

===== B. wrap ด้วย fmt.Errorf("validate config: %w") =====
validate config: Key: 'App.Port' Error:Field validation for 'Port' failed on the 'lte' tag
Key: 'Logging.Level' Error:Field validation for 'Level' failed on the 'oneofci' tag

รายละเอียดที่ 2 — Load() คืน Config ไม่ใช่ *Config

สังเกตว่าตอน error โค้ดเขียน return Config{}, err ไม่ใช่ return nil, err — เพราะมันคืนค่า (value) ไม่ใช่ตัวชี้ (pointer)
ผมรันเทียบสองเวอร์ชันให้ดูว่ามันต่างกันตรงไหนจริง ๆ:

sizeof(config.Config)  = 120 bytes
sizeof(*config.Config) = 8 bytes

[value ] err != nil? true | cfgVal.App.Port = 0 | cfgVal.App.Addr() = ":0"
[ptr   ] err != nil? true | cfgPtr == nil? true
[ptr   ] panic ตอนอ่าน cfgPtr.App.Port: runtime error: invalid memory address or nil pointer dereference

เวอร์ชัน value ตอน error คืน Config{} ที่ยังเรียกเมธอดต่อได้ — Addr() ตอบ ":0" ซึ่งอาจไม่มีประโยชน์ แต่มันไม่พัง
เวอร์ชัน pointer คืน nil ถ้าคนเรียกเผลอลืมเช็ค err ก็ panic ทันที
ราคาที่จ่ายคือ copy 120 byte แทน 8 byte ซึ่งเล็กมาก และ Load() ถูกเรียกครั้งเดียวตอน start

แต่เหตุผลที่หนักแน่นกว่านั้นคือข้อสอง — ใครแก้ config หลัง validate ผ่านไปแล้วได้บ้าง ผมเขียน handler สองตัว ตัวหนึ่งรับ value ตัวหนึ่งรับ pointer แล้วให้ทั้งคู่สั่ง cfg.App.Port = 1 เหมือนกัน:

ก่อนเรียก              : Port=8080 Addr=":8080"
หลัง handlerA(value)   : Port=8080 Addr=":8080"
หลัง handlerB(pointer) : Port=1 Addr=":1"  <-- validate ผ่านไปแล้ว แต่ค่าเปลี่ยนได้

5 · app.go — section แรก

ไฟล์แต่ละ section หน้าตาเหมือนกันหมดสามส่วน: struct + helper + Validate() ของตัวเอง

// internal/config/app.go
package config

import (
	"fmt"
	"time"
)

type App struct {
	Name            string        `env:"APP_NAME" envDefault:"wongnok" validate:"required"`
	Env             string        `env:"APP_ENV" envDefault:"development" validate:"required,oneof=development staging production"`
	Port            int           `env:"APP_PORT" envDefault:"8080" validate:"gte=1,lte=65535"`
	ShutdownTimeout time.Duration `env:"APP_SHUTDOWN_TIMEOUT" envDefault:"10s" validate:"required"`
}

func (app App) Addr() string       { return fmt.Sprintf(":%d", app.Port) }
func (app App) IsProduction() bool { return app.Env == "production" }

func (app App) Validate() error { return validate.Struct(app) }

ทุกเคสในคอลัมน์ขวาผมรันจริง และทุกเคส env.ParseAs ผ่านหมด — "99999" เป็น int ได้ · "prodction" เป็น string ได้ · "0s" เป็น time.Duration ได้
นี่คือการแบ่งงานที่ชัดเจนระหว่างสองไลบรารี: env ตอบว่า "แปลงเป็นชนิดนั้นได้ไหม" · validator ตอบว่า "ค่านั้นใช้ได้จริงไหม"

$ env APP_SHUTDOWN_TIMEOUT=-5s go run ./cmd/probe

$ env POSTGRES_DSN="postgres://u:p@localhost:5432/db" APP_SHUTDOWN_TIMEOUT=-5s go run ./cmd/probe
ParseAs  : OK -> App.Port=8080 App.Env="development" Log.Level="info" Shutdown=-5s DSN="postgres://u:p@localhost:5432/db"
Validate : OK

// validate:"required,gt=0"
-5s    -> Key: 'A.T' Error:Field validation for 'T' failed on the 'gt' tag
0s     -> Key: 'A.T' Error:Field validation for 'T' failed on the 'required' tag
500ms  -> <nil>
10s    -> <nil>

// tag: gte=1  (ไม่ใส่หน่วย)
gte=1 with 1ns  -> <nil>
gte=1 with 0    -> Key: 'A.T' Error:Field validation for 'T' failed on the 'gte' tag
gte=1 with 500ms -> <nil>

// tag: gte=1s,lte=30s  (ใส่หน่วย)
0s     -> Key: 'B.T' Error:Field validation for 'T' failed on the 'gte' tag
1s     -> <nil>
15s    -> <nil>
31s    -> Key: 'B.T' Error:Field validation for 'T' failed on the 'lte' tag

6 · logging.go — section ที่สั้นที่สุด

// internal/config/logging.go
package config

// ไฟล์นี้ไม่ต้อง import อะไรเลย — validate มาจาก config.go ที่อยู่ package เดียวกัน

type Logging struct {
	Level  string `env:"LOG_LEVEL" envDefault:"info" validate:"required,oneofci=debug info warn error"`
	Format string `env:"LOG_FORMAT" envDefault:"json" validate:"required,oneofci=json text"`
}

func (logging Logging) Validate() error { return validate.Struct(logging) }

ตัวใหม่ในนี้คือ oneofci — เหมือน oneof ทุกอย่าง ยกเว้นว่าไม่สนตัวพิมพ์ใหญ่เล็ก (ci = case-insensitive) ผมรันยืนยัน:

---- tag: oneofci=Dev Staging PROD ----
oneofci "dev"    -> <nil>
oneofci "DEV"    -> <nil>
oneofci "prod"   -> <nil>
oneofci "PrOd"   -> <nil>
oneofci "qa"     -> Key: 'C.Env' Error:Field validation for 'Env' failed on the 'oneofci' tag

เขียนรายการใน tag เป็นตัวพิมพ์อะไรก็ได้ ผู้ใช้จะพิมพ์มาแบบไหนก็ได้ ตราบใดที่ตัวสะกดตรง
เหมาะกับ log level มาก เพราะคนตั้งกันทั้ง debug, DEBUG, Debug ซึ่งทั้งสามอันหมายถึงสิ่งเดียวกันจริง ๆ

before Struct()
panic: Undefined validation function 'staging' on field 'Env'

goroutine 1 [running]:
github.com/go-playground/validator/v10.(*Validate).parseFieldTagsRecursive(...)
	.../cache.go:311 +0x9e4
github.com/go-playground/validator/v10.(*Validate).extractStructCache(...)
github.com/go-playground/validator/v10.(*Validate).Struct(...)
main.main()
exit status 2

7 · database.go — ที่ที่ struct tag ไปไม่ถึง

ถ้าอ่านสามไฟล์ที่แล้วแล้วสรุปว่า "ก็แค่แปะ tag ให้ครบ ก็ไม่ต้องเขียน if อีกเลย" — ไฟล์นี้คือไฟล์ที่มาบอกว่าไม่จริง

// internal/config/database.go — เวอร์ชันก่อน
package config

import (
	"errors"
	"time"
)

type Database struct {
	PostgresDSN     string        `env:"POSTGRES_DSN"`
	MaxOpenConns    int           `env:"DB_MAX_OPEN_CONNS" envDefault:"25"`
	MaxIdleConns    int           `env:"DB_MAX_IDLE_CONNS" envDefault:"25"`
	ConnMaxLifetime time.Duration `env:"DB_CONN_MAX_LIFETIME" envDefault:"5m"`
}

func (database Database) Validate() error {
	if database.PostgresDSN == "" {
		return errors.New("POSTGRES_DSN is required")
	}
	if database.MaxOpenConns < 1 || database.MaxOpenConns > 500 {
		return errors.New("DB_MAX_OPEN_CONNS must be between 1 and 500")
	}
	if database.ConnMaxLifetime <= 0 {
		return errors.New("DB_CONN_MAX_LIFETIME must be greater than 0")
	}
	return nil
}

// internal/config/database.go — เวอร์ชันหลัง
package config

import "time"

type Database struct {
	PostgresDSN     string        `env:"POSTGRES_DSN" validate:"required"`
	MaxOpenConns    int           `env:"DB_MAX_OPEN_CONNS" envDefault:"25" validate:"gte=1,lte=500"`
	MaxIdleConns    int           `env:"DB_MAX_IDLE_CONNS" envDefault:"25" validate:"gte=1,lte=500"`
	ConnMaxLifetime time.Duration `env:"DB_CONN_MAX_LIFETIME" envDefault:"5m" validate:"required"`
}

func (database Database) Validate() error {
	return validate.Struct(database)
}

$ env DB_CONN_MAX_LIFETIME=-5s go run ./cmd/probe

########## [ก่อน refactor]
ParseAs  : OK
Validate : FAILED ->
DB_CONN_MAX_LIFETIME must be greater than 0

########## [หลัง refactor]
ParseAs  : OK
Validate : OK          <-- ค่าติดลบหลุดไปแล้ว

แล้วความต่างอีกข้อที่ควรรู้: เวอร์ชัน if คืน error ทีละตัว (เจอ POSTGRES_DSN ว่างก็ return เลย ไม่ดูข้ออื่นต่อ) · ส่วน validate.Struct คืนครบทุก field พร้อมกัน ผมยืนยันด้วย struct ที่ผิด 5 field รวดเดียว:

=== err.Error() ===
Key: 'App.Name' Error:Field validation for 'Name' failed on the 'required' tag
Key: 'App.Port' Error:Field validation for 'Port' failed on the 'lte' tag
Key: 'App.Env' Error:Field validation for 'Env' failed on the 'oneof' tag
Key: 'App.Host' Error:Field validation for 'Host' failed on the 'hostname|ip' tag
Key: 'App.Timeout' Error:Field validation for 'Timeout' failed on the 'gte' tag
=== count ===
len: 5

ครบทั้งห้าจริง ๆ — และสังเกตว่าแต่ละบรรทัดถูกคั่นด้วย \n มาให้แล้ว ตั้งแต่ก่อนถึงมือ errors.Join (validator มี ValidationErrors.Error() ที่ทำเอง)

สิ่งที่ struct tag เขียนไม่ได้ — และเหตุผลที่ Validate() ต้องเป็น method

สไลด์หน้า database.go ยกตัวอย่างกฎที่ไม่มี tag ไหนเขียนได้: DSN สองอันนี้ต่างกันแค่ท้ายสุด แต่ผลลัพธ์คนละเรื่อง

tag url ที่ validator มีให้ ตรวจแค่ว่า "รูปร่างเป็น URL ไหม" — ทั้งสองบรรทัดผ่านหมด
กฎ "ต้องมีชื่อ database ต่อท้าย host" จึงต้องเขียนเอง และนี่คือคำตอบว่า ทำไม Validate() ถึงต้องเป็น method ของ struct ไม่ใช่ปล่อยให้ validator ทำคนเดียว:

// เมธอดนี้เอาไปแทน Validate() เดิมในไฟล์ internal/config/database.go
// แทนแล้วต้องเติม import ให้ครบเป็น: "errors" · "fmt" · "net/url" · "strings" · "time"
func (database Database) Validate() error {
	// ชั้นที่ 1 — กฎมาตรฐาน ให้ validator ทำ
	if err := validate.Struct(database); err != nil {
		return err
	}

	// ชั้นที่ 2 — กฎเฉพาะทางที่ tag เขียนไม่ได้ เขียนเองตรงนี้
	u, err := url.Parse(database.PostgresDSN)
	if err != nil {
		return fmt.Errorf("POSTGRES_DSN: %w", err)
	}
	if strings.Trim(u.Path, "/") == "" {
		return errors.New("POSTGRES_DSN: ไม่มีชื่อ database ต่อท้าย host")
	}

	return nil
}

8 · Error หน้าตาเป็นยังไง

ทีนี้มาดูของจริง — ผมตั้ง env ให้ผิด สามที่พร้อมกัน คนละ section แล้วรัน ./cmd/api:

$ env APP_PORT=99999 LOG_LEVEL=BANANA POSTGRES_DSN= go run ./cmd/api

=== raw error ===
Key: 'App.Port' Error:Field validation for 'Port' failed on the 'lte' tag
Key: 'Logging.Level' Error:Field validation for 'Level' failed on the 'oneofci' tag
Key: 'Database.PostgresDSN' Error:Field validation for 'PostgresDSN' failed on the 'required' tag

time=... level=ERROR msg="load configuration"
invalid configuration:
  - App.Port: ผิดกฎ "lte"
  - Logging.Level: ผิดกฎ "oneofci"
  - Database.PostgresDSN: ผิดกฎ "required"
time=... level=ERROR msg=fatal error="load configuration: Key: 'App.Port' ..."
exit status 1

ตัว Humanize() ที่ผมใช้เขียนสั้น ๆ แบบนี้ (อยู่ในไฟล์ humanize.go) — มันคือการแกะกล่องสองชั้น: ชั้นนอกคือก้อนที่ errors.Join มัดไว้ ชั้นในคือ ValidationErrors ของแต่ละ section

// internal/config/humanize.go
package config

import (
	"errors"
	"fmt"
	"strings"

	"github.com/go-playground/validator/v10"
)

func Humanize(err error) string {
	if err == nil {
		return ""
	}
	var lines []string

	// ชั้นนอก: errors.Join คืน error ที่มีเมธอด Unwrap() []error
	var joined interface{ Unwrap() []error }
	errs := []error{err}
	if errors.As(err, &joined) {
		errs = joined.Unwrap()
	}

	for _, e := range errs {
		// ชั้นใน: แต่ละ section คืน validator.ValidationErrors
		var ve validator.ValidationErrors
		if errors.As(e, &ve) {
			for _, fe := range ve {
				lines = append(lines, fmt.Sprintf("  - %s: ผิดกฎ %q", fe.Namespace(), fe.Tag()))
			}
			continue
		}
		lines = append(lines, "  - "+e.Error())
	}

	return "invalid configuration:\n" + strings.Join(lines, "\n")
}

errors.As(err, &ve) คือ "ขุดลงไปในกล่อง error ดูว่ามีตัวที่เป็นชนิดนี้ไหม ถ้ามีเอามาใส่ ve" — ผมยืนยันว่ามันขุดทะลุ errors.Join ลงไปเจอ ValidationErrors ครบทุกตัวจริง:

errors.As -> true len: 4
errors.As through Join -> true 4

และแต่ละ FieldError ที่ได้มามีข้อมูลมากกว่าที่เราใช้ (ก้อนนี้ผมพิมพ์ช่อง Value ด้วย %#v — จำไว้ก่อน เดี๋ยวมันจะสำคัญ):

Namespace="Cfg.Name"      Field="Name"    Tag="required" Param=""         Kind=string Type=string        Value=""
Namespace="Cfg.Env"       Field="Env"     Tag="oneof"    Param="dev prod" Kind=string Type=string        Value="qa"
Namespace="Cfg.Timeout"   Field="Timeout" Tag="gte"      Param="1s"       Kind=int64  Type=time.Duration Value=100000000
Namespace="Cfg.DB.Port"   Field="Port"    Tag="lte"      Param="65535"    Kind=int    Type=int           Value=99999

สองอย่างที่น่าสังเกต:
· Namespace ของ field ที่ซ้อนอยู่ใน struct ลูกเป็น "Cfg.DB.Port" — validator ไล่ลงไปใน nested struct ให้เอง โดยไม่ต้องแปะ tag อะไรที่ field DB เลย
· Param() คืนพารามิเตอร์ของกฎเป็นสตริง เช่น "dev prod" หรือ "65535" — เอาไปเขียนข้อความว่า "ต้องเป็นหนึ่งใน dev prod" ได้เลย

time=... level=ERROR msg="load configuration"
invalid configuration:
  - parse error on field "Port" of type "int": strconv.ParseInt: parsing "abc": invalid syntax

9 · main.go — เอาไปใช้จริง

main() ทำอย่างเดียว: เรียก run() แล้วแปลง error เป็น exit code
ส่วนงานจริงทั้งหมดอยู่ใน run() ซึ่งเป็นลำดับ 5 ขั้นที่ห้ามสลับ:

// cmd/api/main.go
package main

import (
	"fmt"
	"log/slog"
	"net/http"
	"os"
	"strings"

	"github.com/joho/godotenv"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"

	"wongnok/api/internal/config"
)

func main() {
	if err := run(); err != nil {
		slog.Error("fatal", "error", err)
		os.Exit(1)
	}
}

func run() error {
	// 1) logger ชั่วคราว — ยังไม่รู้ level/format เพราะยังไม่ได้อ่าน config
	bootLogger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
		Level: slog.LevelInfo,
	}))
	slog.SetDefault(bootLogger)

	_ = godotenv.Load() // 2) .env → environment (ไม่มีไฟล์ก็ไม่เป็นไร)

	// 3) โหลด config — พังตรงนี้ = ตายตรงนี้ ไม่ต้องรอ request แรก
	cfg, err := config.Load()
	if err != nil {
		bootLogger.Error("load configuration")
		fmt.Fprintf(os.Stderr, "%s\n", config.Humanize(err))
		return fmt.Errorf("load configuration: %w", err)
	}

	// 4) logger ตัวจริง — สร้างจาก config ที่ผ่าน validate แล้ว
	logger := newLogger(cfg.Logging)
	slog.SetDefault(logger)
	logger.Info("configuration loaded",
		"app", cfg.App.Name, "env", cfg.App.Env, "addr", cfg.App.Addr())

	// 5) จากตรงนี้ไป มั่นใจได้ว่า cfg ทุกค่าใช้งานได้จริง
	db, err := gorm.Open(postgres.Open(cfg.Database.PostgresDSN), &gorm.Config{})
	if err != nil {
		return fmt.Errorf("open database: %w", err)
	}
	_ = db // ... SetMaxOpenConns / SetMaxIdleConns / SetConnMaxLifetime / Ping ...

	mux := http.NewServeMux()
	// ... ผูก handler เข้า mux ตามบทที่ผ่านมา ...
	return http.ListenAndServe(cfg.App.Addr(), mux)
}

// ขั้นที่ 4 ของ run() อยู่ในฟังก์ชันนี้ — หัวข้อถัดไปจะยกมาอธิบายทีละบรรทัด
func newLogger(cfg config.Logging) *slog.Logger {
	var level slog.Level
	if err := level.UnmarshalText([]byte(cfg.Level)); err != nil {
		level = slog.LevelInfo // validate ผ่านมาแล้ว ปกติไม่มีทางเข้าบรรทัดนี้
	}
	opts := &slog.HandlerOptions{Level: level}

	if strings.EqualFold(cfg.Format, "text") {
		return slog.New(slog.NewTextHandler(os.Stderr, opts))
	}
	return slog.New(slog.NewJSONHandler(os.Stderr, opts))
}

โค้ดก้อนนี้ก๊อปไปวางเป็นไฟล์แล้ว go build ผ่านจริง — บรรทัด _ = db มีไว้เพราะ Go ไม่ยอมให้ประกาศตัวแปรแล้วไม่ใช้ (ตัวแปรที่ประกาศแล้วทิ้งไว้เฉย ๆ คือ compile error ไม่ใช่แค่คำเตือน)
พอคุณเขียนบรรทัด SetMaxOpenConns / Ping ที่ตามมาจริง ๆ db ก็ถูกใช้งานแล้ว ให้ลบ _ = db ทิ้งไปได้เลย

ทำไมต้องมี logger สองตัว — ปัญหาไก่กับไข่

ขั้นที่ 1 ดูเหมือนเปลืองโค้ดโดยใช่เหตุ ทำไมไม่สร้าง logger ตัวเดียวให้จบ?
เพราะ logger ตัวจริงต้องรู้ LOG_LEVEL กับ LOG_FORMAT ซึ่งอยู่ใน config
แต่ขั้นตอนโหลด config เองก็ต้องการที่ log ตอนมันพัง
ไก่กับไข่พอดี — และทางออกคือยอมมี logger ธรรมดา ๆ ตัวหนึ่งไว้ก่อน (TextHandler · level Info · ไม่ต้องอ่าน config อะไรเลย) แล้วค่อยเปลี่ยนเป็นตัวจริงหลังโหลดสำเร็จ

newLogger() — จุดที่ LOG_LEVEL กับ LOG_FORMAT ได้ใช้งานจริง

หัวข้อ 6 เราตั้งกฎให้ Logging ไว้แล้ว แต่ยังไม่เคยเห็นว่ามันถูกใช้ตรงไหน — คำตอบอยู่ที่ฟังก์ชันสั้น ๆ ที่ต่อท้ายไฟล์ main.go เมื่อกี้ ขอยกมาดูใกล้ ๆ อีกที เพราะมันคือขั้นที่ 4 ของ run() ทั้งหมด:

func newLogger(cfg config.Logging) *slog.Logger {
	var level slog.Level
	if err := level.UnmarshalText([]byte(cfg.Level)); err != nil {
		level = slog.LevelInfo // validate ผ่านมาแล้ว ปกติไม่มีทางเข้าบรรทัดนี้
	}
	opts := &slog.HandlerOptions{Level: level}

	if strings.EqualFold(cfg.Format, "text") {
		return slog.New(slog.NewTextHandler(os.Stderr, opts))
	}
	return slog.New(slog.NewJSONHandler(os.Stderr, opts))
}

ผมรันด้วย Logging สามชุดเทียบกัน (แต่ละชุดสั่ง Debug · Info · Warn อย่างละบรรทัด):

--- level=info format=json ---
{"time":"...","level":"INFO","msg":"configuration loaded","app":"wongnok","addr":":8080"}
{"time":"...","level":"WARN","msg":"warn line"}

--- level=DEBUG format=text ---
time=... level=DEBUG msg="debug line"
time=... level=INFO msg="configuration loaded" app=wongnok addr=:8080
time=... level=WARN msg="warn line"

--- level=warn format=JSON ---
{"time":"...","level":"WARN","msg":"warn line"}

สามอย่างที่กล่องนี้ยืนยัน:
· ชุดแรก ไม่มีบรรทัด DEBUG — LOG_LEVEL=info กรองทิ้งจริง
· ชุดที่สาม LOG_LEVEL=warn เหลือบรรทัดเดียว
· "DEBUG" กับ "JSON" ตัวใหญ่ก็ใช้ได้ เพราะ UnmarshalText กับ strings.EqualFold ไม่สนตัวพิมพ์ — เข้าคู่กับ tag oneofci ที่เราตั้งไว้ในหัวข้อ 6 พอดี
(สาม package ที่ฟังก์ชันนี้ใช้ — log/slog · os · strings — อยู่ใน import ของ main.go ข้างบนครบแล้ว ไม่ต้องเติมอะไรอีก)

พิสูจน์ว่า "ตายตั้งแต่ start" จริงไหม

ประโยคว่า "config ผิดแล้วแอปตายตั้งแต่ start" ฟังบ่อยจนกลายเป็นคำขวัญ ผมเลยรันแล้ววัดสามชั้นให้เห็นกับตา — สั่ง config ผิดสามที่เหมือนเดิม แล้วเช็คว่า process ยังอยู่ไหม · มีใคร bind พอร์ต 8080 ไหม · curl ต่อติดไหม:

--- ps เช็คว่า process ยังอยู่ไหม ---
process ตายไปแล้ว

--- lsof :8080 ---
(ไม่มี process ไหน listen :8080)

--- curl /healthz ---
http_code=000
curl exit=7

EXIT_CODE=1

curl exit=7 คือ Failed to connect — ไม่ใช่ 404 ไม่ใช่ 500 แต่คือไม่มีอะไรอยู่ปลายสายให้ต่อเลย
นี่คือสิ่งที่เราต้องการจริง ๆ: ไม่มีหน้าต่างเวลาแม้แต่วินาทีเดียวที่แอปเปิดรับ request ทั้งที่ config ยังผิดอยู่

ทีนี้ตั้ง config ให้ถูกแล้วรันใหม่ (มี Postgres รออยู่จริง) — ได้ลำดับตามที่ออกแบบไว้เป๊ะ:

--- curl /healthz ---
ok
http_code=200

--- stderr ของ server ---
{"time":"2026-08-22T10:13:43.048067+07:00","level":"INFO","msg":"configuration loaded","app":"wongnok","env":"development","addr":":8080"}
{"time":"2026-08-22T10:13:43.084594+07:00","level":"INFO","msg":"database connected"}
{"time":"2026-08-22T10:13:43.085393+07:00","level":"INFO","msg":"server starting","addr":":8080"}

สังเกตว่า log ออกมาเป็น JSON แล้ว — เพราะบรรทัดพวกนี้พิมพ์หลังขั้นที่ 4 logger ตัวจริงจึงถูกสร้างจาก cfg.Logging ที่มี LOG_FORMAT=json เป็น default

10 · config_test.go — เทสต์ config ที่ไม่ต้องมีไฟล์ .env

t.Setenv(key, value) คือของที่ทำให้เทสต์ config ง่ายขึ้นมาก — มันตั้ง env ให้เฉพาะระหว่างเทสต์นั้น แล้วคืนค่าเดิมให้อัตโนมัติเมื่อเทสต์จบ ไม่ต้องเขียน cleanup เอง และไม่ต้องมีไฟล์ .env ในเครื่อง CI

// internal/config/config_test.go
package config_test

import (
	"strings"
	"testing"

	"wongnok/api/internal/config"
)

func TestLoad_ThreeErrorsAtOnce(t *testing.T) {
	t.Setenv("APP_PORT", "99999")
	t.Setenv("LOG_LEVEL", "BANANA")
	t.Setenv("POSTGRES_DSN", "")

	_, err := config.Load()
	if err == nil {
		t.Fatal("Load() error = nil, want error")
	}

	got := config.Humanize(err)
	for _, want := range []string{
		`App.Port: ผิดกฎ "lte"`,
		`Logging.Level: ผิดกฎ "oneofci"`,
		`Database.PostgresDSN: ผิดกฎ "required"`,
	} {
		if !strings.Contains(got, want) {
			t.Errorf("Humanize() ไม่มี %q\nได้:\n%s", want, got)
		}
	}
}

func TestLoad_ReturnsZeroValueOnError(t *testing.T) {
	t.Setenv("POSTGRES_DSN", "")

	cfg, err := config.Load()
	if err == nil {
		t.Fatal("want error")
	}
	// value ไม่ใช่ pointer -> เรียกเมธอดต่อได้เลย ไม่ panic
	if cfg.App.Addr() != ":0" {
		t.Errorf("Addr() = %q, want %q", cfg.App.Addr(), ":0")
	}
}

ในไฟล์จริงผมมีอีกตัวหนึ่งชื่อ TestLoad_Defaults (เช็คว่า envDefault ทำงานจริง) ซึ่งไม่ได้ยกมาโชว์ตรงนี้ — ตอนรันจึงเห็นสามตัว:

$ go test ./internal/config/ -v
=== RUN   TestLoad_Defaults
--- PASS: TestLoad_Defaults (0.00s)
=== RUN   TestLoad_ThreeErrorsAtOnce
--- PASS: TestLoad_ThreeErrorsAtOnce (0.00s)
=== RUN   TestLoad_ReturnsZeroValueOnError
--- PASS: TestLoad_ReturnsZeroValueOnError (0.00s)
PASS
ok  	wongnok/api/internal/config	0.572s

เทสต์ตัวที่สามคือตัวที่พิสูจน์เหตุผลข้อ "คืน value ไม่ใช่ pointer" จากหัวข้อ 4 — เรียก cfg.App.Addr() ได้ทั้งที่ Load() เพิ่งคืน error มา ถ้าเปลี่ยนเป็น *Config เมื่อไหร่ บรรทัดนี้จะ panic ทันที

cpu: Apple M4
BenchmarkSingleton-10      	 7712509	     145.9 ns/op	     48 B/op	  1 allocs/op
BenchmarkNewEachTime-10    	  124420	    9609 ns/op	  16617 B/op	232 allocs/op

plain  / zero nested struct  -> <nil>              // tag ถูกเมิน
opt    / zero nested struct  -> Key: 'Cfg.DB' Error:Field validation for 'DB' failed on the 'required' tag

--- pointer nested (*DB), nil ---
plain -> Key: 'Cfg2.DB' Error:... failed on the 'required' tag
opt   -> Key: 'Cfg2.DB' Error:... failed on the 'required' tag   // เท่ากันทั้งคู่

11 · Mental Model — ท่อลำเลียงค่า

ก่อนจะปิดบท ลองถอยออกมามองภาพรวม สิ่งที่เราสร้างมาทั้งสี่บทคือท่อลำเลียงค่าหนึ่งท่อ ที่ค่าไหลจากไฟล์บนดิสก์ ไปจนถึงตัวแปรที่โค้ดใช้จริง:

ถ้ายังนึกภาพไม่ออก สไลด์เทียบกับงานเอกสารที่เคาน์เตอร์ ซึ่งเข้าใจง่ายกว่ามาก:

12 · แบบฝึกหัด — จับคู่

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

APP_PORT=99999
  ParseAs  : OK  -> App.Port=99999
  Validate : FAILED -> Key: 'App.Port' Error:Field validation for 'Port' failed on the 'lte' tag

APP_PORT=abc
  ParseAs  : FAILED -> env: parse error on field "Port" of type "int": strconv.ParseInt: parsing "abc": invalid syntax

APP_ENV=prodction
  ParseAs  : OK  -> App.Env="prodction"
  Validate : FAILED -> Key: 'App.Env' Error:Field validation for 'Env' failed on the 'oneof' tag

APP_SHUTDOWN_TIMEOUT=0s
  ParseAs  : OK  -> Shutdown=0s
  Validate : FAILED -> Key: 'App.ShutdownTimeout' Error:Field validation for 'ShutdownTimeout' failed on the 'required' tag

อ้างอิง

• Go 1.4 Release Notes — Internal packages · cmd/go — Internal Directories — อ่านสองย่อหน้าสั้น ๆ นี้ จะเห็นกฎเป๊ะ ๆ ว่า "ใต้ internal import ได้จากใต้โฟลเดอร์แม่ของมันเท่านั้น" ซึ่งเป็นที่มาของ error use of internal package ... not allowed
• pkg.go.dev — errors.Join — อ่านประโยคเดียวที่บอกว่าคั่นด้วย newline และประโยคที่บอกว่าข้าม nil ให้ · ที่มาของ Unwrap() []error ที่ Humanize() ใช้แกะกล่อง
• pkg.go.dev — errors.As · fmt.Errorf — ความต่างของ "ห่อ error หนึ่งตัว" กับ "มัดหลายตัว" และเหตุผลที่ %w ทำให้ขุดกลับมาได้
• validator/v10 — Validate.Struct · FieldError — รายชื่อ method ทั้งหมดของ FieldError · สังเกตว่า Value() คืน interface{} — พิมพ์ด้วย %v ยังได้ 100ms ตามปกติ แต่ถ้าจะเอาไปคำนวณต่อต้อง type-assert กลับเป็น time.Duration ก่อน
• validator/v10 — WithRequiredStructEnabled — doc comment บรรทัดเดียวที่บอกครบ: "enables required tag on non-pointer structs" ซึ่งตรงกับผลรันในหัวข้อ 10 พอดี
• caarlos0/env v11 — รายการ tag ทั้งหมด (env · envDefault · envSeparator · required) และชนิดข้อมูลที่แปลงให้ได้เอง
• pkg.go.dev — t.Setenv — อ่านย่อหน้าที่บอกว่าใช้กับ t.Parallel() ไม่ได้ ซึ่งเป็นข้อจำกัดที่เจอตอนเทสต์เริ่มเยอะ
• The Twelve-Factor App — III. Config — ต้นทางของแนวคิดทั้งสี่บท และเกณฑ์ทดสอบ "เปิด repo เป็น public ตอนนี้ได้ไหม"
• บทเรียน 44 — Configuration & Environment Variables — จุดที่เรื่องนี้เริ่ม: ห้าปัญหาของ os.Getenv ที่ทั้งสี่บทนี้เกิดมาเพื่อแก้