फीचर फ्लैगिंग ने इस प्रतिमान को बदल दिया है कि बैकएंड डेवलपर उन चीजों का परीक्षण और संशोधन कैसे कर सकते हैं जो वे बनाते हैं। फीचर फ्लैग के साथ, हम एक फीचर को सक्षम या अक्षम कर सकते हैं या एक सिंगल क्लिक के साथ किसी चीज की कार्यक्षमता को बदल सकते हैं (पुनः डिप्लॉय करने की आवश्यकता नहीं)।
इस ट्यूटोरियल में, हम देखेंगे कि फीचर फ्लैग कैसे हमें UI से, पूरे कोड को पुनः डिप्लॉय किए बिना, जब भी हम चाहें एक फीचर/कोड के एक हिस्से को सक्षम और अक्षम करने में मदद करते हैं।
चीजों को अधिक गहराई से समझने के लिए, हम एक ऐप को स्क्रैच से बनाएंगे, फीचर फ्लैगिंग क्षमताओं को देखेंगे, और अपने बनाए गए फीचर फ्लैग को एक ही डैशबोर्ड से प्रबंधित करने के लिए Flagsmith नामक एक टूल का उपयोग करेंगे।
यहां हम क्या कवर करेंगे:
पूर्वापेक्षाएँ
फीचर फ्लैग क्या है?
बैकएंड डेवलपमेंट के लिए फीचर फ्लैग
ओपन सोर्स टूल्स का उपयोग क्यों करें?
आइए कोड करें!
टूल्स को इनिशियलाइज़ करना
API के लिए एंडपॉइंट बनाना
फीचर फ्लैगिंग कैसे जोड़ें
फीचर फ्लैग कोड लॉजिक को समझना
Flagsmith डैशबोर्ड में फीचर फ्लैग कैसे बनाएं
रेट लिमिटिंग फीचर फ्लैग
बीटा फीचर फ्लैग
एक्सेस की प्राप्त करना
API चलाना
rate_limitफ्लैग को अपडेट करनाGitHub ऐप के साथ फीचर फ्लैग को कैसे इंटीग्रेट करें
Flagsmith GitHub ऐप का टेस्ट करना
निष्कर्ष
पूर्वापेक्षाएँ
Golang इंस्टॉल्ड और इसकी मध्यम-स्तर की समझ।
एक रनिंग Redis इंस्टेंस (रिमोट या लोकल इंस्टेंस)
Flagsmith अकाउंट (यह मुफ़्त है। हम इसे बाद में लेख में कवर करेंगे।)
फीचर फ्लैग क्या है?
फीचर फ्लैग डेवलपमेंट में एक तकनीक है जो टीमों को सोर्स कोड को संशोधित किए बिना या पुनः डिप्लॉय किए बिना सुविधाओं को चालू या बंद करने की अनुमति देती है।
इसे थोड़ा सरल बनाने के लिए, उन्हें सशर्त कथनों (उदाहरण के लिए, इफ-एल्स स्टेटमेंट) की तरह काम करने के रूप में सोचें: इस आधार पर कि कब कुछ सच या गलत है, यह निर्धारित करता है कि कौन सा कोड पथ निष्पादित किया जाएगा।
बैकएंड डेवलपमेंट के लिए फीचर फ्लैग
आपने फ्रंटएंड और वेबसाइटों में फीचर फ्लैग का उपयोग देखा होगा, लेकिन उनमें इससे कहीं अधिक है। आप सर्वर-साइड पर API की कार्यक्षमता को संशोधित करने के लिए उनका उपयोग कर सकते हैं, जैसे रेट लिमिट को संशोधित/सेट करना, API एंडपॉइंट की कार्यक्षमता को बदलना या इसे पूरी तरह से बंद करना। बैकएंड डेवलपर्स के रूप में, हम फीचर फ्लैग के साथ अपने टेस्टिंग को लेवल अप कर सकते हैं।
इसे प्रदर्शित करने के लिए, हम एक डेमो ऐप बनाने की प्रक्रिया से गुजरेंगे। डेमो ऐप फीचर फ्लैगिंग क्षमताओं को दिखाने के लिए क्यूरेट किया गया है, जिसमें कार्यक्षमता (रेट लिमिट) को ऑन-द-फ्लाई संशोधित करने से लेकर API में बीटा टेस्टिंग या प्रारंभिक रोलआउट उद्देश्यों के लिए एक नया एंडपॉइंट जोड़ना शामिल है। हम पूरी तरह से ओपन-सोर्स टूल्स का उपयोग करेंगे!
हम इस ऐप को बनाने के लिए ओपन सोर्स टूल्स (Golang, Redis, और Flagsmith) का उपयोग करेंगे। ओपन सोर्स अधिक पारदर्शिता और विश्वास लाता है और बैकएंड डेवलपर्स के वैश्विक समुदाय के साथ सहयोग को प्रोत्साहित करता है।
ओपन सोर्स टूल्स को इंटीग्रेट करके, हमें निर्माण और परीक्षण के दौरान पूरी दृश्यता मिलती है। उदाहरण के लिए, हम फीचर फ्लैग को GitHub के साथ इंटीग्रेट करेंगे, जो हमें एक Flagsmith फीचर फ्लैग को GitHub Pull Request या Issue से लिंक करके एक फीचर के जीवनचक्र को ट्रैक करने देता है। यह हमें प्रत्येक संशोधन को मैन्युअल रूप से ट्रैक किए बिना हमारी सुविधाओं में परिवर्तनों के साथ अपडेट रहने देता है। हम अपने फीचर की स्थिति को विभिन्न वातावरणों में आसानी से ट्रैक कर सकते हैं।
आइए कोड करें!
इस ट्यूटोरियल में, आप देखेंगे कि फीचर फ्लैगिंग मैकेनिज्म के साथ टेस्ट करने से पहले और बाद में ऐप की कार्यक्षमता कैसे बदलती है। हम जिन टूल्स और फ्रेमवर्क का उपयोग करेंगे वे हैं Golang, Docker, Redis, Flagsmith, और GitHub। जैसा कि चर्चा की गई है, सभी ओपन सोर्स हैं और टेस्ट करने के लिए अकाउंट बनाने के लिए मुफ़्त हैं।
शुरू करने के लिए, अपना पसंदीदा IDE खोलें, एक Golang प्रोजेक्ट इनिशियलाइज़ करें, और फिर नीचे दिए गए कोड को main.go फ़ाइल में कॉपी करें। फिर go mod tidy चलाएं ताकि यह सभी डिपेंडेंसी इंस्टॉल कर सके जिनकी इसे आवश्यकता है।
आइए समझें कि नीचे दिए गए कोड स्निपेट में क्या हो रहा है:
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 और रेट लिमिटर क्लाइंट को स्टोर करने के लिए वेरिएबल घोषित करते हैं ताकि उन्हें एक बार पुन: उपयोग और इनिशियलाइज़ किया जा सके। फिर हम उन्हें initClients() में इनिशियलाइज़ करते हैं।
main() में, पहले, हम सिस्टम या .env फ़ाइल से एनवायरनमेंट वेरिएबल लोड करते हैं। फिर हम initClients() कॉल करते हैं। यह क्लाइंट बनाएगा और उन्हें हमारे द्वारा बनाए गए वेरिएबल में स्टोर करेगा।
इसके बाद, हम एक Gin राउटर बनाते हैं जो हमारे सभी इनकमिंग रिक्वेस्ट को संभालता है। ये एनवायरनमेंट वेरिएबल हैं जिनकी हमें अपनी .env फ़ाइल में आवश्यकता है। इस डेमो के लिए, हमें रेट-लिमिटिंग कार्यक्षमता के लिए सभी डेटा स्टोर करने के लिए एक Redis इंस्टेंस चलाने की आवश्यकता है। हम Docker या किसी रिमोट मशीन का उपयोग कर सकते हैं - बस REDIS_URL को तदनुसार अपडेट करना याद रखें। मैं Docker का उपयोग करने जा रहा हूं।
हम एक कदम आगे भी जा सकते थे और फीचर फ्लैग से सभी एनवायरनमेंट वेरिएबल प्राप्त कर सकते थे, लेकिन हम यहां ऐसा नहीं करेंगे।
REDIS_URL=localhost:6379
PORT=8080
RATE_LIMIT=10API के लिए एंडपॉइंट बनाना
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 एंडपॉइंट बनाते हैं, /ping और /beta। हर बार जब कोई /ping एंडपॉइंट को हिट करता है तो हम rateLimitCall() फ़ंक्शन को कॉल करते हैं। यह एक IP एड्रेस से आने वाले रिक्वेस्ट की रेट लिमिट की जांच और सेट करता है। यह सब उस Redis इंस्टेंस में स्टोर होता है जिसे हमने बनाया था।
तो, अब यदि यूज़र ने /ping API एंडपॉइंट के साथ पहली बार इंटरैक्ट किया है, तो यह 10 प्रति घंटे की लिमिट के साथ एक एंट्री बनाएगा। लिमिट नंबर 10 उस RATE_LIMIT से आता है जिसे हमने सेट किया था, और घंटे के रीफ्रेश फॉर्म redis_rate.PerHour(RATE_LIMIT) फ़ंक्शन से आता है।
अगला, हम जांचते हैं कि यूज़र के पास शेष लिमिट है या नहीं। यदि हाँ, तो हम शेष रिक्वेस्ट की संख्या के साथ एक संदेश लौटाएंगे। अन्यथा, यदि वे लिमिट कैप को हिट करते हैं, तो हम उन्हें यह बताने वाला एक संदेश लौटाते हैं।
/ping एंडपॉइंट के अलावा, हमारे पास एक और एंडपॉइंट /beta है। यह एक साधारण संदेश लौटाता है, लेकिन बाद में हम देखेंगे कि कैसे (फीचर फ्लैग का उपयोग करके) हम इस एंडपॉइंट की कार्यक्षमता को पूरी तरह से चालू और बंद कर सकते हैं।
फीचर फ्लैगिंग कैसे जोड़ें
अब हमारे ऐप में फीचर फ्लैगिंग क्षमताओं को जोड़ने का समय आ गया है। हम Flagsmith का उपयोग करने जा रहे हैं। Flagsmith एक ओपन सोर्स सॉफ़्टवेयर है जो हमें वेब, मोबाइल और सर्वर-साइड एप्लिकेशन में फीचर फ्लैग को आसानी से बनाने और प्रबंधित करने देता है।
Flagsmith का उपयोग करके, हम एक फ्लैग में फीचर को लपेट सकते हैं और फिर उन्हें अलग-अलग वातावरण, यूज़र्स या यूज़र सेगमेंट के लिए चालू या बंद कर सकते हैं। और फिर आप उन सभी को Flagsmith डैशबोर्ड से प्रबंधित कर पाएंगे बिना पुनः डिप्लॉय करने की आवश्यकता के।
तो, आइए Flagsmith पैकेज को इंस्टॉल करें नीचे दी गई कमांड चलाकर:
go get github.com/Flagsmith/flagsmith-go-client/v3फिर हम पैकेज को flagsmith उपनाम देकर इम्पोर्ट करते हैं। नीचे फीचर फ्लैगिंग को हमारे मौजूदा कोड पर लागू करने के बाद अपडेटेड कार्यक्षमता है।
आइए यहां किए गए परिवर्तनों को समझें (मैं नीचे कोड स्निपेट के बाद समझाऊंगा):
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
}पहले, आइए सीधे नीचे हमारे द्वारा बनाए गए नए getFeatureFlags() फ़ंक्शन पर जाएं। यह फ़ंक्शन Flagsmith डैशबोर्ड पर हमारे द्वारा बनाए गए सभी फ्लैग को लौटाएगा, flagsmithClient पर GetEnvironmentFlags() मेथड को कॉल करके।
हमने initClients() फ़ंक्शन के अंदर flagsmithClient को इनिशियलाइज़ किया। Flagsmith Client को एक्सेस की ( NewClient() फ़ंक्शन) की आवश्यकता होती है जिसे हम Flagsmith डैशबोर्ड से प्राप्त कर सकते हैं। जैसा कि हमने Redis और Limter क्लाइंट के लिए किया था, हम क्लाइंट को पुन: उपयोगिता के लिए एक ग्लोबल वेरिएबल में स्टोर करेंगे। आप बाद के चरणों में डैशबोर्ड, फ्लैग बनाना और की प्राप्त करना समझेंगे।
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 प्राप्त करने के बजाय, हम rate_limit फ्लैग (जिसे हम बाद में बनाएंगे) से मान प्राप्त करते हैं। हम getFeatureFlags() को कॉल करते हैं और सभी फ्लैग से rate_limit फ्लैग वैल्यू निकालते हैं।
इन्हें फीचर फ्लैग के रूप में सेट करके, हम डैशबोर्ड से कभी भी लिमिट को डायनामिक रूप से बदल सकते हैं। हमें कोड की कार्यक्षमता को बदलने या RATE_LIMIT वैल्यू को बदलकर और सर्वर को पुनः चलाकर इसे पारंपरिक तरीके से करने की आवश्यकता नहीं है ताकि यह नए अपडेटेड वैल्यू को पकड़ ले।
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 एंडपॉइंट पर आते हैं, इस आधार पर कि बीटा फ्लैग सक्षम या अक्षम है, यह एंडपॉइंट क्वेरी को सर्व करेगा। अन्यथा, यह एक अनपहुंच योग्य एंडपॉइंट की तरह कार्य करेगा और 404 एरर संदेश लौटाएगा।
हमारे उदाहरण में, मैंने यह दिखाने के लिए एक बेसिक प्लेसहोल्डर संदेश जोड़ा है कि यह कैसे काम करेगा, लेकिन यह टेस्टिंग और प्रारंभिक रिलीज़ (बीटा) में नई संभावनाएं खोलता है। यदि API में एक नया एंडपॉइंट है, तो हम कार्यक्षमता को फीचर फ्लैग में लपेट सकते हैं और इसे एक बटन के सिंगल क्लिक के साथ उपलब्ध और अनुपलब्ध बना सकते हैं। इसके अलावा, हम शेड्यूलिंग और कैनरी रिलीज़ जैसे बहुत कुछ कर सकते हैं।
साथ ही, हमारी .env फ़ाइल इस तरह दिखेगी। हमने RATE_LIMIT को हटा दिया है और FLAGSMITH_ENVIRONMENT_KEY जोड़ा है।
REDIS_URL=localhost:6379
PORT=8080
FLAGSMITH_ENVIRONMENT_KEY=ser.ZRd***********469Flagsmith डैशबोर्ड में फीचर फ्लैग कैसे बनाएं
आइए Flagsmith डैशबोर्ड पर जाएं ताकि हम ऊपर उपयोग किए गए फ्लैग बना सकें और एक्सेस की प्राप्त कर सकें। यदि आपके पास Flagsmith अकाउंट नहीं है तो आप यहां मुफ़्त में साइन अप कर सकते हैं।
साइन अप करने के बाद आपको एक ऑर्गनाइज़ेशन और एक प्रोजेक्ट बनाने के लिए प्रेरित किया जाएगा। प्रोजेक्ट पृथक्करण अच्छा है, क्योंकि यह हमें विभिन्न प्रोजेक्ट्स के लिए लॉजिक को अलग करने में मदद करता है। एक बार जब आप हो जाते हैं, तो आप एक डैशबोर्ड देखेंगे, बिल्कुल नीचे दिए गए स्क्रीनशॉट की तरह।
इंटीग्रेशन से लेकर फ्लैग को शेड्यूल करने से लेकर परिवर्तनों की तुलना करने तक हमारे पास बहुत सारी कार्यक्षमताएं हैं। Go के अलावा, Flagsmith कई SDK प्रदान करता है। आप जहां भाषा का नाम लिखा है उस पर क्लिक कर सकते हैं और यह आपको उस भाषा के लिए कुछ बॉयलरप्लेट कोड देगा।
रेट लिमिटिंग फीचर फ्लैग
अब, आइए रेट लिमिट के लिए अपना पहला फीचर फ्लैग बनाएं। ऊपरी दाएं कोने में Create Feature बटन पर क्लिक करें। एक साइडबार विंडो खुलेगी। नाम सेट करें, फिर फ्लैग को बनाते समय सही तरीके से चालू करने के लिए, हम Enabled by default चुन सकते हैं।
वैल्यू सेक्शन में, हमें फ्लैग वैल्यू सेट करने की आवश्यकता है। यह Txt, JSON, XML, आदि जैसे फॉर्मेट ले सकता है। चूंकि हमारी फीचर वैल्यू 20, 30, आदि जैसे सरल टेक्स्ट है, हम Txt (डिफ़ॉल्ट वाला) चुनेंगे और एक रैंडम लिमिट सेट करेंगे - हम 20 के साथ जाएंगे।
आप टैग और डिस्क्रिप्शन भी दे सकते हैं। टैग फीचर फ्लैग को फ़िल्टर करने में मददगार हो सकते हैं। उदाहरण के लिए, हम बैकएंड से संबंधित सभी फीचर फ्लैग को फ़िल्टर करने के लिए backend टैग बना सकते हैं। डिस्क्रिप्शन इस विशेष फ्यूचर फ्लैग का संक्षिप्त विवरण है कि जब यह सक्षम होता है तो यह क्या करता है (और भविष्य की समझ में मदद करेगा)।
नीचे दिया गया स्क्रीनशॉट दिखाता है कि विवरण भरने के बाद यह कैसा दिखेगा। फिर, फ्लैग बनाने के लिए Create Feature बटन पर क्लिक करें।
बीटा फीचर फ्लैग
आइए अब दूसरा, beta फीचर फ्लैग बनाएं। यह पहली वाली के समान प्रक्रिया होगी, लेकिन इसमें हमें कोई फ्लैग वैल्यू सेट करने की आवश्यकता नहीं है और उस कॉलम को खाली छोड़ दें। एक बार जब हम दोनों फ्लैग बना लेते हैं, तो हमारा डैशबोर्ड ऐसा दिखेगा। यह फ्लैग नाम, वैल्यू, वर्तमान स्थिति (व्यू), आदि दिखाता है।
एक्सेस की प्राप्त करना
एक्सेस की प्राप्त करने के लिए, साइडबार से SDK Keys पर क्लिक करें, और एक कुंजी जनरेट करने के लिए Create Server-side Environment Key बटन पर क्लिक करें। चूंकि हमारा ऐप सर्वर-साइड है, इसलिए केवल उसी का उपयोग करना अच्छा है। फिर उस कुंजी को कॉपी करें और .env में FLAGSMITH_ENVIRONMENT_KEY कुंजी के लिए रखे गए वैल्यू में पेस्ट करें।
API चलाना
अब सब कुछ सेट है, तो आइए वापस IDE पर जाएं और टर्मिनल में go run main.go कमांड निष्पादित करके सर्वर चलाएं। हम टर्मिनल में यह संदेश देखेंगे। यदि आपको कोई त्रुटि आती है, तो बस जांच लें कि पैकेज सही ढंग से इंस्टॉल हैं, वेरिएबल सही ढंग से सेट हैं, और ऐप Redis इंस्टेंस तक पहुंच सकता है।
अब यदि हम localhost:8080/ping पर जाते हैं, तो हमें एक संदेश {"Your left over API request is":19} मिलेगा। लिमिट 20 थी, हमने अभी एक रिक्वेस्ट की, और शेष 19 है।
rate_limit फ्लैग को अपडेट करना
आइए rate_limit फ्लैग वैल्यू को 10 पर अपडेट करें और देखें क्या होता है। ऐसा करने के लिए, फिर से Flagsmith डैशबोर्ड पर जाएं और फ्लैग नाम पर क्लिक करें। एक साइड मेनू बार खुलेगा। वैल्यू को 10 पर अपडेट करें, और Update Feature Value बटन पर क्लिक करें।
हम अपडेट को शेड्यूल भी कर सकते हैं। उदाहरण के लिए, यह तब उपयोगी हो सकता है जब हम एक निश्चित समय सीमा में ट्रैफिक में स्पाइक की उम्मीद करते हैं और सर्वर लोड को कम करने के लिए प्रति यूज़र लिमिट को कम करते हैं।
यदि आप अब localhost:8080/ping पर जाते हैं, तो आपको एक संदेश {"Your left over API request is":8} मिलेगा - क्योंकि कुल लिमिट 10 है और हमने पहले ही दो बार अनुरोध किया है।
आइए अब /beta एंडपॉइंट का टेस्ट करें। localhost:8080/beta पर जाएं, और हमें एक संदेश {"message":"This is beta endpoint"} दिखाई देगा।
अब Flagsmith डैशबोर्ड पर वापस जाएं और इस फ्लैग को अक्षम करने के लिए स्विच को टॉगल करें। अब URL पर जाएं। आपको एक 404 संदेश मिलेगा जैसे यह एंडपॉइंट कभी अस्तित्व में ही नहीं था।
अब जब हमने कार्यक्षमता सेट कर ली है और फीचर फ्लैगिंग क्षमताओं का डेमो दिया है, तो आइए देखें कि हम Flasgsmith GitHub ऐप को कैसे इंटीग्रेट कर सकते हैं।
GitHub ऐप के साथ फीचर फ्लैग को कैसे इंटीग्रेट करें
सबसे पहले, सुनिश्चित करें कि आपने अपने ऐप को GitHub पर पुश कर दिया है। उसके बाद, GitHub मार्केटप्लेस से अपने रिपॉजिटरी पर GitHub Flasgsmith ऐप इंस्टॉल करें।
GitHub और Falagsmith को इंटीग्रेट करके, हम GitHub Issues और Pull Requests पर टिप्पणियों के रूप में अपने फीचर फ्लैग/फीचर पर अपडेट देख सकते हैं। यह हमें आसानी से फीचर को ट्रैक करने की अनुमति देता है, एक इश्यू बनाने से लेकर PR मर्ज करने और परिवर्तनों को डिप्लॉय करने तक।
फिर अपनी ऑर्गनाइज़ेशन और उन रिपॉजिटरी का चयन करें जहां आप ऐप इंस्टॉल करना चाहते हैं। आप इसे अपने सभी रिपॉजिटरी पर इंस्टॉल कर सकते हैं या किसी विशेष को चुन सकते हैं।
जैसे ही आप इसे इंस्टॉल करते हैं, आपको Flagsmith डैशबोर्ड पर कॉन्फिगर करने और इंटीग्रेशन पूरा करने के लिए ऑटो-रीडायरेक्ट किया जाएगा। अधिकांश डेटा प्री-पॉपुलेटेड होगा, इसलिए आपको बस एक प्रोजेक्ट चुनना और जोड़ना है, और फिर कॉन्फिगरेशन सेव करना है।
एक बार जब आप Save Configuration Button दबाते हैं, तो यह आपको मुख्य Flagsmith डैशबोर्ड पर वापस रीडायरेक्ट कर देगा जहां हम पहले काम कर रहे थे।
अब आइए मौजूदा फ्लैग में से एक को GitHub इश्यू/पुल रिक्वेस्ट के साथ लिंक करें (इसे टेस्ट करने के लिए एक डमी PR/इश्यू उठाएं), या आप टेस्ट करने के लिए एक नया फ्लैग बना सकते हैं। आइए beta फ्लैग के साथ आगे बढ़ते हैं जिसे हमने पहले beta एंडपॉइंट के लिए बनाया था।
फ्लैग को मौजूदा इश्यू या पुल रिक्वेस्ट के साथ लिंक करने के लिए, फ्लैग नाम पर क्लिक करें, और दाईं ओर से एक साइड मेनू पॉप अप होगा। फिर, 'Link' टैब चुनें। फिर पुल रिक्वेस्ट विकल्प चुनें, और उस पुल रिक्वेस्ट को चुनें जिसे आप लिंक करना चाहते हैं। इस फ्लैग से जुड़े आपके सभी इश्यू और पुल रिक्वेस्ट नीचे दिखाई देते हैं:
यह सत्यापित करने के लिए कि फ्लैग सफलतापूर्वक लिंक हो गया है, Name कॉलम हेडिंग के नीचे तीर आइकन वाले हाइपरलिंक पर क्लिक करें। यह आपको GitHub पर उस विशेष इश्यू/पुल रिक्वेस्ट पर नेविगेट करेगा। आप देख सकते हैं कि Flagsmith GitHub ऐप ने नीचे सभी डिटेल्स के साथ टिप्पणी की है, जैसे वातावरण, सक्षम वैल्यू, आदि।
Flagsmith GitHub ऐप का टेस्ट करना
इसके बाद, जब आप फ्लैग सेटिंग्स में कोई बदलाव करते हैं, जैसे फ्लैग को चालू/बंद करना या वैल्यू बदलना, तो बॉट सभी अपडेटेड डिटेल्स के साथ टिप्पणी करेगा।
आइए फ्लैग को बंद करके टेस्ट करें। जैसे ही आप डैशबोर्ड से फ्लैश को बंद करते हैं, बॉट को टिप्पणी करनी चाहिए कि फ्लैग अब अक्षम हो गया है:
बस। Flagsmith को GitHub के साथ इंटीग्रेट करना इतना सरल है।
निष्कर्ष
इसे सारांशित करने के लिए, अब आप जानते हैं कि कैसे आप एक बैकएंड डेवलपर के रूप में फीचर फ्लैग का लाभ उठा सकते हैं अपनी ऐप की कार्यक्षमता को ऑन-द-फ्लाई बदलने के लिए।
चीजों को अगले स्तर पर ले जाने के लिए, हमने अपने डेमो ऐप को Flagsmith GitHub ऐप के साथ इंटीग्रेट किया ताकि यह हमारे फीचर फ्लैग की स्थिति में परिवर्तनों के साथ Pull Requests/Issues पर अपडेट रह सके बिना उन्हें मैन्युअल रूप से अपडेट किए बिना।
Flagsmith रिपॉजिटरी को यहां देखें और इनमें से प्रत्येक प्रोजेक्ट को अपना समर्थन दिखाने के लिए एक स्टार देना न भूलें। आप तकनीकी सहायता प्राप्त करने के लिए उनके अद्भुत समुदाय में भी शामिल हो सकते हैं।
आप मुझसे - प्रडुम्ना सराफ, यहां सोशल पर जुड़ सकते हैं।
