Rövid útmutató: Funkciójelzők hozzáadása Go Gin-webalkalmazáshoz

Ebben a rövid útmutatóban létrehoz egy funkciójelzőt az Azure App Configurationban, és segítségével dinamikusan szabályozhatja egy Go Gin-webalkalmazás új weblapjának elérhetőségét anélkül, hogy újraindítaná vagy újra üzembe helyezi.

A szolgáltatásfelügyeleti támogatás kibővíti az alkalmazáskonfiguráció dinamikus konfigurációs funkcióját. Ez a példa bemutatja, hogyan integrálhatók a funkciójelzők egy Go Gin-webalkalmazásba valós idejű frissítésekkel és feltételes lapmegjelenítésekkel.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Hozzon létre egyet ingyen.
Alkalmazáskonfigurációs áruház. Hozzon létre egy áruházat.
Ugrás 1.21 vagy újabb verzióra. A Go telepítésével kapcsolatos információkért tekintse meg a Go letöltési oldalát.
Azure App Configuration Go provider v1.1.0 vagy újabb verzió.

Funkciójelző létrehozása

Adjon hozzá egy bétaverzió nevű funkciójelzőt az Alkalmazáskonfigurációs áruházhoz, és hagyja meg a címkét és a leírást az alapértelmezett értékekkel. Ha többet szeretne tudni arról, hogyan adhat hozzá funkciójelzőket egy áruházhoz az Azure Portal vagy a parancssori felület használatával, lépjen a Funkciójelölő létrehozása elemre.

Go-webalkalmazás létrehozása

Hozzon létre egy új könyvtárat a Go-projekthez, és navigáljon hozzá:
```
mkdir gin-feature-flag-quickstart
cd gin-feature-flag-quickstart
```

Új Go-modul inicializálása:

go mod init gin-feature-flag-quickstart

Telepítse a szükséges Go-csomagokat az Azure App Configurationhoz, a Gin webes keretrendszerhez és a funkciókezeléshez:

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

Hozzon létre egy sablonkönyvtárat a HTML-sablonokhoz, és adja hozzá a szükséges HTML-fájlokat:
```
mkdir templates
```
Adja hozzá a következő HTML-sablonfájlokat a GitHub-adattárból , és helyezze őket a templates könyvtárba:
- index.html - A kezdőlap sablonja
- beta.html - A bétaoldal sablonja

Funkciójelző használata

Hozzon létre egy fájlt appconfig.go az alábbi tartalommal. Az Alkalmazáskonfigurációs áruházhoz Microsoft Entra ID (ajánlott) vagy kapcsolati string használatával csatlakozhat.

Microsoft Entra-azonosító (ajánlott)
Kapcsolati karakterlánc

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
}

Jótanács

Ha nincs megadva választó, az FeatureFlagOptions funkciójelzőt címke nélkül tölti be az alkalmazáskonfigurációs áruházban. A funkciójelölők alapértelmezett frissítési időköze 30 másodperc. Ezt a viselkedést a RefreshOptions paraméteren keresztül szabhatja testre. A következő kódrészlet például csak a TestApptal kezdődő funkciójelölőket tölti be: a kulcsnevüket, és a címke fejlesztőivel rendelkeznek. A kód a frissítési időközt is 5 percre módosítja. Vegye figyelembe, hogy ez a frissítési időköz eltér a normál kulcsértékek időtartamától.

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

Hozzon létre egy fájlt main.go a következő tartalommal:

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

A webalkalmazás futtatása

Állítsa be a környezeti változót a hitelesítéshez , és futtassa az alkalmazást.
```
go mod tidy
go run .
```
Nyisson meg egy ablakot a böngészőben, és menjen a http://localhost:8080. A böngészőnek az alábbi képhez hasonló oldalt kell megjelenítenie.
Jelentkezzen be a Azure portalra. Válassza a Minden erőforrás lehetőséget, és válassza ki a korábban létrehozott Alkalmazáskonfigurációs áruházat.
Válassza a Funkciókezelőt, és keresse meg a bétafunkció-jelzőt. Engedélyezze a jelölőt az Engedélyezve jelölőnégyzet bejelölésével.
Frissítse a böngészőt néhányszor. Amikor a frissítési időköz időablaka eltelik, a lap frissült tartalommal jelenik meg:
Figyelje meg, hogy a Béta menüelem most megjelenik a navigációs sávon. Kattintson rá a bétaoldal eléréséhez:

Erőforrások tisztítása

Ha nem szeretné folytatni a cikkben létrehozott erőforrások használatát, törölje az itt létrehozott erőforráscsoportot a díjak elkerülése érdekében.

Fontos

Egy erőforráscsoport törlése visszafordíthatatlan. Az erőforráscsoport és a benne lévő összes erőforrás véglegesen törlődik. Győződjön meg arról, hogy nem véletlenül törli a rossz erőforráscsoportot vagy erőforrásokat. Ha a cikk erőforrásait olyan erőforráscsoporton belül hozta létre, amely más megtartani kívánt erőforrásokat tartalmaz, törölje az egyes erőforrásokat a megfelelő panelről az erőforráscsoport törlése helyett.

Jelentkezzen be az Azure Portalra, és válassza ki az Erőforráscsoportokat.
A Szűrés név szerint mezőbe írja be az erőforráscsoport nevét.
Az eredménylistában válassza ki az erőforráscsoport nevét az áttekintés megtekintéséhez.
Válassza az Erőforráscsoport törlése lehetőséget.
A rendszer az erőforráscsoport törlésének megerősítését kéri. Adja meg a megerősítéshez az erőforráscsoport nevét, és válassza a Törlés lehetőséget.

Néhány pillanat múlva az erőforráscsoport és annak összes erőforrása törlődik.

Következő lépések

Ebben a rövid útmutatóban létrehozott egy funkciójelzőt az Azure App Configurationban, és egy Go Gin-webalkalmazásban használta. A Feature Management Go kódtár olyan funkciójelölő képességeket biztosít, amelyek zökkenőmentesen integrálhatók az Azure App Configuration szolgáltatással. További funkciókért tekintse meg az alábbi dokumentumot.

Go szolgáltatási funkciókezelési referencia

Bár a funkciójelölő lehetővé teszi a funkciók aktiválását vagy inaktiválását az alkalmazásban, érdemes lehet testre szabni egy funkciójelzőt az alkalmazás logikája alapján. A funkciószűrők lehetővé teszik a funkciójelző feltételes engedélyezését. További információkért tekintse meg az alábbi oktatóanyagot.

Feltételes szolgáltatások engedélyezése funkciószűrőkkel

Azure-alkalmazás Konfiguráció beépített funkciószűrőket kínál, amelyek lehetővé teszik a funkciójelző aktiválását csak egy adott időszakban vagy az alkalmazás egy meghatározott célközönsége számára. További információkért tekintse meg az alábbi oktatóanyagot.

Funkciók engedélyezése ütemezés szerint

Szolgáltatások bevezetése a célközönségek számára

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-08-26