สร้าง Scalable API พร้อม Feature Flags ด้วย Open-Source Tools

Feature flagging เปลี่ยนพาราดายม์ของวิธีที่ backend developers ทดสอบและแก้ไขสิ่งที่พวกเขาสร้าง ด้วย feature flags เราสามารถเปิด/ปิดฟีเจอร์ หรือเปลี่ยน functionality ของสิ่งใดสิ่งหนึ่ง on-the-fly ด้วยคลิกเดียว (ไม่ต้อง redeploy)

ใน tutorial นี้ เราจะดูว่า feature flags ช่วยให้เรา enable/disable ฟีเจอร์/ส่วนของโค้ด ได้เมื่อไหร่ก็ได้จาก UI โดยไม่ต้อง redeploy โค้ดทั้งหมด

เพื่อเข้าใจลึกขึ้น เราจะสร้างแอปจากศูนย์ ดูความสามารถของ feature flagging และใช้ tool ชื่อ Flagsmith จัดการ feature flags ที่สร้างจาก dashboard เดียว

สิ่งที่เราจะครอบคลุม:

• ข้อกำหนดเบื้องต้น (Prerequisites)
• Feature Flag คืออะไร?
• Feature Flags สำหรับ Backend Development
• ทำไมต้องใช้ Open Source Tools?
• มาเขียนโค้ดกัน! (Let's Code!)
  • เริ่มต้นเครื่องมือ (Initializing the tools)
  • สร้าง endpoints สำหรับ API (Creating endpoints for the API)
  • วิธีเพิ่ม Feature Flagging (How to Add Feature Flagging)
  • เข้าใจตรรกะ Feature Flag code (Understanding the Feature Flag code logic)
  • วิธีสร้าง Feature Flags ใน Flasgsmith Dashboard
  • Rate Limiting Feature Flag
  • Beta Feature Flag
  • การรับ Access Key (Getting the Access Key)
  • การรัน API (Running the API)
  • การอัปเดต rate_limit Flag (Updating the rate_limit Flag)
  • วิธีรวม Feature Flags กับ GitHub App
  • ทดสอบ Flagsmith GitHub App
• สรุป

ข้อกำหนดเบื้องต้น (Prerequisites)

• Golang ติดตั้งแล้ว และเข้าใจระดับกลาง
• Redis instance ที่ทำงานอยู่ (Remote หรือ local instance)
• Flagsmith Account (ฟรี เราจะครอบคลุมภายหลังในบทความ)

Feature Flag คืออะไร?

Feature Flag เป็นเทคนิคในการพัฒนาที่ให้ทีมเปิด/ปิดฟีเจอร์ได้โดยไม่ต้องแก้ source code หรือ redeploy

ให้เข้าใจง่าย คิดว่ามันทำงานคล้าย conditional statements (เช่น if-else statements): ตามว่าเงื่อนไขเป็น true หรือ false จะกำหนด code path ที่จะ execute

Feature Flags สำหรับ Backend Development

คุณอาจเคยเห็น feature flags ใช้ใน frontend และเว็บไซต์ แตมีอะไรมากกว่านั้น คุณใช้ฝั่งเซิร์ฟเวอร์ (server-side) เพื่อแก้ไข functionality ของ API ได้ เช่น แก้/ตั้ง rate limit, เปลี่ยน functionality ของ API endpoint หรือปิดมันทิ้งเลย ในฐานะ backend developers เราสามารถเลเวลอัพการทดสอบด้วย feature flags

เพื่อสาธิต เราจะผ่านการสร้าง demo app Demo app นี้คัดสรรมาแสดงความสามารถของ feature flagging ตั้งแต่การแก้ไข functionality (rate limit) on-the-fly จนถึงการเพิ่ม endpoint ใหม่สำหรับ beta testing หรือ initial rolling เราจะใช้ open-source tools ทั้งหมด!

เราจะใช้ open source tools สร้างแอปนี้ (Golang, Redis, และ Flagsmith) Open source นำความโปร่งใสและความไว้วางใจมา และส่งเสริมการร่วมมือกับชุมชน backend developers ทั่วโลก

ด้วยการรวม open source tools เราได้ full visibility ขณะ build และ test ตัวอย่างเช่น เราจะ integrate feature flags กับ GitHub ซึ่งให้เราติดตาม lifecycle ของฟีเจอร์โดย link Flagsmith feature flag กับ GitHub Pull Request หรือ Issue นี่ช่วยให้เราอัปเดตการเปลี่ยนแปลงฟีเจอร์โดยไม่ต้อง track แต่ละ modification ด้วยมือ เราติดตามสถานะฟีเจอร์ข้าม environments ได้ง่าย

มาเขียนโค้ดกัน! (Let's Code!)

ใน tutorial นี้ คุณจะเห็นว่าความสามารถของแอปเปลี่ยนอย่างไรก่อนและหลังการทดสอบด้วย feature flagging mechanisms เครื่องมือและ frameworks ที่ใช้คือ Golang, Docker, Redis, Flagsmith, และ GitHub ตามที่กล่าวไว้ ทั้งหมดเป็น open source และฟรีสำหรับสร้างบัญชีทดสอบ

เปิด IDE ที่ชอบ เริ่มโปรเจกต์ Golang แล้วคัดลอกโค้ดด้านล่างในไฟล์ main.go จากนั้นรัน go mod tidy ติดตั้ง dependencies ทั้งหมด

มาเข้าใจว่ากำลังเกิดอะไรขึ้นในโค้ดสนิปเปตด้านล่าง:

package main
import (
    "context"
    "errors"
    "fmt"
    "log"
    "net/http"
    "os"
    "strconv"
    "github.com/gin-gonic/gin"
    "github.com/go-redis/redis_rate/v10"
    "github.com/joho/godotenv"
    "github.com/redis/go-redis/v9"
)
var (
    redisClient *redis.Client
    limiter *redis_rate.Limiter
)
func initClients() {
    redisClient = redis.NewClient(&redis.Options{
        Addr: os.Getenv("REDIS_URL"),
    })
    limiter = redis_rate.NewLimiter(redisClient)
}
func main() {
    err := godotenv.Load()
    if err != nil {
        log.Printf("Loading environment variable from the host system")
    } else {
        log.Printf("Loading environment from .env file")
    }
    initClients()
    defer redisClient.Close()
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        err, remainingLimit := rateLimitCall(c.ClientIP())
        if err != nil {
            c.JSON(
                http.StatusTooManyRequests,
                gin.H{"error": "Rate Limit Hit"})
        } else {
            c.JSON(
                http.StatusOK,
                gin.H{"Your left over API request is": remainingLimit})
        }
    })
    r.GET("/beta", func(c *gin.Context) {
        c.JSON(
            http.StatusOK,
            gin.H{"message": "This is beta endpoint"})
    })
    r.Run(":" + os.Getenv("PORT"))
}
func rateLimitCall(ClientIP string) (error, int) {
    ctx := context.Background()
    rateLimitString := os.Getenv("RATE_LIMIT")
    RATE_LIMIT, _ := strconv.Atoi(rateLimitString)
    res, err := limiter.Allow(ctx, ClientIP, redis_rate.PerHour(RATE_LIMIT))
    if err != nil {
        panic(err)
    }
    if res.Remaining == 0 {
        return errors.New("You have hit the Rate Limit for the API. Try again later"), 0
    }
    fmt.Println("remaining request for", ClientIP, "is", res.Remaining)
    return nil, res.Remaining
}

เริ่มต้นเครื่องมือ (Initializing the Tools)

func initClients() {
    redisClient = redis.NewClient(&redis.Options{
        Addr: os.Getenv("REDIS_URL"),
    })
    limiter = redis_rate.NewLimiter(redisClient)
}
func main() {
    err := godotenv.Load()
    if err != nil {
        log.Printf("Loading environment variable from the host system")
    } else {
        log.Printf("Loading environment from .env file")
    }
    initClients()
    defer redisClient.Close()
    r := gin.Default()
    ... })

ด้านบน เราประกาศตัวแปรเก็บ Redis และ Rate limiter clients เพื่อ reuse และ initialize ครั้งเดียว แล้ว initialize ใน initClients()

ใน main() ก่อนอื่น โหลด environment variables จากระบบหรือ .env file แล้วเรียก initClients() จะสร้าง clients และเก็บในตัวแปรที่สร้างไว้

ต่อไป สร้าง Gin router จัดการ incoming requests ทั้งหมด นี่คือ environment variables ที่ต้องการใน .env file สำหรับ demo นี้ เราต้องการ Redis instance ทำงานอยู่ เพื่อเก็บข้อมือทั้งหมดสำหรับ rate-limiting functionality ใช้ Docker หรือ remote machine ก็ได้ จำไว้แค่ update REDIS_URL ให้ถูกต้อง ผมจะใช้ Docker

เราอาจไปไกลกว่านี้และดึง environment variables ทั้งหมดจาก feature flags แต่นี่ไม่ทำในที่นี้

REDIS_URL=localhost:6379
PORT=8080
RATE_LIMIT=10

สร้าง Endpoints สำหรับ API (Creating Endpoints for the API)

r.GET("/ping", func(c *gin.Context) {
    err, remainingLimit := rateLimitCall(c.ClientIP())
    if err != nil {
        c.JSON(
            http.StatusTooManyRequests,
            gin.H{"error": "Rate Limit Hit"})
    } else {
        c.JSON(
            http.StatusOK,
            gin.H{"Your left over API request is": remainingLimit})
    }
})
r.GET("/beta", func(c *gin.Context) {
    c.JSON(
        http.StatusOK,
        gin.H{"message": "This is beta endpoint"})
})
r.Run(":" + os.Getenv("PORT"))

จากนั้นสร้างสอง GET endpoints คือ /ping และ /beta ทุกครั้งที่ใคร hit /ping endpoint เราเรียกฟังก์ชัน rateLimitCall() มันตรวจสอบและตั้ง rate limit ของ incoming requests จาก IP address ทั้งหมดเก็บใน Redis instance ที่เราสร้าง

ตอนนี้ หากผู้ใช้ interact กับ /ping API endpoint ครั้งแรก จะสร้าง entry พร้อม limit 10 per hour ตัวเลข limit 10 มาจาก RATE_LIMIT ที่เราตั้ง และ hourly refresh มาจากฟังก์ชัน redis_rate.PerHour(RATE_LIMIT)

ต่อไป ตรวจสอบว่าผู้ใช้เหลือ limit หรือไม่ หากมี ส่งคืนข้อความพร้อมจำนวน request ที่เหลือ มิฉะนั้น หากชน limit cap ส่งคืนข้อความแจ้งให้รู้

นอกจาก /ping endpoint เรายังมี /beta endpoint ส่งคืนข้อความง่ายๆ แต่อีกไม่นานเราจะเห็นว่า (ด้วย feature flags) เราสามารถเปิด/ปิด functionality ของ endpoint นี้ได้หมด

วิธีเพิ่ม Feature Flagging (How to Add Feature Flagging)

ตอนนี้ถึงเวลาเพิ่มความสามารถ feature flagging ให้แอป เราจะใช้ Flagsmith Flagsmith เป็น open source software ให้เราสร้างและจัดการ feature flags ได้ง่าย ข้าม web, mobile, และ server-side applications

ใช้ Flagsmith เราสามารถห่อ features ใน flag แล้ว toggle on/off สำหรับ environments, users, หรือ user segments ต่างๆ แล้วจัดการทั้งหมดจาก Flagsmith dashboard โดยไม่ต้อง redeploy

มาติดตั้ง Flagsmith package โดยรันคำสั่ง:

go get github.com/Flagsmith/flagsmith-go-client/v3

จากนั้น import package ให้ alias flagsmith ด้านล่างคือ functionality ที่อัปเดตแล้วหลัง apply feature flagging กับโค้ดเดิม

มาเข้าใจการเปลี่ยนแปลงที่เราทำ (จะอธิบายใต้โค้ด):

package main
import (
    "context"
    "errors"
    "fmt"
    "log"
    "net/http"
    "os"
    flagsmith "github.com/Flagsmith/flagsmith-go-client/v3"
    "github.com/gin-gonic/gin"
    "github.com/go-redis/redis_rate/v10"
    "github.com/joho/godotenv"
    "github.com/redis/go-redis/v9"
)
var (
    redisClient *redis.Client
    limiter *redis_rate.Limiter
    flagsmithClient *flagsmith.Client
)
func initClients() {
    redisClient = redis.NewClient(&redis.Options{
        Addr: os.Getenv("REDIS_URL"),
    })
    limiter = redis_rate.NewLimiter(redisClient)
    flagsmithClient = flagsmith.NewClient(os.Getenv("FLAGSMITH_ENVIRONMENT_KEY"))
}
func main() {
    err := godotenv.Load()
    if err != nil {
        log.Printf("Loading environment variable from the host system")
    } else {
        log.Printf("Loading environment from .env file")
    }
    initClients()
    defer redisClient.Close()
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        err, remainingLimit := rateLimitCall(c.ClientIP())
        if err != nil {
            c.JSON(
                http.StatusTooManyRequests,
                gin.H{"error": "Rate Limit Hit"})
        } else {
            c.JSON(
                http.StatusOK,
                gin.H{"Your left over API request is": remainingLimit})
        }
    })
    r.GET("/beta", func(c *gin.Context) {
        flags := getFeatureFlags()
        isEnabled, _ := flags.IsFeatureEnabled("beta")
        if isEnabled {
            c.JSON(
                http.StatusOK,
                gin.H{"message": "This is beta endpoint"})
        } else {
            c.String(http.StatusNotFound, "404 page not found")
        }
    })
    r.Run(":" + os.Getenv("PORT"))
}
func rateLimitCall(ClientIP string) (error, int) {
    ctx := context.Background()
    flags := getFeatureFlags()
    rateLimitInterface, _ := flags.GetFeatureValue("rate_limit")
    RATE_LIMIT := int(rateLimitInterface.(float64))
    fmt.Println("Current Rate Limit is", RATE_LIMIT)
    res, err := limiter.Allow(ctx, ClientIP, redis_rate.PerHour(RATE_LIMIT))
    if err != nil {
        panic(err)
    }
    if res.Remaining == 0 {
        return errors.New("You have hit the Rate Limit for the API. Try again later"), 0
    }
    fmt.Println("remaining request for", ClientIP, "is", res.Remaining)
    return nil, res.Remaining
}
func getFeatureFlags() flagsmith.Flags {
    ctx := context.Background()
    flags, _ := flagsmithClient.GetEnvironmentFlags(ctx)
    return flags
}

เข้าใจตรรกะ Feature Flag Code (Understanding the Feature Flag Code Logic)

func getFeatureFlags() flagsmith.Flags {
    ctx := context.Background()
    flags, _ := flagsmithClient.GetEnvironmentFlags(ctx)
    return flags
}

ก่อนอื่น มาดูฟังก์ชัน getFeatureFlags() ใหม่ที่เราสร้างท้ายสุด ฟังก์ชันนี้จะคืน flags ทั้งหมดที่เราสร้างบน Flagsmith dashboard โดยเรียก method GetEnvironmentFlags() บน flagsmithClient

เรา initialize flagsmithClient ภายในฟังก์ชัน initClients() Flagsmith Client ต้องการ access key (ฟังก์ชัน NewClient()) ที่เราได้จาก Flagsmith dashboard เหมือนที่เราทำกับ Redis และ Limiter clients เราจะเก็บ client ใน global variable เพื่อ reuse คุณจะเข้าใจ dashboard, การสร้าง flags, และการดึง key ในขั้นตอนต่อไป

func rateLimitCall(ClientIP string) (error, int) {
    ctx := context.Background()
    flags := getFeatureFlags()
    rateLimitInterface, _ := flags.GetFeatureValue("rate_limit")
    RATE_LIMIT := int(rateLimitInterface.(float64))
    fmt.Println("Current Rate Limit is", RATE_LIMIT)
    res, err := limiter.Allow(ctx, ClientIP, redis_rate.PerHour(RATE_LIMIT))
    if err != nil {
        panic(err)
    }
    if res.Remaining == 0 {
        return errors.New("You have hit the Rate Limit for the API. Try again later"), 0
    }
    fmt.Println("remaining request for", ClientIP, "is", res.Remaining)
    return nil, res.Remaining
}

ตอนนี้มาที่ฟังก์ชัน rateLimitCall() แทนที่จะได้ RATE_LIMIT จาก environment เราเอาค่าจาก flag rate_limit (ที่เราจะสร้างทีหลัง) เราเรียก getFeatureFlags() และดึงค่า flag rate_limit ออกมาจาก flags ทั้งหมด

ด้วยการตั้งค่าเหล่านี้เป็น feature flags เราสามารถเปลี่ยน limit ได้ dynamically จาก dashboard ตลอดเวลา ไม่ต้องเปลี่ยน functionality ของโค้ด หรือทำแบบดั้งเดิมด้วยการเปลี่ยนค่า RATE_LIMIT และ restart server ให้มันดค่าใหม่

r.GET("/beta", func(c *gin.Context) {
    flags := getFeatureFlags()
    isEnabled, _ := flags.IsFeatureEnabled("beta")
    if isEnabled {
        c.JSON(
            http.StatusOK,
            gin.H{"message": "This is beta endpoint"})
    } else {
        c.String(http.StatusNotFound, "404 page not found")
    }
})

ตอนนี้มาที่ /beta endpoint ตามว่า beta flag enabled หรือ disabled endpoint นี้จะ serve query มิฉะนั้น มันจะทำงานเหมือน endpoint ที่เข้าถึงไม่ได้ และส่งคืน 404 error message

ในตัวอย่างของผม ใส่ placeholder message แค่พอแสดงว่า มันทำงานอย่างไร แต่นี่เปิดโอกาสใหม่ใน testing และ initial releases (beta) หาก API มี endpoint ใหม่ เราสามารถห่อ functionality ไว้ใน feature flag และทำให้ available/unavailable ด้วยคลิกปุ่มเดียว ยังทำได้อีกมากมาย เช่น scheduling และ canary releases

ไฟล์ .env ของเราจะเป็นแบบนี้ เราลบ RATE_LIMIT ออก และเพิ่ม FLAGSMITH_ENVIRONMENT_KEY

REDIS_URL=localhost:6379
PORT=8080
FLAGSMITH_ENVIRONMENT_KEY=ser.ZRd***********469

วิธีสร้าง Feature Flags ใน Flasgsmith Dashboard

ไปที่ Flagsmith dashboard สร้าง flags ที่เราใช้ข้างต้น และรับ access key หากยังไม่มีบัญชี Flagsmith สมัครฟรีได้ที่นี่

หลังสมัคร คุณจะได้ prompt สร้าง organisation และ project การแยก project ดี เพราะช่วย isolate logic สำหรับ projects ต่างๆ เสร็จแล้ว คุณจะเห็น dashboard เหมือน screenshot ด้านล่าง

เรามี functionalities มากมาย จาก integrations ไปจนถึง scheduling flags เพื่อ compare การเปลี่ยนแปลง นอกจาก Go Flagsmith มี SDKs หลายตัว คลิกที่ชื่อภาษา จะให้ boilerplate code สำหรับภาษานั้น

Rate Limiting Feature Flag

ตอนนี้ สร้าง feature flag แรกสำหรับ rate limit คลิกปุ่ม Create Feature มุมขวาบน Sidebar window จะเปิด ตั้งชื่อ แล้วเพื่อให้ flag เปิดถูกต้องตอนสร้าง เราเลือก Enabled by default.

ในส่วน value ตั้งค่า flag value ได้ รองรับ formats เช่น Txt, JSON, XML ฯลฯ เนื่องจาก feature value ของเราเป็น text เรียบง่าย เช่น 20, 30 เราเลือก Txt (default) และตั้ง limit 隨機 – เราเลือก 20

คุณเพิ่ม tags และ descriptions ได้ Tags ช่วย filter Feature Flags เช่น สร้าง tag backend filter flags ที่เกี่ยวกับ Backend Description เป็นคำอธิบายกระชับว่าตอน enabled flag นี้ทำอะไร (ช่วยเข้าใจในอนาคต)

Screenshot ด้านล่างแสดงลักษณะหลัง填入รายละเอียด แล้วกด Create Feature สร้าง flag

Beta Feature Flag

มาสร้าง feature flag ที่สอง beta กระบวนการเหมือนอันแรก แต่ในอันนี้ ไม่ต้องตั้ง flag value ทิ้งว่างไว้ หลังสร้างทั้งสอง flags dashboard จะเป็นแบบนี้ แสดง flag name, value, current state (view) ฯลฯ

การรับ Access Key (Getting the Access Key)

เพื่อรับ Access Key คลิก SDK Keys จาก sidebar และกด Create Server-side Environment Key สร้าง key เนื่องจากแอปของเราเป็น server-side จึงควรใช้ตัวนี้ คัดลอกและวาง key นั้นใน value ของ .env สำหรับ key FLAGSMITH_ENVIRONMENT_KEY

การรัน API (Running the API)

ทุกอย่างพร้อมแล้ว กลับไป IDE รัน server ด้วยคำสั่ง go run main.go ใน terminal จะเห็นข้อความนี้ ในกรณีเจอ errors ให้เช็คว่า packages ติดตั้งถูกต้อง variables ตั้งถูกต้อง และแอปเข้าถึง Redis instance ได้

ตอนนี้เข้า localhost:8080/ping จะได้ข้อความ {"Your left over API request is":19} Limit คือ 20 เรา request หนึ่งครั้ง เหลือ 19

การอัปเดต rate_limit Flag (Updating the rate_limit Flag)

ลองอัปเดตค่า rate_limit flag เป็น 10 ดูสิ่งที่เกิดขึ้น ไป Flagsmith dashboard อีกครั้ง คลิกชื่อ flag Side menu bar จะเปิด อัปเดต value เป็น 10 กด Update Feature Value

เรายัง schedule การอัปเดตได้ เช่น ใช้ตอนคาดว่ามี traffic spike ช่วงเวลาหนึ่ง และลด limit ต่อ user เพื่อลด server load

ตอนนี้เข้า localhost:8080/ping จะได้ข้อความ {"Your left over API request is":8} – เพราะ total limit 10 และเรา request ไปแล้วสองครั้ง

ลองทดสอบ /beta endpoint เข้า localhost:8080/beta จะเห็นข้อความ {"message":"This is beta endpoint"}

กลับไป Flagsmith dashboard toggle switch ปิด flag นี้ ตอนนี้เข้า URL จะได้ข้อความ 404 เหมือน endpoint นี้ไม่เคยมีอยู่

ตอนนี้เรา setup functionality และ demo feature flagging capabilities แล้ว มาดูวิธี integrate Flagsmith GitHub App

วิธีรวม Feature Flags กับ GitHub App (How to Integrate Feature Flags with the GitHub App)

ก่อนอื่น ตรวจสอบว่า push แอปขึ้น GitHub แล้ว หลังนั้น ติดตั้ง GitHub Flasgsmith App บน repo จาก GitHub Marketplace

ด้วยการ integrate GitHub และ Falagsmith เราสามารถดู updates บน feature flags/features เป็น comments ใน GitHub Issues และ Pull Requests นี่ช่วยให้เราติดตามฟีเจอร์ได้ง่าย จากการสร้าง issue จน merge PR และ deploy การเปลี่ยนแปลง

เลือก organisation และ repositories ที่ต้องการติดตั้ง app สามารถติดตั้งทั้งหมด หรือเลือก repo เฉพาะ

ขณะติดตั้ง คุณจะถูก redirect ไป Flagsmith dashboard เพื่อ configure และ complete integration ข้อมูลส่วนใหญ่ pre-populated แล้ว เพียง select และ add project แล้ว save configuration

หลังกด Save Configuration Button จะ redirect กลับ dashboard หลัก Flagsmith ที่เราทำงานอยู่ก่อน

ตอนนี้ link flag ที่มีอยู่กับ GitHub issue/pull request (สร้าง dummy PR/issue ทดสอบได้) หรือสร้าง flag ใหม่ทดสอบ มาทำกับ beta flag ที่เราสร้างไว้สำหรับ beta endpoint

เพื่อ link flag กับ existing issue หรือ pull request คลิกชื่อ flag side menu จะโผล่ขวา เลือก tab 'Link' เลือก Pull Request option และเลือก PR ที่ต้องการ link Issues และ Pull Requests ที่ link กับ flag นี้ จะมองเห็นด้านล่าง:

เพื่อ verify ว่า flag linked สำเร็จ คลิก hyperlink พร้อมไอคอนลูกศร ใต้ column heading Name จะ navigate ไป Issue/PR นั้นบน GitHub คุณจะเห็นว่า Flagsmith GitHub App ได้ comment ด้านล่างพร้อมรายละเอียด เช่น environment, enabled value ฯลฯ

ทดสอบ Flagsmith GitHub App (Testing the Flagsmith GitHub App)

หลังจากนี้ เมื่อคุณเปลี่ยนแปลง flag settings ใดๆ เช่น on/off flag หรือเปลี่ยนค่า bot จะ comment พร้อมรายละเอียดที่อัปเดต

ลองทดสอบโดยปิด flag ทันทีที่ปิด flag จาก Dashboard bot ควร comment ว่า flag disabled แล้ว:

แค่นั้นแหละ วิธี integrate Flagsmith กับ GitHub เรียบร้อยแล้ว

สรุป

สรุปคือ ตอนนี้คุณรู้แล้วว่าคุณสามารถใช้ feature flags ในฐานะ backend developer เพื่อเปลี่ยน functionality ของแอป on-the-fly ได้

เพื่อนำไปสู่ระดับต่อไป เรา integrate demo app กับ Flagsmith GitHub app ให้มันอัปเดตการเปลี่ยนแปลงสถานะ feature flags บน Pull Requests/Issues โดยไม่ต้อง update ด้วยมือ

ดู Flagsmith repo ที่นี่ และอย่าลืมให้ดาวแต่ละโปรเจกต์เพื่อแสดงการสนับสนุน คุณยัง join community พวกเขาได้สำหรับ technical support

ติดต่อผม - Pradumna Saraf บน socials ที่นี่

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started