Teilen über

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

In dieser Schnellstartanleitung erstellen Sie ein Feature-Flag in der Azure App-Konfiguration und verwenden es, um die Verfügbarkeit einer neuen Webseite in einer Go Gin Web App dynamisch zu steuern, ohne sie neu zu starten oder erneut bereitzustellen.

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 Gin-Webanwendung mit Echtzeitaktualisierungen und bedingtem Seitenrendering 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.

Erstellen einer Go-Webanwendung

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

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

  2. Initialisieren eines neuen Go-Moduls:

    go mod init gin-feature-flag-quickstart

  3. Installieren Sie die erforderlichen Go-Pakete für Azure App-Konfiguration, Gin-Webframework und Featureverwaltung:

    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

  4. Erstellen Sie ein Vorlagenverzeichnis für Ihre HTML-Vorlagen, und fügen Sie die erforderlichen HTML-Dateien hinzu:

    mkdir templates

    Fügen Sie die folgenden HTML-Vorlagendateien aus dem GitHub-Repository hinzu, und platzieren Sie sie im templates Verzeichnis:

Verwenden eines Featureflags

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

  2. Erstellen Sie eine Datei mit dem Namen main.go und dem folgenden Inhalt:

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

Ausführen der Webanwendung

  1. Legen Sie die Umgebungsvariable für die Authentifizierung fest, und führen Sie die Anwendung aus.

    go mod tidy
go run .

  2. Öffnen Sie ein Browserfenster, und wechseln Sie zu http://localhost:8080. In Ihrem Browser sollte eine Seite angezeigt werden, die in etwa wie die folgende Abbildung aussieht:

    Screenshot der Gin Web App vor dem Aktivieren der Featurekennzeichnung.

  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. Aktualisieren Sie den Browser mehrmals. Wenn das Zeitfenster des Aktualisierungsintervalls verstrichen ist, wird die Seite mit aktualisierten Inhalten angezeigt.

    Screenshot der Gin Web App nach dem Aktivieren der Featurekennzeichnung.

  6. Beachten Sie, dass das Betamenüelement jetzt in der Navigationsleiste angezeigt wird. Klicken Sie darauf, um auf die Betaseite zuzugreifen:

    Screenshot der Betaseite von Gin Web App.

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 ein Feature-Flag in der Azure App-Konfiguration erstellt und in einer Go Gin-Webanwendung verwendet. Die Go-Bibliothek für die Featureverwaltung bietet Featurekennzeichnungsfunktionen, die nahtlos in die Azure App-Konfiguration integriert werden. Weitere Informationen zu 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