Go Gin 웹 애플리케이션에서 대상 그룹에 기능 롤아웃

이 가이드에서는 대상 지정 필터를 사용하여 Go Gin 웹 애플리케이션의 대상 그룹에 기능을 롤아웃합니다. 대상 필터에 대한 자세한 내용은 대상 그룹층을 대상 그룹으로 기능 롤아웃를 참조하세요.

Prerequisites

• 활성 구독이 있는 Azure 계정. 체험 계정 만들기
• App Configuration 저장소는 스토어를 만들기 위한 자습서에 표시됩니다.
• 대상 지정 필터가 있는 기능 플래그입니다. 기능 플래그를 만듭니다.
• 1.21 버전 이상 이용 가능. Go 설치에 대한 자세한 내용은 Go 다운로드 페이지를 참조하세요.
• Azure App Configuration Go 공급자 v1.1.0 이상.

기능 플래그를 사용하여 웹 애플리케이션 만들기

이 섹션에서는 사용자가 이전에 만든 베타 기능 플래그에 로그인하고 사용할 수 있도록 하는 웹 애플리케이션을 만듭니다.

1. Go 프로젝트에 대한 새 디렉터리를 만들고 다음으로 이동합니다.

   mkdir gin-targeting-quickstart
   cd gin-targeting-quickstart
   

2. 새 Go 모듈을 초기화합니다.

   go mod init gin-targeting-quickstart
   

3. 필요한 Go 패키지를 설치합니다.

   go get github.com/gin-gonic/gin
   go get github.com/gin-contrib/sessions
   go get github.com/gin-contrib/sessions/cookie
   go get github.com/microsoft/Featuremanagement-Go/featuremanagement
   go get github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig
   

4. HTML 템플릿에 대한 템플릿 디렉터리를 만들고 필요한 HTML 파일을 추가합니다.

   mkdir templates
   

   GitHub 리포지토리에서 다음 HTML 템플릿 파일을 추가하고 디렉터리에 배치합니다templates.

   • index.html - 홈페이지 템플릿
   • beta.html - 베타 페이지 템플릿
   • login.html - 로그인 페이지 템플릿

5. 다음과 같은 내용으로 appconfig.go라는 파일을 만듭니다. Microsoft Entra ID(권장) 또는 연결 문자열을 사용하여 App Configuration 저장소에 연결할 수 있습니다.

   Microsoft Entra ID(권장)

   package main
   
   import (
       "context"
       "log"
       "os"
   
       "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
       // Get the endpoint from environment variable
       endpoint := os.Getenv("AZURE_APPCONFIG_ENDPOINT")
       if endpoint == "" {
           log.Fatal("AZURE_APPCONFIG_ENDPOINT environment variable is not set")
       }
   
       // Create a credential using DefaultAzureCredential
       credential, err := azidentity.NewDefaultAzureCredential(nil)
       if err != nil {
           log.Fatalf("Failed to create credential: %v", err)
       }
   
       // Set up authentication options with endpoint and credential
       authOptions := azureappconfiguration.AuthenticationOptions{
           Endpoint:   endpoint,
           Credential: credential,
       }
   
       // Set up options to enable feature flags
       options := &azureappconfiguration.Options{
           FeatureFlagOptions: azureappconfiguration.FeatureFlagOptions{
               Enabled: true,
               RefreshOptions: azureappconfiguration.RefreshOptions{
                   Enabled: true,
               },
           },
       }
   
       // Load configuration from Azure App Configuration
       appConfig, err := azureappconfiguration.Load(ctx, authOptions, options)
       if err != nil {
           log.Fatalf("Failed to load configuration: %v", err)
       }
   
       return appConfig, nil
   }
   

   연결 문자열

   package main
   
   import (
       "context"
       "log"
       "os"
   
       "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
   )
   
   func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
       // Get the connection string from environment variable
       connectionString := os.Getenv("AZURE_APPCONFIG_CONNECTION_STRING")
       if connectionString == "" {
           log.Fatal("AZURE_APPCONFIG_CONNECTION_STRING environment variable is not set")
       }
   
       // Set up authentication options with connection string
       authOptions := azureappconfiguration.AuthenticationOptions{
           ConnectionString: connectionString,
       }
   
       // Set up options to enable feature flags
       options := &azureappconfiguration.Options{
           FeatureFlagOptions: azureappconfiguration.FeatureFlagOptions{
               Enabled: true,
               RefreshOptions: azureappconfiguration.RefreshOptions{
                   Enabled: true,
               },
           },
       }
   
       // Load configuration from Azure App Configuration
       appConfig, err := azureappconfiguration.Load(ctx, authOptions, options)
       if err != nil {
           log.Fatalf("Failed to load configuration: %v", err)
       }
   
       return appConfig, nil
   }
   

기능 플래그와 함께 대상 지정 사용

1. 다음과 같은 내용으로 main.go라는 파일을 만듭니다.

   package main
   
   import (
       "context"
       "fmt"
       "log"
       "net/http"
       "strings"
   
       "github.com/gin-contrib/sessions"
       "github.com/gin-contrib/sessions/cookie"
       "github.com/gin-gonic/gin"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
   )
   
   type WebApp struct {
       featureManager *featuremanagement.FeatureManager
       appConfig      *azureappconfiguration.AzureAppConfiguration
   }
   
   func main() {
       // Load Azure App Configuration
       appConfig, err := loadAzureAppConfiguration(context.Background())
       if err != nil {
           log.Fatalf("Error loading Azure App Configuration: %v", err)
       }
   
       // Create feature flag provider
       featureFlagProvider, err := azappconfig.NewFeatureFlagProvider(appConfig)
       if err != nil {
           log.Fatalf("Error creating feature flag provider: %v", err)
       }
   
       // Create feature manager
       featureManager, err := featuremanagement.NewFeatureManager(featureFlagProvider, nil)
       if err != nil {
           log.Fatalf("Error creating feature manager: %v", err)
       }
   
       // Create web app
       app := &WebApp{
           featureManager: featureManager,
           appConfig:      appConfig,
       }
   
       // Setup Gin with default middleware (Logger and Recovery)
       r := gin.Default()
   
       // Start server
       if err := r.Run(":8080"); err != nil {
           log.Fatalf("Failed to start server: %v", err)
       }
   
       fmt.Println("Starting server on http://localhost:8080")
       fmt.Println("Open http://localhost:8080 in your browser")
       fmt.Println()
   }
   

2. 미들웨어를 사용하여 Azure App Configuration에서 구성 및 기능 플래그 새로 고침을 사용하도록 설정합니다.

   // Existing code
   // ... ...
   
   func (app *WebApp) refreshMiddleware() gin.HandlerFunc {
       return func(c *gin.Context) {
           go func() {
               if err := app.appConfig.Refresh(context.Background()); err != nil {
                   log.Printf("Error refreshing configuration: %v", err)
               }
           }()
           c.Next()
       }
   }
   
   func (app *WebApp) featureMiddleware() gin.HandlerFunc {
       return func(c *gin.Context) {
           // Get current user from session
           session := sessions.Default(c)
           username := session.Get("username")
   
           var betaEnabled bool
           var targetingContext featuremanagement.TargetingContext
           if username != nil {
               // Evaluate Beta feature with targeting context
               var err error
               targetingContext = createTargetingContext(username.(string))
               betaEnabled, err = app.featureManager.IsEnabledWithAppContext("Beta", targetingContext)
               if err != nil {
                   log.Printf("Error checking Beta feature with targeting: %v", err)
               }
           }
   
           c.Set("betaEnabled", betaEnabled)
           c.Set("user", username)
           c.Set("targetingContext", targetingContext)
           c.Next()
       }
   }
   
   // Helper function to create TargetingContext
   func createTargetingContext(userID string) featuremanagement.TargetingContext {
       targetingContext := featuremanagement.TargetingContext{
           UserID: userID,
           Groups: []string{},
       }
   
       if strings.Contains(userID, "@") {
           parts := strings.Split(userID, "@")
           if len(parts) == 2 {
               targetingContext.Groups = append(targetingContext.Groups, parts[1]) // Add domain as group
           }
       }
   
       return targetingContext
   }
   
   // The rest of existing code
   //... ...
   

3. 다음 콘텐츠를 사용하여 경로를 설정합니다.

   // Existing code
   // ... ...
   
   func (app *WebApp) setupRoutes(r *gin.Engine) {
       // Setup sessions
       store := cookie.NewStore([]byte("secret-key-change-in-production"))
       store.Options(sessions.Options{
           MaxAge:   3600, // 1 hour
           HttpOnly: true,
           Secure:   false, // Set to true in production with HTTPS
       })
       r.Use(sessions.Sessions("session", store))
   
   
       r.Use(app.refreshMiddleware())
       r.Use(app.featureMiddleware())
   
       // Load HTML templates
       r.LoadHTMLGlob("templates/*.html")
   
       // Routes
       r.GET("/", app.homeHandler)
       r.GET("/beta", app.betaHandler)
       r.GET("/login", app.loginPageHandler)
       r.POST("/login", app.loginHandler)
       r.GET("/logout", app.logoutHandler)
   }
   
   // Home page handler
   func (app *WebApp) homeHandler(c *gin.Context) {
       betaEnabled := c.GetBool("betaEnabled")
       user := c.GetString("user")
   
       c.HTML(http.StatusOK, "index.html", gin.H{
           "title":       "TestFeatureFlags",
           "betaEnabled": betaEnabled,
           "user":        user,
       })
   }
   
   // Beta page handler
   func (app *WebApp) betaHandler(c *gin.Context) {
       betaEnabled := c.GetBool("betaEnabled")
       if !betaEnabled {
           return
       }
   
       c.HTML(http.StatusOK, "beta.html", gin.H{
           "title": "Beta Page",
       })
   }
   
   func (app *WebApp) loginPageHandler(c *gin.Context) {
       c.HTML(http.StatusOK, "login.html", gin.H{
           "title": "Login",
       })
   }
   
   func (app *WebApp) loginHandler(c *gin.Context) {
       username := c.PostForm("username")
   
       // Basic validation - ensure username is not empty
       if strings.TrimSpace(username) == "" {
           c.HTML(http.StatusOK, "login.html", gin.H{
               "title": "Login",
               "error": "Username cannot be empty",
           })
           return
       }
   
       // Store username in session - any valid username is accepted
       session := sessions.Default(c)
       session.Set("username", username)
       session.Save()
       c.Redirect(http.StatusFound, "/")
   }
   
   func (app *WebApp) logoutHandler(c *gin.Context) {
       session := sessions.Default(c)
       session.Clear()
       session.Save()
       c.Redirect(http.StatusFound, "/")
   }
   
   // The rest of existing code
   //... ...
   

4. main.go를 다음 콘텐츠로 업데이트하십시오.

   // Existing code
   // ... ...
    r := gin.Default()
   
    // Setup routes
    app.setupRoutes(r)
   
    // Start server
    if err := r.Run(":8080"); err != nil {
       log.Fatalf("Failed to start server: %v", err)
   }
   // The rest of existing code
   // ... ...
   

5. 이전 단계를 완료한 후에는 파일 main.go에 아래와 같이 전체 구현이 포함되어야 합니다.

   package main
   
   import (
       "context"
       "fmt"
       "log"
       "net/http"
       "strings"
   
       "github.com/gin-contrib/sessions"
       "github.com/gin-contrib/sessions/cookie"
       "github.com/gin-gonic/gin"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
   )
   
   type WebApp struct {
       featureManager *featuremanagement.FeatureManager
       appConfig      *azureappconfiguration.AzureAppConfiguration
   }
   
   func (app *WebApp) refreshMiddleware() gin.HandlerFunc {
       return func(c *gin.Context) {
           go func() {
               if err := app.appConfig.Refresh(context.Background()); err != nil {
                   log.Printf("Error refreshing configuration: %v", err)
               }
           }()
           c.Next()
       }
   }
   
   func (app *WebApp) featureMiddleware() gin.HandlerFunc {
       return func(c *gin.Context) {
           // Get current user from session
           session := sessions.Default(c)
           username := session.Get("username")
   
           var betaEnabled bool
           var targetingContext featuremanagement.TargetingContext
           if username != nil {
               // Evaluate Beta feature with targeting context
               var err error
               targetingContext = createTargetingContext(username.(string))
               betaEnabled, err = app.featureManager.IsEnabledWithAppContext("Beta", targetingContext)
               if err != nil {
                   log.Printf("Error checking Beta feature with targeting: %v", err)
               }
           }
   
           c.Set("betaEnabled", betaEnabled)
           c.Set("user", username)
           c.Set("targetingContext", targetingContext)
           c.Next()
       }
   }
   
   // Helper function to create TargetingContext
   func createTargetingContext(userID string) featuremanagement.TargetingContext {
       targetingContext := featuremanagement.TargetingContext{
           UserID: userID,
           Groups: []string{},
       }
   
       if strings.Contains(userID, "@") {
           parts := strings.Split(userID, "@")
           if len(parts) == 2 {
               targetingContext.Groups = append(targetingContext.Groups, parts[1]) // Add domain as group
           }
       }
   
       return targetingContext
   }
   
   func (app *WebApp) setupRoutes(r *gin.Engine) {
       // Setup sessions
       store := cookie.NewStore([]byte("secret-key-change-in-production"))
       store.Options(sessions.Options{
           MaxAge:   3600, // 1 hour
           HttpOnly: true,
           Secure:   false, // Set to true in production with HTTPS
       })
       r.Use(sessions.Sessions("session", store))
   
   
       r.Use(app.refreshMiddleware())
       r.Use(app.featureMiddleware())
   
       // Load HTML templates
       r.LoadHTMLGlob("templates/*.html")
   
       // Routes
       r.GET("/", app.homeHandler)
       r.GET("/beta", app.betaHandler)
       r.GET("/login", app.loginPageHandler)
       r.POST("/login", app.loginHandler)
       r.GET("/logout", app.logoutHandler)
   }
   
   // Home page handler
   func (app *WebApp) homeHandler(c *gin.Context) {
       betaEnabled := c.GetBool("betaEnabled")
       user := c.GetString("user")
   
       c.HTML(http.StatusOK, "index.html", gin.H{
           "title":       "TestFeatureFlags",
           "betaEnabled": betaEnabled,
           "user":        user,
       })
   }
   
   // Beta page handler
   func (app *WebApp) betaHandler(c *gin.Context) {
       betaEnabled := c.GetBool("betaEnabled")
       if !betaEnabled {
           return
       }
   
       c.HTML(http.StatusOK, "beta.html", gin.H{
           "title": "Beta Page",
       })
   }
   
   func (app *WebApp) loginPageHandler(c *gin.Context) {
       c.HTML(http.StatusOK, "login.html", gin.H{
           "title": "Login",
       })
   }
   
   func (app *WebApp) loginHandler(c *gin.Context) {
       username := c.PostForm("username")
   
       // Basic validation - ensure username is not empty
       if strings.TrimSpace(username) == "" {
           c.HTML(http.StatusOK, "login.html", gin.H{
               "title": "Login",
               "error": "Username cannot be empty",
           })
           return
       }
   
       // Store username in session - any valid username is accepted
       session := sessions.Default(c)
       session.Set("username", username)
       session.Save()
       c.Redirect(http.StatusFound, "/")
   }
   
   func (app *WebApp) logoutHandler(c *gin.Context) {
       session := sessions.Default(c)
       session.Clear()
       session.Save()
       c.Redirect(http.StatusFound, "/")
   }
   
   func main() {
       // Load Azure App Configuration
       appConfig, err := loadAzureAppConfiguration(context.Background())
       if err != nil {
           log.Fatalf("Error loading Azure App Configuration: %v", err)
       }
   
       // Create feature flag provider
       featureFlagProvider, err := azappconfig.NewFeatureFlagProvider(appConfig)
       if err != nil {
           log.Fatalf("Error creating feature flag provider: %v", err)
       }
   
       // Create feature manager
       featureManager, err := featuremanagement.NewFeatureManager(featureFlagProvider, nil)
       if err != nil {
           log.Fatalf("Error creating feature manager: %v", err)
       }
   
       // Create web app
       app := &WebApp{
           featureManager: featureManager,
           appConfig:      appConfig,
       }
   
       // Setup Gin with default middleware (Logger and Recovery)
       r := gin.Default()
   
       // Setup routes
       app.setupRoutes(r)
   
       // Start server
       if err := r.Run(":8080"); err != nil {
           log.Fatalf("Failed to start server: %v", err)
       }
   
       fmt.Println("Starting server on http://localhost:8080")
       fmt.Println("Open http://localhost:8080 in your browser")
       fmt.Println()
   }
   

대상 지정 필터 작동 중

1. 인증에 대한 환경 변수를 설정하고 애플리케이션을 실행합니다.

   go mod tidy
   go run .
   

2. 브라우저 창을 열고 http://localhost:8080(으)로 이동합니다. 처음에는 ‘기본 백분율’ 옵션이 0으로 설정되므로 ‘베타’ 항목이 도구 모음에 표시되지 않습니다.

   

3. 오른쪽 위 모서리에 있는 로그인 링크를 클릭합니다. test@contoso.com로 로그인 시도해 보세요.

4. test@contoso.com로 로그인하면, 가 대상 사용자로 지정되었기 때문에 test@contoso.com 항목이 이제 도구 모음에 표시됩니다.

   

5. 이제 로그아웃하고 testuser@contoso.com으로 로그인합니다. 이 제외된 사용자로 지정되므로 도구 모음에 ‘베타’ 항목이 표시되지 않습니다.testuser@contoso.com

다음 단계

기능 필터에 대해 자세히 알아보려면 다음 문서로 계속하세요.

기능 필터를 사용하여 조건부 기능 사용

일정에 따라 기능 사용

Go 기능 관리 라이브러리에 대한 자세한 내용은 다음 문서를 계속 진행하세요.

Go 기능 관리 참조