Go Gin web uygulamasında özellikleri hedeflenen hedef kitlelere sunma

Bu kılavuzda, Go Gin web uygulamanız için hedeflenen hedef kitlelere bir özellik dağıtacak hedefleme filtresini kullanacaksınız. Hedefleme filtresi hakkında daha fazla bilgi için bkz . Özellikleri hedeflenen hedef kitlelere dağıtma.

Prerequisites

Aktif bir aboneliğe sahip bir Azure hesabı. Ücretsiz bir tane oluşturun.
Mağaza oluşturma öğreticisinde gösterildiği gibi bir Uygulama Yapılandırma deposu.
Hedefleme filtresi içeren bir özellik bayrağı. Özellik bayrağını oluşturun.
1.21 veya sonraki bir sürüme geçin. Go yükleme hakkında bilgi için Go indirmeleri sayfasına bakın.
Azure App Configuration Go sağlayıcısı v1.1.0 veya üzeri.

Özellik bayrağıyla web uygulaması oluşturma

Bu bölümde, kullanıcıların oturum açmasına ve daha önce oluşturduğunuz Beta özellik bayrağını kullanmasına olanak tanıyan bir web uygulaması oluşturacaksınız.

Go projeniz için yeni bir dizin oluşturun ve bu dizine gidin:
```
mkdir gin-targeting-quickstart
cd gin-targeting-quickstart
```
Yeni bir Go modülü başlatın:
```
go mod init gin-targeting-quickstart
```

Gerekli Go paketlerini yükleyin:

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

HTML şablonlarınız için bir şablon dizini oluşturun ve gerekli HTML dosyalarını ekleyin:
```
mkdir templates
```
GitHub deposundan aşağıdaki HTML şablonu dosyalarını ekleyin ve dizine templates yerleştirin:
- index.html - Giriş sayfası şablonu
- beta.html - Beta sayfası şablonu
- login.html - Oturum açma sayfası şablonu

Aşağıdaki içeriğe sahip adlı appconfig.go bir dosya oluşturun. Microsoft Entra Id (önerilen) veya bağlantı dizesi kullanarak Uygulama Yapılandırması mağazanıza bağlanabilirsiniz.

Microsoft Entra Id (önerilen)
Bağlantı dizesi

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
}

Özellik bayraklarıyla hedeflemeyi kullanma

Aşağıdaki içeriğe sahip adlı main.go bir dosya oluşturun.

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

Ara yazılım ile Azure Uygulama Yapılandırması'ndan yapılandırmayı ve özellik bayrağı yenilemeyi etkinleştirin.

// 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
//... ...

Aşağıdaki içeriğe sahip yolları ayarlayın:

// 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
//... ...

aşağıdaki main.go içerikle güncelleştirin:

// 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
// ... ...

Önceki adımları tamamladıktan sonra dosyanız main.go artık aşağıda gösterildiği gibi tam uygulamayı içermelidir:

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

Filtrelemeyi hedefleme işlemi

Kimlik doğrulaması için ortam değişkenini ayarlayın ve uygulamayı çalıştırın:
```
go mod tidy
go run .
```
Bir tarayıcı penceresi açın ve adresine http://localhost:8080gidin. Varsayılan yüzde seçeneği 0 olarak ayarlandığından, başlangıçta Beta öğesi araç çubuğunda görünmez.
Sağ üst köşedeki Oturum aç bağlantısına tıklayın. ile test@contoso.comoturum açmayı deneyin.
Olarak test@contoso.com oturum açtıktan sonra, Beta seçeneği artık araç çubuğunda görünür çünkü test@contoso.com hedeflenen kullanıcı olarak belirtilmiştir.
Şimdi oturumu kapatıp testuser@contoso.com olarak oturum açın. Beta öğesi, dışlanan bir kullanıcı olarak belirtildiğinden testuser@contoso.com araç çubuğunda görünmez.

Sonraki Adımlar

Özellik filtreleri hakkında daha fazla bilgi edinmek için aşağıdaki belgelere geçin.

Özellik filtreleri ile koşullu özellikleri etkinleştirme

Zamanlamaya göre özellikleri etkinleştirme

Go Özellik Yönetimi kitaplığı hakkında daha fazla bilgi için aşağıdaki belgeye geçin:

Go Özellik Yönetimi rehberi

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-08-26