Tutorial: Verwenden von Variantenfunktionsflags in einer Go-Webanwendung

In diesem Tutorial verwenden Sie Variantenfeatureflags zum Verwalten der Benutzeroberflächen für verschiedene Benutzersegmente in der Beispielanwendung Zitat des Tages. Sie verwenden das in Verwenden von Variantenfeatureflags erstellte Variantenfeatureflag. Erstellen Sie vor dem Fortfahren unbedingt das Variantenfeatureflag mit dem Namen Greeting (Begrüßung) im App Configuration-Speicher.

Voraussetzungen

• Ein Azure-Konto mit einem aktiven Abonnement. Erstellen Sie ein kostenloses Konto.
• Ein App-Konfigurationsspeicher, wie in der Anleitung zum Erstellen eines Speichers gezeigt.
• Wechseln Sie zu 1.21 oder höher. Informationen zum Installieren von Go finden Sie auf der Seite "Go-Downloads".
• Azure App Configuration Go-Anbieter v1.1.0 oder höher.
• Featureverwaltung Go-Bibliothek v1.1.0 oder höher.
• Befolgen Sie das Tutorial Verwenden von Variantenfeatureflags, und erstellen Sie das Variantenfeatureflag namens Greeting (Begrüßung).

Einrichten einer Go-Webanwendung

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

   mkdir quote-of-the-day
   cd quote-of-the-day
   

2. Initialisieren eines neuen Go-Moduls:

   go mod init quote-of-the-day
   

3. Installieren Sie die erforderlichen Go-Pakete:

   go get github.com/gin-gonic/gin
   go get github.com/gin-contrib/sessions
   go get github.com/gin-contrib/sessions/cookie
   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:

   • index.html - Die Homepagevorlage
   • login.html - Die Anmeldeseitenvorlage

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

   Microsoft Entra ID (empfohlen)

   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,
       }
   
       // Set up options to enable feature flags
       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
   }
   

   Verbindungszeichenfolge

   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,
       }
   
       // Set up options to enable feature flags
       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
   }
   

Verwenden der von Variantenfeatureflags

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

   package main
   
   import (
       "context"
       "fmt"
       "log"
       "net/http"
       "strings"
   
       "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
       "github.com/gin-contrib/sessions"
       "github.com/gin-contrib/sessions/cookie"
       "github.com/gin-gonic/gin"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
   )
   
   type Quote struct {
       Message string `json:"message"`
       Author  string `json:"author"`
   }
   
   type WebApp struct {
       featureManager *featuremanagement.FeatureManager
       appConfig      *azureappconfiguration.AzureAppConfiguration
       quotes         []Quote
   }
   
   func main() {
       // Load Azure App Configuration
       appConfig, err := loadAzureAppConfiguration(context.Background())
       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)
       }
   
       // Initialize quotes
       quotes := []Quote{
           {
               Message: "You cannot change what you are, only what you do.",
               Author:  "Philip Pullman",
           },
       }
   
       // Create web app
       app := &WebApp{
           featureManager: featureManager,
           appConfig:      appConfig,
           quotes:         quotes,
       }
   
       // Setup Gin with default middleware (Logger and Recovery)
       r := gin.Default()
   
       // Start server
       if err := r.Run(":8080"); err != nil {
           log.Fatalf("Failed to start server: %v", err)
       }
   
       fmt.Println("Starting Quote of the Day server on http://localhost:8080")
       fmt.Println("Open http://localhost:8080 in your browser")
       fmt.Println()
   }
   

2. Aktivieren Sie die Aktualisierung von Konfigurations- und Featurekennzeichnungen aus der Azure-App-Konfiguration mit der Middleware.

   // Existing code
   // ... ...
   
   func (app *WebApp) refreshMiddleware() gin.HandlerFunc {
       return func(c *gin.Context) {
           go func() {
               if err := app.appConfig.Refresh(context.Background()); err != nil {
                   log.Printf("Error refreshing configuration: %v", err)
               }
           }()
           c.Next()
       }
   }
   // The rest of existing code
   //... ...
   

3. Richten Sie die Routen mit folgendem Inhalt ein:

   // Existing code
   // ... ...
   
   func (app *WebApp) setupRoutes(r *gin.Engine) {
       // Setup sessions
       store := cookie.NewStore([]byte("secret-key-change-in-production"))
       store.Options(sessions.Options{
           MaxAge:   3600, // 1 hour
           HttpOnly: true,
           Secure:   false, // Set to true in production with HTTPS
       })
       r.Use(sessions.Sessions("session", store))
   
       r.Use(app.refreshMiddleware())
   
       // Load HTML templates
       r.LoadHTMLGlob("templates/*.html")
       // Routes
       r.GET("/", app.homeHandler)
       r.GET("/login", app.loginPageHandler)
       r.POST("/login", app.loginHandler)
       r.GET("/logout", app.logoutHandler)
   }
   
   // Home page handler
   func (app *WebApp) homeHandler(c *gin.Context) {
       session := sessions.Default(c)
       username := session.Get("username")
       quote := app.quotes[0]
   
       var greetingMessage string
       var targetingContext featuremanagement.TargetingContext
       if username != nil {
           // Create targeting context for the user
           targetingContext = createTargetingContext(username.(string))
   
           // Get the Greeting variant for the current user
           if variant, err := app.featureManager.GetVariant("Greeting", targetingContext); err != nil {
               log.Printf("Error getting Greeting variant: %v", err)
           } else if variant != nil && variant.ConfigurationValue != nil {
               // Extract the greeting message from the variant configuration
               if configValue, ok := variant.ConfigurationValue.(string); ok {
                   greetingMessage = configValue
               }
           }
       }
   
       c.HTML(http.StatusOK, "index.html", gin.H{
           "title":           "Quote of the Day",
           "user":            username,
           "greetingMessage": greetingMessage,
           "quote":           quote,
       })
   }
   
   func (app *WebApp) loginPageHandler(c *gin.Context) {
       c.HTML(http.StatusOK, "login.html", gin.H{
           "title": "Login - Quote of the Day",
       })
   }
   
   func (app *WebApp) loginHandler(c *gin.Context) {
       email := strings.TrimSpace(c.PostForm("email"))
   
       // Basic validation
       if email == "" {
           c.HTML(http.StatusOK, "login.html", gin.H{
               "title": "Login - Quote of the Day",
               "error": "Email cannot be empty",
           })
           return
       }
   
       if !strings.Contains(email, "@") {
           c.HTML(http.StatusOK, "login.html", gin.H{
               "title": "Login - Quote of the Day",
               "error": "Please enter a valid email address",
           })
           return
       }
   
       // Store email in session
       session := sessions.Default(c)
       session.Set("username", email)
       if err := session.Save(); err != nil {
           log.Printf("Error saving session: %v", err)
       }
   
       c.Redirect(http.StatusFound, "/")
   }
   
   func (app *WebApp) logoutHandler(c *gin.Context) {
       session := sessions.Default(c)
       session.Clear()
       if err := session.Save(); err != nil {
           log.Printf("Error saving session: %v", err)
       }
       c.Redirect(http.StatusFound, "/")
   }
   
   // Helper function to create TargetingContext
   func createTargetingContext(userID string) featuremanagement.TargetingContext {
       targetingContext := featuremanagement.TargetingContext{
           UserID: userID,
           Groups: []string{},
       }
   
       if strings.Contains(userID, "@") {
           parts := strings.Split(userID, "@")
           if len(parts) == 2 {
               domain := parts[1]
               targetingContext.Groups = append(targetingContext.Groups, domain) // Add domain as group
           }
       }
   
       return targetingContext
   }
   // The rest of existing code
   //... ...
   

4. Aktualisieren Sie das main.go mit dem folgenden Inhalt:

   // Existing code
   // ... ...
    r := gin.Default()
   
    // Setup routes
    app.setupRoutes(r)
   
    // Start server
    if err := r.Run(":8080"); err != nil {
       log.Fatalf("Failed to start server: %v", err)
   }
   // The rest of existing code
   // ... ...
   

Erstellen und Ausführen der App

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

   go mod tidy
   go run .
   

2. Navigieren Sie in Ihrem Browser zu http://localhost:8080. Wählen Sie rechts oben Anmelden aus, um sich als usera@contoso.com anzumelden.

   

3. Nach der Anmeldung wird eine lange Begrüßungsnachricht für usera@contoso.com angezeigt.

   

4. Wählen Sie Abmelden aus, und melden Sie sich als userb@contoso.com an, um die einfache Begrüßungsnachricht anzuzeigen.

   

   Hinweis

   Es ist wichtig, dass in diesem Tutorial genau diese Namen verwendet werden. Solange das Feature wie erwartet konfiguriert wurde, sollten die beiden Benutzer unterschiedliche Varianten sehen.

Nächste Schritte

Weitere Informationen zur Featureverwaltung in Go finden Sie in den folgenden Dokumenten:

Referenz zur Go-Featureverwaltung

Bereitstellen von Features für Zielgruppen

Aktivieren bedingter Features mit Featurefiltern