Functies implementeren voor doelgroepen in een Go Gin-webtoepassing

2025-07-30

In deze handleiding gebruikt u het doelfilter om een functie uit te rollen voor doelgroepen voor uw Go Gin-webtoepassing. Zie Functies implementeren voor doelgroepen voor meer informatie over het doelfilter.

Prerequisites

Een Azure-account met een actief abonnement. Maak gratis een account.
Een App Configuration-winkel, zoals uiteengezet in de zelfstudie voor het maken van een winkel.
Een functievlag met doelfilter. Maak de functievlag.
Ga 1.21 of hoger. Zie de pagina Go-downloads voor meer informatie over het installeren van Go.
Azure App Configuration Go-provider v1.1.0-beta.1 of hoger.

Een webtoepassing maken met een functievlag

In deze sectie maakt u een webtoepassing waarmee gebruikers zich kunnen aanmelden en de bètafunctievlag kunnen gebruiken die u eerder hebt gemaakt.

Maak een nieuwe map voor uw Go-project en navigeer ernaartoe:
```
mkdir gin-targeting-quickstart
cd gin-targeting-quickstart
```
Initialiseer een nieuwe Go-module:
```
go mod init gin-targeting-quickstart
```

Installeer de vereiste Go-pakketten:

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

Maak een sjabloonmap voor uw HTML-sjablonen:
```
mkdir templates
```

Maak een HTML-sjabloon voor de startpagina. Voeg de volgende inhoud toe aan templates/index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{.title}}</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
        <div class="container">
            <a class="navbar-brand" href="/">TestFeatureFlags</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
                    aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                <ul class="navbar-nav flex-grow-1">
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/">Home</a>
                    </li>
                    {{if .betaEnabled}}
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/beta">Beta</a>
                    </li>
                    {{end}}
                </ul>
                <ul class="navbar-nav">
                    {{if .user}}
                    <li class="nav-item">
                        <span class="navbar-text me-3">Welcome, {{.user}}!</span>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/logout">Logout</a>
                    </li>
                    {{else}}
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/login">Login</a>
                    </li>
                    {{end}}
                </ul>
            </div>
        </div>
    </nav>    <div class="container">
        <div class="row justify-content-center">
            <div class="col-md-8 text-center">
                <h1>Welcome</h1>
        </div>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

Maak een HTML-sjabloon voor de bètapagina. Voeg de volgende inhoud toe aan templates/beta.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{.title}}</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>    <!-- Navigation -->    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
        <div class="container">
            <a class="navbar-brand" href="/">TestFeatureFlags</a>
            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                <ul class="navbar-nav flex-grow-1">
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/">Home</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/beta">Beta</a>
                    </li>
                </ul>
                <ul class="navbar-nav">
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/logout">Logout</a>
                    </li>
                </ul>
            </div>
        </div>
    </nav>    <div class="container">
        <div class="row justify-content-center">
            <div class="col-md-8 text-center">
                <h1>This is the beta website.</h1>
            </div>
        </div>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

Maak een HTML-sjabloon voor de aanmeldingspagina. Voeg de volgende inhoud toe aan templates/login.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{.title}}</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
        <div class="container">
            <a class="navbar-brand" href="/">TestFeatureFlags</a>
            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                <ul class="navbar-nav flex-grow-1">
                    <li class="nav-item">
                        <a class="nav-link text-dark" href="/">Home</a>
                    </li>
                </ul>
            </div>
        </div>
    </nav>

    <div class="container">
        <div class="row justify-content-center">
            <div class="col-md-6">
                <div class="card">
                    <div class="card-header">
                        <h3 class="text-center">Login</h3>
                    </div>
                    <div class="card-body">
                        {{if .error}}
                        <div class="alert alert-danger" role="alert">
                            {{.error}}
                        </div>
                        {{end}}

                        <form method="post" action="/login">
                            <div class="mb-3">
                                <input type="text" class="form-control" id="username" name="username" required 
                                    placeholder="Enter you email">
                            </div>
                            <div class="d-grid">
                                <button type="submit" class="btn btn-primary">Login</button>
                            </div>
                        </form>
                    </div>
                </div>
            </div>
        </div>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

Verbinding maken met App Configuration

Maak een bestand met de naam appconfig.go met de volgende inhoud. U kunt verbinding maken met uw App Configuration-archief met behulp van Microsoft Entra ID (aanbevolen) of een verbindingsreeks.

Microsoft Entra-id (aanbevolen)
Connection string

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
}

Targeting gebruiken met functievlagmen

Maak een bestand met de naam main.go met de volgende inhoud.

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

Schakel het vernieuwen van configuratie- en functievlagken in vanuit Azure App Configuration met de middleware.

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

Stel de routes in met de volgende inhoud:

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

Werk de main.go inhoud bij met de volgende inhoud:

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

Nadat u de vorige stappen hebt voltooid, moet uw main.go bestand nu de volledige implementatie bevatten, zoals hieronder wordt weergegeven:

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

Doelfilter in actie

Stel de omgevingsvariabele in voor verificatie en voer de toepassing uit:
```
go mod tidy
go run .
```
Open een browservenster en ga naar http://localhost:8080. In eerste instantie wordt het bèta-item niet weergegeven op de werkbalk, omdat de optie Standaardpercentage is ingesteld op 0.
Klik op de aanmeldingskoppeling in de rechterbovenhoek. Probeer u aan te melden met test@contoso.com.
Nadat u zich hebt aangemeld als test@contoso.com, wordt het Beta-item nu weergegeven op de werkbalk, omdat test@contoso.com is opgegeven als een gerichte gebruiker.
Nu afmelden en aanmelden als testuser@contoso.com. Het bèta-item wordt niet weergegeven op de werkbalk, omdat testuser@contoso.com het is opgegeven als een uitgesloten gebruiker.