Teilen über

Schnellstart: Hinzufügen von Featurekennzeichnungen zu einer Go-Konsolen-App

In dieser Schnellstartanleitung erstellen Sie ein Feature-Flag in der Azure-App-Konfiguration und verwenden es, um die Verfügbarkeit von Features in einer Go-Konsolen-App dynamisch zu steuern.

Die Unterstützung für die Featureverwaltung stellt eine Erweiterung des Features für die dynamische Konfiguration in App Configuration dar. In diesem Beispiel wird veranschaulicht, wie Featurekennzeichnungen in eine Go-Konsolenanwendung mit Echtzeitüberwachungsfunktionen integriert werden.

Voraussetzungen

Erstellen eines Featureflags

Fügen Sie dem App-Konfigurationsspeicher eine Feature-Flag namens Beta hinzu und lassen Sie Bezeichnung und Beschreibung mit ihren Standardwerten. Weitere Informationen zum Hinzufügen von Featurekennzeichnungen zu einem Store mithilfe des Azure-Portals oder der CLI finden Sie unter "Erstellen eines Featureflags".

Screenshot des Erstellens einer Featurekennzeichnung.

Verwenden eines Featureflags

  1. Erstellen Sie ein neues Verzeichnis für Ihr Go-Projekt, und navigieren Sie dorthin:

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

  2. Initialisieren eines neuen Go-Moduls:

    go mod init go-feature-flag-quickstart

  3. Installieren Sie die erforderlichen Go-Pakete für azure App-Konfiguration und Featureverwaltung:

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

  4. Erstellen Sie eine Datei namens appconfig.go mit folgendem Inhalt. Sie können eine Verbindung mit Ihrem App Configuration-Speicher entweder mithilfe von Microsoft Entra ID (empfohlen) oder mit einer Verbindungszeichenfolge herstellen.

    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
}

    Tipp

    Wenn kein Selektor angegeben FeatureFlagOptionsist, werden alle Featurekennzeichnungen ohne Bezeichnung im App-Konfigurationsspeicher geladen. Das standardmäßige Aktualisierungsintervall von Featureflags beträgt 30 Sekunden. Sie können dieses Verhalten über den RefreshOptions-Parameter anpassen. Der folgende Codeausschnitt lädt beispielsweise nur Featureflags, deren Schlüsselname mit TestApp: beginnt und die die Bezeichnung dev haben. Außerdem ändert der Code auch die Intervallzeit der Aktualisierung in 5 Minuten. Beachten Sie, dass diese Intervallzeit für Aktualisierungen von der für reguläre Schlüsselwerte unabhängig ist.

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

  5. Erstellen Sie die Hauptanwendungsdatei 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
        }
    }
}

Ausführen der Anwendung

  1. Führen Sie die Anwendung aus.

    go mod tidy
go run .

  2. Die Anwendung nimmt die Überwachung des Beta-Feature-Flags auf und zeigt alle 5 Sekunden den aktuellen Status an.

    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. Melden Sie sich beim Azure-Portal an. Wählen Sie "Alle Ressourcen" und dann den Zuvor erstellten App-Konfigurationsspeicher aus.

  4. Wählen Sie den Feature-Manager aus, und suchen Sie das Feature-Flag "Beta ". Aktivieren Sie die Kennzeichnung, indem Sie das Kontrollkästchen unter "Aktiviert" aktivieren.

  5. Kehren Sie zur Konsolenanwendung zurück. Nach ein paar Sekunden sollten Sie die Änderung des Feature-Flags-Status sehen.

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

  6. Sie können die Featurekennzeichnung im Azure-Portal aktivieren und deaktivieren, um Echtzeitupdates in Ihrer Konsolenanwendung anzuzeigen, ohne es neu zu starten.

  7. Drücken Sie STRG+C , um die Anwendung zu beenden.

Bereinigen von Ressourcen

Wenn Sie die in diesem Artikel erstellten Ressourcen nicht mehr verwenden möchten, löschen Sie die erstellte Ressourcengruppe, um Kosten zu vermeiden.

Von Bedeutung

Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Die Ressourcengruppe und alle darin enthaltenen Ressourcen werden unwiderruflich gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Falls Sie die Ressourcen für diesen Artikel in einer Ressourcengruppe erstellt haben, die andere beizubehaltende Ressourcen enthält, löschen Sie die Ressourcen einzeln über den entsprechenden Bereich, statt die Ressourcengruppe zu löschen.

  1. Melden Sie sich beim Azure-Portal an, und klicken Sie auf Ressourcengruppen.
  2. Geben Sie im Feld Nach Name filtern den Namen Ihrer Ressourcengruppe ein.
  3. Wählen Sie in der Ergebnisliste den Ressourcengruppennamen aus, um eine Übersicht anzuzeigen.
  4. Wählen Sie die Option Ressourcengruppe löschen.
  5. Sie werden aufgefordert, das Löschen der Ressourcengruppe zu bestätigen. Geben Sie zur Bestätigung den Namen Ihrer Ressourcengruppe ein, und klicken Sie auf Löschen.

Daraufhin werden die Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie eine Featurekennzeichnung in der Azure-App-Konfiguration erstellt und in einer Go-Konsolenanwendung verwendet. Die Feature Management Go-Bibliothek bietet umfassende Feature-Flag-Fähigkeiten, die nahtlos in Azure App Configuration integriert sind. Weitere Features finden Sie im folgenden Dokument.

Referenz zur Go-Featureverwaltung

Mit einem Featureflag können Sie zwar Funktionen in Ihrer App aktivieren oder deaktivieren, Sie können ein Featureflag aber auch basierend auf der Logik Ihrer App anpassen. Mit Featurefiltern können Sie ein Featureflag bedingt aktivieren. Weitere Informationen erhalten Sie im folgenden Tutorial.

Aktivieren bedingter Features mit Featurefiltern

Azure App Configuration bietet integrierte Featurefilter, mit denen Sie ein Featureflag nur während eines bestimmten Zeitraums oder für eine bestimmte Zielgruppe Ihrer App aktivieren können. Weitere Informationen erhalten Sie im folgenden Tutorial.

Aktivieren von Features nach einem Zeitplan

Bereitstellen von Features für Zielgruppen

  • Last updated on