Snabbstart: Lägga till funktionsflaggor i en Go Gin-webbapp

2025-08-26

I den här snabbstarten skapar du en funktionsflagga i Azure App Configuration och använder den för att dynamiskt styra tillgängligheten för en ny webbsida i en Go Gin-webbapp utan att starta om eller distribuera om den.

Stöd för funktionshantering utökar funktionen för dynamisk konfiguration i App Configuration. Det här exemplet visar hur du integrerar funktionsflaggor i ett Go Gin-webbprogram med realtidsuppdateringar och villkorsstyrd sidåtergivning.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa en kostnadsfritt.
En konfigurationsbutik för appar. Skapa en butik.
Gå 1.21 eller senare. Information om hur du installerar Go finns på sidan Go downloads (Go-nedladdningar).
Azure App Configuration Go-provider v1.1.0 eller senare.

Skapa en funktionsflagga

Lägg till en funktionsflagga med namnet Beta i App Configuration Store och lämna Etikett och Beskrivning med sina standardvärden. Mer information om hur du lägger till funktionsflaggor i en butik med hjälp av Azure Portal eller CLI finns i Skapa en funktionsflagga.

Skapa ett Go-webbprogram

Skapa en ny katalog för Ditt Go-projekt och navigera till det:

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

Skapa en ny Go-modul:

go mod init gin-feature-flag-quickstart

Installera nödvändiga Go-paket för Azure App Configuration, Gin-webbramverk och funktionshantering:

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

Skapa en mallkatalog för dina HTML-mallar och lägg till nödvändiga HTML-filer:
```
mkdir templates
```
Lägg till följande HTML-mallfiler från GitHub-lagringsplatsen och placera dem i templates katalogen:
- index.html - Mallen för startsidan
- beta.html – Mallen för betasidan

Använda en funktionsflagga

Skapa en fil med namnet appconfig.go med följande innehåll. Du kan ansluta till App Configuration-butik genom Microsoft Entra-ID, vilket rekommenderas, eller genom en anslutningssträng.

Microsoft Entra-ID (rekommenderas)
Anslutningssträng

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
}

Tips/Råd

När ingen väljare anges i FeatureFlagOptions, läser den in alla funktionsflaggor utan etikett i din App Configuration-butik. Standarduppdateringsintervallet för funktionsflaggor är 30 sekunder. Du kan anpassa det här beteendet via parametern RefreshOptions . Följande kodfragment läser till exempel bara in funktionsflaggor som börjar med TestApp: i deras nyckelnamn och har etiketten dev. Koden ändrar även uppdateringsintervalltiden till 5 minuter. Observera att den här uppdateringsintervalltiden är separat från den för vanliga nyckelvärden.

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

Skapa en fil med namnet main.go med följande innehåll:

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

Köra webbprogrammet

Ange miljövariabeln för autentisering och kör programmet.
```
go mod tidy
go run .
```
Öppna ett webbläsarfönster och gå till http://localhost:8080. Webbläsaren bör visa en sida som liknar bilden nedan.
Logga in på Azure-portalen. Välj Alla resurser och välj appkonfigurationsarkivet som du skapade tidigare.
Välj Funktionshanterare och leta upp flaggan Beta-funktion . Aktivera flaggan genom att markera kryssrutan under Aktiverad.
Uppdatera webbläsaren några gånger. När tidsperioden för uppdateringsintervallet passerar visas sidan med uppdaterat innehåll:
Observera att menyalternativet Beta nu visas i navigeringsfältet. Klicka på den för att komma åt betasidan:

Rensa resurser

Om du inte vill fortsätta använda resurserna som skapas i den här artikeln tar du bort resursgruppen som du skapade här för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. Resursgruppen och alla resurser i den tas bort permanent. Se till att du inte oavsiktligt tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för den här artikeln i en resursgrupp som innehåller andra resurser som du vill behålla tar du bort varje resurs individuellt från respektive fönster i stället för att ta bort resursgruppen.

Logga in på Azure Portal och välj Resursgrupper.
I rutan Filtrera efter namn anger du namnet på resursgruppen.
I resultatlistan väljer du resursgruppens namn för att se en översikt.
Välj Ta bort resursgrupp.
Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och alla dess resurser bort.

Nästa steg

I den här snabbstarten skapade du en funktionsflagga i Azure App Configuration och använde den i ett Go Gin-webbprogram. Biblioteket Funktionshantering Go innehåller funktioner för funktionsflagga som integreras sömlöst med Azure App Configuration.Om du vill ha fler funktioner fortsätter du till följande dokument.

Referens för Go-funktionshantering

Med en funktionsflagga kan du aktivera eller inaktivera funktioner i din app, men du kanske vill anpassa en funktionsflagga baserat på appens logik. Med funktionsfilter kan du aktivera en funktionsflagga villkorligt. Mer information finns i följande självstudie.

Aktivera villkorsstyrda funktioner med funktionsfilter

Azure App Configuration erbjuder inbyggda funktionsfilter som gör att du endast kan aktivera en funktionsflagga under en viss period eller till en viss målgrupp för din app. Mer information finns i följande självstudie.

Aktivera funktioner enligt ett schema

Distribuera funktioner till målgrupper

Feedback

Var den här sidan till hjälp?