Snabbstart: Lägga till funktionsflaggor i en Go-konsolapp

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 funktioner i en Go-konsolapp.

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-konsolprogram med övervakningsfunktioner i realtid.

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.

Använda en funktionsflagga

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

mkdir go-feature-flag-quickstart
cd go-feature-flag-quickstart

Skapa en ny Go-modul:
```
go mod init go-feature-flag-quickstart
```

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

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

Skapa en fil med namnet appconfig.go med följande innehåll. Du kan ansluta till appkonfigurationsarkivet med hjälp av Microsoft Entra-ID (rekommenderas) eller 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 huvudprogramfilen main.go:

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/microsoft/Featuremanagement-Go/featuremanagement"
	"github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
)

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

    // Monitor the Beta feature flag
    fmt.Println("Monitoring 'Beta' feature flag (press Ctrl+C to exit):")
    fmt.Println("Toggle the Beta feature flag in Azure portal to see real-time updates...")
    fmt.Println()

    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            // Refresh configuration to get latest feature flag settings
            if err := appConfig.Refresh(ctx); err != nil {
                log.Printf("Error refreshing configuration: %v", err)
                continue
            }

            // Evaluate the Beta feature flag
            isEnabled, err := featureManager.IsEnabled("Beta")
            if err != nil {
                log.Printf("Error checking if Beta feature is enabled: %v", err)
                continue
            }

            // Print timestamp and feature status
            timestamp := time.Now().Format("15:04:05")
            fmt.Printf("[%s] Beta is enabled: %t\n", timestamp, isEnabled)

        case <-ctx.Done():
            fmt.Println("\nShutting down...")
            return
        }
    }
}

Starta programmet

Kör programmet:
```
go mod tidy
go run .
```

Programmet börjar övervaka betafunktionsflaggan och visar dess aktuella tillstånd var 5:e sekund:

Monitoring 'Beta' feature flag (press Ctrl+C to exit):
Toggle the Beta feature flag in Azure portal to see real-time updates...

[14:30:15] Beta is enabled: false
[14:30:20] Beta is enabled: false
[14:30:25] Beta is enabled: false

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.
Gå tillbaka till konsolprogrammet. Efter några sekunder bör statusen för funktionsflaggan ändras:
```
[14:30:30] Beta is enabled: false
[14:30:35] Beta is enabled: true
[14:30:40] Beta is enabled: true
```
Du kan aktivera och inaktivera funktionsflaggan i Azure-portalen för att se realtidsuppdateringar i konsolprogrammet utan att starta om den.
Stoppa programmet genom att trycka på Ctrl+C .

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-konsolprogram. Biblioteket Funktionshantering Go innehåller omfattande 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?