Avvio rapido: Aggiungere flag di funzionalità a un'app Web Go Gin

In questa guida introduttiva si creerà un flag di funzionalità in Configurazione app di Azure e lo si userà per controllare in modo dinamico la disponibilità di una nuova pagina Web in un'app Web Go Gin senza riavviarlo o ridistribuirlo.

Il supporto per la gestione delle funzionalità estende la funzionalità di configurazione dinamica a Configurazione app. Questo esempio illustra come integrare i flag di funzionalità in un'applicazione web sviluppata con Go Gin, con rendering condizionale delle pagine e aggiornamenti in tempo reale.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creane uno gratis.
Un servizio di configurazione delle app. Creare un negozio.
Passare alla versione 1.21 o successiva. Per informazioni sull'installazione di Go, vedere la pagina dei download di Go.
Provider Go di Azure App Configuration v1.1.0 o versione successiva.

Creare un flag di funzionalità

Aggiungere un flag di funzionalità denominato Beta all'archivio di Configurazione app e lasciare Etichetta e Descrizione con i relativi valori predefiniti. Per altre informazioni su come aggiungere flag di funzionalità a un archivio usando il portale di Azure o l’interfaccia della riga di comando, vedere Creare un flag di funzionalità.

Creare un'applicazione Web Go

Creare una nuova directory per il progetto Go e spostarsi in questa directory:
```
mkdir gin-feature-flag-quickstart
cd gin-feature-flag-quickstart
```

Inizializzare un nuovo modulo Go:

go mod init gin-feature-flag-quickstart

Installare i pacchetti Go necessari per Configurazione app di Azure, framework Web Gin e gestione delle funzionalità:

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

Creare una directory di modelli per i modelli HTML e aggiungere i file HTML necessari:
```
mkdir templates
```
Aggiungere i file di modello HTML seguenti dal repository GitHub e inserirli nella templates directory:
- index.html - Modello della home page
- beta.html - Modello di pagina beta

Usare un flag di funzionalità

Creare un file denominato appconfig.go con il contenuto seguente. È possibile connettersi al proprio App Configuration store utilizzando Microsoft Entra ID (consigliato) o una stringa di connessione.

ID Microsoft Entra (scelta consigliata)
Stringa di connessione

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
}

Suggerimento

Quando non viene specificato alcun selettore in FeatureFlagOptions, carica tutti i flag di funzionalità senza etichetta nell'archivio di Configurazione app. L’intervallo di aggiornamento predefinito dei flag di funzionalità è di 30 secondi. È possibile personalizzare questo comportamento tramite il parametro RefreshOptions. Ad esempio, il frammento di codice seguente carica solo i flag di funzionalità che iniziano con TestApp: nel nome della chiave e hanno l’etichetta dev. Il codice modifica anche il tempo dell’intervallo di aggiornamento a 5 minuti. Questo tempo dell’intervallo di aggiornamento è separato da quello per i normali valori chiave.

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

Creare un file denominato main.go con il contenuto seguente:

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

Eseguire l'applicazione Web

Impostare la variabile di ambiente per l'autenticazione ed eseguire l'applicazione.
```
go mod tidy
go run .
```
Aprire una finestra del browser e passare a http://localhost:8080. Nel browser verrà visualizzata una pagina simile all'immagine seguente.
Accedi al portale di Azure. Selezionare Tutte le risorse e selezionare l’archivio di Configurazione app creato in precedenza.
Selezionare Gestione funzionalità e individuare il flag di funzionalità Beta. Abilitare il flag selezionando la casella di controllo in Abilitato.
Aggiornare alcune volte il browser. Quando passa l'intervallo di tempo dell'aggiornamento, la pagina viene visualizzata con contenuto aggiornato:
Si noti che la voce di menu Beta viene ora visualizzata nella barra di spostamento. Fare clic su di esso per accedere alla pagina beta:

Pulire le risorse

Se non si vuole continuare a usare le risorse create in questo articolo, eliminare il gruppo di risorse creato qui per evitare addebiti.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Il gruppo di risorse e tutte le risorse in esso contenute vengono eliminati in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse o le risorse sbagliate. Se le risorse per questo articolo sono state create in un gruppo di risorse che contiene altre risorse che si vogliono mantenere, eliminare ogni risorsa singolarmente dal rispettivo riquadro anziché eliminare il gruppo di risorse.

Accedere al portale di Azure e selezionare Gruppi di risorse.
Nella casella Filtra per nome immettere il nome del gruppo di risorse.
Nell'elenco dei risultati selezionare il nome del gruppo di risorse per visualizzare una panoramica.
Selezionare Elimina gruppo di risorse.
Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Immettere il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Passaggi successivi

In questa guida introduttiva è stato creato un flag di funzionalità in Configurazione app di Azure e usato in un'applicazione Web Go Gin. La libreria Feature Management Go offre funzionalità di feature flag che si integrano facilmente con Azure App Configuration. Per altre funzionalità, si prega di consultare il documento seguente.

Informazioni di riferimento su Go Feature Management

Anche se un flag di funzionalità consente di attivare o disattivare funzionalità nell'app, può essere necessario personalizzare un flag di funzionalità in base alla logica della propria app. I filtri delle funzionalità consentono di abilitare un flag di funzionalità in modo condizionale. Per altre informazioni, continuare con l'esercitazione seguente.

Abilitare le funzionalità condizionali con filtri di funzionalità

Configurazione app di Azure offre filtri di funzionalità predefiniti che consentono di attivare un flag di funzionalità solo durante un periodo specifico o per un particolare gruppo di destinatari dell'app. Per altre informazioni, continuare con l'esercitazione seguente.

Abilitare le funzionalità in base a una pianificazione

Distribuire le funzionalità al pubblico di destinazione

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-08-26