Quickstart: Functievlagmen toevoegen aan een Go Gin-web-app

2025-08-26

In deze quickstart maakt u een functievlag in Azure App Configuration en gebruikt u deze om de beschikbaarheid van een nieuwe webpagina in een Go Gin-web-app dynamisch te beheren zonder deze opnieuw te starten of opnieuw te implementeren.

De ondersteuning voor functiebeheer breidt de dynamische configuratiefunctie in App Configuration uit. In dit voorbeeld ziet u hoe u functievlagmen integreert in een Go Gin-webtoepassing met realtime-updates en voorwaardelijke paginaweergave.

Vereiste voorwaarden

Een Azure-account met een actief abonnement. Maak gratis een account.
Een App Configuration-winkel. Een winkel maken.
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 of hoger.

Een functievlag maken

Voeg een functievlag met de naam Beta toe aan het App Configuration-archief en laat label en beschrijving ongewijzigd met de standaardwaarden. Ga naar Een functievlag maken voor meer informatie over het toevoegen van functievlagmen aan een winkel met behulp van Azure Portal of de CLI.

Een Go-webtoepassing maken

Maak een nieuwe map voor uw Go-project en navigeer ernaartoe:

mkdir gin-feature-flag-quickstart
cd gin-feature-flag-quickstart

Initialiseer een nieuwe Go-module:

go mod init gin-feature-flag-quickstart

Installeer de vereiste Go-pakketten voor Azure App Configuration, Gin-webframework en functiebeheer:

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

Maak een map met sjablonen voor uw HTML-sjablonen en voeg de vereiste HTML-bestanden toe:
```
mkdir templates
```
Voeg de volgende HTML-sjabloonbestanden toe vanuit de GitHub-opslagplaats en plaats ze in de templates map:
- index.html - De startpaginasjabloon
- beta.html - De bètapaginasjabloon

Een functievlag gebruiken

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

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,
    }

    // Configure feature flag options
    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,
    }

    // Configure feature flag options
    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
}

Aanbeveling

Wanneer er geen selector is opgegeven FeatureFlagOptions, worden alle functievlaggen zonder label geladen in uw App Configuration-opslag. Het standaardvernieuwingsinterval van functievlagmen is 30 seconden. U kunt dit gedrag aanpassen via de RefreshOptions parameter. Met het volgende codefragment worden bijvoorbeeld alleen functievlagmen geladen die beginnen met TestApp: in hun sleutelnaam en de labeldev. De code wijzigt ook de vernieuwingsintervaltijd in 5 minuten. Houd er rekening mee dat deze vernieuwingsintervaltijd gescheiden is van die voor normale sleutelwaarden.

azureappconfiguration.FeatureFlagOptions{
    Enabled: true,
    Selectors: []azureappconfiguration.Selector{
        {
            KeyFilter:   "TestApp:*",
            LabelFilter: "dev",
        },
    },
    RefreshOptions: azureappconfiguration.RefreshOptions{
        Enabled: true,
        Interval: 5 * time.Minute,
    },
}

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

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"

    "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
    "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() {
            ctx := context.Background()
            if err := app.appConfig.Refresh(ctx); err != nil {
                log.Printf("Error refreshing configuration: %v", err)
            }
        }()
        c.Next()
    }
}

func (app *WebApp) featureMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Check if Beta feature is enabled
        betaEnabled, err := app.featureManager.IsEnabled("Beta")
        if err != nil {
            log.Printf("Error checking Beta feature: %v", err)
            betaEnabled = false
        }

        // Store feature flag status for use in templates
        c.Set("betaEnabled", betaEnabled)
        c.Next()
    }
}

func (app *WebApp) setupRoutes(r *gin.Engine) {
    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)
}

// Home page handler
func (app *WebApp) homeHandler(c *gin.Context) {
    betaEnabled := c.GetBool("betaEnabled")

    c.HTML(http.StatusOK, "index.html", gin.H{
        "title":       "Feature Management Example App",
        "betaEnabled": betaEnabled,
    })
}

// 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 main() {
    ctx := context.Background()

    // Load Azure App Configuration
    appConfig, err := loadAzureAppConfiguration(ctx)
    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,
    }

    // Set up Gin with default middleware (Logger and Recovery)
    r := gin.Default()

    // Set up routes
    app.setupRoutes(r)

    // Start server
    fmt.Println("Starting server on http://localhost:8080")
    fmt.Println("Open http://localhost:8080 in your browser")
    fmt.Println("Toggle the 'Beta' feature flag in Azure portal to see changes")
    fmt.Println()

    if err := r.Run(":8080"); err != nil {
        log.Fatalf("Failed to start server: %v", err)
    }
}

De webtoepassing uitvoeren

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 uw browser wordt een pagina weergegeven die vergelijkbaar is met de onderstaande afbeelding.
Meld u aan bij het Azure-portaal. Selecteer Alle resources en selecteer het App Configuration-archief dat u eerder hebt gemaakt.
Selecteer Functiebeheer en zoek de bètafunctievlag. Schakel de vlag in door het selectievakje onder Ingeschakeld in te schakelen.
Vernieuw de browser een paar keer. Wanneer het tijdvenster voor het vernieuwingsinterval is verstreken, wordt de pagina weergegeven met bijgewerkte inhoud:
U ziet dat het menu-item Bèta nu wordt weergegeven in de navigatiebalk. Klik erop om toegang te krijgen tot de bètapagina:

De hulpbronnen opschonen

Als u de resources die in dit artikel zijn gemaakt niet wilt blijven gebruiken, verwijdert u de resourcegroep die u hier hebt gemaakt om kosten te voorkomen.

Belangrijk

Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. De resourcegroep en alle resources daarin worden permanent verwijderd. Zorg ervoor dat u niet per ongeluk de verkeerde groep of bronnen verwijdert. Als u de resources voor dit artikel in een resourcegroep hebt gemaakt die andere resources bevat die u wilt behouden, moet u elke resource afzonderlijk verwijderen uit het deelvenster in plaats van dat u de resourcegroep verwijdert.

Meld u aan bij de Azure-portal en selecteer Resourcegroepen.
Voer in het vak Filteren op naam de naam van uw resourcegroep in.
Selecteer in de resultatenlijst de resourcegroepnaam om een overzicht te bekijken.
Selecteer Resourcegroep verwijderen.
U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Voer de naam van de resourcegroep in die u wilt bevestigen en selecteer Verwijderen.

Na enkele ogenblikken worden de resourcegroep en alle bijbehorende resources verwijderd.

Volgende stappen

In deze quickstart hebt u een functievlag gemaakt in Azure App Configuration en deze gebruikt in een Go Gin-webtoepassing. De bibliotheek Functiebeheer go biedt mogelijkheden voor functievlagken die naadloos kunnen worden geïntegreerd met Azure App Configuration. Ga naar het volgende document voor meer functies.

Naslaginformatie over Go-functiebeheer

Hoewel u met een functievlag functionaliteit in uw app kunt activeren of deactiveren, kunt u een functievlag aanpassen op basis van de logica van uw app. Met functiefilters kunt u een functievlag voorwaardelijk inschakelen. Ga verder met de volgende zelfstudie voor meer informatie.

Voorwaardelijke functies met functiefilters inschakelen

Azure-app Configuratie biedt ingebouwde functiefilters waarmee u een functievlag alleen kunt activeren tijdens een bepaalde periode of voor een bepaalde doelgroep van uw app. Ga verder met de volgende zelfstudie voor meer informatie.

Functies inschakelen volgens een planning

Functies implementeren voor doelgroepen

Feedback

Is deze pagina nuttig?