Rychlý začátek: Přidání funkčních přepínačů do webové aplikace Go Gin

V tomto rychlém startu vytvoříte příznak funkce v Azure App Configuration a použijete ho k dynamickému řízení dostupnosti nové webové stránky ve webové aplikaci Go Gin bez restartování nebo opětovného nasazení.

Podpora správy funkcí rozšiřuje funkci dynamické konfigurace v nástroji App Configuration. Tento příklad ukazuje, jak integrovat příznaky funkcí do webové aplikace Go Gin s aktualizacemi v reálném čase a podmíněným vykreslováním stránek.

Požadavky

Účet Azure s aktivním předplatným. Vytvořte si ho zdarma.
Úložiště konfigurace aplikací. Vytvořte úložiště.
Přejděte na verzi 1.21 nebo novější. Informace o instalaci Go najdete na stránce ke stažení go.
Poskytovatel Azure App Configuration Go verze 1.1.0 nebo novější.

Vytvořit přepínač funkce

Přidejte příznak funkce s názvem Beta do obchodu App Configuration Store a ponechte popis a popis s výchozími hodnotami. Další informace o přidání příznaků funkcí do úložiště pomocí webu Azure Portal nebo rozhraní příkazového řádku najdete v části Vytvoření příznaku funkce.

Vytvoření webové aplikace Go

Vytvořte nový adresář pro projekt Go a přejděte do něj:

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

Inicializace nového modulu Go:

go mod init gin-feature-flag-quickstart

Nainstalujte požadované balíčky Go pro Azure App Configuration, webovou architekturu Gin a správu funkcí:

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

Vytvořte adresář šablon pro šablony HTML a přidejte požadované soubory HTML:
```
mkdir templates
```
Přidejte následující soubory šablon HTML z úložiště GitHub a umístěte je do templates adresáře:
- index.html - Šablona domovské stránky
- beta.html - Šablona beta stránky

Použití příznaku funkce

Vytvořte soubor s názvem appconfig.go s následujícím obsahem. Ke službě App Configuration Store se můžete připojit pomocí Microsoft Entra ID (doporučeno) nebo připojovacího řetězce.

Microsoft Entra ID (doporučeno)
Připojovací řetězec

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
}

Návod

Pokud není zadán FeatureFlagOptionsžádný selektor , načte všechny příznaky funkcí bez popisku v App Configuration Storu. Výchozí interval aktualizace příznaků funkcí je 30 sekund. Toto chování můžete přizpůsobit pomocí parametru RefreshOptions . Například následující fragment kódu načte pouze příznaky funkcí, které začínají testAppem: v názvu klíče a mají vývoj popisků. Kód také změní dobu intervalu aktualizace na 5 minut. Všimněte si, že tato doba intervalu aktualizace je oddělená od času pro běžné hodnoty klíče.

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

Vytvořte soubor s názvem main.go s následujícím obsahem:

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

Spuštění webové aplikace

Nastavte proměnnou prostředí pro ověřování a spusťte aplikaci.
```
go mod tidy
go run .
```
Otevřete okno prohlížeče a přejděte na http://localhost:8080. Prohlížeč by měl zobrazit stránku podobnou obrázku níže.
Přihlaste se do Azure Portalu. Zvolte Všechny prostředky a vyberte úložiště App Configuration, které jste vytvořili dříve.
Vyberte Správce funkcí a vyhledejte příznak funkce Beta . Povolte příznak zaškrtnutím políčka v části Povoleno.
Několikrát aktualizujte prohlížeč. Po uplynutí časového intervalu aktualizace se zobrazí stránka s aktualizovaným obsahem:
Všimněte si, že položka nabídky Beta se teď zobrazuje na navigačním panelu. Kliknutím na odkaz se dostanete na beta stránku.

Vyčistěte zdroje

Pokud nechcete dál používat prostředky vytvořené v tomto článku, odstraňte skupinu prostředků, kterou jste tady vytvořili, abyste se vyhnuli poplatkům.

Důležité

Odstranění skupiny prostředků je nevratné. Skupina prostředků a všechny prostředky v ní se trvale odstraní. Dávejte pozor, abyste omylem neodstranili nesprávnou skupinu prostředků nebo jednotlivé prostředky. Pokud jste vytvořili prostředky pro tento článek ve skupině prostředků, která obsahuje další prostředky, které chcete zachovat, odstraňte jednotlivé prostředky z příslušného podokna místo odstranění skupiny prostředků.

Přihlaste se k webu Azure Portal a vyberte skupiny prostředků.
Do pole Filtrovat podle názvu zadejte název vaší skupiny prostředků.
V seznamu výsledků vyberte název skupiny prostředků, abyste zobrazili přehled.
Vyberte odstranit skupinu zdrojů.
Zobrazí se výzva k potvrzení odstranění skupiny prostředků. Potvrďte název skupiny prostředků a vyberte Odstranit.

Po několika okamžicích se skupina prostředků a všechny její prostředky vymažou.

Další kroky

V tomto rychlém startu jste vytvořili příznak funkce v Azure App Configuration a použili ho ve webové aplikaci Go Gin. Knihovna Feature Management Go poskytuje funkce přepínačů funkcí, které se bezproblémově integrují se službou Azure App Configuration. Další informace o funkcích najdete v následujícím dokumentu.

Referenční informace ke správě funkcí Go

I když příznak funkce umožňuje aktivovat nebo deaktivovat funkce v aplikaci, můžete chtít přizpůsobit příznak funkce na základě logiky vaší aplikace. Filtry funkcí umožňují podmíněně povolit příznak funkce. Další informace najdete v následujícím kurzu.

Povolování podmíněných funkcí pomocí filtrů funkcí

Azure App Configuration nabízí vestavěné filtry funkcí, které umožňují aktivovat příznak vlastnosti pouze během určitého období nebo pro konkrétní cílovou skupinu vaší aplikace. Další informace najdete v následujícím kurzu.

Povolení funkcí podle plánu

Zavedení funkcí cílovým skupinám

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-08-26