Condividi tramite

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

In questo avvio rapido si creerà un flag di funzionalità in Configurazione app di Azure e lo si userà per controllare dinamicamente la disponibilità delle funzionalità in un'app console Go.

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 console Go con funzionalità di monitoraggio in tempo reale.

Prerequisiti

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à.

Screenshot della creazione di un flag di funzionalità.

Usare un flag di funzionalità

  1. Creare una nuova directory per il progetto Go e spostarsi in questa directory:

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

  2. Inizializzare un nuovo modulo Go:

    go mod init go-feature-flag-quickstart

  3. Installare i pacchetti Go necessari per Configurazione app di Azure e la gestione delle funzionalità:

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

  4. Creare un file denominato appconfig.go con il contenuto seguente. È possibile connettersi all'archivio di Configurazione app usando Microsoft Entra ID (scelta consigliata) o una 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
}

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

  5. Creare il file main.goprincipale dell'applicazione :

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

Eseguire l'applicazione

  1. Eseguire l'applicazione:

    go mod tidy
go run .

  2. L'applicazione avvia il monitoraggio del flag di funzionalità Beta e ne visualizza lo stato corrente ogni 5 secondi:

    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

  3. Accedi al portale di Azure. Selezionare Tutte le risorse e selezionare l’archivio di Configurazione app creato in precedenza.

  4. Selezionare Gestione funzionalità e individuare il flag di funzionalità Beta. Abilitare il flag selezionando la casella di controllo in Abilitato.

  5. Tornare all'applicazione console. Dopo alcuni secondi, si noterà che lo stato del flag di funzionalità cambia:

    [14:30:30] Beta is enabled: false
[14:30:35] Beta is enabled: true
[14:30:40] Beta is enabled: true

  6. È possibile attivare e disattivare il flag di funzionalità nel portale di Azure per visualizzare gli aggiornamenti in tempo reale nell'applicazione console senza riavviarlo.

  7. Premere CTRL+C per arrestare l'applicazione.

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.

  1. Accedere al portale di Azure e selezionare Gruppi di risorse.
  2. Nella casella Filtra per nome immettere il nome del gruppo di risorse.
  3. Nell'elenco dei risultati selezionare il nome del gruppo di risorse per visualizzare una panoramica.
  4. Selezionare Elimina gruppo di risorse.
  5. 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 questo avvio rapido è stato creato un flag di funzionalità in Configurazione app di Azure ed è stato usato in un'applicazione console Go. La Feature Management Go library offre ricche capacità di flag di funzionalità che si integrano perfettamente con Azure App Configuration. Per altre funzionalità, continuare con 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

  • Last updated on