DEV Community: Nattrio

มือใหม่หัด Go: Docker Multi-stage Builds

Nattrio — Mon, 29 May 2023 14:29:21 +0000

สวัสดีชาว Gopher ทุกท่าน ในปัจจุบันการใช้ Container สำหรับพัฒนาแอปอย่าง Docker เป็นที่นิยมอย่างมาก เนื่องจากช่วยในการจัดการ environment และ library ให้เหมือนกันได้ไม่ว่าจะอยู่ที่ไหนก็ตาม

อย่างไรก็ดี ปัญหาการ "บวม" (Docker image bloating) หรือก็คือ image มีขนาดใหญ่เกินความจำเป็นนั้น สามารถเกิดขึ้นได้ถ้าไม่จัดการให้ดี ทางออกอื่นๆ ที่ช่วยได้ เช่น

ใช้ dockerignore เพื่อไม่ให้เพิ่มไฟล์ที่ไม่ต้องการ
เลือกใช้ distroless/minimal base image เพื่อลดขนาดให้ได้มากที่สุด

ต้องเข้าใจว่าส่วนที่ใช้ทำในตอน build แอปพลิเคชันนั้น พอเสร็จแล้วมักจะไม่ถูกนำมาใช้ต่อตอนที่แอปกำลังรัน ถ้าเรานำทั้งหมดมาใช้ก็จะทำให้บวมได้ ในบทความนี้จะนำเสนออีกวิธีที่จะแยกส่วนที่เป็น build tool ออก ให้เหลือเฉพาะส่วนที่จำเป็นต่อการรันแอปนั่นเอง เรียกว่า Multi-stage builds

Docker : Multi-Stage Builds

Multi-stage builds จะช่วยลดขนาดของ container ให้เล็กลงได้ ด้วยการแตกขั้นตอนออกเป็นหลายๆ stage ย่อย แต่ละ stage จะส่งผลลัพธ์ต่อไปยัง stage ถัดไป

Demo

เราสามารถใช้แอปนี้ GitHub เป็นตัวอย่างเบื้องต้นในทดสอบ

ในการเปรียบเทียบเพื่อให้เห็นภาพชัด จะทดสอบการ build ทั้งสองรูปแบบ

ใช้ Dockerfile ในการ build แบบปกติ

FROM golang:1.18-alpine

WORKDIR /crud

COPY . .

RUN go mod download

EXPOSE 2565

RUN  go build -o /test main.go

CMD [ "/test" ]

ใช้ Dockerfile ในการทำ Multi-Stage build ซึ่งจะแบ่งเป็น 2 environment ที่แตกต่างกัน

# Build stage

FROM golang:1.18-alpine AS builder

WORKDIR /crud

COPY . .

RUN go mod download

EXPOSE 2565

RUN  go build -o /test main.go

# Deploy stage

FROM alpine:latest

WORKDIR /

COPY --from=builder /test /test

EXPOSE 2565

USER nonroot:nonroot

ENTRYPOINT [ "/test" ]

เมื่อ build เรียบร้อยทั้งสองรูปแบบ มาดูผลลัพธ์กันดีกว่า

จะเห็นว่าการใช้ Multi-stage builds ช่วยลดขนาดให้ image ของเราอย่างมหาศาลเทียบกับแบบปกติ จาก 430 MB เป็น 16 MB พอเล็กแล้วก็สามารถนำไปใช้ต่อได้ง่ายมากขึ้นนั่นเอง

หวังว่าบทความนี้จะเป็นประโยชน์กับ Gopher และผู้ใช้ Docker ทุกคนกันนะครับ

Reference:
Optimizing Golang Docker images with multi-stage build | by Krishnadutt Panchagnula

Clean Architecture ฉบับเริ่มต้น

Nattrio — Tue, 23 May 2023 10:40:55 +0000

เชื่อว่าในการพัฒนาซอฟต์แวร์นั้น ความเข้าใจในเรื่องสถาปัตยกรรม (Software Architecture) มีความสำคัญอย่างยิ่ง เพราะนอกจากจะช่วยออกแบบระบบได้ดียิ่งขึ้น ยังเป็นการเปิดมุมมองต่อแนวคิดเบื้องหลังของสถาปัตยกรรมเหล่านี้อีกด้วย เพื่อให้นำมาปรับใช้ได้เหมาะสมกับงาน

ในบทความนี้จะพามารู้จักกับ Clean Architecture ซึ่งเป็นการอ้างอิงจากบทความของ Robert C. Martin แม้ว่าบทความนั้นจะมีอายุมากกว่า 10 แล้ว แต่แนวคิดก็ยังนับว่าน่าสนใจไม่น้อยเลยทีเดียว

รู้จัก Clean Architecture

สถาปัตยกรรมนี้ให้ความสำคัญกับ Separation of Concern คือมีการแบ่ง layer การทำงานของซอฟต์แวร์เป็นชั้นๆ ซึ่งในแต่ละชั้น layer จะทำงานในขอบเขตของตัวเองไม่ปะปนกัน

ในแผนภาพสะท้อนหลักการ The Dependency Rule โดยวงกลมด้านนอกจะเกี่ยวข้องกับการติดต่อประสานเครื่องไม้เครื่องมือต่างๆ สามารถปรับเปลี่ยนได้ตลอด ส่วนวงกลมด้านในจะเป็นการกำหนดนโยบายซึ่งเกี่ยวข้องกับ business โดยตรง จึงไม่ได้ปรับเปลี่ยนบ่อย

นอกจากนี้ยังกล่าวว่า source code dependencies can only point inwards คือวงภายในจะต้องไม่รับรู้และไม่พึ่งพาอาศัยโค้ดจากวงภายนอก แต่วงนอกพึ่งพาอาศัยวงภายในตามลูกศร depend on

เดี๋ยวเรามาลงรายละเอียดในแต่ละวงกัน เริ่มจากด้านนอกเข้าไปด้านใน

Frameworks and Drivers

เป็นส่วนที่จัดการกับ Framework และติดต่อกับเครื่องมือภายนอกอื่นๆ ด้วย driver ซึ่งอาจไม่ได้เขียนโค้ดมาก แต่จะเป็นการลงรายละเอียดที่จำเพาะ (specific) เช่น ติดต่อกับ database ตัวไหน หรือจะใช้ Web Framework อะไร เป็นต้น

Interface Adapters

ใช้ในการแปลงข้อมูล (convert data) ให้อยู่ใน format ที่เหมาะสม ให้วงในและนอกสื่อสารกันได้ แบ่งได้เป็นหมวดหลักๆ ดังนี้

Presenters: ใช้จัดการ UI logic หรือ states แปลงให้แสดงผลได้เหมาะสม
Controllers: ใช้จัดการ input/output จากระบบภายนอก เช่น UI, external services โดยรับ request มา validate/process ตาม business logic
Gateways: อาจเรียกว่า repository หรือ data access layer ใช้จัดการ communication จาก data source เพื่อทำ data access operation

Application Business Rules

เป็นการกำหนด rule ที่จำเป็น (แต่ยังไม่ใช่ core-business-rule) ใน layer นี้มี Use Case ใช้บอกว่า application มี function ใช้ทำอะไรได้บ้าง นอกจากนี้ใช้กำหนดว่าควรเรียก Controller/Gateway มาใช้ในแต่ละ use case

Enterprise Business Rules

ส่วนนี้จะกำหนด core-business-rule เช่น model/entity ที่ใช้เก็บ data structure ซึ่งมีการเปลี่ยนแปลงน้อย และไม่ได้รับผลกระทบจากการเปลี่ยนแปลงของภายนอกมาก

หวังว่าบทความ Clean Architecture นี้จะเป็นประโยชน์กับผู้ที่เริ่มต้นศึกษา และสามารถอ่านรายละเอียดที่น่าสนใจที่ด้านล่างนี้ได้เลย

References:

มือใหม่หัด Go: Factory Pattern

Nattrio — Tue, 16 May 2023 07:06:58 +0000

Factory Pattern เป็น creational design pattern แบบหนึ่ง โดยทั่วไปแล้วเป็นรูปแบบที่ใช้กันอย่างแพร่หลายใน Object Oriented Programming แม้ภาษา Go จะไม่ได้มี OOP feature มากมายขนาดนั้น แต่เราสามารถนำมาปรับใช้ในแบบ Simple Factory ได้

บทความนี้ จะพามาสร้างโรงงานอาวุธสไตล์เกม RPG โดยใช้แนวคิด Simple Factory มาเขียนโค้ดกัน

Product interface

ขั้นตอนแรกให้สร้าง IWeapon เป็น interface ที่ระบุว่าอาวุธของเราควรจะมี method อะไรบ้าง

type IWeapon interface {
    setName(name string)
    setPower(power int)
    getName() string
    getPower() int
    attack()
}

Concrete product

สร้าง Weapon เป็น struct ที่ implement IWeapon

type Weapon struct {
    name  string
    power int
}

func (w *Weapon) setName(name string) {
    w.name = name
}

func (w *Weapon) setPower(power int) {
    w.power = power
}

func (w *Weapon) getName() string {
    return w.name
}

func (w *Weapon) getPower() int {
    return w.power
}

func (w *Weapon) attack() {
}

สร้าง concrete Sword และ Bow ที่ struct ที่ทำการ embed Weapon struct ซึ่งจะเป็นการ implement method ทั้งหมดของ IWeapon แบบ indirect อีกทอดหนึ่ง

type Sword struct {
    Weapon
}

func (s *Sword) attack() {
    fmt.Printf("%s Slash! %d\n", s.getName(), s.getPower())
}

type Bow struct {
    Weapon
}

func (b *Bow) attack() {
    fmt.Printf("%s Shot! %d\n", b.getName(), b.getPower())
}

Factory

สร้าง WeaponFactory เป็น struct ที่มี method createWeapon() รับค่า string เพื่อสร้าง Weapon ประเภทต่างๆ ในที่นี่จะมีการตั้งชื่อ

type WeaponFactory struct {
}

func (wf *WeaponFactory) createWeapon(weaponType string) IWeapon {
    switch weaponType {
    case "Sword":
        return &Sword{Weapon{"Sword", 100}}
    case "Bow":
        return &Bow{Weapon{"Bow", 50}}
    default:
        return nil
    }
}

สังเกตการคืนค่าเป็น &Sword{Weapon{}} และ &Bow{Weapon{}} การใช้ & เพราะว่า Sword และ Bow types นั้น embed Weapon struct โดยตัว factory method เองต้อง return เป็น pointer (memory address) ซึ่งใช้ในการสร้าง instance ออกมา อีกทั้งเป็นการจัดการ memory ที่มีประสิทธิภาพโดยลดการ copy struct อย่างไม่จำเป็น

Client code

ได้เวลาสร้างอาวุธจริงๆ ขึ้นมาแล้ว โดยเราจะสร้าง Sword และ Bow อย่างละชิ้น ซึ่งต้องทำผ่าน weaponFactory.createWeapon() อาวุธที่ได้ออกมาสามารถตั้งชื่อใหม่ เปลี่ยนค่าพลังได้ และนำไปใช้ Attack() ได้ด้วย

func main() {
    weaponFactory := WeaponFactory{}

    Excailbur := weaponFactory.createWeapon("Sword")
    Excailbur.SetName("Excalibur")
    Excailbur.SetPower(9000)
    Excailbur.Attack()

    LongBow := weaponFactory.createWeapon("Bow")
    LongBow.SetName("LongBow")
    LongBow.SetPower(100)
    LongBow.Attack()
}

output:

Excalibur Slash! 9000
LongBow Shot! 100

สรุป Factory Pattern

ข้อดี

Encapsulation และมีการแยก separation of concern
Abstraction: client มีการดำเนินการกับ interface ซึ่ง decouple จาก implementation
Flexibility: สามารถปรับหรือเพิ่ม concrete ชนิดใหม่ได้โดยไม่ต้องยุ่ง client code

ข้อควรระวัง

เป็นการเพิ่มความซับซ้อนที่มากขึ้นเมื่อเทียบกับการสร้าง instance แบบตรงๆ

All code:

package main

import "fmt"

type IWeapon interface {
    SetName(name string)
    SetPower(power int)
    GetName() string
    GetPower() int
    Attack()
}

type Weapon struct {
    name  string
    power int
}

func (w *Weapon) SetName(name string) {
    w.name = name
}

func (w *Weapon) SetPower(power int) {
    w.power = power
}

func (w *Weapon) GetName() string {
    return w.name
}

func (w *Weapon) GetPower() int {
    return w.power
}

func (w *Weapon) Attack() {
}

type Sword struct {
    Weapon
}

func (s *Sword) Attack() {
    fmt.Printf("%s Slash! %d\n", s.GetName(), s.GetPower())
}

type Bow struct {
    Weapon
}

func (b *Bow) Attack() {
    fmt.Printf("%s Shot! %d\n", b.GetName(), b.GetPower())
}

type WeaponFactory struct {
}

func (wf *WeaponFactory) createWeapon(weaponType string) IWeapon {
    switch weaponType {
    case "Sword":
        return &Sword{Weapon{"Sword", 100}}
    case "Bow":
        return &Bow{Weapon{"Bow", 50}}
    default:
        return nil
    }
}

func main() {
    weaponFactory := WeaponFactory{}

    Excalibur := weaponFactory.createWeapon("Sword")
    Excalibur.SetName("Excalibur")
    Excalibur.SetPower(9000)
    Excalibur.Attack()

    LongBow := weaponFactory.createWeapon("Bow")
    LongBow.SetName("LongBow")
    LongBow.SetPower(100)
    LongBow.Attack()
}

References:

มือใหม่หัด Go: Two Sum

Nattrio — Sun, 14 May 2023 05:30:27 +0000

โจทย์ปัญหาที่พบได้บ่อยๆ สำหรับมือใหม่ คือ Two Sum จาก LeetCode นั่นเอง ในบทความนี้จะมาแสดงวิธีแก้โจทย์ด้วย Go กัน

Two Sum

กำหนดให้ nums: array ของ int, target: int เป็น parameter ของ function เพื่อคืนค่าเป็น index ของสองตัวเลขที่ได้ผลรวมเท่ากับ target
ในแต่ละ input จะมีผลลัพธ์แค่คำตอบเดียว จึงไม่จำเป็นต้องใช้เลขตัวเดิมมาคิด
คืนค่าคำตอบไม่จำเป็นต้องเรียงลำดับ

Example:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]

Answer:

func twoSum(nums []int, target int) []int {
    numMap := make(map[int]int)

    for i, num := range nums {
        complement := target - num
        if _, ok := numMap[complement]; ok {
            return []int{numMap[complement], i}
        }
        numMap[num] = i
    }

    return nil
}

Explanation:

numMap ตัวเปล่าใช้ในการเก็บค่าในรูปแบบ key: value ช่วยเก็บคำตอบ
แตก index i and ค่า num ออกจาก array
Iteration 1 : num = 2
- complement := target - num ได้เป็น 7 จาก 9 - 2
- เช็คว่ามี key 7 อยู่ใน numMap หรือไม่ โดยใช้ _, ok := numMap[complement]
  - ค่าแรกเป็น zero value ของ int = 0 แต่ไม่ได้ใช้จึงละไว้
  - ค่าที่สองเป็น false เพราะ numMap ยังว่างอยู่
- จึงทำการ numMap[num] = i เพิ่มค่า map เป็น {2: 0}
Iteration 2 num = 7
- complement := target - num ได้เป็น 2 จาก 9 - 7
- เช็คว่ามี key 2 อยู่ใน numMap หรือไม่ ซึ่งเป็น true
- เข้าเงื่อนไขให้ return []int{numMap[complement], i} ออกมาเป็น [0, 1] คือ ตำแหน่ง index ของจำนวนที่รวมกันได้ target

มือใหม่หัด Go: Basic Unit Testing

Nattrio — Sat, 13 May 2023 14:40:30 +0000

วันนี้จะมาลองใช้ Go เพื่อทำ unit testing อย่างง่าย เพื่อทำความเข้าใจสำหรับมือใหม่ให้เห็นภาพไปพร้อมกัน ด้วยความที่ Go มี function ที่อำนวยความสะดวกในการทำ testing รวมถึงมีคำสั่งในการ run test ซึ่งเรียกใช้ได้เลยโดยไม่ต้องลง plug in เพิ่มเติม จึงเหมาะมากที่จะใช้เป็นตัวอย่างสำหรับ TDD

Test Driven Development (TDD)

TDD มีหลักการอย่างง่าย คือ ให้สร้าง test สำหรับ function ที่ยังไม่ implement ขึ้นมาก่อน จากนั้นให้ค่อยๆ เริ่มเขียนโค้ดเพิ่มเติมเพื่อให้ได้ผลลัพธ์ตามที่เราคาดหวัง โดยมากแล้วมักมีวงจรดังนี้

Red: ประกาศตัวแปร, function ที่ใช้ในการทดสอบ (testcase) ซึ่งผลลัพธ์ที่คาดหวังคือ fail
Green: เขียนโค้ด (code) เพื่อทำให้ทดสอบ pass โดยอาจเขียนอย่างง่ายไว้ก่อน
Refactor: ปรับปรุงโค้ดให้ทำงานได้ดี ถูกต้อง เข้าใจง่าย รวมถึงหากรณีอื่นๆ เพื่อนำไปสู่ testcase ใหม่ให้ครอบคลุมมากขึ้น วนซ้ำไปเรื่อยๆ

เอาล่ะ ต่อไปจะเริ่มลงมือเขียนโค้ดกันเพื่อให้เข้าใจมากขึ้น เริ่มจากสร้างไฟล์ตามนี้

mkdir water
cd ./water
touch water.go
touch water_test.go

ในบทความนี้จะทำการเขียน function เพื่อรับค่า temperature เป็นองศสาเซลเซียส แล้วคืนค่าออกมาเป็นสถานะของน้ำ

🔴Red: เริ่มต้นจากล้มเหลว

เริ่มต้นเขียนจาก testcase ให้ใส่ temperature = 25 แล้วคาดหวังว่าควรจะได้รับคืนค่าเป็น "liquid"

// water_test.go

func TestWaterStatus(t *testing.T) {
    temperature := 25
    want := "liquid"
    got := water.WaterStatus(temperature)
    if got != want {
        t.Errorf("WaterStatus(%d) = %q; want %q", temperature, got, want)
    }
}

🟢Green: แก้ไขให้รันผ่าน

ในที่นี้จะเขียนแบบง่าย หรือโกงให้รันทดสอบให้ผ่านก่อน คือ return "liquid" ไปตรงๆ เลย

// water.go

func WaterStatus(temperature int) string {
    return "liquid"
}

รันเทสโดยใช้ go test -v ./...

🔵Refactor: ปรับปรุงจนดีเลิศ

คราวนี้คือส่วนที่ต้องปรับปรุงโค้ดให้มันดีและสมเหตุสมผลมากขึ้น เนื่องจากเราทราบว่าน้ำโดยปกติจะมี 3 สถานะ ได้แก่ solid, liquid และ gas

// water.go

func WaterStatus(temperature int) string {
    if temperature <= 0 {
        return "solid"
    } else if temperature >= 100 {
        return "gas"
    } else {
        return "liquid"
    }
}

รันเทสอีกรอบพร้อมเช็ค coverage โดยใช้ go test -v -cover ./... จะเห็นว่ารันผ่าน แต่ coverage ยังไม่ครบ 100% ทำให้เราต้องกลับมาที่ Red เพื่อเขียน testcase เพิ่ม

กลับมาที่ไฟล์ water_test.go เราสามารถเขียนแยก function ใหม่สำหรับ case ของ solid และ gas ได้

// water_test.go

func TestWaterStatusLiquid(t *testing.T) {
    temperature := 25
    want := "liquid"
    got := water.WaterStatus(temperature)
    if got != want {
        t.Errorf("WaterStatus(%d) = %q; want %q", temperature, got, want)
    }
}

func TestWaterStatusSolid(t *testing.T) {
    temperature := -10
    want := "solid"
    got := water.WaterStatus(temperature)
    if got != want {
        t.Errorf("WaterStatus(%d) = %q; want %q", temperature, got, want)
    }
}

func TestWaterStatusGas(t *testing.T) {
    temperature := 110
    want := "gas"
    got := water.WaterStatus(temperature)
    if got != want {
        t.Errorf("WaterStatus(%d) = %q; want %q", temperature, got, want)
    }
}

แต่พิจารณาดูแล้วก็เหมือนเขียนโค้ดคล้ายกัน จะดีกว่าไหมหากเราเขียนภายใน function และเปลี่ยนแค่ testcase ที่เราต้องการทดสอบ แบบนี้

// water_test.go

func TestWaterStatus(t *testing.T) {
    type testcase struct {
        name        string
        temperature int
        expected    string
    }

    cases := []testcase{
        {"solid", -10, "solid"},
        {"liquid", 25, "liquid"},
        {"gas", 110, "gas"},
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            actual := WaterStatus(tc.temperature)
            if actual != tc.expected {
                t.Errorf("Expected %s, got %s", tc.expected, actual)
            }
        })
    }
}

ลองรัน go test -v -cover ./... จะเห็นว่าเป็น pass และ coverage: 100%

หวังว่าการ demo ในบทความนี้จะเป็นประโยชน์สำหรับผู้เริ่มต้นกันนะครับ