ओपन-सोर्स टूल्स का उपयोग करके फ़ीचर फ़्लैग के साथ एक स्केलेबल एपीआई बनाएं

यहां हम क्या कवर करेंगे:

• <पी> पूर्वावश्यकताएँ

• <पी> फ़ीचर फ़्लैग क्या है?

• <पी> बैकएंड विकास के लिए फ़ीचर फ़्लैग

• <पी> ओपन सोर्स टूल्स का उपयोग क्यों करें?

• <पी> आइए कोड करें!
  • <पी> टूल प्रारंभ करना

  • <पी> एपीआई के लिए एंडपॉइंट बनाना

  • <पी> फ़ीचर फ़्लैगिंग कैसे जोड़ें

  • <पी> फ़ीचर फ़्लैग कोड तर्क को समझना

  • <पी> फ़्लैसस्मिथ डैशबोर्ड में फ़ीचर फ़्लैग कैसे बनाएं

  • <पी> दर सीमित करने वाला फ़ीचर फ़्लैग

  • <पी> बीटा फ़ीचर फ़्लैग

  • <पी> एक्सेस कुंजी प्राप्त करना

  • <पी> एपीआई चला रहा है

  • <पी> रेट_लिमिट फ़्लैग
    को अपडेट किया जा रहा है
  • <पी> GitHub ऐप के साथ फ़ीचर फ़्लैग को कैसे एकीकृत करें

  • <पी> फ़्लैगस्मिथ GitHub ऐप का परीक्षण

• <पी> निष्कर्ष

आवश्यकताएँ

• <पी> गोलांग स्थापित और इसकी एक मध्यम स्तर की समझ।

• <पी> एक चालू रेडिस इंस्टेंस (दूरस्थ या स्थानीय इंस्टेंस)

• <पी> फ़्लैगस्मिथ खाता (यह मुफ़्त है। हम इसे बाद में लेख में शामिल करेंगे।)

फ़ीचर फ़्लैग क्या है?

बैकएंड डेवलपमेंट के लिए फ़ीचर फ़्लैग

आइए कोड करें!

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
}

टूल्स को प्रारंभ करना

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_URL=localhost:6379
PORT=8080
RATE_LIMIT=10

एपीआई के लिए एंडपॉइंट बनाना

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"))

फ़ीचर फ़्लैगिंग कैसे जोड़ें

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

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
}

फ़ीचर फ़्लैग कोड लॉजिक को समझना

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

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
}

 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")
 }
 })

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

फ्लैसस्मिथ डैशबोर्ड में फ़ीचर फ़्लैग कैसे बनाएं

रेट लिमिटिंग फ़ीचर फ़्लैग

बीटा फ़ीचर फ़्लैग

एक्सेस कुंजी प्राप्त करना

एपीआई चला रहा है

rate_limit को अपडेट किया जा रहा है झंडा

GitHub ऐप के साथ फ़ीचर फ़्लैग को कैसे एकीकृत करें

फ्लैगस्मिथ GitHub ऐप का परीक्षण

निष्कर्ष